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

Для чего это надо?
С помощью этого режима можно измерить длительность импульса или период сигнала.

Режим захвата у STM32 обладает некоторыми особенностями:

• возможность выбрать какой фронт будет активным
• возможность изменить частоту входного сигнала с помощью предделителя (1,2,4,8)
• каждый канал захвата оснащён встроенным входным фильтром
• источником сигнала захвата может служить другой таймер
• для каждого канала предусмотрено по два флага, первый выставляется если произошёл захват, второй если произошёл захват при установленном первом флаге

Для настройки режима захвата предназначены регистры CCMR1 (для 1 и 2 канала) и CCMR2 (для 3 и 4), а также регистры CCER , DIER .

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

CC4S - определяет направление работы четвёртого канала(вход или выход). При настройке канала как вход сопоставляет ему сигнал захвата

• 00 - канал работает как выход
• 01 - канал работает как вход, сигнал захвата - TI4
• 10 - канал работает как вход, сигнал захвата - TI3
• 11 - канал работает как вход, сигнал захвата - TRC

• 00 - делитель не используется, сигнал захвата IC1PS формируется по каждому событию
• 01 - сигнал захвата формируется по каждому второму событию
• 10 - сигнал захвата формируется по каждому четвёртому событию
• 11 - сигнал захвата формируется по каждому восьмому событию

Теперь давайте рассмотрим регистр CCER .

CC4E - включает/выключает режим захвата.
CC4P - определяет фронт по которому будет производиться захват, 0 - передний, 1 - задний.

И регистр DIER .

CC4DE - разрешает формировать запрос к DMA.
CC4IE - разрешает прерывание по захвату.

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

Битовые поля CC1G, CC2G, CC3G и CC4G позволяют генерировать событие в соответствующем канале захвата/сравнения.

Кстати, CCR1, CCR2, CCR3 и CCR4 - регистры захвата, в которых сохраняется значение таймера по сигналу захвата.

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

CC4IF - устанавливается когда формируется сигнал захвата, сбрасываются эти флаги программно или чтением соответствующего регистра захвата/сравнения.
CC4OF - устанавливается если флаг CC4IF не был очищен, а пришёл очередной сигнал захвата. Этот флаг очищается программно записью нуля.

Теперь давайте применим полученные знания на практике, с генератора сигналов на вход TIM5_CH4 подадим синусоиду с частотой 50Гц и попробуем измерить её период. Для того чтобы ускорить процесс предлагаю использовать DMA. Какой вывод МК соответствует 4 каналу TIM5 можно найти в даташите на МК в разделе Pinouts and pin description .

Для DMA необходим адрес регистра CCR4 , вот как его найти. Открываем RM0008 и в таблице Register boundary addresses находим начальный адрес TIM5.

#include "stm32f10x.h" #define TIM5_CCR4_Address ((u32)0x40000C00+0x40) #define DMA_BUFF_SIZE 2 uint16_t buff;//Буфер uint16_t volatile T; void DMA2_Channel1_IRQHandler (void) { T = (buff > buff) ? (buff - buff) : (65535+ buff - buff); DMA2->IFCR |= DMA_IFCR_CGIF1; } void Init_DMA(void) { RCC->AHBENR |= RCC_AHBENR_DMA2EN; //Разрешаем тактирование первого DMA модуля DMA2_Channel1->CPAR = TIM5_CCR4_Address; //Указываем адрес периферии - регистр результата преобразования АЦП для регулярных каналов DMA2_Channel1->CMAR = (uint32_t)buff; //Задаем адрес памяти - базовый адрес массива в RAM DMA2_Channel1->CCR &= ~DMA_CCR1_DIR; //Указываем направление передачи данных, из периферии в память DMA2_Channel1->CNDTR = DMA_BUFF_SIZE; //Количество пересылаемых значений DMA2_Channel1->CCR &= ~DMA_CCR1_PINC; //Адрес периферии не инкрементируем после каждой пересылки DMA2_Channel1->CCR |= DMA_CCR1_MINC; //Адрес памяти инкрементируем после каждой пересылки. DMA2_Channel1->CCR |= DMA_CCR1_PSIZE_0; //Размерность данных периферии - 16 бит DMA2_Channel1->CCR |= DMA_CCR1_MSIZE_0; //Размерность данных памяти - 16 бит DMA2_Channel1->CCR |= DMA_CCR1_PL; //Приоритет - очень высокий DMA2_Channel1->CCR |= DMA_CCR1_CIRC; //Разрешаем работу DMA в циклическом режиме DMA2_Channel1->CCR |= DMA_CCR1_TCIE;//Разрешаем прерывание по окончанию передачи DMA2_Channel1->CCR |= DMA_CCR1_EN; //Разрешаем работу 1-го канала DMA } int main(void) { Init_DMA(); //включаем тактирование порта А, альтернативных функций и таймера RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_AFIOEN; RCC->APB1ENR |= RCC_APB1ENR_TIM5EN; TIM5->PSC = 56000-1;//новая частота 1Khz TIM5->CCMR2 |= TIM_CCMR2_CC4S_0;//выбираем TI4 для TIM5_CH4 TIM5->CCMR2 &= ~(TIM_CCMR2_IC4F | TIM_CCMR2_IC4PSC);//не фильтруем и делитель не используем TIM5->CCER &= ~TIM_CCER_CC4P;//выбираем захват по переднему фронту TIM5->CCER |= TIM_CCER_CC4E;//включаем режим захвата для 4-го канала TIM5->DIER |= TIM_DIER_CC4DE;//разрешаем формировать запрос к DMA //TIM5->DIER |= TIM_DIER_CC4IE; //разрешаем прерывание по захвату TIM5->CR1 |= TIM_CR1_CEN; //включаем счётчик //NVIC->ISER |= NVIC_ISER_SETENA_18; //TIM5 Interrupt NVIC->ISER |= NVIC_ISER_SETENA_24; //DMA Interrupt while(1) { } }

В STM32 есть множество очень удобных и гибких в настройке таймеров. Даже у самого младшего микроконтроллера (STM32F030F4P6) есть 4 таких таймера.

8. Настроим проект - добавим нужные файлы

Чтобы использовать таймер, нам потребуется подключить файл библиотеки периферии stm32f10x_tim.c. Точно так же, правой кнопкой щёлкаем в Workspace (окно слева) по группе StdPeriphLib, Add –> Add files, файл LibrariesSTM32F10x_StdPeriph_Driversrcstm32f10x_tim.c.

Ещё нужно включить использование заголовка к этому файлу. Открываем stm32f10x_conf.h (правой кнопкой по названию этого файла в коде, «Open stm32f10x_conf.h». Раскомментируем строчку #include «stm32f10x_tim.h».

9. Добавим таймер

Задержка пустым циклом - это кощунство, тем более на таком мощном кристалле как STM32, с кучей таймеров. Поэтому сделаем эту задержку с помощью таймера.

В STM32 есть разные таймеры, отличающиеся набором свойств. Самые простые - Basic timers, посложнее - General purpose timers, и самые сложные - Advanced timers. Простые таймеры ограничиваются просто отсчётом тактов. В более сложных таймерах появляется ШИМ. Самые сложные таймеры, к примеру, могут сгенерировать 3–фазный ШИМ с прямыми и инверсными выходами и дедтаймом. Нам хватит и простого таймера, под номером 6.

Немного теории

Всё, что нам требуется от таймера - досчитывать до определённого значения и генерировать прерывание (да, мы ещё и научимся использовать прерывания). Таймер TIM6 тактируется от системной шины, но не напрямую а через прескалер - простой программируемый счётчик–делитель (подумать только, в СССР выпускались специальные микросхемы–счётчики, причём программируемые были особым дефицитом - а теперь я говорю о таком счётчике просто между делом). Прескалер можно настраивать на любое значение от 1 (т.е. на счётчик попадёт полная частота шины, 24МГц) до 65536 (т.е. 366 Гц).

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

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

Код

Код будет очень похож на предыдущий, т.к. инициализация всей периферии происходит однотипно - за тем лишь исключением, что таймер TIM6 висит на шине APB1. Поэтому включение таймера: RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);

Теперь заводим структуру типа TIM_TimeBaseInitTypeDef, инициализируем её (TIM_TimeBaseStructInit), настраиваем, передаём её в функцию инициализации таймера (TIM_TimeBaseInit) и наконец включаем таймер (TIM_Cmd).

TIM_TimeBaseInitTypeDef TIM_InitStructure; // Заводим структуру TIM_TimeBaseStructInit(&TIM_InitStructure); // Инициализация структуры TIM_InitStructure.TIM_Prescaler = 24000; // Предделитель TIM_InitStructure.TIM_Period = 1000; // Период таймера TIM_TimeBaseInit(TIM6, &TIM_InitStructure); // Функция настройки таймера TIM_Cmd(TIM6, ENABLE); // Включение таймера

Что за магические числа? Как мы помним, на шине присутствует тактовая частота 24МГц (при наших настройках проекта). Настроив предделитель таймера на 24000, мы поделим эту частоту на 24 тысячи, и получим 1кГц. Именно такая частота попадёт на вход счётчика таймера.

Значение же в счётчике - 1000. Значит, счётчик переполнится за 1000 тактов, т.е. ровно за 1 секунду.

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

10. Разберёмся с прерываниями

Окей, прерывания. Для меня когда–то (во времена PIC) они были тёмным лесом, и я старался вообще их не использовать - да и не умел, на самом деле. Однако, в них заключена сила, игнорировать которую вообще недостойно. Правда, прерывания в STM32 - ещё более сложная штука, особенно механизм их вытеснения; но об этом позже.

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

1. Включить вообще прерывания таймера TIM6;
2. Включить прерывание таймера TIM6 на переполнение счётчика;
3. Написать процедуру–обработчик прерывания;
4. После обработки прерывания сбросить его.

Включение прерываний

Честно говоря, тут вообще ничего сложного. Первым делом включаем прерывания TIM6: NVIC_EnableIRQ(TIM6_DAC_IRQn); Почему такое название? Потому что в ядре STM32 прерывания от TIM6 и от ЦАП имеют одинаковый номер. Не знаю, почему так сделано - экономия, нехватка номеров или просто какая–то наследная штука - в любом случае, никаких проблем это не принесёт, потому что в этом проекте не используется ЦАП. Даже если в нашем проекте использовался бы ЦАП - мы могли бы при входе в прерывание узнавать, кто конкретно его вызвал. Практически все другие таймеры имеют единоличное прерывание.

Настройка события–источника прерываний: TIM_ITConfig(TIM6, TIM_DIER_UIE, ENABLE); - включаем прерывание таймера TIM6 по событию TIM_DIER_UIE, т.е. событие обновления значения ARR. Как мы помним из картинки, это происходит одновременно с переполнением счётчика - так что это именно то событие, которое нам нужно.

На текущий момент код таймерных дел таков:

RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE); TIM_TimeBaseInitTypeDef TIM_InitStructure; TIM_TimeBaseStructInit(&TIM_InitStructure); TIM_InitStructure.TIM_Prescaler = 24000; TIM_InitStructure.TIM_Period = 1000; TIM_TimeBaseInit(TIM6, &TIM_InitStructure); TIM_Cmd(TIM6, ENABLE); NVIC_EnableIRQ(TIM6_DAC_IRQn); TIM_ITConfig(TIM6, TIM_DIER_UIE, ENABLE);

Обработка прерываний

Сейчас запускать проект нельзя - первое же прерывание от таймера не найдёт свой обработчик, и контроллер повиснет (точнее, попадёт в обработчик HARD_FAULT, что по сути одно и то же). Нужно его написать.

Немного теории

Он должен иметь совершенно определённое имя, void TIM6_DAC_IRQHandler(void). Это имя, так называемый вектор прерывания, описано в файле startup (в нашем проекте это startup_stm32f10x_md_vl.s - можете сами увидеть, 126 строка). На самом деле вектор - это адрес обработчика прерывания, и при возникновении прерывания ядро ARM лезет в начальную область (в которую транслирован файл startup - т.е. его местоположение задано совершенно жёстко, в самом начале флеш–памяти), ищет там вектор и переходит в нужное место кода.

Проверка события

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

В нашей программе эта проверка будет выглядеть так: if (TIM_GetITStatus(TIM6, TIM_IT_Update) != RESET) - всё понятно, функция TIM_GetITStatus проверяет наличие указанного события у таймера, и возвращает 0 или 1.

Очистка флага UIF

Второй шаг - очистка флага прерывания. Вернитесь к картинке: самый последний график UIF это и есть флаг прерывания. Если его не очистить, следующее прерывание не сможет вызваться, и контроллер опять упадёт в HARD_FAULT (да что же такое!).

Выполнение действий в прерывании

Будем просто переключать состояние светодиода, как и в первой программе. Разница в том, что теперь наша программа делает это более сложно! На самом деле, так писать гораздо правильнее.

If(state) GPIO_WriteBit(GPIOC, GPIO_Pin_8, Bit_SET); else GPIO_WriteBit(GPIOC, GPIO_Pin_8, Bit_RESET); state = 1 - state;

Используем глобальную переменную int state=0;

11. Весь код проекта с таймером

Архив с проектом таймера.

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

Весь цикл:

1. Порты ввода–вывода

2. Таймер и прерывания

3. Выходы таймера

4. Внешние прерывания и NVIC

5. Ставим FreeRTOS

Post Views: 235

Добрый день. Сегодня набросаю первую статейку по таймерам в STM32. Вообще таймеры в STM32 настолько круты, что даже Шварцнегер нервно курит по крутости))) И изучать их придётся не в одной, и не в двух и не в трёх статьях. Но для начала не будем забивать себе сильно головы, а просто изучим первые простые таймеры и поработаем с ними.

В STM32 вообще существует три вида таймеров
1) базовые (basic timers)
2)общего назначения (general-purpose timers)
3)продвинутые (advanced-control timers)

Продвинутые таймеры самые крутые и в себе сочитают возможности двух предыдущих групп, плюс к этому ещё множество дополнительных функций типа работа с трёхфазными моторами и т.д. и т.п. До них нам ещё далеко, поэтому в данной части мы будем рассматривать работу с базовыми (basic timers).
Для начала давайте рассмотрим, какие есть таймеры на нашем процессоре STM32F407VG (вы смотрите про свои процессоры с которыми работаете)). В моём процессоре 14 таймеров — 12 — 16ти битных и 2 32 битных

Как мы видим на картинках к шине АРВ1 подключены таймеры TIM2, TIM3, TIM4, TIM5, TIM6, TIM7, TIM12
А к шине АРВ2 — TIM1, TIM8, TIM9, TIM10, TIM11
Теперь давайте рассмотрим картинку настройки нашего тактирования в программе CubeMX. Систему тактирования я ещё отдельно опишу, так как без неё никуда, но просто пока покажу как можно затактировать наши таймеры используя внутренний источник тактирования HSI.
Вот наша стандартная настройка тактирования без всяких перемножителей частот и т.д. Её мы и будем использовать.

А вот вариант ускорения работы)) Но советую шаловливыми ручёнками туда сильно не лазить, а то может уложить процессор на лопатки)) Это всё мы потом изучим и рассмотрим.

Итак, открываем Reference Manual на F4 серию микроконтроллеров, и начинаем курить мануал. ДА, в STM32 не всё так просто, поэтому товарищи учите английский, и читайте мануалы, потому что без этого будете долго искать что к чему. Я раньше как то очень тяжко к чтению документации относился (видать потому что задачи были простыми и мне хватало обычных примеров из интернета). Ну а теперь читаем… читаем…читаем…
Продолжим…
Итак таймеры 6 и 7 являются базовыми таймерами. Сидят они на шине АРВ1 как мы видим на картинке из reference manual.

Базовые таймеры 6 и 7 — 16ти битные, имеют настраиваемый предделитель от 0 до 65535. Для этих таймеров есть вот такие регистры доступные для чтения\записи.
Counter Register (TIMx_CNT) — счётчик
Prescaler Register (TIMx_PSC) — предделитель
Auto-Reload Register (TIMx_ARR) — регистр перезагрузки

Не будем сильно углубляться в подробности работы, так как там страниц 10 описания доступных нам регистров и т.д, нам хватит трёх — написанных выше
Итак, что это за регистры и для чего они нам нужны. Да вот для чего. Решили мы тут срочно помигать светодиодом, удивить товарищей AVR-щиков например, и говорим — а давай кто быстрее настроит мигание одним светодиодом с периодом пол секунды, а вторым с периодом в секунду тот и выиграл. (кстати можно проделать подобный эксперимент))))
Для того чтобы это нам реализовать нужно всего 5 шагов — 1
1) Запустить CubeMX и создать проект под наш контроллер.
2)в CubeMX выставить работу таймеров
3) сгенерировать проект и открыть его в Keil uVision
4)проинициализировать таймеры (по одной строчке на таймер)
5)прописать в прерывании каждого таймера код постоянного изменения состояния ножки к которой подключен светодиод.
Итак, давайте это рассмотрим более подробно. Первым делом запускам нашу программу CubeMX
и настраиваем наши 2 вывода PD12 и PD13 на вывод (ножки куда подключены светодиоды). Устанавливаем для них режим GPIO_Output, и режим Output Push_Pull.
Далее слева активируем наши базовые таймеры 6 и 7.

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

Как мы помним, нам нужно чтобы один светодиод мигал с частотой 1Гц (период 1000мсек), а второй с частотой 2Гц (период 500 мсек) . Как нам это получить — да очень просто. Так как предделитель на СТМ32 можно ставить любой, то мы просто вычислим его значение
Итак частота у нас 16 000 000 тиков в секундку, а нужно 1000 тиков в секунду. Значит 16 000 000 \ 1 000 = 16 000. Это число минус 1 и вписываем в значение предделителя. То есть число у нас получается 15999.
Теперь наш таймер тикает с частотой 1000 раз в секунду. Далее, мы должны указать когда же нам нужно прерывание по переполнению. Для этого мы записываем нужное нам число в Counter Period (autoreload register).
То есть нам нужно получить одно прерывание в секунду, а как мы помним наш таймер тикает 1 раз в милисекунду. В одной секнуде — 1000 мсек — значит это значение и вписываем в регистр автоперезагрузки.
Для того, чтобы получить прерывание раз в пол секунды — записываем соответсвенно — 500.

Итак — настроили, теперь можно смело генерировать наш проект. Сгенерировали, хорошо. осталось совсем чуток до момента мигания светодиодиками.
Открыли наш проект. У нас впринципе всё настроено и готово, только нужно запустить наши таймеры, так как хоть CubeMX всё за нас и делает — этим он уже не занимается. Итак- инициализируем
наши таймеры вот такими строчками

HAL_TIM_Base_Start_IT(&htim6);
HAL_TIM_Base_Start_IT(&htim7);

Именно в нём и находятся наши обработчки прерывания для наших таймеров
Вот обработчик прерывания для таймера 7

void TIM7_IRQHandler(void)
{
/* USER CODE BEGIN TIM7_IRQn 0 */
/* USER CODE END TIM7_IRQn 0 */
HAL_TIM_IRQHandler(&htim7);
/* USER CODE BEGIN TIM7_IRQn 1 */
/* USER CODE END TIM7_IRQn 1 */
}

Вписываем в обработчик прерывания то что мы хотим делать — а мы хотим в каждом прерывании менять состояние наших ножек к которым подключены свтеодиоды.
Используем вот такую конструкцию — HAL_GPIO_TogglePin(GPIOD, GPIO_PIN_13) ;

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

Мы уже рассматривали таймер SysTick, который является частью ядра Cortex. Однако на этом всё не заканчивается. Таймеров в stm32 много, и они бывают разные. В зависимости от цели вам придется выбрать тот или иной таймер:

• SysTick;
• таймеры общего назначения (англ. general purpose timer) - TIM2, TIM3, TIM4, TIM15, TIM16, TIM17;
• продвинутый таймер (англ. advanced timer) - TIM1;
• сторожевой таймер (англ. watchdog timer).

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

Таймеры бывают разной битности: например, SysTick - 24-битный, а все таймеры, что имеются у нас в камне - 16-битные (т. е. могут считать до 2 16 = 65535), кроме WatchDog. Кроме того, каждый таймер имеет некоторое количество каналов, то есть, по сути, он может работать за двоих, троих и т. д. Эти таймеры умеют работать с инкрементными энкодерами, датчиками Холла, могут генерировать ШИМ (широтно-импульсная модуляция, англ. Pulse Width Modulation - о которой мы поговорим позже) и многое другое. Кроме того, они могут генерирувать прерывания или совершать запрос к другим модулям (например, к DMA - Direct Memory Access) по разным событиям:

• переполнение (англ. overflow);
• захват сигнала (англ. input capture);
• сравнение (англ. output compere);
• событие-триггер (англ. event trigger).

Если с переполнением таймера (точнее, достижением «0») нам всё понятно - мы рассматривали SysTick - то с другими возможными режимами работы мы еще не знакомы. Давайте рассмотрим их подробнее.

Захват сигнала

Этот режим хорошо подходит, чтобы измерять период следования импульсов (или их количество, скажем, за секунду). Когда на выход МК приходит импульс, таймер генерирует прерывание, с которого мы можем снять текущее значение счетчика (из регистра TIM_CCRx , где x - номер канала) и сохранить во внешнюю переменную. Затем придет следующий импульс, и мы простой операцией вычитания получим «время» между двумя импульсами. Отлавливать можно как передний, так и задний фронт импульса, или даже сразу оба. Зачем это нужно? Предположим, у вас есть магнит, который вы приклеили к диску на колесе, а датчик Холла - к вилке велосипеда. Тогда, вращая колесо, вы будете получать импульс каждый раз, когда магнит на колесе будет в той же плоскости, что и датчик Холла. Зная расстояние которое пролетает магнит за оборот и время можно вычислить скорость движения.

Также существует режим захвата ШИМ, однако это скорее особый способ настройки таймера, нежели отдельный режим работы: один канал ловит передние фронты, а второй - задние фронты. Тогда первый канал детектирует период, а второй - заполнение.

Режим сравнения

В таком режиме выбранный канал таймера подключается к соответствующему выводу, и как только таймер достигнет определенного значения, состояние вывода изменится в зависимости от настройки режима (это может быть «1» или «0», или состояние на выходе просто инвертируется).

Режим генерации ШИМ

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

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

Режим Dead-time

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

В курсе мы будем использовать только «захват сигнала» и «генерацию ШИМ».

Таймеры — это такая периферия контроллера STM32 позволяющая нам очень точно отсчитывать интервалы времени. Это пожалуй одна из самых важных и наиболее используемых функций, однако есть и другие. Следует начать с того, что в контроллерах STM32 существуют таймеры разной степени крутости. Самые простые это Basic timers . Они хороши тем, что очень просто настраиваются и управляются при помощи минимума регистров. Все что они умеют это отсчитывать временные интервалы и генерировать когда таймер дотикает до заданного значения. Следующая группа (general-purpose timers ) гораздо круче первой, они умеют генерировать ШИМ, умеют считать испульсы поступающие на определённые ножки, можно подключать энкодер итд. И самый крутой таймер это advanced-control timer , думаю что его я использовать не буду еще очень долго так как мне пока без надобности управлять трехфазным электродвигателем. Начать знакомство с таймерами следует с чего попроще, я решил взяться за Basic таймеры. Задача которую я себе поставил: Заставить таймер генерить прерывания каждую секунду.

Первым делом отмечу, что Basic таймеры (TIM6 и TIM7) прицеплены к шине APB1, поэтому в случае если частота тактовых импульсов на ней будет меняться, то и таймеры начнут тикать быстрее или медленнее. Если ничего не менять в настройках тактирования и оставить их по умолчанию, то частота APB1 составляет 24МГц при условии что подключен внешний кварц на частоту 8 МГц. Вообще система тактирования у STM32 очень замысловатая и я попробую про неё нормально написать отдельный пост. А пока просто воспользуемся теми настройками тактирования которые задаются кодом автоматически сгенерированым CooCox’ом. Начать стоит с самого главного регистра — TIMx_CNT (здесь и далее x — номер basic таймера 6 или 7). Это счётный 16-ти битный регистр, занимающийся непосредственно счётом времени. Каждый раз когда с шины APB1 приходит тактовый импульс, содержимое этого регистра увеличивается на едницу. Когда регистр переполняется, все начинается с нуля. При нашей дефолтной частоте шины APB1, таймер за одну секунду тикнет 24 млн раз! Это очень дофига, и поэтому у таймера есть предделитель, управлять которым мы можем при помощи регистра TIMx_PSC . Записав в него значение 24000-1 мы заставим счётный регистр TIMx_CNT увеличивать свое значение каждую милисекунду (Частоту APB1 делим на число в регистре предделителе и получаем сколько раз в секунду увеличивается счётчик). Единицу нужно вычесть потому, что если в регистре ноль то это означает, что включен делитель на единицу. Теперь, когда счётный регистр дотикает до 1000 мы можем точно заявить, что прошла ровно одна секунда! И че теперь опрашивать счётный регистр и ждать пока там появится 1000? Это не наш метод, ведь мы можем заюзать ! Но вот беда, прерывание у нас всего одно, и возникает оно когда счётчик обнулится. Для того чтоб счётчик обнулялся досрочно, а не когда дотикает до 0xFFFF, служит регистр TIMx_ARR . Записываем в него то число до которого должен досчитывать регистр TIMx_CNT перед тем как обнулиться. Если мы хотим чтоб прерывание возникало раз в секунду, то нам нужно записать туда 1000. По части непосредственно отсчёта времени это все, но таймер сам по себе тикать не начнет. Его нужно включить установив бит CEN в регистре TIMx_CR1 . Этот бит разрешает начать отсчёт, соответственно если его сбросить то отсчет остановится (ваш К.О.). В регистре есть и другие биты но они нам не особо интересны. Зато интересен нам еще один бит, но уже в регистре TIMx_DIER . Называется он UIE, установив его мы разрешаем таймеру генерить прерывания при сбросе счётного регистра. Вот собственно и всё, даже не сложней чем в каких-нибудь AVRках. Итак небольше резюме: Чтоб заюзать basic таймер нужно:

1. Установить предделитель чтоб таймер не тикал быстро (TIMx_PSC )
2. Задать предел до которого таймер должен дотикать перед своим сбросом (TIMx_ARR )
3. Включить отсчет битом CEN в регистре TIMx_CR1
4. Включить прерывание по переполнению битом UIE в регистре TIMx_DIER

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

#include "stm32f10x.h" #include "stm32f10x_gpio.h" #include "stm32f10x_rcc.h" int main() { GPIO_InitTypeDef PORT; //Включаем порт С и таймер 6 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6,ENABLE); // Настроим ноги со светодиодами на выход PORT.GPIO_Pin = (GPIO_Pin_9 | GPIO_Pin_8); PORT.GPIO_Mode = GPIO_Mode_Out_PP; PORT.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init(GPIOC, &PORT); TIM6->PSC = 24000 - 1; // Настраиваем делитель что таймер тикал 1000 раз в секунду TIM6->ARR = 1000 ; // Чтоб прерывание случалось раз в секунду TIM6->DIER |= TIM_DIER_UIE; //разрешаем прерывание от таймера TIM6->CR1 |= TIM_CR1_CEN; // Начать отсчёт! NVIC_EnableIRQ(TIM6_DAC_IRQn); //Разрешение TIM6_DAC_IRQn прерывания while(1) { //Программа ничего не делает в пустом цикле } } // Обработчик прерывания TIM6_DAC void TIM6_DAC_IRQHandler(void) { TIM6->SR &= ~TIM_SR_UIF; //Сбрасываем флаг UIF GPIOC->ODR^=(GPIO_Pin_9 | GPIO_Pin_8); //Инвертируем состояние светодиодов }

Стоит добавить небольшое примечание к обработчику прерывания. Дело в том, что он у нас используется сразу двумя блоками периферии: таймером 6 и DAC’ом. Это означает, что если вы будете писать программу которая разрешает прерывания от обоих этих периферийных устройств, то в теле обработчика необходимо проверять кто же из них вызвал прерывание. В нашем случае я не стал этого делать, так как ни каких прерываний от DAC возникнуть не может. Он не настроен, а по дефолту прерывания запрещены. В следующий раз рассмотрим general-purpose таймеры и их практическое применение.