crank_angle_calculator.h

Go to the documentation of this file.

 
#pragma once
#include "src/utils/nominmax.h"
#include <tuple>
#include "config_pages.h"
#include "atomic.h"
#include "decoder_state.h"
 
namespace decoders {
 
namespace shared {
 
 
struct last_tooth_rev_calculator_t
{
  uint32_t _toothLastToothTime = 0;  
 
#if !defined(UNIT_TEST)
protected:
#endif
  last_tooth_rev_calculator_t() = default;
  explicit last_tooth_rev_calculator_t(uint32_t toothLastToothTime);
  
  int16_t calculate(uint32_t currMicros) const;
};
 
struct tooth_interval_calculator_t
{
  uint32_t _toothLastToothTime = 0;         
  uint32_t _toothLastMinusOneToothTime = 0; 
  uint16_t _toothAngle = 0;                 
  bool _toothAngleCorrect;                  
 
#if !defined(UNIT_TEST)
protected:
#endif
  tooth_interval_calculator_t() = default;
  explicit tooth_interval_calculator_t(uint32_t toothLastToothTime, uint32_t toothLastMinusOneToothTime, uint16_t toothAngle, bool toothAngleCorrect);
  
  int16_t calculate(uint32_t currMicros) const;
};
 
struct lookup_initial_calculator_t
{
  uint16_t _toothCurrentCount = 0;   
 
#if !defined(UNIT_TEST)
protected:
#endif
  lookup_initial_calculator_t() = default;
  explicit lookup_initial_calculator_t(uint16_t toothCurrentCount);
  
  int16_t calculate(const int16_t toothAngles[]) const;
};
 
struct compute_initial_calculator_t
{
  uint16_t _toothCurrentCount = 0;  
  uint16_t _toothAngle = 0;         
 
#if !defined(UNIT_TEST)
protected:
#endif
  compute_initial_calculator_t() = default;
  explicit compute_initial_calculator_t(uint16_t toothCurrentCount, uint16_t toothAngle);
  
  int16_t calculate(void) const;
};
 
struct sequential_correction_calculator_t
{
  bool _revZeroOrOne = false; 
 
#if !defined(UNIT_TEST)
protected:
#endif
  sequential_correction_calculator_t() = default;
  explicit sequential_correction_calculator_t(bool revZeroOrOne);
  
  int16_t calculate(const config4 &page4) const;
};
 
 
struct simple_crank_angle_calculator_t : last_tooth_rev_calculator_t, sequential_correction_calculator_t
 {
    int16_t calculateCrankAngle(int16_t initialCrankAngle, uint32_t currMicros, const config4 &page4) const;
};
 
struct lookup_crank_angle_calculator_t : public last_tooth_rev_calculator_t, sequential_correction_calculator_t, lookup_initial_calculator_t
{
  lookup_crank_angle_calculator_t() = default;
  explicit lookup_crank_angle_calculator_t(const std::tuple<uint32_t, bool, uint16_t> &data);
 
  int16_t calculateCrankAngle(uint32_t currMicros, const int16_t toothAngles[], const config4 &page4) const;
};
 
struct trigger_angle_crank_angle_calculator_t : public last_tooth_rev_calculator_t, sequential_correction_calculator_t, compute_initial_calculator_t
{
  trigger_angle_crank_angle_calculator_t() = default;
  explicit trigger_angle_crank_angle_calculator_t(const std::tuple<uint32_t, bool, uint16_t, uint16_t> &data);
 
  int16_t calculateCrankAngle(uint32_t currMicros, const config4 &page4) const;
};
 
struct lookup_crank_angle_calculator_tooth_interval_t : public tooth_interval_calculator_t, sequential_correction_calculator_t, lookup_initial_calculator_t
{
  lookup_crank_angle_calculator_tooth_interval_t() = default;
  explicit lookup_crank_angle_calculator_tooth_interval_t(const std::tuple<uint32_t, uint32_t, bool, uint16_t, uint16_t, bool> &data);
 
  int16_t calculateCrankAngle(uint32_t currMicros, const int16_t toothAngles[], const config4 &page4) const;
};
 
struct compute_crank_angle_calculator_tooth_interval_t : public tooth_interval_calculator_t, sequential_correction_calculator_t, compute_initial_calculator_t
{
  compute_crank_angle_calculator_tooth_interval_t() = default;
  explicit compute_crank_angle_calculator_tooth_interval_t(const std::tuple<uint32_t, uint32_t, bool, uint16_t, uint16_t, bool> &data);
 
  int16_t calculateCrankAngle(uint32_t currMicros, const config4 &page4) const;
};
 
 
static inline auto atomic_make_lookup_caa(const state_t &decoderState)
{
  return lookup_crank_angle_calculator_t(atomic_copy(decoderState.toothLastToothTime, decoderState.revolutionOne, decoderState.toothCurrentCount));
}
static inline auto atomic_make_lookup_caa_secondary(const state_t &decoderState)
{
  return lookup_crank_angle_calculator_t(atomic_copy(decoderState.toothLastToothTime, decoderState.revolutionOne, decoderState.secondaryToothCount));
}
static inline auto atomic_make_angle_caa(const state_t &decoderState)
{
  return trigger_angle_crank_angle_calculator_t(atomic_copy(decoderState.toothLastToothTime, decoderState.revolutionOne, decoderState.toothCurrentCount, decoderState.triggerToothAngle));
}
 
static inline uint16_t clampCrankAngle(int16_t crankAngle)
{
  auto crankMax = std::max(CRANK_ANGLE_MAX_IGN, CRANK_ANGLE_MAX_INJ);
  return nudge((int16_t)0, (int16_t)crankMax, (int16_t)crankAngle);
}
 
}
}