Многозадачный программный таймер, ver 2.0

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


Поскольку мой таймер не отличается большой приоритетностью и частотой срабатывания — его прерыванию был назначен минимальный приоритет — 15.
Все остальные прерывания могут его «обскакивать» без проблем. Проблемы начинаются, когда вот в этих самых прерываниях имеется необходимость управлять программным таймером. И еще не надо забывать и об основном цикле. Эти функции нужны и для основного цикла тоже.
И что же теперь делать?
Почитав замечательную статью на нашем форуме Атомарные операции в Cortex-M3 у меня возникла идея, как это воплотить. Хорошая это идея или нет — решать вам.
Итак, сначала идет заголовок:

#ifndef SYSTEM_TIMER_H
#define SYSTEM_TIMER_H

//-------- <<< Use Configuration Wizard in Context Menu >>> --------------------

// <h> System Timer Initialization
//   <o> Count: <1-20>
//   <i> System-Timer count setup
#define SYSTEM_TIMER_COUNT                25
//   <o> Frequency Hz <5-2000>
//   <i> System-Timer Frequency setup
#define SYSTEM_TIMER_FREQUENCY            500
// </h>

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

#include <stdint.h>

void Init_System_Timer(void);
uint8_t System_Timer_Get_Status(int8_t TimerId);
void System_Timer_Reset_Status(int8_t TimerId);
int8_t System_Timer_Add(Timer_Mode_t mode, uint16_t compare, void (*handler)());
int8_t System_Timer_Set_Mode(int8_t TimerId, Timer_Mode_t mode);
void System_Timer_Clear_Counter(int8_t TimerId); 
void System_Timer_Set_Compare(int8_t TimerId, uint16_t compare); 
uint16_t System_Timer_Get_Counter(int8_t TimerId);
void System_Timer_Delete(int8_t TimerId);
void System_Timer_Lock(int8_t TimerId);
void System_Timer_Unlock(int8_t TimerId);
#endif

далее само «тело»:

#include "stm32f10x.h"
#include "system_timer.h"
#include "RTE_Device.h"
#include "mutex.h"
#include "bitbanding.h"

typedef struct
{
    uint8_t timer_mode;
		uint8_t timer_status;
		// 0..6 bit - lock counter; 7 bit - timer event;
    uint16_t counter;
    uint16_t compare;
    void (*handler)();
} System_Timer_t;

volatile System_Timer_t System_Timers[SYSTEM_TIMER_COUNT];

uint8_t System_Timer_Get_Status(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    if (System_Timers[TimerId].timer_mode != tm_Free)
      return System_Timers[TimerId].timer_status & 0x80;
  return 0;
}

void System_Timer_Reset_Status(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    BIT_BAND_SRAM(&System_Timers[TimerId].timer_status,7) = 0;		
}	

void System_Timer_Lock(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    Atomic8AddAndFetch(&(System_Timers[TimerId].timer_status), 1);
}

void System_Timer_Unlock(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    Atomic8AddAndFetch(&(System_Timers[TimerId].timer_status), -1);
}

void System_Timer_Delete(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {
    System_Timers[TimerId].timer_mode = tm_Free;
    __CLREX():
  }
}

void Init_System_Timer(void)
{
  uint8_t i;
  NVIC_SetPriority(SysTick_IRQn, 15);
  for(i = 0; i < SYSTEM_TIMER_COUNT; i++)
    System_Timer_Delete(i);
  SysTick_Config(RTE_SYSCLK / SYSTEM_TIMER_FREQUENCY -1);
}

int8_t System_Timer_Set_Mode(int8_t TimerId, Timer_Mode_t mode) //if OK - return 1
{
  int8_t temp = 0;
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {  
    if (mode != tm_Free)
    {
      do
      {
         temp = __LDREXB(&System_Timers[TimerId].timer_mode);
         if (temp != tm_Free)
           temp = mode;
      }while(__STREXB(temp, &System_Timers[TimerId].timer_mode));
    }
  }
return temp != 0;
}

void System_Timer_Clear_Counter(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {  
    System_Timers[TimerId].counter = 1;
    __CLREX():
  }
}

void System_Timer_Set_Compare(int8_t TimerId, uint16_t compare)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {  
    System_Timers[TimerId].compare = compare;
  }
}

uint16_t System_Timer_Get_Counter(int8_t TimerId)
{
  uint16_t counter = 0;
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {
    counter = System_Timers[TimerId].counter;
  }
  return counter;
}

int8_t System_Timer_Add(Timer_Mode_t mode, uint16_t compare, void (*handler)())
{
  uint8_t i;
  Timer_Mode_t temp;
  uint8_t result;
  if(mode != tm_Free)
  {
    for (i = 0; i < SYSTEM_TIMER_COUNT; i++)
    {
      do
      {
        result = 2;
        temp = (Timer_Mode_t)__LDREXB(&System_Timers[i].timer_mode);
        if (temp == tm_Free)
          result = __STREXB(tm_Stop, &System_Timers[i].timer_mode);
        else
          __CLREX();
      }while(result == 1);
      if (!result)
      {
        System_Timers[i].counter = 1;
        System_Timers[i].compare = compare;
        System_Timers[i].handler = handler;
        System_Timers[i].timer_status = 0;
        System_Timers[i].timer_mode = mode;
        return i;
      }
    }
  }
  return -1;
}

void SysTick_Handler(void)
{
  uint8_t i;
  void (*handler)();
  Timer_Mode_t mode; 
  for(i = 0; i < SYSTEM_TIMER_COUNT; i++)
  {
    if ((!(System_Timers[i].timer_status & 0x7F)) && (System_Timers[i].timer_mode > tm_Stop))
    {
      if(System_Timers[i].counter >= System_Timers[i].compare)
      {
        System_Timers[i].counter = 1;
        handler = System_Timers[i].handler;
        do
        {
          mode = (Timer_Mode_t)__LDREXB(&(System_Timers[i].timer_mode));
          if (mode == tm_Once)
            mode = tm_Stop;
        }while(__STREXB(mode, &System_Timers[i].timer_mode));
        BIT_BAND_SRAM(&System_Timers[i].timer_status,7) = 1;
        if ((handler) && (mode))
          handler();
      }
      else
        Atomic16AddAndFetch(&System_Timers[i].counter, 1);
    }
  }
}

А теперь разберемся что да как:
Функция SysTick_Handler() является тем самым «сердцем» нашего таймера. Здесь происходит периодичное выполнение всех назначенных задач. Все остальные функции — доступны извне, то есть, могут вызываться как и из основного цикла, так и из более приоритетных прерываний. Следовательно — работа этого «сердца» может прерывать свои же интерфейсные функции, и может быть прервана ими же. Для решения этих задач требуется синхронизация, и здесь активно используется связка команд процессора LDREX и STREX. Теория работы этих команд хорошо изложена в вышеуказанной статье, поэтому я не буду вдаваться в подробности. Итак, разберем функцию SysTick_Handler:

void SysTick_Handler(void)
{
  uint8_t i;
  void (*handler)();
  Timer_Mode_t mode; 
  for(i = 0; i < SYSTEM_TIMER_COUNT; i++)
  {
    if ((!(System_Timers[i].timer_status & 0x7F)) && (System_Timers[i].timer_mode > tm_Stop))
    {
      if(System_Timers[i].counter >= System_Timers[i].compare)
      {
    	System_Timers[i].counter = 1;
	handler = System_Timers[i].handler;

До сих пор нет ничего необычного. Организуется цикл, проверяется режим работы таймеров, сравниваются счетчики, проверка блокировки таймеров и сброс счетчиков в начало (==1) при удачном сравнении. Отмечу лишь, что мы сохраняем указатель на функцию в отдельную переменную. Для чего это — будет разъяснено позже.
Дальше нам нужно переключить режим таймера с «однократный» (tm_Once) на «остановлен» (tm_Stop).
Только вот незадача: А вдруг в тот самый момент, когда мы производим «чтение — модификация — запись»(далее ЧМЗ) у нас этот самый таймер был удален вызовом функции System_Timer_Delete(TimerId)? Вот здесь нам на помощь и придут те самые команды процессора LDREX STREX. Смотрим дальше:

        do
        {
          mode = (Timer_Mode_t)__LDREXB(&(System_Timers[i].timer_mode));
          if (mode == tm_Once)
            mode = tm_Stop;
        }while(__STREXB(mode, &System_Timers[i].timer_mode));

Ну что, кажется теперь все будет работать. Если в процессе ЧМЗ флаг эксклюзивного доступа будет сброшен — то однозначно произойдет все сначала. Цикл повторится и данные будут правильно обработаны. Кстати сказать, не нужно забывать, что все подобные переменные должны иметь приписочку "volatile" иначе все будет напрасно.
Едем дальше:

        BIT_BAND_SRAM(&System_Timers[i].timer_status,7) = 1;
        if ((handler) && (mode))
          handler();

Здесь, собственно, устанавливаем событие вызова (7 бит статуса). Используется модуль «bitbanding.h» далее — вызов подпрограмм. На последнем рубеже снова удостоверимся, что удаления не было. После чего осуществляем вызов. Даже если таймер удалился после последней проверки — мы успели сохранить указатель на функцию, и счетчик команд не уйдет абы куда, а последний раз (на прощание) обратится к законной функции. Далее:

      }
      else
        Atomic16AddAndFetch(&System_Timers[i].counter, 1);
    }
  }
}

А здесь у меня используется немного модифицированная функция из статьи уважаемого neiver'а. и выглядит так:

uint16_t Atomic16AddAndFetch(volatile uint16_t * ptr, int16_t value)
{
  uint16_t oldValue, newValue;
  do
  {
    oldValue = __LDREXH(ptr);
    newValue = oldValue + value;
  }while(__STREXH(newValue, ptr));
  return newValue;
}

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

Теперь поговорим об интерфейсных функциях:

uint8_t System_Timer_Get_Status(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    if (System_Timers[TimerId].timer_mode != tm_Free)
      return System_Timers[TimerId].timer_status & 0x80;
  return 0;
}

Здесь мы получаем положительное значение (0x80) если таймер сработал или 0 — если нет.

void System_Timer_Reset_Status(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    BIT_BAND_SRAM(&System_Timers[TimerId].timer_status,7) = 0;		
}

Здесь сбрасываем атомарно событие таймера.

void System_Timer_Lock(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    Atomic8AddAndFetch(&(System_Timers[TimerId].timer_status), 1);
}

void System_Timer_Unlock(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
    Atomic8AddAndFetch(&(System_Timers[TimerId].timer_status), -1);
}

Здесь, собственно функция блокировки/разблокировки одного из программных таймеров. Поскольку эти функции могут быть прерваны самими же собой или своими «антиподами» из основного цикла и какого-нибудь прерывания, необходимо не потерять кол-во вхождений подобных функций. С этим опять же хорошо справляется функция Atomic8AddAndFetch(). Вот ее код:

uint8_t Atomic8AddAndFetch(volatile uint8_t * ptr, int8_t value)
{
  uint8_t oldValue, newValue;
  do
  {
    oldValue = __LDREXB(ptr);
    newValue = oldValue + value;
  }while(__STREXB(newValue, ptr));
  return newValue;
}

Функции блокировки/разблокировки не поддерживают более 127 вложений lock/unlock, так что будьте внимательней. Дополнительных проверок в целях экономии ресурсов процессора нет.
Едем далее:

void System_Timer_Delete(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {
    System_Timers[TimerId].timer_mode = tm_Free;
    __CLREX();
  }
}

Здесь нет никаких блокировок и прочее. Здесь главное, timer_mode выполняется атомарной операцией. И добавляем сброс эксклюзива, на случай, если удаление будет вызвано в высокоприоритетном прерывании.
Функция Init_System_Timer() не участвует в процессе работы, ее рассматривать не будем.
Едем дальше:

int8_t System_Timer_Set_Mode(int8_t TimerId, Timer_Mode_t mode) //if OK - return 1
{
  int8_t temp = 0;
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {  
    if (mode != tm_Free)
    {
      do
      {
	 temp = __LDREXB(&System_Timers[TimerId].timer_mode);
	 if (temp != tm_Free)
	   temp = mode;
      }while(__STREXB(temp, &System_Timers[TimerId].timer_mode));
    }
  }
return temp != 0;
}

Смысл работы этой функции в следующем: Изменяя режим работы таймера, не напороться на подлянку — если этот самый таймер был удален… Функция возвращает «0», если изменение не удалось по той самой причине, если все ОК — возвращаем единичку

Дальше и дальше:

void System_Timer_Clear_Counter(int8_t TimerId)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {  
    System_Timers[TimerId].counter = 1;
    __CLREX();
  }
}

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

void System_Timer_Set_Compare(int8_t TimerId, uint16_t compare)
{
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {  
    System_Timers[TimerId].compare = compare;
  }
}

uint16_t System_Timer_Get_Counter(int8_t TimerId)
{
  uint16_t counter = 0;
  if ((TimerId < SYSTEM_TIMER_COUNT) && (TimerId >= 0))
  {
    counter = System_Timers[TimerId].counter;
  }
  return counter;
}

Функции сброса счетчика, установки значения сравнения и считывания счетчика — производятся де-факто атомарно, поэтому тут городить ничего не требуется.Главное, чтобы в программе не путать местами используемые функции. Например, сначала мы сбрасываем счетчик, а уж потом изменяем значение сравнения (ну если это потребуется конечно)… И да, не забываем, что это все — volatile.

Следующая функция требует более внимательного рассмотрения. System_Timer_Add() — позволяет добавлять новые таймеры уже в процессе работы. Предполагается, что эта функция будет перекрыта и сама собою, и прерыванием таймера SysTick. Алгоритм работы следующий. Функция ищет пустой программный таймер в массиве таймеров и занимает его. Если учитывать, что место может быть занято дважды(трижды, пятижды))) — то нужно как то от этого защититься. Смотрим код:

int8_t System_Timer_Add(Timer_Mode_t mode, uint16_t compare, void (*handler)())
{
  uint8_t i;
  Timer_Mode_t temp;
  uint8_t result;
  if(mode != tm_Free)
  {
    for (i = 0; i < SYSTEM_TIMER_COUNT; i++)
    {

Организовываем первоначальные проверки и запускаем цикл. Далее:

      do
      {
	result = 2;
	temp = (Timer_Mode_t)__LDREXB(&System_Timers[i].timer_mode);
	if (temp == tm_Free)
	  result = __STREXB(tm_Stop, &System_Timers[i].timer_mode);
	else
	  __CLREX();
      }while(result == 1);

Тот самый блок синхронизации. Сначала в temp помещаем значение режима таймера через LDREX.
если temp — означает «пустой» таймер, то мы его пытаемся занять через запись STREX. Устанавливаем режим таймера как «остановлен», чтобы избежать несанкционированной обработки от прерывания SysTick.
Итак, запись удачна? — значит в result — 0, если не удалось записать — значит в result — единица и повтор по циклу. Впрочем, если таймер уже занят, то мы так же выкатываемся из цикла со значением в result == 2
Ну а дальше все просто:

      if (!result)
      {
	System_Timers[i].counter = 1;
	System_Timers[i].compare = compare;
	System_Timers[i].handler = handler;
        System_Timers[i].timer_status = 0;
	System_Timers[i].timer_mode = mode;
	return i;
      }
    }
  }
  return -1;
}

Главное, чтобы timer_mode — заполнялся последним. И здесь снова вспомним про заветный volatile

Ну вот, подробный обзор завершен, прошу ваше мнение, господа!

UPDATE:
В связи с развенчанием коллективного заблуждения по поводу работы пары LDREX — STREX нынешний код мною был подправлен.
Сделаю небольшой экскурс в историю.
Мною было замечено, что цикл LDREX и STREX работает не всегда так как предполагалось. Оглашу несколько заблуждений, витающих в рунете:
1. LDREX — STREX контролируют определенную ячейку в памяти и не допускают ее изменения в промежутке между этими командами.
2. LDREX — STREX не терпит обращения к памяти внутри блока.
Тест:

ptr = &Counters[channel];
do
{
  oldValue = __LDREXH(ptr);
  newValue = (oldValue < CHECK_COUNTER)? CHECK_COUNTER : oldValue;
  (*ptr)++;
}while(__STREXH(newValue, ptr));

Результат отрицательный. Команда STREX успешно выполняется и глазом не моргнув, что ячейка подверглась изменению.

3. LDREX — STREX не срабатывает, если пришло прерывание внутри блока.
Тест:

ptr = &Counters[channel];
do
{
  oldValue = __LDREXH(ptr);
  newValue = (oldValue < CHECK_COUNTER)? CHECK_COUNTER : oldValue;
  EXTI->SWIER = 0x00000001;//программно вызываем прерывание
  __NOP();
}while(__STREXH(newValue, ptr));

void EXTI0_IRQHandler(void)
{
	EXTI->SWIER = 0x00000000;
	EXTI->PR = 0x00000001;
	(*ptr)++;
}

Результат абсолютно аналогичен. Система не отреагировала ни на прерывание, ни на изменение в нем ячейки памяти.

Как же оно работает? А вот так:

ptr = &Counters[channel];
do
{
  oldValue = __LDREXH(ptr);
  newValue = (oldValue < CHECK_COUNTER)? CHECK_COUNTER : oldValue;
  __CLREX(); // сбрасываем флаг эксклюзива
}while(__STREXH(newValue, ptr));

И так:

ptr = &Counters[channel];
do
{
  oldValue = __LDREXH(ptr);
  newValue = (oldValue < CHECK_COUNTER)? CHECK_COUNTER : oldValue;
  __STREXH(__LDREXH(ptr) + 1, ptr); //Инструкции LDREX - STREX. После выполнения сбрасывается флаг эксклюзива
}while(__STREXH(newValue, ptr));

И даже вот так:

ptr = &Counters[channel];
ptr2 = &Counters[(channel + 1)&0x07];
do
{
  oldValue = __LDREXH(ptr);
  newValue = (oldValue < CHECK_COUNTER)? CHECK_COUNTER : oldValue;
  __STREXH(__LDREXH(ptr2) + 1, ptr2);
}while(__STREXH(newValue, ptr));

Здесь видно, что изменяется внутри цикла другая(!) ячейка памяти, однако STREX уже выдает ошибку записи. Отсюда вывод:
1. LDREX при чтении взводит некий флаг эксклюзива. STREX выполняет сохранение только в случае, если этот флаг возведен, и после сбрасывает флаг. Все! Нет ничего более, кроме этого.

Как правильно пользоваться:
1. Определить для себя ячейку(и) памяти, которая(ые) будет(ут) контролироваться эксклюзивным методом.
2. Если требуется произвести ЧМЗ — выполнять только через пару эксклюзивного доступа. Исключением может быть только самое высокоприоритетное прерывание, где можно указать только сброс флага:

(*ptr)++;
__CLREX();

3. Если требуется только запись — то можно ограничиться сбросом эксклюзивного флага:

(*ptr) = value;
__CLREX();

4. Если читаем — то ничего дополнительного писать не требуется.

Теперь вернемся к теме.
Последние изменения коснулись функций

System_Timer_Clear_Counter();
System_Timer_Delete();

, где было добавлено

__CLREX();

в связи с последними замечаниями.

Успехов в программировании!