us_timer.c

#include "us_timer.h"
#include "nrf_util.h"
#include <stddef.h>

#if ISR_MANAGER == 1
#include "isr_manager.h"
#endif

#define TIMER_ID              CONCAT_2(NRF_TIMER, US_TIMER_USED)
#define TIMER_IRQN            CONCAT_3(TIMER, US_TIMER_USED, _IRQn)
#define TIMER_IRQ_Handler     CONCAT_3(TIMER, US_TIMER_USED, _IRQHandler)
#define TIMER_SIZE            CONCAT_3(NRF_TIMER, US_TIMER_USED, _MAX_SIZE)

#define TIMER_PRESCALER    4

#if(TIMER_SIZE ==32)
#define TIMER_BITSIZE      TIMER_BITMODE_BITMODE_32Bit
#else
#define TIMER_BITSIZE      TIMER_BITMODE_BITMODE_16Bit
#endif

static struct us_timer_t{
    volatile uint32_t timer_mode;
    void (*timer_handler)(void);
}us_timer[US_TIMER_MAX];

static volatile uint32_t us_timers_status;

void us_timer_init(uint32_t irq_priority){
    for(us_timer_num id = US_TIMER0; id < US_TIMER_MAX; id++){
        us_timer[id].timer_mode = US_SINGLE_CALL;
        us_timer[id].timer_handler  = NULL;
    }
    us_timers_status = 0;

    TIMER_ID->TASKS_STOP      = 1;                        // Stop timer.
    TIMER_ID->MODE            = TIMER_MODE_MODE_Timer;    // Set the timer in Timer Mode.
    TIMER_ID->PRESCALER       = TIMER_PRESCALER;         // Prescaler 4 produces 1 MHz.
    TIMER_ID->BITMODE         = TIMER_BITSIZE;           // 32 bit mode.
    TIMER_ID->TASKS_CLEAR     = 1;                        // clear the Timer first to be usable for later.
    TIMER_ID->TASKS_START     = 1;

    NVIC_SetPriority(TIMER_IRQN, irq_priority);
    NVIC_EnableIRQ(TIMER_IRQN);
}

void us_timer_start(us_timer_num id, us_timer_mode mode, uint32_t time_us, void (*handler)(void)){
    us_timer[id].timer_handler = handler;
    if(mode == US_SINGLE_CALL){
        us_timer[id].timer_mode  = US_SINGLE_CALL;
    }else{
        us_timer[id].timer_mode  = time_us;
    }

    TIMER_ID->TASKS_CAPTURE[id] = 1;
    TIMER_ID->CC[id] += time_us;

    TIMER_ID->EVENTS_COMPARE[id]  = 0;
    TIMER_ID->INTENSET            = 1 << (TIMER_INTENSET_COMPARE0_Pos + id);

    //If no timers are currently on
    if (us_timers_status == 0)
    {
        TIMER_ID->TASKS_START = 1;
    }

    us_timers_status |= 1 << id;
}

void us_timer_stop(us_timer_num id){
    us_timer[id].timer_mode  = US_SINGLE_CALL;
    us_timers_status &= ~(1 << id);

    TIMER_ID->INTENCLR        = 1 << (TIMER_INTENSET_COMPARE0_Pos + id);

    //If the stopped timer is the last timer that's on
    if (us_timers_status == 0)
    {
        TIMER_ID->TASKS_STOP          = 1;                // Stop timer.
        TIMER_ID->TASKS_SHUTDOWN      = 1;                // Fully stop timer.
    }
}

bool us_timer_get_on_status(us_timer_num id){
    return ((us_timers_status & (1<<id)) != 0);
}

#if ISR_MANAGER == 1
void us_timer_timer_Handler ()
#else
void TIMER_IRQ_Handler()
#endif
{
    for(us_timer_num id = US_TIMER0; id < US_TIMER_MAX; id++){
        if(TIMER_ID->EVENTS_COMPARE[id]){
#if ISR_MANAGER == 0
            TIMER_ID->EVENTS_COMPARE[id] = 0;
            (void) TIMER_ID->EVENTS_COMPARE[id];
#endif
            void (*cb_handler)(void) = NULL;
            if(us_timer[id].timer_handler != NULL)
            {
                cb_handler = us_timer[id].timer_handler;
            }

            if (us_timer[id].timer_mode == US_SINGLE_CALL)
            {
                us_timer_stop(id);
            }
            else
            {
                TIMER_ID->TASKS_CAPTURE[id] = 1;
                TIMER_ID->CC[id] += us_timer[id].timer_mode;
            }

            if(cb_handler != NULL)
            {
                cb_handler();
            }
        }
    }
}