rusefi
/
custom-board-bundle-sample-fork-of-rusefi
mirror of https://github.com/rusefi/custom-board-bundle-sample-fork-of-rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Drop SingleChannelStateSequence in favor of MultiChannelStateSequenceWithData (#3519) 

* Drop SingleChannelStateSequence in favor of MultiChannelStateSequenceWithData

Most all the users were Multi* anyways, so just improve that:
1. Allow up to 8 waveforms to share one byte per timestamp.  It could be better but this is simple
   and gets most of the benefit.
2. Use a wrapper structure to handle reserving space for the arrays.  Makes the interface simpler
   and more rigid.  Also saves 4 bytes per Multi*.  Downside is access is now via -> and *,
   not . and (nothing).

Saves 224 bytes of BSS, 1832 bytes of RAM4/CCM, 952 bytes of TEXT, and 103 bytes of RODATA

* Instantiate a base_t to make debugging easier.
Also fixes crash on real firmware by using &m_base instead - LTO optimization issue?

* No magical templated StaticAlloc thingy.  Just virtual functions.
This commit is contained in:
Scott Smith 2021-11-21 01:56:07 -08:00 committed by GitHub
parent 9a28e8d938
commit ba4a00d3bb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 137 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
firmware/controllers/core/state_sequence.cpp
View File

@ -9,86 +9,24 @@
#include "state_sequence.h" #include "state_sequence.h"
#include "trigger_structure.h" #include "trigger_structure.h"
SingleChannelStateSequence::SingleChannelStateSequence() {
init(NULL);
}
SingleChannelStateSequence::SingleChannelStateSequence(pin_state_t *ps) {
init(ps);
}
void SingleChannelStateSequence::init(pin_state_t *pinStates) {
this->pinStates = pinStates;
}
pin_state_t SingleChannelStateSequence::getState(int switchIndex) const {
pin_state_t state = pinStates[switchIndex];
efiAssert(OBD_PCM_Processor_Fault, state == 0 || state == 1, "wave state get", TV_FALL);
return state;
}
void SingleChannelStateSequence::setState(int switchIndex, pin_state_t state) {
efiAssertVoid(OBD_PCM_Processor_Fault, state == 0 || state == 1, "wave state set");
pinStates[switchIndex] = state;
}
MultiChannelStateSequence::MultiChannelStateSequence() {
reset();
}
MultiChannelStateSequence::MultiChannelStateSequence(float *switchTimes, SingleChannelStateSequence *waves) : MultiChannelStateSequence() {
init(switchTimes, waves);
}
void MultiChannelStateSequence::init(float *switchTimes, SingleChannelStateSequence *channels) {
this->switchTimes = switchTimes;
this->channels = channels;
}
void MultiChannelStateSequence::reset(void) {
waveCount = 0;
}
float MultiChannelStateSequence::getSwitchTime(const int index) const {
return switchTimes[index];
}
void MultiChannelStateSequence::checkSwitchTimes(const float scale) const { void MultiChannelStateSequence::checkSwitchTimes(const float scale) const {
if (switchTimes[phaseCount - 1] != 1) { if (getSwitchTime(phaseCount - 1) != 1) {
firmwareError(CUSTOM_ERR_WAVE_1, "last switch time has to be 1/%f not %.2f/%f", scale, firmwareError(CUSTOM_ERR_WAVE_1, "last switch time has to be 1/%f not %.2f/%f",
switchTimes[phaseCount - 1], scale * switchTimes[phaseCount - 1]); scale, getSwitchTime(phaseCount - 1),
scale * getSwitchTime(phaseCount - 1));
return; return;
} }
for (int i = 0; i < phaseCount - 1; i++) { for (int i = 0; i < phaseCount - 1; i++) {
if (switchTimes[i] >= switchTimes[i + 1]) { if (getSwitchTime(i) >= getSwitchTime(i + 1)) {
firmwareError(CUSTOM_ERR_WAVE_2, "invalid switchTimes @%d: %.2f/%.2f", i, switchTimes[i], switchTimes[i + 1]); firmwareError(CUSTOM_ERR_WAVE_2, "invalid switchTimes @%d: %.2f/%.2f",
i, getSwitchTime(i), getSwitchTime(i + 1));
} }
} }
} }
pin_state_t MultiChannelStateSequence::getChannelState(const int channelIndex, const int phaseIndex) const {
if (channelIndex >= waveCount) {
// todo: would be nice to get this asserting working
//firmwareError(OBD_PCM_Processor_Fault, "channel index %d/%d", channelIndex, waveCount);
}
return channels[channelIndex].pinStates[phaseIndex];
}
void MultiChannelStateSequence::setChannelState(const int channelIndex, const int phaseIndex,
pin_state_t state) {
if (channelIndex >= waveCount) {
// todo: would be nice to get this asserting working
//firmwareError(OBD_PCM_Processor_Fault, "channel index %d/%d", channelIndex, waveCount);
}
channels[channelIndex].pinStates[phaseIndex] = state;
}
/**
* returns the index at which given value would need to be inserted into sorted array
*/
int MultiChannelStateSequence::findInsertionAngle(const float angle) const { int MultiChannelStateSequence::findInsertionAngle(const float angle) const {
for (int i = phaseCount - 1; i >= 0; i--) { for (int i = phaseCount - 1; i >= 0; i--) {
if (angle > switchTimes[i]) if (angle > getSwitchTime(i))
return i + 1; return i + 1;
} }
return 0; return 0;
@ -96,13 +34,8 @@ int MultiChannelStateSequence::findInsertionAngle(const float angle) const {
int MultiChannelStateSequence::findAngleMatch(const float angle) const { int MultiChannelStateSequence::findAngleMatch(const float angle) const {
for (int i = 0; i < phaseCount; i++) { for (int i = 0; i < phaseCount; i++) {
if (isSameF(switchTimes[i], angle)) if (isSameF(getSwitchTime(i), angle))
return i; return i;
} }
return EFI_ERROR_CODE; return EFI_ERROR_CODE;
} }
void MultiChannelStateSequence::setSwitchTime(const int index, const float value) {
efiAssertVoid(CUSTOM_ERR_PWM_SWITCH_ASSERT, switchTimes != NULL, "switchTimes");
switchTimes[index] = value;
}

112
firmware/controllers/core/state_sequence.h
View File

@ -26,72 +26,72 @@
#endif /* PWM_PHASE_MAX_COUNT */ #endif /* PWM_PHASE_MAX_COUNT */
#define PWM_PHASE_MAX_WAVE_PER_PWM 3 #define PWM_PHASE_MAX_WAVE_PER_PWM 3
/**
* int8_t is probably less efficient then int32_t but we need
* to reduce memory footprint
*
* todo: migrate to bit-array to save memory?
* this would cost some CPU cycles. see std::vector<bool>
*/
typedef trigger_value_e pin_state_t; typedef trigger_value_e pin_state_t;
/**
* This class represents one channel of a digital signal state sequence
* Each element represents either a HIGH or LOW state - while at the moment this
* is not implemented using a bit array, it could absolutely be a bit array
*
* This sequence does not know anything about signal lengths - only signal state at a given index
* This sequence can have consecutive zeros and ones since these sequences work as a group within MultiChannelStateSequence
*
* @brief PWM configuration for the specific output pin
*/
class SingleChannelStateSequence {
public:
SingleChannelStateSequence();
explicit SingleChannelStateSequence(pin_state_t *pinStates);
void init(pin_state_t *pinStates);
/**
* todo: confirm that we only deal with two states here, no magic '-1'?
* @return HIGH or LOW state at given index
*/
pin_state_t getState(int switchIndex) const;
void setState(int switchIndex, pin_state_t state);
// todo: make this private by using 'getState' and 'setState' methods
pin_state_t *pinStates;
};
/** /**
* This class represents multi-channel logical signals with shared time axis * This class represents multi-channel logical signals with shared time axis
* *
* This is a semi-abstract interface so that implementations can exist for either regularized
* patterns (60-2, etc) or completely arbitrary patterns stored in arrays.
*/ */
class MultiChannelStateSequence { class MultiChannelStateSequence {
public: public:
MultiChannelStateSequence();
MultiChannelStateSequence(float *switchTimes, SingleChannelStateSequence *waves);
void init(float *switchTimes, SingleChannelStateSequence *waves);
void reset(void);
float getSwitchTime(const int phaseIndex) const;
void setSwitchTime(const int phaseIndex, const float value);
void checkSwitchTimes(const float scale) const;
pin_state_t getChannelState(const int channelIndex, const int phaseIndex) const;
void setChannelState(const int channelIndex, const int phaseIndex, pin_state_t state);
int findAngleMatch(const float angle) const;
int findInsertionAngle(const float angle) const;
/** /**
* Number of signal channels * values in the (0..1] range which refer to points within the period at at which pin state
* should be changed So, in the simplest case we turn pin off at 0.3 and turn it on at 1 -
* that would give us a 70% duty cycle PWM
*/ */
uint16_t phaseCount; virtual float getSwitchTime(int phaseIndex) const = 0;
uint16_t waveCount; virtual pin_state_t getChannelState(int channelIndex, int phaseIndex) const = 0;
SingleChannelStateSequence *channels = nullptr;
//private: // Make sure the switch times are in order and end at the very end.
/** void checkSwitchTimes(float scale) const;
* values in the (0..1] range which refer to points within the period at at which pin state should be changed
* So, in the simplest case we turn pin off at 0.3 and turn it on at 1 - that would give us a 70% duty cycle PWM // Find the exact angle, or EFI_ERROR_CODE if it doesn't exist
*/ int findAngleMatch(float angle) const;
float *switchTimes = nullptr;
// returns the index at which given value would need to be inserted into sorted array
int findInsertionAngle(float angle) const;
uint16_t phaseCount = 0; // Number of timestamps
uint16_t waveCount = 0; // Number of waveforms
}; };
template<unsigned max_phase>
class MultiChannelStateSequenceWithData : public MultiChannelStateSequence {
public:
float getSwitchTime(int phaseIndex) const override {
return switchTimes[phaseIndex];
}
pin_state_t getChannelState(int channelIndex, int phaseIndex) const override {
if (channelIndex >= waveCount) {
// todo: would be nice to get this asserting working
//firmwareError(OBD_PCM_Processor_Fault, "channel index %d/%d", channelIndex, waveCount);
}
return ((waveForm[phaseIndex] >> channelIndex) & 1) ? TV_RISE : TV_FALL;
}
void reset() {
waveCount = 0;
}
void setSwitchTime(const int phaseIndex, const float value) {
efiAssertVoid(CUSTOM_ERR_PWM_SWITCH_ASSERT, switchTimes != nullptr, "switchTimes");
switchTimes[phaseIndex] = value;
}
void setChannelState(const int channelIndex, const int phaseIndex, pin_state_t state) {
if (channelIndex >= waveCount) {
// todo: would be nice to get this asserting working
//firmwareError(OBD_PCM_Processor_Fault, "channel index %d/%d", channelIndex, waveCount);
}
uint8_t & ref = waveForm[phaseIndex];
ref = (ref & ~(1U << channelIndex)) | ((state == TV_RISE ? 1 : 0) << channelIndex);
}
private:
float switchTimes[max_phase];
uint8_t waveForm[max_phase];
};

14
firmware/controllers/system/timer/pwm_generator_logic.cpp
View File

@ -19,8 +19,6 @@
#define ZERO_PWM_THRESHOLD 0.01 #define ZERO_PWM_THRESHOLD 0.01
SimplePwm::SimplePwm() SimplePwm::SimplePwm()
: sr(pinStates)
, seq(_switchTimes, &sr)
{ {
seq.waveCount = 1; seq.waveCount = 1;
seq.phaseCount = 2; seq.phaseCount = 2;
@ -87,7 +85,7 @@ void SimplePwm::setSimplePwmDutyCycle(float dutyCycle) {
mode = PM_FULL; mode = PM_FULL;
} else { } else {
mode = PM_NORMAL; mode = PM_NORMAL;
_switchTimes[0] = dutyCycle; seq.setSwitchTime(0, dutyCycle);
} }
} }
@ -316,15 +314,15 @@ void startSimplePwm(SimplePwm *state, const char *msg, ExecutorInterface *execut
return; return;
} }
state->_switchTimes[0] = dutyCycle; state->seq.setSwitchTime(0, dutyCycle);
state->_switchTimes[1] = 1; state->seq.setSwitchTime(1, 1);
state->pinStates[0] = TV_FALL; state->seq.setChannelState(0, 0, TV_FALL);
state->pinStates[1] = TV_RISE; state->seq.setChannelState(0, 1, TV_RISE);
state->outputPins[0] = output; state->outputPins[0] = output;
state->setFrequency(frequency); state->setFrequency(frequency);
state->setSimplePwmDutyCycle(dutyCycle); // TODO: DUP ABOVE? state->setSimplePwmDutyCycle(dutyCycle);
state->weComplexInit(msg, executor, &state->seq, NULL, (pwm_gen_callback*)applyPinState); state->weComplexInit(msg, executor, &state->seq, NULL, (pwm_gen_callback*)applyPinState);
} }

5
firmware/controllers/system/timer/pwm_generator_logic.h
View File

@ -120,10 +120,7 @@ public:
SimplePwm(); SimplePwm();
explicit SimplePwm(const char *name); explicit SimplePwm(const char *name);
void setSimplePwmDutyCycle(float dutyCycle) override; void setSimplePwmDutyCycle(float dutyCycle) override;
pin_state_t pinStates[2]; MultiChannelStateSequenceWithData<2> seq;
SingleChannelStateSequence sr;
float _switchTimes[2];
MultiChannelStateSequence seq;
hardware_pwm* hardPwm = nullptr; hardware_pwm* hardPwm = nullptr;
}; };

78
firmware/controllers/trigger/decoders/trigger_structure.cpp
View File

@ -49,18 +49,8 @@ void event_trigger_position_s::setAngle(angle_t angle) {
this, angle); this, angle);
} }
trigger_shape_helper::trigger_shape_helper() { TriggerWaveform::TriggerWaveform() {
memset(&pinStates, 0, sizeof(pinStates));
for (int channelIndex = 0; channelIndex < TRIGGER_CHANNEL_COUNT; channelIndex++) {
channels[channelIndex].init(pinStates[channelIndex]);
}
}
TriggerWaveform::TriggerWaveform()
: waveStorage(switchTimesBuffer, NULL)
, wave(&waveStorage) {
initialize(OM_NONE); initialize(OM_NONE);
wave->channels = h.channels;
} }
void TriggerWaveform::initialize(operation_mode_e operationMode) { void TriggerWaveform::initialize(operation_mode_e operationMode) {
@ -85,11 +75,10 @@ void TriggerWaveform::initialize(operation_mode_e operationMode) {
this->operationMode = operationMode; this->operationMode = operationMode;
triggerShapeSynchPointIndex = 0; triggerShapeSynchPointIndex = 0;
memset(initialState, 0, sizeof(initialState)); memset(initialState, 0, sizeof(initialState));
memset(switchTimesBuffer, 0, sizeof(switchTimesBuffer));
memset(expectedEventCount, 0, sizeof(expectedEventCount)); memset(expectedEventCount, 0, sizeof(expectedEventCount));
wave->reset(); wave.reset();
wave->waveCount = TRIGGER_CHANNEL_COUNT; wave.waveCount = TRIGGER_CHANNEL_COUNT;
wave->phaseCount = 0; wave.phaseCount = 0;
previousAngle = 0; previousAngle = 0;
memset(isRiseEvent, 0, sizeof(isRiseEvent)); memset(isRiseEvent, 0, sizeof(isRiseEvent));
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
@ -99,7 +88,7 @@ void TriggerWaveform::initialize(operation_mode_e operationMode) {
} }
size_t TriggerWaveform::getSize() const { size_t TriggerWaveform::getSize() const {
return wave->phaseCount; return wave.phaseCount;
} }
int TriggerWaveform::getTriggerWaveformSynchPointIndex() const { int TriggerWaveform::getTriggerWaveformSynchPointIndex() const {
@ -149,9 +138,9 @@ angle_t TriggerWaveform::getAngle(int index) const {
* See also trigger_central.cpp * See also trigger_central.cpp
* See also getEngineCycleEventCount() * See also getEngineCycleEventCount()
*/ */
efiAssert(CUSTOM_ERR_ASSERT, wave->phaseCount != 0, "shapeSize=0", NAN); efiAssert(CUSTOM_ERR_ASSERT, wave.phaseCount != 0, "shapeSize=0", NAN);
int crankCycle = index / wave->phaseCount; int crankCycle = index / wave.phaseCount;
int remainder = index % wave->phaseCount; int remainder = index % wave.phaseCount;
auto cycleStartAngle = getCycleDuration() * crankCycle; auto cycleStartAngle = getCycleDuration() * crankCycle;
auto positionWithinCycle = getSwitchAngle(remainder); auto positionWithinCycle = getSwitchAngle(remainder);
@ -235,9 +224,9 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
#endif #endif
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
assertIsInBounds(wave->phaseCount, triggerSignalIndeces, "trigger shape overflow"); assertIsInBounds(wave.phaseCount, triggerSignalIndeces, "trigger shape overflow");
triggerSignalIndeces[wave->phaseCount] = channelIndex; triggerSignalIndeces[wave.phaseCount] = channelIndex;
triggerSignalStates[wave->phaseCount] = state; triggerSignalStates[wave.phaseCount] = state;
#endif // EFI_UNIT_TEST #endif // EFI_UNIT_TEST
@ -249,46 +238,39 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
} }
efiAssertVoid(CUSTOM_ERR_6599, angle > 0 && angle <= 1, "angle should be positive not above 1"); efiAssertVoid(CUSTOM_ERR_6599, angle > 0 && angle <= 1, "angle should be positive not above 1");
if (wave->phaseCount > 0) { if (wave.phaseCount > 0) {
if (angle <= previousAngle) { if (angle <= previousAngle) {
warning(CUSTOM_ERR_TRG_ANGLE_ORDER, "invalid angle order %s %s: new=%.2f/%f and prev=%.2f/%f, size=%d", warning(CUSTOM_ERR_TRG_ANGLE_ORDER, "invalid angle order %s %s: new=%.2f/%f and prev=%.2f/%f, size=%d",
getTrigger_wheel_e(channelIndex), getTrigger_wheel_e(channelIndex),
getTrigger_value_e(state), getTrigger_value_e(state),
angle, angle * getCycleDuration(), angle, angle * getCycleDuration(),
previousAngle, previousAngle * getCycleDuration(), previousAngle, previousAngle * getCycleDuration(),
wave->phaseCount); wave.phaseCount);
setShapeDefinitionError(true); setShapeDefinitionError(true);
return; return;
} }
} }
previousAngle = angle; previousAngle = angle;
if (wave->phaseCount == 0) { if (wave.phaseCount == 0) {
wave->phaseCount = 1; wave.phaseCount = 1;
for (int i = 0; i < PWM_PHASE_MAX_WAVE_PER_PWM; i++) { for (int i = 0; i < PWM_PHASE_MAX_WAVE_PER_PWM; i++) {
SingleChannelStateSequence *swave = &wave->channels[i]; wave.setChannelState(i, /* switchIndex */ 0, /* value */ initialState[i]);
if (swave->pinStates == nullptr) {
warning(CUSTOM_ERR_STATE_NULL, "wave pinStates is NULL");
setShapeDefinitionError(true);
return;
}
wave->setChannelState(i, /* switchIndex */ 0, /* value */ initialState[i]);
} }
isRiseEvent[0] = TV_RISE == state; isRiseEvent[0] = TV_RISE == state;
wave->setSwitchTime(0, angle); wave.setSwitchTime(0, angle);
wave->setChannelState(channelIndex, /* channelIndex */ 0, /* value */ state); wave.setChannelState(channelIndex, /* channelIndex */ 0, /* value */ state);
return; return;
} }
int exactMatch = wave->findAngleMatch(angle); int exactMatch = wave.findAngleMatch(angle);
if (exactMatch != (int)EFI_ERROR_CODE) { if (exactMatch != (int)EFI_ERROR_CODE) {
warning(CUSTOM_ERR_SAME_ANGLE, "same angle: not supported"); warning(CUSTOM_ERR_SAME_ANGLE, "same angle: not supported");
setShapeDefinitionError(true); setShapeDefinitionError(true);
return; return;
} }
int index = wave->findInsertionAngle(angle); int index = wave.findInsertionAngle(angle);
/** /**
* todo: it would be nice to be able to provide trigger angles without sorting them externally * todo: it would be nice to be able to provide trigger angles without sorting them externally
@ -298,29 +280,29 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
/* /*
for (int i = size - 1; i >= index; i--) { for (int i = size - 1; i >= index; i--) {
for (int j = 0; j < PWM_PHASE_MAX_WAVE_PER_PWM; j++) { for (int j = 0; j < PWM_PHASE_MAX_WAVE_PER_PWM; j++) {
wave->waves[j].pinStates[i + 1] = wave->getChannelState(j, index); wave.waves[j].pinStates[i + 1] = wave.getChannelState(j, index);
} }
wave->setSwitchTime(i + 1, wave->getSwitchTime(i)); wave.setSwitchTime(i + 1, wave.getSwitchTime(i));
} }
*/ */
isRiseEvent[index] = TV_RISE == state; isRiseEvent[index] = TV_RISE == state;
if ((unsigned)index != wave->phaseCount) { if ((unsigned)index != wave.phaseCount) {
firmwareError(ERROR_TRIGGER_DRAMA, "are we ever here?"); firmwareError(ERROR_TRIGGER_DRAMA, "are we ever here?");
} }
wave->phaseCount++; wave.phaseCount++;
for (int i = 0; i < PWM_PHASE_MAX_WAVE_PER_PWM; i++) { for (int i = 0; i < PWM_PHASE_MAX_WAVE_PER_PWM; i++) {
pin_state_t value = wave->getChannelState(/* channelIndex */i, index - 1); pin_state_t value = wave.getChannelState(/* channelIndex */i, index - 1);
wave->setChannelState(i, index, value); wave.setChannelState(i, index, value);
} }
wave->setSwitchTime(index, angle); wave.setSwitchTime(index, angle);
wave->setChannelState(channelIndex, index, state); wave.setChannelState(channelIndex, index, state);
} }
angle_t TriggerWaveform::getSwitchAngle(int index) const { angle_t TriggerWaveform::getSwitchAngle(int index) const {
return getCycleDuration() * wave->getSwitchTime(index); return getCycleDuration() * wave.getSwitchTime(index);
} }
void setToothedWheelConfiguration(TriggerWaveform *s, int total, int skipped, void setToothedWheelConfiguration(TriggerWaveform *s, int total, int skipped,
@ -761,7 +743,7 @@ void TriggerWaveform::initializeTriggerWaveform(operation_mode_e ambiguousOperat
version++; version++;
if (!shapeDefinitionError) { if (!shapeDefinitionError) {
wave->checkSwitchTimes(getCycleDuration()); wave.checkSwitchTimes(getCycleDuration());
} }
if (bothFrontsRequired && useOnlyRisingEdgeForTrigger) { if (bothFrontsRequired && useOnlyRisingEdgeForTrigger) {

22
firmware/controllers/trigger/decoders/trigger_structure.h
View File

@ -60,15 +60,6 @@ public:
#define TRIGGER_CHANNEL_COUNT 3 #define TRIGGER_CHANNEL_COUNT 3
class trigger_shape_helper {
public:
trigger_shape_helper();
SingleChannelStateSequence channels[TRIGGER_CHANNEL_COUNT];
private:
pin_state_t pinStates[TRIGGER_CHANNEL_COUNT][PWM_PHASE_MAX_COUNT];
};
class Engine; class Engine;
class TriggerState; class TriggerState;
class TriggerFormDetails; class TriggerFormDetails;
@ -199,8 +190,7 @@ public:
* but name is supposed to hint at the fact that decoders should not be assigning to it * but name is supposed to hint at the fact that decoders should not be assigning to it
* Please use "getTriggerSize()" macro or "getSize()" method to read this value * Please use "getTriggerSize()" macro or "getSize()" method to read this value
*/ */
MultiChannelStateSequence waveStorage; // DON'T USE - WILL BE REMOVED LATER MultiChannelStateSequenceWithData<PWM_PHASE_MAX_COUNT> wave;
MultiChannelStateSequence * const wave;
// todo: add a runtime validation which would verify that this field was set properly // todo: add a runtime validation which would verify that this field was set properly
// todo: maybe even automate this flag calculation? // todo: maybe even automate this flag calculation?
@ -276,14 +266,6 @@ public:
uint16_t findAngleIndex(TriggerFormDetails *details, angle_t angle) const; uint16_t findAngleIndex(TriggerFormDetails *details, angle_t angle) const;
private: private:
trigger_shape_helper h;
/**
* Working buffer for 'wave' instance
* Values are in the 0..1 range
*/
float switchTimesBuffer[PWM_PHASE_MAX_COUNT];
/** /**
* These angles are in trigger DESCRIPTION coordinates - i.e. the way you add events while declaring trigger shape * These angles are in trigger DESCRIPTION coordinates - i.e. the way you add events while declaring trigger shape
*/ */
@ -326,4 +308,4 @@ void setToothedWheelConfiguration(TriggerWaveform *s, int total, int skipped, op
#define TRIGGER_WAVEFORM(x) engine->triggerCentral.triggerShape.x #define TRIGGER_WAVEFORM(x) engine->triggerCentral.triggerShape.x
#define getTriggerSize() TRIGGER_WAVEFORM(wave->phaseCount) #define getTriggerSize() TRIGGER_WAVEFORM(wave.phaseCount)

6
firmware/controllers/trigger/trigger_emulator_algo.cpp
View File

@ -20,7 +20,7 @@ int getPreviousIndex(const int currentIndex, const int size) {
return (currentIndex + size - 1) % size; return (currentIndex + size - 1) % size;
} }
bool needEvent(const int currentIndex, const MultiChannelStateSequence& mcss, int channelIndex) { bool needEvent(const int currentIndex, const MultiChannelStateSequence & mcss, int channelIndex) {
int prevIndex = getPreviousIndex(currentIndex, mcss.phaseCount); int prevIndex = getPreviousIndex(currentIndex, mcss.phaseCount);
pin_state_t previousValue = mcss.getChannelState(channelIndex, /*phaseIndex*/prevIndex); pin_state_t previousValue = mcss.getChannelState(channelIndex, /*phaseIndex*/prevIndex);
pin_state_t currentValue = mcss.getChannelState(channelIndex, /*phaseIndex*/currentIndex); pin_state_t currentValue = mcss.getChannelState(channelIndex, /*phaseIndex*/currentIndex);
@ -106,7 +106,7 @@ static void updateTriggerWaveformIfNeeded(PwmConfig *state) {
TriggerWaveform *s = &engine->triggerCentral.triggerShape; TriggerWaveform *s = &engine->triggerCentral.triggerShape;
copyPwmParameters(state, s->wave); copyPwmParameters(state, &s->wave);
state->safe.periodNt = -1; // this would cause loop re-initialization state->safe.periodNt = -1; // this would cause loop re-initialization
} }
} }
@ -146,7 +146,7 @@ static void initTriggerPwm() {
setTriggerEmulatorRPM(engineConfiguration->triggerSimulatorFrequency); setTriggerEmulatorRPM(engineConfiguration->triggerSimulatorFrequency);
triggerSignal.weComplexInit("position sensor", triggerSignal.weComplexInit("position sensor",
&engine->executor, &engine->executor,
s->wave, &s->wave,
updateTriggerWaveformIfNeeded, (pwm_gen_callback*)emulatorApplyPinState); updateTriggerWaveformIfNeeded, (pwm_gen_callback*)emulatorApplyPinState);
hasInitTriggerEmulator = true; hasInitTriggerEmulator = true;

4
firmware/controllers/trigger/trigger_simulator.cpp
View File

@ -33,7 +33,7 @@ int getSimulatedEventTime(const TriggerWaveform& shape, int i) {
int stateIndex = i % shape.getSize(); int stateIndex = i % shape.getSize();
int loopIndex = i / shape.getSize(); int loopIndex = i / shape.getSize();
return (int) (SIMULATION_CYCLE_PERIOD * (loopIndex + shape.wave->getSwitchTime(stateIndex))); return (int) (SIMULATION_CYCLE_PERIOD * (loopIndex + shape.wave.getSwitchTime(stateIndex)));
} }
void TriggerStimulatorHelper::feedSimulatedEvent( void TriggerStimulatorHelper::feedSimulatedEvent(
@ -48,7 +48,7 @@ void TriggerStimulatorHelper::feedSimulatedEvent(
int time = getSimulatedEventTime(shape, i); int time = getSimulatedEventTime(shape, i);
const MultiChannelStateSequence& multiChannelStateSequence = *shape.wave; const auto & multiChannelStateSequence = shape.wave;
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
int prevIndex = getPreviousIndex(stateIndex, shape.getSize()); int prevIndex = getPreviousIndex(stateIndex, shape.getSize());

42
unit_tests/tests/ignition_injection/test_fuel_map.cpp
View File

@ -103,31 +103,31 @@ static void configureFordAspireTriggerWaveform(TriggerWaveform * s) {
s->addEvent720(657.03, T_SECONDARY, TV_FALL); s->addEvent720(657.03, T_SECONDARY, TV_FALL);
s->addEvent720(720, T_PRIMARY, TV_FALL); s->addEvent720(720, T_PRIMARY, TV_FALL);
ASSERT_FLOAT_EQ(53.747 / 720, s->wave->getSwitchTime(0)); ASSERT_FLOAT_EQ(53.747 / 720, s->wave.getSwitchTime(0));
ASSERT_EQ( 1, s->wave->getChannelState(1, 0)) << "@0"; ASSERT_EQ( 1, s->wave.getChannelState(1, 0)) << "@0";
ASSERT_EQ( 1, s->wave->getChannelState(1, 0)) << "@0"; ASSERT_EQ( 1, s->wave.getChannelState(1, 0)) << "@0";
ASSERT_EQ( 0, s->wave->getChannelState(0, 1)) << "@1"; ASSERT_EQ( 0, s->wave.getChannelState(0, 1)) << "@1";
ASSERT_EQ( 0, s->wave->getChannelState(1, 1)) << "@1"; ASSERT_EQ( 0, s->wave.getChannelState(1, 1)) << "@1";
ASSERT_EQ( 0, s->wave->getChannelState(0, 2)) << "@2"; ASSERT_EQ( 0, s->wave.getChannelState(0, 2)) << "@2";
ASSERT_EQ( 1, s->wave->getChannelState(1, 2)) << "@2"; ASSERT_EQ( 1, s->wave.getChannelState(1, 2)) << "@2";
ASSERT_EQ( 0, s->wave->getChannelState(0, 3)) << "@3"; ASSERT_EQ( 0, s->wave.getChannelState(0, 3)) << "@3";
ASSERT_EQ( 0, s->wave->getChannelState(1, 3)) << "@3"; ASSERT_EQ( 0, s->wave.getChannelState(1, 3)) << "@3";
ASSERT_EQ( 1, s->wave->getChannelState(0, 4)) << "@4"; ASSERT_EQ( 1, s->wave.getChannelState(0, 4)) << "@4";
ASSERT_EQ( 1, s->wave->getChannelState(1, 5)) << "@5"; ASSERT_EQ( 1, s->wave.getChannelState(1, 5)) << "@5";
ASSERT_EQ( 0, s->wave->getChannelState(1, 8)) << "@8"; ASSERT_EQ( 0, s->wave.getChannelState(1, 8)) << "@8";
ASSERT_FLOAT_EQ(121.90 / 720, s->wave->getSwitchTime(1)); ASSERT_FLOAT_EQ(121.90 / 720, s->wave.getSwitchTime(1));
ASSERT_FLOAT_EQ(657.03 / 720, s->wave->getSwitchTime(8)); ASSERT_FLOAT_EQ(657.03 / 720, s->wave.getSwitchTime(8));
ASSERT_EQ( 0, s->wave->findAngleMatch(53.747 / 720.0)) << "expecting 0"; ASSERT_EQ( 0, s->wave.findAngleMatch(53.747 / 720.0)) << "expecting 0";
assertEqualsM("expecting not found", -1, s->wave->findAngleMatch(53 / 720.0)); assertEqualsM("expecting not found", -1, s->wave.findAngleMatch(53 / 720.0));
ASSERT_EQ(7, s->wave->findAngleMatch(588.045 / 720.0)); ASSERT_EQ(7, s->wave.findAngleMatch(588.045 / 720.0));
ASSERT_EQ( 0, s->wave->findInsertionAngle(23.747 / 720.0)) << "expecting 0"; ASSERT_EQ( 0, s->wave.findInsertionAngle(23.747 / 720.0)) << "expecting 0";
ASSERT_EQ( 1, s->wave->findInsertionAngle(63.747 / 720.0)) << "expecting 1"; ASSERT_EQ( 1, s->wave.findInsertionAngle(63.747 / 720.0)) << "expecting 1";
} }
TEST(misc, testAngleResolver) { TEST(misc, testAngleResolver) {
@ -142,9 +142,9 @@ TEST(misc, testAngleResolver) {
engine->initializeTriggerWaveform(); engine->initializeTriggerWaveform();
assertEqualsM("index 2", 52.76, triggerFormDetails->eventAngles[3]); // this angle is relation to synch point assertEqualsM("index 2", 52.76, triggerFormDetails->eventAngles[3]); // this angle is relation to synch point
assertEqualsM("time 2", 0.3233, ts->wave->getSwitchTime(2)); assertEqualsM("time 2", 0.3233, ts->wave.getSwitchTime(2));
assertEqualsM("index 5", 412.76, triggerFormDetails->eventAngles[6]); assertEqualsM("index 5", 412.76, triggerFormDetails->eventAngles[6]);
assertEqualsM("time 5", 0.5733, ts->wave->getSwitchTime(5)); assertEqualsM("time 5", 0.5733, ts->wave.getSwitchTime(5));
ASSERT_EQ(4, ts->getTriggerWaveformSynchPointIndex()); ASSERT_EQ(4, ts->getTriggerWaveformSynchPointIndex());

2
unit_tests/tests/trigger/test_miata_na_tdc.cpp
View File

@ -21,7 +21,7 @@ TEST(miata, miata_na_tdc) {
eth.setTimeAndInvokeEventsUs(time); eth.setTimeAndInvokeEventsUs(time);
emulatorHelper.handleEmulatorCallback( emulatorHelper.handleEmulatorCallback(
*shape.wave, shape.wave,
i % shape.getSize()); i % shape.getSize());
} }

4
unit_tests/tests/trigger/test_nissan_vq_vvt.cpp
View File

@ -22,9 +22,9 @@ public:
static void func(TriggerCallback *callback) { static void func(TriggerCallback *callback) {
int formIndex = callback->toothIndex % callback->form->getSize(); int formIndex = callback->toothIndex % callback->form->getSize();
Engine *engine = callback->engine; Engine *engine = callback->engine;
int value = callback->form->wave->getChannelState(0, formIndex);
int value = callback->form->wave.getChannelState(0, formIndex);
efitick_t nowNt = getTimeNowNt(); efitick_t nowNt = getTimeNowNt();
if (callback->isVvt) { if (callback->isVvt) {
trigger_value_e v = value ? TV_RISE : TV_FALL; trigger_value_e v = value ? TV_RISE : TV_FALL;

8
unit_tests/tests/trigger/test_trigger_decoder.cpp
View File

@ -466,10 +466,10 @@ TEST(misc, testTriggerDecoder) {
s->useOnlyRisingEdgeForTriggerTemp = false; s->useOnlyRisingEdgeForTriggerTemp = false;
initializeSkippedToothTriggerWaveformExt(s, 2, 0, FOUR_STROKE_CAM_SENSOR); initializeSkippedToothTriggerWaveformExt(s, 2, 0, FOUR_STROKE_CAM_SENSOR);
assertEqualsM("shape size", s->getSize(), 4); assertEqualsM("shape size", s->getSize(), 4);
ASSERT_EQ(s->wave->getSwitchTime(0), 0.25); ASSERT_EQ(s->wave.getSwitchTime(0), 0.25);
ASSERT_EQ(s->wave->getSwitchTime(1), 0.5); ASSERT_EQ(s->wave.getSwitchTime(1), 0.5);
ASSERT_EQ(s->wave->getSwitchTime(2), 0.75); ASSERT_EQ(s->wave.getSwitchTime(2), 0.75);
ASSERT_EQ(s->wave->getSwitchTime(3), 1); ASSERT_EQ(s->wave.getSwitchTime(3), 1);
} }