Программирование STM32 в Linux — задача вполне решаемая, хотя и требует некоторой начальной настройки. В отличие от Windows, где доминируют IDE вроде Keil или STM32CubeIDE, в Linux вы получаете полный контроль над инструментами и можете выбрать подход по душе: от "голого" C до Rust.

Ниже показаны простые шаги по быстрому старту на примере STM32F103C8T6 (BluePill). Вот что вам понадобится и какие есть пути.

[Базовый набор инструментов]

Для начала работы в Linux (на примере Ubuntu) потребуется установить кросс-компилятор и утилиты для прошивки. Стандартный набор:

gcc-arm-none-eabi: кросс-компилятор для ARM Cortex-M.
binutils-arm-none-eabi: ассемблер, линкер и другие бинарные утилиты.
gdb-multiarch: отладчик для разных архитектур.
stlink-tools или openocd: для прошивки через ST-Link.

Установка в Ubuntu/Debian:

sudo apt install gcc-arm-none-eabi binutils-arm-none-eabi gdb-multiarch stlink-tools openocd

[Основные пути разработки]

В Linux у вас есть несколько вариантов, от простого к сложному:

1. Arduino Framework (STM32duino): самый быстрый старт, если вы знакомы с Arduino. Можно использовать PlatformIO в VS Code или настроить Arduino IDE с ядром STM32. Вы получаете функции вроде pinMode() и digitalWrite(), но с ограничениями по контролю.

2. Bare-Metal (на регистрах): полный контроль над железом без библиотек. Вы напрямую управляете регистрами RCC, GPIO и другими. Идеально для понимания, как работает микроконтроллер, и дает самый компактный код. Например, мигание светодиодом может занимать всего 440 байт.

3. libopencm3: библиотека с открытым исходным кодом, которая предоставляет удобные функции для работы с периферией, но без «тяжеловесности» HAL от ST. Хороший компромисс между контролем и удобством.

4. Rust: современный и безопасный язык. Настройка включает установку rustup, целей для ARM Cortex-M (thumbv7m-none-eabi для STM32F103) и инструментов вроде probe-rs для прошивки.

[Bare-Metal: мигание светодиодом (Blinker)]

Ниже показан простой пример для микроконтроллера STM32F103C8T6 на плате BluePill для понимания процесса программирования без библиотек.

Файл stm32f103c8t6.ld (скрипт линкера):

/* Entry Point */
ENTRY(Reset_Handler)

/* Memory regions for STM32F103C8T6 */
MEMORY
{
  RAM (xrw)  : ORIGIN = 0x20000000, LENGTH = 20K
  FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 64K
}

/* Stack top */
_estack = ORIGIN(RAM) + LENGTH(RAM);

SECTIONS
{
  /* Vector table goes first */
  .isr_vector :
  {
    . = ALIGN(4);
    KEEP(*(.isr_vector))
    . = ALIGN(4);
  } >FLASH

  /* Program code */
  .text :
  {
    . = ALIGN(4);
    *(.text)
    *(.text*)
    . = ALIGN(4);
  } >FLASH

  /* Constant data */
  .rodata :
  {
    . = ALIGN(4);
    *(.rodata)
    *(.rodata*)
    . = ALIGN(4);
  } >FLASH

  /* Initialized data (stored in Flash, copied to RAM at startup) */
  _sidata = LOADADDR(.data);
  .data :
  {
    . = ALIGN(4);
    _sdata = .;
    *(.data)
    *(.data*)
    . = ALIGN(4);
    _edata = .;
  } >RAM AT> FLASH

  /* Uninitialized data */
  .bss :
  {
    . = ALIGN(4);
    _sbss = .;
    *(.bss)
    *(.bss*)
    . = ALIGN(4);
    _ebss = .;
  } >RAM
}

Скрипт линкера (linker script) — это файл, который сообщает линкеру, как расположить код и данные в памяти микроконтроллера. Он определяет области памяти (Flash, RAM) и распределяет по ним секции: вектор прерываний, код программы, константы, инициализированные и неинициализированные данные.

Для STM32F103C8T6 типичная карта памяти:

Flash: 64 КБ, начиная с адреса 0x08000000
RAM: 20 КБ, начиная с адреса 0x20000000

Примечание: в сообществе есть готовые скрипты для STM32F103C8T6, например, в репозиториях на GitHub [5, 6], посвящённых bare-metal программированию. Файл STM32F103C8Tx_FLASH.ld также генерируется STM32CubeMX при создании проекта.

Файл startup.c (код начального запуска):

#include < stdint.h>

/* Символы из скрипта линкера */
extern uint32_t _estack;
extern uint32_t _sidata;
extern uint32_t _sdata;
extern uint32_t _edata;
extern uint32_t _sbss;
extern uint32_t _ebss;

int main(void);

void Reset_Handler(void);
void Default_Handler(void);

/* Векторная таблица — кладём в секцию .isr_vector */
__attribute__((section(".isr_vector")))
const uint32_t vector_table[] = {
    (uint32_t)&_estack,          /* 0x00: Initial SP */
    (uint32_t)&Reset_Handler,    /* 0x04: Reset */
    (uint32_t)&Default_Handler,  /* 0x08: NMI */
    (uint32_t)&Default_Handler,  /* 0x0C: HardFault */
    /* ... остальные векторы можно добавить позже ... */
};

void Reset_Handler(void) {
    /* 1. Копируем .data из Flash в RAM */
    uint32_t *src = &_sidata;
    uint32_t *dst = &_sdata;
    while (dst < &_edata) {
        *dst++ = *src++;
    }

    /* 2. Обнуляем .bss */
    dst = &_sbss;
    while (dst < &_ebss) {
        *dst++ = 0;
    }

    /* 3. Вызываем main() */
    main();

    /* 4. Если main() вернулся — зацикливаемся */
    while (1) { }
}

void Default_Handler(void) {
    while (1) { }
}

Файл main.c (основной алгоритм программы):

#include < stdint.h>

// Адреса регистров для STM32F103
#define RCC_APB2ENR   (*(volatile uint32_t *)0x40021018)
#define GPIOC_CRH     (*(volatile uint32_t *)0x40011004)
#define GPIOC_BSRR    (*(volatile uint32_t *)0x40011010)

// Включение тактирования порта C
#define RCC_IOPCEN    (1 << 4)

void delay(volatile uint32_t count) {
    while (count--) { __asm__("nop"); }
}

int main(void) {
    // 1. Включаем тактирование GPIOC
    RCC_APB2ENR |= RCC_IOPCEN;

    // 2. Настраиваем PC13 как выход (50 MHz, Push-Pull).
    // Сбрасываем биты для PC13 и устанавливаем нужные.
    GPIOC_CRH &= ~(0xF << 20); // Очистить биты для PC13
    GPIOC_CRH |=  (0x3 << 20); // Output mode, max speed 50 MHz, push-pull
    while (1) {
        // 3. Зажигаем светодиод (PC13 в 0)
        GPIOC_BSRR = (1 << 13);
        delay(500000);

        // 4. Гасим светодиод (PC13 в 1)
        GPIOC_BSRR = (1 << (13 + 16));
        delay(500000);
    }
}

Этот код напрямую манипулирует регистрами, чтобы мигнуть светодиодом на плате Blue Pill.

Компиляция:

arm-none-eabi-gcc -mcpu=cortex-m3 -mthumb -c main.c -o main.o
arm-none-eabi-gcc -mcpu=cortex-m3 -mthumb -c startup.c -o startup.o

Линковка:

arm-none-eabi-ld -T stm32f103c8t6.ld main.o startup.o -o main.elf

Генерация двоичного файла прошивки:

arm-none-eabi-objcopy -O binary main.elf main.bin

[Прошивка через st-flash]

Для работы команды st-flash` вам нужен программатор ST-Link, подключённый к плате Blue Pill по интерфейсу SWD. Напрямую через USB-порт Blue Pill эту команду выполнить нельзя.

Схема подключения ST-Link к Blue Pill. Вам понадобятся 4 провода (плюс опционально пятый для Reset). Подключение к 4-контактному разъёму SWD на Blue Pill:

Важный нюанс: обычно не рекомендуется подавать питание на Blue Pill одновременно от ST-Link и от USB. Выберите один источник: либо ST-Link (подаёт 3.3V), либо USB-порт. Для прошивки обычно достаточно питания от ST-Link.

Программная настройка в Linux. Прежде чем запускать st-flash, убедитесь, что система видит программатор и у вас есть права на доступ к USB-устройству.

1. Проверьте подключение. Подключите ST-Link к компьютеру. Выполните в терминале:

lsusb | grep -i st-link

Вы должны увидеть устройство с ID `0483:3748` (или похожим).

2. Настройте права доступа, если они еще не настроены (udev rules). Если st-flash выдаёт ошибку `No ST-Link detected` или `Failed to connect`, скорее всего, у вашего пользователя нет прав на USB-устройство.

Создайте файл правил udev:

sudo nano /etc/udev/rules.d/50-stlink.rules

Добавьте в него строку (для ST-Link/V2):

ATTRS{idVendor}=="0483", ATTRS{idProduct}=="3748", MODE="0666"

Для других версий (например, ST-Link/V2-1 от плат Nucleo или V3) ID продукта будет другим (374b и 374e соответственно).

Сохраните файл, перезагрузите правила и переподключите ST-Link:

sudo udevadm control --reload-rules
sudo udevadm trigger

3. Проверьте связь с микроконтроллером:

Команда ниже покажет, видит ли ST-Link подключённую плату Blue Pill:

st-info --probe

Вы должны увидеть информацию о чипе (например, `Device connected is: F1 Medium-density device`).

4. Запуск прошивки. После всех подключений и настройки выполните команду:

st-flash write main.bin 0x8000000

Будет выведено что-то наподобие:

$ st-flash write main.bin 0x8000000
st-flash 1.8.0
2026-09-10T09:18:54 INFO common.c: STM32F1xx_MD: 20 KiB SRAM,
 64 KiB flash in at least 1 KiB pages.
file main.bin md5 checksum: 1e8cd4107ce0a1137684211ff09bfed,
 stlink checksum: 0x00004ee7
2026-09-10T09:18:54 INFO common_flash.c: Attempting to write
 236 (0xec) bytes to stm32 address: 134217728 (0x8000000)
-> Flash page at 0x8000000 erased (size: 0x400)
2026-09-10T09:18:54 INFO flash_loader.c: Starting Flash write for VL/F0/F3/F1_XL
2026-09-10T09:18:54 INFO flash_loader.c: Successfully loaded flash loader in sram
2026-09-10T09:18:54 INFO flash_loader.c: Clear DFSR
  1/1   pages written
2026-09-10T09:18:54 INFO common_flash.c: Starting verification of write complete
2026-09-10T09:18:54 INFO common_flash.c: Flash written and verified! jolly good!
2026-09-10T09:18:54 INFO common.c: Go to Thumb mode

Нажмите на кнопку RESET платы, и зеленый светодиод, подключенный к порту PC13, начнет мигать.

[Прошивка с помощью USB-загрузчика]

Для этого потребуется сначала один раз записать в микроконтроллер специальную программу-загрузчик (bootloader) [2].

Важный нюанс: встроенного USB DFU нет. Многие ожидают, что STM32F103C8T6, как и некоторые другие модели STM32, имеет встроенный в системную память USB DFU-загрузчик. Однако это не так.

Встроенный USB DFU есть только у линеек STM32F105/107. У STM32F103C8T6 (и у всей линейки F103) такого заводского загрузчика нет. Поэтому, если просто подключить плату по USB-кабелю и замкнуть BOOT0 в 1, она не определится как DFU-устройство.

Однако есть решение: пользовательский USB-загрузчик. Чтобы получить возможность прошиваться через USB, в микроконтроллер нужно один раз (через ST-Link) записать пользовательский bootloader. После этого обновлять прошивку можно будет обычным USB-кабелем.

Распространённые варианты таких загрузчиков:

1. STM32duino bootloader (Maple) — классический выбор для Blue Pill. Он создаёт виртуальный последовательный порт (CDC ACM) и позволяет загружать прошивку через dfu-util или среду Arduino IDE [7].
2. USB DFU Bootloader (Rust/RTIC) — пример загрузчика на Rust, который занимает 16 КБ Flash и позволяет обновлять прошивку через стандартную утилиту dfu-util [8].
3. USB Mass Storage Bootloader — загрузчик, который после включения эмулирует USB-флешку (FAT32). Вы просто перетаскиваете на неё .hex-файл, и прошивка обновляется [9].

Как это работает (на примере STM32duino)

1. Установка загрузчика: с помощью ST-Link (как вы уже делали) вы прошиваете в Blue Pill бинарник загрузчика. Обычно он располагается по адресу 0x08000000 и занимает небольшой объём (например, 2 КБ).

2. Настройка платы: устанавливаете перемычки BOOT0 и BOOT1 в определённое положение. Для некоторых версий загрузчика это нестандартная комбинация (BOOT0=0, BOOT1=1). Для большинства других — стандартная для входа в режим загрузки (BOOT0=1, BOOT1=0) .

3. Подключение и прошивка: перезагружаете плату, подключив её к ПК через USB. В системе появляется виртуальный COM-порт или DFU-устройство с определённым VID/PID. После этого можно использовать `dfu-util` для загрузки новой прошивки .

4. Возврат в рабочий режим: после прошивки нужно установить BOOT0 в `0` (GND) и нажать Reset. Микроконтроллер запустит вашу основную программу.

Что важно помнить:

- Вы потеряете часть Flash-памяти: загрузчик занимает место в начале памяти (например, первые 16 КБ из 64 КБ). Соответственно для основного кода останется меньше места, и его придётся размещать со смещением (например, по адресу 0x08004000) (см. врезку далее для примера загрузчика STM32duino bootloader).
- Нужна первоначальная прошивка загрузчика через ST-Link: это разовое действие, без него USB-загрузчик не появится.
- Не все загрузчики одинаковы: у разных загрузчиков могут отличаться адреса, способ входа в режим и утилиты для прошивки.

    MEMORY
    {
      RAM (xrw)  : ORIGIN = 0x20000000, LENGTH = 20K
      FLASH (rx) : ORIGIN = 0x08002000, LENGTH = 56K  /* Было 0x08000000 и 64K */
    }

// Для работы с загрузчиком Maple
#define VECT_TAB_OFFSET  0x2000
SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET;

/* Entry Point */
ENTRY(Reset_Handler)

/* Memory regions for STM32F103C8T6 with Maple bootloader */
MEMORY
{
  RAM (xrw)  : ORIGIN = 0x20000000, LENGTH = 20K
  FLASH (rx) : ORIGIN = 0x08002000, LENGTH = 56K   /* было 0x08000000 / 64K */
}

/* Stack top */
_estack = ORIGIN(RAM) + LENGTH(RAM);

SECTIONS
{
  /* Vector table goes first */
  .isr_vector :
  {
    . = ALIGN(4);
    KEEP(*(.isr_vector))
    . = ALIGN(4);
  } >FLASH

  /* Program code */
  .text :
  {
    . = ALIGN(4);
    *(.text)
    *(.text*)
    . = ALIGN(4);
  } >FLASH

  /* Constant data */
  .rodata :
  {
    . = ALIGN(4);
    *(.rodata)
    *(.rodata*)
    . = ALIGN(4);
  } >FLASH

  /* Initialized data (stored in Flash, copied to RAM at startup) */
  _sidata = LOADADDR(.data);
  .data :
  {
    . = ALIGN(4);
    _sdata = .;
    *(.data)
    *(.data*)
    . = ALIGN(4);
    _edata = .;
  } >RAM AT> FLASH

  /* Uninitialized data */
  .bss :
  {
    . = ALIGN(4);
    _sbss = .;
    *(.bss)
    *(.bss*)
    . = ALIGN(4);
    _ebss = .;
  } >RAM
}

#include < stdint.h>

/* Символы из скрипта линкера */
extern uint32_t _estack;
extern uint32_t _sidata;
extern uint32_t _sdata;
extern uint32_t _edata;
extern uint32_t _sbss;
extern uint32_t _ebss;

int main(void);
void Reset_Handler(void);
void Default_Handler(void);

/* Регистры Cortex-M3 */
#define SCB_VTOR   (*(volatile uint32_t *)0xE000ED08)
#define FLASH_BASE 0x08000000U
#define VECT_TAB_OFFSET 0x2000U   /* 8 КБ — размер загрузчика Maple */

/* Векторная таблица — кладём в секцию .isr_vector */
__attribute__((section(".isr_vector")))
const uint32_t vector_table[] = {
    (uint32_t)&_estack,          /* 0x00: Initial SP */
    (uint32_t)&Reset_Handler,    /* 0x04: Reset */
    (uint32_t)&Default_Handler,  /* 0x08: NMI */
    (uint32_t)&Default_Handler,  /* 0x0C: HardFault */
    /* ... остальные векторы можно добавить позже ... */
};

void Reset_Handler(void) {
    /* 0. Переключаем векторную таблицу на нашу (сразу после bootloader) */
    SCB_VTOR = FLASH_BASE | VECT_TAB_OFFSET;

    /* 1. Копируем .data из Flash в RAM */
    uint32_t *src = &_sidata;
    uint32_t *dst = &_sdata;
    while (dst < &_edata) {
        *dst++ = *src++;
    }

    /* 2. Обнуляем .bss */
    dst = &_sbss;
    while (dst < &_ebss) {
        *dst++ = 0;
    }

    /* 3. Вызываем main() */
    main();

    /* 4. Если main() вернулся — зацикливаемся */
    while (1) { }
}

void Default_Handler(void) {
    while (1) { }
}

Итог: прошивать Blue Pill через USB можно, но для этого сначала нужно «научить» его это делать, записав специальный bootloader через ST-Link. Это отличное решение для готовых устройств, к которым сложно подключаться программатором, но для начального освоения микроконтроллера проще и надёжнее продолжать использовать ST-Link.

[Советы для комфортной работы]

• Правила udev: чтобы прошивать без sudo, добавьте себя в группу dialout и настройте правила udev для ST-Link. Инструкции обычно есть в документации stlink-tools или openocd.

• Отладка: OpenOCD + GDB — мощный тандем. Запускаете openocd -f interface/stlink.cfg -f target/stm32f1x.cfg, затем подключаетесь gdb-multiarch и можете пошагово выполнять код, ставить точки останова и смотреть регистры.

• STM32CubeMX: хотя это GUI-инструмент, он может генерировать проекты с Makefile для Linux. Это удобный способ получить начальную инициализацию периферии, которую потом можно изучать и модифицировать.

[Ссылки]

1. STM32 "Blue Pill" в среде Arduino.
2. Программирование STM32 Blue Pill через USB.
3. Адаптеры JTAG с поддержкой SWD.
4. RT-Thread RTOS.
5. STM32F103C8T6 Linker Script and Startup Code.
6. Bare metal programming with STM32.
7. rogerclarkmelbourne / STM32duino-bootloader.
8. mygnu / rtic-dfu-bootloader.
9. STM32F103_MSD_BOOTLOADER.
10. bluepill-stm32-freertos: запуск на Code::Blocks в Linux.