В первой лабе надо было подключиться к устройству (оно создаёт точку WiFi) и через веб-интерфейса устройства зажечь светодиод

Во второй надо было подключить к устройству кнопку, подключиться опять по WiFi и в веб-интерфейсе увидеть, что при нажатии на кнопку, отображается информация, что она нажата.

В третьей надо было подключить к устройству джойстик, в веб-интерфейсе можно смотреть положение джойстика.

В четвёртой лабе подключали динамик к устройству, заходили в веб-интерфейс и включали оттуда мелодию на динамике))

И в пятой взяли два устройства. Одно запрограммировали как сервер. Другое как клиент. Сервер раздаёт WiFi. Клиент автоматически к нему подключается. На клиенте есть кнопка. Если на неё нажать, то на сервере зажигается лампочка)

❯ Предисловие

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

Почти два года назад в моей голове уже возникала идея сделать «портативку» из полурабочего гаджета. В то время я хотел рассказать читателям о том, что многие старые девайсы можно использовать в качестве одноплатных компьютеров и HMI-панелей благодаря наличию пятачков с шиной UART на плате, с которой можно легко взаимодействовать в Android-приложениях! В качестве реального примера использования я взял планшет с нерабочим тачскрином, подключил через UART геймпад, разработанный на базе RP2040 и написал программу, которая читает UART и инжектит состояние кнопок напрямую в драйвер ввода:

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

Недавно я осматривал свою коллекцию гаджетов и на полочке с смартфонами Samsung обнаружил легендарный Galaxy S4 Mini, который мне когда-то дарил один из читателей. У смартфона отсутствовала задняя крышка, средняя часть корпуса была немного ободрана, однако несмотря на почтенный возраст в 12 лет, смартфон продолжал нормально работать и даже AMOLED-матрица у него ничуть не выгорела!

И тут в моей голове что-то щёлкнуло: я вспомнил что S4 Mini — смартфон с довольно неплохим железом для эмуляторов и очень крутым даже по современным меркам AMOLED дисплеем. На моей памяти, в мире не выходило ни одного серийного игрового телефона в монолитном корпусе с OLED-матрицей, а тут ещё рядом лежал оригинальный N-Gage, который я недавно купил в утиле и восстановил после воды. Я взвесил все за и против, прикинул схему и конструктив будущего устройства и принялся мастерить...

Перед тем как начать работу, нам необходимо определится с тем что нам нужно будет сделать для реализации такого гаджета на практике:

• В первую очередь, нам необходимо продумать как геймпад будет общаться с нашим устройством. За исключением моего хака с UART'ом, у нас есть два варианта: первый — микроконтроллер выполняет роль USB-HID устройства (прикидываясь клавиатурой) и подключается к OTG-хосту гаджета. Среди плюсов этого подхода можно выделить низкую задержку, однако минусов гораздо больше. Например, далеко не все старые устройства поддерживают OTG и могут быть проблемы с реализацией одновременной работы USB-хоста и зарядки (зависит от реализации OTG в каждом конкретном устройстве). А второй вариант — это Bluetooth-HID, который работает почти с любыми Android устройствами, однако потребляет чуть больше энергии и может иметь небольшой инпут-лаг.
  
  После расследования выяснилось, что у S4 Mini OTG нет, а значит остается лишь один вариант — Bluetooth. Среди дешевых микроконтроллеров с BT выделяется лишь ESP32, который стоит буквально три пачки доширака. Его мы с вами и выберем.

• Далее нам необходимо придумать внешний вид устройства. Изначально мне хотелось, чтобы гаджет по форм-фактору и эргономике напоминал оригинальный N-Gage. Но поскольку мне не хотелось делать слишком длинную «колбасу» и бюджета по свободному пространству в корпусе откровенно не хватало, пришлось пойти на некоторые ухищрения — например, расположить блок кнопок вертикально.

• Теперь самое сложное — смоделировать более-менее адекватный корпус и подогнать детали так, чтобы их хоть как-то можно было состыковать и закрепить. Я в 3D-печати новичок, а в вопросах проектирования корпусов — вообще неотесанный селюк, поэтому мне оставалось лишь смоделировать в блендере выпуклый меш, импортировать в TinkerCad и затем CSG'шками вырезать в нём дырки отверстия.

• И самое легкое — написать прошивку для микроконтроллера и спаять всё вместе, дабы наши кнопочки не просто прикольно щелкали, но и на практике работали в системе!

Звучит как приключение на 5 минут. Но вот как на практике? Давайте посмотрим!

❯ Моделируем корпус

В первую очередь я сел моделировать корпус устройства и прикидывать его размеры. В TinkerCad'е CSG'шками сделать корпус по референсу проблематично (по крайней мере для меня), поэтому я решил смоделировать основу в блендере. Я взял рендеры N-Gage с фронтальной части, установил камеру в ортографическую проекцию и принялся повторять контур корпуса оригинального телефона. После этого я создал грани на одной половинке корпуса, продублировал все вершины и отзеркалил их с другой стороны. Таким образом, корпус получился одинаковым (кривым) с обеих сторон.

Далее я убрал лишние рёбра посередине и вытянул корпус по оси Z с помощью инструмента Extrude. Теперь это напоминает поделку семикласника на уроке обращения с рубанком:

Дальше я использовал инструмент Inset faces, дабы создать новые грани на плоскости и вытянуть из них фронтальную часть корпуса. Таким образом, мы получаем ровные и мягкие стенки, которые затем можно смягчить ещё больше с помощью модификатора Bevel:

Однако сейчас геометрия нашего корпуса полая, внутри неё ничего нет. Чтобы добавить внутренние стенки, мы воспользуемся модификатором Boolean (CSG) в блендере: дублируем геометрию нашего корпуса, немного уменьшаем её по оси X и Y (чем меньше дубль, тем толще будут стенки), и затем сдвигаем немного вниз, а затем на основном объекте корпуса добавляем модификатор Boolean, устанавливаем режим Difference, ставим дубль в качестве второго объекта и жмём Apply. Теперь у нашего корпуса внутри отнюдь не пустота!

Далее экспортируем модель в STL, импортируем её в TinkerCad и берём линейку в зубы. Пора замерять габариты нашего устройства и размер дисплея.

Поскольку S4 Mini уж очень скругленный, я аппроксимировал его размеры до прямоугольника (ни слово про мыло!). Над этим прямоугольником я расположил прямоугольник размером с дисплей, который и вырежет нам пространство для этого самого дисплея:

На этом подготовка болванки корпуса закончена, переходим к реализации геймпада.

❯ Геймпад

Изначально я решил распаять все кнопки геймпада на двух макетных платах — первая с «стрелками» будет установлена слева, вторая с кнопками действий — справа. Поскольку место в корпусе сильно ограничено, текстолит я решил распилить: для этого я сделал насечки канцелярским ножом и затем руками отломал ненужные части.

В качестве кнопок я решил использовать обычные DIP-микрики, поскольку в моем городе не было ни плоских SMD-кнопок, ни тем более мягких мембранных. А ещё они прикольно щёлкают. Я, как пользователь механической клавиатуры, гарантирую это!

Для реализации обработки кнопок есть несколько подходов:

• «В лоб»: самый простой и самый подходящий для геймпадов. На один входной GPIO микроконтроллера вешается подтягивающий резистор и кнопка, которая коммутирует массу. Главный плюс такого подхода — возможность зажимать сколько угодно кнопок одновременно, а если ножек на микроконтроллере не хватает, то всегда можно использовать сдвиговый регистр!

• На резисторах: требует наличия ADC в микроконтроллере. Принцип работы заключается в том, что на выходе каждой кнопки установлен резистор определенного номинала. В прошивке микроконтроллера опытным путем задается диапазон значений ADC, который соответствует нажатой кнопке. Такой подход иногда используется в планшетах для обработки кнопок по типу включения, громкости и т.п.

• Матричный: используется в клавиатурах, в том числе и в телефонах. Позволяет реализовать 16-кнопочную клавиатуру всего с 8-ю сигнальными линиями, однако с таким подходом нельзя нажимать сразу несколько кнопок кнопок в одной «линии» одновременно. Этим и страдали некоторые китайские игровые консоли, на которых нельзя было одновременно зажать вверх и влево или A и B!

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

После этого я наконец-то напечатал первую примерочную болванку, в которой всё помещалось идеально! Время от раздумий до первой болванки — ~5-6 часов:

❯ Стыкуем корпус

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

Сначала я решил сделать толкатели кнопок. Для «стрелок» я решил сделать классическую крестовину в духе GBA, а кнопки действий решил сделать цилиндрическими. Здесь в целом ничего сложного: подгоняем размеры толкателей к размерам кнопок, делаем у них небольшую выемку снизу, которая будет «шляпкой» для самих кнопок, а также добавляем «юбку» по бокам как ограничитель, дабы они не выпадали из корпуса:

С крестовиной всё чуточку сложнее: сначала я сделал монолитную в стиле GameBoy, однако из-за того что расстояние между кнопками относительно маленькое, при нажатии на стрелку иногда нажималась и вторая кнопка. Поэтому я решил её разделить на несколько частей, оставив характерный рельеф посередине для лучшей тактильности. Я печатал много разных вариантов: подгонял зазоры для уменьшения люфта и добавлял тактильные выемки, однако остановился на классическом варианте. Далее встал вопрос как закрепить плату с геймпадом с обратной части корпуса. Я долго думал и прикидывал варианты: хотел и саморезы вкручивать, и гайки вплавлять, но потом придумал что самым лучшим и надежным решением будут салазки приклеенные на дихлорэтан, которые при желании можно снять не ломая корпус, но которые будут хорошо выдерживать постоянное усилие со стороны игрока!

Когда зазоры были подогнаны, я принялся моделировать заднюю крышку. Дабы она не выбивалась из общего стиля, я сделал её из фронтальной части корпуса: продублировал, отменил все CSG-операции характерные для основного корпуса и обрезал стенки одним большим кубиком.

Нарезаем модель в слайсере и печатаем! Как по мне, получилось очень даже стильно. Да, кто-то скажет, мол, видно, что это колхоз, не Industrial-grade, но как по мне для самоделки вполне на уровне!

На этом разработка корпуса наконец-то закончена!

❯ Пишем прошивку

Теперь, когда корпус нашего устройства готов и элементы в нём более-менее стыкуются, можно перейти к написанию прошивки. Как я уже говорил ранее, в качестве микроконтроллера я решил выбрать ESP32 благодаря копеечной цене и наличию неплохого BT-стека:

В качестве основы я взял официальный сэмпл BT HID-устройства с гитхаба Espressif. Собрав прошивку и протестировав что всё работает нормально, я принялся адаптировать её под свои задачи. Сначала я написал код для опроса кнопок: устанавливаем GPIO в режим входа с подтяжкой к высокому уровню, затем по запросу итерируемся по массиву с GPIO и заносим состояние кнопок в отдельный массив:

У любых механических кнопок есть особенность, которая называется дребезг. Случается она в момент когда мы отпускаем кнопку, но при этом размыкатель ещё не полностью поднялся в крайнее верхнее положение. Бороться с этим можно по разному, самый простой способ — программный, когда мы обновляем состояние кнопки только когда прошло определенное время (измеряемое в миллисекундах) с момента прошлого апдейта.

Все HID-устройства описываются специальным дескриптором, однако формат пакетов с репортами о состоянии устройства у них очень сильно отличается: мышки передают ускорение по осям X и Y, а также состояние кнопок, клавиатуры передают до 8-нажатых клавиш одновременно (наследие PS/2), а у геймпадов целый ворох стандартов (DirectInput, XInput... чего только нет. Кстати именно поэтому внешние геймпады обычно имеют несколько режимов). Алгоритм отправки репортов очень прост: 60 раз в секунду проверяем состояние кнопок, если какие-то нажаты — заполняем буфер с нажатыми клавишами и затем отправляем репорт хост-устройству.

Вуаля! Всё работает идеально!

❯ Доводим ПО смартфона

Мы уже почти дошли до финала, осталось лишь чуть-чуть доработать прошивку смартфона! Для этого, его сначала необходимо рутировать: ставим CWM через Odin и устанавливаем SuperSU!

Поскольку кнопку включения я не предусмотрел в корпусе, было решено реализовать автостарт устройства от зарядки — прямо как на айфоне! Большинство смартфонов при отображении анимации зарядки на самом деле загружают ядро Linux и запускают специальную программу. Если эту программу подменить на перезагрузку в обычный режим — мы получим автостарт устройства!

На смартфонах Samsung за это отвечает бинарник /system/bin/lpm или же /system/bin/playlpm. Изначально я хотел сделать жёсткую ссылку на программу reboot, которая не работала пока не были запущены какие-то Samsung'овские службы. Затем я узнал что есть возможность напрямую направить ядру запрос о перезагрузке устройства с помощью sysrq.

Далее был написан простенький скрипт:

Который тоже не работал. И я понял что lpm нужно подменять другой самопальной программой. Так была написана и собрана с помощью NDK вот такая мелкая утилита, с которой уже всё заработало:

Далее необходимо было решить вопрос с виртуальными кнопками: поскольку в корпусе консоли виден только дисплей смартфона без кнопки Home, нам нужен был способ как-то управлять системой. Для этого было достаточно лишь пропатчить build.prop и добавить qemu.hw.mainkeys=0. В S4 Mini программные кнопки работают немного кривовато (только в портретной ориентации - т.е в нашем случае в режиме смартфона), но в целом пойдет. Я ещё немного поигрался в build.prop ради фана и добавил упоминания N-Gage :)

❯ Аппаратные доработки

Далее необходимо было решить вопрос с зарядкой. Как я уже говорил выше, было решено использовать Type-C. Я заказал разъём на плате, разобрал смартфон и кинул перемычки с цепи питания и сигнальных линий на разъем.

Теперь нужно решить задачу запитывания микроконтроллера. ESP32 в режиме BLE кушает целые 130мА (что очень много, телефоны нулевых кушали меньше с учетом параллельно работающего GSM-тракта!) в режиме активной передачи данных. Поскольку на самой плате с ESP32 используется LDO AMS1117 с высоким dropout-напряжением в 1.2В, для использования с обычным литий-ионным аккумулятором необходимо было использовать ULDO с дропаутом в ~0.3В...

...но зачем, если контроллер питания смартфона — буквально и есть многоканальный DC-DC преобразователь, который выдаёт сразу несколько различных напряжений:

• 0.8В-1.2В - VCore, это шина питания ядер процессора. Именно на ней работает вся или почти вся внутренняя логика системы на кристалле.

• 1.2V-1.8V VRef - обычно это референсное напряжение для работы процессора с внешней логикой. Впрочем, с таким напряжением может быть и одна из шин питания для каких-то модулей (например камеры), это зависит от платформы.

• 3.3V - Ну, здесь всё очевидно. 3.3В — одно из самых распространенных напряжений в микроэлектронике и может использоваться в широком спектре модулей. Например оно может использоваться для запитки модуля камеры, различных датчиков, контроллера тачскрина, усилителя и т.п. Именно эта шина питания в идеале нам и нужна.

Однако 3v3 уровни могут быть и логическими. Крайне не рекомендую вешать нагрузку аж в целых 130мАч на какую-нибудь цифровую линию, есть неиллюзорный риск спалить процессор или контролер питания. Лучше всего брать эту шину питания с здоровых decoupling-конденсаторов, однако имейте ввиду что шина может быть нагружена другими устройствами и вы со своей нагрузкой в сотню миллиампер можете увести КП в защиту!

В случае с S4 Mini у меня был сервис-мануал с схемой, где я принялся искать нужное напряжение. Изначально у меня была возможность взять 3.3В с питания eMMC, однако по ходу изучения схемы я заметил ещё одну подходящую шину питания — 3P0 (т.е 3В ровно), которая питает Wi-Fi, ИК-порт и тачскрин.

Я решил заглянуть в даташит на микроконтроллер и убедился, что он умеет работать в том числе и при 3В на входе, однако это пороговое напряжение при котором может работать чип. Если питание нестабильное и проседает, то МК либо зависнет, либо упадет в ресет. Однако я был уверен что на выходе DC-DC с КП смартфона точно должно быть всё нормальным. Я быстренько вывел перемычку и запитал МК буквально «в воздухе», проверил что всё работает стабильно, а затем припаял несколько жилок с LVDS-кабеля и закрепил УФ-маской.

Ну что ж, пришло время собрать всё воедино! Не без помощи дихлоэретана салазки были установлены, платы геймпада вставлены, все питания припаяны, а резьба в задней крышке была нарезана.

И вот, наконец-то моё детище собрано! Давайте же посмотрим что я там насобирал!

❯ Тестируем

Одним из основных критериев будущего игрового смартфона была конечно-же возможность сохранить функционал телефона. Иными словами, мне очень хотелось чтобы девайс повторял концепцию N-Gage и действительно в себе совмещал возможность звонить и удобно играть в игры!

В целом, я считаю что у меня это вполне получилось. Помимо функций самой звонилки, Android 4.4 всё ещё вполне может порадовать владельца базовым серфингом сети (большинство сайтов не откроется... ну нам и опеннета хватит!) и мессенджерами - здесь пока ещё работают и Telegram, и ВК в лице в Kate Mobile. Однако есть определенный нюанс... я взял GT-I9190 - т.е односимочную 3G-версию S4 Mini. А как известно, 3G в России уже практически не используется, поэтому вне Wi-Fi придется ограничится EDGE :)

Вчера я сделал анонс статьи на Пикабу и несколько читателей задали резонный вопрос: это же буквально смартфон 2013 года, он же, на первый взгляд, ничего не умеет в современных реалиях. Однако спешу вас заверить что под капотом всё не так уж и плохо! 400'ого Snapdragon'а хватает для большинства мобильных игр тех лет, не говоря уже об эмуляторах. При этом в отличии от старших 600'ых снапов (тогда 800'ый ещё не вышел), он не слишком сильно греется и более лоялен к и без того не самому объёмному аккумулятору!

Однако про опыт использования смартфонов прошлых лет в современных реалиях я уже не раз рассказывал в других своих статьях, поэтому предлагаю перейти к тесту игр. И начнем мы с вами с эмулятора NES.

Когда запускаешь любимый Super Mario Bros на офигенной AMOLED-матрице, то сразу понимаешь что весь проект был затеян точно не зря. После отключения линейного фильтра и растягивания картинки на весь экран, то диву даешься какие тут сочные цвета - не как на ЭЛТ-телевизоре, но тоже очень годно! Эмулятор работает очень шустро!

Давайте же перейдем к чему-то ещё более пестрому и "графонистому" - а именно к Sega Mega Drive с оригинальным Соником! Здесь игра точно также летает, звук не хрипит, а картинка выглядят максимально приятной. Когда-то AMOLED-матрицы Samsung ругали за PenTile и немного не естественную цветовую схему... но в эмуляторах она как-будто какой-то шарм придает.

Далее предлагаю опробовать DOS'овскую классику - Wolfenstein 3D. Помимо "вольфа", я хотел добавить в тесты также и Quake... но порты попались кривые и не запускались. Очевидно что игра, которая шла даже на 286'ом, будет отлично летать на S4 Mini:

Ну и нативные игрушки здесь тоже работают неплохо. В какие-нибудь аркады типа Angry Brids, Fruit Ninja или Asphalt можно поиграть с большим удовольствием!

❯ Заключение

Вот такой незамысловатый и полезный девайс у нас с вами сегодня получился. Вы можете собрать такой и сами, схему, код прошивки и исходные файлы моделей я выкладываю на своём Github. Корпус можно "пощупать" в TinkerCad.

Сама разработка заняла всего 7 дней, большая часть времени ушла на подгонку деталей. Да, эту неделю я определенно точно почти не спал и даже один раз попсиховал. Однако все время разработки мне было дико весело и интересно. Ну, а что ещё пареньку в 23 года то нужно, кроме как писать код, копаться в девайсах и ТАЗах!?

Жду ваше мнение о моей самоделке в комментариях! А если вам интересна тематика ремонта, моддинга и программирования для гаджетов прошлых лет, подписывайтесь на мой Telegram-канал «Клуб фанатов балдежа», куда я публикую бэкстейджи статей, иногда полезные посты ну и немножечко щитпоста! Если вам интересны мои видео той же тематики — предлагаю подписаться на мой YouTube-канал.

Важно

Друзья! Для подготовки статей с разработкой самопальных игрушек под необычные устройства, объявляется розыск телефонов и консолей! В 2000-х годах, китайцы часто делали дешевые телефоны с игровым уклоном — обычно у них было подобие геймпада (джойстика) или хотя бы две кнопки с верхней части устройства, выполняющие функцию A/B, а также предустановлены эмуляторы NES/Sega. Фишка в том, что на таких телефонах можно выполнять нативный код и портировать на них новые эмуляторы, чем я и хочу заняться и написать об этом подробную статью и записать видео! Если у вас есть телефон подобного формата и вы готовы его задонатить или продать, пожалуйста напишите мне в Telegram (@monobogdan) или в комментарии. Также интересуют смартфоны-консоли на Android (на рынке РФ точно была Func Much-01), там будет контент чуточку другого формата :)

А также я ищу старые (2010-2014) подделки на брендовые смартфоны Samsung, Apple и т. п. Они зачастую работают на весьма интересных чипсетах и поддаются хорошему моддингу, парочку статей уже вышло, но у меня ещё есть идеи по их моддингу! Также может у кого-то остались самые первые смартфоны Xiaomi (серии Mi), Meizu (ещё на Exynos) или телефоны Motorola на Linux (например, EM30, RAZR V8, ROKR Z6, ROKR E2, ROKR E5, ZINE ZN5 и т.п, о них я хотел бы подготовить специальную статью и видео т. к. на самом деле они работали на очень мощных для своих лет процессорах, поддавались серьезному моддингу и были способны запустить даже Quake!). Всем большое спасибо за донаты!

Статья подготовлена при поддержке TimeWeb Cloud. Подписывайтесь на меня и @Timeweb.Cloud чтобы не пропускать новые статьи каждую неделю!

Зачастую в процессе разработки собственных устройств или моддинга уже существующих, встаёт задача выполнения стороннего кода: будь то ваши собственные программы с SD-флэшек, или программы, написанные другими пользователями с помощью SDK для вашего устройства. Тема компиляторов и кодогенерации достаточно сложная: чтобы просто загрузить ELF или EXE (PE) программу, вам нужно досконально разбираться в особенностях вашей архитектуры: что такое ABI, релокации, GOT, отличие -fPIE от -fPIC, как писать скрипты для ld и т. п. Недавно я копал SDK для первых версий Symbian и основываясь на решениях из этой ОС понял, каким образом можно сделать крайне «дешевую» загрузку любого нативного кода практически на любом микроконтроллере, совершенно не вникая в особенности кодогенерации под неё! Сегодня мы с вами: узнаем, что происходит в процессе загрузки программы ядром Linux, рассмотрим концепцию, предложенную Symbian Foundation и реализуем её на практике для относительно малоизвестной архитектуры — XTensa (хотя она используется в ESP32, детали её реализации «под капотом» для многих остаются загадкой). Интересно? Тогда добро пожаловать под кат!

❯ Как это работает?

Думаю, для многих моих читателей реализация процесса загрузки exe-программ и dll-библиотек в память процесса оставалась эдаким чёрным ящиком, в детали реализации которого вдаваться не нужно. Отчасти это так и есть: современные ОС разруливают процесс загрузки бинарников в память сами, не требуя от программиста вообще ничего, даже понимания того, куда будет загружена его библиотека или программа.

Давайте для общего понимания вкратце разберемся, как происходит загрузка программ в Windows/Linux:

1. Система создаёт процесс и загружает в память программы секции из ELF/PE. Обычные программы для своей работы используют 3 секции: .text (код), .data (не-инициализированный сегмент памяти для глобальных переменных), .bss (сегмент памяти для инициализированных переменных). Каждому процессу выделяется собственное адресное пространство, называемое виртуальной памятью, которое не позволяет программе испортить память ядра, а также позволяет не зависеть от разметки физической памяти на выполняющей машине. Концепцию виртуальной памяти реализует специальной модуль в процессоре, называемый MMU.

2. Если бы наши программы не использовали никаких зависимостей в виде динамических библиотек, то на этом процесс загрузки можно было бы закончить: каждая программа имеет свой адрес загрузки, относительно которого линкер строит связи между обращениями к коду/данным программы. Фактически, для самых простых программ линкеру остаётся лишь прибавить адрес загрузки программы (например, 0x100) к каждому абсолютному обращению к памяти.
Однако современные программы используют десятки библиотек и для всех предусмотреть собственный адрес загрузки не получится: кто-то где-то всё равно будет пересекаться и вероятно, портить память. Кроме того, современные стандарты безопасности в Linux рекомендуют использовать позиционно-независимый код, дабы использовать преимущества ASLR (Address Space Layout Randomization, или простыми словами возможность загрузить программу в случайное место в памяти, дабы некоторые уязвимости, завязанные на фиксированном адресе загрузки программы перестали работать).

3. Поэтому для решения этой проблемы придуман т. н. динамический линкер, который уже на этапе загрузки программы или библиотеки патчит программу так, чтобы её можно было загрузить в любой участок памяти. Для этого используются данные, полученные от обычного линкера а этапе компиляции программы: помимо .text, .data и .bss, линкер создаёт секции .rel и .rel-plt, которые называются релокациями. Если объяснять совсем условно, то релокации — это просто запись вида «какой абсолютный адрес в коде программы нужно пропатчить» -> «на какое смещение его пропатчить». Самая простая релокация выглядит вот так:

Где по итогу:

.rel-plt же служит для резолвинга вызовов к dll/so: изначально программа ссылается на заранее определенные в процессе компиляции символы, которые уже в процессе загрузки патчатся на физические адреса функций из загруженной библиотеки.

И казалось бы — всё очень просто, пока в дело не вступают GOT (Global Offset Table — глобальная таблица смещений) и особенности реализации конкретного ABI. И ладно бы x86 или ARM, там всё разжевано и понятно, однако на других архитектурах начинаются проблемы и не всегда очевидно что и где за что отвечает.

А ведь чаще всего нужно просто загрузить небольшую программу, которой не нужны комплексные загрузчики: немного кода, немного данных и всё. И тут у нас есть три выхода:

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

2. Зарезервировать определенный сегмент в памяти (пусть с 0xFFF по 0xFFFF) и скомпилировать нашу программу с адресом загрузки 0xFFF с параметром -fno-pic. В таком случае, линкер сгенерирует обращения к памяти по абсолютным адресам — если переменная лежит по адресу 0xFFF, то программа будет обращаться сразу к этому адресу памяти, без необходимости что либо динамически линковать. Именно такой подход использовался во времена ZX Spectrum, Commodore 64 и MS-DOS (однако там роль «виртуальной памяти» выполняла такая особенность 8086, как сегменты). У такого подхода есть и минусы: относительная невозможность загрузки сразу нескольких программ одновременно, зарезервированное пространство линейно отъест небольшой кусок памяти у основной прошивки, нет возможности динамической аллокации секций. Зато такой код теоретически будет работать быстрее, чем PIC.
   
   Проблемы реализации такого способа: иногда нужно лезть в систему сборки основной прошивки и патчить скрипт линкера так, чтобы он не трогал определенный регион памяти. В случае esp32, например, это требует патча в сам SDK и возможного «откола» от мейнлайн дистрибутива.

3. Использовать программу с относительной адресацией, однако без сегментов .bss и .data. Самый простой в реализации способ, который к тому же очень экономичен к памяти, позволяет загружать программу в любое место и пользоваться всеми фишками динамического аллокатора и не требует вмешательств в основную прошивку, кроме примитивного загрузчика программ. Именно его я и предлагаю рассмотреть подробнее.

Недавно мы сидели в чате ELF-сцены (разработка нативных программ под телефоны Siemens, Sony Ericsson, Motorola и LG с помощью хаков) и думали, как же можно реализовать загрузчик сторонних программ на практически неизвестных платформах. Кто-то предлагал взять ELF под основу — однако с его реализацией под некоторые платформы есть трудности, а кто-то предлагал писать «бинлоадер» — самопальный формат бинарников, который получается из, например, тех же эльфов.

В это же время я копал SDK для Symbian и хорошо помнил, что в прикладных приложениях для этой ОС нет поддержки глобальных переменных вообще. Да, сегмент .data и .bss полностью отсутствует — переменные предлагается хранить в структурах. Почему так сделано? Всё дело в том, что каждая программа в Symbian — это dll-библиотека, которую загружает EKA и создаёт экземпляр CApaApplication. И дабы была возможность загрузить dll один раз для всех программ (что справедливо для системных библиотек), ребята полностью выкинули возможность использования любых глобальных переменных. А ведь идея интересная!

Однако в таком подходе есть несколько серьезных ограничений:

• Отсутствие глобальных переменных может стать проблемой при портированиии уже существующего софта, хотя вашим программам ничего не мешает передавать в каждую функцию структуру с глобальным стейтом, который можно при необходимости изменять. Кроме того, нет ограничений на использование C++ (за исключением необходимости ручной реализации new/delete и отсутствием исключений).

• Отсутствие преинициализированных данных. Вот это уже может стать относительно серьёзной проблемой, у которой, тем не менее, есть свои обходные решения. Например если вы храните команды для инициализации дисплея в таблице, или какие-либо калибровочные данные — вы не сможете их объявить, просто используя инициализаторы в C. Тоже самое касается и строковых литерал. Тут есть два варианта: часть таблиц можно вынести на стек (если эти самые таблицы достаточно маленькие), либо подгружать необходимые данные из бинарника с помощью основной прошивки (например, LoadString и т. п.).

Давайте же на практике посмотрим, имеет ли право на жизнь такой подход!

❯ Практическая реализация

Формат нашего бинарника будет до безобразия прост: небольшой заголовок в начале файла и просто сырой дамп сегмента .text, который можно экспортировать из полученного elf даже без необходимости писать скрипт для линкера. При этом нужно учесть, что ESP32 — это микроконтроллер частично Гарвардской архитектуры, т. е. шина данных и кода у него расположены отдельно. Однако у чипа есть полноценный MMU, который позволяет маппить регионы физической памяти в виртуальную память, чем мы и воспользуемся в итоге!

Заголовок нашего бинарника будет выглядеть вот так:

Программа общается с основной прошивкой посредством псевдо-syscall'ов: функции, которая в качестве первого аргумента ожидает номер нужной службы и один 32х-битный указатель для описания структуры с параметрами. Реализация syscall'ов — одна из самых простых и неприхотливых с точки зрения обратной совместимости с будущими прошивками.

Концептуально всё очень просто: GetGlobalStateSize сообщает нашему загрузчику размер структуры для хранения глобального стейта, в то время как Start уже фактически заменяет main() в нашей программе. Необходимости в crt0 нет, поскольку весь необходимый инит выполняет бутлоадер ESP32. Впрочем, при желании вы можете выделить отдельный стек для вашей программы — это повысит надежность, если выполняемая программа удумает испортить стек.

Собираем нашу программу:

-fno-pic отключает генерацию кода, зависимого от GOT, -nostdlib и -nostartfiles убирает из билда crt0 и stdlib, благодаря чему мы получаем только необходимый код. --section-start задает смещение для загрузки секции .text на 0x0 (в идеале это делать необходимо из скрипта для ld).
objcopy скопирует из полученного ELF только необходимую нам секцию .text.

Как же это работает на практике? Давайте дизассемблируем выходной бинарник и посмотрим, что у нас дает на выхлопе cc:

Обратите внимание, что Start вызывает подфункции с помощью инструкции CALLX8, которая в отличии от обычного Immediate-версии CALL8, выполняет переход относительно текущего адреса в PC, благодаря чему переход полностью независим от адреса загрузки программы в памяти. А благодаря тому, что все данные, в том числе и указатель на глобальный стейт передаются через стек, нет необходимости релокейтить сегменты данных.

По итогу всё, что нужно от загрузчика бинарников — это загрузить программу в память для инструкций, выделить память для структуры с стейтом программы и передать управление Start. Всё!
Конкретно в случае ESP32, у нас есть два возможных решения задачи загрузки программы в память:

1. Загрузить программу в IRAM. Такая возможность теоретически есть, однако на практике загрузчик ESP32 устанавливает права только на чтение и выполнение на данный регион памяти. Попытка что-то скопировать туда закончится исключением SIGSEGV. Кроме того, сегмент IRAM относительно небольшой — всего около 200Кб.

2. Самопрограммирование. Для этого, в esp32 есть два механизма — Partition API и SPI Flash API. Я выбрал Partition API для простоты реализации.

Для нашей прошивки необходимо будет переразметить флэш-память. Для этого запускаем idf.py menuconfig, идём в Partition Table -> Custom partition table CSV. Создаём в папке проекта partitions.csv, куда пишем:

# ESP-IDF Partition Table
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x6000,
phy_init, data, phy, 0xf000, 0x1000,
factory, app, factory, 0x10000, 1M,
executable, data, undefined, 0x110000, 0x10000

Для заливки программы можно использовать соответствующее Partition API, либо parttool.py:

Переходим к загрузчику программы:

Прошиваем ESP32:

И смотрим результат:

Всё работает!

❯ Заключение

Как видите, ничего сложного в выполнении сторонних программ при условии соблюдении некоторых ограничений нет. Да, в таком подходе есть как серьезные плюсы, так и минусы, однако он делает своё дело и позволяет реализовать запуск игр на кастомных игровых консолях, или сторонних программ на самодельных компьютерах. Ну и конечно же не стоит забывать про плагины! Авось в вашем решении нужна возможность расширения функционала устройства, однако предоставлять исходный код или даже объектные файлы нет возможности — тогда вам может пригодится и такая методика.

Пожалуй, стоит упомянуть ещё один… очень своеобразный метод, который я иногда встречаю при реализации самодельных компьютеров. Люди пишут… эмуляторы 6502/Z80 :)
И если такой подход ещё +- применим к ESP32, то в AVR просадки производительности будут слишком серьезными. Так зачем, если можно использовать все возможности ядра на максимум?