Многозадачный программный таймер.

В мире микроконтроллеров, как и в мире вообще — существуют разного рода задачи. Какие-то требуют немедленного исполнения, какие-то могут подождать. Но есть и такие, которые возникают крайне редко, но их количество может быть внушительным. Вот о реализации таких задач (последних) мы и поговорим. Чтобы «убить» 7 мух(, а может быть и великанов) одним ударом — будем использовать программный таймер на базе одного аппаратного. Так как все задачи — «медленноприходящие» (интересно, есть такое слово в русском языке?) — настроим аппаратный таймер таким образом, чтобы тикал он несколько раз в секунду (например, 50 или даже 500). И создадим массив структур, в каждой из которых будет лежать вся информация по каждому программному таймеру отдельно. Итак, рассмотрим чего добился:

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

Хочу поделиться с вами исходниками и, как всегда, прежде всего вкусностями препроцессора. Файл Slow_timer.h состряпан таким образом, что для настройки таймера требуется минимум настроек, таких как выбор аппаратного таймера, частота срабатывания и кол-во программных ячеек(таймеров).

#define SLOW_TIMER_COUNT 		10
#define SLOW_TIMER_NUMBER		5			//Timer == (1..15) or SYSTICK (==0)
#define SLOW_TIMER_FREQUENCY		500			// 5..1000

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

Итак, сам Slow_timer.h

#ifndef SLOW_TIMER_H
#define SLOW_TIMER_H

#define SLOW_TIMER_COUNT                20
#define SLOW_TIMER_NUMBER               0              //Timer 1..15 or SYSTICK (==0)
#define SLOW_TIMER_FREQUENCY            500            // 5..1000

typedef enum
{
 tm_Not_Change,
 tm_Stop,
 tm_Repeat,
 tm_Once
} Timer_Mode_t;

#include <stdint.h>

void Init_Slow_Timer(void);
int8_t Slow_Timer_Add(Timer_Mode_t mode, uint16_t compare, void (*handler)());
uint16_t Slow_Timer_Get_Counter(int8_t TimerId);
void Slow_Timer_Delete(int8_t TimerId);
void Slow_Timer_Modify(int8_t TimerId, Timer_Mode_t mode, uint16_t counter, uint16_t compare);
void Slow_Timer_Lock(void);
void Slow_Timer_Unlock(void);
#endif

и файл Slow_timer.c:

#include "Slow_timer.h"
#include "bitbanding.h"
#include "stm32f10x.h"

#if (SLOW_TIMER_NUMBER == 1)||(SLOW_TIMER_NUMBER==8)||(SLOW_TIMER_NUMBER==9)||(SLOW_TIMER_NUMBER==10)||(SLOW_TIMER_NUMBER==11)
#define SYS_FREQ_TIMER                          SystemFrequency_APB2Clk
#define TIMER_IRQ_SUFFIX                        _UP_
#define TIMER_SLOW_APBENR                       APB2ENR
#else
#define SYS_FREQ_TIMER                         (SystemFrequency_APB1Clk*2)
#define TIMER_IRQ_SUFFIX                        _
#define TIMER_SLOW_APBENR                       APB1ENR
#endif

#define __SLOW_TIMER(N)                         TIM##N
#define _SLOW_TIMER(N)                          __SLOW_TIMER(N)
#define SLOW_TIMER                              _SLOW_TIMER(SLOW_TIMER_NUMBER)

#define __SLOW_TIMER_IRQH(N,S)                  TIM##N##S##IRQHandler
#define _SLOW_TIMER_IRQH(N,S)                   __SLOW_TIMER_IRQH(N,S)

#if SLOW_TIMER_NUMBER>0
#define SLOW_TIMER_IRQHandler                   _SLOW_TIMER_IRQH(SLOW_TIMER_NUMBER, TIMER_IRQ_SUFFIX)
#else
#define SLOW_TIMER_IRQHandler                   SysTick_Handler
#endif

#define __SLOW_TIMER_IRQN(N,S)                  TIM##N##S##IRQn
#define _SLOW_TIMER_IRQN(N,S)                   __SLOW_TIMER_IRQN(N,S)
#define SLOW_TIMER_IRQn                         _SLOW_TIMER_IRQN(SLOW_TIMER_NUMBER, TIMER_IRQ_SUFFIX)

#define __SLOW_TIMER_RCC_EN(A, N)               RCC_##A##_TIM##N##EN
#define _SLOW_TIMER_RCC_EN(A, N)                __SLOW_TIMER_RCC_EN(A, N)
#define SLOW_TIMER_RCC_EN                       _SLOW_TIMER_RCC_EN(TIMER_SLOW_APBENR, SLOW_TIMER_NUMBER)

#define SLOW_TIMER_PRESCALER                    ((SYS_FREQ_TIMER/100000)-1)
#define SLOW_TIMER_PERIOD                       ((100000/SLOW_TIMER_FREQUENCY)-1)

typedef struct
{
   uint8_t timer_mode;
   uint16_t counter;
   uint16_t compare;
   void (*handler)();
} Slow_Timer_t;

volatile Slow_Timer_t Slow_Timers[SLOW_TIMER_COUNT];

void Slow_Timer_Lock(void)
{
#if SLOW_TIMER_NUMBER > 0
  BIT_BAND_PER(SLOW_TIMER->DIER,TIM_DIER_UIE)=RESET;
#else
  SysTick->CTRL&=~(SysTick_CTRL_TICKINT_Msk);
#endif
}

void Slow_Timer_Unlock(void)
{
#if SLOW_TIMER_NUMBER > 0
  BIT_BAND_PER(SLOW_TIMER->DIER,TIM_DIER_UIE)=SET;
#else
  SysTick->CTRL|=(SysTick_CTRL_TICKINT_Msk);
#endif
}

void Slow_Timer_Delete(int8_t TimerId)
{
  if (TimerId<SLOW_TIMER_COUNT)
  {
    Slow_Timers[TimerId].timer_mode=tm_Not_Change;
    Slow_Timers[TimerId].handler=0;
  }
}

void Init_Slow_Timer(void)
{
  uint8_t i;
  for(i=0;i<SLOW_TIMER_COUNT;i++)
    Slow_Timer_Delete(i);
  #if SLOW_TIMER_NUMBER > 0
    BIT_BAND_PER(RCC->TIMER_SLOW_APBENR,SLOW_TIMER_RCC_EN)=SET;
    SLOW_TIMER->PSC = SLOW_TIMER_PRESCALER;
    SLOW_TIMER->CNT = 0x0000;
    SLOW_TIMER->ARR = SLOW_TIMER_PERIOD;
    NVIC_SetPriority(SLOW_TIMER_IRQn,15);
    NVIC_EnableIRQ(SLOW_TIMER_IRQn);
    BIT_BAND_PER(SLOW_TIMER->EGR,TIM_EGR_UG)=SET; 
    BIT_BAND_PER(SLOW_TIMER->SR,TIM_SR_UIF)=SET;
    BIT_BAND_PER(SLOW_TIMER->DIER,TIM_DIER_UIE)=SET;
    BIT_BAND_PER(SLOW_TIMER->CR1,TIM_CR1_CEN)=SET;
  #else
    SysTick_Config(SystemFrequency/SLOW_TIMER_FREQUENCY);
  #endif
}

void Slow_Timer_Modify(int8_t TimerId, Timer_Mode_t mode, uint16_t counter, uint16_t compare)
{
  if ((TimerId<SLOW_TIMER_COUNT)&&(TimerId>=0))
  {  
    Slow_Timer_Lock();
    if (mode!=tm_Not_Change)
      Slow_Timers[TimerId].timer_mode = mode;
    if (counter)  
      Slow_Timers[TimerId].counter = counter;
    if (compare)  
      Slow_Timers[TimerId].compare = compare;
    Slow_Timer_Unlock();
  }
}

int8_t Slow_Timer_Add(Timer_Mode_t mode, uint16_t compare, void (*handler)())
{
  uint8_t i;
  if(mode!=tm_Not_Change)
  {
    for (i=0;i<SLOW_TIMER_COUNT;i++)
    {
      if (Slow_Timers[i].timer_mode==tm_Not_Change)
      {
        Slow_Timers[i].counter = 1;
        Slow_Timers[i].compare = compare;
        Slow_Timers[i].handler = handler;
        Slow_Timers[i].timer_mode = mode;
        return i;        
      }
    }
  }
  return -1;
}

uint16_t Slow_Timer_Get_Counter(int8_t TimerId)
{
  uint16_t counter=0;
  if ((TimerId>=0)&&(TimerId<SLOW_TIMER_COUNT))  
  {
    Slow_Timer_Lock();
    counter=Slow_Timers[TimerId].counter;
    Slow_Timer_Unlock();
  }
  return counter;
}

void SLOW_TIMER_IRQHandler(void)
{
  uint8_t i;
  #if SLOW_TIMER_NUMBER > 0
    BIT_BAND_PER(SLOW_TIMER->SR,TIM_SR_UIF)=RESET;
  #endif
  for(i=0;i<SLOW_TIMER_COUNT;i++)
  {
    if(Slow_Timers[i].timer_mode > tm_Stop)
    {
      if(Slow_Timers[i].counter >= Slow_Timers[i].compare)
      {
        Slow_Timers[i].counter = 1;
        if(Slow_Timers[i].timer_mode==tm_Once)
          Slow_Timers[i].timer_mode = tm_Stop;
        if (Slow_Timers[i].handler)
          Slow_Timers[i].handler();
      }
      else
        Slow_Timers[i].counter++;
    }
  }
}

Для инициализации программного таймера в системе запустим функцию:

Init_Slow_Timer();

Чтобы нам стартовать (инициализировать) вложенный программный таймер, нужно выполнить функцию:

uint8_t Slow_Timer_Add(Timer_Mode_t mode, uint16_t compare, void (*handler)())

где:
mode — режим таймера. Их три: выключен (tm_Stop), включен однократно (tm_Once) или постоянно (tm_Repeat)
compare — число сравнения. Если вы укажете здесь значение, равное 0 или 1 — таймер «тикнет» один раз. Если 2 — 2 раза и так далее…
handler — указатель на функцию, которая будет вызываться при срабатывании таймера.

Чтобы вычислить период задержки — нужно пользоваться несложной формулой:
VALUE = SLOW_TIMER_FREQUENCY * PERIOD, где:
VALUE — значение, записываемое в counter;
SLOW_TIMER_FREQUENCY — константа, определяющая частоту прерываний аппаратного таймера
PERIOD — требуемое время задержки в секундах.

Если мы хотим вычислить частоту вызова — тогда здесь другая формула:
VALUE = SLOW_TIMER_FREQUENCY / FREQUENCY, где:
VALUE, SLOW_TIMER_FREQUENCY аналогично
FREQUENCY — требуемая частота вызова функции в Гц. Учтите, что частота вызова не может быть больше частоты работы самого таймера и будет всегда кратна значению SLOW_TIMER_FREQUENCY.

Функция возвращает число: идентификатор программного таймера или -1, если таймер инициализировать не удалось. Таким образом, если потребуется в дальнейшем этот таймер конфигурировать — то это значение нужно сохранить, например в глобальной переменной Keyboard_Timer_Id (так мы обозвали переменную в модуле опроса клавиатуры):

Keyboard_Timer_Id = Slow_Timer_Add(tm_Repeat, SLOW_TIMER_FREQUENCY / 50 /*50Гц*/, KeyboardExe);

Конфигурация программного таймера доступна через функцию Slow_Timer_Modify. Вот ее описание:

void Slow_Timer_Modify(int8_t TimerId, Timer_Mode_t mode, uint16_t counter, uint16_t compare);

где:
TimerId — идентификатор таймера
mode — режим таймера (аналогично как в функции Slow_Timer_Add)
counter — программный счетчик. Если таймер активен(см. timer_mode), то этот параметр инкрементируется на 1 при каждом срабатывании прерывания таймера до тех пор, пока не это число не станет равным compare(см. ниже). После этого значение сбрасывается (присваивается 1), и происходит вызов функции handler (см. выше).
compare — число сравнения.
Если параметр mode изменять не требуется — пишем туда — tm_Not_Change. Если параметр compare или counter изменять не требуется — пишем 0 в соответствующие поля.

Чтобы узнать, сколько времени прошло с момента, когда мы таймер запустили — используйте функцию Slow_Timer_Get_Counter:

uint16_t counter = Slow_Timer_Get_Counter(int8_t TimerId);

Чтобы удалить таймер, используйте функцию Slow_Timer_Delete:

Slow_Timer_Delete(int8_t TimerId);

, где единственным параметром этой функции является идентификатор TimerId.

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

#include "Slow_timer.h"
.....
int main (void)
{
.....
  Init_Slow_Timer();//инициализируем Slow Timer
  Init_Led(); //инициализируем светодиод
.....
  Led_On(); // Где-то в программе включаем светодиод. Через нужное кол-во сек он сам погаснет
}
// где-то в модуле, например в "led.c"
#define LED_LIGHT_PERIOD     5
int8_t Led_Timer_Id;

void Led_Off()
{
  LED_OFF;
}

//Инициализация таймера:
void Init_Led(void)
{
  Led_Timer_Id=Slow_Timer_Add(tm_Stop, SLOW_TIMER_FREQUENCY * LED_LIGHT_PERIOD, Led_Off);
  .....
}

//Включение светодиода:
void Led_On(void)
{
  LED_ON; // какой-то там макрос или команда, включающая светодиод
  Slow_Timer_Modify(Led_Timer_Id, tm_Once, 1, 0); //Запускаем таймер для выключения светодиода через 5 сек.
//                        ↑          ↑     ↑  ↑
// идентификатор таймера ─┘          │     │  │
// режим однократного срабатывания ──┘     │  │
// сбрасываем счетчик ─────────────────────┘  │
// период оставляем без изменений ────────────┘
}

Ну вот и все!

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

PS: Отдельная благодарность teplofizik и Vga за активное участие в процессе становления сего продухта))

UPD:
Продолжение жизни данного таймера смотрите в следующей статье