SysTick Software Timer

#ifndef __SYSTEM_H__
#define __SYSTEM_H__

#include <stdint.h>
#include <stddef.h>

#include "bsp.h"

extern void sys_srand( unsigned int seed );
extern int sys_rand( void );

extern uint32_t g_SysTick_Counter;

typedef void (*SYS_TIMER_CALLBACK_T)( void * pContext );

typedef struct SYS_TIMER_T
{
  // set before SysTick_Start()
  uint32_t Period;
  SYS_TIMER_CALLBACK_T callback;
  void * pContext;
  uint32_t Periodical;
  // set after SysTick_Start()
  uint32_t Active;
  uint32_t Time; // Delta value relative to prev timer
  struct SYS_TIMER_T *pNext;
} SYS_TIMER_T;

//------------------------------------------------------------------------------
void SysTick_DelayTicks( uint32_t ticks );

void SysTick_DelayUs( uint32_t usec );

void SysTick_DelayMs( uint32_t msec );

uint32_t SysTick_Get( void );

void SysTick_DelayUnitl( uint32_t time );

void SysTick_Init( void );

//------------------------------------------------------------------------------
void SysTick_Start( SYS_TIMER_T * pTimer );

void SysTick_Stop( SYS_TIMER_T * pTimer );

//------------------------------------------------------------------------------
uint32_t SysInt_Enable( void );

uint32_t SysInt_Disable( void );

void SysInt_Init( void );

#endif /* __SYSTEM_H__ */

#include "system.h"

#define SysTick_CLKSource_HCLK_Div8_Used    ( 0 )
#define SysTick_IRQ_Priority                ( SYSTICK_PRIORITY )

static uint32_t g_Ticks_In_Ms;
static uint32_t g_Ticks_In_1us;
static uint32_t g_Ticks_In_10us;
static uint32_t g_Ticks_In_100us;
static SYS_TIMER_T *g_TimerHead = 0;
uint32_t g_SysTick_Counter = 0;
uint32_t g_SysInt_Counter = 0;

static unsigned int g_Next = 1;

//------------------------------------------------------------------------------
/// Initialize the seed for rand generator.
/// param seed rand initiation seed -- g_SysTick_Counter ?
//------------------------------------------------------------------------------
void sys_srand( unsigned int seed )
{
  g_Next = seed;
}

//------------------------------------------------------------------------------
/// Return a random number, maxinum assumed to be 65535
//------------------------------------------------------------------------------
int sys_rand( void )
{
  g_Next = g_Next * 1103515245 + 12345;
  return (unsigned int) ( g_Next / 131072 ) % 65536;
}

/*
 * Configures the priority grouping: pre-emption priority and subpriority.
 *    4 bits for pre-emption priority
 *    0 bits for subpriority
 */
void SysInt_Init( void )
{
  NVIC_PriorityGroupConfig( NVIC_PRIORITY_GROUP );
}

uint32_t SysInt_Disable( void )
{
  __disable_interrupt( );
  if ( g_SysInt_Counter < UINT32_MAX )
    g_SysInt_Counter++;
  
  return g_SysInt_Counter;
}

uint32_t SysInt_Enable( void )
{
  if ( g_SysInt_Counter > 0 )
    g_SysInt_Counter--;
  
  if ( g_SysInt_Counter == 0 )
    __enable_interrupt( );
  return g_SysInt_Counter;
}

//------------------------------------------------------------------------------
void SysTick_DelayTicks( uint32_t ticks )
{
  uint32_t SysTickVal = SysTick->VAL;  // from VAL downto 0
  while ( ticks >= SysTickVal ) // SysTick->VAL <= SysTick->LOAD
  {
    ticks -= SysTickVal;
    while ( !( SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk ) )
    {
    }
    SysTickVal = SysTick->LOAD;  // from LOAD downto 0
  }
  
  if ( ticks > 0 )  // LOAD >= VAL > ticks > 0
  {
    uint32_t SysTickValMarker = SysTick->LOAD - ticks;
    while ( SysTick->VAL > SysTickValMarker )
    {
    }
  }
}

static void SysTick_DelayTicks_64( uint64_t totalTicks )
{
  while ( totalTicks > 0xFFFFFFFF )
  {
    SysTick_DelayTicks( 0xFFFFFFFF );
    totalTicks -= 0xFFFFFFFF;
  }
  SysTick_DelayTicks( totalTicks );
}

void SysTick_DelayUs( uint32_t usec )
{
  uint64_t totalTicks;
  
  totalTicks = (uint64_t) g_Ticks_In_1us * usec;
  if ( totalTicks == 0 )
  {
    usec /= 10;
    totalTicks = (uint64_t) g_Ticks_In_10us * usec;
    
    if ( totalTicks == 0 )
    {
      usec /= 10;
      totalTicks = (uint64_t) g_Ticks_In_100us * usec;
    }
  }
  SysTick_DelayTicks_64( totalTicks );
}

void SysTick_DelayMs( uint32_t msec )
{
  uint64_t totalTicks;
  
  totalTicks = (uint64_t) g_Ticks_In_Ms * msec;
  SysTick_DelayTicks_64( totalTicks );
}

void SysTick_DelayUnitl( uint32_t time )
{
  while ( time > g_SysTick_Counter )
  {
  }
}

uint32_t SysTick_Get( void )
{
  return g_SysTick_Counter;
}
/*------------------------------------------------------------------------------
 Setup SysTick Timer for 1 msec interrupts.
 -------------------------------------------------------------------------------
 1. The SysTick_Config() function is a CMSIS function which configure:
 - The SysTick Reload register with value passed as function parameter.
 - Configure the SysTick IRQ priority to the lowest value (0x0F).
 - Reset the SysTick Counter register.
 - Configure the SysTick Counter clock source to be Core Clock Source (HCLK).
 - Enable the SysTick Interrupt.
 - Start the SysTick Counter.

 2. You can change the SysTick Clock source to be HCLK_Div8 by calling the
 SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8) just after the
 SysTick_Config() function call.
 The SysTick_CLKSourceConfig() is defined inside the misc.c file.

 3. You can change the SysTick IRQ priority by calling the
 NVIC_SetPriority(SysTick_IRQn, n)
 just after the SysTick_Config() function call.
 The NVIC_SetPriority() is defined inside the core_cm3.h file.

 4. To adjust the SysTick time base, use the following formula:

 Reload Value = SysTick Counter Clock (Hz) x  Desired Time base (s)

 - Reload Value is the parameter to be passed for SysTick_Config() function
 - Reload Value should not exceed 0xFFFFFF

 5. SysTick_CLKSource: specifies the SysTick clock source.

 SysTick_CLKSource_HCLK
 AHB clock selected as SysTick clock source.

 SysTick_CLKSource_HCLK_Div8
 AHB clock divided by 8 selected as SysTick clock source.

 */
void SysTick_Init( void )
{
#if ( RTOS_USED > 0 )
  return;
#else
  SysTick_Config( SystemCoreClock / 1000 );
  NVIC_SetPriority( SysTick_IRQn, SYSTICK_PRIORITY );
  
#if (SysTick_CLKSource_HCLK_Div8_Used > 0 )
  uint32_t SysTick_Clock = SystemCoreClock / 8;
  SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
#else
  uint32_t SysTick_Clock = SystemCoreClock;
#endif
  
  g_TimerHead = 0;
  g_SysTick_Counter = 0;
  g_Ticks_In_1us = ( SysTick_Clock + 500000 ) / 1000000;   // 168/21, 72/9
  g_Ticks_In_10us = ( SysTick_Clock + 50000 ) / 100000;
  g_Ticks_In_100us = ( SysTick_Clock + 5000 ) / 10000;
  g_Ticks_In_Ms = ( SysTick_Clock + 500 ) / 1000;   // 168000/21000, 72000/9000
#endif
}

#if (RTOS_USED > 0 )
__weak
#endif
//------------------------------------------------------------------------------
// The hook function is called directly from the interrupt handler
// The callback therefore should execute as fast as possible.
// The callback called must not re-enable interrupts.
//
void SysTick_Handler( void )
{
  SysInt_Disable( );
  
  g_SysTick_Counter++;
  
  SYS_TIMER_T * pTimerHead = g_TimerHead;
  SYS_TIMER_T * pTimerNext = pTimerHead->pNext;
  if ( pTimerHead )  // at least one timer is Active ...
  {
    pTimerHead->Time--;
    
    // There might be more than one timeout pr. tick ( with same Period )
    while ( pTimerHead )
    {
      if ( pTimerHead->Time > 0 )
        break;
      
      // The callback may place new/same items in the queue !!!
      if ( pTimerHead->callback ) // execute as fast as possible
      {
        ( pTimerHead->callback )( pTimerHead->pContext );
        
        if ( pTimerHead->Periodical > 0 )
          SysTick_Start( pTimerHead );
        else
          SysTick_Stop( pTimerHead );
      }
      
      pTimerHead = pTimerNext;
      pTimerNext = pTimerHead->pNext;
    }
  }
  
  SysInt_Enable( );
}

//------------------------------------------------------------------------------
// place timer in the queue
// If the timer is already Active, it will be restarted with new configuration
//
void SysTick_Start( SYS_TIMER_T * pTimer )
{
  uint32_t accumulated;
  SYS_TIMER_T *this, **last;
  if ( ( pTimer->callback == 0 ) || ( pTimer->Period == 0 ) )
    return;
  
  SysInt_Disable( );
  
  if ( pTimer->Active )
    SysTick_Stop( pTimer );
  
  pTimer->Active = 1;
  pTimer->pNext = 0;
  
  if ( g_TimerHead == 0 ) /* Queue empty ?  */
  {
    pTimer->Time = pTimer->Period;
    g_TimerHead = pTimer;
  }
  else /* Do a sorted insert */
  {
    this = g_TimerHead;
    last = &g_TimerHead;
    accumulated = 0;
    
    while ( this )
    {
      /* Insert before "this" ? */
      if ( pTimer->Period < accumulated + this->Time )
      {
        pTimer->pNext = this;
        pTimer->Time = pTimer->Period - accumulated;
        this->Time -= pTimer->Time; /* Adjust timeout */
        *last = pTimer;
        break;
      }
      else if ( this->pNext == 0 ) /* At end of queue ?  */
      {
        pTimer->Time = //
          pTimer->Period - accumulated - this->Time;
        this->pNext = pTimer;
        break;
      }
      accumulated += this->Time;
      last = &this->pNext;
      this = this->pNext;
    }
  }
  
  SysInt_Enable( );
}

void SysTick_Stop( SYS_TIMER_T * pTimer )
{
  if ( pTimer == 0 )
    return;
  
  if ( g_TimerHead == 0 ) /* Queue empty ?    */
    return;
  
  SYS_TIMER_T *this, **last;
  
  SysInt_Disable( );
  
  this = g_TimerHead;
  last = &g_TimerHead;
  pTimer->Active = 0;
  
  while ( this )
  {
    if ( this == pTimer ) /* Correct timer ?  */
    {
      pTimer->Period = 0;
      pTimer->Active = 0;
      if ( this->pNext ) /* Adjust timeout   */
        this->pNext->Time += pTimer->Time;
      *last = this->pNext;
      break;
    }
    last = &this->pNext;
    this = this->pNext;
  }
  
  SysInt_Enable( );
}