diff --git a/firmware/config/boards/kinetis/board_configuration.cpp b/firmware/config/boards/kinetis/board_configuration.cpp index 9b8d8defd7..44915dc5b4 100644 --- a/firmware/config/boards/kinetis/board_configuration.cpp +++ b/firmware/config/boards/kinetis/board_configuration.cpp @@ -26,8 +26,8 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2; engineConfiguration->useOnlyRisingEdgeForTrigger = true; - boardConfiguration->isFasterEngineSpinUpEnabled = true; - boardConfiguration->useNoiselessTriggerDecoder = true; + engineConfiguration->isFasterEngineSpinUpEnabled = true; + engineConfiguration->useNoiselessTriggerDecoder = true; setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX); @@ -72,7 +72,7 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->tpsErrorDetectionTooLow = -10; // -10% open engineConfiguration->tpsErrorDetectionTooHigh = 110; // 110% open - boardConfiguration->mapMinBufferLength = 4; + engineConfiguration->mapMinBufferLength = 4; // todo: engineConfiguration->map.sensor.hwChannel = EFI_ADC_NONE; @@ -90,9 +90,9 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->clt.adcChannel = EFI_ADC_14; - boardConfiguration->triggerInputPins[0] = GPIOE_7; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOE_7; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; engineConfiguration->tle6240spiDevice = SPI_DEVICE_1; engineConfiguration->tle6240_cs = GPIOB_0; @@ -100,14 +100,14 @@ void setBoardConfigurationOverrides(void) { // todo: int i; for (i = 0; i < INJECTION_PIN_COUNT; i++) - boardConfiguration->injectionPins[i] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[i] = GPIO_UNASSIGNED; for (i = 0; i < IGNITION_PIN_COUNT; i++) - boardConfiguration->ignitionPins[i] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[i] = GPIO_UNASSIGNED; engineConfiguration->adcVcc = 5.0f; engineConfiguration->analogInputDividerCoefficient = 1; - //boardConfiguration->isFastAdcEnabled = false; + //engineConfiguration->isFastAdcEnabled = false; // we call it here because setDefaultBoardConfiguration() is not called for DEFAULT_ENGINE_TYPE=MINIMAL_PINS setSerialConfigurationOverrides(); @@ -117,12 +117,12 @@ void setPinConfigurationOverrides(void) { } void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = true; + engineConfiguration->useSerialPort = true; engineConfiguration->binarySerialTxPin = GPIOC_7; engineConfiguration->binarySerialRxPin = GPIOC_6; engineConfiguration->consoleSerialTxPin = GPIOA_10; engineConfiguration->consoleSerialRxPin = GPIOA_11; - boardConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; + engineConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; engineConfiguration->uartConsoleSerialSpeed = SERIAL_SPEED; } diff --git a/firmware/config/boards/kinetis/config/controllers/algo/engine_configuration_generated_structures.h b/firmware/config/boards/kinetis/config/controllers/algo/engine_configuration_generated_structures.h index 845efa0091..9ae540b556 100644 --- a/firmware/config/boards/kinetis/config/controllers/algo/engine_configuration_generated_structures.h +++ b/firmware/config/boards/kinetis/config/controllers/algo/engine_configuration_generated_structures.h @@ -1,4 +1,4 @@ -// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration/rusefi_config.txt Sun Dec 08 00:34:54 EST 2019 +// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration/rusefi_config.txt Wed Dec 11 16:41:07 EST 2019 // by class com.rusefi.output.CHeaderConsumer // begin #ifndef CONFIG_BOARDS_KINETIS_CONFIG_CONTROLLERS_ALGO_ENGINE_CONFIGURATION_GENERATED_STRUCTURES_H @@ -441,564 +441,6 @@ struct etb_io { typedef struct etb_io etb_io; -// start of board_configuration_s -struct board_configuration_s { - /** - * offset 0 - */ - idle_hardware_s idle; - /** - * value between 0 and 100 used in Manual mode - * offset 8 - */ - float manIdlePosition; - /** - * offset 12 - */ - float mapFrequency0Kpa; - /** - * offset 16 - */ - float mapFrequency100Kpa; - /** - * Same RPM is used for two ways of producing simulated RPM. See also triggerSimulatorPins (with wires) - * See also directSelfStimulation (no wires, bypassing input hardware) - * rpm X - * offset 20 - */ - int triggerSimulatorFrequency; - /** - * offset 24 - */ - output_pin_e injectionPins[INJECTION_PIN_COUNT]; - /** - * offset 36 - */ - output_pin_e ignitionPins[IGNITION_PIN_COUNT]; - /** - * offset 48 - */ - pin_output_mode_e injectionPinMode; - /** - * offset 49 - */ - pin_output_mode_e ignitionPinMode; - /** - * offset 50 - */ - brain_pin_e HD44780_rs; - /** - * offset 51 - */ - brain_pin_e HD44780_e; - /** - * offset 52 - */ - brain_pin_e HD44780_db4; - /** - * offset 53 - */ - brain_pin_e HD44780_db5; - /** - * offset 54 - */ - brain_pin_e HD44780_db6; - /** - * offset 55 - */ - brain_pin_e HD44780_db7; - /** - * offset 56 - */ - brain_pin_e gps_rx_pin; - /** - * offset 57 - */ - brain_pin_e gps_tx_pin; - /** - * offset 58 - */ - output_pin_e fuelPumpPin; - /** - * offset 59 - */ - pin_output_mode_e fuelPumpPinMode; - /** - * Check engine light, also malfunction indicator light. Always blinks once on boot. - * offset 60 - */ - output_pin_e malfunctionIndicatorPin; - /** - * offset 61 - */ - pin_output_mode_e malfunctionIndicatorPinMode; - /** - * offset 62 - */ - pin_output_mode_e fanPinMode; - /** - * offset 63 - */ - output_pin_e fanPin; - /** - * some cars have a switch to indicate that clutch pedal is all the way down - * offset 64 - */ - switch_input_pin_e clutchDownPin; - /** - * offset 65 - */ - output_pin_e alternatorControlPin; - /** - * offset 66 - */ - pin_output_mode_e alternatorControlPinMode; - /** - * offset 67 - */ - pin_input_mode_e clutchDownPinMode; - /** - * offset 68 - */ - brain_pin_e digitalPotentiometerChipSelect[DIGIPOT_COUNT]; - /** - * offset 72 - */ - pin_output_mode_e electronicThrottlePin1Mode; - /** - * offset 73 - */ - brain_pin_e wboHeaterPin; - /** - * offset 74 - */ - brain_pin_e cj125CsPin; - /** - * offset 75 - */ - spi_device_e max31855spiDevice; - /** - * offset 76 - */ - brain_pin_e debugTriggerSync; - /** - * Digital Potentiometer is used by stock ECU stimulation code - * offset 77 - */ - spi_device_e digitalPotentiometerSpiDevice; - /** - * offset 78 - */ - brain_pin_e mc33972_cs; - /** - * offset 79 - */ - pin_output_mode_e mc33972_csPinMode; - /** - * Useful in Research&Development phase - * offset 80 - */ - adc_channel_e auxFastSensor1_adcChannel; - /** - * offset 81 - */ - uint8_t unused556[3]; - /** - * offset 84 - */ - float fuelLevelEmptyTankVoltage; - /** - * offset 88 - */ - float fuelLevelFullTankVoltage; - /** - * AFR, WBO, EGO - whatever you like to call it - * offset 92 - */ - ego_sensor_e afr_type; - /** - * offset 96 - */ - float fuelClosedLoopAfrLowThreshold; - /** - * offset 100 - */ - brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT]; - /** - * offset 103 - */ - pin_output_mode_e hip9011CsPinMode; - /** - * This implementation produces one pulse per engine cycle. See also dizzySparkOutputPin. - * offset 104 - */ - output_pin_e tachOutputPin; - /** - * offset 105 - */ - pin_output_mode_e tachOutputPinMode; - /** - * offset 106 - */ - output_pin_e mainRelayPin; - /** - * offset 107 - */ - brain_pin_e sdCardCsPin; - /** - * offset 108 - */ - brain_pin_e canTxPin; - /** - * offset 109 - */ - brain_pin_e canRxPin; - /** - * offset 110 - */ - pin_input_mode_e throttlePedalUpPinMode; - /** - * offset 111 - */ - brain_pin_e debugTimerCallback; - /** - * offset 112 - */ - int idleThreadPeriodMs; - /** - * offset 116 - */ - int consoleLoopPeriodMs; - /** - * offset 120 - */ - int lcdThreadPeriodMs; - /** - * offset 124 - */ - int generalPeriodicThreadPeriodMs; - /** - * offset 128 - */ - uint32_t tunerStudioSerialSpeed; - /** - * offset 132 - */ - can_device_mode_e canDeviceMode; - /** - * Each rusEfi piece can provide synthetic trigger signal for external ECU. Sometimes these wires are routed back into trigger inputs of the same rusEfi board. - * See also directSelfStimulation which is different. - * offset 136 - */ - brain_pin_e triggerSimulatorPins[TRIGGER_SIMULATOR_PIN_COUNT]; - /** - * offset 139 - */ - pin_output_mode_e triggerSimulatorPinModes[TRIGGER_SIMULATOR_PIN_COUNT]; - /** - * Narrow band o2 heater, not used for CJ125. See wboHeaterPin - * offset 142 - */ - output_pin_e o2heaterPin; - /** - * offset 143 - */ - pin_output_mode_e o2heaterPinModeTodO; - /** - offset 144 bit 0 */ - bool is_enabled_spi_1 : 1; - /** - offset 144 bit 1 */ - bool is_enabled_spi_2 : 1; - /** - offset 144 bit 2 */ - bool is_enabled_spi_3 : 1; - /** - offset 144 bit 3 */ - bool isSdCardEnabled : 1; - /** - offset 144 bit 4 */ - bool isFastAdcEnabled : 1; - /** - offset 144 bit 5 */ - bool isEngineControlEnabled : 1; - /** - offset 144 bit 6 */ - bool isHip9011Enabled : 1; - /** - offset 144 bit 7 */ - bool isVerboseAlternator : 1; - /** - offset 144 bit 8 */ - bool useSerialPort : 1; - /** - * This setting should only be used if you have a stepper motor idle valve and a stepper motor driver installed. - offset 144 bit 9 */ - bool useStepperIdle : 1; - /** - offset 144 bit 10 */ - bool enabledStep1Limiter : 1; - /** - offset 144 bit 11 */ - bool useTpicAdvancedMode : 1; - /** - offset 144 bit 12 */ - bool useLcdScreen : 1; - /** - offset 144 bit 13 */ - bool unusedAnotherOne : 1; - /** - offset 144 bit 14 */ - bool unusedOldWarmupAfr : 1; - /** - * +This will cause the alternator to be operated in a basic on or off mode, this is the simplest alternator control. - offset 144 bit 15 */ - bool onOffAlternatorLogic : 1; - /** - offset 144 bit 16 */ - bool isCJ125Enabled : 1; - /** - * Use rise or fall signal front - offset 144 bit 17 */ - bool vvtCamSensorUseRise : 1; - /** - * Useful for individual intakes - offset 144 bit 18 */ - bool measureMapOnlyInOneCylinder : 1; - /** - offset 144 bit 19 */ - bool stepperForceParkingEveryRestart : 1; - /** - * Smarter cranking logic. - * See also startOfCrankingPrimingPulse - offset 144 bit 20 */ - bool isFasterEngineSpinUpEnabled : 1; - /** - * This setting disables fuel injection while the engine is in overrun, this is useful as a fuel saving measure and to prevent back firing. - offset 144 bit 21 */ - bool coastingFuelCutEnabled : 1; - /** - * This setting allows the ECU to open the IAC during overrun conditions to help reduce engine breaking, this can be helpful for large engines in light weight cars. - offset 144 bit 22 */ - bool useIacTableForCoasting : 1; - /** - offset 144 bit 23 */ - bool useNoiselessTriggerDecoder : 1; - /** - offset 144 bit 24 */ - bool useIdleTimingPidControl : 1; - /** - offset 144 bit 25 */ - bool useTPSBasedVeTable : 1; - /** - offset 144 bit 26 */ - bool is_enabled_spi_4 : 1; - /** - offset 144 bit 27 */ - bool pauseEtbControl : 1; - /** - offset 144 bit 28 */ - bool alignEngineSnifferAtTDC : 1; - /** - * This setting allows the ETB to act as the idle air control valve and move to regulate the airflow at idle. - offset 144 bit 29 */ - bool useETBforIdleControl : 1; - /** - offset 144 bit 30 */ - bool idleIncrementalPidCic : 1; - /** - offset 144 bit 31 */ - bool unused_board_984_31 : 1; - /** - * offset 148 - */ - brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT]; - /** - * offset 152 - */ - pin_output_mode_e mainRelayPinMode; - /** - * offset 153 - */ - brain_pin_e hip9011CsPin; - /** - * offset 154 - */ - brain_pin_e hip9011IntHoldPin; - /** - * offset 155 - */ - pin_output_mode_e hip9011IntHoldPinMode; - /** - * default or inverted input - * offset 156 - */ - uint8_t logicAnalyzerMode[LOGIC_ANALYZER_CHANNEL_COUNT]; - /** - * offset 160 - */ - int unrealisticRpmThreashold; - /** - * offset 164 - */ - pin_output_mode_e gpioPinModes[FSIO_COMMAND_COUNT]; - /** - * todo: more comments - * offset 180 - */ - output_pin_e fsioOutputPins[FSIO_COMMAND_COUNT]; - /** - * offset 196 - */ - brain_pin_e max31855_cs[EGT_CHANNEL_COUNT]; - /** - * SD card logging period, in milliseconds - * offset 204 - */ - int16_t sdCardPeriodMs; - /** - * offset 206 - */ - brain_pin_e debugSetTimer; - /** - * offset 207 - */ - brain_pin_e debugMapAveraging; - /** - * offset 208 - */ - brain_pin_e starterRelayPin; - /** - * offset 209 - */ - pin_output_mode_e starterRelayPinMode; - /** - * offset 210 - */ - uint8_t unuseduartPadding1[2]; - /** - * offset 212 - */ - int mapMinBufferLength; - /** - * offset 216 - */ - int16_t idlePidDeactivationTpsThreshold; - /** - * offset 218 - */ - int16_t stepperParkingExtraSteps; - /** - * This magic property is specific to Mazda Miata NB2 - * offset 220 - */ - float miataNb2VVTRatioFrom; - /** - * This magic property is specific to Mazda Miata NB2 - * offset 224 - */ - float miataNb2VVTRatioTo; - /** - * This pin is used for debugging - snap a logic analyzer on it and see if it's ever high - * offset 228 - */ - brain_pin_e triggerErrorPin; - /** - * offset 229 - */ - pin_output_mode_e triggerErrorPinMode; - /** - * offset 230 - */ - output_pin_e acRelayPin; - /** - * offset 231 - */ - pin_output_mode_e acRelayPinMode; - /** - * offset 232 - */ - fsio_pwm_freq_t fsioFrequency[FSIO_COMMAND_COUNT]; - /** - * offset 264 - */ - fsio_setting_t fsio_setting[FSIO_COMMAND_COUNT]; - /** - * offset 328 - */ - brain_pin_e spi1mosiPin; - /** - * offset 329 - */ - brain_pin_e spi1misoPin; - /** - * offset 330 - */ - brain_pin_e spi1sckPin; - /** - * offset 331 - */ - brain_pin_e spi2mosiPin; - /** - * offset 332 - */ - brain_pin_e spi2misoPin; - /** - * offset 333 - */ - brain_pin_e spi2sckPin; - /** - * offset 334 - */ - brain_pin_e spi3mosiPin; - /** - * offset 335 - */ - brain_pin_e spi3misoPin; - /** - * offset 336 - */ - brain_pin_e spi3sckPin; - /** - * Saab Combustion Detection Module knock signal input pin - * also known as Saab Ion Sensing Module - * offset 337 - */ - brain_pin_e cdmInputPin; - /** - * offset 338 - */ - brain_pin_e joystickCenterPin; - /** - * offset 339 - */ - brain_pin_e joystickAPin; - /** - * offset 340 - */ - brain_pin_e joystickBPin; - /** - * offset 341 - */ - brain_pin_e joystickCPin; - /** - * offset 342 - */ - brain_pin_e joystickDPin; - /** - * offset 343 - */ - uart_device_e consoleUartDevice; - /** - * rusEfi console Sensor Sniffer mode - * offset 344 - */ - sensor_chart_e sensorChartMode; - /** total size 348*/ -}; - -typedef struct board_configuration_s board_configuration_s; - // start of engine_configuration_s struct engine_configuration_s { /** @@ -1449,7 +891,554 @@ struct engine_configuration_s { /** * offset 600 */ - board_configuration_s bc; + idle_hardware_s idle; + /** + * value between 0 and 100 used in Manual mode + * offset 608 + */ + float manIdlePosition; + /** + * offset 612 + */ + float mapFrequency0Kpa; + /** + * offset 616 + */ + float mapFrequency100Kpa; + /** + * Same RPM is used for two ways of producing simulated RPM. See also triggerSimulatorPins (with wires) + * See also directSelfStimulation (no wires, bypassing input hardware) + * rpm X + * offset 620 + */ + int triggerSimulatorFrequency; + /** + * offset 624 + */ + output_pin_e injectionPins[INJECTION_PIN_COUNT]; + /** + * offset 636 + */ + output_pin_e ignitionPins[IGNITION_PIN_COUNT]; + /** + * offset 648 + */ + pin_output_mode_e injectionPinMode; + /** + * offset 649 + */ + pin_output_mode_e ignitionPinMode; + /** + * offset 650 + */ + brain_pin_e HD44780_rs; + /** + * offset 651 + */ + brain_pin_e HD44780_e; + /** + * offset 652 + */ + brain_pin_e HD44780_db4; + /** + * offset 653 + */ + brain_pin_e HD44780_db5; + /** + * offset 654 + */ + brain_pin_e HD44780_db6; + /** + * offset 655 + */ + brain_pin_e HD44780_db7; + /** + * offset 656 + */ + brain_pin_e gps_rx_pin; + /** + * offset 657 + */ + brain_pin_e gps_tx_pin; + /** + * offset 658 + */ + output_pin_e fuelPumpPin; + /** + * offset 659 + */ + pin_output_mode_e fuelPumpPinMode; + /** + * Check engine light, also malfunction indicator light. Always blinks once on boot. + * offset 660 + */ + output_pin_e malfunctionIndicatorPin; + /** + * offset 661 + */ + pin_output_mode_e malfunctionIndicatorPinMode; + /** + * offset 662 + */ + pin_output_mode_e fanPinMode; + /** + * offset 663 + */ + output_pin_e fanPin; + /** + * some cars have a switch to indicate that clutch pedal is all the way down + * offset 664 + */ + switch_input_pin_e clutchDownPin; + /** + * offset 665 + */ + output_pin_e alternatorControlPin; + /** + * offset 666 + */ + pin_output_mode_e alternatorControlPinMode; + /** + * offset 667 + */ + pin_input_mode_e clutchDownPinMode; + /** + * offset 668 + */ + brain_pin_e digitalPotentiometerChipSelect[DIGIPOT_COUNT]; + /** + * offset 672 + */ + pin_output_mode_e electronicThrottlePin1Mode; + /** + * offset 673 + */ + brain_pin_e wboHeaterPin; + /** + * offset 674 + */ + brain_pin_e cj125CsPin; + /** + * offset 675 + */ + spi_device_e max31855spiDevice; + /** + * offset 676 + */ + brain_pin_e debugTriggerSync; + /** + * Digital Potentiometer is used by stock ECU stimulation code + * offset 677 + */ + spi_device_e digitalPotentiometerSpiDevice; + /** + * offset 678 + */ + brain_pin_e mc33972_cs; + /** + * offset 679 + */ + pin_output_mode_e mc33972_csPinMode; + /** + * Useful in Research&Development phase + * offset 680 + */ + adc_channel_e auxFastSensor1_adcChannel; + /** + * offset 681 + */ + uint8_t unused556[3]; + /** + * offset 684 + */ + float fuelLevelEmptyTankVoltage; + /** + * offset 688 + */ + float fuelLevelFullTankVoltage; + /** + * AFR, WBO, EGO - whatever you like to call it + * offset 692 + */ + ego_sensor_e afr_type; + /** + * offset 696 + */ + float fuelClosedLoopAfrLowThreshold; + /** + * offset 700 + */ + brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT]; + /** + * offset 703 + */ + pin_output_mode_e hip9011CsPinMode; + /** + * This implementation produces one pulse per engine cycle. See also dizzySparkOutputPin. + * offset 704 + */ + output_pin_e tachOutputPin; + /** + * offset 705 + */ + pin_output_mode_e tachOutputPinMode; + /** + * offset 706 + */ + output_pin_e mainRelayPin; + /** + * offset 707 + */ + brain_pin_e sdCardCsPin; + /** + * offset 708 + */ + brain_pin_e canTxPin; + /** + * offset 709 + */ + brain_pin_e canRxPin; + /** + * offset 710 + */ + pin_input_mode_e throttlePedalUpPinMode; + /** + * offset 711 + */ + brain_pin_e debugTimerCallback; + /** + * offset 712 + */ + int idleThreadPeriodMs; + /** + * offset 716 + */ + int consoleLoopPeriodMs; + /** + * offset 720 + */ + int lcdThreadPeriodMs; + /** + * offset 724 + */ + int generalPeriodicThreadPeriodMs; + /** + * offset 728 + */ + uint32_t tunerStudioSerialSpeed; + /** + * offset 732 + */ + can_device_mode_e canDeviceMode; + /** + * Each rusEfi piece can provide synthetic trigger signal for external ECU. Sometimes these wires are routed back into trigger inputs of the same rusEfi board. + * See also directSelfStimulation which is different. + * offset 736 + */ + brain_pin_e triggerSimulatorPins[TRIGGER_SIMULATOR_PIN_COUNT]; + /** + * offset 739 + */ + pin_output_mode_e triggerSimulatorPinModes[TRIGGER_SIMULATOR_PIN_COUNT]; + /** + * Narrow band o2 heater, not used for CJ125. See wboHeaterPin + * offset 742 + */ + output_pin_e o2heaterPin; + /** + * offset 743 + */ + pin_output_mode_e o2heaterPinModeTodO; + /** + offset 744 bit 0 */ + bool is_enabled_spi_1 : 1; + /** + offset 744 bit 1 */ + bool is_enabled_spi_2 : 1; + /** + offset 744 bit 2 */ + bool is_enabled_spi_3 : 1; + /** + offset 744 bit 3 */ + bool isSdCardEnabled : 1; + /** + offset 744 bit 4 */ + bool isFastAdcEnabled : 1; + /** + offset 744 bit 5 */ + bool isEngineControlEnabled : 1; + /** + offset 744 bit 6 */ + bool isHip9011Enabled : 1; + /** + offset 744 bit 7 */ + bool isVerboseAlternator : 1; + /** + offset 744 bit 8 */ + bool useSerialPort : 1; + /** + * This setting should only be used if you have a stepper motor idle valve and a stepper motor driver installed. + offset 744 bit 9 */ + bool useStepperIdle : 1; + /** + offset 744 bit 10 */ + bool enabledStep1Limiter : 1; + /** + offset 744 bit 11 */ + bool useTpicAdvancedMode : 1; + /** + offset 744 bit 12 */ + bool useLcdScreen : 1; + /** + offset 744 bit 13 */ + bool unusedAnotherOne : 1; + /** + offset 744 bit 14 */ + bool unusedOldWarmupAfr : 1; + /** + * +This will cause the alternator to be operated in a basic on or off mode, this is the simplest alternator control. + offset 744 bit 15 */ + bool onOffAlternatorLogic : 1; + /** + offset 744 bit 16 */ + bool isCJ125Enabled : 1; + /** + * Use rise or fall signal front + offset 744 bit 17 */ + bool vvtCamSensorUseRise : 1; + /** + * Useful for individual intakes + offset 744 bit 18 */ + bool measureMapOnlyInOneCylinder : 1; + /** + offset 744 bit 19 */ + bool stepperForceParkingEveryRestart : 1; + /** + * Smarter cranking logic. + * See also startOfCrankingPrimingPulse + offset 744 bit 20 */ + bool isFasterEngineSpinUpEnabled : 1; + /** + * This setting disables fuel injection while the engine is in overrun, this is useful as a fuel saving measure and to prevent back firing. + offset 744 bit 21 */ + bool coastingFuelCutEnabled : 1; + /** + * This setting allows the ECU to open the IAC during overrun conditions to help reduce engine breaking, this can be helpful for large engines in light weight cars. + offset 744 bit 22 */ + bool useIacTableForCoasting : 1; + /** + offset 744 bit 23 */ + bool useNoiselessTriggerDecoder : 1; + /** + offset 744 bit 24 */ + bool useIdleTimingPidControl : 1; + /** + offset 744 bit 25 */ + bool useTPSBasedVeTable : 1; + /** + offset 744 bit 26 */ + bool is_enabled_spi_4 : 1; + /** + offset 744 bit 27 */ + bool pauseEtbControl : 1; + /** + offset 744 bit 28 */ + bool alignEngineSnifferAtTDC : 1; + /** + * This setting allows the ETB to act as the idle air control valve and move to regulate the airflow at idle. + offset 744 bit 29 */ + bool useETBforIdleControl : 1; + /** + offset 744 bit 30 */ + bool idleIncrementalPidCic : 1; + /** + offset 744 bit 31 */ + bool unused_board_984_31 : 1; + /** + * offset 748 + */ + brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT]; + /** + * offset 752 + */ + pin_output_mode_e mainRelayPinMode; + /** + * offset 753 + */ + brain_pin_e hip9011CsPin; + /** + * offset 754 + */ + brain_pin_e hip9011IntHoldPin; + /** + * offset 755 + */ + pin_output_mode_e hip9011IntHoldPinMode; + /** + * default or inverted input + * offset 756 + */ + uint8_t logicAnalyzerMode[LOGIC_ANALYZER_CHANNEL_COUNT]; + /** + * offset 760 + */ + int unrealisticRpmThreashold; + /** + * offset 764 + */ + pin_output_mode_e gpioPinModes[FSIO_COMMAND_COUNT]; + /** + * todo: more comments + * offset 780 + */ + output_pin_e fsioOutputPins[FSIO_COMMAND_COUNT]; + /** + * offset 796 + */ + brain_pin_e max31855_cs[EGT_CHANNEL_COUNT]; + /** + * SD card logging period, in milliseconds + * offset 804 + */ + int16_t sdCardPeriodMs; + /** + * offset 806 + */ + brain_pin_e debugSetTimer; + /** + * offset 807 + */ + brain_pin_e debugMapAveraging; + /** + * offset 808 + */ + brain_pin_e starterRelayPin; + /** + * offset 809 + */ + pin_output_mode_e starterRelayPinMode; + /** + * offset 810 + */ + uint8_t unuseduartPadding1[2]; + /** + * offset 812 + */ + int mapMinBufferLength; + /** + * offset 816 + */ + int16_t idlePidDeactivationTpsThreshold; + /** + * offset 818 + */ + int16_t stepperParkingExtraSteps; + /** + * This magic property is specific to Mazda Miata NB2 + * offset 820 + */ + float miataNb2VVTRatioFrom; + /** + * This magic property is specific to Mazda Miata NB2 + * offset 824 + */ + float miataNb2VVTRatioTo; + /** + * This pin is used for debugging - snap a logic analyzer on it and see if it's ever high + * offset 828 + */ + brain_pin_e triggerErrorPin; + /** + * offset 829 + */ + pin_output_mode_e triggerErrorPinMode; + /** + * offset 830 + */ + output_pin_e acRelayPin; + /** + * offset 831 + */ + pin_output_mode_e acRelayPinMode; + /** + * offset 832 + */ + fsio_pwm_freq_t fsioFrequency[FSIO_COMMAND_COUNT]; + /** + * offset 864 + */ + fsio_setting_t fsio_setting[FSIO_COMMAND_COUNT]; + /** + * offset 928 + */ + brain_pin_e spi1mosiPin; + /** + * offset 929 + */ + brain_pin_e spi1misoPin; + /** + * offset 930 + */ + brain_pin_e spi1sckPin; + /** + * offset 931 + */ + brain_pin_e spi2mosiPin; + /** + * offset 932 + */ + brain_pin_e spi2misoPin; + /** + * offset 933 + */ + brain_pin_e spi2sckPin; + /** + * offset 934 + */ + brain_pin_e spi3mosiPin; + /** + * offset 935 + */ + brain_pin_e spi3misoPin; + /** + * offset 936 + */ + brain_pin_e spi3sckPin; + /** + * Saab Combustion Detection Module knock signal input pin + * also known as Saab Ion Sensing Module + * offset 937 + */ + brain_pin_e cdmInputPin; + /** + * offset 938 + */ + brain_pin_e joystickCenterPin; + /** + * offset 939 + */ + brain_pin_e joystickAPin; + /** + * offset 940 + */ + brain_pin_e joystickBPin; + /** + * offset 941 + */ + brain_pin_e joystickCPin; + /** + * offset 942 + */ + brain_pin_e joystickDPin; + /** + * offset 943 + */ + uart_device_e consoleUartDevice; + /** + * rusEfi console Sensor Sniffer mode + * offset 944 + */ + sensor_chart_e sensorChartMode; /** * offset 948 */ @@ -2939,4 +2928,4 @@ typedef struct persistent_config_s persistent_config_s; #endif // end -// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration/rusefi_config.txt Sun Dec 08 00:34:54 EST 2019 +// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration/rusefi_config.txt Wed Dec 11 16:41:07 EST 2019 diff --git a/firmware/config/boards/kinetis/config/controllers/algo/rusefi_generated.h b/firmware/config/boards/kinetis/config/controllers/algo/rusefi_generated.h index 76440ba83a..38a8b9a7a1 100644 --- a/firmware/config/boards/kinetis/config/controllers/algo/rusefi_generated.h +++ b/firmware/config/boards/kinetis/config/controllers/algo/rusefi_generated.h @@ -246,8 +246,6 @@ #define baroSensor_offset_hex 248 #define baroSensor_type_offset 592 #define baroSensor_type_offset_hex 250 -#define bc_offset 600 -#define bc_offset_hex 258 #define binarySerialRxPin_offset 1815 #define binarySerialRxPin_offset_hex 717 #define binarySerialTxPin_offset 1814 diff --git a/firmware/config/boards/me7_pnp/board_configuration.cpp b/firmware/config/boards/me7_pnp/board_configuration.cpp index 1fb7bbed46..b4c5bce7cf 100644 --- a/firmware/config/boards/me7_pnp/board_configuration.cpp +++ b/firmware/config/boards/me7_pnp/board_configuration.cpp @@ -19,7 +19,7 @@ EXTERN_ENGINE static void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { } void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = true; + engineConfiguration->useSerialPort = true; //UART @@ -36,11 +36,11 @@ void setPinConfigurationOverrides(void) { engineConfiguration->baroSensor.hwChannel = EFI_ADC_NONE; engineConfiguration->afr.hwChannel = EFI_ADC_NONE; - boardConfiguration->ignitionPins[8] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[9] = GPIO_UNASSIGNED; - boardConfiguration->mainRelayPin = GPIO_UNASSIGNED; - boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; - boardConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[8] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[9] = GPIO_UNASSIGNED; + engineConfiguration->mainRelayPin = GPIO_UNASSIGNED; + engineConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; + engineConfiguration->fanPin = GPIO_UNASSIGNED; } void setBoardConfigurationOverrides(void) { @@ -49,33 +49,33 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->dizzySparkOutputPin = GPIO_UNASSIGNED; engineConfiguration->externalKnockSenseAdc = EFI_ADC_NONE; engineConfiguration->displayMode = DM_NONE; - boardConfiguration->HD44780_rs = GPIO_UNASSIGNED; - boardConfiguration->HD44780_e = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db4 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db5 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db6 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db7 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_rs = GPIO_UNASSIGNED; + engineConfiguration->HD44780_e = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db4 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db5 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db6 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db7 = GPIO_UNASSIGNED; for (int i = 0; i < DIGIPOT_COUNT; i++) { - boardConfiguration->digitalPotentiometerChipSelect[i] = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[i] = GPIO_UNASSIGNED; } - boardConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; - boardConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; - boardConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; - boardConfiguration->max31855spiDevice = SPI_NONE; + engineConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; + engineConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; + engineConfiguration->max31855spiDevice = SPI_NONE; engineConfiguration->warningLedPin = GPIO_UNASSIGNED; engineConfiguration->runningLedPin = GPIO_UNASSIGNED; - boardConfiguration->useStepperIdle = false; - boardConfiguration->idle.stepperDirectionPin = GPIO_UNASSIGNED; - boardConfiguration->idle.stepperStepPin = GPIO_UNASSIGNED; + engineConfiguration->useStepperIdle = false; + engineConfiguration->idle.stepperDirectionPin = GPIO_UNASSIGNED; + engineConfiguration->idle.stepperStepPin = GPIO_UNASSIGNED; engineConfiguration->stepperEnablePin = GPIO_UNASSIGNED; engineConfiguration->stepperEnablePinMode = OM_DEFAULT; - boardConfiguration->injectionPins[8] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[9] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[10] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[11] = GPIO_UNASSIGNED; - boardConfiguration->isHip9011Enabled = false; + engineConfiguration->injectionPins[8] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[9] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[10] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[11] = GPIO_UNASSIGNED; + engineConfiguration->isHip9011Enabled = false; } diff --git a/firmware/config/boards/microrusefi/board_configuration.cpp b/firmware/config/boards/microrusefi/board_configuration.cpp index c23f373100..d7d800c212 100644 --- a/firmware/config/boards/microrusefi/board_configuration.cpp +++ b/firmware/config/boards/microrusefi/board_configuration.cpp @@ -19,32 +19,32 @@ EXTERN_ENGINE; static void setInjectorPins() { - boardConfiguration->injectionPins[0] = GPIOE_14; - boardConfiguration->injectionPins[1] = GPIOE_13; - boardConfiguration->injectionPins[2] = GPIOE_12; - boardConfiguration->injectionPins[3] = GPIOE_11; + engineConfiguration->injectionPins[0] = GPIOE_14; + engineConfiguration->injectionPins[1] = GPIOE_13; + engineConfiguration->injectionPins[2] = GPIOE_12; + engineConfiguration->injectionPins[3] = GPIOE_11; // Disable remainder for (int i = 4; i < INJECTION_PIN_COUNT;i++) { - boardConfiguration->injectionPins[i] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[i] = GPIO_UNASSIGNED; } - boardConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPinMode = OM_DEFAULT; } static void setIgnitionPins() { // todo: I wonder if these are not right in light of the network rename and the +12 VP issue? - boardConfiguration->ignitionPins[0] = GPIOD_4; - boardConfiguration->ignitionPins[1] = GPIOD_3; - boardConfiguration->ignitionPins[2] = GPIOD_2; - boardConfiguration->ignitionPins[3] = GPIOD_1; + engineConfiguration->ignitionPins[0] = GPIOD_4; + engineConfiguration->ignitionPins[1] = GPIOD_3; + engineConfiguration->ignitionPins[2] = GPIOD_2; + engineConfiguration->ignitionPins[3] = GPIOD_1; // disable remainder for (int i = 4; i < IGNITION_PIN_COUNT; i++) { - boardConfiguration->ignitionPins[i] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[i] = GPIO_UNASSIGNED; } - boardConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPinMode = OM_DEFAULT; } static void setLedPins() { @@ -55,7 +55,7 @@ static void setLedPins() { engineConfiguration->communicationLedPin = GPIOE_2; // d23 = blue #endif /* EFI_COMMUNICATION_PIN */ engineConfiguration->runningLedPin = GPIOE_4; // d22 = green - boardConfiguration->triggerErrorPin = GPIOE_1; // d27 = orange + engineConfiguration->triggerErrorPin = GPIOE_1; // d27 = orange } static void setupVbatt() { @@ -71,12 +71,12 @@ static void setupVbatt() { static void setupTle8888() { // Enable spi3 - boardConfiguration->is_enabled_spi_3 = true; + engineConfiguration->is_enabled_spi_3 = true; // Wire up spi3 - boardConfiguration->spi3mosiPin = GPIOB_5; - boardConfiguration->spi3misoPin = GPIOB_4; - boardConfiguration->spi3sckPin = GPIOB_3; + engineConfiguration->spi3mosiPin = GPIOB_5; + engineConfiguration->spi3misoPin = GPIOB_4; + engineConfiguration->spi3sckPin = GPIOB_3; // Chip select engineConfiguration->tle8888_cs = GPIOD_5; @@ -124,9 +124,9 @@ static void setupEtb() { static void setupDefaultSensorInputs() { // trigger inputs // tle8888 VR conditioner - boardConfiguration->triggerInputPins[0] = GPIOC_6; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOC_6; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; // Direct hall-only cam input engineConfiguration->camInputs[0] = GPIOA_5; @@ -157,7 +157,7 @@ void setPinConfigurationOverrides(void) { } void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = false; + engineConfiguration->useSerialPort = false; engineConfiguration->binarySerialTxPin = GPIO_UNASSIGNED; engineConfiguration->binarySerialRxPin = GPIO_UNASSIGNED; engineConfiguration->consoleSerialTxPin = GPIO_UNASSIGNED; @@ -185,16 +185,16 @@ void setBoardConfigurationOverrides(void) { // todo: maybe even set EFI_MAIN_RELAY_CONTROL to FALSE for MRE configuration // TLE8888 half bridges (pushpull, lowside, or high-low) TLE8888_IN11 / TLE8888_OUT21 // GPIOE_8: "35 - GP Out 1" - boardConfiguration->fuelPumpPin = GPIOE_8; + engineConfiguration->fuelPumpPin = GPIOE_8; // TLE8888 high current low side: VVT2 IN9 / OUT5 // GPIOE_10: "3 - Lowside 2" - boardConfiguration->idle.solenoidPin = GPIOE_10; + engineConfiguration->idle.solenoidPin = GPIOE_10; // TLE8888_PIN_22: "34 - GP Out 2" - boardConfiguration->fanPin = TLE8888_PIN_22; + engineConfiguration->fanPin = TLE8888_PIN_22; // "required" hardware is done - set some reasonable defaults setupDefaultSensorInputs(); diff --git a/firmware/config/boards/nucleo_f767/board_configuration.cpp b/firmware/config/boards/nucleo_f767/board_configuration.cpp index c4bbf9ae07..fda5cb365d 100644 --- a/firmware/config/boards/nucleo_f767/board_configuration.cpp +++ b/firmware/config/boards/nucleo_f767/board_configuration.cpp @@ -24,12 +24,12 @@ void setPinConfigurationOverrides(void) { } void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = true; + engineConfiguration->useSerialPort = true; engineConfiguration->binarySerialTxPin = GPIOD_8; engineConfiguration->binarySerialRxPin = GPIOD_9; engineConfiguration->consoleSerialTxPin = GPIOD_8; engineConfiguration->consoleSerialRxPin = GPIOD_9; - boardConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; + engineConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; engineConfiguration->uartConsoleSerialSpeed = SERIAL_SPEED; } @@ -56,28 +56,28 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->dizzySparkOutputPin = GPIO_UNASSIGNED; engineConfiguration->externalKnockSenseAdc = EFI_ADC_NONE; engineConfiguration->displayMode = DM_NONE; - boardConfiguration->HD44780_rs = GPIO_UNASSIGNED; - boardConfiguration->HD44780_e = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db4 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db5 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db6 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db7 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_rs = GPIO_UNASSIGNED; + engineConfiguration->HD44780_e = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db4 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db5 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db6 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db7 = GPIO_UNASSIGNED; for (int i = 0; i < DIGIPOT_COUNT ; i++) { - boardConfiguration->digitalPotentiometerChipSelect[i] = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[i] = GPIO_UNASSIGNED; } - boardConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; - boardConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; engineConfiguration->vehicleSpeedSensorInputPin = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; - boardConfiguration->max31855spiDevice = SPI_NONE; + engineConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; + engineConfiguration->max31855spiDevice = SPI_NONE; ///////////////////////////////////////////////////////// - boardConfiguration->is_enabled_spi_1 = false; - boardConfiguration->is_enabled_spi_2 = false; - boardConfiguration->is_enabled_spi_3 = false; + engineConfiguration->is_enabled_spi_1 = false; + engineConfiguration->is_enabled_spi_2 = false; + engineConfiguration->is_enabled_spi_3 = false; } void setAdcChannelOverrides(void) { diff --git a/firmware/config/boards/prometheus/board_configuration.cpp b/firmware/config/boards/prometheus/board_configuration.cpp index 2faf3efe50..ebd518aa08 100644 --- a/firmware/config/boards/prometheus/board_configuration.cpp +++ b/firmware/config/boards/prometheus/board_configuration.cpp @@ -63,22 +63,22 @@ static void setPrometheusDefaults(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->tpsErrorDetectionTooLow = -10; // -10% open engineConfiguration->tpsErrorDetectionTooHigh = 110; // 110% open - boardConfiguration->mapMinBufferLength = 4; + engineConfiguration->mapMinBufferLength = 4; } void setPinConfigurationOverrides(void) { #if 0 - boardConfiguration->injectionPins[0] = is469 ? GPIOD_9 : GPIOB_14; // #1 - boardConfiguration->injectionPins[1] = is469 ? GPIOD_15 : GPIOC_7; // #2 - boardConfiguration->injectionPins[2] = is469 ? GPIOD_10 : GPIOB_15; // #3 - boardConfiguration->injectionPins[3] = is469 ? GPIOD_14 : GPIOC_6; // #4 + engineConfiguration->injectionPins[0] = is469 ? GPIOD_9 : GPIOB_14; // #1 + engineConfiguration->injectionPins[1] = is469 ? GPIOD_15 : GPIOC_7; // #2 + engineConfiguration->injectionPins[2] = is469 ? GPIOD_10 : GPIOB_15; // #3 + engineConfiguration->injectionPins[3] = is469 ? GPIOD_14 : GPIOC_6; // #4 - boardConfiguration->ignitionPins[0] = GPIOA_10; - boardConfiguration->ignitionPins[1] = GPIOA_9; - boardConfiguration->ignitionPins[2] = GPIOA_8; - boardConfiguration->ignitionPins[3] = GPIOA_11; - boardConfiguration->ignitionPinMode = OM_INVERTED; + engineConfiguration->ignitionPins[0] = GPIOA_10; + engineConfiguration->ignitionPins[1] = GPIOA_9; + engineConfiguration->ignitionPins[2] = GPIOA_8; + engineConfiguration->ignitionPins[3] = GPIOA_11; + engineConfiguration->ignitionPinMode = OM_INVERTED; enginePins.startInjectionPins(); enginePins.startIgnitionPins(); @@ -109,20 +109,20 @@ void setPinConfigurationOverrides(void) { } void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = true; + engineConfiguration->useSerialPort = true; engineConfiguration->binarySerialTxPin = GPIOA_0; engineConfiguration->binarySerialRxPin = GPIOA_1; engineConfiguration->consoleSerialTxPin = GPIOA_0; engineConfiguration->consoleSerialRxPin = GPIOA_1; - boardConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; + engineConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; engineConfiguration->uartConsoleSerialSpeed = SERIAL_SPEED; } void setSdCardConfigurationOverrides(void) { - boardConfiguration->is_enabled_spi_1 = true; + engineConfiguration->is_enabled_spi_1 = true; engineConfiguration->sdCardSpiDevice = SPI_DEVICE_1; - boardConfiguration->sdCardCsPin = GPIOA_2; - boardConfiguration->isSdCardEnabled = true; + engineConfiguration->sdCardCsPin = GPIOA_2; + engineConfiguration->isSdCardEnabled = true; } /** @@ -148,24 +148,24 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->baroSensor.hwChannel = EFI_ADC_NONE; engineConfiguration->throttlePedalPositionAdcChannel = EFI_ADC_NONE; - boardConfiguration->injectionPins[0] = is469 ? GPIOD_9 : GPIOB_14; // #1 - boardConfiguration->injectionPins[1] = is469 ? GPIOD_15 : GPIOC_7; // #2 - boardConfiguration->injectionPins[2] = is469 ? GPIOD_10 : GPIOB_15; // #3 - boardConfiguration->injectionPins[3] = is469 ? GPIOD_14 : GPIOC_6; // #4 + engineConfiguration->injectionPins[0] = is469 ? GPIOD_9 : GPIOB_14; // #1 + engineConfiguration->injectionPins[1] = is469 ? GPIOD_15 : GPIOC_7; // #2 + engineConfiguration->injectionPins[2] = is469 ? GPIOD_10 : GPIOB_15; // #3 + engineConfiguration->injectionPins[3] = is469 ? GPIOD_14 : GPIOC_6; // #4 - boardConfiguration->ignitionPins[0] = GPIOA_10; - boardConfiguration->ignitionPins[1] = GPIOA_9; - boardConfiguration->ignitionPins[2] = GPIOA_8; - boardConfiguration->ignitionPins[3] = GPIOA_11; - boardConfiguration->ignitionPinMode = OM_INVERTED; + engineConfiguration->ignitionPins[0] = GPIOA_10; + engineConfiguration->ignitionPins[1] = GPIOA_9; + engineConfiguration->ignitionPins[2] = GPIOA_8; + engineConfiguration->ignitionPins[3] = GPIOA_11; + engineConfiguration->ignitionPinMode = OM_INVERTED; engineConfiguration->vbattDividerCoeff = ((float) (2 + 10)) / 2; engineConfiguration->clt.config.bias_resistor = 2700; engineConfiguration->iat.config.bias_resistor = 2700; - boardConfiguration->useStepperIdle = true; - boardConfiguration->idle.stepperDirectionPin = is469 ? GPIOB_14 : GPIOB_12; - boardConfiguration->idle.stepperStepPin = is469 ? GPIOB_15 : GPIOB_13; + engineConfiguration->useStepperIdle = true; + engineConfiguration->idle.stepperDirectionPin = is469 ? GPIOB_14 : GPIOB_12; + engineConfiguration->idle.stepperStepPin = is469 ? GPIOB_15 : GPIOB_13; engineConfiguration->stepperEnablePin = GPIO_UNASSIGNED; engineConfiguration->stepperEnablePinMode = OM_DEFAULT; @@ -174,93 +174,93 @@ void setBoardConfigurationOverrides(void) { //engineConfiguration->fatalErrorPin = GPIOA_13; engineConfiguration->warningLedPin = GPIO_UNASSIGNED; - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = is469 ? GPIOE_9 : GPIOA_6; - boardConfiguration->tachOutputPin = GPIOC_8; - boardConfiguration->tachOutputPinMode = OM_DEFAULT; - boardConfiguration->fuelPumpPin = is469 ? GPIOD_6 : GPIOB_7; - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; - boardConfiguration->mainRelayPin = is469 ? GPIOB_11 : GPIOB_2; - boardConfiguration->mainRelayPinMode = OM_DEFAULT; - boardConfiguration->fanPin = GPIOC_9; - boardConfiguration->fanPinMode = OM_DEFAULT; - boardConfiguration->malfunctionIndicatorPin = GPIOC_1; - boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; + engineConfiguration->tachOutputPin = GPIOC_8; + engineConfiguration->tachOutputPinMode = OM_DEFAULT; + engineConfiguration->fuelPumpPin = is469 ? GPIOD_6 : GPIOB_7; + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->mainRelayPin = is469 ? GPIOB_11 : GPIOB_2; + engineConfiguration->mainRelayPinMode = OM_DEFAULT; + engineConfiguration->fanPin = GPIOC_9; + engineConfiguration->fanPinMode = OM_DEFAULT; + engineConfiguration->malfunctionIndicatorPin = GPIOC_1; + engineConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; // starter block setFsio(0, (is469 ? GPIOB_10 : GPIOB_1), STARTER_RELAY_LOGIC PASS_CONFIG_PARAMETER_SUFFIX); // debug pad - boardConfiguration->triggerSimulatorPins[0] = GPIOD_8; - boardConfiguration->triggerSimulatorPinModes[0] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPins[0] = GPIOD_8; + engineConfiguration->triggerSimulatorPinModes[0] = OM_DEFAULT; // not used engineConfiguration->dizzySparkOutputPin = GPIO_UNASSIGNED; engineConfiguration->externalKnockSenseAdc = EFI_ADC_NONE; engineConfiguration->displayMode = DM_NONE; - boardConfiguration->HD44780_rs = GPIO_UNASSIGNED; - boardConfiguration->HD44780_e = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db4 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db5 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db6 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db7 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_rs = GPIO_UNASSIGNED; + engineConfiguration->HD44780_e = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db4 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db5 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db6 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db7 = GPIO_UNASSIGNED; for (int i = 0; i < DIGIPOT_COUNT ; i++) { - boardConfiguration->digitalPotentiometerChipSelect[i] = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[i] = GPIO_UNASSIGNED; } - boardConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; - boardConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; engineConfiguration->vehicleSpeedSensorInputPin = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; - boardConfiguration->max31855spiDevice = SPI_NONE; + engineConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; + engineConfiguration->max31855spiDevice = SPI_NONE; ///////////////////////////////////////////////////////// - boardConfiguration->is_enabled_spi_1 = true; - boardConfiguration->is_enabled_spi_2 = false; - boardConfiguration->is_enabled_spi_3 = true; + engineConfiguration->is_enabled_spi_1 = true; + engineConfiguration->is_enabled_spi_2 = false; + engineConfiguration->is_enabled_spi_3 = true; - boardConfiguration->spi1mosiPin = GPIOB_5; + engineConfiguration->spi1mosiPin = GPIOB_5; engineConfiguration->spi1MosiMode = PO_DEFAULT; // PAL_STM32_OTYPE_PUSHPULL - boardConfiguration->spi1misoPin = GPIOB_4; + engineConfiguration->spi1misoPin = GPIOB_4; engineConfiguration->spi1MisoMode = PO_DEFAULT; // PAL_STM32_OTYPE_PUSHPULL - boardConfiguration->spi1sckPin = GPIOB_3; + engineConfiguration->spi1sckPin = GPIOB_3; engineConfiguration->spi1SckMode = PO_DEFAULT; // PAL_STM32_OTYPE_PUSHPULL - boardConfiguration->spi3mosiPin = GPIOC_12; + engineConfiguration->spi3mosiPin = GPIOC_12; engineConfiguration->spi3MosiMode = PO_OPENDRAIN; // 4 - boardConfiguration->spi3misoPin = GPIOC_11; + engineConfiguration->spi3misoPin = GPIOC_11; engineConfiguration->spi3MisoMode = PO_PULLUP; // 32 - boardConfiguration->spi3sckPin = GPIOC_10; + engineConfiguration->spi3sckPin = GPIOC_10; engineConfiguration->spi3SckMode = PO_OPENDRAIN; // 4 engineConfiguration->hip9011SpiDevice = SPI_DEVICE_3; - boardConfiguration->hip9011CsPin = is469 ? GPIOD_1 : GPIOD_2; - boardConfiguration->hip9011CsPinMode = OM_OPENDRAIN; - boardConfiguration->hip9011IntHoldPin = GPIOC_14; - boardConfiguration->hip9011IntHoldPinMode = OM_OPENDRAIN; + engineConfiguration->hip9011CsPin = is469 ? GPIOD_1 : GPIOD_2; + engineConfiguration->hip9011CsPinMode = OM_OPENDRAIN; + engineConfiguration->hip9011IntHoldPin = GPIOC_14; + engineConfiguration->hip9011IntHoldPinMode = OM_OPENDRAIN; engineConfiguration->hipOutputChannel = EFI_ADC_10; // PC0 - boardConfiguration->isHip9011Enabled = true; + engineConfiguration->isHip9011Enabled = true; engineConfiguration->cj125SpiDevice = SPI_DEVICE_3; engineConfiguration->cj125ua = is469 ? EFI_ADC_9 : EFI_ADC_8; engineConfiguration->cj125ur = EFI_ADC_12; - boardConfiguration->cj125CsPin = GPIOA_15; + engineConfiguration->cj125CsPin = GPIOA_15; engineConfiguration->cj125CsPinMode = OM_OPENDRAIN; - boardConfiguration->wboHeaterPin = GPIOC_13; - boardConfiguration->o2heaterPin = GPIOC_13; - //boardConfiguration->isCJ125Enabled = true; - boardConfiguration->isCJ125Enabled = false; + engineConfiguration->wboHeaterPin = GPIOC_13; + engineConfiguration->o2heaterPin = GPIOC_13; + //engineConfiguration->isCJ125Enabled = true; + engineConfiguration->isCJ125Enabled = false; - boardConfiguration->canDeviceMode = CD_USE_CAN1; - boardConfiguration->canTxPin = GPIOB_9; - boardConfiguration->canRxPin = GPIOB_8; + engineConfiguration->canDeviceMode = CD_USE_CAN1; + engineConfiguration->canTxPin = GPIOB_9; + engineConfiguration->canRxPin = GPIOB_8; //!!!!!!!!!!!!!!! #if 1 diff --git a/firmware/config/boards/proteus/board_configuration.cpp b/firmware/config/boards/proteus/board_configuration.cpp index d4f6e46f9c..0d4dd75035 100644 --- a/firmware/config/boards/proteus/board_configuration.cpp +++ b/firmware/config/boards/proteus/board_configuration.cpp @@ -46,19 +46,19 @@ static const brain_pin_e ignPins[] = { }; static void setInjectorPins() { - copyArray(boardConfiguration->injectionPins, injPins); - boardConfiguration->injectionPinMode = OM_DEFAULT; + copyArray(engineConfiguration->injectionPins, injPins); + engineConfiguration->injectionPinMode = OM_DEFAULT; } static void setIgnitionPins() { - copyArray(boardConfiguration->ignitionPins, ignPins); - boardConfiguration->ignitionPinMode = OM_DEFAULT; + copyArray(engineConfiguration->ignitionPins, ignPins); + engineConfiguration->ignitionPinMode = OM_DEFAULT; } static void setLedPins() { engineConfiguration->communicationLedPin = GPIOE_4; engineConfiguration->runningLedPin = GPIOE_5; - boardConfiguration->triggerErrorPin = GPIOE_6; + engineConfiguration->triggerErrorPin = GPIOE_6; } static void setupVbatt() { @@ -109,9 +109,9 @@ static void setupEtb() { static void setupDefaultSensorInputs() { // trigger inputs // VR channel 1 as default - others not set - boardConfiguration->triggerInputPins[0] = GPIOC_6; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOC_6; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = GPIO_UNASSIGNED; // clt = Analog Temp 1 = PC4 @@ -129,7 +129,7 @@ void setPinConfigurationOverrides(void) { } void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = false; + engineConfiguration->useSerialPort = false; engineConfiguration->binarySerialTxPin = GPIO_UNASSIGNED; engineConfiguration->binarySerialRxPin = GPIO_UNASSIGNED; engineConfiguration->consoleSerialTxPin = GPIO_UNASSIGNED; diff --git a/firmware/config/boards/skeleton/board_configuration.cpp b/firmware/config/boards/skeleton/board_configuration.cpp index 0ca92b6f12..641145b987 100644 --- a/firmware/config/boards/skeleton/board_configuration.cpp +++ b/firmware/config/boards/skeleton/board_configuration.cpp @@ -42,10 +42,10 @@ EXTERN_ENGINE; // This shows a SPI connected TLE8888. static void setupTle8888() { // Enable the SPI channel and set up the SPI pins - boardConfiguration->is_enabled_spi_3 = true; - boardConfiguration->spi3mosiPin = GPIOB_5; - boardConfiguration->spi3misoPin = GPIOB_4; - boardConfiguration->spi3sckPin = GPIOB_3; + engineConfiguration->is_enabled_spi_3 = true; + engineConfiguration->spi3mosiPin = GPIOB_5; + engineConfiguration->spi3misoPin = GPIOB_4; + engineConfiguration->spi3sckPin = GPIOB_3; // SPI chip select is often independent of the SPI pin limitations engineConfiguration->tle8888_cs = GPIOD_5; @@ -81,8 +81,8 @@ static void setupDefaultSensorInputs() { // Engine rotation position sensors // Trigger is our primary timing signal, and usually comes from the crank. // trigger inputs up TRIGGER_SUPPORTED_CHANNELS (2) - boardConfiguration->triggerInputPins[0] = GPIOC_6; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOC_6; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; // A secondary Cam signal up to CAM_INPUTS_COUNT (4) engineConfiguration->camInputs[0] = GPIOA_5; @@ -121,7 +121,7 @@ void setPinConfigurationOverrides(void) { // Future: configure USART3 for LIN bus and UART4 for console void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = false; + engineConfiguration->useSerialPort = false; engineConfiguration->binarySerialTxPin = GPIO_UNASSIGNED; engineConfiguration->binarySerialRxPin = GPIO_UNASSIGNED; engineConfiguration->consoleSerialTxPin = GPIO_UNASSIGNED; @@ -140,7 +140,7 @@ void setBoardConfigurationOverrides(void) { // Set indicator LED pins. // This is often redundant with efifeatures.h or the run-time config - boardConfiguration->triggerErrorPin = GPIOE_1; + engineConfiguration->triggerErrorPin = GPIOE_1; engineConfiguration->communicationLedPin = GPIOE_2; engineConfiguration->FatalErrorPin = GPIOE_3; engineConfiguration->runningLedPin = GPIOE_4; @@ -149,25 +149,25 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->errorLedPin = GPIOE_7; // Set injector pins and the pin output mode - boardConfiguration->injectionPinMode = OM_DEFAULT; - boardConfiguration->injectionPins[0] = GPIOE_14; - boardConfiguration->injectionPins[1] = GPIOE_13; - boardConfiguration->injectionPins[2] = GPIOE_12; - boardConfiguration->injectionPins[3] = GPIOE_11; + engineConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPins[0] = GPIOE_14; + engineConfiguration->injectionPins[1] = GPIOE_13; + engineConfiguration->injectionPins[2] = GPIOE_12; + engineConfiguration->injectionPins[3] = GPIOE_11; // Disable the remainder only when they may never be assigned for (int i = 4; i < INJECTION_PIN_COUNT;i++) { - boardConfiguration->injectionPins[i] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[i] = GPIO_UNASSIGNED; } // Do the same for ignition outputs - boardConfiguration->ignitionPinMode = OM_DEFAULT; - boardConfiguration->ignitionPins[0] = GPIOD_4; - boardConfiguration->ignitionPins[1] = GPIOD_3; - boardConfiguration->ignitionPins[2] = GPIOD_2; - boardConfiguration->ignitionPins[3] = GPIOD_1; + engineConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPins[0] = GPIOD_4; + engineConfiguration->ignitionPins[1] = GPIOD_3; + engineConfiguration->ignitionPins[2] = GPIOD_2; + engineConfiguration->ignitionPins[3] = GPIOD_1; // Disable remainder for (int i = 4; i < IGNITION_PIN_COUNT; i++) { - boardConfiguration->ignitionPins[i] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[i] = GPIO_UNASSIGNED; } // Board-specific scaling values to convert ADC fraction to Volts. @@ -199,16 +199,16 @@ void setBoardConfigurationOverrides(void) { // Configure the TLE8888 half bridges (pushpull, lowside, or high-low) // TLE8888_IN11 -> TLE8888_OUT21 // GPIOE_8: "35 - GP Out 1" - boardConfiguration->fuelPumpPin = GPIOE_8; + engineConfiguration->fuelPumpPin = GPIOE_8; // TLE8888 high current low side: VVT2 IN9 / OUT5 // GPIOE_10: "3 - Lowside 2" - boardConfiguration->idle.solenoidPin = GPIOE_10; + engineConfiguration->idle.solenoidPin = GPIOE_10; // TLE8888_PIN_22: "34 - GP Out 2" - boardConfiguration->fanPin = TLE8888_PIN_22; + engineConfiguration->fanPin = TLE8888_PIN_22; // The "required" hardware is done - set some reasonable input defaults setupDefaultSensorInputs(); diff --git a/firmware/config/boards/subaru-ej20gn/board_configuration.cpp b/firmware/config/boards/subaru-ej20gn/board_configuration.cpp index 03a9dcf8f0..e6dc998cbc 100644 --- a/firmware/config/boards/subaru-ej20gn/board_configuration.cpp +++ b/firmware/config/boards/subaru-ej20gn/board_configuration.cpp @@ -57,7 +57,7 @@ static void setSubaruEJ20GDefaults(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->tpsErrorDetectionTooLow = -10; // -10% open engineConfiguration->tpsErrorDetectionTooHigh = 110; // 110% open - boardConfiguration->mapMinBufferLength = 4; + engineConfiguration->mapMinBufferLength = 4; } void setPinConfigurationOverrides(void) { @@ -65,20 +65,20 @@ void setPinConfigurationOverrides(void) { } void setSerialConfigurationOverrides(void) { - boardConfiguration->useSerialPort = false; + engineConfiguration->useSerialPort = false; engineConfiguration->binarySerialTxPin = GPIOE_1; engineConfiguration->binarySerialRxPin = GPIOE_0; engineConfiguration->consoleSerialTxPin = GPIOA_9; engineConfiguration->consoleSerialRxPin = GPIOA_10; - boardConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; + engineConfiguration->tunerStudioSerialSpeed = SERIAL_SPEED; engineConfiguration->uartConsoleSerialSpeed = SERIAL_SPEED; } void setSdCardConfigurationOverrides(void) { - boardConfiguration->is_enabled_spi_1 = false; + engineConfiguration->is_enabled_spi_1 = false; engineConfiguration->sdCardSpiDevice = SPI_DEVICE_1; - boardConfiguration->sdCardCsPin = GPIOA_2; - boardConfiguration->isSdCardEnabled = false; + engineConfiguration->sdCardCsPin = GPIOA_2; + engineConfiguration->isSdCardEnabled = false; } /** @@ -103,19 +103,19 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->throttlePedalPositionAdcChannel = EFI_ADC_NONE; /* Injectors */ - boardConfiguration->injectionPins[0] = GPIOB_11; - boardConfiguration->injectionPins[1] = GPIOA_0; - boardConfiguration->injectionPins[2] = GPIOA_1; - boardConfiguration->injectionPins[3] = GPIOB_10; + engineConfiguration->injectionPins[0] = GPIOB_11; + engineConfiguration->injectionPins[1] = GPIOA_0; + engineConfiguration->injectionPins[2] = GPIOA_1; + engineConfiguration->injectionPins[3] = GPIOB_10; /* 5th injector */ - //boardConfiguration->injectionPins[4] = GPIOD_15; + //engineConfiguration->injectionPins[4] = GPIOD_15; /* Ignition */ - boardConfiguration->ignitionPins[0] = GPIOB_8; - boardConfiguration->ignitionPins[1] = GPIOB_9; - boardConfiguration->ignitionPins[2] = GPIOF_8; - boardConfiguration->ignitionPins[3] = GPIOF_9; - //boardConfiguration->ignitionPinMode = OM_INVERTED; + engineConfiguration->ignitionPins[0] = GPIOB_8; + engineConfiguration->ignitionPins[1] = GPIOB_9; + engineConfiguration->ignitionPins[2] = GPIOF_8; + engineConfiguration->ignitionPins[3] = GPIOF_9; + //engineConfiguration->ignitionPinMode = OM_INVERTED; //? //engineConfiguration->vbattDividerCoeff = ((float) (2 + 10)) / 2; @@ -123,9 +123,9 @@ void setBoardConfigurationOverrides(void) { //sengineConfiguration->iat.config.bias_resistor = 2700; //? - //boardConfiguration->useStepperIdle = true; - //boardConfiguration->idle.stepperDirectionPin = GPIOB_12; - //boardConfiguration->idle.stepperStepPin = GPIOB_13; + //engineConfiguration->useStepperIdle = true; + //engineConfiguration->idle.stepperDirectionPin = GPIOB_12; + //engineConfiguration->idle.stepperStepPin = GPIOB_13; //engineConfiguration->stepperEnablePin = GPIO_UNASSIGNED; //engineConfiguration->stepperEnablePinMode = OM_DEFAULT; @@ -136,27 +136,27 @@ void setBoardConfigurationOverrides(void) { /* IF you have BOTH camshaft position sensor and crankshaft position sensor * camshaft is always trigger#1 input and then crankshaft is trigger#2. */ - boardConfiguration->triggerInputPins[0] = GPIOC_8; - boardConfiguration->triggerInputPins[1] = GPIOC_9; - boardConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOC_8; + engineConfiguration->triggerInputPins[1] = GPIOC_9; + engineConfiguration->triggerInputPins[2] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = GPIO_UNASSIGNED; /* spi driven - TLE6240 - OUT8, also direct driven by GPIOG_2 */ - boardConfiguration->tachOutputPin = TLE6240_PIN(0); - boardConfiguration->tachOutputPinMode = OM_DEFAULT; + engineConfiguration->tachOutputPin = TLE6240_PIN(0); + engineConfiguration->tachOutputPinMode = OM_DEFAULT; /* spi driven - TLE6240 - OUT5 */ - boardConfiguration->fuelPumpPin = TLE6240_PIN(5); - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->fuelPumpPin = TLE6240_PIN(5); + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; /* self shutdownd? */ - boardConfiguration->mainRelayPin = GPIOG_4; - boardConfiguration->mainRelayPinMode = OM_DEFAULT; + engineConfiguration->mainRelayPin = GPIOG_4; + engineConfiguration->mainRelayPinMode = OM_DEFAULT; /* spi driven - TLE6240 - OUT3, OUT4 * TODO: second fan */ - boardConfiguration->fanPin = TLE6240_PIN(2); - boardConfiguration->fanPinMode = OM_DEFAULT; + engineConfiguration->fanPin = TLE6240_PIN(2); + engineConfiguration->fanPinMode = OM_DEFAULT; /* spi driven - TLE6240 - OUT8 */ - boardConfiguration->malfunctionIndicatorPin = TLE6240_PIN(7); - boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; + engineConfiguration->malfunctionIndicatorPin = TLE6240_PIN(7); + engineConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; // starter block /* Starter signal connected through MC33972 - SG11 */ @@ -167,84 +167,84 @@ void setBoardConfigurationOverrides(void) { engineConfiguration->dizzySparkOutputPin = GPIO_UNASSIGNED; engineConfiguration->externalKnockSenseAdc = EFI_ADC_NONE; engineConfiguration->displayMode = DM_NONE; - boardConfiguration->HD44780_rs = GPIO_UNASSIGNED; - boardConfiguration->HD44780_e = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db4 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db5 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db6 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db7 = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerChipSelect[0] = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerChipSelect[1] = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerChipSelect[2] = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerChipSelect[3] = GPIO_UNASSIGNED; + engineConfiguration->HD44780_rs = GPIO_UNASSIGNED; + engineConfiguration->HD44780_e = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db4 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db5 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db6 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db7 = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[0] = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[1] = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[2] = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[3] = GPIO_UNASSIGNED; engineConfiguration->vehicleSpeedSensorInputPin = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; - boardConfiguration->max31855spiDevice = SPI_NONE; + engineConfiguration->digitalPotentiometerSpiDevice = SPI_NONE; + engineConfiguration->max31855spiDevice = SPI_NONE; ///////////////////////////////////////////////////////// - boardConfiguration->is_enabled_spi_1 = true; - boardConfiguration->is_enabled_spi_2 = false; - boardConfiguration->is_enabled_spi_3 = true; + engineConfiguration->is_enabled_spi_1 = true; + engineConfiguration->is_enabled_spi_2 = false; + engineConfiguration->is_enabled_spi_3 = true; - boardConfiguration->spi1mosiPin = GPIO_UNASSIGNED; + engineConfiguration->spi1mosiPin = GPIO_UNASSIGNED; engineConfiguration->spi1MosiMode = PO_DEFAULT; - boardConfiguration->spi1misoPin = GPIO_UNASSIGNED; + engineConfiguration->spi1misoPin = GPIO_UNASSIGNED; engineConfiguration->spi1MisoMode = PO_DEFAULT; - boardConfiguration->spi1sckPin = GPIO_UNASSIGNED; + engineConfiguration->spi1sckPin = GPIO_UNASSIGNED; engineConfiguration->spi1SckMode = PO_DEFAULT; - boardConfiguration->spi3mosiPin = GPIOC_12; + engineConfiguration->spi3mosiPin = GPIOC_12; engineConfiguration->spi3MosiMode = PO_DEFAULT; - boardConfiguration->spi3misoPin = GPIOC_11; + engineConfiguration->spi3misoPin = GPIOC_11; engineConfiguration->spi3MisoMode = PO_DEFAULT; - boardConfiguration->spi3sckPin = GPIOC_10; + engineConfiguration->spi3sckPin = GPIOC_10; engineConfiguration->spi3SckMode = PO_DEFAULT; engineConfiguration->hip9011SpiDevice = SPI_DEVICE_4; - boardConfiguration->hip9011CsPin = GPIOF_1; - boardConfiguration->hip9011CsPinMode = OM_OPENDRAIN; - boardConfiguration->hip9011IntHoldPin = GPIOC_15; - boardConfiguration->hip9011IntHoldPinMode = OM_OPENDRAIN; + engineConfiguration->hip9011CsPin = GPIOF_1; + engineConfiguration->hip9011CsPinMode = OM_OPENDRAIN; + engineConfiguration->hip9011IntHoldPin = GPIOC_15; + engineConfiguration->hip9011IntHoldPinMode = OM_OPENDRAIN; engineConfiguration->hipOutputChannel = EFI_ADC_7; // PA7 - boardConfiguration->isHip9011Enabled = true; + engineConfiguration->isHip9011Enabled = true; #if 0 engineConfiguration->cj125SpiDevice = SPI_DEVICE_3; engineConfiguration->cj125ua = EFI_ADC_9; engineConfiguration->cj125ur = EFI_ADC_12; - boardConfiguration->cj125CsPin = GPIOA_15; + engineConfiguration->cj125CsPin = GPIOA_15; engineConfiguration->cj125CsPinMode = OM_OPENDRAIN; - boardConfiguration->wboHeaterPin = GPIOC_13; - boardConfiguration->o2heaterPin = GPIOC_13; + engineConfiguration->wboHeaterPin = GPIOC_13; + engineConfiguration->o2heaterPin = GPIOC_13; #endif - boardConfiguration->isCJ125Enabled = false; + engineConfiguration->isCJ125Enabled = false; - boardConfiguration->canDeviceMode = CD_USE_CAN1; - boardConfiguration->canTxPin = GPIOD_0; - boardConfiguration->canRxPin = GPIOD_1; + engineConfiguration->canDeviceMode = CD_USE_CAN1; + engineConfiguration->canTxPin = GPIOD_0; + engineConfiguration->canRxPin = GPIOD_1; //!!!!!!!!!!!!!!! #if 1 setSubaruEJ20GDefaults(PASS_ENGINE_PARAMETER_SIGNATURE); #endif /* actually i2c extension connector */ - boardConfiguration->triggerSimulatorPins[0] = GPIOF_14; - boardConfiguration->triggerSimulatorPins[1] = GPIOF_15; - boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPinModes[0] = OM_DEFAULT; - boardConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; - boardConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPins[0] = GPIOF_14; + engineConfiguration->triggerSimulatorPins[1] = GPIOF_15; + engineConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPinModes[0] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPinModes[1] = OM_DEFAULT; + engineConfiguration->triggerSimulatorPinModes[2] = OM_DEFAULT; - boardConfiguration->logicAnalyzerPins[0] = GPIO_UNASSIGNED; - boardConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED; - boardConfiguration->logicAnalyzerPins[2] = GPIO_UNASSIGNED; - boardConfiguration->logicAnalyzerPins[3] = GPIO_UNASSIGNED; - boardConfiguration->logicAnalyzerMode[0] = OM_DEFAULT; - boardConfiguration->logicAnalyzerMode[1] = OM_DEFAULT; - boardConfiguration->logicAnalyzerMode[2] = OM_DEFAULT; - boardConfiguration->logicAnalyzerMode[3] = OM_DEFAULT; + engineConfiguration->logicAnalyzerPins[0] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerPins[2] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerPins[3] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerMode[0] = OM_DEFAULT; + engineConfiguration->logicAnalyzerMode[1] = OM_DEFAULT; + engineConfiguration->logicAnalyzerMode[2] = OM_DEFAULT; + engineConfiguration->logicAnalyzerMode[3] = OM_DEFAULT; //!!!!!!!!!!!!!!!!!!! //engineConfiguration->silentTriggerError = true; diff --git a/firmware/config/engines/GY6_139QMB.cpp b/firmware/config/engines/GY6_139QMB.cpp index 319a352508..9b59b7da51 100644 --- a/firmware/config/engines/GY6_139QMB.cpp +++ b/firmware/config/engines/GY6_139QMB.cpp @@ -89,7 +89,7 @@ void setGy6139qmbDefaultEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) engineConfiguration->analogInputDividerCoefficient = 1; engineConfiguration->fuelAlgorithm = LM_MAP; engineConfiguration->globalTriggerAngleOffset = 45; - boardConfiguration->sensorChartMode = SC_MAP; + engineConfiguration->sensorChartMode = SC_MAP; engineConfiguration->specs.displacement = 0.072; // 72cc engineConfiguration->specs.cylindersCount = 1; setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR); @@ -103,8 +103,8 @@ void setGy6139qmbDefaultEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) engineConfiguration->trigger.customTotalToothCount = 8; engineConfiguration->trigger.customSkippedToothCount = 1; - boardConfiguration->injectionPins[0] = GPIOC_9; - boardConfiguration->ignitionPins[0] = GPIOC_8; + engineConfiguration->injectionPins[0] = GPIOC_9; + engineConfiguration->ignitionPins[0] = GPIOC_8; // set injection_mode 1 engineConfiguration->injectionMode = IM_SEQUENTIAL; diff --git a/firmware/config/engines/bmw_e34.cpp b/firmware/config/engines/bmw_e34.cpp index 72bcb1d5e3..4baf1b83b1 100644 --- a/firmware/config/engines/bmw_e34.cpp +++ b/firmware/config/engines/bmw_e34.cpp @@ -27,8 +27,8 @@ void setBmwE34(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR); // engineConfiguration->trigger.type = TT_ONE_PLUS_TOOTHED_WHEEL_60_2; // engineConfiguration->injectionMode = IM_SEQUENTIAL; -// boardConfiguration->triggerInputPins[0] = GPIOC_6; -// boardConfiguration->triggerInputPins[1] = GPIOA_5; +// engineConfiguration->triggerInputPins[0] = GPIOC_6; +// engineConfiguration->triggerInputPins[1] = GPIOA_5; //Base engine setting engineConfiguration->specs.cylindersCount = 6; @@ -39,7 +39,7 @@ void setBmwE34(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->ignitionMode = IM_WASTED_SPARK; engineConfiguration->useOnlyRisingEdgeForTrigger = true; - boardConfiguration->tachOutputPin = GPIOC_8; + engineConfiguration->tachOutputPin = GPIOC_8; // Trigger configuration // engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2; @@ -58,12 +58,12 @@ void setBmwE34(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->injector.flow = 750; // General settings - boardConfiguration->tunerStudioSerialSpeed = 57600; + engineConfiguration->tunerStudioSerialSpeed = 57600; engineConfiguration->rpmHardLimit = 7000; setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX); // for best performance at high RPM, we need to turn off 'Engine Sniffer' and 'Sensor Sniffer' - boardConfiguration->sensorChartMode = SC_OFF; + engineConfiguration->sensorChartMode = SC_OFF; engineConfiguration->isEngineChartEnabled = false; engineConfiguration->isCylinderCleanupEnabled = false; @@ -90,52 +90,52 @@ void setBmwE34(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->tps1_1AdcChannel = EFI_ADC_3; - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; setWholeTimingTable(25); - boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; + engineConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; // bc->isFastAdcEnabled = true; - boardConfiguration->injectionPinMode = OM_INVERTED; - boardConfiguration->injectionPins[0] = GPIOB_8; // #1 - boardConfiguration->injectionPins[1] = GPIOE_2; // #2 - boardConfiguration->injectionPins[2] = GPIOE_3; // #3 - boardConfiguration->injectionPins[3] = GPIOE_4; // #4 - boardConfiguration->injectionPins[4] = GPIOE_5; // #5 - boardConfiguration->injectionPins[5] = GPIOE_6; // #6 + engineConfiguration->injectionPinMode = OM_INVERTED; + engineConfiguration->injectionPins[0] = GPIOB_8; // #1 + engineConfiguration->injectionPins[1] = GPIOE_2; // #2 + engineConfiguration->injectionPins[2] = GPIOE_3; // #3 + engineConfiguration->injectionPins[3] = GPIOE_4; // #4 + engineConfiguration->injectionPins[4] = GPIOE_5; // #5 + engineConfiguration->injectionPins[5] = GPIOE_6; // #6 - boardConfiguration->ignitionPinMode = OM_INVERTED; + engineConfiguration->ignitionPinMode = OM_INVERTED; - boardConfiguration->ignitionPins[0] = GPIOB_5; // #1 - boardConfiguration->ignitionPins[2] = GPIOB_6; // #3 - boardConfiguration->ignitionPins[4] = GPIOB_7; // #5 + engineConfiguration->ignitionPins[0] = GPIOB_5; // #1 + engineConfiguration->ignitionPins[2] = GPIOB_6; // #3 + engineConfiguration->ignitionPins[4] = GPIOB_7; // #5 - boardConfiguration->canRxPin = GPIO_UNASSIGNED; - boardConfiguration->canTxPin = GPIO_UNASSIGNED; + engineConfiguration->canRxPin = GPIO_UNASSIGNED; + engineConfiguration->canTxPin = GPIO_UNASSIGNED; - boardConfiguration->triggerErrorPin = GPIO_UNASSIGNED; + engineConfiguration->triggerErrorPin = GPIO_UNASSIGNED; // clutch up engineConfiguration->clutchUpPin = GPIOD_3; engineConfiguration->clutchUpPinMode = PI_PULLUP; // fuel pump - boardConfiguration->fuelPumpPin = GPIOD_4; + engineConfiguration->fuelPumpPin = GPIOD_4; // idle - boardConfiguration->idle.solenoidPin = GPIOC_14; - boardConfiguration->idle.solenoidPinMode = OM_INVERTED; - boardConfiguration->idle.solenoidFrequency = 300; - boardConfiguration->manIdlePosition = 50; // set_idle_pwm 50 + engineConfiguration->idle.solenoidPin = GPIOC_14; + engineConfiguration->idle.solenoidPinMode = OM_INVERTED; + engineConfiguration->idle.solenoidFrequency = 300; + engineConfiguration->manIdlePosition = 50; // set_idle_pwm 50 // disable sd_card - boardConfiguration->sdCardCsPin = GPIO_UNASSIGNED; - boardConfiguration->is_enabled_spi_2 = false; - boardConfiguration->is_enabled_spi_3 = false; - boardConfiguration->max31855spiDevice = SPI_NONE; + engineConfiguration->sdCardCsPin = GPIO_UNASSIGNED; + engineConfiguration->is_enabled_spi_2 = false; + engineConfiguration->is_enabled_spi_3 = false; + engineConfiguration->max31855spiDevice = SPI_NONE; // turbocharger boost control solenoid: TODO output: GPIOE_6 // water injection #1 TODO GPIOD_7 @@ -145,7 +145,7 @@ void setBmwE34(DECLARE_CONFIG_PARAMETER_SIGNATURE) { * emulating the 60-0 trigger takes some resources, let's keep it slow by default * rpm 200 */ - boardConfiguration->triggerSimulatorFrequency = 200; + engineConfiguration->triggerSimulatorFrequency = 200; // Configurating sensors: @@ -163,7 +163,7 @@ void setBmwE34(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // */ // bc->triggerSimulatorPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPins[0] = GPIOD_1; - boardConfiguration->triggerSimulatorPins[1] = GPIOD_2; - boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPins[0] = GPIOD_1; + engineConfiguration->triggerSimulatorPins[1] = GPIOD_2; + engineConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; } diff --git a/firmware/config/engines/bmw_m73.cpp b/firmware/config/engines/bmw_m73.cpp index 96058e04da..0f52463f3b 100644 --- a/firmware/config/engines/bmw_m73.cpp +++ b/firmware/config/engines/bmw_m73.cpp @@ -98,36 +98,36 @@ void setEngineBMW_M73_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setFrankensoConfiguration(PASS_CONFIG_PARAMETER_SIGNATURE); m73engine(PASS_CONFIG_PARAMETER_SIGNATURE); - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = GPIOC_6; - CONFIGB(idle).solenoidPin = GPIO_UNASSIGNED; - CONFIGB(mainRelayPin) = GPIO_UNASSIGNED; - CONFIGB(fanPin) = GPIO_UNASSIGNED; - CONFIGB(fuelPumpPin) = GPIO_UNASSIGNED; + CONFIG(idle).solenoidPin = GPIO_UNASSIGNED; + CONFIG(mainRelayPin) = GPIO_UNASSIGNED; + CONFIG(fanPin) = GPIO_UNASSIGNED; + CONFIG(fuelPumpPin) = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[ID2INDEX(1)] = GPIOE_14; // Frankenso high side - pin 1G - GREEN wire - boardConfiguration->ignitionPins[ID2INDEX(2)] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[ID2INDEX(3)] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[ID2INDEX(4)] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[ID2INDEX(7)] = GPIOC_7; // Frankenso high side - pin 1H - ORANGE wire + engineConfiguration->ignitionPins[ID2INDEX(1)] = GPIOE_14; // Frankenso high side - pin 1G - GREEN wire + engineConfiguration->ignitionPins[ID2INDEX(2)] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[ID2INDEX(3)] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[ID2INDEX(4)] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[ID2INDEX(7)] = GPIOC_7; // Frankenso high side - pin 1H - ORANGE wire - boardConfiguration->injectionPins[0] = GPIOB_8; // BLU - boardConfiguration->injectionPins[1] = GPIOB_7; // BLK - boardConfiguration->injectionPins[2] = GPIOB_9; // GRN - boardConfiguration->injectionPins[3] = GPIOD_5; // WHT - boardConfiguration->injectionPins[4] = GPIOD_3; // RED - boardConfiguration->injectionPins[5] = GPIOE_2; // ORG + engineConfiguration->injectionPins[0] = GPIOB_8; // BLU + engineConfiguration->injectionPins[1] = GPIOB_7; // BLK + engineConfiguration->injectionPins[2] = GPIOB_9; // GRN + engineConfiguration->injectionPins[3] = GPIOD_5; // WHT + engineConfiguration->injectionPins[4] = GPIOD_3; // RED + engineConfiguration->injectionPins[5] = GPIOE_2; // ORG - boardConfiguration->injectionPins[6] = GPIOE_3; // BLU - boardConfiguration->injectionPins[7] = GPIOE_4; // BLK - boardConfiguration->injectionPins[8] = GPIOE_5; // GRN - boardConfiguration->injectionPins[9] = GPIOE_6; // WHT - boardConfiguration->injectionPins[10] = GPIOC_13;//RED - boardConfiguration->injectionPins[11] = GPIOD_7;// ORG + engineConfiguration->injectionPins[6] = GPIOE_3; // BLU + engineConfiguration->injectionPins[7] = GPIOE_4; // BLK + engineConfiguration->injectionPins[8] = GPIOE_5; // GRN + engineConfiguration->injectionPins[9] = GPIOE_6; // WHT + engineConfiguration->injectionPins[10] = GPIOC_13;//RED + engineConfiguration->injectionPins[11] = GPIOD_7;// ORG } // BMW_M73_M @@ -155,10 +155,10 @@ GPIOA_6 */ - CONFIGB(fsioOutputPins)[7] = GPIO_UNASSIGNED; - boardConfiguration->fuelPumpPin = GPIO_UNASSIGNED; - boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; - boardConfiguration->fanPin = GPIO_UNASSIGNED; + CONFIG(fsioOutputPins)[7] = GPIO_UNASSIGNED; + engineConfiguration->fuelPumpPin = GPIO_UNASSIGNED; + engineConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; + engineConfiguration->fanPin = GPIO_UNASSIGNED; /** * Yellow op-amp board @@ -194,19 +194,19 @@ GPIOA_6 engineConfiguration->etbIo[1].directionPin2 = GPIOB_9; - boardConfiguration->injectionPins[0] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[0] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[6] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[7] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[8] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[9] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[10] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[11] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[6] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[7] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[8] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[9] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[10] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[11] = GPIO_UNASSIGNED; } diff --git a/firmware/config/engines/chevrolet_camaro_4.cpp b/firmware/config/engines/chevrolet_camaro_4.cpp index 26eddc0b7f..cbe24d74c3 100644 --- a/firmware/config/engines/chevrolet_camaro_4.cpp +++ b/firmware/config/engines/chevrolet_camaro_4.cpp @@ -24,8 +24,8 @@ void setCamaro4(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->specs.cylindersCount = 8; engineConfiguration->specs.firingOrder = FO_1_8_7_2_6_5_4_3; - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIOC_6; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIOC_6; engineConfiguration->injectionMode = IM_BATCH; engineConfiguration->twoWireBatchInjection = true; @@ -56,31 +56,31 @@ void setCamaro4(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->afr.hwChannel = EFI_ADC_13; - boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; - boardConfiguration->fuelPumpPin = GPIO_UNASSIGNED; + engineConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; + engineConfiguration->fuelPumpPin = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[0] = GPIOE_6; - boardConfiguration->injectionPins[1] = GPIOE_5; - boardConfiguration->injectionPins[2] = GPIOD_7; - boardConfiguration->injectionPins[3] = GPIOC_13; - boardConfiguration->injectionPins[4] = GPIOE_3; - boardConfiguration->injectionPins[5] = GPIOE_4; - boardConfiguration->injectionPins[6] = GPIOD_3; - boardConfiguration->injectionPins[7] = GPIOE_2; + engineConfiguration->injectionPins[0] = GPIOE_6; + engineConfiguration->injectionPins[1] = GPIOE_5; + engineConfiguration->injectionPins[2] = GPIOD_7; + engineConfiguration->injectionPins[3] = GPIOC_13; + engineConfiguration->injectionPins[4] = GPIOE_3; + engineConfiguration->injectionPins[5] = GPIOE_4; + engineConfiguration->injectionPins[6] = GPIOD_3; + engineConfiguration->injectionPins[7] = GPIOE_2; - boardConfiguration->ignitionPins[0] = GPIOC_9; - boardConfiguration->ignitionPins[1] = GPIOC_7; - boardConfiguration->ignitionPins[2] = GPIOE_14; - boardConfiguration->ignitionPins[3] = GPIOE_12; - boardConfiguration->ignitionPins[4] = GPIOE_10; - boardConfiguration->ignitionPins[5] = GPIOE_8; - boardConfiguration->ignitionPins[6] = GPIOD_9; - boardConfiguration->ignitionPins[7] = GPIOD_8; + engineConfiguration->ignitionPins[0] = GPIOC_9; + engineConfiguration->ignitionPins[1] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOE_14; + engineConfiguration->ignitionPins[3] = GPIOE_12; + engineConfiguration->ignitionPins[4] = GPIOE_10; + engineConfiguration->ignitionPins[5] = GPIOE_8; + engineConfiguration->ignitionPins[6] = GPIOD_9; + engineConfiguration->ignitionPins[7] = GPIOD_8; - boardConfiguration->fuelPumpPin = GPIOB_8; - boardConfiguration->fanPin = GPIO_UNASSIGNED; - boardConfiguration->mainRelayPin = GPIOD_5; + engineConfiguration->fuelPumpPin = GPIOB_8; + engineConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->mainRelayPin = GPIOD_5; } diff --git a/firmware/config/engines/citroenBerlingoTU3JP.cpp b/firmware/config/engines/citroenBerlingoTU3JP.cpp index 301d99210c..e970ea469d 100644 --- a/firmware/config/engines/citroenBerlingoTU3JP.cpp +++ b/firmware/config/engines/citroenBerlingoTU3JP.cpp @@ -14,13 +14,13 @@ #include "citroenBerlingoTU3JP.h" #include "settings.h" -void setLCD(board_configuration_s *boardConfiguration) { - boardConfiguration->HD44780_rs = GPIOE_7; - boardConfiguration->HD44780_e = GPIOE_9; - boardConfiguration->HD44780_db4 = GPIOE_11; - boardConfiguration->HD44780_db5 = GPIOE_13; - boardConfiguration->HD44780_db6 = GPIOE_15; - boardConfiguration->HD44780_db7 = GPIOB_10; +void setLCD(engine_configuration_s *engineConfiguration) { + engineConfiguration->HD44780_rs = GPIOE_7; + engineConfiguration->HD44780_e = GPIOE_9; + engineConfiguration->HD44780_db4 = GPIOE_11; + engineConfiguration->HD44780_db5 = GPIOE_13; + engineConfiguration->HD44780_db6 = GPIOE_15; + engineConfiguration->HD44780_db7 = GPIOB_10; } #if DEFAULT_FUEL_LOAD_COUNT == FUEL_LOAD_COUNT @@ -117,35 +117,35 @@ void setCitroenBerlingoTU3JPConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenstein lo-side output #11: PB8 Main relay // Frankenstein lo-side output #12: PB9 Fuel pump - boardConfiguration->ignitionPins[0] = GPIOC_14; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOC_15; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOC_14; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOC_15; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; engineConfiguration->injector.flow = 137; //SIEMENS DEKA VAZ20734 - boardConfiguration->injectionPins[0] = GPIOE_6; - boardConfiguration->injectionPins[1] = GPIOC_13; - boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[0] = GPIOE_6; + engineConfiguration->injectionPins[1] = GPIOC_13; + engineConfiguration->injectionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->fanPin = GPIOE_0; - boardConfiguration->fanPinMode = OM_DEFAULT; + engineConfiguration->fanPin = GPIOE_0; + engineConfiguration->fanPinMode = OM_DEFAULT; engineConfiguration->fanOffTemperature = 95; engineConfiguration->fanOnTemperature = 99; - boardConfiguration->malfunctionIndicatorPin = GPIOE_1; - boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; + engineConfiguration->malfunctionIndicatorPin = GPIOE_1; + engineConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; - boardConfiguration->mainRelayPin = GPIOB_8; + engineConfiguration->mainRelayPin = GPIOB_8; - boardConfiguration->fuelPumpPin = GPIOB_9; - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->fuelPumpPin = GPIOB_9; + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; - setLCD(boardConfiguration); + setLCD(engineConfiguration); -// boardConfiguration->o2heaterPin = GPIOC_13; -// boardConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED; +// engineConfiguration->o2heaterPin = GPIOC_13; +// engineConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED; /** * Inputs diff --git a/firmware/config/engines/custom_engine.cpp b/firmware/config/engines/custom_engine.cpp index 8686d24dc9..69f88312b3 100644 --- a/firmware/config/engines/custom_engine.cpp +++ b/firmware/config/engines/custom_engine.cpp @@ -65,22 +65,22 @@ void runSchedulingPrecisionTestIfNeeded(void) { } #endif /* EFI_PROD_CODE */ -void setFrankenso_01_LCD(board_configuration_s *boardConfiguration) { - boardConfiguration->HD44780_rs = GPIOE_7; - boardConfiguration->HD44780_e = GPIOE_9; - boardConfiguration->HD44780_db4 = GPIOE_11; - boardConfiguration->HD44780_db5 = GPIOE_13; - boardConfiguration->HD44780_db6 = GPIOE_15; - boardConfiguration->HD44780_db7 = GPIOB_10; +void setFrankenso_01_LCD(engine_configuration_s *engineConfiguration) { + engineConfiguration->HD44780_rs = GPIOE_7; + engineConfiguration->HD44780_e = GPIOE_9; + engineConfiguration->HD44780_db4 = GPIOE_11; + engineConfiguration->HD44780_db5 = GPIOE_13; + engineConfiguration->HD44780_db6 = GPIOE_15; + engineConfiguration->HD44780_db7 = GPIOB_10; } -void disableLCD(board_configuration_s *boardConfiguration) { - boardConfiguration->HD44780_rs = GPIO_UNASSIGNED; - boardConfiguration->HD44780_e = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db4 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db5 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db6 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db7 = GPIO_UNASSIGNED; +void disableLCD(engine_configuration_s *engineConfiguration) { + engineConfiguration->HD44780_rs = GPIO_UNASSIGNED; + engineConfiguration->HD44780_e = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db4 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db5 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db6 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db7 = GPIO_UNASSIGNED; } // todo: should this be part of more default configurations? @@ -88,7 +88,7 @@ void setFrankensoConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setDefaultFrankensoConfiguration(PASS_CONFIG_PARAMETER_SIGNATURE); engineConfiguration->trigger.type = TT_ONE_PLUS_ONE; - setFrankenso_01_LCD(boardConfiguration); + setFrankenso_01_LCD(engineConfiguration); engineConfiguration->displayMode = DM_HD44780; commonFrankensoAnalogInputs(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration); @@ -135,32 +135,32 @@ void setFrankensoConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenso low out #11: PB8 injector #3 // Frankenso low out #12: PB7 injector #4 - boardConfiguration->fuelPumpPin = GPIOE_4; - boardConfiguration->mainRelayPin = GPIOD_7; - boardConfiguration->idle.solenoidPin = GPIOC_13; + engineConfiguration->fuelPumpPin = GPIOE_4; + engineConfiguration->mainRelayPin = GPIOD_7; + engineConfiguration->idle.solenoidPin = GPIOC_13; - boardConfiguration->fanPin = GPIOE_5; + engineConfiguration->fanPin = GPIOE_5; - boardConfiguration->injectionPins[0] = GPIOB_9; // #1 - boardConfiguration->injectionPins[1] = GPIOE_2; // #2 - boardConfiguration->injectionPins[2] = GPIOB_8; // #3 + engineConfiguration->injectionPins[0] = GPIOB_9; // #1 + engineConfiguration->injectionPins[1] = GPIOE_2; // #2 + engineConfiguration->injectionPins[2] = GPIOB_8; // #3 #ifndef EFI_INJECTOR_PIN3 - boardConfiguration->injectionPins[3] = GPIOB_7; // #4 + engineConfiguration->injectionPins[3] = GPIOB_7; // #4 #else /* EFI_INJECTOR_PIN3 */ - boardConfiguration->injectionPins[3] = EFI_INJECTOR_PIN3; // #4 + engineConfiguration->injectionPins[3] = EFI_INJECTOR_PIN3; // #4 #endif /* EFI_INJECTOR_PIN3 */ setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX); #if EFI_PWM_TESTER - boardConfiguration->injectionPins[4] = GPIOC_8; // #5 - boardConfiguration->injectionPins[5] = GPIOD_10; // #6 - boardConfiguration->injectionPins[6] = GPIOD_9; - boardConfiguration->injectionPins[7] = GPIOD_11; - boardConfiguration->injectionPins[8] = GPIOD_0; - boardConfiguration->injectionPins[9] = GPIOB_11; - boardConfiguration->injectionPins[10] = GPIOC_7; - boardConfiguration->injectionPins[11] = GPIOE_4; + engineConfiguration->injectionPins[4] = GPIOC_8; // #5 + engineConfiguration->injectionPins[5] = GPIOD_10; // #6 + engineConfiguration->injectionPins[6] = GPIOD_9; + engineConfiguration->injectionPins[7] = GPIOD_11; + engineConfiguration->injectionPins[8] = GPIOD_0; + engineConfiguration->injectionPins[9] = GPIOB_11; + engineConfiguration->injectionPins[10] = GPIOC_7; + engineConfiguration->injectionPins[11] = GPIOE_4; /** * We want to initialize all outputs for test @@ -169,20 +169,20 @@ void setFrankensoConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->displayMode = DM_NONE; #else /* EFI_PWM_TESTER */ - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[6] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[7] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[8] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[9] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[10] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[11] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[6] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[7] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[8] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[9] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[10] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[11] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[0] = GPIOE_14; - boardConfiguration->ignitionPins[1] = GPIOC_7; - boardConfiguration->ignitionPins[2] = GPIOC_9; + engineConfiguration->ignitionPins[0] = GPIOE_14; + engineConfiguration->ignitionPins[1] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOC_9; // set_ignition_pin 4 PE10 - boardConfiguration->ignitionPins[3] = GPIOE_10; + engineConfiguration->ignitionPins[3] = GPIOE_10; #endif /* EFI_PWM_TESTER */ // todo: 8.2 or 10k? @@ -198,7 +198,7 @@ void setFrankensoBoardTestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->directSelfStimulation = true; // this engine type is used for board validation - boardConfiguration->triggerSimulatorFrequency = 300; + engineConfiguration->triggerSimulatorFrequency = 300; engineConfiguration->cranking.rpm = 100; engineConfiguration->specs.cylindersCount = 12; @@ -207,38 +207,38 @@ void setFrankensoBoardTestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // set ignition_mode 1 engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; - boardConfiguration->injectionPins[0] = GPIOB_7; // injector in default pinout - boardConfiguration->injectionPins[1] = GPIOB_8; // injector in default pinout - boardConfiguration->injectionPins[2] = GPIOB_9; // injector in default pinout - boardConfiguration->injectionPins[3] = GPIOC_13; + engineConfiguration->injectionPins[0] = GPIOB_7; // injector in default pinout + engineConfiguration->injectionPins[1] = GPIOB_8; // injector in default pinout + engineConfiguration->injectionPins[2] = GPIOB_9; // injector in default pinout + engineConfiguration->injectionPins[3] = GPIOC_13; - boardConfiguration->injectionPins[4] = GPIOD_3; - boardConfiguration->injectionPins[5] = GPIOD_5; - boardConfiguration->injectionPins[6] = GPIOD_7; - boardConfiguration->injectionPins[7] = GPIOE_2; // injector in default pinout - boardConfiguration->injectionPins[8] = GPIOE_3; - boardConfiguration->injectionPins[9] = GPIOE_4; - boardConfiguration->injectionPins[10] = GPIOE_5; - boardConfiguration->injectionPins[11] = GPIOE_6; + engineConfiguration->injectionPins[4] = GPIOD_3; + engineConfiguration->injectionPins[5] = GPIOD_5; + engineConfiguration->injectionPins[6] = GPIOD_7; + engineConfiguration->injectionPins[7] = GPIOE_2; // injector in default pinout + engineConfiguration->injectionPins[8] = GPIOE_3; + engineConfiguration->injectionPins[9] = GPIOE_4; + engineConfiguration->injectionPins[10] = GPIOE_5; + engineConfiguration->injectionPins[11] = GPIOE_6; - boardConfiguration->fuelPumpPin = GPIO_UNASSIGNED; - boardConfiguration->mainRelayPin = GPIO_UNASSIGNED; - boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; - boardConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->fuelPumpPin = GPIO_UNASSIGNED; + engineConfiguration->mainRelayPin = GPIO_UNASSIGNED; + engineConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; + engineConfiguration->fanPin = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[0] = GPIOC_9; // coil in default pinout - boardConfiguration->ignitionPins[1] = GPIOC_7; // coil in default pinout - boardConfiguration->ignitionPins[2] = GPIOE_10; // coil in default pinout - boardConfiguration->ignitionPins[3] = GPIOE_8; // Miata VVT tach + engineConfiguration->ignitionPins[0] = GPIOC_9; // coil in default pinout + engineConfiguration->ignitionPins[1] = GPIOC_7; // coil in default pinout + engineConfiguration->ignitionPins[2] = GPIOE_10; // coil in default pinout + engineConfiguration->ignitionPins[3] = GPIOE_8; // Miata VVT tach - boardConfiguration->ignitionPins[4] = GPIOE_14; // coil in default pinout - boardConfiguration->ignitionPins[5] = GPIOE_12; - boardConfiguration->ignitionPins[6] = GPIOD_8; - boardConfiguration->ignitionPins[7] = GPIOD_9; + engineConfiguration->ignitionPins[4] = GPIOE_14; // coil in default pinout + engineConfiguration->ignitionPins[5] = GPIOE_12; + engineConfiguration->ignitionPins[6] = GPIOD_8; + engineConfiguration->ignitionPins[7] = GPIOD_9; - boardConfiguration->ignitionPins[8] = GPIOE_0; // brain board, not discovery - boardConfiguration->ignitionPins[9] = GPIOE_1; // brain board, not discovery + engineConfiguration->ignitionPins[8] = GPIOE_0; // brain board, not discovery + engineConfiguration->ignitionPins[9] = GPIOE_1; // brain board, not discovery } @@ -260,10 +260,10 @@ void setEtbTestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2; - boardConfiguration->ignitionPins[0] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; /** * remember that some H-bridges require 5v control lines, not just 3v logic outputs we have on stm32 */ @@ -282,11 +282,11 @@ void setEtbTestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->debugMode = DBG_ELECTRONIC_THROTTLE_PID; // turning off other PWMs to simplify debugging - engineConfiguration->bc.triggerSimulatorFrequency = 0; + engineConfiguration->triggerSimulatorFrequency = 0; engineConfiguration->stepperEnablePin = GPIO_UNASSIGNED; - CONFIGB(idle).stepperStepPin = GPIO_UNASSIGNED; - CONFIGB(idle).stepperDirectionPin = GPIO_UNASSIGNED; - boardConfiguration->useStepperIdle = true; + CONFIG(idle).stepperStepPin = GPIO_UNASSIGNED; + CONFIG(idle).stepperDirectionPin = GPIO_UNASSIGNED; + engineConfiguration->useStepperIdle = true; // no analog dividers - all sensors with 3v supply, naked discovery bench setup engineConfiguration->analogInputDividerCoefficient = 1; @@ -313,28 +313,28 @@ void setTle8888TestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->directSelfStimulation = true; #if defined(STM32_HAS_GPIOG) && STM32_HAS_GPIOG - boardConfiguration->ignitionPins[0] = GPIOG_3; - boardConfiguration->ignitionPins[1] = GPIOG_4; - boardConfiguration->ignitionPins[2] = GPIOG_5; - boardConfiguration->ignitionPins[3] = GPIOG_6; - boardConfiguration->ignitionPins[4] = GPIOG_7; - boardConfiguration->ignitionPins[5] = GPIOG_8; + engineConfiguration->ignitionPins[0] = GPIOG_3; + engineConfiguration->ignitionPins[1] = GPIOG_4; + engineConfiguration->ignitionPins[2] = GPIOG_5; + engineConfiguration->ignitionPins[3] = GPIOG_6; + engineConfiguration->ignitionPins[4] = GPIOG_7; + engineConfiguration->ignitionPins[5] = GPIOG_8; #endif /* STM32_HAS_GPIOG */ - boardConfiguration->ignitionPins[6] = GPIOC_6; - boardConfiguration->ignitionPins[7] = GPIOC_7; + engineConfiguration->ignitionPins[6] = GPIOC_6; + engineConfiguration->ignitionPins[7] = GPIOC_7; #if (BOARD_TLE8888_COUNT > 0) engineConfiguration->tle8888spiDevice = SPI_DEVICE_1; engineConfiguration->tle8888_cs = GPIOD_5; // PB3 is nicely both SWO and SPI1 SCK so logic analyzer could be used on SWO header - boardConfiguration->spi1mosiPin = GPIOB_5; - boardConfiguration->spi1misoPin = GPIOB_4; - boardConfiguration->spi1sckPin = GPIOB_3; // please note that this pin is also SWO/SWD - Single Wire debug Output - boardConfiguration->is_enabled_spi_1 = true; + engineConfiguration->spi1mosiPin = GPIOB_5; + engineConfiguration->spi1misoPin = GPIOB_4; + engineConfiguration->spi1sckPin = GPIOB_3; // please note that this pin is also SWO/SWD - Single Wire debug Output + engineConfiguration->is_enabled_spi_1 = true; engineConfiguration->debugMode = DBG_TLE8888; - boardConfiguration->fuelPumpPin = TLE8888_PIN_20; + engineConfiguration->fuelPumpPin = TLE8888_PIN_20; #endif /* BOARD_TLE8888_COUNT */ engineConfiguration->throttlePedalPositionAdcChannel = EFI_ADC_9; // PB1 // just any non-empty value for now @@ -353,7 +353,7 @@ void setTle8888TestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { CONFIG(etbIo[0].directionPin2) = GPIOF_14; #endif /* STM32_HAS_GPIOF */ CONFIG(etb_use_two_wires) = true; - boardConfiguration->isHip9011Enabled = false; + engineConfiguration->isHip9011Enabled = false; // ETB #2 // DIS PE5 @@ -400,7 +400,7 @@ void mreBoardTest(DECLARE_CONFIG_PARAMETER_SIGNATURE) { #if (BOARD_TLE8888_COUNT > 0) engineConfiguration->directSelfStimulation = true; // this engine type is used for board validation - boardConfiguration->triggerSimulatorFrequency = 60; + engineConfiguration->triggerSimulatorFrequency = 60; // set cranking_rpm 500 engineConfiguration->cranking.rpm = 100; // set cranking_dwell 200 @@ -447,64 +447,64 @@ void mreBoardTest(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->specs.firingOrder = FO_1_10_9_4_3_6_5_8_7_2; // red LED #1 - boardConfiguration->ignitionPins[1 - 1] = GPIOD_4; - boardConfiguration->ignitionPins[10 - 1] = GPIOD_3; - boardConfiguration->ignitionPins[9 - 1] = GPIOD_6; - boardConfiguration->ignitionPins[4 - 1] = GPIOD_7; - boardConfiguration->ignitionPins[3 - 1] = GPIOD_1; - boardConfiguration->ignitionPins[6 - 1] = GPIOD_2; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[6] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[7] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[1 - 1] = GPIOD_4; + engineConfiguration->ignitionPins[10 - 1] = GPIOD_3; + engineConfiguration->ignitionPins[9 - 1] = GPIOD_6; + engineConfiguration->ignitionPins[4 - 1] = GPIOD_7; + engineConfiguration->ignitionPins[3 - 1] = GPIOD_1; + engineConfiguration->ignitionPins[6 - 1] = GPIOD_2; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[6] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[7] = GPIO_UNASSIGNED; - boardConfiguration->fuelPumpPin = GPIO_UNASSIGNED; - boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; - boardConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->fuelPumpPin = GPIO_UNASSIGNED; + engineConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; + engineConfiguration->fanPin = GPIO_UNASSIGNED; // fuel pump is useful to test power on/off scenario -// boardConfiguration->fuelPumpPin = TLE8888_PIN_22; +// engineConfiguration->fuelPumpPin = TLE8888_PIN_22; // LED #1 // GPIOE_7: "34 - GP Out 2" - boardConfiguration->injectionPins[1 - 1] = TLE8888_PIN_22;//GPIOE_7; + engineConfiguration->injectionPins[1 - 1] = TLE8888_PIN_22;//GPIOE_7; // LED #2 // TLE8888_PIN_23: "33 - GP Out 3" - boardConfiguration->injectionPins[10 - 1] = TLE8888_PIN_23; + engineConfiguration->injectionPins[10 - 1] = TLE8888_PIN_23; // LED #3 - INJ#1 - boardConfiguration->injectionPins[9 - 1] = GPIOE_13; + engineConfiguration->injectionPins[9 - 1] = GPIOE_13; // LED #4 - INJ#2 - boardConfiguration->injectionPins[4 - 1] = GPIOE_14; + engineConfiguration->injectionPins[4 - 1] = GPIOE_14; // LED #5 - INJ#3 - boardConfiguration->injectionPins[3 - 1] = GPIOE_12; + engineConfiguration->injectionPins[3 - 1] = GPIOE_12; // LED #6 - INJ#4 - boardConfiguration->injectionPins[6 - 1] = GPIOE_11; + engineConfiguration->injectionPins[6 - 1] = GPIOE_11; // LED #7 // TLE8888_PIN_24: "43 - GP Out 4" - boardConfiguration->injectionPins[5 - 1] = TLE8888_PIN_24; + engineConfiguration->injectionPins[5 - 1] = TLE8888_PIN_24; // LED #8 // TLE8888 half bridges (pushpull, lowside, or high-low) IN12 // GPIOE_8: "35 - GP Out 1" - boardConfiguration->injectionPins[8 - 1] = GPIOE_8; + engineConfiguration->injectionPins[8 - 1] = GPIOE_8; // LED #9 // TLE8888 high current low side: IN10 // GPIOE_9: "7 - Lowside 1" - boardConfiguration->injectionPins[7 - 1] = GPIOE_9; + engineConfiguration->injectionPins[7 - 1] = GPIOE_9; // LED #10 // TLE8888 high current low side: VVT2 IN9 / OUT5 // GPIOE_10: "3 - Lowside 2" - boardConfiguration->injectionPins[2 - 1] = GPIOE_10; + engineConfiguration->injectionPins[2 - 1] = GPIOE_10; #endif /* BOARD_TLE8888_COUNT */ } diff --git a/firmware/config/engines/custom_engine.h b/firmware/config/engines/custom_engine.h index 210b04562b..da55c1f5e6 100644 --- a/firmware/config/engines/custom_engine.h +++ b/firmware/config/engines/custom_engine.h @@ -10,8 +10,8 @@ #include "engine_configuration.h" void setFrankensoConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE); -void setFrankenso_01_LCD(board_configuration_s *boardConfiguration); -void disableLCD(board_configuration_s *boardConfiguration); +void setFrankenso_01_LCD(engine_configuration_s *engineConfiguration); +void disableLCD(engine_configuration_s *engineConfiguration); void runSchedulingPrecisionTestIfNeeded(void); void setFrankensoBoardTestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE); void setEtbTestConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE); diff --git a/firmware/config/engines/dodge_neon.cpp b/firmware/config/engines/dodge_neon.cpp index c07d5b80f7..89687a1dba 100644 --- a/firmware/config/engines/dodge_neon.cpp +++ b/firmware/config/engines/dodge_neon.cpp @@ -155,12 +155,12 @@ void setDodgeNeon1995EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // engineConfiguration->spi2MosiMode = PAL_STM32_OTYPE_OPENDRAIN; // 4 // engineConfiguration->spi2MisoMode = PAL_STM32_PUDR_PULLUP; // 32 - // boardConfiguration->spi2mosiPin = GPIOB_15; - // boardConfiguration->spi2misoPin = GPIOB_14; - // boardConfiguration->spi2sckPin = GPIOB_13; - boardConfiguration->cj125CsPin = GPIOB_0; // rev 0.4 - boardConfiguration->isCJ125Enabled = true; - boardConfiguration->is_enabled_spi_2 = true; + // engineConfiguration->spi2mosiPin = GPIOB_15; + // engineConfiguration->spi2misoPin = GPIOB_14; + // engineConfiguration->spi2sckPin = GPIOB_13; + engineConfiguration->cj125CsPin = GPIOB_0; // rev 0.4 + engineConfiguration->isCJ125Enabled = true; + engineConfiguration->is_enabled_spi_2 = true; // set_rpm_hard_limit 4000 @@ -222,28 +222,28 @@ void setDodgeNeon1995EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenstein: low side - out #11: PB8 // Frankenstein: low side - out #12: PB9 - boardConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 - boardConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 - boardConfiguration->injectionPins[2] = GPIOE_3; // Frankenstein: low side - out #8 - boardConfiguration->injectionPins[3] = GPIOE_5; // Frankenstein: low side - out #6 + engineConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 + engineConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 + engineConfiguration->injectionPins[2] = GPIOE_3; // Frankenstein: low side - out #8 + engineConfiguration->injectionPins[3] = GPIOE_5; // Frankenstein: low side - out #6 - boardConfiguration->fuelPumpPin = GPIOC_13; // Frankenstein: low side - out #4 - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->fuelPumpPin = GPIOC_13; // Frankenstein: low side - out #4 + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; engineConfiguration->mapErrorDetectionTooHigh = 120; // set injection_pin_mode 0 - boardConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPinMode = OM_DEFAULT; // Frankenstein: high side #1: PE8 // Frankenstein: high side #2: PE10 - boardConfiguration->ignitionPins[0] = GPIOE_8; // Frankenstein: high side #1 - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOE_10; // // Frankenstein: high side #2 + engineConfiguration->ignitionPins[0] = GPIOE_8; // Frankenstein: high side #1 + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOE_10; // // Frankenstein: high side #2 // set ignition_pin_mode 0 - boardConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPinMode = OM_DEFAULT; engineConfiguration->clt.config = {0, 30, 100, 32500, 7550, 700, 2700}; @@ -253,7 +253,7 @@ void setDodgeNeon1995EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setDefaultFrankensoConfiguration(PASS_CONFIG_PARAMETER_SIGNATURE); engineConfiguration->trigger.type = TT_DODGE_NEON_2003_CAM; - setFrankenso_01_LCD(boardConfiguration); + setFrankenso_01_LCD(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration); // set global_trigger_offset_angle 38 @@ -316,7 +316,7 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setFuelTablesLoadBin(20, 120 PASS_CONFIG_PARAMETER_SUFFIX); - boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; + engineConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; /** * PA4 Wideband O2 Sensor @@ -342,29 +342,29 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenso low out #11: PB8 injector #1 // Frankenso low out #12: PB7 injector #4 - boardConfiguration->fanPin = GPIOD_7; + engineConfiguration->fanPin = GPIOD_7; - boardConfiguration->injectionPins[0] = GPIOB_8; - boardConfiguration->injectionPins[1] = GPIOB_9; - boardConfiguration->injectionPins[2] = GPIOE_2; - boardConfiguration->injectionPins[3] = GPIOB_7; + engineConfiguration->injectionPins[0] = GPIOB_8; + engineConfiguration->injectionPins[1] = GPIOB_9; + engineConfiguration->injectionPins[2] = GPIOE_2; + engineConfiguration->injectionPins[3] = GPIOB_7; - boardConfiguration->ignitionPins[0] = GPIOC_9; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOE_8; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOC_9; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOE_8; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->mainRelayPin = GPIOE_6; + engineConfiguration->mainRelayPin = GPIOE_6; - boardConfiguration->idle.solenoidPin = GPIOC_13; - boardConfiguration->idle.solenoidFrequency = 300; - boardConfiguration->manIdlePosition = 36; + engineConfiguration->idle.solenoidPin = GPIOC_13; + engineConfiguration->idle.solenoidFrequency = 300; + engineConfiguration->manIdlePosition = 36; - boardConfiguration->fuelPumpPin = GPIOE_3; - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->fuelPumpPin = GPIOE_3; + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIOC_6; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIOC_6; /** * Frankenso analog #1 PC2 ADC12 CLT @@ -412,8 +412,8 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { */ engineConfiguration->clt.adcChannel = EFI_ADC_12; - boardConfiguration->sensorChartMode = SC_MAP; - boardConfiguration->isFastAdcEnabled = true; + engineConfiguration->sensorChartMode = SC_MAP; + engineConfiguration->isFastAdcEnabled = true; engineConfiguration->map.sensor.type = MT_DODGE_NEON_2003; engineConfiguration->hip9011Gain = 0.3; @@ -432,8 +432,8 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->cylinderBore = 87.5; - boardConfiguration->clutchDownPin = GPIOC_12; - boardConfiguration->clutchDownPinMode = PI_PULLUP; + engineConfiguration->clutchDownPin = GPIOC_12; + engineConfiguration->clutchDownPinMode = PI_PULLUP; // engineConfiguration->clutchUpPin = GPIOA_14; // note SWCLK - conflict with SWD engineConfiguration->clutchUpPinMode = PI_PULLUP; @@ -452,7 +452,7 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // /** // * set_fsio_setting 1 0.55 // */ -// boardConfiguration->fsio_setting[0] = 0.55; +// engineConfiguration->fsio_setting[0] = 0.55; // setFsioExt(0, GPIOE_5, "0 fsio_setting", 400 PASS_CONFIG_PARAMETER_SUFFIX); #endif @@ -463,11 +463,11 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // engineConfiguration->fanOnTemperature = 115; // knock testing - value is a bit high // engineConfiguration->fanOffTemperature = 100; -// boardConfiguration->tunerStudioSerialSpeed = 9600; - boardConfiguration->tunerStudioSerialSpeed = 19200; +// engineConfiguration->tunerStudioSerialSpeed = 9600; + engineConfiguration->tunerStudioSerialSpeed = 19200; setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX); -//temp boardConfiguration->alternatorControlPin = GPIOD_5; +//temp engineConfiguration->alternatorControlPin = GPIOD_5; engineConfiguration->targetVBatt = 14.0; engineConfiguration->alternatorControl.offset = 20; engineConfiguration->alternatorControl.pFactor = 20; @@ -493,8 +493,8 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->wwaeTau = 0; engineConfiguration->wwaeBeta = 0; - boardConfiguration->isSdCardEnabled = false; - boardConfiguration->manIdlePosition = 36; // set_idle_pwm 40 + engineConfiguration->isSdCardEnabled = false; + engineConfiguration->manIdlePosition = 36; // set_idle_pwm 40 engineConfiguration->slowAdcAlpha = 0.33333; diff --git a/firmware/config/engines/dodge_ram.cpp b/firmware/config/engines/dodge_ram.cpp index 6a12cf9259..1ee445e19f 100644 --- a/firmware/config/engines/dodge_ram.cpp +++ b/firmware/config/engines/dodge_ram.cpp @@ -35,27 +35,27 @@ void setDodgeRam1996(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->specs.firingOrder = FO_1_8_4_3_6_5_7_2; engineConfiguration->specs.displacement = 5.2; - boardConfiguration->triggerInputPins[0] = GPIOC_6; - boardConfiguration->triggerInputPins[1] = GPIOA_5; + engineConfiguration->triggerInputPins[0] = GPIOC_6; + engineConfiguration->triggerInputPins[1] = GPIOA_5; - boardConfiguration->injectionPins[0] = GPIOE_2; - boardConfiguration->injectionPins[1] = GPIOB_9; - boardConfiguration->injectionPins[2] = GPIOD_5; - boardConfiguration->injectionPins[3] = GPIOB_8; + engineConfiguration->injectionPins[0] = GPIOE_2; + engineConfiguration->injectionPins[1] = GPIOB_9; + engineConfiguration->injectionPins[2] = GPIOD_5; + engineConfiguration->injectionPins[3] = GPIOB_8; - boardConfiguration->injectionPins[4] = GPIOB_7; - boardConfiguration->injectionPins[5] = GPIOE_3; - boardConfiguration->injectionPins[6] = GPIOE_4; - boardConfiguration->injectionPins[7] = GPIOD_3; + engineConfiguration->injectionPins[4] = GPIOB_7; + engineConfiguration->injectionPins[5] = GPIOE_3; + engineConfiguration->injectionPins[6] = GPIOE_4; + engineConfiguration->injectionPins[7] = GPIOD_3; - boardConfiguration->ignitionPins[0] = GPIOC_9; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOC_9; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->mainRelayPin = GPIOE_5; - boardConfiguration->fuelPumpPin = GPIOE_6; - boardConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->mainRelayPin = GPIOE_5; + engineConfiguration->fuelPumpPin = GPIOE_6; + engineConfiguration->fanPin = GPIO_UNASSIGNED; engineConfiguration->engineChartSize = 450; @@ -69,11 +69,11 @@ void setDodgeRam1996(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setWholeTimingTable_d(10 PASS_CONFIG_PARAMETER_SUFFIX); - boardConfiguration->alternatorControlPin = GPIOD_7; + engineConfiguration->alternatorControlPin = GPIOD_7; engineConfiguration->alternatorControl.pFactor = 22; - boardConfiguration->idle.solenoidPin = GPIOC_13; - boardConfiguration->idle.solenoidFrequency = 300; + engineConfiguration->idle.solenoidPin = GPIOC_13; + engineConfiguration->idle.solenoidFrequency = 300; engineConfiguration->vbattAdcChannel = EFI_ADC_14; // engineConfiguration->vbattDividerCoeff = ((float) (8.93 + 41.27)) / 8.93 * 2; @@ -82,5 +82,5 @@ void setDodgeRam1996(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setDodgeSensor(&engineConfiguration->clt, 2700); setDodgeSensor(&engineConfiguration->iat, 2700); - boardConfiguration->useStepperIdle = true; + engineConfiguration->useStepperIdle = true; } diff --git a/firmware/config/engines/ford_1995_inline_6.cpp b/firmware/config/engines/ford_1995_inline_6.cpp index b041473081..639516b587 100644 --- a/firmware/config/engines/ford_1995_inline_6.cpp +++ b/firmware/config/engines/ford_1995_inline_6.cpp @@ -82,13 +82,13 @@ void setFordInline6(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // output 5 is PC13 // output 6 is PC15 - boardConfiguration->fuelPumpPin = GPIOC_13; - boardConfiguration->injectionPins[0] = GPIOB_9; - boardConfiguration->injectionPins[1] = GPIOE_3; - boardConfiguration->ignitionPins[0] = GPIOC_15; + engineConfiguration->fuelPumpPin = GPIOC_13; + engineConfiguration->injectionPins[0] = GPIOB_9; + engineConfiguration->injectionPins[1] = GPIOE_3; + engineConfiguration->ignitionPins[0] = GPIOC_15; - boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->fanPin = GPIO_UNASSIGNED; engineConfiguration->tpsMin = convertVoltageTo10bitADC(1.250); engineConfiguration->tpsMax = convertVoltageTo10bitADC(4.538); @@ -96,10 +96,10 @@ void setFordInline6(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // engineConfiguration->vbattAdcChannel = 0; // engineConfiguration->mafAdcChannel = EFI_ADC_1; - boardConfiguration->triggerInputPins[0] = GPIOA_8; - boardConfiguration->triggerInputPins[1] = GPIOA_5; - boardConfiguration->logicAnalyzerPins[0] = GPIOC_6; - boardConfiguration->logicAnalyzerPins[1] = GPIOE_5; + engineConfiguration->triggerInputPins[0] = GPIOA_8; + engineConfiguration->triggerInputPins[1] = GPIOA_5; + engineConfiguration->logicAnalyzerPins[0] = GPIOC_6; + engineConfiguration->logicAnalyzerPins[1] = GPIOE_5; } #endif /* EFI_SUPPORT_1995_FORD_INLINE_6 */ diff --git a/firmware/config/engines/ford_aspire.cpp b/firmware/config/engines/ford_aspire.cpp index f3bbe29921..1568759197 100644 --- a/firmware/config/engines/ford_aspire.cpp +++ b/firmware/config/engines/ford_aspire.cpp @@ -129,8 +129,8 @@ void setFordAspireEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->useOnlyRisingEdgeForTrigger = true; engineConfiguration->trigger.type = TT_FORD_ASPIRE; - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; engineConfiguration->HD44780width = 20; engineConfiguration->HD44780height = 4; diff --git a/firmware/config/engines/ford_festiva.cpp b/firmware/config/engines/ford_festiva.cpp index 894ac85977..69e257aefb 100644 --- a/firmware/config/engines/ford_festiva.cpp +++ b/firmware/config/engines/ford_festiva.cpp @@ -73,7 +73,7 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->trigger.type = TT_MAZDA_DOHC_1_4; - setFrankenso_01_LCD(boardConfiguration); + setFrankenso_01_LCD(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration); setDensoTODO(config); @@ -112,21 +112,21 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { copyFuelTable(racingFestivaVeTable, config->veTable); -// boardConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU -// boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP +// engineConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU +// engineConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP // in case of SOHC distributor we only have one signal -// boardConfiguration->triggerInputPins[0] = GPIOA_5; // 2E White CKP -// boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; +// engineConfiguration->triggerInputPins[0] = GPIOA_5; // 2E White CKP +// engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; // in case of DOHC distributor we have two signals - boardConfiguration->triggerInputPins[0] = GPIOC_6; - boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP + engineConfiguration->triggerInputPins[0] = GPIOC_6; + engineConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP // Denso 195500-2180 engineConfiguration->injector.flow = 265; - boardConfiguration->isFastAdcEnabled = true; + engineConfiguration->isFastAdcEnabled = true; engineConfiguration->map.sensor.type = MT_DENSO183; /** * pin PA4: jumper W47<>W47 - ecu plug 3I @@ -137,7 +137,7 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->afr.hwChannel = EFI_ADC_2; // Frankenso analog #5 // PA2 // set_idle_position 10 - boardConfiguration->manIdlePosition = 10; + engineConfiguration->manIdlePosition = 10; engineConfiguration->crankingIACposition = 65; setWholeIatCorrTimingTable(0 PASS_CONFIG_PARAMETER_SUFFIX); @@ -164,8 +164,8 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setSingleCoilDwell(PASS_CONFIG_PARAMETER_SIGNATURE); engineConfiguration->ignitionMode = IM_ONE_COIL; - boardConfiguration->triggerSimulatorPinModes[0] = OM_OPENDRAIN; - boardConfiguration->triggerSimulatorPinModes[1] = OM_OPENDRAIN; + engineConfiguration->triggerSimulatorPinModes[0] = OM_OPENDRAIN; + engineConfiguration->triggerSimulatorPinModes[1] = OM_OPENDRAIN; // individual coils // W6 PC9 @@ -173,11 +173,11 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // W12 PE8 // W13 PE12 - boardConfiguration->ignitionPins[0] = GPIOC_9; - boardConfiguration->ignitionPins[1] = GPIOC_7; - boardConfiguration->ignitionPins[2] = GPIOE_8; - boardConfiguration->ignitionPins[3] = GPIOE_12; - boardConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPins[0] = GPIOC_9; + engineConfiguration->ignitionPins[1] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOE_8; + engineConfiguration->ignitionPins[3] = GPIOE_12; + engineConfiguration->ignitionPinMode = OM_DEFAULT; engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; @@ -199,18 +199,18 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenso low out #11: PB8 // Frankenso low out #12: PB7 - boardConfiguration->injectionPins[0] = GPIOD_3; - boardConfiguration->injectionPins[1] = GPIOE_2; + engineConfiguration->injectionPins[0] = GPIOD_3; + engineConfiguration->injectionPins[1] = GPIOE_2; // 40% idle is good default - boardConfiguration->idle.solenoidFrequency = 300; - boardConfiguration->idle.solenoidPin = GPIOB_9; + engineConfiguration->idle.solenoidFrequency = 300; + engineConfiguration->idle.solenoidPin = GPIOB_9; - boardConfiguration->malfunctionIndicatorPin = GPIOE_5; - boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; + engineConfiguration->malfunctionIndicatorPin = GPIOE_5; + engineConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; - boardConfiguration->tunerStudioSerialSpeed = 19200; + engineConfiguration->tunerStudioSerialSpeed = 19200; commonFrankensoAnalogInputs(engineConfiguration); setCommonNTCSensor(&engineConfiguration->clt, 2700); @@ -235,7 +235,7 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { * to test * set_fsio_setting 1 5000 */ - boardConfiguration->fsio_setting[0] = 5000; + engineConfiguration->fsio_setting[0] = 5000; // set_fsio_expression 1 "rpm > fsio_setting(1)" setFsioExt(0, GPIOE_3, RPM_ABOVE_USER_SETTING_1, 150 PASS_CONFIG_PARAMETER_SUFFIX); @@ -250,9 +250,9 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { * set_rpn_expression 1 "rpm 0 fsio_setting > coolant 1 fsio_setting > | vbatt 2 fsio_setting < |" * eval "rpm 0 fsio_setting > coolant 1 fsio_setting > | vbatt 2 fsio_setting < |" */ - boardConfiguration->fsio_setting[1] = 6200; // RPM threshold - boardConfiguration->fsio_setting[2] = 90; // CLT threshold - boardConfiguration->fsio_setting[3] = 13.5; // voltage threshold + engineConfiguration->fsio_setting[1] = 6200; // RPM threshold + engineConfiguration->fsio_setting[2] = 90; // CLT threshold + engineConfiguration->fsio_setting[3] = 13.5; // voltage threshold // setFsio(1, GPIOC_13, "rpm 2 fsio_setting > coolant 3 fsio_setting > | vbatt 4 fsio_setting < |" PASS_CONFIG_PARAMETER_SUFFIX); setFsio(1, GPIOD_7, RPM_ABOVE_USER_SETTING_2 PASS_CONFIG_PARAMETER_SUFFIX); @@ -289,7 +289,7 @@ void setFordEscortGt(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->engineLoadAccelEnrichmentThreshold = 5.0; engineConfiguration->engineLoadAccelEnrichmentMultiplier = 1; - boardConfiguration->isSdCardEnabled = true; + engineConfiguration->isSdCardEnabled = true; // engineConfiguration->useFSIO16ForTimingAdjustment = true; // we wanted to have a timinig table adjustment switch here diff --git a/firmware/config/engines/honda_600.cpp b/firmware/config/engines/honda_600.cpp index 5a00607f04..66c1ba5b22 100644 --- a/firmware/config/engines/honda_600.cpp +++ b/firmware/config/engines/honda_600.cpp @@ -69,8 +69,8 @@ void setHonda600(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->fuelAlgorithm = LM_ALPHA_N; // upside down wiring - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIOC_6; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIOC_6; // set global_trigger_offset_angle 180 @@ -90,7 +90,7 @@ void setHonda600(DECLARE_CONFIG_PARAMETER_SIGNATURE) { //setIndividualCoilsIgnition(); - setFrankenso_01_LCD(boardConfiguration); + setFrankenso_01_LCD(engineConfiguration); commonFrankensoAnalogInputs(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration); #if IGN_LOAD_COUNT == DEFAULT_IGN_LOAD_COUNT @@ -138,33 +138,33 @@ void setHonda600(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenso low out #11: PB8 injector #3 // Frankenso low out #12: PB7 injector #4 - boardConfiguration->fuelPumpPin = GPIOE_4; - boardConfiguration->mainRelayPin = GPIOD_7; - boardConfiguration->idle.solenoidPin = GPIOC_13; + engineConfiguration->fuelPumpPin = GPIOE_4; + engineConfiguration->mainRelayPin = GPIOD_7; + engineConfiguration->idle.solenoidPin = GPIOC_13; - boardConfiguration->fanPin = GPIOE_5; + engineConfiguration->fanPin = GPIOE_5; - boardConfiguration->injectionPins[0] = GPIOB_9; // #1 - boardConfiguration->injectionPins[1] = GPIOD_5; // #2 - boardConfiguration->injectionPins[2] = GPIOB_7; // #3 - boardConfiguration->injectionPins[3] = GPIOB_8; // #4 + engineConfiguration->injectionPins[0] = GPIOB_9; // #1 + engineConfiguration->injectionPins[1] = GPIOD_5; // #2 + engineConfiguration->injectionPins[2] = GPIOB_7; // #3 + engineConfiguration->injectionPins[3] = GPIOB_8; // #4 setDefaultCustomMaps(PASS_CONFIG_PARAMETER_SIGNATURE); setAlgorithm(LM_ALPHA_N PASS_CONFIG_PARAMETER_SUFFIX); - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[6] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[7] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[8] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[9] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[10] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[11] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[6] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[7] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[8] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[9] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[10] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[11] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[0] = GPIOE_14; - boardConfiguration->ignitionPins[1] = GPIOC_7; - boardConfiguration->ignitionPins[2] = GPIOE_10; - boardConfiguration->ignitionPins[3] = GPIOC_9; // #4 + engineConfiguration->ignitionPins[0] = GPIOE_14; + engineConfiguration->ignitionPins[1] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOE_10; + engineConfiguration->ignitionPins[3] = GPIOC_9; // #4 // todo: 8.2 or 10k? engineConfiguration->vbattDividerCoeff = ((float) (10 + 33)) / 10 * 2; diff --git a/firmware/config/engines/honda_accord.cpp b/firmware/config/engines/honda_accord.cpp index 6b9e6db0c6..89364d2c1e 100644 --- a/firmware/config/engines/honda_accord.cpp +++ b/firmware/config/engines/honda_accord.cpp @@ -39,7 +39,7 @@ EXTERN_CONFIG; static void setHondaAccordConfigurationCommon(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->map.sensor.type = MT_DENSO183; - boardConfiguration->isFastAdcEnabled = true; + engineConfiguration->isFastAdcEnabled = true; // set ignition_mode 0 engineConfiguration->ignitionMode = IM_ONE_COIL; @@ -148,29 +148,29 @@ static void setHondaAccordConfigurationCommon(DECLARE_CONFIG_PARAMETER_SIGNATURE // Frankenso low out #10: PD5 Injector #3 // Frankenso low out #11: PB8 injector #1 // Frankenso low out #12: PB7 injector #4 - boardConfiguration->fuelPumpPin = GPIOE_3; - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; - boardConfiguration->malfunctionIndicatorPin = GPIOE_2; - boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; - boardConfiguration->fanPin = GPIOE_4; // blue wire + engineConfiguration->fuelPumpPin = GPIOE_3; + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->malfunctionIndicatorPin = GPIOE_2; + engineConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; + engineConfiguration->fanPin = GPIOE_4; // blue wire - boardConfiguration->idle.solenoidPin = GPIOD_3; // green wire + engineConfiguration->idle.solenoidPin = GPIOD_3; // green wire - boardConfiguration->injectionPins[0] = GPIOB_8; - boardConfiguration->injectionPins[1] = GPIOB_9; - boardConfiguration->injectionPins[2] = GPIOD_5; - boardConfiguration->injectionPins[3] = GPIOB_7; + engineConfiguration->injectionPins[0] = GPIOB_8; + engineConfiguration->injectionPins[1] = GPIOB_9; + engineConfiguration->injectionPins[2] = GPIOD_5; + engineConfiguration->injectionPins[3] = GPIOB_7; - boardConfiguration->ignitionPins[0] = GPIOE_12; // white wire - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOE_12; // white wire + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - setFrankenso_01_LCD(boardConfiguration); + setFrankenso_01_LCD(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration); - boardConfiguration->idle.solenoidFrequency = 500; + engineConfiguration->idle.solenoidFrequency = 500; } /* diff --git a/firmware/config/engines/lada_kalina.cpp b/firmware/config/engines/lada_kalina.cpp index ed03a3b18d..56f77539bc 100644 --- a/firmware/config/engines/lada_kalina.cpp +++ b/firmware/config/engines/lada_kalina.cpp @@ -15,35 +15,35 @@ EXTERN_CONFIG; void setLadaKalina(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setFrankensoConfiguration(PASS_CONFIG_PARAMETER_SIGNATURE); - disableLCD(boardConfiguration); + disableLCD(engineConfiguration); - boardConfiguration->HD44780_rs = GPIO_UNASSIGNED; - boardConfiguration->HD44780_e = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db4 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db5 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db6 = GPIO_UNASSIGNED; - boardConfiguration->HD44780_db7 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_rs = GPIO_UNASSIGNED; + engineConfiguration->HD44780_e = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db4 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db5 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db6 = GPIO_UNASSIGNED; + engineConfiguration->HD44780_db7 = GPIO_UNASSIGNED; setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR); engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2; - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; engineConfiguration->globalTriggerAngleOffset = 114; - boardConfiguration->ignitionPins[0] = GPIOE_14; - boardConfiguration->ignitionPins[1] = GPIOC_7; - boardConfiguration->ignitionPins[2] = GPIOC_9; - boardConfiguration->ignitionPins[3] = GPIOE_12; + engineConfiguration->ignitionPins[0] = GPIOE_14; + engineConfiguration->ignitionPins[1] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOC_9; + engineConfiguration->ignitionPins[3] = GPIOE_12; - boardConfiguration->useStepperIdle = true; - boardConfiguration->fuelPumpPin = GPIOC_13; - boardConfiguration->mainRelayPin = GPIOD_7; + engineConfiguration->useStepperIdle = true; + engineConfiguration->fuelPumpPin = GPIOC_13; + engineConfiguration->mainRelayPin = GPIOD_7; - boardConfiguration->idle.stepperDirectionPin = GPIOE_15; - boardConfiguration->idle.stepperStepPin = GPIOE_13; + engineConfiguration->idle.stepperDirectionPin = GPIOE_15; + engineConfiguration->idle.stepperStepPin = GPIOE_13; engineConfiguration->stepperEnablePin = GPIOE_11; @@ -54,7 +54,7 @@ void setLadaKalina(DECLARE_CONFIG_PARAMETER_SIGNATURE) { * to test * set_fsio_setting 1 5000 */ - engineConfiguration->bc.fsio_setting[0] = 500; + engineConfiguration->fsio_setting[0] = 500; // set_rpn_expression 1 "rpm 0 fsio_setting <" setFsioExt(0, GPIOE_3, RPM_BELOW_USER_SETTING_1, 0 PASS_CONFIG_PARAMETER_SUFFIX); #endif /* EFI_FSIO */ diff --git a/firmware/config/engines/mazda_626.cpp b/firmware/config/engines/mazda_626.cpp index a75e558467..880c7a8a9f 100644 --- a/firmware/config/engines/mazda_626.cpp +++ b/firmware/config/engines/mazda_626.cpp @@ -26,7 +26,7 @@ void setMazda626EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // engineConfiguration->trigger.type = TT_MAZDA_DOHC_1_4; // with this complex trigger we do not need this by default - boardConfiguration->sensorChartMode = SC_OFF; + engineConfiguration->sensorChartMode = SC_OFF; engineConfiguration->useOnlyRisingEdgeForTrigger = true; @@ -103,6 +103,6 @@ void setMazda626EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->externalKnockSenseAdc = EFI_ADC_4; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = GPIOA_5; } diff --git a/firmware/config/engines/mazda_miata.cpp b/firmware/config/engines/mazda_miata.cpp index 6ab448d89d..2ea2a44160 100644 --- a/firmware/config/engines/mazda_miata.cpp +++ b/firmware/config/engines/mazda_miata.cpp @@ -135,14 +135,14 @@ static void commonMiataNa(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->trigger.type = TT_MAZDA_MIATA_NA; engineConfiguration->engineChartSize = 100; - boardConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU - boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP + engineConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU + engineConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP engineConfiguration->ignitionMode = IM_WASTED_SPARK; setFuelLoadBin(1.2, 4.4 PASS_CONFIG_PARAMETER_SUFFIX); setFuelRpmBin(800, 7000 PASS_CONFIG_PARAMETER_SUFFIX); - boardConfiguration->idle.solenoidFrequency = 160; + engineConfiguration->idle.solenoidFrequency = 160; // Frankenstein: high side #1 is PE8 // Frankenstein: high side #2 is PE10 @@ -151,16 +151,16 @@ static void commonMiataNa(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenstein: high side #5 is PC9 // Frankenstein: high side #6 is PC7 - boardConfiguration->ignitionPins[0] = GPIOE_12; // Frankenstein: high side #3 - boardConfiguration->ignitionPins[1] = GPIOE_14; // Frankenstein: high side #4 - boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPins[0] = GPIOE_12; // Frankenstein: high side #3 + engineConfiguration->ignitionPins[1] = GPIOE_14; // Frankenstein: high side #4 + engineConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPinMode = OM_DEFAULT; setDefaultCrankingFuel(engineConfiguration); - boardConfiguration->triggerSimulatorPinModes[0] = OM_OPENDRAIN; - boardConfiguration->triggerSimulatorPinModes[1] = OM_OPENDRAIN; + engineConfiguration->triggerSimulatorPinModes[0] = OM_OPENDRAIN; + engineConfiguration->triggerSimulatorPinModes[1] = OM_OPENDRAIN; setCommonNTCSensor(&engineConfiguration->clt, 2700); setCommonNTCSensor(&engineConfiguration->iat, 2700); @@ -174,7 +174,7 @@ void common079721_2351(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->specs.cylindersCount = 4; engineConfiguration->specs.firingOrder = FO_1_3_4_2; - boardConfiguration->fuelPumpPin = GPIO_UNASSIGNED; // fuel pump is not controlled by ECU on this engine + engineConfiguration->fuelPumpPin = GPIO_UNASSIGNED; // fuel pump is not controlled by ECU on this engine // set cranking_injection_mode 0 engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS; @@ -221,13 +221,13 @@ void setMiata1990(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenstein: low side - out #11: PB8 // Frankenstein: low side - out #12: PB9 - boardConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 - boardConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 - boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 + engineConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 + engineConfiguration->injectionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPinMode = OM_DEFAULT; // todo: idleValvePin } @@ -250,17 +250,17 @@ static void setMiata1994_common(DECLARE_CONFIG_PARAMETER_SIGNATURE) { copyTimingTable(miataNA8_maf_advance_table, config->ignitionTable); #endif -// boardConfiguration->triggerSimulatorPins[0] = GPIOD_2; // 2G - YEL/BLU -// boardConfiguration->triggerSimulatorPins[1] = GPIOB_3; // 2E - WHT - four times -// boardConfiguration->triggerSimulatorPinModes[0] = OM_OPENDRAIN; -// boardConfiguration->triggerSimulatorPinModes[1] = OM_OPENDRAIN; +// engineConfiguration->triggerSimulatorPins[0] = GPIOD_2; // 2G - YEL/BLU +// engineConfiguration->triggerSimulatorPins[1] = GPIOB_3; // 2E - WHT - four times +// engineConfiguration->triggerSimulatorPinModes[0] = OM_OPENDRAIN; +// engineConfiguration->triggerSimulatorPinModes[1] = OM_OPENDRAIN; // -// boardConfiguration->triggerInputPins[0] = GPIO_UNASSIGNED; -// boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; +// engineConfiguration->triggerInputPins[0] = GPIO_UNASSIGNED; +// engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; // -// boardConfiguration->is_enabled_spi_1 = false; -// boardConfiguration->is_enabled_spi_2 = false; -// boardConfiguration->is_enabled_spi_3 = false; +// engineConfiguration->is_enabled_spi_1 = false; +// engineConfiguration->is_enabled_spi_2 = false; +// engineConfiguration->is_enabled_spi_3 = false; /** * Outputs @@ -277,25 +277,25 @@ static void setMiata1994_common(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenso low out #10: PE0 (do not use with discovery!) // Frankenso low out #11: PB8 // Frankenso low out #12: PB7 - boardConfiguration->fanPin = GPIOE_6; + engineConfiguration->fanPin = GPIOE_6; - boardConfiguration->o2heaterPin = GPIO_UNASSIGNED; + engineConfiguration->o2heaterPin = GPIO_UNASSIGNED; - boardConfiguration->fuelPumpPin = GPIOE_4; + engineConfiguration->fuelPumpPin = GPIOE_4; - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPinMode = OM_DEFAULT; - boardConfiguration->idle.solenoidPin = GPIOB_9; + engineConfiguration->idle.solenoidPin = GPIOB_9; - boardConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOC_7; // Frankenso high side - pin 1H - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOC_7; // Frankenso high side - pin 1H + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPinMode = OM_DEFAULT; - setFrankenso_01_LCD(boardConfiguration); + setFrankenso_01_LCD(engineConfiguration); commonFrankensoAnalogInputs(engineConfiguration); @@ -318,13 +318,13 @@ void setMiata1994_d(DECLARE_CONFIG_PARAMETER_SIGNATURE) { /** * This board was avoiding PE0 & PE1 mosfets altogether */ - boardConfiguration->injectionPins[0] = GPIOD_7; // avoiding PE1 - boardConfiguration->injectionPins[1] = GPIOE_2; - boardConfiguration->injectionPins[2] = GPIOB_8; - boardConfiguration->injectionPins[3] = GPIOB_7; + engineConfiguration->injectionPins[0] = GPIOD_7; // avoiding PE1 + engineConfiguration->injectionPins[1] = GPIOE_2; + engineConfiguration->injectionPins[2] = GPIOB_8; + engineConfiguration->injectionPins[3] = GPIOB_7; // todo: add the diode? change idle valve logic? - boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; + engineConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; } /** @@ -342,31 +342,31 @@ void setMiata1996(DECLARE_CONFIG_PARAMETER_SIGNATURE) { #endif // upside down - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIOC_6; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIOC_6; - boardConfiguration->fuelPumpPin = GPIOE_4; - boardConfiguration->idle.solenoidPin = GPIOE_5; + engineConfiguration->fuelPumpPin = GPIOE_4; + engineConfiguration->idle.solenoidPin = GPIOE_5; engineConfiguration->mafAdcChannel = EFI_ADC_1; engineConfiguration->clt.adcChannel = EFI_ADC_11; engineConfiguration->tps1_1AdcChannel = EFI_ADC_13; - boardConfiguration->ignitionPins[0] = GPIOE_12; // Frankenstein: high side #3 - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOE_14; // Frankenstein: high side #4 - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPins[0] = GPIOE_12; // Frankenstein: high side #3 + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOE_14; // Frankenstein: high side #4 + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPinMode = OM_DEFAULT; // harness is sequential but we have a limited board engineConfiguration->crankingInjectionMode = IM_BATCH; engineConfiguration->injectionMode = IM_BATCH; - boardConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 - boardConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 - boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 + engineConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 + engineConfiguration->injectionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPinMode = OM_DEFAULT; } diff --git a/firmware/config/engines/mazda_miata_1_6.cpp b/firmware/config/engines/mazda_miata_1_6.cpp index c84624c382..33a746ebda 100644 --- a/firmware/config/engines/mazda_miata_1_6.cpp +++ b/firmware/config/engines/mazda_miata_1_6.cpp @@ -114,7 +114,7 @@ static void miataNAcommonEngineSettings(DECLARE_CONFIG_PARAMETER_SIGNATURE) { copyTimingTable(mapBased16IgnitionTable, config->ignitionTable); #endif - boardConfiguration->idle.solenoidFrequency = 160; + engineConfiguration->idle.solenoidFrequency = 160; engineConfiguration->ignitionMode = IM_WASTED_SPARK; } @@ -122,16 +122,16 @@ void miataNAcommon(DECLARE_CONFIG_PARAMETER_SIGNATURE) { miataNAcommonEngineSettings(PASS_CONFIG_PARAMETER_SIGNATURE); - boardConfiguration->idle.solenoidPin = GPIOB_9; // this W61 <> W61 jumper, pin 3W + engineConfiguration->idle.solenoidPin = GPIOB_9; // this W61 <> W61 jumper, pin 3W - boardConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOC_7; // Frankenso high side - pin 1H - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOC_7; // Frankenso high side - pin 1H + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; } static void setMiataNA6_settings(DECLARE_CONFIG_PARAMETER_SIGNATURE) { - engineConfiguration->bc.isFasterEngineSpinUpEnabled = true; + engineConfiguration->isFasterEngineSpinUpEnabled = true; memcpy(config->veRpmBins, ve16RpmBins, sizeof(ve16RpmBins)); memcpy(config->veLoadBins, ve16LoadBins, sizeof(ve16LoadBins)); @@ -202,8 +202,8 @@ void setMiataNA6_MAP_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setFrankensoConfiguration(PASS_CONFIG_PARAMETER_SIGNATURE); - boardConfiguration->isHip9011Enabled = false; - boardConfiguration->isSdCardEnabled = false; + engineConfiguration->isHip9011Enabled = false; + engineConfiguration->isSdCardEnabled = false; setMiataNA6_settings(PASS_CONFIG_PARAMETER_SIGNATURE); @@ -217,7 +217,7 @@ void setMiataNA6_MAP_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->vbattDividerCoeff = 9.75;// ((float) (8.2 + 33)) / 8.2 * 2; - boardConfiguration->isSdCardEnabled = true; + engineConfiguration->isSdCardEnabled = true; // /** // * oil pressure line @@ -238,14 +238,14 @@ void setMiataNA6_MAP_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) { */ /* //WARNING: these indeces are off - boardConfiguration->fsio_setting[0] = 6400; // RPM threshold - boardConfiguration->fsio_setting[1] = 100; // CLT threshold, fsio_setting #2 - boardConfiguration->fsio_setting[2] = 13.0; // voltage threshold, fsio_setting #3 + engineConfiguration->fsio_setting[0] = 6400; // RPM threshold + engineConfiguration->fsio_setting[1] = 100; // CLT threshold, fsio_setting #2 + engineConfiguration->fsio_setting[2] = 13.0; // voltage threshold, fsio_setting #3 // set_fsio_setting 4 3000 - boardConfiguration->fsio_setting[3] = 3000; // oil pressure RPM, fsio_setting #4 + engineConfiguration->fsio_setting[3] = 3000; // oil pressure RPM, fsio_setting #4 // set_fsio_setting 5 0.52 - boardConfiguration->fsio_setting[4] = 0.52; // oil pressure threshold, fsio_setting #5 + engineConfiguration->fsio_setting[4] = 0.52; // oil pressure threshold, fsio_setting #5 */ // * set_rpn_expression 1 "rpm 3 fsio_setting >" @@ -259,17 +259,17 @@ void setMiataNA6_MAP_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setFsio(0, GPIOC_13, COMBINED_WARNING_LIGHT PASS_CONFIG_PARAMETER_SUFFIX); #endif /* EFI_FSIO */ - boardConfiguration->injectionPins[0] = GPIOD_3; // #1&3 pin 3U - boardConfiguration->injectionPins[1] = GPIOE_2; // #2&4 pin 3V - boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[0] = GPIOD_3; // #1&3 pin 3U + engineConfiguration->injectionPins[1] = GPIOE_2; // #2&4 pin 3V + engineConfiguration->injectionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[3] = GPIO_UNASSIGNED; // white wire from 1E - TOP of W4 to BOTTOM W62 - boardConfiguration->malfunctionIndicatorPin = GPIOD_5; + engineConfiguration->malfunctionIndicatorPin = GPIOD_5; // yellow wire from 1V/W22 to bottom of W48 - boardConfiguration->clutchDownPin = GPIOA_3; - boardConfiguration->clutchDownPinMode = PI_PULLUP; + engineConfiguration->clutchDownPin = GPIOA_3; + engineConfiguration->clutchDownPinMode = PI_PULLUP; // 110mm red wire from 1N/W14 to bottom of W45 @@ -280,7 +280,7 @@ void setMiataNA6_MAP_Frankenso(DECLARE_CONFIG_PARAMETER_SIGNATURE) { #if ! EFI_UNIT_TEST // W57 PE3 A/C compressor relay out - boardConfiguration->acRelayPin = GPIOE_3; + engineConfiguration->acRelayPin = GPIOE_3; // W58 PE4 A/C fan relay out #endif /* EFI_UNIT_TEST */ @@ -311,17 +311,17 @@ void setMiataNA6_VAF_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // MAF/VAF: "19 - AN volt 4" engineConfiguration->mafAdcChannel = EFI_ADC_12; - //boardConfiguration->triggerInputPins[0] = GPIOC_6; - boardConfiguration->triggerInputPins[1] = GPIOA_5; + //engineConfiguration->triggerInputPins[0] = GPIOC_6; + engineConfiguration->triggerInputPins[1] = GPIOA_5; engineConfiguration->camInputs[0] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[0] = GPIOD_7; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOD_6; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOD_7; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOD_6; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[3] = GPIO_UNASSIGNED; // tps = "20 - AN volt 5" //engineConfiguration->tps1_1AdcChannel = EFI_ADC_13; @@ -332,7 +332,7 @@ void setMiataNA6_VAF_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // TLE8888_PIN_24: "43 - GP Out 4" // MIL check engine // NA6 check engine light is just a normal low side driver - boardConfiguration->malfunctionIndicatorPin = TLE8888_PIN_24; + engineConfiguration->malfunctionIndicatorPin = TLE8888_PIN_24; // IAC: GPIOE_9: "7 - Lowside 1" @@ -342,8 +342,8 @@ void setMiataNA6_VAF_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // engineConfiguration->vbattDividerCoeff = (66.0f / 10.0f) * engineConfiguration->analogInputDividerCoefficient; - boardConfiguration->isHip9011Enabled = false; - boardConfiguration->isSdCardEnabled = false; + engineConfiguration->isHip9011Enabled = false; + engineConfiguration->isSdCardEnabled = false; setMiataNA6_settings(PASS_CONFIG_PARAMETER_SIGNATURE); miataNAcommonEngineSettings(PASS_CONFIG_PARAMETER_SIGNATURE); diff --git a/firmware/config/engines/mazda_miata_custom_hunchback.cpp b/firmware/config/engines/mazda_miata_custom_hunchback.cpp index 32c0895a58..6efaf285dd 100644 --- a/firmware/config/engines/mazda_miata_custom_hunchback.cpp +++ b/firmware/config/engines/mazda_miata_custom_hunchback.cpp @@ -122,7 +122,7 @@ void setMazdaMiata2003EngineConfigurationNaFuelRail(DECLARE_CONFIG_PARAMETER_SIG memcpy(config->afrLoadBins, mazda_miata_nb2_targetAfrLoadBins, sizeof(mazda_miata_nb2_targetAfrLoadBins)); copyTargetAfrTable(target_AFR_hunchback, config->afrTable); - boardConfiguration->ignitionPins[2] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOC_7; // Frankenso analog #7 pin 3J, W48 top <>W48 bottom jumper, not OEM engineConfiguration->afr.hwChannel = EFI_ADC_3; // PA3 @@ -145,7 +145,7 @@ void setMazdaMiata2003EngineConfigurationNaFuelRail(DECLARE_CONFIG_PARAMETER_SIG engineConfiguration->rpmHardLimit = 7200; // we want to survive the race, but we also want some fun! // set idle_position 30 - boardConfiguration->manIdlePosition = 30; + engineConfiguration->manIdlePosition = 30; engineConfiguration->crankingIACposition = 65; } diff --git a/firmware/config/engines/mazda_miata_na8.cpp b/firmware/config/engines/mazda_miata_na8.cpp index 32415cc461..8c22452187 100644 --- a/firmware/config/engines/mazda_miata_na8.cpp +++ b/firmware/config/engines/mazda_miata_na8.cpp @@ -41,10 +41,10 @@ void setMazdaMiataNA8Configuration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->vbattDividerCoeff = 9.75;// ((float) (8.2 + 33)) / 8.2 * 2; - boardConfiguration->injectionPins[0] = GPIOD_3; // #1 pin 3U - boardConfiguration->injectionPins[1] = GPIOE_2; // #2 pin 3V - boardConfiguration->injectionPins[2] = GPIOB_8; // #3 pin 3Y - boardConfiguration->injectionPins[3] = GPIOB_7; // #4 pin 3Z + engineConfiguration->injectionPins[0] = GPIOD_3; // #1 pin 3U + engineConfiguration->injectionPins[1] = GPIOE_2; // #2 pin 3V + engineConfiguration->injectionPins[2] = GPIOB_8; // #3 pin 3Y + engineConfiguration->injectionPins[3] = GPIOB_7; // #4 pin 3Z engineConfiguration->injectionMode = IM_SEQUENTIAL; } diff --git a/firmware/config/engines/mazda_miata_nb.cpp b/firmware/config/engines/mazda_miata_nb.cpp index a1eda0b209..7449a4e953 100644 --- a/firmware/config/engines/mazda_miata_nb.cpp +++ b/firmware/config/engines/mazda_miata_nb.cpp @@ -45,33 +45,33 @@ void setMazdaMiataNb1EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->iat.adcChannel = EFI_ADC_13; engineConfiguration->afr.hwChannel = EFI_ADC_2; // PA2 - boardConfiguration->idle.solenoidPin = GPIOE_0; - boardConfiguration->idle.solenoidPinMode = OM_DEFAULT; + engineConfiguration->idle.solenoidPin = GPIOE_0; + engineConfiguration->idle.solenoidPinMode = OM_DEFAULT; - boardConfiguration->fuelPumpPin = GPIOC_14; // Frankenstein: low side - out #4 - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->fuelPumpPin = GPIOC_14; // Frankenstein: low side - out #4 + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; - boardConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 - boardConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 - boardConfiguration->injectionPins[2] = GPIOE_3; // Frankenstein: low side - out #8 - boardConfiguration->injectionPins[3] = GPIOE_5; // Frankenstein: low side - out #6 - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 + engineConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 + engineConfiguration->injectionPins[2] = GPIOE_3; // Frankenstein: low side - out #8 + engineConfiguration->injectionPins[3] = GPIOE_5; // Frankenstein: low side - out #6 + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPinMode = OM_DEFAULT; - boardConfiguration->ignitionPins[0] = GPIOE_10; // Frankenstein: high side #1 - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOC_9; // // Frankenstein: high side #2 - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPinMode = OM_INVERTED; + engineConfiguration->ignitionPins[0] = GPIOE_10; // Frankenstein: high side #1 + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOC_9; // // Frankenstein: high side #2 + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPinMode = OM_INVERTED; - boardConfiguration->malfunctionIndicatorPin = GPIOE_1; - boardConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; + engineConfiguration->malfunctionIndicatorPin = GPIOE_1; + engineConfiguration->malfunctionIndicatorPinMode = OM_DEFAULT; - boardConfiguration->fanPin = GPIOE_6; - boardConfiguration->fanPinMode = OM_DEFAULT; + engineConfiguration->fanPin = GPIOE_6; + engineConfiguration->fanPinMode = OM_DEFAULT; - boardConfiguration->clutchDownPin = GPIO_UNASSIGNED; + engineConfiguration->clutchDownPin = GPIO_UNASSIGNED; // set_whole_fuel_map 3 setWholeFuelMap(3 PASS_CONFIG_PARAMETER_SUFFIX); @@ -84,7 +84,7 @@ void setMazdaMiataNb1EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { * to test * set_fsio_setting 1 5000 */ - boardConfiguration->fsio_setting[0] = 5000; + engineConfiguration->fsio_setting[0] = 5000; // (self and (rpm > 4800)) OR (rpm > 5000) // set_rpn_expression 1 "self rpm 4800 > & rpm 5000 > OR" // setFsioExt(0, GPIOE_3, "self rpm 4800 > & rpm 5000 > OR", 150 PASS_CONFIG_PARAMETER_SUFFIX); diff --git a/firmware/config/engines/mazda_miata_vvt.cpp b/firmware/config/engines/mazda_miata_vvt.cpp index cb87c96203..ec68b2f37b 100644 --- a/firmware/config/engines/mazda_miata_vvt.cpp +++ b/firmware/config/engines/mazda_miata_vvt.cpp @@ -197,14 +197,14 @@ static void setMazdaMiataEngineNB2Defaults(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // 0.1375 // 6.375 // 10.625 - boardConfiguration->miataNb2VVTRatioFrom = 8.50 * 0.75; - boardConfiguration->miataNb2VVTRatioTo = 14; + engineConfiguration->miataNb2VVTRatioFrom = 8.50 * 0.75; + engineConfiguration->miataNb2VVTRatioTo = 14; engineConfiguration->nbVvtIndex = 0; engineConfiguration->auxPidFrequency[0] = 300; // VVT solenoid control // set idle_position 35 - boardConfiguration->manIdlePosition = 35; + engineConfiguration->manIdlePosition = 35; engineConfiguration->specs.cylindersCount = 4; engineConfiguration->specs.firingOrder = FO_1_3_4_2; @@ -292,29 +292,29 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setMazdaMiataEngineNB2Defaults(PASS_CONFIG_PARAMETER_SIGNATURE); -// boardConfiguration->triggerInputPins[0] = GPIOA_8; // custom Frankenso wiring in order to use SPI1 for accelerometer - boardConfiguration->triggerInputPins[0] = GPIOA_5; // board still not modified - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; +// engineConfiguration->triggerInputPins[0] = GPIOA_8; // custom Frankenso wiring in order to use SPI1 for accelerometer + engineConfiguration->triggerInputPins[0] = GPIOA_5; // board still not modified + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = GPIOC_6; -// boardConfiguration->is_enabled_spi_1 = true; +// engineConfiguration->is_enabled_spi_1 = true; engineConfiguration->twoWireBatchInjection = true; // this is needed for #492 testing - boardConfiguration->alternatorControlPin = GPIOE_10; - boardConfiguration->alternatorControlPinMode = OM_OPENDRAIN; + engineConfiguration->alternatorControlPin = GPIOE_10; + engineConfiguration->alternatorControlPinMode = OM_OPENDRAIN; // engineConfiguration->vehicleSpeedSensorInputPin = GPIOA_8; - boardConfiguration->vvtCamSensorUseRise = true; + engineConfiguration->vvtCamSensorUseRise = true; engineConfiguration->vvtDisplayInverted = true; engineConfiguration->auxPidPins[0] = GPIOE_3; // VVT solenoid control // /** // * set_fsio_setting 1 0.55 // */ - boardConfiguration->fsio_setting[0] = 0.0; + engineConfiguration->fsio_setting[0] = 0.0; // setFsioExt(0, GPIOE_3, "0 fsio_setting", 400 PASS_CONFIG_PARAMETER_SUFFIX); @@ -341,10 +341,10 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { * Miata coil on #4 PE14 - white ECU wire "1&4" */ - boardConfiguration->ignitionPins[0] = GPIOE_14; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOC_9; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOE_14; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOC_9; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; // set tps_min 90 engineConfiguration->tpsMin = 100; // convert 12to10 bit (ADC/4) @@ -354,11 +354,11 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { - boardConfiguration->malfunctionIndicatorPin = GPIOD_5; + engineConfiguration->malfunctionIndicatorPin = GPIOD_5; -// boardConfiguration->malfunctionIndicatorPin = GPIOD_9; -// boardConfiguration->malfunctionIndicatorPinMode = OM_INVERTED; +// engineConfiguration->malfunctionIndicatorPin = GPIOD_9; +// engineConfiguration->malfunctionIndicatorPinMode = OM_INVERTED; // todo: blue jumper wire - what is it?! // Frankenso analog #6 pin 3R, W56 (5th lower row pin from the end) top <> W45 bottom jumper, not OEM @@ -383,9 +383,9 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { * set_fsio_setting 3 65 * set_fsio_setting 4 15 */ - boardConfiguration->fsio_setting[1] = 6500; // #2 RPM threshold - boardConfiguration->fsio_setting[2] = 105; // #3 CLT threshold - boardConfiguration->fsio_setting[3] = 12.0; // #4 voltage threshold + engineConfiguration->fsio_setting[1] = 6500; // #2 RPM threshold + engineConfiguration->fsio_setting[2] = 105; // #3 CLT threshold + engineConfiguration->fsio_setting[3] = 12.0; // #4 voltage threshold // setFsio(1, GPIOE_6, COMBINED_WARNING_LIGHT PASS_CONFIG_PARAMETER_SUFFIX); @@ -422,7 +422,7 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->tps1_1AdcChannel = EFI_ADC_13; // PC3 engineConfiguration->idleMode = IM_AUTO; - CONFIGB(useETBforIdleControl) = true; + CONFIG(useETBforIdleControl) = true; // set_analog_input_pin pps PA2 engineConfiguration->throttlePedalPositionAdcChannel = EFI_ADC_2; @@ -432,7 +432,7 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->idleRpmPid.dFactor = 5; engineConfiguration->idleRpmPid.periodMs = 10; - engineConfiguration->bc.isFasterEngineSpinUpEnabled = true; + engineConfiguration->isFasterEngineSpinUpEnabled = true; //set etb_p 12 engineConfiguration->etb.pFactor = 12; // a bit lower p-factor seems to work better on TLE9201? MRE? @@ -473,7 +473,7 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { void setMazdaMiata2003EngineConfigurationBoardTest(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setMazdaMiata2003EngineConfiguration(PASS_CONFIG_PARAMETER_SIGNATURE); - boardConfiguration->ignitionPins[2] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOC_7; // Frankenso analog #7 pin 3J, W48 top <>W48 bottom jumper, not OEM. Make sure 500K pull-down on Frankenso engineConfiguration->afr.hwChannel = EFI_ADC_3; // PA3 @@ -499,15 +499,15 @@ void setMiataNB2_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // tps1_1AdcChannel input is inherited from boards/microrusefi/board_configuration.cpp // afr.hwChannel input is inherited from boards/microrusefi/board_configuration.cpp - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = GPIOA_5; engineConfiguration->useOnlyRisingEdgeForTrigger = false; engineConfiguration->useTLE8888_hall_mode = true; // GPIOD_6: "13 - GP Out 6" - selected to +12v - boardConfiguration->alternatorControlPin = GPIOD_6; + engineConfiguration->alternatorControlPin = GPIOD_6; // GPIOD_7: "14 - GP Out 5" - selected to +12v engineConfiguration->dizzySparkOutputPin = GPIOD_7; // tachometer @@ -525,7 +525,7 @@ void setMiataNB2_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->auxPidPins[0] = GPIOE_9; // VVT solenoid control // TLE8888_PIN_23: "33 - GP Out 3" - boardConfiguration->malfunctionIndicatorPin = TLE8888_PIN_23; + engineConfiguration->malfunctionIndicatorPin = TLE8888_PIN_23; //set idle_offset 0 engineConfiguration->idleRpmPid.offset = 0; @@ -534,7 +534,7 @@ void setMiataNB2_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->idleRpmPid.dFactor = 5; engineConfiguration->idleRpmPid.periodMs = 10; - engineConfiguration->bc.isFasterEngineSpinUpEnabled = true; + engineConfiguration->isFasterEngineSpinUpEnabled = true; engineConfiguration->etb.pFactor = 12; // a bit lower p-factor seems to work better on TLE9201? MRE? engineConfiguration->etb.iFactor = 0; @@ -556,7 +556,7 @@ void setMiataNB2_MRE(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->tpsMax = 870; engineConfiguration->idleMode = IM_AUTO; - CONFIGB(useETBforIdleControl) = true; + CONFIG(useETBforIdleControl) = true; engineConfiguration->throttlePedalUpVoltage = 1; // WAT? that's an interesting value, how come it's above 5v? engineConfiguration->throttlePedalWOTVoltage = 5.47; diff --git a/firmware/config/engines/me7pnp.cpp b/firmware/config/engines/me7pnp.cpp index 4f9f1721f2..07bd1d93ee 100644 --- a/firmware/config/engines/me7pnp.cpp +++ b/firmware/config/engines/me7pnp.cpp @@ -35,8 +35,8 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; engineConfiguration->crankingInjectionMode = IM_SEQUENTIAL; engineConfiguration->injectionMode = IM_SEQUENTIAL; - boardConfiguration->ignitionPinMode = OM_INVERTED; - boardConfiguration->injectionPinMode = OM_OPENDRAIN_INVERTED; + engineConfiguration->ignitionPinMode = OM_INVERTED; + engineConfiguration->injectionPinMode = OM_OPENDRAIN_INVERTED; engineConfiguration->isCylinderCleanupEnabled = true; engineConfiguration->rpmHardLimit = 8000; engineConfiguration->cranking.baseFuel = 4; @@ -44,7 +44,7 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { //Analog Inputs - boardConfiguration->isFastAdcEnabled = true; + engineConfiguration->isFastAdcEnabled = true; engineConfiguration->map.sensor.type = MT_GM_3_BAR; setCommonNTCSensor(&engineConfiguration->clt, 2700); setCommonNTCSensor(&engineConfiguration->iat, 2700); @@ -65,56 +65,56 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->canNbcType = CAN_BUS_NBC_VAG; engineConfiguration->canReadEnabled = true; engineConfiguration->canWriteEnabled = true; - boardConfiguration->canDeviceMode = CD_USE_CAN1; - boardConfiguration->canTxPin = GPIOB_6; - boardConfiguration->canRxPin = GPIOB_12; + engineConfiguration->canDeviceMode = CD_USE_CAN1; + engineConfiguration->canTxPin = GPIOB_6; + engineConfiguration->canRxPin = GPIOB_12; // Injectors - boardConfiguration->injectionPins[0] = GPIOE_4; // #1 - boardConfiguration->injectionPins[1] = GPIOE_2; // #2 - boardConfiguration->injectionPins[2] = GPIOE_3; // #3 - boardConfiguration->injectionPins[3] = GPIOE_1; // #4 - boardConfiguration->injectionPins[4] = GPIOE_6; // #5 - boardConfiguration->injectionPins[5] = GPIOE_5; // #6 - boardConfiguration->injectionPins[6] = GPIOB_9; // #7 - boardConfiguration->injectionPins[7] = GPIOE_0; // #8 + engineConfiguration->injectionPins[0] = GPIOE_4; // #1 + engineConfiguration->injectionPins[1] = GPIOE_2; // #2 + engineConfiguration->injectionPins[2] = GPIOE_3; // #3 + engineConfiguration->injectionPins[3] = GPIOE_1; // #4 + engineConfiguration->injectionPins[4] = GPIOE_6; // #5 + engineConfiguration->injectionPins[5] = GPIOE_5; // #6 + engineConfiguration->injectionPins[6] = GPIOB_9; // #7 + engineConfiguration->injectionPins[7] = GPIOE_0; // #8 //Ignition Outputs - boardConfiguration->ignitionPins[0] = GPIOD_1; // #1 - boardConfiguration->ignitionPins[1] = GPIOD_6; // #2 - boardConfiguration->ignitionPins[2] = GPIOD_3; // #3 - boardConfiguration->ignitionPins[3] = GPIOD_4; // #4 - boardConfiguration->ignitionPins[4] = GPIOD_0; // #5 - boardConfiguration->ignitionPins[5] = GPIOD_2; // #6 - boardConfiguration->ignitionPins[6] = GPIOA_15; // #7 - boardConfiguration->ignitionPins[7] = GPIOC_12; // #8 + engineConfiguration->ignitionPins[0] = GPIOD_1; // #1 + engineConfiguration->ignitionPins[1] = GPIOD_6; // #2 + engineConfiguration->ignitionPins[2] = GPIOD_3; // #3 + engineConfiguration->ignitionPins[3] = GPIOD_4; // #4 + engineConfiguration->ignitionPins[4] = GPIOD_0; // #5 + engineConfiguration->ignitionPins[5] = GPIOD_2; // #6 + engineConfiguration->ignitionPins[6] = GPIOA_15; // #7 + engineConfiguration->ignitionPins[7] = GPIOC_12; // #8 //SPI Settings - boardConfiguration->is_enabled_spi_1 = true; - boardConfiguration->is_enabled_spi_2 = true; - boardConfiguration->is_enabled_spi_3 = false; + engineConfiguration->is_enabled_spi_1 = true; + engineConfiguration->is_enabled_spi_2 = true; + engineConfiguration->is_enabled_spi_3 = false; engineConfiguration->cj125SpiDevice = SPI_DEVICE_2; - boardConfiguration->cj125CsPin = GPIOB_11; + engineConfiguration->cj125CsPin = GPIOB_11; //Digital Inputs/Outputs #if (BOARD_TLE8888_COUNT > 0) engineConfiguration->tle8888spiDevice = SPI_DEVICE_1; - boardConfiguration->fuelPumpPin = TLE8888_PIN_22; - boardConfiguration->tachOutputPin = TLE8888_PIN_16; - boardConfiguration->alternatorControlPin = TLE8888_PIN_17; + engineConfiguration->fuelPumpPin = TLE8888_PIN_22; + engineConfiguration->tachOutputPin = TLE8888_PIN_16; + engineConfiguration->alternatorControlPin = TLE8888_PIN_17; engineConfiguration->auxPidPins[0] = TLE8888_PIN_6; // VVT solenoid control #endif /* BOARD_TLE8888_COUNT */ - boardConfiguration->mainRelayPin = GPIO_UNASSIGNED; - boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; - boardConfiguration->fanPin = GPIO_UNASSIGNED; - boardConfiguration->clutchDownPin = GPIOD_11; + engineConfiguration->mainRelayPin = GPIO_UNASSIGNED; + engineConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; + engineConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->clutchDownPin = GPIOD_11; engineConfiguration->brakePedalPin = GPIOE_10; engineConfiguration->camInputs[0] = GPIOA_2; #if defined(STM32_HAS_GPIOG) && STM32_HAS_GPIOG - boardConfiguration->triggerInputPins[0] = GPIOG_7; + engineConfiguration->triggerInputPins[0] = GPIOG_7; #endif /* STM32_HAS_GPIOF */ #if defined(STM32_HAS_GPIOF) && STM32_HAS_GPIOF engineConfiguration->vehicleSpeedSensorInputPin = GPIOF_14; @@ -122,7 +122,7 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { //Alternator Settings - boardConfiguration->alternatorControlPinMode = OM_OPENDRAIN; + engineConfiguration->alternatorControlPinMode = OM_OPENDRAIN; engineConfiguration->targetVBatt = 13.8; engineConfiguration->alternatorControl.offset = 40; engineConfiguration->alternatorControl.pFactor = 14; @@ -145,7 +145,7 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { CONFIG(etbIo[0].directionPin1) = GPIOF_15; CONFIG(etbIo[0].directionPin2) = GPIOF_14; #endif /* STM32_HAS_GPIOF */ - boardConfiguration->isHip9011Enabled = false; + engineConfiguration->isHip9011Enabled = false; #if EFI_FSIO setFsio (13, GPIOE_5, "0" PASS_CONFIG_PARAMETER_SUFFIX); @@ -165,7 +165,7 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->activateAuxPid1 = true; engineConfiguration->auxPidFrequency[0] = 300; - boardConfiguration->fsio_setting[0] = 0.0; + engineConfiguration->fsio_setting[0] = 0.0; engineConfiguration->auxPid[0].pFactor = 2; engineConfiguration->auxPid[0].iFactor = 0.005; engineConfiguration->auxPid[0].dFactor = 0; @@ -173,7 +173,7 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->auxPid[0].minValue = 24; engineConfiguration->auxPid[0].maxValue = 44; engineConfiguration->auxPidFrequency[0] = 300; - boardConfiguration->fsio_setting[0] = 0.0; + engineConfiguration->fsio_setting[0] = 0.0; //AC Settings @@ -181,7 +181,7 @@ void vag_18_Turbo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { //Configuration 2 : Over CAN with variable Kompressor(CAN: Input=B_sacc,B_skoc Output: B_kov) //Configuration 3 : 2 Wires - boardConfiguration->acRelayPin = GPIO_UNASSIGNED; + engineConfiguration->acRelayPin = GPIO_UNASSIGNED; engineConfiguration->acCutoffLowRpm = 400; engineConfiguration->acCutoffHighRpm = 4500; engineConfiguration->acIdleRpmBump = 200; diff --git a/firmware/config/engines/mitsubishi.cpp b/firmware/config/engines/mitsubishi.cpp index 207c25d7cc..7590562102 100644 --- a/firmware/config/engines/mitsubishi.cpp +++ b/firmware/config/engines/mitsubishi.cpp @@ -65,19 +65,19 @@ void setMitsubishiConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenstein: low side - out #11: PB8 // Frankenstein: low side - out #12: PB9 - boardConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 - boardConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 - boardConfiguration->injectionPins[2] = GPIOE_3; // Frankenstein: low side - out #8 - boardConfiguration->injectionPins[3] = GPIOE_5; // Frankenstein: low side - out #6 + engineConfiguration->injectionPins[0] = GPIOB_9; // Frankenstein: low side - out #12 + engineConfiguration->injectionPins[1] = GPIOB_8; // Frankenstein: low side - out #11 + engineConfiguration->injectionPins[2] = GPIOE_3; // Frankenstein: low side - out #8 + engineConfiguration->injectionPins[3] = GPIOE_5; // Frankenstein: low side - out #6 // Frankenstein: high side #1: PE8 // Frankenstein: high side #2: PE10 - boardConfiguration->ignitionPins[0] = GPIOE_8; // Frankenstein: high side #1 - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOE_10; // // Frankenstein: high side #2 - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[0] = GPIOE_8; // Frankenstein: high side #1 + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOE_10; // // Frankenstein: high side #2 + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; engineConfiguration->HD44780width = 20; engineConfiguration->HD44780height = 4; diff --git a/firmware/config/engines/nissan_primera.cpp b/firmware/config/engines/nissan_primera.cpp index 5e319d17e9..b9bc7639fb 100644 --- a/firmware/config/engines/nissan_primera.cpp +++ b/firmware/config/engines/nissan_primera.cpp @@ -20,9 +20,9 @@ void setNissanPrimeraEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->trigger.type = TT_NISSAN_SR20VE; - boardConfiguration->ignitionPins[0] = GPIOD_7; - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIOD_6; + engineConfiguration->ignitionPins[0] = GPIOD_7; + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIOD_6; engineConfiguration->auxValves[0] = GPIOE_14; diff --git a/firmware/config/engines/rover_v8.cpp b/firmware/config/engines/rover_v8.cpp index 417fa006a2..eaee8377f5 100644 --- a/firmware/config/engines/rover_v8.cpp +++ b/firmware/config/engines/rover_v8.cpp @@ -16,13 +16,13 @@ #include "engine_math.h" #include "allsensors.h" -void setFrankenstein_01_LCD(board_configuration_s *boardConfiguration) { - boardConfiguration->HD44780_rs = GPIOE_9; - boardConfiguration->HD44780_e = GPIOE_11; - boardConfiguration->HD44780_db4 = GPIOE_13; - boardConfiguration->HD44780_db5 = GPIOE_15; - boardConfiguration->HD44780_db6 = GPIOB_11; - boardConfiguration->HD44780_db7 = GPIOB_13; +void setFrankenstein_01_LCD(engine_configuration_s *engineConfiguration) { + engineConfiguration->HD44780_rs = GPIOE_9; + engineConfiguration->HD44780_e = GPIOE_11; + engineConfiguration->HD44780_db4 = GPIOE_13; + engineConfiguration->HD44780_db5 = GPIOE_15; + engineConfiguration->HD44780_db6 = GPIOB_11; + engineConfiguration->HD44780_db7 = GPIOB_13; } EXTERN_CONFIG; @@ -34,10 +34,10 @@ void setRoverv8(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // set trigger_type 9 engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_36_1; - boardConfiguration->is_enabled_spi_2 = false; - boardConfiguration->isHip9011Enabled = false; - CONFIGB(hip9011IntHoldPin) = GPIO_UNASSIGNED; - setFrankenstein_01_LCD(boardConfiguration); + engineConfiguration->is_enabled_spi_2 = false; + engineConfiguration->isHip9011Enabled = false; + CONFIG(hip9011IntHoldPin) = GPIO_UNASSIGNED; + setFrankenstein_01_LCD(engineConfiguration); engineConfiguration->specs.displacement = 3.528; engineConfiguration->specs.cylindersCount = 8; @@ -58,13 +58,13 @@ void setRoverv8(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // set ignition_mode 2 engineConfiguration->ignitionMode = IM_WASTED_SPARK; - boardConfiguration->ignitionPinMode = OM_INVERTED; + engineConfiguration->ignitionPinMode = OM_INVERTED; // set_ignition_channels - boardConfiguration->ignitionPins[0] = GPIOE_8; // Frankenstein: low side - out #x (?) - boardConfiguration->ignitionPins[7] = GPIOE_10; // Frankenstein: low side - out #x (?) - boardConfiguration->ignitionPins[3] = GPIOE_12; // Frankenstein: low side - out #x (?) - boardConfiguration->ignitionPins[2] = GPIOE_14; // Frankenstein: low side - out #x (?) + engineConfiguration->ignitionPins[0] = GPIOE_8; // Frankenstein: low side - out #x (?) + engineConfiguration->ignitionPins[7] = GPIOE_10; // Frankenstein: low side - out #x (?) + engineConfiguration->ignitionPins[3] = GPIOE_12; // Frankenstein: low side - out #x (?) + engineConfiguration->ignitionPins[2] = GPIOE_14; // Frankenstein: low side - out #x (?) // Frankenstein: low side - out #1: PC14 // Frankenstein: low side - out #2: PC15 @@ -79,27 +79,27 @@ void setRoverv8(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenstein: low side - out #11: PB8 // Frankenstein: low side - out #12: PB9 - boardConfiguration->injectionPins[0] = GPIOC_14; // Frankenstein: low side - out #1 - boardConfiguration->injectionPins[1] = GPIOC_15; // Frankenstein: low side - out #2 - boardConfiguration->injectionPins[2] = GPIOE_6; // Frankenstein: low side - out #3 - boardConfiguration->injectionPins[3] = GPIOC_13; // Frankenstein: low side - out #4 - boardConfiguration->injectionPins[4] = GPIOE_4; // Frankenstein: low side - out #5 - boardConfiguration->injectionPins[5] = GPIOE_5; // Frankenstein: low side - out #6 - boardConfiguration->injectionPins[6] = GPIOE_2; // Frankenstein: low side - out #7 - boardConfiguration->injectionPins[7] = GPIOE_3; // Frankenstein: low side - out #8 + engineConfiguration->injectionPins[0] = GPIOC_14; // Frankenstein: low side - out #1 + engineConfiguration->injectionPins[1] = GPIOC_15; // Frankenstein: low side - out #2 + engineConfiguration->injectionPins[2] = GPIOE_6; // Frankenstein: low side - out #3 + engineConfiguration->injectionPins[3] = GPIOC_13; // Frankenstein: low side - out #4 + engineConfiguration->injectionPins[4] = GPIOE_4; // Frankenstein: low side - out #5 + engineConfiguration->injectionPins[5] = GPIOE_5; // Frankenstein: low side - out #6 + engineConfiguration->injectionPins[6] = GPIOE_2; // Frankenstein: low side - out #7 + engineConfiguration->injectionPins[7] = GPIOE_3; // Frankenstein: low side - out #8 // not valid ICU pin engineConfiguration->vehicleSpeedSensorInputPin = GPIOC_2; //GPIOE_0 AND GPIOE_1 are bad pins since they conflict with accelerometer //no malfunction indicator pin needed, since we use CAN_BUS_MAZDA_RX8 - //boardConfiguration->fuelPumpPin = GPIOE_0; // Frankenstein: low side - out #9 - //boardConfiguration->malfunctionIndicatorPin = GPIOE_1; // Frankenstein: low side - out #10 - boardConfiguration->fuelPumpPin = GPIOB_8; // Frankenstein: low side - out #11 - boardConfiguration->fuelPumpPinMode = OM_DEFAULT; - boardConfiguration->mainRelayPin = GPIOB_9; // Frankenstein: low side - out #12 + //engineConfiguration->fuelPumpPin = GPIOE_0; // Frankenstein: low side - out #9 + //engineConfiguration->malfunctionIndicatorPin = GPIOE_1; // Frankenstein: low side - out #10 + engineConfiguration->fuelPumpPin = GPIOB_8; // Frankenstein: low side - out #11 + engineConfiguration->fuelPumpPinMode = OM_DEFAULT; + engineConfiguration->mainRelayPin = GPIOB_9; // Frankenstein: low side - out #12 - boardConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU - boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP + engineConfiguration->triggerInputPins[0] = GPIOC_6; // 2G YEL/BLU + engineConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP setCommonNTCSensor(&engineConfiguration->clt, 2700); setCommonNTCSensor(&engineConfiguration->iat, 2700); @@ -117,19 +117,19 @@ void setRoverv8(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->tpsMax = convertVoltageTo10bitADC(4.538); // Stepper logic: - boardConfiguration->idle.stepperDirectionPin = GPIOB_10; - boardConfiguration->idle.stepperStepPin = GPIOB_15; + engineConfiguration->idle.stepperDirectionPin = GPIOB_10; + engineConfiguration->idle.stepperStepPin = GPIOB_15; engineConfiguration->stepperEnablePin = GPIOB_14; engineConfiguration->idleStepperReactionTime = 10; engineConfiguration->idleStepperTotalSteps = 150; - boardConfiguration->useStepperIdle = false; + engineConfiguration->useStepperIdle = false; // set injection_pin_mode 0 - boardConfiguration->injectionPinMode = OM_DEFAULT; + engineConfiguration->injectionPinMode = OM_DEFAULT; - boardConfiguration->canTxPin = GPIOB_6; - boardConfiguration->canRxPin = GPIOB_12; + engineConfiguration->canTxPin = GPIOB_6; + engineConfiguration->canRxPin = GPIOB_12; engineConfiguration->canWriteEnabled = true; engineConfiguration->canReadEnabled = false; engineConfiguration->canNbcType = CAN_BUS_MAZDA_RX8; @@ -138,10 +138,10 @@ void setRoverv8(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX); // todo: make this official Frankenstein joystick? - boardConfiguration->joystickCenterPin = GPIOD_8; - boardConfiguration->joystickAPin = GPIOD_10; - boardConfiguration->joystickBPin = GPIO_UNASSIGNED; - boardConfiguration->joystickCPin = GPIO_UNASSIGNED; - boardConfiguration->joystickDPin = GPIOD_11; + engineConfiguration->joystickCenterPin = GPIOD_8; + engineConfiguration->joystickAPin = GPIOD_10; + engineConfiguration->joystickBPin = GPIO_UNASSIGNED; + engineConfiguration->joystickCPin = GPIO_UNASSIGNED; + engineConfiguration->joystickDPin = GPIOD_11; } diff --git a/firmware/config/engines/rover_v8.h b/firmware/config/engines/rover_v8.h index 3d9b773987..838438a7b0 100644 --- a/firmware/config/engines/rover_v8.h +++ b/firmware/config/engines/rover_v8.h @@ -9,7 +9,7 @@ #include "engine_configuration.h" -void setFrankenstein_01_LCD(board_configuration_s *boardConfiguration); +void setFrankenstein_01_LCD(engine_configuration_s *engineConfiguration); void setRoverv8(DECLARE_CONFIG_PARAMETER_SIGNATURE); #endif /* ROVER_V8_H_ */ diff --git a/firmware/config/engines/sachs.cpp b/firmware/config/engines/sachs.cpp index f811931d64..1c9420fd46 100644 --- a/firmware/config/engines/sachs.cpp +++ b/firmware/config/engines/sachs.cpp @@ -36,7 +36,7 @@ void setSachs(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->trigger.customTotalToothCount = 50; engineConfiguration->trigger.customSkippedToothCount = 2; - boardConfiguration->useSerialPort = false; + engineConfiguration->useSerialPort = false; // Frankenstein analog input #1: PA1 adc1 MAP // Frankenstein analog input #2: PA3 adc3 TPS @@ -75,12 +75,12 @@ void setSachs(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // Frankenstein: low side - out #11: PB8 // Frankenstein: low side - out #12: PB9 - boardConfiguration->triggerInputPins[0] = GPIOA_5; - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[0] = GPIOA_5; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[0] = GPIOC_15; + engineConfiguration->injectionPins[0] = GPIOC_15; - boardConfiguration->fuelPumpPin = GPIOE_6; + engineConfiguration->fuelPumpPin = GPIOE_6; // todo: extract a method? figure out something smarter setFuelRpmBin(800, 15000 PASS_CONFIG_PARAMETER_SUFFIX); @@ -90,6 +90,6 @@ void setSachs(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->hasFrequencyReportingMapSensor = true; engineConfiguration->frequencyReportingMapInputPin = GPIOC_6; - boardConfiguration->mapFrequency100Kpa = 159; - boardConfiguration->mapFrequency0Kpa = 80; + engineConfiguration->mapFrequency100Kpa = 159; + engineConfiguration->mapFrequency0Kpa = 80; } diff --git a/firmware/config/engines/subaru.cpp b/firmware/config/engines/subaru.cpp index bfe2086d81..f74a1bebf4 100644 --- a/firmware/config/engines/subaru.cpp +++ b/firmware/config/engines/subaru.cpp @@ -14,7 +14,7 @@ EXTERN_CONFIG; void setSubaru2003Wrx(DECLARE_CONFIG_PARAMETER_SIGNATURE) { - setFrankenso_01_LCD(boardConfiguration); + setFrankenso_01_LCD(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration); engineConfiguration->trigger.type = TT_TOOTHED_WHEEL; @@ -23,16 +23,16 @@ void setSubaru2003Wrx(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->sensorChartFrequency = 2; - boardConfiguration->useStepperIdle = true; + engineConfiguration->useStepperIdle = true; // See http://rusefi.com/forum/viewtopic.php?f=4&t=1161 - boardConfiguration->idle.stepperDirectionPin = GPIOD_1; // top stepper drive pin, white wire recommended - boardConfiguration->idle.stepperStepPin = GPIOD_6; // yellow wire recommended + engineConfiguration->idle.stepperDirectionPin = GPIOD_1; // top stepper drive pin, white wire recommended + engineConfiguration->idle.stepperStepPin = GPIOD_6; // yellow wire recommended engineConfiguration->stepperEnablePin = GPIOB_1; // bottom stepper driver board pin, blue wire recommended - boardConfiguration->triggerSimulatorPins[0] = GPIO_UNASSIGNED; // we want to avoid PD1 conflict - boardConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; - boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPins[0] = GPIO_UNASSIGNED; // we want to avoid PD1 conflict + engineConfiguration->triggerSimulatorPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; } /* diff --git a/firmware/config/engines/suzuki_vitara.cpp b/firmware/config/engines/suzuki_vitara.cpp index 2909e2031f..0f43f6447d 100644 --- a/firmware/config/engines/suzuki_vitara.cpp +++ b/firmware/config/engines/suzuki_vitara.cpp @@ -19,7 +19,7 @@ void setSuzukiVitara(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->ignitionMode = IM_ONE_COIL; engineConfiguration->injectionMode = IM_SIMULTANEOUS; - boardConfiguration->mainRelayPin = GPIOE_6; + engineConfiguration->mainRelayPin = GPIOE_6; } diff --git a/firmware/config/engines/test_engine.cpp b/firmware/config/engines/test_engine.cpp index 0062d9e438..8e7e1f0858 100644 --- a/firmware/config/engines/test_engine.cpp +++ b/firmware/config/engines/test_engine.cpp @@ -38,20 +38,19 @@ void setTestEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->ignitionMode = IM_ONE_COIL; setConstantDwell(3 PASS_CONFIG_PARAMETER_SUFFIX); // 50% duty cycle @ 5000 rpm - board_configuration_s *bc = &engineConfiguration->bc; - bc->malfunctionIndicatorPin = GPIO_UNASSIGNED; + engineConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[0] = GPIOC_7; // #1 - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; // #2 - boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; // #3 - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; // #4 - boardConfiguration->ignitionPins[4] = GPIO_UNASSIGNED; // #5 - boardConfiguration->ignitionPins[5] = GPIO_UNASSIGNED; // #6 + engineConfiguration->ignitionPins[0] = GPIOC_7; // #1 + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; // #2 + engineConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; // #3 + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; // #4 + engineConfiguration->ignitionPins[4] = GPIO_UNASSIGNED; // #5 + engineConfiguration->ignitionPins[5] = GPIO_UNASSIGNED; // #6 - boardConfiguration->logicAnalyzerPins[0] = GPIO_UNASSIGNED; - boardConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED; - boardConfiguration->logicAnalyzerPins[2] = GPIO_UNASSIGNED; - boardConfiguration->logicAnalyzerPins[3] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerPins[0] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerPins[1] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerPins[2] = GPIO_UNASSIGNED; + engineConfiguration->logicAnalyzerPins[3] = GPIO_UNASSIGNED; } void setTestVVTEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { @@ -65,7 +64,7 @@ void setTestVVTEngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // set algorithm 3 setAlgorithm(LM_SPEED_DENSITY PASS_CONFIG_PARAMETER_SUFFIX); - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; engineConfiguration->camInputs[0] = GPIOA_5; // set global_trigger_offset_angle 0 diff --git a/firmware/config/engines/toyota_jzs147.cpp b/firmware/config/engines/toyota_jzs147.cpp index 93c4edcf9d..d2f0e21430 100644 --- a/firmware/config/engines/toyota_jzs147.cpp +++ b/firmware/config/engines/toyota_jzs147.cpp @@ -32,22 +32,22 @@ static void common2jz(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // set ignition_mode 1 engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; - boardConfiguration->ignitionPins[0] = GPIOE_14; - boardConfiguration->ignitionPins[1] = GPIOC_7; - boardConfiguration->ignitionPins[2] = GPIOC_9; - boardConfiguration->ignitionPins[3] = GPIOE_10; - boardConfiguration->ignitionPins[4] = GPIOE_8; - boardConfiguration->ignitionPins[5] = GPIOE_12; + engineConfiguration->ignitionPins[0] = GPIOE_14; + engineConfiguration->ignitionPins[1] = GPIOC_7; + engineConfiguration->ignitionPins[2] = GPIOC_9; + engineConfiguration->ignitionPins[3] = GPIOE_10; + engineConfiguration->ignitionPins[4] = GPIOE_8; + engineConfiguration->ignitionPins[5] = GPIOE_12; - boardConfiguration->injectionPins[0] = GPIOB_9; // #1 - boardConfiguration->injectionPins[1] = GPIOE_2; // #2 - boardConfiguration->injectionPins[2] = GPIOB_8; // #3 - boardConfiguration->injectionPins[3] = GPIOB_7; // #4 - boardConfiguration->injectionPins[4] = GPIOE_3; // #5 - boardConfiguration->injectionPins[5] = GPIOE_4; // #6 + engineConfiguration->injectionPins[0] = GPIOB_9; // #1 + engineConfiguration->injectionPins[1] = GPIOE_2; // #2 + engineConfiguration->injectionPins[2] = GPIOB_8; // #3 + engineConfiguration->injectionPins[3] = GPIOB_7; // #4 + engineConfiguration->injectionPins[4] = GPIOE_3; // #5 + engineConfiguration->injectionPins[5] = GPIOE_4; // #6 - boardConfiguration->fuelPumpPin = GPIO_UNASSIGNED; + engineConfiguration->fuelPumpPin = GPIO_UNASSIGNED; // chartsize 450 engineConfiguration->engineChartSize = 450; @@ -87,10 +87,10 @@ void setToyota_jzs147EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // engineConfiguration->injectionMode = IM_BATCH; // engineConfiguration->twoWireBatchInjection = true; -// boardConfiguration->triggerInputPins[0] = GPIOA_5; -// boardConfiguration->triggerInputPins[1] = GPIOC_6; +// engineConfiguration->triggerInputPins[0] = GPIOA_5; +// engineConfiguration->triggerInputPins[1] = GPIOC_6; - boardConfiguration->isSdCardEnabled = false; + engineConfiguration->isSdCardEnabled = false; } @@ -98,13 +98,13 @@ void setToyota_jzs147EngineConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { void setToyota_2jz_vics(DECLARE_CONFIG_PARAMETER_SIGNATURE) { common2jz(PASS_CONFIG_PARAMETER_SIGNATURE); - boardConfiguration->isSdCardEnabled = true; + engineConfiguration->isSdCardEnabled = true; setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR); engineConfiguration->trigger.type = TT_2JZ_3_34; - boardConfiguration->triggerInputPins[0] = GPIOA_5; // crank sensor - boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; // cam sensor will he handled by custom vtti code + engineConfiguration->triggerInputPins[0] = GPIOA_5; // crank sensor + engineConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; // cam sensor will he handled by custom vtti code engineConfiguration->camInputs[0] = GPIOC_6; engineConfiguration->vvtMode = VVT_2GZ; diff --git a/firmware/config/engines/vw.cpp b/firmware/config/engines/vw.cpp index d15b73bc13..259b20f35f 100644 --- a/firmware/config/engines/vw.cpp +++ b/firmware/config/engines/vw.cpp @@ -48,11 +48,11 @@ void setVwAba(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->ignitionMode = IM_ONE_COIL; - boardConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G - boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPinMode = OM_DEFAULT; + engineConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G + engineConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPins[3] = GPIO_UNASSIGNED; + engineConfiguration->ignitionPinMode = OM_DEFAULT; float mapRange = 110; @@ -60,7 +60,7 @@ void setVwAba(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setFuelTablesLoadBin(20, mapRange PASS_CONFIG_PARAMETER_SUFFIX); setTimingLoadBin(20, mapRange PASS_CONFIG_PARAMETER_SUFFIX); - boardConfiguration->isSdCardEnabled = false; + engineConfiguration->isSdCardEnabled = false; engineConfiguration->tpsMin = 740; engineConfiguration->tpsMax = 135; } diff --git a/firmware/config/engines/zil130.cpp b/firmware/config/engines/zil130.cpp index 2cf22aafd9..dcd19bbad3 100644 --- a/firmware/config/engines/zil130.cpp +++ b/firmware/config/engines/zil130.cpp @@ -31,39 +31,39 @@ void setZil130(DECLARE_CONFIG_PARAMETER_SIGNATURE) { - boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; + engineConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; // engineConfiguration->twoWireBatchInjection = true; - boardConfiguration->injectionPinMode = OM_INVERTED; - boardConfiguration->injectionPins[0] = GPIOB_8; // #1 - boardConfiguration->injectionPins[1] = GPIOE_2; // #2 - boardConfiguration->injectionPins[2] = GPIOE_3; // #3 - boardConfiguration->injectionPins[3] = GPIOE_4; // #4 - boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; // #5 - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; // #6 - boardConfiguration->injectionPins[6] = GPIO_UNASSIGNED; - boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; + engineConfiguration->injectionPinMode = OM_INVERTED; + engineConfiguration->injectionPins[0] = GPIOB_8; // #1 + engineConfiguration->injectionPins[1] = GPIOE_2; // #2 + engineConfiguration->injectionPins[2] = GPIOE_3; // #3 + engineConfiguration->injectionPins[3] = GPIOE_4; // #4 + engineConfiguration->injectionPins[4] = GPIO_UNASSIGNED; // #5 + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; // #6 + engineConfiguration->injectionPins[6] = GPIO_UNASSIGNED; + engineConfiguration->injectionPins[5] = GPIO_UNASSIGNED; - boardConfiguration->ignitionPins[0] = GPIOB_5; // #1 - boardConfiguration->ignitionPins[1] = GPIOB_6; // #2 - boardConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; // #3 - boardConfiguration->ignitionPins[3] = GPIOB_7; // #4 - boardConfiguration->ignitionPins[4] = GPIOC_7; // #5 + engineConfiguration->ignitionPins[0] = GPIOB_5; // #1 + engineConfiguration->ignitionPins[1] = GPIOB_6; // #2 + engineConfiguration->ignitionPins[2] = GPIO_UNASSIGNED; // #3 + engineConfiguration->ignitionPins[3] = GPIOB_7; // #4 + engineConfiguration->ignitionPins[4] = GPIOC_7; // #5 // fuel pump - boardConfiguration->fuelPumpPin = GPIOD_4; + engineConfiguration->fuelPumpPin = GPIOD_4; // idle - boardConfiguration->idle.solenoidPin = GPIOC_14; - boardConfiguration->idle.solenoidPinMode = OM_INVERTED; - boardConfiguration->idle.solenoidFrequency = 300; - boardConfiguration->manIdlePosition = 50; // set_idle_pwm 50 + engineConfiguration->idle.solenoidPin = GPIOC_14; + engineConfiguration->idle.solenoidPinMode = OM_INVERTED; + engineConfiguration->idle.solenoidFrequency = 300; + engineConfiguration->manIdlePosition = 50; // set_idle_pwm 50 // disable sd_card - boardConfiguration->sdCardCsPin = GPIO_UNASSIGNED; - boardConfiguration->is_enabled_spi_2 = false; - boardConfiguration->is_enabled_spi_3 = false; - boardConfiguration->max31855spiDevice = SPI_NONE; + engineConfiguration->sdCardCsPin = GPIO_UNASSIGNED; + engineConfiguration->is_enabled_spi_2 = false; + engineConfiguration->is_enabled_spi_3 = false; + engineConfiguration->max31855spiDevice = SPI_NONE; - boardConfiguration->fanPin = GPIO_UNASSIGNED; + engineConfiguration->fanPin = GPIO_UNASSIGNED; } diff --git a/firmware/console/binary/bluetooth.cpp b/firmware/console/binary/bluetooth.cpp index 1260ef921c..5667721f7e 100644 --- a/firmware/console/binary/bluetooth.cpp +++ b/firmware/console/binary/bluetooth.cpp @@ -49,7 +49,7 @@ static void runCommands() { chThdSleepMilliseconds(1000); // safety // Store current serial port speed - we're going to change it - int savedSerialSpeed = CONFIGB(tunerStudioSerialSpeed); + int savedSerialSpeed = CONFIG(tunerStudioSerialSpeed); int prevBaudIdx = -1, baudIdx = -1, baudListIdx = 0; int cmdIdx = 0; @@ -75,7 +75,7 @@ static void runCommands() { } chThdSleepMilliseconds(10); // safety // change the port speed - CONFIGB(tunerStudioSerialSpeed) = restoreAndExit ? savedSerialSpeed : baudRates[baudIdx]; + CONFIG(tunerStudioSerialSpeed) = restoreAndExit ? savedSerialSpeed : baudRates[baudIdx]; // init UART startTsPort(tsChannel); chThdSleepMilliseconds(10); // safety @@ -160,7 +160,7 @@ void bluetoothStart(ts_channel_s *tsChan, bluetooth_module_e moduleType, const c tsChannel = tsChan; // if a binary protocol uses USB, we cannot init the bluetooth module! - if (!CONFIGB(useSerialPort)) { + if (!CONFIG(useSerialPort)) { scheduleMsg(&btLogger, "Failed! Serial Port connection is disabled!"); return; } diff --git a/firmware/console/binary/tunerstudio.cpp b/firmware/console/binary/tunerstudio.cpp index f52c70493b..0fb655e747 100644 --- a/firmware/console/binary/tunerstudio.cpp +++ b/firmware/console/binary/tunerstudio.cpp @@ -152,7 +152,7 @@ void printTsStats(void) { scheduleMsg(&tsLogger, "TS RX on %s", hwPortname(engineConfiguration->binarySerialRxPin)); scheduleMsg(&tsLogger, "TS TX on %s @%d", hwPortname(engineConfiguration->binarySerialTxPin), - CONFIGB(tunerStudioSerialSpeed)); + CONFIG(tunerStudioSerialSpeed)); } #endif /* EFI_PROD_CODE */ @@ -164,7 +164,7 @@ void printTsStats(void) { // int fuelMapOffset = (int) (&engineConfiguration->fuelTable) - (int) engineConfiguration; // scheduleMsg(logger, "fuelTable %d", fuelMapOffset); // -// int offset = (int) (&CONFIGB(hip9011Gain)) - (int) engineConfiguration; +// int offset = (int) (&CONFIG(hip9011Gain)) - (int) engineConfiguration; // scheduleMsg(&tsLogger, "hip9011Gain %d", offset); // // offset = (int) (&engineConfiguration->crankingCycleBins) - (int) engineConfiguration; @@ -175,7 +175,7 @@ void printTsStats(void) { } static void setTsSpeed(int value) { - CONFIGB(tunerStudioSerialSpeed) = value; + CONFIG(tunerStudioSerialSpeed) = value; printTsStats(); } diff --git a/firmware/console/binary/tunerstudio_io.cpp b/firmware/console/binary/tunerstudio_io.cpp index 9a6111ea5a..170c692529 100644 --- a/firmware/console/binary/tunerstudio_io.cpp +++ b/firmware/console/binary/tunerstudio_io.cpp @@ -99,7 +99,7 @@ void startTsPort(ts_channel_s *tsChannel) { return; #endif /* CONSOLE_USB_DEVICE */ #if defined(TS_UART_DEVICE) || defined(TS_SERIAL_DEVICE) - if (CONFIGB(useSerialPort)) { + if (CONFIG(useSerialPort)) { print("TunerStudio over USART"); /** @@ -115,7 +115,7 @@ void startTsPort(ts_channel_s *tsChannel) { iqObjectInit(&tsUartDma.fifoRxQueue, tsUartDma.buffer, sizeof(tsUartDma.buffer), NULL, NULL); // start DMA driver - tsDmaUartConfig.speed = CONFIGB(tunerStudioSerialSpeed); + tsDmaUartConfig.speed = CONFIG(tunerStudioSerialSpeed); uartStart(TS_UART_DEVICE, &tsDmaUartConfig); // start continuous DMA transfer using our circular buffer @@ -124,11 +124,11 @@ void startTsPort(ts_channel_s *tsChannel) { #elif TS_UART_MODE print("Using UART mode"); // start DMA driver - tsUartConfig.speed = CONFIGB(tunerStudioSerialSpeed); + tsUartConfig.speed = CONFIG(tunerStudioSerialSpeed); uartStart(TS_UART_DEVICE, &tsUartConfig); #elif defined(TS_SERIAL_DEVICE) print("Using Serial mode"); - tsSerialConfig.speed = CONFIGB(tunerStudioSerialSpeed); + tsSerialConfig.speed = CONFIG(tunerStudioSerialSpeed); sdStart(TS_SERIAL_DEVICE, &tsSerialConfig); @@ -148,7 +148,7 @@ bool stopTsPort(ts_channel_s *tsChannel) { //usb_serial_stop(); return false; #endif - if (CONFIGB(useSerialPort)) { + if (CONFIG(useSerialPort)) { // todo: disable Rx/Tx pads? #if (TS_UART_DMA_MODE || TS_UART_MODE) uartStop(TS_UART_DEVICE); diff --git a/firmware/console/status_loop.cpp b/firmware/console/status_loop.cpp index 9f0b9ee948..203cba5c68 100644 --- a/firmware/console/status_loop.cpp +++ b/firmware/console/status_loop.cpp @@ -452,21 +452,21 @@ void printOverallStatus(systime_t nowSeconds) { int seconds = getTimeNowSeconds(); printCurrentState(&logger, seconds, getConfigurationName(engineConfiguration->engineType), FIRMWARE_ID); #if EFI_PROD_CODE - printOutPin(PROTOCOL_CRANK1, CONFIGB(triggerInputPins)[0]); - printOutPin(PROTOCOL_CRANK2, CONFIGB(triggerInputPins)[1]); + printOutPin(PROTOCOL_CRANK1, CONFIG(triggerInputPins)[0]); + printOutPin(PROTOCOL_CRANK2, CONFIG(triggerInputPins)[1]); printOutPin(PROTOCOL_VVT_NAME, engineConfiguration->camInputs[0]); - printOutPin(PROTOCOL_HIP_NAME, CONFIGB(hip9011IntHoldPin)); - printOutPin(PROTOCOL_TACH_NAME, CONFIGB(tachOutputPin)); + printOutPin(PROTOCOL_HIP_NAME, CONFIG(hip9011IntHoldPin)); + printOutPin(PROTOCOL_TACH_NAME, CONFIG(tachOutputPin)); printOutPin(PROTOCOL_DIZZY_NAME, engineConfiguration->dizzySparkOutputPin); #if EFI_LOGIC_ANALYZER - printOutPin(PROTOCOL_WA_CHANNEL_1, CONFIGB(logicAnalyzerPins)[0]); - printOutPin(PROTOCOL_WA_CHANNEL_2, CONFIGB(logicAnalyzerPins)[1]); + printOutPin(PROTOCOL_WA_CHANNEL_1, CONFIG(logicAnalyzerPins)[0]); + printOutPin(PROTOCOL_WA_CHANNEL_2, CONFIG(logicAnalyzerPins)[1]); #endif /* EFI_LOGIC_ANALYZER */ for (int i = 0; i < engineConfiguration->specs.cylindersCount; i++) { - printOutPin(enginePins.coils[i].getShortName(), CONFIGB(ignitionPins)[i]); + printOutPin(enginePins.coils[i].getShortName(), CONFIG(ignitionPins)[i]); - printOutPin(enginePins.injectors[i].getShortName(), CONFIGB(injectionPins)[i]); + printOutPin(enginePins.injectors[i].getShortName(), CONFIG(injectionPins)[i]); } for (int i = 0; i < AUX_DIGITAL_VALVE_COUNT;i++) { printOutPin(enginePins.auxValve[i].getShortName(), engineConfiguration->auxValves[i]); @@ -586,14 +586,14 @@ static OutputPin *leds[] = { &enginePins.warningLedPin, &enginePins.runningLedPi static void initStatusLeds(void) { enginePins.communicationLedPin.initPin("led: comm status", engineConfiguration->communicationLedPin); // we initialize this here so that we can blink it on start-up - enginePins.checkEnginePin.initPin("MalfunctionIndicator", CONFIGB(malfunctionIndicatorPin), &CONFIGB(malfunctionIndicatorPinMode)); + enginePins.checkEnginePin.initPin("MalfunctionIndicator", CONFIG(malfunctionIndicatorPin), &CONFIG(malfunctionIndicatorPinMode)); enginePins.warningLedPin.initPin("led: warning status", engineConfiguration->warningLedPin); enginePins.runningLedPin.initPin("led: running status", engineConfiguration->runningLedPin); - enginePins.debugTriggerSync.initPin("debug: sync", CONFIGB(debugTriggerSync)); - enginePins.debugTimerCallback.initPin("debug: timer callback", CONFIGB(debugTimerCallback)); - enginePins.debugSetTimer.initPin("debug: set timer", CONFIGB(debugSetTimer)); + enginePins.debugTriggerSync.initPin("debug: sync", CONFIG(debugTriggerSync)); + enginePins.debugTimerCallback.initPin("debug: timer callback", CONFIG(debugTimerCallback)); + enginePins.debugSetTimer.initPin("debug: set timer", CONFIG(debugSetTimer)); } #define BLINKING_PERIOD_MS 33 @@ -680,8 +680,8 @@ public: private: void PeriodicTask(efitime_t nowNt) override { UNUSED(nowNt); - setPeriod(NOT_TOO_OFTEN(10 /* ms */, engineConfiguration->bc.lcdThreadPeriodMs)); - if (engineConfiguration->bc.useLcdScreen) { + setPeriod(NOT_TOO_OFTEN(10 /* ms */, engineConfiguration->lcdThreadPeriodMs)); + if (engineConfiguration->useLcdScreen) { #if EFI_HD44780_LCD updateHD44780lcd(); #endif diff --git a/firmware/controllers/actuators/alternator_controller.cpp b/firmware/controllers/actuators/alternator_controller.cpp index 44ac40ff64..0b4fa3ab48 100644 --- a/firmware/controllers/actuators/alternator_controller.cpp +++ b/firmware/controllers/actuators/alternator_controller.cpp @@ -86,7 +86,7 @@ class AlternatorController : public PeriodicTimerController { float vBatt = getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE); float targetVoltage = engineConfiguration->targetVBatt; - if (CONFIGB(onOffAlternatorLogic)) { + if (CONFIG(onOffAlternatorLogic)) { float h = 0.1; bool newState = (vBatt < targetVoltage - h) || (currentPlainOnOffState && vBatt < targetVoltage); enginePins.alternatorPin.setValue(newState); @@ -102,7 +102,7 @@ class AlternatorController : public PeriodicTimerController { currentAltDuty = alternatorPid.getOutput(targetVoltage, vBatt); - if (CONFIGB(isVerboseAlternator)) { + if (CONFIG(isVerboseAlternator)) { scheduleMsg(logger, "alt duty: %.2f/vbatt=%.2f/p=%.2f/i=%.2f/d=%.2f int=%.2f", currentAltDuty, vBatt, alternatorPid.getP(), alternatorPid.getI(), alternatorPid.getD(), alternatorPid.getIntegration()); } @@ -116,7 +116,7 @@ static AlternatorController instance; void showAltInfo(void) { scheduleMsg(logger, "alt=%s @%s t=%dms", boolToString(engineConfiguration->isAlternatorControlEnabled), - hwPortname(CONFIGB(alternatorControlPin)), + hwPortname(CONFIG(alternatorControlPin)), engineConfiguration->alternatorControl.periodMs); scheduleMsg(logger, "p=%.2f/i=%.2f/d=%.2f offset=%.2f", engineConfiguration->alternatorControl.pFactor, 0, 0, engineConfiguration->alternatorControl.offset); // todo: i & d @@ -160,17 +160,17 @@ void onConfigurationChangeAlternatorCallback(engine_configuration_s *previousCon void initAlternatorCtrl(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { logger = sharedLogger; addConsoleAction("altinfo", showAltInfo); - if (CONFIGB(alternatorControlPin) == GPIO_UNASSIGNED) + if (CONFIG(alternatorControlPin) == GPIO_UNASSIGNED) return; - if (CONFIGB(onOffAlternatorLogic)) { - enginePins.alternatorPin.initPin("on/off alternator", CONFIGB(alternatorControlPin)); + if (CONFIG(onOffAlternatorLogic)) { + enginePins.alternatorPin.initPin("on/off alternator", CONFIG(alternatorControlPin)); } else { startSimplePwmExt(&alternatorControl, "Alternator control", &engine->executor, - CONFIGB(alternatorControlPin), + CONFIG(alternatorControlPin), &enginePins.alternatorPin, engineConfiguration->alternatorPwmFrequency, 0.1, (pwm_gen_callback*)applyAlternatorPinState); } diff --git a/firmware/controllers/actuators/electronic_throttle.cpp b/firmware/controllers/actuators/electronic_throttle.cpp index 891e0a3f19..2b888e0f08 100644 --- a/firmware/controllers/actuators/electronic_throttle.cpp +++ b/firmware/controllers/actuators/electronic_throttle.cpp @@ -238,7 +238,7 @@ void EtbController::PeriodicTask() { return; } - if (boardConfiguration->pauseEtbControl) { + if (engineConfiguration->pauseEtbControl) { m_motor->set(0); return; } @@ -270,7 +270,7 @@ void EtbController::PeriodicTask() { int rpm = GET_RPM(); engine->engineState.targetFromTable = pedal2tpsMap.getValue(rpm / RPM_1_BYTE_PACKING_MULT, pedalPosition); - percent_t etbIdleAddition = CONFIGB(useETBforIdleControl) ? engine->engineState.idle.etbIdleAddition : 0; + percent_t etbIdleAddition = CONFIG(useETBforIdleControl) ? engine->engineState.idle.etbIdleAddition : 0; percent_t targetPosition = engine->engineState.targetFromTable + etbIdleAddition; if (engineConfiguration->debugMode == DBG_ETB_LOGIC) { diff --git a/firmware/controllers/actuators/idle_thread.cpp b/firmware/controllers/actuators/idle_thread.cpp index 8ee03533a8..3e4fe53e18 100644 --- a/firmware/controllers/actuators/idle_thread.cpp +++ b/firmware/controllers/actuators/idle_thread.cpp @@ -112,18 +112,18 @@ void idleDebug(const char *msg, percent_t value) { static void showIdleInfo(void) { const char * idleModeStr = getIdle_mode_e(engineConfiguration->idleMode); scheduleMsg(logger, "idleMode=%s position=%.2f isStepper=%s", idleModeStr, - getIdlePosition(), boolToString(CONFIGB(useStepperIdle))); + getIdlePosition(), boolToString(CONFIG(useStepperIdle))); - if (CONFIGB(useStepperIdle)) { - scheduleMsg(logger, "directionPin=%s reactionTime=%.2f", hwPortname(CONFIGB(idle).stepperDirectionPin), + if (CONFIG(useStepperIdle)) { + scheduleMsg(logger, "directionPin=%s reactionTime=%.2f", hwPortname(CONFIG(idle).stepperDirectionPin), engineConfiguration->idleStepperReactionTime); - scheduleMsg(logger, "stepPin=%s steps=%d", hwPortname(CONFIGB(idle).stepperStepPin), + scheduleMsg(logger, "stepPin=%s steps=%d", hwPortname(CONFIG(idle).stepperStepPin), engineConfiguration->idleStepperTotalSteps); scheduleMsg(logger, "enablePin=%s/%d", hwPortname(engineConfiguration->stepperEnablePin), engineConfiguration->stepperEnablePinMode); } else { - scheduleMsg(logger, "idle valve freq=%d on %s", CONFIGB(idle).solenoidFrequency, - hwPortname(CONFIGB(idle).solenoidPin)); + scheduleMsg(logger, "idle valve freq=%d on %s", CONFIG(idle).solenoidFrequency, + hwPortname(CONFIG(idle).solenoidPin)); } @@ -138,10 +138,10 @@ void setIdleMode(idle_mode_e value) { } static void applyIACposition(percent_t position) { - if (CONFIGB(useETBforIdleControl)) { + if (CONFIG(useETBforIdleControl)) { engine->engineState.idle.etbIdleAddition = position / 100 * CONFIG(etbIdleThrottleRange); #if ! EFI_UNIT_TEST - } if (CONFIGB(useStepperIdle)) { + } if (CONFIG(useStepperIdle)) { iacMotor.setTargetPosition(position / 100 * engineConfiguration->idleStepperTotalSteps); #endif /* EFI_UNIT_TEST */ } else { @@ -165,14 +165,14 @@ void setIdleValvePosition(int positionPercent) { showIdleInfo(); #endif /* EFI_UNIT_TEST */ // todo: this is not great that we have to write into configuration here - CONFIGB(manIdlePosition) = positionPercent; + CONFIG(manIdlePosition) = positionPercent; } #endif /* EFI_UNIT_TEST */ static percent_t manualIdleController(float cltCorrection DECLARE_ENGINE_PARAMETER_SUFFIX) { - percent_t correctedPosition = cltCorrection * CONFIGB(manIdlePosition); + percent_t correctedPosition = cltCorrection * CONFIG(manIdlePosition); // let's put the value into the right range correctedPosition = maxF(correctedPosition, 0.01); @@ -223,7 +223,7 @@ static bool isOutOfAutomaticIdleCondition(DECLARE_ENGINE_PARAMETER_SIGNATURE) { inputPosition = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE); } - return inputPosition > CONFIGB(idlePidDeactivationTpsThreshold); + return inputPosition > CONFIG(idlePidDeactivationTpsThreshold); } /** @@ -287,7 +287,7 @@ static percent_t automaticIdleController(DECLARE_ENGINE_PARAMETER_SIGNATURE) { // Apply PID Deactivation Threshold as a smooth taper for TPS transients. percent_t tpsPos = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE); // if tps==0 then PID just works as usual, or we completely disable it if tps>=threshold - newValue = interpolateClamped(0.0f, newValue, CONFIGB(idlePidDeactivationTpsThreshold), engine->engineState.idle.baseIdlePosition, tpsPos); + newValue = interpolateClamped(0.0f, newValue, CONFIG(idlePidDeactivationTpsThreshold), engine->engineState.idle.baseIdlePosition, tpsPos); // Interpolate to the manual position when RPM is close to the upper RPM limit (if idlePidRpmUpperLimit is set). // If RPM increases and the throttle is closed, then we're in coasting mode, and we should smoothly disable auto-pid. @@ -297,7 +297,7 @@ static percent_t automaticIdleController(DECLARE_ENGINE_PARAMETER_SIGNATURE) { int idlePidLowerRpm = targetRpm + CONFIG(idlePidRpmDeadZone); if (CONFIG(idlePidRpmUpperLimit) > 0) { engine->engineState.idle.idleState = PID_UPPER; - if (CONFIGB(useIacTableForCoasting) && hasCltSensor()) { + if (CONFIG(useIacTableForCoasting) && hasCltSensor()) { percent_t iacPosForCoasting = interpolate2d("iacCoasting", getCoolantTemperature(), CONFIG(iacCoastingBins), CONFIG(iacCoasting)); newValue = interpolateClamped(idlePidLowerRpm, newValue, idlePidLowerRpm + CONFIG(idlePidRpmUpperLimit), iacPosForCoasting, rpm); } else { @@ -341,8 +341,8 @@ static percent_t automaticIdleController(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #if EFI_GPIO_HARDWARE // this value is not used yet - if (CONFIGB(clutchDownPin) != GPIO_UNASSIGNED) { - engine->clutchDownState = efiReadPin(CONFIGB(clutchDownPin)); + if (CONFIG(clutchDownPin) != GPIO_UNASSIGNED) { + engine->clutchDownState = efiReadPin(CONFIG(clutchDownPin)); } if (hasAcToggle(PASS_ENGINE_PARAMETER_SIGNATURE)) { bool result = getAcToggle(PASS_ENGINE_PARAMETER_SIGNATURE); @@ -412,7 +412,7 @@ static percent_t automaticIdleController(DECLARE_ENGINE_PARAMETER_SIGNATURE) { percent_t tpsPos = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE); float additionalAir = (float)engineConfiguration->iacByTpsTaper; - iacPosition += interpolateClamped(0.0f, 0.0f, CONFIGB(idlePidDeactivationTpsThreshold), additionalAir, tpsPos); + iacPosition += interpolateClamped(0.0f, 0.0f, CONFIG(idlePidDeactivationTpsThreshold), additionalAir, tpsPos); // taper transition from cranking to running (uint32_t to float conversion is safe here) if (engineConfiguration->afterCrankingIACtaperDuration > 0) @@ -472,7 +472,7 @@ void setDefaultIdleParameters(DECLARE_CONFIG_PARAMETER_SIGNATURE) { void onConfigurationChangeIdleCallback(engine_configuration_s *previousConfiguration) { shouldResetPid = !idlePid.isSame(&previousConfiguration->idleRpmPid); - idleSolenoid.setFrequency(CONFIGB(idle).solenoidFrequency); + idleSolenoid.setFrequency(CONFIG(idle).solenoidFrequency); } void setTargetIdleRpm(int value) { @@ -534,31 +534,31 @@ static void applyIdleSolenoidPinState(int stateIndex, PwmConfig *state) /* pwm_g bool isIdleHardwareRestartNeeded() { return isConfigurationChanged(stepperEnablePin) || isConfigurationChanged(stepperEnablePinMode) || - isConfigurationChanged(bc.idle.stepperStepPin) || - isConfigurationChanged(bc.idle.solenoidFrequency) || - isConfigurationChanged(bc.useStepperIdle) || + isConfigurationChanged(idle.stepperStepPin) || + isConfigurationChanged(idle.solenoidFrequency) || + isConfigurationChanged(useStepperIdle) || // isConfigurationChanged() || - isConfigurationChanged(bc.useETBforIdleControl) || - isConfigurationChanged(bc.idle.solenoidPin); + isConfigurationChanged(useETBforIdleControl) || + isConfigurationChanged(idle.solenoidPin); } void stopIdleHardware(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #if EFI_PROD_CODE brain_pin_markUnused(activeConfiguration.stepperEnablePin); - brain_pin_markUnused(activeConfiguration.bc.idle.stepperStepPin); - brain_pin_markUnused(activeConfiguration.bc.idle.solenoidPin); -// brain_pin_markUnused(activeConfiguration.bc.idle.); -// brain_pin_markUnused(activeConfiguration.bc.idle.); -// brain_pin_markUnused(activeConfiguration.bc.idle.); -// brain_pin_markUnused(activeConfiguration.bc.idle.); + brain_pin_markUnused(activeConfiguration.idle.stepperStepPin); + brain_pin_markUnused(activeConfiguration.idle.solenoidPin); +// brain_pin_markUnused(activeConfiguration.idle.); +// brain_pin_markUnused(activeConfiguration.idle.); +// brain_pin_markUnused(activeConfiguration.idle.); +// brain_pin_markUnused(activeConfiguration.idle.); #endif /* EFI_PROD_CODE */ } void initIdleHardware(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - if (CONFIGB(useStepperIdle)) { - iacMotor.initialize(CONFIGB(idle).stepperStepPin, - CONFIGB(idle).stepperDirectionPin, + if (CONFIG(useStepperIdle)) { + iacMotor.initialize(CONFIG(idle).stepperStepPin, + CONFIG(idle).stepperDirectionPin, engineConfiguration->stepperDirectionPinMode, engineConfiguration->idleStepperReactionTime, engineConfiguration->idleStepperTotalSteps, @@ -566,14 +566,14 @@ void initIdleHardware(DECLARE_ENGINE_PARAMETER_SIGNATURE) { logger); // This greatly improves PID accuracy for steppers with a small number of steps idlePositionSensitivityThreshold = 1.0f / engineConfiguration->idleStepperTotalSteps; - } else if (!engineConfiguration->bc.useETBforIdleControl) { + } else if (!engineConfiguration->useETBforIdleControl) { /** * Start PWM for idleValvePin */ startSimplePwmExt(&idleSolenoid, "Idle Valve", &engine->executor, - CONFIGB(idle).solenoidPin, &enginePins.idleSolenoidPin, - CONFIGB(idle).solenoidFrequency, CONFIGB(manIdlePosition) / 100, + CONFIG(idle).solenoidPin, &enginePins.idleSolenoidPin, + CONFIG(idle).solenoidFrequency, CONFIG(manIdlePosition) / 100, (pwm_gen_callback*)applyIdleSolenoidPinState); idlePositionSensitivityThreshold = 0.0f; } @@ -642,9 +642,9 @@ void startIdleThread(Logging*sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { #if ! EFI_UNIT_TEST // this is neutral/no gear switch input. on Miata it's wired both to clutch pedal and neutral in gearbox // this switch is not used yet - if (CONFIGB(clutchDownPin) != GPIO_UNASSIGNED) { - efiSetPadMode("clutch down switch", CONFIGB(clutchDownPin), - getInputMode(CONFIGB(clutchDownPinMode))); + if (CONFIG(clutchDownPin) != GPIO_UNASSIGNED) { + efiSetPadMode("clutch down switch", CONFIG(clutchDownPin), + getInputMode(CONFIG(clutchDownPinMode))); } if (CONFIG(clutchUpPin) != GPIO_UNASSIGNED) { @@ -654,7 +654,7 @@ void startIdleThread(Logging*sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { if (CONFIG(throttlePedalUpPin) != GPIO_UNASSIGNED) { efiSetPadMode("throttle pedal up switch", CONFIG(throttlePedalUpPin), - getInputMode(CONFIGB(throttlePedalUpPinMode))); + getInputMode(CONFIG(throttlePedalUpPinMode))); } if (engineConfiguration->brakePedalPin != GPIO_UNASSIGNED) { diff --git a/firmware/controllers/actuators/pwm_tester.cpp b/firmware/controllers/actuators/pwm_tester.cpp index c257bf7f74..f6d1277c62 100644 --- a/firmware/controllers/actuators/pwm_tester.cpp +++ b/firmware/controllers/actuators/pwm_tester.cpp @@ -35,7 +35,7 @@ static void startPwmTest(int freq) { /** * See custom_engine.cpp for pinout */ - // currently this is PB9 by default - see CONFIGB(injectionPins) + // currently this is PB9 by default - see CONFIG(injectionPins) startSimplePwm(&pwmTest[1], "tester", &enginePins.injectors[0], freq / 1.3333333333, 0.5f, applyPinState); // currently this is PE2 by default startSimplePwm(&pwmTest[2], "tester", &enginePins.injectors[1], freq / 1000, 0.5f, applyPinState); diff --git a/firmware/controllers/algo/advance_map.cpp b/firmware/controllers/algo/advance_map.cpp index 8da18d85c9..46bfb5674e 100644 --- a/firmware/controllers/algo/advance_map.cpp +++ b/firmware/controllers/algo/advance_map.cpp @@ -68,7 +68,7 @@ static const ignition_table_t defaultIatTiming = { #endif /* IGN_LOAD_COUNT == DEFAULT_IGN_LOAD_COUNT */ bool isStep1Condition(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) { - return CONFIGB(enabledStep1Limiter) && rpm >= engineConfiguration->step1rpm; + return CONFIG(enabledStep1Limiter) && rpm >= engineConfiguration->step1rpm; } /** @@ -104,7 +104,7 @@ static angle_t getRunningAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAME float idleAdvance = interpolate2d("idleAdvance", rpm, config->idleAdvanceBins, config->idleAdvance); // interpolate between idle table and normal (running) table using TPS threshold float tps = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE); - advanceAngle = interpolateClamped(0.0f, idleAdvance, CONFIGB(idlePidDeactivationTpsThreshold), advanceAngle, tps); + advanceAngle = interpolateClamped(0.0f, idleAdvance, CONFIG(idlePidDeactivationTpsThreshold), advanceAngle, tps); } engine->m.advanceLookupTime = getTimeNowLowerNt() - engine->m.beforeAdvance; @@ -120,11 +120,11 @@ angle_t getAdvanceCorrections(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) { } // PID Ignition Advance angle correction float pidTimingCorrection = 0.0f; - if (CONFIGB(useIdleTimingPidControl)) { + if (CONFIG(useIdleTimingPidControl)) { int targetRpm = getTargetRpmForIdleCorrection(PASS_ENGINE_PARAMETER_SIGNATURE); int rpmDelta = absI(rpm - targetRpm); float tps = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE); - if (tps >= CONFIGB(idlePidDeactivationTpsThreshold)) { + if (tps >= CONFIG(idlePidDeactivationTpsThreshold)) { // we are not in the idle mode anymore, so the 'reset' flag will help us when we return to the idle. shouldResetTimingPid = true; } @@ -139,7 +139,7 @@ angle_t getAdvanceCorrections(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) { percent_t timingRawCorr = idleTimingPid.getOutput(targetRpm, rpm, /* is this the right dTime? this period is not exactly the period at which this code is invoked*/engineConfiguration->idleTimingPid.periodMs); // tps idle-running falloff - pidTimingCorrection = interpolateClamped(0.0f, timingRawCorr, CONFIGB(idlePidDeactivationTpsThreshold), 0.0f, tps); + pidTimingCorrection = interpolateClamped(0.0f, timingRawCorr, CONFIG(idlePidDeactivationTpsThreshold), 0.0f, tps); // rpm falloff pidTimingCorrection = interpolateClamped(0.0f, pidTimingCorrection, CONFIG(idlePidFalloffDeltaRpm), 0.0f, rpmDelta - CONFIG(idleTimingPidWorkZone)); } else { diff --git a/firmware/controllers/algo/engine.cpp b/firmware/controllers/algo/engine.cpp index 98c1ab7b2c..d7f75c4501 100644 --- a/firmware/controllers/algo/engine.cpp +++ b/firmware/controllers/algo/engine.cpp @@ -155,15 +155,15 @@ void Engine::updateSlowSensors(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #if EFI_ENGINE_CONTROL int rpm = GET_RPM(); isEngineChartEnabled = CONFIG(isEngineChartEnabled) && rpm < CONFIG(engineSnifferRpmThreshold); - sensorChartMode = rpm < CONFIG(sensorSnifferRpmThreshold) ? CONFIGB(sensorChartMode) : SC_OFF; + sensorChartMode = rpm < CONFIG(sensorSnifferRpmThreshold) ? CONFIG(sensorChartMode) : SC_OFF; engineState.updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE); // todo: move this logic somewhere to sensors folder? if (CONFIG(fuelLevelSensor) != EFI_ADC_NONE) { float fuelLevelVoltage = getVoltageDivided("fuel", engineConfiguration->fuelLevelSensor PASS_ENGINE_PARAMETER_SUFFIX); - sensors.fuelTankLevel = interpolateMsg("fgauge", CONFIGB(fuelLevelEmptyTankVoltage), 0, - CONFIGB(fuelLevelFullTankVoltage), 100, + sensors.fuelTankLevel = interpolateMsg("fgauge", CONFIG(fuelLevelEmptyTankVoltage), 0, + CONFIG(fuelLevelFullTankVoltage), 100, fuelLevelVoltage); } sensors.vBatt = hasVBatt(PASS_ENGINE_PARAMETER_SIGNATURE) ? getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE) : 12; diff --git a/firmware/controllers/algo/engine2.cpp b/firmware/controllers/algo/engine2.cpp index 8ef3bcd6bf..e586c91cb8 100644 --- a/firmware/controllers/algo/engine2.cpp +++ b/firmware/controllers/algo/engine2.cpp @@ -205,7 +205,7 @@ void EngineState::periodicFastCallback(DECLARE_ENGINE_PARAMETER_SIGNATURE) { /** * *0.01 because of https://sourceforge.net/p/rusefi/tickets/153/ */ - if (CONFIGB(useTPSBasedVeTable)) { + if (CONFIG(useTPSBasedVeTable)) { // todo: should we have 'veTpsMap' fuel_Map3D_t variable here? currentRawVE = interpolate3d(tps, CONFIG(ignitionTpsBins), IGN_TPS_COUNT, rpm, config->veRpmBins, FUEL_RPM_COUNT, veMap.pointers); } else { @@ -215,7 +215,7 @@ void EngineState::periodicFastCallback(DECLARE_ENGINE_PARAMETER_SIGNATURE) { if (CONFIG(useSeparateVeForIdle)) { float idleVe = interpolate2d("idleVe", rpm, config->idleVeBins, config->idleVe); // interpolate between idle table and normal (running) table using TPS threshold - currentRawVE = interpolateClamped(0.0f, idleVe, CONFIGB(idlePidDeactivationTpsThreshold), currentRawVE, tps); + currentRawVE = interpolateClamped(0.0f, idleVe, CONFIG(idlePidDeactivationTpsThreshold), currentRawVE, tps); } currentBaroCorrectedVE = baroCorrection * currentRawVE * PERCENT_DIV; targetAFR = afrMap.getValue(rpm, map); diff --git a/firmware/controllers/algo/engine_configuration.cpp b/firmware/controllers/algo/engine_configuration.cpp index 1599dc9e41..817d27fc4e 100644 --- a/firmware/controllers/algo/engine_configuration.cpp +++ b/firmware/controllers/algo/engine_configuration.cpp @@ -286,7 +286,7 @@ static void initTemperatureCurve(float *bins, float *values, int size, float def void prepareVoidConfiguration(engine_configuration_s *engineConfiguration) { efiAssertVoid(OBD_PCM_Processor_Fault, engineConfiguration != NULL, "ec NULL"); memset(engineConfiguration, 0, sizeof(engine_configuration_s)); - board_configuration_s *boardConfiguration = &engineConfiguration->bc; + // Now that GPIO_UNASSIGNED == 0 we do not really need explicit zero assignments since memset above does that // todo: migrate 'EFI_ADC_NONE' to '0' and eliminate the need in this method altogether @@ -312,7 +312,7 @@ void prepareVoidConfiguration(engine_configuration_s *engineConfiguration) { engineConfiguration->tps1_1AdcChannel = EFI_ADC_NONE; */ engineConfiguration->tps2_1AdcChannel = EFI_ADC_NONE; - engineConfiguration->bc.auxFastSensor1_adcChannel = EFI_ADC_NONE; + engineConfiguration->auxFastSensor1_adcChannel = EFI_ADC_NONE; engineConfiguration->acSwitchAdc = EFI_ADC_NONE; engineConfiguration->externalKnockSenseAdc = EFI_ADC_NONE; engineConfiguration->fuelLevelSensor = EFI_ADC_NONE; @@ -321,7 +321,7 @@ void prepareVoidConfiguration(engine_configuration_s *engineConfiguration) { engineConfiguration->high_fuel_pressure_sensor_1 = EFI_ADC_NONE; engineConfiguration->high_fuel_pressure_sensor_2 = EFI_ADC_NONE; - boardConfiguration->clutchDownPinMode = PI_PULLUP; + engineConfiguration->clutchDownPinMode = PI_PULLUP; engineConfiguration->clutchUpPinMode = PI_PULLUP; engineConfiguration->brakePedalPinMode = PI_PULLUP; } @@ -353,12 +353,12 @@ void setDefaultBasePins(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // set UART pads configuration based on the board // needed also by bootloader code - boardConfiguration->useSerialPort = true; + engineConfiguration->useSerialPort = true; engineConfiguration->binarySerialTxPin = GPIOC_10; engineConfiguration->binarySerialRxPin = GPIOC_11; engineConfiguration->consoleSerialTxPin = GPIOC_10; engineConfiguration->consoleSerialRxPin = GPIOC_11; - boardConfiguration->tunerStudioSerialSpeed = TS_DEFAULT_SPEED; + engineConfiguration->tunerStudioSerialSpeed = TS_DEFAULT_SPEED; engineConfiguration->uartConsoleSerialSpeed = 115200; #if EFI_PROD_CODE @@ -370,10 +370,10 @@ void setDefaultBasePins(DECLARE_CONFIG_PARAMETER_SIGNATURE) { // needed also by bootloader code // at the moment bootloader does NOT really need SD card, this is a step towards future bootloader SD card usage void setDefaultSdCardParameters(DECLARE_CONFIG_PARAMETER_SIGNATURE) { - boardConfiguration->is_enabled_spi_3 = true; + engineConfiguration->is_enabled_spi_3 = true; engineConfiguration->sdCardSpiDevice = SPI_DEVICE_3; - boardConfiguration->sdCardCsPin = GPIOD_4; - boardConfiguration->isSdCardEnabled = true; + engineConfiguration->sdCardCsPin = GPIOD_4; + engineConfiguration->isSdCardEnabled = true; #if EFI_PROD_CODE // call overrided board-specific SD card configuration setup, if needed (for custom boards only) @@ -477,7 +477,7 @@ static void setDefaultWarmupFuelEnrichment(DECLARE_ENGINE_PARAMETER_SIGNATURE) { } static void setDefaultFuelCutParameters(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - boardConfiguration->coastingFuelCutEnabled = false; + engineConfiguration->coastingFuelCutEnabled = false; engineConfiguration->coastingFuelCutRpmLow = 1300; engineConfiguration->coastingFuelCutRpmHigh = 1500; engineConfiguration->coastingFuelCutTps = 2; @@ -578,17 +578,17 @@ static void setDefaultIdleSpeedTarget(DECLARE_ENGINE_PARAMETER_SIGNATURE) { } static void setDefaultStepperIdleParameters(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - boardConfiguration->idle.stepperDirectionPin = GPIOE_10; - boardConfiguration->idle.stepperStepPin = GPIOE_12; + engineConfiguration->idle.stepperDirectionPin = GPIOE_10; + engineConfiguration->idle.stepperStepPin = GPIOE_12; engineConfiguration->stepperEnablePin = GPIOE_14; engineConfiguration->idleStepperReactionTime = 10; engineConfiguration->idleStepperTotalSteps = 150; } static void setCanFrankensoDefaults(DECLARE_CONFIG_PARAMETER_SIGNATURE) { - boardConfiguration->canDeviceMode = CD_USE_CAN2; - boardConfiguration->canTxPin = GPIOB_6; - boardConfiguration->canRxPin = GPIOB_12; + engineConfiguration->canDeviceMode = CD_USE_CAN2; + engineConfiguration->canTxPin = GPIOB_6; + engineConfiguration->canRxPin = GPIOB_12; } /** @@ -657,14 +657,14 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->canWriteEnabled = true; engineConfiguration->canNbcType = CAN_BUS_MAZDA_RX8; - boardConfiguration->sdCardPeriodMs = 50; + engineConfiguration->sdCardPeriodMs = 50; for (int i = 0; i < FSIO_COMMAND_COUNT; i++) { config->fsioFormulas[i][0] = 0; } - CONFIGB(mapMinBufferLength) = 1; + CONFIG(mapMinBufferLength) = 1; engineConfiguration->idlePidRpmDeadZone = 50; engineConfiguration->startOfCrankingPrimingPulse = 0; @@ -806,7 +806,7 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->fuelClosedLoopCltThreshold = 70; engineConfiguration->fuelClosedLoopRpmThreshold = 900; engineConfiguration->fuelClosedLoopTpsThreshold = 80; - boardConfiguration->fuelClosedLoopAfrLowThreshold = 10.3; + engineConfiguration->fuelClosedLoopAfrLowThreshold = 10.3; engineConfiguration->fuelClosedLoopAfrHighThreshold = 19.8; engineConfiguration->fuelClosedLoopPid.pFactor = -0.1; @@ -821,16 +821,16 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->idleRpmPid.minValue = 0.1; engineConfiguration->idleRpmPid.maxValue = 99; - boardConfiguration->idlePidDeactivationTpsThreshold = 2; + engineConfiguration->idlePidDeactivationTpsThreshold = 2; - boardConfiguration->idle.solenoidFrequency = 200; + engineConfiguration->idle.solenoidFrequency = 200; // set idle_position 50 - boardConfiguration->manIdlePosition = 50; + engineConfiguration->manIdlePosition = 50; engineConfiguration->crankingIACposition = 50; // engineConfiguration->idleMode = IM_AUTO; engineConfiguration->idleMode = IM_MANUAL; - boardConfiguration->useStepperIdle = false; + engineConfiguration->useStepperIdle = false; setDefaultStepperIdleParameters(PASS_ENGINE_PARAMETER_SIGNATURE); @@ -850,7 +850,7 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #endif // performance optimization - boardConfiguration->sensorChartMode = SC_OFF; + engineConfiguration->sensorChartMode = SC_OFF; engineConfiguration->storageMode = MS_AUTO; @@ -945,13 +945,13 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->knockDetectionWindowStart = 35; engineConfiguration->knockDetectionWindowEnd = 135; - boardConfiguration->fuelLevelEmptyTankVoltage = 0; - boardConfiguration->fuelLevelFullTankVoltage = 5; + engineConfiguration->fuelLevelEmptyTankVoltage = 0; + engineConfiguration->fuelLevelFullTankVoltage = 5; /** * this is RPM. 10000 rpm is only 166Hz, 800 rpm is 13Hz */ - boardConfiguration->triggerSimulatorFrequency = 1200; + engineConfiguration->triggerSimulatorFrequency = 1200; engineConfiguration->alternatorPwmFrequency = 300; @@ -964,24 +964,24 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->vehicleSpeedCoef = 1.0f; - boardConfiguration->logicAnalyzerMode[0] = false; - boardConfiguration->logicAnalyzerMode[1] = false; + engineConfiguration->logicAnalyzerMode[0] = false; + engineConfiguration->logicAnalyzerMode[1] = false; engineConfiguration->mapErrorDetectionTooLow = 5; engineConfiguration->mapErrorDetectionTooHigh = 250; - boardConfiguration->idleThreadPeriodMs = 100; - boardConfiguration->consoleLoopPeriodMs = 200; - boardConfiguration->lcdThreadPeriodMs = 300; - boardConfiguration->generalPeriodicThreadPeriodMs = 50; - boardConfiguration->useLcdScreen = true; + engineConfiguration->idleThreadPeriodMs = 100; + engineConfiguration->consoleLoopPeriodMs = 200; + engineConfiguration->lcdThreadPeriodMs = 300; + engineConfiguration->generalPeriodicThreadPeriodMs = 50; + engineConfiguration->useLcdScreen = true; engineConfiguration->hip9011Gain = 1; - boardConfiguration->isFastAdcEnabled = true; - boardConfiguration->isEngineControlEnabled = true; + engineConfiguration->isFastAdcEnabled = true; + engineConfiguration->isEngineControlEnabled = true; - boardConfiguration->isVerboseAlternator = false; + engineConfiguration->isVerboseAlternator = false; engineConfiguration->engineLoadAccelLength = 6; engineConfiguration->engineLoadAccelEnrichmentThreshold = 5; // kPa @@ -1000,7 +1000,7 @@ static void setDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { * * fsioinfo */ - boardConfiguration->fsio_setting[0] = 5000; + engineConfiguration->fsio_setting[0] = 5000; // simple warning light as default configuration // set_fsio_expression 1 "rpm > fsio_setting(1)" setFsio(0, GPIO_UNASSIGNED, RPM_ABOVE_USER_SETTING_1 PASS_CONFIG_PARAMETER_SUFFIX); @@ -1023,36 +1023,36 @@ void setDefaultFrankensoConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { engineConfiguration->hip9011SpiDevice = SPI_DEVICE_2; engineConfiguration->cj125SpiDevice = SPI_DEVICE_2; -// boardConfiguration->gps_rx_pin = GPIOB_7; -// boardConfiguration->gps_tx_pin = GPIOB_6; +// engineConfiguration->gps_rx_pin = GPIOB_7; +// engineConfiguration->gps_tx_pin = GPIOB_6; - boardConfiguration->triggerSimulatorPins[0] = GPIOD_1; - boardConfiguration->triggerSimulatorPins[1] = GPIOD_2; + engineConfiguration->triggerSimulatorPins[0] = GPIOD_1; + engineConfiguration->triggerSimulatorPins[1] = GPIOD_2; - boardConfiguration->triggerInputPins[0] = GPIOC_6; - boardConfiguration->triggerInputPins[1] = GPIOA_5; + engineConfiguration->triggerInputPins[0] = GPIOC_6; + engineConfiguration->triggerInputPins[1] = GPIOA_5; - //boardConfiguration->logicAnalyzerPins[1] = GPIOE_5; // GPIOE_5 is a popular option (if available) + //engineConfiguration->logicAnalyzerPins[1] = GPIOE_5; // GPIOE_5 is a popular option (if available) // set this to SPI_DEVICE_3 to enable stimulation - //boardConfiguration->digitalPotentiometerSpiDevice = SPI_DEVICE_3; - boardConfiguration->digitalPotentiometerChipSelect[0] = GPIOD_7; - boardConfiguration->digitalPotentiometerChipSelect[1] = GPIO_UNASSIGNED; - boardConfiguration->digitalPotentiometerChipSelect[2] = GPIOD_5; - boardConfiguration->digitalPotentiometerChipSelect[3] = GPIO_UNASSIGNED; + //engineConfiguration->digitalPotentiometerSpiDevice = SPI_DEVICE_3; + engineConfiguration->digitalPotentiometerChipSelect[0] = GPIOD_7; + engineConfiguration->digitalPotentiometerChipSelect[1] = GPIO_UNASSIGNED; + engineConfiguration->digitalPotentiometerChipSelect[2] = GPIOD_5; + engineConfiguration->digitalPotentiometerChipSelect[3] = GPIO_UNASSIGNED; - boardConfiguration->spi1mosiPin = GPIOB_5; - boardConfiguration->spi1misoPin = GPIOB_4; - boardConfiguration->spi1sckPin = GPIOB_3; // please note that this pin is also SWO/SWD - Single Wire debug Output + engineConfiguration->spi1mosiPin = GPIOB_5; + engineConfiguration->spi1misoPin = GPIOB_4; + engineConfiguration->spi1sckPin = GPIOB_3; // please note that this pin is also SWO/SWD - Single Wire debug Output - boardConfiguration->spi2mosiPin = GPIOB_15; - boardConfiguration->spi2misoPin = GPIOB_14; - boardConfiguration->spi2sckPin = GPIOB_13; + engineConfiguration->spi2mosiPin = GPIOB_15; + engineConfiguration->spi2misoPin = GPIOB_14; + engineConfiguration->spi2sckPin = GPIOB_13; - boardConfiguration->spi3mosiPin = GPIOB_5; - boardConfiguration->spi3misoPin = GPIOB_4; - boardConfiguration->spi3sckPin = GPIOB_3; + engineConfiguration->spi3mosiPin = GPIOB_5; + engineConfiguration->spi3misoPin = GPIOB_4; + engineConfiguration->spi3sckPin = GPIOB_3; // set optional subsystem configs #if EFI_MEMS @@ -1068,9 +1068,9 @@ void setDefaultFrankensoConfiguration(DECLARE_CONFIG_PARAMETER_SIGNATURE) { setDefaultSdCardParameters(PASS_CONFIG_PARAMETER_SIGNATURE); #endif /* EFI_FILE_LOGGING */ - boardConfiguration->is_enabled_spi_1 = false; - boardConfiguration->is_enabled_spi_2 = false; - boardConfiguration->is_enabled_spi_3 = true; + engineConfiguration->is_enabled_spi_1 = false; + engineConfiguration->is_enabled_spi_2 = false; + engineConfiguration->is_enabled_spi_3 = true; } void resetConfigurationExt(Logging * logger, configuration_callback_t boardCallback, engine_type_e engineType DECLARE_ENGINE_PARAMETER_SUFFIX) { @@ -1373,12 +1373,12 @@ void commonFrankensoAnalogInputs(engine_configuration_s *engineConfiguration) { } void setFrankenso0_1_joystick(engine_configuration_s *engineConfiguration) { - board_configuration_s *boardConfiguration = &engineConfiguration->bc; - boardConfiguration->joystickCenterPin = GPIOC_8; - boardConfiguration->joystickAPin = GPIOD_10; - boardConfiguration->joystickBPin = GPIO_UNASSIGNED; - boardConfiguration->joystickCPin = GPIO_UNASSIGNED; - boardConfiguration->joystickDPin = GPIOD_11; + + engineConfiguration->joystickCenterPin = GPIOC_8; + engineConfiguration->joystickAPin = GPIOD_10; + engineConfiguration->joystickBPin = GPIO_UNASSIGNED; + engineConfiguration->joystickCPin = GPIO_UNASSIGNED; + engineConfiguration->joystickDPin = GPIOD_11; } void copyTargetAfrTable(fuel_table_t const source, afr_table_t destination) { diff --git a/firmware/controllers/algo/fuel_math.cpp b/firmware/controllers/algo/fuel_math.cpp index e059f99f90..7fd257cced 100644 --- a/firmware/controllers/algo/fuel_math.cpp +++ b/firmware/controllers/algo/fuel_math.cpp @@ -344,7 +344,7 @@ float getFuelCutOffCorrection(efitick_t nowNt, int rpm DECLARE_ENGINE_PARAMETER_ float fuelCorr = 1.0f; // coasting fuel cut-off correction - if (CONFIGB(coastingFuelCutEnabled)) { + if (CONFIG(coastingFuelCutEnabled)) { percent_t tpsPos = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE); float map = getMap(PASS_ENGINE_PARAMETER_SIGNATURE); diff --git a/firmware/controllers/core/common_headers.h b/firmware/controllers/core/common_headers.h index aa0056ac64..189222b212 100644 --- a/firmware/controllers/core/common_headers.h +++ b/firmware/controllers/core/common_headers.h @@ -68,20 +68,18 @@ #define DECLARE_ENGINE_PTR \ Engine *engine = nullptr; \ engine_configuration_s *engineConfiguration = nullptr; \ - persistent_config_s *config = nullptr; \ - board_configuration_s *boardConfiguration = nullptr; + persistent_config_s *config = nullptr; #define INJECT_ENGINE_REFERENCE(x) \ (x)->engine = engine; \ (x)->engineConfiguration = engineConfiguration; \ - (x)->config = config; \ - (x)->boardConfiguration = boardConfiguration; + (x)->config = config; #define EXPAND_Engine \ engine_configuration_s *engineConfiguration = engine->engineConfigurationPtr; \ persistent_config_s *config = engine->config; \ - board_configuration_s *boardConfiguration = &engineConfiguration->bc; + #ifndef EFI_ACTIVE_CONFIGURATION_IN_FLASH // We store a special changeable copy of configuration is RAM, so we can just compare them diff --git a/firmware/controllers/core/fsio_core.cpp b/firmware/controllers/core/fsio_core.cpp index 221c77874e..f4a08c0038 100644 --- a/firmware/controllers/core/fsio_core.cpp +++ b/firmware/controllers/core/fsio_core.cpp @@ -254,7 +254,7 @@ bool LECalculator::processElement(LEElement *element DECLARE_ENGINE_PARAMETER_SU float humanIndex = pop(LE_METHOD_FSIO_SETTING); int index = (int) humanIndex - 1; if (index >= 0 && index < FSIO_COMMAND_COUNT) { - push(element->action, CONFIGB(fsio_setting)[index]); + push(element->action, CONFIG(fsio_setting)[index]); } else { push(element->action, NAN); } diff --git a/firmware/controllers/core/fsio_impl.cpp b/firmware/controllers/core/fsio_impl.cpp index 8b358f3a9c..bcbc454787 100644 --- a/firmware/controllers/core/fsio_impl.cpp +++ b/firmware/controllers/core/fsio_impl.cpp @@ -229,7 +229,7 @@ static void setFsioOutputPin(const char *indexStr, const char *pinName) { scheduleMsg(logger, "invalid pin name [%s]", pinName); return; } - CONFIGB(fsioOutputPins)[index] = pin; + CONFIG(fsioOutputPins)[index] = pin; scheduleMsg(logger, "FSIO output pin #%d [%s]", (index + 1), hwPortname(pin)); scheduleMsg(logger, "please writeconfig and reboot for pin to take effect"); showFsioInfo(); @@ -242,13 +242,13 @@ static void setFsioOutputPin(const char *indexStr, const char *pinName) { * index is between zero and LE_COMMAND_LENGTH-1 */ void setFsioExt(int index, brain_pin_e pin, const char * formula, int pwmFrequency DECLARE_CONFIG_PARAMETER_SUFFIX) { - CONFIGB(fsioOutputPins)[index] = pin; + CONFIG(fsioOutputPins)[index] = pin; int len = strlen(formula); if (len >= LE_COMMAND_LENGTH) { return; } strcpy(config->fsioFormulas[index], formula); - CONFIGB(fsioFrequency)[index] = pwmFrequency; + CONFIG(fsioFrequency)[index] = pwmFrequency; } void setFsio(int index, brain_pin_e pin, const char * exp DECLARE_CONFIG_PARAMETER_SUFFIX) { @@ -260,7 +260,7 @@ void applyFsioConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) { for (int i = 0; i < FSIO_COMMAND_COUNT; i++) { const char *formula = config->fsioFormulas[i]; LEElement *logic = userPool.parseExpression(formula); - brain_pin_e brainPin = CONFIGB(fsioOutputPins)[i]; + brain_pin_e brainPin = CONFIG(fsioOutputPins)[i]; if (brainPin != GPIO_UNASSIGNED && logic == NULL) { warning(CUSTOM_FSIO_PARSING, "parsing [%s]", formula); } @@ -321,7 +321,7 @@ static const char *getGpioPinName(int index) { float getFsioOutputValue(int index DECLARE_ENGINE_PARAMETER_SUFFIX) { if (state.fsioLogics[index] == NULL) { - warning(CUSTOM_NO_FSIO, "no FSIO for #%d %s", index + 1, hwPortname(CONFIGB(fsioOutputPins)[index])); + warning(CUSTOM_NO_FSIO, "no FSIO for #%d %s", index + 1, hwPortname(CONFIG(fsioOutputPins)[index])); return NAN; } else { return calc.getValue2(engine->fsioState.fsioLastValue[index], state.fsioLogics[index] PASS_ENGINE_PARAMETER_SUFFIX); @@ -332,12 +332,12 @@ float getFsioOutputValue(int index DECLARE_ENGINE_PARAMETER_SUFFIX) { * @param index from zero for (FSIO_COMMAND_COUNT - 1) */ static void handleFsio(int index DECLARE_ENGINE_PARAMETER_SUFFIX) { - if (CONFIGB(fsioOutputPins)[index] == GPIO_UNASSIGNED) { + if (CONFIG(fsioOutputPins)[index] == GPIO_UNASSIGNED) { engine->fsioState.fsioLastValue[index] = NAN; return; } - bool isPwmMode = CONFIGB(fsioFrequency)[index] != NO_PWM; + bool isPwmMode = CONFIG(fsioFrequency)[index] != NO_PWM; float fvalue = getFsioOutputValue(index PASS_ENGINE_PARAMETER_SUFFIX); engine->fsioState.fsioLastValue[index] = fvalue; @@ -410,11 +410,11 @@ static void setFsioFrequency(int index, int frequency) { scheduleMsg(logger, "invalid FSIO index: %d", index); return; } - CONFIGB(fsioFrequency)[index] = frequency; + CONFIG(fsioFrequency)[index] = frequency; if (frequency == 0) { - scheduleMsg(logger, "FSIO output #%d@%s set to on/off mode", index + 1, hwPortname(CONFIGB(fsioOutputPins)[index])); + scheduleMsg(logger, "FSIO output #%d@%s set to on/off mode", index + 1, hwPortname(CONFIG(fsioOutputPins)[index])); } else { - scheduleMsg(logger, "Setting FSIO frequency %dHz on #%d@%s", frequency, index + 1, hwPortname(CONFIGB(fsioOutputPins)[index])); + scheduleMsg(logger, "Setting FSIO frequency %dHz on #%d@%s", frequency, index + 1, hwPortname(CONFIG(fsioOutputPins)[index])); } } #endif /* EFI_PROD_CODE */ @@ -449,23 +449,23 @@ void runFsio(DECLARE_ENGINE_PARAMETER_SIGNATURE) { } #if EFI_FUEL_PUMP - if (CONFIGB(fuelPumpPin) != GPIO_UNASSIGNED) { + if (CONFIG(fuelPumpPin) != GPIO_UNASSIGNED) { setPinState("pump", &enginePins.fuelPumpRelay, fuelPumpLogic PASS_ENGINE_PARAMETER_SUFFIX); } #endif /* EFI_FUEL_PUMP */ #if EFI_MAIN_RELAY_CONTROL - if (CONFIGB(mainRelayPin) != GPIO_UNASSIGNED) + if (CONFIG(mainRelayPin) != GPIO_UNASSIGNED) setPinState("main_relay", &enginePins.mainRelay, mainRelayLogic PASS_ENGINE_PARAMETER_SUFFIX); #else /* EFI_MAIN_RELAY_CONTROL */ /** * main relay is always on if ECU is on, that's a good enough initial implementation */ - if (CONFIGB(mainRelayPin) != GPIO_UNASSIGNED) + if (CONFIG(mainRelayPin) != GPIO_UNASSIGNED) enginePins.mainRelay.setValue(true); #endif /* EFI_MAIN_RELAY_CONTROL */ - if (CONFIGB(starterRelayPin) != GPIO_UNASSIGNED) + if (CONFIG(starterRelayPin) != GPIO_UNASSIGNED) setPinState("starter_relay", &enginePins.starterRelay, starterRelayLogic PASS_ENGINE_PARAMETER_SUFFIX); /** @@ -475,15 +475,15 @@ void runFsio(DECLARE_ENGINE_PARAMETER_SIGNATURE) { */ enginePins.o2heater.setValue(engine->rpmCalculator.isRunning(PASS_ENGINE_PARAMETER_SIGNATURE)); - if (CONFIGB(acRelayPin) != GPIO_UNASSIGNED) { + if (CONFIG(acRelayPin) != GPIO_UNASSIGNED) { setPinState("A/C", &enginePins.acRelay, acRelayLogic PASS_ENGINE_PARAMETER_SUFFIX); } -// if (CONFIGB(alternatorControlPin) != GPIO_UNASSIGNED) { +// if (CONFIG(alternatorControlPin) != GPIO_UNASSIGNED) { // setPinState("alternator", &enginePins.alternatorField, alternatorLogic, engine PASS_ENGINE_PARAMETER_SUFFIX); // } - if (CONFIGB(fanPin) != GPIO_UNASSIGNED) { + if (CONFIG(fanPin) != GPIO_UNASSIGNED) { setPinState("fan", &enginePins.fanRelay, radiatorFanLogic PASS_ENGINE_PARAMETER_SUFFIX); } @@ -573,14 +573,14 @@ static void showFsioInfo(void) { * is the fact that the target audience is more software developers */ scheduleMsg(logger, "FSIO #%d [%s] at %s@%dHz value=%.2f", (i + 1), exp, - hwPortname(CONFIGB(fsioOutputPins)[i]), CONFIGB(fsioFrequency)[i], + hwPortname(CONFIG(fsioOutputPins)[i]), CONFIG(fsioFrequency)[i], engine->fsioState.fsioLastValue[i]); // scheduleMsg(logger, "user-defined #%d value=%.2f", i, engine->engineConfigurationPtr2->fsioLastValue[i]); showFsio(NULL, state.fsioLogics[i]); } } for (int i = 0; i < FSIO_COMMAND_COUNT; i++) { - float v = CONFIGB(fsio_setting)[i]; + float v = CONFIG(fsio_setting)[i]; if (!cisnan(v)) { scheduleMsg(logger, "user property #%d: %.2f", i + 1, v); } @@ -604,7 +604,7 @@ static void setFsioSetting(float humanIndexF, float value) { scheduleMsg(logger, "invalid FSIO index: %d", (int)humanIndexF); return; } - engineConfiguration->bc.fsio_setting[index] = value; + engineConfiguration->fsio_setting[index] = value; showFsioInfo(); #endif } @@ -674,20 +674,20 @@ void initFsioImpl(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { alternatorLogic = sysPool.parseExpression(ALTERNATOR_LOGIC); #if EFI_MAIN_RELAY_CONTROL - if (CONFIGB(mainRelayPin) != GPIO_UNASSIGNED) + if (CONFIG(mainRelayPin) != GPIO_UNASSIGNED) mainRelayLogic = sysPool.parseExpression(MAIN_RELAY_LOGIC); #endif /* EFI_MAIN_RELAY_CONTROL */ - if (CONFIGB(starterRelayPin) != GPIO_UNASSIGNED) + if (CONFIG(starterRelayPin) != GPIO_UNASSIGNED) starterRelayLogic = sysPool.parseExpression(STARTER_RELAY_LOGIC); #if EFI_PROD_CODE for (int i = 0; i < FSIO_COMMAND_COUNT; i++) { - brain_pin_e brainPin = CONFIGB(fsioOutputPins)[i]; + brain_pin_e brainPin = CONFIG(fsioOutputPins)[i]; if (brainPin != GPIO_UNASSIGNED) { - int frequency = CONFIGB(fsioFrequency)[i]; + int frequency = CONFIG(fsioFrequency)[i]; if (frequency == 0) { - enginePins.fsioOutputs[i].initPin(getGpioPinName(i), CONFIGB(fsioOutputPins)[i], &DEFAULT_OUTPUT); + enginePins.fsioOutputs[i].initPin(getGpioPinName(i), CONFIG(fsioOutputPins)[i], &DEFAULT_OUTPUT); } else { startSimplePwmExt(&fsioPwm[i], "FSIOpwm", &engine->executor, @@ -739,24 +739,24 @@ extern EnginePins enginePins; // "Limp-mode" implementation for some RAM-limited configs without FSIO void runHardcodedFsio(DECLARE_ENGINE_PARAMETER_SIGNATURE) { // see MAIN_RELAY_LOGIC - if (CONFIGB(mainRelayPin) != GPIO_UNASSIGNED) { + if (CONFIG(mainRelayPin) != GPIO_UNASSIGNED) { enginePins.mainRelay.setValue((getTimeNowSeconds() < 2) || (getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE) > 5) || engine->isInShutdownMode()); } // see STARTER_RELAY_LOGIC - if (CONFIGB(starterRelayPin) != GPIO_UNASSIGNED) { + if (CONFIG(starterRelayPin) != GPIO_UNASSIGNED) { enginePins.starterRelay.setValue(engine->rpmCalculator.getRpm() < engineConfiguration->cranking.rpm); } // see FAN_CONTROL_LOGIC - if (CONFIGB(fanPin) != GPIO_UNASSIGNED) { + if (CONFIG(fanPin) != GPIO_UNASSIGNED) { enginePins.fanRelay.setValue((enginePins.fanRelay.getLogicValue() && (getCoolantTemperature() > engineConfiguration->fanOffTemperature)) || (getCoolantTemperature() > engineConfiguration->fanOnTemperature) || engine->isCltBroken); } // see AC_RELAY_LOGIC - if (CONFIGB(acRelayPin) != GPIO_UNASSIGNED) { + if (CONFIG(acRelayPin) != GPIO_UNASSIGNED) { enginePins.acRelay.setValue(getAcToggle(PASS_ENGINE_PARAMETER_SIGNATURE) && engine->rpmCalculator.getRpm() > 850); } // see FUEL_PUMP_LOGIC - if (CONFIGB(fuelPumpPin) != GPIO_UNASSIGNED) { + if (CONFIG(fuelPumpPin) != GPIO_UNASSIGNED) { enginePins.fuelPumpRelay.setValue((getTimeNowSeconds() < engineConfiguration->startUpFuelPumpDuration) || (engine->rpmCalculator.getRpm() > 0)); } diff --git a/firmware/controllers/engine_controller.cpp b/firmware/controllers/engine_controller.cpp index bdbc78fb2c..d0926a3493 100644 --- a/firmware/controllers/engine_controller.cpp +++ b/firmware/controllers/engine_controller.cpp @@ -157,7 +157,7 @@ class PeriodicSlowController : public PeriodicTimerController { int getPeriodMs() override { // we need at least protection from zero value while resetting configuration - int periodMs = maxI(50, CONFIGB(generalPeriodicThreadPeriodMs)); + int periodMs = maxI(50, CONFIG(generalPeriodicThreadPeriodMs)); return periodMs; } }; @@ -389,7 +389,7 @@ static void printAnalogChannelInfoExt(const char *name, adc_channel_e hwChannel, } if (fastAdc.isHwUsed(hwChannel)) { - scheduleMsg(&logger, "fast enabled=%s", boolToString(CONFIGB(isFastAdcEnabled))); + scheduleMsg(&logger, "fast enabled=%s", boolToString(CONFIG(isFastAdcEnabled))); } float voltage = adcVoltage * dividerCoeff; @@ -769,7 +769,7 @@ void initEngineContoller(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) initEgoAveraging(PASS_ENGINE_PARAMETER_SIGNATURE); #if EFI_ENGINE_CONTROL && EFI_SHAFT_POSITION_INPUT - if (CONFIGB(isEngineControlEnabled)) { + if (CONFIG(isEngineControlEnabled)) { /** * This method initialized the main listener which actually runs injectors & ignition */ diff --git a/firmware/controllers/engine_cycle/main_trigger_callback.cpp b/firmware/controllers/engine_cycle/main_trigger_callback.cpp index 647a3ee6c1..0e4fcc9aa9 100644 --- a/firmware/controllers/engine_cycle/main_trigger_callback.cpp +++ b/firmware/controllers/engine_cycle/main_trigger_callback.cpp @@ -342,7 +342,7 @@ static void fuelClosedLoopCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) { if (GET_RPM_VALUE < CONFIG(fuelClosedLoopRpmThreshold) || getCoolantTemperature() < CONFIG(fuelClosedLoopCltThreshold) || getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) > CONFIG(fuelClosedLoopTpsThreshold) || - ENGINE(sensors.currentAfr) < CONFIGB(fuelClosedLoopAfrLowThreshold) || + ENGINE(sensors.currentAfr) < CONFIG(fuelClosedLoopAfrLowThreshold) || ENGINE(sensors.currentAfr) > engineConfiguration->fuelClosedLoopAfrHighThreshold) { engine->engineState.running.pidCorrection = 0; fuelPid.reset(); @@ -443,7 +443,7 @@ void mainTriggerCallback(trigger_event_e ckpSignalType, uint32_t trgEventIndex D efiAssertVoid(CUSTOM_STACK_6629, getCurrentRemainingStack() > 128, "lowstck#2"); #if EFI_CDM_INTEGRATION - if (trgEventIndex == 0 && CONFIGB(cdmInputPin) != GPIO_UNASSIGNED) { + if (trgEventIndex == 0 && CONFIG(cdmInputPin) != GPIO_UNASSIGNED) { int cdmKnockValue = getCurrentCdmValue(engine->triggerCentral.triggerState.getTotalRevolutionCounter()); engine->knockLogic(cdmKnockValue); } diff --git a/firmware/controllers/engine_cycle/map_averaging.cpp b/firmware/controllers/engine_cycle/map_averaging.cpp index 070408753a..cdb19ca60c 100644 --- a/firmware/controllers/engine_cycle/map_averaging.cpp +++ b/firmware/controllers/engine_cycle/map_averaging.cpp @@ -211,7 +211,7 @@ static void endAveraging(void *arg) { static void applyMapMinBufferLength(DECLARE_ENGINE_PARAMETER_SIGNATURE) { // check range - mapMinBufferLength = maxI(minI(CONFIGB(mapMinBufferLength), MAX_MAP_BUFFER_LENGTH), 1); + mapMinBufferLength = maxI(minI(CONFIG(mapMinBufferLength), MAX_MAP_BUFFER_LENGTH), 1); // reset index averagedMapBufIdx = 0; // fill with maximum values @@ -279,14 +279,14 @@ static void mapAveragingTriggerCallback(trigger_event_e ckpEventType, return; } - if (CONFIGB(mapMinBufferLength) != mapMinBufferLength) { + if (CONFIG(mapMinBufferLength) != mapMinBufferLength) { applyMapMinBufferLength(PASS_ENGINE_PARAMETER_SIGNATURE); } measurementsPerRevolution = measurementsPerRevolutionCounter; measurementsPerRevolutionCounter = 0; - int samplingCount = CONFIGB(measureMapOnlyInOneCylinder) ? 1 : engineConfiguration->specs.cylindersCount; + int samplingCount = CONFIG(measureMapOnlyInOneCylinder) ? 1 : engineConfiguration->specs.cylindersCount; for (int i = 0; i < samplingCount; i++) { angle_t samplingStart = ENGINE(engineState.mapAveragingStart[i]); diff --git a/firmware/controllers/engine_cycle/rpm_calculator.cpp b/firmware/controllers/engine_cycle/rpm_calculator.cpp index 980e3eb3ba..17ccd7105e 100644 --- a/firmware/controllers/engine_cycle/rpm_calculator.cpp +++ b/firmware/controllers/engine_cycle/rpm_calculator.cpp @@ -201,7 +201,7 @@ void RpmCalculator::setStopSpinning(DECLARE_ENGINE_PARAMETER_SIGNATURE) { } void RpmCalculator::setSpinningUp(efitime_t nowNt DECLARE_ENGINE_PARAMETER_SUFFIX) { - if (!CONFIGB(isFasterEngineSpinUpEnabled)) + if (!CONFIG(isFasterEngineSpinUpEnabled)) return; // Only a completely stopped and non-spinning engine can enter the spinning-up state. if (isStopped(PASS_ENGINE_PARAMETER_SIGNATURE) && !isSpinning) { diff --git a/firmware/controllers/gauges/lcd_controller.cpp b/firmware/controllers/gauges/lcd_controller.cpp index d01aa69617..6e9ca2c70c 100644 --- a/firmware/controllers/gauges/lcd_controller.cpp +++ b/firmware/controllers/gauges/lcd_controller.cpp @@ -219,7 +219,7 @@ static void showLine(lcd_line_e line, int screenY) { #if EFI_FILE_LOGGING { char sdState; - if (CONFIGB(isSdCardEnabled)) { + if (CONFIG(isSdCardEnabled)) { sdState = isSdCardAlive() ? 'L' : 'n'; } else { sdState = 'D'; diff --git a/firmware/controllers/gauges/malfunction_indicator.cpp b/firmware/controllers/gauges/malfunction_indicator.cpp index 83684c0256..b05baa2ff8 100644 --- a/firmware/controllers/gauges/malfunction_indicator.cpp +++ b/firmware/controllers/gauges/malfunction_indicator.cpp @@ -114,7 +114,7 @@ static void testMil(void) { #endif /* TEST_MIL_CODE */ bool isMilEnabled() { - return CONFIGB(malfunctionIndicatorPin) != GPIO_UNASSIGNED; + return CONFIG(malfunctionIndicatorPin) != GPIO_UNASSIGNED; } void initMalfunctionIndicator(void) { diff --git a/firmware/controllers/gauges/tachometer.cpp b/firmware/controllers/gauges/tachometer.cpp index c0b7982e0a..4dbdd6c29f 100644 --- a/firmware/controllers/gauges/tachometer.cpp +++ b/firmware/controllers/gauges/tachometer.cpp @@ -41,11 +41,11 @@ static void tachSignalCallback(trigger_event_e ckpSignalType, } void initTachometer(void) { - if (CONFIGB(tachOutputPin) == GPIO_UNASSIGNED) { + if (CONFIG(tachOutputPin) == GPIO_UNASSIGNED) { return; } - enginePins.tachOut.initPin("analog tach output", CONFIGB(tachOutputPin), &CONFIGB(tachOutputPinMode)); + enginePins.tachOut.initPin("analog tach output", CONFIG(tachOutputPin), &CONFIG(tachOutputPinMode)); #if EFI_SHAFT_POSITION_INPUT addTriggerEventListener(tachSignalCallback, "tach", engine); diff --git a/firmware/controllers/generated/engine_configuration_generated_structures.h b/firmware/controllers/generated/engine_configuration_generated_structures.h index 9cb32cec57..b2f5edabfb 100644 --- a/firmware/controllers/generated/engine_configuration_generated_structures.h +++ b/firmware/controllers/generated/engine_configuration_generated_structures.h @@ -1,4 +1,4 @@ -// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration\rusefi_config.txt Sun Dec 08 00:34:44 EST 2019 +// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration\rusefi_config.txt Wed Dec 11 16:40:57 EST 2019 // by class com.rusefi.output.CHeaderConsumer // begin #ifndef CONTROLLERS_GENERATED_ENGINE_CONFIGURATION_GENERATED_STRUCTURES_H @@ -441,564 +441,6 @@ struct etb_io { typedef struct etb_io etb_io; -// start of board_configuration_s -struct board_configuration_s { - /** - * offset 0 - */ - idle_hardware_s idle; - /** - * value between 0 and 100 used in Manual mode - * offset 8 - */ - float manIdlePosition; - /** - * offset 12 - */ - float mapFrequency0Kpa; - /** - * offset 16 - */ - float mapFrequency100Kpa; - /** - * Same RPM is used for two ways of producing simulated RPM. See also triggerSimulatorPins (with wires) - * See also directSelfStimulation (no wires, bypassing input hardware) - * rpm X - * offset 20 - */ - int triggerSimulatorFrequency; - /** - * offset 24 - */ - output_pin_e injectionPins[INJECTION_PIN_COUNT]; - /** - * offset 36 - */ - output_pin_e ignitionPins[IGNITION_PIN_COUNT]; - /** - * offset 48 - */ - pin_output_mode_e injectionPinMode; - /** - * offset 49 - */ - pin_output_mode_e ignitionPinMode; - /** - * offset 50 - */ - brain_pin_e HD44780_rs; - /** - * offset 51 - */ - brain_pin_e HD44780_e; - /** - * offset 52 - */ - brain_pin_e HD44780_db4; - /** - * offset 53 - */ - brain_pin_e HD44780_db5; - /** - * offset 54 - */ - brain_pin_e HD44780_db6; - /** - * offset 55 - */ - brain_pin_e HD44780_db7; - /** - * offset 56 - */ - brain_pin_e gps_rx_pin; - /** - * offset 57 - */ - brain_pin_e gps_tx_pin; - /** - * offset 58 - */ - output_pin_e fuelPumpPin; - /** - * offset 59 - */ - pin_output_mode_e fuelPumpPinMode; - /** - * Check engine light, also malfunction indicator light. Always blinks once on boot. - * offset 60 - */ - output_pin_e malfunctionIndicatorPin; - /** - * offset 61 - */ - pin_output_mode_e malfunctionIndicatorPinMode; - /** - * offset 62 - */ - pin_output_mode_e fanPinMode; - /** - * offset 63 - */ - output_pin_e fanPin; - /** - * some cars have a switch to indicate that clutch pedal is all the way down - * offset 64 - */ - switch_input_pin_e clutchDownPin; - /** - * offset 65 - */ - output_pin_e alternatorControlPin; - /** - * offset 66 - */ - pin_output_mode_e alternatorControlPinMode; - /** - * offset 67 - */ - pin_input_mode_e clutchDownPinMode; - /** - * offset 68 - */ - brain_pin_e digitalPotentiometerChipSelect[DIGIPOT_COUNT]; - /** - * offset 72 - */ - pin_output_mode_e electronicThrottlePin1Mode; - /** - * offset 73 - */ - brain_pin_e wboHeaterPin; - /** - * offset 74 - */ - brain_pin_e cj125CsPin; - /** - * offset 75 - */ - spi_device_e max31855spiDevice; - /** - * offset 76 - */ - brain_pin_e debugTriggerSync; - /** - * Digital Potentiometer is used by stock ECU stimulation code - * offset 77 - */ - spi_device_e digitalPotentiometerSpiDevice; - /** - * offset 78 - */ - brain_pin_e mc33972_cs; - /** - * offset 79 - */ - pin_output_mode_e mc33972_csPinMode; - /** - * Useful in Research&Development phase - * offset 80 - */ - adc_channel_e auxFastSensor1_adcChannel; - /** - * offset 81 - */ - uint8_t unused556[3]; - /** - * offset 84 - */ - float fuelLevelEmptyTankVoltage; - /** - * offset 88 - */ - float fuelLevelFullTankVoltage; - /** - * AFR, WBO, EGO - whatever you like to call it - * offset 92 - */ - ego_sensor_e afr_type; - /** - * offset 96 - */ - float fuelClosedLoopAfrLowThreshold; - /** - * offset 100 - */ - brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT]; - /** - * offset 103 - */ - pin_output_mode_e hip9011CsPinMode; - /** - * This implementation produces one pulse per engine cycle. See also dizzySparkOutputPin. - * offset 104 - */ - output_pin_e tachOutputPin; - /** - * offset 105 - */ - pin_output_mode_e tachOutputPinMode; - /** - * offset 106 - */ - output_pin_e mainRelayPin; - /** - * offset 107 - */ - brain_pin_e sdCardCsPin; - /** - * offset 108 - */ - brain_pin_e canTxPin; - /** - * offset 109 - */ - brain_pin_e canRxPin; - /** - * offset 110 - */ - pin_input_mode_e throttlePedalUpPinMode; - /** - * offset 111 - */ - brain_pin_e debugTimerCallback; - /** - * offset 112 - */ - int idleThreadPeriodMs; - /** - * offset 116 - */ - int consoleLoopPeriodMs; - /** - * offset 120 - */ - int lcdThreadPeriodMs; - /** - * offset 124 - */ - int generalPeriodicThreadPeriodMs; - /** - * offset 128 - */ - uint32_t tunerStudioSerialSpeed; - /** - * offset 132 - */ - can_device_mode_e canDeviceMode; - /** - * Each rusEfi piece can provide synthetic trigger signal for external ECU. Sometimes these wires are routed back into trigger inputs of the same rusEfi board. - * See also directSelfStimulation which is different. - * offset 136 - */ - brain_pin_e triggerSimulatorPins[TRIGGER_SIMULATOR_PIN_COUNT]; - /** - * offset 139 - */ - pin_output_mode_e triggerSimulatorPinModes[TRIGGER_SIMULATOR_PIN_COUNT]; - /** - * Narrow band o2 heater, not used for CJ125. See wboHeaterPin - * offset 142 - */ - output_pin_e o2heaterPin; - /** - * offset 143 - */ - pin_output_mode_e o2heaterPinModeTodO; - /** - offset 144 bit 0 */ - bool is_enabled_spi_1 : 1; - /** - offset 144 bit 1 */ - bool is_enabled_spi_2 : 1; - /** - offset 144 bit 2 */ - bool is_enabled_spi_3 : 1; - /** - offset 144 bit 3 */ - bool isSdCardEnabled : 1; - /** - offset 144 bit 4 */ - bool isFastAdcEnabled : 1; - /** - offset 144 bit 5 */ - bool isEngineControlEnabled : 1; - /** - offset 144 bit 6 */ - bool isHip9011Enabled : 1; - /** - offset 144 bit 7 */ - bool isVerboseAlternator : 1; - /** - offset 144 bit 8 */ - bool useSerialPort : 1; - /** - * This setting should only be used if you have a stepper motor idle valve and a stepper motor driver installed. - offset 144 bit 9 */ - bool useStepperIdle : 1; - /** - offset 144 bit 10 */ - bool enabledStep1Limiter : 1; - /** - offset 144 bit 11 */ - bool useTpicAdvancedMode : 1; - /** - offset 144 bit 12 */ - bool useLcdScreen : 1; - /** - offset 144 bit 13 */ - bool unusedAnotherOne : 1; - /** - offset 144 bit 14 */ - bool unusedOldWarmupAfr : 1; - /** - * +This will cause the alternator to be operated in a basic on or off mode, this is the simplest alternator control. - offset 144 bit 15 */ - bool onOffAlternatorLogic : 1; - /** - offset 144 bit 16 */ - bool isCJ125Enabled : 1; - /** - * Use rise or fall signal front - offset 144 bit 17 */ - bool vvtCamSensorUseRise : 1; - /** - * Useful for individual intakes - offset 144 bit 18 */ - bool measureMapOnlyInOneCylinder : 1; - /** - offset 144 bit 19 */ - bool stepperForceParkingEveryRestart : 1; - /** - * Smarter cranking logic. - * See also startOfCrankingPrimingPulse - offset 144 bit 20 */ - bool isFasterEngineSpinUpEnabled : 1; - /** - * This setting disables fuel injection while the engine is in overrun, this is useful as a fuel saving measure and to prevent back firing. - offset 144 bit 21 */ - bool coastingFuelCutEnabled : 1; - /** - * This setting allows the ECU to open the IAC during overrun conditions to help reduce engine breaking, this can be helpful for large engines in light weight cars. - offset 144 bit 22 */ - bool useIacTableForCoasting : 1; - /** - offset 144 bit 23 */ - bool useNoiselessTriggerDecoder : 1; - /** - offset 144 bit 24 */ - bool useIdleTimingPidControl : 1; - /** - offset 144 bit 25 */ - bool useTPSBasedVeTable : 1; - /** - offset 144 bit 26 */ - bool is_enabled_spi_4 : 1; - /** - offset 144 bit 27 */ - bool pauseEtbControl : 1; - /** - offset 144 bit 28 */ - bool alignEngineSnifferAtTDC : 1; - /** - * This setting allows the ETB to act as the idle air control valve and move to regulate the airflow at idle. - offset 144 bit 29 */ - bool useETBforIdleControl : 1; - /** - offset 144 bit 30 */ - bool idleIncrementalPidCic : 1; - /** - offset 144 bit 31 */ - bool unused_board_984_31 : 1; - /** - * offset 148 - */ - brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT]; - /** - * offset 152 - */ - pin_output_mode_e mainRelayPinMode; - /** - * offset 153 - */ - brain_pin_e hip9011CsPin; - /** - * offset 154 - */ - brain_pin_e hip9011IntHoldPin; - /** - * offset 155 - */ - pin_output_mode_e hip9011IntHoldPinMode; - /** - * default or inverted input - * offset 156 - */ - uint8_t logicAnalyzerMode[LOGIC_ANALYZER_CHANNEL_COUNT]; - /** - * offset 160 - */ - int unrealisticRpmThreashold; - /** - * offset 164 - */ - pin_output_mode_e gpioPinModes[FSIO_COMMAND_COUNT]; - /** - * todo: more comments - * offset 180 - */ - output_pin_e fsioOutputPins[FSIO_COMMAND_COUNT]; - /** - * offset 196 - */ - brain_pin_e max31855_cs[EGT_CHANNEL_COUNT]; - /** - * SD card logging period, in milliseconds - * offset 204 - */ - int16_t sdCardPeriodMs; - /** - * offset 206 - */ - brain_pin_e debugSetTimer; - /** - * offset 207 - */ - brain_pin_e debugMapAveraging; - /** - * offset 208 - */ - brain_pin_e starterRelayPin; - /** - * offset 209 - */ - pin_output_mode_e starterRelayPinMode; - /** - * offset 210 - */ - uint8_t unuseduartPadding1[2]; - /** - * offset 212 - */ - int mapMinBufferLength; - /** - * offset 216 - */ - int16_t idlePidDeactivationTpsThreshold; - /** - * offset 218 - */ - int16_t stepperParkingExtraSteps; - /** - * This magic property is specific to Mazda Miata NB2 - * offset 220 - */ - float miataNb2VVTRatioFrom; - /** - * This magic property is specific to Mazda Miata NB2 - * offset 224 - */ - float miataNb2VVTRatioTo; - /** - * This pin is used for debugging - snap a logic analyzer on it and see if it's ever high - * offset 228 - */ - brain_pin_e triggerErrorPin; - /** - * offset 229 - */ - pin_output_mode_e triggerErrorPinMode; - /** - * offset 230 - */ - output_pin_e acRelayPin; - /** - * offset 231 - */ - pin_output_mode_e acRelayPinMode; - /** - * offset 232 - */ - fsio_pwm_freq_t fsioFrequency[FSIO_COMMAND_COUNT]; - /** - * offset 264 - */ - fsio_setting_t fsio_setting[FSIO_COMMAND_COUNT]; - /** - * offset 328 - */ - brain_pin_e spi1mosiPin; - /** - * offset 329 - */ - brain_pin_e spi1misoPin; - /** - * offset 330 - */ - brain_pin_e spi1sckPin; - /** - * offset 331 - */ - brain_pin_e spi2mosiPin; - /** - * offset 332 - */ - brain_pin_e spi2misoPin; - /** - * offset 333 - */ - brain_pin_e spi2sckPin; - /** - * offset 334 - */ - brain_pin_e spi3mosiPin; - /** - * offset 335 - */ - brain_pin_e spi3misoPin; - /** - * offset 336 - */ - brain_pin_e spi3sckPin; - /** - * Saab Combustion Detection Module knock signal input pin - * also known as Saab Ion Sensing Module - * offset 337 - */ - brain_pin_e cdmInputPin; - /** - * offset 338 - */ - brain_pin_e joystickCenterPin; - /** - * offset 339 - */ - brain_pin_e joystickAPin; - /** - * offset 340 - */ - brain_pin_e joystickBPin; - /** - * offset 341 - */ - brain_pin_e joystickCPin; - /** - * offset 342 - */ - brain_pin_e joystickDPin; - /** - * offset 343 - */ - uart_device_e consoleUartDevice; - /** - * rusEfi console Sensor Sniffer mode - * offset 344 - */ - sensor_chart_e sensorChartMode; - /** total size 348*/ -}; - -typedef struct board_configuration_s board_configuration_s; - // start of engine_configuration_s struct engine_configuration_s { /** @@ -1449,7 +891,554 @@ struct engine_configuration_s { /** * offset 600 */ - board_configuration_s bc; + idle_hardware_s idle; + /** + * value between 0 and 100 used in Manual mode + * offset 608 + */ + float manIdlePosition; + /** + * offset 612 + */ + float mapFrequency0Kpa; + /** + * offset 616 + */ + float mapFrequency100Kpa; + /** + * Same RPM is used for two ways of producing simulated RPM. See also triggerSimulatorPins (with wires) + * See also directSelfStimulation (no wires, bypassing input hardware) + * rpm X + * offset 620 + */ + int triggerSimulatorFrequency; + /** + * offset 624 + */ + output_pin_e injectionPins[INJECTION_PIN_COUNT]; + /** + * offset 636 + */ + output_pin_e ignitionPins[IGNITION_PIN_COUNT]; + /** + * offset 648 + */ + pin_output_mode_e injectionPinMode; + /** + * offset 649 + */ + pin_output_mode_e ignitionPinMode; + /** + * offset 650 + */ + brain_pin_e HD44780_rs; + /** + * offset 651 + */ + brain_pin_e HD44780_e; + /** + * offset 652 + */ + brain_pin_e HD44780_db4; + /** + * offset 653 + */ + brain_pin_e HD44780_db5; + /** + * offset 654 + */ + brain_pin_e HD44780_db6; + /** + * offset 655 + */ + brain_pin_e HD44780_db7; + /** + * offset 656 + */ + brain_pin_e gps_rx_pin; + /** + * offset 657 + */ + brain_pin_e gps_tx_pin; + /** + * offset 658 + */ + output_pin_e fuelPumpPin; + /** + * offset 659 + */ + pin_output_mode_e fuelPumpPinMode; + /** + * Check engine light, also malfunction indicator light. Always blinks once on boot. + * offset 660 + */ + output_pin_e malfunctionIndicatorPin; + /** + * offset 661 + */ + pin_output_mode_e malfunctionIndicatorPinMode; + /** + * offset 662 + */ + pin_output_mode_e fanPinMode; + /** + * offset 663 + */ + output_pin_e fanPin; + /** + * some cars have a switch to indicate that clutch pedal is all the way down + * offset 664 + */ + switch_input_pin_e clutchDownPin; + /** + * offset 665 + */ + output_pin_e alternatorControlPin; + /** + * offset 666 + */ + pin_output_mode_e alternatorControlPinMode; + /** + * offset 667 + */ + pin_input_mode_e clutchDownPinMode; + /** + * offset 668 + */ + brain_pin_e digitalPotentiometerChipSelect[DIGIPOT_COUNT]; + /** + * offset 672 + */ + pin_output_mode_e electronicThrottlePin1Mode; + /** + * offset 673 + */ + brain_pin_e wboHeaterPin; + /** + * offset 674 + */ + brain_pin_e cj125CsPin; + /** + * offset 675 + */ + spi_device_e max31855spiDevice; + /** + * offset 676 + */ + brain_pin_e debugTriggerSync; + /** + * Digital Potentiometer is used by stock ECU stimulation code + * offset 677 + */ + spi_device_e digitalPotentiometerSpiDevice; + /** + * offset 678 + */ + brain_pin_e mc33972_cs; + /** + * offset 679 + */ + pin_output_mode_e mc33972_csPinMode; + /** + * Useful in Research&Development phase + * offset 680 + */ + adc_channel_e auxFastSensor1_adcChannel; + /** + * offset 681 + */ + uint8_t unused556[3]; + /** + * offset 684 + */ + float fuelLevelEmptyTankVoltage; + /** + * offset 688 + */ + float fuelLevelFullTankVoltage; + /** + * AFR, WBO, EGO - whatever you like to call it + * offset 692 + */ + ego_sensor_e afr_type; + /** + * offset 696 + */ + float fuelClosedLoopAfrLowThreshold; + /** + * offset 700 + */ + brain_input_pin_e triggerInputPins[TRIGGER_INPUT_PIN_COUNT]; + /** + * offset 703 + */ + pin_output_mode_e hip9011CsPinMode; + /** + * This implementation produces one pulse per engine cycle. See also dizzySparkOutputPin. + * offset 704 + */ + output_pin_e tachOutputPin; + /** + * offset 705 + */ + pin_output_mode_e tachOutputPinMode; + /** + * offset 706 + */ + output_pin_e mainRelayPin; + /** + * offset 707 + */ + brain_pin_e sdCardCsPin; + /** + * offset 708 + */ + brain_pin_e canTxPin; + /** + * offset 709 + */ + brain_pin_e canRxPin; + /** + * offset 710 + */ + pin_input_mode_e throttlePedalUpPinMode; + /** + * offset 711 + */ + brain_pin_e debugTimerCallback; + /** + * offset 712 + */ + int idleThreadPeriodMs; + /** + * offset 716 + */ + int consoleLoopPeriodMs; + /** + * offset 720 + */ + int lcdThreadPeriodMs; + /** + * offset 724 + */ + int generalPeriodicThreadPeriodMs; + /** + * offset 728 + */ + uint32_t tunerStudioSerialSpeed; + /** + * offset 732 + */ + can_device_mode_e canDeviceMode; + /** + * Each rusEfi piece can provide synthetic trigger signal for external ECU. Sometimes these wires are routed back into trigger inputs of the same rusEfi board. + * See also directSelfStimulation which is different. + * offset 736 + */ + brain_pin_e triggerSimulatorPins[TRIGGER_SIMULATOR_PIN_COUNT]; + /** + * offset 739 + */ + pin_output_mode_e triggerSimulatorPinModes[TRIGGER_SIMULATOR_PIN_COUNT]; + /** + * Narrow band o2 heater, not used for CJ125. See wboHeaterPin + * offset 742 + */ + output_pin_e o2heaterPin; + /** + * offset 743 + */ + pin_output_mode_e o2heaterPinModeTodO; + /** + offset 744 bit 0 */ + bool is_enabled_spi_1 : 1; + /** + offset 744 bit 1 */ + bool is_enabled_spi_2 : 1; + /** + offset 744 bit 2 */ + bool is_enabled_spi_3 : 1; + /** + offset 744 bit 3 */ + bool isSdCardEnabled : 1; + /** + offset 744 bit 4 */ + bool isFastAdcEnabled : 1; + /** + offset 744 bit 5 */ + bool isEngineControlEnabled : 1; + /** + offset 744 bit 6 */ + bool isHip9011Enabled : 1; + /** + offset 744 bit 7 */ + bool isVerboseAlternator : 1; + /** + offset 744 bit 8 */ + bool useSerialPort : 1; + /** + * This setting should only be used if you have a stepper motor idle valve and a stepper motor driver installed. + offset 744 bit 9 */ + bool useStepperIdle : 1; + /** + offset 744 bit 10 */ + bool enabledStep1Limiter : 1; + /** + offset 744 bit 11 */ + bool useTpicAdvancedMode : 1; + /** + offset 744 bit 12 */ + bool useLcdScreen : 1; + /** + offset 744 bit 13 */ + bool unusedAnotherOne : 1; + /** + offset 744 bit 14 */ + bool unusedOldWarmupAfr : 1; + /** + * +This will cause the alternator to be operated in a basic on or off mode, this is the simplest alternator control. + offset 744 bit 15 */ + bool onOffAlternatorLogic : 1; + /** + offset 744 bit 16 */ + bool isCJ125Enabled : 1; + /** + * Use rise or fall signal front + offset 744 bit 17 */ + bool vvtCamSensorUseRise : 1; + /** + * Useful for individual intakes + offset 744 bit 18 */ + bool measureMapOnlyInOneCylinder : 1; + /** + offset 744 bit 19 */ + bool stepperForceParkingEveryRestart : 1; + /** + * Smarter cranking logic. + * See also startOfCrankingPrimingPulse + offset 744 bit 20 */ + bool isFasterEngineSpinUpEnabled : 1; + /** + * This setting disables fuel injection while the engine is in overrun, this is useful as a fuel saving measure and to prevent back firing. + offset 744 bit 21 */ + bool coastingFuelCutEnabled : 1; + /** + * This setting allows the ECU to open the IAC during overrun conditions to help reduce engine breaking, this can be helpful for large engines in light weight cars. + offset 744 bit 22 */ + bool useIacTableForCoasting : 1; + /** + offset 744 bit 23 */ + bool useNoiselessTriggerDecoder : 1; + /** + offset 744 bit 24 */ + bool useIdleTimingPidControl : 1; + /** + offset 744 bit 25 */ + bool useTPSBasedVeTable : 1; + /** + offset 744 bit 26 */ + bool is_enabled_spi_4 : 1; + /** + offset 744 bit 27 */ + bool pauseEtbControl : 1; + /** + offset 744 bit 28 */ + bool alignEngineSnifferAtTDC : 1; + /** + * This setting allows the ETB to act as the idle air control valve and move to regulate the airflow at idle. + offset 744 bit 29 */ + bool useETBforIdleControl : 1; + /** + offset 744 bit 30 */ + bool idleIncrementalPidCic : 1; + /** + offset 744 bit 31 */ + bool unused_board_984_31 : 1; + /** + * offset 748 + */ + brain_input_pin_e logicAnalyzerPins[LOGIC_ANALYZER_CHANNEL_COUNT]; + /** + * offset 752 + */ + pin_output_mode_e mainRelayPinMode; + /** + * offset 753 + */ + brain_pin_e hip9011CsPin; + /** + * offset 754 + */ + brain_pin_e hip9011IntHoldPin; + /** + * offset 755 + */ + pin_output_mode_e hip9011IntHoldPinMode; + /** + * default or inverted input + * offset 756 + */ + uint8_t logicAnalyzerMode[LOGIC_ANALYZER_CHANNEL_COUNT]; + /** + * offset 760 + */ + int unrealisticRpmThreashold; + /** + * offset 764 + */ + pin_output_mode_e gpioPinModes[FSIO_COMMAND_COUNT]; + /** + * todo: more comments + * offset 780 + */ + output_pin_e fsioOutputPins[FSIO_COMMAND_COUNT]; + /** + * offset 796 + */ + brain_pin_e max31855_cs[EGT_CHANNEL_COUNT]; + /** + * SD card logging period, in milliseconds + * offset 804 + */ + int16_t sdCardPeriodMs; + /** + * offset 806 + */ + brain_pin_e debugSetTimer; + /** + * offset 807 + */ + brain_pin_e debugMapAveraging; + /** + * offset 808 + */ + brain_pin_e starterRelayPin; + /** + * offset 809 + */ + pin_output_mode_e starterRelayPinMode; + /** + * offset 810 + */ + uint8_t unuseduartPadding1[2]; + /** + * offset 812 + */ + int mapMinBufferLength; + /** + * offset 816 + */ + int16_t idlePidDeactivationTpsThreshold; + /** + * offset 818 + */ + int16_t stepperParkingExtraSteps; + /** + * This magic property is specific to Mazda Miata NB2 + * offset 820 + */ + float miataNb2VVTRatioFrom; + /** + * This magic property is specific to Mazda Miata NB2 + * offset 824 + */ + float miataNb2VVTRatioTo; + /** + * This pin is used for debugging - snap a logic analyzer on it and see if it's ever high + * offset 828 + */ + brain_pin_e triggerErrorPin; + /** + * offset 829 + */ + pin_output_mode_e triggerErrorPinMode; + /** + * offset 830 + */ + output_pin_e acRelayPin; + /** + * offset 831 + */ + pin_output_mode_e acRelayPinMode; + /** + * offset 832 + */ + fsio_pwm_freq_t fsioFrequency[FSIO_COMMAND_COUNT]; + /** + * offset 864 + */ + fsio_setting_t fsio_setting[FSIO_COMMAND_COUNT]; + /** + * offset 928 + */ + brain_pin_e spi1mosiPin; + /** + * offset 929 + */ + brain_pin_e spi1misoPin; + /** + * offset 930 + */ + brain_pin_e spi1sckPin; + /** + * offset 931 + */ + brain_pin_e spi2mosiPin; + /** + * offset 932 + */ + brain_pin_e spi2misoPin; + /** + * offset 933 + */ + brain_pin_e spi2sckPin; + /** + * offset 934 + */ + brain_pin_e spi3mosiPin; + /** + * offset 935 + */ + brain_pin_e spi3misoPin; + /** + * offset 936 + */ + brain_pin_e spi3sckPin; + /** + * Saab Combustion Detection Module knock signal input pin + * also known as Saab Ion Sensing Module + * offset 937 + */ + brain_pin_e cdmInputPin; + /** + * offset 938 + */ + brain_pin_e joystickCenterPin; + /** + * offset 939 + */ + brain_pin_e joystickAPin; + /** + * offset 940 + */ + brain_pin_e joystickBPin; + /** + * offset 941 + */ + brain_pin_e joystickCPin; + /** + * offset 942 + */ + brain_pin_e joystickDPin; + /** + * offset 943 + */ + uart_device_e consoleUartDevice; + /** + * rusEfi console Sensor Sniffer mode + * offset 944 + */ + sensor_chart_e sensorChartMode; /** * offset 948 */ @@ -2939,4 +2928,4 @@ typedef struct persistent_config_s persistent_config_s; #endif // end -// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration\rusefi_config.txt Sun Dec 08 00:34:44 EST 2019 +// this section was generated automatically by rusEfi tool ConfigDefinition.jar based on integration\rusefi_config.txt Wed Dec 11 16:40:57 EST 2019 diff --git a/firmware/controllers/generated/rusefi_generated.h b/firmware/controllers/generated/rusefi_generated.h index 39e6501f06..dc89b2db34 100644 --- a/firmware/controllers/generated/rusefi_generated.h +++ b/firmware/controllers/generated/rusefi_generated.h @@ -246,8 +246,6 @@ #define baroSensor_offset_hex 248 #define baroSensor_type_offset 592 #define baroSensor_type_offset_hex 250 -#define bc_offset 600 -#define bc_offset_hex 258 #define binarySerialRxPin_offset 1815 #define binarySerialRxPin_offset_hex 717 #define binarySerialTxPin_offset 1814 diff --git a/firmware/controllers/global_shared.h b/firmware/controllers/global_shared.h index 956e0d59cb..df7cc3070a 100644 --- a/firmware/controllers/global_shared.h +++ b/firmware/controllers/global_shared.h @@ -28,7 +28,7 @@ #define EXTERN_CONFIG \ extern engine_configuration_s *engineConfiguration; \ - extern board_configuration_s *boardConfiguration; \ + extern engine_configuration_s *engineConfiguration; \ extern engine_configuration_s & activeConfiguration; \ extern persistent_config_container_s persistentState; \ extern persistent_config_s *config; \ @@ -64,7 +64,6 @@ * access in unit tests */ #define CONFIG(x) persistentState.persistentConfiguration.engineConfiguration.x -#define CONFIGB(x) persistentState.persistentConfiguration.engineConfiguration.bc.x #define ENGINE(x) ___engine.x #define DEFINE_CONFIG_PARAM(x, y) diff --git a/firmware/controllers/injector_central.cpp b/firmware/controllers/injector_central.cpp index 5effd8280f..83e081e0ac 100644 --- a/firmware/controllers/injector_central.cpp +++ b/firmware/controllers/injector_central.cpp @@ -154,7 +154,7 @@ static void doRunFuel(int humanIndex, const char *delayStr, const char * onTimeS scheduleMsg(logger, "Invalid index: %d", humanIndex); return; } - brain_pin_e b = CONFIGB(injectionPins)[humanIndex - 1]; + brain_pin_e b = CONFIG(injectionPins)[humanIndex - 1]; pinbench(delayStr, onTimeStr, offTimeStr, countStr, &enginePins.injectors[humanIndex - 1], b); } @@ -169,7 +169,7 @@ static void fuelbench2(const char *delayStr, const char *indexStr, const char * } static void fanBenchExt(const char *durationMs) { - pinbench("0", durationMs, "100", "1", &enginePins.fanRelay, CONFIGB(fanPin)); + pinbench("0", durationMs, "100", "1", &enginePins.fanRelay, CONFIG(fanPin)); } void fanBench(void) { @@ -180,15 +180,15 @@ void fanBench(void) { * we are blinking for 16 seconds so that one can click the button and walk around to see the light blinking */ void milBench(void) { - pinbench("0", "500", "500", "16", &enginePins.checkEnginePin, CONFIGB(malfunctionIndicatorPin)); + pinbench("0", "500", "500", "16", &enginePins.checkEnginePin, CONFIG(malfunctionIndicatorPin)); } void fuelPumpBenchExt(const char *durationMs) { - pinbench("0", durationMs, "100", "1", &enginePins.fuelPumpRelay, CONFIGB(fuelPumpPin)); + pinbench("0", durationMs, "100", "1", &enginePins.fuelPumpRelay, CONFIG(fuelPumpPin)); } void acRelayBench(void) { - pinbench("0", "1000", "100", "1", &enginePins.acRelay, CONFIGB(acRelayPin)); + pinbench("0", "1000", "100", "1", &enginePins.acRelay, CONFIG(acRelayPin)); } void fuelPumpBench(void) { @@ -206,7 +206,7 @@ static void doRunSpark(int humanIndex, const char *delayStr, const char * onTime scheduleMsg(logger, "Invalid index: %d", humanIndex); return; } - brain_pin_e b = CONFIGB(ignitionPins)[humanIndex - 1]; + brain_pin_e b = CONFIG(ignitionPins)[humanIndex - 1]; pinbench(delayStr, onTimeStr, offTimeStr, countStr, &enginePins.coils[humanIndex - 1], b); } diff --git a/firmware/controllers/math/config_engine_specs.h b/firmware/controllers/math/config_engine_specs.h index 82628654d0..50d551432e 100644 --- a/firmware/controllers/math/config_engine_specs.h +++ b/firmware/controllers/math/config_engine_specs.h @@ -18,9 +18,9 @@ */ #if EFI_UNIT_TEST -#define DECLARE_GLOBAL_SIGNATURE Engine *engine, engine_configuration_s *___engineConfiguration, persistent_config_s *config, board_configuration_s *boardConfiguration +#define DECLARE_GLOBAL_SIGNATURE Engine *engine, engine_configuration_s *___engineConfiguration, persistent_config_s *config #define DECLARE_GLOBAL_SUFFIX , DECLARE_GLOBAL_SIGNATURE -#define PASS_GLOBAL_SIGNATURE engine, ___engineConfiguration, config, boardConfiguration +#define PASS_GLOBAL_SIGNATURE engine, ___engineConfiguration, config #define PASS_GLOBAL_SUFFIX , PASS_GLOBAL_SIGNATURE #define CONFIG_ACCESS_FOR_CONFIG_HEADER_ONLY(x) ___engineConfiguration->x #else /* EFI_UNIT_TEST */ diff --git a/firmware/controllers/persistent_store.cpp b/firmware/controllers/persistent_store.cpp index 359e222cdf..402fd05c5c 100644 --- a/firmware/controllers/persistent_store.cpp +++ b/firmware/controllers/persistent_store.cpp @@ -28,7 +28,6 @@ #include "trigger_central.h" #include "engine_controller.h" - persistent_config_container_s persistentState CCM_OPTIONAL; persistent_config_s *config = &persistentState.persistentConfiguration; @@ -39,6 +38,5 @@ persistent_config_s *config = &persistentState.persistentConfiguration; * would be a smaller evil. Whatever is needed should be passed into methods/modules/files as an explicit parameter. */ engine_configuration_s *engineConfiguration = &persistentState.persistentConfiguration.engineConfiguration; -board_configuration_s *boardConfiguration = &persistentState.persistentConfiguration.engineConfiguration.bc; #endif /* EFI_UNIT_TEST */ diff --git a/firmware/controllers/sensors/ego.cpp b/firmware/controllers/sensors/ego.cpp index d03813aa2b..71ab0232c9 100644 --- a/firmware/controllers/sensors/ego.cpp +++ b/firmware/controllers/sensors/ego.cpp @@ -49,7 +49,7 @@ static float lastAfr = stoichAfr; void initEgoAveraging(DECLARE_ENGINE_PARAMETER_SIGNATURE) { // Our averaging is intended for use only with Narrow EGOs. - if (CONFIGB(afr_type) == ES_NarrowBand) { + if (CONFIG(afr_type) == ES_NarrowBand) { totalEgoCnt = prevEgoCnt = 0; egoAfrBuf.clear(); useAveraging = true; @@ -96,7 +96,7 @@ void initEgoAveraging(DECLARE_ENGINE_PARAMETER_SIGNATURE) { bool hasAfrSensor(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #if EFI_CJ125 && HAL_USE_SPI - if (CONFIGB(isCJ125Enabled)) { + if (CONFIG(isCJ125Enabled)) { return cjHasAfrSensor(PASS_ENGINE_PARAMETER_SIGNATURE); } #endif /* EFI_CJ125 && HAL_USE_SPI */ @@ -105,7 +105,7 @@ bool hasAfrSensor(DECLARE_ENGINE_PARAMETER_SIGNATURE) { float getAfr(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #if EFI_CJ125 && HAL_USE_SPI - if (CONFIGB(isCJ125Enabled)) { + if (CONFIG(isCJ125Enabled)) { return cjGetAfr(PASS_ENGINE_PARAMETER_SIGNATURE); } #endif /* EFI_CJ125 && HAL_USE_SPI */ @@ -113,7 +113,7 @@ float getAfr(DECLARE_ENGINE_PARAMETER_SIGNATURE) { float volts = getVoltageDivided("ego", sensor->hwChannel PASS_ENGINE_PARAMETER_SUFFIX); - if (CONFIGB(afr_type) == ES_NarrowBand) { + if (CONFIG(afr_type) == ES_NarrowBand) { float afr = interpolate2d("narrow", volts, engineConfiguration->narrowToWideOxygenBins, engineConfiguration->narrowToWideOxygen); #ifdef EFI_NARROW_EGO_AVERAGING if (useAveraging) @@ -173,6 +173,6 @@ static void initEgoSensor(afr_sensor_s *sensor, ego_sensor_e type) { } void setEgoSensor(ego_sensor_e type DECLARE_CONFIG_PARAMETER_SUFFIX) { - CONFIGB(afr_type) = type; + CONFIG(afr_type) = type; initEgoSensor(&engineConfiguration->afr, type); } diff --git a/firmware/controllers/sensors/map.cpp b/firmware/controllers/sensors/map.cpp index 22e4deb748..152cf4a8e5 100644 --- a/firmware/controllers/sensors/map.cpp +++ b/firmware/controllers/sensors/map.cpp @@ -148,7 +148,7 @@ float getMapByVoltage(float voltage DECLARE_ENGINE_PARAMETER_SUFFIX) { */ float getRawMap(DECLARE_ENGINE_PARAMETER_SIGNATURE) { if (engineConfiguration->hasFrequencyReportingMapSensor) { - return interpolateMsg("rmap", CONFIGB(mapFrequency0Kpa), 0, CONFIGB(mapFrequency100Kpa), 100, mapFreq); + return interpolateMsg("rmap", CONFIG(mapFrequency0Kpa), 0, CONFIG(mapFrequency100Kpa), 100, mapFreq); } float voltage = getVoltageDivided("map", engineConfiguration->map.sensor.hwChannel PASS_ENGINE_PARAMETER_SUFFIX); diff --git a/firmware/controllers/settings.cpp b/firmware/controllers/settings.cpp index bf82370028..abec4ac2fc 100644 --- a/firmware/controllers/settings.cpp +++ b/firmware/controllers/settings.cpp @@ -81,46 +81,46 @@ void printFloatArray(const char *prefix, float array[], int size) { scheduleLogging(&logger); } -void printSpiState(Logging *logger, board_configuration_s *boardConfiguration) { - scheduleMsg(logger, "spi 1=%s/2=%s/3=%s", boolToString(boardConfiguration->is_enabled_spi_1), - boolToString(boardConfiguration->is_enabled_spi_2), boolToString(boardConfiguration->is_enabled_spi_3)); +void printSpiState(Logging *logger, const engine_configuration_s *engineConfiguration) { + scheduleMsg(logger, "spi 1=%s/2=%s/3=%s", boolToString(engineConfiguration->is_enabled_spi_1), + boolToString(engineConfiguration->is_enabled_spi_2), boolToString(engineConfiguration->is_enabled_spi_3)); } -extern board_configuration_s *boardConfiguration; +extern engine_configuration_s *engineConfiguration; static void printOutputs(const engine_configuration_s *engineConfiguration) { - scheduleMsg(&logger, "injectionPins: mode %s", getPin_output_mode_e(boardConfiguration->injectionPinMode)); + scheduleMsg(&logger, "injectionPins: mode %s", getPin_output_mode_e(engineConfiguration->injectionPinMode)); for (int i = 0; i < engineConfiguration->specs.cylindersCount; i++) { - brain_pin_e brainPin = boardConfiguration->injectionPins[i]; + brain_pin_e brainPin = engineConfiguration->injectionPins[i]; scheduleMsg(&logger, "injection #%d @ %s", (1 + i), hwPortname(brainPin)); } - scheduleMsg(&logger, "ignitionPins: mode %s", getPin_output_mode_e(boardConfiguration->ignitionPinMode)); + scheduleMsg(&logger, "ignitionPins: mode %s", getPin_output_mode_e(engineConfiguration->ignitionPinMode)); for (int i = 0; i < engineConfiguration->specs.cylindersCount; i++) { - brain_pin_e brainPin = boardConfiguration->ignitionPins[i]; + brain_pin_e brainPin = engineConfiguration->ignitionPins[i]; scheduleMsg(&logger, "ignition #%d @ %s", (1 + i), hwPortname(brainPin)); } - scheduleMsg(&logger, "idlePin: mode %s @ %s freq=%d", getPin_output_mode_e(boardConfiguration->idle.solenoidPinMode), - hwPortname(boardConfiguration->idle.solenoidPin), boardConfiguration->idle.solenoidFrequency); - scheduleMsg(&logger, "malfunctionIndicator: %s mode=%s", hwPortname(boardConfiguration->malfunctionIndicatorPin), - getPin_output_mode_e(boardConfiguration->malfunctionIndicatorPinMode)); + scheduleMsg(&logger, "idlePin: mode %s @ %s freq=%d", getPin_output_mode_e(engineConfiguration->idle.solenoidPinMode), + hwPortname(engineConfiguration->idle.solenoidPin), engineConfiguration->idle.solenoidFrequency); + scheduleMsg(&logger, "malfunctionIndicator: %s mode=%s", hwPortname(engineConfiguration->malfunctionIndicatorPin), + getPin_output_mode_e(engineConfiguration->malfunctionIndicatorPinMode)); - scheduleMsg(&logger, "fuelPumpPin: mode %s @ %s", getPin_output_mode_e(boardConfiguration->fuelPumpPinMode), - hwPortname(boardConfiguration->fuelPumpPin)); + scheduleMsg(&logger, "fuelPumpPin: mode %s @ %s", getPin_output_mode_e(engineConfiguration->fuelPumpPinMode), + hwPortname(engineConfiguration->fuelPumpPin)); - scheduleMsg(&logger, "fanPin: mode %s @ %s", getPin_output_mode_e(boardConfiguration->fanPinMode), - hwPortname(boardConfiguration->fanPin)); + scheduleMsg(&logger, "fanPin: mode %s @ %s", getPin_output_mode_e(engineConfiguration->fanPinMode), + hwPortname(engineConfiguration->fanPin)); - scheduleMsg(&logger, "mainRelay: mode %s @ %s", getPin_output_mode_e(boardConfiguration->mainRelayPinMode), - hwPortname(boardConfiguration->mainRelayPin)); + scheduleMsg(&logger, "mainRelay: mode %s @ %s", getPin_output_mode_e(engineConfiguration->mainRelayPinMode), + hwPortname(engineConfiguration->mainRelayPin)); - scheduleMsg(&logger, "starterRelay: mode %s @ %s", getPin_output_mode_e(boardConfiguration->starterRelayPinMode), - hwPortname(boardConfiguration->starterRelayPin)); + scheduleMsg(&logger, "starterRelay: mode %s @ %s", getPin_output_mode_e(engineConfiguration->starterRelayPinMode), + hwPortname(engineConfiguration->starterRelayPin)); scheduleMsg(&logger, "alternator field: mode %s @ %s", - getPin_output_mode_e(boardConfiguration->alternatorControlPinMode), - hwPortname(boardConfiguration->alternatorControlPin)); + getPin_output_mode_e(engineConfiguration->alternatorControlPinMode), + hwPortname(engineConfiguration->alternatorControlPin)); } @@ -275,7 +275,7 @@ void printConfiguration(const engine_configuration_s *engineConfiguration) { boolToString(engineConfiguration->isMapAveragingEnabled), boolToString(engineConfiguration->isTunerStudioEnabled), boolToString(engineConfiguration->isWaveAnalyzerEnabled), - boolToString(boardConfiguration->isFastAdcEnabled)); + boolToString(engineConfiguration->isFastAdcEnabled)); scheduleMsg(&logger, "isManualSpinningMode=%s/isCylinderCleanupEnabled=%s", boolToString(engineConfiguration->isManualSpinningMode), @@ -283,20 +283,20 @@ void printConfiguration(const engine_configuration_s *engineConfiguration) { scheduleMsg(&logger, "clutchUp@%s: %s", hwPortname(engineConfiguration->clutchUpPin), boolToString(engine->clutchUpState)); - scheduleMsg(&logger, "clutchDown@%s: %s", hwPortname(boardConfiguration->clutchDownPin), + scheduleMsg(&logger, "clutchDown@%s: %s", hwPortname(engineConfiguration->clutchDownPin), boolToString(engine->clutchDownState)); scheduleMsg(&logger, "nesting=%d", maxNesting); - scheduleMsg(&logger, "digitalPotentiometerSpiDevice %d", boardConfiguration->digitalPotentiometerSpiDevice); + scheduleMsg(&logger, "digitalPotentiometerSpiDevice %d", engineConfiguration->digitalPotentiometerSpiDevice); for (int i = 0; i < DIGIPOT_COUNT; i++) { scheduleMsg(&logger, "digitalPotentiometer CS%d %s", i, - hwPortname(boardConfiguration->digitalPotentiometerChipSelect[i])); + hwPortname(engineConfiguration->digitalPotentiometerChipSelect[i])); } #if EFI_PROD_CODE - printSpiState(&logger, boardConfiguration); + printSpiState(&logger, engineConfiguration); #endif /* EFI_PROD_CODE */ } @@ -334,22 +334,22 @@ void setEngineType(int value) { } static void setIdleSolenoidFrequency(int value) { - boardConfiguration->idle.solenoidFrequency = value; + engineConfiguration->idle.solenoidFrequency = value; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); } static void setInjectionPinMode(int value) { - boardConfiguration->injectionPinMode = (pin_output_mode_e) value; + engineConfiguration->injectionPinMode = (pin_output_mode_e) value; doPrintConfiguration(); } static void setIgnitionPinMode(int value) { - boardConfiguration->ignitionPinMode = (pin_output_mode_e) value; + engineConfiguration->ignitionPinMode = (pin_output_mode_e) value; doPrintConfiguration(); } static void setIdlePinMode(int value) { - boardConfiguration->idle.solenoidPinMode = (pin_output_mode_e) value; + engineConfiguration->idle.solenoidPinMode = (pin_output_mode_e) value; doPrintConfiguration(); } @@ -366,17 +366,17 @@ static void setIgnitionOffset(float value) { } static void setFuelPumpPinMode(int value) { - boardConfiguration->fuelPumpPinMode = (pin_output_mode_e) value; + engineConfiguration->fuelPumpPinMode = (pin_output_mode_e) value; doPrintConfiguration(); } static void setMalfunctionIndicatorPinMode(int value) { - boardConfiguration->malfunctionIndicatorPinMode = (pin_output_mode_e) value; + engineConfiguration->malfunctionIndicatorPinMode = (pin_output_mode_e) value; doPrintConfiguration(); } static void setSensorChartMode(int value) { - boardConfiguration->sensorChartMode = (sensor_chart_e) value; + engineConfiguration->sensorChartMode = (sensor_chart_e) value; doPrintConfiguration(); } @@ -446,10 +446,10 @@ static void printTemperatureInfo(void) { } scheduleMsg(&logger, "fan=%s @ %s", boolToString(enginePins.fanRelay.getLogicValue()), - hwPortname(boardConfiguration->fanPin)); + hwPortname(engineConfiguration->fanPin)); scheduleMsg(&logger, "A/C relay=%s @ %s", boolToString(enginePins.acRelay.getLogicValue()), - hwPortname(boardConfiguration->acRelayPin)); + hwPortname(engineConfiguration->acRelayPin)); #endif /* EFI_ANALOG_SENSORS */ } @@ -651,11 +651,11 @@ static void setWholeFuelMapCmd(float value) { #if EFI_PROD_CODE static void setEgtSpi(int spi) { - boardConfiguration->max31855spiDevice = (spi_device_e) spi; + engineConfiguration->max31855spiDevice = (spi_device_e) spi; } static void setPotSpi(int spi) { - boardConfiguration->digitalPotentiometerSpiDevice = (spi_device_e) spi; + engineConfiguration->digitalPotentiometerSpiDevice = (spi_device_e) spi; } /** @@ -675,7 +675,7 @@ static void setIgnitionPin(const char *indexStr, const char *pinName) { return; } scheduleMsg(&logger, "setting ignition pin[%d] to %s please save&restart", index, hwPortname(pin)); - boardConfiguration->ignitionPins[index] = pin; + engineConfiguration->ignitionPins[index] = pin; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); } @@ -692,27 +692,27 @@ static void setIndividualPin(const char *pinName, brain_pin_e *targetPin, const // set_idle_pin none static void setIdlePin(const char *pinName) { - setIndividualPin(pinName, &boardConfiguration->idle.solenoidPin, "idle"); + setIndividualPin(pinName, &engineConfiguration->idle.solenoidPin, "idle"); } static void setMainRelayPin(const char *pinName) { - setIndividualPin(pinName, &boardConfiguration->mainRelayPin, "main relay"); + setIndividualPin(pinName, &engineConfiguration->mainRelayPin, "main relay"); } static void setStarterRelayPin(const char *pinName) { - setIndividualPin(pinName, &boardConfiguration->starterRelayPin, "starter relay"); + setIndividualPin(pinName, &engineConfiguration->starterRelayPin, "starter relay"); } static void setAlternatorPin(const char *pinName) { - setIndividualPin(pinName, &boardConfiguration->alternatorControlPin, "alternator"); + setIndividualPin(pinName, &engineConfiguration->alternatorControlPin, "alternator"); } static void setACRelayPin(const char *pinName) { - setIndividualPin(pinName, &boardConfiguration->acRelayPin, "A/C"); + setIndividualPin(pinName, &engineConfiguration->acRelayPin, "A/C"); } static void setFuelPumpPin(const char *pinName) { - setIndividualPin(pinName, &boardConfiguration->fuelPumpPin, "fuelPump"); + setIndividualPin(pinName, &engineConfiguration->fuelPumpPin, "fuelPump"); } static void setInjectionPin(const char *indexStr, const char *pinName) { @@ -726,7 +726,7 @@ static void setInjectionPin(const char *indexStr, const char *pinName) { return; } scheduleMsg(&logger, "setting injection pin[%d] to %s please save&restart", index, hwPortname(pin)); - boardConfiguration->injectionPins[index] = pin; + engineConfiguration->injectionPins[index] = pin; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); } @@ -747,7 +747,7 @@ static void setTriggerInputPin(const char *indexStr, const char *pinName) { return; } scheduleMsg(&logger, "setting trigger pin[%d] to %s please save&restart", index, hwPortname(pin)); - boardConfiguration->triggerInputPins[index] = pin; + engineConfiguration->triggerInputPins[index] = pin; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); } @@ -760,7 +760,7 @@ static void setTriggerSimulatorMode(const char *indexStr, const char *modeCode) if (absI(mode) == ERROR_CODE) { return; } - boardConfiguration->triggerSimulatorPinModes[index] = (pin_output_mode_e) mode; + engineConfiguration->triggerSimulatorPinModes[index] = (pin_output_mode_e) mode; } static void setEgtCSPin(const char *indexStr, const char *pinName) { @@ -773,7 +773,7 @@ static void setEgtCSPin(const char *indexStr, const char *pinName) { return; } scheduleMsg(&logger, "setting EGT CS pin[%d] to %s please save&restart", index, hwPortname(pin)); - boardConfiguration->max31855_cs[index] = pin; + engineConfiguration->max31855_cs[index] = pin; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); } @@ -787,7 +787,7 @@ static void setTriggerSimulatorPin(const char *indexStr, const char *pinName) { return; } scheduleMsg(&logger, "setting trigger simulator pin[%d] to %s please save&restart", index, hwPortname(pin)); - boardConfiguration->triggerSimulatorPins[index] = pin; + engineConfiguration->triggerSimulatorPins[index] = pin; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); } @@ -838,7 +838,7 @@ static void setLogicInputPin(const char *indexStr, const char *pinName) { return; } scheduleMsg(&logger, "setting logic input pin[%d] to %s please save&restart", index, hwPortname(pin)); - boardConfiguration->logicAnalyzerPins[index] = pin; + engineConfiguration->logicAnalyzerPins[index] = pin; } static void showPinFunction(const char *pinName) { @@ -883,24 +883,24 @@ static void setFuelMap(const char * rpmStr, const char *loadStr, const char *val static void setSpiMode(int index, bool mode) { switch (index) { case 1: - boardConfiguration->is_enabled_spi_1 = mode; + engineConfiguration->is_enabled_spi_1 = mode; break; case 2: - boardConfiguration->is_enabled_spi_2 = mode; + engineConfiguration->is_enabled_spi_2 = mode; break; case 3: - boardConfiguration->is_enabled_spi_3 = mode; + engineConfiguration->is_enabled_spi_3 = mode; break; default: scheduleMsg(&logger, "invalid spi index %d", index); return; } - printSpiState(&logger, boardConfiguration); + printSpiState(&logger, engineConfiguration); } static void enableOrDisable(const char *param, bool isEnabled) { if (strEqualCaseInsensitive(param, "fastadc")) { - boardConfiguration->isFastAdcEnabled = isEnabled; + engineConfiguration->isFastAdcEnabled = isEnabled; } else if (strEqualCaseInsensitive(param, CMD_TRIGGER_HW_INPUT)) { engine->hwTriggerInputEnabled = isEnabled; } else if (strEqualCaseInsensitive(param, "etb_auto")) { @@ -908,11 +908,11 @@ static void enableOrDisable(const char *param, bool isEnabled) { } else if (strEqualCaseInsensitive(param, "cranking_constant_dwell")) { engineConfiguration->useConstantDwellDuringCranking = isEnabled; } else if (strEqualCaseInsensitive(param, "cj125")) { - boardConfiguration->isCJ125Enabled = isEnabled; + engineConfiguration->isCJ125Enabled = isEnabled; } else if (strEqualCaseInsensitive(param, "engine_sniffer")) { engineConfiguration->isEngineChartEnabled = isEnabled; } else if (strEqualCaseInsensitive(param, "step1limimter")) { - boardConfiguration->enabledStep1Limiter = isEnabled; + engineConfiguration->enabledStep1Limiter = isEnabled; #if EFI_PROD_CODE } else if (strEqualCaseInsensitive(param, "auto_idle")) { #if EFI_IDLE_CONTROL @@ -920,9 +920,9 @@ static void enableOrDisable(const char *param, bool isEnabled) { #endif /* EFI_IDLE_CONTROL */ #endif /* EFI_PROD_CODE */ } else if (strEqualCaseInsensitive(param, "serial")) { - boardConfiguration->useSerialPort = isEnabled; + engineConfiguration->useSerialPort = isEnabled; } else if (strEqualCaseInsensitive(param, "stepperidle")) { - boardConfiguration->useStepperIdle = isEnabled; + engineConfiguration->useStepperIdle = isEnabled; } else if (strEqualCaseInsensitive(param, "trigger_only_front")) { engineConfiguration->useOnlyRisingEdgeForTrigger = isEnabled; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); @@ -936,7 +936,7 @@ static void enableOrDisable(const char *param, bool isEnabled) { engineConfiguration->twoWireBatchIgnition = isEnabled; incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE); } else if (strEqualCaseInsensitive(param, "HIP9011")) { - boardConfiguration->isHip9011Enabled = isEnabled; + engineConfiguration->isHip9011Enabled = isEnabled; } else if (strEqualCaseInsensitive(param, "verbose_etb")) { engineConfiguration->isVerboseETB = isEnabled; } else if (strEqualCaseInsensitive(param, "verbose_idle")) { @@ -950,15 +950,15 @@ static void enableOrDisable(const char *param, bool isEnabled) { } else if (strEqualCaseInsensitive(param, "auxdebug4")) { engineConfiguration->isVerboseAuxPid4 = isEnabled; } else if (strEqualCaseInsensitive(param, "altdebug")) { - boardConfiguration->isVerboseAlternator = isEnabled; + engineConfiguration->isVerboseAlternator = isEnabled; } else if (strEqualCaseInsensitive(param, "tpic_advanced_mode")) { - boardConfiguration->useTpicAdvancedMode = isEnabled; + engineConfiguration->useTpicAdvancedMode = isEnabled; } else if (strEqualCaseInsensitive(param, "knockdebug")) { engine->knockDebug = isEnabled; } else if (strEqualCaseInsensitive(param, "altcontrol")) { engineConfiguration->isAlternatorControlEnabled = isEnabled; } else if (strEqualCaseInsensitive(param, "sd")) { - boardConfiguration->isSdCardEnabled = isEnabled; + engineConfiguration->isSdCardEnabled = isEnabled; } else if (strEqualCaseInsensitive(param, "test_mode")) { engine->isTestMode = isEnabled; } else if (strEqualCaseInsensitive(param, "can_read")) { @@ -974,7 +974,7 @@ static void enableOrDisable(const char *param, bool isEnabled) { } else if (strEqualCaseInsensitive(param, "self_stimulation")) { engineConfiguration->directSelfStimulation = isEnabled; } else if (strEqualCaseInsensitive(param, "engine_control")) { - boardConfiguration->isEngineControlEnabled = isEnabled; + engineConfiguration->isEngineControlEnabled = isEnabled; } else if (strEqualCaseInsensitive(param, "map_avg")) { engineConfiguration->isMapAveragingEnabled = isEnabled; } else if (strEqualCaseInsensitive(param, "tunerstudio")) { @@ -1086,7 +1086,7 @@ const plain_get_integer_s getI_plain[] = { const plain_get_float_s getF_plain[] = { {"adcVcc", &engineConfiguration->adcVcc}, {"cranking_dwell", &engineConfiguration->ignitionDwellForCrankingMs}, - {"idle_position", &boardConfiguration->manIdlePosition}, + {"idle_position", &engineConfiguration->manIdlePosition}, {"ignition_offset", &engineConfiguration->ignitionOffset}, {"injection_offset", &engineConfiguration->extraInjectionOffset}, {"global_trigger_offset_angle", &engineConfiguration->globalTriggerAngleOffset}, @@ -1126,7 +1126,7 @@ static void getValue(const char *paramStr) { if (strEqualCaseInsensitive(paramStr, "isCJ125Enabled")) { - scheduleMsg(&logger, "isCJ125Enabled=%d", boardConfiguration->isCJ125Enabled); + scheduleMsg(&logger, "isCJ125Enabled=%d", engineConfiguration->isCJ125Enabled); #if EFI_PROD_CODE } else if (strEqualCaseInsensitive(paramStr, "bor")) { showBor(); @@ -1142,7 +1142,7 @@ static void getValue(const char *paramStr) { } else if (strEqualCaseInsensitive(paramStr, "global_trigger_offset_angle")) { scheduleMsg(&logger, "global_trigger_offset=%.2f", engineConfiguration->globalTriggerAngleOffset); } else if (strEqualCaseInsensitive(paramStr, "isHip9011Enabled")) { - scheduleMsg(&logger, "isHip9011Enabled=%d", boardConfiguration->isHip9011Enabled); + scheduleMsg(&logger, "isHip9011Enabled=%d", engineConfiguration->isHip9011Enabled); } #if EFI_RTC diff --git a/firmware/controllers/settings.h b/firmware/controllers/settings.h index ba49d590fe..9535e12032 100644 --- a/firmware/controllers/settings.h +++ b/firmware/controllers/settings.h @@ -12,7 +12,7 @@ #include "engine.h" void initSettings(void); -void printSpiState(Logging *logger, board_configuration_s *boardConfiguration); +void printSpiState(Logging *logger, const engine_configuration_s *engineConfiguration); void printConfiguration(const engine_configuration_s *engineConfiguration); void scheduleStopEngine(void); void setCallFromPitStop(int durationMs); diff --git a/firmware/controllers/system/efi_gpio.cpp b/firmware/controllers/system/efi_gpio.cpp index 3616753985..b209fed6b4 100644 --- a/firmware/controllers/system/efi_gpio.cpp +++ b/firmware/controllers/system/efi_gpio.cpp @@ -126,25 +126,25 @@ void EnginePins::unregisterPins() { unregisterEtbPins(); #endif /* EFI_ELECTRONIC_THROTTLE_BODY */ #if EFI_PROD_CODE - unregisterOutputIfPinOrModeChanged(fuelPumpRelay, bc.fuelPumpPin, bc.fuelPumpPinMode); - unregisterOutputIfPinOrModeChanged(fanRelay, bc.fanPin, bc.fanPinMode); - unregisterOutputIfPinOrModeChanged(acRelay, bc.acRelayPin, bc.acRelayPinMode); - unregisterOutputIfPinOrModeChanged(hipCs, bc.hip9011CsPin, bc.hip9011CsPinMode); - unregisterOutputIfPinOrModeChanged(triggerDecoderErrorPin, bc.triggerErrorPin, bc.triggerErrorPinMode); - unregisterOutputIfPinOrModeChanged(checkEnginePin, bc.malfunctionIndicatorPin, bc.malfunctionIndicatorPinMode); + unregisterOutputIfPinOrModeChanged(fuelPumpRelay, fuelPumpPin, fuelPumpPinMode); + unregisterOutputIfPinOrModeChanged(fanRelay, fanPin, fanPinMode); + unregisterOutputIfPinOrModeChanged(acRelay, acRelayPin, acRelayPinMode); + unregisterOutputIfPinOrModeChanged(hipCs, hip9011CsPin, hip9011CsPinMode); + unregisterOutputIfPinOrModeChanged(triggerDecoderErrorPin, triggerErrorPin, triggerErrorPinMode); + unregisterOutputIfPinOrModeChanged(checkEnginePin, malfunctionIndicatorPin, malfunctionIndicatorPinMode); unregisterOutputIfPinOrModeChanged(dizzyOutput, dizzySparkOutputPin, dizzySparkOutputPinMode); - unregisterOutputIfPinOrModeChanged(tachOut, bc.tachOutputPin, bc.tachOutputPinMode); - unregisterOutputIfPinOrModeChanged(idleSolenoidPin, bc.idle.solenoidPin, bc.idle.solenoidPinMode); - unregisterOutputIfPinChanged(sdCsPin, bc.sdCardCsPin); + unregisterOutputIfPinOrModeChanged(tachOut, tachOutputPin, tachOutputPinMode); + unregisterOutputIfPinOrModeChanged(idleSolenoidPin, idle.solenoidPin, idle.solenoidPinMode); + unregisterOutputIfPinChanged(sdCsPin, sdCardCsPin); unregisterOutputIfPinChanged(accelerometerCs, LIS302DLCsPin); for (int i = 0;i < FSIO_COMMAND_COUNT;i++) { - unregisterOutputIfPinChanged(fsioOutputs[i], bc.fsioOutputPins[i]); + unregisterOutputIfPinChanged(fsioOutputs[i], fsioOutputPins[i]); } - unregisterOutputIfPinOrModeChanged(alternatorPin, bc.alternatorControlPin, bc.alternatorControlPinMode); - unregisterOutputIfPinOrModeChanged(mainRelay, bc.mainRelayPin, bc.mainRelayPinMode); - unregisterOutputIfPinOrModeChanged(starterRelay, bc.starterRelayPin, bc.starterRelayPinMode); + unregisterOutputIfPinOrModeChanged(alternatorPin, alternatorControlPin, alternatorControlPinMode); + unregisterOutputIfPinOrModeChanged(mainRelay, mainRelayPin, mainRelayPinMode); + unregisterOutputIfPinOrModeChanged(starterRelay, starterRelayPin, starterRelayPinMode); #endif /* EFI_PROD_CODE */ } @@ -161,7 +161,7 @@ void EnginePins::reset() { void EnginePins::stopIgnitionPins(void) { #if EFI_PROD_CODE for (int i = 0; i < IGNITION_PIN_COUNT; i++) { - unregisterOutputIfPinOrModeChanged(enginePins.coils[i], bc.ignitionPins[i], bc.ignitionPinMode); + unregisterOutputIfPinOrModeChanged(enginePins.coils[i], ignitionPins[i], ignitionPinMode); } #endif /* EFI_PROD_CODE */ } @@ -169,7 +169,7 @@ void EnginePins::stopIgnitionPins(void) { void EnginePins::stopInjectionPins(void) { #if EFI_PROD_CODE for (int i = 0; i < INJECTION_PIN_COUNT; i++) { - unregisterOutputIfPinOrModeChanged(enginePins.injectors[i], bc.injectionPins[i], bc.injectionPinMode); + unregisterOutputIfPinOrModeChanged(enginePins.injectors[i], injectionPins[i], injectionPinMode); } #endif /* EFI_PROD_CODE */ } @@ -187,8 +187,8 @@ void EnginePins::startIgnitionPins(void) { #if EFI_PROD_CODE for (int i = 0; i < engineConfiguration->specs.cylindersCount; i++) { NamedOutputPin *output = &enginePins.coils[i]; - if (isPinOrModeChanged(bc.ignitionPins[i], bc.ignitionPinMode)) { - output->initPin(output->name, CONFIGB(ignitionPins)[i], &CONFIGB(ignitionPinMode)); + if (isPinOrModeChanged(ignitionPins[i], ignitionPinMode)) { + output->initPin(output->name, CONFIG(ignitionPins)[i], &CONFIG(ignitionPinMode)); } } if (isPinOrModeChanged(dizzySparkOutputPin, dizzySparkOutputPinMode)) { @@ -204,9 +204,9 @@ void EnginePins::startInjectionPins(void) { // todo: should we move this code closer to the injection logic? for (int i = 0; i < engineConfiguration->specs.cylindersCount; i++) { NamedOutputPin *output = &enginePins.injectors[i]; - if (isPinOrModeChanged(bc.injectionPins[i], bc.injectionPinMode)) { - output->initPin(output->name, CONFIGB(injectionPins)[i], - &CONFIGB(injectionPinMode)); + if (isPinOrModeChanged(injectionPins[i], injectionPinMode)) { + output->initPin(output->name, CONFIG(injectionPins)[i], + &CONFIG(injectionPinMode)); } } #endif /* EFI_PROD_CODE */ @@ -368,18 +368,18 @@ void initOutputPins(DECLARE_ENGINE_PARAMETER_SIGNATURE) { // memset(&outputs, 0, sizeof(outputs)); #if HAL_USE_SPI - enginePins.sdCsPin.initPin("spi CS5", CONFIGB(sdCardCsPin)); + enginePins.sdCsPin.initPin("spi CS5", CONFIG(sdCardCsPin)); #endif /* HAL_USE_SPI */ // todo: should we move this code closer to the fuel pump logic? - enginePins.fuelPumpRelay.initPin("fuel pump relay", CONFIGB(fuelPumpPin), &CONFIGB(fuelPumpPinMode)); + enginePins.fuelPumpRelay.initPin("fuel pump relay", CONFIG(fuelPumpPin), &CONFIG(fuelPumpPinMode)); - enginePins.mainRelay.initPin("main relay", CONFIGB(mainRelayPin), &CONFIGB(mainRelayPinMode)); - enginePins.starterRelay.initPin("starter relay", CONFIGB(starterRelayPin), &CONFIGB(starterRelayPinMode)); + enginePins.mainRelay.initPin("main relay", CONFIG(mainRelayPin), &CONFIG(mainRelayPinMode)); + enginePins.starterRelay.initPin("starter relay", CONFIG(starterRelayPin), &CONFIG(starterRelayPinMode)); - enginePins.fanRelay.initPin("fan relay", CONFIGB(fanPin), &CONFIGB(fanPinMode)); - enginePins.o2heater.initPin("o2 heater", CONFIGB(o2heaterPin)); - enginePins.acRelay.initPin("A/C relay", CONFIGB(acRelayPin), &CONFIGB(acRelayPinMode)); + enginePins.fanRelay.initPin("fan relay", CONFIG(fanPin), &CONFIG(fanPinMode)); + enginePins.o2heater.initPin("o2 heater", CONFIG(o2heaterPin)); + enginePins.acRelay.initPin("A/C relay", CONFIG(acRelayPin), &CONFIG(acRelayPinMode)); // digit 1 /* diff --git a/firmware/controllers/system/efi_gpio.h b/firmware/controllers/system/efi_gpio.h index e1b60f3c12..b59cab4ed9 100644 --- a/firmware/controllers/system/efi_gpio.h +++ b/firmware/controllers/system/efi_gpio.h @@ -4,10 +4,10 @@ * * * @date Sep 26, 2014 - * @author Andrey Belomutskiy, (c) 2012-2017 + * @author Andrey Belomutskiy, (c) 2012-2019 */ -#ifndef efi_gpio_H_ -#define efi_gpio_H_ + +#pragma once #include "global.h" #include "io_pins.h" @@ -191,5 +191,3 @@ const char *portname(ioportid_t GPIOx); brain_pin_e parseBrainPin(const char *str); const char *hwPortname(brain_pin_e brainPin); - -#endif /* efi_gpio_H_ */ diff --git a/firmware/controllers/trigger/trigger_central.cpp b/firmware/controllers/trigger/trigger_central.cpp index 71ab35c636..f4ad01a2ea 100644 --- a/firmware/controllers/trigger/trigger_central.cpp +++ b/firmware/controllers/trigger/trigger_central.cpp @@ -100,7 +100,7 @@ void hwHandleVvtCamSignal(trigger_value_e front DECLARE_ENGINE_PARAMETER_SUFFIX) addEngineSnifferEvent(PROTOCOL_VVT_NAME, front == TV_RISE ? PROTOCOL_ES_UP : PROTOCOL_ES_DOWN); - if (CONFIGB(vvtCamSensorUseRise) ^ (front != TV_FALL)) { + if (CONFIG(vvtCamSensorUseRise) ^ (front != TV_FALL)) { return; } @@ -126,7 +126,7 @@ void hwHandleVvtCamSignal(trigger_value_e front DECLARE_ENGINE_PARAMETER_SUFFIX) if (engineConfiguration->verboseTriggerSynchDetails) { scheduleMsg(logger, "vvt ratio %.2f", ratio); } - if (ratio < CONFIGB(miataNb2VVTRatioFrom) || ratio > CONFIGB(miataNb2VVTRatioTo)) { + if (ratio < CONFIG(miataNb2VVTRatioFrom) || ratio > CONFIG(miataNb2VVTRatioTo)) { return; } if (engineConfiguration->verboseTriggerSynchDetails) { @@ -210,7 +210,7 @@ void hwHandleShaftSignal(trigger_event_e signal) { // for effective noise filtering, we need both signal edges, // so we pass them to handleShaftSignal() and defer this test - if (!CONFIGB(useNoiselessTriggerDecoder)) { + if (!CONFIG(useNoiselessTriggerDecoder)) { if (!isUsefulSignal(signal PASS_ENGINE_PARAMETER_SUFFIX)) { return; } @@ -333,7 +333,7 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PAR nowNt = getTimeNowNt(); // This code gathers some statistics on signals and compares accumulated periods to filter interference - if (CONFIGB(useNoiselessTriggerDecoder)) { + if (CONFIG(useNoiselessTriggerDecoder)) { if (!noiseFilter(nowNt, signal PASS_ENGINE_PARAMETER_SUFFIX)) { return; } @@ -469,7 +469,7 @@ void printAllTriggers() { Engine *engine = &e; persistent_config_s *config = &pc; engine_configuration_s *engineConfiguration = &pc.engineConfiguration; - board_configuration_s *boardConfiguration = &engineConfiguration->bc; + engineConfiguration->trigger.type = tt; engineConfiguration->ambiguousOperationMode = FOUR_STROKE_CAM_SENSOR; @@ -604,27 +604,27 @@ void triggerInfo(void) { } - scheduleMsg(logger, "primary trigger input: %s", hwPortname(CONFIGB(triggerInputPins)[0])); + scheduleMsg(logger, "primary trigger input: %s", hwPortname(CONFIG(triggerInputPins)[0])); scheduleMsg(logger, "primary trigger simulator: %s %s freq=%d", - hwPortname(CONFIGB(triggerSimulatorPins)[0]), - getPin_output_mode_e(CONFIGB(triggerSimulatorPinModes)[0]), - CONFIGB(triggerSimulatorFrequency)); + hwPortname(CONFIG(triggerSimulatorPins)[0]), + getPin_output_mode_e(CONFIG(triggerSimulatorPinModes)[0]), + CONFIG(triggerSimulatorFrequency)); if (ts->needSecondTriggerInput) { - scheduleMsg(logger, "secondary trigger input: %s", hwPortname(CONFIGB(triggerInputPins)[1])); + scheduleMsg(logger, "secondary trigger input: %s", hwPortname(CONFIG(triggerInputPins)[1])); #if EFI_EMULATE_POSITION_SENSORS scheduleMsg(logger, "secondary trigger simulator: %s %s phase=%d", - hwPortname(CONFIGB(triggerSimulatorPins)[1]), - getPin_output_mode_e(CONFIGB(triggerSimulatorPinModes)[1]), triggerSignal.safe.phaseIndex); + hwPortname(CONFIG(triggerSimulatorPins)[1]), + getPin_output_mode_e(CONFIG(triggerSimulatorPinModes)[1]), triggerSignal.safe.phaseIndex); #endif /* EFI_EMULATE_POSITION_SENSORS */ } -// scheduleMsg(logger, "3rd trigger simulator: %s %s", hwPortname(CONFIGB(triggerSimulatorPins)[2]), -// getPin_output_mode_e(CONFIGB(triggerSimulatorPinModes)[2])); +// scheduleMsg(logger, "3rd trigger simulator: %s %s", hwPortname(CONFIG(triggerSimulatorPins)[2]), +// getPin_output_mode_e(CONFIG(triggerSimulatorPinModes)[2])); - scheduleMsg(logger, "trigger error extra LED: %s %s", hwPortname(CONFIGB(triggerErrorPin)), - getPin_output_mode_e(CONFIGB(triggerErrorPinMode))); - scheduleMsg(logger, "primary logic input: %s", hwPortname(CONFIGB(logicAnalyzerPins)[0])); - scheduleMsg(logger, "secondary logic input: %s", hwPortname(CONFIGB(logicAnalyzerPins)[1])); + scheduleMsg(logger, "trigger error extra LED: %s %s", hwPortname(CONFIG(triggerErrorPin)), + getPin_output_mode_e(CONFIG(triggerErrorPinMode))); + scheduleMsg(logger, "primary logic input: %s", hwPortname(CONFIG(logicAnalyzerPins)[0])); + scheduleMsg(logger, "secondary logic input: %s", hwPortname(CONFIG(logicAnalyzerPins)[1])); scheduleMsg(logger, "zeroTestTime=%d maxSchedulingPrecisionLoss=%d", engine->m.zeroTestTime, maxSchedulingPrecisionLoss); @@ -685,15 +685,15 @@ void onConfigurationChangeTriggerCallback(DECLARE_ENGINE_PARAMETER_SIGNATURE) { isConfigurationChanged(globalTriggerAngleOffset) || isConfigurationChanged(trigger.customTotalToothCount) || isConfigurationChanged(trigger.customSkippedToothCount) || - isConfigurationChanged(bc.triggerInputPins[0]) || - isConfigurationChanged(bc.triggerInputPins[1]) || - isConfigurationChanged(bc.triggerInputPins[2]) || + isConfigurationChanged(triggerInputPins[0]) || + isConfigurationChanged(triggerInputPins[1]) || + isConfigurationChanged(triggerInputPins[2]) || isConfigurationChanged(vvtMode) || - isConfigurationChanged(bc.vvtCamSensorUseRise) || + isConfigurationChanged(vvtCamSensorUseRise) || isConfigurationChanged(vvtOffset) || isConfigurationChanged(vvtDisplayInverted) || - isConfigurationChanged(bc.miataNb2VVTRatioFrom) || - isConfigurationChanged(bc.miataNb2VVTRatioTo) || + isConfigurationChanged(miataNb2VVTRatioFrom) || + isConfigurationChanged(miataNb2VVTRatioTo) || isConfigurationChanged(nbVvtIndex); if (changed) { assertEngineReference(); diff --git a/firmware/controllers/trigger/trigger_decoder.cpp b/firmware/controllers/trigger/trigger_decoder.cpp index da07d6816b..3c99601d69 100644 --- a/firmware/controllers/trigger/trigger_decoder.cpp +++ b/firmware/controllers/trigger/trigger_decoder.cpp @@ -260,7 +260,7 @@ void TriggerStateWithRunningStatistics::runtimeStatistics(efitime_t nowNt DECLAR #if EFI_SENSOR_CHART angle_t currentAngle = TRIGGER_WAVEFORM(eventAngles[currentCycle.current_index]); - if (CONFIGB(sensorChartMode) == SC_DETAILED_RPM) { + if (CONFIG(sensorChartMode) == SC_DETAILED_RPM) { scAddData(currentAngle, instantRpm); } else { scAddData(currentAngle, instantRpm / instantRpmValue[prevIndex]); @@ -767,8 +767,8 @@ void TriggerState::runtimeStatistics(efitime_t nowNt DECLARE_ENGINE_PARAMETER_SU void initTriggerDecoder(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #if EFI_GPIO_HARDWARE - enginePins.triggerDecoderErrorPin.initPin("trg_err", CONFIGB(triggerErrorPin), - &CONFIGB(triggerErrorPinMode)); + enginePins.triggerDecoderErrorPin.initPin("trg_err", CONFIG(triggerErrorPin), + &CONFIG(triggerErrorPinMode)); #endif /* EFI_GPIO_HARDWARE */ } diff --git a/firmware/controllers/trigger/trigger_emulator_algo.cpp b/firmware/controllers/trigger/trigger_emulator_algo.cpp index c022a79f66..683496d113 100644 --- a/firmware/controllers/trigger/trigger_emulator_algo.cpp +++ b/firmware/controllers/trigger/trigger_emulator_algo.cpp @@ -95,7 +95,7 @@ extern WaveChart waveChart; #endif /* EFI_ENGINE_SNIFFER */ void setTriggerEmulatorRPM(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) { - engineConfiguration->bc.triggerSimulatorFrequency = rpm; + engineConfiguration->triggerSimulatorFrequency = rpm; /** * All we need to do here is to change the periodMs * togglePwmState() would see that the periodMs has changed and act accordingly @@ -165,7 +165,7 @@ void initTriggerEmulatorLogic(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUF logger = sharedLogger; TriggerWaveform *s = &engine->triggerCentral.triggerShape; - setTriggerEmulatorRPM(engineConfiguration->bc.triggerSimulatorFrequency PASS_ENGINE_PARAMETER_SUFFIX); + setTriggerEmulatorRPM(engineConfiguration->triggerSimulatorFrequency PASS_ENGINE_PARAMETER_SUFFIX); pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.channels[0].pinStates, s->wave.channels[1].pinStates, diff --git a/firmware/development/hw_layer/poten.cpp b/firmware/development/hw_layer/poten.cpp index ab9d241938..a85ef6e0fa 100644 --- a/firmware/development/hw_layer/poten.cpp +++ b/firmware/development/hw_layer/poten.cpp @@ -97,19 +97,19 @@ static void setPotValue1(int value) { void initPotentiometers(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { logger = sharedLogger; #if EFI_POTENTIOMETER - if (CONFIGB(digitalPotentiometerSpiDevice) == SPI_NONE) { + if (CONFIG(digitalPotentiometerSpiDevice) == SPI_NONE) { scheduleMsg(logger, "digiPot spi disabled"); return; } - turnOnSpi(CONFIGB(digitalPotentiometerSpiDevice)); + turnOnSpi(CONFIG(digitalPotentiometerSpiDevice)); for (int i = 0; i < DIGIPOT_COUNT; i++) { - brain_pin_e csPin = CONFIGB(digitalPotentiometerChipSelect)[i]; + brain_pin_e csPin = CONFIG(digitalPotentiometerChipSelect)[i]; if (csPin == GPIO_UNASSIGNED) { continue; } - SPIDriver *driver = getSpiDevice(CONFIGB(digitalPotentiometerSpiDevice)); + SPIDriver *driver = getSpiDevice(CONFIG(digitalPotentiometerSpiDevice)); if (driver == NULL) { // error already reported return; diff --git a/firmware/development/logic_analyzer.cpp b/firmware/development/logic_analyzer.cpp index b9e0317bcd..20b1283c0e 100644 --- a/firmware/development/logic_analyzer.cpp +++ b/firmware/development/logic_analyzer.cpp @@ -101,12 +101,12 @@ static void waIcuPeriodCallback(WaveReader *reader) { } static void initWave(const char *name, int index) { - brain_pin_e brainPin = CONFIGB(logicAnalyzerPins)[index]; + brain_pin_e brainPin = CONFIG(logicAnalyzerPins)[index]; if (brainPin == GPIO_UNASSIGNED) return; - bool mode = CONFIGB(logicAnalyzerMode)[index]; + bool mode = CONFIG(logicAnalyzerMode)[index]; waveReaderCount++; efiAssertVoid(CUSTOM_ERR_6655, index < MAX_ICU_COUNT, "too many ICUs"); diff --git a/firmware/development/trigger_emulator.cpp b/firmware/development/trigger_emulator.cpp index 55f910d080..cc7f1a1134 100644 --- a/firmware/development/trigger_emulator.cpp +++ b/firmware/development/trigger_emulator.cpp @@ -29,11 +29,11 @@ static OutputPin emulatorOutputs[3]; EXTERN_ENGINE; void onConfigurationChangeRpmEmulatorCallback(engine_configuration_s *previousConfiguration) { - if (engineConfiguration->bc.triggerSimulatorFrequency == - previousConfiguration->bc.triggerSimulatorFrequency) { + if (engineConfiguration->triggerSimulatorFrequency == + previousConfiguration->triggerSimulatorFrequency) { return; } - setTriggerEmulatorRPM(engineConfiguration->bc.triggerSimulatorFrequency); + setTriggerEmulatorRPM(engineConfiguration->triggerSimulatorFrequency); } void initTriggerEmulator(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { @@ -48,14 +48,14 @@ void initTriggerEmulator(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) #if EFI_PROD_CODE // todo: refactor, make this a loop - triggerSignal.outputPins[0]->initPin("trg emulator ch1", CONFIGB(triggerSimulatorPins)[0], - &CONFIGB(triggerSimulatorPinModes)[0]); + triggerSignal.outputPins[0]->initPin("trg emulator ch1", CONFIG(triggerSimulatorPins)[0], + &CONFIG(triggerSimulatorPinModes)[0]); - triggerSignal.outputPins[1]->initPin("trg emulator ch2", CONFIGB(triggerSimulatorPins)[1], - &CONFIGB(triggerSimulatorPinModes)[1]); + triggerSignal.outputPins[1]->initPin("trg emulator ch2", CONFIG(triggerSimulatorPins)[1], + &CONFIG(triggerSimulatorPinModes)[1]); - triggerSignal.outputPins[2]->initPin("trg emulator ch3", CONFIGB(triggerSimulatorPins)[2], - &CONFIGB(triggerSimulatorPinModes)[2]); + triggerSignal.outputPins[2]->initPin("trg emulator ch3", CONFIG(triggerSimulatorPins)[2], + &CONFIG(triggerSimulatorPinModes)[2]); #endif /* EFI_PROD_CODE */ initTriggerEmulatorLogic(sharedLogger); diff --git a/firmware/hw_layer/adc_inputs.cpp b/firmware/hw_layer/adc_inputs.cpp index 1907c0ca4d..25e387076d 100644 --- a/firmware/hw_layer/adc_inputs.cpp +++ b/firmware/hw_layer/adc_inputs.cpp @@ -514,9 +514,9 @@ static void configureInputs(void) { addChannel("IAT", engineConfiguration->iat.adcChannel, ADC_SLOW); addChannel("AUXT#1", engineConfiguration->auxTempSensor1.adcChannel, ADC_SLOW); addChannel("AUXT#2", engineConfiguration->auxTempSensor2.adcChannel, ADC_SLOW); - if (engineConfiguration->bc.auxFastSensor1_adcChannel != EFI_ADC_0) { + if (engineConfiguration->auxFastSensor1_adcChannel != EFI_ADC_0) { // allow EFI_ADC_0 next time we have an incompatible configuration change - addChannel("AUXF#1", engineConfiguration->bc.auxFastSensor1_adcChannel, ADC_FAST); + addChannel("AUXF#1", engineConfiguration->auxFastSensor1_adcChannel, ADC_FAST); } addChannel("AFR", engineConfiguration->afr.hwChannel, ADC_SLOW); addChannel("OilP", engineConfiguration->oilPressure.hwChannel, ADC_SLOW); @@ -526,7 +526,7 @@ static void configureInputs(void) { if (engineConfiguration->high_fuel_pressure_sensor_2 != INCOMPATIBLE_CONFIG_CHANGE) addChannel("HFP2", engineConfiguration->high_fuel_pressure_sensor_2, ADC_SLOW); - if (CONFIGB(isCJ125Enabled)) { + if (CONFIG(isCJ125Enabled)) { addChannel("cj125ur", engineConfiguration->cj125ur, ADC_SLOW); addChannel("cj125ua", engineConfiguration->cj125ua, ADC_SLOW); } @@ -583,7 +583,7 @@ void initAdcInputs() { // Start the slow ADC thread slowAdcController.Start(); - if (CONFIGB(isFastAdcEnabled)) { + if (CONFIG(isFastAdcEnabled)) { fastAdc.init(); /* * Initializes the PWM driver. diff --git a/firmware/hw_layer/can_hw.cpp b/firmware/hw_layer/can_hw.cpp index 692c9b8fb1..6d03ab058c 100644 --- a/firmware/hw_layer/can_hw.cpp +++ b/firmware/hw_layer/can_hw.cpp @@ -112,8 +112,8 @@ void commonTxInit(int eid) { * send CAN message from txmsg buffer */ static void sendCanMessage2(int size) { - CANDriver *device = detectCanDevice(CONFIGB(canRxPin), - CONFIGB(canTxPin)); + CANDriver *device = detectCanDevice(CONFIG(canRxPin), + CONFIG(canTxPin)); if (device == NULL) { warning(CUSTOM_ERR_CAN_CONFIGURATION, "CAN configuration issue"); return; @@ -242,8 +242,8 @@ static void canInfoNBCBroadcast(can_nbc_e typeOfNBC) { } static void canRead(void) { - CANDriver *device = detectCanDevice(CONFIGB(canRxPin), - CONFIGB(canTxPin)); + CANDriver *device = detectCanDevice(CONFIG(canRxPin), + CONFIG(canTxPin)); if (device == NULL) { warning(CUSTOM_ERR_CAN_CONFIGURATION, "CAN configuration issue"); return; @@ -291,8 +291,8 @@ static void canInfo(void) { return; } - scheduleMsg(&logger, "CAN TX %s", hwPortname(CONFIGB(canTxPin))); - scheduleMsg(&logger, "CAN RX %s", hwPortname(CONFIGB(canRxPin))); + scheduleMsg(&logger, "CAN TX %s", hwPortname(CONFIG(canTxPin))); + scheduleMsg(&logger, "CAN RX %s", hwPortname(CONFIG(canRxPin))); scheduleMsg(&logger, "type=%d canReadEnabled=%s canWriteEnabled=%s period=%d", engineConfiguration->canNbcType, boolToString(engineConfiguration->canReadEnabled), boolToString(engineConfiguration->canWriteEnabled), engineConfiguration->canSleepPeriodMs); @@ -314,28 +314,28 @@ void postCanState(TunerStudioOutputChannels *tsOutputChannels) { #endif /* EFI_TUNER_STUDIO */ void enableFrankensoCan(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - CONFIGB(canTxPin) = GPIOB_6; - CONFIGB(canRxPin) = GPIOB_12; + CONFIG(canTxPin) = GPIOB_6; + CONFIG(canRxPin) = GPIOB_12; engineConfiguration->canReadEnabled = false; } void stopCanPins(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - brain_pin_markUnused(activeConfiguration.bc.canTxPin); - brain_pin_markUnused(activeConfiguration.bc.canRxPin); + brain_pin_markUnused(activeConfiguration.canTxPin); + brain_pin_markUnused(activeConfiguration.canRxPin); } void startCanPins(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - efiSetPadMode("CAN TX", CONFIGB(canTxPin), PAL_MODE_ALTERNATE(EFI_CAN_TX_AF)); - efiSetPadMode("CAN RX", CONFIGB(canRxPin), PAL_MODE_ALTERNATE(EFI_CAN_RX_AF)); + efiSetPadMode("CAN TX", CONFIG(canTxPin), PAL_MODE_ALTERNATE(EFI_CAN_TX_AF)); + efiSetPadMode("CAN RX", CONFIG(canRxPin), PAL_MODE_ALTERNATE(EFI_CAN_RX_AF)); } void initCan(void) { - isCanEnabled = (CONFIGB(canTxPin) != GPIO_UNASSIGNED) && (CONFIGB(canRxPin) != GPIO_UNASSIGNED); + isCanEnabled = (CONFIG(canTxPin) != GPIO_UNASSIGNED) && (CONFIG(canRxPin) != GPIO_UNASSIGNED); if (isCanEnabled) { - if (!isValidCanTxPin(CONFIGB(canTxPin))) - firmwareError(CUSTOM_OBD_70, "invalid CAN TX %s", hwPortname(CONFIGB(canTxPin))); - if (!isValidCanRxPin(CONFIGB(canRxPin))) - firmwareError(CUSTOM_OBD_70, "invalid CAN RX %s", hwPortname(CONFIGB(canRxPin))); + if (!isValidCanTxPin(CONFIG(canTxPin))) + firmwareError(CUSTOM_OBD_70, "invalid CAN TX %s", hwPortname(CONFIG(canTxPin))); + if (!isValidCanRxPin(CONFIG(canRxPin))) + firmwareError(CUSTOM_OBD_70, "invalid CAN RX %s", hwPortname(CONFIG(canRxPin))); } addConsoleAction("caninfo", canInfo); diff --git a/firmware/hw_layer/cdm_ion_sense.cpp b/firmware/hw_layer/cdm_ion_sense.cpp index 65277d210f..ae509a22ce 100644 --- a/firmware/hw_layer/cdm_ion_sense.cpp +++ b/firmware/hw_layer/cdm_ion_sense.cpp @@ -74,16 +74,16 @@ static void extIonCallback(void *arg) { } void cdmIonInit(void) { - if (CONFIGB(cdmInputPin) == GPIO_UNASSIGNED) { + if (CONFIG(cdmInputPin) == GPIO_UNASSIGNED) { return; } - int pin = (int)CONFIGB(cdmInputPin); + int pin = (int)CONFIG(cdmInputPin); if (pin <= 0 || pin > (int)GPIO_UNASSIGNED) { // todo: remove this protection once we migrate to new mandatory configuration return; } - efiExtiEnablePin("ion", CONFIGB(cdmInputPin), PAL_EVENT_MODE_RISING_EDGE, extIonCallback, NULL); + efiExtiEnablePin("ion", CONFIG(cdmInputPin), PAL_EVENT_MODE_RISING_EDGE, extIonCallback, NULL); } #endif /* EFI_CDM_INTEGRATION */ diff --git a/firmware/hw_layer/hardware.cpp b/firmware/hw_layer/hardware.cpp index c58a37d134..af9a41863a 100644 --- a/firmware/hw_layer/hardware.cpp +++ b/firmware/hw_layer/hardware.cpp @@ -103,15 +103,15 @@ void unlockSpi(void) { chMtxUnlock(&spiMtx); } -static void initSpiModules(board_configuration_s *boardConfiguration) { - UNUSED(boardConfiguration); - if (CONFIGB(is_enabled_spi_1)) { +static void initSpiModules(engine_configuration_s *engineConfiguration) { + UNUSED(engineConfiguration); + if (CONFIG(is_enabled_spi_1)) { turnOnSpi(SPI_DEVICE_1); } - if (CONFIGB(is_enabled_spi_2)) { + if (CONFIG(is_enabled_spi_2)) { turnOnSpi(SPI_DEVICE_2); } - if (CONFIGB(is_enabled_spi_3)) { + if (CONFIG(is_enabled_spi_3)) { turnOnSpi(SPI_DEVICE_3); } } @@ -217,7 +217,7 @@ void adc_callback_fast(ADCDriver *adcp, adcsample_t *buffer, size_t n) { #if EFI_SENSOR_CHART if (ENGINE(sensorChartMode) == SC_AUX_FAST1) { - float voltage = getAdcValue("fAux1", engineConfiguration->bc.auxFastSensor1_adcChannel); + float voltage = getAdcValue("fAux1", engineConfiguration->auxFastSensor1_adcChannel); scAddData(getCrankshaftAngleNt(getTimeNowNt() PASS_ENGINE_PARAMETER_SUFFIX), voltage); } #endif /* EFI_SENSOR_CHART */ @@ -226,7 +226,7 @@ void adc_callback_fast(ADCDriver *adcp, adcsample_t *buffer, size_t n) { mapAveragingAdcCallback(fastAdc.samples[fastMapSampleIndex]); #endif /* EFI_MAP_AVERAGING */ #if EFI_HIP_9011 - if (CONFIGB(isHip9011Enabled)) { + if (CONFIG(isHip9011Enabled)) { hipAdcCallback(fastAdc.samples[hipSampleIndex]); } #endif /* EFI_HIP_9011 */ @@ -327,13 +327,13 @@ void applyNewHardwareSettings(void) { stopAuxPins(); #endif /* EFI_AUX_PID */ - if (isConfigurationChanged(bc.is_enabled_spi_1)) + if (isConfigurationChanged(is_enabled_spi_1)) stopSpi(SPI_DEVICE_1); - if (isConfigurationChanged(bc.is_enabled_spi_2)) + if (isConfigurationChanged(is_enabled_spi_2)) stopSpi(SPI_DEVICE_2); - if (isConfigurationChanged(bc.is_enabled_spi_3)) + if (isConfigurationChanged(is_enabled_spi_3)) stopSpi(SPI_DEVICE_3); #if EFI_HD44780_LCD @@ -407,7 +407,7 @@ void initHardware(Logging *l) { sharedLogger = l; engine_configuration_s *engineConfiguration = engine->engineConfigurationPtr; efiAssertVoid(CUSTOM_EC_NULL, engineConfiguration!=NULL, "engineConfiguration"); - board_configuration_s *boardConfiguration = &engineConfiguration->bc; + printMsg(sharedLogger, "initHardware()"); // todo: enable protection. it's disabled because it takes @@ -487,7 +487,7 @@ void initHardware(Logging *l) { initRtc(); #if HAL_USE_SPI - initSpiModules(boardConfiguration); + initSpiModules(engineConfiguration); #endif /* HAL_USE_SPI */ // initSmartGpio depends on 'initSpiModules' initSmartGpio(PASS_ENGINE_PARAMETER_SIGNATURE); @@ -500,7 +500,7 @@ void initHardware(Logging *l) { #endif /* EFI_MC33816 */ #if EFI_MAX_31855 - initMax31855(sharedLogger, CONFIGB(max31855spiDevice), CONFIGB(max31855_cs)); + initMax31855(sharedLogger, CONFIG(max31855spiDevice), CONFIG(max31855_cs)); #endif /* EFI_MAX_31855 */ #if EFI_CAN_SUPPORT diff --git a/firmware/hw_layer/hip9011.cpp b/firmware/hw_layer/hip9011.cpp index f0dde59bde..9b11a5f7a0 100644 --- a/firmware/hw_layer/hip9011.cpp +++ b/firmware/hw_layer/hip9011.cpp @@ -132,14 +132,14 @@ EXTERN_ENGINE static char hipPinNameBuffer[16]; static void showHipInfo(void) { - if (!CONFIGB(isHip9011Enabled)) { + if (!CONFIG(isHip9011Enabled)) { scheduleMsg(logger, "hip9011 driver not active"); return; } - printSpiState(logger, boardConfiguration); + printSpiState(logger, engineConfiguration); scheduleMsg(logger, "enabled=%s state=%s bore=%.2fmm freq=%.2fkHz PaSDO=%d", - boolToString(CONFIGB(isHip9011Enabled)), + boolToString(CONFIG(isHip9011Enabled)), getHip_state_e(instance.state), engineConfiguration->cylinderBore, getHIP9011Band(PASS_HIP_PARAMS), engineConfiguration->hip9011PrescalerAndSDO); @@ -155,11 +155,11 @@ static void showHipInfo(void) { const char * msg = instance.invalidHip9011ResponsesCount > 0 ? "NOT GOOD" : "ok"; scheduleMsg(logger, "spi=%s IntHold@%s/%d response count=%d incorrect response=%d %s", getSpi_device_e(engineConfiguration->hip9011SpiDevice), - hwPortname(CONFIGB(hip9011IntHoldPin)), - CONFIGB(hip9011IntHoldPinMode), + hwPortname(CONFIG(hip9011IntHoldPin)), + CONFIG(hip9011IntHoldPinMode), instance.correctResponsesCount, instance.invalidHip9011ResponsesCount, msg); - scheduleMsg(logger, "CS@%s updateCount=%d", hwPortname(CONFIGB(hip9011CsPin)), instance.settingUpdateCount); + scheduleMsg(logger, "CS@%s updateCount=%d", hwPortname(CONFIG(hip9011CsPin)), instance.settingUpdateCount); #if EFI_PROD_CODE scheduleMsg(logger, "hip %.2fv/last=%.2f@%s/max=%.2f adv=%d", @@ -167,7 +167,7 @@ static void showHipInfo(void) { getVoltage("hipinfo", engineConfiguration->hipOutputChannel), getPinNameByAdcChannel("hip", engineConfiguration->hipOutputChannel, pinNameBuffer), hipValueMax, - CONFIGB(useTpicAdvancedMode)); + CONFIG(useTpicAdvancedMode)); scheduleMsg(logger, "mosi=%s", hwPortname(getMosiPin(engineConfiguration->hip9011SpiDevice))); scheduleMsg(logger, "miso=%s", hwPortname(getMisoPin(engineConfiguration->hip9011SpiDevice))); scheduleMsg(logger, "sck=%s", hwPortname(getSckPin(engineConfiguration->hip9011SpiDevice))); @@ -184,22 +184,22 @@ void setHip9011FrankensoPinout(void) { /** * SPI on PB13/14/15 */ - // CONFIGB(hip9011CsPin) = GPIOD_0; // rev 0.1 + // CONFIG(hip9011CsPin) = GPIOD_0; // rev 0.1 - CONFIGB(isHip9011Enabled) = true; + CONFIG(isHip9011Enabled) = true; engineConfiguration->hip9011PrescalerAndSDO = _8MHZ_PRESCALER; // 8MHz chip - CONFIGB(is_enabled_spi_2) = true; + CONFIG(is_enabled_spi_2) = true; // todo: convert this to rusEfi, hardware-independent enum #if EFI_PROD_CODE #ifdef EFI_HIP_CS_PIN - CONFIGB(hip9011CsPin) = EFI_HIP_CS_PIN; + CONFIG(hip9011CsPin) = EFI_HIP_CS_PIN; #else - CONFIGB(hip9011CsPin) = GPIOB_0; // rev 0.4 + CONFIG(hip9011CsPin) = GPIOB_0; // rev 0.4 #endif - CONFIGB(hip9011CsPinMode) = OM_OPENDRAIN; + CONFIG(hip9011CsPinMode) = OM_OPENDRAIN; - CONFIGB(hip9011IntHoldPin) = GPIOB_11; - CONFIGB(hip9011IntHoldPinMode) = OM_OPENDRAIN; + CONFIG(hip9011IntHoldPin) = GPIOB_11; + CONFIG(hip9011IntHoldPinMode) = OM_OPENDRAIN; engineConfiguration->spi2SckMode = PO_OPENDRAIN; // 4 engineConfiguration->spi2MosiMode = PO_OPENDRAIN; // 4 @@ -211,7 +211,7 @@ void setHip9011FrankensoPinout(void) { engineConfiguration->maxKnockSubDeg = 20; - if (!CONFIGB(useTpicAdvancedMode)) { + if (!CONFIG(useTpicAdvancedMode)) { engineConfiguration->hipOutputChannel = EFI_ADC_10; // PC0 } } @@ -341,7 +341,7 @@ static void hipStartupCode(void) { warning(CUSTOM_OBD_KNOCK_PROCESSOR, "TPIC/HIP does not respond"); } - if (CONFIGB(useTpicAdvancedMode)) { + if (CONFIG(useTpicAdvancedMode)) { // enable advanced mode for digital integrator output instance.hardware->sendSyncCommand(SET_ADVANCED_MODE); } @@ -384,20 +384,20 @@ static msg_t hipThread(void *arg) { void stopHip9001_pins() { #if EFI_PROD_CODE - brain_pin_markUnused(activeConfiguration.bc.hip9011IntHoldPin); - brain_pin_markUnused(activeConfiguration.bc.hip9011CsPin); + brain_pin_markUnused(activeConfiguration.hip9011IntHoldPin); + brain_pin_markUnused(activeConfiguration.hip9011CsPin); #endif /* EFI_PROD_CODE */ } void startHip9001_pins() { - intHold.initPin("hip int/hold", CONFIGB(hip9011IntHoldPin), &CONFIGB(hip9011IntHoldPinMode)); - enginePins.hipCs.initPin("hip CS", CONFIGB(hip9011CsPin), &CONFIGB(hip9011CsPinMode)); + intHold.initPin("hip int/hold", CONFIG(hip9011IntHoldPin), &CONFIG(hip9011IntHoldPinMode)); + enginePins.hipCs.initPin("hip CS", CONFIG(hip9011CsPin), &CONFIG(hip9011CsPinMode)); } void initHip9011(Logging *sharedLogger) { logger = sharedLogger; addConsoleAction("hipinfo", showHipInfo); - if (!CONFIGB(isHip9011Enabled)) + if (!CONFIG(isHip9011Enabled)) return; @@ -410,8 +410,8 @@ void initHip9011(Logging *sharedLogger) { return; } - hipSpiCfg.ssport = getHwPort("hip", CONFIGB(hip9011CsPin)); - hipSpiCfg.sspad = getHwPin("hip", CONFIGB(hip9011CsPin)); + hipSpiCfg.ssport = getHwPort("hip", CONFIG(hip9011CsPin)); + hipSpiCfg.sspad = getHwPin("hip", CONFIG(hip9011CsPin)); #endif /* EFI_PROD_CODE */ startHip9001_pins(); diff --git a/firmware/hw_layer/lcd/lcd_HD44780.cpp b/firmware/hw_layer/lcd/lcd_HD44780.cpp index 95ad1a30a1..23503eb9c1 100644 --- a/firmware/hw_layer/lcd/lcd_HD44780.cpp +++ b/firmware/hw_layer/lcd/lcd_HD44780.cpp @@ -83,18 +83,18 @@ static void writePad(const char *msg, brain_pin_e pin, int bit) { //----------------------------------------------------------------------------- static void lcd_HD44780_write(uint8_t data) { if (engineConfiguration->displayMode == DM_HD44780) { - writePad("lcd", CONFIGB(HD44780_db7), + writePad("lcd", CONFIG(HD44780_db7), data & 0x80 ? 1 : 0); - writePad("lcd", CONFIGB(HD44780_db6), + writePad("lcd", CONFIG(HD44780_db6), data & 0x40 ? 1 : 0); - writePad("lcd", CONFIGB(HD44780_db5), + writePad("lcd", CONFIG(HD44780_db5), data & 0x20 ? 1 : 0); - writePad("lcd", CONFIGB(HD44780_db4), + writePad("lcd", CONFIG(HD44780_db4), data & 0x10 ? 1 : 0); - writePad("lcd", CONFIGB(HD44780_e), 1); // En high + writePad("lcd", CONFIG(HD44780_e), 1); // En high lcdSleep(10); // enable pulse must be >450ns - writePad("lcd", CONFIGB(HD44780_e), 0); // En low + writePad("lcd", CONFIG(HD44780_e), 0); // En low lcdSleep(40); // commands need > 37us to settle } else { @@ -124,7 +124,7 @@ static void lcd_HD44780_write(uint8_t data) { //----------------------------------------------------------------------------- void lcd_HD44780_write_command(uint8_t data) { - palClearPad(getHwPort("lcd", CONFIGB(HD44780_rs)), getHwPin("lcd", CONFIGB(HD44780_rs))); + palClearPad(getHwPort("lcd", CONFIG(HD44780_rs)), getHwPin("lcd", CONFIG(HD44780_rs))); lcd_HD44780_write(data); lcd_HD44780_write(data << 4); @@ -132,13 +132,13 @@ void lcd_HD44780_write_command(uint8_t data) { //----------------------------------------------------------------------------- void lcd_HD44780_write_data(uint8_t data) { - palSetPad(getHwPort("lcd", CONFIGB(HD44780_rs)), getHwPin("lcd", CONFIGB(HD44780_rs))); + palSetPad(getHwPort("lcd", CONFIG(HD44780_rs)), getHwPin("lcd", CONFIG(HD44780_rs))); lcd_HD44780_write(data); lcd_HD44780_write(data << 4); currentColumn++; - palClearPad(getHwPort("lcd", CONFIGB(HD44780_rs)), getHwPin("lcd", CONFIGB(HD44780_rs))); + palClearPad(getHwPort("lcd", CONFIG(HD44780_rs)), getHwPin("lcd", CONFIG(HD44780_rs))); } //----------------------------------------------------------------------------- @@ -170,41 +170,41 @@ void lcd_HD44780_print_string(const char* string) { lcd_HD44780_print_char(*string++); } -//getHwPin(CONFIGB(HD44780_db7)) +//getHwPin(CONFIG(HD44780_db7)) static void lcdInfo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - scheduleMsg(logger, "HD44780 RS=%s", hwPortname(CONFIGB(HD44780_rs))); - scheduleMsg(logger, "HD44780 E=%s", hwPortname(CONFIGB(HD44780_e))); - scheduleMsg(logger, "HD44780 D4=%s", hwPortname(CONFIGB(HD44780_db4))); - scheduleMsg(logger, "HD44780 D5=%s", hwPortname(CONFIGB(HD44780_db5))); - scheduleMsg(logger, "HD44780 D6=%s", hwPortname(CONFIGB(HD44780_db6))); - scheduleMsg(logger, "HD44780 D7=%s", hwPortname(CONFIGB(HD44780_db7))); + scheduleMsg(logger, "HD44780 RS=%s", hwPortname(CONFIG(HD44780_rs))); + scheduleMsg(logger, "HD44780 E=%s", hwPortname(CONFIG(HD44780_e))); + scheduleMsg(logger, "HD44780 D4=%s", hwPortname(CONFIG(HD44780_db4))); + scheduleMsg(logger, "HD44780 D5=%s", hwPortname(CONFIG(HD44780_db5))); + scheduleMsg(logger, "HD44780 D6=%s", hwPortname(CONFIG(HD44780_db6))); + scheduleMsg(logger, "HD44780 D7=%s", hwPortname(CONFIG(HD44780_db7))); } void stopHD44780_pins() { - brain_pin_markUnused(activeConfiguration.bc.HD44780_rs); - brain_pin_markUnused(activeConfiguration.bc.HD44780_e); - brain_pin_markUnused(activeConfiguration.bc.HD44780_db4); - brain_pin_markUnused(activeConfiguration.bc.HD44780_db5); - brain_pin_markUnused(activeConfiguration.bc.HD44780_db6); - brain_pin_markUnused(activeConfiguration.bc.HD44780_db7); + brain_pin_markUnused(activeConfiguration.HD44780_rs); + brain_pin_markUnused(activeConfiguration.HD44780_e); + brain_pin_markUnused(activeConfiguration.HD44780_db4); + brain_pin_markUnused(activeConfiguration.HD44780_db5); + brain_pin_markUnused(activeConfiguration.HD44780_db6); + brain_pin_markUnused(activeConfiguration.HD44780_db7); } void startHD44780_pins() { if (engineConfiguration->displayMode == DM_HD44780) { // initialize hardware lines - efiSetPadMode("lcd RS", CONFIGB(HD44780_rs), PAL_MODE_OUTPUT_PUSHPULL); - efiSetPadMode("lcd E", CONFIGB(HD44780_e), PAL_MODE_OUTPUT_PUSHPULL); - efiSetPadMode("lcd DB4", CONFIGB(HD44780_db4), PAL_MODE_OUTPUT_PUSHPULL); - efiSetPadMode("lcd DB5", CONFIGB(HD44780_db5), PAL_MODE_OUTPUT_PUSHPULL); - efiSetPadMode("lcd DB6", CONFIGB(HD44780_db6), PAL_MODE_OUTPUT_PUSHPULL); - efiSetPadMode("lcd DB7", CONFIGB(HD44780_db7), PAL_MODE_OUTPUT_PUSHPULL); + efiSetPadMode("lcd RS", CONFIG(HD44780_rs), PAL_MODE_OUTPUT_PUSHPULL); + efiSetPadMode("lcd E", CONFIG(HD44780_e), PAL_MODE_OUTPUT_PUSHPULL); + efiSetPadMode("lcd DB4", CONFIG(HD44780_db4), PAL_MODE_OUTPUT_PUSHPULL); + efiSetPadMode("lcd DB5", CONFIG(HD44780_db5), PAL_MODE_OUTPUT_PUSHPULL); + efiSetPadMode("lcd DB6", CONFIG(HD44780_db6), PAL_MODE_OUTPUT_PUSHPULL); + efiSetPadMode("lcd DB7", CONFIG(HD44780_db7), PAL_MODE_OUTPUT_PUSHPULL); // and zero values - palWritePad(getHwPort("lcd", CONFIGB(HD44780_rs)), getHwPin("lcd", CONFIGB(HD44780_rs)), 0); - palWritePad(getHwPort("lcd", CONFIGB(HD44780_e)), getHwPin("lcd", CONFIGB(HD44780_e)), 0); - palWritePad(getHwPort("lcd", CONFIGB(HD44780_db4)), getHwPin("lcd", CONFIGB(HD44780_db4)), 0); - palWritePad(getHwPort("lcd", CONFIGB(HD44780_db5)), getHwPin("lcd", CONFIGB(HD44780_db5)), 0); - palWritePad(getHwPort("lcd", CONFIGB(HD44780_db6)), getHwPin("lcd", CONFIGB(HD44780_db6)), 0); - palWritePad(getHwPort("lcd", CONFIGB(HD44780_db7)), getHwPin("lcd", CONFIGB(HD44780_db7)), 0); + palWritePad(getHwPort("lcd", CONFIG(HD44780_rs)), getHwPin("lcd", CONFIG(HD44780_rs)), 0); + palWritePad(getHwPort("lcd", CONFIG(HD44780_e)), getHwPin("lcd", CONFIG(HD44780_e)), 0); + palWritePad(getHwPort("lcd", CONFIG(HD44780_db4)), getHwPin("lcd", CONFIG(HD44780_db4)), 0); + palWritePad(getHwPort("lcd", CONFIG(HD44780_db5)), getHwPin("lcd", CONFIG(HD44780_db5)), 0); + palWritePad(getHwPort("lcd", CONFIG(HD44780_db6)), getHwPin("lcd", CONFIG(HD44780_db6)), 0); + palWritePad(getHwPort("lcd", CONFIG(HD44780_db7)), getHwPin("lcd", CONFIG(HD44780_db7)), 0); } } diff --git a/firmware/hw_layer/max31855.cpp b/firmware/hw_layer/max31855.cpp index 75633db860..138f86b9ca 100644 --- a/firmware/hw_layer/max31855.cpp +++ b/firmware/hw_layer/max31855.cpp @@ -37,13 +37,13 @@ EXTERN_ENGINE; static void showEgtInfo(void) { #if EFI_PROD_CODE - printSpiState(logger, boardConfiguration); + printSpiState(logger, engineConfiguration); - scheduleMsg(logger, "EGT spi: %d", CONFIGB(max31855spiDevice)); + scheduleMsg(logger, "EGT spi: %d", CONFIG(max31855spiDevice)); for (int i = 0; i < EGT_CHANNEL_COUNT; i++) { - if (CONFIGB(max31855_cs)[i] != GPIO_UNASSIGNED) { - scheduleMsg(logger, "%d ETG @ %s", i, hwPortname(CONFIGB(max31855_cs)[i])); + if (CONFIG(max31855_cs)[i] != GPIO_UNASSIGNED) { + scheduleMsg(logger, "%d ETG @ %s", i, hwPortname(CONFIG(max31855_cs)[i])); } } #endif diff --git a/firmware/hw_layer/mmc_card.cpp b/firmware/hw_layer/mmc_card.cpp index a113c81004..d12b718465 100644 --- a/firmware/hw_layer/mmc_card.cpp +++ b/firmware/hw_layer/mmc_card.cpp @@ -127,7 +127,7 @@ static int logFileIndex = 1; static char logName[_MAX_FILLER + 20]; static void printMmcPinout(void) { - scheduleMsg(&logger, "MMC CS %s", hwPortname(CONFIGB(sdCardCsPin))); + scheduleMsg(&logger, "MMC CS %s", hwPortname(CONFIG(sdCardCsPin))); // todo: we need to figure out the right SPI pinout, not just SPI2 // scheduleMsg(&logger, "MMC SCK %s:%d", portname(EFI_SPI2_SCK_PORT), EFI_SPI2_SCK_PIN); // scheduleMsg(&logger, "MMC MISO %s:%d", portname(EFI_SPI2_MISO_PORT), EFI_SPI2_MISO_PIN); @@ -136,7 +136,7 @@ static void printMmcPinout(void) { static void sdStatistics(void) { printMmcPinout(); - scheduleMsg(&logger, "SD enabled=%s status=%s", boolToString(CONFIGB(isSdCardEnabled)), + scheduleMsg(&logger, "SD enabled=%s status=%s", boolToString(CONFIG(isSdCardEnabled)), sdStatus); if (isSdCardAlive()) { scheduleMsg(&logger, "filename=%s size=%d", logName, totalLoggedBytes); @@ -462,8 +462,8 @@ static THD_FUNCTION(MMCmonThread, arg) { chThdSleepMilliseconds(100); } - if (boardConfiguration->sdCardPeriodMs > 0) { - chThdSleepMilliseconds(boardConfiguration->sdCardPeriodMs); + if (engineConfiguration->sdCardPeriodMs > 0) { + chThdSleepMilliseconds(engineConfiguration->sdCardPeriodMs); } } } @@ -475,13 +475,13 @@ bool isSdCardAlive(void) { void initMmcCard(void) { logName[0] = 0; addConsoleAction("sdinfo", sdStatistics); - if (!CONFIGB(isSdCardEnabled)) { + if (!CONFIG(isSdCardEnabled)) { return; } // todo: reuse initSpiCs method? - hs_spicfg.ssport = ls_spicfg.ssport = getHwPort("mmc", CONFIGB(sdCardCsPin)); - hs_spicfg.sspad = ls_spicfg.sspad = getHwPin("mmc", CONFIGB(sdCardCsPin)); + hs_spicfg.ssport = ls_spicfg.ssport = getHwPort("mmc", CONFIG(sdCardCsPin)); + hs_spicfg.sspad = ls_spicfg.sspad = getHwPin("mmc", CONFIG(sdCardCsPin)); mmccfg.spip = getSpiDevice(engineConfiguration->sdCardSpiDevice); /** diff --git a/firmware/hw_layer/neo6m.cpp b/firmware/hw_layer/neo6m.cpp index 376357d69f..0bcd458db1 100644 --- a/firmware/hw_layer/neo6m.cpp +++ b/firmware/hw_layer/neo6m.cpp @@ -46,8 +46,8 @@ float getCurrentSpeed(void) { EXTERN_ENGINE; static void printGpsInfo(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - scheduleMsg(&logging, "GPS RX %s", hwPortname(CONFIGB(gps_rx_pin))); - scheduleMsg(&logging, "GPS TX %s", hwPortname(CONFIGB(gps_tx_pin))); + scheduleMsg(&logging, "GPS RX %s", hwPortname(CONFIG(gps_rx_pin))); + scheduleMsg(&logging, "GPS TX %s", hwPortname(CONFIG(gps_tx_pin))); scheduleMsg(&logging, "m=%d,e=%d: vehicle speed = %.2f\r\n", gpsMesagesCount, uartErrors, getCurrentSpeed()); @@ -101,8 +101,8 @@ static THD_FUNCTION(GpsThreadEntryPoint, arg) { } static bool isGpsEnabled() { - return CONFIGB(gps_rx_pin) != GPIO_UNASSIGNED || - CONFIGB(gps_tx_pin) != GPIO_UNASSIGNED; + return CONFIG(gps_rx_pin) != GPIO_UNASSIGNED || + CONFIG(gps_tx_pin) != GPIO_UNASSIGNED; } void initGps(void) { @@ -112,8 +112,8 @@ void initGps(void) { sdStart(GPS_SERIAL_DEVICE, &GPSserialConfig); // GPS we have USART1: PB7 -> USART1_RX and PB6 -> USART1_TX - efiSetPadMode("GPS tx", CONFIGB(gps_tx_pin), PAL_MODE_ALTERNATE(7)); - efiSetPadMode("GPS rx", CONFIGB(gps_rx_pin), PAL_MODE_ALTERNATE(7)); + efiSetPadMode("GPS tx", CONFIG(gps_tx_pin), PAL_MODE_ALTERNATE(7)); + efiSetPadMode("GPS rx", CONFIG(gps_rx_pin), PAL_MODE_ALTERNATE(7)); // todo: add a thread which would save location. If the GPS 5Hz - we should save the location each 200 ms chThdCreateStatic(gpsThreadStack, sizeof(gpsThreadStack), LOWPRIO, (tfunc_t)(void*) GpsThreadEntryPoint, NULL); diff --git a/firmware/hw_layer/ports/kinetis/mpu_util.cpp b/firmware/hw_layer/ports/kinetis/mpu_util.cpp index 78475108f3..1d6052555e 100644 --- a/firmware/hw_layer/ports/kinetis/mpu_util.cpp +++ b/firmware/hw_layer/ports/kinetis/mpu_util.cpp @@ -77,11 +77,11 @@ static int getSpiAf(SPIDriver *driver) { brain_pin_e getMisoPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1misoPin); + return CONFIG(spi1misoPin); case SPI_DEVICE_2: - return CONFIGB(spi2misoPin); + return CONFIG(spi2misoPin); case SPI_DEVICE_3: - return CONFIGB(spi3misoPin); + return CONFIG(spi3misoPin); default: break; } @@ -91,11 +91,11 @@ brain_pin_e getMisoPin(spi_device_e device) { brain_pin_e getMosiPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1mosiPin); + return CONFIG(spi1mosiPin); case SPI_DEVICE_2: - return CONFIGB(spi2mosiPin); + return CONFIG(spi2mosiPin); case SPI_DEVICE_3: - return CONFIGB(spi3mosiPin); + return CONFIG(spi3mosiPin); default: break; } @@ -105,11 +105,11 @@ brain_pin_e getMosiPin(spi_device_e device) { brain_pin_e getSckPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1sckPin); + return CONFIG(spi1sckPin); case SPI_DEVICE_2: - return CONFIGB(spi2sckPin); + return CONFIG(spi2sckPin); case SPI_DEVICE_3: - return CONFIGB(spi3sckPin); + return CONFIG(spi3sckPin); default: break; } diff --git a/firmware/hw_layer/ports/stm32/stm32f4/mpu_util.cpp b/firmware/hw_layer/ports/stm32/stm32f4/mpu_util.cpp index 3585257993..bdb52cc2c9 100644 --- a/firmware/hw_layer/ports/stm32/stm32f4/mpu_util.cpp +++ b/firmware/hw_layer/ports/stm32/stm32f4/mpu_util.cpp @@ -241,11 +241,11 @@ static int getSpiAf(SPIDriver *driver) { brain_pin_e getMisoPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1misoPin); + return CONFIG(spi1misoPin); case SPI_DEVICE_2: - return CONFIGB(spi2misoPin); + return CONFIG(spi2misoPin); case SPI_DEVICE_3: - return CONFIGB(spi3misoPin); + return CONFIG(spi3misoPin); default: break; } @@ -255,11 +255,11 @@ brain_pin_e getMisoPin(spi_device_e device) { brain_pin_e getMosiPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1mosiPin); + return CONFIG(spi1mosiPin); case SPI_DEVICE_2: - return CONFIGB(spi2mosiPin); + return CONFIG(spi2mosiPin); case SPI_DEVICE_3: - return CONFIGB(spi3mosiPin); + return CONFIG(spi3mosiPin); default: break; } @@ -269,11 +269,11 @@ brain_pin_e getMosiPin(spi_device_e device) { brain_pin_e getSckPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1sckPin); + return CONFIG(spi1sckPin); case SPI_DEVICE_2: - return CONFIGB(spi2sckPin); + return CONFIG(spi2sckPin); case SPI_DEVICE_3: - return CONFIGB(spi3sckPin); + return CONFIG(spi3sckPin); default: break; } diff --git a/firmware/hw_layer/ports/stm32/stm32f7/mpu_util.cpp b/firmware/hw_layer/ports/stm32/stm32f7/mpu_util.cpp index bce4e43da2..aa4f9203b9 100644 --- a/firmware/hw_layer/ports/stm32/stm32f7/mpu_util.cpp +++ b/firmware/hw_layer/ports/stm32/stm32f7/mpu_util.cpp @@ -236,11 +236,11 @@ static int getSpiAf(SPIDriver *driver) { brain_pin_e getMisoPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1misoPin); + return CONFIG(spi1misoPin); case SPI_DEVICE_2: - return CONFIGB(spi2misoPin); + return CONFIG(spi2misoPin); case SPI_DEVICE_3: - return CONFIGB(spi3misoPin); + return CONFIG(spi3misoPin); default: break; } @@ -250,11 +250,11 @@ brain_pin_e getMisoPin(spi_device_e device) { brain_pin_e getMosiPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1mosiPin); + return CONFIG(spi1mosiPin); case SPI_DEVICE_2: - return CONFIGB(spi2mosiPin); + return CONFIG(spi2mosiPin); case SPI_DEVICE_3: - return CONFIGB(spi3mosiPin); + return CONFIG(spi3mosiPin); default: break; } @@ -264,11 +264,11 @@ brain_pin_e getMosiPin(spi_device_e device) { brain_pin_e getSckPin(spi_device_e device) { switch(device) { case SPI_DEVICE_1: - return CONFIGB(spi1sckPin); + return CONFIG(spi1sckPin); case SPI_DEVICE_2: - return CONFIGB(spi2sckPin); + return CONFIG(spi2sckPin); case SPI_DEVICE_3: - return CONFIGB(spi3sckPin); + return CONFIG(spi3sckPin); default: break; } diff --git a/firmware/hw_layer/sensors/accelerometer.cpp b/firmware/hw_layer/sensors/accelerometer.cpp index 81e55a508d..51ef8c834c 100644 --- a/firmware/hw_layer/sensors/accelerometer.cpp +++ b/firmware/hw_layer/sensors/accelerometer.cpp @@ -44,12 +44,12 @@ static const SPIConfig accelerometerCfg = { void configureAccelerometerPins(DECLARE_ENGINE_PARAMETER_SIGNATURE) { // engineConfiguration->LIS302DLCsPin = GPIOE_3; // we have a conflict with VVT output on Miata -// CONFIGB(is_enabled_spi_1) = true; // we have a conflict with PA5 input pin +// CONFIG(is_enabled_spi_1) = true; // we have a conflict with PA5 input pin // stm32f4discovery defaults - CONFIGB(spi1mosiPin) = GPIOA_7; - CONFIGB(spi1misoPin) = GPIOA_6; - CONFIGB(spi1sckPin) = GPIOA_5; + CONFIG(spi1mosiPin) = GPIOA_7; + CONFIG(spi1misoPin) = GPIOA_6; + CONFIG(spi1sckPin) = GPIOA_5; } @@ -76,7 +76,7 @@ void initAccelerometer(DECLARE_ENGINE_PARAMETER_SIGNATURE) { if (engineConfiguration->LIS302DLCsPin == GPIO_UNASSIGNED) return; // not used - if (!CONFIGB(is_enabled_spi_1)) + if (!CONFIG(is_enabled_spi_1)) return; // temporary #if HAL_USE_SPI driver = getSpiDevice(engineConfiguration->accelerometerSpiDevice); @@ -90,8 +90,8 @@ void initAccelerometer(DECLARE_ENGINE_PARAMETER_SIGNATURE) { initSpiCs((SPIConfig *)driver->config, engineConfiguration->LIS302DLCsPin); // memsCs.initPin("LIS302 CS", engineConfiguration->LIS302DLCsPin); -// memsCfg.ssport = getHwPort("mmc", CONFIGB(sdCardCsPin)); -// memsCfg.sspad = getHwPin("mmc", CONFIGB(sdCardCsPin)); +// memsCfg.ssport = getHwPort("mmc", CONFIG(sdCardCsPin)); +// memsCfg.sspad = getHwPin("mmc", CONFIG(sdCardCsPin)); /* LIS302DL initialization.*/ diff --git a/firmware/hw_layer/sensors/cj125.cpp b/firmware/hw_layer/sensors/cj125.cpp index d24f6c08d4..226b67d56c 100644 --- a/firmware/hw_layer/sensors/cj125.cpp +++ b/firmware/hw_layer/sensors/cj125.cpp @@ -266,7 +266,7 @@ static void cjCalibrate(void) { } static void cjStart(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - if (!CONFIGB(isCJ125Enabled)) { + if (!CONFIG(isCJ125Enabled)) { scheduleMsg(logger, "cj125 is disabled."); return; } @@ -313,35 +313,35 @@ void CJ125::setError(cj125_error_e errCode DECLARE_ENGINE_PARAMETER_SUFFIX) { // engineConfiguration->spi2SckMode = PAL_STM32_OTYPE_OPENDRAIN; // 4 // engineConfiguration->spi2MosiMode = PAL_STM32_OTYPE_OPENDRAIN; // 4 // engineConfiguration->spi2MisoMode = PAL_STM32_PUDR_PULLUP; // 32 -// CONFIGB(cj125CsPin) = GPIOA_15; +// CONFIG(cj125CsPin) = GPIOA_15; // engineConfiguration->cj125CsPinMode = OM_OPENDRAIN; void cj125defaultPinout(DECLARE_ENGINE_PARAMETER_SIGNATURE) { engineConfiguration->cj125ua = EFI_ADC_13; // PC3 engineConfiguration->cj125ur = EFI_ADC_4; // PA4 - CONFIGB(wboHeaterPin) = GPIOC_13; + CONFIG(wboHeaterPin) = GPIOC_13; - CONFIGB(isCJ125Enabled) = false; + CONFIG(isCJ125Enabled) = false; - CONFIGB(spi2mosiPin) = GPIOB_15; - CONFIGB(spi2misoPin) = GPIOB_14; - CONFIGB(spi2sckPin) = GPIOB_13; + CONFIG(spi2mosiPin) = GPIOB_15; + CONFIG(spi2misoPin) = GPIOB_14; + CONFIG(spi2sckPin) = GPIOB_13; - CONFIGB(cj125CsPin) = GPIOB_0; - CONFIGB(isCJ125Enabled) = true; - CONFIGB(is_enabled_spi_2) = true; + CONFIG(cj125CsPin) = GPIOB_0; + CONFIG(isCJ125Enabled) = true; + CONFIG(is_enabled_spi_2) = true; } static void cjStartSpi(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - globalInstance.cj125Cs.initPin("cj125 CS", CONFIGB(cj125CsPin), + globalInstance.cj125Cs.initPin("cj125 CS", CONFIG(cj125CsPin), &engineConfiguration->cj125CsPinMode); // Idle CS pin - SPI CS is high when idle globalInstance.cj125Cs.setValue(true); cj125spicfg.cr1 += getSpiPrescaler(_150KHz, engineConfiguration->cj125SpiDevice); - cj125spicfg.ssport = getHwPort("cj125", CONFIGB(cj125CsPin)); - cj125spicfg.sspad = getHwPin("cj125", CONFIGB(cj125CsPin)); + cj125spicfg.ssport = getHwPort("cj125", CONFIG(cj125CsPin)); + cj125spicfg.sspad = getHwPin("cj125", CONFIG(cj125CsPin)); driver = getSpiDevice(engineConfiguration->cj125SpiDevice); if (driver == NULL) { // error already reported @@ -463,7 +463,7 @@ static msg_t cjThread(void) #if ! EFI_UNIT_TEST static bool cjCheckConfig(void) { - if (!CONFIGB(isCJ125Enabled)) { + if (!CONFIG(isCJ125Enabled)) { scheduleMsg(logger, "cj125 is disabled. Failed!"); return false; } @@ -518,7 +518,7 @@ float cjGetAfr(DECLARE_ENGINE_PARAMETER_SIGNATURE) { } bool cjHasAfrSensor(DECLARE_ENGINE_PARAMETER_SIGNATURE) { - if (!CONFIGB(isCJ125Enabled)) + if (!CONFIG(isCJ125Enabled)) return false; return globalInstance.isValidState(); } @@ -543,7 +543,7 @@ void initCJ125(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { globalInstance.spi = &spi; globalInstance.logger = sharedLogger; - if (!CONFIGB(isCJ125Enabled)) { + if (!CONFIG(isCJ125Enabled)) { globalInstance.errorCode = CJ125_ERROR_DISABLED; return; } @@ -555,7 +555,7 @@ void initCJ125(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) { return; } - if (CONFIGB(wboHeaterPin) == GPIO_UNASSIGNED) { + if (CONFIG(wboHeaterPin) == GPIO_UNASSIGNED) { scheduleMsg(logger, "cj125 init error! wboHeaterPin is required."); warning(CUSTOM_CJ125_1, "cj heater"); globalInstance.errorCode = CJ125_ERROR_DISABLED; diff --git a/firmware/hw_layer/sensors/cj125_logic.cpp b/firmware/hw_layer/sensors/cj125_logic.cpp index e8b017da1e..3411f815cc 100644 --- a/firmware/hw_layer/sensors/cj125_logic.cpp +++ b/firmware/hw_layer/sensors/cj125_logic.cpp @@ -43,7 +43,7 @@ void CJ125::StartHeaterControl(pwm_gen_callback *stateChangeCallback DECLARE_ENG // todo: use custom pin state method, turn pin off while not running startSimplePwmExt(&wboHeaterControl, "wboHeaterPin", &engine->executor, - CONFIGB(wboHeaterPin), + CONFIG(wboHeaterPin), &wboHeaterPin, CJ125_HEATER_PWM_FREQ, 0.0f, stateChangeCallback); SetIdleHeater(PASS_ENGINE_PARAMETER_SIGNATURE); } diff --git a/firmware/hw_layer/sensors/joystick.cpp b/firmware/hw_layer/sensors/joystick.cpp index 45bee159a8..f6f624de2b 100644 --- a/firmware/hw_layer/sensors/joystick.cpp +++ b/firmware/hw_layer/sensors/joystick.cpp @@ -50,21 +50,21 @@ static void extCallback(ioportmask_t channel) { joyTotal++; joystick_button_e button; // todo: I guess it's time to reduce code duplication and start working with an array - if (channel == getHwPin("joy", CONFIGB(joystickCenterPin))) { + if (channel == getHwPin("joy", CONFIG(joystickCenterPin))) { joyCenter++; button = JB_CENTER; - } else if (channel == getHwPin("joy", CONFIGB(joystickAPin))) { + } else if (channel == getHwPin("joy", CONFIG(joystickAPin))) { joyA++; button = JB_BUTTON_A; /* not used so far - } else if (channel == getHwPin("joy", CONFIGB(joystickBPin))) { + } else if (channel == getHwPin("joy", CONFIG(joystickBPin))) { joyB++; button = JB_BUTTON_B; - } else if (channel == getHwPin("joy", CONFIGB(joystickCPin))) { + } else if (channel == getHwPin("joy", CONFIG(joystickCPin))) { joyC++; button = JB_BUTTON_C; */ - } else if (channel == getHwPin("joy", CONFIGB(joystickDPin))) { + } else if (channel == getHwPin("joy", CONFIG(joystickDPin))) { joyD++; button = JB_BUTTON_D; } else { @@ -80,34 +80,34 @@ static void extCallback(ioportmask_t channel) { static void joystickInfo(void) { scheduleMsg(sharedLogger, "total %d center=%d@%s", joyTotal, joyCenter, - hwPortname(CONFIGB(joystickCenterPin))); - scheduleMsg(sharedLogger, "a=%d@%s", joyA, hwPortname(CONFIGB(joystickAPin))); - scheduleMsg(sharedLogger, "b=%d@%s", joyB, hwPortname(CONFIGB(joystickBPin))); - scheduleMsg(sharedLogger, "c=%d@%s", joyC, hwPortname(CONFIGB(joystickCPin))); - scheduleMsg(sharedLogger, "d=%d@%s", joyD, hwPortname(CONFIGB(joystickDPin))); + hwPortname(CONFIG(joystickCenterPin))); + scheduleMsg(sharedLogger, "a=%d@%s", joyA, hwPortname(CONFIG(joystickAPin))); + scheduleMsg(sharedLogger, "b=%d@%s", joyB, hwPortname(CONFIG(joystickBPin))); + scheduleMsg(sharedLogger, "c=%d@%s", joyC, hwPortname(CONFIG(joystickCPin))); + scheduleMsg(sharedLogger, "d=%d@%s", joyD, hwPortname(CONFIG(joystickDPin))); } static bool isJoystickEnabled() { - return CONFIGB(joystickCenterPin) != GPIO_UNASSIGNED || - CONFIGB(joystickAPin) != GPIO_UNASSIGNED || - // not used so far CONFIGB(joystickBPin) != GPIO_UNASSIGNED || - // not used so far CONFIGB(joystickCPin) != GPIO_UNASSIGNED || - CONFIGB(joystickDPin) != GPIO_UNASSIGNED; + return CONFIG(joystickCenterPin) != GPIO_UNASSIGNED || + CONFIG(joystickAPin) != GPIO_UNASSIGNED || + // not used so far CONFIG(joystickBPin) != GPIO_UNASSIGNED || + // not used so far CONFIG(joystickCPin) != GPIO_UNASSIGNED || + CONFIG(joystickDPin) != GPIO_UNASSIGNED; } void stopJoystickPins() { - brain_pin_markUnused(activeConfiguration.bc.joystickCenterPin); - brain_pin_markUnused(activeConfiguration.bc.joystickAPin); - brain_pin_markUnused(activeConfiguration.bc.joystickDPin); + brain_pin_markUnused(activeConfiguration.joystickCenterPin); + brain_pin_markUnused(activeConfiguration.joystickAPin); + brain_pin_markUnused(activeConfiguration.joystickDPin); } void startJoystickPins() { // todo: extract 'configurePalInputPin() method? - efiSetPadMode("joy center", CONFIGB(joystickCenterPin), PAL_MODE_INPUT_PULLUP); - efiSetPadMode("joy A", CONFIGB(joystickAPin), PAL_MODE_INPUT_PULLUP); - // not used so far efiSetPadMode("joy B", CONFIGB(joystickBPin), PAL_MODE_INPUT_PULLUP); - // not used so far efiSetPadMode("joy C", CONFIGB(joystickCPin), PAL_MODE_INPUT_PULLUP); - efiSetPadMode("joy D", CONFIGB(joystickDPin), PAL_MODE_INPUT_PULLUP); + efiSetPadMode("joy center", CONFIG(joystickCenterPin), PAL_MODE_INPUT_PULLUP); + efiSetPadMode("joy A", CONFIG(joystickAPin), PAL_MODE_INPUT_PULLUP); + // not used so far efiSetPadMode("joy B", CONFIG(joystickBPin), PAL_MODE_INPUT_PULLUP); + // not used so far efiSetPadMode("joy C", CONFIG(joystickCPin), PAL_MODE_INPUT_PULLUP); + efiSetPadMode("joy D", CONFIG(joystickDPin), PAL_MODE_INPUT_PULLUP); } void initJoystick(Logging *shared) { @@ -117,14 +117,14 @@ void initJoystick(Logging *shared) { return; sharedLogger = shared; - channel = getHwPin("joy", CONFIGB(joystickCenterPin)); - efiExtiEnablePin("joy", CONFIGB(joystickCenterPin), PAL_EVENT_MODE_RISING_EDGE, (palcallback_t)(void *)extCallback, (void *)channel); - channel = getHwPin("joy", CONFIGB(joystickAPin)); - efiExtiEnablePin("joy", CONFIGB(joystickAPin), PAL_EVENT_MODE_RISING_EDGE, (palcallback_t)(void *)extCallback, (void *)channel); -// not used so far applyPin(CONFIGB(joystickBPin)); -// not used so far applyPin(CONFIGB(joystickCPin)); - channel = getHwPin("joy", CONFIGB(joystickDPin)); - efiExtiEnablePin("joy", CONFIGB(joystickDPin), PAL_EVENT_MODE_RISING_EDGE, (palcallback_t)(void *)extCallback, (void *)channel); + channel = getHwPin("joy", CONFIG(joystickCenterPin)); + efiExtiEnablePin("joy", CONFIG(joystickCenterPin), PAL_EVENT_MODE_RISING_EDGE, (palcallback_t)(void *)extCallback, (void *)channel); + channel = getHwPin("joy", CONFIG(joystickAPin)); + efiExtiEnablePin("joy", CONFIG(joystickAPin), PAL_EVENT_MODE_RISING_EDGE, (palcallback_t)(void *)extCallback, (void *)channel); +// not used so far applyPin(CONFIG(joystickBPin)); +// not used so far applyPin(CONFIG(joystickCPin)); + channel = getHwPin("joy", CONFIG(joystickDPin)); + efiExtiEnablePin("joy", CONFIG(joystickDPin), PAL_EVENT_MODE_RISING_EDGE, (palcallback_t)(void *)extCallback, (void *)channel); startJoystickPins(); } diff --git a/firmware/hw_layer/smart_gpio.cpp b/firmware/hw_layer/smart_gpio.cpp index 40c5c97053..26ab59f0c4 100644 --- a/firmware/hw_layer/smart_gpio.cpp +++ b/firmware/hw_layer/smart_gpio.cpp @@ -156,10 +156,10 @@ void initSmartGpio() { gpiochip_use_gpio_base(TLE6240_OUTPUTS); #if (BOARD_MC33972_COUNT > 0) - if (boardConfiguration->mc33972_cs != GPIO_UNASSIGNED) { + if (engineConfiguration->mc33972_cs != GPIO_UNASSIGNED) { // todo: reuse initSpiCs method? - mc33972.spi_config.ssport = getHwPort("mc33972 CS", boardConfiguration->mc33972_cs); - mc33972.spi_config.sspad = getHwPin("mc33972 CS", boardConfiguration->mc33972_cs); + mc33972.spi_config.ssport = getHwPort("mc33972 CS", engineConfiguration->mc33972_cs); + mc33972.spi_config.sspad = getHwPin("mc33972 CS", engineConfiguration->mc33972_cs); mc33972.spi_bus = getSpiDevice(engineConfiguration->mc33972spiDevice); // todo: propogate 'basePinOffset' parameter ret = mc33972_add(0, &mc33972); @@ -209,7 +209,7 @@ void stopSmartCsPins() { brain_pin_markUnused(activeConfiguration.tle6240_cs); #endif /* BOARD_TLE6240_COUNT */ #if (BOARD_MC33972_COUNT > 0) - brain_pin_markUnused(activeConfiguration.bc.mc33972_cs); + brain_pin_markUnused(activeConfiguration.mc33972_cs); #endif /* BOARD_MC33972_COUNT */ } @@ -225,8 +225,8 @@ void startSmartCsPins() { tle6240Cs.setValue(true); #endif /* BOARD_TLE6240_COUNT */ #if (BOARD_MC33972_COUNT > 0) - mc33972Cs.initPin("mc33972 CS", boardConfiguration->mc33972_cs, - &boardConfiguration->mc33972_csPinMode); + mc33972Cs.initPin("mc33972 CS", engineConfiguration->mc33972_cs, + &engineConfiguration->mc33972_csPinMode); mc33972Cs.setValue(true); #endif /* BOARD_MC33972_COUNT */ } diff --git a/firmware/hw_layer/stepper.cpp b/firmware/hw_layer/stepper.cpp index 663804a243..58ddb11103 100644 --- a/firmware/hw_layer/stepper.cpp +++ b/firmware/hw_layer/stepper.cpp @@ -53,7 +53,7 @@ static msg_t stThread(StepperMotor *motor) { #endif /* EFI_SHAFT_POSITION_INPUT */ // now check if stepper motor re-initialization is requested - if the throttle pedal is pressed at startup bool forceStepperParking = !isRunning && getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) > STEPPER_PARKING_TPS; - if (CONFIGB(stepperForceParkingEveryRestart)) + if (CONFIG(stepperForceParkingEveryRestart)) forceStepperParking = true; scheduleMsg(logger, "Stepper: savedStepperPos=%d forceStepperParking=%d (tps=%.2f)", motor->currentPosition, (forceStepperParking ? 1 : 0), getTPS(PASS_ENGINE_PARAMETER_SIGNATURE)); @@ -69,7 +69,7 @@ static msg_t stThread(StepperMotor *motor) { * * Add extra steps to compensate step skipping by some old motors. */ - int numParkingSteps = (int)efiRound((1.0f + (float)CONFIGB(stepperParkingExtraSteps) / PERCENT_MULT) * motor->totalSteps, 1.0f); + int numParkingSteps = (int)efiRound((1.0f + (float)CONFIG(stepperParkingExtraSteps) / PERCENT_MULT) * motor->totalSteps, 1.0f); for (int i = 0; i < numParkingSteps; i++) { motor->pulse(); } diff --git a/firmware/hw_layer/trigger_input.cpp b/firmware/hw_layer/trigger_input.cpp index 3bf42ff9e2..476d7b9b1e 100644 --- a/firmware/hw_layer/trigger_input.cpp +++ b/firmware/hw_layer/trigger_input.cpp @@ -15,8 +15,8 @@ EXTERN_ENGINE; #if (HAL_USE_ICU == TRUE) || (HAL_TRIGGER_USE_PAL == TRUE) void stopTriggerInputPins(void) { for (int i = 0; i < TRIGGER_SUPPORTED_CHANNELS; i++) { - if (isConfigurationChanged(bc.triggerInputPins[i])) { - turnOffTriggerInputPin(activeConfiguration.bc.triggerInputPins[i]); + if (isConfigurationChanged(triggerInputPins[i])) { + turnOffTriggerInputPin(activeConfiguration.triggerInputPins[i]); } } for (int i = 0; i < CAM_INPUTS_COUNT; i++) { @@ -28,7 +28,7 @@ void stopTriggerInputPins(void) { void startTriggerInputPins(void) { for (int i = 0; i < TRIGGER_SUPPORTED_CHANNELS; i++) { - if (isConfigurationChanged(bc.triggerInputPins[i])) { + if (isConfigurationChanged(triggerInputPins[i])) { const char * msg = (i == 0 ? "trigger#1" : (i == 1 ? "trigger#2" : "trigger#3")); turnOnTriggerInputPin(msg, i, true); } @@ -40,7 +40,7 @@ void startTriggerInputPins(void) { } } - setPrimaryChannel(CONFIGB(triggerInputPins)[0]); + setPrimaryChannel(CONFIG(triggerInputPins)[0]); } #endif diff --git a/firmware/hw_layer/trigger_input_exti.cpp b/firmware/hw_layer/trigger_input_exti.cpp index ac136bbdf1..9fd75b6289 100644 --- a/firmware/hw_layer/trigger_input_exti.cpp +++ b/firmware/hw_layer/trigger_input_exti.cpp @@ -65,7 +65,7 @@ static void cam_callback(void *arg) { } void turnOnTriggerInputPin(const char *msg, int index, bool isTriggerShaft) { - brain_pin_e brainPin = isTriggerShaft ? CONFIGB(triggerInputPins)[index] : engineConfiguration->camInputs[index]; + brain_pin_e brainPin = isTriggerShaft ? CONFIG(triggerInputPins)[index] : engineConfiguration->camInputs[index]; scheduleMsg(logger, "turnOnTriggerInputPin(PAL) %s %s", msg, hwPortname(brainPin)); diff --git a/firmware/hw_layer/trigger_input_icu.cpp b/firmware/hw_layer/trigger_input_icu.cpp index f3f0eb2260..50a601694a 100644 --- a/firmware/hw_layer/trigger_input_icu.cpp +++ b/firmware/hw_layer/trigger_input_icu.cpp @@ -81,7 +81,7 @@ static void shaftPeriodCallback(bool isPrimary) { void turnOnTriggerInputPin(const char *msg, int index, bool isTriggerShaft) { (void)msg; - brain_pin_e brainPin = isTriggerShaft ? CONFIGB(triggerInputPins)[index] : engineConfiguration->camInputs[index]; + brain_pin_e brainPin = isTriggerShaft ? CONFIG(triggerInputPins)[index] : engineConfiguration->camInputs[index]; if (brainPin == GPIO_UNASSIGNED) { return; } diff --git a/firmware/integration/rusefi_config.txt b/firmware/integration/rusefi_config.txt index f94af55680..14efdc4bdf 100644 --- a/firmware/integration/rusefi_config.txt +++ b/firmware/integration/rusefi_config.txt @@ -508,7 +508,6 @@ struct etb_io pin_output_mode_e controlPinMode; end_struct -struct_no_prefix board_configuration_s idle_hardware_s idle; float manIdlePosition;value between 0 and 100 used in Manual mode;"%", 1, 0, 0, 100, 0 @@ -712,10 +711,7 @@ custom maf_sensor_type_e 4 bits, S32, @OFFSET@, [0:7], @@maf_sensor_type_e_enum@ ! todo: keep moving all these fields at the end of board_configuration_s below 'board_configuration_s bc' ! end of board_configuration_s -end_struct - -board_configuration_s bc; maf_sensor_type_e mafSensorType; custom le_formula_t 200 string, ASCII, @OFFSET@, 200 diff --git a/firmware/rusefi.cpp b/firmware/rusefi.cpp index 04399d7aa9..15b493319f 100644 --- a/firmware/rusefi.cpp +++ b/firmware/rusefi.cpp @@ -244,7 +244,7 @@ void runRusEfi(void) { updateDevConsoleState(); #endif /* EFI_CLI_SUPPORT */ - chThdSleepMilliseconds(CONFIGB(consoleLoopPeriodMs)); + chThdSleepMilliseconds(CONFIG(consoleLoopPeriodMs)); } } diff --git a/java_console/models/src/com/rusefi/config/generated/Fields.java b/java_console/models/src/com/rusefi/config/generated/Fields.java index 793263ad05..be3dc072e7 100644 --- a/java_console/models/src/com/rusefi/config/generated/Fields.java +++ b/java_console/models/src/com/rusefi/config/generated/Fields.java @@ -1,6 +1,6 @@ package com.rusefi.config.generated; -// this file was generated automatically by rusEfi tool ConfigDefinition.jar based on integration\rusefi_config.txt Sun Dec 08 00:20:37 EST 2019 +// this file was generated automatically by rusEfi tool ConfigDefinition.jar based on integration\rusefi_config.txt Wed Dec 11 16:40:57 EST 2019 // by class com.rusefi.output.FileJavaFieldsConsumer import com.rusefi.config.*; @@ -152,8 +152,6 @@ public class Fields { public static final int baroSensor_offset_hex = 248; public static final int baroSensor_type_offset = 592; public static final int baroSensor_type_offset_hex = 250; - public static final int bc_offset = 600; - public static final int bc_offset_hex = 258; public static final int binarySerialRxPin_offset = 1815; public static final int binarySerialRxPin_offset_hex = 717; public static final int binarySerialTxPin_offset = 1814; diff --git a/unit_tests/engine_test_helper.cpp b/unit_tests/engine_test_helper.cpp index ae3e57da27..038fc0c065 100644 --- a/unit_tests/engine_test_helper.cpp +++ b/unit_tests/engine_test_helper.cpp @@ -41,7 +41,6 @@ EngineTestHelper::EngineTestHelper(engine_type_e engineType, configuration_callb Engine *engine = &this->engine; engine->setConfig(config); engine_configuration_s *engineConfiguration = engine->engineConfigurationPtr; - board_configuration_s * boardConfiguration = &persistentConfig.engineConfiguration.bc; setCurveValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -40, 1.5); setCurveValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -30, 1.5); @@ -95,8 +94,7 @@ void EngineTestHelper::fireRise(float delayMs) { * fire single RISE front event */ void EngineTestHelper::firePrimaryTriggerRise() { - board_configuration_s * boardConfiguration = &engine.engineConfigurationPtr->bc; - engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING, &engine, engine.engineConfigurationPtr, &persistentConfig, boardConfiguration); + engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING, &engine, engine.engineConfigurationPtr, &persistentConfig); } void EngineTestHelper::fireFall(float delayMs) { @@ -105,8 +103,7 @@ void EngineTestHelper::fireFall(float delayMs) { } void EngineTestHelper::firePrimaryTriggerFall() { - board_configuration_s * boardConfiguration = &engine.engineConfigurationPtr->bc; - engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING, &engine, engine.engineConfigurationPtr, &persistentConfig, boardConfiguration); + engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING, &engine, engine.engineConfigurationPtr, &persistentConfig); } void EngineTestHelper::fireTriggerEventsWithDuration(float durationMs) { diff --git a/unit_tests/globalaccess.h b/unit_tests/globalaccess.h index 03171a25c8..82ba659ac6 100644 --- a/unit_tests/globalaccess.h +++ b/unit_tests/globalaccess.h @@ -9,9 +9,9 @@ #include "global.h" -#define DECLARE_CONFIG_PARAMETER_SIGNATURE engine_configuration_s *engineConfiguration, persistent_config_s *config, board_configuration_s *boardConfiguration +#define DECLARE_CONFIG_PARAMETER_SIGNATURE engine_configuration_s *engineConfiguration, persistent_config_s *config #define DECLARE_CONFIG_PARAMETER_SUFFIX , DECLARE_CONFIG_PARAMETER_SIGNATURE -#define PASS_CONFIG_PARAMETER_SIGNATURE engineConfiguration, config, boardConfiguration +#define PASS_CONFIG_PARAMETER_SIGNATURE engineConfiguration, config #define PASS_CONFIG_PARAMETER_SUFFIX , PASS_CONFIG_PARAMETER_SIGNATURE /** @@ -23,7 +23,4 @@ #define PASS_ENGINE_PARAMETER_SUFFIX , PASS_ENGINE_PARAMETER_SIGNATURE #define CONFIG(x) engineConfiguration->x -// todo: fix this! this does not work because of 'prepareVoidConfiguration(&activeConfiguration);' -//#define CONFIGB(x) engine->engineConfigurationPtr->bc.x -#define CONFIGB(x) CONFIG(bc.x) #define ENGINE(x) engine->x diff --git a/unit_tests/tests/test_fasterEngineSpinningUp.cpp b/unit_tests/tests/test_fasterEngineSpinningUp.cpp index fc92e1928d..1ee97d9926 100644 --- a/unit_tests/tests/test_fasterEngineSpinningUp.cpp +++ b/unit_tests/tests/test_fasterEngineSpinningUp.cpp @@ -12,7 +12,7 @@ TEST(cranking, testFasterEngineSpinningUp) { WITH_ENGINE_TEST_HELPER(TEST_ENGINE); // turn on FasterEngineSpinUp mode - engineConfiguration->bc.isFasterEngineSpinUpEnabled = true; + engineConfiguration->isFasterEngineSpinUpEnabled = true; // set ignition mode engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; @@ -100,7 +100,7 @@ TEST(cranking, testFasterEngineSpinningUp) { static void doTestFasterEngineSpinningUp60_2(int startUpDelayMs, int rpm1, int expectedRpm) { WITH_ENGINE_TEST_HELPER(TEST_ENGINE); // turn on FasterEngineSpinUp mode - engineConfiguration->bc.isFasterEngineSpinUpEnabled = true; + engineConfiguration->isFasterEngineSpinUpEnabled = true; setupSimpleTestEngineWithMaf(ð, IM_SEQUENTIAL, TT_TOOTHED_WHEEL_60_2); eth.moveTimeForwardMs(startUpDelayMs); diff --git a/unit_tests/tests/test_fuelCut.cpp b/unit_tests/tests/test_fuelCut.cpp index aac2da0cfa..20b0040c35 100644 --- a/unit_tests/tests/test_fuelCut.cpp +++ b/unit_tests/tests/test_fuelCut.cpp @@ -17,7 +17,7 @@ TEST(fuelCut, coasting) { WITH_ENGINE_TEST_HELPER(TEST_ENGINE); // configure coastingFuelCut - engineConfiguration->bc.coastingFuelCutEnabled = true; + engineConfiguration->coastingFuelCutEnabled = true; engineConfiguration->coastingFuelCutRpmLow = 1300; engineConfiguration->coastingFuelCutRpmHigh = 1500; engineConfiguration->coastingFuelCutTps = 2; diff --git a/unit_tests/tests/test_fuel_map.cpp b/unit_tests/tests/test_fuel_map.cpp index 4360bc4d5f..32d8617fdf 100644 --- a/unit_tests/tests/test_fuel_map.cpp +++ b/unit_tests/tests/test_fuel_map.cpp @@ -227,7 +227,7 @@ TEST(fuel, testTpsBasedVeDefect799) { WITH_ENGINE_TEST_HELPER(FORD_ASPIRE_1996); engineConfiguration->fuelAlgorithm = LM_SPEED_DENSITY; - CONFIGB(useTPSBasedVeTable) = true; + CONFIG(useTPSBasedVeTable) = true; int mapFrom = 100; // set MAP axis range diff --git a/unit_tests/tests/test_idle_controller.cpp b/unit_tests/tests/test_idle_controller.cpp index 69b0a23b38..c9e548ed21 100644 --- a/unit_tests/tests/test_idle_controller.cpp +++ b/unit_tests/tests/test_idle_controller.cpp @@ -82,7 +82,7 @@ TEST(idle, timingPid) { // configure TPS engineConfiguration->tpsMin = 0; engineConfiguration->tpsMax = 100; - engineConfiguration->bc.idlePidDeactivationTpsThreshold = 10; + engineConfiguration->idlePidDeactivationTpsThreshold = 10; setMockTpsAdc(0 PASS_ENGINE_PARAMETER_SUFFIX); // disable temperature sensors @@ -90,12 +90,12 @@ TEST(idle, timingPid) { eth.engine.sensors.iat = NAN; // all corrections disabled, should be 0 - engineConfiguration->bc.useIdleTimingPidControl = false; + engineConfiguration->useIdleTimingPidControl = false; angle_t corr = getAdvanceCorrections(idleRpmTarget PASS_ENGINE_PARAMETER_SUFFIX); ASSERT_EQ(0, corr) << "getAdvanceCorrections#1"; // basic IDLE PID correction test - engineConfiguration->bc.useIdleTimingPidControl = true; + engineConfiguration->useIdleTimingPidControl = true; int baseTestRpm = idleRpmTarget + engineConfiguration->idleTimingPidWorkZone; corr = getAdvanceCorrections(baseTestRpm PASS_ENGINE_PARAMETER_SUFFIX); // (delta_rpm=-100) * (p-factor=0.1) = -10 degrees @@ -117,12 +117,12 @@ TEST(idle, timingPid) { ASSERT_FLOAT_EQ(-5.75f, corr) << "getAdvanceCorrections#5"; // check if PID correction is disabled in running mode (tps > threshold): - setMockTpsAdc(engineConfiguration->bc.idlePidDeactivationTpsThreshold + 1 PASS_ENGINE_PARAMETER_SUFFIX); + setMockTpsAdc(engineConfiguration->idlePidDeactivationTpsThreshold + 1 PASS_ENGINE_PARAMETER_SUFFIX); corr = getAdvanceCorrections(idleRpmTarget PASS_ENGINE_PARAMETER_SUFFIX); ASSERT_EQ(0, corr) << "getAdvanceCorrections#6"; // check if PID correction is interpolated for transient idle-running TPS positions - setMockTpsAdc(engineConfiguration->bc.idlePidDeactivationTpsThreshold / 2 PASS_ENGINE_PARAMETER_SUFFIX); + setMockTpsAdc(engineConfiguration->idlePidDeactivationTpsThreshold / 2 PASS_ENGINE_PARAMETER_SUFFIX); corr = getAdvanceCorrections(baseTestRpm PASS_ENGINE_PARAMETER_SUFFIX); ASSERT_FLOAT_EQ(-5.0f, corr) << "getAdvanceCorrections#7"; diff --git a/unit_tests/tests/test_miata_na6_real_cranking.cpp b/unit_tests/tests/test_miata_na6_real_cranking.cpp index dc799e57aa..cc47a4252e 100644 --- a/unit_tests/tests/test_miata_na6_real_cranking.cpp +++ b/unit_tests/tests/test_miata_na6_real_cranking.cpp @@ -29,7 +29,7 @@ static void fireTriggerEvent(EngineTestHelper*eth, double timestampS, int channe EXPAND_Engine; timeNowUs = 1000000 * timestampS; printf("MIATANA: posting time=%d event=%d\r\n", timeNowUs, event); - engine->triggerCentral.handleShaftSignal(event, engine, engine->engineConfigurationPtr, ð->persistentConfig, boardConfiguration); + engine->triggerCentral.handleShaftSignal(event, engine, engine->engineConfigurationPtr, ð->persistentConfig); } TEST(miataNA6, realCranking) { diff --git a/unit_tests/tests/test_trigger_decoder.cpp b/unit_tests/tests/test_trigger_decoder.cpp index 7908947e6c..a18fa20b2f 100644 --- a/unit_tests/tests/test_trigger_decoder.cpp +++ b/unit_tests/tests/test_trigger_decoder.cpp @@ -455,7 +455,6 @@ TEST(misc, testTriggerDecoder) { Engine *engine = &e; engine_configuration_s *engineConfiguration = &c.engineConfiguration; - board_configuration_s *boardConfiguration = &c.engineConfiguration.bc; initializeSkippedToothTriggerWaveformExt(s, 2, 0, FOUR_STROKE_CAM_SENSOR); assertEqualsM("shape size", s->getSize(), 4); @@ -528,7 +527,7 @@ TEST(misc, testTriggerDecoder) { eth.persistentConfig.engineConfiguration.useOnlyRisingEdgeForTrigger = false; - eth.persistentConfig.engineConfiguration.bc.sensorChartMode = SC_DETAILED_RPM; + eth.persistentConfig.engineConfiguration.sensorChartMode = SC_DETAILED_RPM; applyNonPersistentConfiguration(NULL PASS_ENGINE_PARAMETER_SUFFIX); // assertEqualsM2("rpm#1", 16666.9746, eth.engine.triggerCentral.triggerState.instantRpmValue[0], 0.5); diff --git a/unit_tests/tests/test_trigger_noiseless.cpp b/unit_tests/tests/test_trigger_noiseless.cpp index 285394492b..8b5df27e3c 100644 --- a/unit_tests/tests/test_trigger_noiseless.cpp +++ b/unit_tests/tests/test_trigger_noiseless.cpp @@ -29,7 +29,7 @@ static void fireEvent(EngineTestHelper *eth, bool isRise) { // but for noise filtering, both edges should be processed, so we fire falling events too if (isRise) eth->firePrimaryTriggerRise(); - else if (eth->engine.engineConfigurationPtr->bc.useNoiselessTriggerDecoder) + else if (eth->engine.engineConfigurationPtr->useNoiselessTriggerDecoder) eth->firePrimaryTriggerFall(); } @@ -92,7 +92,7 @@ static void resetTrigger(EngineTestHelper ð) { static void testNoiselessDecoderProcedure(EngineTestHelper ð, int errorToleranceCnt DECLARE_ENGINE_PARAMETER_SUFFIX) { printf("*** (bc->useNoiselessTriggerDecoder = %s)\r\n", - CONFIGB(useNoiselessTriggerDecoder) ? "true" : "false"); + CONFIG(useNoiselessTriggerDecoder) ? "true" : "false"); resetTrigger(eth); @@ -183,13 +183,13 @@ TEST(big, testNoiselessDecoder) { #if 0 // try normal trigger mode, no noise filtering - CONFIGB(useNoiselessTriggerDecoder) = false; + CONFIG(useNoiselessTriggerDecoder) = false; // for test validation, it should be 1 trigger error testNoiselessDecoderProcedure(eth, 1 PASS_ENGINE_PARAMETER_SUFFIX); #endif // now enable our noise filtering algo - CONFIGB(useNoiselessTriggerDecoder) = true; + CONFIG(useNoiselessTriggerDecoder) = true; // should be 0 errors! testNoiselessDecoderProcedure(eth, 0 PASS_ENGINE_PARAMETER_SUFFIX);