timer.c File Reference

timer support function More...

#include "..\includes.h"

Functions
	if (RecentEpoch.tv_usec >=1000000)
	while (pActiveRecord)
	AckTimerInterrupt ()
time_t	GetSystemTimerRes (void)
FUNC_RETURN	ResetTimeOutTimer (T_TimeOutTimer *tot, char symbol, time_t period, char *text)
FUNC_RETURN	ProcessTimeout (T_TimeOutTimer *tot, time_t timeout)
int	tv_elapsed (timeval *t, time_t s, time_t u, uint16_t retrigger)
	check if given time has elapsed More...
void	tv_interval (timeval *e, timeval *t1, timeval *t2)
	compute elapsed time More...
void	SetupSystemTime (int32_t cpuint, int port, time_t resolution)
	Setup System Time. More...
void	StartSystemTimer (void)
	start system timer More...
void	StopSystemTimer (void)
	stop system timer More...
void	RegisterTimerEvent (T_TimerEventHandler EventHandlerFunc, time_t sec, time_t usec)
	register a new timer event More...

Variables
timeval	RecentEpoch = {(time_t)0,(time_t)0}
static time_t	usec_inc = (time_t)1
static int	SystemTimerRunning = 0
static T_SchedulerRecord *	gpSchedulerHead = NULL
uint16_t	gTaskId = 1
const char *	TimerMessages []
	TIMER_HANDLER_INTERRUPT
	timer interrupt function More...
RecentEpoch	tv_usec = usec_inc

Detailed Description

                          _         _             _
                       __| |    ___(_) ____ _ __ | |_
                      / _` |   / __| |/ _` | '_ \| __|
                     | (_| | _ \__ \ | (_| | | | | |_
                      \__,_|(_) ___/_|\__, |_| |_|\__|
                     Signalprocessing |___/ Technology

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Version

2.91

Date

2019-04-17

Function Documentation

if

(

RecentEpoch.tv_usec >=

1000000

)

Examples:

Echo.c, and NetTest.c.

    {
        RecentEpoch.tv_usec = (time_t)0;
        RecentEpoch.tv_sec++;
    }

while

(

pActiveRecord

)

    {
        if (tv_elapsed (&(pActiveRecord->timer), pActiveRecord->sec, pActiveRecord->usec, pActiveRecord->control&TR_CONTROL_ACTIVE) )
        {
            pActiveRecord->EventHandler((uint32_t*)pActiveRecord);
            // if(pActiveRecord->control&TR_CONTROL_SINGLE)
            // {
            // }
        }

        /***********************************************************************
         switch to next task
        ***********************************************************************/
        pActiveRecord = pActiveRecord->pNext;
}

AckTimerInterrupt

(

)

time_t GetSystemTimerRes

(

void

)

{
    return (usec_inc);
}

FUNC_RETURN ResetTimeOutTimer	(	T_TimeOutTimer *	tot,
		char	symbol,
		time_t	period,
		char *	text
	)

{
    /***************************************************************************
     assign initialization parameters
    ***************************************************************************/
    tot-> Symbol = symbol;
    tot-> Period = period;
    tot-> Text   = text;
    if ((text!=NULL) && *text)
        tot-> Length = strlen(text)-1;
    else
        tot-> Length = 0;

    /***************************************************************************
     limit text length
    ***************************************************************************/
    if (tot-> Length < CPRINTF_PROGRESS_COL)
    {
        tot-> Length = CPRINTF_PROGRESS_COL - tot-> Length;
    }
    else
    {
        tot-> Length = CPRINTF_PROGRESS_COL;
    }

    /***************************************************************************
     reset time stamp
    ***************************************************************************/
    tot-> Timer  = GetTimeStamp();
    return(FR_OK);
}

FUNC_RETURN ProcessTimeout	(	T_TimeOutTimer *	tot,
		time_t	timeout
	)

Examples:

SMTP.c.

{
    FUNC_RETURN f_result = FR_OK;     // test result
#if (defined(INC_UART) || defined(INC_CDC))
    char c;
#endif

#ifdef INC_UART
    if (output_device & CPRINTF_UART_OUTPUT)
    {
        if ( BoardUartReadChar ( &c) ) // read from UART to skip if necessary
        {
            return (f_result = FR_SKIPPED);
        }
    }
#endif
#ifdef INC_CDC
    if (output_device & CPRINTF_CDC_OUTPUT)
    {
        if ( CDC_read ( &c) ) // read from CDC to skip if necessary
        {
            return (f_result = FR_SKIPPED);
        }
    }
#endif
    /***************************************************************************
     reset timeout
    ***************************************************************************/
    if ( timeout == 0 )
    {
        tot-> Timer  = GetTimeStamp(); // reset timeout
    }

    /***************************************************************************
     process a timeout
    ***************************************************************************/
    if ( timeout && tv_elapsed (&(tot-> Timer), timeout, 0, TRUE) )
    {
        f_result = FR_TIMEDOUT;
    }
    else
    {
        /***********************************************************************
         perform progress bar animation
        ***********************************************************************/
        CPrintProgressBarText (tot-> Symbol, tot-> Period, tot-> Length, tot-> Text );
    }

    return (f_result);
}

int tv_elapsed	(	timeval *	t,
		time_t	s,
		time_t	u,
		uint16_t	retrigger
	)

Use this function to determine if a certain period of time has elapsed since a given time stamp. The desired time period can be specified in micro second or seconds or a combination of both.

Parameters

t	- timestamp
s	- seconds
u	- micro seconds
retrigger	- if true (1) timeval *t is updated to current time stamp

Returns

TRUE - time elapsed

FALSE - time not elapsed

{
    /***************************************************************************
      locals
    ***************************************************************************/
    timeval e;
    time_t sec = s + (u/1000000);
    time_t usec = u - ((u/1000000)*1000000);

    if ( SystemTimerRunning == 0 )
    {
        prg_exit (TIMER_NOT_RUNNING);
    } // if

    /***************************************************************************
     tv_interval() requires RecentEpoch > t. If the RecentEpoch was modified
     (e.g. by NTP service or manual setting), prevent tv_interval() being called
     and return TRUE to force update
    ***************************************************************************/
    if ( RecentEpoch.tv_sec < t->tv_sec )
    {
        if (retrigger) *t = RecentEpoch;
        return (TRUE);
    } // if

    tv_interval (&e, t, &RecentEpoch);

    if ( ( e.tv_sec >= sec ) && (e.tv_usec >= usec) )
    {
        if (retrigger) *t = RecentEpoch;
        return (TRUE);
    } // if

    return (FALSE);
}

void tv_interval	(	timeval *	e,
		timeval *	t1,
		timeval *	t2
	)

tv_interval() computes the elapsed time between two time values. All time values have micro seconds resolution. A carry-over is taken into account.

Parameters

e	- elapsed time [OUT]
t1	- start time [IN]
t2	- end time [IN]

Returns

-

Note

precondition t2 > t1

{
    /***************************************************************************
      locals
    ***************************************************************************/
    time_t t;
    time_t carry = (time_t)0;

    /***************************************************************************
      compute seconds
    ***************************************************************************/
    t= t2->tv_sec - t1->tv_sec;

    /***************************************************************************
      check for carry
    ***************************************************************************/
    if ( t2->tv_usec < t1->tv_usec )
    {
        /***********************************************************************
          correct seconds, carry micro seconds
        ***********************************************************************/
        t--;
        carry = 1000000;
    }

    /***************************************************************************
      write back seconds
    ***************************************************************************/
    e->tv_sec = t;

    /***************************************************************************
      build time difference in micro seconds
    ***************************************************************************/
    t = carry + t2->tv_usec-t1->tv_usec;

    /***************************************************************************
      write back micro seconds
    ***************************************************************************/
    e->tv_usec = t;

}

void SetupSystemTime	(	int32_t	cpuint,
		int	port,
		time_t	resolution
	)

The system time in this application starts at compile date (see BUILD_XXX macros). For higher precision time use NTP protocol or a Real Time Clock.

Parameters

cpuint	- cpu interrupt to use
port	- timer to use
resolution	- timer resolution

Returns

-

{
    /***************************************************************************
      locals
    ***************************************************************************/
    struct tm *local_time;          /* structure to hold time and date        */

    /***************************************************************************
      range checking
    ***************************************************************************/
    if ( resolution > RES_SECONDS )
    {
        prg_exit (TIMER_RANGE_ERROR_STRING);
    } // if

    /***************************************************************************
      save desired resolution
    ***************************************************************************/
    usec_inc = resolution;

    /***************************************************************************
     initialize local time (use BUILD_ macros from Common.h)
    ***************************************************************************/
    local_time = localtime (NULL);
    local_time->tm_year = BUILD_YEAR-1900;
    local_time->tm_mon = BUILD_MONTH-1;
    local_time->tm_mday = BUILD_DAY;
    local_time->tm_hour = BUILD_HOUR;
    local_time->tm_min = BUILD_MINUTE;
    local_time->tm_sec = BUILD_SECOND;
    RecentEpoch.tv_sec = mktime (local_time);
    local_time = localtime ((const time_t *)&RecentEpoch);

    /***************************************************************************
      initialize Timer to desired clock period
    ***************************************************************************/
    if (BoardInitializeTimer (TimerClock, port, usec_inc))
    {
        prg_exit (TIMER_RANGE_ERROR_STRING);
    }

    /***************************************************************************
     plug in interrupt handler
    ***************************************************************************/
    BoardPlugTimerHandler (cpuint, port, TIMER_HANDLER_FUNCTION);
}

void StartSystemTimer

(

void

)

Parameters

-

Returns

-

{
    BoardStartTimer (SYSTEM_TIMER);
    SystemTimerRunning = 1;
}

void StopSystemTimer

(

void

)

Parameters

-

Returns

-

{
    BoardStopTimer (SYSTEM_TIMER);
    SystemTimerRunning = 0;
}

void RegisterTimerEvent	(	T_TimerEventHandler	EventHandlerFunc,
		time_t	sec,
		time_t	usec
	)

Parameters

EventHandlerFunc	- event handler callback function
sec	- seconds the timer is fired
usec	- micro seconds the timer is fired

{
    /***************************************************************************
     locals
    ***************************************************************************/
    T_SchedulerRecord *pNewRecord, *pActiveRecord;

    /***************************************************************************
     Create a new task record
    ***************************************************************************/
    pNewRecord = (T_SchedulerRecord *)calloc(1,sizeof(T_SchedulerRecord));
    if(pNewRecord != NULL)
    {
        pNewRecord->id = ++gTaskId;        /* assign unique ID                */
        pNewRecord->sec = sec;             /* seconds to fire the timer       */
        pNewRecord->usec = usec;           /* micro seconds to fire the timer */
        pNewRecord->control = TR_CONTROL_ACTIVE; /* switch event to active    */

        /***********************************************************************
         Assign the event handler function to the task
        ***********************************************************************/
        pNewRecord->EventHandler = EventHandlerFunc;

        if(gpSchedulerHead == NULL)
        {
            /*******************************************************************
             first record in the event list
            *******************************************************************/
            gpSchedulerHead = pNewRecord;
        }
        else
        {
            /*******************************************************************
             Move to the last event in the list
            *******************************************************************/
            pActiveRecord = gpSchedulerHead;
            while(pActiveRecord->pNext != NULL)
            {
                pActiveRecord = pActiveRecord->pNext;
            }

            /*******************************************************************
             Append the new event to the end of the list
            *******************************************************************/
            pActiveRecord->pNext = pNewRecord;
        }
    }
}

Variable Documentation

timeval RecentEpoch = {(time_t)0,(time_t)0}

time_t usec_inc = (time_t)1

static

int SystemTimerRunning = 0

static

T_SchedulerRecord* gpSchedulerHead = NULL

static

uint16_t gTaskId = 1

const char* TimerMessages[]

Initial value:

= {
    " Timer out of range error",
    " System timer not running!",
}

TIMER_HANDLER_INTERRUPT

Initial value:

{
    
    T_SchedulerRecord *pActiveRecord = gpSchedulerHead

Parameters

-

Returns

nothing

Note

uses global variable RecentEpoch

RecentEpoch tv_usec = usec_inc