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 = ;
uint32_t g_SysTick_Counter = ;
uint32_t g_SysInt_Counter = ;

static unsigned int g_Next = ;

//------------------------------------------------------------------------------
/// 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 *  + ;
  return (unsigned int) ( g_Next /  ) % ;
}

/*
 * 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 >  )
    g_SysInt_Counter--;

  if ( g_SysInt_Counter ==  )
    __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 >  )  // 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 ==  )
  {
    usec /= ;
    totalTicks = (uint64_t) g_Ticks_In_10us * usec;

    if ( totalTicks ==  )
    {
      usec /= ;
      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 /  );
  NVIC_SetPriority( SysTick_IRQn, SYSTICK_PRIORITY );

#if (SysTick_CLKSource_HCLK_Div8_Used > 0 )
  uint32_t SysTick_Clock = SystemCoreClock / ;
  SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
#else
  uint32_t SysTick_Clock = SystemCoreClock;
#endif

  g_TimerHead = ;
  g_SysTick_Counter = ;
  g_Ticks_In_1us = ( SysTick_Clock +  ) / ;   // 168/21, 72/9
  g_Ticks_In_10us = ( SysTick_Clock +  ) / ;
  g_Ticks_In_100us = ( SysTick_Clock +  ) / ;
  g_Ticks_In_Ms = ( SysTick_Clock +  ) / ;   // 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 >  )
        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 >  )
          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 ==  ) || ( pTimer->Period ==  ) )
    return;

  SysInt_Disable( );

  if ( pTimer->Active )
    SysTick_Stop( pTimer );

  pTimer->Active = ;
  pTimer->pNext = ;

  if ( g_TimerHead ==  ) /* Queue empty ?  */
  {
    pTimer->Time = pTimer->Period;
    g_TimerHead = pTimer;
  }
  else /* Do a sorted insert */
  {
    this = g_TimerHead;
    last = &g_TimerHead;
    accumulated = ;

    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 ==  ) /* 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 ==  )
    return;

  if ( g_TimerHead ==  ) /* Queue empty ?    */
    return;

  SYS_TIMER_T *this, **last;

  SysInt_Disable( );

  this = g_TimerHead;
  last = &g_TimerHead;
  pTimer->Active = ;

  while ( this )
  {
    if ( this == pTimer ) /* Correct timer ?  */
    {
      pTimer->Period = ;
      pTimer->Active = ;
      if ( this->pNext ) /* Adjust timeout   */
        this->pNext->Time += pTimer->Time;
      *last = this->pNext;
      break;
    }
    last = &this->pNext;
    this = this->pNext;
  }

  SysInt_Enable( );
}