rusEFI
The most advanced open source ECU
Loading...
Searching...
No Matches
Functions
trigger_chrysler.cpp File Reference

Detailed Description

Date
Mar 24, 2014
Author
Andrey Belomutskiy, (c) 2012-2020

Definition in file trigger_chrysler.cpp.

Functions

void initDodgeRam (TriggerWaveform *s)
 
void configureNeon2003TriggerWaveformCrank (TriggerWaveform *s)
 
void configureNeon2003TriggerWaveformCam (TriggerWaveform *s)
 
void configureDodgeStratusTriggerWaveform (TriggerWaveform *s)
 
void configureNeon1995TriggerWaveformOnlyCrank (TriggerWaveform *s)
 
void initJeep18_2_2_2 (TriggerWaveform *s)
 
static void add4cylblock (int off, TriggerWaveform *s)
 
void initJeep_XJ_4cyl_2500 (TriggerWaveform *s)
 
void configureChryslerNGC_36_2_2 (TriggerWaveform *s)
 
void configureJeepEVD_36_2_2 (TriggerWaveform *s)
 
void configureChryslerVtt15 (TriggerWaveform *s)
 

Function Documentation

◆ add4cylblock()

static void add4cylblock ( int  off,
TriggerWaveform *  s 
)
static

Definition at line 492 of file trigger_chrysler.cpp.

492 {
493 s->addEvent720(114 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
494 s->addEvent720(114 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
495
496 s->addEvent720(134 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
497 s->addEvent720(134 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
498
499 s->addEvent720(154 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
500 s->addEvent720(154 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
501
502 s->addEvent720(174 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
503 s->addEvent720(174 + off + 2, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
504}
off
beuint16_t off
Definition can_gpio_msiobox.cpp:1
TriggerWaveform::addEvent720
void addEvent720(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:246
TriggerWheel::T_SECONDARY
@ T_SECONDARY
TriggerValue::RISE
@ RISE
TriggerValue::FALL
@ FALL

Referenced by initJeep_XJ_4cyl_2500().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureChryslerNGC_36_2_2()

void configureChryslerNGC_36_2_2 ( TriggerWaveform *  s)

Definition at line 526 of file trigger_chrysler.cpp.

526 {
527 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
528
529 float wide = 30 * 2;
530 float narrow = 10 * 2;
531
532 s->setTriggerSynchronizationGap(3.5);
533 for (int i = 1; i < 15; i++) {
534 s->setTriggerSynchronizationGap4(/*gapIndex*/i, 1);
535 }
536 s->setTriggerSynchronizationGap4(/*gapIndex*/15, 0.4);
537
538 float base = 0;
539
540 for (int i = 0; i < 14; i++) {
541 s->addEventAngle(base + narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
542 s->addEventAngle(base + narrow, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
543 base += narrow;
544 }
545
546 s->addEventAngle(base + narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
547 base += narrow / 2;
548 s->addEventAngle(base + wide, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
549 base += wide;
550
551 for (int i = 0; i < 16; i++) {
552 s->addEventAngle(base + narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
553 s->addEventAngle(base + narrow, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
554 base += narrow;
555 }
556
557 // one small tooth at the end of the engine cycle
558 s->addEventAngle(s->getCycleDuration() - narrow / 2, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
559 s->addEventAngle(s->getCycleDuration(), TriggerValue::FALL, TriggerWheel::T_PRIMARY);
560}
TriggerWaveform::initialize
void initialize(operation_mode_e operationMode, SyncEdge syncEdge)
Definition trigger_structure.cpp:65
TriggerWaveform::getCycleDuration
angle_t getCycleDuration() const
Definition trigger_structure.cpp:115
TriggerWaveform::setTriggerSynchronizationGap
void setTriggerSynchronizationGap(float syncRatio)
Definition trigger_structure.cpp:423
TriggerWaveform::addEventAngle
void addEventAngle(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:266
TriggerWaveform::setTriggerSynchronizationGap4
void setTriggerSynchronizationGap4(int index, float syncRatio)
Definition trigger_structure.h:201
FOUR_STROKE_CAM_SENSOR
@ FOUR_STROKE_CAM_SENSOR
Definition rusefi_enums.h:275
TriggerWheel::T_PRIMARY
@ T_PRIMARY
SyncEdge::RiseOnly
@ RiseOnly

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureChryslerVtt15()

void configureChryslerVtt15 ( TriggerWaveform *  s)

Definition at line 599 of file trigger_chrysler.cpp.

599 {
600 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
601 int width = 5;
602
603 s->addToothRiseFall(37 + width, width);
604 s->addToothRiseFall(47 + width, width);
605
606 s->addToothRiseFall(81 + width, width);
607 s->addToothRiseFall(93 + width, width);
608 s->addToothRiseFall(105 + width, width);
609
610 s->addToothRiseFall(129 + width, width);
611 s->addToothRiseFall(139 + width, width);
612
613 s->addToothRiseFall(174 + width, width);
614 s->addToothRiseFall(186 + width, width);
615
616 s->addToothRiseFall(211 + width, width);
617
618 s->addToothRiseFall(265 + width, width);
619 s->addToothRiseFall(276 + width, width);
620 s->addToothRiseFall(286 + width, width);
621
622 s->addToothRiseFall(309 + width, width);
623
624 s->addToothRiseFall(360, width);
625
626 s->setTriggerSynchronizationGap4(/*gapIndex*/0, 2.16);
627 s->setTriggerSynchronizationGap4(/*gapIndex*/1, 2.08);
628 s->setTriggerSynchronizationGap4(/*gapIndex*/2, 0.34);
629}
TriggerWaveform::addToothRiseFall
void addToothRiseFall(angle_t angle, angle_t width=10, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:256

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureDodgeStratusTriggerWaveform()

void configureDodgeStratusTriggerWaveform ( TriggerWaveform *  s)

Definition at line 323 of file trigger_chrysler.cpp.

323 {
324 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
325 s->tdcPosition = 150;
326
327 float w = 7;
328 float g = 20;
329 s->setTriggerSynchronizationGap2(CHRYSLER_NGC6_GAP - 0.25,
330 CHRYSLER_NGC6_GAP + 0.4);
331
332 float base = 0;
333 // 2 teeth
334 float angle = base + 120.0 - w;
335 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
336 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
337 angle += g;
338 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
339 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
340
341 base += 120;
342 // 3 teeth
343 angle = base + 120.0 - w;
344 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
345 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
346 angle += g;
347 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
348 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
349 angle += g;
350 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
351 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
352
353 base += 120;
354 // 2 teeth
355 angle = base + 120.0 - w;
356 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
357 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
358 angle += g;
359 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
360 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
361
362 base += 120;
363 // just one
364 angle = base + 120.0 - w;
365 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
366 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
367
368 base += 120;
369 // 3 teeth
370 angle = base + 120.0 - w;
371 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
372 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
373 angle += g;
374 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
375 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
376 angle += g;
377 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
378 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
379
380 base += 120;
381 // just one again
382 angle = base + 120.0 - w;
383 s->addEvent720(angle, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
384 s->addEvent720(angle + w, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
385}
TriggerWaveform::setTriggerSynchronizationGap2
void setTriggerSynchronizationGap2(float syncRatioFrom, float syncRatioTo)
Definition trigger_structure.cpp:367

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureJeepEVD_36_2_2()

void configureJeepEVD_36_2_2 ( TriggerWaveform *  s)

Definition at line 562 of file trigger_chrysler.cpp.

562 {
563 s->initialize(FOUR_STROKE_CRANK_SENSOR, SyncEdge::RiseOnly);
564
565 float wide = 15 * 2;
566 float narrow = 5 * 2;
567
568 /* Last falling edge before big gap */
569 s->tdcPosition = 13.5 * narrow;
570
571 s->setTriggerSynchronizationGap3(/*gapIndex*/0, 0.2, 0.6);
572 s->setTriggerSynchronizationGap3(/*gapIndex*/1, 2.2, 3.8);
573
574 for (int i = 2; i < 17; i++) {
575 s->setTriggerSynchronizationGap3(/*gapIndex*/i, 0.7, 1.6);
576 }
577
578 /* Starting with big gap */
579 float base = wide - narrow / 2;
580
581 for (int i = 0; i < 16; i++) {
582 s->addEventAngle(base, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
583 s->addEventAngle(base + narrow / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
584 base += narrow;
585 }
586
587 /* Big tooth */
588 s->addEventAngle(base, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
589 s->addEventAngle(base + wide - narrow / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
590 base += wide;
591
592 for (int i = 0; i < 15; i++) {
593 s->addEventAngle(base, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
594 s->addEventAngle(base + narrow / 2, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
595 base += narrow;
596 }
597}
TriggerWaveform::setTriggerSynchronizationGap3
void setTriggerSynchronizationGap3(int index, float syncRatioFrom, float syncRatioTo)
Definition trigger_structure.cpp:371
FOUR_STROKE_CRANK_SENSOR
@ FOUR_STROKE_CRANK_SENSOR
Definition rusefi_enums.h:271

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureNeon1995TriggerWaveformOnlyCrank()

void configureNeon1995TriggerWaveformOnlyCrank ( TriggerWaveform *  s)

Definition at line 387 of file trigger_chrysler.cpp.

387 {
388 s->initialize(FOUR_STROKE_CRANK_SENSOR, SyncEdge::Rise);
389
390 // Nominal gap 3.25
391 s->setTriggerSynchronizationGap3(0, 1.6, 4.5);
392
393 // Nominal gap 1.0
394 s->setTriggerSynchronizationGap3(1, 0.5, 1.5);
395 s->setTriggerSynchronizationGap3(2, 0.5, 1.5);
396
397 // Nominal gap 0.168
398 s->setTriggerSynchronizationGap3(3, 0.1, 0.3);
399
400 s->tdcPosition = 279;
401
402 // voodoo magic - we always need 720 at the end
403 int base = 59;
404
405 s->addEvent360(base + 0, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
406 s->addEvent360(base + 60, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
407 s->addEvent360(base + 75, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
408 s->addEvent360(base + 82, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
409 s->addEvent360(base + 96, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
410 s->addEvent360(base + 102, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
411 s->addEvent360(base + 116, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
412 s->addEvent360(base + 122, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
413
414 s->addEvent360(base + 235, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
415 s->addEvent360(base + 242, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
416 s->addEvent360(base + 255, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
417 s->addEvent360(base + 261, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
418 s->addEvent360(base + 275, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
419 s->addEvent360(base + 281, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
420 s->addEvent360(base + 295, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
421 s->addEvent360(base + 301, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
422}
TriggerWaveform::addEvent360
void addEvent360(angle_t angle, TriggerValue const state, TriggerWheel const channelIndex=TriggerWheel::T_PRIMARY)
Definition trigger_structure.cpp:250
SyncEdge::Rise
@ Rise

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureNeon2003TriggerWaveformCam()

void configureNeon2003TriggerWaveformCam ( TriggerWaveform *  s) 
   ratio sequence is:

gap=2.17/1.46 gap=0.33/2.17 gap=1.06/0.33 gap=2.73/1.06 gap=0.47/2.73 gap=0.71/0.47 gap=1.43/0.71

7 primary (four narrow + one wide + two narrow) 64 secondary (one wide + 15 narrow + 16 narrow + one wide + 15 narrow + 16 narrow)

Definition at line 100 of file trigger_chrysler.cpp.

100 {
101// todo: move sync point so that two channel does not have false trigger issues
102 bool useOnlyPrimary = true;
103
104 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::Rise);
105
106 s->tdcPosition = 496;
107
108 /**
109 * ratio sequence is:
110gap=2.17/1.46
111gap=0.33/2.17
112gap=1.06/0.33
113gap=2.73/1.06
114gap=0.47/2.73
115gap=0.71/0.47
116gap=1.43/0.71
117 *
118 */
119
120 // these values only work well for 'useFronOnly' mode!!!
121 s->setTriggerSynchronizationGap2(0.75, 1.5);
122 s->setTriggerSynchronizationGap3(1, 0.65, 1.25);
123
124 float EPS_ANGLE = 0.3;
125
126
127 if (useOnlyPrimary) {
128 s->addEvent720(144, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
129 s->addEvent720(180, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
130
131 s->addEvent720(216, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
132 s->addEvent720(252, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
133
134 s->addEvent720(288, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
135 s->addEvent720(324, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
136
137 s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // width = 144
138 s->addEvent720(504, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // width = 36
139 s->addEvent720(540, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
140 s->addEvent720(576, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
141 s->addEvent720(612, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
142 s->addEvent720(648, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
143 s->addEvent720(684, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
144 s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
145
146 } else {
147 /**
148 * 7 primary (four narrow + one wide + two narrow)
149 * 64 secondary (one wide + 15 narrow + 16 narrow + one wide + 15 narrow + 16 narrow)
150 *
151 */
152
153 s->useOnlyPrimaryForSync = true;
154
155 s->addEvent720(25, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
156 s->addEvent720(30, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
157 s->addEvent720(35, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
158 s->addEvent720(40, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
159 s->addEvent720(45, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
160 s->addEvent720(50, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
161 s->addEvent720(55, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
162 s->addEvent720(60, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
163 s->addEvent720(65, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
164 s->addEvent720(70, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
165 s->addEvent720(75, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
166 s->addEvent720(80, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
167 s->addEvent720(85, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
168 s->addEvent720(90, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
169 s->addEvent720(95, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
170 s->addEvent720(100, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
171 s->addEvent720(105, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
172 s->addEvent720(110, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
173 s->addEvent720(115, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
174 s->addEvent720(120, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
175 s->addEvent720(125, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
176 s->addEvent720(130, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
177 s->addEvent720(135, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
178 s->addEvent720(140, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
179
180 s->addEvent720(144, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
181
182 s->addEvent720(145,TriggerValue::FALL, TriggerWheel::T_SECONDARY);
183 s->addEvent720(150, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
184 s->addEvent720(155, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
185 s->addEvent720(160, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
186 s->addEvent720(165, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
187 s->addEvent720(170, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
188 s->addEvent720(175, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
189 s->addEvent720(180 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
190
191 s->addEvent720(180, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
192
193 s->addEvent720(185, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
194 s->addEvent720(210, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
195 s->addEvent720(215, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
196
197 s->addEvent720(216, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
198
199 s->addEvent720(220, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
200 s->addEvent720(225, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
201 s->addEvent720(230, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
202 s->addEvent720(235, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
203 s->addEvent720(240, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
204 s->addEvent720(245, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
205 s->addEvent720(250, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
206
207 s->addEvent720(252, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
208
209 s->addEvent720(255, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
210
211 s->addEvent720(260, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
212 s->addEvent720(265, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
213 s->addEvent720(270, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
214 s->addEvent720(275, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
215 s->addEvent720(280, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
216 s->addEvent720(285, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
217
218 s->addEvent720(288, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
219
220 s->addEvent720(290, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
221 s->addEvent720(295, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
222 s->addEvent720(300, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
223 s->addEvent720(305, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
224 s->addEvent720(310, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
225 s->addEvent720(315, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
226 s->addEvent720(320, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
227
228 s->addEvent720(324, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
229
230 s->addEvent720(325, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
231 s->addEvent720(330, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
232 s->addEvent720(335, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
233 s->addEvent720(340, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
234 s->addEvent720(345, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
235 s->addEvent720(350, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
236 s->addEvent720(355, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
237 s->addEvent720(360 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
238
239 s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
240
241 s->addEvent720(385, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
242 s->addEvent720(390, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
243 s->addEvent720(395, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
244 s->addEvent720(400, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
245 s->addEvent720(405, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
246 s->addEvent720(410, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
247 s->addEvent720(415, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
248 s->addEvent720(420, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
249 s->addEvent720(425, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
250 s->addEvent720(430, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
251 s->addEvent720(435, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
252 s->addEvent720(440, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
253 s->addEvent720(445, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
254 s->addEvent720(450, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
255 s->addEvent720(455, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
256 s->addEvent720(460, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
257 s->addEvent720(465, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
258 s->addEvent720(470, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
259 s->addEvent720(475, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
260 s->addEvent720(480, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
261 s->addEvent720(485, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
262 s->addEvent720(490, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
263 s->addEvent720(495, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
264 s->addEvent720(500, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
265
266 s->addEvent720(504, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
267
268 s->addEvent720(505, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
269 s->addEvent720(510, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
270 s->addEvent720(515, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
271 s->addEvent720(520, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
272 s->addEvent720(525, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
273 s->addEvent720(530, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
274 s->addEvent720(535, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
275 s->addEvent720(540 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
276
277 s->addEvent720(540, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
278
279 s->addEvent720(545, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
280 s->addEvent720(570, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
281 s->addEvent720(575, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
282
283 s->addEvent720(576, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
284 s->addEvent720(580, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
285 s->addEvent720(585, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
286 s->addEvent720(590, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
287 s->addEvent720(595, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
288 s->addEvent720(600, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
289 s->addEvent720(605, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
290 s->addEvent720(610, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
291
292 s->addEvent720(612, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
293 s->addEvent720(615, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
294 s->addEvent720(620, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
295 s->addEvent720(625, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
296 s->addEvent720(630, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
297 s->addEvent720(635, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
298 s->addEvent720(640, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
299 s->addEvent720(645, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
300
301 s->addEvent720(648, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
302 s->addEvent720(650, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
303 s->addEvent720(655, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
304 s->addEvent720(660, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
305 s->addEvent720(665, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
306 s->addEvent720(670, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
307 s->addEvent720(675, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
308 s->addEvent720(680, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
309
310 s->addEvent720(684, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
311 s->addEvent720(685, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
312 s->addEvent720(690, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
313 s->addEvent720(695, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
314 s->addEvent720(700, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
315 s->addEvent720(705, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
316 s->addEvent720(710, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
317 s->addEvent720(715, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
318 s->addEvent720(720 - EPS_ANGLE, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
319 s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
320 }
321}

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ configureNeon2003TriggerWaveformCrank()

void configureNeon2003TriggerWaveformCrank ( TriggerWaveform *  s)

Definition at line 28 of file trigger_chrysler.cpp.

28 {
29 s->initialize(FOUR_STROKE_CRANK_SENSOR, SyncEdge::RiseOnly);
30
31 s->setTriggerSynchronizationGap(3);
32
33 s->addEvent360(25, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
34 s->addEvent360(30, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
35 s->addEvent360(35, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
36 s->addEvent360(40, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
37 s->addEvent360(45, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
38 s->addEvent360(50, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
39 s->addEvent360(55, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
40 s->addEvent360(60, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
41 s->addEvent360(65, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
42 s->addEvent360(70, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
43 s->addEvent360(75, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
44 s->addEvent360(80, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
45 s->addEvent360(85, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
46 s->addEvent360(90, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
47 s->addEvent360(95, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
48 s->addEvent360(100, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
49 s->addEvent360(105, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
50 s->addEvent360(110, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
51 s->addEvent360(115, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
52 s->addEvent360(120, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
53 s->addEvent360(125, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
54 s->addEvent360(130, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
55 s->addEvent360(135, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
56 s->addEvent360(140, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
57 s->addEvent360(145,TriggerValue::FALL, TriggerWheel::T_PRIMARY);
58 s->addEvent360(150, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
59 s->addEvent360(155, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
60 s->addEvent360(160, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
61 s->addEvent360(165, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
62 s->addEvent360(170, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
63 s->addEvent360(175, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
64 s->addEvent360(180, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
65 s->addEvent360(185, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
66 // gap 25
67 s->addEvent360(210, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
68 s->addEvent360(215, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
69 s->addEvent360(220, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
70 s->addEvent360(225, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
71 s->addEvent360(230, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
72 s->addEvent360(235, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
73 s->addEvent360(240, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
74 s->addEvent360(245, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
75 s->addEvent360(250, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
76 s->addEvent360(255, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
77 s->addEvent360(260, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
78 s->addEvent360(265, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
79 s->addEvent360(270, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
80 s->addEvent360(275, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
81 s->addEvent360(280, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
82 s->addEvent360(285, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
83 s->addEvent360(290, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
84 s->addEvent360(295, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
85 s->addEvent360(300, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
86 s->addEvent360(305, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
87 s->addEvent360(310, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
88 s->addEvent360(315, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
89 s->addEvent360(320, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
90 s->addEvent360(325, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
91 s->addEvent360(330, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
92 s->addEvent360(335, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
93 s->addEvent360(340, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
94 s->addEvent360(345, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
95 s->addEvent360(350, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
96 s->addEvent360(355, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
97 s->addEvent360(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
98}
Here is the call graph for this function:

◆ initDodgeRam()

void initDodgeRam ( TriggerWaveform *  s)

Definition at line 13 of file trigger_chrysler.cpp.

13 {
14
15 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::Rise);
16
17 s->isSynchronizationNeeded = false;
18
19 addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, 8, 0, 0.06, -25, 360, 0, 720);
20
21 s->addEvent720(360, TriggerValue::RISE, TriggerWheel::T_PRIMARY);
22
23 addSkippedToothTriggerEvents(TriggerWheel::T_SECONDARY, s, 8, 0, 0.06, 360 - 25, 360, 0, 720);
24
25 s->addEvent720(720, TriggerValue::FALL, TriggerWheel::T_PRIMARY);
26}
addSkippedToothTriggerEvents
void addSkippedToothTriggerEvents(TriggerWheel wheel, TriggerWaveform *s, int totalTeethCount, int skippedCount, float toothWidthPercentage, float offset, float engineCycle, float filterLeft, float filterRight)
Definition trigger_universal.cpp:22

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initJeep18_2_2_2()

void initJeep18_2_2_2 ( TriggerWaveform *  s)

Definition at line 424 of file trigger_chrysler.cpp.

424 {
425 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
426 s->isSynchronizationNeeded = false;
427 s->tdcPosition = 581;
428
429 float off = 212;
430
431 s->addEvent720(534 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
432 s->addEvent720(536 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
433 s->addEvent720(554 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
434 s->addEvent720(556 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
435 s->addEvent720(574 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
436 s->addEvent720(576 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
437 s->addEvent720(594 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
438 s->addEvent720(596 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
439
440 s->addEvent720(654 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
441 s->addEvent720(656 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
442 s->addEvent720(674 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
443 s->addEvent720(676 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
444 s->addEvent720(694 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
445 s->addEvent720(696 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
446 s->addEvent720(714 - 720 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
447 s->addEvent720(716 - 720 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
448
449
450 s->addEvent720(54 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
451 s->addEvent720(56 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
452 s->addEvent720(74 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
453 s->addEvent720(76 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
454 s->addEvent720(94 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
455 s->addEvent720(96 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
456 s->addEvent720(114 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
457 s->addEvent720(116 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
458
459 s->addEvent720(148 + off, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // 360
460
461 s->addEvent720(174 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
462 s->addEvent720(176 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
463 s->addEvent720(194 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
464 s->addEvent720(196 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
465 s->addEvent720(214 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
466 s->addEvent720(216 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
467 s->addEvent720(234 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
468 s->addEvent720(236 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
469
470 s->addEvent720(294 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
471 s->addEvent720(296 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
472 s->addEvent720(314 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
473 s->addEvent720(316 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
474 s->addEvent720(334 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
475 s->addEvent720(336 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
476 s->addEvent720(354 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
477 s->addEvent720(356 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
478
479 s->addEvent720(414 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
480 s->addEvent720(416 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
481 s->addEvent720(434 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
482 s->addEvent720(436 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
483 s->addEvent720(454 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
484 s->addEvent720(456 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
485 s->addEvent720(474 + off, TriggerValue::RISE, TriggerWheel::T_SECONDARY);
486 s->addEvent720(476 + off, TriggerValue::FALL, TriggerWheel::T_SECONDARY);
487
488 s->addEvent720(508 + off, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // 720
489
490}

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ initJeep_XJ_4cyl_2500()

void initJeep_XJ_4cyl_2500 ( TriggerWaveform *  s)

Definition at line 507 of file trigger_chrysler.cpp.

507 {
508 s->initialize(FOUR_STROKE_CAM_SENSOR, SyncEdge::RiseOnly);
509 s->isSynchronizationNeeded = false;
510 s->tdcPosition = 720 - 236;
511
512 float offset = 124;
513
514 add4cylblock(offset - 180, s);
515 add4cylblock(offset, s);
516
517 s->addEvent720(236 + offset, TriggerValue::RISE, TriggerWheel::T_PRIMARY); // 360
518
519 add4cylblock(offset + 180, s);
520 add4cylblock(offset + 360, s);
521
522 s->addEvent720(596 + offset, TriggerValue::FALL, TriggerWheel::T_PRIMARY); // 720
523
524}
add4cylblock
static void add4cylblock(int off, TriggerWaveform *s)
Definition trigger_chrysler.cpp:492
offset
uint16_t offset
Definition tunerstudio.h:0

Referenced by TriggerWaveform::initializeTriggerWaveform().

Here is the call graph for this function:
Here is the caller graph for this function:

Go to the source code of this file.

Generated on Sat Sep 27 2025 00:10:08 for rusEFI by doxygen 1.9.8