From e7b8cd96461f8e80ec0ac55fe032322f1cc42dd7 Mon Sep 17 00:00:00 2001 From: rusEfi Date: Mon, 31 Oct 2016 22:02:12 -0400 Subject: [PATCH] auto-sync --- firmware/controllers/math/engine_math.cpp | 4 + firmware/controllers/system/efiGpio.cpp | 8 + firmware/controllers/system/efiGpio.h | 10 +- firmware/controllers/trigger/spark_logic.cpp | 17 +- firmware/controllers/trigger/spark_logic.h | 4 +- firmware/controllers/trigger/trigger_bmw.cpp | 32 +- firmware/controllers/trigger/trigger_bmw.h | 2 +- .../controllers/trigger/trigger_chrysler.cpp | 568 +++++++++--------- .../controllers/trigger/trigger_decoder.cpp | 80 +-- .../controllers/trigger/trigger_decoder.h | 4 +- firmware/controllers/trigger/trigger_gm.cpp | 128 ++-- firmware/controllers/trigger/trigger_gm.h | 4 +- .../controllers/trigger/trigger_honda.cpp | 201 ++++--- firmware/controllers/trigger/trigger_honda.h | 6 +- .../controllers/trigger/trigger_mazda.cpp | 84 +-- .../trigger/trigger_mitsubishi.cpp | 48 +- .../controllers/trigger/trigger_mitsubishi.h | 4 +- .../controllers/trigger/trigger_nissan.cpp | 6 +- firmware/controllers/trigger/trigger_nissan.h | 2 +- .../controllers/trigger/trigger_rover.cpp | 2 +- firmware/controllers/trigger/trigger_rover.h | 2 +- .../controllers/trigger/trigger_structure.cpp | 23 +- .../controllers/trigger/trigger_structure.h | 8 +- .../controllers/trigger/trigger_subaru.cpp | 22 +- firmware/controllers/trigger/trigger_subaru.h | 2 +- .../controllers/trigger/trigger_toyota.cpp | 58 +- firmware/controllers/trigger/trigger_toyota.h | 4 +- firmware/rusefi.cpp | 2 +- unit_tests/engine_test_helper.cpp | 3 + unit_tests/test_fuel_map.cpp | 24 +- unit_tests/test_trigger_decoder.cpp | 49 +- 31 files changed, 736 insertions(+), 675 deletions(-) diff --git a/firmware/controllers/math/engine_math.cpp b/firmware/controllers/math/engine_math.cpp index 0c1b44ccff..bd1af929fa 100644 --- a/firmware/controllers/math/engine_math.cpp +++ b/firmware/controllers/math/engine_math.cpp @@ -418,6 +418,10 @@ static int getIgnitionPinForIndex(int i DECLARE_ENGINE_PARAMETER_S void prepareOutputSignals(DECLARE_ENGINE_PARAMETER_F) { ENGINE(engineCycle) = getEngineCycle(CONFIG(operationMode)); +#if EFI_UNIT_TEST + printf("prepareOutputSignals %d onlyEdge=%s\r\n", engineConfiguration->trigger.type, boolToString(engineConfiguration->useOnlyRisingEdgeForTrigger)); +#endif + engine_configuration2_s *engineConfiguration2 = engine->engineConfiguration2; for (int i = 0; i < CONFIG(specs.cylindersCount); i++) { diff --git a/firmware/controllers/system/efiGpio.cpp b/firmware/controllers/system/efiGpio.cpp index 15cda8c6cf..d88571b0ba 100644 --- a/firmware/controllers/system/efiGpio.cpp +++ b/firmware/controllers/system/efiGpio.cpp @@ -57,6 +57,14 @@ void InjectorOutputPin::reset() { currentLogicValue = INITIAL_PIN_STATE; } +IgnitionOutputPin::IgnitionOutputPin() { + reset(); +} + +void IgnitionOutputPin::reset() { + outOfOrderCounter = 0; +} + OutputPin::OutputPin() { modePtr = &OUTPUT_MODE_DEFAULT; #if EFI_PROD_CODE || defined(__DOXYGEN__) diff --git a/firmware/controllers/system/efiGpio.h b/firmware/controllers/system/efiGpio.h index ecc5362b53..1dd6023844 100644 --- a/firmware/controllers/system/efiGpio.h +++ b/firmware/controllers/system/efiGpio.h @@ -56,6 +56,13 @@ public: int overlappingCounter; }; +class IgnitionOutputPin : public NamedOutputPin { +public: + IgnitionOutputPin(); + void reset(); + int outOfOrderCounter; // https://sourceforge.net/p/rusefi/tickets/319/ +}; + class engine_pins_s { public: engine_pins_s(); @@ -77,9 +84,8 @@ public: OutputPin hipCs; OutputPin sdCsPin; - InjectorOutputPin injectors[INJECTION_PIN_COUNT]; - NamedOutputPin coils[IGNITION_PIN_COUNT]; + IgnitionOutputPin coils[IGNITION_PIN_COUNT]; NamedOutputPin dizzyOutput; }; diff --git a/firmware/controllers/trigger/spark_logic.cpp b/firmware/controllers/trigger/spark_logic.cpp index 202bbf0989..64047bceae 100644 --- a/firmware/controllers/trigger/spark_logic.cpp +++ b/firmware/controllers/trigger/spark_logic.cpp @@ -24,10 +24,16 @@ int isIgnitionTimingError(void) { return ignitionErrorDetection.sum(6) > 4; } -void turnSparkPinLow(NamedOutputPin *output) { +void turnSparkPinLow(IgnitionOutputPin *output) { #if SPARK_EXTREME_LOGGING || defined(__DOXYGEN__) scheduleMsg(logger, "spark goes low %d %s %d", getRevolutionCounter(), output->name, (int)getTimeNowUs()); #endif /* FUEL_MATH_EXTREME_LOGGING */ + + if (!output->currentLogicValue) { + warning(CUSTOM_ERR_6149, "out-of-order coil off %s", output->name); + output->outOfOrderCounter++; + } + turnPinLow(output); #if EFI_PROD_CODE || defined(__DOXYGEN__) if (CONFIG(dizzySparkOutputPin) != GPIO_UNASSIGNED) { @@ -36,10 +42,17 @@ void turnSparkPinLow(NamedOutputPin *output) { #endif /* EFI_PROD_CODE */ } -void turnSparkPinHigh(NamedOutputPin *output) { +void turnSparkPinHigh(IgnitionOutputPin *output) { #if SPARK_EXTREME_LOGGING || defined(__DOXYGEN__) scheduleMsg(logger, "spark goes high %d %s %d", getRevolutionCounter(), output->name, (int)getTimeNowUs()); #endif /* FUEL_MATH_EXTREME_LOGGING */ + + if (output->outOfOrderCounter > 0) { + // let's save this coil if things do not look right + output->outOfOrderCounter--; + return; + } + turnPinHigh(output); #if EFI_PROD_CODE || defined(__DOXYGEN__) if (CONFIG(dizzySparkOutputPin) != GPIO_UNASSIGNED) { diff --git a/firmware/controllers/trigger/spark_logic.h b/firmware/controllers/trigger/spark_logic.h index 3b73200225..419867eeec 100644 --- a/firmware/controllers/trigger/spark_logic.h +++ b/firmware/controllers/trigger/spark_logic.h @@ -14,7 +14,7 @@ int isInjectionEnabled(engine_configuration_s *engineConfiguration); void handleSpark(int revolutionIndex, bool limitedSpark, uint32_t trgEventIndex, int rpm, IgnitionEventList *list DECLARE_ENGINE_PARAMETER_S); void initSparkLogic(Logging *sharedLogger); -void turnSparkPinHigh(NamedOutputPin *output); -void turnSparkPinLow(NamedOutputPin *output); +void turnSparkPinHigh(IgnitionOutputPin *output); +void turnSparkPinLow(IgnitionOutputPin *output); #endif /* CONTROLLERS_TRIGGER_SPARK_LOGIC_H_ */ diff --git a/firmware/controllers/trigger/trigger_bmw.cpp b/firmware/controllers/trigger/trigger_bmw.cpp index 151b9febf7..cddc96d5c2 100644 --- a/firmware/controllers/trigger/trigger_bmw.cpp +++ b/firmware/controllers/trigger/trigger_bmw.cpp @@ -7,63 +7,63 @@ #include "trigger_bmw.h" -static inline float addPair(TriggerShape *s, float a, float w) { - s->addEvent(a, T_SECONDARY, TV_RISE); +static inline float addPair(TriggerShape *s, float a, float w DECLARE_ENGINE_PARAMETER_S) { + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); a += w; return a; } -void configureMiniCooperTriggerShape(TriggerShape *s) { +void configureMiniCooperTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); // s->initialState[0] = 1; float w = 360.0 / 121; float a = w / 2; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); a += w; for (int i = 0; i <= 22; i++) { - a = addPair(s, a, w); + a = addPair(s, a, w PASS_ENGINE_PARAMETER); } a += 3 * w; float firstGapAngle = a; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += 3 * w; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); a += w; for (int i = 0; i < 36; i++) { - a = addPair(s, a, w); + a = addPair(s, a, w PASS_ENGINE_PARAMETER); } - s->addEvent(376, T_PRIMARY, TV_RISE); + s->addEvent2(376, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); for (int i = 0; i < 21; i++) { - a = addPair(s, a, w); + a = addPair(s, a, w PASS_ENGINE_PARAMETER); } a += 3 * w; efiAssertVoid(absF(firstGapAngle + 360 - a) < 0.1, "shape constraint"); - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += 3 * w; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); a += w; for (int i = 0; i < 33; i++) { - a = addPair(s, a, w); + a = addPair(s, a, w PASS_ENGINE_PARAMETER); } efiAssertVoid(absF(720 - w / 2 - a) < 0.1, "shape constraint"); - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(720.0, T_PRIMARY, TV_FALL); + s->addEvent2(720.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); /** * With just one tooth on camshaft synchronization is not needed diff --git a/firmware/controllers/trigger/trigger_bmw.h b/firmware/controllers/trigger/trigger_bmw.h index 3e2c375143..77f2879014 100644 --- a/firmware/controllers/trigger/trigger_bmw.h +++ b/firmware/controllers/trigger/trigger_bmw.h @@ -9,6 +9,6 @@ #include "engine.h" -void configureMiniCooperTriggerShape(TriggerShape *s); +void configureMiniCooperTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); #endif /* TRIGGER_BMW_H_ */ diff --git a/firmware/controllers/trigger/trigger_chrysler.cpp b/firmware/controllers/trigger/trigger_chrysler.cpp index 8ad3917f4d..8233283417 100644 --- a/firmware/controllers/trigger/trigger_chrysler.cpp +++ b/firmware/controllers/trigger/trigger_chrysler.cpp @@ -15,14 +15,14 @@ void initDodgeRam(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->isSynchronizationNeeded = false; - addSkippedToothTriggerEvents(T_SECONDARY, s, 8, 0, 0.06, -25, 360, 0, 720); + addSkippedToothTriggerEvents(T_SECONDARY, s, 8, 0, 0.06, -25, 360, 0, 720 PASS_ENGINE_PARAMETER); - s->addEvent(360, T_PRIMARY, TV_RISE); + s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); addSkippedToothTriggerEvents(T_SECONDARY, s, 8, 0, 0.06, 360 - 25, 360, 0, - 720); + 720 PASS_ENGINE_PARAMETER); - s->addEvent(720, T_PRIMARY, TV_FALL); + s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->useOnlyPrimaryForSync = true; } @@ -34,71 +34,71 @@ void configureNeon2003TriggerShapeCrank(TriggerShape *s DECLARE_ENGINE_PARAMETER s->setTriggerSynchronizationGap(3); int m = 2; - s->addEvent(m * 25, T_PRIMARY, TV_FALL); - s->addEvent(m * 30, T_PRIMARY, TV_RISE); - s->addEvent(m * 35, T_PRIMARY, TV_FALL); - s->addEvent(m * 40, T_PRIMARY, TV_RISE); - s->addEvent(m * 45, T_PRIMARY, TV_FALL); - s->addEvent(m * 50, T_PRIMARY, TV_RISE); - s->addEvent(m * 55, T_PRIMARY, TV_FALL); - s->addEvent(m * 60, T_PRIMARY, TV_RISE); - s->addEvent(m * 65, T_PRIMARY, TV_FALL); - s->addEvent(m * 70, T_PRIMARY, TV_RISE); - s->addEvent(m * 75, T_PRIMARY, TV_FALL); - s->addEvent(m * 80, T_PRIMARY, TV_RISE); - s->addEvent(m * 85, T_PRIMARY, TV_FALL); - s->addEvent(m * 90, T_PRIMARY, TV_RISE); - s->addEvent(m * 95, T_PRIMARY, TV_FALL); - s->addEvent(m * 100, T_PRIMARY, TV_RISE); - s->addEvent(m * 105, T_PRIMARY, TV_FALL); - s->addEvent(m * 110, T_PRIMARY, TV_RISE); - s->addEvent(m * 115, T_PRIMARY, TV_FALL); - s->addEvent(m * 120, T_PRIMARY, TV_RISE); - s->addEvent(m * 125, T_PRIMARY, TV_FALL); - s->addEvent(m * 130, T_PRIMARY, TV_RISE); - s->addEvent(m * 135, T_PRIMARY, TV_FALL); - s->addEvent(m * 140, T_PRIMARY, TV_RISE); - s->addEvent(m * 145,T_PRIMARY, TV_FALL); - s->addEvent(m * 150, T_PRIMARY, TV_RISE); - s->addEvent(m * 155, T_PRIMARY, TV_FALL); - s->addEvent(m * 160, T_PRIMARY, TV_RISE); - s->addEvent(m * 165, T_PRIMARY, TV_FALL); - s->addEvent(m * 170, T_PRIMARY, TV_RISE); - s->addEvent(m * 175, T_PRIMARY, TV_FALL); - s->addEvent(m * 180, T_PRIMARY, TV_RISE); - s->addEvent(m * 185, T_PRIMARY, TV_FALL); + s->addEvent2(m * 25, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 30, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 35, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 40, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 45, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 50, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 55, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 60, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 65, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 70, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 75, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 80, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 85, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 90, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 95, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 100, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 105, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 110, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 115, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 120, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 125, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 130, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 135, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 140, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 145,T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 150, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 155, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 160, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 165, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 170, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 175, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 180, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 185, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); // gap 25 - s->addEvent(m * 210, T_PRIMARY, TV_RISE); - s->addEvent(m * 215, T_PRIMARY, TV_FALL); - s->addEvent(m * 220, T_PRIMARY, TV_RISE); - s->addEvent(m * 225, T_PRIMARY, TV_FALL); - s->addEvent(m * 230, T_PRIMARY, TV_RISE); - s->addEvent(m * 235, T_PRIMARY, TV_FALL); - s->addEvent(m * 240, T_PRIMARY, TV_RISE); - s->addEvent(m * 245, T_PRIMARY, TV_FALL); - s->addEvent(m * 250, T_PRIMARY, TV_RISE); - s->addEvent(m * 255, T_PRIMARY, TV_FALL); - s->addEvent(m * 260, T_PRIMARY, TV_RISE); - s->addEvent(m * 265, T_PRIMARY, TV_FALL); - s->addEvent(m * 270, T_PRIMARY, TV_RISE); - s->addEvent(m * 275, T_PRIMARY, TV_FALL); - s->addEvent(m * 280, T_PRIMARY, TV_RISE); - s->addEvent(m * 285, T_PRIMARY, TV_FALL); - s->addEvent(m * 290, T_PRIMARY, TV_RISE); - s->addEvent(m * 295, T_PRIMARY, TV_FALL); - s->addEvent(m * 300, T_PRIMARY, TV_RISE); - s->addEvent(m * 305, T_PRIMARY, TV_FALL); - s->addEvent(m * 310, T_PRIMARY, TV_RISE); - s->addEvent(m * 315, T_PRIMARY, TV_FALL); - s->addEvent(m * 320, T_PRIMARY, TV_RISE); - s->addEvent(m * 325, T_PRIMARY, TV_FALL); - s->addEvent(m * 330, T_PRIMARY, TV_RISE); - s->addEvent(m * 335, T_PRIMARY, TV_FALL); - s->addEvent(m * 340, T_PRIMARY, TV_RISE); - s->addEvent(m * 345, T_PRIMARY, TV_FALL); - s->addEvent(m * 350, T_PRIMARY, TV_RISE); - s->addEvent(m * 355, T_PRIMARY, TV_FALL); - s->addEvent(m * 360, T_PRIMARY, TV_RISE); + s->addEvent2(m * 210, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 215, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 220, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 225, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 230, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 235, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 240, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 245, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 250, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 255, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 260, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 265, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 270, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 275, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 280, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 285, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 290, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 295, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 300, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 305, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 310, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 315, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 320, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 325, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 330, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 335, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 340, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 345, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 350, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(m * 355, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(m * 360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); } void configureNeon2003TriggerShapeCam(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { @@ -132,23 +132,23 @@ gap=1.43/0.71 s->useOnlyPrimaryForSync = true; if (useOnlyPrimary) { - s->addEvent(144, T_PRIMARY, TV_RISE); - s->addEvent(180, T_PRIMARY, TV_FALL); + s->addEvent2(144, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(216, T_PRIMARY, TV_RISE); - s->addEvent(252, T_PRIMARY, TV_FALL); + s->addEvent2(216, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(252, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(288, T_PRIMARY, TV_RISE); - s->addEvent(324, T_PRIMARY, TV_FALL); + s->addEvent2(288, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(324, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(360, T_PRIMARY, TV_RISE); // width = 144 - s->addEvent(504, T_PRIMARY, TV_FALL); // width = 36 - s->addEvent(540, T_PRIMARY, TV_RISE); - s->addEvent(576, T_PRIMARY, TV_FALL); - s->addEvent(612, T_PRIMARY, TV_RISE); - s->addEvent(648, T_PRIMARY, TV_FALL); - s->addEvent(684, T_PRIMARY, TV_RISE); - s->addEvent(720, T_PRIMARY, TV_FALL); + s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // width = 144 + s->addEvent2(504, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); // width = 36 + s->addEvent2(540, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(576, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(612, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(648, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(684, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); } else { /** @@ -157,171 +157,171 @@ gap=1.43/0.71 * */ - s->addEvent(25, T_SECONDARY, TV_FALL); - s->addEvent(30, T_SECONDARY, TV_RISE); - s->addEvent(35, T_SECONDARY, TV_FALL); - s->addEvent(40, T_SECONDARY, TV_RISE); - s->addEvent(45, T_SECONDARY, TV_FALL); - s->addEvent(50, T_SECONDARY, TV_RISE); - s->addEvent(55, T_SECONDARY, TV_FALL); - s->addEvent(60, T_SECONDARY, TV_RISE); - s->addEvent(65, T_SECONDARY, TV_FALL); - s->addEvent(70, T_SECONDARY, TV_RISE); - s->addEvent(75, T_SECONDARY, TV_FALL); - s->addEvent(80, T_SECONDARY, TV_RISE); - s->addEvent(85, T_SECONDARY, TV_FALL); - s->addEvent(90, T_SECONDARY, TV_RISE); - s->addEvent(95, T_SECONDARY, TV_FALL); - s->addEvent(100, T_SECONDARY, TV_RISE); - s->addEvent(105, T_SECONDARY, TV_FALL); - s->addEvent(110, T_SECONDARY, TV_RISE); - s->addEvent(115, T_SECONDARY, TV_FALL); - s->addEvent(120, T_SECONDARY, TV_RISE); - s->addEvent(125, T_SECONDARY, TV_FALL); - s->addEvent(130, T_SECONDARY, TV_RISE); - s->addEvent(135, T_SECONDARY, TV_FALL); - s->addEvent(140, T_SECONDARY, TV_RISE); + s->addEvent2(25, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(30, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(35, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(40, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(45, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(50, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(60, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(65, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(70, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(75, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(80, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(85, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(90, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(95, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(100, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(105, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(110, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(115, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(120, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(125, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(130, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(135, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(140, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(144, T_PRIMARY, TV_RISE); + s->addEvent2(144, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(145,T_SECONDARY, TV_FALL); - s->addEvent(150, T_SECONDARY, TV_RISE); - s->addEvent(155, T_SECONDARY, TV_FALL); - s->addEvent(160, T_SECONDARY, TV_RISE); - s->addEvent(165, T_SECONDARY, TV_FALL); - s->addEvent(170, T_SECONDARY, TV_RISE); - s->addEvent(175, T_SECONDARY, TV_FALL); - s->addEvent(180 - EPS_ANGLE, T_SECONDARY, TV_RISE); + s->addEvent2(145,T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(150, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(155, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(160, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(165, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(170, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(175, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(180 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(180, T_PRIMARY, TV_FALL); + s->addEvent2(180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(185, T_SECONDARY, TV_FALL); - s->addEvent(210, T_SECONDARY, TV_RISE); - s->addEvent(215, T_SECONDARY, TV_FALL); + s->addEvent2(185, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(210, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(215, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(216, T_PRIMARY, TV_RISE); + s->addEvent2(216, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(220, T_SECONDARY, TV_RISE); - s->addEvent(225, T_SECONDARY, TV_FALL); - s->addEvent(230, T_SECONDARY, TV_RISE); - s->addEvent(235, T_SECONDARY, TV_FALL); - s->addEvent(240, T_SECONDARY, TV_RISE); - s->addEvent(245, T_SECONDARY, TV_FALL); - s->addEvent(250, T_SECONDARY, TV_RISE); + s->addEvent2(220, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(225, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(230, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(235, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(240, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(245, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(250, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(252, T_PRIMARY, TV_FALL); + s->addEvent2(252, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(255, T_SECONDARY, TV_FALL); + s->addEvent2(255, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(260, T_SECONDARY, TV_RISE); - s->addEvent(265, T_SECONDARY, TV_FALL); - s->addEvent(270, T_SECONDARY, TV_RISE); - s->addEvent(275, T_SECONDARY, TV_FALL); - s->addEvent(280, T_SECONDARY, TV_RISE); - s->addEvent(285, T_SECONDARY, TV_FALL); + s->addEvent2(260, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(265, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(270, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(275, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(280, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(285, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(288, T_PRIMARY, TV_RISE); + s->addEvent2(288, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(290, T_SECONDARY, TV_RISE); - s->addEvent(295, T_SECONDARY, TV_FALL); - s->addEvent(300, T_SECONDARY, TV_RISE); - s->addEvent(305, T_SECONDARY, TV_FALL); - s->addEvent(310, T_SECONDARY, TV_RISE); - s->addEvent(315, T_SECONDARY, TV_FALL); - s->addEvent(320, T_SECONDARY, TV_RISE); + s->addEvent2(290, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(295, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(300, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(305, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(310, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(315, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(320, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(324, T_PRIMARY, TV_FALL); + s->addEvent2(324, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(325, T_SECONDARY, TV_FALL); - s->addEvent(330, T_SECONDARY, TV_RISE); - s->addEvent(335, T_SECONDARY, TV_FALL); - s->addEvent(340, T_SECONDARY, TV_RISE); - s->addEvent(345, T_SECONDARY, TV_FALL); - s->addEvent(350, T_SECONDARY, TV_RISE); - s->addEvent(355, T_SECONDARY, TV_FALL); - s->addEvent(360 - EPS_ANGLE, T_SECONDARY, TV_RISE); + s->addEvent2(325, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(330, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(335, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(340, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(345, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(350, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(355, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(360 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(360, T_PRIMARY, TV_RISE); + s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(385, T_SECONDARY, TV_FALL); - s->addEvent(390, T_SECONDARY, TV_RISE); - s->addEvent(395, T_SECONDARY, TV_FALL); - s->addEvent(400, T_SECONDARY, TV_RISE); - s->addEvent(405, T_SECONDARY, TV_FALL); - s->addEvent(410, T_SECONDARY, TV_RISE); - s->addEvent(415, T_SECONDARY, TV_FALL); - s->addEvent(420, T_SECONDARY, TV_RISE); - s->addEvent(425, T_SECONDARY, TV_FALL); - s->addEvent(430, T_SECONDARY, TV_RISE); - s->addEvent(435, T_SECONDARY, TV_FALL); - s->addEvent(440, T_SECONDARY, TV_RISE); - s->addEvent(445, T_SECONDARY, TV_FALL); - s->addEvent(450, T_SECONDARY, TV_RISE); - s->addEvent(455, T_SECONDARY, TV_FALL); - s->addEvent(460, T_SECONDARY, TV_RISE); - s->addEvent(465, T_SECONDARY, TV_FALL); - s->addEvent(470, T_SECONDARY, TV_RISE); - s->addEvent(475, T_SECONDARY, TV_FALL); - s->addEvent(480, T_SECONDARY, TV_RISE); - s->addEvent(485, T_SECONDARY, TV_FALL); - s->addEvent(490, T_SECONDARY, TV_RISE); - s->addEvent(495, T_SECONDARY, TV_FALL); - s->addEvent(500, T_SECONDARY, TV_RISE); + s->addEvent2(385, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(390, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(395, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(400, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(405, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(410, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(415, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(420, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(425, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(430, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(435, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(440, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(445, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(450, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(455, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(460, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(465, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(470, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(475, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(480, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(485, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(490, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(495, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(500, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(504, T_PRIMARY, TV_FALL); + s->addEvent2(504, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(505, T_SECONDARY, TV_FALL); - s->addEvent(510, T_SECONDARY, TV_RISE); - s->addEvent(515, T_SECONDARY, TV_FALL); - s->addEvent(520, T_SECONDARY, TV_RISE); - s->addEvent(525, T_SECONDARY, TV_FALL); - s->addEvent(530, T_SECONDARY, TV_RISE); - s->addEvent(535, T_SECONDARY, TV_FALL); - s->addEvent(540 - EPS_ANGLE, T_SECONDARY, TV_RISE); + s->addEvent2(505, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(510, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(515, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(520, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(525, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(530, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(535, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(540 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(540, T_PRIMARY, TV_RISE); + s->addEvent2(540, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(545, T_SECONDARY, TV_FALL); - s->addEvent(570, T_SECONDARY, TV_RISE); - s->addEvent(575, T_SECONDARY, TV_FALL); + s->addEvent2(545, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(570, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(575, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(576, T_PRIMARY, TV_FALL); - s->addEvent(580, T_SECONDARY, TV_RISE); - s->addEvent(585, T_SECONDARY, TV_FALL); - s->addEvent(590, T_SECONDARY, TV_RISE); - s->addEvent(595, T_SECONDARY, TV_FALL); - s->addEvent(600, T_SECONDARY, TV_RISE); - s->addEvent(605, T_SECONDARY, TV_FALL); - s->addEvent(610, T_SECONDARY, TV_RISE); + s->addEvent2(576, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(580, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(585, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(590, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(595, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(600, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(605, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(610, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(612, T_PRIMARY, TV_RISE); - s->addEvent(615, T_SECONDARY, TV_FALL); - s->addEvent(620, T_SECONDARY, TV_RISE); - s->addEvent(625, T_SECONDARY, TV_FALL); - s->addEvent(630, T_SECONDARY, TV_RISE); - s->addEvent(635, T_SECONDARY, TV_FALL); - s->addEvent(640, T_SECONDARY, TV_RISE); - s->addEvent(645, T_SECONDARY, TV_FALL); + s->addEvent2(612, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(615, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(620, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(625, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(630, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(635, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(640, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(645, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(648, T_PRIMARY, TV_FALL); - s->addEvent(650, T_SECONDARY, TV_RISE); - s->addEvent(655, T_SECONDARY, TV_FALL); - s->addEvent(660, T_SECONDARY, TV_RISE); - s->addEvent(665, T_SECONDARY, TV_FALL); - s->addEvent(670, T_SECONDARY, TV_RISE); - s->addEvent(675, T_SECONDARY, TV_FALL); - s->addEvent(680, T_SECONDARY, TV_RISE); + s->addEvent2(648, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(650, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(655, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(660, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(665, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(670, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(675, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(680, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(684, T_PRIMARY, TV_RISE); - s->addEvent(685, T_SECONDARY, TV_FALL); - s->addEvent(690, T_SECONDARY, TV_RISE); - s->addEvent(695, T_SECONDARY, TV_FALL); - s->addEvent(700, T_SECONDARY, TV_RISE); - s->addEvent(705, T_SECONDARY, TV_FALL); - s->addEvent(710, T_SECONDARY, TV_RISE); - s->addEvent(715, T_SECONDARY, TV_FALL); - s->addEvent(720 - EPS_ANGLE, T_SECONDARY, TV_RISE); - s->addEvent(720, T_PRIMARY, TV_FALL); + s->addEvent2(684, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(685, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(690, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(695, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(700, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(705, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(710, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(715, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(720 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); } } @@ -339,56 +339,56 @@ void configureDodgeStratusTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_ float base = 0; // 2 teeth float angle = base + 120.0 - w; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); angle += g; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += 120; // 3 teeth angle = base + 120.0 - w; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); angle += g; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); angle += g; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += 120; // 2 teeth angle = base + 120.0 - w; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); angle += g; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += 120; // just one angle = base + 120.0 - w; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += 120; // 3 teeth angle = base + 120.0 - w; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); angle += g; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); angle += g; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += 120; // just one again angle = base + 120.0 - w; - s->addEvent(angle, T_PRIMARY, TV_RISE); - s->addEvent(angle + w, T_PRIMARY, TV_FALL); + s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); } void configureNeon1995TriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { @@ -403,50 +403,50 @@ void configureNeon1995TriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialState[T_PRIMARY] = 1; - s->addEvent(base - 720 + 600, T_SECONDARY, TV_RISE); - s->addEvent(base - 720 + 604, T_SECONDARY, TV_FALL); - s->addEvent(base - 720 + 616, T_SECONDARY, TV_RISE); - s->addEvent(base - 720 + 620, T_SECONDARY, TV_FALL); - s->addEvent(base - 720 + 643, T_SECONDARY, TV_RISE); - s->addEvent(base - 720 + 648, T_SECONDARY, TV_FALL); - s->addEvent(base - 720 + 671, T_SECONDARY, TV_RISE); - s->addEvent(base - 720 + 676, T_SECONDARY, TV_FALL); + s->addEvent2(base - 720 + 600, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base - 720 + 604, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base - 720 + 616, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base - 720 + 620, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base - 720 + 643, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base - 720 + 648, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base - 720 + 671, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base - 720 + 676, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(base + 0, T_PRIMARY, TV_FALL); + s->addEvent2(base + 0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(base + 20, T_SECONDARY, TV_RISE); - s->addEvent(base + 60, T_SECONDARY, TV_FALL); - s->addEvent(base + 75, T_SECONDARY, TV_RISE); - s->addEvent(base + 79, T_SECONDARY, TV_FALL); - s->addEvent(base + 101, T_SECONDARY, TV_RISE); - s->addEvent(base + 106, T_SECONDARY, TV_FALL); - s->addEvent(base + 130, T_SECONDARY, TV_RISE); - s->addEvent(base + 135, T_SECONDARY, TV_FALL); + s->addEvent2(base + 20, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 60, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 75, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 79, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 101, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 106, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 130, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 135, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(base + 200, T_PRIMARY, TV_RISE); // width = 150 + s->addEvent2(base + 200, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // width = 150 - s->addEvent(base + 236, T_SECONDARY, TV_RISE); - s->addEvent(base + 239, T_SECONDARY, TV_FALL); - s->addEvent(base + 250, T_SECONDARY, TV_RISE); - s->addEvent(base + 255, T_SECONDARY, TV_FALL); - s->addEvent(base + 277, T_SECONDARY, TV_RISE); - s->addEvent(base + 282, T_SECONDARY, TV_FALL); - s->addEvent(base + 305, T_SECONDARY, TV_RISE); - s->addEvent(base + 310, T_SECONDARY, TV_FALL); + s->addEvent2(base + 236, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 239, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 250, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 255, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 277, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 282, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 305, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 310, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(base + 374, T_SECONDARY, TV_RISE); + s->addEvent2(base + 374, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(base + 395, T_PRIMARY, TV_FALL); // width = + s->addEvent2(base + 395, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); // width = - s->addEvent(base + 418, T_SECONDARY, TV_FALL); - s->addEvent(base + 436, T_SECONDARY, TV_RISE); - s->addEvent(base + 441, T_SECONDARY, TV_FALL); - s->addEvent(base + 463, T_SECONDARY, TV_RISE); - s->addEvent(base + 468, T_SECONDARY, TV_FALL); - s->addEvent(base + 492, T_SECONDARY, TV_RISE); - s->addEvent(base + 497, T_SECONDARY, TV_FALL); + s->addEvent2(base + 418, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 436, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 441, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 463, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 468, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(base + 492, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + 497, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(base + 560, T_PRIMARY, TV_RISE); // width = + s->addEvent2(base + 560, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // width = s->useOnlyPrimaryForSync = true; } diff --git a/firmware/controllers/trigger/trigger_decoder.cpp b/firmware/controllers/trigger/trigger_decoder.cpp index df4c098b97..bb90f79eb5 100644 --- a/firmware/controllers/trigger/trigger_decoder.cpp +++ b/firmware/controllers/trigger/trigger_decoder.cpp @@ -347,24 +347,24 @@ angle_t getEngineCycle(operation_mode_e operationMode) { } void addSkippedToothTriggerEvents(trigger_wheel_e wheel, TriggerShape *s, int totalTeethCount, int skippedCount, - float toothWidth, float offset, float engineCycle, float filterLeft, float filterRight) { + float toothWidth, float offset, float engineCycle, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_S) { efiAssertVoid(totalTeethCount > 0, "total count"); efiAssertVoid(skippedCount >= 0, "skipped count"); for (int i = 0; i < totalTeethCount - skippedCount - 1; i++) { float angleDown = engineCycle / totalTeethCount * (i + (1 - toothWidth)); float angleUp = engineCycle / totalTeethCount * (i + 1); - s->addEvent(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight); - s->addEvent(offset + angleUp, wheel, TV_FALL, filterLeft, filterRight); + s->addEvent2(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight PASS_ENGINE_PARAMETER); + s->addEvent2(offset + angleUp, wheel, TV_FALL, filterLeft, filterRight PASS_ENGINE_PARAMETER); } float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth)); - s->addEvent(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight); - s->addEvent(offset + engineCycle, wheel, TV_FALL, filterLeft, filterRight); + s->addEvent2(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight PASS_ENGINE_PARAMETER); + s->addEvent2(offset + engineCycle, wheel, TV_FALL, filterLeft, filterRight PASS_ENGINE_PARAMETER); } void initializeSkippedToothTriggerShapeExt(TriggerShape *s, int totalTeethCount, int skippedCount, - operation_mode_e operationMode) { + operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { efiAssertVoid(totalTeethCount > 0, "totalTeethCount is zero"); efiAssertVoid(s != NULL, "TriggerShape is NULL"); s->initialize(operationMode, false); @@ -373,7 +373,7 @@ void initializeSkippedToothTriggerShapeExt(TriggerShape *s, int totalTeethCount, s->isSynchronizationNeeded = (skippedCount != 0); addSkippedToothTriggerEvents(T_PRIMARY, s, totalTeethCount, skippedCount, 0.5, 0, getEngineCycle(operationMode), - NO_LEFT_FILTER, NO_RIGHT_FILTER); + NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); } static void configure3_1_cam(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { @@ -413,34 +413,34 @@ static void configure3_1_cam(TriggerShape *s, operation_mode_e operationMode DEC } -static void configureOnePlusOne(TriggerShape *s, operation_mode_e operationMode) { +static void configureOnePlusOne(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { float engineCycle = getEngineCycle(operationMode); s->initialize(FOUR_STROKE_CAM_SENSOR, true); - s->addEvent(180, T_PRIMARY, TV_RISE); - s->addEvent(360, T_PRIMARY, TV_FALL); + s->addEvent2(180, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(360, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(540, T_SECONDARY, TV_RISE); - s->addEvent(720, T_SECONDARY, TV_FALL); + s->addEvent2(540, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->isSynchronizationNeeded = false; s->useOnlyPrimaryForSync = true; } -static void configureOnePlus60_2(TriggerShape *s, operation_mode_e operationMode) { +static void configureOnePlus60_2(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); int totalTeethCount = 60; int skippedCount = 2; - s->addEvent(2, T_PRIMARY, TV_RISE); - addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 2, 20); - s->addEvent(20, T_PRIMARY, TV_FALL); - addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 20, NO_RIGHT_FILTER); + s->addEvent2(2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 2, 20 PASS_ENGINE_PARAMETER); + s->addEvent2(20, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 20, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 360, 360, NO_LEFT_FILTER, - NO_RIGHT_FILTER); + NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); s->isSynchronizationNeeded = false; s->useOnlyPrimaryForSync = true; @@ -464,7 +464,7 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET case TT_TOOTHED_WHEEL: initializeSkippedToothTriggerShapeExt(triggerShape, triggerConfig->customTotalToothCount, - triggerConfig->customSkippedToothCount, engineConfiguration->operationMode); + triggerConfig->customSkippedToothCount, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); break; case TT_MAZDA_MIATA_NA: @@ -495,12 +495,12 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET break; case TT_FORD_ASPIRE: - configureFordAspireTriggerShape(triggerShape); + configureFordAspireTriggerShape(triggerShape PASS_ENGINE_PARAMETER); break; case TT_GM_7X: // todo: fix this configureGmTriggerShape(triggerShape); - configureFordAspireTriggerShape(triggerShape); + configureFordAspireTriggerShape(triggerShape PASS_ENGINE_PARAMETER); break; case TT_MAZDA_DOHC_1_4: @@ -508,7 +508,7 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET break; case TT_ONE_PLUS_ONE: - configureOnePlusOne(triggerShape, engineConfiguration->operationMode); + configureOnePlusOne(triggerShape, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); break; case TT_3_1_CAM: @@ -516,11 +516,11 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET break; case TT_ONE_PLUS_TOOTHED_WHEEL_60_2: - configureOnePlus60_2(triggerShape, engineConfiguration->operationMode); + configureOnePlus60_2(triggerShape, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); break; case TT_ONE: - setToothedWheelConfiguration(triggerShape, 1, 0, engineConfiguration->operationMode); + setToothedWheelConfiguration(triggerShape, 1, 0, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); break; case TT_MAZDA_SOHC_4: @@ -528,39 +528,39 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET break; case TT_MINI_COOPER_R50: - configureMiniCooperTriggerShape(triggerShape); + configureMiniCooperTriggerShape(triggerShape PASS_ENGINE_PARAMETER); break; case TT_TOOTHED_WHEEL_60_2: - setToothedWheelConfiguration(triggerShape, 60, 2, engineConfiguration->operationMode); + setToothedWheelConfiguration(triggerShape, 60, 2, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); break; case TT_60_2_VW: - setVwConfiguration(triggerShape); + setVwConfiguration(triggerShape PASS_ENGINE_PARAMETER); break; case TT_TOOTHED_WHEEL_36_1: - setToothedWheelConfiguration(triggerShape, 36, 1, engineConfiguration->operationMode); + setToothedWheelConfiguration(triggerShape, 36, 1, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); break; case TT_HONDA_ACCORD_CD_TWO_WIRES: - configureHondaAccordCD(triggerShape, false, true, T_CHANNEL_3, T_PRIMARY, 0); + configureHondaAccordCD(triggerShape, false, true, T_CHANNEL_3, T_PRIMARY, 0 PASS_ENGINE_PARAMETER); break; case TT_HONDA_ACCORD_CD: - configureHondaAccordCD(triggerShape, true, true, T_CHANNEL_3, T_PRIMARY, 0); + configureHondaAccordCD(triggerShape, true, true, T_CHANNEL_3, T_PRIMARY, 0 PASS_ENGINE_PARAMETER); break; case TT_HONDA_ACCORD_1_24: - configureHondaAccordCD(triggerShape, true, false, T_PRIMARY, T_PRIMARY, 10); + configureHondaAccordCD(triggerShape, true, false, T_PRIMARY, T_PRIMARY, 10 PASS_ENGINE_PARAMETER); break; case TT_HONDA_ACCORD_1_24_SHIFTED: - configureHondaAccordShifter(triggerShape); + configureHondaAccordShifter(triggerShape PASS_ENGINE_PARAMETER); break; case TT_HONDA_ACCORD_CD_DIP: - configureHondaAccordCDDip(triggerShape); + configureHondaAccordCDDip(triggerShape PASS_ENGINE_PARAMETER); break; case TT_HONDA_CBR_600: @@ -572,7 +572,7 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET break; case TT_MITSU: - initializeMitsubishi4g18(triggerShape); + initializeMitsubishi4g18(triggerShape PASS_ENGINE_PARAMETER); break; case TT_DODGE_RAM: @@ -580,27 +580,27 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET break; case TT_36_2_2_2: - initialize36_2_2_2(triggerShape); + initialize36_2_2_2(triggerShape PASS_ENGINE_PARAMETER); break; case TT_2JZ_3_34: - initialize2jzGE3_34(triggerShape); + initialize2jzGE3_34(triggerShape PASS_ENGINE_PARAMETER); break; case TT_2JZ_1_12: - initialize2jzGE1_12(triggerShape); + initialize2jzGE1_12(triggerShape PASS_ENGINE_PARAMETER); break; case TT_NISSAN: - initializeNissan(triggerShape); + initializeNissan(triggerShape PASS_ENGINE_PARAMETER); break; case TT_ROVER_K: - initializeRoverK(triggerShape); + initializeRoverK(triggerShape PASS_ENGINE_PARAMETER); break; case TT_GM_LS_24: - initGmLS24(triggerShape); + initGmLS24(triggerShape PASS_ENGINE_PARAMETER); break; default: diff --git a/firmware/controllers/trigger/trigger_decoder.h b/firmware/controllers/trigger/trigger_decoder.h index add28720fa..847aa0ffbe 100644 --- a/firmware/controllers/trigger/trigger_decoder.h +++ b/firmware/controllers/trigger/trigger_decoder.h @@ -122,8 +122,8 @@ angle_t getEngineCycle(operation_mode_e operationMode); void addSkippedToothTriggerEvents(trigger_wheel_e wheel, TriggerShape *s, int totalTeethCount, int skippedCount, float toothWidth, - float offset, float engineCycle, float filterLeft, float filterRight); -void initializeSkippedToothTriggerShapeExt(TriggerShape *s, int totalTeethCount, int skippedCount, operation_mode_e operationMode); + float offset, float engineCycle, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_S); +void initializeSkippedToothTriggerShapeExt(TriggerShape *s, int totalTeethCount, int skippedCount, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S); uint32_t findTriggerZeroEventIndex(TriggerState *state, TriggerShape * shape, trigger_config_s const*triggerConfig DECLARE_ENGINE_PARAMETER_S); class Engine; diff --git a/firmware/controllers/trigger/trigger_gm.cpp b/firmware/controllers/trigger/trigger_gm.cpp index 3ec04d3267..011d5844a2 100644 --- a/firmware/controllers/trigger/trigger_gm.cpp +++ b/firmware/controllers/trigger/trigger_gm.cpp @@ -8,32 +8,32 @@ #include "trigger_gm.h" // GM7X looks like this is not complete -void configureGmTriggerShape(TriggerShape *s) { +void configureGmTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, false); // all angles are x2 here - so, 5 degree width is 10 float w = 10; - s->addEvent(120 - w, T_PRIMARY, TV_RISE); - s->addEvent(120.0, T_PRIMARY, TV_FALL); + s->addEvent2(120 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(120.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(240 - w, T_PRIMARY, TV_RISE); - s->addEvent(240.0, T_PRIMARY, TV_FALL); + s->addEvent2(240 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(240.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(360 - w, T_PRIMARY, TV_RISE); - s->addEvent(360.0, T_PRIMARY, TV_FALL); + s->addEvent2(360 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(360.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(480 - w, T_PRIMARY, TV_RISE); - s->addEvent(480.0, T_PRIMARY, TV_FALL); + s->addEvent2(480 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(480.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(600 - w, T_PRIMARY, TV_RISE); - s->addEvent(600.0, T_PRIMARY, TV_FALL); + s->addEvent2(600 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(600.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(700 - w, T_PRIMARY, TV_RISE); - s->addEvent(700.0, T_PRIMARY, TV_FALL); + s->addEvent2(700 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(700.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(720 - w, T_PRIMARY, TV_RISE); - s->addEvent(720.0, T_PRIMARY, TV_FALL); + s->addEvent2(720 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); } /** @@ -42,61 +42,61 @@ void configureGmTriggerShape(TriggerShape *s) { * http://www.ls2.com/forums/showthread.php/834483-LS-Timing-Reluctor-Wheels-Explained * */ -void initGmLS24(TriggerShape *s) { +void initGmLS24(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CRANK_SENSOR, false); trigger_wheel_e ch = T_PRIMARY; /** * based on http://rusefi.com/forum/viewtopic.php?f=3&t=936&start=30 logs */ - s->addEvent(22.2733333333334, ch, TV_RISE); - s->addEvent(27.59333333333338, ch, TV_FALL); - s->addEvent(51.18333333333338, ch, TV_RISE); - s->addEvent(57.58333333333338, ch, TV_FALL); - s->addEvent(81.17333333333337, ch, TV_RISE); - s->addEvent(87.61333333333339, ch, TV_FALL); - s->addEvent(111.30666666666671, ch, TV_RISE); - s->addEvent(117.81000000000004, ch, TV_FALL); - s->addEvent(141.50000000000006, ch, TV_RISE); - s->addEvent(148.05666666666673, ch, TV_FALL); - s->addEvent(153.41333333333338, ch, TV_RISE); - s->addEvent(178.29333333333338, ch, TV_FALL); - s->addEvent(183.51000000000005, ch, TV_RISE); - s->addEvent(208.3266666666667, ch, TV_FALL); - s->addEvent(213.50000000000006, ch, TV_RISE); - s->addEvent(238.26000000000005, ch, TV_FALL); - s->addEvent(243.51000000000005, ch, TV_RISE); - s->addEvent(268.27000000000004, ch, TV_FALL); - s->addEvent(273.53666666666675, ch, TV_RISE); - s->addEvent(298.35, ch, TV_FALL); - s->addEvent(321.86333333333334, ch, TV_RISE); - s->addEvent(328.4966666666667, ch, TV_FALL); - s->addEvent(333.81000000000006, ch, TV_RISE); - s->addEvent(358.66, ch, TV_FALL); - s->addEvent(363.8633333333334, ch, TV_RISE); - s->addEvent(388.7033333333334, ch, TV_FALL); - s->addEvent(393.88000000000005, ch, TV_RISE); - s->addEvent(418.62000000000006, ch, TV_FALL); - s->addEvent(441.9566666666667, ch, TV_RISE); - s->addEvent(448.6700000000001, ch, TV_FALL); - s->addEvent(472.1000000000001, ch, TV_RISE); - s->addEvent(478.9333333333334, ch, TV_FALL); - s->addEvent(484.08000000000004, ch, TV_RISE); - s->addEvent(509.1333333333334, ch, TV_FALL); - s->addEvent(514.2666666666667, ch, TV_RISE); - s->addEvent(539.1733333333334, ch, TV_FALL); - s->addEvent(562.5166666666668, ch, TV_RISE); - s->addEvent(569.1133333333333, ch, TV_FALL); - s->addEvent(592.5400000000001, ch, TV_RISE); - s->addEvent(599.1433333333334, ch, TV_FALL); - s->addEvent(622.6300000000001, ch, TV_RISE); - s->addEvent(629.2633333333334, ch, TV_FALL); - s->addEvent(634.6, ch, TV_RISE); - s->addEvent(659.5, ch, TV_FALL); - s->addEvent(683.1133333333333, ch, TV_RISE); - s->addEvent(689.77, ch, TV_FALL); - s->addEvent(695.0666666666667, ch, TV_RISE); - s->addEvent(720.0, ch, TV_FALL); + s->addEvent2(22.2733333333334, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(27.59333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(51.18333333333338, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(57.58333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(81.17333333333337, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(87.61333333333339, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(111.30666666666671, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(117.81000000000004, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(141.50000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(148.05666666666673, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(153.41333333333338, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(178.29333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(183.51000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(208.3266666666667, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(213.50000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(238.26000000000005, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(243.51000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(268.27000000000004, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(273.53666666666675, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(298.35, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(321.86333333333334, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(328.4966666666667, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(333.81000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(358.66, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(363.8633333333334, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(388.7033333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(393.88000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(418.62000000000006, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(441.9566666666667, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(448.6700000000001, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(472.1000000000001, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(478.9333333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(484.08000000000004, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(509.1333333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(514.2666666666667, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(539.1733333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(562.5166666666668, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(569.1133333333333, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(592.5400000000001, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(599.1433333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(622.6300000000001, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(629.2633333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(634.6, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(659.5, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(683.1133333333333, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(689.77, ch, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(695.0666666666667, ch, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720.0, ch, TV_FALL PASS_ENGINE_PARAMETER); s->useOnlyPrimaryForSync = true; diff --git a/firmware/controllers/trigger/trigger_gm.h b/firmware/controllers/trigger/trigger_gm.h index 47d7b34414..384117cf44 100644 --- a/firmware/controllers/trigger/trigger_gm.h +++ b/firmware/controllers/trigger/trigger_gm.h @@ -10,7 +10,7 @@ #include "trigger_structure.h" -void configureGmTriggerShape(TriggerShape *s); -void initGmLS24(TriggerShape *s); +void configureGmTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); +void initGmLS24(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); #endif /* TRIGGER_GM_H_ */ diff --git a/firmware/controllers/trigger/trigger_honda.cpp b/firmware/controllers/trigger/trigger_honda.cpp index 1a8efa685e..c3fb3674f1 100644 --- a/firmware/controllers/trigger/trigger_honda.cpp +++ b/firmware/controllers/trigger/trigger_honda.cpp @@ -9,21 +9,21 @@ #define S24 (720.0f / 24 / 2) -static float addAccordPair(TriggerShape *s, float sb, trigger_wheel_e const waveIndex) { - s->addEvent(sb, waveIndex, TV_RISE); +static float addAccordPair(TriggerShape *s, float sb, trigger_wheel_e const waveIndex DECLARE_ENGINE_PARAMETER_S) { + s->addEvent2(sb, waveIndex, TV_RISE PASS_ENGINE_PARAMETER); sb += S24; - s->addEvent(sb, waveIndex, TV_FALL); + s->addEvent2(sb, waveIndex, TV_FALL PASS_ENGINE_PARAMETER); sb += S24; return sb; } #define DIP 7.5f -static float addAccordPair3(TriggerShape *s, float sb) { +static float addAccordPair3(TriggerShape *s, float sb DECLARE_ENGINE_PARAMETER_S) { sb += DIP; - s->addEvent(sb, T_CHANNEL_3, TV_RISE); + s->addEvent2(sb, T_CHANNEL_3, TV_RISE PASS_ENGINE_PARAMETER); sb += DIP; - s->addEvent(sb, T_CHANNEL_3, TV_FALL); + s->addEvent2(sb, T_CHANNEL_3, TV_FALL PASS_ENGINE_PARAMETER); sb += 2 * DIP; return sb; } @@ -32,65 +32,65 @@ static float addAccordPair3(TriggerShape *s, float sb) { * Thank you Dip! * http://forum.pgmfi.org/viewtopic.php?f=2&t=15570start=210#p139007 */ -void configureHondaAccordCDDip(TriggerShape *s) { +void configureHondaAccordCDDip(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialState[T_SECONDARY] = TV_RISE; float sb = 0; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(90, T_SECONDARY, TV_FALL); + s->addEvent2(90, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); sb = 90; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(180, T_SECONDARY, TV_RISE); + s->addEvent2(180, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); sb = 180; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(270, T_SECONDARY, TV_FALL); + s->addEvent2(270, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); sb = 270; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(360.0f - DIP, T_PRIMARY, TV_RISE); - s->addEvent(360, T_SECONDARY, TV_RISE); + s->addEvent2(360.0f - DIP, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(360, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); sb = 360; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(450, T_SECONDARY, TV_FALL); + s->addEvent2(450, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); sb = 450; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(540, T_SECONDARY, TV_RISE); + s->addEvent2(540, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); sb = 540; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(630, T_SECONDARY, TV_FALL); + s->addEvent2(630, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); sb = 630; - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); - sb = addAccordPair3(s, sb); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); + sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); - s->addEvent(720.0f - DIP, T_PRIMARY, TV_FALL); + s->addEvent2(720.0f - DIP, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); -// s->addEvent(720.0f - 12 * sb, T_SECONDARY, TV_FALL); -// s->addEvent(720.0f, T_SECONDARY, TV_FALL); +// s->addEvent2(720.0f - 12 * sb, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); +// s->addEvent2(720.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(720.0f, T_SECONDARY, TV_RISE); + s->addEvent2(720.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->isSynchronizationNeeded = false; s->useOnlyPrimaryForSync = true; @@ -99,7 +99,7 @@ void configureHondaAccordCDDip(TriggerShape *s) { void configureHondaAccordCD(TriggerShape *s, bool withOneEventSignal, bool withFourEventSignal, trigger_wheel_e const oneEventWave, trigger_wheel_e const fourEventWave, - float prefix) { + float prefix DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); // trigger_wheel_e const oneEventWave = T_CHANNEL_3; @@ -112,52 +112,52 @@ void configureHondaAccordCD(TriggerShape *s, bool withOneEventSignal, bool withF s->isSynchronizationNeeded = false; - sb = addAccordPair(s, sb, T_SECONDARY); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withOneEventSignal) - s->addEvent(sb - S24 / 2, oneEventWave, TV_RISE); + s->addEvent2(sb - S24 / 2, oneEventWave, TV_RISE PASS_ENGINE_PARAMETER); - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withOneEventSignal) - s->addEvent(sb - S24 / 2, oneEventWave, TV_FALL); - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); + s->addEvent2(sb - S24 / 2, oneEventWave, TV_FALL PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withFourEventSignal) { - s->addEvent(1 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE); + s->addEvent2(1 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER); } - sb = addAccordPair(s, sb, T_SECONDARY); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withFourEventSignal) { - s->addEvent(1 * 180.0f + prefix, fourEventWave, TV_FALL); + s->addEvent2(1 * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER); } - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb,T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb,T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withFourEventSignal) { - s->addEvent(2 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE); + s->addEvent2(2 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER); } - sb = addAccordPair(s, sb, T_SECONDARY); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withFourEventSignal) { - s->addEvent(2 * 180.0f + prefix, fourEventWave, TV_FALL); + s->addEvent2(2 * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER); } for (int i = 3; i <= 4; i++) { - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); - sb = addAccordPair(s, sb, T_SECONDARY); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withFourEventSignal) { - s->addEvent(i * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE); + s->addEvent2(i * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER); } - sb = addAccordPair(s, sb, T_SECONDARY); + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); if (withFourEventSignal) { - s->addEvent(i * 180.0f + prefix, fourEventWave, TV_FALL); + s->addEvent2(i * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER); } } s->useOnlyPrimaryForSync = true; @@ -165,7 +165,7 @@ void configureHondaAccordCD(TriggerShape *s, bool withOneEventSignal, bool withF void configureHondaCbr600(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { // todo: finish this - setToothedWheelConfiguration(s, 24, 0, FOUR_STROKE_CRANK_SENSOR); + setToothedWheelConfiguration(s, 24, 0, FOUR_STROKE_CRANK_SENSOR PASS_ENGINE_PARAMETER); } @@ -184,89 +184,90 @@ void configureHondaCbr600custom(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { float a = 0; a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a - 1, T_SECONDARY, TV_FALL); // 30 + s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); // 30 a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); - s->addEvent(52.4, T_PRIMARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(52.4, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a - 1, T_SECONDARY, TV_FALL); // 60 + s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); // 60 for (int i = 0;i<10;i++) { a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); } a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(381.34f, T_PRIMARY, TV_RISE); + s->addEvent2(381.34f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a - 1, T_SECONDARY, TV_FALL); + s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); for (int i = 0;i<1;i++) { a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); } a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(449.1f, T_PRIMARY, TV_FALL); + s->addEvent2(449.1f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); for (int i = 0;i<8;i++) { a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a, T_SECONDARY, TV_FALL); + s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); } a += w; - s->addEvent(a, T_SECONDARY, TV_RISE); + s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); a += w; - s->addEvent(a - 1, T_SECONDARY, TV_FALL); + s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(720.0f, T_PRIMARY, TV_RISE); + s->addEvent2(720.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); } -void configureHondaAccordShifter(TriggerShape *s) { +void configureHondaAccordShifter(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { float w = 720 / 2 / 24; s->initialize(FOUR_STROKE_CAM_SENSOR, true); float sb = S24; // like this there is no issue -// s->addEvent(S24 + 0.001, T_PRIMARY, TV_RISE); -// s->addEvent(S24 + 0.1, T_SECONDARY, TV_RISE); +// s->addEvent2(S24 + 0.001, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); +// s->addEvent2(S24 + 0.1, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(S24 + 0.001, T_SECONDARY, TV_RISE); - s->addEvent(S24 + 0.1, T_PRIMARY, TV_RISE); + s->addEvent2(S24 + 0.001, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(S24 + 0.1, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); sb += S24; - s->addEvent(sb, T_SECONDARY, TV_FALL); + s->addEvent2(sb, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); sb += S24; - s->addEvent(S24 + 22, T_PRIMARY, TV_FALL); + s->addEvent2(S24 + 22, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - for (int i = 0;i<23;i++) - sb = addAccordPair(s, sb, T_SECONDARY); + for (int i = 0;i<23;i++) { + sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); + } diff --git a/firmware/controllers/trigger/trigger_honda.h b/firmware/controllers/trigger/trigger_honda.h index 052f74a7ca..05c013b1bd 100644 --- a/firmware/controllers/trigger/trigger_honda.h +++ b/firmware/controllers/trigger/trigger_honda.h @@ -10,12 +10,12 @@ #include "trigger_structure.h" -void configureHondaAccordCDDip(TriggerShape *s); -void configureHondaAccordShifter(TriggerShape *s); +void configureHondaAccordCDDip(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); +void configureHondaAccordShifter(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); void configureHondaAccordCD(TriggerShape *s, bool withOneEventSignal, bool withFourEventSignal, trigger_wheel_e const oneEventWave, trigger_wheel_e const fourEventWave, - float d); + float d DECLARE_ENGINE_PARAMETER_S); void configureHondaCbr600(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); void configureHondaCbr600custom(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); diff --git a/firmware/controllers/trigger/trigger_mazda.cpp b/firmware/controllers/trigger/trigger_mazda.cpp index 2764e42536..e63ea86a7f 100644 --- a/firmware/controllers/trigger/trigger_mazda.cpp +++ b/firmware/controllers/trigger/trigger_mazda.cpp @@ -32,21 +32,21 @@ void initializeMazdaMiataNaShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { /** * http://rusefi.com/forum/viewtopic.php?f=3&t=729&p=12983#p12983 */ - s->addEvent(52.960405, T_SECONDARY, TV_RISE); - s->addEvent(122.635956, T_SECONDARY, TV_FALL); + s->addEvent2(52.960405, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(122.635956, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(216.897031, T_PRIMARY, TV_RISE); - s->addEvent(232.640068, T_SECONDARY, TV_RISE); - s->addEvent(288.819688, T_PRIMARY, TV_FALL); - s->addEvent(302.646323, T_SECONDARY, TV_FALL); + s->addEvent2(216.897031, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(232.640068, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(288.819688, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(302.646323, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(412.448056, T_SECONDARY, TV_RISE); - s->addEvent(482.816719, T_SECONDARY, TV_FALL); + s->addEvent2(412.448056, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(482.816719, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(577.035495, T_PRIMARY, TV_RISE); - s->addEvent(592.878113, T_SECONDARY, TV_RISE); - s->addEvent(662.899708, T_SECONDARY, TV_FALL); - s->addEvent(720.0f, T_PRIMARY, TV_FALL); + s->addEvent2(577.035495, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(592.878113, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(662.899708, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(720.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->useOnlyPrimaryForSync = true; } @@ -60,33 +60,33 @@ void initializeMazdaMiataNbShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { /** * cam sensor is primary, crank sensor is secondary */ - s->addEvent(20.0f, T_PRIMARY, TV_RISE); + s->addEvent2(20.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(66.0f, T_SECONDARY, TV_FALL); - s->addEvent(70.0f, T_SECONDARY, TV_RISE); - s->addEvent(136.0f, T_SECONDARY, TV_FALL); - s->addEvent(140.0f, T_SECONDARY, TV_RISE); - s->addEvent(246.0f, T_SECONDARY, TV_FALL); - s->addEvent(250.0f, T_SECONDARY, TV_RISE); - s->addEvent(316.0f, T_SECONDARY, TV_FALL); - s->addEvent(320.0f, T_SECONDARY, TV_RISE); + s->addEvent2(66.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(70.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(136.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(140.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(246.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(250.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(316.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(320.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(340.0f, T_PRIMARY, TV_FALL); - s->addEvent(360.0f, T_PRIMARY, TV_RISE); + s->addEvent2(340.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(360.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(380.0f, T_PRIMARY, TV_FALL); - s->addEvent(400.0f, T_PRIMARY, TV_RISE); + s->addEvent2(380.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(400.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(426.0f, T_SECONDARY, TV_FALL); - s->addEvent(430.0f, T_SECONDARY, TV_RISE); - s->addEvent(496.0f, T_SECONDARY, TV_FALL); - s->addEvent(500.0f, T_SECONDARY, TV_RISE); - s->addEvent(606.0f, T_SECONDARY, TV_FALL); - s->addEvent(610.0f, T_SECONDARY, TV_RISE); - s->addEvent(676.0f, T_SECONDARY, TV_FALL); - s->addEvent(680.0f, T_SECONDARY, TV_RISE); + s->addEvent2(426.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(430.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(496.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(500.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(606.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(610.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(676.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(680.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(720.0f, T_PRIMARY, TV_FALL); + s->addEvent2(720.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->useOnlyPrimaryForSync = true; } @@ -102,18 +102,18 @@ void configureMazdaProtegeSOHC(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { float z = 0.093; a = 180; - s->addEvent(a - z * 720, T_PRIMARY, TV_RISE); - s->addEvent(a, T_PRIMARY, TV_FALL); + s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); a += 180; - s->addEvent(a - z * 720, T_PRIMARY, TV_RISE); - s->addEvent(a, T_PRIMARY, TV_FALL); + s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); a += 180; - s->addEvent(a - z * 720, T_PRIMARY, TV_RISE); - s->addEvent(a, T_PRIMARY, TV_FALL); + s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); a += 180; - s->addEvent(a - z * 720, T_PRIMARY, TV_RISE); - s->addEvent(a, T_PRIMARY, TV_FALL); + s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->isSynchronizationNeeded = false; } diff --git a/firmware/controllers/trigger/trigger_mitsubishi.cpp b/firmware/controllers/trigger/trigger_mitsubishi.cpp index 4567b493a7..ebdba2dfdd 100644 --- a/firmware/controllers/trigger/trigger_mitsubishi.cpp +++ b/firmware/controllers/trigger/trigger_mitsubishi.cpp @@ -7,28 +7,28 @@ #include "trigger_mitsubishi.h" -void configureFordAspireTriggerShape(TriggerShape * s) { +void configureFordAspireTriggerShape(TriggerShape * s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->isSynchronizationNeeded = false; float x = 121.90; float y = 110.86; - s->addEvent(x + y - 180, T_SECONDARY, TV_RISE); - s->addEvent(x, T_SECONDARY, TV_FALL); - s->addEvent(x + y, T_SECONDARY, TV_RISE); - s->addEvent(x + 180, T_SECONDARY, TV_FALL); - s->addEvent(360, T_PRIMARY, TV_RISE); + s->addEvent2(x + y - 180, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(x, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(x + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(x + 180, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(x + 180 + y, T_SECONDARY, TV_RISE); - s->addEvent(x + 360, T_SECONDARY, TV_FALL); - s->addEvent(x + 360 + y, T_SECONDARY, TV_RISE); - s->addEvent(x + 540, T_SECONDARY, TV_FALL); - s->addEvent(720, T_PRIMARY, TV_FALL); + s->addEvent2(x + 180 + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(x + 360, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(x + 360 + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(x + 540, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->useOnlyPrimaryForSync = true; } -void initializeMitsubishi4g18(TriggerShape *s) { +void initializeMitsubishi4g18(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->useRiseEdge = false; @@ -36,20 +36,20 @@ void initializeMitsubishi4g18(TriggerShape *s) { int secondaryWidth = 70; - s->addEvent(180.0 - 131 + 5, T_PRIMARY, TV_RISE); - s->addEvent(180.0 - secondaryWidth, T_SECONDARY, TV_RISE); - s->addEvent(180.0, T_SECONDARY, TV_FALL); - s->addEvent(180.0 + 49 + 5, T_PRIMARY, TV_FALL); + s->addEvent2(180.0 - 131 + 5, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(180.0 - secondaryWidth, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(180.0, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(180.0 + 49 + 5, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(360.0 - secondaryWidth, T_SECONDARY, TV_RISE); - s->addEvent(360.0, T_SECONDARY, TV_FALL); + s->addEvent2(360.0 - secondaryWidth, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(360.0, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(540.0 - 131 + 5, T_PRIMARY, TV_RISE); - s->addEvent(540.0 - secondaryWidth, T_SECONDARY, TV_RISE); - s->addEvent(540.0 - 131 + 5 + 90, T_PRIMARY, TV_FALL); - s->addEvent(540.0, T_SECONDARY, TV_FALL); + s->addEvent2(540.0 - 131 + 5, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(540.0 - secondaryWidth, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(540.0 - 131 + 5 + 90, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(540.0, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(720.0 - secondaryWidth, T_SECONDARY, TV_RISE); - s->addEvent(720.0, T_SECONDARY, TV_FALL); + s->addEvent2(720.0 - secondaryWidth, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720.0, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->useOnlyPrimaryForSync = true; } diff --git a/firmware/controllers/trigger/trigger_mitsubishi.h b/firmware/controllers/trigger/trigger_mitsubishi.h index 0437c4b0a6..e694e8b82e 100644 --- a/firmware/controllers/trigger/trigger_mitsubishi.h +++ b/firmware/controllers/trigger/trigger_mitsubishi.h @@ -9,7 +9,7 @@ #include "trigger_structure.h" -void initializeMitsubishi4g18(TriggerShape *s); -void configureFordAspireTriggerShape(TriggerShape * s); +void initializeMitsubishi4g18(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); +void configureFordAspireTriggerShape(TriggerShape * s DECLARE_ENGINE_PARAMETER_S); #endif /* TRIGGER_MITSUBISHI_H_ */ diff --git a/firmware/controllers/trigger/trigger_nissan.cpp b/firmware/controllers/trigger/trigger_nissan.cpp index 46781d439c..428ac07e8e 100644 --- a/firmware/controllers/trigger/trigger_nissan.cpp +++ b/firmware/controllers/trigger/trigger_nissan.cpp @@ -7,7 +7,7 @@ #include "trigger_nissan.h" -void initializeNissan(TriggerShape *s) { +void initializeNissan(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, false); s->isSynchronizationNeeded = false; @@ -24,7 +24,7 @@ void initializeNissan(TriggerShape *s) { // todo base += 180; - s->addEvent(base - w, T_PRIMARY, TV_RISE); - s->addEvent(base, T_PRIMARY, TV_FALL); + s->addEvent2(base - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); } diff --git a/firmware/controllers/trigger/trigger_nissan.h b/firmware/controllers/trigger/trigger_nissan.h index 4dd8d3ebac..5bc9332cb5 100644 --- a/firmware/controllers/trigger/trigger_nissan.h +++ b/firmware/controllers/trigger/trigger_nissan.h @@ -10,6 +10,6 @@ #include "trigger_structure.h" -void initializeNissan(TriggerShape *s); +void initializeNissan(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); #endif /* CONTROLLERS_TRIGGER_TRIGGER_NISSAN_H_ */ diff --git a/firmware/controllers/trigger/trigger_rover.cpp b/firmware/controllers/trigger/trigger_rover.cpp index 90c5c3c541..ff1a5eedee 100644 --- a/firmware/controllers/trigger/trigger_rover.cpp +++ b/firmware/controllers/trigger/trigger_rover.cpp @@ -8,7 +8,7 @@ #include "trigger_rover.h" -void initializeRoverK(TriggerShape *s) { +void initializeRoverK(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CRANK_SENSOR, false); float tooth = 20; diff --git a/firmware/controllers/trigger/trigger_rover.h b/firmware/controllers/trigger/trigger_rover.h index 28f6513c45..5839da5aaa 100644 --- a/firmware/controllers/trigger/trigger_rover.h +++ b/firmware/controllers/trigger/trigger_rover.h @@ -11,6 +11,6 @@ #include "trigger_structure.h" -void initializeRoverK(TriggerShape *s); +void initializeRoverK(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); #endif /* CONTROLLERS_TRIGGER_TRIGGER_ROVER_H_ */ diff --git a/firmware/controllers/trigger/trigger_structure.cpp b/firmware/controllers/trigger/trigger_structure.cpp index df1766dbfd..1be9959159 100644 --- a/firmware/controllers/trigger/trigger_structure.cpp +++ b/firmware/controllers/trigger/trigger_structure.cpp @@ -245,9 +245,9 @@ angle_t TriggerShape::getAngle(int index) const { } } -void TriggerShape::addEvent(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam, float filterLeft, float filterRight) { +void TriggerShape::addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_S) { if (angle > filterLeft && angle < filterRight) - addEvent(angle, waveIndex, stateParam); + addEvent2(angle, waveIndex, stateParam PASS_ENGINE_PARAMETER); } operation_mode_e TriggerShape::getOperationMode() { @@ -259,11 +259,6 @@ extern bool printTriggerDebug; #endif void TriggerShape::addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam DECLARE_ENGINE_PARAMETER_S) { - addEvent(angle, waveIndex, stateParam); -} - -// todo: probably replace all usages with 'addEvent2'? -void TriggerShape::addEvent(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam) { efiAssertVoid(operationMode != OM_NONE, "operationMode not set"); efiAssertVoid(waveIndex!= T_SECONDARY || needSecondTriggerInput, "secondary needed or not?"); @@ -294,11 +289,9 @@ void TriggerShape::addEvent(angle_t angle, trigger_wheel_e const waveIndex, trig */ angle /= engineCycle; -#if !EFI_UNIT_TEST || defined(__DOXYGEN__) if (!engineConfiguration->useOnlyRisingEdgeForTrigger || stateParam == TV_RISE) { expectedEventCount[waveIndex]++; } -#endif efiAssertVoid(angle > 0, "angle should be positive"); if (size > 0) { @@ -371,7 +364,7 @@ void multi_wave_s::checkSwitchTimes(int size) { checkSwitchTimes2(size, switchTimes); } -void setVwConfiguration(TriggerShape *s) { +void setVwConfiguration(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { efiAssertVoid(s != NULL, "TriggerShape is NULL"); operation_mode_e operationMode = FOUR_STROKE_CRANK_SENSOR; @@ -387,23 +380,23 @@ void setVwConfiguration(TriggerShape *s) { float toothWidth = 0.5; addSkippedToothTriggerEvents(T_PRIMARY, s, 60, 2, toothWidth, 0, engineCycle, - NO_LEFT_FILTER, 690); + NO_LEFT_FILTER, 690 PASS_ENGINE_PARAMETER); float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth) ); - s->addEvent(0 + angleDown + 12, T_PRIMARY, TV_RISE, NO_LEFT_FILTER, NO_RIGHT_FILTER); - s->addEvent(0 + engineCycle, T_PRIMARY, TV_FALL, NO_LEFT_FILTER, NO_RIGHT_FILTER); + s->addEvent2(0 + angleDown + 12, T_PRIMARY, TV_RISE, NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); + s->addEvent2(0 + engineCycle, T_PRIMARY, TV_FALL, NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); s->setTriggerSynchronizationGap2(1.6, 4); } void setToothedWheelConfiguration(TriggerShape *s, int total, int skipped, - operation_mode_e operationMode) { + operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { #if EFI_ENGINE_CONTROL || defined(__DOXYGEN__) s->useRiseEdge = true; initializeSkippedToothTriggerShapeExt(s, total, skipped, - operationMode); + operationMode PASS_ENGINE_PARAMETER); #endif } diff --git a/firmware/controllers/trigger/trigger_structure.h b/firmware/controllers/trigger/trigger_structure.h index 151e02f9eb..e75a9852e3 100644 --- a/firmware/controllers/trigger/trigger_structure.h +++ b/firmware/controllers/trigger/trigger_structure.h @@ -133,8 +133,8 @@ public: int size; void addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const state DECLARE_ENGINE_PARAMETER_S); - void addEvent(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const state); - void addEvent(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam, float filterLeft, float filterRight); + + void addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_S); operation_mode_e getOperationMode(); void initialize(operation_mode_e operationMode, bool needSecondTriggerInput); @@ -189,8 +189,8 @@ private: void calculateTriggerSynchPoint(TriggerState *state DECLARE_ENGINE_PARAMETER_S); }; -void setVwConfiguration(TriggerShape *s); +void setVwConfiguration(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); -void setToothedWheelConfiguration(TriggerShape *s, int total, int skipped, operation_mode_e operationMode); +void setToothedWheelConfiguration(TriggerShape *s, int total, int skipped, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S); #endif /* TRIGGER_STRUCTURE_H_ */ diff --git a/firmware/controllers/trigger/trigger_subaru.cpp b/firmware/controllers/trigger/trigger_subaru.cpp index bd29a85d77..5dba5274fc 100644 --- a/firmware/controllers/trigger/trigger_subaru.cpp +++ b/firmware/controllers/trigger/trigger_subaru.cpp @@ -10,7 +10,7 @@ /** * This trigger is also used by Nissan and Mazda */ -void initialize36_2_2_2(TriggerShape *s) { +void initialize36_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); float wide = 30 * 2; @@ -23,25 +23,25 @@ void initialize36_2_2_2(TriggerShape *s) { float base = 0; for (int i = 0; i < 12; i++) { - s->addEvent(base + narrow / 2, T_PRIMARY, TV_RISE); - s->addEvent(base + narrow, T_PRIMARY, TV_FALL); + s->addEvent2(base + narrow / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + narrow, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += narrow; } - s->addEvent(base + wide / 2, T_PRIMARY, TV_RISE); - s->addEvent(base + wide, T_PRIMARY, TV_FALL); + s->addEvent2(base + wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + wide, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += wide; for (int i = 0; i < 15; i++) { - s->addEvent(base + narrow / 2, T_PRIMARY, TV_RISE); - s->addEvent(base + narrow, T_PRIMARY, TV_FALL); + s->addEvent2(base + narrow / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(base + narrow, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); base += narrow; } - s->addEvent(720 - wide - wide / 2, T_PRIMARY, TV_RISE); - s->addEvent(720 - wide, T_PRIMARY, TV_FALL); + s->addEvent2(720 - wide - wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720 - wide, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); - s->addEvent(720 - wide / 2, T_PRIMARY, TV_RISE); - s->addEvent(720, T_PRIMARY, TV_FALL); + s->addEvent2(720 - wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->useOnlyPrimaryForSync = true; } diff --git a/firmware/controllers/trigger/trigger_subaru.h b/firmware/controllers/trigger/trigger_subaru.h index 260506fef6..d70e4e729d 100644 --- a/firmware/controllers/trigger/trigger_subaru.h +++ b/firmware/controllers/trigger/trigger_subaru.h @@ -10,6 +10,6 @@ #include "engine.h" -void initialize36_2_2_2(TriggerShape *s); +void initialize36_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); #endif /* CONTROLLERS_TRIGGER_TRIGGER_SUBARU_H_ */ diff --git a/firmware/controllers/trigger/trigger_toyota.cpp b/firmware/controllers/trigger/trigger_toyota.cpp index 6b3d766173..1c46eab86e 100644 --- a/firmware/controllers/trigger/trigger_toyota.cpp +++ b/firmware/controllers/trigger/trigger_toyota.cpp @@ -11,42 +11,42 @@ EXTERN_ENGINE; -void initialize2jzGE1_12(TriggerShape *s) { +void initialize2jzGE1_12(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); float crankD = 360 / 12 / 2; // 15 float crankAngle = 10; - s->addEvent(crankAngle, T_SECONDARY, TV_FALL, -1, 721); // 120 + s->addEvent2(crankAngle, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); // 120 for (int i = 0; i < 2; i++) { - s->addEvent(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721); + s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); crankAngle += crankD; - s->addEvent(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721); // 120 + s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); // 120 crankAngle += crankD; } - s->addEvent(75, T_PRIMARY, TV_FALL, -1, 721); + s->addEvent2(75, T_PRIMARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); for (int i = 0; i < 21; i++) { - s->addEvent(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721); + s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); crankAngle += crankD; - s->addEvent(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721); // 120 + s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); // 120 crankAngle += crankD; } - s->addEvent(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721); + s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); crankAngle += crankD; - s->addEvent(720, T_PRIMARY, TV_RISE, -1, 721); + s->addEvent2(720, T_PRIMARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); s->isSynchronizationNeeded = false; } -void initialize2jzGE3_34(TriggerShape *s) { - setToothedWheelConfiguration(s, 36, 2, FOUR_STROKE_CRANK_SENSOR); +void initialize2jzGE3_34(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { + setToothedWheelConfiguration(s, 36, 2, FOUR_STROKE_CRANK_SENSOR PASS_ENGINE_PARAMETER); // s->initialize(FOUR_STROKE_CAM_SENSOR, true); // @@ -55,61 +55,61 @@ void initialize2jzGE3_34(TriggerShape *s) { // float crankAngle = 20; // skipping two teeth // // for (int i = 0; i < 10; i++) { -// s->addEvent(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); -// s->addEvent(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 +// s->addEvent2(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); +// s->addEvent2(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 // crankAngle += 10; // } // 2 + 10 // // float camAngle = 0; // camAngle += camD; -// s->addEvent(camAngle, T_PRIMARY, TV_RISE, -1, 721); // 120 +// s->addEvent2(camAngle, T_PRIMARY, TV_RISE, -1, 721); // 120 // // for (int i = 0; i < 12; i++) { -// s->addEvent(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); -// s->addEvent(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 +// s->addEvent2(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); +// s->addEvent2(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 // crankAngle += 10; // } // 2 + 22 // // // camAngle += camD; -// s->addEvent(camAngle, T_PRIMARY, TV_FALL, -1, 721); // 240 +// s->addEvent2(camAngle, T_PRIMARY, TV_FALL, -1, 721); // 240 // // for (int i = 0; i < 12; i++) { -// s->addEvent(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); -// s->addEvent(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 +// s->addEvent2(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); +// s->addEvent2(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 // crankAngle += 10; // } // 2 + 34 // // camAngle += camD; -// s->addEvent(camAngle, T_PRIMARY, TV_RISE, -1, 721); // 360 +// s->addEvent2(camAngle, T_PRIMARY, TV_RISE, -1, 721); // 360 // // crankAngle += 20; // skipping two teeth one more time // for (int i = 0; i < 10; i++) { -// s->addEvent(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); -// s->addEvent(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 +// s->addEvent2(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); +// s->addEvent2(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 // crankAngle += 10; // } // 2 + 10 // // camAngle += camD; -// s->addEvent(camAngle, T_PRIMARY, TV_FALL, -1, 721); // 480 +// s->addEvent2(camAngle, T_PRIMARY, TV_FALL, -1, 721); // 480 // // for (int i = 0; i < 12; i++) { -// s->addEvent(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); -// s->addEvent(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 +// s->addEvent2(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); +// s->addEvent2(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 // crankAngle += 10; // } // 2 + 22 // // camAngle += camD; -// s->addEvent(camAngle, T_PRIMARY, TV_RISE, -1, 721); // 600 +// s->addEvent2(camAngle, T_PRIMARY, TV_RISE, -1, 721); // 600 // // // for (int i = 0; i < 12; i++) { -// s->addEvent(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); -// s->addEvent(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 +// s->addEvent2(crankAngle + 5, T_SECONDARY, TV_RISE, -1, 721); +// s->addEvent2(crankAngle + 9.9, T_SECONDARY, TV_FALL, -1, 721); // 120 // crankAngle += 10; // } // 2 + 32 // camAngle += camD; -// s->addEvent(camAngle, T_PRIMARY, TV_FALL, -1, 721); // 720 +// s->addEvent2(camAngle, T_PRIMARY, TV_FALL, -1, 721); // 720 // // s->isSynchronizationNeeded = false; diff --git a/firmware/controllers/trigger/trigger_toyota.h b/firmware/controllers/trigger/trigger_toyota.h index eb3162cf30..0295908510 100644 --- a/firmware/controllers/trigger/trigger_toyota.h +++ b/firmware/controllers/trigger/trigger_toyota.h @@ -10,7 +10,7 @@ #include "engine.h" -void initialize2jzGE1_12(TriggerShape *s); -void initialize2jzGE3_34(TriggerShape *s); +void initialize2jzGE1_12(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); +void initialize2jzGE3_34(TriggerShape *s DECLARE_ENGINE_PARAMETER_S); #endif /* CONTROLLERS_TRIGGER_TRIGGER_TOYOTA_H_ */ diff --git a/firmware/rusefi.cpp b/firmware/rusefi.cpp index 569a8358f9..41d00c38a2 100644 --- a/firmware/rusefi.cpp +++ b/firmware/rusefi.cpp @@ -294,5 +294,5 @@ int getRusEfiVersion(void) { return 123; // this is here to make the compiler happy about the unused array if (UNUSED_CCM_SIZE[0] * 0 != 0) return 3211; // this is here to make the compiler happy about the unused array - return 20161027; + return 20161031; } diff --git a/unit_tests/engine_test_helper.cpp b/unit_tests/engine_test_helper.cpp index 4e8294ad56..8d5fdc348c 100644 --- a/unit_tests/engine_test_helper.cpp +++ b/unit_tests/engine_test_helper.cpp @@ -23,6 +23,9 @@ EngineTestHelper::EngineTestHelper(engine_type_e engineType) : engine (&persiste for (int i = 0; i < INJECTION_PIN_COUNT;i++) { enginePins.injectors[i].reset(); } + for (int i = 0; i < IGNITION_PIN_COUNT;i++) { + enginePins.coils[i].reset(); + } engineConfiguration = ec; board_configuration_s * boardConfiguration = &engineConfiguration->bc; diff --git a/unit_tests/test_fuel_map.cpp b/unit_tests/test_fuel_map.cpp index 83d89b85f0..5ffe500069 100644 --- a/unit_tests/test_fuel_map.cpp +++ b/unit_tests/test_fuel_map.cpp @@ -118,20 +118,20 @@ void testFuelMap(void) { extern engine_configuration_s *engineConfiguration; -static void confgiureFordAspireTriggerShape(TriggerShape * s) { +static void confgiureFordAspireTriggerShape(TriggerShape * s DECLARE_ENGINE_PARAMETER_S) { s->initialize(FOUR_STROKE_CAM_SENSOR, true); - s->addEvent(53.747, T_SECONDARY, TV_RISE); - s->addEvent(121.90, T_SECONDARY, TV_FALL); - s->addEvent(232.76, T_SECONDARY, TV_RISE); - s->addEvent(300.54, T_SECONDARY, TV_FALL); - s->addEvent(360, T_PRIMARY, TV_RISE); + s->addEvent2(53.747, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(121.90, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(232.76, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(300.54, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); - s->addEvent(409.8412, T_SECONDARY, TV_RISE); - s->addEvent(478.6505, T_SECONDARY, TV_FALL); - s->addEvent(588.045, T_SECONDARY, TV_RISE); - s->addEvent(657.03, T_SECONDARY, TV_FALL); - s->addEvent(720, T_PRIMARY, TV_FALL); + s->addEvent2(409.8412, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(478.6505, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(588.045, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); + s->addEvent2(657.03, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); + s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); assertEquals(53.747 / 720, s->wave.getSwitchTime(0)); assertEqualsM("@0", 1, s->wave.getChannelState(1, 0)); @@ -220,7 +220,7 @@ void testAngleResolver(void) { assertEquals(178.24, ae.elements[0].injectionStart.angleOffset); TriggerShape t; - confgiureFordAspireTriggerShape(&t); + confgiureFordAspireTriggerShape(&t PASS_ENGINE_PARAMETER); } void testPinHelper(void) { diff --git a/unit_tests/test_trigger_decoder.cpp b/unit_tests/test_trigger_decoder.cpp index ec02d01c26..8745e67f78 100644 --- a/unit_tests/test_trigger_decoder.cpp +++ b/unit_tests/test_trigger_decoder.cpp @@ -460,12 +460,18 @@ void testRpmCalculator(void) { void testTriggerDecoder(void) { printf("*************************************************** testTriggerDecoder\r\n"); - persistent_config_s config; - Engine engine(&config); - TriggerShape * s = &engine.triggerShape; + persistent_config_s c; + Engine e(&c); + TriggerShape * s = &e.triggerShape; - initializeSkippedToothTriggerShapeExt(s, 2, 0, FOUR_STROKE_CAM_SENSOR); + persistent_config_s *config = &c; + Engine *engine = &e; + + engine_configuration_s *engineConfiguration = &c.engineConfiguration; + board_configuration_s *boardConfiguration = &c.engineConfiguration.bc; + + initializeSkippedToothTriggerShapeExt(s, 2, 0, FOUR_STROKE_CAM_SENSOR PASS_ENGINE_PARAMETER); assertEqualsM("shape size", s->getSize(), 4); assertEquals(s->wave.switchTimes[0], 0.25); assertEquals(s->wave.switchTimes[1], 0.5); @@ -604,14 +610,11 @@ static void setTestBug299(EngineTestHelper *eth) { Engine *engine = ð->engine; EXPAND_Engine - FuelSchedule * t; - assertEquals(LM_PLAIN_MAF, engineConfiguration->fuelAlgorithm); engineConfiguration->isIgnitionEnabled = false; engineConfiguration->specs.cylindersCount = 4; engineConfiguration->injectionMode = IM_BATCH; - timeNow = 0; schedulingQueue.clear(); @@ -658,7 +661,7 @@ static void setTestBug299(EngineTestHelper *eth) { assertInjectorDownEvent("@7", 7, MS2US(40), 1); assertEqualsM("exec#0", 0, schedulingQueue.executeAll(timeNow)); - t = ENGINE(engineConfiguration2)->injectionEvents; + FuelSchedule * t = ENGINE(engineConfiguration2)->injectionEvents; assertEqualsM("t.s#0", 4, t->injectionEvents.size); assertInjectionEvent("#0", &t->injectionEvents.elements[0], 0, 0, 513, false); assertInjectionEvent("#0", &t->injectionEvents.elements[1], 1, 0, 693, false); @@ -1116,11 +1119,23 @@ void testSparkReverseOrderBug319(void) { EngineTestHelper eth(TEST_ENGINE); EXPAND_EngineTestHelper + engineConfiguration->useOnlyRisingEdgeForTrigger = false; engineConfiguration->isInjectionEnabled = false; engineConfiguration->specs.cylindersCount = 4; engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; + setConstantDwell(45 PASS_ENGINE_PARAMETER); + + // this is needed to update injectorLag + engine->updateSlowSensors(PASS_ENGINE_PARAMETER_F); + + assertEqualsM("CLT", 70, engine->engineState.clt); + engineConfiguration->trigger.type = TT_ONE; + incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); + + eth.applyTriggerShape(); + eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); timeNow = 0; @@ -1140,9 +1155,27 @@ void testSparkReverseOrderBug319(void) { timeNow += MS2US(20); eth.firePrimaryTriggerFall(); + assertEqualsM("RPM", 3000, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); + + assertEqualsM("queue size", 7, schedulingQueue.size()); schedulingQueue.executeAll(timeNow); + printf("***************************************************\r\n"); + + timeNow += MS2US(20); + eth.firePrimaryTriggerRise(); + schedulingQueue.executeAll(timeNow); + timeNow += 100; // executing new signal too early + eth.firePrimaryTriggerFall(); + schedulingQueue.executeAll(timeNow); + assertEqualsM("out-of-order #1", 1, enginePins.coils[3].outOfOrderCounter); + + + timeNow += MS2US(200); // moving time forward to execute all pending actions + schedulingQueue.executeAll(timeNow); + + assertEqualsM("out-of-order #2", 0, enginePins.coils[3].outOfOrderCounter); }