Недавно коллега меня подсадил на идею создания умного дома, я даже успел заказать себе десятки разных датчиков. Встал вопрос о выборе Микроконтроллера (далее МК) или платы. После некоторых поисков нашёл несколько вариантов. Среди них были и Arduino (включая его клоны, один из которых себе заказал ради того, чтобы просто побаловаться) и Launchpad , но всё это избыточно и громоздко (хотя в плане программирования гораздо проще, но тему холиваров поднимать не буду, у каждого свои вкусы). В итоге решил определяться не с готовой платой, а взять только МК и делать всё с нуля. В итоге выбирал между Atmel ATtiny (2313), Atmel ATmega (решил отказаться т.к. не смог найти за адекватные деньги), STM32 (Cortex на ядре ARM ). С тинькой я уже успел побаловаться, так что взял себе STM32VL-Discovery . Это можно назвать вступлением к циклу статей по STM32 . Оговорюсь сразу, автором большинства этих статей буду являться не я, т.к. сам только познаю, здесь я публикую их в первую очередь для себя, чтоб удобнее было искать если что-то забуду. И так поехали!

Общие сведения

Микроконтроллеры семейства STM32 содержат в своём составе до семи 16-разрядных портов ввода-вывода c именами от PORTA до PORTG. В конкретной модели микроконтроллера без исключений доступны все выводы портов, общее количество которых зависит от типа корпуса и оговорено в DataSheet на соответствующее подсемейство.

Для включения в работу порта x необходимо предварительно подключить его к шине APB2 установкой соответствующего бита IOPxEN в регистре разрешения тактирования периферийных блоков RCC_APB2ENR :

RCC->APB2ENR |= RCC_APB2ENR_IOPxEN; // Разрешить тактирование PORTx.

Управление портами STM32 осуществляется при помощи наборов из семи 32-разрядных регистров:

• GPIOx_CRL, GPIOx_CRH – задают режимы работы каждого из битов порта в качестве входа или выхода, определяют конфигурацию входных и выходных каскадов.
• GPIOx_IDR – входной регистр данных для чтения физического состояния выводов порта x.
• GPIOx_ODR – выходной регистр осуществляет запись данных непосредственно в порт.
• GPIOx_BSRR – регистр атомарного сброса и установки битов порта.
• GPIOx_BSR – регистр сброса битов порта.
• GPIOx_LCKR – регистр блокировки конфигурации выводов.

Режимы работы выводов GPIO

Режимы работы отдельных выводов определяются комбинацией битов MODEy и CNFy регистров GPIOx_CRL и GPIOx_CRH (здесь и далее: x-имя порта, y- номер бита порта).

GPIOx_CRL - регистр конфигурации выводов 0...7 порта x :

Структура регистра GPIOx_CRH аналогична структуре GPIOx_CRL и предназначена для управления режимами работы старших выводов порта (биты 8...15).

Биты MODEy указанных регистров определяют направление вывода и ограничение скорости переключения в режиме выхода:

• MODEy = 00: Режим входа (состояние после сброса);
• MODEy = 01: Режим выхода, максимальная скорость – 10МГц;
• MODEy = 10: Режим выхода, максимальная скорость – 2МГц;
• MODEy = 11: Режим выхода, максимальная скорость – 50МГц.

Биты CNF задают конфигурацию выходных каскадов соответствующих выводов:

в режиме входа:

• CNFy = 00: Аналоговый вход;
• CNFy = 01: Вход в третьем состоянии (состояние после сброса);
• CNFy = 10: Вход с притягивающим резистором pull-up (если PxODR=1) или pull-down (если PxODR=0);
• CNFy = 11: Зарезервировано.

в режиме выхода:

• CNFy = 00: Двухтактный выход общего назначения;
• CNFy = 01: Выход с открытым стоком общего назначения;
• CNFy = 10: Двухтактный выход с альтернативной функцией;
• CNFy = 11: Выход с открытым стоком с альтернативной функцией.

С целью повышения помехоустойчивости все входные буферы содержат в своём составе триггеры Шмидта. Часть выводов STM32 , снабженных защитными диодами, соединёнными с общей шиной и шиной питания, помечены в datasheet как FT (5V tolerant) - совместимые с напряжением 5 вольт.

Защита битов конфигурации GPIO

Для защиты битов в регистрах конфигурации от несанкционированной записи в STM32 предусмотрен регистр блокировки настроек GPIOx_LCKR
GPIOx_LCKR - регистр блокировки настроек вывода порта:

Для защиты настроек отдельного вывода порта необходимо установить соответствующий бит LCKy. После чего осуществить последовательную запись в разряд LCKK значений "1” - "0” - "1” и две операции чтения регистра LCKR , которые в случае успешной блокировки дадут для бита LCKK значения "0” и "1” . Защита настроечных битов сохранит своё действие до очередной перезагрузки микроконтроллера.

Файл определений для периферии микроконтроллеров STM32 stm32f10x.h определяет отдельные группы регистров, объединённые общим функциональным назначением (в том числе и GPIO ), как структуры языка Си, а сами регистры как элементы данной структуры. Например:

GPIOC->BSRR – регистр BSRR установки/сброса порта GPIOC.
Воспользуемся определениями из файла stm32f10x.h для иллюстрации работы с регистрами ввода-вывода микроконтроллера STM32F100RB установленного в стартовом наборе STM32VLDISCOVERY :

#include "stm32F10x.h" u32 tmp; int main (void) { RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; // Разрешить тактирование PORTC. GPIOC->CRH |= GPIO_CRH_MODE8; // Вывод светодиода LED4 PC8 на выход. GPIOC->CRH &=~GPIO_CRH_CNF8; // Двухтактный выход на PC8. GPIOC->CRH |= GPIO_CRH_MODE9; // Вывод светодиода LED3 PC9 на выход. GPIOC->CRH &=~GPIO_CRH_CNF9; // Двухтактный выход на PC9. GPIOA->CRL&=~GPIO_CRL_MODE0; // Кнопка "USER" PA0 - на вход. // Заблокировать настройки выводов PC8, PC9. GPIOC->LCKR = GPIO_LCKR_LCK8|GPIO_LCKR_LCK9| GPIO_LCKR_LCKK; GPIOC->LCKR = GPIO_LCKR_LCK8|GPIO_LCKR_LCK9; GPIOC->LCKR = GPIO_LCKR_LCK8|GPIO_LCKR_LCK9| GPIO_LCKR_LCKK; tmp=GPIOC->LCKR; tmp=GPIOC->LCKR; }

Запись и чтение GPIO

Для записи и чтения портов предназначены входной GPIOx_IDR и выходной GPIOx_ODR регистры данных.

Запись в выходной регистр ODR порта настроенного на вывод осуществляет установку выходных уровней всех разрядов порта в соответствии с записываемым значением. Если вывод настроен как вход с подтягивающими резисторами, состояние соответствующего бита регистра ODR активирует подтяжку вывода к шине питания (pull-up, ODR=1) или общей шине микроконтроллера (pull-down, ODR=0).

Чтение регистра IDR возвращает значение состояния выводов микроконтроллера настроенных как входы:

// Если кнопка нажата (PA0=1), установить биты порта C, иначе сбросить. if (GPIOA->IDR & GPIO_IDR_IDR0) GPIOC->ODR=0xFFFF; else GPIOC->ODR=0x0000;

Сброс и установка битов порта

Для атомарного сброса и установки битов GPIO в микроконтроллерах STM32 предназначен регистр GPIOx_BSRR . Традиционный для архитектуры ARM способ управления битами регистров не требующий применения операции типа "чтение-модификация-запись” позволяет устанавливать и сбрасывать биты порта простой записью единицы в биты установки BS (BitSet) и сброса BR (BitReset) регистра BSRR . При этом запись в регистр нулевых битов не оказывает влияния на состояние соответствующих выводов.

GPIOx_BSRR – регистр сброса и установки битов порта:

GPIOC->BSRR=GPIO_BSRR_BS8|GPIO_BSRR_BR9; // Зажечь LED4 (PC8), погасить LED3. GPIOC->BSRR=GPIO_BSRR_BS9|GPIO_BSRR_BR8; // Зажечь LED3 (PC9), погасить LED4.

Альтернативные функции GPIO и их переназначение (remapping)
Практически все внешние цепи специального назначения STM32 (включая выводы для подключения кварцевых резонаторов, JTAG/SWD и так далее) могут быть разрешены на соответствующих выводах микроконтроллера, либо отключены от них для возможности их использования в качестве выводов общего назначения. Выбор альтернативной функции вывода осуществляется при помощи регистров с префиксом "AFIO ”_.
Помимо этого регистры AFIO _ позволяют выбирать несколько вариантов расположения специальных функций на выводах микроконтроллера. Это в частности относится к выводам коммуникационных интерфейсов, таймеров (регистры AFIO_MAPR ), выводам внешних прерываний (регистры AFIO_EXTICR ) и т. д.

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

Регистры конфигурации порта.

Port configuration register low (GPIOx_CRL) (x=A..G)

Port configuration register high (GPIOx_CRH) (x=A..G)

Для программирования режимов работы портов ввода/вывода STM32, используются два 32 разрядных регистра для каждого GPIO. Они позволяют произвольно настроить режим работы любой отдельной линии. Регистр GPIOx_CRL отвечает за линии с номерами от 0 до 7, GPIOx_CRH – за линии 8-15. Для каждой из них в регистре имеется два двухразрядных поля CNFy и MODEy. Первое определяет тип работы линии, второе – направление обмена по линии. все биты доступны для чтения/записи.

Регистр GPIOx_CRL

Регистр GPIOX_CRH

Поле MODEy может принимать следующие значения:

• 00 – линия работает на ввод. Данное состояние устанавливается после сброса.
• 01 – линия работает на выход, с максимальной частотой переключения 10 МГц
• 10 – линия работает на выход, с максимальной частотой переключения 20 МГц
• 11 – линия работает на выход, с максимальной частотой переключения 50 МГц

Поле CNFy зависит от направления передачи. При работе на вход (MODEy=0) доступны следующие состояния:

• 00 – аналоговый вход.
• 01 – вход в третьем состоянии. (Устанавливается после сброса).
• 10 – вход с подтягивающим резистором
• 11 – зарезервировано для будущих применений.

При работе на выход (MODEy>0) поле CNFy может иметь следующие состояния:

• 00 – цифровой выход
• 01 – цифровой выход с открытым стоком
• 10 – цифровой выход, подключенный специализированным блокам
• 11 – цифровой выход, подключенный специализированным блокам с открытым стоком

Регистр защиты от изменения настроек

Port configuration lock register (GPIOx_LCKR) (x=A..G)

Установить блокируемый бит в GPIOx_LCKRДля невозможности изменения настроек порта в микроконтроллерах STM32 используется регистр GPIOx_LCKR. Его младщие 15 бит отвечают за соответсвующие линии порта ввода/вывода. Бит 16, установленный в 1, разрешает блокировку изменения настроек. все биты доступны на чтение/запись. Для усложнения жизни пользователям ;-) , используется специальный алгоритм установки защиты. Если он применен, то следующее изменение конфигурации доступно только после сброса. Алгоритм установки защиты выглядит следующим образом:

1. Установить бит 16 GPIOx_LCKR.
2. Сбросить бит 16 GPIOx_LCKR.
3. Установить бит 16 GPIOx_LCKR.
4. Прочитать GPIOx_LCKR
5. Повторно прочитать GPIOx_LCKR

Регистры установки состояния линий

В отличие от привычных 8-ми битных моделей, в STM32 имеется несколько регистров, отвечающих за состояние линий порта ввода вывода. Условно они разделены на две группы – регистры порта и регистры установки отдельных битов.

Выходной регистр порта ввода/вывода

Port output data register (GPIOx_ODR) (x=A..G)

Данный регистр имеет разрядность 32, но используются только младшие 16 бит. Биты с 16 по 31 не используются. При записи в GPIOx_ODR какого-либо значения, это значение устанавливается на выходных линиях соответствующего порта. Биты регистра доступны только для чтения/записи.

Входной регистр

Port input data register (GPIOx_IDR) (x=A..G)

Аналогично регистру выхода, регистр входа имеет толь 16 младших действующих бит из 32. Чтение GPIOx_IDR возвращает значение состояния всех линий порта. Биты регистра доступны только для чтения.

Регистр битовых операций

Port bit set/reset register (GPIOx_BSRR) (x=A..G)

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

Регистр сброса

Port bit reset register (GPIOx_BRR) (x=A..G)

Данный регистр производит сброс высокого уровня линии, установленной в регистре GPIOx_ODR. Задействованы только младшие 16 бит, доступных только для записи.

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

Память и регистры

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

Каждый из регистров имеет свой порядковый номер – адрес. Адрес регистра обозначается 32-битным числом представленным в шестнадцатеричной системе счисления. Путём записи по адресу регистра определённой комбинации единиц и нулей, которые обычно представлены в шестнадцатеричном виде, осуществляется настройка и управление тем или иным узлом в МК. Вспомним, что в программе для работы с битовыми операциями, мы могли представить в виде шестнадцатеричного числа произвольный набор единиц и нулей. В целом стоит отметить, что существует два вида регистров: регистры общего назначения и специальные регистры. Первые расположены внутри ядра МК, а вторые являются частью RAM-памяти.

Так же стоит отметить, что Reference Manual , который мы скачивали в первом уроке , это один большой справочник по регистрам, содержащимся в целевом микроконтроллере, а библиотека CMSIS позволяет нам оперировать символьными именами регистров вместо числовых адресов. Например, к регистру 0x40011018 мы можем обратиться просто, используя символьное имя GPIOC_BSSR . Конкретные примеры конфигурирования мы рассмотрим в ходе разбора нашей программы из .

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

1. Названия регистра и описания его назначения
2. Адреса регистра или смещением относительно базового адреса
3. Значения по умолчанию после сброса
4. Типа доступа к ячейкам регистра (чтение, запись, чтение/запись)
5. Значения и описания параметров записываемых битов

Разбор кода из первого занятия

Давайте еще разок взглянем на код программы, которую мы использовали для того, чтобы заставить наш МК дрыгать двумя ногами на которых расположены наши светодиоды:

Код main.c

/* Заголовочный файл для нашего семейства микроконтроллеров*/ #include "stm32f0xx.h" /* Тело основной программы */ int main(void) { /* Включаем тактирование на порту GPIO */ RCC->AHBENR |= RCC_AHBENR_GPIOCEN; /* Настраиваем режим работы портов PC8 и PC9 в Output*/ GPIOC ->MODER = 0x50000; /* Настраиваем Output type в режим Push-Pull */ GPIOC->OTYPER = 0; /* Настраиваем скорость работы порта в Low */ GPIOC->OSPEEDR = 0; while(1) { /* Зажигаем светодиод PC8, гасим PC9 */ GPIOC->ODR = 0x100; for (int i=0; i<500000; i++){} // Искусственная задержка /* Зажигаем светодиод PC9, гасим PC8 */ GPIOC->ODR = 0x200; for (int i=0; i<500000; i++){} // Искусственная задержка } }

1. Как настроить, нужные нам, пины порта GPIO для того чтобы можно было включить светодиод?
2. Как включить и выключить светодиод?

Куда подключены наши светодиоды? К какому выводу микроконтроллера?

Как включить тактирование на нужный порт GPIO?

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

Внимание! Вопрос касательно системы тактирования, её настройки и использования мы подробно рассмотрим в отдельной статье.

Найти к какой шине подключен наш порт GPIOC можно найти в Datasheet"е на наш МК в разделе Memory Mapping в Таблице 16. STM32F051xx peripheral register boundary addresses.

Основываясь на материалах прошлого урока, мы знаем что для того чтобы выставить определенный бит нужно используя логическую операцию «ИЛИ» сложить текущее значение регистра с маской которая содержит те биты которые необходимо включить. Например, сложим значение регистра RCC->AHBENR по умолчанию, т.е. 0x14 и число 0x80000 тем самым включим тактирование GPIOC путем установки 19 бита:

Каким образом мы можем это сделать из программы? Всё достаточно просто. В данном случае у нас два варианта:

1. Запись в регистр напрямую численного значения регистра напрямую через его адрес.
2. Настройка с использованием библиотеки CMSIS

То есть, мы могли бы обращаться к адресам регистров напрямую по адресу и написать так:

IO uint32_t * register_address = (uint32_t *) 0x40021014U; // Адрес нашего регистра в памяти *(__IO uint32_t *)register_address |= 0x80000; // Включаем 19 бит с нашим параметром
Второй вариант мне кажется наиболее привлекательным, т.к. библиотека CMSIS организована таким способом, что регистру можно обращаться, используя только его название. Препроцессор в ходе обработки текста программы перед компиляцией подставит все цифровые значения адреса регистра автоматически. Давайте разберем этот вопрос чуть подробнее.

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

Наш код будет выглядеть следующим образом:

/* Заголовочный файл для нашего семейства микроконтроллеров*/ #include "stm32f0xx.h" /* Тело основной программы */ int main(void) { /* Включаем тактирование на порту GPIO */ RCC->AHBENR|=RCC_AHBENR_GPIOCEN; }
Давайте для ознакомления копнём вглубь библиотеки CMSIS.

Для того, чтобы быстро перейти к месту где объявлена та или иная константа или переменная в Keil реализована удобная функция. Кликаем правой кнопкой по необходимой нам константе, например, на RCC:

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

/* Включаем тактирование на порту GPIO */ RCC->AHBENR|=RCC_AHBENR_GPIOCEN;
В качестве задания: определите используя возможности Keil, каким образом получился адрес регистра RCC->AHBENR как 0x40021014.

Как настроить нужные нам пины GPIO для того чтобы можно было включить светодиод?

Первым делом нам нужно перевести режим работы пинов PC8 и PC9 в режим Output. Остальные параметры порта можно оставить по умолчанию. Переходим в Reference Manual в раздел 9. General-purpose I/Os (GPIO) и открываем пункт отвечающий за режим работы пинов порта GPIO и видим что за этот параметр отвечает регистр MODER:

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

Или через использование определений из библиотеки:

/* Включаем тактирование на порту GPIO */ GPIOC->MODER |= GPIO_MODER_MODER8_0 | GPIO_MODER_MODER9_0;
После данной инструкции наши пины PC8 и PC9 перейдут в режим Output.

Как включить светодиод?

Сделать это мы можем через прямое присвоение значений регистру:

GPIOC->ODR = 0x100; // Зажигаем PC8, гасим PC9 GPIOC->ODR = 0x200; // Зажигаем PC9, гасим PC8
Можем через использование определений из библиотеки:

GPIOC->ODR = GPIO_ODR_8; // Зажигаем PC8, гасим PC9 GPIOC->ODR = GPIO_ODR_9; // Зажигаем PC9, гасим PC8
Но так как микроконтроллер работает очень быстро - мы не будем замечать смены состояний светодиодов и визуально будет казаться что они оба горят постоянно. Для того чтобы они действительно моргали попеременно мы внесем искусственную задержку в виде цикла который займет МК бесполезными вычислениями на некоторое время. Получится следующий код:

/* Зажигаем светодиод PC8, гасим PC9 */ GPIOC->ODR = GPIO_ODR_8; for (int i=0; i<500000; i++){} // Искусственная задержка /* Зажигаем светодиод PC9, гасим PC8 */ GPIOC->ODR = GPIO_ODR_9; for (int i=0; i<500000; i++){} // Искусственная задержка
На этом первоначальное знакомство с регистрами и методами работы с ними мы можем закончить.

Проверка результатов работы нашего кода

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

General Purpose Input/Output (GPIO). GPIO основной и часто применяемый способ связи с внешней средой. Порты могут работать в двух режимах: вход (прием сигнала) и выход (передача сигнала). Работают они только с логическими уровнями 0 (низкий уровень) или 1 (высокий уровень).
Например, если подключить к порту в режиме выхода светодиод, то при подаче сигнала высокого уровня светодиод будет светиться, а при подаче низкого – потухнет.
Если включить вывод в режим входа и подключить к нему кнопку, то с помощью микроконтроллера можно отслеживать ее состояние: нажатое или отпущенное.
По сути GPIO самый простой и примитивный способ организации работы с внешними устройствами, но использование обработки прерываний и таймеров значительно расширяет возможности. Речь о них пойдет немного позже.

Решим первую практическую задачу: управление светодиодами и считывание состояние кнопки.
Следует отметить очень важный момент – порты микроконтроллера могут выдать ток не более 20 мА. Хотя выдать он их может, но один раз и ненадолго, до хлопка и сизого дыма;). Для подключения более мощных нагрузок следует использовать силовые ключи.

Итак, начнем. Для работы возьмем плату STM32F4 Discovery. На ней изначально установлена пользовательская кнопка, подключенная к порту PA0 и 4 светодиода, подключенные к портам PD12-PD15.

Схема подключение кнопки и светодиодов показаны на рисунке.

Резистор R1 номиналом 10кОм – «подтяжка к земле», позволяет избежать ситуации, когда порт не подключен ни к «0», ни к «1» - этого необходимо избегать, а резистор решает эту проблему. Такую подтяжку можно включить и программно, но лучше обезопасить себя так.

Резисторы R2-R5 330Ом ограничивают ток, протекающий через светодиоды. Их можно выбрать в диапазоне от 200Ом до 1кОм, все зависит от необходимой яркости.

Теперь перейдем к написанию программы. В качестве среды разработки я использую . Среда бесплатная и, на мой взгляд, удобная. Как начинать в ней работать рассказывать не буду – в интернете по ней достаточно информации, для прошивки использую STM32 ST-LINK Utility.
Для начала включаем тактирование порта A, к которому подключена кнопка:

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

Теперь нужно правильно сконфигурировать порт:

//Структура содержащая настройки порта GPIO_InitTypeDef GPIO_InitStructure; //задаем номер вывода, если кнопка подключена, например к 6 порту, то пишем GPIO_Pin_6 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; //порт будет работать как цифровой вход GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;

Существует несколько вариантов режима работы порта:
GPIO_Mode_IN – цифровой вход;
GPIO_Mode_OUT – цифровой выход;
GPIO_Mode_AF – альтернативная функция (UART и т.д.);
GPIO_Mode_AN – аналоговый режим.

//включаем подтяжку к «земле» GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;

Возможны следующие режимы «подтяжки»:
GPIO_PuPd_NOPULL – без подтяжки, вывод «болтается в воздухе»
GPIO_PuPd_UP – подтяжка к 3,3В
GPIO_PuPd_DOWN – подтяжка к «земле»

//вызов функции инициализации GPIO_Init(GPIOA, &GPIO_InitStructure);

Теперь сконфигурируем выводы, к которым подключены светодиоды:

//Включаем тактирование порта D RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); //Выбираем нужные выводы GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12| GPIO_Pin_13| GPIO_Pin_14| GPIO_Pin_15; //Включаем режим выхода GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; //вызов функции инициализации GPIO_Init(GPIOD, &GPIO_InitStructure);

Вот и все, порты сконфигурированы. Теперь напишем обработку в основном цикле программы:

While(1) { //Если кнопка нажата, то… if (GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)==1) { GPIO_SetBits(GPIOD, GPIO_Pin_12); //Подаем «1» на PD12 delay(); //Функция задержки GPIO_SetBits(GPIOD, GPIO_Pin_13); //Подаем «1» на PD13 delay(); GPIO_SetBits(GPIOD, GPIO_Pin_14); //Подаем «1» на PD14 delay(); GPIO_SetBits(GPIOD, GPIO_Pin_15); //Подаем «1» на PD15 delay(); GPIO_ResetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15); //Сбрасываем все пины в «0» delay(); } }

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

Порты ввода/вывода пожалуй важнейшая часть микроконтроллера, без неё всё остальное просто бессмысленно. Сколько бы не было у контроллера памяти, периферии, какой бы высокой не была тактовая частота - это всё не имеет значения если он не может взаимодействовать с внешним миром. А взаимодействие это осуществляется через эти самые порты ввода/вывода. Далее для краткости будем называть их просто портами. Порт это некоторый именованный набор из 16-ти (как правило) ног контроллера, каждая из которых может быть индивидуально настроена и использована. Количество портов может различаться, например в контроллере установленном в отладочной плате STM32vl Discovery имеются три порта A,B,C. Существует два основных режима работы ног контроллера: вход и выход. Когда нога контроллера настроена на выход - к ней можно прицепить любой потребитель: светодиод, пищалку, да и вообще что угодно. Нужно понимать что ноги у контроллера не потянут большую нагрузку. Максимальный ток который может пропустить через себя одна нога составляет ~20 мА. Если планируется подключать что-то с более высоким энергопотреблением то нужно делать это через транзисторный ключ. В противном случае нога порта (а то и весь порт, чем черт не шутит) сгорит и перестанет выполнять свои функции. Чтобы обезопасить ногу порта можно прицепить к ней резистор номиналом примерно 220 ом. Таким образом при напряжении питания 3.3 вольта даже при коротком замыкании ноги на землю ток не превысит критического значения. Второй режим работы ноги контроллера - это вход. Благодаря этому режиму мы можем считывать например состояние кнопок, проверяя есть ли на ноге напряжение или нет. Это вкратце, а сейчас рассмотрим подробнее как работать с портами. Рассматривать будем конечно же на практике, благо что аппаратная часть (светодиоды и кнопка) для наших экспериментов уже реализована на плате STM32vl Discovery. Если же платы нет, то можно подключить к контроллеру светодиоды и кнопку следующим образом:

Для начала попробуем зажечь светодиоды, для этого мы должны произвести аж целых три действия:

1. Включить тактирование порта
2. Настроить две ножки как выходы
3. Установить логическую единицу на 2-х выводах порта

Для начала создадим проект в CooCox"e точно так же как мы [делали ранее] . Запишем в файл main.c следующий код и будем разбираться:

#include int main(void) { RCC->APB2ENR |= RCC_APB2Periph_GPIOC; GPIOC->CRH |=0x33; GPIOC->CRH &= ~0xCC; GPIOC->ODR |= (GPIO_ODR_ODR9 | GPIO_ODR_ODR8); }

Всего-то четыре строчки кода, но сколько смысла:) Для начала разберемся что значит "Включить тактирование порта". В контроллере полно периферии: Таймеры, АЦП, USART и т.д. Порт ввода/вывода является такой же периферией. Когда периферия включена (подаются тактовые импульсы) - она потребляет ток. Нет тактирования - нет потребления. По умолчанию вообще весь этот зоопарк периферии вырублен. Итак нас интересует порт C, ведь именно на нем висят наши светодиоды. Для включения/выключения периферии есть два регистра RCC_APB1ENR и RCC_APB2ENR. Нам нужен последний, потому что через него мы можем управлять тактированием порта C. Устроен этот регистр так:

Как видно на картинке в нем есть бит IOPCEN. Установив его в единицу мы включим наш порт. Именно это и делает строчка кода

RCC->APB2ENR |= RCC_APB2Periph_GPIOC;

После включения тактирования мы должны настроить некоторые (а именно 8-ю и 9-ю) ноги порта на выход. За конфигурирование вообще любого порта отвечают два регистра GPIOx_CRL и GPIOx_CRH где икс это буква порта (от A до G), в нашем случае это буква С. Оба регистра выполняют одну и ту же функцию, просто GPIOx_CRL отвечает за конфигурирование младшей половины порта (ножки с 0 по 7), а GPIOx_CRH старшей (ножки с 8 по 15). Наши светодиоды висят на ногах PC8 и PC9 а это значит что для настройки этих ног в режим выхода нам потребуется регистр GPIOC_CRH. Вот так он устроен:

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

Максимальная частота в моём понимании это насколько быстро нога может менять свое состояние, скорее всего частота влияет на энергопотребление. Теперь для рассмотрим следующую группу бит CNF. Если мы настроили ногу на выход (биты MODE отличны от нуля) то биты группы CNF могут принимать следующие значения:

Тут всё немного сложнее, во-первых разберёмся что подразумевается под обычным и альтернативный режимами. В обычном режиме вы можете распоряжаться ногой как вам угодно, например установить единицу или ноль при помощи своего кода. В альтернативном режиме вы передаёте эту ножку контроллера в распоряжение какой-либо периферии контроллера например UART"у, SPI, I2c и всему прочему что нуждается в ножках. Теперь разберемся чем отличается push-pull от открытого коллектора. В режиме push-pull нога всегда находится в одном из двух состояний: На ней всегда либо земля либо полное напряжение питания. В режиме открытого коллектора: Земля или ничего, нога просто как-бы зависает в воздухе ни к чему не подключенная внутри контроллера. Теперь рассмотрим что означают те же самый два бита если наш порт настроен на вход (биты MODE обнулены):

Аналоговый режим предназначен для работы АЦП, если мы хотим чтоб АЦП мог производить измерения используя эту ногу мы должны выбрать этот режим. Вход без подтяжки делает ногу входом с Hi-z состоянием, это означает что сопротивление входа велико и любая электрическая наводка (помеха) может вызвать появление на таком входе единицу или ноль, причем сделать это не предсказуемо. Во избежание этого нужно использовать подтяжку, она позволяет установить на входе какое либо устойчивое состояние которое не будет зависеть от помех. Подтяжка представляет собой резистор большого сопротивления подключенный одним концом к земле или к плюсу питания, а другим концом ко входу. Например если включена подтяжка к плюсу питания, то когда нога контроллера ни куда не припаяна на ней всегда логическая единица. Если мы припаяем кнопку между этой ножкой и землёй, то всякий раз при нажатии кнопки на ноге будет появляться логический ноль. Если бы подтяжка была выключена, то в момент нажатия кнопки на ноге так же появлялся бы ноль, но при отпущенной кнопке нога могла бы легко поймать любую наводку и вызвать появление логической единицы на ноге. В результате, микроконтроллер бы думал что кто-то хаотично жмет на кнопку. Мы рассмотрим все это на практике чуть позже, а сейчас вернемся к нашему регистру GPIOC_CRH. Итак мы планируем установить биты этого регистра (для двух ножек PC8 и PC9) следующим образом:

Исходя из вышесказанного, такая комбинация бит настроит обе ножки на выход с максимальной частотой 50 МГц в обычном режиме push-pull, что нам вполне подходит. Эта строчка устанавливает в единицы биты MODE:

GPIOC->CRH |=0x33;

А вот эта, обнуляет биты CNF:

GPIOC->CRH &= ~0xCC;

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

GPIOC->CRH = 0x33; // 0x33 это и есть 00110011

Но нужно понимать что во все остальные биты (кроме первых восьми) запишутся нули, и это повлияет на конфигурацию остальных пинов (они все станут аналоговыми входами). Теперь когда обе ножки сконфигурированы можно попробовать зажечь светодиоды. За вывод данных в порт C отвечает регистр GPIOC_ODR, записывая в определённый бит единицу, мы получаем логическую единицу на соответствующей ножке порта. Поскольку в порте С 16 ножек, а регистр 32-х битный, то используются только первые 16 бит. Светодиоды подключены к пинам PC8 и PC9, поэтому мы должны установить восьмой и девятый биты. Для этого служит строчка:

GPIOC->ODR |= (GPIO_ODR_ODR9 | GPIO_ODR_ODR8);

Очень надеюсь, что читатели знакомы с битовой арифметикой в Си:) ибо без неё может быть сложновато. Ну собственно все, после компиляции и загрузки программы в контроллер - на платке загорятся два светодиода: синий и зелёный. Использование регистра GPIOC_ODR - это не единственный способ изменить состояние порта С. Существует еще один регистр позволяющий сделать это - GPIOC_BSRR. Этот регистр позволят атомарно устанавливает состояние какой-либо ножки. Ведь в примере выше мы делали следующим образом:

1) Считывали текущее состояние регистра GPIOC_ODR в некоторую временную переменную

2) устанавливали в ней нужные биты (8-й и 9-й)

3) записывали то что получилось обратно в регистр GPIOC_ODR.

Чтение->модификация->запись это довольно долгая процедура, иногда надо делать это очень быстро. Вот тут то и выходит на сцену регистр GPIOC_BSRR. Посмотрим как он устроен:

На каждую ножку порта выделяется по два бита: BRXX и BSXX. Далее всё просто: записывая единицу в бит BSXX мы устанавливаем на соответствующей ножке логическую единицу. Записывая единицу в бит BRXX мы сбрасываем в ноль соответствующую ножку. Запись нулей в любой из битов не приводит ни к чему. Если мы заменим последнюю строчку программы на:

GPIOC->BSRR=(GPIO_BSRR_BS8|GPIO_BSRR_BS9);

то получим тот же результат, но работает оно быстрей:) Ну а для того чтоб сбросить в ноль определённые биты порта С необходим так же записать две единицы но уже в биты BR8 и BR9:

GPIOC->BSRR=(GPIO_BSRR_BR8|GPIO_BSRR_BR9);

Но и это еще не всё :) Так же изменить состояние порта можно при помощи регистра GPIOC_BRR, установив в единицу какой либо из первых 16-бит, мы сбросим в ноль соответствующие ножки порта. Зачем он нужен - не понятно, ведь есть же регистр GPIOC_BSRR который может делать тоже самое да и еще плюс устанавливать логическую единицу на ноге (а не только сбрасывать в ноль как GPIOC_BRR). С выводом данных в порт теперь точно всё. Настало время что-то из порта прочитать. Ну а читать мы будет состояние кнопки, которая у нас подключена к ноге PA0. Когда кнопка не нажата - на ножке PA0 присутствует логический ноль за счёт резистора номиналом 10 кОм который подтягивает этот вывод к земле. После замыкания контактов кнопки, слабенькая подтяжка к земле будет подавлена напряжением питания и на входе появится логическая единица. Сейчас мы попробуем написать программу которая читает состояние ножки PA0 и в зависимости от наличия логической единицы, зажигает или гасит светодиоды. Управлять состоянием светодиодов мы уже научились из предыдущего примера, осталось только разобраться как читать что-то из порта. Для чтения из порта А используется регистр GPIOA_IDR. В его внутреннем устройстве нет ничего особо сложного и поэтому я не буду рисовать тут картинку, а объясню всё парой слов: Первые 16 бит регистра соответствуют 16 ногам порта. Что приходит в порт - то и попадает в этот регистр. Если на всех ногах порта А будут присутствовать логические единицы, то и из регистра GPIOA_IDR мы прочитаем 0xFFFF. Естественно, не надо забывать настраивать порт как вход, хотя по умолчанию он настроен именно так как нам надо, просто сделаем это для понимания сути дела. После этого в бесконечном цикле мы считываем регистр GPIOA_IDR, зануляем в все биты кроме нулевого (кнопка ведь висит на PA 0 ) и сравниваем результат с единицей. Если результат равен единице значит кто-то удерживает нажатой кнопку (и надо зажечь светодиоды), в противном случае (если 0) кнопка отпущена и светодиоды надо погасить. Может возникнуть здравый вопрос: Зачем занулять все остальные биты кроме нулевого? А дело тут вот в чем, все остальные ноги порта (как и PA0) так же настроены на вход без подтяжки. Это означает что в любой момент времени там может быть вообще всё что угодно, всё зависит от количества вокруг контроллера наводок и помех. Следовательно при нажатой кнопке из регистра GPIOA_IDR может прочитаться не только 0000 0000 0000 0001 но и например 0000 0000 01 01 0001 а следовательно сравнивать такое число с единицей нельзя, однако после зануления остальных битов вполне можно. Посмотрим на код реализующий всё сказанное выше:

#include int main(void) { //Включим тактирование порта С (со светодиодами) и порта А (с кнопкой) RCC->APB2ENR |= (RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA); //Настроим ножки со светодиодами как выходы GPIOC->CRH |=0x33; GPIOC->CRH &= ~0xCC; //Настроим ногу PA0 как вход без подтяжки (подтягивающий резистор уже есть на плате) GPIOA->CRL |= 0x04; GPIOA->CRL &= ~0x11; while(1) { //Бесконечный цикл if ((GPIOA->IDR & 0x01)==0x01) { //Кнопка нажата? GPIOC->BSRR=(GPIO_BSRR_BS8|GPIO_BSRR_BS9); //Зажигаем светодиоды } else { GPIOC->BSRR=(GPIO_BSRR_BR8|GPIO_BSRR_BR9); //Гасим светодиоды } } }

Код не особо сложный, но если вдруг появились вопросы, то они принимаются в комментариях. Напоследок хотелось бы в двух словах рассказать о еще одном регистре с непонятной областью практического применения - GPIOx_LCKR. Он служит для блокировки настроек порта. Это означает что настроив какую либо ножку порта на выход и установив соответствующий бит блокировки в этом регистре, мы не сможем сделать её входом (только после сброса контроллера).

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

1. Устанавливаем нужные биты блокировки
2. Записываем в LCKK единицу
3. Записываем в LCKK ноль
4. Записываем в LCKK единицу
5. Читаем из LCKK ноль
6. Читаем из LCKK единицу (опционально, только для того, чтоб убедиться что блокировка сработала)