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

auto-sync

This commit is contained in:
rusEfi 2016-10-31 22:02:12 -04:00
parent 08650ccdbc
commit e7b8cd9646
31 changed files with 736 additions and 675 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
firmware/controllers/math/engine_math.cpp
View File

@ -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++) {

8
firmware/controllers/system/efiGpio.cpp
View File

@ -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__)

10
firmware/controllers/system/efiGpio.h
View File

@ -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;
};

17
firmware/controllers/trigger/spark_logic.cpp
View File

@ -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) {

4
firmware/controllers/trigger/spark_logic.h
View File

@ -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_ */

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

@ -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

2
firmware/controllers/trigger/trigger_bmw.h
View File

@ -9,6 +9,6 @@
#include "engine.h"
void configureMiniCooperTriggerShape(TriggerShape *s);
void configureMiniCooperTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S);
#endif /* TRIGGER_BMW_H_ */

568
firmware/controllers/trigger/trigger_chrysler.cpp
View File

@ -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;
}

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

@ -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:

4
firmware/controllers/trigger/trigger_decoder.h
View File

@ -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;

128
firmware/controllers/trigger/trigger_gm.cpp
View File

@ -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;

4
firmware/controllers/trigger/trigger_gm.h
View File

@ -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_ */

201
firmware/controllers/trigger/trigger_honda.cpp
View File

@ -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);
}

6
firmware/controllers/trigger/trigger_honda.h
View File

@ -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);

84
firmware/controllers/trigger/trigger_mazda.cpp
View File

@ -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;
}

48
firmware/controllers/trigger/trigger_mitsubishi.cpp
View File

@ -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;
}

4
firmware/controllers/trigger/trigger_mitsubishi.h
View File

@ -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_ */

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

@ -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);
}

2
firmware/controllers/trigger/trigger_nissan.h
View File

@ -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_ */

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

@ -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;

2
firmware/controllers/trigger/trigger_rover.h
View File

@ -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_ */

23
firmware/controllers/trigger/trigger_structure.cpp
View File

@ -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
}

8
firmware/controllers/trigger/trigger_structure.h
View File

@ -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_ */

22
firmware/controllers/trigger/trigger_subaru.cpp
View File

@ -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;
}

2
firmware/controllers/trigger/trigger_subaru.h
View File

@ -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_ */

58
firmware/controllers/trigger/trigger_toyota.cpp
View File

@ -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;

4
firmware/controllers/trigger/trigger_toyota.h
View File

@ -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_ */

2
firmware/rusefi.cpp
View File

@ -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;
}

3
unit_tests/engine_test_helper.cpp
View File

@ -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;

24
unit_tests/test_fuel_map.cpp
View File

@ -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) {

49
unit_tests/test_trigger_decoder.cpp
View File

@ -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 = &eth->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);
}