slowtimer.c

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

// Привязку к контроллеру тоже делаем внутри сишника, не надо светить ею наружу - это не их дело
#include <stm32f10x.h>

// Снаружи это знать никому не надо, потому пусть в сишнике и объявляется, а не в заголовочном
typedef enum
{
    TIMER_MODE_DELETED,
    TIMER_MODE_STOP,
    TIMER_MODE_REPEAT,
    TIMER_MODE_ONCE
} TTimerMode;

// Ну и все кишочки тоже спрячем. Внешним модулям толку от них никакого, только зря мусорить в пространстве имён будет
#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)
#define SLOW_TIMER_IRQHandler                   _SLOW_TIMER_IRQH(SLOW_TIMER_NUMBER, TIMER_IRQ_SUFFIX)

#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 reload;
   void (*handler)();
} sSlow_Timer;

volatile sSlow_Timer Slow_Timers[SLOW_TIMER_COUNT];

__inline void Slow_Timer_Lock(void)
{
    BIT_BAND_PER(SLOW_TIMER->DIER,TIM_DIER_UIE)=RESET;
}

__inline void Slow_Timer_Unlock(void)
{
    BIT_BAND_PER(SLOW_TIMER->DIER,TIM_DIER_UIE)=SET;
}

void Slow_Timer_Delete(int8_t index)
{
    if (index >= SLOW_TIMER_COUNT) return;

    Slow_Timers[index].timer_mode = TIMER_MODE_DELETED;
    Slow_Timers[index].handler = 0;
}

void Init_Slow_Timer(void)
{
    uint8_t i;
    for(i = 0; i < SLOW_TIMER_COUNT; i++) Slow_Timer_Delete(i);

    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;
}

void Slow_Timer_Modify(int8_t index, uint8_t mode, uint16_t counter, uint16_t reload)
{
    if (index >= SLOW_TIMER_COUNT) return;

    Slow_Timer_Lock();
    if (!mode)    Slow_Timers[index].timer_mode = mode;
    if (!counter) Slow_Timers[index].counter = counter;
    if (!reload)  Slow_Timers[index].reload = reload;
    Slow_Timer_Unlock();
}

int8_t Slow_Timer_Add(uint8_t mode, uint16_t counter, void (*handler)(void))
{
    uint8_t i;

    for (i = 0; i < SLOW_TIMER_COUNT; i++)
    {
        if (Slow_Timers[i].timer_mode == TIMER_MODE_DELETED)
        {
            Slow_Timers[i].counter = counter;
            Slow_Timers[i].reload = counter;
            Slow_Timers[i].handler = handler;
            Slow_Timers[i].timer_mode = mode;
            return i;
        }
    }

    return -1;
    // Проверка тут не нужна
}

void SLOW_TIMER_IRQHandler(void)
{
    uint8_t i;

    BIT_BAND_PER(SLOW_TIMER->SR,TIM_SR_UIF) = RESET;
    for(i = 0; i < Timer_Counter - 1; i++)
    {
        // Шлак пропустим
        if(Slow_Timers[i].timer_mode <= TIMER_MODE_STOP) continue;

        if(Slow_Timers[i].counter <= 1)
        {
            void (* Handler)(void) = Slow_Timers[i].handler;

            // Перезапустим
            Slow_Timers[i].counter = Slow_Timers[i].reload;
            if(Slow_Timers[i].timer_mode == TIMER_MODE_ONCE)
                Slow_Timers[i].timer_mode = TIMER_MODE_STOP;

            // Поменяем все поля заранее, чтоб не насорить потом, если таймер удалят в handler или ещё что
            if(Handler) Handler();
        }
        else
        {
            Slow_Timers[i].counter--;
        }
    }
}