From a273376a4a71c2dca628f9e79eed76d2fe7495d0 Mon Sep 17 00:00:00 2001 From: GitHub git update Action Date: Tue, 5 Mar 2024 17:18:31 +0000 Subject: [PATCH] GHA Automation --- .../binary/output_channels_generated.h | 1280 +++++++++++++++++ .../actuators/ac_control_generated.h | 136 ++ .../actuators/boost_control_generated.h | 156 ++ .../actuators/dc_motors_generated.h | 126 ++ .../actuators/electronic_throttle_generated.h | 187 +++ .../actuators/fan_control_generated.h | 108 ++ .../actuators/fuel_pump_control_generated.h | 108 ++ .../actuators/idle_state_generated.h | 181 +++ .../actuators/main_relay_generated.h | 108 ++ .../controllers/actuators/vvt_generated.h | 28 + .../algo/antilag_system_state_generated.h | 122 ++ .../controllers/algo/engine_state_generated.h | 402 ++++++ .../algo/fuel/fuel_computer_generated.h | 207 +++ .../algo/fuel/injector_model_generated.h | 29 + .../algo/ignition_state_generated.h | 183 +++ .../algo/launch_control_state_generated.h | 112 ++ .../algo/tps_accel_state_generated.h | 159 ++ .../algo/wall_fuel_state_generated.h | 24 + .../high_pressure_fuel_pump_generated.h | 140 ++ .../engine_cycle/knock_controller_generated.h | 45 + ...e_configuration_generated_structures_XXX.h | 6 +- .../generated/rusefi_generated_XXX.h | 32 +- .../controllers/generated/signature_XXX.h | 4 +- .../math/lambda_monitor_generated.h | 119 ++ .../math/throttle_model_generated.h | 127 ++ .../sensors/sent_state_generated.h | 30 + .../sensors/wideband_state_generated.h | 59 + .../tcu/tcu_controller_generated.h | 45 + .../trigger/trigger_central_generated.h | 169 +++ .../trigger/trigger_state_generated.h | 56 + .../trigger/trigger_state_primary_generated.h | 120 ++ .../tunerstudio/generated/rusefi_XXX.ini | 319 ++-- 32 files changed, 4765 insertions(+), 162 deletions(-) create mode 100644 generated/console/binary/output_channels_generated.h create mode 100644 generated/controllers/actuators/ac_control_generated.h create mode 100644 generated/controllers/actuators/boost_control_generated.h create mode 100644 generated/controllers/actuators/dc_motors_generated.h create mode 100644 generated/controllers/actuators/electronic_throttle_generated.h create mode 100644 generated/controllers/actuators/fan_control_generated.h create mode 100644 generated/controllers/actuators/fuel_pump_control_generated.h create mode 100644 generated/controllers/actuators/idle_state_generated.h create mode 100644 generated/controllers/actuators/main_relay_generated.h create mode 100644 generated/controllers/actuators/vvt_generated.h create mode 100644 generated/controllers/algo/antilag_system_state_generated.h create mode 100644 generated/controllers/algo/engine_state_generated.h create mode 100644 generated/controllers/algo/fuel/fuel_computer_generated.h create mode 100644 generated/controllers/algo/fuel/injector_model_generated.h create mode 100644 generated/controllers/algo/ignition_state_generated.h create mode 100644 generated/controllers/algo/launch_control_state_generated.h create mode 100644 generated/controllers/algo/tps_accel_state_generated.h create mode 100644 generated/controllers/algo/wall_fuel_state_generated.h create mode 100644 generated/controllers/engine_cycle/high_pressure_fuel_pump_generated.h create mode 100644 generated/controllers/engine_cycle/knock_controller_generated.h create mode 100644 generated/controllers/math/lambda_monitor_generated.h create mode 100644 generated/controllers/math/throttle_model_generated.h create mode 100644 generated/controllers/sensors/sent_state_generated.h create mode 100644 generated/controllers/sensors/wideband_state_generated.h create mode 100644 generated/controllers/tcu/tcu_controller_generated.h create mode 100644 generated/controllers/trigger/trigger_central_generated.h create mode 100644 generated/controllers/trigger/trigger_state_generated.h create mode 100644 generated/controllers/trigger/trigger_state_primary_generated.h diff --git a/generated/console/binary/output_channels_generated.h b/generated/console/binary/output_channels_generated.h new file mode 100644 index 0000000..a80ac5f --- /dev/null +++ b/generated/console/binary/output_channels_generated.h @@ -0,0 +1,1280 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) console/binary/output_channels.txt Tue Mar 05 17:17:33 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of pid_status_s +struct pid_status_s { + /** + * offset 0 + */ + float pTerm = (float)0; + /** + * offset 4 + */ + scaled_channel iTerm = (int16_t)0; + /** + * offset 6 + */ + scaled_channel dTerm = (int16_t)0; + /** + * offset 8 + */ + scaled_channel output = (int16_t)0; + /** + * offset 10 + */ + scaled_channel error = (int16_t)0; + /** + * offset 12 + */ + uint32_t resetCounter = (uint32_t)0; +}; +static_assert(sizeof(pid_status_s) == 16); + +// start of output_channels_s +struct output_channels_s { + /** + * SD: Present + offset 0 bit 0 */ + bool sd_present : 1 {}; + /** + * SD: Logging + offset 0 bit 1 */ + bool sd_logging_internal : 1 {}; + /** + offset 0 bit 2 */ + bool triggerScopeReady : 1 {}; + /** + offset 0 bit 3 */ + bool antilagTriggered : 1 {}; + /** + * Radiator Fan + offset 0 bit 4 */ + bool isFanOn : 1 {}; + /** + offset 0 bit 5 */ + bool isO2HeaterOn : 1 {}; + /** + offset 0 bit 6 */ + bool checkEngine : 1 {}; + /** + offset 0 bit 7 */ + bool needBurn : 1 {}; + /** + * SD: MSD + offset 0 bit 8 */ + bool sd_msd : 1 {}; + /** + * Radiator Fan 2 + offset 0 bit 9 */ + bool isFan2On : 1 {}; + /** + * Tooth Logger Ready + offset 0 bit 10 */ + bool toothLogReady : 1 {}; + /** + * Error: TPS + offset 0 bit 11 */ + bool isTpsError : 1 {}; + /** + * Error: CLT + offset 0 bit 12 */ + bool isCltError : 1 {}; + /** + * Error: MAP + offset 0 bit 13 */ + bool isMapError : 1 {}; + /** + * Error: IAT + offset 0 bit 14 */ + bool isIatError : 1 {}; + /** + * Error: Trigger + offset 0 bit 15 */ + bool isTriggerError : 1 {}; + /** + * Error: Active + offset 0 bit 16 */ + bool hasCriticalError : 1 {}; + /** + * Warning: Active + offset 0 bit 17 */ + bool isWarnNow : 1 {}; + /** + * Error: Pedal + offset 0 bit 18 */ + bool isPedalError : 1 {}; + /** + offset 0 bit 19 */ + bool isKnockChipOk : 1 {}; + /** + * Launch Control Triggered + offset 0 bit 20 */ + bool launchTriggered : 1 {}; + /** + * Error: TPS2 + offset 0 bit 21 */ + bool isTps2Error : 1 {}; + /** + * Injector Fault + offset 0 bit 22 */ + bool injectorFault : 1 {}; + /** + * Ignition Fault + offset 0 bit 23 */ + bool ignitionFault : 1 {}; + /** + offset 0 bit 24 */ + bool isMainRelayOn : 1 {}; + /** + * isUsbConnected + * Original reason for this is to check if USB is connected from Lua + offset 0 bit 25 */ + bool isUsbConnected : 1 {}; + /** + offset 0 bit 26 */ + bool dfcoActive : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_27_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_27_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_27_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_27_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_27_31 : 1 {}; + /** + * @@GAUGE_NAME_RPM@@ + * units: RPM + * offset 4 + */ + uint16_t RPMValue = (uint16_t)0; + /** + * dRPM + * units: RPM acceleration + * offset 6 + */ + int16_t rpmAcceleration = (int16_t)0; + /** + * @@GAUGE_NAME_GEAR_RATIO@@ + * units: value + * offset 8 + */ + scaled_channel speedToRpmRatio = (uint16_t)0; + /** + * @@GAUGE_NAME_VVS@@ + * units: kph + * offset 10 + */ + uint8_t unusedVehicleSpeedKph = (uint8_t)0; + /** + * @@GAUGE_NAME_CPU_TEMP@@ + * units: deg C + * offset 11 + */ + int8_t internalMcuTemperature = (int8_t)0; + /** + * @@GAUGE_NAME_CLT@@ + * units: deg C + * offset 12 + */ + scaled_channel coolant = (int16_t)0; + /** + * @@GAUGE_NAME_IAT@@ + * units: deg C + * offset 14 + */ + scaled_channel intake = (int16_t)0; + /** + * units: deg C + * offset 16 + */ + scaled_channel auxTemp1 = (int16_t)0; + /** + * units: deg C + * offset 18 + */ + scaled_channel auxTemp2 = (int16_t)0; + /** + * @@GAUGE_NAME_TPS@@ + * units: % + * offset 20 + */ + scaled_channel TPSValue = (int16_t)0; + /** + * @@GAUGE_NAME_THROTTLE_PEDAL@@ + * units: % + * offset 22 + */ + scaled_channel throttlePedalPosition = (int16_t)0; + /** + * units: ADC + * offset 24 + */ + uint16_t tpsADC = (uint16_t)0; + /** + * units: V + * offset 26 + */ + scaled_channel rawMaf = (uint16_t)0; + /** + * @@GAUGE_NAME_AIR_FLOW_MEASURED@@ + * units: kg/h + * offset 28 + */ + scaled_channel mafMeasured = (uint16_t)0; + /** + * @@GAUGE_NAME_MAP@@ + * units: kPa + * offset 30 + */ + scaled_channel MAPValue = (uint16_t)0; + /** + * units: kPa + * offset 32 + */ + scaled_channel baroPressure = (uint16_t)0; + /** + * @@GAUGE_NAME_LAMBDA@@ + * offset 34 + */ + scaled_channel lambdaValue = (uint16_t)0; + /** + * @@GAUGE_NAME_VBAT@@ + * units: V + * offset 36 + */ + scaled_channel VBatt = (uint16_t)0; + /** + * @@GAUGE_NAME_OIL_PRESSURE@@ + * units: kPa + * offset 38 + */ + scaled_channel oilPressure = (uint16_t)0; + /** + * @@GAUGE_NAME_VVT_B1I@@ + * units: deg + * offset 40 + */ + scaled_channel vvtPositionB1I = (int16_t)0; + /** + * @@GAUGE_NAME_FUEL_LAST_INJECTION@@ + * Actual last injection time - including all compensation and injection mode + * units: ms + * offset 42 + */ + scaled_channel actualLastInjection = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_INJ_DUTY@@ + * units: % + * offset 44 + */ + scaled_channel injectorDutyCycle = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 45 + */ + uint8_t alignmentFill_at_45[1]; + /** + * @@GAUGE_NAME_FUEL_INJECTION_TIMING@@ + * units: deg + * offset 46 + */ + int16_t injectionOffset = (int16_t)0; + /** + * @@GAUGE_NAME_ENGINE_CRC16@@ + * units: crc16 + * offset 48 + */ + uint16_t engineMakeCodeNameCrc16 = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_WALL_AMOUNT@@ + * units: mg + * offset 50 + */ + scaled_channel wallFuelAmount = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_WALL_CORRECTION@@ + * units: mg + * offset 52 + */ + scaled_channel wallFuelCorrectionValue = (int16_t)0; + /** + * offset 54 + */ + uint16_t revolutionCounterSinceStart = (uint16_t)0; + /** + * @@GAUGE_NAME_CAN_READ_OK@@ + * offset 56 + */ + uint16_t canReadCounter = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_TPS_EXTRA@@ + * units: ms + * offset 58 + */ + scaled_channel tpsAccelFuel = (int16_t)0; + /** + * @@GAUGE_NAME_IGNITION_MODE@@ + * offset 60 + */ + uint8_t currentIgnitionMode = (uint8_t)0; + /** + * @@GAUGE_NAME_INJECTION_MODE@@ + * offset 61 + */ + uint8_t currentInjectionMode = (uint8_t)0; + /** + * @@GAUGE_NAME_DWELL_DUTY@@ + * units: % + * offset 62 + */ + scaled_channel coilDutyCycle = (uint16_t)0; + /** + * ETB Target + * units: % + * offset 64 + */ + scaled_channel etbTarget = (int16_t)0; + /** + * @@GAUGE_NAME_ETB_DUTY@@ + * units: % + * offset 66 + */ + scaled_channel etb1DutyCycle = (int16_t)0; + /** + * Fuel level + * units: % + * offset 68 + */ + scaled_channel fuelTankLevel = (int16_t)0; + /** + * @@GAUGE_NAME_FUEL_CONSUMPTION@@ + * units: grams + * offset 70 + */ + uint16_t totalFuelConsumption = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_FLOW@@ + * units: gram/s + * offset 72 + */ + scaled_channel fuelFlowRate = (uint16_t)0; + /** + * @@GAUGE_NAME_TPS2@@ + * units: % + * offset 74 + */ + scaled_channel TPS2Value = (int16_t)0; + /** + * @@GAUGE_NAME_TUNE_CRC16@@ + * units: crc16 + * offset 76 + */ + uint16_t tuneCrc16 = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_VE@@ + * units: ratio + * offset 78 + */ + scaled_channel veValue = (uint16_t)0; + /** + * @@GAUGE_NAME_UPTIME@@ + * units: sec + * offset 80 + */ + uint32_t seconds = (uint32_t)0; + /** + * Engine Mode + * units: em + * offset 84 + */ + uint32_t engineMode = (uint32_t)0; + /** + * @@GAUGE_NAME_VERSION@@ + * units: version_f + * offset 88 + */ + uint32_t firmwareVersion = (uint32_t)0; + /** + * units: V + * offset 92 + */ + scaled_channel rawIdlePositionSensor = (int16_t)0; + /** + * units: V + * offset 94 + */ + scaled_channel rawWastegatePosition = (int16_t)0; + /** + * @@GAUGE_NAME_ACCEL_LAT@@ + * units: G + * offset 96 + */ + scaled_channel accelerationLat = (int16_t)0; + /** + * @@GAUGE_NAME_ACCEL_LON@@ + * units: G + * offset 98 + */ + scaled_channel accelerationLon = (int16_t)0; + /** + * @@GAUGE_NAME_DETECTED_GEAR@@ + * offset 100 + */ + uint8_t detectedGear = (uint8_t)0; + /** + * offset 101 + */ + uint8_t maxTriggerReentrant = (uint8_t)0; + /** + * units: V + * offset 102 + */ + scaled_channel rawLowFuelPressure = (int16_t)0; + /** + * units: V + * offset 104 + */ + scaled_channel rawHighFuelPressure = (int16_t)0; + /** + * @@GAUGE_NAME_FUEL_PRESSURE_LOW@@ + * units: kpa + * offset 106 + */ + scaled_channel lowFuelPressure = (int16_t)0; + /** + * @@GAUGE_NAME_DESIRED_GEAR@@ + * units: gear + * offset 108 + */ + int8_t tcuDesiredGear = (int8_t)0; + /** + * @@GAUGE_NAME_FLEX@@ + * units: % + * offset 109 + */ + scaled_channel flexPercent = (uint8_t)0; + /** + * @@GAUGE_NAME_WG_POSITION@@ + * units: % + * offset 110 + */ + scaled_channel wastegatePositionSensor = (int16_t)0; + /** + * @@GAUGE_NAME_FUEL_PRESSURE_HIGH@@ + * units: bar + * offset 112 + */ + scaled_channel highFuelPressure = (int16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 114 + */ + uint8_t alignmentFill_at_114[2]; + /** + * offset 116 + */ + float calibrationValue = (float)0; + /** + * offset 120 + */ + uint8_t calibrationMode = (uint8_t)0; + /** + * Idle: Stepper target position + * offset 121 + */ + uint8_t idleStepperTargetPosition = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 122 + */ + uint8_t alignmentFill_at_122[2]; + /** + * offset 124 + */ + uint32_t tsConfigVersion = (uint32_t)0; + /** + * @@GAUGE_NAME_TRG_ERR@@ + * units: counter + * offset 128 + */ + uint32_t totalTriggerErrorCounter = (uint32_t)0; + /** + * offset 132 + */ + uint32_t orderingErrorCounter = (uint32_t)0; + /** + * @@GAUGE_NAME_WARNING_COUNTER@@ + * units: count + * offset 136 + */ + uint16_t warningCounter = (uint16_t)0; + /** + * @@GAUGE_NAME_WARNING_LAST@@ + * units: error + * offset 138 + */ + uint16_t lastErrorCode = (uint16_t)0; + /** + * units: error + * offset 140 + */ + uint16_t recentErrorCode[8]; + /** + * units: val + * offset 156 + */ + float debugFloatField1 = (float)0; + /** + * units: val + * offset 160 + */ + float debugFloatField2 = (float)0; + /** + * units: val + * offset 164 + */ + float debugFloatField3 = (float)0; + /** + * units: val + * offset 168 + */ + float debugFloatField4 = (float)0; + /** + * units: val + * offset 172 + */ + float debugFloatField5 = (float)0; + /** + * units: val + * offset 176 + */ + float debugFloatField6 = (float)0; + /** + * units: val + * offset 180 + */ + float debugFloatField7 = (float)0; + /** + * units: val + * offset 184 + */ + uint32_t debugIntField1 = (uint32_t)0; + /** + * units: val + * offset 188 + */ + uint32_t debugIntField2 = (uint32_t)0; + /** + * units: val + * offset 192 + */ + uint32_t debugIntField3 = (uint32_t)0; + /** + * units: val + * offset 196 + */ + int16_t debugIntField4 = (int16_t)0; + /** + * units: val + * offset 198 + */ + int16_t debugIntField5 = (int16_t)0; + /** + * EGT + * units: deg C + * offset 200 + */ + uint16_t egt[EGT_CHANNEL_COUNT]; + /** + * units: V + * offset 216 + */ + scaled_channel rawTps1Primary = (int16_t)0; + /** + * units: V + * offset 218 + */ + scaled_channel rawPpsPrimary = (int16_t)0; + /** + * units: V + * offset 220 + */ + scaled_channel rawClt = (int16_t)0; + /** + * units: V + * offset 222 + */ + scaled_channel rawIat = (int16_t)0; + /** + * units: V + * offset 224 + */ + scaled_channel rawOilPressure = (int16_t)0; + /** + * offset 226 + */ + uint8_t fuelClosedLoopBinIdx = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 227 + */ + uint8_t alignmentFill_at_227[1]; + /** + * units: V + * offset 228 + */ + scaled_channel rawPpsSecondary = (int16_t)0; + /** + * @@GAUGE_NAME_IDLE_POSITION@@ + * units: % + * offset 230 + */ + scaled_channel idlePositionSensor = (int16_t)0; + /** + * @@GAUGE_NAME_AFR@@ + * units: AFR + * offset 232 + */ + scaled_channel AFRValue = (uint16_t)0; + /** + * Vss Accel + * units: m/s2 + * offset 234 + */ + scaled_channel VssAcceleration = (uint16_t)0; + /** + * @@GAUGE_NAME_LAMBDA2@@ + * offset 236 + */ + scaled_channel lambdaValue2 = (uint16_t)0; + /** + * @@GAUGE_NAME_AFR2@@ + * units: AFR + * offset 238 + */ + scaled_channel AFRValue2 = (uint16_t)0; + /** + * @@GAUGE_NAME_VVT_B1E@@ + * units: deg + * offset 240 + */ + scaled_channel vvtPositionB1E = (int16_t)0; + /** + * @@GAUGE_NAME_VVT_B2I@@ + * units: deg + * offset 242 + */ + scaled_channel vvtPositionB2I = (int16_t)0; + /** + * @@GAUGE_NAME_VVT_B2E@@ + * units: deg + * offset 244 + */ + scaled_channel vvtPositionB2E = (int16_t)0; + /** + * Fuel: Trim bank + * units: % + * offset 246 + */ + scaled_channel fuelPidCorrection[2]; + /** + * units: V + * offset 250 + */ + scaled_channel rawTps1Secondary = (int16_t)0; + /** + * units: V + * offset 252 + */ + scaled_channel rawTps2Primary = (int16_t)0; + /** + * units: V + * offset 254 + */ + scaled_channel rawTps2Secondary = (int16_t)0; + /** + * @@GAUGE_NAME_ACCEL_VERT@@ + * units: G + * offset 256 + */ + scaled_channel accelerationVert = (int16_t)0; + /** + * @@GAUGE_NAME_GYRO_YAW@@ + * units: deg/sec + * offset 258 + */ + scaled_channel gyroYaw = (int16_t)0; + /** + * units: deg + * offset 260 + */ + int8_t vvtTargets[4]; + /** + * @@GAUGE_NAME_TURBO_SPEED@@ + * units: hz + * offset 264 + */ + uint16_t turboSpeed = (uint16_t)0; + /** + * Ign: Timing Cyl + * units: deg + * offset 266 + */ + scaled_channel ignitionAdvanceCyl[MAX_CYLINDER_COUNT]; + /** + * units: % + * offset 290 + */ + scaled_channel tps1Split = (int16_t)0; + /** + * units: % + * offset 292 + */ + scaled_channel tps2Split = (int16_t)0; + /** + * units: % + * offset 294 + */ + scaled_channel tps12Split = (int16_t)0; + /** + * units: % + * offset 296 + */ + scaled_channel accPedalSplit = (int16_t)0; + /** + * Ign: Cut Code + * units: code + * offset 298 + */ + int8_t sparkCutReason = (int8_t)0; + /** + * Fuel: Cut Code + * units: code + * offset 299 + */ + int8_t fuelCutReason = (int8_t)0; + /** + * @@GAUGE_NAME_AIR_FLOW_ESTIMATE@@ + * units: kg/h + * offset 300 + */ + scaled_channel mafEstimate = (uint16_t)0; + /** + * sync: instant RPM + * units: rpm + * offset 302 + */ + uint16_t instantRpm = (uint16_t)0; + /** + * units: V + * offset 304 + */ + scaled_channel rawMap = (uint16_t)0; + /** + * units: V + * offset 306 + */ + scaled_channel rawAfr = (uint16_t)0; + /** + * offset 308 + */ + float calibrationValue2 = (float)0; + /** + * Lua: Tick counter + * units: count + * offset 312 + */ + uint32_t luaInvocationCounter = (uint32_t)0; + /** + * Lua: Last tick duration + * units: nt + * offset 316 + */ + uint32_t luaLastCycleDuration = (uint32_t)0; + /** + * offset 320 + */ + uint32_t vssEdgeCounter = (uint32_t)0; + /** + * offset 324 + */ + uint32_t issEdgeCounter = (uint32_t)0; + /** + * @@GAUGE_NAME_AUX_LINEAR_1@@ + * offset 328 + */ + scaled_channel auxLinear1 = (int16_t)0; + /** + * @@GAUGE_NAME_AUX_LINEAR_2@@ + * offset 330 + */ + scaled_channel auxLinear2 = (int16_t)0; + /** + * units: kPa + * offset 332 + */ + scaled_channel fallbackMap = (uint16_t)0; + /** + * Instant MAP + * units: kPa + * offset 334 + */ + scaled_channel instantMAPValue = (uint16_t)0; + /** + * units: us + * offset 336 + */ + uint16_t maxLockedDuration = (uint16_t)0; + /** + * @@GAUGE_NAME_CAN_WRITE_OK@@ + * offset 338 + */ + uint16_t canWriteOk = (uint16_t)0; + /** + * @@GAUGE_NAME_CAN_WRITE_ERR@@ + * offset 340 + */ + uint16_t canWriteNotOk = (uint16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 342 + */ + uint8_t alignmentFill_at_342[2]; + /** + * offset 344 + */ + uint32_t triggerPrimaryFall = (uint32_t)0; + /** + * offset 348 + */ + uint32_t triggerPrimaryRise = (uint32_t)0; + /** + * offset 352 + */ + uint32_t triggerSecondaryFall = (uint32_t)0; + /** + * offset 356 + */ + uint32_t triggerSecondaryRise = (uint32_t)0; + /** + * offset 360 + */ + uint16_t triggerVvtFall = (uint16_t)0; + /** + * offset 362 + */ + uint16_t triggerVvtRise = (uint16_t)0; + /** + * offset 364 + */ + uint16_t triggerVvt2Fall = (uint16_t)0; + /** + * offset 366 + */ + uint16_t triggerVvt2Rise = (uint16_t)0; + /** + * offset 368 + */ + uint8_t starterState = (uint8_t)0; + /** + * offset 369 + */ + uint8_t starterRelayDisable = (uint8_t)0; + /** + * Ign: Multispark count + * offset 370 + */ + uint8_t multiSparkCounter = (uint8_t)0; + /** + * offset 371 + */ + uint8_t extiOverflowCount = (uint8_t)0; + /** + * offset 372 + */ + pid_status_s alternatorStatus; + /** + * offset 388 + */ + pid_status_s idleStatus; + /** + * offset 404 + */ + pid_status_s etbStatus; + /** + * offset 420 + */ + pid_status_s boostStatus; + /** + * offset 436 + */ + pid_status_s wastegateDcStatus; + /** + * offset 452 + */ + pid_status_s vvtStatus[CAM_INPUTS_COUNT]; + /** + * Aux speed 1 + * units: s + * offset 516 + */ + uint16_t auxSpeed1 = (uint16_t)0; + /** + * Aux speed 2 + * units: s + * offset 518 + */ + uint16_t auxSpeed2 = (uint16_t)0; + /** + * @@GAUGE_NAME_ISS@@ + * units: RPM + * offset 520 + */ + uint16_t ISSValue = (uint16_t)0; + /** + * units: V + * offset 522 + */ + scaled_channel rawAnalogInput[LUA_ANALOG_INPUT_COUNT]; + /** + * GPPWM Output + * units: % + * offset 538 + */ + scaled_channel gppwmOutput[4]; + /** + * offset 542 + */ + scaled_channel gppwmXAxis[4]; + /** + * offset 550 + */ + scaled_channel gppwmYAxis[4]; + /** + * units: V + * offset 558 + */ + scaled_channel rawBattery = (int16_t)0; + /** + * offset 560 + */ + scaled_channel ignBlendParameter[IGN_BLEND_COUNT]; + /** + * units: % + * offset 568 + */ + scaled_channel ignBlendBias[IGN_BLEND_COUNT]; + /** + * units: deg + * offset 572 + */ + scaled_channel ignBlendOutput[IGN_BLEND_COUNT]; + /** + * offset 580 + */ + scaled_channel veBlendParameter[VE_BLEND_COUNT]; + /** + * units: % + * offset 588 + */ + scaled_channel veBlendBias[VE_BLEND_COUNT]; + /** + * units: % + * offset 592 + */ + scaled_channel veBlendOutput[VE_BLEND_COUNT]; + /** + * offset 600 + */ + scaled_channel boostOpenLoopBlendParameter[BOOST_BLEND_COUNT]; + /** + * units: % + * offset 604 + */ + scaled_channel boostOpenLoopBlendBias[BOOST_BLEND_COUNT]; + /** + * units: % + * offset 606 + */ + scaled_channel boostOpenLoopBlendOutput[BOOST_BLEND_COUNT]; + /** + * offset 608 + */ + scaled_channel boostClosedLoopBlendParameter[BOOST_BLEND_COUNT]; + /** + * units: % + * offset 612 + */ + scaled_channel boostClosedLoopBlendBias[BOOST_BLEND_COUNT]; + /** + * units: % + * offset 614 + */ + scaled_channel boostClosedLoopBlendOutput[BOOST_BLEND_COUNT]; + /** + * need 4 byte alignment + * units: units + * offset 618 + */ + uint8_t alignmentFill_at_618[2]; + /** + offset 620 bit 0 */ + bool coilState1 : 1 {}; + /** + offset 620 bit 1 */ + bool coilState2 : 1 {}; + /** + offset 620 bit 2 */ + bool coilState3 : 1 {}; + /** + offset 620 bit 3 */ + bool coilState4 : 1 {}; + /** + offset 620 bit 4 */ + bool coilState5 : 1 {}; + /** + offset 620 bit 5 */ + bool coilState6 : 1 {}; + /** + offset 620 bit 6 */ + bool coilState7 : 1 {}; + /** + offset 620 bit 7 */ + bool coilState8 : 1 {}; + /** + offset 620 bit 8 */ + bool coilState9 : 1 {}; + /** + offset 620 bit 9 */ + bool coilState10 : 1 {}; + /** + offset 620 bit 10 */ + bool coilState11 : 1 {}; + /** + offset 620 bit 11 */ + bool coilState12 : 1 {}; + /** + offset 620 bit 12 */ + bool injectorState1 : 1 {}; + /** + offset 620 bit 13 */ + bool injectorState2 : 1 {}; + /** + offset 620 bit 14 */ + bool injectorState3 : 1 {}; + /** + offset 620 bit 15 */ + bool injectorState4 : 1 {}; + /** + offset 620 bit 16 */ + bool injectorState5 : 1 {}; + /** + offset 620 bit 17 */ + bool injectorState6 : 1 {}; + /** + offset 620 bit 18 */ + bool injectorState7 : 1 {}; + /** + offset 620 bit 19 */ + bool injectorState8 : 1 {}; + /** + offset 620 bit 20 */ + bool injectorState9 : 1 {}; + /** + offset 620 bit 21 */ + bool injectorState10 : 1 {}; + /** + offset 620 bit 22 */ + bool injectorState11 : 1 {}; + /** + offset 620 bit 23 */ + bool injectorState12 : 1 {}; + /** + offset 620 bit 24 */ + bool triggerChannel1 : 1 {}; + /** + offset 620 bit 25 */ + bool triggerChannel2 : 1 {}; + /** + * bank 1 intake cam input + offset 620 bit 26 */ + bool vvtChannel1 : 1 {}; + /** + * bank 1 exhaust cam input + offset 620 bit 27 */ + bool vvtChannel2 : 1 {}; + /** + * bank 2 intake cam input + offset 620 bit 28 */ + bool vvtChannel3 : 1 {}; + /** + * bank 2 exhaust cam input + offset 620 bit 29 */ + bool vvtChannel4 : 1 {}; + /** + offset 620 bit 30 */ + bool unusedBit_230_30 : 1 {}; + /** + offset 620 bit 31 */ + bool unusedBit_230_31 : 1 {}; + /** + * offset 624 + */ + uint32_t outputRequestPeriod = (uint32_t)0; + /** + * offset 628 + */ + float mapFast = (float)0; + /** + * Lua: Gauge + * units: value + * offset 632 + */ + float luaGauges[LUA_GAUGE_COUNT]; + /** + * units: V + * offset 640 + */ + scaled_channel rawMaf2 = (uint16_t)0; + /** + * @@GAUGE_NAME_AIR_FLOW_MEASURED_2@@ + * units: kg/h + * offset 642 + */ + scaled_channel mafMeasured2 = (uint16_t)0; + /** + * offset 644 + */ + uint16_t schedulingUsedCount = (uint16_t)0; + /** + * @@GAUGE_NAME_VVS@@ + * units: kph + * offset 646 + */ + scaled_channel vehicleSpeedKph = (uint16_t)0; + /** + * units: % + * offset 648 + */ + scaled_channel Gego = (uint16_t)0; + /** + * units: count + * offset 650 + */ + uint16_t testBenchIter = (uint16_t)0; + /** + * units: deg C + * offset 652 + */ + scaled_channel oilTemp = (int16_t)0; + /** + * units: deg C + * offset 654 + */ + scaled_channel fuelTemp = (int16_t)0; + /** + * units: deg C + * offset 656 + */ + scaled_channel ambientTemp = (int16_t)0; + /** + * units: deg C + * offset 658 + */ + scaled_channel compressorDischargeTemp = (int16_t)0; + /** + * units: kPa + * offset 660 + */ + scaled_channel compressorDischargePressure = (uint16_t)0; + /** + * units: kPa + * offset 662 + */ + scaled_channel throttleInletPressure = (uint16_t)0; + /** + * units: sec + * offset 664 + */ + uint16_t ignitionOnTime = (uint16_t)0; + /** + * units: sec + * offset 666 + */ + uint16_t engineRunTime = (uint16_t)0; + /** + * units: km + * offset 668 + */ + scaled_channel distanceTraveled = (uint16_t)0; + /** + * @@GAUGE_NAME_AFR_GAS_SCALE@@ + * units: AFR + * offset 670 + */ + scaled_channel afrGasolineScale = (uint16_t)0; + /** + * @@GAUGE_NAME_AFR2_GAS_SCALE@@ + * units: AFR + * offset 672 + */ + scaled_channel afr2GasolineScale = (uint16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 674 + */ + uint8_t alignmentFill_at_674[2]; + /** + * offset 676 + */ + float wheelSlipRatio = (float)0; + /** + * offset 680 + */ + uint8_t ignitorDiagnostic[MAX_CYLINDER_COUNT]; + /** + * offset 692 + */ + uint8_t injectorDiagnostic[MAX_CYLINDER_COUNT]; + /** + * @@GAUGE_NAME_FUEL_LAST_INJECTION_STAGE_2@@ + * units: ms + * offset 704 + */ + scaled_channel actualLastInjectionStage2 = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_INJ_DUTY_STAGE_2@@ + * units: % + * offset 706 + */ + scaled_channel injectorDutyCycleStage2 = (uint8_t)0; + /** + * offset 707 + */ + uint8_t unusedAtTheEnd[88]; + /** + * need 4 byte alignment + * units: units + * offset 795 + */ + uint8_t alignmentFill_at_795[1]; +}; +static_assert(sizeof(output_channels_s) == 796); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) console/binary/output_channels.txt Tue Mar 05 17:17:33 UTC 2024 diff --git a/generated/controllers/actuators/ac_control_generated.h b/generated/controllers/actuators/ac_control_generated.h new file mode 100644 index 0000000..dba6aa4 --- /dev/null +++ b/generated/controllers/actuators/ac_control_generated.h @@ -0,0 +1,136 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/ac_control.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of ac_control_s +struct ac_control_s { + /** + * @@INDICATOR_NAME_AC_SWITCH@@ + * offset 0 + */ + int8_t acButtonState = (int8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 1 + */ + uint8_t alignmentFill_at_1[3]; + /** + * AC enabled + offset 4 bit 0 */ + bool m_acEnabled : 1 {}; + /** + * AC engine too slow + offset 4 bit 1 */ + bool engineTooSlow : 1 {}; + /** + * AC engine too fast + offset 4 bit 2 */ + bool engineTooFast : 1 {}; + /** + * AC no CLT + offset 4 bit 3 */ + bool noClt : 1 {}; + /** + * AC engine too hot + offset 4 bit 4 */ + bool engineTooHot : 1 {}; + /** + * AC tps too high + offset 4 bit 5 */ + bool tpsTooHigh : 1 {}; + /** + * AC disabled by Lua + offset 4 bit 6 */ + bool isDisabledByLua : 1 {}; + /** + * AC compressor on + offset 4 bit 7 */ + bool acCompressorState : 1 {}; + /** + offset 4 bit 8 */ + bool unusedBit_10_8 : 1 {}; + /** + offset 4 bit 9 */ + bool unusedBit_10_9 : 1 {}; + /** + offset 4 bit 10 */ + bool unusedBit_10_10 : 1 {}; + /** + offset 4 bit 11 */ + bool unusedBit_10_11 : 1 {}; + /** + offset 4 bit 12 */ + bool unusedBit_10_12 : 1 {}; + /** + offset 4 bit 13 */ + bool unusedBit_10_13 : 1 {}; + /** + offset 4 bit 14 */ + bool unusedBit_10_14 : 1 {}; + /** + offset 4 bit 15 */ + bool unusedBit_10_15 : 1 {}; + /** + offset 4 bit 16 */ + bool unusedBit_10_16 : 1 {}; + /** + offset 4 bit 17 */ + bool unusedBit_10_17 : 1 {}; + /** + offset 4 bit 18 */ + bool unusedBit_10_18 : 1 {}; + /** + offset 4 bit 19 */ + bool unusedBit_10_19 : 1 {}; + /** + offset 4 bit 20 */ + bool unusedBit_10_20 : 1 {}; + /** + offset 4 bit 21 */ + bool unusedBit_10_21 : 1 {}; + /** + offset 4 bit 22 */ + bool unusedBit_10_22 : 1 {}; + /** + offset 4 bit 23 */ + bool unusedBit_10_23 : 1 {}; + /** + offset 4 bit 24 */ + bool unusedBit_10_24 : 1 {}; + /** + offset 4 bit 25 */ + bool unusedBit_10_25 : 1 {}; + /** + offset 4 bit 26 */ + bool unusedBit_10_26 : 1 {}; + /** + offset 4 bit 27 */ + bool unusedBit_10_27 : 1 {}; + /** + offset 4 bit 28 */ + bool unusedBit_10_28 : 1 {}; + /** + offset 4 bit 29 */ + bool unusedBit_10_29 : 1 {}; + /** + offset 4 bit 30 */ + bool unusedBit_10_30 : 1 {}; + /** + offset 4 bit 31 */ + bool unusedBit_10_31 : 1 {}; + /** + * AC latest activity + * offset 8 + */ + int latest_usage_ac_control = (int)0; + /** + * offset 12 + */ + int acSwitchLastChangeTimeMs = (int)0; +}; +static_assert(sizeof(ac_control_s) == 16); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/ac_control.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/actuators/boost_control_generated.h b/generated/controllers/actuators/boost_control_generated.h new file mode 100644 index 0000000..39617ec --- /dev/null +++ b/generated/controllers/actuators/boost_control_generated.h @@ -0,0 +1,156 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/boost_control.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of boost_control_s +struct boost_control_s { + /** + offset 0 bit 0 */ + bool isTpsInvalid : 1 {}; + /** + offset 0 bit 1 */ + bool m_shouldResetPid : 1 {}; + /** + offset 0 bit 2 */ + bool isBelowClosedLoopThreshold : 1 {}; + /** + offset 0 bit 3 */ + bool isNotClosedLoop : 1 {}; + /** + offset 0 bit 4 */ + bool isZeroRpm : 1 {}; + /** + offset 0 bit 5 */ + bool hasInitBoost : 1 {}; + /** + offset 0 bit 6 */ + bool rpmTooLow : 1 {}; + /** + offset 0 bit 7 */ + bool tpsTooLow : 1 {}; + /** + offset 0 bit 8 */ + bool mapTooLow : 1 {}; + /** + offset 0 bit 9 */ + bool isPlantValid : 1 {}; + /** + offset 0 bit 10 */ + bool isBoostControlled : 1 {}; + /** + offset 0 bit 11 */ + bool unusedBit_11_11 : 1 {}; + /** + offset 0 bit 12 */ + bool unusedBit_11_12 : 1 {}; + /** + offset 0 bit 13 */ + bool unusedBit_11_13 : 1 {}; + /** + offset 0 bit 14 */ + bool unusedBit_11_14 : 1 {}; + /** + offset 0 bit 15 */ + bool unusedBit_11_15 : 1 {}; + /** + offset 0 bit 16 */ + bool unusedBit_11_16 : 1 {}; + /** + offset 0 bit 17 */ + bool unusedBit_11_17 : 1 {}; + /** + offset 0 bit 18 */ + bool unusedBit_11_18 : 1 {}; + /** + offset 0 bit 19 */ + bool unusedBit_11_19 : 1 {}; + /** + offset 0 bit 20 */ + bool unusedBit_11_20 : 1 {}; + /** + offset 0 bit 21 */ + bool unusedBit_11_21 : 1 {}; + /** + offset 0 bit 22 */ + bool unusedBit_11_22 : 1 {}; + /** + offset 0 bit 23 */ + bool unusedBit_11_23 : 1 {}; + /** + offset 0 bit 24 */ + bool unusedBit_11_24 : 1 {}; + /** + offset 0 bit 25 */ + bool unusedBit_11_25 : 1 {}; + /** + offset 0 bit 26 */ + bool unusedBit_11_26 : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_11_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_11_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_11_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_11_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_11_31 : 1 {}; + /** + * "Boost: Lua target add" + * units: v + * offset 4 + */ + scaled_channel luaTargetAdd = (int16_t)0; + /** + * @@GAUGE_NAME_BOOST_OUTPUT@@ + * units: percent + * offset 6 + */ + scaled_channel boostOutput = (int16_t)0; + /** + * "Boost: Lua target mult" + * units: v + * offset 8 + */ + float luaTargetMult = (float)0; + /** + * @@GAUGE_NAME_BOOST_OPEN_LOOP@@ + * units: v + * offset 12 + */ + float openLoopPart = (float)0; + /** + * "Boost: Lua open loop add" + * units: v + * offset 16 + */ + float luaOpenLoopAdd = (float)0; + /** + * @@GAUGE_NAME_BOOST_CLOSED_LOOP@@ + * units: % + * offset 20 + */ + scaled_channel boostControllerClosedLoopPart = (int8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 21 + */ + uint8_t alignmentFill_at_21[1]; + /** + * @@GAUGE_NAME_BOOST_TARGET@@ + * units: kPa + * offset 22 + */ + scaled_channel boostControlTarget = (int16_t)0; +}; +static_assert(sizeof(boost_control_s) == 24); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/boost_control.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/actuators/dc_motors_generated.h b/generated/controllers/actuators/dc_motors_generated.h new file mode 100644 index 0000000..8a2ae29 --- /dev/null +++ b/generated/controllers/actuators/dc_motors_generated.h @@ -0,0 +1,126 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/dc_motors.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of dc_motors_s +struct dc_motors_s { + /** + * "DC: output0" + * units: per + * offset 0 + */ + float dcOutput0 = (float)0; + /** + * "DC: en0" + * units: per + * offset 4 + */ + uint8_t isEnabled0_int = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 5 + */ + uint8_t alignmentFill_at_5[3]; + /** + offset 8 bit 0 */ + bool isEnabled0 : 1 {}; + /** + offset 8 bit 1 */ + bool unusedBit_4_1 : 1 {}; + /** + offset 8 bit 2 */ + bool unusedBit_4_2 : 1 {}; + /** + offset 8 bit 3 */ + bool unusedBit_4_3 : 1 {}; + /** + offset 8 bit 4 */ + bool unusedBit_4_4 : 1 {}; + /** + offset 8 bit 5 */ + bool unusedBit_4_5 : 1 {}; + /** + offset 8 bit 6 */ + bool unusedBit_4_6 : 1 {}; + /** + offset 8 bit 7 */ + bool unusedBit_4_7 : 1 {}; + /** + offset 8 bit 8 */ + bool unusedBit_4_8 : 1 {}; + /** + offset 8 bit 9 */ + bool unusedBit_4_9 : 1 {}; + /** + offset 8 bit 10 */ + bool unusedBit_4_10 : 1 {}; + /** + offset 8 bit 11 */ + bool unusedBit_4_11 : 1 {}; + /** + offset 8 bit 12 */ + bool unusedBit_4_12 : 1 {}; + /** + offset 8 bit 13 */ + bool unusedBit_4_13 : 1 {}; + /** + offset 8 bit 14 */ + bool unusedBit_4_14 : 1 {}; + /** + offset 8 bit 15 */ + bool unusedBit_4_15 : 1 {}; + /** + offset 8 bit 16 */ + bool unusedBit_4_16 : 1 {}; + /** + offset 8 bit 17 */ + bool unusedBit_4_17 : 1 {}; + /** + offset 8 bit 18 */ + bool unusedBit_4_18 : 1 {}; + /** + offset 8 bit 19 */ + bool unusedBit_4_19 : 1 {}; + /** + offset 8 bit 20 */ + bool unusedBit_4_20 : 1 {}; + /** + offset 8 bit 21 */ + bool unusedBit_4_21 : 1 {}; + /** + offset 8 bit 22 */ + bool unusedBit_4_22 : 1 {}; + /** + offset 8 bit 23 */ + bool unusedBit_4_23 : 1 {}; + /** + offset 8 bit 24 */ + bool unusedBit_4_24 : 1 {}; + /** + offset 8 bit 25 */ + bool unusedBit_4_25 : 1 {}; + /** + offset 8 bit 26 */ + bool unusedBit_4_26 : 1 {}; + /** + offset 8 bit 27 */ + bool unusedBit_4_27 : 1 {}; + /** + offset 8 bit 28 */ + bool unusedBit_4_28 : 1 {}; + /** + offset 8 bit 29 */ + bool unusedBit_4_29 : 1 {}; + /** + offset 8 bit 30 */ + bool unusedBit_4_30 : 1 {}; + /** + offset 8 bit 31 */ + bool unusedBit_4_31 : 1 {}; +}; +static_assert(sizeof(dc_motors_s) == 12); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/dc_motors.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/actuators/electronic_throttle_generated.h b/generated/controllers/actuators/electronic_throttle_generated.h new file mode 100644 index 0000000..b680cab --- /dev/null +++ b/generated/controllers/actuators/electronic_throttle_generated.h @@ -0,0 +1,187 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/electronic_throttle.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of electronic_throttle_s +struct electronic_throttle_s { + /** + * "ETB: idlePosition" + * units: per + * offset 0 + */ + float idlePosition = (float)0; + /** + * "ETB: trim" + * offset 4 + */ + float trim = (float)0; + /** + * "ETB: luaAdjustment" + * units: per + * offset 8 + */ + float luaAdjustment = (float)0; + /** + * "DC: wastegatePosition" + * units: per + * offset 12 + */ + float m_wastegatePosition = (float)0; + /** + * offset 16 + */ + percent_t etbFeedForward = (percent_t)0; + /** + * offset 20 + */ + float etbIntegralError = (float)0; + /** + * units: % + * offset 24 + */ + float etbCurrentTarget = (float)0; + /** + * units: % + * offset 28 + */ + float etbCurrentAdjustedTarget = (float)0; + /** + offset 32 bit 0 */ + bool etbRevLimitActive : 1 {}; + /** + offset 32 bit 1 */ + bool jamDetected : 1 {}; + /** + offset 32 bit 2 */ + bool unusedBit_10_2 : 1 {}; + /** + offset 32 bit 3 */ + bool unusedBit_10_3 : 1 {}; + /** + offset 32 bit 4 */ + bool unusedBit_10_4 : 1 {}; + /** + offset 32 bit 5 */ + bool unusedBit_10_5 : 1 {}; + /** + offset 32 bit 6 */ + bool unusedBit_10_6 : 1 {}; + /** + offset 32 bit 7 */ + bool unusedBit_10_7 : 1 {}; + /** + offset 32 bit 8 */ + bool unusedBit_10_8 : 1 {}; + /** + offset 32 bit 9 */ + bool unusedBit_10_9 : 1 {}; + /** + offset 32 bit 10 */ + bool unusedBit_10_10 : 1 {}; + /** + offset 32 bit 11 */ + bool unusedBit_10_11 : 1 {}; + /** + offset 32 bit 12 */ + bool unusedBit_10_12 : 1 {}; + /** + offset 32 bit 13 */ + bool unusedBit_10_13 : 1 {}; + /** + offset 32 bit 14 */ + bool unusedBit_10_14 : 1 {}; + /** + offset 32 bit 15 */ + bool unusedBit_10_15 : 1 {}; + /** + offset 32 bit 16 */ + bool unusedBit_10_16 : 1 {}; + /** + offset 32 bit 17 */ + bool unusedBit_10_17 : 1 {}; + /** + offset 32 bit 18 */ + bool unusedBit_10_18 : 1 {}; + /** + offset 32 bit 19 */ + bool unusedBit_10_19 : 1 {}; + /** + offset 32 bit 20 */ + bool unusedBit_10_20 : 1 {}; + /** + offset 32 bit 21 */ + bool unusedBit_10_21 : 1 {}; + /** + offset 32 bit 22 */ + bool unusedBit_10_22 : 1 {}; + /** + offset 32 bit 23 */ + bool unusedBit_10_23 : 1 {}; + /** + offset 32 bit 24 */ + bool unusedBit_10_24 : 1 {}; + /** + offset 32 bit 25 */ + bool unusedBit_10_25 : 1 {}; + /** + offset 32 bit 26 */ + bool unusedBit_10_26 : 1 {}; + /** + offset 32 bit 27 */ + bool unusedBit_10_27 : 1 {}; + /** + offset 32 bit 28 */ + bool unusedBit_10_28 : 1 {}; + /** + offset 32 bit 29 */ + bool unusedBit_10_29 : 1 {}; + /** + offset 32 bit 30 */ + bool unusedBit_10_30 : 1 {}; + /** + offset 32 bit 31 */ + bool unusedBit_10_31 : 1 {}; + /** + * "ETB duty rate of change" + * units: per + * offset 36 + */ + float etbDutyRateOfChange = (float)0; + /** + * "ETB average duty" + * units: per + * offset 40 + */ + float etbDutyAverage = (float)0; + /** + * "ETB TPS error counter" + * units: count + * offset 44 + */ + uint16_t etbTpsErrorCounter = (uint16_t)0; + /** + * "ETB pedal error counter" + * units: count + * offset 46 + */ + uint16_t etbPpsErrorCounter = (uint16_t)0; + /** + * offset 48 + */ + int8_t etbErrorCode = (int8_t)0; + /** + * offset 49 + */ + int8_t tcEtbDrop = (int8_t)0; + /** + * ETB jam timer + * units: sec + * offset 50 + */ + scaled_channel jamTimer = (uint16_t)0; +}; +static_assert(sizeof(electronic_throttle_s) == 52); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/electronic_throttle.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/actuators/fan_control_generated.h b/generated/controllers/actuators/fan_control_generated.h new file mode 100644 index 0000000..f88e66c --- /dev/null +++ b/generated/controllers/actuators/fan_control_generated.h @@ -0,0 +1,108 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/fan_control.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of fan_control_s +struct fan_control_s { + /** + offset 0 bit 0 */ + bool cranking : 1 {}; + /** + offset 0 bit 1 */ + bool notRunning : 1 {}; + /** + offset 0 bit 2 */ + bool disabledWhileEngineStopped : 1 {}; + /** + offset 0 bit 3 */ + bool brokenClt : 1 {}; + /** + offset 0 bit 4 */ + bool enabledForAc : 1 {}; + /** + offset 0 bit 5 */ + bool hot : 1 {}; + /** + offset 0 bit 6 */ + bool cold : 1 {}; + /** + offset 0 bit 7 */ + bool disabledBySpeed : 1 {}; + /** + offset 0 bit 8 */ + bool unusedBit_8_8 : 1 {}; + /** + offset 0 bit 9 */ + bool unusedBit_8_9 : 1 {}; + /** + offset 0 bit 10 */ + bool unusedBit_8_10 : 1 {}; + /** + offset 0 bit 11 */ + bool unusedBit_8_11 : 1 {}; + /** + offset 0 bit 12 */ + bool unusedBit_8_12 : 1 {}; + /** + offset 0 bit 13 */ + bool unusedBit_8_13 : 1 {}; + /** + offset 0 bit 14 */ + bool unusedBit_8_14 : 1 {}; + /** + offset 0 bit 15 */ + bool unusedBit_8_15 : 1 {}; + /** + offset 0 bit 16 */ + bool unusedBit_8_16 : 1 {}; + /** + offset 0 bit 17 */ + bool unusedBit_8_17 : 1 {}; + /** + offset 0 bit 18 */ + bool unusedBit_8_18 : 1 {}; + /** + offset 0 bit 19 */ + bool unusedBit_8_19 : 1 {}; + /** + offset 0 bit 20 */ + bool unusedBit_8_20 : 1 {}; + /** + offset 0 bit 21 */ + bool unusedBit_8_21 : 1 {}; + /** + offset 0 bit 22 */ + bool unusedBit_8_22 : 1 {}; + /** + offset 0 bit 23 */ + bool unusedBit_8_23 : 1 {}; + /** + offset 0 bit 24 */ + bool unusedBit_8_24 : 1 {}; + /** + offset 0 bit 25 */ + bool unusedBit_8_25 : 1 {}; + /** + offset 0 bit 26 */ + bool unusedBit_8_26 : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_8_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_8_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_8_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_8_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_8_31 : 1 {}; +}; +static_assert(sizeof(fan_control_s) == 4); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/fan_control.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/actuators/fuel_pump_control_generated.h b/generated/controllers/actuators/fuel_pump_control_generated.h new file mode 100644 index 0000000..39c6fb3 --- /dev/null +++ b/generated/controllers/actuators/fuel_pump_control_generated.h @@ -0,0 +1,108 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/fuel_pump_control.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of fuel_pump_control_s +struct fuel_pump_control_s { + /** + offset 0 bit 0 */ + bool isPrime : 1 {}; + /** + offset 0 bit 1 */ + bool engineTurnedRecently : 1 {}; + /** + offset 0 bit 2 */ + bool isFuelPumpOn : 1 {}; + /** + offset 0 bit 3 */ + bool ignitionOn : 1 {}; + /** + offset 0 bit 4 */ + bool unusedBit_4_4 : 1 {}; + /** + offset 0 bit 5 */ + bool unusedBit_4_5 : 1 {}; + /** + offset 0 bit 6 */ + bool unusedBit_4_6 : 1 {}; + /** + offset 0 bit 7 */ + bool unusedBit_4_7 : 1 {}; + /** + offset 0 bit 8 */ + bool unusedBit_4_8 : 1 {}; + /** + offset 0 bit 9 */ + bool unusedBit_4_9 : 1 {}; + /** + offset 0 bit 10 */ + bool unusedBit_4_10 : 1 {}; + /** + offset 0 bit 11 */ + bool unusedBit_4_11 : 1 {}; + /** + offset 0 bit 12 */ + bool unusedBit_4_12 : 1 {}; + /** + offset 0 bit 13 */ + bool unusedBit_4_13 : 1 {}; + /** + offset 0 bit 14 */ + bool unusedBit_4_14 : 1 {}; + /** + offset 0 bit 15 */ + bool unusedBit_4_15 : 1 {}; + /** + offset 0 bit 16 */ + bool unusedBit_4_16 : 1 {}; + /** + offset 0 bit 17 */ + bool unusedBit_4_17 : 1 {}; + /** + offset 0 bit 18 */ + bool unusedBit_4_18 : 1 {}; + /** + offset 0 bit 19 */ + bool unusedBit_4_19 : 1 {}; + /** + offset 0 bit 20 */ + bool unusedBit_4_20 : 1 {}; + /** + offset 0 bit 21 */ + bool unusedBit_4_21 : 1 {}; + /** + offset 0 bit 22 */ + bool unusedBit_4_22 : 1 {}; + /** + offset 0 bit 23 */ + bool unusedBit_4_23 : 1 {}; + /** + offset 0 bit 24 */ + bool unusedBit_4_24 : 1 {}; + /** + offset 0 bit 25 */ + bool unusedBit_4_25 : 1 {}; + /** + offset 0 bit 26 */ + bool unusedBit_4_26 : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_4_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_4_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_4_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_4_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_4_31 : 1 {}; +}; +static_assert(sizeof(fuel_pump_control_s) == 4); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/fuel_pump_control.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/actuators/idle_state_generated.h b/generated/controllers/actuators/idle_state_generated.h new file mode 100644 index 0000000..cba0599 --- /dev/null +++ b/generated/controllers/actuators/idle_state_generated.h @@ -0,0 +1,181 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/idle_state.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of idle_state_s +struct idle_state_s { + /** + * offset 0 + */ + idle_state_e idleState = (idle_state_e)0; + /** + * @@GAUGE_NAME_IAC@@ + * units: % + * offset 4 + */ + percent_t currentIdlePosition = (percent_t)0; + /** + * "idle: base value + * current position without adjustments (iacByTpsTaper, afterCrankingIACtaperDuration)" + * offset 8 + */ + percent_t baseIdlePosition = (percent_t)0; + /** + * Idle: Closed loop + * offset 12 + */ + percent_t idleClosedLoop = (percent_t)0; + /** + * idle: iacByTpsTaper portion + * offset 16 + */ + percent_t iacByTpsTaper = (percent_t)0; + /** + * idle: throttlePedalUpState + * true in IDLE throttle pedal state, false if driver is touching the pedal + * todo: better name for this field? + * offset 20 + */ + int throttlePedalUpState = (int)0; + /** + * idle: mightResetPid + * The idea of 'mightResetPid' is to reset PID only once - each time when TPS > idlePidDeactivationTpsThreshold. + * The throttle pedal can be pressed for a long time, making the PID data obsolete (thus the reset is required). + * We set 'mightResetPid' to true only if PID was actually used (i.e. idlePid.getOutput() was called) to save some CPU resources. + * See automaticIdleController(). + offset 24 bit 0 */ + bool mightResetPid : 1 {}; + /** + * Idle: shouldResetPid + offset 24 bit 1 */ + bool shouldResetPid : 1 {}; + /** + * Idle: wasResetPid + * This is needed to slowly turn on the PID back after it was reset. + offset 24 bit 2 */ + bool wasResetPid : 1 {}; + /** + * Idle: mustResetPid + * This is used when the PID configuration is changed, to guarantee the reset + offset 24 bit 3 */ + bool mustResetPid : 1 {}; + /** + * Idle: cranking + offset 24 bit 4 */ + bool isCranking : 1 {}; + /** + offset 24 bit 5 */ + bool isIacTableForCoasting : 1 {}; + /** + offset 24 bit 6 */ + bool notIdling : 1 {}; + /** + * Idle: reset + offset 24 bit 7 */ + bool needReset : 1 {}; + /** + * Idle: dead zone + offset 24 bit 8 */ + bool isInDeadZone : 1 {}; + /** + offset 24 bit 9 */ + bool isBlipping : 1 {}; + /** + offset 24 bit 10 */ + bool useClosedLoop : 1 {}; + /** + offset 24 bit 11 */ + bool badTps : 1 {}; + /** + offset 24 bit 12 */ + bool looksLikeRunning : 1 {}; + /** + offset 24 bit 13 */ + bool looksLikeCoasting : 1 {}; + /** + offset 24 bit 14 */ + bool looksLikeCrankToIdle : 1 {}; + /** + * Idle: coasting + offset 24 bit 15 */ + bool isIdleCoasting : 1 {}; + /** + * Idle: Closed loop active + offset 24 bit 16 */ + bool isIdleClosedLoop : 1 {}; + /** + offset 24 bit 17 */ + bool unusedBit_23_17 : 1 {}; + /** + offset 24 bit 18 */ + bool unusedBit_23_18 : 1 {}; + /** + offset 24 bit 19 */ + bool unusedBit_23_19 : 1 {}; + /** + offset 24 bit 20 */ + bool unusedBit_23_20 : 1 {}; + /** + offset 24 bit 21 */ + bool unusedBit_23_21 : 1 {}; + /** + offset 24 bit 22 */ + bool unusedBit_23_22 : 1 {}; + /** + offset 24 bit 23 */ + bool unusedBit_23_23 : 1 {}; + /** + offset 24 bit 24 */ + bool unusedBit_23_24 : 1 {}; + /** + offset 24 bit 25 */ + bool unusedBit_23_25 : 1 {}; + /** + offset 24 bit 26 */ + bool unusedBit_23_26 : 1 {}; + /** + offset 24 bit 27 */ + bool unusedBit_23_27 : 1 {}; + /** + offset 24 bit 28 */ + bool unusedBit_23_28 : 1 {}; + /** + offset 24 bit 29 */ + bool unusedBit_23_29 : 1 {}; + /** + offset 24 bit 30 */ + bool unusedBit_23_30 : 1 {}; + /** + offset 24 bit 31 */ + bool unusedBit_23_31 : 1 {}; + /** + * Idle: Target RPM + * offset 28 + */ + int idleTarget = (int)0; + /** + * Idle: Target RPM base + * offset 32 + */ + int targetRpmByClt = (int)0; + /** + * Idle: Target A/C RPM + * offset 36 + */ + int targetRpmAc = (int)0; + /** + * idle: iacByRpmTaper portion + * offset 40 + */ + percent_t iacByRpmTaper = (percent_t)0; + /** + * idle: Lua Adder + * offset 44 + */ + percent_t luaAdd = (percent_t)0; +}; +static_assert(sizeof(idle_state_s) == 48); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/idle_state.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/actuators/main_relay_generated.h b/generated/controllers/actuators/main_relay_generated.h new file mode 100644 index 0000000..389cfee --- /dev/null +++ b/generated/controllers/actuators/main_relay_generated.h @@ -0,0 +1,108 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/main_relay.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of main_relay_s +struct main_relay_s { + /** + offset 0 bit 0 */ + bool isBenchTest : 1 {}; + /** + offset 0 bit 1 */ + bool hasIgnitionVoltage : 1 {}; + /** + offset 0 bit 2 */ + bool mainRelayState : 1 {}; + /** + offset 0 bit 3 */ + bool delayedShutoffRequested : 1 {}; + /** + offset 0 bit 4 */ + bool unusedBit_4_4 : 1 {}; + /** + offset 0 bit 5 */ + bool unusedBit_4_5 : 1 {}; + /** + offset 0 bit 6 */ + bool unusedBit_4_6 : 1 {}; + /** + offset 0 bit 7 */ + bool unusedBit_4_7 : 1 {}; + /** + offset 0 bit 8 */ + bool unusedBit_4_8 : 1 {}; + /** + offset 0 bit 9 */ + bool unusedBit_4_9 : 1 {}; + /** + offset 0 bit 10 */ + bool unusedBit_4_10 : 1 {}; + /** + offset 0 bit 11 */ + bool unusedBit_4_11 : 1 {}; + /** + offset 0 bit 12 */ + bool unusedBit_4_12 : 1 {}; + /** + offset 0 bit 13 */ + bool unusedBit_4_13 : 1 {}; + /** + offset 0 bit 14 */ + bool unusedBit_4_14 : 1 {}; + /** + offset 0 bit 15 */ + bool unusedBit_4_15 : 1 {}; + /** + offset 0 bit 16 */ + bool unusedBit_4_16 : 1 {}; + /** + offset 0 bit 17 */ + bool unusedBit_4_17 : 1 {}; + /** + offset 0 bit 18 */ + bool unusedBit_4_18 : 1 {}; + /** + offset 0 bit 19 */ + bool unusedBit_4_19 : 1 {}; + /** + offset 0 bit 20 */ + bool unusedBit_4_20 : 1 {}; + /** + offset 0 bit 21 */ + bool unusedBit_4_21 : 1 {}; + /** + offset 0 bit 22 */ + bool unusedBit_4_22 : 1 {}; + /** + offset 0 bit 23 */ + bool unusedBit_4_23 : 1 {}; + /** + offset 0 bit 24 */ + bool unusedBit_4_24 : 1 {}; + /** + offset 0 bit 25 */ + bool unusedBit_4_25 : 1 {}; + /** + offset 0 bit 26 */ + bool unusedBit_4_26 : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_4_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_4_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_4_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_4_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_4_31 : 1 {}; +}; +static_assert(sizeof(main_relay_s) == 4); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/main_relay.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/actuators/vvt_generated.h b/generated/controllers/actuators/vvt_generated.h new file mode 100644 index 0000000..7ad8751 --- /dev/null +++ b/generated/controllers/actuators/vvt_generated.h @@ -0,0 +1,28 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/vvt.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of vvt_s +struct vvt_s { + /** + * units: deg + * offset 0 + */ + scaled_channel vvtTarget = (uint16_t)0; + /** + * units: % + * offset 2 + */ + scaled_channel vvtOutput = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 3 + */ + uint8_t alignmentFill_at_3[1]; +}; +static_assert(sizeof(vvt_s) == 4); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/actuators/vvt.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/algo/antilag_system_state_generated.h b/generated/controllers/algo/antilag_system_state_generated.h new file mode 100644 index 0000000..cd3f717 --- /dev/null +++ b/generated/controllers/algo/antilag_system_state_generated.h @@ -0,0 +1,122 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/antilag_system_state.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of antilag_system_state_s +struct antilag_system_state_s { + /** + offset 0 bit 0 */ + bool isAntilagCondition : 1 {}; + /** + offset 0 bit 1 */ + bool ALSMinRPMCondition : 1 {}; + /** + offset 0 bit 2 */ + bool ALSMaxRPMCondition : 1 {}; + /** + offset 0 bit 3 */ + bool ALSMinCLTCondition : 1 {}; + /** + offset 0 bit 4 */ + bool ALSMaxCLTCondition : 1 {}; + /** + offset 0 bit 5 */ + bool ALSMaxThrottleIntentCondition : 1 {}; + /** + offset 0 bit 6 */ + bool isALSSwitchActivated : 1 {}; + /** + offset 0 bit 7 */ + bool ALSActivatePinState : 1 {}; + /** + offset 0 bit 8 */ + bool ALSSwitchCondition : 1 {}; + /** + offset 0 bit 9 */ + bool ALSTimerCondition : 1 {}; + /** + offset 0 bit 10 */ + bool unusedBit_10_10 : 1 {}; + /** + offset 0 bit 11 */ + bool unusedBit_10_11 : 1 {}; + /** + offset 0 bit 12 */ + bool unusedBit_10_12 : 1 {}; + /** + offset 0 bit 13 */ + bool unusedBit_10_13 : 1 {}; + /** + offset 0 bit 14 */ + bool unusedBit_10_14 : 1 {}; + /** + offset 0 bit 15 */ + bool unusedBit_10_15 : 1 {}; + /** + offset 0 bit 16 */ + bool unusedBit_10_16 : 1 {}; + /** + offset 0 bit 17 */ + bool unusedBit_10_17 : 1 {}; + /** + offset 0 bit 18 */ + bool unusedBit_10_18 : 1 {}; + /** + offset 0 bit 19 */ + bool unusedBit_10_19 : 1 {}; + /** + offset 0 bit 20 */ + bool unusedBit_10_20 : 1 {}; + /** + offset 0 bit 21 */ + bool unusedBit_10_21 : 1 {}; + /** + offset 0 bit 22 */ + bool unusedBit_10_22 : 1 {}; + /** + offset 0 bit 23 */ + bool unusedBit_10_23 : 1 {}; + /** + offset 0 bit 24 */ + bool unusedBit_10_24 : 1 {}; + /** + offset 0 bit 25 */ + bool unusedBit_10_25 : 1 {}; + /** + offset 0 bit 26 */ + bool unusedBit_10_26 : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_10_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_10_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_10_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_10_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_10_31 : 1 {}; + /** + * offset 4 + */ + float fuelALSCorrection = (float)0; + /** + * units: deg + * offset 8 + */ + scaled_channel timingALSCorrection = (int16_t)0; + /** + * units: deg + * offset 10 + */ + scaled_channel timingALSSkip = (int16_t)0; +}; +static_assert(sizeof(antilag_system_state_s) == 12); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/antilag_system_state.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/algo/engine_state_generated.h b/generated/controllers/algo/engine_state_generated.h new file mode 100644 index 0000000..af56ff0 --- /dev/null +++ b/generated/controllers/algo/engine_state_generated.h @@ -0,0 +1,402 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/engine_state.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of LuaAdjustments +struct LuaAdjustments { + /** + * Lua: Fuel add + * units: g + * offset 0 + */ + float fuelAdd = (float)0; + /** + * Lua: Fuel mult + * offset 4 + */ + float fuelMult = (float)0; + /** + offset 8 bit 0 */ + bool clutchUpState : 1 {}; + /** + offset 8 bit 1 */ + bool brakePedalState : 1 {}; + /** + offset 8 bit 2 */ + bool acRequestState : 1 {}; + /** + offset 8 bit 3 */ + bool luaDisableEtb : 1 {}; + /** + offset 8 bit 4 */ + bool luaIgnCut : 1 {}; + /** + offset 8 bit 5 */ + bool unusedBit_7_5 : 1 {}; + /** + offset 8 bit 6 */ + bool unusedBit_7_6 : 1 {}; + /** + offset 8 bit 7 */ + bool unusedBit_7_7 : 1 {}; + /** + offset 8 bit 8 */ + bool unusedBit_7_8 : 1 {}; + /** + offset 8 bit 9 */ + bool unusedBit_7_9 : 1 {}; + /** + offset 8 bit 10 */ + bool unusedBit_7_10 : 1 {}; + /** + offset 8 bit 11 */ + bool unusedBit_7_11 : 1 {}; + /** + offset 8 bit 12 */ + bool unusedBit_7_12 : 1 {}; + /** + offset 8 bit 13 */ + bool unusedBit_7_13 : 1 {}; + /** + offset 8 bit 14 */ + bool unusedBit_7_14 : 1 {}; + /** + offset 8 bit 15 */ + bool unusedBit_7_15 : 1 {}; + /** + offset 8 bit 16 */ + bool unusedBit_7_16 : 1 {}; + /** + offset 8 bit 17 */ + bool unusedBit_7_17 : 1 {}; + /** + offset 8 bit 18 */ + bool unusedBit_7_18 : 1 {}; + /** + offset 8 bit 19 */ + bool unusedBit_7_19 : 1 {}; + /** + offset 8 bit 20 */ + bool unusedBit_7_20 : 1 {}; + /** + offset 8 bit 21 */ + bool unusedBit_7_21 : 1 {}; + /** + offset 8 bit 22 */ + bool unusedBit_7_22 : 1 {}; + /** + offset 8 bit 23 */ + bool unusedBit_7_23 : 1 {}; + /** + offset 8 bit 24 */ + bool unusedBit_7_24 : 1 {}; + /** + offset 8 bit 25 */ + bool unusedBit_7_25 : 1 {}; + /** + offset 8 bit 26 */ + bool unusedBit_7_26 : 1 {}; + /** + offset 8 bit 27 */ + bool unusedBit_7_27 : 1 {}; + /** + offset 8 bit 28 */ + bool unusedBit_7_28 : 1 {}; + /** + offset 8 bit 29 */ + bool unusedBit_7_29 : 1 {}; + /** + offset 8 bit 30 */ + bool unusedBit_7_30 : 1 {}; + /** + offset 8 bit 31 */ + bool unusedBit_7_31 : 1 {}; +}; +static_assert(sizeof(LuaAdjustments) == 12); + +// start of speed_density_s +struct speed_density_s { + /** + * Air: Charge temperature estimate + * units: deg C + * offset 0 + */ + scaled_channel tCharge = (int16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 2 + */ + uint8_t alignmentFill_at_2[2]; + /** + * Air: Charge temperature estimate K + * offset 4 + */ + float tChargeK = (float)0; +}; +static_assert(sizeof(speed_density_s) == 8); + +// start of cranking_fuel_s +struct cranking_fuel_s { + /** + * Fuel: cranking CLT mult + * offset 0 + */ + float coolantTemperatureCoefficient = (float)0; + /** + * Fuel: cranking TPS mult + * offset 4 + */ + float tpsCoefficient = (float)0; + /** + * Fuel: cranking duration mult + * offset 8 + */ + float durationCoefficient = (float)0; + /** + * Fuel: Cranking cycle mass + * units: mg + * offset 12 + */ + scaled_channel fuel = (uint16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 14 + */ + uint8_t alignmentFill_at_14[2]; +}; +static_assert(sizeof(cranking_fuel_s) == 16); + +// start of engine_state_s +struct engine_state_s { + /** + * offset 0 + */ + LuaAdjustments lua; + /** + * offset 12 + */ + speed_density_s sd; + /** + * offset 20 + */ + cranking_fuel_s crankingFuel; + /** + * @@GAUGE_NAME_FUEL_BARO_CORR@@ + * offset 36 + */ + float baroCorrection = (float)0; + /** + * Detected Board ID + * units: id + * offset 40 + */ + int16_t hellenBoardId = (int16_t)0; + /** + * @@INDICATOR_NAME_CLUTCH_UP@@ + * offset 42 + */ + int8_t clutchUpState = (int8_t)0; + /** + * @@INDICATOR_NAME_CLUTCH_DOWN@@ + * offset 43 + */ + int8_t clutchDownState = (int8_t)0; + /** + * @@INDICATOR_NAME_BRAKE_DOWN@@ + * offset 44 + */ + int8_t brakePedalState = (int8_t)0; + /** + * offset 45 + */ + int8_t startStopState = (int8_t)0; + /** + * offset 46 + */ + int8_t smartChipState = (int8_t)0; + /** + * offset 47 + */ + int8_t smartChipRestartCounter = (int8_t)0; + /** + * offset 48 + */ + int8_t smartChipAliveCounter = (int8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 49 + */ + uint8_t alignmentFill_at_49[3]; + /** + offset 52 bit 0 */ + bool startStopPhysicalState : 1 {}; + /** + * Harley ACR Active + offset 52 bit 1 */ + bool acrActive : 1 {}; + /** + offset 52 bit 2 */ + bool acrEngineMovedRecently : 1 {}; + /** + offset 52 bit 3 */ + bool heaterControlEnabled : 1 {}; + /** + offset 52 bit 4 */ + bool luaDigitalState0 : 1 {}; + /** + offset 52 bit 5 */ + bool luaDigitalState1 : 1 {}; + /** + offset 52 bit 6 */ + bool luaDigitalState2 : 1 {}; + /** + offset 52 bit 7 */ + bool luaDigitalState3 : 1 {}; + /** + offset 52 bit 8 */ + bool unusedBit_21_8 : 1 {}; + /** + offset 52 bit 9 */ + bool unusedBit_21_9 : 1 {}; + /** + offset 52 bit 10 */ + bool unusedBit_21_10 : 1 {}; + /** + offset 52 bit 11 */ + bool unusedBit_21_11 : 1 {}; + /** + offset 52 bit 12 */ + bool unusedBit_21_12 : 1 {}; + /** + offset 52 bit 13 */ + bool unusedBit_21_13 : 1 {}; + /** + offset 52 bit 14 */ + bool unusedBit_21_14 : 1 {}; + /** + offset 52 bit 15 */ + bool unusedBit_21_15 : 1 {}; + /** + offset 52 bit 16 */ + bool unusedBit_21_16 : 1 {}; + /** + offset 52 bit 17 */ + bool unusedBit_21_17 : 1 {}; + /** + offset 52 bit 18 */ + bool unusedBit_21_18 : 1 {}; + /** + offset 52 bit 19 */ + bool unusedBit_21_19 : 1 {}; + /** + offset 52 bit 20 */ + bool unusedBit_21_20 : 1 {}; + /** + offset 52 bit 21 */ + bool unusedBit_21_21 : 1 {}; + /** + offset 52 bit 22 */ + bool unusedBit_21_22 : 1 {}; + /** + offset 52 bit 23 */ + bool unusedBit_21_23 : 1 {}; + /** + offset 52 bit 24 */ + bool unusedBit_21_24 : 1 {}; + /** + offset 52 bit 25 */ + bool unusedBit_21_25 : 1 {}; + /** + offset 52 bit 26 */ + bool unusedBit_21_26 : 1 {}; + /** + offset 52 bit 27 */ + bool unusedBit_21_27 : 1 {}; + /** + offset 52 bit 28 */ + bool unusedBit_21_28 : 1 {}; + /** + offset 52 bit 29 */ + bool unusedBit_21_29 : 1 {}; + /** + offset 52 bit 30 */ + bool unusedBit_21_30 : 1 {}; + /** + offset 52 bit 31 */ + bool unusedBit_21_31 : 1 {}; + /** + * offset 56 + */ + uint32_t startStopStateToggleCounter = (uint32_t)0; + /** + * offset 60 + */ + float egtValue1 = (float)0; + /** + * offset 64 + */ + float egtValue2 = (float)0; + /** + * offset 68 + */ + float luaSoftSparkSkip = (float)0; + /** + * offset 72 + */ + float luaHardSparkSkip = (float)0; + /** + * offset 76 + */ + float tractionControlSparkSkip = (float)0; + /** + * User-defined RPM hard limit + * units: rpm + * offset 80 + */ + int16_t desiredRpmLimit = (int16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 82 + */ + uint8_t alignmentFill_at_82[2]; + /** + * Fuel: Injection counter + * offset 84 + */ + uint32_t fuelInjectionCounter = (uint32_t)0; + /** + * Ign: Spark counter + * offset 88 + */ + uint32_t globalSparkCounter = (uint32_t)0; + /** + * @@GAUGE_NAME_FUEL_LOAD@@ + * offset 92 + */ + float fuelingLoad = (float)0; + /** + * @@GAUGE_NAME_IGNITION_LOAD@@ + * offset 96 + */ + float ignitionLoad = (float)0; + /** + * units: % + * offset 100 + */ + scaled_channel veTableYAxis = (uint16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 102 + */ + uint8_t alignmentFill_at_102[2]; +}; +static_assert(sizeof(engine_state_s) == 104); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/engine_state.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/algo/fuel/fuel_computer_generated.h b/generated/controllers/algo/fuel/fuel_computer_generated.h new file mode 100644 index 0000000..77a474c --- /dev/null +++ b/generated/controllers/algo/fuel/fuel_computer_generated.h @@ -0,0 +1,207 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/fuel/fuel_computer.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of running_fuel_s +struct running_fuel_s { + /** + * Fuel: Post cranking mult + * offset 0 + */ + float postCrankingFuelCorrection = (float)0; + /** + * @@GAUGE_NAME_FUEL_IAT_CORR@@ + * offset 4 + */ + float intakeTemperatureCoefficient = (float)0; + /** + * @@GAUGE_NAME_FUEL_CLT_CORR@@ + * offset 8 + */ + float coolantTemperatureCoefficient = (float)0; + /** + * units: secs + * offset 12 + */ + float timeSinceCrankingInSecs = (float)0; + /** + * @@GAUGE_NAME_FUEL_BASE@@ + * This is the raw value we take from the fuel map or base fuel algorithm, before the corrections + * units: mg + * offset 16 + */ + scaled_channel baseFuel = (uint16_t)0; + /** + * @@GAUGE_NAME_FUEL_RUNNING@@ + * Total fuel with CLT IAT and TPS acceleration without injector lag corrections per cycle, as pulse per cycle + * units: mg + * offset 18 + */ + scaled_channel fuel = (uint16_t)0; +}; +static_assert(sizeof(running_fuel_s) == 20); + +// start of fuel_computer_s +struct fuel_computer_s { + /** + * Fuel: Total correction + * units: mult + * offset 0 + */ + float totalFuelCorrection = (float)0; + /** + * offset 4 + */ + running_fuel_s running; + /** + * units: % + * offset 24 + */ + scaled_channel afrTableYAxis = (uint16_t)0; + /** + * @@GAUGE_NAME_TARGET_LAMBDA@@ + * offset 26 + */ + scaled_channel targetLambda = (uint16_t)0; + /** + * @@GAUGE_NAME_TARGET_AFR@@ + * units: ratio + * offset 28 + */ + scaled_channel targetAFR = (uint16_t)0; + /** + * Fuel: Stoich ratio + * units: ratio + * offset 30 + */ + scaled_channel stoichiometricRatio = (uint16_t)0; + /** + * offset 32 + */ + float sdTcharge_coff = (float)0; + /** + * @@GAUGE_NAME_AIR_MASS@@ + * units: g + * offset 36 + */ + float sdAirMassInOneCylinder = (float)0; + /** + * Air: Normalized cyl filling + * units: % + * offset 40 + */ + float normalizedCylinderFilling = (float)0; + /** + * offset 44 + */ + uint8_t brokenInjector = (uint8_t)0; + /** + * offset 45 + */ + uint8_t unused88 = (uint8_t)0; + /** + * offset 46 + */ + uint16_t idealEngineTorque = (uint16_t)0; + /** + offset 48 bit 0 */ + bool injectorHwIssue : 1 {}; + /** + offset 48 bit 1 */ + bool unusedBit_13_1 : 1 {}; + /** + offset 48 bit 2 */ + bool unusedBit_13_2 : 1 {}; + /** + offset 48 bit 3 */ + bool unusedBit_13_3 : 1 {}; + /** + offset 48 bit 4 */ + bool unusedBit_13_4 : 1 {}; + /** + offset 48 bit 5 */ + bool unusedBit_13_5 : 1 {}; + /** + offset 48 bit 6 */ + bool unusedBit_13_6 : 1 {}; + /** + offset 48 bit 7 */ + bool unusedBit_13_7 : 1 {}; + /** + offset 48 bit 8 */ + bool unusedBit_13_8 : 1 {}; + /** + offset 48 bit 9 */ + bool unusedBit_13_9 : 1 {}; + /** + offset 48 bit 10 */ + bool unusedBit_13_10 : 1 {}; + /** + offset 48 bit 11 */ + bool unusedBit_13_11 : 1 {}; + /** + offset 48 bit 12 */ + bool unusedBit_13_12 : 1 {}; + /** + offset 48 bit 13 */ + bool unusedBit_13_13 : 1 {}; + /** + offset 48 bit 14 */ + bool unusedBit_13_14 : 1 {}; + /** + offset 48 bit 15 */ + bool unusedBit_13_15 : 1 {}; + /** + offset 48 bit 16 */ + bool unusedBit_13_16 : 1 {}; + /** + offset 48 bit 17 */ + bool unusedBit_13_17 : 1 {}; + /** + offset 48 bit 18 */ + bool unusedBit_13_18 : 1 {}; + /** + offset 48 bit 19 */ + bool unusedBit_13_19 : 1 {}; + /** + offset 48 bit 20 */ + bool unusedBit_13_20 : 1 {}; + /** + offset 48 bit 21 */ + bool unusedBit_13_21 : 1 {}; + /** + offset 48 bit 22 */ + bool unusedBit_13_22 : 1 {}; + /** + offset 48 bit 23 */ + bool unusedBit_13_23 : 1 {}; + /** + offset 48 bit 24 */ + bool unusedBit_13_24 : 1 {}; + /** + offset 48 bit 25 */ + bool unusedBit_13_25 : 1 {}; + /** + offset 48 bit 26 */ + bool unusedBit_13_26 : 1 {}; + /** + offset 48 bit 27 */ + bool unusedBit_13_27 : 1 {}; + /** + offset 48 bit 28 */ + bool unusedBit_13_28 : 1 {}; + /** + offset 48 bit 29 */ + bool unusedBit_13_29 : 1 {}; + /** + offset 48 bit 30 */ + bool unusedBit_13_30 : 1 {}; + /** + offset 48 bit 31 */ + bool unusedBit_13_31 : 1 {}; +}; +static_assert(sizeof(fuel_computer_s) == 52); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/fuel/fuel_computer.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/algo/fuel/injector_model_generated.h b/generated/controllers/algo/fuel/injector_model_generated.h new file mode 100644 index 0000000..791a49e --- /dev/null +++ b/generated/controllers/algo/fuel/injector_model_generated.h @@ -0,0 +1,29 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/fuel/injector_model.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of injector_model_s +struct injector_model_s { + /** + * @@GAUGE_NAME_INJECTOR_LAG@@ + * units: ms + * offset 0 + */ + float m_deadtime = (float)0; + /** + * Fuel: Injector pressure delta + * units: kPa + * offset 4 + */ + float pressureDelta = (float)0; + /** + * Fuel: Injector pressure ratio + * offset 8 + */ + float pressureRatio = (float)0; +}; +static_assert(sizeof(injector_model_s) == 12); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/fuel/injector_model.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/algo/ignition_state_generated.h b/generated/controllers/algo/ignition_state_generated.h new file mode 100644 index 0000000..76075cd --- /dev/null +++ b/generated/controllers/algo/ignition_state_generated.h @@ -0,0 +1,183 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/ignition_state.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of ignition_state_s +struct ignition_state_s { + /** + * "Ignition: base dwell" + * units: ms + * offset 0 + */ + float baseDwell = (float)0; + /** + * @@GAUGE_COIL_DWELL_TIME@@ + * units: ms + * offset 4 + */ + floatms_t sparkDwell = (floatms_t)0; + /** + * Ignition: dwell duration + * as crankshaft angle + * NAN if engine is stopped + * See also sparkDwell + * units: deg + * offset 8 + */ + angle_t dwellDurationAngle = (angle_t)0; + /** + * Ign: CLT correction + * units: deg + * offset 12 + */ + scaled_channel cltTimingCorrection = (int16_t)0; + /** + * Ign: IAT correction + * units: deg + * offset 14 + */ + scaled_channel timingIatCorrection = (int16_t)0; + /** + * Idle: Timing adjustment + * units: deg + * offset 16 + */ + scaled_channel timingPidCorrection = (int16_t)0; + /** + * @@GAUGE_NAME_TIMING_ADVANCE@@ + * units: deg + * offset 18 + */ + scaled_channel baseIgnitionAdvance = (int16_t)0; + /** + * @@GAUGE_NAME_ADJUSTED_TIMING@@ + * units: deg + * offset 20 + */ + scaled_channel correctedIgnitionAdvance = (int16_t)0; + /** + * Traction: timing correction + * units: deg + * offset 22 + */ + scaled_channel tractionAdvanceDrop = (int16_t)0; + /** + * Ign: Dwell voltage correction + * offset 24 + */ + float dwellVoltageCorrection = (float)0; + /** + * Ign: Lua timing add + * units: deg + * offset 28 + */ + float luaTimingAdd = (float)0; + /** + * Ign: Lua timing mult + * units: deg + * offset 32 + */ + float luaTimingMult = (float)0; + /** + * Ign: Lua Spark Skip + offset 36 bit 0 */ + bool luaIgnitionSkip : 1 {}; + /** + offset 36 bit 1 */ + bool unusedBit_13_1 : 1 {}; + /** + offset 36 bit 2 */ + bool unusedBit_13_2 : 1 {}; + /** + offset 36 bit 3 */ + bool unusedBit_13_3 : 1 {}; + /** + offset 36 bit 4 */ + bool unusedBit_13_4 : 1 {}; + /** + offset 36 bit 5 */ + bool unusedBit_13_5 : 1 {}; + /** + offset 36 bit 6 */ + bool unusedBit_13_6 : 1 {}; + /** + offset 36 bit 7 */ + bool unusedBit_13_7 : 1 {}; + /** + offset 36 bit 8 */ + bool unusedBit_13_8 : 1 {}; + /** + offset 36 bit 9 */ + bool unusedBit_13_9 : 1 {}; + /** + offset 36 bit 10 */ + bool unusedBit_13_10 : 1 {}; + /** + offset 36 bit 11 */ + bool unusedBit_13_11 : 1 {}; + /** + offset 36 bit 12 */ + bool unusedBit_13_12 : 1 {}; + /** + offset 36 bit 13 */ + bool unusedBit_13_13 : 1 {}; + /** + offset 36 bit 14 */ + bool unusedBit_13_14 : 1 {}; + /** + offset 36 bit 15 */ + bool unusedBit_13_15 : 1 {}; + /** + offset 36 bit 16 */ + bool unusedBit_13_16 : 1 {}; + /** + offset 36 bit 17 */ + bool unusedBit_13_17 : 1 {}; + /** + offset 36 bit 18 */ + bool unusedBit_13_18 : 1 {}; + /** + offset 36 bit 19 */ + bool unusedBit_13_19 : 1 {}; + /** + offset 36 bit 20 */ + bool unusedBit_13_20 : 1 {}; + /** + offset 36 bit 21 */ + bool unusedBit_13_21 : 1 {}; + /** + offset 36 bit 22 */ + bool unusedBit_13_22 : 1 {}; + /** + offset 36 bit 23 */ + bool unusedBit_13_23 : 1 {}; + /** + offset 36 bit 24 */ + bool unusedBit_13_24 : 1 {}; + /** + offset 36 bit 25 */ + bool unusedBit_13_25 : 1 {}; + /** + offset 36 bit 26 */ + bool unusedBit_13_26 : 1 {}; + /** + offset 36 bit 27 */ + bool unusedBit_13_27 : 1 {}; + /** + offset 36 bit 28 */ + bool unusedBit_13_28 : 1 {}; + /** + offset 36 bit 29 */ + bool unusedBit_13_29 : 1 {}; + /** + offset 36 bit 30 */ + bool unusedBit_13_30 : 1 {}; + /** + offset 36 bit 31 */ + bool unusedBit_13_31 : 1 {}; +}; +static_assert(sizeof(ignition_state_s) == 40); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/ignition_state.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/algo/launch_control_state_generated.h b/generated/controllers/algo/launch_control_state_generated.h new file mode 100644 index 0000000..13f8279 --- /dev/null +++ b/generated/controllers/algo/launch_control_state_generated.h @@ -0,0 +1,112 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/launch_control_state.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of launch_control_state_s +struct launch_control_state_s { + /** + * offset 0 + */ + int retardThresholdRpm = (int)0; + /** + offset 4 bit 0 */ + bool combinedConditions : 1 {}; + /** + offset 4 bit 1 */ + bool launchActivatePinState : 1 {}; + /** + offset 4 bit 2 */ + bool isLaunchPreCondition : 1 {}; + /** + offset 4 bit 3 */ + bool isLaunchCondition : 1 {}; + /** + offset 4 bit 4 */ + bool isSwitchActivated : 1 {}; + /** + offset 4 bit 5 */ + bool isClutchActivated : 1 {}; + /** + offset 4 bit 6 */ + bool isValidInputPin : 1 {}; + /** + offset 4 bit 7 */ + bool activateSwitchCondition : 1 {}; + /** + offset 4 bit 8 */ + bool rpmCondition : 1 {}; + /** + offset 4 bit 9 */ + bool speedCondition : 1 {}; + /** + offset 4 bit 10 */ + bool tpsCondition : 1 {}; + /** + offset 4 bit 11 */ + bool unusedBit_12_11 : 1 {}; + /** + offset 4 bit 12 */ + bool unusedBit_12_12 : 1 {}; + /** + offset 4 bit 13 */ + bool unusedBit_12_13 : 1 {}; + /** + offset 4 bit 14 */ + bool unusedBit_12_14 : 1 {}; + /** + offset 4 bit 15 */ + bool unusedBit_12_15 : 1 {}; + /** + offset 4 bit 16 */ + bool unusedBit_12_16 : 1 {}; + /** + offset 4 bit 17 */ + bool unusedBit_12_17 : 1 {}; + /** + offset 4 bit 18 */ + bool unusedBit_12_18 : 1 {}; + /** + offset 4 bit 19 */ + bool unusedBit_12_19 : 1 {}; + /** + offset 4 bit 20 */ + bool unusedBit_12_20 : 1 {}; + /** + offset 4 bit 21 */ + bool unusedBit_12_21 : 1 {}; + /** + offset 4 bit 22 */ + bool unusedBit_12_22 : 1 {}; + /** + offset 4 bit 23 */ + bool unusedBit_12_23 : 1 {}; + /** + offset 4 bit 24 */ + bool unusedBit_12_24 : 1 {}; + /** + offset 4 bit 25 */ + bool unusedBit_12_25 : 1 {}; + /** + offset 4 bit 26 */ + bool unusedBit_12_26 : 1 {}; + /** + offset 4 bit 27 */ + bool unusedBit_12_27 : 1 {}; + /** + offset 4 bit 28 */ + bool unusedBit_12_28 : 1 {}; + /** + offset 4 bit 29 */ + bool unusedBit_12_29 : 1 {}; + /** + offset 4 bit 30 */ + bool unusedBit_12_30 : 1 {}; + /** + offset 4 bit 31 */ + bool unusedBit_12_31 : 1 {}; +}; +static_assert(sizeof(launch_control_state_s) == 8); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/launch_control_state.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/algo/tps_accel_state_generated.h b/generated/controllers/algo/tps_accel_state_generated.h new file mode 100644 index 0000000..318fd7b --- /dev/null +++ b/generated/controllers/algo/tps_accel_state_generated.h @@ -0,0 +1,159 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/tps_accel_state.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of tps_accel_state_s +struct tps_accel_state_s { + /** + * Fuel: TPS AE from + * offset 0 + */ + percent_t tpsFrom = (percent_t)0; + /** + * Fuel: TPS AE to + * offset 4 + */ + percent_t tpsTo = (percent_t)0; + /** + * Fuel: TPS AE change + * offset 8 + */ + percent_t deltaTps = (percent_t)0; + /** + * offset 12 + */ + floatms_t extraFuel = (floatms_t)0; + /** + * offset 16 + */ + float valueFromTable = (float)0; + /** + * Fuel: TPS AE Active + offset 20 bit 0 */ + bool isAboveAccelThreshold : 1 {}; + /** + offset 20 bit 1 */ + bool isBelowDecelThreshold : 1 {}; + /** + * Fuel: TPS AE: reset time + offset 20 bit 2 */ + bool isTimeToResetAccumulator : 1 {}; + /** + offset 20 bit 3 */ + bool isFractionalEnrichment : 1 {}; + /** + * Fuel: TPS AE: below threshold + offset 20 bit 4 */ + bool belowEpsilon : 1 {}; + /** + * Fuel: TPS AE: too short + offset 20 bit 5 */ + bool tooShort : 1 {}; + /** + offset 20 bit 6 */ + bool unusedBit_11_6 : 1 {}; + /** + offset 20 bit 7 */ + bool unusedBit_11_7 : 1 {}; + /** + offset 20 bit 8 */ + bool unusedBit_11_8 : 1 {}; + /** + offset 20 bit 9 */ + bool unusedBit_11_9 : 1 {}; + /** + offset 20 bit 10 */ + bool unusedBit_11_10 : 1 {}; + /** + offset 20 bit 11 */ + bool unusedBit_11_11 : 1 {}; + /** + offset 20 bit 12 */ + bool unusedBit_11_12 : 1 {}; + /** + offset 20 bit 13 */ + bool unusedBit_11_13 : 1 {}; + /** + offset 20 bit 14 */ + bool unusedBit_11_14 : 1 {}; + /** + offset 20 bit 15 */ + bool unusedBit_11_15 : 1 {}; + /** + offset 20 bit 16 */ + bool unusedBit_11_16 : 1 {}; + /** + offset 20 bit 17 */ + bool unusedBit_11_17 : 1 {}; + /** + offset 20 bit 18 */ + bool unusedBit_11_18 : 1 {}; + /** + offset 20 bit 19 */ + bool unusedBit_11_19 : 1 {}; + /** + offset 20 bit 20 */ + bool unusedBit_11_20 : 1 {}; + /** + offset 20 bit 21 */ + bool unusedBit_11_21 : 1 {}; + /** + offset 20 bit 22 */ + bool unusedBit_11_22 : 1 {}; + /** + offset 20 bit 23 */ + bool unusedBit_11_23 : 1 {}; + /** + offset 20 bit 24 */ + bool unusedBit_11_24 : 1 {}; + /** + offset 20 bit 25 */ + bool unusedBit_11_25 : 1 {}; + /** + offset 20 bit 26 */ + bool unusedBit_11_26 : 1 {}; + /** + offset 20 bit 27 */ + bool unusedBit_11_27 : 1 {}; + /** + offset 20 bit 28 */ + bool unusedBit_11_28 : 1 {}; + /** + offset 20 bit 29 */ + bool unusedBit_11_29 : 1 {}; + /** + offset 20 bit 30 */ + bool unusedBit_11_30 : 1 {}; + /** + offset 20 bit 31 */ + bool unusedBit_11_31 : 1 {}; + /** + * offset 24 + */ + float fractionalInjFuel = (float)0; + /** + * offset 28 + */ + floatms_t accumulatedValue = (floatms_t)0; + /** + * offset 32 + */ + floatms_t maxExtraPerCycle = (floatms_t)0; + /** + * offset 36 + */ + floatms_t maxExtraPerPeriod = (floatms_t)0; + /** + * offset 40 + */ + floatms_t maxInjectedPerPeriod = (floatms_t)0; + /** + * offset 44 + */ + int cycleCnt = (int)0; +}; +static_assert(sizeof(tps_accel_state_s) == 48); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/tps_accel_state.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/algo/wall_fuel_state_generated.h b/generated/controllers/algo/wall_fuel_state_generated.h new file mode 100644 index 0000000..dcf982f --- /dev/null +++ b/generated/controllers/algo/wall_fuel_state_generated.h @@ -0,0 +1,24 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/wall_fuel_state.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of wall_fuel_state_s +struct wall_fuel_state_s { + /** + * fuel wallwetting injection time + * correction to account for wall wetting effect for current cycle + * offset 0 + */ + float wallFuelCorrection = (float)0; + /** + * Fuel on the wall + * in ms of injector open time for each injector. + * offset 4 + */ + floatms_t wallFuel = (floatms_t)0; +}; +static_assert(sizeof(wall_fuel_state_s) == 8); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/algo/wall_fuel_state.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/engine_cycle/high_pressure_fuel_pump_generated.h b/generated/controllers/engine_cycle/high_pressure_fuel_pump_generated.h new file mode 100644 index 0000000..2d6ecae --- /dev/null +++ b/generated/controllers/engine_cycle/high_pressure_fuel_pump_generated.h @@ -0,0 +1,140 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/engine_cycle/high_pressure_fuel_pump.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of high_pressure_fuel_pump_s +struct high_pressure_fuel_pump_s { + /** + * GDI: HPFP duration + * Computed requested pump duration in degrees (not including deadtime) + * offset 0 + */ + angle_t m_requested_pump = (angle_t)0; + /** + * "GDI: requested_percent" + * offset 4 + */ + float fuel_requested_percent = (float)0; + /** + * "GDI: percent_pi" + * offset 8 + */ + float fuel_requested_percent_pi = (float)0; + /** + offset 12 bit 0 */ + bool noValve : 1 {}; + /** + offset 12 bit 1 */ + bool angleAboveMin : 1 {}; + /** + offset 12 bit 2 */ + bool isHpfpInactive : 1 {}; + /** + offset 12 bit 3 */ + bool unusedBit_6_3 : 1 {}; + /** + offset 12 bit 4 */ + bool unusedBit_6_4 : 1 {}; + /** + offset 12 bit 5 */ + bool unusedBit_6_5 : 1 {}; + /** + offset 12 bit 6 */ + bool unusedBit_6_6 : 1 {}; + /** + offset 12 bit 7 */ + bool unusedBit_6_7 : 1 {}; + /** + offset 12 bit 8 */ + bool unusedBit_6_8 : 1 {}; + /** + offset 12 bit 9 */ + bool unusedBit_6_9 : 1 {}; + /** + offset 12 bit 10 */ + bool unusedBit_6_10 : 1 {}; + /** + offset 12 bit 11 */ + bool unusedBit_6_11 : 1 {}; + /** + offset 12 bit 12 */ + bool unusedBit_6_12 : 1 {}; + /** + offset 12 bit 13 */ + bool unusedBit_6_13 : 1 {}; + /** + offset 12 bit 14 */ + bool unusedBit_6_14 : 1 {}; + /** + offset 12 bit 15 */ + bool unusedBit_6_15 : 1 {}; + /** + offset 12 bit 16 */ + bool unusedBit_6_16 : 1 {}; + /** + offset 12 bit 17 */ + bool unusedBit_6_17 : 1 {}; + /** + offset 12 bit 18 */ + bool unusedBit_6_18 : 1 {}; + /** + offset 12 bit 19 */ + bool unusedBit_6_19 : 1 {}; + /** + offset 12 bit 20 */ + bool unusedBit_6_20 : 1 {}; + /** + offset 12 bit 21 */ + bool unusedBit_6_21 : 1 {}; + /** + offset 12 bit 22 */ + bool unusedBit_6_22 : 1 {}; + /** + offset 12 bit 23 */ + bool unusedBit_6_23 : 1 {}; + /** + offset 12 bit 24 */ + bool unusedBit_6_24 : 1 {}; + /** + offset 12 bit 25 */ + bool unusedBit_6_25 : 1 {}; + /** + offset 12 bit 26 */ + bool unusedBit_6_26 : 1 {}; + /** + offset 12 bit 27 */ + bool unusedBit_6_27 : 1 {}; + /** + offset 12 bit 28 */ + bool unusedBit_6_28 : 1 {}; + /** + offset 12 bit 29 */ + bool unusedBit_6_29 : 1 {}; + /** + offset 12 bit 30 */ + bool unusedBit_6_30 : 1 {}; + /** + offset 12 bit 31 */ + bool unusedBit_6_31 : 1 {}; + /** + * "GDI: target pressure" + * offset 16 + */ + float m_pressureTarget_kPa = (float)0; + /** + * "GDI: nextLobe" + * offset 20 + */ + angle_t nextLobe = (angle_t)0; + /** + * GDI: next start + * units: v + * offset 24 + */ + float di_nextStart = (float)0; +}; +static_assert(sizeof(high_pressure_fuel_pump_s) == 28); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/engine_cycle/high_pressure_fuel_pump.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/engine_cycle/knock_controller_generated.h b/generated/controllers/engine_cycle/knock_controller_generated.h new file mode 100644 index 0000000..9cc3bd6 --- /dev/null +++ b/generated/controllers/engine_cycle/knock_controller_generated.h @@ -0,0 +1,45 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/engine_cycle/knock_controller.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of knock_controller_s +struct knock_controller_s { + /** + * @@GAUGE_NAME_KNOCK_LEVEL@@ + * units: Volts + * offset 0 + */ + float m_knockLevel = (float)0; + /** + * Knock: Cyl + * units: dBv + * offset 4 + */ + int8_t m_knockCyl[12]; + /** + * @@GAUGE_NAME_KNOCK_RETARD@@ + * units: deg + * offset 16 + */ + angle_t m_knockRetard = (angle_t)0; + /** + * Knock: Threshold + * offset 20 + */ + float m_knockThreshold = (float)0; + /** + * @@GAUGE_NAME_KNOCK_COUNTER@@ + * offset 24 + */ + uint32_t m_knockCount = (uint32_t)0; + /** + * Knock: Max retard + * offset 28 + */ + float m_maximumRetard = (float)0; +}; +static_assert(sizeof(knock_controller_s) == 32); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/engine_cycle/knock_controller.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/generated/engine_configuration_generated_structures_XXX.h b/generated/controllers/generated/engine_configuration_generated_structures_XXX.h index 2240c24..00bbf01 100644 --- a/generated/controllers/generated/engine_configuration_generated_structures_XXX.h +++ b/generated/controllers/generated/engine_configuration_generated_structures_XXX.h @@ -1,4 +1,4 @@ -// this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt Mon Mar 04 17:17:55 UTC 2024 +// this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt Tue Mar 05 17:17:37 UTC 2024 // by class com.rusefi.output.CHeaderConsumer // begin #pragma once @@ -2843,7 +2843,7 @@ struct engine_configuration_s { bool flexSensorInverted : 1 {}; /** offset 1576 bit 8 */ - bool unusedBit_495_8 : 1 {}; + bool useHardSkipInTraction : 1 {}; /** offset 1576 bit 9 */ bool unusedBit_495_9 : 1 {}; @@ -5630,4 +5630,4 @@ struct persistent_config_s { static_assert(sizeof(persistent_config_s) == 22236); // end -// this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt Mon Mar 04 17:17:55 UTC 2024 +// this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt Tue Mar 05 17:17:37 UTC 2024 diff --git a/generated/controllers/generated/rusefi_generated_XXX.h b/generated/controllers/generated/rusefi_generated_XXX.h index ee39c18..ffbfa66 100644 --- a/generated/controllers/generated/rusefi_generated_XXX.h +++ b/generated/controllers/generated/rusefi_generated_XXX.h @@ -629,7 +629,7 @@ #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",284="MC33810_0_GD_0",285="MC33810_0_GD_1",286="MC33810_0_GD_2",287="MC33810_0_GD_3",280="MC33810_0_OUT_0",281="MC33810_0_OUT_1",282="MC33810_0_OUT_2",283="MC33810_0_OUT_3",294="MC33810_1_GD_0",295="MC33810_1_GD_1",296="MC33810_1_GD_2",297="MC33810_1_GD_3",290="MC33810_1_OUT_0",291="MC33810_1_OUT_1",292="MC33810_1_OUT_2",293="MC33810_1_OUT_3",146="MC33972_PIN_1",155="MC33972_PIN_10",156="MC33972_PIN_11",157="MC33972_PIN_12",158="MC33972_PIN_13",159="MC33972_PIN_14",160="MC33972_PIN_15",161="MC33972_PIN_16",162="MC33972_PIN_17",163="MC33972_PIN_18",164="MC33972_PIN_19",147="MC33972_PIN_2",165="MC33972_PIN_20",166="MC33972_PIN_21",167="MC33972_PIN_22",148="MC33972_PIN_3",149="MC33972_PIN_4",150="MC33972_PIN_5",151="MC33972_PIN_6",152="MC33972_PIN_7",153="MC33972_PIN_8",154="MC33972_PIN_9",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_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",284="MC33810_0_GD_0",285="MC33810_0_GD_1",286="MC33810_0_GD_2",287="MC33810_0_GD_3",280="MC33810_0_OUT_0",281="MC33810_0_OUT_1",282="MC33810_0_OUT_2",283="MC33810_0_OUT_3",294="MC33810_1_GD_0",295="MC33810_1_GD_1",296="MC33810_1_GD_2",297="MC33810_1_GD_3",290="MC33810_1_OUT_0",291="MC33810_1_OUT_1",292="MC33810_1_OUT_2",293="MC33810_1_OUT_3",146="MC33972_PIN_1",155="MC33972_PIN_10",156="MC33972_PIN_11",157="MC33972_PIN_12",158="MC33972_PIN_13",159="MC33972_PIN_14",160="MC33972_PIN_15",161="MC33972_PIN_16",162="MC33972_PIN_17",163="MC33972_PIN_18",164="MC33972_PIN_19",147="MC33972_PIN_2",165="MC33972_PIN_20",166="MC33972_PIN_21",167="MC33972_PIN_22",148="MC33972_PIN_3",149="MC33972_PIN_4",150="MC33972_PIN_5",151="MC33972_PIN_6",152="MC33972_PIN_7",153="MC33972_PIN_8",154="MC33972_PIN_9",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",300="TLE9104_0_OUT_0",301="TLE9104_0_OUT_1",302="TLE9104_0_OUT_2",303="TLE9104_0_OUT_3",304="TLE9104_1_OUT_0",305="TLE9104_1_OUT_1",306="TLE9104_1_OUT_2",307="TLE9104_1_OUT_3",308="TLE9104_2_OUT_0",309="TLE9104_2_OUT_1",310="TLE9104_2_OUT_2",311="TLE9104_2_OUT_3",312="TLE9104_3_OUT_0",313="TLE9104_3_OUT_1",314="TLE9104_3_OUT_2",315="TLE9104_3_OUT_3",316="TLE9104_4_OUT_0",317="TLE9104_4_OUT_1",318="TLE9104_4_OUT_2",319="TLE9104_4_OUT_3",320="TLE9104_5_OUT_0",321="TLE9104_5_OUT_1",322="TLE9104_5_OUT_2",323="TLE9104_5_OUT_3" #define Gpio_B0 18 #define Gpio_B1 19 #define Gpio_B10 28 @@ -903,6 +903,30 @@ #define Gpio_TLE8888_PIN_KEY 197 #define Gpio_TLE8888_PIN_MR 196 #define Gpio_TLE8888_PIN_WAKE 198 +#define Gpio_TLE9104_0_OUT_0 300 +#define Gpio_TLE9104_0_OUT_1 301 +#define Gpio_TLE9104_0_OUT_2 302 +#define Gpio_TLE9104_0_OUT_3 303 +#define Gpio_TLE9104_1_OUT_0 304 +#define Gpio_TLE9104_1_OUT_1 305 +#define Gpio_TLE9104_1_OUT_2 306 +#define Gpio_TLE9104_1_OUT_3 307 +#define Gpio_TLE9104_2_OUT_0 308 +#define Gpio_TLE9104_2_OUT_1 309 +#define Gpio_TLE9104_2_OUT_2 310 +#define Gpio_TLE9104_2_OUT_3 311 +#define Gpio_TLE9104_3_OUT_0 312 +#define Gpio_TLE9104_3_OUT_1 313 +#define Gpio_TLE9104_3_OUT_2 314 +#define Gpio_TLE9104_3_OUT_3 315 +#define Gpio_TLE9104_4_OUT_0 316 +#define Gpio_TLE9104_4_OUT_1 317 +#define Gpio_TLE9104_4_OUT_2 318 +#define Gpio_TLE9104_4_OUT_3 319 +#define Gpio_TLE9104_5_OUT_0 320 +#define Gpio_TLE9104_5_OUT_1 321 +#define Gpio_TLE9104_5_OUT_2 322 +#define Gpio_TLE9104_5_OUT_3 323 #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",26="GPPWM_BaroPressure",3="GPPWM_Clt",25="GPPWM_DetectedGear",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", "Gear (detected)", "Baro pressure" @@ -1162,7 +1186,7 @@ #define show_microRusEFI_presets false #define show_Proteus_presets false #define show_test_presets false -#define SIGNATURE_HASH 1281921938 +#define SIGNATURE_HASH 3211138767 #define SIMULATOR_TUNE_BIN_FILE_NAME "generated/simulator_tune_image.bin" #define SIMULATOR_TUNE_BIN_FILE_NAME_PREFIX "generated/simulator_tune_image" #define SIMULATOR_TUNE_BIN_FILE_NAME_SUFFIX ".bin" @@ -1500,14 +1524,14 @@ #define ts_show_vr_threshold_all false #define ts_show_vr_threshold_pins true #define ts_show_vvt_output true -#define TS_SIGNATURE "rusEFI default.2024.03.04.XXX.1281921938" +#define TS_SIGNATURE "rusEFI default.2024.03.05.XXX.3211138767" #define TS_SIMULATE_CAN '>' #define TS_SIMULATE_CAN_char > #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 1456 +#define TS_TOTAL_OUTPUT_SIZE 1468 #define TS_TRIGGER_SCOPE_CHANNEL_1_NAME "Channel 1" #define TS_TRIGGER_SCOPE_CHANNEL_2_NAME "Channel 2" #define TS_TRIGGER_SCOPE_DISABLE 5 diff --git a/generated/controllers/generated/signature_XXX.h b/generated/controllers/generated/signature_XXX.h index c3b17e3..6cab234 100644 --- a/generated/controllers/generated/signature_XXX.h +++ b/generated/controllers/generated/signature_XXX.h @@ -2,5 +2,5 @@ // was generated automatically by rusEFI tool config_definition-all.jar based on gen_config.sh by SignatureConsumer // -#define SIGNATURE_HASH 1281921938 -#define TS_SIGNATURE "rusEFI default.2024.03.04.XXX.1281921938" +#define SIGNATURE_HASH 3211138767 +#define TS_SIGNATURE "rusEFI default.2024.03.05.XXX.3211138767" diff --git a/generated/controllers/math/lambda_monitor_generated.h b/generated/controllers/math/lambda_monitor_generated.h new file mode 100644 index 0000000..3aa656e --- /dev/null +++ b/generated/controllers/math/lambda_monitor_generated.h @@ -0,0 +1,119 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/math/lambda_monitor.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of lambda_monitor_s +struct lambda_monitor_s { + /** + offset 0 bit 0 */ + bool lambdaCurrentlyGood : 1 {}; + /** + offset 0 bit 1 */ + bool lambdaMonitorCut : 1 {}; + /** + offset 0 bit 2 */ + bool unusedBit_2_2 : 1 {}; + /** + offset 0 bit 3 */ + bool unusedBit_2_3 : 1 {}; + /** + offset 0 bit 4 */ + bool unusedBit_2_4 : 1 {}; + /** + offset 0 bit 5 */ + bool unusedBit_2_5 : 1 {}; + /** + offset 0 bit 6 */ + bool unusedBit_2_6 : 1 {}; + /** + offset 0 bit 7 */ + bool unusedBit_2_7 : 1 {}; + /** + offset 0 bit 8 */ + bool unusedBit_2_8 : 1 {}; + /** + offset 0 bit 9 */ + bool unusedBit_2_9 : 1 {}; + /** + offset 0 bit 10 */ + bool unusedBit_2_10 : 1 {}; + /** + offset 0 bit 11 */ + bool unusedBit_2_11 : 1 {}; + /** + offset 0 bit 12 */ + bool unusedBit_2_12 : 1 {}; + /** + offset 0 bit 13 */ + bool unusedBit_2_13 : 1 {}; + /** + offset 0 bit 14 */ + bool unusedBit_2_14 : 1 {}; + /** + offset 0 bit 15 */ + bool unusedBit_2_15 : 1 {}; + /** + offset 0 bit 16 */ + bool unusedBit_2_16 : 1 {}; + /** + offset 0 bit 17 */ + bool unusedBit_2_17 : 1 {}; + /** + offset 0 bit 18 */ + bool unusedBit_2_18 : 1 {}; + /** + offset 0 bit 19 */ + bool unusedBit_2_19 : 1 {}; + /** + offset 0 bit 20 */ + bool unusedBit_2_20 : 1 {}; + /** + offset 0 bit 21 */ + bool unusedBit_2_21 : 1 {}; + /** + offset 0 bit 22 */ + bool unusedBit_2_22 : 1 {}; + /** + offset 0 bit 23 */ + bool unusedBit_2_23 : 1 {}; + /** + offset 0 bit 24 */ + bool unusedBit_2_24 : 1 {}; + /** + offset 0 bit 25 */ + bool unusedBit_2_25 : 1 {}; + /** + offset 0 bit 26 */ + bool unusedBit_2_26 : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_2_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_2_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_2_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_2_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_2_31 : 1 {}; + /** + * units: sec + * offset 4 + */ + scaled_channel lambdaTimeSinceGood = (uint16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 6 + */ + uint8_t alignmentFill_at_6[2]; +}; +static_assert(sizeof(lambda_monitor_s) == 8); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/math/lambda_monitor.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/math/throttle_model_generated.h b/generated/controllers/math/throttle_model_generated.h new file mode 100644 index 0000000..27856e2 --- /dev/null +++ b/generated/controllers/math/throttle_model_generated.h @@ -0,0 +1,127 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/math/throttle_model.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of throttle_model_s +struct throttle_model_s { + /** + * Air: Throttle model WOT + offset 0 bit 0 */ + bool throttleUseWotModel : 1 {}; + /** + offset 0 bit 1 */ + bool unusedBit_1_1 : 1 {}; + /** + offset 0 bit 2 */ + bool unusedBit_1_2 : 1 {}; + /** + offset 0 bit 3 */ + bool unusedBit_1_3 : 1 {}; + /** + offset 0 bit 4 */ + bool unusedBit_1_4 : 1 {}; + /** + offset 0 bit 5 */ + bool unusedBit_1_5 : 1 {}; + /** + offset 0 bit 6 */ + bool unusedBit_1_6 : 1 {}; + /** + offset 0 bit 7 */ + bool unusedBit_1_7 : 1 {}; + /** + offset 0 bit 8 */ + bool unusedBit_1_8 : 1 {}; + /** + offset 0 bit 9 */ + bool unusedBit_1_9 : 1 {}; + /** + offset 0 bit 10 */ + bool unusedBit_1_10 : 1 {}; + /** + offset 0 bit 11 */ + bool unusedBit_1_11 : 1 {}; + /** + offset 0 bit 12 */ + bool unusedBit_1_12 : 1 {}; + /** + offset 0 bit 13 */ + bool unusedBit_1_13 : 1 {}; + /** + offset 0 bit 14 */ + bool unusedBit_1_14 : 1 {}; + /** + offset 0 bit 15 */ + bool unusedBit_1_15 : 1 {}; + /** + offset 0 bit 16 */ + bool unusedBit_1_16 : 1 {}; + /** + offset 0 bit 17 */ + bool unusedBit_1_17 : 1 {}; + /** + offset 0 bit 18 */ + bool unusedBit_1_18 : 1 {}; + /** + offset 0 bit 19 */ + bool unusedBit_1_19 : 1 {}; + /** + offset 0 bit 20 */ + bool unusedBit_1_20 : 1 {}; + /** + offset 0 bit 21 */ + bool unusedBit_1_21 : 1 {}; + /** + offset 0 bit 22 */ + bool unusedBit_1_22 : 1 {}; + /** + offset 0 bit 23 */ + bool unusedBit_1_23 : 1 {}; + /** + offset 0 bit 24 */ + bool unusedBit_1_24 : 1 {}; + /** + offset 0 bit 25 */ + bool unusedBit_1_25 : 1 {}; + /** + offset 0 bit 26 */ + bool unusedBit_1_26 : 1 {}; + /** + offset 0 bit 27 */ + bool unusedBit_1_27 : 1 {}; + /** + offset 0 bit 28 */ + bool unusedBit_1_28 : 1 {}; + /** + offset 0 bit 29 */ + bool unusedBit_1_29 : 1 {}; + /** + offset 0 bit 30 */ + bool unusedBit_1_30 : 1 {}; + /** + offset 0 bit 31 */ + bool unusedBit_1_31 : 1 {}; + /** + * Air: Throttle crossover pos + * units: % + * offset 4 + */ + scaled_channel throttleModelCrossoverAngle = (int16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 6 + */ + uint8_t alignmentFill_at_6[2]; + /** + * Air: Throttle flow estimate + * units: g/s + * offset 8 + */ + float throttleEstimatedFlow = (float)0; +}; +static_assert(sizeof(throttle_model_s) == 12); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/math/throttle_model.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/sensors/sent_state_generated.h b/generated/controllers/sensors/sent_state_generated.h new file mode 100644 index 0000000..3f524f5 --- /dev/null +++ b/generated/controllers/sensors/sent_state_generated.h @@ -0,0 +1,30 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/sensors/sent_state.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of sent_state_s +struct sent_state_s { + /** + * "ETB: SENT value0" + * units: value + * offset 0 + */ + uint16_t value0 = (uint16_t)0; + /** + * "ETB: SENT value1" + * units: value + * offset 2 + */ + uint16_t value1 = (uint16_t)0; + /** + * "ETB: SENT error rate" + * units: ratio + * offset 4 + */ + float errorRate = (float)0; +}; +static_assert(sizeof(sent_state_s) == 8); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/sensors/sent_state.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/sensors/wideband_state_generated.h b/generated/controllers/sensors/wideband_state_generated.h new file mode 100644 index 0000000..334ba6d --- /dev/null +++ b/generated/controllers/sensors/wideband_state_generated.h @@ -0,0 +1,59 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/sensors//wideband_state.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of wideband_state_s +struct wideband_state_s { + /** + * WBO: Fault code + * offset 0 + */ + uint8_t faultCode = (uint8_t)0; + /** + * WBO: Heater duty + * units: % + * offset 1 + */ + uint8_t heaterDuty = (uint8_t)0; + /** + * WBO: Pump duty + * units: % + * offset 2 + */ + uint8_t pumpDuty = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 3 + */ + uint8_t alignmentFill_at_3[1]; + /** + * WBO: Temperature + * units: C + * offset 4 + */ + uint16_t tempC = (uint16_t)0; + /** + * WBO: Nernst Voltage + * units: V + * offset 6 + */ + scaled_channel nernstVoltage = (uint16_t)0; + /** + * WBO: ESR + * units: ohm + * offset 8 + */ + uint16_t esr = (uint16_t)0; + /** + * need 4 byte alignment + * units: units + * offset 10 + */ + uint8_t alignmentFill_at_10[2]; +}; +static_assert(sizeof(wideband_state_s) == 12); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/sensors//wideband_state.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/tcu/tcu_controller_generated.h b/generated/controllers/tcu/tcu_controller_generated.h new file mode 100644 index 0000000..27306ac --- /dev/null +++ b/generated/controllers/tcu/tcu_controller_generated.h @@ -0,0 +1,45 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/tcu/tcu_controller.txt Tue Mar 05 17:17:34 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of tcu_controller_s +struct tcu_controller_s { + /** + * @@GAUGE_NAME_CURRENT_GEAR@@ + * units: gear + * offset 0 + */ + int8_t tcuCurrentGear = (int8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 1 + */ + uint8_t alignmentFill_at_1[1]; + /** + * @@GAUGE_NAME_TC_RATIO@@ + * units: value + * offset 2 + */ + scaled_channel tcRatio = (uint16_t)0; + /** + * offset 4 + */ + float lastShiftTime = (float)0; + /** + * "TCU: Current Range" + * offset 8 + */ + uint8_t tcu_currentRange = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 9 + */ + uint8_t alignmentFill_at_9[3]; +}; +static_assert(sizeof(tcu_controller_s) == 12); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/tcu/tcu_controller.txt Tue Mar 05 17:17:34 UTC 2024 diff --git a/generated/controllers/trigger/trigger_central_generated.h b/generated/controllers/trigger/trigger_central_generated.h new file mode 100644 index 0000000..d2a13b4 --- /dev/null +++ b/generated/controllers/trigger/trigger_central_generated.h @@ -0,0 +1,169 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/trigger/trigger_central.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +#define HW_EVENT_TYPES 6 +// start of trigger_central_s +struct trigger_central_s { + /** + * Hardware events since boot + * offset 0 + */ + uint32_t hwEventCounters[HW_EVENT_TYPES]; + /** + * Sync: total cams front counter + * offset 24 + */ + uint32_t vvtCamCounter = (uint32_t)0; + /** + * offset 28 + */ + float mapVvt_MAP_AT_SPECIAL_POINT = (float)0; + /** + * offset 32 + */ + float mapVvt_MAP_AT_DIFF = (float)0; + /** + * offset 36 + */ + uint8_t mapVvt_MAP_AT_CYCLE_COUNT = (uint8_t)0; + /** + * offset 37 + */ + uint8_t mapVvt_map_peak = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 38 + */ + uint8_t alignmentFill_at_38[2]; + /** + * Sync: Engine Phase + * units: deg + * offset 40 + */ + float currentEngineDecodedPhase = (float)0; + /** + * Sync: trigger angle error + * units: deg + * offset 44 + */ + float triggerToothAngleError = (float)0; + /** + * offset 48 + */ + uint8_t triggerIgnoredToothCount = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 49 + */ + uint8_t alignmentFill_at_49[3]; + /** + * Sync: MAP: prev angle + * units: deg + * offset 52 + */ + angle_t mapCamPrevToothAngle = (angle_t)0; + /** + offset 56 bit 0 */ + bool isDecodingMapCam : 1 {}; + /** + offset 56 bit 1 */ + bool unusedBit_13_1 : 1 {}; + /** + offset 56 bit 2 */ + bool unusedBit_13_2 : 1 {}; + /** + offset 56 bit 3 */ + bool unusedBit_13_3 : 1 {}; + /** + offset 56 bit 4 */ + bool unusedBit_13_4 : 1 {}; + /** + offset 56 bit 5 */ + bool unusedBit_13_5 : 1 {}; + /** + offset 56 bit 6 */ + bool unusedBit_13_6 : 1 {}; + /** + offset 56 bit 7 */ + bool unusedBit_13_7 : 1 {}; + /** + offset 56 bit 8 */ + bool unusedBit_13_8 : 1 {}; + /** + offset 56 bit 9 */ + bool unusedBit_13_9 : 1 {}; + /** + offset 56 bit 10 */ + bool unusedBit_13_10 : 1 {}; + /** + offset 56 bit 11 */ + bool unusedBit_13_11 : 1 {}; + /** + offset 56 bit 12 */ + bool unusedBit_13_12 : 1 {}; + /** + offset 56 bit 13 */ + bool unusedBit_13_13 : 1 {}; + /** + offset 56 bit 14 */ + bool unusedBit_13_14 : 1 {}; + /** + offset 56 bit 15 */ + bool unusedBit_13_15 : 1 {}; + /** + offset 56 bit 16 */ + bool unusedBit_13_16 : 1 {}; + /** + offset 56 bit 17 */ + bool unusedBit_13_17 : 1 {}; + /** + offset 56 bit 18 */ + bool unusedBit_13_18 : 1 {}; + /** + offset 56 bit 19 */ + bool unusedBit_13_19 : 1 {}; + /** + offset 56 bit 20 */ + bool unusedBit_13_20 : 1 {}; + /** + offset 56 bit 21 */ + bool unusedBit_13_21 : 1 {}; + /** + offset 56 bit 22 */ + bool unusedBit_13_22 : 1 {}; + /** + offset 56 bit 23 */ + bool unusedBit_13_23 : 1 {}; + /** + offset 56 bit 24 */ + bool unusedBit_13_24 : 1 {}; + /** + offset 56 bit 25 */ + bool unusedBit_13_25 : 1 {}; + /** + offset 56 bit 26 */ + bool unusedBit_13_26 : 1 {}; + /** + offset 56 bit 27 */ + bool unusedBit_13_27 : 1 {}; + /** + offset 56 bit 28 */ + bool unusedBit_13_28 : 1 {}; + /** + offset 56 bit 29 */ + bool unusedBit_13_29 : 1 {}; + /** + offset 56 bit 30 */ + bool unusedBit_13_30 : 1 {}; + /** + offset 56 bit 31 */ + bool unusedBit_13_31 : 1 {}; +}; +static_assert(sizeof(trigger_central_s) == 60); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/trigger/trigger_central.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/trigger/trigger_state_generated.h b/generated/controllers/trigger/trigger_state_generated.h new file mode 100644 index 0000000..706026c --- /dev/null +++ b/generated/controllers/trigger/trigger_state_generated.h @@ -0,0 +1,56 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/trigger/trigger_state.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of trigger_state_s +struct trigger_state_s { + /** + * sync: Crank sync counter + * Usually matches crank revolutions + * offset 0 + */ + uint32_t crankSynchronizationCounter = (uint32_t)0; + /** + * offset 4 + */ + float vvtSyncGapRatio = (float)0; + /** + * units: us + * offset 8 + */ + uint32_t vvtToothDurations0 = (uint32_t)0; + /** + * units: sync: Primary Cam Position + * offset 12 + */ + float vvtCurrentPosition = (float)0; + /** + * units: sync: Cam Tooth Position + * offset 16 + */ + float vvtToothPosition[4]; + /** + * @@GAUGE_NAME_TRG_GAP@@ + * offset 32 + */ + float triggerSyncGapRatio = (float)0; + /** + * offset 36 + */ + uint8_t triggerStateIndex = (uint8_t)0; + /** + * offset 37 + */ + uint8_t vvtStateIndex = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 38 + */ + uint8_t alignmentFill_at_38[2]; +}; +static_assert(sizeof(trigger_state_s) == 40); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/trigger/trigger_state.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/controllers/trigger/trigger_state_primary_generated.h b/generated/controllers/trigger/trigger_state_primary_generated.h new file mode 100644 index 0000000..e10c1d7 --- /dev/null +++ b/generated/controllers/trigger/trigger_state_primary_generated.h @@ -0,0 +1,120 @@ +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/trigger/trigger_state_primary.txt Tue Mar 05 17:17:35 UTC 2024 +// by class com.rusefi.output.CHeaderConsumer +// begin +#pragma once +#include "rusefi_types.h" +// start of trigger_state_primary_s +struct trigger_state_primary_s { + /** + * sync: Phase Re-Sync Counter + * offset 0 + */ + uint8_t camResyncCounter = (uint8_t)0; + /** + * need 4 byte alignment + * units: units + * offset 1 + */ + uint8_t alignmentFill_at_1[3]; + /** + * sync: Known Engine Phase + offset 4 bit 0 */ + bool m_hasSynchronizedPhase : 1 {}; + /** + offset 4 bit 1 */ + bool unusedBit_3_1 : 1 {}; + /** + offset 4 bit 2 */ + bool unusedBit_3_2 : 1 {}; + /** + offset 4 bit 3 */ + bool unusedBit_3_3 : 1 {}; + /** + offset 4 bit 4 */ + bool unusedBit_3_4 : 1 {}; + /** + offset 4 bit 5 */ + bool unusedBit_3_5 : 1 {}; + /** + offset 4 bit 6 */ + bool unusedBit_3_6 : 1 {}; + /** + offset 4 bit 7 */ + bool unusedBit_3_7 : 1 {}; + /** + offset 4 bit 8 */ + bool unusedBit_3_8 : 1 {}; + /** + offset 4 bit 9 */ + bool unusedBit_3_9 : 1 {}; + /** + offset 4 bit 10 */ + bool unusedBit_3_10 : 1 {}; + /** + offset 4 bit 11 */ + bool unusedBit_3_11 : 1 {}; + /** + offset 4 bit 12 */ + bool unusedBit_3_12 : 1 {}; + /** + offset 4 bit 13 */ + bool unusedBit_3_13 : 1 {}; + /** + offset 4 bit 14 */ + bool unusedBit_3_14 : 1 {}; + /** + offset 4 bit 15 */ + bool unusedBit_3_15 : 1 {}; + /** + offset 4 bit 16 */ + bool unusedBit_3_16 : 1 {}; + /** + offset 4 bit 17 */ + bool unusedBit_3_17 : 1 {}; + /** + offset 4 bit 18 */ + bool unusedBit_3_18 : 1 {}; + /** + offset 4 bit 19 */ + bool unusedBit_3_19 : 1 {}; + /** + offset 4 bit 20 */ + bool unusedBit_3_20 : 1 {}; + /** + offset 4 bit 21 */ + bool unusedBit_3_21 : 1 {}; + /** + offset 4 bit 22 */ + bool unusedBit_3_22 : 1 {}; + /** + offset 4 bit 23 */ + bool unusedBit_3_23 : 1 {}; + /** + offset 4 bit 24 */ + bool unusedBit_3_24 : 1 {}; + /** + offset 4 bit 25 */ + bool unusedBit_3_25 : 1 {}; + /** + offset 4 bit 26 */ + bool unusedBit_3_26 : 1 {}; + /** + offset 4 bit 27 */ + bool unusedBit_3_27 : 1 {}; + /** + offset 4 bit 28 */ + bool unusedBit_3_28 : 1 {}; + /** + offset 4 bit 29 */ + bool unusedBit_3_29 : 1 {}; + /** + offset 4 bit 30 */ + bool unusedBit_3_30 : 1 {}; + /** + offset 4 bit 31 */ + bool unusedBit_3_31 : 1 {}; +}; +static_assert(sizeof(trigger_state_primary_s) == 8); + +// end +// this section was generated automatically by rusEFI tool config_definition_base-all.jar based on (unknown script) controllers/trigger/trigger_state_primary.txt Tue Mar 05 17:17:35 UTC 2024 diff --git a/generated/tunerstudio/generated/rusefi_XXX.ini b/generated/tunerstudio/generated/rusefi_XXX.ini index ab97694..815939c 100644 --- a/generated/tunerstudio/generated/rusefi_XXX.ini +++ b/generated/tunerstudio/generated/rusefi_XXX.ini @@ -37,12 +37,12 @@ enable2ndByteCanID = false [MegaTune] ; https://rusefi.com/forum/viewtopic.php?p=36201#p36201 - signature = "rusEFI default.2024.03.04.XXX.1281921938" + signature = "rusEFI default.2024.03.05.XXX.3211138767" [TunerStudio] queryCommand = "S" versionInfo = "V" ; firmware version for title bar. - signature= "rusEFI default.2024.03.04.XXX.1281921938" ; signature is expected to be 7 or more characters. + signature= "rusEFI default.2024.03.05.XXX.3211138767" ; signature is expected to be 7 or more characters. ; TS will try to use legacy temp units in some cases, showing "deg F" on a CLT gauge that's actually deg C useLegacyFTempUnits = false @@ -98,7 +98,7 @@ enable2ndByteCanID = false #define adc_channel_e_list="Disabled", "PA0", "PA1", "PA2", "PA3", "PA4", "PA5", "PA6", "PA7", "PB0", "PB1", "PC0", "PC1", "PC2", "PC3", "PC4", "PC5" ; CONFIG_DEFINITION_START -; this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt Mon Mar 04 17:17:55 UTC 2024 +; this section was generated automatically by rusEFI tool config_definition-all.jar based on (unknown script) integration/rusefi_config.txt Tue Mar 05 17:17:37 UTC 2024 pageSize = 22236 page = 1 @@ -745,6 +745,7 @@ mc33810Gpgd3Mode = bits, U32, 1576, [4:4], "false", "true" enableExtendedCanBroadcast = bits, U32, 1576, [5:5], "false", "true" luaCanRxWorkaround = bits, U32, 1576, [6:6], "false", "true" flexSensorInverted = bits, U32, 1576, [7:7], "false", "true" +useHardSkipInTraction = bits, U32, 1576, [8:8], "false", "true" useAuxSpeedForSlipRatio = bits, U32, 1576, [11:11], "false", "true" useVssAsSecondWheelSpeed = bits, U32, 1576, [12:12], "false", "true" is_enabled_spi_5 = bits, U32, 1576, [13:13], "false", "true" @@ -2468,7 +2469,7 @@ injectorStagingRpmBins = array, U16, 22222, [6], "RPM", 1, 0, 0, 18000, 0 ochGetCommand = "O%2o%2c" ; see TS_OUTPUT_SIZE in console source code - ochBlockSize = 1456 + ochBlockSize = 1468 ; 11.2.3 Full Optimized – High Speed scatteredOchGetCommand = 9 @@ -2493,24 +2494,23 @@ checkEngine = bits, U32, 0, [6:6] needBurn = bits, U32, 0, [7:7] sd_msd = bits, U32, 0, [8:8] isFan2On = bits, U32, 0, [9:9] -acrActive = bits, U32, 0, [10:10] -toothLogReady = bits, U32, 0, [11:11] -isTpsError = bits, U32, 0, [12:12] -isCltError = bits, U32, 0, [13:13] -isMapError = bits, U32, 0, [14:14] -isIatError = bits, U32, 0, [15:15] -isTriggerError = bits, U32, 0, [16:16] -hasCriticalError = bits, U32, 0, [17:17] -isWarnNow = bits, U32, 0, [18:18] -isPedalError = bits, U32, 0, [19:19] -isKnockChipOk = bits, U32, 0, [20:20] -launchTriggered = bits, U32, 0, [21:21] -isTps2Error = bits, U32, 0, [22:22] -injectorFault = bits, U32, 0, [23:23] -ignitionFault = bits, U32, 0, [24:24] -isMainRelayOn = bits, U32, 0, [25:25] -isUsbConnected = bits, U32, 0, [26:26] -dfcoActive = bits, U32, 0, [27:27] +toothLogReady = bits, U32, 0, [10:10] +isTpsError = bits, U32, 0, [11:11] +isCltError = bits, U32, 0, [12:12] +isMapError = bits, U32, 0, [13:13] +isIatError = bits, U32, 0, [14:14] +isTriggerError = bits, U32, 0, [15:15] +hasCriticalError = bits, U32, 0, [16:16] +isWarnNow = bits, U32, 0, [17:17] +isPedalError = bits, U32, 0, [18:18] +isKnockChipOk = bits, U32, 0, [19:19] +launchTriggered = bits, U32, 0, [20:20] +isTps2Error = bits, U32, 0, [21:21] +injectorFault = bits, U32, 0, [22:22] +ignitionFault = bits, U32, 0, [23:23] +isMainRelayOn = bits, U32, 0, [24:24] +isUsbConnected = bits, U32, 0, [25:25] +dfcoActive = bits, U32, 0, [26:26] RPMValue = scalar, U16, 4, "RPM", 1, 0 rpmAcceleration = scalar, S16, 6, "RPM acceleration", 1, 0 speedToRpmRatio = scalar, U16, 8, "value", 0.01, 0 @@ -3131,7 +3131,7 @@ smartChipState = scalar, S08, 1102, "", 1, 0 smartChipRestartCounter = scalar, S08, 1103, "", 1, 0 smartChipAliveCounter = scalar, S08, 1104, "", 1, 0 startStopPhysicalState = bits, U32, 1108, [0:0] -acrStateDup = bits, U32, 1108, [1:1] +acrActive = bits, U32, 1108, [1:1] acrEngineMovedRecently = bits, U32, 1108, [2:2] heaterControlEnabled = bits, U32, 1108, [3:3] luaDigitalState0 = bits, U32, 1108, [4:4] @@ -3141,135 +3141,138 @@ luaDigitalState3 = bits, U32, 1108, [7:7] startStopStateToggleCounter = scalar, U32, 1112, "", 1, 0 egtValue1 = scalar, F32, 1116, "", 1, 0 egtValue2 = scalar, F32, 1120, "", 1, 0 -desiredRpmLimit = scalar, S16, 1124, "rpm", 1, 0 -fuelInjectionCounter = scalar, U32, 1128, "", 1, 0 -globalSparkCounter = scalar, U32, 1132, "", 1, 0 -fuelingLoad = scalar, F32, 1136, "", 1, 0 -ignitionLoad = scalar, F32, 1140, "", 1, 0 -veTableYAxis = scalar, U16, 1144, "%", 0.01, 0 -; total TS size = 1148 -tpsFrom = scalar, F32, 1148 -tpsTo = scalar, F32, 1152 -deltaTps = scalar, F32, 1156 -extraFuel = scalar, F32, 1160, "", 1, 0 -valueFromTable = scalar, F32, 1164, "", 1, 0 -isAboveAccelThreshold = bits, U32, 1168, [0:0] -isBelowDecelThreshold = bits, U32, 1168, [1:1] -isTimeToResetAccumulator = bits, U32, 1168, [2:2] -isFractionalEnrichment = bits, U32, 1168, [3:3] -belowEpsilon = bits, U32, 1168, [4:4] -tooShort = bits, U32, 1168, [5:5] -fractionalInjFuel = scalar, F32, 1172, "", 1, 0 -accumulatedValue = scalar, F32, 1176, "", 1, 0 -maxExtraPerCycle = scalar, F32, 1180, "", 1, 0 -maxExtraPerPeriod = scalar, F32, 1184, "", 1, 0 -maxInjectedPerPeriod = scalar, F32, 1188, "", 1, 0 -cycleCnt = scalar, S32, 1192, "", 1, 0 -; total TS size = 1196 -hwEventCounters1 = scalar, U32, 1196, "", 1, 0 -hwEventCounters2 = scalar, U32, 1200, "", 1, 0 -hwEventCounters3 = scalar, U32, 1204, "", 1, 0 -hwEventCounters4 = scalar, U32, 1208, "", 1, 0 -hwEventCounters5 = scalar, U32, 1212, "", 1, 0 -hwEventCounters6 = scalar, U32, 1216, "", 1, 0 -vvtCamCounter = scalar, U32, 1220, "", 1, 0 -mapVvt_MAP_AT_SPECIAL_POINT = scalar, F32, 1224, "", 1, 0 -mapVvt_MAP_AT_DIFF = scalar, F32, 1228, "", 1, 0 -mapVvt_MAP_AT_CYCLE_COUNT = scalar, U08, 1232, "", 1, 0 -mapVvt_map_peak = scalar, U08, 1233, "", 1, 0 -currentEngineDecodedPhase = scalar, F32, 1236, "deg", 1, 0 -triggerToothAngleError = scalar, F32, 1240, "deg", 1, 0 -triggerIgnoredToothCount = scalar, U08, 1244, "", 1, 0 -mapCamPrevToothAngle = scalar, F32, 1248, "deg", 1, 0 -isDecodingMapCam = bits, U32, 1252, [0:0] -; total TS size = 1256 -crankSynchronizationCounter0 = scalar, U32, 1256, "", 1, 0 -vvtSyncGapRatio0 = scalar, F32, 1260, "", 1, 0 -vvtToothDurations00 = scalar, U32, 1264, "us", 1, 0 -vvtCurrentPosition0 = scalar, F32, 1268, "sync: Primary Cam Position", 1, 0 -vvtToothPosition10 = scalar, F32, 1272, "sync: Cam Tooth Position", 1, 0 -vvtToothPosition20 = scalar, F32, 1276, "sync: Cam Tooth Position", 1, 0 -vvtToothPosition30 = scalar, F32, 1280, "sync: Cam Tooth Position", 1, 0 -vvtToothPosition40 = scalar, F32, 1284, "sync: Cam Tooth Position", 1, 0 -triggerSyncGapRatio0 = scalar, F32, 1288, "", 1, 0 -triggerStateIndex0 = scalar, U08, 1292, "", 1, 0 -vvtStateIndex0 = scalar, U08, 1293, "", 1, 0 -; total TS size = 1296 -camResyncCounter = scalar, U08, 1296, "", 1, 0 -m_hasSynchronizedPhase = bits, U32, 1300, [0:0] -; total TS size = 1304 -wallFuelCorrection = scalar, F32, 1304, "", 1, 0 -wallFuel = scalar, F32, 1308, "", 1, 0 -; total TS size = 1312 -idleState = bits, S32, 1312, [0:2], "not important" -currentIdlePosition = scalar, F32, 1316 -baseIdlePosition = scalar, F32, 1320 -idleClosedLoop = scalar, F32, 1324 -iacByTpsTaper = scalar, F32, 1328 -throttlePedalUpState = scalar, S32, 1332, "", 1, 0 -mightResetPid = bits, U32, 1336, [0:0] -shouldResetPid = bits, U32, 1336, [1:1] -wasResetPid = bits, U32, 1336, [2:2] -mustResetPid = bits, U32, 1336, [3:3] -isCranking = bits, U32, 1336, [4:4] -isIacTableForCoasting = bits, U32, 1336, [5:5] -notIdling = bits, U32, 1336, [6:6] -needReset = bits, U32, 1336, [7:7] -isInDeadZone = bits, U32, 1336, [8:8] -isBlipping = bits, U32, 1336, [9:9] -useClosedLoop = bits, U32, 1336, [10:10] -badTps = bits, U32, 1336, [11:11] -looksLikeRunning = bits, U32, 1336, [12:12] -looksLikeCoasting = bits, U32, 1336, [13:13] -looksLikeCrankToIdle = bits, U32, 1336, [14:14] -isIdleCoasting = bits, U32, 1336, [15:15] -isIdleClosedLoop = bits, U32, 1336, [16:16] -idleTarget = scalar, S32, 1340, "", 1, 0 -targetRpmByClt = scalar, S32, 1344, "", 1, 0 -targetRpmAc = scalar, S32, 1348, "", 1, 0 -iacByRpmTaper = scalar, F32, 1352 -luaAdd = scalar, F32, 1356 -; total TS size = 1360 -idlePosition0 = scalar, F32, 1360, "per", 1,0 -trim0 = scalar, F32, 1364, "", 1, 0 -luaAdjustment0 = scalar, F32, 1368, "per", 1,0 -m_wastegatePosition0 = scalar, F32, 1372, "per", 1,0 -etbFeedForward0 = scalar, F32, 1376 -etbIntegralError0 = scalar, F32, 1380, "", 1, 0 -etbCurrentTarget0 = scalar, F32, 1384, "%", 1, 0 -etbCurrentAdjustedTarget0 = scalar, F32, 1388, "%", 1, 0 -etbRevLimitActive0 = bits, U32, 1392, [0:0] -jamDetected0 = bits, U32, 1392, [1:1] -etbDutyRateOfChange0 = scalar, F32, 1396, "per", 1,0 -etbDutyAverage0 = scalar, F32, 1400, "per", 1,0 -etbTpsErrorCounter0 = scalar, U16, 1404, "count", 1,0 -etbPpsErrorCounter0 = scalar, U16, 1406, "count", 1,0 -etbErrorCode0 = scalar, S08, 1408, "", 1, 0 -tcEtbDrop0 = scalar, S08, 1409, "", 1, 0 -jamTimer0 = scalar, U16, 1410, "sec", 0.01, 0 -; total TS size = 1412 -faultCode0 = scalar, U08, 1412, "", 1, 0 -heaterDuty0 = scalar, U08, 1413, "%", 1, 0 -pumpDuty0 = scalar, U08, 1414, "%", 1, 0 -tempC0 = scalar, U16, 1416, "C", 1, 0 -nernstVoltage0 = scalar, U16, 1418, "V", 0.001, 0 -esr0 = scalar, U16, 1420, "ohm", 1, 0 +luaSoftSparkSkip = scalar, F32, 1124, "", 1, 0 +luaHardSparkSkip = scalar, F32, 1128, "", 1, 0 +tractionControlSparkSkip = scalar, F32, 1132, "", 1, 0 +desiredRpmLimit = scalar, S16, 1136, "rpm", 1, 0 +fuelInjectionCounter = scalar, U32, 1140, "", 1, 0 +globalSparkCounter = scalar, U32, 1144, "", 1, 0 +fuelingLoad = scalar, F32, 1148, "", 1, 0 +ignitionLoad = scalar, F32, 1152, "", 1, 0 +veTableYAxis = scalar, U16, 1156, "%", 0.01, 0 +; total TS size = 1160 +tpsFrom = scalar, F32, 1160 +tpsTo = scalar, F32, 1164 +deltaTps = scalar, F32, 1168 +extraFuel = scalar, F32, 1172, "", 1, 0 +valueFromTable = scalar, F32, 1176, "", 1, 0 +isAboveAccelThreshold = bits, U32, 1180, [0:0] +isBelowDecelThreshold = bits, U32, 1180, [1:1] +isTimeToResetAccumulator = bits, U32, 1180, [2:2] +isFractionalEnrichment = bits, U32, 1180, [3:3] +belowEpsilon = bits, U32, 1180, [4:4] +tooShort = bits, U32, 1180, [5:5] +fractionalInjFuel = scalar, F32, 1184, "", 1, 0 +accumulatedValue = scalar, F32, 1188, "", 1, 0 +maxExtraPerCycle = scalar, F32, 1192, "", 1, 0 +maxExtraPerPeriod = scalar, F32, 1196, "", 1, 0 +maxInjectedPerPeriod = scalar, F32, 1200, "", 1, 0 +cycleCnt = scalar, S32, 1204, "", 1, 0 +; total TS size = 1208 +hwEventCounters1 = scalar, U32, 1208, "", 1, 0 +hwEventCounters2 = scalar, U32, 1212, "", 1, 0 +hwEventCounters3 = scalar, U32, 1216, "", 1, 0 +hwEventCounters4 = scalar, U32, 1220, "", 1, 0 +hwEventCounters5 = scalar, U32, 1224, "", 1, 0 +hwEventCounters6 = scalar, U32, 1228, "", 1, 0 +vvtCamCounter = scalar, U32, 1232, "", 1, 0 +mapVvt_MAP_AT_SPECIAL_POINT = scalar, F32, 1236, "", 1, 0 +mapVvt_MAP_AT_DIFF = scalar, F32, 1240, "", 1, 0 +mapVvt_MAP_AT_CYCLE_COUNT = scalar, U08, 1244, "", 1, 0 +mapVvt_map_peak = scalar, U08, 1245, "", 1, 0 +currentEngineDecodedPhase = scalar, F32, 1248, "deg", 1, 0 +triggerToothAngleError = scalar, F32, 1252, "deg", 1, 0 +triggerIgnoredToothCount = scalar, U08, 1256, "", 1, 0 +mapCamPrevToothAngle = scalar, F32, 1260, "deg", 1, 0 +isDecodingMapCam = bits, U32, 1264, [0:0] +; total TS size = 1268 +crankSynchronizationCounter0 = scalar, U32, 1268, "", 1, 0 +vvtSyncGapRatio0 = scalar, F32, 1272, "", 1, 0 +vvtToothDurations00 = scalar, U32, 1276, "us", 1, 0 +vvtCurrentPosition0 = scalar, F32, 1280, "sync: Primary Cam Position", 1, 0 +vvtToothPosition10 = scalar, F32, 1284, "sync: Cam Tooth Position", 1, 0 +vvtToothPosition20 = scalar, F32, 1288, "sync: Cam Tooth Position", 1, 0 +vvtToothPosition30 = scalar, F32, 1292, "sync: Cam Tooth Position", 1, 0 +vvtToothPosition40 = scalar, F32, 1296, "sync: Cam Tooth Position", 1, 0 +triggerSyncGapRatio0 = scalar, F32, 1300, "", 1, 0 +triggerStateIndex0 = scalar, U08, 1304, "", 1, 0 +vvtStateIndex0 = scalar, U08, 1305, "", 1, 0 +; total TS size = 1308 +camResyncCounter = scalar, U08, 1308, "", 1, 0 +m_hasSynchronizedPhase = bits, U32, 1312, [0:0] +; total TS size = 1316 +wallFuelCorrection = scalar, F32, 1316, "", 1, 0 +wallFuel = scalar, F32, 1320, "", 1, 0 +; total TS size = 1324 +idleState = bits, S32, 1324, [0:2], "not important" +currentIdlePosition = scalar, F32, 1328 +baseIdlePosition = scalar, F32, 1332 +idleClosedLoop = scalar, F32, 1336 +iacByTpsTaper = scalar, F32, 1340 +throttlePedalUpState = scalar, S32, 1344, "", 1, 0 +mightResetPid = bits, U32, 1348, [0:0] +shouldResetPid = bits, U32, 1348, [1:1] +wasResetPid = bits, U32, 1348, [2:2] +mustResetPid = bits, U32, 1348, [3:3] +isCranking = bits, U32, 1348, [4:4] +isIacTableForCoasting = bits, U32, 1348, [5:5] +notIdling = bits, U32, 1348, [6:6] +needReset = bits, U32, 1348, [7:7] +isInDeadZone = bits, U32, 1348, [8:8] +isBlipping = bits, U32, 1348, [9:9] +useClosedLoop = bits, U32, 1348, [10:10] +badTps = bits, U32, 1348, [11:11] +looksLikeRunning = bits, U32, 1348, [12:12] +looksLikeCoasting = bits, U32, 1348, [13:13] +looksLikeCrankToIdle = bits, U32, 1348, [14:14] +isIdleCoasting = bits, U32, 1348, [15:15] +isIdleClosedLoop = bits, U32, 1348, [16:16] +idleTarget = scalar, S32, 1352, "", 1, 0 +targetRpmByClt = scalar, S32, 1356, "", 1, 0 +targetRpmAc = scalar, S32, 1360, "", 1, 0 +iacByRpmTaper = scalar, F32, 1364 +luaAdd = scalar, F32, 1368 +; total TS size = 1372 +idlePosition0 = scalar, F32, 1372, "per", 1,0 +trim0 = scalar, F32, 1376, "", 1, 0 +luaAdjustment0 = scalar, F32, 1380, "per", 1,0 +m_wastegatePosition0 = scalar, F32, 1384, "per", 1,0 +etbFeedForward0 = scalar, F32, 1388 +etbIntegralError0 = scalar, F32, 1392, "", 1, 0 +etbCurrentTarget0 = scalar, F32, 1396, "%", 1, 0 +etbCurrentAdjustedTarget0 = scalar, F32, 1400, "%", 1, 0 +etbRevLimitActive0 = bits, U32, 1404, [0:0] +jamDetected0 = bits, U32, 1404, [1:1] +etbDutyRateOfChange0 = scalar, F32, 1408, "per", 1,0 +etbDutyAverage0 = scalar, F32, 1412, "per", 1,0 +etbTpsErrorCounter0 = scalar, U16, 1416, "count", 1,0 +etbPpsErrorCounter0 = scalar, U16, 1418, "count", 1,0 +etbErrorCode0 = scalar, S08, 1420, "", 1, 0 +tcEtbDrop0 = scalar, S08, 1421, "", 1, 0 +jamTimer0 = scalar, U16, 1422, "sec", 0.01, 0 ; total TS size = 1424 -dcOutput0 = scalar, F32, 1424, "per", 1,0 -isEnabled0_int = scalar, U08, 1428, "per", 1,0 -isEnabled0 = bits, U32, 1432, [0:0] +faultCode0 = scalar, U08, 1424, "", 1, 0 +heaterDuty0 = scalar, U08, 1425, "%", 1, 0 +pumpDuty0 = scalar, U08, 1426, "%", 1, 0 +tempC0 = scalar, U16, 1428, "C", 1, 0 +nernstVoltage0 = scalar, U16, 1430, "V", 0.001, 0 +esr0 = scalar, U16, 1432, "ohm", 1, 0 ; total TS size = 1436 -value0 = scalar, U16, 1436, "value", 1,0 -value1 = scalar, U16, 1438, "value", 1,0 -errorRate = scalar, F32, 1440, "ratio", 1,0 -; total TS size = 1444 -vvtTarget = scalar, U16, 1444, "deg", 0.1, 0 -vvtOutput = scalar, U08, 1446, "%", 0.5, 0 +dcOutput0 = scalar, F32, 1436, "per", 1,0 +isEnabled0_int = scalar, U08, 1440, "per", 1,0 +isEnabled0 = bits, U32, 1444, [0:0] ; total TS size = 1448 -lambdaCurrentlyGood = bits, U32, 1448, [0:0] -lambdaMonitorCut = bits, U32, 1448, [1:1] -lambdaTimeSinceGood = scalar, U16, 1452, "sec", 0.01, 0 +value0 = scalar, U16, 1448, "value", 1,0 +value1 = scalar, U16, 1450, "value", 1,0 +errorRate = scalar, F32, 1452, "ratio", 1,0 ; total TS size = 1456 +vvtTarget = scalar, U16, 1456, "deg", 0.1, 0 +vvtOutput = scalar, U08, 1458, "%", 0.5, 0 +; total TS size = 1460 +lambdaCurrentlyGood = bits, U32, 1460, [0:0] +lambdaMonitorCut = bits, U32, 1460, [1:1] +lambdaTimeSinceGood = scalar, U16, 1464, "sec", 0.01, 0 +; total TS size = 1468 time = { timeNow } @@ -4860,7 +4863,6 @@ entry = checkEngine, "checkEngine", int, "%d" entry = needBurn, "needBurn", int, "%d" entry = sd_msd, "SD: MSD", int, "%d" entry = isFan2On, "Radiator Fan 2", int, "%d" -entry = acrActive, "Harley ACR Active", int, "%d" entry = toothLogReady, "Tooth Logger Ready", int, "%d" entry = isTpsError, "Error: TPS", int, "%d" entry = isCltError, "Error: CLT", int, "%d" @@ -5401,7 +5403,7 @@ entry = smartChipState, "smartChipState", int, "%d" entry = smartChipRestartCounter, "smartChipRestartCounter", int, "%d" entry = smartChipAliveCounter, "smartChipAliveCounter", int, "%d" entry = startStopPhysicalState, "startStopPhysicalState", int, "%d" -entry = acrStateDup, "acrStateDup", int, "%d" +entry = acrActive, "Harley ACR Active", int, "%d" entry = acrEngineMovedRecently, "acrEngineMovedRecently", int, "%d" entry = heaterControlEnabled, "heaterControlEnabled", int, "%d" entry = luaDigitalState0, "luaDigitalState0", int, "%d" @@ -5411,6 +5413,9 @@ entry = luaDigitalState3, "luaDigitalState3", int, "%d" entry = startStopStateToggleCounter, "startStopStateToggleCounter", int, "%d" entry = egtValue1, "egtValue1", float, "%.3f" entry = egtValue2, "egtValue2", float, "%.3f" +entry = luaSoftSparkSkip, "luaSoftSparkSkip", float, "%.3f" +entry = luaHardSparkSkip, "luaHardSparkSkip", float, "%.3f" +entry = tractionControlSparkSkip, "tractionControlSparkSkip", float, "%.3f" entry = desiredRpmLimit, "User-defined RPM hard limit", int, "%d" entry = fuelInjectionCounter, "Fuel: Injection counter", int, "%d" entry = globalSparkCounter, "Ign: Spark counter", int, "%d" @@ -5912,7 +5917,7 @@ menuDialog = main subMenu = fancyHardwareDialog, "Fancy Hardware" subMenu = tractionEtbTableTbl, "Traction Control ETB Drop" subMenu = tractionTimingTableTbl, "Traction Control Timing Adjustment" - subMenu = tractionIgnitionSkipTableTbl, "Traction Control Skip Ignition" + subMenu = tractionIgnitionSkipDialog, "Traction Control Skip Ignition" subMenu = std_separator @@ -6360,7 +6365,7 @@ indicatorPanel = engine_stateIndicatorPanel, 2 indicator = {lua_luaDisableEtb}, "luaDisableEtb No", "luaDisableEtb Yes" indicator = {lua_luaIgnCut}, "luaIgnCut No", "luaIgnCut Yes" indicator = {startStopPhysicalState}, "startStopPhysicalState No", "startStopPhysicalState Yes" - indicator = {acrStateDup}, "acrStateDup No", "acrStateDup Yes" + indicator = {acrActive}, "acrActive No", "acrActive Yes" indicator = {acrEngineMovedRecently}, "acrEngineMovedRecently No", "acrEngineMovedRecently Yes" indicator = {heaterControlEnabled}, "heaterControlEnabled No", "heaterControlEnabled Yes" indicator = {luaDigitalState0}, "luaDigitalState0 No", "luaDigitalState0 Yes" @@ -6396,12 +6401,16 @@ dialog = engine_stateDialog, "engine_state" graphLine = egtValue1 graphLine = egtValue2 liveGraph = engine_state_6_Graph, "Graph", South + graphLine = luaSoftSparkSkip + graphLine = luaHardSparkSkip + graphLine = tractionControlSparkSkip graphLine = desiredRpmLimit + liveGraph = engine_state_7_Graph, "Graph", South graphLine = fuelInjectionCounter graphLine = globalSparkCounter graphLine = fuelingLoad - liveGraph = engine_state_7_Graph, "Graph", South graphLine = ignitionLoad + liveGraph = engine_state_8_Graph, "Graph", South graphLine = veTableYAxis indicatorPanel = tps_accel_stateIndicatorPanel, 2 @@ -7308,6 +7317,10 @@ dialog = lambda_monitorDialog, "lambda_monitor" panel = wastegateIdlePosLeft, West panel = wastegateIdlePosGauges, East + dialog = tractionIgnitionSkipDialog, "Traction Ignition Skip" + field = useHardSkipInTraction, useHardSkipInTraction + panel = tractionIgnitionSkipTableTbl + dialog = mc33Dialog, "Low-Z injector control PT2001" field = "SPI Chip Select", mc33816_cs field = "SPI Device", mc33816spiDevice