В чем написать программу для stm

С чего начать изучать программирование STM32?

Я только начинаю изучать AVR. Может сразу начать с STM32? Вроде хвалят
Микроконтроллеры изучаю для себя. Язык С более-менее знаю. Времени не очень много, но хочу изучить.

нуберский вопрос про STM32 или с чего начать
как то сложилось что начал с AVR как и многие но любопытство не оставляет в покое) есть вот.

С чего начать? программирование микроконтроллеров
Здрасьте. Хочу начать заниматься программированием микроконтроллеров. Хотел бы купить все.

Добавлено через 47 секунд
+ смотрите примеры с сайта ST

Вот хороший мануал по Си )

в Visual Studio хорошо тренироваться на этом языке. Сначала сочиняем и отлаживаем в этой среде алгоритмы, а потом переносим их в свои программы в среду Кейл или IAR

Я так же учусь как и вы, но на это попробую ответить.
Если сгенерировать Кубом проект, открыть его в Кейле и смотреть код по порядку сверху вниз:
1. Идет подключение различных библиотек при помощи команды #include.
Например, автоматически подключилась собственная библиотека «stm32f1xx_hal.h». Уберите ее, и компилятор не
поймет, как работать с переменными, ножками микроконтроллера и т.д.
Туда же, со временем, будете подключать свои собственные библиотеки.

2. Удут названия функций, которые будут использоваться ниже в файле main. Прототипы.
Например, описан прототип функции void SystemClock_Config(void); Сама эта функция будет описана ниже, в программе.

3. int main(void) <Отсюда программа начнет свою работу после запуска. Еще ее называют точкой входа.
Когда программа запустится, начнет выполняться содержимое функции int main(void) < >. Например, выполнится
спрятанная внутри собственных библиотек функция HAL_Init(); Она, вроде, настраивает системный таймер.
Посмотреть содержимое этой функции можно, если кликнуть по HAL_Init() левой мышкой, затем правой и в меню выбрать
Go To Definition of «HAL_Init». Так можно смотреть содержимое любой функции и не только. Например так можно увидеть, из чего состоит команда GPIO_PIN_6 и т.д.
Но, не забудьте перед этим собрать проект. Иначе ничего не увидите.

4. Следующим в main идет SystemClock_Config(); Она нигде в в недрах библиотек не спрятана. Запустившись она выполнит то, что описано в сгенерированном коде ниже. Если полистать программу и найти ее, то там можно увидеть настройки тактирования микропроцессора. Когда в Кубе вы настраивали Clock Configuration, то в SystemClock_Config() можно увидеть итог этих настроек.

5. Дальше выполнится MX_GPIO_Init(); Она тоже нигде в библиотеках не спрятана, а описана ниже в основной программе.
Когда в Кубе вы настраивали ножки микроконтроллера, то там можно увидеть итог этих настроек.

Источник

2. STM32. Программирование. IDE для STM32

Для того, чтобы разрабатывать свои программы нам понадобится среда разработки, желательно с дебаггером, и компилятор C.

UPD: Я выложил версию CoIDE 1.7.8 на Яндексдиск. В дальнейшем будем использовать и другие IDE (читай как установить и настроить Keil uVision5 – IDE для STM32, IAR Workbench – IDE для STM32).

Установим IDE CooCox CoIDE на Windows

Первая программа

Указываем имя проекта:

В репозитории выбираем какие именно модули мы будем использовать:

Открываем main.c і набираем следующий код программы:

Компилируем (Project->Build)

При первой компиляции IDE может запросить указать местонахождение компилятора.

Надо корректно указать место, куда был установлен GCC.

После удачной компиляции заливаем программу в микроконтроллер. Эта программа будет мигать светодиодом на плате. Как залить программу в микроконтроллер мы рассматривали в предыдущей статье.

Если Вы будете заливать прошивку через UART с помощью UART-USB переходника, файл для заливки найдете в директории: C:\CooCox\CoIDE\workspace\Example_GPIO\Example_GPIO\Debug\bin\Example_GPIO.bin

Некоторые настройки IDE и параметры компилятора

Repository

Здесь мы выбираем библиотеки, которые необходимы для нашего проекта. При этом IDE копирует в папку stm_lib вашего проекта нужные файлы.

Конфигурация проекта

Закладка Compile

в этой закладке устанавливаются ключи компилятора. Мы сюда еще будем возвращаться, а пока обратим внимание на поле Optimization. Это поле задает параметр оптимизации для компилятора. Об оптимизации будет отдельный разговор, пока Вам нужно усвоить, что оптимизация Optimizate Size (-Os) максимально уменьшает объем скомпилированных программ. Но при этом компилятор может выбросить (оптимизировать) некоторые операции, и программа может работать не так, как Вам бы хотелось. Поэтому, на первых этапах, я не рекомендую использовать этот метод оптимизации. Установите Optimizate (-O1).

Закладка Link

В этой закладке пока нас интересует только поле Library и Linked Libraries. Если Вы будете использовать стандартные библиотеки С, например библиотеку математических функций math Вам нужно будет выбрать «Use base C Library«. Если этого не сделать, то компилятор выдаст ошибку.

Закладка Output

Здесь указываются куда складывать скомпилированные файлы и в каких форматах.

Закладка User

Пока в ней мы ничего делать не будем.

Закладка Debugger

В этой закладке устанавливаются параметры дебаггера. Поскольку мы будем использовать ST-Link, здесь ничего менять не придется.

Закладка Download

Здесь устанавливаются параметры загрузки программы в микроконтроллер. Здесь нам тоже ничего менять не надо.

Дебаггер

У Вас есть следующие кнопки для управления дебаггером.

Поэкспериментируйте с ними, чтобы понять как они работают.

В закладке Variables можете наблюдать за значением переменных.

Также можно подвести курсор к переменной и наблюдать в всплывающей подсказке ее значение

Теперь, после первого знакомства с IDE, можно перейти непосредственно к изучению микроконтроллера STM32F103 и написания своих программ.

Источник

Низкоуровневое программирование STM32: от включения питания до «Hello, World»

В этом материале я хочу рассказать о том, как писать программы для микроконтроллеров (Microcontroller Unit, MCU) Cortex-M, вроде STM32, используя лишь набор инструментов ARM и документацию, подготовленную STMicroelectronics. У некоторых читателей может появиться вопрос о том, почему кому-то это может понадобиться. Если вам эта идея, на первый взгляд, не показалась очень уж страшной, то, возможно, вам будет интересно то, о чём пойдёт речь в этом материале. И, кстати, подумаем о том, кому и зачем это может пригодиться.

Конечно, разрабатывать программы для MCU STM32 можно с помощью существующих фреймворков. Это может быть ST HAL, обычный CMSIS, или даже что-то, более близкое к Arduino. Но… что тут увлекательного? Ведь, в итоге, тот, кто пользуется каким-то фреймворком, полностью зависим от документации к нему и от его разработчиков. И, с другой стороны, если документация к STM32 кажется кому-то, работающему с этой платформой, так сказать, бредом сивой кобылы, то можно ли говорить о том, что этот человек по-настоящему понимает данную платформу?

Поэтому давайте поговорим о низкоуровневом программировании STM32 и доберёмся от включения питания STM32 до «Hello, World».

STM32 очень похож на компьютер

На низком уровне микроконтроллер не особенно сильно отличается от полнофункционального компьютера, основанного на процессоре от Intel или AMD. Тут имеется как минимум одно процессорное ядро, инициализирующееся после подачи и стабилизации внешнего питания. В этот момент производится считывание загрузчика, код которого находится по адресу, заранее известному микроконтроллеру. А в обычных компьютерах подобную роль играет BIOS. В случае с MCU это — код, находящийся по определённому смещению в (обычно) интегрированной памяти, предназначенной только для чтения. То, что происходит потом, полностью зависит от этого кода.

Пример Pushy

Возможно, аналогом «Hello, World» для STM32 можно назвать пример из моего фреймворка для STM32 Nodate, который я ласково называю Pushy. Он ещё проще, чем традиционный пример Blinky, так как он использует лишь регистры управления тактированием и сбросом (Reset & Clock Control, RCC) и базовые возможности интерфейса ввода/вывода общего назначения (General-Purpose Input/Output, GPIO). Код этого примера считывает входной регистр GPIO-пина и подстраивает значение на выходном пине в соответствии с входным. Благодаря этому можно, с помощью кнопки, включать и выключать светодиод. Вот код этого примера:

Где именно в этом примере используются регистры группы RCC? В названии этих регистров содержится намёк на то, что они позволяют управлять тактовой частотой MCU. Их можно сравнить с переключателями, которые могут пребывать в двух состояниях — «включено» или «выключено», включая и отключая соответствующие возможности MCU. Если посмотреть, например, на описание регистра RCC_AHBENR в разделе 6.4 руководства по STM32F0xx, то мы увидим бит, маркированный как IOPAEN (Input/Output Port A ENable, включение порта ввода/вывода A), который управляет частотой для периферии, подключённой к GPIO A. То же касается и других портов.

Раздел 6.4.6 руководства по STM32F0xx, описание регистра RCC_AHBENR

Как можно видеть на вышеприведённой иллюстрации, RCC_AHBENR — это регистр, отвечающий за включение AHB. Это — одна из шин внутри MCU, к которой подключены процессорное ядро, SRAM, ROM и периферийные устройства.

Шины AHB (Advanced High-performance Bus) и APB (Advanced Peripheral Bus) описаны в спецификации AMBA фирмы Arm.

Раздел 2.1 руководства по STM32F0xx, архитектура STM32F0xx

В целом можно отметить, что AHB — это более быстрая шина, соединяющая процессорное ядро со SRAM, ROM и с высокоскоростной периферией. Более медленная периферия подключается к более медленной шине APB. Между AHB и APB имеется мост, позволяющий устройствам, подключённым к ним, взаимодействовать друг с другом.

Низкоуровневое программирование

Функция SystemInit() сбрасывает системные регистры, отвечающие за частоту, что приводит к использованию стандартной частоты HSI (High Speed Internal oscillator, высокоскоростной внутренний генератор). После выполнения процедур настройки libc (в данном случае используется Newlib — вспомогательная C/C++-библиотека) она, наконец, вызывает функцию main() следующей командой:

Эта инструкция, название которой расшифровывается как Branch with Link (переход с сохранением адреса возврата), приводит к переходу к заданной метке. В этот момент мы оказываемся в функции main() нашего примера Pushy. После этого в дело вступают возможности класса GPIO.

Класс GPIO

А в других упомянутых семействах MCU имеются отдельные регистры для каждой опции (режим, скорость, повышающий или понижающий резистор, тип):

Запись опций в регистры выполняется с помощью побитовых операций, используемых для записи значений с применением битовых масок. Имена регистров обычно хорошо описывают их предназначение. Например — PUPDR расшифровывается как Pull-Up Pull-Down Register — «регистр управления подтяжкой к плюсу питания или к земле».

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

Для чтения данных с входного пина мы пользуемся IDR (Input Data Register, регистр входных данных) для банка GPIO, с которым работаем:

Аналогично выглядит и использование ODR (Output Data Register, регистр выходных данных), с помощью которого осуществляется вывод данных на пин:

Если периферийное устройство существует (то есть — имеется в CMSIS-заголовке для конкретного MCU, например, для STM32F042), то в структуре GPIO_instance создаётся запись, указывающая на память, соответствующую регистрам этого устройства ( regs ). К этим записям, равно как и к мета-информации, содержащейся в них, потом можно обращаться. Например, можно узнать о состоянии устройства:

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

Класс RCC

Класс RCC тоже интересуется тем, существует ли то или иное периферийное устройство. Делается это для того чтобы избежать разного рода сюрпризов. При этом используются те же определения препроцессора CMSIS. После проверки существования устройства включить его довольно просто:

В дополнение к изменению значения соответствующего бита ( ph.enable ) мы подсчитываем ссылки. Это делается для того чтобы случайно не выключить периферийное устройство, которое используется в другом месте кода.

Запуск примера

Когда кнопка подключена к используемому в коде пину и к Vdd, нажатие на эту кнопку должно зажигать соответствующим образом подключенный к плате светодиод.

Здесь продемонстрирован простой пример низкоуровневого программирования STM32. Освоив его, вы, фактически, находитесь лишь немного «ниже» уровня примера Blinky.

Надеюсь, я смогла показать то, что низкоуровневое программирование STM32 — это совсем несложно.

Какие инструменты вы используете при написании программ для STM32?

Источник

Начинаем писать под stm8, выбираем среды разработки и стартуем

На пути в программировании stm8 есть развилка, о ней сегодня и поговорим.

Определимся что речь будет идти о средах которые могут писать под си. Для начала поговорим о подходах, я выделю 2 основных.

Первый установка ST Visual Develop и выбор в качестве компилятора COSMIC Бывший платный, а ныне бесплатный, но со своими заморочками; регистрация, получение ключа, и прочие танцы с бубном.

Второй же вариант, более простой VS Code + PlatformIO и компилятор SDCC полностью свободный. И опять же не все так просто. Sdcc не умеет исключать не используемые функции. Я решил этот вопрос хоть и успешно, но не без дополнительных действий при написании кода.

Первая среда, для любителей всё делать правильно

Для начала нам нужен ST Visual Develop. Устанавливаем и ставим запуск ярлыка всегда от администратора. В придачу к нему нам дают ST Visual Programmer, полезный инструмент, особенно когда стоит защита от записи и надо разблокировать микроконтроллер, а ведь китайские blue pill всегда приходят заблокированными. Китайцы бояться что мы украдём их круто оптимизированный Blink.

Дальше нужно будет получить компилятор COSMIC и его лицензионный ключ. Заполняем то что просят, получаем дистрибутив и делаем запрос ключа по электронной почте (тут рулетка кому то сразу придёт, кому то придётся подождать).

После пройденного лабиринта из форм и запросов, когда всё уже установлено, начнём

При первом запуске нужно указать расположение ключа, его лучше поместить в директорию компилятора. После создания нажимаем F7, ошибок быть не должно. Если писать на чистых регистрах, то всё готово, но я такой хардкор не люблю, поэтому продолжим и добавим SPL библиотеку.

Теперь когда мы прошлись по верхам давайте пробовать запускать библиотеку. Добавляем в проект из шаблона main и конфигурационный файл в. В include files добавляем всё из STM8S_StdPeriph_Lib\Libraries\STM8S_StdPeriph_Driver\inc.

Теперь всё должно собраться.

Добавим stm8s_gpio.c и соберём простецкую мигалку. У меня один из светодиодов висит на D3, конфигурация ноги на выход выглядит так:

Её вписываем в main до бесконечного цикла.

А вот функция смены состояния. GPIO_WriteReverse(GPIOD, GPIO_PIN_3); вписываем её в бесконечный цикл.

Но вот незадача, в SPL нету функций задержки, скопипастим из примера GPIO в библиотеке. Там она выглядит следующим образом.

Впишем её в конец перед #ifdef USE_FULL_ASSERT. Так же впишем её прототип в начало, где под это выделено место в шаблонном main.

Ну и наконец впишем функцию со значением в бесконечный цикл после функции смены состояния: Delay(0xFFFF);

Подключаем ST-Link и прошиваем, для этого нажимаем Start Debugging и Run. Светодиод моргает значит всё хорошо.

Теперь посмотрим со стороны на эту среду.

По плюсам; у неё есть полноценная отладка, поддержка SPL из коробки. По минусам; она старая из этого вытекает, не очень приятный интерфейс и старый диалект си, на который многие свежие библиотеки придётся переписывать, в частности ставить переменные только вначале функций. Вес кода оставляет желать лучшего. Ну последний камень, этот инструмент может просто взять и вылететь, такое бывает, нечасто, но всё же.

Вторая среда, для тех кто не любит заморачиваться.

Второй подход — это свободный и обновляемый компилятор SDCC, а так же среда PlatformIO.

Для начала установим VS Code и станем рабами Microsoft, далее найдём расширение PlatformIO.

Ждём пока миллион ползунков пройдёт до конца и перезапускаем программу. Открываем расширение (может быть и само откроется). Создаём новый проект и выбираем ближайшую плату с stm8s (микроконтроллер можно будет изменить в конфигурационном файле). В качестве фреймворка выбираем SPL мы же не ардуинщики, нас интересует хардкор.

Разберем поподробнее среду разработки. Во первых весь проект должен лежать в src, иначе среда ведёт себя неадекватно. Во вторых открываем stm8s_conf.h и видим что все библиотеки кроме GPIO закомментированы, если этого не сделать то у мк не хватит памяти что бы поместить весь SPL в микроконтроллер (помните в начале я говорил что он загружает все функции что видит в код?).

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

Каждую функцию я включаю через макрос, для этого у меня переписана большая часть SPL. Если вам оптимизация сильно не нужна, то такой упоротостью можете не заниматься.

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

По минусам: нету полноценной отладки (над ней активно работают, но пока ничего приближённого к cosmic я не видел), в проекте небольшой хаос, раскидать по папкам пока нельзя.

Послевкусие.

Ну и на последок есть ещё среды, варианты и компиляторы, но либо это тот же SDCC вкрученный силой в Eclipse или ещё куда и работающий хуже чем в VS Code, либо это платные варианты IAR, Raisonance. Я лично пользуюсь и тем и тем, но чаще VS Code. Рекомендовать ничего не буду каждому своё, увидимся в комментариях)

Источник

Программирование stm32 с самых основ

В статье я хотел бы описать шаги на пути к написанию прошивки для микроконтроллеров stm32 без использования специальных сред разработки типа keil, eclipse и тому подобных. Я опишу подготовку прошивки с самых основ, начиная с написания загрузчика на ассемблере, скрипта для линкера и заканчивая основной программы на C. В коде на C буду использовать заголовочные файлы из CMSIS. Редактор кода может быть любым на ваш вкус, vim, emacs, блокнот, все что угодно. Для сборки проекта буду использовать утилиту make. Итак, начнем!

Почему так сурово, спросите вы. Во-первых, чтобы что-то хорошо освоить, необходимо начинать с основ. Я не хочу, чтобы мой читатель бездумно щелкал клавишами клавиатуры набирая текст очередной супер-программы для устройства, не понимая, как работает устройство. Stm32 гораздо более сложный микроконтроллер по сравнению, например с atmega8 — atmega328 (микроконтроллером, установленным на самой популярной плате серии arduino). Во-вторых, я люблю сам разбираться в любом деле с нуля, и можно сказать, данная статья — это заметки для меня в будущем, чтобы открыть и вспомнить некоторые нюансы.

Да, я забыл еще сказать, что разработку буду вести под Linux. Подойдет любой дистрибутив, например, у меня это Arch Linux. Для ubuntu процесс установки необходимых утилит я постараюсь описать в следующих частях. Можете попробовать Windows, MacOS, но для этого вам самим придется разобраться, как установить необходимые утилиты для компиляции и прошивки.

Первое, что вам нужно сделать, это приобрести плату для разработки на основе контроллера stm32f103. У меня это blue pill:

Еще одна вещь, необходимая для старта, это программатор st-link:

Плату blue pill и программатор я приобрел на aliexpress, заплатив 200 руб. за все вместе.
Второе, что необходимо сделать, это скачать набор для компиляции кода под arm GNU GCC.

Для arch linux необходимо поставить пакет gcc-arm-none-eabi:

Далее нам понадобится утилита st-link для работы с одноименным программатором st-link2:

Теперь давайте попробуем подключить нашу плату к компьютеру через программатор.

Соединяем программатор с платой blue pill в таком порядке:

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

Теперь давайте проверим характеристики нашей демо-платы. Для этого в терминале запускаем команду st-info из установленного до этого пакета stlink:

На выбор можем посмотреть:

—version — текущая версии утилиты st-info
—flash — выведет информацию о размере flash-памяти программ микроконтроллера, в моем случае это 0x10000 (65536 байт)
—sram — объем статической памяти — 0x5000 (20480 байт)
—descr — описание — F1 Medium-density device
—pagesize — размер страницы памяти — 0x400 (1024 байт)
—hla-serial — «\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x31»
—probe — Found 1 stlink programmers
serial: 303030303030303030303031
openocd: «\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x31»
flash: 65536 (pagesize: 1024)
sram: 20480
chipid: 0x0410
descr: F1 Medium-density device

Из важного для нас — размер flash-памяти и размер статической памяти, а также стоит запомнить что у нас устройство Medium-density.

Не следует начинать разработку без документации под рукой. Во-первых следует скачать с официального сайта Reference Manual. В нем полное описание всей периферии, регистров периферии микроконтроллера. Во-вторых, скачиваем Programmer Manual по той же ссылке. В нем узнаете о микропроцессоре семейства контроллеров STM32F10xxx/20xxx/21xxx/L1xxxx Cortex-M3, его архитектуре, наборе команд.

Далее разберем, с чего вообще начинается исполнение программы на микроконтроллере.

0x2000 0000 + 0x5000 = 0x2000 5000

То есть по адресу 0x0800 0000 мы должны поместить значение 0x2000 5000.
По адресу 0x0800 0004 мы должны положить указатель на начало нашей программы. Каждый указатель имеет размер 4 байта, значит следующий адрес за 0x0800 0004 во flash памяти будет 0x0800 0004 + 4 = 0x0800 0008. Это значение и необходимо поместить по адресу 0x0800 0004.

Так будет выглядеть начальный участок нашей прошивки:

Теперь об одной особенности микроконтроллеров stm32. Дело в том, что формат команд для stm32 должен быть в Thumb представлении вместо стандартного ARM. Это значит, что при указании указателей мы должны прибавлять 1. Запомните это правило.

Хватит теории, пора переходить к практике. Надеюсь, вы еще не спите. Открывайте ваш любимый редактор кода, будем писать начальный файл для запуска нашего контроллера. Мы начнем с startup файла и он будет написан на ассемблере. Это будет единственный раз, когда я заставляю вас писать на скучном ассемблере, зато вы начнете понимать и “чувствовать” устройство изнутри.

Пишем в самом начале:

Это комментарий на языке ассемблера, каждый комментарий начинается с символа @.
Далее указываем директивы ассемблеру

И далее коротенькая bootstrap-программа:

@указатель на вершину стека. Пишем без пробелов!
@.equ директива ассемблера это почти
@тоже что и define в C или на худой конец
@думайте, что это обычное присваивание переменной
.equ StackPointer 0x20005000

А теперь давайте скомпилируем и прошьем нашу плату.

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

Снова вставляем программатор с подключенной платой в usb и запускаем в терминале Linux команду:

Здесь мы указываем, что хотим прочитать в файл default.bin flash-память начиная с адреса 0x08000000 и размером 0x10000 (64K), то есть всю flash-память.

После этого проверим, что прошивка корректно считалась. Загрузим ее вновь, перезаписывая старую.

Что означает записать default.bin в flash память контроллера начиная с адреса 0x08000000.

Выньте и снова вставьте программатор, на плате зеленый диод должен как и раньше мигать.

Теперь давайте скомпилируем нашу самописную прошивку. В терминале в той же директории, что и сохранили запустите:

Здесь мы компилируем наш исходный файл в объектный код. Это еще не готовая прошивка, годная для заливки в микроконтроллер. Нам необходимо еще “указать” куда, по каким адресам размещать нашу программу. Этим занимается компоновщик. Мы воспользуемся самым популярным компоновщиком LD, который входит в поставку пакета arm-none-eabi-gcc. Подробнее о компоновщике и описание скрипта для компоновщика ld я расскажу в следующей части, когда мы перейдем к автоматической сборке нашей супер-простой прошивки. А пока просто скачайте этот маленький файл stm32f103.ld https://bit.ly/2HXIydu, и выполните команду:

Этой командой мы компонуем наш объектный файл с помощью скрипта stm32f103.ld, на выходе получаем elf файл.

Чтобы окончательно подготовить исполнимый elf файл к прошиванию, выполним последнюю команду:

Здесь мы преобразуем elf файл в чистый бинарный формат, пригодный для заливки в нашу плату.

Итак, наша первая программа для контроллера stm32 готова! Прошиваем!

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

Источник