Хабрахабр

Встраиваем Lua интерпретатор в проект для микроконтроллера (stm32)

Эту часть программы удобно отлаживать на компьютере, после чего встраивать в состав проекта для микроконтроллера, ожидая, что эта часть будет выполняться в точности так, как было задумано без какой-либо отладки (идеальный случай). В достаточно крупных приложениях немалую часть проекта составляет бизнес-логика.

Данный подход предоставляет требуемый уровень абстракции над железом, однако чреват надобностью в постоянной повторной компиляции проекта с последующим программированием энергонезависимой памяти микроконтроллера бинарным файлом прошивки большого объема. Так как большинство программ для микроконтроллеров пишется на С/C++, то для этих целей обычно используют абстрактные классы, предоставляющие интерфейсы к низкоуровневым сущностям (в случае, если проект пишется только с использованием C, то зачастую используются структуры указателей на функции).

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

В качестве скриптового языка я выбрал Lua.

Почему Lua?

Существуют несколько скриптовых языков, которые можно встроить в проект для микроконтроллера. Несколько простых BASIC-подобных, PyMite, Pawn… У каждого есть свои плюсы и минусы, обсуждение которых не входит перечень обсуждаемых вопросов данной статьи.

Меня эта статья сильно вдохновила и я, для более детального изучения вопрос, прочел официальное руководство-книгу от автора языка Роберту Иерузалимски "Программирование на языке Lua" (имеется в официальном русском переводе). Кратко о том, чем хорош конкретно lua — можно прочесть в статье «Lua за 60 минут».

В моем случае, у меня уже имеется готовая программная низкоуровневая прослойка для взаимодействия как с периферией микроконтроллера, так и для прочей требуемой периферии, расположенной на плате устройства. Отдельно хочу отметить проект eLua. Поэтому данный проект мною не рассматривался (поскольку он признан предоставить те самые прослойки для связи ядра Lua с периферией микроконтроллера).

О проекте, в который будет встраиваться Lua

По традиции, в качество поля для экспериментов будет использоваться мой проект-песочница (ссылка на коммит с уже интегрированной lua со всеми необходимыми доработками, описанными ниже).

Проект базируется на микроконтроллере stm32f405rgt6 c 1 МБ энергонезависимой и 192 КБ оперативной памяти (на данный момент используются старшие 2 блока с суммарным объемом 128 КБ).

Вся память под задачи, семафоры и прочие объекты FreeRTOS выделена статически на этапе компоновки (находятся в .bss области оперативной памяти). В проекте присутствует операционная система реального времени FreeRTOS для поддержания инфраструктуры работы с аппаратной периферией. Однако FreeRTOS куча все равно выделяется для поддержки переопределённых на работу с нею функций malloc, free, calloc (требуемых для таких функций, как printf). Все FreeRTOS сущности (семафоры, очереди, стеки задач и прочие) являются частями глобальных объектов в private областях их классов. Имеется поднятый API для работы с MicroSD (FatFS) картами, а так же отладочный UART (115200, 8N1).

О логике использования Lua в составе проекта

Для цели отладки бизнес-логики предполагается, что команды будут приходить по UART-у, паковаться (отдельным объектом) в законченные строки (завершающиеся символом "\n" + 0-терминатор) и отправляться в lua-машину. В случае неудачного выполнения, вывод по средствам printf (так как в проекте он был ранее задействован). Когда логика будет отлажена, можно будет реализовать загрузку конечного файла бизнес-логики из файла с MicroSD карты (не входит в материал этой статьи). Так же для цели отладки Lua машина будет исполняться внутри отдельного потока FreeRTOS (в будущем на каждый отлаженный скрипт бизнес-логики будет выделен отдельный поток, в котором он будет выполняться со своим окружением).

Включение субмодуля lua в состав проекта

В качестве источника библиотеки lua будет использоваться официальное зеркало проекта на github (поскольку мой проект так же размещен там. Вы можете использовать исходники напрямую с официального сайта). Так как в проекте имеется налаженная система сборки субмодулей в составе проекта по индивидуальным для каждого субмодуля CMakeLists-ам, то я создал отдельный субмодуль, в который включил fork данного и CMakeLists для сохранения единой стилистики сборки.

CMakeLists производит сборку исходников репозитория lua как статическую библиотеку со следующими флагами компиляции субмодуля (берутся из файла конфигурации субмодулей в основном проекте):

SET(C_COMPILER_FLAGS "-std=gnu99;-fshort-enums;-fno-exceptions;-Wno-type-limits;-ffunction-sections;-fdata-sections;")
SET(MODULE_LUA_COMP_FLAGS "-O0;-g3;$"

И флагами конкретизации используемого процессора (задаются в корневом CMakeLists-е):

SET(HARDWARE_FLAGS -mthumb; -mcpu=cortex-m4; -mfloat-abi=hard; -mfpu=fpv4-sp-d16;)

Важно отметить необходимость в корневом CMakeLists-е указать определение, разрешающее не использовать double значения (поскольку микроконтроллер не имеет аппаратной поддержки double. Только float):

add_definitions(-DLUA_32BITS)

Ну и остается только сообщить компоновщику о необходимости собрать данную библиотеку и включить итог в компоновку конечного проекта:

Участок CMakeLists-а для компоновки проекта с библиотекой lua

add_subdirectory(${CMAKE_SOURCE_DIR}/bsp/submodules/module_lua)
...
target_link_libraries(${PROJECT_NAME}.elf PUBLIC # -Wl,--start-group нужно для решения вопроса с циклическими # зависимостями между библиотеками во время компоновки. # Конкретно Lua в этом не нуждается, но не все библиотеки так # хорошо написаны. "-Wl,--start-group" ...другие_библиотеки... MODULE_LUA ...другие_библиотеки... "-Wl,--end-group")

Определение функций для работы с памятью

Так как сама Lua не занимается работой с памятью, то эта обязанность переходит на пользователя. Однако при использовании идущей в комплекте библиотеки lauxlib и функции luaL_newstate из нее, происходит привязка функции l_alloc в качестве системы работы с памятью. Она определена следующим образом:

static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { (void)ud; (void)osize; /* not used */ if (nsize == 0) { free(ptr); return NULL; } else return realloc(ptr, nsize);
}

Как было сказано в начале статьи, в проекте уже имеются переопределенные функции malloc и free, однако нет функции realloc. Нам требуется это исправить.

В связи с этим, придется на основе malloc и free сделать свою реализацию. В стандартном механизме работы с кучей FreeRTOS, в файле heap_4.c, используемом в проекте, отсутствует функция для изменения размера ранее выделанного блока памяти.

Хоть и менее эффективную. Поскольку в будущем возможно изменение схемы распределения памяти (использование другого файла heap_x.c), то было решено не использовать внутренности текущей схемы (heap_4.c), а сделать более высокоуровневую надстройку.

Причем в случае, если в старом блоке было больше данных, чем в новом, то новый заполняется старыми до предела, а оставшиеся данные отбрасываются. Важно учесть, что метод realloc не только удаляет старый блок (если таковой существовал) и создает новый, но еще и перемещает данные из старого блока в новый.

На проблему удастся выйти после изучения остаточного образа регистров в обработчике hard fault, из которого удастся узнать, что падение произошло после попытки расширить таблицу в недрах кода интерпретатора и его библиотек. Если не учесть этого факта, то ваша машина сможет выполнить трижды вот такой скрипт из строки "a = 3\n", после чего упадет в hard fault. Если же вызывать скрипт по типу "print 'test'", то поведение будет меняться в зависимости от того, как соберется файл прошивки (иначе говоря, поведение не определено).

FreeRTOS heap_4.c (как и другие файлы, предоставляющие методы работы с кучей) не предоставляет API для этого. Для того, чтобы скопировать из старого блока данные в новый нам потребуется узнать размер старого блока. За основу я взял функцию vPortFree и урезал ее функциональность до следующего вида: Поэтому придется дописать свой.

Код функции vPortGetSizeBlock

int vPortGetSizeBlock (void *pv) { uint8_t *puc = (uint8_t *)pv; BlockLink_t *pxLink; if (pv != NULL) { puc -= xHeapStructSize; pxLink = (BlockLink_t *)puc; configASSERT((pxLink->xBlockSize & xBlockAllocatedBit) != 0); configASSERT(pxLink->pxNextFreeBlock == NULL); return pxLink->xBlockSize & ~xBlockAllocatedBit; } return 0;
}

Теперь дело за малым, написать realloc на основе malloc, free, и vPortGetSizeBlock:

Код реализации realloc на основе malloc, free, и vPortGetSizeBlock

void *realloc (void *ptr, size_t new_size) { if (ptr == nullptr) { return malloc(new_size); } void* p = malloc(new_size); if (p == nullptr) { return p; } size_t old_size = vPortGetSizeBlock(ptr); size_t cpy_len = (new_size < old_size)?new_size:old_size; memcpy(p, ptr, cpy_len); free(ptr); return p;
}

Добавляем поддержку работы с stdout

Как становится известно из официального описания, сам lua интерпретатор не умеет работать с вводом-выводом. Для этих целей подключается одна из стандартных библиотек. Для вывода она использует поток stdout. За подключение к потоку отвечает функция luaopen_io из стандартной библиотеки. Для поддержки работы с stdout (в отличие от printf), потребуется переопределить функцию fwrite. Я переопределил ее на основе функций, описанных в предыдущей статье.

Функция fwrite

size_t fwrite(const void *buf, size_t size, size_t count, FILE *stream) { stream = stream; size_t len = size * count; const char *s = reinterpret_cast<const char*>(buf); for (size_t i = 0; i < len; i++) { if (_write_char((s[i])) != 0) { return -1; } } return len;
}

Без ее определения, функция print в lua будет отрабатывать успешно, но вывода результата не будет. При том на стеке Lua машины не будет никаких ошибок (поскольку формально функция выполнилась успешно).

Так как эту функцию нельзя переопределить, то придется назвать ее чуть иначе. Помимо этой функции нам понадобится функция fflush (для функционирования интерактивного режима, о чем будет далее). Функция является урезанной версией функции fwrite и предназначена для отправки того, что сейчас находится в буфере с последующей его очисткой (без дополнительного перевода каретки).

Функция mc_fflush

int mc_fflush () { uint32_t len = buf_p; buf_p = 0; if (uart_1.tx(tx_buf, len, 100) != mc_interfaces::res::ok) { errno = EIO; return -1; } return 0;
}

Получение строк из последовательного порта

Для получения строк для lua-машины я решил написать простенький класс uart-терминала, который:

  • принимает данные по последовательному порту побайтно (в прерывании);
  • добавляет полученный байт в очередь, откуда его принимает поток;
  • в потоке байт, если это не перевод строки, отправляется обратно в таком виде, в каком он пришел;
  • если пришел перевод строки ('\r'), то отправляются 2 байта перевода каретки терминала ("\n\r");
  • после отправки ответа вызывается обработчик пришедшего байта (объект компоновки строки);
  • контролирует нажатие клавиши удаления символа (во избежание удаления с окна терминала служебных символов);

Ссылки на исходники:
Дополнительно замечу, что чтобы данный объект работал исправно, требуется назначить приоритет прерывания UART в допустимом диапазоне для работы с функциями FreeRTOS из прерывания. В противном случае можно получить интересные сложно отлаживаемые ошибки. В текущем примере в файле FreeRTOSConfig.h установлены следующие параметры для прерываний.

Настройки в FreeRTOSConfig.h

#define configPRIO_BITS 4
#define configKERNEL_INTERRUPT_PRIORITY 0XF0
// Можно использовать FreeRTOS API в прерываниях
// с уровнем 0x8 - 0xF.
#define configMAX_SYSCALL_INTERRUPT_PRIORITY 0x80

В самом проекте объект класса nvic устанавливает приоритет прерывания 0x9, что входит в допустимый диапазон (класс nvic описан здесь и здесь).

Формирование строки для Lua-машины

Принятые из объекта uart_terminal байты передаются в экземпляр простенького класса serial_cli, который предоставляет минимальный интерфейс редактирования строки и передачу ее непосредственно в поток, в котором выполняется lua-машина (через вызов callback функции). По принятии символа '\r' вызывается функция обратного вызова (callback). Эта функция должна скопировать себе строку и «отпустить» управление (поскольку во время вызова прием новых байт блокируется. Это не является проблемой при правильно расставленных приоритетах потоков и достаточной низкой скорости UART).

Ссылки на исходники:

  • файлы описания serial_cli тут и тут;
  • создание объекта класса в составе проекта здесь.

Важно заметить, что данный класс считает строку длиннее 255 символов невалидной и сбрасывает ее. Это сделано намеренно, поскольку интерпретатор lua позволяет вводить конструкции построчно, ожидая окончания блока.

Передача строки в Lua интерпретатор и ее исполнение

Сам по себе Lua интерпретатор не умеет принимать код блока построчно, после чего исполнять целый блок самостоятельно. Однако, если установить Lua на компьютер и запустить интерпретатор в интерактивном режиме, то мы можем видеть, что исполнение идет построчно с соответствующими обозначениями по мере ввода, что блок пока не является завершённым. Так как интерактивный режим это то, что предоставляется в стандартной поставке, то мы можем посмотреть его код. Он находится в файле lua.c. Нас интересует функция doREPL и все, что она использует. Дабы не придумывать велосипед, я для получения функций интерактивного режима в проекте сделал порт этого кода в отдельный класс, который назвал по имени исходной функции lua_repl, который использует printf для вывода информации в консоль и имеет публичный метод add_lua_string для добавления строки, полученной из объекта класса serial_cli, описанного выше.

Ссылки:

Класс выполнен по паттерну синглтон Майерса, поскольку нет необходимости в пределах одного устройства давать несколько интерактивных режимов. Объект класса lua_repl получает данные от объекта класса serial_cli здесь.

В методе start объекта класса player::base (объявленного здесь. Так как в проекте уже существует единая система инициализации и обслуживания глобальных объектов, то указатель на объект класса lua_repl передается объекту глобального класса player::base здесь. Где 1 — наименьший приоритет, а 4 — наибольший). Тут же и происходит его вызов из main), производится вызов метода init объекта класса lua_repl с приоритетом задачи FreeRTOS 3 (в проекте можно назначать приоритет задачи от 1, до 4. По окончании успешной инициализации глобальный класс запускает планировщик FreeRTOS и интерактивный режим начинает свою работу.

Проблемы, появляющиеся при портировании

Ниже будет приведен перечень проблем, с которыми я столкнулся во время порта Lua машины.

Исполняются 2-3 однострочных скрипта присвоения значения переменной, затем все падает в hard fault

Проблема была в методе realloc. Требуется не просто повторно выделить блок, но еще и скопировать содержимое старого (о чем писал выше).

При попытке напечатать значение интерпретатор падает в hard fault

Тут было уже сложнее обнаружить проблему, но по итогу удалось выяснить, что для печати используется snprintf. Так как lua хранит значения в double (или float в нашем случае), то требуется printf (и его производные) с поддержкой плавающей точки (о тонкостях настройки printf я писал здесь).

Требования к энергонезависимой (flash) памяти

Вот некоторые замеры, которые я сделал, позволяющие судить о том, сколько нужно выделить энергонезависимой (flash) памяти для интеграции Lua-машины в проект. Компиляция производилась с использованием gcc-arm-none-eabi-8-2018-q4-major. Использовалась версия Lua 5.4. Ниже в замерах под фразой «без Lua» подразумевается невключение в проект непосредственно интерпретатора и методов взаимодействие с ним и его библиотеками, а так же объекта класса lua_repl. Все низкоуровневые сущности (включая переопределения для работы функций printf и fwrite) остаются в составе проекта. Размер FreeRTOS кучи составляет 1024*25 байт. Остальное занимают глобальные сущьности проекта.

Сводная таблица результатов выглядит следующим образом (все размеры в байтах):

Параметры сборки

Без Lua

Только ядро

Lua c библиотекой base

Lua c библиотеками base, coroutine, table, string

luaL_openlibs

-O0 -g3

103028

220924

236124

262652

308372

-O1 -g3

74940

144732

156916

174452

213068

-Os -g0

71172

134228

145756

161428

198400

Требования к оперативной памяти

Так как потребление оперативной памяти зависит всецело от задачи, то я приведу сводную таблицу потребленной памяти сразу после включения машины с разным набором библиотек (она выводится командой print(collectgarbage(«count»)*1024)).

Состав

Использовано RAM

Lua c библиотекой base

4809

Lua c библиотеками base, coroutine, table, string

6407

luaL_openlibs

12769

В случае использования всех библиотек размер требуемой оперативной памяти значительно растет в сравнении с предыдущими комплектами. Однако его использование в немалой части приложений не обязательно.

Помимо этого так же выделяется 4 кб на стек задачи, в которой происходит выполнение Lua-машины.

Дальнейшее использование

Для полноценного использования машины в проекте далее потребуется описать все требуемые кодом бизнес-логики интерфейсы к аппаратной части или служебным объектам проекта. Однако это уже тема отдельной статьи.

Итоги

В данной статье было рассказано, как можно подключить к проекту для микроконтроллера Lua-машину, а так же запустить полноценный интерактивный интерпретатор, позволяющий производить эксперименты с бизнес-логикой прямо из командной строки терминала. Кроме того были рассмотрены требования к аппаратной начинке микроконтроллера при разных комплектациях Lua машины.

Теги
Показать больше

Похожие статьи

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»
Закрыть