scheduler.h

Go to the documentation of this file.

 
#ifndef SCHEDULER_H
#define SCHEDULER_H
 
#include "board_definition.h"
#include "crankMaths.h"
#include "preprocessor.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;
 
void adjustCrankAngle(const statuses &current, IgnitionSchedule &schedule, int16_t crankAngle);
 
struct FuelSchedule : public Schedule {
 
  using Schedule::Schedule;
 
  uint16_t channelDegrees = 0U;    
  uint16_t pw = 0U;                
 
  void reset(void) override;
};
 
void moveToNextState(FuelSchedule &schedule) noexcept;
 
static FORCE_INLINE uint32_t _calculateAngularTime(const Schedule &schedule, uint16_t eventAngle, uint16_t crankAngle, uint16_t maxAngle) {
  int16_t delta = eventAngle - crankAngle;
  if ( (isRunning(schedule)) || (schedule._status == OFF)) {
    while(delta < 0) { delta += (int16_t)maxAngle; }
  } 
 
  return delta > 0 ? angleToTime((uint16_t)delta) : 0U;
}
 
static FORCE_INLINE uint16_t _adjustToTDC(int16_t angle, uint16_t angleOffset, uint16_t maxAngle) {
  angle = angle - (int16_t)angleOffset;
  if( angle < 0) { return angle + (int16_t)maxAngle; }
  return angle;
}
 
static FORCE_INLINE uint32_t _calculateAngularTime(const Schedule &schedule, uint16_t angleOffset, uint16_t eventAngle, uint16_t crankAngle, uint16_t maxAngle) {
  if (angleOffset==0U) { // Optimize for zero channel angle - no need to adjust start & crank angles
    return _calculateAngularTime(schedule, eventAngle, crankAngle, maxAngle);
  }
  // Realign the current crank angle and the desired start angle around 0 degrees for the given cylinder/output
  // Eg: If cylinder 2 TDC is 180 degrees after cylinder 1 (E.g. a standard 4 cylinder engine), then
  // adjusted crank angle is 180* less than the current crank angle and adjusted start angle is the desired open angle less 180*. 
  // Thus the cylinder is being treated relative to its own TDC, regardless of its offset
  //
  // This is done to avoid very small or very large deltas between crank angle and start angle.
  return _calculateAngularTime(schedule, 
            _adjustToTDC(eventAngle, angleOffset, maxAngle),
            _adjustToTDC(crankAngle, angleOffset, maxAngle),
            maxAngle);
}
 
 
#endif // SCHEDULER_H