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

rename Executor -> Scheduler

This commit is contained in:
Matthew Kennedy 2024-07-11 20:03:13 -04:00 committed by rusefillc
parent 6d34aff938
commit b9292dbb33
47 changed files with 184 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
firmware/console/binary/trigger_scope.cpp
View File

@ -94,7 +94,7 @@ const BigBufferHandle& triggerScopeGetBuffer() {
// Start the next sample once we've read out this one
if (isRunning) {
engine->executor.scheduleByTimestampNt("trigger scope", &restartTimer, getTimeNowNt() + MS2NT(10), startSampling);
engine->scheduler.schedule("trigger scope", &restartTimer, getTimeNowNt() + MS2NT(10), startSampling);
}
return buffer;

2
firmware/controllers/actuators/alternator_controller.cpp
View File

@ -122,7 +122,7 @@ void initAlternatorCtrl() {
startSimplePwm(&alternatorControl,
"Alternator control",
&engine->executor,
&engine->scheduler,
&enginePins.alternatorPin,
engineConfiguration->alternatorPwmFrequency, 0);
}

2
firmware/controllers/actuators/boost_control.cpp
View File

@ -324,7 +324,7 @@ void startBoostPin() {
startSimplePwm(
&boostPwmControl,
"Boost",
&engine->executor,
&engine->scheduler,
&enginePins.boostPin,
engineConfiguration->boostPwmFrequency,
/*dutyCycle*/0

6
firmware/controllers/actuators/dc_motors.cpp
View File

@ -16,7 +16,7 @@
const char *disPinMsg,
brain_pin_e pinDisable,
bool isInverted,
ExecutorInterface* executor,
Scheduler* executor,
int frequency) {
if (isStarted) {
@ -99,7 +99,7 @@ DcMotor* initDcMotor(const char *disPinMsg,const dc_io& io, size_t index, bool u
io.disablePin,
// todo You would not believe how you invert TLE9201 #4579
engineConfiguration->stepperDcInvertedPins,
&engine->executor,
&engine->scheduler,
engineConfiguration->etbFreq
);
@ -117,7 +117,7 @@ DcMotor* initDcMotor(brain_pin_e coil_p, brain_pin_e coil_m, size_t index) {
nullptr,
Gpio::Unassigned, /* pinDisable */
engineConfiguration->stepperDcInvertedPins,
&engine->executor,
&engine->scheduler,
engineConfiguration->etbFreq /* same in case of stepper? */
);

2
firmware/controllers/actuators/dc_motors.h
View File

@ -57,7 +57,7 @@ public:
const char *disPinMsg,
brain_pin_e pinDisable,
bool isInverted,
ExecutorInterface* executor,
Scheduler* executor,
int frequency);
TwoPinDcMotor dcMotor;

2
firmware/controllers/actuators/gppwm/gppwm.cpp
View File

@ -44,7 +44,7 @@ void initGpPwm() {
// Setup pin & pwm
pins[i].initPin("gp pwm", cfg.pin);
if (usePwm) {
startSimplePwm(&outputs[i], channelNames[i], &engine->executor, &pins[i], freq, 0);
startSimplePwm(&outputs[i], channelNames[i], &engine->scheduler, &pins[i], freq, 0);
}
// Set up this channel's lookup table

4
firmware/controllers/actuators/idle_hardware.cpp
View File

@ -150,7 +150,7 @@ void initIdleHardware() {
*/
// todo: even for double-solenoid mode we can probably use same single SimplePWM
startSimplePwm(&idleSolenoidOpen, "Idle Valve Open",
&engine->executor,
&engine->scheduler,
&enginePins.idleSolenoidPin,
engineConfiguration->idle.solenoidFrequency, PERCENT_TO_DUTY(engineConfiguration->manIdlePosition));
@ -161,7 +161,7 @@ void initIdleHardware() {
}
startSimplePwm(&idleSolenoidClose, "Idle Valve Close",
&engine->executor,
&engine->scheduler,
&enginePins.secondIdleSolenoidPin,
engineConfiguration->idle.solenoidFrequency, PERCENT_TO_DUTY(engineConfiguration->manIdlePosition));
}

2
firmware/controllers/actuators/vvt.cpp
View File

@ -160,7 +160,7 @@ static void turnVvtPidOn(int index) {
}
startSimplePwmExt(&vvtPwms[index], vvtOutputNames[index],
&engine->executor,
&engine->scheduler,
engineConfiguration->vvtPins[index],
getVvtOutputPin(index),
engineConfiguration->vvtOutputFrequency, 0.1,

4
firmware/controllers/algo/engine.cpp
View File

@ -601,8 +601,8 @@ TunerStudioOutputChannels *getTunerStudioOutputChannels() {
return &engine->outputChannels;
}
ExecutorInterface *getExecutorInterface() {
return &engine->executor;
Scheduler *getScheduler() {
return &engine->scheduler;
}
#if EFI_SHAFT_POSITION_INPUT

6
firmware/controllers/algo/engine.h
View File

@ -237,14 +237,14 @@ public:
// cost to resolve pointer, we use instances as a micro optimization
#if EFI_SIGNAL_EXECUTOR_ONE_TIMER
// while theoretically PROD could be using EFI_SIGNAL_EXECUTOR_SLEEP, as of 2024 all PROD uses SingleTimerExecutor
SingleTimerExecutor executor;
SingleTimerExecutor scheduler;
#endif
#if EFI_SIGNAL_EXECUTOR_SLEEP
// at the moment this one is used exclusively by x86 simulator it should theoretically be possible to make it available in embedded if needed
SleepExecutor executor;
SleepExecutor scheduler;
#endif
#if EFI_UNIT_TEST
TestExecutor executor;
TestExecutor scheduler;
std::function<void(IgnitionEvent*, bool)> onIgnitionEvent;
std::function<void(const IgnitionEvent&, efitick_t, angle_t, efitick_t)> onScheduleTurnSparkPinHighStartCharging

4
firmware/controllers/bench_test.cpp
View File

@ -112,8 +112,8 @@ static void runBench(OutputPin *output, float onTimeMs, float offTimeMs, int cou
efitick_t endTime = startTime + US2NT(onTimeUs);
// Schedule both events
engine->executor.scheduleByTimestampNt("bstart", &benchSchedStart, startTime, {(swapOnOff ? benchOff : benchOn), output});
engine->executor.scheduleByTimestampNt("bend", &benchSchedEnd, endTime, {(swapOnOff ? benchOn : benchOff), output});
engine->scheduler.schedule("bstart", &benchSchedStart, startTime, {(swapOnOff ? benchOff : benchOn), output});
engine->scheduler.schedule("bend", &benchSchedEnd, endTime, {(swapOnOff ? benchOn : benchOff), output});
// Wait one full cycle time for the event + delay to happen
chThdSleepMicroseconds(onTimeUs + offTimeUs);

4
firmware/controllers/engine_cycle/main_trigger_callback.cpp
View File

@ -189,12 +189,12 @@ void InjectionEvent::onTriggerTooth(efitick_t nowNt, float currentPhase, float n
// Schedule closing stage 1
efitick_t turnOffTimeStage1 = startTime + US2NT((int)durationUsStage1);
getExecutorInterface()->scheduleByTimestampNt("inj", nullptr, turnOffTimeStage1, endActionStage1);
getScheduler()->schedule("inj", nullptr, turnOffTimeStage1, endActionStage1);
// Schedule closing stage 2 (if applicable)
if (hasStage2Injection && endActionStage2) {
efitick_t turnOffTimeStage2 = startTime + US2NT((int)durationUsStage2);
getExecutorInterface()->scheduleByTimestampNt("inj stage 2", nullptr, turnOffTimeStage2, endActionStage2);
getScheduler()->schedule("inj stage 2", nullptr, turnOffTimeStage2, endActionStage2);
}
#if EFI_DEFAILED_LOGGING

4
firmware/controllers/engine_cycle/prime_injection.cpp
View File

@ -67,7 +67,7 @@ void PrimeController::onIgnitionStateChanged(bool ignitionOn) {
int32_t primeDelayNt = assertFloatFitsInto32BitsAndCast("primingDelay", MSF2NT(engineConfiguration->primingDelay * 1000 + minimumPrimeDelayMs));
auto startTime = getTimeNowNt() + primeDelayNt;
getExecutorInterface()->scheduleByTimestampNt("primingDelay", nullptr, startTime, { PrimeController::onPrimeStartAdapter, this });
getScheduler()->schedule("primingDelay", nullptr, startTime, { PrimeController::onPrimeStartAdapter, this });
} else {
efiPrintf("Skipped priming pulse since ignSwitchCounter = %lu", ignSwitchCounter);
}
@ -112,7 +112,7 @@ void PrimeController::onPrimeStart() {
// Open all injectors, schedule closing later
m_isPriming = true;
startSimultaneousInjection();
getExecutorInterface()->scheduleByTimestampNt("onPrimeStart", nullptr, endTime, { onPrimeEndAdapter, this });
getScheduler()->schedule("onPrimeStart", nullptr, endTime, { onPrimeEndAdapter, this });
}
void PrimeController::onPrimeEnd() {

2
firmware/controllers/engine_cycle/rpm_calculator.cpp
View File

@ -398,7 +398,7 @@ efitick_t scheduleByAngle(scheduling_s *timer, efitick_t nowNt, angle_t angle,
efitick_t actionTimeNt = sumTickAndFloat(nowNt, USF2NT(delayUs));
engine->executor.scheduleByTimestampNt("angle", timer, actionTimeNt, action);
engine->scheduler.schedule("angle", timer, actionTimeNt, action);
return actionTimeNt;
}

6
firmware/controllers/engine_cycle/spark_logic.cpp
View File

@ -264,8 +264,8 @@ if (engineConfiguration->debugMode == DBG_DWELL_METRIC) {
#endif /* SPARK_EXTREME_LOGGING */
// We can schedule both of these right away, since we're going for "asap" not "particular angle"
engine->executor.scheduleByTimestampNt("dwell", &event->dwellStartTimer, nextDwellStart, { &turnSparkPinHighStartCharging, event });
engine->executor.scheduleByTimestampNt("firing", &event->sparkEvent.eventScheduling, nextFiring, { fireSparkAndPrepareNextSchedule, event });
engine->scheduler.schedule("dwell", &event->dwellStartTimer, nextDwellStart, { &turnSparkPinHighStartCharging, event });
engine->scheduler.schedule("firing", &event->sparkEvent.eventScheduling, nextFiring, { fireSparkAndPrepareNextSchedule, event });
} else {
if (engineConfiguration->enableTrailingSparks) {
#if SPARK_EXTREME_LOGGING
@ -466,7 +466,7 @@ static void scheduleSparkEvent(bool limitedSpark, IgnitionEvent *event,
* and it looks like current (smart?) re-queuing is effectively cancelling out the overdwell? is that the way this was intended to work?
* [tag:overdwell]
*/
engine->executor.scheduleByTimestampNt("overdwell", &event->sparkEvent.eventScheduling, fireTime, { overFireSparkAndPrepareNextSchedule, event });
engine->scheduler.schedule("overdwell", &event->sparkEvent.eventScheduling, fireTime, { overFireSparkAndPrepareNextSchedule, event });
#if EFI_UNIT_TEST
engine->onScheduleOverFireSparkAndPrepareNextSchedule(*event, fireTime);

2
firmware/controllers/gauges/speedometer.cpp
View File

@ -31,7 +31,7 @@ void initSpeedometer() {
startSimplePwm(&speedoPwm,
"Speedometer",
&engine->executor,
&engine->scheduler,
&enginePins.speedoOut,
NAN, 0.5f);

2
firmware/controllers/gauges/tachometer.cpp
View File

@ -73,7 +73,7 @@ void initTachometer() {
startSimplePwm(&tachControl,
"Tachometer",
&engine->executor,
&engine->scheduler,
&enginePins.tachOut,
NAN, 0.1f);

2
firmware/controllers/lua/lua_hooks.cpp
View File

@ -277,7 +277,7 @@ void startPwm(int index, float freq, float duty) {
brain_pin_e pwmPin = engineConfiguration->luaOutputPins[index];
startSimplePwmExt(
&pwms[index], "lua", &engine->executor,
&pwms[index], "lua", &engine->scheduler,
pwmPin, &enginePins.luaOutputPins[index],
freq, duty
);

2
firmware/controllers/sensors/vr_pwm.cpp
View File

@ -45,7 +45,7 @@ void initVrThresholdPwm() {
}
startSimplePwmHard(&pwms[i], "VR Threshold",
&engine->executor,
&engine->scheduler,
cfg.pin,
&pins[i],
10000, // it's guaranteed to be hardware PWM, the faster the PWM, the less noise makes it through

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

@ -268,7 +268,7 @@ static void timerCallback(PwmConfig *state) {
return;
}
state->m_executor->scheduleByTimestampNt(state->m_name, &state->scheduling, switchTimeNt, { timerCallback, state });
state->m_executor->schedule(state->m_name, &state->scheduling, switchTimeNt, { timerCallback, state });
state->dbgNestingLevel--;
}
@ -287,7 +287,7 @@ void copyPwmParameters(PwmConfig *state, MultiChannelStateSequence const * seq)
* this method also starts the timer cycle
* See also startSimplePwm
*/
void PwmConfig::weComplexInit(ExecutorInterface *executor,
void PwmConfig::weComplexInit(Scheduler *executor,
MultiChannelStateSequence const * seq,
pwm_cycle_callback *pwmCycleCallback, pwm_gen_callback *stateChangeCallback) {
m_executor = executor;
@ -313,7 +313,7 @@ void PwmConfig::weComplexInit(ExecutorInterface *executor,
}
void startSimplePwm(SimplePwm *state, const char *msg,
ExecutorInterface *executor,
Scheduler *executor,
OutputPin *output, float frequency, float dutyCycle, pwm_gen_callback *callback) {
efiAssertVoid(ObdCode::CUSTOM_ERR_PWM_STATE_ASSERT, state != NULL, "state");
efiAssertVoid(ObdCode::CUSTOM_ERR_PWM_DUTY_ASSERT, dutyCycle >= 0 && dutyCycle <= PWM_MAX_DUTY, "dutyCycle");
@ -325,7 +325,7 @@ void startSimplePwm(SimplePwm *state, const char *msg,
#if EFI_PROD_CODE
#if (BOARD_EXT_GPIOCHIPS > 0)
if (!callback) {
/* No specific executor, we can try enabling HW PWM */
/* No specific scheduler, we can try enabling HW PWM */
if (brain_pin_is_ext(output->brainPin)) {
/* this pin is driven by external gpio chip, let's see if it can PWM */
state->hardPwm = gpiochip_tryInitPwm(msg, output->brainPin, frequency, dutyCycle);
@ -359,7 +359,7 @@ void startSimplePwm(SimplePwm *state, const char *msg,
}
void startSimplePwmExt(SimplePwm *state, const char *msg,
ExecutorInterface *executor,
Scheduler *executor,
brain_pin_e brainPin, OutputPin *output, float frequency,
float dutyCycle, pwm_gen_callback *callback) {
@ -372,7 +372,7 @@ void startSimplePwmExt(SimplePwm *state, const char *msg,
* @param dutyCycle value between 0 and 1
*/
void startSimplePwmHard(SimplePwm *state, const char *msg,
ExecutorInterface *executor,
Scheduler *executor,
brain_pin_e brainPin, OutputPin *output, float frequency,
float dutyCycle) {
#if EFI_PROD_CODE && HAL_USE_PWM

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

@ -52,12 +52,12 @@ public:
PwmConfig();
void weComplexInit(
ExecutorInterface *executor,
Scheduler *executor,
MultiChannelStateSequence const * seq,
pwm_cycle_callback *pwmCycleCallback,
pwm_gen_callback *callback);
ExecutorInterface *m_executor = nullptr;
Scheduler *m_executor = nullptr;
/**
* We need to handle zero duty cycle and 100% duty cycle in a special way
@ -135,7 +135,7 @@ void applyPinState(int stateIndex, PwmConfig* state) /* pwm_gen_callback */;
* This method should be called after scheduling layer is started by initSignalExecutor()
*/
void startSimplePwm(SimplePwm *state, const char *msg,
ExecutorInterface *executor,
Scheduler *executor,
OutputPin *output,
float frequency, float dutyCycle, pwm_gen_callback *callback = NULL);
@ -146,12 +146,12 @@ void startSimplePwm(SimplePwm *state, const char *msg,
*/
void startSimplePwmExt(SimplePwm *state,
const char *msg,
ExecutorInterface *executor,
Scheduler *executor,
brain_pin_e brainPin, OutputPin *output,
float frequency, float dutyCycle, pwm_gen_callback *callback = NULL);
void startSimplePwmHard(SimplePwm *state, const char *msg,
ExecutorInterface *executor,
Scheduler *executor,
brain_pin_e brainPin, OutputPin *output, float frequency,
float dutyCycle);

6
firmware/controllers/system/timer/scheduler.h
View File

@ -90,7 +90,7 @@ private:
};
#pragma pack(pop)
struct ExecutorInterface {
struct Scheduler {
/**
* @brief Schedule an action to be executed in the future.
*
@ -102,7 +102,7 @@ struct ExecutorInterface {
* very near future, it may execute immediately.
* @param action An action to execute at the specified time.
*/
virtual void scheduleByTimestampNt(const char *msg, scheduling_s *scheduling, efitick_t targetTime, action_s action) = 0;
virtual void schedule(const char *msg, scheduling_s *scheduling, efitick_t targetTime, action_s action) = 0;
/**
* @brief Cancel the specified scheduling_s so that, if currently scheduled, it does not execute.
@ -112,5 +112,5 @@ struct ExecutorInterface {
virtual void cancel(scheduling_s* scheduling) = 0;
};
ExecutorInterface *getExecutorInterface();
Scheduler *getScheduler();

16
firmware/controllers/system/timer/single_timer_executor.cpp
View File

@ -36,7 +36,7 @@ uint32_t hwSetTimerDuration;
void globalTimerCallback() {
efiAssertVoid(ObdCode::CUSTOM_ERR_6624, hasLotsOfRemainingStack(), "lowstck#2y");
___engine.executor.onTimerCallback();
___engine.scheduler.onTimerCallback();
}
SingleTimerExecutor::SingleTimerExecutor()
@ -45,7 +45,7 @@ SingleTimerExecutor::SingleTimerExecutor()
{
}
void SingleTimerExecutor::scheduleByTimestampNt(const char *msg, scheduling_s* scheduling, efitick_t nt, action_s action) {
void SingleTimerExecutor::schedule(const char *msg, scheduling_s* scheduling, efitick_t nt, action_s action) {
ScopePerf perf(PE::SingleTimerExecutorScheduleByTimestamp);
#if EFI_ENABLE_ASSERTS
@ -54,7 +54,7 @@ void SingleTimerExecutor::scheduleByTimestampNt(const char *msg, scheduling_s* s
if (deltaTimeNt >= TOO_FAR_INTO_FUTURE_NT) {
// we are trying to set callback for too far into the future. This does not look right at all
int32_t intDeltaTimeNt = (int32_t)deltaTimeNt;
firmwareError(ObdCode::CUSTOM_ERR_TASK_TIMER_OVERFLOW, "scheduleByTimestampNt() too far: %ld %s", intDeltaTimeNt, msg);
firmwareError(ObdCode::CUSTOM_ERR_TASK_TIMER_OVERFLOW, "schedule() too far: %ld %s", intDeltaTimeNt, msg);
return;
}
#endif
@ -161,11 +161,11 @@ void initSingleTimerExecutorHardware() {
void executorStatistics() {
if (engineConfiguration->debugMode == DBG_EXECUTOR) {
#if EFI_TUNER_STUDIO
engine->outputChannels.debugIntField1 = ___engine.executor.timerCallbackCounter;
engine->outputChannels.debugIntField2 = ___engine.executor.executeAllPendingActionsInvocationCounter;
engine->outputChannels.debugIntField3 = ___engine.executor.scheduleCounter;
engine->outputChannels.debugIntField4 = ___engine.executor.executeCounter;
engine->outputChannels.debugIntField5 = ___engine.executor.maxExecuteCounter;
engine->outputChannels.debugIntField1 = ___engine.scheduler.timerCallbackCounter;
engine->outputChannels.debugIntField2 = ___engine.scheduler.executeAllPendingActionsInvocationCounter;
engine->outputChannels.debugIntField3 = ___engine.scheduler.scheduleCounter;
engine->outputChannels.debugIntField4 = ___engine.scheduler.executeCounter;
engine->outputChannels.debugIntField5 = ___engine.scheduler.maxExecuteCounter;
#endif /* EFI_TUNER_STUDIO */
}
}

4
firmware/controllers/system/timer/single_timer_executor.h
View File

@ -10,10 +10,10 @@
#include "scheduler.h"
#include "event_queue.h"
class SingleTimerExecutor final : public ExecutorInterface {
class SingleTimerExecutor final : public Scheduler {
public:
SingleTimerExecutor();
void scheduleByTimestampNt(const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action) override;
void schedule(const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action) override;
void cancel(scheduling_s* scheduling) override;
void onTimerCallback();

4
firmware/controllers/system/timer/trigger_scheduler.cpp
View File

@ -16,7 +16,7 @@ bool TriggerScheduler::assertNotInList(AngleBasedEvent *head, AngleBasedEvent *e
/**
* for example, this might happen in case of sudden RPM change if event
* was not scheduled by angle but was scheduled by time. In case of scheduling
* by time with slow RPM the whole next fast revolution might be within the wait
* by time with slow RPM the whole next fast revolution might be within the wait
*/
warning(ObdCode::CUSTOM_RE_ADDING_INTO_EXECUTION_QUEUE, "re-adding element into event_queue");
return true;
@ -129,7 +129,7 @@ void TriggerScheduler::scheduleEventsUntilNextTriggerTooth(int rpm,
// In case this event was scheduled by overdwell protection, cancel it so
// we can re-schedule at the correct time
// [tag:overdwell]
engine->executor.cancel(sDown);
engine->scheduler.cancel(sDown);
scheduleByAngle(
sDown,

2
firmware/controllers/tcu/tc_4.cpp
View File

@ -14,7 +14,7 @@ void Generic4TransmissionController::init() {
enginePins.tcuPcSolenoid.initPin("Pressure Control Solenoid", engineConfiguration->tcu_pc_solenoid_pin, engineConfiguration->tcu_pc_solenoid_pin_mode);
startSimplePwm(&pcPwm,
"Line Pressure",
&engine->executor,
&engine->scheduler,
&enginePins.tcuPcSolenoid,
engineConfiguration->tcu_pc_solenoid_freq,
0);

6
firmware/controllers/tcu/tc_4l6x.cpp
View File

@ -9,11 +9,11 @@ static SimplePwm shift32Pwm("3-2 Shift Control");
void Gm4l6xTransmissionController::init() {
Generic4TransmissionController::init();
enginePins.tcuTccPwmSolenoid.initPin("TCC PWM Solenoid", engineConfiguration->tcu_tcc_pwm_solenoid, engineConfiguration->tcu_tcc_pwm_solenoid_mode);
startSimplePwm(&tccPwm,
"TCC",
&engine->executor,
&engine->scheduler,
&enginePins.tcuTccPwmSolenoid,
engineConfiguration->tcu_tcc_pwm_solenoid_freq,
0);
@ -21,7 +21,7 @@ void Gm4l6xTransmissionController::init() {
enginePins.tcu32Solenoid.initPin("3-2 Shift Solenoid", engineConfiguration->tcu_32_solenoid_pin, engineConfiguration->tcu_32_solenoid_pin_mode);
startSimplePwm(&shift32Pwm,
"3-2 Solenoid",
&engine->executor,
&engine->scheduler,
&enginePins.tcu32Solenoid,
engineConfiguration->tcu_32_solenoid_freq,
0);

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

@ -234,7 +234,7 @@ static void logVvtFront(bool useOnlyRise, bool isImportantFront, TriggerValue fr
#if EFI_PROD_CODE
writePad("cam debug", engineConfiguration->camInputsDebug[index], 1);
#endif /* EFI_PROD_CODE */
getExecutorInterface()->scheduleByTimestampNt("dbg_on", &debugToggleScheduling, nowNt + DEBUG_PIN_DELAY, &turnOffAllDebugFields);
getScheduler()->schedule("dbg_on", &debugToggleScheduling, nowNt + DEBUG_PIN_DELAY, &turnOffAllDebugFields);
}
if (!useOnlyRise || engineConfiguration->displayLogicLevelsInEngineSniffer) {
@ -536,7 +536,7 @@ void handleShaftSignal(int signalIndex, bool isRising, efitick_t timestamp) {
#if EFI_PROD_CODE
writePad("trigger debug", engineConfiguration->triggerInputDebugPins[signalIndex], 1);
#endif /* EFI_PROD_CODE */
getExecutorInterface()->scheduleByTimestampNt("dbg_off", &debugToggleScheduling, timestamp + DEBUG_PIN_DELAY, &turnOffAllDebugFields);
getScheduler()->schedule("dbg_off", &debugToggleScheduling, timestamp + DEBUG_PIN_DELAY, &turnOffAllDebugFields);
}
#if EFI_TOOTH_LOGGER

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

@ -182,7 +182,7 @@ static void startSimulatedTriggerSignal() {
if (s->getSize() == 0)
continue;
triggerEmulatorSignals[channel].weComplexInit(
&engine->executor,
&engine->scheduler,
&s->wave,
updateTriggerWaveformIfNeeded, emulatorApplyPinState);
}

4
firmware/hw_layer/microsecond_timer/microsecond_timer.cpp
View File

@ -129,7 +129,7 @@ static void watchDogBuddyCallback(void*) {
* watchdog happy by ensuring that we have scheduler activity even in case of very broken configuration
* without any PWM or input pins
*/
engine->executor.scheduleByTimestampNt("watch", &watchDogBuddy, getTimeNowNt() + MS2NT(1000), watchDogBuddyCallback);
engine->scheduler.schedule("watch", &watchDogBuddy, getTimeNowNt() + MS2NT(1000), watchDogBuddyCallback);
}
static volatile bool testSchedulingHappened = false;
@ -155,7 +155,7 @@ static void validateHardwareTimer() {
testScheduling.reset();
// to save RAM let's use 'watchDogBuddy' here once before we enable watchdog
engine->executor.scheduleByTimestampNt(
engine->scheduler.schedule(
"hw-validate",
&watchDogBuddy,
getTimeNowNt() + MS2NT(TEST_CALLBACK_DELAY_MS),

2
simulator/simulator/system/signal_executor_sleep.cpp
View File

@ -38,7 +38,7 @@ struct CallbackContext
static void doScheduleForLater(scheduling_s *scheduling, int delayUs, action_s action);
void SleepExecutor::scheduleByTimestampNt(const char *msg, scheduling_s* scheduling, efitick_t timeNt, action_s action) {
void SleepExecutor::schedule(const char *msg, scheduling_s* scheduling, efitick_t timeNt, action_s action) {
doScheduleForLater(scheduling, NT2US(timeNt) - getTimeNowUs(), action);
}

4
simulator/simulator/system/signal_executor_sleep.h
View File

@ -9,8 +9,8 @@
#include "scheduler.h"
class SleepExecutor : public ExecutorInterface {
class SleepExecutor : public Scheduler {
public:
void scheduleByTimestampNt(const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action) override;
void schedule(const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action) override;
void cancel(scheduling_s* s) override;
};

2
unit_tests/mocks.h
View File

@ -80,7 +80,7 @@ public:
MockExecutor();
virtual ~MockExecutor();
MOCK_METHOD(void, scheduleByTimestampNt, (const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action), (override));
MOCK_METHOD(void, schedule, (const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action), (override));
MOCK_METHOD(void, cancel, (scheduling_s*), (override));
};

12
unit_tests/test-framework/engine_test_helper.cpp
View File

@ -227,12 +227,12 @@ void EngineTestHelper::smartFireTriggerEvents2(int count, float durationMs) {
}
void EngineTestHelper::clearQueue() {
engine.executor.executeAll(99999999); // this is needed to clear 'isScheduled' flag
ASSERT_EQ( 0, engine.executor.size()) << "Failed to clearQueue";
engine.scheduler.executeAll(99999999); // this is needed to clear 'isScheduled' flag
ASSERT_EQ( 0, engine.scheduler.size()) << "Failed to clearQueue";
}
int EngineTestHelper::executeActions() {
return engine.executor.executeAll(getTimeNowUs());
return engine.scheduler.executeAll(getTimeNowUs());
}
void EngineTestHelper::moveTimeForwardMs(float deltaTimeMs) {
@ -268,7 +268,7 @@ void EngineTestHelper::setTimeAndInvokeEventsUs(int targetTimeUs) {
int counter = 0;
while (true) {
criticalAssertVoid(counter++ < 100'000, "EngineTestHelper: failing to setTimeAndInvokeEventsUs");
scheduling_s* nextScheduledEvent = engine.executor.getHead();
scheduling_s* nextScheduledEvent = engine.scheduler.getHead();
if (nextScheduledEvent == nullptr) {
// nothing pending - we are done here
break;
@ -279,7 +279,7 @@ void EngineTestHelper::setTimeAndInvokeEventsUs(int targetTimeUs) {
break;
}
setTimeNowUs(nextEventTime);
engine.executor.executeAll(getTimeNowUs());
engine.scheduler.executeAll(getTimeNowUs());
}
setTimeNowUs(targetTimeUs);
@ -300,7 +300,7 @@ void EngineTestHelper::assertInjectorDownEvent(const char *msg, int eventIndex,
}
scheduling_s * EngineTestHelper::assertEvent5(const char *msg, int index, void *callback, efitimeus_t expectedTimestamp) {
TestExecutor *executor = &engine.executor;
TestExecutor *executor = &engine.scheduler;
EXPECT_TRUE(executor->size() > index) << msg << " valid index";
scheduling_s *event = executor->getForUnitTest(index);
assertEqualsM4(msg, " callback up/down", (void*)event->action.getCallback() == (void*) callback, 1);

6
unit_tests/test-framework/test_executor.cpp
View File

@ -35,9 +35,9 @@ scheduling_s* TestExecutor::getForUnitTest(int index) {
return schedulingQueue.getElementAtIndexForUnitText(index);
}
void TestExecutor::scheduleByTimestampNt(const char *msg, scheduling_s* scheduling, efitick_t timeNt, action_s action) {
void TestExecutor::schedule(const char *msg, scheduling_s* scheduling, efitick_t timeNt, action_s action) {
if (m_mockExecutor) {
m_mockExecutor->scheduleByTimestampNt(msg, scheduling, timeNt, action);
m_mockExecutor->schedule(msg, scheduling, timeNt, action);
return;
}
// by the way we have loss of precision while converting NT to integer US
@ -55,6 +55,6 @@ void TestExecutor::cancel(scheduling_s* s) {
schedulingQueue.remove(s);
}
void TestExecutor::setMockExecutor(ExecutorInterface* exec) {
void TestExecutor::setMockExecutor(Scheduler* exec) {
m_mockExecutor = exec;
}

8
unit_tests/test-framework/test_executor.h
View File

@ -11,11 +11,11 @@
#include "scheduler.h"
#include "event_queue.h"
class TestExecutor : public ExecutorInterface {
class TestExecutor : public Scheduler {
public:
~TestExecutor();
void scheduleByTimestampNt(const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action) override;
void schedule(const char *msg, scheduling_s *scheduling, efitick_t timeNt, action_s action) override;
void cancel(scheduling_s* scheduling) override;
void clear();
@ -24,8 +24,8 @@ public:
scheduling_s * getHead();
scheduling_s * getForUnitTest(int index);
void setMockExecutor(ExecutorInterface* exec);
void setMockExecutor(Scheduler* exec);
private:
EventQueue schedulingQueue;
ExecutorInterface* m_mockExecutor = nullptr;
Scheduler* m_mockExecutor = nullptr;
};

6
unit_tests/tests/ignition_injection/injection_mode_transition.cpp
View File

@ -65,14 +65,14 @@ TEST(fuelControl, transitionIssue1592) {
// Injector 2 should be scheduled to open then close
void* inj2 = reinterpret_cast<void*>(&engine->injectionEvents.elements[1]);
ASSERT_EQ(engine->executor.size(), 2);
ASSERT_EQ(engine->scheduler.size(), 2);
// Check that the action is correct - we don't care about the timing necessarily
auto sched_open = engine->executor.getForUnitTest(0);
auto sched_open = engine->scheduler.getForUnitTest(0);
ASSERT_EQ(sched_open->action.getArgument(), inj2);
ASSERT_EQ(sched_open->action.getCallback(), (void(*)(void*))turnInjectionPinHigh);
auto sched_close = engine->executor.getForUnitTest(1);
auto sched_close = engine->scheduler.getForUnitTest(1);
// Next action should be closing the same injector
ASSERT_EQ(sched_close->action.getArgument(), inj2);
ASSERT_EQ(sched_close->action.getCallback(), (void(*)(void*))turnInjectionPinLow);

12
unit_tests/tests/ignition_injection/test_ignition_scheduling.cpp
View File

@ -89,7 +89,7 @@ TEST(ignition, trailingSpark) {
EXPECT_EQ(enginePins.trailingCoils[0].getLogicValue(), false);
// Should be a TDC callback + spark firing
EXPECT_EQ(engine->executor.size(), 2);
EXPECT_EQ(engine->scheduler.size(), 2);
// execute all actions
eth.executeActions();
@ -198,7 +198,7 @@ TEST(ignition, oddCylinderWastedSpark) {
StrictMock<MockExecutor> mockExec;
EngineTestHelper eth(engine_type_e::TEST_ENGINE);
engine->executor.setMockExecutor(&mockExec);
engine->scheduler.setMockExecutor(&mockExec);
engineConfiguration->cylindersCount = 1;
engineConfiguration->firingOrder = FO_1;
engineConfiguration->ignitionMode = IM_WASTED_SPARK;
@ -216,19 +216,19 @@ TEST(ignition, oddCylinderWastedSpark) {
// Dwell 5 deg from now
float nt1deg = USF2NT(engine->rpmCalculator.oneDegreeUs);
efitick_t startTime = nowNt1 + nt1deg * 5;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime, _));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime, _));
// Spark 15 deg from now
efitick_t endTime = startTime + nt1deg * 10;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, endTime, _));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, endTime, _));
// Should schedule second dwell+fire pair, the out of phase copy
// Dwell 5 deg from now
startTime = nowNt2 + nt1deg * 5;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime, _));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime, _));
// Spark 15 deg from now
endTime = startTime + nt1deg * 10;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, endTime, _));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, endTime, _));
}
engine->ignitionState.sparkDwell = 1;

6
unit_tests/tests/ignition_injection/test_odd_firing_engine.cpp
View File

@ -53,7 +53,7 @@ TEST(OddFireRunningMode, hd) {
angle_t expectedAngle3 = -180 + cylinderTwo - timing;
ASSERT_EQ( 8, engine->executor.size());
ASSERT_EQ( 8, engine->scheduler.size());
eth.assertEvent5("spark down#3", 3, (void*)fireSparkAndPrepareNextSchedule, eth.angleToTimeUs(expectedAngle3));
angle_t expectedAngle7 = 180 + cylinderOne - timing;
@ -61,13 +61,13 @@ TEST(OddFireRunningMode, hd) {
eth.assertRpm( 500, "spinning-RPM#1");
engine->executor.executeAll(getTimeNowUs() + MS2US(1000000));
engine->scheduler.executeAll(getTimeNowUs() + MS2US(1000000));
eth.fireTriggerEvents2(2 /* count */ , 60 /* ms */);
ASSERT_EQ(IM_SEQUENTIAL, getCurrentInjectionMode());
ASSERT_NEAR(0.0069257142022, getInjectionMass(200), EPS3D);
ASSERT_EQ( 8, engine->executor.size());
ASSERT_EQ( 8, engine->scheduler.size());
eth.assertEvent5("fuel down2#1", 1, (void*)turnInjectionPinLow, eth.angleToTimeUs(180 + PORT_INJECTION_OFFSET + cylinderOne));
eth.assertEvent5("spark down2#3", 3, (void*)fireSparkAndPrepareNextSchedule, eth.angleToTimeUs(-180 + cylinderTwo - timing));
eth.assertEvent5("fuel down2#6", 6, (void*)turnInjectionPinLow, eth.angleToTimeUs(540 + PORT_INJECTION_OFFSET + cylinderTwo));

8
unit_tests/tests/ignition_injection/test_one_cylinder_logic.cpp
View File

@ -22,11 +22,11 @@ TEST(issues, issueOneCylinderSpecialCase968) {
eth.setTriggerType(trigger_type_e::TT_HALF_MOON);
ASSERT_EQ( 0, engine->executor.size()) << "start";
ASSERT_EQ( 0, engine->scheduler.size()) << "start";
eth.fireTriggerEvents2(/* count */ 2, 50 /* ms */);
eth.assertRpm(0);
ASSERT_EQ( 0, engine->executor.size()) << "first revolution(s)";
ASSERT_EQ( 0, engine->scheduler.size()) << "first revolution(s)";
eth.fireTriggerEvents2(/* count */ 1, 50 /* ms */);
eth.assertRpm(600, "RPM");
@ -36,11 +36,11 @@ TEST(issues, issueOneCylinderSpecialCase968) {
angle_t expectedAngle = 180 - Gy6139_globalTriggerAngleOffset + timing;
int expectedDeltaTimeUs = eth.angleToTimeUs(expectedAngle);
ASSERT_EQ( 2, engine->executor.size()) << "first revolution(s)";
ASSERT_EQ( 2, engine->scheduler.size()) << "first revolution(s)";
eth.assertEvent5("spark up#0", 0, (void*)turnSparkPinHighStartCharging, -expectedDeltaTimeUs - MS2US(DEFAULT_CRANKING_DWELL_MS));
eth.assertEvent5("spark down#0", 1, (void*)fireSparkAndPrepareNextSchedule, -expectedDeltaTimeUs);
eth.fireTriggerEvents2(/* count */ 1, 50 /* ms */);
ASSERT_EQ( 4, engine->executor.size()) << "first revolution(s)";
ASSERT_EQ( 4, engine->scheduler.size()) << "first revolution(s)";
}

4
unit_tests/tests/ignition_injection/test_startOfCrankingPrimingPulse.cpp
View File

@ -25,7 +25,7 @@ TEST(engine, testPlainCrankingWithoutAdvancedFeatures) {
eth.fireRise(/* delayMs */ 200);
eth.assertRpm(300, "RPM#2");
// two simultaneous injections
ASSERT_EQ( 4, engine->executor.size()) << "plain#2";
ASSERT_EQ( 4, engine->scheduler.size()) << "plain#2";
eth.assertEvent5("sim start", 0, (void*)startSimultaneousInjection, 100000 - 1625);
// -1 because ugh floating point math
@ -41,7 +41,7 @@ TEST(priming, startScheduling) {
// Turn on the ignition switch!
engine->module<PrimeController>()->onIgnitionStateChanged(true);
ASSERT_EQ(1, engine->executor.size()) << "prime fuel";
ASSERT_EQ(1, engine->scheduler.size()) << "prime fuel";
}
TEST(priming, duration) {

8
unit_tests/tests/test_hpfp.cpp
View File

@ -244,7 +244,7 @@ TEST(HPFP, Schedule) {
auto & hpfp = *engine->module<HpfpController>();
StrictMock<MockExecutor> mockExec;
engine->executor.setMockExecutor(&mockExec);
engine->scheduler.setMockExecutor(&mockExec);
engineConfiguration->hpfpActivationAngle = 30;
constexpr angle_t angle0 = 90;
@ -262,13 +262,13 @@ TEST(HPFP, Schedule) {
// First call to setRpmValue will cause a dummy call to fast periodic timer.
// Injection Mass will be 0 so expect a no-op.
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), &hpfp.m_event.eventScheduling, nt0, action_s(HpfpController::pinTurnOff, &hpfp)));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), &hpfp.m_event.eventScheduling, nt0, action_s(HpfpController::pinTurnOff, &hpfp)));
// Second call will be the start of a real pump event.
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), &hpfp.m_event.eventScheduling, nt1, action_s(HpfpController::pinTurnOn, &hpfp)));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), &hpfp.m_event.eventScheduling, nt1, action_s(HpfpController::pinTurnOn, &hpfp)));
// Third call will be off event
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), &hpfp.m_event.eventScheduling, nt2, action_s(HpfpController::pinTurnOff, &hpfp)));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), &hpfp.m_event.eventScheduling, nt2, action_s(HpfpController::pinTurnOff, &hpfp)));
}
EXPECT_CALL(mockExec, cancel(_)).Times(2);

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

@ -40,7 +40,7 @@ TEST(cranking, testFasterEngineSpinningUp) {
// check RPM
eth.assertRpm( 0, "RPM=0");
// the queue should be empty, no trigger events yet
ASSERT_EQ(0, engine->executor.size()) << "plain#1";
ASSERT_EQ(0, engine->scheduler.size()) << "plain#1";
// check all events starting from now
// advance 1 revolution
@ -52,7 +52,7 @@ TEST(cranking, testFasterEngineSpinningUp) {
// due to isFasterEngineSpinUp=true, we should have already detected RPM!
eth.assertRpm( 300, "spinning-RPM#1");
// two simultaneous injections
ASSERT_EQ(4, engine->executor.size()) << "plain#2";
ASSERT_EQ(4, engine->scheduler.size()) << "plain#2";
// test if they are simultaneous
ASSERT_EQ(IM_SIMULTANEOUS, getCurrentInjectionMode());
// test if ignition mode is temporary changed to wasted spark, if set to individual coils
@ -81,7 +81,7 @@ TEST(cranking, testFasterEngineSpinningUp) {
// Should still be in wasted spark since we don't have cam sync yet
ASSERT_EQ(IM_WASTED_SPARK, getCurrentIgnitionMode());
// two simultaneous injections
ASSERT_EQ( 4, engine->executor.size()) << "plain#2";
ASSERT_EQ( 4, engine->scheduler.size()) << "plain#2";
// check real events
expectedSimultaneousTimestamp = eth.angleToTimeUs(360 - phase);
@ -108,7 +108,7 @@ TEST(cranking, testFasterEngineSpinningUp) {
ASSERT_EQ(IM_SEQUENTIAL, getCurrentInjectionMode());
ASSERT_NEAR(0.0, getInjectionMass(200), EPS3D); // in this test fuel calculation is not active in running mode
// 4 sequential injections for the full cycle
ASSERT_EQ( 8, engine->executor.size()) << "plain#3";
ASSERT_EQ( 8, engine->scheduler.size()) << "plain#3";
// check real events for sequential injection
// Note: See addFuelEvents() fix inside setRpmValue()!

28
unit_tests/tests/trigger/test_injection_scheduling.cpp
View File

@ -19,7 +19,7 @@ TEST(injectionScheduling, InjectionIsScheduled) {
StrictMock<MockExecutor> mockExec;
EngineTestHelper eth(engine_type_e::TEST_ENGINE);
engine->executor.setMockExecutor(&mockExec);
engine->scheduler.setMockExecutor(&mockExec);
efitick_t nowNt = 1000000;
@ -42,9 +42,9 @@ TEST(injectionScheduling, InjectionIsScheduled) {
// rising edge 5 degrees from now
float nt5deg = USF2NT(engine->rpmCalculator.oneDegreeUs * 5);
efitick_t startTime = nowNt + nt5deg;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime, Not(Truly(ActionArgumentHasLowBitSet))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime, Not(Truly(ActionArgumentHasLowBitSet))));
// falling edge 20ms later
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
}
// Event scheduled at 125 degrees
@ -59,7 +59,7 @@ TEST(injectionScheduling, InjectionIsScheduledDualStage) {
StrictMock<MockInjectorModel2> im;
EngineTestHelper eth(engine_type_e::TEST_ENGINE);
engine->executor.setMockExecutor(&mockExec);
engine->scheduler.setMockExecutor(&mockExec);
engine->module<InjectorModelPrimary>().set(&im);
engine->module<InjectorModelSecondary>().set(&im);
@ -91,11 +91,11 @@ TEST(injectionScheduling, InjectionIsScheduledDualStage) {
// rising edge 5 degrees from now
float nt5deg = USF2NT(engine->rpmCalculator.oneDegreeUs * 5);
efitick_t startTime = nowNt + nt5deg;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime, Truly(ActionArgumentHasLowBitSet)));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime, Truly(ActionArgumentHasLowBitSet)));
// falling edge (primary) 20ms later
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
// falling edge (secondary) 10ms later
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime + MS2NT(10), Property(&action_s::getArgument, Eq(&event))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime + MS2NT(10), Property(&action_s::getArgument, Eq(&event))));
}
// Event scheduled at 125 degrees
@ -109,7 +109,7 @@ TEST(injectionScheduling, InjectionIsScheduledBeforeWraparound) {
StrictMock<MockExecutor> mockExec;
EngineTestHelper eth(engine_type_e::TEST_ENGINE);
engine->executor.setMockExecutor(&mockExec);
engine->scheduler.setMockExecutor(&mockExec);
efitick_t nowNt = 1000000;
@ -132,9 +132,9 @@ TEST(injectionScheduling, InjectionIsScheduledBeforeWraparound) {
// rising edge 5 degrees from now
float nt5deg = USF2NT(engine->rpmCalculator.oneDegreeUs * 5);
efitick_t startTime = nowNt + nt5deg;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime, Not(Truly(ActionArgumentHasLowBitSet))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime, Not(Truly(ActionArgumentHasLowBitSet))));
// falling edge 20ms later
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
}
// Event scheduled at 715 degrees
@ -148,7 +148,7 @@ TEST(injectionScheduling, InjectionIsScheduledAfterWraparound) {
StrictMock<MockExecutor> mockExec;
EngineTestHelper eth(engine_type_e::TEST_ENGINE);
engine->executor.setMockExecutor(&mockExec);
engine->scheduler.setMockExecutor(&mockExec);
efitick_t nowNt = 1000000;
@ -171,9 +171,9 @@ TEST(injectionScheduling, InjectionIsScheduledAfterWraparound) {
// rising edge 15 degrees from now
float nt5deg = USF2NT(engine->rpmCalculator.oneDegreeUs * 15);
efitick_t startTime = nowNt + nt5deg;
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime, Not(Truly(ActionArgumentHasLowBitSet))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime, Not(Truly(ActionArgumentHasLowBitSet))));
// falling edge 20ms later
EXPECT_CALL(mockExec, scheduleByTimestampNt(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
EXPECT_CALL(mockExec, schedule(testing::NotNull(), _, startTime + MS2NT(20), Property(&action_s::getArgument, Eq(&event))));
}
// Event scheduled at 5 degrees
@ -188,7 +188,7 @@ TEST(injectionScheduling, InjectionNotScheduled) {
StrictMock<MockExecutor> mockExec;
EngineTestHelper eth(engine_type_e::TEST_ENGINE);
engine->executor.setMockExecutor(&mockExec);
engine->scheduler.setMockExecutor(&mockExec);
efitick_t nowNt = 1000000;

6
unit_tests/tests/trigger/test_map_cam.cpp
View File

@ -28,8 +28,8 @@ TEST(trigger, map_cam_by_magic_point) {
ASSERT_EQ(0, engine->triggerCentral.triggerState.camResyncCounter);
// Nothing should have been scheduled yet
ASSERT_EQ(1, engine->executor.size());
scheduling_s* next = engine->executor.getForUnitTest(0);
ASSERT_EQ(1, engine->scheduler.size());
scheduling_s* next = engine->scheduler.getForUnitTest(0);
eth.assertEvent5("spark down#0", 0, (void*)fireSparkAndPrepareNextSchedule, 188333);
engine->outputChannels.instantMAPValue = 120;
@ -43,7 +43,7 @@ TEST(trigger, map_cam_by_magic_point) {
ASSERT_EQ(ClearReason::None, getLimpManager()->allowInjection().reason);
// We have "VVT" sync, things should be scheduled!
ASSERT_EQ(2, engine->executor.size());
ASSERT_EQ(2, engine->scheduler.size());
eth.assertEvent5("spark down#0", 0, (void*)turnSparkPinHighStartCharging, 185333);
eth.assertEvent5("spark down#1", 1, (void*)fireSparkAndPrepareNextSchedule, 188333);
}

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

@ -62,7 +62,7 @@ static void scheduleTriggerEvents(TriggerWaveform *shape,
efitick_t timeNt = efitick_t{US2NT(timeScale * 1000 * angle)};
engine->executor.scheduleByTimestampNt("test", &param->sched, timeNt, { func, param.get() });
engine->scheduler.schedule("test", &param->sched, timeNt, { func, param.get() });
totalIndex++;
}
}
@ -129,7 +129,7 @@ TEST(nissan, vq_vvt) {
scheduling_s *head;
int queueIndex = 0;
while ((head = engine->executor.getHead()) != nullptr) {
while ((head = engine->scheduler.getHead()) != nullptr) {
// todo: what shall we change here once we migrate unit_tests to NT?
eth.setTimeAndInvokeEventsUs(head->getMomentUs());

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

@ -244,48 +244,48 @@ TEST(misc, testRpmCalculator) {
EXPECT_NEAR(ilist->elements[0].sparkAngle, 13.0f, 1e-3);
ASSERT_EQ( 0, engine->triggerCentral.triggerState.getCurrentIndex()) << "index #2";
ASSERT_EQ( 4, engine->executor.size()) << "queue size/2";
ASSERT_EQ( 4, engine->scheduler.size()) << "queue size/2";
{
scheduling_s *ev0 = engine->executor.getForUnitTest(0);
scheduling_s *ev0 = engine->scheduler.getForUnitTest(0);
assertREqualsM("Call@0", (void*)ev0->action.getCallback(), (void*)turnSparkPinHighStartCharging);
ASSERT_EQ(start + 944, ev0->getMomentUs()) << "ev 0";
assertEqualsLM("coil 0", (uintptr_t)&enginePins.coils[0], (uintptr_t)((IgnitionEvent*)ev0->action.getArgument())->outputs[0]);
scheduling_s *ev1 = engine->executor.getForUnitTest(1);
scheduling_s *ev1 = engine->scheduler.getForUnitTest(1);
assertREqualsM("Call@1", (void*)ev1->action.getCallback(), (void*)fireSparkAndPrepareNextSchedule);
ASSERT_EQ(start + 944 + 1000 * FORD_INLINE_DWELL, ev1->getMomentUs()) << "ev 1";
assertEqualsLM("coil 1", (uintptr_t)&enginePins.coils[0], (uintptr_t)((IgnitionEvent*)ev1->action.getArgument())->outputs[0]);
}
engine->executor.clear();
engine->scheduler.clear();
eth.fireFall(5);
eth.fireRise(5);
eth.fireFall(5);
ASSERT_EQ( 2, engine->triggerCentral.triggerState.getCurrentIndex()) << "index #3";
ASSERT_EQ( 4, engine->executor.size()) << "queue size 3";
ASSERT_EQ( 4, engine->scheduler.size()) << "queue size 3";
ASSERT_EQ(start + 13333 - 1515 + 2459, engine->executor.getForUnitTest(0)->getMomentUs()) << "ev 3";
ASSERT_EQ(start + 14277 + 500, engine->executor.getForUnitTest(1)->getMomentUs()) << "ev 5";
ASSERT_EQ(start + 14777 + 677, engine->executor.getForUnitTest(2)->getMomentUs()) << "3/3";
engine->executor.clear();
ASSERT_EQ(start + 13333 - 1515 + 2459, engine->scheduler.getForUnitTest(0)->getMomentUs()) << "ev 3";
ASSERT_EQ(start + 14277 + 500, engine->scheduler.getForUnitTest(1)->getMomentUs()) << "ev 5";
ASSERT_EQ(start + 14777 + 677, engine->scheduler.getForUnitTest(2)->getMomentUs()) << "3/3";
engine->scheduler.clear();
ASSERT_EQ(4, engine->triggerCentral.triggerShape.findAngleIndex(&engine->triggerCentral.triggerFormDetails, 240));
ASSERT_EQ(4, engine->triggerCentral.triggerShape.findAngleIndex(&engine->triggerCentral.triggerFormDetails, 241));
eth.fireFall(5);
ASSERT_EQ( 0, engine->executor.size()) << "queue size 4.1";
ASSERT_EQ( 0, engine->scheduler.size()) << "queue size 4.1";
eth.fireRise(5);
ASSERT_EQ( 4, engine->executor.size()) << "queue size 4.2";
ASSERT_EQ( 4, engine->scheduler.size()) << "queue size 4.2";
eth.fireRise(5);
ASSERT_EQ( 4, engine->executor.size()) << "queue size 4.3";
ASSERT_EQ( 4, engine->scheduler.size()) << "queue size 4.3";
assertEqualsM("dwell", eth.timeToAngle(FORD_INLINE_DWELL), engine->ignitionState.dwellDurationAngle);
assertEqualsM("fuel #3", 4.5450, engine->engineState.injectionDuration);
@ -293,32 +293,32 @@ TEST(misc, testRpmCalculator) {
ASSERT_EQ( 6, engine->triggerCentral.triggerState.getCurrentIndex()) << "index #4";
ASSERT_EQ( 4, engine->executor.size()) << "queue size 4";
engine->executor.clear();
ASSERT_EQ( 4, engine->scheduler.size()) << "queue size 4";
engine->scheduler.clear();
eth.fireFall(5);
ASSERT_EQ( 0, engine->executor.size()) << "queue size 5";
ASSERT_EQ( 0, engine->scheduler.size()) << "queue size 5";
// todo: assert queue elements
engine->executor.clear();
engine->scheduler.clear();
eth.fireRise(5);
ASSERT_EQ( 4, engine->executor.size()) << "queue size 6";
ASSERT_EQ(start + 40944, engine->executor.getForUnitTest(0)->getMomentUs()) << "6/0";
ASSERT_EQ(start + 41444, engine->executor.getForUnitTest(1)->getMomentUs()) << "6/1";
engine->executor.clear();
ASSERT_EQ( 4, engine->scheduler.size()) << "queue size 6";
ASSERT_EQ(start + 40944, engine->scheduler.getForUnitTest(0)->getMomentUs()) << "6/0";
ASSERT_EQ(start + 41444, engine->scheduler.getForUnitTest(1)->getMomentUs()) << "6/1";
engine->scheduler.clear();
eth.fireFall(5);
ASSERT_EQ( 0, engine->executor.size()) << "queue size 7";
engine->executor.clear();
ASSERT_EQ( 0, engine->scheduler.size()) << "queue size 7";
engine->scheduler.clear();
eth.fireRise(5 /*ms*/);
eth.fireFall(5);
ASSERT_EQ( 4, engine->executor.size()) << "queue size 8";
ASSERT_EQ(start + 53333 - 1515 + 2459, engine->executor.getForUnitTest(0)->getMomentUs()) << "8/0";
ASSERT_EQ(start + 54277 + 2459 - 1959, engine->executor.getForUnitTest(1)->getMomentUs()) << "8/1";
engine->executor.clear();
ASSERT_EQ( 4, engine->scheduler.size()) << "queue size 8";
ASSERT_EQ(start + 53333 - 1515 + 2459, engine->scheduler.getForUnitTest(0)->getMomentUs()) << "8/0";
ASSERT_EQ(start + 54277 + 2459 - 1959, engine->scheduler.getForUnitTest(1)->getMomentUs()) << "8/1";
engine->scheduler.clear();
}
TEST(trigger, testAnotherTriggerDecoder) {
@ -427,7 +427,7 @@ static void setTestBug299(EngineTestHelper *eth) {
// time...|0.......|10......|20......|30......|40
// inj #0 |.......#|........|.......#|........|
// inj #1 |........|.......#|........|.......#|
ASSERT_EQ( 4, engine->executor.size()) << "qs#00";
ASSERT_EQ( 4, engine->scheduler.size()) << "qs#00";
ASSERT_EQ( 3, getRevolutionCounter()) << "rev cnt#3";
eth->assertInjectorUpEvent("setTestBug299: 1@0", 0, MS2US(8.5), 2);
eth->assertInjectorDownEvent("@1", 1, MS2US(10), 2);
@ -450,7 +450,7 @@ static void setTestBug299(EngineTestHelper *eth) {
// time...|-20.....|-10.....|0.......|10......|20
// inj #0 |.......#|........|.......#|........|
// inj #1 |........|.......#|........|.......#|
ASSERT_EQ( 8, engine->executor.size()) << "qs#0";
ASSERT_EQ( 8, engine->scheduler.size()) << "qs#0";
ASSERT_EQ( 3, getRevolutionCounter()) << "rev cnt#3";
eth->assertInjectorUpEvent("02@0", 0, MS2US(-11.5), 2);
eth->assertInjectorDownEvent("@1", 1, MS2US(-10), 2);
@ -474,7 +474,7 @@ static void setTestBug299(EngineTestHelper *eth) {
ASSERT_EQ( 4, eth->executeActions()) << "exec#20";
eth->firePrimaryTriggerRise();
ASSERT_EQ( 4, engine->executor.size()) << "qs#0-2";
ASSERT_EQ( 4, engine->scheduler.size()) << "qs#0-2";
// fuel schedule - short pulses. and more realistic schedule this time
// time...|-20.....|-10.....|0.......|10......|20
// inj #0 |.......#|........|.......#|........|
@ -493,7 +493,7 @@ static void setTestBug299(EngineTestHelper *eth) {
// time...|-20.....|-10.....|0.......|10......|20
// inj #0 |.......#|........|........|........|
// inj #1 |........|.......#|........|........|
ASSERT_EQ( 4, engine->executor.size()) << "qs#0-2";
ASSERT_EQ( 4, engine->scheduler.size()) << "qs#0-2";
ASSERT_EQ( 4, getRevolutionCounter()) << "rev cnt#4";
eth->assertInjectorUpEvent("0@0", 0, MS2US(8.5), 0);
eth->assertInjectorDownEvent("0@1", 1, MS2US(10), 0);
@ -550,10 +550,10 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
assertEqualsM("duty for maf=3", 62.5, getInjectorDutyCycle(round(Sensor::getOrZero(SensorType::Rpm))));
ASSERT_EQ( 4, engine->executor.size()) << "qs#1";
ASSERT_EQ( 4, engine->scheduler.size()) << "qs#1";
eth.moveTimeForwardUs(MS2US(20));
ASSERT_EQ( 4, eth.executeActions()) << "exec#2#0";
ASSERT_EQ( 0, engine->executor.size()) << "qs#1#2";
ASSERT_EQ( 0, engine->scheduler.size()) << "qs#1#2";
ASSERT_EQ( 4, getRevolutionCounter()) << "rev cnt#4#0";
@ -562,7 +562,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
// time...|0.......|10......|20......|30......|40......|50......|60......|
// inj #0 |########|##...###|########|.....###|########|........|........|
// inj #1 |.....###|########|....####|########|........|........|........|
ASSERT_EQ( 6, engine->executor.size()) << "qs#4";
ASSERT_EQ( 6, engine->scheduler.size()) << "qs#4";
//todo assertInjectorUpEvent("04@0", 0, MS2US(0), 0);
// assertInjectorUpEvent("04@1", 1, MS2US(7.5), 1);
// assertInjectorDownEvent("04@2", 2, MS2US(12.5), 0);
@ -575,7 +575,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
// assertInjectorDownEvent("04@9", 9, MS2US(50.0), 0);
// {
// scheduling_s *ev = engine->executor.getForUnitTest(9);
// scheduling_s *ev = engine->scheduler.getForUnitTest(9);
// ASSERT_EQ( 5, getRevolutionCounter()) << "rev cnt#4#2";
// ASSERT_TRUE(ev == &engineConfiguration->fuelActuators[2].signalPair[1].signalTimerDown) << "down 50";
// }
@ -585,7 +585,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
eth.fireFall(20);
ASSERT_EQ( 8, engine->executor.size()) << "qs#2#1";
ASSERT_EQ( 8, engine->scheduler.size()) << "qs#2#1";
ASSERT_EQ( 5, getRevolutionCounter()) << "rev cnt#5";
// using old fuel schedule - but already wider pulses
// time...|-20.....|-10.....|0.......|10......|20......|30......|40......|
@ -615,7 +615,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
assertInjectionEventBatch("inj#3", &t->elements[3], 1, 2, 0, 333);
eth.moveTimeForwardUs(MS2US(20));
ASSERT_EQ( 5, engine->executor.size()) << "qs#02";
ASSERT_EQ( 5, engine->scheduler.size()) << "qs#02";
// assertInjectorUpEvent("6@0", 0, MS2US(-12.5), 1);
// assertInjectorDownEvent("6@1", 1, MS2US(-10.0), 0);
// assertInjectorUpEvent("6@2", 2, MS2US(-2.5), 0);
@ -624,11 +624,11 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
// so placing this 'executeAll' changes much?
ASSERT_EQ( 5, eth.executeActions()) << "exec#07";
ASSERT_EQ( 0, engine->executor.size()) << "qs#07";
ASSERT_EQ( 0, engine->scheduler.size()) << "qs#07";
// assertInjectorDownEvent("26@0", 0, MS2US(10.0), 0);
eth.firePrimaryTriggerRise();
ASSERT_EQ( 4, engine->executor.size()) << "qs#2#2";
ASSERT_EQ( 4, engine->scheduler.size()) << "qs#2#2";
ASSERT_EQ( 6, getRevolutionCounter()) << "rev cnt6";
// time...|-20.....|-10.....|0.......|10......|20......|30......|40......|
// inj #0 |########|.....###|########|....####|........|........|........|
@ -646,7 +646,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
// time...|-20.....|-10.....|0.......|10......|20......|30......|40......|
// inj #0 |########|.......#|........|........|........|........|........|
// inj #1 |....####|########|........|........|........|........|........|
ASSERT_EQ( 4, engine->executor.size()) << "qs#022";
ASSERT_EQ( 4, engine->scheduler.size()) << "qs#022";
// assertInjectorUpEvent("7@0", 0, MS2US(-12.5), 1);
// assertInjectorDownEvent("7@1", 1, MS2US(-10.0), 0);
// assertInjectorUpEvent("7@2", 2, MS2US(-2.5), 0);
@ -659,7 +659,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
ASSERT_EQ( 3, eth.executeActions()) << "executed #06";
assertInjectors("#4", 1, 0);
ASSERT_EQ( 1, engine->executor.size()) << "qs#06";
ASSERT_EQ( 1, engine->scheduler.size()) << "qs#06";
eth.assertInjectorDownEvent("17@0", 0, MS2US(10), 0);
// assertInjectorDownEvent("17@1", 1, MS2US(10.0), 0);
// assertInjectorUpEvent("17@2", 2, MS2US(17.5), 0);
@ -668,18 +668,18 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
eth.firePrimaryTriggerFall();
ASSERT_EQ( 5, engine->executor.size()) << "qs#3";
ASSERT_EQ( 5, engine->scheduler.size()) << "qs#3";
ASSERT_EQ( 6, getRevolutionCounter()) << "rev cnt6";
ASSERT_EQ( 0, eth.executeActions()) << "executed #6";
eth.moveTimeForwardUs(MS2US(20));
ASSERT_EQ( 4, eth.executeActions()) << "executed #06";
ASSERT_EQ( 1, engine->executor.size()) << "qs#06";
ASSERT_EQ( 1, engine->scheduler.size()) << "qs#06";
assertInjectors("inj#2", 1, 0);
eth.firePrimaryTriggerRise();
ASSERT_EQ( 5, engine->executor.size()) << "Queue.size#03";
ASSERT_EQ( 5, engine->scheduler.size()) << "Queue.size#03";
eth.assertInjectorUpEvent("07@0", 0, MS2US(7.5), 3);
eth.assertInjectorDownEvent("07@1", 1, MS2US(10), 2);
@ -717,7 +717,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
ASSERT_EQ( 1, enginePins.injectors[0].currentLogicValue) << "inj#0";
ASSERT_EQ( 1, engine->executor.size()) << "Queue.size#04";
ASSERT_EQ( 1, engine->scheduler.size()) << "Queue.size#04";
eth.assertInjectorDownEvent("08@0", 0, MS2US(10), 0);
// assertInjectorDownEvent("08@1", 1, MS2US(10), 0);
// assertInjectorUpEvent("08@2", 2, MS2US(17.5), 0);
@ -729,7 +729,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
eth.executeActions();
eth.fireRise(20);
ASSERT_EQ(9, engine->executor.size()) << "Queue.size#05";
ASSERT_EQ(9, engine->scheduler.size()) << "Queue.size#05";
eth.executeActions();
@ -748,7 +748,7 @@ void doTestFuelSchedulerBug299smallAndMedium(int startUpDelayMs) {
assertInjectionEventBatch("#30", &t->elements[3], 1, 2, 0, 45);
// todo: what's what? a mix of new something and old something?
ASSERT_EQ(6, engine->executor.size()) << "qs#5";
ASSERT_EQ(6, engine->scheduler.size()) << "qs#5";
// assertInjectorDownEvent("8@0", 0, MS2US(5.0), 1);
// assertInjectorUpEvent("8@1", 1, MS2US(7.5), 1);
// assertInjectorDownEvent("8@2", 2, MS2US(15.0), 0);
@ -894,7 +894,7 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
engineConfiguration->isFasterEngineSpinUpEnabled = false;
engine->tdcMarkEnabled = false;
setTestBug299(&eth);
ASSERT_EQ( 4, engine->executor.size()) << "Lqs#0";
ASSERT_EQ( 4, engine->scheduler.size()) << "Lqs#0";
engine->periodicFastCallback();
@ -907,7 +907,7 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
assertEqualsM("Lduty for maf=3", 87.5, getInjectorDutyCycle(round(Sensor::getOrZero(SensorType::Rpm))));
ASSERT_EQ( 4, engine->executor.size()) << "Lqs#1";
ASSERT_EQ( 4, engine->scheduler.size()) << "Lqs#1";
eth.moveTimeForwardUs(MS2US(20));
eth.executeActions();
@ -919,7 +919,7 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
// time...|0.......|10......|20......|30......|40......|50......|60......|
// inj #0 |########|########|########|.....###|########|........|........|
// inj #1 |..######|########|....####|########|........|........|........|
ASSERT_EQ( 6, engine->executor.size()) << "Lqs#4";
ASSERT_EQ( 6, engine->scheduler.size()) << "Lqs#4";
eth.assertInjectorUpEvent("L04@0", 0, MS2US(8.5), 2);
eth.assertInjectorUpEvent("L04@1", 1, MS2US(12.5), 0);
// special overlapping injection is merged with one of the scheduled injections
@ -934,18 +934,18 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
// assertInjectorDownEvent("L04@8", 8, MS2US(50.0), 0);
engine->executor.executeAll(getTimeNowUs() + 1);
engine->scheduler.executeAll(getTimeNowUs() + 1);
// injector goes high...
ASSERT_FALSE(enginePins.injectors[0].currentLogicValue) << "injector@1";
engine->executor.executeAll(getTimeNowUs() + MS2US(17.5) + 1);
engine->scheduler.executeAll(getTimeNowUs() + MS2US(17.5) + 1);
// injector does not go low too soon, that's a feature :)
ASSERT_TRUE(enginePins.injectors[0].currentLogicValue) << "injector@2";
eth.fireFall(20);
ASSERT_EQ( 6, engine->executor.size()) << "Lqs#04";
ASSERT_EQ( 6, engine->scheduler.size()) << "Lqs#04";
eth.assertInjectorUpEvent("L015@0", 0, MS2US(-1.5), 3);
eth.assertInjectorUpEvent("L015@1", 1, MS2US(2.5), 1);
eth.assertInjectorDownEvent("L015@2", 2, MS2US(6), 2);
@ -954,14 +954,14 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
//todo assertInjectorDownEvent("L015@5", 5, MS2US(30), 0);
engine->executor.executeAll(getTimeNowUs() + MS2US(10) + 1);
engine->scheduler.executeAll(getTimeNowUs() + MS2US(10) + 1);
// end of combined injection
ASSERT_FALSE(enginePins.injectors[0].currentLogicValue) << "injector@3";
eth.moveTimeForwardUs(MS2US(20));
eth.executeActions();
ASSERT_EQ( 0, engine->executor.size()) << "Lqs#04";
ASSERT_EQ( 0, engine->scheduler.size()) << "Lqs#04";
engine->periodicFastCallback();
@ -976,7 +976,7 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
eth.firePrimaryTriggerRise();
//todoASSERT_EQ( 5, engine->executor.size()) << "Lqs#05";
//todoASSERT_EQ( 5, engine->scheduler.size()) << "Lqs#05";
//todo assertInjectorUpEvent("L016@0", 0, MS2US(8), 0);
//todo assertInjectorDownEvent("L016@1", 1, MS2US(10), 0);
//todo assertInjectorDownEvent("L016@2", 2, MS2US(10), 0);
@ -991,7 +991,7 @@ TEST(big, testFuelSchedulerBug299smallAndLarge) {
eth.executeActions();
eth.firePrimaryTriggerRise();
ASSERT_EQ( 4, engine->executor.size()) << "Lqs#5";
ASSERT_EQ( 4, engine->scheduler.size()) << "Lqs#5";
eth.assertInjectorUpEvent("L05@0", 0, MS2US(8), 2);
eth.assertInjectorDownEvent("L05@1", 1, MS2US(10), 2);
eth.assertInjectorUpEvent("L05@2", 2, MS2US(18), 3);
@ -1038,7 +1038,7 @@ TEST(big, testSparkReverseOrderBug319) {
ASSERT_EQ( 3000, round(Sensor::getOrZero(SensorType::Rpm))) << "testSparkReverseOrderBug319: RPM";
ASSERT_EQ( 8, engine->executor.size()) << "testSparkReverseOrderBug319: queue size";
ASSERT_EQ( 8, engine->scheduler.size()) << "testSparkReverseOrderBug319: queue size";
eth.executeActions();
printf("***************************************************\r\n");
ASSERT_EQ( 0, engine->engineState.sparkOutOfOrderCounter) << "out-of-order #1";