| Line | Branch | Decision | Exec | Source |
|---|---|---|---|---|
| 1 | #include "global.h" | |||
| 2 | #include "rusefi_enums.h" | |||
| 3 | // was generated automatically by rusEFI tool from rusefi_enums.h // by enum_to_string.jar tool on Sat Aug 23 12:26:08 UTC 2025 | |||
| 4 | // see also gen_config_and_enums.bat | |||
| 5 | ||||
| 6 | ||||
| 7 | ||||
| 8 | ✗ | const char *getCanGpioType(CanGpioType value){ | ||
| 9 | ✗ | switch(value) { | ||
| 10 | ✗ | case CanGpioType::DRT: | ||
| 11 | ✗ | return "DRT"; | ||
| 12 | ✗ | case CanGpioType::MS: | ||
| 13 | ✗ | return "MS"; | ||
| 14 | ✗ | case CanGpioType::NONE: | ||
| 15 | ✗ | return "NONE"; | ||
| 16 | } | |||
| 17 | ✗ | return NULL; | ||
| 18 | } | |||
| 19 | ✗ | const char *getGearControllerMode(GearControllerMode value){ | ||
| 20 | ✗ | switch(value) { | ||
| 21 | ✗ | case GearControllerMode::Automatic: | ||
| 22 | ✗ | return "Automatic"; | ||
| 23 | ✗ | case GearControllerMode::ButtonShift: | ||
| 24 | ✗ | return "ButtonShift"; | ||
| 25 | ✗ | case GearControllerMode::Generic: | ||
| 26 | ✗ | return "Generic"; | ||
| 27 | ✗ | case GearControllerMode::None: | ||
| 28 | ✗ | return "None"; | ||
| 29 | } | |||
| 30 | ✗ | return NULL; | ||
| 31 | } | |||
| 32 | ✗ | const char *getInjectionTimingMode(InjectionTimingMode value){ | ||
| 33 | ✗ | switch(value) { | ||
| 34 | ✗ | case InjectionTimingMode::Center: | ||
| 35 | ✗ | return "Center"; | ||
| 36 | ✗ | case InjectionTimingMode::End: | ||
| 37 | ✗ | return "End"; | ||
| 38 | ✗ | case InjectionTimingMode::Start: | ||
| 39 | ✗ | return "Start"; | ||
| 40 | } | |||
| 41 | ✗ | return NULL; | ||
| 42 | } | |||
| 43 | ✗ | const char *getInjectorNonlinearMode(InjectorNonlinearMode value){ | ||
| 44 | ✗ | switch(value) { | ||
| 45 | ✗ | case INJ_FordModel: | ||
| 46 | ✗ | return "INJ_FordModel"; | ||
| 47 | ✗ | case INJ_None: | ||
| 48 | ✗ | return "INJ_None"; | ||
| 49 | ✗ | case INJ_PolynomialAdder: | ||
| 50 | ✗ | return "INJ_PolynomialAdder"; | ||
| 51 | } | |||
| 52 | ✗ | return NULL; | ||
| 53 | } | |||
| 54 | ✗ | const char *getMsIoBoxId(MsIoBoxId value){ | ||
| 55 | ✗ | switch(value) { | ||
| 56 | ✗ | case MsIoBoxId::ID200: | ||
| 57 | ✗ | return "ID200"; | ||
| 58 | ✗ | case MsIoBoxId::ID220: | ||
| 59 | ✗ | return "ID220"; | ||
| 60 | ✗ | case MsIoBoxId::ID240: | ||
| 61 | ✗ | return "ID240"; | ||
| 62 | ✗ | case MsIoBoxId::OFF: | ||
| 63 | ✗ | return "OFF"; | ||
| 64 | } | |||
| 65 | ✗ | return NULL; | ||
| 66 | } | |||
| 67 | ✗ | const char *getMsIoBoxVss(MsIoBoxVss value){ | ||
| 68 | ✗ | switch(value) { | ||
| 69 | ✗ | case MsIoBoxVss::ALL1234: | ||
| 70 | ✗ | return "ALL1234"; | ||
| 71 | ✗ | case MsIoBoxVss::HALL34: | ||
| 72 | ✗ | return "HALL34"; | ||
| 73 | ✗ | case MsIoBoxVss::OFF: | ||
| 74 | ✗ | return "OFF"; | ||
| 75 | ✗ | case MsIoBoxVss::VR12: | ||
| 76 | ✗ | return "VR12"; | ||
| 77 | } | |||
| 78 | ✗ | return NULL; | ||
| 79 | } | |||
| 80 | ✗ | const char *getSelectedGear(SelectedGear value){ | ||
| 81 | ✗ | switch(value) { | ||
| 82 | ✗ | case SelectedGear::Drive: | ||
| 83 | ✗ | return "Drive"; | ||
| 84 | ✗ | case SelectedGear::Invalid: | ||
| 85 | ✗ | return "Invalid"; | ||
| 86 | ✗ | case SelectedGear::Low: | ||
| 87 | ✗ | return "Low"; | ||
| 88 | ✗ | case SelectedGear::Manual: | ||
| 89 | ✗ | return "Manual"; | ||
| 90 | ✗ | case SelectedGear::Manual1: | ||
| 91 | ✗ | return "Manual1"; | ||
| 92 | ✗ | case SelectedGear::Manual2: | ||
| 93 | ✗ | return "Manual2"; | ||
| 94 | ✗ | case SelectedGear::Manual3: | ||
| 95 | ✗ | return "Manual3"; | ||
| 96 | ✗ | case SelectedGear::ManualMinus: | ||
| 97 | ✗ | return "ManualMinus"; | ||
| 98 | ✗ | case SelectedGear::ManualPlus: | ||
| 99 | ✗ | return "ManualPlus"; | ||
| 100 | ✗ | case SelectedGear::Neutral: | ||
| 101 | ✗ | return "Neutral"; | ||
| 102 | ✗ | case SelectedGear::Park: | ||
| 103 | ✗ | return "Park"; | ||
| 104 | ✗ | case SelectedGear::Reverse: | ||
| 105 | ✗ | return "Reverse"; | ||
| 106 | } | |||
| 107 | ✗ | return NULL; | ||
| 108 | } | |||
| 109 | ✗ | const char *getSentEtbType(SentEtbType value){ | ||
| 110 | ✗ | switch(value) { | ||
| 111 | ✗ | case SentEtbType::CUSTOM: | ||
| 112 | ✗ | return "CUSTOM"; | ||
| 113 | ✗ | case SentEtbType::FORD_TYPE_1: | ||
| 114 | ✗ | return "FORD_TYPE_1"; | ||
| 115 | ✗ | case SentEtbType::GM_TYPE_1: | ||
| 116 | ✗ | return "GM_TYPE_1"; | ||
| 117 | ✗ | case SentEtbType::NONE: | ||
| 118 | ✗ | return "NONE"; | ||
| 119 | } | |||
| 120 | ✗ | return NULL; | ||
| 121 | } | |||
| 122 | ✗ | const char *getSentFuelHighPressureType(SentFuelHighPressureType value){ | ||
| 123 | ✗ | switch(value) { | ||
| 124 | ✗ | case SentFuelHighPressureType::GM_TYPE: | ||
| 125 | ✗ | return "GM_TYPE"; | ||
| 126 | ✗ | case SentFuelHighPressureType::NONE: | ||
| 127 | ✗ | return "NONE"; | ||
| 128 | } | |||
| 129 | ✗ | return NULL; | ||
| 130 | } | |||
| 131 | ✗ | const char *getSentInput(SentInput value){ | ||
| 132 | ✗ | switch(value) { | ||
| 133 | ✗ | case SentInput::INPUT1: | ||
| 134 | ✗ | return "INPUT1"; | ||
| 135 | ✗ | case SentInput::INPUT2: | ||
| 136 | ✗ | return "INPUT2"; | ||
| 137 | ✗ | case SentInput::INPUT3: | ||
| 138 | ✗ | return "INPUT3"; | ||
| 139 | ✗ | case SentInput::INPUT4: | ||
| 140 | ✗ | return "INPUT4"; | ||
| 141 | ✗ | case SentInput::INPUT5: | ||
| 142 | ✗ | return "INPUT5"; | ||
| 143 | ✗ | case SentInput::INPUT6: | ||
| 144 | ✗ | return "INPUT6"; | ||
| 145 | ✗ | case SentInput::INPUT7: | ||
| 146 | ✗ | return "INPUT7"; | ||
| 147 | ✗ | case SentInput::NONE: | ||
| 148 | ✗ | return "NONE"; | ||
| 149 | } | |||
| 150 | ✗ | return NULL; | ||
| 151 | } | |||
| 152 | ✗ | const char *getTransmissionControllerMode(TransmissionControllerMode value){ | ||
| 153 | ✗ | switch(value) { | ||
| 154 | ✗ | case TransmissionControllerMode::Generic4: | ||
| 155 | ✗ | return "Generic4"; | ||
| 156 | ✗ | case TransmissionControllerMode::Gm4l6x: | ||
| 157 | ✗ | return "Gm4l6x"; | ||
| 158 | ✗ | case TransmissionControllerMode::None: | ||
| 159 | ✗ | return "None"; | ||
| 160 | ✗ | case TransmissionControllerMode::SimpleTransmissionController: | ||
| 161 | ✗ | return "SimpleTransmissionController"; | ||
| 162 | } | |||
| 163 | ✗ | return NULL; | ||
| 164 | } | |||
| 165 | ✗ | const char *getTriggerWheel(TriggerWheel value){ | ||
| 166 | ✗ | switch(value) { | ||
| 167 | ✗ | case TriggerWheel::T_PRIMARY: | ||
| 168 | ✗ | return "T_PRIMARY"; | ||
| 169 | ✗ | case TriggerWheel::T_SECONDARY: | ||
| 170 | ✗ | return "T_SECONDARY"; | ||
| 171 | } | |||
| 172 | ✗ | return NULL; | ||
| 173 | } | |||
| 174 | ✗ | const char *getTsCalMode(TsCalMode value){ | ||
| 175 | ✗ | switch(value) { | ||
| 176 | ✗ | case TsCalMode::EtbKd: | ||
| 177 | ✗ | return "EtbKd"; | ||
| 178 | ✗ | case TsCalMode::EtbKi: | ||
| 179 | ✗ | return "EtbKi"; | ||
| 180 | ✗ | case TsCalMode::EtbKp: | ||
| 181 | ✗ | return "EtbKp"; | ||
| 182 | ✗ | case TsCalMode::EwgPosMax: | ||
| 183 | ✗ | return "EwgPosMax"; | ||
| 184 | ✗ | case TsCalMode::EwgPosMin: | ||
| 185 | ✗ | return "EwgPosMin"; | ||
| 186 | ✗ | case TsCalMode::None: | ||
| 187 | ✗ | return "None"; | ||
| 188 | ✗ | case TsCalMode::PedalMax: | ||
| 189 | ✗ | return "PedalMax"; | ||
| 190 | ✗ | case TsCalMode::PedalMin: | ||
| 191 | ✗ | return "PedalMin"; | ||
| 192 | ✗ | case TsCalMode::Tps1Max: | ||
| 193 | ✗ | return "Tps1Max"; | ||
| 194 | ✗ | case TsCalMode::Tps1Min: | ||
| 195 | ✗ | return "Tps1Min"; | ||
| 196 | ✗ | case TsCalMode::Tps1SecondaryMax: | ||
| 197 | ✗ | return "Tps1SecondaryMax"; | ||
| 198 | ✗ | case TsCalMode::Tps1SecondaryMin: | ||
| 199 | ✗ | return "Tps1SecondaryMin"; | ||
| 200 | ✗ | case TsCalMode::Tps2Max: | ||
| 201 | ✗ | return "Tps2Max"; | ||
| 202 | ✗ | case TsCalMode::Tps2Min: | ||
| 203 | ✗ | return "Tps2Min"; | ||
| 204 | ✗ | case TsCalMode::Tps2SecondaryMax: | ||
| 205 | ✗ | return "Tps2SecondaryMax"; | ||
| 206 | ✗ | case TsCalMode::Tps2SecondaryMin: | ||
| 207 | ✗ | return "Tps2SecondaryMin"; | ||
| 208 | } | |||
| 209 | ✗ | return NULL; | ||
| 210 | } | |||
| 211 | ✗ | const char *getUiMode(UiMode value){ | ||
| 212 | ✗ | switch(value) { | ||
| 213 | ✗ | case UiMode::FULL: | ||
| 214 | ✗ | return "FULL"; | ||
| 215 | ✗ | case UiMode::INSTALLATION: | ||
| 216 | ✗ | return "INSTALLATION"; | ||
| 217 | ✗ | case UiMode::TUNING: | ||
| 218 | ✗ | return "TUNING"; | ||
| 219 | } | |||
| 220 | ✗ | return NULL; | ||
| 221 | } | |||
| 222 | ✗ | const char *getAccel_enrichment_mode_e(accel_enrichment_mode_e value){ | ||
| 223 | ✗ | switch(value) { | ||
| 224 | ✗ | case AE_MODE_MS_ADDER: | ||
| 225 | ✗ | return "AE_MODE_MS_ADDER"; | ||
| 226 | ✗ | case AE_MODE_PERCENT_ADDER: | ||
| 227 | ✗ | return "AE_MODE_PERCENT_ADDER"; | ||
| 228 | ✗ | case AE_MODE_PREDICTIVE_MAP: | ||
| 229 | ✗ | return "AE_MODE_PREDICTIVE_MAP"; | ||
| 230 | } | |||
| 231 | ✗ | return NULL; | ||
| 232 | } | |||
| 233 | ✗ | const char *getAir_pressure_sensor_type_e(air_pressure_sensor_type_e value){ | ||
| 234 | ✗ | switch(value) { | ||
| 235 | ✗ | case MT_BOSCH_2_5: | ||
| 236 | ✗ | return "MT_BOSCH_2_5"; | ||
| 237 | ✗ | case MT_CUSTOM: | ||
| 238 | ✗ | return "MT_CUSTOM"; | ||
| 239 | ✗ | case MT_DENSO183: | ||
| 240 | ✗ | return "MT_DENSO183"; | ||
| 241 | ✗ | case MT_DODGE_NEON_2003: | ||
| 242 | ✗ | return "MT_DODGE_NEON_2003"; | ||
| 243 | ✗ | case MT_GM_1_BAR: | ||
| 244 | ✗ | return "MT_GM_1_BAR"; | ||
| 245 | ✗ | case MT_GM_2_BAR: | ||
| 246 | ✗ | return "MT_GM_2_BAR"; | ||
| 247 | ✗ | case MT_GM_3_BAR: | ||
| 248 | ✗ | return "MT_GM_3_BAR"; | ||
| 249 | ✗ | case MT_HONDA3BAR: | ||
| 250 | ✗ | return "MT_HONDA3BAR"; | ||
| 251 | ✗ | case MT_MAZDA_1_BAR: | ||
| 252 | ✗ | return "MT_MAZDA_1_BAR"; | ||
| 253 | ✗ | case MT_MPX4100: | ||
| 254 | ✗ | return "MT_MPX4100"; | ||
| 255 | ✗ | case MT_MPX4250: | ||
| 256 | ✗ | return "MT_MPX4250"; | ||
| 257 | ✗ | case MT_MPX4250A: | ||
| 258 | ✗ | return "MT_MPX4250A"; | ||
| 259 | ✗ | case MT_MPXH6300: | ||
| 260 | ✗ | return "MT_MPXH6300"; | ||
| 261 | ✗ | case MT_MPXH6400: | ||
| 262 | ✗ | return "MT_MPXH6400"; | ||
| 263 | ✗ | case MT_SUBY_DENSO: | ||
| 264 | ✗ | return "MT_SUBY_DENSO"; | ||
| 265 | ✗ | case MT_TOYOTA_89420_02010: | ||
| 266 | ✗ | return "MT_TOYOTA_89420_02010"; | ||
| 267 | } | |||
| 268 | ✗ | return NULL; | ||
| 269 | } | |||
| 270 | ✗ | const char *getAntiLagActivationMode_e(antiLagActivationMode_e value){ | ||
| 271 | ✗ | switch(value) { | ||
| 272 | ✗ | case ALWAYS_ON_ANTILAG: | ||
| 273 | ✗ | return "ALWAYS_ON_ANTILAG"; | ||
| 274 | ✗ | case LUA_ANTILAG: | ||
| 275 | ✗ | return "LUA_ANTILAG"; | ||
| 276 | ✗ | case SWITCH_INPUT_ANTILAG: | ||
| 277 | ✗ | return "SWITCH_INPUT_ANTILAG"; | ||
| 278 | } | |||
| 279 | ✗ | return NULL; | ||
| 280 | } | |||
| 281 | ✗ | const char *getBoostType_e(boostType_e value){ | ||
| 282 | ✗ | switch(value) { | ||
| 283 | ✗ | case CLOSED_LOOP: | ||
| 284 | ✗ | return "CLOSED_LOOP"; | ||
| 285 | ✗ | case OPEN_LOOP: | ||
| 286 | ✗ | return "OPEN_LOOP"; | ||
| 287 | } | |||
| 288 | ✗ | return NULL; | ||
| 289 | } | |||
| 290 | ✗ | const char *getBrain_pin_diag_e(brain_pin_diag_e value){ | ||
| 291 | ✗ | switch(value) { | ||
| 292 | ✗ | case PIN_DRIVER_OFF: | ||
| 293 | ✗ | return "PIN_DRIVER_OFF"; | ||
| 294 | ✗ | case PIN_DRIVER_OVERTEMP: | ||
| 295 | ✗ | return "PIN_DRIVER_OVERTEMP"; | ||
| 296 | ✗ | case PIN_OK: | ||
| 297 | ✗ | return "PIN_OK"; | ||
| 298 | ✗ | case PIN_OPEN: | ||
| 299 | ✗ | return "PIN_OPEN"; | ||
| 300 | ✗ | case PIN_OVERLOAD: | ||
| 301 | ✗ | return "PIN_OVERLOAD"; | ||
| 302 | ✗ | case PIN_SHORT_TO_BAT: | ||
| 303 | ✗ | return "PIN_SHORT_TO_BAT"; | ||
| 304 | ✗ | case PIN_SHORT_TO_GND: | ||
| 305 | ✗ | return "PIN_SHORT_TO_GND"; | ||
| 306 | ✗ | case PIN_UNKNOWN: | ||
| 307 | ✗ | return "PIN_UNKNOWN"; | ||
| 308 | } | |||
| 309 | ✗ | return NULL; | ||
| 310 | } | |||
| 311 | ✗ | const char *getCan_baudrate_e(can_baudrate_e value){ | ||
| 312 | ✗ | switch(value) { | ||
| 313 | ✗ | case B100KBPS: | ||
| 314 | ✗ | return "B100KBPS"; | ||
| 315 | ✗ | case B125KBPS: | ||
| 316 | ✗ | return "B125KBPS"; | ||
| 317 | ✗ | case B1MBPS: | ||
| 318 | ✗ | return "B1MBPS"; | ||
| 319 | ✗ | case B250KBPS: | ||
| 320 | ✗ | return "B250KBPS"; | ||
| 321 | ✗ | case B33KBPS: | ||
| 322 | ✗ | return "B33KBPS"; | ||
| 323 | ✗ | case B500KBPS: | ||
| 324 | ✗ | return "B500KBPS"; | ||
| 325 | ✗ | case B50KBPS: | ||
| 326 | ✗ | return "B50KBPS"; | ||
| 327 | ✗ | case B83KBPS: | ||
| 328 | ✗ | return "B83KBPS"; | ||
| 329 | } | |||
| 330 | ✗ | return NULL; | ||
| 331 | } | |||
| 332 | ✗ | const char *getCan_nbc_e(can_nbc_e value){ | ||
| 333 | ✗ | switch(value) { | ||
| 334 | ✗ | case CAN_AIM_DASH: | ||
| 335 | ✗ | return "CAN_AIM_DASH"; | ||
| 336 | ✗ | case CAN_BUS_BMW_E46: | ||
| 337 | ✗ | return "CAN_BUS_BMW_E46"; | ||
| 338 | ✗ | case CAN_BUS_BMW_E90: | ||
| 339 | ✗ | return "CAN_BUS_BMW_E90"; | ||
| 340 | ✗ | case CAN_BUS_GENESIS_COUPE: | ||
| 341 | ✗ | return "CAN_BUS_GENESIS_COUPE"; | ||
| 342 | ✗ | case CAN_BUS_HONDA_K: | ||
| 343 | ✗ | return "CAN_BUS_HONDA_K"; | ||
| 344 | ✗ | case CAN_BUS_Haltech: | ||
| 345 | ✗ | return "CAN_BUS_Haltech"; | ||
| 346 | ✗ | case CAN_BUS_MAZDA_RX8: | ||
| 347 | ✗ | return "CAN_BUS_MAZDA_RX8"; | ||
| 348 | ✗ | case CAN_BUS_MQB: | ||
| 349 | ✗ | return "CAN_BUS_MQB"; | ||
| 350 | ✗ | case CAN_BUS_MS_SIMPLE_BROADCAST: | ||
| 351 | ✗ | return "CAN_BUS_MS_SIMPLE_BROADCAST"; | ||
| 352 | ✗ | case CAN_BUS_NBC_FIAT: | ||
| 353 | ✗ | return "CAN_BUS_NBC_FIAT"; | ||
| 354 | ✗ | case CAN_BUS_NBC_NONE: | ||
| 355 | ✗ | return "CAN_BUS_NBC_NONE"; | ||
| 356 | ✗ | case CAN_BUS_NBC_VAG: | ||
| 357 | ✗ | return "CAN_BUS_NBC_VAG"; | ||
| 358 | ✗ | case CAN_BUS_NISSAN_VQ: | ||
| 359 | ✗ | return "CAN_BUS_NISSAN_VQ"; | ||
| 360 | ✗ | case CAN_BUS_W202_C180: | ||
| 361 | ✗ | return "CAN_BUS_W202_C180"; | ||
| 362 | } | |||
| 363 | ✗ | return NULL; | ||
| 364 | } | |||
| 365 | ✗ | const char *getCan_vss_nbc_e(can_vss_nbc_e value){ | ||
| 366 | ✗ | switch(value) { | ||
| 367 | ✗ | case BMW_e46: | ||
| 368 | ✗ | return "BMW_e46"; | ||
| 369 | ✗ | case BMW_e90: | ||
| 370 | ✗ | return "BMW_e90"; | ||
| 371 | ✗ | case HONDA_CIVIC9: | ||
| 372 | ✗ | return "HONDA_CIVIC9"; | ||
| 373 | ✗ | case HYUNDAI_PB: | ||
| 374 | ✗ | return "HYUNDAI_PB"; | ||
| 375 | ✗ | case NISSAN_350: | ||
| 376 | ✗ | return "NISSAN_350"; | ||
| 377 | ✗ | case W202: | ||
| 378 | ✗ | return "W202"; | ||
| 379 | } | |||
| 380 | ✗ | return NULL; | ||
| 381 | } | |||
| 382 | ✗ | const char *getCan_wbo_aem_id_e(can_wbo_aem_id_e value){ | ||
| 383 | ✗ | switch(value) { | ||
| 384 | ✗ | case WBO_AEM_ID1: | ||
| 385 | ✗ | return "WBO_AEM_ID1"; | ||
| 386 | ✗ | case WBO_AEM_ID10: | ||
| 387 | ✗ | return "WBO_AEM_ID10"; | ||
| 388 | ✗ | case WBO_AEM_ID11: | ||
| 389 | ✗ | return "WBO_AEM_ID11"; | ||
| 390 | ✗ | case WBO_AEM_ID12: | ||
| 391 | ✗ | return "WBO_AEM_ID12"; | ||
| 392 | ✗ | case WBO_AEM_ID13: | ||
| 393 | ✗ | return "WBO_AEM_ID13"; | ||
| 394 | ✗ | case WBO_AEM_ID14: | ||
| 395 | ✗ | return "WBO_AEM_ID14"; | ||
| 396 | ✗ | case WBO_AEM_ID15: | ||
| 397 | ✗ | return "WBO_AEM_ID15"; | ||
| 398 | ✗ | case WBO_AEM_ID16: | ||
| 399 | ✗ | return "WBO_AEM_ID16"; | ||
| 400 | ✗ | case WBO_AEM_ID2: | ||
| 401 | ✗ | return "WBO_AEM_ID2"; | ||
| 402 | ✗ | case WBO_AEM_ID3: | ||
| 403 | ✗ | return "WBO_AEM_ID3"; | ||
| 404 | ✗ | case WBO_AEM_ID4: | ||
| 405 | ✗ | return "WBO_AEM_ID4"; | ||
| 406 | ✗ | case WBO_AEM_ID5: | ||
| 407 | ✗ | return "WBO_AEM_ID5"; | ||
| 408 | ✗ | case WBO_AEM_ID6: | ||
| 409 | ✗ | return "WBO_AEM_ID6"; | ||
| 410 | ✗ | case WBO_AEM_ID7: | ||
| 411 | ✗ | return "WBO_AEM_ID7"; | ||
| 412 | ✗ | case WBO_AEM_ID8: | ||
| 413 | ✗ | return "WBO_AEM_ID8"; | ||
| 414 | ✗ | case WBO_AEM_ID9: | ||
| 415 | ✗ | return "WBO_AEM_ID9"; | ||
| 416 | } | |||
| 417 | ✗ | return NULL; | ||
| 418 | } | |||
| 419 | ✗ | const char *getCan_wbo_re_hwidx_e(can_wbo_re_hwidx_e value){ | ||
| 420 | ✗ | switch(value) { | ||
| 421 | ✗ | case WBO_RE_HWIDX0: | ||
| 422 | ✗ | return "WBO_RE_HWIDX0"; | ||
| 423 | ✗ | case WBO_RE_HWIDX1: | ||
| 424 | ✗ | return "WBO_RE_HWIDX1"; | ||
| 425 | ✗ | case WBO_RE_HWIDX2: | ||
| 426 | ✗ | return "WBO_RE_HWIDX2"; | ||
| 427 | ✗ | case WBO_RE_HWIDX3: | ||
| 428 | ✗ | return "WBO_RE_HWIDX3"; | ||
| 429 | ✗ | case WBO_RE_HWIDX4: | ||
| 430 | ✗ | return "WBO_RE_HWIDX4"; | ||
| 431 | ✗ | case WBO_RE_HWIDX5: | ||
| 432 | ✗ | return "WBO_RE_HWIDX5"; | ||
| 433 | ✗ | case WBO_RE_HWIDX6: | ||
| 434 | ✗ | return "WBO_RE_HWIDX6"; | ||
| 435 | ✗ | case WBO_RE_HWIDX7: | ||
| 436 | ✗ | return "WBO_RE_HWIDX7"; | ||
| 437 | } | |||
| 438 | ✗ | return NULL; | ||
| 439 | } | |||
| 440 | ✗ | const char *getCan_wbo_re_id_e(can_wbo_re_id_e value){ | ||
| 441 | ✗ | switch(value) { | ||
| 442 | ✗ | case WBO_RE_ID1: | ||
| 443 | ✗ | return "WBO_RE_ID1"; | ||
| 444 | ✗ | case WBO_RE_ID10: | ||
| 445 | ✗ | return "WBO_RE_ID10"; | ||
| 446 | ✗ | case WBO_RE_ID11: | ||
| 447 | ✗ | return "WBO_RE_ID11"; | ||
| 448 | ✗ | case WBO_RE_ID12: | ||
| 449 | ✗ | return "WBO_RE_ID12"; | ||
| 450 | ✗ | case WBO_RE_ID13: | ||
| 451 | ✗ | return "WBO_RE_ID13"; | ||
| 452 | ✗ | case WBO_RE_ID14: | ||
| 453 | ✗ | return "WBO_RE_ID14"; | ||
| 454 | ✗ | case WBO_RE_ID15: | ||
| 455 | ✗ | return "WBO_RE_ID15"; | ||
| 456 | ✗ | case WBO_RE_ID16: | ||
| 457 | ✗ | return "WBO_RE_ID16"; | ||
| 458 | ✗ | case WBO_RE_ID2: | ||
| 459 | ✗ | return "WBO_RE_ID2"; | ||
| 460 | ✗ | case WBO_RE_ID3: | ||
| 461 | ✗ | return "WBO_RE_ID3"; | ||
| 462 | ✗ | case WBO_RE_ID4: | ||
| 463 | ✗ | return "WBO_RE_ID4"; | ||
| 464 | ✗ | case WBO_RE_ID5: | ||
| 465 | ✗ | return "WBO_RE_ID5"; | ||
| 466 | ✗ | case WBO_RE_ID6: | ||
| 467 | ✗ | return "WBO_RE_ID6"; | ||
| 468 | ✗ | case WBO_RE_ID7: | ||
| 469 | ✗ | return "WBO_RE_ID7"; | ||
| 470 | ✗ | case WBO_RE_ID8: | ||
| 471 | ✗ | return "WBO_RE_ID8"; | ||
| 472 | ✗ | case WBO_RE_ID9: | ||
| 473 | ✗ | return "WBO_RE_ID9"; | ||
| 474 | } | |||
| 475 | ✗ | return NULL; | ||
| 476 | } | |||
| 477 | ✗ | const char *getCan_wbo_re_status_e(can_wbo_re_status_e value){ | ||
| 478 | ✗ | switch(value) { | ||
| 479 | ✗ | case WBO_RE_BUSY: | ||
| 480 | ✗ | return "WBO_RE_BUSY"; | ||
| 481 | ✗ | case WBO_RE_DONE: | ||
| 482 | ✗ | return "WBO_RE_DONE"; | ||
| 483 | ✗ | case WBO_RE_FAILED: | ||
| 484 | ✗ | return "WBO_RE_FAILED"; | ||
| 485 | ✗ | case WBO_RE_IDLE: | ||
| 486 | ✗ | return "WBO_RE_IDLE"; | ||
| 487 | } | |||
| 488 | ✗ | return NULL; | ||
| 489 | } | |||
| 490 | ✗ | const char *getCan_wbo_type_e(can_wbo_type_e value){ | ||
| 491 | ✗ | switch(value) { | ||
| 492 | ✗ | case AEM: | ||
| 493 | ✗ | return "AEM"; | ||
| 494 | ✗ | case DISABLED: | ||
| 495 | ✗ | return "DISABLED"; | ||
| 496 | ✗ | case RUSEFI: | ||
| 497 | ✗ | return "RUSEFI"; | ||
| 498 | } | |||
| 499 | ✗ | return NULL; | ||
| 500 | } | |||
| 501 | ✗ | const char *getCranking_condition_e(cranking_condition_e value){ | ||
| 502 | ✗ | switch(value) { | ||
| 503 | ✗ | case CCNONE: | ||
| 504 | ✗ | return "CCNONE"; | ||
| 505 | ✗ | case CC_BRAKE: | ||
| 506 | ✗ | return "CC_BRAKE"; | ||
| 507 | ✗ | case CC_CLUTCH: | ||
| 508 | ✗ | return "CC_CLUTCH"; | ||
| 509 | } | |||
| 510 | ✗ | return NULL; | ||
| 511 | } | |||
| 512 | ✗ | const char *getDc_function_e(dc_function_e value){ | ||
| 513 | ✗ | switch(value) { | ||
| 514 | ✗ | case DC_IdleValve: | ||
| 515 | ✗ | return "DC_IdleValve"; | ||
| 516 | ✗ | case DC_None: | ||
| 517 | ✗ | return "DC_None"; | ||
| 518 | ✗ | case DC_Throttle1: | ||
| 519 | ✗ | return "DC_Throttle1"; | ||
| 520 | ✗ | case DC_Throttle2: | ||
| 521 | ✗ | return "DC_Throttle2"; | ||
| 522 | ✗ | case DC_Wastegate: | ||
| 523 | ✗ | return "DC_Wastegate"; | ||
| 524 | } | |||
| 525 | ✗ | return NULL; | ||
| 526 | } | |||
| 527 | ✗ | const char *getDisplay_mode_e(display_mode_e value){ | ||
| 528 | ✗ | switch(value) { | ||
| 529 | ✗ | case DM_HD44780: | ||
| 530 | ✗ | return "DM_HD44780"; | ||
| 531 | ✗ | case DM_HD44780_OVER_PCF8574: | ||
| 532 | ✗ | return "DM_HD44780_OVER_PCF8574"; | ||
| 533 | ✗ | case DM_NONE: | ||
| 534 | ✗ | return "DM_NONE"; | ||
| 535 | } | |||
| 536 | ✗ | return NULL; | ||
| 537 | } | |||
| 538 | ✗ | const char *getEgo_sensor_e(ego_sensor_e value){ | ||
| 539 | ✗ | switch(value) { | ||
| 540 | ✗ | case ES_14Point7_Free: | ||
| 541 | ✗ | return "ES_14Point7_Free"; | ||
| 542 | ✗ | case ES_AEM: | ||
| 543 | ✗ | return "ES_AEM"; | ||
| 544 | ✗ | case ES_BPSX_D1: | ||
| 545 | ✗ | return "ES_BPSX_D1"; | ||
| 546 | ✗ | case ES_Custom: | ||
| 547 | ✗ | return "ES_Custom"; | ||
| 548 | ✗ | case ES_Innovate_MTX_L: | ||
| 549 | ✗ | return "ES_Innovate_MTX_L"; | ||
| 550 | ✗ | case ES_PLX: | ||
| 551 | ✗ | return "ES_PLX"; | ||
| 552 | } | |||
| 553 | ✗ | return NULL; | ||
| 554 | } | |||
| 555 | ✗ | const char *getFuel_pressure_sensor_mode_e(fuel_pressure_sensor_mode_e value){ | ||
| 556 | ✗ | switch(value) { | ||
| 557 | ✗ | case FPM_Absolute: | ||
| 558 | ✗ | return "FPM_Absolute"; | ||
| 559 | ✗ | case FPM_Differential: | ||
| 560 | ✗ | return "FPM_Differential"; | ||
| 561 | ✗ | case FPM_Gauge: | ||
| 562 | ✗ | return "FPM_Gauge"; | ||
| 563 | } | |||
| 564 | ✗ | return NULL; | ||
| 565 | } | |||
| 566 | ✗ | const char *getGear_e(gear_e value){ | ||
| 567 | ✗ | switch(value) { | ||
| 568 | ✗ | case GEAR_1: | ||
| 569 | ✗ | return "GEAR_1"; | ||
| 570 | ✗ | case GEAR_2: | ||
| 571 | ✗ | return "GEAR_2"; | ||
| 572 | ✗ | case GEAR_3: | ||
| 573 | ✗ | return "GEAR_3"; | ||
| 574 | ✗ | case GEAR_4: | ||
| 575 | ✗ | return "GEAR_4"; | ||
| 576 | ✗ | case NEUTRAL: | ||
| 577 | ✗ | return "NEUTRAL"; | ||
| 578 | ✗ | case REVERSE: | ||
| 579 | ✗ | return "REVERSE"; | ||
| 580 | } | |||
| 581 | ✗ | return NULL; | ||
| 582 | } | |||
| 583 | ✗ | const char *getGppwm_channel_e(gppwm_channel_e value){ | ||
| 584 | ✗ | switch(value) { | ||
| 585 | ✗ | case GPPWM_AccelPedal: | ||
| 586 | ✗ | return "GPPWM_AccelPedal"; | ||
| 587 | ✗ | case GPPWM_AuxLinear1: | ||
| 588 | ✗ | return "GPPWM_AuxLinear1"; | ||
| 589 | ✗ | case GPPWM_AuxLinear2: | ||
| 590 | ✗ | return "GPPWM_AuxLinear2"; | ||
| 591 | ✗ | case GPPWM_AuxLinear3: | ||
| 592 | ✗ | return "GPPWM_AuxLinear3"; | ||
| 593 | ✗ | case GPPWM_AuxLinear4: | ||
| 594 | ✗ | return "GPPWM_AuxLinear4"; | ||
| 595 | ✗ | case GPPWM_AuxTemp1: | ||
| 596 | ✗ | return "GPPWM_AuxTemp1"; | ||
| 597 | ✗ | case GPPWM_AuxTemp2: | ||
| 598 | ✗ | return "GPPWM_AuxTemp2"; | ||
| 599 | ✗ | case GPPWM_BaroPressure: | ||
| 600 | ✗ | return "GPPWM_BaroPressure"; | ||
| 601 | ✗ | case GPPWM_Clt: | ||
| 602 | ✗ | return "GPPWM_Clt"; | ||
| 603 | ✗ | case GPPWM_DetectedGear: | ||
| 604 | ✗ | return "GPPWM_DetectedGear"; | ||
| 605 | ✗ | case GPPWM_Egt1: | ||
| 606 | ✗ | return "GPPWM_Egt1"; | ||
| 607 | ✗ | case GPPWM_Egt2: | ||
| 608 | ✗ | return "GPPWM_Egt2"; | ||
| 609 | ✗ | case GPPWM_EthanolPercent: | ||
| 610 | ✗ | return "GPPWM_EthanolPercent"; | ||
| 611 | ✗ | case GPPWM_FuelLoad: | ||
| 612 | ✗ | return "GPPWM_FuelLoad"; | ||
| 613 | ✗ | case GPPWM_FuelPressure: | ||
| 614 | ✗ | return "GPPWM_FuelPressure"; | ||
| 615 | ✗ | case GPPWM_GppwmOutput1: | ||
| 616 | ✗ | return "GPPWM_GppwmOutput1"; | ||
| 617 | ✗ | case GPPWM_GppwmOutput2: | ||
| 618 | ✗ | return "GPPWM_GppwmOutput2"; | ||
| 619 | ✗ | case GPPWM_GppwmOutput3: | ||
| 620 | ✗ | return "GPPWM_GppwmOutput3"; | ||
| 621 | ✗ | case GPPWM_GppwmOutput4: | ||
| 622 | ✗ | return "GPPWM_GppwmOutput4"; | ||
| 623 | ✗ | case GPPWM_Iat: | ||
| 624 | ✗ | return "GPPWM_Iat"; | ||
| 625 | ✗ | case GPPWM_IgnLoad: | ||
| 626 | ✗ | return "GPPWM_IgnLoad"; | ||
| 627 | ✗ | case GPPWM_LuaGauge1: | ||
| 628 | ✗ | return "GPPWM_LuaGauge1"; | ||
| 629 | ✗ | case GPPWM_LuaGauge2: | ||
| 630 | ✗ | return "GPPWM_LuaGauge2"; | ||
| 631 | ✗ | case GPPWM_Map: | ||
| 632 | ✗ | return "GPPWM_Map"; | ||
| 633 | ✗ | case GPPWM_OilPressure: | ||
| 634 | ✗ | return "GPPWM_OilPressure"; | ||
| 635 | ✗ | case GPPWM_OilTemp: | ||
| 636 | ✗ | return "GPPWM_OilTemp"; | ||
| 637 | ✗ | case GPPWM_Rpm: | ||
| 638 | ✗ | return "GPPWM_Rpm"; | ||
| 639 | ✗ | case GPPWM_ThrottleRatio: | ||
| 640 | ✗ | return "GPPWM_ThrottleRatio"; | ||
| 641 | ✗ | case GPPWM_Tps: | ||
| 642 | ✗ | return "GPPWM_Tps"; | ||
| 643 | ✗ | case GPPWM_VVT_1E: | ||
| 644 | ✗ | return "GPPWM_VVT_1E"; | ||
| 645 | ✗ | case GPPWM_VVT_1I: | ||
| 646 | ✗ | return "GPPWM_VVT_1I"; | ||
| 647 | ✗ | case GPPWM_VVT_2E: | ||
| 648 | ✗ | return "GPPWM_VVT_2E"; | ||
| 649 | ✗ | case GPPWM_VVT_2I: | ||
| 650 | ✗ | return "GPPWM_VVT_2I"; | ||
| 651 | ✗ | case GPPWM_Vbatt: | ||
| 652 | ✗ | return "GPPWM_Vbatt"; | ||
| 653 | ✗ | case GPPWM_VehicleSpeed: | ||
| 654 | ✗ | return "GPPWM_VehicleSpeed"; | ||
| 655 | ✗ | case GPPWM_Zero: | ||
| 656 | ✗ | return "GPPWM_Zero"; | ||
| 657 | } | |||
| 658 | ✗ | return NULL; | ||
| 659 | } | |||
| 660 | ✗ | const char *getGppwm_compare_mode_e(gppwm_compare_mode_e value){ | ||
| 661 | ✗ | switch(value) { | ||
| 662 | ✗ | case GPPWM_GreaterThan: | ||
| 663 | ✗ | return "GPPWM_GreaterThan"; | ||
| 664 | ✗ | case GPPWM_LessThan: | ||
| 665 | ✗ | return "GPPWM_LessThan"; | ||
| 666 | } | |||
| 667 | ✗ | return NULL; | ||
| 668 | } | |||
| 669 | ✗ | const char *getHpfp_cam_e(hpfp_cam_e value){ | ||
| 670 | ✗ | switch(value) { | ||
| 671 | ✗ | case HPFP_CAM_EX1: | ||
| 672 | ✗ | return "HPFP_CAM_EX1"; | ||
| 673 | ✗ | case HPFP_CAM_EX2: | ||
| 674 | ✗ | return "HPFP_CAM_EX2"; | ||
| 675 | ✗ | case HPFP_CAM_IN1: | ||
| 676 | ✗ | return "HPFP_CAM_IN1"; | ||
| 677 | ✗ | case HPFP_CAM_IN2: | ||
| 678 | ✗ | return "HPFP_CAM_IN2"; | ||
| 679 | ✗ | case HPFP_CAM_NONE: | ||
| 680 | ✗ | return "HPFP_CAM_NONE"; | ||
| 681 | } | |||
| 682 | ✗ | return NULL; | ||
| 683 | } | |||
| 684 | ✗ | const char *getIdle_mode_e(idle_mode_e value){ | ||
| 685 | ✗ | switch(value) { | ||
| 686 | ✗ | case idle_mode_e::IM_AUTO: | ||
| 687 | ✗ | return "IM_AUTO"; | ||
| 688 | ✗ | case idle_mode_e::IM_MANUAL: | ||
| 689 | ✗ | return "IM_MANUAL"; | ||
| 690 | } | |||
| 691 | ✗ | return NULL; | ||
| 692 | } | |||
| 693 | ✗ | const char *getIdle_state_e(idle_state_e value){ | ||
| 694 | ✗ | switch(value) { | ||
| 695 | ✗ | case BLIP: | ||
| 696 | ✗ | return "BLIP"; | ||
| 697 | ✗ | case INIT: | ||
| 698 | ✗ | return "INIT"; | ||
| 699 | ✗ | case PID_UPPER: | ||
| 700 | ✗ | return "PID_UPPER"; | ||
| 701 | ✗ | case PID_VALUE: | ||
| 702 | ✗ | return "PID_VALUE"; | ||
| 703 | ✗ | case RPM_DEAD_ZONE: | ||
| 704 | ✗ | return "RPM_DEAD_ZONE"; | ||
| 705 | ✗ | case TPS_THRESHOLD: | ||
| 706 | ✗ | return "TPS_THRESHOLD"; | ||
| 707 | } | |||
| 708 | ✗ | return NULL; | ||
| 709 | } | |||
| 710 | ✗ | const char *getIgnition_mode_e(ignition_mode_e value){ | ||
| 711 | ✗ | switch(value) { | ||
| 712 | ✗ | case IM_INDIVIDUAL_COILS: | ||
| 713 | ✗ | return "IM_INDIVIDUAL_COILS"; | ||
| 714 | ✗ | case IM_ONE_COIL: | ||
| 715 | ✗ | return "IM_ONE_COIL"; | ||
| 716 | ✗ | case IM_TWO_COILS: | ||
| 717 | ✗ | return "IM_TWO_COILS"; | ||
| 718 | ✗ | case IM_WASTED_SPARK: | ||
| 719 | ✗ | return "IM_WASTED_SPARK"; | ||
| 720 | } | |||
| 721 | ✗ | return NULL; | ||
| 722 | } | |||
| 723 | ✗ | const char *getImu_type_e(imu_type_e value){ | ||
| 724 | ✗ | switch(value) { | ||
| 725 | ✗ | case IMU_MM5_10: | ||
| 726 | ✗ | return "IMU_MM5_10"; | ||
| 727 | ✗ | case IMU_NONE: | ||
| 728 | ✗ | return "IMU_NONE"; | ||
| 729 | ✗ | case IMU_TYPE_3: | ||
| 730 | ✗ | return "IMU_TYPE_3"; | ||
| 731 | ✗ | case IMU_TYPE_4: | ||
| 732 | ✗ | return "IMU_TYPE_4"; | ||
| 733 | ✗ | case IMU_TYPE_MB_A0065422618: | ||
| 734 | ✗ | return "IMU_TYPE_MB_A0065422618"; | ||
| 735 | ✗ | case IMU_VAG: | ||
| 736 | ✗ | return "IMU_VAG"; | ||
| 737 | } | |||
| 738 | ✗ | return NULL; | ||
| 739 | } | |||
| 740 | ✗ | const char *getInjection_mode_e(injection_mode_e value){ | ||
| 741 | ✗ | switch(value) { | ||
| 742 | ✗ | case IM_BATCH: | ||
| 743 | ✗ | return "IM_BATCH"; | ||
| 744 | ✗ | case IM_SEQUENTIAL: | ||
| 745 | ✗ | return "IM_SEQUENTIAL"; | ||
| 746 | ✗ | case IM_SIMULTANEOUS: | ||
| 747 | ✗ | return "IM_SIMULTANEOUS"; | ||
| 748 | ✗ | case IM_SINGLE_POINT: | ||
| 749 | ✗ | return "IM_SINGLE_POINT"; | ||
| 750 | } | |||
| 751 | ✗ | return NULL; | ||
| 752 | } | |||
| 753 | ✗ | const char *getInjector_compensation_mode_e(injector_compensation_mode_e value){ | ||
| 754 | ✗ | switch(value) { | ||
| 755 | ✗ | case ICM_FixedRailPressure: | ||
| 756 | ✗ | return "ICM_FixedRailPressure"; | ||
| 757 | ✗ | case ICM_HPFP_Manual_Compensation: | ||
| 758 | ✗ | return "ICM_HPFP_Manual_Compensation"; | ||
| 759 | ✗ | case ICM_None: | ||
| 760 | ✗ | return "ICM_None"; | ||
| 761 | ✗ | case ICM_SensedRailPressure: | ||
| 762 | ✗ | return "ICM_SensedRailPressure"; | ||
| 763 | } | |||
| 764 | ✗ | return NULL; | ||
| 765 | } | |||
| 766 | ✗ | const char *getInjector_pressure_type_e(injector_pressure_type_e value){ | ||
| 767 | ✗ | switch(value) { | ||
| 768 | ✗ | case IPT_High: | ||
| 769 | ✗ | return "IPT_High"; | ||
| 770 | ✗ | case IPT_Low: | ||
| 771 | ✗ | return "IPT_Low"; | ||
| 772 | } | |||
| 773 | ✗ | return NULL; | ||
| 774 | } | |||
| 775 | ✗ | const char *getLaunchActivationMode_e(launchActivationMode_e value){ | ||
| 776 | ✗ | switch(value) { | ||
| 777 | ✗ | case ALWAYS_ACTIVE_LAUNCH: | ||
| 778 | ✗ | return "ALWAYS_ACTIVE_LAUNCH"; | ||
| 779 | ✗ | case CLUTCH_INPUT_LAUNCH: | ||
| 780 | ✗ | return "CLUTCH_INPUT_LAUNCH"; | ||
| 781 | ✗ | case LUA_LAUNCH: | ||
| 782 | ✗ | return "LUA_LAUNCH"; | ||
| 783 | ✗ | case STOP_INPUT_LAUNCH: | ||
| 784 | ✗ | return "STOP_INPUT_LAUNCH"; | ||
| 785 | ✗ | case SWITCH_INPUT_LAUNCH: | ||
| 786 | ✗ | return "SWITCH_INPUT_LAUNCH"; | ||
| 787 | } | |||
| 788 | ✗ | return NULL; | ||
| 789 | } | |||
| 790 | ✗ | const char *getLoad_override_e(load_override_e value){ | ||
| 791 | ✗ | switch(value) { | ||
| 792 | ✗ | case AFR_AccPedal: | ||
| 793 | ✗ | return "AFR_AccPedal"; | ||
| 794 | ✗ | case AFR_CylFilling: | ||
| 795 | ✗ | return "AFR_CylFilling"; | ||
| 796 | ✗ | case AFR_MAP: | ||
| 797 | ✗ | return "AFR_MAP"; | ||
| 798 | ✗ | case AFR_None: | ||
| 799 | ✗ | return "AFR_None"; | ||
| 800 | ✗ | case AFR_Tps: | ||
| 801 | ✗ | return "AFR_Tps"; | ||
| 802 | } | |||
| 803 | ✗ | return NULL; | ||
| 804 | } | |||
| 805 | ✗ | const char *getLua_gauge_e(lua_gauge_e value){ | ||
| 806 | ✗ | switch(value) { | ||
| 807 | ✗ | case LUA_GAUGE_1: | ||
| 808 | ✗ | return "LUA_GAUGE_1"; | ||
| 809 | ✗ | case LUA_GAUGE_2: | ||
| 810 | ✗ | return "LUA_GAUGE_2"; | ||
| 811 | ✗ | case LUA_GAUGE_3: | ||
| 812 | ✗ | return "LUA_GAUGE_3"; | ||
| 813 | ✗ | case LUA_GAUGE_4: | ||
| 814 | ✗ | return "LUA_GAUGE_4"; | ||
| 815 | ✗ | case LUA_GAUGE_5: | ||
| 816 | ✗ | return "LUA_GAUGE_5"; | ||
| 817 | ✗ | case LUA_GAUGE_6: | ||
| 818 | ✗ | return "LUA_GAUGE_6"; | ||
| 819 | ✗ | case LUA_GAUGE_7: | ||
| 820 | ✗ | return "LUA_GAUGE_7"; | ||
| 821 | ✗ | case LUA_GAUGE_8: | ||
| 822 | ✗ | return "LUA_GAUGE_8"; | ||
| 823 | } | |||
| 824 | ✗ | return NULL; | ||
| 825 | } | |||
| 826 | ✗ | const char *getLua_gauge_meaning_e(lua_gauge_meaning_e value){ | ||
| 827 | ✗ | switch(value) { | ||
| 828 | ✗ | case LUA_GAUGE_LOWER_BOUND: | ||
| 829 | ✗ | return "LUA_GAUGE_LOWER_BOUND"; | ||
| 830 | ✗ | case LUA_GAUGE_UPPER_BOUND: | ||
| 831 | ✗ | return "LUA_GAUGE_UPPER_BOUND"; | ||
| 832 | } | |||
| 833 | ✗ | return NULL; | ||
| 834 | } | |||
| 835 | ✗ | const char *getMc33810maxDwellTimer_e(mc33810maxDwellTimer_e value){ | ||
| 836 | ✗ | switch(value) { | ||
| 837 | ✗ | case DWELL_16MS: | ||
| 838 | ✗ | return "DWELL_16MS"; | ||
| 839 | ✗ | case DWELL_2MS: | ||
| 840 | ✗ | return "DWELL_2MS"; | ||
| 841 | ✗ | case DWELL_32MS: | ||
| 842 | ✗ | return "DWELL_32MS"; | ||
| 843 | ✗ | case DWELL_4MS: | ||
| 844 | ✗ | return "DWELL_4MS"; | ||
| 845 | ✗ | case DWELL_64MS: | ||
| 846 | ✗ | return "DWELL_64MS"; | ||
| 847 | ✗ | case DWELL_8MS: | ||
| 848 | ✗ | return "DWELL_8MS"; | ||
| 849 | } | |||
| 850 | ✗ | return NULL; | ||
| 851 | } | |||
| 852 | ✗ | const char *getNitrous_arming_method_e(nitrous_arming_method_e value){ | ||
| 853 | ✗ | switch(value) { | ||
| 854 | ✗ | case DIGITAL_SWITCH_INPUT: | ||
| 855 | ✗ | return "DIGITAL_SWITCH_INPUT"; | ||
| 856 | ✗ | case LUA_GAUGE: | ||
| 857 | ✗ | return "LUA_GAUGE"; | ||
| 858 | } | |||
| 859 | ✗ | return NULL; | ||
| 860 | } | |||
| 861 | ✗ | const char *getOperation_mode_e(operation_mode_e value){ | ||
| 862 | ✗ | switch(value) { | ||
| 863 | ✗ | case FOUR_STROKE_CAM_SENSOR: | ||
| 864 | ✗ | return "FOUR_STROKE_CAM_SENSOR"; | ||
| 865 | ✗ | case FOUR_STROKE_CRANK_SENSOR: | ||
| 866 | ✗ | return "FOUR_STROKE_CRANK_SENSOR"; | ||
| 867 | ✗ | case FOUR_STROKE_SIX_TIMES_CRANK_SENSOR: | ||
| 868 | ✗ | return "FOUR_STROKE_SIX_TIMES_CRANK_SENSOR"; | ||
| 869 | ✗ | case FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR: | ||
| 870 | ✗ | return "FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR"; | ||
| 871 | ✗ | case FOUR_STROKE_THREE_TIMES_CRANK_SENSOR: | ||
| 872 | ✗ | return "FOUR_STROKE_THREE_TIMES_CRANK_SENSOR"; | ||
| 873 | ✗ | case FOUR_STROKE_TWELVE_TIMES_CRANK_SENSOR: | ||
| 874 | ✗ | return "FOUR_STROKE_TWELVE_TIMES_CRANK_SENSOR"; | ||
| 875 | ✗ | case OM_NONE: | ||
| 876 | ✗ | return "OM_NONE"; | ||
| 877 | ✗ | case TWO_STROKE: | ||
| 878 | ✗ | return "TWO_STROKE"; | ||
| 879 | } | |||
| 880 | ✗ | return NULL; | ||
| 881 | } | |||
| 882 | ✗ | const char *getPin_input_mode_e(pin_input_mode_e value){ | ||
| 883 | ✗ | switch(value) { | ||
| 884 | ✗ | case PI_DEFAULT: | ||
| 885 | ✗ | return "PI_DEFAULT"; | ||
| 886 | ✗ | case PI_INVERTED_DEFAULT: | ||
| 887 | ✗ | return "PI_INVERTED_DEFAULT"; | ||
| 888 | ✗ | case PI_INVERTED_PULLDOWN: | ||
| 889 | ✗ | return "PI_INVERTED_PULLDOWN"; | ||
| 890 | ✗ | case PI_INVERTED_PULLUP: | ||
| 891 | ✗ | return "PI_INVERTED_PULLUP"; | ||
| 892 | ✗ | case PI_PULLDOWN: | ||
| 893 | ✗ | return "PI_PULLDOWN"; | ||
| 894 | ✗ | case PI_PULLUP: | ||
| 895 | ✗ | return "PI_PULLUP"; | ||
| 896 | } | |||
| 897 | ✗ | return NULL; | ||
| 898 | } | |||
| 899 | ✗ | const char *getPin_output_mode_e(pin_output_mode_e value){ | ||
| 900 | ✗ | switch(value) { | ||
| 901 | ✗ | case OM_DEFAULT: | ||
| 902 | ✗ | return "OM_DEFAULT"; | ||
| 903 | ✗ | case OM_INVERTED: | ||
| 904 | ✗ | return "OM_INVERTED"; | ||
| 905 | ✗ | case OM_OPENDRAIN: | ||
| 906 | ✗ | return "OM_OPENDRAIN"; | ||
| 907 | ✗ | case OM_OPENDRAIN_INVERTED: | ||
| 908 | ✗ | return "OM_OPENDRAIN_INVERTED"; | ||
| 909 | } | |||
| 910 | ✗ | return NULL; | ||
| 911 | } | |||
| 912 | ✗ | const char *getSpi_device_e(spi_device_e value){ | ||
| 913 | ✗ | switch(value) { | ||
| 914 | ✗ | case SPI_DEVICE_1: | ||
| 915 | ✗ | return "SPI_DEVICE_1"; | ||
| 916 | ✗ | case SPI_DEVICE_2: | ||
| 917 | ✗ | return "SPI_DEVICE_2"; | ||
| 918 | ✗ | case SPI_DEVICE_3: | ||
| 919 | ✗ | return "SPI_DEVICE_3"; | ||
| 920 | ✗ | case SPI_DEVICE_4: | ||
| 921 | ✗ | return "SPI_DEVICE_4"; | ||
| 922 | ✗ | case SPI_DEVICE_5: | ||
| 923 | ✗ | return "SPI_DEVICE_5"; | ||
| 924 | ✗ | case SPI_DEVICE_6: | ||
| 925 | ✗ | return "SPI_DEVICE_6"; | ||
| 926 | ✗ | case SPI_NONE: | ||
| 927 | ✗ | return "SPI_NONE"; | ||
| 928 | } | |||
| 929 | ✗ | return NULL; | ||
| 930 | } | |||
| 931 | ✗ | const char *getStepper_num_micro_steps_e(stepper_num_micro_steps_e value){ | ||
| 932 | ✗ | switch(value) { | ||
| 933 | ✗ | case STEPPER_EIGHTH: | ||
| 934 | ✗ | return "STEPPER_EIGHTH"; | ||
| 935 | ✗ | case STEPPER_FOURTH: | ||
| 936 | ✗ | return "STEPPER_FOURTH"; | ||
| 937 | ✗ | case STEPPER_FULL: | ||
| 938 | ✗ | return "STEPPER_FULL"; | ||
| 939 | ✗ | case STEPPER_HALF: | ||
| 940 | ✗ | return "STEPPER_HALF"; | ||
| 941 | } | |||
| 942 | ✗ | return NULL; | ||
| 943 | } | |||
| 944 | ✗ | const char *getStft_state_e(stft_state_e value){ | ||
| 945 | ✗ | switch(value) { | ||
| 946 | ✗ | case stftDisabledAfrOurOfRange: | ||
| 947 | ✗ | return "stftDisabledAfrOurOfRange"; | ||
| 948 | ✗ | case stftDisabledClt: | ||
| 949 | ✗ | return "stftDisabledClt"; | ||
| 950 | ✗ | case stftDisabledCrankingDelay: | ||
| 951 | ✗ | return "stftDisabledCrankingDelay"; | ||
| 952 | ✗ | case stftDisabledDFCO: | ||
| 953 | ✗ | return "stftDisabledDFCO"; | ||
| 954 | ✗ | case stftDisabledFuelCut: | ||
| 955 | ✗ | return "stftDisabledFuelCut"; | ||
| 956 | ✗ | case stftDisabledRPM: | ||
| 957 | ✗ | return "stftDisabledRPM"; | ||
| 958 | ✗ | case stftDisabledSettings: | ||
| 959 | ✗ | return "stftDisabledSettings"; | ||
| 960 | ✗ | case stftDisabledTpsAccel: | ||
| 961 | ✗ | return "stftDisabledTpsAccel"; | ||
| 962 | ✗ | case stftDisabledTuning: | ||
| 963 | ✗ | return "stftDisabledTuning"; | ||
| 964 | ✗ | case stftEnabled: | ||
| 965 | ✗ | return "stftEnabled"; | ||
| 966 | } | |||
| 967 | ✗ | return NULL; | ||
| 968 | } | |||
| 969 | ✗ | const char *getTChargeMode_e(tChargeMode_e value){ | ||
| 970 | ✗ | switch(value) { | ||
| 971 | ✗ | case TCHARGE_MODE_AIR_INTERP: | ||
| 972 | ✗ | return "TCHARGE_MODE_AIR_INTERP"; | ||
| 973 | ✗ | case TCHARGE_MODE_AIR_INTERP_TABLE: | ||
| 974 | ✗ | return "TCHARGE_MODE_AIR_INTERP_TABLE"; | ||
| 975 | ✗ | case TCHARGE_MODE_RPM_TPS: | ||
| 976 | ✗ | return "TCHARGE_MODE_RPM_TPS"; | ||
| 977 | } | |||
| 978 | ✗ | return NULL; | ||
| 979 | } | |||
| 980 | ✗ | const char *getTiming_mode_e(timing_mode_e value){ | ||
| 981 | ✗ | switch(value) { | ||
| 982 | ✗ | case TM_DYNAMIC: | ||
| 983 | ✗ | return "TM_DYNAMIC"; | ||
| 984 | ✗ | case TM_FIXED: | ||
| 985 | ✗ | return "TM_FIXED"; | ||
| 986 | } | |||
| 987 | ✗ | return NULL; | ||
| 988 | } | |||
| 989 | ✗ | const char *getTle8888_mode_e(tle8888_mode_e value){ | ||
| 990 | ✗ | switch(value) { | ||
| 991 | ✗ | case TL_AUTO: | ||
| 992 | ✗ | return "TL_AUTO"; | ||
| 993 | ✗ | case TL_HALL: | ||
| 994 | ✗ | return "TL_HALL"; | ||
| 995 | ✗ | case TL_MANUAL: | ||
| 996 | ✗ | return "TL_MANUAL"; | ||
| 997 | ✗ | case TL_SEMI_AUTO: | ||
| 998 | ✗ | return "TL_SEMI_AUTO"; | ||
| 999 | } | |||
| 1000 | ✗ | return NULL; | ||
| 1001 | } | |||
| 1002 | ✗ | const char *getTorqueReductionActivationMode_e(torqueReductionActivationMode_e value){ | ||
| 1003 | ✗ | switch(value) { | ||
| 1004 | ✗ | case LAUNCH_BUTTON: | ||
| 1005 | ✗ | return "LAUNCH_BUTTON"; | ||
| 1006 | ✗ | case TORQUE_REDUCTION_BUTTON: | ||
| 1007 | ✗ | return "TORQUE_REDUCTION_BUTTON"; | ||
| 1008 | ✗ | case TORQUE_REDUCTION_CLUTCH_DOWN_SWITCH: | ||
| 1009 | ✗ | return "TORQUE_REDUCTION_CLUTCH_DOWN_SWITCH"; | ||
| 1010 | ✗ | case TORQUE_REDUCTION_CLUTCH_UP_SWITCH: | ||
| 1011 | ✗ | return "TORQUE_REDUCTION_CLUTCH_UP_SWITCH"; | ||
| 1012 | } | |||
| 1013 | ✗ | return NULL; | ||
| 1014 | } | |||
| 1015 | ✗ | const char *getUart_device_e(uart_device_e value){ | ||
| 1016 | ✗ | switch(value) { | ||
| 1017 | ✗ | case UART_DEVICE_1: | ||
| 1018 | ✗ | return "UART_DEVICE_1"; | ||
| 1019 | ✗ | case UART_DEVICE_2: | ||
| 1020 | ✗ | return "UART_DEVICE_2"; | ||
| 1021 | ✗ | case UART_DEVICE_3: | ||
| 1022 | ✗ | return "UART_DEVICE_3"; | ||
| 1023 | ✗ | case UART_DEVICE_4: | ||
| 1024 | ✗ | return "UART_DEVICE_4"; | ||
| 1025 | ✗ | case UART_NONE: | ||
| 1026 | ✗ | return "UART_NONE"; | ||
| 1027 | } | |||
| 1028 | ✗ | return NULL; | ||
| 1029 | } | |||
| 1030 | ✗ | const char *getVe_override_e(ve_override_e value){ | ||
| 1031 | ✗ | switch(value) { | ||
| 1032 | ✗ | case VE_MAP: | ||
| 1033 | ✗ | return "VE_MAP"; | ||
| 1034 | ✗ | case VE_None: | ||
| 1035 | ✗ | return "VE_None"; | ||
| 1036 | ✗ | case VE_TPS: | ||
| 1037 | ✗ | return "VE_TPS"; | ||
| 1038 | } | |||
| 1039 | ✗ | return NULL; | ||
| 1040 | } | |||
| 1041 | ✗ | const char *getVvt_mode_e(vvt_mode_e value){ | ||
| 1042 | ✗ | switch(value) { | ||
| 1043 | ✗ | case VVT_BARRA_3_PLUS_1: | ||
| 1044 | ✗ | return "VVT_BARRA_3_PLUS_1"; | ||
| 1045 | ✗ | case VVT_BOSCH_QUICK_START: | ||
| 1046 | ✗ | return "VVT_BOSCH_QUICK_START"; | ||
| 1047 | ✗ | case VVT_CHRYSLER_PHASER: | ||
| 1048 | ✗ | return "VVT_CHRYSLER_PHASER"; | ||
| 1049 | ✗ | case VVT_CUSTOM_1: | ||
| 1050 | ✗ | return "VVT_CUSTOM_1"; | ||
| 1051 | ✗ | case VVT_CUSTOM_2: | ||
| 1052 | ✗ | return "VVT_CUSTOM_2"; | ||
| 1053 | ✗ | case VVT_CUSTOM_25: | ||
| 1054 | ✗ | return "VVT_CUSTOM_25"; | ||
| 1055 | ✗ | case VVT_CUSTOM_26: | ||
| 1056 | ✗ | return "VVT_CUSTOM_26"; | ||
| 1057 | ✗ | case VVT_DEV: | ||
| 1058 | ✗ | return "VVT_DEV"; | ||
| 1059 | ✗ | case VVT_FORD_COYOTE: | ||
| 1060 | ✗ | return "VVT_FORD_COYOTE"; | ||
| 1061 | ✗ | case VVT_FORD_ST170: | ||
| 1062 | ✗ | return "VVT_FORD_ST170"; | ||
| 1063 | ✗ | case VVT_HONDA_CBR_600: | ||
| 1064 | ✗ | return "VVT_HONDA_CBR_600"; | ||
| 1065 | ✗ | case VVT_HONDA_K_EXHAUST: | ||
| 1066 | ✗ | return "VVT_HONDA_K_EXHAUST"; | ||
| 1067 | ✗ | case VVT_HONDA_K_INTAKE: | ||
| 1068 | ✗ | return "VVT_HONDA_K_INTAKE"; | ||
| 1069 | ✗ | case VVT_HR12DDR_IN: | ||
| 1070 | ✗ | return "VVT_HR12DDR_IN"; | ||
| 1071 | ✗ | case VVT_INACTIVE: | ||
| 1072 | ✗ | return "VVT_INACTIVE"; | ||
| 1073 | ✗ | case VVT_MAP_V_TWIN: | ||
| 1074 | ✗ | return "VVT_MAP_V_TWIN"; | ||
| 1075 | ✗ | case VVT_MAZDA_L: | ||
| 1076 | ✗ | return "VVT_MAZDA_L"; | ||
| 1077 | ✗ | case VVT_MAZDA_SKYACTIV: | ||
| 1078 | ✗ | return "VVT_MAZDA_SKYACTIV"; | ||
| 1079 | ✗ | case VVT_MIATA_NB: | ||
| 1080 | ✗ | return "VVT_MIATA_NB"; | ||
| 1081 | ✗ | case VVT_MITSUBISHI_3A92: | ||
| 1082 | ✗ | return "VVT_MITSUBISHI_3A92"; | ||
| 1083 | ✗ | case VVT_MITSUBISHI_4G63: | ||
| 1084 | ✗ | return "VVT_MITSUBISHI_4G63"; | ||
| 1085 | ✗ | case VVT_MITSUBISHI_4G69: | ||
| 1086 | ✗ | return "VVT_MITSUBISHI_4G69"; | ||
| 1087 | ✗ | case VVT_MITSUBISHI_6G72: | ||
| 1088 | ✗ | return "VVT_MITSUBISHI_6G72"; | ||
| 1089 | ✗ | case VVT_NISSAN_MR: | ||
| 1090 | ✗ | return "VVT_NISSAN_MR"; | ||
| 1091 | ✗ | case VVT_NISSAN_VQ: | ||
| 1092 | ✗ | return "VVT_NISSAN_VQ"; | ||
| 1093 | ✗ | case VVT_SINGLE_TOOTH: | ||
| 1094 | ✗ | return "VVT_SINGLE_TOOTH"; | ||
| 1095 | ✗ | case VVT_SUBARU_7TOOTH: | ||
| 1096 | ✗ | return "VVT_SUBARU_7TOOTH"; | ||
| 1097 | ✗ | case VVT_TOYOTA_3TOOTH_UZ: | ||
| 1098 | ✗ | return "VVT_TOYOTA_3TOOTH_UZ"; | ||
| 1099 | ✗ | case VVT_TOYOTA_3_TOOTH: | ||
| 1100 | ✗ | return "VVT_TOYOTA_3_TOOTH"; | ||
| 1101 | ✗ | case VVT_TOYOTA_4_1: | ||
| 1102 | ✗ | return "VVT_TOYOTA_4_1"; | ||
| 1103 | ✗ | case VVT_UNUSED_17: | ||
| 1104 | ✗ | return "VVT_UNUSED_17"; | ||
| 1105 | } | |||
| 1106 | ✗ | return NULL; | ||
| 1107 | } | |||
| 1108 |