В последние годы 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.
Приветствую всех любителей программирования, микроконтроллеров, да и электроники в целом на нашем сайте! В этой статье немного расскажу о том, чем мы будем заниматься тут, а именно об учебном курсе по микроконтроллерам 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 с нуля!
§> Общие вопросы. Переменные объявляемые пользователем.
Итак, язык 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-ным битом, применив к ней операцию побитного инвертирования: 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 в единицу; Пример использования с регистрами, определенными в CMSIS: DAC0->CTRL |= DAC_CTRL_DIFF; // установка
§> Проверка разрядов регистра на ноль и единицу. Регистры специального назначения микроконтроллеров содержат в своём составе множество битов-признаков, так называемых "флагов”, уведомляющих программу о текущем состоянии микроконтроллера и его отдельных модулей. Проверка логического уровня флага сводится к подбору выражения, которое становится истинным или ложным в зависимости от того установлен или сброшен данный разряд в регистре. Таким выражением может служить логическое "И” между регистром и маской с установленным разрядом N на позиции проверяемого бита:
(REGISTR & (1< Приведённое выражение можно использовать в условном операторе if (выражение) или операторе цикла while (выражение), которые относятся к группе логических, то есть воспринимают в качестве аргументов значения типа истина и ложь. Поскольку язык Си, приводя числовые значения к логическим, любые числа не равные нулю воспринимает как логическую истину, значение (REGISTR & (1< While (!(UCSRA & (1< Здесь при сброшенном бите UDRE выражение (UCSRA & (1<
§> Изменение состояния бита регистра на противоположное. Эту, с позволения сказать, проблему с успехом решает логическая операция побитного "ИСКЛЮЧАЮЩЕГО ИЛИ” и соответствующий ей оператор Си, записываемый в виде символа " ^ ”. Правило "исключающего или" с двумя битами даёт "истину” тогда и только тогда, когда один из битов установлен, а другой сброшен. Не трудно убедиться, что этот оператор, применённый между битовой маской и регистром, скопирует в результат биты стоящие напротив нулевых битов маски без изменения и инвертирует расположенные напротив единичных. Например, если: reg=b0001 0110 и mask=b0000 1111, то reg^mask=b0001 1001. Таким способом можно менять состояние светодиода, подключенного к пятому биту порта A:
#define LED 5 // Заменять в программе сочетание символов LED на число 5 (вывод светодиода).
§> Арифметика и логика языка Си. Мы рассмотрели типичный набор операций, используемый при работе с регистрами микроконтроллера. Помимо них в арсенале языка имеется ряд простейших арифметических и логических операций, описания которых можно найти в любом справочнике по Си, например: Преобразование типов переменных – это часть внутренней автоматической работы компилятора, происходящая в строгом соответствии с правилами языка программирования. Сам разработчик при написании программы в явном виде этим, как правило, не занимается. Однако, неаккуратное объявление типов переменных, или присвоение переменной значения превышающего допустимый диапазон, и даже неправильный формат записи константы, могут привести к потере данных и некорректной работе программы, при полном молчании компилятора.
§> Преобразование типа выражения перед присвоением переменной. В первом разделе мы обращали своё внимание на необходимость явного указания типа объявляемой переменной. Это позволяет компилятору зарезервировать за ней нужное количество адресного пространства и определить диапазон значений, которые она способна хранить. Тем не менее, мы не застрахованы он того, что в процессе выполнения программы произойдёт попытка записать в переменную значение свыше предельно допустимого. В самых грубых случаях компилятор выдаст нам сообщение о возможной ошибке. Например, при желании записать в переменную типа unsigned char (диапазон от 0 до 255) число 400: Unsigned char a=400; // выдаст сообщение типа "integer conversion resulted in truncation” Компилятор предупреждает нас о том, что произошла попытка записать числовое значение, требующее для хранения два байта (400 это 1 в старшем байте и 144 в младшем) в однобайтовую переменную. Однако тех случаях, когда присваиваемое выражение содержит переменные, и компилятор мог бы заметить возможную потерю данных, он освобождает себя от этой обязанности, например: Unsigned char x=200, y=200; При таком варианте, не смотря на то, что значение выражение (x+y) так же равно 400, никаких предупреждений со стороны компилятора уже не последует. А в переменную x запишется только младший байт числа 400, то есть 144. И здесь компилятор трудно в чём-то упрекнуть, ведь вместо явно проинициализированной переменной в выражении может быть использован, например, приёмный регистр шины UART, в котором может оказаться любое значение, принятое от внешнего устройства. Float a=1.5; // Объявлена переменная с плавающей точкой. В результате в переменной b сохранится только целая часть результата a*b – число 4.
§> Преобразование результата выражения к типу наиболее точной переменной в выражении. При таком преобразовании компилятор руководствуется следующим правилом: прежде чем начнется вычисление выражения, операторы с "низшим” типом повышаются до "высших” при этом результат также приводится к ”высшему” типу. Какой тип нужно считать ”высшим”? Тот, который без потери точности может сохранить любое допустимое значение другого типа. Так, в предыдущем примере: Float a =1.5; // Объявлена переменная a с плавающей точкой. В выражении (a*b) переменная float a имеет более высокий тип, потому что может сохранять любое целое значение из диапазона 0…255 типа char. Результат выражения (a*b) будет иметь тип float. Char a=3; // Объявлена целочисленная переменная. В отличие от предыдущего примера, результат записывается в переменную способную хранить числа с плавающей точкой, однако компилятор в соответствии с правилом приведения, получив в результате деления число 0,75 приводит его к типу целочисленных операндов, отбросив дробную часть. В результате в переменную "c” будет записан ноль. Int ADC; // Двухбайтовая целочисленная переменная для хранения кода АЦП. Здесь упущено из виду то, что константа в Си, как и любая переменная, тоже имеет свой тип. Его желательно указывать явно или, используя соответствующую форму записи. Константы 5 и 1024 записаны без десятичной точки и будут восприняты языком Си как целочисленные. Как следствие, результат выражения (5/1024) тоже будет приведён к целому – 0 вместо ожидаемого 0,00489. Это не случилось бы при записи выражения в формате (5.0/1024). C= (float) a/b; // Ожидается, что "c" будет равно 0,75 (¾);
§> Назначение функций. Ещё древние программисты обратили своё внимание на один занимательный факт – зачастую программа вынуждена несколько раз выполнять ровно одну и ту же последовательность действий. Именно тогда родилась идея при достаточно большом наборе таких действий и их повторов, с целью экономии программной памяти, оформлять их в виде отдельной группы, а затем при необходимости просто отправлять программу на её выполнение. Такой обособленный кусок кода в Си как раз и называется функцией. Само название термина "функция” исконно отражает другое свойство некоторых функций – способность (подобно функциям математическим) преобразовывать по заданному алгоритму некие входные данные. Но этом немного позже. Другое назначение функции, полностью отражющее её название – это выделение в отдельную группу действий связанных одной общей целью, например, функция инициализации портов или функция опроса клавиатуры. Это и есть одно из дополнительных предназначений функции. 1. Наличие одинаковых, достаточно больших и многократно повторяющихся наборов действий. Здесь нужно сразу сделать важную оговорку. Дело в том, при каждом переходе на функцию и возврате из неё микроконтроллер вынужден сохранять некоторые системные данные, например адрес программы, с которого произошёл переход в функцию, а это требует дополнительных временных ресурсов. Нужно учитывать этот факт и стараться не плодить в программе множество коротких функций, если есть возможноть объединить их в одну общую.
§> Структура и оформление функций. В любой функции структурно легко выделить две составные части: заголовок и тело функции. Тип выходной переменной Имя функции (Типы входных переменных и их имена через запятую) Временно опустим рассмотрение содержимого заголовка до и после имени и рассмотрим функции, которые не обрабатывают никаких данных. Они предназначены только для выполнения определённых действий. В заголовках таких функций нужно указать названия пустого типа – void (англ. вакуум, пустота): Void имя функции (void) В качестве имени можно использовать любое слово, отражающее смысл выполняемых функцией действий, лишь бы оно не начиналось с цифры. Уже сейчас мы можем вызвать выполнение нашей функции из любого места программы. Для этого нужно записать имя функции, круглые скобки и символ точки с запятой. Например, функцию с заголовком: Initialization (); Тело функции это набор команд расположенный между первой открывающейся фигурной скобкой после заголовка и соответствующей ей закрывающейся фигурной скобкой. Пояснение: наборы действий внутри фигурных скобок в Си принято называть блоками. Они логически связывают несколько одиночных действий в одно сложное, которое либо полностью выполняется, либо полностью игнорируется в зависимости от контекста программы. В данном случае тело функции представляет собой блок команд, которые функция обязана выполнить от начала и до конца. Таким образом, программа, встретив переход на функцию, выполнит содержимое блока и по последней закрывающей скобке вернётся туда, откуда была вызвана. Void initialization (void) Проинициализировав направление выводов портов A, B и С, вернётся в следующую после её вызова строчку.
§> Обработка параметров функцией. Всё функции могут обрабатывать и изменять значения специализированных регистров микроконтроллера и так называемых глобальных переменных, то есть тех, которые объявлены пользователем в самом начале программы вне каких либо функций. Помимо этого имеется возможность передавать данные в функцию для обработки непосредственно в момент её вызова. Это просто удобно и ничего больше. Такое оформление заголовка будет означать, что функция способна принимать в качестве параметров два числа типа char с именами FrameLength и StopBit. Теперь при вызове функции компилятор не позволит оставить круглые скобки пустыми и потребует передачи конкретных значений, через запятую, например: InitUart (8, 2); После этого внутри функции переменным с именами FrameLength и StopBit присвоятся конкретные значении 8 и 2, которые можно использовать, например, для настройки длинны посылки модуля UART и количества его стоп-битов: Void initUart (char FrameLength, char StopBit)
§> Специализированные функции. Мы рассмотрели функции, задаваемые самим пользователем. Помимо них в любой программе присутствуют функции, которые выполняют специализированные задачи и должны быть оформлены по особым правилам. Очевидно, что любая программа представляет собой совокупность действий, описанных в соответствии с правилами языка программирования и предназначенных для исполнения конкретным устройством, в данном случае микроконтроллером. Каков порядок выполнения этих действий на практике, мы и попытаемся уяснить в данном разделе.
§> Общая структура простейшей программы. Инициализация, фон. При рассмотрении программы на уровне языка Си можно сказать, что она начинает свою работу с первой строки функции main (строка 001 на рисунке): Поскольку любая программа предназначена для непрерывной работы, нормальный режим её функционирования - это безостановочное повторение по кругу содержимого бесконечного цикла. На практике такой цикл чаще всего реализуется с помощью конструкции while(1) { }, предназначенной для многократного выполнения действий, размещённых внутри её фигурных скобок. Содержимое бесконечного цикла программы называется фоном. Именно здесь происходит основная часть работы по проверке состояния аппаратной части и соответствующее воздействие на неё для получения нужного результата. Рассмотрим описанную структуру программы на простейшем примере. Пусть необходимо: отправлять по шине UART символ *, пока кнопка на выводе PA0 находится в нажатом состоянии (нулевой уровень сигнала). Программа в данном случае (без лишних процедур по подавлению дребезга кнопки и прочего) может выглядеть так: Void main (void) Здесь конструкция if (...), расположенная в фоне программы проводит бесконечные опросы входного регистра PINA и проверку вывода PA0 на наличие низкого уровня. Далее выполняются другие действия фонового процесса, обозначенные строками 00N, 00N+1 и так далее. Какие факторы, применительно к данной программе, определяют самые важные параметры её работы - надёжность и быстродействие? Из примера видно, что частота опроса входа PA.0 определяется длительностью выполнения команд фона, ведь прежде чем в очередной раз опросить кнопку, микроконтроллер должен выполнить следующие за этим строки 00N, 00N+1 и т. д. Очевидно, что надёжность фиксации внешнего события (нажатия на кнопку) в данном случае будет зависеть от соотношения длительности воздействия этого события к периоду его детектирования. Длительность фона в данной программе наверняка будет во много раз меньше длительности удержания кнопки, которое на практике составляет несколько десятков миллисекунд. Однако при разрастании фоновой части программы и малом времени внешнего воздействия, надёжность его отслеживания в определённый момент резко снизится. Что бы этого не произошло, а также для снижения времени реакции программы на внешнее событие, используется система прерываний.
§> Прерывания. Как работает механизм прерываний? Очень просто, особенно на уровне языка Си! В архитектуру микроконтроллеров AVR, впрочем как и любых других, на аппаратном уровне заложена способность отслеживать определённые "интересные состояния железа” и устанавливать при этом соответствующие биты-признаки. Такие состояния называются условиями возникновения прерываний, а устанавливаемые признаки - флагами прерываний. В процессе работы, микроконтроллер непрерывно отслеживает состояние этих флагов. При обнаружении любого установленного флага прерывания, при условии, что оно разрешено включением соответствующего бита, а также установлен бит глобального разрешения прерываний (№7 в регистре SREG для AVR), выполнение основной части программы будет временно приостановлено (прервано). Поскольку прерывание может возникнуть при выполнении любой произвольной команды фона, её адрес запоминается в так называемом программном стеке. После чего, выполнение предается на часть программы, специально написанную разработчиком для реакции на событие, вызвавшее данное прерывание. Эта небольшая часть программы называется обработчиком прерывания. Когда обработчик будет выполнен до конца, программа, воспользовавшись адресом, сохранённым в программном стеке, вернётся в то место, откуда была вызвана для обработки данного прерывания. Какова роль программиста в этом процессе? При разработке на Си она сведена к минимуму. 1. Разрешить использование прерываний в программе. Применительно к нашему примеру организовать отправку в UART по низкому уровню на входе кнопки, можно используя так называемое внешнее прерывание INT0. Данное прерывание вызывается по фронту, срезу или нулевому уровню на выводе INT0. Перенесем кнопку на вывод PD.2 с альтернативной функцией INT0. В инициализационной части программы разрешим прерывания глобально и INT0 конкретно. Микроконтроллер по-умолчанию настроен на формирование прерывания INT по низкому уровню входного сигнала, поэтому дополнительных настроек не потребуется. Остаётся объявить за пределами функции main обработчик INT0, отправляющий в UART символ *: Void main (void)
#pragma vector=INT0_vect // Обработчик прерывания INT0/ Здесь обработчик прерывания объявлен в формате компилятора IAR. Принципиально в нём только имя вектора прерывания - INT0_vect, компилятор заменяет его на адрес памяти программ, на который передаётся выполнение программы при возникновении данного прерывания. Имя самого обработчика INT0_INTPT выбирается произвольно. Названия векторов всех возможных прерываний для данного МК описаны в h-файлах. Теперь время реакции на нажатие кнопки не зависит от длительности фона программы и составляет несколько тактов микроконтроллера, а вероятность пропустить это событие равна нулю. Таким образом, прерывание – отличный способ реакции на событие, требующее немедленной обработки. Это и есть его главное предназначение. Хочется сразу упомянуть одно негласное правило относительно обработчиков прерываний, хоть это и достаточно узкий вопрос. В них следует размещать только то, что на самом деле необходимо для быстрой реакции на прерывание. Все остальные действия, которые можно отложить, необходимо размещать в фоне. Взято с сайта Данная статья является первой в планируемом цикле статей по изучению программирования микроконтроллеров. Изучая различные материалы я отметил, что практически все они начинаются с того, что новичку предлагается скачать (или использовать идущую со средой разработки) библиотеку для работы с периферийными устройствами и использовать ее для написания своей первой программы (обычно мигание светодиодом). Меня это сильно удивило. Если верить данным статьям, для программирования не обязательно даже читать документацию к программируемому контроллеру. Меня же учили премудростям «железного программирования»
совершенно иначе. В этой статье, путь от фразы «Да, я хочу попробовать!» до радостного подмигивания светодиода, будет значительно длиннее чем у других авторов. Я постараюсь раскрыть аспекты программирования микроконтроллеров, которые прячутся за использованием библиотечных функций и готовых примеров. Будем считать, что с типом микроконтроллера мы разобрались. Но на рынке представлен огромнейший спектр различных модификаций от разных производителей. Они отличаются по множеству параметров - от размера флеш памяти до количества аналоговых входов. Для каждой задачи выбор стоит производить индивидуально. Ни каких общих рекомендаций тут нет и быть не может. Отмечу лишь, что стоит начинать изучение с МК производителей имеющих как можно больший ассортимент. Тогда, при выборе МК для определенной задачи достаточно велик шанс, что из представленного ассортимента вам что-нибудь да подойдет. Я остановил свой выбор на STM32
(хотя и считаю, что лучше начинать изучение с МК от TexasInstruments - очень грамотно составлена документация), потому что они широко распространены среди российских разработчиков электроники. При возникновении проблем и вопросов вы сможете без труда найти решения на форумах. Еще одним плюсом является богатый выбор демонстрационных плат как от производителя, так и от сторонних организаций. Сам я использую демонстрационную плату STM3220G-EVAL
и программатор J-Link PRO
. Но для начала, будет вполне достаточно STM32F4DISCOVERY
, которую можно купить без особых проблем за небольшую сумму. Все примеры будут именно для отладочной платы STM32F4DISCOVERY
. На данном этапе нам будет совершенно не важно, что этой плате стоит МК на базе ядра Cortex-M4. В ближайшее время мы не будем использовать его особенности и преимущества над Cortex-M3. А как там будет дальше - посмотрим. Если у вас есть в наличии любая другая плата на базе STM32F2xx/STM32F4xx, вы сможете работать с ней. В изложении материала я постараюсь максимально подробно описывать почему
мы делаем именно так, а не иначе. Надеюсь ни у кого не возникнет проблем с переносом примеров на другое железо. Почему платная среда разработки?
Возможно, кто-то будет не совсем доволен тем, что я предлагаю использовать платную среду разработки, но в IAR есть возможность получить временную лицензию без ограничения функционала, либо безлимитную лицензию с ограничением по размеру кода (32КБ для МК это очень много). Перед нами появится пустой проект с main файлом. Теперь необходимо настроить проект для начала работы с «нашим» МК и отладчиком. На плате STM32F4DISCOVERY установлен MK STM32F407VG
. Его необходимо выбрать в свойствах проекта (General Options->Target->Device): При выборе целевого программируемого процессора происходит загрузка его описания, что дает широкие возможности для отладки (об этом будет идти речь ниже). Кроме того, автоматически присоединяется конфигурационный файл с описанием доступного адресного пространства для линкера. Если будет необходимо, мы затронем тему конфигурационного файла линкера в следующих статьях. После этого необходимо настроить отладчик. Отладка программы происходит непосредственно «в железе». Производится это с помощью JTAG отладчика. Более подробнее ознакомиться с тем, как это происходит можно на Википедии . На плату STM32F4DISCOVERY интегрирован отладчик ST-LINK/V2. Для работы с отладчиком необходимо выбрать его драйвер в меню Debugger->Setup->Driver
. Так же необходимо указать, что отладка должна производиться непосредственно в железе. Для этого необходимо поставить флаг Debugger->Download->Use flash loader(s)
Для тех, кто увидел слово Simulator
Теоретически, IAR позволяет отлаживать программы с использованием симулятора. Но я ни разу на практике не встречал его использования. Теперь проект готов для работы (программирования, заливки и отладки). Не будем отходить от классики. Первым проектом будет мигающий светодиод. Благо на плате их предостаточно.Что же это означает с точки зрения программирования? Первым делом необходимо изучить принципиальную схему демонстрационной платы и понять как «заводится» светодиод. Простейший анализ схемы говорит о том, что для того, что бы «зажечь» светодиод необходимо на пин МК подать «1» (которая для данного МК соответствует 3.3В). Выключение производится подачей на этот пин «0». На схеме этот пин обозначается PD13
(это, наверное, самая важная информация из этого документа). В итоге, мы можем написать «ТЗ» для нашей первой программы:
Начнем с того, что любой МК включает ядро, память и периферийные блоки. Думаю, что с памятью пока все понятно. Упомяну лишь, в STM32 есть флеш память в которой хранится программа МК (в общем случае это не верное утверждение, программа может храниться во внешней энергонезависимой памяти, но пока это опустим) и другие данные, в том числе и пользовательские. Так же есть SRAM - оперативная память. Ядро - часть микроконтроллера, осуществляющая выполнение одного потока команд. В нашем МК тип ядра - Cortex-M4. Ядро МК можно сравнить с процессором в ПК. Оно умеет только выполнять команды и передавать данные другим блокам (в этом сравнении не учитываются процессоры с интегрированными графическими ускорителями). Периферийные блоки - блоки осуществляющие взаимодействие с «внешним миром» или выполняющие специфические функции, недоступные ядру МК. Современные МК (в том числе и STM32) содержат огромный спектр периферийных блоков. Периферийные блоки предназначены для решения различных задач, от считывания значения напряжения с аналогового входа МК до передачи данных внешним устройствам по шине SPI. Пример
В качестве примера можно привести блок UART, который предназначен для приема и передачи данных от МК внешним устройствам. От ядра необходимо лишь сконфигурировать блок и отдать ему данные для передачи. После этого ядро может дальше выполнять инструкции. На плечи же периферийного блока ложится управление соответствующим выводом МК для передачи данных в соответствии с протоколом. Периферийный блок сам переводит выход МК в необходимое состояние «0» или «1» в нужный момент времени, осуществляя передачу. ВАЖНО:
После записи данных в спецрегистр и последующем чтении вы можете получить совершенно иные данные. Например, передача данных блоку UART для отправки, и считывание данных, полученных блоком от внешнего устройства, осуществляется с помощью одного и того же регистра. Спецрегистры обычно разделены на битовые поля. Один (или несколько) бит управляют определенным параметром периферийного блока, обычно независимо. Например, разные биты одного регистра управляют состоянием разных выходов МК. Запись данных по адресу в памяти
Предположим, что читая описание периферийного блока, мы поняли, что для его корректной работы необходимо записать в него число 0x3B. Адрес спецрегистра 0x60004012. Регистр 32-битный. Значение 0x60004012 есть не что иное, как значение указателя на ячейку памяти. Нужно именно это и указать в нашей программе, тоесть сделать преобразование типов согласно синтаксису языка C: (unsigned long*)(0x60004012)
Таким образом, у нас есть указатель на элемент. Теперь нужно в этот элемент записать необходимое значение. Делается это разыменовыванием указателя. Таким образом получаем правильную команду: *(unsigned long*)(0x60004012) = 0x3B;
Установка произвольных бит в 1
Предположим, что необходимо установить «1» в 7 и 1 биты по адресу 0x60004012, при этом не изменив значение всех остальных бит в регистре. Для этого необходимо использовать бинарную операцию |. Сразу приведу правильный ответ: *(unsigned long*)(0x60004012) |= 0x82;
Обратите внимание на 2 факта. Биты считаются с нулевого, а не с первого. Данная операция на самом деле занимает неменее 3 тактов - считывание значения, модификация, запись. Иногда это не допустимо, поскольку между считыванием и записью значение одного из бит, которые нам запрещено изменять, могло быть изменено периферийным блоком. Незабывайте про эту особенность, иначе могут полезть баги, которые крайне сложно отловить. Установка произвольных бит в 0
Предположим, что необходимо установить «0» в 7 и 1 биты по адресу 0x60004012, при этом не изменив значение всех остальных бит в регистре. Для этого необходимо использовать бинарную операцию &. Сразу приведу правильный ответ: *(unsigned long*)(0x60004012) &= 0xFFFFFF7D;
Или его более простою запись (не переживайте за лишнюю операцию, компилятор все заранее посчитает даже при минимальной оптимизации): *(unsigned long*)(0x60004012) &= (~0x82);
В первую очередь необходимо определиться с какими блоками предстоит работать. Для это достаточно изучит разделы Introduction
и Main features
. Непосредственное управление состоянием пинов МК осуществляется с помощью блока GPIO. Как указано в документации в МК STM32 может быть до 11 независимых блоков GPIO. Различные периферийные блоки GPIO принято называть портами. Порты обозначаются буквам от A до K. Каждый порт может содержать до 16 пинов. Как мы отметили ранее, светодиод подключается к пину PD13. Это означает, что управление этим пином осуществляется периферийным блоком GPIO порт D. Номер пина 13. Ни каких других периферийных блоков на это раз нам не понадобится. За включение тактирования периферийных блоков отвечают регистры RCC XXX peripheral clock enable register
.На месте XXX могут стоять шины AHB1, AHB2, AHB3, APB1 и APB2. После внимательного изучения описания соответствующих регистров, можно сделать вывод о том, тактирование периферийного блока GPIOD включается установкой «1» в третий бит регистра RCC AHB1 peripheral clock enable register (RCC_AHB1ENR)
: Теперь необходимо разобраться с тем, как узнать адрес самого регистра RCC_AHB1ENR
. Замечание:
Описание системы тактирования МК STM32 достойно отдельной статьи. Если у читателей возникнет желание, я подробнее освещу этот раздел в одной из следующих статей. Для получения адреса регистра, необходимо к начальному значению адресного пространства блока RCC прибавить Addr. offset
нужного регистра. Addres offset
указывается и в описании регистра (см. скриншот выше). В итоге, мы определили адрес регистра RCC_AHB1ENR
- 0x4002 3830. Сейчас же наша задача научиться управлять состоянием пинов МК. Перейдем сразу к описанию регистров GPIO. Как видно из описания для совершения требуемой нам настройки необходимо записать значение 01b в 26-27 биты регистра GPIOx_MODER
. Адрес регистра можно определить тем же методом, что описан выше. Используем регистр GPIO port bit set/reset register (GPIOx_BSRR)
Запись «0» или «1» в биты 0-16 приводят к соответствующему изменению состояния пинов порта. Для того, чтобы установить определенное значение на выходе одного или нескольких пинов МК и не изменить состояния остальных, необходимо будет пользоваться операцией модификации отдельных бит. Такая операция выполняется не менее чем за 3 такта. Если же необходимо в часть битов записать 1, а в другие 0, то понадобится не менее 4 тактов. Данный метод предпочтительнее всего использовать для изменения состояния выхода на противоположное, если его изначальное состояние не известно. GPIO port bit set/reset register (GPIOx_BSRR)
В отличии от предыдущего метода, запись 0 в любой из битов данного регистра не приведет ни к чему (да и вообще, все биты write-only!). Запись 1 в биты 0-15 приведет к установке «1» на соответствующем выходе МК. Запись 1 в биты 16-31 приведет к установке «0» на соответствующем выходе МК. Этот метод предпочтительнее предыдущего, если необходимо установить определенное значение на пине «МК», а не изменить его. Для того, чтобы этого избежать, обычно используется счетчик циклов, а переключение состояние пина МК происходит при прохождении программы определенного числа циклов. Но помимо этого, присутствует возможность просмотра значений регистров ядра, спецрегистров периферийных блоков (View->Register) и т.п. Спасибо всем, кто прочитал мой пост, получилось значительно больше чем я ожидал в начале. Все картинки в этой статье кликабельны.
Микроконтроллеры содержат микропроцессорное ядро ARM , точнее ARM Cortex-M. Это ядро присуще не только микроконтроллерам STM32, оно существует само по себе, и на его основе выпускается множество микроконтроллеров от разных производителей. Тогда находим этот микроконтроллер в списке слева и устанавливаем соответствующий пакет DFP: Можно заметить, что среди установленных пакетов есть CMSIS. CMSIS - это библиотека для ядра Cortex-M, общая для всех микроконтроллеров. Библиотека разрабатывается фирмой ARM и доступна для скачивания с официального сайта после регистрации. Можно было бы не устанавливать этот пакет, а пользоваться официальным выпуском библиотеки, но это дополнительные сложности. Закрываем менеджер пакетов и запускаем Keil uVision5 (произносится мю-вижен): Keil uVision5 - это часть MDK-ARM, графический интерфейс среды, который включает редактор кода: Эти настройки довольно спорные. У каждого разработчика свои предпочтения. Теперь создаем проект. Для этого выбираем меню «Project -> New uVision Project…». В открывшемся окне выбираем расположение и имя проекта. Для проекта лучше создать отдельную папку и сохранить проект туда. После сохранения появится окно выбора устройства. Выбираем нужный микроконтроллер и нажимаем «ОК». Если бы мы не установили нужный пакет, то микроконтроллера не было бы в списке: В следующем окне предстоит выбрать компоненты, которые будут использоваться в проекте. Необходимо выбрать «CMSIS:CORE» и «Device:Startup»: После нажатия «OK» процесс создания проекта завершится. В дальнейшем вы всегда сможете запустить окно выбора компонентов, чтобы добавить или удалить их. Для этого надо выбрать меню «Project -> Manage -> Run-Time Evironment…». При выборе компонентов может оказаться, что какой-то компонент зависит от других компонентов, которые вы не выбрали. Об этом вы узнаете из сообщений в нижней части окна. Необходимо будет выбрать зависимые компоненты. После создания проекта описанным способом, в окне справа вы увидите следующую структуру проекта: Здесь мы видим название проекта «example», цель проекта «Target 1», пустую группу файлов «Source Group 1», компоненты CMSIS и Device. Целей проекта может быть сколько угодно. Цель включает в себя важнейшие настройки проекта в том числе выбор микроконтроллера. Цели нужны, чтобы можно было собрать программу разными способами для одних и тех же файлов исходного кода. Например, вам может понадобиться, чтобы проект охватывал множество микроконтроллеров. Группы файлов нужны, чтобы красиво группировать файлы исходного кода. Группы помогают легко ориентироваться в файлах в большом проекте. Например, у вас может быть группа файлов, отвечающих за светодиоды, и отдельная группа с файлами для взаимодействия с USB. В структуре мы видим два файла. Один с расширением «s». Он содержит исходный код на языке ассемблера. Другой с расширением «с». Он содержит исходный код на языке Си. Собрать проект и получить файл прошивки можно нажав клавишу F7. Но в таком виде проект не будет собран и вы получите ошибку, потому что отсутствует функция «main()». Функция «main()» - это точка входа в вашу программу, то с чего начинается программа. Ее наличие обязательно если вы пишите программу на языке Си. Давайте создадим эту функцию. Кликнем на группе «Source Group 1» правой кнопкой и выберем «Add New Item to ‘Source Group 1’…» (перевод: добавить новый элемент в группу ‘Source Group 1’). Создадим файл «main.c»: В созданный файл добавим код: Int main() {
return 0;
}
В конец файла стоит добавить пустую строку, иначе при сборке вы получите предупреждение «warning: #1-D: last line of file ends without a newline». Теперь проект можно собрать клавишей F7. В результате вы получите файл «Objects\example.axf» (по умолчанию имя файла совпадает с именем проекта). Файл располагается в папке с проектом. Обычно разработчику требуется файл прошивки в формате Intel HEX . Чтобы получить его, надо произвести настройку цели. Чтобы увидеть настройки цели нажмите Alt-F7, перейдите на вкладку «Output» и выберите «Create HEX File». После очередной сборки вы получите файл «Objects\example.hex». Сейчас программа не делает ничего, и прошивать ее бессмысленно. Давайте напишем программу, которая управляет состоянием ножки микроконтроллера. Запустим выбор компонентов с помощью меню «Project -> Manage -> Run-Time Evironment…» и выберем компонент «Device:STM32Cube Hal:GPIO». В нижней части окна мы увидим неудовлетворенную зависимость «Device:STM32Cube Hal:Common». Выберем этот компонент и увидим еще больший список зависимостей. Необходимо выбрать все требуемые зависимости: STM32Cube - это библиотека, которую предоставляет STMicroelectronics. При выборе компонентов мы выбираем какие возможности этой библиотеки использовать. Микроконтроллер, кроме ядра, содержит большое количество периферийных устройств: АЦП, ЦАП, таймеры, различные интерфейсы и многое другое. Каждое периферийное устройство имеет свое название. Например, устройство для работы с портами микроконтроллера называется GPIO, об этом можно узнать из документации на микроконтроллер. Библиотека STM32Cube многоуровневая, то есть включает в себя множество промежуточных библиотек. Одна из промежуточных библиотек называется STM32Cube HAL, или просто HAL. Она поделена на модули и каждый модуль соответствует какому-нибудь периферийному устройству. Название модуля совпадает с названием устройства, например, имеется модуль GPIO. Существует большое количество документации по STM32Cube . Но основное описание по работе с периферийными устройствами содержится в . Это руководство разработчик использует большую часть времени. Обратимся к нему, чтобы заставить шевелиться ножки микроконтроллера. Для начала подключим HAL в нашей программе, добавив строчку перед определением функции «main()»:
#include "stm32f4xx_hal.h"
В самом начале функции «main()» вызовем функцию «HAL_Init()», которая инициализирует библиотеку. Таким образом мы получим следующий код в файле «main.c»:
#include "stm32f4xx_hal.h"
int main() {
HAL_Init();
return 0;
}
На этом я вынужден прервать свою статью, так как в данный момент мне не на чем отлаживать программу, то есть нет под рукой отладочной платы. Я написал программу, которая собирается и теоретически должна работать, но я не хочу вводить в заблуждение читателя. Выше изложенный материал считаю полезным и без конечного результата.
#include "stm32f4xx_hal.h"
int main() {
HAL_Init();
// Разрешить тактирование порта A.
__HAL_RCC_GPIOA_CLK_ENABLE();
// Настройки порта.
GPIO_InitTypeDef s;
s.Pin = GPIO_PIN_0; // Вывод 0.
s.Mode = GPIO_MODE_OUTPUT_PP; // Цифровой выход.
s.Pull = GPIO_NOPULL; // Без подтяжки.
s.Speed = GPIO_SPEED_FREQ_VERY_HIGH; // Максимальная скорость.
// Настроить вывод 0 порт A.
HAL_GPIO_Init(GPIOA, &s);
// Бесконечно переключать состояние порта с максимальной скоростью.
while(1) {
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
}
//return 0;
}
void SysTick_Handler(void) {
HAL_IncTick();
}
~(1<
PORTA&=~((1<<2)|(1<<3)); // Выводы 2 и 3 порта A сбросить в ноль.
DAC0->CTRL &= ~DAC_CTRL_DIFF; //сброс
…
PORTA ^=(1<< LED); // Погасить светодиод, если он светится и наоборот.
Для более подробного знакомства с операциями над переменными и языком Си в целом, рекомендую книгу "Язык программирования Си" Б. Керниган, Д. Ритчи.
Когда происходит и в чём заключается приведение типов? Таких ситуаций достаточно много. Рассмотрим наиболее опасные из них.
x=x+y;
Другой пример в этом же духе – присвоение дробного значения переменной целого типа:
b=a*b; // Ожидается, что в переменную b будет записано значение 4,5.
char b=3; // Объявлена целочисленная переменная.
Типичный пример неожиданности для этого случая – попытка получить дробное число делением двух целочисленных:
char b=4; // Объявлена целочисленная переменная.
float c; // Объявлена переменная "c" с плавающей точкой для сохранения результата.
c=a/b; // Ожидается, что "c" будет равно 0,75 (¾).
Более реалистичный пример из жизни – расчёт измеряемого напряжения из выходного кода АЦП:
float U; // Переменная с плавающей точкой для сохранения значения напряжения.
U= ADC*(5/1024); // Расчёт напряжения.
Приведённых ошибок также можно избежать, используя оператор явного приведения типов выражений языка Си, который записывается в виде названия типа, заключённого в круглые скобки и воздействует на выражение стоящее после него. Этот оператор приводит результат выражения к явно указанному типу, не взирая на типы его операндов:
U= ADC * ((float)5/1024); // Расчёт напряжения.
Такие функции могут вызываться программой только один раз. Зачем же тогда они нужны? Для обоснования такого подхода в литературе часто приводится фраза неизвестного, но по всей видимости, очень авторитетного древнеримского программиста: " Разделяй и властвуй!”. И действительно, программа, оформленная в виде целевых функциональных блоков гораздо проще для понимания, отладки и последующей модификации, чем набор отдельных, разрозненных по назначению кусков кода.
Обобщая сказанное, можно сформулировать формальные предпосылки к созданию функций в программе, это:
2. Желание структурировать программу в виде отдельных блоков с общим функциональным назначением.
Заголовок это самая первая строчка любой функции вида:
void initialization (void)
можно вызвать так:
Например, функция:
{
DDRA=0xFF; // PORTA на выход.
DDRB|=(1<<0)| (1<<3)| (1<<4); // PB0, PB3, PB4 на выход.
DDRC=0xF0; // Старшая тетрада PORTC на выход.
}
Для начала также важно знать, что тексте программы каждая функция должна быть расположена отдельно, то есть одна функция не может находиться внутри другой или частично накладываться на неё.
Эти данные называются параметрами, передаваемыми функции. Они должны быть перечислены через запятую вместе с их типами в заголовке функции, внутри круглых скобок после её имени:
{
if (FrameLength==8) UCSR0C|=((1<<1)|(1<<2));
if (StopBit==2) UCSR0C|=(1<<3);
}
Самая главная функция такого рода, как это видно и самого её названия это функция main. Она характеризуется тем, что выполнение передаётся на неё самим микроконтроллером при подаче питания или после перезагрузки, то есть, именно с неё и начинается работа любой программы. Еще одно свойство функции main состоит в том, что при её выполнении до конца программа автоматически перейдёт на её же начало, то есть она выполняется по циклу, если внутри её самим пользователем специально не был организован бесконечный цикл.
Ещё один вариант системных функций – обработчики прерываний. Их так же невозможно вызвать программно. Микроконтроллер самостоятельно передаёт управление на них в случае возникновения особых аппаратных состояний – условий вызова прерываний.
Структкра программы на Си
Далее последовательно выполняются строки 002, 003, 004, объёдинённые одним общим свойством: программа проходит по ним только один раз, при запуске микроконтроллера. Эту часть программы принято называть инициализационной. Инициализационная часть - законное место для размещения действий по подготовке периферии микроконтроллера к работе с заданными параметрами - настройки портов на вход или выход, начальной инициализации таймеров, задания скорости и формата кадра UART и так далее для всего, что планируется использовать в дальнейшем.
{
PORTA|=(1<<0); // Притянуть вход кнопки PORTA.0 внутренним pull-up резистором.
UCSRB = (1<
{
if (! (PINA & (1<<0))) // Если кнопка нажата...
{
while(! (UCSRA & (1<
}
// другие команды фона:
00N
00N+1
...
}
}
Часть действий, как то отслеживание флагов прерываний реализованы на аппаратном уровне. Другую часть, например, защиту от изменений в обработчике важного для программы регистра статуса SREG, сохранение адреса программы в стеке и многое другое компилятор берёт на себя.
Единственное, в чём остаётся необходимость это:
2. Разрешить вызов интересующего нас прерывания специальным битом в соответствующем регистре. Каким именно и где подскажет описание на микроконтроллер.
3. Создать условия для возникновения прерывания, например, если это переполнение таймера, то банально запустить его. Если это прерывание по изменению состояния внешнего вывода то задать нужные условия для этого (фронт, срез или нулевой уровень).
4. Разместить в программе обработчик прерывания, оформив его в соответствии с требованиями компилятора.
{
PORTD|=(1<<2); // Притянуть вход кнопки PORTD.2 внутренним pull-up.
UBRRL=51; // Скорость UART – 9600 bps.
UCSRB = (1<
GICR|=(1<
}
__interrupt void INT0_INTPT()
{
if (! (PIND & (1<<2))) {while(! (UCSRA & (1<
С чем это связано?
Если события, вызывающие прерывание, происходят достаточно часто, то на момент возникновения следующего прерывания слишком длинный обработчик может не успеть выполниться до конца. А это чревато неприятными последствиями в виде потери данных и нарушения нормальной последовательности действий. Например, если необходимо принять по UART некий массив байтов, то в обработчике, который вызывается после приёма каждого из них, не следует заниматься пристальным изучением принятых данных, а только переписывать их с заранее заготовленный массив. А уже после приёма последнего из них, в обработчике можно выставить соответствующий признак (мол, всё принято) и в фоне, обнаружив его, спокойно заняться исследованием всего принятого массива.
http://eugenemcu.ru/
Если вы намерены серьезно изучать программирование микроконтроллеров данная статья для вас. Возможно, она может заинтересовать и тех, кто вдоволь наигрался с Arduino и хочет получить в свои руки все аппаратные возможности железа.Выбор микроконтроллера
Многие могут сказать, что начинать изучение микроконтроллеров лучше с AVR, PIC, 8051 или чего-то еще. Вопрос многогранный и спорный. Я знаю достаточно примеров, когда люди изучив Cortex-M, программировали AVR, ARM7 и т.д. Сам же я начинал с Cortex-M3. Если перед вами стоит определенная задача, в интернете достаточно много информации со сравнением различных типов микроконтроллеров и решаемых с их помощью задач. На хабре этот вопрос тоже поднимался, например .Что необходимо для изучения?
К сожалению, для начала программирования МК не достаточно одного лишь ПК. Придется где-то раздобыть демонстрационную плату и программатор. Хотя это и уменьшает конкуренцию на рынке труда. Среда разработки
Как уже неоднократно упоминалось, для ARM микроконтроллеров существует достаточное количество сред разработки, как платных так и не очень. И снова хочется опустить полемику по этому поводу. Я использую IAR Embedded Workbench for ARM 6.60 . Все примеры будут именно в этой среде. Если вам по душе (или в вашей организации используется) что-то другое (Keil, Eclipse, CCS, CooCoc и т.д.) то это вам тоже не очень помешает. На особенности, связанные именно со средой разработки, я буду обращать отдельное внимание.
Помимо этого, сразу замечу, что для некоторых МК не существует бесплатных сред разработки. И к сожалению эти МК в некоторых областях незаменимы.
Процесс установки я описывать не буду.С чего начать?
Создание проекта
Для начала создадим пустой проект. IAR позволяет создать проекты на ASM, C и C++. Мы будем использовать C.
«ТЗ» для первого проекта
Подведем промежуточный итог:
МК и отладочная плата выбраны, проект подготовлен. Пора определиться с задачей.
доступен на сайте производителя. В данном описании даже есть отдельный раздел про светодиоды на плате -4.4 LEDs
. Для примера, будем использовать User LD3
. Найдем его на схеме:
Программа для МК должна переводить состояние пина МК PD13 из состояния «0» в состояние «1» и обратно с некоторой периодичностью, различимой для человеческого глаза (важное замечание, если моргать светодиодом слишком часто глаз может этого не различить).
Прежде чем приступать к программированию, или немного теории
Прежде чем приступить к реализации нашего ТЗ, необходимо понять как производится управление МК.
При этом производитель МК не разрабатывает ядро. Ядро покупается у компании ARM Limited . Главное отличие между различными МК - в периферии.
В отличии от ядра МК периферийные блоки не выполняют инструкции. Они лишь выполняют команды ядра. При этом участие ядра при выполнении команды не требуется.Взаимодействие ядра с периферийным блоком
Взаимодействие ядра МК с периферийным блоком осуществляется с помощью спецрегистров (есть еще взаимодействие через механизм прерываний и DMA, но об этом в следующих постах). С точки зрения ядра это просто участок памяти с определенным адресом, вот только на самом деле это не так
. Запись данных в спецрегистр эквивалентна передаче команды или данных периферийному блоку. Считывание - получение данных от блока или считывание его состояния. Описание периферийных блоков и их спецрегистров занимает львиную долю описания МК. Вспоминаем С
Если вы гуру в языке C, то можете смело пропускать данный раздел. Он предназначен в первую очередь для тех, кого учили (или ктоучился сам) программировать для ПК. Опыт показывает, что люди часто не помнят важных команд. Здесь я вкратце напомню про побитовые операции и работу напрямую с памятью по ее адресу.
Если вы сразу не знаете как это сделать, попробую описать цепочку рассуждений для получения правильной команды. Некоторые особенности программ для МК
Здесь я постараюсь описать некоторые особенности программ для МК, которые важно помнить. Вещи достаточно очевидные, но все же.
У программы нет конца
В отличии от большинства программ для ПК, программа для МК не должна заканчиваться, НИКОГДА! А что собственно должен будет делать МК после завершения вашей программы? Вопрос, практически, риторический. Поэтому не забываем убедиться в том, что вы не забыли вечный цикл. При желании, можно перевести МК в режим сна.
Пользуйтесь целочисленными переменными
Не смотря на то, что мы используем МК с ядром Cortex-M4, который аппаратно выполняет операции над числами с плавающей точкой, советую вам отказаться от их использования. В МК без поддержки таких операций время вычислений будет просто огромным.
Откажитесь от динамического выделения памяти
Это только совет. Причина проста - памяти мало. Я не раз встречался с библиотеками, в которых были «медленные утечки» памяти. Было очень неприятно, когда после нескольких недель стабильной работы МК зависал с ошибкой. Лучше заранее продумать архитектуру своей программы так, чтобы не пришлось использовать динамическое выделение памяти.
Если же все-таки хочется использовать - внимательно изучите работу менеджера памяти или пишите свой.Приступаем к работе!
Работа над программой для МК всегда начинается с чтения документации. Для нашего МК доступен на сайте производителя. Страниц много, но все читать пока
не нужно. Как уже было сказано, большую часть документации составляет описание периферийных блоков и их регистров. Так же хочу обратить внимание на то, что этот Reference Manual написан не для одного МК, а для нескольких линеек. Это говорит о том, что код будет переносим при переходе на другие МК в этих линейках (если конечно не пытаться использовать периферийные блоки которых нет в используемом МК).Управление тактированием периферийных блоков
Для снижения электропотребления МК практически все периферийные блоки после включения МК отключены. Включение/выключение блока производится подачей/прекращением подачи тактового сигнала на его вход. Для корректной работы, необходимо сконфигурировать контроллер тактового сигнала МК, чтобы необходимому периферийному блоку поступал тактовый сигнал.
Важно:
Периферийный блок не может начать работу сразу
после включения тактового сигнала. Необходимо подождать несколько тактов пока он «запустится». Люди, использующие библиотеки для периферийных устройств, зачастую даже не знают об этой особенности.
Определение адресов спецрегистров
Определение адресов спецрегистров необходимо начинать с чтения раздела Memory map
в Reference manual. Можно заметить, что каждому блоку выделен свой участок адресного пространства. Например, для блока RCC это участок 0x4002 3800 - 0x4002 3BFF:
Блок GPIO
Для общего ознакомления с блоком GPIO я настоятельно рекомендую полностью прочитать соответствующий раздел Reference Manual. Пока можно не особо обращать внимание на Alternate mode
. Это оставим на потом.Режим работы
В первую очередь необходимо установить режим работы 13 пина порта D как General purpose output mode
, что означает что блок GPIO будет управлять состоянием пина МК. Управление режимом работы пинов МК производитсяс помощью регистра GPIO port mode register (GPIOx_MODER) (x = A..I/J/K)
:
Настройка параметров работы выходных пинов порта GPIO
Блок GPIO позволяет применить дополнительные настройки для выходных пинов порта. Данные настройки производятся в регистрах:
Мы не будем менять данных параметров, поскольку нас вполне устраивают значения по умолчанию.Установка значения на пине МК
Наконец-то мы подошли к моменту управления состоянием выхода МК. Для утановки выходного значения на определенном пине МК есть два метода.
Зажигаем светодиод!
Найдя адреса всех необходимых регистров, можно написать программу, которая включает светодиод:
void main()
{
//Enable port D clocking
*(unsigned long*)(0x40023830) |= 0x8;
//little delay for GPIOD get ready
volatile unsigned long i=0;
i++; i++; i++;
i=0;
//Set PD13 as General purpose output
*(unsigned long*)(0x40020C00) = (*(unsigned long*)(0x40020C00)& (~0x0C000000)) | (0x04000000);
//Turn LED ON!
*(unsigned long*)(0x40020C14) |= 0x2000;
while(1);
}
Можно компилировать (Project->Compile
) и заливать (Project->Download->Download active application
). Или запустить отладку (Project->Dpwnload and Debug
) и начать выполнение (F5).
Светодиод загорелся!Мигаем светодиодом
Мигание светодиода есть ни что иное, как попеременное включение и выключение с задержкой между этими действиями. Самый простой способ - поместить включение и выключение в вечный цикл, а между ними вставить задержку.
void main()
{
//Enable port D clocking
*(unsigned long*)(0x40023830) |= 0x8;
//little delay for GPIOD get ready
volatile unsigned long i=0;
i++; i++; i++;
i=0;
//Set PD13 as General purpose output
*(unsigned long*)(0x40020C00) = (*(unsigned long*)(0x40020C00)& (~0x0C000000)) | (0x04000000);
while(1)
{
//Turn LED ON
*(unsigned long*)(0x40020C14) |= 0x2000;
//Delay
for(i=0; i<1000000 ;++i);
//Turn LED OFF
*(unsigned long*)(0x40020C14) &= ~0x2000;
//Delay
for(i=0; i<1000000 ;++i);
}
}
Значение 1000000 в задержке подобрано экспериментально так, чтобы период мигания светодиода был различим глазом, но и не был слишком велик.Оптимизируем алгоритм
Минусом выбранного подхода миганием светодиодом является то, что ядро МК большую часть времени проводит в пустых циклах, хотя мог бы заниматься чем-нибудь полезным (в нашем примере других задач нет, но в будущем они появятся).
void main()
{
//Enable port D clocking
*(unsigned long*)(0x40023830) |= 0x8;
//little delay for GPIOD get ready
volatile unsigned long i=0;
i++; i++; i++;
i=0;
//Set PD13 as General purpose output
*(unsigned long*)(0x40020C00) = (*(unsigned long*)(0x40020C00)& (~0x0C000000)) | (0x04000000);
while(1)
{
i++;
if(!(i%2000000))
{
//Turn LED ON
*(unsigned long*)(0x40020С14) |= 0x2020;
}
else if(!(i%1000000))
{
//Turn LED OFF
*(unsigned long*)(0x40020С14) &= ~0x2000;
}
}
}
Но и тут не обойдется без проблем, с изменением количества команд выполняемых внутри цикла, будет меняться период мигания светодиодом (или период выполнения других команд в цикле). Но на данном этапе мы не можем с этим бороться.Немного об отладке
IAR позволяет осуществлять отладку приложения непосредственно в железе. Все выглядит практически так же, как и отладка приложения для ПК. Есть режим пошагового выполнения, входа в функцию, просмотр значения переменных (В режиме отладки View->Watch->Watch1/4
).
Я настоятельно рекомендую ознакомиться с возможностями дебаггера во время изучения программирования МК.Несколько слов в заключение
Возможно, многие скажут, что ручное прописывание адресов в программе это не правильно, поскольку производитель предоставляет файлы с определениями регистров и битовых полей, библиотеки для работы с периферией и другие инструменты, облегчающие жизнь разработчику. Я с этим полностью согласен, но все равно считаю, что первые шаги в программировании МК необходимо делать перекапывая документацию к вручную, самостоятельно определяя необходимые регистры и битовые поля. В дальнейшем этим можно не пользоваться, но уметь нужно обязательно.
Приведу лишь несколько причин для этого утверждения:
Жду ваших комментариев и аргументированной критики. Если у прочитавших возникнет желание - постараюсь продолжить цикл статей. Возможно у кого-то есть идеи по поводу тем, которые стоило бы осветить - я был бы рад их услышать.
Продолжение следует…
Ссылки