rusEFI
The most advanced open source ECU
Loading...
Searching...
No Matches
engine_configuration_generated_structures_alphax-8chan.h
Go to the documentation of this file.
1// this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt
2// by class com.rusefi.output.CHeaderConsumer
3// begin
4#pragma once
5#include "rusefi_types.h"
6// start of stft_cell_cfg_s
7struct stft_cell_cfg_s {
8 /**
9 * Maximum % that the short term fuel trim can add
10 * units: %
11 * offset 0
12 */
13 int8_t maxAdd;
14 /**
15 * Maximum % that the short term fuel trim can remove
16 * units: %
17 * offset 1
18 */
19 int8_t maxRemove;
20 /**
21 * Time constant for correction while in this cell: this sets responsiveness of the closed loop correction. A value of 5.0 means it will try to make most of the correction within 5 seconds, and a value of 1.0 will try to correct within 1 second.
22 * units: sec
23 * offset 2
24 */
25 scaled_channel<uint16_t, 10, 1> timeConstant;
26};
27static_assert(sizeof(stft_cell_cfg_s) == 4);
28
29// start of stft_s
30struct stft_s {
31 /**
32 * Below this RPM, the idle region is active, idle+300 would be a good value
33 * units: RPM
34 * offset 0
35 */
36 scaled_channel<uint8_t, 1, 50> maxIdleRegionRpm;
37 /**
38 * need 4 byte alignment
39 * units: units
40 * offset 1
41 */
42 uint8_t alignmentFill_at_1[1] = {};
43 /**
44 * Below this engine load, the overrun region is active
45 * units: load
46 * offset 2
47 */
48 uint16_t maxOverrunLoad;
49 /**
50 * Above this engine load, the power region is active
51 * units: load
52 * offset 4
53 */
54 uint16_t minPowerLoad;
55 /**
56 * When close to correct AFR, pause correction. This can improve stability by not changing the adjustment if the error is extremely small, but is not required.
57 * units: %
58 * offset 6
59 */
60 scaled_channel<uint8_t, 10, 1> deadband;
61 /**
62 * Below this temperature, correction is disabled.
63 * units: C
64 * offset 7
65 */
66 int8_t minClt;
67 /**
68 * Below this AFR, correction is paused
69 * units: afr
70 * offset 8
71 */
72 scaled_channel<uint8_t, 10, 1> minAfr;
73 /**
74 * Above this AFR, correction is paused
75 * units: afr
76 * offset 9
77 */
78 scaled_channel<uint8_t, 10, 1> maxAfr;
79 /**
80 * Delay after starting the engine before beginning closed loop correction.
81 * units: seconds
82 * offset 10
83 */
84 uint8_t startupDelay;
85 /**
86 * need 4 byte alignment
87 * units: units
88 * offset 11
89 */
90 uint8_t alignmentFill_at_11[1] = {};
91 /**
92 * offset 12
93 */
94 stft_cell_cfg_s cellCfgs[STFT_CELL_COUNT] = {};
95};
96static_assert(sizeof(stft_s) == 28);
97
98// start of pid_s
99struct pid_s {
100 /**
101 * offset 0
102 */
103 float pFactor;
104 /**
105 * offset 4
106 */
107 float iFactor;
108 /**
109 * offset 8
110 */
111 float dFactor;
112 /**
113 * Linear addition to PID logic
114 * offset 12
115 */
116 int16_t offset;
117 /**
118 * PID dTime
119 * units: ms
120 * offset 14
121 */
122 int16_t periodMs;
123 /**
124 * Output Min Duty Cycle
125 * offset 16
126 */
127 int16_t minValue;
128 /**
129 * Output Max Duty Cycle
130 * offset 18
131 */
132 int16_t maxValue;
133};
134static_assert(sizeof(pid_s) == 20);
135
136// start of MsIoBox_config_s
137struct MsIoBox_config_s {
138 /**
139 * offset 0
140 */
142 /**
143 * offset 1
144 */
146 /**
147 * need 4 byte alignment
148 * units: units
149 * offset 2
150 */
151 uint8_t alignmentFill_at_2[2] = {};
152};
153static_assert(sizeof(MsIoBox_config_s) == 4);
154
155// start of cranking_parameters_s
157 /**
158 * Base mass of the per-cylinder fuel injected during cranking. This is then modified by the multipliers for CLT, IAT, TPS ect, to give the final cranking pulse width.
159 * A reasonable starting point is 60mg per liter per cylinder.
160 * ex: 2 liter 4 cyl = 500cc/cyl, so 30mg cranking fuel.
161 * units: mg
162 * offset 0
163 */
164 float baseFuel;
165 /**
166 * This sets the RPM limit below which the ECU will use cranking fuel and ignition logic, typically this is around 350-450rpm.
167 * set cranking_rpm X
168 * units: RPM
169 * offset 4
170 */
171 int16_t rpm;
172 /**
173 * need 4 byte alignment
174 * units: units
175 * offset 6
176 */
177 uint8_t alignmentFill_at_6[2] = {};
178};
179static_assert(sizeof(cranking_parameters_s) == 8);
180
181// start of gppwm_channel
182struct gppwm_channel {
183 /**
184 * Select a pin to use for PWM or on-off output.
185 * offset 0
186 */
188 /**
189 * If an error (with a sensor, etc) is detected, this value is used instead of reading from the table.
190 * This should be a safe value for whatever hardware is connected to prevent damage.
191 * units: %
192 * offset 2
193 */
194 uint8_t dutyIfError;
195 /**
196 * need 4 byte alignment
197 * units: units
198 * offset 3
199 */
200 uint8_t alignmentFill_at_3[1] = {};
201 /**
202 * Select a frequency to run PWM at.
203 * Set this to 0hz to enable on-off mode.
204 * units: hz
205 * offset 4
206 */
207 uint16_t pwmFrequency;
208 /**
209 * Hysteresis: in on-off mode, turn the output on when the table value is above this duty.
210 * units: %
211 * offset 6
212 */
213 uint8_t onAboveDuty;
214 /**
215 * Hysteresis: in on-off mode, turn the output off when the table value is below this duty.
216 * units: %
217 * offset 7
218 */
219 uint8_t offBelowDuty;
220 /**
221 * Selects the Y axis to use for the table.
222 * offset 8
223 */
225 /**
226 * Selects the X axis to use for the table.
227 * offset 9
228 */
230 /**
231 * offset 10
232 */
233 scaled_channel<int16_t, 2, 1> loadBins[GPPWM_LOAD_COUNT] = {};
234 /**
235 * offset 26
236 */
237 int16_t rpmBins[GPPWM_RPM_COUNT] = {};
238 /**
239 * units: duty
240 * offset 42
241 */
242 scaled_channel<uint8_t, 2, 1> table[GPPWM_LOAD_COUNT][GPPWM_RPM_COUNT] = {};
243 /**
244 * need 4 byte alignment
245 * units: units
246 * offset 106
247 */
248 uint8_t alignmentFill_at_106[2] = {};
249};
250static_assert(sizeof(gppwm_channel) == 108);
251
252// start of air_pressure_sensor_config_s
254 /**
255 * kPa value at low volts
256 * units: kpa
257 * offset 0
258 */
259 float lowValue;
260 /**
261 * kPa value at high volts
262 * units: kpa
263 * offset 4
264 */
265 float highValue;
266 /**
267 * offset 8
268 */
270 /**
271 * offset 9
272 */
274 /**
275 * need 4 byte alignment
276 * units: units
277 * offset 10
278 */
279 uint8_t alignmentFill_at_10[2] = {};
280};
281static_assert(sizeof(air_pressure_sensor_config_s) == 12);
282
283// start of MAP_sensor_config_s
284struct MAP_sensor_config_s {
285 /**
286 * offset 0
287 */
288 float samplingAngleBins[MAP_ANGLE_SIZE] = {};
289 /**
290 * MAP averaging sampling start crank degree angle
291 * units: deg
292 * offset 32
293 */
294 float samplingAngle[MAP_ANGLE_SIZE] = {};
295 /**
296 * offset 64
297 */
298 float samplingWindowBins[MAP_WINDOW_SIZE] = {};
299 /**
300 * MAP averaging angle crank degree duration
301 * units: deg
302 * offset 96
303 */
304 float samplingWindow[MAP_WINDOW_SIZE] = {};
305 /**
306 * offset 128
307 */
309};
310static_assert(sizeof(MAP_sensor_config_s) == 140);
311
312/**
313 * @brief Thermistor known values
314
315*/
316// start of thermistor_conf_s
317struct thermistor_conf_s {
318 /**
319 * these values are in Celcius
320 * units: *C
321 * offset 0
322 */
323 float tempC_1;
324 /**
325 * units: *C
326 * offset 4
327 */
328 float tempC_2;
329 /**
330 * units: *C
331 * offset 8
332 */
333 float tempC_3;
334 /**
335 * units: Ohm
336 * offset 12
337 */
338 float resistance_1;
339 /**
340 * units: Ohm
341 * offset 16
342 */
343 float resistance_2;
344 /**
345 * units: Ohm
346 * offset 20
347 */
348 float resistance_3;
349 /**
350 * Pull-up resistor value on your board
351 * units: Ohm
352 * offset 24
353 */
354 float bias_resistor;
355};
356static_assert(sizeof(thermistor_conf_s) == 28);
357
358// start of linear_sensor_s
359struct linear_sensor_s {
360 /**
361 * offset 0
362 */
364 /**
365 * need 4 byte alignment
366 * units: units
367 * offset 1
368 */
369 uint8_t alignmentFill_at_1[3] = {};
370 /**
371 * units: volts
372 * offset 4
373 */
374 float v1;
375 /**
376 * offset 8
377 */
378 float value1;
379 /**
380 * units: volts
381 * offset 12
382 */
383 float v2;
384 /**
385 * offset 16
386 */
387 float value2;
388};
389static_assert(sizeof(linear_sensor_s) == 20);
390
391// start of ThermistorConf
392struct ThermistorConf {
393 /**
394 * offset 0
395 */
397 /**
398 * offset 28
399 */
401 /**
402 * need 4 byte alignment
403 * units: units
404 * offset 29
405 */
406 uint8_t alignmentFill_at_29[3] = {};
407};
408static_assert(sizeof(ThermistorConf) == 32);
409
410// start of injector_s
411struct injector_s {
412 /**
413 * This is your injector flow at the fuel pressure used in the vehicle
414 * See units setting below
415 * offset 0
416 */
417 float flow;
418 /**
419 * units: volts
420 * offset 4
421 */
422 float battLagCorrBins[VBAT_INJECTOR_CURVE_SIZE] = {};
423 /**
424 * ms delay between injector open and close dead times
425 * units: ms
426 * offset 36
427 */
428 float battLagCorr[VBAT_INJECTOR_CURVE_SIZE] = {};
429};
430static_assert(sizeof(injector_s) == 68);
431
432// start of trigger_config_s
433struct trigger_config_s {
434 /**
435 * https://github.com/rusefi/rusefi/wiki/All-Supported-Triggers
436 * offset 0
437 */
439 /**
440 * units: number
441 * offset 4
442 */
444 /**
445 * units: number
446 * offset 8
447 */
449};
450static_assert(sizeof(trigger_config_s) == 12);
451
452// start of afr_sensor_s
453struct afr_sensor_s {
454 /**
455 * offset 0
456 */
458 /**
459 * offset 1
460 */
462 /**
463 * need 4 byte alignment
464 * units: units
465 * offset 2
466 */
467 uint8_t alignmentFill_at_2[2] = {};
468 /**
469 * units: volts
470 * offset 4
471 */
472 float v1;
473 /**
474 * units: AFR
475 * offset 8
476 */
477 float value1;
478 /**
479 * units: volts
480 * offset 12
481 */
482 float v2;
483 /**
484 * units: AFR
485 * offset 16
486 */
487 float value2;
488};
489static_assert(sizeof(afr_sensor_s) == 20);
490
491// start of idle_hardware_s
492struct idle_hardware_s {
493 /**
494 * units: Hz
495 * offset 0
496 */
498 /**
499 * offset 4
500 */
502 /**
503 * offset 6
504 */
506 /**
507 * offset 8
508 */
510 /**
511 * offset 10
512 */
514 /**
515 * need 4 byte alignment
516 * units: units
517 * offset 11
518 */
519 uint8_t alignmentFill_at_11[1] = {};
520};
521static_assert(sizeof(idle_hardware_s) == 12);
522
523// start of dc_io
524struct dc_io {
525 /**
526 * offset 0
527 */
529 /**
530 * offset 2
531 */
533 /**
534 * Acts as EN pin in two-wire mode
535 * offset 4
536 */
538 /**
539 * offset 6
540 */
542};
543static_assert(sizeof(dc_io) == 8);
544
545// start of vr_threshold_s
546struct vr_threshold_s {
547 /**
548 * units: rpm
549 * offset 0
550 */
551 scaled_channel<uint8_t, 1, 50> rpmBins[6] = {};
552 /**
553 * units: volts
554 * offset 6
555 */
556 scaled_channel<uint8_t, 100, 1> values[6] = {};
557 /**
558 * offset 12
559 */
560 Gpio pin;
561 /**
562 * need 4 byte alignment
563 * units: units
564 * offset 14
565 */
566 uint8_t alignmentFill_at_14[2] = {};
567};
568static_assert(sizeof(vr_threshold_s) == 16);
569
570// start of engine_configuration_s
572 /**
573 * http://rusefi.com/wiki/index.php?title=Manual:Engine_Type
574 * set engine_type X
575 * offset 0
576 */
578 /**
579 * offset 2
580 */
582 /**
583 * Disable sensor sniffer above this rpm
584 * units: RPM
585 * offset 4
586 */
588 /**
589 * A secondary Rev limit engaged by the driver to help launch the vehicle faster
590 * units: rpm
591 * offset 6
592 */
593 uint16_t launchRpm;
594 /**
595 * set rpm_hard_limit X
596 * units: rpm
597 * offset 8
598 */
599 uint16_t rpmHardLimit;
600 /**
601 * Engine sniffer would be disabled above this rpm
602 * set engineSnifferRpmThreshold X
603 * units: RPM
604 * offset 10
605 */
607 /**
608 * Disable multispark above this engine speed.
609 * units: rpm
610 * offset 12
611 */
612 scaled_channel<uint8_t, 1, 50> multisparkMaxRpm;
613 /**
614 * Above this RPM, disable AC. Set to 0 to disable check.
615 * units: rpm
616 * offset 13
617 */
618 scaled_channel<uint8_t, 1, 50> maxAcRpm;
619 /**
620 * Above this TPS, disable AC. Set to 0 to disable check.
621 * units: %
622 * offset 14
623 */
624 uint8_t maxAcTps;
625 /**
626 * Above this CLT, disable AC to prevent overheating the engine. Set to 0 to disable check.
627 * units: deg C
628 * offset 15
629 */
630 uint8_t maxAcClt;
631 /**
632 * Just for reference really, not taken into account by any logic at this point
633 * units: CR
634 * offset 16
635 */
636 float compressionRatio;
637 /**
638 * Voltage when the wastegate is closed.
639 * You probably don't have one of these!
640 * units: mv
641 * offset 20
642 */
643 uint16_t wastegatePositionMin;
644 /**
645 * Voltage when the wastegate is fully open.
646 * You probably don't have one of these!
647 * 1 volt = 1000 units
648 * units: mv
649 * offset 22
650 */
651 uint16_t wastegatePositionMax;
652 /**
653 * Voltage when the idle valve is closed.
654 * You probably don't have one of these!
655 * units: mv
656 * offset 24
657 */
658 uint16_t idlePositionMin;
659 /**
660 * Voltage when the idle valve is open.
661 * You probably don't have one of these!
662 * 1 volt = 1000 units
663 * units: mv
664 * offset 26
665 */
666 uint16_t idlePositionMax;
667 /**
668 * offset 28
669 */
671 /**
672 * offset 30
673 */
675 /**
676 * offset 32
677 */
679 /**
680 * offset 34
681 */
683 /**
684 * Pin that activates the reduction/cut for shifting. Sometimes shared with the Launch Control pin
685 * offset 36
686 */
688 /**
689 * units: %
690 * offset 38
691 */
693 /**
694 * Time after which the throttle is considered jammed.
695 * units: sec
696 * offset 39
697 */
698 scaled_channel<uint8_t, 50, 1> etbJamTimeout;
699 /**
700 * offset 40
701 */
703 /**
704 * offset 42
705 */
707 /**
708 * Additional idle % while A/C is active
709 * units: %
710 * offset 43
711 */
712 uint8_t acIdleExtraOffset;
713 /**
714 * Value between 0 and 100 used in Manual mode
715 * units: %
716 * offset 44
717 */
718 float manIdlePosition;
719 /**
720 * This parameter sets the latest that the last multispark can occur after the main ignition event. For example, if the ignition timing is 30 degrees BTDC, and this parameter is set to 45, no multispark will ever be fired after 15 degrees ATDC.
721 * units: deg
722 * offset 48
723 */
725 /**
726 * Configures the maximum number of extra sparks to fire (does not include main spark)
727 * units: count
728 * offset 49
729 */
731 /**
732 * units: RPM
733 * offset 50
734 */
735 int16_t vvtControlMinRpm;
736 /**
737 * offset 52
738 */
740 /**
741 * offset 120
742 */
744 /**
745 * Does the vehicle have a turbo or supercharger?
746 offset 188 bit 0 */
747 bool isForcedInduction : 1 {};
748 /**
749 * On some Ford and Toyota vehicles one of the throttle sensors is not linear on the full range, i.e. in the specific range of the positions we effectively have only one sensor.
750 offset 188 bit 1 */
751 bool useFordRedundantTps : 1 {};
752 /**
753 offset 188 bit 2 */
754 bool enableKline : 1 {};
755 /**
756 offset 188 bit 3 */
757 bool overrideTriggerGaps : 1 {};
758 /**
759 * Turn on this fan when AC is on.
760 offset 188 bit 4 */
761 bool enableFan1WithAc : 1 {};
762 /**
763 * Turn on this fan when AC is on.
764 offset 188 bit 5 */
765 bool enableFan2WithAc : 1 {};
766 /**
767 * Inhibit operation of this fan while the engine is not running.
768 offset 188 bit 6 */
769 bool disableFan1WhenStopped : 1 {};
770 /**
771 * Inhibit operation of this fan while the engine is not running.
772 offset 188 bit 7 */
773 bool disableFan2WhenStopped : 1 {};
774 /**
775 * Enable secondary spark outputs that fire after the primary (rotaries, twin plug engines).
776 offset 188 bit 8 */
777 bool enableTrailingSparks : 1 {};
778 /**
779 * TLE7209 and L6205 use two-wire mode. TLE9201 and VNH2SP30 do NOT use two wire mode.
780 offset 188 bit 9 */
781 bool etb_use_two_wires : 1 {};
782 /**
783 * Subaru/BMW style where default valve position is somewhere in the middle. First solenoid opens it more while second can close it more than default position.
784 offset 188 bit 10 */
785 bool isDoubleSolenoidIdle : 1 {};
786 /**
787 offset 188 bit 11 */
788 bool useEeprom : 1 {};
789 /**
790 * Switch between Industrial and Cic PID implementation
791 offset 188 bit 12 */
792 bool useCicPidForIdle : 1 {};
793 /**
794 offset 188 bit 13 */
795 bool useTLE8888_cranking_hack : 1 {};
796 /**
797 offset 188 bit 14 */
798 bool kickStartCranking : 1 {};
799 /**
800 * This uses separate ignition timing and VE tables not only for idle conditions, also during the postcranking-to-idle taper transition (See also afterCrankingIACtaperDuration).
801 offset 188 bit 15 */
803 /**
804 offset 188 bit 16 */
805 bool launchControlEnabled : 1 {};
806 /**
807 * "Detect double trigger edges"
808 offset 188 bit 17 */
809 bool doNotFilterTriggerEdgeNoise : 1 {};
810 /**
811 offset 188 bit 18 */
812 bool antiLagEnabled : 1 {};
813 /**
814 * For cranking either use the specified fixed base fuel mass, or use the normal running math (VE table).
815 offset 188 bit 19 */
816 bool useRunningMathForCranking : 1 {};
817 /**
818 * Shall we display real life signal or just the part consumed by trigger decoder.
819 * Applies to both trigger and cam/vvt input.
820 *
821 * enable logic_level_trigger
822 offset 188 bit 20 */
824 /**
825 offset 188 bit 21 */
826 bool useTLE8888_stepper : 1 {};
827 /**
828 offset 188 bit 22 */
830 /**
831 * Print incoming and outgoing first bus CAN messages in rusEFI console
832 offset 188 bit 23 */
833 bool verboseCan : 1 {};
834 /**
835 * Experimental setting that will cause a misfire
836 * DO NOT ENABLE.
837 offset 188 bit 24 */
838 bool artificialTestMisfire : 1 {};
839 /**
840 * On some Ford and Toyota vehicles one of the pedal sensors is not linear on the full range, i.e. in the specific range of the positions we effectively have only one sensor.
841 offset 188 bit 25 */
842 bool useFordRedundantPps : 1 {};
843 /**
844 offset 188 bit 26 */
845 bool cltSensorPulldown : 1 {};
846 /**
847 offset 188 bit 27 */
848 bool iatSensorPulldown : 1 {};
849 /**
850 offset 188 bit 28 */
851 bool allowIdenticalPps : 1 {};
852 /**
853 offset 188 bit 29 */
854 bool overrideVvtTriggerGaps : 1 {};
855 /**
856 * If enabled - use onboard SPI Accelerometer, otherwise listen for CAN messages
857 offset 188 bit 30 */
858 bool useSpiImu : 1 {};
859 /**
860 offset 188 bit 31 */
861 bool enableStagedInjection : 1 {};
862 /**
863 * Closed throttle, 1 volt = 200 units.
864 * See also tps1_1AdcChannel
865 * set tps_min X
866 * units: ADC
867 * offset 192
868 */
869 int16_t tpsMin;
870 /**
871 * Full throttle.
872 * See also tps1_1AdcChannel
873 * set tps_max X
874 * units: ADC
875 * offset 194
876 */
877 int16_t tpsMax;
878 /**
879 * TPS error detection: what throttle % is unrealistically low?
880 * Also used for accelerator pedal error detection if so equipped.
881 * units: %
882 * offset 196
883 */
885 /**
886 * TPS error detection: what throttle % is unrealistically high?
887 * Also used for accelerator pedal error detection if so equipped.
888 * units: %
889 * offset 198
890 */
892 /**
893 * offset 200
894 */
896 /**
897 * Dwell duration while cranking
898 * units: ms
899 * offset 208
900 */
902 /**
903 * Once engine speed passes this value, start reducing ETB angle.
904 * units: rpm
905 * offset 212
906 */
907 uint16_t etbRevLimitStart;
908 /**
909 * This far above 'Soft limiter start', fully close the throttle. At the bottom of the range, throttle control is normal. At the top of the range, the throttle is fully closed.
910 * units: rpm
911 * offset 214
912 */
913 uint16_t etbRevLimitRange;
914 /**
915 * @see isMapAveragingEnabled
916 * offset 216
917 */
919 /**
920 * todo: merge with channel settings, use full-scale Thermistor here!
921 * offset 356
922 */
924 /**
925 * offset 388
926 */
928 /**
929 * units: deg
930 * offset 420
931 */
932 float launchTimingRetard;
933 /**
934 * value '6' for 8MHz hw osc
935 * read hip9011 datasheet for details
936 * todo split into two bit fields
937 * units: integer
938 * offset 424
939 */
941 /**
942 * iTerm min value
943 * offset 428
944 */
945 int16_t alternator_iTermMin;
946 /**
947 * iTerm max value
948 * offset 430
949 */
950 int16_t alternator_iTermMax;
951 /**
952 * @@DISPLACEMENT_TOOLTIP@@
953 * units: L
954 * offset 432
955 */
956 scaled_channel<uint16_t, 1000, 1> displacement;
957 /**
958 * units: RPM
959 * offset 434
960 */
961 uint16_t triggerSimulatorRpm;
962 /**
963 * Number of cylinder the engine has.
964 * offset 436
965 */
966 uint32_t cylindersCount;
967 /**
968 * offset 440
969 */
971 /**
972 * offset 441
973 */
974 uint8_t justATempTest;
975 /**
976 * Delta kPa for MAP sync
977 * units: kPa
978 * offset 442
979 */
980 uint8_t mapSyncThreshold;
981 /**
982 * How many % of ignition events will be cut
983 * units: %
984 * offset 443
985 */
987 /**
988 * @@CYLINDER_BORE_TOOLTIP@@
989 * units: mm
990 * offset 444
991 */
992 float cylinderBore;
993 /**
994 * This setting controls which fuel quantity control algorithm is used.
995 * Alpha-N means drive by TPS commonly only used for NA engines
996 * Speed Density requires MAP sensor and is the default choice for may installs
997 * MAF air charge is a cylinder filling based method that uses a mass air flow sensor.
998 * offset 448
999 */
1001 /**
1002 * units: %
1003 * offset 449
1004 */
1005 uint8_t ALSMaxTPS;
1006 /**
1007 * This is the injection strategy during engine start. See Fuel/Injection settings for more detail. It is suggested to use "Simultaneous".
1008 * offset 450
1009 */
1011 /**
1012 * This is where the fuel injection type is defined: "Simultaneous" means all injectors will fire together at once. "Sequential" fires the injectors on a per cylinder basis, which requires individually wired injectors. "Batched" will fire the injectors in groups.
1013 * offset 451
1014 */
1016 /**
1017 * Minimum RPM to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases.
1018 * offset 452
1019 */
1020 uint16_t boostControlMinRpm;
1021 /**
1022 * Minimum TPS to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases.
1023 * offset 454
1024 */
1025 uint8_t boostControlMinTps;
1026 /**
1027 * need 4 byte alignment
1028 * units: units
1029 * offset 455
1030 */
1031 uint8_t alignmentFill_at_455[1] = {};
1032 /**
1033 * Minimum MAP to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases.
1034 * offset 456
1035 */
1036 uint16_t boostControlMinMap;
1037 /**
1038 * need 4 byte alignment
1039 * units: units
1040 * offset 458
1041 */
1042 uint8_t alignmentFill_at_458[2] = {};
1043 /**
1044 * Ignition advance angle used during engine cranking, 5-10 degrees will work as a base setting for most engines.
1045 * There is tapering towards running timing advance
1046 * set cranking_timing_angle X
1047 * units: deg
1048 * offset 460
1049 */
1051 /**
1052 * Single coil = distributor
1053 * Individual coils = one coil per cylinder (COP, coil-near-plug), requires sequential mode
1054 * Wasted spark = Fires pairs of cylinders together, either one coil per pair of cylinders or one coil per cylinder
1055 * Two distributors = A pair of distributors, found on some BMW, Toyota and other engines
1056 * set ignition_mode X
1057 * offset 464
1058 */
1060 /**
1061 * How many consecutive gap rations have to match expected ranges for sync to happen
1062 * units: count
1063 * offset 465
1064 */
1066 /**
1067 * Above this speed, disable closed loop idle control. Set to 0 to disable (allow closed loop idle at any speed).
1068 * units: kph
1069 * offset 466
1070 */
1071 uint8_t maxIdleVss;
1072 /**
1073 * offset 467
1074 */
1075 uint8_t camDecoder2jzPrecision;
1076 /**
1077 * Expected oil pressure after starting the engine. If oil pressure does not reach this level within 5 seconds of engine start, fuel will be cut. Set to 0 to disable and always allow starting.
1078 * units: kPa
1079 * offset 468
1080 */
1081 uint16_t minOilPressureAfterStart;
1082 /**
1083 * Dynamic uses the timing map to decide the ignition timing
1084 * Static timing fixes the timing to the value set below (only use for checking static timing with a timing light).
1085 * offset 470
1086 */
1088 /**
1089 * offset 471
1090 */
1092 /**
1093 * This value is the ignition timing used when in 'fixed timing' mode, i.e. constant timing
1094 * This mode is useful when adjusting distributor location.
1095 * units: RPM
1096 * offset 472
1097 */
1099 /**
1100 * Angle between Top Dead Center (TDC) and the first trigger event.
1101 * Positive value in case of synchronization point before TDC and negative in case of synchronization point after TDC
1102 * .Knowing this angle allows us to control timing and other angles in reference to TDC.
1103 * HOWTO:
1104 * 1: Switch to fixed timing mode on 'ignition setting' dialog
1105 * 2: use an actual timing light to calibrate
1106 * 3: add/subtract until timing light confirms desired fixed timing value!'
1107 * units: deg btdc
1108 * offset 476
1109 */
1111 /**
1112 * Ratio/coefficient of input voltage dividers on your PCB. For example, use '2' if your board divides 5v into 2.5v. Use '1.66' if your board divides 5v into 3v.
1113 * units: coef
1114 * offset 480
1115 */
1117 /**
1118 * This is the ratio of the resistors for the battery voltage, measure the voltage at the battery and then adjust this number until the gauge matches the reading.
1119 * units: coef
1120 * offset 484
1121 */
1122 float vbattDividerCoeff;
1123 /**
1124 * Cooling fan turn-on temperature threshold, in Celsius
1125 * units: deg C
1126 * offset 488
1127 */
1128 float fanOnTemperature;
1129 /**
1130 * Cooling fan turn-off temperature threshold, in Celsius
1131 * units: deg C
1132 * offset 492
1133 */
1134 float fanOffTemperature;
1135 /**
1136 * offset 496
1137 */
1139 /**
1140 * need 4 byte alignment
1141 * units: units
1142 * offset 498
1143 */
1144 uint8_t alignmentFill_at_498[2] = {};
1145 /**
1146 * Number of revolutions per kilometer for the wheels your vehicle speed sensor is connected to. Use an online calculator to determine this based on your tire size.
1147 * units: revs/km
1148 * offset 500
1149 */
1150 float driveWheelRevPerKm;
1151 /**
1152 * CANbus thread period in ms
1153 * units: ms
1154 * offset 504
1155 */
1156 int canSleepPeriodMs;
1157 /**
1158 * units: index
1159 * offset 508
1160 */
1162 /**
1163 * First throttle body, first sensor. See also pedalPositionAdcChannel
1164 * offset 512
1165 */
1167 /**
1168 * This is the processor input pin that the battery voltage circuit is connected to, if you are unsure of what pin to use, check the schematic that corresponds to your PCB.
1169 * offset 513
1170 */
1172 /**
1173 * This is the processor pin that your fuel level sensor in connected to. This is a non standard input so will need to be user defined.
1174 * offset 514
1175 */
1177 /**
1178 * Second throttle body position sensor, single channel so far
1179 * offset 515
1180 */
1182 /**
1183 * 0.1 is a good default value
1184 * units: x
1185 * offset 516
1186 */
1188 /**
1189 * offset 520
1190 */
1192 /**
1193 * offset 524
1194 */
1196 /**
1197 * Extra air taper amount
1198 * units: %
1199 * offset 536
1200 */
1201 float airByRpmTaper;
1202 /**
1203 * offset 540
1204 */
1206 /**
1207 * Duty cycle to use in case of a sensor failure. This duty cycle should produce the minimum possible amount of boost. This duty is also used in case any of the minimum RPM/TPS/MAP conditions are not met.
1208 * units: %
1209 * offset 541
1210 */
1212 /**
1213 * offset 542
1214 */
1216 /**
1217 * offset 543
1218 */
1219 uint8_t acrRevolutions;
1220 /**
1221 * offset 544
1222 */
1224 /**
1225 * units: volts
1226 * offset 548
1227 */
1228 float adcVcc;
1229 /**
1230 * Magic engine phase: we compare instant MAP at X to instant MAP at x+360 angle in one complete cycle
1231 * units: Deg
1232 * offset 552
1233 */
1235 /**
1236 * Camshaft input could be used either just for engine phase detection if your trigger shape does not include cam sensor as 'primary' channel, or it could be used for Variable Valve timing on one of the camshafts.
1237 * offset 556
1238 */
1239 brain_input_pin_e camInputs[CAM_INPUTS_COUNT] = {};
1240 /**
1241 * offset 564
1242 */
1244 /**
1245 * Electronic throttle pedal position first channel
1246 * See throttlePedalPositionSecondAdcChannel for second channel
1247 * See also tps1_1AdcChannel
1248 * See throttlePedalUpVoltage and throttlePedalWOTVoltage
1249 * offset 584
1250 */
1252 /**
1253 * TPS/PPS error threshold
1254 * units: %
1255 * offset 585
1256 */
1257 scaled_channel<uint8_t, 10, 1> etbSplit;
1258 /**
1259 * offset 586
1260 */
1262 /**
1263 * offset 588
1264 */
1266 /**
1267 * offset 589
1268 */
1270 /**
1271 * need 4 byte alignment
1272 * units: units
1273 * offset 590
1274 */
1275 uint8_t alignmentFill_at_590[2] = {};
1276 /**
1277 * @see hasBaroSensor
1278 * offset 592
1279 */
1281 /**
1282 * offset 604
1283 */
1285 /**
1286 * Ignition timing to remove when a knock event occurs. Advice: 5% (mild), 10% (turbo/high comp.), 15% (high knock, e.g. GDI), 20% (spicy lump),
1287 * units: %
1288 * offset 616
1289 */
1290 scaled_channel<uint8_t, 10, 1> knockRetardAggression;
1291 /**
1292 * After a knock event, reapply timing at this rate.
1293 * units: deg/s
1294 * offset 617
1295 */
1296 scaled_channel<uint8_t, 10, 1> knockRetardReapplyRate;
1297 /**
1298 * Select which cam is used for engine sync. Other cams will be used only for VVT measurement, but not engine sync.
1299 * offset 618
1300 */
1302 /**
1303 * offset 619
1304 */
1306 /**
1307 * Number of turns of your vehicle speed sensor per turn of the wheels. For example if your sensor is on the transmission output, enter your axle/differential ratio. If you are using a hub-mounted sensor, enter a value of 1.0.
1308 * units: ratio
1309 * offset 620
1310 */
1311 scaled_channel<uint16_t, 1000, 1> vssGearRatio;
1312 /**
1313 * Set this so your vehicle speed signal is responsive, but not noisy. Larger value give smoother but slower response.
1314 * offset 622
1315 */
1316 uint8_t vssFilterReciprocal;
1317 /**
1318 * Number of pulses output per revolution of the shaft where your VSS is mounted. For example, GM applications of the T56 output 17 pulses per revolution of the transmission output shaft.
1319 * units: count
1320 * offset 623
1321 */
1322 uint8_t vssToothCount;
1323 /**
1324 * Override the Y axis (load) value used for only the Idle VE table.
1325 * Advanced users only: If you aren't sure you need this, you probably don't need this.
1326 * offset 624
1327 */
1329 /**
1330 * need 4 byte alignment
1331 * units: units
1332 * offset 625
1333 */
1334 uint8_t alignmentFill_at_625[1] = {};
1335 /**
1336 * offset 626
1337 */
1338 Gpio l9779_cs;
1339 /**
1340 * offset 628
1341 */
1342 output_pin_e injectionPins[MAX_CYLINDER_COUNT] = {};
1343 /**
1344 * offset 652
1345 */
1346 output_pin_e ignitionPins[MAX_CYLINDER_COUNT] = {};
1347 /**
1348 * offset 676
1349 */
1351 /**
1352 * offset 677
1353 */
1355 /**
1356 * offset 678
1357 */
1359 /**
1360 * offset 680
1361 */
1363 /**
1364 * How many consecutive VVT gap rations have to match expected ranges for sync to happen
1365 * units: count
1366 * offset 681
1367 */
1369 /**
1370 * Check engine light, also malfunction indicator light. Always blinks once on boot.
1371 * offset 682
1372 */
1374 /**
1375 * offset 684
1376 */
1378 /**
1379 * offset 685
1380 */
1382 /**
1383 * offset 686
1384 */
1386 /**
1387 * Some cars have a switch to indicate that clutch pedal is all the way down
1388 * offset 688
1389 */
1391 /**
1392 * offset 690
1393 */
1395 /**
1396 * offset 692
1397 */
1399 /**
1400 * offset 693
1401 */
1403 /**
1404 * offset 694
1405 */
1406 Gpio digitalPotentiometerChipSelect[DIGIPOT_COUNT] = {};
1407 /**
1408 * offset 702
1409 */
1411 /**
1412 * offset 703
1413 */
1415 /**
1416 * offset 704
1417 */
1419 /**
1420 * Digital Potentiometer is used by stock ECU stimulation code
1421 * offset 706
1422 */
1424 /**
1425 * offset 707
1426 */
1428 /**
1429 * offset 708
1430 */
1432 /**
1433 * offset 710
1434 */
1436 /**
1437 * Useful in Research&Development phase
1438 * offset 711
1439 */
1441 /**
1442 * First throttle body, second sensor.
1443 * offset 712
1444 */
1446 /**
1447 * Second throttle body, second sensor.
1448 * offset 713
1449 */
1451 /**
1452 * Electronic throttle pedal position input
1453 * Second channel
1454 * See also tps1_1AdcChannel
1455 * See throttlePedalSecondaryUpVoltage and throttlePedalSecondaryWOTVoltage
1456 * offset 714
1457 */
1459 /**
1460 * AFR, WBO, EGO - whatever you like to call it
1461 * offset 715
1462 */
1464 /**
1465 * offset 716
1466 */
1467 Gpio mc33810_cs[C_MC33810_COUNT] = {};
1468 /**
1469 * need 4 byte alignment
1470 * units: units
1471 * offset 718
1472 */
1473 uint8_t alignmentFill_at_718[2] = {};
1474 /**
1475 * 0.1 is a good default value
1476 * units: x
1477 * offset 720
1478 */
1479 float idle_antiwindupFreq;
1480 /**
1481 * offset 724
1482 */
1483 brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT] = {};
1484 /**
1485 * Minimum allowed time for the boost phase. If the boost target current is reached before this time elapses, it is assumed that the injector has failed short circuit.
1486 * units: us
1487 * offset 728
1488 */
1489 uint16_t mc33_t_min_boost;
1490 /**
1491 * offset 730
1492 */
1494 /**
1495 * need 4 byte alignment
1496 * units: units
1497 * offset 731
1498 */
1499 uint8_t alignmentFill_at_731[1] = {};
1500 /**
1501 * Ratio between the wheels and your transmission output.
1502 * units: ratio
1503 * offset 732
1504 */
1505 scaled_channel<uint16_t, 100, 1> finalGearRatio;
1506 /**
1507 * offset 734
1508 */
1510 /**
1511 * offset 736
1512 */
1514 /**
1515 * need 4 byte alignment
1516 * units: units
1517 * offset 737
1518 */
1519 uint8_t alignmentFill_at_737[1] = {};
1520 /**
1521 * Each rusEFI piece can provide synthetic trigger signal for external ECU. Sometimes these wires are routed back into trigger inputs of the same rusEFI board.
1522 * See also directSelfStimulation which is different.
1523 * offset 738
1524 */
1525 Gpio triggerSimulatorPins[TRIGGER_SIMULATOR_PIN_COUNT] = {};
1526 /**
1527 * units: g/s
1528 * offset 742
1529 */
1530 scaled_channel<uint16_t, 1000, 1> fordInjectorSmallPulseSlope;
1531 /**
1532 * offset 744
1533 */
1534 pin_output_mode_e triggerSimulatorPinModes[TRIGGER_SIMULATOR_PIN_COUNT] = {};
1535 /**
1536 * offset 746
1537 */
1539 /**
1540 * need 4 byte alignment
1541 * units: units
1542 * offset 747
1543 */
1544 uint8_t alignmentFill_at_747[1] = {};
1545 /**
1546 * On-off O2 sensor heater control. 'ON' if engine is running, 'OFF' if stopped or cranking.
1547 * offset 748
1548 */
1550 /**
1551 * offset 750
1552 */
1554 /**
1555 * units: RPM
1556 * offset 751
1557 */
1558 scaled_channel<uint8_t, 1, 100> lambdaProtectionMinRpm;
1559 /**
1560 * units: %
1561 * offset 752
1562 */
1563 scaled_channel<uint8_t, 1, 10> lambdaProtectionMinLoad;
1564 /**
1565 * need 4 byte alignment
1566 * units: units
1567 * offset 753
1568 */
1569 uint8_t alignmentFill_at_753[3] = {};
1570 /**
1571 offset 756 bit 0 */
1572 bool is_enabled_spi_1 : 1 {};
1573 /**
1574 offset 756 bit 1 */
1575 bool is_enabled_spi_2 : 1 {};
1576 /**
1577 offset 756 bit 2 */
1578 bool is_enabled_spi_3 : 1 {};
1579 /**
1580 * enable sd/disable sd
1581 offset 756 bit 3 */
1582 bool isSdCardEnabled : 1 {};
1583 /**
1584 * Use 11 bit (standard) or 29 bit (extended) IDs for rusEFI verbose CAN format.
1585 offset 756 bit 4 */
1586 bool rusefiVerbose29b : 1 {};
1587 /**
1588 offset 756 bit 5 */
1589 bool rethrowHardFault : 1 {};
1590 /**
1591 offset 756 bit 6 */
1592 bool isHip9011Enabled : 1 {};
1593 /**
1594 offset 756 bit 7 */
1595 bool requireFootOnBrakeToCrank : 1 {};
1596 /**
1597 offset 756 bit 8 */
1598 bool verboseQuad : 1 {};
1599 /**
1600 * This setting should only be used if you have a stepper motor idle valve and a stepper motor driver installed.
1601 offset 756 bit 9 */
1602 bool useStepperIdle : 1 {};
1603 /**
1604 offset 756 bit 10 */
1605 bool enabledStep1Limiter : 1 {};
1606 /**
1607 offset 756 bit 11 */
1608 bool useTpicAdvancedMode : 1 {};
1609 /**
1610 offset 756 bit 12 */
1611 bool lambdaProtectionEnable : 1 {};
1612 /**
1613 offset 756 bit 13 */
1614 bool verboseTLE8888 : 1 {};
1615 /**
1616 * CAN broadcast using custom rusEFI protocol
1617 * enable can_broadcast/disable can_broadcast
1618 offset 756 bit 14 */
1619 bool enableVerboseCanTx : 1 {};
1620 /**
1621 offset 756 bit 15 */
1622 bool externalRusEfiGdiModule : 1 {};
1623 /**
1624 offset 756 bit 16 */
1625 bool flipWboChannels : 1 {};
1626 /**
1627 * Useful for individual intakes
1628 offset 756 bit 17 */
1629 bool measureMapOnlyInOneCylinder : 1 {};
1630 /**
1631 offset 756 bit 18 */
1633 /**
1634 * If enabled, try to fire the engine before a full engine cycle has been completed using RPM estimated from the last 90 degrees of engine rotation. As soon as the trigger syncs plus 90 degrees rotation, fuel and ignition events will occur. If disabled, worst case may require up to 4 full crank rotations before any events are scheduled.
1635 offset 756 bit 19 */
1636 bool isFasterEngineSpinUpEnabled : 1 {};
1637 /**
1638 * This setting disables fuel injection while the engine is in overrun, this is useful as a fuel saving measure and to prevent back firing.
1639 offset 756 bit 20 */
1640 bool coastingFuelCutEnabled : 1 {};
1641 /**
1642 * Override the IAC position during overrun conditions to help reduce engine breaking, this can be helpful for large engines in light weight cars or engines that have trouble returning to idle.
1643 offset 756 bit 21 */
1644 bool useIacTableForCoasting : 1 {};
1645 /**
1646 offset 756 bit 22 */
1647 bool useNoiselessTriggerDecoder : 1 {};
1648 /**
1649 offset 756 bit 23 */
1650 bool useIdleTimingPidControl : 1 {};
1651 /**
1652 * Allows disabling the ETB when the engine is stopped. You may not like the power draw or PWM noise from the motor, so this lets you turn it off until it's necessary.
1653 offset 756 bit 24 */
1654 bool disableEtbWhenEngineStopped : 1 {};
1655 /**
1656 offset 756 bit 25 */
1657 bool is_enabled_spi_4 : 1 {};
1658 /**
1659 * Disable the electronic throttle motor and DC idle motor for testing.
1660 * This mode is for testing ETB/DC idle position sensors, etc without actually driving the throttle.
1661 offset 756 bit 26 */
1662 bool pauseEtbControl : 1 {};
1663 /**
1664 offset 756 bit 27 */
1665 bool tpsTpsPercentMode : 1 {};
1666 /**
1667 offset 756 bit 28 */
1668 bool verboseKLine : 1 {};
1669 /**
1670 offset 756 bit 29 */
1671 bool idleIncrementalPidCic : 1 {};
1672 /**
1673 * AEM X-Series or rusEFI Wideband
1674 offset 756 bit 30 */
1675 bool enableAemXSeries : 1 {};
1676 /**
1677 offset 756 bit 31 */
1678 bool unused32nd : 1 {};
1679 /**
1680 * offset 760
1681 */
1682 brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT] = {};
1683 /**
1684 * offset 768
1685 */
1687 /**
1688 * need 4 byte alignment
1689 * units: units
1690 * offset 769
1691 */
1692 uint8_t alignmentFill_at_769[1] = {};
1693 /**
1694 * offset 770
1695 */
1697 /**
1698 * offset 772
1699 */
1701 /**
1702 * offset 774
1703 */
1705 /**
1706 * need 4 byte alignment
1707 * units: units
1708 * offset 775
1709 */
1710 uint8_t alignmentFill_at_775[1] = {};
1711 /**
1712 * offset 776
1713 */
1714 uint32_t verboseCanBaseAddress;
1715 /**
1716 * Boost Voltage
1717 * units: v
1718 * offset 780
1719 */
1720 uint8_t mc33_hvolt;
1721 /**
1722 * need 4 byte alignment
1723 * units: units
1724 * offset 781
1725 */
1726 uint8_t alignmentFill_at_781[1] = {};
1727 /**
1728 * Minimum MAP before closed loop boost is enabled. Use to prevent misbehavior upon entering boost.
1729 * units: kPa
1730 * offset 782
1731 */
1733 /**
1734 * units: %
1735 * offset 784
1736 */
1738 /**
1739 * units: %
1740 * offset 785
1741 */
1743 /**
1744 * offset 786
1745 */
1747 /**
1748 * offset 787
1749 */
1751 /**
1752 * offset 788
1753 */
1755 /**
1756 * need 4 byte alignment
1757 * units: units
1758 * offset 789
1759 */
1760 uint8_t alignmentFill_at_789[1] = {};
1761 /**
1762 * How far above idle speed do we consider idling, i.e. coasting detection threshold.
1763 * For example, if target = 800, this param = 200, then anything below 1000 RPM is considered idle.
1764 * units: RPM
1765 * offset 790
1766 */
1767 int16_t idlePidRpmUpperLimit;
1768 /**
1769 * Apply nonlinearity correction below a pulse of this duration. Pulses longer than this duration will receive no adjustment.
1770 * units: ms
1771 * offset 792
1772 */
1773 scaled_channel<uint16_t, 1000, 1> applyNonlinearBelowPulse;
1774 /**
1775 * offset 794
1776 */
1778 /**
1779 * offset 796
1780 */
1782 /**
1783 * offset 798
1784 */
1786 /**
1787 * Some vehicles have a switch to indicate that clutch pedal is all the way up
1788 * offset 800
1789 */
1791 /**
1792 * offset 802
1793 */
1795 /**
1796 * offset 803
1797 */
1799 /**
1800 * offset 804
1801 */
1802 Gpio max31855_cs[EGT_CHANNEL_COUNT] = {};
1803 /**
1804 * Continental/GM flex fuel sensor, 50-150hz type
1805 * offset 820
1806 */
1808 /**
1809 * Since torque reduction pin is usually shared with launch control, most people have an RPM where behavior under that is Launch Control, over that is Flat Shift/Torque Reduction
1810 * units: rpm
1811 * offset 822
1812 */
1813 uint16_t torqueReductionArmingRpm;
1814 /**
1815 * offset 824
1816 */
1818 /**
1819 * offset 825
1820 */
1822 /**
1823 * Stoichiometric ratio for your secondary fuel. This value is used when the Flex Fuel sensor indicates E100, typically 9.0
1824 * units: :1
1825 * offset 826
1826 */
1827 scaled_channel<uint8_t, 10, 1> stoichRatioSecondary;
1828 /**
1829 * Maximum allowed ETB position. Some throttles go past fully open, so this allows you to limit it to fully open.
1830 * units: %
1831 * offset 827
1832 */
1833 uint8_t etbMaximumPosition;
1834 /**
1835 * Rate the ECU will log to the SD card, in hz (log lines per second).
1836 * units: hz
1837 * offset 828
1838 */
1839 uint16_t sdCardLogFrequency;
1840 /**
1841 * offset 830
1842 */
1844 /**
1845 * need 4 byte alignment
1846 * units: units
1847 * offset 831
1848 */
1849 uint8_t alignmentFill_at_831[1] = {};
1850 /**
1851 * offset 832
1852 */
1853 uint16_t launchCorrectionsEndRpm;
1854 /**
1855 * offset 834
1856 */
1858 /**
1859 * On some vehicles we can disable starter once engine is already running
1860 * offset 836
1861 */
1863 /**
1864 * need 4 byte alignment
1865 * units: units
1866 * offset 837
1867 */
1868 uint8_t alignmentFill_at_837[1] = {};
1869 /**
1870 * Some Subaru and some Mazda use double-solenoid idle air valve
1871 * offset 838
1872 */
1874 /**
1875 * See also starterControlPin
1876 * offset 840
1877 */
1879 /**
1880 * units: RPM
1881 * offset 842
1882 */
1883 scaled_channel<uint8_t, 1, 100> lambdaProtectionRestoreRpm;
1884 /**
1885 * offset 843
1886 */
1888 /**
1889 * This many MAP samples are used to estimate the current MAP. This many samples are considered, and the minimum taken. Recommended value is 1 for single-throttle engines, and your number of cylinders for individual throttle bodies.
1890 * units: count
1891 * offset 844
1892 */
1894 /**
1895 * Below this throttle position, the engine is considered idling. If you have an electronic throttle, this checks accelerator pedal position instead of throttle position, and should be set to 1-2%.
1896 * units: %
1897 * offset 848
1898 */
1900 /**
1901 * units: %
1902 * offset 850
1903 */
1905 /**
1906 * units: ADC
1907 * offset 852
1908 */
1909 uint16_t tps1SecondaryMin;
1910 /**
1911 * units: ADC
1912 * offset 854
1913 */
1914 uint16_t tps1SecondaryMax;
1915 /**
1916 * units: rpm
1917 * offset 856
1918 */
1919 int16_t antiLagRpmTreshold;
1920 /**
1921 * Maximum time to crank starter when start/stop button is pressed
1922 * units: Seconds
1923 * offset 858
1924 */
1925 uint16_t startCrankingDuration;
1926 /**
1927 * This pin is used for debugging - snap a logic analyzer on it and see if it's ever high
1928 * offset 860
1929 */
1931 /**
1932 * offset 862
1933 */
1935 /**
1936 * need 4 byte alignment
1937 * units: units
1938 * offset 863
1939 */
1940 uint8_t alignmentFill_at_863[1] = {};
1941 /**
1942 * offset 864
1943 */
1945 /**
1946 * units: %
1947 * offset 866
1948 */
1949 uint8_t lambdaProtectionMinTps;
1950 /**
1951 * Only respond once lambda is out of range for this period of time. Use to avoid transients triggering lambda protection when not needed
1952 * units: s
1953 * offset 867
1954 */
1955 scaled_channel<uint8_t, 10, 1> lambdaProtectionTimeout;
1956 /**
1957 * offset 868
1958 */
1959 script_setting_t scriptSetting[SCRIPT_SETTING_COUNT] = {};
1960 /**
1961 * offset 900
1962 */
1964 /**
1965 * offset 902
1966 */
1968 /**
1969 * offset 904
1970 */
1972 /**
1973 * offset 906
1974 */
1976 /**
1977 * offset 908
1978 */
1980 /**
1981 * offset 910
1982 */
1984 /**
1985 * offset 912
1986 */
1988 /**
1989 * offset 914
1990 */
1992 /**
1993 * offset 916
1994 */
1996 /**
1997 * Saab Combustion Detection Module knock signal input pin
1998 * also known as Saab Ion Sensing Module
1999 * offset 918
2000 */
2002 /**
2003 * offset 920
2004 */
2006 /**
2007 * rusEFI console Sensor Sniffer mode
2008 * offset 921
2009 */
2011 /**
2012 * offset 922
2013 */
2015 /**
2016 * need 4 byte alignment
2017 * units: units
2018 * offset 923
2019 */
2020 uint8_t alignmentFill_at_923[1] = {};
2021 /**
2022 offset 924 bit 0 */
2023 bool clutchUpPinInverted : 1 {};
2024 /**
2025 offset 924 bit 1 */
2026 bool clutchDownPinInverted : 1 {};
2027 /**
2028 * If enabled we use two H-bridges to drive stepper idle air valve
2029 offset 924 bit 2 */
2031 /**
2032 offset 924 bit 3 */
2033 bool multisparkEnable : 1 {};
2034 /**
2035 offset 924 bit 4 */
2036 bool enableLaunchRetard : 1 {};
2037 /**
2038 offset 924 bit 5 */
2039 bool canInputBCM : 1 {};
2040 /**
2041 * This property is useful if using rusEFI as TCM or BCM only
2042 offset 924 bit 6 */
2043 bool consumeObdSensors : 1 {};
2044 /**
2045 * Read VSS from OEM CAN bus according to selected CAN vehicle configuration.
2046 offset 924 bit 7 */
2047 bool enableCanVss : 1 {};
2048 /**
2049 offset 924 bit 8 */
2050 bool suppressWboWorkaround7048 : 1 {};
2051 /**
2052 * If enabled, adjust at a constant rate instead of a rate proportional to the current lambda error. This mode may be easier to tune, and more tolerant of sensor noise.
2053 offset 924 bit 9 */
2054 bool stftIgnoreErrorMagnitude : 1 {};
2055 /**
2056 offset 924 bit 10 */
2058 /**
2059 offset 924 bit 11 */
2060 bool enableSoftwareKnock : 1 {};
2061 /**
2062 * Verbose info in console below engineSnifferRpmThreshold
2063 * enable vvt_details
2064 offset 924 bit 12 */
2065 bool verboseVVTDecoding : 1 {};
2066 /**
2067 offset 924 bit 13 */
2068 bool invertCamVVTSignal : 1 {};
2069 /**
2070 * In Alpha-N mode, compensate for air temperature.
2071 offset 924 bit 14 */
2072 bool alphaNUseIat : 1 {};
2073 /**
2074 offset 924 bit 15 */
2075 bool knockBankCyl1 : 1 {};
2076 /**
2077 offset 924 bit 16 */
2078 bool knockBankCyl2 : 1 {};
2079 /**
2080 offset 924 bit 17 */
2081 bool knockBankCyl3 : 1 {};
2082 /**
2083 offset 924 bit 18 */
2084 bool knockBankCyl4 : 1 {};
2085 /**
2086 offset 924 bit 19 */
2087 bool knockBankCyl5 : 1 {};
2088 /**
2089 offset 924 bit 20 */
2090 bool knockBankCyl6 : 1 {};
2091 /**
2092 offset 924 bit 21 */
2093 bool knockBankCyl7 : 1 {};
2094 /**
2095 offset 924 bit 22 */
2096 bool knockBankCyl8 : 1 {};
2097 /**
2098 offset 924 bit 23 */
2099 bool knockBankCyl9 : 1 {};
2100 /**
2101 offset 924 bit 24 */
2102 bool knockBankCyl10 : 1 {};
2103 /**
2104 offset 924 bit 25 */
2105 bool knockBankCyl11 : 1 {};
2106 /**
2107 offset 924 bit 26 */
2108 bool knockBankCyl12 : 1 {};
2109 /**
2110 offset 924 bit 27 */
2111 bool tcuEnabled : 1 {};
2112 /**
2113 offset 924 bit 28 */
2114 bool canBroadcastUseChannelTwo : 1 {};
2115 /**
2116 * If enabled we use four Push-Pull outputs to directly drive stepper idle air valve coils
2117 offset 924 bit 29 */
2119 /**
2120 * Print incoming and outgoing second bus CAN messages in rusEFI console
2121 offset 924 bit 30 */
2122 bool verboseCan2 : 1 {};
2123 /**
2124 offset 924 bit 31 */
2125 bool unusedBit_332_31 : 1 {};
2126 /**
2127 * offset 928
2128 */
2129 dc_io etbIo[ETB_COUNT] = {};
2130 /**
2131 * Wastegate control Solenoid
2132 * offset 944
2133 */
2135 /**
2136 * offset 946
2137 */
2139 /**
2140 * need 4 byte alignment
2141 * units: units
2142 * offset 947
2143 */
2144 uint8_t alignmentFill_at_947[1] = {};
2145 /**
2146 * offset 948
2147 */
2149 /**
2150 * offset 950
2151 */
2153 /**
2154 * offset 952
2155 */
2157 /**
2158 * offset 972
2159 */
2161 /**
2162 * offset 973
2163 */
2165 /**
2166 * offset 974
2167 */
2169 /**
2170 * units: Hz
2171 * offset 976
2172 */
2174 /**
2175 * offset 980
2176 */
2178 /**
2179 * offset 981
2180 */
2182 /**
2183 * How long to look back for TPS-based acceleration enrichment. Increasing this time will trigger enrichment for longer when a throttle position change occurs.
2184 * units: sec
2185 * offset 982
2186 */
2187 scaled_channel<uint8_t, 20, 1> tpsAccelLookback;
2188 /**
2189 * Pause closed loop fueling after deceleration fuel cut occurs. Set this to a little longer than however long is required for normal fueling behavior to resume after fuel cut.
2190 * units: sec
2191 * offset 983
2192 */
2193 scaled_channel<uint8_t, 10, 1> noFuelTrimAfterDfcoTime;
2194 /**
2195 * Launch disabled above this speed if setting is above zero
2196 * units: Kph
2197 * offset 984
2198 */
2200 /**
2201 * Starting Launch RPM window to activate (subtracts from Launch RPM)
2202 * units: RPM
2203 * offset 988
2204 */
2205 int launchRpmWindow;
2206 /**
2207 * units: ms
2208 * offset 992
2209 */
2211 /**
2212 * offset 996
2213 */
2214 float mapExpAverageAlpha;
2215 /**
2216 * offset 1000
2217 */
2219 /**
2220 * offset 1004
2221 */
2222 float turbochargerFilter;
2223 /**
2224 * offset 1008
2225 */
2227 /**
2228 * offset 1012
2229 */
2230 float launchActivateDelay;
2231 /**
2232 * offset 1016
2233 */
2234 stft_s stft;
2235 /**
2236 * offset 1044
2237 */
2238 dc_io stepperDcIo[DC_PER_STEPPER] = {};
2239 /**
2240 * For example, BMW, GM or Chevrolet
2241 * REQUIRED for rusEFI Online
2242 * offset 1060
2243 */
2245 /**
2246 * For example, LS1 or NB2
2247 * REQUIRED for rusEFI Online
2248 * offset 1092
2249 */
2251 /**
2252 * For example, Hunchback or Orange Miata
2253 * Vehicle name has to be unique between your vehicles.
2254 * REQUIRED for rusEFI Online
2255 * offset 1124
2256 */
2258 /**
2259 * offset 1156
2260 */
2261 output_pin_e tcu_solenoid[TCU_SOLENOID_COUNT] = {};
2262 /**
2263 * offset 1168
2264 */
2265 dc_function_e etbFunctions[ETB_COUNT] = {};
2266 /**
2267 * offset 1170
2268 */
2270 /**
2271 * need 4 byte alignment
2272 * units: units
2273 * offset 1171
2274 */
2275 uint8_t alignmentFill_at_1171[1] = {};
2276 /**
2277 * offset 1172
2278 */
2280 /**
2281 * offset 1174
2282 */
2284 /**
2285 * need 4 byte alignment
2286 * units: units
2287 * offset 1175
2288 */
2289 uint8_t alignmentFill_at_1175[1] = {};
2290 /**
2291 * offset 1176
2292 */
2294 /**
2295 * offset 1178
2296 */
2297 output_pin_e luaOutputPins[LUA_PWM_COUNT] = {};
2298 /**
2299 * need 4 byte alignment
2300 * units: units
2301 * offset 1194
2302 */
2303 uint8_t alignmentFill_at_1194[2] = {};
2304 /**
2305 * Angle between cam sensor and VVT zero position
2306 * units: value
2307 * offset 1196
2308 */
2309 float vvtOffsets[CAM_INPUTS_COUNT] = {};
2310 /**
2311 * offset 1212
2312 */
2313 vr_threshold_s vrThreshold[VR_THRESHOLD_COUNT] = {};
2314 /**
2315 * offset 1260
2316 */
2317 gppwm_note_t gpPwmNote[GPPWM_CHANNELS] = {};
2318 /**
2319 * units: ADC
2320 * offset 1324
2321 */
2322 uint16_t tps2SecondaryMin;
2323 /**
2324 * units: ADC
2325 * offset 1326
2326 */
2327 uint16_t tps2SecondaryMax;
2328 /**
2329 * Select which bus the wideband controller is attached to.
2330 offset 1328 bit 0 */
2331 bool widebandOnSecondBus : 1 {};
2332 /**
2333 * Enables lambda sensor closed loop feedback for fuelling.
2334 offset 1328 bit 1 */
2336 /**
2337 * Write SD card log even when powered by USB
2338 offset 1328 bit 2 */
2339 bool alwaysWriteSdCard : 1 {};
2340 /**
2341 * Second harmonic (aka double) is usually quieter background noise
2342 offset 1328 bit 3 */
2344 /**
2345 offset 1328 bit 4 */
2346 bool yesUnderstandLocking : 1 {};
2347 /**
2348 * Sometimes we have a performance issue while printing error
2349 offset 1328 bit 5 */
2350 bool silentTriggerError : 1 {};
2351 /**
2352 offset 1328 bit 6 */
2353 bool useLinearCltSensor : 1 {};
2354 /**
2355 * enable can_read/disable can_read
2356 offset 1328 bit 7 */
2357 bool canReadEnabled : 1 {};
2358 /**
2359 * enable can_write/disable can_write. See also can1ListenMode
2360 offset 1328 bit 8 */
2361 bool canWriteEnabled : 1 {};
2362 /**
2363 offset 1328 bit 9 */
2364 bool useLinearIatSensor : 1 {};
2365 /**
2366 offset 1328 bit 10 */
2367 bool enableOilPressureProtect : 1 {};
2368 /**
2369 * Treat milliseconds value as duty cycle value, i.e. 0.5ms would become 50%
2370 offset 1328 bit 11 */
2371 bool tachPulseDurationAsDutyCycle : 1 {};
2372 /**
2373 * This enables smart alternator control and activates the extra alternator settings.
2374 offset 1328 bit 12 */
2375 bool isAlternatorControlEnabled : 1 {};
2376 /**
2377 * https://wiki.rusefi.com/Trigger-Configuration-Guide
2378 * This setting flips the signal from the primary engine speed sensor.
2379 offset 1328 bit 13 */
2380 bool invertPrimaryTriggerSignal : 1 {};
2381 /**
2382 * https://wiki.rusefi.com/Trigger-Configuration-Guide
2383 * This setting flips the signal from the secondary engine speed sensor.
2384 offset 1328 bit 14 */
2385 bool invertSecondaryTriggerSignal : 1 {};
2386 /**
2387 offset 1328 bit 15 */
2388 bool cutFuelOnHardLimit : 1 {};
2389 /**
2390 * Be careful enabling this: some engines are known to self-disassemble their valvetrain with a spark cut. Fuel cut is much safer.
2391 offset 1328 bit 16 */
2392 bool cutSparkOnHardLimit : 1 {};
2393 /**
2394 offset 1328 bit 17 */
2395 bool launchFuelCutEnable : 1 {};
2396 /**
2397 * This is the Cut Mode normally used
2398 offset 1328 bit 18 */
2399 bool launchSparkCutEnable : 1 {};
2400 /**
2401 offset 1328 bit 19 */
2402 bool torqueReductionEnabled : 1 {};
2403 /**
2404 offset 1328 bit 20 */
2406 /**
2407 offset 1328 bit 21 */
2408 bool limitTorqueReductionTime : 1 {};
2409 /**
2410 * Are you a developer troubleshooting TS over CAN ISO/TP?
2411 offset 1328 bit 22 */
2412 bool verboseIsoTp : 1 {};
2413 /**
2414 offset 1328 bit 23 */
2415 bool engineSnifferFocusOnInputs : 1 {};
2416 /**
2417 offset 1328 bit 24 */
2418 bool launchActivateInverted : 1 {};
2419 /**
2420 offset 1328 bit 25 */
2421 bool twoStroke : 1 {};
2422 /**
2423 * Where is your primary skipped wheel located?
2424 offset 1328 bit 26 */
2425 bool skippedWheelOnCam : 1 {};
2426 /**
2427 offset 1328 bit 27 */
2428 bool unusedBit_403_27 : 1 {};
2429 /**
2430 offset 1328 bit 28 */
2431 bool unusedBit_403_28 : 1 {};
2432 /**
2433 offset 1328 bit 29 */
2434 bool unusedBit_403_29 : 1 {};
2435 /**
2436 offset 1328 bit 30 */
2437 bool unusedBit_403_30 : 1 {};
2438 /**
2439 offset 1328 bit 31 */
2440 bool unusedBit_403_31 : 1 {};
2441 /**
2442 * offset 1332
2443 */
2445 /**
2446 * need 4 byte alignment
2447 * units: units
2448 * offset 1333
2449 */
2450 uint8_t alignmentFill_at_1333[1] = {};
2451 /**
2452 * A/C button input
2453 * offset 1334
2454 */
2456 /**
2457 * offset 1336
2458 */
2460 /**
2461 * Expected neutral position
2462 * units: %
2463 * offset 1337
2464 */
2465 uint8_t etbNeutralPosition;
2466 /**
2467 * See also idleRpmPid
2468 * offset 1338
2469 */
2471 /**
2472 * need 4 byte alignment
2473 * units: units
2474 * offset 1339
2475 */
2476 uint8_t alignmentFill_at_1339[1] = {};
2477 /**
2478 offset 1340 bit 0 */
2479 bool isInjectionEnabled : 1 {};
2480 /**
2481 offset 1340 bit 1 */
2482 bool isIgnitionEnabled : 1 {};
2483 /**
2484 * When enabled if TPS is held above 95% no fuel is injected while cranking to clear excess fuel from the cylinders.
2485 offset 1340 bit 2 */
2486 bool isCylinderCleanupEnabled : 1 {};
2487 /**
2488 * Should we use tables to vary tau/beta based on CLT/MAP, or just with fixed values?
2489 offset 1340 bit 3 */
2490 bool complexWallModel : 1 {};
2491 /**
2492 * RPM is measured based on last 720 degrees while instant RPM is measured based on the last 90 degrees of crank revolution
2493 offset 1340 bit 4 */
2494 bool alwaysInstantRpm : 1 {};
2495 /**
2496 offset 1340 bit 5 */
2497 bool isMapAveragingEnabled : 1 {};
2498 /**
2499 * If enabled, use separate temperature multiplier table for cranking idle position.
2500 * If disabled, use normal running multiplier table applied to the cranking base position.
2501 offset 1340 bit 6 */
2502 bool overrideCrankingIacSetting : 1 {};
2503 /**
2504 * This activates a separate ignition timing table for idle conditions, this can help idle stability by using ignition retard and advance either side of the desired idle speed. Extra advance at low idle speeds will prevent stalling and extra retard at high idle speeds can help reduce engine power and slow the idle speed.
2505 offset 1340 bit 7 */
2506 bool useSeparateAdvanceForIdle : 1 {};
2507 /**
2508 offset 1340 bit 8 */
2509 bool isWaveAnalyzerEnabled : 1 {};
2510 /**
2511 * This activates a separate fuel table for Idle, this allows fine tuning of the idle fuelling.
2512 offset 1340 bit 9 */
2513 bool useSeparateVeForIdle : 1 {};
2514 /**
2515 * Verbose info in console below engineSnifferRpmThreshold
2516 * enable trigger_details
2517 offset 1340 bit 10 */
2518 bool verboseTriggerSynchDetails : 1 {};
2519 /**
2520 offset 1340 bit 11 */
2521 bool cutFuelInAcr : 1 {};
2522 /**
2523 offset 1340 bit 12 */
2524 bool hondaK : 1 {};
2525 /**
2526 * This is needed if your coils are individually wired (COP) and you wish to use batch ignition (Wasted Spark).
2527 offset 1340 bit 13 */
2528 bool twoWireBatchIgnition : 1 {};
2529 /**
2530 * Read MAP sensor on ECU start-up to use as baro value.
2531 offset 1340 bit 14 */
2532 bool useFixedBaroCorrFromMap : 1 {};
2533 /**
2534 * In Constant mode, timing is automatically tapered to running as RPM increases.
2535 * In Table mode, the "Cranking ignition advance" table is used directly.
2536 offset 1340 bit 15 */
2538 /**
2539 * This enables the various ignition corrections during cranking (IAT, CLT and PID idle).
2540 * You probably don't need this.
2541 offset 1340 bit 16 */
2543 /**
2544 * Enable a second cranking table to use for E100 flex fuel, interpolating between the two based on flex fuel sensor.
2545 offset 1340 bit 17 */
2546 bool flexCranking : 1 {};
2547 /**
2548 * This flag allows to use a special 'PID Multiplier' table (0.0-1.0) to compensate for nonlinear nature of IAC-RPM controller
2549 offset 1340 bit 18 */
2550 bool useIacPidMultTable : 1 {};
2551 /**
2552 offset 1340 bit 19 */
2553 bool isBoostControlEnabled : 1 {};
2554 /**
2555 * Interpolates the Ignition Retard from 0 to 100% within the RPM Range
2556 offset 1340 bit 20 */
2557 bool launchSmoothRetard : 1 {};
2558 /**
2559 * Some engines are OK running semi-random sequential while other engine require phase synchronization
2560 offset 1340 bit 21 */
2562 /**
2563 * If enabled, use a curve for RPM limit (based on coolant temperature) instead of a constant value.
2564 offset 1340 bit 22 */
2565 bool useCltBasedRpmLimit : 1 {};
2566 /**
2567 * If enabled, don't wait for engine start to heat O2 sensors.
2568 * WARNING: this will reduce the life of your sensor, as condensation in the exhaust from a cold start can crack the sensing element.
2569 offset 1340 bit 23 */
2570 bool forceO2Heating : 1 {};
2571 /**
2572 * If increased VVT duty cycle increases the indicated VVT angle, set this to 'advance'. If it decreases, set this to 'retard'. Most intake cams use 'advance', and most exhaust cams use 'retard'.
2573 offset 1340 bit 24 */
2574 bool invertVvtControlIntake : 1 {};
2575 /**
2576 * If increased VVT duty cycle increases the indicated VVT angle, set this to 'advance'. If it decreases, set this to 'retard'. Most intake cams use 'advance', and most exhaust cams use 'retard'.
2577 offset 1340 bit 25 */
2578 bool invertVvtControlExhaust : 1 {};
2579 /**
2580 offset 1340 bit 26 */
2581 bool useBiQuadOnAuxSpeedSensors : 1 {};
2582 /**
2583 * 'Trigger' mode will write a high speed log of trigger events (warning: uses lots of space!). 'Normal' mode will write a standard MLG of sensors, engine function, etc. similar to the one captured in TunerStudio.
2584 offset 1340 bit 27 */
2585 bool sdTriggerLog : 1 {};
2586 /**
2587 offset 1340 bit 28 */
2588 bool ALSActivateInverted : 1 {};
2589 /**
2590 offset 1340 bit 29 */
2591 bool stepper_dc_use_two_wires : 1 {};
2592 /**
2593 offset 1340 bit 30 */
2594 bool watchOutForLinearTime : 1 {};
2595 /**
2596 offset 1340 bit 31 */
2597 bool unusedBit_446_31 : 1 {};
2598 /**
2599 * units: count
2600 * offset 1344
2601 */
2602 uint32_t engineChartSize;
2603 /**
2604 * units: mult
2605 * offset 1348
2606 */
2608 /**
2609 * offset 1352
2610 */
2611 Gpio camInputsDebug[CAM_INPUTS_COUNT] = {};
2612 /**
2613 * Idle target speed when A/C is enabled. Some cars need the extra speed to keep the AC efficient while idling.
2614 * units: RPM
2615 * offset 1360
2616 */
2617 int16_t acIdleRpmTarget;
2618 /**
2619 * set warningPeriod X
2620 * units: seconds
2621 * offset 1362
2622 */
2623 int16_t warningPeriod;
2624 /**
2625 * units: angle
2626 * offset 1364
2627 */
2629 /**
2630 * units: angle
2631 * offset 1368
2632 */
2634 /**
2635 * units: ms
2636 * offset 1372
2637 */
2639 /**
2640 * units: count
2641 * offset 1376
2642 */
2644 /**
2645 * Pedal position to realize that we need to reduce torque when the trigger pin is uuuh triggered
2646 * offset 1380
2647 */
2649 /**
2650 * Duration in ms or duty cycle depending on selected mode
2651 * offset 1384
2652 */
2654 /**
2655 * Length of time the deposited wall fuel takes to dissipate after the start of acceleration.
2656 * units: Seconds
2657 * offset 1388
2658 */
2659 float wwaeTau;
2660 /**
2661 * offset 1392
2662 */
2664 /**
2665 * offset 1412
2666 */
2667 pid_s etb;
2668 /**
2669 * offset 1432
2670 */
2671 Gpio triggerInputDebugPins[TRIGGER_INPUT_PIN_COUNT] = {};
2672 /**
2673 * RPM range above upper limit for extra air taper
2674 * units: RPM
2675 * offset 1436
2676 */
2677 int16_t airTaperRpmRange;
2678 /**
2679 * offset 1438
2680 */
2682 /**
2683 * Closed throttle#2. todo: extract these two fields into a structure
2684 * See also tps2_1AdcChannel
2685 * units: ADC
2686 * offset 1440
2687 */
2688 int16_t tps2Min;
2689 /**
2690 * Full throttle#2. tpsMax value as 10 bit ADC value. Not Voltage!
2691 * See also tps1_1AdcChannel
2692 * units: ADC
2693 * offset 1442
2694 */
2695 int16_t tps2Max;
2696 /**
2697 * See also startStopButtonPin
2698 * offset 1444
2699 */
2701 /**
2702 * offset 1446
2703 */
2705 /**
2706 * need 4 byte alignment
2707 * units: units
2708 * offset 1447
2709 */
2710 uint8_t alignmentFill_at_1447[1] = {};
2711 /**
2712 * offset 1448
2713 */
2715 /**
2716 * units: Pulse
2717 * offset 1450
2718 */
2719 uint8_t tachPulsePerRev;
2720 /**
2721 * need 4 byte alignment
2722 * units: units
2723 * offset 1451
2724 */
2725 uint8_t alignmentFill_at_1451[1] = {};
2726 /**
2727 * kPa value which is too low to be true
2728 * units: kPa
2729 * offset 1452
2730 */
2732 /**
2733 * kPa value which is too high to be true
2734 * units: kPa
2735 * offset 1456
2736 */
2738 /**
2739 * How long to wait for the spark to fire before recharging the coil for another spark.
2740 * units: ms
2741 * offset 1460
2742 */
2743 scaled_channel<uint16_t, 1000, 1> multisparkSparkDuration;
2744 /**
2745 * This sets the dwell time for subsequent sparks. The main spark's dwell is set by the dwell table.
2746 * units: ms
2747 * offset 1462
2748 */
2749 scaled_channel<uint16_t, 1000, 1> multisparkDwell;
2750 /**
2751 * See cltIdleRpmBins
2752 * offset 1464
2753 */
2755 /**
2756 * 0 = No fuel settling on port walls 1 = All the fuel settling on port walls setting this to 0 disables the wall wetting enrichment.
2757 * units: Fraction
2758 * offset 1484
2759 */
2760 float wwaeBeta;
2761 /**
2762 * See also EFI_CONSOLE_RX_BRAIN_PIN
2763 * offset 1488
2764 */
2766 /**
2767 * offset 1490
2768 */
2770 /**
2771 * offset 1492
2772 */
2773 Gpio auxValves[AUX_DIGITAL_VALVE_COUNT] = {};
2774 /**
2775 * offset 1496
2776 */
2778 /**
2779 * offset 1498
2780 */
2782 /**
2783 * units: voltage
2784 * offset 1500
2785 */
2787 /**
2788 * Pedal in the floor
2789 * units: voltage
2790 * offset 1504
2791 */
2793 /**
2794 * on IGN voltage detection turn fuel pump on to build fuel pressure
2795 * units: seconds
2796 * offset 1508
2797 */
2799 /**
2800 * If the RPM closer to target than this value, disable closed loop idle correction to prevent oscillation
2801 * units: RPM
2802 * offset 1510
2803 */
2804 int16_t idlePidRpmDeadZone;
2805 /**
2806 * For how long after the pin has been triggered will the cut/reduction stay active. After that, even if the pin is still triggered, torque is re-introduced
2807 * units: ms
2808 * offset 1512
2809 */
2810 float torqueReductionTime;
2811 /**
2812 * See Over/Undervoltage Shutdown/Retry bit in documentation
2813 offset 1516 bit 0 */
2814 bool mc33810DisableRecoveryMode : 1 {};
2815 /**
2816 offset 1516 bit 1 */
2817 bool mc33810Gpgd0Mode : 1 {};
2818 /**
2819 offset 1516 bit 2 */
2820 bool mc33810Gpgd1Mode : 1 {};
2821 /**
2822 offset 1516 bit 3 */
2823 bool mc33810Gpgd2Mode : 1 {};
2824 /**
2825 offset 1516 bit 4 */
2826 bool mc33810Gpgd3Mode : 1 {};
2827 /**
2828 * Send out board statistics
2829 offset 1516 bit 5 */
2830 bool enableExtendedCanBroadcast : 1 {};
2831 /**
2832 * global_can_data performance hack
2833 offset 1516 bit 6 */
2834 bool luaCanRxWorkaround : 1 {};
2835 /**
2836 offset 1516 bit 7 */
2837 bool flexSensorInverted : 1 {};
2838 /**
2839 offset 1516 bit 8 */
2840 bool useHardSkipInTraction : 1 {};
2841 /**
2842 * Use Aux Speed 1 as one of speeds for wheel slip ratio?
2843 offset 1516 bit 9 */
2844 bool useAuxSpeedForSlipRatio : 1 {};
2845 /**
2846 * VSS and Aux Speed 1 or Aux Speed 1 with Aux Speed 2?
2847 offset 1516 bit 10 */
2848 bool useVssAsSecondWheelSpeed : 1 {};
2849 /**
2850 offset 1516 bit 11 */
2851 bool is_enabled_spi_5 : 1 {};
2852 /**
2853 offset 1516 bit 12 */
2854 bool is_enabled_spi_6 : 1 {};
2855 /**
2856 * AEM X-Series EGT gauge kit or rusEFI EGT sensor from Wideband controller
2857 offset 1516 bit 13 */
2858 bool enableAemXSeriesEgt : 1 {};
2859 /**
2860 offset 1516 bit 14 */
2861 bool startRequestPinInverted : 1 {};
2862 /**
2863 offset 1516 bit 15 */
2864 bool tcu_rangeSensorPulldown : 1 {};
2865 /**
2866 offset 1516 bit 16 */
2867 bool brakePedalPinInverted : 1 {};
2868 /**
2869 offset 1516 bit 17 */
2870 bool devBit0 : 1 {};
2871 /**
2872 offset 1516 bit 18 */
2873 bool devBit1 : 1 {};
2874 /**
2875 offset 1516 bit 19 */
2876 bool devBit2 : 1 {};
2877 /**
2878 offset 1516 bit 20 */
2879 bool devBit3 : 1 {};
2880 /**
2881 offset 1516 bit 21 */
2882 bool devBit4 : 1 {};
2883 /**
2884 offset 1516 bit 22 */
2885 bool devBit5 : 1 {};
2886 /**
2887 offset 1516 bit 23 */
2888 bool devBit6 : 1 {};
2889 /**
2890 offset 1516 bit 24 */
2891 bool devBit7 : 1 {};
2892 /**
2893 offset 1516 bit 25 */
2894 bool invertExhaustCamVVTSignal : 1 {};
2895 /**
2896 * "Available via TS Plugin see https://rusefi.com/s/knock"
2897 offset 1516 bit 26 */
2898 bool enableKnockSpectrogram : 1 {};
2899 /**
2900 offset 1516 bit 27 */
2901 bool enableKnockSpectrogramFilter : 1 {};
2902 /**
2903 offset 1516 bit 28 */
2904 bool unusedBit_516_28 : 1 {};
2905 /**
2906 offset 1516 bit 29 */
2907 bool unusedBit_516_29 : 1 {};
2908 /**
2909 offset 1516 bit 30 */
2910 bool unusedBit_516_30 : 1 {};
2911 /**
2912 offset 1516 bit 31 */
2913 bool unusedBit_516_31 : 1 {};
2914 /**
2915 * This is the duration in cycles that the IAC will take to reach its normal idle position, it can be used to hold the idle higher for a few seconds after cranking to improve startup.\Should be 100 once tune is better
2916 * units: cycles
2917 * offset 1520
2918 */
2920 /**
2921 * IAC Value added when coasting and transitioning into idle.
2922 * units: percent
2923 * offset 1522
2924 */
2925 int16_t iacByTpsTaper;
2926 /**
2927 * offset 1524
2928 */
2930 /**
2931 * Below this speed, disable DFCO. Use this to prevent jerkiness from fuel enable/disable in low gears.
2932 * units: kph
2933 * offset 1526
2934 */
2935 uint8_t coastingFuelCutVssLow;
2936 /**
2937 * Above this speed, allow DFCO. Use this to prevent jerkiness from fuel enable/disable in low gears.
2938 * units: kph
2939 * offset 1527
2940 */
2941 uint8_t coastingFuelCutVssHigh;
2942 /**
2943 * Maximum change delta of TPS percentage over the 'length'. Actual TPS change has to be above this value in order for TPS/TPS acceleration to kick in.
2944 * units: roc
2945 * offset 1528
2946 */
2948 /**
2949 * offset 1532
2950 */
2951 brain_input_pin_e auxSpeedSensorInputPin[AUX_SPEED_SENSOR_COUNT] = {};
2952 /**
2953 * offset 1536
2954 */
2955 uint8_t totalGearsCount;
2956 /**
2957 * Sets what part of injection's is controlled by the injection phase table.
2958 * offset 1537
2959 */
2961 /**
2962 * See http://rusefi.com/s/debugmode
2963 * offset 1538
2964 */
2966 /**
2967 * Additional idle % when fan #1 is active
2968 * units: %
2969 * offset 1539
2970 */
2971 uint8_t fan1ExtraIdle;
2972 /**
2973 * Band rate for primary TTL
2974 * units: BPs
2975 * offset 1540
2976 */
2977 uint32_t uartConsoleSerialSpeed;
2978 /**
2979 * For decel we simply multiply delta of TPS and tFor decel we do not use table?!
2980 * units: roc
2981 * offset 1544
2982 */
2984 /**
2985 * Magic multiplier, we multiply delta of TPS and get fuel squirt duration
2986 * units: coeff
2987 * offset 1548
2988 */
2990 /**
2991 * How many degrees of timing advance will be reduced during the Torque Reduction Time
2992 * units: deg
2993 * offset 1552
2994 */
2996 /**
2997 * units: voltage
2998 * offset 1556
2999 */
3001 /**
3002 * Pedal in the floor
3003 * units: voltage
3004 * offset 1560
3005 */
3007 /**
3008 * offset 1564
3009 */
3011 /**
3012 * Override the Y axis (load) value used for the VE table.
3013 * Advanced users only: If you aren't sure you need this, you probably don't need this.
3014 * offset 1565
3015 */
3017 /**
3018 * offset 1566
3019 */
3021 /**
3022 * Override the Y axis (load) value used for the AFR table.
3023 * Advanced users only: If you aren't sure you need this, you probably don't need this.
3024 * offset 1567
3025 */
3027 /**
3028 * units: A
3029 * offset 1568
3030 */
3031 scaled_channel<uint8_t, 10, 1> mc33_hpfp_i_peak;
3032 /**
3033 * units: A
3034 * offset 1569
3035 */
3036 scaled_channel<uint8_t, 10, 1> mc33_hpfp_i_hold;
3037 /**
3038 * How long to deactivate power when hold current is reached before applying power again
3039 * units: us
3040 * offset 1570
3041 */
3042 uint8_t mc33_hpfp_i_hold_off;
3043 /**
3044 * Maximum amount of time the solenoid can be active before assuming a programming error
3045 * units: ms
3046 * offset 1571
3047 */
3048 uint8_t mc33_hpfp_max_hold;
3049 /**
3050 * Enable if DC-motor driver (H-bridge) inverts the signals (eg. RZ7899 on Hellen boards)
3051 offset 1572 bit 0 */
3052 bool stepperDcInvertedPins : 1 {};
3053 /**
3054 * Allow OpenBLT on Primary CAN
3055 offset 1572 bit 1 */
3056 bool canOpenBLT : 1 {};
3057 /**
3058 * Allow OpenBLT on Secondary CAN
3059 offset 1572 bit 2 */
3060 bool can2OpenBLT : 1 {};
3061 /**
3062 * Select whether to configure injector flow in volumetric flow (default, cc/min) or mass flow (g/s).
3063 offset 1572 bit 3 */
3064 bool injectorFlowAsMassFlow : 1 {};
3065 /**
3066 offset 1572 bit 4 */
3067 bool boardUseCanTerminator : 1 {};
3068 /**
3069 offset 1572 bit 5 */
3070 bool kLineDoHondaSend : 1 {};
3071 /**
3072 * ListenMode is about acknowledging CAN traffic on the protocol level. Different from canWriteEnabled
3073 offset 1572 bit 6 */
3074 bool can1ListenMode : 1 {};
3075 /**
3076 offset 1572 bit 7 */
3077 bool can2ListenMode : 1 {};
3078 /**
3079 offset 1572 bit 8 */
3080 bool unusedBit_553_8 : 1 {};
3081 /**
3082 offset 1572 bit 9 */
3083 bool unusedBit_553_9 : 1 {};
3084 /**
3085 offset 1572 bit 10 */
3086 bool unusedBit_553_10 : 1 {};
3087 /**
3088 offset 1572 bit 11 */
3089 bool unusedBit_553_11 : 1 {};
3090 /**
3091 offset 1572 bit 12 */
3092 bool unusedBit_553_12 : 1 {};
3093 /**
3094 offset 1572 bit 13 */
3095 bool unusedBit_553_13 : 1 {};
3096 /**
3097 offset 1572 bit 14 */
3098 bool unusedBit_553_14 : 1 {};
3099 /**
3100 offset 1572 bit 15 */
3101 bool unusedBit_553_15 : 1 {};
3102 /**
3103 offset 1572 bit 16 */
3104 bool unusedBit_553_16 : 1 {};
3105 /**
3106 offset 1572 bit 17 */
3107 bool unusedBit_553_17 : 1 {};
3108 /**
3109 offset 1572 bit 18 */
3110 bool unusedBit_553_18 : 1 {};
3111 /**
3112 offset 1572 bit 19 */
3113 bool unusedBit_553_19 : 1 {};
3114 /**
3115 offset 1572 bit 20 */
3116 bool unusedBit_553_20 : 1 {};
3117 /**
3118 offset 1572 bit 21 */
3119 bool unusedBit_553_21 : 1 {};
3120 /**
3121 offset 1572 bit 22 */
3122 bool unusedBit_553_22 : 1 {};
3123 /**
3124 offset 1572 bit 23 */
3125 bool unusedBit_553_23 : 1 {};
3126 /**
3127 offset 1572 bit 24 */
3128 bool unusedBit_553_24 : 1 {};
3129 /**
3130 offset 1572 bit 25 */
3131 bool unusedBit_553_25 : 1 {};
3132 /**
3133 offset 1572 bit 26 */
3134 bool unusedBit_553_26 : 1 {};
3135 /**
3136 offset 1572 bit 27 */
3137 bool unusedBit_553_27 : 1 {};
3138 /**
3139 offset 1572 bit 28 */
3140 bool unusedBit_553_28 : 1 {};
3141 /**
3142 offset 1572 bit 29 */
3143 bool unusedBit_553_29 : 1 {};
3144 /**
3145 offset 1572 bit 30 */
3146 bool unusedBit_553_30 : 1 {};
3147 /**
3148 offset 1572 bit 31 */
3149 bool unusedBit_553_31 : 1 {};
3150 /**
3151 * offset 1576
3152 */
3153 uint8_t camDecoder2jzPosition;
3154 /**
3155 * offset 1577
3156 */
3158 /**
3159 * Duration of each test pulse
3160 * units: ms
3161 * offset 1578
3162 */
3163 scaled_channel<uint16_t, 100, 1> benchTestOnTime;
3164 /**
3165 * units: %
3166 * offset 1580
3167 */
3169 /**
3170 * units: %
3171 * offset 1581
3172 */
3173 scaled_channel<uint8_t, 1, 10> lambdaProtectionRestoreLoad;
3174 /**
3175 * offset 1582
3176 */
3178 /**
3179 * need 4 byte alignment
3180 * units: units
3181 * offset 1583
3182 */
3183 uint8_t alignmentFill_at_1583[1] = {};
3184 /**
3185 * offset 1584
3186 */
3188 /**
3189 * offset 1586
3190 */
3192 /**
3193 * offset 1588
3194 */
3196 /**
3197 * offset 1589
3198 */
3200 /**
3201 * Override the Y axis (load) value used for the ignition table.
3202 * Advanced users only: If you aren't sure you need this, you probably don't need this.
3203 * offset 1590
3204 */
3206 /**
3207 * Select which fuel pressure sensor measures the pressure of the fuel at your injectors.
3208 * offset 1591
3209 */
3211 /**
3212 * offset 1592
3213 */
3215 /**
3216 * offset 1594
3217 */
3219 /**
3220 * need 4 byte alignment
3221 * units: units
3222 * offset 1595
3223 */
3224 uint8_t alignmentFill_at_1595[1] = {};
3225 /**
3226 * MAP value above which fuel is cut in case of overboost.
3227 * Set to 0 to disable overboost cut.
3228 * units: kPa (absolute)
3229 * offset 1596
3230 */
3231 float boostCutPressure;
3232 /**
3233 * units: kg/h
3234 * offset 1600
3235 */
3236 scaled_channel<uint8_t, 1, 5> tchargeBins[16] = {};
3237 /**
3238 * units: ratio
3239 * offset 1616
3240 */
3241 scaled_channel<uint8_t, 100, 1> tchargeValues[16] = {};
3242 /**
3243 * Fixed timing, useful for TDC testing
3244 * units: deg
3245 * offset 1632
3246 */
3247 float fixedTiming;
3248 /**
3249 * MAP voltage for low point
3250 * units: v
3251 * offset 1636
3252 */
3253 float mapLowValueVoltage;
3254 /**
3255 * MAP voltage for low point
3256 * units: v
3257 * offset 1640
3258 */
3259 float mapHighValueVoltage;
3260 /**
3261 * EGO value correction
3262 * units: value
3263 * offset 1644
3264 */
3265 float egoValueShift;
3266 /**
3267 * VVT output solenoid pin for this cam
3268 * offset 1648
3269 */
3270 output_pin_e vvtPins[CAM_INPUTS_COUNT] = {};
3271 /**
3272 * This is the IAC position during cranking, some engines start better if given more air during cranking to improve cylinder filling.
3273 * units: percent
3274 * offset 1656
3275 */
3277 /**
3278 * offset 1660
3279 */
3280 scaled_channel<uint8_t, 200, 1> tChargeMinRpmMinTps;
3281 /**
3282 * offset 1661
3283 */
3284 scaled_channel<uint8_t, 200, 1> tChargeMinRpmMaxTps;
3285 /**
3286 * offset 1662
3287 */
3288 scaled_channel<uint8_t, 200, 1> tChargeMaxRpmMinTps;
3289 /**
3290 * offset 1663
3291 */
3292 scaled_channel<uint8_t, 200, 1> tChargeMaxRpmMaxTps;
3293 /**
3294 * offset 1664
3295 */
3297 /**
3298 * Minimim timing advance allowed. No spark on any cylinder will ever fire after this angle BTDC. For example, setting -10 here means no spark ever fires later than 10 deg ATDC. Note that this only concerns the primary spark: any trailing sparks or multispark may violate this constraint.
3299 * units: deg BTDC
3300 * offset 1666
3301 */
3302 int8_t minimumIgnitionTiming;
3303 /**
3304 * Maximum timing advance allowed. No spark on any cylinder will ever fire before this angle BTDC. For example, setting 45 here means no spark ever fires earlier than 45 deg BTDC
3305 * units: deg BTDC
3306 * offset 1667
3307 */
3308 int8_t maximumIgnitionTiming;
3309 /**
3310 * units: Hz
3311 * offset 1668
3312 */
3314 /**
3315 * set vvt_mode X
3316 * offset 1672
3317 */
3318 vvt_mode_e vvtMode[CAMS_PER_BANK] = {};
3319 /**
3320 * Additional idle % when fan #2 is active
3321 * units: %
3322 * offset 1674
3323 */
3324 uint8_t fan2ExtraIdle;
3325 /**
3326 * Delay to allow fuel pressure to build before firing the priming pulse.
3327 * units: sec
3328 * offset 1675
3329 */
3330 scaled_channel<uint8_t, 100, 1> primingDelay;
3331 /**
3332 * offset 1676
3333 */
3334 adc_channel_e auxAnalogInputs[LUA_ANALOG_INPUT_COUNT] = {};
3335 /**
3336 * offset 1684
3337 */
3338 output_pin_e trailingCoilPins[MAX_CYLINDER_COUNT] = {};
3339 /**
3340 * offset 1708
3341 */
3343 /**
3344 * offset 1709
3345 */
3347 /**
3348 * None = I have a MAP-referenced fuel pressure regulator
3349 * Fixed rail pressure = I have an atmosphere-referenced fuel pressure regulator (returnless, typically)
3350 * Sensed rail pressure = I have a fuel pressure sensor
3351 * offset 1710
3352 */
3354 /**
3355 * offset 1711
3356 */
3358 /**
3359 * This is the pressure at which your injector flow is known.
3360 * For example if your injectors flow 400cc/min at 3.5 bar, enter 350kpa here.
3361 * units: kPa
3362 * offset 1712
3363 */
3365 /**
3366 * offset 1716
3367 */
3369 /**
3370 * offset 1748
3371 */
3373 /**
3374 * units: Deg
3375 * offset 1780
3376 */
3377 int16_t knockSamplingDuration;
3378 /**
3379 * units: Hz
3380 * offset 1782
3381 */
3382 int16_t etbFreq;
3383 /**
3384 * offset 1784
3385 */
3387 /**
3388 * For micro-stepping, make sure that PWM frequency (etbFreq) is high enough
3389 * offset 1804
3390 */
3392 /**
3393 * Use to limit the current when the stepper motor is idle, not moving (100% = no limit)
3394 * units: %
3395 * offset 1805
3396 */
3397 uint8_t stepperMinDutyCycle;
3398 /**
3399 * Use to limit the max.current through the stepper motor (100% = no limit)
3400 * units: %
3401 * offset 1806
3402 */
3403 uint8_t stepperMaxDutyCycle;
3404 /**
3405 * offset 1807
3406 */
3408 /**
3409 * per-cylinder ignition and fueling timing correction for uneven engines
3410 * units: deg
3411 * offset 1808
3412 */
3413 angle_t timing_offset_cylinder[MAX_CYLINDER_COUNT] = {};
3414 /**
3415 * units: seconds
3416 * offset 1856
3417 */
3419 /**
3420 * offset 1860
3421 */
3423 /**
3424 * Modes count be used for 3v<>5v integration using pull-ups/pull-downs etc.
3425 * offset 1861
3426 */
3428 /**
3429 * offset 1862
3430 */
3432 /**
3433 * offset 1863
3434 */
3436 /**
3437 * offset 1864
3438 */
3440 /**
3441 * offset 1865
3442 */
3444 /**
3445 * offset 1866
3446 */
3448 /**
3449 * offset 1867
3450 */
3452 /**
3453 * offset 1868
3454 */
3456 /**
3457 * offset 1869
3458 */
3460 /**
3461 * ResetB
3462 * offset 1870
3463 */
3465 /**
3466 * offset 1872
3467 */
3469 /**
3470 * Brake pedal switch
3471 * offset 1874
3472 */
3474 /**
3475 * VVT output PID
3476 * TODO: rename to vvtPid
3477 * offset 1876
3478 */
3479 pid_s auxPid[CAMS_PER_BANK] = {};
3480 /**
3481 * offset 1916
3482 */
3483 float injectorCorrectionPolynomial[8] = {};
3484 /**
3485 * units: C
3486 * offset 1948
3487 */
3488 int8_t primeBins[PRIME_CURVE_COUNT] = {};
3489 /**
3490 * offset 1956
3491 */
3493 /**
3494 * offset 1976
3495 */
3497 /**
3498 * need 4 byte alignment
3499 * units: units
3500 * offset 1977
3501 */
3502 uint8_t alignmentFill_at_1977[1] = {};
3503 /**
3504 * offset 1978
3505 */
3507 /**
3508 * Cooling fan turn-on temperature threshold, in Celsius
3509 * units: deg C
3510 * offset 1980
3511 */
3512 uint8_t fan2OnTemperature;
3513 /**
3514 * Cooling fan turn-off temperature threshold, in Celsius
3515 * units: deg C
3516 * offset 1981
3517 */
3518 uint8_t fan2OffTemperature;
3519 /**
3520 * offset 1982
3521 */
3523 /**
3524 * offset 1984
3525 */
3527 /**
3528 * offset 1986
3529 */
3531 /**
3532 * need 4 byte alignment
3533 * units: units
3534 * offset 1987
3535 */
3536 uint8_t alignmentFill_at_1987[1] = {};
3537 /**
3538 * offset 1988
3539 */
3541 /**
3542 * need 4 byte alignment
3543 * units: units
3544 * offset 1990
3545 */
3546 uint8_t alignmentFill_at_1990[2] = {};
3547 /**
3548 * units: hz
3549 * offset 1992
3550 */
3551 float auxFrequencyFilter;
3552 /**
3553 * offset 1996
3554 */
3555 sent_input_pin_e sentInputPins[SENT_INPUT_COUNT] = {};
3556 /**
3557 * This sets the RPM above which fuel cut is active.
3558 * units: rpm
3559 * offset 1998
3560 */
3561 int16_t coastingFuelCutRpmHigh;
3562 /**
3563 * This sets the RPM below which fuel cut is deactivated, this prevents jerking or issues transitioning to idle
3564 * units: rpm
3565 * offset 2000
3566 */
3567 int16_t coastingFuelCutRpmLow;
3568 /**
3569 * Throttle position below which fuel cut is active. With an electronic throttle enabled, this checks against pedal position.
3570 * units: %
3571 * offset 2002
3572 */
3573 int16_t coastingFuelCutTps;
3574 /**
3575 * Fuel cutoff is disabled when the engine is cold.
3576 * units: C
3577 * offset 2004
3578 */
3579 int16_t coastingFuelCutClt;
3580 /**
3581 * Increases PID reaction for RPM<target by adding extra percent to PID-error
3582 * units: %
3583 * offset 2006
3584 */
3585 int16_t pidExtraForLowRpm;
3586 /**
3587 * MAP value above which fuel injection is re-enabled.
3588 * units: kPa
3589 * offset 2008
3590 */
3591 int16_t coastingFuelCutMap;
3592 /**
3593 * need 4 byte alignment
3594 * units: units
3595 * offset 2010
3596 */
3597 uint8_t alignmentFill_at_2010[2] = {};
3598 /**
3599 * offset 2012
3600 */
3602 /**
3603 * offset 2032
3604 */
3606 /**
3607 * offset 2052
3608 */
3609 gppwm_note_t scriptCurveName[SCRIPT_CURVE_COUNT] = {};
3610 /**
3611 * offset 2148
3612 */
3613 gppwm_note_t scriptTableName[SCRIPT_TABLE_COUNT] = {};
3614 /**
3615 * offset 2212
3616 */
3617 gppwm_note_t scriptSettingName[SCRIPT_SETTING_COUNT] = {};
3618 /**
3619 * Heat transfer coefficient at zero flow.
3620 * 0 means the air charge is fully heated to the same temperature as CLT.
3621 * 1 means the air charge gains no heat, and enters the cylinder at the temperature measured by IAT.
3622 * offset 2340
3623 */
3624 float tChargeAirCoefMin;
3625 /**
3626 * Heat transfer coefficient at high flow, as defined by "max air flow".
3627 * 0 means the air charge is fully heated to the same temperature as CLT.
3628 * 1 means the air charge gains no heat, and enters the cylinder at the temperature measured by IAT.
3629 * offset 2344
3630 */
3631 float tChargeAirCoefMax;
3632 /**
3633 * High flow point for heat transfer estimation.
3634 * Set this to perhaps 50-75% of your maximum airflow at wide open throttle.
3635 * units: kg/h
3636 * offset 2348
3637 */
3638 float tChargeAirFlowMax;
3639 /**
3640 * Maximum allowed rate of increase allowed for the estimated charge temperature
3641 * units: deg/sec
3642 * offset 2352
3643 */
3644 float tChargeAirIncrLimit;
3645 /**
3646 * Maximum allowed rate of decrease allowed for the estimated charge temperature
3647 * units: deg/sec
3648 * offset 2356
3649 */
3650 float tChargeAirDecrLimit;
3651 /**
3652 * offset 2360
3653 */
3654 float hip9011Gain;
3655 /**
3656 * iTerm min value
3657 * offset 2364
3658 */
3659 int16_t etb_iTermMin;
3660 /**
3661 * iTerm max value
3662 * offset 2366
3663 */
3664 int16_t etb_iTermMax;
3665 /**
3666 * See useIdleTimingPidControl
3667 * offset 2368
3668 */
3670 /**
3671 * When entering idle, and the PID settings are aggressive, it's good to make a soft entry upon entering closed loop
3672 * offset 2388
3673 */
3675 /**
3676 * offset 2392
3677 */
3679 /**
3680 * offset 2393
3681 */
3683 /**
3684 * A delay in cycles between fuel-enrich. portions
3685 * units: cycles
3686 * offset 2394
3687 */
3688 int16_t tpsAccelFractionPeriod;
3689 /**
3690 * A fraction divisor: 1 or less = entire portion at once, or split into diminishing fractions
3691 * units: coef
3692 * offset 2396
3693 */
3695 /**
3696 * offset 2400
3697 */
3699 /**
3700 * offset 2401
3701 */
3703 /**
3704 * iTerm min value
3705 * offset 2402
3706 */
3707 int16_t idlerpmpid_iTermMin;
3708 /**
3709 * offset 2404
3710 */
3712 /**
3713 * Stoichiometric ratio for your primary fuel. When Flex Fuel is enabled, this value is used when the Flex Fuel sensor indicates E0.
3714 * E0 = 14.7
3715 * E10 = 14.1
3716 * E85 = 9.9
3717 * E100 = 9.0
3718 * units: :1
3719 * offset 2405
3720 */
3721 scaled_channel<uint8_t, 10, 1> stoichRatioPrimary;
3722 /**
3723 * iTerm max value
3724 * offset 2406
3725 */
3726 int16_t idlerpmpid_iTermMax;
3727 /**
3728 * This sets the range of the idle control on the ETB. At 100% idle position, the value specified here sets the base ETB position.
3729 * units: %
3730 * offset 2408
3731 */
3733 /**
3734 * Select which fuel correction bank this cylinder belongs to. Group cylinders that share the same O2 sensor
3735 * offset 2412
3736 */
3737 uint8_t cylinderBankSelect[MAX_CYLINDER_COUNT] = {};
3738 /**
3739 * units: mg
3740 * offset 2424
3741 */
3742 scaled_channel<uint8_t, 1, 5> primeValues[PRIME_CURVE_COUNT] = {};
3743 /**
3744 * Trigger comparator center point voltage
3745 * units: V
3746 * offset 2432
3747 */
3748 scaled_channel<uint8_t, 50, 1> triggerCompCenterVolt;
3749 /**
3750 * Trigger comparator hysteresis voltage (Min)
3751 * units: V
3752 * offset 2433
3753 */
3754 scaled_channel<uint8_t, 50, 1> triggerCompHystMin;
3755 /**
3756 * Trigger comparator hysteresis voltage (Max)
3757 * units: V
3758 * offset 2434
3759 */
3760 scaled_channel<uint8_t, 50, 1> triggerCompHystMax;
3761 /**
3762 * VR-sensor saturation RPM
3763 * units: RPM
3764 * offset 2435
3765 */
3766 scaled_channel<uint8_t, 1, 50> triggerCompSensorSatRpm;
3767 /**
3768 * units: ratio
3769 * offset 2436
3770 */
3771 scaled_channel<uint16_t, 100, 1> tractionControlSlipBins[TRACTION_CONTROL_ETB_DROP_SIZE] = {};
3772 /**
3773 * units: RPM
3774 * offset 2448
3775 */
3776 uint8_t tractionControlSpeedBins[TRACTION_CONTROL_ETB_DROP_SIZE] = {};
3777 /**
3778 * offset 2454
3779 */
3780 int8_t disableFan1AtSpeed;
3781 /**
3782 * offset 2455
3783 */
3784 int8_t disableFan2AtSpeed;
3785 /**
3786 * offset 2456
3787 */
3789 /**
3790 * need 4 byte alignment
3791 * units: units
3792 * offset 2458
3793 */
3794 uint8_t alignmentFill_at_2458[2] = {};
3795 /**
3796 * offset 2460
3797 */
3798 gppwm_channel gppwm[GPPWM_CHANNELS] = {};
3799 /**
3800 * Boost Current
3801 * units: mA
3802 * offset 2892
3803 */
3804 uint16_t mc33_i_boost;
3805 /**
3806 * Peak Current
3807 * units: mA
3808 * offset 2894
3809 */
3810 uint16_t mc33_i_peak;
3811 /**
3812 * Hold Current
3813 * units: mA
3814 * offset 2896
3815 */
3816 uint16_t mc33_i_hold;
3817 /**
3818 * Maximum allowed boost phase time. If the injector current doesn't reach the threshold before this time elapses, it is assumed that the injector is missing or has failed open circuit.
3819 * units: us
3820 * offset 2898
3821 */
3822 uint16_t mc33_t_max_boost;
3823 /**
3824 * units: us
3825 * offset 2900
3826 */
3827 uint16_t mc33_t_peak_off;
3828 /**
3829 * Peak phase duration
3830 * units: us
3831 * offset 2902
3832 */
3833 uint16_t mc33_t_peak_tot;
3834 /**
3835 * units: us
3836 * offset 2904
3837 */
3838 uint16_t mc33_t_bypass;
3839 /**
3840 * units: us
3841 * offset 2906
3842 */
3843 uint16_t mc33_t_hold_off;
3844 /**
3845 * Hold phase duration
3846 * units: us
3847 * offset 2908
3848 */
3849 uint16_t mc33_t_hold_tot;
3850 /**
3851 * offset 2910
3852 */
3854 /**
3855 * offset 2911
3856 */
3858 /**
3859 * offset 2912
3860 */
3862 /**
3863 * offset 2913
3864 */
3865 pin_output_mode_e tcu_solenoid_mode[TCU_SOLENOID_COUNT] = {};
3866 /**
3867 * need 4 byte alignment
3868 * units: units
3869 * offset 2919
3870 */
3871 uint8_t alignmentFill_at_2919[1] = {};
3872 /**
3873 * units: ratio
3874 * offset 2920
3875 */
3876 float triggerGapOverrideFrom[GAP_TRACKING_LENGTH] = {};
3877 /**
3878 * units: ratio
3879 * offset 2992
3880 */
3881 float triggerGapOverrideTo[GAP_TRACKING_LENGTH] = {};
3882 /**
3883 * Below this RPM, use camshaft information to synchronize the crank's position for full sequential operation. Use this if your cam sensor does weird things at high RPM. Set to 0 to disable, and always use cam to help sync crank.
3884 * units: rpm
3885 * offset 3064
3886 */
3887 scaled_channel<uint8_t, 1, 50> maxCamPhaseResolveRpm;
3888 /**
3889 * Delay before cutting fuel. Set to 0 to cut immediately with no delay. May cause rumbles and pops out of your exhaust...
3890 * units: sec
3891 * offset 3065
3892 */
3893 scaled_channel<uint8_t, 10, 1> dfcoDelay;
3894 /**
3895 * Delay before engaging the AC compressor. Set to 0 to engage immediately with no delay. Use this to prevent bogging at idle when AC engages.
3896 * units: sec
3897 * offset 3066
3898 */
3899 scaled_channel<uint8_t, 10, 1> acDelay;
3900 /**
3901 * offset 3067
3902 */
3904 /**
3905 * units: mg
3906 * offset 3068
3907 */
3908 scaled_channel<uint16_t, 1000, 1> fordInjectorSmallPulseBreakPoint;
3909 /**
3910 * Threshold in ETB error (target vs. actual) above which the jam timer is started. If the timer reaches the time specified in the jam detection timeout period, the throttle is considered jammed, and engine operation limited.
3911 * units: %
3912 * offset 3070
3913 */
3914 uint8_t etbJamDetectThreshold;
3915 /**
3916 * units: lobes/cam
3917 * offset 3071
3918 */
3919 uint8_t hpfpCamLobes;
3920 /**
3921 * offset 3072
3922 */
3924 /**
3925 * Low engine speed for A/C. Larger engines can survive lower values
3926 * units: RPM
3927 * offset 3073
3928 */
3929 scaled_channel<int8_t, 1, 10> acLowRpmLimit;
3930 /**
3931 * If the requested activation time is below this angle, don't bother running the pump
3932 * units: deg
3933 * offset 3074
3934 */
3935 uint8_t hpfpMinAngle;
3936 /**
3937 * need 4 byte alignment
3938 * units: units
3939 * offset 3075
3940 */
3941 uint8_t alignmentFill_at_3075[1] = {};
3942 /**
3943 * Size of the pump chamber in cc. Typical Bosch HDP5 has a 9.0mm diameter, typical BMW N* stroke is 4.4mm.
3944 * units: cc
3945 * offset 3076
3946 */
3947 scaled_channel<uint16_t, 1000, 1> hpfpPumpVolume;
3948 /**
3949 * How long to keep the valve activated (in order to allow the pump to build pressure and keep the valve open on its own)
3950 * units: deg
3951 * offset 3078
3952 */
3953 uint8_t hpfpActivationAngle;
3954 /**
3955 * offset 3079
3956 */
3957 uint8_t issFilterReciprocal;
3958 /**
3959 * units: %/kPa
3960 * offset 3080
3961 */
3962 scaled_channel<uint16_t, 1000, 1> hpfpPidP;
3963 /**
3964 * units: %/kPa/lobe
3965 * offset 3082
3966 */
3967 scaled_channel<uint16_t, 100000, 1> hpfpPidI;
3968 /**
3969 * The fastest rate the target pressure can be reduced by. This is because HPFP have no way to bleed off pressure other than injecting fuel.
3970 * units: kPa/s
3971 * offset 3084
3972 */
3973 uint16_t hpfpTargetDecay;
3974 /**
3975 * offset 3086
3976 */
3978 /**
3979 * units: ratio
3980 * offset 3094
3981 */
3982 scaled_channel<uint16_t, 100, 1> gearRatio[TCU_GEAR_COUNT] = {};
3983 /**
3984 * We need to give engine time to build oil pressure without diverting it to VVT
3985 * units: ms
3986 * offset 3114
3987 */
3988 uint16_t vvtActivationDelayMs;
3989 /**
3990 * units: Nm
3991 * offset 3116
3992 */
3993 scaled_channel<uint8_t, 1, 10> torqueTable[TORQUE_CURVE_SIZE][TORQUE_CURVE_SIZE] = {};
3994 /**
3995 * units: RPM
3996 * offset 3152
3997 */
3998 uint16_t torqueRpmBins[TORQUE_CURVE_SIZE] = {};
3999 /**
4000 * units: Load
4001 * offset 3164
4002 */
4003 uint16_t torqueLoadBins[TORQUE_CURVE_SIZE] = {};
4004 /**
4005 * offset 3176
4006 */
4008 /**
4009 * offset 3177
4010 */
4012 /**
4013 * During revolution where ACR should be disabled at what specific angle to disengage
4014 * units: deg
4015 * offset 3178
4016 */
4017 uint16_t acrDisablePhase;
4018 /**
4019 * offset 3180
4020 */
4022 /**
4023 * offset 3200
4024 */
4026 /**
4027 * offset 3220
4028 */
4030 /**
4031 * offset 3222
4032 */
4034 /**
4035 * need 4 byte alignment
4036 * units: units
4037 * offset 3223
4038 */
4039 uint8_t alignmentFill_at_3223[1] = {};
4040 /**
4041 * offset 3224
4042 */
4044 /**
4045 * offset 3226
4046 */
4048 /**
4049 * need 4 byte alignment
4050 * units: units
4051 * offset 3227
4052 */
4053 uint8_t alignmentFill_at_3227[1] = {};
4054 /**
4055 * offset 3228
4056 */
4058 /**
4059 * offset 3230
4060 */
4062 /**
4063 * offset 3232
4064 */
4066 /**
4067 * need 4 byte alignment
4068 * units: units
4069 * offset 3233
4070 */
4071 uint8_t alignmentFill_at_3233[1] = {};
4072 /**
4073 * offset 3234
4074 */
4076 /**
4077 * offset 3236
4078 */
4080 /**
4081 * offset 3238
4082 */
4084 /**
4085 * need 4 byte alignment
4086 * units: units
4087 * offset 3239
4088 */
4089 uint8_t alignmentFill_at_3239[1] = {};
4090 /**
4091 * offset 3240
4092 */
4094 /**
4095 * offset 3242
4096 */
4098 /**
4099 * Set a minimum allowed target position to avoid slamming/driving against the hard mechanical stop in the throttle.
4100 * units: %
4101 * offset 3244
4102 */
4103 scaled_channel<uint8_t, 10, 1> etbMinimumPosition;
4104 /**
4105 * need 4 byte alignment
4106 * units: units
4107 * offset 3245
4108 */
4109 uint8_t alignmentFill_at_3245[1] = {};
4110 /**
4111 * offset 3246
4112 */
4113 uint16_t tuneHidingKey;
4114 /**
4115 * Individual charaters are accessible using vin(index) Lua function
4116 * offset 3248
4117 */
4119 /**
4120 * need 4 byte alignment
4121 * units: units
4122 * offset 3265
4123 */
4124 uint8_t alignmentFill_at_3265[1] = {};
4125 /**
4126 * offset 3266
4127 */
4128 uint16_t highSpeedOffsets[HIGH_SPEED_COUNT] = {};
4129 /**
4130 * offset 3330
4131 */
4133 /**
4134 * need 4 byte alignment
4135 * units: units
4136 * offset 3331
4137 */
4138 uint8_t alignmentFill_at_3331[1] = {};
4139 /**
4140 * offset 3332
4141 */
4142 switch_input_pin_e luaDigitalInputPins[LUA_DIGITAL_INPUT_COUNT] = {};
4143 /**
4144 * units: rpm
4145 * offset 3348
4146 */
4147 int16_t ALSMinRPM;
4148 /**
4149 * units: rpm
4150 * offset 3350
4151 */
4152 int16_t ALSMaxRPM;
4153 /**
4154 * units: sec
4155 * offset 3352
4156 */
4157 int16_t ALSMaxDuration;
4158 /**
4159 * units: C
4160 * offset 3354
4161 */
4162 int8_t ALSMinCLT;
4163 /**
4164 * units: C
4165 * offset 3355
4166 */
4167 int8_t ALSMaxCLT;
4168 /**
4169 * offset 3356
4170 */
4171 uint8_t alsMinTimeBetween;
4172 /**
4173 * offset 3357
4174 */
4175 uint8_t alsEtbPosition;
4176 /**
4177 * units: %
4178 * offset 3358
4179 */
4181 /**
4182 * If you have SENT TPS sensor please select type. For analog TPS leave None
4183 * offset 3359
4184 */
4186 /**
4187 * offset 3360
4188 */
4189 uint16_t customSentTpsMin;
4190 /**
4191 * need 4 byte alignment
4192 * units: units
4193 * offset 3362
4194 */
4195 uint8_t alignmentFill_at_3362[2] = {};
4196 /**
4197 * units: %
4198 * offset 3364
4199 */
4200 int ALSIdleAdd;
4201 /**
4202 * units: %
4203 * offset 3368
4204 */
4205 int ALSEtbAdd;
4206 /**
4207 * offset 3372
4208 */
4209 float ALSSkipRatio;
4210 /**
4211 * Hysterisis: if Pressure High Disable is 240kpa, and acPressureEnableHyst is 20, when the ECU sees 240kpa, A/C will be disabled, and stay disabled until 240-20=220kpa is reached
4212 * units: kPa (absolute)
4213 * offset 3376
4214 */
4215 scaled_channel<uint8_t, 2, 1> acPressureEnableHyst;
4216 /**
4217 * offset 3377
4218 */
4220 /**
4221 * For Ford TPS, use 53%. For Toyota ETCS-i, use ~65%
4222 * units: %
4223 * offset 3378
4224 */
4225 scaled_channel<uint8_t, 2, 1> tpsSecondaryMaximum;
4226 /**
4227 * For Toyota ETCS-i, use ~69%
4228 * units: %
4229 * offset 3379
4230 */
4231 scaled_channel<uint8_t, 2, 1> ppsSecondaryMaximum;
4232 /**
4233 * offset 3380
4234 */
4235 pin_input_mode_e luaDigitalInputPinModes[LUA_DIGITAL_INPUT_COUNT] = {};
4236 /**
4237 * offset 3388
4238 */
4239 uint16_t customSentTpsMax;
4240 /**
4241 * offset 3390
4242 */
4243 uint16_t kLineBaudRate;
4244 /**
4245 * offset 3392
4246 */
4248 /**
4249 * offset 3393
4250 */
4251 UiMode uiMode;
4252 /**
4253 * Crank angle ATDC of first lobe peak
4254 * units: deg
4255 * offset 3394
4256 */
4257 int16_t hpfpPeakPos;
4258 /**
4259 * units: us
4260 * offset 3396
4261 */
4262 int16_t kLinePeriodUs;
4263 /**
4264 * Window that the correction will be added throughout (example, if rpm limit is 7000, and rpmSoftLimitWindowSize is 200, the corrections activate at 6800RPM, creating a 200rpm window)
4265 * units: RPM
4266 * offset 3398
4267 */
4268 scaled_channel<uint8_t, 1, 10> rpmSoftLimitWindowSize;
4269 /**
4270 * Degrees of timing REMOVED from actual timing during soft RPM limit window
4271 * units: deg
4272 * offset 3399
4273 */
4274 scaled_channel<uint8_t, 5, 1> rpmSoftLimitTimingRetard;
4275 /**
4276 * % of fuel ADDED during window
4277 * units: %
4278 * offset 3400
4279 */
4280 scaled_channel<uint8_t, 5, 1> rpmSoftLimitFuelAdded;
4281 /**
4282 * Hysterisis: if the hard limit is 7200rpm and rpmHardLimitHyst is 200rpm, then when the ECU sees 7200rpm, fuel/ign will cut, and stay cut until 7000rpm (7200-200) is reached
4283 * units: RPM
4284 * offset 3401
4285 */
4286 scaled_channel<uint8_t, 1, 10> rpmHardLimitHyst;
4287 /**
4288 * Time between bench test pulses
4289 * units: ms
4290 * offset 3402
4291 */
4292 scaled_channel<uint16_t, 10, 1> benchTestOffTime;
4293 /**
4294 * Hysterisis: if hard cut is 240kpa, and boostCutPressureHyst is 20, when the ECU sees 240kpa, fuel/ign will cut, and stay cut until 240-20=220kpa is reached
4295 * units: kPa (absolute)
4296 * offset 3404
4297 */
4298 scaled_channel<uint8_t, 2, 1> boostCutPressureHyst;
4299 /**
4300 * Boost duty cycle modified by gear
4301 * units: %
4302 * offset 3405
4303 */
4304 scaled_channel<int8_t, 2, 1> gearBasedOpenLoopBoostAdder[TCU_GEAR_COUNT] = {};
4305 /**
4306 * need 4 byte alignment
4307 * units: units
4308 * offset 3415
4309 */
4310 uint8_t alignmentFill_at_3415[1] = {};
4311 /**
4312 * How many test bench pulses do you want
4313 * offset 3416
4314 */
4315 uint32_t benchTestCount;
4316 /**
4317 * How long initial IAC adder is held before starting to decay.
4318 * units: seconds
4319 * offset 3420
4320 */
4321 scaled_channel<uint8_t, 10, 1> iacByTpsHoldTime;
4322 /**
4323 * How long it takes to remove initial IAC adder to return to normal idle.
4324 * units: seconds
4325 * offset 3421
4326 */
4327 scaled_channel<uint8_t, 10, 1> iacByTpsDecayTime;
4328 /**
4329 * offset 3422
4330 */
4331 switch_input_pin_e tcu_rangeInput[RANGE_INPUT_COUNT] = {};
4332 /**
4333 * offset 3434
4334 */
4335 pin_input_mode_e tcu_rangeInputMode[RANGE_INPUT_COUNT] = {};
4336 /**
4337 * Scale the reported vehicle speed value from CAN. Example: Parameter set to 1.1, CAN VSS reports 50kph, ECU will report 55kph instead.
4338 * units: ratio
4339 * offset 3440
4340 */
4341 scaled_channel<uint16_t, 10000, 1> canVssScaling;
4342 /**
4343 * need 4 byte alignment
4344 * units: units
4345 * offset 3442
4346 */
4347 uint8_t alignmentFill_at_3442[2] = {};
4348 /**
4349 * offset 3444
4350 */
4352 /**
4353 * offset 3476
4354 */
4356 /**
4357 * offset 3508
4358 */
4360 /**
4361 * offset 3540
4362 */
4364 /**
4365 * Place the sensor before the throttle, but after any turbocharger/supercharger and intercoolers if fitted. Uses the same calibration as the MAP sensor.
4366 * offset 3572
4367 */
4369 /**
4370 * Place the sensor after the turbocharger/supercharger, but before any intercoolers if fitted. Uses the same calibration as the MAP sensor.
4371 * offset 3573
4372 */
4374 /**
4375 * offset 3574
4376 */
4377 Gpio dacOutputPins[DAC_OUTPUT_COUNT] = {};
4378 /**
4379 * offset 3578
4380 */
4382 /**
4383 * Number of speedometer pulses per kilometer travelled.
4384 * offset 3580
4385 */
4386 uint16_t speedometerPulsePerKm;
4387 /**
4388 * offset 3582
4389 */
4390 uint8_t simulatorCamPosition[CAM_INPUTS_COUNT] = {};
4391 /**
4392 * offset 3586
4393 */
4395 /**
4396 * offset 3587
4397 */
4399 /**
4400 * units: ratio
4401 * offset 3588
4402 */
4403 float triggerVVTGapOverrideFrom[VVT_TRACKING_LENGTH] = {};
4404 /**
4405 * units: ratio
4406 * offset 3604
4407 */
4408 float triggerVVTGapOverrideTo[VVT_TRACKING_LENGTH] = {};
4409 /**
4410 * units: %
4411 * offset 3620
4412 */
4413 int8_t tractionControlEtbDrop[TRACTION_CONTROL_ETB_DROP_SIZE][TRACTION_CONTROL_ETB_DROP_SIZE] = {};
4414 /**
4415 * If injector duty cycle hits this value, instantly cut fuel.
4416 * units: %
4417 * offset 3656
4418 */
4419 uint8_t maxInjectorDutyInstant;
4420 /**
4421 * If injector duty cycle hits this value for the specified delay time, cut fuel.
4422 * units: %
4423 * offset 3657
4424 */
4426 /**
4427 * Timeout period for duty cycle over the sustained limit to trigger duty cycle protection.
4428 * units: sec
4429 * offset 3658
4430 */
4431 scaled_channel<uint8_t, 10, 1> maxInjectorDutySustainedTimeout;
4432 /**
4433 * need 4 byte alignment
4434 * units: units
4435 * offset 3659
4436 */
4437 uint8_t alignmentFill_at_3659[1] = {};
4438 /**
4439 * offset 3660
4440 */
4441 output_pin_e injectionPinsStage2[MAX_CYLINDER_COUNT] = {};
4442 /**
4443 * units: Deg
4444 * offset 3684
4445 */
4446 int8_t tractionControlTimingDrop[TRACTION_CONTROL_ETB_DROP_SIZE][TRACTION_CONTROL_ETB_DROP_SIZE] = {};
4447 /**
4448 * units: %
4449 * offset 3720
4450 */
4451 int8_t tractionControlIgnitionSkip[TRACTION_CONTROL_ETB_DROP_SIZE][TRACTION_CONTROL_ETB_DROP_SIZE] = {};
4452 /**
4453 * offset 3756
4454 */
4455 float auxSpeed1Multiplier;
4456 /**
4457 * offset 3760
4458 */
4460 /**
4461 * offset 3764
4462 */
4464 /**
4465 * offset 3766
4466 */
4468 /**
4469 * offset 3768
4470 */
4472 /**
4473 * offset 3770
4474 */
4476 /**
4477 * offset 3772
4478 */
4480 /**
4481 * offset 3774
4482 */
4484 /**
4485 * offset 3776
4486 */
4488 /**
4489 * offset 3778
4490 */
4492 /**
4493 * offset 3780
4494 */
4496 /**
4497 * offset 3782
4498 */
4500 /**
4501 * offset 3783
4502 */
4504 /**
4505 * offset 3784
4506 */
4508 /**
4509 * offset 3785
4510 */
4512 /**
4513 * offset 3786
4514 */
4516 /**
4517 * offset 3787
4518 */
4520 /**
4521 * offset 3788
4522 */
4524 /**
4525 * offset 3789
4526 */
4528 /**
4529 * need 4 byte alignment
4530 * units: units
4531 * offset 3790
4532 */
4533 uint8_t alignmentFill_at_3790[2] = {};
4534 /**
4535 * Secondary TTL channel baud rate
4536 * units: BPs
4537 * offset 3792
4538 */
4539 uint32_t tunerStudioSerialSpeed;
4540 /**
4541 * offset 3796
4542 */
4544 /**
4545 * offset 3798
4546 */
4548 /**
4549 * need 4 byte alignment
4550 * units: units
4551 * offset 3799
4552 */
4553 uint8_t alignmentFill_at_3799[1] = {};
4554 /**
4555 * offset 3800
4556 */
4557 int anotherCiTest;
4558 /**
4559 * offset 3804
4560 */
4561 uint32_t device_uid[3] = {};
4562 /**
4563 * offset 3816
4564 */
4565 adc_channel_e tcu_rangeAnalogInput[RANGE_INPUT_COUNT] = {};
4566 /**
4567 * need 4 byte alignment
4568 * units: units
4569 * offset 3822
4570 */
4571 uint8_t alignmentFill_at_3822[2] = {};
4572 /**
4573 * units: Ohm
4574 * offset 3824
4575 */
4577 /**
4578 * offset 3828
4579 */
4581 /**
4582 * Nominal coil charge current, 0.25A step
4583 * units: A
4584 * offset 3832
4585 */
4586 scaled_channel<uint8_t, 4, 1> mc33810Nomi;
4587 /**
4588 * Maximum coil charge current, 1A step
4589 * units: A
4590 * offset 3833
4591 */
4592 uint8_t mc33810Maxi;
4593 /**
4594 * need 4 byte alignment
4595 * units: units
4596 * offset 3834
4597 */
4598 uint8_t alignmentFill_at_3834[2] = {};
4599 /**
4600 * offset 3836
4601 */
4603 /**
4604 * value of A/C pressure in kPa before that compressor is disengaged
4605 * units: kPa
4606 * offset 3856
4607 */
4608 uint16_t minAcPressure;
4609 /**
4610 * value of A/C pressure in kPa after that compressor is disengaged
4611 * units: kPa
4612 * offset 3858
4613 */
4614 uint16_t maxAcPressure;
4615 /**
4616 * Delay before cutting fuel due to low oil pressure. Use this to ignore short pressure blips and sensor noise.
4617 * units: sec
4618 * offset 3860
4619 */
4620 scaled_channel<uint8_t, 10, 1> minimumOilPressureTimeout;
4621 /**
4622 * need 4 byte alignment
4623 * units: units
4624 * offset 3861
4625 */
4626 uint8_t alignmentFill_at_3861[3] = {};
4627 /**
4628 * offset 3864
4629 */
4631 /**
4632 * offset 3884
4633 */
4635 /**
4636 * Below TPS value all knock suppression will be disabled.
4637 * units: %
4638 * offset 3904
4639 */
4640 scaled_channel<uint8_t, 1, 1> knockSuppressMinTps;
4641 /**
4642 * Fuel to odd when a knock event occurs. Advice: 5% (mild), 10% (turbo/high comp.), 15% (high knock, e.g. GDI), 20% (spicy lump),
4643 * units: %
4644 * offset 3905
4645 */
4646 scaled_channel<uint8_t, 10, 1> knockFuelTrimAggression;
4647 /**
4648 * After a knock event, reapply fuel at this rate.
4649 * units: 1%/s
4650 * offset 3906
4651 */
4652 scaled_channel<uint8_t, 10, 1> knockFuelTrimReapplyRate;
4653 /**
4654 * Fuel trim when knock, max 30%
4655 * units: %
4656 * offset 3907
4657 */
4658 scaled_channel<uint8_t, 1, 1> knockFuelTrim;
4659 /**
4660 * units: sense
4661 * offset 3908
4662 */
4664 /**
4665 * "Estimated knock frequency, ignore cylinderBore if this one > 0"
4666 * units: Hz
4667 * offset 3912
4668 */
4669 float knockFrequency;
4670 /**
4671 * None = I have a MAP-referenced fuel pressure regulator
4672 * Fixed rail pressure = I have an atmosphere-referenced fuel pressure regulator (returnless, typically)
4673 * Sensed rail pressure = I have a fuel pressure sensor
4674 * offset 3916
4675 */
4677 /**
4678 * need 4 byte alignment
4679 * units: units
4680 * offset 3917
4681 */
4682 uint8_t alignmentFill_at_3917[3] = {};
4683 /**
4684 * This is the pressure at which your injector flow is known.
4685 * For example if your injectors flow 400cc/min at 3.5 bar, enter 350kpa here.
4686 * units: kPa
4687 * offset 3920
4688 */
4690 /**
4691 * SENT input connected to ETB
4692 * offset 3924
4693 */
4695 /**
4696 * SENT input used for high pressure fuel sensor
4697 * offset 3925
4698 */
4700 /**
4701 * If you have SENT High Pressure Fuel Sensor please select type. For analog TPS leave None
4702 * offset 3926
4703 */
4705 /**
4706 * need 4 byte alignment
4707 * units: units
4708 * offset 3927
4709 */
4710 uint8_t alignmentFill_at_3927[1] = {};
4711 /**
4712 offset 3928 bit 0 */
4713 bool nitrousControlEnabled : 1 {};
4714 /**
4715 offset 3928 bit 1 */
4717 /**
4718 offset 3928 bit 2 */
4719 bool unusedFancy3 : 1 {};
4720 /**
4721 offset 3928 bit 3 */
4722 bool unusedFancy4 : 1 {};
4723 /**
4724 offset 3928 bit 4 */
4725 bool unusedFancy5 : 1 {};
4726 /**
4727 offset 3928 bit 5 */
4728 bool unusedFancy6 : 1 {};
4729 /**
4730 offset 3928 bit 6 */
4731 bool unusedFancy7 : 1 {};
4732 /**
4733 offset 3928 bit 7 */
4734 bool unusedFancy8 : 1 {};
4735 /**
4736 offset 3928 bit 8 */
4737 bool unusedFancy9 : 1 {};
4738 /**
4739 offset 3928 bit 9 */
4740 bool unusedFancy10 : 1 {};
4741 /**
4742 offset 3928 bit 10 */
4743 bool unusedFancy11 : 1 {};
4744 /**
4745 offset 3928 bit 11 */
4746 bool unusedFancy12 : 1 {};
4747 /**
4748 offset 3928 bit 12 */
4749 bool unusedFancy13 : 1 {};
4750 /**
4751 offset 3928 bit 13 */
4752 bool unusedFancy14 : 1 {};
4753 /**
4754 offset 3928 bit 14 */
4755 bool unusedFancy15 : 1 {};
4756 /**
4757 offset 3928 bit 15 */
4758 bool unusedFancy16 : 1 {};
4759 /**
4760 offset 3928 bit 16 */
4761 bool unusedFancy17 : 1 {};
4762 /**
4763 offset 3928 bit 17 */
4764 bool unusedFancy18 : 1 {};
4765 /**
4766 offset 3928 bit 18 */
4767 bool unusedFancy19 : 1 {};
4768 /**
4769 offset 3928 bit 19 */
4770 bool unusedFancy20 : 1 {};
4771 /**
4772 offset 3928 bit 20 */
4773 bool unusedFancy21 : 1 {};
4774 /**
4775 offset 3928 bit 21 */
4776 bool unusedFancy22 : 1 {};
4777 /**
4778 offset 3928 bit 22 */
4779 bool unusedFancy23 : 1 {};
4780 /**
4781 offset 3928 bit 23 */
4782 bool unusedFancy24 : 1 {};
4783 /**
4784 offset 3928 bit 24 */
4785 bool unusedFancy25 : 1 {};
4786 /**
4787 offset 3928 bit 25 */
4788 bool unusedFancy26 : 1 {};
4789 /**
4790 offset 3928 bit 26 */
4791 bool unusedFancy27 : 1 {};
4792 /**
4793 offset 3928 bit 27 */
4794 bool unusedFancy28 : 1 {};
4795 /**
4796 offset 3928 bit 28 */
4797 bool unusedFancy29 : 1 {};
4798 /**
4799 offset 3928 bit 29 */
4800 bool unusedFancy30 : 1 {};
4801 /**
4802 offset 3928 bit 30 */
4803 bool unusedFancy31 : 1 {};
4804 /**
4805 offset 3928 bit 31 */
4806 bool unusedFancy32 : 1 {};
4807 /**
4808 * offset 3932
4809 */
4811 /**
4812 * need 4 byte alignment
4813 * units: units
4814 * offset 3933
4815 */
4816 uint8_t alignmentFill_at_3933[1] = {};
4817 /**
4818 * Pin that activates nitrous control
4819 * offset 3934
4820 */
4822 /**
4823 * offset 3936
4824 */
4826 /**
4827 * offset 3937
4828 */
4830 /**
4831 * offset 3938
4832 */
4834 /**
4835 * need 4 byte alignment
4836 * units: units
4837 * offset 3939
4838 */
4839 uint8_t alignmentFill_at_3939[1] = {};
4840 /**
4841 * offset 3940
4842 */
4844 /**
4845 * offset 3944
4846 */
4848 /**
4849 * units: deg C
4850 * offset 3948
4851 */
4852 uint8_t nitrousMinimumClt;
4853 /**
4854 * need 4 byte alignment
4855 * units: units
4856 * offset 3949
4857 */
4858 uint8_t alignmentFill_at_3949[1] = {};
4859 /**
4860 * units: kPa
4861 * offset 3950
4862 */
4863 int16_t nitrousMaximumMap;
4864 /**
4865 * units: afr
4866 * offset 3952
4867 */
4868 scaled_channel<uint8_t, 10, 1> nitrousMaximumAfr;
4869 /**
4870 * need 4 byte alignment
4871 * units: units
4872 * offset 3953
4873 */
4874 uint8_t alignmentFill_at_3953[1] = {};
4875 /**
4876 * units: rpm
4877 * offset 3954
4878 */
4879 uint16_t nitrousActivationRpm;
4880 /**
4881 * units: rpm
4882 * offset 3956
4883 */
4884 uint16_t nitrousDeactivationRpm;
4885 /**
4886 * units: rpm
4887 * offset 3958
4888 */
4890 /**
4891 * Retard timing by this amount during DFCO. Smooths the transition back from fuel cut. After fuel is restored, ramp timing back in over the period specified.
4892 * units: deg
4893 * offset 3960
4894 */
4895 uint8_t dfcoRetardDeg;
4896 /**
4897 * Smooths the transition back from fuel cut. After fuel is restored, ramp timing back in over the period specified.
4898 * units: s
4899 * offset 3961
4900 */
4901 scaled_channel<uint8_t, 10, 1> dfcoRetardRampInTime;
4902 /**
4903 * offset 3962
4904 */
4906 /**
4907 * offset 3964
4908 */
4910 /**
4911 * units: %
4912 * offset 3965
4913 */
4915 /**
4916 * need 4 byte alignment
4917 * units: units
4918 * offset 3966
4919 */
4920 uint8_t alignmentFill_at_3966[2] = {};
4921 /**
4922 * Retard timing to remove from actual final timing (after all corrections) due to additional air.
4923 * units: deg
4924 * offset 3968
4925 */
4927 /**
4928 * units: Kph
4929 * offset 3972
4930 */
4932 /**
4933 * need 4 byte alignment
4934 * units: units
4935 * offset 3974
4936 */
4937 uint8_t alignmentFill_at_3974[2] = {};
4938 /**
4939 * Exponential Average Alpha filtering parameter
4940 * offset 3976
4941 */
4943 /**
4944 * How often do we update fuel level gauge
4945 * units: seconds
4946 * offset 3980
4947 */
4949 /**
4950 * Error below specified value
4951 * units: v
4952 * offset 3984
4953 */
4955 /**
4956 * Error above specified value
4957 * units: v
4958 * offset 3988
4959 */
4961 /**
4962 * units: units
4963 * offset 3992
4964 */
4965 uint8_t unusedOftenChangesDuringFirmwareUpdate[END_OF_CALIBRATION_PADDING] = {};
4966 /**
4967 * need 4 byte alignment
4968 * units: units
4969 * offset 4050
4970 */
4971 uint8_t alignmentFill_at_4050[2] = {};
4972};
4973static_assert(sizeof(engine_configuration_s) == 4052);
4974
4975// start of ign_cyl_trim_s
4976struct ign_cyl_trim_s {
4977 /**
4978 * offset 0
4979 */
4980 scaled_channel<int8_t, 5, 1> table[IGN_TRIM_SIZE][IGN_TRIM_SIZE] = {};
4981};
4982static_assert(sizeof(ign_cyl_trim_s) == 16);
4983
4984// start of fuel_cyl_trim_s
4985struct fuel_cyl_trim_s {
4986 /**
4987 * offset 0
4988 */
4989 scaled_channel<int8_t, 5, 1> table[FUEL_TRIM_SIZE][FUEL_TRIM_SIZE] = {};
4990};
4991static_assert(sizeof(fuel_cyl_trim_s) == 16);
4992
4993// start of blend_table_s
4994struct blend_table_s {
4995 /**
4996 * offset 0
4997 */
4998 scaled_channel<int16_t, 10, 1> table[BLEND_TABLE_COUNT][BLEND_TABLE_COUNT] = {};
4999 /**
5000 * units: Load
5001 * offset 128
5002 */
5003 uint16_t loadBins[BLEND_TABLE_COUNT] = {};
5004 /**
5005 * units: RPM
5006 * offset 144
5007 */
5008 uint16_t rpmBins[BLEND_TABLE_COUNT] = {};
5009 /**
5010 * offset 160
5011 */
5013 /**
5014 * offset 161
5015 */
5017 /**
5018 * offset 162
5019 */
5020 scaled_channel<int16_t, 10, 1> blendBins[BLEND_FACTOR_SIZE] = {};
5021 /**
5022 * units: %
5023 * offset 178
5024 */
5025 scaled_channel<uint8_t, 2, 1> blendValues[BLEND_FACTOR_SIZE] = {};
5026 /**
5027 * need 4 byte alignment
5028 * units: units
5029 * offset 186
5030 */
5031 uint8_t alignmentFill_at_186[2] = {};
5032};
5033static_assert(sizeof(blend_table_s) == 188);
5034
5035// start of persistent_config_s
5036struct persistent_config_s {
5037 /**
5038 * offset 0
5039 */
5041 /**
5042 * units: mult
5043 * offset 4052
5044 */
5045 float postCrankingFactor[CRANKING_ENRICH_COUNT][CRANKING_ENRICH_COUNT] = {};
5046 /**
5047 * units: count
5048 * offset 4196
5049 */
5050 uint16_t postCrankingDurationBins[CRANKING_ENRICH_COUNT] = {};
5051 /**
5052 * units: C
5053 * offset 4208
5054 */
5055 int16_t postCrankingCLTBins[CRANKING_ENRICH_COUNT] = {};
5056 /**
5057 * target TPS value, 0 to 100%
5058 * TODO: use int8 data date once we template interpolation method
5059 * units: target TPS position
5060 * offset 4220
5061 */
5062 float etbBiasBins[ETB_BIAS_CURVE_LENGTH] = {};
5063 /**
5064 * PWM bias, open loop component of PID closed loop control
5065 * units: ETB duty cycle bias
5066 * offset 4252
5067 */
5068 float etbBiasValues[ETB_BIAS_CURVE_LENGTH] = {};
5069 /**
5070 * units: %
5071 * offset 4284
5072 */
5073 scaled_channel<uint8_t, 20, 1> iacPidMultTable[IAC_PID_MULT_SIZE][IAC_PID_MULT_SIZE] = {};
5074 /**
5075 * units: Load
5076 * offset 4348
5077 */
5078 uint8_t iacPidMultLoadBins[IAC_PID_MULT_SIZE] = {};
5079 /**
5080 * units: RPM
5081 * offset 4356
5082 */
5083 scaled_channel<uint8_t, 1, 10> iacPidMultRpmBins[IAC_PID_MULT_SIZE] = {};
5084 /**
5085 * On Single Coil or Wasted Spark setups you have to lower dwell at high RPM
5086 * units: RPM
5087 * offset 4364
5088 */
5089 uint16_t sparkDwellRpmBins[DWELL_CURVE_SIZE] = {};
5090 /**
5091 * units: ms
5092 * offset 4380
5093 */
5094 scaled_channel<uint16_t, 100, 1> sparkDwellValues[DWELL_CURVE_SIZE] = {};
5095 /**
5096 * CLT-based target RPM for automatic idle controller
5097 * units: C
5098 * offset 4396
5099 */
5100 scaled_channel<int8_t, 1, 2> cltIdleRpmBins[CLT_CURVE_SIZE] = {};
5101 /**
5102 * See idleRpmPid
5103 * units: RPM
5104 * offset 4412
5105 */
5106 scaled_channel<uint8_t, 1, 20> cltIdleRpm[CLT_CURVE_SIZE] = {};
5107 /**
5108 * CLT-based timing correction
5109 * units: C
5110 * offset 4428
5111 */
5112 float cltTimingBins[CLT_TIMING_CURVE_SIZE] = {};
5113 /**
5114 * units: degree
5115 * offset 4460
5116 */
5117 float cltTimingExtra[CLT_TIMING_CURVE_SIZE] = {};
5118 /**
5119 * units: x
5120 * offset 4492
5121 */
5122 float scriptCurve1Bins[SCRIPT_CURVE_16] = {};
5123 /**
5124 * units: y
5125 * offset 4556
5126 */
5127 float scriptCurve1[SCRIPT_CURVE_16] = {};
5128 /**
5129 * units: x
5130 * offset 4620
5131 */
5132 float scriptCurve2Bins[SCRIPT_CURVE_16] = {};
5133 /**
5134 * units: y
5135 * offset 4684
5136 */
5137 float scriptCurve2[SCRIPT_CURVE_16] = {};
5138 /**
5139 * units: x
5140 * offset 4748
5141 */
5142 float scriptCurve3Bins[SCRIPT_CURVE_8] = {};
5143 /**
5144 * units: y
5145 * offset 4780
5146 */
5147 float scriptCurve3[SCRIPT_CURVE_8] = {};
5148 /**
5149 * units: x
5150 * offset 4812
5151 */
5152 float scriptCurve4Bins[SCRIPT_CURVE_8] = {};
5153 /**
5154 * units: y
5155 * offset 4844
5156 */
5157 float scriptCurve4[SCRIPT_CURVE_8] = {};
5158 /**
5159 * units: x
5160 * offset 4876
5161 */
5162 float scriptCurve5Bins[SCRIPT_CURVE_8] = {};
5163 /**
5164 * units: y
5165 * offset 4908
5166 */
5167 float scriptCurve5[SCRIPT_CURVE_8] = {};
5168 /**
5169 * units: x
5170 * offset 4940
5171 */
5172 float scriptCurve6Bins[SCRIPT_CURVE_8] = {};
5173 /**
5174 * units: y
5175 * offset 4972
5176 */
5177 float scriptCurve6[SCRIPT_CURVE_8] = {};
5178 /**
5179 * units: kPa
5180 * offset 5004
5181 */
5182 float baroCorrPressureBins[BARO_CORR_SIZE] = {};
5183 /**
5184 * units: RPM
5185 * offset 5020
5186 */
5187 float baroCorrRpmBins[BARO_CORR_SIZE] = {};
5188 /**
5189 * units: ratio
5190 * offset 5036
5191 */
5192 float baroCorrTable[BARO_CORR_SIZE][BARO_CORR_SIZE] = {};
5193 /**
5194 * Cranking fuel correction coefficient based on TPS
5195 * units: Ratio
5196 * offset 5100
5197 */
5198 float crankingTpsCoef[CRANKING_CURVE_SIZE] = {};
5199 /**
5200 * units: %
5201 * offset 5132
5202 */
5203 float crankingTpsBins[CRANKING_CURVE_SIZE] = {};
5204 /**
5205 * Optional timing advance table for Cranking (see useSeparateAdvanceForCranking)
5206 * units: RPM
5207 * offset 5164
5208 */
5209 uint16_t crankingAdvanceBins[CRANKING_ADVANCE_CURVE_SIZE] = {};
5210 /**
5211 * Optional timing advance table for Cranking (see useSeparateAdvanceForCranking)
5212 * units: deg
5213 * offset 5172
5214 */
5215 scaled_channel<int16_t, 100, 1> crankingAdvance[CRANKING_ADVANCE_CURVE_SIZE] = {};
5216 /**
5217 * RPM-based idle position for coasting
5218 * units: RPM
5219 * offset 5180
5220 */
5221 scaled_channel<uint8_t, 1, 100> iacCoastingRpmBins[CLT_CURVE_SIZE] = {};
5222 /**
5223 * RPM-based idle position for coasting
5224 * units: %
5225 * offset 5196
5226 */
5227 scaled_channel<uint8_t, 2, 1> iacCoasting[CLT_CURVE_SIZE] = {};
5228 /**
5229 * offset 5212
5230 */
5231 scaled_channel<uint8_t, 2, 1> boostTableOpenLoop[BOOST_LOAD_COUNT][BOOST_RPM_COUNT] = {};
5232 /**
5233 * units: RPM
5234 * offset 5276
5235 */
5236 scaled_channel<uint8_t, 1, 100> boostRpmBins[BOOST_RPM_COUNT] = {};
5237 /**
5238 * offset 5284
5239 */
5240 scaled_channel<uint8_t, 1, 2> boostTableClosedLoop[BOOST_LOAD_COUNT][BOOST_RPM_COUNT] = {};
5241 /**
5242 * offset 5348
5243 */
5244 uint16_t boostLoadBins[BOOST_LOAD_COUNT] = {};
5245 /**
5246 * units: %
5247 * offset 5364
5248 */
5249 uint8_t pedalToTpsTable[PEDAL_TO_TPS_SIZE][PEDAL_TO_TPS_SIZE] = {};
5250 /**
5251 * units: %
5252 * offset 5428
5253 */
5254 uint8_t pedalToTpsPedalBins[PEDAL_TO_TPS_SIZE] = {};
5255 /**
5256 * units: RPM
5257 * offset 5436
5258 */
5259 scaled_channel<uint8_t, 1, 100> pedalToTpsRpmBins[PEDAL_TO_TPS_SIZE] = {};
5260 /**
5261 * CLT-based cranking position multiplier for simple manual idle controller
5262 * units: C
5263 * offset 5444
5264 */
5265 float cltCrankingCorrBins[CLT_CRANKING_CURVE_SIZE] = {};
5266 /**
5267 * CLT-based cranking position multiplier for simple manual idle controller
5268 * units: %
5269 * offset 5476
5270 */
5271 float cltCrankingCorr[CLT_CRANKING_CURVE_SIZE] = {};
5272 /**
5273 * Optional timing advance table for Idle (see useSeparateAdvanceForIdle)
5274 * units: RPM
5275 * offset 5508
5276 */
5277 scaled_channel<uint8_t, 1, 50> idleAdvanceBins[IDLE_ADVANCE_CURVE_SIZE] = {};
5278 /**
5279 * Optional timing advance table for Idle (see useSeparateAdvanceForIdle)
5280 * units: deg
5281 * offset 5516
5282 */
5283 float idleAdvance[IDLE_ADVANCE_CURVE_SIZE] = {};
5284 /**
5285 * units: RPM
5286 * offset 5548
5287 */
5288 scaled_channel<uint8_t, 1, 10> idleVeRpmBins[IDLE_VE_SIZE] = {};
5289 /**
5290 * units: load
5291 * offset 5552
5292 */
5293 uint8_t idleVeLoadBins[IDLE_VE_SIZE] = {};
5294 /**
5295 * units: %
5296 * offset 5556
5297 */
5298 scaled_channel<uint16_t, 10, 1> idleVeTable[IDLE_VE_SIZE][IDLE_VE_SIZE] = {};
5299 /**
5300 * offset 5588
5301 */
5303 /**
5304 * units: C
5305 * offset 15588
5306 */
5307 float cltFuelCorrBins[CLT_FUEL_CURVE_SIZE] = {};
5308 /**
5309 * units: ratio
5310 * offset 15652
5311 */
5312 float cltFuelCorr[CLT_FUEL_CURVE_SIZE] = {};
5313 /**
5314 * units: C
5315 * offset 15716
5316 */
5317 float iatFuelCorrBins[IAT_CURVE_SIZE] = {};
5318 /**
5319 * units: ratio
5320 * offset 15780
5321 */
5322 float iatFuelCorr[IAT_CURVE_SIZE] = {};
5323 /**
5324 * units: ratio
5325 * offset 15844
5326 */
5327 float crankingFuelCoef[CRANKING_CURVE_SIZE] = {};
5328 /**
5329 * units: C
5330 * offset 15876
5331 */
5332 float crankingFuelBins[CRANKING_CURVE_SIZE] = {};
5333 /**
5334 * units: counter
5335 * offset 15908
5336 */
5337 float crankingCycleBins[CRANKING_CURVE_SIZE] = {};
5338 /**
5339 * units: C
5340 * offset 15940
5341 */
5342 int16_t crankingCycleFuelCltBins[CRANKING_CYCLE_CLT_SIZE] = {};
5343 /**
5344 * units: mult
5345 * offset 15948
5346 */
5347 float crankingCycleFuelCoef[CRANKING_CYCLE_CLT_SIZE][CRANKING_CURVE_SIZE] = {};
5348 /**
5349 * CLT-based idle position multiplier for simple manual idle controller
5350 * units: C
5351 * offset 16076
5352 */
5353 float cltIdleCorrBins[CLT_CURVE_SIZE] = {};
5354 /**
5355 * CLT-based idle position multiplier for simple manual idle controller
5356 * units: ratio
5357 * offset 16140
5358 */
5359 float cltIdleCorr[CLT_CURVE_SIZE] = {};
5360 /**
5361 * Also known as MAF transfer function.
5362 * kg/hour value.
5363 * By the way 2.081989116 kg/h = 1 ft3/m
5364 * units: kg/hour
5365 * offset 16204
5366 */
5367 float mafDecoding[MAF_DECODING_COUNT] = {};
5368 /**
5369 * units: V
5370 * offset 16332
5371 */
5372 float mafDecodingBins[MAF_DECODING_COUNT] = {};
5373 /**
5374 * units: deg
5375 * offset 16460
5376 */
5377 scaled_channel<int8_t, 10, 1> ignitionIatCorrTable[IAT_IGN_CORR_COUNT][IAT_IGN_CORR_COUNT] = {};
5378 /**
5379 * units: C
5380 * offset 16524
5381 */
5382 int8_t ignitionIatCorrTempBins[IAT_IGN_CORR_COUNT] = {};
5383 /**
5384 * units: Load
5385 * offset 16532
5386 */
5387 scaled_channel<uint8_t, 1, 5> ignitionIatCorrLoadBins[IAT_IGN_CORR_COUNT] = {};
5388 /**
5389 * units: deg
5390 * offset 16540
5391 */
5392 int16_t injectionPhase[INJ_PHASE_LOAD_COUNT][INJ_PHASE_RPM_COUNT] = {};
5393 /**
5394 * units: Load
5395 * offset 17052
5396 */
5397 uint16_t injPhaseLoadBins[INJ_PHASE_LOAD_COUNT] = {};
5398 /**
5399 * units: RPM
5400 * offset 17084
5401 */
5402 uint16_t injPhaseRpmBins[INJ_PHASE_RPM_COUNT] = {};
5403 /**
5404 * units: onoff
5405 * offset 17116
5406 */
5407 uint8_t tcuSolenoidTable[TCU_SOLENOID_COUNT][TCU_GEAR_COUNT] = {};
5408 /**
5409 * units: kPa
5410 * offset 17176
5411 */
5412 scaled_channel<uint16_t, 100, 1> mapEstimateTable[FUEL_LOAD_COUNT][FUEL_RPM_COUNT] = {};
5413 /**
5414 * units: % TPS
5415 * offset 17688
5416 */
5417 scaled_channel<uint16_t, 100, 1> mapEstimateTpsBins[FUEL_LOAD_COUNT] = {};
5418 /**
5419 * units: RPM
5420 * offset 17720
5421 */
5422 uint16_t mapEstimateRpmBins[FUEL_RPM_COUNT] = {};
5423 /**
5424 * units: value
5425 * offset 17752
5426 */
5427 int8_t vvtTable1[VVT_TABLE_SIZE][VVT_TABLE_SIZE] = {};
5428 /**
5429 * units: L
5430 * offset 17816
5431 */
5432 uint16_t vvtTable1LoadBins[VVT_TABLE_SIZE] = {};
5433 /**
5434 * units: RPM
5435 * offset 17832
5436 */
5437 uint16_t vvtTable1RpmBins[VVT_TABLE_SIZE] = {};
5438 /**
5439 * units: value
5440 * offset 17848
5441 */
5442 int8_t vvtTable2[VVT_TABLE_SIZE][VVT_TABLE_SIZE] = {};
5443 /**
5444 * units: L
5445 * offset 17912
5446 */
5447 uint16_t vvtTable2LoadBins[VVT_TABLE_SIZE] = {};
5448 /**
5449 * units: RPM
5450 * offset 17928
5451 */
5452 uint16_t vvtTable2RpmBins[VVT_TABLE_SIZE] = {};
5453 /**
5454 * units: deg
5455 * offset 17944
5456 */
5457 scaled_channel<int16_t, 10, 1> ignitionTable[IGN_LOAD_COUNT][IGN_RPM_COUNT] = {};
5458 /**
5459 * units: Load
5460 * offset 18456
5461 */
5462 uint16_t ignitionLoadBins[IGN_LOAD_COUNT] = {};
5463 /**
5464 * units: RPM
5465 * offset 18488
5466 */
5467 uint16_t ignitionRpmBins[IGN_RPM_COUNT] = {};
5468 /**
5469 * units: %
5470 * offset 18520
5471 */
5472 scaled_channel<uint16_t, 10, 1> veTable[VE_LOAD_COUNT][VE_RPM_COUNT] = {};
5473 /**
5474 * units: {bitStringValue(fuelUnits, fuelAlgorithm) }
5475 * offset 19032
5476 */
5477 uint16_t veLoadBins[VE_LOAD_COUNT] = {};
5478 /**
5479 * units: RPM
5480 * offset 19064
5481 */
5482 uint16_t veRpmBins[VE_RPM_COUNT] = {};
5483 /**
5484 * units: lambda
5485 * offset 19096
5486 */
5487 scaled_channel<uint8_t, 147, 1> lambdaTable[FUEL_LOAD_COUNT][FUEL_RPM_COUNT] = {};
5488 /**
5489 * offset 19352
5490 */
5491 uint16_t lambdaLoadBins[FUEL_LOAD_COUNT] = {};
5492 /**
5493 * units: RPM
5494 * offset 19384
5495 */
5496 uint16_t lambdaRpmBins[FUEL_RPM_COUNT] = {};
5497 /**
5498 * units: value
5499 * offset 19416
5500 */
5501 float tpsTpsAccelTable[TPS_TPS_ACCEL_TABLE][TPS_TPS_ACCEL_TABLE] = {};
5502 /**
5503 * units: from
5504 * offset 19672
5505 */
5506 float tpsTpsAccelFromRpmBins[TPS_TPS_ACCEL_TABLE] = {};
5507 /**
5508 * units: to
5509 * offset 19704
5510 */
5511 float tpsTpsAccelToRpmBins[TPS_TPS_ACCEL_TABLE] = {};
5512 /**
5513 * units: value
5514 * offset 19736
5515 */
5516 float scriptTable1[SCRIPT_TABLE_8][SCRIPT_TABLE_8] = {};
5517 /**
5518 * units: L
5519 * offset 19992
5520 */
5521 int16_t scriptTable1LoadBins[SCRIPT_TABLE_8] = {};
5522 /**
5523 * units: RPM
5524 * offset 20008
5525 */
5526 int16_t scriptTable1RpmBins[SCRIPT_TABLE_8] = {};
5527 /**
5528 * units: value
5529 * offset 20024
5530 */
5531 float scriptTable2[TABLE_2_LOAD_SIZE][TABLE_2_RPM_SIZE] = {};
5532 /**
5533 * units: L
5534 * offset 20280
5535 */
5536 int16_t scriptTable2LoadBins[TABLE_2_LOAD_SIZE] = {};
5537 /**
5538 * units: RPM
5539 * offset 20296
5540 */
5541 int16_t scriptTable2RpmBins[TABLE_2_RPM_SIZE] = {};
5542 /**
5543 * units: value
5544 * offset 20312
5545 */
5546 uint8_t scriptTable3[SCRIPT_TABLE_8][SCRIPT_TABLE_8] = {};
5547 /**
5548 * units: L
5549 * offset 20376
5550 */
5551 int16_t scriptTable3LoadBins[SCRIPT_TABLE_8] = {};
5552 /**
5553 * units: RPM
5554 * offset 20392
5555 */
5556 int16_t scriptTable3RpmBins[SCRIPT_TABLE_8] = {};
5557 /**
5558 * units: value
5559 * offset 20408
5560 */
5561 uint8_t scriptTable4[SCRIPT_TABLE_8][TABLE_4_RPM] = {};
5562 /**
5563 * units: L
5564 * offset 20488
5565 */
5566 int16_t scriptTable4LoadBins[SCRIPT_TABLE_8] = {};
5567 /**
5568 * units: RPM
5569 * offset 20504
5570 */
5571 int16_t scriptTable4RpmBins[TABLE_4_RPM] = {};
5572 /**
5573 * offset 20524
5574 */
5575 uint16_t ignTrimLoadBins[IGN_TRIM_SIZE] = {};
5576 /**
5577 * units: rpm
5578 * offset 20532
5579 */
5580 uint16_t ignTrimRpmBins[IGN_TRIM_SIZE] = {};
5581 /**
5582 * offset 20540
5583 */
5584 ign_cyl_trim_s ignTrims[12] = {};
5585 /**
5586 * offset 20732
5587 */
5588 uint16_t fuelTrimLoadBins[FUEL_TRIM_SIZE] = {};
5589 /**
5590 * units: rpm
5591 * offset 20740
5592 */
5593 uint16_t fuelTrimRpmBins[FUEL_TRIM_SIZE] = {};
5594 /**
5595 * offset 20748
5596 */
5597 fuel_cyl_trim_s fuelTrims[12] = {};
5598 /**
5599 * units: ratio
5600 * offset 20940
5601 */
5602 scaled_channel<uint16_t, 100, 1> crankingFuelCoefE100[CRANKING_CURVE_SIZE] = {};
5603 /**
5604 * units: Airmass
5605 * offset 20956
5606 */
5607 scaled_channel<uint8_t, 1, 5> tcu_pcAirmassBins[TCU_TABLE_WIDTH] = {};
5608 /**
5609 * units: %
5610 * offset 20964
5611 */
5612 uint8_t tcu_pcValsR[TCU_TABLE_WIDTH] = {};
5613 /**
5614 * units: %
5615 * offset 20972
5616 */
5617 uint8_t tcu_pcValsN[TCU_TABLE_WIDTH] = {};
5618 /**
5619 * units: %
5620 * offset 20980
5621 */
5622 uint8_t tcu_pcVals1[TCU_TABLE_WIDTH] = {};
5623 /**
5624 * units: %
5625 * offset 20988
5626 */
5627 uint8_t tcu_pcVals2[TCU_TABLE_WIDTH] = {};
5628 /**
5629 * units: %
5630 * offset 20996
5631 */
5632 uint8_t tcu_pcVals3[TCU_TABLE_WIDTH] = {};
5633 /**
5634 * units: %
5635 * offset 21004
5636 */
5637 uint8_t tcu_pcVals4[TCU_TABLE_WIDTH] = {};
5638 /**
5639 * units: %
5640 * offset 21012
5641 */
5642 uint8_t tcu_pcVals12[TCU_TABLE_WIDTH] = {};
5643 /**
5644 * units: %
5645 * offset 21020
5646 */
5647 uint8_t tcu_pcVals23[TCU_TABLE_WIDTH] = {};
5648 /**
5649 * units: %
5650 * offset 21028
5651 */
5652 uint8_t tcu_pcVals34[TCU_TABLE_WIDTH] = {};
5653 /**
5654 * units: %
5655 * offset 21036
5656 */
5657 uint8_t tcu_pcVals21[TCU_TABLE_WIDTH] = {};
5658 /**
5659 * units: %
5660 * offset 21044
5661 */
5662 uint8_t tcu_pcVals32[TCU_TABLE_WIDTH] = {};
5663 /**
5664 * units: %
5665 * offset 21052
5666 */
5667 uint8_t tcu_pcVals43[TCU_TABLE_WIDTH] = {};
5668 /**
5669 * units: TPS
5670 * offset 21060
5671 */
5672 uint8_t tcu_tccTpsBins[8] = {};
5673 /**
5674 * units: MPH
5675 * offset 21068
5676 */
5677 uint8_t tcu_tccLockSpeed[8] = {};
5678 /**
5679 * units: MPH
5680 * offset 21076
5681 */
5682 uint8_t tcu_tccUnlockSpeed[8] = {};
5683 /**
5684 * units: KPH
5685 * offset 21084
5686 */
5687 uint8_t tcu_32SpeedBins[8] = {};
5688 /**
5689 * units: %
5690 * offset 21092
5691 */
5692 uint8_t tcu_32Vals[8] = {};
5693 /**
5694 * units: %
5695 * offset 21100
5696 */
5697 scaled_channel<int8_t, 10, 1> throttle2TrimTable[ETB2_TRIM_SIZE][ETB2_TRIM_SIZE] = {};
5698 /**
5699 * units: %
5700 * offset 21136
5701 */
5702 uint8_t throttle2TrimTpsBins[ETB2_TRIM_SIZE] = {};
5703 /**
5704 * units: RPM
5705 * offset 21142
5706 */
5707 scaled_channel<uint8_t, 1, 100> throttle2TrimRpmBins[ETB2_TRIM_SIZE] = {};
5708 /**
5709 * units: deg
5710 * offset 21148
5711 */
5712 scaled_channel<uint8_t, 4, 1> maxKnockRetardTable[KNOCK_TABLE_SIZE][KNOCK_TABLE_SIZE] = {};
5713 /**
5714 * units: %
5715 * offset 21184
5716 */
5717 uint8_t maxKnockRetardLoadBins[KNOCK_TABLE_SIZE] = {};
5718 /**
5719 * units: RPM
5720 * offset 21190
5721 */
5722 scaled_channel<uint8_t, 1, 100> maxKnockRetardRpmBins[KNOCK_TABLE_SIZE] = {};
5723 /**
5724 * units: deg
5725 * offset 21196
5726 */
5727 scaled_channel<int16_t, 10, 1> ALSTimingRetardTable[ALS_SIZE][ALS_SIZE] = {};
5728 /**
5729 * units: TPS
5730 * offset 21228
5731 */
5732 uint16_t alsIgnRetardLoadBins[ALS_SIZE] = {};
5733 /**
5734 * units: RPM
5735 * offset 21236
5736 */
5737 uint16_t alsIgnRetardrpmBins[ALS_SIZE] = {};
5738 /**
5739 * units: percent
5740 * offset 21244
5741 */
5742 scaled_channel<int16_t, 10, 1> ALSFuelAdjustment[ALS_SIZE][ALS_SIZE] = {};
5743 /**
5744 * units: TPS
5745 * offset 21276
5746 */
5747 uint16_t alsFuelAdjustmentLoadBins[ALS_SIZE] = {};
5748 /**
5749 * units: RPM
5750 * offset 21284
5751 */
5752 uint16_t alsFuelAdjustmentrpmBins[ALS_SIZE] = {};
5753 /**
5754 * units: ratio
5755 * offset 21292
5756 */
5757 scaled_channel<int16_t, 1, 10> ALSIgnSkipTable[ALS_SIZE][ALS_SIZE] = {};
5758 /**
5759 * units: TPS
5760 * offset 21324
5761 */
5762 uint16_t alsIgnSkipLoadBins[ALS_SIZE] = {};
5763 /**
5764 * units: RPM
5765 * offset 21332
5766 */
5767 uint16_t alsIgnSkiprpmBins[ALS_SIZE] = {};
5768 /**
5769 * offset 21340
5770 */
5771 blend_table_s ignBlends[IGN_BLEND_COUNT] = {};
5772 /**
5773 * offset 22092
5774 */
5775 blend_table_s veBlends[VE_BLEND_COUNT] = {};
5776 /**
5777 * units: %
5778 * offset 22844
5779 */
5780 scaled_channel<uint16_t, 10, 1> throttleEstimateEffectiveAreaBins[THR_EST_SIZE] = {};
5781 /**
5782 * In units of g/s normalized to choked flow conditions
5783 * units: g/s
5784 * offset 22868
5785 */
5786 scaled_channel<uint16_t, 10, 1> throttleEstimateEffectiveAreaValues[THR_EST_SIZE] = {};
5787 /**
5788 * offset 22892
5789 */
5790 blend_table_s boostOpenLoopBlends[BOOST_BLEND_COUNT] = {};
5791 /**
5792 * offset 23268
5793 */
5794 blend_table_s boostClosedLoopBlends[BOOST_BLEND_COUNT] = {};
5795 /**
5796 * units: level
5797 * offset 23644
5798 */
5799 float tcu_rangeP[RANGE_INPUT_COUNT] = {};
5800 /**
5801 * units: level
5802 * offset 23668
5803 */
5804 float tcu_rangeR[RANGE_INPUT_COUNT] = {};
5805 /**
5806 * units: level
5807 * offset 23692
5808 */
5809 float tcu_rangeN[RANGE_INPUT_COUNT] = {};
5810 /**
5811 * units: level
5812 * offset 23716
5813 */
5814 float tcu_rangeD[RANGE_INPUT_COUNT] = {};
5815 /**
5816 * units: level
5817 * offset 23740
5818 */
5819 float tcu_rangeM[RANGE_INPUT_COUNT] = {};
5820 /**
5821 * units: level
5822 * offset 23764
5823 */
5824 float tcu_rangeM3[RANGE_INPUT_COUNT] = {};
5825 /**
5826 * units: level
5827 * offset 23788
5828 */
5829 float tcu_rangeM2[RANGE_INPUT_COUNT] = {};
5830 /**
5831 * units: level
5832 * offset 23812
5833 */
5834 float tcu_rangeM1[RANGE_INPUT_COUNT] = {};
5835 /**
5836 * units: level
5837 * offset 23836
5838 */
5839 float tcu_rangePlus[RANGE_INPUT_COUNT] = {};
5840 /**
5841 * units: level
5842 * offset 23860
5843 */
5844 float tcu_rangeMinus[RANGE_INPUT_COUNT] = {};
5845 /**
5846 * units: level
5847 * offset 23884
5848 */
5849 float tcu_rangeLow[RANGE_INPUT_COUNT] = {};
5850 /**
5851 * units: lambda
5852 * offset 23908
5853 */
5854 scaled_channel<uint8_t, 100, 1> lambdaMaxDeviationTable[LAM_SIZE][LAM_SIZE] = {};
5855 /**
5856 * offset 23924
5857 */
5858 uint16_t lambdaMaxDeviationLoadBins[LAM_SIZE] = {};
5859 /**
5860 * units: RPM
5861 * offset 23932
5862 */
5863 uint16_t lambdaMaxDeviationRpmBins[LAM_SIZE] = {};
5864 /**
5865 * units: %
5866 * offset 23940
5867 */
5868 uint8_t injectorStagingTable[INJ_STAGING_COUNT][INJ_STAGING_COUNT] = {};
5869 /**
5870 * offset 23976
5871 */
5872 uint16_t injectorStagingLoadBins[INJ_STAGING_COUNT] = {};
5873 /**
5874 * units: RPM
5875 * offset 23988
5876 */
5877 uint16_t injectorStagingRpmBins[INJ_STAGING_COUNT] = {};
5878 /**
5879 * units: deg C
5880 * offset 24000
5881 */
5882 int8_t wwCltBins[WWAE_TABLE_SIZE] = {};
5883 /**
5884 * offset 24008
5885 */
5886 scaled_channel<uint8_t, 100, 1> wwTauCltValues[WWAE_TABLE_SIZE] = {};
5887 /**
5888 * offset 24016
5889 */
5890 scaled_channel<uint8_t, 100, 1> wwBetaCltValues[WWAE_TABLE_SIZE] = {};
5891 /**
5892 * units: kPa
5893 * offset 24024
5894 */
5895 int8_t wwMapBins[WWAE_TABLE_SIZE] = {};
5896 /**
5897 * offset 24032
5898 */
5899 scaled_channel<uint8_t, 100, 1> wwTauMapValues[WWAE_TABLE_SIZE] = {};
5900 /**
5901 * offset 24040
5902 */
5903 scaled_channel<uint8_t, 100, 1> wwBetaMapValues[WWAE_TABLE_SIZE] = {};
5904 /**
5905 * units: %
5906 * offset 24048
5907 */
5908 scaled_channel<uint8_t, 2, 1> hpfpLobeProfileQuantityBins[HPFP_LOBE_PROFILE_SIZE] = {};
5909 /**
5910 * units: deg
5911 * offset 24064
5912 */
5913 scaled_channel<uint8_t, 2, 1> hpfpLobeProfileAngle[HPFP_LOBE_PROFILE_SIZE] = {};
5914 /**
5915 * units: volts
5916 * offset 24080
5917 */
5918 uint8_t hpfpDeadtimeVoltsBins[HPFP_DEADTIME_SIZE] = {};
5919 /**
5920 * units: ms
5921 * offset 24088
5922 */
5923 scaled_channel<uint16_t, 1000, 1> hpfpDeadtimeMS[HPFP_DEADTIME_SIZE] = {};
5924 /**
5925 * units: kPa
5926 * offset 24104
5927 */
5928 uint16_t hpfpTarget[HPFP_TARGET_SIZE][HPFP_TARGET_SIZE] = {};
5929 /**
5930 * units: load
5931 * offset 24304
5932 */
5933 scaled_channel<uint16_t, 10, 1> hpfpTargetLoadBins[HPFP_TARGET_SIZE] = {};
5934 /**
5935 * units: RPM
5936 * offset 24324
5937 */
5938 scaled_channel<uint8_t, 1, 50> hpfpTargetRpmBins[HPFP_TARGET_SIZE] = {};
5939 /**
5940 * units: %
5941 * offset 24334
5942 */
5943 int8_t hpfpCompensation[HPFP_COMPENSATION_SIZE][HPFP_COMPENSATION_SIZE] = {};
5944 /**