andreika-git
/
rusefi
mirror of https://github.com/andreika-git/rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

All it wants is to use the main trigger state, so don't bother copying it.  Instead, change
PwmConfig to take a const pointer to a Multi.*Sequence, then make all the users adapt.  Worse
fallout is that SimplePwm now has its own Multi.*Sequence, but PwmConfig is downgraded to a
pointer, so that's only a net +4 bytes.  And we can make the overhead of Multi.*Sequence much lower
using embedded arrays, which only the caller can do since it knows the maximum size... (for another
day...)

Also remove SimplePwm's 2nd copy of SingleChannelStateSequence.  It served no purpose.

Saves 1992 bytes of BSS and 24 bytes of RAM4 (latter probably due to SimplePwm change)
This commit is contained in:
Scott Smith 2021-11-09 11:35:07 -08:00 committed by GitHub
parent 1d970dace1
commit 280dfa94e7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 60 additions and 110 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) { void MultiChannelStateSequence::checkSwitchTimes(const int size, const float scale) const {
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); void checkSwitchTimes(const int size, const float scale) const;
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,10 +18,11 @@
// 1% duty cycle // 1% duty cycle
#define ZERO_PWM_THRESHOLD 0.01 #define ZERO_PWM_THRESHOLD 0.01
SimplePwm::SimplePwm() { SimplePwm::SimplePwm()
waveInstance.init(pinStates); : sr(pinStates)
sr[0] = waveInstance; , seq(_switchTimes, &sr)
init(_switchTimes, sr); {
seq.waveCount = 1;
} }
SimplePwm::SimplePwm(const char *name) : SimplePwm() { SimplePwm::SimplePwm(const char *name) : SimplePwm() {
@ -43,14 +44,6 @@ 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
@ -94,7 +87,7 @@ void SimplePwm::setSimplePwmDutyCycle(float dutyCycle) {
mode = PM_FULL; mode = PM_FULL;
} else { } else {
mode = PM_NORMAL; mode = PM_NORMAL;
multiChannelStateSequence.setSwitchTime(0, dutyCycle); _switchTimes[0] = dutyCycle;
} }
} }
@ -105,7 +98,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);
@ -272,21 +265,11 @@ 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, float const *switchTimes, int waveCount, pin_state_t *const *pinStates) { void copyPwmParameters(PwmConfig *state, int phaseCount, MultiChannelStateSequence const * seq) {
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);
} }
} }
@ -296,9 +279,8 @@ void copyPwmParameters(PwmConfig *state, int phaseCount, float const *switchTime
*/ */
void PwmConfig::weComplexInit(const char *msg, ExecutorInterface *executor, void PwmConfig::weComplexInit(const char *msg, ExecutorInterface *executor,
const int phaseCount, const int phaseCount,
float const *switchTimes, MultiChannelStateSequence const * seq,
const int waveCount, pwm_cycle_callback *pwmCycleCallback, pwm_gen_callback *stateChangeCallback) {
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;
@ -312,14 +294,12 @@ 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, waveCount > 0, "waveCount should be positive"); efiAssertVoid(CUSTOM_ERR_6583, seq->waveCount > 0, "waveCount should be positive");
this->pwmCycleCallback = pwmCycleCallback; this->pwmCycleCallback = pwmCycleCallback;
this->stateChangeCallback = stateChangeCallback; this->stateChangeCallback = stateChangeCallback;
multiChannelStateSequence.waveCount = waveCount; copyPwmParameters(this, phaseCount, seq);
copyPwmParameters(this, phaseCount, switchTimes, waveCount, pinStates);
safe.phaseIndex = 0; safe.phaseIndex = 0;
safe.periodNt = -1; safe.periodNt = -1;
@ -338,16 +318,16 @@ void startSimplePwm(SimplePwm *state, const char *msg, ExecutorInterface *execut
return; return;
} }
float switchTimes[] = { dutyCycle, 1 }; state->_switchTimes[0] = dutyCycle;
pin_state_t pinStates0[] = { TV_FALL, TV_RISE }; state->_switchTimes[1] = 1;
state->setSimplePwmDutyCycle(dutyCycle); state->pinStates[0] = TV_FALL;
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->weComplexInit(msg, executor, 2, switchTimes, 1, pinStates, NULL, (pwm_gen_callback*)applyPinState); state->setSimplePwmDutyCycle(dutyCycle); // TODO: DUP ABOVE?
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,
@ -385,7 +365,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);
} }
@ -394,10 +374,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,13 +53,11 @@ 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, float const *switchTimes, const int waveCount, pin_state_t *const*pinStates, const int phaseCount, MultiChannelStateSequence const * seq,
pwm_cycle_callback *pwmCycleCallback, pwm_cycle_callback *pwmCycleCallback,
pwm_gen_callback *callback); pwm_gen_callback *callback);
@ -81,7 +79,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 multiChannelStateSequence; MultiChannelStateSequence const * multiChannelStateSequence = nullptr;
efitick_t togglePwmState(); efitick_t togglePwmState();
void stop(); void stop();
@ -127,12 +125,10 @@ 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[1]; SingleChannelStateSequence sr;
float _switchTimes[2]; float _switchTimes[2];
MultiChannelStateSequence seq;
hardware_pwm* hardPwm = nullptr; hardware_pwm* hardPwm = nullptr;
private:
SingleChannelStateSequence waveInstance;
}; };
/** /**
@ -167,6 +163,5 @@ 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, float const *switchTimes, void copyPwmParameters(PwmConfig *state, int phaseCount, MultiChannelStateSequence const * seq);
int waveCount, pin_state_t *const *pinStates);

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

@ -81,7 +81,6 @@ 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));
@ -96,7 +95,7 @@ void TriggerWaveform::initialize(operation_mode_e operationMode) {
} }
size_t TriggerWaveform::getSize() const { size_t TriggerWaveform::getSize() const {
return privateTriggerDefinitionSize; return wave.waveCount;
} }
int TriggerWaveform::getTriggerWaveformSynchPointIndex() const { int TriggerWaveform::getTriggerWaveformSynchPointIndex() const {
@ -146,9 +145,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, privateTriggerDefinitionSize != 0, "shapeSize=0", NAN); efiAssert(CUSTOM_ERR_ASSERT, wave.waveCount != 0, "shapeSize=0", NAN);
int crankCycle = index / privateTriggerDefinitionSize; int crankCycle = index / wave.waveCount;
int remainder = index % privateTriggerDefinitionSize; int remainder = index % wave.waveCount;
auto cycleStartAngle = getCycleDuration() * crankCycle; auto cycleStartAngle = getCycleDuration() * crankCycle;
auto positionWithinCycle = getSwitchAngle(remainder); auto positionWithinCycle = getSwitchAngle(remainder);
@ -228,9 +227,9 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
#endif #endif
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
assertIsInBounds(privateTriggerDefinitionSize, triggerSignalIndeces, "trigger shape overflow"); assertIsInBounds(wave.waveCount, triggerSignalIndeces, "trigger shape overflow");
triggerSignalIndeces[privateTriggerDefinitionSize] = channelIndex; triggerSignalIndeces[wave.waveCount] = channelIndex;
triggerSignalStates[privateTriggerDefinitionSize] = state; triggerSignalStates[wave.waveCount] = state;
#endif // EFI_UNIT_TEST #endif // EFI_UNIT_TEST
@ -242,21 +241,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 (privateTriggerDefinitionSize > 0) { if (wave.waveCount > 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(),
privateTriggerDefinitionSize); wave.waveCount);
setShapeDefinitionError(true); setShapeDefinitionError(true);
return; return;
} }
} }
previousAngle = angle; previousAngle = angle;
if (privateTriggerDefinitionSize == 0) { if (wave.waveCount == 0) {
privateTriggerDefinitionSize = 1; wave.waveCount = 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];
@ -274,14 +273,14 @@ void TriggerWaveform::addEvent(angle_t angle, trigger_wheel_e const channelIndex
return; return;
} }
int exactMatch = wave.findAngleMatch(angle, privateTriggerDefinitionSize); int exactMatch = wave.findAngleMatch(angle, wave.waveCount);
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, privateTriggerDefinitionSize); int index = wave.findInsertionAngle(angle, wave.waveCount);
/** /**
* 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,11 +297,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 != privateTriggerDefinitionSize) { if ((unsigned)index != wave.waveCount) {
firmwareError(ERROR_TRIGGER_DRAMA, "are we ever here?"); firmwareError(ERROR_TRIGGER_DRAMA, "are we ever here?");
} }
privateTriggerDefinitionSize++; wave.waveCount++;
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,6 +193,13 @@ 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
@ -201,15 +208,6 @@ 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 */
@ -325,4 +323,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(privateTriggerDefinitionSize) #define getTriggerSize() TRIGGER_WAVEFORM(wave.waveCount)

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->privateTriggerDefinitionSize; int triggerShapeLength = shape->getSize();
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,20 +53,7 @@ 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;
@ -119,11 +106,7 @@ static void updateTriggerWaveformIfNeeded(PwmConfig *state DECLARE_ENGINE_PARAME
TriggerWaveform *s = &engine->triggerCentral.triggerShape; TriggerWaveform *s = &engine->triggerCentral.triggerShape;
pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { copyPwmParameters(state, s->getSize(), &s->wave);
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
} }
} }
@ -141,7 +124,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);
} }
@ -161,16 +144,11 @@ 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.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM, phaseCount, &s->wave,
pinStates, updateTriggerWaveformIfNeeded, (pwm_gen_callback*)emulatorApplyPinState); updateTriggerWaveformIfNeeded, (pwm_gen_callback*)emulatorApplyPinState);
hasInitTriggerEmulator = true; hasInitTriggerEmulator = true;
} }