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 "mathio.h"
 
#include "time.h"
#include "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  __attribute__((unused)))
{
    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  __attribute__((unused)), struct timespec *res)
{
    if(clk_id)
        return(-1);
    res->tv_sec = 0;
    res->tv_nsec = SYSTEM_TASK_TIC_NS;
    return(0);
}
 
 
MEMSPACE
int clock_settime(clockid_t clk_id  __attribute__((unused)), 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  __attribute__((unused)), struct timespec *ts)
{
 
    if(clk_id)
        return(-1);
 
    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