timer.h

#ifndef _timer_h_
#define _timer_h_

#include "chip.h"
#include "types.h"
#include "exti.h"
#include "gpio.h"

#ifdef __cplusplus
extern "C"{
#endif // __cplusplus

extern uint8_t TIMER_IC_PRIORITY;

// FUTURE IDEAS?
// 
// pinModeTimer should take another argument: ENCODER_AB, PWM_IN or PWM_OUT
// if pwmIn is called and it is in output mode it should be re-inited TIM_ICInit etc. <- function timerInitPulseInPin
// if analogWrite is called and it is in input mode it should be re-inited TIM_OC1Init etc. <- timerInitPWMPin


void analogWriteResolution(uint8_t nbits);

void analogWriteFrequency(uint8_t pin, int freqHz);

void analogWriteFloat(uint8_t pin, float duty);

void analogWrite(uint8_t pin, uint32_t duty);

float pwmIn(uint8_t pin);

// To try and reduce position reading bugs, fix pwmIn period
// 36000 -> 1ms (1KHz PWM)
// Set = 0 to autodetect period
// extern int PWM_IN_FIXED_PERIOD;
void pwmInExpectedPeriod(int expectedUs);

// Helper functions
void pwmInRaw(uint8_t name, int *period, int *pulseWidth);

 // end of addtogroup

void timerInit(uint8_t timer, int freqHz);

void pinTimerInit(uint8_t pin);

// Timer init with period: mostly a helper function
void timerInitHelper(uint8_t timer, uint16_t prescaler, uint32_t period);



// Helper for each channel
static inline void timerCCxISR(TIM_TypeDef *TIMx, TimerChannelData *C, int current, uint32_t currRollover) __attribute__((always_inline, unused));
static inline void timerCCxISR(TIM_TypeDef *TIMx, TimerChannelData *C, int current, uint32_t currRollover) {
  // Is this a pwmIn pin?
  if (C->bPwmIn == 1) {
    // Keep track of how many times timer rolled over since last time
    int newRollovers = currRollover - C->lastRollover;
    int delta = current + TIMx->ARR * newRollovers - C->risingEdge;

    if (digitalRead(C->pin)) {
      // This was a rising edge
      if (delta > PWM_IN_MAXPERIOD)
        C->period = delta - TIMx->ARR;
      else if (delta < PWM_IN_MINPERIOD)
        C->period = delta + TIMx->ARR;
      else 
        C->period = delta;

      C->risingEdge = current;
      C->lastRollover = currRollover;
    } else {
      // This was a falling edge
      C->pulseWidth = delta;
      
      // HACK: sometimes it is greater than the period
      if (C->pulseWidth > C->period)
        C->pulseWidth -= C->period;
      if (C->pulseWidth < 0)
        C->pulseWidth += C->period;
    }
  }
}

// Main GP timer ISR
#if defined(KODUINO_ISRS_INLINE)
static inline void timerISR(uint8_t timer) __attribute__((always_inline, unused));
#else
static inline void timerISR(uint8_t timer);
#endif
static inline void timerISR(uint8_t timer) {
  TIM_TypeDef *TIMx = TIMER_MAP[timer].TIMx;
  TimerInfo *cfg = &TIMER_MAP[timer];

  // Update for rollover
  if (TIM_GetITStatus(TIMx, TIM_IT_Update) != RESET) {
    TIM_ClearITPendingBit(TIMx, TIM_IT_Update);
    cfg->numRollovers++;
  }

  // CCx for pwmIn
  if (TIM_GetITStatus(TIMx, TIM_IT_CC1) != RESET) {
    TIM_ClearITPendingBit(TIMx, TIM_IT_CC1);
    timerCCxISR(TIMx, &cfg->channelData[0], TIM_GetCapture1(TIMx), cfg->numRollovers);
  }
  if (TIM_GetITStatus(TIMx, TIM_IT_CC2) != RESET) {
    TIM_ClearITPendingBit(TIMx, TIM_IT_CC2);
    timerCCxISR(TIMx, &cfg->channelData[1], TIM_GetCapture2(TIMx), cfg->numRollovers);
  }
  if (TIM_GetITStatus(TIMx, TIM_IT_CC3) != RESET) {
    TIM_ClearITPendingBit(TIMx, TIM_IT_CC3);
    timerCCxISR(TIMx, &cfg->channelData[2], TIM_GetCapture3(TIMx), cfg->numRollovers);
  }
  if (TIM_GetITStatus(TIMx, TIM_IT_CC4) != RESET) {
    TIM_ClearITPendingBit(TIMx, TIM_IT_CC4);
    timerCCxISR(TIMx, &cfg->channelData[3], TIM_GetCapture4(TIMx), cfg->numRollovers);
  }
}


// Special timer features
void complementaryPWM(uint8_t timer, int freqHz, uint16_t deadtime);


#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus

#endif