STM32 с нуля. Timer. Настройка и использование таймеров.

Таймеры в STM32, как, в принципе, и вся периферия, являются очень навороченными. От обилия разных функций, которые могут выполнять таймеры может даже закружиться голова. Хотя, казалось бы, таймер он на то и таймер, чтобы просто считать. Но на деле все гораздо круче!

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

• 3 таймера общего назначения (TIM2, TIM3, TIM4).
• 1 более продвинутый таймер с расширенными возможностями (TIM1).
• 2 WDT (WatchDog Timer).
• 1 SysTick Timer.

Собственно таймеры общего назначения и таймер TIM1 не сильно отличаются друг от друга, так что ограничимся рассмотрением какого-нибудь одного из них. К слову я остановил свой выбор на TIM4. Без особой причины, просто так захотелось 🙂 Таймеры имеют 4 независимых канала, которые могут использоваться для:

• Захвата сигнала.
• Сравнения.
• Генерации ШИМ.
• Генерации одиночного импульса.

Таймеры 16-битные (то есть могут считать до 65535), умеют работать с инкрементальными энкодерами и датчиками Холла, несколько таймеров можно синхронизировать между собой. Есть прерывания на разные события, а именно:

• Переполнение.
• Захват сигнала.
• Сравнение.
• Событие-триггер.

При наступлении любого из этих событий таймеры могут генерировать запрос к DMA (DMA – прямой доступ к памяти, уже скоро мы будем разбираться и с ним). Теперь немного подробнее о каждом из режимов работы таймеров.

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

Режим сравнения. Тут просто подключаем какой-нибудь канал таймера к соответствующему выводу, и как только таймер досчитает до определенного значения (оно в TIM_CCR) состояние вывода изменится в зависимости от настройки режима (либо выставится в единицу, либо в ноль, либо изменится на противоположное).

Режим генерации ШИМ. Ну тут все уже понятно из названия - в этом режиме таймер генерирует ШИМ! Наверно нет смысла что-то писать тут еще сейчас. Скоро будет пример как раз с ШИМ, там и поковыряем поподробнее.

Режим Dead-Time. Суть режима в том, что между сигналами на основном и комплементарном  выводах таймера появляется определенная задержка. В интернете есть  довольно много информации о том, где это можно и нужно применять.

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

Время традиционной вставки: поскольку компания STMicroelectronics прекратила поддержку библиотеки SPL, которая использовалась в этом курсе, я создал новый, посвященный работе уже с новыми инструментами, так что буду рад видеть вас там - STM32CubeMx. Кроме того, вот глобальная рубрика по STM32, а также небольшая подборка на смежную тему из нового курса:

• STM32 и таймеры. STM32CubeMx. Настройка и использование.
• STM32 и watchdog. STM32CubeMx. Настройка модуля WWDG.
• STM32 и Timer Input Capture. Режим захвата сигнала.

Надо бы потихоньку написать программу какую-нибудь тестовую. Но сначала посмотрим, что есть в библиотеке Standard Peripheral Library.

Итак, за таймеры несут ответственность файлы - stm32f10x_tim.h и stm32f10x_tim.c. Открываем первый и видим, что структура файла повторяет структуру файла для работы с GPIO, который мы рассматривали в предыдущей статье. Здесь описаны структуры и поля структур, которые нужны для конфигурирования таймеров. Правда здесь уже не одна, а несколько структур (режимов, а соответственно и настроек-то у таймеров побольше, чем у портов ввода-вывода). Все поля структур снабжены комментариями, вот, например:

uint16_t TIM_OCMode; // Specifies the TIM mode.

Здесь будем задавать режим работы таймера. А вот еще:

uint16_t TIM_Channel; // Specifies the TIM channel.

Здесь выбираем канал таймера, ничего неожиданного 🙂 В общем все довольно прозрачно, если что спрашивайте!

Пример инициализации таймера в STM32CubeMx.

С первым файлом понятно. А в файле stm32f10x_tim.c – готовые функции для работы с таймерами. Тоже все в целом ясно. Мы уже использовали библиотеку для работы с GPIO, теперь вот работаем с таймерами, и очевидно, что для разной периферии все очень  похоже. Так что давайте создавать проект и писать программу. Итак, создаем новый проект, добавляем в него все необходимые файлы:

Пишем код:

• необходимо отметить, что в поле TIM_Prescaler нужно записывать значение, на единицу меньшее, чем то, которое мы хотим получить.

/***************************************************************************************/
#include "stm32f10x.h" 
#include "stm32f10x_rcc.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_tim.h"


/***************************************************************************************/
// При таком предделителе у меня получается один тик таймера на 10 мкс
#define TIMER_PRESCALER 720


/***************************************************************************************/
// Переменная для хранения предыдущего состояния вывода PB0
uint16_t previousState;
GPIO_InitTypeDef port;
TIM_TimeBaseInitTypeDef timer;


/***************************************************************************************/
void initAll()
{
	// Включаем тактирование порта GPIOB и таймера TIM4
	// Таймер 4 у нас висит на шине APB1
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
	// Тут настраиваем порт PB0 на выход
	// Подробнее об этом в статье про GPIO
	GPIO_StructInit(&port);
	port.GPIO_Mode = GPIO_Mode_Out_PP;
	port.GPIO_Pin = GPIO_Pin_0;
	port.GPIO_Speed = GPIO_Speed_2MHz;
	GPIO_Init(GPIOB, &port);
	// А тут настройка таймера
	// Заполняем поля структуры дефолтными значениями
	TIM_TimeBaseStructInit(&timer);
	// Выставляем предделитель
	timer.TIM_Prescaler = TIMER_PRESCALER - 1;
	// Тут значение, досчитав до которого таймер сгенерирует прерывание
	// Кстати это значение мы будем менять в самом прерывании
	timer.TIM_Period = 50;
	// Инициализируем TIM4 нашими значениями
	TIM_TimeBaseInit(TIM4, &timer);
}


/***************************************************************************************/
int main()
{
	__enable_irq();
	initAll();
	// Настраиваем таймер для генерации прерывания по обновлению (переполнению)
	TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
	// Запускаем таймер 
	TIM_Cmd(TIM4, ENABLE);
	// Разрешаем соответствующее прерывание
	NVIC_EnableIRQ(TIM4_IRQn);
	while(1)
	{
		// Бесконечно тупим) Вся полезная работа – в прерывании
		__NOP();
	} 
}


/***************************************************************************************/
void TIM4_IRQHandler()
{ 
	// Если на выходе был 0..
	if (previousState == 0)
	{
		// Выставляем единицу на выходе
		previousState = 1;
		GPIO_SetBits(GPIOB, GPIO_Pin_0);
		// Период 50 тиков таймера, то есть 0.5 мс
		timer.TIM_Period = 50;
		TIM_TimeBaseInit(TIM4, &timer); 
		// Очищаем бит прерывания
		TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
	}
	else
	{
		// Выставляем ноль на выходе
		previousState = 0;
		GPIO_ResetBits(GPIOB, GPIO_Pin_0);
		// А период теперь будет 250 тиков – 2.5 мс
		timer.TIM_Period = 250;
		TIM_TimeBaseInit(TIM4, &timer); 
		TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
	} 
}


/***************************************************************************************/

В этой программе мы смотрим, что было на выходе до момента генерации прерывания – если ноль, выставляем единицу на 0.5 мс. Если была единица – ставим ноль на 2.5 мс. Компилируем и запускаем отладку!

Небольшое, но очень важное отступление... Наш пример, конечно, будет работать и для теста он вполне сгодится, но все-таки в "боевых" программах нужно следить за оптимальностью кода как с точки зрения его объема, так и с точки зрения производительности и расхода памяти. В данном случае нет никакого смысла использовать структуру timer, а также вызывать функцию TIM_TimeBaseInit() каждый раз при смене периода. Правильнее менять всего лишь одно значение в одном регистре, а именно в регистре TIMx->ARR (где х - это номер таймера). В данном примере код трансформируется следующим образом:

/***************************************************************************************/
void TIM4_IRQHandler()
{
	// Если на выходе был 0
	if (previousState == 0)
	{
		// Выставляем единицу на выходе
		previousState = 1;
		GPIO_SetBits(GPIOB, GPIO_Pin_0);
		// Период 50 тиков таймера, то есть 0.5 мс
		TIM4->ARR = 50;
	}
	else
	{
		// Выставляем ноль на выходе
		previousState = 0;
		GPIO_ResetBits(GPIOB, GPIO_Pin_0);
		// А период теперь будет 250 тиков – 2.5 мс
		TIM4->ARR = 250;
	}
	
	TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
} 

/***************************************************************************************/

Итак, продолжаем, на пути у нас очередные грабли! А именно ошибка:

• ..\..\..\SPL\src\stm32f10x_tim.c(2870): error:  #20: identifier "TIM_CCER_CC4NP" is undefined

Не так страшно как может показаться, идем в файл stm32f10x.h, находим строки:

#define TIM_CCER_CC3NE                                           ((uint16_t)0x0400)
#define TIM_CCER_CC3NP                                           ((uint16_t)0x0800)
#define TIM_CCER_CC4E                                            ((uint16_t)0x1000)
#define TIM_CCER_CC4P                                            ((uint16_t)0x2000

И смело дописываем:

#define TIM_CCER_CC4NP                                           ((uint16_t)0x8000)

Вот теперь все собирается, можно отлаживать. Включаем логический анализатор. В командной строке пишем: la portb&0x01 и наблюдаем на выходе:

Видим, что все работает правильно! В следующей статье будем изучать режим генерации ШИМ, оставайтесь на связи 🙂