Мультитул для инженера: волшебная коробочка с I2C/SPI/UART/JTAG за 1.000 рублей
Будучи творческим человеком и техногиком, я обожаю при первой возможности апгрейдить своё оборудование. Время от времени я мониторю маркетплейсы в поисках чего-то новенького и в этот раз я наткнулся на настоящий мультитул для Embedded-разработчика — контроллер I2C/SPI/UART/JTAG в одной коробочке и всё это всего за 1.000 рублей... Конечно я не смог пройти мимо этой штучки и в рамках сегодняшней статьи хочу рассказать что оно из себя представляет и как с ним работать. Жду вас под катом!
❯ Что за устройство?
На самом деле такой формат статей для меня «в новинку», до этого я ни разу не делал обзоров на оборудование. Да и мой инструментарий слишком зауряден, чтобы делать ещё одну статью уровня «почему Quciko T12 лучше любой 900M станции» или «почему Вам не стоит покупать компрессорный люкей в 2025 году». Однако обзоров на сегодняшний гаджет я не нашёл, несмотря на его огромную пользу как для Embedded-разработчиков и инженеров, так и мастеров по ремонту смартфонов, планшетов и ноутбуков.
Во время подготовки статьи о том, как я написал BIOS для игровой консоли от Waveshare, в рекомендациях мне попадались другие товары от этого производителя — в том числе и сегодняшний гаджет. Меня сразу привлекла возможность переключения 3v3->5v логики и обширный набор поддерживаемых шин. В официальной вики были описаны следующие характеристики:
Шины: 1x SPI с двумя чип-селектами (можно подключить до двух устройств на одну шину), 1x I2C, 1x JTAG (полноценный, с ресетом!) и 2x UART с дополнительными линиями CTS/RTS для совместимости с классическими COM-портами.
Используемый контроллер: WCH CH347. Некоторым читателям чип может показаться знакомым по аналогии с классическим CH341A.
Питание: 5В, 3.3В, потребление ~65мА на VBus. Есть самовосстанавливающийся предохранитель на «входе».
Waveshare — достаточно известный бренд, под которым реализуются одноплатные компьютеры, «бутербродная» периферия для них и инструменты.
Я сразу смекнул, что смогу использовать гаджет как для восстановления программно-убитых устройств по типу КПК, так и для отладки своих собственных самоделок, благо набор шин к этому располагает. Устройство приехало ко мне примерно через месяц, в небольшом пакетике и брендовой коробочке, в которую входило само устройство, кабель USB Type-B (ну почему не Type-C?), Dupont-провода в IDC-коннекторе для всех шин, а также небольшой мануал. Нареканий к доставке кроме скорости не возникло.
Сам гаджет представляет из себя компактную металлическую коробочку с «ушками» для удобного крепления на столе или стене. Сверху расположена шпаргалка по распиновке и режимам работы CH347, а также светодиодные индикаторы для UART.
Разбирается гаджет очень просто: достаточно лишь открутить несколько винтов с обеих боковых пластин устройства и перед нами открывается вид на плату. Схемотехника здесь простейшая: самовосстанавливающийся предохранитель, линейный регулятор AMS1117, который питает контроллер и нагрузку на VCC (до ~600мА), сам CH347, а также набор ключей для согласования режимов работы. CH347 — это не просто ASIC, а вполне себе полноценный микроконтроллер, прошивку которого можно обновить, правда SDK для использования CH347 как МК производитель не предоставляет.
После подключения гаджет радостно зажег индикатор PWR, подтвердив свою работоспособность, а значит пришло время протестировать возможные варианты использования!
❯ UART
С UART всё просто и понятно: нам достаточно лишь выбрать желаемый режим работы (M0 — двухканальный UART, остальные режимы — UART + I2C/SPI или UART + JTAG) с помощью тумблера и подключить/припаять Dupont'ы к соответствующим пинам на плате. UART здесь достаточно быстрый: при двухканальном режиме работы, на UART0 можно добиться до 9Мб/с (мегабод), а на UART1 — до 7.5Мб/с.
Провода в разъёмы установлены не бездумно — у них есть цветовая маркировка и логика помимо «красный — VCC, чёрный — GND».
В качестве теста я решил снять лог загрузки со своего проекта самодельной игровой консоли. Для работы с UART я привык использовать Putty: сначала я припаял RX/TX и массу, затем запустил Putty и выбрал COM-порт, соответствующий первому каналу, установил бодрейт в 115200 и включил консоль:
Всё работает! В целом, гаджет можно использовать и для прошивки более сложных устройств: например многие смартфоны и кнопочные телефоны всё ещё имеют альтернативный режим прошивки через UART, а ретро-телефоны Samsung и LG так вообще не имеют альтернатив — если нет специального JIG, то остаётся лишь вызванивать RX/TX с разъёма и подпаиваться напрямую к UART процессора!
❯ SPI/I2C
С SPI и I2C уже всё чуточку интереснее. Дело в том, что как вы уже могли понять — чип использует свой собственный проприетарный протокол для организации моста между программой на ПК и шиной данных. Для работы с этим протоколом производитель предоставляет уже готовую библиотеку для Windows начиная с 2000, так что возможно у чипа есть перспективы для оживления легаси пром. оборудования. Для Linux же есть альтернативные драйвера, которые пробрасывают CH347 как обычные spidev и i2c-dev устройства.
Для проверки коммуникации можно использовать специальную тестовую программу из SDK, которая позволяет отправлять произвольные данные и даже прошивать флэшки 25 'ой и EEPROM'ки 24'ой серии.
Давайте же попробуем написать что-нибудь полезное! Например, подключим к гаджету 1.8-дюймовый дисплей и что-нибудь на него выведем.
С разводкой дисплея проблем не возникает: SDO к MOSI, SCK к CLK, VCC к VCC и BL (питание подсветки), однако для управления DBI-дисплеями необходимы ещё две дополнительные линии: D/C (линия, определяющая как интерпретировать байт на входе), а также RESET для аппаратного сброса контроллера. И с этим проблем тоже не возникает: у контроллера есть как минимум четыре свободных GPIO, два из которых мы с вами и будем использовать для управления линиями дисплея — GPIO6 (CTS на UART1) и GPIO7 (RTS на UART).
Далее я начал изучать PDF-ку с документацией сомнительного качества и писать код инициализации. Начинается всё с получения контекста устройства с помощью функции CH347OpenDevice, которая принимает в себя индекс нужного контроллера в системе и возвращает непонятный идентификатор (вероятно WinUSB?). Интересно то, что в остальном API используется не идентификатор, а как раз тот самый индекс, который в большинстве случаев будет 0. Далее мы получаем информацию об устройстве и сверяем режим работы, если он отличается от нужного — выбрасываем исключение:
/* Initialize CH347 */
deviceHandle = CH347OpenDevice(deviceIndex);
if (!deviceHandle)
throw new std::runtime_error("Failed to open CH347 device");
mDeviceInforS info;
CH347GetDeviceInfor(deviceIndex, &info);
if (info.ChipMode != 1)
throw new std::runtime_error("Incorrect chip mode");
Далее настраиваем SPI-контроллер. На выбор есть все три существующих режима, настройки полярности и возможность вручную дергать один из двух доступных ChipSelect'ов, а также тайминги. Частота работы определяется предустановленным набором делителей — 60МГц, 30МГц, 15МГц и т.п. Не забываем настроить таймаут каждой USB-транзакции:
CH347SetTimeout(deviceIndex, CommunicationTimeout, CommunicationTimeout);
/* Initialize SPI bus & GPIO */
mSpiCfgS cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.CS1Polarity = 0; /* CS0 = active low */
cfg.CS2Polarity = 0;
cfg.iActiveDelay = DefaultChipSelectDelay;
cfg.iByteOrder = 1;
cfg.iClock = 0;
cfg.iDelayDeactive = DefaultChipSelectDelay;
cfg.iIsAutoDeativeCS = 0;
cfg.iMode = 0;
cfg.iChipSelect = 0;
cfg.iSpiWriteReadInterval = DefaultChipSelectDelay;
if (!CH347SPI_Init(deviceIndex, &cfg))
throw new std::runtime_error("Failed to initialize SPI");
И инициализируем дисплей. Здесь есть важный момент: функция CH347GPIO_Set устанавливает состояние всего GPIO-контроллера в чипе и поэтому принимает в себя три битовые маски с конфигурацией каждого пина. Функции GPIO стандартные — вход/выход, плюс обработка прерываний с помощью специального callback'а:
CH347GPIO_Set(deviceIndex, 1 << config.IOReset, 1 << config.IOReset, 0);
this_thread::sleep_for(16ms); /* HW reset */
CH347GPIO_Set(deviceIndex, 1 << config.IOReset, 1 << config.IOReset, 1 << config.IOReset);
/* Software initialization */
SendCommand(EMIPICommandList::cmdSWRESET, 0, 0, 16);
SendCommand(EMIPICommandList::cmdSLPOUT, 0, 0, 0);
/* Framerate and refresh */
uint8_t frameRateControlRegister[] = { 0x01, 0x2C, 0x2D };
SendCommand(EMIPICommandList::cmdFRMCTL1, frameRateControlRegister, sizeof(frameRateControlRegister), 0);
SendCommand(EMIPICommandList::cmdFRMCTL2, frameRateControlRegister, sizeof(frameRateControlRegister), 0);
SendCommand(EMIPICommandList::cmdFRMCTL3, frameRateControlRegister, sizeof(frameRateControlRegister), 0);
SendCommand(EMIPICommandList::cmdFRMCTL4, frameRateControlRegister, sizeof(frameRateControlRegister), 0);
/* Power control */
uint8_t powerControlRegister1[] = { 0xA2, 0x02, 0x84 };
SendCommand(EMIPICommandList::cmdPWCTL1, powerControlRegister1, sizeof(powerControlRegister1), 0);
uint8_t powerControlRegister2 = 0xC5;
SendCommand(EMIPICommandList::cmdPWCTL2, &powerControlRegister2, sizeof(powerControlRegister2), 0);
uint8_t powerControlRegister3[] = { 0x0A, 0x00 };
SendCommand(EMIPICommandList::cmdPWCTL3, powerControlRegister3, sizeof(powerControlRegister3), 0);
uint8_t powerControlRegister4[] = { 0x8A, 0x2A };
SendCommand(EMIPICommandList::cmdPWCTL4, powerControlRegister4, sizeof(powerControlRegister4), 0);
uint8_t powerControlRegister5[] = { 0x8A, 0xEE };
SendCommand(EMIPICommandList::cmdPWCTL5, powerControlRegister5, sizeof(powerControlRegister5), 0);
uint8_t powerControlVCOMRegister = 0x0E;
SendCommand(EMIPICommandList::cmdPWCTL6, &powerControlVCOMRegister, sizeof(powerControlVCOMRegister), 0);
/* Addressing */
uint8_t madCtlMode = 0xC8;
SendCommand(EMIPICommandList::cmdMADCTL, &madCtlMode, sizeof(madCtlMode), 0);
uint8_t rasetRegister[] = { 0x0, 0x0, 0x0, 0x7f };
uint8_t casetRegister[] = { 0x0, 0x0, 0x0, 0x9f };
SendCommand(EMIPICommandList::cmdRASET, casetRegister, sizeof(rasetRegister), 0);
SendCommand(EMIPICommandList::cmdCASET, rasetRegister, sizeof(casetRegister), 0);
uint8_t colorMode = 0x05; /* RGB565 */
SendCommand(EMIPICommandList::cmdCOLMOD, &colorMode, sizeof(colorMode), 0);
SendCommand(EMIPICommandList::cmdDISPON, nullptr, 0, 0);
...
void CDisplay::SendCommand(EMIPICommandList command, uint8_t* data, size_t length, uint32_t delay)
{
uint8_t cmd = (uint8_t)command;
/* Send command */
GPIOSet(deviceIndex, config.IODataCommand, 0);
CH347SPI_Write(deviceIndex, 0, sizeof(cmd), sizeof(cmd), &cmd);
/* Send arguments (if any) */
if (data && length)
{
GPIOSet(deviceIndex, config.IODataCommand, 1);
CH347SPI_Write(deviceIndex, 0, length, length, data);
}
this_thread::sleep_for(chrono::milliseconds(delay));
}
Теперь можно запустить программу и посмотреть на результат. Если вы увидели шум (или мусор) на экране — значит вы всё делаете правильно и контроллер успешно проинициализирован.
На фото можно заметить перемычку между CS и массой, однако не все контроллеры дисплеев толерантны к постоянному низкому уровню на CS. На моей практике контроллеры ILI отказывались проходить инициализацию, если не разграничивать каждую транзакцию с помощью CS.
Теперь можно что-нибудь вывести. Подготавливаем изображение, преобразовав в 16-битный массив пикселей, переводим контроллер в режим записи в VRAM, отправляем изображение:
void CDisplay::CopyFrameBuffer(uint8_t* pixels)
{
uint8_t cmd = (uint8_t)EMIPICommandList::cmdRAMWR;
/* Send command */
GPIOSet(deviceIndex, config.IODataCommand, 0);
CH347SPI_Write(deviceIndex, 0, sizeof(cmd), sizeof(cmd), &cmd);
GPIOSet(deviceIndex, config.IODataCommand, 1);
uint32_t frameBufferSize = config.Width * config.Height * 2;
uint32_t offset = 0;
CH347SPI_Write(deviceIndex, 0, frameBufferSize, 2, pixels);
}
И пишем небольшую демо-программу:
int main(int argc, char** argv)
{
CDisplayConfiguration config = {
ChipSelectIndex, ResetGPIOIndex, DataCommandGPIOIndex, 128, 160
};
CDisplay display(config);
display.CopyFrameBuffer(beach);
return 0;
}
Результат — на дисплее появляется картинка!
Потенциальных применений у такого гаджета много: можно сделать красивые анимированные часы, мониторинг датчиков, показ уведомлений или дублировать окно с основного ПК. А ведь когда-то ради такого покупали LPT-провода, дисплеи от Сименсов и вручную превращали параллельную шину в последовательную...
❯ Заключение
Вот такой интересный гаджет выпустила компания Waveshare — и, что радует, по очень приятной цене! Ссылку по понятным причинам прилагать не буду, но при желании вы сможете его найти на всех трёх крупных маркетплейсах. Кроме того, можно купить Breakout-плату с тем же самым чипом за ~500 рублей, но там не будет таких удобных переключателей и Dupont'ов.
К сожалению, теста JTAG в статье не будет. У меня пока нет готовых к работе необычных гаджетов, где можно было бы протестировать OpenOCD... однако мой HTC Dream всё ещё ждёт свою прошивку модема!
А если вам интересна тематика ремонта, моддинга и программирования для гаджетов прошлых лет — подписывайтесь на мой Telegram-канал «Клуб фанатов балдежа», куда я выкладываю бэкстейджи статей, ссылки на новые статьи и видео, а также иногда выкладываю полезные посты и щитпостю. А ролики (не всегда дублирующие статьи) можно найти на моём YouTube канале.
Если вам понравилась статья...
И у вас появилось желание что-то мне задонатить (например прикольный гаджет) - пишите мне в телегу или в комментариях :) Без вашей помощи статьи бы не выходили! А ещё у меня есть Boosty.
Подготовлено при поддержке @Timeweb.Cloud
Ответ на пост «Я купил игровую консоль и написал для неё BIOS»2
А можно рассмотреть старые компы типа XT?
Эмулятор для них есть в проекте "мурмулятор".
Там же схемы эмуляции различных приставок, компьютеров типа "Радио-86РК" и "ZX-Spectrum".
Надеюсь скоро можно будет эмулировать i286 и i386 - и, возможно, даже получится запустить OS/2 Warp 4.0 Merlin или что-то подобное для офисной работы...
Продолжение поста «Я купил игровую консоль и написал для неё BIOS»2
Меня часто спрашивают, почему я не наносек.
Я маргинал, который знает исключительно вершки-корешки и не умеет ни код нормальный писать, ни что то доводить до конца. Я не закончил три пту в своем городе из за того, что просто отбитый маргинал. Поэтому мне не светит ни госка, ни частная контора, ни даже работа на галере - у меня нет скиллов, а умело продавать себя я не умею и у меня не хватает хватки.
Так что фигня это все, мой максимум - второсортные развлекательные статейки, чисто как бульварное чтиво, только про IT. Почти как нейромусор.
Я купил игровую консоль и написал для неё BIOS2
Осторожно: Статья написана максимально простым языком. Так что если вы гик, но не умеете программировать - вам всё равно будет интересно!
Недавно я наткнулся на DIY-игровую консоль за 1.500 рублей - Waveshare GamePi13. Когда гаджет приехал ко мне, я запустил примеры игр от производителя... и оторопел от 5 FPS в Pong - это ж как плохо нужно код писать!
Не желая мириться с этим, я открыл схему устройства, даташит на RP2040 и принялся писать свой собственный BIOS. Если вам интересно узнать, как работают DIY-консоли «изнутри», можно ли запускать внешние программы на микроконтроллерах из RAM, как реализованы различные подсистемы BIOS, а в конце даже написать «Змейку» - добро пожаловать под кат!
❯ Предисловие
Иногда китайские производители выпускают на рынок дешевые гаджеты с ориентиром исключительно на гиков. Чего-уж говорить, с какой-нибудь R36s чего только не сделали: и кастомные прошивки, и порты игр с ПК, и даже достаточно сложные аппаратные модификации. Однако в тусовке DIY'щиков обычно всё куда хардкорнее...
«Андерграундные» консоли выходят чуть ли не каждый день, но лишь единицы из них становятся хоть сколь либо популярными и попадают на массовый конвейер. От «больших» консолей их отличает простая схемотехника, использование распространенных и дешевых микроконтроллеров общего назначения и полная свобода творчества — что хочешь, то и твори! По характеристикам они чаще всего близки к оригинальному GameBoy или GameBoy Advance, а покупают их инженеры, демосценеры и ретро-энтузиасты, которые не только играют во что-то готовое, но и пишут небольшие игрушки сами!
Самые известные консоли такого формата — это нашумевший Playdate и чуть менее известный Arduboy. Обе консоли сильно ограничены в характеристиках и это подстегивает интерес гиков к постоянной оптимизации кода и попыткам впихнуть «невпихуемое». Выделился даже российский «Микрон», представив свою DIY-консоль «для хардкорных ардуинщиков» — некий MikBoy на базе своего же МИК32 «Амур»!
Я уверен что Микроновцы будут читать эту статью... Если вдруг всё получится и MikBoy пойдёт в серию — то напишите мне пожалуйста сообщение :)
Подобным «ардуинщиком» являюсь и я. Ещё со школьных лет меня нереально тянет к микроконтроллерам и Embedded-электронике в целом. О консоли собственной разработки я мечтаю с 14 лет, при этом мне не просто хочется собрать прототип и «забить», но и запустить мелкосерийное ручное производство и продавать устройства подписчикам! К своим 24-годам я сделал два прототипа и развел три платы, но все эти проекты так или иначе откладывались в долгий ящик...
И вот, 25 сентября мне стукнуло 24 годика. Уже взрослый мальчик получил в качестве подарка донат от постоянного читателя и пошёл изучать маркетплейсы в поисках интересного железа. По ключевым словам «tft lcd diy» был найден «ESP32 Bitcoin Miner V2» (выгодный девкит с 2.8" и ESP32-S2), девкит ESP32 с 4.3" дисплеем и емкостным тачскрином, а также некий Waveshare GamePi13, о котором мы сегодня с вами и поговорим!
Отдельное спасибо хотелось бы сказать тем самым подписчикам. Без вашей поддержки этой статьи бы не было!
Waveshare — знаменитый в кругах энтузиастов SBC производитель. В основном компания занимается дисплеями, модулями расширения и одноплатными компьютерами.
В тот же день я заказал устройство, и уже через 3 недели трепетного ожидания, GamePi13 оказался у меня на столе. На первый взгляд консоль показалась очень маленькой: её 1.3" дисплей был даже меньше, чем у Nokia 6230i, а кнопки оказались расположены непривычно близко друг к другу. Ко всему прочему, у консоли не было предусмотрено вообще никакого корпуса: ни «болванки» от производителя, ни STL-файлов для печати. Что-ж, это только придаёт брутальности нашему устройству!
Как вы уже могли заметить, консоль состоит из двух независимых модулей: платы разработки Waveshare RP2040-PiZero и «бутербродного» геймпада с дисплеем, который подключается к гребёнке основной платы. В этом и кроется главный секрет устройства: геймпад изначально рассчитан именно для «одноплатников» Raspberry Pi, но поскольку Waveshare также выпускает плату RP2040 с Pi-совместимой гребёнкой, они решили заодно адаптировать его и для PiZero.
❯ Что внутри?
Хоть PiZero и похожа на референсную плату в лице Raspberry Pi Pico, у неё есть несколько серьёзных отличий:
Во первых, на плате установлена SPI-флэшка объёмом аж в 16МБ. Это максимальный объём, который поддерживает XIP-контроллер в RP2040. В RPi Pico же используется флэш-память объёмом всего в 2МБ.
Далее внимание привлекает использование менее эффективного ULDO RT9193 вместо полноценного DC-DC преобразователя в оригинальном Pico. Сам микроконтроллер сможет работать при разрядке аккумулятора ниже 3.6В, а вот периферия — под вопросом. Иными словами, мы не сможем использовать «все соки» из аккумулятора и нам придётся реализовывать отсечку по напряжению.
На плате распаяна микросхема-чарджер литий-ионных аккумуляторов ETA6096 с током зарядки аж в 1А. Если захотите использовать аккумулятор меньшей емкости — стоит подобрать резистор ISET большего номинала, иначе есть риск перегрева.
Из разъёмов распаян HDMI (да, я тоже в шоке), слот для MicroSD (под него отдали весь SPI0) и два Type-C: один для аппаратного USB-контроллера в RP2040, второй для USB через PIO. В общем, пытались угодить всем.
Плата с геймпадом не менее интересная. С фронтальной стороны у нас расположилось 10 кнопок и 1.3" IPS-дисплей с разрешением 240x240, использующий контроллер ST7789. Вообще, для такой диагонали разрешение дисплея крайне избыточно: оно не только съедает драгоценные килобайты оперативной памяти для фреймбуфера, но и значительно грузит DMA-контроллер и всю шину SPI. Я бы на месте инженеров установил бы сюда «золотой стандарт» — недорогой 1.8" 128x160. Все кнопки подключены к отдельным пинам без сдвигового регистра и занимают значительную часть доступных GPIO.
С обратной стороны расположился небольшой динамик, усилитель, построенный на базе NS8002, 3.5мм джек для подключения наушников, а также токоограничивающий резистор подсветки и обвязка для дисплея. Подсветка подключена напрямую к VSYS и рассчитана на питание от 3.3В, так что никакой регулировки яркости и продвинутых режимов сна!
Ну что-ж, собираем наш бутерброд обратно, подключаем Type-C и смотрим на одну из представленных демо-игр — Тетрис!
Нет, это не пережатая гифка, игра действительно идёт буквально в 1 FPS и с мерцанием — и это на микроконтроллере с ядром Cortex-M0+ на частоте аж в 150МГц! Я напомню, что N-Gage с процессором TI OMAP на более старом ядре ARM926EJ-S с частотой 104МГц умудрялся тянуть первый Tomb Raider с полностью программным рендерингом в 25 FPS!!!
Далее я решил открыть официальный вики Waveshare и изучить информацию о консоли, где нашел несколько примеров игр для неё, одной из которых был Pong. Какое же было моё разочарование, когда я узнал, что обе игры написаны полностью на Python: игровая логика, маршалинг данных, работа с «железом» — всё это было на интерпретируемом языке и более того, написано плохо и крайне неэффективно!
class hardware():
def init():
spi0=SPI(1,baudrate=900000000, phase=0, polarity=0,
sck=Pin(game_kit.lcd_sck, Pin.OUT),
mosi=Pin(game_kit.lcd_sda, Pin.OUT))
display = st7789.ST7789(spi0, 240, 240,
reset=Pin(game_kit.lcd_rst, Pin.OUT),
dc=Pin(game_kit.lcd_dc, Pin.OUT),cs=Pin(game_kit.lcd_cs, Pin.OUT),
xstart=0, ystart=0, rotation=0)
# 初始界面,提示游戏开始
display.fill(st7789.BLACK)
display.text(font2, "Pong!", 90, 90)
display.text(font2, "Let's go!", 60, 140)
time.sleep(1)
hardware.display = display
class pong():
def __init__(self):
# bgm
self.bgm = p_music(p_music.song2, tempo=1, duty=500, pins=[
Pin(game_kit.buzzer, Pin.OUT)])
# 控制音乐暂停和播放的键start
self.key_start = button(game_kit.key_start, self.key_start_callback)
# led
self.led = Pin(game_kit.led_sta, Pin.OUT)
Ни о каком подобии SDK или библиотеки для абстрагирования работы с железом даже речи не шло, практически всё, кроме номеров пинов, было захардкожено прямо в коде игры. О хорошей архитектуре тоже речи не идёт: один класс на всю логику с глобальными переменными... В общем, сэмплы писал либо новичок, либо прожженный эмбеддер :)
Драйвер дисплея даже не пытается использовать DMA, из-за чего даже Понг, состоящий из трёх прямоугольников умудряется тормозить.
def blit_buffer(self, buffer, x, y, width, height):
"""
Copy buffer to display at the given location.
Args:
buffer (bytes): Data to copy to display
x (int): Top left corner x coordinate
Y (int): Top left corner y coordinate
width (int): Width
height (int): Height
"""
self.set_window(x, y, x + width - 1, y + height - 1)
self.write(None, buffer)
Звуковая подсистема, состоящая из одноканальной тональной пищалки на аппаратном ШИМ-контроллере, тоже была со своими «приколами». Например «тишина» — это 0, то есть магнит всегда прижат к нижней части, хотя должно быть PWM_MAX / 2.
Под впечатлением от такого кода, я решил попробовать написать SDK для этой консоли сам. Однако моё видение идеальной DIY-консоли сильно отличалось от того-же Arduboy или Playdate!
❯ Архитектура
При проработке архитектуры будущего «BIOS», я сразу же поставил для себя несколько чётких задач:
Во первых, BIOS должен быть достаточно абстрактным для того, чтобы скрывать от игры детали реализации конкретного «железа». Иными словами, игра оперирует не DMA-контроллерами, FPU-сопроцессором и SPI, а набором простых и понятных подсистем: графика, ввод, звук, хранилище. Кроме того, это позволяет легко портировать игры для такого BIOS'а на другие платформы: можно без проблем реализовать симулятор (не эмулятор!) консоли на ПК или портировать её на ESP32 с минимальными изменениями.
Во вторых, мы ставим производительность в основной приоритет при разработке устройства. В конце-концов это же позорище, что простейшая игра тормозит и мерцает на мощном микроконтроллере, но при этом тетрисы с трёхмерной графикой вполне шустро работали на телефонах Sony Ericsson 2005 года. Именно поэтому для написания игр используются не скриптовые языки по типу Lua или JS, а самый обычный «C с классами».
В третьих, сам BIOS должен быть легко портируем между разными платами (у SpotPear есть вторая похожая плата — уже с 1.5" и стиком) и даже аппаратными платформами. Этот проект может стать основной прошивкой для консоли уже моей разработки и иметь вот такую «кроссплатформу» было бы отнюдь не лишним!
Руководствуясь критериями выше, я решил писать BIOS на C++ (на деле C с классами) с активным использованием интерфейсов и VMT. Это позволяет не только удобно структурировать модули и повышает читаемость кода игры, но и избавляет от необходимости вручную составлять таблицу системных вызовов к API. Тем не менее, в таком подходе есть один серьёзный нюанс: когда у подсистем появляются новые методы или добавляются перегрузки к прошлым, их необходимо по порядку добавлять в конец интерфейса, иначе VMT ломается.
vtable for CTest:
.word 0
.word typeinfo for CTest
.word CTest::Test()
.word CTest::Abc()
vtable for ITest:
.word 0
.word typeinfo for ITest
.word __cxa_pure_virtual
.word __cxa_pure_virtual
В своё время Microsoft решила эту проблему в COM с помощью QueryInterface и миллиона вариаций этих самых интерфейсов: IDirectSound8, IDirectDraw7 и т.д, но мы можем не изобретать велосипед, а просто предоставлять «старым» играм такие же «старые» версии VMT.
Основным объектом в BIOS'е является CSystem, который содержит в себе ссылки на другие подсистемы консоли, а также на информацию о текущей аппаратной платформе:
/// @brief Primary system service, supplied to both games and system modules.
class ISystem
{
public:
virtual CSystemInfo* GetSystemInfo() = 0;
virtual void* Alloc(uint32_t size) = 0;
virtual void Free(void* ptr) = 0;
virtual IGraphicsService* GetGraphicsService() = 0;
virtual IInputService* GetInputService() = 0;
virtual IDebugService* GetDebugService() = 0;
};
Несмотря на кажущуюся «динамическую» натуру системы, никаких IID я переизобретать не стал. BIOS должен реализовывать ровно тот минимальный функционал системы, который нужен. Экземпляр CSystem создаётся так называемым «портом» на конкретную плату, который должен заполнить структуру с указателями на реализации подсистем — прямо как machine-файлы в Linux! И RAII не нарушили, и полный контроль без костылей сохранили — ляпота!
void InitializePlatform()
{
CommManager = new CCommunicationManager();
CDebugService* dbgSvc = new CDebugService();
/* Print some userful debug information */
CJEDECFlashID* flashId = FlashManager.GetFlashID();
dbgSvc->Print("Initializing platform");
dbgSvc->Print("Flash memory manufacturer: 0x%x, capacity: %dKb", flashId->Manufacturer, flashId->Capacity / 1024);
dbgSvc->Print("CID: %d", FlashManager.GetCID());
dbgSvc->Print("First available: %d", FlashManager.GetFirstUserSector());
/* Service initialization */
InputService = new CInputService(dbgSvc);
GraphicsService = new CGraphicsService(dbgSvc);
/* Platform description info */
PlatformInfo.DebugService = dbgSvc;
PlatformInfo.GraphicsService = GraphicsService;
PlatformInfo.InputService = InputService;
System = new CSystem(&PlatformInfo);
}
int main() {
InitializePlatform();
while (true) {
/* Tick all platform-depend services here */
CommManager->Tick();
PowerStateManager.Tick();
InputService->Tick();
System->Tick();
}
}
В целом, базовая архитектура примитивная и понятная. Перейдем же к деталям реализации конкретных модулей.
❯ Графика
Первая подсистема, которую я реализовал — была графической. Концептуально она разделена на два отдельных модуля: драйвер дисплея, который позволяет получить его параметры и в будущем управлять его состоянием, а также модуль для рисования на поверхностях. Прямо как в DirectDraw:
struct CFrameBufferInfo
{
uint16_t Width;
uint16_t Height;
CColor* Pointer;
uint32_t Size;
};
class IDrawingSurface : public ISystemService
{
public:
virtual void Clear(CColor color) = 0;
virtual void DrawBitmap(CBitmap* bitmap, int x, int y) = 0;
virtual void DrawBitmapEx(CBitmap* bitmap, int x, int y, CSpriteInfo* spriteInfo) = 0;
virtual void DrawRect(CColor color, int x, int y, int width, int height) = 0;
virtual void FillRect(CColor color, int x, int y, int width, int height) = 0;
virtual void DrawLine(CColor color, int x1, int y1, int x2, int y2) = 0;
virtual void DrawString(CColor color, int x, int y, CAnsiChar* str) = 0;
};
class IGraphicsService : public ISystemService
{
public:
virtual void SetPowerState(bool isPowerEnabled) = 0;
virtual void SetBacklightState(bool isBacklightEnabled) = 0;
/* Maybe some controller-related functions in future? Like BIAS and HW rotation? */
virtual CFrameBufferInfo* GetFrameBufferInfo() = 0;
virtual IDrawingSurface* GetDrawingSurface() = 0;
virtual void Flush() = 0;
};
Сам драйвер дисплея классический: в его задачи входит инициализация контроллера, выделение памяти под фреймбуфер и регулярное обновление изображения на матрице. Поскольку в таких устройствах используются стандартные MIPI DBI экраны с набором команд DCS, часть кода инициализации и работы с дисплеем стало возможным унифицировать:
/* Perform hardware reset */
gpio_put(PIN_LCD_RST, 0);
sleep_ms(DISPLAY_INIT_SLEEP_TIME);
gpio_put(PIN_LCD_RST, 1);
sleep_ms(DISPLAY_INIT_SLEEP_TIME); /* Wait for display controller to complete initialization */
Reset(); /* Perform software reset to maintain default register state */
SendCommand(cmdSLPOUT, 0, 0); /* Disable sleep mode */
SendCommand(cmdCOLMOD, 0x05); /* Set color format and decoding*/
SendCommand(cmdINVON, 0, 0); /* Disable inversion */
SendCommand(cmdNORON, 0, 0); /* Enable normal mode */
SendCommand(cmdMADCTL, cmdMADCTL_RGB); /* Set pixel size */
uint8_t windowSize[] = { 0 >> 8, 0, DISPLAY_WIDTH >> 8, DISPLAY_WIDTH }; /* Set display window (note this is not safe for displays with sides not equal in size) */
SendCommand(cmdCASET, windowSize, 4);
SendCommand(cmdRASET, windowSize, 4);
SetPowerState(true); /* Enable display */
Вероятно читатель может спросить: «зачем выделять целых 115КБ под фреймбуфер, если можно использовать команды CASET/RASET и рисовать отдельные спрайты прямо в память дисплея?». Дело в том, что в таком случае скорость отрисовки будет падать обратно пропорционально размеру и числу рисуемых изображений. Если мы попытаемся нарисовать параллакс-фон, состоящий из трёх картинок с размерами 240x240, то нашим узким местом станет не только цена обращения к XIP-кэшу, но и производительность SPI-контроллера (который напрямую тактируется от системного PLL) и мы получим те самые 1-2 FPS. Кроме того мы потеряем возможность использования DMA и нам придётся ждать каждой транзакции на экран: это проблема многих «самодельных» консолей, которую, впрочем, можно решить обратившись к опыту предков — а именно PPU.
В своём проекте я решил активно задействовать DMA-контроллер для отправки фреймбуфера на дисплей. Концепция простая: мы указываем ему переслать фреймбуфер, начинаем подготавливать следующий кадр и если транзакция ещё не завершена - то дожидаемся её окончания, дабы картинка оставалась целостной. Однако если обновление логики следующего кадра завершается быстрее, чем DMA-контроллер успевает отправить сканлайны - мы можем получить эффект тиринга.
/* Setup DMA for SPI */
dmaChannel = dma_claim_unused_channel(true);
dmaConfig = dma_channel_get_default_config(dmaChannel);
channel_config_set_transfer_data_size(&dmaConfig, DMA_SIZE_8);
channel_config_set_dreq(&dmaConfig, spi_get_dreq(spi1, true));
channel_config_set_read_increment(&dmaConfig, true);
channel_config_set_write_increment(&dmaConfig, false);
...
if(!dma_channel_is_busy(dmaChannel))
{
uint8_t cmdByte = cmdRAMWR;
gpio_put(PIN_LCD_CS, 0);
gpio_put(PIN_LCD_DC, 0);
spi_write_blocking(spi1, &cmdByte, 1);
gpio_put(PIN_LCD_DC, 1);
dma_channel_configure(dmaChannel, &dmaConfig, &spi_get_hw(spi1)->dr, frameBufferInfo.Pointer, frameBufferInfo.Size, true);
}
Далее переходим к фактической отрисовке изображений. На данный момент поддерживается только один формат пикселей — RGB565, поскольку нет особого смысла использовать 8-битную палитру для изображений 32x32 (но есть смысл использовать 4х-битную, как на NES). Процесс рисования называется блиттингом и поскольку реализация полноценного альфа-блендинга слишком дорогая для реалтайм графики на микроконтроллерах, для описания прозрачности используется техника колоркеев.
Взято с pinterest
ColorKey — это как ChromaKey, но для описания прозрачного цвета используется только базовый цвет, а не цвет + порог допустимых цветов. Помните как в играх 90-х были картинки с розовым фоном цвета Magenta? Вот это оно самое :)
for(int i = 0; i < min(y + bitmap->Height, frameBufferInfo->Height) - y; i++)
{
CColor* bitmapScanline = &bitmap->Pointer[i * bitmap->Width];
CColor* scanline = &frameBufferInfo->Pointer[(y + i) * frameBufferInfo->Width + x];
for(int j = 0; j < min(x + bitmap->Width, frameBufferInfo->Width) - x; j++)
{
uint16_t sample = *bitmapScanline;
if(sample != bitmap->ColorKey)
*scanline = sample;
scanline++;
bitmapScanline++;
}
}
Рисование текста реализовано знакомым для Embedded-инженеров способом: шрифты описываются в формате 8x8, где 8 битов каждого байта обозначают наличие или отсутствие пикселя в текущей позиции. Такие шрифты не только занимают очень мало места, но их также очень легко и быстро рисовать, а также масштабировать под различные разрешения экранов. На данный момент я задумываюсь — стоит ли добавлять в консоль поддержку полноценного UTF-16, если учесть что основной таргет на русскоязычную аудиторию, где и CP866 хватает с головой?
❯ Ввод
Далее мы плавно переходим к реализации драйвера ввода. Как я уже говорил выше, все кнопки подключены к своим отдельным GPIO без использования сдвигового регистра или I/O Expander'а, что с одной стороны и хорошо (некоторые китайские производители реализовывают консоли с кнопками, основанными на матричном (!!!) принципе), а с другой — отъедает большинство GPIO у RP2040. Свободными пинами мы могли бы выполнять множество полезной работы: получать уровень заряда аккумулятора у Fuel Gauge, управлять уровнем подсветки с помощью ШИМ-контроллера и ключа, или, в конце-концов, сделать порт для подключения периферии... но нет так нет.
Сам по себе драйвер ввода до жути примитивный: он позволяет получить состояние отдельных кнопок, осей (как Input.GetAxis в Unity) и проверить, нажата ли хоть какая-то кнопка:
class IInputService : public ISystemService
{
public:
virtual EKeyState GetKeyState(EKeyCode keyCode) = 0;
virtual int GetAxis(EInputAxis axis) = 0;
virtual bool IsAnyKeyPressed() = 0;
};
Для удобства и портабельности BIOS'а между платами, кнопки геймпада маппятся к соответствующим GPIO в отдельной таблице трансляции, которая также содержит состояния этих самых кнопок:
// Should be layouted in order of EKeyCode enum
CButtonState ButtonMapping[] = {
{
PIN_KEY_LEFT
},
{
PIN_KEY_RIGHT
},
{
PIN_KEY_UP
},
{
PIN_KEY_DOWN
},
{
PIN_KEY_A
},
{
PIN_KEY_B
},
{
PIN_KEY_X
},
{
PIN_KEY_Y
},
{
PIN_KEY_LEFT_TRIGGER
},
{
PIN_KEY_RIGHT_TRIGGER
}
};
Дело в том, что в нашем проекте недостаточно иметь лишь одно булево: нажата-ли кнопка или нет, для компенсации дребезга кнопок у нас также реализуется задержка перед следующей проверкой и дополнительное состояние для удобства реализации меню — «только что отпущена».
void CInputService::Tick()
{
timeStamp = get_absolute_time();
for(int i = 0; i < ButtonMappingCount; i++)
{
CButtonState* buttonState = &ButtonMapping[i];
bool gpioState = !gpio_get(buttonState->GPIO); // Buttons are pull-up to high when not pressed
// Check if there was elapsed enough time
if(timeStamp > buttonState->LastStateChange)
{
if(buttonState->State == EKeyState::ksReleased)
buttonState->State = EKeyState::ksIdle;
if(buttonState->State == EKeyState::ksIdle && gpioState)
buttonState->State = EKeyState::ksPressed;
if(buttonState->State == EKeyState::ksPressed && !gpioState)
buttonState->State = EKeyState::ksReleased;
buttonState->LastStateChange = timeStamp + KEY_DEBOUNCE_THRESHOLD;
}
}
}
Таким образом, мы получаем куда более удобную подсистему ввода, чем условная битовая маска с обозначением каждой кнопки и ручной обработкой её состояний в игре...
EKeyState CInputService::GetKeyState(EKeyCode keyCode)
{
uint32_t code = (uint32_t)keyCode;
if(keyCode >= ButtonMappingCount)
return EKeyState::ksIdle; /* Maybe we should throw an exception? */
return ButtonMapping[code].State;
}
int CInputService::GetAxis(EInputAxis axis)
{
EKeyCode a = EKeyCode::keyLeft;
EKeyCode b = EKeyCode::keyRight;
if(axis == EInputAxis::inputAxisVertical)
{
a = EKeyCode::keyUp;
b = EKeyCode::keyDown;
}
return GetKeyState(a) == EKeyState::ksPressed ? -1 : (GetKeyState(b) == EKeyState::ksPressed ? 1 : 0);
}
А вот и результат:
❯ Запуск программ
Вот мы и подошли к, возможно, самой интересной подсистеме в нашем BIOS'е. Думаю многие читатели так или иначе интересовались тем, как же компилятор и линкер превращают исходный код и объектный файлы в пригодные для выполнения программы и библиотеки. Вопрос запуска нативных программ на микроконтроллерах интересовал и меня — я даже написал целых три статьи об этом: в первой мы поговорили о ESP32 и Xtensa, а во второй реализовали BinLoader путём реверс-инжиниринга и хакинга кнопочного телефона, а в третьей сделали полу-универсальный ElfLoader для нескольких моделей телефонов на разных платформах.
Но начнём мы с простого. Каждая программа делится на три основных секции:
.text — содержит в себе машинный код функций и так называемые Literal pools. Может быть как в ROM, так и в RAM. На системах, где есть возможность выполнять код и в ROM, и в RAM, есть отдельная секция - .iram.
.data — содержит инициализированные переменные, которые обычно попадают в оперативную память. Для статических констант есть отдельная секция, называемая .rodata.
.bss — содержит в себе не-инициализированные переменные, обычно это нули. В исполняемый файл секция .bss напрямую не записывается, остаётся лишь информация о том, каков её размер, а саму секцию затем выделит динамический линкер.
Куда попадут части программы определяет специальная утилита — линкер, которая на основе специального скрипта «раскладывает» данные по нужным секциям. Благодаря этому скрипту, мы можем, например, перенести часть функций в оперативную память для более быстрого исполнения или добавить в начало программы заголовок с описанием приложения.
В моём случае, я решил загружать игры в SRAM и дабы не реализовывать нормальный динамический линкер и релокации, решил выделить под игру фиксированный кусочек оперативной памяти объёмом в 128КБ. Для этого я отредактировал скрипт линкера Pico C SDK так, чтобы сразу после вектора прерываний шла наша программа:
. = ALIGN(4);
.ram_vector_table (NOLOAD): {
*(.ram_vector_table)
} > RAM
iram_program_reserve_size = 128K;
.iram_program (NOLOAD) : {
. = ALIGN(4);
PROVIDE(iram_program_origin = .);
. += iram_program_reserve_size;
} > RAM
.uninitialized_data (NOLOAD): {
. = ALIGN(4);
*(.uninitialized_data*)
} > RAM
Для компиляции программы также используется кастомный скрипт для линкера и особый Makefile, где после сборки программы мы копируем все её секции в выходной файл в «сыром» виде. Поскольку программа собирается под выполнение из конкретного адреса — пока речь идёт о переносимости только между одной аппаратной платформой. На RP2040, RP2350 и возможно STM32 такое «прокатит», но вот на других ARM-процессорах — большой вопрос!
OUTPUT_FORMAT("elf32-littlearm")
SECTIONS
{
. = 0x200000c0;
.program_info : {
*(.program_info*)
}
.text : {
*(.vtable*)
*(.text*)
*(.rodata*)
*(.data*)
*(.bss*)
}
/DISCARD/ : {
*(.ARM.*)
*(.comment*)
}
}
Каждое приложение, как и базовая система, предполагает использование ООП и поэтому представляет из себя реализацию класса IApplication. Для этого нам нужна некоторая runtime-поддержка: аллокатор, функция для создания экземпляра приложения, а также указатель на ISystem. Именно поэтому каждая программа должна экспортировать специальный заголовок, где содержится указатель на функцию-инициализатор:
#define PROGRAM_HEADER 0x1337
#define PROGRAM_INFO(name, clazz) int test; CAllocator* __Allocator; IApplication* __createInstance(CAllocator* allocator, ISystem* systemPtr) { __Allocator = allocator; return new clazz(systemPtr); } \
CProgramInfo __program_info __attribute__ ((section(".program_info"))) = { PROGRAM_HEADER, BIOS_VERSION, name, &__createInstance };
struct CProgramInfo
{
uint32_t Header;
uint32_t BIOSVersion;
CAnsiChar Name[32];
CreateApplicationInstanceFunction CreateApplicationInstance;
};
...
PROGRAM_INFO("Blink", CBlinkApplication)
Таким образом, для выполнения нашей программы и вызова её обработчиков событий нам достаточно лишь загрузить файл по адресу 0x200000c0 и создать экземпляр IApplication. Всё очень просто и понятно!
CAllocator allocator;
allocator.Alloc = malloc;
allocator.Free = free;
IApplication* app = ((CProgramInfo*)ptr)->CreateApplicationInstance(&allocator, System);
Но "моргалка" ведь слишком просто, согласитесь? Поэтому мы с вами напишем ремейк классической игры Змейка, которая работает в настоящие 60 FPS!
❯ Заключение
Вот таким нехитрым образом я понемногу реализовываю свою мечту детства: «андерграунд" консоль собственной разработки. Конечно здесь ещё много чего нужно доделывать перед тем, как начинать разводить свою плату, но начало ведь положено! В контексте GamePi13, я считаю что моя реализация SDK для консоли всё таки немного лучше, чем то, что предлагает производитель «из коробки».
Я понимаю что мой не совсем трушный эмбеддерский подход может вызвать разные ощущения у читателей: так что приглашаю всех заинтересованных в комментарии, обсудим с вами «сломанный Branch-prediction из-за виртуалов», «UB из-за того, что порядок указателей на реализации в VMT может отличаться» и «какого фига игры у тебя оказались в SRAM, а высокопроизводительный код на Flash, если у XIP кэш всего в 16КБ!».
А если вам интересна тематика ремонта, моддинга и программирования для гаджетов прошлых лет — подписывайтесь на мой Telegram-канал «Клуб фанатов балдежа», куда я выкладываю бэкстейджи статей, ссылки на новые статьи и видео, а также иногда выкладываю полезные посты и щитпостю. А ролики (не всегда дублирующие статьи) можно найти на моём YouTube канале.
Если вам понравилась статья...
И у вас появилось желание что-то мне задонатить (например прикольный гаджет) - пишите мне в телегу или в комментариях :) Без вашей помощи статьи бы не выходили! А ещё у меня есть Boosty.
Подготовлено при поддержке @Timeweb.Cloud
ТОП-25 курсов разработчика игр: обучение разработке компьютерных игр с нуля
Для будущего разработчика игр обучение на курсах — хороший способ для старта. Большинство программ не требуют изначального знания языка программирования или понимания программ. Помимо технической стороны, такие курсы обучают психологии игр, графике, дизайну, коммуникации в IT-команде и помогают с карьерой.
В 2025 году российский геймдев достиг максимальной прибыли (более 200 млрд. рублей) и продолжает активно расти. Требуются специалисты, которые умеют создавать красивые и интересные истории, оформляя их в формате разножанровых компьютерных игр. Многие зарубежные компании также ценят российских разработчиков, благодаря их опыту и навыкам. Поэтому сейчас самое время пройти курсы разработчика игр с нуля.
Я просмотрела более 40 курсов по геймдеву и составила подборку из 10 лучших программ. Дополнила список еще 10 курсами с качественным содержанием и условиями, а также 5 вариантами обучения для детей. А для некоторых курсов я нашла скидки и промокоды.
ТОП-10 лучших курсов разработчика игр в 2025 году
Разработчик игр на Unity от Eduson Academy — один из самых подробных курсов для программистов в сфере геймдева.
Профессия разработчик игр на Unity от Нетологии — углубленная программа от известной онлайн-школы; студенты получают навыки разработки игр на уровне middle.
Профессия Разработчик игр на Unity с нуля от Skillbox — большой курс с уклоном на применение актуальных нейросетей в работе гейм-разработчика.
Профессия Разработчик на Unreal Engine от GeekBrains — лучший курс для освоения С++ и написания кода на движке Unreal Engine.
Профессия Разработчик игр от Skillbox — программа с возможностью дальнейшей стажировки и трудоустройством в реальной игровой студии GameBox.
Профессия Разработчик на Unity от GeekBrains — программа по разработке на Unity с самой быстрой и развернутой обратной связью.
Unity Game Developer. Basic от OTUS — углубленный курс по C#, Unity и геймдеву для тех, кто уже имеет определенный опыт в программировании.
Создание игр в Unity и программирование на языке C# от Pixel — качественный учебный план, рассчитанный на подростков с 6 по 8 класс.
Unity Game Developer. Professional от OTUS — лучший курс для повышения уровня навыков в геймдеве на Unity до middle.
Разработчик игр на Unity от Skillfactory — практико-ориентированный курс с лучшими условиями оплаты и вариантами сэкономить на стоимости.
Онлайн-курсы разработчика игр
1. Разработчик игр на Unity | Eduson Academy
Этот полугодовой курс подходит и новичкам, и программистам, желающим попробовать себя в разработке именно игрового контента. Авторы не гарантируют трудоустройство, однако обещают сделать для этого все. В том числе работает искусственный интеллект по поиску и отбору лучших рабочих офферов. Большой упор идет на практическую часть. По итогу студенты получают сразу три формата подтверждения образования: диплом о профессиональной переподготовке (в соответствии с российскими требованиями), два сертификата школы на русском и английском языках.
Стоимость: от 4 791 руб./мес.
Длительность: 6 месяцев
Формат обучения: онлайн, live-встречи, 85% программы — практические занятия
Сертификат: выдается
Кому подойдет: программа рассчитана как на новичков в геймдеве, так и на разработчиков в смежных направлениях, которые давно хотели попробовать себя в создании игр.
Преимущества:
соответствует изменениям в сфере разработке игр;
после обучения бессрочный доступ не только к текущей программе, но и к изменениям;
портфолио пополнится 5 большими работами;
доступ к специальному ИИ-сервису, помогающему трудоустроиться;
подробное описание требований к ПК, чтобы процесс обучения был максимально комфортным;
85% от всех уроков и академических часов приходится на практику;
дипломы подтверждаются на уровне исследовательского центра Сколково;
много личного общения и постоянная обратная связь по прогрессу.
Недостатки:
не очень большой опыт работы у педагогов курса — в среднем 5 лет.
Программа обучения:
знакомство;
IDE и Code Style;
базовые конструкции C#;
психологический аспект в работе программиста;
Git;
управление камерой Cinemachine.
2. Профессия разработчик игр на Unity | Нетология
Используйте промокод kursfinder, чтобы получить скидку 7%
Большой онлайн-курс, позволяющий с нуля достичь уровня «профи» в разработке игр. Главный результат — 12 проектов в разных жанрах. Занятия проводятся дважды в неделю в вечернее время. Однако можно настроить свой режим или даже приостановить обучения, если сложно успевать за общим темпом. Полученные навыки подтверждаются диплом российского образца.
Стоимость: от 3 198 руб./мес. или 109 400 рублей одним платежом
Длительность: 13 месяцев
Формат обучения: дистанционный, онлайн-трансляции, тренажеры, практические упражнения, общение в чате
Сертификат: диплом о профессиональной переподготовке на базе СПО или Вуза
Кому подойдет: всем желающим достичь профессионального уровня разработчика компьютерных игр обучением с нуля. Также программа полезна программистам смежных областей.
Преимущества:
внушительное пополнение портфолио — 12 крупных игровых проектов в разных жанрах для демонстрации навыков;
разработка по реальным техническим заданиям и кейсам;
сопровождение и помощь во всех шагах к трудоустройству: от участия в Карьерном клубе до полезных материалов Энциклопедии;
очень много практики — 182 академических часа;
рассматривается применение современных нейросетей в геймдеве;
обратная связь в удобных форматах: записанный ролик, сообщения в чате или видео-звонок. На выбор клиента;
можно сдвигать дедлайны или ставить обучение на «паузу»;
быстрые ответы от службы технической поддержки. Заявлено ожидание не более 3 часов;
имеется общий чат для студентов;
удобное мобильное приложение Академии для постоянного доступа к личному кабинету;
допускается полный возврат денег в первые 3 суток. Далее сумма зависит от уже пройденных часов.
Недостатки:
высокая стоимость обучения.
Программа обучения:
редактор Unity;
язык программирования С#;
как писать код на С# в Unity;
создание компьютерных игр;
мобильный геймдев;
Blender;
прототипирование на базе Unity;
бонусные блоки по моделированию, soft-skills программиста и поиску работы.
3. Профессия Разработчик игр на Unity с нуля | Skillbox
Используйте промокод kursfinder, чтобы получить скидку 50%
Онлайн-курс длительностью от полугода до 10 месяцев. Срок зависит от выбранного тарифа программы и собственного темпа студента. При желании ученик может следовать личному графику, но участвовать на общих обязательных видео-звонках или онлайн-вебинарах. Наставники помогут освоить язык программирования, способы использования ИИ, работу в Unity, анимацию и графику компьютерных игр.
Стоимость: от 5 825 руб./мес.
Длительность: от 6 до 10 месяцев
Формат обучения: дистанционный, подготовленные ролики, практикумы, вебинары с экспертами, связь через сообщения
Сертификат: от школы Skillbox
Кому подойдет: начинающим разработчикам и людям без опыта в программировании; всем, кто хочет создавать компьютерные игры и зарабатывать на этом.
Преимущества:
первая оплата, если взять курс частями, через полгода;
гарантированное трудоустройство, иначе вернут стоимость программы. Однако обязательно следовать всем рекомендациям и шагам карьерного центра;
за выполнение некоторых заказов еще во время обучения предусмотрена оплата;
быстрый ответ от наставников;
иногда проводятся онлайн-вебинары с приглашенными экспертами;
можно заниматься с телефона через приложение или мобильную версию сайта;
преподаватели курса — именитые разработчики, которые участвовали в создании таких игр, как Civilization или World of Tanks;
стажировка для студентов, которые прошли отбор;
7 игр разных жанров и уровня сложности для портфолио;
можно запросить бесплатную консультацию, чтобы уточнить все вопросы до оплаты.
Недостатки:
большая часть обратной связи происходит через сообщения по электронной почте. Мало «живого» контакта;
не выдается диплом государственного образца, исключительно сертификат школы.
Программа обучения:
теория разработки игр;
пользовательские интерфейсы в Unity;
физика и механика;
работа с компонентами;
создание искусственного интеллекта;
углубленное изучение графики и анимации;
командная практика;
применение нейросетей в game-разработке;
психология компьютерных игр.
4. Профессия Разработчик на Unreal Engine | GeekBrains
Используйте промокод kursfinder, чтобы получить скидку 7%
Дистанционный курс для освоения игровой разработки на C++ на базе Unreal Engine. Опытные преподаватели научат не только программированию, но и работе с персонажами, анимацией, сценами и разными уровнями игры. Школа комплексно готовит к собеседованиям и поиску заказчиков. Если не удается получить место после всех усилий HR-команды, возвращают деньги. В 98% случаев, судя по отзывам, до этого не доходит.
Стоимость: от 4 842 руб./мес.
Длительность: индивидуальный темп, около 650 часов
Формат обучения: полностью онлайн
Сертификат: выдается
Кому подойдет: всем желающим научиться разработке компьютерных игр и освоить один из самых популярных языков программирования С++.
Преимущества:
много «живого» взаимодействия с кураторами в формате онлайн-трансляций;
составление сильного портфолио, минимум 4 проекта (больше, если купить расширенный курс);
подготовка к поиску первой работы после выпуска;
есть система возврата средств, если не получилось трудоустроиться;
полученные навыки работы на «движке» Unreal Engine пригодятся не только в геймдеве. Применяются в кинопроизводстве, промышленности и графическом дизайне;
дополнительное обучение мобильной разработке;
безграничный доступ ко всем видео-урокам. Можно просматривать в любое время через личный кабинет;
геймдевы для отработки практических навыков;
наставники отвечают в текстовом формате в течение 24 часов;
помогает развить коммуникативные навыки для работы в команде разработки;
все преподаватели — разработчики-практики;
возможность попасть на стажировку после отбора;
имеется база вакансий специально для студентов GeekBrains;
более 500 часов посвящено практическим упражнениям и непосредственной разработке.
Недостатки:
«живые» занятия проводятся по графику. Может быть сложно совмещать с основной занятостью.
Программа обучения:
изучение Unreal Engine;
применение Git;
освоение С++;
создание и настройка проекта на С++;
TopDownShooter.
5. Профессия Разработчик игр | Skillbox
Используйте промокод kursfinder, чтобы получить скидку 60%
После курса студенты научатся придумывать успешные концепты компьютерных игр, создавать игры с и без программного кода, продвигать и зарабатывать на своем продукте. По всем урокам предоставляется развернутая обратная связь в формате видео или текстового сообщения. Максимальное время ожидания отклика — сутки. Для наиболее активных студентов открыт набор на стажировку в dev-команду от GameBox.
Стоимость: от 7 062 руб./мес.
Длительность: в своем режиме с бессрочным доступом
Формат обучения: дистанционный, записанные видео, онлайн-трансляции, практикумы
Сертификат: от школы Skillbox
Кому подойдет: тем, кто хочет использовать свое хобби и интерес к компьютерным играм для заработка. Курс ориентирован на новичков в разработке, но будет интересен и программистам из других областей: back-end, front-end, создателям ПО и пр.
Преимущества:
возврат денег, если не устроились на работу;
спикеры курса имеют большой опыт в геймдеве, разрабатывали Call of Duty, Final Fantasy и др.;
максимально удобная платформа и мобильное приложение;
нестандартный подход обучения разработке через игры, легенды и «лор»;
геймификация процесса;
участие в комьюнити российских разработчиков;
программа учит создавать игры сразу на трех популярных «движках»: Unreal Engine, Unity и GameMaker;
бесплатный годовой курс по английскому языку в подарок к любой «специализированной» программе школы;
эксперты имеют большой опыт в российском и зарубежном геймдеве.
Недостатки:
диплом не дает повышение квалификации или профессиональную переподготовку.
Программа обучения:
концепт игры;
игровой рынок в России;
сценарное мастерство в геймдеве;
документация первой компьютерной игры;
левел-дизайн;
разработка игр «без кода».
6. Профессия Разработчик на Unity | GeekBrains
Используйте промокод kursfinder, чтобы получить скидку 7%
Курс учит создавать 2D-стратегии, 3D-шутеры и игры во многих других жанрах. Обучение проводится на самом популярном движке в геймдеве — Unity. Знания пригодятся и в других сферах, если студент решит расширить свои компетенции. GeekBrains хорошо помогает с поиском работы или заказчиков на фрилансе. Если после всех усилий трудоустроиться не вышло, можно запросить деньги на возврат.
Стоимость: от 5 356 руб./мес.
Длительность: свой темп, всего 400 часов
Формат обучения: онлайн-встречи, видеоролики, тренажеры, реальные кейсы
Сертификат: диплом школы GeekBrains
Кому подойдет: всем желающим получить навыки middle-уровня разработчика компьютерных игр. Курс подходит тем, кто еще не сталкивался с написанием программного кода.
Преимущества:
только актуальные и популярные инструменты: Unity, Visual Studio и Blender;
программа актуализирована на 2025 год, соответствует новым изменениям в России и мире;
перед оплатой можно пройти бесплатную консультацию у сотрудника школы;
«прямые эфиры» с экспертами;
только реальные кейсы;
быстрая обратная связь после каждого практического занятия в личном чате с куратором прямо на платформе;
дружелюбные и профессиональные педагоги, судя по отзывам на сторонних сайтах;
обучают эффективной работе в команде. Пригодится, потому что в разработке почти всегда участвует целая группа специалистов, важна грамотная коммуникация;
среди наставников: руководитель игровой студии, Unity-программист, геймдизайнеры, разработчики и другие сертифицированные специалисты;
есть шанс попасть на стажировку в игровую студию, но для этого придется проходить отбор среди всех участников за 3 месяца;
от 10 проектов для портфолио. Точное количество зависит от покупки бонусных уроков;
курс прошел государственное лицензирование;
Базовый и Расширенный тарифы временно по одной стоимости.
Недостатки:
высокая стоимость.
Программа обучения:
методы программирования в геймдеве;
Unity-разработка;
искусственный интеллект;
работа в Blender;
использование Video Studio.
7. Unity Game Developer. Basic | OTUS
Пятимесячный курс по освоению базовых и продвинутых навыков в игровой разработке на Unity. Для прохождения курса желательно иметь некоторое представление о том, что такое геймдев, какие процессы включает и т.д. Для этого можно пройти курс разработчика игр бесплатно с описанием профессии и сферы. К желательным, но необязательным требованиям относится опыт в Unity и знание основ ЯП С#.
Стоимость: от 7 916 руб./мес. или 95 тысяч рублей одним платежом
Длительность: 5 месяцев
Формат обучения: онлайн, вебинары
Сертификат: удостоверение о повышении квалификации и сертификат OTUS
Кому подойдет: любителям компьютерных игр, которые быть не только пользователем, но и разработчикам; программистам из других сфер, которые задумываются о геймдеве.
Преимущества:
теория подается не записанными видео, а вебинарами. Проще воспринимается, благодаря мгновенной обратной связи;
карьерная поддержка: помощь с резюме, составление рекомендательного письма, создание портфолио, которое понравится работодателям;
закрытый чат в Telegram для общения с кураторами и другими учениками;
если пропустили вебинар, можно просмотреть его запись в любое время;
возможно корпоративное обучение сразу нескольких сотрудников;
выдается официальный диплом о повышении квалификации, если имеется необходимая «база» образования;
создатель курса имеет более 7 лет опыта в разработке игр разного уровня;
есть возможность перевода в другую группу занятий, если не удается учиться в текущий момент;
возвращают средства за непройденные месяцы обучения.
Недостатки:
только один итоговый проект для портфолио, в узконаправленном жанре — зомби-шутер Top-Down;
довольно большие платежи по рассрочке.
Программа обучения:
создание персонажей;
разработка оружия для шутера;
игровой интерфейс;
Level-дизайн;
оптимизация процессов в Unity;
аналитика;
публикация и монетизация игры;
создание своей игры;
презентация продукта.
Расширенный курс для подростков от 10 до 14 лет. Подходит для любого изначального уровня знания информатики, программирования и математики. Занятия проводятся по четкому расписанию раз в неделю. Процесс обучения геймифицирован, чтобы ученикам было проще и воспринимать теорию, и выполнять практику. Регулярно предоставляется обратная связь для родителей и самих детей от преподавателей.
Стоимость: только по заявке
Длительность: 9 месяцев
Формат обучения: очный или заочный по выбору студента
Сертификат: да
Кому подойдет: курс ориентирован на подростков, которые не просто увлекаются играми, а хотят превратить свое хобби в будущую работу — стать гейм-разработчиком.
Преимущества:
можно заниматься как из дома, так и в классах Pixel;
комфортный уровень нагрузки на подростка. Удобно совмещать с основной учебой в школе;
качественная обратная связь для родителей;
отслеживание прогресса по занятиям из личного кабинета на сайте или в мобильном приложении;
теория и практика геймифицирована для упрощения восприятия информации;
освоение только актуальных инструментов и программ: Unity, Zoom, C#, iSpring и др.;
много дополнительных материалов для детей;
несколько вариантов сэкономить: рассрочка, материнский капитал, скидки новичкам и пр.
Недостатки:
в открытом доступе нет информации о стоимости курса.
Программа обучения:
разработка 2D-игр на С#;
создание 3D-игр на С#;
углубленная работа с персонажами и мирами игры.
9. Unity Game Developer. Professional | OTUS
6-месячный курс по game-разработке с занятиями по вторникам и пятницам с 19:00. Подходит только тем, кто уже разбирается в компьютерной разработке, умеет работать на Unity, но хочет усовершенствовать свои навыки. Изначально нужны умения по С#, Git, объектно-ориентированному программированию и структурам данных. Прохождение курса дает углубленные навыки в сфере игровой разработки. Например, студенты научатся проектированию архитектуры нейросетей для геймдева, писать собственный фреймворк или разрабатывать серверы для мета-игр.
Стоимость: от 8 666 руб./мес. или 104 000 рублей
Длительность: в своем темпе
Формат обучения: онлайн-вебинары, тренажеры, практические кейсы
Сертификат: удостоверение о повышении квалификации
Кому подойдет: только тем, кто уже занимается разработкой и понимает, как создавать игры на Unity. Курс расширяет компетенции.
Преимущества:
углубленная программа для поднятия уровня навыков до middle или senior;
большой упор на создание и использование собственного искусственного интеллекта в работе гейм-разработчика;
много вебинаров для личного взаимодействия с наставниками;
все преподаватели имеют senior-уровень навыков в программировании;
разбор кейсов из реальной практики экспертов;
бесплатное участие в офлайн- и онлайн-мероприятиях после оплаты любого курса на сайте;
предоставляется удостоверение о повышении квалификации российского государственного образца. Если нет вузовского образования или СПО, выдается сертификат школы.
Недостатки:
очень высокая цена, но оправдывается углубленным уровнем программы.
Программа обучения:
архитектура игры;
мета-механики в компьютерных играх;
нейросети, создание своего ИИ;
интеграция основных плагинов;
реализация и «защита» итогового проекта.
10. Разработчик игр на Unity | Skillfactory
Объемный онлайн-курс для всех, кто хочет не только играть, но и создавать свои IT-проекты. Подходит для людей вообще без опыта и знаний в области программирования. Предлагается несколько тарифов. Самый дорогой включает в себя общий с наставником проект и личные консультации каждую неделю длительностью 1 час.
Стоимость: от 5 379 руб./мес.
Длительность: 13 месяцев
Формат обучения: полностью дистанционный
Сертификат: о прохождении обучения и стажировки
Кому подойдет: для обучения разработке ПК- и мобильных игр с нуля. Подходит фрилансерам, студентам, разработчикам из смежных областей и всем желающим зарабатывать на участии в создании IT-продукта.
Преимущества:
стажировка входит в программу обучения;
некоторые заказы оплачиваются еще в процессе прохождения курса;
подготовка яркого портфолио с 7 играми в популярных жанрах: шутеры, гонки, платформеры и другие;
итоговый проект полностью зависит от учащегося. Самостоятельно выбирает стиль, придумывает сценарий, жанр и т.д.;
создатели и эксперты — практикующие программисты, участвуют в разработке популярных игр, имеют педагогический опыт в обучении взрослых студентов;
13 месяцев обучения можно пройти быстрее в зависимости от личного темпа;
подается только действительно важная и интересная теория;
максимальный процент практики;
оказывается постоянная поддержка менторов;
лекции, рекомендации, практическая помощь по трудоустройству.
Недостатки:
нет диплома о профпереподготовке или повышении квалификации.
Программа обучения:
знакомство с геймдевом;
уроки программирования на С#;
дизайн компьютерных игр;
Space shooter;
Tower defense;
3D-racing;
разработка личной или групповой игры;
архитектура на «движке» Unity.
Еще 10 курсов разработчика игр
Геймдев — популярное направление в IT. Почти все крупные онлайн-школы и академии предлагают свои курсы по разработке компьютерных и мобильных игр. Я не смогла ограничиться одной десяткой лучших программ, поэтому нашла еще несколько вариантов от крупных школ.
Разработчик игр на Unreal Engine с нуля от Нетологии — программа по освоению разработки компьютерных игр для тех, кто никогда не занимался кодингом. Продолжительность — 4,5 месяцев. В конце выдается сертификат Нетологии. Итоговый проект необходим не только для портфолио, но и для получения удостоверения. Его направленность и сложность студент выбирает самостоятельно. Чтобы заниматься онлайн, важно следовать расписанию. Уроки проводятся по вечерам, с 19:00.
Разработчик игр на Unreal Engine 5 от Skillbox — на прохождение курса понадобится от 8 до 16 месяцев. Длительность зависит от личной загруженности и выбора дополнительных модулей программы. Сначала студенты обучаются no-code-разработке (без программирования), затем переходят на С++. По частям можно купить курс за 5 825 рублей в месяц. Причем первый взнос только через полгода обучения. К тому времени ученики уже могут начинать зарабатывать на разработке.
Основы разработки игр на C# от Stepik — мини-курс на 5 часов за 3 500 рублей. Через «Сплит» или «Долями» можно оплатить частями, около 800 рублей каждый платеж. Подходит для самых начинающих. Изучите Visual Studio и научитесь писать на С#. Эти навыки пригодятся не только в game-разработке, но и в других IT-областях. В комментариях хвалят легкость и доступность программы, но не подходит для углубленного изучения.
Разработка игр на Unity от XYZ School — 5-месячное обучение на геймдев. Студенты учатся создавать играбельные 2D-прототипы, писать код на С#, и загружать свои продукты в GooglePlay и подобные маркеты приложений. Дается много фидбэка от наставников по каждому этапу учебы и работы над собственной игрой. Темп и график полностью настраивается, но следующий урок открывается только после прохождения и сдачи предыдущего. Авторы считают, что это дисциплинирует и мотивирует.
Разработчик игр от Академии «Синергия» — большой курс с обещанным трудоустройством в конце. Выдается диплом о профессиональной переподготовке. Бессрочный доступ для всех материалов, входящих в программу. Можно учиться в любое свободное время вне зависимости от группы. В программу включено несколько мастер-классов от приглашенных экспертов в области геймдева. 8 игр разного жанра, уровня сложности и сюжета в портфолио.
C++ разработчик игр от XYZ School — полугодовое обучение по геймдеву с самого нуля. В рассрочку стоимость каждого платежа составит от 7 500 рублей. Перед оплатой рекомендую пройти бесплатную профориентационную консультацию. Поможет лучше понять, кто такой гейм-разработчик, чем занимается, подходит ли специальность. После курса ученики овладевают языком программирования C++ на middle-уровнем, а навыки разработчика — на junior.
Unity и Unreal начальный курс от Stepik — программа для новичков в программировании за 30 тысяч рублей. Можно оплатить частями через сервисы Яндекса или российских банков. Автор и единственный преподаватель — Елена Тинькова, опытный программист и педагог. Однако о ее компетенциях в разработке игр указано мало. Содержание программы содержит очень «сильную» теорию, но недостаточно практики.
C# для разработки игр от XYZ School — 5 месяцев занятий для освоения ЯП С#, которые применяется и в игровой, и в веб-разработке. Уровень необходимых знаний — нулевой. Будет понятно даже тем, кто плохо разбирается в информатике. Для создания игр будет использоваться Unity. Отдельный упор в программе делается на отладку контроля версий, в том числе через Git. Расписание и общий темп полностью подстраивается под обучающегося. Можно ставить на паузу, переносить дедлайны или прохождение уроков. Главное — закрыть все зачеты и сдать итоговый проект.
Python для начинающих. Графика. Анимация. Создание игр от Stepik — уникальная программа, так как обучает создавать игры для ПК не на C++ или С#, а на Python. Само знание этого языка программирования открывает возможности во многих других IT-направлениях. Подходит всем новичкам и даже детям, начиная с 6 класса школы. Упор делается на создание графики и анимирование. Преподаватель курса — Радик Ишмуратов, является победителем конкурса «Учитель года» за 2015 год. Очень хорошие отзывы о его педагогическом подходе, а также большой опыт в программировании. Цена программы — 3 500 рублей.
Разработчик игр на Unity от TeachMeSkills — обучение всему, что нужно знать и уметь по геймдеву, за 6 месяцев. После курса студенты пишут коды, создают интерфейсы, отлаживают процессы, тестируют и продвигают 3D- и 2D-игры. Используется «движок» Unity. Перед выпуском специалисты платформы помогают создать портфолио. В него будут включены 9 проектов: игры разных, популярных жанров. Вся программа длится почти 200 академических часов.
Еще 5 курсов разработчика игр для детей
Сегодня очень большой процент детей и подростков увлекаются компьютерными и мобильными играми. Родители часто считают, что это исключительно вредное занятие. Однако увлечение технологиями можно использовать во благо — научить ребенка полезным навыкам геймдева, которые пригодятся в будущем при выборе профессии, поступлении и первой работе. Для этого хорошо подходят онлайн-курсы по разработке игр для детей и подростков.
Разработка игр на Unity от GeekBrains — программа для учащихся с 6 по 8 класс, от 12 лет. Первое занятие проводится учителем бесплатно, чтобы ребенок дал понять, хочет ли заниматься разработкой или нет. Подходит любителям ПК-игр и тем, кто интересуется программированием. В программу входит создание пяти разножанровых игр, написание сценариев, разработка героев и «лора». Работа в команде развивает коммуникативные способности. Подросток сможет найти друзей с общими интересами.
Scratch программирование для детей от Hello World — программирование и создание игр для самых маленьких. Минимальный возраст — 7 лет. Сам процесс обучения геймифицирован, проходит в форме игр и интерактивов. Очень много практики при доступной теории. Всего 69 игровых проектов, включая написание своей собственной игры в качестве выпускной работы. На стартовом уроке определяются начальные навыки будущего ученика, его уровень понимания ПК и информатики.
Программирование и создание игр на Scratch от GeekBrains — для учеников начальных классов, примерно с 8 до 10 лет. Продолжительность курса — 8 месяцев, соответствует школьному темпу обучения. Каждый урок длится 1,5 часа, возможны перерывы по желанию ребенка. Можно купить индивидуальный или групповой тариф. Первый дает доступ к персональному общению с педагогом, лучше воспринимается информация и обратная связь. Групповой тариф развивает коммуникативные способности.
Разработка 2D и 3D-игр в Godot на Python от Coddy School — от 9 месяцев обучения для подростков от 11 до 16 лет. Можно полностью настроить формат обучения: онлайн или офлайн, в группе или один-на-один с наставником. Программа сильно отличается от аналогов. Будет изучаться язык программирования Python (наиболее востребованный в разработке) и «движок» Godot, а не Unity или Unreal Engine. Пробное занятие бесплатно, чтобы оценить преподавательский подход.
Разработка игр с Godot для детей от Айтигенио — трехуровневый учебный план для детей и подростков по разработке на базе Godot Engine. Дети научатся создавать качественные 3D-игры и запускать их на онлайн-платформах, в маркетах приложений. Педагог и создатель данного курса — Виталий Власенко, имеет высшее IT-образование, стаж работы в разработке более 5 лет, а также большой преподавательский опыт. Стоимость и дополнительную информацию нужно уточнять отдельно у администратора Айтигенио.
Game-developer в России — одна из самых востребованных и высокооплачиваемых специальностей из мира IT. Сейчас только в Москве на hh.ru открыто более 250 вакансий со средним уровнем заработка от 150 тысяч рублей в месяц. Но многие работодатели предлагают оплату за отдельные проекты. Один из главных плюсов работы разработчика игр — обучение позволяет трудиться удаленно. А значит, можно выбирать московские или другие крупные IT-компании, не находясь в столице. Заработная плата у них, естественно, на уровень выше, чем в регионах.
Разработчик C++ — кто это и чем занимается
Рассказываем, чем занимаются программисты на С++, сколько получают, какие навыки нужны в профессии — и не только.
Пара слов о С++
Это один из самых востребованных языков бэкенда — «внутренней» части программ и приложений. Он подходит тем, кто хочет заниматься вплотную кодом и крупными проектами, где важна производительность и надежность.
Где нужны разработчики С++
C++ используют для написания кода высокопроизводительных программ, приложений и операционных систем, браузеров (тот же Google Chrome) — и даже видеоигр и игровых движков.
Еще C++ часто используют для продуктов, связанных с графикой, видео и работой со звуком. Например, на нем (и его предшественнике C) базируются графические редакторы Adobe Photoshop и Illustrator, дополнительные компоненты ОС Windows.
Если говорить о работодателях, то C++ разработчики нужны в сферах, где критичны скорость, работа с памятью и надёжность: игровые движки, финтех и трейдинг, системное и встроенное ПО, автомобильные и авиационные системы, телеком и медицина.
Какие хард скилы потребуются
Базовый синтаксис языка — чтобы понять, как соединять те или иные части когда. Синтаксически правильные программы можно скомпилировать и потом запустить.
#include <iostream>
int main() {
std::cout << "Hello world" << std::endl;
return 0;
}
Основные структуры данных, отвечающие за способ организации памяти. Это поможет эффективно управлять информацией, которая в ней хранятся. Так как конкретный вид структуры зависит от задачи — разбираться нужно во всей типологии.
Стандартная библиотека ― набор функций и классов, которые строго описаны и всегда доступны для языка. Например, чтение и записи файлов на диске. Понимание ее возможностей нужно для оценки решений:какие доступны «из коробки», а какие придется искать в сторонних библиотеках или разрабатывать с нуля.
Изучить основы C++ можно самостоятельно — или освоить профессию с нуля на курсе «Разработчик C++». Наставники и ревьюеры помогут разобраться с базовыми алгоритмами и структурами данных и научат писать чистый, работающий код.
Какие софт скилы пригодятся
Критическое мышление. В C++ почти всегда несколько решений: быстрый хак, красивый шаблон, сторонняя библиотека. Важно уметь оценивать компромиссы: например, между скоростью и поддерживаемостью, удобством и безопасностью.
Коммуникация. В больших проектах в разработке участвует множество людей. Если плохо объясняешь решения или не умеешь задавать уточняющие вопросы — вырастает гора багов. Поэтому важно умение донести мысль на техмитинге и в код-ревью.
Системное мышление. Нужно видеть систему целиком и понимать, как твоя часть проекта влияет на производительность, память, безопасность.
Самообучаемость и желание прокачиваться. Язык С++ постоянно эволюционирует. Без привычки быстро вникать в новое, читать документацию и пробовать руками разработчик быстро «застаивается».
Средние зарплаты специалистов
Средняя зарплата начинающего программиста C++ составляет в среднем 135 тысяч рублей. В дальнейшем мидлы могут рассчитывать уже на оклад 251 тысячу — эти деньги реально начать зарабатывать уже через год-два. В дальнейшем рост до сеньора потребует уже большего ресурса — в среднем через пять-шесть лет можно рассчитывать на х2.
Чем больше опыт, набор навыков и круг обязанностей — тем выше зарплата. Специалист с опытом программирования на C++ и умением создавать коммерческие многопоточные приложения может получать 400 тысяч рублей и больше. Добавьте к этому управление командой — и оклад вырастет до 450–600 тысяч.
Как стать востребованным разработчиком С++
Читайте профессиональную литературу. Например, «Программирование. Принципы и практика с использованием C++» (Бьёрн Страуструп), «Эффективный и современный С++: 42 рекомендации по использованию C++11 и C++14» (Скотт Мейерс), «Гибкая разработка программ на Java и C++. Принципы, паттерны и методики» (Роберт С. Мартин).
Больше практикуйтесь на C++. Даже если ваши знания минимальны — пробуйте создавать свои проекты. Чтобы не делать этого впустую, найдите ментора, который укажет на слабые места и поможет улучшить код.
Не забывайте про теорию языка. Отличный ресурс для этого — сайт cppreference.com. По сути это подробный справочник с описанием языка и стандартной библиотеки. C++ программисты часто обращаются к этому сайту как к основному инструменту. Многие страницы переведены на русский.
Читайте руководства, которые активно создают разработчики С++.
Следите за сайтом комитета ISO C++ — там собраны новости, статусы и черновики стандартов для всех компиляторов и платформ.
А чтобы уверенно шагнуть в мир С++ разработки, присмотритесь к онлайн-курсу «Разработчик C++» от Яндекс Практикума. В программе отводится много времени на практику, приближенную к реальным рабочим задачам. Есть поддержка наставников, а после выпуска — помощь с трудоустройством.
Попробуйте бесплатную вводную часть курса и решите, хотите ли продолжать.
Реклама ООО «Яндекс», ИНН: 7736207543













































