timer.c

Go to the documentation of this file.

#include "user_config.h"

#ifdef AVR
#include <stdlib.h>
#define HAVE_HIRES_TIMER /*< We can read a high resolution hardware timer */
#endif

#include "printf/mathio.h"

#include "lib/time.h"
#include "lib/timer.h"

volatile ts_t __clock;

tz_t __tzone;

static int timers_enabled = 0;
static int timers_configured = 0;

TIMERS timer_irq[MAX_TIMER_CNT];


MEMSPACE
int set_timers(void (*handler)(void), int timer)
{
    int i;
    int ret = -1;

    if(!handler)
        return -1;

    for(i=0;i<MAX_TIMER_CNT;++i)
    {

        // already assigned
        if(timer_irq[i].user_timer_handler == handler)
            ret = i;

        if(!timer_irq[i].user_timer_handler)
        {
            timer_irq[i].timer = 0;   // Set to disable
            timer_irq[i].user_timer_handler = handler;
            timer_irq[i].timer = 1;      // Set if enabled, 0 if not
            ret = i;
            break;
        }
    }
    if(ret == -1)
        printf("set_timers: No more timers!\n");

    return(ret);
}


MEMSPACE
int kill_timer( int timer )
{
    int ret = -1;
    if(timer >= 0 && timer <= MAX_TIMER_CNT)
    {
        timer_irq[timer].timer = 0;               // Disable
        timer_irq[timer].user_timer_handler = 0;
        ret = timer;
    }
    return(ret);
}


MEMSPACE
void delete_all_timers()
{
    int i;
    for(i=0; i < MAX_TIMER_CNT; i++)
    {
        timer_irq[i].timer = 0;                   // Disable
        timer_irq[i].user_timer_handler = 0;
    }
}


MEMSPACE
void subtract_timespec(ts_t *a, ts_t *b)
{
    a->tv_nsec = a->tv_nsec - b->tv_nsec;
    if (a->tv_nsec < 0L)
    {
        a->tv_nsec += 1000000000L;
        a->tv_sec --;
    }
    a->tv_sec = a->tv_sec - b->tv_sec;
}


static char _ts_to_str[32];
MEMSPACE
char * ts_to_str(ts_t *val)
{
    snprintf(_ts_to_str,31,"%ld.%09ld", val->tv_sec, val->tv_nsec);
    return( _ts_to_str );
}

MEMSPACE
void display_ts(ts_t *val)
{
    printf("[Seconds: %s]\n", ts_to_str(val) );
}


static ts_t __clock_elapsed;

MEMSPACE
void clock_elapsed_begin()
{
    clock_gettime(0, (ts_t *) &__clock_elapsed);
}


MEMSPACE
void clock_elapsed_end(char *msg)
{
    ts_t current;

    clock_gettime(0, (ts_t *) &current);

    subtract_timespec((ts_t *) &current, (ts_t *) &__clock_elapsed);

    if(msg && *msg)
        printf("[%s Time:%s]\n", msg, ts_to_str((ts_t *) &current) );
    else
        printf("[Time:%s]\n", ts_to_str((ts_t *) &current) );
}

MEMSPACE
void clock_clear()
{
    struct timespec ts;
    ts.tv_nsec = 0;
    ts.tv_sec = 0;
    clock_settime(0, &ts);
    __tzone.tz_minuteswest = 0;
    __tzone.tz_dsttime = 0;
}

MEMSPACE
void disable_timers()
{
    if(timers_configured && timers_enabled)
    {
        disable_system_task();
        timers_enabled = 0;
    }
}

MEMSPACE
void enable_timers()
{
    if(timers_configured && !timers_enabled)
    {
        enable_system_task();
        timers_enabled = 1;
    }
}

void execute_timers()
{
    int i;

    for(i=0; i < MAX_TIMER_CNT; i++)
    {
        if(timer_irq[i].timer && timer_irq[i].user_timer_handler != NULL)
            (*timer_irq[i].user_timer_handler)();
    }
}

void clock_task(void)
{
    __clock.tv_nsec += 1000000;
    if(__clock.tv_nsec >= 1000000000L)
    {
        __clock.tv_sec++;
        __clock.tv_nsec = 0;
    }
}

//
MEMSPACE
void init_timers()
{
    printf("Timers init called\n");

    if(!timers_configured)
    {
        install_timers_isr();
        timers_configured = 1;
        timers_enabled = 0;
        printf("Timers configured\n");
    }

    delete_all_timers();

    clock_clear();
    printf("Clock Init\n");

    if(set_timers(clock_task,1) == -1)
        printf("Clock task init failed\n");
    printf("Clock Installed\n");

    enable_timers();

    printf("Timers enabled\n");
}


MEMSPACE
int clock_getres(clockid_t clk_id, struct timespec *res)
{
    res->tv_sec = 0;
    res->tv_nsec = SYSTEM_TASK_TIC_NS;
    return(0);
}


MEMSPACE
int clock_settime(clockid_t clk_id, const struct timespec *ts)
{
    if(clk_id)
        return(-1);

    while(1)
    {
        __clock.tv_nsec = ts->tv_nsec;
        __clock.tv_sec  = ts->tv_sec;

        if(ts->tv_nsec != __clock.tv_nsec || ts->tv_sec != __clock.tv_sec)
            continue;
        break;
    }

    return(0);
}

#if ! defined(HAVE_HIRES_TIMER) 

//TODO try to use system_get_time() to get microsecond offsets
MEMSPACE
int clock_gettime(clockid_t clk_id, struct timespec *ts)
{
    ts->tv_nsec = 0;
    ts->tv_sec = 0;

    while(1)
    {
        ts->tv_nsec = __clock.tv_nsec;
        ts->tv_sec = __clock.tv_sec;
        if(ts->tv_nsec != __clock.tv_nsec || ts->tv_sec != __clock.tv_sec)
            continue;
        break;
    }
    return(0);
}

#endif