diff --git a/firmware/controllers/generated/engine_configuration_generated_structures.h b/firmware/controllers/generated/engine_configuration_generated_structures.h new file mode 100644 index 0000000000..2dcfdca424 --- /dev/null +++ b/firmware/controllers/generated/engine_configuration_generated_structures.h @@ -0,0 +1,5267 @@ +// this section was generated automatically by rusEFI tool ConfigDefinition.jar based on gen_config.sh integration/rusefi_config.txt Mon Feb 20 21:09:11 PST 2023 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of stft_cell_cfg_s +struct stft_cell_cfg_s { + /** + % + * offset 0 + */ + int8_t maxAdd; + /** + % + * offset 1 + */ + int8_t maxRemove; + /** + * 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. + sec + * offset 2 + */ + scaled_channel timeConstant; +}; +static_assert(sizeof(stft_cell_cfg_s) == 4); + +// start of stft_s +struct stft_s { + /** + * Below this RPM, the idle region is active + RPM + * offset 0 + */ + scaled_channel maxIdleRegionRpm; + /** + * Below this engine load, the overrun region is active + load + * offset 1 + */ + uint8_t maxOverrunLoad; + /** + * Above this engine load, the power region is active + load + * offset 2 + */ + uint8_t minPowerLoad; + /** + * 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. + % + * offset 3 + */ + scaled_channel deadband; + /** + * Below this temperature, correction is disabled. + C + * offset 4 + */ + int8_t minClt; + /** + * Below this AFR, correction is paused + afr + * offset 5 + */ + scaled_channel minAfr; + /** + * Above this AFR, correction is paused + afr + * offset 6 + */ + scaled_channel maxAfr; + /** + * Delay after starting the engine before beginning closed loop correction. + seconds + * offset 7 + */ + uint8_t startupDelay; + /** + * offset 8 + */ + stft_cell_cfg_s cellCfgs[STFT_CELL_COUNT]; +}; +static_assert(sizeof(stft_s) == 24); + +// start of pid_s +struct pid_s { + /** + * offset 0 + */ + float pFactor; + /** + * offset 4 + */ + float iFactor; + /** + * offset 8 + */ + float dFactor; + /** + * Linear addition to PID logic + * offset 12 + */ + int16_t offset; + /** + * PID dTime + ms + * offset 14 + */ + int16_t periodMs; + /** + * Output Min Duty Cycle + * offset 16 + */ + int16_t minValue; + /** + * Output Max Duty Cycle + * offset 18 + */ + int16_t maxValue; +}; +static_assert(sizeof(pid_s) == 20); + +// start of cranking_parameters_s +struct cranking_parameters_s { + /** + * 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. + * A reasonable starting point is 60mg per liter per cylinder. + * ex: 2 liter 4 cyl = 500cc/cyl, so 30mg cranking fuel. + mg + * offset 0 + */ + float baseFuel; + /** + * This sets the RPM limit below which the ECU will use cranking fuel and ignition logic, typically this is around 350-450rpm. + * set cranking_rpm X + RPM + * offset 4 + */ + int16_t rpm; + /** + * need 4 byte alignment + units + * offset 6 + */ + uint8_t alignmentFill_at_6[2]; +}; +static_assert(sizeof(cranking_parameters_s) == 8); + +// start of spi_pins +struct spi_pins { + /** + * offset 0 + */ + Gpio mosiPin; + /** + * offset 2 + */ + Gpio misoPin; + /** + * offset 4 + */ + Gpio sckPin; + /** + * need 4 byte alignment + units + * offset 6 + */ + uint8_t alignmentFill_at_6[2]; +}; +static_assert(sizeof(spi_pins) == 8); + +// start of gppwm_channel +struct gppwm_channel { + /** + * Select a pin to use for PWM or on-off output. + * offset 0 + */ + output_pin_e pin; + /** + * If an error (with a sensor, etc) is detected, this value is used instead of reading from the table. + * This should be a safe value for whatever hardware is connected to prevent damage. + % + * offset 2 + */ + uint8_t dutyIfError; + /** + * need 4 byte alignment + units + * offset 3 + */ + uint8_t alignmentFill_at_3[1]; + /** + * Select a frequency to run PWM at. + * Set this to 0hz to enable on-off mode. + hz + * offset 4 + */ + uint16_t pwmFrequency; + /** + * Hysteresis: in on-off mode, turn the output on when the table value is above this duty. + % + * offset 6 + */ + uint8_t onAboveDuty; + /** + * Hysteresis: in on-off mode, turn the output off when the table value is below this duty. + % + * offset 7 + */ + uint8_t offBelowDuty; + /** + * Selects the Y axis to use for the table. + * offset 8 + */ + gppwm_channel_e loadAxis; + /** + * Selects the X axis to use for the table. + * offset 9 + */ + gppwm_channel_e rpmAxis; + /** + load + * offset 10 + */ + scaled_channel loadBins[GPPWM_LOAD_COUNT]; + /** + RPM + * offset 26 + */ + scaled_channel rpmBins[GPPWM_RPM_COUNT]; + /** + duty + * offset 42 + */ + scaled_channel table[GPPWM_RPM_COUNT][GPPWM_LOAD_COUNT]; + /** + * need 4 byte alignment + units + * offset 106 + */ + uint8_t alignmentFill_at_106[2]; +}; +static_assert(sizeof(gppwm_channel) == 108); + +// start of air_pressure_sensor_config_s +struct air_pressure_sensor_config_s { + /** + * kPa value at low volts + kpa + * offset 0 + */ + float lowValue; + /** + * kPa value at high volts + kpa + * offset 4 + */ + float highValue; + /** + * offset 8 + */ + air_pressure_sensor_type_e type; + /** + * offset 9 + */ + adc_channel_e hwChannel; + /** + * need 4 byte alignment + units + * offset 10 + */ + uint8_t alignmentFill_at_10[2]; +}; +static_assert(sizeof(air_pressure_sensor_config_s) == 12); + +/** + * @brief MAP averaging configuration + +*/ +// start of MAP_sensor_config_s +struct MAP_sensor_config_s { + /** + * offset 0 + */ + float samplingAngleBins[MAP_ANGLE_SIZE]; + /** + * MAP averaging sampling start crank degree angle + deg + * offset 32 + */ + float samplingAngle[MAP_ANGLE_SIZE]; + /** + * offset 64 + */ + float samplingWindowBins[MAP_WINDOW_SIZE]; + /** + * MAP averaging angle crank degree duration + deg + * offset 96 + */ + float samplingWindow[MAP_WINDOW_SIZE]; + /** + * offset 128 + */ + air_pressure_sensor_config_s sensor; +}; +static_assert(sizeof(MAP_sensor_config_s) == 140); + +/** + * @brief Thermistor known values + +*/ +// start of thermistor_conf_s +struct thermistor_conf_s { + /** + * these values are in Celcius + *C + * offset 0 + */ + float tempC_1; + /** + *C + * offset 4 + */ + float tempC_2; + /** + *C + * offset 8 + */ + float tempC_3; + /** + Ohm + * offset 12 + */ + float resistance_1; + /** + Ohm + * offset 16 + */ + float resistance_2; + /** + Ohm + * offset 20 + */ + float resistance_3; + /** + * Pull-up resistor value on your board + Ohm + * offset 24 + */ + float bias_resistor; +}; +static_assert(sizeof(thermistor_conf_s) == 28); + +/** + * @brief Linear sensor interpolation + +*/ +// start of linear_sensor_s +struct linear_sensor_s { + /** + * offset 0 + */ + adc_channel_e hwChannel; + /** + * need 4 byte alignment + units + * offset 1 + */ + uint8_t alignmentFill_at_1[3]; + /** + volts + * offset 4 + */ + float v1; + /** + kPa + * offset 8 + */ + float value1; + /** + volts + * offset 12 + */ + float v2; + /** + kPa + * offset 16 + */ + float value2; +}; +static_assert(sizeof(linear_sensor_s) == 20); + +/** + * @brief Thermistor curve parameters + +*/ +// start of ThermistorConf +struct ThermistorConf { + /** + * offset 0 + */ + thermistor_conf_s config; + /** + * offset 28 + */ + adc_channel_e adcChannel; + /** + * need 4 byte alignment + units + * offset 29 + */ + uint8_t alignmentFill_at_29[3]; +}; +static_assert(sizeof(ThermistorConf) == 32); + +// start of injector_s +struct injector_s { + /** + * This is your injector flow at the fuel pressure used in the vehicle. cc/min, cubic centimetre per minute + * By the way, g/s = 0.125997881 * (lb/hr) + * g/s = 0.125997881 * (cc/min)/10.5 + * g/s = 0.0119997981 * cc/min + cm3/min + * offset 0 + */ + float flow; + /** + * set_flat_injector_lag LAG + * set_injector_lag VOLTAGE LAG + volts + * offset 4 + */ + float battLagCorrBins[VBAT_INJECTOR_CURVE_SIZE]; + /** + * ms delay between injector open and close dead times + ms + * offset 36 + */ + float battLagCorr[VBAT_INJECTOR_CURVE_SIZE]; +}; +static_assert(sizeof(injector_s) == 68); + +// start of specs_s +struct specs_s { + /** + * Engine volume/capacity, in litres + * see also cylindersCount + L + * offset 0 + */ + float displacement; + /** + * Number of cylinder the engine has. + * offset 4 + */ + uint32_t cylindersCount; + /** + * offset 8 + */ + firing_order_e firingOrder; + /** + * need 4 byte alignment + units + * offset 9 + */ + uint8_t alignmentFill_at_9[3]; +}; +static_assert(sizeof(specs_s) == 12); + +/** + * @brief Trigger wheel(s) configuration + +*/ +// start of trigger_config_s +struct trigger_config_s { + /** + * https://github.com/rusefi/rusefi/wiki/All-Supported-Triggers + * set trigger_type X + * offset 0 + */ + trigger_type_e type; + /** + number + * offset 4 + */ + int customTotalToothCount; + /** + number + * offset 8 + */ + int customSkippedToothCount; +}; +static_assert(sizeof(trigger_config_s) == 12); + +// start of afr_sensor_s +struct afr_sensor_s { + /** + * offset 0 + */ + adc_channel_e hwChannel; + /** + * offset 1 + */ + adc_channel_e hwChannel2; + /** + * need 4 byte alignment + units + * offset 2 + */ + uint8_t alignmentFill_at_2[2]; + /** + volts + * offset 4 + */ + float v1; + /** + AFR + * offset 8 + */ + float value1; + /** + volts + * offset 12 + */ + float v2; + /** + AFR + * offset 16 + */ + float value2; +}; +static_assert(sizeof(afr_sensor_s) == 20); + +// start of idle_hardware_s +struct idle_hardware_s { + /** + Hz + * offset 0 + */ + int solenoidFrequency; + /** + * offset 4 + */ + output_pin_e solenoidPin; + /** + * offset 6 + */ + Gpio stepperDirectionPin; + /** + * offset 8 + */ + Gpio stepperStepPin; + /** + * offset 10 + */ + pin_output_mode_e solenoidPinMode; + /** + * need 4 byte alignment + units + * offset 11 + */ + uint8_t alignmentFill_at_11[1]; +}; +static_assert(sizeof(idle_hardware_s) == 12); + +// start of dc_io +struct dc_io { + /** + * offset 0 + */ + Gpio directionPin1; + /** + * offset 2 + */ + Gpio directionPin2; + /** + * Acts as EN pin in two-wire mode + * offset 4 + */ + Gpio controlPin; + /** + * offset 6 + */ + Gpio disablePin; +}; +static_assert(sizeof(dc_io) == 8); + +// start of vr_threshold_s +struct vr_threshold_s { + /** + rpm + * offset 0 + */ + scaled_channel rpmBins[6]; + /** + volts + * offset 6 + */ + scaled_channel values[6]; + /** + * offset 12 + */ + Gpio pin; + /** + * need 4 byte alignment + units + * offset 14 + */ + uint8_t alignmentFill_at_14[2]; +}; +static_assert(sizeof(vr_threshold_s) == 16); + +// start of engine_configuration_s +struct engine_configuration_s { + /** + * http://rusefi.com/wiki/index.php?title=Manual:Engine_Type + * set engine_type X + * offset 0 + */ + engine_type_e engineType; + /** + * Disable sensor sniffer above this rpm + RPM + * offset 4 + */ + uint16_t sensorSnifferRpmThreshold; + /** + * A secondary Rev limit engaged by the driver to help launch the vehicle faster + rpm + * offset 6 + */ + uint16_t launchRpm; + /** + * set rpm_hard_limit X + rpm + * offset 8 + */ + uint16_t rpmHardLimit; + /** + * Engine sniffer would be disabled above this rpm + * set engineSnifferRpmThreshold X + RPM + * offset 10 + */ + uint16_t engineSnifferRpmThreshold; + /** + * Disable multispark above this engine speed. + rpm + * offset 12 + */ + scaled_channel multisparkMaxRpm; + /** + * Above this RPM, disable AC. Set to 0 to disable check. + rpm + * offset 13 + */ + scaled_channel maxAcRpm; + /** + * Above this TPS, disable AC. Set to 0 to disable check. + % + * offset 14 + */ + uint8_t maxAcTps; + /** + * Above this CLT, disable AC to prevent overheating the engine. Set to 0 to disable check. + deg C + * offset 15 + */ + uint8_t maxAcClt; + /** + RPM + * offset 16 + */ + uint16_t knockNoiseRpmBins[ENGINE_NOISE_CURVE_SIZE]; + /** + * 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. + deg + * offset 48 + */ + uint8_t multisparkMaxSparkingAngle; + /** + * Configures the maximum number of extra sparks to fire (does not include main spark) + count + * offset 49 + */ + uint8_t multisparkMaxExtraSparkCount; + /** + * need 4 byte alignment + units + * offset 50 + */ + uint8_t alignmentFill_at_50[2]; + /** + * offset 52 + */ + injector_s injector; + /** + * Does the vehicle have a turbo or supercharger? + offset 120 bit 0 */ + bool isForcedInduction : 1 {}; + /** + * 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. + offset 120 bit 1 */ + bool useFordRedundantTps : 1 {}; + /** + offset 120 bit 2 */ + bool isVerboseAuxPid1 : 1 {}; + /** + offset 120 bit 3 */ + bool overrideTriggerGaps : 1 {}; + /** + * Turn on this fan when AC is on. + offset 120 bit 4 */ + bool enableFan1WithAc : 1 {}; + /** + * Turn on this fan when AC is on. + offset 120 bit 5 */ + bool enableFan2WithAc : 1 {}; + /** + * Inhibit operation of this fan while the engine is not running. + offset 120 bit 6 */ + bool disableFan1WhenStopped : 1 {}; + /** + * Inhibit operation of this fan while the engine is not running. + offset 120 bit 7 */ + bool disableFan2WhenStopped : 1 {}; + /** + * Enable secondary spark outputs that fire after the primary (rotaries, twin plug engines). + offset 120 bit 8 */ + bool enableTrailingSparks : 1 {}; + /** + * enable cj125verbose/disable cj125verbose + offset 120 bit 9 */ + bool isCJ125Verbose : 1 {}; + /** + * Is your UA CJ125 output wired to MCU via resistor divider? Ua can go over 3.3v but only at lambda >3, i.e very lean AFR above 44.1 + * When exposed to free air and 17x gain, Ua will be 4.17 volt + offset 120 bit 10 */ + bool cj125isUaDivided : 1 {}; + /** + offset 120 bit 11 */ + bool cj125isLsu49 : 1 {}; + /** + * TLE7209 uses two-wire mode. TLE9201 and VNH2SP30 do NOT use two wire mode. + offset 120 bit 12 */ + bool etb_use_two_wires : 1 {}; + /** + * 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. + offset 120 bit 13 */ + bool isDoubleSolenoidIdle : 1 {}; + /** + offset 120 bit 14 */ + bool useEeprom : 1 {}; + /** + * Is your UR CJ125 output wired to MCU via resistor divider? + * Looks like 3v range should be enough, divider generally not needed. + offset 120 bit 15 */ + bool cj125isUrDivided : 1 {}; + /** + * Switch between Industrial and Cic PID implementation + offset 120 bit 16 */ + bool useCicPidForIdle : 1 {}; + /** + offset 120 bit 17 */ + bool useTLE8888_cranking_hack : 1 {}; + /** + offset 120 bit 18 */ + bool kickStartCranking : 1 {}; + /** + * This uses separate ignition timing and VE tables not only for idle conditions, also during the postcranking-to-idle taper transition (See also afterCrankingIACtaperDuration). + offset 120 bit 19 */ + bool useSeparateIdleTablesForCrankingTaper : 1 {}; + /** + offset 120 bit 20 */ + bool launchControlEnabled : 1 {}; + /** + * "Detect double trigger edges" + offset 120 bit 21 */ + bool doNotFilterTriggerEdgeNoise : 1 {}; + /** + offset 120 bit 22 */ + bool antiLagEnabled : 1 {}; + /** + * For cranking either use the specified fixed base fuel mass, or use the normal running math (VE table). + offset 120 bit 23 */ + bool useRunningMathForCranking : 1 {}; + /** + * Shall we display real life signal or just the part consumed by trigger decoder. + * Applies to both trigger and cam/vvt input. + * + * enable logic_level_trigger + offset 120 bit 24 */ + bool displayLogicLevelsInEngineSniffer : 1 {}; + /** + offset 120 bit 25 */ + bool useTLE8888_stepper : 1 {}; + /** + * If enabled, the MAP estimate table will be used if the MAP sensor fails to estimate manifold pressure based on RPM and TPS. + offset 120 bit 26 */ + bool enableMapEstimationTableFallback : 1 {}; + /** + offset 120 bit 27 */ + bool usescriptTableForCanSniffingFiltering : 1 {}; + /** + * Print incoming and outgoing first bus CAN messages in rusEFI console + offset 120 bit 28 */ + bool verboseCan : 1 {}; + /** + * Experimental setting that will cause a misfire + * DO NOT ENABLE. + offset 120 bit 29 */ + bool artificialTestMisfire : 1 {}; + /** + * 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. + offset 120 bit 30 */ + bool useFordRedundantPps : 1 {}; + /** + offset 120 bit 31 */ + bool unusedBit_45_31 : 1 {}; + /** + * Closed throttle, 1 volt = 200 units. + * See also tps1_1AdcChannel + * set tps_min X + ADC + * offset 124 + */ + int16_t tpsMin; + /** + * Full throttle. + * See also tps1_1AdcChannel + * set tps_max X + ADC + * offset 126 + */ + int16_t tpsMax; + /** + * TPS error detection: what throttle % is unrealistically low? + * Also used for accelerator pedal error detection if so equiped. + % + * offset 128 + */ + int16_t tpsErrorDetectionTooLow; + /** + * TPS error detection: what throttle % is unrealistically high? + * Also used for accelerator pedal error detection if so equiped. + % + * offset 130 + */ + int16_t tpsErrorDetectionTooHigh; + /** + * offset 132 + */ + cranking_parameters_s cranking; + /** + * Dwell duration while cranking + ms + * offset 140 + */ + float ignitionDwellForCrankingMs; + /** + * Once engine speed passes this value, start reducing ETB angle. + rpm + * offset 144 + */ + uint16_t etbRevLimitStart; + /** + * 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. + rpm + * offset 146 + */ + uint16_t etbRevLimitRange; + /** + * @see isMapAveragingEnabled + * offset 148 + */ + MAP_sensor_config_s map; + /** + * todo: merge with channel settings, use full-scale Thermistor here! + * offset 288 + */ + ThermistorConf clt; + /** + * offset 320 + */ + ThermistorConf iat; + /** + deg + * offset 352 + */ + int launchTimingRetard; + /** + * value '6' for 8MHz hw osc + * read hip9011 datasheet for details + * todo split into two bit fields + integer + * offset 356 + */ + int hip9011PrescalerAndSDO; + /** + * We calculate knock band based of cylinderBore + * Use this to override - kHz knock band override + kHz + * offset 360 + */ + float knockBandCustom; + /** + * offset 364 + */ + specs_s specs; + /** + * Cylinder diameter in mm. + mm + * offset 376 + */ + float cylinderBore; + /** + * This setting controls which fuel quantity control algorithm is used. + * Alpha-N means drive by TPS commonly only used for NA engines + * Speed Density requires MAP sensor and is the default choice for may installs + * MAF air charge is a cylinder filling based method that uses a mass air flow sensor. + * offset 380 + */ + engine_load_mode_e fuelAlgorithm; + /** + % + * offset 381 + */ + uint8_t ALSMaxTPS; + /** + * offset 382 + */ + Gpio criticalLedPin; + /** + * This is the injection strategy during engine start. See Fuel/Injection settings for more detail. It is suggested to use "Simultaneous". + * offset 384 + */ + injection_mode_e crankingInjectionMode; + /** + * 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. If your injectors are individually wired you will also need to enable "Two wire batch emulation". + * set injection_mode X + * See also twoWireBatchInjection + * offset 385 + */ + injection_mode_e injectionMode; + /** + * Minimum RPM to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases. + * offset 386 + */ + uint16_t boostControlMinRpm; + /** + * Minimum TPS to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases. + * offset 388 + */ + uint8_t boostControlMinTps; + /** + * Minimum MAP to enable boost control. Use this to avoid solenoid noise at idle, and help spool in some cases. + * offset 389 + */ + uint8_t boostControlMinMap; + /** + * need 4 byte alignment + units + * offset 390 + */ + uint8_t alignmentFill_at_390[2]; + /** + * Ignition advance angle used during engine cranking, 5-10 degrees will work as a base setting for most engines. + * There is tapering towards running timing advance + * set cranking_timing_angle X + deg + * offset 392 + */ + angle_t crankingTimingAngle; + /** + * Single coil = distributor + * Individual coils = one coil per cylinder (COP, coil-near-plug), requires sequential mode + * Wasted spark = Fires pairs of cylinders together, either one coil per pair of cylinders or one coil per cylinder + * Two distributors = A pair of distributors, found on some BMW, Toyota and other engines + * set ignition_mode X + * offset 396 + */ + ignition_mode_e ignitionMode; + /** + * How many consecutive gap rations have to match expected ranges for sync to happen + count + * offset 397 + */ + int8_t gapTrackingLengthOverride; + /** + * Above this speed, disable closed loop idle control. Set to 0 to disable (allow closed loop idle at any speed). + kph + * offset 398 + */ + uint8_t maxIdleVss; + /** + * need 4 byte alignment + units + * offset 399 + */ + uint8_t alignmentFill_at_399[1]; + /** + * 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. + kPa + * offset 400 + */ + uint16_t minOilPressureAfterStart; + /** + * 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). + * offset 402 + */ + timing_mode_e timingMode; + /** + * need 4 byte alignment + units + * offset 403 + */ + uint8_t alignmentFill_at_403[1]; + /** + * This value is the ignition timing used when in 'fixed timing' mode, i.e. constant timing + * This mode is useful when adjusting distributor location. + RPM + * offset 404 + */ + angle_t fixedModeTiming; + /** + * Angle between Top Dead Center (TDC) and the first trigger event. + * Positive value in case of synchnization point before TDC and negative in case of synchnization point after TDC + * .Knowing this angle allows us to control timing and other angles in reference to TDC. + * set global_trigger_offset_angle X + deg btdc + * offset 408 + */ + angle_t globalTriggerAngleOffset; + /** + * 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. + coef + * offset 412 + */ + float analogInputDividerCoefficient; + /** + * 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. + coef + * offset 416 + */ + float vbattDividerCoeff; + /** + * Cooling fan turn-on temperature threshold, in Celsius + deg C + * offset 420 + */ + float fanOnTemperature; + /** + * Cooling fan turn-off temperature threshold, in Celsius + deg C + * offset 424 + */ + float fanOffTemperature; + /** + * 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. + revs/km + * offset 428 + */ + float driveWheelRevPerKm; + /** + * set can_mode X + * offset 432 + */ + can_nbc_e canNbcType; + /** + * need 4 byte alignment + units + * offset 433 + */ + uint8_t alignmentFill_at_433[3]; + /** + * CANbus thread period in ms + ms + * offset 436 + */ + int canSleepPeriodMs; + /** + * offset 440 + */ + display_mode_e displayMode; + /** + * need 4 byte alignment + units + * offset 441 + */ + uint8_t alignmentFill_at_441[3]; + /** + index + * offset 444 + */ + int byFirmwareVersion; + /** + index + * offset 448 + */ + int HD44780width; + /** + index + * offset 452 + */ + int HD44780height; + /** + * First throttle body, first sensor. See also pedalPositionAdcChannel + * offset 456 + */ + adc_channel_e tps1_1AdcChannel; + /** + * 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. + * offset 457 + */ + adc_channel_e vbattAdcChannel; + /** + * 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. + * offset 458 + */ + adc_channel_e fuelLevelSensor; + /** + * Second throttle body position sensor, single channel so far + * set_analog_input_pin tps2 X + * offset 459 + */ + adc_channel_e tps2_1AdcChannel; + /** + * 0.1 is a good default value + x + * offset 460 + */ + float idle_derivativeFilterLoss; + /** + * just a temporary solution + angle + * offset 464 + */ + int trailingSparkAngle; + /** + * offset 468 + */ + trigger_config_s trigger; + /** + * Extra air taper amount + % + * offset 480 + */ + float airByRpmTaper; + /** + * offset 484 + */ + spi_device_e hip9011SpiDevice; + /** + * Single value to be used in event of a failed MAP sensor + * This value is only used for speed density fueling calculations. + kPa + * offset 485 + */ + uint8_t failedMapFallback; + /** + * 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. + % + * offset 486 + */ + uint8_t boostControlSafeDutyCycle; + /** + * offset 487 + */ + adc_channel_e mafAdcChannel; + /** + * set global_fuel_correction X + coef + * offset 488 + */ + float globalFuelCorrection; + /** + volts + * offset 492 + */ + float adcVcc; + /** + Deg + * offset 496 + */ + float mapCamDetectionAnglePosition; + /** + * 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. + * offset 500 + */ + brain_input_pin_e camInputs[CAM_INPUTS_COUNT]; + /** + * offset 508 + */ + afr_sensor_s afr; + /** + * Electronic throttle pedal position first channel + * See throttlePedalPositionSecondAdcChannel for second channel + * See also tps1_1AdcChannel + * set_analog_input_pin pps X + * See throttlePedalUpVoltage and throttlePedalWOTVoltage + * offset 528 + */ + adc_channel_e throttlePedalPositionAdcChannel; + /** + * need 4 byte alignment + units + * offset 529 + */ + uint8_t alignmentFill_at_529[1]; + /** + * offset 530 + */ + Gpio tle6240_cs; + /** + * offset 532 + */ + pin_output_mode_e tle6240_csPinMode; + /** + * need 4 byte alignment + units + * offset 533 + */ + uint8_t alignmentFill_at_533[1]; + /** + * Throttle Pedal not pressed switch - used on some older vehicles like early Mazda Miata + * offset 534 + */ + switch_input_pin_e throttlePedalUpPin; + /** + * @see hasBaroSensor + * offset 536 + */ + air_pressure_sensor_config_s baroSensor; + /** + * offset 548 + */ + idle_hardware_s idle; + /** + * Value between 0 and 100 used in Manual mode + % + * offset 560 + */ + float manIdlePosition; + /** + * Ignition timing to remove when a knock event occurs. + % + * offset 564 + */ + scaled_channel knockRetardAggression; + /** + * After a knock event, reapply timing at this rate. + deg/s + * offset 565 + */ + scaled_channel knockRetardReapplyRate; + /** + * Select which cam is used for engine sync. Other cams will be used only for VVT measurement, but not engine sync. + * offset 566 + */ + engineSyncCam_e engineSyncCam; + /** + * Set this so your vehicle speed signal is responsive, but not noisy. Larger value give smoother but slower response. + * offset 567 + */ + uint8_t vssFilterReciprocal; + /** + * 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. + ratio + * offset 568 + */ + scaled_channel vssGearRatio; + /** + * 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. + count + * offset 570 + */ + uint8_t vssToothCount; + /** + * need 4 byte alignment + units + * offset 571 + */ + uint8_t alignmentFill_at_571[1]; + /** + * offset 572 + */ + Gpio l9779_cs; + /** + * need 4 byte alignment + units + * offset 574 + */ + uint8_t alignmentFill_at_574[2]; + /** + * Same RPM is used for two ways of producing simulated RPM. See also triggerSimulatorPins (with wires) + * See also directSelfStimulation (no wires, bypassing input hardware) + * rpm X + * TODO: rename to triggerSimulatorRpm + Rpm + * offset 576 + */ + int triggerSimulatorFrequency; + /** + * offset 580 + */ + output_pin_e injectionPins[MAX_CYLINDER_COUNT]; + /** + * offset 604 + */ + output_pin_e ignitionPins[MAX_CYLINDER_COUNT]; + /** + * offset 628 + */ + pin_output_mode_e injectionPinMode; + /** + * offset 629 + */ + pin_output_mode_e ignitionPinMode; + /** + * offset 630 + */ + Gpio HD44780_rs; + /** + * offset 632 + */ + Gpio HD44780_e; + /** + * offset 634 + */ + Gpio HD44780_db4; + /** + * offset 636 + */ + Gpio HD44780_db5; + /** + * offset 638 + */ + Gpio HD44780_db6; + /** + * offset 640 + */ + Gpio HD44780_db7; + /** + * offset 642 + */ + Gpio gps_rx_pin; + /** + * offset 644 + */ + Gpio gps_tx_pin; + /** + * offset 646 + */ + output_pin_e fuelPumpPin; + /** + * offset 648 + */ + pin_output_mode_e fuelPumpPinMode; + /** + * need 4 byte alignment + units + * offset 649 + */ + uint8_t alignmentFill_at_649[1]; + /** + * Check engine light, also malfunction indicator light. Always blinks once on boot. + * offset 650 + */ + output_pin_e malfunctionIndicatorPin; + /** + * offset 652 + */ + pin_output_mode_e malfunctionIndicatorPinMode; + /** + * offset 653 + */ + pin_output_mode_e fanPinMode; + /** + * offset 654 + */ + output_pin_e fanPin; + /** + * Some cars have a switch to indicate that clutch pedal is all the way down + * offset 656 + */ + switch_input_pin_e clutchDownPin; + /** + * offset 658 + */ + output_pin_e alternatorControlPin; + /** + * offset 660 + */ + pin_output_mode_e alternatorControlPinMode; + /** + * offset 661 + */ + pin_input_mode_e clutchDownPinMode; + /** + * offset 662 + */ + Gpio digitalPotentiometerChipSelect[DIGIPOT_COUNT]; + /** + * offset 670 + */ + pin_output_mode_e electronicThrottlePin1Mode; + /** + * need 4 byte alignment + units + * offset 671 + */ + uint8_t alignmentFill_at_671[1]; + /** + * set_cj125_heater_pin XXX + * offset 672 + */ + Gpio wboHeaterPin; + /** + * set_cj125_cs_pin XXX + * offset 674 + */ + Gpio cj125CsPin; + /** + * offset 676 + */ + spi_device_e max31855spiDevice; + /** + * need 4 byte alignment + units + * offset 677 + */ + uint8_t alignmentFill_at_677[1]; + /** + * offset 678 + */ + Gpio debugTriggerSync; + /** + * Digital Potentiometer is used by stock ECU stimulation code + * offset 680 + */ + spi_device_e digitalPotentiometerSpiDevice; + /** + * need 4 byte alignment + units + * offset 681 + */ + uint8_t alignmentFill_at_681[1]; + /** + * offset 682 + */ + Gpio mc33972_cs; + /** + * offset 684 + */ + pin_output_mode_e mc33972_csPinMode; + /** + * Useful in Research&Development phase + * offset 685 + */ + adc_channel_e auxFastSensor1_adcChannel; + /** + * First throttle body, second sensor. + * offset 686 + */ + adc_channel_e tps1_2AdcChannel; + /** + * Second throttle body, second sensor. + * offset 687 + */ + adc_channel_e tps2_2AdcChannel; + /** + * Electronic throttle pedal position input + * Second channel + * See also tps1_1AdcChannel + * See throttlePedalSecondaryUpVoltage and throttlePedalSecondaryWOTVoltage + * offset 688 + */ + adc_channel_e throttlePedalPositionSecondAdcChannel; + /** + % + * offset 689 + */ + uint8_t fuelLevelValues[FUEL_LEVEL_TABLE_COUNT]; + /** + * AFR, WBO, EGO - whatever you like to call it + * offset 697 + */ + ego_sensor_e afr_type; + /** + * need 4 byte alignment + units + * offset 698 + */ + uint8_t alignmentFill_at_698[2]; + /** + * 0.1 is a good default value + x + * offset 700 + */ + float idle_antiwindupFreq; + /** + * offset 704 + */ + brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT]; + /** + * 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. + us + * offset 708 + */ + uint16_t mc33_t_min_boost; + /** + * offset 710 + */ + pin_output_mode_e hip9011CsPinMode; + /** + * need 4 byte alignment + units + * offset 711 + */ + uint8_t alignmentFill_at_711[1]; + /** + * offset 712 + */ + output_pin_e tachOutputPin; + /** + * offset 714 + */ + pin_output_mode_e tachOutputPinMode; + /** + * need 4 byte alignment + units + * offset 715 + */ + uint8_t alignmentFill_at_715[1]; + /** + * offset 716 + */ + output_pin_e mainRelayPin; + /** + * offset 718 + */ + Gpio sdCardCsPin; + /** + * set_can_tx_pin X + * offset 720 + */ + Gpio canTxPin; + /** + * set_can_rx_pin X + * offset 722 + */ + Gpio canRxPin; + /** + * offset 724 + */ + pin_input_mode_e throttlePedalUpPinMode; + /** + * Additional idle % while A/C is active + % + * offset 725 + */ + uint8_t acIdleExtraOffset; + /** + * Ratio between the wheels and your transmission output. + ratio + * offset 726 + */ + scaled_channel finalGearRatio; + /** + * offset 728 + */ + brain_input_pin_e tcuInputSpeedSensorPin; + /** + * offset 730 + */ + uint8_t tcuInputSpeedSensorTeeth; + /** + * need 4 byte alignment + units + * offset 731 + */ + uint8_t alignmentFill_at_731[1]; + /** + * Voltage when the wastegate is closed. + * You probably don't have one of these! + mv + * offset 732 + */ + uint16_t wastegatePositionMin; + /** + * Voltage when the wastegate is fully open. + * You probably don't have one of these! + * 1 volt = 1000 units + mv + * offset 734 + */ + uint16_t wastegatePositionMax; + /** + * Voltage when the idle valve is closed. + * You probably don't have one of these! + mv + * offset 736 + */ + uint16_t idlePositionMin; + /** + * Voltage when the idle valve is open. + * You probably don't have one of these! + * 1 volt = 1000 units + mv + * offset 738 + */ + uint16_t idlePositionMax; + /** + * Secondary TTL channel baud rate + BPs + * offset 740 + */ + uint32_t tunerStudioSerialSpeed; + /** + * Just for reference really, not taken into account by any logic at this point + CR + * offset 744 + */ + float compressionRatio; + /** + * 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. + * See also directSelfStimulation which is different. + * offset 748 + */ + Gpio triggerSimulatorPins[TRIGGER_SIMULATOR_PIN_COUNT]; + /** + g/s + * offset 752 + */ + scaled_channel fordInjectorSmallPulseSlope; + /** + * offset 754 + */ + pin_output_mode_e triggerSimulatorPinModes[TRIGGER_SIMULATOR_PIN_COUNT]; + /** + * offset 756 + */ + adc_channel_e maf2AdcChannel; + /** + * need 4 byte alignment + units + * offset 757 + */ + uint8_t alignmentFill_at_757[1]; + /** + * Narrow band o2 heater, not used for CJ125. 'ON' if engine is running, 'OFF' if stopped or cranking. See wboHeaterPin + * offset 758 + */ + output_pin_e o2heaterPin; + /** + * offset 760 + */ + pin_output_mode_e o2heaterPinModeTodO; + /** + * need 4 byte alignment + units + * offset 761 + */ + uint8_t alignmentFill_at_761[3]; + /** + offset 764 bit 0 */ + bool is_enabled_spi_1 : 1 {}; + /** + offset 764 bit 1 */ + bool is_enabled_spi_2 : 1 {}; + /** + offset 764 bit 2 */ + bool is_enabled_spi_3 : 1 {}; + /** + * enable sd/disable sd + offset 764 bit 3 */ + bool isSdCardEnabled : 1 {}; + /** + * Use 11 bit (standard) or 29 bit (extended) IDs for rusEFI verbose CAN format. + offset 764 bit 4 */ + bool rusefiVerbose29b : 1 {}; + /** + offset 764 bit 5 */ + bool isEngineControlEnabled : 1 {}; + /** + offset 764 bit 6 */ + bool isHip9011Enabled : 1 {}; + /** + offset 764 bit 7 */ + bool isVerboseAlternator : 1 {}; + /** + offset 764 bit 8 */ + bool verboseQuad : 1 {}; + /** + * This setting should only be used if you have a stepper motor idle valve and a stepper motor driver installed. + offset 764 bit 9 */ + bool useStepperIdle : 1 {}; + /** + offset 764 bit 10 */ + bool enabledStep1Limiter : 1 {}; + /** + offset 764 bit 11 */ + bool useTpicAdvancedMode : 1 {}; + /** + offset 764 bit 12 */ + bool useLcdScreen : 1 {}; + /** + offset 764 bit 13 */ + bool verboseTLE8888 : 1 {}; + /** + * CAN broadcast using custom rusEFI protocol + * enable can_broadcast/disable can_broadcast + offset 764 bit 14 */ + bool enableVerboseCanTx : 1 {}; + /** + offset 764 bit 15 */ + bool etb1configured : 1 {}; + /** + * enable cj125/disable cj125 + offset 764 bit 16 */ + bool isCJ125Enabled : 1 {}; + /** + offset 764 bit 17 */ + bool etb2configured : 1 {}; + /** + * Useful for individual intakes + offset 764 bit 18 */ + bool measureMapOnlyInOneCylinder : 1 {}; + /** + offset 764 bit 19 */ + bool stepperForceParkingEveryRestart : 1 {}; + /** + * 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. + offset 764 bit 20 */ + bool isFasterEngineSpinUpEnabled : 1 {}; + /** + * This setting disables fuel injection while the engine is in overrun, this is useful as a fuel saving measure and to prevent back firing. + offset 764 bit 21 */ + bool coastingFuelCutEnabled : 1 {}; + /** + * 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. + offset 764 bit 22 */ + bool useIacTableForCoasting : 1 {}; + /** + offset 764 bit 23 */ + bool useNoiselessTriggerDecoder : 1 {}; + /** + offset 764 bit 24 */ + bool useIdleTimingPidControl : 1 {}; + /** + * 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. + offset 764 bit 25 */ + bool disableEtbWhenEngineStopped : 1 {}; + /** + offset 764 bit 26 */ + bool is_enabled_spi_4 : 1 {}; + /** + * Disable the electronic throttle motor and DC idle motor for testing. + * This mode is for testing ETB/DC idle position sensors, etc without actually driving the throttle. + offset 764 bit 27 */ + bool pauseEtbControl : 1 {}; + /** + offset 764 bit 28 */ + bool alignEngineSnifferAtTDC : 1 {}; + /** + offset 764 bit 29 */ + bool unused764b29 : 1 {}; + /** + offset 764 bit 30 */ + bool idleIncrementalPidCic : 1 {}; + /** + * AEM X-Series or rusEFI Wideband + offset 764 bit 31 */ + bool enableAemXSeries : 1 {}; + /** + * offset 768 + */ + brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT]; + /** + * offset 776 + */ + pin_output_mode_e mainRelayPinMode; + /** + * need 4 byte alignment + units + * offset 777 + */ + uint8_t alignmentFill_at_777[1]; + /** + * offset 778 + */ + Gpio hip9011CsPin; + /** + * offset 780 + */ + Gpio hip9011IntHoldPin; + /** + * offset 782 + */ + pin_output_mode_e hip9011IntHoldPinMode; + /** + * need 4 byte alignment + units + * offset 783 + */ + uint8_t alignmentFill_at_783[1]; + /** + * offset 784 + */ + uint32_t verboseCanBaseAddress; + /** + * Boost Voltage + v + * offset 788 + */ + uint8_t mc33_hvolt; + /** + * Minimum MAP before closed loop boost is enabled. Use to prevent misbehavior upon entering boost. + kPa + * offset 789 + */ + uint8_t minimumBoostClosedLoopMap; + /** + * Optional Radiator Fan used with A/C + * offset 790 + */ + output_pin_e acFanPin; + /** + * offset 792 + */ + pin_output_mode_e acFanPinMode; + /** + * offset 793 + */ + spi_device_e l9779spiDevice; + /** + volts + * offset 794 + */ + scaled_channel dwellVoltageCorrVoltBins[DWELL_CURVE_SIZE]; + /** + * offset 802 + */ + imu_type_e imuType; + /** + multiplier + * offset 803 + */ + scaled_channel dwellVoltageCorrValues[DWELL_CURVE_SIZE]; + /** + * need 4 byte alignment + units + * offset 811 + */ + uint8_t alignmentFill_at_811[1]; + /** + kg + * offset 812 + */ + uint16_t vehicleWeight; + /** + * How far above idle speed do we consider idling? + * For example, if target = 800, this param = 200, then anything below 1000 RPM is considered idle. + RPM + * offset 814 + */ + int16_t idlePidRpmUpperLimit; + /** + * Apply nonlinearity correction below a pulse of this duration. Pulses longer than this duration will receive no adjustment. + ms + * offset 816 + */ + scaled_channel applyNonlinearBelowPulse; + /** + * offset 818 + */ + Gpio lps25BaroSensorScl; + /** + * offset 820 + */ + Gpio lps25BaroSensorSda; + /** + * offset 822 + */ + brain_input_pin_e vehicleSpeedSensorInputPin; + /** + * Some vehicles have a switch to indicate that clutch pedal is all the way up + * offset 824 + */ + switch_input_pin_e clutchUpPin; + /** + * offset 826 + */ + InjectorNonlinearMode injectorNonlinearMode; + /** + * offset 827 + */ + pin_input_mode_e clutchUpPinMode; + /** + * offset 828 + */ + Gpio max31855_cs[EGT_CHANNEL_COUNT]; + /** + * Continental/GM flex fuel sensor, 50-150hz type + * offset 844 + */ + brain_input_pin_e flexSensorPin; + /** + * offset 846 + */ + Gpio test557pin; + /** + * offset 848 + */ + pin_output_mode_e stepperDirectionPinMode; + /** + * offset 849 + */ + spi_device_e mc33972spiDevice; + /** + * Stoichiometric ratio for your secondary fuel. This value is used when the Flex Fuel sensor indicates E100, typically 9.0 + :1 + * offset 850 + */ + scaled_channel stoichRatioSecondary; + /** + * Maximum allowed ETB position. Some throttles go past fully open, so this allows you to limit it to fully open. + % + * offset 851 + */ + uint8_t etbMaximumPosition; + /** + * Rate the ECU will log to the SD card, in hz (log lines per second). + hz + * offset 852 + */ + uint16_t sdCardLogFrequency; + /** + * offset 854 + */ + adc_channel_e idlePositionSensor; + /** + * need 4 byte alignment + units + * offset 855 + */ + uint8_t alignmentFill_at_855[1]; + /** + * offset 856 + */ + Gpio debugMapAveraging; + /** + * offset 858 + */ + output_pin_e starterRelayDisablePin; + /** + * On some vehicles we can disable starter once engine is already running + * offset 860 + */ + pin_output_mode_e starterRelayDisablePinMode; + /** + * need 4 byte alignment + units + * offset 861 + */ + uint8_t alignmentFill_at_861[1]; + /** + * Some Subaru and some Mazda use double-solenoid idle air valve + * offset 862 + */ + output_pin_e secondSolenoidPin; + /** + * See also starterControlPin + * offset 864 + */ + switch_input_pin_e startStopButtonPin; + /** + * need 4 byte alignment + units + * offset 866 + */ + uint8_t alignmentFill_at_866[2]; + /** + * 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. + count + * offset 868 + */ + int mapMinBufferLength; + /** + * 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%. + % + * offset 872 + */ + int16_t idlePidDeactivationTpsThreshold; + /** + % + * offset 874 + */ + int16_t stepperParkingExtraSteps; + /** + ADC + * offset 876 + */ + uint16_t tps1SecondaryMin; + /** + ADC + * offset 878 + */ + uint16_t tps1SecondaryMax; + /** + rpm + * offset 880 + */ + int16_t antiLagRpmTreshold; + /** + * Maximum time to crank starter when start/stop button is pressed + Seconds + * offset 882 + */ + uint16_t startCrankingDuration; + /** + * This pin is used for debugging - snap a logic analyzer on it and see if it's ever high + * offset 884 + */ + Gpio triggerErrorPin; + /** + * offset 886 + */ + pin_output_mode_e triggerErrorPinMode; + /** + * need 4 byte alignment + units + * offset 887 + */ + uint8_t alignmentFill_at_887[1]; + /** + * offset 888 + */ + output_pin_e acRelayPin; + /** + * offset 890 + */ + pin_output_mode_e acRelayPinMode; + /** + * need 4 byte alignment + units + * offset 891 + */ + uint8_t alignmentFill_at_891[1]; + /** + * offset 892 + */ + script_setting_t scriptSetting[SCRIPT_SETTING_COUNT]; + /** + * offset 924 + */ + Gpio spi1mosiPin; + /** + * offset 926 + */ + Gpio spi1misoPin; + /** + * offset 928 + */ + Gpio spi1sckPin; + /** + * offset 930 + */ + Gpio spi2mosiPin; + /** + * offset 932 + */ + Gpio spi2misoPin; + /** + * offset 934 + */ + Gpio spi2sckPin; + /** + * offset 936 + */ + Gpio spi3mosiPin; + /** + * offset 938 + */ + Gpio spi3misoPin; + /** + * offset 940 + */ + Gpio spi3sckPin; + /** + * Saab Combustion Detection Module knock signal input pin + * also known as Saab Ion Sensing Module + * offset 942 + */ + Gpio cdmInputPin; + /** + * offset 944 + */ + Gpio joystickCenterPin; + /** + * offset 946 + */ + Gpio joystickAPin; + /** + * offset 948 + */ + Gpio joystickBPin; + /** + * offset 950 + */ + Gpio joystickCPin; + /** + * offset 952 + */ + Gpio joystickDPin; + /** + * offset 954 + */ + uart_device_e consoleUartDevice; + /** + * rusEFI console Sensor Sniffer mode + * offset 955 + */ + sensor_chart_e sensorChartMode; + /** + * offset 956 + */ + maf_sensor_type_e mafSensorType; + /** + * need 4 byte alignment + units + * offset 957 + */ + uint8_t alignmentFill_at_957[3]; + /** + offset 960 bit 0 */ + bool clutchUpPinInverted : 1 {}; + /** + offset 960 bit 1 */ + bool clutchDownPinInverted : 1 {}; + /** + * If enabled we use two H-bridges to drive stepper idle air valve + offset 960 bit 2 */ + bool useHbridgesToDriveIdleStepper : 1 {}; + /** + offset 960 bit 3 */ + bool multisparkEnable : 1 {}; + /** + offset 960 bit 4 */ + bool enableLaunchRetard : 1 {}; + /** + offset 960 bit 5 */ + bool unfinishedenableLaunchBoost : 1 {}; + /** + offset 960 bit 6 */ + bool unfinishedlaunchDisableBySpeed : 1 {}; + /** + * Read VSS from OEM CAN bus according to selected CAN vehicle configuration. + offset 960 bit 7 */ + bool enableCanVss : 1 {}; + /** + offset 960 bit 8 */ + bool enableInnovateLC2 : 1 {}; + /** + offset 960 bit 9 */ + bool showHumanReadableWarning : 1 {}; + /** + * 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. Use of this mode is required if you have a narrowband O2 sensor. + offset 960 bit 10 */ + bool stftIgnoreErrorMagnitude : 1 {}; + /** + offset 960 bit 11 */ + bool vvtBooleanForVerySpecialCases : 1 {}; + /** + offset 960 bit 12 */ + bool enableSoftwareKnock : 1 {}; + /** + * Verbose info in console below engineSnifferRpmThreshold + * enable vvt_details + offset 960 bit 13 */ + bool verboseVVTDecoding : 1 {}; + /** + * get invertCamVVTSignal + offset 960 bit 14 */ + bool invertCamVVTSignal : 1 {}; + /** + * This property is useful if using rusEFI as TCM or BCM only + * enable consumeObdSensors + offset 960 bit 15 */ + bool consumeObdSensors : 1 {}; + /** + offset 960 bit 16 */ + bool knockBankCyl1 : 1 {}; + /** + offset 960 bit 17 */ + bool knockBankCyl2 : 1 {}; + /** + offset 960 bit 18 */ + bool knockBankCyl3 : 1 {}; + /** + offset 960 bit 19 */ + bool knockBankCyl4 : 1 {}; + /** + offset 960 bit 20 */ + bool knockBankCyl5 : 1 {}; + /** + offset 960 bit 21 */ + bool knockBankCyl6 : 1 {}; + /** + offset 960 bit 22 */ + bool knockBankCyl7 : 1 {}; + /** + offset 960 bit 23 */ + bool knockBankCyl8 : 1 {}; + /** + offset 960 bit 24 */ + bool knockBankCyl9 : 1 {}; + /** + offset 960 bit 25 */ + bool knockBankCyl10 : 1 {}; + /** + offset 960 bit 26 */ + bool knockBankCyl11 : 1 {}; + /** + offset 960 bit 27 */ + bool knockBankCyl12 : 1 {}; + /** + offset 960 bit 28 */ + bool tcuEnabled : 1 {}; + /** + offset 960 bit 29 */ + bool canBroadcastUseChannelTwo : 1 {}; + /** + * If enabled we use four Push-Pull outputs to directly drive stepper idle air valve coilss + offset 960 bit 30 */ + bool useRawOutputToDriveIdleStepper : 1 {}; + /** + * Print incoming and outgoing second bus CAN messages in rusEFI console + offset 960 bit 31 */ + bool verboseCan2 : 1 {}; + /** + * offset 964 + */ + dc_io etbIo[ETB_COUNT]; + /** + * Wastegate control Solenoid + * offset 980 + */ + output_pin_e boostControlPin; + /** + * offset 982 + */ + pin_output_mode_e boostControlPinMode; + /** + * need 4 byte alignment + units + * offset 983 + */ + uint8_t alignmentFill_at_983[1]; + /** + * offset 984 + */ + switch_input_pin_e ALSActivatePin; + /** + * offset 986 + */ + switch_input_pin_e launchActivatePin; + /** + * offset 988 + */ + pid_s boostPid; + /** + * offset 1008 + */ + boostType_e boostType; + /** + * need 4 byte alignment + units + * offset 1009 + */ + uint8_t alignmentFill_at_1009[3]; + /** + Hz + * offset 1012 + */ + int boostPwmFrequency; + /** + * offset 1016 + */ + launchActivationMode_e launchActivationMode; + /** + * offset 1017 + */ + antiLagActivationMode_e antiLagActivationMode; + /** + * need 4 byte alignment + units + * offset 1018 + */ + uint8_t alignmentFill_at_1018[2]; + /** + * Disabled above this speed + Kph + * offset 1020 + */ + int launchSpeedThreshold; + /** + * Range from Launch RPM for Timing Retard to activate + RPM + * offset 1024 + */ + int launchTimingRpmRange; + /** + * Extra Fuel Added + % + * offset 1028 + */ + int launchFuelAdded; + /** + * Duty Cycle for the Boost Solenoid + % + * offset 1032 + */ + int launchBoostDuty; + /** + * Range from Launch RPM to activate Hard Cut + RPM + * offset 1036 + */ + int hardCutRpmRange; + /** + * offset 1040 + */ + float turbochargerFilter; + /** + * offset 1044 + */ + int launchTpsThreshold; + /** + * offset 1048 + */ + float launchActivateDelay; + /** + * offset 1052 + */ + stft_s stft; + /** + * offset 1076 + */ + dc_io stepperDcIo[DC_PER_STEPPER]; + /** + * For example, BMW, GM or Chevrolet + * REQUIRED for rusEFI Online + * offset 1092 + */ + vehicle_info_t engineMake; + /** + * For example, LS1 or NB2 + * REQUIRED for rusEFI Online + * offset 1124 + */ + vehicle_info_t engineCode; + /** + * For example, Hunchback or Orange Miata + * Vehicle name has to be unique between your vehicles. + * REQUIRED for rusEFI Online + * offset 1156 + */ + vehicle_info_t vehicleName; + /** + * offset 1188 + */ + output_pin_e tcu_solenoid[TCU_SOLENOID_COUNT]; + /** + * offset 1200 + */ + dc_function_e etbFunctions[ETB_COUNT]; + /** + * offset 1202 + */ + spi_device_e drv8860spiDevice; + /** + * need 4 byte alignment + units + * offset 1203 + */ + uint8_t alignmentFill_at_1203[1]; + /** + * offset 1204 + */ + Gpio drv8860_cs; + /** + * offset 1206 + */ + pin_output_mode_e drv8860_csPinMode; + /** + * need 4 byte alignment + units + * offset 1207 + */ + uint8_t alignmentFill_at_1207[1]; + /** + * offset 1208 + */ + Gpio drv8860_miso; + /** + volt + * offset 1210 + */ + scaled_channel fuelLevelBins[FUEL_LEVEL_TABLE_COUNT]; + /** + * offset 1226 + */ + output_pin_e luaOutputPins[LUA_PWM_COUNT]; + /** + * need 4 byte alignment + units + * offset 1242 + */ + uint8_t alignmentFill_at_1242[2]; + /** + * Angle between cam sensor and VVT zero position + * set vvt_offset X + value + * offset 1244 + */ + float vvtOffsets[CAM_INPUTS_COUNT]; + /** + * offset 1260 + */ + vr_threshold_s vrThreshold[VR_THRESHOLD_COUNT]; + /** + * offset 1292 + */ + gppwm_note_t gpPwmNote[GPPWM_CHANNELS]; + /** + ADC + * offset 1356 + */ + uint16_t tps2SecondaryMin; + /** + ADC + * offset 1358 + */ + uint16_t tps2SecondaryMax; + /** + * Select which bus the wideband controller is attached to. + offset 1360 bit 0 */ + bool widebandOnSecondBus : 1 {}; + /** + * Enables lambda sensor closed loop feedback for fuelling. + offset 1360 bit 1 */ + bool fuelClosedLoopCorrectionEnabled : 1 {}; + /** + * Print details into rusEFI console + * enable verbose_idle + offset 1360 bit 2 */ + bool isVerboseIAC : 1 {}; + /** + offset 1360 bit 3 */ + bool boardUseTachPullUp : 1 {}; + /** + offset 1360 bit 4 */ + bool boardUseTempPullUp : 1 {}; + /** + offset 1360 bit 5 */ + bool yesUnderstandLocking : 1 {}; + /** + * Sometimes we have a performance issue while printing error + offset 1360 bit 6 */ + bool silentTriggerError : 1 {}; + /** + offset 1360 bit 7 */ + bool useLinearCltSensor : 1 {}; + /** + * enable can_read/disable can_read + offset 1360 bit 8 */ + bool canReadEnabled : 1 {}; + /** + * enable can_write/disable can_write + offset 1360 bit 9 */ + bool canWriteEnabled : 1 {}; + /** + offset 1360 bit 10 */ + bool useLinearIatSensor : 1 {}; + /** + offset 1360 bit 11 */ + bool boardUse2stepPullDown : 1 {}; + /** + * Treat milliseconds value as duty cycle value, i.e. 0.5ms would become 50% + offset 1360 bit 12 */ + bool tachPulseDurationAsDutyCycle : 1 {}; + /** + * This enables smart alternator control and activates the extra alternator settings. + offset 1360 bit 13 */ + bool isAlternatorControlEnabled : 1 {}; + /** + * https://wiki.rusefi.com/Trigger-Configuration-Guide + * This setting flips the signal from the primary engine speed sensor. + offset 1360 bit 14 */ + bool invertPrimaryTriggerSignal : 1 {}; + /** + * https://wiki.rusefi.com/Trigger-Configuration-Guide + * This setting flips the signal from the secondary engine speed sensor. + offset 1360 bit 15 */ + bool invertSecondaryTriggerSignal : 1 {}; + /** + offset 1360 bit 16 */ + bool cutFuelOnHardLimit : 1 {}; + /** + * Be careful enabling this: some engines are known to self-disassemble their valvetrain with a spark cut. Fuel cut is much safer. + offset 1360 bit 17 */ + bool cutSparkOnHardLimit : 1 {}; + /** + offset 1360 bit 18 */ + bool launchFuelCutEnable : 1 {}; + /** + * This is the Cut Mode normally used + offset 1360 bit 19 */ + bool launchSparkCutEnable : 1 {}; + /** + offset 1360 bit 20 */ + bool boardUseCrankPullUp : 1 {}; + /** + offset 1360 bit 21 */ + bool boardUseCamPullDown : 1 {}; + /** + offset 1360 bit 22 */ + bool boardUseCamVrPullUp : 1 {}; + /** + offset 1360 bit 23 */ + bool boardUseD2PullDown : 1 {}; + /** + offset 1360 bit 24 */ + bool boardUseD3PullDown : 1 {}; + /** + offset 1360 bit 25 */ + bool boardUseD4PullDown : 1 {}; + /** + offset 1360 bit 26 */ + bool boardUseD5PullDown : 1 {}; + /** + offset 1360 bit 27 */ + bool verboseIsoTp : 1 {}; + /** + offset 1360 bit 28 */ + bool engineSnifferFocusOnInputs : 1 {}; + /** + offset 1360 bit 29 */ + bool launchActivateInverted : 1 {}; + /** + offset 1360 bit 30 */ + bool twoStroke : 1 {}; + /** + * Where is your primary skipped wheel located? + offset 1360 bit 31 */ + bool skippedWheelOnCam : 1 {}; + /** + * offset 1364 + */ + adc_channel_e hipOutputChannel; + /** + * need 4 byte alignment + units + * offset 1365 + */ + uint8_t alignmentFill_at_1365[1]; + /** + * A/C button input + * offset 1366 + */ + switch_input_pin_e acSwitch; + /** + * offset 1368 + */ + adc_channel_e vRefAdcChannel; + /** + * Expected neutral position + % + * offset 1369 + */ + uint8_t etbNeutralPosition; + /** + * See also idleRpmPid + * offset 1370 + */ + idle_mode_e idleMode; + /** + * need 4 byte alignment + units + * offset 1371 + */ + uint8_t alignmentFill_at_1371[1]; + /** + offset 1372 bit 0 */ + bool isInjectionEnabled : 1 {}; + /** + offset 1372 bit 1 */ + bool isIgnitionEnabled : 1 {}; + /** + * When enabled if TPS is held above 95% no fuel is injected while cranking to clear excess fuel from the cylinders. + offset 1372 bit 2 */ + bool isCylinderCleanupEnabled : 1 {}; + /** + * Should we use tables to vary tau/beta based on CLT/MAP, or just with fixed values? + offset 1372 bit 3 */ + bool complexWallModel : 1 {}; + /** + offset 1372 bit 4 */ + bool alwaysInstantRpm : 1 {}; + /** + offset 1372 bit 5 */ + bool isMapAveragingEnabled : 1 {}; + /** + * If enabled, use separate temperature multiplier table for cranking idle position. + * If disabled, use normal running multiplier table applied to the cranking base position. + offset 1372 bit 6 */ + bool overrideCrankingIacSetting : 1 {}; + /** + * 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. + offset 1372 bit 7 */ + bool useSeparateAdvanceForIdle : 1 {}; + /** + offset 1372 bit 8 */ + bool isWaveAnalyzerEnabled : 1 {}; + /** + * This activates a separate fuel table for Idle, this allows fine tuning of the idle fuelling. + offset 1372 bit 9 */ + bool useSeparateVeForIdle : 1 {}; + /** + * Verbose info in console below engineSnifferRpmThreshold + * enable trigger_details + offset 1372 bit 10 */ + bool verboseTriggerSynchDetails : 1 {}; + /** + * Usually if we have no trigger events that means engine is stopped + * Unless we are troubleshooting and spinning the engine by hand - this case a longer + * delay is needed + offset 1372 bit 11 */ + bool isManualSpinningMode : 1 {}; + /** + * This is needed if your coils are individually wired and you wish to use batch injection. + * enable two_wire_batch_injection + offset 1372 bit 12 */ + bool twoWireBatchInjection : 1 {}; + /** + offset 1372 bit 13 */ + bool neverInstantRpm : 1 {}; + /** + * This is needed if your coils are individually wired (COP) and you wish to use batch ignition (Wasted Spark). + offset 1372 bit 14 */ + bool twoWireBatchIgnition : 1 {}; + /** + offset 1372 bit 15 */ + bool useFixedBaroCorrFromMap : 1 {}; + /** + * In Constant mode, timing is automatically tapered to running as RPM increases. + * In Table mode, the "Cranking ignition advance" table is used directly. + offset 1372 bit 16 */ + bool useSeparateAdvanceForCranking : 1 {}; + /** + * This enables the various ignition corrections during cranking (IAT, CLT, FSIO and PID idle). + * You probably don't need this. + offset 1372 bit 17 */ + bool useAdvanceCorrectionsForCranking : 1 {}; + /** + * Enable a second cranking table to use for E100 flex fuel, interpolating between the two based on flex fuel sensor. + offset 1372 bit 18 */ + bool flexCranking : 1 {}; + /** + * This flag allows to use a special 'PID Multiplier' table (0.0-1.0) to compensate for nonlinear nature of IAC-RPM controller + offset 1372 bit 19 */ + bool useIacPidMultTable : 1 {}; + /** + offset 1372 bit 20 */ + bool isBoostControlEnabled : 1 {}; + /** + * Interpolates the Ignition Retard from 0 to 100% within the RPM Range + offset 1372 bit 21 */ + bool launchSmoothRetard : 1 {}; + /** + * Some engines are OK running semi-random sequential while other engine require phase synchronization + offset 1372 bit 22 */ + bool isPhaseSyncRequiredForIgnition : 1 {}; + /** + * If enabled, use a curve for RPM limit (based on coolant temperature) instead of a constant value. + offset 1372 bit 23 */ + bool useCltBasedRpmLimit : 1 {}; + /** + * 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. + offset 1372 bit 24 */ + bool forceO2Heating : 1 {}; + /** + * 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'. + offset 1372 bit 25 */ + bool invertVvtControlIntake : 1 {}; + /** + * 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'. + offset 1372 bit 26 */ + bool invertVvtControlExhaust : 1 {}; + /** + offset 1372 bit 27 */ + bool useBiQuadOnAuxSpeedSensors : 1 {}; + /** + * '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. + offset 1372 bit 28 */ + bool sdTriggerLog : 1 {}; + /** + offset 1372 bit 29 */ + bool ALSActivateInverted : 1 {}; + /** + offset 1372 bit 30 */ + bool unused_1484_bit_30 : 1 {}; + /** + offset 1372 bit 31 */ + bool tempBooleanForVerySpecialLogic : 1 {}; + /** + count + * offset 1376 + */ + uint32_t engineChartSize; + /** + mult + * offset 1380 + */ + float turboSpeedSensorMultiplier; + /** + * offset 1384 + */ + Gpio camInputsDebug[CAM_INPUTS_COUNT]; + /** + * Extra idle target speed when A/C is enabled. Some cars need the extra speed to keep the AC efficient while idling. + RPM + * offset 1392 + */ + int16_t acIdleRpmBump; + /** + * set warningPeriod X + seconds + * offset 1394 + */ + int16_t warningPeriod; + /** + angle + * offset 1396 + */ + float knockDetectionWindowStart; + /** + angle + * offset 1400 + */ + float knockDetectionWindowEnd; + /** + ms + * offset 1404 + */ + float idleStepperReactionTime; + /** + count + * offset 1408 + */ + int idleStepperTotalSteps; + /** + * TODO: finish this #413 + sec + * offset 1412 + */ + float noAccelAfterHardLimitPeriodSecs; + /** + * At what trigger index should some MAP-related math be executed? This is a performance trick to reduce load on synchronization trigger callback. + index + * offset 1416 + */ + int mapAveragingSchedulingAtIndex; + /** + * Duration in ms or duty cycle depending on selected mode + * offset 1420 + */ + float tachPulseDuractionMs; + /** + * Length of time the deposited wall fuel takes to dissipate after the start of acceleration. + Seconds + * offset 1424 + */ + float wwaeTau; + /** + * offset 1428 + */ + pid_s alternatorControl; + /** + * offset 1448 + */ + pid_s etb; + /** + * offset 1468 + */ + Gpio triggerInputDebugPins[TRIGGER_INPUT_PIN_COUNT]; + /** + * RPM range above upper limit for extra air taper,"RPM", 1, 0, 0, 1500, 0 + * offset 1472 + */ + int16_t airTaperRpmRange; + /** + * offset 1474 + */ + brain_input_pin_e turboSpeedSensorInputPin; + /** + * Closed throttle#2. todo: extract these two fields into a structure + * See also tps2_1AdcChannel + * set tps2_min X + ADC + * offset 1476 + */ + int16_t tps2Min; + /** + * Full throttle#2. tpsMax value as 10 bit ADC value. Not Voltage! + * See also tps1_1AdcChannel + * set tps2_max X + ADC + * offset 1478 + */ + int16_t tps2Max; + /** + * See also startStopButtonPin + * offset 1480 + */ + output_pin_e starterControlPin; + /** + * offset 1482 + */ + pin_input_mode_e startStopButtonMode; + /** + * need 4 byte alignment + units + * offset 1483 + */ + uint8_t alignmentFill_at_1483[1]; + /** + * offset 1484 + */ + Gpio mc33816_flag0; + /** + Pulse + * offset 1486 + */ + uint8_t tachPulsePerRev; + /** + * need 4 byte alignment + units + * offset 1487 + */ + uint8_t alignmentFill_at_1487[1]; + /** + * kPa value which is too low to be true + kPa + * offset 1488 + */ + float mapErrorDetectionTooLow; + /** + * kPa value which is too high to be true + kPa + * offset 1492 + */ + float mapErrorDetectionTooHigh; + /** + * How long to wait for the spark to fire before recharging the coil for another spark. + ms + * offset 1496 + */ + scaled_channel multisparkSparkDuration; + /** + * This sets the dwell time for subsequent sparks. The main spark's dwell is set by the dwell table. + ms + * offset 1498 + */ + scaled_channel multisparkDwell; + /** + * See cltIdleRpmBins + * offset 1500 + */ + pid_s idleRpmPid; + /** + * 0 = No fuel settling on port walls 1 = All the fuel settling on port walls setting this to 0 disables the wall wetting enrichment. + Fraction + * offset 1520 + */ + float wwaeBeta; + /** + * blue LED on many rusEFI boards. + * Blue Communication LED which is expected to blink at 50% duty cycle during normal board operation. + * If USB communication cable is connected Blue LED starts to blink faster. + * offset 1524 + */ + Gpio communicationLedPin; + /** + * Green LED on many rusEFI boards. + * Off if engine is stopped, blinks if engine is cranking, solid if engine is running. + * offset 1526 + */ + Gpio runningLedPin; + /** + * See also EFI_CONSOLE_RX_BRAIN_PIN + * offset 1528 + */ + Gpio binarySerialTxPin; + /** + * offset 1530 + */ + Gpio binarySerialRxPin; + /** + * offset 1532 + */ + Gpio auxValves[AUX_DIGITAL_VALVE_COUNT]; + /** + * offset 1536 + */ + switch_input_pin_e tcuUpshiftButtonPin; + /** + * offset 1538 + */ + switch_input_pin_e tcuDownshiftButtonPin; + /** + voltage + * offset 1540 + */ + float throttlePedalUpVoltage; + /** + * Pedal in the floor + voltage + * offset 1544 + */ + float throttlePedalWOTVoltage; + /** + * on IGN voltage detection turn fuel pump on to build fuel pressure + seconds + * offset 1548 + */ + int16_t startUpFuelPumpDuration; + /** + * If the RPM closer to target than this value, disable closed loop idle correction to prevent oscillation + RPM + * offset 1550 + */ + int16_t idlePidRpmDeadZone; + /** + * This is the target battery voltage the alternator PID control will attempt to maintain + Volts + * offset 1552 + */ + float targetVBatt; + /** + * Turns off alternator output above specified TPS, enabling this reduced parasitic drag on the engine at full load. + % + * offset 1556 + */ + float alternatorOffAboveTps; + /** + * 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. + cycles + * offset 1560 + */ + int16_t afterCrankingIACtaperDuration; + /** + * Extra IAC, in percent between 0 and 100, tapered between zero and idle deactivation TPS value + percent + * offset 1562 + */ + int16_t iacByTpsTaper; + /** + * Auxiliary sensor serial, not to be confused with secondary calibration serial + * set_aux_tx_pin X + * offset 1564 + */ + Gpio auxSerialTxPin; + /** + * offset 1566 + */ + Gpio warningLedPin; + /** + * Auxiliary sensor serial, not to be confused with secondary calibration serial + * set_aux_rx_pin X + * offset 1568 + */ + Gpio auxSerialRxPin; + /** + * offset 1570 + */ + Gpio LIS302DLCsPin; + /** + * How long to look back for TPS-based acceleration enrichment. Increasing this time will trigger enrichment for longer when a throttle position change occurs. + sec + * offset 1572 + */ + scaled_channel tpsAccelLookback; + /** + * Below this speed, disable DFCO. Use this to prevent jerkiness from fuel enable/disable in low gears. + kph + * offset 1573 + */ + uint8_t coastingFuelCutVssLow; + /** + * Above this speed, allow DFCO. Use this to prevent jerkiness from fuel enable/disable in low gears. + kph + * offset 1574 + */ + uint8_t coastingFuelCutVssHigh; + /** + * 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. + sec + * offset 1575 + */ + scaled_channel noFuelTrimAfterDfcoTime; + /** + * 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. + roc + * offset 1576 + */ + float tpsAccelEnrichmentThreshold; + /** + * offset 1580 + */ + brain_input_pin_e auxSpeedSensorInputPin[2]; + /** + * offset 1584 + */ + uint8_t totalGearsCount; + /** + * Sets what part of injection's is controlled by the injection phase table. + * offset 1585 + */ + InjectionTimingMode injectionTimingMode; + /** + * need 4 byte alignment + units + * offset 1586 + */ + uint8_t alignmentFill_at_1586[2]; + /** + * Band rate for primary TTL + BPs + * offset 1588 + */ + uint32_t uartConsoleSerialSpeed; + /** + * For decel we simply multiply delta of TPS and tFor decel we do not use table?! + roc + * offset 1592 + */ + float tpsDecelEnleanmentThreshold; + /** + * Magic multiplier, we multiply delta of TPS and get fuel squirt duration + coeff + * offset 1596 + */ + float tpsDecelEnleanmentMultiplier; + /** + * ExpAverage alpha coefficient + coeff + * offset 1600 + */ + float slowAdcAlpha; + /** + * See http://rusefi.com/s/debugmode + * + * set debug_mode X + * offset 1604 + */ + debug_mode_e debugMode; + /** + * need 4 byte alignment + units + * offset 1605 + */ + uint8_t alignmentFill_at_1605[3]; + /** + BPs + * offset 1608 + */ + uint32_t auxSerialSpeed; + /** + voltage + * offset 1612 + */ + float throttlePedalSecondaryUpVoltage; + /** + * Pedal in the floor + voltage + * offset 1616 + */ + float throttlePedalSecondaryWOTVoltage; + /** + * set can_baudrate + * offset 1620 + */ + can_baudrate_e canBaudRate; + /** + * Override the Y axis (load) value used for the VE table. + * Advanced users only: If you aren't sure you need this, you probably don't need this. + * offset 1621 + */ + ve_override_e veOverrideMode; + /** + * offset 1622 + */ + can_baudrate_e can2BaudRate; + /** + * Override the Y axis (load) value used for the AFR table. + * Advanced users only: If you aren't sure you need this, you probably don't need this. + * offset 1623 + */ + load_override_e afrOverrideMode; + /** + A + * offset 1624 + */ + scaled_channel mc33_hpfp_i_peak; + /** + A + * offset 1625 + */ + scaled_channel mc33_hpfp_i_hold; + /** + * How long to deactivate power when hold current is reached before applying power again + us + * offset 1626 + */ + uint8_t mc33_hpfp_i_hold_off; + /** + * Maximum amount of time the solenoid can be active before assuming a programming error + ms + * offset 1627 + */ + uint8_t mc33_hpfp_max_hold; + /** + * Enable if DC-motor driver (H-bridge) inverts the signals (eg. RZ7899 on Hellen boards) + offset 1628 bit 0 */ + bool stepperDcInvertedPins : 1 {}; + /** + * Allow OpenBLT on Primary CAN + offset 1628 bit 1 */ + bool canOpenBLT : 1 {}; + /** + * Allow OpenBLT on Secondary CAN + offset 1628 bit 2 */ + bool can2OpenBLT : 1 {}; + /** + * Select whether to configure injector flow in volumetric flow (defualt, cc/min) or mass flow (g/s). + offset 1628 bit 3 */ + bool injectorFlowAsMassFlow : 1 {}; + /** + offset 1628 bit 4 */ + bool unused1127 : 1 {}; + /** + offset 1628 bit 5 */ + bool unused1128 : 1 {}; + /** + offset 1628 bit 6 */ + bool unused1129 : 1 {}; + /** + offset 1628 bit 7 */ + bool unused1130 : 1 {}; + /** + offset 1628 bit 8 */ + bool unusedBit_542_8 : 1 {}; + /** + offset 1628 bit 9 */ + bool unusedBit_542_9 : 1 {}; + /** + offset 1628 bit 10 */ + bool unusedBit_542_10 : 1 {}; + /** + offset 1628 bit 11 */ + bool unusedBit_542_11 : 1 {}; + /** + offset 1628 bit 12 */ + bool unusedBit_542_12 : 1 {}; + /** + offset 1628 bit 13 */ + bool unusedBit_542_13 : 1 {}; + /** + offset 1628 bit 14 */ + bool unusedBit_542_14 : 1 {}; + /** + offset 1628 bit 15 */ + bool unusedBit_542_15 : 1 {}; + /** + offset 1628 bit 16 */ + bool unusedBit_542_16 : 1 {}; + /** + offset 1628 bit 17 */ + bool unusedBit_542_17 : 1 {}; + /** + offset 1628 bit 18 */ + bool unusedBit_542_18 : 1 {}; + /** + offset 1628 bit 19 */ + bool unusedBit_542_19 : 1 {}; + /** + offset 1628 bit 20 */ + bool unusedBit_542_20 : 1 {}; + /** + offset 1628 bit 21 */ + bool unusedBit_542_21 : 1 {}; + /** + offset 1628 bit 22 */ + bool unusedBit_542_22 : 1 {}; + /** + offset 1628 bit 23 */ + bool unusedBit_542_23 : 1 {}; + /** + offset 1628 bit 24 */ + bool unusedBit_542_24 : 1 {}; + /** + offset 1628 bit 25 */ + bool unusedBit_542_25 : 1 {}; + /** + offset 1628 bit 26 */ + bool unusedBit_542_26 : 1 {}; + /** + offset 1628 bit 27 */ + bool unusedBit_542_27 : 1 {}; + /** + offset 1628 bit 28 */ + bool unusedBit_542_28 : 1 {}; + /** + offset 1628 bit 29 */ + bool unusedBit_542_29 : 1 {}; + /** + offset 1628 bit 30 */ + bool unusedBit_542_30 : 1 {}; + /** + offset 1628 bit 31 */ + bool unusedBit_542_31 : 1 {}; + /** + * Time between bench test pulses + ms + * offset 1632 + */ + scaled_channel benchTestOffTime; + /** + * How many test bench pulses do you want + count + * offset 1633 + */ + uint8_t benchTestCount; + /** + * Length of each of the test pulses + ms + * offset 1634 + */ + scaled_channel benchTestOnTime; + /** + * offset 1635 + */ + pin_input_mode_e launchActivatePinMode; + /** + * set_can2_tx_pin X + * offset 1636 + */ + Gpio can2TxPin; + /** + * set_can2_rx_pin X + * offset 1638 + */ + Gpio can2RxPin; + /** + * offset 1640 + */ + pin_output_mode_e starterControlPinMode; + /** + * offset 1641 + */ + adc_channel_e wastegatePositionSensor; + /** + * Override the Y axis (load) value used for the ignition table. + * Advanced users only: If you aren't sure you need this, you probably don't need this. + * offset 1642 + */ + load_override_e ignOverrideMode; + /** + * Select which fuel pressure sensor measures the pressure of the fuel at your injectors. + * offset 1643 + */ + injector_pressure_type_e injectorPressureType; + /** + * offset 1644 + */ + output_pin_e hpfpValvePin; + /** + * offset 1646 + */ + pin_output_mode_e hpfpValvePinMode; + /** + * need 4 byte alignment + units + * offset 1647 + */ + uint8_t alignmentFill_at_1647[1]; + /** + * MAP value above which fuel is cut in case of overboost. + * Set to 0 to disable overboost cut. + kPa (absolute) + * offset 1648 + */ + float boostCutPressure; + /** + kg/h + * offset 1652 + */ + scaled_channel tchargeBins[16]; + /** + ratio + * offset 1668 + */ + scaled_channel tchargeValues[16]; + /** + * Fixed timing, useful for TDC testing + deg + * offset 1684 + */ + float fixedTiming; + /** + * MAP voltage for low point + v + * offset 1688 + */ + float mapLowValueVoltage; + /** + * MAP voltage for low point + v + * offset 1692 + */ + float mapHighValueVoltage; + /** + * EGO value correction + value + * offset 1696 + */ + float egoValueShift; + /** + * VVT output + * TODO: rename to vvtOutputs + * offset 1700 + */ + output_pin_e vvtPins[CAM_INPUTS_COUNT]; + /** + * offset 1708 + */ + spi_device_e cj125SpiDevice; + /** + * offset 1709 + */ + pin_output_mode_e cj125CsPinMode; + /** + * offset 1710 + */ + pin_output_mode_e sdCardCsPinMode; + /** + * need 4 byte alignment + units + * offset 1711 + */ + uint8_t alignmentFill_at_1711[1]; + /** + * This is the IAC position during cranking, some engines start better if given more air during cranking to improve cylinder filling. + percent + * offset 1712 + */ + int crankingIACposition; + /** + * offset 1716 + */ + float tChargeMinRpmMinTps; + /** + * offset 1720 + */ + float tChargeMinRpmMaxTps; + /** + * offset 1724 + */ + float tChargeMaxRpmMinTps; + /** + * offset 1728 + */ + float tChargeMaxRpmMaxTps; + /** + * offset 1732 + */ + pwm_freq_t vvtOutputFrequency[CAMS_PER_BANK]; + /** + * Additional idle % when fan #1 is active + % + * offset 1736 + */ + uint8_t fan1ExtraIdle; + /** + * need 4 byte alignment + units + * offset 1737 + */ + uint8_t alignmentFill_at_1737[3]; + /** + Hz + * offset 1740 + */ + int alternatorPwmFrequency; + /** + * set vvt_mode X + * offset 1744 + */ + vvt_mode_e vvtMode[CAMS_PER_BANK]; + /** + * Additional idle % when fan #2 is active + % + * offset 1746 + */ + uint8_t fan2ExtraIdle; + /** + * Delay to allow fuel pressure to build before firing the priming pulse. + sec + * offset 1747 + */ + scaled_channel primingDelay; + /** + * offset 1748 + */ + adc_channel_e auxAnalogInputs[LUA_ANALOG_INPUT_COUNT]; + /** + * offset 1756 + */ + output_pin_e trailingCoilPins[MAX_CYLINDER_COUNT]; + /** + * offset 1780 + */ + tle8888_mode_e tle8888mode; + /** + * offset 1781 + */ + pin_output_mode_e LIS302DLCsPinMode; + /** + * None = I have a MAP-referenced fuel pressure regulator + * Fixed rail pressure = I have an atmosphere-referenced fuel pressure regulator (returnless, typically) + * Sensed rail pressure = I have a fuel pressure sensor + * offset 1782 + */ + injector_compensation_mode_e injectorCompensationMode; + /** + * offset 1783 + */ + pin_output_mode_e fan2PinMode; + /** + * This is the pressure at which your injector flow is known. + * For example if your injectors flow 400cc/min at 3.5 bar, enter 350kpa here. + kPa + * offset 1784 + */ + float fuelReferencePressure; + /** + * Fuel multiplier (enrichment) immediately after engine start + mult + * offset 1788 + */ + float postCrankingFactor; + /** + * Time over which to taper out after start enrichment + seconds + * offset 1792 + */ + float postCrankingDurationSec; + /** + * offset 1796 + */ + ThermistorConf auxTempSensor1; + /** + * offset 1828 + */ + ThermistorConf auxTempSensor2; + /** + Deg + * offset 1860 + */ + int16_t knockSamplingDuration; + /** + Hz + * offset 1862 + */ + int16_t etbFreq; + /** + * offset 1864 + */ + pid_s etbWastegatePid; + /** + * For micro-stepping, make sure that PWM frequency (etbFreq) is high enough + * offset 1884 + */ + stepper_num_micro_steps_e stepperNumMicroSteps; + /** + * Use to limit the current when the stepper motor is idle, not moving (100% = no limit) + % + * offset 1885 + */ + uint8_t stepperMinDutyCycle; + /** + * Use to limit the max.current through the stepper motor (100% = no limit) + % + * offset 1886 + */ + uint8_t stepperMaxDutyCycle; + /** + * offset 1887 + */ + spi_device_e sdCardSpiDevice; + /** + * per-cylinder timing correction + deg + * offset 1888 + */ + angle_t timing_offset_cylinder[MAX_CYLINDER_COUNT]; + /** + seconds + * offset 1936 + */ + float idlePidActivationTime; + /** + * offset 1940 + */ + pin_mode_e spi1SckMode; + /** + * Modes count be used for 3v<>5v integration using pull-ups/pull-downs etc. + * offset 1941 + */ + pin_mode_e spi1MosiMode; + /** + * offset 1942 + */ + pin_mode_e spi1MisoMode; + /** + * offset 1943 + */ + pin_mode_e spi2SckMode; + /** + * offset 1944 + */ + pin_mode_e spi2MosiMode; + /** + * offset 1945 + */ + pin_mode_e spi2MisoMode; + /** + * offset 1946 + */ + pin_mode_e spi3SckMode; + /** + * offset 1947 + */ + pin_mode_e spi3MosiMode; + /** + * offset 1948 + */ + pin_mode_e spi3MisoMode; + /** + * offset 1949 + */ + pin_output_mode_e stepperEnablePinMode; + /** + * ResetB + * offset 1950 + */ + Gpio mc33816_rstb; + /** + * offset 1952 + */ + Gpio mc33816_driven; + /** + * Brake pedal switch + * offset 1954 + */ + switch_input_pin_e brakePedalPin; + /** + * lambda input + * offset 1956 + */ + adc_channel_e cj125ua; + /** + * heater input + * offset 1957 + */ + adc_channel_e cj125ur; + /** + * offset 1958 + */ + pin_input_mode_e brakePedalPinMode; + /** + * need 4 byte alignment + units + * offset 1959 + */ + uint8_t alignmentFill_at_1959[1]; + /** + * VVT output PID + * TODO: rename to vvtPid + * offset 1960 + */ + pid_s auxPid[CAMS_PER_BANK]; + /** + * offset 2000 + */ + float injectorCorrectionPolynomial[8]; + /** + C + * offset 2032 + */ + int8_t primeBins[8]; + /** + * offset 2040 + */ + linear_sensor_s oilPressure; + /** + * offset 2060 + */ + spi_device_e accelerometerSpiDevice; + /** + * need 4 byte alignment + units + * offset 2061 + */ + uint8_t alignmentFill_at_2061[1]; + /** + * offset 2062 + */ + output_pin_e fan2Pin; + /** + * Cooling fan turn-on temperature threshold, in Celsius + deg C + * offset 2064 + */ + uint8_t fan2OnTemperature; + /** + * Cooling fan turn-off temperature threshold, in Celsius + deg C + * offset 2065 + */ + uint8_t fan2OffTemperature; + /** + * offset 2066 + */ + Gpio stepperEnablePin; + /** + * offset 2068 + */ + Gpio tle8888_cs; + /** + * offset 2070 + */ + pin_output_mode_e tle8888_csPinMode; + /** + * need 4 byte alignment + units + * offset 2071 + */ + uint8_t alignmentFill_at_2071[1]; + /** + * offset 2072 + */ + Gpio mc33816_cs; + /** + * need 4 byte alignment + units + * offset 2074 + */ + uint8_t alignmentFill_at_2074[2]; + /** + * offset 2076 + */ + float auxFrequencyFilter; + /** + RPM + * offset 2080 + */ + int16_t vvtControlMinRpm; + /** + * offset 2082 + */ + brain_input_pin_e sentInputPins[SENT_INPUT_COUNT]; + /** + * offset 2084 + */ + int8_t launchFuelAdderPercent; + /** + * Time required to detect a stuck throttle. + sec + * offset 2085 + */ + scaled_channel etbJamTimeout; + /** + * By the way ETB PID runs at 500hz, length in 1/500 of second here. + * offset 2086 + */ + uint16_t etbExpAverageLength; + /** + * offset 2088 + */ + float etbDutyThreshold; + /** + * This sets the RPM above which fuel cut is active. + rpm + * offset 2092 + */ + int16_t coastingFuelCutRpmHigh; + /** + * This sets the RPM below which fuel cut is deactivated, this prevents jerking or issues transitioning to idle + rpm + * offset 2094 + */ + int16_t coastingFuelCutRpmLow; + /** + * Throttle position below which fuel cut is active. With an electronic throttle enabled, this checks against pedal position. + % + * offset 2096 + */ + int16_t coastingFuelCutTps; + /** + * Fuel cutoff is disabled when the engine is cold. + C + * offset 2098 + */ + int16_t coastingFuelCutClt; + /** + * Increases PID reaction for RPM stoichRatioPrimary; + /** + * iTerm max value + * offset 2510 + */ + int16_t idlerpmpid_iTermMax; + /** + * This sets the range of the idle control on the ETB. At 100% idle position, the value specified here sets the base ETB position. + % + * offset 2512 + */ + float etbIdleThrottleRange; + /** + * Select which fuel correction bank this cylinder belongs to. Group cylinders that share the same O2 sensor + * offset 2516 + */ + uint8_t cylinderBankSelect[MAX_CYLINDER_COUNT]; + /** + mg + * offset 2528 + */ + scaled_channel primeValues[8]; + /** + * Trigger comparator center point voltage + V + * offset 2536 + */ + scaled_channel triggerCompCenterVolt; + /** + * Trigger comparator hysteresis voltage (Min) + V + * offset 2537 + */ + scaled_channel triggerCompHystMin; + /** + * Trigger comparator hysteresis voltage (Max) + V + * offset 2538 + */ + scaled_channel triggerCompHystMax; + /** + * VR-sensor saturation RPM + RPM + * offset 2539 + */ + scaled_channel triggerCompSensorSatRpm; + /** + * offset 2540 + */ + pid_s idleRpmPid2; + /** + * set can_vss X + * offset 2560 + */ + can_vss_nbc_e canVssNbcType; + /** + * need 4 byte alignment + units + * offset 2561 + */ + uint8_t alignmentFill_at_2561[3]; + /** + * offset 2564 + */ + gppwm_channel gppwm[GPPWM_CHANNELS]; + /** + * Boost Current + mA + * offset 2996 + */ + uint16_t mc33_i_boost; + /** + * Peak Current + mA + * offset 2998 + */ + uint16_t mc33_i_peak; + /** + * Hold Current + mA + * offset 3000 + */ + uint16_t mc33_i_hold; + /** + * 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. + us + * offset 3002 + */ + uint16_t mc33_t_max_boost; + /** + us + * offset 3004 + */ + uint16_t mc33_t_peak_off; + /** + * Peak phase duration + us + * offset 3006 + */ + uint16_t mc33_t_peak_tot; + /** + us + * offset 3008 + */ + uint16_t mc33_t_bypass; + /** + us + * offset 3010 + */ + uint16_t mc33_t_hold_off; + /** + * Hold phase duration + us + * offset 3012 + */ + uint16_t mc33_t_hold_tot; + /** + * offset 3014 + */ + pin_input_mode_e tcuUpshiftButtonPinMode; + /** + * offset 3015 + */ + pin_input_mode_e tcuDownshiftButtonPinMode; + /** + * offset 3016 + */ + pin_input_mode_e acSwitchMode; + /** + * offset 3017 + */ + pin_output_mode_e tcu_solenoid_mode[TCU_SOLENOID_COUNT]; + /** + * Knock sensor output knock detection threshold depending on current RPM. + dB + * offset 3023 + */ + scaled_channel knockBaseNoise[ENGINE_NOISE_CURVE_SIZE]; + /** + * need 4 byte alignment + units + * offset 3039 + */ + uint8_t alignmentFill_at_3039[1]; + /** + ratio + * offset 3040 + */ + float triggerGapOverrideFrom[GAP_TRACKING_LENGTH]; + /** + ratio + * offset 3112 + */ + float triggerGapOverrideTo[GAP_TRACKING_LENGTH]; + /** + * 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. + rpm + * offset 3184 + */ + scaled_channel maxCamPhaseResolveRpm; + /** + * Delay before cutting fuel. Set to 0 to cut immediately with no delay. May cause rumbles and pops out of your exhaust... + sec + * offset 3185 + */ + scaled_channel dfcoDelay; + /** + * 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. + sec + * offset 3186 + */ + scaled_channel acDelay; + /** + * need 4 byte alignment + units + * offset 3187 + */ + uint8_t alignmentFill_at_3187[1]; + /** + mg + * offset 3188 + */ + scaled_channel fordInjectorSmallPulseBreakPoint; + /** + multiplier + * offset 3190 + */ + scaled_channel tpsTspCorrValues[TPS_TPS_ACCEL_CLT_CORR_TABLE]; + /** + % + * offset 3194 + */ + uint8_t etbJamIntegratorLimit; + /** + lobes/cam + * offset 3195 + */ + uint8_t hpfpCamLobes; + /** + * offset 3196 + */ + hpfp_cam_e hpfpCam; + /** + * Crank angle ATDC of first lobe peak + deg + * offset 3197 + */ + uint8_t hpfpPeakPos; + /** + * If the requested activation time is below this angle, don't bother running the pump + deg + * offset 3198 + */ + uint8_t hpfpMinAngle; + /** + * need 4 byte alignment + units + * offset 3199 + */ + uint8_t alignmentFill_at_3199[1]; + /** + * Size of the pump chamber in cc. Typical Bosch HDP5 has a 9.0mm diameter, typical BMW N* stroke is 4.4mm. + cc + * offset 3200 + */ + scaled_channel hpfpPumpVolume; + /** + * How long to keep the valve activated (in order to allow the pump to build pressure and keep the valve open on its own) + deg + * offset 3202 + */ + uint8_t hpfpActivationAngle; + /** + * offset 3203 + */ + uint8_t issFilterReciprocal; + /** + %/kPa + * offset 3204 + */ + scaled_channel hpfpPidP; + /** + %/kPa/lobe + * offset 3206 + */ + scaled_channel hpfpPidI; + /** + * 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. + kPa/s + * offset 3208 + */ + uint16_t hpfpTargetDecay; + /** + % + * offset 3210 + */ + scaled_channel hpfpLobeProfileQuantityBins[HPFP_LOBE_PROFILE_SIZE]; + /** + deg + * offset 3226 + */ + scaled_channel hpfpLobeProfileAngle[HPFP_LOBE_PROFILE_SIZE]; + /** + volts + * offset 3242 + */ + uint8_t hpfpDeadtimeVoltsBins[HPFP_DEADTIME_SIZE]; + /** + ms + * offset 3250 + */ + scaled_channel hpfpDeadtimeMS[HPFP_DEADTIME_SIZE]; + /** + kPa + * offset 3266 + */ + uint16_t hpfpTarget[HPFP_TARGET_SIZE][HPFP_TARGET_SIZE]; + /** + load + * offset 3466 + */ + scaled_channel hpfpTargetLoadBins[HPFP_TARGET_SIZE]; + /** + RPM + * offset 3486 + */ + scaled_channel hpfpTargetRpmBins[HPFP_TARGET_SIZE]; + /** + % + * offset 3496 + */ + int8_t hpfpCompensation[HPFP_COMPENSATION_SIZE][HPFP_COMPENSATION_SIZE]; + /** + cc/lobe + * offset 3596 + */ + scaled_channel hpfpCompensationLoadBins[HPFP_COMPENSATION_SIZE]; + /** + RPM + * offset 3616 + */ + scaled_channel hpfpCompensationRpmBins[HPFP_COMPENSATION_SIZE]; + /** + * offset 3626 + */ + output_pin_e stepper_raw_output[4]; + /** + ratio + * offset 3634 + */ + scaled_channel gearRatio[GEARS_COUNT]; + /** + * We need to give engine time to build oil pressure without diverting it to VVT + ms + * offset 3650 + */ + uint16_t vvtActivationDelayMs; + /** + deg C + * offset 3652 + */ + int8_t wwCltBins[WWAE_TABLE_SIZE]; + /** + * offset 3660 + */ + scaled_channel wwTauCltValues[WWAE_TABLE_SIZE]; + /** + * offset 3668 + */ + scaled_channel wwBetaCltValues[WWAE_TABLE_SIZE]; + /** + kPa + * offset 3676 + */ + int8_t wwMapBins[WWAE_TABLE_SIZE]; + /** + * offset 3684 + */ + scaled_channel wwTauMapValues[WWAE_TABLE_SIZE]; + /** + * offset 3692 + */ + scaled_channel wwBetaMapValues[WWAE_TABLE_SIZE]; + /** + Nm + * offset 3700 + */ + scaled_channel torqueTable[TORQUE_CURVE_SIZE][TORQUE_CURVE_SIZE]; + /** + RPM + * offset 3736 + */ + uint16_t torqueRpmBins[TORQUE_CURVE_SIZE]; + /** + Load + * offset 3748 + */ + uint16_t torqueLoadBins[TORQUE_CURVE_SIZE]; + /** + * offset 3760 + */ + GearControllerMode gearControllerMode; + /** + * offset 3761 + */ + TransmissionControllerMode transmissionControllerMode; + /** + * need 4 byte alignment + units + * offset 3762 + */ + uint8_t alignmentFill_at_3762[2]; + /** + * offset 3764 + */ + linear_sensor_s auxLinear1; + /** + * offset 3784 + */ + linear_sensor_s auxLinear2; + /** + * offset 3804 + */ + output_pin_e tcu_tcc_onoff_solenoid; + /** + * offset 3806 + */ + pin_output_mode_e tcu_tcc_onoff_solenoid_mode; + /** + * need 4 byte alignment + units + * offset 3807 + */ + uint8_t alignmentFill_at_3807[1]; + /** + * offset 3808 + */ + output_pin_e tcu_tcc_pwm_solenoid; + /** + * offset 3810 + */ + pin_output_mode_e tcu_tcc_pwm_solenoid_mode; + /** + * need 4 byte alignment + units + * offset 3811 + */ + uint8_t alignmentFill_at_3811[1]; + /** + * offset 3812 + */ + pwm_freq_t tcu_tcc_pwm_solenoid_freq; + /** + * offset 3814 + */ + output_pin_e tcu_pc_solenoid_pin; + /** + * offset 3816 + */ + pin_output_mode_e tcu_pc_solenoid_pin_mode; + /** + * need 4 byte alignment + units + * offset 3817 + */ + uint8_t alignmentFill_at_3817[1]; + /** + * offset 3818 + */ + pwm_freq_t tcu_pc_solenoid_freq; + /** + * offset 3820 + */ + output_pin_e tcu_32_solenoid_pin; + /** + * offset 3822 + */ + pin_output_mode_e tcu_32_solenoid_pin_mode; + /** + * need 4 byte alignment + units + * offset 3823 + */ + uint8_t alignmentFill_at_3823[1]; + /** + * offset 3824 + */ + pwm_freq_t tcu_32_solenoid_freq; + /** + * need 4 byte alignment + units + * offset 3826 + */ + uint8_t alignmentFill_at_3826[2]; + /** + % + * offset 3828 + */ + float etbMinimumPosition; + /** + * offset 3832 + */ + uint16_t tuneHidingKey; + /** + * offset 3834 + */ + vin_number_t vinNumber; + /** + * need 4 byte alignment + units + * offset 3851 + */ + uint8_t alignmentFill_at_3851[1]; + /** + * offset 3852 + */ + uint16_t highSpeedOffsets[HIGH_SPEED_COUNT]; + /** + * offset 3916 + */ + float etbDutyShutdownThreshold; + /** + * offset 3920 + */ + Gpio luaDigitalInputPins[LUA_DIGITAL_INPUT_COUNT]; + /** + RPM + * offset 3936 + */ + scaled_channel tpsTspCorrValuesBins[TPS_TPS_ACCEL_CLT_CORR_TABLE]; + /** + rpm + * offset 3940 + */ + int16_t ALSMinRPM; + /** + rpm + * offset 3942 + */ + int16_t ALSMaxRPM; + /** + sec + * offset 3944 + */ + int16_t ALSMaxDuration; + /** + C + * offset 3946 + */ + int8_t ALSMinCLT; + /** + C + * offset 3947 + */ + int8_t ALSMaxCLT; + /** + * offset 3948 + */ + uint8_t alsMinTimeBetween; + /** + * offset 3949 + */ + uint8_t alsEtbPosition; + /** + * offset 3950 + */ + uint8_t acRelayAlternatorDutyAdder; + /** + deg + * offset 3951 + */ + uint8_t instantRpmRange; + /** + * offset 3952 + */ + uint8_t unusedA11lignmentFill_at_33; + /** + * offset 3953 + */ + SentEtbType sentEtbType; + /** + * need 4 byte alignment + units + * offset 3954 + */ + uint8_t alignmentFill_at_3954[2]; + /** + % + * offset 3956 + */ + int ALSIdleAdd; + /** + % + * offset 3960 + */ + int ALSEtbAdd; + /** + * offset 3964 + */ + int ALSSkipRatio; + /** + % + * offset 3968 + */ + uint8_t ALSMaxDriverThrottleIntent; + /** + * offset 3969 + */ + pin_input_mode_e ALSActivatePinMode; + /** + * For Ford TPS, use 53%. For Toyota ETCS-i, use ~65% + % + * offset 3970 + */ + scaled_channel tpsSecondaryMaximum; + /** + * For Toyota ETCS-i, use ~69% + % + * offset 3971 + */ + scaled_channel ppsSecondaryMaximum; + /** + * offset 3972 + */ + pin_input_mode_e luaDigitalInputPinModes[LUA_DIGITAL_INPUT_COUNT]; + /** + units + * offset 3980 + */ + uint8_t mainUnusedEnd[96]; +}; +static_assert(sizeof(engine_configuration_s) == 4076); + +// start of cyl_trim_s +struct cyl_trim_s { + /** + * offset 0 + */ + scaled_channel table[TRIM_SIZE][TRIM_SIZE]; +}; +static_assert(sizeof(cyl_trim_s) == 16); + +// start of blend_table_s +struct blend_table_s { + /** + * offset 0 + */ + scaled_channel table[8][8]; + /** + Load + * offset 128 + */ + uint16_t loadBins[8]; + /** + RPM + * offset 144 + */ + uint16_t rpmBins[8]; + /** + * offset 160 + */ + gppwm_channel_e blendParameter; + /** + * need 4 byte alignment + units + * offset 161 + */ + uint8_t alignmentFill_at_161[1]; + /** + * offset 162 + */ + scaled_channel blendBins[8]; + /** + % + * offset 178 + */ + scaled_channel blendValues[8]; + /** + * need 4 byte alignment + units + * offset 186 + */ + uint8_t alignmentFill_at_186[2]; +}; +static_assert(sizeof(blend_table_s) == 188); + +// start of persistent_config_s +struct persistent_config_s { + /** + * offset 0 + */ + engine_configuration_s engineConfiguration; + /** + * target TPS value, 0 to 100% + * TODO: use int8 data date once we template interpolation method + target TPS position + * offset 4076 + */ + float etbBiasBins[ETB_BIAS_CURVE_LENGTH]; + /** + * PWM bias, 0 to 100% + ETB duty cycle bias + * offset 4108 + */ + float etbBiasValues[ETB_BIAS_CURVE_LENGTH]; + /** + % + * offset 4140 + */ + scaled_channel iacPidMultTable[IAC_PID_MULT_SIZE][IAC_PID_MULT_SIZE]; + /** + Load + * offset 4204 + */ + uint8_t iacPidMultLoadBins[IAC_PID_MULT_SIZE]; + /** + RPM + * offset 4212 + */ + scaled_channel iacPidMultRpmBins[IAC_PID_MULT_SIZE]; + /** + * On Single Coil or Wasted Spark setups you have to lower dwell at high RPM + RPM + * offset 4220 + */ + uint16_t sparkDwellRpmBins[DWELL_CURVE_SIZE]; + /** + ms + * offset 4236 + */ + scaled_channel sparkDwellValues[DWELL_CURVE_SIZE]; + /** + * CLT-based target RPM for automatic idle controller + C + * offset 4252 + */ + scaled_channel cltIdleRpmBins[CLT_CURVE_SIZE]; + /** + * See idleRpmPid + RPM + * offset 4268 + */ + scaled_channel cltIdleRpm[CLT_CURVE_SIZE]; + /** + * CLT-based timing correction + C + * offset 4284 + */ + float cltTimingBins[CLT_TIMING_CURVE_SIZE]; + /** + degree + * offset 4316 + */ + float cltTimingExtra[CLT_TIMING_CURVE_SIZE]; + /** + x + * offset 4348 + */ + float scriptCurve1Bins[SCRIPT_CURVE_16]; + /** + y + * offset 4412 + */ + float scriptCurve1[SCRIPT_CURVE_16]; + /** + x + * offset 4476 + */ + float scriptCurve2Bins[SCRIPT_CURVE_16]; + /** + y + * offset 4540 + */ + float scriptCurve2[SCRIPT_CURVE_16]; + /** + x + * offset 4604 + */ + float scriptCurve3Bins[SCRIPT_CURVE_8]; + /** + y + * offset 4636 + */ + float scriptCurve3[SCRIPT_CURVE_8]; + /** + x + * offset 4668 + */ + float scriptCurve4Bins[SCRIPT_CURVE_8]; + /** + y + * offset 4700 + */ + float scriptCurve4[SCRIPT_CURVE_8]; + /** + x + * offset 4732 + */ + float scriptCurve5Bins[SCRIPT_CURVE_8]; + /** + y + * offset 4764 + */ + float scriptCurve5[SCRIPT_CURVE_8]; + /** + x + * offset 4796 + */ + float scriptCurve6Bins[SCRIPT_CURVE_8]; + /** + y + * offset 4828 + */ + float scriptCurve6[SCRIPT_CURVE_8]; + /** + kPa + * offset 4860 + */ + float baroCorrPressureBins[BARO_CORR_SIZE]; + /** + RPM + * offset 4876 + */ + float baroCorrRpmBins[BARO_CORR_SIZE]; + /** + ratio + * offset 4892 + */ + float baroCorrTable[BARO_CORR_SIZE][BARO_CORR_SIZE]; + /** + * Cranking fuel correction coefficient based on TPS + Ratio + * offset 4956 + */ + float crankingTpsCoef[CRANKING_CURVE_SIZE]; + /** + % + * offset 4988 + */ + float crankingTpsBins[CRANKING_CURVE_SIZE]; + /** + * Narrow Band WBO Approximation + V + * offset 5020 + */ + float narrowToWideOxygenBins[NARROW_BAND_WIDE_BAND_CONVERSION_SIZE]; + /** + ratio + * offset 5052 + */ + float narrowToWideOxygen[NARROW_BAND_WIDE_BAND_CONVERSION_SIZE]; + /** + * Optional timing advance table for Cranking (see useSeparateAdvanceForCranking) + RPM + * offset 5084 + */ + uint16_t crankingAdvanceBins[CRANKING_ADVANCE_CURVE_SIZE]; + /** + * Optional timing advance table for Cranking (see useSeparateAdvanceForCranking) + deg + * offset 5092 + */ + scaled_channel crankingAdvance[CRANKING_ADVANCE_CURVE_SIZE]; + /** + * RPM-based idle position for coasting + RPM + * offset 5100 + */ + scaled_channel iacCoastingRpmBins[CLT_CURVE_SIZE]; + /** + * RPM-based idle position for coasting + % + * offset 5116 + */ + scaled_channel iacCoasting[CLT_CURVE_SIZE]; + /** + * offset 5132 + */ + error_message_t warning_message; + /** + C + * offset 5252 + */ + float afterstartCoolantBins[AFTERSTART_HOLD_CURVE_SIZE]; + /** + Seconds + * offset 5284 + */ + float afterstartHoldTime[AFTERSTART_HOLD_CURVE_SIZE]; + /** + % + * offset 5316 + */ + float afterstartEnrich[AFTERSTART_ENRICH_CURVE_SIZE]; + /** + Seconds + * offset 5348 + */ + float afterstartDecayTime[AFTERSTART_DECAY_CURVE_SIZE]; + /** + * offset 5380 + */ + scaled_channel boostTableOpenLoop[BOOST_RPM_COUNT][BOOST_LOAD_COUNT]; + /** + RPM + * offset 5444 + */ + scaled_channel boostRpmBins[BOOST_RPM_COUNT]; + /** + * offset 5452 + */ + scaled_channel boostTableClosedLoop[BOOST_RPM_COUNT][BOOST_LOAD_COUNT]; + /** + % + * offset 5516 + */ + uint8_t boostTpsBins[BOOST_LOAD_COUNT]; + /** + % + * offset 5524 + */ + uint8_t pedalToTpsTable[PEDAL_TO_TPS_SIZE][PEDAL_TO_TPS_SIZE]; + /** + % + * offset 5588 + */ + uint8_t pedalToTpsPedalBins[PEDAL_TO_TPS_SIZE]; + /** + RPM + * offset 5596 + */ + scaled_channel pedalToTpsRpmBins[PEDAL_TO_TPS_SIZE]; + /** + * CLT-based cranking position multiplier for simple manual idle controller + C + * offset 5604 + */ + float cltCrankingCorrBins[CLT_CRANKING_CURVE_SIZE]; + /** + * CLT-based cranking position multiplier for simple manual idle controller + % + * offset 5636 + */ + float cltCrankingCorr[CLT_CRANKING_CURVE_SIZE]; + /** + * Optional timing advance table for Idle (see useSeparateAdvanceForIdle) + RPM + * offset 5668 + */ + scaled_channel idleAdvanceBins[IDLE_ADVANCE_CURVE_SIZE]; + /** + * Optional timing advance table for Idle (see useSeparateAdvanceForIdle) + deg + * offset 5676 + */ + float idleAdvance[IDLE_ADVANCE_CURVE_SIZE]; + /** + RPM + * offset 5708 + */ + scaled_channel idleVeRpmBins[IDLE_VE_SIZE]; + /** + load + * offset 5712 + */ + uint8_t idleVeLoadBins[IDLE_VE_SIZE]; + /** + % + * offset 5716 + */ + scaled_channel idleVeTable[IDLE_VE_SIZE][IDLE_VE_SIZE]; + /** + * offset 5748 + */ + lua_script_t luaScript; + /** + C + * offset 13748 + */ + float cltFuelCorrBins[CLT_CURVE_SIZE]; + /** + ratio + * offset 13812 + */ + float cltFuelCorr[CLT_CURVE_SIZE]; + /** + C + * offset 13876 + */ + float iatFuelCorrBins[IAT_CURVE_SIZE]; + /** + ratio + * offset 13940 + */ + float iatFuelCorr[IAT_CURVE_SIZE]; + /** + ratio + * offset 14004 + */ + float crankingFuelCoef[CRANKING_CURVE_SIZE]; + /** + C + * offset 14036 + */ + float crankingFuelBins[CRANKING_CURVE_SIZE]; + /** + ratio + * offset 14068 + */ + float crankingCycleCoef[CRANKING_CURVE_SIZE]; + /** + counter + * offset 14100 + */ + float crankingCycleBins[CRANKING_CURVE_SIZE]; + /** + * CLT-based idle position multiplier for simple manual idle controller + C + * offset 14132 + */ + float cltIdleCorrBins[CLT_CURVE_SIZE]; + /** + * CLT-based idle position multiplier for simple manual idle controller + ratio + * offset 14196 + */ + float cltIdleCorr[CLT_CURVE_SIZE]; + /** + * Also known as MAF transfer function. + * kg/hour value. + * By the way 2.081989116 kg/h = 1 ft3/m + kg/hour + * offset 14260 + */ + float mafDecoding[MAF_DECODING_COUNT]; + /** + V + * offset 15284 + */ + float mafDecodingBins[MAF_DECODING_COUNT]; + /** + deg + * offset 16308 + */ + scaled_channel ignitionIatCorrTable[8][8]; + /** + C + * offset 16372 + */ + int8_t ignitionIatCorrTempBins[8]; + /** + Load + * offset 16380 + */ + scaled_channel ignitionIatCorrLoadBins[8]; + /** + deg + * offset 16388 + */ + int16_t injectionPhase[IGN_RPM_COUNT][IGN_LOAD_COUNT]; + /** + Load + * offset 16900 + */ + uint16_t injPhaseLoadBins[FUEL_LOAD_COUNT]; + /** + RPM + * offset 16932 + */ + uint16_t injPhaseRpmBins[FUEL_RPM_COUNT]; + /** + onoff + * offset 16964 + */ + uint8_t tcuSolenoidTable[TCU_SOLENOID_COUNT][TCU_GEAR_COUNT]; + /** + kPa + * offset 17024 + */ + scaled_channel mapEstimateTable[FUEL_RPM_COUNT][FUEL_LOAD_COUNT]; + /** + % TPS + * offset 17536 + */ + scaled_channel mapEstimateTpsBins[FUEL_LOAD_COUNT]; + /** + RPM + * offset 17568 + */ + uint16_t mapEstimateRpmBins[FUEL_RPM_COUNT]; + /** + value + * offset 17600 + */ + int8_t vvtTable1[SCRIPT_TABLE_8][SCRIPT_TABLE_8]; + /** + L + * offset 17664 + */ + uint16_t vvtTable1LoadBins[SCRIPT_TABLE_8]; + /** + RPM + * offset 17680 + */ + uint16_t vvtTable1RpmBins[SCRIPT_TABLE_8]; + /** + value + * offset 17696 + */ + int8_t vvtTable2[SCRIPT_TABLE_8][SCRIPT_TABLE_8]; + /** + L + * offset 17760 + */ + uint16_t vvtTable2LoadBins[SCRIPT_TABLE_8]; + /** + RPM + * offset 17776 + */ + uint16_t vvtTable2RpmBins[SCRIPT_TABLE_8]; + /** + deg + * offset 17792 + */ + scaled_channel ignitionTable[IGN_RPM_COUNT][IGN_LOAD_COUNT]; + /** + Load + * offset 18304 + */ + uint16_t ignitionLoadBins[IGN_LOAD_COUNT]; + /** + RPM + * offset 18336 + */ + uint16_t ignitionRpmBins[IGN_RPM_COUNT]; + /** + % + * offset 18368 + */ + scaled_channel veTable[FUEL_RPM_COUNT][FUEL_LOAD_COUNT]; + /** + kPa + * offset 18880 + */ + uint16_t veLoadBins[FUEL_LOAD_COUNT]; + /** + RPM + * offset 18912 + */ + uint16_t veRpmBins[FUEL_RPM_COUNT]; + /** + lambda + * offset 18944 + */ + scaled_channel lambdaTable[FUEL_RPM_COUNT][FUEL_LOAD_COUNT]; + /** + * offset 19200 + */ + uint16_t lambdaLoadBins[FUEL_LOAD_COUNT]; + /** + RPM + * offset 19232 + */ + uint16_t lambdaRpmBins[FUEL_RPM_COUNT]; + /** + value + * offset 19264 + */ + float tpsTpsAccelTable[TPS_TPS_ACCEL_TABLE][TPS_TPS_ACCEL_TABLE]; + /** + from + * offset 19520 + */ + float tpsTpsAccelFromRpmBins[TPS_TPS_ACCEL_TABLE]; + /** + to + * offset 19552 + */ + float tpsTpsAccelToRpmBins[TPS_TPS_ACCEL_TABLE]; + /** + value + * offset 19584 + */ + float scriptTable1[SCRIPT_TABLE_8][SCRIPT_TABLE_8]; + /** + L + * offset 19840 + */ + int16_t scriptTable1LoadBins[SCRIPT_TABLE_8]; + /** + RPM + * offset 19856 + */ + int16_t scriptTable1RpmBins[SCRIPT_TABLE_8]; + /** + value + * offset 19872 + */ + uint8_t scriptTable2[SCRIPT_TABLE_8][SCRIPT_TABLE_8]; + /** + L + * offset 19936 + */ + int16_t scriptTable2LoadBins[SCRIPT_TABLE_8]; + /** + RPM + * offset 19952 + */ + int16_t scriptTable2RpmBins[SCRIPT_TABLE_8]; + /** + value + * offset 19968 + */ + uint8_t scriptTable3[SCRIPT_TABLE_8][SCRIPT_TABLE_8]; + /** + L + * offset 20032 + */ + int16_t scriptTable3LoadBins[SCRIPT_TABLE_8]; + /** + RPM + * offset 20048 + */ + int16_t scriptTable3RpmBins[SCRIPT_TABLE_8]; + /** + value + * offset 20064 + */ + uint8_t scriptTable4[SCRIPT_TABLE_8][SCRIPT_TABLE_8]; + /** + L + * offset 20128 + */ + int16_t scriptTable4LoadBins[SCRIPT_TABLE_8]; + /** + RPM + * offset 20144 + */ + int16_t scriptTable4RpmBins[SCRIPT_TABLE_8]; + /** + * offset 20160 + */ + uint16_t ignTrimLoadBins[TRIM_SIZE]; + /** + rpm + * offset 20168 + */ + uint16_t ignTrimRpmBins[TRIM_SIZE]; + /** + * offset 20176 + */ + cyl_trim_s ignTrims[12]; + /** + * offset 20368 + */ + uint16_t fuelTrimLoadBins[TRIM_SIZE]; + /** + rpm + * offset 20376 + */ + uint16_t fuelTrimRpmBins[TRIM_SIZE]; + /** + * offset 20384 + */ + cyl_trim_s fuelTrims[12]; + /** + ratio + * offset 20576 + */ + scaled_channel crankingFuelCoefE100[CRANKING_CURVE_SIZE]; + /** + Airmass + * offset 20592 + */ + scaled_channel tcu_pcAirmassBins[TCU_MAGIC_SIZE]; + /** + % + * offset 20600 + */ + uint8_t tcu_pcValsR[TCU_MAGIC_SIZE]; + /** + % + * offset 20608 + */ + uint8_t tcu_pcValsN[TCU_MAGIC_SIZE]; + /** + % + * offset 20616 + */ + uint8_t tcu_pcVals1[TCU_MAGIC_SIZE]; + /** + % + * offset 20624 + */ + uint8_t tcu_pcVals2[TCU_MAGIC_SIZE]; + /** + % + * offset 20632 + */ + uint8_t tcu_pcVals3[TCU_MAGIC_SIZE]; + /** + % + * offset 20640 + */ + uint8_t tcu_pcVals4[TCU_MAGIC_SIZE]; + /** + % + * offset 20648 + */ + uint8_t tcu_pcVals12[TCU_MAGIC_SIZE]; + /** + % + * offset 20656 + */ + uint8_t tcu_pcVals23[TCU_MAGIC_SIZE]; + /** + % + * offset 20664 + */ + uint8_t tcu_pcVals34[TCU_MAGIC_SIZE]; + /** + % + * offset 20672 + */ + uint8_t tcu_pcVals21[TCU_MAGIC_SIZE]; + /** + % + * offset 20680 + */ + uint8_t tcu_pcVals32[TCU_MAGIC_SIZE]; + /** + % + * offset 20688 + */ + uint8_t tcu_pcVals43[TCU_MAGIC_SIZE]; + /** + TPS + * offset 20696 + */ + uint8_t tcu_tccTpsBins[8]; + /** + MPH + * offset 20704 + */ + uint8_t tcu_tccLockSpeed[8]; + /** + MPH + * offset 20712 + */ + uint8_t tcu_tccUnlockSpeed[8]; + /** + KPH + * offset 20720 + */ + uint8_t tcu_32SpeedBins[8]; + /** + % + * offset 20728 + */ + uint8_t tcu_32Vals[8]; + /** + % + * offset 20736 + */ + scaled_channel throttle2TrimTable[6][6]; + /** + % + * offset 20772 + */ + uint8_t throttle2TrimTpsBins[6]; + /** + RPM + * offset 20778 + */ + scaled_channel throttle2TrimRpmBins[6]; + /** + deg + * offset 20784 + */ + scaled_channel maxKnockRetardTable[6][6]; + /** + % + * offset 20820 + */ + uint8_t maxKnockRetardLoadBins[6]; + /** + RPM + * offset 20826 + */ + scaled_channel maxKnockRetardRpmBins[6]; + /** + deg + * offset 20832 + */ + scaled_channel ALSTimingRetardTable[4][4]; + /** + TPS + * offset 20864 + */ + uint16_t alsIgnRetardLoadBins[4]; + /** + RPM + * offset 20872 + */ + uint16_t alsIgnRetardrpmBins[4]; + /** + percent + * offset 20880 + */ + scaled_channel ALSFuelAdjustment[4][4]; + /** + TPS + * offset 20912 + */ + uint16_t alsFuelAdjustmentLoadBins[4]; + /** + RPM + * offset 20920 + */ + uint16_t alsFuelAdjustmentrpmBins[4]; + /** + * offset 20928 + */ + blend_table_s ignBlends[IGN_BLEND_COUNT]; + /** + * offset 21680 + */ + blend_table_s veBlends[VE_BLEND_COUNT]; +}; +static_assert(sizeof(persistent_config_s) == 22432); + +// end +// this section was generated automatically by rusEFI tool ConfigDefinition.jar based on gen_config.sh integration/rusefi_config.txt Mon Feb 20 21:09:11 PST 2023 diff --git a/firmware/controllers/generated/rusefi_generated.h b/firmware/controllers/generated/rusefi_generated.h new file mode 100644 index 0000000000..9e09557ce8 --- /dev/null +++ b/firmware/controllers/generated/rusefi_generated.h @@ -0,0 +1,1398 @@ +// +// was generated automatically by rusEFI tool ConfigDefinition.jar based on gen_config.sh integration/rusefi_config.txt +// + +#define adc_channel_e_auto_enum 0="EFI_ADC_NONE",1="EFI_ADC_0",2="EFI_ADC_1",11="EFI_ADC_10",12="EFI_ADC_11",13="EFI_ADC_12",14="EFI_ADC_13",15="EFI_ADC_14",16="EFI_ADC_15",17="EFI_ADC_16",18="EFI_ADC_17",19="EFI_ADC_18",20="EFI_ADC_19",3="EFI_ADC_2",21="EFI_ADC_20",22="EFI_ADC_21",23="EFI_ADC_22",24="EFI_ADC_23",25="EFI_ADC_24",26="EFI_ADC_25",27="EFI_ADC_26",28="EFI_ADC_27",29="EFI_ADC_28",30="EFI_ADC_29",4="EFI_ADC_3",31="EFI_ADC_30",32="EFI_ADC_31",5="EFI_ADC_4",6="EFI_ADC_5",7="EFI_ADC_6",8="EFI_ADC_7",9="EFI_ADC_8",10="EFI_ADC_9",50="EFI_ADC_ERROR",33="EFI_ADC_LAST_CHANNEL" +#define adc_channel_e_EFI_ADC_0 1 +#define adc_channel_e_EFI_ADC_1 2 +#define adc_channel_e_EFI_ADC_10 11 +#define adc_channel_e_EFI_ADC_11 12 +#define adc_channel_e_EFI_ADC_12 13 +#define adc_channel_e_EFI_ADC_13 14 +#define adc_channel_e_EFI_ADC_14 15 +#define adc_channel_e_EFI_ADC_15 16 +#define adc_channel_e_EFI_ADC_16 17 +#define adc_channel_e_EFI_ADC_17 18 +#define adc_channel_e_EFI_ADC_18 19 +#define adc_channel_e_EFI_ADC_19 20 +#define adc_channel_e_EFI_ADC_2 3 +#define adc_channel_e_EFI_ADC_20 21 +#define adc_channel_e_EFI_ADC_21 22 +#define adc_channel_e_EFI_ADC_22 23 +#define adc_channel_e_EFI_ADC_23 24 +#define adc_channel_e_EFI_ADC_24 25 +#define adc_channel_e_EFI_ADC_25 26 +#define adc_channel_e_EFI_ADC_26 27 +#define adc_channel_e_EFI_ADC_27 28 +#define adc_channel_e_EFI_ADC_28 29 +#define adc_channel_e_EFI_ADC_29 30 +#define adc_channel_e_EFI_ADC_3 4 +#define adc_channel_e_EFI_ADC_30 31 +#define adc_channel_e_EFI_ADC_31 32 +#define adc_channel_e_EFI_ADC_4 5 +#define adc_channel_e_EFI_ADC_5 6 +#define adc_channel_e_EFI_ADC_6 7 +#define adc_channel_e_EFI_ADC_7 8 +#define adc_channel_e_EFI_ADC_8 9 +#define adc_channel_e_EFI_ADC_9 10 +#define adc_channel_e_EFI_ADC_ERROR 50 +#define adc_channel_e_EFI_ADC_LAST_CHANNEL 33 +#define adc_channel_e_EFI_ADC_NONE 0 +#define adc_channel_e_enum "Disabled", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PB0", "PB1", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5" +#define ADC_CHANNEL_NONE 0 +#define afr_sensor_s_size 20 +#define AFTERSTART_DECAY_CURVE_SIZE 8 +#define AFTERSTART_ENRICH_CURVE_SIZE 8 +#define AFTERSTART_HOLD_CURVE_SIZE 8 +#define air_pressure_sensor_config_s_size 12 +#define air_pressure_sensor_type_e_auto_enum 0="MT_CUSTOM",10="MT_BOSCH_2_5",1="MT_DENSO183",4="MT_DODGE_NEON_2003",13="MT_GM_1_BAR",12="MT_GM_2_BAR",6="MT_GM_3_BAR",3="MT_HONDA3BAR",11="MT_MAZDA_1_BAR",7="MT_MPX4100",2="MT_MPX4250",9="MT_MPX4250A",14="MT_MPXH6400",5="MT_SUBY_DENSO",8="MT_TOYOTA_89420_02010" +#define air_pressure_sensor_type_e_MT_BOSCH_2_5 10 +#define air_pressure_sensor_type_e_MT_CUSTOM 0 +#define air_pressure_sensor_type_e_MT_DENSO183 1 +#define air_pressure_sensor_type_e_MT_DODGE_NEON_2003 4 +#define air_pressure_sensor_type_e_MT_GM_1_BAR 13 +#define air_pressure_sensor_type_e_MT_GM_2_BAR 12 +#define air_pressure_sensor_type_e_MT_GM_3_BAR 6 +#define air_pressure_sensor_type_e_MT_HONDA3BAR 3 +#define air_pressure_sensor_type_e_MT_MAZDA_1_BAR 11 +#define air_pressure_sensor_type_e_MT_MPX4100 7 +#define air_pressure_sensor_type_e_MT_MPX4250 2 +#define air_pressure_sensor_type_e_MT_MPX4250A 9 +#define air_pressure_sensor_type_e_MT_MPXH6400 14 +#define air_pressure_sensor_type_e_MT_SUBY_DENSO 5 +#define air_pressure_sensor_type_e_MT_TOYOTA_89420_02010 8 +#define antiLagActivationMode_e_ALWAYS_ON_ANTILAG 1 +#define antiLagActivationMode_e_auto_enum 0="SWITCH_INPUT_ANTILAG",1="ALWAYS_ON_ANTILAG" +#define antiLagActivationMode_e_enum "Switch Input", "Always Active" +#define antiLagActivationMode_e_SWITCH_INPUT_ANTILAG 0 +#define AUX_DIGITAL_VALVE_COUNT 2 +#define BANKS_COUNT 2 +#define BARO_CORR_SIZE 4 +#define bench_mode_e_BENCH_AC_COMPRESSOR_RELAY 6 +#define bench_mode_e_BENCH_CHECK_ENGINE_LIGHT 7 +#define bench_mode_e_BENCH_FAN_RELAY 4 +#define bench_mode_e_BENCH_FAN_RELAY_2 5 +#define bench_mode_e_BENCH_FUEL_PUMP 1 +#define bench_mode_e_BENCH_GPPWM1_VALVE 10 +#define bench_mode_e_BENCH_GPPWM2_VALVE 11 +#define bench_mode_e_BENCH_GPPWM3_VALVE 12 +#define bench_mode_e_BENCH_GPPWM4_VALVE 13 +#define bench_mode_e_BENCH_HPFP_VALVE 9 +#define bench_mode_e_BENCH_IDLE_VALVE 8 +#define bench_mode_e_BENCH_MAIN_RELAY 0 +#define bench_mode_e_BENCH_SECOND_IDLE_VALVE 14 +#define bench_mode_e_BENCH_STARTER_DISABLE_RELAY 3 +#define bench_mode_e_BENCH_STARTER_ENABLE_RELAY 2 +#define blend_table_s_size 188 +#define BLOCKING_FACTOR 750 +#define BOOST_LOAD_COUNT 8 +#define BOOST_RPM_COUNT 8 +#define boostType_e_auto_enum 0="OPEN_LOOP",1="CLOSED_LOOP" +#define boostType_e_CLOSED_LOOP 1 +#define boostType_e_OPEN_LOOP 0 +#define brain_input_pin_e_enum "NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15" +#define brain_pin_diag_e_PIN_DRIVER_OFF 0x20 +#define brain_pin_diag_e_PIN_DRIVER_OVERTEMP 0x10 +#define brain_pin_diag_e_PIN_INVALID 0x80 +#define brain_pin_diag_e_PIN_OK 0 +#define brain_pin_diag_e_PIN_OPEN 0x01 +#define brain_pin_diag_e_PIN_OVERLOAD 0x08 +#define brain_pin_diag_e_PIN_SHORT_TO_BAT 0x04 +#define brain_pin_diag_e_PIN_SHORT_TO_GND 0x02 +#define CAM_INPUTS_COUNT 4 +#define CAMS_PER_BANK 2 +#define can_baudrate_e_auto_enum 0="B50KBPS",2="B100KBPS",3="B125KBPS",6="B1MBPS",4="B250KBPS",5="B500KBPS",1="B83KBPS" +#define can_baudrate_e_B100KBPS 2 +#define can_baudrate_e_B125KBPS 3 +#define can_baudrate_e_B1MBPS 6 +#define can_baudrate_e_B250KBPS 4 +#define can_baudrate_e_B500KBPS 5 +#define can_baudrate_e_B50KBPS 0 +#define can_baudrate_e_B83KBPS 1 +#define can_baudrate_e_enum "50kbps", "83.33kbps", "100kbps", "125kbps", "250kbps", "500kbps", "1Mbps" +#define CAN_DEFAULT_BASE 0x200 +#define CAN_ECU_HW_META 0xAB1234 +#define CAN_ECU_SERIAL_RX_ID 0x100 +#define CAN_ECU_SERIAL_TX_ID 0x102 +#define can_nbc_e_auto_enum 0="CAN_BUS_NBC_NONE",12="CAN_AIM_DASH",6="CAN_BUS_BMW_E90",10="CAN_BUS_GENESIS_COUPE",11="CAN_BUS_HONDA_K",7="CAN_BUS_Haltech",3="CAN_BUS_MAZDA_RX8",8="CAN_BUS_MQB",4="CAN_BUS_NBC_BMW",1="CAN_BUS_NBC_FIAT",2="CAN_BUS_NBC_VAG",9="CAN_BUS_NISSAN_VQ",5="CAN_BUS_W202_C180" +#define can_nbc_e_CAN_AIM_DASH 12 +#define can_nbc_e_CAN_BUS_BMW_E90 6 +#define can_nbc_e_CAN_BUS_GENESIS_COUPE 10 +#define can_nbc_e_CAN_BUS_Haltech 7 +#define can_nbc_e_CAN_BUS_HONDA_K 11 +#define can_nbc_e_CAN_BUS_MAZDA_RX8 3 +#define can_nbc_e_CAN_BUS_MQB 8 +#define can_nbc_e_CAN_BUS_NBC_BMW 4 +#define can_nbc_e_CAN_BUS_NBC_FIAT 1 +#define can_nbc_e_CAN_BUS_NBC_NONE 0 +#define can_nbc_e_CAN_BUS_NBC_VAG 2 +#define can_nbc_e_CAN_BUS_NISSAN_VQ 9 +#define can_nbc_e_CAN_BUS_W202_C180 5 +#define CAN_RX_PREFIX "CAN_rx" +#define can_vss_nbc_e_auto_enum 0="BMW_e46",1="W202" +#define can_vss_nbc_e_BMW_e46 0 +#define can_vss_nbc_e_W202 1 +#define CLT_CRANKING_CURVE_SIZE 8 +#define CLT_CURVE_SIZE 16 +#define CLT_LIMITER_CURVE_SIZE 4 +#define CLT_TIMING_CURVE_SIZE 8 +#define CMD_AC_RELAY_BENCH "acrelaybench" +#define CMD_ALTERNATOR_PIN "set_alternator_pin" +#define CMD_BOOST_PIN "set_boost_pin" +#define CMD_BURNCONFIG "burnconfig" +#define CMD_DATE "date" +#define CMD_DISABLE "disable" +#define CMD_ECU_UNLOCK "unlock" +#define CMD_ENABLE "enable" +#define CMD_ENGINE_TYPE "engine_type" +#define CMD_ENGINESNIFFERRPMTHRESHOLD "engineSnifferRpmThreshold" +#define CMD_ETB_DUTY "set_etb_duty" +#define CMD_EXTERNAL_STIMULATION "ext_stimulation" +#define CMD_FAN2_BENCH "fan2bench" +#define CMD_FAN_BENCH "fanbench" +#define CMD_FUEL_BENCH "fuelbench" +#define CMD_FUEL_PUMP_BENCH "fuelpumpbench" +#define CMD_FUNCTIONAL_TEST_MODE "test_mode" +#define CMD_GET "get" +#define CMD_HPFP_BENCH "hpfpbench" +#define CMD_IDLE_BENCH "idlebench" +#define CMD_IDLE_PIN "set_idle_pin" +#define CMD_IGNITION "ignition" +#define CMD_IGNITION_PIN "set_ignition_pin" +#define CMD_INJECTION "injection" +#define CMD_INJECTION_PIN "set_injection_pin" +#define CMD_LOGIC_PIN "set_logic_input_pin" +#define CMD_MIL_BENCH "milbench" +#define CMD_PINS "pins" +#define CMD_PWM "pwm" +#define CMD_REBOOT "reboot" +#define CMD_REBOOT_DFU "reboot_dfu" +#define CMD_REBOOT_OPENBLT "reboot_openblt" +#define CMD_RESET_ENGINE_SNIFFER "reset_engine_chart" +#define CMD_RPM "rpm" +#define CMD_SELF_STIMULATION "self_stimulation" +#define CMD_SET "set" +#define CMD_SPARK_BENCH "sparkbench" +#define CMD_STARTER_BENCH "starterbench" +#define CMD_TRIGGER_HW_INPUT "trigger_hw_input" +#define CMD_TRIGGER_PIN "set_trigger_input_pin" +#define CMD_TRIGGER_SIMULATOR_PIN "set_trigger_simulator_pin" +#define CMD_TRIGGERINFO "triggerinfo" +#define CMD_VSS_PIN "vss_pin" +#define CMD_WRITECONFIG "writeconfig" +#define COMPOSITE_PACKET_SIZE 5 +#define CONSOLE_DATA_PROTOCOL_TAG " @" +#define CRANKING_ADVANCE_CURVE_SIZE 4 +#define CRANKING_CLT_IDLE_CURVE_SIZE 8 +#define CRANKING_CURVE_SIZE 8 +#define cranking_parameters_s_size 8 +#define CRITICAL_PREFIX "CRITICAL" +#define cyl_trim_s_size 16 +#define dc_function_e_auto_enum 0="DC_None",3="DC_IdleValve",1="DC_Throttle1",2="DC_Throttle2",4="DC_Wastegate" +#define dc_function_e_DC_IdleValve 3 +#define dc_function_e_DC_None 0 +#define dc_function_e_DC_Throttle1 1 +#define dc_function_e_DC_Throttle2 2 +#define dc_function_e_DC_Wastegate 4 +#define dc_io_size 8 +#define DC_PER_STEPPER 2 +#define debug_mode_e_auto_enum 0="DBG_0",10="DBG_10",11="DBG_11",16="DBG_16",2="DBG_2",20="DBG_20",24="DBG_24",26="DBG_26",29="DBG_29",34="DBG_34",35="DBG_35",36="DBG_36",37="DBG_37",38="DBG_38",43="DBG_43",46="DBG_46",7="DBG_7",8="DBG_8",9="DBG_9",21="DBG_ANALOG_INPUTS",32="DBG_ANALOG_INPUTS2",19="DBG_BENCH_TEST",25="DBG_CJ125",40="DBG_COMPOSITE_LOG",33="DBG_DWELL_METRIC",44="DBG_DYNO_VIEW",17="DBG_ELECTRONIC_THROTTLE_PID",4="DBG_EL_ACCEL",39="DBG_ETB_AUTOTUNE",18="DBG_EXECUTOR",22="DBG_INSTANT_RPM",30="DBG_ION",15="DBG_KNOCK",45="DBG_LOGIC_ANALYZER",48="DBG_LUA",27="DBG_MAP",28="DBG_METRICS",13="DBG_SD_CARD",6="DBG_SOFT_SPARK_CUT",14="DBG_SR5_PROTOCOL",3="DBG_STEPPER_IDLE_CONTROL",47="DBG_TCU",31="DBG_TLE8888",1="DBG_TPS_ACCEL",5="DBG_TRIGGER_COUNTERS",12="DBG_UNUSED12",41="DBG_UNUSED41",42="DBG_UNUSED_42",23="UNUSED23" +#define debug_mode_e_DBG_0 0 +#define debug_mode_e_DBG_10 10 +#define debug_mode_e_DBG_11 11 +#define debug_mode_e_DBG_16 16 +#define debug_mode_e_DBG_2 2 +#define debug_mode_e_DBG_20 20 +#define debug_mode_e_DBG_24 24 +#define debug_mode_e_DBG_26 26 +#define debug_mode_e_DBG_29 29 +#define debug_mode_e_DBG_34 34 +#define debug_mode_e_DBG_35 35 +#define debug_mode_e_DBG_36 36 +#define debug_mode_e_DBG_37 37 +#define debug_mode_e_DBG_38 38 +#define debug_mode_e_DBG_43 43 +#define debug_mode_e_DBG_46 46 +#define debug_mode_e_DBG_7 7 +#define debug_mode_e_DBG_8 8 +#define debug_mode_e_DBG_9 9 +#define debug_mode_e_DBG_ANALOG_INPUTS 21 +#define debug_mode_e_DBG_ANALOG_INPUTS2 32 +#define debug_mode_e_DBG_BENCH_TEST 19 +#define debug_mode_e_DBG_CJ125 25 +#define debug_mode_e_DBG_COMPOSITE_LOG 40 +#define debug_mode_e_DBG_DWELL_METRIC 33 +#define debug_mode_e_DBG_DYNO_VIEW 44 +#define debug_mode_e_DBG_EL_ACCEL 4 +#define debug_mode_e_DBG_ELECTRONIC_THROTTLE_PID 17 +#define debug_mode_e_DBG_ETB_AUTOTUNE 39 +#define debug_mode_e_DBG_EXECUTOR 18 +#define debug_mode_e_DBG_INSTANT_RPM 22 +#define debug_mode_e_DBG_ION 30 +#define debug_mode_e_DBG_KNOCK 15 +#define debug_mode_e_DBG_LOGIC_ANALYZER 45 +#define debug_mode_e_DBG_LUA 48 +#define debug_mode_e_DBG_MAP 27 +#define debug_mode_e_DBG_METRICS 28 +#define debug_mode_e_DBG_SD_CARD 13 +#define debug_mode_e_DBG_SOFT_SPARK_CUT 6 +#define debug_mode_e_DBG_SR5_PROTOCOL 14 +#define debug_mode_e_DBG_STEPPER_IDLE_CONTROL 3 +#define debug_mode_e_DBG_TCU 47 +#define debug_mode_e_DBG_TLE8888 31 +#define debug_mode_e_DBG_TPS_ACCEL 1 +#define debug_mode_e_DBG_TRIGGER_COUNTERS 5 +#define debug_mode_e_DBG_UNUSED12 12 +#define debug_mode_e_DBG_UNUSED41 41 +#define debug_mode_e_DBG_UNUSED_42 42 +#define debug_mode_e_enum "INVALID", "TPS acceleration enrichment", "INVALID", "Stepper Idle Control", "Engine Load accl enrich", "Trigger Counters", "Soft Spark Cut", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "SD card", "sr5", "Knock", "INVALID", "Electronic Throttle", "Executor", "Bench Test / TS commands", "INVALID", "Analog inputs #1", "INSTANT_RPM", "INVALID", "Status", "CJ125", "INVALID", "MAP", "Metrics", "INVALID", "Ion Sense", "TLE8888", "Analog inputs #2", "Dwell Metric", "INVALID", "INVALID", "Boost Control", "INVALID", "INVALID", "ETB Autotune", "Composite Log", "INVALID", "INVALID", "INVALID", "Dyno_View", "Logic_Analyzer", "INVALID", "TCU", "Lua" +#define debug_mode_e_UNUSED23 23 +#define DIGIPOT_COUNT 4 +#define display_mode_e_auto_enum 0="DM_NONE",1="DM_HD44780",2="DM_HD44780_OVER_PCF8574" +#define display_mode_e_DM_HD44780 1 +#define display_mode_e_DM_HD44780_OVER_PCF8574 2 +#define display_mode_e_DM_NONE 0 +#define DWELL_CURVE_SIZE 8 +#define ego_sensor_e_auto_enum 0="ES_BPSX_D1",2="ES_14Point7_Free",6="ES_AEM",5="ES_Custom",1="ES_Innovate_MTX_L",3="ES_NarrowBand",4="ES_PLX" +#define ego_sensor_e_enum "BPSX", "Innovate", "14Point7", "Narrow", "PLX", "Custom" +#define ego_sensor_e_ES_14Point7_Free 2 +#define ego_sensor_e_ES_AEM 6 +#define ego_sensor_e_ES_BPSX_D1 0 +#define ego_sensor_e_ES_Custom 5 +#define ego_sensor_e_ES_Innovate_MTX_L 1 +#define ego_sensor_e_ES_NarrowBand 3 +#define ego_sensor_e_ES_PLX 4 +#define EGT_CHANNEL_COUNT 8 +#define engine_configuration_s_size 4076 +#define engine_load_mode_e_auto_enum 0="LM_SPEED_DENSITY",2="LM_ALPHA_N",3="LM_LUA",100="LM_MOCK",1="LM_REAL_MAF" +#define engine_load_mode_e_enum "Speed Density", "MAF Air Charge", "Alpha-N", "Lua" +#define engine_load_mode_e_LM_ALPHA_N 2 +#define engine_load_mode_e_LM_LUA 3 +#define engine_load_mode_e_LM_MOCK 100 +#define engine_load_mode_e_LM_REAL_MAF 1 +#define engine_load_mode_e_LM_SPEED_DENSITY 0 +#define ENGINE_MAKE_BMW "BMW" +#define ENGINE_MAKE_GM "GM" +#define ENGINE_MAKE_HONDA "Honda" +#define ENGINE_MAKE_Hyundai "Hyundai" +#define ENGINE_MAKE_LADA "Lada" +#define ENGINE_MAKE_MAZDA "Mazda" +#define ENGINE_MAKE_MERCEDES "Mercedes" +#define ENGINE_MAKE_NISSAN "Nissan" +#define ENGINE_MAKE_SUBARU "Subaru" +#define ENGINE_MAKE_TOYOTA "Toyota" +#define ENGINE_MAKE_VAG "VAG" +#define ENGINE_NOISE_CURVE_SIZE 16 +#define ENGINE_SNIFFER_UNIT_US 10 +#define engine_type_e_auto_enum 0="DEFAULT_FRANKENSO",24="BMW_M73_M",50="BMW_M73_MRE",51="BMW_M73_MRE_SLAVE",35="CAMARO_4",65="CITROEN_TU3JP",38="DISCOVERY_PDM",2="DODGE_NEON_1995",46="DODGE_NEON_2003_CRANK",64="DODGE_RAM",61="EEPROM_BENCH_ENGINE",58="ETB_BENCH_ENGINE",97="ET_UNUSED97",98="ET_UNUSED98",17="ET_UNUSED_17",3="FORD_ASPIRE_1996",14="FORD_ESCORT_GT",7="FORD_INLINE_6_1995",40="FRANKENSO_BMW_M73_F",47="FRANKENSO_MAZDA_MIATA_2003",56="FRANKENSO_MAZDA_MIATA_NA8",41="FRANKENSO_MIATA_NA6_MAP",57="FRANKENSO_MIATA_NA6_VAF",49="FRANKENSO_QA_ENGINE",8="GY6_139QMB",33="HELLEN72_ETB",84="HELLEN_121_NISSAN_4_CYL",72="HELLEN_121_NISSAN_6_CYL",85="HELLEN_121_NISSAN_8_CYL",87="HELLEN_121_NISSAN_ALMERA_N16",71="HELLEN_121_VAG_4_CYL",77="HELLEN_121_VAG_5_CYL",81="HELLEN_121_VAG_8_CYL",78="HELLEN_121_VAG_V6_CYL",79="HELLEN_121_VAG_VR6_CYL",36="HELLEN_128_MERCEDES_4_CYL",88="HELLEN_128_MERCEDES_6_CYL",89="HELLEN_128_MERCEDES_8_CYL",75="HELLEN_134_BMW",82="HELLEN_154_HYUNDAI_COUPE_BK1",95="HELLEN_154_HYUNDAI_COUPE_BK2",76="HELLEN_154_VAG",73="HELLEN_55_BMW",74="HELLEN_88_BMW",34="HELLEN_NA6",10="HELLEN_NA8_96",80="HELLEN_NA94",83="HELLEN_NB1",94="HELLEN_NB1_36",69="HELLEN_NB2",86="HELLEN_NB2_36",43="HONDA_600",60="L9779_BENCH_ENGINE",55="MAZDA_MIATA_2003_BOARD_TEST",54="MAZDA_MIATA_2003_NA_RAIL",21="MIATA_1996",1="MIATA_PROTEUS_TCU",99="MINIMAL_PINS",16="MITSU_4G93",31="MRE_BOARD_NEW_TEST",23="MRE_BODY_CONTROL",68="MRE_M111",20="MRE_MIATA_94_MAP",66="MRE_MIATA_NA6_MAP",12="MRE_MIATA_NA6_VAF",13="MRE_MIATA_NB2_ETB",15="MRE_MIATA_NB2_MAF",11="MRE_MIATA_NB2_MAP",4="MRE_SECONDARY_CAN",37="MRE_SUBARU_EJ18",62="MRE_VW_B6",5="NISSAN_PRIMERA",30="PROTEUS_ANALOG_PWM_TEST",63="PROTEUS_BMW_M73",9="PROTEUS_E65_6H_MAN_IN_THE_MIDDLE",27="PROTEUS_GM_LS_4",6="PROTEUS_HARLEY",90="PROTEUS_HONDA_K",91="PROTEUS_HONDA_OBD2A",25="PROTEUS_LUA_DEMO",67="PROTEUS_MIATA_NB2",93="PROTEUS_N73",42="PROTEUS_QC_TEST_BOARD",92="PROTEUS_VAG_80_18T",39="PROTEUS_VW_B6",29="SACHS",70="SUBARUEG33_DEFAULTS",22="SUBARU_2003_WRX",100="TEST_100",101="TEST_101",102="TEST_102",18="TEST_33816",28="TEST_CRANK_ENGINE",48="TEST_DC_WASTEGATE_DISCOVERY",26="TEST_ENGINE",45="TEST_ENGINE_VVT",52="TEST_ISSUE_366_BOTH",53="TEST_ISSUE_366_RISE",19="TEST_ROTARY",59="TLE8888_BENCH_ENGINE",44="TOYOTA_2JZ_GTE_VVTi",32="VW_ABA",96="WASTEGATE_PROTEUS_TEST" +#define engine_type_e_BMW_M73_M 24 +#define engine_type_e_BMW_M73_MRE 50 +#define engine_type_e_BMW_M73_MRE_SLAVE 51 +#define engine_type_e_CAMARO_4 35 +#define engine_type_e_CITROEN_TU3JP 65 +#define engine_type_e_DEFAULT_FRANKENSO 0 +#define engine_type_e_DISCOVERY_PDM 38 +#define engine_type_e_DODGE_NEON_1995 2 +#define engine_type_e_DODGE_NEON_2003_CRANK 46 +#define engine_type_e_DODGE_RAM 64 +#define engine_type_e_EEPROM_BENCH_ENGINE 61 +#define engine_type_e_ET_UNUSED97 97 +#define engine_type_e_ET_UNUSED98 98 +#define engine_type_e_ET_UNUSED_17 17 +#define engine_type_e_ETB_BENCH_ENGINE 58 +#define engine_type_e_Force_4_bytes_size_engine_type 70000 +#define engine_type_e_FORD_ASPIRE_1996 3 +#define engine_type_e_FORD_ESCORT_GT 14 +#define engine_type_e_FORD_INLINE_6_1995 7 +#define engine_type_e_FRANKENSO_BMW_M73_F 40 +#define engine_type_e_FRANKENSO_MAZDA_MIATA_2003 47 +#define engine_type_e_FRANKENSO_MAZDA_MIATA_NA8 56 +#define engine_type_e_FRANKENSO_MIATA_NA6_MAP 41 +#define engine_type_e_FRANKENSO_MIATA_NA6_VAF 57 +#define engine_type_e_FRANKENSO_QA_ENGINE 49 +#define engine_type_e_GY6_139QMB 8 +#define engine_type_e_HELLEN72_ETB 33 +#define engine_type_e_HELLEN_121_NISSAN_4_CYL 84 +#define engine_type_e_HELLEN_121_NISSAN_6_CYL 72 +#define engine_type_e_HELLEN_121_NISSAN_8_CYL 85 +#define engine_type_e_HELLEN_121_NISSAN_ALMERA_N16 87 +#define engine_type_e_HELLEN_121_VAG_4_CYL 71 +#define engine_type_e_HELLEN_121_VAG_5_CYL 77 +#define engine_type_e_HELLEN_121_VAG_8_CYL 81 +#define engine_type_e_HELLEN_121_VAG_V6_CYL 78 +#define engine_type_e_HELLEN_121_VAG_VR6_CYL 79 +#define engine_type_e_HELLEN_128_MERCEDES_4_CYL 36 +#define engine_type_e_HELLEN_128_MERCEDES_6_CYL 88 +#define engine_type_e_HELLEN_128_MERCEDES_8_CYL 89 +#define engine_type_e_HELLEN_134_BMW 75 +#define engine_type_e_HELLEN_154_HYUNDAI_COUPE_BK1 82 +#define engine_type_e_HELLEN_154_HYUNDAI_COUPE_BK2 95 +#define engine_type_e_HELLEN_154_VAG 76 +#define engine_type_e_HELLEN_55_BMW 73 +#define engine_type_e_HELLEN_88_BMW 74 +#define engine_type_e_HELLEN_NA6 34 +#define engine_type_e_HELLEN_NA8_96 10 +#define engine_type_e_HELLEN_NA94 80 +#define engine_type_e_HELLEN_NB1 83 +#define engine_type_e_HELLEN_NB1_36 94 +#define engine_type_e_HELLEN_NB2 69 +#define engine_type_e_HELLEN_NB2_36 86 +#define engine_type_e_HONDA_600 43 +#define engine_type_e_L9779_BENCH_ENGINE 60 +#define engine_type_e_MAZDA_MIATA_2003_BOARD_TEST 55 +#define engine_type_e_MAZDA_MIATA_2003_NA_RAIL 54 +#define engine_type_e_MIATA_1996 21 +#define engine_type_e_MIATA_PROTEUS_TCU 1 +#define engine_type_e_MINIMAL_PINS 99 +#define engine_type_e_MITSU_4G93 16 +#define engine_type_e_MRE_BOARD_NEW_TEST 31 +#define engine_type_e_MRE_BODY_CONTROL 23 +#define engine_type_e_MRE_M111 68 +#define engine_type_e_MRE_MIATA_94_MAP 20 +#define engine_type_e_MRE_MIATA_NA6_MAP 66 +#define engine_type_e_MRE_MIATA_NA6_VAF 12 +#define engine_type_e_MRE_MIATA_NB2_ETB 13 +#define engine_type_e_MRE_MIATA_NB2_MAF 15 +#define engine_type_e_MRE_MIATA_NB2_MAP 11 +#define engine_type_e_MRE_SECONDARY_CAN 4 +#define engine_type_e_MRE_SUBARU_EJ18 37 +#define engine_type_e_MRE_VW_B6 62 +#define engine_type_e_NISSAN_PRIMERA 5 +#define engine_type_e_PROTEUS_ANALOG_PWM_TEST 30 +#define engine_type_e_PROTEUS_BMW_M73 63 +#define engine_type_e_PROTEUS_E65_6H_MAN_IN_THE_MIDDLE 9 +#define engine_type_e_PROTEUS_GM_LS_4 27 +#define engine_type_e_PROTEUS_HARLEY 6 +#define engine_type_e_PROTEUS_HONDA_K 90 +#define engine_type_e_PROTEUS_HONDA_OBD2A 91 +#define engine_type_e_PROTEUS_LUA_DEMO 25 +#define engine_type_e_PROTEUS_MIATA_NB2 67 +#define engine_type_e_PROTEUS_N73 93 +#define engine_type_e_PROTEUS_QC_TEST_BOARD 42 +#define engine_type_e_PROTEUS_VAG_80_18T 92 +#define engine_type_e_PROTEUS_VW_B6 39 +#define engine_type_e_SACHS 29 +#define engine_type_e_SUBARU_2003_WRX 22 +#define engine_type_e_SUBARUEG33_DEFAULTS 70 +#define engine_type_e_TEST_100 100 +#define engine_type_e_TEST_101 101 +#define engine_type_e_TEST_102 102 +#define engine_type_e_TEST_33816 18 +#define engine_type_e_TEST_CRANK_ENGINE 28 +#define engine_type_e_TEST_DC_WASTEGATE_DISCOVERY 48 +#define engine_type_e_TEST_ENGINE 26 +#define engine_type_e_TEST_ENGINE_VVT 45 +#define engine_type_e_TEST_ISSUE_366_BOTH 52 +#define engine_type_e_TEST_ISSUE_366_RISE 53 +#define engine_type_e_TEST_ROTARY 19 +#define engine_type_e_TLE8888_BENCH_ENGINE 59 +#define engine_type_e_TOYOTA_2JZ_GTE_VVTi 44 +#define engine_type_e_VW_ABA 32 +#define engine_type_e_WASTEGATE_PROTEUS_TEST 96 +#define engineSyncCam_enum "Intake First Bank", "Exhaust First Bank", "Intake Second Bank", "Exhaust Second Bank" +#define ERROR_BUFFER_SIZE 120 +#define ETB_BIAS_CURVE_LENGTH 8 +#define ETB_COUNT 2 +#define ETB_HW_MAX_FREQUENCY 3000 +#define FLASH_DATA_VERSION 10020 +#define FUEL_LEVEL_TABLE_COUNT 8 +#define FUEL_LOAD_COUNT 16 +#define FUEL_RPM_COUNT 16 +#define GAP_TRACKING_LENGTH 18 +#define GAUGE_CATEGORY_BOOST_CONTROL "Boost Control" +#define GAUGE_CATEGORY_ETB "ETB more" +#define GAUGE_CATEGORY_FUEL_MATH "Fuel: math" +#define GAUGE_CATEGORY_TIMING "Timing" +#define GAUGE_COIL_DWELL_TIME "dwell: coil charge time" +#define GAUGE_NAME_ACCEL_ROLL "Acceleration: Roll" +#define GAUGE_NAME_ACCEL_X "Acceleration: X" +#define GAUGE_NAME_ACCEL_Y "Acceleration: Y" +#define GAUGE_NAME_ACCEL_YAW "Acceleration: Yaw" +#define GAUGE_NAME_ACCEL_Z "Acceleration: Z" +#define GAUGE_NAME_AFR "Air/Fuel Ratio" +#define GAUGE_NAME_AFR2 "Air/Fuel Ratio 2" +#define GAUGE_NAME_AIR_FLOW_ESTIMATE "MAF estimate" +#define GAUGE_NAME_AIR_FLOW_MEASURED "MAF" +#define GAUGE_NAME_AIR_FLOW_MEASURED_2 "MAF #2" +#define GAUGE_NAME_AIR_MASS "air mass" +#define GAUGE_NAME_AUX_LINEAR_1 "Aux Linear #1" +#define GAUGE_NAME_AUX_LINEAR_2 "Aux Linear #2" +#define GAUGE_NAME_AUX_TEMP1 "Aux temp 1" +#define GAUGE_NAME_AUX_TEMP2 "Aux temp 2" +#define GAUGE_NAME_BARO_PRESSURE "Barometric pressure" +#define GAUGE_NAME_BOOST_CLOSED_LOOP "Boost Closed Loop" +#define GAUGE_NAME_BOOST_OPEN_LOOP "Boost Open Loop" +#define GAUGE_NAME_BOOST_OUTPUT "Boost Output" +#define GAUGE_NAME_BOOST_TARGET "Boost Target" +#define GAUGE_NAME_CLT "CLT" +#define GAUGE_NAME_CPU_TEMP "CPU Temperature" +#define GAUGE_NAME_CURRENT_GEAR "Current Gear" +#define GAUGE_NAME_DEBUG_F1 "debug f1" +#define GAUGE_NAME_DEBUG_F2 "debug f2: iTerm" +#define GAUGE_NAME_DEBUG_F3 "debug f3: prevError" +#define GAUGE_NAME_DEBUG_F4 "debug f4: iParam" +#define GAUGE_NAME_DEBUG_F5 "debug f5: dParam" +#define GAUGE_NAME_DEBUG_F6 "debug f6: dTerm" +#define GAUGE_NAME_DEBUG_F7 "debug f7" +#define GAUGE_NAME_DEBUG_I1 "debug i1: pParam" +#define GAUGE_NAME_DEBUG_I2 "debug i2: offset" +#define GAUGE_NAME_DEBUG_I3 "debug i3" +#define GAUGE_NAME_DEBUG_I4 "debug i4" +#define GAUGE_NAME_DEBUG_I5 "debug i5" +#define GAUGE_NAME_DESIRED_GEAR "Desired Gear" +#define GAUGE_NAME_DETECTED_GEAR "Detected Gear" +#define GAUGE_NAME_DWELL_DUTY "dwell: coil duty cycle" +#define GAUGE_NAME_ECU_TEMPERATURE "ECU temperature" +#define GAUGE_NAME_ENGINE_CRC16 "Engine CRC16" +#define GAUGE_NAME_ETB_DUTY "ETB Duty" +#define GAUGE_NAME_ETB_ERROR "ETB position error" +#define GAUGE_NAME_ETB_TARGET "ETB position target" +#define GAUGE_NAME_FLEX "Flex Ethanol %" +#define GAUGE_NAME_FUEL_BARO_CORR "fuel: Barometric pressure mult" +#define GAUGE_NAME_FUEL_BASE "fuel: base mass" +#define GAUGE_NAME_FUEL_CHARGE_TEMP "fuel: Estimated charge temperature" +#define GAUGE_NAME_FUEL_CLT_CORR "fuel: CLT correction" +#define GAUGE_NAME_FUEL_CONSUMPTION "fuel: Total consumed" +#define GAUGE_NAME_FUEL_CRANKING "fuel: cranking" +#define GAUGE_NAME_FUEL_EL_EXTRA "fuel: engine load acceleration extra fuel" +#define GAUGE_NAME_FUEL_FLOW "fuel: Flow rate" +#define GAUGE_NAME_FUEL_IAT_CORR "fuel: IAT correction" +#define GAUGE_NAME_FUEL_INJ_DUTY "fuel: injector duty cycle" +#define GAUGE_NAME_FUEL_LAST_INJECTION "fuel: Last injection" +#define GAUGE_NAME_FUEL_LEVEL "fuel level" +#define GAUGE_NAME_FUEL_LOAD "fuel: load" +#define GAUGE_NAME_FUEL_PRESSURE_HIGH "Fuel pressure (high)" +#define GAUGE_NAME_FUEL_PRESSURE_HIGH_UNITS "bar" +#define GAUGE_NAME_FUEL_PRESSURE_LOW "Fuel pressure (low)" +#define GAUGE_NAME_FUEL_PRESSURE_LOW_UNITS "kPa" +#define GAUGE_NAME_FUEL_RUNNING "fuel: running" +#define GAUGE_NAME_FUEL_TPS_EXTRA "fuel: TPS acceleration add fuel ms" +#define GAUGE_NAME_FUEL_TPS_ROC "fuel: TPS change" +#define GAUGE_NAME_FUEL_TRIM "fuel: fuel trim" +#define GAUGE_NAME_FUEL_TRIM_2 "fuel: fuel trim 2" +#define GAUGE_NAME_FUEL_VE "fuel: VE" +#define GAUGE_NAME_FUEL_WALL_AMOUNT "fuel: wall amount" +#define GAUGE_NAME_FUEL_WALL_CORRECTION "fuel: wall correction" +#define GAUGE_NAME_FW_VERSION "ECU Software Version" +#define GAUGE_NAME_GEAR_RATIO "Gearbox Ratio" +#define GAUGE_NAME_IAC "Idle Air Valve" +#define GAUGE_NAME_IAT "IAT" +#define GAUGE_NAME_IDLE_POSITION "Idle position sensor" +#define GAUGE_NAME_IGNITION_LOAD "ign: load" +#define GAUGE_NAME_INJECTOR_LAG "fuel: injector lag" +#define GAUGE_NAME_ISS "Input Shaft Speed" +#define GAUGE_NAME_KNOCK_1 "knock 1" +#define GAUGE_NAME_KNOCK_10 "knock 10" +#define GAUGE_NAME_KNOCK_11 "knock 11" +#define GAUGE_NAME_KNOCK_12 "knock 12" +#define GAUGE_NAME_KNOCK_2 "knock 2" +#define GAUGE_NAME_KNOCK_3 "knock 3" +#define GAUGE_NAME_KNOCK_4 "knock 4" +#define GAUGE_NAME_KNOCK_5 "knock 5" +#define GAUGE_NAME_KNOCK_6 "knock 6" +#define GAUGE_NAME_KNOCK_7 "knock 7" +#define GAUGE_NAME_KNOCK_8 "knock 8" +#define GAUGE_NAME_KNOCK_9 "knock 9" +#define GAUGE_NAME_KNOCK_COUNTER "knock: count" +#define GAUGE_NAME_KNOCK_LEVEL "knock: current level" +#define GAUGE_NAME_KNOCK_RETARD "knock: retard" +#define GAUGE_NAME_LAMBDA "Lambda" +#define GAUGE_NAME_LAMBDA2 "Lambda 2" +#define GAUGE_NAME_LAST_ERROR "Last error" +#define GAUGE_NAME_MAF "MAF" +#define GAUGE_NAME_MAP "MAP" +#define GAUGE_NAME_OIL_PRESSURE "Oil Pressure" +#define GAUGE_NAME_OIL_PRESSURE_UNITS "kPa" +#define GAUGE_NAME_RAW_FUEL_PRESSURE_HIGH "Fuel pressure raw (high)" +#define GAUGE_NAME_RAW_FUEL_PRESSURE_LOW "Fuel pressure raw (low)" +#define GAUGE_NAME_RPM "RPM" +#define GAUGE_NAME_TARGET_AFR "fuel: target AFR" +#define GAUGE_NAME_TARGET_LAMBDA "fuel: target lambda" +#define GAUGE_NAME_TC_RATIO "Torque Converter Ratio" +#define GAUGE_NAME_TCHARGE "fuel: SD tCharge" +#define GAUGE_NAME_THROTTLE_PEDAL "Throttle pedal position" +#define GAUGE_NAME_TIME "Time" +#define GAUGE_NAME_TIMING_ADVANCE "timing" +#define GAUGE_NAME_TPS "TPS" +#define GAUGE_NAME_TPS2 "TPS2" +#define GAUGE_NAME_TRG_ERR "Trigger Error Counter" +#define GAUGE_NAME_TRG_GAP "Trigger Sync Latest Ratio" +#define GAUGE_NAME_TUNE_CRC16 "Tune CRC16" +#define GAUGE_NAME_TURBO_SPEED "Turbocharger Speed" +#define GAUGE_NAME_UPTIME "Uptime" +#define GAUGE_NAME_VBAT "VBatt" +#define GAUGE_NAME_VERSION "firmware" +#define GAUGE_NAME_VVS "Vehicle Speed" +#define GAUGE_NAME_VVT_B1E "VVT: bank 1 exhaust" +#define GAUGE_NAME_VVT_B1I "VVT: bank 1 intake" +#define GAUGE_NAME_VVT_B2E "VVT: bank 2 exhaust" +#define GAUGE_NAME_VVT_B2I "VVT: bank 2 intake" +#define GAUGE_NAME_VVT_TARGET_B1E "VVT: bank 1 exhaust target" +#define GAUGE_NAME_VVT_TARGET_B1I "VVT: bank 1 intake target" +#define GAUGE_NAME_VVT_TARGET_B2E "VVT: bank 2 exhaust target" +#define GAUGE_NAME_VVT_TARGET_B2I "VVT: bank 2 intake target" +#define GAUGE_NAME_WARNING_COUNT "Warning count" +#define GAUGE_NAME_WARNING_COUNTER "warning: counter" +#define GAUGE_NAME_WARNING_LAST "warning: last" +#define GAUGE_NAME_WG_POSITION "Wastegate position sensor" +#define gear_controller_e_enum "None", "Button Shift" +#define gear_e_GEAR_1 1 +#define gear_e_GEAR_2 2 +#define gear_e_GEAR_3 3 +#define gear_e_GEAR_4 4 +#define gear_e_NEUTRAL 0 +#define gear_e_REVERSE -1 +#define GearControllerMode_auto_enum 0="None",1="ButtonShift",2="Generic" +#define GearControllerMode_ButtonShift 1 +#define GearControllerMode_Generic 2 +#define GearControllerMode_None 0 +#define GEARS_COUNT 8 +#define Gpio_A0 2 +#define Gpio_A1 3 +#define Gpio_A10 12 +#define Gpio_A11 13 +#define Gpio_A12 14 +#define Gpio_A13 15 +#define Gpio_A14 16 +#define Gpio_A15 17 +#define Gpio_A2 4 +#define Gpio_A3 5 +#define Gpio_A4 6 +#define Gpio_A5 7 +#define Gpio_A6 8 +#define Gpio_A7 9 +#define Gpio_A8 10 +#define Gpio_A9 11 +#define Gpio_auto_enum 0="Unassigned",2="A0",3="A1",12="A10",13="A11",14="A12",15="A13",16="A14",17="A15",4="A2",5="A3",6="A4",7="A5",8="A6",9="A7",10="A8",11="A9",18="B0",19="B1",28="B10",29="B11",30="B12",31="B13",32="B14",33="B15",20="B2",21="B3",22="B4",23="B5",24="B6",25="B7",26="B8",27="B9",34="C0",35="C1",44="C10",45="C11",46="C12",47="C13",48="C14",49="C15",36="C2",37="C3",38="C4",39="C5",40="C6",41="C7",42="C8",43="C9",249="CAN_PIN_0",250="CAN_PIN_1",251="CAN_PIN_2",252="CAN_PIN_3",253="CAN_PIN_4",254="CAN_PIN_5",255="CAN_PIN_6",256="CAN_PIN_7",50="D0",51="D1",60="D10",61="D11",62="D12",63="D13",64="D14",65="D15",52="D2",53="D3",54="D4",55="D5",56="D6",57="D7",58="D8",59="D9",66="E0",67="E1",76="E10",77="E11",78="E12",79="E13",80="E14",81="E15",68="E2",69="E3",70="E4",71="E5",72="E6",73="E7",74="E8",75="E9",82="F0",83="F1",92="F10",93="F11",94="F12",95="F13",96="F14",97="F15",84="F2",85="F3",86="F4",87="F5",88="F6",89="F7",90="F8",91="F9",98="G0",99="G1",108="G10",109="G11",110="G12",111="G13",112="G14",113="G15",100="G2",101="G3",102="G4",103="G5",104="G6",105="G7",106="G8",107="G9",114="H0",115="H1",124="H10",125="H11",126="H12",127="H13",128="H14",129="H15",116="H2",117="H3",118="H4",119="H5",120="H6",121="H7",122="H8",123="H9",130="I0",131="I1",140="I10",141="I11",142="I12",143="I13",144="I14",145="I15",132="I2",133="I3",134="I4",135="I5",136="I6",137="I7",138="I8",139="I9",1="Invalid",215="L9779_IGN_1",216="L9779_IGN_2",217="L9779_IGN_3",218="L9779_IGN_4",219="L9779_OUT_1",228="L9779_OUT_10",229="L9779_OUT_11",230="L9779_OUT_12",231="L9779_OUT_13",232="L9779_OUT_14",233="L9779_OUT_15",234="L9779_OUT_16",235="L9779_OUT_17",236="L9779_OUT_18",237="L9779_OUT_19",220="L9779_OUT_2",238="L9779_OUT_20",243="L9779_OUT_25",244="L9779_OUT_26",245="L9779_OUT_27",246="L9779_OUT_28",221="L9779_OUT_3",222="L9779_OUT_4",223="L9779_OUT_5",224="L9779_OUT_6",225="L9779_OUT_7",226="L9779_OUT_8",227="L9779_OUT_9",239="L9779_OUT_A",240="L9779_OUT_B",241="L9779_OUT_C",242="L9779_OUT_D",247="L9779_OUT_MRD",248="L9779_PIN_KEY",146="MC33972_PIN_1",166="MC33972_PIN_21",167="MC33972_PIN_22",257="PROTECTED_PIN_0",258="PROTECTED_PIN_1",267="PROTECTED_PIN_10",268="PROTECTED_PIN_11",269="PROTECTED_PIN_12",270="PROTECTED_PIN_13",271="PROTECTED_PIN_14",272="PROTECTED_PIN_15",259="PROTECTED_PIN_2",260="PROTECTED_PIN_3",261="PROTECTED_PIN_4",262="PROTECTED_PIN_5",263="PROTECTED_PIN_6",264="PROTECTED_PIN_7",265="PROTECTED_PIN_8",266="PROTECTED_PIN_9",199="TLE6240_PIN_1",208="TLE6240_PIN_10",209="TLE6240_PIN_11",210="TLE6240_PIN_12",211="TLE6240_PIN_13",212="TLE6240_PIN_14",213="TLE6240_PIN_15",214="TLE6240_PIN_16",200="TLE6240_PIN_2",201="TLE6240_PIN_3",202="TLE6240_PIN_4",203="TLE6240_PIN_5",204="TLE6240_PIN_6",205="TLE6240_PIN_7",206="TLE6240_PIN_8",207="TLE6240_PIN_9",168="TLE8888_PIN_1",177="TLE8888_PIN_10",178="TLE8888_PIN_11",179="TLE8888_PIN_12",180="TLE8888_PIN_13",181="TLE8888_PIN_14",182="TLE8888_PIN_15",183="TLE8888_PIN_16",184="TLE8888_PIN_17",185="TLE8888_PIN_18",186="TLE8888_PIN_19",169="TLE8888_PIN_2",187="TLE8888_PIN_20",188="TLE8888_PIN_21",189="TLE8888_PIN_22",190="TLE8888_PIN_23",191="TLE8888_PIN_24",192="TLE8888_PIN_25",193="TLE8888_PIN_26",194="TLE8888_PIN_27",195="TLE8888_PIN_28",170="TLE8888_PIN_3",171="TLE8888_PIN_4",172="TLE8888_PIN_5",173="TLE8888_PIN_6",174="TLE8888_PIN_7",175="TLE8888_PIN_8",176="TLE8888_PIN_9",197="TLE8888_PIN_KEY",196="TLE8888_PIN_MR",198="TLE8888_PIN_WAKE" +#define Gpio_B0 18 +#define Gpio_B1 19 +#define Gpio_B10 28 +#define Gpio_B11 29 +#define Gpio_B12 30 +#define Gpio_B13 31 +#define Gpio_B14 32 +#define Gpio_B15 33 +#define Gpio_B2 20 +#define Gpio_B3 21 +#define Gpio_B4 22 +#define Gpio_B5 23 +#define Gpio_B6 24 +#define Gpio_B7 25 +#define Gpio_B8 26 +#define Gpio_B9 27 +#define Gpio_C0 34 +#define Gpio_C1 35 +#define Gpio_C10 44 +#define Gpio_C11 45 +#define Gpio_C12 46 +#define Gpio_C13 47 +#define Gpio_C14 48 +#define Gpio_C15 49 +#define Gpio_C2 36 +#define Gpio_C3 37 +#define Gpio_C4 38 +#define Gpio_C5 39 +#define Gpio_C6 40 +#define Gpio_C7 41 +#define Gpio_C8 42 +#define Gpio_C9 43 +#define Gpio_CAN_PIN_0 249 +#define Gpio_CAN_PIN_1 250 +#define Gpio_CAN_PIN_2 251 +#define Gpio_CAN_PIN_3 252 +#define Gpio_CAN_PIN_4 253 +#define Gpio_CAN_PIN_5 254 +#define Gpio_CAN_PIN_6 255 +#define Gpio_CAN_PIN_7 256 +#define Gpio_D0 50 +#define Gpio_D1 51 +#define Gpio_D10 60 +#define Gpio_D11 61 +#define Gpio_D12 62 +#define Gpio_D13 63 +#define Gpio_D14 64 +#define Gpio_D15 65 +#define Gpio_D2 52 +#define Gpio_D3 53 +#define Gpio_D4 54 +#define Gpio_D5 55 +#define Gpio_D6 56 +#define Gpio_D7 57 +#define Gpio_D8 58 +#define Gpio_D9 59 +#define Gpio_E0 66 +#define Gpio_E1 67 +#define Gpio_E10 76 +#define Gpio_E11 77 +#define Gpio_E12 78 +#define Gpio_E13 79 +#define Gpio_E14 80 +#define Gpio_E15 81 +#define Gpio_E2 68 +#define Gpio_E3 69 +#define Gpio_E4 70 +#define Gpio_E5 71 +#define Gpio_E6 72 +#define Gpio_E7 73 +#define Gpio_E8 74 +#define Gpio_E9 75 +#define Gpio_enum "NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15" +#define Gpio_F0 82 +#define Gpio_F1 83 +#define Gpio_F10 92 +#define Gpio_F11 93 +#define Gpio_F12 94 +#define Gpio_F13 95 +#define Gpio_F14 96 +#define Gpio_F15 97 +#define Gpio_F2 84 +#define Gpio_F3 85 +#define Gpio_F4 86 +#define Gpio_F5 87 +#define Gpio_F6 88 +#define Gpio_F7 89 +#define Gpio_F8 90 +#define Gpio_F9 91 +#define Gpio_G0 98 +#define Gpio_G1 99 +#define Gpio_G10 108 +#define Gpio_G11 109 +#define Gpio_G12 110 +#define Gpio_G13 111 +#define Gpio_G14 112 +#define Gpio_G15 113 +#define Gpio_G2 100 +#define Gpio_G3 101 +#define Gpio_G4 102 +#define Gpio_G5 103 +#define Gpio_G6 104 +#define Gpio_G7 105 +#define Gpio_G8 106 +#define Gpio_G9 107 +#define Gpio_H0 114 +#define Gpio_H1 115 +#define Gpio_H10 124 +#define Gpio_H11 125 +#define Gpio_H12 126 +#define Gpio_H13 127 +#define Gpio_H14 128 +#define Gpio_H15 129 +#define Gpio_H2 116 +#define Gpio_H3 117 +#define Gpio_H4 118 +#define Gpio_H5 119 +#define Gpio_H6 120 +#define Gpio_H7 121 +#define Gpio_H8 122 +#define Gpio_H9 123 +#define Gpio_I0 130 +#define Gpio_I1 131 +#define Gpio_I10 140 +#define Gpio_I11 141 +#define Gpio_I12 142 +#define Gpio_I13 143 +#define Gpio_I14 144 +#define Gpio_I15 145 +#define Gpio_I2 132 +#define Gpio_I3 133 +#define Gpio_I4 134 +#define Gpio_I5 135 +#define Gpio_I6 136 +#define Gpio_I7 137 +#define Gpio_I8 138 +#define Gpio_I9 139 +#define Gpio_Invalid 1 +#define Gpio_L9779_IGN_1 215 +#define Gpio_L9779_IGN_2 216 +#define Gpio_L9779_IGN_3 217 +#define Gpio_L9779_IGN_4 218 +#define Gpio_L9779_OUT_1 219 +#define Gpio_L9779_OUT_10 228 +#define Gpio_L9779_OUT_11 229 +#define Gpio_L9779_OUT_12 230 +#define Gpio_L9779_OUT_13 231 +#define Gpio_L9779_OUT_14 232 +#define Gpio_L9779_OUT_15 233 +#define Gpio_L9779_OUT_16 234 +#define Gpio_L9779_OUT_17 235 +#define Gpio_L9779_OUT_18 236 +#define Gpio_L9779_OUT_19 237 +#define Gpio_L9779_OUT_2 220 +#define Gpio_L9779_OUT_20 238 +#define Gpio_L9779_OUT_25 243 +#define Gpio_L9779_OUT_26 244 +#define Gpio_L9779_OUT_27 245 +#define Gpio_L9779_OUT_28 246 +#define Gpio_L9779_OUT_3 221 +#define Gpio_L9779_OUT_4 222 +#define Gpio_L9779_OUT_5 223 +#define Gpio_L9779_OUT_6 224 +#define Gpio_L9779_OUT_7 225 +#define Gpio_L9779_OUT_8 226 +#define Gpio_L9779_OUT_9 227 +#define Gpio_L9779_OUT_A 239 +#define Gpio_L9779_OUT_B 240 +#define Gpio_L9779_OUT_C 241 +#define Gpio_L9779_OUT_D 242 +#define Gpio_L9779_OUT_MRD 247 +#define Gpio_L9779_PIN_KEY 248 +#define Gpio_MC33972_PIN_1 146 +#define Gpio_MC33972_PIN_21 166 +#define Gpio_MC33972_PIN_22 167 +#define Gpio_PROTECTED_PIN_0 257 +#define Gpio_PROTECTED_PIN_1 258 +#define Gpio_PROTECTED_PIN_10 267 +#define Gpio_PROTECTED_PIN_11 268 +#define Gpio_PROTECTED_PIN_12 269 +#define Gpio_PROTECTED_PIN_13 270 +#define Gpio_PROTECTED_PIN_14 271 +#define Gpio_PROTECTED_PIN_15 272 +#define Gpio_PROTECTED_PIN_2 259 +#define Gpio_PROTECTED_PIN_3 260 +#define Gpio_PROTECTED_PIN_4 261 +#define Gpio_PROTECTED_PIN_5 262 +#define Gpio_PROTECTED_PIN_6 263 +#define Gpio_PROTECTED_PIN_7 264 +#define Gpio_PROTECTED_PIN_8 265 +#define Gpio_PROTECTED_PIN_9 266 +#define Gpio_TLE6240_PIN_1 199 +#define Gpio_TLE6240_PIN_10 208 +#define Gpio_TLE6240_PIN_11 209 +#define Gpio_TLE6240_PIN_12 210 +#define Gpio_TLE6240_PIN_13 211 +#define Gpio_TLE6240_PIN_14 212 +#define Gpio_TLE6240_PIN_15 213 +#define Gpio_TLE6240_PIN_16 214 +#define Gpio_TLE6240_PIN_2 200 +#define Gpio_TLE6240_PIN_3 201 +#define Gpio_TLE6240_PIN_4 202 +#define Gpio_TLE6240_PIN_5 203 +#define Gpio_TLE6240_PIN_6 204 +#define Gpio_TLE6240_PIN_7 205 +#define Gpio_TLE6240_PIN_8 206 +#define Gpio_TLE6240_PIN_9 207 +#define Gpio_TLE8888_PIN_1 168 +#define Gpio_TLE8888_PIN_10 177 +#define Gpio_TLE8888_PIN_11 178 +#define Gpio_TLE8888_PIN_12 179 +#define Gpio_TLE8888_PIN_13 180 +#define Gpio_TLE8888_PIN_14 181 +#define Gpio_TLE8888_PIN_15 182 +#define Gpio_TLE8888_PIN_16 183 +#define Gpio_TLE8888_PIN_17 184 +#define Gpio_TLE8888_PIN_18 185 +#define Gpio_TLE8888_PIN_19 186 +#define Gpio_TLE8888_PIN_2 169 +#define Gpio_TLE8888_PIN_20 187 +#define Gpio_TLE8888_PIN_21 188 +#define Gpio_TLE8888_PIN_22 189 +#define Gpio_TLE8888_PIN_23 190 +#define Gpio_TLE8888_PIN_24 191 +#define Gpio_TLE8888_PIN_25 192 +#define Gpio_TLE8888_PIN_26 193 +#define Gpio_TLE8888_PIN_27 194 +#define Gpio_TLE8888_PIN_28 195 +#define Gpio_TLE8888_PIN_3 170 +#define Gpio_TLE8888_PIN_4 171 +#define Gpio_TLE8888_PIN_5 172 +#define Gpio_TLE8888_PIN_6 173 +#define Gpio_TLE8888_PIN_7 174 +#define Gpio_TLE8888_PIN_8 175 +#define Gpio_TLE8888_PIN_9 176 +#define Gpio_TLE8888_PIN_KEY 197 +#define Gpio_TLE8888_PIN_MR 196 +#define Gpio_TLE8888_PIN_WAKE 198 +#define Gpio_Unassigned 0 +#define gppwm_channel_e_auto_enum 0="GPPWM_Zero",9="GPPWM_AccelPedal",16="GPPWM_AuxLinear1",17="GPPWM_AuxLinear2",7="GPPWM_AuxTemp1",8="GPPWM_AuxTemp2",3="GPPWM_Clt",15="GPPWM_EthanolPercent",5="GPPWM_FuelLoad",18="GPPWM_GppwmOutput1",19="GPPWM_GppwmOutput2",20="GPPWM_GppwmOutput3",21="GPPWM_GppwmOutput4",4="GPPWM_Iat",6="GPPWM_IgnLoad",22="GPPWM_LuaGauge1",23="GPPWM_LuaGauge2",2="GPPWM_Map",24="GPPWM_Rpm",1="GPPWM_Tps",12="GPPWM_VVT_1E",11="GPPWM_VVT_1I",14="GPPWM_VVT_2E",13="GPPWM_VVT_2I",10="GPPWM_Vbatt" +#define gppwm_channel_e_enum "Zero", "TPS", "MAP", "CLT", "IAT", "Fuel Load", "Ignition Load", "Aux Temp 1", "Aux Temp 2", "Accel Pedal", "Battery Voltage", "VVT 1 I", "VVT 1 E", "VVT 2 I", "VVT 2 E", "Ethanol (Flex) %", "Aux Linear 1", "Aux Linear 2", "GPPWM Output 1", "GPPWM Output 2", "GPPWM Output 3", "GPPWM Output 4", "Lua Gauge 1", "Lua Gauge 2", "RPM" +#define gppwm_channel_e_GPPWM_AccelPedal 9 +#define gppwm_channel_e_GPPWM_AuxLinear1 16 +#define gppwm_channel_e_GPPWM_AuxLinear2 17 +#define gppwm_channel_e_GPPWM_AuxTemp1 7 +#define gppwm_channel_e_GPPWM_AuxTemp2 8 +#define gppwm_channel_e_GPPWM_Clt 3 +#define gppwm_channel_e_GPPWM_EthanolPercent 15 +#define gppwm_channel_e_GPPWM_FuelLoad 5 +#define gppwm_channel_e_GPPWM_GppwmOutput1 18 +#define gppwm_channel_e_GPPWM_GppwmOutput2 19 +#define gppwm_channel_e_GPPWM_GppwmOutput3 20 +#define gppwm_channel_e_GPPWM_GppwmOutput4 21 +#define gppwm_channel_e_GPPWM_Iat 4 +#define gppwm_channel_e_GPPWM_IgnLoad 6 +#define gppwm_channel_e_GPPWM_LuaGauge1 22 +#define gppwm_channel_e_GPPWM_LuaGauge2 23 +#define gppwm_channel_e_GPPWM_Map 2 +#define gppwm_channel_e_GPPWM_Rpm 24 +#define gppwm_channel_e_GPPWM_Tps 1 +#define gppwm_channel_e_GPPWM_Vbatt 10 +#define gppwm_channel_e_GPPWM_VVT_1E 12 +#define gppwm_channel_e_GPPWM_VVT_1I 11 +#define gppwm_channel_e_GPPWM_VVT_2E 14 +#define gppwm_channel_e_GPPWM_VVT_2I 13 +#define gppwm_channel_e_GPPWM_Zero 0 +#define gppwm_channel_size 108 +#define GPPWM_CHANNELS 4 +#define gppwm_compare_mode_e_GPPWM_GreaterThan 0 +#define gppwm_compare_mode_e_GPPWM_LessThan 1 +#define GPPWM_LOAD_COUNT 8 +#define GPPWM_NOTE_SIZE 16 +#define GPPWM_RPM_COUNT 8 +#define HIGH_SPEED_COUNT 32 +#define hpfp_cam_e_auto_enum 0="HPFP_CAM_NONE",2="HPFP_CAM_EX1",4="HPFP_CAM_EX2",1="HPFP_CAM_IN1",3="HPFP_CAM_IN2" +#define hpfp_cam_e_enum "NONE", "Intake 1", "Exhaust 1", "Intake 2", "Exhaust 2" +#define hpfp_cam_e_HPFP_CAM_EX1 2 +#define hpfp_cam_e_HPFP_CAM_EX2 4 +#define hpfp_cam_e_HPFP_CAM_IN1 1 +#define hpfp_cam_e_HPFP_CAM_IN2 3 +#define hpfp_cam_e_HPFP_CAM_NONE 0 +#define HPFP_COMPENSATION_SIZE 10 +#define HPFP_DEADTIME_SIZE 8 +#define HPFP_LOBE_PROFILE_SIZE 16 +#define HPFP_TARGET_SIZE 10 +#define HW_MAX_ADC_INDEX 17 +#define IAC_PID_MULT_SIZE 8 +#define IAT_CURVE_SIZE 16 +#define IDLE_ADVANCE_CURVE_SIZE 8 +#define idle_hardware_s_size 12 +#define idle_mode_e_auto_enum 0="IM_AUTO",1="IM_MANUAL" +#define idle_mode_e_IM_AUTO 0 +#define idle_mode_e_IM_MANUAL 1 +#define idle_state_e_BLIP 64 +#define idle_state_e_INIT 0 +#define idle_state_e_PID_UPPER 16 +#define idle_state_e_PID_VALUE 4 +#define idle_state_e_RPM_DEAD_ZONE 2 +#define idle_state_e_TPS_THRESHOLD 1 +#define IDLE_VE_SIZE 4 +#define IGN_BLEND_COUNT 4 +#define IGN_LOAD_COUNT 16 +#define IGN_RPM_COUNT 16 +#define ignition_mode_e_auto_enum 0="IM_ONE_COIL",1="IM_INDIVIDUAL_COILS",3="IM_TWO_COILS",2="IM_WASTED_SPARK" +#define ignition_mode_e_IM_INDIVIDUAL_COILS 1 +#define ignition_mode_e_IM_ONE_COIL 0 +#define ignition_mode_e_IM_TWO_COILS 3 +#define ignition_mode_e_IM_WASTED_SPARK 2 +#define imu_type_e_auto_enum 0="IMU_NONE",2="IMU_MM5_10",3="IMU_TYPE_3",4="IMU_TYPE_4",5="IMU_TYPE_MB_A0065422618",1="IMU_VAG" +#define imu_type_e_IMU_MM5_10 2 +#define imu_type_e_IMU_NONE 0 +#define imu_type_e_IMU_TYPE_3 3 +#define imu_type_e_IMU_TYPE_4 4 +#define imu_type_e_IMU_TYPE_MB_A0065422618 5 +#define imu_type_e_IMU_VAG 1 +#define INDICATOR_NAME_AC_SWITCH "AC switch" +#define INDICATOR_NAME_BRAKE_DOWN "brake: down" +#define INDICATOR_NAME_CLUTCH_DOWN "clutch: down" +#define INDICATOR_NAME_CLUTCH_UP "clutch: up" +#define injection_mode_e_auto_enum 0="IM_SIMULTANEOUS",2="IM_BATCH",1="IM_SEQUENTIAL",3="IM_SINGLE_POINT" +#define injection_mode_e_IM_BATCH 2 +#define injection_mode_e_IM_SEQUENTIAL 1 +#define injection_mode_e_IM_SIMULTANEOUS 0 +#define injection_mode_e_IM_SINGLE_POINT 3 +#define InjectionTimingMode_auto_enum 0="End",2="Center",1="Start" +#define InjectionTimingMode_Center 2 +#define InjectionTimingMode_End 0 +#define InjectionTimingMode_Start 1 +#define injector_compensation_mode_e_auto_enum 0="ICM_None",1="ICM_FixedRailPressure",2="ICM_SensedRailPressure" +#define injector_compensation_mode_e_ICM_FixedRailPressure 1 +#define injector_compensation_mode_e_ICM_None 0 +#define injector_compensation_mode_e_ICM_SensedRailPressure 2 +#define injector_pressure_type_e_auto_enum 0="IPT_Low",1="IPT_High" +#define injector_pressure_type_e_IPT_High 1 +#define injector_pressure_type_e_IPT_Low 0 +#define injector_s_size 68 +#define InjectorNonlinearMode_auto_enum 0="INJ_None",2="INJ_FordModel",1="INJ_PolynomialAdder" +#define InjectorNonlinearMode_INJ_FordModel 2 +#define InjectorNonlinearMode_INJ_None 0 +#define InjectorNonlinearMode_INJ_PolynomialAdder 1 +#define launchActivationMode_e_ALWAYS_ACTIVE_LAUNCH 2 +#define launchActivationMode_e_auto_enum 0="SWITCH_INPUT_LAUNCH",2="ALWAYS_ACTIVE_LAUNCH",1="CLUTCH_INPUT_LAUNCH" +#define launchActivationMode_e_CLUTCH_INPUT_LAUNCH 1 +#define launchActivationMode_e_enum "Launch Button", "Clutch Down Switch", "Always Active(Disabled By Speed)" +#define launchActivationMode_e_SWITCH_INPUT_LAUNCH 0 +#define linear_sensor_s_size 20 +#define load_override_e_AFR_AccPedal 3 +#define load_override_e_AFR_CylFilling 4 +#define load_override_e_AFR_MAP 1 +#define load_override_e_AFR_None 0 +#define load_override_e_AFR_Tps 2 +#define load_override_e_auto_enum 0="AFR_None",3="AFR_AccPedal",4="AFR_CylFilling",1="AFR_MAP",2="AFR_Tps" +#define load_override_e_enum "None", "MAP", "TPS", "Acc Pedal", "Cyl Filling %" +#define LOG_DELIMITER "`" +#define LOGIC_ANALYZER_CHANNEL_COUNT 4 +#define LUA_ANALOG_INPUT_COUNT 8 +#define LUA_DIGITAL_INPUT_COUNT 8 +#define LUA_GAUGE_COUNT 2 +#define LUA_PWM_COUNT 8 +#define LUA_SCRIPT_SIZE 8000 +#define MAF_DECODING_COUNT 256 +#define maf_sensor_type_e_auto_enum 0="CUSTOM",2="Bosch0280218004",1="Bosch0280218037",3="DensoTODO" +#define maf_sensor_type_e_Bosch0280218004 2 +#define maf_sensor_type_e_Bosch0280218037 1 +#define maf_sensor_type_e_CUSTOM 0 +#define maf_sensor_type_e_DensoTODO 3 +#define maf_sensor_type_e_enum "v0", "v1", "v2", "v3" +#define MAIN_HELP_URL "http://www.rusefi.com/" +#define MAP_ANGLE_SIZE 8 +#define MAP_sensor_config_s_size 140 +#define MAP_WINDOW_SIZE 8 +#define MAX_CYLINDER_COUNT 12 +#define MLQ_FIELD_HEADER_SIZE 89 +#define MLQ_HEADER_SIZE 24 +#define MOCK_PPS_POSITION_COMMAND "mock_pps_position" +#define MOCK_PPS_VOLTAGE_COMMAND "mock_pps_voltage" +#define NARROW_BAND_WIDE_BAND_CONVERSION_SIZE 8 +#define operation_mode_e_FOUR_STROKE_CAM_SENSOR 2 +#define operation_mode_e_FOUR_STROKE_CRANK_SENSOR 1 +#define operation_mode_e_FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR 4 +#define operation_mode_e_FOUR_STROKE_THREE_TIMES_CRANK_SENSOR 5 +#define operation_mode_e_FOUR_STROKE_TWELVE_TIMES_CRANK_SENSOR 6 +#define operation_mode_e_OM_NONE 0 +#define operation_mode_e_TWO_STROKE 3 +#define output_pin_e_enum "NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15", "MC33972_1", "MC33972_2", "MC33972_3", "MC33972_4", "MC33972_5", "MC33972_6", "MC33972_7", "MC33972_8", "MC33972_9", "MC33972_10", "MC33972_11", "MC33972_12", "MC33972_13", "MC33972_14", "MC33972_15", "MC33972_16", "MC33972_17", "MC33972_18", "MC33972_19", "MC33972_20", "MC33972_21", "MC33972_22", "TLE8888_1", "TLE8888_2", "TLE8888_3", "TLE8888_4", "TLE8888_5", "TLE8888_6", "TLE8888_7", "TLE8888_8", "TLE8888_9", "TLE8888_10", "TLE8888_11", "TLE8888_12", "TLE8888_13", "TLE8888_14", "TLE8888_15", "TLE8888_16", "TLE8888_17", "TLE8888_18", "TLE8888_19", "TLE8888_20", "TLE8888_21", "TLE8888_22", "TLE8888_23", "TLE8888_24", "TLE8888_25", "TLE8888_26", "TLE8888_27", "TLE8888_28", "INVALID", "INVALID", "INVALID", "TLE6240_1", "TLE6240_2", "TLE6240_3", "TLE6240_4", "TLE6240_5", "TLE6240_6", "TLE6240_7", "TLE6240_8", "TLE6240_9", "TLE6240_10", "TLE6240_11", "TLE6240_12", "TLE6240_13", "TLE6240_14", "TLE6240_15", "TLE6240_16" +#define PACK_ADD_TEMPERATURE 40 +#define PACK_MULT_AFR 1000 +#define PACK_MULT_AFR_CFG 10 +#define PACK_MULT_ANGLE 50 +#define PACK_MULT_FUEL_FLOW 200 +#define PACK_MULT_FUEL_MASS 100 +#define PACK_MULT_HIGH_PRESSURE 10 +#define PACK_MULT_LAMBDA 10000 +#define PACK_MULT_LAMBDA_CFG 147 +#define PACK_MULT_MASS_FLOW 10 +#define PACK_MULT_MS 300 +#define PACK_MULT_PERCENT 100 +#define PACK_MULT_PRESSURE 30 +#define PACK_MULT_TEMPERATURE 100 +#define PACK_MULT_VOLTAGE 1000 +#define PACK_PERCENT_BYTE_MULT 100.0 +#define PEDAL_TO_TPS_SIZE 8 +#define PERCENT_TRIM_BYTE_PACKING_DIV 0.02 +#define persistent_config_s_size 22432 +#define pid_s_size 20 +#define PidAutoTune_AutoTunerState_AUTOTUNER_OFF 0 +#define PidAutoTune_AutoTunerState_CONVERGED 16 +#define PidAutoTune_AutoTunerState_FAILED 128 +#define PidAutoTune_AutoTunerState_RELAY_STEP_DOWN 8 +#define PidAutoTune_AutoTunerState_RELAY_STEP_UP 4 +#define PidAutoTune_AutoTunerState_STEADY_STATE_AFTER_STEP_UP 2 +#define PidAutoTune_AutoTunerState_STEADY_STATE_AT_BASELINE 1 +#define PidAutoTune_Peak_MAXIMUM 1 +#define PidAutoTune_Peak_MINIMUM -1 +#define PidAutoTune_Peak_NOT_A_PEAK 0 +#define pin_input_mode_e_auto_enum 0="PI_DEFAULT",2="PI_PULLDOWN",1="PI_PULLUP" +#define pin_input_mode_e_enum "DEFAULT", "PULLUP", "PULLDOWN" +#define pin_input_mode_e_PI_DEFAULT 0 +#define pin_input_mode_e_PI_PULLDOWN 2 +#define pin_input_mode_e_PI_PULLUP 1 +#define pin_mode_e_auto_enum 0="PO_DEFAULT",4="PO_OPENDRAIN",64="PO_PULLDOWN",32="PO_PULLUP" +#define pin_mode_e_enum "default", "INVALID", "INVALID", "INVALID", "opendrain", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "PULLUP", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "PULLDOWN" +#define pin_mode_e_PO_DEFAULT 0 +#define pin_mode_e_PO_OPENDRAIN 4 +#define pin_mode_e_PO_PULLDOWN 64 +#define pin_mode_e_PO_PULLUP 32 +#define pin_output_mode_e_auto_enum 0="OM_DEFAULT",1="OM_INVERTED",2="OM_OPENDRAIN",3="OM_OPENDRAIN_INVERTED" +#define pin_output_mode_e_enum "default", "default inverted", "open collector", "open collector inverted" +#define pin_output_mode_e_OM_DEFAULT 0 +#define pin_output_mode_e_OM_INVERTED 1 +#define pin_output_mode_e_OM_OPENDRAIN 2 +#define pin_output_mode_e_OM_OPENDRAIN_INVERTED 3 +#define PROTOCOL_ANALOG_CHART "analog_chart" +#define PROTOCOL_COIL1_SHORT_NAME "c1" +#define PROTOCOL_CRANK1 "t1" +#define PROTOCOL_CRANK2 "t2" +#define PROTOCOL_ENGINE_SNIFFER "wave_chart" +#define PROTOCOL_ES_DOWN "d" +#define PROTOCOL_ES_UP "u" +#define PROTOCOL_HELLO_PREFIX "***" +#define PROTOCOL_HIP_NAME "HIP" +#define PROTOCOL_HPFP_NAME "hpfp" +#define PROTOCOL_INJ1_SHORT_NAME "i1" +#define PROTOCOL_MSG "msg" +#define PROTOCOL_OUTPIN "outpin" +#define PROTOCOL_SIGNATURE_PREFIX "rusEFI " +#define PROTOCOL_TACH_NAME "tach" +#define PROTOCOL_TEST_RESPONSE_TAG "ts_p_alive" +#define PROTOCOL_VERSION_TAG "rusEfiVersion" +#define PROTOCOL_VVT1_NAME "VVT1" +#define PROTOCOL_VVT2_NAME "VVT2" +#define PROTOCOL_VVT3_NAME "VVT3" +#define PROTOCOL_VVT4_NAME "VVT4" +#define PROTOCOL_WA_CHANNEL_1 "input1" +#define PROTOCOL_WA_CHANNEL_2 "input2" +#define PROTOCOL_WA_CHANNEL_3 "input3" +#define PROTOCOL_WA_CHANNEL_4 "input4" +#define SCRIPT_CURVE_16 16 +#define SCRIPT_CURVE_8 8 +#define SCRIPT_CURVE_COUNT 6 +#define SCRIPT_SETTING_COUNT 8 +#define SCRIPT_TABLE_8 8 +#define SCRIPT_TABLE_COUNT 4 +#define SelectedGear_Drive 6 +#define SelectedGear_Invalid 0 +#define SelectedGear_Low 11 +#define SelectedGear_Manual 7 +#define SelectedGear_Manual1 10 +#define SelectedGear_Manual2 9 +#define SelectedGear_Manual3 8 +#define SelectedGear_ManualMinus 2 +#define SelectedGear_ManualPlus 1 +#define SelectedGear_Neutral 5 +#define SelectedGear_Park 3 +#define SelectedGear_Reverse 4 +#define sensor_chart_e_auto_enum 0="SC_OFF",5="SC_AUX_FAST1",4="SC_DETAILED_RPM",3="SC_RPM_ACCEL",1="SC_TRIGGER" +#define sensor_chart_e_enum "none", "trigger", "INVALID", "RPM ACCEL", "DETAILED RPM", "Fast Aux1" +#define sensor_chart_e_SC_AUX_FAST1 5 +#define sensor_chart_e_SC_DETAILED_RPM 4 +#define sensor_chart_e_SC_OFF 0 +#define sensor_chart_e_SC_RPM_ACCEL 3 +#define sensor_chart_e_SC_TRIGGER 1 +#define SENT_INPUT_COUNT 1 +#define SentEtbType_auto_enum 0="NONE",2="FORD_TYPE_1",1="GM_TYPE_1" +#define SentEtbType_enum "None", "GM type 1", "Ford type 1" +#define SentEtbType_FORD_TYPE_1 2 +#define SentEtbType_GM_TYPE_1 1 +#define SentEtbType_NONE 0 +#define show_Frankenso_presets true +#define show_test_presets true +#define SIGNATURE_HASH 4145602307 +#define specs_s_size 12 +#define spi_device_e_auto_enum 0="SPI_NONE",1="SPI_DEVICE_1",2="SPI_DEVICE_2",3="SPI_DEVICE_3",4="SPI_DEVICE_4" +#define spi_device_e_SPI_DEVICE_1 1 +#define spi_device_e_SPI_DEVICE_2 2 +#define spi_device_e_SPI_DEVICE_3 3 +#define spi_device_e_SPI_DEVICE_4 4 +#define spi_device_e_SPI_NONE 0 +#define spi_pins_size 8 +#define spi_speed_e__150KHz 3 +#define spi_speed_e__1_25MHz 2 +#define spi_speed_e__2_5MHz 1 +#define spi_speed_e__5MHz 0 +#define stepper_num_micro_steps_e_auto_enum 0="STEPPER_FULL",8="STEPPER_EIGHTH",4="STEPPER_FOURTH",2="STEPPER_HALF" +#define stepper_num_micro_steps_e_enum "Full-Step (Default)", "INVALID", "Half-Step", "INVALID", "1/4 Micro-Step", "INVALID", "INVALID", "INVALID", "1/8 Micro-Step" +#define stepper_num_micro_steps_e_STEPPER_EIGHTH 8 +#define stepper_num_micro_steps_e_STEPPER_FOURTH 4 +#define stepper_num_micro_steps_e_STEPPER_FULL 0 +#define stepper_num_micro_steps_e_STEPPER_HALF 2 +#define STFT_BANK_COUNT 2 +#define stft_cell_cfg_s_size 4 +#define STFT_CELL_COUNT 4 +#define stft_s_size 24 +#define switch_input_pin_e_enum "NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15" +#define tChargeMode_e_auto_enum 0="TCHARGE_MODE_RPM_TPS",1="TCHARGE_MODE_AIR_INTERP",2="TCHARGE_MODE_AIR_INTERP_TABLE" +#define tChargeMode_e_enum "RPM+TPS (Default)", "Air Mass Interpolation", "Table" +#define tChargeMode_e_TCHARGE_MODE_AIR_INTERP 1 +#define tChargeMode_e_TCHARGE_MODE_AIR_INTERP_TABLE 2 +#define tChargeMode_e_TCHARGE_MODE_RPM_TPS 0 +#define TCU_GEAR_COUNT 10 +#define TCU_MAGIC_SIZE 8 +#define TCU_SOLENOID_COUNT 6 +#define thermistor_conf_s_size 28 +#define ThermistorConf_size 32 +#define timing_mode_e_auto_enum 0="TM_DYNAMIC",1="TM_FIXED" +#define timing_mode_e_TM_DYNAMIC 0 +#define timing_mode_e_TM_FIXED 1 +#define tle8888_mode_e_auto_enum 0="TL_AUTO",3="TL_HALL",2="TL_MANUAL",1="TL_SEMI_AUTO" +#define tle8888_mode_e_TL_AUTO 0 +#define tle8888_mode_e_TL_HALL 3 +#define tle8888_mode_e_TL_MANUAL 2 +#define tle8888_mode_e_TL_SEMI_AUTO 1 +#define TOOTH_DATA_LENGTH 2000 +#define TOOTH_PACKET_COUNT 1000 +#define TOOTH_PACKET_SIZE 2 +#define TOP_DEAD_CENTER_MESSAGE "r" +#define TORQUE_CURVE_SIZE 6 +#define TOTAL_CONFIG_SIZE 22432 +#define TPS_2_BYTE_PACKING_MULT 100 +#define TPS_TPS_ACCEL_CLT_CORR_TABLE 4 +#define TPS_TPS_ACCEL_TABLE 8 +#define transmission_controller_e_enum "None", "Simple Transmission", "GM 4L6X" +#define TransmissionControllerMode_auto_enum 0="None",2="Gm4l6x",1="SimpleTransmissionController" +#define TransmissionControllerMode_Gm4l6x 2 +#define TransmissionControllerMode_None 0 +#define TransmissionControllerMode_SimpleTransmissionController 1 +#define TRIGGER_COMMENT "#" +#define trigger_config_s_size 12 +#define TRIGGER_CRANK_BASED trigger_type == 2 || trigger_type == 5 || trigger_type == 10 || trigger_type == 12 || trigger_type == 20 || trigger_type == 21 || trigger_type == 26 || trigger_type == 27 || trigger_type == 33 || trigger_type == 38 || trigger_type == 39 || trigger_type == 44 || trigger_type == 45 || trigger_type == 46 || trigger_type == 53 || trigger_type == 55 || trigger_type == 57 || trigger_type == 58 || trigger_type == 61 || trigger_type == 62 || trigger_type == 68 || trigger_type == 70 || trigger_type == 71 || trigger_type == 72 || trigger_type == 74 +#define TRIGGER_CYCLE_DURATION "cycleDuration" +#define TRIGGER_GAP_FROM "gapFrom" +#define TRIGGER_GAP_TO "gapTo" +#define TRIGGER_GAPS_COUNT "gapsCount" +#define TRIGGER_HARDCODED_OPERATION_MODE "knownOperationMode" +#define TRIGGER_HAS_SECOND_CHANNEL "hasSecondChannel" +#define TRIGGER_INPUT_PIN_COUNT 2 +#define TRIGGER_IS_CRANK_KEY "crankBased" +#define TRIGGER_IS_SECOND_WHEEL_CAM "isSecondWheelCam" +#define TRIGGER_SIMULATOR_PIN_COUNT 2 +#define trigger_type_e_auto_enum 0="TT_TOOTHED_WHEEL",38="TT_12_TOOTH_CRANK",50="TT_1_16",25="TT_2JZ_3_34",70="TT_36_2_1",71="TT_36_2_1_1",23="TT_36_2_2_2",31="TT_3_1_CAM",20="TT_60_2_VW",21="TT_BENELLI_TRE",30="TT_CHRYSLER_NGC_36_2_2",6="TT_DAIHATSU",2="TT_DODGE_NEON_1995",39="TT_DODGE_NEON_1995_ONLY_CRANK",14="TT_DODGE_NEON_2003_CAM",32="TT_DODGE_NEON_2003_CRANK",19="TT_DODGE_RAM",22="TT_DODGE_STRATUS",41="TT_FIAT_IAW_P8",1="TT_FORD_ASPIRE",42="TT_FORD_ST170",65="TT_FORD_TFI_PIP",27="TT_GM_24x",74="TT_GM_24x_2",54="TT_GM_60_2_2_2",5="TT_GM_7X",28="TT_HONDA_CBR_600",67="TT_HONDA_K_CAM_4_1",46="TT_HONDA_K_CRANK_12_1",37="TT_JEEP_18_2_2_2",40="TT_JEEP_4_CYL",57="TT_KAWA_KX450F",15="TT_MAZDA_DOHC_1_4",3="TT_MAZDA_MIATA_NA",35="TT_MAZDA_MIATA_VVT_TEST",7="TT_MAZDA_SOHC_4",10="TT_MERCEDES_2_SEGMENT",33="TT_MIATA_VVT",11="TT_MITSUBISHI_4G93",4="TT_MITSUBISHI_MESS",34="TT_MITSU_4G63_CAM",29="TT_MITSU_4G9x_CAM",52="TT_NISSAN_MR18_CAM_VVT",68="TT_NISSAN_MR18_CRANK",61="TT_NISSAN_QR25",24="TT_NISSAN_SR20VE",60="TT_NISSAN_VQ30",58="TT_NISSAN_VQ35",18="TT_ONE",16="TT_ONE_PLUS_ONE",44="TT_RENIX_44_2_2",45="TT_RENIX_66_2_2_2",26="TT_ROVER_K",55="TT_SKODA_FAVORIT",36="TT_SUBARU_7_6",51="TT_SUBARU_7_WITHOUT_6",12="TT_SUBARU_EZ30",49="TT_SUBARU_SVX",64="TT_SUBARU_SVX_CAM_VVT",63="TT_SUBARU_SVX_CRANK_1",66="TT_SUZUKI_G13B",69="TT_TOOTHED_WHEEL_32_2",9="TT_TOOTHED_WHEEL_36_1",48="TT_TOOTHED_WHEEL_36_2",8="TT_TOOTHED_WHEEL_60_2",53="TT_TRI_TACH",75="TT_UNUSED",56="TT_VVT_BARRA_3_PLUS_1",47="TT_VVT_BOSCH_QUICK_START",17="TT_VVT_JZ",13="TT_VVT_MAZDA_SKYACTIV",43="TT_VVT_MIATA_NB",62="TT_VVT_MITSUBISHI_3A92",72="TT_VVT_MITSUBISHI_6G75",59="TT_VVT_NISSAN_VQ35",73="TT_VVT_TOYOTA_4_1" +#define trigger_type_e_enum "custom toothed wheel", "Ford Aspire", "Dodge Neon 1995", "Miata NA", "Mitsubishi Mess 4", "GM_7X", "Cooper R50", "Mazda SOHC 4", "60/2", "36/1", "Mercedes Two Segment", "Mitsubishi 4G93 11", "EZ30", "INVALID", "Dodge Neon 2003", "Mazda DOHC 1+4", "1+1", "INVALID", "Single Tooth", "Dodge Ram 1+16", "60/2 VW", "Benelli Tre", "Dodge Stratus", "36_2_2_2", "Nissan Primera", "dev 2JZ 3/34 simulator", "Rover K", "GM 24x 5 degree", "Honda CBR 600", "Mitsubishi 4G92/93/94 Cam 29", "Honda CBR 600 custom", "3/1 skipped", "Dodge Neon 2003 crank", "Miata NB", "Mitsubishi 4G63 Cam 34", "INVALID", "Subaru 7+6", "Jeep 18-2-2-2", "12 tooth crank", "Dodge Neon 1995 crank only", "Jeep XJ 4 cyl", "FiatIAQ_P8", "Mazda Z5", "INVALID", "Renix 44-2-2", "Renix 66-2-2-2", "Honda K 12+1", "INVALID", "36/2", "Subaru SVX", "1+16", "Subaru 7 without 6", "INVALID", "TriTach", "GM 60/2/2/2", "Skoda Favorit", "Barra 3+1 Cam", "Kawa KX450F", "Nissan VQ35", "INVALID", "Nissan VQ30", "Nissan QR25", "Mitsubishi 3A92", "Subaru SVX Crank 1", "Subaru SVX Cam VVT", "Ford PIP", "Suzuki G13B", "Honda K 4+1", "Nissan MR18 Crank", "32/2", "36-2-1", "36-2-1-1", "INVALID", "INVALID", "GM 24x 3 degree", "trg75" +#define trigger_type_e_Force_4_bytes_size_trigger_type 70000 +#define trigger_type_e_TT_12_TOOTH_CRANK 38 +#define trigger_type_e_TT_1_16 50 +#define trigger_type_e_TT_2JZ_3_34 25 +#define trigger_type_e_TT_36_2_1 70 +#define trigger_type_e_TT_36_2_1_1 71 +#define trigger_type_e_TT_36_2_2_2 23 +#define trigger_type_e_TT_3_1_CAM 31 +#define trigger_type_e_TT_60_2_VW 20 +#define trigger_type_e_TT_BENELLI_TRE 21 +#define trigger_type_e_TT_CHRYSLER_NGC_36_2_2 30 +#define trigger_type_e_TT_DAIHATSU 6 +#define trigger_type_e_TT_DODGE_NEON_1995 2 +#define trigger_type_e_TT_DODGE_NEON_1995_ONLY_CRANK 39 +#define trigger_type_e_TT_DODGE_NEON_2003_CAM 14 +#define trigger_type_e_TT_DODGE_NEON_2003_CRANK 32 +#define trigger_type_e_TT_DODGE_RAM 19 +#define trigger_type_e_TT_DODGE_STRATUS 22 +#define trigger_type_e_TT_FIAT_IAW_P8 41 +#define trigger_type_e_TT_FORD_ASPIRE 1 +#define trigger_type_e_TT_FORD_ST170 42 +#define trigger_type_e_TT_FORD_TFI_PIP 65 +#define trigger_type_e_TT_GM_24x 27 +#define trigger_type_e_TT_GM_24x_2 74 +#define trigger_type_e_TT_GM_60_2_2_2 54 +#define trigger_type_e_TT_GM_7X 5 +#define trigger_type_e_TT_HONDA_CBR_600 28 +#define trigger_type_e_TT_HONDA_K_CAM_4_1 67 +#define trigger_type_e_TT_HONDA_K_CRANK_12_1 46 +#define trigger_type_e_TT_JEEP_18_2_2_2 37 +#define trigger_type_e_TT_JEEP_4_CYL 40 +#define trigger_type_e_TT_KAWA_KX450F 57 +#define trigger_type_e_TT_MAZDA_DOHC_1_4 15 +#define trigger_type_e_TT_MAZDA_MIATA_NA 3 +#define trigger_type_e_TT_MAZDA_MIATA_VVT_TEST 35 +#define trigger_type_e_TT_MAZDA_SOHC_4 7 +#define trigger_type_e_TT_MERCEDES_2_SEGMENT 10 +#define trigger_type_e_TT_MIATA_VVT 33 +#define trigger_type_e_TT_MITSU_4G63_CAM 34 +#define trigger_type_e_TT_MITSU_4G9x_CAM 29 +#define trigger_type_e_TT_MITSUBISHI_4G93 11 +#define trigger_type_e_TT_MITSUBISHI_MESS 4 +#define trigger_type_e_TT_NISSAN_MR18_CAM_VVT 52 +#define trigger_type_e_TT_NISSAN_MR18_CRANK 68 +#define trigger_type_e_TT_NISSAN_QR25 61 +#define trigger_type_e_TT_NISSAN_SR20VE 24 +#define trigger_type_e_TT_NISSAN_VQ30 60 +#define trigger_type_e_TT_NISSAN_VQ35 58 +#define trigger_type_e_TT_ONE 18 +#define trigger_type_e_TT_ONE_PLUS_ONE 16 +#define trigger_type_e_TT_RENIX_44_2_2 44 +#define trigger_type_e_TT_RENIX_66_2_2_2 45 +#define trigger_type_e_TT_ROVER_K 26 +#define trigger_type_e_TT_SKODA_FAVORIT 55 +#define trigger_type_e_TT_SUBARU_7_6 36 +#define trigger_type_e_TT_SUBARU_7_WITHOUT_6 51 +#define trigger_type_e_TT_SUBARU_EZ30 12 +#define trigger_type_e_TT_SUBARU_SVX 49 +#define trigger_type_e_TT_SUBARU_SVX_CAM_VVT 64 +#define trigger_type_e_TT_SUBARU_SVX_CRANK_1 63 +#define trigger_type_e_TT_SUZUKI_G13B 66 +#define trigger_type_e_TT_TOOTHED_WHEEL 0 +#define trigger_type_e_TT_TOOTHED_WHEEL_32_2 69 +#define trigger_type_e_TT_TOOTHED_WHEEL_36_1 9 +#define trigger_type_e_TT_TOOTHED_WHEEL_36_2 48 +#define trigger_type_e_TT_TOOTHED_WHEEL_60_2 8 +#define trigger_type_e_TT_TRI_TACH 53 +#define trigger_type_e_TT_UNUSED 75 +#define trigger_type_e_TT_VVT_BARRA_3_PLUS_1 56 +#define trigger_type_e_TT_VVT_BOSCH_QUICK_START 47 +#define trigger_type_e_TT_VVT_JZ 17 +#define trigger_type_e_TT_VVT_MAZDA_SKYACTIV 13 +#define trigger_type_e_TT_VVT_MIATA_NB 43 +#define trigger_type_e_TT_VVT_MITSUBISHI_3A92 62 +#define trigger_type_e_TT_VVT_MITSUBISHI_6G75 72 +#define trigger_type_e_TT_VVT_NISSAN_VQ35 59 +#define trigger_type_e_TT_VVT_TOYOTA_4_1 73 +#define TRIGGER_TYPE_WITH_SECOND_WHEEL trigger_type == 1 || trigger_type == 3 || trigger_type == 11 || trigger_type == 15 || trigger_type == 16 || trigger_type == 19 || trigger_type == 25 || trigger_type == 28 || trigger_type == 31 || trigger_type == 35 || trigger_type == 36 || trigger_type == 37 || trigger_type == 40 || trigger_type == 49 || trigger_type == 50 || trigger_type == 53 || trigger_type == 54 || trigger_type == 63 || trigger_type == 64 +#define TRIGGER_TYPE_WITHOUT_KNOWN_LOCATION trigger_type == 8 || trigger_type == 9 || trigger_type == 17 || trigger_type == 18 || trigger_type == 23 || trigger_type == 48 || trigger_type == 69 || trigger_type == 73 +#define TRIGGER_WITH_SYNC "isSynchronizationNeeded" +#define TRIGGERS_FILE_NAME "triggers.txt" +#define TriggerWheel_T_PRIMARY 0 +#define TriggerWheel_T_SECONDARY 1 +#define TRIM_SIZE 4 +#define TS_BLOCK_READ_TIMEOUT 3000 +#define TS_BURN_COMMAND 'B' +#define TS_BURN_COMMAND_char B +#define TS_CHUNK_WRITE_COMMAND 'C' +#define TS_CHUNK_WRITE_COMMAND_char C +#define ts_command_e_TS_BENCH_CATEGORY 22 +#define ts_command_e_TS_CLEAR_WARNINGS 17 +#define ts_command_e_TS_COMMAND_1 1 +#define ts_command_e_TS_COMMAND_11 11 +#define ts_command_e_TS_COMMAND_12 12 +#define ts_command_e_TS_COMMAND_13 13 +#define ts_command_e_TS_COMMAND_14 14 +#define ts_command_e_TS_COMMAND_15 15 +#define ts_command_e_TS_COMMAND_16 16 +#define ts_command_e_TS_COMMAND_4 4 +#define ts_command_e_TS_COMMAND_5 5 +#define ts_command_e_TS_COMMAND_9 9 +#define ts_command_e_TS_DEBUG_MODE 0 +#define ts_command_e_TS_GRAB_PEDAL_UP 6 +#define ts_command_e_TS_GRAB_PEDAL_WOT 7 +#define ts_command_e_TS_GRAB_TPS_CLOSED 2 +#define ts_command_e_TS_GRAB_TPS_WOT 3 +#define ts_command_e_TS_IGNITION_CATEGORY 18 +#define ts_command_e_TS_INJECTOR_CATEGORY 19 +#define ts_command_e_TS_LUA_OUTPUT_CATEGORY 32 +#define ts_command_e_TS_RESET_TLE8888 8 +#define ts_command_e_TS_SET_DEFAULT_ENGINE 31 +#define ts_command_e_TS_SET_ENGINE_TYPE 30 +#define ts_command_e_TS_SOLENOID_CATEGORY 25 +#define ts_command_e_TS_UNUSED_23 23 +#define ts_command_e_TS_UNUSED_26 26 +#define ts_command_e_TS_UNUSED_27 27 +#define ts_command_e_TS_UNUSED_28 28 +#define ts_command_e_TS_UNUSED_29 29 +#define ts_command_e_TS_UNUSED_CJ125_CALIB 24 +#define ts_command_e_TS_WIDEBAND 21 +#define ts_command_e_TS_WRITE_FLASH 10 +#define ts_command_e_TS_X14 20 +#define TS_COMMAND_F 'F' +#define TS_COMMAND_F_char F +#define TS_COMPOSITE_DISABLE 2 +#define TS_COMPOSITE_ENABLE 1 +#define TS_COMPOSITE_READ 3 +#define TS_CRC_CHECK_COMMAND 'k' +#define TS_CRC_CHECK_COMMAND_char k +#define TS_EXECUTE 'E' +#define TS_EXECUTE_char E +#define TS_FILE_VERSION 20210312 +#define TS_FILE_VERSION_OFFSET 124 +#define TS_GET_COMPOSITE_BUFFER_DONE_DIFFERENTLY '8' +#define TS_GET_COMPOSITE_BUFFER_DONE_DIFFERENTLY_char 8 +#define TS_GET_CONFIG_ERROR 'e' +#define TS_GET_CONFIG_ERROR_char e +#define TS_GET_FIRMWARE_VERSION 'V' +#define TS_GET_FIRMWARE_VERSION_char V +#define TS_GET_OUTPUTS_SIZE '4' +#define TS_GET_OUTPUTS_SIZE_char 4 +#define TS_GET_PROTOCOL_VERSION_COMMAND_F 'F' +#define TS_GET_PROTOCOL_VERSION_COMMAND_F_char F +#define TS_GET_SCATTERED_GET_COMMAND '9' +#define TS_GET_SCATTERED_GET_COMMAND_char 9 +#define TS_GET_TEXT 'G' +#define TS_GET_TEXT_char G +#define TS_HELLO_COMMAND 'S' +#define TS_HELLO_COMMAND_char S +#define TS_IO_TEST_COMMAND 'Z' +#define TS_IO_TEST_COMMAND_char Z +#define TS_ONLINE_PROTOCOL 'z' +#define TS_ONLINE_PROTOCOL_char z +#define TS_OUTPUT_COMMAND 'O' +#define TS_OUTPUT_COMMAND_char O +#define TS_PAGE_COMMAND 'P' +#define TS_PAGE_COMMAND_char P +#define TS_PERF_TRACE_BEGIN '_' +#define TS_PERF_TRACE_BEGIN_char _ +#define TS_PERF_TRACE_GET_BUFFER 'b' +#define TS_PERF_TRACE_GET_BUFFER_char b +#define TS_PROTOCOL "001" +#define TS_QUERY_COMMAND 'Q' +#define TS_QUERY_COMMAND_char Q +#define TS_READ_COMMAND 'R' +#define TS_READ_COMMAND_char R +#define TS_RESPONSE_BURN_OK 4 +#define TS_RESPONSE_COMMAND_OK 7 +#define TS_RESPONSE_CRC_FAILURE 0x82 +#define TS_RESPONSE_FRAMING_ERROR 0x8D +#define TS_RESPONSE_OK 0 +#define TS_RESPONSE_OUT_OF_RANGE 0x84 +#define TS_RESPONSE_UNDERRUN 0x80 +#define TS_RESPONSE_UNRECOGNIZED_COMMAND 0x83 +#define TS_SET_LOGGER_SWITCH 'l' +#define TS_SET_LOGGER_SWITCH_char l +#define ts_show_analog_divider true +#define ts_show_auxserial_pins true +#define ts_show_can2 true +#define ts_show_can_pins true +#define ts_show_cj125 true +#define ts_show_clt_iat_pullup true +#define ts_show_critical_led true +#define ts_show_egt true +#define ts_show_etb true +#define ts_show_etb_pins true +#define ts_show_full_pinout true +#define ts_show_gps true +#define ts_show_hardware_simulator true +#define ts_show_hip9011 true +#define ts_show_ignitionPinMode true +#define ts_show_injectionPinMode true +#define ts_show_joystick true +#define ts_show_lcd true +#define ts_show_main_relay true +#define ts_show_main_relay_microRusEFI_message false +#define ts_show_sd_card true +#define ts_show_sd_pins true +#define ts_show_software_knock false +#define ts_show_spi true +#define ts_show_trigger_comparator false +#define ts_show_tunerstudio_port true +#define ts_show_vbatt true +#define ts_show_vr_threshold_2 true +#define ts_show_vr_threshold_all true +#define TS_SIGNATURE "rusEFI (FOME) master.2023.02.21.f407-discovery.4145602307" +#define TS_SINGLE_WRITE_COMMAND 'W' +#define TS_SINGLE_WRITE_COMMAND_char W +#define TS_TEST_COMMAND 't' +#define TS_TEST_COMMAND_char t +#define TS_TOTAL_OUTPUT_SIZE 1356 +#define TS_TRIGGER_SCOPE_CHANNEL_1_NAME "Channel 1" +#define TS_TRIGGER_SCOPE_CHANNEL_2_NAME "Channel 2" +#define TS_TRIGGER_SCOPE_DISABLE 5 +#define TS_TRIGGER_SCOPE_ENABLE 4 +#define TS_TRIGGER_SCOPE_READ 6 +#define TsCalMode_EtbKd 5 +#define TsCalMode_EtbKi 4 +#define TsCalMode_EtbKp 3 +#define TsCalMode_None 0 +#define TsCalMode_PedalMax 13 +#define TsCalMode_PedalMin 12 +#define TsCalMode_Tps1Max 1 +#define TsCalMode_Tps1Min 2 +#define TsCalMode_Tps1SecondaryMax 6 +#define TsCalMode_Tps1SecondaryMin 7 +#define TsCalMode_Tps2Max 8 +#define TsCalMode_Tps2Min 9 +#define TsCalMode_Tps2SecondaryMax 10 +#define TsCalMode_Tps2SecondaryMin 11 +#define uart_device_e_auto_enum 0="UART_NONE",1="UART_DEVICE_1",2="UART_DEVICE_2",3="UART_DEVICE_3",4="UART_DEVICE_4" +#define uart_device_e_UART_DEVICE_1 1 +#define uart_device_e_UART_DEVICE_2 2 +#define uart_device_e_UART_DEVICE_3 3 +#define uart_device_e_UART_DEVICE_4 4 +#define uart_device_e_UART_NONE 0 +#define VBAT_INJECTOR_CURVE_SIZE 8 +#define VE_BLEND_COUNT 4 +#define ve_override_e_auto_enum 0="VE_None",1="VE_MAP",2="VE_TPS" +#define ve_override_e_enum "None", "MAP", "TPS" +#define ve_override_e_VE_MAP 1 +#define ve_override_e_VE_None 0 +#define ve_override_e_VE_TPS 2 +#define VEHICLE_INFO_SIZE 32 +#define VIN_NUMBER_SIZE 17 +#define VM_VVT_INACTIVE 0 +#define VOLTAGE_1_BYTE_PACKING_DIV 0.02 +#define VR_THRESHOLD_COUNT 2 +#define vr_threshold_s_size 16 +#define vvt_mode_e_auto_enum 0="VVT_INACTIVE",2="VVT_2JZ",8="VVT_BARRA_3_PLUS_1",5="VVT_BOSCH_QUICK_START",4="VVT_FIRST_HALF",7="VVT_FORD_ST170",16="VVT_HONDA_K_EXHAUST",10="VVT_HONDA_K_INTAKE",13="VVT_MAP_V_TWIN",15="VVT_MAZDA_SKYACTIV",3="VVT_MIATA_NB",12="VVT_MITSUBISHI_3A92",18="VVT_MITSUBISHI_4G63",17="VVT_MITSUBISHI_4G9x",14="VVT_MITSUBISHI_6G75",11="VVT_NISSAN_MR",9="VVT_NISSAN_VQ",1="VVT_SECOND_HALF",6="VVT_TOYOTA_4_1" +#define vvt_mode_e_enum "Inactive", "Single Tooth Second Half", "2JZ", "Miata NB2", "Single Tooth First Half", "Bosch Quick Start", "4/1", "ST 170", "Ford Barra 3+1", "Nissan VQ", "Honda K Intake", "Nissan MR18", "Mitsu 3A92", "VTwin by MAP", "Mitsu 6G75", "Mazda Skyactiv", "Honda K Exhaust", "Mitsubishi 4G92/93/94", "Mitsubishi 4G63" +#define vvt_mode_e_VVT_2JZ 2 +#define vvt_mode_e_VVT_BARRA_3_PLUS_1 8 +#define vvt_mode_e_VVT_BOSCH_QUICK_START 5 +#define vvt_mode_e_VVT_FIRST_HALF 4 +#define vvt_mode_e_VVT_FORD_ST170 7 +#define vvt_mode_e_VVT_HONDA_K_EXHAUST 16 +#define vvt_mode_e_VVT_HONDA_K_INTAKE 10 +#define vvt_mode_e_VVT_INACTIVE 0 +#define vvt_mode_e_VVT_MAP_V_TWIN 13 +#define vvt_mode_e_VVT_MAZDA_SKYACTIV 15 +#define vvt_mode_e_VVT_MIATA_NB 3 +#define vvt_mode_e_VVT_MITSUBISHI_3A92 12 +#define vvt_mode_e_VVT_MITSUBISHI_4G63 18 +#define vvt_mode_e_VVT_MITSUBISHI_4G9x 17 +#define vvt_mode_e_VVT_MITSUBISHI_6G75 14 +#define vvt_mode_e_VVT_NISSAN_MR 11 +#define vvt_mode_e_VVT_NISSAN_VQ 9 +#define vvt_mode_e_VVT_SECOND_HALF 1 +#define vvt_mode_e_VVT_TOYOTA_4_1 6 +#define WWAE_TABLE_SIZE 8 diff --git a/java_console/models/src/main/java/com/rusefi/config/generated/Fields.java b/java_console/models/src/main/java/com/rusefi/config/generated/Fields.java new file mode 100644 index 0000000000..cf8a16d5bb --- /dev/null +++ b/java_console/models/src/main/java/com/rusefi/config/generated/Fields.java @@ -0,0 +1,4187 @@ +package com.rusefi.config.generated; + +// this file was generated automatically by rusEFI tool ConfigDefinition.jar based on gen_config.sh integration/rusefi_config.txt Mon Feb 20 21:09:11 PST 2023 + +// by class com.rusefi.output.FileJavaFieldsConsumer +import com.rusefi.config.*; + +public class Fields { + public static final int adc_channel_e_EFI_ADC_0 = 1; + public static final int adc_channel_e_EFI_ADC_1 = 2; + public static final int adc_channel_e_EFI_ADC_10 = 11; + public static final int adc_channel_e_EFI_ADC_11 = 12; + public static final int adc_channel_e_EFI_ADC_12 = 13; + public static final int adc_channel_e_EFI_ADC_13 = 14; + public static final int adc_channel_e_EFI_ADC_14 = 15; + public static final int adc_channel_e_EFI_ADC_15 = 16; + public static final int adc_channel_e_EFI_ADC_16 = 17; + public static final int adc_channel_e_EFI_ADC_17 = 18; + public static final int adc_channel_e_EFI_ADC_18 = 19; + public static final int adc_channel_e_EFI_ADC_19 = 20; + public static final int adc_channel_e_EFI_ADC_2 = 3; + public static final int adc_channel_e_EFI_ADC_20 = 21; + public static final int adc_channel_e_EFI_ADC_21 = 22; + public static final int adc_channel_e_EFI_ADC_22 = 23; + public static final int adc_channel_e_EFI_ADC_23 = 24; + public static final int adc_channel_e_EFI_ADC_24 = 25; + public static final int adc_channel_e_EFI_ADC_25 = 26; + public static final int adc_channel_e_EFI_ADC_26 = 27; + public static final int adc_channel_e_EFI_ADC_27 = 28; + public static final int adc_channel_e_EFI_ADC_28 = 29; + public static final int adc_channel_e_EFI_ADC_29 = 30; + public static final int adc_channel_e_EFI_ADC_3 = 4; + public static final int adc_channel_e_EFI_ADC_30 = 31; + public static final int adc_channel_e_EFI_ADC_31 = 32; + public static final int adc_channel_e_EFI_ADC_4 = 5; + public static final int adc_channel_e_EFI_ADC_5 = 6; + public static final int adc_channel_e_EFI_ADC_6 = 7; + public static final int adc_channel_e_EFI_ADC_7 = 8; + public static final int adc_channel_e_EFI_ADC_8 = 9; + public static final int adc_channel_e_EFI_ADC_9 = 10; + public static final int adc_channel_e_EFI_ADC_ERROR = 50; + public static final int adc_channel_e_EFI_ADC_LAST_CHANNEL = 33; + public static final int adc_channel_e_EFI_ADC_NONE = 0; + public static final int ADC_CHANNEL_NONE = 0; + public static final int afr_sensor_s_size = 20; + public static final int AFTERSTART_DECAY_CURVE_SIZE = 8; + public static final int AFTERSTART_ENRICH_CURVE_SIZE = 8; + public static final int AFTERSTART_HOLD_CURVE_SIZE = 8; + public static final int air_pressure_sensor_config_s_size = 12; + public static final int air_pressure_sensor_type_e_MT_BOSCH_2_5 = 10; + public static final int air_pressure_sensor_type_e_MT_CUSTOM = 0; + public static final int air_pressure_sensor_type_e_MT_DENSO183 = 1; + public static final int air_pressure_sensor_type_e_MT_DODGE_NEON_2003 = 4; + public static final int air_pressure_sensor_type_e_MT_GM_1_BAR = 13; + public static final int air_pressure_sensor_type_e_MT_GM_2_BAR = 12; + public static final int air_pressure_sensor_type_e_MT_GM_3_BAR = 6; + public static final int air_pressure_sensor_type_e_MT_HONDA3BAR = 3; + public static final int air_pressure_sensor_type_e_MT_MAZDA_1_BAR = 11; + public static final int air_pressure_sensor_type_e_MT_MPX4100 = 7; + public static final int air_pressure_sensor_type_e_MT_MPX4250 = 2; + public static final int air_pressure_sensor_type_e_MT_MPX4250A = 9; + public static final int air_pressure_sensor_type_e_MT_MPXH6400 = 14; + public static final int air_pressure_sensor_type_e_MT_SUBY_DENSO = 5; + public static final int air_pressure_sensor_type_e_MT_TOYOTA_89420_02010 = 8; + public static final int antiLagActivationMode_e_ALWAYS_ON_ANTILAG = 1; + public static final int antiLagActivationMode_e_SWITCH_INPUT_ANTILAG = 0; + public static final int AUX_DIGITAL_VALVE_COUNT = 2; + public static final int BANKS_COUNT = 2; + public static final int BARO_CORR_SIZE = 4; + public static final int bench_mode_e_BENCH_AC_COMPRESSOR_RELAY = 6; + public static final int bench_mode_e_BENCH_CHECK_ENGINE_LIGHT = 7; + public static final int bench_mode_e_BENCH_FAN_RELAY = 4; + public static final int bench_mode_e_BENCH_FAN_RELAY_2 = 5; + public static final int bench_mode_e_BENCH_FUEL_PUMP = 1; + public static final int bench_mode_e_BENCH_GPPWM1_VALVE = 10; + public static final int bench_mode_e_BENCH_GPPWM2_VALVE = 11; + public static final int bench_mode_e_BENCH_GPPWM3_VALVE = 12; + public static final int bench_mode_e_BENCH_GPPWM4_VALVE = 13; + public static final int bench_mode_e_BENCH_HPFP_VALVE = 9; + public static final int bench_mode_e_BENCH_IDLE_VALVE = 8; + public static final int bench_mode_e_BENCH_MAIN_RELAY = 0; + public static final int bench_mode_e_BENCH_SECOND_IDLE_VALVE = 14; + public static final int bench_mode_e_BENCH_STARTER_DISABLE_RELAY = 3; + public static final int bench_mode_e_BENCH_STARTER_ENABLE_RELAY = 2; + public static final int blend_table_s_size = 188; + public static final int BLOCKING_FACTOR = 750; + public static final int BOOST_LOAD_COUNT = 8; + public static final int BOOST_RPM_COUNT = 8; + public static final int boostType_e_CLOSED_LOOP = 1; + public static final int boostType_e_OPEN_LOOP = 0; + public static final int brain_pin_diag_e_PIN_DRIVER_OFF = 0x20; + public static final int brain_pin_diag_e_PIN_DRIVER_OVERTEMP = 0x10; + public static final int brain_pin_diag_e_PIN_INVALID = 0x80; + public static final int brain_pin_diag_e_PIN_OK = 0; + public static final int brain_pin_diag_e_PIN_OPEN = 0x01; + public static final int brain_pin_diag_e_PIN_OVERLOAD = 0x08; + public static final int brain_pin_diag_e_PIN_SHORT_TO_BAT = 0x04; + public static final int brain_pin_diag_e_PIN_SHORT_TO_GND = 0x02; + public static final int CAM_INPUTS_COUNT = 4; + public static final int CAMS_PER_BANK = 2; + public static final int can_baudrate_e_B100KBPS = 2; + public static final int can_baudrate_e_B125KBPS = 3; + public static final int can_baudrate_e_B1MBPS = 6; + public static final int can_baudrate_e_B250KBPS = 4; + public static final int can_baudrate_e_B500KBPS = 5; + public static final int can_baudrate_e_B50KBPS = 0; + public static final int can_baudrate_e_B83KBPS = 1; + public static final int CAN_DEFAULT_BASE = 0x200; + public static final int CAN_ECU_HW_META = 0xAB1234; + public static final int CAN_ECU_SERIAL_RX_ID = 0x100; + public static final int CAN_ECU_SERIAL_TX_ID = 0x102; + public static final int can_nbc_e_CAN_AIM_DASH = 12; + public static final int can_nbc_e_CAN_BUS_BMW_E90 = 6; + public static final int can_nbc_e_CAN_BUS_GENESIS_COUPE = 10; + public static final int can_nbc_e_CAN_BUS_Haltech = 7; + public static final int can_nbc_e_CAN_BUS_HONDA_K = 11; + public static final int can_nbc_e_CAN_BUS_MAZDA_RX8 = 3; + public static final int can_nbc_e_CAN_BUS_MQB = 8; + public static final int can_nbc_e_CAN_BUS_NBC_BMW = 4; + public static final int can_nbc_e_CAN_BUS_NBC_FIAT = 1; + public static final int can_nbc_e_CAN_BUS_NBC_NONE = 0; + public static final int can_nbc_e_CAN_BUS_NBC_VAG = 2; + public static final int can_nbc_e_CAN_BUS_NISSAN_VQ = 9; + public static final int can_nbc_e_CAN_BUS_W202_C180 = 5; + public static final String CAN_RX_PREFIX = "CAN_rx"; + public static final int can_vss_nbc_e_BMW_e46 = 0; + public static final int can_vss_nbc_e_W202 = 1; + public static final int CLT_CRANKING_CURVE_SIZE = 8; + public static final int CLT_CURVE_SIZE = 16; + public static final int CLT_LIMITER_CURVE_SIZE = 4; + public static final int CLT_TIMING_CURVE_SIZE = 8; + public static final String CMD_AC_RELAY_BENCH = "acrelaybench"; + public static final String CMD_ALTERNATOR_PIN = "set_alternator_pin"; + public static final String CMD_BOOST_PIN = "set_boost_pin"; + public static final String CMD_BURNCONFIG = "burnconfig"; + public static final String CMD_DATE = "date"; + public static final String CMD_DISABLE = "disable"; + public static final String CMD_ECU_UNLOCK = "unlock"; + public static final String CMD_ENABLE = "enable"; + public static final String CMD_ENGINE_TYPE = "engine_type"; + public static final String CMD_ENGINESNIFFERRPMTHRESHOLD = "engineSnifferRpmThreshold"; + public static final String CMD_ETB_DUTY = "set_etb_duty"; + public static final String CMD_EXTERNAL_STIMULATION = "ext_stimulation"; + public static final String CMD_FAN2_BENCH = "fan2bench"; + public static final String CMD_FAN_BENCH = "fanbench"; + public static final String CMD_FUEL_BENCH = "fuelbench"; + public static final String CMD_FUEL_PUMP_BENCH = "fuelpumpbench"; + public static final String CMD_FUNCTIONAL_TEST_MODE = "test_mode"; + public static final String CMD_GET = "get"; + public static final String CMD_HPFP_BENCH = "hpfpbench"; + public static final String CMD_IDLE_BENCH = "idlebench"; + public static final String CMD_IDLE_PIN = "set_idle_pin"; + public static final String CMD_IGNITION = "ignition"; + public static final String CMD_IGNITION_PIN = "set_ignition_pin"; + public static final String CMD_INJECTION = "injection"; + public static final String CMD_INJECTION_PIN = "set_injection_pin"; + public static final String CMD_LOGIC_PIN = "set_logic_input_pin"; + public static final String CMD_MIL_BENCH = "milbench"; + public static final String CMD_PINS = "pins"; + public static final String CMD_PWM = "pwm"; + public static final String CMD_REBOOT = "reboot"; + public static final String CMD_REBOOT_DFU = "reboot_dfu"; + public static final String CMD_REBOOT_OPENBLT = "reboot_openblt"; + public static final String CMD_RESET_ENGINE_SNIFFER = "reset_engine_chart"; + public static final String CMD_RPM = "rpm"; + public static final String CMD_SELF_STIMULATION = "self_stimulation"; + public static final String CMD_SET = "set"; + public static final String CMD_SPARK_BENCH = "sparkbench"; + public static final String CMD_STARTER_BENCH = "starterbench"; + public static final String CMD_TRIGGER_HW_INPUT = "trigger_hw_input"; + public static final String CMD_TRIGGER_PIN = "set_trigger_input_pin"; + public static final String CMD_TRIGGER_SIMULATOR_PIN = "set_trigger_simulator_pin"; + public static final String CMD_TRIGGERINFO = "triggerinfo"; + public static final String CMD_VSS_PIN = "vss_pin"; + public static final String CMD_WRITECONFIG = "writeconfig"; + public static final int COMPOSITE_PACKET_SIZE = 5; + public static final String CONSOLE_DATA_PROTOCOL_TAG = " @"; + public static final int CRANKING_ADVANCE_CURVE_SIZE = 4; + public static final int CRANKING_CLT_IDLE_CURVE_SIZE = 8; + public static final int CRANKING_CURVE_SIZE = 8; + public static final int cranking_parameters_s_size = 8; + public static final String CRITICAL_PREFIX = "CRITICAL"; + public static final int cyl_trim_s_size = 16; + public static final int dc_function_e_DC_IdleValve = 3; + public static final int dc_function_e_DC_None = 0; + public static final int dc_function_e_DC_Throttle1 = 1; + public static final int dc_function_e_DC_Throttle2 = 2; + public static final int dc_function_e_DC_Wastegate = 4; + public static final int dc_io_size = 8; + public static final int DC_PER_STEPPER = 2; + public static final int debug_mode_e_DBG_0 = 0; + public static final int debug_mode_e_DBG_10 = 10; + public static final int debug_mode_e_DBG_11 = 11; + public static final int debug_mode_e_DBG_16 = 16; + public static final int debug_mode_e_DBG_2 = 2; + public static final int debug_mode_e_DBG_20 = 20; + public static final int debug_mode_e_DBG_24 = 24; + public static final int debug_mode_e_DBG_26 = 26; + public static final int debug_mode_e_DBG_29 = 29; + public static final int debug_mode_e_DBG_34 = 34; + public static final int debug_mode_e_DBG_35 = 35; + public static final int debug_mode_e_DBG_36 = 36; + public static final int debug_mode_e_DBG_37 = 37; + public static final int debug_mode_e_DBG_38 = 38; + public static final int debug_mode_e_DBG_43 = 43; + public static final int debug_mode_e_DBG_46 = 46; + public static final int debug_mode_e_DBG_7 = 7; + public static final int debug_mode_e_DBG_8 = 8; + public static final int debug_mode_e_DBG_9 = 9; + public static final int debug_mode_e_DBG_ANALOG_INPUTS = 21; + public static final int debug_mode_e_DBG_ANALOG_INPUTS2 = 32; + public static final int debug_mode_e_DBG_BENCH_TEST = 19; + public static final int debug_mode_e_DBG_CJ125 = 25; + public static final int debug_mode_e_DBG_COMPOSITE_LOG = 40; + public static final int debug_mode_e_DBG_DWELL_METRIC = 33; + public static final int debug_mode_e_DBG_DYNO_VIEW = 44; + public static final int debug_mode_e_DBG_EL_ACCEL = 4; + public static final int debug_mode_e_DBG_ELECTRONIC_THROTTLE_PID = 17; + public static final int debug_mode_e_DBG_ETB_AUTOTUNE = 39; + public static final int debug_mode_e_DBG_EXECUTOR = 18; + public static final int debug_mode_e_DBG_INSTANT_RPM = 22; + public static final int debug_mode_e_DBG_ION = 30; + public static final int debug_mode_e_DBG_KNOCK = 15; + public static final int debug_mode_e_DBG_LOGIC_ANALYZER = 45; + public static final int debug_mode_e_DBG_LUA = 48; + public static final int debug_mode_e_DBG_MAP = 27; + public static final int debug_mode_e_DBG_METRICS = 28; + public static final int debug_mode_e_DBG_SD_CARD = 13; + public static final int debug_mode_e_DBG_SOFT_SPARK_CUT = 6; + public static final int debug_mode_e_DBG_SR5_PROTOCOL = 14; + public static final int debug_mode_e_DBG_STEPPER_IDLE_CONTROL = 3; + public static final int debug_mode_e_DBG_TCU = 47; + public static final int debug_mode_e_DBG_TLE8888 = 31; + public static final int debug_mode_e_DBG_TPS_ACCEL = 1; + public static final int debug_mode_e_DBG_TRIGGER_COUNTERS = 5; + public static final int debug_mode_e_DBG_UNUSED12 = 12; + public static final int debug_mode_e_DBG_UNUSED41 = 41; + public static final int debug_mode_e_DBG_UNUSED_42 = 42; + public static final int debug_mode_e_UNUSED23 = 23; + public static final int DIGIPOT_COUNT = 4; + public static final int display_mode_e_DM_HD44780 = 1; + public static final int display_mode_e_DM_HD44780_OVER_PCF8574 = 2; + public static final int display_mode_e_DM_NONE = 0; + public static final int DWELL_CURVE_SIZE = 8; + public static final int ego_sensor_e_ES_14Point7_Free = 2; + public static final int ego_sensor_e_ES_AEM = 6; + public static final int ego_sensor_e_ES_BPSX_D1 = 0; + public static final int ego_sensor_e_ES_Custom = 5; + public static final int ego_sensor_e_ES_Innovate_MTX_L = 1; + public static final int ego_sensor_e_ES_NarrowBand = 3; + public static final int ego_sensor_e_ES_PLX = 4; + public static final int EGT_CHANNEL_COUNT = 8; + public static final int engine_configuration_s_size = 4076; + public static final int engine_load_mode_e_LM_ALPHA_N = 2; + public static final int engine_load_mode_e_LM_LUA = 3; + public static final int engine_load_mode_e_LM_MOCK = 100; + public static final int engine_load_mode_e_LM_REAL_MAF = 1; + public static final int engine_load_mode_e_LM_SPEED_DENSITY = 0; + public static final String ENGINE_MAKE_BMW = "BMW"; + public static final String ENGINE_MAKE_GM = "GM"; + public static final String ENGINE_MAKE_HONDA = "Honda"; + public static final String ENGINE_MAKE_Hyundai = "Hyundai"; + public static final String ENGINE_MAKE_LADA = "Lada"; + public static final String ENGINE_MAKE_MAZDA = "Mazda"; + public static final String ENGINE_MAKE_MERCEDES = "Mercedes"; + public static final String ENGINE_MAKE_NISSAN = "Nissan"; + public static final String ENGINE_MAKE_SUBARU = "Subaru"; + public static final String ENGINE_MAKE_TOYOTA = "Toyota"; + public static final String ENGINE_MAKE_VAG = "VAG"; + public static final int ENGINE_NOISE_CURVE_SIZE = 16; + public static final int ENGINE_SNIFFER_UNIT_US = 10; + public static final int engine_type_e_BMW_M73_M = 24; + public static final int engine_type_e_BMW_M73_MRE = 50; + public static final int engine_type_e_BMW_M73_MRE_SLAVE = 51; + public static final int engine_type_e_CAMARO_4 = 35; + public static final int engine_type_e_CITROEN_TU3JP = 65; + public static final int engine_type_e_DEFAULT_FRANKENSO = 0; + public static final int engine_type_e_DISCOVERY_PDM = 38; + public static final int engine_type_e_DODGE_NEON_1995 = 2; + public static final int engine_type_e_DODGE_NEON_2003_CRANK = 46; + public static final int engine_type_e_DODGE_RAM = 64; + public static final int engine_type_e_EEPROM_BENCH_ENGINE = 61; + public static final int engine_type_e_ET_UNUSED97 = 97; + public static final int engine_type_e_ET_UNUSED98 = 98; + public static final int engine_type_e_ET_UNUSED_17 = 17; + public static final int engine_type_e_ETB_BENCH_ENGINE = 58; + public static final int engine_type_e_Force_4_bytes_size_engine_type = 70000; + public static final int engine_type_e_FORD_ASPIRE_1996 = 3; + public static final int engine_type_e_FORD_ESCORT_GT = 14; + public static final int engine_type_e_FORD_INLINE_6_1995 = 7; + public static final int engine_type_e_FRANKENSO_BMW_M73_F = 40; + public static final int engine_type_e_FRANKENSO_MAZDA_MIATA_2003 = 47; + public static final int engine_type_e_FRANKENSO_MAZDA_MIATA_NA8 = 56; + public static final int engine_type_e_FRANKENSO_MIATA_NA6_MAP = 41; + public static final int engine_type_e_FRANKENSO_MIATA_NA6_VAF = 57; + public static final int engine_type_e_FRANKENSO_QA_ENGINE = 49; + public static final int engine_type_e_GY6_139QMB = 8; + public static final int engine_type_e_HELLEN72_ETB = 33; + public static final int engine_type_e_HELLEN_121_NISSAN_4_CYL = 84; + public static final int engine_type_e_HELLEN_121_NISSAN_6_CYL = 72; + public static final int engine_type_e_HELLEN_121_NISSAN_8_CYL = 85; + public static final int engine_type_e_HELLEN_121_NISSAN_ALMERA_N16 = 87; + public static final int engine_type_e_HELLEN_121_VAG_4_CYL = 71; + public static final int engine_type_e_HELLEN_121_VAG_5_CYL = 77; + public static final int engine_type_e_HELLEN_121_VAG_8_CYL = 81; + public static final int engine_type_e_HELLEN_121_VAG_V6_CYL = 78; + public static final int engine_type_e_HELLEN_121_VAG_VR6_CYL = 79; + public static final int engine_type_e_HELLEN_128_MERCEDES_4_CYL = 36; + public static final int engine_type_e_HELLEN_128_MERCEDES_6_CYL = 88; + public static final int engine_type_e_HELLEN_128_MERCEDES_8_CYL = 89; + public static final int engine_type_e_HELLEN_134_BMW = 75; + public static final int engine_type_e_HELLEN_154_HYUNDAI_COUPE_BK1 = 82; + public static final int engine_type_e_HELLEN_154_HYUNDAI_COUPE_BK2 = 95; + public static final int engine_type_e_HELLEN_154_VAG = 76; + public static final int engine_type_e_HELLEN_55_BMW = 73; + public static final int engine_type_e_HELLEN_88_BMW = 74; + public static final int engine_type_e_HELLEN_NA6 = 34; + public static final int engine_type_e_HELLEN_NA8_96 = 10; + public static final int engine_type_e_HELLEN_NA94 = 80; + public static final int engine_type_e_HELLEN_NB1 = 83; + public static final int engine_type_e_HELLEN_NB1_36 = 94; + public static final int engine_type_e_HELLEN_NB2 = 69; + public static final int engine_type_e_HELLEN_NB2_36 = 86; + public static final int engine_type_e_HONDA_600 = 43; + public static final int engine_type_e_L9779_BENCH_ENGINE = 60; + public static final int engine_type_e_MAZDA_MIATA_2003_BOARD_TEST = 55; + public static final int engine_type_e_MAZDA_MIATA_2003_NA_RAIL = 54; + public static final int engine_type_e_MIATA_1996 = 21; + public static final int engine_type_e_MIATA_PROTEUS_TCU = 1; + public static final int engine_type_e_MINIMAL_PINS = 99; + public static final int engine_type_e_MITSU_4G93 = 16; + public static final int engine_type_e_MRE_BOARD_NEW_TEST = 31; + public static final int engine_type_e_MRE_BODY_CONTROL = 23; + public static final int engine_type_e_MRE_M111 = 68; + public static final int engine_type_e_MRE_MIATA_94_MAP = 20; + public static final int engine_type_e_MRE_MIATA_NA6_MAP = 66; + public static final int engine_type_e_MRE_MIATA_NA6_VAF = 12; + public static final int engine_type_e_MRE_MIATA_NB2_ETB = 13; + public static final int engine_type_e_MRE_MIATA_NB2_MAF = 15; + public static final int engine_type_e_MRE_MIATA_NB2_MAP = 11; + public static final int engine_type_e_MRE_SECONDARY_CAN = 4; + public static final int engine_type_e_MRE_SUBARU_EJ18 = 37; + public static final int engine_type_e_MRE_VW_B6 = 62; + public static final int engine_type_e_NISSAN_PRIMERA = 5; + public static final int engine_type_e_PROTEUS_ANALOG_PWM_TEST = 30; + public static final int engine_type_e_PROTEUS_BMW_M73 = 63; + public static final int engine_type_e_PROTEUS_E65_6H_MAN_IN_THE_MIDDLE = 9; + public static final int engine_type_e_PROTEUS_GM_LS_4 = 27; + public static final int engine_type_e_PROTEUS_HARLEY = 6; + public static final int engine_type_e_PROTEUS_HONDA_K = 90; + public static final int engine_type_e_PROTEUS_HONDA_OBD2A = 91; + public static final int engine_type_e_PROTEUS_LUA_DEMO = 25; + public static final int engine_type_e_PROTEUS_MIATA_NB2 = 67; + public static final int engine_type_e_PROTEUS_N73 = 93; + public static final int engine_type_e_PROTEUS_QC_TEST_BOARD = 42; + public static final int engine_type_e_PROTEUS_VAG_80_18T = 92; + public static final int engine_type_e_PROTEUS_VW_B6 = 39; + public static final int engine_type_e_SACHS = 29; + public static final int engine_type_e_SUBARU_2003_WRX = 22; + public static final int engine_type_e_SUBARUEG33_DEFAULTS = 70; + public static final int engine_type_e_TEST_100 = 100; + public static final int engine_type_e_TEST_101 = 101; + public static final int engine_type_e_TEST_102 = 102; + public static final int engine_type_e_TEST_33816 = 18; + public static final int engine_type_e_TEST_CRANK_ENGINE = 28; + public static final int engine_type_e_TEST_DC_WASTEGATE_DISCOVERY = 48; + public static final int engine_type_e_TEST_ENGINE = 26; + public static final int engine_type_e_TEST_ENGINE_VVT = 45; + public static final int engine_type_e_TEST_ISSUE_366_BOTH = 52; + public static final int engine_type_e_TEST_ISSUE_366_RISE = 53; + public static final int engine_type_e_TEST_ROTARY = 19; + public static final int engine_type_e_TLE8888_BENCH_ENGINE = 59; + public static final int engine_type_e_TOYOTA_2JZ_GTE_VVTi = 44; + public static final int engine_type_e_VW_ABA = 32; + public static final int engine_type_e_WASTEGATE_PROTEUS_TEST = 96; + public static final int ERROR_BUFFER_SIZE = 120; + public static final int ETB_BIAS_CURVE_LENGTH = 8; + public static final int ETB_COUNT = 2; + public static final int ETB_HW_MAX_FREQUENCY = 3000; + public static final int FLASH_DATA_VERSION = 10020; + public static final int FUEL_LEVEL_TABLE_COUNT = 8; + public static final int FUEL_LOAD_COUNT = 16; + public static final int FUEL_RPM_COUNT = 16; + public static final int GAP_TRACKING_LENGTH = 18; + public static final String GAUGE_CATEGORY_BOOST_CONTROL = "Boost Control"; + public static final String GAUGE_CATEGORY_ETB = "ETB more"; + public static final String GAUGE_CATEGORY_FUEL_MATH = "Fuel: math"; + public static final String GAUGE_CATEGORY_TIMING = "Timing"; + public static final String GAUGE_COIL_DWELL_TIME = "dwell: coil charge time"; + public static final String GAUGE_NAME_ACCEL_ROLL = "Acceleration: Roll"; + public static final String GAUGE_NAME_ACCEL_X = "Acceleration: X"; + public static final String GAUGE_NAME_ACCEL_Y = "Acceleration: Y"; + public static final String GAUGE_NAME_ACCEL_YAW = "Acceleration: Yaw"; + public static final String GAUGE_NAME_ACCEL_Z = "Acceleration: Z"; + public static final String GAUGE_NAME_AFR = "Air/Fuel Ratio"; + public static final String GAUGE_NAME_AFR2 = "Air/Fuel Ratio 2"; + public static final String GAUGE_NAME_AIR_FLOW_ESTIMATE = "MAF estimate"; + public static final String GAUGE_NAME_AIR_FLOW_MEASURED = "MAF"; + public static final String GAUGE_NAME_AIR_FLOW_MEASURED_2 = "MAF #2"; + public static final String GAUGE_NAME_AIR_MASS = "air mass"; + public static final String GAUGE_NAME_AUX_LINEAR_1 = "Aux Linear #1"; + public static final String GAUGE_NAME_AUX_LINEAR_2 = "Aux Linear #2"; + public static final String GAUGE_NAME_AUX_TEMP1 = "Aux temp 1"; + public static final String GAUGE_NAME_AUX_TEMP2 = "Aux temp 2"; + public static final String GAUGE_NAME_BARO_PRESSURE = "Barometric pressure"; + public static final String GAUGE_NAME_BOOST_CLOSED_LOOP = "Boost Closed Loop"; + public static final String GAUGE_NAME_BOOST_OPEN_LOOP = "Boost Open Loop"; + public static final String GAUGE_NAME_BOOST_OUTPUT = "Boost Output"; + public static final String GAUGE_NAME_BOOST_TARGET = "Boost Target"; + public static final String GAUGE_NAME_CLT = "CLT"; + public static final String GAUGE_NAME_CPU_TEMP = "CPU Temperature"; + public static final String GAUGE_NAME_CURRENT_GEAR = "Current Gear"; + public static final String GAUGE_NAME_DEBUG_F1 = "debug f1"; + public static final String GAUGE_NAME_DEBUG_F2 = "debug f2: iTerm"; + public static final String GAUGE_NAME_DEBUG_F3 = "debug f3: prevError"; + public static final String GAUGE_NAME_DEBUG_F4 = "debug f4: iParam"; + public static final String GAUGE_NAME_DEBUG_F5 = "debug f5: dParam"; + public static final String GAUGE_NAME_DEBUG_F6 = "debug f6: dTerm"; + public static final String GAUGE_NAME_DEBUG_F7 = "debug f7"; + public static final String GAUGE_NAME_DEBUG_I1 = "debug i1: pParam"; + public static final String GAUGE_NAME_DEBUG_I2 = "debug i2: offset"; + public static final String GAUGE_NAME_DEBUG_I3 = "debug i3"; + public static final String GAUGE_NAME_DEBUG_I4 = "debug i4"; + public static final String GAUGE_NAME_DEBUG_I5 = "debug i5"; + public static final String GAUGE_NAME_DESIRED_GEAR = "Desired Gear"; + public static final String GAUGE_NAME_DETECTED_GEAR = "Detected Gear"; + public static final String GAUGE_NAME_DWELL_DUTY = "dwell: coil duty cycle"; + public static final String GAUGE_NAME_ECU_TEMPERATURE = "ECU temperature"; + public static final String GAUGE_NAME_ENGINE_CRC16 = "Engine CRC16"; + public static final String GAUGE_NAME_ETB_DUTY = "ETB Duty"; + public static final String GAUGE_NAME_ETB_ERROR = "ETB position error"; + public static final String GAUGE_NAME_ETB_TARGET = "ETB position target"; + public static final String GAUGE_NAME_FLEX = "Flex Ethanol %"; + public static final String GAUGE_NAME_FUEL_BARO_CORR = "fuel: Barometric pressure mult"; + public static final String GAUGE_NAME_FUEL_BASE = "fuel: base mass"; + public static final String GAUGE_NAME_FUEL_CHARGE_TEMP = "fuel: Estimated charge temperature"; + public static final String GAUGE_NAME_FUEL_CLT_CORR = "fuel: CLT correction"; + public static final String GAUGE_NAME_FUEL_CONSUMPTION = "fuel: Total consumed"; + public static final String GAUGE_NAME_FUEL_CRANKING = "fuel: cranking"; + public static final String GAUGE_NAME_FUEL_EL_EXTRA = "fuel: engine load acceleration extra fuel"; + public static final String GAUGE_NAME_FUEL_FLOW = "fuel: Flow rate"; + public static final String GAUGE_NAME_FUEL_IAT_CORR = "fuel: IAT correction"; + public static final String GAUGE_NAME_FUEL_INJ_DUTY = "fuel: injector duty cycle"; + public static final String GAUGE_NAME_FUEL_LAST_INJECTION = "fuel: Last injection"; + public static final String GAUGE_NAME_FUEL_LEVEL = "fuel level"; + public static final String GAUGE_NAME_FUEL_LOAD = "fuel: load"; + public static final String GAUGE_NAME_FUEL_PRESSURE_HIGH = "Fuel pressure (high)"; + public static final String GAUGE_NAME_FUEL_PRESSURE_HIGH_UNITS = "bar"; + public static final String GAUGE_NAME_FUEL_PRESSURE_LOW = "Fuel pressure (low)"; + public static final String GAUGE_NAME_FUEL_PRESSURE_LOW_UNITS = "kPa"; + public static final String GAUGE_NAME_FUEL_RUNNING = "fuel: running"; + public static final String GAUGE_NAME_FUEL_TPS_EXTRA = "fuel: TPS acceleration add fuel ms"; + public static final String GAUGE_NAME_FUEL_TPS_ROC = "fuel: TPS change"; + public static final String GAUGE_NAME_FUEL_TRIM = "fuel: fuel trim"; + public static final String GAUGE_NAME_FUEL_TRIM_2 = "fuel: fuel trim 2"; + public static final String GAUGE_NAME_FUEL_VE = "fuel: VE"; + public static final String GAUGE_NAME_FUEL_WALL_AMOUNT = "fuel: wall amount"; + public static final String GAUGE_NAME_FUEL_WALL_CORRECTION = "fuel: wall correction"; + public static final String GAUGE_NAME_FW_VERSION = "ECU Software Version"; + public static final String GAUGE_NAME_GEAR_RATIO = "Gearbox Ratio"; + public static final String GAUGE_NAME_IAC = "Idle Air Valve"; + public static final String GAUGE_NAME_IAT = "IAT"; + public static final String GAUGE_NAME_IDLE_POSITION = "Idle position sensor"; + public static final String GAUGE_NAME_IGNITION_LOAD = "ign: load"; + public static final String GAUGE_NAME_INJECTOR_LAG = "fuel: injector lag"; + public static final String GAUGE_NAME_ISS = "Input Shaft Speed"; + public static final String GAUGE_NAME_KNOCK_1 = "knock 1"; + public static final String GAUGE_NAME_KNOCK_10 = "knock 10"; + public static final String GAUGE_NAME_KNOCK_11 = "knock 11"; + public static final String GAUGE_NAME_KNOCK_12 = "knock 12"; + public static final String GAUGE_NAME_KNOCK_2 = "knock 2"; + public static final String GAUGE_NAME_KNOCK_3 = "knock 3"; + public static final String GAUGE_NAME_KNOCK_4 = "knock 4"; + public static final String GAUGE_NAME_KNOCK_5 = "knock 5"; + public static final String GAUGE_NAME_KNOCK_6 = "knock 6"; + public static final String GAUGE_NAME_KNOCK_7 = "knock 7"; + public static final String GAUGE_NAME_KNOCK_8 = "knock 8"; + public static final String GAUGE_NAME_KNOCK_9 = "knock 9"; + public static final String GAUGE_NAME_KNOCK_COUNTER = "knock: count"; + public static final String GAUGE_NAME_KNOCK_LEVEL = "knock: current level"; + public static final String GAUGE_NAME_KNOCK_RETARD = "knock: retard"; + public static final String GAUGE_NAME_LAMBDA = "Lambda"; + public static final String GAUGE_NAME_LAMBDA2 = "Lambda 2"; + public static final String GAUGE_NAME_LAST_ERROR = "Last error"; + public static final String GAUGE_NAME_MAF = "MAF"; + public static final String GAUGE_NAME_MAP = "MAP"; + public static final String GAUGE_NAME_OIL_PRESSURE = "Oil Pressure"; + public static final String GAUGE_NAME_OIL_PRESSURE_UNITS = "kPa"; + public static final String GAUGE_NAME_RAW_FUEL_PRESSURE_HIGH = "Fuel pressure raw (high)"; + public static final String GAUGE_NAME_RAW_FUEL_PRESSURE_LOW = "Fuel pressure raw (low)"; + public static final String GAUGE_NAME_RPM = "RPM"; + public static final String GAUGE_NAME_TARGET_AFR = "fuel: target AFR"; + public static final String GAUGE_NAME_TARGET_LAMBDA = "fuel: target lambda"; + public static final String GAUGE_NAME_TC_RATIO = "Torque Converter Ratio"; + public static final String GAUGE_NAME_TCHARGE = "fuel: SD tCharge"; + public static final String GAUGE_NAME_THROTTLE_PEDAL = "Throttle pedal position"; + public static final String GAUGE_NAME_TIME = "Time"; + public static final String GAUGE_NAME_TIMING_ADVANCE = "timing"; + public static final String GAUGE_NAME_TPS = "TPS"; + public static final String GAUGE_NAME_TPS2 = "TPS2"; + public static final String GAUGE_NAME_TRG_ERR = "Trigger Error Counter"; + public static final String GAUGE_NAME_TRG_GAP = "Trigger Sync Latest Ratio"; + public static final String GAUGE_NAME_TUNE_CRC16 = "Tune CRC16"; + public static final String GAUGE_NAME_TURBO_SPEED = "Turbocharger Speed"; + public static final String GAUGE_NAME_UPTIME = "Uptime"; + public static final String GAUGE_NAME_VBAT = "VBatt"; + public static final String GAUGE_NAME_VERSION = "firmware"; + public static final String GAUGE_NAME_VVS = "Vehicle Speed"; + public static final String GAUGE_NAME_VVT_B1E = "VVT: bank 1 exhaust"; + public static final String GAUGE_NAME_VVT_B1I = "VVT: bank 1 intake"; + public static final String GAUGE_NAME_VVT_B2E = "VVT: bank 2 exhaust"; + public static final String GAUGE_NAME_VVT_B2I = "VVT: bank 2 intake"; + public static final String GAUGE_NAME_VVT_TARGET_B1E = "VVT: bank 1 exhaust target"; + public static final String GAUGE_NAME_VVT_TARGET_B1I = "VVT: bank 1 intake target"; + public static final String GAUGE_NAME_VVT_TARGET_B2E = "VVT: bank 2 exhaust target"; + public static final String GAUGE_NAME_VVT_TARGET_B2I = "VVT: bank 2 intake target"; + public static final String GAUGE_NAME_WARNING_COUNT = "Warning count"; + public static final String GAUGE_NAME_WARNING_COUNTER = "warning: counter"; + public static final String GAUGE_NAME_WARNING_LAST = "warning: last"; + public static final String GAUGE_NAME_WG_POSITION = "Wastegate position sensor"; + public static final int gear_e_GEAR_1 = 1; + public static final int gear_e_GEAR_2 = 2; + public static final int gear_e_GEAR_3 = 3; + public static final int gear_e_GEAR_4 = 4; + public static final int gear_e_NEUTRAL = 0; + public static final int gear_e_REVERSE = -1; + public static final int GearControllerMode_ButtonShift = 1; + public static final int GearControllerMode_Generic = 2; + public static final int GearControllerMode_None = 0; + public static final int GEARS_COUNT = 8; + public static final int Gpio_A0 = 2; + public static final int Gpio_A1 = 3; + public static final int Gpio_A10 = 12; + public static final int Gpio_A11 = 13; + public static final int Gpio_A12 = 14; + public static final int Gpio_A13 = 15; + public static final int Gpio_A14 = 16; + public static final int Gpio_A15 = 17; + public static final int Gpio_A2 = 4; + public static final int Gpio_A3 = 5; + public static final int Gpio_A4 = 6; + public static final int Gpio_A5 = 7; + public static final int Gpio_A6 = 8; + public static final int Gpio_A7 = 9; + public static final int Gpio_A8 = 10; + public static final int Gpio_A9 = 11; + public static final int Gpio_B0 = 18; + public static final int Gpio_B1 = 19; + public static final int Gpio_B10 = 28; + public static final int Gpio_B11 = 29; + public static final int Gpio_B12 = 30; + public static final int Gpio_B13 = 31; + public static final int Gpio_B14 = 32; + public static final int Gpio_B15 = 33; + public static final int Gpio_B2 = 20; + public static final int Gpio_B3 = 21; + public static final int Gpio_B4 = 22; + public static final int Gpio_B5 = 23; + public static final int Gpio_B6 = 24; + public static final int Gpio_B7 = 25; + public static final int Gpio_B8 = 26; + public static final int Gpio_B9 = 27; + public static final int Gpio_C0 = 34; + public static final int Gpio_C1 = 35; + public static final int Gpio_C10 = 44; + public static final int Gpio_C11 = 45; + public static final int Gpio_C12 = 46; + public static final int Gpio_C13 = 47; + public static final int Gpio_C14 = 48; + public static final int Gpio_C15 = 49; + public static final int Gpio_C2 = 36; + public static final int Gpio_C3 = 37; + public static final int Gpio_C4 = 38; + public static final int Gpio_C5 = 39; + public static final int Gpio_C6 = 40; + public static final int Gpio_C7 = 41; + public static final int Gpio_C8 = 42; + public static final int Gpio_C9 = 43; + public static final int Gpio_CAN_PIN_0 = 249; + public static final int Gpio_CAN_PIN_1 = 250; + public static final int Gpio_CAN_PIN_2 = 251; + public static final int Gpio_CAN_PIN_3 = 252; + public static final int Gpio_CAN_PIN_4 = 253; + public static final int Gpio_CAN_PIN_5 = 254; + public static final int Gpio_CAN_PIN_6 = 255; + public static final int Gpio_CAN_PIN_7 = 256; + public static final int Gpio_D0 = 50; + public static final int Gpio_D1 = 51; + public static final int Gpio_D10 = 60; + public static final int Gpio_D11 = 61; + public static final int Gpio_D12 = 62; + public static final int Gpio_D13 = 63; + public static final int Gpio_D14 = 64; + public static final int Gpio_D15 = 65; + public static final int Gpio_D2 = 52; + public static final int Gpio_D3 = 53; + public static final int Gpio_D4 = 54; + public static final int Gpio_D5 = 55; + public static final int Gpio_D6 = 56; + public static final int Gpio_D7 = 57; + public static final int Gpio_D8 = 58; + public static final int Gpio_D9 = 59; + public static final int Gpio_E0 = 66; + public static final int Gpio_E1 = 67; + public static final int Gpio_E10 = 76; + public static final int Gpio_E11 = 77; + public static final int Gpio_E12 = 78; + public static final int Gpio_E13 = 79; + public static final int Gpio_E14 = 80; + public static final int Gpio_E15 = 81; + public static final int Gpio_E2 = 68; + public static final int Gpio_E3 = 69; + public static final int Gpio_E4 = 70; + public static final int Gpio_E5 = 71; + public static final int Gpio_E6 = 72; + public static final int Gpio_E7 = 73; + public static final int Gpio_E8 = 74; + public static final int Gpio_E9 = 75; + public static final int Gpio_F0 = 82; + public static final int Gpio_F1 = 83; + public static final int Gpio_F10 = 92; + public static final int Gpio_F11 = 93; + public static final int Gpio_F12 = 94; + public static final int Gpio_F13 = 95; + public static final int Gpio_F14 = 96; + public static final int Gpio_F15 = 97; + public static final int Gpio_F2 = 84; + public static final int Gpio_F3 = 85; + public static final int Gpio_F4 = 86; + public static final int Gpio_F5 = 87; + public static final int Gpio_F6 = 88; + public static final int Gpio_F7 = 89; + public static final int Gpio_F8 = 90; + public static final int Gpio_F9 = 91; + public static final int Gpio_G0 = 98; + public static final int Gpio_G1 = 99; + public static final int Gpio_G10 = 108; + public static final int Gpio_G11 = 109; + public static final int Gpio_G12 = 110; + public static final int Gpio_G13 = 111; + public static final int Gpio_G14 = 112; + public static final int Gpio_G15 = 113; + public static final int Gpio_G2 = 100; + public static final int Gpio_G3 = 101; + public static final int Gpio_G4 = 102; + public static final int Gpio_G5 = 103; + public static final int Gpio_G6 = 104; + public static final int Gpio_G7 = 105; + public static final int Gpio_G8 = 106; + public static final int Gpio_G9 = 107; + public static final int Gpio_H0 = 114; + public static final int Gpio_H1 = 115; + public static final int Gpio_H10 = 124; + public static final int Gpio_H11 = 125; + public static final int Gpio_H12 = 126; + public static final int Gpio_H13 = 127; + public static final int Gpio_H14 = 128; + public static final int Gpio_H15 = 129; + public static final int Gpio_H2 = 116; + public static final int Gpio_H3 = 117; + public static final int Gpio_H4 = 118; + public static final int Gpio_H5 = 119; + public static final int Gpio_H6 = 120; + public static final int Gpio_H7 = 121; + public static final int Gpio_H8 = 122; + public static final int Gpio_H9 = 123; + public static final int Gpio_I0 = 130; + public static final int Gpio_I1 = 131; + public static final int Gpio_I10 = 140; + public static final int Gpio_I11 = 141; + public static final int Gpio_I12 = 142; + public static final int Gpio_I13 = 143; + public static final int Gpio_I14 = 144; + public static final int Gpio_I15 = 145; + public static final int Gpio_I2 = 132; + public static final int Gpio_I3 = 133; + public static final int Gpio_I4 = 134; + public static final int Gpio_I5 = 135; + public static final int Gpio_I6 = 136; + public static final int Gpio_I7 = 137; + public static final int Gpio_I8 = 138; + public static final int Gpio_I9 = 139; + public static final int Gpio_Invalid = 1; + public static final int Gpio_L9779_IGN_1 = 215; + public static final int Gpio_L9779_IGN_2 = 216; + public static final int Gpio_L9779_IGN_3 = 217; + public static final int Gpio_L9779_IGN_4 = 218; + public static final int Gpio_L9779_OUT_1 = 219; + public static final int Gpio_L9779_OUT_10 = 228; + public static final int Gpio_L9779_OUT_11 = 229; + public static final int Gpio_L9779_OUT_12 = 230; + public static final int Gpio_L9779_OUT_13 = 231; + public static final int Gpio_L9779_OUT_14 = 232; + public static final int Gpio_L9779_OUT_15 = 233; + public static final int Gpio_L9779_OUT_16 = 234; + public static final int Gpio_L9779_OUT_17 = 235; + public static final int Gpio_L9779_OUT_18 = 236; + public static final int Gpio_L9779_OUT_19 = 237; + public static final int Gpio_L9779_OUT_2 = 220; + public static final int Gpio_L9779_OUT_20 = 238; + public static final int Gpio_L9779_OUT_25 = 243; + public static final int Gpio_L9779_OUT_26 = 244; + public static final int Gpio_L9779_OUT_27 = 245; + public static final int Gpio_L9779_OUT_28 = 246; + public static final int Gpio_L9779_OUT_3 = 221; + public static final int Gpio_L9779_OUT_4 = 222; + public static final int Gpio_L9779_OUT_5 = 223; + public static final int Gpio_L9779_OUT_6 = 224; + public static final int Gpio_L9779_OUT_7 = 225; + public static final int Gpio_L9779_OUT_8 = 226; + public static final int Gpio_L9779_OUT_9 = 227; + public static final int Gpio_L9779_OUT_A = 239; + public static final int Gpio_L9779_OUT_B = 240; + public static final int Gpio_L9779_OUT_C = 241; + public static final int Gpio_L9779_OUT_D = 242; + public static final int Gpio_L9779_OUT_MRD = 247; + public static final int Gpio_L9779_PIN_KEY = 248; + public static final int Gpio_MC33972_PIN_1 = 146; + public static final int Gpio_MC33972_PIN_21 = 166; + public static final int Gpio_MC33972_PIN_22 = 167; + public static final int Gpio_PROTECTED_PIN_0 = 257; + public static final int Gpio_PROTECTED_PIN_1 = 258; + public static final int Gpio_PROTECTED_PIN_10 = 267; + public static final int Gpio_PROTECTED_PIN_11 = 268; + public static final int Gpio_PROTECTED_PIN_12 = 269; + public static final int Gpio_PROTECTED_PIN_13 = 270; + public static final int Gpio_PROTECTED_PIN_14 = 271; + public static final int Gpio_PROTECTED_PIN_15 = 272; + public static final int Gpio_PROTECTED_PIN_2 = 259; + public static final int Gpio_PROTECTED_PIN_3 = 260; + public static final int Gpio_PROTECTED_PIN_4 = 261; + public static final int Gpio_PROTECTED_PIN_5 = 262; + public static final int Gpio_PROTECTED_PIN_6 = 263; + public static final int Gpio_PROTECTED_PIN_7 = 264; + public static final int Gpio_PROTECTED_PIN_8 = 265; + public static final int Gpio_PROTECTED_PIN_9 = 266; + public static final int Gpio_TLE6240_PIN_1 = 199; + public static final int Gpio_TLE6240_PIN_10 = 208; + public static final int Gpio_TLE6240_PIN_11 = 209; + public static final int Gpio_TLE6240_PIN_12 = 210; + public static final int Gpio_TLE6240_PIN_13 = 211; + public static final int Gpio_TLE6240_PIN_14 = 212; + public static final int Gpio_TLE6240_PIN_15 = 213; + public static final int Gpio_TLE6240_PIN_16 = 214; + public static final int Gpio_TLE6240_PIN_2 = 200; + public static final int Gpio_TLE6240_PIN_3 = 201; + public static final int Gpio_TLE6240_PIN_4 = 202; + public static final int Gpio_TLE6240_PIN_5 = 203; + public static final int Gpio_TLE6240_PIN_6 = 204; + public static final int Gpio_TLE6240_PIN_7 = 205; + public static final int Gpio_TLE6240_PIN_8 = 206; + public static final int Gpio_TLE6240_PIN_9 = 207; + public static final int Gpio_TLE8888_PIN_1 = 168; + public static final int Gpio_TLE8888_PIN_10 = 177; + public static final int Gpio_TLE8888_PIN_11 = 178; + public static final int Gpio_TLE8888_PIN_12 = 179; + public static final int Gpio_TLE8888_PIN_13 = 180; + public static final int Gpio_TLE8888_PIN_14 = 181; + public static final int Gpio_TLE8888_PIN_15 = 182; + public static final int Gpio_TLE8888_PIN_16 = 183; + public static final int Gpio_TLE8888_PIN_17 = 184; + public static final int Gpio_TLE8888_PIN_18 = 185; + public static final int Gpio_TLE8888_PIN_19 = 186; + public static final int Gpio_TLE8888_PIN_2 = 169; + public static final int Gpio_TLE8888_PIN_20 = 187; + public static final int Gpio_TLE8888_PIN_21 = 188; + public static final int Gpio_TLE8888_PIN_22 = 189; + public static final int Gpio_TLE8888_PIN_23 = 190; + public static final int Gpio_TLE8888_PIN_24 = 191; + public static final int Gpio_TLE8888_PIN_25 = 192; + public static final int Gpio_TLE8888_PIN_26 = 193; + public static final int Gpio_TLE8888_PIN_27 = 194; + public static final int Gpio_TLE8888_PIN_28 = 195; + public static final int Gpio_TLE8888_PIN_3 = 170; + public static final int Gpio_TLE8888_PIN_4 = 171; + public static final int Gpio_TLE8888_PIN_5 = 172; + public static final int Gpio_TLE8888_PIN_6 = 173; + public static final int Gpio_TLE8888_PIN_7 = 174; + public static final int Gpio_TLE8888_PIN_8 = 175; + public static final int Gpio_TLE8888_PIN_9 = 176; + public static final int Gpio_TLE8888_PIN_KEY = 197; + public static final int Gpio_TLE8888_PIN_MR = 196; + public static final int Gpio_TLE8888_PIN_WAKE = 198; + public static final int Gpio_Unassigned = 0; + public static final int gppwm_channel_e_GPPWM_AccelPedal = 9; + public static final int gppwm_channel_e_GPPWM_AuxLinear1 = 16; + public static final int gppwm_channel_e_GPPWM_AuxLinear2 = 17; + public static final int gppwm_channel_e_GPPWM_AuxTemp1 = 7; + public static final int gppwm_channel_e_GPPWM_AuxTemp2 = 8; + public static final int gppwm_channel_e_GPPWM_Clt = 3; + public static final int gppwm_channel_e_GPPWM_EthanolPercent = 15; + public static final int gppwm_channel_e_GPPWM_FuelLoad = 5; + public static final int gppwm_channel_e_GPPWM_GppwmOutput1 = 18; + public static final int gppwm_channel_e_GPPWM_GppwmOutput2 = 19; + public static final int gppwm_channel_e_GPPWM_GppwmOutput3 = 20; + public static final int gppwm_channel_e_GPPWM_GppwmOutput4 = 21; + public static final int gppwm_channel_e_GPPWM_Iat = 4; + public static final int gppwm_channel_e_GPPWM_IgnLoad = 6; + public static final int gppwm_channel_e_GPPWM_LuaGauge1 = 22; + public static final int gppwm_channel_e_GPPWM_LuaGauge2 = 23; + public static final int gppwm_channel_e_GPPWM_Map = 2; + public static final int gppwm_channel_e_GPPWM_Rpm = 24; + public static final int gppwm_channel_e_GPPWM_Tps = 1; + public static final int gppwm_channel_e_GPPWM_Vbatt = 10; + public static final int gppwm_channel_e_GPPWM_VVT_1E = 12; + public static final int gppwm_channel_e_GPPWM_VVT_1I = 11; + public static final int gppwm_channel_e_GPPWM_VVT_2E = 14; + public static final int gppwm_channel_e_GPPWM_VVT_2I = 13; + public static final int gppwm_channel_e_GPPWM_Zero = 0; + public static final int gppwm_channel_size = 108; + public static final int GPPWM_CHANNELS = 4; + public static final int gppwm_compare_mode_e_GPPWM_GreaterThan = 0; + public static final int gppwm_compare_mode_e_GPPWM_LessThan = 1; + public static final int GPPWM_LOAD_COUNT = 8; + public static final int GPPWM_NOTE_SIZE = 16; + public static final int GPPWM_RPM_COUNT = 8; + public static final int HIGH_SPEED_COUNT = 32; + public static final int hpfp_cam_e_HPFP_CAM_EX1 = 2; + public static final int hpfp_cam_e_HPFP_CAM_EX2 = 4; + public static final int hpfp_cam_e_HPFP_CAM_IN1 = 1; + public static final int hpfp_cam_e_HPFP_CAM_IN2 = 3; + public static final int hpfp_cam_e_HPFP_CAM_NONE = 0; + public static final int HPFP_COMPENSATION_SIZE = 10; + public static final int HPFP_DEADTIME_SIZE = 8; + public static final int HPFP_LOBE_PROFILE_SIZE = 16; + public static final int HPFP_TARGET_SIZE = 10; + public static final int HW_MAX_ADC_INDEX = 17; + public static final int IAC_PID_MULT_SIZE = 8; + public static final int IAT_CURVE_SIZE = 16; + public static final int IDLE_ADVANCE_CURVE_SIZE = 8; + public static final int idle_hardware_s_size = 12; + public static final int idle_mode_e_IM_AUTO = 0; + public static final int idle_mode_e_IM_MANUAL = 1; + public static final int idle_state_e_BLIP = 64; + public static final int idle_state_e_INIT = 0; + public static final int idle_state_e_PID_UPPER = 16; + public static final int idle_state_e_PID_VALUE = 4; + public static final int idle_state_e_RPM_DEAD_ZONE = 2; + public static final int idle_state_e_TPS_THRESHOLD = 1; + public static final int IDLE_VE_SIZE = 4; + public static final int IGN_BLEND_COUNT = 4; + public static final int IGN_LOAD_COUNT = 16; + public static final int IGN_RPM_COUNT = 16; + public static final int ignition_mode_e_IM_INDIVIDUAL_COILS = 1; + public static final int ignition_mode_e_IM_ONE_COIL = 0; + public static final int ignition_mode_e_IM_TWO_COILS = 3; + public static final int ignition_mode_e_IM_WASTED_SPARK = 2; + public static final int imu_type_e_IMU_MM5_10 = 2; + public static final int imu_type_e_IMU_NONE = 0; + public static final int imu_type_e_IMU_TYPE_3 = 3; + public static final int imu_type_e_IMU_TYPE_4 = 4; + public static final int imu_type_e_IMU_TYPE_MB_A0065422618 = 5; + public static final int imu_type_e_IMU_VAG = 1; + public static final String INDICATOR_NAME_AC_SWITCH = "AC switch"; + public static final String INDICATOR_NAME_BRAKE_DOWN = "brake: down"; + public static final String INDICATOR_NAME_CLUTCH_DOWN = "clutch: down"; + public static final String INDICATOR_NAME_CLUTCH_UP = "clutch: up"; + public static final int injection_mode_e_IM_BATCH = 2; + public static final int injection_mode_e_IM_SEQUENTIAL = 1; + public static final int injection_mode_e_IM_SIMULTANEOUS = 0; + public static final int injection_mode_e_IM_SINGLE_POINT = 3; + public static final int InjectionTimingMode_Center = 2; + public static final int InjectionTimingMode_End = 0; + public static final int InjectionTimingMode_Start = 1; + public static final int injector_compensation_mode_e_ICM_FixedRailPressure = 1; + public static final int injector_compensation_mode_e_ICM_None = 0; + public static final int injector_compensation_mode_e_ICM_SensedRailPressure = 2; + public static final int injector_pressure_type_e_IPT_High = 1; + public static final int injector_pressure_type_e_IPT_Low = 0; + public static final int injector_s_size = 68; + public static final int InjectorNonlinearMode_INJ_FordModel = 2; + public static final int InjectorNonlinearMode_INJ_None = 0; + public static final int InjectorNonlinearMode_INJ_PolynomialAdder = 1; + public static final int launchActivationMode_e_ALWAYS_ACTIVE_LAUNCH = 2; + public static final int launchActivationMode_e_CLUTCH_INPUT_LAUNCH = 1; + public static final int launchActivationMode_e_SWITCH_INPUT_LAUNCH = 0; + public static final int linear_sensor_s_size = 20; + public static final int load_override_e_AFR_AccPedal = 3; + public static final int load_override_e_AFR_CylFilling = 4; + public static final int load_override_e_AFR_MAP = 1; + public static final int load_override_e_AFR_None = 0; + public static final int load_override_e_AFR_Tps = 2; + public static final String LOG_DELIMITER = "`"; + public static final int LOGIC_ANALYZER_CHANNEL_COUNT = 4; + public static final int LUA_ANALOG_INPUT_COUNT = 8; + public static final int LUA_DIGITAL_INPUT_COUNT = 8; + public static final int LUA_GAUGE_COUNT = 2; + public static final int LUA_PWM_COUNT = 8; + public static final int LUA_SCRIPT_SIZE = 8000; + public static final int MAF_DECODING_COUNT = 256; + public static final int maf_sensor_type_e_Bosch0280218004 = 2; + public static final int maf_sensor_type_e_Bosch0280218037 = 1; + public static final int maf_sensor_type_e_CUSTOM = 0; + public static final int maf_sensor_type_e_DensoTODO = 3; + public static final String MAIN_HELP_URL = "http://www.rusefi.com/"; + public static final int MAP_ANGLE_SIZE = 8; + public static final int MAP_sensor_config_s_size = 140; + public static final int MAP_WINDOW_SIZE = 8; + public static final int MAX_CYLINDER_COUNT = 12; + public static final int MLQ_FIELD_HEADER_SIZE = 89; + public static final int MLQ_HEADER_SIZE = 24; + public static final String MOCK_PPS_POSITION_COMMAND = "mock_pps_position"; + public static final String MOCK_PPS_VOLTAGE_COMMAND = "mock_pps_voltage"; + public static final int NARROW_BAND_WIDE_BAND_CONVERSION_SIZE = 8; + public static final int operation_mode_e_FOUR_STROKE_CAM_SENSOR = 2; + public static final int operation_mode_e_FOUR_STROKE_CRANK_SENSOR = 1; + public static final int operation_mode_e_FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR = 4; + public static final int operation_mode_e_FOUR_STROKE_THREE_TIMES_CRANK_SENSOR = 5; + public static final int operation_mode_e_FOUR_STROKE_TWELVE_TIMES_CRANK_SENSOR = 6; + public static final int operation_mode_e_OM_NONE = 0; + public static final int operation_mode_e_TWO_STROKE = 3; + public static final int PACK_ADD_TEMPERATURE = 40; + public static final int PACK_MULT_AFR = 1000; + public static final int PACK_MULT_AFR_CFG = 10; + public static final int PACK_MULT_ANGLE = 50; + public static final int PACK_MULT_FUEL_FLOW = 200; + public static final int PACK_MULT_FUEL_MASS = 100; + public static final int PACK_MULT_HIGH_PRESSURE = 10; + public static final int PACK_MULT_LAMBDA = 10000; + public static final int PACK_MULT_LAMBDA_CFG = 147; + public static final int PACK_MULT_MASS_FLOW = 10; + public static final int PACK_MULT_MS = 300; + public static final int PACK_MULT_PERCENT = 100; + public static final int PACK_MULT_PRESSURE = 30; + public static final int PACK_MULT_TEMPERATURE = 100; + public static final int PACK_MULT_VOLTAGE = 1000; + public static final int PEDAL_TO_TPS_SIZE = 8; + public static final int persistent_config_s_size = 22432; + public static final int pid_s_size = 20; + public static final int PidAutoTune_AutoTunerState_AUTOTUNER_OFF = 0; + public static final int PidAutoTune_AutoTunerState_CONVERGED = 16; + public static final int PidAutoTune_AutoTunerState_FAILED = 128; + public static final int PidAutoTune_AutoTunerState_RELAY_STEP_DOWN = 8; + public static final int PidAutoTune_AutoTunerState_RELAY_STEP_UP = 4; + public static final int PidAutoTune_AutoTunerState_STEADY_STATE_AFTER_STEP_UP = 2; + public static final int PidAutoTune_AutoTunerState_STEADY_STATE_AT_BASELINE = 1; + public static final int PidAutoTune_Peak_MAXIMUM = 1; + public static final int PidAutoTune_Peak_MINIMUM = -1; + public static final int PidAutoTune_Peak_NOT_A_PEAK = 0; + public static final int pin_input_mode_e_PI_DEFAULT = 0; + public static final int pin_input_mode_e_PI_PULLDOWN = 2; + public static final int pin_input_mode_e_PI_PULLUP = 1; + public static final int pin_mode_e_PO_DEFAULT = 0; + public static final int pin_mode_e_PO_OPENDRAIN = 4; + public static final int pin_mode_e_PO_PULLDOWN = 64; + public static final int pin_mode_e_PO_PULLUP = 32; + public static final int pin_output_mode_e_OM_DEFAULT = 0; + public static final int pin_output_mode_e_OM_INVERTED = 1; + public static final int pin_output_mode_e_OM_OPENDRAIN = 2; + public static final int pin_output_mode_e_OM_OPENDRAIN_INVERTED = 3; + public static final String PROTOCOL_ANALOG_CHART = "analog_chart"; + public static final String PROTOCOL_COIL1_SHORT_NAME = "c1"; + public static final String PROTOCOL_CRANK1 = "t1"; + public static final String PROTOCOL_CRANK2 = "t2"; + public static final String PROTOCOL_ENGINE_SNIFFER = "wave_chart"; + public static final String PROTOCOL_ES_DOWN = "d"; + public static final String PROTOCOL_ES_UP = "u"; + public static final String PROTOCOL_HELLO_PREFIX = "***"; + public static final String PROTOCOL_HIP_NAME = "HIP"; + public static final String PROTOCOL_HPFP_NAME = "hpfp"; + public static final String PROTOCOL_INJ1_SHORT_NAME = "i1"; + public static final String PROTOCOL_MSG = "msg"; + public static final String PROTOCOL_OUTPIN = "outpin"; + public static final String PROTOCOL_SIGNATURE_PREFIX = "rusEFI "; + public static final String PROTOCOL_TACH_NAME = "tach"; + public static final String PROTOCOL_TEST_RESPONSE_TAG = "ts_p_alive"; + public static final String PROTOCOL_VERSION_TAG = "rusEfiVersion"; + public static final String PROTOCOL_VVT1_NAME = "VVT1"; + public static final String PROTOCOL_VVT2_NAME = "VVT2"; + public static final String PROTOCOL_VVT3_NAME = "VVT3"; + public static final String PROTOCOL_VVT4_NAME = "VVT4"; + public static final String PROTOCOL_WA_CHANNEL_1 = "input1"; + public static final String PROTOCOL_WA_CHANNEL_2 = "input2"; + public static final String PROTOCOL_WA_CHANNEL_3 = "input3"; + public static final String PROTOCOL_WA_CHANNEL_4 = "input4"; + public static final int SCRIPT_CURVE_16 = 16; + public static final int SCRIPT_CURVE_8 = 8; + public static final int SCRIPT_CURVE_COUNT = 6; + public static final int SCRIPT_SETTING_COUNT = 8; + public static final int SCRIPT_TABLE_8 = 8; + public static final int SCRIPT_TABLE_COUNT = 4; + public static final int SelectedGear_Drive = 6; + public static final int SelectedGear_Invalid = 0; + public static final int SelectedGear_Low = 11; + public static final int SelectedGear_Manual = 7; + public static final int SelectedGear_Manual1 = 10; + public static final int SelectedGear_Manual2 = 9; + public static final int SelectedGear_Manual3 = 8; + public static final int SelectedGear_ManualMinus = 2; + public static final int SelectedGear_ManualPlus = 1; + public static final int SelectedGear_Neutral = 5; + public static final int SelectedGear_Park = 3; + public static final int SelectedGear_Reverse = 4; + public static final int sensor_chart_e_SC_AUX_FAST1 = 5; + public static final int sensor_chart_e_SC_DETAILED_RPM = 4; + public static final int sensor_chart_e_SC_OFF = 0; + public static final int sensor_chart_e_SC_RPM_ACCEL = 3; + public static final int sensor_chart_e_SC_TRIGGER = 1; + public static final int SENT_INPUT_COUNT = 1; + public static final int SentEtbType_FORD_TYPE_1 = 2; + public static final int SentEtbType_GM_TYPE_1 = 1; + public static final int SentEtbType_NONE = 0; + public static final int specs_s_size = 12; + public static final int spi_device_e_SPI_DEVICE_1 = 1; + public static final int spi_device_e_SPI_DEVICE_2 = 2; + public static final int spi_device_e_SPI_DEVICE_3 = 3; + public static final int spi_device_e_SPI_DEVICE_4 = 4; + public static final int spi_device_e_SPI_NONE = 0; + public static final int spi_pins_size = 8; + public static final int spi_speed_e__150KHz = 3; + public static final int spi_speed_e__1_25MHz = 2; + public static final int spi_speed_e__2_5MHz = 1; + public static final int spi_speed_e__5MHz = 0; + public static final int stepper_num_micro_steps_e_STEPPER_EIGHTH = 8; + public static final int stepper_num_micro_steps_e_STEPPER_FOURTH = 4; + public static final int stepper_num_micro_steps_e_STEPPER_FULL = 0; + public static final int stepper_num_micro_steps_e_STEPPER_HALF = 2; + public static final int STFT_BANK_COUNT = 2; + public static final int stft_cell_cfg_s_size = 4; + public static final int STFT_CELL_COUNT = 4; + public static final int stft_s_size = 24; + public static final int tChargeMode_e_TCHARGE_MODE_AIR_INTERP = 1; + public static final int tChargeMode_e_TCHARGE_MODE_AIR_INTERP_TABLE = 2; + public static final int tChargeMode_e_TCHARGE_MODE_RPM_TPS = 0; + public static final int TCU_GEAR_COUNT = 10; + public static final int TCU_MAGIC_SIZE = 8; + public static final int TCU_SOLENOID_COUNT = 6; + public static final int thermistor_conf_s_size = 28; + public static final int ThermistorConf_size = 32; + public static final int timing_mode_e_TM_DYNAMIC = 0; + public static final int timing_mode_e_TM_FIXED = 1; + public static final int tle8888_mode_e_TL_AUTO = 0; + public static final int tle8888_mode_e_TL_HALL = 3; + public static final int tle8888_mode_e_TL_MANUAL = 2; + public static final int tle8888_mode_e_TL_SEMI_AUTO = 1; + public static final int TOOTH_DATA_LENGTH = 2000; + public static final int TOOTH_PACKET_COUNT = 1000; + public static final int TOOTH_PACKET_SIZE = 2; + public static final String TOP_DEAD_CENTER_MESSAGE = "r"; + public static final int TORQUE_CURVE_SIZE = 6; + public static final int TOTAL_CONFIG_SIZE = 22432; + public static final int TPS_2_BYTE_PACKING_MULT = 100; + public static final int TPS_TPS_ACCEL_CLT_CORR_TABLE = 4; + public static final int TPS_TPS_ACCEL_TABLE = 8; + public static final int TransmissionControllerMode_Gm4l6x = 2; + public static final int TransmissionControllerMode_None = 0; + public static final int TransmissionControllerMode_SimpleTransmissionController = 1; + public static final String TRIGGER_COMMENT = "#"; + public static final int trigger_config_s_size = 12; + public static final String TRIGGER_CYCLE_DURATION = "cycleDuration"; + public static final String TRIGGER_GAP_FROM = "gapFrom"; + public static final String TRIGGER_GAP_TO = "gapTo"; + public static final String TRIGGER_GAPS_COUNT = "gapsCount"; + public static final String TRIGGER_HARDCODED_OPERATION_MODE = "knownOperationMode"; + public static final String TRIGGER_HAS_SECOND_CHANNEL = "hasSecondChannel"; + public static final int TRIGGER_INPUT_PIN_COUNT = 2; + public static final String TRIGGER_IS_CRANK_KEY = "crankBased"; + public static final String TRIGGER_IS_SECOND_WHEEL_CAM = "isSecondWheelCam"; + public static final int TRIGGER_SIMULATOR_PIN_COUNT = 2; + public static final int trigger_type_e_Force_4_bytes_size_trigger_type = 70000; + public static final int trigger_type_e_TT_12_TOOTH_CRANK = 38; + public static final int trigger_type_e_TT_1_16 = 50; + public static final int trigger_type_e_TT_2JZ_3_34 = 25; + public static final int trigger_type_e_TT_36_2_1 = 70; + public static final int trigger_type_e_TT_36_2_1_1 = 71; + public static final int trigger_type_e_TT_36_2_2_2 = 23; + public static final int trigger_type_e_TT_3_1_CAM = 31; + public static final int trigger_type_e_TT_60_2_VW = 20; + public static final int trigger_type_e_TT_BENELLI_TRE = 21; + public static final int trigger_type_e_TT_CHRYSLER_NGC_36_2_2 = 30; + public static final int trigger_type_e_TT_DAIHATSU = 6; + public static final int trigger_type_e_TT_DODGE_NEON_1995 = 2; + public static final int trigger_type_e_TT_DODGE_NEON_1995_ONLY_CRANK = 39; + public static final int trigger_type_e_TT_DODGE_NEON_2003_CAM = 14; + public static final int trigger_type_e_TT_DODGE_NEON_2003_CRANK = 32; + public static final int trigger_type_e_TT_DODGE_RAM = 19; + public static final int trigger_type_e_TT_DODGE_STRATUS = 22; + public static final int trigger_type_e_TT_FIAT_IAW_P8 = 41; + public static final int trigger_type_e_TT_FORD_ASPIRE = 1; + public static final int trigger_type_e_TT_FORD_ST170 = 42; + public static final int trigger_type_e_TT_FORD_TFI_PIP = 65; + public static final int trigger_type_e_TT_GM_24x = 27; + public static final int trigger_type_e_TT_GM_24x_2 = 74; + public static final int trigger_type_e_TT_GM_60_2_2_2 = 54; + public static final int trigger_type_e_TT_GM_7X = 5; + public static final int trigger_type_e_TT_HONDA_CBR_600 = 28; + public static final int trigger_type_e_TT_HONDA_K_CAM_4_1 = 67; + public static final int trigger_type_e_TT_HONDA_K_CRANK_12_1 = 46; + public static final int trigger_type_e_TT_JEEP_18_2_2_2 = 37; + public static final int trigger_type_e_TT_JEEP_4_CYL = 40; + public static final int trigger_type_e_TT_KAWA_KX450F = 57; + public static final int trigger_type_e_TT_MAZDA_DOHC_1_4 = 15; + public static final int trigger_type_e_TT_MAZDA_MIATA_NA = 3; + public static final int trigger_type_e_TT_MAZDA_MIATA_VVT_TEST = 35; + public static final int trigger_type_e_TT_MAZDA_SOHC_4 = 7; + public static final int trigger_type_e_TT_MERCEDES_2_SEGMENT = 10; + public static final int trigger_type_e_TT_MIATA_VVT = 33; + public static final int trigger_type_e_TT_MITSU_4G63_CAM = 34; + public static final int trigger_type_e_TT_MITSU_4G9x_CAM = 29; + public static final int trigger_type_e_TT_MITSUBISHI_4G93 = 11; + public static final int trigger_type_e_TT_MITSUBISHI_MESS = 4; + public static final int trigger_type_e_TT_NISSAN_MR18_CAM_VVT = 52; + public static final int trigger_type_e_TT_NISSAN_MR18_CRANK = 68; + public static final int trigger_type_e_TT_NISSAN_QR25 = 61; + public static final int trigger_type_e_TT_NISSAN_SR20VE = 24; + public static final int trigger_type_e_TT_NISSAN_VQ30 = 60; + public static final int trigger_type_e_TT_NISSAN_VQ35 = 58; + public static final int trigger_type_e_TT_ONE = 18; + public static final int trigger_type_e_TT_ONE_PLUS_ONE = 16; + public static final int trigger_type_e_TT_RENIX_44_2_2 = 44; + public static final int trigger_type_e_TT_RENIX_66_2_2_2 = 45; + public static final int trigger_type_e_TT_ROVER_K = 26; + public static final int trigger_type_e_TT_SKODA_FAVORIT = 55; + public static final int trigger_type_e_TT_SUBARU_7_6 = 36; + public static final int trigger_type_e_TT_SUBARU_7_WITHOUT_6 = 51; + public static final int trigger_type_e_TT_SUBARU_EZ30 = 12; + public static final int trigger_type_e_TT_SUBARU_SVX = 49; + public static final int trigger_type_e_TT_SUBARU_SVX_CAM_VVT = 64; + public static final int trigger_type_e_TT_SUBARU_SVX_CRANK_1 = 63; + public static final int trigger_type_e_TT_SUZUKI_G13B = 66; + public static final int trigger_type_e_TT_TOOTHED_WHEEL = 0; + public static final int trigger_type_e_TT_TOOTHED_WHEEL_32_2 = 69; + public static final int trigger_type_e_TT_TOOTHED_WHEEL_36_1 = 9; + public static final int trigger_type_e_TT_TOOTHED_WHEEL_36_2 = 48; + public static final int trigger_type_e_TT_TOOTHED_WHEEL_60_2 = 8; + public static final int trigger_type_e_TT_TRI_TACH = 53; + public static final int trigger_type_e_TT_UNUSED = 75; + public static final int trigger_type_e_TT_VVT_BARRA_3_PLUS_1 = 56; + public static final int trigger_type_e_TT_VVT_BOSCH_QUICK_START = 47; + public static final int trigger_type_e_TT_VVT_JZ = 17; + public static final int trigger_type_e_TT_VVT_MAZDA_SKYACTIV = 13; + public static final int trigger_type_e_TT_VVT_MIATA_NB = 43; + public static final int trigger_type_e_TT_VVT_MITSUBISHI_3A92 = 62; + public static final int trigger_type_e_TT_VVT_MITSUBISHI_6G75 = 72; + public static final int trigger_type_e_TT_VVT_NISSAN_VQ35 = 59; + public static final int trigger_type_e_TT_VVT_TOYOTA_4_1 = 73; + public static final String TRIGGER_WITH_SYNC = "isSynchronizationNeeded"; + public static final String TRIGGERS_FILE_NAME = "triggers.txt"; + public static final int TriggerWheel_T_PRIMARY = 0; + public static final int TriggerWheel_T_SECONDARY = 1; + public static final int TRIM_SIZE = 4; + public static final int TS_BLOCK_READ_TIMEOUT = 3000; + public static final char TS_BURN_COMMAND = 'B'; + public static final char TS_CHUNK_WRITE_COMMAND = 'C'; + public static final int ts_command_e_TS_BENCH_CATEGORY = 22; + public static final int ts_command_e_TS_CLEAR_WARNINGS = 17; + public static final int ts_command_e_TS_COMMAND_1 = 1; + public static final int ts_command_e_TS_COMMAND_11 = 11; + public static final int ts_command_e_TS_COMMAND_12 = 12; + public static final int ts_command_e_TS_COMMAND_13 = 13; + public static final int ts_command_e_TS_COMMAND_14 = 14; + public static final int ts_command_e_TS_COMMAND_15 = 15; + public static final int ts_command_e_TS_COMMAND_16 = 16; + public static final int ts_command_e_TS_COMMAND_4 = 4; + public static final int ts_command_e_TS_COMMAND_5 = 5; + public static final int ts_command_e_TS_COMMAND_9 = 9; + public static final int ts_command_e_TS_DEBUG_MODE = 0; + public static final int ts_command_e_TS_GRAB_PEDAL_UP = 6; + public static final int ts_command_e_TS_GRAB_PEDAL_WOT = 7; + public static final int ts_command_e_TS_GRAB_TPS_CLOSED = 2; + public static final int ts_command_e_TS_GRAB_TPS_WOT = 3; + public static final int ts_command_e_TS_IGNITION_CATEGORY = 18; + public static final int ts_command_e_TS_INJECTOR_CATEGORY = 19; + public static final int ts_command_e_TS_LUA_OUTPUT_CATEGORY = 32; + public static final int ts_command_e_TS_RESET_TLE8888 = 8; + public static final int ts_command_e_TS_SET_DEFAULT_ENGINE = 31; + public static final int ts_command_e_TS_SET_ENGINE_TYPE = 30; + public static final int ts_command_e_TS_SOLENOID_CATEGORY = 25; + public static final int ts_command_e_TS_UNUSED_23 = 23; + public static final int ts_command_e_TS_UNUSED_26 = 26; + public static final int ts_command_e_TS_UNUSED_27 = 27; + public static final int ts_command_e_TS_UNUSED_28 = 28; + public static final int ts_command_e_TS_UNUSED_29 = 29; + public static final int ts_command_e_TS_UNUSED_CJ125_CALIB = 24; + public static final int ts_command_e_TS_WIDEBAND = 21; + public static final int ts_command_e_TS_WRITE_FLASH = 10; + public static final int ts_command_e_TS_X14 = 20; + public static final char TS_COMMAND_F = 'F'; + public static final int TS_COMPOSITE_DISABLE = 2; + public static final int TS_COMPOSITE_ENABLE = 1; + public static final int TS_COMPOSITE_READ = 3; + public static final char TS_CRC_CHECK_COMMAND = 'k'; + public static final char TS_EXECUTE = 'E'; + public static final int TS_FILE_VERSION = 20210312; + public static final int TS_FILE_VERSION_OFFSET = 124; + public static final char TS_GET_COMPOSITE_BUFFER_DONE_DIFFERENTLY = '8'; + public static final char TS_GET_CONFIG_ERROR = 'e'; + public static final char TS_GET_FIRMWARE_VERSION = 'V'; + public static final char TS_GET_OUTPUTS_SIZE = '4'; + public static final char TS_GET_PROTOCOL_VERSION_COMMAND_F = 'F'; + public static final char TS_GET_SCATTERED_GET_COMMAND = '9'; + public static final char TS_GET_TEXT = 'G'; + public static final char TS_HELLO_COMMAND = 'S'; + public static final char TS_IO_TEST_COMMAND = 'Z'; + public static final char TS_ONLINE_PROTOCOL = 'z'; + public static final char TS_OUTPUT_COMMAND = 'O'; + public static final char TS_PAGE_COMMAND = 'P'; + public static final char TS_PERF_TRACE_BEGIN = '_'; + public static final char TS_PERF_TRACE_GET_BUFFER = 'b'; + public static final String TS_PROTOCOL = "001"; + public static final char TS_QUERY_COMMAND = 'Q'; + public static final char TS_READ_COMMAND = 'R'; + public static final int TS_RESPONSE_BURN_OK = 4; + public static final int TS_RESPONSE_COMMAND_OK = 7; + public static final int TS_RESPONSE_CRC_FAILURE = 0x82; + public static final int TS_RESPONSE_FRAMING_ERROR = 0x8D; + public static final int TS_RESPONSE_OK = 0; + public static final int TS_RESPONSE_OUT_OF_RANGE = 0x84; + public static final int TS_RESPONSE_UNDERRUN = 0x80; + public static final int TS_RESPONSE_UNRECOGNIZED_COMMAND = 0x83; + public static final char TS_SET_LOGGER_SWITCH = 'l'; + public static final String TS_SIGNATURE = "rusEFI (FOME) master.2023.02.21.f407-discovery.4145602307"; + public static final char TS_SINGLE_WRITE_COMMAND = 'W'; + public static final char TS_TEST_COMMAND = 't'; + public static final int TS_TOTAL_OUTPUT_SIZE = 1356; + public static final String TS_TRIGGER_SCOPE_CHANNEL_1_NAME = "Channel 1"; + public static final String TS_TRIGGER_SCOPE_CHANNEL_2_NAME = "Channel 2"; + public static final int TS_TRIGGER_SCOPE_DISABLE = 5; + public static final int TS_TRIGGER_SCOPE_ENABLE = 4; + public static final int TS_TRIGGER_SCOPE_READ = 6; + public static final int TsCalMode_EtbKd = 5; + public static final int TsCalMode_EtbKi = 4; + public static final int TsCalMode_EtbKp = 3; + public static final int TsCalMode_None = 0; + public static final int TsCalMode_PedalMax = 13; + public static final int TsCalMode_PedalMin = 12; + public static final int TsCalMode_Tps1Max = 1; + public static final int TsCalMode_Tps1Min = 2; + public static final int TsCalMode_Tps1SecondaryMax = 6; + public static final int TsCalMode_Tps1SecondaryMin = 7; + public static final int TsCalMode_Tps2Max = 8; + public static final int TsCalMode_Tps2Min = 9; + public static final int TsCalMode_Tps2SecondaryMax = 10; + public static final int TsCalMode_Tps2SecondaryMin = 11; + public static final int uart_device_e_UART_DEVICE_1 = 1; + public static final int uart_device_e_UART_DEVICE_2 = 2; + public static final int uart_device_e_UART_DEVICE_3 = 3; + public static final int uart_device_e_UART_DEVICE_4 = 4; + public static final int uart_device_e_UART_NONE = 0; + public static final int VBAT_INJECTOR_CURVE_SIZE = 8; + public static final int VE_BLEND_COUNT = 4; + public static final int ve_override_e_VE_MAP = 1; + public static final int ve_override_e_VE_None = 0; + public static final int ve_override_e_VE_TPS = 2; + public static final int VEHICLE_INFO_SIZE = 32; + public static final int VIN_NUMBER_SIZE = 17; + public static final int VM_VVT_INACTIVE = 0; + public static final int VR_THRESHOLD_COUNT = 2; + public static final int vr_threshold_s_size = 16; + public static final int vvt_mode_e_VVT_2JZ = 2; + public static final int vvt_mode_e_VVT_BARRA_3_PLUS_1 = 8; + public static final int vvt_mode_e_VVT_BOSCH_QUICK_START = 5; + public static final int vvt_mode_e_VVT_FIRST_HALF = 4; + public static final int vvt_mode_e_VVT_FORD_ST170 = 7; + public static final int vvt_mode_e_VVT_HONDA_K_EXHAUST = 16; + public static final int vvt_mode_e_VVT_HONDA_K_INTAKE = 10; + public static final int vvt_mode_e_VVT_INACTIVE = 0; + public static final int vvt_mode_e_VVT_MAP_V_TWIN = 13; + public static final int vvt_mode_e_VVT_MAZDA_SKYACTIV = 15; + public static final int vvt_mode_e_VVT_MIATA_NB = 3; + public static final int vvt_mode_e_VVT_MITSUBISHI_3A92 = 12; + public static final int vvt_mode_e_VVT_MITSUBISHI_4G63 = 18; + public static final int vvt_mode_e_VVT_MITSUBISHI_4G9x = 17; + public static final int vvt_mode_e_VVT_MITSUBISHI_6G75 = 14; + public static final int vvt_mode_e_VVT_NISSAN_MR = 11; + public static final int vvt_mode_e_VVT_NISSAN_VQ = 9; + public static final int vvt_mode_e_VVT_SECOND_HALF = 1; + public static final int vvt_mode_e_VVT_TOYOTA_4_1 = 6; + public static final int WWAE_TABLE_SIZE = 8; + public static final Field ENGINETYPE = Field.create("ENGINETYPE", 0, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SENSORSNIFFERRPMTHRESHOLD = Field.create("SENSORSNIFFERRPMTHRESHOLD", 4, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHRPM = Field.create("LAUNCHRPM", 6, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field RPMHARDLIMIT = Field.create("RPMHARDLIMIT", 8, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ENGINESNIFFERRPMTHRESHOLD = Field.create("ENGINESNIFFERRPMTHRESHOLD", 10, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MULTISPARKMAXRPM = Field.create("MULTISPARKMAXRPM", 12, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field MAXACRPM = Field.create("MAXACRPM", 13, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field MAXACTPS = Field.create("MAXACTPS", 14, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAXACCLT = Field.create("MAXACCLT", 15, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field KNOCKNOISERPMBINS = Field.create("KNOCKNOISERPMBINS", 16, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MULTISPARKMAXSPARKINGANGLE = Field.create("MULTISPARKMAXSPARKINGANGLE", 48, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MULTISPARKMAXEXTRASPARKCOUNT = Field.create("MULTISPARKMAXEXTRASPARKCOUNT", 49, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_50 = Field.create("ALIGNMENTFILL_AT_50", 50, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field INJECTOR_FLOW = Field.create("INJECTOR_FLOW", 52, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTOR_BATTLAGCORRBINS = Field.create("INJECTOR_BATTLAGCORRBINS", 56, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTOR_BATTLAGCORR = Field.create("INJECTOR_BATTLAGCORR", 88, FieldType.FLOAT).setBaseOffset(0); + public static final Field ISFORCEDINDUCTION = Field.create("ISFORCEDINDUCTION", 120, FieldType.BIT, 0).setBaseOffset(0); + public static final Field USEFORDREDUNDANTTPS = Field.create("USEFORDREDUNDANTTPS", 120, FieldType.BIT, 1).setBaseOffset(0); + public static final Field ISVERBOSEAUXPID1 = Field.create("ISVERBOSEAUXPID1", 120, FieldType.BIT, 2).setBaseOffset(0); + public static final Field OVERRIDETRIGGERGAPS = Field.create("OVERRIDETRIGGERGAPS", 120, FieldType.BIT, 3).setBaseOffset(0); + public static final Field ENABLEFAN1WITHAC = Field.create("ENABLEFAN1WITHAC", 120, FieldType.BIT, 4).setBaseOffset(0); + public static final Field ENABLEFAN2WITHAC = Field.create("ENABLEFAN2WITHAC", 120, FieldType.BIT, 5).setBaseOffset(0); + public static final Field DISABLEFAN1WHENSTOPPED = Field.create("DISABLEFAN1WHENSTOPPED", 120, FieldType.BIT, 6).setBaseOffset(0); + public static final Field DISABLEFAN2WHENSTOPPED = Field.create("DISABLEFAN2WHENSTOPPED", 120, FieldType.BIT, 7).setBaseOffset(0); + public static final Field ENABLETRAILINGSPARKS = Field.create("ENABLETRAILINGSPARKS", 120, FieldType.BIT, 8).setBaseOffset(0); + public static final Field ISCJ125VERBOSE = Field.create("ISCJ125VERBOSE", 120, FieldType.BIT, 9).setBaseOffset(0); + public static final Field CJ125ISUADIVIDED = Field.create("CJ125ISUADIVIDED", 120, FieldType.BIT, 10).setBaseOffset(0); + public static final Field CJ125ISLSU49 = Field.create("CJ125ISLSU49", 120, FieldType.BIT, 11).setBaseOffset(0); + public static final Field ETB_USE_TWO_WIRES = Field.create("ETB_USE_TWO_WIRES", 120, FieldType.BIT, 12).setBaseOffset(0); + public static final Field ISDOUBLESOLENOIDIDLE = Field.create("ISDOUBLESOLENOIDIDLE", 120, FieldType.BIT, 13).setBaseOffset(0); + public static final Field USEEEPROM = Field.create("USEEEPROM", 120, FieldType.BIT, 14).setBaseOffset(0); + public static final Field CJ125ISURDIVIDED = Field.create("CJ125ISURDIVIDED", 120, FieldType.BIT, 15).setBaseOffset(0); + public static final Field USECICPIDFORIDLE = Field.create("USECICPIDFORIDLE", 120, FieldType.BIT, 16).setBaseOffset(0); + public static final Field USETLE8888_CRANKING_HACK = Field.create("USETLE8888_CRANKING_HACK", 120, FieldType.BIT, 17).setBaseOffset(0); + public static final Field KICKSTARTCRANKING = Field.create("KICKSTARTCRANKING", 120, FieldType.BIT, 18).setBaseOffset(0); + public static final Field USESEPARATEIDLETABLESFORCRANKINGTAPER = Field.create("USESEPARATEIDLETABLESFORCRANKINGTAPER", 120, FieldType.BIT, 19).setBaseOffset(0); + public static final Field LAUNCHCONTROLENABLED = Field.create("LAUNCHCONTROLENABLED", 120, FieldType.BIT, 20).setBaseOffset(0); + public static final Field DONOTFILTERTRIGGEREDGENOISE = Field.create("DONOTFILTERTRIGGEREDGENOISE", 120, FieldType.BIT, 21).setBaseOffset(0); + public static final Field ANTILAGENABLED = Field.create("ANTILAGENABLED", 120, FieldType.BIT, 22).setBaseOffset(0); + public static final Field USERUNNINGMATHFORCRANKING = Field.create("USERUNNINGMATHFORCRANKING", 120, FieldType.BIT, 23).setBaseOffset(0); + public static final Field DISPLAYLOGICLEVELSINENGINESNIFFER = Field.create("DISPLAYLOGICLEVELSINENGINESNIFFER", 120, FieldType.BIT, 24).setBaseOffset(0); + public static final Field USETLE8888_STEPPER = Field.create("USETLE8888_STEPPER", 120, FieldType.BIT, 25).setBaseOffset(0); + public static final Field ENABLEMAPESTIMATIONTABLEFALLBACK = Field.create("ENABLEMAPESTIMATIONTABLEFALLBACK", 120, FieldType.BIT, 26).setBaseOffset(0); + public static final Field USESCRIPTTABLEFORCANSNIFFINGFILTERING = Field.create("USESCRIPTTABLEFORCANSNIFFINGFILTERING", 120, FieldType.BIT, 27).setBaseOffset(0); + public static final Field VERBOSECAN = Field.create("VERBOSECAN", 120, FieldType.BIT, 28).setBaseOffset(0); + public static final Field ARTIFICIALTESTMISFIRE = Field.create("ARTIFICIALTESTMISFIRE", 120, FieldType.BIT, 29).setBaseOffset(0); + public static final Field USEFORDREDUNDANTPPS = Field.create("USEFORDREDUNDANTPPS", 120, FieldType.BIT, 30).setBaseOffset(0); + public static final Field TPSMIN = Field.create("TPSMIN", 124, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPSMAX = Field.create("TPSMAX", 126, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPSERRORDETECTIONTOOLOW = Field.create("TPSERRORDETECTIONTOOLOW", 128, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPSERRORDETECTIONTOOHIGH = Field.create("TPSERRORDETECTIONTOOHIGH", 130, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field CRANKING_BASEFUEL = Field.create("CRANKING_BASEFUEL", 132, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKING_RPM = Field.create("CRANKING_RPM", 136, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field CRANKING_ALIGNMENTFILL_AT_6 = Field.create("CRANKING_ALIGNMENTFILL_AT_6", 138, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONDWELLFORCRANKINGMS = Field.create("IGNITIONDWELLFORCRANKINGMS", 140, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETBREVLIMITSTART = Field.create("ETBREVLIMITSTART", 144, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBREVLIMITRANGE = Field.create("ETBREVLIMITRANGE", 146, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MAP_SAMPLINGANGLEBINS = Field.create("MAP_SAMPLINGANGLEBINS", 148, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAP_SAMPLINGANGLE = Field.create("MAP_SAMPLINGANGLE", 180, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAP_SAMPLINGWINDOWBINS = Field.create("MAP_SAMPLINGWINDOWBINS", 212, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAP_SAMPLINGWINDOW = Field.create("MAP_SAMPLINGWINDOW", 244, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAP_SENSOR_LOWVALUE = Field.create("MAP_SENSOR_LOWVALUE", 276, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAP_SENSOR_HIGHVALUE = Field.create("MAP_SENSOR_HIGHVALUE", 280, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAP_SENSOR_TYPE = Field.create("MAP_SENSOR_TYPE", 284, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] adc_channel_e = {"Disabled", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PB0", "PB1", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5"}; + public static final Field MAP_SENSOR_HWCHANNEL = Field.create("MAP_SENSOR_HWCHANNEL", 285, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field MAP_SENSOR_ALIGNMENTFILL_AT_10 = Field.create("MAP_SENSOR_ALIGNMENTFILL_AT_10", 286, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CLT_TEMPC_1 = Field.create("CLT_TEMPC_1", 288, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLT_TEMPC_2 = Field.create("CLT_TEMPC_2", 292, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLT_TEMPC_3 = Field.create("CLT_TEMPC_3", 296, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLT_RESISTANCE_1 = Field.create("CLT_RESISTANCE_1", 300, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLT_RESISTANCE_2 = Field.create("CLT_RESISTANCE_2", 304, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLT_RESISTANCE_3 = Field.create("CLT_RESISTANCE_3", 308, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLT_BIAS_RESISTOR = Field.create("CLT_BIAS_RESISTOR", 312, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLT_ADCCHANNEL = Field.create("CLT_ADCCHANNEL", 316, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field CLT_ALIGNMENTFILL_AT_29 = Field.create("CLT_ALIGNMENTFILL_AT_29", 317, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IAT_TEMPC_1 = Field.create("IAT_TEMPC_1", 320, FieldType.FLOAT).setBaseOffset(0); + public static final Field IAT_TEMPC_2 = Field.create("IAT_TEMPC_2", 324, FieldType.FLOAT).setBaseOffset(0); + public static final Field IAT_TEMPC_3 = Field.create("IAT_TEMPC_3", 328, FieldType.FLOAT).setBaseOffset(0); + public static final Field IAT_RESISTANCE_1 = Field.create("IAT_RESISTANCE_1", 332, FieldType.FLOAT).setBaseOffset(0); + public static final Field IAT_RESISTANCE_2 = Field.create("IAT_RESISTANCE_2", 336, FieldType.FLOAT).setBaseOffset(0); + public static final Field IAT_RESISTANCE_3 = Field.create("IAT_RESISTANCE_3", 340, FieldType.FLOAT).setBaseOffset(0); + public static final Field IAT_BIAS_RESISTOR = Field.create("IAT_BIAS_RESISTOR", 344, FieldType.FLOAT).setBaseOffset(0); + public static final Field IAT_ADCCHANNEL = Field.create("IAT_ADCCHANNEL", 348, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field IAT_ALIGNMENTFILL_AT_29 = Field.create("IAT_ALIGNMENTFILL_AT_29", 349, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHTIMINGRETARD = Field.create("LAUNCHTIMINGRETARD", 352, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field HIP9011PRESCALERANDSDO = Field.create("HIP9011PRESCALERANDSDO", 356, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field KNOCKBANDCUSTOM = Field.create("KNOCKBANDCUSTOM", 360, FieldType.FLOAT).setBaseOffset(0); + public static final Field DISPLACEMENT = Field.create("DISPLACEMENT", 364, FieldType.FLOAT).setBaseOffset(0); + public static final Field CYLINDERSCOUNT = Field.create("CYLINDERSCOUNT", 368, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field FIRINGORDER = Field.create("FIRINGORDER", 372, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_9 = Field.create("ALIGNMENTFILL_AT_9", 373, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBORE = Field.create("CYLINDERBORE", 376, FieldType.FLOAT).setBaseOffset(0); + public static final String[] engine_load_mode_e = {"Speed Density", "MAF Air Charge", "Alpha-N", "Lua"}; + public static final Field FUELALGORITHM = Field.create("FUELALGORITHM", 380, FieldType.INT8, engine_load_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALSMAXTPS = Field.create("ALSMAXTPS", 381, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] Gpio = {"NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15"}; + public static final Field CRITICALLEDPIN = Field.create("CRITICALLEDPIN", 382, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CRANKINGINJECTIONMODE = Field.create("CRANKINGINJECTIONMODE", 384, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONMODE = Field.create("INJECTIONMODE", 385, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTCONTROLMINRPM = Field.create("BOOSTCONTROLMINRPM", 386, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTCONTROLMINTPS = Field.create("BOOSTCONTROLMINTPS", 388, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTCONTROLMINMAP = Field.create("BOOSTCONTROLMINMAP", 389, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_390 = Field.create("ALIGNMENTFILL_AT_390", 390, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CRANKINGTIMINGANGLE = Field.create("CRANKINGTIMINGANGLE", 392, FieldType.FLOAT).setBaseOffset(0); + public static final Field IGNITIONMODE = Field.create("IGNITIONMODE", 396, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GAPTRACKINGLENGTHOVERRIDE = Field.create("GAPTRACKINGLENGTHOVERRIDE", 397, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAXIDLEVSS = Field.create("MAXIDLEVSS", 398, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_399 = Field.create("ALIGNMENTFILL_AT_399", 399, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MINOILPRESSUREAFTERSTART = Field.create("MINOILPRESSUREAFTERSTART", 400, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TIMINGMODE = Field.create("TIMINGMODE", 402, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_403 = Field.create("ALIGNMENTFILL_AT_403", 403, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field FIXEDMODETIMING = Field.create("FIXEDMODETIMING", 404, FieldType.FLOAT).setBaseOffset(0); + public static final Field GLOBALTRIGGERANGLEOFFSET = Field.create("GLOBALTRIGGERANGLEOFFSET", 408, FieldType.FLOAT).setBaseOffset(0); + public static final Field ANALOGINPUTDIVIDERCOEFFICIENT = Field.create("ANALOGINPUTDIVIDERCOEFFICIENT", 412, FieldType.FLOAT).setBaseOffset(0); + public static final Field VBATTDIVIDERCOEFF = Field.create("VBATTDIVIDERCOEFF", 416, FieldType.FLOAT).setBaseOffset(0); + public static final Field FANONTEMPERATURE = Field.create("FANONTEMPERATURE", 420, FieldType.FLOAT).setBaseOffset(0); + public static final Field FANOFFTEMPERATURE = Field.create("FANOFFTEMPERATURE", 424, FieldType.FLOAT).setBaseOffset(0); + public static final Field DRIVEWHEELREVPERKM = Field.create("DRIVEWHEELREVPERKM", 428, FieldType.FLOAT).setBaseOffset(0); + public static final Field CANNBCTYPE = Field.create("CANNBCTYPE", 432, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_433 = Field.create("ALIGNMENTFILL_AT_433", 433, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CANSLEEPPERIODMS = Field.create("CANSLEEPPERIODMS", 436, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field DISPLAYMODE = Field.create("DISPLAYMODE", 440, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_441 = Field.create("ALIGNMENTFILL_AT_441", 441, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BYFIRMWAREVERSION = Field.create("BYFIRMWAREVERSION", 444, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field HD44780WIDTH = Field.create("HD44780WIDTH", 448, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field HD44780HEIGHT = Field.create("HD44780HEIGHT", 452, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field TPS1_1ADCCHANNEL = Field.create("TPS1_1ADCCHANNEL", 456, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field VBATTADCCHANNEL = Field.create("VBATTADCCHANNEL", 457, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field FUELLEVELSENSOR = Field.create("FUELLEVELSENSOR", 458, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field TPS2_1ADCCHANNEL = Field.create("TPS2_1ADCCHANNEL", 459, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field IDLE_DERIVATIVEFILTERLOSS = Field.create("IDLE_DERIVATIVEFILTERLOSS", 460, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRAILINGSPARKANGLE = Field.create("TRAILINGSPARKANGLE", 464, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final String[] trigger_type_e = {"custom toothed wheel", "Ford Aspire", "Dodge Neon 1995", "Miata NA", "Mitsubishi Mess 4", "GM_7X", "Cooper R50", "Mazda SOHC 4", "60/2", "36/1", "Mercedes Two Segment", "Mitsubishi 4G93 11", "EZ30", "INVALID", "Dodge Neon 2003", "Mazda DOHC 1+4", "1+1", "INVALID", "Single Tooth", "Dodge Ram 1+16", "60/2 VW", "Benelli Tre", "Dodge Stratus", "36_2_2_2", "Nissan Primera", "dev 2JZ 3/34 simulator", "Rover K", "GM 24x 5 degree", "Honda CBR 600", "Mitsubishi 4G92/93/94 Cam 29", "Honda CBR 600 custom", "3/1 skipped", "Dodge Neon 2003 crank", "Miata NB", "Mitsubishi 4G63 Cam 34", "INVALID", "Subaru 7+6", "Jeep 18-2-2-2", "12 tooth crank", "Dodge Neon 1995 crank only", "Jeep XJ 4 cyl", "FiatIAQ_P8", "Mazda Z5", "INVALID", "Renix 44-2-2", "Renix 66-2-2-2", "Honda K 12+1", "INVALID", "36/2", "Subaru SVX", "1+16", "Subaru 7 without 6", "INVALID", "TriTach", "GM 60/2/2/2", "Skoda Favorit", "Barra 3+1 Cam", "Kawa KX450F", "Nissan VQ35", "INVALID", "Nissan VQ30", "Nissan QR25", "Mitsubishi 3A92", "Subaru SVX Crank 1", "Subaru SVX Cam VVT", "Ford PIP", "Suzuki G13B", "Honda K 4+1", "Nissan MR18 Crank", "32/2", "36-2-1", "36-2-1-1", "INVALID", "INVALID", "GM 24x 3 degree", "trg75"}; + public static final Field TRIGGER_TYPE = Field.create("TRIGGER_TYPE", 468, FieldType.INT, trigger_type_e).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGER_CUSTOMTOTALTOOTHCOUNT = Field.create("TRIGGER_CUSTOMTOTALTOOTHCOUNT", 472, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGER_CUSTOMSKIPPEDTOOTHCOUNT = Field.create("TRIGGER_CUSTOMSKIPPEDTOOTHCOUNT", 476, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field AIRBYRPMTAPER = Field.create("AIRBYRPMTAPER", 480, FieldType.FLOAT).setBaseOffset(0); + public static final Field HIP9011SPIDEVICE = Field.create("HIP9011SPIDEVICE", 484, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field FAILEDMAPFALLBACK = Field.create("FAILEDMAPFALLBACK", 485, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTCONTROLSAFEDUTYCYCLE = Field.create("BOOSTCONTROLSAFEDUTYCYCLE", 486, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAFADCCHANNEL = Field.create("MAFADCCHANNEL", 487, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GLOBALFUELCORRECTION = Field.create("GLOBALFUELCORRECTION", 488, FieldType.FLOAT).setBaseOffset(0); + public static final Field ADCVCC = Field.create("ADCVCC", 492, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAPCAMDETECTIONANGLEPOSITION = Field.create("MAPCAMDETECTIONANGLEPOSITION", 496, FieldType.FLOAT).setBaseOffset(0); + public static final String[] brain_input_pin_e = {"NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15"}; + public static final Field CAMINPUTS1 = Field.create("CAMINPUTS1", 500, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field CAMINPUTS2 = Field.create("CAMINPUTS2", 502, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field CAMINPUTS3 = Field.create("CAMINPUTS3", 504, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field CAMINPUTS4 = Field.create("CAMINPUTS4", 506, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field AFR_HWCHANNEL = Field.create("AFR_HWCHANNEL", 508, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AFR_HWCHANNEL2 = Field.create("AFR_HWCHANNEL2", 509, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AFR_ALIGNMENTFILL_AT_2 = Field.create("AFR_ALIGNMENTFILL_AT_2", 510, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AFR_V1 = Field.create("AFR_V1", 512, FieldType.FLOAT).setBaseOffset(0); + public static final Field AFR_VALUE1 = Field.create("AFR_VALUE1", 516, FieldType.FLOAT).setBaseOffset(0); + public static final Field AFR_V2 = Field.create("AFR_V2", 520, FieldType.FLOAT).setBaseOffset(0); + public static final Field AFR_VALUE2 = Field.create("AFR_VALUE2", 524, FieldType.FLOAT).setBaseOffset(0); + public static final Field THROTTLEPEDALPOSITIONADCCHANNEL = Field.create("THROTTLEPEDALPOSITIONADCCHANNEL", 528, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_529 = Field.create("ALIGNMENTFILL_AT_529", 529, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TLE6240_CS = Field.create("TLE6240_CS", 530, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final String[] pin_output_mode_e = {"default", "default inverted", "open collector", "open collector inverted"}; + public static final Field TLE6240_CSPINMODE = Field.create("TLE6240_CSPINMODE", 532, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_533 = Field.create("ALIGNMENTFILL_AT_533", 533, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] switch_input_pin_e = {"NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15"}; + public static final Field THROTTLEPEDALUPPIN = Field.create("THROTTLEPEDALUPPIN", 534, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field BAROSENSOR_LOWVALUE = Field.create("BAROSENSOR_LOWVALUE", 536, FieldType.FLOAT).setBaseOffset(0); + public static final Field BAROSENSOR_HIGHVALUE = Field.create("BAROSENSOR_HIGHVALUE", 540, FieldType.FLOAT).setBaseOffset(0); + public static final Field BAROSENSOR_TYPE = Field.create("BAROSENSOR_TYPE", 544, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BAROSENSOR_HWCHANNEL = Field.create("BAROSENSOR_HWCHANNEL", 545, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field BAROSENSOR_ALIGNMENTFILL_AT_10 = Field.create("BAROSENSOR_ALIGNMENTFILL_AT_10", 546, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IDLE_SOLENOIDFREQUENCY = Field.create("IDLE_SOLENOIDFREQUENCY", 548, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final String[] output_pin_e = {"NONE", "INVALID", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PA8", "PA9", "PA10", "PA11", "PA12", "PA13", "PA14", "PA15", "PB0", "PB1", "PB2", "PB3", "PB4", "PB5", "PB6", "PB7", "PB8", "PB9", "PB10", "PB11", "PB12", "PB13", "PB14", "PB15", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5", "PC6", "PC7", "PC8", "PC9", "PC10", "PC11", "PC12", "PC13", "PC14", "PC15", "PD0", "PD1", "PD2", "PD3", "PD4", "PD5", "PD6", "PD7", "PD8", "PD9", "PD10", "PD11", "PD12", "PD13", "PD14", "PD15", "PE0", "PE1", "PE2", "PE3", "PE4", "PE5", "PE6", "PE7", "PE8", "PE9", "PE10", "PE11", "PE12", "PE13", "PE14", "PE15", "PF0", "PF1", "PF2", "PF3", "PF4", "PF5", "PF6", "PF7", "PF8", "PF9", "PF10", "PF11", "PF12", "PF13", "PF14", "PF15", "PG0", "PG1", "PG2", "PG3", "PG4", "PG5", "PG6", "PG7", "PG8", "PG9", "PG10", "PG11", "PG12", "PG13", "PG14", "PG15", "PH0", "PH1", "PH2", "PH3", "PH4", "PH5", "PH6", "PH7", "PH8", "PH9", "PH10", "PH11", "PH12", "PH13", "PH14", "PH15", "PI0", "PI1", "PI2", "PI3", "PI4", "PI5", "PI6", "PI7", "PI8", "PI9", "PI10", "PI11", "PI12", "PI13", "PI14", "PI15", "MC33972_1", "MC33972_2", "MC33972_3", "MC33972_4", "MC33972_5", "MC33972_6", "MC33972_7", "MC33972_8", "MC33972_9", "MC33972_10", "MC33972_11", "MC33972_12", "MC33972_13", "MC33972_14", "MC33972_15", "MC33972_16", "MC33972_17", "MC33972_18", "MC33972_19", "MC33972_20", "MC33972_21", "MC33972_22", "TLE8888_1", "TLE8888_2", "TLE8888_3", "TLE8888_4", "TLE8888_5", "TLE8888_6", "TLE8888_7", "TLE8888_8", "TLE8888_9", "TLE8888_10", "TLE8888_11", "TLE8888_12", "TLE8888_13", "TLE8888_14", "TLE8888_15", "TLE8888_16", "TLE8888_17", "TLE8888_18", "TLE8888_19", "TLE8888_20", "TLE8888_21", "TLE8888_22", "TLE8888_23", "TLE8888_24", "TLE8888_25", "TLE8888_26", "TLE8888_27", "TLE8888_28", "INVALID", "INVALID", "INVALID", "TLE6240_1", "TLE6240_2", "TLE6240_3", "TLE6240_4", "TLE6240_5", "TLE6240_6", "TLE6240_7", "TLE6240_8", "TLE6240_9", "TLE6240_10", "TLE6240_11", "TLE6240_12", "TLE6240_13", "TLE6240_14", "TLE6240_15", "TLE6240_16"}; + public static final Field IDLE_SOLENOIDPIN = Field.create("IDLE_SOLENOIDPIN", 552, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IDLE_STEPPERDIRECTIONPIN = Field.create("IDLE_STEPPERDIRECTIONPIN", 554, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field IDLE_STEPPERSTEPPIN = Field.create("IDLE_STEPPERSTEPPIN", 556, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field IDLE_SOLENOIDPINMODE = Field.create("IDLE_SOLENOIDPINMODE", 558, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field IDLE_ALIGNMENTFILL_AT_11 = Field.create("IDLE_ALIGNMENTFILL_AT_11", 559, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MANIDLEPOSITION = Field.create("MANIDLEPOSITION", 560, FieldType.FLOAT).setBaseOffset(0); + public static final Field KNOCKRETARDAGGRESSION = Field.create("KNOCKRETARDAGGRESSION", 564, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field KNOCKRETARDREAPPLYRATE = Field.create("KNOCKRETARDREAPPLYRATE", 565, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field ENGINESYNCCAM = Field.create("ENGINESYNCCAM", 566, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VSSFILTERRECIPROCAL = Field.create("VSSFILTERRECIPROCAL", 567, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VSSGEARRATIO = Field.create("VSSGEARRATIO", 568, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field VSSTOOTHCOUNT = Field.create("VSSTOOTHCOUNT", 570, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_571 = Field.create("ALIGNMENTFILL_AT_571", 571, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field L9779_CS = Field.create("L9779_CS", 572, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_574 = Field.create("ALIGNMENTFILL_AT_574", 574, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERSIMULATORFREQUENCY = Field.create("TRIGGERSIMULATORFREQUENCY", 576, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS1 = Field.create("INJECTIONPINS1", 580, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS2 = Field.create("INJECTIONPINS2", 582, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS3 = Field.create("INJECTIONPINS3", 584, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS4 = Field.create("INJECTIONPINS4", 586, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS5 = Field.create("INJECTIONPINS5", 588, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS6 = Field.create("INJECTIONPINS6", 590, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS7 = Field.create("INJECTIONPINS7", 592, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS8 = Field.create("INJECTIONPINS8", 594, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS9 = Field.create("INJECTIONPINS9", 596, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS10 = Field.create("INJECTIONPINS10", 598, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS11 = Field.create("INJECTIONPINS11", 600, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINS12 = Field.create("INJECTIONPINS12", 602, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS1 = Field.create("IGNITIONPINS1", 604, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS2 = Field.create("IGNITIONPINS2", 606, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS3 = Field.create("IGNITIONPINS3", 608, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS4 = Field.create("IGNITIONPINS4", 610, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS5 = Field.create("IGNITIONPINS5", 612, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS6 = Field.create("IGNITIONPINS6", 614, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS7 = Field.create("IGNITIONPINS7", 616, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS8 = Field.create("IGNITIONPINS8", 618, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS9 = Field.create("IGNITIONPINS9", 620, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS10 = Field.create("IGNITIONPINS10", 622, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS11 = Field.create("IGNITIONPINS11", 624, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINS12 = Field.create("IGNITIONPINS12", 626, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONPINMODE = Field.create("INJECTIONPINMODE", 628, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONPINMODE = Field.create("IGNITIONPINMODE", 629, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field HD44780_RS = Field.create("HD44780_RS", 630, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field HD44780_E = Field.create("HD44780_E", 632, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field HD44780_DB4 = Field.create("HD44780_DB4", 634, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field HD44780_DB5 = Field.create("HD44780_DB5", 636, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field HD44780_DB6 = Field.create("HD44780_DB6", 638, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field HD44780_DB7 = Field.create("HD44780_DB7", 640, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field GPS_RX_PIN = Field.create("GPS_RX_PIN", 642, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field GPS_TX_PIN = Field.create("GPS_TX_PIN", 644, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field FUELPUMPPIN = Field.create("FUELPUMPPIN", 646, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field FUELPUMPPINMODE = Field.create("FUELPUMPPINMODE", 648, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_649 = Field.create("ALIGNMENTFILL_AT_649", 649, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MALFUNCTIONINDICATORPIN = Field.create("MALFUNCTIONINDICATORPIN", 650, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field MALFUNCTIONINDICATORPINMODE = Field.create("MALFUNCTIONINDICATORPINMODE", 652, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field FANPINMODE = Field.create("FANPINMODE", 653, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field FANPIN = Field.create("FANPIN", 654, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field CLUTCHDOWNPIN = Field.create("CLUTCHDOWNPIN", 656, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field ALTERNATORCONTROLPIN = Field.create("ALTERNATORCONTROLPIN", 658, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field ALTERNATORCONTROLPINMODE = Field.create("ALTERNATORCONTROLPINMODE", 660, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final String[] pin_input_mode_e = {"DEFAULT", "PULLUP", "PULLDOWN"}; + public static final Field CLUTCHDOWNPINMODE = Field.create("CLUTCHDOWNPINMODE", 661, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field DIGITALPOTENTIOMETERCHIPSELECT1 = Field.create("DIGITALPOTENTIOMETERCHIPSELECT1", 662, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field DIGITALPOTENTIOMETERCHIPSELECT2 = Field.create("DIGITALPOTENTIOMETERCHIPSELECT2", 664, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field DIGITALPOTENTIOMETERCHIPSELECT3 = Field.create("DIGITALPOTENTIOMETERCHIPSELECT3", 666, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field DIGITALPOTENTIOMETERCHIPSELECT4 = Field.create("DIGITALPOTENTIOMETERCHIPSELECT4", 668, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ELECTRONICTHROTTLEPIN1MODE = Field.create("ELECTRONICTHROTTLEPIN1MODE", 670, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_671 = Field.create("ALIGNMENTFILL_AT_671", 671, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field WBOHEATERPIN = Field.create("WBOHEATERPIN", 672, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CJ125CSPIN = Field.create("CJ125CSPIN", 674, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855SPIDEVICE = Field.create("MAX31855SPIDEVICE", 676, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_677 = Field.create("ALIGNMENTFILL_AT_677", 677, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field DEBUGTRIGGERSYNC = Field.create("DEBUGTRIGGERSYNC", 678, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field DIGITALPOTENTIOMETERSPIDEVICE = Field.create("DIGITALPOTENTIOMETERSPIDEVICE", 680, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_681 = Field.create("ALIGNMENTFILL_AT_681", 681, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MC33972_CS = Field.create("MC33972_CS", 682, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MC33972_CSPINMODE = Field.create("MC33972_CSPINMODE", 684, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXFASTSENSOR1_ADCCHANNEL = Field.create("AUXFASTSENSOR1_ADCCHANNEL", 685, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field TPS1_2ADCCHANNEL = Field.create("TPS1_2ADCCHANNEL", 686, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field TPS2_2ADCCHANNEL = Field.create("TPS2_2ADCCHANNEL", 687, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field THROTTLEPEDALPOSITIONSECONDADCCHANNEL = Field.create("THROTTLEPEDALPOSITIONSECONDADCCHANNEL", 688, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field FUELLEVELVALUES = Field.create("FUELLEVELVALUES", 689, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] ego_sensor_e = {"BPSX", "Innovate", "14Point7", "Narrow", "PLX", "Custom"}; + public static final Field AFR_TYPE = Field.create("AFR_TYPE", 697, FieldType.INT8, ego_sensor_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_698 = Field.create("ALIGNMENTFILL_AT_698", 698, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IDLE_ANTIWINDUPFREQ = Field.create("IDLE_ANTIWINDUPFREQ", 700, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERINPUTPINS1 = Field.create("TRIGGERINPUTPINS1", 704, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERINPUTPINS2 = Field.create("TRIGGERINPUTPINS2", 706, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field MC33_T_MIN_BOOST = Field.create("MC33_T_MIN_BOOST", 708, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field HIP9011CSPINMODE = Field.create("HIP9011CSPINMODE", 710, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_711 = Field.create("ALIGNMENTFILL_AT_711", 711, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TACHOUTPUTPIN = Field.create("TACHOUTPUTPIN", 712, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TACHOUTPUTPINMODE = Field.create("TACHOUTPUTPINMODE", 714, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_715 = Field.create("ALIGNMENTFILL_AT_715", 715, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAINRELAYPIN = Field.create("MAINRELAYPIN", 716, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field SDCARDCSPIN = Field.create("SDCARDCSPIN", 718, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CANTXPIN = Field.create("CANTXPIN", 720, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CANRXPIN = Field.create("CANRXPIN", 722, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field THROTTLEPEDALUPPINMODE = Field.create("THROTTLEPEDALUPPINMODE", 724, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ACIDLEEXTRAOFFSET = Field.create("ACIDLEEXTRAOFFSET", 725, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field FINALGEARRATIO = Field.create("FINALGEARRATIO", 726, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field TCUINPUTSPEEDSENSORPIN = Field.create("TCUINPUTSPEEDSENSORPIN", 728, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCUINPUTSPEEDSENSORTEETH = Field.create("TCUINPUTSPEEDSENSORTEETH", 730, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_731 = Field.create("ALIGNMENTFILL_AT_731", 731, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field WASTEGATEPOSITIONMIN = Field.create("WASTEGATEPOSITIONMIN", 732, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field WASTEGATEPOSITIONMAX = Field.create("WASTEGATEPOSITIONMAX", 734, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLEPOSITIONMIN = Field.create("IDLEPOSITIONMIN", 736, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLEPOSITIONMAX = Field.create("IDLEPOSITIONMAX", 738, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TUNERSTUDIOSERIALSPEED = Field.create("TUNERSTUDIOSERIALSPEED", 740, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field COMPRESSIONRATIO = Field.create("COMPRESSIONRATIO", 744, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERSIMULATORPINS1 = Field.create("TRIGGERSIMULATORPINS1", 748, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERSIMULATORPINS2 = Field.create("TRIGGERSIMULATORPINS2", 750, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field FORDINJECTORSMALLPULSESLOPE = Field.create("FORDINJECTORSMALLPULSESLOPE", 752, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field TRIGGERSIMULATORPINMODES1 = Field.create("TRIGGERSIMULATORPINMODES1", 754, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERSIMULATORPINMODES2 = Field.create("TRIGGERSIMULATORPINMODES2", 755, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field MAF2ADCCHANNEL = Field.create("MAF2ADCCHANNEL", 756, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_757 = Field.create("ALIGNMENTFILL_AT_757", 757, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field O2HEATERPIN = Field.create("O2HEATERPIN", 758, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field O2HEATERPINMODETODO = Field.create("O2HEATERPINMODETODO", 760, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_761 = Field.create("ALIGNMENTFILL_AT_761", 761, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IS_ENABLED_SPI_1 = Field.create("IS_ENABLED_SPI_1", 764, FieldType.BIT, 0).setBaseOffset(0); + public static final Field IS_ENABLED_SPI_2 = Field.create("IS_ENABLED_SPI_2", 764, FieldType.BIT, 1).setBaseOffset(0); + public static final Field IS_ENABLED_SPI_3 = Field.create("IS_ENABLED_SPI_3", 764, FieldType.BIT, 2).setBaseOffset(0); + public static final Field ISSDCARDENABLED = Field.create("ISSDCARDENABLED", 764, FieldType.BIT, 3).setBaseOffset(0); + public static final Field RUSEFIVERBOSE29B = Field.create("RUSEFIVERBOSE29B", 764, FieldType.BIT, 4).setBaseOffset(0); + public static final Field ISENGINECONTROLENABLED = Field.create("ISENGINECONTROLENABLED", 764, FieldType.BIT, 5).setBaseOffset(0); + public static final Field ISHIP9011ENABLED = Field.create("ISHIP9011ENABLED", 764, FieldType.BIT, 6).setBaseOffset(0); + public static final Field ISVERBOSEALTERNATOR = Field.create("ISVERBOSEALTERNATOR", 764, FieldType.BIT, 7).setBaseOffset(0); + public static final Field VERBOSEQUAD = Field.create("VERBOSEQUAD", 764, FieldType.BIT, 8).setBaseOffset(0); + public static final Field USESTEPPERIDLE = Field.create("USESTEPPERIDLE", 764, FieldType.BIT, 9).setBaseOffset(0); + public static final Field ENABLEDSTEP1LIMITER = Field.create("ENABLEDSTEP1LIMITER", 764, FieldType.BIT, 10).setBaseOffset(0); + public static final Field USETPICADVANCEDMODE = Field.create("USETPICADVANCEDMODE", 764, FieldType.BIT, 11).setBaseOffset(0); + public static final Field USELCDSCREEN = Field.create("USELCDSCREEN", 764, FieldType.BIT, 12).setBaseOffset(0); + public static final Field VERBOSETLE8888 = Field.create("VERBOSETLE8888", 764, FieldType.BIT, 13).setBaseOffset(0); + public static final Field ENABLEVERBOSECANTX = Field.create("ENABLEVERBOSECANTX", 764, FieldType.BIT, 14).setBaseOffset(0); + public static final Field ETB1CONFIGURED = Field.create("ETB1CONFIGURED", 764, FieldType.BIT, 15).setBaseOffset(0); + public static final Field ISCJ125ENABLED = Field.create("ISCJ125ENABLED", 764, FieldType.BIT, 16).setBaseOffset(0); + public static final Field ETB2CONFIGURED = Field.create("ETB2CONFIGURED", 764, FieldType.BIT, 17).setBaseOffset(0); + public static final Field MEASUREMAPONLYINONECYLINDER = Field.create("MEASUREMAPONLYINONECYLINDER", 764, FieldType.BIT, 18).setBaseOffset(0); + public static final Field STEPPERFORCEPARKINGEVERYRESTART = Field.create("STEPPERFORCEPARKINGEVERYRESTART", 764, FieldType.BIT, 19).setBaseOffset(0); + public static final Field ISFASTERENGINESPINUPENABLED = Field.create("ISFASTERENGINESPINUPENABLED", 764, FieldType.BIT, 20).setBaseOffset(0); + public static final Field COASTINGFUELCUTENABLED = Field.create("COASTINGFUELCUTENABLED", 764, FieldType.BIT, 21).setBaseOffset(0); + public static final Field USEIACTABLEFORCOASTING = Field.create("USEIACTABLEFORCOASTING", 764, FieldType.BIT, 22).setBaseOffset(0); + public static final Field USENOISELESSTRIGGERDECODER = Field.create("USENOISELESSTRIGGERDECODER", 764, FieldType.BIT, 23).setBaseOffset(0); + public static final Field USEIDLETIMINGPIDCONTROL = Field.create("USEIDLETIMINGPIDCONTROL", 764, FieldType.BIT, 24).setBaseOffset(0); + public static final Field DISABLEETBWHENENGINESTOPPED = Field.create("DISABLEETBWHENENGINESTOPPED", 764, FieldType.BIT, 25).setBaseOffset(0); + public static final Field IS_ENABLED_SPI_4 = Field.create("IS_ENABLED_SPI_4", 764, FieldType.BIT, 26).setBaseOffset(0); + public static final Field PAUSEETBCONTROL = Field.create("PAUSEETBCONTROL", 764, FieldType.BIT, 27).setBaseOffset(0); + public static final Field ALIGNENGINESNIFFERATTDC = Field.create("ALIGNENGINESNIFFERATTDC", 764, FieldType.BIT, 28).setBaseOffset(0); + public static final Field IDLEINCREMENTALPIDCIC = Field.create("IDLEINCREMENTALPIDCIC", 764, FieldType.BIT, 30).setBaseOffset(0); + public static final Field ENABLEAEMXSERIES = Field.create("ENABLEAEMXSERIES", 764, FieldType.BIT, 31).setBaseOffset(0); + public static final Field LOGICANALYZERPINS1 = Field.create("LOGICANALYZERPINS1", 768, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LOGICANALYZERPINS2 = Field.create("LOGICANALYZERPINS2", 770, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LOGICANALYZERPINS3 = Field.create("LOGICANALYZERPINS3", 772, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LOGICANALYZERPINS4 = Field.create("LOGICANALYZERPINS4", 774, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field MAINRELAYPINMODE = Field.create("MAINRELAYPINMODE", 776, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_777 = Field.create("ALIGNMENTFILL_AT_777", 777, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HIP9011CSPIN = Field.create("HIP9011CSPIN", 778, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field HIP9011INTHOLDPIN = Field.create("HIP9011INTHOLDPIN", 780, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field HIP9011INTHOLDPINMODE = Field.create("HIP9011INTHOLDPINMODE", 782, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_783 = Field.create("ALIGNMENTFILL_AT_783", 783, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VERBOSECANBASEADDRESS = Field.create("VERBOSECANBASEADDRESS", 784, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field MC33_HVOLT = Field.create("MC33_HVOLT", 788, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MINIMUMBOOSTCLOSEDLOOPMAP = Field.create("MINIMUMBOOSTCLOSEDLOOPMAP", 789, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ACFANPIN = Field.create("ACFANPIN", 790, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field ACFANPINMODE = Field.create("ACFANPINMODE", 792, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field L9779SPIDEVICE = Field.create("L9779SPIDEVICE", 793, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field DWELLVOLTAGECORRVOLTBINS = Field.create("DWELLVOLTAGECORRVOLTBINS", 794, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field IMUTYPE = Field.create("IMUTYPE", 802, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field DWELLVOLTAGECORRVALUES = Field.create("DWELLVOLTAGECORRVALUES", 803, FieldType.INT8).setScale(0.02).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_811 = Field.create("ALIGNMENTFILL_AT_811", 811, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEHICLEWEIGHT = Field.create("VEHICLEWEIGHT", 812, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLEPIDRPMUPPERLIMIT = Field.create("IDLEPIDRPMUPPERLIMIT", 814, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field APPLYNONLINEARBELOWPULSE = Field.create("APPLYNONLINEARBELOWPULSE", 816, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field LPS25BAROSENSORSCL = Field.create("LPS25BAROSENSORSCL", 818, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LPS25BAROSENSORSDA = Field.create("LPS25BAROSENSORSDA", 820, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field VEHICLESPEEDSENSORINPUTPIN = Field.create("VEHICLESPEEDSENSORINPUTPIN", 822, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field CLUTCHUPPIN = Field.create("CLUTCHUPPIN", 824, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTORNONLINEARMODE = Field.create("INJECTORNONLINEARMODE", 826, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CLUTCHUPPINMODE = Field.create("CLUTCHUPPINMODE", 827, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS1 = Field.create("MAX31855_CS1", 828, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS2 = Field.create("MAX31855_CS2", 830, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS3 = Field.create("MAX31855_CS3", 832, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS4 = Field.create("MAX31855_CS4", 834, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS5 = Field.create("MAX31855_CS5", 836, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS6 = Field.create("MAX31855_CS6", 838, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS7 = Field.create("MAX31855_CS7", 840, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MAX31855_CS8 = Field.create("MAX31855_CS8", 842, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field FLEXSENSORPIN = Field.create("FLEXSENSORPIN", 844, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TEST557PIN = Field.create("TEST557PIN", 846, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDIRECTIONPINMODE = Field.create("STEPPERDIRECTIONPINMODE", 848, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field MC33972SPIDEVICE = Field.create("MC33972SPIDEVICE", 849, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STOICHRATIOSECONDARY = Field.create("STOICHRATIOSECONDARY", 850, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field ETBMAXIMUMPOSITION = Field.create("ETBMAXIMUMPOSITION", 851, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field SDCARDLOGFREQUENCY = Field.create("SDCARDLOGFREQUENCY", 852, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLEPOSITIONSENSOR = Field.create("IDLEPOSITIONSENSOR", 854, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_855 = Field.create("ALIGNMENTFILL_AT_855", 855, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field DEBUGMAPAVERAGING = Field.create("DEBUGMAPAVERAGING", 856, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STARTERRELAYDISABLEPIN = Field.create("STARTERRELAYDISABLEPIN", 858, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field STARTERRELAYDISABLEPINMODE = Field.create("STARTERRELAYDISABLEPINMODE", 860, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_861 = Field.create("ALIGNMENTFILL_AT_861", 861, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field SECONDSOLENOIDPIN = Field.create("SECONDSOLENOIDPIN", 862, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field STARTSTOPBUTTONPIN = Field.create("STARTSTOPBUTTONPIN", 864, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_866 = Field.create("ALIGNMENTFILL_AT_866", 866, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAPMINBUFFERLENGTH = Field.create("MAPMINBUFFERLENGTH", 868, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field IDLEPIDDEACTIVATIONTPSTHRESHOLD = Field.create("IDLEPIDDEACTIVATIONTPSTHRESHOLD", 872, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERPARKINGEXTRASTEPS = Field.create("STEPPERPARKINGEXTRASTEPS", 874, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPS1SECONDARYMIN = Field.create("TPS1SECONDARYMIN", 876, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPS1SECONDARYMAX = Field.create("TPS1SECONDARYMAX", 878, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ANTILAGRPMTRESHOLD = Field.create("ANTILAGRPMTRESHOLD", 880, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field STARTCRANKINGDURATION = Field.create("STARTCRANKINGDURATION", 882, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERERRORPIN = Field.create("TRIGGERERRORPIN", 884, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERERRORPINMODE = Field.create("TRIGGERERRORPINMODE", 886, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_887 = Field.create("ALIGNMENTFILL_AT_887", 887, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ACRELAYPIN = Field.create("ACRELAYPIN", 888, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field ACRELAYPINMODE = Field.create("ACRELAYPINMODE", 890, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_891 = Field.create("ALIGNMENTFILL_AT_891", 891, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING1 = Field.create("SCRIPTSETTING1", 892, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING2 = Field.create("SCRIPTSETTING2", 896, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING3 = Field.create("SCRIPTSETTING3", 900, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING4 = Field.create("SCRIPTSETTING4", 904, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING5 = Field.create("SCRIPTSETTING5", 908, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING6 = Field.create("SCRIPTSETTING6", 912, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING7 = Field.create("SCRIPTSETTING7", 916, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTING8 = Field.create("SCRIPTSETTING8", 920, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field SPI1MOSIPIN = Field.create("SPI1MOSIPIN", 924, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI1MISOPIN = Field.create("SPI1MISOPIN", 926, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI1SCKPIN = Field.create("SPI1SCKPIN", 928, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI2MOSIPIN = Field.create("SPI2MOSIPIN", 930, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI2MISOPIN = Field.create("SPI2MISOPIN", 932, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI2SCKPIN = Field.create("SPI2SCKPIN", 934, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI3MOSIPIN = Field.create("SPI3MOSIPIN", 936, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI3MISOPIN = Field.create("SPI3MISOPIN", 938, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field SPI3SCKPIN = Field.create("SPI3SCKPIN", 940, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CDMINPUTPIN = Field.create("CDMINPUTPIN", 942, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field JOYSTICKCENTERPIN = Field.create("JOYSTICKCENTERPIN", 944, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field JOYSTICKAPIN = Field.create("JOYSTICKAPIN", 946, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field JOYSTICKBPIN = Field.create("JOYSTICKBPIN", 948, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field JOYSTICKCPIN = Field.create("JOYSTICKCPIN", 950, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field JOYSTICKDPIN = Field.create("JOYSTICKDPIN", 952, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CONSOLEUARTDEVICE = Field.create("CONSOLEUARTDEVICE", 954, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] sensor_chart_e = {"none", "trigger", "INVALID", "RPM ACCEL", "DETAILED RPM", "Fast Aux1"}; + public static final Field SENSORCHARTMODE = Field.create("SENSORCHARTMODE", 955, FieldType.INT8, sensor_chart_e).setScale(1.0).setBaseOffset(0); + public static final String[] maf_sensor_type_e = {"v0", "v1", "v2", "v3"}; + public static final Field MAFSENSORTYPE = Field.create("MAFSENSORTYPE", 956, FieldType.INT8, maf_sensor_type_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_957 = Field.create("ALIGNMENTFILL_AT_957", 957, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CLUTCHUPPININVERTED = Field.create("CLUTCHUPPININVERTED", 960, FieldType.BIT, 0).setBaseOffset(0); + public static final Field CLUTCHDOWNPININVERTED = Field.create("CLUTCHDOWNPININVERTED", 960, FieldType.BIT, 1).setBaseOffset(0); + public static final Field USEHBRIDGESTODRIVEIDLESTEPPER = Field.create("USEHBRIDGESTODRIVEIDLESTEPPER", 960, FieldType.BIT, 2).setBaseOffset(0); + public static final Field MULTISPARKENABLE = Field.create("MULTISPARKENABLE", 960, FieldType.BIT, 3).setBaseOffset(0); + public static final Field ENABLELAUNCHRETARD = Field.create("ENABLELAUNCHRETARD", 960, FieldType.BIT, 4).setBaseOffset(0); + public static final Field UNFINISHEDENABLELAUNCHBOOST = Field.create("UNFINISHEDENABLELAUNCHBOOST", 960, FieldType.BIT, 5).setBaseOffset(0); + public static final Field UNFINISHEDLAUNCHDISABLEBYSPEED = Field.create("UNFINISHEDLAUNCHDISABLEBYSPEED", 960, FieldType.BIT, 6).setBaseOffset(0); + public static final Field ENABLECANVSS = Field.create("ENABLECANVSS", 960, FieldType.BIT, 7).setBaseOffset(0); + public static final Field ENABLEINNOVATELC2 = Field.create("ENABLEINNOVATELC2", 960, FieldType.BIT, 8).setBaseOffset(0); + public static final Field SHOWHUMANREADABLEWARNING = Field.create("SHOWHUMANREADABLEWARNING", 960, FieldType.BIT, 9).setBaseOffset(0); + public static final Field STFTIGNOREERRORMAGNITUDE = Field.create("STFTIGNOREERRORMAGNITUDE", 960, FieldType.BIT, 10).setBaseOffset(0); + public static final Field VVTBOOLEANFORVERYSPECIALCASES = Field.create("VVTBOOLEANFORVERYSPECIALCASES", 960, FieldType.BIT, 11).setBaseOffset(0); + public static final Field ENABLESOFTWAREKNOCK = Field.create("ENABLESOFTWAREKNOCK", 960, FieldType.BIT, 12).setBaseOffset(0); + public static final Field VERBOSEVVTDECODING = Field.create("VERBOSEVVTDECODING", 960, FieldType.BIT, 13).setBaseOffset(0); + public static final Field INVERTCAMVVTSIGNAL = Field.create("INVERTCAMVVTSIGNAL", 960, FieldType.BIT, 14).setBaseOffset(0); + public static final Field CONSUMEOBDSENSORS = Field.create("CONSUMEOBDSENSORS", 960, FieldType.BIT, 15).setBaseOffset(0); + public static final Field KNOCKBANKCYL1 = Field.create("KNOCKBANKCYL1", 960, FieldType.BIT, 16).setBaseOffset(0); + public static final Field KNOCKBANKCYL2 = Field.create("KNOCKBANKCYL2", 960, FieldType.BIT, 17).setBaseOffset(0); + public static final Field KNOCKBANKCYL3 = Field.create("KNOCKBANKCYL3", 960, FieldType.BIT, 18).setBaseOffset(0); + public static final Field KNOCKBANKCYL4 = Field.create("KNOCKBANKCYL4", 960, FieldType.BIT, 19).setBaseOffset(0); + public static final Field KNOCKBANKCYL5 = Field.create("KNOCKBANKCYL5", 960, FieldType.BIT, 20).setBaseOffset(0); + public static final Field KNOCKBANKCYL6 = Field.create("KNOCKBANKCYL6", 960, FieldType.BIT, 21).setBaseOffset(0); + public static final Field KNOCKBANKCYL7 = Field.create("KNOCKBANKCYL7", 960, FieldType.BIT, 22).setBaseOffset(0); + public static final Field KNOCKBANKCYL8 = Field.create("KNOCKBANKCYL8", 960, FieldType.BIT, 23).setBaseOffset(0); + public static final Field KNOCKBANKCYL9 = Field.create("KNOCKBANKCYL9", 960, FieldType.BIT, 24).setBaseOffset(0); + public static final Field KNOCKBANKCYL10 = Field.create("KNOCKBANKCYL10", 960, FieldType.BIT, 25).setBaseOffset(0); + public static final Field KNOCKBANKCYL11 = Field.create("KNOCKBANKCYL11", 960, FieldType.BIT, 26).setBaseOffset(0); + public static final Field KNOCKBANKCYL12 = Field.create("KNOCKBANKCYL12", 960, FieldType.BIT, 27).setBaseOffset(0); + public static final Field TCUENABLED = Field.create("TCUENABLED", 960, FieldType.BIT, 28).setBaseOffset(0); + public static final Field CANBROADCASTUSECHANNELTWO = Field.create("CANBROADCASTUSECHANNELTWO", 960, FieldType.BIT, 29).setBaseOffset(0); + public static final Field USERAWOUTPUTTODRIVEIDLESTEPPER = Field.create("USERAWOUTPUTTODRIVEIDLESTEPPER", 960, FieldType.BIT, 30).setBaseOffset(0); + public static final Field VERBOSECAN2 = Field.create("VERBOSECAN2", 960, FieldType.BIT, 31).setBaseOffset(0); + public static final Field ETBIO1_DIRECTIONPIN1 = Field.create("ETBIO1_DIRECTIONPIN1", 964, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ETBIO1_DIRECTIONPIN2 = Field.create("ETBIO1_DIRECTIONPIN2", 966, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ETBIO1_CONTROLPIN = Field.create("ETBIO1_CONTROLPIN", 968, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ETBIO1_DISABLEPIN = Field.create("ETBIO1_DISABLEPIN", 970, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ETBIO2_DIRECTIONPIN1 = Field.create("ETBIO2_DIRECTIONPIN1", 972, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ETBIO2_DIRECTIONPIN2 = Field.create("ETBIO2_DIRECTIONPIN2", 974, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ETBIO2_CONTROLPIN = Field.create("ETBIO2_CONTROLPIN", 976, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ETBIO2_DISABLEPIN = Field.create("ETBIO2_DISABLEPIN", 978, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTCONTROLPIN = Field.create("BOOSTCONTROLPIN", 980, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTCONTROLPINMODE = Field.create("BOOSTCONTROLPINMODE", 982, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_983 = Field.create("ALIGNMENTFILL_AT_983", 983, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALSACTIVATEPIN = Field.create("ALSACTIVATEPIN", 984, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHACTIVATEPIN = Field.create("LAUNCHACTIVATEPIN", 986, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTPID_PFACTOR = Field.create("BOOSTPID_PFACTOR", 988, FieldType.FLOAT).setBaseOffset(0); + public static final Field BOOSTPID_IFACTOR = Field.create("BOOSTPID_IFACTOR", 992, FieldType.FLOAT).setBaseOffset(0); + public static final Field BOOSTPID_DFACTOR = Field.create("BOOSTPID_DFACTOR", 996, FieldType.FLOAT).setBaseOffset(0); + public static final Field BOOSTPID_OFFSET = Field.create("BOOSTPID_OFFSET", 1000, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTPID_PERIODMS = Field.create("BOOSTPID_PERIODMS", 1002, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTPID_MINVALUE = Field.create("BOOSTPID_MINVALUE", 1004, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTPID_MAXVALUE = Field.create("BOOSTPID_MAXVALUE", 1006, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTTYPE = Field.create("BOOSTTYPE", 1008, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1009 = Field.create("ALIGNMENTFILL_AT_1009", 1009, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTPWMFREQUENCY = Field.create("BOOSTPWMFREQUENCY", 1012, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final String[] launchActivationMode_e = {"Launch Button", "Clutch Down Switch", "Always Active(Disabled By Speed)"}; + public static final Field LAUNCHACTIVATIONMODE = Field.create("LAUNCHACTIVATIONMODE", 1016, FieldType.INT8, launchActivationMode_e).setScale(1.0).setBaseOffset(0); + public static final String[] antiLagActivationMode_e = {"Switch Input", "Always Active"}; + public static final Field ANTILAGACTIVATIONMODE = Field.create("ANTILAGACTIVATIONMODE", 1017, FieldType.INT8, antiLagActivationMode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1018 = Field.create("ALIGNMENTFILL_AT_1018", 1018, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHSPEEDTHRESHOLD = Field.create("LAUNCHSPEEDTHRESHOLD", 1020, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHTIMINGRPMRANGE = Field.create("LAUNCHTIMINGRPMRANGE", 1024, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHFUELADDED = Field.create("LAUNCHFUELADDED", 1028, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHBOOSTDUTY = Field.create("LAUNCHBOOSTDUTY", 1032, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field HARDCUTRPMRANGE = Field.create("HARDCUTRPMRANGE", 1036, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field TURBOCHARGERFILTER = Field.create("TURBOCHARGERFILTER", 1040, FieldType.FLOAT).setBaseOffset(0); + public static final Field LAUNCHTPSTHRESHOLD = Field.create("LAUNCHTPSTHRESHOLD", 1044, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHACTIVATEDELAY = Field.create("LAUNCHACTIVATEDELAY", 1048, FieldType.FLOAT).setBaseOffset(0); + public static final Field STFT_MAXIDLEREGIONRPM = Field.create("STFT_MAXIDLEREGIONRPM", 1052, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field STFT_MAXOVERRUNLOAD = Field.create("STFT_MAXOVERRUNLOAD", 1053, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_MINPOWERLOAD = Field.create("STFT_MINPOWERLOAD", 1054, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_DEADBAND = Field.create("STFT_DEADBAND", 1055, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field STFT_MINCLT = Field.create("STFT_MINCLT", 1056, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_MINAFR = Field.create("STFT_MINAFR", 1057, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field STFT_MAXAFR = Field.create("STFT_MAXAFR", 1058, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field STFT_STARTUPDELAY = Field.create("STFT_STARTUPDELAY", 1059, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS1_MAXADD = Field.create("STFT_CELLCFGS1_MAXADD", 1060, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS1_MAXREMOVE = Field.create("STFT_CELLCFGS1_MAXREMOVE", 1061, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS1_TIMECONSTANT = Field.create("STFT_CELLCFGS1_TIMECONSTANT", 1062, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field STFT_CELLCFGS2_MAXADD = Field.create("STFT_CELLCFGS2_MAXADD", 1064, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS2_MAXREMOVE = Field.create("STFT_CELLCFGS2_MAXREMOVE", 1065, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS2_TIMECONSTANT = Field.create("STFT_CELLCFGS2_TIMECONSTANT", 1066, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field STFT_CELLCFGS3_MAXADD = Field.create("STFT_CELLCFGS3_MAXADD", 1068, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS3_MAXREMOVE = Field.create("STFT_CELLCFGS3_MAXREMOVE", 1069, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS3_TIMECONSTANT = Field.create("STFT_CELLCFGS3_TIMECONSTANT", 1070, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field STFT_CELLCFGS4_MAXADD = Field.create("STFT_CELLCFGS4_MAXADD", 1072, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS4_MAXREMOVE = Field.create("STFT_CELLCFGS4_MAXREMOVE", 1073, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STFT_CELLCFGS4_TIMECONSTANT = Field.create("STFT_CELLCFGS4_TIMECONSTANT", 1074, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field STEPPERDCIO1_DIRECTIONPIN1 = Field.create("STEPPERDCIO1_DIRECTIONPIN1", 1076, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCIO1_DIRECTIONPIN2 = Field.create("STEPPERDCIO1_DIRECTIONPIN2", 1078, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCIO1_CONTROLPIN = Field.create("STEPPERDCIO1_CONTROLPIN", 1080, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCIO1_DISABLEPIN = Field.create("STEPPERDCIO1_DISABLEPIN", 1082, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCIO2_DIRECTIONPIN1 = Field.create("STEPPERDCIO2_DIRECTIONPIN1", 1084, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCIO2_DIRECTIONPIN2 = Field.create("STEPPERDCIO2_DIRECTIONPIN2", 1086, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCIO2_CONTROLPIN = Field.create("STEPPERDCIO2_CONTROLPIN", 1088, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCIO2_DISABLEPIN = Field.create("STEPPERDCIO2_DISABLEPIN", 1090, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ENGINEMAKE = Field.create("ENGINEMAKE", 1092, 32, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field ENGINECODE = Field.create("ENGINECODE", 1124, 32, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field VEHICLENAME = Field.create("VEHICLENAME", 1156, 32, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID1 = Field.create("TCU_SOLENOID1", 1188, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID2 = Field.create("TCU_SOLENOID2", 1190, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID3 = Field.create("TCU_SOLENOID3", 1192, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID4 = Field.create("TCU_SOLENOID4", 1194, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID5 = Field.create("TCU_SOLENOID5", 1196, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID6 = Field.create("TCU_SOLENOID6", 1198, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field ETBFUNCTIONS1 = Field.create("ETBFUNCTIONS1", 1200, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ETBFUNCTIONS2 = Field.create("ETBFUNCTIONS2", 1201, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field DRV8860SPIDEVICE = Field.create("DRV8860SPIDEVICE", 1202, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1203 = Field.create("ALIGNMENTFILL_AT_1203", 1203, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field DRV8860_CS = Field.create("DRV8860_CS", 1204, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field DRV8860_CSPINMODE = Field.create("DRV8860_CSPINMODE", 1206, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1207 = Field.create("ALIGNMENTFILL_AT_1207", 1207, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field DRV8860_MISO = Field.create("DRV8860_MISO", 1208, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field FUELLEVELBINS = Field.create("FUELLEVELBINS", 1210, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field LUAOUTPUTPINS1 = Field.create("LUAOUTPUTPINS1", 1226, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LUAOUTPUTPINS2 = Field.create("LUAOUTPUTPINS2", 1228, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LUAOUTPUTPINS3 = Field.create("LUAOUTPUTPINS3", 1230, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LUAOUTPUTPINS4 = Field.create("LUAOUTPUTPINS4", 1232, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LUAOUTPUTPINS5 = Field.create("LUAOUTPUTPINS5", 1234, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LUAOUTPUTPINS6 = Field.create("LUAOUTPUTPINS6", 1236, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LUAOUTPUTPINS7 = Field.create("LUAOUTPUTPINS7", 1238, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LUAOUTPUTPINS8 = Field.create("LUAOUTPUTPINS8", 1240, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1242 = Field.create("ALIGNMENTFILL_AT_1242", 1242, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VVTOFFSETS1 = Field.create("VVTOFFSETS1", 1244, FieldType.FLOAT).setBaseOffset(0); + public static final Field VVTOFFSETS2 = Field.create("VVTOFFSETS2", 1248, FieldType.FLOAT).setBaseOffset(0); + public static final Field VVTOFFSETS3 = Field.create("VVTOFFSETS3", 1252, FieldType.FLOAT).setBaseOffset(0); + public static final Field VVTOFFSETS4 = Field.create("VVTOFFSETS4", 1256, FieldType.FLOAT).setBaseOffset(0); + public static final Field VRTHRESHOLD1_RPMBINS = Field.create("VRTHRESHOLD1_RPMBINS", 1260, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field VRTHRESHOLD1_VALUES = Field.create("VRTHRESHOLD1_VALUES", 1266, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field VRTHRESHOLD1_PIN = Field.create("VRTHRESHOLD1_PIN", 1272, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field VRTHRESHOLD1_ALIGNMENTFILL_AT_14 = Field.create("VRTHRESHOLD1_ALIGNMENTFILL_AT_14", 1274, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VRTHRESHOLD2_RPMBINS = Field.create("VRTHRESHOLD2_RPMBINS", 1276, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field VRTHRESHOLD2_VALUES = Field.create("VRTHRESHOLD2_VALUES", 1282, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field VRTHRESHOLD2_PIN = Field.create("VRTHRESHOLD2_PIN", 1288, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field VRTHRESHOLD2_ALIGNMENTFILL_AT_14 = Field.create("VRTHRESHOLD2_ALIGNMENTFILL_AT_14", 1290, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWMNOTE1 = Field.create("GPPWMNOTE1", 1292, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field GPPWMNOTE2 = Field.create("GPPWMNOTE2", 1308, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field GPPWMNOTE3 = Field.create("GPPWMNOTE3", 1324, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field GPPWMNOTE4 = Field.create("GPPWMNOTE4", 1340, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field TPS2SECONDARYMIN = Field.create("TPS2SECONDARYMIN", 1356, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPS2SECONDARYMAX = Field.create("TPS2SECONDARYMAX", 1358, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field WIDEBANDONSECONDBUS = Field.create("WIDEBANDONSECONDBUS", 1360, FieldType.BIT, 0).setBaseOffset(0); + public static final Field FUELCLOSEDLOOPCORRECTIONENABLED = Field.create("FUELCLOSEDLOOPCORRECTIONENABLED", 1360, FieldType.BIT, 1).setBaseOffset(0); + public static final Field ISVERBOSEIAC = Field.create("ISVERBOSEIAC", 1360, FieldType.BIT, 2).setBaseOffset(0); + public static final Field BOARDUSETACHPULLUP = Field.create("BOARDUSETACHPULLUP", 1360, FieldType.BIT, 3).setBaseOffset(0); + public static final Field BOARDUSETEMPPULLUP = Field.create("BOARDUSETEMPPULLUP", 1360, FieldType.BIT, 4).setBaseOffset(0); + public static final Field YESUNDERSTANDLOCKING = Field.create("YESUNDERSTANDLOCKING", 1360, FieldType.BIT, 5).setBaseOffset(0); + public static final Field SILENTTRIGGERERROR = Field.create("SILENTTRIGGERERROR", 1360, FieldType.BIT, 6).setBaseOffset(0); + public static final Field USELINEARCLTSENSOR = Field.create("USELINEARCLTSENSOR", 1360, FieldType.BIT, 7).setBaseOffset(0); + public static final Field CANREADENABLED = Field.create("CANREADENABLED", 1360, FieldType.BIT, 8).setBaseOffset(0); + public static final Field CANWRITEENABLED = Field.create("CANWRITEENABLED", 1360, FieldType.BIT, 9).setBaseOffset(0); + public static final Field USELINEARIATSENSOR = Field.create("USELINEARIATSENSOR", 1360, FieldType.BIT, 10).setBaseOffset(0); + public static final Field BOARDUSE2STEPPULLDOWN = Field.create("BOARDUSE2STEPPULLDOWN", 1360, FieldType.BIT, 11).setBaseOffset(0); + public static final Field TACHPULSEDURATIONASDUTYCYCLE = Field.create("TACHPULSEDURATIONASDUTYCYCLE", 1360, FieldType.BIT, 12).setBaseOffset(0); + public static final Field ISALTERNATORCONTROLENABLED = Field.create("ISALTERNATORCONTROLENABLED", 1360, FieldType.BIT, 13).setBaseOffset(0); + public static final Field INVERTPRIMARYTRIGGERSIGNAL = Field.create("INVERTPRIMARYTRIGGERSIGNAL", 1360, FieldType.BIT, 14).setBaseOffset(0); + public static final Field INVERTSECONDARYTRIGGERSIGNAL = Field.create("INVERTSECONDARYTRIGGERSIGNAL", 1360, FieldType.BIT, 15).setBaseOffset(0); + public static final Field CUTFUELONHARDLIMIT = Field.create("CUTFUELONHARDLIMIT", 1360, FieldType.BIT, 16).setBaseOffset(0); + public static final Field CUTSPARKONHARDLIMIT = Field.create("CUTSPARKONHARDLIMIT", 1360, FieldType.BIT, 17).setBaseOffset(0); + public static final Field LAUNCHFUELCUTENABLE = Field.create("LAUNCHFUELCUTENABLE", 1360, FieldType.BIT, 18).setBaseOffset(0); + public static final Field LAUNCHSPARKCUTENABLE = Field.create("LAUNCHSPARKCUTENABLE", 1360, FieldType.BIT, 19).setBaseOffset(0); + public static final Field BOARDUSECRANKPULLUP = Field.create("BOARDUSECRANKPULLUP", 1360, FieldType.BIT, 20).setBaseOffset(0); + public static final Field BOARDUSECAMPULLDOWN = Field.create("BOARDUSECAMPULLDOWN", 1360, FieldType.BIT, 21).setBaseOffset(0); + public static final Field BOARDUSECAMVRPULLUP = Field.create("BOARDUSECAMVRPULLUP", 1360, FieldType.BIT, 22).setBaseOffset(0); + public static final Field BOARDUSED2PULLDOWN = Field.create("BOARDUSED2PULLDOWN", 1360, FieldType.BIT, 23).setBaseOffset(0); + public static final Field BOARDUSED3PULLDOWN = Field.create("BOARDUSED3PULLDOWN", 1360, FieldType.BIT, 24).setBaseOffset(0); + public static final Field BOARDUSED4PULLDOWN = Field.create("BOARDUSED4PULLDOWN", 1360, FieldType.BIT, 25).setBaseOffset(0); + public static final Field BOARDUSED5PULLDOWN = Field.create("BOARDUSED5PULLDOWN", 1360, FieldType.BIT, 26).setBaseOffset(0); + public static final Field VERBOSEISOTP = Field.create("VERBOSEISOTP", 1360, FieldType.BIT, 27).setBaseOffset(0); + public static final Field ENGINESNIFFERFOCUSONINPUTS = Field.create("ENGINESNIFFERFOCUSONINPUTS", 1360, FieldType.BIT, 28).setBaseOffset(0); + public static final Field LAUNCHACTIVATEINVERTED = Field.create("LAUNCHACTIVATEINVERTED", 1360, FieldType.BIT, 29).setBaseOffset(0); + public static final Field TWOSTROKE = Field.create("TWOSTROKE", 1360, FieldType.BIT, 30).setBaseOffset(0); + public static final Field SKIPPEDWHEELONCAM = Field.create("SKIPPEDWHEELONCAM", 1360, FieldType.BIT, 31).setBaseOffset(0); + public static final Field HIPOUTPUTCHANNEL = Field.create("HIPOUTPUTCHANNEL", 1364, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1365 = Field.create("ALIGNMENTFILL_AT_1365", 1365, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ACSWITCH = Field.create("ACSWITCH", 1366, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field VREFADCCHANNEL = Field.create("VREFADCCHANNEL", 1368, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field ETBNEUTRALPOSITION = Field.create("ETBNEUTRALPOSITION", 1369, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IDLEMODE = Field.create("IDLEMODE", 1370, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1371 = Field.create("ALIGNMENTFILL_AT_1371", 1371, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ISINJECTIONENABLED = Field.create("ISINJECTIONENABLED", 1372, FieldType.BIT, 0).setBaseOffset(0); + public static final Field ISIGNITIONENABLED = Field.create("ISIGNITIONENABLED", 1372, FieldType.BIT, 1).setBaseOffset(0); + public static final Field ISCYLINDERCLEANUPENABLED = Field.create("ISCYLINDERCLEANUPENABLED", 1372, FieldType.BIT, 2).setBaseOffset(0); + public static final Field COMPLEXWALLMODEL = Field.create("COMPLEXWALLMODEL", 1372, FieldType.BIT, 3).setBaseOffset(0); + public static final Field ALWAYSINSTANTRPM = Field.create("ALWAYSINSTANTRPM", 1372, FieldType.BIT, 4).setBaseOffset(0); + public static final Field ISMAPAVERAGINGENABLED = Field.create("ISMAPAVERAGINGENABLED", 1372, FieldType.BIT, 5).setBaseOffset(0); + public static final Field OVERRIDECRANKINGIACSETTING = Field.create("OVERRIDECRANKINGIACSETTING", 1372, FieldType.BIT, 6).setBaseOffset(0); + public static final Field USESEPARATEADVANCEFORIDLE = Field.create("USESEPARATEADVANCEFORIDLE", 1372, FieldType.BIT, 7).setBaseOffset(0); + public static final Field ISWAVEANALYZERENABLED = Field.create("ISWAVEANALYZERENABLED", 1372, FieldType.BIT, 8).setBaseOffset(0); + public static final Field USESEPARATEVEFORIDLE = Field.create("USESEPARATEVEFORIDLE", 1372, FieldType.BIT, 9).setBaseOffset(0); + public static final Field VERBOSETRIGGERSYNCHDETAILS = Field.create("VERBOSETRIGGERSYNCHDETAILS", 1372, FieldType.BIT, 10).setBaseOffset(0); + public static final Field ISMANUALSPINNINGMODE = Field.create("ISMANUALSPINNINGMODE", 1372, FieldType.BIT, 11).setBaseOffset(0); + public static final Field TWOWIREBATCHINJECTION = Field.create("TWOWIREBATCHINJECTION", 1372, FieldType.BIT, 12).setBaseOffset(0); + public static final Field NEVERINSTANTRPM = Field.create("NEVERINSTANTRPM", 1372, FieldType.BIT, 13).setBaseOffset(0); + public static final Field TWOWIREBATCHIGNITION = Field.create("TWOWIREBATCHIGNITION", 1372, FieldType.BIT, 14).setBaseOffset(0); + public static final Field USEFIXEDBAROCORRFROMMAP = Field.create("USEFIXEDBAROCORRFROMMAP", 1372, FieldType.BIT, 15).setBaseOffset(0); + public static final Field USESEPARATEADVANCEFORCRANKING = Field.create("USESEPARATEADVANCEFORCRANKING", 1372, FieldType.BIT, 16).setBaseOffset(0); + public static final Field USEADVANCECORRECTIONSFORCRANKING = Field.create("USEADVANCECORRECTIONSFORCRANKING", 1372, FieldType.BIT, 17).setBaseOffset(0); + public static final Field FLEXCRANKING = Field.create("FLEXCRANKING", 1372, FieldType.BIT, 18).setBaseOffset(0); + public static final Field USEIACPIDMULTTABLE = Field.create("USEIACPIDMULTTABLE", 1372, FieldType.BIT, 19).setBaseOffset(0); + public static final Field ISBOOSTCONTROLENABLED = Field.create("ISBOOSTCONTROLENABLED", 1372, FieldType.BIT, 20).setBaseOffset(0); + public static final Field LAUNCHSMOOTHRETARD = Field.create("LAUNCHSMOOTHRETARD", 1372, FieldType.BIT, 21).setBaseOffset(0); + public static final Field ISPHASESYNCREQUIREDFORIGNITION = Field.create("ISPHASESYNCREQUIREDFORIGNITION", 1372, FieldType.BIT, 22).setBaseOffset(0); + public static final Field USECLTBASEDRPMLIMIT = Field.create("USECLTBASEDRPMLIMIT", 1372, FieldType.BIT, 23).setBaseOffset(0); + public static final Field FORCEO2HEATING = Field.create("FORCEO2HEATING", 1372, FieldType.BIT, 24).setBaseOffset(0); + public static final Field INVERTVVTCONTROLINTAKE = Field.create("INVERTVVTCONTROLINTAKE", 1372, FieldType.BIT, 25).setBaseOffset(0); + public static final Field INVERTVVTCONTROLEXHAUST = Field.create("INVERTVVTCONTROLEXHAUST", 1372, FieldType.BIT, 26).setBaseOffset(0); + public static final Field USEBIQUADONAUXSPEEDSENSORS = Field.create("USEBIQUADONAUXSPEEDSENSORS", 1372, FieldType.BIT, 27).setBaseOffset(0); + public static final Field SDTRIGGERLOG = Field.create("SDTRIGGERLOG", 1372, FieldType.BIT, 28).setBaseOffset(0); + public static final Field ALSACTIVATEINVERTED = Field.create("ALSACTIVATEINVERTED", 1372, FieldType.BIT, 29).setBaseOffset(0); + public static final Field TEMPBOOLEANFORVERYSPECIALLOGIC = Field.create("TEMPBOOLEANFORVERYSPECIALLOGIC", 1372, FieldType.BIT, 31).setBaseOffset(0); + public static final Field ENGINECHARTSIZE = Field.create("ENGINECHARTSIZE", 1376, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field TURBOSPEEDSENSORMULTIPLIER = Field.create("TURBOSPEEDSENSORMULTIPLIER", 1380, FieldType.FLOAT).setBaseOffset(0); + public static final Field CAMINPUTSDEBUG1 = Field.create("CAMINPUTSDEBUG1", 1384, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CAMINPUTSDEBUG2 = Field.create("CAMINPUTSDEBUG2", 1386, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CAMINPUTSDEBUG3 = Field.create("CAMINPUTSDEBUG3", 1388, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CAMINPUTSDEBUG4 = Field.create("CAMINPUTSDEBUG4", 1390, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ACIDLERPMBUMP = Field.create("ACIDLERPMBUMP", 1392, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field WARNINGPERIOD = Field.create("WARNINGPERIOD", 1394, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field KNOCKDETECTIONWINDOWSTART = Field.create("KNOCKDETECTIONWINDOWSTART", 1396, FieldType.FLOAT).setBaseOffset(0); + public static final Field KNOCKDETECTIONWINDOWEND = Field.create("KNOCKDETECTIONWINDOWEND", 1400, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLESTEPPERREACTIONTIME = Field.create("IDLESTEPPERREACTIONTIME", 1404, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLESTEPPERTOTALSTEPS = Field.create("IDLESTEPPERTOTALSTEPS", 1408, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field NOACCELAFTERHARDLIMITPERIODSECS = Field.create("NOACCELAFTERHARDLIMITPERIODSECS", 1412, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAPAVERAGINGSCHEDULINGATINDEX = Field.create("MAPAVERAGINGSCHEDULINGATINDEX", 1416, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field TACHPULSEDURACTIONMS = Field.create("TACHPULSEDURACTIONMS", 1420, FieldType.FLOAT).setBaseOffset(0); + public static final Field WWAETAU = Field.create("WWAETAU", 1424, FieldType.FLOAT).setBaseOffset(0); + public static final Field ALTERNATORCONTROL_PFACTOR = Field.create("ALTERNATORCONTROL_PFACTOR", 1428, FieldType.FLOAT).setBaseOffset(0); + public static final Field ALTERNATORCONTROL_IFACTOR = Field.create("ALTERNATORCONTROL_IFACTOR", 1432, FieldType.FLOAT).setBaseOffset(0); + public static final Field ALTERNATORCONTROL_DFACTOR = Field.create("ALTERNATORCONTROL_DFACTOR", 1436, FieldType.FLOAT).setBaseOffset(0); + public static final Field ALTERNATORCONTROL_OFFSET = Field.create("ALTERNATORCONTROL_OFFSET", 1440, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALTERNATORCONTROL_PERIODMS = Field.create("ALTERNATORCONTROL_PERIODMS", 1442, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALTERNATORCONTROL_MINVALUE = Field.create("ALTERNATORCONTROL_MINVALUE", 1444, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALTERNATORCONTROL_MAXVALUE = Field.create("ALTERNATORCONTROL_MAXVALUE", 1446, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETB_PFACTOR = Field.create("ETB_PFACTOR", 1448, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETB_IFACTOR = Field.create("ETB_IFACTOR", 1452, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETB_DFACTOR = Field.create("ETB_DFACTOR", 1456, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETB_OFFSET = Field.create("ETB_OFFSET", 1460, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETB_PERIODMS = Field.create("ETB_PERIODMS", 1462, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETB_MINVALUE = Field.create("ETB_MINVALUE", 1464, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETB_MAXVALUE = Field.create("ETB_MAXVALUE", 1466, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERINPUTDEBUGPINS1 = Field.create("TRIGGERINPUTDEBUGPINS1", 1468, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERINPUTDEBUGPINS2 = Field.create("TRIGGERINPUTDEBUGPINS2", 1470, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field AIRTAPERRPMRANGE = Field.create("AIRTAPERRPMRANGE", 1472, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TURBOSPEEDSENSORINPUTPIN = Field.create("TURBOSPEEDSENSORINPUTPIN", 1474, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TPS2MIN = Field.create("TPS2MIN", 1476, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPS2MAX = Field.create("TPS2MAX", 1478, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field STARTERCONTROLPIN = Field.create("STARTERCONTROLPIN", 1480, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field STARTSTOPBUTTONMODE = Field.create("STARTSTOPBUTTONMODE", 1482, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1483 = Field.create("ALIGNMENTFILL_AT_1483", 1483, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MC33816_FLAG0 = Field.create("MC33816_FLAG0", 1484, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TACHPULSEPERREV = Field.create("TACHPULSEPERREV", 1486, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1487 = Field.create("ALIGNMENTFILL_AT_1487", 1487, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAPERRORDETECTIONTOOLOW = Field.create("MAPERRORDETECTIONTOOLOW", 1488, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAPERRORDETECTIONTOOHIGH = Field.create("MAPERRORDETECTIONTOOHIGH", 1492, FieldType.FLOAT).setBaseOffset(0); + public static final Field MULTISPARKSPARKDURATION = Field.create("MULTISPARKSPARKDURATION", 1496, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field MULTISPARKDWELL = Field.create("MULTISPARKDWELL", 1498, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field IDLERPMPID_PFACTOR = Field.create("IDLERPMPID_PFACTOR", 1500, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLERPMPID_IFACTOR = Field.create("IDLERPMPID_IFACTOR", 1504, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLERPMPID_DFACTOR = Field.create("IDLERPMPID_DFACTOR", 1508, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLERPMPID_OFFSET = Field.create("IDLERPMPID_OFFSET", 1512, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLERPMPID_PERIODMS = Field.create("IDLERPMPID_PERIODMS", 1514, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLERPMPID_MINVALUE = Field.create("IDLERPMPID_MINVALUE", 1516, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLERPMPID_MAXVALUE = Field.create("IDLERPMPID_MAXVALUE", 1518, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field WWAEBETA = Field.create("WWAEBETA", 1520, FieldType.FLOAT).setBaseOffset(0); + public static final Field COMMUNICATIONLEDPIN = Field.create("COMMUNICATIONLEDPIN", 1524, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field RUNNINGLEDPIN = Field.create("RUNNINGLEDPIN", 1526, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field BINARYSERIALTXPIN = Field.create("BINARYSERIALTXPIN", 1528, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field BINARYSERIALRXPIN = Field.create("BINARYSERIALRXPIN", 1530, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field AUXVALVES1 = Field.create("AUXVALVES1", 1532, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field AUXVALVES2 = Field.create("AUXVALVES2", 1534, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TCUUPSHIFTBUTTONPIN = Field.create("TCUUPSHIFTBUTTONPIN", 1536, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCUDOWNSHIFTBUTTONPIN = Field.create("TCUDOWNSHIFTBUTTONPIN", 1538, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field THROTTLEPEDALUPVOLTAGE = Field.create("THROTTLEPEDALUPVOLTAGE", 1540, FieldType.FLOAT).setBaseOffset(0); + public static final Field THROTTLEPEDALWOTVOLTAGE = Field.create("THROTTLEPEDALWOTVOLTAGE", 1544, FieldType.FLOAT).setBaseOffset(0); + public static final Field STARTUPFUELPUMPDURATION = Field.create("STARTUPFUELPUMPDURATION", 1548, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLEPIDRPMDEADZONE = Field.create("IDLEPIDRPMDEADZONE", 1550, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TARGETVBATT = Field.create("TARGETVBATT", 1552, FieldType.FLOAT).setBaseOffset(0); + public static final Field ALTERNATOROFFABOVETPS = Field.create("ALTERNATOROFFABOVETPS", 1556, FieldType.FLOAT).setBaseOffset(0); + public static final Field AFTERCRANKINGIACTAPERDURATION = Field.create("AFTERCRANKINGIACTAPERDURATION", 1560, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IACBYTPSTAPER = Field.create("IACBYTPSTAPER", 1562, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXSERIALTXPIN = Field.create("AUXSERIALTXPIN", 1564, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field WARNINGLEDPIN = Field.create("WARNINGLEDPIN", 1566, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field AUXSERIALRXPIN = Field.create("AUXSERIALRXPIN", 1568, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LIS302DLCSPIN = Field.create("LIS302DLCSPIN", 1570, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TPSACCELLOOKBACK = Field.create("TPSACCELLOOKBACK", 1572, FieldType.INT8).setScale(0.05).setBaseOffset(0); + public static final Field COASTINGFUELCUTVSSLOW = Field.create("COASTINGFUELCUTVSSLOW", 1573, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field COASTINGFUELCUTVSSHIGH = Field.create("COASTINGFUELCUTVSSHIGH", 1574, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field NOFUELTRIMAFTERDFCOTIME = Field.create("NOFUELTRIMAFTERDFCOTIME", 1575, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field TPSACCELENRICHMENTTHRESHOLD = Field.create("TPSACCELENRICHMENTTHRESHOLD", 1576, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXSPEEDSENSORINPUTPIN1 = Field.create("AUXSPEEDSENSORINPUTPIN1", 1580, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXSPEEDSENSORINPUTPIN2 = Field.create("AUXSPEEDSENSORINPUTPIN2", 1582, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TOTALGEARSCOUNT = Field.create("TOTALGEARSCOUNT", 1584, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field INJECTIONTIMINGMODE = Field.create("INJECTIONTIMINGMODE", 1585, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1586 = Field.create("ALIGNMENTFILL_AT_1586", 1586, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field UARTCONSOLESERIALSPEED = Field.create("UARTCONSOLESERIALSPEED", 1588, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field TPSDECELENLEANMENTTHRESHOLD = Field.create("TPSDECELENLEANMENTTHRESHOLD", 1592, FieldType.FLOAT).setBaseOffset(0); + public static final Field TPSDECELENLEANMENTMULTIPLIER = Field.create("TPSDECELENLEANMENTMULTIPLIER", 1596, FieldType.FLOAT).setBaseOffset(0); + public static final Field SLOWADCALPHA = Field.create("SLOWADCALPHA", 1600, FieldType.FLOAT).setBaseOffset(0); + public static final String[] debug_mode_e = {"INVALID", "TPS acceleration enrichment", "INVALID", "Stepper Idle Control", "Engine Load accl enrich", "Trigger Counters", "Soft Spark Cut", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "SD card", "sr5", "Knock", "INVALID", "Electronic Throttle", "Executor", "Bench Test / TS commands", "INVALID", "Analog inputs #1", "INSTANT_RPM", "INVALID", "Status", "CJ125", "INVALID", "MAP", "Metrics", "INVALID", "Ion Sense", "TLE8888", "Analog inputs #2", "Dwell Metric", "INVALID", "INVALID", "Boost Control", "INVALID", "INVALID", "ETB Autotune", "Composite Log", "INVALID", "INVALID", "INVALID", "Dyno_View", "Logic_Analyzer", "INVALID", "TCU", "Lua"}; + public static final Field DEBUGMODE = Field.create("DEBUGMODE", 1604, FieldType.INT8, debug_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1605 = Field.create("ALIGNMENTFILL_AT_1605", 1605, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AUXSERIALSPEED = Field.create("AUXSERIALSPEED", 1608, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field THROTTLEPEDALSECONDARYUPVOLTAGE = Field.create("THROTTLEPEDALSECONDARYUPVOLTAGE", 1612, FieldType.FLOAT).setBaseOffset(0); + public static final Field THROTTLEPEDALSECONDARYWOTVOLTAGE = Field.create("THROTTLEPEDALSECONDARYWOTVOLTAGE", 1616, FieldType.FLOAT).setBaseOffset(0); + public static final String[] can_baudrate_e = {"50kbps", "83.33kbps", "100kbps", "125kbps", "250kbps", "500kbps", "1Mbps"}; + public static final Field CANBAUDRATE = Field.create("CANBAUDRATE", 1620, FieldType.INT8, can_baudrate_e).setScale(1.0).setBaseOffset(0); + public static final String[] ve_override_e = {"None", "MAP", "TPS"}; + public static final Field VEOVERRIDEMODE = Field.create("VEOVERRIDEMODE", 1621, FieldType.INT8, ve_override_e).setScale(1.0).setBaseOffset(0); + public static final Field CAN2BAUDRATE = Field.create("CAN2BAUDRATE", 1622, FieldType.INT8, can_baudrate_e).setScale(1.0).setBaseOffset(0); + public static final String[] load_override_e = {"None", "MAP", "TPS", "Acc Pedal", "Cyl Filling %"}; + public static final Field AFROVERRIDEMODE = Field.create("AFROVERRIDEMODE", 1623, FieldType.INT8, load_override_e).setScale(1.0).setBaseOffset(0); + public static final Field MC33_HPFP_I_PEAK = Field.create("MC33_HPFP_I_PEAK", 1624, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field MC33_HPFP_I_HOLD = Field.create("MC33_HPFP_I_HOLD", 1625, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field MC33_HPFP_I_HOLD_OFF = Field.create("MC33_HPFP_I_HOLD_OFF", 1626, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MC33_HPFP_MAX_HOLD = Field.create("MC33_HPFP_MAX_HOLD", 1627, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERDCINVERTEDPINS = Field.create("STEPPERDCINVERTEDPINS", 1628, FieldType.BIT, 0).setBaseOffset(0); + public static final Field CANOPENBLT = Field.create("CANOPENBLT", 1628, FieldType.BIT, 1).setBaseOffset(0); + public static final Field CAN2OPENBLT = Field.create("CAN2OPENBLT", 1628, FieldType.BIT, 2).setBaseOffset(0); + public static final Field INJECTORFLOWASMASSFLOW = Field.create("INJECTORFLOWASMASSFLOW", 1628, FieldType.BIT, 3).setBaseOffset(0); + public static final Field BENCHTESTOFFTIME = Field.create("BENCHTESTOFFTIME", 1632, FieldType.INT8).setScale(5.0).setBaseOffset(0); + public static final Field BENCHTESTCOUNT = Field.create("BENCHTESTCOUNT", 1633, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BENCHTESTONTIME = Field.create("BENCHTESTONTIME", 1634, FieldType.INT8).setScale(5.0).setBaseOffset(0); + public static final Field LAUNCHACTIVATEPINMODE = Field.create("LAUNCHACTIVATEPINMODE", 1635, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field CAN2TXPIN = Field.create("CAN2TXPIN", 1636, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field CAN2RXPIN = Field.create("CAN2RXPIN", 1638, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field STARTERCONTROLPINMODE = Field.create("STARTERCONTROLPINMODE", 1640, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field WASTEGATEPOSITIONSENSOR = Field.create("WASTEGATEPOSITIONSENSOR", 1641, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNOVERRIDEMODE = Field.create("IGNOVERRIDEMODE", 1642, FieldType.INT8, load_override_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTORPRESSURETYPE = Field.create("INJECTORPRESSURETYPE", 1643, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HPFPVALVEPIN = Field.create("HPFPVALVEPIN", 1644, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field HPFPVALVEPINMODE = Field.create("HPFPVALVEPINMODE", 1646, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1647 = Field.create("ALIGNMENTFILL_AT_1647", 1647, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field BOOSTCUTPRESSURE = Field.create("BOOSTCUTPRESSURE", 1648, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEBINS = Field.create("TCHARGEBINS", 1652, FieldType.INT8).setScale(5.0).setBaseOffset(0); + public static final Field TCHARGEVALUES = Field.create("TCHARGEVALUES", 1668, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field FIXEDTIMING = Field.create("FIXEDTIMING", 1684, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAPLOWVALUEVOLTAGE = Field.create("MAPLOWVALUEVOLTAGE", 1688, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAPHIGHVALUEVOLTAGE = Field.create("MAPHIGHVALUEVOLTAGE", 1692, FieldType.FLOAT).setBaseOffset(0); + public static final Field EGOVALUESHIFT = Field.create("EGOVALUESHIFT", 1696, FieldType.FLOAT).setBaseOffset(0); + public static final Field VVTPINS1 = Field.create("VVTPINS1", 1700, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field VVTPINS2 = Field.create("VVTPINS2", 1702, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field VVTPINS3 = Field.create("VVTPINS3", 1704, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field VVTPINS4 = Field.create("VVTPINS4", 1706, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field CJ125SPIDEVICE = Field.create("CJ125SPIDEVICE", 1708, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CJ125CSPINMODE = Field.create("CJ125CSPINMODE", 1709, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SDCARDCSPINMODE = Field.create("SDCARDCSPINMODE", 1710, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1711 = Field.create("ALIGNMENTFILL_AT_1711", 1711, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CRANKINGIACPOSITION = Field.create("CRANKINGIACPOSITION", 1712, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field TCHARGEMINRPMMINTPS = Field.create("TCHARGEMINRPMMINTPS", 1716, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEMINRPMMAXTPS = Field.create("TCHARGEMINRPMMAXTPS", 1720, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEMAXRPMMINTPS = Field.create("TCHARGEMAXRPMMINTPS", 1724, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEMAXRPMMAXTPS = Field.create("TCHARGEMAXRPMMAXTPS", 1728, FieldType.FLOAT).setBaseOffset(0); + public static final Field VVTOUTPUTFREQUENCY1 = Field.create("VVTOUTPUTFREQUENCY1", 1732, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VVTOUTPUTFREQUENCY2 = Field.create("VVTOUTPUTFREQUENCY2", 1734, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field FAN1EXTRAIDLE = Field.create("FAN1EXTRAIDLE", 1736, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1737 = Field.create("ALIGNMENTFILL_AT_1737", 1737, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALTERNATORPWMFREQUENCY = Field.create("ALTERNATORPWMFREQUENCY", 1740, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final String[] vvt_mode_e = {"Inactive", "Single Tooth Second Half", "2JZ", "Miata NB2", "Single Tooth First Half", "Bosch Quick Start", "4/1", "ST 170", "Ford Barra 3+1", "Nissan VQ", "Honda K Intake", "Nissan MR18", "Mitsu 3A92", "VTwin by MAP", "Mitsu 6G75", "Mazda Skyactiv", "Honda K Exhaust", "Mitsubishi 4G92/93/94", "Mitsubishi 4G63"}; + public static final Field VVTMODE1 = Field.create("VVTMODE1", 1744, FieldType.INT8, vvt_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field VVTMODE2 = Field.create("VVTMODE2", 1745, FieldType.INT8, vvt_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field FAN2EXTRAIDLE = Field.create("FAN2EXTRAIDLE", 1746, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field PRIMINGDELAY = Field.create("PRIMINGDELAY", 1747, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field AUXANALOGINPUTS1 = Field.create("AUXANALOGINPUTS1", 1748, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXANALOGINPUTS2 = Field.create("AUXANALOGINPUTS2", 1749, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXANALOGINPUTS3 = Field.create("AUXANALOGINPUTS3", 1750, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXANALOGINPUTS4 = Field.create("AUXANALOGINPUTS4", 1751, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXANALOGINPUTS5 = Field.create("AUXANALOGINPUTS5", 1752, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXANALOGINPUTS6 = Field.create("AUXANALOGINPUTS6", 1753, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXANALOGINPUTS7 = Field.create("AUXANALOGINPUTS7", 1754, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXANALOGINPUTS8 = Field.create("AUXANALOGINPUTS8", 1755, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS1 = Field.create("TRAILINGCOILPINS1", 1756, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS2 = Field.create("TRAILINGCOILPINS2", 1758, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS3 = Field.create("TRAILINGCOILPINS3", 1760, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS4 = Field.create("TRAILINGCOILPINS4", 1762, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS5 = Field.create("TRAILINGCOILPINS5", 1764, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS6 = Field.create("TRAILINGCOILPINS6", 1766, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS7 = Field.create("TRAILINGCOILPINS7", 1768, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS8 = Field.create("TRAILINGCOILPINS8", 1770, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS9 = Field.create("TRAILINGCOILPINS9", 1772, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS10 = Field.create("TRAILINGCOILPINS10", 1774, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS11 = Field.create("TRAILINGCOILPINS11", 1776, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TRAILINGCOILPINS12 = Field.create("TRAILINGCOILPINS12", 1778, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TLE8888MODE = Field.create("TLE8888MODE", 1780, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field LIS302DLCSPINMODE = Field.create("LIS302DLCSPINMODE", 1781, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field INJECTORCOMPENSATIONMODE = Field.create("INJECTORCOMPENSATIONMODE", 1782, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field FAN2PINMODE = Field.create("FAN2PINMODE", 1783, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field FUELREFERENCEPRESSURE = Field.create("FUELREFERENCEPRESSURE", 1784, FieldType.FLOAT).setBaseOffset(0); + public static final Field POSTCRANKINGFACTOR = Field.create("POSTCRANKINGFACTOR", 1788, FieldType.FLOAT).setBaseOffset(0); + public static final Field POSTCRANKINGDURATIONSEC = Field.create("POSTCRANKINGDURATIONSEC", 1792, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_TEMPC_1 = Field.create("AUXTEMPSENSOR1_TEMPC_1", 1796, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_TEMPC_2 = Field.create("AUXTEMPSENSOR1_TEMPC_2", 1800, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_TEMPC_3 = Field.create("AUXTEMPSENSOR1_TEMPC_3", 1804, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_RESISTANCE_1 = Field.create("AUXTEMPSENSOR1_RESISTANCE_1", 1808, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_RESISTANCE_2 = Field.create("AUXTEMPSENSOR1_RESISTANCE_2", 1812, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_RESISTANCE_3 = Field.create("AUXTEMPSENSOR1_RESISTANCE_3", 1816, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_BIAS_RESISTOR = Field.create("AUXTEMPSENSOR1_BIAS_RESISTOR", 1820, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_ADCCHANNEL = Field.create("AUXTEMPSENSOR1_ADCCHANNEL", 1824, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXTEMPSENSOR1_ALIGNMENTFILL_AT_29 = Field.create("AUXTEMPSENSOR1_ALIGNMENTFILL_AT_29", 1825, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_TEMPC_1 = Field.create("AUXTEMPSENSOR2_TEMPC_1", 1828, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_TEMPC_2 = Field.create("AUXTEMPSENSOR2_TEMPC_2", 1832, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_TEMPC_3 = Field.create("AUXTEMPSENSOR2_TEMPC_3", 1836, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_RESISTANCE_1 = Field.create("AUXTEMPSENSOR2_RESISTANCE_1", 1840, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_RESISTANCE_2 = Field.create("AUXTEMPSENSOR2_RESISTANCE_2", 1844, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_RESISTANCE_3 = Field.create("AUXTEMPSENSOR2_RESISTANCE_3", 1848, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_BIAS_RESISTOR = Field.create("AUXTEMPSENSOR2_BIAS_RESISTOR", 1852, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_ADCCHANNEL = Field.create("AUXTEMPSENSOR2_ADCCHANNEL", 1856, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXTEMPSENSOR2_ALIGNMENTFILL_AT_29 = Field.create("AUXTEMPSENSOR2_ALIGNMENTFILL_AT_29", 1857, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field KNOCKSAMPLINGDURATION = Field.create("KNOCKSAMPLINGDURATION", 1860, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBFREQ = Field.create("ETBFREQ", 1862, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBWASTEGATEPID_PFACTOR = Field.create("ETBWASTEGATEPID_PFACTOR", 1864, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETBWASTEGATEPID_IFACTOR = Field.create("ETBWASTEGATEPID_IFACTOR", 1868, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETBWASTEGATEPID_DFACTOR = Field.create("ETBWASTEGATEPID_DFACTOR", 1872, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETBWASTEGATEPID_OFFSET = Field.create("ETBWASTEGATEPID_OFFSET", 1876, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBWASTEGATEPID_PERIODMS = Field.create("ETBWASTEGATEPID_PERIODMS", 1878, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBWASTEGATEPID_MINVALUE = Field.create("ETBWASTEGATEPID_MINVALUE", 1880, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBWASTEGATEPID_MAXVALUE = Field.create("ETBWASTEGATEPID_MAXVALUE", 1882, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final String[] stepper_num_micro_steps_e = {"Full-Step (Default)", "INVALID", "Half-Step", "INVALID", "1/4 Micro-Step", "INVALID", "INVALID", "INVALID", "1/8 Micro-Step"}; + public static final Field STEPPERNUMMICROSTEPS = Field.create("STEPPERNUMMICROSTEPS", 1884, FieldType.INT8, stepper_num_micro_steps_e).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERMINDUTYCYCLE = Field.create("STEPPERMINDUTYCYCLE", 1885, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERMAXDUTYCYCLE = Field.create("STEPPERMAXDUTYCYCLE", 1886, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field SDCARDSPIDEVICE = Field.create("SDCARDSPIDEVICE", 1887, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER1 = Field.create("TIMING_OFFSET_CYLINDER1", 1888, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER2 = Field.create("TIMING_OFFSET_CYLINDER2", 1892, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER3 = Field.create("TIMING_OFFSET_CYLINDER3", 1896, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER4 = Field.create("TIMING_OFFSET_CYLINDER4", 1900, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER5 = Field.create("TIMING_OFFSET_CYLINDER5", 1904, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER6 = Field.create("TIMING_OFFSET_CYLINDER6", 1908, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER7 = Field.create("TIMING_OFFSET_CYLINDER7", 1912, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER8 = Field.create("TIMING_OFFSET_CYLINDER8", 1916, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER9 = Field.create("TIMING_OFFSET_CYLINDER9", 1920, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER10 = Field.create("TIMING_OFFSET_CYLINDER10", 1924, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER11 = Field.create("TIMING_OFFSET_CYLINDER11", 1928, FieldType.FLOAT).setBaseOffset(0); + public static final Field TIMING_OFFSET_CYLINDER12 = Field.create("TIMING_OFFSET_CYLINDER12", 1932, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLEPIDACTIVATIONTIME = Field.create("IDLEPIDACTIVATIONTIME", 1936, FieldType.FLOAT).setBaseOffset(0); + public static final String[] pin_mode_e = {"default", "INVALID", "INVALID", "INVALID", "opendrain", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "PULLUP", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "INVALID", "PULLDOWN"}; + public static final Field SPI1SCKMODE = Field.create("SPI1SCKMODE", 1940, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI1MOSIMODE = Field.create("SPI1MOSIMODE", 1941, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI1MISOMODE = Field.create("SPI1MISOMODE", 1942, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI2SCKMODE = Field.create("SPI2SCKMODE", 1943, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI2MOSIMODE = Field.create("SPI2MOSIMODE", 1944, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI2MISOMODE = Field.create("SPI2MISOMODE", 1945, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI3SCKMODE = Field.create("SPI3SCKMODE", 1946, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI3MOSIMODE = Field.create("SPI3MOSIMODE", 1947, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field SPI3MISOMODE = Field.create("SPI3MISOMODE", 1948, FieldType.INT8, pin_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERENABLEPINMODE = Field.create("STEPPERENABLEPINMODE", 1949, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field MC33816_RSTB = Field.create("MC33816_RSTB", 1950, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field MC33816_DRIVEN = Field.create("MC33816_DRIVEN", 1952, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field BRAKEPEDALPIN = Field.create("BRAKEPEDALPIN", 1954, FieldType.INT16, switch_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field CJ125UA = Field.create("CJ125UA", 1956, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field CJ125UR = Field.create("CJ125UR", 1957, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field BRAKEPEDALPINMODE = Field.create("BRAKEPEDALPINMODE", 1958, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_1959 = Field.create("ALIGNMENTFILL_AT_1959", 1959, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID1_PFACTOR = Field.create("AUXPID1_PFACTOR", 1960, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXPID1_IFACTOR = Field.create("AUXPID1_IFACTOR", 1964, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXPID1_DFACTOR = Field.create("AUXPID1_DFACTOR", 1968, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXPID1_OFFSET = Field.create("AUXPID1_OFFSET", 1972, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID1_PERIODMS = Field.create("AUXPID1_PERIODMS", 1974, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID1_MINVALUE = Field.create("AUXPID1_MINVALUE", 1976, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID1_MAXVALUE = Field.create("AUXPID1_MAXVALUE", 1978, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID2_PFACTOR = Field.create("AUXPID2_PFACTOR", 1980, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXPID2_IFACTOR = Field.create("AUXPID2_IFACTOR", 1984, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXPID2_DFACTOR = Field.create("AUXPID2_DFACTOR", 1988, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXPID2_OFFSET = Field.create("AUXPID2_OFFSET", 1992, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID2_PERIODMS = Field.create("AUXPID2_PERIODMS", 1994, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID2_MINVALUE = Field.create("AUXPID2_MINVALUE", 1996, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field AUXPID2_MAXVALUE = Field.create("AUXPID2_MAXVALUE", 1998, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL1 = Field.create("INJECTORCORRECTIONPOLYNOMIAL1", 2000, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL2 = Field.create("INJECTORCORRECTIONPOLYNOMIAL2", 2004, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL3 = Field.create("INJECTORCORRECTIONPOLYNOMIAL3", 2008, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL4 = Field.create("INJECTORCORRECTIONPOLYNOMIAL4", 2012, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL5 = Field.create("INJECTORCORRECTIONPOLYNOMIAL5", 2016, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL6 = Field.create("INJECTORCORRECTIONPOLYNOMIAL6", 2020, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL7 = Field.create("INJECTORCORRECTIONPOLYNOMIAL7", 2024, FieldType.FLOAT).setBaseOffset(0); + public static final Field INJECTORCORRECTIONPOLYNOMIAL8 = Field.create("INJECTORCORRECTIONPOLYNOMIAL8", 2028, FieldType.FLOAT).setBaseOffset(0); + public static final Field PRIMEBINS = Field.create("PRIMEBINS", 2032, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field OILPRESSURE_HWCHANNEL = Field.create("OILPRESSURE_HWCHANNEL", 2040, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field OILPRESSURE_ALIGNMENTFILL_AT_1 = Field.create("OILPRESSURE_ALIGNMENTFILL_AT_1", 2041, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field OILPRESSURE_V1 = Field.create("OILPRESSURE_V1", 2044, FieldType.FLOAT).setBaseOffset(0); + public static final Field OILPRESSURE_VALUE1 = Field.create("OILPRESSURE_VALUE1", 2048, FieldType.FLOAT).setBaseOffset(0); + public static final Field OILPRESSURE_V2 = Field.create("OILPRESSURE_V2", 2052, FieldType.FLOAT).setBaseOffset(0); + public static final Field OILPRESSURE_VALUE2 = Field.create("OILPRESSURE_VALUE2", 2056, FieldType.FLOAT).setBaseOffset(0); + public static final Field ACCELEROMETERSPIDEVICE = Field.create("ACCELEROMETERSPIDEVICE", 2060, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_2061 = Field.create("ALIGNMENTFILL_AT_2061", 2061, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field FAN2PIN = Field.create("FAN2PIN", 2062, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field FAN2ONTEMPERATURE = Field.create("FAN2ONTEMPERATURE", 2064, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field FAN2OFFTEMPERATURE = Field.create("FAN2OFFTEMPERATURE", 2065, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STEPPERENABLEPIN = Field.create("STEPPERENABLEPIN", 2066, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TLE8888_CS = Field.create("TLE8888_CS", 2068, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TLE8888_CSPINMODE = Field.create("TLE8888_CSPINMODE", 2070, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_2071 = Field.create("ALIGNMENTFILL_AT_2071", 2071, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MC33816_CS = Field.create("MC33816_CS", 2072, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_2074 = Field.create("ALIGNMENTFILL_AT_2074", 2074, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AUXFREQUENCYFILTER = Field.create("AUXFREQUENCYFILTER", 2076, FieldType.FLOAT).setBaseOffset(0); + public static final Field VVTCONTROLMINRPM = Field.create("VVTCONTROLMINRPM", 2080, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SENTINPUTPINS1 = Field.create("SENTINPUTPINS1", 2082, FieldType.INT16, brain_input_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field LAUNCHFUELADDERPERCENT = Field.create("LAUNCHFUELADDERPERCENT", 2084, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ETBJAMTIMEOUT = Field.create("ETBJAMTIMEOUT", 2085, FieldType.INT8).setScale(0.02).setBaseOffset(0); + public static final Field ETBEXPAVERAGELENGTH = Field.create("ETBEXPAVERAGELENGTH", 2086, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBDUTYTHRESHOLD = Field.create("ETBDUTYTHRESHOLD", 2088, FieldType.FLOAT).setBaseOffset(0); + public static final Field COASTINGFUELCUTRPMHIGH = Field.create("COASTINGFUELCUTRPMHIGH", 2092, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field COASTINGFUELCUTRPMLOW = Field.create("COASTINGFUELCUTRPMLOW", 2094, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field COASTINGFUELCUTTPS = Field.create("COASTINGFUELCUTTPS", 2096, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field COASTINGFUELCUTCLT = Field.create("COASTINGFUELCUTCLT", 2098, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field PIDEXTRAFORLOWRPM = Field.create("PIDEXTRAFORLOWRPM", 2100, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field COASTINGFUELCUTMAP = Field.create("COASTINGFUELCUTMAP", 2102, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field HIGHPRESSUREFUEL_HWCHANNEL = Field.create("HIGHPRESSUREFUEL_HWCHANNEL", 2104, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field HIGHPRESSUREFUEL_ALIGNMENTFILL_AT_1 = Field.create("HIGHPRESSUREFUEL_ALIGNMENTFILL_AT_1", 2105, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HIGHPRESSUREFUEL_V1 = Field.create("HIGHPRESSUREFUEL_V1", 2108, FieldType.FLOAT).setBaseOffset(0); + public static final Field HIGHPRESSUREFUEL_VALUE1 = Field.create("HIGHPRESSUREFUEL_VALUE1", 2112, FieldType.FLOAT).setBaseOffset(0); + public static final Field HIGHPRESSUREFUEL_V2 = Field.create("HIGHPRESSUREFUEL_V2", 2116, FieldType.FLOAT).setBaseOffset(0); + public static final Field HIGHPRESSUREFUEL_VALUE2 = Field.create("HIGHPRESSUREFUEL_VALUE2", 2120, FieldType.FLOAT).setBaseOffset(0); + public static final Field LOWPRESSUREFUEL_HWCHANNEL = Field.create("LOWPRESSUREFUEL_HWCHANNEL", 2124, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field LOWPRESSUREFUEL_ALIGNMENTFILL_AT_1 = Field.create("LOWPRESSUREFUEL_ALIGNMENTFILL_AT_1", 2125, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field LOWPRESSUREFUEL_V1 = Field.create("LOWPRESSUREFUEL_V1", 2128, FieldType.FLOAT).setBaseOffset(0); + public static final Field LOWPRESSUREFUEL_VALUE1 = Field.create("LOWPRESSUREFUEL_VALUE1", 2132, FieldType.FLOAT).setBaseOffset(0); + public static final Field LOWPRESSUREFUEL_V2 = Field.create("LOWPRESSUREFUEL_V2", 2136, FieldType.FLOAT).setBaseOffset(0); + public static final Field LOWPRESSUREFUEL_VALUE2 = Field.create("LOWPRESSUREFUEL_VALUE2", 2140, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLTREVLIMITRPMBINS = Field.create("CLTREVLIMITRPMBINS", 2144, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CLTREVLIMITRPM = Field.create("CLTREVLIMITRPM", 2148, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTCURVENAME1 = Field.create("SCRIPTCURVENAME1", 2156, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTCURVENAME2 = Field.create("SCRIPTCURVENAME2", 2172, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTCURVENAME3 = Field.create("SCRIPTCURVENAME3", 2188, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTCURVENAME4 = Field.create("SCRIPTCURVENAME4", 2204, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTCURVENAME5 = Field.create("SCRIPTCURVENAME5", 2220, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTCURVENAME6 = Field.create("SCRIPTCURVENAME6", 2236, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLENAME1 = Field.create("SCRIPTTABLENAME1", 2252, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLENAME2 = Field.create("SCRIPTTABLENAME2", 2268, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLENAME3 = Field.create("SCRIPTTABLENAME3", 2284, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLENAME4 = Field.create("SCRIPTTABLENAME4", 2300, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME1 = Field.create("SCRIPTSETTINGNAME1", 2316, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME2 = Field.create("SCRIPTSETTINGNAME2", 2332, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME3 = Field.create("SCRIPTSETTINGNAME3", 2348, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME4 = Field.create("SCRIPTSETTINGNAME4", 2364, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME5 = Field.create("SCRIPTSETTINGNAME5", 2380, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME6 = Field.create("SCRIPTSETTINGNAME6", 2396, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME7 = Field.create("SCRIPTSETTINGNAME7", 2412, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTSETTINGNAME8 = Field.create("SCRIPTSETTINGNAME8", 2428, 16, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field TCHARGEAIRCOEFMIN = Field.create("TCHARGEAIRCOEFMIN", 2444, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEAIRCOEFMAX = Field.create("TCHARGEAIRCOEFMAX", 2448, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEAIRFLOWMAX = Field.create("TCHARGEAIRFLOWMAX", 2452, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEAIRINCRLIMIT = Field.create("TCHARGEAIRINCRLIMIT", 2456, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCHARGEAIRDECRLIMIT = Field.create("TCHARGEAIRDECRLIMIT", 2460, FieldType.FLOAT).setBaseOffset(0); + public static final String[] tChargeMode_e = {"RPM+TPS (Default)", "Air Mass Interpolation", "Table"}; + public static final Field TCHARGEMODE = Field.create("TCHARGEMODE", 2464, FieldType.INT8, tChargeMode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_2465 = Field.create("ALIGNMENTFILL_AT_2465", 2465, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HIP9011GAIN = Field.create("HIP9011GAIN", 2468, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETB_ITERMMIN = Field.create("ETB_ITERMMIN", 2472, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETB_ITERMMAX = Field.create("ETB_ITERMMAX", 2474, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLETIMINGPID_PFACTOR = Field.create("IDLETIMINGPID_PFACTOR", 2476, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLETIMINGPID_IFACTOR = Field.create("IDLETIMINGPID_IFACTOR", 2480, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLETIMINGPID_DFACTOR = Field.create("IDLETIMINGPID_DFACTOR", 2484, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLETIMINGPID_OFFSET = Field.create("IDLETIMINGPID_OFFSET", 2488, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLETIMINGPID_PERIODMS = Field.create("IDLETIMINGPID_PERIODMS", 2490, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLETIMINGPID_MINVALUE = Field.create("IDLETIMINGPID_MINVALUE", 2492, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLETIMINGPID_MAXVALUE = Field.create("IDLETIMINGPID_MAXVALUE", 2494, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBROCEXPAVERAGELENGTH = Field.create("ETBROCEXPAVERAGELENGTH", 2496, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPSACCELFRACTIONPERIOD = Field.create("TPSACCELFRACTIONPERIOD", 2498, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPSACCELFRACTIONDIVISOR = Field.create("TPSACCELFRACTIONDIVISOR", 2500, FieldType.FLOAT).setBaseOffset(0); + public static final Field TLE8888SPIDEVICE = Field.create("TLE8888SPIDEVICE", 2504, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MC33816SPIDEVICE = Field.create("MC33816SPIDEVICE", 2505, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IDLERPMPID_ITERMMIN = Field.create("IDLERPMPID_ITERMMIN", 2506, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TLE6240SPIDEVICE = Field.create("TLE6240SPIDEVICE", 2508, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field STOICHRATIOPRIMARY = Field.create("STOICHRATIOPRIMARY", 2509, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field IDLERPMPID_ITERMMAX = Field.create("IDLERPMPID_ITERMMAX", 2510, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBIDLETHROTTLERANGE = Field.create("ETBIDLETHROTTLERANGE", 2512, FieldType.FLOAT).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT1 = Field.create("CYLINDERBANKSELECT1", 2516, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT2 = Field.create("CYLINDERBANKSELECT2", 2517, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT3 = Field.create("CYLINDERBANKSELECT3", 2518, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT4 = Field.create("CYLINDERBANKSELECT4", 2519, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT5 = Field.create("CYLINDERBANKSELECT5", 2520, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT6 = Field.create("CYLINDERBANKSELECT6", 2521, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT7 = Field.create("CYLINDERBANKSELECT7", 2522, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT8 = Field.create("CYLINDERBANKSELECT8", 2523, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT9 = Field.create("CYLINDERBANKSELECT9", 2524, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT10 = Field.create("CYLINDERBANKSELECT10", 2525, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT11 = Field.create("CYLINDERBANKSELECT11", 2526, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field CYLINDERBANKSELECT12 = Field.create("CYLINDERBANKSELECT12", 2527, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field PRIMEVALUES = Field.create("PRIMEVALUES", 2528, FieldType.INT8).setScale(5.0).setBaseOffset(0); + public static final Field TRIGGERCOMPCENTERVOLT = Field.create("TRIGGERCOMPCENTERVOLT", 2536, FieldType.INT8).setScale(0.02).setBaseOffset(0); + public static final Field TRIGGERCOMPHYSTMIN = Field.create("TRIGGERCOMPHYSTMIN", 2537, FieldType.INT8).setScale(0.02).setBaseOffset(0); + public static final Field TRIGGERCOMPHYSTMAX = Field.create("TRIGGERCOMPHYSTMAX", 2538, FieldType.INT8).setScale(0.02).setBaseOffset(0); + public static final Field TRIGGERCOMPSENSORSATRPM = Field.create("TRIGGERCOMPSENSORSATRPM", 2539, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field IDLERPMPID2_PFACTOR = Field.create("IDLERPMPID2_PFACTOR", 2540, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLERPMPID2_IFACTOR = Field.create("IDLERPMPID2_IFACTOR", 2544, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLERPMPID2_DFACTOR = Field.create("IDLERPMPID2_DFACTOR", 2548, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLERPMPID2_OFFSET = Field.create("IDLERPMPID2_OFFSET", 2552, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLERPMPID2_PERIODMS = Field.create("IDLERPMPID2_PERIODMS", 2554, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLERPMPID2_MINVALUE = Field.create("IDLERPMPID2_MINVALUE", 2556, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IDLERPMPID2_MAXVALUE = Field.create("IDLERPMPID2_MAXVALUE", 2558, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field CANVSSNBCTYPE = Field.create("CANVSSNBCTYPE", 2560, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_2561 = Field.create("ALIGNMENTFILL_AT_2561", 2561, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_PIN = Field.create("GPPWM1_PIN", 2564, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_DUTYIFERROR = Field.create("GPPWM1_DUTYIFERROR", 2566, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_ALIGNMENTFILL_AT_3 = Field.create("GPPWM1_ALIGNMENTFILL_AT_3", 2567, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_PWMFREQUENCY = Field.create("GPPWM1_PWMFREQUENCY", 2568, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_ONABOVEDUTY = Field.create("GPPWM1_ONABOVEDUTY", 2570, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_OFFBELOWDUTY = Field.create("GPPWM1_OFFBELOWDUTY", 2571, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] gppwm_channel_e = {"Zero", "TPS", "MAP", "CLT", "IAT", "Fuel Load", "Ignition Load", "Aux Temp 1", "Aux Temp 2", "Accel Pedal", "Battery Voltage", "VVT 1 I", "VVT 1 E", "VVT 2 I", "VVT 2 E", "Ethanol (Flex) %", "Aux Linear 1", "Aux Linear 2", "GPPWM Output 1", "GPPWM Output 2", "GPPWM Output 3", "GPPWM Output 4", "Lua Gauge 1", "Lua Gauge 2", "RPM"}; + public static final Field GPPWM1_LOADAXIS = Field.create("GPPWM1_LOADAXIS", 2572, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_RPMAXIS = Field.create("GPPWM1_RPMAXIS", 2573, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_LOADBINS = Field.create("GPPWM1_LOADBINS", 2574, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field GPPWM1_RPMBINS = Field.create("GPPWM1_RPMBINS", 2590, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM1_TABLE = Field.create("GPPWM1_TABLE", 2606, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field GPPWM1_ALIGNMENTFILL_AT_106 = Field.create("GPPWM1_ALIGNMENTFILL_AT_106", 2670, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_PIN = Field.create("GPPWM2_PIN", 2672, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_DUTYIFERROR = Field.create("GPPWM2_DUTYIFERROR", 2674, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_ALIGNMENTFILL_AT_3 = Field.create("GPPWM2_ALIGNMENTFILL_AT_3", 2675, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_PWMFREQUENCY = Field.create("GPPWM2_PWMFREQUENCY", 2676, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_ONABOVEDUTY = Field.create("GPPWM2_ONABOVEDUTY", 2678, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_OFFBELOWDUTY = Field.create("GPPWM2_OFFBELOWDUTY", 2679, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_LOADAXIS = Field.create("GPPWM2_LOADAXIS", 2680, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_RPMAXIS = Field.create("GPPWM2_RPMAXIS", 2681, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_LOADBINS = Field.create("GPPWM2_LOADBINS", 2682, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field GPPWM2_RPMBINS = Field.create("GPPWM2_RPMBINS", 2698, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM2_TABLE = Field.create("GPPWM2_TABLE", 2714, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field GPPWM2_ALIGNMENTFILL_AT_106 = Field.create("GPPWM2_ALIGNMENTFILL_AT_106", 2778, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_PIN = Field.create("GPPWM3_PIN", 2780, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_DUTYIFERROR = Field.create("GPPWM3_DUTYIFERROR", 2782, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_ALIGNMENTFILL_AT_3 = Field.create("GPPWM3_ALIGNMENTFILL_AT_3", 2783, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_PWMFREQUENCY = Field.create("GPPWM3_PWMFREQUENCY", 2784, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_ONABOVEDUTY = Field.create("GPPWM3_ONABOVEDUTY", 2786, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_OFFBELOWDUTY = Field.create("GPPWM3_OFFBELOWDUTY", 2787, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_LOADAXIS = Field.create("GPPWM3_LOADAXIS", 2788, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_RPMAXIS = Field.create("GPPWM3_RPMAXIS", 2789, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_LOADBINS = Field.create("GPPWM3_LOADBINS", 2790, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field GPPWM3_RPMBINS = Field.create("GPPWM3_RPMBINS", 2806, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM3_TABLE = Field.create("GPPWM3_TABLE", 2822, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field GPPWM3_ALIGNMENTFILL_AT_106 = Field.create("GPPWM3_ALIGNMENTFILL_AT_106", 2886, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_PIN = Field.create("GPPWM4_PIN", 2888, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_DUTYIFERROR = Field.create("GPPWM4_DUTYIFERROR", 2890, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_ALIGNMENTFILL_AT_3 = Field.create("GPPWM4_ALIGNMENTFILL_AT_3", 2891, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_PWMFREQUENCY = Field.create("GPPWM4_PWMFREQUENCY", 2892, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_ONABOVEDUTY = Field.create("GPPWM4_ONABOVEDUTY", 2894, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_OFFBELOWDUTY = Field.create("GPPWM4_OFFBELOWDUTY", 2895, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_LOADAXIS = Field.create("GPPWM4_LOADAXIS", 2896, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_RPMAXIS = Field.create("GPPWM4_RPMAXIS", 2897, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_LOADBINS = Field.create("GPPWM4_LOADBINS", 2898, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field GPPWM4_RPMBINS = Field.create("GPPWM4_RPMBINS", 2914, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GPPWM4_TABLE = Field.create("GPPWM4_TABLE", 2930, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field GPPWM4_ALIGNMENTFILL_AT_106 = Field.create("GPPWM4_ALIGNMENTFILL_AT_106", 2994, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MC33_I_BOOST = Field.create("MC33_I_BOOST", 2996, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_I_PEAK = Field.create("MC33_I_PEAK", 2998, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_I_HOLD = Field.create("MC33_I_HOLD", 3000, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_T_MAX_BOOST = Field.create("MC33_T_MAX_BOOST", 3002, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_T_PEAK_OFF = Field.create("MC33_T_PEAK_OFF", 3004, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_T_PEAK_TOT = Field.create("MC33_T_PEAK_TOT", 3006, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_T_BYPASS = Field.create("MC33_T_BYPASS", 3008, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_T_HOLD_OFF = Field.create("MC33_T_HOLD_OFF", 3010, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field MC33_T_HOLD_TOT = Field.create("MC33_T_HOLD_TOT", 3012, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TCUUPSHIFTBUTTONPINMODE = Field.create("TCUUPSHIFTBUTTONPINMODE", 3014, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TCUDOWNSHIFTBUTTONPINMODE = Field.create("TCUDOWNSHIFTBUTTONPINMODE", 3015, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ACSWITCHMODE = Field.create("ACSWITCHMODE", 3016, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID_MODE1 = Field.create("TCU_SOLENOID_MODE1", 3017, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID_MODE2 = Field.create("TCU_SOLENOID_MODE2", 3018, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID_MODE3 = Field.create("TCU_SOLENOID_MODE3", 3019, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID_MODE4 = Field.create("TCU_SOLENOID_MODE4", 3020, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID_MODE5 = Field.create("TCU_SOLENOID_MODE5", 3021, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_SOLENOID_MODE6 = Field.create("TCU_SOLENOID_MODE6", 3022, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field KNOCKBASENOISE = Field.create("KNOCKBASENOISE", 3023, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3039 = Field.create("ALIGNMENTFILL_AT_3039", 3039, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM1 = Field.create("TRIGGERGAPOVERRIDEFROM1", 3040, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM2 = Field.create("TRIGGERGAPOVERRIDEFROM2", 3044, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM3 = Field.create("TRIGGERGAPOVERRIDEFROM3", 3048, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM4 = Field.create("TRIGGERGAPOVERRIDEFROM4", 3052, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM5 = Field.create("TRIGGERGAPOVERRIDEFROM5", 3056, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM6 = Field.create("TRIGGERGAPOVERRIDEFROM6", 3060, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM7 = Field.create("TRIGGERGAPOVERRIDEFROM7", 3064, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM8 = Field.create("TRIGGERGAPOVERRIDEFROM8", 3068, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM9 = Field.create("TRIGGERGAPOVERRIDEFROM9", 3072, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM10 = Field.create("TRIGGERGAPOVERRIDEFROM10", 3076, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM11 = Field.create("TRIGGERGAPOVERRIDEFROM11", 3080, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM12 = Field.create("TRIGGERGAPOVERRIDEFROM12", 3084, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM13 = Field.create("TRIGGERGAPOVERRIDEFROM13", 3088, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM14 = Field.create("TRIGGERGAPOVERRIDEFROM14", 3092, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM15 = Field.create("TRIGGERGAPOVERRIDEFROM15", 3096, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM16 = Field.create("TRIGGERGAPOVERRIDEFROM16", 3100, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM17 = Field.create("TRIGGERGAPOVERRIDEFROM17", 3104, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDEFROM18 = Field.create("TRIGGERGAPOVERRIDEFROM18", 3108, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO1 = Field.create("TRIGGERGAPOVERRIDETO1", 3112, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO2 = Field.create("TRIGGERGAPOVERRIDETO2", 3116, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO3 = Field.create("TRIGGERGAPOVERRIDETO3", 3120, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO4 = Field.create("TRIGGERGAPOVERRIDETO4", 3124, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO5 = Field.create("TRIGGERGAPOVERRIDETO5", 3128, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO6 = Field.create("TRIGGERGAPOVERRIDETO6", 3132, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO7 = Field.create("TRIGGERGAPOVERRIDETO7", 3136, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO8 = Field.create("TRIGGERGAPOVERRIDETO8", 3140, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO9 = Field.create("TRIGGERGAPOVERRIDETO9", 3144, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO10 = Field.create("TRIGGERGAPOVERRIDETO10", 3148, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO11 = Field.create("TRIGGERGAPOVERRIDETO11", 3152, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO12 = Field.create("TRIGGERGAPOVERRIDETO12", 3156, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO13 = Field.create("TRIGGERGAPOVERRIDETO13", 3160, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO14 = Field.create("TRIGGERGAPOVERRIDETO14", 3164, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO15 = Field.create("TRIGGERGAPOVERRIDETO15", 3168, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO16 = Field.create("TRIGGERGAPOVERRIDETO16", 3172, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO17 = Field.create("TRIGGERGAPOVERRIDETO17", 3176, FieldType.FLOAT).setBaseOffset(0); + public static final Field TRIGGERGAPOVERRIDETO18 = Field.create("TRIGGERGAPOVERRIDETO18", 3180, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAXCAMPHASERESOLVERPM = Field.create("MAXCAMPHASERESOLVERPM", 3184, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field DFCODELAY = Field.create("DFCODELAY", 3185, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field ACDELAY = Field.create("ACDELAY", 3186, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3187 = Field.create("ALIGNMENTFILL_AT_3187", 3187, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field FORDINJECTORSMALLPULSEBREAKPOINT = Field.create("FORDINJECTORSMALLPULSEBREAKPOINT", 3188, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field TPSTSPCORRVALUES = Field.create("TPSTSPCORRVALUES", 3190, FieldType.INT8).setScale(0.02).setBaseOffset(0); + public static final Field ETBJAMINTEGRATORLIMIT = Field.create("ETBJAMINTEGRATORLIMIT", 3194, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HPFPCAMLOBES = Field.create("HPFPCAMLOBES", 3195, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] hpfp_cam_e = {"NONE", "Intake 1", "Exhaust 1", "Intake 2", "Exhaust 2"}; + public static final Field HPFPCAM = Field.create("HPFPCAM", 3196, FieldType.INT8, hpfp_cam_e).setScale(1.0).setBaseOffset(0); + public static final Field HPFPPEAKPOS = Field.create("HPFPPEAKPOS", 3197, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HPFPMINANGLE = Field.create("HPFPMINANGLE", 3198, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3199 = Field.create("ALIGNMENTFILL_AT_3199", 3199, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HPFPPUMPVOLUME = Field.create("HPFPPUMPVOLUME", 3200, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field HPFPACTIVATIONANGLE = Field.create("HPFPACTIVATIONANGLE", 3202, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ISSFILTERRECIPROCAL = Field.create("ISSFILTERRECIPROCAL", 3203, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HPFPPIDP = Field.create("HPFPPIDP", 3204, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field HPFPPIDI = Field.create("HPFPPIDI", 3206, FieldType.INT16).setScale(1.0E-5).setBaseOffset(0); + public static final Field HPFPTARGETDECAY = Field.create("HPFPTARGETDECAY", 3208, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field HPFPLOBEPROFILEQUANTITYBINS = Field.create("HPFPLOBEPROFILEQUANTITYBINS", 3210, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field HPFPLOBEPROFILEANGLE = Field.create("HPFPLOBEPROFILEANGLE", 3226, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field HPFPDEADTIMEVOLTSBINS = Field.create("HPFPDEADTIMEVOLTSBINS", 3242, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HPFPDEADTIMEMS = Field.create("HPFPDEADTIMEMS", 3250, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field HPFPTARGET = Field.create("HPFPTARGET", 3266, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field HPFPTARGETLOADBINS = Field.create("HPFPTARGETLOADBINS", 3466, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field HPFPTARGETRPMBINS = Field.create("HPFPTARGETRPMBINS", 3486, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field HPFPCOMPENSATION = Field.create("HPFPCOMPENSATION", 3496, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HPFPCOMPENSATIONLOADBINS = Field.create("HPFPCOMPENSATIONLOADBINS", 3596, FieldType.INT16).setScale(0.001).setBaseOffset(0); + public static final Field HPFPCOMPENSATIONRPMBINS = Field.create("HPFPCOMPENSATIONRPMBINS", 3616, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field STEPPER_RAW_OUTPUT1 = Field.create("STEPPER_RAW_OUTPUT1", 3626, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field STEPPER_RAW_OUTPUT2 = Field.create("STEPPER_RAW_OUTPUT2", 3628, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field STEPPER_RAW_OUTPUT3 = Field.create("STEPPER_RAW_OUTPUT3", 3630, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field STEPPER_RAW_OUTPUT4 = Field.create("STEPPER_RAW_OUTPUT4", 3632, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field GEARRATIO1 = Field.create("GEARRATIO1", 3634, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field GEARRATIO2 = Field.create("GEARRATIO2", 3636, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field GEARRATIO3 = Field.create("GEARRATIO3", 3638, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field GEARRATIO4 = Field.create("GEARRATIO4", 3640, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field GEARRATIO5 = Field.create("GEARRATIO5", 3642, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field GEARRATIO6 = Field.create("GEARRATIO6", 3644, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field GEARRATIO7 = Field.create("GEARRATIO7", 3646, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field GEARRATIO8 = Field.create("GEARRATIO8", 3648, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field VVTACTIVATIONDELAYMS = Field.create("VVTACTIVATIONDELAYMS", 3650, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field WWCLTBINS = Field.create("WWCLTBINS", 3652, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field WWTAUCLTVALUES = Field.create("WWTAUCLTVALUES", 3660, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field WWBETACLTVALUES = Field.create("WWBETACLTVALUES", 3668, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field WWMAPBINS = Field.create("WWMAPBINS", 3676, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field WWTAUMAPVALUES = Field.create("WWTAUMAPVALUES", 3684, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field WWBETAMAPVALUES = Field.create("WWBETAMAPVALUES", 3692, FieldType.INT8).setScale(0.01).setBaseOffset(0); + public static final Field TORQUETABLE = Field.create("TORQUETABLE", 3700, FieldType.INT8).setScale(10.0).setBaseOffset(0); + public static final Field TORQUERPMBINS = Field.create("TORQUERPMBINS", 3736, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TORQUELOADBINS = Field.create("TORQUELOADBINS", 3748, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field GEARCONTROLLERMODE = Field.create("GEARCONTROLLERMODE", 3760, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TRANSMISSIONCONTROLLERMODE = Field.create("TRANSMISSIONCONTROLLERMODE", 3761, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3762 = Field.create("ALIGNMENTFILL_AT_3762", 3762, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AUXLINEAR1_HWCHANNEL = Field.create("AUXLINEAR1_HWCHANNEL", 3764, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXLINEAR1_ALIGNMENTFILL_AT_1 = Field.create("AUXLINEAR1_ALIGNMENTFILL_AT_1", 3765, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AUXLINEAR1_V1 = Field.create("AUXLINEAR1_V1", 3768, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXLINEAR1_VALUE1 = Field.create("AUXLINEAR1_VALUE1", 3772, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXLINEAR1_V2 = Field.create("AUXLINEAR1_V2", 3776, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXLINEAR1_VALUE2 = Field.create("AUXLINEAR1_VALUE2", 3780, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXLINEAR2_HWCHANNEL = Field.create("AUXLINEAR2_HWCHANNEL", 3784, FieldType.INT8, adc_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field AUXLINEAR2_ALIGNMENTFILL_AT_1 = Field.create("AUXLINEAR2_ALIGNMENTFILL_AT_1", 3785, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field AUXLINEAR2_V1 = Field.create("AUXLINEAR2_V1", 3788, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXLINEAR2_VALUE1 = Field.create("AUXLINEAR2_VALUE1", 3792, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXLINEAR2_V2 = Field.create("AUXLINEAR2_V2", 3796, FieldType.FLOAT).setBaseOffset(0); + public static final Field AUXLINEAR2_VALUE2 = Field.create("AUXLINEAR2_VALUE2", 3800, FieldType.FLOAT).setBaseOffset(0); + public static final Field TCU_TCC_ONOFF_SOLENOID = Field.create("TCU_TCC_ONOFF_SOLENOID", 3804, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_TCC_ONOFF_SOLENOID_MODE = Field.create("TCU_TCC_ONOFF_SOLENOID_MODE", 3806, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3807 = Field.create("ALIGNMENTFILL_AT_3807", 3807, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_TCC_PWM_SOLENOID = Field.create("TCU_TCC_PWM_SOLENOID", 3808, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_TCC_PWM_SOLENOID_MODE = Field.create("TCU_TCC_PWM_SOLENOID_MODE", 3810, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3811 = Field.create("ALIGNMENTFILL_AT_3811", 3811, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_TCC_PWM_SOLENOID_FREQ = Field.create("TCU_TCC_PWM_SOLENOID_FREQ", 3812, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PC_SOLENOID_PIN = Field.create("TCU_PC_SOLENOID_PIN", 3814, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PC_SOLENOID_PIN_MODE = Field.create("TCU_PC_SOLENOID_PIN_MODE", 3816, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3817 = Field.create("ALIGNMENTFILL_AT_3817", 3817, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PC_SOLENOID_FREQ = Field.create("TCU_PC_SOLENOID_FREQ", 3818, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TCU_32_SOLENOID_PIN = Field.create("TCU_32_SOLENOID_PIN", 3820, FieldType.INT16, output_pin_e).setScale(1.0).setBaseOffset(0); + public static final Field TCU_32_SOLENOID_PIN_MODE = Field.create("TCU_32_SOLENOID_PIN_MODE", 3822, FieldType.INT8, pin_output_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3823 = Field.create("ALIGNMENTFILL_AT_3823", 3823, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_32_SOLENOID_FREQ = Field.create("TCU_32_SOLENOID_FREQ", 3824, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3826 = Field.create("ALIGNMENTFILL_AT_3826", 3826, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ETBMINIMUMPOSITION = Field.create("ETBMINIMUMPOSITION", 3828, FieldType.FLOAT).setBaseOffset(0); + public static final Field TUNEHIDINGKEY = Field.create("TUNEHIDINGKEY", 3832, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VINNUMBER = Field.create("VINNUMBER", 3834, 17, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3851 = Field.create("ALIGNMENTFILL_AT_3851", 3851, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field HIGHSPEEDOFFSETS = Field.create("HIGHSPEEDOFFSETS", 3852, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ETBDUTYSHUTDOWNTHRESHOLD = Field.create("ETBDUTYSHUTDOWNTHRESHOLD", 3916, FieldType.FLOAT).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS1 = Field.create("LUADIGITALINPUTPINS1", 3920, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS2 = Field.create("LUADIGITALINPUTPINS2", 3922, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS3 = Field.create("LUADIGITALINPUTPINS3", 3924, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS4 = Field.create("LUADIGITALINPUTPINS4", 3926, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS5 = Field.create("LUADIGITALINPUTPINS5", 3928, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS6 = Field.create("LUADIGITALINPUTPINS6", 3930, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS7 = Field.create("LUADIGITALINPUTPINS7", 3932, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINS8 = Field.create("LUADIGITALINPUTPINS8", 3934, FieldType.INT16, Gpio).setScale(1.0).setBaseOffset(0); + public static final Field TPSTSPCORRVALUESBINS = Field.create("TPSTSPCORRVALUESBINS", 3936, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field ALSMINRPM = Field.create("ALSMINRPM", 3940, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALSMAXRPM = Field.create("ALSMAXRPM", 3942, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALSMAXDURATION = Field.create("ALSMAXDURATION", 3944, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALSMINCLT = Field.create("ALSMINCLT", 3946, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALSMAXCLT = Field.create("ALSMAXCLT", 3947, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALSMINTIMEBETWEEN = Field.create("ALSMINTIMEBETWEEN", 3948, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALSETBPOSITION = Field.create("ALSETBPOSITION", 3949, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ACRELAYALTERNATORDUTYADDER = Field.create("ACRELAYALTERNATORDUTYADDER", 3950, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field INSTANTRPMRANGE = Field.create("INSTANTRPMRANGE", 3951, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field UNUSEDA11LIGNMENTFILL_AT_33 = Field.create("UNUSEDA11LIGNMENTFILL_AT_33", 3952, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final String[] SentEtbType = {"None", "GM type 1", "Ford type 1"}; + public static final Field SENTETBTYPE = Field.create("SENTETBTYPE", 3953, FieldType.INT8, SentEtbType).setScale(1.0).setBaseOffset(0); + public static final Field ALIGNMENTFILL_AT_3954 = Field.create("ALIGNMENTFILL_AT_3954", 3954, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALSIDLEADD = Field.create("ALSIDLEADD", 3956, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field ALSETBADD = Field.create("ALSETBADD", 3960, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field ALSSKIPRATIO = Field.create("ALSSKIPRATIO", 3964, FieldType.INT).setScale(1.0).setBaseOffset(0); + public static final Field ALSMAXDRIVERTHROTTLEINTENT = Field.create("ALSMAXDRIVERTHROTTLEINTENT", 3968, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ALSACTIVATEPINMODE = Field.create("ALSACTIVATEPINMODE", 3969, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field TPSSECONDARYMAXIMUM = Field.create("TPSSECONDARYMAXIMUM", 3970, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field PPSSECONDARYMAXIMUM = Field.create("PPSSECONDARYMAXIMUM", 3971, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES1 = Field.create("LUADIGITALINPUTPINMODES1", 3972, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES2 = Field.create("LUADIGITALINPUTPINMODES2", 3973, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES3 = Field.create("LUADIGITALINPUTPINMODES3", 3974, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES4 = Field.create("LUADIGITALINPUTPINMODES4", 3975, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES5 = Field.create("LUADIGITALINPUTPINMODES5", 3976, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES6 = Field.create("LUADIGITALINPUTPINMODES6", 3977, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES7 = Field.create("LUADIGITALINPUTPINMODES7", 3978, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field LUADIGITALINPUTPINMODES8 = Field.create("LUADIGITALINPUTPINMODES8", 3979, FieldType.INT8, pin_input_mode_e).setScale(1.0).setBaseOffset(0); + public static final Field MAINUNUSEDEND = Field.create("MAINUNUSEDEND", 3980, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field ETBBIASBINS = Field.create("ETBBIASBINS", 4076, FieldType.FLOAT).setBaseOffset(0); + public static final Field ETBBIASVALUES = Field.create("ETBBIASVALUES", 4108, FieldType.FLOAT).setBaseOffset(0); + public static final Field IACPIDMULTTABLE = Field.create("IACPIDMULTTABLE", 4140, FieldType.INT8).setScale(0.05).setBaseOffset(0); + public static final Field IACPIDMULTLOADBINS = Field.create("IACPIDMULTLOADBINS", 4204, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IACPIDMULTRPMBINS = Field.create("IACPIDMULTRPMBINS", 4212, FieldType.INT8).setScale(10.0).setBaseOffset(0); + public static final Field SPARKDWELLRPMBINS = Field.create("SPARKDWELLRPMBINS", 4220, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SPARKDWELLVALUES = Field.create("SPARKDWELLVALUES", 4236, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field CLTIDLERPMBINS = Field.create("CLTIDLERPMBINS", 4252, FieldType.INT8).setScale(2.0).setBaseOffset(0); + public static final Field CLTIDLERPM = Field.create("CLTIDLERPM", 4268, FieldType.INT8).setScale(20.0).setBaseOffset(0); + public static final Field CLTTIMINGBINS = Field.create("CLTTIMINGBINS", 4284, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLTTIMINGEXTRA = Field.create("CLTTIMINGEXTRA", 4316, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE1BINS = Field.create("SCRIPTCURVE1BINS", 4348, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE1 = Field.create("SCRIPTCURVE1", 4412, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE2BINS = Field.create("SCRIPTCURVE2BINS", 4476, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE2 = Field.create("SCRIPTCURVE2", 4540, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE3BINS = Field.create("SCRIPTCURVE3BINS", 4604, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE3 = Field.create("SCRIPTCURVE3", 4636, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE4BINS = Field.create("SCRIPTCURVE4BINS", 4668, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE4 = Field.create("SCRIPTCURVE4", 4700, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE5BINS = Field.create("SCRIPTCURVE5BINS", 4732, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE5 = Field.create("SCRIPTCURVE5", 4764, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE6BINS = Field.create("SCRIPTCURVE6BINS", 4796, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTCURVE6 = Field.create("SCRIPTCURVE6", 4828, FieldType.FLOAT).setBaseOffset(0); + public static final Field BAROCORRPRESSUREBINS = Field.create("BAROCORRPRESSUREBINS", 4860, FieldType.FLOAT).setBaseOffset(0); + public static final Field BAROCORRRPMBINS = Field.create("BAROCORRRPMBINS", 4876, FieldType.FLOAT).setBaseOffset(0); + public static final Field BAROCORRTABLE = Field.create("BAROCORRTABLE", 4892, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKINGTPSCOEF = Field.create("CRANKINGTPSCOEF", 4956, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKINGTPSBINS = Field.create("CRANKINGTPSBINS", 4988, FieldType.FLOAT).setBaseOffset(0); + public static final Field NARROWTOWIDEOXYGENBINS = Field.create("NARROWTOWIDEOXYGENBINS", 5020, FieldType.FLOAT).setBaseOffset(0); + public static final Field NARROWTOWIDEOXYGEN = Field.create("NARROWTOWIDEOXYGEN", 5052, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKINGADVANCEBINS = Field.create("CRANKINGADVANCEBINS", 5084, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field CRANKINGADVANCE = Field.create("CRANKINGADVANCE", 5092, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field IACCOASTINGRPMBINS = Field.create("IACCOASTINGRPMBINS", 5100, FieldType.INT8).setScale(100.0).setBaseOffset(0); + public static final Field IACCOASTING = Field.create("IACCOASTING", 5116, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field WARNING_MESSAGE = Field.create("WARNING_MESSAGE", 5132, 120, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field AFTERSTARTCOOLANTBINS = Field.create("AFTERSTARTCOOLANTBINS", 5252, FieldType.FLOAT).setBaseOffset(0); + public static final Field AFTERSTARTHOLDTIME = Field.create("AFTERSTARTHOLDTIME", 5284, FieldType.FLOAT).setBaseOffset(0); + public static final Field AFTERSTARTENRICH = Field.create("AFTERSTARTENRICH", 5316, FieldType.FLOAT).setBaseOffset(0); + public static final Field AFTERSTARTDECAYTIME = Field.create("AFTERSTARTDECAYTIME", 5348, FieldType.FLOAT).setBaseOffset(0); + public static final Field BOOSTTABLEOPENLOOP = Field.create("BOOSTTABLEOPENLOOP", 5380, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field BOOSTRPMBINS = Field.create("BOOSTRPMBINS", 5444, FieldType.INT8).setScale(100.0).setBaseOffset(0); + public static final Field BOOSTTABLECLOSEDLOOP = Field.create("BOOSTTABLECLOSEDLOOP", 5452, FieldType.INT8).setScale(2.0).setBaseOffset(0); + public static final Field BOOSTTPSBINS = Field.create("BOOSTTPSBINS", 5516, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field PEDALTOTPSTABLE = Field.create("PEDALTOTPSTABLE", 5524, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field PEDALTOTPSPEDALBINS = Field.create("PEDALTOTPSPEDALBINS", 5588, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field PEDALTOTPSRPMBINS = Field.create("PEDALTOTPSRPMBINS", 5596, FieldType.INT8).setScale(100.0).setBaseOffset(0); + public static final Field CLTCRANKINGCORRBINS = Field.create("CLTCRANKINGCORRBINS", 5604, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLTCRANKINGCORR = Field.create("CLTCRANKINGCORR", 5636, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLEADVANCEBINS = Field.create("IDLEADVANCEBINS", 5668, FieldType.INT8).setScale(50.0).setBaseOffset(0); + public static final Field IDLEADVANCE = Field.create("IDLEADVANCE", 5676, FieldType.FLOAT).setBaseOffset(0); + public static final Field IDLEVERPMBINS = Field.create("IDLEVERPMBINS", 5708, FieldType.INT8).setScale(10.0).setBaseOffset(0); + public static final Field IDLEVELOADBINS = Field.create("IDLEVELOADBINS", 5712, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IDLEVETABLE = Field.create("IDLEVETABLE", 5716, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field LUASCRIPT = Field.create("LUASCRIPT", 5748, 8000, FieldType.STRING).setScale(1.0).setBaseOffset(0); + public static final Field CLTFUELCORRBINS = Field.create("CLTFUELCORRBINS", 13748, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLTFUELCORR = Field.create("CLTFUELCORR", 13812, FieldType.FLOAT).setBaseOffset(0); + public static final Field IATFUELCORRBINS = Field.create("IATFUELCORRBINS", 13876, FieldType.FLOAT).setBaseOffset(0); + public static final Field IATFUELCORR = Field.create("IATFUELCORR", 13940, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKINGFUELCOEF = Field.create("CRANKINGFUELCOEF", 14004, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKINGFUELBINS = Field.create("CRANKINGFUELBINS", 14036, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKINGCYCLECOEF = Field.create("CRANKINGCYCLECOEF", 14068, FieldType.FLOAT).setBaseOffset(0); + public static final Field CRANKINGCYCLEBINS = Field.create("CRANKINGCYCLEBINS", 14100, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLTIDLECORRBINS = Field.create("CLTIDLECORRBINS", 14132, FieldType.FLOAT).setBaseOffset(0); + public static final Field CLTIDLECORR = Field.create("CLTIDLECORR", 14196, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAFDECODING = Field.create("MAFDECODING", 14260, FieldType.FLOAT).setBaseOffset(0); + public static final Field MAFDECODINGBINS = Field.create("MAFDECODINGBINS", 15284, FieldType.FLOAT).setBaseOffset(0); + public static final Field IGNITIONIATCORRTABLE = Field.create("IGNITIONIATCORRTABLE", 16308, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field IGNITIONIATCORRTEMPBINS = Field.create("IGNITIONIATCORRTEMPBINS", 16372, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONIATCORRLOADBINS = Field.create("IGNITIONIATCORRLOADBINS", 16380, FieldType.INT8).setScale(5.0).setBaseOffset(0); + public static final Field INJECTIONPHASE = Field.create("INJECTIONPHASE", 16388, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field INJPHASELOADBINS = Field.create("INJPHASELOADBINS", 16900, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field INJPHASERPMBINS = Field.create("INJPHASERPMBINS", 16932, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TCUSOLENOIDTABLE = Field.create("TCUSOLENOIDTABLE", 16964, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAPESTIMATETABLE = Field.create("MAPESTIMATETABLE", 17024, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field MAPESTIMATETPSBINS = Field.create("MAPESTIMATETPSBINS", 17536, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field MAPESTIMATERPMBINS = Field.create("MAPESTIMATERPMBINS", 17568, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VVTTABLE1 = Field.create("VVTTABLE1", 17600, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VVTTABLE1LOADBINS = Field.create("VVTTABLE1LOADBINS", 17664, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VVTTABLE1RPMBINS = Field.create("VVTTABLE1RPMBINS", 17680, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VVTTABLE2 = Field.create("VVTTABLE2", 17696, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VVTTABLE2LOADBINS = Field.create("VVTTABLE2LOADBINS", 17760, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VVTTABLE2RPMBINS = Field.create("VVTTABLE2RPMBINS", 17776, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONTABLE = Field.create("IGNITIONTABLE", 17792, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNITIONLOADBINS = Field.create("IGNITIONLOADBINS", 18304, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNITIONRPMBINS = Field.create("IGNITIONRPMBINS", 18336, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VETABLE = Field.create("VETABLE", 18368, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VELOADBINS = Field.create("VELOADBINS", 18880, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VERPMBINS = Field.create("VERPMBINS", 18912, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field LAMBDATABLE = Field.create("LAMBDATABLE", 18944, FieldType.INT8).setScale(0.006802721088435374).setBaseOffset(0); + public static final Field LAMBDALOADBINS = Field.create("LAMBDALOADBINS", 19200, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field LAMBDARPMBINS = Field.create("LAMBDARPMBINS", 19232, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field TPSTPSACCELTABLE = Field.create("TPSTPSACCELTABLE", 19264, FieldType.FLOAT).setBaseOffset(0); + public static final Field TPSTPSACCELFROMRPMBINS = Field.create("TPSTPSACCELFROMRPMBINS", 19520, FieldType.FLOAT).setBaseOffset(0); + public static final Field TPSTPSACCELTORPMBINS = Field.create("TPSTPSACCELTORPMBINS", 19552, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTTABLE1 = Field.create("SCRIPTTABLE1", 19584, FieldType.FLOAT).setBaseOffset(0); + public static final Field SCRIPTTABLE1LOADBINS = Field.create("SCRIPTTABLE1LOADBINS", 19840, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE1RPMBINS = Field.create("SCRIPTTABLE1RPMBINS", 19856, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE2 = Field.create("SCRIPTTABLE2", 19872, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE2LOADBINS = Field.create("SCRIPTTABLE2LOADBINS", 19936, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE2RPMBINS = Field.create("SCRIPTTABLE2RPMBINS", 19952, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE3 = Field.create("SCRIPTTABLE3", 19968, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE3LOADBINS = Field.create("SCRIPTTABLE3LOADBINS", 20032, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE3RPMBINS = Field.create("SCRIPTTABLE3RPMBINS", 20048, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE4 = Field.create("SCRIPTTABLE4", 20064, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE4LOADBINS = Field.create("SCRIPTTABLE4LOADBINS", 20128, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field SCRIPTTABLE4RPMBINS = Field.create("SCRIPTTABLE4RPMBINS", 20144, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNTRIMLOADBINS = Field.create("IGNTRIMLOADBINS", 20160, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNTRIMRPMBINS = Field.create("IGNTRIMRPMBINS", 20168, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNTRIMS1_TABLE = Field.create("IGNTRIMS1_TABLE", 20176, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS2_TABLE = Field.create("IGNTRIMS2_TABLE", 20192, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS3_TABLE = Field.create("IGNTRIMS3_TABLE", 20208, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS4_TABLE = Field.create("IGNTRIMS4_TABLE", 20224, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS5_TABLE = Field.create("IGNTRIMS5_TABLE", 20240, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS6_TABLE = Field.create("IGNTRIMS6_TABLE", 20256, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS7_TABLE = Field.create("IGNTRIMS7_TABLE", 20272, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS8_TABLE = Field.create("IGNTRIMS8_TABLE", 20288, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS9_TABLE = Field.create("IGNTRIMS9_TABLE", 20304, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS10_TABLE = Field.create("IGNTRIMS10_TABLE", 20320, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS11_TABLE = Field.create("IGNTRIMS11_TABLE", 20336, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field IGNTRIMS12_TABLE = Field.create("IGNTRIMS12_TABLE", 20352, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMLOADBINS = Field.create("FUELTRIMLOADBINS", 20368, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field FUELTRIMRPMBINS = Field.create("FUELTRIMRPMBINS", 20376, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field FUELTRIMS1_TABLE = Field.create("FUELTRIMS1_TABLE", 20384, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS2_TABLE = Field.create("FUELTRIMS2_TABLE", 20400, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS3_TABLE = Field.create("FUELTRIMS3_TABLE", 20416, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS4_TABLE = Field.create("FUELTRIMS4_TABLE", 20432, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS5_TABLE = Field.create("FUELTRIMS5_TABLE", 20448, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS6_TABLE = Field.create("FUELTRIMS6_TABLE", 20464, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS7_TABLE = Field.create("FUELTRIMS7_TABLE", 20480, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS8_TABLE = Field.create("FUELTRIMS8_TABLE", 20496, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS9_TABLE = Field.create("FUELTRIMS9_TABLE", 20512, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS10_TABLE = Field.create("FUELTRIMS10_TABLE", 20528, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS11_TABLE = Field.create("FUELTRIMS11_TABLE", 20544, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field FUELTRIMS12_TABLE = Field.create("FUELTRIMS12_TABLE", 20560, FieldType.INT8).setScale(0.2).setBaseOffset(0); + public static final Field CRANKINGFUELCOEFE100 = Field.create("CRANKINGFUELCOEFE100", 20576, FieldType.INT16).setScale(0.01).setBaseOffset(0); + public static final Field TCU_PCAIRMASSBINS = Field.create("TCU_PCAIRMASSBINS", 20592, FieldType.INT8).setScale(0.02).setBaseOffset(0); + public static final Field TCU_PCVALSR = Field.create("TCU_PCVALSR", 20600, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALSN = Field.create("TCU_PCVALSN", 20608, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS1 = Field.create("TCU_PCVALS1", 20616, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS2 = Field.create("TCU_PCVALS2", 20624, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS3 = Field.create("TCU_PCVALS3", 20632, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS4 = Field.create("TCU_PCVALS4", 20640, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS12 = Field.create("TCU_PCVALS12", 20648, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS23 = Field.create("TCU_PCVALS23", 20656, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS34 = Field.create("TCU_PCVALS34", 20664, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS21 = Field.create("TCU_PCVALS21", 20672, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS32 = Field.create("TCU_PCVALS32", 20680, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_PCVALS43 = Field.create("TCU_PCVALS43", 20688, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_TCCTPSBINS = Field.create("TCU_TCCTPSBINS", 20696, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_TCCLOCKSPEED = Field.create("TCU_TCCLOCKSPEED", 20704, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_TCCUNLOCKSPEED = Field.create("TCU_TCCUNLOCKSPEED", 20712, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_32SPEEDBINS = Field.create("TCU_32SPEEDBINS", 20720, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field TCU_32VALS = Field.create("TCU_32VALS", 20728, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field THROTTLE2TRIMTABLE = Field.create("THROTTLE2TRIMTABLE", 20736, FieldType.INT8).setScale(0.1).setBaseOffset(0); + public static final Field THROTTLE2TRIMTPSBINS = Field.create("THROTTLE2TRIMTPSBINS", 20772, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field THROTTLE2TRIMRPMBINS = Field.create("THROTTLE2TRIMRPMBINS", 20778, FieldType.INT8).setScale(100.0).setBaseOffset(0); + public static final Field MAXKNOCKRETARDTABLE = Field.create("MAXKNOCKRETARDTABLE", 20784, FieldType.INT8).setScale(0.25).setBaseOffset(0); + public static final Field MAXKNOCKRETARDLOADBINS = Field.create("MAXKNOCKRETARDLOADBINS", 20820, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field MAXKNOCKRETARDRPMBINS = Field.create("MAXKNOCKRETARDRPMBINS", 20826, FieldType.INT8).setScale(100.0).setBaseOffset(0); + public static final Field ALSTIMINGRETARDTABLE = Field.create("ALSTIMINGRETARDTABLE", 20832, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field ALSIGNRETARDLOADBINS = Field.create("ALSIGNRETARDLOADBINS", 20864, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALSIGNRETARDRPMBINS = Field.create("ALSIGNRETARDRPMBINS", 20872, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALSFUELADJUSTMENT = Field.create("ALSFUELADJUSTMENT", 20880, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field ALSFUELADJUSTMENTLOADBINS = Field.create("ALSFUELADJUSTMENTLOADBINS", 20912, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field ALSFUELADJUSTMENTRPMBINS = Field.create("ALSFUELADJUSTMENTRPMBINS", 20920, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS1_TABLE = Field.create("IGNBLENDS1_TABLE", 20928, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS1_LOADBINS = Field.create("IGNBLENDS1_LOADBINS", 21056, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS1_RPMBINS = Field.create("IGNBLENDS1_RPMBINS", 21072, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS1_BLENDPARAMETER = Field.create("IGNBLENDS1_BLENDPARAMETER", 21088, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS1_ALIGNMENTFILL_AT_161 = Field.create("IGNBLENDS1_ALIGNMENTFILL_AT_161", 21089, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS1_BLENDBINS = Field.create("IGNBLENDS1_BLENDBINS", 21090, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS1_BLENDVALUES = Field.create("IGNBLENDS1_BLENDVALUES", 21106, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field IGNBLENDS1_ALIGNMENTFILL_AT_186 = Field.create("IGNBLENDS1_ALIGNMENTFILL_AT_186", 21114, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS2_TABLE = Field.create("IGNBLENDS2_TABLE", 21116, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS2_LOADBINS = Field.create("IGNBLENDS2_LOADBINS", 21244, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS2_RPMBINS = Field.create("IGNBLENDS2_RPMBINS", 21260, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS2_BLENDPARAMETER = Field.create("IGNBLENDS2_BLENDPARAMETER", 21276, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS2_ALIGNMENTFILL_AT_161 = Field.create("IGNBLENDS2_ALIGNMENTFILL_AT_161", 21277, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS2_BLENDBINS = Field.create("IGNBLENDS2_BLENDBINS", 21278, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS2_BLENDVALUES = Field.create("IGNBLENDS2_BLENDVALUES", 21294, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field IGNBLENDS2_ALIGNMENTFILL_AT_186 = Field.create("IGNBLENDS2_ALIGNMENTFILL_AT_186", 21302, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS3_TABLE = Field.create("IGNBLENDS3_TABLE", 21304, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS3_LOADBINS = Field.create("IGNBLENDS3_LOADBINS", 21432, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS3_RPMBINS = Field.create("IGNBLENDS3_RPMBINS", 21448, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS3_BLENDPARAMETER = Field.create("IGNBLENDS3_BLENDPARAMETER", 21464, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS3_ALIGNMENTFILL_AT_161 = Field.create("IGNBLENDS3_ALIGNMENTFILL_AT_161", 21465, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS3_BLENDBINS = Field.create("IGNBLENDS3_BLENDBINS", 21466, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS3_BLENDVALUES = Field.create("IGNBLENDS3_BLENDVALUES", 21482, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field IGNBLENDS3_ALIGNMENTFILL_AT_186 = Field.create("IGNBLENDS3_ALIGNMENTFILL_AT_186", 21490, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS4_TABLE = Field.create("IGNBLENDS4_TABLE", 21492, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS4_LOADBINS = Field.create("IGNBLENDS4_LOADBINS", 21620, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS4_RPMBINS = Field.create("IGNBLENDS4_RPMBINS", 21636, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS4_BLENDPARAMETER = Field.create("IGNBLENDS4_BLENDPARAMETER", 21652, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS4_ALIGNMENTFILL_AT_161 = Field.create("IGNBLENDS4_ALIGNMENTFILL_AT_161", 21653, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field IGNBLENDS4_BLENDBINS = Field.create("IGNBLENDS4_BLENDBINS", 21654, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field IGNBLENDS4_BLENDVALUES = Field.create("IGNBLENDS4_BLENDVALUES", 21670, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field IGNBLENDS4_ALIGNMENTFILL_AT_186 = Field.create("IGNBLENDS4_ALIGNMENTFILL_AT_186", 21678, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS1_TABLE = Field.create("VEBLENDS1_TABLE", 21680, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS1_LOADBINS = Field.create("VEBLENDS1_LOADBINS", 21808, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS1_RPMBINS = Field.create("VEBLENDS1_RPMBINS", 21824, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS1_BLENDPARAMETER = Field.create("VEBLENDS1_BLENDPARAMETER", 21840, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS1_ALIGNMENTFILL_AT_161 = Field.create("VEBLENDS1_ALIGNMENTFILL_AT_161", 21841, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS1_BLENDBINS = Field.create("VEBLENDS1_BLENDBINS", 21842, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS1_BLENDVALUES = Field.create("VEBLENDS1_BLENDVALUES", 21858, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field VEBLENDS1_ALIGNMENTFILL_AT_186 = Field.create("VEBLENDS1_ALIGNMENTFILL_AT_186", 21866, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS2_TABLE = Field.create("VEBLENDS2_TABLE", 21868, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS2_LOADBINS = Field.create("VEBLENDS2_LOADBINS", 21996, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS2_RPMBINS = Field.create("VEBLENDS2_RPMBINS", 22012, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS2_BLENDPARAMETER = Field.create("VEBLENDS2_BLENDPARAMETER", 22028, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS2_ALIGNMENTFILL_AT_161 = Field.create("VEBLENDS2_ALIGNMENTFILL_AT_161", 22029, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS2_BLENDBINS = Field.create("VEBLENDS2_BLENDBINS", 22030, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS2_BLENDVALUES = Field.create("VEBLENDS2_BLENDVALUES", 22046, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field VEBLENDS2_ALIGNMENTFILL_AT_186 = Field.create("VEBLENDS2_ALIGNMENTFILL_AT_186", 22054, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS3_TABLE = Field.create("VEBLENDS3_TABLE", 22056, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS3_LOADBINS = Field.create("VEBLENDS3_LOADBINS", 22184, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS3_RPMBINS = Field.create("VEBLENDS3_RPMBINS", 22200, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS3_BLENDPARAMETER = Field.create("VEBLENDS3_BLENDPARAMETER", 22216, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS3_ALIGNMENTFILL_AT_161 = Field.create("VEBLENDS3_ALIGNMENTFILL_AT_161", 22217, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS3_BLENDBINS = Field.create("VEBLENDS3_BLENDBINS", 22218, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS3_BLENDVALUES = Field.create("VEBLENDS3_BLENDVALUES", 22234, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field VEBLENDS3_ALIGNMENTFILL_AT_186 = Field.create("VEBLENDS3_ALIGNMENTFILL_AT_186", 22242, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS4_TABLE = Field.create("VEBLENDS4_TABLE", 22244, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS4_LOADBINS = Field.create("VEBLENDS4_LOADBINS", 22372, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS4_RPMBINS = Field.create("VEBLENDS4_RPMBINS", 22388, FieldType.INT16).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS4_BLENDPARAMETER = Field.create("VEBLENDS4_BLENDPARAMETER", 22404, FieldType.INT8, gppwm_channel_e).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS4_ALIGNMENTFILL_AT_161 = Field.create("VEBLENDS4_ALIGNMENTFILL_AT_161", 22405, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field VEBLENDS4_BLENDBINS = Field.create("VEBLENDS4_BLENDBINS", 22406, FieldType.INT16).setScale(0.1).setBaseOffset(0); + public static final Field VEBLENDS4_BLENDVALUES = Field.create("VEBLENDS4_BLENDVALUES", 22422, FieldType.INT8).setScale(0.5).setBaseOffset(0); + public static final Field VEBLENDS4_ALIGNMENTFILL_AT_186 = Field.create("VEBLENDS4_ALIGNMENTFILL_AT_186", 22430, FieldType.INT8).setScale(1.0).setBaseOffset(0); + public static final Field[] VALUES = { + ENGINETYPE, + SENSORSNIFFERRPMTHRESHOLD, + LAUNCHRPM, + RPMHARDLIMIT, + ENGINESNIFFERRPMTHRESHOLD, + MULTISPARKMAXRPM, + MAXACRPM, + MAXACTPS, + MAXACCLT, + KNOCKNOISERPMBINS, + MULTISPARKMAXSPARKINGANGLE, + MULTISPARKMAXEXTRASPARKCOUNT, + ALIGNMENTFILL_AT_50, + INJECTOR_FLOW, + INJECTOR_BATTLAGCORRBINS, + INJECTOR_BATTLAGCORR, + ISFORCEDINDUCTION, + USEFORDREDUNDANTTPS, + ISVERBOSEAUXPID1, + OVERRIDETRIGGERGAPS, + ENABLEFAN1WITHAC, + ENABLEFAN2WITHAC, + DISABLEFAN1WHENSTOPPED, + DISABLEFAN2WHENSTOPPED, + ENABLETRAILINGSPARKS, + ISCJ125VERBOSE, + CJ125ISUADIVIDED, + CJ125ISLSU49, + ETB_USE_TWO_WIRES, + ISDOUBLESOLENOIDIDLE, + USEEEPROM, + CJ125ISURDIVIDED, + USECICPIDFORIDLE, + USETLE8888_CRANKING_HACK, + KICKSTARTCRANKING, + USESEPARATEIDLETABLESFORCRANKINGTAPER, + LAUNCHCONTROLENABLED, + DONOTFILTERTRIGGEREDGENOISE, + ANTILAGENABLED, + USERUNNINGMATHFORCRANKING, + DISPLAYLOGICLEVELSINENGINESNIFFER, + USETLE8888_STEPPER, + ENABLEMAPESTIMATIONTABLEFALLBACK, + USESCRIPTTABLEFORCANSNIFFINGFILTERING, + VERBOSECAN, + ARTIFICIALTESTMISFIRE, + USEFORDREDUNDANTPPS, + TPSMIN, + TPSMAX, + TPSERRORDETECTIONTOOLOW, + TPSERRORDETECTIONTOOHIGH, + CRANKING_BASEFUEL, + CRANKING_RPM, + CRANKING_ALIGNMENTFILL_AT_6, + IGNITIONDWELLFORCRANKINGMS, + ETBREVLIMITSTART, + ETBREVLIMITRANGE, + MAP_SAMPLINGANGLEBINS, + MAP_SAMPLINGANGLE, + MAP_SAMPLINGWINDOWBINS, + MAP_SAMPLINGWINDOW, + MAP_SENSOR_LOWVALUE, + MAP_SENSOR_HIGHVALUE, + MAP_SENSOR_TYPE, + MAP_SENSOR_HWCHANNEL, + MAP_SENSOR_ALIGNMENTFILL_AT_10, + CLT_TEMPC_1, + CLT_TEMPC_2, + CLT_TEMPC_3, + CLT_RESISTANCE_1, + CLT_RESISTANCE_2, + CLT_RESISTANCE_3, + CLT_BIAS_RESISTOR, + CLT_ADCCHANNEL, + CLT_ALIGNMENTFILL_AT_29, + IAT_TEMPC_1, + IAT_TEMPC_2, + IAT_TEMPC_3, + IAT_RESISTANCE_1, + IAT_RESISTANCE_2, + IAT_RESISTANCE_3, + IAT_BIAS_RESISTOR, + IAT_ADCCHANNEL, + IAT_ALIGNMENTFILL_AT_29, + LAUNCHTIMINGRETARD, + HIP9011PRESCALERANDSDO, + KNOCKBANDCUSTOM, + DISPLACEMENT, + CYLINDERSCOUNT, + FIRINGORDER, + ALIGNMENTFILL_AT_9, + CYLINDERBORE, + FUELALGORITHM, + ALSMAXTPS, + CRITICALLEDPIN, + CRANKINGINJECTIONMODE, + INJECTIONMODE, + BOOSTCONTROLMINRPM, + BOOSTCONTROLMINTPS, + BOOSTCONTROLMINMAP, + ALIGNMENTFILL_AT_390, + CRANKINGTIMINGANGLE, + IGNITIONMODE, + GAPTRACKINGLENGTHOVERRIDE, + MAXIDLEVSS, + ALIGNMENTFILL_AT_399, + MINOILPRESSUREAFTERSTART, + TIMINGMODE, + ALIGNMENTFILL_AT_403, + FIXEDMODETIMING, + GLOBALTRIGGERANGLEOFFSET, + ANALOGINPUTDIVIDERCOEFFICIENT, + VBATTDIVIDERCOEFF, + FANONTEMPERATURE, + FANOFFTEMPERATURE, + DRIVEWHEELREVPERKM, + CANNBCTYPE, + ALIGNMENTFILL_AT_433, + CANSLEEPPERIODMS, + DISPLAYMODE, + ALIGNMENTFILL_AT_441, + BYFIRMWAREVERSION, + HD44780WIDTH, + HD44780HEIGHT, + TPS1_1ADCCHANNEL, + VBATTADCCHANNEL, + FUELLEVELSENSOR, + TPS2_1ADCCHANNEL, + IDLE_DERIVATIVEFILTERLOSS, + TRAILINGSPARKANGLE, + TRIGGER_TYPE, + TRIGGER_CUSTOMTOTALTOOTHCOUNT, + TRIGGER_CUSTOMSKIPPEDTOOTHCOUNT, + AIRBYRPMTAPER, + HIP9011SPIDEVICE, + FAILEDMAPFALLBACK, + BOOSTCONTROLSAFEDUTYCYCLE, + MAFADCCHANNEL, + GLOBALFUELCORRECTION, + ADCVCC, + MAPCAMDETECTIONANGLEPOSITION, + CAMINPUTS1, + CAMINPUTS2, + CAMINPUTS3, + CAMINPUTS4, + AFR_HWCHANNEL, + AFR_HWCHANNEL2, + AFR_ALIGNMENTFILL_AT_2, + AFR_V1, + AFR_VALUE1, + AFR_V2, + AFR_VALUE2, + THROTTLEPEDALPOSITIONADCCHANNEL, + ALIGNMENTFILL_AT_529, + TLE6240_CS, + TLE6240_CSPINMODE, + ALIGNMENTFILL_AT_533, + THROTTLEPEDALUPPIN, + BAROSENSOR_LOWVALUE, + BAROSENSOR_HIGHVALUE, + BAROSENSOR_TYPE, + BAROSENSOR_HWCHANNEL, + BAROSENSOR_ALIGNMENTFILL_AT_10, + IDLE_SOLENOIDFREQUENCY, + IDLE_SOLENOIDPIN, + IDLE_STEPPERDIRECTIONPIN, + IDLE_STEPPERSTEPPIN, + IDLE_SOLENOIDPINMODE, + IDLE_ALIGNMENTFILL_AT_11, + MANIDLEPOSITION, + KNOCKRETARDAGGRESSION, + KNOCKRETARDREAPPLYRATE, + ENGINESYNCCAM, + VSSFILTERRECIPROCAL, + VSSGEARRATIO, + VSSTOOTHCOUNT, + ALIGNMENTFILL_AT_571, + L9779_CS, + ALIGNMENTFILL_AT_574, + TRIGGERSIMULATORFREQUENCY, + INJECTIONPINS1, + INJECTIONPINS2, + INJECTIONPINS3, + INJECTIONPINS4, + INJECTIONPINS5, + INJECTIONPINS6, + INJECTIONPINS7, + INJECTIONPINS8, + INJECTIONPINS9, + INJECTIONPINS10, + INJECTIONPINS11, + INJECTIONPINS12, + IGNITIONPINS1, + IGNITIONPINS2, + IGNITIONPINS3, + IGNITIONPINS4, + IGNITIONPINS5, + IGNITIONPINS6, + IGNITIONPINS7, + IGNITIONPINS8, + IGNITIONPINS9, + IGNITIONPINS10, + IGNITIONPINS11, + IGNITIONPINS12, + INJECTIONPINMODE, + IGNITIONPINMODE, + HD44780_RS, + HD44780_E, + HD44780_DB4, + HD44780_DB5, + HD44780_DB6, + HD44780_DB7, + GPS_RX_PIN, + GPS_TX_PIN, + FUELPUMPPIN, + FUELPUMPPINMODE, + ALIGNMENTFILL_AT_649, + MALFUNCTIONINDICATORPIN, + MALFUNCTIONINDICATORPINMODE, + FANPINMODE, + FANPIN, + CLUTCHDOWNPIN, + ALTERNATORCONTROLPIN, + ALTERNATORCONTROLPINMODE, + CLUTCHDOWNPINMODE, + DIGITALPOTENTIOMETERCHIPSELECT1, + DIGITALPOTENTIOMETERCHIPSELECT2, + DIGITALPOTENTIOMETERCHIPSELECT3, + DIGITALPOTENTIOMETERCHIPSELECT4, + ELECTRONICTHROTTLEPIN1MODE, + ALIGNMENTFILL_AT_671, + WBOHEATERPIN, + CJ125CSPIN, + MAX31855SPIDEVICE, + ALIGNMENTFILL_AT_677, + DEBUGTRIGGERSYNC, + DIGITALPOTENTIOMETERSPIDEVICE, + ALIGNMENTFILL_AT_681, + MC33972_CS, + MC33972_CSPINMODE, + AUXFASTSENSOR1_ADCCHANNEL, + TPS1_2ADCCHANNEL, + TPS2_2ADCCHANNEL, + THROTTLEPEDALPOSITIONSECONDADCCHANNEL, + FUELLEVELVALUES, + AFR_TYPE, + ALIGNMENTFILL_AT_698, + IDLE_ANTIWINDUPFREQ, + TRIGGERINPUTPINS1, + TRIGGERINPUTPINS2, + MC33_T_MIN_BOOST, + HIP9011CSPINMODE, + ALIGNMENTFILL_AT_711, + TACHOUTPUTPIN, + TACHOUTPUTPINMODE, + ALIGNMENTFILL_AT_715, + MAINRELAYPIN, + SDCARDCSPIN, + CANTXPIN, + CANRXPIN, + THROTTLEPEDALUPPINMODE, + ACIDLEEXTRAOFFSET, + FINALGEARRATIO, + TCUINPUTSPEEDSENSORPIN, + TCUINPUTSPEEDSENSORTEETH, + ALIGNMENTFILL_AT_731, + WASTEGATEPOSITIONMIN, + WASTEGATEPOSITIONMAX, + IDLEPOSITIONMIN, + IDLEPOSITIONMAX, + TUNERSTUDIOSERIALSPEED, + COMPRESSIONRATIO, + TRIGGERSIMULATORPINS1, + TRIGGERSIMULATORPINS2, + FORDINJECTORSMALLPULSESLOPE, + TRIGGERSIMULATORPINMODES1, + TRIGGERSIMULATORPINMODES2, + MAF2ADCCHANNEL, + ALIGNMENTFILL_AT_757, + O2HEATERPIN, + O2HEATERPINMODETODO, + ALIGNMENTFILL_AT_761, + IS_ENABLED_SPI_1, + IS_ENABLED_SPI_2, + IS_ENABLED_SPI_3, + ISSDCARDENABLED, + RUSEFIVERBOSE29B, + ISENGINECONTROLENABLED, + ISHIP9011ENABLED, + ISVERBOSEALTERNATOR, + VERBOSEQUAD, + USESTEPPERIDLE, + ENABLEDSTEP1LIMITER, + USETPICADVANCEDMODE, + USELCDSCREEN, + VERBOSETLE8888, + ENABLEVERBOSECANTX, + ETB1CONFIGURED, + ISCJ125ENABLED, + ETB2CONFIGURED, + MEASUREMAPONLYINONECYLINDER, + STEPPERFORCEPARKINGEVERYRESTART, + ISFASTERENGINESPINUPENABLED, + COASTINGFUELCUTENABLED, + USEIACTABLEFORCOASTING, + USENOISELESSTRIGGERDECODER, + USEIDLETIMINGPIDCONTROL, + DISABLEETBWHENENGINESTOPPED, + IS_ENABLED_SPI_4, + PAUSEETBCONTROL, + ALIGNENGINESNIFFERATTDC, + IDLEINCREMENTALPIDCIC, + ENABLEAEMXSERIES, + LOGICANALYZERPINS1, + LOGICANALYZERPINS2, + LOGICANALYZERPINS3, + LOGICANALYZERPINS4, + MAINRELAYPINMODE, + ALIGNMENTFILL_AT_777, + HIP9011CSPIN, + HIP9011INTHOLDPIN, + HIP9011INTHOLDPINMODE, + ALIGNMENTFILL_AT_783, + VERBOSECANBASEADDRESS, + MC33_HVOLT, + MINIMUMBOOSTCLOSEDLOOPMAP, + ACFANPIN, + ACFANPINMODE, + L9779SPIDEVICE, + DWELLVOLTAGECORRVOLTBINS, + IMUTYPE, + DWELLVOLTAGECORRVALUES, + ALIGNMENTFILL_AT_811, + VEHICLEWEIGHT, + IDLEPIDRPMUPPERLIMIT, + APPLYNONLINEARBELOWPULSE, + LPS25BAROSENSORSCL, + LPS25BAROSENSORSDA, + VEHICLESPEEDSENSORINPUTPIN, + CLUTCHUPPIN, + INJECTORNONLINEARMODE, + CLUTCHUPPINMODE, + MAX31855_CS1, + MAX31855_CS2, + MAX31855_CS3, + MAX31855_CS4, + MAX31855_CS5, + MAX31855_CS6, + MAX31855_CS7, + MAX31855_CS8, + FLEXSENSORPIN, + TEST557PIN, + STEPPERDIRECTIONPINMODE, + MC33972SPIDEVICE, + STOICHRATIOSECONDARY, + ETBMAXIMUMPOSITION, + SDCARDLOGFREQUENCY, + IDLEPOSITIONSENSOR, + ALIGNMENTFILL_AT_855, + DEBUGMAPAVERAGING, + STARTERRELAYDISABLEPIN, + STARTERRELAYDISABLEPINMODE, + ALIGNMENTFILL_AT_861, + SECONDSOLENOIDPIN, + STARTSTOPBUTTONPIN, + ALIGNMENTFILL_AT_866, + MAPMINBUFFERLENGTH, + IDLEPIDDEACTIVATIONTPSTHRESHOLD, + STEPPERPARKINGEXTRASTEPS, + TPS1SECONDARYMIN, + TPS1SECONDARYMAX, + ANTILAGRPMTRESHOLD, + STARTCRANKINGDURATION, + TRIGGERERRORPIN, + TRIGGERERRORPINMODE, + ALIGNMENTFILL_AT_887, + ACRELAYPIN, + ACRELAYPINMODE, + ALIGNMENTFILL_AT_891, + SCRIPTSETTING1, + SCRIPTSETTING2, + SCRIPTSETTING3, + SCRIPTSETTING4, + SCRIPTSETTING5, + SCRIPTSETTING6, + SCRIPTSETTING7, + SCRIPTSETTING8, + SPI1MOSIPIN, + SPI1MISOPIN, + SPI1SCKPIN, + SPI2MOSIPIN, + SPI2MISOPIN, + SPI2SCKPIN, + SPI3MOSIPIN, + SPI3MISOPIN, + SPI3SCKPIN, + CDMINPUTPIN, + JOYSTICKCENTERPIN, + JOYSTICKAPIN, + JOYSTICKBPIN, + JOYSTICKCPIN, + JOYSTICKDPIN, + CONSOLEUARTDEVICE, + SENSORCHARTMODE, + MAFSENSORTYPE, + ALIGNMENTFILL_AT_957, + CLUTCHUPPININVERTED, + CLUTCHDOWNPININVERTED, + USEHBRIDGESTODRIVEIDLESTEPPER, + MULTISPARKENABLE, + ENABLELAUNCHRETARD, + UNFINISHEDENABLELAUNCHBOOST, + UNFINISHEDLAUNCHDISABLEBYSPEED, + ENABLECANVSS, + ENABLEINNOVATELC2, + SHOWHUMANREADABLEWARNING, + STFTIGNOREERRORMAGNITUDE, + VVTBOOLEANFORVERYSPECIALCASES, + ENABLESOFTWAREKNOCK, + VERBOSEVVTDECODING, + INVERTCAMVVTSIGNAL, + CONSUMEOBDSENSORS, + KNOCKBANKCYL1, + KNOCKBANKCYL2, + KNOCKBANKCYL3, + KNOCKBANKCYL4, + KNOCKBANKCYL5, + KNOCKBANKCYL6, + KNOCKBANKCYL7, + KNOCKBANKCYL8, + KNOCKBANKCYL9, + KNOCKBANKCYL10, + KNOCKBANKCYL11, + KNOCKBANKCYL12, + TCUENABLED, + CANBROADCASTUSECHANNELTWO, + USERAWOUTPUTTODRIVEIDLESTEPPER, + VERBOSECAN2, + ETBIO1_DIRECTIONPIN1, + ETBIO1_DIRECTIONPIN2, + ETBIO1_CONTROLPIN, + ETBIO1_DISABLEPIN, + ETBIO2_DIRECTIONPIN1, + ETBIO2_DIRECTIONPIN2, + ETBIO2_CONTROLPIN, + ETBIO2_DISABLEPIN, + BOOSTCONTROLPIN, + BOOSTCONTROLPINMODE, + ALIGNMENTFILL_AT_983, + ALSACTIVATEPIN, + LAUNCHACTIVATEPIN, + BOOSTPID_PFACTOR, + BOOSTPID_IFACTOR, + BOOSTPID_DFACTOR, + BOOSTPID_OFFSET, + BOOSTPID_PERIODMS, + BOOSTPID_MINVALUE, + BOOSTPID_MAXVALUE, + BOOSTTYPE, + ALIGNMENTFILL_AT_1009, + BOOSTPWMFREQUENCY, + LAUNCHACTIVATIONMODE, + ANTILAGACTIVATIONMODE, + ALIGNMENTFILL_AT_1018, + LAUNCHSPEEDTHRESHOLD, + LAUNCHTIMINGRPMRANGE, + LAUNCHFUELADDED, + LAUNCHBOOSTDUTY, + HARDCUTRPMRANGE, + TURBOCHARGERFILTER, + LAUNCHTPSTHRESHOLD, + LAUNCHACTIVATEDELAY, + STFT_MAXIDLEREGIONRPM, + STFT_MAXOVERRUNLOAD, + STFT_MINPOWERLOAD, + STFT_DEADBAND, + STFT_MINCLT, + STFT_MINAFR, + STFT_MAXAFR, + STFT_STARTUPDELAY, + STFT_CELLCFGS1_MAXADD, + STFT_CELLCFGS1_MAXREMOVE, + STFT_CELLCFGS1_TIMECONSTANT, + STFT_CELLCFGS2_MAXADD, + STFT_CELLCFGS2_MAXREMOVE, + STFT_CELLCFGS2_TIMECONSTANT, + STFT_CELLCFGS3_MAXADD, + STFT_CELLCFGS3_MAXREMOVE, + STFT_CELLCFGS3_TIMECONSTANT, + STFT_CELLCFGS4_MAXADD, + STFT_CELLCFGS4_MAXREMOVE, + STFT_CELLCFGS4_TIMECONSTANT, + STEPPERDCIO1_DIRECTIONPIN1, + STEPPERDCIO1_DIRECTIONPIN2, + STEPPERDCIO1_CONTROLPIN, + STEPPERDCIO1_DISABLEPIN, + STEPPERDCIO2_DIRECTIONPIN1, + STEPPERDCIO2_DIRECTIONPIN2, + STEPPERDCIO2_CONTROLPIN, + STEPPERDCIO2_DISABLEPIN, + ENGINEMAKE, + ENGINECODE, + VEHICLENAME, + TCU_SOLENOID1, + TCU_SOLENOID2, + TCU_SOLENOID3, + TCU_SOLENOID4, + TCU_SOLENOID5, + TCU_SOLENOID6, + ETBFUNCTIONS1, + ETBFUNCTIONS2, + DRV8860SPIDEVICE, + ALIGNMENTFILL_AT_1203, + DRV8860_CS, + DRV8860_CSPINMODE, + ALIGNMENTFILL_AT_1207, + DRV8860_MISO, + FUELLEVELBINS, + LUAOUTPUTPINS1, + LUAOUTPUTPINS2, + LUAOUTPUTPINS3, + LUAOUTPUTPINS4, + LUAOUTPUTPINS5, + LUAOUTPUTPINS6, + LUAOUTPUTPINS7, + LUAOUTPUTPINS8, + ALIGNMENTFILL_AT_1242, + VVTOFFSETS1, + VVTOFFSETS2, + VVTOFFSETS3, + VVTOFFSETS4, + VRTHRESHOLD1_RPMBINS, + VRTHRESHOLD1_VALUES, + VRTHRESHOLD1_PIN, + VRTHRESHOLD1_ALIGNMENTFILL_AT_14, + VRTHRESHOLD2_RPMBINS, + VRTHRESHOLD2_VALUES, + VRTHRESHOLD2_PIN, + VRTHRESHOLD2_ALIGNMENTFILL_AT_14, + GPPWMNOTE1, + GPPWMNOTE2, + GPPWMNOTE3, + GPPWMNOTE4, + TPS2SECONDARYMIN, + TPS2SECONDARYMAX, + WIDEBANDONSECONDBUS, + FUELCLOSEDLOOPCORRECTIONENABLED, + ISVERBOSEIAC, + BOARDUSETACHPULLUP, + BOARDUSETEMPPULLUP, + YESUNDERSTANDLOCKING, + SILENTTRIGGERERROR, + USELINEARCLTSENSOR, + CANREADENABLED, + CANWRITEENABLED, + USELINEARIATSENSOR, + BOARDUSE2STEPPULLDOWN, + TACHPULSEDURATIONASDUTYCYCLE, + ISALTERNATORCONTROLENABLED, + INVERTPRIMARYTRIGGERSIGNAL, + INVERTSECONDARYTRIGGERSIGNAL, + CUTFUELONHARDLIMIT, + CUTSPARKONHARDLIMIT, + LAUNCHFUELCUTENABLE, + LAUNCHSPARKCUTENABLE, + BOARDUSECRANKPULLUP, + BOARDUSECAMPULLDOWN, + BOARDUSECAMVRPULLUP, + BOARDUSED2PULLDOWN, + BOARDUSED3PULLDOWN, + BOARDUSED4PULLDOWN, + BOARDUSED5PULLDOWN, + VERBOSEISOTP, + ENGINESNIFFERFOCUSONINPUTS, + LAUNCHACTIVATEINVERTED, + TWOSTROKE, + SKIPPEDWHEELONCAM, + HIPOUTPUTCHANNEL, + ALIGNMENTFILL_AT_1365, + ACSWITCH, + VREFADCCHANNEL, + ETBNEUTRALPOSITION, + IDLEMODE, + ALIGNMENTFILL_AT_1371, + ISINJECTIONENABLED, + ISIGNITIONENABLED, + ISCYLINDERCLEANUPENABLED, + COMPLEXWALLMODEL, + ALWAYSINSTANTRPM, + ISMAPAVERAGINGENABLED, + OVERRIDECRANKINGIACSETTING, + USESEPARATEADVANCEFORIDLE, + ISWAVEANALYZERENABLED, + USESEPARATEVEFORIDLE, + VERBOSETRIGGERSYNCHDETAILS, + ISMANUALSPINNINGMODE, + TWOWIREBATCHINJECTION, + NEVERINSTANTRPM, + TWOWIREBATCHIGNITION, + USEFIXEDBAROCORRFROMMAP, + USESEPARATEADVANCEFORCRANKING, + USEADVANCECORRECTIONSFORCRANKING, + FLEXCRANKING, + USEIACPIDMULTTABLE, + ISBOOSTCONTROLENABLED, + LAUNCHSMOOTHRETARD, + ISPHASESYNCREQUIREDFORIGNITION, + USECLTBASEDRPMLIMIT, + FORCEO2HEATING, + INVERTVVTCONTROLINTAKE, + INVERTVVTCONTROLEXHAUST, + USEBIQUADONAUXSPEEDSENSORS, + SDTRIGGERLOG, + ALSACTIVATEINVERTED, + TEMPBOOLEANFORVERYSPECIALLOGIC, + ENGINECHARTSIZE, + TURBOSPEEDSENSORMULTIPLIER, + CAMINPUTSDEBUG1, + CAMINPUTSDEBUG2, + CAMINPUTSDEBUG3, + CAMINPUTSDEBUG4, + ACIDLERPMBUMP, + WARNINGPERIOD, + KNOCKDETECTIONWINDOWSTART, + KNOCKDETECTIONWINDOWEND, + IDLESTEPPERREACTIONTIME, + IDLESTEPPERTOTALSTEPS, + NOACCELAFTERHARDLIMITPERIODSECS, + MAPAVERAGINGSCHEDULINGATINDEX, + TACHPULSEDURACTIONMS, + WWAETAU, + ALTERNATORCONTROL_PFACTOR, + ALTERNATORCONTROL_IFACTOR, + ALTERNATORCONTROL_DFACTOR, + ALTERNATORCONTROL_OFFSET, + ALTERNATORCONTROL_PERIODMS, + ALTERNATORCONTROL_MINVALUE, + ALTERNATORCONTROL_MAXVALUE, + ETB_PFACTOR, + ETB_IFACTOR, + ETB_DFACTOR, + ETB_OFFSET, + ETB_PERIODMS, + ETB_MINVALUE, + ETB_MAXVALUE, + TRIGGERINPUTDEBUGPINS1, + TRIGGERINPUTDEBUGPINS2, + AIRTAPERRPMRANGE, + TURBOSPEEDSENSORINPUTPIN, + TPS2MIN, + TPS2MAX, + STARTERCONTROLPIN, + STARTSTOPBUTTONMODE, + ALIGNMENTFILL_AT_1483, + MC33816_FLAG0, + TACHPULSEPERREV, + ALIGNMENTFILL_AT_1487, + MAPERRORDETECTIONTOOLOW, + MAPERRORDETECTIONTOOHIGH, + MULTISPARKSPARKDURATION, + MULTISPARKDWELL, + IDLERPMPID_PFACTOR, + IDLERPMPID_IFACTOR, + IDLERPMPID_DFACTOR, + IDLERPMPID_OFFSET, + IDLERPMPID_PERIODMS, + IDLERPMPID_MINVALUE, + IDLERPMPID_MAXVALUE, + WWAEBETA, + COMMUNICATIONLEDPIN, + RUNNINGLEDPIN, + BINARYSERIALTXPIN, + BINARYSERIALRXPIN, + AUXVALVES1, + AUXVALVES2, + TCUUPSHIFTBUTTONPIN, + TCUDOWNSHIFTBUTTONPIN, + THROTTLEPEDALUPVOLTAGE, + THROTTLEPEDALWOTVOLTAGE, + STARTUPFUELPUMPDURATION, + IDLEPIDRPMDEADZONE, + TARGETVBATT, + ALTERNATOROFFABOVETPS, + AFTERCRANKINGIACTAPERDURATION, + IACBYTPSTAPER, + AUXSERIALTXPIN, + WARNINGLEDPIN, + AUXSERIALRXPIN, + LIS302DLCSPIN, + TPSACCELLOOKBACK, + COASTINGFUELCUTVSSLOW, + COASTINGFUELCUTVSSHIGH, + NOFUELTRIMAFTERDFCOTIME, + TPSACCELENRICHMENTTHRESHOLD, + AUXSPEEDSENSORINPUTPIN1, + AUXSPEEDSENSORINPUTPIN2, + TOTALGEARSCOUNT, + INJECTIONTIMINGMODE, + ALIGNMENTFILL_AT_1586, + UARTCONSOLESERIALSPEED, + TPSDECELENLEANMENTTHRESHOLD, + TPSDECELENLEANMENTMULTIPLIER, + SLOWADCALPHA, + DEBUGMODE, + ALIGNMENTFILL_AT_1605, + AUXSERIALSPEED, + THROTTLEPEDALSECONDARYUPVOLTAGE, + THROTTLEPEDALSECONDARYWOTVOLTAGE, + CANBAUDRATE, + VEOVERRIDEMODE, + CAN2BAUDRATE, + AFROVERRIDEMODE, + MC33_HPFP_I_PEAK, + MC33_HPFP_I_HOLD, + MC33_HPFP_I_HOLD_OFF, + MC33_HPFP_MAX_HOLD, + STEPPERDCINVERTEDPINS, + CANOPENBLT, + CAN2OPENBLT, + INJECTORFLOWASMASSFLOW, + BENCHTESTOFFTIME, + BENCHTESTCOUNT, + BENCHTESTONTIME, + LAUNCHACTIVATEPINMODE, + CAN2TXPIN, + CAN2RXPIN, + STARTERCONTROLPINMODE, + WASTEGATEPOSITIONSENSOR, + IGNOVERRIDEMODE, + INJECTORPRESSURETYPE, + HPFPVALVEPIN, + HPFPVALVEPINMODE, + ALIGNMENTFILL_AT_1647, + BOOSTCUTPRESSURE, + TCHARGEBINS, + TCHARGEVALUES, + FIXEDTIMING, + MAPLOWVALUEVOLTAGE, + MAPHIGHVALUEVOLTAGE, + EGOVALUESHIFT, + VVTPINS1, + VVTPINS2, + VVTPINS3, + VVTPINS4, + CJ125SPIDEVICE, + CJ125CSPINMODE, + SDCARDCSPINMODE, + ALIGNMENTFILL_AT_1711, + CRANKINGIACPOSITION, + TCHARGEMINRPMMINTPS, + TCHARGEMINRPMMAXTPS, + TCHARGEMAXRPMMINTPS, + TCHARGEMAXRPMMAXTPS, + VVTOUTPUTFREQUENCY1, + VVTOUTPUTFREQUENCY2, + FAN1EXTRAIDLE, + ALIGNMENTFILL_AT_1737, + ALTERNATORPWMFREQUENCY, + VVTMODE1, + VVTMODE2, + FAN2EXTRAIDLE, + PRIMINGDELAY, + AUXANALOGINPUTS1, + AUXANALOGINPUTS2, + AUXANALOGINPUTS3, + AUXANALOGINPUTS4, + AUXANALOGINPUTS5, + AUXANALOGINPUTS6, + AUXANALOGINPUTS7, + AUXANALOGINPUTS8, + TRAILINGCOILPINS1, + TRAILINGCOILPINS2, + TRAILINGCOILPINS3, + TRAILINGCOILPINS4, + TRAILINGCOILPINS5, + TRAILINGCOILPINS6, + TRAILINGCOILPINS7, + TRAILINGCOILPINS8, + TRAILINGCOILPINS9, + TRAILINGCOILPINS10, + TRAILINGCOILPINS11, + TRAILINGCOILPINS12, + TLE8888MODE, + LIS302DLCSPINMODE, + INJECTORCOMPENSATIONMODE, + FAN2PINMODE, + FUELREFERENCEPRESSURE, + POSTCRANKINGFACTOR, + POSTCRANKINGDURATIONSEC, + AUXTEMPSENSOR1_TEMPC_1, + AUXTEMPSENSOR1_TEMPC_2, + AUXTEMPSENSOR1_TEMPC_3, + AUXTEMPSENSOR1_RESISTANCE_1, + AUXTEMPSENSOR1_RESISTANCE_2, + AUXTEMPSENSOR1_RESISTANCE_3, + AUXTEMPSENSOR1_BIAS_RESISTOR, + AUXTEMPSENSOR1_ADCCHANNEL, + AUXTEMPSENSOR1_ALIGNMENTFILL_AT_29, + AUXTEMPSENSOR2_TEMPC_1, + AUXTEMPSENSOR2_TEMPC_2, + AUXTEMPSENSOR2_TEMPC_3, + AUXTEMPSENSOR2_RESISTANCE_1, + AUXTEMPSENSOR2_RESISTANCE_2, + AUXTEMPSENSOR2_RESISTANCE_3, + AUXTEMPSENSOR2_BIAS_RESISTOR, + AUXTEMPSENSOR2_ADCCHANNEL, + AUXTEMPSENSOR2_ALIGNMENTFILL_AT_29, + KNOCKSAMPLINGDURATION, + ETBFREQ, + ETBWASTEGATEPID_PFACTOR, + ETBWASTEGATEPID_IFACTOR, + ETBWASTEGATEPID_DFACTOR, + ETBWASTEGATEPID_OFFSET, + ETBWASTEGATEPID_PERIODMS, + ETBWASTEGATEPID_MINVALUE, + ETBWASTEGATEPID_MAXVALUE, + STEPPERNUMMICROSTEPS, + STEPPERMINDUTYCYCLE, + STEPPERMAXDUTYCYCLE, + SDCARDSPIDEVICE, + TIMING_OFFSET_CYLINDER1, + TIMING_OFFSET_CYLINDER2, + TIMING_OFFSET_CYLINDER3, + TIMING_OFFSET_CYLINDER4, + TIMING_OFFSET_CYLINDER5, + TIMING_OFFSET_CYLINDER6, + TIMING_OFFSET_CYLINDER7, + TIMING_OFFSET_CYLINDER8, + TIMING_OFFSET_CYLINDER9, + TIMING_OFFSET_CYLINDER10, + TIMING_OFFSET_CYLINDER11, + TIMING_OFFSET_CYLINDER12, + IDLEPIDACTIVATIONTIME, + SPI1SCKMODE, + SPI1MOSIMODE, + SPI1MISOMODE, + SPI2SCKMODE, + SPI2MOSIMODE, + SPI2MISOMODE, + SPI3SCKMODE, + SPI3MOSIMODE, + SPI3MISOMODE, + STEPPERENABLEPINMODE, + MC33816_RSTB, + MC33816_DRIVEN, + BRAKEPEDALPIN, + CJ125UA, + CJ125UR, + BRAKEPEDALPINMODE, + ALIGNMENTFILL_AT_1959, + AUXPID1_PFACTOR, + AUXPID1_IFACTOR, + AUXPID1_DFACTOR, + AUXPID1_OFFSET, + AUXPID1_PERIODMS, + AUXPID1_MINVALUE, + AUXPID1_MAXVALUE, + AUXPID2_PFACTOR, + AUXPID2_IFACTOR, + AUXPID2_DFACTOR, + AUXPID2_OFFSET, + AUXPID2_PERIODMS, + AUXPID2_MINVALUE, + AUXPID2_MAXVALUE, + INJECTORCORRECTIONPOLYNOMIAL1, + INJECTORCORRECTIONPOLYNOMIAL2, + INJECTORCORRECTIONPOLYNOMIAL3, + INJECTORCORRECTIONPOLYNOMIAL4, + INJECTORCORRECTIONPOLYNOMIAL5, + INJECTORCORRECTIONPOLYNOMIAL6, + INJECTORCORRECTIONPOLYNOMIAL7, + INJECTORCORRECTIONPOLYNOMIAL8, + PRIMEBINS, + OILPRESSURE_HWCHANNEL, + OILPRESSURE_ALIGNMENTFILL_AT_1, + OILPRESSURE_V1, + OILPRESSURE_VALUE1, + OILPRESSURE_V2, + OILPRESSURE_VALUE2, + ACCELEROMETERSPIDEVICE, + ALIGNMENTFILL_AT_2061, + FAN2PIN, + FAN2ONTEMPERATURE, + FAN2OFFTEMPERATURE, + STEPPERENABLEPIN, + TLE8888_CS, + TLE8888_CSPINMODE, + ALIGNMENTFILL_AT_2071, + MC33816_CS, + ALIGNMENTFILL_AT_2074, + AUXFREQUENCYFILTER, + VVTCONTROLMINRPM, + SENTINPUTPINS1, + LAUNCHFUELADDERPERCENT, + ETBJAMTIMEOUT, + ETBEXPAVERAGELENGTH, + ETBDUTYTHRESHOLD, + COASTINGFUELCUTRPMHIGH, + COASTINGFUELCUTRPMLOW, + COASTINGFUELCUTTPS, + COASTINGFUELCUTCLT, + PIDEXTRAFORLOWRPM, + COASTINGFUELCUTMAP, + HIGHPRESSUREFUEL_HWCHANNEL, + HIGHPRESSUREFUEL_ALIGNMENTFILL_AT_1, + HIGHPRESSUREFUEL_V1, + HIGHPRESSUREFUEL_VALUE1, + HIGHPRESSUREFUEL_V2, + HIGHPRESSUREFUEL_VALUE2, + LOWPRESSUREFUEL_HWCHANNEL, + LOWPRESSUREFUEL_ALIGNMENTFILL_AT_1, + LOWPRESSUREFUEL_V1, + LOWPRESSUREFUEL_VALUE1, + LOWPRESSUREFUEL_V2, + LOWPRESSUREFUEL_VALUE2, + CLTREVLIMITRPMBINS, + CLTREVLIMITRPM, + SCRIPTCURVENAME1, + SCRIPTCURVENAME2, + SCRIPTCURVENAME3, + SCRIPTCURVENAME4, + SCRIPTCURVENAME5, + SCRIPTCURVENAME6, + SCRIPTTABLENAME1, + SCRIPTTABLENAME2, + SCRIPTTABLENAME3, + SCRIPTTABLENAME4, + SCRIPTSETTINGNAME1, + SCRIPTSETTINGNAME2, + SCRIPTSETTINGNAME3, + SCRIPTSETTINGNAME4, + SCRIPTSETTINGNAME5, + SCRIPTSETTINGNAME6, + SCRIPTSETTINGNAME7, + SCRIPTSETTINGNAME8, + TCHARGEAIRCOEFMIN, + TCHARGEAIRCOEFMAX, + TCHARGEAIRFLOWMAX, + TCHARGEAIRINCRLIMIT, + TCHARGEAIRDECRLIMIT, + TCHARGEMODE, + ALIGNMENTFILL_AT_2465, + HIP9011GAIN, + ETB_ITERMMIN, + ETB_ITERMMAX, + IDLETIMINGPID_PFACTOR, + IDLETIMINGPID_IFACTOR, + IDLETIMINGPID_DFACTOR, + IDLETIMINGPID_OFFSET, + IDLETIMINGPID_PERIODMS, + IDLETIMINGPID_MINVALUE, + IDLETIMINGPID_MAXVALUE, + ETBROCEXPAVERAGELENGTH, + TPSACCELFRACTIONPERIOD, + TPSACCELFRACTIONDIVISOR, + TLE8888SPIDEVICE, + MC33816SPIDEVICE, + IDLERPMPID_ITERMMIN, + TLE6240SPIDEVICE, + STOICHRATIOPRIMARY, + IDLERPMPID_ITERMMAX, + ETBIDLETHROTTLERANGE, + CYLINDERBANKSELECT1, + CYLINDERBANKSELECT2, + CYLINDERBANKSELECT3, + CYLINDERBANKSELECT4, + CYLINDERBANKSELECT5, + CYLINDERBANKSELECT6, + CYLINDERBANKSELECT7, + CYLINDERBANKSELECT8, + CYLINDERBANKSELECT9, + CYLINDERBANKSELECT10, + CYLINDERBANKSELECT11, + CYLINDERBANKSELECT12, + PRIMEVALUES, + TRIGGERCOMPCENTERVOLT, + TRIGGERCOMPHYSTMIN, + TRIGGERCOMPHYSTMAX, + TRIGGERCOMPSENSORSATRPM, + IDLERPMPID2_PFACTOR, + IDLERPMPID2_IFACTOR, + IDLERPMPID2_DFACTOR, + IDLERPMPID2_OFFSET, + IDLERPMPID2_PERIODMS, + IDLERPMPID2_MINVALUE, + IDLERPMPID2_MAXVALUE, + CANVSSNBCTYPE, + ALIGNMENTFILL_AT_2561, + GPPWM1_PIN, + GPPWM1_DUTYIFERROR, + GPPWM1_ALIGNMENTFILL_AT_3, + GPPWM1_PWMFREQUENCY, + GPPWM1_ONABOVEDUTY, + GPPWM1_OFFBELOWDUTY, + GPPWM1_LOADAXIS, + GPPWM1_RPMAXIS, + GPPWM1_LOADBINS, + GPPWM1_RPMBINS, + GPPWM1_TABLE, + GPPWM1_ALIGNMENTFILL_AT_106, + GPPWM2_PIN, + GPPWM2_DUTYIFERROR, + GPPWM2_ALIGNMENTFILL_AT_3, + GPPWM2_PWMFREQUENCY, + GPPWM2_ONABOVEDUTY, + GPPWM2_OFFBELOWDUTY, + GPPWM2_LOADAXIS, + GPPWM2_RPMAXIS, + GPPWM2_LOADBINS, + GPPWM2_RPMBINS, + GPPWM2_TABLE, + GPPWM2_ALIGNMENTFILL_AT_106, + GPPWM3_PIN, + GPPWM3_DUTYIFERROR, + GPPWM3_ALIGNMENTFILL_AT_3, + GPPWM3_PWMFREQUENCY, + GPPWM3_ONABOVEDUTY, + GPPWM3_OFFBELOWDUTY, + GPPWM3_LOADAXIS, + GPPWM3_RPMAXIS, + GPPWM3_LOADBINS, + GPPWM3_RPMBINS, + GPPWM3_TABLE, + GPPWM3_ALIGNMENTFILL_AT_106, + GPPWM4_PIN, + GPPWM4_DUTYIFERROR, + GPPWM4_ALIGNMENTFILL_AT_3, + GPPWM4_PWMFREQUENCY, + GPPWM4_ONABOVEDUTY, + GPPWM4_OFFBELOWDUTY, + GPPWM4_LOADAXIS, + GPPWM4_RPMAXIS, + GPPWM4_LOADBINS, + GPPWM4_RPMBINS, + GPPWM4_TABLE, + GPPWM4_ALIGNMENTFILL_AT_106, + MC33_I_BOOST, + MC33_I_PEAK, + MC33_I_HOLD, + MC33_T_MAX_BOOST, + MC33_T_PEAK_OFF, + MC33_T_PEAK_TOT, + MC33_T_BYPASS, + MC33_T_HOLD_OFF, + MC33_T_HOLD_TOT, + TCUUPSHIFTBUTTONPINMODE, + TCUDOWNSHIFTBUTTONPINMODE, + ACSWITCHMODE, + TCU_SOLENOID_MODE1, + TCU_SOLENOID_MODE2, + TCU_SOLENOID_MODE3, + TCU_SOLENOID_MODE4, + TCU_SOLENOID_MODE5, + TCU_SOLENOID_MODE6, + KNOCKBASENOISE, + ALIGNMENTFILL_AT_3039, + TRIGGERGAPOVERRIDEFROM1, + TRIGGERGAPOVERRIDEFROM2, + TRIGGERGAPOVERRIDEFROM3, + TRIGGERGAPOVERRIDEFROM4, + TRIGGERGAPOVERRIDEFROM5, + TRIGGERGAPOVERRIDEFROM6, + TRIGGERGAPOVERRIDEFROM7, + TRIGGERGAPOVERRIDEFROM8, + TRIGGERGAPOVERRIDEFROM9, + TRIGGERGAPOVERRIDEFROM10, + TRIGGERGAPOVERRIDEFROM11, + TRIGGERGAPOVERRIDEFROM12, + TRIGGERGAPOVERRIDEFROM13, + TRIGGERGAPOVERRIDEFROM14, + TRIGGERGAPOVERRIDEFROM15, + TRIGGERGAPOVERRIDEFROM16, + TRIGGERGAPOVERRIDEFROM17, + TRIGGERGAPOVERRIDEFROM18, + TRIGGERGAPOVERRIDETO1, + TRIGGERGAPOVERRIDETO2, + TRIGGERGAPOVERRIDETO3, + TRIGGERGAPOVERRIDETO4, + TRIGGERGAPOVERRIDETO5, + TRIGGERGAPOVERRIDETO6, + TRIGGERGAPOVERRIDETO7, + TRIGGERGAPOVERRIDETO8, + TRIGGERGAPOVERRIDETO9, + TRIGGERGAPOVERRIDETO10, + TRIGGERGAPOVERRIDETO11, + TRIGGERGAPOVERRIDETO12, + TRIGGERGAPOVERRIDETO13, + TRIGGERGAPOVERRIDETO14, + TRIGGERGAPOVERRIDETO15, + TRIGGERGAPOVERRIDETO16, + TRIGGERGAPOVERRIDETO17, + TRIGGERGAPOVERRIDETO18, + MAXCAMPHASERESOLVERPM, + DFCODELAY, + ACDELAY, + ALIGNMENTFILL_AT_3187, + FORDINJECTORSMALLPULSEBREAKPOINT, + TPSTSPCORRVALUES, + ETBJAMINTEGRATORLIMIT, + HPFPCAMLOBES, + HPFPCAM, + HPFPPEAKPOS, + HPFPMINANGLE, + ALIGNMENTFILL_AT_3199, + HPFPPUMPVOLUME, + HPFPACTIVATIONANGLE, + ISSFILTERRECIPROCAL, + HPFPPIDP, + HPFPPIDI, + HPFPTARGETDECAY, + HPFPLOBEPROFILEQUANTITYBINS, + HPFPLOBEPROFILEANGLE, + HPFPDEADTIMEVOLTSBINS, + HPFPDEADTIMEMS, + HPFPTARGET, + HPFPTARGETLOADBINS, + HPFPTARGETRPMBINS, + HPFPCOMPENSATION, + HPFPCOMPENSATIONLOADBINS, + HPFPCOMPENSATIONRPMBINS, + STEPPER_RAW_OUTPUT1, + STEPPER_RAW_OUTPUT2, + STEPPER_RAW_OUTPUT3, + STEPPER_RAW_OUTPUT4, + GEARRATIO1, + GEARRATIO2, + GEARRATIO3, + GEARRATIO4, + GEARRATIO5, + GEARRATIO6, + GEARRATIO7, + GEARRATIO8, + VVTACTIVATIONDELAYMS, + WWCLTBINS, + WWTAUCLTVALUES, + WWBETACLTVALUES, + WWMAPBINS, + WWTAUMAPVALUES, + WWBETAMAPVALUES, + TORQUETABLE, + TORQUERPMBINS, + TORQUELOADBINS, + GEARCONTROLLERMODE, + TRANSMISSIONCONTROLLERMODE, + ALIGNMENTFILL_AT_3762, + AUXLINEAR1_HWCHANNEL, + AUXLINEAR1_ALIGNMENTFILL_AT_1, + AUXLINEAR1_V1, + AUXLINEAR1_VALUE1, + AUXLINEAR1_V2, + AUXLINEAR1_VALUE2, + AUXLINEAR2_HWCHANNEL, + AUXLINEAR2_ALIGNMENTFILL_AT_1, + AUXLINEAR2_V1, + AUXLINEAR2_VALUE1, + AUXLINEAR2_V2, + AUXLINEAR2_VALUE2, + TCU_TCC_ONOFF_SOLENOID, + TCU_TCC_ONOFF_SOLENOID_MODE, + ALIGNMENTFILL_AT_3807, + TCU_TCC_PWM_SOLENOID, + TCU_TCC_PWM_SOLENOID_MODE, + ALIGNMENTFILL_AT_3811, + TCU_TCC_PWM_SOLENOID_FREQ, + TCU_PC_SOLENOID_PIN, + TCU_PC_SOLENOID_PIN_MODE, + ALIGNMENTFILL_AT_3817, + TCU_PC_SOLENOID_FREQ, + TCU_32_SOLENOID_PIN, + TCU_32_SOLENOID_PIN_MODE, + ALIGNMENTFILL_AT_3823, + TCU_32_SOLENOID_FREQ, + ALIGNMENTFILL_AT_3826, + ETBMINIMUMPOSITION, + TUNEHIDINGKEY, + VINNUMBER, + ALIGNMENTFILL_AT_3851, + HIGHSPEEDOFFSETS, + ETBDUTYSHUTDOWNTHRESHOLD, + LUADIGITALINPUTPINS1, + LUADIGITALINPUTPINS2, + LUADIGITALINPUTPINS3, + LUADIGITALINPUTPINS4, + LUADIGITALINPUTPINS5, + LUADIGITALINPUTPINS6, + LUADIGITALINPUTPINS7, + LUADIGITALINPUTPINS8, + TPSTSPCORRVALUESBINS, + ALSMINRPM, + ALSMAXRPM, + ALSMAXDURATION, + ALSMINCLT, + ALSMAXCLT, + ALSMINTIMEBETWEEN, + ALSETBPOSITION, + ACRELAYALTERNATORDUTYADDER, + INSTANTRPMRANGE, + UNUSEDA11LIGNMENTFILL_AT_33, + SENTETBTYPE, + ALIGNMENTFILL_AT_3954, + ALSIDLEADD, + ALSETBADD, + ALSSKIPRATIO, + ALSMAXDRIVERTHROTTLEINTENT, + ALSACTIVATEPINMODE, + TPSSECONDARYMAXIMUM, + PPSSECONDARYMAXIMUM, + LUADIGITALINPUTPINMODES1, + LUADIGITALINPUTPINMODES2, + LUADIGITALINPUTPINMODES3, + LUADIGITALINPUTPINMODES4, + LUADIGITALINPUTPINMODES5, + LUADIGITALINPUTPINMODES6, + LUADIGITALINPUTPINMODES7, + LUADIGITALINPUTPINMODES8, + MAINUNUSEDEND, + ETBBIASBINS, + ETBBIASVALUES, + IACPIDMULTTABLE, + IACPIDMULTLOADBINS, + IACPIDMULTRPMBINS, + SPARKDWELLRPMBINS, + SPARKDWELLVALUES, + CLTIDLERPMBINS, + CLTIDLERPM, + CLTTIMINGBINS, + CLTTIMINGEXTRA, + SCRIPTCURVE1BINS, + SCRIPTCURVE1, + SCRIPTCURVE2BINS, + SCRIPTCURVE2, + SCRIPTCURVE3BINS, + SCRIPTCURVE3, + SCRIPTCURVE4BINS, + SCRIPTCURVE4, + SCRIPTCURVE5BINS, + SCRIPTCURVE5, + SCRIPTCURVE6BINS, + SCRIPTCURVE6, + BAROCORRPRESSUREBINS, + BAROCORRRPMBINS, + BAROCORRTABLE, + CRANKINGTPSCOEF, + CRANKINGTPSBINS, + NARROWTOWIDEOXYGENBINS, + NARROWTOWIDEOXYGEN, + CRANKINGADVANCEBINS, + CRANKINGADVANCE, + IACCOASTINGRPMBINS, + IACCOASTING, + WARNING_MESSAGE, + AFTERSTARTCOOLANTBINS, + AFTERSTARTHOLDTIME, + AFTERSTARTENRICH, + AFTERSTARTDECAYTIME, + BOOSTTABLEOPENLOOP, + BOOSTRPMBINS, + BOOSTTABLECLOSEDLOOP, + BOOSTTPSBINS, + PEDALTOTPSTABLE, + PEDALTOTPSPEDALBINS, + PEDALTOTPSRPMBINS, + CLTCRANKINGCORRBINS, + CLTCRANKINGCORR, + IDLEADVANCEBINS, + IDLEADVANCE, + IDLEVERPMBINS, + IDLEVELOADBINS, + IDLEVETABLE, + LUASCRIPT, + CLTFUELCORRBINS, + CLTFUELCORR, + IATFUELCORRBINS, + IATFUELCORR, + CRANKINGFUELCOEF, + CRANKINGFUELBINS, + CRANKINGCYCLECOEF, + CRANKINGCYCLEBINS, + CLTIDLECORRBINS, + CLTIDLECORR, + MAFDECODING, + MAFDECODINGBINS, + IGNITIONIATCORRTABLE, + IGNITIONIATCORRTEMPBINS, + IGNITIONIATCORRLOADBINS, + INJECTIONPHASE, + INJPHASELOADBINS, + INJPHASERPMBINS, + TCUSOLENOIDTABLE, + MAPESTIMATETABLE, + MAPESTIMATETPSBINS, + MAPESTIMATERPMBINS, + VVTTABLE1, + VVTTABLE1LOADBINS, + VVTTABLE1RPMBINS, + VVTTABLE2, + VVTTABLE2LOADBINS, + VVTTABLE2RPMBINS, + IGNITIONTABLE, + IGNITIONLOADBINS, + IGNITIONRPMBINS, + VETABLE, + VELOADBINS, + VERPMBINS, + LAMBDATABLE, + LAMBDALOADBINS, + LAMBDARPMBINS, + TPSTPSACCELTABLE, + TPSTPSACCELFROMRPMBINS, + TPSTPSACCELTORPMBINS, + SCRIPTTABLE1, + SCRIPTTABLE1LOADBINS, + SCRIPTTABLE1RPMBINS, + SCRIPTTABLE2, + SCRIPTTABLE2LOADBINS, + SCRIPTTABLE2RPMBINS, + SCRIPTTABLE3, + SCRIPTTABLE3LOADBINS, + SCRIPTTABLE3RPMBINS, + SCRIPTTABLE4, + SCRIPTTABLE4LOADBINS, + SCRIPTTABLE4RPMBINS, + IGNTRIMLOADBINS, + IGNTRIMRPMBINS, + IGNTRIMS1_TABLE, + IGNTRIMS2_TABLE, + IGNTRIMS3_TABLE, + IGNTRIMS4_TABLE, + IGNTRIMS5_TABLE, + IGNTRIMS6_TABLE, + IGNTRIMS7_TABLE, + IGNTRIMS8_TABLE, + IGNTRIMS9_TABLE, + IGNTRIMS10_TABLE, + IGNTRIMS11_TABLE, + IGNTRIMS12_TABLE, + FUELTRIMLOADBINS, + FUELTRIMRPMBINS, + FUELTRIMS1_TABLE, + FUELTRIMS2_TABLE, + FUELTRIMS3_TABLE, + FUELTRIMS4_TABLE, + FUELTRIMS5_TABLE, + FUELTRIMS6_TABLE, + FUELTRIMS7_TABLE, + FUELTRIMS8_TABLE, + FUELTRIMS9_TABLE, + FUELTRIMS10_TABLE, + FUELTRIMS11_TABLE, + FUELTRIMS12_TABLE, + CRANKINGFUELCOEFE100, + TCU_PCAIRMASSBINS, + TCU_PCVALSR, + TCU_PCVALSN, + TCU_PCVALS1, + TCU_PCVALS2, + TCU_PCVALS3, + TCU_PCVALS4, + TCU_PCVALS12, + TCU_PCVALS23, + TCU_PCVALS34, + TCU_PCVALS21, + TCU_PCVALS32, + TCU_PCVALS43, + TCU_TCCTPSBINS, + TCU_TCCLOCKSPEED, + TCU_TCCUNLOCKSPEED, + TCU_32SPEEDBINS, + TCU_32VALS, + THROTTLE2TRIMTABLE, + THROTTLE2TRIMTPSBINS, + THROTTLE2TRIMRPMBINS, + MAXKNOCKRETARDTABLE, + MAXKNOCKRETARDLOADBINS, + MAXKNOCKRETARDRPMBINS, + ALSTIMINGRETARDTABLE, + ALSIGNRETARDLOADBINS, + ALSIGNRETARDRPMBINS, + ALSFUELADJUSTMENT, + ALSFUELADJUSTMENTLOADBINS, + ALSFUELADJUSTMENTRPMBINS, + IGNBLENDS1_TABLE, + IGNBLENDS1_LOADBINS, + IGNBLENDS1_RPMBINS, + IGNBLENDS1_BLENDPARAMETER, + IGNBLENDS1_ALIGNMENTFILL_AT_161, + IGNBLENDS1_BLENDBINS, + IGNBLENDS1_BLENDVALUES, + IGNBLENDS1_ALIGNMENTFILL_AT_186, + IGNBLENDS2_TABLE, + IGNBLENDS2_LOADBINS, + IGNBLENDS2_RPMBINS, + IGNBLENDS2_BLENDPARAMETER, + IGNBLENDS2_ALIGNMENTFILL_AT_161, + IGNBLENDS2_BLENDBINS, + IGNBLENDS2_BLENDVALUES, + IGNBLENDS2_ALIGNMENTFILL_AT_186, + IGNBLENDS3_TABLE, + IGNBLENDS3_LOADBINS, + IGNBLENDS3_RPMBINS, + IGNBLENDS3_BLENDPARAMETER, + IGNBLENDS3_ALIGNMENTFILL_AT_161, + IGNBLENDS3_BLENDBINS, + IGNBLENDS3_BLENDVALUES, + IGNBLENDS3_ALIGNMENTFILL_AT_186, + IGNBLENDS4_TABLE, + IGNBLENDS4_LOADBINS, + IGNBLENDS4_RPMBINS, + IGNBLENDS4_BLENDPARAMETER, + IGNBLENDS4_ALIGNMENTFILL_AT_161, + IGNBLENDS4_BLENDBINS, + IGNBLENDS4_BLENDVALUES, + IGNBLENDS4_ALIGNMENTFILL_AT_186, + VEBLENDS1_TABLE, + VEBLENDS1_LOADBINS, + VEBLENDS1_RPMBINS, + VEBLENDS1_BLENDPARAMETER, + VEBLENDS1_ALIGNMENTFILL_AT_161, + VEBLENDS1_BLENDBINS, + VEBLENDS1_BLENDVALUES, + VEBLENDS1_ALIGNMENTFILL_AT_186, + VEBLENDS2_TABLE, + VEBLENDS2_LOADBINS, + VEBLENDS2_RPMBINS, + VEBLENDS2_BLENDPARAMETER, + VEBLENDS2_ALIGNMENTFILL_AT_161, + VEBLENDS2_BLENDBINS, + VEBLENDS2_BLENDVALUES, + VEBLENDS2_ALIGNMENTFILL_AT_186, + VEBLENDS3_TABLE, + VEBLENDS3_LOADBINS, + VEBLENDS3_RPMBINS, + VEBLENDS3_BLENDPARAMETER, + VEBLENDS3_ALIGNMENTFILL_AT_161, + VEBLENDS3_BLENDBINS, + VEBLENDS3_BLENDVALUES, + VEBLENDS3_ALIGNMENTFILL_AT_186, + VEBLENDS4_TABLE, + VEBLENDS4_LOADBINS, + VEBLENDS4_RPMBINS, + VEBLENDS4_BLENDPARAMETER, + VEBLENDS4_ALIGNMENTFILL_AT_161, + VEBLENDS4_BLENDBINS, + VEBLENDS4_BLENDVALUES, + VEBLENDS4_ALIGNMENTFILL_AT_186, + }; +}