timer.c

Go to the documentation of this file.

/*
 * Copyright (C) 2001-2006 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 */

#include <cfg/os.h>
#include <dev/irqreg.h>

#include <sys/types.h>
#include <sys/atom.h>
#include <sys/heap.h>
#include <sys/thread.h>
#include <sys/timer.h>
#include <sys/nutdebug.h>

#ifdef NUTDEBUG
#include <sys/osdebug.h>
#endif

#ifdef NUTTRACER
#include <sys/tracer.h>
#endif

#ifdef __NUT_EMULATION__
#include <sys/time.h>
static struct timeval   timeStart;
#endif

#include <string.h>


NUTTIMERINFO *nutTimerList;

/*
 * Last processing time of elapsed timers.
 */
static uint32_t nut_ticks_resume;

volatile uint32_t nut_ticks;

// volatile uint32_t nut_tick_dist[32];

static uint32_t clock_cache[NUT_HWCLK_MAX + 1];

#if defined(NUT_DELAYLOOPS)
uint32_t nut_delay_loops = NUT_DELAYLOOPS;
#else
uint32_t nut_delay_loops;
#endif

//Not Used uint32_t nut_delay_loops_clk;

#ifndef __NUT_EMULATION__
#ifdef USE_TIMER
SIGNAL( SIG_TIMER )
#else
static void NutTimerIntr(void *arg)
#endif
{
    nut_ticks++;
    // nut_tick_dist[TCNT0]++;
#ifdef NUTDEBUG_CHECK_STACKMIN
    if((nut_ticks % 1000) == 0) {
        NUTTHREADINFO *tdp = NutThreadStackCheck(NUTDEBUG_CHECK_STACKMIN);
        if (tdp) {
            NUTFATAL(tdp->td_name, __FILE__, __LINE__, "more stack space");
        }
    }
#endif
}
#endif


void NutTimerInit(void)
{
#ifdef __NUT_EMULATION__
    gettimeofday( &timeStart, NULL );
#else
    NutRegisterTimer(NutTimerIntr);
    NutEnableTimerIrq();
//Not Used     /* Remember the CPU clock for which the loop counter is valid. */
//Not Used     nut_delay_loops_clk = NutGetCpuClock();
#if !defined(NUT_DELAYLOOPS)
#ifndef NUT_TICK_FREQ
#define NUT_TICK_FREQ   1000UL
#endif
    {
        /* Wait for the next tick. */
        uint32_t cnt = NutGetTickCount();
        while (cnt == NutGetTickCount());
        /* Wait for the next tick, counting loops. */
        cnt = NutGetTickCount();
        while (cnt == NutGetTickCount()) {
            nut_delay_loops++;
        }
        /*
         * The loop above needs more cycles than the actual delay loop.
         * Apply the correction found by trial and error. Works acceptable
         * with GCC for Ethernut 1 and 3.
         */
#if defined(__AVR__)
        nut_delay_loops *= 103UL;
        nut_delay_loops /= 26UL;
#else
        nut_delay_loops *= 137UL;
        nut_delay_loops /= 25UL;
#endif
    }
#endif
#endif
}

void NutMicroDelay(uint32_t us)
{
#ifdef __NUT_EMULATION__
    usleep(us);
#else
    register uint32_t cnt = nut_delay_loops * us / 1000;

    while (cnt--) {
        _NOP();
    }
#endif
}

void NutDelay(uint8_t ms)
{
    NutMicroDelay((uint32_t)ms * 1000);
}

void NutTimerInsert(NUTTIMERINFO * tn)
{
    NUTTIMERINFO *tnp;

    NUTASSERT(tn != NULL);

    tn->tn_prev = NULL;
    for (tnp = nutTimerList; tnp; tnp = tnp->tn_next) {
        if (tn->tn_ticks_left < tnp->tn_ticks_left) {
            tnp->tn_ticks_left -= tn->tn_ticks_left;
            break;
        }
        tn->tn_ticks_left -= tnp->tn_ticks_left;
        tn->tn_prev = tnp;
    }
    tn->tn_next = tnp;
    if (tn->tn_next) {
        tn->tn_next->tn_prev = tn;
    }
    if (tn->tn_prev) {
        tn->tn_prev->tn_next = tn;
    }
    else {
        nutTimerList = tn;
    }
}

void NutTimerProcessElapsed(void)
{
    NUTTIMERINFO *tn;
    uint32_t ticks;
    uint32_t ticks_new;

    // calculate ticks since last call
    ticks = NutGetTickCount();
    ticks_new = ticks - nut_ticks_resume;
    nut_ticks_resume = ticks;

    // process timers
    while (nutTimerList && ticks_new){

        tn = nutTimerList;

        // subtract time
        if (ticks_new < tn->tn_ticks_left) {
            tn->tn_ticks_left -= ticks_new;
            ticks_new = 0;
        } else {
            ticks_new -= tn->tn_ticks_left;
            tn->tn_ticks_left = 0;
        }

        // elapsed
        if (tn->tn_ticks_left == 0){

            // callback
            if (tn->tn_callback) {
                (*tn->tn_callback) (tn, (void *) tn->tn_arg);
            }
            // remove from list
            nutTimerList = nutTimerList->tn_next;
            if (nutTimerList) {
                nutTimerList->tn_prev = NULL;
            }
            if ((tn->tn_ticks_left = tn->tn_ticks) == 0) {
                NutHeapFree(tn);
            }
            else {
                // re-insert
                NutTimerInsert(tn);
            }
        }
    }
}

NUTTIMERINFO * NutTimerCreate(uint32_t ticks, void (*callback) (HANDLE, void *), void *arg, uint8_t flags)
{
    NUTTIMERINFO *tn;

    tn = NutHeapAlloc(sizeof(NUTTIMERINFO));
    if (tn) {
        tn->tn_ticks_left = ticks + NutGetTickCount() - nut_ticks_resume;

        /*
         * Periodic timers will reload the tick counter on each timer
         * intervall.
         */
        if (flags & TM_ONESHOT) {
            tn->tn_ticks = 0;
        } else {
            tn->tn_ticks = ticks;
        }

        /* Set callback and callback argument. */
        tn->tn_callback = callback;
        tn->tn_arg = arg;
    }
    return tn;
}

HANDLE NutTimerStartTicks(uint32_t ticks, void (*callback) (HANDLE, void *), void *arg, uint8_t flags)
{
    NUTTIMERINFO *tn;

    tn = NutTimerCreate( ticks, callback, arg, flags);
    if (tn) {
        /* Add the timer to the list. */
        NutTimerInsert(tn);
    }
    return tn;
}

HANDLE NutTimerStart(uint32_t ms, void (*callback) (HANDLE, void *), void *arg, uint8_t flags)
{
        return NutTimerStartTicks(NutTimerMillisToTicks(ms), callback, arg, flags);
}

void NutSleep(uint32_t ms)
{
    if (ms) {

        /* remove running thread from runQueue */
        NutThreadRemoveQueue(runningThread, &runQueue);
        runningThread->td_state = TDS_SLEEP;

        if ((runningThread->td_timer = NutTimerStart(ms, NutThreadWake, runningThread, TM_ONESHOT)) != 0) {
#ifdef NUTTRACER
            TRACE_ADD_ITEM(TRACE_TAG_THREAD_SLEEP,(int)runningThread);
#endif
            NutThreadResume();
        } else
        {
            /* timer creation failed, restore queues */
            runningThread->td_queue = &runQueue;
            runningThread->td_qnxt  = runQueue;
            runningThread->td_state = TDS_RUNNING;
            runQueue = runningThread;
        }
    } else
        NutThreadYield();
}

void NutTimerStop(HANDLE handle)
{
    NUTTIMERINFO *tn = (NUTTIMERINFO *)handle;

    NUTASSERT(tn != NULL);

    /* Disable periodic operation and callback. */
    tn->tn_ticks = 0;
    tn->tn_callback = NULL;
    /* If not already elapsed, expire the timer. */
    if (tn->tn_ticks_left) {
        if (tn->tn_prev) {
            tn->tn_prev->tn_next = tn->tn_next;
        }
        else {
            nutTimerList = tn->tn_next;
        }
        if (tn->tn_next) {
            tn->tn_next->tn_prev = tn->tn_prev;
            tn->tn_next->tn_ticks_left += tn->tn_ticks_left;
        }
        tn->tn_ticks_left = 0;
        NutTimerInsert(tn);
    }
}

uint32_t NutGetTickCount(void)
{
    uint32_t rc;

#ifdef __NUT_EMULATION__
    struct timeval   timeNow;
    gettimeofday( &timeNow, NULL );
    rc = (timeNow.tv_sec - timeStart.tv_sec) * 1000;
    rc += (timeNow.tv_usec - timeStart.tv_usec) / 1000;
#else
    NutEnterCritical();
    rc = nut_ticks;
    NutExitCritical();
#endif

    return rc;
}

uint32_t NutGetSeconds(void)
{
    return NutGetTickCount() / NutGetTickClock();
}

uint32_t NutGetMillis(void)
{
    // carefully stay within 32 bit values
    uint32_t ticks   = NutGetTickCount();
    uint32_t seconds = ticks / NutGetTickClock();
    ticks         -= seconds * NutGetTickClock();
    return seconds * 1000 + (ticks * 1000 ) / NutGetTickClock();
}

#if NUT_HWCLK_MAX
uint32_t NutClockGet(int idx)
{
    if (clock_cache[idx] == 0) {
        clock_cache[idx] = NutArchClockGet(idx) | NUT_CACHE_LVALID;
    }
    return clock_cache[idx] & ~NUT_CACHE_LVALID;
}
#endif

int NutClockSet(int idx, uint32_t freq)
{
    /* Clear all cached values. */
    memset(clock_cache, 0, sizeof(clock_cache));

    return 0;
}

#if !defined(NutGetCpuClock)
uint32_t NutGetCpuClock(void)
{
#ifdef NUT_CPU_FREQ
    /* Keep this code small! Can we use a preprocessor
    ** macro to define NutGetCpuClock() as NUT_CPU_FREQ? */
    return NUT_CPU_FREQ;
#else /* !NUT_CPU_FREQ */
    /* Keep this code fast for the normal case, where the
    ** cached value is valid. */
    if (clock_cache[NUT_HWCLK_CPU]) {
        return clock_cache[NUT_HWCLK_CPU] & ~NUT_CACHE_LVALID;
    }
#if NUT_HWCLK_MAX
    return NutClockGet(NUT_HWCLK_CPU);
#else /* !NUT_HWCLK_MAX */
    clock_cache[NUT_HWCLK_CPU] = NutArchClockGet(NUT_HWCLK_CPU) | NUT_CACHE_LVALID;
    return clock_cache[NUT_HWCLK_CPU] & ~NUT_CACHE_LVALID;
#endif /* !NUT_HWCLK_MAX */
#endif /* !NUT_CPU_FREQ */
}
#endif /* !NutGetCpuClock */