File content as of revision 20:62e0760cae13:

#include <stdint.h>
#include <stdbool.h>

#include "peripherals.h"
#include  "rtc.h"
#include "time.h"
#include "tick.h"
#include "led.h"
#include "log.h"

#define ONE_BILLION 1000000000

static volatile int64_t nsTickCount;
static volatile int64_t nsFreqCount;
static volatile int64_t nsTimeCount;
static bool nsCountIsSet = false;
bool  TickIsSet() { return nsCountIsSet; }

static volatile int32_t slew = 0; //ns     - up to +/- 2.147s of slew
int32_t TickGetSlew() { return slew; }
void    TickSetSlew(int32_t value) { slew = value; }

static volatile int32_t ppb  = 0;
int32_t TickGetPpb () { return ppb;  }
void    TickSetPpb (int32_t value) { ppb  = value; LPC_RTC->GPREG0 = ppb; }
void    TickAddPpb (int32_t value) { ppb += value; LPC_RTC->GPREG0 = ppb; }

bool TickTicked = false;

/*
+---------+---------------+
| Seconds |   Base count  |
+---------+---------------+
|    0    |             0 |
|    1    |    96,000,000 |
|   ...   |       ...     |
|   44    | 4,224,000,000 |
|   44.74 |          2^32 |
|   45    |    25,032,704 |
|   ...   |       ...     |
+---------+---------------+
*/
static uint32_t secondsBaseCount = 0;

void TickSet(int64_t extClock)
{
    uint32_t       tc = LPC_TIM1->TC;
    uint32_t  seconds =       tc / TICK_COUNT_PER_SECOND; //0 to 44
    uint32_t     base =  seconds * TICK_COUNT_PER_SECOND; //0 to 2^32
    uint32_t fraction =       tc % TICK_COUNT_PER_SECOND; //0 to 96,000,000
    uint32_t fractionNs = fraction / 96 * 1000;           //0 to 1,000,000,000 which fits into 32 bits
     int64_t       ns = extClock - fractionNs;
     
    __disable_irq();
             nsTickCount = ns;
             nsFreqCount = 0;
             nsTimeCount = 0;
        secondsBaseCount = base;
    __enable_irq();
    
    nsCountIsSet = true;
}
void TickMain()
{
    uint32_t sincesecondsBaseCount = LPC_TIM1->TC - secondsBaseCount;
    if (sincesecondsBaseCount > TICK_COUNT_PER_SECOND)
    { 
        __disable_irq();
        secondsBaseCount += TICK_COUNT_PER_SECOND;
             nsTickCount += ONE_BILLION;
             nsFreqCount += ppb;
             nsTimeCount += slew;
        __enable_irq();
        slew  = 0;
        TickTicked = true;
    }
    else
    {
        TickTicked = false;
    }
}
static volatile  int64_t nsTickSnapshot;
static volatile  int64_t nsFreqSnapshot;
static volatile  int64_t nsTimeSnapshot;
static volatile uint32_t  timerSnapshot;

void TickSaveSnapshotI()
{
     timerSnapshot = LPC_TIM1->TC - secondsBaseCount;
    nsTickSnapshot = nsTickCount;
    nsFreqSnapshot = nsFreqCount;
    nsTimeSnapshot = nsTimeCount;
}
static void makeTimesFromCounts(uint32_t timerCount, int64_t tickNs, int64_t freqNs, int64_t timeNs, int64_t* pNsInt, int64_t* pNsAbs)
{
    int64_t   fraction = timerCount;
              fraction <<= 32;
              fraction /= TICK_COUNT_PER_SECOND;

    int64_t nsFraction;
    
    int64_t nsBase     = tickNs;
    int64_t nsPerTick  = ONE_BILLION;
     
    nsBase    += freqNs;
    nsPerTick += ppb;
    nsFraction = (nsPerTick * fraction) >> 32;
    *pNsInt = nsBase + nsFraction;

    nsBase    += timeNs;
    nsPerTick += slew;
    nsFraction = (nsPerTick * fraction) >> 32;
    *pNsAbs = nsBase + nsFraction;
}
void TickRetrieveSnapshot(int64_t* pNsInt, int64_t* pNsAbs)
{
    makeTimesFromCounts(timerSnapshot, nsTickSnapshot, nsFreqSnapshot, nsTimeSnapshot, pNsInt, pNsAbs);
}
void TickGetTimes(int64_t* pNsInt, int64_t* pNsAbs)
{
    uint32_t timerCount;
     int64_t tickNs;
     int64_t freqNs;
     int64_t timeNs;
    
    timerCount = LPC_TIM1->TC - secondsBaseCount;
     tickNs    = nsTickCount;
     freqNs    = nsFreqCount;
     timeNs    = nsTimeCount;
    
    makeTimesFromCounts(timerCount, tickNs, freqNs, timeNs, pNsInt, pNsAbs);
}

void TickInit(void)
{
    nsTickCount = 0;
    nsFreqCount = 0;
    nsTimeCount = 0;
    
    ppb  = LPC_RTC->GPREG0; //This is saved each time Tickppb is updated
    slew = 0;
    nsCountIsSet = false;
    
    LPC_TIM1->TCR     =     2; // 21.6.2 Timer Control Register - Reset TC and PC.
    LPC_TIM1->CTCR    =     0; // 21.6.3 Count Control Register - Timer mode
    LPC_TIM1->PR      =     0; // 21.6.5 Prescale register      - Don't prescale 96MHz clock (divide by PR+1).
    LPC_TIM1->MCR     =     0; // 21.6.8 Match Control Register - no interrupt or reset
    LPC_TIM1->TCR     =     1; // 21.6.2 Timer Control Register - Enable TC and PC
}
uint32_t TickElapsed(uint32_t* pLastTime)
{
    uint32_t thisTime = LPC_TIM1->TC;
    uint32_t elapsed = thisTime - *pLastTime;    
    *pLastTime = thisTime;
    return elapsed;
}
uint32_t TickTimerStart()
{
    return LPC_TIM1->TC;
}
uint32_t TickTimerCount(uint32_t startCount)
{
    uint32_t thisCount = LPC_TIM1->TC;
    return thisCount - startCount; 
}
uint32_t TickTimerMs(uint32_t startCount)
{
    uint32_t count = TickTimerCount(startCount);
    return count / 96000;
}