rusefi
/
custom-board-bundle-sample-fork-of-rusefi
mirror of https://github.com/rusefi/custom-board-bundle-sample-fork-of-rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactoring: default parameter, global replace

This commit is contained in:
Andrey 2022-11-16 14:28:43 -05:00
parent 2fb23cf58b
commit 6ca9b6eda7
18 changed files with 680 additions and 680 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

700
firmware/controllers/trigger/decoders/trigger_chrysler.cpp
View File

@ -18,11 +18,11 @@ void initDodgeRam(TriggerWaveform *s) {
addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, 8, 0, 0.06, -25, 360, 0, 720);
s->addEvent720(360, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, 8, 0, 0.06, 360 - 25, 360, 0, 720);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
void configureNeon2003TriggerWaveformCrank(TriggerWaveform *s) {
@ -30,71 +30,71 @@ void configureNeon2003TriggerWaveformCrank(TriggerWaveform *s) {
s->setTriggerSynchronizationGap(3);
s->addEvent360(25, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(30, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(35, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(40, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(45, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(50, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(55, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(60, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(65, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(70, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(75, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(80, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(85, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(90, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(95, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(100, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(105, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(110, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(115, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(120, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(125, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(130, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(135, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(140, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(145,TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(150, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(155, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(160, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(165, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(170, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(175, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(180, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(185, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(25, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(30, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(35, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(40, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(45, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(50, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(55, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(60, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(65, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(70, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(75, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(80, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(85, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(90, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(95, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(100, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(105, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(110, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(115, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(120, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(125, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(130, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(135, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(140, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(145,TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(150, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(155, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(160, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(165, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(170, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(175, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(180, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(185, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
// gap 25
s->addEvent360(210, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(215, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(220, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(225, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(230, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(235, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(240, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(245, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(250, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(255, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(260, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(265, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(270, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(275, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(280, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(285, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(290, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(295, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(300, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(305, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(310, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(315, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(320, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(325, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(330, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(335, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(340, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(345, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(350, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(355, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(360, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(210, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(215, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(220, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(225, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(230, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(235, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(240, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(245, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(250, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(255, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(260, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(265, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(270, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(275, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(280, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(285, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(290, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(295, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(300, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(305, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(310, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(315, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(320, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(325, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(330, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(335, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(340, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(345, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(350, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(355, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
}
void configureNeon2003TriggerWaveformCam(TriggerWaveform *s) {
@ -125,23 +125,23 @@ gap=1.43/0.71
if (useOnlyPrimary) {
s->addEvent720(144, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(144, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(180, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(216, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(252, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(216, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(252, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(288, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(324, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(288, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(324, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(360, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // width = 144
s->addEvent720(504, TriggerWheel::T_PRIMARY, TriggerValue::FALL); // width = 36
s->addEvent720(540, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(576, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(612, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(648, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(684, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // width = 144
s->addEvent720(504, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // width = 36
s->addEvent720(540, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(576, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(612, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(648, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(684, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
} else {
/**
@ -152,171 +152,171 @@ gap=1.43/0.71
s->useOnlyPrimaryForSync = true;
s->addEvent720(25, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(30, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(35, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(40, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(45, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(50, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(55, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(60, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(65, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(70, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(75, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(80, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(85, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(90, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(95, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(100, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(105, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(110, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(115, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(120, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(125, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(130, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(135, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(140, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(25, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(30, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(35, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(40, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(45, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(50, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(55, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(60, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(65, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(70, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(75, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(80, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(85, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(90, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(95, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(100, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(105, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(110, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(115, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(120, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(125, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(130, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(135, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(140, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(144, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(144, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(145,TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(150, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(155, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(160, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(165, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(170, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(175, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(180 - EPS_ANGLE, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(145,TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(150, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(155, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(160, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(165, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(170, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(175, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(180 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(180, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(185, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(210, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(215, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(185, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(210, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(215, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(216, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(216, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(220, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(225, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(230, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(235, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(240, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(245, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(250, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(220, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(225, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(230, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(235, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(240, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(245, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(250, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(252, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(252, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(255, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(255, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(260, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(265, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(270, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(275, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(280, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(285, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(260, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(265, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(270, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(275, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(280, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(285, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(288, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(288, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(290, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(295, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(300, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(305, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(310, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(315, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(320, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(290, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(295, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(300, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(305, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(310, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(315, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(320, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(324, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(324, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(325, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(330, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(335, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(340, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(345, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(350, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(355, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(360 - EPS_ANGLE, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(325, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(330, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(335, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(340, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(345, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(350, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(355, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(360 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(360, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(385, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(390, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(395, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(400, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(405, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(410, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(415, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(420, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(425, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(430, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(435, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(440, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(445, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(450, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(455, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(460, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(465, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(470, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(475, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(480, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(485, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(490, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(495, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(500, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(385, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(390, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(395, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(400, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(405, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(410, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(415, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(420, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(425, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(430, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(435, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(440, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(445, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(450, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(455, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(460, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(465, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(470, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(475, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(480, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(485, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(490, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(495, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(500, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(504, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(504, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(505, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(510, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(515, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(520, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(525, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(530, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(535, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(540 - EPS_ANGLE, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(505, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(510, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(515, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(520, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(525, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(530, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(535, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(540 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(540, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(540, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(545, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(570, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(575, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(545, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(570, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(575, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(576, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(580, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(585, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(590, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(595, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(600, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(605, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(610, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(576, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(580, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(585, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(590, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(595, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(600, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(605, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(610, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(612, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(615, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(620, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(625, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(630, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(635, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(640, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(645, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(612, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(615, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(620, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(625, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(630, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(635, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(640, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(645, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(648, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(650, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(655, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(660, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(665, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(670, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(675, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(680, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(648, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(650, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(655, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(660, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(665, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(670, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(675, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(680, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(684, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(685, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(690, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(695, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(700, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(705, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(710, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(715, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(720 - EPS_ANGLE, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(684, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(685, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(690, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(695, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(700, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(705, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(710, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(715, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(720 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
}
@ -332,56 +332,56 @@ void configureDodgeStratusTriggerWaveform(TriggerWaveform *s) {
float base = 0;
// 2 teeth
float angle = base + 120.0 - w;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
angle += g;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += 120;
// 3 teeth
angle = base + 120.0 - w;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
angle += g;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
angle += g;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += 120;
// 2 teeth
angle = base + 120.0 - w;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
angle += g;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += 120;
// just one
angle = base + 120.0 - w;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += 120;
// 3 teeth
angle = base + 120.0 - w;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
angle += g;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
angle += g;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += 120;
// just one again
angle = base + 120.0 - w;
s->addEvent720(angle, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(angle + w, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
static void configureNeon1995TriggerWaveformCommon(bool withCam, TriggerWaveform *s) {
@ -394,54 +394,54 @@ static void configureNeon1995TriggerWaveformCommon(bool withCam, TriggerWaveform
float m = withCam ? 1 : 2;
s->addEvent720(m * (base - 120), crank, TriggerValue::RISE);
s->addEvent720(m * (base - 116), crank, TriggerValue::FALL);
s->addEvent720(m * (base - 720 + 616), crank, TriggerValue::RISE);
s->addEvent720(m * (base - 100), crank, TriggerValue::FALL);
s->addEvent720(m * (base - 720 + 643), crank, TriggerValue::RISE);
s->addEvent720(m * (base - 720 + 648), crank, TriggerValue::FALL);
s->addEvent720(m * (base - 720 + 671), crank, TriggerValue::RISE);
s->addEvent720(m * (base - 44), crank, TriggerValue::FALL);
s->addEvent720(m * (base - 120), TriggerValue::RISE, crank);
s->addEvent720(m * (base - 116), TriggerValue::FALL, crank);
s->addEvent720(m * (base - 720 + 616), TriggerValue::RISE, crank);
s->addEvent720(m * (base - 100), TriggerValue::FALL, crank);
s->addEvent720(m * (base - 720 + 643), TriggerValue::RISE, crank);
s->addEvent720(m * (base - 720 + 648), TriggerValue::FALL, crank);
s->addEvent720(m * (base - 720 + 671), TriggerValue::RISE, crank);
s->addEvent720(m * (base - 44), TriggerValue::FALL, crank);
if (withCam) {
s->addEvent720(base + 0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + 0, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
s->addEvent720(m * (base + 20), crank, TriggerValue::RISE);
s->addEvent720(m * (base + 60), crank, TriggerValue::FALL);
s->addEvent720(m * (base + 75), crank, TriggerValue::RISE);
s->addEvent720(m * (base + 79), crank, TriggerValue::FALL);
s->addEvent720(m * (base + 101), crank, TriggerValue::RISE);
s->addEvent720(m * (base + 106), crank, TriggerValue::FALL);
s->addEvent720(m * (base + 130), crank, TriggerValue::RISE);
s->addEvent720(m * (base + 135), crank, TriggerValue::FALL);
s->addEvent720(m * (base + 20), TriggerValue::RISE, crank);
s->addEvent720(m * (base + 60), TriggerValue::FALL, crank);
s->addEvent720(m * (base + 75), TriggerValue::RISE, crank);
s->addEvent720(m * (base + 79), TriggerValue::FALL, crank);
s->addEvent720(m * (base + 101), TriggerValue::RISE, crank);
s->addEvent720(m * (base + 106), TriggerValue::FALL, crank);
s->addEvent720(m * (base + 130), TriggerValue::RISE, crank);
s->addEvent720(m * (base + 135), TriggerValue::FALL, crank);
if (withCam) {
s->addEvent720(base + 200, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // width = 150
s->addEvent720(base + 200, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // width = 150
s->addEvent720(base + 236, crank, TriggerValue::RISE);
s->addEvent720(base + 239, crank, TriggerValue::FALL);
s->addEvent720(base + 250, crank, TriggerValue::RISE);
s->addEvent720(base + 255, crank, TriggerValue::FALL);
s->addEvent720(base + 277, crank, TriggerValue::RISE);
s->addEvent720(base + 282, crank, TriggerValue::FALL);
s->addEvent720(base + 305, crank, TriggerValue::RISE);
s->addEvent720(base + 310, crank, TriggerValue::FALL);
s->addEvent720(base + 236, TriggerValue::RISE, crank);
s->addEvent720(base + 239, TriggerValue::FALL, crank);
s->addEvent720(base + 250, TriggerValue::RISE, crank);
s->addEvent720(base + 255, TriggerValue::FALL, crank);
s->addEvent720(base + 277, TriggerValue::RISE, crank);
s->addEvent720(base + 282, TriggerValue::FALL, crank);
s->addEvent720(base + 305, TriggerValue::RISE, crank);
s->addEvent720(base + 310, TriggerValue::FALL, crank);
s->addEvent720(base + 374, crank, TriggerValue::RISE);
s->addEvent720(base + 374, TriggerValue::RISE, crank);
// if (withCam)
s->addEvent720(base + 395, TriggerWheel::T_PRIMARY, TriggerValue::FALL); // width =
s->addEvent720(base + 395, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // width =
s->addEvent720(base + 418, crank, TriggerValue::FALL);
s->addEvent720(base + 436, crank, TriggerValue::RISE);
s->addEvent720(base + 441, crank, TriggerValue::FALL);
s->addEvent720(base + 463, crank, TriggerValue::RISE);
s->addEvent720(base + 468, crank, TriggerValue::FALL);
s->addEvent720(base + 492, crank, TriggerValue::RISE);
s->addEvent720(base + 497, crank, TriggerValue::FALL);
s->addEvent720(base + 418, TriggerValue::FALL, crank);
s->addEvent720(base + 436, TriggerValue::RISE, crank);
s->addEvent720(base + 441, TriggerValue::FALL, crank);
s->addEvent720(base + 463, TriggerValue::RISE, crank);
s->addEvent720(base + 468, TriggerValue::FALL, crank);
s->addEvent720(base + 492, TriggerValue::RISE, crank);
s->addEvent720(base + 497, TriggerValue::FALL, crank);
// if (withCam)
s->addEvent720(base + 560, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // width =
s->addEvent720(base + 560, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // width =
}
}
@ -473,79 +473,79 @@ void initJeep18_2_2_2(TriggerWaveform *s) {
float off = 212;
s->addEvent720(534 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(536 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(554 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(556 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(574 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(576 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(594 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(596 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(534 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(536 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(554 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(556 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(574 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(576 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(594 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(596 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(654 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(656 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(674 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(676 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(694 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(696 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(714 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(716 - 720 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(654 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(656 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(674 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(676 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(694 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(696 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(714 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(716 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(54 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(56 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(74 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(76 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(94 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(96 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(114 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(116 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(54 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(56 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(74 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(76 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(94 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(96 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(114 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(116 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(148 + off, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // 360
s->addEvent720(148 + off, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // 360
s->addEvent720(174 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(176 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(194 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(196 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(214 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(216 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(234 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(236 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(174 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(176 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(194 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(196 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(214 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(216 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(234 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(236 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(294 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(296 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(314 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(316 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(334 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(336 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(354 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(356 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(294 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(296 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(314 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(316 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(334 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(336 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(354 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(356 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(414 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(416 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(434 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(436 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(454 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(456 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(474 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(476 + off, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(414 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(416 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(434 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(436 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(454 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(456 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(474 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(476 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(508 + off, TriggerWheel::T_PRIMARY, TriggerValue::FALL); // 720
s->addEvent720(508 + off, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // 720
}
static void add4cylblock(int off, TriggerWaveform *s) {
s->addEvent720(114 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(114 + off + 2, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(114 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(114 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(134 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(134 + off + 2, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(134 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(134 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(154 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(154 + off + 2, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(154 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(154 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(174 + off, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(174 + off + 2, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(174 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(174 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
}
// TT_JEEP_4_CYL
@ -559,12 +559,12 @@ void initJeep_XJ_4cyl_2500(TriggerWaveform *s) {
add4cylblock(offset - 180, s);
add4cylblock(offset, s);
s->addEvent720(236 + offset, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // 360
s->addEvent720(236 + offset, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // 360
add4cylblock(offset + 180, s);
add4cylblock(offset + 360, s);
s->addEvent720(596 + offset, TriggerWheel::T_PRIMARY, TriggerValue::FALL); // 720
s->addEvent720(596 + offset, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // 720
}
@ -583,23 +583,23 @@ void configureChryslerNGC_36_2_2(TriggerWaveform *s) {
float base = 0;
for (int i = 0; i < 14; i++) {
s->addEventAngle(base + narrow / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(base + narrow, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(base + narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEventAngle(base + narrow, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += narrow;
}
s->addEventAngle(base + narrow / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(base + narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
base += narrow / 2;
s->addEventAngle(base + wide, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(base + wide, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += wide;
for (int i = 0; i < 16; i++) {
s->addEventAngle(base + narrow / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(base + narrow, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(base + narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEventAngle(base + narrow, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
base += narrow;
}
// one small tooth at the end of the engine cycle
s->addEventAngle(s->getCycleDuration() - narrow / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(s->getCycleDuration(), TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration() - narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEventAngle(s->getCycleDuration(), TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}

40
firmware/controllers/trigger/decoders/trigger_gm.cpp
View File

@ -10,9 +10,9 @@
#include "trigger_gm.h"
static float addTooth(float offset, TriggerWaveform *s) {
s->addEventAngle(offset, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEventAngle(offset, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
offset += CRANK_MODE_MULTIPLIER * 3;
s->addEventAngle(offset, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEventAngle(offset, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
offset += CRANK_MODE_MULTIPLIER * 3;
return offset;
}
@ -52,11 +52,11 @@ void configureGm60_2_2_2(TriggerWaveform *s) {
}
s->addEventAngle(m * (360 - 6), TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(m * (360 - 6), TriggerValue::RISE);
offset = addTooth(offset, s);
s->addEventAngle(m * (360), TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(m * (360), TriggerValue::FALL);
}
@ -65,26 +65,26 @@ void configureGmTriggerWaveform(TriggerWaveform *s) {
float w = 5;
s->addEvent360(60 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(60, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(60 - w, TriggerValue::RISE);
s->addEvent360(60, TriggerValue::FALL);
s->addEvent360(120 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(120.0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(120 - w, TriggerValue::RISE);
s->addEvent360(120.0, TriggerValue::FALL);
s->addEvent360(180 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(180 - w, TriggerValue::RISE);
s->addEvent360(180, TriggerValue::FALL);
s->addEvent360(240 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(240.0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(240 - w, TriggerValue::RISE);
s->addEvent360(240.0, TriggerValue::FALL);
s->addEvent360(300 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(300.0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(300 - w, TriggerValue::RISE);
s->addEvent360(300.0, TriggerValue::FALL);
s->addEvent360(350 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(350.0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(350 - w, TriggerValue::RISE);
s->addEvent360(350.0, TriggerValue::FALL);
s->addEvent360(360 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(360.0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(360 - w, TriggerValue::RISE);
s->addEvent360(360.0, TriggerValue::FALL);
s->setTriggerSynchronizationGap(6);
}
@ -94,8 +94,8 @@ static int gm_tooth_pair(float startAngle, bool isShortLong, TriggerWaveform* s,
int window = (isShortLong ? shortToothWidth : (15 - shortToothWidth)) * mult;
int end = startAngle + mult * 15;
s->addEvent720(startAngle + window, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(end, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(startAngle + window, TriggerValue::RISE);
s->addEvent720(end, TriggerValue::FALL);
return end;
}

50
firmware/controllers/trigger/decoders/trigger_honda.cpp
View File

@ -22,20 +22,20 @@ void configureHondaCbr600(TriggerWaveform *s) {
addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 720,
0, 349);
s->addEvent720(350.0f, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(360.0f, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(350.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(360.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(360 + 0.2, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(360 + 0.2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 720,
361, 649);
s->addEvent720(650.0f, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(660.0f, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(650.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(660.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(660 + 0.2, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(660 + 0.2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 720,
@ -44,11 +44,11 @@ void configureHondaCbr600(TriggerWaveform *s) {
// exit(-1);
s->addEvent720(710.0f, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(710.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(720.0f - 1, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(720.0f - 1, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(720.0f, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(720.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
}
void configureOnePlus16(TriggerWaveform *s) {
@ -58,12 +58,12 @@ void configureOnePlus16(TriggerWaveform *s) {
float tooth = s->getCycleDuration() / count;
float width = tooth / 2; // for VR we only handle rises so width does not matter much
s->addEventAngle(1, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(5, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(1, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEventAngle(5, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
for (int i = 1; i <= count; i++) {
s->addEventAngle(tooth * i - width, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEventAngle(tooth * i, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEventAngle(tooth * i - width, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEventAngle(tooth * i, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
}
s->isSynchronizationNeeded = false;
@ -71,8 +71,8 @@ void configureOnePlus16(TriggerWaveform *s) {
static void kseriesTooth(TriggerWaveform* s, float end) {
// for VR we only handle rises so width does not matter much
s->addEvent360(end - 4, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(end , TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(end - 4, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(end , TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
// TT_HONDA_K_CRANK_12_1
@ -107,18 +107,18 @@ void configureHondaK_4_1(TriggerWaveform *s) {
angle_t start = 55.5;
angle_t end = 70.5;
s->addEvent360(start + 90 * 0, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(end + 90 * 0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(start + 90 * 0, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(end + 90 * 0, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(start + 90 * 1, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(end + 90 * 1, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(start + 90 * 1, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(end + 90 * 1, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(start + 90 * 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(end + 90 * 2, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(start + 90 * 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(end + 90 * 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(start + 90 * 3, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(end + 90 * 3, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(start + 90 * 3, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(end + 90 * 3, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(353, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(360, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(353, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(360, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}

120
firmware/controllers/trigger/decoders/trigger_mazda.cpp
View File

@ -38,21 +38,21 @@ void initializeMazdaMiataNaShape(TriggerWaveform *s) {
/**
* http://rusefi.com/forum/viewtopic.php?f=3&t=729&p=12983#p12983
*/
s->addEvent720(52.960405, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(122.635956, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(52.960405, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(122.635956, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(216.897031, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(232.640068, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(288.819688, TriggerWheel::T_PRIMARY, TriggerValue::FALL); // <-- This edge is the sync point
s->addEvent720(302.646323, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(216.897031, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(232.640068, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(288.819688, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // <-- This edge is the sync point
s->addEvent720(302.646323, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(412.448056, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(482.816719, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(412.448056, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(482.816719, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(577.035495, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(592.878113, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(662.899708, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(720.0f, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(577.035495, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(592.878113, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(662.899708, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(720.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->useOnlyPrimaryForSync = true;
}
@ -72,15 +72,15 @@ void initializeMazdaMiataNb2Crank(TriggerWaveform *s) {
s->setSecondTriggerSynchronizationGap2(0.8f, 1.8f);
// todo: NB2 fronts are inverted comparing to NB1, life is not perfect :(
s->addEventAngle(180.0f - NB_CRANK_MAGIC - 4, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(180.0f - NB_CRANK_MAGIC, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(180.0f - 4, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(180.0f, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(180.0f - NB_CRANK_MAGIC - 4, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEventAngle(180.0f - NB_CRANK_MAGIC, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEventAngle(180.0f - 4, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEventAngle(180.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
}
static void addNBCrankTooth(TriggerWaveform *s, angle_t angle, TriggerWheel const channelIndex) {
s->addEvent720(angle, channelIndex, TriggerValue::RISE);
s->addEvent720(angle + 4, channelIndex, TriggerValue::FALL);
s->addEvent720(angle, TriggerValue::RISE, channelIndex);
s->addEvent720(angle + 4, TriggerValue::FALL, channelIndex);
}
static void initializeMazdaMiataNb1ShapeWithOffset(TriggerWaveform *s, float offset) {
@ -93,25 +93,25 @@ static void initializeMazdaMiataNb1ShapeWithOffset(TriggerWaveform *s, float off
/**
* cam sensor is primary, crank sensor is secondary
*/
s->addEvent720(20.0f, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(20.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
addNBCrankTooth(s, offset + 66.0f, TriggerWheel::T_SECONDARY);
addNBCrankTooth(s, offset + 66.0f + NB_CRANK_MAGIC, TriggerWheel:: T_SECONDARY);
addNBCrankTooth(s, offset + 66.0f + 180, TriggerWheel:: T_SECONDARY);
addNBCrankTooth(s, offset + 66.0f + 180 + NB_CRANK_MAGIC, TriggerWheel:: T_SECONDARY);
s->addEvent720(340.0f, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(360.0f, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(340.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(360.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(380.0f, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(400.0f, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(380.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(400.0f, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
addNBCrankTooth(s, offset + 66.0f + 360, TriggerWheel:: T_SECONDARY);
addNBCrankTooth(s, offset + 66.0f + 360 + NB_CRANK_MAGIC, TriggerWheel:: T_SECONDARY);
addNBCrankTooth(s, offset + 66.0f + 540, TriggerWheel:: T_SECONDARY);
addNBCrankTooth(s, offset + 66.0f + 540 + NB_CRANK_MAGIC, TriggerWheel:: T_SECONDARY);
s->addEvent720(720.0f, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(720.0f, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
}
void initializeMazdaMiataVVtTestShape(TriggerWaveform *s) {
@ -127,18 +127,18 @@ void configureMazdaProtegeSOHC(TriggerWaveform *s) {
float z = 0.093;
a = 180;
s->addEvent720(a - z * 720, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(a, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(a - z * 720, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(a, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
a += 180;
s->addEvent720(a - z * 720, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(a, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(a - z * 720, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(a, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
a += 180;
s->addEvent720(a - z * 720, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(a, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(a - z * 720, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(a, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
a += 180;
s->addEvent720(a - z * 720, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(a, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(a - z * 720, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(a, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->isSynchronizationNeeded = false;
s->shapeWithoutTdc = true;
@ -150,21 +150,21 @@ void configureMazdaProtegeLx(TriggerWaveform *s) {
/**
* based on https://svn.code.sf.net/p/rusefi/code/trunk/misc/logs/1993_escort_gt/MAIN_rfi_report_2015-02-01%2017_39.csv
*/
s->addEvent720(95.329254, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(95.329254, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(95.329254 + 14.876692, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(95.329254 + 82.693557, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(95.329254 + 14.876692, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(95.329254 + 82.693557, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(95.329254 + 137.119154, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(95.329254 + 137.119154, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(95.329254 + 192.378308, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(95.329254 + 261.556418, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(95.329254 + 192.378308, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(95.329254 + 261.556418, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(95.329254 + 373.060597, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(95.329254 + 443.503184, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(95.329254 + 373.060597, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(95.329254 + 443.503184, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(95.329254 + 555.349776, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(720, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(95.329254 + 555.349776, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->tdcPosition = 137.119154;
s->isSynchronizationNeeded = false;
@ -178,14 +178,14 @@ void initializeMazdaMiataVVtCamShape(TriggerWaveform *s) {
// Nominal gap is 0.128
s->setSecondTriggerSynchronizationGap2(0.04f, 0.2f);
s->addEvent720(325, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(360, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(325, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(641, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(679, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(641, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(679, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(700, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(700, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(720, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
}
// https://rusefi.com/forum/viewtopic.php?f=17&t=2417
@ -194,26 +194,26 @@ void initializeMazdaSkyactivCam(TriggerWaveform *s) {
s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
// wide
s->addEvent360(50, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(70, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(50, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(70, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
// narrow
s->addEvent360(80, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(90, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(80, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(90, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
// wide
s->addEvent360(140, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(160, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(140, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(160, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
// narrow
s->addEvent360(170, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(170, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(180, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
// wide
s->addEvent360(250, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(270, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(250, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(270, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
// wide
s->addEvent360(340, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(360, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(340, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(360, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->setTriggerSynchronizationGap(0.43);
s->setSecondTriggerSynchronizationGap(0.78);

12
firmware/controllers/trigger/decoders/trigger_mercedes.cpp
View File

@ -6,14 +6,14 @@
void setMercedesTwoSegment(TriggerWaveform* s) {
s->initialize(FOUR_STROKE_CRANK_SENSOR, SyncEdge::Rise);
s->addEvent360(180 - 10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(180 - 10, TriggerValue::RISE);
s->addEvent360(180, TriggerValue::FALL);
s->addEvent360(227 - 10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(227, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(227 - 10, TriggerValue::RISE);
s->addEvent360(227, TriggerValue::FALL);
s->addEvent360(360 - 10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(360, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(360 - 10, TriggerValue::RISE);
s->addEvent360(360, TriggerValue::FALL);
s->setTriggerSynchronizationGap(1.35);
s->setSecondTriggerSynchronizationGap(2.84);

76
firmware/controllers/trigger/decoders/trigger_misc.cpp
View File

@ -17,11 +17,11 @@ void configureFiatIAQ_P8(TriggerWaveform * s) {
int width = 60;
s->tdcPosition = width;
s->addEvent720(width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(width, TriggerValue::RISE);
s->addEvent720(180, TriggerValue::FALL);
s->addEvent720(180 + width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(180 + width, TriggerValue::RISE);
s->addEvent720(720, TriggerValue::FALL);
s->setTriggerSynchronizationGap(3);
}
@ -40,10 +40,10 @@ void configureTriTach(TriggerWaveform * s) {
float angleDown = engineCycle / totalTeethCount * (0 + (1 - toothWidth));
float angleUp = engineCycle / totalTeethCount * (0 + 1);
s->addEventClamped(offset + angleDown, TriggerWheel::T_PRIMARY, TriggerValue::RISE, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(offset + angleDown + 0.1, TriggerWheel::T_SECONDARY, TriggerValue::RISE, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(offset + angleUp, TriggerWheel::T_PRIMARY, TriggerValue::FALL, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(offset + angleUp + 0.1, TriggerWheel::T_SECONDARY, TriggerValue::FALL, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(offset + angleDown, TriggerValue::RISE, TriggerWheel::T_PRIMARY, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(offset + angleDown + 0.1, TriggerValue::RISE, TriggerWheel::T_SECONDARY, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(offset + angleUp, TriggerValue::FALL, TriggerWheel::T_PRIMARY, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(offset + angleUp + 0.1, TriggerValue::FALL, TriggerWheel::T_SECONDARY, NO_LEFT_FILTER, NO_RIGHT_FILTER);
addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, totalTeethCount, /* skipped */ 0, toothWidth, offset, engineCycle,
@ -67,13 +67,13 @@ void configureFordPip(TriggerWaveform * s) {
*/
int oneCylinder = s->getCycleDuration() / 8;
s->addEventAngle(oneCylinder * 0.75, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(oneCylinder, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(oneCylinder * 0.75, TriggerValue::RISE);
s->addEventAngle(oneCylinder, TriggerValue::FALL);
for (int i = 2;i<=8;i++) {
s->addEventAngle(oneCylinder * (i - 0.5), TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(oneCylinder * i, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(oneCylinder * (i - 0.5), TriggerValue::RISE);
s->addEventAngle(oneCylinder * i, TriggerValue::FALL);
}
}
@ -84,20 +84,20 @@ void configureFordST170(TriggerWaveform * s) {
int total = s->getCycleDuration() / 8;
s->addEventAngle(1 * total - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(1 * total, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(1 * total - width, TriggerValue::RISE);
s->addEventAngle(1 * total, TriggerValue::FALL);
s->addEventAngle(2 * total - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(2 * total, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(2 * total - width, TriggerValue::RISE);
s->addEventAngle(2 * total, TriggerValue::FALL);
s->addEventAngle(4 * total - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(4 * total, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(4 * total - width, TriggerValue::RISE);
s->addEventAngle(4 * total, TriggerValue::FALL);
s->addEventAngle(6 * total - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(6 * total, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(6 * total - width, TriggerValue::RISE);
s->addEventAngle(6 * total, TriggerValue::FALL);
s->addEventAngle(8 * total - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(8 * total, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(8 * total - width, TriggerValue::RISE);
s->addEventAngle(8 * total, TriggerValue::FALL);
}
void configureDaihatsu4(TriggerWaveform * s) {
@ -107,18 +107,18 @@ void configureDaihatsu4(TriggerWaveform * s) {
s->setTriggerSynchronizationGap(0.125);
s->addEventAngle(30 - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(30, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(30 - width, TriggerValue::RISE);
s->addEventAngle(30, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration() / 3 - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(s->getCycleDuration() / 3, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration() / 3 - width, TriggerValue::RISE);
s->addEventAngle(s->getCycleDuration() / 3, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration() / 3 * 2 - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(s->getCycleDuration() / 3 * 2, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration() / 3 * 2 - width, TriggerValue::RISE);
s->addEventAngle(s->getCycleDuration() / 3 * 2, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration() - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(s->getCycleDuration(), TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration() - width, TriggerValue::RISE);
s->addEventAngle(s->getCycleDuration(), TriggerValue::FALL);
}
@ -133,23 +133,23 @@ void configureBarra3plus1cam(TriggerWaveform *s) {
{
int offset = 120;
s->addEventAngle(offset + 2 * 0 - 10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 0 + 0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(offset + 2 * 0 - 10, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 0 + 0, TriggerValue::FALL);
// short gap 60 deg
s->addEventAngle(offset + 2 * 60 - 10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 60 + 0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(offset + 2 * 60 - 10, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 60 + 0, TriggerValue::FALL);
// long gap 120 deg
s->addEventAngle(offset + 2 * 180 - 10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 180 + 0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(offset + 2 * 180 - 10, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 180 + 0, TriggerValue::FALL);
// long gap 120 deg
s->addEventAngle(offset + 2 * 300 - 10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 300 + 0, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(offset + 2 * 300 - 10, TriggerValue::RISE);
s->addEventAngle(offset + 2 * 300 + 0, TriggerValue::FALL);
// short gap, 60 deg back to zero/720
}

60
firmware/controllers/trigger/decoders/trigger_mitsubishi.cpp
View File

@ -18,17 +18,17 @@ void configureFordAspireTriggerWaveform(TriggerWaveform * s) {
float x = 121.90;
float y = 110.86;
s->addEvent720(x + y - 180, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(x, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(x + y, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(x + 180, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(360, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(x + y - 180, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(x, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(x + y, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(x + 180, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(x + 180 + y, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(x + 360, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(x + 360 + y, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(x + 540, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(x + 180 + y, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(x + 360, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(x + 360 + y, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(x + 540, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
/**
@ -39,18 +39,18 @@ void initializeMitsubishi4g18(TriggerWaveform *s) {
s->setTriggerSynchronizationGap(1.6666);
s->addEvent720(106.77999999999997, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(120.09999999999998, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(188.0775, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(286.33, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(298.875, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(354.91999999999996, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(366.6825, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(476.45, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(543.9749999999999, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(639.52, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(653.15, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(720.0, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(106.77999999999997, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(120.09999999999998, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(188.0775, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(286.33, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(298.875, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(354.91999999999996, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(366.6825, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(476.45, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(543.9749999999999, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(639.52, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(653.15, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(720.0, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->useOnlyPrimaryForSync = true;
}
@ -114,17 +114,17 @@ void initializeVvt3A92(TriggerWaveform *s) {
s->initialize(FOUR_STROKE_CRANK_SENSOR, SyncEdge::RiseOnly);
int w = 5;
s->addEvent360(120 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(120, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(120 - w, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(120, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(12 + 120 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(12 + 120, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(12 + 120 - w, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(12 + 120, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(240 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(240, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(240 - w, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(240, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(360 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(360, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(360 - w, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(360, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->setTriggerSynchronizationGap(9);
s->setSecondTriggerSynchronizationGap(0.11); // redundancy

32
firmware/controllers/trigger/decoders/trigger_nissan.cpp
View File

@ -24,24 +24,24 @@ void initializeNissanSR20VE_4(TriggerWaveform *s) {
float width = 4;
s->addEvent720(1 * 180 - 4 * width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(1 * 180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(1 * 180 - 4 * width, TriggerValue::RISE);
s->addEvent720(1 * 180, TriggerValue::FALL);
s->addEvent720(2 * 180 - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(2 * 180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(2 * 180 - width, TriggerValue::RISE);
s->addEvent720(2 * 180, TriggerValue::FALL);
s->addEvent720(3 * 180 - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(3 * 180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(3 * 180 - width, TriggerValue::RISE);
s->addEvent720(3 * 180, TriggerValue::FALL);
s->addEvent720(4 * 180 - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(4 * 180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(4 * 180 - width, TriggerValue::RISE);
s->addEvent720(4 * 180, TriggerValue::FALL);
}
static void addPrimaryToothEndingAt(TriggerWaveform *s, float fallAngle) {
int vvtWidth = 20;
s->addEventAngle(fallAngle - vvtWidth, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(fallAngle, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(fallAngle - vvtWidth, TriggerValue::RISE);
s->addEventAngle(fallAngle, TriggerValue::FALL);
}
@ -71,8 +71,8 @@ void makeNissanPattern(TriggerWaveform* s, size_t halfCylinderCount, size_t tota
float currentAngle = missing * toothAngle;
for (size_t i = 0; i < toothCount; i++) {
currentAngle += toothAngle;
s->addEventAngle(currentAngle - 5, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(currentAngle, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(currentAngle - 5, TriggerValue::RISE);
s->addEventAngle(currentAngle, TriggerValue::FALL);
}
}
@ -108,14 +108,14 @@ void initializeNissanQR25crank(TriggerWaveform *s) {
float currentAngle = 20;
for (int i = 0;i < 16;i++) {
currentAngle += 10;
s->addEventAngle(currentAngle - 5, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(currentAngle, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(currentAngle - 5, TriggerValue::RISE);
s->addEventAngle(currentAngle, TriggerValue::FALL);
}
}
static void addvq30tooth(TriggerWaveform *s, float angle) {
s->addEvent360(angle - 4, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(angle, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(angle - 4, TriggerValue::RISE);
s->addEvent360(angle, TriggerValue::FALL);
}
// yes, this is CAM shaft shape NOT crank shaft shape!

8
firmware/controllers/trigger/decoders/trigger_renix.cpp
View File

@ -19,15 +19,15 @@ static void commonRenix(TriggerWaveform *s) {
float currentAngle = 0;
for (int i = 0;i < 20;i++) {
s->addEventAngle(currentAngle + tooth / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(currentAngle + tooth, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(currentAngle + tooth / 2, TriggerValue::RISE);
s->addEventAngle(currentAngle + tooth, TriggerValue::FALL);
currentAngle += tooth;
}
s->addEventAngle(currentAngle + tooth, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(currentAngle + tooth, TriggerValue::RISE);
// float math error accumulates at this point so we have to spell out 180
s->addEventAngle(s->getCycleDuration(), TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(s->getCycleDuration(), TriggerValue::FALL);
}
// TT_RENIX_44_2_2

20
firmware/controllers/trigger/decoders/trigger_rover.cpp
View File

@ -26,32 +26,32 @@ void initializeRoverK(TriggerWaveform *s) {
float base = 0;
for (int i = 0; i < 2; i++) {
s->addEvent720(base + tooth / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + tooth / 2, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerValue::FALL);
base += tooth;
}
base += tooth;
for (int i = 0; i < 2; i++) {
s->addEvent720(base + tooth / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + tooth / 2, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerValue::FALL);
base += tooth;
}
base += tooth;
for (int i = 0; i < 14; i++) {
s->addEvent720(base + tooth / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + tooth / 2, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerValue::FALL);
base += tooth;
}
base += tooth;
for (int i = 0; i < 3; i++) {
s->addEvent720(base + tooth / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + tooth / 2, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerValue::FALL);
base += tooth;
}
base += tooth;
for (int i = 0; i < 11; i++) {
s->addEvent720(base + tooth / 2, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + tooth / 2, TriggerValue::RISE);
s->addEvent720(base + tooth, TriggerValue::FALL);
base += tooth;
}

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

@ -163,12 +163,12 @@ angle_t TriggerWaveform::getAngle(int index) const {
return cycleStartAngle + positionWithinCycle;
}
void TriggerWaveform::addEventClamped(angle_t angle, TriggerWheel const channelIndex, TriggerValue const stateParam, float filterLeft, float filterRight) {
void TriggerWaveform::addEventClamped(angle_t angle, TriggerValue const stateParam, TriggerWheel const channelIndex, float filterLeft, float filterRight) {
if (angle > filterLeft && angle < filterRight) {
#if EFI_UNIT_TEST
// printf("addEventClamped %f %s\r\n", angle, getTrigger_value_e(stateParam));
#endif /* EFI_UNIT_TEST */
addEvent(angle / getEngineCycle(operationMode), channelIndex, stateParam);
addEvent(angle / getEngineCycle(operationMode), stateParam, channelIndex);
}
}
@ -220,13 +220,13 @@ void TriggerWaveform::calculateExpectedEventCounts() {
/**
* Deprecated! many usages should be replaced by addEvent360
*/
void TriggerWaveform::addEvent720(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state) {
addEvent(angle / FOUR_STROKE_CYCLE_DURATION, channelIndex, state);
void TriggerWaveform::addEvent720(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) {
addEvent(angle / FOUR_STROKE_CYCLE_DURATION, state, channelIndex);
}
void TriggerWaveform::addEvent360(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state) {
void TriggerWaveform::addEvent360(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) {
efiAssertVoid(CUSTOM_OMODE_UNDEF, operationMode == FOUR_STROKE_CAM_SENSOR || operationMode == FOUR_STROKE_CRANK_SENSOR, "Not a mode for 360");
addEvent(CRANK_MODE_MULTIPLIER * angle / FOUR_STROKE_CYCLE_DURATION, channelIndex, state);
addEvent(CRANK_MODE_MULTIPLIER * angle / FOUR_STROKE_CYCLE_DURATION, state, channelIndex);
}
/**
@ -234,14 +234,14 @@ void TriggerWaveform::addEvent360(angle_t angle, TriggerWheel const channelIndex
*
* @param angle 0 to 360 or 0 to 720 depending on configuration
*/
void TriggerWaveform::addEventAngle(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state) {
addEvent(angle / getCycleDuration(), channelIndex, state);
void TriggerWaveform::addEventAngle(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) {
addEvent(angle / getCycleDuration(), state, channelIndex);
}
/**
* @param angle [0,1)
*/
void TriggerWaveform::addEvent(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state) {
void TriggerWaveform::addEvent(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex) {
efiAssertVoid(CUSTOM_OMODE_UNDEF, operationMode != OM_NONE, "operationMode not set");
if (channelIndex == TriggerWheel:: T_SECONDARY) {

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

@ -171,16 +171,16 @@ public:
bool isRiseEvent[PWM_PHASE_MAX_COUNT];
/* (0..1] angle range */
void addEvent(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state);
void addEvent(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex = TriggerWheel::T_PRIMARY);
/* (0..720] angle range
* Deprecated! many usages should be replaced by addEvent360
*/
void addEvent720(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state);
void addEvent720(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex = TriggerWheel::T_PRIMARY);
/**
* this method helps us use real world 360 degrees shape for FOUR_STROKE_CAM_SENSOR and FOUR_STROKE_CRANK_SENSOR
*/
void addEvent360(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state);
void addEvent360(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex = TriggerWheel::T_PRIMARY);
/**
* This version of 'addEvent...' family considers the angle duration of operationMode in this trigger
@ -189,12 +189,12 @@ public:
* TODO: one day kill all usages with FOUR_STROKE_CAM_SENSOR 720 cycle and add runtime prohibition
* TODO: for FOUR_STROKE_CAM_SENSOR addEvent360 is the way to go
*/
void addEventAngle(angle_t angle, TriggerWheel const channelIndex, TriggerValue const state);
void addEventAngle(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex = TriggerWheel::T_PRIMARY);
/* (0..720] angle range
* Deprecated?
*/
void addEventClamped(angle_t angle, TriggerWheel const channelIndex, TriggerValue const stateParam, float filterLeft, float filterRight);
void addEventClamped(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex, float filterLeft, float filterRight);
operation_mode_e getWheelOperationMode() const;
void initialize(operation_mode_e operationMode, SyncEdge syncEdge);

48
firmware/controllers/trigger/decoders/trigger_subaru.cpp
View File

@ -25,26 +25,26 @@ static void initialize_one_of_36_2_2_2(TriggerWaveform *s, int firstCount, int s
float base = 0;
for (int i = 0; i < firstCount; i++) {
s->addEvent720(base + narrow / 2, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + narrow, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + narrow / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(base + narrow, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
base += narrow;
}
s->addEvent720(base + wide / 2, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + wide, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + wide / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(base + wide, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
base += wide;
for (int i = 0; i < secondCount; i++) {
s->addEvent720(base + narrow / 2, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(base + narrow, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(base + narrow / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(base + narrow, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
base += narrow;
}
s->addEvent720(720 - wide - wide / 2, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(720 - wide, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(720 - wide - wide / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(720 - wide, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(720 - wide / 2, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(720 - wide / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent720(720, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
}
/**
@ -87,22 +87,22 @@ static void initializeSubaru7_6(TriggerWaveform *s, bool withCrankWheel) {
/* 97 degrees BTDC, but we have 20 degrees shift:
* 180 - 97 - 20 = 63 */
#define SUBARU76_CRANK_PULSE0(cycle) \
s->addEvent720((180 * (cycle)) + 63 - width, TriggerWheel::T_SECONDARY, TriggerValue::RISE); \
s->addEvent720((180 * (cycle)) + 63, TriggerWheel::T_SECONDARY, TriggerValue::FALL)
s->addEvent720((180 * (cycle)) + 63 - width, TriggerValue::RISE, TriggerWheel::T_SECONDARY); \
s->addEvent720((180 * (cycle)) + 63, TriggerValue::FALL, TriggerWheel::T_SECONDARY)
/* 65 degrees BTDC, but we have 20 degrees shift:
* 180 - 65 - 20 = 95 */
#define SUBARU76_CRANK_PULSE1(cycle) \
s->addEvent720((180 * (cycle)) + 95 - width, TriggerWheel::T_SECONDARY, TriggerValue::RISE); \
s->addEvent720((180 * (cycle)) + 95, TriggerWheel::T_SECONDARY, TriggerValue::FALL)
s->addEvent720((180 * (cycle)) + 95 - width, TriggerValue::RISE, TriggerWheel::T_SECONDARY); \
s->addEvent720((180 * (cycle)) + 95, TriggerValue::FALL, TriggerWheel::T_SECONDARY)
/* 10 degrees BTDC, but we have 20 degrees shift:
* 180 - 10 - 20 = 150 */
#define SUBARU76_CRANK_PULSE2(cycle) \
s->addEvent720((180 * (cycle)) + 150 - width, TriggerWheel::T_SECONDARY, TriggerValue::RISE); \
s->addEvent720((180 * (cycle)) + 150, TriggerWheel::T_SECONDARY, TriggerValue::FALL)
s->addEvent720((180 * (cycle)) + 150 - width, TriggerValue::RISE, TriggerWheel::T_SECONDARY); \
s->addEvent720((180 * (cycle)) + 150, TriggerValue::FALL, TriggerWheel::T_SECONDARY)
#define SUBARU76_CAM_PULSE(cycle, offset) \
s->addEvent720((180 * (cycle)) + (offset) - width, TriggerWheel::T_PRIMARY, TriggerValue::RISE); \
s->addEvent720((180 * (cycle)) + (offset), TriggerWheel::T_PRIMARY, TriggerValue::FALL)
s->addEvent720((180 * (cycle)) + (offset) - width, TriggerValue::RISE, TriggerWheel::T_PRIMARY); \
s->addEvent720((180 * (cycle)) + (offset), TriggerValue::FALL, TriggerWheel::T_PRIMARY)
/* (TDC#2 + 20) + 15 */
SUBARU76_CAM_PULSE(0, +15);
@ -203,14 +203,14 @@ void initializeSubaru_SVX(TriggerWaveform *s) {
#define CRANK_1_RISE(n) (CRANK_1_FALL(n) - width)
#define SUBARU_SVX_CRANK1_PULSE(n) \
s->addEventAngle(20 + (30 * (n)) + offset - width, SVX_CRANK_1, TriggerValue::RISE); \
s->addEventAngle(20 + (30 * (n)) + offset, SVX_CRANK_1, TriggerValue::FALL)
s->addEventAngle(20 + (30 * (n)) + offset - width, TriggerValue::RISE, SVX_CRANK_1); \
s->addEventAngle(20 + (30 * (n)) + offset, TriggerValue::FALL, SVX_CRANK_1)
/* cam falling edge offset from preceding Cr #1 falling edge */
float cam_offset = (10.0 + 30.0 + 30.0 + 30.0) - 90.0;
#define SUBARU_SVX_CAM_PULSE(n) \
s->addEvent720(CRANK_1_RISE(n) + cam_offset, SVX_CAM, TriggerValue::RISE); \
s->addEvent720(CRANK_1_FALL(n) + cam_offset, SVX_CAM, TriggerValue::FALL)
s->addEvent720(CRANK_1_RISE(n) + cam_offset, TriggerValue::RISE, SVX_CAM); \
s->addEvent720(CRANK_1_FALL(n) + cam_offset, TriggerValue::FALL, SVX_CAM)
#ifdef SVX_CRANK_2
/* Cr #2 signle tooth falling edge is (55 + 1) BTDC
@ -218,8 +218,8 @@ void initializeSubaru_SVX(TriggerWaveform *s) {
float crank_2_offset = (10.0 + 30.0 + 30.0) - (55.0 + 1.0);
#define SUBARU_SVX_CRANK2_PULSE(n) \
s->addEvent720(CRANK_1_RISE(n) + crank_2_offset, SVX_CRANK_2, TriggerValue::RISE); \
s->addEvent720(CRANK_1_FALL(n) + crank_2_offset, SVX_CRANK_2, TriggerValue::FALL)
s->addEvent720(CRANK_1_RISE(n) + crank_2_offset, TriggerValue::RISE, SVX_CRANK_2); \
s->addEvent720(CRANK_1_FALL(n) + crank_2_offset, TriggerValue::FALL, SVX_CRANK_2)
#else
#define SUBARU_SVX_CRANK2_PULSE(n) (void)(n)
#endif

20
firmware/controllers/trigger/decoders/trigger_suzuki.cpp
View File

@ -15,20 +15,20 @@ void initializeSuzukiG13B(TriggerWaveform *s) {
float w = 5;
float specialTooth = 20;
s->addEvent720(180 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(180 - w, TriggerValue::RISE);
s->addEvent720(180, TriggerValue::FALL);
s->addEvent720(2 * specialTooth + 180 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(2 * specialTooth + 180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(2 * specialTooth + 180 - w, TriggerValue::RISE);
s->addEvent720(2 * specialTooth + 180, TriggerValue::FALL);
s->addEvent720(360 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(360, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(360 - w, TriggerValue::RISE);
s->addEvent720(360, TriggerValue::FALL);
s->addEvent720(540 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(540, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(540 - w, TriggerValue::RISE);
s->addEvent720(540, TriggerValue::FALL);
s->addEvent720(720 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(720 - w, TriggerValue::RISE);
s->addEvent720(720, TriggerValue::FALL);
s->setTriggerSynchronizationGap(0.22);
s->setSecondTriggerSynchronizationGap(1);

48
firmware/controllers/trigger/decoders/trigger_toyota.cpp
View File

@ -25,18 +25,18 @@ void initialize2jzGE3_34_simulation_shape(TriggerWaveform *s) {
float crankAngle = 2 * crankDelta; // skipping two teeth
for (int i = 0; i < 10; i++) {
s->addEvent720(crankAngle + 5, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(crankAngle + crankDelta, TriggerWheel::T_SECONDARY, TriggerValue::FALL); // 120
s->addEvent720(crankAngle + 5, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(crankAngle + crankDelta, TriggerValue::FALL, TriggerWheel::T_SECONDARY); // 120
crankAngle += 10;
} // 2 + 10
camAngle += camD;
s->addEvent720(camAngle, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // 120
s->addEvent720(camAngle + 3, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(camAngle, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // 120
s->addEvent720(camAngle + 3, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
for (int i = 0; i < 12; i++) {
s->addEvent720(crankAngle + 5, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(crankAngle + crankDelta, TriggerWheel::T_SECONDARY, TriggerValue::FALL); // 120
s->addEvent720(crankAngle + 5, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(crankAngle + crankDelta, TriggerValue::FALL, TriggerWheel::T_SECONDARY); // 120
crankAngle += 10;
} // 2 + 22
@ -44,38 +44,38 @@ void initialize2jzGE3_34_simulation_shape(TriggerWaveform *s) {
camAngle += camD;
for (int i = 0; i < 12; i++) {
s->addEvent720(crankAngle + 5, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(crankAngle + crankDelta, TriggerWheel::T_SECONDARY, TriggerValue::FALL); // 120
s->addEvent720(crankAngle + 5, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(crankAngle + crankDelta, TriggerValue::FALL, TriggerWheel::T_SECONDARY); // 120
crankAngle += crankDelta;
} // 2 + 34
camAngle += camD;
s->addEvent720(camAngle, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // 360
s->addEvent720(camAngle + 3, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(camAngle, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // 360
s->addEvent720(camAngle + 3, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
crankAngle += 20; // skipping two teeth one more time
for (int i = 0; i < 10; i++) {
s->addEvent720(crankAngle + 5, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(crankAngle + crankDelta, TriggerWheel::T_SECONDARY, TriggerValue::FALL); // 120
s->addEvent720(crankAngle + 5, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(crankAngle + crankDelta, TriggerValue::FALL, TriggerWheel::T_SECONDARY); // 120
crankAngle += crankDelta;
} // 2 + 10
camAngle += camD;
for (int i = 0; i < 12; i++) {
s->addEvent720(crankAngle + 5, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(crankAngle + crankDelta, TriggerWheel::T_SECONDARY, TriggerValue::FALL); // 120
s->addEvent720(crankAngle + 5, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(crankAngle + crankDelta, TriggerValue::FALL, TriggerWheel::T_SECONDARY); // 120
crankAngle += crankDelta;
} // 2 + 22
camAngle += camD;
s->addEvent720(camAngle, TriggerWheel::T_PRIMARY, TriggerValue::RISE); // 600
s->addEvent720(camAngle + 3, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(camAngle, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // 600
s->addEvent720(camAngle + 3, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
for (int i = 0; i < 12; i++) {
s->addEvent720(crankAngle + 5, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(crankAngle + crankDelta, TriggerWheel::T_SECONDARY, TriggerValue::FALL); // 120
s->addEvent720(crankAngle + 5, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(crankAngle + crankDelta, TriggerValue::FALL, TriggerWheel::T_SECONDARY); // 120
crankAngle += 10;
} // 2 + 32
camAngle += camD;
@ -89,12 +89,12 @@ void initializeToyota4_1(TriggerWaveform *s) {
int w = 10;
s->addEvent360(180 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(180 - w, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(180, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(270 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(270, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(270 - w, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(270, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(360 - w, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(360, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(360 - w, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(360, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}

62
firmware/controllers/trigger/decoders/trigger_universal.cpp
View File

@ -24,14 +24,14 @@ void addSkippedToothTriggerEvents(TriggerWheel wheel, TriggerWaveform *s, int to
for (int i = 0; i < totalTeethCount - skippedCount - 1; i++) {
float angleDown = engineCycle / totalTeethCount * (i + (1 - toothWidth));
float angleUp = engineCycle / totalTeethCount * (i + 1);
s->addEventClamped(offset + angleDown, wheel, TriggerValue::RISE, filterLeft, filterRight);
s->addEventClamped(offset + angleUp, wheel, TriggerValue::FALL, filterLeft, filterRight);
s->addEventClamped(offset + angleDown, TriggerValue::RISE, wheel, filterLeft, filterRight);
s->addEventClamped(offset + angleUp, TriggerValue::FALL, wheel, filterLeft, filterRight);
}
float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth));
s->addEventClamped(offset + angleDown, wheel, TriggerValue::RISE, filterLeft, filterRight);
s->addEventClamped(offset + angleDown, TriggerValue::RISE, wheel, filterLeft, filterRight);
// custom handling of last event in order to avoid rounding error
s->addEventClamped(offset + engineCycle, wheel, TriggerValue::FALL, filterLeft, filterRight);
s->addEventClamped(offset + engineCycle, TriggerValue::FALL, wheel, filterLeft, filterRight);
}
void initializeSkippedToothTrigger(TriggerWaveform *s, int totalTeethCount, int skippedCount,
@ -65,11 +65,11 @@ void initializeSkippedToothTrigger(TriggerWaveform *s, int totalTeethCount, int
void configureOnePlusOne(TriggerWaveform *s) {
s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::Rise);
s->addEvent360( 90, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(180, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360( 90, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(180, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(270, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent360(360, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent360(270, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent360(360, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->isSynchronizationNeeded = false;
s->useOnlyPrimaryForSync = true;
@ -82,31 +82,31 @@ void configure3_1_cam(TriggerWaveform *s) {
const float crankW = 360 / 3 / 2;
TriggerWheel crank = TriggerWheel:: T_SECONDARY;
TriggerWheel crank = TriggerWheel::T_SECONDARY;
s->addEvent720(10, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(50, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(10, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(50, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
float a = 2 * crankW;
// #1/3
s->addEvent720(a += crankW, crank, TriggerValue::RISE);
s->addEvent720(a += crankW, crank, TriggerValue::FALL);
s->addEvent720(a += crankW, TriggerValue::RISE, crank);
s->addEvent720(a += crankW, TriggerValue::FALL, crank);
// #2/3
s->addEvent720(a += crankW, crank, TriggerValue::RISE);
s->addEvent720(a += crankW, crank, TriggerValue::FALL);
s->addEvent720(a += crankW, TriggerValue::RISE, crank);
s->addEvent720(a += crankW, TriggerValue::FALL, crank);
// #3/3
a += crankW;
a += crankW;
// 2nd #1/3
s->addEvent720(a += crankW, crank, TriggerValue::RISE);
s->addEvent720(a += crankW, crank, TriggerValue::FALL);
s->addEvent720(a += crankW, TriggerValue::RISE, crank);
s->addEvent720(a += crankW, TriggerValue::FALL, crank);
// 2nd #2/3
s->addEvent720(a += crankW, crank, TriggerValue::RISE);
s->addEvent720(a += crankW, crank, TriggerValue::FALL);
s->addEvent720(a += crankW, TriggerValue::RISE, crank);
s->addEvent720(a += crankW, TriggerValue::FALL, crank);
s->isSynchronizationNeeded = false;
}
@ -125,8 +125,8 @@ void configureKawaKX450F(TriggerWaveform *s) {
addSkippedToothTriggerEvents(TriggerWheel::T_PRIMARY, s, 18, 0, toothWidth, 0, engineCycle,
NO_LEFT_FILTER, 720 - 39);
s->addEvent(0.97, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent(1, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent(0.97, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent(1, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
void configureQuickStartSenderWheel(TriggerWaveform *s) {
@ -138,17 +138,17 @@ void configureQuickStartSenderWheel(TriggerWaveform *s) {
s->setTriggerSynchronizationGap(0.645);
s->setSecondTriggerSynchronizationGap(1.556);
s->addEvent360(offset + 0, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(offset + 70, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(offset + 0, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(offset + 70, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(offset + 90, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(offset + 110, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(offset + 90, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(offset + 110, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(offset + 180, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(offset + 200, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(offset + 180, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(offset + 200, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(offset + 270, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(offset + 340, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(offset + 270, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(offset + 340, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
}
// Useful for:
@ -165,6 +165,6 @@ void configure12ToothCrank(TriggerWaveform* s) {
}
// Just a single tooth with 50% duty cycle
s->addEventAngle(15, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEventAngle(30, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEventAngle(15, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEventAngle(30, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
}

16
firmware/controllers/trigger/decoders/trigger_vw.cpp
View File

@ -12,14 +12,14 @@
void setSkodaFavorit(TriggerWaveform *s) {
s->initialize(FOUR_STROKE_CRANK_SENSOR, SyncEdge::Rise);
s->addEvent360(46, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(177, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(46, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(177, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(180, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(183, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(180, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(183, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->addEvent360(226, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent360(360, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent360(226, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent360(360, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
s->tdcPosition = 180 - 46;
s->setTriggerSynchronizationGap(3.91);
@ -38,8 +38,8 @@ void setVwConfiguration(TriggerWaveform *s) {
NO_LEFT_FILTER, 690);
float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth) );
s->addEventClamped(0 + angleDown + 12, TriggerWheel::T_PRIMARY, TriggerValue::RISE, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(0 + engineCycle, TriggerWheel::T_PRIMARY, TriggerValue::FALL, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(0 + angleDown + 12, TriggerValue::RISE, TriggerWheel::T_PRIMARY, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->addEventClamped(0 + engineCycle, TriggerValue::FALL, TriggerWheel::T_PRIMARY, NO_LEFT_FILTER, NO_RIGHT_FILTER);
s->setTriggerSynchronizationGap2(1.6, 4);
s->setSecondTriggerSynchronizationGap(1); // this gap is not required to synch on perfect signal but is needed to handle to reject cranking transition noise

20
unit_tests/tests/ignition_injection/test_fuel_map.cpp
View File

@ -87,17 +87,17 @@ TEST(misc, testFuelMap) {
static void configureFordAspireTriggerWaveform(TriggerWaveform * s) {
s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::Rise);
s->addEvent720(53.747, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(121.90, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(232.76, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(300.54, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(360, TriggerWheel::T_PRIMARY, TriggerValue::RISE);
s->addEvent720(53.747, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(121.90, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(232.76, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(300.54, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
s->addEvent720(409.8412, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(478.6505, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(588.045, TriggerWheel::T_SECONDARY, TriggerValue::RISE);
s->addEvent720(657.03, TriggerWheel::T_SECONDARY, TriggerValue::FALL);
s->addEvent720(720, TriggerWheel::T_PRIMARY, TriggerValue::FALL);
s->addEvent720(409.8412, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(478.6505, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(588.045, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
s->addEvent720(657.03, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
ASSERT_FLOAT_EQ(53.747 / 720, s->wave.getSwitchTime(0));
ASSERT_EQ( TriggerValue::RISE, s->wave.getChannelState(1, 0)) << "@0";