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

Revert "Don't keep a separate MultiChannelStateSequence for the trigger emulator. (#3513)" 

This reverts commit 4e220dc163.
This commit is contained in:
rusefillc 2021-11-09 20:42:02 -05:00
parent 150019b0ed
commit 38ea0d1835
8 changed files with 110 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -53,7 +53,7 @@ float MultiChannelStateSequence::getSwitchTime(const int index) const {
return switchTimes[index]; return switchTimes[index];
} }
void MultiChannelStateSequence::checkSwitchTimes(const int size, const float scale) const { void MultiChannelStateSequence::checkSwitchTimes(const int size, const float scale) {
if (switchTimes[size - 1] != 1) { if (switchTimes[size - 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", scale,
switchTimes[size - 1], scale * switchTimes[size - 1]); switchTimes[size - 1], scale * switchTimes[size - 1]);

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

@ -72,7 +72,7 @@ public:
void reset(void); void reset(void);
float getSwitchTime(const int phaseIndex) const; float getSwitchTime(const int phaseIndex) const;
void setSwitchTime(const int phaseIndex, const float value); void setSwitchTime(const int phaseIndex, const float value);
void checkSwitchTimes(const int size, const float scale) const; void checkSwitchTimes(const int size, const float scale);
pin_state_t getChannelState(const int channelIndex, const int phaseIndex) const; pin_state_t getChannelState(const int channelIndex, const int phaseIndex) const;
int findAngleMatch(const float angle, const int size) const; int findAngleMatch(const float angle, const int size) const;

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

@ -18,11 +18,10 @@
// 1% duty cycle // 1% duty cycle
#define ZERO_PWM_THRESHOLD 0.01 #define ZERO_PWM_THRESHOLD 0.01
SimplePwm::SimplePwm() SimplePwm::SimplePwm() {
: sr(pinStates) waveInstance.init(pinStates);
, seq(_switchTimes, &sr) sr[0] = waveInstance;
{ init(_switchTimes, sr);
seq.waveCount = 1;
} }
SimplePwm::SimplePwm(const char *name) : SimplePwm() { SimplePwm::SimplePwm(const char *name) : SimplePwm() {
@ -44,6 +43,14 @@ PwmConfig::PwmConfig() {
arg = this; arg = this;
} }
PwmConfig::PwmConfig(float *st, SingleChannelStateSequence *waves) : PwmConfig() {
multiChannelStateSequence.init(st, waves);
}
void PwmConfig::init(float *st, SingleChannelStateSequence *waves) {
multiChannelStateSequence.init(st, waves);
}
/** /**
* This method allows you to change duty cycle on the fly * This method allows you to change duty cycle on the fly
* @param dutyCycle value between 0 and 1 * @param dutyCycle value between 0 and 1
@ -87,7 +94,7 @@ void SimplePwm::setSimplePwmDutyCycle(float dutyCycle) {
mode = PM_FULL; mode = PM_FULL;
} else { } else {
mode = PM_NORMAL; mode = PM_NORMAL;
_switchTimes[0] = dutyCycle; multiChannelStateSequence.setSwitchTime(0, dutyCycle);
} }
} }
@ -98,7 +105,7 @@ static efitick_t getNextSwitchTimeNt(PwmConfig *state) {
efiAssert(CUSTOM_ERR_ASSERT, state->safe.phaseIndex < PWM_PHASE_MAX_COUNT, "phaseIndex range", 0); efiAssert(CUSTOM_ERR_ASSERT, state->safe.phaseIndex < PWM_PHASE_MAX_COUNT, "phaseIndex range", 0);
int iteration = state->safe.iteration; int iteration = state->safe.iteration;
// we handle PM_ZERO and PM_FULL separately // we handle PM_ZERO and PM_FULL separately
float switchTime = state->mode == PM_NORMAL ? state->multiChannelStateSequence->getSwitchTime(state->safe.phaseIndex) : 1; float switchTime = state->mode == PM_NORMAL ? state->multiChannelStateSequence.getSwitchTime(state->safe.phaseIndex) : 1;
float periodNt = state->safe.periodNt; float periodNt = state->safe.periodNt;
#if DEBUG_PWM #if DEBUG_PWM
efiPrintf("iteration=%d switchTime=%.2f period=%.2f", iteration, switchTime, period); efiPrintf("iteration=%d switchTime=%.2f period=%.2f", iteration, switchTime, period);
@ -265,11 +272,21 @@ static void timerCallback(PwmConfig *state) {
* Incoming parameters are potentially just values on current stack, so we have to copy * Incoming parameters are potentially just values on current stack, so we have to copy
* into our own permanent storage, right? * into our own permanent storage, right?
*/ */
void copyPwmParameters(PwmConfig *state, int phaseCount, MultiChannelStateSequence const * seq) { void copyPwmParameters(PwmConfig *state, int phaseCount, float const *switchTimes, int waveCount, pin_state_t *const *pinStates) {
state->phaseCount = phaseCount; state->phaseCount = phaseCount;
state->multiChannelStateSequence = seq;
for (int phaseIndex = 0; phaseIndex < phaseCount; phaseIndex++) {
state->multiChannelStateSequence.setSwitchTime(phaseIndex, switchTimes[phaseIndex]);
for (int channelIndex = 0; channelIndex < waveCount; channelIndex++) {
// print("output switch time index (%d/%d) at %.2f to %d\r\n", phaseIndex, channelIndex,
// switchTimes[phaseIndex], pinStates[waveIndex][phaseIndex]);
pin_state_t value = pinStates[channelIndex][phaseIndex];
state->multiChannelStateSequence.channels[channelIndex].setState(phaseIndex, value);
}
}
if (state->mode == PM_NORMAL) { if (state->mode == PM_NORMAL) {
state->multiChannelStateSequence->checkSwitchTimes(phaseCount, 1); state->multiChannelStateSequence.checkSwitchTimes(phaseCount, 1);
} }
} }
@ -279,8 +296,9 @@ void copyPwmParameters(PwmConfig *state, int phaseCount, MultiChannelStateSequen
*/ */
void PwmConfig::weComplexInit(const char *msg, ExecutorInterface *executor, void PwmConfig::weComplexInit(const char *msg, ExecutorInterface *executor,
const int phaseCount, const int phaseCount,
MultiChannelStateSequence const * seq, float const *switchTimes,
pwm_cycle_callback *pwmCycleCallback, pwm_gen_callback *stateChangeCallback) { const int waveCount,
pin_state_t *const*pinStates, pwm_cycle_callback *pwmCycleCallback, pwm_gen_callback *stateChangeCallback) {
UNUSED(msg); UNUSED(msg);
this->executor = executor; this->executor = executor;
isStopRequested = false; isStopRequested = false;
@ -294,12 +312,14 @@ void PwmConfig::weComplexInit(const char *msg, ExecutorInterface *executor,
firmwareError(CUSTOM_ERR_PWM_2, "too many phases in PWM"); firmwareError(CUSTOM_ERR_PWM_2, "too many phases in PWM");
return; return;
} }
efiAssertVoid(CUSTOM_ERR_6583, seq->waveCount > 0, "waveCount should be positive"); efiAssertVoid(CUSTOM_ERR_6583, waveCount > 0, "waveCount should be positive");
this->pwmCycleCallback = pwmCycleCallback; this->pwmCycleCallback = pwmCycleCallback;
this->stateChangeCallback = stateChangeCallback; this->stateChangeCallback = stateChangeCallback;
copyPwmParameters(this, phaseCount, seq); multiChannelStateSequence.waveCount = waveCount;
copyPwmParameters(this, phaseCount, switchTimes, waveCount, pinStates);
safe.phaseIndex = 0; safe.phaseIndex = 0;
safe.periodNt = -1; safe.periodNt = -1;
@ -318,16 +338,16 @@ void startSimplePwm(SimplePwm *state, const char *msg, ExecutorInterface *execut
return; return;
} }
state->_switchTimes[0] = dutyCycle; float switchTimes[] = { dutyCycle, 1 };
state->_switchTimes[1] = 1; pin_state_t pinStates0[] = { TV_FALL, TV_RISE };
state->pinStates[0] = TV_FALL; state->setSimplePwmDutyCycle(dutyCycle);
state->pinStates[1] = TV_RISE;
pin_state_t *pinStates[1] = { pinStates0 };
state->outputPins[0] = output; state->outputPins[0] = output;
state->setFrequency(frequency); state->setFrequency(frequency);
state->setSimplePwmDutyCycle(dutyCycle); // TODO: DUP ABOVE? state->weComplexInit(msg, executor, 2, switchTimes, 1, pinStates, NULL, (pwm_gen_callback*)applyPinState);
state->weComplexInit(msg, executor, 2, &state->seq, NULL, (pwm_gen_callback*)applyPinState);
} }
void startSimplePwmExt(SimplePwm *state, const char *msg, void startSimplePwmExt(SimplePwm *state, const char *msg,
@ -365,7 +385,7 @@ void startSimplePwmHard(SimplePwm *state, const char *msg,
void applyPinState(int stateIndex, PwmConfig *state) /* pwm_gen_callback */ { void applyPinState(int stateIndex, PwmConfig *state) /* pwm_gen_callback */ {
#if EFI_PROD_CODE #if EFI_PROD_CODE
if (!engine->isPwmEnabled) { if (!engine->isPwmEnabled) {
for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence->waveCount; channelIndex++) { for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence.waveCount; channelIndex++) {
OutputPin *output = state->outputPins[channelIndex]; OutputPin *output = state->outputPins[channelIndex];
output->setValue(0); output->setValue(0);
} }
@ -374,10 +394,10 @@ void applyPinState(int stateIndex, PwmConfig *state) /* pwm_gen_callback */ {
#endif // EFI_PROD_CODE #endif // EFI_PROD_CODE
efiAssertVoid(CUSTOM_ERR_6663, stateIndex < PWM_PHASE_MAX_COUNT, "invalid stateIndex"); efiAssertVoid(CUSTOM_ERR_6663, stateIndex < PWM_PHASE_MAX_COUNT, "invalid stateIndex");
efiAssertVoid(CUSTOM_ERR_6664, state->multiChannelStateSequence->waveCount <= PWM_PHASE_MAX_WAVE_PER_PWM, "invalid waveCount"); efiAssertVoid(CUSTOM_ERR_6664, state->multiChannelStateSequence.waveCount <= PWM_PHASE_MAX_WAVE_PER_PWM, "invalid waveCount");
for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence->waveCount; channelIndex++) { for (int channelIndex = 0; channelIndex < state->multiChannelStateSequence.waveCount; channelIndex++) {
OutputPin *output = state->outputPins[channelIndex]; OutputPin *output = state->outputPins[channelIndex];
int value = state->multiChannelStateSequence->getChannelState(channelIndex, stateIndex); int value = state->multiChannelStateSequence.getChannelState(channelIndex, stateIndex);
output->setValue(value); output->setValue(value);
} }
} }

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

@ -53,11 +53,13 @@ typedef enum {
class PwmConfig { class PwmConfig {
public: public:
PwmConfig(); PwmConfig();
PwmConfig(float *switchTimes, SingleChannelStateSequence *waves);
void init(float *switchTimes, SingleChannelStateSequence *waves);
void *arg = nullptr; void *arg = nullptr;
void weComplexInit(const char *msg, void weComplexInit(const char *msg,
ExecutorInterface *executor, ExecutorInterface *executor,
const int phaseCount, MultiChannelStateSequence const * seq, const int phaseCount, float const *switchTimes, const int waveCount, pin_state_t *const*pinStates,
pwm_cycle_callback *pwmCycleCallback, pwm_cycle_callback *pwmCycleCallback,
pwm_gen_callback *callback); pwm_gen_callback *callback);
@ -79,7 +81,7 @@ public:
// todo: 'outputPins' should be extracted away from here since technically one can want PWM scheduler without actual pin output // todo: 'outputPins' should be extracted away from here since technically one can want PWM scheduler without actual pin output
OutputPin *outputPins[PWM_PHASE_MAX_WAVE_PER_PWM]; OutputPin *outputPins[PWM_PHASE_MAX_WAVE_PER_PWM];
MultiChannelStateSequence const * multiChannelStateSequence = nullptr; MultiChannelStateSequence multiChannelStateSequence;
efitick_t togglePwmState(); efitick_t togglePwmState();
void stop(); void stop();
@ -125,10 +127,12 @@ public:
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]; pin_state_t pinStates[2];
SingleChannelStateSequence sr; SingleChannelStateSequence sr[1];
float _switchTimes[2]; float _switchTimes[2];
MultiChannelStateSequence seq;
hardware_pwm* hardPwm = nullptr; hardware_pwm* hardPwm = nullptr;
private:
SingleChannelStateSequence waveInstance;
}; };
/** /**
@ -163,5 +167,6 @@ void startSimplePwmHard(SimplePwm *state, const char *msg,
brain_pin_e brainPin, OutputPin *output, float frequency, brain_pin_e brainPin, OutputPin *output, float frequency,
float dutyCycle); float dutyCycle);
void copyPwmParameters(PwmConfig *state, int phaseCount, MultiChannelStateSequence const * seq); void copyPwmParameters(PwmConfig *state, int phaseCount, float const *switchTimes,
int waveCount, pin_state_t *const *pinStates);

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

@ -81,6 +81,7 @@ void TriggerWaveform::initialize(operation_mode_e operationMode) {
gapBothDirections = false; gapBothDirections = false;
this->operationMode = operationMode; this->operationMode = operationMode;
privateTriggerDefinitionSize = 0;
triggerShapeSynchPointIndex = 0; triggerShapeSynchPointIndex = 0;
memset(initialState, 0, sizeof(initialState)); memset(initialState, 0, sizeof(initialState));
memset(switchTimesBuffer, 0, sizeof(switchTimesBuffer)); memset(switchTimesBuffer, 0, sizeof(switchTimesBuffer));
@ -95,7 +96,7 @@ void TriggerWaveform::initialize(operation_mode_e operationMode) {
} }
size_t TriggerWaveform::getSize() const { size_t TriggerWaveform::getSize() const {
return wave.waveCount; return privateTriggerDefinitionSize;
} }
int TriggerWaveform::getTriggerWaveformSynchPointIndex() const { int TriggerWaveform::getTriggerWaveformSynchPointIndex() const {
@ -145,9 +146,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.waveCount != 0, "shapeSize=0", NAN); efiAssert(CUSTOM_ERR_ASSERT, privateTriggerDefinitionSize != 0, "shapeSize=0", NAN);
int crankCycle = index / wave.waveCount; int crankCycle = index / privateTriggerDefinitionSize;
int remainder = index % wave.waveCount; int remainder = index % privateTriggerDefinitionSize;
auto cycleStartAngle = getCycleDuration() * crankCycle; auto cycleStartAngle = getCycleDuration() * crankCycle;
auto positionWithinCycle = getSwitchAngle(remainder); auto positionWithinCycle = getSwitchAngle(remainder);
@ -227,9 +228,9 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
#endif #endif
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
assertIsInBounds(wave.waveCount, triggerSignalIndeces, "trigger shape overflow"); assertIsInBounds(privateTriggerDefinitionSize, triggerSignalIndeces, "trigger shape overflow");
triggerSignalIndeces[wave.waveCount] = channelIndex; triggerSignalIndeces[privateTriggerDefinitionSize] = channelIndex;
triggerSignalStates[wave.waveCount] = state; triggerSignalStates[privateTriggerDefinitionSize] = state;
#endif // EFI_UNIT_TEST #endif // EFI_UNIT_TEST
@ -241,21 +242,21 @@ 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.waveCount > 0) { if (privateTriggerDefinitionSize > 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.waveCount); privateTriggerDefinitionSize);
setShapeDefinitionError(true); setShapeDefinitionError(true);
return; return;
} }
} }
previousAngle = angle; previousAngle = angle;
if (wave.waveCount == 0) { if (privateTriggerDefinitionSize == 0) {
wave.waveCount = 1; privateTriggerDefinitionSize = 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 *wave = &this->wave.channels[i]; SingleChannelStateSequence *wave = &this->wave.channels[i];
@ -273,14 +274,14 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
return; return;
} }
int exactMatch = wave.findAngleMatch(angle, wave.waveCount); int exactMatch = wave.findAngleMatch(angle, privateTriggerDefinitionSize);
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, wave.waveCount); int index = wave.findInsertionAngle(angle, privateTriggerDefinitionSize);
/** /**
* 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
@ -297,11 +298,11 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
*/ */
isRiseEvent[index] = TV_RISE == state; isRiseEvent[index] = TV_RISE == state;
if ((unsigned)index != wave.waveCount) { if ((unsigned)index != privateTriggerDefinitionSize) {
firmwareError(ERROR_TRIGGER_DRAMA, "are we ever here?"); firmwareError(ERROR_TRIGGER_DRAMA, "are we ever here?");
} }
wave.waveCount++; privateTriggerDefinitionSize++;
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);

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

@ -193,13 +193,6 @@ public:
int triggerSignalStates[PWM_PHASE_MAX_COUNT]; int triggerSignalStates[PWM_PHASE_MAX_COUNT];
#endif #endif
/**
* waveCount member is total count of shaft events per CAM or CRANK shaft revolution.
* TODO this should be migrated to CRANKshaft revolution, this would go together
* this variable is public for performance reasons (I want to avoid costs of method if it's not inlined)
* 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
*/
MultiChannelStateSequence wave; MultiChannelStateSequence 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
@ -208,6 +201,15 @@ public:
bool isRiseEvent[PWM_PHASE_MAX_COUNT]; bool isRiseEvent[PWM_PHASE_MAX_COUNT];
/**
* Total count of shaft events per CAM or CRANK shaft revolution.
* TODO this should be migrated to CRANKshaft revolution, this would go together
* this variable is public for performance reasons (I want to avoid costs of method if it's not inlined)
* 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
*/
unsigned int privateTriggerDefinitionSize;
bool useOnlyRisingEdgeForTriggerTemp; bool useOnlyRisingEdgeForTriggerTemp;
/* (0..1] angle range */ /* (0..1] angle range */
@ -323,4 +325,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.waveCount) #define getTriggerSize() TRIGGER_WAVEFORM(privateTriggerDefinitionSize)

2
firmware/controllers/trigger/trigger_decoder.cpp
View File

@ -168,7 +168,7 @@ void prepareEventAngles(TriggerWaveform *shape,
memset(details->eventAngles, 0, sizeof(details->eventAngles)); memset(details->eventAngles, 0, sizeof(details->eventAngles));
// this may be <length for some triggers like symmetrical crank Miata NB // this may be <length for some triggers like symmetrical crank Miata NB
int triggerShapeLength = shape->getSize(); int triggerShapeLength = shape->privateTriggerDefinitionSize;
assertAngleRange(shape->triggerShapeSynchPointIndex, "triggerShapeSynchPointIndex", CUSTOM_TRIGGER_SYNC_ANGLE2); assertAngleRange(shape->triggerShapeSynchPointIndex, "triggerShapeSynchPointIndex", CUSTOM_TRIGGER_SYNC_ANGLE2);
efiAssertVoid(CUSTOM_TRIGGER_CYCLE, engine->engineCycleEventCount != 0, "zero engineCycleEventCount"); efiAssertVoid(CUSTOM_TRIGGER_CYCLE, engine->engineCycleEventCount != 0, "zero engineCycleEventCount");

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

@ -53,7 +53,20 @@ void TriggerEmulatorHelper::handleEmulatorCallback(const int size, const MultiCh
} }
} }
PwmConfig triggerSignal; /*
* todo: should we simply re-use instances used by trigger_decoder?
* todo: since we are emulating same shape we are decoding
*/
static pin_state_t pinStates1[PWM_PHASE_MAX_COUNT];
static pin_state_t pinStates2[PWM_PHASE_MAX_COUNT];
static pin_state_t pinStates3[PWM_PHASE_MAX_COUNT];
static SingleChannelStateSequence waves[PWM_PHASE_MAX_WAVE_PER_PWM] = { SingleChannelStateSequence(pinStates1), SingleChannelStateSequence(pinStates2),
SingleChannelStateSequence(pinStates3) };
static SingleChannelStateSequence sr[PWM_PHASE_MAX_WAVE_PER_PWM] = { waves[0], waves[1], waves[2] };
static float pwmSwitchTimesBuffer[PWM_PHASE_MAX_COUNT];
PwmConfig triggerSignal(pwmSwitchTimesBuffer, sr);
static int atTriggerVersion = 0; static int atTriggerVersion = 0;
@ -106,7 +119,11 @@ static void updateTriggerWaveformIfNeeded(PwmConfig *state DECLARE_ENGINE_PARAME
TriggerWaveform *s = &engine->triggerCentral.triggerShape; TriggerWaveform *s = &engine->triggerCentral.triggerShape;
copyPwmParameters(state, s->getSize(), &s->wave); pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = {
s->wave.channels[0].pinStates,
s->wave.channels[1].pinStates,
s->wave.channels[2].pinStates };
copyPwmParameters(state, s->getSize(), s->wave.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM, pinStates);
state->safe.periodNt = -1; // this would cause loop re-initialization state->safe.periodNt = -1; // this would cause loop re-initialization
} }
} }
@ -124,7 +141,7 @@ static void emulatorApplyPinState(int stateIndex, PwmConfig *state) /* pwm_gen_c
* this callback would invoke the input signal handlers directly * this callback would invoke the input signal handlers directly
*/ */
helper.handleEmulatorCallback(state->phaseCount, helper.handleEmulatorCallback(state->phaseCount,
*state->multiChannelStateSequence, state->multiChannelStateSequence,
stateIndex); stateIndex);
} }
@ -144,11 +161,16 @@ static void initTriggerPwm(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
TriggerWaveform *s = &engine->triggerCentral.triggerShape; TriggerWaveform *s = &engine->triggerCentral.triggerShape;
setTriggerEmulatorRPM(engineConfiguration->triggerSimulatorFrequency PASS_ENGINE_PARAMETER_SUFFIX); setTriggerEmulatorRPM(engineConfiguration->triggerSimulatorFrequency PASS_ENGINE_PARAMETER_SUFFIX);
pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = {
s->wave.channels[0].pinStates,
s->wave.channels[1].pinStates,
s->wave.channels[2].pinStates };
int phaseCount = s->getSize(); int phaseCount = s->getSize();
assertIsInBounds(phaseCount - 1, pwmSwitchTimesBuffer, "pwmSwitchTimesBuffer");
triggerSignal.weComplexInit("position sensor", triggerSignal.weComplexInit("position sensor",
&engine->executor, &engine->executor,
phaseCount, &s->wave, phaseCount, s->wave.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM,
updateTriggerWaveformIfNeeded, (pwm_gen_callback*)emulatorApplyPinState); pinStates, updateTriggerWaveformIfNeeded, (pwm_gen_callback*)emulatorApplyPinState);
hasInitTriggerEmulator = true; hasInitTriggerEmulator = true;
} }