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

Итак, для начала разберемся, что же нужно знать и уметь, чтобы начать изучать ARM’ы. А, в принципе, ничего супер сложного и фееричного 😉 Конечно, на контроллеры ARM люди обычно переходят, уже наигравшись с PIC’ами и AVR’ками, то есть в большинстве своем опытные разработчики. Но я постараюсь максимально подробно и понятно описывать все то, что мы будем разбирать, чтобы те, кто впервые решил попробовать себя в программировании микроконтроллеров, могли легко разобраться в материале. Кстати, если будут возникать какие-нибудь вопросы, или просто что-то будет работать не так, как задумывалось, пишите в комментарии, постараюсь разобраться и помочь.

Теперь перейдем к техническим вопросам) Несколько раз я уже упомянул название «Учебный курс ARM», но, по большому счету, это не совсем верно. Микроконтроллера ARM как такового не существует. Есть контроллер с ядром(!) ARM, а это, согласитесь, все-таки не одно и то же. Так вот, такие девайсы выпускает ряд фирм, среди которых особо выделяются, STMicroelectronics и NXP Semiconductors. Соответственно выпускают они контроллеры STM и LPC. Я остановил свой выбор на STM32, они мне просто больше понравились =) У STM очень подкупает, что разобравшись с любым МК из линейки STM32F10x, не возникнет никаких проблем и с любым другим. Одна линейка – один даташит. Кстати есть огромное количество как дорогих, так и не очень, отладочных плат с контроллерами STM32, что очень радует, хотя первое время будем отлаживать наши программы в симуляторе, чтобы оценить возможности контроллера, прежде чем покупать железо. Вот, на всякий случай, официальный сайт STMicroelectronics – .

Как то плавно выехали на тему компилятора, так что скажу пару слов об этом. Я, недолго думая, выбрал Keil, не в последнюю очередь из-за мощного встроенного симулятора. Можно и на UART там посмотреть, и на любой регистр, и даже логический анализатор имеется в наличии. Словом, у меня Keil оставил в основном только приятные впечатления, хотя есть и минусы, конечно, но не катастрофические. Так что можете смело качать Keil uvision4 с офф. сайта (). Правда есть одно НО – IDE платная, но доступен демо-режим с ограничением кода в 32кБ, которых нам пока с лихвой хватит. Кому этого мало есть огромное количество кряков для Keil’а 😉 Устанавливается все без проблем – пару раз тыкаем далее и все отлично ставится и работает без дополнительных танцев с бубном.

Собственно, вот и все, что я хотел тут рассказать, пора переходить от слов к делу, но это уже в следующей статье. Будем изучать программирование микроконтроллеров STM32 с нуля!

Одна из причин популярности микроконтроллеров STM32 производства STMicroelectronics – разнообразие инструментов разработки и отладки. Это касается как аппаратных, так и программных средств. Существует возможность создания и отладки резидентного ПО для STM32 без материальных затрат с помощью набора бесплатных программ . В статье дан обзор наиболее значимых бесплатных программных инструментов разработки: ST MCU Finder, STM32CubeMX, SW4STM32, STM32 Studio .

Компания STMicroelectronics (ST) является крупнейшим производителем микроконтроллеров в мире, при этом большая часть приходится на семейства STM32. При разработке новых линеек контроллеров STMicroelectronics преследует несколько стратегических целей:

• повышение производительности;
• повышение уровня интеграции: рост объема памяти, расширение перечня периферии;
• снижение потребления;
• снижение стоимости.

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

Дадим краткую характеристику семействам микроконтроллеров STM32 от ST.

Малопотребляющие микроконтроллеры семейств STM32L. Данная группа объединяет семейства, ориентированные, в первую очередь, на достижение минимального уровня потребления. Для этого используются различные методы: динамическое управление напряжением питания, гибкая система тактирования, специализированная периферия (LP-Timer, LP-UART), развитая система режимов пониженного потребления и так далее.

Базовые семейства STM32F0, STM32F1, STM32F3. Данная группа включает семейства со сбалансированными характеристиками и компромиссным значением производительности/потребления/цены.

В свою очередь отдельные пакеты STMCube включают:

• аппаратно независимые библиотеки HAL для работы с аппаратными средствами микроконтроллеров;
• библиотеки промежуточного уровня. Например, в состав самого развитого пакета ПО STM32CubeF7 входят следующие библиотеки и стеки: CMSIS-RTOS на базе FreeRTOS, стек TCP/IP на базе LwIP, файловая система FAT на базе FatFs с поддержкой NAND Flash, StemWin – графический стек на базе SEGGER emWin, полный стек USB (Host и Device). Для ряда семейств доступна библиотека Touch Library для сенсорных приложений;
• примеры и шаблоны проектов для различных сред и отладочных наборов (Discovery, Nucleo, Evaluation Boards).

Чтобы понять, как происходит взаимодействие между составляющими программной платформы STM32Cube, следует обратиться к примеру, представленному на рисунке 9. В этом примере пользователь конфигурирует микроконтроллер STM32F429ZIT с помощью STM32CubeMX. После окончания визуальной настройки (выводов, тактирования и прочего) STM32CubeMX генерирует С-код, для этого используются библиотеки из программного пакета STM32CubeF4. В результате пользователь получает завершенный С-проект, сформированный для конкретной интегрированной среды разработки: IAR™ EWARM, Keil™MDK-ARM, Atollic® TrueSTUDIO и AC6 System Workbench (SW4STM32). В этот проект уже включены все необходимые библиотеки и файлы.

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

• генерируемый С-код охватывает только настройку блоков и периферии микроконтроллера. Это значит, что алгоритмическую часть программы автоматически сгенерировать нельзя, ее нужно будет дописать вручную;
• STM32CubeMX поможет создать только стартовую конфигурацию. Иногда в процессе работы пользователю требуется изменить частоту работы периферийного блока или изменить конфигурацию вывода. Все это придется прописывать самостоятельно;
• для генерации кода используются стандартные, разработанные ST, библиотеки нижнего уровня (HAL и LL) и промежуточного уровня, например, StemWin или STM32_USB_Device_Library;
• в процессе генерации С-файл выстраивается таким образом, что для пользователя выделяются специальные секции, в которые он может помещать свой код. Если пользовательский код окажется вне этих рамок – он будет затерт при следующих генерациях;
• существуют и другие ограничения для отдельных блоков, для более подробного ознакомления с которыми следует обратиться к руководству по STM32CubeMX.

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

Создание простейшей программы с помощью STM32CubeMX

Рассмотрим подробнее создание скелета проекта в среде STM32CubeMX . Для начала требуется скачать саму среду STM32CubeMX. Это можно сделать абсолютно бесплатно с сайта ST. После установки на диске пользователя будут размещены как сам STM32CubeMX, так и папки с библиотеками STM32Cube.

Процесс создания скелета проекта выполняется по шагам.

Шаг первый. Скачивание актуальных версий библиотек с помощью специальной утилиты. Для этого вначале нужно настроить параметры сети (Help → Updater Settings) и далее запустить автоматическое обновление (Help → Check for Updates). Если ПК не подключен к сети – обновлять библиотеки придется вручную.

Шаг второй. После запуска STM32CubeMX на стартовом экране или в меню “File” необходимо создать новый проект, нажав “New Project”. Далее STM32CubeMX предложит выбрать целевую платформу: контроллер с заданными параметрами или отладочную плату. На рисунке 10 в качестве примера демонстрируется, как встроенный поиск подобрал список контроллеров по параметрам: семейство STM32F4, корпус TQFP100, объем Flash не менее 592 кбайт, ОЗУ более 214 кбайт.

Шаг третий. На третьем этапе разработчику предстоит определить назначение выводов с помощью Pin Wizard (рисунок 11). Данная утилита помогает создавать требуемую конфигурацию и проверять ее на ошибки. Стоит отметить и удобную систему подсветки, например, системные выводы закрашиваются бледно-желтым цветом.

Шаг четвертый. Настройка системы тактирования производится с помощью вкладки Clock Configuration (утилита Clock Wizard). При этом пользователь работает с визуализированным деревом тактирования (рисунок 12). С помощью Clock Wizard удается за нескольких щелчков мыши выбрать источник системного тактового сигнала, значения определителей и умножителей, а также источники тактирования периферийных блоков. При написании кода вручную для этого потребовалось бы приложить много усилий.

Шаг пятый. Создание С-кода начинается с выбора целевой интегрированной среды в настройках проекта (Project → Settings). В настоящий момент к услугам пользователя предлагаются: IAR™ EWARM, Keil™MDK-ARM, Atollic® TrueSTUDIO и AC6 System Workbench (SW4STM32) (рисунок 13). Далее на вкладке Code Generator следует определиться с составом копируемых в директорию проекта библиотек, настройками обработки пользовательского кода при регенерации (например, сохранять или удалять), настройками использования HAL (рисунок 13).

Для более детальной настройки генератора следует перейти на вкладку Advanced Settings (рисунок 14). Главной особенностью С-генератора в STM32CubeMX является возможность использования как HAL-, так и LL-драйверов. На этом моменте следует остановиться подробнее.

HAL – набор абстрактных драйверов, обеспечивающих максимальную кроссплатформенность среди контроллеров STM32. При этом некоторые драйверы являются абсолютно универсальными (подходят ко всем контроллерам STM32), а часть применима только к отдельным линейкам с соответствующими периферийными блоками (например, блоками шифрования). Главными достоинствами HAL являются :

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

Вместе с тем, у HAL есть и недостатки: значительный объем кода, недостаточная оптимизация выполнения задач, сравнительно малое быстродействие. Если эти недостатки являются критичными, то следует использовать LL-драйверы.

Low Layer APIs (LL) – аппаратно зависимые драйверы, позволяющие напрямую работать с периферией контроллера, в том числе – использовать inline-функции и выполнять атомарный доступ к регистрам . Такой подход не требует значительных затрат памяти, функции получаются максимально короткими и эффективными по скорости. Очевидными недостатками LL-драйверов являются снижение совместимости кода при переходе от одного контроллера к другому и необходимость глубокого знания особенностей архитектуры контроллера.

В рамках одно и того же проекта на STM32CubeMX можно одновременно использовать как HAL так и LL, но для разных периферийных блоков. Например, на рисунке 15 показаны настройки С-генератора, при которых для UART/TIM/RTC используются LL-драйверы, а для остальных блоков – HAL.

Шаг шестой. После настройки проекта следует выполнить генерацию кода, зайдя в меню Project → Generate Code. В результате этого в указанной директории проекта будет сгенерирован скелет проекта для заданной среды разработки.

Иногда возникает необходимость миграции проекта с одной платформы на другую. С помощью STM32CubeMX это можно сделать с минимальными затратами времени.

Миграция проектов с помощью STM32CubeMX

Для миграции проекта с одной платформы на другую используется дополнительная утилита File → Import Project (рисунок 15). В ней требуется указать тип нового микроконтроллера и режим миграции. После этого программа автоматически генерирует новый код либо, при наличии неполной совместимости ядер, указывает на возникшие сложности, предлагая пользователю их устранить.

Несовместимость, обнаруживаемая при миграции, может быть устранимой и неустранимой. Неустранимый случай возникает, когда состав периферии контроллеров значительно отличается. Например, ранее использовался модуль Ethernet, который отсутствует на новом МК (рисунок 15). Очевидно, что в таком случае миграция невозможна.

Но зачастую несовместимость имеет локальный характер, когда, например, необходимо всего лишь перенастроить параметры дерева тактирования, чтобы согласовать рабочие частоты, либо изменить номер канала АЦП или DMA и так далее (рисунок 16). В таких случаях STM32CubeMX предложит выполнить миграцию в ручном режиме с устранением появившихся сложностей с помощью редактирования проекта в рассмотренных выше утилитах. При этом STM32CubeMX будет сигнализировать пользователю о наличии проблем до их устранения.

После получения итогового скелета проекта останется добавить пользовательскую алгоритмическую часть кода, провести компиляцию и выполнить отладку. Для этого используются специализированные среды. Среда SW4STM32 для STM32 производства компании AC6 позволяет делать это абсолютно бесплатно.

AC6 System Workbench – бесплатная IDE для STM32

Для редактирования, компиляции и отладки программ предназначены специальные интегрированные среды IDE. Большая часть из них является коммерческими продуктами (IAR™ EWARM, Keil™MDK-ARM, Atollic® TrueSTUDIO и другие), но есть и бесплатные инструменты, например, System Workbench производства компании AC6. В рамках системы названий STMicroelectronics данная IDE носит название SW4STM32 .

Интегрированная среда SW4STM32 предназначена для работы с микроконтроллерами STM32. Она основана на базе платформы Eclipse и является бесплатной и кроссплатформенной. Основными ее достоинствами являются :

• поддержка работы с микроконтроллерами STM32, аппаратными отладочными наборами (STM32 Nucleo, Discovery и Evaluation boards), с программными библиотеками (Standard Peripheral library и STM32Cube HAL);
• отсутствие ограничений на объем программного кода;
• бесплатный компилятор GCC C/C++;
• свободный отладчик GDB (проект GNU);
• открытая платформа Eclipse IDE с поддержкой групповой разработки встраиваемого ПО с системой контроля версий SVN/GIT;
• совместимость с плагинами Eclipse;
• поддержка ST-LINK;
• мультиплатформенность и совместимость с Windows®, Linux и OS X®.

С помощью SW4STM32 можно редактировать, компилировать и отлаживать программы для STM32. Для этого удобно использовать скелеты программ, создаваемые в STM32CubeMX. Для их импорта следует выполнить простейшие операции: выбрать меню File -> Import, назначить тип импорта «Existing Projects into Workspace», указать директорию проекта, выбрать сам проект и нажать Finish.

При работе с проектами, созданными в STM32CubeMX, следует размещать пользовательский код в специальных секциях:

/*USER CODE BEGIN…*/

/*USER CODE END…*/

Это необходимо делать, чтобы при повторной генерации кода в STM32CubeMX не произошло затирание рукописной части программы. Повторная генерация необходима в двух случаях:

• при перенастройке используемого МК;
• при миграции с одного МК на другой.

Таким образом, при работе в связке STM32CubeMX + SW4STM32 пользователь может в любой момент перенастроить контроллер и произвести миграцию с сохранением пользовательского кода при минимальных затратах времени.

При отладке программ в SW4STM32 доступна возможность широкого мониторинга состояния памяти, регистров, переменных. Также среда имеет поддержку точек останова (рисунок 17). Для запуска процесса отладки требуется нажать значок “Debug” (в виде жука), выбрать тип проекта “Ac6 STM32 C/C++ Application”, определить тип отладчика и интерфейс, нажать кнопку “OK”.

SW4STM32 имеет поддержку систем контроля версий SVN/GIT. Это важно для больших проектов, над которыми работает несколько разработчиков. Система контроля версий позволяет: регистрировать все изменения, производимые в проекте; сравнивать версии проектов; восстанавливать предыдущие версии; разрешать конфликты при работе нескольких программистов над одним файлом; вести параллельно несколько версий и так далее.

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

Рассмотрим последовательность действий при подключении проекта к SVN (рисунок 18).

• в открытом проекте щелкнуть по его названию на панели директорий правой кнопкой мыши и пройти Team → Share Project(s) (рисунок 18а);
• выбрать тип системы SVN/GIT и нажать “Next” (рисунок 18б);
• выбрать директорию для SVN и нажать “Next” (рисунок 18в);
• выбрать директорию хранения проекта в SVN нажать “Finish” (рисунок 18г);
• на вкладке “General” (рисунок 18д) выбрать URL-адрес SVN, метку для репозитория, имя пользователя, пароль, нажать “Next”;
• ввести комментарий для проекта, выбрать файл, помещаемый под контроль SVN, нажать “OK” (рисунок 18е).

В дальнейшем для синхронизации файла или всего проекта необходимо щелкнуть по его названию на панели директорий правой кнопкой мыши и выбрать Team → Commit. В открывшемся окне следует написать пояснение к изменениям и нажать “OK”.

Для отключения SVN следует использовать команду Team → Disconnect.

Для импорта проекта из SVN применяется команда меню Import → SVN → Project from SVN. Далее требуется выполнить ряд настроек по импорту во всплывающих диалоговых окнах.

SW4STM32 имеет очень широкие возможности, но у среды есть и недостатки, достаточно характерные для бесплатных сред:

• отсутствие встроенного симулятора;
• компилятор GCC проигрывает своим коммерческим собратьям по объему кода и быстродействию;
• поддержка SW4STM32 со стороны разработчиков не будет столь оперативной, как в случае с платными средами.

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

Отладка кода может производиться не только в SW4STM32, но с помощью дополнительных средств. Рассмотрим некоторые из них.

STMStudio – простой способ отладки приложений на STM32

STM Studio – фирменная утилита производства компании STMicroelectronics, которая помогает проводить отладку программы и позволяет отслеживать значения пользовательских переменных при выполнении кода в реальном времени. Данная программа запускается под ОС Windows и использует отладчик ST-LINK для связи с микроконтроллером.

STM Studio имеет следующие возможности :

• чтение переменных из ОЗУ «на лету», без влияния на работу пользовательской программы;
• использование исполнительных файлов.elf, .out, .axf для импорта переменных;
• вывод значений переменных в табличной и графической форме;
• графический вывод в виде графиков или диаграмм;
• возможность вывода зависимостей переменных, когда одна из переменных откладывается по оси Х, а вторая – по оси Y;
• логирование данных в файл для последующего просмотра.

Окно STM Studio состоит из нескольких панелей (рисунок 19).

Работа с STM Studio начинается с импорта переменных. Для этого в программу необходимо загрузить тот же исполнительный файл, что находится в самом микроконтроллере. Для этого подойдут следующие форматы, которые генерируются при компиляции: .elf, .out, .axf. Далее необходимо выполнить команду File → Import variables. В диалоговом окне при выборе пункта “Expand table elements” пользователь сможет вручную выбрать из предлагаемой таблицы любые глобальные переменные. Для запуска отладки необходимо выполнить команду “Run”.

Как говорилось выше, STM Studio позволяет отображать переменные в трех формах: в виде текста, диаграммы и графика (рисунок 20). Настройка типа отображения может быть изменена в любое время. Кроме того, все данные дополнительно записываются в лог-файл для дальнейшего анализа. Интересной особенностью STM Studio является возможность отображения зависимостей одних переменных от других, а также построения выражений из переменных.

Популярным средством передачи отладочной информации является использование консоли и функции вывода printf().

Реализация терминального вывода printf() через USART

Использование стандартной функции printf() – один из наиболее популярных методов вывода отладочной информации. С помощью данной функции вывода пользователь может передавать любые данные на консоль среды разработки или терминал. Большинство интегрированных сред поддерживает эту возможность. При использовании STM32 есть два способа реализации этого метода: традиционный, с помощью UART, и дополнительный, через SWO-интерфейс с помощью отладчика ST-LINK. Реализация каждого из них максимально упрощается при использовании STM32CubeMX и SW4STM32.

Рассмотрим вначале первый вариант реализации – через UART. Для этого придется выполнить следующую последовательность действий:

• обеспечить аппаратное подключение к ПК;
• выполнить настройку UART в среде STM32CubeMX;
• реализовать саму функцию printf() в среде SW4STM32.

Подключение к ПК можно выполнить тремя путями: через COM-порт и микросхему приемопередатчика RS-232; через USB-порт и микросхему конвертера UART-USB (например, FT232); с помощью USB-интерфейса отладчика ST-LINK. Вне зависимости от того, какой способ выбран, далее необходимо сконфигурировать аппаратный UART.

C помощью STM32CubeMX настройка UART выполняется в несколько кликов (рисунок 21). Сначала на вкладке Pin Wizard соответствующие выводы контроллера переводятся в режим работы UART. Далее во вкладке “Configuration” настраиваются параметры UART: тип обмена, скорость, наличие стоп-битов и так далее. После этого генерируется С-код.

В среде SW4STM32 необходимо подключить стандартную библиотеку и определить функции _io_putchar() и _write(), например, так:

/*USER CODE BEGIN Includes*/

#include

/*USER CODE END Includes*/

/*USER CODE BEGIN 1*/

int __io_putchar(int ch)

c = ch & 0x00FF;

HAL_UART_Transmit(&huart2,&*c,1,10);

int _write(int file, char *ptr, int len)

for (DataIdx = 0; DataIdx < len; DataIdx++)

Достоинствами такого подхода к передаче отладочной информации можно считать:

• использование интерфейса UART, который присутствует во всех микроконтроллерах STM32 без исключения;
• простоту настройки и привычность для программистов. Можно использовать старые наработки из проектов с другими контроллерами;
• отсутствие сложного аппаратного обеспечения (за исключением моста UART-USB или приемопередатчика RS-232);
• отсутствие сложного ПО. Работа производится со всеми IDE или терминальными программами.

Однако есть у этого метода и недостатки. Во-первых, придется пожертвовать каналом UART для отладки. А во-вторых, такая реализация влияет на работу контроллера, так как занимает ядро для обработки кода функции printf(). В случае с STM32 есть более специализированный, а главное – простой способ, который не занимает ресурсы микроконтроллера – использование связки SWO и ST-LINK.

Реализация терминального вывода printf() через SWO

При использовании связки SWO и ST-LINK создание терминального ввода/вывода оказывается еще проще, чем в рассмотренном выше методе с аппаратным UART. В этом случае связь с ПК осуществляется через интерфейс SWO и USB-интерфейс, используемый в ST-LINK. Последовательность действий остается примерно той же, что и в предыдущем случае.

Сначала с помощью STM32CubeMX происходит настройка выводов SWO-интерфейса во вкладках “Pin Wizard” и “Configuration” (рисунок 22). После этого происходит перегенерация кода для среды разработки.

Следующий шаг заключается в написании кода обработчика __io_putchar(int ch), например, так:

/*USER CODE BEGIN 1*/

int __io_putchar(int ch)

ITM_SendChar(ch);

/*USER CODE END 1*/

Для отладки удобно использовать утилиту STLink Utility (рисунок 23).

Достоинства метода:

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

Из недостатков этого метода реализации можно отметить аппаратную зависимость, так как требуется наличие ST-LINK.

Заключение

Компания STMicroelectronics выпускает более семисот моделей микроконтроллеров STM32, которые отличаются по производительности/потреблению/цене/уровню интеграции. Каждый пользователь сможет подобрать себе оптимальную модель с учетом требований конкретного приложения.

Важным преимуществом STM32 является наличие развитой системы средств отладки. К услугам разработчиков предлагается более ста отладочных плат (Nucleo, Discovery, Evaluation Boards). Еще большим подспорьем для программистов станет наличие полного набора бесплатного прикладного ПО для создания, компиляции и отладки программного кода:

ST MCU Finder – приложение для смартфонов, помогающее выбрать наиболее оптимальный МК для конкретного приложения;

STM32CubeMX – кроссплатформенный графический редактор для конфигурирования микроконтроллеров STM32 и автоматической генерации кода. STM32CubeMX также способен оказать помощь при выборе оптимального микроконтроллера, оценить потребляемую мощность и упростить миграцию проекта между различными МК.

SW4STM32 – кросплатформенная интегрированная среда разработки встраиваемого ПО для микроконтроллеров STM32.

STM32 Studio – утилита для отслеживания и графической визуализации значений переменных при выполнении кода в реальном времени.

ST-LINK Utility позволяет совместно с программатором ST-Link выполнять ввод и вывод отладочной информации через SWO-интерфейс.

Данный набор ПО позволяет выполнить полный цикл разработки резидентного ПО, не потратив ни единого рубля.

Литература

1. Data brief. NUCLEO-XXXXKX. STM32 Nucleo-32 board. Rev 3. ST Microelectronics, 2016.
2. Data brief. NUCLEO-XXXXRX. STM32 Nucleo-64 board. Rev 8. ST Microelectronics, 2016.
3. Data brief. NUCLEO-XXXXZX. STM32 Nucleo-144 board. Rev 5. ST Microelectronics, 2017.
4. UM1718. User manual. STM32CubeMX for STM32 configuration and initialization C code generation. Rev 18. ST Microelectronics, 2017.
5. Виктор Чистяков. CUBEMX И WORKBENCH: СОЗДАНИЕ ПРОЕКТА НА БАЗЕ STM32 С ПОМОЩЬЮ БЕСПЛАТНОГО ПО. Новости Электроники №2/2016.
6. UM1884. User manual. Description of STM32L4 HAL and Low-layer drivers. Rev 5. ST Microelectronics, 2016.
7. UM1025. User manual. Getting started with STM-STUDIO. Rev6. ST Microelectronics, 2013.
8. UM0892.User manual STM32 ST-LINK utility software description. Rev 22. ST Microelectronics, 2016.

О компании ST Microelectronics

§> Общие вопросы. Переменные объявляемые пользователем.

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

Основной объект программирования для классического Си - переменная. Это может быть одиночная или группа особым образом связанных переменных, например, массив или структура. По сути переменная представляет из себя некое хранилище для числа, имеющее своё уникальное имя и допустимый диапазон значений, выходить за пределы которого крайне нежелательно. И первое что мы должны сделать перед тем как начать использовать имя переменной в тексте программы это познакомить программу с её свойствами. В языке Си этот процесс называется объявлением переменной.

Зачем нужно объявлять переменные?

Хоть язык Си и абстрактный, используемый разработчиком микроконтроллер, как правило, вполне конкретный и имеет своё адресное пространство памяти с заданными свойствам, где и будет храниться объявляемая переменная. Объявление, помимо присвоения переменной имени, заставляет компилятор разместить её по конкретному адресу в памяти микроконтроллера (по какому именно нас в большинстве случаев совершенно не интересует).

Как нужно объявлять переменные?

Правило для объявления можно формулировать так: до того как мы впервые употребим имя переменной в тексте нашей программы, необходимо размесить её объявление в следующем формате:

Type name; // Переменная с именем "name" и типом "type".

Здесь: type - так называемый идентификатор типа переменной из определённого набора стандартных типов;
name - произвольное имя переменной, лишь бы оно не начиналось с цифры, состояло только из латинских символов, и не совпадало со служебными словами языка Си (список которых не так велик, чтобы столкнуться с такой ситуацией нужно на самом деле очень постараться).

Что такое идентификатор типа и зачем его упоминать?

Для хранения переменной микроконтроллер использует ячейки памяти, размер которых определяется его разрядностью. Так например, микроконтроллеры семейства AVR - 8-разрядные, а значит для хранения данных используют ячейки памяти размером в один байт, которые способны сохранять 256 различных числовых значений. Если ожидаемые значения переменной могут превысить это количество, то для её хранения понадобится две или более ячеек памяти. Поскольку Си, строго говоря, не представляет какие значения мы планируем присваивать переменной, то просит нас указать её тип, который как раз и определяет допустимый диапазон значений. Это необходимо чтобы не зарезервировать за ней избыточный или недопустимо малый объём памяти, а так же предупреждать нас при попытке присвоить слишком большое значение переменной, не способной его сохранить. Для 8-разрядных микроконтроллеров наиболее часто употребимые целочисленные типы данных следующие:

Способные хранить только положительные значения (беззнаковые):
unsigned char - занимает один байт памяти, значения 0...255
unsigned int - два байта, значения 0...65535
unsigned long - четыре байта, от 0 до (2^32)-1
способные хранить значения со знаком (знаковые):
signed char - занимает один байт памяти, от -128...127
signed int - два байта, значения -32768...32767
signed long - требует четыре байта, значения от -(2^31) до (2^31)

Ключевое слово "unsigned" (беззнаковое), вообще говоря, можно не употреблять, поскольку в Си по умолчанию тип, для которого не указан этот признак, считается беззнаковым.
Для работы с дробными числами в Си предусмотрены типы с плавающей точкой:

Float – 32 бита, значения от ±1.18E-38 до ±3.39E+38
double – 32 (±1.18E-38…±3.39E+38) или 64 бита (±2.23E-308…±1.79E+308) в зависимости от настроек компилятора.

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

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

Например:

Int A=100; // Переменная с именем "А" типом int и начальным значением равным 100.

Практический пример: пусть планируется написать программу, мигающую светодиодом 5 раз. Для подсчёта числа миганий потребуется переменная, значение которой, очевидно никогда не будет отрицательным и не выйдет за пределы диапазона от 0 до 255, а значит в данном случае будет вполне достаточно использовать однобайтовый тип char:

§> Область видимости переменной.

Источником многих затруднений для начинающих становится свойство языка, которое называется областью видимости объявленной переменной. Язык Си имеет возможность ограничить действие переменной конкретной областью программного кода, при этом в других частях программы она становится недоступной, благодаря чему высвобождается память, которая на других участках программы может использоваться другими переменными. Такие переменные называются локальными, а их использование - основной способ получения экономичного кода.

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

§> Область размещения переменной.

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

Для хранения пользовательских переменных может быть использована ОЗУ, энергонезависимая память EEPROM, а для хранения констант, значение которых не может быть изменено в процессе работы программы также и FLASH- память микроконтроллера.

Для начала полезно знать, что переменные, объявленные пользователем без использования специальных ключевых слов типа _eeprom или _flash, размещаются в ОЗУ микроконтроллера, в виде одной или нескольких ячеек статической памяти SRAM. В процессе работы они периодически копируются в быструю регистровую память РОН, которая непосредственно взаимодействует с арифметически-логическим блоком АЛУ микроконтроллера.
Вопросы размещения переменных внутри ОЗУ, как правило, представляют интерес только в контексте быстродействия программы.

§> Регистры специального назначения микроконтроллера SFR.

Итак, мы кратко рассмотрели объявление переменных предназначенных для организации вычислительного процесса, которые мало связаны со спецификой аппаратной части МК.

Управление и контроль работы микроконтроллера и его отдельных внутренних модулей осуществляется путём записи и чтения специальных ячеек-регистров в служебной области памяти ОЗУ - регистров специального назначения (Special Function Register, далее просто SFR).

Основная идея, позволяющая использовать Си для программирования микроконтроллеров, такова: регистры специального значения являются такими же переменными языка Си, как и объявленные пользователем. Этим переменным можно присваивать значения, управляя работой микроконтроллера, или считывать их, получая таким образом информацию о его текущем состоянии. Объявлять регистры микроконтроллера подобно пользовательским переменным не нужно по нескольким причинам. Во-первых, их размер заранее известен: в Си для AVR это беззнаковые 8-разрядные переменные. Во-вторых, SFR имеют строго определённые имена и адреса в памяти, являясь так называемыми регистрами ввода-вывода.

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

В начале любой программы на Си мы можем видеть строки типа:

#include "file1.h" // Включить в код содержимое файла "file1.h".

#include - это директива (указание), заставляющая среду разработки поместить в данное место программы содержимое файла с именем file1.h. Файлы с расширением.h называются заголовочными или h-файлами. Разработчик может создавать собственные h-файлы и помещать их, учитывая содержимое, в любое место программы. Однако, чтобы познакомить программу с SFR для данного типа микроконтроллера, необходимо подключать вполне конкретные заголовочные файлы. Их имена и количество зависит от конкретной среды разработки и типа используемого микроконтроллера, так, например, в IAR для Atmega64 достаточно прописать строки:

#include "iom64"
#include "inavr.h"

После включения в текст необходимых h-файлов программа будет узнавать упоминаемые в ней имена SFR, например, регистр статуса микроконтроллера AVR с именем SREG, буфер приёма/передачи модуля UART - UDR и так далее.

Заготовка программы для IAR, которая ничего не делает, но уже не "ругается" на имена регистров специального назначения микроконтроллера Atmega16, должна выглядеть так:

#include "iom16.h"
#include "inavr.h"
unsigned char ChisloMiganiy=0;
void main (void)
{
// Здесь мы разместим программу, использующую переменную ChisloMiganiy
// и любые регистры Atmega16, имена которых прописаны в файле iom16.h.
}

Хочется надеяться, что читатель знаком с правилами оформления комментариев в тексте программы. Это заметки, которые игнорируются языком Си и не считаются частью программного кода, если записаны в одной и более строках, заключённых между символами /* и */, или в одной строке, начинающейся с последовательности //.

§> Обзор стандартных операций с регистрами.

Настало время перейти к более серьёзным операциям над регистрами и программными переменными. Управление работой микроконтроллера в большинстве случаев сводится к следующему простому набору действий с его регистрами:

1. Запись в регистр необходимого значения.
2. Чтение значения регистра.
3. Установка в единицу нужных разрядов регистра.
4. Сброс разрядов регистра в ноль.
5. Проверка разряда на логическую единицу или логический ноль.
6. Изменение логического состояния разряда регистра на противоположное.

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

A = 16; // Присвоить переменной A значение 16;
A = B; // Считать значение переменной B и присвоить это значение переменной A;
A = B+10; // Считать значение переменной B, прибавить к считанному значению 10, результат присвоить переменной A (значение переменной B при этом не изменяется).

§> Запись и чтение регистров.

Из рассмотренных примеров видно, что оператор присваивания сам по себе решает две первые задачи — запись и чтение значений регистров. Например для отправки микроконтроллером AVR байта по шине UART достаточно записать его в передающий регистр с именем UDR:

UDR = 8; // Отправить по UART число 8;

Чтобы получить принятый по UART байт достаточно считать его из регистра UDR:

§> Установка битов регистров.

Язык Си не имеет в своём составе команд непосредственного сброса или установки разрядов переменной, однако присутствуют побитовые логические операции "И" и "ИЛИ", которые успешно используются для этих целей.
Оператор побитовой логической операции "ИЛИ" записывается в виде вертикальной черты - "|" и может выполнятся между двумя переменными, а так же между переменной и константой. Напомню, что операция "ИЛИ" над двумя битами даёт в результате единичный бит, если хотя бы один из исходных битов находится с состоянии единицы. Таким образом для любого бита логическое "ИЛИ" с "1" даст в результате "1", независимо от состояния этого бита, а "ИЛИ" с логическим "0" оставит в результате состояние исходного бита без изменения. Это свойство позволяет использовать операцию "ИЛИ" для установки N-ого разряда в регистре. Для этого необходимо вычислить константу с единичным N-ным битом по формуле 2^N, которая называется битовой маской и выполнить логическое "ИЛИ" между ней и регистром, например для установки бита №7 в регистре SREG:

(SREG | 128) — это выражение считывает регистр SREG и устанавливает в считанном значении седьмой бит, далее достаточно изменённое значение снова поместить в регистр SREG:

SREG = SREG | 128; // Установить бит №7 регистра SREG.

Такую работу с регистром принято называть "чтение - модификация - запись", в отличие от простого присваивания она сохраняет состояние остальных битов без именения.
Приведённый программный код, устанавливая седьмой бит в регистре SREG, выполняет вполне осмысленную работу - разрешает микроконтроллеру обработку программных прерываний. Единственный недостаток такой записи — в константе 128 не легко угадать установленный седьмой бит, поэтому чаще маску для N-ного бита записывают в следующем виде:

(1<

SREG = SREG | (1<<7);

Или ещё проще с использование краткой формы записи языка Си:

SREG |= (1<<7);

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

§> Сброс битов в регистрах.

Ещё одна логическая операция языка Си – побитовое "И", записывается в виде символа "&". Как известно, операция логического "И", применительно к двум битам даёт единицу тогда и только тогда, когда оба исходных бита имеют единичное значение, это позволяет применять её для сброса разрядов в регистрах. При этом используется битовая маска, в которой все разряды единичные, кроме нулевого на позиции сбрасываемого. Её легко получить из маски с установленным N-ным битом, применив к ней операцию побитного инвертирования:
~(1<

SREG = SREG & (~ (1<<7)); или кратко: SREG &= ~ (1<<7);

В упомянутом ранее заголовочном файле для конкретного микроконтроллера приведены стандартные имена разрядов регистров специального назначения, например:

#define OCIE0 1

Здесь #define – указание компилятору заменять в тексте программы сочетание символов "OCIE0" на число 1, то есть стандартное имя бита OCIE0, который входит в состав регистра TIMSK микроконтроллера Atmega64 на его порядковый номер в этом регистре. Благодаря этому установку бита OCIE0 в регистре TIMSK можно нагляднее записывать так:

TIMSK|=(1<

Устанавливать или сбрасывать несколько разрядов регистра одновременно можно, объединяя битовые маски в выражениях оператором логического "ИЛИ":

PORTA |= (1<<1)|(1<<4); // Установить выводы 1 и 4 порта A в единицу;
PORTA&=~((1<<2)|(1<<3)); // Выводы 2 и 3 порта A сбросить в ноль.

Пример использования с регистрами, определенными в CMSIS:

DAC0->CTRL |= DAC_CTRL_DIFF; // установка
DAC0->CTRL &= ~DAC_CTRL_DIFF; //сброс

§> Проверка разрядов регистра на ноль и единицу.

Регистры специального назначения микроконтроллеров содержат в своём составе множество битов-признаков, так называемых "флагов”, уведомляющих программу о текущем состоянии микроконтроллера и его отдельных модулей. Проверка логического уровня флага сводится к подбору выражения, которое становится истинным или ложным в зависимости от того установлен или сброшен данный разряд в регистре. Таким выражением может служить логическое "И” между регистром и маской с установленным разрядом N на позиции проверяемого бита:

(REGISTR & (1<

Приведённое выражение можно использовать в условном операторе if (выражение) или операторе цикла while (выражение), которые относятся к группе логических, то есть воспринимают в качестве аргументов значения типа истина и ложь. Поскольку язык Си, приводя числовые значения к логическим, любые числа не равные нулю воспринимает как логическую истину, значение (REGISTR & (1< Если появляется необходимость при установленном бите N получить для нашего выражения логическое значение «ложь», достаточно дополнить его оператором логической инверсии в виде восклицательного знака - !(REGISTR & (1<

While (!(UCSRA & (1<

Здесь при сброшенном бите UDRE выражение (UCSRA & (1< !(UCSRA & (1<

§> Изменение состояния бита регистра на противоположное.

Эту, с позволения сказать, проблему с успехом решает логическая операция побитного "ИСКЛЮЧАЮЩЕГО ИЛИ” и соответствующий ей оператор Си, записываемый в виде символа " ^ ”. Правило "исключающего или" с двумя битами даёт "истину” тогда и только тогда, когда один из битов установлен, а другой сброшен. Не трудно убедиться, что этот оператор, применённый между битовой маской и регистром, скопирует в результат биты стоящие напротив нулевых битов маски без изменения и инвертирует расположенные напротив единичных. Например, если: reg=b0001 0110 и mask=b0000 1111, то reg^mask=b0001 1001. Таким способом можно менять состояние светодиода, подключенного к пятому биту порта A:

#define LED 5 // Заменять в программе сочетание символов LED на число 5 (вывод светодиода).
…
PORTA ^=(1<< LED); // Погасить светодиод, если он светится и наоборот.

§> Арифметика и логика языка Си.

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

Для более подробного знакомства с операциями над переменными и языком Си в целом, рекомендую книгу "Язык программирования Си" Б. Керниган, Д. Ритчи.

Преобразование типов переменных – это часть внутренней автоматической работы компилятора, происходящая в строгом соответствии с правилами языка программирования. Сам разработчик при написании программы в явном виде этим, как правило, не занимается. Однако, неаккуратное объявление типов переменных, или присвоение переменной значения превышающего допустимый диапазон, и даже неправильный формат записи константы, могут привести к потере данных и некорректной работе программы, при полном молчании компилятора.
Когда происходит и в чём заключается приведение типов? Таких ситуаций достаточно много. Рассмотрим наиболее опасные из них.

§> Преобразование типа выражения перед присвоением переменной.

В первом разделе мы обращали своё внимание на необходимость явного указания типа объявляемой переменной. Это позволяет компилятору зарезервировать за ней нужное количество адресного пространства и определить диапазон значений, которые она способна хранить. Тем не менее, мы не застрахованы он того, что в процессе выполнения программы произойдёт попытка записать в переменную значение свыше предельно допустимого. В самых грубых случаях компилятор выдаст нам сообщение о возможной ошибке. Например, при желании записать в переменную типа unsigned char (диапазон от 0 до 255) число 400:

Unsigned char a=400; // выдаст сообщение типа "integer conversion resulted in truncation”

Компилятор предупреждает нас о том, что произошла попытка записать числовое значение, требующее для хранения два байта (400 это 1 в старшем байте и 144 в младшем) в однобайтовую переменную. Однако тех случаях, когда присваиваемое выражение содержит переменные, и компилятор мог бы заметить возможную потерю данных, он освобождает себя от этой обязанности, например:

Unsigned char x=200, y=200;
x=x+y;

При таком варианте, не смотря на то, что значение выражение (x+y) так же равно 400, никаких предупреждений со стороны компилятора уже не последует. А в переменную x запишется только младший байт числа 400, то есть 144. И здесь компилятор трудно в чём-то упрекнуть, ведь вместо явно проинициализированной переменной в выражении может быть использован, например, приёмный регистр шины UART, в котором может оказаться любое значение, принятое от внешнего устройства.
Другой пример в этом же духе – присвоение дробного значения переменной целого типа:

Float a=1.5; // Объявлена переменная с плавающей точкой.

b=a*b; // Ожидается, что в переменную b будет записано значение 4,5.

В результате в переменной b сохранится только целая часть результата a*b – число 4.

§> Преобразование результата выражения к типу наиболее точной переменной в выражении.

При таком преобразовании компилятор руководствуется следующим правилом: прежде чем начнется вычисление выражения, операторы с "низшим” типом повышаются до "высших” при этом результат также приводится к ”высшему” типу. Какой тип нужно считать ”высшим”? Тот, который без потери точности может сохранить любое допустимое значение другого типа. Так, в предыдущем примере:

Float a =1.5; // Объявлена переменная a с плавающей точкой.
char b=3; // Объявлена целочисленная переменная.

В выражении (a*b) переменная float a имеет более высокий тип, потому что может сохранять любое целое значение из диапазона 0…255 типа char. Результат выражения (a*b) будет иметь тип float.
Типичный пример неожиданности для этого случая – попытка получить дробное число делением двух целочисленных:

Char a=3; // Объявлена целочисленная переменная.
char b=4; // Объявлена целочисленная переменная.
float c; // Объявлена переменная "c" с плавающей точкой для сохранения результата.
c=a/b; // Ожидается, что "c" будет равно 0,75 (¾).

В отличие от предыдущего примера, результат записывается в переменную способную хранить числа с плавающей точкой, однако компилятор в соответствии с правилом приведения, получив в результате деления число 0,75 приводит его к типу целочисленных операндов, отбросив дробную часть. В результате в переменную "c” будет записан ноль.
Более реалистичный пример из жизни – расчёт измеряемого напряжения из выходного кода АЦП:

Int ADC; // Двухбайтовая целочисленная переменная для хранения кода АЦП.
float U; // Переменная с плавающей точкой для сохранения значения напряжения.
U= ADC*(5/1024); // Расчёт напряжения.

Здесь упущено из виду то, что константа в Си, как и любая переменная, тоже имеет свой тип. Его желательно указывать явно или, используя соответствующую форму записи. Константы 5 и 1024 записаны без десятичной точки и будут восприняты языком Си как целочисленные. Как следствие, результат выражения (5/1024) тоже будет приведён к целому – 0 вместо ожидаемого 0,00489. Это не случилось бы при записи выражения в формате (5.0/1024).
Приведённых ошибок также можно избежать, используя оператор явного приведения типов выражений языка Си, который записывается в виде названия типа, заключённого в круглые скобки и воздействует на выражение стоящее после него. Этот оператор приводит результат выражения к явно указанному типу, не взирая на типы его операндов:

C= (float) a/b; // Ожидается, что "c" будет равно 0,75 (¾);
U= ADC * ((float)5/1024); // Расчёт напряжения.

§> Назначение функций.

Ещё древние программисты обратили своё внимание на один занимательный факт – зачастую программа вынуждена несколько раз выполнять ровно одну и ту же последовательность действий. Именно тогда родилась идея при достаточно большом наборе таких действий и их повторов, с целью экономии программной памяти, оформлять их в виде отдельной группы, а затем при необходимости просто отправлять программу на её выполнение. Такой обособленный кусок кода в Си как раз и называется функцией. Само название термина "функция” исконно отражает другое свойство некоторых функций – способность (подобно функциям математическим) преобразовывать по заданному алгоритму некие входные данные. Но этом немного позже.

Другое назначение функции, полностью отражющее её название – это выделение в отдельную группу действий связанных одной общей целью, например, функция инициализации портов или функция опроса клавиатуры. Это и есть одно из дополнительных предназначений функции.
Такие функции могут вызываться программой только один раз. Зачем же тогда они нужны? Для обоснования такого подхода в литературе часто приводится фраза неизвестного, но по всей видимости, очень авторитетного древнеримского программиста: " Разделяй и властвуй!”. И действительно, программа, оформленная в виде целевых функциональных блоков гораздо проще для понимания, отладки и последующей модификации, чем набор отдельных, разрозненных по назначению кусков кода.
Обобщая сказанное, можно сформулировать формальные предпосылки к созданию функций в программе, это:

1. Наличие одинаковых, достаточно больших и многократно повторяющихся наборов действий.
2. Желание структурировать программу в виде отдельных блоков с общим функциональным назначением.

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

§> Структура и оформление функций.

В любой функции структурно легко выделить две составные части: заголовок и тело функции.
Заголовок это самая первая строчка любой функции вида:

Тип выходной переменной Имя функции (Типы входных переменных и их имена через запятую)

Временно опустим рассмотрение содержимого заголовка до и после имени и рассмотрим функции, которые не обрабатывают никаких данных. Они предназначены только для выполнения определённых действий. В заголовках таких функций нужно указать названия пустого типа – void (англ. вакуум, пустота):

Void имя функции (void)

В качестве имени можно использовать любое слово, отражающее смысл выполняемых функцией действий, лишь бы оно не начиналось с цифры. Уже сейчас мы можем вызвать выполнение нашей функции из любого места программы. Для этого нужно записать имя функции, круглые скобки и символ точки с запятой. Например, функцию с заголовком:
void initialization (void)
можно вызвать так:

Initialization ();

Тело функции это набор команд расположенный между первой открывающейся фигурной скобкой после заголовка и соответствующей ей закрывающейся фигурной скобкой. Пояснение: наборы действий внутри фигурных скобок в Си принято называть блоками. Они логически связывают несколько одиночных действий в одно сложное, которое либо полностью выполняется, либо полностью игнорируется в зависимости от контекста программы. В данном случае тело функции представляет собой блок команд, которые функция обязана выполнить от начала и до конца. Таким образом, программа, встретив переход на функцию, выполнит содержимое блока и по последней закрывающей скобке вернётся туда, откуда была вызвана.
Например, функция:

Void initialization (void)
{
DDRA=0xFF; // PORTA на выход.
DDRB|=(1<<0)| (1<<3)| (1<<4); // PB0, PB3, PB4 на выход.
DDRC=0xF0; // Старшая тетрада PORTC на выход.
}

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

§> Обработка параметров функцией.

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

Такое оформление заголовка будет означать, что функция способна принимать в качестве параметров два числа типа char с именами FrameLength и StopBit. Теперь при вызове функции компилятор не позволит оставить круглые скобки пустыми и потребует передачи конкретных значений, через запятую, например:

InitUart (8, 2);

После этого внутри функции переменным с именами FrameLength и StopBit присвоятся конкретные значении 8 и 2, которые можно использовать, например, для настройки длинны посылки модуля UART и количества его стоп-битов:

Void initUart (char FrameLength, char StopBit)
{
if (FrameLength==8) UCSR0C|=((1<<1)|(1<<2));
if (StopBit==2) UCSR0C|=(1<<3);
}

§> Специализированные функции.

Мы рассмотрели функции, задаваемые самим пользователем. Помимо них в любой программе присутствуют функции, которые выполняют специализированные задачи и должны быть оформлены по особым правилам.
Самая главная функция такого рода, как это видно и самого её названия это функция main. Она характеризуется тем, что выполнение передаётся на неё самим микроконтроллером при подаче питания или после перезагрузки, то есть, именно с неё и начинается работа любой программы. Еще одно свойство функции main состоит в том, что при её выполнении до конца программа автоматически перейдёт на её же начало, то есть она выполняется по циклу, если внутри её самим пользователем специально не был организован бесконечный цикл.
Ещё один вариант системных функций – обработчики прерываний. Их так же невозможно вызвать программно. Микроконтроллер самостоятельно передаёт управление на них в случае возникновения особых аппаратных состояний – условий вызова прерываний.

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

§> Общая структура простейшей программы. Инициализация, фон.

При рассмотрении программы на уровне языка Си можно сказать, что она начинает свою работу с первой строки функции main (строка 001 на рисунке):

Структкра программы на Си
Далее последовательно выполняются строки 002, 003, 004, объёдинённые одним общим свойством: программа проходит по ним только один раз, при запуске микроконтроллера. Эту часть программы принято называть инициализационной. Инициализационная часть - законное место для размещения действий по подготовке периферии микроконтроллера к работе с заданными параметрами - настройки портов на вход или выход, начальной инициализации таймеров, задания скорости и формата кадра UART и так далее для всего, что планируется использовать в дальнейшем.

Поскольку любая программа предназначена для непрерывной работы, нормальный режим её функционирования - это безостановочное повторение по кругу содержимого бесконечного цикла. На практике такой цикл чаще всего реализуется с помощью конструкции while(1) { }, предназначенной для многократного выполнения действий, размещённых внутри её фигурных скобок. Содержимое бесконечного цикла программы называется фоном. Именно здесь происходит основная часть работы по проверке состояния аппаратной части и соответствующее воздействие на неё для получения нужного результата.

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

Void main (void)
{
PORTA|=(1<<0); // Притянуть вход кнопки PORTA.0 внутренним pull-up резистором.

UCSRB = (1< while (1)
{
if (! (PINA & (1<<0))) // Если кнопка нажата...
{
while(! (UCSRA & (1< UDR = " * "; // Отправить *.
}
// другие команды фона:
00N
00N+1
...
}
}

Здесь конструкция if (...), расположенная в фоне программы проводит бесконечные опросы входного регистра PINA и проверку вывода PA0 на наличие низкого уровня. Далее выполняются другие действия фонового процесса, обозначенные строками 00N, 00N+1 и так далее.

Какие факторы, применительно к данной программе, определяют самые важные параметры её работы - надёжность и быстродействие?

Из примера видно, что частота опроса входа PA.0 определяется длительностью выполнения команд фона, ведь прежде чем в очередной раз опросить кнопку, микроконтроллер должен выполнить следующие за этим строки 00N, 00N+1 и т. д. Очевидно, что надёжность фиксации внешнего события (нажатия на кнопку) в данном случае будет зависеть от соотношения длительности воздействия этого события к периоду его детектирования. Длительность фона в данной программе наверняка будет во много раз меньше длительности удержания кнопки, которое на практике составляет несколько десятков миллисекунд. Однако при разрастании фоновой части программы и малом времени внешнего воздействия, надёжность его отслеживания в определённый момент резко снизится. Что бы этого не произошло, а также для снижения времени реакции программы на внешнее событие, используется система прерываний.

§> Прерывания.

Как работает механизм прерываний? Очень просто, особенно на уровне языка Си!

В архитектуру микроконтроллеров AVR, впрочем как и любых других, на аппаратном уровне заложена способность отслеживать определённые "интересные состояния железа” и устанавливать при этом соответствующие биты-признаки. Такие состояния называются условиями возникновения прерываний, а устанавливаемые признаки - флагами прерываний. В процессе работы, микроконтроллер непрерывно отслеживает состояние этих флагов. При обнаружении любого установленного флага прерывания, при условии, что оно разрешено включением соответствующего бита, а также установлен бит глобального разрешения прерываний (№7 в регистре SREG для AVR), выполнение основной части программы будет временно приостановлено (прервано).

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

Какова роль программиста в этом процессе? При разработке на Си она сведена к минимуму.
Часть действий, как то отслеживание флагов прерываний реализованы на аппаратном уровне. Другую часть, например, защиту от изменений в обработчике важного для программы регистра статуса SREG, сохранение адреса программы в стеке и многое другое компилятор берёт на себя.
Единственное, в чём остаётся необходимость это:

1. Разрешить использование прерываний в программе.
2. Разрешить вызов интересующего нас прерывания специальным битом в соответствующем регистре. Каким именно и где подскажет описание на микроконтроллер.
3. Создать условия для возникновения прерывания, например, если это переполнение таймера, то банально запустить его. Если это прерывание по изменению состояния внешнего вывода то задать нужные условия для этого (фронт, срез или нулевой уровень).
4. Разместить в программе обработчик прерывания, оформив его в соответствии с требованиями компилятора.

Применительно к нашему примеру организовать отправку в UART по низкому уровню на входе кнопки, можно используя так называемое внешнее прерывание INT0. Данное прерывание вызывается по фронту, срезу или нулевому уровню на выводе INT0.

Перенесем кнопку на вывод PD.2 с альтернативной функцией INT0. В инициализационной части программы разрешим прерывания глобально и INT0 конкретно. Микроконтроллер по-умолчанию настроен на формирование прерывания INT по низкому уровню входного сигнала, поэтому дополнительных настроек не потребуется. Остаётся объявить за пределами функции main обработчик INT0, отправляющий в UART символ *:

Void main (void)
{
PORTD|=(1<<2); // Притянуть вход кнопки PORTD.2 внутренним pull-up.
UBRRL=51; // Скорость UART – 9600 bps.
UCSRB = (1< SREG|=(1<<7); // Разрешить прерывания.
GICR|=(1< while (1){}
}

#pragma vector=INT0_vect // Обработчик прерывания INT0/
__interrupt void INT0_INTPT()
{
if (! (PIND & (1<<2))) {while(! (UCSRA & (1< }

Здесь обработчик прерывания объявлен в формате компилятора IAR. Принципиально в нём только имя вектора прерывания - INT0_vect, компилятор заменяет его на адрес памяти программ, на который передаётся выполнение программы при возникновении данного прерывания. Имя самого обработчика INT0_INTPT выбирается произвольно. Названия векторов всех возможных прерываний для данного МК описаны в h-файлах.

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

Хочется сразу упомянуть одно негласное правило относительно обработчиков прерываний, хоть это и достаточно узкий вопрос. В них следует размещать только то, что на самом деле необходимо для быстрой реакции на прерывание. Все остальные действия, которые можно отложить, необходимо размещать в фоне.
С чем это связано?
Если события, вызывающие прерывание, происходят достаточно часто, то на момент возникновения следующего прерывания слишком длинный обработчик может не успеть выполниться до конца. А это чревато неприятными последствиями в виде потери данных и нарушения нормальной последовательности действий. Например, если необходимо принять по UART некий массив байтов, то в обработчике, который вызывается после приёма каждого из них, не следует заниматься пристальным изучением принятых данных, а только переписывать их с заранее заготовленный массив. А уже после приёма последнего из них, в обработчике можно выставить соответствующий признак (мол, всё принято) и в фоне, обнаружив его, спокойно заняться исследованием всего принятого массива.

Взято с сайта
http://eugenemcu.ru/

В последние годы 32 разрядные микроконтроллеры (МК) на основе процессоров ARM стремительно завоёвывают мир электроники. Этот прорыв обусловлен их высокой производи тельностью, совершенной архитектурой, малым потреблением энергии, низкой стоимостью и развитыми средствами программирования.

КРАТКАЯ ИСТОРИЯ
Название ARM является аббревиатурой Advanced RISC Machines, где RISC (Reduced Instruction Set Computer) обозначает архитектуру процессоров с сокращённым набором команд. Подавляющее число популярных МК, а пример семейства PIC и AVR, также имеют архитектуру RISC, которая позволила увеличить быстродействие за счёт упрощения декодирования инструкций и ускорения их выполнения. Появление совершенных и производительных 32 разрядных ARMмикроконтроллеров позволяет перейти к решению более сложных задач, с которыми уже не справляются 8 и 16 разрядные МК. Микропроцессорная архитектура ARM с 32 разрядным ядром и набором команд RISC была разработана британской компанией ARM Ltd, которая занимается исключительно разработкой ядер, компиляторов и средств отладки. Компания не производит МК, а продаёт лицензии на их производство. МК ARM – один из быстро развивающихся сегментов рынка МК. Эти приборы используют технологии энергосбережения, поэтому находят широкое применение во встраиваемых системах и доминируют на рынке мобильных устройств, для которых важно низкое энергопотребление. Кроме того, ARM микроконтроллеры активно применяются в средствах связи, портативных и встраиваемых устройствах, где требуется высокая производительность. Особенностью архитектуры ARM является вычислительное ядро процессора, не оснащённое какими либо дополнительными элементами. Каждый разработчик процессоров должен самостоятельно до оснастить это ядро необходимыми блоками под свои конкретные задачи. Такой подход хорошо себя зарекомендовал для крупных производителей микросхем, хотя изначально был ориентирован на классические процессорные решения. Процессоры ARM уже прошли несколько этапов развития и хорошо известны семействами ARM7, ARM9, ARM11 и Cortex. Последнее делится на подсемейства классических процессоров CortexA, процессоров для систем реального времени CortexR и микропроцессорные ядра CortexM. Именно ядра CortexM стали основой для разработки большого класса 32 разрядных МК. От других вариантов архитектуры Cortex они отличаются, прежде всего, использованием 16разрядного набора инструкций Thumb2. Этот набор совмещал в себе производительность и компактность «классических» инструкций ARM и Thumb и разрабатывался специально для работы с языками С и С++, что существенно повышает качество кода. Большим достоинством МК, построенных на ядре CortexM, является их программная совместимость, что теоретически позволяет использовать программный код на языке высокого уровня в моделях разных производителей. Кроме обозначения области применения ядра, разработчики МК указывают производительность ядра CortexM по десятибалльной шкале. На сегодняшний день самыми популярными вариантами являются CortexM3 и CortexM4. МК с архитектурой ARM производят такие компании, как Analog Devices, Atmel, Xilinx, Altera, Cirrus Logic, Intel, Marvell, NXP, STMicroelectronics, Samsung, LG, MediaTek, MStar, Qualcomm, SonyEricsson, Texas Instruments, nVidia, Freescale, Миландр, HiSilicon и другие.
Благодаря оптимизированной архитектуре стоимость МК на основе ядра CortexM в некоторых случаях даже ни же, чем у многих 8разрядных приборов. «Младшие» модели в настоящее время можно приобрести по 30 руб. за корпус, что создаёт конкуренцию предыдущим поколениям МК. МИКРОКОНТРОЛЛЕРЫ STM32 Рассмотрим наиболее доступный и широко распространённый МК семейства STM32F100 от компании STMicroelectronics , которая является одним из ведущих мировых производителей МК. Недавно компания объявила о начале производства 32битного МК, использующего преимущества индустриального
ядра STM32 в недорогих приложениях. МК семейства STM32F100 Value line предназначены для устройств, где не хватает производительности 16разрядных МК, а богатый функционал «обычных» 32разрядных приборов является избыточным. Линейка МК STM32F100 базируется на современном ядре ARM CortexM3 с периферией, оптимизированной для применения в типичных приложениях, где использовались 16разрядные МК. Производительность МК STM32F100 на тактовой частоте 24 МГц превосходит большинство 16разрядных МК. Данная линейка включает приборы с различными параметрами:
● от 16 до 128 кбайт флэшпамяти программ;
● от 4 до 8 кбайт оперативной памяти;
● до 80 портов ввода вывода GPIO;
● до девяти 16разрядных таймеров с расширенными функциями;
● два сторожевых таймера;
● 16канальный высокоскоростной 12разрядный АЦП;
● два 12разрядных ЦАП со встроенными генераторами сигналов;
● до трёх интерфейсов UART с поддержкой режимов IrDA, LIN и ISO7816;
● до двух интерфейсов SPI;
● до двух интерфейсов I2С с поддержкой режимов SMBus и PMBus;
● 7канальный блок прямого доступа к памяти (DMA);
● интерфейс CEC (Consumer Electronics Control), включённый в стандарт HDMI;
● часы реального времени (RTC);
● контроллер вложенных прерываний NVIC.

Функциональная схема STM32F100 представлена на рисунке 1.

Рис. 1. Архитектура МК линейки STM32F100

Дополнительным удобством является совместимость приборов по выводам, что позволяет, при необходимости, использовать любой МК семейства с большей функциональностью и памятью без переработки печатной платы. Линейка контроллеров STM32F100 производится в трёх типах корпусов LQFP48, LQFP64 и LQFP100, имеющих, соответственно, 48, 64 и 100 выводов. Назначение выводов представлено на рисунках 2, 3 и 4. Такие корпуса можно устанавливать на печатные платы без применения специального оборудования, что является весомым фактором при мелкосерийном производстве.

Рис. 2. МК STM32 в корпусе LQFP48 Рис. 3. МК STM32 в корпусе LQFP64

Рис. 4. МК STM32 в корпусе LQFP100

STM32F100 – доступный и оптимизированный прибор, базирующийся на ядре CortexM3, поддерживается развитой средой разработки МК семейства STM32, которая содержит
бесплатные библиотеки для всей пе риферии, включая управление двига телями и сенсорными клавиатурами.

СХЕМА ВКЛЮЧЕНИЯ STM32F100C4
Рассмотрим практическое использование МК на примере самого простого прибора STM32F100C4, который, тем не менее, содержит все основные блоки линейки STM32F100. Принципиальная электрическая схема включения STM32F100C4 представлена на рисунке 5.


Рис. 5. Схема включения МК STM32F100C4

Конденсатор С1 обеспечивает сброс МК при включении питания, а конденсаторы С2-С6 фильтруют напряжение питания. Резисторы R1 и R2 ограничивают сигнальный ток выводов МК. В качестве источника тактовой частоты используется внутренний генератор, поэтому нет необходимости применять внешний кварцевый резонатор.


Входы BOOT0 и BOOT1 позволяют выбрать способ загрузки МК при включении питания в соответствии с таб лицей. Вход BOOT0 подключён к шине нулевого потенциала через резистор R2, который предохраняет вывод BOOT0 от короткого замыкания при его использовании в качестве выход ного порта PB2. С помощью соединителя J1 и одной перемычки можно из менять потенциал на входе BOOT0, определяя тем самым способ загрузки МК – из флэшпамяти или от встроенного загрузчика. При необходимости загрузки МК из оперативной памяти аналогичный соединитель с перемычкой можно подключить и к входу BOOT1.
Программирование МК осуществляется через последовательный порт UART1 или через специальные программаторы – отладчики JTAG или STLink. Последний входит в состав популярного отладочного устройства STM32VLDISCOVERY , изображённого на рисунке 6. На плате STM32VLDIS COVERY 4контактный разъём программатора – отладчика STLink – имеет обозначение SWD. Автор статьи предлагает программировать МК через последовательный порт UART1, поскольку это значительно проще, не требует специального оборудования и не уступает в скорости JTAG или ST Link. В качестве управляющего устройства, способного формировать команды и отображать результаты работы про граммы МК, а также в качестве программатора можно использовать любой персональный компьютер (ПК), имеющий последовательный COM порт или порт USB с преобразователем USBRS232.

Для сопряжения COMпорта ПК с МК подойдет любой преобразователь сиг налов RS232 в уровни логических сигналов от 0 до 3,3 В, например, микросхема ADM3232. Линия передачи TXD последовательного порта компьютера, после преобразователя уровней, должна подключаться к входу PA10 микроконтроллера, а линия приёмника RXD, через аналогичный преобразователь, – к выходу PA9.

При необходимости использования энергонезависимых часов МК, к нему следует подключить элемент питания типа CR2032 с напряжением 3 В и кварцевый резонатор на частоту 32768 Гц. Для этого МК оснащён выводами Vbat/GND и OSC32_IN/OSC32_OUT. Предварительно вывод Vbat необходимо отключить от шины питания 3,3 В.

Оставшиеся свободными выводы МК можно использовать по необходимости. Для этого их следует подключить к разъёмам, которые расположены по периметру печатной платы для МК, по аналогии с популярными устройствами Arduino и отладочной платой STM32VLDISCOVERY .


Рис. 6. Отладочное устройство STM32VLDISCOVERY

Схема электрическая принципиальная STM32VLDISCOVERY.

Таким образом, в зависимости от назначения и способа применения МК, к нему можно подключать необходимые элементы, чтобы задействовать другие функциональные блоки и пор ты, например, ADC, DAC, SPI, I2C и т.п. В дальнейшем эти устройства будут рас смотрены подробнее.

ПРОГРАММИРОВАНИЕ
Сегодня многие компании предлагают средства для создания и отладки программ микроконтроллеров STM32. К их числу относятся Keil от ARM Ltd, IAR Embedded Workbench for ARM, Atol lic TrueStudio, CooCox IDE, GCC и Eclipse IDE. Разработчик может выбрать про граммные средства по своему пред почтению. Ниже будет описан инструментарий Keil uVision 4 от компании Keil , который поддерживает огромное число типов МК, имеет развитую систему отладочных средств и может быть использован бесплатно с ограничениями размера генерируемого кода 32 кбайт (что, фактически, максимально для рассматриваемых МК).

Простой и быстрый старт с CooCox CoIDE.

Итак приступим. Идем на официальный сайт CooCox и качаем последнюю версию CooCox CoIDE . Для скачивания необходимо зарегистрироваться, регистрация простая и бесплатная. Затем инсталлируем скачанный файл и запускаем.

CooCox CoIDE — среда разработки, на базе Eclipse, которая помимо STM32 поддерживает кучу других семейств микроконтроллеров: Freescale, Holtek, NXP, Nuvoton, TI, Atmel SAM, Energy Micro и др. С каждой новой версией CoIDE список МК постоянно пополняется. После успешной установки CoIDE запускаем:

Появится стартовое окно Step 1, в котором необходимо выбрать производителя нашего микроконтроллера. Нажимаем ST и переходим к Step 2 (выбор микроконтроллера), в котором необходимо выбрать конкретную модель. У нас STM32F100RBT6B, поэтому нажимаем на соответствующую модель:

Справа, в окне Help отображаются краткие характеристики каждого чипа. После выбора нужного нам микроконтроллера переходим к третьему шагу Step 3 — к выбору необходимых библиотек для работы:

Давайте создадим простейший проект для мигания светодиодом, как это принято для изучения микроконтроллеров.

Для этого нам понадобится библиотека GPIO, при включении которой, CoIDE попросит создать новый проект. На это предложение нажимаем Yes, указываем папку где будет храниться наш проект и его название. При этом, CoIDE подключит к проекту 3 другие, необходимые для работы библиотеки, а также создаст всю необходимую структуру проекта:

Чем еще хорош CoIDE, это тем, что в нем есть возможность загружать примеры прямо в среду разработки. В вкладке Components вы можете видеть, что почти к каждой библиотеке есть примеры, нажимаем на GPIO (with 4 examples) и видим их:

Туда можно добавлять и свои примеры. Как видно на скриншоте выше, в примерах уже присутствует код для мигания светодиодом GPIO_Blink. Можно нажать кнопку add и он добавиться в проект, но как подключаемый файл, поэтому мы сделаем по другому просто скопируем весь код примера в файл main.c. Единственное, строку void GPIO_Blink(void) замените на int main(void). Итак, нажимаем F7 (или в меню выбираем Project->Build), чтобы скомпилировать проект и… не тут то было!

Среде нужен компилятор GCC, а у нас его нет. Поэтому идем на страничку GNU Tools for ARM Embedded Processors , справа выбираем тип вашей ОС и качаем последнюю версию тулчайна. Затем запускаем файл и инсталируем gcc toolchain. Далее, в настройках CoIDE укажем правильный путь к тулчайну:

Опять нажимаем F7 (Project->Build) и видим, что компиляция прошла успешно:

Осталось прошить микроконтроллер. Для этого при помощи USB подключаем нашу плату к компьютеру. Затем, в настройках дебаггера необходимо поставить ST-Link, для этого в меню выбираем Project->Configuration и открываем вкладку Debugger. В выпадающем списке выбираем ST-Link и закрываем окно:

Попробуем прошить МК. В меню выбираем Flash->Program Download (или на панели инструментов щелкаем по соответствующей иконке) и видим, что МК успешно прошит:

На плате наблюдаем мигающий светодиод, видео или фото я думаю приводить нет смысла, т.к. все это видели.

Также, в CoIDE работают различные режимы отладки, для этого нажимаем CTRL+F5 (или в меню Debug->Debug):

На этом все. Как видите, настройка среды CoIDE и работа с ней очень проста. Надеюсь данная статья подтолкнет вас в изучении очень перспективных и недорогих микроконтроллеров STM32.