6

Два месяца Rust Embedded⁠⁠

Два месяца Rust Embedded

Два месяца назад я решил снова погрузиться в вопросы 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.


Embassy

Так, а что, собственно, async/await? В Rust это синтаксический сахар к poll-based futures. Для того чтобы они работали, нужна абстракция экзекьютора — кооперативного планировщика. Для реализации планировщика на микроконтроллере существует три пути.

  1. Работать на голом железе, т. е. основном потоке инструкций, реализуется максимально просто, но лишает возможности создать несколько параллельно работающих экзекьюторов (вопрос «зачем» — это тема для отдельной статьи).

  2. Работать на базе планировщика потоков. Это не обязательно полноценная RTOS, но она должна предоставлять возможности преемптивной многозадачности.

  3. Работа на базе прерываний, когда продвижение фьюч происходит внутри обработчиков прерываний. Это, кстати, основной метод реализации жесткого реального времени в системах кооперативной асинхронности, поскольку прерывания гарантируют, что фьюча будет включена в работу в момент возникновения аппаратного события (таймер/внешний сигнал).

На основе этих идей и возник фреймворк 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а.

Инженериум DIY

657 постов5.6K подписчика

Правила сообщества

Давайте уважать друг друга - любые аморальные посты выпиливаются, даже если они затрагивают основную тематику сообщества.

В сообществе будут попадаться посты для новичков, поэтому не стоит влетать в пост с минусомётом, направленным на задающих вопросы по теме поста.

Темы

Политика

Теги

Популярные авторы

Сообщества

18+

Теги

Популярные авторы

Сообщества

Игры

Теги

Популярные авторы

Сообщества

Юмор

Теги

Популярные авторы

Сообщества

Отношения

Теги

Популярные авторы

Сообщества

Здоровье

Теги

Популярные авторы

Сообщества

Путешествия

Теги

Популярные авторы

Сообщества

Спорт

Теги

Популярные авторы

Сообщества

Хобби

Теги

Популярные авторы

Сообщества

Сервис

Теги

Популярные авторы

Сообщества

Природа

Теги

Популярные авторы

Сообщества

Бизнес

Теги

Популярные авторы

Сообщества

Транспорт

Теги

Популярные авторы

Сообщества

Общение

Теги

Популярные авторы

Сообщества

Юриспруденция

Теги

Популярные авторы

Сообщества

Наука

Теги

Популярные авторы

Сообщества

IT

Теги

Популярные авторы

Сообщества

Животные

Теги

Популярные авторы

Сообщества

Кино и сериалы

Теги

Популярные авторы

Сообщества

Экономика

Теги

Популярные авторы

Сообщества

Кулинария

Теги

Популярные авторы

Сообщества

История

Теги

Популярные авторы

Сообщества

Недвижимость и ремонт

Теги

Популярные авторы

Сообщества