scheduler.h

Go to the documentation of this file.

 
#ifndef SCHEDULER_H
#define SCHEDULER_H
 
#include "globals.h"
#include "crankMaths.h"
 
 
enum ScheduleStatus {
  // We use powers of 2 so we can check multiple states with a single bitwise AND
 
  OFF              = 0b00000000U, 
  PENDING          = 0b00000001U,
  RUNNING          = 0b00000010U,
  RUNNING_WITHNEXT = 0b00000100U,
}; 
 
void nullCallback(void);
 
struct Schedule {
  // Deduce the real types of the counter and compare registers.
  // COMPARE_TYPE is NOT the same - it's just an integer type wide enough to
  // store 16-bit counter/compare calculation results.
  using counter_t = decltype(FUEL1_COUNTER /* <-- Arbitrary choice of macro, assumes all have the same type */);
  using compare_t = decltype(FUEL1_COMPARE /* <-- Arbitrary choice of macro, assumes all have the same type */);
 
  constexpr Schedule(counter_t &counter, compare_t &compare)
    : _counter(counter)
    , _compare(compare) 
  {
  }
 
  using callback = void(*)(void);
 
  volatile COMPARE_TYPE _duration = 0U;
  volatile ScheduleStatus _status = OFF;  
  callback _pStartCallback = &nullCallback; 
  callback _pEndCallback = &nullCallback;   
  COMPARE_TYPE _nextStartCompare = 0U;   
  
  counter_t &_counter;       
  compare_t &_compare;       
 
protected:
  virtual void reset(void);
};
 
static inline bool isRunning(const Schedule &schedule) noexcept {
  // Using flags and bitwise AND (&) to check multiple states is much quicker
  // than a logical or (||) (one less branch & 30% less instructions)
  static constexpr uint8_t flags = RUNNING | RUNNING_WITHNEXT;
  return ((uint8_t)schedule._status & flags)!=0U;
}
 
void setCallbacks(Schedule &schedule, Schedule::callback pStartCallback, Schedule::callback pEndCallback) noexcept;
 
void setSchedule(Schedule &schedule, uint32_t delay, uint16_t duration, bool allowQueuedSchedule);
 
struct IgnitionSchedule : public Schedule {
 
  using Schedule::Schedule;
 
  volatile uint32_t _startTime = 0U;
  int16_t chargeAngle = 0U;         
  int16_t dischargeAngle = 0U;      
  uint16_t channelDegrees = 0U;     
 
  void reset(void) override;
};
 
void moveToNextState(IgnitionSchedule &schedule) noexcept;
 
struct FuelSchedule : public Schedule {
 
  using Schedule::Schedule;
 
  uint16_t channelDegrees = 0U;    
  uint16_t pw = 0U;                
 
  void reset(void) override;
};
 
void moveToNextState(FuelSchedule &schedule) noexcept;
 
#include "schedule_calcs.hpp"
 
#endif // SCHEDULER_H