src/lib/HWTIMER/ESP8266_hwTimer.cpp

   1 #if defined(PLATFORM_ESP8266)
   2 #include "hwTimer.h"
   3
   4 void (*hwTimer::callbackTick)() = nullptr;
   5 void (*hwTimer::callbackTock)() = nullptr;
   6
   7 volatile bool hwTimer::running = false;
   8 volatile bool hwTimer::isTick = false;
   9
  10 volatile uint32_t hwTimer::HWtimerInterval = TimerIntervalUSDefault;
  11 volatile int32_t hwTimer::PhaseShift = 0;
  12 volatile int32_t hwTimer::FreqOffset = 0;
  13
  14 // Internal implementation specific variables
  15 static uint32_t NextTimeout;
  16
  17 #define HWTIMER_TICKS_PER_US 5
  18 #define HWTIMER_PRESCALER (clockCyclesPerMicrosecond() / HWTIMER_TICKS_PER_US)
  19
  20 void hwTimer::init(void (*callbackTick)(), void (*callbackTock)())
  21 {
  22     hwTimer::callbackTick = callbackTick;
  23     hwTimer::callbackTock = callbackTock;
  24     timer0_isr_init();
  25     running = false;
  26 }
  27
  28 void hwTimer::stop()
  29 {
  30     if (running)
  31     {
  32         timer0_detachInterrupt();
  33         running = false;
  34     }
  35 }
  36
  37 void ICACHE_RAM_ATTR hwTimer::resume()
  38 {
  39     if (!running)
  40     {
  41         noInterrupts();
  42         timer0_attachInterrupt(hwTimer::callback);
  43         // We want the timer to fire tock() ASAP after enabling
  44         // tock() should always be the first event to maintain consistency
  45         isTick = false;
  46 #if defined(TARGET_TX)
  47         NextTimeout = ESP.getCycleCount() + HWtimerInterval;
  48 #else
  49         // Fire the timer in 20us to get it started close to the correct starting time and phase.
  50         // The 20us delay is requied to allow the transceiver IRQ enough time to return and finish IsrCallback().
  51         // If it does not there is a chance that the IRQ will not be cleared and the radio will hang.
  52         NextTimeout = ESP.getCycleCount() + (20 * HWTIMER_TICKS_PER_US * HWTIMER_PRESCALER);
  53 #endif
  54         timer0_write(NextTimeout);
  55         interrupts();
  56
  57         running = true;
  58     }
  59 }
  60
  61 void hwTimer::updateInterval(uint32_t newTimerInterval)
  62 {
  63     // timer should not be running when updateInterval() is called
  64     HWtimerInterval = newTimerInterval * (HWTIMER_TICKS_PER_US * HWTIMER_PRESCALER);
  65 }
  66
  67 void ICACHE_RAM_ATTR hwTimer::phaseShift(int32_t newPhaseShift)
  68 {
  69     int32_t minVal = -(HWtimerInterval >> 2);
  70     int32_t maxVal = (HWtimerInterval >> 2);
  71
  72     // phase shift is in microseconds
  73     PhaseShift = constrain(newPhaseShift, minVal, maxVal) * (HWTIMER_TICKS_PER_US * HWTIMER_PRESCALER);
  74 }
  75
  76 void ICACHE_RAM_ATTR hwTimer::callback()
  77 {
  78     if (running)
  79     {
  80 #if defined(TARGET_TX)
  81         NextTimeout += HWtimerInterval;
  82         timer0_write(NextTimeout);
  83         callbackTock();
  84 #else
  85         NextTimeout += (HWtimerInterval >> 1) + (FreqOffset * HWTIMER_PRESCALER);
  86         if (hwTimer::isTick)
  87         {
  88             timer0_write(NextTimeout);
  89             callbackTick();
  90         }
  91         else
  92         {
  93             NextTimeout += PhaseShift;
  94             timer0_write(NextTimeout);
  95             PhaseShift = 0;
  96             callbackTock();
  97         }
  98         hwTimer::isTick = !hwTimer::isTick;
  99 #endif
 100     }
 101 }
 102
 103 #endif