rusEFI
The most advanced open source ECU
engine_configuration_generated_structures_cypress.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 Fri Mar 08 23:06:04 UTC 2024
2 // by class com.rusefi.output.CHeaderConsumer
3 // begin
4 #pragma once
5 #include "rusefi_types.h"
6 // start of 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 };
27 static_assert(sizeof(stft_cell_cfg_s) == 4);
28 
29 // start of stft_s
30 struct stft_s {
31  /**
32  * Below this RPM, the idle region is active
33  * units: RPM
34  * offset 0
35  */
36  scaled_channel<uint8_t, 1, 50> maxIdleRegionRpm;
37  /**
38  * Below this engine load, the overrun region is active
39  * units: load
40  * offset 1
41  */
42  uint8_t maxOverrunLoad;
43  /**
44  * Above this engine load, the power region is active
45  * units: load
46  * offset 2
47  */
48  uint8_t minPowerLoad;
49  /**
50  * 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.
51  * units: %
52  * offset 3
53  */
54  scaled_channel<uint8_t, 10, 1> deadband;
55  /**
56  * Below this temperature, correction is disabled.
57  * units: C
58  * offset 4
59  */
60  int8_t minClt;
61  /**
62  * Below this AFR, correction is paused
63  * units: afr
64  * offset 5
65  */
66  scaled_channel<uint8_t, 10, 1> minAfr;
67  /**
68  * Above this AFR, correction is paused
69  * units: afr
70  * offset 6
71  */
72  scaled_channel<uint8_t, 10, 1> maxAfr;
73  /**
74  * Delay after starting the engine before beginning closed loop correction.
75  * units: seconds
76  * offset 7
77  */
78  uint8_t startupDelay;
79  /**
80  * offset 8
81  */
82  stft_cell_cfg_s cellCfgs[STFT_CELL_COUNT];
83 };
84 static_assert(sizeof(stft_s) == 24);
85 
86 // start of pid_s
87 struct pid_s {
88  /**
89  * offset 0
90  */
91  float pFactor;
92  /**
93  * offset 4
94  */
95  float iFactor;
96  /**
97  * offset 8
98  */
99  float dFactor;
100  /**
101  * Linear addition to PID logic
102  * offset 12
103  */
104  int16_t offset;
105  /**
106  * PID dTime
107  * units: ms
108  * offset 14
109  */
110  int16_t periodMs;
111  /**
112  * Output Min Duty Cycle
113  * offset 16
114  */
115  int16_t minValue;
116  /**
117  * Output Max Duty Cycle
118  * offset 18
119  */
120  int16_t maxValue;
121 };
122 static_assert(sizeof(pid_s) == 20);
123 
124 // start of cranking_parameters_s
126  /**
127  * 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.
128  * A reasonable starting point is 60mg per liter per cylinder.
129  * ex: 2 liter 4 cyl = 500cc/cyl, so 30mg cranking fuel.
130  * units: mg
131  * offset 0
132  */
133  float baseFuel;
134  /**
135  * This sets the RPM limit below which the ECU will use cranking fuel and ignition logic, typically this is around 350-450rpm.
136  * set cranking_rpm X
137  * units: RPM
138  * offset 4
139  */
140  int16_t rpm;
141  /**
142  * need 4 byte alignment
143  * units: units
144  * offset 6
145  */
146  uint8_t alignmentFill_at_6[2];
147 };
148 static_assert(sizeof(cranking_parameters_s) == 8);
149 
150 // start of gppwm_channel
152  /**
153  * Select a pin to use for PWM or on-off output.
154  * offset 0
155  */
157  /**
158  * If an error (with a sensor, etc) is detected, this value is used instead of reading from the table.
159  * This should be a safe value for whatever hardware is connected to prevent damage.
160  * units: %
161  * offset 2
162  */
163  uint8_t dutyIfError;
164  /**
165  * need 4 byte alignment
166  * units: units
167  * offset 3
168  */
169  uint8_t alignmentFill_at_3[1];
170  /**
171  * Select a frequency to run PWM at.
172  * Set this to 0hz to enable on-off mode.
173  * units: hz
174  * offset 4
175  */
176  uint16_t pwmFrequency;
177  /**
178  * Hysteresis: in on-off mode, turn the output on when the table value is above this duty.
179  * units: %
180  * offset 6
181  */
182  uint8_t onAboveDuty;
183  /**
184  * Hysteresis: in on-off mode, turn the output off when the table value is below this duty.
185  * units: %
186  * offset 7
187  */
188  uint8_t offBelowDuty;
189  /**
190  * Selects the Y axis to use for the table.
191  * offset 8
192  */
194  /**
195  * Selects the X axis to use for the table.
196  * offset 9
197  */
199  /**
200  * units: load
201  * offset 10
202  */
203  scaled_channel<int16_t, 2, 1> loadBins[GPPWM_LOAD_COUNT];
204  /**
205  * units: RPM
206  * offset 26
207  */
208  int16_t rpmBins[GPPWM_RPM_COUNT];
209  /**
210  * units: duty
211  * offset 42
212  */
213  scaled_channel<uint8_t, 2, 1> table[GPPWM_LOAD_COUNT][GPPWM_RPM_COUNT];
214  /**
215  * need 4 byte alignment
216  * units: units
217  * offset 106
218  */
220 };
221 static_assert(sizeof(gppwm_channel) == 108);
222 
223 // start of air_pressure_sensor_config_s
225  /**
226  * kPa value at low volts
227  * units: kpa
228  * offset 0
229  */
230  float lowValue;
231  /**
232  * kPa value at high volts
233  * units: kpa
234  * offset 4
235  */
236  float highValue;
237  /**
238  * offset 8
239  */
241  /**
242  * offset 9
243  */
245  /**
246  * need 4 byte alignment
247  * units: units
248  * offset 10
249  */
251 };
252 static_assert(sizeof(air_pressure_sensor_config_s) == 12);
253 
254 // start of MAP_sensor_config_s
256  /**
257  * offset 0
258  */
259  float samplingAngleBins[MAP_ANGLE_SIZE];
260  /**
261  * MAP averaging sampling start crank degree angle
262  * units: deg
263  * offset 32
264  */
265  float samplingAngle[MAP_ANGLE_SIZE];
266  /**
267  * offset 64
268  */
269  float samplingWindowBins[MAP_WINDOW_SIZE];
270  /**
271  * MAP averaging angle crank degree duration
272  * units: deg
273  * offset 96
274  */
275  float samplingWindow[MAP_WINDOW_SIZE];
276  /**
277  * offset 128
278  */
280 };
281 static_assert(sizeof(MAP_sensor_config_s) == 140);
282 
283 /**
284  * @brief Thermistor known values
285 
286 */
287 // start of thermistor_conf_s
289  /**
290  * these values are in Celcius
291  * units: *C
292  * offset 0
293  */
294  float tempC_1;
295  /**
296  * units: *C
297  * offset 4
298  */
299  float tempC_2;
300  /**
301  * units: *C
302  * offset 8
303  */
304  float tempC_3;
305  /**
306  * units: Ohm
307  * offset 12
308  */
310  /**
311  * units: Ohm
312  * offset 16
313  */
315  /**
316  * units: Ohm
317  * offset 20
318  */
320  /**
321  * Pull-up resistor value on your board
322  * units: Ohm
323  * offset 24
324  */
326 };
327 static_assert(sizeof(thermistor_conf_s) == 28);
328 
329 // start of linear_sensor_s
331  /**
332  * offset 0
333  */
335  /**
336  * need 4 byte alignment
337  * units: units
338  * offset 1
339  */
340  uint8_t alignmentFill_at_1[3];
341  /**
342  * units: volts
343  * offset 4
344  */
345  float v1;
346  /**
347  * offset 8
348  */
349  float value1;
350  /**
351  * units: volts
352  * offset 12
353  */
354  float v2;
355  /**
356  * offset 16
357  */
358  float value2;
359 };
360 static_assert(sizeof(linear_sensor_s) == 20);
361 
362 // start of ThermistorConf
364  /**
365  * offset 0
366  */
368  /**
369  * offset 28
370  */
372  /**
373  * need 4 byte alignment
374  * units: units
375  * offset 29
376  */
378 };
379 static_assert(sizeof(ThermistorConf) == 32);
380 
381 // start of injector_s
382 struct injector_s {
383  /**
384  * This is your injector flow at the fuel pressure used in the vehicle. cc/min, cubic centimetre per minute
385  * By the way, g/s = 0.125997881 * (lb/hr)
386  * g/s = 0.125997881 * (cc/min)/10.5
387  * g/s = 0.0119997981 * cc/min
388  * units: cm3/min
389  * offset 0
390  */
391  float flow;
392  /**
393  * units: volts
394  * offset 4
395  */
396  float battLagCorrBins[VBAT_INJECTOR_CURVE_SIZE];
397  /**
398  * ms delay between injector open and close dead times
399  * units: ms
400  * offset 36
401  */
402  float battLagCorr[VBAT_INJECTOR_CURVE_SIZE];
403 };
404 static_assert(sizeof(injector_s) == 68);
405 
406 // start of trigger_config_s
408  /**
409  * https://github.com/rusefi/rusefi/wiki/All-Supported-Triggers
410  * set trigger_type X
411  * offset 0
412  */
414  /**
415  * units: number
416  * offset 4
417  */
419  /**
420  * units: number
421  * offset 8
422  */
424 };
425 static_assert(sizeof(trigger_config_s) == 12);
426 
427 // start of afr_sensor_s
428 struct afr_sensor_s {
429  /**
430  * offset 0
431  */
433  /**
434  * offset 1
435  */
437  /**
438  * need 4 byte alignment
439  * units: units
440  * offset 2
441  */
442  uint8_t alignmentFill_at_2[2];
443  /**
444  * units: volts
445  * offset 4
446  */
447  float v1;
448  /**
449  * units: AFR
450  * offset 8
451  */
452  float value1;
453  /**
454  * units: volts
455  * offset 12
456  */
457  float v2;
458  /**
459  * units: AFR
460  * offset 16
461  */
462  float value2;
463 };
464 static_assert(sizeof(afr_sensor_s) == 20);
465 
466 // start of idle_hardware_s
468  /**
469  * units: Hz
470  * offset 0
471  */
473  /**
474  * offset 4
475  */
477  /**
478  * offset 6
479  */
481  /**
482  * offset 8
483  */
485  /**
486  * offset 10
487  */
489  /**
490  * need 4 byte alignment
491  * units: units
492  * offset 11
493  */
495 };
496 static_assert(sizeof(idle_hardware_s) == 12);
497 
498 // start of dc_io
499 struct dc_io {
500  /**
501  * offset 0
502  */
504  /**
505  * offset 2
506  */
508  /**
509  * Acts as EN pin in two-wire mode
510  * offset 4
511  */
513  /**
514  * offset 6
515  */
517 };
518 static_assert(sizeof(dc_io) == 8);
519 
520 // start of vr_threshold_s
522  /**
523  * units: rpm
524  * offset 0
525  */
526  scaled_channel<uint8_t, 1, 50> rpmBins[6];
527  /**
528  * units: volts
529  * offset 6
530  */
531  scaled_channel<uint8_t, 100, 1> values[6];
532  /**
533  * offset 12
534  */
536  /**
537  * need 4 byte alignment
538  * units: units
539  * offset 14
540  */
542 };
543 static_assert(sizeof(vr_threshold_s) == 16);
544 
545 // start of engine_configuration_s
547  /**
548  * http://rusefi.com/wiki/index.php?title=Manual:Engine_Type
549  * set engine_type X
550  * offset 0
551  */
553  /**
554  * offset 2
555  */
557  /**
558  * Disable sensor sniffer above this rpm
559  * units: RPM
560  * offset 4
561  */
563  /**
564  * A secondary Rev limit engaged by the driver to help launch the vehicle faster
565  * units: rpm
566  * offset 6
567  */
568  uint16_t launchRpm;
569  /**
570  * set rpm_hard_limit X
571  * units: rpm
572  * offset 8
573  */
574  uint16_t rpmHardLimit;
575  /**
576  * Engine sniffer would be disabled above this rpm
577  * set engineSnifferRpmThreshold X
578  * units: RPM
579  * offset 10
580  */
582  /**
583  * Disable multispark above this engine speed.
584  * units: rpm
585  * offset 12
586  */
587  scaled_channel<uint8_t, 1, 50> multisparkMaxRpm;
588  /**
589  * Above this RPM, disable AC. Set to 0 to disable check.
590  * units: rpm
591  * offset 13
592  */
593  scaled_channel<uint8_t, 1, 50> maxAcRpm;
594  /**
595  * Above this TPS, disable AC. Set to 0 to disable check.
596  * units: %
597  * offset 14
598  */
599  uint8_t maxAcTps;
600  /**
601  * Above this CLT, disable AC to prevent overheating the engine. Set to 0 to disable check.
602  * units: deg C
603  * offset 15
604  */
605  uint8_t maxAcClt;
606  /**
607  * units: RPM
608  * offset 16
609  */
610  uint16_t knockNoiseRpmBins[ENGINE_NOISE_CURVE_SIZE];
611  /**
612  * 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.
613  * units: deg
614  * offset 48
615  */
617  /**
618  * Configures the maximum number of extra sparks to fire (does not include main spark)
619  * units: count
620  * offset 49
621  */
623  /**
624  * need 4 byte alignment
625  * units: units
626  * offset 50
627  */
629  /**
630  * offset 52
631  */
633  /**
634  * offset 120
635  */
637  /**
638  * Does the vehicle have a turbo or supercharger?
639  offset 188 bit 0 */
640  bool isForcedInduction : 1 {};
641  /**
642  * 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.
643  offset 188 bit 1 */
644  bool useFordRedundantTps : 1 {};
645  /**
646  offset 188 bit 2 */
647  bool enableKline : 1 {};
648  /**
649  offset 188 bit 3 */
650  bool overrideTriggerGaps : 1 {};
651  /**
652  * Turn on this fan when AC is on.
653  offset 188 bit 4 */
654  bool enableFan1WithAc : 1 {};
655  /**
656  * Turn on this fan when AC is on.
657  offset 188 bit 5 */
658  bool enableFan2WithAc : 1 {};
659  /**
660  * Inhibit operation of this fan while the engine is not running.
661  offset 188 bit 6 */
663  /**
664  * Inhibit operation of this fan while the engine is not running.
665  offset 188 bit 7 */
667  /**
668  * Enable secondary spark outputs that fire after the primary (rotaries, twin plug engines).
669  offset 188 bit 8 */
670  bool enableTrailingSparks : 1 {};
671  /**
672  * TLE7209 uses two-wire mode. TLE9201 and VNH2SP30 do NOT use two wire mode.
673  offset 188 bit 9 */
674  bool etb_use_two_wires : 1 {};
675  /**
676  * 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.
677  offset 188 bit 10 */
678  bool isDoubleSolenoidIdle : 1 {};
679  /**
680  offset 188 bit 11 */
681  bool useEeprom : 1 {};
682  /**
683  * Switch between Industrial and Cic PID implementation
684  offset 188 bit 12 */
685  bool useCicPidForIdle : 1 {};
686  /**
687  offset 188 bit 13 */
689  /**
690  offset 188 bit 14 */
691  bool kickStartCranking : 1 {};
692  /**
693  * This uses separate ignition timing and VE tables not only for idle conditions, also during the postcranking-to-idle taper transition (See also afterCrankingIACtaperDuration).
694  offset 188 bit 15 */
696  /**
697  offset 188 bit 16 */
698  bool launchControlEnabled : 1 {};
699  /**
700  * "Detect double trigger edges"
701  offset 188 bit 17 */
703  /**
704  offset 188 bit 18 */
705  bool antiLagEnabled : 1 {};
706  /**
707  * For cranking either use the specified fixed base fuel mass, or use the normal running math (VE table).
708  offset 188 bit 19 */
710  /**
711  * Shall we display real life signal or just the part consumed by trigger decoder.
712  * Applies to both trigger and cam/vvt input.
713  *
714  * enable logic_level_trigger
715  offset 188 bit 20 */
717  /**
718  offset 188 bit 21 */
719  bool useTLE8888_stepper : 1 {};
720  /**
721  offset 188 bit 22 */
723  /**
724  * Print incoming and outgoing first bus CAN messages in rusEFI console
725  offset 188 bit 23 */
726  bool verboseCan : 1 {};
727  /**
728  * Experimental setting that will cause a misfire
729  * DO NOT ENABLE.
730  offset 188 bit 24 */
732  /**
733  * 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.
734  offset 188 bit 25 */
735  bool useFordRedundantPps : 1 {};
736  /**
737  offset 188 bit 26 */
738  bool cltSensorPulldown : 1 {};
739  /**
740  offset 188 bit 27 */
741  bool iatSensorPulldown : 1 {};
742  /**
743  offset 188 bit 28 */
744  bool allowIdenticalPps : 1 {};
745  /**
746  offset 188 bit 29 */
748  /**
749  * If enabled - use onboard SPI Accelerometer, otherwise listen for CAN messages
750  offset 188 bit 30 */
751  bool useSpiImu : 1 {};
752  /**
753  offset 188 bit 31 */
755  /**
756  * Closed throttle, 1 volt = 200 units.
757  * See also tps1_1AdcChannel
758  * set tps_min X
759  * units: ADC
760  * offset 192
761  */
762  int16_t tpsMin;
763  /**
764  * Full throttle.
765  * See also tps1_1AdcChannel
766  * set tps_max X
767  * units: ADC
768  * offset 194
769  */
770  int16_t tpsMax;
771  /**
772  * TPS error detection: what throttle % is unrealistically low?
773  * Also used for accelerator pedal error detection if so equipped.
774  * units: %
775  * offset 196
776  */
778  /**
779  * TPS error detection: what throttle % is unrealistically high?
780  * Also used for accelerator pedal error detection if so equipped.
781  * units: %
782  * offset 198
783  */
785  /**
786  * offset 200
787  */
789  /**
790  * Dwell duration while cranking
791  * units: ms
792  * offset 208
793  */
795  /**
796  * Once engine speed passes this value, start reducing ETB angle.
797  * units: rpm
798  * offset 212
799  */
801  /**
802  * 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.
803  * units: rpm
804  * offset 214
805  */
807  /**
808  * @see isMapAveragingEnabled
809  * offset 216
810  */
812  /**
813  * todo: merge with channel settings, use full-scale Thermistor here!
814  * offset 356
815  */
817  /**
818  * offset 388
819  */
821  /**
822  * units: deg
823  * offset 420
824  */
826  /**
827  * value '6' for 8MHz hw osc
828  * read hip9011 datasheet for details
829  * todo split into two bit fields
830  * units: integer
831  * offset 424
832  */
834  /**
835  * We calculate knock band based of cylinderBore
836  * Use this to override - kHz knock band override
837  * Requires power cycling to effect
838  * units: kHz
839  * offset 428
840  */
842  /**
843  * Engine displacement in litres
844  * units: L
845  * offset 432
846  */
847  scaled_channel<uint16_t, 1000, 1> displacement;
848  /**
849  * units: RPM
850  * offset 434
851  */
853  /**
854  * Number of cylinder the engine has.
855  * offset 436
856  */
857  uint32_t cylindersCount;
858  /**
859  * offset 440
860  */
862  /**
863  * need 4 byte alignment
864  * units: units
865  * offset 441
866  */
868  /**
869  * offset 442
870  */
872  /**
873  * Cylinder diameter in mm.
874  * units: mm
875  * offset 444
876  */
878  /**
879  * This setting controls which fuel quantity control algorithm is used.
880  * Alpha-N means drive by TPS commonly only used for NA engines
881  * Speed Density requires MAP sensor and is the default choice for may installs
882  * MAF air charge is a cylinder filling based method that uses a mass air flow sensor.
883  * offset 448
884  */
886  /**
887  * units: %
888  * offset 449
889  */
890  uint8_t ALSMaxTPS;
891  /**
892  * This is the injection strategy during engine start. See Fuel/Injection settings for more detail. It is suggested to use "Simultaneous".
893  * offset 450
894  */
896  /**
897  * 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.
898  * offset 451
899  */
901  /**
902  * Minimum RPM to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases.
903  * offset 452
904  */
906  /**
907  * Minimum TPS to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases.
908  * offset 454
909  */
911  /**
912  * Minimum MAP to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases.
913  * offset 455
914  */
916  /**
917  * Ignition advance angle used during engine cranking, 5-10 degrees will work as a base setting for most engines.
918  * There is tapering towards running timing advance
919  * set cranking_timing_angle X
920  * units: deg
921  * offset 456
922  */
924  /**
925  * Single coil = distributor
926  * Individual coils = one coil per cylinder (COP, coil-near-plug), requires sequential mode
927  * Wasted spark = Fires pairs of cylinders together, either one coil per pair of cylinders or one coil per cylinder
928  * Two distributors = A pair of distributors, found on some BMW, Toyota and other engines
929  * set ignition_mode X
930  * offset 460
931  */
933  /**
934  * How many consecutive gap rations have to match expected ranges for sync to happen
935  * units: count
936  * offset 461
937  */
939  /**
940  * Above this speed, disable closed loop idle control. Set to 0 to disable (allow closed loop idle at any speed).
941  * units: kph
942  * offset 462
943  */
944  uint8_t maxIdleVss;
945  /**
946  * need 4 byte alignment
947  * units: units
948  * offset 463
949  */
951  /**
952  * 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.
953  * units: kPa
954  * offset 464
955  */
957  /**
958  * Dynamic uses the timing map to decide the ignition timing, Static timing fixes the timing to the value set below (only use for checking static timing with a timing light).
959  * offset 466
960  */
962  /**
963  * need 4 byte alignment
964  * units: units
965  * offset 467
966  */
968  /**
969  * This value is the ignition timing used when in 'fixed timing' mode, i.e. constant timing
970  * This mode is useful when adjusting distributor location.
971  * units: RPM
972  * offset 468
973  */
975  /**
976  * Angle between Top Dead Center (TDC) and the first trigger event.
977  * Positive value in case of synchronization point before TDC and negative in case of synchronization point after TDC
978  * .Knowing this angle allows us to control timing and other angles in reference to TDC.
979  * set global_trigger_offset_angle X
980  * units: deg btdc
981  * offset 472
982  */
984  /**
985  * 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.
986  * units: coef
987  * offset 476
988  */
990  /**
991  * 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.
992  * units: coef
993  * offset 480
994  */
996  /**
997  * Cooling fan turn-on temperature threshold, in Celsius
998  * units: deg C
999  * offset 484
1000  */
1002  /**
1003  * Cooling fan turn-off temperature threshold, in Celsius
1004  * units: deg C
1005  * offset 488
1006  */
1008  /**
1009  * offset 492
1010  */
1012  /**
1013  * need 4 byte alignment
1014  * units: units
1015  * offset 494
1016  */
1018  /**
1019  * 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.
1020  * units: revs/km
1021  * offset 496
1022  */
1024  /**
1025  * set can_mode X
1026  * offset 500
1027  */
1029  /**
1030  * need 4 byte alignment
1031  * units: units
1032  * offset 501
1033  */
1035  /**
1036  * CANbus thread period in ms
1037  * units: ms
1038  * offset 504
1039  */
1041  /**
1042  * offset 508
1043  */
1045  /**
1046  * offset 509
1047  */
1048  uint8_t justATempTest;
1049  /**
1050  * offset 510
1051  */
1052  uint8_t unusedHere333;
1053  /**
1054  * offset 511
1055  */
1056  uint8_t unusedHere334;
1057  /**
1058  * units: index
1059  * offset 512
1060  */
1062  /**
1063  * First throttle body, first sensor. See also pedalPositionAdcChannel
1064  * offset 516
1065  */
1067  /**
1068  * 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.
1069  * offset 517
1070  */
1072  /**
1073  * 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.
1074  * offset 518
1075  */
1077  /**
1078  * Second throttle body position sensor, single channel so far
1079  * set_analog_input_pin tps2 X
1080  * offset 519
1081  */
1083  /**
1084  * 0.1 is a good default value
1085  * units: x
1086  * offset 520
1087  */
1089  /**
1090  * just a temporary solution
1091  * units: angle
1092  * offset 524
1093  */
1095  /**
1096  * offset 528
1097  */
1099  /**
1100  * Extra air taper amount
1101  * units: %
1102  * offset 540
1103  */
1105  /**
1106  * offset 544
1107  */
1109  /**
1110  * 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.
1111  * units: %
1112  * offset 545
1113  */
1115  /**
1116  * offset 546
1117  */
1119  /**
1120  * offset 547
1121  */
1123  /**
1124  * offset 548
1125  */
1127  /**
1128  * units: volts
1129  * offset 552
1130  */
1131  float adcVcc;
1132  /**
1133  * units: Deg
1134  * offset 556
1135  */
1137  /**
1138  * 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.
1139  * offset 560
1140  */
1141  brain_input_pin_e camInputs[CAM_INPUTS_COUNT];
1142  /**
1143  * offset 568
1144  */
1146  /**
1147  * Electronic throttle pedal position first channel
1148  * See throttlePedalPositionSecondAdcChannel for second channel
1149  * See also tps1_1AdcChannel
1150  * set_analog_input_pin pps X
1151  * See throttlePedalUpVoltage and throttlePedalWOTVoltage
1152  * offset 588
1153  */
1155  /**
1156  * TPS/PPS error threshold
1157  * units: %
1158  * offset 589
1159  */
1160  scaled_channel<uint8_t, 10, 1> etbSplit;
1161  /**
1162  * offset 590
1163  */
1165  /**
1166  * offset 592
1167  */
1169  /**
1170  * offset 593
1171  */
1173  /**
1174  * Throttle Pedal not pressed switch - used on some older vehicles like early Mazda Miata
1175  * offset 594
1176  */
1178  /**
1179  * @see hasBaroSensor
1180  * offset 596
1181  */
1183  /**
1184  * offset 608
1185  */
1187  /**
1188  * Value between 0 and 100 used in Manual mode
1189  * units: %
1190  * offset 620
1191  */
1193  /**
1194  * Ignition timing to remove when a knock event occurs.
1195  * units: %
1196  * offset 624
1197  */
1198  scaled_channel<uint8_t, 10, 1> knockRetardAggression;
1199  /**
1200  * After a knock event, reapply timing at this rate.
1201  * units: deg/s
1202  * offset 625
1203  */
1204  scaled_channel<uint8_t, 10, 1> knockRetardReapplyRate;
1205  /**
1206  * Select which cam is used for engine sync. Other cams will be used only for VVT measurement, but not engine sync.
1207  * offset 626
1208  */
1210  /**
1211  * Set this so your vehicle speed signal is responsive, but not noisy. Larger value give smoother but slower response.
1212  * offset 627
1213  */
1215  /**
1216  * 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.
1217  * units: ratio
1218  * offset 628
1219  */
1220  scaled_channel<uint16_t, 1000, 1> vssGearRatio;
1221  /**
1222  * 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.
1223  * units: count
1224  * offset 630
1225  */
1226  uint8_t vssToothCount;
1227  /**
1228  * Override the Y axis (load) value used for only the Idle VE table.
1229  * Advanced users only: If you aren't sure you need this, you probably don't need this.
1230  * offset 631
1231  */
1233  /**
1234  * offset 632
1235  */
1237  /**
1238  * offset 634
1239  */
1240  output_pin_e injectionPins[MAX_CYLINDER_COUNT];
1241  /**
1242  * offset 658
1243  */
1244  output_pin_e ignitionPins[MAX_CYLINDER_COUNT];
1245  /**
1246  * offset 682
1247  */
1249  /**
1250  * offset 683
1251  */
1253  /**
1254  * offset 684
1255  */
1257  /**
1258  * offset 686
1259  */
1261  /**
1262  * How many consecutive VVT gap rations have to match expected ranges for sync to happen
1263  * units: count
1264  * offset 687
1265  */
1267  /**
1268  * Check engine light, also malfunction indicator light. Always blinks once on boot.
1269  * offset 688
1270  */
1272  /**
1273  * offset 690
1274  */
1276  /**
1277  * offset 691
1278  */
1280  /**
1281  * offset 692
1282  */
1284  /**
1285  * Some cars have a switch to indicate that clutch pedal is all the way down
1286  * offset 694
1287  */
1289  /**
1290  * offset 696
1291  */
1293  /**
1294  * offset 698
1295  */
1297  /**
1298  * offset 699
1299  */
1301  /**
1302  * offset 700
1303  */
1305  /**
1306  * offset 708
1307  */
1309  /**
1310  * offset 709
1311  */
1313  /**
1314  * offset 710
1315  */
1317  /**
1318  * Digital Potentiometer is used by stock ECU stimulation code
1319  * offset 712
1320  */
1322  /**
1323  * need 4 byte alignment
1324  * units: units
1325  * offset 713
1326  */
1328  /**
1329  * offset 714
1330  */
1332  /**
1333  * offset 716
1334  */
1336  /**
1337  * Useful in Research&Development phase
1338  * offset 717
1339  */
1341  /**
1342  * First throttle body, second sensor.
1343  * offset 718
1344  */
1346  /**
1347  * Second throttle body, second sensor.
1348  * offset 719
1349  */
1351  /**
1352  * Electronic throttle pedal position input
1353  * Second channel
1354  * See also tps1_1AdcChannel
1355  * See throttlePedalSecondaryUpVoltage and throttlePedalSecondaryWOTVoltage
1356  * offset 720
1357  */
1359  /**
1360  * units: %
1361  * offset 721
1362  */
1363  uint8_t fuelLevelValues[FUEL_LEVEL_TABLE_COUNT];
1364  /**
1365  * AFR, WBO, EGO - whatever you like to call it
1366  * offset 729
1367  */
1369  /**
1370  * offset 730
1371  */
1372  Gpio mc33810_cs[C_MC33810_COUNT];
1373  /**
1374  * 0.1 is a good default value
1375  * units: x
1376  * offset 732
1377  */
1379  /**
1380  * offset 736
1381  */
1382  brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT];
1383  /**
1384  * 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.
1385  * units: us
1386  * offset 740
1387  */
1389  /**
1390  * offset 742
1391  */
1393  /**
1394  * need 4 byte alignment
1395  * units: units
1396  * offset 743
1397  */
1399  /**
1400  * offset 744
1401  */
1403  /**
1404  * offset 746
1405  */
1407  /**
1408  * need 4 byte alignment
1409  * units: units
1410  * offset 747
1411  */
1413  /**
1414  * offset 748
1415  */
1417  /**
1418  * offset 750
1419  */
1421  /**
1422  * set_can_tx_pin X
1423  * offset 752
1424  */
1426  /**
1427  * set_can_rx_pin X
1428  * offset 754
1429  */
1431  /**
1432  * offset 756
1433  */
1435  /**
1436  * Additional idle % while A/C is active
1437  * units: %
1438  * offset 757
1439  */
1441  /**
1442  * Ratio between the wheels and your transmission output.
1443  * units: ratio
1444  * offset 758
1445  */
1446  scaled_channel<uint16_t, 100, 1> finalGearRatio;
1447  /**
1448  * offset 760
1449  */
1451  /**
1452  * offset 762
1453  */
1455  /**
1456  * need 4 byte alignment
1457  * units: units
1458  * offset 763
1459  */
1461  /**
1462  * Voltage when the wastegate is closed.
1463  * You probably don't have one of these!
1464  * units: mv
1465  * offset 764
1466  */
1468  /**
1469  * Voltage when the wastegate is fully open.
1470  * You probably don't have one of these!
1471  * 1 volt = 1000 units
1472  * units: mv
1473  * offset 766
1474  */
1476  /**
1477  * Voltage when the idle valve is closed.
1478  * You probably don't have one of these!
1479  * units: mv
1480  * offset 768
1481  */
1483  /**
1484  * Voltage when the idle valve is open.
1485  * You probably don't have one of these!
1486  * 1 volt = 1000 units
1487  * units: mv
1488  * offset 770
1489  */
1491  /**
1492  * Secondary TTL channel baud rate
1493  * units: BPs
1494  * offset 772
1495  */
1497  /**
1498  * Just for reference really, not taken into account by any logic at this point
1499  * units: CR
1500  * offset 776
1501  */
1503  /**
1504  * 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.
1505  * See also directSelfStimulation which is different.
1506  * offset 780
1507  */
1508  Gpio triggerSimulatorPins[TRIGGER_SIMULATOR_PIN_COUNT];
1509  /**
1510  * units: g/s
1511  * offset 784
1512  */
1513  scaled_channel<uint16_t, 1000, 1> fordInjectorSmallPulseSlope;
1514  /**
1515  * offset 786
1516  */
1517  pin_output_mode_e triggerSimulatorPinModes[TRIGGER_SIMULATOR_PIN_COUNT];
1518  /**
1519  * offset 788
1520  */
1522  /**
1523  * need 4 byte alignment
1524  * units: units
1525  * offset 789
1526  */
1528  /**
1529  * On-off O2 sensor heater control. 'ON' if engine is running, 'OFF' if stopped or cranking.
1530  * offset 790
1531  */
1533  /**
1534  * offset 792
1535  */
1537  /**
1538  * units: RPM
1539  * offset 793
1540  */
1541  scaled_channel<uint8_t, 1, 100> lambdaProtectionMinRpm;
1542  /**
1543  * units: %
1544  * offset 794
1545  */
1546  scaled_channel<uint8_t, 1, 10> lambdaProtectionMinLoad;
1547  /**
1548  * need 4 byte alignment
1549  * units: units
1550  * offset 795
1551  */
1553  /**
1554  offset 796 bit 0 */
1555  bool is_enabled_spi_1 : 1 {};
1556  /**
1557  offset 796 bit 1 */
1558  bool is_enabled_spi_2 : 1 {};
1559  /**
1560  offset 796 bit 2 */
1561  bool is_enabled_spi_3 : 1 {};
1562  /**
1563  * enable sd/disable sd
1564  offset 796 bit 3 */
1565  bool isSdCardEnabled : 1 {};
1566  /**
1567  * Use 11 bit (standard) or 29 bit (extended) IDs for rusEFI verbose CAN format.
1568  offset 796 bit 4 */
1569  bool rusefiVerbose29b : 1 {};
1570  /**
1571  offset 796 bit 5 */
1572  bool rethrowHardFault : 1 {};
1573  /**
1574  offset 796 bit 6 */
1575  bool isHip9011Enabled : 1 {};
1576  /**
1577  offset 796 bit 7 */
1579  /**
1580  offset 796 bit 8 */
1581  bool verboseQuad : 1 {};
1582  /**
1583  * This setting should only be used if you have a stepper motor idle valve and a stepper motor driver installed.
1584  offset 796 bit 9 */
1585  bool useStepperIdle : 1 {};
1586  /**
1587  offset 796 bit 10 */
1588  bool enabledStep1Limiter : 1 {};
1589  /**
1590  offset 796 bit 11 */
1591  bool useTpicAdvancedMode : 1 {};
1592  /**
1593  offset 796 bit 12 */
1595  /**
1596  offset 796 bit 13 */
1597  bool verboseTLE8888 : 1 {};
1598  /**
1599  * CAN broadcast using custom rusEFI protocol
1600  * enable can_broadcast/disable can_broadcast
1601  offset 796 bit 14 */
1602  bool enableVerboseCanTx : 1 {};
1603  /**
1604  offset 796 bit 15 */
1605  bool etb1configured : 1 {};
1606  /**
1607  offset 796 bit 16 */
1608  bool etb2configured : 1 {};
1609  /**
1610  * Useful for individual intakes
1611  offset 796 bit 17 */
1613  /**
1614  offset 796 bit 18 */
1616  /**
1617  * 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.
1618  offset 796 bit 19 */
1620  /**
1621  * This setting disables fuel injection while the engine is in overrun, this is useful as a fuel saving measure and to prevent back firing.
1622  offset 796 bit 20 */
1624  /**
1625  * 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.
1626  offset 796 bit 21 */
1628  /**
1629  offset 796 bit 22 */
1631  /**
1632  offset 796 bit 23 */
1634  /**
1635  * 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.
1636  offset 796 bit 24 */
1638  /**
1639  offset 796 bit 25 */
1640  bool is_enabled_spi_4 : 1 {};
1641  /**
1642  * Disable the electronic throttle motor and DC idle motor for testing.
1643  * This mode is for testing ETB/DC idle position sensors, etc without actually driving the throttle.
1644  offset 796 bit 26 */
1645  bool pauseEtbControl : 1 {};
1646  /**
1647  offset 796 bit 27 */
1649  /**
1650  offset 796 bit 28 */
1651  bool verboseKLine : 1 {};
1652  /**
1653  offset 796 bit 29 */
1655  /**
1656  * AEM X-Series or rusEFI Wideband
1657  offset 796 bit 30 */
1658  bool enableAemXSeries : 1 {};
1659  /**
1660  offset 796 bit 31 */
1661  bool unusedBit_230_31 : 1 {};
1662  /**
1663  * offset 800
1664  */
1665  brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT];
1666  /**
1667  * offset 808
1668  */
1670  /**
1671  * need 4 byte alignment
1672  * units: units
1673  * offset 809
1674  */
1676  /**
1677  * offset 810
1678  */
1680  /**
1681  * offset 812
1682  */
1684  /**
1685  * offset 814
1686  */
1688  /**
1689  * need 4 byte alignment
1690  * units: units
1691  * offset 815
1692  */
1694  /**
1695  * offset 816
1696  */
1698  /**
1699  * Boost Voltage
1700  * units: v
1701  * offset 820
1702  */
1703  uint8_t mc33_hvolt;
1704  /**
1705  * Minimum MAP before closed loop boost is enabled. Use to prevent misbehavior upon entering boost.
1706  * units: kPa
1707  * offset 821
1708  */
1710  /**
1711  * Optional Radiator Fan used with A/C
1712  * offset 822
1713  */
1715  /**
1716  * offset 824
1717  */
1719  /**
1720  * offset 825
1721  */
1723  /**
1724  * units: volts
1725  * offset 826
1726  */
1727  scaled_channel<uint8_t, 10, 1> dwellVoltageCorrVoltBins[DWELL_CURVE_SIZE];
1728  /**
1729  * offset 834
1730  */
1732  /**
1733  * units: multiplier
1734  * offset 835
1735  */
1736  scaled_channel<uint8_t, 50, 1> dwellVoltageCorrValues[DWELL_CURVE_SIZE];
1737  /**
1738  * need 4 byte alignment
1739  * units: units
1740  * offset 843
1741  */
1743  /**
1744  * units: kg
1745  * offset 844
1746  */
1747  uint16_t vehicleWeight;
1748  /**
1749  * How far above idle speed do we consider idling, i.e. coasting detection threshold.
1750  * For example, if target = 800, this param = 200, then anything below 1000 RPM is considered idle.
1751  * units: RPM
1752  * offset 846
1753  */
1755  /**
1756  * Apply nonlinearity correction below a pulse of this duration. Pulses longer than this duration will receive no adjustment.
1757  * units: ms
1758  * offset 848
1759  */
1760  scaled_channel<uint16_t, 1000, 1> applyNonlinearBelowPulse;
1761  /**
1762  * offset 850
1763  */
1765  /**
1766  * offset 852
1767  */
1769  /**
1770  * offset 854
1771  */
1773  /**
1774  * Some vehicles have a switch to indicate that clutch pedal is all the way up
1775  * offset 856
1776  */
1778  /**
1779  * offset 858
1780  */
1782  /**
1783  * offset 859
1784  */
1786  /**
1787  * offset 860
1788  */
1789  Gpio max31855_cs[EGT_CHANNEL_COUNT];
1790  /**
1791  * Continental/GM flex fuel sensor, 50-150hz type
1792  * offset 876
1793  */
1795  /**
1796  * offset 878
1797  */
1799  /**
1800  * offset 880
1801  */
1803  /**
1804  * offset 881
1805  */
1807  /**
1808  * Stoichiometric ratio for your secondary fuel. This value is used when the Flex Fuel sensor indicates E100, typically 9.0
1809  * units: :1
1810  * offset 882
1811  */
1812  scaled_channel<uint8_t, 10, 1> stoichRatioSecondary;
1813  /**
1814  * Maximum allowed ETB position. Some throttles go past fully open, so this allows you to limit it to fully open.
1815  * units: %
1816  * offset 883
1817  */
1819  /**
1820  * Rate the ECU will log to the SD card, in hz (log lines per second).
1821  * units: hz
1822  * offset 884
1823  */
1825  /**
1826  * offset 886
1827  */
1829  /**
1830  * need 4 byte alignment
1831  * units: units
1832  * offset 887
1833  */
1835  /**
1836  * offset 888
1837  */
1839  /**
1840  * offset 890
1841  */
1843  /**
1844  * On some vehicles we can disable starter once engine is already running
1845  * offset 892
1846  */
1848  /**
1849  * need 4 byte alignment
1850  * units: units
1851  * offset 893
1852  */
1854  /**
1855  * Some Subaru and some Mazda use double-solenoid idle air valve
1856  * offset 894
1857  */
1859  /**
1860  * See also starterControlPin
1861  * offset 896
1862  */
1864  /**
1865  * need 4 byte alignment
1866  * units: units
1867  * offset 898
1868  */
1870  /**
1871  * 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.
1872  * units: count
1873  * offset 900
1874  */
1876  /**
1877  * 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%.
1878  * units: %
1879  * offset 904
1880  */
1882  /**
1883  * units: %
1884  * offset 906
1885  */
1887  /**
1888  * units: ADC
1889  * offset 908
1890  */
1892  /**
1893  * units: ADC
1894  * offset 910
1895  */
1897  /**
1898  * units: rpm
1899  * offset 912
1900  */
1902  /**
1903  * Maximum time to crank starter when start/stop button is pressed
1904  * units: Seconds
1905  * offset 914
1906  */
1908  /**
1909  * This pin is used for debugging - snap a logic analyzer on it and see if it's ever high
1910  * offset 916
1911  */
1913  /**
1914  * offset 918
1915  */
1917  /**
1918  * need 4 byte alignment
1919  * units: units
1920  * offset 919
1921  */
1923  /**
1924  * offset 920
1925  */
1927  /**
1928  * units: %
1929  * offset 922
1930  */
1932  /**
1933  * Only respond once lambda is out of range for this period of time. Use to avoid transients triggering lambda protection when not needed
1934  * units: s
1935  * offset 923
1936  */
1937  scaled_channel<uint8_t, 10, 1> lambdaProtectionTimeout;
1938  /**
1939  * units: RPM
1940  * offset 924
1941  */
1942  scaled_channel<uint8_t, 1, 100> lambdaProtectionRestoreRpm;
1943  /**
1944  * offset 925
1945  */
1947  /**
1948  * need 4 byte alignment
1949  * units: units
1950  * offset 926
1951  */
1953  /**
1954  * offset 928
1955  */
1956  script_setting_t scriptSetting[SCRIPT_SETTING_COUNT];
1957  /**
1958  * offset 960
1959  */
1961  /**
1962  * offset 962
1963  */
1965  /**
1966  * offset 964
1967  */
1969  /**
1970  * offset 966
1971  */
1973  /**
1974  * offset 968
1975  */
1977  /**
1978  * offset 970
1979  */
1981  /**
1982  * offset 972
1983  */
1985  /**
1986  * offset 974
1987  */
1989  /**
1990  * offset 976
1991  */
1993  /**
1994  * Saab Combustion Detection Module knock signal input pin
1995  * also known as Saab Ion Sensing Module
1996  * offset 978
1997  */
1999  /**
2000  * offset 980
2001  */
2003  /**
2004  * rusEFI console Sensor Sniffer mode
2005  * offset 981
2006  */
2008  /**
2009  * offset 982
2010  */
2012  /**
2013  * need 4 byte alignment
2014  * units: units
2015  * offset 983
2016  */
2018  /**
2019  offset 984 bit 0 */
2020  bool clutchUpPinInverted : 1 {};
2021  /**
2022  offset 984 bit 1 */
2024  /**
2025  * If enabled we use two H-bridges to drive stepper idle air valve
2026  offset 984 bit 2 */
2028  /**
2029  offset 984 bit 3 */
2030  bool multisparkEnable : 1 {};
2031  /**
2032  offset 984 bit 4 */
2033  bool enableLaunchRetard : 1 {};
2034  /**
2035  offset 984 bit 5 */
2036  bool canInputBCM : 1 {};
2037  /**
2038  * This property is useful if using rusEFI as TCM or BCM only
2039  offset 984 bit 6 */
2040  bool consumeObdSensors : 1 {};
2041  /**
2042  * Read VSS from OEM CAN bus according to selected CAN vehicle configuration.
2043  offset 984 bit 7 */
2044  bool enableCanVss : 1 {};
2045  /**
2046  offset 984 bit 8 */
2047  bool enableInnovateLC2 : 1 {};
2048  /**
2049  offset 984 bit 9 */
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 984 bit 10 */
2055  /**
2056  offset 984 bit 11 */
2058  /**
2059  offset 984 bit 12 */
2060  bool enableSoftwareKnock : 1 {};
2061  /**
2062  * Verbose info in console below engineSnifferRpmThreshold
2063  * enable vvt_details
2064  offset 984 bit 13 */
2065  bool verboseVVTDecoding : 1 {};
2066  /**
2067  * get invertCamVVTSignal
2068  offset 984 bit 14 */
2069  bool invertCamVVTSignal : 1 {};
2070  /**
2071  * In Alpha-N mode, compensate for air temperature.
2072  offset 984 bit 15 */
2073  bool alphaNUseIat : 1 {};
2074  /**
2075  offset 984 bit 16 */
2076  bool knockBankCyl1 : 1 {};
2077  /**
2078  offset 984 bit 17 */
2079  bool knockBankCyl2 : 1 {};
2080  /**
2081  offset 984 bit 18 */
2082  bool knockBankCyl3 : 1 {};
2083  /**
2084  offset 984 bit 19 */
2085  bool knockBankCyl4 : 1 {};
2086  /**
2087  offset 984 bit 20 */
2088  bool knockBankCyl5 : 1 {};
2089  /**
2090  offset 984 bit 21 */
2091  bool knockBankCyl6 : 1 {};
2092  /**
2093  offset 984 bit 22 */
2094  bool knockBankCyl7 : 1 {};
2095  /**
2096  offset 984 bit 23 */
2097  bool knockBankCyl8 : 1 {};
2098  /**
2099  offset 984 bit 24 */
2100  bool knockBankCyl9 : 1 {};
2101  /**
2102  offset 984 bit 25 */
2103  bool knockBankCyl10 : 1 {};
2104  /**
2105  offset 984 bit 26 */
2106  bool knockBankCyl11 : 1 {};
2107  /**
2108  offset 984 bit 27 */
2109  bool knockBankCyl12 : 1 {};
2110  /**
2111  offset 984 bit 28 */
2112  bool tcuEnabled : 1 {};
2113  /**
2114  offset 984 bit 29 */
2116  /**
2117  * If enabled we use four Push-Pull outputs to directly drive stepper idle air valve coils
2118  offset 984 bit 30 */
2120  /**
2121  * Print incoming and outgoing second bus CAN messages in rusEFI console
2122  offset 984 bit 31 */
2123  bool verboseCan2 : 1 {};
2124  /**
2125  * offset 988
2126  */
2127  dc_io etbIo[ETB_COUNT];
2128  /**
2129  * Wastegate control Solenoid
2130  * offset 1004
2131  */
2133  /**
2134  * offset 1006
2135  */
2137  /**
2138  * need 4 byte alignment
2139  * units: units
2140  * offset 1007
2141  */
2143  /**
2144  * offset 1008
2145  */
2147  /**
2148  * offset 1010
2149  */
2151  /**
2152  * offset 1012
2153  */
2155  /**
2156  * offset 1032
2157  */
2159  /**
2160  * offset 1033
2161  */
2163  /**
2164  * offset 1034
2165  */
2167  /**
2168  * units: Hz
2169  * offset 1036
2170  */
2172  /**
2173  * offset 1040
2174  */
2176  /**
2177  * offset 1041
2178  */
2180  /**
2181  * need 4 byte alignment
2182  * units: units
2183  * offset 1042
2184  */
2186  /**
2187  * Launch disabled above this speed if setting is above zero
2188  * units: Kph
2189  * offset 1044
2190  */
2192  /**
2193  * Range from Launch RPM for Timing Retard to activate
2194  * units: RPM
2195  * offset 1048
2196  */
2198  /**
2199  * Spark Skip Transition Target
2200  * units: %
2201  * offset 1052
2202  */
2204  /**
2205  * Duty Cycle for the Boost Solenoid
2206  * units: %
2207  * offset 1056
2208  */
2210  /**
2211  * Range from Launch RPM to activate Hard Cut
2212  * units: RPM
2213  * offset 1060
2214  */
2216  /**
2217  * offset 1064
2218  */
2220  /**
2221  * offset 1068
2222  */
2224  /**
2225  * offset 1072
2226  */
2228  /**
2229  * offset 1076
2230  */
2232  /**
2233  * offset 1100
2234  */
2235  dc_io stepperDcIo[DC_PER_STEPPER];
2236  /**
2237  * For example, BMW, GM or Chevrolet
2238  * REQUIRED for rusEFI Online
2239  * offset 1116
2240  */
2242  /**
2243  * For example, LS1 or NB2
2244  * REQUIRED for rusEFI Online
2245  * offset 1148
2246  */
2248  /**
2249  * For example, Hunchback or Orange Miata
2250  * Vehicle name has to be unique between your vehicles.
2251  * REQUIRED for rusEFI Online
2252  * offset 1180
2253  */
2255  /**
2256  * offset 1212
2257  */
2258  output_pin_e tcu_solenoid[TCU_SOLENOID_COUNT];
2259  /**
2260  * offset 1224
2261  */
2263  /**
2264  * offset 1226
2265  */
2267  /**
2268  * need 4 byte alignment
2269  * units: units
2270  * offset 1227
2271  */
2273  /**
2274  * offset 1228
2275  */
2277  /**
2278  * offset 1230
2279  */
2281  /**
2282  * need 4 byte alignment
2283  * units: units
2284  * offset 1231
2285  */
2287  /**
2288  * offset 1232
2289  */
2291  /**
2292  * units: volt
2293  * offset 1234
2294  */
2295  scaled_channel<uint16_t, 1000, 1> fuelLevelBins[FUEL_LEVEL_TABLE_COUNT];
2296  /**
2297  * offset 1250
2298  */
2299  output_pin_e luaOutputPins[LUA_PWM_COUNT];
2300  /**
2301  * need 4 byte alignment
2302  * units: units
2303  * offset 1266
2304  */
2306  /**
2307  * Angle between cam sensor and VVT zero position
2308  * set vvt_offset X
2309  * units: value
2310  * offset 1268
2311  */
2312  float vvtOffsets[CAM_INPUTS_COUNT];
2313  /**
2314  * offset 1284
2315  */
2316  vr_threshold_s vrThreshold[VR_THRESHOLD_COUNT];
2317  /**
2318  * offset 1316
2319  */
2320  gppwm_note_t gpPwmNote[GPPWM_CHANNELS];
2321  /**
2322  * units: ADC
2323  * offset 1380
2324  */
2326  /**
2327  * units: ADC
2328  * offset 1382
2329  */
2331  /**
2332  * Select which bus the wideband controller is attached to.
2333  offset 1384 bit 0 */
2334  bool widebandOnSecondBus : 1 {};
2335  /**
2336  * Enables lambda sensor closed loop feedback for fuelling.
2337  offset 1384 bit 1 */
2339  /**
2340  * On even fire engines with even number of cylinders we go wasted spark during cranking. Use this setting to disable wasted spark cranking on odd fire engines.
2341  offset 1384 bit 2 */
2342  bool oddFireEngine : 1 {};
2343  /**
2344  offset 1384 bit 3 */
2345  bool boardUseTachPullUp : 1 {};
2346  /**
2347  offset 1384 bit 4 */
2348  bool boardUseTempPullUp : 1 {};
2349  /**
2350  offset 1384 bit 5 */
2352  /**
2353  * Sometimes we have a performance issue while printing error
2354  offset 1384 bit 6 */
2355  bool silentTriggerError : 1 {};
2356  /**
2357  offset 1384 bit 7 */
2358  bool useLinearCltSensor : 1 {};
2359  /**
2360  * enable can_read/disable can_read
2361  offset 1384 bit 8 */
2362  bool canReadEnabled : 1 {};
2363  /**
2364  * enable can_write/disable can_write. See also can1ListenMode
2365  offset 1384 bit 9 */
2366  bool canWriteEnabled : 1 {};
2367  /**
2368  offset 1384 bit 10 */
2369  bool useLinearIatSensor : 1 {};
2370  /**
2371  offset 1384 bit 11 */
2373  /**
2374  * Treat milliseconds value as duty cycle value, i.e. 0.5ms would become 50%
2375  offset 1384 bit 12 */
2377  /**
2378  * This enables smart alternator control and activates the extra alternator settings.
2379  offset 1384 bit 13 */
2381  /**
2382  * https://wiki.rusefi.com/Trigger-Configuration-Guide
2383  * This setting flips the signal from the primary engine speed sensor.
2384  offset 1384 bit 14 */
2386  /**
2387  * https://wiki.rusefi.com/Trigger-Configuration-Guide
2388  * This setting flips the signal from the secondary engine speed sensor.
2389  offset 1384 bit 15 */
2391  /**
2392  offset 1384 bit 16 */
2393  bool cutFuelOnHardLimit : 1 {};
2394  /**
2395  * Be careful enabling this: some engines are known to self-disassemble their valvetrain with a spark cut. Fuel cut is much safer.
2396  offset 1384 bit 17 */
2397  bool cutSparkOnHardLimit : 1 {};
2398  /**
2399  offset 1384 bit 18 */
2400  bool launchFuelCutEnable : 1 {};
2401  /**
2402  * This is the Cut Mode normally used
2403  offset 1384 bit 19 */
2405  /**
2406  offset 1384 bit 20 */
2407  bool boardUseCrankPullUp : 1 {};
2408  /**
2409  offset 1384 bit 21 */
2410  bool boardUseCamPullDown : 1 {};
2411  /**
2412  offset 1384 bit 22 */
2413  bool boardUseCamVrPullUp : 1 {};
2414  /**
2415  offset 1384 bit 23 */
2416  bool boardUseD2PullDown : 1 {};
2417  /**
2418  offset 1384 bit 24 */
2419  bool boardUseD3PullDown : 1 {};
2420  /**
2421  offset 1384 bit 25 */
2422  bool boardUseD4PullDown : 1 {};
2423  /**
2424  offset 1384 bit 26 */
2425  bool boardUseD5PullDown : 1 {};
2426  /**
2427  * Are you a developer troubleshooting TS over CAN ISO/TP?
2428  offset 1384 bit 27 */
2429  bool verboseIsoTp : 1 {};
2430  /**
2431  offset 1384 bit 28 */
2433  /**
2434  offset 1384 bit 29 */
2436  /**
2437  offset 1384 bit 30 */
2438  bool twoStroke : 1 {};
2439  /**
2440  * Where is your primary skipped wheel located?
2441  offset 1384 bit 31 */
2442  bool skippedWheelOnCam : 1 {};
2443  /**
2444  * offset 1388
2445  */
2447  /**
2448  * need 4 byte alignment
2449  * units: units
2450  * offset 1389
2451  */
2453  /**
2454  * A/C button input
2455  * offset 1390
2456  */
2458  /**
2459  * offset 1392
2460  */
2462  /**
2463  * Expected neutral position
2464  * units: %
2465  * offset 1393
2466  */
2468  /**
2469  * See also idleRpmPid
2470  * offset 1394
2471  */
2473  /**
2474  * need 4 byte alignment
2475  * units: units
2476  * offset 1395
2477  */
2479  /**
2480  offset 1396 bit 0 */
2481  bool isInjectionEnabled : 1 {};
2482  /**
2483  offset 1396 bit 1 */
2484  bool isIgnitionEnabled : 1 {};
2485  /**
2486  * When enabled if TPS is held above 95% no fuel is injected while cranking to clear excess fuel from the cylinders.
2487  offset 1396 bit 2 */
2489  /**
2490  * Should we use tables to vary tau/beta based on CLT/MAP, or just with fixed values?
2491  offset 1396 bit 3 */
2492  bool complexWallModel : 1 {};
2493  /**
2494  * RPM is measured based on last 720 degrees while instant RPM is measured based on the last 90 degrees of crank revolution
2495  offset 1396 bit 4 */
2496  bool alwaysInstantRpm : 1 {};
2497  /**
2498  offset 1396 bit 5 */
2500  /**
2501  * If enabled, use separate temperature multiplier table for cranking idle position.
2502  * If disabled, use normal running multiplier table applied to the cranking base position.
2503  offset 1396 bit 6 */
2505  /**
2506  * 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 retard at low idle speeds will prevent stalling and extra advance at high idle speeds can help reduce engine power and slow the idle speed.
2507  offset 1396 bit 7 */
2509  /**
2510  offset 1396 bit 8 */
2512  /**
2513  * This activates a separate fuel table for Idle, this allows fine tuning of the idle fuelling.
2514  offset 1396 bit 9 */
2516  /**
2517  * Verbose info in console below engineSnifferRpmThreshold
2518  * enable trigger_details
2519  offset 1396 bit 10 */
2521  /**
2522  * Usually if we have no trigger events that means engine is stopped
2523  * Unless we are troubleshooting and spinning the engine by hand - this case a longer
2524  * delay is needed
2525  offset 1396 bit 11 */
2527  /**
2528  offset 1396 bit 12 */
2529  bool cutFuelInAcr : 1 {};
2530  /**
2531  offset 1396 bit 13 */
2532  bool hondaK : 1 {};
2533  /**
2534  * This is needed if your coils are individually wired (COP) and you wish to use batch ignition (Wasted Spark).
2535  offset 1396 bit 14 */
2537  /**
2538  offset 1396 bit 15 */
2540  /**
2541  * In Constant mode, timing is automatically tapered to running as RPM increases.
2542  * In Table mode, the "Cranking ignition advance" table is used directly.
2543  offset 1396 bit 16 */
2545  /**
2546  * This enables the various ignition corrections during cranking (IAT, CLT, FSIO and PID idle).
2547  * You probably don't need this.
2548  offset 1396 bit 17 */
2550  /**
2551  * Enable a second cranking table to use for E100 flex fuel, interpolating between the two based on flex fuel sensor.
2552  offset 1396 bit 18 */
2553  bool flexCranking : 1 {};
2554  /**
2555  * This flag allows to use a special 'PID Multiplier' table (0.0-1.0) to compensate for nonlinear nature of IAC-RPM controller
2556  offset 1396 bit 19 */
2557  bool useIacPidMultTable : 1 {};
2558  /**
2559  offset 1396 bit 20 */
2561  /**
2562  * Interpolates the Ignition Retard from 0 to 100% within the RPM Range
2563  offset 1396 bit 21 */
2564  bool launchSmoothRetard : 1 {};
2565  /**
2566  * Some engines are OK running semi-random sequential while other engine require phase synchronization
2567  offset 1396 bit 22 */
2569  /**
2570  * If enabled, use a curve for RPM limit (based on coolant temperature) instead of a constant value.
2571  offset 1396 bit 23 */
2572  bool useCltBasedRpmLimit : 1 {};
2573  /**
2574  * If enabled, don't wait for engine start to heat O2 sensors. WARNING: this will reduce the life of your sensor, as condensation in the exhaust from a cold start can crack the sensing element.
2575  offset 1396 bit 24 */
2576  bool forceO2Heating : 1 {};
2577  /**
2578  * 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'.
2579  offset 1396 bit 25 */
2581  /**
2582  * 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'.
2583  offset 1396 bit 26 */
2585  /**
2586  offset 1396 bit 27 */
2588  /**
2589  * '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.
2590  offset 1396 bit 28 */
2591  bool sdTriggerLog : 1 {};
2592  /**
2593  offset 1396 bit 29 */
2594  bool ALSActivateInverted : 1 {};
2595  /**
2596  offset 1396 bit 30 */
2598  /**
2599  offset 1396 bit 31 */
2601  /**
2602  * units: count
2603  * offset 1400
2604  */
2606  /**
2607  * units: mult
2608  * offset 1404
2609  */
2611  /**
2612  * offset 1408
2613  */
2614  Gpio camInputsDebug[CAM_INPUTS_COUNT];
2615  /**
2616  * Idle target speed when A/C is enabled. Some cars need the extra speed to keep the AC efficient while idling.
2617  * units: RPM
2618  * offset 1416
2619  */
2621  /**
2622  * set warningPeriod X
2623  * units: seconds
2624  * offset 1418
2625  */
2626  int16_t warningPeriod;
2627  /**
2628  * units: angle
2629  * offset 1420
2630  */
2632  /**
2633  * units: angle
2634  * offset 1424
2635  */
2637  /**
2638  * units: ms
2639  * offset 1428
2640  */
2642  /**
2643  * units: count
2644  * offset 1432
2645  */
2647  /**
2648  * TODO: finish this #413
2649  * units: sec
2650  * offset 1436
2651  */
2653  /**
2654  * At what trigger index should some MAP-related math be executed? This is a performance trick to reduce load on synchronization trigger callback.
2655  * units: index
2656  * offset 1440
2657  */
2659  /**
2660  * Duration in ms or duty cycle depending on selected mode
2661  * offset 1444
2662  */
2664  /**
2665  * Length of time the deposited wall fuel takes to dissipate after the start of acceleration.
2666  * units: Seconds
2667  * offset 1448
2668  */
2669  float wwaeTau;
2670  /**
2671  * offset 1452
2672  */
2674  /**
2675  * offset 1472
2676  */
2678  /**
2679  * offset 1492
2680  */
2681  Gpio triggerInputDebugPins[TRIGGER_INPUT_PIN_COUNT];
2682  /**
2683  * RPM range above upper limit for extra air taper
2684  * units: RPM
2685  * offset 1496
2686  */
2688  /**
2689  * offset 1498
2690  */
2692  /**
2693  * Closed throttle#2. todo: extract these two fields into a structure
2694  * See also tps2_1AdcChannel
2695  * set tps2_min X
2696  * units: ADC
2697  * offset 1500
2698  */
2699  int16_t tps2Min;
2700  /**
2701  * Full throttle#2. tpsMax value as 10 bit ADC value. Not Voltage!
2702  * See also tps1_1AdcChannel
2703  * set tps2_max X
2704  * units: ADC
2705  * offset 1502
2706  */
2707  int16_t tps2Max;
2708  /**
2709  * See also startStopButtonPin
2710  * offset 1504
2711  */
2713  /**
2714  * offset 1506
2715  */
2717  /**
2718  * need 4 byte alignment
2719  * units: units
2720  * offset 1507
2721  */
2723  /**
2724  * offset 1508
2725  */
2727  /**
2728  * units: Pulse
2729  * offset 1510
2730  */
2732  /**
2733  * need 4 byte alignment
2734  * units: units
2735  * offset 1511
2736  */
2738  /**
2739  * kPa value which is too low to be true
2740  * units: kPa
2741  * offset 1512
2742  */
2744  /**
2745  * kPa value which is too high to be true
2746  * units: kPa
2747  * offset 1516
2748  */
2750  /**
2751  * How long to wait for the spark to fire before recharging the coil for another spark.
2752  * units: ms
2753  * offset 1520
2754  */
2755  scaled_channel<uint16_t, 1000, 1> multisparkSparkDuration;
2756  /**
2757  * This sets the dwell time for subsequent sparks. The main spark's dwell is set by the dwell table.
2758  * units: ms
2759  * offset 1522
2760  */
2761  scaled_channel<uint16_t, 1000, 1> multisparkDwell;
2762  /**
2763  * See cltIdleRpmBins
2764  * offset 1524
2765  */
2767  /**
2768  * 0 = No fuel settling on port walls 1 = All the fuel settling on port walls setting this to 0 disables the wall wetting enrichment.
2769  * units: Fraction
2770  * offset 1544
2771  */
2772  float wwaeBeta;
2773  /**
2774  * See also EFI_CONSOLE_RX_BRAIN_PIN
2775  * offset 1548
2776  */
2778  /**
2779  * offset 1550
2780  */
2782  /**
2783  * offset 1552
2784  */
2785  Gpio auxValves[AUX_DIGITAL_VALVE_COUNT];
2786  /**
2787  * offset 1556
2788  */
2790  /**
2791  * offset 1558
2792  */
2794  /**
2795  * units: voltage
2796  * offset 1560
2797  */
2799  /**
2800  * Pedal in the floor
2801  * units: voltage
2802  * offset 1564
2803  */
2805  /**
2806  * on IGN voltage detection turn fuel pump on to build fuel pressure
2807  * units: seconds
2808  * offset 1568
2809  */
2811  /**
2812  * If the RPM closer to target than this value, disable closed loop idle correction to prevent oscillation
2813  * units: RPM
2814  * offset 1570
2815  */
2817  /**
2818  * This is the target battery voltage the alternator PID control will attempt to maintain
2819  * units: Volts
2820  * offset 1572
2821  */
2823  /**
2824  * See Over/Undervoltage Shutdown/Retry bit in documentation
2825  offset 1576 bit 0 */
2827  /**
2828  offset 1576 bit 1 */
2829  bool mc33810Gpgd0Mode : 1 {};
2830  /**
2831  offset 1576 bit 2 */
2832  bool mc33810Gpgd1Mode : 1 {};
2833  /**
2834  offset 1576 bit 3 */
2835  bool mc33810Gpgd2Mode : 1 {};
2836  /**
2837  offset 1576 bit 4 */
2838  bool mc33810Gpgd3Mode : 1 {};
2839  /**
2840  offset 1576 bit 5 */
2842  /**
2843  offset 1576 bit 6 */
2844  bool luaCanRxWorkaround : 1 {};
2845  /**
2846  offset 1576 bit 7 */
2847  bool flexSensorInverted : 1 {};
2848  /**
2849  offset 1576 bit 8 */
2851  /**
2852  offset 1576 bit 9 */
2853  bool unusedBit_495_9 : 1 {};
2854  /**
2855  offset 1576 bit 10 */
2856  bool unusedBit_495_10 : 1 {};
2857  /**
2858  offset 1576 bit 11 */
2860  /**
2861  * VSS and auxSpeed1 or auxSpeed1 with auxSpeed2?
2862  offset 1576 bit 12 */
2864  /**
2865  offset 1576 bit 13 */
2866  bool is_enabled_spi_5 : 1 {};
2867  /**
2868  offset 1576 bit 14 */
2869  bool is_enabled_spi_6 : 1 {};
2870  /**
2871  offset 1576 bit 15 */
2872  bool unusedBit_503_15 : 1 {};
2873  /**
2874  offset 1576 bit 16 */
2875  bool unusedBit_503_16 : 1 {};
2876  /**
2877  offset 1576 bit 17 */
2878  bool unusedBit_503_17 : 1 {};
2879  /**
2880  offset 1576 bit 18 */
2881  bool unusedBit_511_18 : 1 {};
2882  /**
2883  offset 1576 bit 19 */
2884  bool unusedBit_511_19 : 1 {};
2885  /**
2886  offset 1576 bit 20 */
2887  bool unusedBit_511_20 : 1 {};
2888  /**
2889  offset 1576 bit 21 */
2890  bool unusedBit_511_21 : 1 {};
2891  /**
2892  offset 1576 bit 22 */
2893  bool unusedBit_511_22 : 1 {};
2894  /**
2895  offset 1576 bit 23 */
2896  bool unusedBit_511_23 : 1 {};
2897  /**
2898  offset 1576 bit 24 */
2899  bool unusedBit_511_24 : 1 {};
2900  /**
2901  offset 1576 bit 25 */
2902  bool unusedBit_511_25 : 1 {};
2903  /**
2904  offset 1576 bit 26 */
2905  bool unusedBit_511_26 : 1 {};
2906  /**
2907  offset 1576 bit 27 */
2908  bool unusedBit_511_27 : 1 {};
2909  /**
2910  offset 1576 bit 28 */
2911  bool unusedBit_511_28 : 1 {};
2912  /**
2913  offset 1576 bit 29 */
2914  bool unusedBit_511_29 : 1 {};
2915  /**
2916  offset 1576 bit 30 */
2917  bool unusedBit_511_30 : 1 {};
2918  /**
2919  offset 1576 bit 31 */
2920  bool unusedBit_511_31 : 1 {};
2921  /**
2922  * 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.
2923  * units: cycles
2924  * offset 1580
2925  */
2927  /**
2928  * IAC Value added when coasting and transitioning into idle.
2929  * units: percent
2930  * offset 1582
2931  */
2932  int16_t iacByTpsTaper;
2933  /**
2934  * Auxiliary sensor serial, not to be confused with secondary calibration serial
2935  * offset 1584
2936  */
2938  /**
2939  * Auxiliary sensor serial, not to be confused with secondary calibration serial
2940  * offset 1586
2941  */
2943  /**
2944  * offset 1588
2945  */
2947  /**
2948  * How long to look back for TPS-based acceleration enrichment. Increasing this time will trigger enrichment for longer when a throttle position change occurs.
2949  * units: sec
2950  * offset 1590
2951  */
2952  scaled_channel<uint8_t, 20, 1> tpsAccelLookback;
2953  /**
2954  * Below this speed, disable DFCO. Use this to prevent jerkiness from fuel enable/disable in low gears.
2955  * units: kph
2956  * offset 1591
2957  */
2959  /**
2960  * Above this speed, allow DFCO. Use this to prevent jerkiness from fuel enable/disable in low gears.
2961  * units: kph
2962  * offset 1592
2963  */
2965  /**
2966  * 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.
2967  * units: sec
2968  * offset 1593
2969  */
2970  scaled_channel<uint8_t, 10, 1> noFuelTrimAfterDfcoTime;
2971  /**
2972  * need 4 byte alignment
2973  * units: units
2974  * offset 1594
2975  */
2977  /**
2978  * 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.
2979  * units: roc
2980  * offset 1596
2981  */
2983  /**
2984  * offset 1600
2985  */
2987  /**
2988  * offset 1604
2989  */
2991  /**
2992  * Sets what part of injection's is controlled by the injection phase table.
2993  * offset 1605
2994  */
2996  /**
2997  * See http://rusefi.com/s/debugmode
2998  * offset 1606
2999  */
3001  /**
3002  * Additional idle % when fan #1 is active
3003  * units: %
3004  * offset 1607
3005  */
3006  uint8_t fan1ExtraIdle;
3007  /**
3008  * Band rate for primary TTL
3009  * units: BPs
3010  * offset 1608
3011  */
3013  /**
3014  * For decel we simply multiply delta of TPS and tFor decel we do not use table?!
3015  * units: roc
3016  * offset 1612
3017  */
3019  /**
3020  * Magic multiplier, we multiply delta of TPS and get fuel squirt duration
3021  * units: coeff
3022  * offset 1616
3023  */
3025  /**
3026  * units: BPs
3027  * offset 1620
3028  */
3029  uint32_t auxSerialSpeed;
3030  /**
3031  * units: voltage
3032  * offset 1624
3033  */
3035  /**
3036  * Pedal in the floor
3037  * units: voltage
3038  * offset 1628
3039  */
3041  /**
3042  * set can_baudrate
3043  * offset 1632
3044  */
3046  /**
3047  * Override the Y axis (load) value used for the VE table.
3048  * Advanced users only: If you aren't sure you need this, you probably don't need this.
3049  * offset 1633
3050  */
3052  /**
3053  * offset 1634
3054  */
3056  /**
3057  * Override the Y axis (load) value used for the AFR table.
3058  * Advanced users only: If you aren't sure you need this, you probably don't need this.
3059  * offset 1635
3060  */
3062  /**
3063  * units: A
3064  * offset 1636
3065  */
3066  scaled_channel<uint8_t, 10, 1> mc33_hpfp_i_peak;
3067  /**
3068  * units: A
3069  * offset 1637
3070  */
3071  scaled_channel<uint8_t, 10, 1> mc33_hpfp_i_hold;
3072  /**
3073  * How long to deactivate power when hold current is reached before applying power again
3074  * units: us
3075  * offset 1638
3076  */
3078  /**
3079  * Maximum amount of time the solenoid can be active before assuming a programming error
3080  * units: ms
3081  * offset 1639
3082  */
3084  /**
3085  * Enable if DC-motor driver (H-bridge) inverts the signals (eg. RZ7899 on Hellen boards)
3086  offset 1640 bit 0 */
3088  /**
3089  * Allow OpenBLT on Primary CAN
3090  offset 1640 bit 1 */
3091  bool canOpenBLT : 1 {};
3092  /**
3093  * Allow OpenBLT on Secondary CAN
3094  offset 1640 bit 2 */
3095  bool can2OpenBLT : 1 {};
3096  /**
3097  * Select whether to configure injector flow in volumetric flow (defualt, cc/min) or mass flow (g/s).
3098  offset 1640 bit 3 */
3100  /**
3101  offset 1640 bit 4 */
3103  /**
3104  offset 1640 bit 5 */
3105  bool kLineDoHondaSend : 1 {};
3106  /**
3107  * ListenMode is about acknowledging CAN traffic on the protocol level. Different from canWriteEnabled
3108  offset 1640 bit 6 */
3109  bool can1ListenMode : 1 {};
3110  /**
3111  offset 1640 bit 7 */
3112  bool can2ListenMode : 1 {};
3113  /**
3114  offset 1640 bit 8 */
3115  bool unusedBit_563_8 : 1 {};
3116  /**
3117  offset 1640 bit 9 */
3118  bool unusedBit_563_9 : 1 {};
3119  /**
3120  offset 1640 bit 10 */
3121  bool unusedBit_563_10 : 1 {};
3122  /**
3123  offset 1640 bit 11 */
3124  bool unusedBit_563_11 : 1 {};
3125  /**
3126  offset 1640 bit 12 */
3127  bool unusedBit_563_12 : 1 {};
3128  /**
3129  offset 1640 bit 13 */
3130  bool unusedBit_563_13 : 1 {};
3131  /**
3132  offset 1640 bit 14 */
3133  bool unusedBit_563_14 : 1 {};
3134  /**
3135  offset 1640 bit 15 */
3136  bool unusedBit_563_15 : 1 {};
3137  /**
3138  offset 1640 bit 16 */
3139  bool unusedBit_563_16 : 1 {};
3140  /**
3141  offset 1640 bit 17 */
3142  bool unusedBit_563_17 : 1 {};
3143  /**
3144  offset 1640 bit 18 */
3145  bool unusedBit_563_18 : 1 {};
3146  /**
3147  offset 1640 bit 19 */
3148  bool unusedBit_563_19 : 1 {};
3149  /**
3150  offset 1640 bit 20 */
3151  bool unusedBit_563_20 : 1 {};
3152  /**
3153  offset 1640 bit 21 */
3154  bool unusedBit_563_21 : 1 {};
3155  /**
3156  offset 1640 bit 22 */
3157  bool unusedBit_563_22 : 1 {};
3158  /**
3159  offset 1640 bit 23 */
3160  bool unusedBit_563_23 : 1 {};
3161  /**
3162  offset 1640 bit 24 */
3163  bool unusedBit_563_24 : 1 {};
3164  /**
3165  offset 1640 bit 25 */
3166  bool unusedBit_563_25 : 1 {};
3167  /**
3168  offset 1640 bit 26 */
3169  bool unusedBit_563_26 : 1 {};
3170  /**
3171  offset 1640 bit 27 */
3172  bool unusedBit_563_27 : 1 {};
3173  /**
3174  offset 1640 bit 28 */
3175  bool unusedBit_563_28 : 1 {};
3176  /**
3177  offset 1640 bit 29 */
3178  bool unusedBit_563_29 : 1 {};
3179  /**
3180  offset 1640 bit 30 */
3181  bool unusedBit_563_30 : 1 {};
3182  /**
3183  offset 1640 bit 31 */
3184  bool unusedBit_563_31 : 1 {};
3185  /**
3186  * offset 1644
3187  */
3189  /**
3190  * offset 1645
3191  */
3193  /**
3194  * Duration of each test pulse
3195  * units: ms
3196  * offset 1646
3197  */
3198  scaled_channel<uint16_t, 100, 1> benchTestOnTime;
3199  /**
3200  * units: %
3201  * offset 1648
3202  */
3204  /**
3205  * units: %
3206  * offset 1649
3207  */
3208  scaled_channel<uint8_t, 1, 10> lambdaProtectionRestoreLoad;
3209  /**
3210  * offset 1650
3211  */
3213  /**
3214  * need 4 byte alignment
3215  * units: units
3216  * offset 1651
3217  */
3219  /**
3220  * set_can2_tx_pin X
3221  * offset 1652
3222  */
3224  /**
3225  * set_can2_rx_pin X
3226  * offset 1654
3227  */
3229  /**
3230  * offset 1656
3231  */
3233  /**
3234  * offset 1657
3235  */
3237  /**
3238  * Override the Y axis (load) value used for the ignition table.
3239  * Advanced users only: If you aren't sure you need this, you probably don't need this.
3240  * offset 1658
3241  */
3243  /**
3244  * Select which fuel pressure sensor measures the pressure of the fuel at your injectors.
3245  * offset 1659
3246  */
3248  /**
3249  * offset 1660
3250  */
3252  /**
3253  * offset 1662
3254  */
3256  /**
3257  * need 4 byte alignment
3258  * units: units
3259  * offset 1663
3260  */
3262  /**
3263  * MAP value above which fuel is cut in case of overboost.
3264  * Set to 0 to disable overboost cut.
3265  * units: kPa (absolute)
3266  * offset 1664
3267  */
3269  /**
3270  * units: kg/h
3271  * offset 1668
3272  */
3273  scaled_channel<uint8_t, 1, 5> tchargeBins[16];
3274  /**
3275  * units: ratio
3276  * offset 1684
3277  */
3278  scaled_channel<uint8_t, 100, 1> tchargeValues[16];
3279  /**
3280  * Fixed timing, useful for TDC testing
3281  * units: deg
3282  * offset 1700
3283  */
3285  /**
3286  * MAP voltage for low point
3287  * units: v
3288  * offset 1704
3289  */
3291  /**
3292  * MAP voltage for low point
3293  * units: v
3294  * offset 1708
3295  */
3297  /**
3298  * EGO value correction
3299  * units: value
3300  * offset 1712
3301  */
3303  /**
3304  * VVT output solenoid pin for this cam
3305  * offset 1716
3306  */
3307  output_pin_e vvtPins[CAM_INPUTS_COUNT];
3308  /**
3309  * offset 1724
3310  */
3312  /**
3313  * need 4 byte alignment
3314  * units: units
3315  * offset 1725
3316  */
3318  /**
3319  * This is the IAC position during cranking, some engines start better if given more air during cranking to improve cylinder filling.
3320  * units: percent
3321  * offset 1728
3322  */
3324  /**
3325  * offset 1732
3326  */
3328  /**
3329  * offset 1736
3330  */
3332  /**
3333  * offset 1740
3334  */
3336  /**
3337  * offset 1744
3338  */
3340  /**
3341  * offset 1748
3342  */
3344  /**
3345  * 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.
3346  * units: deg BTDC
3347  * offset 1750
3348  */
3350  /**
3351  * 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
3352  * units: deg BTDC
3353  * offset 1751
3354  */
3356  /**
3357  * units: Hz
3358  * offset 1752
3359  */
3361  /**
3362  * set vvt_mode X
3363  * offset 1756
3364  */
3365  vvt_mode_e vvtMode[CAMS_PER_BANK];
3366  /**
3367  * Additional idle % when fan #2 is active
3368  * units: %
3369  * offset 1758
3370  */
3371  uint8_t fan2ExtraIdle;
3372  /**
3373  * Delay to allow fuel pressure to build before firing the priming pulse.
3374  * units: sec
3375  * offset 1759
3376  */
3377  scaled_channel<uint8_t, 100, 1> primingDelay;
3378  /**
3379  * offset 1760
3380  */
3381  adc_channel_e auxAnalogInputs[LUA_ANALOG_INPUT_COUNT];
3382  /**
3383  * offset 1768
3384  */
3385  output_pin_e trailingCoilPins[MAX_CYLINDER_COUNT];
3386  /**
3387  * offset 1792
3388  */
3390  /**
3391  * offset 1793
3392  */
3394  /**
3395  * None = I have a MAP-referenced fuel pressure regulator
3396  * Fixed rail pressure = I have an atmosphere-referenced fuel pressure regulator (returnless, typically)
3397  * Sensed rail pressure = I have a fuel pressure sensor
3398  * offset 1794
3399  */
3401  /**
3402  * offset 1795
3403  */
3405  /**
3406  * This is the pressure at which your injector flow is known.
3407  * For example if your injectors flow 400cc/min at 3.5 bar, enter 350kpa here.
3408  * units: kPa
3409  * offset 1796
3410  */
3412  /**
3413  * units: mult
3414  * offset 1800
3415  */
3416  float postCrankingFactor[CRANKING_ENRICH_COUNT][CRANKING_ENRICH_COUNT];
3417  /**
3418  * units: count
3419  * offset 1944
3420  */
3421  float postCrankingDurationBins[CRANKING_ENRICH_COUNT];
3422  /**
3423  * units: C
3424  * offset 1968
3425  */
3426  float postCrankingCLTBins[CRANKING_ENRICH_COUNT];
3427  /**
3428  * offset 1992
3429  */
3431  /**
3432  * offset 2024
3433  */
3435  /**
3436  * units: Deg
3437  * offset 2056
3438  */
3440  /**
3441  * units: Hz
3442  * offset 2058
3443  */
3444  int16_t etbFreq;
3445  /**
3446  * offset 2060
3447  */
3449  /**
3450  * For micro-stepping, make sure that PWM frequency (etbFreq) is high enough
3451  * offset 2080
3452  */
3454  /**
3455  * Use to limit the current when the stepper motor is idle, not moving (100% = no limit)
3456  * units: %
3457  * offset 2081
3458  */
3460  /**
3461  * Use to limit the max.current through the stepper motor (100% = no limit)
3462  * units: %
3463  * offset 2082
3464  */
3466  /**
3467  * offset 2083
3468  */
3470  /**
3471  * per-cylinder ignition and fueling timing correction for uneven engines
3472  * units: deg
3473  * offset 2084
3474  */
3475  angle_t timing_offset_cylinder[MAX_CYLINDER_COUNT];
3476  /**
3477  * units: seconds
3478  * offset 2132
3479  */
3481  /**
3482  * offset 2136
3483  */
3485  /**
3486  * Modes count be used for 3v<>5v integration using pull-ups/pull-downs etc.
3487  * offset 2137
3488  */
3490  /**
3491  * offset 2138
3492  */
3494  /**
3495  * offset 2139
3496  */
3498  /**
3499  * offset 2140
3500  */
3502  /**
3503  * offset 2141
3504  */
3506  /**
3507  * offset 2142
3508  */
3510  /**
3511  * offset 2143
3512  */
3514  /**
3515  * offset 2144
3516  */
3518  /**
3519  * offset 2145
3520  */
3522  /**
3523  * ResetB
3524  * offset 2146
3525  */
3527  /**
3528  * offset 2148
3529  */
3531  /**
3532  * Brake pedal switch
3533  * offset 2150
3534  */
3536  /**
3537  * offset 2152
3538  */
3540  /**
3541  * need 4 byte alignment
3542  * units: units
3543  * offset 2153
3544  */
3546  /**
3547  * VVT output PID
3548  * TODO: rename to vvtPid
3549  * offset 2156
3550  */
3551  pid_s auxPid[CAMS_PER_BANK];
3552  /**
3553  * offset 2196
3554  */
3556  /**
3557  * units: C
3558  * offset 2228
3559  */
3560  int8_t primeBins[PRIME_CURVE_COUNT];
3561  /**
3562  * offset 2236
3563  */
3565  /**
3566  * offset 2256
3567  */
3569  /**
3570  * need 4 byte alignment
3571  * units: units
3572  * offset 2257
3573  */
3575  /**
3576  * offset 2258
3577  */
3579  /**
3580  * Cooling fan turn-on temperature threshold, in Celsius
3581  * units: deg C
3582  * offset 2260
3583  */
3585  /**
3586  * Cooling fan turn-off temperature threshold, in Celsius
3587  * units: deg C
3588  * offset 2261
3589  */
3591  /**
3592  * offset 2262
3593  */
3595  /**
3596  * offset 2264
3597  */
3599  /**
3600  * offset 2266
3601  */
3603  /**
3604  * need 4 byte alignment
3605  * units: units
3606  * offset 2267
3607  */
3609  /**
3610  * offset 2268
3611  */
3613  /**
3614  * need 4 byte alignment
3615  * units: units
3616  * offset 2270
3617  */
3619  /**
3620  * units: hz
3621  * offset 2272
3622  */
3624  /**
3625  * units: RPM
3626  * offset 2276
3627  */
3629  /**
3630  * offset 2278
3631  */
3632  sent_input_pin_e sentInputPins[SENT_INPUT_COUNT];
3633  /**
3634  * units: %
3635  * offset 2280
3636  */
3638  /**
3639  * Time required to detect a stuck throttle.
3640  * units: sec
3641  * offset 2281
3642  */
3643  scaled_channel<uint8_t, 50, 1> etbJamTimeout;
3644  /**
3645  * By the way ETB PID runs at 500hz, length in 1/500 of second here.
3646  * offset 2282
3647  */
3649  /**
3650  * offset 2284
3651  */
3653  /**
3654  * This sets the RPM above which fuel cut is active.
3655  * units: rpm
3656  * offset 2288
3657  */
3659  /**
3660  * This sets the RPM below which fuel cut is deactivated, this prevents jerking or issues transitioning to idle
3661  * units: rpm
3662  * offset 2290
3663  */
3665  /**
3666  * Throttle position below which fuel cut is active. With an electronic throttle enabled, this checks against pedal position.
3667  * units: %
3668  * offset 2292
3669  */
3671  /**
3672  * Fuel cutoff is disabled when the engine is cold.
3673  * units: C
3674  * offset 2294
3675  */
3677  /**
3678  * Increases PID reaction for RPM<target by adding extra percent to PID-error
3679  * units: %
3680  * offset 2296
3681  */
3683  /**
3684  * MAP value above which fuel injection is re-enabled.
3685  * units: kPa
3686  * offset 2298
3687  */
3689  /**
3690  * offset 2300
3691  */
3693  /**
3694  * offset 2320
3695  */
3697  /**
3698  * units: C
3699  * offset 2340
3700  */
3701  int8_t cltRevLimitRpmBins[CLT_LIMITER_CURVE_SIZE];
3702  /**
3703  * units: RPM
3704  * offset 2344
3705  */
3706  uint16_t cltRevLimitRpm[CLT_LIMITER_CURVE_SIZE];
3707  /**
3708  * offset 2352
3709  */
3710  gppwm_note_t scriptCurveName[SCRIPT_CURVE_COUNT];
3711  /**
3712  * offset 2448
3713  */
3714  gppwm_note_t scriptTableName[SCRIPT_TABLE_COUNT];
3715  /**
3716  * offset 2512
3717  */
3718  gppwm_note_t scriptSettingName[SCRIPT_SETTING_COUNT];
3719  /**
3720  * Heat transfer coefficient at zero flow.
3721  * 0 means the air charge is fully heated to the same temperature as CLT.
3722  * 1 means the air charge gains no heat, and enters the cylinder at the temperature measured by IAT.
3723  * offset 2640
3724  */
3726  /**
3727  * Heat transfer coefficient at high flow, as defined by "max air flow".
3728  * 0 means the air charge is fully heated to the same temperature as CLT.
3729  * 1 means the air charge gains no heat, and enters the cylinder at the temperature measured by IAT.
3730  * offset 2644
3731  */
3733  /**
3734  * High flow point for heat transfer estimation.
3735  * Set this to perhaps 50-75% of your maximum airflow at wide open throttle.
3736  * units: kg/h
3737  * offset 2648
3738  */
3740  /**
3741  * Maximum allowed rate of increase allowed for the estimated charge temperature
3742  * units: deg/sec
3743  * offset 2652
3744  */
3746  /**
3747  * Maximum allowed rate of decrease allowed for the estimated charge temperature
3748  * units: deg/sec
3749  * offset 2656
3750  */
3752  /**
3753  * offset 2660
3754  */
3756  /**
3757  * need 4 byte alignment
3758  * units: units
3759  * offset 2661
3760  */
3762  /**
3763  * offset 2664
3764  */
3766  /**
3767  * iTerm min value
3768  * offset 2668
3769  */
3770  int16_t etb_iTermMin;
3771  /**
3772  * iTerm max value
3773  * offset 2670
3774  */
3775  int16_t etb_iTermMax;
3776  /**
3777  * See useIdleTimingPidControl
3778  * offset 2672
3779  */
3781  /**
3782  * When entering idle, and the PID settings are aggressive, it's good to make a soft entry upon entering closed loop
3783  * offset 2692
3784  */
3786  /**
3787  * By the way ETB PID runs at 500hz, length in 1/500 of second here.
3788  * offset 2696
3789  */
3791  /**
3792  * A delay in cycles between fuel-enrich. portions
3793  * units: cycles
3794  * offset 2698
3795  */
3797  /**
3798  * A fraction divisor: 1 or less = entire portion at once, or split into diminishing fractions
3799  * units: coef
3800  * offset 2700
3801  */
3803  /**
3804  * offset 2704
3805  */
3807  /**
3808  * offset 2705
3809  */
3811  /**
3812  * iTerm min value
3813  * offset 2706
3814  */
3816  /**
3817  * offset 2708
3818  */
3820  /**
3821  * Stoichiometric ratio for your primary fuel. When Flex Fuel is enabled, this value is used when the Flex Fuel sensor indicates E0.
3822  * E0 = 14.7
3823  * E10 = 14.1
3824  * E85 = 9.9
3825  * E100 = 9.0
3826  * units: :1
3827  * offset 2709
3828  */
3829  scaled_channel<uint8_t, 10, 1> stoichRatioPrimary;
3830  /**
3831  * iTerm max value
3832  * offset 2710
3833  */
3835  /**
3836  * This sets the range of the idle control on the ETB. At 100% idle position, the value specified here sets the base ETB position.
3837  * units: %
3838  * offset 2712
3839  */
3841  /**
3842  * Select which fuel correction bank this cylinder belongs to. Group cylinders that share the same O2 sensor
3843  * offset 2716
3844  */
3845  uint8_t cylinderBankSelect[MAX_CYLINDER_COUNT];
3846  /**
3847  * units: mg
3848  * offset 2728
3849  */
3850  scaled_channel<uint8_t, 1, 5> primeValues[PRIME_CURVE_COUNT];
3851  /**
3852  * Trigger comparator center point voltage
3853  * units: V
3854  * offset 2736
3855  */
3856  scaled_channel<uint8_t, 50, 1> triggerCompCenterVolt;
3857  /**
3858  * Trigger comparator hysteresis voltage (Min)
3859  * units: V
3860  * offset 2737
3861  */
3862  scaled_channel<uint8_t, 50, 1> triggerCompHystMin;
3863  /**
3864  * Trigger comparator hysteresis voltage (Max)
3865  * units: V
3866  * offset 2738
3867  */
3868  scaled_channel<uint8_t, 50, 1> triggerCompHystMax;
3869  /**
3870  * VR-sensor saturation RPM
3871  * units: RPM
3872  * offset 2739
3873  */
3874  scaled_channel<uint8_t, 1, 50> triggerCompSensorSatRpm;
3875  /**
3876  * units: ratio
3877  * offset 2740
3878  */
3879  scaled_channel<uint16_t, 100, 1> tractionControlSlipBins[TRACTION_CONTROL_ETB_DROP_SIZE];
3880  /**
3881  * units: RPM
3882  * offset 2752
3883  */
3884  uint8_t tractionControlSpeedBins[TRACTION_CONTROL_ETB_DROP_SIZE];
3885  /**
3886  * offset 2758
3887  */
3889  /**
3890  * offset 2759
3891  */
3893  /**
3894  * offset 2760
3895  */
3897  /**
3898  * need 4 byte alignment
3899  * units: units
3900  * offset 2762
3901  */
3903  /**
3904  * offset 2764
3905  */
3906  gppwm_channel gppwm[GPPWM_CHANNELS];
3907  /**
3908  * Boost Current
3909  * units: mA
3910  * offset 3196
3911  */
3912  uint16_t mc33_i_boost;
3913  /**
3914  * Peak Current
3915  * units: mA
3916  * offset 3198
3917  */
3918  uint16_t mc33_i_peak;
3919  /**
3920  * Hold Current
3921  * units: mA
3922  * offset 3200
3923  */
3924  uint16_t mc33_i_hold;
3925  /**
3926  * 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.
3927  * units: us
3928  * offset 3202
3929  */
3931  /**
3932  * units: us
3933  * offset 3204
3934  */
3936  /**
3937  * Peak phase duration
3938  * units: us
3939  * offset 3206
3940  */
3942  /**
3943  * units: us
3944  * offset 3208
3945  */
3946  uint16_t mc33_t_bypass;
3947  /**
3948  * units: us
3949  * offset 3210
3950  */
3952  /**
3953  * Hold phase duration
3954  * units: us
3955  * offset 3212
3956  */
3958  /**
3959  * offset 3214
3960  */
3962  /**
3963  * offset 3215
3964  */
3966  /**
3967  * offset 3216
3968  */
3970  /**
3971  * offset 3217
3972  */
3974  /**
3975  * Knock sensor output knock detection threshold depending on current RPM.
3976  * units: dB
3977  * offset 3223
3978  */
3979  scaled_channel<int8_t, 2, 1> knockBaseNoise[ENGINE_NOISE_CURVE_SIZE];
3980  /**
3981  * need 4 byte alignment
3982  * units: units
3983  * offset 3239
3984  */
3986  /**
3987  * units: ratio
3988  * offset 3240
3989  */
3990  float triggerGapOverrideFrom[GAP_TRACKING_LENGTH];
3991  /**
3992  * units: ratio
3993  * offset 3312
3994  */
3995  float triggerGapOverrideTo[GAP_TRACKING_LENGTH];
3996  /**
3997  * 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.
3998  * units: rpm
3999  * offset 3384
4000  */
4001  scaled_channel<uint8_t, 1, 50> maxCamPhaseResolveRpm;
4002  /**
4003  * Delay before cutting fuel. Set to 0 to cut immediately with no delay. May cause rumbles and pops out of your exhaust...
4004  * units: sec
4005  * offset 3385
4006  */
4007  scaled_channel<uint8_t, 10, 1> dfcoDelay;
4008  /**
4009  * 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.
4010  * units: sec
4011  * offset 3386
4012  */
4013  scaled_channel<uint8_t, 10, 1> acDelay;
4014  /**
4015  * need 4 byte alignment
4016  * units: units
4017  * offset 3387
4018  */
4020  /**
4021  * units: mg
4022  * offset 3388
4023  */
4024  scaled_channel<uint16_t, 1000, 1> fordInjectorSmallPulseBreakPoint;
4025  /**
4026  * units: multiplier
4027  * offset 3390
4028  */
4029  scaled_channel<uint8_t, 50, 1> tpsTspCorrValues[TPS_TPS_ACCEL_CLT_CORR_TABLE];
4030  /**
4031  * units: %
4032  * offset 3394
4033  */
4035  /**
4036  * units: lobes/cam
4037  * offset 3395
4038  */
4039  uint8_t hpfpCamLobes;
4040  /**
4041  * offset 3396
4042  */
4044  /**
4045  * offset 3397
4046  */
4048  /**
4049  * If the requested activation time is below this angle, don't bother running the pump
4050  * units: deg
4051  * offset 3398
4052  */
4053  uint8_t hpfpMinAngle;
4054  /**
4055  * need 4 byte alignment
4056  * units: units
4057  * offset 3399
4058  */
4060  /**
4061  * Size of the pump chamber in cc. Typical Bosch HDP5 has a 9.0mm diameter, typical BMW N* stroke is 4.4mm.
4062  * units: cc
4063  * offset 3400
4064  */
4065  scaled_channel<uint16_t, 1000, 1> hpfpPumpVolume;
4066  /**
4067  * How long to keep the valve activated (in order to allow the pump to build pressure and keep the valve open on its own)
4068  * units: deg
4069  * offset 3402
4070  */
4072  /**
4073  * offset 3403
4074  */
4076  /**
4077  * units: %/kPa
4078  * offset 3404
4079  */
4080  scaled_channel<uint16_t, 1000, 1> hpfpPidP;
4081  /**
4082  * units: %/kPa/lobe
4083  * offset 3406
4084  */
4085  scaled_channel<uint16_t, 100000, 1> hpfpPidI;
4086  /**
4087  * 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.
4088  * units: kPa/s
4089  * offset 3408
4090  */
4092  /**
4093  * units: %
4094  * offset 3410
4095  */
4096  scaled_channel<uint8_t, 2, 1> hpfpLobeProfileQuantityBins[HPFP_LOBE_PROFILE_SIZE];
4097  /**
4098  * units: deg
4099  * offset 3426
4100  */
4101  scaled_channel<uint8_t, 2, 1> hpfpLobeProfileAngle[HPFP_LOBE_PROFILE_SIZE];
4102  /**
4103  * units: volts
4104  * offset 3442
4105  */
4106  uint8_t hpfpDeadtimeVoltsBins[HPFP_DEADTIME_SIZE];
4107  /**
4108  * units: ms
4109  * offset 3450
4110  */
4111  scaled_channel<uint16_t, 1000, 1> hpfpDeadtimeMS[HPFP_DEADTIME_SIZE];
4112  /**
4113  * units: kPa
4114  * offset 3466
4115  */
4116  uint16_t hpfpTarget[HPFP_TARGET_SIZE][HPFP_TARGET_SIZE];
4117  /**
4118  * units: load
4119  * offset 3666
4120  */
4121  scaled_channel<uint16_t, 10, 1> hpfpTargetLoadBins[HPFP_TARGET_SIZE];
4122  /**
4123  * units: RPM
4124  * offset 3686
4125  */
4126  scaled_channel<uint8_t, 1, 50> hpfpTargetRpmBins[HPFP_TARGET_SIZE];
4127  /**
4128  * units: %
4129  * offset 3696
4130  */
4131  int8_t hpfpCompensation[HPFP_COMPENSATION_SIZE][HPFP_COMPENSATION_SIZE];
4132  /**
4133  * units: cc/lobe
4134  * offset 3796
4135  */
4136  scaled_channel<uint16_t, 1000, 1> hpfpCompensationLoadBins[HPFP_COMPENSATION_SIZE];
4137  /**
4138  * units: RPM
4139  * offset 3816
4140  */
4141  scaled_channel<uint8_t, 1, 50> hpfpCompensationRpmBins[HPFP_COMPENSATION_SIZE];
4142  /**
4143  * offset 3826
4144  */
4146  /**
4147  * units: ratio
4148  * offset 3834
4149  */
4150  scaled_channel<uint16_t, 100, 1> gearRatio[TCU_GEAR_COUNT];
4151  /**
4152  * We need to give engine time to build oil pressure without diverting it to VVT
4153  * units: ms
4154  * offset 3854
4155  */
4157  /**
4158  * units: deg C
4159  * offset 3856
4160  */
4161  int8_t wwCltBins[WWAE_TABLE_SIZE];
4162  /**
4163  * offset 3864
4164  */
4165  scaled_channel<uint8_t, 100, 1> wwTauCltValues[WWAE_TABLE_SIZE];
4166  /**
4167  * offset 3872
4168  */
4169  scaled_channel<uint8_t, 100, 1> wwBetaCltValues[WWAE_TABLE_SIZE];
4170  /**
4171  * units: kPa
4172  * offset 3880
4173  */
4174  int8_t wwMapBins[WWAE_TABLE_SIZE];
4175  /**
4176  * offset 3888
4177  */
4178  scaled_channel<uint8_t, 100, 1> wwTauMapValues[WWAE_TABLE_SIZE];
4179  /**
4180  * offset 3896
4181  */
4182  scaled_channel<uint8_t, 100, 1> wwBetaMapValues[WWAE_TABLE_SIZE];
4183  /**
4184  * units: Nm
4185  * offset 3904
4186  */
4187  scaled_channel<uint8_t, 1, 10> torqueTable[TORQUE_CURVE_SIZE][TORQUE_CURVE_SIZE];
4188  /**
4189  * units: RPM
4190  * offset 3940
4191  */
4192  uint16_t torqueRpmBins[TORQUE_CURVE_SIZE];
4193  /**
4194  * units: Load
4195  * offset 3952
4196  */
4197  uint16_t torqueLoadBins[TORQUE_CURVE_SIZE];
4198  /**
4199  * offset 3964
4200  */
4202  /**
4203  * offset 3965
4204  */
4206  /**
4207  * units: deg
4208  * offset 3966
4209  */
4211  /**
4212  * offset 3968
4213  */
4215  /**
4216  * offset 3988
4217  */
4219  /**
4220  * offset 4008
4221  */
4223  /**
4224  * offset 4010
4225  */
4227  /**
4228  * need 4 byte alignment
4229  * units: units
4230  * offset 4011
4231  */
4233  /**
4234  * offset 4012
4235  */
4237  /**
4238  * offset 4014
4239  */
4241  /**
4242  * need 4 byte alignment
4243  * units: units
4244  * offset 4015
4245  */
4247  /**
4248  * offset 4016
4249  */
4251  /**
4252  * offset 4018
4253  */
4255  /**
4256  * offset 4020
4257  */
4259  /**
4260  * need 4 byte alignment
4261  * units: units
4262  * offset 4021
4263  */
4265  /**
4266  * offset 4022
4267  */
4269  /**
4270  * offset 4024
4271  */
4273  /**
4274  * offset 4026
4275  */
4277  /**
4278  * need 4 byte alignment
4279  * units: units
4280  * offset 4027
4281  */
4283  /**
4284  * offset 4028
4285  */
4287  /**
4288  * offset 4030
4289  */
4291  /**
4292  * units: %
4293  * offset 4032
4294  */
4296  /**
4297  * offset 4036
4298  */
4299  uint16_t tuneHidingKey;
4300  /**
4301  * offset 4038
4302  */
4304  /**
4305  * need 4 byte alignment
4306  * units: units
4307  * offset 4055
4308  */
4310  /**
4311  * offset 4056
4312  */
4313  uint16_t highSpeedOffsets[HIGH_SPEED_COUNT];
4314  /**
4315  * offset 4120
4316  */
4318  /**
4319  * offset 4124
4320  */
4322  /**
4323  * need 4 byte alignment
4324  * units: units
4325  * offset 4125
4326  */
4328  /**
4329  * offset 4126
4330  */
4331  switch_input_pin_e luaDigitalInputPins[LUA_DIGITAL_INPUT_COUNT];
4332  /**
4333  * units: RPM
4334  * offset 4142
4335  */
4336  scaled_channel<uint8_t, 1, 50> tpsTspCorrValuesBins[TPS_TPS_ACCEL_CLT_CORR_TABLE];
4337  /**
4338  * units: rpm
4339  * offset 4146
4340  */
4341  int16_t ALSMinRPM;
4342  /**
4343  * units: rpm
4344  * offset 4148
4345  */
4346  int16_t ALSMaxRPM;
4347  /**
4348  * units: sec
4349  * offset 4150
4350  */
4352  /**
4353  * units: C
4354  * offset 4152
4355  */
4356  int8_t ALSMinCLT;
4357  /**
4358  * units: C
4359  * offset 4153
4360  */
4361  int8_t ALSMaxCLT;
4362  /**
4363  * offset 4154
4364  */
4366  /**
4367  * offset 4155
4368  */
4370  /**
4371  * units: %
4372  * offset 4156
4373  */
4375  /**
4376  * offset 4157
4377  */
4379  /**
4380  * offset 4158
4381  */
4383  /**
4384  * units: %
4385  * offset 4160
4386  */
4388  /**
4389  * units: %
4390  * offset 4164
4391  */
4393  /**
4394  * offset 4168
4395  */
4397  /**
4398  * units: %
4399  * offset 4172
4400  */
4402  /**
4403  * offset 4173
4404  */
4406  /**
4407  * For Ford TPS, use 53%. For Toyota ETCS-i, use ~65%
4408  * units: %
4409  * offset 4174
4410  */
4411  scaled_channel<uint8_t, 2, 1> tpsSecondaryMaximum;
4412  /**
4413  * For Toyota ETCS-i, use ~69%
4414  * units: %
4415  * offset 4175
4416  */
4417  scaled_channel<uint8_t, 2, 1> ppsSecondaryMaximum;
4418  /**
4419  * offset 4176
4420  */
4421  pin_input_mode_e luaDigitalInputPinModes[LUA_DIGITAL_INPUT_COUNT];
4422  /**
4423  * offset 4184
4424  */
4426  /**
4427  * offset 4186
4428  */
4429  uint16_t kLineBaudRate;
4430  /**
4431  * offset 4188
4432  */
4434  /**
4435  * offset 4189
4436  */
4438  /**
4439  * Crank angle ATDC of first lobe peak
4440  * units: deg
4441  * offset 4190
4442  */
4443  int16_t hpfpPeakPos;
4444  /**
4445  * units: us
4446  * offset 4192
4447  */
4448  int16_t kLinePeriodUs;
4449  /**
4450  * 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)
4451  * units: RPM
4452  * offset 4194
4453  */
4454  scaled_channel<uint8_t, 1, 10> rpmSoftLimitWindowSize;
4455  /**
4456  * Degrees of timing REMOVED from actual timing during soft RPM limit window
4457  * units: deg
4458  * offset 4195
4459  */
4460  scaled_channel<uint8_t, 5, 1> rpmSoftLimitTimingRetard;
4461  /**
4462  * % of fuel ADDED during window
4463  * units: %
4464  * offset 4196
4465  */
4466  scaled_channel<uint8_t, 5, 1> rpmSoftLimitFuelAdded;
4467  /**
4468  * 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
4469  * units: RPM
4470  * offset 4197
4471  */
4472  scaled_channel<uint8_t, 1, 10> rpmHardLimitHyst;
4473  /**
4474  * Time between bench test pulses
4475  * units: ms
4476  * offset 4198
4477  */
4478  scaled_channel<uint16_t, 10, 1> benchTestOffTime;
4479  /**
4480  * 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
4481  * units: kPa (absolute)
4482  * offset 4200
4483  */
4484  scaled_channel<uint8_t, 2, 1> boostCutPressureHyst;
4485  /**
4486  * Boost duty cycle added by gear
4487  * units: %
4488  * offset 4201
4489  */
4490  scaled_channel<uint8_t, 2, 1> gearBasedOpenLoopBoostAdder[TCU_GEAR_COUNT];
4491  /**
4492  * need 4 byte alignment
4493  * units: units
4494  * offset 4211
4495  */
4497  /**
4498  * How many test bench pulses do you want
4499  * offset 4212
4500  */
4501  uint32_t benchTestCount;
4502  /**
4503  * How long initial IAC adder is held before starting to decay.
4504  * units: seconds
4505  * offset 4216
4506  */
4507  scaled_channel<uint8_t, 10, 1> iacByTpsHoldTime;
4508  /**
4509  * How long it takes to remove initial IAC adder to return to normal idle.
4510  * units: seconds
4511  * offset 4217
4512  */
4513  scaled_channel<uint8_t, 10, 1> iacByTpsDecayTime;
4514  /**
4515  * offset 4218
4516  */
4518  /**
4519  * offset 4230
4520  */
4522  /**
4523  * Scale the reported vehicle speed value from CAN. Example: Parameter set to 1.1, CAN VSS reports 50kph, ECU will report 55kph instead.
4524  * units: ratio
4525  * offset 4236
4526  */
4527  scaled_channel<uint16_t, 10000, 1> canVssScaling;
4528  /**
4529  * need 4 byte alignment
4530  * units: units
4531  * offset 4238
4532  */
4534  /**
4535  * offset 4240
4536  */
4538  /**
4539  * offset 4272
4540  */
4542  /**
4543  * offset 4304
4544  */
4546  /**
4547  * offset 4336
4548  */
4550  /**
4551  * Place the sensor before the throttle, but after any turbocharger/supercharger and intercoolers if fitted. Uses the same calibration as the MAP sensor.
4552  * offset 4368
4553  */
4555  /**
4556  * Place the sensor after the turbocharger/supercharger, but before any intercoolers if fitted. Uses the same calibration as the MAP sensor.
4557  * offset 4369
4558  */
4560  /**
4561  * offset 4370
4562  */
4563  Gpio dacOutputPins[DAC_OUTPUT_COUNT];
4564  /**
4565  * offset 4374
4566  */
4568  /**
4569  * Number of speedometer pulses per kilometer travelled.
4570  * offset 4376
4571  */
4573  /**
4574  * offset 4378
4575  */
4576  uint8_t simulatorCamPosition[CAM_INPUTS_COUNT];
4577  /**
4578  * offset 4382
4579  */
4581  /**
4582  * offset 4383
4583  */
4585  /**
4586  * units: ratio
4587  * offset 4384
4588  */
4589  float triggerVVTGapOverrideFrom[VVT_TRACKING_LENGTH];
4590  /**
4591  * units: ratio
4592  * offset 4400
4593  */
4594  float triggerVVTGapOverrideTo[VVT_TRACKING_LENGTH];
4595  /**
4596  * units: %
4597  * offset 4416
4598  */
4599  int8_t tractionControlEtbDrop[TRACTION_CONTROL_ETB_DROP_SIZE][TRACTION_CONTROL_ETB_DROP_SIZE];
4600  /**
4601  * If injector duty cycle hits this value, instantly cut fuel.
4602  * units: %
4603  * offset 4452
4604  */
4606  /**
4607  * If injector duty cycle hits this value for the specified delay time, cut fuel.
4608  * units: %
4609  * offset 4453
4610  */
4612  /**
4613  * Timeout period for duty cycle over the sustained limit to trigger duty cycle protection.
4614  * units: sec
4615  * offset 4454
4616  */
4617  scaled_channel<uint8_t, 10, 1> maxInjectorDutySustainedTimeout;
4618  /**
4619  * need 4 byte alignment
4620  * units: units
4621  * offset 4455
4622  */
4624  /**
4625  * offset 4456
4626  */
4627  output_pin_e injectionPinsStage2[MAX_CYLINDER_COUNT];
4628  /**
4629  * units: Deg
4630  * offset 4480
4631  */
4632  int8_t tractionControlTimingDrop[TRACTION_CONTROL_ETB_DROP_SIZE][TRACTION_CONTROL_ETB_DROP_SIZE];
4633  /**
4634  * units: %
4635  * offset 4516
4636  */
4637  int8_t tractionControlIgnitionSkip[TRACTION_CONTROL_ETB_DROP_SIZE][TRACTION_CONTROL_ETB_DROP_SIZE];
4638  /**
4639  * offset 4552
4640  */
4642  /**
4643  * offset 4556
4644  */
4646  /**
4647  * offset 4560
4648  */
4650  /**
4651  * offset 4562
4652  */
4654  /**
4655  * offset 4564
4656  */
4658  /**
4659  * offset 4566
4660  */
4662  /**
4663  * offset 4568
4664  */
4666  /**
4667  * offset 4570
4668  */
4670  /**
4671  * offset 4572
4672  */
4674  /**
4675  * offset 4574
4676  */
4678  /**
4679  * offset 4576
4680  */
4682  /**
4683  * offset 4578
4684  */
4686  /**
4687  * offset 4579
4688  */
4690  /**
4691  * offset 4580
4692  */
4694  /**
4695  * offset 4581
4696  */
4698  /**
4699  * offset 4582
4700  */
4702  /**
4703  * offset 4583
4704  */
4706  /**
4707  * offset 4584
4708  */
4710  /**
4711  * offset 4585
4712  */
4714  /**
4715  * units: units
4716  * offset 4586
4717  */
4719  /**
4720  * need 4 byte alignment
4721  * units: units
4722  * offset 4706
4723  */
4725 };
4726 static_assert(sizeof(engine_configuration_s) == 4708);
4727 
4728 // start of cyl_trim_s
4729 struct cyl_trim_s {
4730  /**
4731  * offset 0
4732  */
4733  scaled_channel<int8_t, 5, 1> table[TRIM_SIZE][TRIM_SIZE];
4734 };
4735 static_assert(sizeof(cyl_trim_s) == 16);
4736 
4737 // start of blend_table_s
4739  /**
4740  * offset 0
4741  */
4742  scaled_channel<int16_t, 10, 1> table[8][8];
4743  /**
4744  * units: Load
4745  * offset 128
4746  */
4747  uint16_t loadBins[8];
4748  /**
4749  * units: RPM
4750  * offset 144
4751  */
4752  uint16_t rpmBins[8];
4753  /**
4754  * offset 160
4755  */
4757  /**
4758  * offset 161
4759  */
4761  /**
4762  * offset 162
4763  */
4764  scaled_channel<int16_t, 10, 1> blendBins[8];
4765  /**
4766  * units: %
4767  * offset 178
4768  */
4769  scaled_channel<uint8_t, 2, 1> blendValues[8];
4770  /**
4771  * need 4 byte alignment
4772  * units: units
4773  * offset 186
4774  */
4776 };
4777 static_assert(sizeof(blend_table_s) == 188);
4778 
4779 // start of persistent_config_s
4781  /**
4782  * offset 0
4783  */
4785  /**
4786  * target TPS value, 0 to 100%
4787  * TODO: use int8 data date once we template interpolation method
4788  * units: target TPS position
4789  * offset 4708
4790  */
4791  float etbBiasBins[ETB_BIAS_CURVE_LENGTH];
4792  /**
4793  * PWM bias, 0 to 100%
4794  * units: ETB duty cycle bias
4795  * offset 4740
4796  */
4797  float etbBiasValues[ETB_BIAS_CURVE_LENGTH];
4798  /**
4799  * units: %
4800  * offset 4772
4801  */
4802  scaled_channel<uint8_t, 20, 1> iacPidMultTable[IAC_PID_MULT_SIZE][IAC_PID_MULT_SIZE];
4803  /**
4804  * units: Load
4805  * offset 4836
4806  */
4807  uint8_t iacPidMultLoadBins[IAC_PID_MULT_SIZE];
4808  /**
4809  * units: RPM
4810  * offset 4844
4811  */
4812  scaled_channel<uint8_t, 1, 10> iacPidMultRpmBins[IAC_PID_MULT_SIZE];
4813  /**
4814  * On Single Coil or Wasted Spark setups you have to lower dwell at high RPM
4815  * units: RPM
4816  * offset 4852
4817  */
4818  uint16_t sparkDwellRpmBins[DWELL_CURVE_SIZE];
4819  /**
4820  * units: ms
4821  * offset 4868
4822  */
4823  scaled_channel<uint16_t, 100, 1> sparkDwellValues[DWELL_CURVE_SIZE];
4824  /**
4825  * CLT-based target RPM for automatic idle controller
4826  * units: C
4827  * offset 4884
4828  */
4829  scaled_channel<int8_t, 1, 2> cltIdleRpmBins[CLT_CURVE_SIZE];
4830  /**
4831  * See idleRpmPid
4832  * units: RPM
4833  * offset 4900
4834  */
4835  scaled_channel<uint8_t, 1, 20> cltIdleRpm[CLT_CURVE_SIZE];
4836  /**
4837  * CLT-based timing correction
4838  * units: C
4839  * offset 4916
4840  */
4841  float cltTimingBins[CLT_TIMING_CURVE_SIZE];
4842  /**
4843  * units: degree
4844  * offset 4948
4845  */
4846  float cltTimingExtra[CLT_TIMING_CURVE_SIZE];
4847  /**
4848  * units: x
4849  * offset 4980
4850  */
4851  float scriptCurve1Bins[SCRIPT_CURVE_16];
4852  /**
4853  * units: y
4854  * offset 5044
4855  */
4856  float scriptCurve1[SCRIPT_CURVE_16];
4857  /**
4858  * units: x
4859  * offset 5108
4860  */
4861  float scriptCurve2Bins[SCRIPT_CURVE_16];
4862  /**
4863  * units: y
4864  * offset 5172
4865  */
4866  float scriptCurve2[SCRIPT_CURVE_16];
4867  /**
4868  * units: x
4869  * offset 5236
4870  */
4871  float scriptCurve3Bins[SCRIPT_CURVE_8];
4872  /**
4873  * units: y
4874  * offset 5268
4875  */
4876  float scriptCurve3[SCRIPT_CURVE_8];
4877  /**
4878  * units: x
4879  * offset 5300
4880  */
4881  float scriptCurve4Bins[SCRIPT_CURVE_8];
4882  /**
4883  * units: y
4884  * offset 5332
4885  */
4886  float scriptCurve4[SCRIPT_CURVE_8];
4887  /**
4888  * units: x
4889  * offset 5364
4890  */
4891  float scriptCurve5Bins[SCRIPT_CURVE_8];
4892  /**
4893  * units: y
4894  * offset 5396
4895  */
4896  float scriptCurve5[SCRIPT_CURVE_8];
4897  /**
4898  * units: x
4899  * offset 5428
4900  */
4901  float scriptCurve6Bins[SCRIPT_CURVE_8];
4902  /**
4903  * units: y
4904  * offset 5460
4905  */
4906  float scriptCurve6[SCRIPT_CURVE_8];
4907  /**
4908  * units: kPa
4909  * offset 5492
4910  */
4911  float baroCorrPressureBins[BARO_CORR_SIZE];
4912  /**
4913  * units: RPM
4914  * offset 5508
4915  */
4916  float baroCorrRpmBins[BARO_CORR_SIZE];
4917  /**
4918  * units: ratio
4919  * offset 5524
4920  */
4921  float baroCorrTable[BARO_CORR_SIZE][BARO_CORR_SIZE];
4922  /**
4923  * Cranking fuel correction coefficient based on TPS
4924  * units: Ratio
4925  * offset 5588
4926  */
4927  float crankingTpsCoef[CRANKING_CURVE_SIZE];
4928  /**
4929  * units: %
4930  * offset 5620
4931  */
4932  float crankingTpsBins[CRANKING_CURVE_SIZE];
4933  /**
4934  * Optional timing advance table for Cranking (see useSeparateAdvanceForCranking)
4935  * units: RPM
4936  * offset 5652
4937  */
4938  uint16_t crankingAdvanceBins[CRANKING_ADVANCE_CURVE_SIZE];
4939  /**
4940  * Optional timing advance table for Cranking (see useSeparateAdvanceForCranking)
4941  * units: deg
4942  * offset 5660
4943  */
4944  scaled_channel<int16_t, 100, 1> crankingAdvance[CRANKING_ADVANCE_CURVE_SIZE];
4945  /**
4946  * RPM-based idle position for coasting
4947  * units: RPM
4948  * offset 5668
4949  */
4950  scaled_channel<uint8_t, 1, 100> iacCoastingRpmBins[CLT_CURVE_SIZE];
4951  /**
4952  * RPM-based idle position for coasting
4953  * units: %
4954  * offset 5684
4955  */
4956  scaled_channel<uint8_t, 2, 1> iacCoasting[CLT_CURVE_SIZE];
4957  /**
4958  * offset 5700
4959  */
4961  /**
4962  * units: C
4963  * offset 5820
4964  */
4965  float afterstartCoolantBins[AFTERSTART_HOLD_CURVE_SIZE];
4966  /**
4967  * units: Seconds
4968  * offset 5852
4969  */
4970  float afterstartHoldTime[AFTERSTART_HOLD_CURVE_SIZE];
4971  /**
4972  * units: %
4973  * offset 5884
4974  */
4975  float afterstartEnrich[AFTERSTART_ENRICH_CURVE_SIZE];
4976  /**
4977  * units: Seconds
4978  * offset 5916
4979  */
4980  float afterstartDecayTime[AFTERSTART_DECAY_CURVE_SIZE];
4981  /**
4982  * offset 5948
4983  */
4984  scaled_channel<uint8_t, 2, 1> boostTableOpenLoop[BOOST_LOAD_COUNT][BOOST_RPM_COUNT];
4985  /**
4986  * units: RPM
4987  * offset 6012
4988  */
4989  scaled_channel<uint8_t, 1, 100> boostRpmBins[BOOST_RPM_COUNT];
4990  /**
4991  * offset 6020
4992  */
4993  scaled_channel<uint8_t, 1, 2> boostTableClosedLoop[BOOST_LOAD_COUNT][BOOST_RPM_COUNT];
4994  /**
4995  * units: %
4996  * offset 6084
4997  */
4998  uint8_t boostTpsBins[BOOST_LOAD_COUNT];
4999  /**
5000  * units: %
5001  * offset 6092
5002  */
5003  uint8_t pedalToTpsTable[PEDAL_TO_TPS_SIZE][PEDAL_TO_TPS_SIZE];
5004  /**
5005  * units: %
5006  * offset 6156
5007  */
5008  uint8_t pedalToTpsPedalBins[PEDAL_TO_TPS_SIZE];
5009  /**
5010  * units: RPM
5011  * offset 6164
5012  */
5013  scaled_channel<uint8_t, 1, 100> pedalToTpsRpmBins[PEDAL_TO_TPS_SIZE];
5014  /**
5015  * CLT-based cranking position multiplier for simple manual idle controller
5016  * units: C
5017  * offset 6172
5018  */
5019  float cltCrankingCorrBins[CLT_CRANKING_CURVE_SIZE];
5020  /**
5021  * CLT-based cranking position multiplier for simple manual idle controller
5022  * units: %
5023  * offset 6204
5024  */
5025  float cltCrankingCorr[CLT_CRANKING_CURVE_SIZE];
5026  /**
5027  * Optional timing advance table for Idle (see useSeparateAdvanceForIdle)
5028  * units: RPM
5029  * offset 6236
5030  */
5031  scaled_channel<uint8_t, 1, 50> idleAdvanceBins[IDLE_ADVANCE_CURVE_SIZE];
5032  /**
5033  * Optional timing advance table for Idle (see useSeparateAdvanceForIdle)
5034  * units: deg
5035  * offset 6244
5036  */
5037  float idleAdvance[IDLE_ADVANCE_CURVE_SIZE];
5038  /**
5039  * units: RPM
5040  * offset 6276
5041  */
5042  scaled_channel<uint8_t, 1, 10> idleVeRpmBins[IDLE_VE_SIZE];
5043  /**
5044  * units: load
5045  * offset 6280
5046  */
5047  uint8_t idleVeLoadBins[IDLE_VE_SIZE];
5048  /**
5049  * units: %
5050  * offset 6284
5051  */
5052  scaled_channel<uint16_t, 10, 1> idleVeTable[IDLE_VE_SIZE][IDLE_VE_SIZE];
5053  /**
5054  * offset 6316
5055  */
5057  /**
5058  * units: C
5059  * offset 14316
5060  */
5061  float cltFuelCorrBins[CLT_CURVE_SIZE];
5062  /**
5063  * units: ratio
5064  * offset 14380
5065  */
5066  float cltFuelCorr[CLT_CURVE_SIZE];
5067  /**
5068  * units: C
5069  * offset 14444
5070  */
5071  float iatFuelCorrBins[IAT_CURVE_SIZE];
5072  /**
5073  * units: ratio
5074  * offset 14508
5075  */
5076  float iatFuelCorr[IAT_CURVE_SIZE];
5077  /**
5078  * units: ratio
5079  * offset 14572
5080  */
5081  float crankingFuelCoef[CRANKING_CURVE_SIZE];
5082  /**
5083  * units: C
5084  * offset 14604
5085  */
5086  float crankingFuelBins[CRANKING_CURVE_SIZE];
5087  /**
5088  * units: ratio
5089  * offset 14636
5090  */
5091  float crankingCycleCoef[CRANKING_CURVE_SIZE];
5092  /**
5093  * units: counter
5094  * offset 14668
5095  */
5096  float crankingCycleBins[CRANKING_CURVE_SIZE];
5097  /**
5098  * CLT-based idle position multiplier for simple manual idle controller
5099  * units: C
5100  * offset 14700
5101  */
5102  float cltIdleCorrBins[CLT_CURVE_SIZE];
5103  /**
5104  * CLT-based idle position multiplier for simple manual idle controller
5105  * units: ratio
5106  * offset 14764
5107  */
5108  float cltIdleCorr[CLT_CURVE_SIZE];
5109  /**
5110  * Also known as MAF transfer function.
5111  * kg/hour value.
5112  * By the way 2.081989116 kg/h = 1 ft3/m
5113  * units: kg/hour
5114  * offset 14828
5115  */
5116  float mafDecoding[MAF_DECODING_COUNT];
5117  /**
5118  * units: V
5119  * offset 14956
5120  */
5121  float mafDecodingBins[MAF_DECODING_COUNT];
5122  /**
5123  * units: deg
5124  * offset 15084
5125  */
5126  scaled_channel<int8_t, 10, 1> ignitionIatCorrTable[8][8];
5127  /**
5128  * units: C
5129  * offset 15148
5130  */
5132  /**
5133  * units: Load
5134  * offset 15156
5135  */
5136  scaled_channel<uint8_t, 1, 5> ignitionIatCorrLoadBins[8];
5137  /**
5138  * units: deg
5139  * offset 15164
5140  */
5141  int16_t injectionPhase[FUEL_LOAD_COUNT][FUEL_RPM_COUNT];
5142  /**
5143  * units: Load
5144  * offset 15676
5145  */
5146  uint16_t injPhaseLoadBins[FUEL_LOAD_COUNT];
5147  /**
5148  * units: RPM
5149  * offset 15708
5150  */
5151  uint16_t injPhaseRpmBins[FUEL_RPM_COUNT];
5152  /**
5153  * units: onoff
5154  * offset 15740
5155  */
5156  uint8_t tcuSolenoidTable[TCU_SOLENOID_COUNT][TCU_GEAR_COUNT];
5157  /**
5158  * units: kPa
5159  * offset 15800
5160  */
5161  scaled_channel<uint16_t, 100, 1> mapEstimateTable[FUEL_LOAD_COUNT][FUEL_RPM_COUNT];
5162  /**
5163  * units: % TPS
5164  * offset 16312
5165  */
5166  scaled_channel<uint16_t, 100, 1> mapEstimateTpsBins[FUEL_LOAD_COUNT];
5167  /**
5168  * units: RPM
5169  * offset 16344
5170  */
5171  uint16_t mapEstimateRpmBins[FUEL_RPM_COUNT];
5172  /**
5173  * units: value
5174  * offset 16376
5175  */
5176  int8_t vvtTable1[SCRIPT_TABLE_8][SCRIPT_TABLE_8];
5177  /**
5178  * units: L
5179  * offset 16440
5180  */
5181  uint16_t vvtTable1LoadBins[SCRIPT_TABLE_8];
5182  /**
5183  * units: RPM
5184  * offset 16456
5185  */
5186  uint16_t vvtTable1RpmBins[SCRIPT_TABLE_8];
5187  /**
5188  * units: value
5189  * offset 16472
5190  */
5191  int8_t vvtTable2[SCRIPT_TABLE_8][SCRIPT_TABLE_8];
5192  /**
5193  * units: L
5194  * offset 16536
5195  */
5196  uint16_t vvtTable2LoadBins[SCRIPT_TABLE_8];
5197  /**
5198  * units: RPM
5199  * offset 16552
5200  */
5201  uint16_t vvtTable2RpmBins[SCRIPT_TABLE_8];
5202  /**
5203  * units: deg
5204  * offset 16568
5205  */
5206  scaled_channel<int16_t, 10, 1> ignitionTable[IGN_LOAD_COUNT][IGN_RPM_COUNT];
5207  /**
5208  * units: Load
5209  * offset 17080
5210  */
5211  uint16_t ignitionLoadBins[IGN_LOAD_COUNT];
5212  /**
5213  * units: RPM
5214  * offset 17112
5215  */
5216  uint16_t ignitionRpmBins[IGN_RPM_COUNT];
5217  /**
5218  * units: %
5219  * offset 17144
5220  */
5221  scaled_channel<uint16_t, 10, 1> veTable[FUEL_LOAD_COUNT][FUEL_RPM_COUNT];
5222  /**
5223  * units: kPa
5224  * offset 17656
5225  */
5226  uint16_t veLoadBins[FUEL_LOAD_COUNT];
5227  /**
5228  * units: RPM
5229  * offset 17688
5230  */
5231  uint16_t veRpmBins[FUEL_RPM_COUNT];
5232  /**
5233  * units: lambda
5234  * offset 17720
5235  */
5236  scaled_channel<uint8_t, 147, 1> lambdaTable[FUEL_LOAD_COUNT][FUEL_RPM_COUNT];
5237  /**
5238  * offset 17976
5239  */
5240  uint16_t lambdaLoadBins[FUEL_LOAD_COUNT];
5241  /**
5242  * units: RPM
5243  * offset 18008
5244  */
5245  uint16_t lambdaRpmBins[FUEL_RPM_COUNT];
5246  /**
5247  * units: value
5248  * offset 18040
5249  */
5250  float tpsTpsAccelTable[TPS_TPS_ACCEL_TABLE][TPS_TPS_ACCEL_TABLE];
5251  /**
5252  * units: from
5253  * offset 18296
5254  */
5255  float tpsTpsAccelFromRpmBins[TPS_TPS_ACCEL_TABLE];
5256  /**
5257  * units: to
5258  * offset 18328
5259  */
5260  float tpsTpsAccelToRpmBins[TPS_TPS_ACCEL_TABLE];
5261  /**
5262  * units: value
5263  * offset 18360
5264  */
5265  float scriptTable1[SCRIPT_TABLE_8][SCRIPT_TABLE_8];
5266  /**
5267  * units: L
5268  * offset 18616
5269  */
5270  int16_t scriptTable1LoadBins[SCRIPT_TABLE_8];
5271  /**
5272  * units: RPM
5273  * offset 18632
5274  */
5275  int16_t scriptTable1RpmBins[SCRIPT_TABLE_8];
5276  /**
5277  * units: value
5278  * offset 18648
5279  */
5280  uint8_t scriptTable2[SCRIPT_TABLE_8][SCRIPT_TABLE_8];
5281  /**
5282  * units: L
5283  * offset 18712
5284  */
5285  int16_t scriptTable2LoadBins[SCRIPT_TABLE_8];
5286  /**
5287  * units: RPM
5288  * offset 18728
5289  */
5290  int16_t scriptTable2RpmBins[SCRIPT_TABLE_8];
5291  /**
5292  * units: value
5293  * offset 18744
5294  */
5295  uint8_t scriptTable3[SCRIPT_TABLE_8][SCRIPT_TABLE_8];
5296  /**
5297  * units: L
5298  * offset 18808
5299  */
5300  int16_t scriptTable3LoadBins[SCRIPT_TABLE_8];
5301  /**
5302  * units: RPM
5303  * offset 18824
5304  */
5305  int16_t scriptTable3RpmBins[SCRIPT_TABLE_8];
5306  /**
5307  * units: value
5308  * offset 18840
5309  */
5310  uint8_t scriptTable4[SCRIPT_TABLE_8][TABLE_4_RPM];
5311  /**
5312  * units: L
5313  * offset 18920
5314  */
5315  int16_t scriptTable4LoadBins[SCRIPT_TABLE_8];
5316  /**
5317  * units: RPM
5318  * offset 18936
5319  */
5320  int16_t scriptTable4RpmBins[TABLE_4_RPM];
5321  /**
5322  * offset 18956
5323  */
5324  uint16_t ignTrimLoadBins[TRIM_SIZE];
5325  /**
5326  * units: rpm
5327  * offset 18964
5328  */
5329  uint16_t ignTrimRpmBins[TRIM_SIZE];
5330  /**
5331  * offset 18972
5332  */
5334  /**
5335  * offset 19164
5336  */
5337  uint16_t fuelTrimLoadBins[TRIM_SIZE];
5338  /**
5339  * units: rpm
5340  * offset 19172
5341  */
5342  uint16_t fuelTrimRpmBins[TRIM_SIZE];
5343  /**
5344  * offset 19180
5345  */
5347  /**
5348  * units: ratio
5349  * offset 19372
5350  */
5351  scaled_channel<uint16_t, 100, 1> crankingFuelCoefE100[CRANKING_CURVE_SIZE];
5352  /**
5353  * units: Airmass
5354  * offset 19388
5355  */
5356  scaled_channel<uint8_t, 50, 1> tcu_pcAirmassBins[TCU_MAGIC_SIZE];
5357  /**
5358  * units: %
5359  * offset 19396
5360  */
5361  uint8_t tcu_pcValsR[TCU_MAGIC_SIZE];
5362  /**
5363  * units: %
5364  * offset 19404
5365  */
5366  uint8_t tcu_pcValsN[TCU_MAGIC_SIZE];
5367  /**
5368  * units: %
5369  * offset 19412
5370  */
5371  uint8_t tcu_pcVals1[TCU_MAGIC_SIZE];
5372  /**
5373  * units: %
5374  * offset 19420
5375  */
5376  uint8_t tcu_pcVals2[TCU_MAGIC_SIZE];
5377  /**
5378  * units: %
5379  * offset 19428
5380  */
5381  uint8_t tcu_pcVals3[TCU_MAGIC_SIZE];
5382  /**
5383  * units: %
5384  * offset 19436
5385  */
5386  uint8_t tcu_pcVals4[TCU_MAGIC_SIZE];
5387  /**
5388  * units: %
5389  * offset 19444
5390  */
5391  uint8_t tcu_pcVals12[TCU_MAGIC_SIZE];
5392  /**
5393  * units: %
5394  * offset 19452
5395  */
5396  uint8_t tcu_pcVals23[TCU_MAGIC_SIZE];
5397  /**
5398  * units: %
5399  * offset 19460
5400  */
5401  uint8_t tcu_pcVals34[TCU_MAGIC_SIZE];
5402  /**
5403  * units: %
5404  * offset 19468
5405  */
5406  uint8_t tcu_pcVals21[TCU_MAGIC_SIZE];
5407  /**
5408  * units: %
5409  * offset 19476
5410  */
5411  uint8_t tcu_pcVals32[TCU_MAGIC_SIZE];
5412  /**
5413  * units: %
5414  * offset 19484
5415  */
5416  uint8_t tcu_pcVals43[TCU_MAGIC_SIZE];
5417  /**
5418  * units: TPS
5419  * offset 19492
5420  */
5421  uint8_t tcu_tccTpsBins[8];
5422  /**
5423  * units: MPH
5424  * offset 19500
5425  */
5426  uint8_t tcu_tccLockSpeed[8];
5427  /**
5428  * units: MPH
5429  * offset 19508
5430  */
5432  /**
5433  * units: KPH
5434  * offset 19516
5435  */
5436  uint8_t tcu_32SpeedBins[8];
5437  /**
5438  * units: %
5439  * offset 19524
5440  */
5441  uint8_t tcu_32Vals[8];
5442  /**
5443  * units: %
5444  * offset 19532
5445  */
5446  scaled_channel<int8_t, 10, 1> throttle2TrimTable[ETB2_TRIM_SIZE][ETB2_TRIM_SIZE];
5447  /**
5448  * units: %
5449  * offset 19568
5450  */
5451  uint8_t throttle2TrimTpsBins[ETB2_TRIM_SIZE];
5452  /**
5453  * units: RPM
5454  * offset 19574
5455  */
5456  scaled_channel<uint8_t, 1, 100> throttle2TrimRpmBins[ETB2_TRIM_SIZE];
5457  /**
5458  * units: deg
5459  * offset 19580
5460  */
5461  scaled_channel<uint8_t, 4, 1> maxKnockRetardTable[6][6];
5462  /**
5463  * units: %
5464  * offset 19616
5465  */
5467  /**
5468  * units: RPM
5469  * offset 19622
5470  */
5471  scaled_channel<uint8_t, 1, 100> maxKnockRetardRpmBins[6];
5472  /**
5473  * units: deg
5474  * offset 19628
5475  */
5476  scaled_channel<int16_t, 10, 1> ALSTimingRetardTable[4][4];
5477  /**
5478  * units: TPS
5479  * offset 19660
5480  */
5482  /**
5483  * units: RPM
5484  * offset 19668
5485  */
5486  uint16_t alsIgnRetardrpmBins[4];
5487  /**
5488  * units: percent
5489  * offset 19676
5490  */
5491  scaled_channel<int16_t, 10, 1> ALSFuelAdjustment[4][4];
5492  /**
5493  * units: TPS
5494  * offset 19708
5495  */
5497  /**
5498  * units: RPM
5499  * offset 19716
5500  */
5502  /**
5503  * units: ratio
5504  * offset 19724
5505  */
5506  scaled_channel<int16_t, 1, 10> ALSIgnSkipTable[4][4];
5507  /**
5508  * units: TPS
5509  * offset 19756
5510  */
5511  uint16_t alsIgnSkipLoadBins[4];
5512  /**
5513  * units: RPM
5514  * offset 19764
5515  */
5516  uint16_t alsIgnSkiprpmBins[4];
5517  /**
5518  * offset 19772
5519  */
5520  blend_table_s ignBlends[IGN_BLEND_COUNT];
5521  /**
5522  * offset 20524
5523  */
5524  blend_table_s veBlends[VE_BLEND_COUNT];
5525  /**
5526  * units: %
5527  * offset 21276
5528  */
5529  scaled_channel<uint16_t, 10, 1> throttleEstimateEffectiveAreaBins[12];
5530  /**
5531  * In units of g/s normalized to choked flow conditions
5532  * units: g/s
5533  * offset 21300
5534  */
5535  scaled_channel<uint16_t, 10, 1> throttleEstimateEffectiveAreaValues[12];
5536  /**
5537  * offset 21324
5538  */
5540  /**
5541  * offset 21700
5542  */
5544  /**
5545  * units: level
5546  * offset 22076
5547  */
5548  uint8_t tcu_rangeP[6];
5549  /**
5550  * units: level
5551  * offset 22082
5552  */
5553  uint8_t tcu_rangeR[6];
5554  /**
5555  * units: level
5556  * offset 22088
5557  */
5558  uint8_t tcu_rangeN[6];
5559  /**
5560  * units: level
5561  * offset 22094
5562  */
5563  uint8_t tcu_rangeD[6];
5564  /**
5565  * units: level
5566  * offset 22100
5567  */
5568  uint8_t tcu_rangeM[6];
5569  /**
5570  * units: level
5571  * offset 22106
5572  */
5573  uint8_t tcu_rangeM3[6];
5574  /**
5575  * units: level
5576  * offset 22112
5577  */
5578  uint8_t tcu_rangeM2[6];
5579  /**
5580  * units: level
5581  * offset 22118
5582  */
5583  uint8_t tcu_rangeM1[6];
5584  /**
5585  * units: level
5586  * offset 22124
5587  */
5588  uint8_t tcu_rangePlus[6];
5589  /**
5590  * units: level
5591  * offset 22130
5592  */
5593  uint8_t tcu_rangeMinus[6];
5594  /**
5595  * units: level
5596  * offset 22136
5597  */
5598  uint8_t tcu_rangeLow[6];
5599  /**
5600  * units: lambda
5601  * offset 22142
5602  */
5603  scaled_channel<uint8_t, 100, 1> lambdaMaxDeviationTable[4][4];
5604  /**
5605  * offset 22158
5606  */
5608  /**
5609  * units: RPM
5610  * offset 22166
5611  */
5613  /**
5614  * units: %
5615  * offset 22174
5616  */
5617  uint8_t injectorStagingTable[INJ_STAGING_COUNT][INJ_STAGING_COUNT];
5618  /**
5619  * offset 22210
5620  */
5621  uint16_t injectorStagingLoadBins[INJ_STAGING_COUNT];
5622  /**
5623  * units: RPM
5624  * offset 22222
5625  */
5626  uint16_t injectorStagingRpmBins[INJ_STAGING_COUNT];
5627  /**
5628  * need 4 byte alignment
5629  * units: units
5630  * offset 22234
5631  */
5633 };
5634 static_assert(sizeof(persistent_config_s) == 22236);
5635 
5636 // end
5637 // this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt Fri Mar 08 23:06:04 UTC 2024
Gpio
debug_mode_e
Definition: engine_types.h:280
trigger_type_e