Увлажнитель воздуха из стаканчика для кофе
Кому интересно, ссылка на такой набор для сборки увлажнителя
p.s
Сохраняйте в закладки, чтобы не потерять
Реклама: ООО "АЕР Услуги" ИНН: 7703380158
Кому интересно, ссылка на такой набор для сборки увлажнителя
p.s
Сохраняйте в закладки, чтобы не потерять
Реклама: ООО "АЕР Услуги" ИНН: 7703380158
Из этой тяжелой и прочной детали можно сделать надежное, долговечное и очень полезное приспособление для гаража, дачи или домашней мастерской. Пошаговый процесс изготовления самоделки своими руками из доступных материалов! Повторить сможет каждый, у кого есть минимальный набор инструментов.
Два месяца назад я решил снова погрузиться в вопросы embedded разработки и посмотреть, как там обстоят дела с Rust, об этом небольшой очерк ниже.
Когда я последний раз интересовался связкой Rust+Embedded, это был год где-то 2019, ландшафт там был, мягко говоря, пустынный. Кто-то где-то пилил кросскомпиляторы под микроконтроллеры. У кого-то даже получалось запускать rust-код на STM32 в режиме hard bare metal. Это когда у вас нет даже LL-драйверов и, чтобы помигать светодиодом, приходится в unsafe прямо брать указатель на область памяти и писать биты регистров. В общем, лабораторные поделки, не более того.
С 2019 года, как оказалось, произошли тектонические сдвиги в этой области. Rust теперь предоставляет полноценную экосистему практически под все популярные микроконтроллеры, а в перспективе ему прочат место полноправного младшего брата C++ в embedded-разработке. Чем же так оказался хорош Rust для embedded, что за столь малый срок он проделал путь от лаборатории до промышленного языка программирования?
В основе управления памятью в Rust лежит модель владения и заимствования. Принцип очень специфический и ломающий голову любому программисту, который берется за изучение этого языка. Если кратко, в Rust нет сборщика мусора и нет прямого управления памятью. Вместо этого язык на этапе компиляции гарантирует, что в один момент времени конкретным участком памяти может владеть только один участок кода. И если эта память не переходит во владение другому участку кода, она освобождается. Это правило порождает за собой следующее требование, проверяемое также на этапе компиляции: к одному участку памяти одновременно никогда не получит доступ более одного потока. Это очень общее определение, за конкретикой сходите лучше вот сюда.
А теперь давайте посмотрим на статистику. 70% падений прошивок в рантайме связаны с ошибками управления памятью и разделяемым состоянием. Взяли освобожденный указатель — получили мусор вместо данных. Забыли сделать free в цикле — утечка. Прошляпили освобождение мьютекса — дедлок. Эти ошибки крайне банальны, но они настолько въедливы и повсеместны на С, что подавляющее большинство аварийных ситуаций в проде с микроконтроллерами исходят именно от них. Да, в нем ведут активную борьбу с ними, но это полумеры в сравнении с Rust. Его компилятор просто не даст скомпилировать программу, которая имеет возможности для их проявления. Т. е. на этапе компиляции исключается огромный класс ошибок, приводящих к падению кода в проде.
Ситуация настолько значительная, что в некоторых странах, на уровне органов по стандартизации, всерьез поговаривают о том, чтобы сделать разработку на Rust обязательным требованием для систем с высокой степенью отвественности (аэрокосмическая отрасль, автомобилестроение и т. п.).
Rust изначально разрабатывался как async-awareness. Т. е. кго компилтор, в отличие от сишных собратьев, заранее осведомлен, что программа будет выполняться в многопоточной среде. А сам язык предоставляет синтаксический сахар для модели async/await, которая, я думаю, хорошо знакома многим разработчикам. Он же (компилятор) дает гарантии невозможности скомпилировать многопоточный код, который может привести к ошибкам разделяемого состояния. Для embedded это сразу ставит два акцента. Первый на то что краш прошивок по багам с разделяемым состоянием на Rust просто невозможен. Второй на то, что мы из коробки работаем в полноценной async среде.
Очень сильная сторона rust как окружения — это стандартизация. В отличие от С++, где каждый разводит свой огород, разработчики Rust решили на корню испепелить это зло. Одна система сборки, один центральный репозиторий, единые правила оформления кода и структур проектов для всех. Если ты их не соблюдаешь, никто с твоими библиотеками работать не будет. За отдельные значимые области в мире Rust отвечают консорциумы, комитеты по стандартизации, которые представляют официальное мнение о том, как должно быть в рамках их зоны отвественности.
Одним из таких комитетов по стандартизации является Embedded Rust. Это группа разработчиков, которые стояли у основ его экосистемы, и, насколько я понимаю, это как раз те люди, которые проводили с ним ранние эксперименты на мк. Пораскинув мозгами, они сделали вполне очевидный вывод: сейчас архитектурно практически все прошивки для микроконтроллеров работают по одному и тому же принципу — LL -> HAL -> RTOS, DRIVERS. Реализация HAL у каждого своя, но они похожи между собой как близнецы. Что мы знаем, например, о UART? Последовательный интерфейс, у которого есть скорость обмена, линии аппаратного контроля потока, пины RX, TX, DMA. I2C? Адрес устройства, скорость, размер слова. GPIO? Направление, подтяжка, логический уровень. Т. е. вся периферия любого современного микроконтроллера в сути одинкова, разница состоит только на уровне LL, в регистрах управления и техниках работы с ними.
Так вот, эти люди на понимании этих моментов пришли к тому, чтобы сделать embedded_hal, контракт для HAL, который бы позволял создать переносимость вышестоящего кода. Т. е. непосредственно слои HAL остаются специфичными для каждого МК, но они обязуются реализовать его интерфейсы. Это открывает возможность создавать полностью платформенно независимый код, который будет свободно переноситься между различными архитектурами и моделями МК.
Эта идея и ее реализация привели к появлянеию большого количества платформенно-независимых драйверов, опирающихся на это соглашение, которые достаточно просто добавить в проект, они будут бесшовно работать на STM32, ESP32, WCH и других мк.
Та же самая история постигла и RTOS. Их много, но принципы у всех одни и те же: треды, очереди, мьютексы, семафоры (aka CMSIS). За ними потянулись другие абстракции. Сокет Беркли по семантике работает везде одинаково. Потоки ввода-вывода — та же история. Описывать все соглашения тут просто не имеет смысла. Я хочу донести общую идею о том что из Rust практически сделаи кросс-платформенную embedded инфраструктуру.
За два месяца, пока я работаю над новым проектом на ESP32, я коснулся такой периферии, как GNSS, INA, SX12**, контроллеры питания, SimCom-овский модем. Подо всё под это уже имелись готовые драйвера на embedded_hal, которые я просто добавил в зависимости, прокинул в них нужные определения, и они заработали так, будто бы были специально написаны для EPS32.
Так, а что, собственно, async/await? В Rust это синтаксический сахар к poll-based futures. Для того чтобы они работали, нужна абстракция экзекьютора — кооперативного планировщика. Для реализации планировщика на микроконтроллере существует три пути.
Работать на голом железе, т. е. основном потоке инструкций, реализуется максимально просто, но лишает возможности создать несколько параллельно работающих экзекьюторов (вопрос «зачем» — это тема для отдельной статьи).
Работать на базе планировщика потоков. Это не обязательно полноценная RTOS, но она должна предоставлять возможности преемптивной многозадачности.
Работа на базе прерываний, когда продвижение фьюч происходит внутри обработчиков прерываний. Это, кстати, основной метод реализации жесткого реального времени в системах кооперативной асинхронности, поскольку прерывания гарантируют, что фьюча будет включена в работу в момент возникновения аппаратного события (таймер/внешний сигнал).
На основе этих идей и возник фреймворк Embassy. Если очень кратко, то embassy — это tokio для микроконтроллеров. Если последний заточен на работу в std-окружении больших преемптивных операционных систем, то embassy точится именно под сценарии трех вышеописанных пунктов. Так же, как и у tokio, вокруг него развивается значительная инфраструктура. Он определяет примитивы времени вроде Timer/Duration, Instant, которые опираются на монотонное время ядра вместо эпохального. Базу async-await вроде select, mutex, channel. И множество различных интерфейсов вроде примитивов io. Всё это делается с очень большим вниманием и пониманием особенностей аппаратуры микроконтроллеров. Embassy — это замена RTOS в инфраструктуре Embedded Rust. И с моей точки крайне успешная, потому что позволяет за счет async/await-семантики снижать лапшичность кода в десятки раз в сравнении, например, с теми же задачами во FreeRTOS.
У этого подхода есть, конечно же, и один серьезный минус — раздувание кода. Поскольку каждый async fn разворачивается компилятором в солидный блок обвязочного кода, это приводит к его ощутимому увеличению. Насколько ощутимому? Настолько, насколько вы допускаете антипаттерн async contamination. Самая нижняя в стеке вызовов async функция требует того, чтобы все вышестоящие функции также были async, если этот процесс сознательно не разрушается правильной архитектурой приложения (например, применением принципа async only for IO). При соблюдении этого правила, раздувание размеров прошивки не выходит за границы 10–15% от такого же функционала, написанного на С++. Но, как я уже упомянул выше, это дает колоссальный прирост по степени организации и читаемости кода.
Как бы я не любил Rust и не желал бы его вездесущего распространения, надо смотреть на факты. А они такие, С++ морально устарел и все попытки сделать ему лицо современного языка программирования выглядт откровенно слабо. Но на нем написно 99% всего фундаментального кода в мире embedded разрабокти. Крупный бизнес заточен десятилитеями практики на эксплуатацию этого кода и им проще (дешевле) продолжать есть кактус, чем ориентироваться на новую технологию, которая окупит свое внедрение неизвестно когда. Другое дело новые проекты, стартапы, малый бизнес. Исходя из того что я сейчас прощупал про Embedded Rust, начинать новый чистовой проект на С++, это ну как бы помягче выразиться, крипово. С++ проигрывает расту во всем кроме совместимости со старой кодовой базой. Мой прогноз состоит в том, что доля раста будет постепенно расти, возможно какие-то крупные (или будущие крпуные) технологические компании возьмут его в качестве альма-матер своей разработки. Но это скорее всего не пошатнет позиции С++, просто он станет более фундаментальным, этаким легаси на котором держится вся более современная разработка и которому периодически приходится обращаться.
Я же буду далее активно продолжать исследовать его применение на микроконтроллерах, EPS32, STM32 уже опробованы, сейчас на очереди WCH, а за ним NRF. Написал уже приличное количество прикладного кода и буду продвигаться в этой теме. Разибраюсь архитектуре портирования на другие платформы и уже с интересом посмотриваю на отчественный Байкал, как на потенциальную цель создания нового HALа.
При передаче пакета больше 32 байт (в моём случае 36 - 4 адресных диода ws2812b), если 1-ый бит 33 байта high "1", то после передачи всего пакета любых остальных данных шина остаётся в "1". Баг проявляется в независимости от использования DMA в режиме LSB first.
Лечится установкой SPI_CR1_CPHA — Clock phase в "1" (вывод не используется)
Revision ID: REV_ID 0x1001, В errdata об этом нет.
На st меня забанили, да и сам бы забил, но вдруг это не баг конкретно этого чипа и кому то ещё поможет. Конфигурил через CMSIS, но как же без картинок :)
ps в теории надо бы проверить 16 битный режим и MSB, но скорее всего это подвержено тоже, т.к. с них и начинал. Код перенёс с stm32f030 где всё работало, но с одним диодом (9 байт).



кубические настройки
Предыстория.
Прочитал где-то мысль. Что рано или поздно любой программист хочет физически ощутить свою работу. Вот и меня накрыла такая проблема с главным вопросом, куда приложить "кипучую энергию". Как раз был период, когда в новой квартире постоянно отключали свет и после мне надо было бегать по всем комнатам выставлять правильно время на часах. а через 10мин. он мог опять "моргнуть". Прям, бесило это.
Поэтому решил делать единую систему синхронизации времени, а попутно показывать еще и температуру за бортом, чтобы каждый раз в окошко не смотреть, во второй версии графики и прогноз погоды с интернета. Нафига? А потому что появился TFT экран с сенсором не пропадать же такому функционалу. Понятия "Умный дом" тогда еще, по-моему, не существовало.
За более чем, 15-летний срок было сделано около 5 реализаций данного проекта. Часы - ардуино нано, вывод делал с использованием светодиодной матрицы, сегментных индикаторов, на LCD/TFT дисплеях. Сервер - ардуино мега + шильды(SD-card, давление, RTC, ethernet и еще какие-то), но главное условие — это синхронизация времени и отсутствие проводов. Для радиосвязи использовал модули 433 и NRF24L01, для них писал свои протоколы обмена данными. Хотя изначально сам сервер подключался по Ethernet.







Сам пугаюсь, когда смотрю на это
Каждую версию проекта разрабатывал и программировал от начала и до конца сам, языки: web, с++, php — все это приходилось изучать «с нуля». Было интересно, хоть на отладку/доработку уходили месяцы, но важен был процесс и конечно результат. Главная проблема это то, что радиоэлектронщик из меня никакой. Хоть я и пытался сам паять, разрабатывать схемы и печатать платы, но особой радости это не доставляло и поэтому старался, чтоб все подключалось с минимальной электронной оснасткой.
В основном все проекты работали по 2-3 года, далее разработка переходила на "следующую ступень", т.к. к тому времени появлялось что-то новое и мне интересно было работать с этим.
Проект v4.0.
Этот вариант проекта появился из-за потребности перевести все на WiFi, а т.ж. то, что у меня появилось несколько старых планшетов и электронных книг, которые было жалко выкидывать. Использование же WiFi и планшетов, намного упростили компонентную базу. Появилась возможность разделить модули температура/время. И в итоге система получилась следующая:
Модули(климат) получают температуру/влажность, каждый по своей локации и передают данные на сервер. Сервер по запросу выдает данные на другие Модули (они же планшеты, они же часы) и так же дублирует данные в базу на сайте для удаленного мониторинга. Для всего этого был развернут отдельный сервер(ПК с пассивным охлаждением), который хранил данные в базе MySQL.
Система достаточно простая, но были некоторые недочеты, с пропаданием WiFi на старых планшетах, проблемой со стартом после отключения питания, хоть все это было решаемо, но т.к. делал для себя, то нетрудно было подойти и принудительно исправить.
Со временем друзья/знакомые начали просить сделать им такое же, ведь старья у всех много. Но из-за отсутствия универсальности проекта приходилось отказывать. В итоге достали, все-таки решил сделать универсальную автономную платформу и без привязки к ПК. С достаточно простым подключением и обслуживанием, не требующего больших знаний в электронике.
Проект v5.0.
Железо:
Сервер - ESP2866 Lolin v3 - памяти маловато, но я сумел в нее уместиться, был вариант сделать на более современной платформе ESP32-c3, но там какие-то ограничения с WiFi, например в режиме точки доступа, чип грелся как чайник. В итоге намучился с ней и отказался. К нему подключен дисплей, для визуального контроля состояния оборудования.
Модуль(климат) - ESP8266 D1-MINI использовал их для совместимости с сервером + DHT11. Опционально к каждому модулю можно подключить BME280 для улицы. Он имеет и влажность, и давление и температуру. Есть возможность подключить несколько «Улиц» если, например, окна выходят на разные стороны, я отказался до конца это реализовывать, хотя в коде эта опция есть.
Для улицы использовал раньше DHT22, но как-то у него все печально с влажностью, через какое-то время она "отваливается", попробую как будет BME в работе.
Модуль(часы) - старые планшеты/эл.читалки с дохлыми аккумуляторами работают постоянно от сети.
Программная часть:
Функционал достаточно обширный, тут только основное.
Сервер - хранит данные в своей файловой системе(тем самым избавляемся от развертывания базы). Данные хранятся за последние 24часа, мне так захотелось, чтоб видеть графики. Получив данные от локаций сервер отправляет их на сайт. Еще добавил прогноз погоды, запрос 1 раз/час, прогноз за 48 часов. У Яндекса есть такая опция, 30 запросов в день бесплатно т.ч. хватает.
Модуль(климат) -Данные от локаций 1 раз в 15мин передаются на сервер.
Модуль(часы) - 1 раз в 15мин опрашивает сервер для получения температуры по нужной локации, а т.ж. получает уличную температуру. Все это выбирается индивидуально в интерфейсе.
Настройка:
Первое включение, сервер создает точку доступа. Подключившись, надо выбрать свою сеть WiFi и ввести название Места (где будет развернуто). По такому же принципу каждый модуль привязывается к WiFi и обязательно указывается локация, где модуль будет установлен. т.к. в каждой сети IP выдаются рандомно, то сделал общение оборудования не по IP, а по имени http://smart-home.local/.



Итог:
В проекте 3 направления: с++ - это модули/сервер, web – доступ через браузер для управления, и просмотр данных на сайте, android – программная часть для планшетов(часы).
Мякотка данного проекта, которая как бы преуменьшает всю уникальность в том, что все это было написано в общей сложности за 2 недели с помощью ИИ. Даже не так – это просто написал ИИ. т.к. я раньше проходил через все этапы разработки, то в данном случае не чувствую себя каким-то "дилетантом" ну или кем-то еще, мне просто было не интересно и лень заново все это писать, а вот сделать проект как «наставник» который, указывает что и как нужно, это новый для меня опыт. Главное, что я знал, что в итоге должно получиться и какие м.б. "косяки" при эксплуатации, и когда он реально тупил, или мог за раз все сломать, приходилось по сути указывать как правильно делать.
Еще один момент по Android. До этого я писал приложухи на Xamarin, но какая-то одна VisualStudio не работает со всеми SDK сразу, надо ставить несколько и переключаться между средами в зависимости от старости устройства. Пообщавшись, пришли к мнению использовать AndroidStudio. Один проект для любого SDK. Тут даже вникать не стал, подсунул старый проект он все переделал.


Старый и новый варианты.
Так что 99% код написан ИИ. Угроза это для разработчиков - не знаю, но для таких легких проектов он безусловно помощник. В общем, если это возможно, хотел бы выложить исходники проекта, т.к. это все равно не я делал, не жалко. Но не пойму как правильно. Надеюсь так можно, https://yadi.sk/d/Rrz_IcFMOJ-qmQ
P.S. Писатель из меня никакой, т.ч. мучить вас не стал, описал только часть функционала, если будет интересно отвечу подробно.
Замечания, по существу, приветствуются, ну и если посоветуете новые идеи проекта, буду признателен.
Блок вентиляторов стал компактнее и вешается на шею. Подключение к контроллеру теперь разъемом. Вентиляторы 40mm.
Вид с установленными картриджами.
Принцип действия как у предыдущей версии. Решетки состоят из заполнения и были добавлены в слайсере.
Заправляется дистиллированной водой. Внутри создается туман ультразвуковым распылителем. Вентилятор выдувает через решетку. Если распылитель включить на несколько секунд раньше вентилятора то в начальный момент будет более концентрированный туман с брызгами.
Ультразвуковой распылитель. Для него в контроллер была добавлена линия 24V.
12V для вентиляторов получаются преобразователем из 24V. Добавлен светильник который выключается в начале видео и включается в конце. Smell-o-Vision и генератор тумана подключаются разъемами.
MultiFunPlayer теперь использует несколько каналов.
Прошивка ардуино. В прошлый раз в виде текста потерялись отступы поэтому сейчас в виде скриншотов.
В разработке генератор горячего воздуха.
Функциональное решение для разработчиков и исследователей в области робототехники. Этот универсальный мобильный робот обладает расширенными функциональными возможностями и станет помощником в лабораторных условиях, учебных заведениях или дома.
Кому интересно, ссылка на такого робота
p.s.
Сохраняйте страницу в закладки, чтобы не потерять.
Реклама: ООО "АЕР Услуги" ИНН: 7703380158
