scheduler.h

Go to the documentation of this file.

 
#ifndef SCHEDULER_H
#define SCHEDULER_H
 
#include "globals.h"
#include "crankMaths.h"
 
void initialiseFuelSchedulers(void);
 
void startFuelSchedulers(void);
 
void stopFuelSchedulers(void);
 
void beginInjectorPriming(void);
 
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) {
  // 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;
  int16_t chargeAngle;        
  int16_t dischargeAngle;     
  int16_t channelDegrees;     
 
  void reset(void) override;
};
 
void moveToNextState(IgnitionSchedule &schedule) noexcept;
 
struct FuelSchedule : public Schedule {
 
  using Schedule::Schedule;
 
  void reset(void) override;
};
 
static inline void setFuelSchedule(FuelSchedule &schedule, uint32_t delay, uint16_t duration) 
{
  // Only queue up the next schedule if the maximum time between squirts (Based on CRANK_ANGLE_MAX_INJ) is less than the max timer period
  setSchedule(schedule, delay, duration, angleToTimeMicroSecPerDegree((uint16_t)CRANK_ANGLE_MAX_INJ) < MAX_TIMER_PERIOD);
}
 
void moveToNextState(FuelSchedule &schedule) noexcept;
 
extern FuelSchedule fuelSchedule1;
extern FuelSchedule fuelSchedule2;
extern FuelSchedule fuelSchedule3;
extern FuelSchedule fuelSchedule4;
#if INJ_CHANNELS >= 5
extern FuelSchedule fuelSchedule5;
#endif
#if INJ_CHANNELS >= 6
extern FuelSchedule fuelSchedule6;
#endif
#if INJ_CHANNELS >= 7
extern FuelSchedule fuelSchedule7;
#endif
#if INJ_CHANNELS >= 8
extern FuelSchedule fuelSchedule8;
#endif
 
void changeHalfToFullSync(const config2 &page2, statuses &current);
void changeFullToHalfSync(const config2 &page2, const config4 &page4, statuses &current);
 
#endif // SCHEDULER_H