andreika-git
/
rusefi
mirror of https://github.com/andreika-git/rusefi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

better macro name

This commit is contained in:
rusefi 2017-05-15 23:28:49 -04:00
parent a7a1664b07
commit 2a9f3cdede
73 changed files with 1593 additions and 1593 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
firmware/config/engines/GY6_139QMB.cpp
View File

@ -64,21 +64,21 @@ static const fuel_table_t default_139qmb_fuel_table = {
}; };
static void setDefault139qmbMaps(DECLARE_ENGINE_PARAMETER_F) { static void setDefault139qmbMaps(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setFuelRpmBin(1000, 11000 PASS_ENGINE_PARAMETER); setFuelRpmBin(1000, 11000 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setTimingLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingRpmBin(1000, 11000 PASS_ENGINE_PARAMETER); setTimingRpmBin(1000, 11000 PASS_ENGINE_PARAMETER_SUFFIX);
copyFuelTable(default_139qmb_fuel_table, config->fuelTable); copyFuelTable(default_139qmb_fuel_table, config->fuelTable);
//copyTimingTable(default_139qmb_timing_table, config->ignitionTable); //copyTimingTable(default_139qmb_timing_table, config->ignitionTable);
} }
void setGy6139qmbDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setGy6139qmbDefaultEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setDefault139qmbMaps(PASS_ENGINE_PARAMETER_F); setDefault139qmbMaps(PASS_ENGINE_PARAMETER_SIGNATURE);
// engineConfiguration->map.sensor.type = MT_3V_SENSOR; // engineConfiguration->map.sensor.type = MT_3V_SENSOR;
setEgoSensor(ES_NarrowBand PASS_ENGINE_PARAMETER); setEgoSensor(ES_NarrowBand PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->rpmHardLimit = 9000; engineConfiguration->rpmHardLimit = 9000;
engineConfiguration->cranking.rpm = 1100; engineConfiguration->cranking.rpm = 1100;

10
firmware/config/engines/bmw_e34.cpp
View File

@ -19,7 +19,7 @@
EXTERN_ENGINE EXTERN_ENGINE
; ;
void setBmwE34(DECLARE_ENGINE_PARAMETER_F) { void setBmwE34(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
// chartsize 450 // chartsize 450
engineConfiguration->engineChartSize = 450; engineConfiguration->engineChartSize = 450;
@ -52,14 +52,14 @@ void setBmwE34(DECLARE_ENGINE_PARAMETER_F) {
// Injection settings // Injection settings
setInjectorLag(1.15 PASS_ENGINE_PARAMETER); setInjectorLag(1.15 PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->injector.flow = 750; engineConfiguration->injector.flow = 750;
// General settings // General settings
boardConfiguration->tunerStudioSerialSpeed = 57600; boardConfiguration->tunerStudioSerialSpeed = 57600;
engineConfiguration->rpmHardLimit = 7000; engineConfiguration->rpmHardLimit = 7000;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
// for best performance at high RPM, we need to turn off 'Engine Sniffer' and 'Sensor Sniffer' // for best performance at high RPM, we need to turn off 'Engine Sniffer' and 'Sensor Sniffer'
boardConfiguration->sensorChartMode = SC_OFF; boardConfiguration->sensorChartMode = SC_OFF;
@ -69,7 +69,7 @@ void setBmwE34(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->isInjectionEnabled = true; engineConfiguration->isInjectionEnabled = true;
engineConfiguration->isIgnitionEnabled = true; engineConfiguration->isIgnitionEnabled = true;
setConstantDwell(3 PASS_ENGINE_PARAMETER); // a bit shorter dwell setConstantDwell(3 PASS_ENGINE_PARAMETER_SUFFIX); // a bit shorter dwell
engineConfiguration->ignMathCalculateAtIndex = 14; engineConfiguration->ignMathCalculateAtIndex = 14;
engineConfiguration->mapAveragingSchedulingAtIndex = 6; engineConfiguration->mapAveragingSchedulingAtIndex = 6;
@ -93,7 +93,7 @@ void setBmwE34(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->triggerInputPins[0] = GPIOA_5; boardConfiguration->triggerInputPins[0] = GPIOA_5;
boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED;
setWholeTimingTable(25 PASS_ENGINE_PARAMETER); setWholeTimingTable(25 PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED;

4
firmware/config/engines/chevrolet_c20_1973.cpp
View File

@ -18,7 +18,7 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void set1973c20(DECLARE_ENGINE_PARAMETER_F) { void set1973c20(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->specs.displacement = 5.7; engineConfiguration->specs.displacement = 5.7;
engineConfiguration->specs.cylindersCount = 8; engineConfiguration->specs.cylindersCount = 8;
@ -38,7 +38,7 @@ void set1973c20(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->trigger.customSkippedToothCount = 0; engineConfiguration->trigger.customSkippedToothCount = 0;
engineConfiguration->rpmHardLimit = 5000; engineConfiguration->rpmHardLimit = 5000;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
} }

6
firmware/config/engines/chevrolet_camaro_4.cpp
View File

@ -16,11 +16,11 @@
EXTERN_ENGINE EXTERN_ENGINE
; ;
void setCamaro4(DECLARE_ENGINE_PARAMETER_F) { void setCamaro4(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->specs.displacement = 5.7; engineConfiguration->specs.displacement = 5.7;
engineConfiguration->specs.cylindersCount = 8; engineConfiguration->specs.cylindersCount = 8;

10
firmware/config/engines/citroenBerlingoTU3JP.cpp
View File

@ -69,7 +69,7 @@ static const ignition_table_t tps_advance_table = {
EXTERN_ENGINE; EXTERN_ENGINE;
void setCitroenBerlingoTU3JPConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setCitroenBerlingoTU3JPConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->engineType = CITROEN_TU3JP; engineConfiguration->engineType = CITROEN_TU3JP;
/** /**
@ -98,10 +98,10 @@ void setCitroenBerlingoTU3JPConfiguration(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* Algorithm Alpha-N setting * Algorithm Alpha-N setting
*/ */
setAlgorithm(LM_ALPHA_N PASS_ENGINE_PARAMETER); setAlgorithm(LM_ALPHA_N PASS_ENGINE_PARAMETER_SUFFIX);
setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER); setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER_SUFFIX);
setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* Outputs * Outputs

8
firmware/config/engines/custom_engine.cpp
View File

@ -41,7 +41,7 @@ void disableLCD(board_configuration_s *boardConfiguration) {
// todo: should this be renamed to 'setFrankensoConfiguration'? // todo: should this be renamed to 'setFrankensoConfiguration'?
// todo: should this be part of more default configurations? // todo: should this be part of more default configurations?
void setCustomEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setCustomEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->trigger.type = TT_ONE_PLUS_ONE; engineConfiguration->trigger.type = TT_ONE_PLUS_ONE;
setFrankenso_01_LCD(boardConfiguration); setFrankenso_01_LCD(boardConfiguration);
@ -103,7 +103,7 @@ void setCustomEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->injectionPins[2] = GPIOB_8; // #3 boardConfiguration->injectionPins[2] = GPIOB_8; // #3
boardConfiguration->injectionPins[3] = GPIOB_7; // #4 boardConfiguration->injectionPins[3] = GPIOB_7; // #4
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
#if EFI_PWM_TESTER #if EFI_PWM_TESTER
boardConfiguration->injectionPins[4] = GPIOC_8; // #5 boardConfiguration->injectionPins[4] = GPIOC_8; // #5
@ -146,8 +146,8 @@ void setCustomEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
#endif #endif
} }
void setFrankensoBoardTestConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setFrankensoBoardTestConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->specs.cylindersCount = 12; engineConfiguration->specs.cylindersCount = 12;
engineConfiguration->specs.firingOrder = FO_1_7_5_11_3_9_6_12_2_8_4_10; engineConfiguration->specs.firingOrder = FO_1_7_5_11_3_9_6_12_2_8_4_10;

26
firmware/config/engines/dodge_neon.cpp
View File

@ -145,7 +145,7 @@ static const fuel_table_t veDodgeNeon2003Table = {
EXTERN_ENGINE; EXTERN_ENGINE;
void setDodgeNeon1995EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setDodgeNeon1995EngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->trigger.type = TT_DODGE_NEON_1995; engineConfiguration->trigger.type = TT_DODGE_NEON_1995;
engineConfiguration->fuelAlgorithm = LM_ALPHA_N; engineConfiguration->fuelAlgorithm = LM_ALPHA_N;
@ -177,8 +177,8 @@ void setDodgeNeon1995EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
*/ */
// set_whole_fuel_map 9 // set_whole_fuel_map 9
setWholeFuelMap(9 PASS_ENGINE_PARAMETER); setWholeFuelMap(9 PASS_ENGINE_PARAMETER_SUFFIX);
setWholeTimingTable(12 PASS_ENGINE_PARAMETER); setWholeTimingTable(12 PASS_ENGINE_PARAMETER_SUFFIX);
// set cranking_injection_mode 0 // set cranking_injection_mode 0
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS; engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
@ -252,7 +252,7 @@ void setDodgeNeon1995EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->sensorChartFrequency = 7; engineConfiguration->sensorChartFrequency = 7;
} }
void setDodgeNeonNGCEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setDodgeNeonNGCEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->trigger.type = TT_DODGE_NEON_2003_CAM; engineConfiguration->trigger.type = TT_DODGE_NEON_2003_CAM;
setFrankenso_01_LCD(boardConfiguration); setFrankenso_01_LCD(boardConfiguration);
setFrankenso0_1_joystick(engineConfiguration); setFrankenso0_1_joystick(engineConfiguration);
@ -297,9 +297,9 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
* *
* set_whole_fuel_map 12 * set_whole_fuel_map 12
*/ */
//setWholeFuelMap(12 PASS_ENGINE_PARAMETER); //setWholeFuelMap(12 PASS_ENGINE_PARAMETER_SUFFIX);
// copyFuelTable(alphaNfuel, config->fuelTable); // copyFuelTable(alphaNfuel, config->fuelTable);
//setWholeTimingTable(12 PASS_ENGINE_PARAMETER); //setWholeTimingTable(12 PASS_ENGINE_PARAMETER_SUFFIX);
copyTimingTable(fromODB, config->ignitionTable); copyTimingTable(fromODB, config->ignitionTable);
copy2DTable<FSIO_TABLE_8, FSIO_TABLE_8, float>(vBattTarget, config->fsioTable1); copy2DTable<FSIO_TABLE_8, FSIO_TABLE_8, float>(vBattTarget, config->fsioTable1);
@ -321,12 +321,12 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
//engineConfiguration->fuelAlgorithm = LM_ALPHA_N; // I want to start with a simple Alpha-N //engineConfiguration->fuelAlgorithm = LM_ALPHA_N; // I want to start with a simple Alpha-N
setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER); setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER_SUFFIX);
setTableBin2(config->ignitionLoadBins, IGN_LOAD_COUNT, 20, 120, 1); setTableBin2(config->ignitionLoadBins, IGN_LOAD_COUNT, 20, 120, 1);
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
setFuelTablesLoadBin(20, 120 PASS_ENGINE_PARAMETER); setFuelTablesLoadBin(20, 120 PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED; boardConfiguration->malfunctionIndicatorPin = GPIO_UNASSIGNED;
@ -468,7 +468,7 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
// * set_fsio_setting 1 0.55 // * set_fsio_setting 1 0.55
// */ // */
// boardConfiguration->fsio_setting[0] = 0.55; // boardConfiguration->fsio_setting[0] = 0.55;
// setFsioExt(0, GPIOE_5, "0 fsio_setting", 400 PASS_ENGINE_PARAMETER); // setFsioExt(0, GPIOE_5, "0 fsio_setting", 400 PASS_ENGINE_PARAMETER_SUFFIX);
#endif #endif
boardConfiguration->vehicleSpeedSensorInputPin = GPIOA_8; boardConfiguration->vehicleSpeedSensorInputPin = GPIOA_8;
@ -480,7 +480,7 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
// boardConfiguration->tunerStudioSerialSpeed = 9600; // boardConfiguration->tunerStudioSerialSpeed = 9600;
boardConfiguration->tunerStudioSerialSpeed = 19200; boardConfiguration->tunerStudioSerialSpeed = 19200;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
//temp boardConfiguration->alternatorControlPin = GPIOD_5; //temp boardConfiguration->alternatorControlPin = GPIOD_5;
engineConfiguration->targetVBatt = 14.0; engineConfiguration->targetVBatt = 14.0;
@ -518,8 +518,8 @@ void setDodgeNeonNGCEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
// end of setDodgeNeonNGCEngineConfiguration // end of setDodgeNeonNGCEngineConfiguration
} }
void setDodgeNeonNGCEngineConfigurationCrankBased(DECLARE_ENGINE_PARAMETER_F) { void setDodgeNeonNGCEngineConfigurationCrankBased(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setDodgeNeonNGCEngineConfiguration(PASS_ENGINE_PARAMETER_F); setDodgeNeonNGCEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
#endif /* EFI_SUPPORT_DODGE_NEON */ #endif /* EFI_SUPPORT_DODGE_NEON */

10
firmware/config/engines/dodge_ram.cpp
View File

@ -16,20 +16,20 @@
EXTERN_ENGINE EXTERN_ENGINE
; ;
void setDodgeRam1996(DECLARE_ENGINE_PARAMETER_F) { void setDodgeRam1996(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR); setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->trigger.type = TT_DODGE_RAM; engineConfiguration->trigger.type = TT_DODGE_RAM;
engineConfiguration->injector.flow = 243.6; // 23.2lb/h engineConfiguration->injector.flow = 243.6; // 23.2lb/h
engineConfiguration->map.sensor.type = MT_DODGE_NEON_2003; engineConfiguration->map.sensor.type = MT_DODGE_NEON_2003;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
// set cranking_charge_angle 30 // set cranking_charge_angle 30
engineConfiguration->crankingChargeAngle = 30; engineConfiguration->crankingChargeAngle = 30;
// set_whole_fuel_map 6 // set_whole_fuel_map 6
setWholeFuelMap(6 PASS_ENGINE_PARAMETER); setWholeFuelMap(6 PASS_ENGINE_PARAMETER_SUFFIX);
//Base engine setting //Base engine setting
engineConfiguration->specs.cylindersCount = 8; engineConfiguration->specs.cylindersCount = 8;
@ -69,7 +69,7 @@ void setDodgeRam1996(DECLARE_ENGINE_PARAMETER_F) {
// set_global_fuel_correction 1 // set_global_fuel_correction 1
// set_whole_timing_map 10 // set_whole_timing_map 10
setWholeTimingTable(10 PASS_ENGINE_PARAMETER); setWholeTimingTable(10 PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->alternatorControlPin = GPIOD_7; boardConfiguration->alternatorControlPin = GPIOD_7;

4
firmware/config/engines/dodge_stratus.cpp
View File

@ -14,13 +14,13 @@
EXTERN_ENGINE EXTERN_ENGINE
; ;
void setDodgeStratus(DECLARE_ENGINE_PARAMETER_F) { void setDodgeStratus(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->trigger.type = TT_DODGE_STRATUS; engineConfiguration->trigger.type = TT_DODGE_STRATUS;
engineConfiguration->specs.cylindersCount = 6; engineConfiguration->specs.cylindersCount = 6;
engineConfiguration->specs.firingOrder = FO_1_2_3_4_5_6; engineConfiguration->specs.firingOrder = FO_1_2_3_4_5_6;
engineConfiguration->map.sensor.type = MT_DODGE_NEON_2003; engineConfiguration->map.sensor.type = MT_DODGE_NEON_2003;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS;
boardConfiguration->ignitionPins[0] = GPIOC_9; boardConfiguration->ignitionPins[0] = GPIOC_9;

4
firmware/config/engines/ford_1995_inline_6.cpp
View File

@ -25,7 +25,7 @@ EXTERN_ENGINE;
/** /**
* @brief Default values for persistent properties * @brief Default values for persistent properties
*/ */
void setFordInline6(DECLARE_ENGINE_PARAMETER_F) { void setFordInline6(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->specs.cylindersCount = 6; engineConfiguration->specs.cylindersCount = 6;
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR); setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
@ -40,7 +40,7 @@ void setFordInline6(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* 0.5ms dweel time just to be sure it would fit within camshaft revolution, dwell is not controlled by us anyway * 0.5ms dweel time just to be sure it would fit within camshaft revolution, dwell is not controlled by us anyway
*/ */
setConstantDwell(0.5 PASS_ENGINE_PARAMETER); setConstantDwell(0.5 PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* We treat the trigger as 6/0 toothed wheel * We treat the trigger as 6/0 toothed wheel

14
firmware/config/engines/ford_aspire.cpp
View File

@ -67,18 +67,18 @@ static const ignition_table_t default_aspire_timing_table = {
EXTERN_ENGINE; EXTERN_ENGINE;
static void setDefaultAspireMaps(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultAspireMaps(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setTimingLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
copyFuelTable(default_aspire_fuel_table, config->fuelTable); copyFuelTable(default_aspire_fuel_table, config->fuelTable);
copyTimingTable(default_aspire_timing_table, config->ignitionTable); copyTimingTable(default_aspire_timing_table, config->ignitionTable);
} }
void setFordAspireEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setFordAspireEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->tpsMin = 100; engineConfiguration->tpsMin = 100;
engineConfiguration->tpsMax = 750; engineConfiguration->tpsMax = 750;
@ -106,7 +106,7 @@ void setFordAspireEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->ignitionOffset = 87; engineConfiguration->ignitionOffset = 87;
engineConfiguration->extraInjectionOffset = 54 + 360; engineConfiguration->extraInjectionOffset = 54 + 360;
setDefaultAspireMaps(PASS_ENGINE_PARAMETER_F); setDefaultAspireMaps(PASS_ENGINE_PARAMETER_SIGNATURE);
// set_cranking_rpm 550 // set_cranking_rpm 550
engineConfiguration->cranking.rpm = 550; engineConfiguration->cranking.rpm = 550;
// set cranking_charge_angle 70 // set cranking_charge_angle 70

22
firmware/config/engines/ford_festiva.cpp
View File

@ -66,7 +66,7 @@ EXTERN_ENGINE;
* pin 1I/W9 - extra +5v * pin 1I/W9 - extra +5v
* set engine_type 14 * set engine_type 14
*/ */
void setFordEscortGt(DECLARE_ENGINE_PARAMETER_F) { void setFordEscortGt(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->trigger.type = TT_MAZDA_DOHC_1_4; engineConfiguration->trigger.type = TT_MAZDA_DOHC_1_4;
common079721_2351(engineConfiguration, boardConfiguration); common079721_2351(engineConfiguration, boardConfiguration);
@ -79,11 +79,11 @@ void setFordEscortGt(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->globalFuelCorrection = 0.75; engineConfiguration->globalFuelCorrection = 0.75;
engineConfiguration->specs.displacement = 1.839; engineConfiguration->specs.displacement = 1.839;
// engineConfiguration->fuelAlgorithm = LM_PLAIN_MAF; // engineConfiguration->fuelAlgorithm = LM_PLAIN_MAF;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
// engineConfiguration->fuelAlgorithm = LM_REAL_MAF; // engineConfiguration->fuelAlgorithm = LM_REAL_MAF;
setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
config->veRpmBins[0] = 800; config->veRpmBins[0] = 800;
config->veRpmBins[1] = 1200; config->veRpmBins[1] = 1200;
@ -122,13 +122,13 @@ void setFordEscortGt(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->map.sensor.type = MT_DENSO183; engineConfiguration->map.sensor.type = MT_DENSO183;
engineConfiguration->map.sensor.hwChannel = EFI_ADC_4; engineConfiguration->map.sensor.hwChannel = EFI_ADC_4;
setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER); setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->afr.hwChannel = EFI_ADC_2; // Frankenso analog #5 engineConfiguration->afr.hwChannel = EFI_ADC_2; // Frankenso analog #5
// set_idle_position 10 // set_idle_position 10
boardConfiguration->manIdlePosition = 10; boardConfiguration->manIdlePosition = 10;
setWholeIatCorrTimingTable(0 PASS_ENGINE_PARAMETER); setWholeIatCorrTimingTable(0 PASS_ENGINE_PARAMETER_SUFFIX);
// set global_trigger_offset_angle -37 // set global_trigger_offset_angle -37
@ -146,9 +146,9 @@ void setFordEscortGt(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->cranking.baseFuel = 9; engineConfiguration->cranking.baseFuel = 9;
setTableBin2(config->ignitionLoadBins, IGN_LOAD_COUNT, 20, 105, 5); setTableBin2(config->ignitionLoadBins, IGN_LOAD_COUNT, 20, 105, 5);
setWholeTimingTable(10 PASS_ENGINE_PARAMETER); setWholeTimingTable(10 PASS_ENGINE_PARAMETER_SUFFIX);
// set_whole_fuel_map 5 // set_whole_fuel_map 5
setWholeFuelMap(5 PASS_ENGINE_PARAMETER); setWholeFuelMap(5 PASS_ENGINE_PARAMETER_SUFFIX);
setAfrMap(config->afrTable, 13.5); setAfrMap(config->afrTable, 13.5);
setSingleCoilDwell(engineConfiguration); setSingleCoilDwell(engineConfiguration);
@ -231,7 +231,7 @@ void setFordEscortGt(DECLARE_ENGINE_PARAMETER_F) {
*/ */
boardConfiguration->fsio_setting[0] = 5000; boardConfiguration->fsio_setting[0] = 5000;
// set_fsio_expression 1 "rpm > fsio_setting(1)" // set_fsio_expression 1 "rpm > fsio_setting(1)"
setFsioExt(0, GPIOE_3, "rpm 1 fsio_setting >", 150 PASS_ENGINE_PARAMETER); setFsioExt(0, GPIOE_3, "rpm 1 fsio_setting >", 150 PASS_ENGINE_PARAMETER_SUFFIX);
// warning light // warning light
@ -249,8 +249,8 @@ void setFordEscortGt(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->fsio_setting[2] = 90; // CLT threshold boardConfiguration->fsio_setting[2] = 90; // CLT threshold
boardConfiguration->fsio_setting[3] = 13.5; // voltage threshold boardConfiguration->fsio_setting[3] = 13.5; // voltage threshold
// setFsio(1, GPIOC_13, "rpm 2 fsio_setting > coolant 3 fsio_setting > | vbatt 4 fsio_setting < |" PASS_ENGINE_PARAMETER); // setFsio(1, GPIOC_13, "rpm 2 fsio_setting > coolant 3 fsio_setting > | vbatt 4 fsio_setting < |" PASS_ENGINE_PARAMETER_SUFFIX);
setFsio(1, GPIOD_7, "rpm 2 fsio_setting >" PASS_ENGINE_PARAMETER); setFsio(1, GPIOD_7, "rpm 2 fsio_setting >" PASS_ENGINE_PARAMETER_SUFFIX);
config->ignitionRpmBins[0] = 800; config->ignitionRpmBins[0] = 800;

16
firmware/config/engines/honda_600.cpp
View File

@ -47,19 +47,19 @@ static const ignition_table_t default_custom_timing_table = {
EXTERN_ENGINE; EXTERN_ENGINE;
static void setDefaultCustomMaps(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultCustomMaps(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setFuelLoadBin(0,100 PASS_ENGINE_PARAMETER); setFuelLoadBin(0,100 PASS_ENGINE_PARAMETER_SUFFIX);
setFuelRpmBin(0, 7000 PASS_ENGINE_PARAMETER); setFuelRpmBin(0, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingLoadBin(0,100 PASS_ENGINE_PARAMETER); setTimingLoadBin(0,100 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingRpmBin(0,7000 PASS_ENGINE_PARAMETER); setTimingRpmBin(0,7000 PASS_ENGINE_PARAMETER_SUFFIX);
copyFuelTable(default_custom_fuel_table, config->fuelTable); copyFuelTable(default_custom_fuel_table, config->fuelTable);
copyFuelTable(default_custom_fuel_table, config->veTable); copyFuelTable(default_custom_fuel_table, config->veTable);
copyTimingTable(default_custom_timing_table, config->ignitionTable); copyTimingTable(default_custom_timing_table, config->ignitionTable);
} }
void setHonda600(DECLARE_ENGINE_PARAMETER_F) { void setHonda600(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->trigger.type = TT_HONDA_CBR_600_CUSTOM; engineConfiguration->trigger.type = TT_HONDA_CBR_600_CUSTOM;
engineConfiguration->fuelAlgorithm = LM_ALPHA_N; engineConfiguration->fuelAlgorithm = LM_ALPHA_N;
@ -144,8 +144,8 @@ void setHonda600(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->injectionPins[2] = GPIOB_7; // #3 boardConfiguration->injectionPins[2] = GPIOB_7; // #3
boardConfiguration->injectionPins[3] = GPIOB_8; // #4 boardConfiguration->injectionPins[3] = GPIOB_8; // #4
setDefaultCustomMaps(PASS_ENGINE_PARAMETER_F); setDefaultCustomMaps(PASS_ENGINE_PARAMETER_SIGNATURE);
setAlgorithm(LM_ALPHA_N PASS_ENGINE_PARAMETER); setAlgorithm(LM_ALPHA_N PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[4] = GPIO_UNASSIGNED;
boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED; boardConfiguration->injectionPins[5] = GPIO_UNASSIGNED;

36
firmware/config/engines/honda_accord.cpp
View File

@ -38,7 +38,7 @@
EXTERN_ENGINE; EXTERN_ENGINE;
static void setHondaAccordConfigurationCommon(DECLARE_ENGINE_PARAMETER_F) { static void setHondaAccordConfigurationCommon(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->map.sensor.type = MT_DENSO183; engineConfiguration->map.sensor.type = MT_DENSO183;
boardConfiguration->isFastAdcEnabled = true; boardConfiguration->isFastAdcEnabled = true;
@ -57,10 +57,10 @@ static void setHondaAccordConfigurationCommon(DECLARE_ENGINE_PARAMETER_F) {
// Keihin 06164-P0A-A00 // Keihin 06164-P0A-A00
engineConfiguration->injector.flow = 248; engineConfiguration->injector.flow = 248;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER); setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER_SUFFIX);
buildTimingMap(35 PASS_ENGINE_PARAMETER); buildTimingMap(35 PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* 18K Ohm @ -20C * 18K Ohm @ -20C
@ -177,43 +177,43 @@ static void setHondaAccordConfigurationCommon(DECLARE_ENGINE_PARAMETER_F) {
} }
/* /*
void setHondaAccordConfigurationTwoWires(DECLARE_ENGINE_PARAMETER_F) { void setHondaAccordConfigurationTwoWires(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->engineType = HONDA_ACCORD_CD_TWO_WIRES; engineConfiguration->engineType = HONDA_ACCORD_CD_TWO_WIRES;
engineConfiguration->trigger.type = TT_HONDA_ACCORD_CD_TWO_WIRES; engineConfiguration->trigger.type = TT_HONDA_ACCORD_CD_TWO_WIRES;
setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_F); setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
*/ */
void setHondaAccordConfigurationThreeWires(DECLARE_ENGINE_PARAMETER_F) { void setHondaAccordConfigurationThreeWires(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->engineType = HONDA_ACCORD_CD; engineConfiguration->engineType = HONDA_ACCORD_CD;
engineConfiguration->trigger.type = TT_HONDA_4_24_1; engineConfiguration->trigger.type = TT_HONDA_4_24_1;
setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_F); setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
void setHondaAccordConfigurationDip(DECLARE_ENGINE_PARAMETER_F) { void setHondaAccordConfigurationDip(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->engineType = HONDA_ACCORD_CD_DIP; engineConfiguration->engineType = HONDA_ACCORD_CD_DIP;
engineConfiguration->trigger.type = TT_HONDA_1_4_24; engineConfiguration->trigger.type = TT_HONDA_1_4_24;
setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_F); setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
void setHondaAccordConfiguration1_24(DECLARE_ENGINE_PARAMETER_F) { void setHondaAccordConfiguration1_24(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->engineType = HONDA_ACCORD_CD_DIP; engineConfiguration->engineType = HONDA_ACCORD_CD_DIP;
engineConfiguration->trigger.type = TT_HONDA_1_24; engineConfiguration->trigger.type = TT_HONDA_1_24;
setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_F); setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
void setHondaAccordConfiguration1_24_shifted(DECLARE_ENGINE_PARAMETER_F) { void setHondaAccordConfiguration1_24_shifted(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->engineType = HONDA_ACCORD_1_24_SHIFTED; engineConfiguration->engineType = HONDA_ACCORD_1_24_SHIFTED;
engineConfiguration->trigger.type = TT_HONDA_ACCORD_1_24_SHIFTED; engineConfiguration->trigger.type = TT_HONDA_ACCORD_1_24_SHIFTED;
setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_F); setHondaAccordConfigurationCommon(PASS_ENGINE_PARAMETER_SIGNATURE);
// set global_trigger_offset_angle 0 // set global_trigger_offset_angle 0
engineConfiguration->globalTriggerAngleOffset = 0; engineConfiguration->globalTriggerAngleOffset = 0;
} }
void setHondaCivic4_0_both(DECLARE_ENGINE_PARAMETER_F) { void setHondaCivic4_0_both(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setHondaAccordConfiguration1_24_shifted(PASS_ENGINE_PARAMETER_F); setHondaAccordConfiguration1_24_shifted(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->useOnlyRisingEdgeForTrigger = false; engineConfiguration->useOnlyRisingEdgeForTrigger = false;
engineConfiguration->trigger.customTotalToothCount = 4; engineConfiguration->trigger.customTotalToothCount = 4;
@ -222,8 +222,8 @@ void setHondaCivic4_0_both(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL; engineConfiguration->trigger.type = TT_TOOTHED_WHEEL;
} }
void setHondaCivic4_0_rise(DECLARE_ENGINE_PARAMETER_F) { void setHondaCivic4_0_rise(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setHondaAccordConfiguration1_24_shifted(PASS_ENGINE_PARAMETER_F); setHondaAccordConfiguration1_24_shifted(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->useOnlyRisingEdgeForTrigger = true; engineConfiguration->useOnlyRisingEdgeForTrigger = true;
engineConfiguration->trigger.customTotalToothCount = 4; engineConfiguration->trigger.customTotalToothCount = 4;

6
firmware/config/engines/lada_kalina.cpp
View File

@ -14,8 +14,8 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void setLadaKalina(DECLARE_ENGINE_PARAMETER_F) { void setLadaKalina(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
disableLCD(boardConfiguration); disableLCD(boardConfiguration);
boardConfiguration->HD44780_rs = GPIO_UNASSIGNED; boardConfiguration->HD44780_rs = GPIO_UNASSIGNED;
@ -56,6 +56,6 @@ void setLadaKalina(DECLARE_ENGINE_PARAMETER_F) {
*/ */
engineConfiguration->bc.fsio_setting[0] = 500; engineConfiguration->bc.fsio_setting[0] = 500;
// set_rpn_expression 1 "rpm 0 fsio_setting <" // set_rpn_expression 1 "rpm 0 fsio_setting <"
setFsioExt(0, GPIOE_3, "rpm 1 fsio_setting <", 0 PASS_ENGINE_PARAMETER); setFsioExt(0, GPIOE_3, "rpm 1 fsio_setting <", 0 PASS_ENGINE_PARAMETER_SUFFIX);
} }

16
firmware/config/engines/mazda_626.cpp
View File

@ -18,8 +18,8 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void setMazda626EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setMazda626EngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR); setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
// engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2; // engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_60_2;
@ -62,14 +62,14 @@ void setMazda626EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->tpsMin = 80; engineConfiguration->tpsMin = 80;
engineConfiguration->tpsMax = 764; engineConfiguration->tpsMax = 764;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER); setFuelLoadBin(0, 100 PASS_ENGINE_PARAMETER_SUFFIX);
// set_whole_fuel_map 9 // set_whole_fuel_map 9
setWholeFuelMap(9 PASS_ENGINE_PARAMETER); setWholeFuelMap(9 PASS_ENGINE_PARAMETER_SUFFIX);
// set_whole_timing_map 10 // set_whole_timing_map 10
setWholeTimingTable(10 PASS_ENGINE_PARAMETER); setWholeTimingTable(10 PASS_ENGINE_PARAMETER_SUFFIX);
// http://s1.micp.ru/tOb0U.png // http://s1.micp.ru/tOb0U.png
setThermistorConfiguration(&engineConfiguration->clt, -15, 5900, 23, 1750, 97, 165); setThermistorConfiguration(&engineConfiguration->clt, -15, 5900, 23, 1750, 97, 165);
@ -95,12 +95,12 @@ void setMazda626EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
// todo engineConfiguration->afr.hwChannel = EFI_ADC_3; // todo engineConfiguration->afr.hwChannel = EFI_ADC_3;
setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER); setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER_SUFFIX);
//#if EFI_FSIO || defined(__DOXYGEN__) //#if EFI_FSIO || defined(__DOXYGEN__)
// // backup main relay pin // // backup main relay pin
// setFsio(0, GPIOE_6, "1" PASS_ENGINE_PARAMETER); // setFsio(0, GPIOE_6, "1" PASS_ENGINE_PARAMETER_SUFFIX);
//#endif //#endif
engineConfiguration->externalKnockSenseAdc = EFI_ADC_4; engineConfiguration->externalKnockSenseAdc = EFI_ADC_4;

28
firmware/config/engines/mazda_miata.cpp
View File

@ -127,7 +127,7 @@ static void setDefaultCrankingFuel(engine_configuration_s *engineConfiguration)
EXTERN_ENGINE; EXTERN_ENGINE;
static void commonMiataNa(DECLARE_ENGINE_PARAMETER_F) { static void commonMiataNa(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->trigger.type = TT_MAZDA_MIATA_NA; engineConfiguration->trigger.type = TT_MAZDA_MIATA_NA;
engineConfiguration->engineChartSize = 100; engineConfiguration->engineChartSize = 100;
@ -135,8 +135,8 @@ static void commonMiataNa(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP boardConfiguration->triggerInputPins[1] = GPIOA_5; // 2E White CKP
engineConfiguration->ignitionMode = IM_WASTED_SPARK; engineConfiguration->ignitionMode = IM_WASTED_SPARK;
setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->idle.solenoidFrequency = 160; boardConfiguration->idle.solenoidFrequency = 160;
@ -201,10 +201,10 @@ void common079721_2351(engine_configuration_s *engineConfiguration, board_config
/** /**
* Frankenstein board * Frankenstein board
*/ */
void setMiata1990(DECLARE_ENGINE_PARAMETER_F) { void setMiata1990(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
common079721_2351(engineConfiguration, boardConfiguration); common079721_2351(engineConfiguration, boardConfiguration);
commonMiataNa(PASS_ENGINE_PARAMETER_F); commonMiataNa(PASS_ENGINE_PARAMETER_SIGNATURE);
// Frankenstein: low side - out #1: PC14 // Frankenstein: low side - out #1: PC14
// Frankenstein: low side - out #2: PC15 // Frankenstein: low side - out #2: PC15
@ -231,8 +231,8 @@ void setMiata1990(DECLARE_ENGINE_PARAMETER_F) {
} }
static void setMiata1994_common(DECLARE_ENGINE_PARAMETER_F) { static void setMiata1994_common(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
commonMiataNa(PASS_ENGINE_PARAMETER_F); commonMiataNa(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->specs.displacement = 1.839; engineConfiguration->specs.displacement = 1.839;
// set cranking_timing_angle 0 // set cranking_timing_angle 0
@ -305,8 +305,8 @@ static void setMiata1994_common(DECLARE_ENGINE_PARAMETER_F) {
* Frankenso board * Frankenso board
* set engine_type 20 * set engine_type 20
*/ */
void setMiata1994_d(DECLARE_ENGINE_PARAMETER_F) { void setMiata1994_d(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setMiata1994_common(PASS_ENGINE_PARAMETER_F); setMiata1994_common(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->vbattDividerCoeff = ((float) (8.2 + 33)) / 8.2 * 2; engineConfiguration->vbattDividerCoeff = ((float) (8.2 + 33)) / 8.2 * 2;
/** /**
* This board was avoiding PE0 & PE1 mosfets altogether * This board was avoiding PE0 & PE1 mosfets altogether
@ -320,8 +320,8 @@ void setMiata1994_d(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED; boardConfiguration->idle.solenoidPin = GPIO_UNASSIGNED;
} }
void setMiata1994_s(DECLARE_ENGINE_PARAMETER_F) { void setMiata1994_s(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setMiata1994_common(PASS_ENGINE_PARAMETER_F); setMiata1994_common(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->vbattDividerCoeff = ((float) (10.0 + 33)) / 10 * 2; engineConfiguration->vbattDividerCoeff = ((float) (10.0 + 33)) / 10 * 2;
boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED; boardConfiguration->triggerSimulatorPins[2] = GPIO_UNASSIGNED;
@ -329,7 +329,7 @@ void setMiata1994_s(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->acSwitchAdc = EFI_ADC_1; // PA1, W50 on Frankenso engineConfiguration->acSwitchAdc = EFI_ADC_1; // PA1, W50 on Frankenso
engineConfiguration->afr.hwChannel = EFI_ADC_3; engineConfiguration->afr.hwChannel = EFI_ADC_3;
setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER); setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* This board has PE0<>PD5 & PE1<>PD3 rewired in order to avoid Discovery issue * This board has PE0<>PD5 & PE1<>PD3 rewired in order to avoid Discovery issue
@ -364,8 +364,8 @@ void setMiata1994_s(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* Tom tomiata, Frankenstein board * Tom tomiata, Frankenstein board
*/ */
void setMiata1996(DECLARE_ENGINE_PARAMETER_F) { void setMiata1996(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
commonMiataNa(PASS_ENGINE_PARAMETER_F); commonMiataNa(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->specs.displacement = 1.839; engineConfiguration->specs.displacement = 1.839;
copyFuelTable(miata_maf_fuel_table, config->fuelTable); copyFuelTable(miata_maf_fuel_table, config->fuelTable);

8
firmware/config/engines/mazda_miata_1_6.cpp
View File

@ -87,8 +87,8 @@ static const fuel_table_t mafBased16FuelTable = {
{/* 15 4.400 *//* 0 800.0*/7.000, /* 1 1213.33*/7.000, /* 2 1626.6599*/7.000, /* 3 2040.0*/7.000, /* 4 2453.3298*/7.000, /* 5 2866.66*/7.000, /* 6 3280.0*/7.000, /* 7 3693.3298*/7.000, /* 8 4106.6597*/6.000, /* 9 4520.0*/6.000, /* 10 4933.33*/6.000, /* 11 5346.6597*/6.000, /* 12 5760.0*/6.000, /* 13 6173.33*/6.000, /* 14 6586.6597*/6.000, /* 15 7000.0*/6.000, }, {/* 15 4.400 *//* 0 800.0*/7.000, /* 1 1213.33*/7.000, /* 2 1626.6599*/7.000, /* 3 2040.0*/7.000, /* 4 2453.3298*/7.000, /* 5 2866.66*/7.000, /* 6 3280.0*/7.000, /* 7 3693.3298*/7.000, /* 8 4106.6597*/6.000, /* 9 4520.0*/6.000, /* 10 4933.33*/6.000, /* 11 5346.6597*/6.000, /* 12 5760.0*/6.000, /* 13 6173.33*/6.000, /* 14 6586.6597*/6.000, /* 15 7000.0*/6.000, },
}; };
void setMiataNA_1_6_Configuration(DECLARE_ENGINE_PARAMETER_F) { void setMiataNA_1_6_Configuration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
// Frankenso analog #6 pin 3R, W56 (5th lower row pin from the end) top <> W45 bottom jumper, not OEM // Frankenso analog #6 pin 3R, W56 (5th lower row pin from the end) top <> W45 bottom jumper, not OEM
engineConfiguration->map.sensor.hwChannel = EFI_ADC_7; engineConfiguration->map.sensor.hwChannel = EFI_ADC_7;
@ -116,7 +116,7 @@ void setMiataNA_1_6_Configuration(DECLARE_ENGINE_PARAMETER_F) {
// Frankenso analog #7 pin 3J, W48 top <>W48 bottom jumper, not OEM // Frankenso analog #7 pin 3J, W48 top <>W48 bottom jumper, not OEM
engineConfiguration->afr.hwChannel = EFI_ADC_3; // PA3 engineConfiguration->afr.hwChannel = EFI_ADC_3; // PA3
setWholeFuelMap(6 PASS_ENGINE_PARAMETER); setWholeFuelMap(6 PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* http://miataturbo.wikidot.com/fuel-injectors * http://miataturbo.wikidot.com/fuel-injectors
@ -190,7 +190,7 @@ void setMiataNA_1_6_Configuration(DECLARE_ENGINE_PARAMETER_F) {
// set_fsio_expression 0 "((rpm > fsio_setting(4) & (fsio_input < fsio_setting(5)) | rpm > fsio_setting(1) | (coolant > fsio_setting(2) > | (vbatt < fsio_setting(3)" // set_fsio_expression 0 "((rpm > fsio_setting(4) & (fsio_input < fsio_setting(5)) | rpm > fsio_setting(1) | (coolant > fsio_setting(2) > | (vbatt < fsio_setting(3)"
// todo: convert // todo: convert
setFsio(0, GPIOC_13, "rpm 3 fsio_setting > fsio_input 4 fsio_setting < & rpm 0 fsio_setting | > coolant 1 fsio_setting > | vbatt 2 fsio_setting < |" PASS_ENGINE_PARAMETER); setFsio(0, GPIOC_13, "rpm 3 fsio_setting > fsio_input 4 fsio_setting < & rpm 0 fsio_setting | > coolant 1 fsio_setting > | vbatt 2 fsio_setting < |" PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G boardConfiguration->ignitionPins[0] = GPIOE_14; // Frankenso high side - pin 1G
boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED; boardConfiguration->ignitionPins[1] = GPIO_UNASSIGNED;

6
firmware/config/engines/mazda_miata_nb.cpp
View File

@ -17,7 +17,7 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void setMazdaMiataNb1EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setMazdaMiataNb1EngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
// set_rpm_hard_limit 3000 // set_rpm_hard_limit 3000
engineConfiguration->rpmHardLimit = 3000; // yes, 3k. let's play it safe for now engineConfiguration->rpmHardLimit = 3000; // yes, 3k. let's play it safe for now
@ -75,7 +75,7 @@ void setMazdaMiataNb1EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->clutchDownPin = GPIO_UNASSIGNED; boardConfiguration->clutchDownPin = GPIO_UNASSIGNED;
// set_whole_fuel_map 3 // set_whole_fuel_map 3
setWholeFuelMap(3 PASS_ENGINE_PARAMETER); setWholeFuelMap(3 PASS_ENGINE_PARAMETER_SUFFIX);
// 10 deg before TDC is default timing // 10 deg before TDC is default timing
@ -88,5 +88,5 @@ void setMazdaMiataNb1EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->fsio_setting[0] = 5000; boardConfiguration->fsio_setting[0] = 5000;
// (self and (rpm > 4800)) OR (rpm > 5000) // (self and (rpm > 4800)) OR (rpm > 5000)
// set_rpn_expression 1 "self rpm 4800 > & rpm 5000 > OR" // set_rpn_expression 1 "self rpm 4800 > & rpm 5000 > OR"
// setFsioExt(0, GPIOE_3, "self rpm 4800 > & rpm 5000 > OR", 150 PASS_ENGINE_PARAMETER); // setFsioExt(0, GPIOE_3, "self rpm 4800 > & rpm 5000 > OR", 150 PASS_ENGINE_PARAMETER_SUFFIX);
} }

24
firmware/config/engines/mazda_miata_vvt.cpp
View File

@ -213,7 +213,7 @@ static const ignition_table_t mapBased18vvtTimingTable = {
{/* 15 250.000 *//* 0 700.0*/1.100, /* 1 850.0*/1.400, /* 2 943.0*/1.600, /* 3 1112.0*/2.000, /* 4 1310.0*/2.500, /* 5 1545.0*/3.000, /* 6 1821.0*/3.700, /* 7 2146.0*/4.400, /* 8 2530.0*/5.400, /* 9 2982.0*/6.600, /* 10 3515.0*/7.600, /* 11 4144.0*/9.000, /* 12 4884.0*/10.500, /* 13 5757.0*/12.000, /* 14 6787.0*/13.400, /* 15 8000.0*/14.900, }, {/* 15 250.000 *//* 0 700.0*/1.100, /* 1 850.0*/1.400, /* 2 943.0*/1.600, /* 3 1112.0*/2.000, /* 4 1310.0*/2.500, /* 5 1545.0*/3.000, /* 6 1821.0*/3.700, /* 7 2146.0*/4.400, /* 8 2530.0*/5.400, /* 9 2982.0*/6.600, /* 10 3515.0*/7.600, /* 11 4144.0*/9.000, /* 12 4884.0*/10.500, /* 13 5757.0*/12.000, /* 14 6787.0*/13.400, /* 15 8000.0*/14.900, },
}; };
void setMazdaMiataNbTpsTps(DECLARE_ENGINE_PARAMETER_F) { void setMazdaMiataNbTpsTps(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
memcpy(config->tpsTpsAccelFromRpmBins, tpsTspSame, sizeof(tpsTspSame)); memcpy(config->tpsTpsAccelFromRpmBins, tpsTspSame, sizeof(tpsTspSame));
memcpy(config->tpsTpsAccelFromRpmBins, tpsTspSame, sizeof(tpsTspSame)); memcpy(config->tpsTpsAccelFromRpmBins, tpsTspSame, sizeof(tpsTspSame));
// todo: there should be a better way? // todo: there should be a better way?
@ -224,13 +224,13 @@ void setMazdaMiataNbTpsTps(DECLARE_ENGINE_PARAMETER_F) {
} }
} }
void setMazdaMiataNbInjectorLag(DECLARE_ENGINE_PARAMETER_F) { void setMazdaMiataNbInjectorLag(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
memcpy(engineConfiguration->injector.battLagCorr, injectorLagCorrection, sizeof(injectorLagCorrection)); memcpy(engineConfiguration->injector.battLagCorr, injectorLagCorrection, sizeof(injectorLagCorrection));
memcpy(engineConfiguration->injector.battLagCorrBins, injectorLagBins, sizeof(injectorLagBins)); memcpy(engineConfiguration->injector.battLagCorrBins, injectorLagBins, sizeof(injectorLagBins));
} }
void setMazdaMiata2003EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setMazdaMiata2003EngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->trigger.type = TT_MIATA_VVT; engineConfiguration->trigger.type = TT_MIATA_VVT;
setOperationMode(engineConfiguration, FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR); setOperationMode(engineConfiguration, FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR);
@ -277,7 +277,7 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
// * set_fsio_setting 1 0.55 // * set_fsio_setting 1 0.55
// */ // */
boardConfiguration->fsio_setting[0] = 0.0; boardConfiguration->fsio_setting[0] = 0.0;
// setFsioExt(0, GPIOE_3, "0 fsio_setting", 400 PASS_ENGINE_PARAMETER); // setFsioExt(0, GPIOE_3, "0 fsio_setting", 400 PASS_ENGINE_PARAMETER_SUFFIX);
@ -320,10 +320,10 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
} }
} }
setMazdaMiataNbTpsTps(PASS_ENGINE_PARAMETER_F); setMazdaMiataNbTpsTps(PASS_ENGINE_PARAMETER_SIGNATURE);
setMazdaMiataNbInjectorLag(PASS_ENGINE_PARAMETER_F); setMazdaMiataNbInjectorLag(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->tpsMin = 100; // convert 12to10 bit (ADC/4) engineConfiguration->tpsMin = 100; // convert 12to10 bit (ADC/4)
engineConfiguration->tpsMax = 650; // convert 12to10 bit (ADC/4) engineConfiguration->tpsMax = 650; // convert 12to10 bit (ADC/4)
@ -368,7 +368,7 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
// todo: re-wire the board to use default input channel! // todo: re-wire the board to use default input channel!
engineConfiguration->afr.hwChannel = EFI_ADC_4; engineConfiguration->afr.hwChannel = EFI_ADC_4;
setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER); setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER_SUFFIX);
// //
/** /**
@ -383,13 +383,13 @@ void setMazdaMiata2003EngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->fsio_setting[2] = 105; // #3 CLT threshold boardConfiguration->fsio_setting[2] = 105; // #3 CLT threshold
boardConfiguration->fsio_setting[3] = 12.0; // #4 voltage threshold boardConfiguration->fsio_setting[3] = 12.0; // #4 voltage threshold
setFsio(1, GPIOE_6, COMBINED_WARNING_LIGHT PASS_ENGINE_PARAMETER); setFsio(1, GPIOE_6, COMBINED_WARNING_LIGHT PASS_ENGINE_PARAMETER_SUFFIX);
} }
void setMazdaMiata2003EngineConfigurationNewBoard(DECLARE_ENGINE_PARAMETER_F) { void setMazdaMiata2003EngineConfigurationNewBoard(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setMazdaMiata2003EngineConfiguration(PASS_ENGINE_PARAMETER_F); setMazdaMiata2003EngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
// todo: there should be a better way? // todo: there should be a better way?
for (int loadIndex = 0; loadIndex < FSIO_TABLE_8; loadIndex++) { for (int loadIndex = 0; loadIndex < FSIO_TABLE_8; loadIndex++) {
@ -413,7 +413,7 @@ void setMazdaMiata2003EngineConfigurationNewBoard(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->mafAdcChannel = EFI_ADC_4; // PA4 engineConfiguration->mafAdcChannel = EFI_ADC_4; // PA4
setEgoSensor(ES_14Point7_Free PASS_ENGINE_PARAMETER); setEgoSensor(ES_14Point7_Free PASS_ENGINE_PARAMETER_SUFFIX);
// set cranking_fuel 9 // set cranking_fuel 9

8
firmware/config/engines/mitsubishi.cpp
View File

@ -15,7 +15,7 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void setMitsubishiConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setMitsubishiConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->engineType = MITSU_4G93; engineConfiguration->engineType = MITSU_4G93;
engineConfiguration->trigger.type = TT_MITSUBISHI; // same trigger as 4G63? engineConfiguration->trigger.type = TT_MITSUBISHI; // same trigger as 4G63?
@ -38,7 +38,7 @@ void setMitsubishiConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->crankingTimingAngle = -715; engineConfiguration->crankingTimingAngle = -715;
// set_whole_fuel_map 3 // set_whole_fuel_map 3
setWholeFuelMap(3 PASS_ENGINE_PARAMETER); setWholeFuelMap(3 PASS_ENGINE_PARAMETER_SUFFIX);
// set cranking_fuel 4 // set cranking_fuel 4
engineConfiguration->cranking.baseFuel = 4; engineConfiguration->cranking.baseFuel = 4;
@ -85,9 +85,9 @@ void setMitsubishiConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->HD44780width = 20; engineConfiguration->HD44780width = 20;
engineConfiguration->HD44780height = 4; engineConfiguration->HD44780height = 4;
setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER); setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER_SUFFIX);
#if EFI_FSIO || defined(__DOXYGEN__) #if EFI_FSIO || defined(__DOXYGEN__)
setFsio(0, GPIOD_11, "rpm 5500 >" PASS_ENGINE_PARAMETER); setFsio(0, GPIOD_11, "rpm 5500 >" PASS_ENGINE_PARAMETER_SUFFIX);
#endif #endif
} }

6
firmware/config/engines/rover_v8.cpp
View File

@ -29,7 +29,7 @@ void setFrankenstein_01_LCD(board_configuration_s *boardConfiguration) {
EXTERN_ENGINE; EXTERN_ENGINE;
void setRoverv8(DECLARE_ENGINE_PARAMETER_F) { void setRoverv8(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR); setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
// set trigger_type 9 // set trigger_type 9
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_36_1; engineConfiguration->trigger.type = TT_TOOTHED_WHEEL_36_1;
@ -48,7 +48,7 @@ void setRoverv8(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->cranking.rpm = 350; engineConfiguration->cranking.rpm = 350;
// set_whole_fuel_map 3 // set_whole_fuel_map 3
setWholeFuelMap(3 PASS_ENGINE_PARAMETER); setWholeFuelMap(3 PASS_ENGINE_PARAMETER_SUFFIX);
// set cranking_injection_mode 0 // set cranking_injection_mode 0
engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS; engineConfiguration->crankingInjectionMode = IM_SIMULTANEOUS;
@ -134,7 +134,7 @@ void setRoverv8(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->canNbcType = CAN_BUS_MAZDA_RX8; engineConfiguration->canNbcType = CAN_BUS_MAZDA_RX8;
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
// todo: make this official Frankenstein joystick? // todo: make this official Frankenstein joystick?
boardConfiguration->joystickCenterPin = GPIOD_8; boardConfiguration->joystickCenterPin = GPIOD_8;

8
firmware/config/engines/sachs.cpp
View File

@ -14,7 +14,7 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void setSachs(DECLARE_ENGINE_PARAMETER_F) { void setSachs(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->specs.displacement = 0.1; // 100cc engineConfiguration->specs.displacement = 0.1; // 100cc
engineConfiguration->specs.cylindersCount = 1; engineConfiguration->specs.cylindersCount = 1;
@ -25,7 +25,7 @@ void setSachs(DECLARE_ENGINE_PARAMETER_F) {
// set injection_offset 0 // set injection_offset 0
engineConfiguration->extraInjectionOffset = 0; engineConfiguration->extraInjectionOffset = 0;
setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER); setEgoSensor(ES_Innovate_MTX_L PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* 50/2 trigger * 50/2 trigger
@ -81,8 +81,8 @@ void setSachs(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->fuelPumpPin = GPIOE_6; boardConfiguration->fuelPumpPin = GPIOE_6;
// todo: extract a method? figure out something smarter // todo: extract a method? figure out something smarter
setFuelRpmBin(800, 15000 PASS_ENGINE_PARAMETER); setFuelRpmBin(800, 15000 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingRpmBin(800, 15000 PASS_ENGINE_PARAMETER); setTimingRpmBin(800, 15000 PASS_ENGINE_PARAMETER_SUFFIX);
setTableBin2(config->veRpmBins, FUEL_RPM_COUNT, 15000, 7000, 1); setTableBin2(config->veRpmBins, FUEL_RPM_COUNT, 15000, 7000, 1);
setTableBin2(config->afrRpmBins, FUEL_RPM_COUNT, 15000, 7000, 1); setTableBin2(config->afrRpmBins, FUEL_RPM_COUNT, 15000, 7000, 1);

18
firmware/config/engines/test_engine.cpp
View File

@ -17,7 +17,7 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void setTestEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setTestEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR); setOperationMode(engineConfiguration, FOUR_STROKE_CAM_SENSOR);
engineConfiguration->trigger.type = TT_ONE_PLUS_ONE; engineConfiguration->trigger.type = TT_ONE_PLUS_ONE;
@ -32,10 +32,10 @@ void setTestEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->mafAdcChannel = EFI_ADC_1; engineConfiguration->mafAdcChannel = EFI_ADC_1;
engineConfiguration->vbattAdcChannel = EFI_ADC_NONE; engineConfiguration->vbattAdcChannel = EFI_ADC_NONE;
setWholeIatCorrTimingTable(0 PASS_ENGINE_PARAMETER); setWholeIatCorrTimingTable(0 PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->ignitionMode = IM_ONE_COIL; engineConfiguration->ignitionMode = IM_ONE_COIL;
setConstantDwell(3 PASS_ENGINE_PARAMETER); // 50% duty cycle @ 5000 rpm setConstantDwell(3 PASS_ENGINE_PARAMETER_SUFFIX); // 50% duty cycle @ 5000 rpm
board_configuration_s *bc = &engineConfiguration->bc; board_configuration_s *bc = &engineConfiguration->bc;
bc->malfunctionIndicatorPin = GPIO_UNASSIGNED; bc->malfunctionIndicatorPin = GPIO_UNASSIGNED;
@ -53,7 +53,7 @@ void setTestEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->logicAnalyzerPins[3] = GPIO_UNASSIGNED; boardConfiguration->logicAnalyzerPins[3] = GPIO_UNASSIGNED;
} }
void setTestVVTEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setTestVVTEngineConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR); setOperationMode(engineConfiguration, FOUR_STROKE_CRANK_SENSOR);
engineConfiguration->trigger.type = TT_TOOTHED_WHEEL; engineConfiguration->trigger.type = TT_TOOTHED_WHEEL;
@ -61,7 +61,7 @@ void setTestVVTEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->trigger.customSkippedToothCount = 1; engineConfiguration->trigger.customSkippedToothCount = 1;
// set algorithm 3 // set algorithm 3
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED; boardConfiguration->triggerInputPins[1] = GPIO_UNASSIGNED;
engineConfiguration->camInput = GPIOA_5; engineConfiguration->camInput = GPIOA_5;
@ -74,8 +74,8 @@ void setTestVVTEngineConfiguration(DECLARE_ENGINE_PARAMETER_F) {
} }
#if EFI_UNIT_TEST || defined(__DOXYGEN__) #if EFI_UNIT_TEST || defined(__DOXYGEN__)
void setTestEngineIssue366both(DECLARE_ENGINE_PARAMETER_F) { void setTestEngineIssue366both(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setTestEngineConfiguration(PASS_ENGINE_PARAMETER_F); setTestEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->useOnlyRisingEdgeForTrigger = false; engineConfiguration->useOnlyRisingEdgeForTrigger = false;
@ -86,8 +86,8 @@ void setTestEngineIssue366both(DECLARE_ENGINE_PARAMETER_F) {
} }
void setTestEngineIssue366rise(DECLARE_ENGINE_PARAMETER_F) { void setTestEngineIssue366rise(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setTestEngineIssue366both(PASS_ENGINE_PARAMETER_F); setTestEngineIssue366both(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->useOnlyRisingEdgeForTrigger = true; engineConfiguration->useOnlyRisingEdgeForTrigger = true;

16
firmware/config/engines/vw.cpp
View File

@ -15,10 +15,10 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void setVwAba(DECLARE_ENGINE_PARAMETER_F) { void setVwAba(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
setWholeTimingTable(20 PASS_ENGINE_PARAMETER); setWholeTimingTable(20 PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->cranking.baseFuel = 12; engineConfiguration->cranking.baseFuel = 12;
// set cranking_timing_angle 10 // set cranking_timing_angle 10
engineConfiguration->crankingTimingAngle = 10; engineConfiguration->crankingTimingAngle = 10;
@ -26,7 +26,7 @@ void setVwAba(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->isCylinderCleanupEnabled = true; engineConfiguration->isCylinderCleanupEnabled = true;
// set_whole_fuel_map 12 // set_whole_fuel_map 12
setWholeFuelMap(12 PASS_ENGINE_PARAMETER); setWholeFuelMap(12 PASS_ENGINE_PARAMETER_SUFFIX);
// set global_trigger_offset_angle 93 // set global_trigger_offset_angle 93
engineConfiguration->globalTriggerAngleOffset = 93; engineConfiguration->globalTriggerAngleOffset = 93;
@ -44,7 +44,7 @@ void setVwAba(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->specs.displacement = 2.0; engineConfiguration->specs.displacement = 2.0;
engineConfiguration->injector.flow = 320; // 30lb/h engineConfiguration->injector.flow = 320; // 30lb/h
// set algorithm 3 // set algorithm 3
setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER); setAlgorithm(LM_SPEED_DENSITY PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->map.sensor.type = MT_GM_3_BAR; engineConfiguration->map.sensor.type = MT_GM_3_BAR;
engineConfiguration->ignitionMode = IM_ONE_COIL; engineConfiguration->ignitionMode = IM_ONE_COIL;
@ -57,9 +57,9 @@ void setVwAba(DECLARE_ENGINE_PARAMETER_F) {
float mapRange = 110; float mapRange = 110;
setEgoSensor(ES_PLX PASS_ENGINE_PARAMETER); setEgoSensor(ES_PLX PASS_ENGINE_PARAMETER_SUFFIX);
setFuelTablesLoadBin(20, mapRange PASS_ENGINE_PARAMETER); setFuelTablesLoadBin(20, mapRange PASS_ENGINE_PARAMETER_SUFFIX);
setTimingLoadBin(20, mapRange PASS_ENGINE_PARAMETER); setTimingLoadBin(20, mapRange PASS_ENGINE_PARAMETER_SUFFIX);
boardConfiguration->isSdCardEnabled = false; boardConfiguration->isSdCardEnabled = false;
engineConfiguration->tpsMin = 740; engineConfiguration->tpsMin = 740;

92
firmware/console/status_loop.cpp
View File

@ -158,7 +158,7 @@ static char buf[6];
* This is useful if we are changing engine mode dynamically * This is useful if we are changing engine mode dynamically
* For example http://rusefi.com/forum/viewtopic.php?f=5&t=1085 * For example http://rusefi.com/forum/viewtopic.php?f=5&t=1085
*/ */
static int packEngineMode(DECLARE_ENGINE_PARAMETER_F) { static int packEngineMode(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return (engineConfiguration->fuelAlgorithm << 4) + return (engineConfiguration->fuelAlgorithm << 4) +
(engineConfiguration->injectionMode << 2) + (engineConfiguration->injectionMode << 2) +
engineConfiguration->ignitionMode; engineConfiguration->ignitionMode;
@ -183,29 +183,29 @@ static void printSensors(Logging *log, bool fileFormat) {
reportSensorF(log, fileFormat, GAUGE_NAME_CPU_TEMP, "C", getMCUInternalTemperature(), 2); // log column #3 reportSensorF(log, fileFormat, GAUGE_NAME_CPU_TEMP, "C", getMCUInternalTemperature(), 2); // log column #3
#endif #endif
reportSensorI(log, fileFormat, "mode", "v", packEngineMode(PASS_ENGINE_PARAMETER_F)); // log column #3 reportSensorI(log, fileFormat, "mode", "v", packEngineMode(PASS_ENGINE_PARAMETER_SIGNATURE)); // log column #3
if (hasCltSensor()) { if (hasCltSensor()) {
reportSensorF(log, fileFormat, "CLT", "C", getCoolantTemperature(PASS_ENGINE_PARAMETER_F), 2); // log column #4 reportSensorF(log, fileFormat, "CLT", "C", getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE), 2); // log column #4
} }
if (hasTpsSensor()) { if (hasTpsSensor()) {
reportSensorF(log, fileFormat, "TPS", "%", getTPS(PASS_ENGINE_PARAMETER_F), 2); // log column #5 reportSensorF(log, fileFormat, "TPS", "%", getTPS(PASS_ENGINE_PARAMETER_SIGNATURE), 2); // log column #5
} }
if (hasVBatt(PASS_ENGINE_PARAMETER_F)) { if (hasVBatt(PASS_ENGINE_PARAMETER_SIGNATURE)) {
reportSensorF(log, fileFormat, GAUGE_NAME_VBAT, "V", getVBatt(PASS_ENGINE_PARAMETER_F), 2); // log column #6 reportSensorF(log, fileFormat, GAUGE_NAME_VBAT, "V", getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE), 2); // log column #6
} }
if (hasIatSensor()) { if (hasIatSensor()) {
reportSensorF(log, fileFormat, "IAT", "C", getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F), 2); // log column #7 reportSensorF(log, fileFormat, "IAT", "C", getIntakeAirTemperature(PASS_ENGINE_PARAMETER_SIGNATURE), 2); // log column #7
} }
if (hasMafSensor()) { if (hasMafSensor()) {
reportSensorF(log, fileFormat, "maf", "V", getMaf(PASS_ENGINE_PARAMETER_F), 2); reportSensorF(log, fileFormat, "maf", "V", getMaf(PASS_ENGINE_PARAMETER_SIGNATURE), 2);
reportSensorF(log, fileFormat, "mafr", "kg/hr", getRealMaf(PASS_ENGINE_PARAMETER_F), 2); reportSensorF(log, fileFormat, "mafr", "kg/hr", getRealMaf(PASS_ENGINE_PARAMETER_SIGNATURE), 2);
} }
#if EFI_ANALOG_SENSORS || defined(__DOXYGEN__) #if EFI_ANALOG_SENSORS || defined(__DOXYGEN__)
if (hasMapSensor(PASS_ENGINE_PARAMETER_F)) { if (hasMapSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
reportSensorF(log, fileFormat, "MAP", "kPa", getMap(), 2); reportSensorF(log, fileFormat, "MAP", "kPa", getMap(), 2);
// reportSensorF(log, fileFormat, "map_r", "V", getRawMap(), 2); // reportSensorF(log, fileFormat, "map_r", "V", getRawMap(), 2);
} }
@ -216,8 +216,8 @@ static void printSensors(Logging *log, bool fileFormat) {
} }
#endif /* EFI_ANALOG_SENSORS */ #endif /* EFI_ANALOG_SENSORS */
if (hasAfrSensor(PASS_ENGINE_PARAMETER_F)) { if (hasAfrSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
reportSensorF(log, fileFormat, "afr", "AFR", getAfr(PASS_ENGINE_PARAMETER_F), 2); reportSensorF(log, fileFormat, "afr", "AFR", getAfr(PASS_ENGINE_PARAMETER_SIGNATURE), 2);
} }
#if EFI_IDLE_CONTROL || defined(__DOXYGEN__) #if EFI_IDLE_CONTROL || defined(__DOXYGEN__)
@ -247,13 +247,13 @@ static void printSensors(Logging *log, bool fileFormat) {
#endif /* EFI_TUNER_STUDIO */ #endif /* EFI_TUNER_STUDIO */
reportSensorF(log, fileFormat, GAUGE_NAME_TCHARGE, "K", engine->engineState.tChargeK, 2); // log column #8 reportSensorF(log, fileFormat, GAUGE_NAME_TCHARGE, "K", engine->engineState.tChargeK, 2); // log column #8
if (hasMapSensor(PASS_ENGINE_PARAMETER_F)) { if (hasMapSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
reportSensorF(log, fileFormat, GAUGE_NAME_FUEL_VR, "%", veMap.getValue(rpm, getMap()), 2); reportSensorF(log, fileFormat, GAUGE_NAME_FUEL_VR, "%", veMap.getValue(rpm, getMap()), 2);
} }
reportSensorF(log, fileFormat, GAUGE_NAME_VVT, "deg", engine->triggerCentral.vvtPosition, 1); reportSensorF(log, fileFormat, GAUGE_NAME_VVT, "deg", engine->triggerCentral.vvtPosition, 1);
} }
float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_F); float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE);
reportSensorF(log, fileFormat, GAUGE_NAME_ENGINE_LOAD, "x", engineLoad, 2); reportSensorF(log, fileFormat, GAUGE_NAME_ENGINE_LOAD, "x", engineLoad, 2);
@ -264,7 +264,7 @@ static void printSensors(Logging *log, bool fileFormat) {
} }
if (fileFormat) { if (fileFormat) {
floatms_t fuelBase = getBaseFuel(rpm PASS_ENGINE_PARAMETER); floatms_t fuelBase = getBaseFuel(rpm PASS_ENGINE_PARAMETER_SUFFIX);
reportSensorF(log, fileFormat, "f: base", "ms", fuelBase, 2); reportSensorF(log, fileFormat, "f: base", "ms", fuelBase, 2);
reportSensorF(log, fileFormat, "f: actual", "ms", ENGINE(actualLastInjection), 2); reportSensorF(log, fileFormat, "f: actual", "ms", ENGINE(actualLastInjection), 2);
reportSensorF(log, fileFormat, GAUGE_NAME_INJECTOR_LAG, "ms", engine->engineState.injectorLag, 2); reportSensorF(log, fileFormat, GAUGE_NAME_INJECTOR_LAG, "ms", engine->engineState.injectorLag, 2);
@ -296,12 +296,12 @@ static void printSensors(Logging *log, bool fileFormat) {
reportSensorF(log, fileFormat, GAUGE_NAME_FUEL_TPS_EXTRA, "ms", engine->engineState.tpsAccelEnrich, 2); reportSensorF(log, fileFormat, GAUGE_NAME_FUEL_TPS_EXTRA, "ms", engine->engineState.tpsAccelEnrich, 2);
reportSensorF(log, fileFormat, "f: el delta", "v", engine->engineLoadAccelEnrichment.getMaxDelta(), 2); reportSensorF(log, fileFormat, "f: el delta", "v", engine->engineLoadAccelEnrichment.getMaxDelta(), 2);
if (hasMapSensor(PASS_ENGINE_PARAMETER_F)) { if (hasMapSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
reportSensorF(log, fileFormat, "f: el fuel", "v", engine->engineLoadAccelEnrichment.getEngineLoadEnrichment(PASS_ENGINE_PARAMETER_F) * 100 / getMap(), 2); reportSensorF(log, fileFormat, "f: el fuel", "v", engine->engineLoadAccelEnrichment.getEngineLoadEnrichment(PASS_ENGINE_PARAMETER_SIGNATURE) * 100 / getMap(), 2);
} }
reportSensorF(log, fileFormat, GAUGE_NAME_FUEL_INJ_DUTY, "%", getInjectorDutyCycle(rpm PASS_ENGINE_PARAMETER), 2); reportSensorF(log, fileFormat, GAUGE_NAME_FUEL_INJ_DUTY, "%", getInjectorDutyCycle(rpm PASS_ENGINE_PARAMETER_SUFFIX), 2);
reportSensorF(log, fileFormat, GAUGE_NAME_DWELL_DUTY, "%", getCoilDutyCycle(rpm PASS_ENGINE_PARAMETER), 2); reportSensorF(log, fileFormat, GAUGE_NAME_DWELL_DUTY, "%", getCoilDutyCycle(rpm PASS_ENGINE_PARAMETER_SUFFIX), 2);
} }
@ -516,9 +516,9 @@ static void showFuelInfo2(float rpm, float engineLoad) {
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__) #if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
scheduleMsg(&logger, "base cranking fuel %f", engineConfiguration->cranking.baseFuel); scheduleMsg(&logger, "base cranking fuel %f", engineConfiguration->cranking.baseFuel);
scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(PASS_ENGINE_PARAMETER_F)); scheduleMsg(&logger2, "cranking fuel: %f", getCrankingFuel(PASS_ENGINE_PARAMETER_SIGNATURE));
if (engine->rpmCalculator.isRunning(PASS_ENGINE_PARAMETER_F)) { if (engine->rpmCalculator.isRunning(PASS_ENGINE_PARAMETER_SIGNATURE)) {
float iatCorrection = engine->engineState.iatFuelCorrection; float iatCorrection = engine->engineState.iatFuelCorrection;
float cltCorrection = engine->engineState.cltFuelCorrection; float cltCorrection = engine->engineState.cltFuelCorrection;
floatms_t injectorLag = engine->engineState.injectorLag; floatms_t injectorLag = engine->engineState.injectorLag;
@ -528,7 +528,7 @@ static void showFuelInfo2(float rpm, float engineLoad) {
scheduleMsg(&logger2, "iatCorrection=%f cltCorrection=%f injectorLag=%f", iatCorrection, cltCorrection, scheduleMsg(&logger2, "iatCorrection=%f cltCorrection=%f injectorLag=%f", iatCorrection, cltCorrection,
injectorLag); injectorLag);
float value = getRunningFuel(baseFuelMs PASS_ENGINE_PARAMETER); float value = getRunningFuel(baseFuelMs PASS_ENGINE_PARAMETER_SUFFIX);
scheduleMsg(&logger2, "injection pulse width: %f", value); scheduleMsg(&logger2, "injection pulse width: %f", value);
} }
#endif #endif
@ -536,7 +536,7 @@ static void showFuelInfo2(float rpm, float engineLoad) {
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__) #if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
static void showFuelInfo(void) { static void showFuelInfo(void) {
showFuelInfo2((float) getRpmE(engine), getEngineLoadT(PASS_ENGINE_PARAMETER_F)); showFuelInfo2((float) getRpmE(engine), getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE));
} }
#endif #endif
@ -662,18 +662,18 @@ extern int invalidResponsesCount;
#if EFI_TUNER_STUDIO || defined(__DOXYGEN__) #if EFI_TUNER_STUDIO || defined(__DOXYGEN__)
void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_ENGINE_PARAMETER_S) { void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_ENGINE_PARAMETER_SUFFIX) {
#if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__) #if EFI_SHAFT_POSITION_INPUT || defined(__DOXYGEN__)
int rpm = getRpmE(engine); int rpm = getRpmE(engine);
#else #else
int rpm = 0; int rpm = 0;
#endif #endif
float tps = getTPS(PASS_ENGINE_PARAMETER_F); float tps = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE);
float coolant = getCoolantTemperature(PASS_ENGINE_PARAMETER_F); float coolant = getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE);
float intake = getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F); float intake = getIntakeAirTemperature(PASS_ENGINE_PARAMETER_SIGNATURE);
float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_F); float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE);
// header // header
tsOutputChannels->tsConfigVersion = TS_FILE_VERSION; tsOutputChannels->tsConfigVersion = TS_FILE_VERSION;
@ -683,21 +683,21 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_
tsOutputChannels->coolantTemperature = coolant; tsOutputChannels->coolantTemperature = coolant;
tsOutputChannels->intakeAirTemperature = intake; tsOutputChannels->intakeAirTemperature = intake;
tsOutputChannels->throttlePositon = tps; tsOutputChannels->throttlePositon = tps;
tsOutputChannels->massAirFlowVoltage = hasMafSensor() ? getMaf(PASS_ENGINE_PARAMETER_F) : 0; tsOutputChannels->massAirFlowVoltage = hasMafSensor() ? getMaf(PASS_ENGINE_PARAMETER_SIGNATURE) : 0;
tsOutputChannels->massAirFlow = hasMafSensor() ? getRealMaf(PASS_ENGINE_PARAMETER_F) : 0; tsOutputChannels->massAirFlow = hasMafSensor() ? getRealMaf(PASS_ENGINE_PARAMETER_SIGNATURE) : 0;
if (hasMapSensor(PASS_ENGINE_PARAMETER_F)) { if (hasMapSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
float mapValue = getMap(); float mapValue = getMap();
tsOutputChannels->veValue = veMap.getValue(rpm, mapValue); tsOutputChannels->veValue = veMap.getValue(rpm, mapValue);
// todo: bug here? target afr could work based on real MAF? // todo: bug here? target afr could work based on real MAF?
tsOutputChannels->currentTargetAfr = afrMap.getValue(rpm, mapValue); tsOutputChannels->currentTargetAfr = afrMap.getValue(rpm, mapValue);
tsOutputChannels->manifoldAirPressure = mapValue; tsOutputChannels->manifoldAirPressure = mapValue;
} }
tsOutputChannels->airFuelRatio = getAfr(PASS_ENGINE_PARAMETER_F); tsOutputChannels->airFuelRatio = getAfr(PASS_ENGINE_PARAMETER_SIGNATURE);
if (hasVBatt(PASS_ENGINE_PARAMETER_F)) { if (hasVBatt(PASS_ENGINE_PARAMETER_SIGNATURE)) {
tsOutputChannels->vBatt = getVBatt(PASS_ENGINE_PARAMETER_F); tsOutputChannels->vBatt = getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
tsOutputChannels->tpsADC = getTPS12bitAdc(PASS_ENGINE_PARAMETER_F) / TPS_TS_CONVERSION; tsOutputChannels->tpsADC = getTPS12bitAdc(PASS_ENGINE_PARAMETER_SIGNATURE) / TPS_TS_CONVERSION;
#if EFI_ANALOG_SENSORS || defined(__DOXYGEN__) #if EFI_ANALOG_SENSORS || defined(__DOXYGEN__)
tsOutputChannels->baroPressure = hasBaroSensor() ? getBaroPressure() : 0; tsOutputChannels->baroPressure = hasBaroSensor() ? getBaroPressure() : 0;
#endif /* EFI_ANALOG_SENSORS */ #endif /* EFI_ANALOG_SENSORS */
@ -705,7 +705,7 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_
tsOutputChannels->rpmAcceleration = engine->rpmCalculator.getRpmAcceleration(); tsOutputChannels->rpmAcceleration = engine->rpmCalculator.getRpmAcceleration();
tsOutputChannels->triggerErrorsCounter = engine->triggerCentral.triggerState.totalTriggerErrorCounter; tsOutputChannels->triggerErrorsCounter = engine->triggerCentral.triggerState.totalTriggerErrorCounter;
tsOutputChannels->baroCorrection = engine->engineState.baroCorrection; tsOutputChannels->baroCorrection = engine->engineState.baroCorrection;
tsOutputChannels->pedalPosition = hasPedalPositionSensor(PASS_ENGINE_PARAMETER_F) ? getPedalPosition(PASS_ENGINE_PARAMETER_F) : 0; tsOutputChannels->pedalPosition = hasPedalPositionSensor(PASS_ENGINE_PARAMETER_SIGNATURE) ? getPedalPosition(PASS_ENGINE_PARAMETER_SIGNATURE) : 0;
tsOutputChannels->knockCount = engine->knockCount; tsOutputChannels->knockCount = engine->knockCount;
tsOutputChannels->knockLevel = engine->knockVolts; tsOutputChannels->knockLevel = engine->knockVolts;
tsOutputChannels->fuelTankGauge = engine->sensors.fuelTankGauge; tsOutputChannels->fuelTankGauge = engine->sensors.fuelTankGauge;
@ -713,14 +713,14 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_
tsOutputChannels->hasFatalError = hasFirmwareError(); tsOutputChannels->hasFatalError = hasFirmwareError();
tsOutputChannels->totalTriggerErrorCounter = engine->triggerCentral.triggerState.totalTriggerErrorCounter; tsOutputChannels->totalTriggerErrorCounter = engine->triggerCentral.triggerState.totalTriggerErrorCounter;
tsOutputChannels->injectorDutyCycle = getInjectorDutyCycle(rpm PASS_ENGINE_PARAMETER); tsOutputChannels->injectorDutyCycle = getInjectorDutyCycle(rpm PASS_ENGINE_PARAMETER_SUFFIX);
tsOutputChannels->fuelRunning = ENGINE(engineState.runningFuel); tsOutputChannels->fuelRunning = ENGINE(engineState.runningFuel);
tsOutputChannels->fuelPidCorrection = ENGINE(engineState.fuelPidCorrection); tsOutputChannels->fuelPidCorrection = ENGINE(engineState.fuelPidCorrection);
tsOutputChannels->injectorLagMs = ENGINE(engineState.injectorLag); tsOutputChannels->injectorLagMs = ENGINE(engineState.injectorLag);
tsOutputChannels->fuelBase = engine->engineState.baseFuel; tsOutputChannels->fuelBase = engine->engineState.baseFuel;
tsOutputChannels->actualLastInjection = ENGINE(actualLastInjection); tsOutputChannels->actualLastInjection = ENGINE(actualLastInjection);
tsOutputChannels->coilDutyCycle = getCoilDutyCycle(rpm PASS_ENGINE_PARAMETER); tsOutputChannels->coilDutyCycle = getCoilDutyCycle(rpm PASS_ENGINE_PARAMETER_SUFFIX);
efitimesec_t now = getTimeNowSeconds(); efitimesec_t now = getTimeNowSeconds();
tsOutputChannels->timeSeconds = now; tsOutputChannels->timeSeconds = now;
@ -774,8 +774,8 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_
tsOutputChannels->deltaTps = engine->tpsAccelEnrichment.getMaxDelta(); tsOutputChannels->deltaTps = engine->tpsAccelEnrichment.getMaxDelta();
tsOutputChannels->tpsAccelFuel = engine->engineState.tpsAccelEnrich; tsOutputChannels->tpsAccelFuel = engine->engineState.tpsAccelEnrich;
// engine load acceleration // engine load acceleration
if (hasMapSensor(PASS_ENGINE_PARAMETER_F)) { if (hasMapSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
tsOutputChannels->engineLoadAccelExtra = engine->engineLoadAccelEnrichment.getEngineLoadEnrichment(PASS_ENGINE_PARAMETER_F) * 100 / getMap(); tsOutputChannels->engineLoadAccelExtra = engine->engineLoadAccelEnrichment.getEngineLoadEnrichment(PASS_ENGINE_PARAMETER_SIGNATURE) * 100 / getMap();
} }
tsOutputChannels->engineLoadDelta = engine->engineLoadAccelEnrichment.getMaxDelta(); tsOutputChannels->engineLoadDelta = engine->engineLoadAccelEnrichment.getMaxDelta();
@ -787,7 +787,7 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_
tsOutputChannels->vvtPosition = engine->triggerCentral.vvtPosition; tsOutputChannels->vvtPosition = engine->triggerCentral.vvtPosition;
tsOutputChannels->engineMode = packEngineMode(PASS_ENGINE_PARAMETER_F); tsOutputChannels->engineMode = packEngineMode(PASS_ENGINE_PARAMETER_SIGNATURE);
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
tsOutputChannels->internalMcuTemperature = getMCUInternalTemperature(); tsOutputChannels->internalMcuTemperature = getMCUInternalTemperature();
@ -819,8 +819,8 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_
tsOutputChannels->speedToRpmRatio = vehicleSpeed / rpm; tsOutputChannels->speedToRpmRatio = vehicleSpeed / rpm;
#endif /* EFI_VEHICLE_SPEED */ #endif /* EFI_VEHICLE_SPEED */
tsOutputChannels->isCltError = !isValidCoolantTemperature(getCoolantTemperature(PASS_ENGINE_PARAMETER_F)); tsOutputChannels->isCltError = !isValidCoolantTemperature(getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE));
tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F)); tsOutputChannels->isIatError = !isValidIntakeAirTemperature(getIntakeAirTemperature(PASS_ENGINE_PARAMETER_SIGNATURE));
#endif /* EFI_PROD_CODE */ #endif /* EFI_PROD_CODE */
tsOutputChannels->warningCounter = engine->engineState.warningCounter; tsOutputChannels->warningCounter = engine->engineState.warningCounter;
@ -833,11 +833,11 @@ void updateTunerStudioState(TunerStudioOutputChannels *tsOutputChannels DECLARE_
tsOutputChannels->clutchDownState = engine->clutchDownState; tsOutputChannels->clutchDownState = engine->clutchDownState;
tsOutputChannels->brakePedalState = engine->brakePedalState; tsOutputChannels->brakePedalState = engine->brakePedalState;
tsOutputChannels->tCharge = getTCharge(rpm, tps, coolant, intake PASS_ENGINE_PARAMETER); tsOutputChannels->tCharge = getTCharge(rpm, tps, coolant, intake PASS_ENGINE_PARAMETER_SUFFIX);
float timing = engine->engineState.timingAdvance; float timing = engine->engineState.timingAdvance;
tsOutputChannels->ignitionAdvance = timing > 360 ? timing - 720 : timing; tsOutputChannels->ignitionAdvance = timing > 360 ? timing - 720 : timing;
tsOutputChannels->sparkDwell = ENGINE(engineState.sparkDwell); tsOutputChannels->sparkDwell = ENGINE(engineState.sparkDwell);
tsOutputChannels->crankingFuelMs = engine->isCylinderCleanupMode ? 0 : getCrankingFuel(PASS_ENGINE_PARAMETER_F); tsOutputChannels->crankingFuelMs = engine->isCylinderCleanupMode ? 0 : getCrankingFuel(PASS_ENGINE_PARAMETER_SIGNATURE);
tsOutputChannels->chargeAirMass = engine->engineState.airMass; tsOutputChannels->chargeAirMass = engine->engineState.airMass;
} }
@ -845,7 +845,7 @@ extern TunerStudioOutputChannels tsOutputChannels;
void prepareTunerStudioOutputs(void) { void prepareTunerStudioOutputs(void) {
// sensor state for EFI Analytics Tuner Studio // sensor state for EFI Analytics Tuner Studio
updateTunerStudioState(&tsOutputChannels PASS_ENGINE_PARAMETER); updateTunerStudioState(&tsOutputChannels PASS_ENGINE_PARAMETER_SUFFIX);
} }
#endif /* EFI_TUNER_STUDIO */ #endif /* EFI_TUNER_STUDIO */

28
firmware/controllers/algo/accel_enrichment.cpp
View File

@ -47,7 +47,7 @@ void WallFuel::reset() {
memset(wallFuel, 0, sizeof(wallFuel)); memset(wallFuel, 0, sizeof(wallFuel));
} }
floatms_t WallFuel::adjust(int injectorIndex, floatms_t target DECLARE_ENGINE_PARAMETER_S) { floatms_t WallFuel::adjust(int injectorIndex, floatms_t target DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (cisnan(target)) { if (cisnan(target)) {
return target; return target;
} }
@ -70,7 +70,7 @@ floatms_t WallFuel::getWallFuel(int injectorIndex) {
return wallFuel[injectorIndex]; return wallFuel[injectorIndex];
} }
int AccelEnrichmemnt::getMaxDeltaIndex(DECLARE_ENGINE_PARAMETER_F) { int AccelEnrichmemnt::getMaxDeltaIndex(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int len = minI(cb.getSize(), cb.getCount()); int len = minI(cb.getSize(), cb.getCount());
if (len < 2) if (len < 2)
@ -93,15 +93,15 @@ int AccelEnrichmemnt::getMaxDeltaIndex(DECLARE_ENGINE_PARAMETER_F) {
return resultIndex; return resultIndex;
} }
float AccelEnrichmemnt::getMaxDelta(DECLARE_ENGINE_PARAMETER_F) { float AccelEnrichmemnt::getMaxDelta(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int index = getMaxDeltaIndex(PASS_ENGINE_PARAMETER_F); int index = getMaxDeltaIndex(PASS_ENGINE_PARAMETER_SIGNATURE);
return (cb.get(index) - (cb.get(index - 1))) * CONFIG(specs.cylindersCount); return (cb.get(index) - (cb.get(index - 1))) * CONFIG(specs.cylindersCount);
} }
// todo: eliminate code duplication between these two methods! Some pointer magic would help. // todo: eliminate code duplication between these two methods! Some pointer magic would help.
floatms_t AccelEnrichmemnt::getTpsEnrichment(DECLARE_ENGINE_PARAMETER_F) { floatms_t AccelEnrichmemnt::getTpsEnrichment(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int index = getMaxDeltaIndex(PASS_ENGINE_PARAMETER_F); int index = getMaxDeltaIndex(PASS_ENGINE_PARAMETER_SIGNATURE);
// FuelSchedule *fs = engine->engineConfiguration2->injectionEvents; // FuelSchedule *fs = engine->engineConfiguration2->injectionEvents;
float tpsTo = cb.get(index); float tpsTo = cb.get(index);
@ -132,8 +132,8 @@ floatms_t AccelEnrichmemnt::getTpsEnrichment(DECLARE_ENGINE_PARAMETER_F) {
return extraFuel; return extraFuel;
} }
float AccelEnrichmemnt::getEngineLoadEnrichment(DECLARE_ENGINE_PARAMETER_F) { float AccelEnrichmemnt::getEngineLoadEnrichment(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int index = getMaxDeltaIndex(PASS_ENGINE_PARAMETER_F); int index = getMaxDeltaIndex(PASS_ENGINE_PARAMETER_SIGNATURE);
float d = (cb.get(index) - (cb.get(index - 1))) * CONFIG(specs.cylindersCount); float d = (cb.get(index) - (cb.get(index - 1))) * CONFIG(specs.cylindersCount);
@ -173,16 +173,16 @@ void AccelEnrichmemnt::setLength(int length) {
cb.setSize(length); cb.setSize(length);
} }
void AccelEnrichmemnt::onNewValue(float currentValue DECLARE_ENGINE_PARAMETER_S) { void AccelEnrichmemnt::onNewValue(float currentValue DECLARE_ENGINE_PARAMETER_SUFFIX) {
cb.add(currentValue); cb.add(currentValue);
} }
void AccelEnrichmemnt::onEngineCycleTps(DECLARE_ENGINE_PARAMETER_F) { void AccelEnrichmemnt::onEngineCycleTps(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
onNewValue(getTPS(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER); onNewValue(getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX);
} }
void AccelEnrichmemnt::onEngineCycle(DECLARE_ENGINE_PARAMETER_F) { void AccelEnrichmemnt::onEngineCycle(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
onNewValue(getEngineLoadT(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER); onNewValue(getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX);
} }
AccelEnrichmemnt::AccelEnrichmemnt() { AccelEnrichmemnt::AccelEnrichmemnt() {
@ -266,7 +266,7 @@ void updateAccelParameters() {
#endif /* ! EFI_UNIT_TEST */ #endif /* ! EFI_UNIT_TEST */
void initAccelEnrichment(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) { void initAccelEnrichment(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) {
logger = sharedLogger; logger = sharedLogger;
tpsTpsMap.init(config->tpsTpsAccelTable, config->tpsTpsAccelFromRpmBins, config->tpsTpsAccelToRpmBins); tpsTpsMap.init(config->tpsTpsAccelTable, config->tpsTpsAccelFromRpmBins, config->tpsTpsAccelToRpmBins);

16
firmware/controllers/algo/advance_map.cpp
View File

@ -55,14 +55,14 @@ static const ignition_table_t defaultIatTiming = {
{-4.4, -4.9, -5.9, -5.9, -5.9, -5.9, -4.9, -4.9, -4.9, -4.9, -4.9, -3.9, -3.9, -3.9, -3.9, -3.9}, {-4.4, -4.9, -5.9, -5.9, -5.9, -5.9, -4.9, -4.9, -4.9, -4.9, -4.9, -3.9, -3.9, -3.9, -3.9, -3.9},
}; };
bool isStep1Condition(int rpm DECLARE_ENGINE_PARAMETER_S) { bool isStep1Condition(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
return boardConfiguration->enabledStep1Limiter && rpm >= engineConfiguration->step1rpm; return boardConfiguration->enabledStep1Limiter && rpm >= engineConfiguration->step1rpm;
} }
/** /**
* @return ignition timing angle advance before TDC * @return ignition timing angle advance before TDC
*/ */
static angle_t getRunningAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAMETER_S) { static angle_t getRunningAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAMETER_SUFFIX) {
engine->m.beforeAdvance = GET_TIMESTAMP(); engine->m.beforeAdvance = GET_TIMESTAMP();
if (cisnan(engineLoad)) { if (cisnan(engineLoad)) {
warning(CUSTOM_NAN_ENGINE_LOAD, "NaN engine load"); warning(CUSTOM_NAN_ENGINE_LOAD, "NaN engine load");
@ -73,7 +73,7 @@ static angle_t getRunningAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAME
engine->m.beforeZeroTest = GET_TIMESTAMP(); engine->m.beforeZeroTest = GET_TIMESTAMP();
engine->m.zeroTestTime = GET_TIMESTAMP() - engine->m.beforeZeroTest; engine->m.zeroTestTime = GET_TIMESTAMP() - engine->m.beforeZeroTest;
if (isStep1Condition(rpm PASS_ENGINE_PARAMETER)) { if (isStep1Condition(rpm PASS_ENGINE_PARAMETER_SUFFIX)) {
return engineConfiguration->step1timing; return engineConfiguration->step1timing;
} }
@ -99,13 +99,13 @@ static angle_t getRunningAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAME
return result; return result;
} }
angle_t getAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAMETER_S) { angle_t getAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAMETER_SUFFIX) {
angle_t angle; angle_t angle;
if (isCrankingR(rpm)) { if (isCrankingR(rpm)) {
angle = engineConfiguration->crankingTimingAngle; angle = engineConfiguration->crankingTimingAngle;
} else { } else {
if (CONFIG(timingMode) == TM_DYNAMIC) { if (CONFIG(timingMode) == TM_DYNAMIC) {
angle = getRunningAdvance(rpm, engineLoad PASS_ENGINE_PARAMETER); angle = getRunningAdvance(rpm, engineLoad PASS_ENGINE_PARAMETER_SUFFIX);
} else { } else {
angle = engineConfiguration->fixedTiming; angle = engineConfiguration->fixedTiming;
} }
@ -115,13 +115,13 @@ angle_t getAdvance(int rpm, float engineLoad DECLARE_ENGINE_PARAMETER_S) {
return angle; return angle;
} }
void setDefaultIatTimingCorrection(DECLARE_ENGINE_PARAMETER_F) { void setDefaultIatTimingCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setTableBin2(config->ignitionIatCorrLoadBins, IGN_LOAD_COUNT, -40, 110, 1); setTableBin2(config->ignitionIatCorrLoadBins, IGN_LOAD_COUNT, -40, 110, 1);
memcpy(config->ignitionIatCorrRpmBins, iatTimingRpmBins, sizeof(iatTimingRpmBins)); memcpy(config->ignitionIatCorrRpmBins, iatTimingRpmBins, sizeof(iatTimingRpmBins));
copyTimingTable(defaultIatTiming, config->ignitionIatCorrTable); copyTimingTable(defaultIatTiming, config->ignitionIatCorrTable);
} }
void prepareTimingMap(DECLARE_ENGINE_PARAMETER_F) { void prepareTimingMap(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
advanceMap.init(config->ignitionTable, config->ignitionLoadBins, advanceMap.init(config->ignitionTable, config->ignitionLoadBins,
config->ignitionRpmBins); config->ignitionRpmBins);
iatAdvanceCorrectionMap.init(config->ignitionIatCorrTable, config->ignitionIatCorrLoadBins, iatAdvanceCorrectionMap.init(config->ignitionIatCorrTable, config->ignitionIatCorrLoadBins,
@ -190,7 +190,7 @@ float getInitialAdvance(int rpm, float map, float advanceMax) {
/** /**
* this method builds a good-enough base timing advance map bases on a number of heuristics * this method builds a good-enough base timing advance map bases on a number of heuristics
*/ */
void buildTimingMap(float advanceMax DECLARE_ENGINE_PARAMETER_S) { void buildTimingMap(float advanceMax DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (engineConfiguration->fuelAlgorithm != LM_SPEED_DENSITY && if (engineConfiguration->fuelAlgorithm != LM_SPEED_DENSITY &&
engineConfiguration->fuelAlgorithm != LM_MAP) { engineConfiguration->fuelAlgorithm != LM_MAP) {
warning(CUSTOM_WRONG_ALGORITHM, "wrong algorithm for MAP-based timing"); warning(CUSTOM_WRONG_ALGORITHM, "wrong algorithm for MAP-based timing");

52
firmware/controllers/algo/engine.cpp
View File

@ -60,12 +60,12 @@ int MockAdcState::getMockAdcValue(int hwChannel) {
* We are executing these heavy (logarithm) methods from outside the trigger callbacks for performance reasons. * We are executing these heavy (logarithm) methods from outside the trigger callbacks for performance reasons.
* See also periodicFastCallback * See also periodicFastCallback
*/ */
void Engine::updateSlowSensors(DECLARE_ENGINE_PARAMETER_F) { void Engine::updateSlowSensors(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int rpm = rpmCalculator.rpmValue; int rpm = rpmCalculator.rpmValue;
isEngineChartEnabled = CONFIG(isEngineChartEnabled) && rpm < CONFIG(engineSnifferRpmThreshold); isEngineChartEnabled = CONFIG(isEngineChartEnabled) && rpm < CONFIG(engineSnifferRpmThreshold);
sensorChartMode = rpm < CONFIG(sensorSnifferRpmThreshold) ? boardConfiguration->sensorChartMode : SC_OFF; sensorChartMode = rpm < CONFIG(sensorSnifferRpmThreshold) ? boardConfiguration->sensorChartMode : SC_OFF;
engineState.updateSlowSensors(PASS_ENGINE_PARAMETER_F); engineState.updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE);
if (engineConfiguration->fuelLevelSensor != EFI_ADC_NONE) { if (engineConfiguration->fuelLevelSensor != EFI_ADC_NONE) {
float fuelLevelVoltage = getVoltageDivided("fuel", engineConfiguration->fuelLevelSensor); float fuelLevelVoltage = getVoltageDivided("fuel", engineConfiguration->fuelLevelSensor);
@ -73,9 +73,9 @@ void Engine::updateSlowSensors(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->fuelLevelFullTankVoltage, 100, boardConfiguration->fuelLevelFullTankVoltage, 100,
fuelLevelVoltage); fuelLevelVoltage);
} }
sensors.vBatt = hasVBatt(PASS_ENGINE_PARAMETER_F) ? getVBatt(PASS_ENGINE_PARAMETER_F) : 12; sensors.vBatt = hasVBatt(PASS_ENGINE_PARAMETER_SIGNATURE) ? getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE) : 12;
engineState.injectorLag = getInjectorLag(sensors.vBatt PASS_ENGINE_PARAMETER); engineState.injectorLag = getInjectorLag(sensors.vBatt PASS_ENGINE_PARAMETER_SUFFIX);
} }
void Engine::onTriggerEvent(efitick_t nowNt) { void Engine::onTriggerEvent(efitick_t nowNt) {
@ -163,15 +163,15 @@ EngineState::EngineState() {
totalLoggedBytes = injectionOffset = 0; totalLoggedBytes = injectionOffset = 0;
} }
void EngineState::updateSlowSensors(DECLARE_ENGINE_PARAMETER_F) { void EngineState::updateSlowSensors(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engine->sensors.iat = getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F); engine->sensors.iat = getIntakeAirTemperature(PASS_ENGINE_PARAMETER_SIGNATURE);
engine->sensors.clt = getCoolantTemperature(PASS_ENGINE_PARAMETER_F); engine->sensors.clt = getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE);
warmupTargetAfr = interpolate2d(engine->sensors.clt, engineConfiguration->warmupTargetAfrBins, warmupTargetAfr = interpolate2d(engine->sensors.clt, engineConfiguration->warmupTargetAfrBins,
engineConfiguration->warmupTargetAfr, WARMUP_TARGET_AFR_SIZE); engineConfiguration->warmupTargetAfr, WARMUP_TARGET_AFR_SIZE);
} }
void EngineState::periodicFastCallback(DECLARE_ENGINE_PARAMETER_F) { void EngineState::periodicFastCallback(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int rpm = ENGINE(rpmCalculator.rpmValue); int rpm = ENGINE(rpmCalculator.rpmValue);
efitick_t nowNt = getTimeNowNt(); efitick_t nowNt = getTimeNowNt();
@ -181,12 +181,12 @@ void EngineState::periodicFastCallback(DECLARE_ENGINE_PARAMETER_F) {
timeSinceCranking = nowNt - crankingTime; timeSinceCranking = nowNt - crankingTime;
} }
sparkDwell = getSparkDwell(rpm PASS_ENGINE_PARAMETER); sparkDwell = getSparkDwell(rpm PASS_ENGINE_PARAMETER_SUFFIX);
dwellAngle = sparkDwell / getOneDegreeTimeMs(rpm); dwellAngle = sparkDwell / getOneDegreeTimeMs(rpm);
engine->sensors.currentAfr = getAfr(PASS_ENGINE_PARAMETER_F); engine->sensors.currentAfr = getAfr(PASS_ENGINE_PARAMETER_SIGNATURE);
// todo: move this into slow callback, no reason for IAT corr to be here // todo: move this into slow callback, no reason for IAT corr to be here
iatFuelCorrection = getIatFuelCorrection(engine->sensors.iat PASS_ENGINE_PARAMETER); iatFuelCorrection = getIatFuelCorrection(engine->sensors.iat PASS_ENGINE_PARAMETER_SUFFIX);
// todo: move this into slow callback, no reason for CLT corr to be here // todo: move this into slow callback, no reason for CLT corr to be here
if (boardConfiguration->useWarmupPidAfr && engine->sensors.clt < engineConfiguration->warmupAfrThreshold) { if (boardConfiguration->useWarmupPidAfr && engine->sensors.clt < engineConfiguration->warmupAfrThreshold) {
if (rpm < 200) { if (rpm < 200) {
@ -203,25 +203,25 @@ void EngineState::periodicFastCallback(DECLARE_ENGINE_PARAMETER_F) {
#endif #endif
} else { } else {
cltFuelCorrection = getCltFuelCorrection(PASS_ENGINE_PARAMETER_F); cltFuelCorrection = getCltFuelCorrection(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
cltTimingCorrection = getCltTimingCorrection(PASS_ENGINE_PARAMETER_F); cltTimingCorrection = getCltTimingCorrection(PASS_ENGINE_PARAMETER_SIGNATURE);
engineNoiseHipLevel = interpolate2d(rpm, engineConfiguration->knockNoiseRpmBins, engineNoiseHipLevel = interpolate2d(rpm, engineConfiguration->knockNoiseRpmBins,
engineConfiguration->knockNoise, ENGINE_NOISE_CURVE_SIZE); engineConfiguration->knockNoise, ENGINE_NOISE_CURVE_SIZE);
baroCorrection = getBaroCorrection(PASS_ENGINE_PARAMETER_F); baroCorrection = getBaroCorrection(PASS_ENGINE_PARAMETER_SIGNATURE);
injectionOffset = getinjectionOffset(rpm PASS_ENGINE_PARAMETER); injectionOffset = getinjectionOffset(rpm PASS_ENGINE_PARAMETER_SUFFIX);
float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_F); float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE);
timingAdvance = getAdvance(rpm, engineLoad PASS_ENGINE_PARAMETER); timingAdvance = getAdvance(rpm, engineLoad PASS_ENGINE_PARAMETER_SUFFIX);
if (engineConfiguration->fuelAlgorithm == LM_SPEED_DENSITY) { if (engineConfiguration->fuelAlgorithm == LM_SPEED_DENSITY) {
float coolantC = ENGINE(sensors.clt); float coolantC = ENGINE(sensors.clt);
float intakeC = ENGINE(sensors.iat); float intakeC = ENGINE(sensors.iat);
float tps = getTPS(PASS_ENGINE_PARAMETER_F); float tps = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE);
tChargeK = convertCelsiusToKelvin(getTCharge(rpm, tps, coolantC, intakeC PASS_ENGINE_PARAMETER)); tChargeK = convertCelsiusToKelvin(getTCharge(rpm, tps, coolantC, intakeC PASS_ENGINE_PARAMETER_SUFFIX));
float map = getMap(); float map = getMap();
/** /**
@ -335,7 +335,7 @@ void Engine::watchdog() {
#endif #endif
} }
injection_mode_e Engine::getCurrentInjectionMode(DECLARE_ENGINE_PARAMETER_F) { injection_mode_e Engine::getCurrentInjectionMode(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int rpm = rpmCalculator.rpmValue; int rpm = rpmCalculator.rpmValue;
return isCrankingR(rpm) ? CONFIG(crankingInjectionMode) : CONFIG(injectionMode); return isCrankingR(rpm) ? CONFIG(crankingInjectionMode) : CONFIG(injectionMode);
} }
@ -344,7 +344,7 @@ injection_mode_e Engine::getCurrentInjectionMode(DECLARE_ENGINE_PARAMETER_F) {
* The idea of this method is to execute all heavy calculations in a lower-priority thread, * The idea of this method is to execute all heavy calculations in a lower-priority thread,
* so that trigger event handler/IO scheduler tasks are faster. * so that trigger event handler/IO scheduler tasks are faster.
*/ */
void Engine::periodicFastCallback(DECLARE_ENGINE_PARAMETER_F) { void Engine::periodicFastCallback(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int rpm = rpmCalculator.rpmValue; int rpm = rpmCalculator.rpmValue;
if (isValidRpm(rpm)) { if (isValidRpm(rpm)) {
@ -367,10 +367,10 @@ void Engine::periodicFastCallback(DECLARE_ENGINE_PARAMETER_F) {
engine->engineState.mapAveragingDuration = NAN; engine->engineState.mapAveragingDuration = NAN;
} }
engineState.periodicFastCallback(PASS_ENGINE_PARAMETER_F); engineState.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
engine->m.beforeFuelCalc = GET_TIMESTAMP(); engine->m.beforeFuelCalc = GET_TIMESTAMP();
ENGINE(fuelMs) = getInjectionDuration(rpm PASS_ENGINE_PARAMETER) * engineConfiguration->globalFuelCorrection; ENGINE(fuelMs) = getInjectionDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX) * engineConfiguration->globalFuelCorrection;
engine->m.fuelCalcTime = GET_TIMESTAMP() - engine->m.beforeFuelCalc; engine->m.fuelCalcTime = GET_TIMESTAMP() - engine->m.beforeFuelCalc;
} }
@ -393,9 +393,9 @@ void StartupFuelPumping::setPumpsCounter(int newValue) {
} }
} }
void StartupFuelPumping::update(DECLARE_ENGINE_PARAMETER_F) { void StartupFuelPumping::update(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
if (engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F) == 0) { if (engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE) == 0) {
bool isTpsAbove50 = getTPS(PASS_ENGINE_PARAMETER_F) >= 50; bool isTpsAbove50 = getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) >= 50;
if (this->isTpsAbove50 != isTpsAbove50) { if (this->isTpsAbove50 != isTpsAbove50) {
setPumpsCounter(pumpsCounter + 1); setPumpsCounter(pumpsCounter + 1);

196
firmware/controllers/algo/engine_configuration.cpp
View File

@ -150,7 +150,7 @@ int getGlobalConfigurationVersion(void) {
* this is the top-level method which should be called in case of any changes to engine configuration * this is the top-level method which should be called in case of any changes to engine configuration
* online tuning of most values in the maps does not count as configuration change, but 'Burn' command does * online tuning of most values in the maps does not count as configuration change, but 'Burn' command does
*/ */
void incrementGlobalConfigurationVersion(DECLARE_ENGINE_PARAMETER_F) { void incrementGlobalConfigurationVersion(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
globalConfigurationVersion++; globalConfigurationVersion++;
/** /**
* All these callbacks could be implemented as listeners, but these days I am saving RAM * All these callbacks could be implemented as listeners, but these days I am saving RAM
@ -168,7 +168,7 @@ void incrementGlobalConfigurationVersion(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* @brief Sets the same dwell time across the whole getRpm() range * @brief Sets the same dwell time across the whole getRpm() range
*/ */
void setConstantDwell(floatms_t dwellMs DECLARE_ENGINE_PARAMETER_S) { void setConstantDwell(floatms_t dwellMs DECLARE_ENGINE_PARAMETER_SUFFIX) {
for (int i = 0; i < DWELL_CURVE_SIZE; i++) { for (int i = 0; i < DWELL_CURVE_SIZE; i++) {
engineConfiguration->sparkDwellRpmBins[i] = 1000 * i; engineConfiguration->sparkDwellRpmBins[i] = 1000 * i;
engineConfiguration->sparkDwellValues[i] = dwellMs; engineConfiguration->sparkDwellValues[i] = dwellMs;
@ -191,19 +191,19 @@ void setMap(fuel_table_t table, float value) {
} }
} }
static void setWholeVEMap(float value DECLARE_ENGINE_PARAMETER_S) { static void setWholeVEMap(float value DECLARE_ENGINE_PARAMETER_SUFFIX) {
setMap(config->veTable, value); setMap(config->veTable, value);
} }
void setWholeFuelMap(float value DECLARE_ENGINE_PARAMETER_S) { void setWholeFuelMap(float value DECLARE_ENGINE_PARAMETER_SUFFIX) {
setMap(config->fuelTable, value); setMap(config->fuelTable, value);
} }
void setWholeIgnitionIatCorr(float value DECLARE_ENGINE_PARAMETER_S) { void setWholeIgnitionIatCorr(float value DECLARE_ENGINE_PARAMETER_SUFFIX) {
setMap(config->ignitionIatCorrTable, value); setMap(config->ignitionIatCorrTable, value);
} }
void setFuelTablesLoadBin(float minValue, float maxValue DECLARE_ENGINE_PARAMETER_S) { void setFuelTablesLoadBin(float minValue, float maxValue DECLARE_ENGINE_PARAMETER_SUFFIX) {
setTableBin2(config->injPhaseLoadBins, FUEL_LOAD_COUNT, minValue, maxValue, 1); setTableBin2(config->injPhaseLoadBins, FUEL_LOAD_COUNT, minValue, maxValue, 1);
setTableBin2(config->veLoadBins, FUEL_LOAD_COUNT, minValue, maxValue, 1); setTableBin2(config->veLoadBins, FUEL_LOAD_COUNT, minValue, maxValue, 1);
setTableBin2(config->afrLoadBins, FUEL_LOAD_COUNT, minValue, maxValue, 1); setTableBin2(config->afrLoadBins, FUEL_LOAD_COUNT, minValue, maxValue, 1);
@ -217,14 +217,14 @@ void setTimingMap(ignition_table_t map, float value) {
} }
} }
void setWholeIatCorrTimingTable(float value DECLARE_ENGINE_PARAMETER_S) { void setWholeIatCorrTimingTable(float value DECLARE_ENGINE_PARAMETER_SUFFIX) {
setTimingMap(config->ignitionIatCorrTable, value); setTimingMap(config->ignitionIatCorrTable, value);
} }
/** /**
* See also crankingTimingAngle * See also crankingTimingAngle
*/ */
void setWholeTimingTable(angle_t value DECLARE_ENGINE_PARAMETER_S) { void setWholeTimingTable(angle_t value DECLARE_ENGINE_PARAMETER_SUFFIX) {
setTimingMap(config->ignitionTable, value); setTimingMap(config->ignitionTable, value);
} }
@ -329,7 +329,7 @@ void prepareVoidConfiguration(engine_configuration_s *activeConfiguration) {
boardConfiguration->ignitionPinMode = OM_DEFAULT; boardConfiguration->ignitionPinMode = OM_DEFAULT;
} }
void setDefaultBasePins(DECLARE_ENGINE_PARAMETER_F) { void setDefaultBasePins(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engineConfiguration->fatalErrorPin = GPIOD_14; engineConfiguration->fatalErrorPin = GPIOD_14;
engineConfiguration->warninigPin = GPIOD_13; engineConfiguration->warninigPin = GPIOD_13;
engineConfiguration->configResetPin = GPIOB_1; engineConfiguration->configResetPin = GPIOB_1;
@ -337,7 +337,7 @@ void setDefaultBasePins(DECLARE_ENGINE_PARAMETER_F) {
// todo: move injector calibration somewhere else? // todo: move injector calibration somewhere else?
// todo: add a enum? if we have enough data? // todo: add a enum? if we have enough data?
static void setBosch02880155868(DECLARE_ENGINE_PARAMETER_F) { static void setBosch02880155868(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
// http://www.boschdealer.com/specsheets/0280155868cs.jpg // http://www.boschdealer.com/specsheets/0280155868cs.jpg
engineConfiguration->injector.battLagCorrBins[0] = 6; engineConfiguration->injector.battLagCorrBins[0] = 6;
engineConfiguration->injector.battLagCorr[0] = 3.371; engineConfiguration->injector.battLagCorr[0] = 3.371;
@ -364,7 +364,7 @@ static void setBosch02880155868(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->injector.battLagCorr[7] = 0.726; engineConfiguration->injector.battLagCorr[7] = 0.726;
} }
static void setDefaultWarmupIdleCorrection(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultWarmupIdleCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
initTemperatureCurve(CLT_CURVE_SIZE, config->cltIdleCorrBins, config->cltIdleCorr, PERCENT_MULT); initTemperatureCurve(CLT_CURVE_SIZE, config->cltIdleCorrBins, config->cltIdleCorr, PERCENT_MULT);
float baseIdle = 30; float baseIdle = 30;
@ -383,7 +383,7 @@ static void setDefaultWarmupIdleCorrection(DECLARE_ENGINE_PARAMETER_F) {
setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 70, 33.0 / baseIdle * 100); setTableValue(config->cltIdleCorrBins, config->cltIdleCorr, CLT_CURVE_SIZE, 70, 33.0 / baseIdle * 100);
} }
static void setDefaultWarmupFuelEnrichment(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultWarmupFuelEnrichment(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
initTemperatureCurve(CLT_CURVE_SIZE, config->cltFuelCorrBins, config->cltFuelCorr, PERCENT_MULT); initTemperatureCurve(CLT_CURVE_SIZE, config->cltFuelCorrBins, config->cltFuelCorr, PERCENT_MULT);
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -40, 150); setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, -40, 150);
@ -400,7 +400,7 @@ static void setDefaultWarmupFuelEnrichment(DECLARE_ENGINE_PARAMETER_F) {
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 70, 101); setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 70, 101);
} }
static void setDefaultCrankingSettings(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultCrankingSettings(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setTableBin2(engineConfiguration->crankingTpsCoef, CRANKING_CURVE_SIZE, 1, 1, 1); setTableBin2(engineConfiguration->crankingTpsCoef, CRANKING_CURVE_SIZE, 1, 1, 1);
setTableBin2(engineConfiguration->crankingTpsBins, CRANKING_CURVE_SIZE, 0, 100, 1); setTableBin2(engineConfiguration->crankingTpsBins, CRANKING_CURVE_SIZE, 0, 100, 1);
@ -444,7 +444,7 @@ static void setDefaultCrankingSettings(DECLARE_ENGINE_PARAMETER_F) {
} }
static void setDefaultIdleSpeedTarget(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultIdleSpeedTarget(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
// todo: set bins // todo: set bins
setTableValue(engineConfiguration->cltIdleRpmBins, engineConfiguration->cltIdleRpm, CLT_CURVE_SIZE, -30, 1350); setTableValue(engineConfiguration->cltIdleRpmBins, engineConfiguration->cltIdleRpm, CLT_CURVE_SIZE, -30, 1350);
setTableValue(engineConfiguration->cltIdleRpmBins, engineConfiguration->cltIdleRpm, CLT_CURVE_SIZE, -20, 1300); setTableValue(engineConfiguration->cltIdleRpmBins, engineConfiguration->cltIdleRpm, CLT_CURVE_SIZE, -20, 1300);
@ -464,7 +464,7 @@ static void setDefaultIdleSpeedTarget(DECLARE_ENGINE_PARAMETER_F) {
} }
static void setDefaultStepperIdleParameters(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultStepperIdleParameters(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
boardConfiguration->idle.stepperDirectionPin = GPIOE_10; boardConfiguration->idle.stepperDirectionPin = GPIOE_10;
boardConfiguration->idle.stepperStepPin = GPIOE_12; boardConfiguration->idle.stepperStepPin = GPIOE_12;
engineConfiguration->stepperEnablePin = GPIOE_14; engineConfiguration->stepperEnablePin = GPIOE_14;
@ -472,7 +472,7 @@ static void setDefaultStepperIdleParameters(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->idleStepperTotalSteps = 150; engineConfiguration->idleStepperTotalSteps = 150;
} }
static void setDefaultFsioParameters(DECLARE_ENGINE_PARAMETER_F) { static void setDefaultFsioParameters(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
for (int i = 0; i < AUX_PID_COUNT; i++) { for (int i = 0; i < AUX_PID_COUNT; i++) {
engineConfiguration->auxPidPins[i] = GPIO_UNASSIGNED; engineConfiguration->auxPidPins[i] = GPIO_UNASSIGNED;
} }
@ -484,7 +484,7 @@ static void setDefaultFsioParameters(DECLARE_ENGINE_PARAMETER_F) {
} }
} }
static void setCanDefaults(DECLARE_ENGINE_PARAMETER_F) { static void setCanDefaults(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
boardConfiguration->canDeviceMode = CD_USE_CAN2; boardConfiguration->canDeviceMode = CD_USE_CAN2;
boardConfiguration->canTxPin = GPIOB_6; boardConfiguration->canTxPin = GPIOB_6;
boardConfiguration->canRxPin = GPIOB_12; boardConfiguration->canRxPin = GPIOB_12;
@ -509,7 +509,7 @@ static void setCanDefaults(DECLARE_ENGINE_PARAMETER_F) {
* This method should only change the state of the configuration data structure but should NOT change the state of * This method should only change the state of the configuration data structure but should NOT change the state of
* anything else. * anything else.
*/ */
void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) { void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
#if (! EFI_UNIT_TEST) || defined(__DOXYGEN__) #if (! EFI_UNIT_TEST) || defined(__DOXYGEN__)
memset(&persistentState.persistentConfiguration, 0, sizeof(persistentState.persistentConfiguration)); memset(&persistentState.persistentConfiguration, 0, sizeof(persistentState.persistentConfiguration));
#endif #endif
@ -520,7 +520,7 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->startConsoleInBinaryMode = true; boardConfiguration->startConsoleInBinaryMode = true;
setBosch02880155868(PASS_ENGINE_PARAMETER_F); setBosch02880155868(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->acCutoffLowRpm = 700; engineConfiguration->acCutoffLowRpm = 700;
engineConfiguration->acCutoffHighRpm = 5000; engineConfiguration->acCutoffHighRpm = 5000;
@ -542,19 +542,19 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
setTableBin2(engineConfiguration->cltTimingBins, CLT_TIMING_CURVE_SIZE, -40, 120, 1); setTableBin2(engineConfiguration->cltTimingBins, CLT_TIMING_CURVE_SIZE, -40, 120, 1);
setTableBin2(engineConfiguration->cltTimingExtra, CLT_TIMING_CURVE_SIZE, 0, 0, 1); setTableBin2(engineConfiguration->cltTimingExtra, CLT_TIMING_CURVE_SIZE, 0, 0, 1);
setDefaultWarmupIdleCorrection(PASS_ENGINE_PARAMETER_F); setDefaultWarmupIdleCorrection(PASS_ENGINE_PARAMETER_SIGNATURE);
setDefaultWarmupFuelEnrichment(PASS_ENGINE_PARAMETER_F); setDefaultWarmupFuelEnrichment(PASS_ENGINE_PARAMETER_SIGNATURE);
setConstantDwell(4 PASS_ENGINE_PARAMETER); // 4ms is global default dwell setConstantDwell(4 PASS_ENGINE_PARAMETER_SUFFIX); // 4ms is global default dwell
// disable constant_dwell // disable constant_dwell
engineConfiguration->useConstantDwellDuringCranking = false; engineConfiguration->useConstantDwellDuringCranking = false;
engineConfiguration->ignitionDwellForCrankingMs = 6; engineConfiguration->ignitionDwellForCrankingMs = 6;
setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setFuelLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setFuelRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER); setTimingLoadBin(1.2, 4.4 PASS_ENGINE_PARAMETER_SUFFIX);
setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER); setTimingRpmBin(800, 7000 PASS_ENGINE_PARAMETER_SUFFIX);
setTableBin2(engineConfiguration->map.samplingAngleBins, MAP_ANGLE_SIZE, 800, 7000, 1); setTableBin2(engineConfiguration->map.samplingAngleBins, MAP_ANGLE_SIZE, 800, 7000, 1);
setTableBin2(engineConfiguration->map.samplingAngle, MAP_ANGLE_SIZE, 100, 130, 1); setTableBin2(engineConfiguration->map.samplingAngle, MAP_ANGLE_SIZE, 100, 130, 1);
@ -562,15 +562,15 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
setTableBin2(engineConfiguration->map.samplingWindow, MAP_ANGLE_SIZE, 50, 50, 1); setTableBin2(engineConfiguration->map.samplingWindow, MAP_ANGLE_SIZE, 50, 50, 1);
// set_whole_timing_map 3 // set_whole_timing_map 3
setWholeFuelMap(3 PASS_ENGINE_PARAMETER); setWholeFuelMap(3 PASS_ENGINE_PARAMETER_SUFFIX);
setAfrMap(config->afrTable, 14.7); setAfrMap(config->afrTable, 14.7);
setDefaultVETable(PASS_ENGINE_PARAMETER_F); setDefaultVETable(PASS_ENGINE_PARAMETER_SIGNATURE);
setMap(config->injectionPhase, -180); setMap(config->injectionPhase, -180);
setRpmTableBin(config->injPhaseRpmBins, FUEL_RPM_COUNT); setRpmTableBin(config->injPhaseRpmBins, FUEL_RPM_COUNT);
setFuelTablesLoadBin(10, 160 PASS_ENGINE_PARAMETER); setFuelTablesLoadBin(10, 160 PASS_ENGINE_PARAMETER_SUFFIX);
setDefaultIatTimingCorrection(PASS_ENGINE_PARAMETER_F); setDefaultIatTimingCorrection(PASS_ENGINE_PARAMETER_SIGNATURE);
setTableBin2(engineConfiguration->mapAccelTaperBins, FSIO_TABLE_8, 0, 32, 4); setTableBin2(engineConfiguration->mapAccelTaperBins, FSIO_TABLE_8, 0, 32, 4);
setTableBin2(engineConfiguration->mapAccelTaperMult, FSIO_TABLE_8, 1, 1, 1); setTableBin2(engineConfiguration->mapAccelTaperMult, FSIO_TABLE_8, 1, 1, 1);
@ -587,7 +587,7 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
setTableBin2(config->fsioTable4LoadBins, FSIO_TABLE_8, 20, 120, 10); setTableBin2(config->fsioTable4LoadBins, FSIO_TABLE_8, 20, 120, 10);
setRpmTableBin(config->fsioTable4RpmBins, FSIO_TABLE_8); setRpmTableBin(config->fsioTable4RpmBins, FSIO_TABLE_8);
initEngineNoiseTable(PASS_ENGINE_PARAMETER_F); initEngineNoiseTable(PASS_ENGINE_PARAMETER_SIGNATURE);
setThermistorConfiguration(&engineConfiguration->clt, 0, 9500, 23.8889, 2100, 48.8889, 1000); setThermistorConfiguration(&engineConfiguration->clt, 0, 9500, 23.8889, 2100, 48.8889, 1000);
engineConfiguration->clt.config.bias_resistor = 1500; engineConfiguration->clt.config.bias_resistor = 1500;
@ -628,7 +628,7 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->noAccelAfterHardLimitPeriodSecs = 3; engineConfiguration->noAccelAfterHardLimitPeriodSecs = 3;
setDefaultCrankingSettings(PASS_ENGINE_PARAMETER_F); setDefaultCrankingSettings(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->warmupTargetAfrBins[0] = -12; engineConfiguration->warmupTargetAfrBins[0] = -12;
engineConfiguration->warmupTargetAfr[0] = 12.3; engineConfiguration->warmupTargetAfr[0] = 12.3;
@ -639,7 +639,7 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->warmupTargetAfrBins[3] = 60; engineConfiguration->warmupTargetAfrBins[3] = 60;
engineConfiguration->warmupTargetAfr[3] = 14.5; engineConfiguration->warmupTargetAfr[3] = 14.5;
setDefaultIdleSpeedTarget(PASS_ENGINE_PARAMETER_F); setDefaultIdleSpeedTarget(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->fuelClosedLoopCorrectionEnabled = false; engineConfiguration->fuelClosedLoopCorrectionEnabled = false;
@ -723,7 +723,7 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
engineConfiguration->cylinderBore = 87.5; engineConfiguration->cylinderBore = 87.5;
setEgoSensor(ES_14Point7_Free PASS_ENGINE_PARAMETER); setEgoSensor(ES_14Point7_Free PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->globalFuelCorrection = 1; engineConfiguration->globalFuelCorrection = 1;
@ -751,7 +751,7 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->useSerialPort = true; boardConfiguration->useSerialPort = true;
boardConfiguration->useStepperIdle = false; boardConfiguration->useStepperIdle = false;
setDefaultStepperIdleParameters(PASS_ENGINE_PARAMETER_F); setDefaultStepperIdleParameters(PASS_ENGINE_PARAMETER_SIGNATURE);
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
@ -796,13 +796,13 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->max31855_cs[i] = GPIO_UNASSIGNED; boardConfiguration->max31855_cs[i] = GPIO_UNASSIGNED;
} }
setDefaultFsioParameters(PASS_ENGINE_PARAMETER_F); setDefaultFsioParameters(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->alternatorPwmFrequency = 300; engineConfiguration->alternatorPwmFrequency = 300;
engineConfiguration->communicationPin = GPIOD_15; // blue LED on discovery engineConfiguration->communicationPin = GPIOD_15; // blue LED on discovery
engineConfiguration->runningPin = GPIOD_12; // greeb LED on discovery engineConfiguration->runningPin = GPIOD_12; // greeb LED on discovery
setDefaultBasePins(PASS_ENGINE_PARAMETER_F); setDefaultBasePins(PASS_ENGINE_PARAMETER_SIGNATURE);
engineConfiguration->binarySerialTxPin = GPIOC_10; engineConfiguration->binarySerialTxPin = GPIOC_10;
engineConfiguration->binarySerialRxPin = GPIOC_11; engineConfiguration->binarySerialRxPin = GPIOC_11;
engineConfiguration->consoleSerialTxPin = GPIOC_10; engineConfiguration->consoleSerialTxPin = GPIOC_10;
@ -852,7 +852,7 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
boardConfiguration->boardTestModeJumperPin = GPIOB_0; boardConfiguration->boardTestModeJumperPin = GPIOB_0;
setCanDefaults(PASS_ENGINE_PARAMETER_F); setCanDefaults(PASS_ENGINE_PARAMETER_SIGNATURE);
// set this to SPI_DEVICE_3 to enable stimulation // set this to SPI_DEVICE_3 to enable stimulation
@ -910,12 +910,12 @@ void setDefaultConfiguration(DECLARE_ENGINE_PARAMETER_F) {
#endif #endif
} }
void resetConfigurationExt(Logging * logger, engine_type_e engineType DECLARE_ENGINE_PARAMETER_S) { void resetConfigurationExt(Logging * logger, engine_type_e engineType DECLARE_ENGINE_PARAMETER_SUFFIX) {
enginePins.reset(); // that's mostly important for functional tests enginePins.reset(); // that's mostly important for functional tests
/** /**
* Let's apply global defaults first * Let's apply global defaults first
*/ */
setDefaultConfiguration(PASS_ENGINE_PARAMETER_F); setDefaultConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
#if EFI_SIMULATOR || defined(__DOXYGEN__) #if EFI_SIMULATOR || defined(__DOXYGEN__)
engineConfiguration->directSelfStimulation = true; engineConfiguration->directSelfStimulation = true;
#endif /* */ #endif /* */
@ -926,34 +926,34 @@ void resetConfigurationExt(Logging * logger, engine_type_e engineType DECLARE_EN
*/ */
switch (engineType) { switch (engineType) {
case CUSTOM_ENGINE: case CUSTOM_ENGINE:
setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_F); setCustomEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case ACURA_RSX: case ACURA_RSX:
setAcuraRSX(engineConfiguration); setAcuraRSX(engineConfiguration);
break; break;
#if EFI_SUPPORT_DODGE_NEON || defined(__DOXYGEN__) #if EFI_SUPPORT_DODGE_NEON || defined(__DOXYGEN__)
case DODGE_NEON_1995: case DODGE_NEON_1995:
setDodgeNeon1995EngineConfiguration(PASS_ENGINE_PARAMETER_F); setDodgeNeon1995EngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case DODGE_NEON_2003_CAM: case DODGE_NEON_2003_CAM:
setDodgeNeonNGCEngineConfiguration(PASS_ENGINE_PARAMETER_F); setDodgeNeonNGCEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case DODGE_NEON_2003_CRANK: case DODGE_NEON_2003_CRANK:
setDodgeNeonNGCEngineConfigurationCrankBased(PASS_ENGINE_PARAMETER_F); setDodgeNeonNGCEngineConfigurationCrankBased(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case LADA_KALINA: case LADA_KALINA:
setLadaKalina(PASS_ENGINE_PARAMETER_F); setLadaKalina(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
#endif /* EFI_SUPPORT_DODGE_NEON */ #endif /* EFI_SUPPORT_DODGE_NEON */
#if EFI_SUPPORT_FORD_ASPIRE || defined(__DOXYGEN__) #if EFI_SUPPORT_FORD_ASPIRE || defined(__DOXYGEN__)
case FORD_ASPIRE_1996: case FORD_ASPIRE_1996:
setFordAspireEngineConfiguration(PASS_ENGINE_PARAMETER_F); setFordAspireEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
#endif /* EFI_SUPPORT_FORD_ASPIRE */ #endif /* EFI_SUPPORT_FORD_ASPIRE */
#if EFI_SUPPORT_FORD_FIESTA || defined(__DOXYGEN__) #if EFI_SUPPORT_FORD_FIESTA || defined(__DOXYGEN__)
case FORD_FIESTA: case FORD_FIESTA:
setFordFiestaDefaultEngineConfiguration(PASS_ENGINE_PARAMETER_F); setFordFiestaDefaultEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
#endif /* EFI_SUPPORT_FORD_FIESTA */ #endif /* EFI_SUPPORT_FORD_FIESTA */
#if EFI_SUPPORT_NISSAN_PRIMERA || defined(__DOXYGEN__) #if EFI_SUPPORT_NISSAN_PRIMERA || defined(__DOXYGEN__)
@ -962,109 +962,109 @@ void resetConfigurationExt(Logging * logger, engine_type_e engineType DECLARE_EN
break; break;
#endif #endif
case HONDA_ACCORD_CD: case HONDA_ACCORD_CD:
setHondaAccordConfigurationThreeWires(PASS_ENGINE_PARAMETER_F); setHondaAccordConfigurationThreeWires(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case ZIL_130: case ZIL_130:
setZil130(PASS_ENGINE_PARAMETER_F); setZil130(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MIATA_NA_1_6: case MIATA_NA_1_6:
setMiataNA_1_6_Configuration(PASS_ENGINE_PARAMETER_F); setMiataNA_1_6_Configuration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case TEST_CIVIC_4_0_BOTH: case TEST_CIVIC_4_0_BOTH:
setHondaCivic4_0_both(PASS_ENGINE_PARAMETER_F); setHondaCivic4_0_both(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case TEST_CIVIC_4_0_RISE: case TEST_CIVIC_4_0_RISE:
setHondaCivic4_0_rise(PASS_ENGINE_PARAMETER_F); setHondaCivic4_0_rise(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case HONDA_ACCORD_CD_TWO_WIRES: case HONDA_ACCORD_CD_TWO_WIRES:
setHondaAccordConfiguration1_24(PASS_ENGINE_PARAMETER_F); setHondaAccordConfiguration1_24(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case HONDA_ACCORD_1_24_SHIFTED: case HONDA_ACCORD_1_24_SHIFTED:
setHondaAccordConfiguration1_24_shifted(PASS_ENGINE_PARAMETER_F); setHondaAccordConfiguration1_24_shifted(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case FRANKENSO_QA_ENGINE: case FRANKENSO_QA_ENGINE:
setFrankensoBoardTestConfiguration(PASS_ENGINE_PARAMETER_F); setFrankensoBoardTestConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case HONDA_ACCORD_CD_DIP: case HONDA_ACCORD_CD_DIP:
setHondaAccordConfigurationDip(PASS_ENGINE_PARAMETER_F); setHondaAccordConfigurationDip(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MITSU_4G93: case MITSU_4G93:
setMitsubishiConfiguration(PASS_ENGINE_PARAMETER_F); setMitsubishiConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
#if EFI_SUPPORT_1995_FORD_INLINE_6 || defined(__DOXYGEN__) #if EFI_SUPPORT_1995_FORD_INLINE_6 || defined(__DOXYGEN__)
case FORD_INLINE_6_1995: case FORD_INLINE_6_1995:
setFordInline6(PASS_ENGINE_PARAMETER_F); setFordInline6(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
#endif /* EFI_SUPPORT_1995_FORD_INLINE_6 */ #endif /* EFI_SUPPORT_1995_FORD_INLINE_6 */
case GY6_139QMB: case GY6_139QMB:
setGy6139qmbDefaultEngineConfiguration(PASS_ENGINE_PARAMETER_F); setGy6139qmbDefaultEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case HONDA_600: case HONDA_600:
setHonda600(PASS_ENGINE_PARAMETER_F); setHonda600(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MAZDA_MIATA_NB1: case MAZDA_MIATA_NB1:
setMazdaMiataNb1EngineConfiguration(PASS_ENGINE_PARAMETER_F); setMazdaMiataNb1EngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MAZDA_323: case MAZDA_323:
setMazda323EngineConfiguration(engineConfiguration); setMazda323EngineConfiguration(engineConfiguration);
break; break;
case MAZDA_626: case MAZDA_626:
setMazda626EngineConfiguration(PASS_ENGINE_PARAMETER_F); setMazda626EngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case SATURN_ION_2004: case SATURN_ION_2004:
setSaturnIonEngineConfiguration(engineConfiguration); setSaturnIonEngineConfiguration(engineConfiguration);
break; break;
case SUZUKI_VITARA: case SUZUKI_VITARA:
setSuzukiVitara(PASS_ENGINE_PARAMETER_F); setSuzukiVitara(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MINI_COOPER_R50: case MINI_COOPER_R50:
setMiniCooperR50(engineConfiguration); setMiniCooperR50(engineConfiguration);
break; break;
case FORD_ESCORT_GT: case FORD_ESCORT_GT:
setFordEscortGt(PASS_ENGINE_PARAMETER_F); setFordEscortGt(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MIATA_1990: case MIATA_1990:
setMiata1990(PASS_ENGINE_PARAMETER_F); setMiata1990(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MIATA_1994_DEVIATOR: case MIATA_1994_DEVIATOR:
setMiata1994_d(PASS_ENGINE_PARAMETER_F); setMiata1994_d(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MIATA_1994_SPAGS: case MIATA_1994_SPAGS:
setMiata1994_s(PASS_ENGINE_PARAMETER_F); setMiata1994_s(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MIATA_1996: case MIATA_1996:
setMiata1996(PASS_ENGINE_PARAMETER_F); setMiata1996(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case CITROEN_TU3JP: case CITROEN_TU3JP:
setCitroenBerlingoTU3JPConfiguration(PASS_ENGINE_PARAMETER_F); setCitroenBerlingoTU3JPConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case ROVER_V8: case ROVER_V8:
setRoverv8(PASS_ENGINE_PARAMETER_F); setRoverv8(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case SUBARU_2003_WRX: case SUBARU_2003_WRX:
setSubaru2003Wrx(PASS_ENGINE_PARAMETER_F); setSubaru2003Wrx(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case BMW_E34: case BMW_E34:
setBmwE34(PASS_ENGINE_PARAMETER_F); setBmwE34(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case GM_2_2: case GM_2_2:
setGm2_2(PASS_ENGINE_PARAMETER_F); setGm2_2(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case DODGE_RAM: case DODGE_RAM:
setDodgeRam1996(PASS_ENGINE_PARAMETER_F); setDodgeRam1996(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case DODGE_STRATUS: case DODGE_STRATUS:
setDodgeStratus(PASS_ENGINE_PARAMETER_F); setDodgeStratus(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case VW_ABA: case VW_ABA:
setVwAba(PASS_ENGINE_PARAMETER_F); setVwAba(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
case TEST_ISSUE_366_BOTH: case TEST_ISSUE_366_BOTH:
setTestEngineIssue366both(PASS_ENGINE_PARAMETER_F); setTestEngineIssue366both(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case TEST_ISSUE_366_RISE: case TEST_ISSUE_366_RISE:
setTestEngineIssue366rise(PASS_ENGINE_PARAMETER_F); setTestEngineIssue366rise(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
#else #else
case TEST_ISSUE_366_BOTH: case TEST_ISSUE_366_BOTH:
@ -1072,46 +1072,46 @@ void resetConfigurationExt(Logging * logger, engine_type_e engineType DECLARE_EN
#endif #endif
case TEST_ENGINE: case TEST_ENGINE:
setTestEngineConfiguration(PASS_ENGINE_PARAMETER_F); setTestEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MAZDA_MIATA_2003: case MAZDA_MIATA_2003:
setMazdaMiata2003EngineConfiguration(PASS_ENGINE_PARAMETER_F); setMazdaMiata2003EngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case MAZDA_MIATA_2003_BETTER: case MAZDA_MIATA_2003_BETTER:
setMazdaMiata2003EngineConfigurationNewBoard(PASS_ENGINE_PARAMETER_F); setMazdaMiata2003EngineConfigurationNewBoard(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case PROMETHEUS_DEFAULTS: case PROMETHEUS_DEFAULTS:
setPrometheusDefaults(PASS_ENGINE_PARAMETER_F); setPrometheusDefaults(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case TEST_ENGINE_VVT: case TEST_ENGINE_VVT:
setTestVVTEngineConfiguration(PASS_ENGINE_PARAMETER_F); setTestVVTEngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case SACHS: case SACHS:
setSachs(PASS_ENGINE_PARAMETER_F); setSachs(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case DAIHATSU: case DAIHATSU:
setDaihatsu(PASS_ENGINE_PARAMETER_F); setDaihatsu(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case CAMARO_4: case CAMARO_4:
setCamaro4(PASS_ENGINE_PARAMETER_F); setCamaro4(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case CHEVY_C20_1973: case CHEVY_C20_1973:
set1973c20(PASS_ENGINE_PARAMETER_F); set1973c20(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case TOYOTA_2JZ_GTE_VVTi: case TOYOTA_2JZ_GTE_VVTi:
setToyota_2jz_vics(PASS_ENGINE_PARAMETER_F); setToyota_2jz_vics(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case TOYOTA_JZS147: case TOYOTA_JZS147:
setToyota_jzs147EngineConfiguration(PASS_ENGINE_PARAMETER_F); setToyota_jzs147EngineConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
case GEO_STORM: case GEO_STORM:
setGeoStormConfiguration(PASS_ENGINE_PARAMETER_F); setGeoStormConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
break; break;
default: default:
warning(CUSTOM_UNEXPECTED_ENGINE_TYPE, "Unexpected engine type: %d", engineType); warning(CUSTOM_UNEXPECTED_ENGINE_TYPE, "Unexpected engine type: %d", engineType);
} }
applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER); applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER_SUFFIX);
// todo: eliminate triggerShape.operationMode? // todo: eliminate triggerShape.operationMode?
if (engineConfiguration->operationMode != TRIGGER_SHAPE(getOperationMode())) { if (engineConfiguration->operationMode != TRIGGER_SHAPE(getOperationMode())) {
warning(CUSTOM_ERR_OP_MODE, "operationMode %d/trigger mismatch %d", warning(CUSTOM_ERR_OP_MODE, "operationMode %d/trigger mismatch %d",
@ -1124,16 +1124,16 @@ void resetConfigurationExt(Logging * logger, engine_type_e engineType DECLARE_EN
#endif #endif
} }
void applyNonPersistentConfiguration(Logging * logger DECLARE_ENGINE_PARAMETER_S) { void applyNonPersistentConfiguration(Logging * logger DECLARE_ENGINE_PARAMETER_SUFFIX) {
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 256, "apply c"); efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 256, "apply c");
scheduleMsg(logger, "applyNonPersistentConfiguration()"); scheduleMsg(logger, "applyNonPersistentConfiguration()");
#endif #endif
assertEngineReference(PASS_ENGINE_PARAMETER_F); assertEngineReference(PASS_ENGINE_PARAMETER_SIGNATURE);
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__) #if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
engine->triggerCentral.triggerShape.initializeTriggerShape(logger PASS_ENGINE_PARAMETER); engine->triggerCentral.triggerShape.initializeTriggerShape(logger PASS_ENGINE_PARAMETER_SUFFIX);
#endif #endif
if (engine->triggerCentral.triggerShape.getSize() == 0) { if (engine->triggerCentral.triggerShape.getSize() == 0) {
firmwareError(CUSTOM_ERR_TRIGGER_ZERO, "triggerShape size is zero"); firmwareError(CUSTOM_ERR_TRIGGER_ZERO, "triggerShape size is zero");
@ -1141,16 +1141,16 @@ void applyNonPersistentConfiguration(Logging * logger DECLARE_ENGINE_PARAMETER_S
} }
engine->engineCycleEventCount = engine->triggerCentral.triggerShape.getLength(); engine->engineCycleEventCount = engine->triggerCentral.triggerShape.getLength();
#if EFI_FSIO || defined(__DOXYGEN__) #if EFI_FSIO || defined(__DOXYGEN__)
applyFsioConfiguration(PASS_ENGINE_PARAMETER_F); applyFsioConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
#endif #endif
} }
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__) #if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
void prepareShapes(DECLARE_ENGINE_PARAMETER_F) { void prepareShapes(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
prepareOutputSignals(PASS_ENGINE_PARAMETER_F); prepareOutputSignals(PASS_ENGINE_PARAMETER_SIGNATURE);
engine->injectionEvents.addFuelEvents(PASS_ENGINE_PARAMETER_F); engine->injectionEvents.addFuelEvents(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
#endif #endif

62
firmware/controllers/algo/fuel_math.cpp
View File

@ -50,7 +50,7 @@ extern baroCorr_Map3D_t baroCorrMap;
/** /**
* @return total duration of fuel injection per engine cycle, in milliseconds * @return total duration of fuel injection per engine cycle, in milliseconds
*/ */
float getRealMafFuel(float airSpeed, int rpm DECLARE_ENGINE_PARAMETER_S) { float getRealMafFuel(float airSpeed, int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (rpm == 0) if (rpm == 0)
return 0; return 0;
// duration of engine cycle, in hours // duration of engine cycle, in hours
@ -71,18 +71,18 @@ float getRealMafFuel(float airSpeed, int rpm DECLARE_ENGINE_PARAMETER_S) {
} }
// todo: rename this method since it's now base+TPSaccel // todo: rename this method since it's now base+TPSaccel
floatms_t getBaseFuel(int rpm DECLARE_ENGINE_PARAMETER_S) { floatms_t getBaseFuel(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
floatms_t tpsAccelEnrich = ENGINE(tpsAccelEnrichment.getTpsEnrichment(PASS_ENGINE_PARAMETER_F)); floatms_t tpsAccelEnrich = ENGINE(tpsAccelEnrichment.getTpsEnrichment(PASS_ENGINE_PARAMETER_SIGNATURE));
efiAssert(!cisnan(tpsAccelEnrich), "NaN tpsAccelEnrich", 0); efiAssert(!cisnan(tpsAccelEnrich), "NaN tpsAccelEnrich", 0);
ENGINE(engineState.tpsAccelEnrich) = tpsAccelEnrich; ENGINE(engineState.tpsAccelEnrich) = tpsAccelEnrich;
floatms_t baseFuel; floatms_t baseFuel;
if (CONFIG(fuelAlgorithm) == LM_SPEED_DENSITY) { if (CONFIG(fuelAlgorithm) == LM_SPEED_DENSITY) {
baseFuel = getSpeedDensityFuel(PASS_ENGINE_PARAMETER_F); baseFuel = getSpeedDensityFuel(PASS_ENGINE_PARAMETER_SIGNATURE);
efiAssert(!cisnan(baseFuel), "NaN sd baseFuel", 0); efiAssert(!cisnan(baseFuel), "NaN sd baseFuel", 0);
} else if (engineConfiguration->fuelAlgorithm == LM_REAL_MAF) { } else if (engineConfiguration->fuelAlgorithm == LM_REAL_MAF) {
float maf = getRealMaf(PASS_ENGINE_PARAMETER_F) + engine->engineLoadAccelEnrichment.getEngineLoadEnrichment(PASS_ENGINE_PARAMETER_F); float maf = getRealMaf(PASS_ENGINE_PARAMETER_SIGNATURE) + engine->engineLoadAccelEnrichment.getEngineLoadEnrichment(PASS_ENGINE_PARAMETER_SIGNATURE);
baseFuel = getRealMafFuel(maf, rpm PASS_ENGINE_PARAMETER); baseFuel = getRealMafFuel(maf, rpm PASS_ENGINE_PARAMETER_SUFFIX);
efiAssert(!cisnan(baseFuel), "NaN rm baseFuel", 0); efiAssert(!cisnan(baseFuel), "NaN rm baseFuel", 0);
} else { } else {
baseFuel = engine->engineState.baseTableFuel; baseFuel = engine->engineState.baseTableFuel;
@ -93,8 +93,8 @@ floatms_t getBaseFuel(int rpm DECLARE_ENGINE_PARAMETER_S) {
return tpsAccelEnrich + baseFuel; return tpsAccelEnrich + baseFuel;
} }
angle_t getinjectionOffset(float rpm DECLARE_ENGINE_PARAMETER_S) { angle_t getinjectionOffset(float rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_F); float engineLoad = getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE);
angle_t result = fuelPhaseMap.getValue(rpm, engineLoad) + CONFIG(extraInjectionOffset); angle_t result = fuelPhaseMap.getValue(rpm, engineLoad) + CONFIG(extraInjectionOffset);
fixAngle(result, "inj offset"); fixAngle(result, "inj offset");
return result; return result;
@ -104,7 +104,7 @@ angle_t getinjectionOffset(float rpm DECLARE_ENGINE_PARAMETER_S) {
* Number of injections into each cylinder per engine cycle * Number of injections into each cylinder per engine cycle
* @see getNumberOfSparks * @see getNumberOfSparks
*/ */
int getNumberOfInjections(injection_mode_e mode DECLARE_ENGINE_PARAMETER_S) { int getNumberOfInjections(injection_mode_e mode DECLARE_ENGINE_PARAMETER_SUFFIX) {
switch (mode) { switch (mode) {
case IM_SIMULTANEOUS: case IM_SIMULTANEOUS:
return engineConfiguration->specs.cylindersCount; return engineConfiguration->specs.cylindersCount;
@ -121,31 +121,31 @@ int getNumberOfInjections(injection_mode_e mode DECLARE_ENGINE_PARAMETER_S) {
/** /**
* @see getCoilDutyCycle * @see getCoilDutyCycle
*/ */
percent_t getInjectorDutyCycle(int rpm DECLARE_ENGINE_PARAMETER_S) { percent_t getInjectorDutyCycle(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
floatms_t totalPerCycle = getInjectionDuration(rpm PASS_ENGINE_PARAMETER) * getNumberOfInjections(engineConfiguration->injectionMode PASS_ENGINE_PARAMETER); floatms_t totalPerCycle = getInjectionDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX) * getNumberOfInjections(engineConfiguration->injectionMode PASS_ENGINE_PARAMETER_SUFFIX);
floatms_t engineCycleDuration = getEngineCycleDuration(rpm PASS_ENGINE_PARAMETER); floatms_t engineCycleDuration = getEngineCycleDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX);
return 100 * totalPerCycle / engineCycleDuration; return 100 * totalPerCycle / engineCycleDuration;
} }
/** /**
* @returns Length of each individual fuel injection, in milliseconds * @returns Length of each individual fuel injection, in milliseconds
*/ */
floatms_t getInjectionDuration(int rpm DECLARE_ENGINE_PARAMETER_S) { floatms_t getInjectionDuration(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
float theoreticalInjectionLength; float theoreticalInjectionLength;
bool isCranking = isCrankingR(rpm); bool isCranking = isCrankingR(rpm);
int numberOfCylinders = getNumberOfInjections(isCranking ? int numberOfCylinders = getNumberOfInjections(isCranking ?
engineConfiguration->crankingInjectionMode : engineConfiguration->crankingInjectionMode :
engineConfiguration->injectionMode PASS_ENGINE_PARAMETER); engineConfiguration->injectionMode PASS_ENGINE_PARAMETER_SUFFIX);
if (numberOfCylinders == 0) { if (numberOfCylinders == 0) {
warning(CUSTOM_CONFIG_NOT_READY, "config not ready"); warning(CUSTOM_CONFIG_NOT_READY, "config not ready");
return 0; // we can end up here during configuration reset return 0; // we can end up here during configuration reset
} }
if (isCranking) { if (isCranking) {
theoreticalInjectionLength = getCrankingFuel(PASS_ENGINE_PARAMETER_F) / numberOfCylinders; theoreticalInjectionLength = getCrankingFuel(PASS_ENGINE_PARAMETER_SIGNATURE) / numberOfCylinders;
efiAssert(!cisnan(theoreticalInjectionLength), "NaN cranking theoreticalInjectionLength", 0); efiAssert(!cisnan(theoreticalInjectionLength), "NaN cranking theoreticalInjectionLength", 0);
} else { } else {
floatms_t baseFuel = getBaseFuel(rpm PASS_ENGINE_PARAMETER); floatms_t baseFuel = getBaseFuel(rpm PASS_ENGINE_PARAMETER_SUFFIX);
floatms_t fuelPerCycle = getRunningFuel(baseFuel PASS_ENGINE_PARAMETER); floatms_t fuelPerCycle = getRunningFuel(baseFuel PASS_ENGINE_PARAMETER_SUFFIX);
theoreticalInjectionLength = fuelPerCycle / numberOfCylinders; theoreticalInjectionLength = fuelPerCycle / numberOfCylinders;
efiAssert(!cisnan(theoreticalInjectionLength), "NaN fuelPerCycle", 0); efiAssert(!cisnan(theoreticalInjectionLength), "NaN fuelPerCycle", 0);
#if EFI_PRINTF_FUEL_DETAILS || defined(__DOXYGEN__) #if EFI_PRINTF_FUEL_DETAILS || defined(__DOXYGEN__)
@ -161,7 +161,7 @@ floatms_t getInjectionDuration(int rpm DECLARE_ENGINE_PARAMETER_S) {
return theoreticalInjectionLength + injectorLag; return theoreticalInjectionLength + injectorLag;
} }
floatms_t getRunningFuel(floatms_t baseFuel DECLARE_ENGINE_PARAMETER_S) { floatms_t getRunningFuel(floatms_t baseFuel DECLARE_ENGINE_PARAMETER_SUFFIX) {
float iatCorrection = ENGINE(engineState.iatFuelCorrection); float iatCorrection = ENGINE(engineState.iatFuelCorrection);
float cltCorrection = ENGINE(engineState.cltFuelCorrection); float cltCorrection = ENGINE(engineState.cltFuelCorrection);
efiAssert(!cisnan(iatCorrection), "NaN iatCorrection", 0); efiAssert(!cisnan(iatCorrection), "NaN iatCorrection", 0);
@ -179,7 +179,7 @@ floatms_t getRunningFuel(floatms_t baseFuel DECLARE_ENGINE_PARAMETER_S) {
* @param vBatt Battery voltage. * @param vBatt Battery voltage.
* @return Time in ms for injection opening time based on current battery voltage * @return Time in ms for injection opening time based on current battery voltage
*/ */
floatms_t getInjectorLag(float vBatt DECLARE_ENGINE_PARAMETER_S) { floatms_t getInjectorLag(float vBatt DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (cisnan(vBatt)) { if (cisnan(vBatt)) {
warning(OBD_System_Voltage_Malfunction, "vBatt=%f", vBatt); warning(OBD_System_Voltage_Malfunction, "vBatt=%f", vBatt);
return 0; return 0;
@ -194,7 +194,7 @@ floatms_t getInjectorLag(float vBatt DECLARE_ENGINE_PARAMETER_S) {
* @note this method has nothing to do with fuel map VALUES - it's job * @note this method has nothing to do with fuel map VALUES - it's job
* is to prepare the fuel map data structure for 3d interpolation * is to prepare the fuel map data structure for 3d interpolation
*/ */
void prepareFuelMap(DECLARE_ENGINE_PARAMETER_F) { void prepareFuelMap(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
fuelMap.init(config->fuelTable, config->fuelLoadBins, config->fuelRpmBins); fuelMap.init(config->fuelTable, config->fuelLoadBins, config->fuelRpmBins);
fuelPhaseMap.init(config->injectionPhase, config->injPhaseLoadBins, config->injPhaseRpmBins); fuelPhaseMap.init(config->injectionPhase, config->injPhaseLoadBins, config->injPhaseRpmBins);
} }
@ -202,19 +202,19 @@ void prepareFuelMap(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* @brief Engine warm-up fuel correction. * @brief Engine warm-up fuel correction.
*/ */
float getCltFuelCorrection(DECLARE_ENGINE_PARAMETER_F) { float getCltFuelCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
if (cisnan(engine->sensors.clt)) if (cisnan(engine->sensors.clt))
return 1; // this error should be already reported somewhere else, let's just handle it return 1; // this error should be already reported somewhere else, let's just handle it
return interpolate2d(engine->sensors.clt, config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE) / PERCENT_MULT; return interpolate2d(engine->sensors.clt, config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE) / PERCENT_MULT;
} }
angle_t getCltTimingCorrection(DECLARE_ENGINE_PARAMETER_F) { angle_t getCltTimingCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
if (cisnan(engine->sensors.clt)) if (cisnan(engine->sensors.clt))
return 0; // this error should be already reported somewhere else, let's just handle it return 0; // this error should be already reported somewhere else, let's just handle it
return interpolate2d(engine->sensors.clt, engineConfiguration->cltTimingBins, engineConfiguration->cltTimingExtra, CLT_TIMING_CURVE_SIZE); return interpolate2d(engine->sensors.clt, engineConfiguration->cltTimingBins, engineConfiguration->cltTimingExtra, CLT_TIMING_CURVE_SIZE);
} }
float getIatFuelCorrection(float iat DECLARE_ENGINE_PARAMETER_S) { float getIatFuelCorrection(float iat DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (cisnan(iat)) if (cisnan(iat))
return 1; // this error should be already reported somewhere else, let's just handle it return 1; // this error should be already reported somewhere else, let's just handle it
return interpolate2d(iat, config->iatFuelCorrBins, config->iatFuelCorr, IAT_CURVE_SIZE); return interpolate2d(iat, config->iatFuelCorrBins, config->iatFuelCorr, IAT_CURVE_SIZE);
@ -237,9 +237,9 @@ floatms_t getBaseTableFuel(int rpm, float engineLoad) {
return result; return result;
} }
float getBaroCorrection(DECLARE_ENGINE_PARAMETER_F) { float getBaroCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
if (hasBaroSensor(PASS_ENGINE_PARAMETER_F)) { if (hasBaroSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
return baroCorrMap.getValue(getRpmE(engine), getBaroPressure(PASS_ENGINE_PARAMETER_F)); return baroCorrMap.getValue(getRpmE(engine), getBaroPressure(PASS_ENGINE_PARAMETER_SIGNATURE));
} else { } else {
return 1; return 1;
} }
@ -249,14 +249,14 @@ float getBaroCorrection(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* @return Duration of fuel injection while craning * @return Duration of fuel injection while craning
*/ */
floatms_t getCrankingFuel(DECLARE_ENGINE_PARAMETER_F) { floatms_t getCrankingFuel(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return getCrankingFuel3(getCoolantTemperature(PASS_ENGINE_PARAMETER_F), return getCrankingFuel3(getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE),
engine->rpmCalculator.getRevolutionCounterSinceStart() PASS_ENGINE_PARAMETER); engine->rpmCalculator.getRevolutionCounterSinceStart() PASS_ENGINE_PARAMETER_SUFFIX);
} }
#endif #endif
floatms_t getCrankingFuel3(float coolantTemperature, floatms_t getCrankingFuel3(float coolantTemperature,
uint32_t revolutionCounterSinceStart DECLARE_ENGINE_PARAMETER_S) { uint32_t revolutionCounterSinceStart DECLARE_ENGINE_PARAMETER_SUFFIX) {
// these magic constants are in Celsius // these magic constants are in Celsius
float baseCrankingFuel = engineConfiguration->cranking.baseFuel; float baseCrankingFuel = engineConfiguration->cranking.baseFuel;
if (cisnan(coolantTemperature)) // todo: move this check down, below duration correction? if (cisnan(coolantTemperature)) // todo: move this check down, below duration correction?
@ -267,7 +267,7 @@ floatms_t getCrankingFuel3(float coolantTemperature,
float coolantTempCoef = interpolate2d(coolantTemperature, config->crankingFuelBins, float coolantTempCoef = interpolate2d(coolantTemperature, config->crankingFuelBins,
config->crankingFuelCoef, CRANKING_CURVE_SIZE); config->crankingFuelCoef, CRANKING_CURVE_SIZE);
float tpsCoef = interpolate2d(getTPS(PASS_ENGINE_PARAMETER_F), engineConfiguration->crankingTpsBins, float tpsCoef = interpolate2d(getTPS(PASS_ENGINE_PARAMETER_SIGNATURE), engineConfiguration->crankingTpsBins,
engineConfiguration->crankingTpsCoef, CRANKING_CURVE_SIZE); engineConfiguration->crankingTpsCoef, CRANKING_CURVE_SIZE);
return baseCrankingFuel * durationCoef * coolantTempCoef * tpsCoef; return baseCrankingFuel * durationCoef * coolantTempCoef * tpsCoef;

24
firmware/controllers/algo/idle_controller.cpp
View File

@ -38,7 +38,7 @@ IdleValveState::IdleValveState() {
targetRpmRangeLeft = targetRpmRangeRight = 0; targetRpmRangeLeft = targetRpmRangeRight = 0;
} }
void IdleValveState::init(DECLARE_ENGINE_PARAMETER_F) { void IdleValveState::init(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
setTargetRpm(engineConfiguration->targetIdleRpm); setTargetRpm(engineConfiguration->targetIdleRpm);
} }
@ -63,19 +63,19 @@ static percent_t setNewValue(IdleValveState *idle, int currentRpm, efitimems_t n
return newValue; return newValue;
} }
bool isTpsLockout(DECLARE_ENGINE_PARAMETER_F) { bool isTpsLockout(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
// if we have TPS sensor, then use it // if we have TPS sensor, then use it
if (hasTpsSensor(PASS_ENGINE_PARAMETER_F)) { if (hasTpsSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
return getTPS(PASS_ENGINE_PARAMETER_F) > TPS_IDLE_LOCKOUT; return getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) > TPS_IDLE_LOCKOUT;
} }
// TODO: if no TPS sensor then idle switch is our // TODO: if no TPS sensor then idle switch is our
return true; return true;
} }
static percent_t changeValue(IdleValveState *idle, int currentRpm, int now, const char * msg, percent_t delta DECLARE_ENGINE_PARAMETER_S) { static percent_t changeValue(IdleValveState *idle, int currentRpm, int now, const char * msg, percent_t delta DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (isTpsLockout(PASS_ENGINE_PARAMETER_F)) { if (isTpsLockout(PASS_ENGINE_PARAMETER_SIGNATURE)) {
// We are not supposed to be in idle mode. Don't touch anything // We are not supposed to be in idle mode. Don't touch anything
idleDebug("TPS Lockout, TPS=", getTPS(PASS_ENGINE_PARAMETER_F)); idleDebug("TPS Lockout, TPS=", getTPS(PASS_ENGINE_PARAMETER_SIGNATURE));
return idle->value; return idle->value;
} }
percent_t newValue = idle->value + delta; percent_t newValue = idle->value + delta;
@ -85,7 +85,7 @@ static percent_t changeValue(IdleValveState *idle, int currentRpm, int now, cons
/** /**
* now - current time in milliseconds * now - current time in milliseconds
*/ */
percent_t IdleValveState::getIdle(int currentRpm, efitimems_t now DECLARE_ENGINE_PARAMETER_S) { percent_t IdleValveState::getIdle(int currentRpm, efitimems_t now DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (currentRpm == 0 || isCranking()) { if (currentRpm == 0 || isCranking()) {
// todo: why hard-coded value during cranking // todo: why hard-coded value during cranking
return setNewValue(this, currentRpm, now, "cranking value: ", DEFAULT_IDLE_DUTY); return setNewValue(this, currentRpm, now, "cranking value: ", DEFAULT_IDLE_DUTY);
@ -108,14 +108,14 @@ percent_t IdleValveState::getIdle(int currentRpm, efitimems_t now DECLARE_ENGINE
} }
if (currentRpm >= targetRpmRangeRight + 100) if (currentRpm >= targetRpmRangeRight + 100)
return changeValue(this, currentRpm, now, "idle control: rpm is too high: ", -IDLE_DECREASE_STEP PASS_ENGINE_PARAMETER); return changeValue(this, currentRpm, now, "idle control: rpm is too high: ", -IDLE_DECREASE_STEP PASS_ENGINE_PARAMETER_SUFFIX);
if (currentRpm >= targetRpmRangeRight) if (currentRpm >= targetRpmRangeRight)
return changeValue(this, currentRpm, now, "idle control: rpm is a bit too high: ", -IDLE_DECREASE_SMALL_STEP PASS_ENGINE_PARAMETER); return changeValue(this, currentRpm, now, "idle control: rpm is a bit too high: ", -IDLE_DECREASE_SMALL_STEP PASS_ENGINE_PARAMETER_SUFFIX);
// we are here if RPM is low, let's see how low // we are here if RPM is low, let's see how low
if (currentRpm < targetRpmRangeLeft - 100) { if (currentRpm < targetRpmRangeLeft - 100) {
return changeValue(this, currentRpm, now, "idle control: RPMs are low: ", IDLE_INCREASE_STEP PASS_ENGINE_PARAMETER); return changeValue(this, currentRpm, now, "idle control: RPMs are low: ", IDLE_INCREASE_STEP PASS_ENGINE_PARAMETER_SUFFIX);
} }
return changeValue(this, currentRpm, now, "idle control: RPMs are a bit low: ", IDLE_INCREASE_SMALL_STEP PASS_ENGINE_PARAMETER); return changeValue(this, currentRpm, now, "idle control: RPMs are a bit low: ", IDLE_INCREASE_SMALL_STEP PASS_ENGINE_PARAMETER_SUFFIX);
} }

22
firmware/controllers/core/fsio_impl.cpp
View File

@ -80,15 +80,15 @@ float getLEValue(Engine *engine, calc_stack_t *s, le_action_e action) {
case LE_METHOD_FAN: case LE_METHOD_FAN:
return enginePins.fanRelay.getLogicValue(); return enginePins.fanRelay.getLogicValue();
case LE_METHOD_AC_TOGGLE: case LE_METHOD_AC_TOGGLE:
return getAcToggle(PASS_ENGINE_PARAMETER_F); return getAcToggle(PASS_ENGINE_PARAMETER_SIGNATURE);
case LE_METHOD_COOLANT: case LE_METHOD_COOLANT:
return getCoolantTemperature(PASS_ENGINE_PARAMETER_F); return getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE);
case LE_METHOD_INTAKE_AIR: case LE_METHOD_INTAKE_AIR:
return getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F); return getIntakeAirTemperature(PASS_ENGINE_PARAMETER_SIGNATURE);
case LE_METHOD_RPM: case LE_METHOD_RPM:
return engine->rpmCalculator.getRpm(); return engine->rpmCalculator.getRpm();
case LE_METHOD_MAF: case LE_METHOD_MAF:
return getMaf(PASS_ENGINE_PARAMETER_F); return getMaf(PASS_ENGINE_PARAMETER_SIGNATURE);
case LE_METHOD_MAP: case LE_METHOD_MAP:
return getMap(); return getMap();
case LE_METHOD_INTAKE_VVT: case LE_METHOD_INTAKE_VVT:
@ -101,7 +101,7 @@ float getLEValue(Engine *engine, calc_stack_t *s, le_action_e action) {
case LE_METHOD_FAN_ON_SETTING: case LE_METHOD_FAN_ON_SETTING:
return engineConfiguration->fanOnTemperature; return engineConfiguration->fanOnTemperature;
case LE_METHOD_VBATT: case LE_METHOD_VBATT:
return getVBatt(PASS_ENGINE_PARAMETER_F); return getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE);
default: default:
warning(CUSTOM_FSIO_UNEXPECTED, "FSIO unexpected %d", action); warning(CUSTOM_FSIO_UNEXPECTED, "FSIO unexpected %d", action);
return NAN; return NAN;
@ -170,7 +170,7 @@ static void setFsioOutputPin(const char *indexStr, const char *pinName) {
/** /**
* index is between zero and LE_COMMAND_LENGTH-1 * index is between zero and LE_COMMAND_LENGTH-1
*/ */
void setFsioExt(int index, brain_pin_e pin, const char * exp, int freq DECLARE_ENGINE_PARAMETER_S) { void setFsioExt(int index, brain_pin_e pin, const char * exp, int freq DECLARE_ENGINE_PARAMETER_SUFFIX) {
boardConfiguration->fsioPins[index] = pin; boardConfiguration->fsioPins[index] = pin;
int len = strlen(exp); int len = strlen(exp);
if (len >= LE_COMMAND_LENGTH) { if (len >= LE_COMMAND_LENGTH) {
@ -180,11 +180,11 @@ void setFsioExt(int index, brain_pin_e pin, const char * exp, int freq DECLARE_E
boardConfiguration->fsioFrequency[index] = freq; boardConfiguration->fsioFrequency[index] = freq;
} }
void setFsio(int index, brain_pin_e pin, const char * exp DECLARE_ENGINE_PARAMETER_S) { void setFsio(int index, brain_pin_e pin, const char * exp DECLARE_ENGINE_PARAMETER_SUFFIX) {
setFsioExt(index, pin, exp, NO_PWM PASS_ENGINE_PARAMETER); setFsioExt(index, pin, exp, NO_PWM PASS_ENGINE_PARAMETER_SUFFIX);
} }
void applyFsioConfiguration(DECLARE_ENGINE_PARAMETER_F) { void applyFsioConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
userPool.reset(); userPool.reset();
for (int i = 0; i < LE_COMMAND_COUNT; i++) { for (int i = 0; i < LE_COMMAND_COUNT; i++) {
brain_pin_e brainPin = boardConfiguration->fsioPins[i]; brain_pin_e brainPin = boardConfiguration->fsioPins[i];
@ -460,7 +460,7 @@ static void setFsioExpression(const char *indexStr, const char *quotedLine, Engi
scheduleMsg(logger, "setting user out #%d to [%s]", index + 1, l); scheduleMsg(logger, "setting user out #%d to [%s]", index + 1, l);
strcpy(engine->config->le_formulas[index], l); strcpy(engine->config->le_formulas[index], l);
// this would apply the changes // this would apply the changes
applyFsioConfiguration(PASS_ENGINE_PARAMETER_F); applyFsioConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
showFsioInfo(); showFsioInfo();
#endif #endif
} }
@ -480,7 +480,7 @@ static void rpnEval(char *line, Engine *engine) {
#endif #endif
} }
void initFsioImpl(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) { void initFsioImpl(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) {
#if EFI_PROD_CODE || EFI_SIMULATOR #if EFI_PROD_CODE || EFI_SIMULATOR
logger = sharedLogger; logger = sharedLogger;
#endif #endif

30
firmware/controllers/engine_controller.cpp
View File

@ -169,7 +169,7 @@ static void cylinderCleanupControl(Engine *engine) {
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__) #if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
bool newValue; bool newValue;
if (engineConfiguration->isCylinderCleanupEnabled) { if (engineConfiguration->isCylinderCleanupEnabled) {
newValue = !engine->rpmCalculator.isRunning(PASS_ENGINE_PARAMETER_F) && getTPS(PASS_ENGINE_PARAMETER_F) > CLEANUP_MODE_TPS; newValue = !engine->rpmCalculator.isRunning(PASS_ENGINE_PARAMETER_SIGNATURE) && getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) > CLEANUP_MODE_TPS;
} else { } else {
newValue = false; newValue = false;
} }
@ -192,7 +192,7 @@ static void scheduleNextSlowInvocation(void) {
chVTSetAny(&periodicSlowTimer, MS2ST(periodMs), (vtfunc_t) &periodicSlowCallback, engine); chVTSetAny(&periodicSlowTimer, MS2ST(periodMs), (vtfunc_t) &periodicSlowCallback, engine);
} }
static void periodicFastCallback(DECLARE_ENGINE_PARAMETER_F) { static void periodicFastCallback(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engine->periodicFastCallback(); engine->periodicFastCallback();
chVTSetAny(&periodicFastTimer, MS2ST(20), (vtfunc_t) &periodicFastCallback, engine); chVTSetAny(&periodicFastTimer, MS2ST(20), (vtfunc_t) &periodicFastCallback, engine);
@ -241,9 +241,9 @@ static void periodicSlowCallback(Engine *engine) {
scheduleNextSlowInvocation(); scheduleNextSlowInvocation();
} }
void initPeriodicEvents(DECLARE_ENGINE_PARAMETER_F) { void initPeriodicEvents(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
scheduleNextSlowInvocation(); scheduleNextSlowInvocation();
periodicFastCallback(PASS_ENGINE_PARAMETER_F); periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
char * getPinNameByAdcChannel(const char *msg, adc_channel_e hwChannel, char *buffer) { char * getPinNameByAdcChannel(const char *msg, adc_channel_e hwChannel, char *buffer) {
@ -314,10 +314,10 @@ static void printAnalogInfo(void) {
} }
printAnalogChannelInfo("AFR", engineConfiguration->afr.hwChannel); printAnalogChannelInfo("AFR", engineConfiguration->afr.hwChannel);
if (hasMapSensor(PASS_ENGINE_PARAMETER_F)) { if (hasMapSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
printAnalogChannelInfo("MAP", engineConfiguration->map.sensor.hwChannel); printAnalogChannelInfo("MAP", engineConfiguration->map.sensor.hwChannel);
} }
if (hasBaroSensor(PASS_ENGINE_PARAMETER_F)) { if (hasBaroSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
printAnalogChannelInfo("BARO", engineConfiguration->baroSensor.hwChannel); printAnalogChannelInfo("BARO", engineConfiguration->baroSensor.hwChannel);
} }
if (engineConfiguration->externalKnockSenseAdc != EFI_ADC_NONE) { if (engineConfiguration->externalKnockSenseAdc != EFI_ADC_NONE) {
@ -370,7 +370,7 @@ static void setBit(const char *offsetStr, const char *bitStr, const char *valueS
* this response is part of dev console API * this response is part of dev console API
*/ */
scheduleMsg(&logger, "bit @%d/%d is %d", offset, bit, value); scheduleMsg(&logger, "bit @%d/%d is %d", offset, bit, value);
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setShort(const int offset, const int value) { static void setShort(const int offset, const int value) {
@ -379,7 +379,7 @@ static void setShort(const int offset, const int value) {
uint16_t *ptr = (uint16_t *) (&((char *) engineConfiguration)[offset]); uint16_t *ptr = (uint16_t *) (&((char *) engineConfiguration)[offset]);
*ptr = (uint16_t) value; *ptr = (uint16_t) value;
getShort(offset); getShort(offset);
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void getBit(int offset, int bit) { static void getBit(int offset, int bit) {
@ -410,7 +410,7 @@ static void setInt(const int offset, const int value) {
int *ptr = (int *) (&((char *) engineConfiguration)[offset]); int *ptr = (int *) (&((char *) engineConfiguration)[offset]);
*ptr = value; *ptr = value;
getInt(offset); getInt(offset);
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void getFloat(int offset) { static void getFloat(int offset) {
@ -509,7 +509,7 @@ static void getKnockInfo(void) {
} }
// this method is used by real firmware and simulator // this method is used by real firmware and simulator
void commonInitEngineController(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) { void commonInitEngineController(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) {
initConfigActions(); initConfigActions();
initMockVoltage(); initMockVoltage();
@ -535,17 +535,17 @@ void commonInitEngineController(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S
if (hasFirmwareError()) { if (hasFirmwareError()) {
return; return;
} }
initSensors(sharedLogger PASS_ENGINE_PARAMETER_F); initSensors(sharedLogger PASS_ENGINE_PARAMETER_SIGNATURE);
#if EFI_FSIO || defined(__DOXYGEN__) #if EFI_FSIO || defined(__DOXYGEN__)
initFsioImpl(sharedLogger PASS_ENGINE_PARAMETER); initFsioImpl(sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
#endif #endif
initAccelEnrichment(sharedLogger); initAccelEnrichment(sharedLogger);
} }
void initEngineContoller(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) { void initEngineContoller(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) {
addConsoleAction("analoginfo", printAnalogInfo); addConsoleAction("analoginfo", printAnalogInfo);
commonInitEngineController(sharedLogger); commonInitEngineController(sharedLogger);
@ -577,7 +577,7 @@ void initEngineContoller(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) {
// multiple issues with this initMapAdjusterThread(); // multiple issues with this initMapAdjusterThread();
// periodic events need to be initialized after fuel&spark pins to avoid a warning // periodic events need to be initialized after fuel&spark pins to avoid a warning
initPeriodicEvents(PASS_ENGINE_PARAMETER_F); initPeriodicEvents(PASS_ENGINE_PARAMETER_SIGNATURE);
if (hasFirmwareError()) { if (hasFirmwareError()) {
return; return;
@ -590,7 +590,7 @@ void initEngineContoller(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) {
* This has to go after 'initInjectorCentral' and 'initInjectorCentral' in order to * This has to go after 'initInjectorCentral' and 'initInjectorCentral' in order to
* properly detect un-assigned output pins * properly detect un-assigned output pins
*/ */
prepareShapes(PASS_ENGINE_PARAMETER_F); prepareShapes(PASS_ENGINE_PARAMETER_SIGNATURE);
#endif /* EFI_PROD_CODE && EFI_ENGINE_CONTROL */ #endif /* EFI_PROD_CODE && EFI_ENGINE_CONTROL */
#if EFI_PWM_TESTER || defined(__DOXYGEN__) #if EFI_PWM_TESTER || defined(__DOXYGEN__)

12
firmware/controllers/flash_main.cpp
View File

@ -98,7 +98,7 @@ void writeToFlashNow(void) {
} else { } else {
scheduleMsg(logger, "Flashing failed"); scheduleMsg(logger, "Flashing failed");
} }
assertEngineReference(PASS_ENGINE_PARAMETER_F); assertEngineReference(PASS_ENGINE_PARAMETER_SIGNATURE);
maxLockTime = 0; maxLockTime = 0;
} }
@ -109,7 +109,7 @@ static bool isValidCrc(persistent_config_container_s *state) {
} }
static void doResetConfiguration(void) { static void doResetConfiguration(void) {
resetConfigurationExt(logger, engineConfiguration->engineType PASS_ENGINE_PARAMETER); resetConfigurationExt(logger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
} }
persisted_configuration_state_e flashState; persisted_configuration_state_e flashState;
@ -133,7 +133,7 @@ static persisted_configuration_state_e doReadConfiguration(flashaddr_t address,
*/ */
persisted_configuration_state_e readConfiguration(Logging * logger) { persisted_configuration_state_e readConfiguration(Logging * logger) {
efiAssert(getRemainingStack(chThdGetSelfX()) > 256, "read f", PC_ERROR); efiAssert(getRemainingStack(chThdGetSelfX()) > 256, "read f", PC_ERROR);
assertEngineReference(PASS_ENGINE_PARAMETER_F); assertEngineReference(PASS_ENGINE_PARAMETER_SIGNATURE);
persisted_configuration_state_e result = doReadConfiguration(FLASH_ADDR, logger); persisted_configuration_state_e result = doReadConfiguration(FLASH_ADDR, logger);
if (result != PC_OK) { if (result != PC_OK) {
printMsg(logger, "Reading second configuration copy"); printMsg(logger, "Reading second configuration copy");
@ -142,14 +142,14 @@ persisted_configuration_state_e readConfiguration(Logging * logger) {
if (result == CRC_FAILED) { if (result == CRC_FAILED) {
warning(CUSTOM_ERR_FLASH_CRC_FAILED, "flash CRC failed"); warning(CUSTOM_ERR_FLASH_CRC_FAILED, "flash CRC failed");
resetConfigurationExt(logger, DEFAULT_ENGINE_TYPE PASS_ENGINE_PARAMETER); resetConfigurationExt(logger, DEFAULT_ENGINE_TYPE PASS_ENGINE_PARAMETER_SUFFIX);
} else if (result == INCOMPATIBLE_VERSION) { } else if (result == INCOMPATIBLE_VERSION) {
resetConfigurationExt(logger, engineConfiguration->engineType PASS_ENGINE_PARAMETER); resetConfigurationExt(logger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
} else { } else {
/** /**
* At this point we know that CRC and version number is what we expect. Safe to assume it's a valid configuration. * At this point we know that CRC and version number is what we expect. Safe to assume it's a valid configuration.
*/ */
applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER); applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER_SUFFIX);
} }
// we can only change the state after the CRC check // we can only change the state after the CRC check
engineConfiguration->byFirmwareVersion = getRusEfiVersion(); engineConfiguration->byFirmwareVersion = getRusEfiVersion();

2
firmware/controllers/idle_thread.cpp
View File

@ -184,7 +184,7 @@ percent_t getIdlePosition(void) {
static void autoIdle() { static void autoIdle() {
efitimems_t now = currentTimeMillis(); efitimems_t now = currentTimeMillis();
percent_t newValue = idlePositionController.getIdle(getRpmE(engine), now PASS_ENGINE_PARAMETER); percent_t newValue = idlePositionController.getIdle(getRpmE(engine), now PASS_ENGINE_PARAMETER_SUFFIX);
if (currentIdleValve != newValue) { if (currentIdleValve != newValue) {
currentIdleValve = newValue; currentIdleValve = newValue;

4
firmware/controllers/map_averaging.cpp
View File

@ -126,7 +126,7 @@ void mapAveragingCallback(adcsample_t adcValue) {
float voltage = adcToVoltsDivided(adcValue); float voltage = adcToVoltsDivided(adcValue);
float currentPressure = getMapByVoltage(voltage); float currentPressure = getMapByVoltage(voltage);
scAddData( scAddData(
getCrankshaftAngleNt(getTimeNowNt() PASS_ENGINE_PARAMETER), getCrankshaftAngleNt(getTimeNowNt() PASS_ENGINE_PARAMETER_SUFFIX),
currentPressure); currentPressure);
} }
} }
@ -174,7 +174,7 @@ static void endAveraging(void *arg) {
* Shaft Position callback used to schedule start and end of MAP averaging * Shaft Position callback used to schedule start and end of MAP averaging
*/ */
static void mapAveragingCallback(trigger_event_e ckpEventType, static void mapAveragingCallback(trigger_event_e ckpEventType,
uint32_t index DECLARE_ENGINE_PARAMETER_S) { uint32_t index DECLARE_ENGINE_PARAMETER_SUFFIX) {
// this callback is invoked on interrupt thread // this callback is invoked on interrupt thread
UNUSED(ckpEventType); UNUSED(ckpEventType);
engine->m.beforeMapAveragingCb = GET_TIMESTAMP(); engine->m.beforeMapAveragingCb = GET_TIMESTAMP();

70
firmware/controllers/math/engine_math.cpp
View File

@ -35,7 +35,7 @@ EXTERN_ENGINE
extern EnginePins enginePins; extern EnginePins enginePins;
floatms_t getEngineCycleDuration(int rpm DECLARE_ENGINE_PARAMETER_S) { floatms_t getEngineCycleDuration(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
return getCrankshaftRevolutionTimeMs(rpm) * (engineConfiguration->operationMode == TWO_STROKE ? 1 : 2); return getCrankshaftRevolutionTimeMs(rpm) * (engineConfiguration->operationMode == TWO_STROKE ? 1 : 2);
} }
@ -53,12 +53,12 @@ floatms_t getCrankshaftRevolutionTimeMs(int rpm) {
* @brief Returns engine load according to selected engine_load_mode * @brief Returns engine load according to selected engine_load_mode
* *
*/ */
float getEngineLoadT(DECLARE_ENGINE_PARAMETER_F) { float getEngineLoadT(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
efiAssert(engine!=NULL, "engine 2NULL", NAN); efiAssert(engine!=NULL, "engine 2NULL", NAN);
efiAssert(engineConfiguration!=NULL, "engineConfiguration 2NULL", NAN); efiAssert(engineConfiguration!=NULL, "engineConfiguration 2NULL", NAN);
switch (engineConfiguration->fuelAlgorithm) { switch (engineConfiguration->fuelAlgorithm) {
case LM_PLAIN_MAF: case LM_PLAIN_MAF:
if (!hasMafSensor(PASS_ENGINE_PARAMETER_F)) { if (!hasMafSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
warning(CUSTOM_MAF_NEEDED, "MAF sensor needed for current fuel algorithm"); warning(CUSTOM_MAF_NEEDED, "MAF sensor needed for current fuel algorithm");
return NAN; return NAN;
} }
@ -68,9 +68,9 @@ float getEngineLoadT(DECLARE_ENGINE_PARAMETER_F) {
case LM_MAP: case LM_MAP:
return getMap(); return getMap();
case LM_ALPHA_N: case LM_ALPHA_N:
return getTPS(PASS_ENGINE_PARAMETER_F); return getTPS(PASS_ENGINE_PARAMETER_SIGNATURE);
case LM_REAL_MAF: { case LM_REAL_MAF: {
return getRealMaf(PASS_ENGINE_PARAMETER_F); return getRealMaf(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
default: default:
warning(CUSTOM_UNKNOWN_ALGORITHM, "Unexpected engine load parameter: %d", engineConfiguration->fuelAlgorithm); warning(CUSTOM_UNKNOWN_ALGORITHM, "Unexpected engine load parameter: %d", engineConfiguration->fuelAlgorithm);
@ -107,7 +107,7 @@ void FuelSchedule::clear() {
/** /**
* @returns false in case of error, true if success * @returns false in case of error, true if success
*/ */
bool FuelSchedule::addFuelEventsForCylinder(int i DECLARE_ENGINE_PARAMETER_S) { bool FuelSchedule::addFuelEventsForCylinder(int i DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssert(engine!=NULL, "engine is NULL", false); efiAssert(engine!=NULL, "engine is NULL", false);
floatus_t oneDegreeUs = ENGINE(rpmCalculator.oneDegreeUs); // local copy floatus_t oneDegreeUs = ENGINE(rpmCalculator.oneDegreeUs); // local copy
@ -137,12 +137,12 @@ bool FuelSchedule::addFuelEventsForCylinder(int i DECLARE_ENGINE_PARAMETER_S) {
int index; int index;
injection_mode_e mode = engine->getCurrentInjectionMode(PASS_ENGINE_PARAMETER_F); injection_mode_e mode = engine->getCurrentInjectionMode(PASS_ENGINE_PARAMETER_SIGNATURE);
if (mode == IM_SIMULTANEOUS) { if (mode == IM_SIMULTANEOUS) {
index = 0; index = 0;
} else if (mode == IM_SEQUENTIAL) { } else if (mode == IM_SEQUENTIAL) {
index = getCylinderId(i PASS_ENGINE_PARAMETER) - 1; index = getCylinderId(i PASS_ENGINE_PARAMETER_SUFFIX) - 1;
} else if (mode == IM_BATCH) { } else if (mode == IM_BATCH) {
// does not look exactly right, not too consistent with IM_SEQUENTIAL // does not look exactly right, not too consistent with IM_SEQUENTIAL
index = i % (engineConfiguration->specs.cylindersCount / 2); index = i % (engineConfiguration->specs.cylindersCount / 2);
@ -199,20 +199,20 @@ bool FuelSchedule::addFuelEventsForCylinder(int i DECLARE_ENGINE_PARAMETER_S) {
return false; return false;
} }
TRIGGER_SHAPE(findTriggerPosition(&ev->injectionStart, angle PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&ev->injectionStart, angle PASS_ENGINE_PARAMETER_SUFFIX));
#if EFI_UNIT_TEST || defined(__DOXYGEN__) #if EFI_UNIT_TEST || defined(__DOXYGEN__)
printf("registerInjectionEvent angle=%f trgIndex=%d inj %d\r\n", angle, ev->injectionStart.eventIndex, index); printf("registerInjectionEvent angle=%f trgIndex=%d inj %d\r\n", angle, ev->injectionStart.eventIndex, index);
#endif #endif
return true; return true;
} }
void FuelSchedule::addFuelEvents(DECLARE_ENGINE_PARAMETER_F) { void FuelSchedule::addFuelEvents(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
clear(); clear();
for (int i = 0; i < CONFIG(specs.cylindersCount); i++) { for (int i = 0; i < CONFIG(specs.cylindersCount); i++) {
InjectionEvent *ev = &elements[i]; InjectionEvent *ev = &elements[i];
ev->ownIndex = i; ev->ownIndex = i;
bool result = addFuelEventsForCylinder(i PASS_ENGINE_PARAMETER); bool result = addFuelEventsForCylinder(i PASS_ENGINE_PARAMETER_SUFFIX);
if (!result) if (!result)
return; return;
} }
@ -221,7 +221,7 @@ void FuelSchedule::addFuelEvents(DECLARE_ENGINE_PARAMETER_F) {
#endif #endif
floatms_t getCrankingSparkDwell(int rpm DECLARE_ENGINE_PARAMETER_S) { floatms_t getCrankingSparkDwell(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (engineConfiguration->useConstantDwellDuringCranking) { if (engineConfiguration->useConstantDwellDuringCranking) {
return engineConfiguration->ignitionDwellForCrankingMs; return engineConfiguration->ignitionDwellForCrankingMs;
} else { } else {
@ -234,10 +234,10 @@ floatms_t getCrankingSparkDwell(int rpm DECLARE_ENGINE_PARAMETER_S) {
/** /**
* @return Spark dwell time, in milliseconds. 0 if tables are not ready. * @return Spark dwell time, in milliseconds. 0 if tables are not ready.
*/ */
floatms_t getSparkDwell(int rpm DECLARE_ENGINE_PARAMETER_S) { floatms_t getSparkDwell(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
float dwellMs; float dwellMs;
if (isCrankingR(rpm)) { if (isCrankingR(rpm)) {
dwellMs = getCrankingSparkDwell(rpm PASS_ENGINE_PARAMETER); dwellMs = getCrankingSparkDwell(rpm PASS_ENGINE_PARAMETER_SUFFIX);
} else { } else {
efiAssert(!cisnan(rpm), "invalid rpm", NAN); efiAssert(!cisnan(rpm), "invalid rpm", NAN);
@ -255,7 +255,7 @@ floatms_t getSparkDwell(int rpm DECLARE_ENGINE_PARAMETER_S) {
/** /**
* this method is only used on initialization * this method is only used on initialization
*/ */
int TriggerShape::findAngleIndex(float target DECLARE_ENGINE_PARAMETER_S) { int TriggerShape::findAngleIndex(float target DECLARE_ENGINE_PARAMETER_SUFFIX) {
int engineCycleEventCount = TRIGGER_SHAPE(getLength()); int engineCycleEventCount = TRIGGER_SHAPE(getLength());
efiAssert(engineCycleEventCount > 0, "engineCycleEventCount", 0); efiAssert(engineCycleEventCount > 0, "engineCycleEventCount", 0);
@ -283,7 +283,7 @@ int TriggerShape::findAngleIndex(float target DECLARE_ENGINE_PARAMETER_S) {
return left - 1; return left - 1;
} }
void TriggerShape::findTriggerPosition(event_trigger_position_s *position, angle_t angleOffset DECLARE_ENGINE_PARAMETER_S) { void TriggerShape::findTriggerPosition(event_trigger_position_s *position, angle_t angleOffset DECLARE_ENGINE_PARAMETER_SUFFIX) {
// convert engine cycle angle into trigger cycle angle // convert engine cycle angle into trigger cycle angle
angleOffset += tdcPosition(); angleOffset += tdcPosition();
fixAngle(angleOffset, "addFuel#2"); fixAngle(angleOffset, "addFuel#2");
@ -330,7 +330,7 @@ static int order_1_10_9_4_3_6_5_8_7_2[] = {1, 10, 9, 4, 3, 6, 5, 8, 7, 2};
// 12 cyliner // 12 cyliner
static int order_1_7_5_11_3_9_6_12_2_8_4_10[] = {1, 7, 5, 11, 3, 9, 6, 12, 2, 8, 4, 10}; static int order_1_7_5_11_3_9_6_12_2_8_4_10[] = {1, 7, 5, 11, 3, 9, 6, 12, 2, 8, 4, 10};
static int getFiringOrderLength(DECLARE_ENGINE_PARAMETER_F) { static int getFiringOrderLength(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
switch (CONFIG(specs.firingOrder)) { switch (CONFIG(specs.firingOrder)) {
case FO_1: case FO_1:
@ -382,9 +382,9 @@ static int getFiringOrderLength(DECLARE_ENGINE_PARAMETER_F) {
* @param index from zero to cylindersCount - 1 * @param index from zero to cylindersCount - 1
* @return cylinderId from one to cylindersCount * @return cylinderId from one to cylindersCount
*/ */
int getCylinderId(int index DECLARE_ENGINE_PARAMETER_S) { int getCylinderId(int index DECLARE_ENGINE_PARAMETER_SUFFIX) {
const int foLength = getFiringOrderLength(PASS_ENGINE_PARAMETER_F); const int foLength = getFiringOrderLength(PASS_ENGINE_PARAMETER_SIGNATURE);
if (engineConfiguration->specs.cylindersCount != foLength) { if (engineConfiguration->specs.cylindersCount != foLength) {
warning(CUSTOM_OBD_WRONG_FIRING_ORDER, "Wrong firing order %d/%d", engineConfiguration->specs.cylindersCount, foLength); warning(CUSTOM_OBD_WRONG_FIRING_ORDER, "Wrong firing order %d/%d", engineConfiguration->specs.cylindersCount, foLength);
return 1; return 1;
@ -442,7 +442,7 @@ int getCylinderId(int index DECLARE_ENGINE_PARAMETER_S) {
return 1; return 1;
} }
static int getIgnitionPinForIndex(int i DECLARE_ENGINE_PARAMETER_S) { static int getIgnitionPinForIndex(int i DECLARE_ENGINE_PARAMETER_SUFFIX) {
switch (CONFIG(ignitionMode)) { switch (CONFIG(ignitionMode)) {
case IM_ONE_COIL: case IM_ONE_COIL:
return 0; return 0;
@ -461,10 +461,10 @@ static int getIgnitionPinForIndex(int i DECLARE_ENGINE_PARAMETER_S) {
} }
} }
void TriggerShape::prepareShape(DECLARE_ENGINE_PARAMETER_F) { void TriggerShape::prepareShape(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
int engineCycleInt = (int) getEngineCycle(CONFIG(operationMode)); int engineCycleInt = (int) getEngineCycle(CONFIG(operationMode));
for (int angle = 0; angle < engineCycleInt; angle++) { for (int angle = 0; angle < engineCycleInt; angle++) {
int triggerShapeIndex = findAngleIndex(angle PASS_ENGINE_PARAMETER); int triggerShapeIndex = findAngleIndex(angle PASS_ENGINE_PARAMETER_SUFFIX);
if (engineConfiguration->useOnlyRisingEdgeForTrigger) { if (engineConfiguration->useOnlyRisingEdgeForTrigger) {
// we need even index for front_only mode - so if odd indexes are rounded down // we need even index for front_only mode - so if odd indexes are rounded down
triggerShapeIndex = triggerShapeIndex & 0xFFFFFFFE; triggerShapeIndex = triggerShapeIndex & 0xFFFFFFFE;
@ -478,7 +478,7 @@ void TriggerShape::prepareShape(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* This heavy method is only invoked in case of a configuration change or initialization. * This heavy method is only invoked in case of a configuration change or initialization.
*/ */
void prepareOutputSignals(DECLARE_ENGINE_PARAMETER_F) { void prepareOutputSignals(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
ENGINE(engineCycle) = getEngineCycle(CONFIG(operationMode)); ENGINE(engineCycle) = getEngineCycle(CONFIG(operationMode));
angle_t maxTimingCorrMap = -720.0f; angle_t maxTimingCorrMap = -720.0f;
@ -491,7 +491,7 @@ void prepareOutputSignals(DECLARE_ENGINE_PARAMETER_F) {
} }
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
floatms_t crankingDwell = getCrankingSparkDwell(CONFIG(cranking.rpm) PASS_ENGINE_PARAMETER); floatms_t crankingDwell = getCrankingSparkDwell(CONFIG(cranking.rpm) PASS_ENGINE_PARAMETER_SUFFIX);
// dwell at cranking is constant angle or constant time, dwell at cranking threshold is the highest angle duration // dwell at cranking is constant angle or constant time, dwell at cranking threshold is the highest angle duration
// lower RPM angle duration goes up // lower RPM angle duration goes up
@ -531,47 +531,47 @@ void prepareOutputSignals(DECLARE_ENGINE_PARAMETER_F) {
for (int i = 0; i < CONFIG(specs.cylindersCount); i++) { for (int i = 0; i < CONFIG(specs.cylindersCount); i++) {
ENGINE(angleExtra[i])= ENGINE(engineCycle) * i / CONFIG(specs.cylindersCount); ENGINE(angleExtra[i])= ENGINE(engineCycle) * i / CONFIG(specs.cylindersCount);
ENGINE(ignitionPin[i]) = getIgnitionPinForIndex(i PASS_ENGINE_PARAMETER); ENGINE(ignitionPin[i]) = getIgnitionPinForIndex(i PASS_ENGINE_PARAMETER_SUFFIX);
} }
TRIGGER_SHAPE(prepareShape(PASS_ENGINE_PARAMETER_F)); TRIGGER_SHAPE(prepareShape(PASS_ENGINE_PARAMETER_SIGNATURE));
} }
#endif #endif
void setFuelRpmBin(float from, float to DECLARE_ENGINE_PARAMETER_S) { void setFuelRpmBin(float from, float to DECLARE_ENGINE_PARAMETER_SUFFIX) {
setTableBin(config->fuelRpmBins, FUEL_RPM_COUNT, from, to); setTableBin(config->fuelRpmBins, FUEL_RPM_COUNT, from, to);
} }
void setFuelLoadBin(float from, float to DECLARE_ENGINE_PARAMETER_S) { void setFuelLoadBin(float from, float to DECLARE_ENGINE_PARAMETER_SUFFIX) {
setTableBin(config->fuelLoadBins, FUEL_LOAD_COUNT, from, to); setTableBin(config->fuelLoadBins, FUEL_LOAD_COUNT, from, to);
} }
void setTimingRpmBin(float from, float to DECLARE_ENGINE_PARAMETER_S) { void setTimingRpmBin(float from, float to DECLARE_ENGINE_PARAMETER_SUFFIX) {
setRpmBin(config->ignitionRpmBins, IGN_RPM_COUNT, from, to); setRpmBin(config->ignitionRpmBins, IGN_RPM_COUNT, from, to);
} }
void setTimingLoadBin(float from, float to DECLARE_ENGINE_PARAMETER_S) { void setTimingLoadBin(float from, float to DECLARE_ENGINE_PARAMETER_SUFFIX) {
setTableBin(config->ignitionLoadBins, IGN_LOAD_COUNT, from, to); setTableBin(config->ignitionLoadBins, IGN_LOAD_COUNT, from, to);
} }
/** /**
* this method sets algorithm and ignition table scale * this method sets algorithm and ignition table scale
*/ */
void setAlgorithm(engine_load_mode_e algo DECLARE_ENGINE_PARAMETER_S) { void setAlgorithm(engine_load_mode_e algo DECLARE_ENGINE_PARAMETER_SUFFIX) {
engineConfiguration->fuelAlgorithm = algo; engineConfiguration->fuelAlgorithm = algo;
if (algo == LM_ALPHA_N) { if (algo == LM_ALPHA_N) {
setTimingLoadBin(20, 120 PASS_ENGINE_PARAMETER); setTimingLoadBin(20, 120 PASS_ENGINE_PARAMETER_SUFFIX);
} else if (algo == LM_SPEED_DENSITY) { } else if (algo == LM_SPEED_DENSITY) {
setTableBin2(config->ignitionLoadBins, IGN_LOAD_COUNT, 20, 120, 3); setTableBin2(config->ignitionLoadBins, IGN_LOAD_COUNT, 20, 120, 3);
buildTimingMap(35 PASS_ENGINE_PARAMETER); buildTimingMap(35 PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
void setInjectorLag(float value DECLARE_ENGINE_PARAMETER_S) { void setInjectorLag(float value DECLARE_ENGINE_PARAMETER_SUFFIX) {
setArrayValues(engineConfiguration->injector.battLagCorr, VBAT_INJECTOR_CURVE_SIZE, value); setArrayValues(engineConfiguration->injector.battLagCorr, VBAT_INJECTOR_CURVE_SIZE, value);
} }
void assertEngineReference(DECLARE_ENGINE_PARAMETER_F) { void assertEngineReference(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
efiAssertVoid(engine != NULL, "engine is NULL"); efiAssertVoid(engine != NULL, "engine is NULL");
} }

8
firmware/controllers/sensors/allsensors.cpp
View File

@ -12,13 +12,13 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void initSensors(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) { void initSensors(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) {
initThermistors(sharedLogger PASS_ENGINE_PARAMETER); initThermistors(sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
initMapDecoder(sharedLogger PASS_ENGINE_PARAMETER); initMapDecoder(sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
} }
// todo: move this somewhere else? maybe. // todo: move this somewhere else? maybe.
bool getAcToggle(DECLARE_ENGINE_PARAMETER_F) { bool getAcToggle(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
/** /**
* todo: make this flexible * todo: make this flexible
* *

30
firmware/controllers/sensors/map.cpp
View File

@ -66,7 +66,7 @@ static FastInterpolation dodgeNeon2003(0.4 /* volts */, 15.34 /* kPa */, 4.5 /*
*/ */
static FastInterpolation *mapDecoder; static FastInterpolation *mapDecoder;
float decodePressure(float voltage, air_pressure_sensor_config_s * mapConfig DECLARE_ENGINE_PARAMETER_S) { float decodePressure(float voltage, air_pressure_sensor_config_s * mapConfig DECLARE_ENGINE_PARAMETER_SUFFIX) {
switch (mapConfig->type) { switch (mapConfig->type) {
case MT_CUSTOM: case MT_CUSTOM:
// todo: migrate to 'FastInterpolation customMap' // todo: migrate to 'FastInterpolation customMap'
@ -98,7 +98,7 @@ float decodePressure(float voltage, air_pressure_sensor_config_s * mapConfig DEC
* This function adds an error if MAP sensor value is outside of expected range * This function adds an error if MAP sensor value is outside of expected range
* @return unchanged mapKPa parameter * @return unchanged mapKPa parameter
*/ */
float validateMap(float mapKPa DECLARE_ENGINE_PARAMETER_S) { float validateMap(float mapKPa DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (cisnan(mapKPa) || mapKPa < CONFIG(mapErrorDetectionTooLow) || mapKPa > CONFIG(mapErrorDetectionTooHigh)) { if (cisnan(mapKPa) || mapKPa < CONFIG(mapErrorDetectionTooLow) || mapKPa > CONFIG(mapErrorDetectionTooHigh)) {
warning(OBD_Manifold_Absolute_Pressure_Circuit_Malfunction, "unexpected MAP value: %f", mapKPa); warning(OBD_Manifold_Absolute_Pressure_Circuit_Malfunction, "unexpected MAP value: %f", mapKPa);
return 0; return 0;
@ -110,7 +110,7 @@ float validateMap(float mapKPa DECLARE_ENGINE_PARAMETER_S) {
* @brief MAP value decoded according to current settings * @brief MAP value decoded according to current settings
* @returns kPa value * @returns kPa value
*/ */
float getMapByVoltage(float voltage DECLARE_ENGINE_PARAMETER_S) { float getMapByVoltage(float voltage DECLARE_ENGINE_PARAMETER_SUFFIX) {
#if EFI_ENABLE_MOCK_ADC || defined(__DOXYGEN__) #if EFI_ENABLE_MOCK_ADC || defined(__DOXYGEN__)
int mapChannel = engineConfiguration->map.sensor.hwChannel; int mapChannel = engineConfiguration->map.sensor.hwChannel;
if (engine->engineState.mockAdcState.hasMockAdc[mapChannel]) if (engine->engineState.mockAdcState.hasMockAdc[mapChannel])
@ -119,32 +119,32 @@ float getMapByVoltage(float voltage DECLARE_ENGINE_PARAMETER_S) {
// todo: migrate to mapDecoder once parameter listeners are ready // todo: migrate to mapDecoder once parameter listeners are ready
air_pressure_sensor_config_s * apConfig = &engineConfiguration->map.sensor; air_pressure_sensor_config_s * apConfig = &engineConfiguration->map.sensor;
return decodePressure(voltage, apConfig PASS_ENGINE_PARAMETER); return decodePressure(voltage, apConfig PASS_ENGINE_PARAMETER_SUFFIX);
} }
/** /**
* @return Manifold Absolute Pressure, in kPa * @return Manifold Absolute Pressure, in kPa
*/ */
float getRawMap(DECLARE_ENGINE_PARAMETER_F) { float getRawMap(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
if (engineConfiguration->hasFrequencyReportingMapSensor) { if (engineConfiguration->hasFrequencyReportingMapSensor) {
return interpolate(boardConfiguration->mapFrequency0Kpa, 0, boardConfiguration->mapFrequency100Kpa, 100, mapFreq); return interpolate(boardConfiguration->mapFrequency0Kpa, 0, boardConfiguration->mapFrequency100Kpa, 100, mapFreq);
} }
float voltage = getVoltageDivided("map", engineConfiguration->map.sensor.hwChannel); float voltage = getVoltageDivided("map", engineConfiguration->map.sensor.hwChannel);
return getMapByVoltage(voltage PASS_ENGINE_PARAMETER); return getMapByVoltage(voltage PASS_ENGINE_PARAMETER_SUFFIX);
} }
bool hasBaroSensor(DECLARE_ENGINE_PARAMETER_F) { bool hasBaroSensor(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return engineConfiguration->baroSensor.hwChannel != EFI_ADC_NONE; return engineConfiguration->baroSensor.hwChannel != EFI_ADC_NONE;
} }
bool hasMapSensor(DECLARE_ENGINE_PARAMETER_F) { bool hasMapSensor(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return engineConfiguration->map.sensor.hwChannel != EFI_ADC_NONE; return engineConfiguration->map.sensor.hwChannel != EFI_ADC_NONE;
} }
float getBaroPressure(DECLARE_ENGINE_PARAMETER_F) { float getBaroPressure(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
float voltage = getVoltageDivided("baro", engineConfiguration->baroSensor.hwChannel); float voltage = getVoltageDivided("baro", engineConfiguration->baroSensor.hwChannel);
return decodePressure(voltage, &engineConfiguration->baroSensor PASS_ENGINE_PARAMETER); return decodePressure(voltage, &engineConfiguration->baroSensor PASS_ENGINE_PARAMETER_SUFFIX);
} }
static FastInterpolation *getDecoder(air_pressure_sensor_type_e type) { static FastInterpolation *getDecoder(air_pressure_sensor_type_e type) {
@ -169,7 +169,7 @@ static FastInterpolation *getDecoder(air_pressure_sensor_type_e type) {
} }
} }
static void applyConfiguration(DECLARE_ENGINE_PARAMETER_F) { static void applyConfiguration(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
air_pressure_sensor_config_s * apConfig = &engineConfiguration->map.sensor; air_pressure_sensor_config_s * apConfig = &engineConfiguration->map.sensor;
customMap.init(0, apConfig->lowValue, 5, apConfig->highValue); customMap.init(0, apConfig->lowValue, 5, apConfig->highValue);
mapDecoder = getDecoder(engineConfiguration->map.sensor.type); mapDecoder = getDecoder(engineConfiguration->map.sensor.type);
@ -210,7 +210,7 @@ static void printMAPInfo(void) {
} }
} }
if (hasBaroSensor(PASS_ENGINE_PARAMETER_F)) { if (hasBaroSensor(PASS_ENGINE_PARAMETER_SIGNATURE)) {
scheduleMsg(logger, "baro type=%d value=%f", engineConfiguration->baroSensor.type, getBaroPressure()); scheduleMsg(logger, "baro type=%d value=%f", engineConfiguration->baroSensor.type, getBaroPressure());
if (engineConfiguration->baroSensor.type == MT_CUSTOM) { if (engineConfiguration->baroSensor.type == MT_CUSTOM) {
scheduleMsg(logger, "min=%f@%f max=%f@%f", scheduleMsg(logger, "min=%f@%f max=%f@%f",
@ -225,9 +225,9 @@ static void printMAPInfo(void) {
#endif /* EFI_PROD_CODE */ #endif /* EFI_PROD_CODE */
void initMapDecoder(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) { void initMapDecoder(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) {
logger = sharedLogger; logger = sharedLogger;
applyConfiguration(PASS_ENGINE_PARAMETER_F); applyConfiguration(PASS_ENGINE_PARAMETER_SIGNATURE);
//engine->configurationListeners.registerCallback(applyConfiguration); //engine->configurationListeners.registerCallback(applyConfiguration);
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
@ -244,7 +244,7 @@ void initMapDecoder(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) {
#else /* EFI_ANALOG_SENSORS */ #else /* EFI_ANALOG_SENSORS */
void initMapDecoder(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_S) { void initMapDecoder(Logging *sharedLogger DECLARE_ENGINE_PARAMETER_SUFFIX) {
} }
#endif /* EFI_ANALOG_SENSORS */ #endif /* EFI_ANALOG_SENSORS */

22
firmware/controllers/sensors/tps.cpp
View File

@ -57,7 +57,7 @@ float getTpsRateOfChange(void) {
* Return current TPS position based on configured ADC levels, and adc * Return current TPS position based on configured ADC levels, and adc
* *
* */ * */
percent_t getTpsValue(int adc DECLARE_ENGINE_PARAMETER_S) { percent_t getTpsValue(int adc DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (engineConfiguration->tpsMin == engineConfiguration->tpsMax) { if (engineConfiguration->tpsMin == engineConfiguration->tpsMax) {
warning(CUSTOM_INVALID_TPS_SETTING, "Invalid TPS configuration: same value %d", engineConfiguration->tpsMin); warning(CUSTOM_INVALID_TPS_SETTING, "Invalid TPS configuration: same value %d", engineConfiguration->tpsMin);
return NAN; return NAN;
@ -83,7 +83,7 @@ percent_t getTpsValue(int adc DECLARE_ENGINE_PARAMETER_S) {
/* /*
* Return voltage on TPS AND channel * Return voltage on TPS AND channel
* */ * */
float getTPSVoltage(DECLARE_ENGINE_PARAMETER_F) { float getTPSVoltage(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return getVoltageDivided("tps", engineConfiguration->tpsAdcChannel); return getVoltageDivided("tps", engineConfiguration->tpsAdcChannel);
} }
@ -92,7 +92,7 @@ float getTPSVoltage(DECLARE_ENGINE_PARAMETER_F) {
* We need ADC value because TunerStudio has a nice TPS configuration wizard, and this wizard * We need ADC value because TunerStudio has a nice TPS configuration wizard, and this wizard
* wants a TPS value. * wants a TPS value.
*/ */
int getTPS12bitAdc(DECLARE_ENGINE_PARAMETER_F) { int getTPS12bitAdc(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
#if !EFI_PROD_CODE #if !EFI_PROD_CODE
if (mockTps != MOCK_UNDEFINED) if (mockTps != MOCK_UNDEFINED)
return mockTps; return mockTps;
@ -111,18 +111,18 @@ int getTPS12bitAdc(DECLARE_ENGINE_PARAMETER_F) {
/** /**
* @brief Position on physical primary TPS * @brief Position on physical primary TPS
*/ */
static percent_t getPrimatyRawTPS(DECLARE_ENGINE_PARAMETER_F) { static percent_t getPrimatyRawTPS(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
percent_t tpsValue = getTpsValue(getTPS12bitAdc(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER); percent_t tpsValue = getTpsValue(getTPS12bitAdc(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX);
return tpsValue; return tpsValue;
} }
#define NO_TPS_MAGIC_VALUE 66.611 #define NO_TPS_MAGIC_VALUE 66.611
bool hasPedalPositionSensor(DECLARE_ENGINE_PARAMETER_F) { bool hasPedalPositionSensor(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return engineConfiguration->pedalPositionChannel != EFI_ADC_NONE; return engineConfiguration->pedalPositionChannel != EFI_ADC_NONE;
} }
percent_t getPedalPosition(DECLARE_ENGINE_PARAMETER_F) { percent_t getPedalPosition(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
float voltage = getVoltageDivided("pPS", engineConfiguration->pedalPositionChannel); float voltage = getVoltageDivided("pPS", engineConfiguration->pedalPositionChannel);
float result = interpolate(engineConfiguration->pedalPositionMin, 0, engineConfiguration->pedalPositionMax, 100, voltage); float result = interpolate(engineConfiguration->pedalPositionMin, 0, engineConfiguration->pedalPositionMax, 100, voltage);
@ -130,18 +130,18 @@ percent_t getPedalPosition(DECLARE_ENGINE_PARAMETER_F) {
return maxF(0, minF(100, result)); return maxF(0, minF(100, result));
} }
bool hasTpsSensor(DECLARE_ENGINE_PARAMETER_F) { bool hasTpsSensor(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return engineConfiguration->tpsAdcChannel != EFI_ADC_NONE; return engineConfiguration->tpsAdcChannel != EFI_ADC_NONE;
} }
percent_t getTPS(DECLARE_ENGINE_PARAMETER_F) { percent_t getTPS(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
if (!hasTpsSensor(PASS_ENGINE_PARAMETER_F)) if (!hasTpsSensor(PASS_ENGINE_PARAMETER_SIGNATURE))
return NO_TPS_MAGIC_VALUE; return NO_TPS_MAGIC_VALUE;
// todo: if (config->isDualTps) // todo: if (config->isDualTps)
// todo: blah blah // todo: blah blah
// todo: if two TPS do not match - show OBD code via malfunction_central.c // todo: if two TPS do not match - show OBD code via malfunction_central.c
return getPrimatyRawTPS(PASS_ENGINE_PARAMETER_F); return getPrimatyRawTPS(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
int convertVoltageTo10bitADC(float voltage) { int convertVoltageTo10bitADC(float voltage) {

64
firmware/controllers/settings.cpp
View File

@ -298,20 +298,20 @@ static void doPrintConfiguration() {
static void setFixedModeTiming(int value) { static void setFixedModeTiming(int value) {
engineConfiguration->fixedModeTiming = value; engineConfiguration->fixedModeTiming = value;
doPrintConfiguration(); doPrintConfiguration();
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setTimingMode(int value) { static void setTimingMode(int value) {
engineConfiguration->timingMode = (timing_mode_e) value; engineConfiguration->timingMode = (timing_mode_e) value;
doPrintConfiguration(); doPrintConfiguration();
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
void setEngineType(int value) { void setEngineType(int value) {
// enginePins.stopPins(); // this is mostly needed by functional tests // enginePins.stopPins(); // this is mostly needed by functional tests
engineConfiguration->engineType = (engine_type_e) value; engineConfiguration->engineType = (engine_type_e) value;
resetConfigurationExt(&logger, (engine_type_e) value PASS_ENGINE_PARAMETER); resetConfigurationExt(&logger, (engine_type_e) value PASS_ENGINE_PARAMETER_SUFFIX);
#if EFI_ENGINE_SNIFFER || defined(__DOXYGEN__) #if EFI_ENGINE_SNIFFER || defined(__DOXYGEN__)
if (engine->isTestMode) if (engine->isTestMode)
waveChart.reset(); waveChart.reset();
@ -321,7 +321,7 @@ void setEngineType(int value) {
writeToFlashNow(); writeToFlashNow();
// scheduleReset(); // scheduleReset();
#endif /* EFI_PROD_CODE */ #endif /* EFI_PROD_CODE */
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
@ -347,13 +347,13 @@ static void setIdlePinMode(int value) {
static void setInjectionOffset(float value) { static void setInjectionOffset(float value) {
engineConfiguration->extraInjectionOffset = value; engineConfiguration->extraInjectionOffset = value;
doPrintConfiguration(); doPrintConfiguration();
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setIgnitionOffset(float value) { static void setIgnitionOffset(float value) {
engineConfiguration->ignitionOffset = value; engineConfiguration->ignitionOffset = value;
doPrintConfiguration(); doPrintConfiguration();
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setFuelPumpPinMode(int value) { static void setFuelPumpPinMode(int value) {
@ -409,20 +409,20 @@ static void printTPSInfo(void) {
static char pinNameBuffer[16]; static char pinNameBuffer[16];
scheduleMsg(&logger, "tps min (closed) %d/max (full) %d v=%f @%s", engineConfiguration->tpsMin, engineConfiguration->tpsMax, scheduleMsg(&logger, "tps min (closed) %d/max (full) %d v=%f @%s", engineConfiguration->tpsMin, engineConfiguration->tpsMax,
getTPSVoltage(PASS_ENGINE_PARAMETER_F), getPinNameByAdcChannel("tps", engineConfiguration->tpsAdcChannel, pinNameBuffer)); getTPSVoltage(PASS_ENGINE_PARAMETER_SIGNATURE), getPinNameByAdcChannel("tps", engineConfiguration->tpsAdcChannel, pinNameBuffer));
#endif /* EFI_PROD_CODE */ #endif /* EFI_PROD_CODE */
scheduleMsg(&logger, "current 10bit=%d value=%f rate=%f", getTPS12bitAdc() / TPS_TS_CONVERSION, getTPS(PASS_ENGINE_PARAMETER_F), scheduleMsg(&logger, "current 10bit=%d value=%f rate=%f", getTPS12bitAdc() / TPS_TS_CONVERSION, getTPS(PASS_ENGINE_PARAMETER_SIGNATURE),
getTpsRateOfChange()); getTpsRateOfChange());
} }
static void printTemperatureInfo(void) { static void printTemperatureInfo(void) {
#if EFI_ANALOG_SENSORS || defined(__DOXYGEN__) #if EFI_ANALOG_SENSORS || defined(__DOXYGEN__)
printThermistor("CLT", &engineConfiguration->clt, &engine->engineState.cltCurve); printThermistor("CLT", &engineConfiguration->clt, &engine->engineState.cltCurve);
if (!isValidCoolantTemperature(getCoolantTemperature(PASS_ENGINE_PARAMETER_F))) { if (!isValidCoolantTemperature(getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE))) {
scheduleMsg(&logger, "CLT sensing error"); scheduleMsg(&logger, "CLT sensing error");
} }
printThermistor("IAT", &engineConfiguration->iat, &engine->engineState.iatCurve); printThermistor("IAT", &engineConfiguration->iat, &engine->engineState.iatCurve);
if (!isValidIntakeAirTemperature(getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F))) { if (!isValidIntakeAirTemperature(getIntakeAirTemperature(PASS_ENGINE_PARAMETER_SIGNATURE))) {
scheduleMsg(&logger, "IAT sensing error"); scheduleMsg(&logger, "IAT sensing error");
} }
@ -484,31 +484,31 @@ static void setGlobalTriggerAngleOffset(float value) {
return; return;
} }
engineConfiguration->globalTriggerAngleOffset = value; engineConfiguration->globalTriggerAngleOffset = value;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
static void setCrankingTimingAngle(float value) { static void setCrankingTimingAngle(float value) {
engineConfiguration->crankingTimingAngle = value; engineConfiguration->crankingTimingAngle = value;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
static void setCrankingInjectionMode(int value) { static void setCrankingInjectionMode(int value) {
engineConfiguration->crankingInjectionMode = (injection_mode_e) value; engineConfiguration->crankingInjectionMode = (injection_mode_e) value;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
static void setInjectionMode(int value) { static void setInjectionMode(int value) {
engineConfiguration->injectionMode = (injection_mode_e) value; engineConfiguration->injectionMode = (injection_mode_e) value;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
static void setIgnitionMode(int value) { static void setIgnitionMode(int value) {
engineConfiguration->ignitionMode = (ignition_mode_e) value; engineConfiguration->ignitionMode = (ignition_mode_e) value;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
@ -526,7 +526,7 @@ static void setIndividualCoilsIgnition(void) {
static void setTriggerType(int value) { static void setTriggerType(int value) {
engineConfiguration->trigger.type = (trigger_type_e) value; engineConfiguration->trigger.type = (trigger_type_e) value;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
@ -534,7 +534,7 @@ static void setDebugMode(int value) {
engineConfiguration->debugMode = (debug_mode_e) value; engineConfiguration->debugMode = (debug_mode_e) value;
} }
static void setToothedWheel(int total, int skipped DECLARE_ENGINE_PARAMETER_S) { static void setToothedWheel(int total, int skipped DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (total < 1 || skipped >= total) { if (total < 1 || skipped >= total) {
scheduleMsg(&logger, "invalid parameters %d %d", total, skipped); scheduleMsg(&logger, "invalid parameters %d %d", total, skipped);
return; return;
@ -546,13 +546,13 @@ static void setToothedWheel(int total, int skipped DECLARE_ENGINE_PARAMETER_S) {
scheduleMsg(&logger, "toothed: total=%d/skipped=%d", total, skipped); scheduleMsg(&logger, "toothed: total=%d/skipped=%d", total, skipped);
setToothedWheelConfiguration(&engine->triggerCentral.triggerShape, total, skipped, engineConfiguration->operationMode); setToothedWheelConfiguration(&engine->triggerCentral.triggerShape, total, skipped, engineConfiguration->operationMode);
// initializeTriggerShape(&logger, engineConfiguration, engineConfiguration2); // initializeTriggerShape(&logger, engineConfiguration, engineConfiguration2);
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
static void setCrankingChargeAngle(float value) { static void setCrankingChargeAngle(float value) {
engineConfiguration->crankingChargeAngle = value; engineConfiguration->crankingChargeAngle = value;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
doPrintConfiguration(); doPrintConfiguration();
} }
@ -617,7 +617,7 @@ static void setWholeFuelMapCmd(float value) {
if (engineConfiguration->fuelAlgorithm == LM_SPEED_DENSITY) { if (engineConfiguration->fuelAlgorithm == LM_SPEED_DENSITY) {
scheduleMsg(&logger, "WARNING: setting fuel map in SD mode is pointless"); scheduleMsg(&logger, "WARNING: setting fuel map in SD mode is pointless");
} }
setWholeFuelMap(value PASS_ENGINE_PARAMETER); setWholeFuelMap(value PASS_ENGINE_PARAMETER_SUFFIX);
} }
#if EFI_PROD_CODE #if EFI_PROD_CODE
@ -642,7 +642,7 @@ static void setIgnitionPin(const char *indexStr, const char *pinName) {
} }
scheduleMsg(&logger, "setting ignition pin[%d] to %s please save&restart", index, hwPortname(pin)); scheduleMsg(&logger, "setting ignition pin[%d] to %s please save&restart", index, hwPortname(pin));
boardConfiguration->ignitionPins[index] = pin; boardConfiguration->ignitionPins[index] = pin;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setIndividualPin(const char *pinName, brain_pin_e *targetPin, const char *name) { static void setIndividualPin(const char *pinName, brain_pin_e *targetPin, const char *name) {
@ -653,7 +653,7 @@ static void setIndividualPin(const char *pinName, brain_pin_e *targetPin, const
} }
scheduleMsg(&logger, "setting %s pin to %s please save&restart", name, hwPortname(pin)); scheduleMsg(&logger, "setting %s pin to %s please save&restart", name, hwPortname(pin));
*targetPin = pin; *targetPin = pin;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
// set_idle_pin none // set_idle_pin none
@ -689,7 +689,7 @@ static void setInjectionPin(const char *indexStr, const char *pinName) {
} }
scheduleMsg(&logger, "setting injection pin[%d] to %s please save&restart", index, hwPortname(pin)); scheduleMsg(&logger, "setting injection pin[%d] to %s please save&restart", index, hwPortname(pin));
boardConfiguration->injectionPins[index] = pin; boardConfiguration->injectionPins[index] = pin;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setTriggerInputPin(const char *indexStr, const char *pinName) { static void setTriggerInputPin(const char *indexStr, const char *pinName) {
@ -704,7 +704,7 @@ static void setTriggerInputPin(const char *indexStr, const char *pinName) {
} }
scheduleMsg(&logger, "setting trigger pin[%d] to %s please save&restart", index, hwPortname(pin)); scheduleMsg(&logger, "setting trigger pin[%d] to %s please save&restart", index, hwPortname(pin));
boardConfiguration->triggerInputPins[index] = pin; boardConfiguration->triggerInputPins[index] = pin;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setTriggerSimulatorMode(const char *indexStr, const char *modeCode) { static void setTriggerSimulatorMode(const char *indexStr, const char *modeCode) {
@ -730,7 +730,7 @@ static void setEgtCSPin(const char *indexStr, const char *pinName) {
} }
scheduleMsg(&logger, "setting EGT CS pin[%d] to %s please save&restart", index, hwPortname(pin)); scheduleMsg(&logger, "setting EGT CS pin[%d] to %s please save&restart", index, hwPortname(pin));
boardConfiguration->max31855_cs[index] = pin; boardConfiguration->max31855_cs[index] = pin;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
static void setTriggerSimulatorPin(const char *indexStr, const char *pinName) { static void setTriggerSimulatorPin(const char *indexStr, const char *pinName) {
@ -744,7 +744,7 @@ static void setTriggerSimulatorPin(const char *indexStr, const char *pinName) {
} }
scheduleMsg(&logger, "setting trigger simulator pin[%d] to %s please save&restart", index, hwPortname(pin)); scheduleMsg(&logger, "setting trigger simulator pin[%d] to %s please save&restart", index, hwPortname(pin));
boardConfiguration->triggerSimulatorPins[index] = pin; boardConfiguration->triggerSimulatorPins[index] = pin;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
#if HAL_USE_ADC || defined(__DOXYGEN__) #if HAL_USE_ADC || defined(__DOXYGEN__)
@ -772,7 +772,7 @@ static void setAnalogInputPin(const char *sensorStr, const char *pinName) {
engineConfiguration->tpsAdcChannel = channel; engineConfiguration->tpsAdcChannel = channel;
scheduleMsg(&logger, "setting TPS to %s/%d", pinName, channel); scheduleMsg(&logger, "setting TPS to %s/%d", pinName, channel);
} }
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
#endif #endif
@ -866,16 +866,16 @@ static void enableOrDisable(const char *param, bool isEnabled) {
boardConfiguration->useStepperIdle = isEnabled; boardConfiguration->useStepperIdle = isEnabled;
} else if (strEqualCaseInsensitive(param, "trigger_only_front")) { } else if (strEqualCaseInsensitive(param, "trigger_only_front")) {
engineConfiguration->useOnlyRisingEdgeForTrigger = isEnabled; engineConfiguration->useOnlyRisingEdgeForTrigger = isEnabled;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} else if (strEqualCaseInsensitive(param, "use_only_first_channel")) { } else if (strEqualCaseInsensitive(param, "use_only_first_channel")) {
engineConfiguration->trigger.useOnlyFirstChannel = isEnabled; engineConfiguration->trigger.useOnlyFirstChannel = isEnabled;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} else if (strEqualCaseInsensitive(param, "two_wire_batch_injection")) { } else if (strEqualCaseInsensitive(param, "two_wire_batch_injection")) {
engineConfiguration->twoWireBatchInjection = isEnabled; engineConfiguration->twoWireBatchInjection = isEnabled;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} else if (strEqualCaseInsensitive(param, "two_wire_wasted_spark")) { } else if (strEqualCaseInsensitive(param, "two_wire_wasted_spark")) {
engineConfiguration->twoWireBatchIgnition = isEnabled; engineConfiguration->twoWireBatchIgnition = isEnabled;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} else if (strEqualCaseInsensitive(param, "HIP9011")) { } else if (strEqualCaseInsensitive(param, "HIP9011")) {
boardConfiguration->isHip9011Enabled = isEnabled; boardConfiguration->isHip9011Enabled = isEnabled;
} else if (strEqualCaseInsensitive(param, "auxdebug1")) { } else if (strEqualCaseInsensitive(param, "auxdebug1")) {
@ -1210,7 +1210,7 @@ static void setValue(const char *paramStr, const char *valueStr) {
} else if (strEqualCaseInsensitive(paramStr, "warning_period")) { } else if (strEqualCaseInsensitive(paramStr, "warning_period")) {
engineConfiguration->warningPeriod = valueI; engineConfiguration->warningPeriod = valueI;
} else if (strEqualCaseInsensitive(paramStr, "dwell")) { } else if (strEqualCaseInsensitive(paramStr, "dwell")) {
setConstantDwell(valueF PASS_ENGINE_PARAMETER); setConstantDwell(valueF PASS_ENGINE_PARAMETER_SUFFIX);
} else if (strEqualCaseInsensitive(paramStr, "engineSnifferRpmThreshold")) { } else if (strEqualCaseInsensitive(paramStr, "engineSnifferRpmThreshold")) {
engineConfiguration->engineSnifferRpmThreshold = valueI; engineConfiguration->engineSnifferRpmThreshold = valueI;
} else if (strEqualCaseInsensitive(paramStr, "step1rpm")) { } else if (strEqualCaseInsensitive(paramStr, "step1rpm")) {

32
firmware/controllers/trigger/decoders/trigger_bmw.cpp
View File

@ -7,63 +7,63 @@
#include "trigger_bmw.h" #include "trigger_bmw.h"
static inline float addPair(TriggerShape *s, float a, float w DECLARE_ENGINE_PARAMETER_S) { static inline float addPair(TriggerShape *s, float a, float w DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
return a; return a;
} }
void configureMiniCooperTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureMiniCooperTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
// s->initialState[0] = 1; // s->initialState[0] = 1;
float w = 360.0 / 121; float w = 360.0 / 121;
float a = w / 2; float a = w / 2;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
for (int i = 0; i <= 22; i++) { for (int i = 0; i <= 22; i++) {
a = addPair(s, a, w PASS_ENGINE_PARAMETER); a = addPair(s, a, w PASS_ENGINE_PARAMETER_SUFFIX);
} }
a += 3 * w; a += 3 * w;
float firstGapAngle = a; float firstGapAngle = a;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += 3 * w; a += 3 * w;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
for (int i = 0; i < 36; i++) { for (int i = 0; i < 36; i++) {
a = addPair(s, a, w PASS_ENGINE_PARAMETER); a = addPair(s, a, w PASS_ENGINE_PARAMETER_SUFFIX);
} }
s->addEvent2(376, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(376, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
for (int i = 0; i < 21; i++) { for (int i = 0; i < 21; i++) {
a = addPair(s, a, w PASS_ENGINE_PARAMETER); a = addPair(s, a, w PASS_ENGINE_PARAMETER_SUFFIX);
} }
a += 3 * w; a += 3 * w;
efiAssertVoid(absF(firstGapAngle + 360 - a) < 0.1, "shape constraint"); efiAssertVoid(absF(firstGapAngle + 360 - a) < 0.1, "shape constraint");
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += 3 * w; a += 3 * w;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
for (int i = 0; i < 33; i++) { for (int i = 0; i < 33; i++) {
a = addPair(s, a, w PASS_ENGINE_PARAMETER); a = addPair(s, a, w PASS_ENGINE_PARAMETER_SUFFIX);
} }
efiAssertVoid(absF(720 - w / 2 - a) < 0.1, "shape constraint"); efiAssertVoid(absF(720 - w / 2 - a) < 0.1, "shape constraint");
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* With just one tooth on camshaft synchronization is not needed * With just one tooth on camshaft synchronization is not needed

680
firmware/controllers/trigger/decoders/trigger_chrysler.cpp
View File

@ -9,99 +9,99 @@
#include "trigger_decoder.h" #include "trigger_decoder.h"
#include "trigger_universal.h" #include "trigger_universal.h"
void initDodgeRam(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initDodgeRam(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->useRiseEdge = true; s->useRiseEdge = true;
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
addSkippedToothTriggerEvents(T_SECONDARY, s, 8, 0, 0.06, -25, 360, 0, 720 PASS_ENGINE_PARAMETER); addSkippedToothTriggerEvents(T_SECONDARY, s, 8, 0, 0.06, -25, 360, 0, 720 PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
addSkippedToothTriggerEvents(T_SECONDARY, s, 8, 0, 0.06, 360 - 25, 360, 0, addSkippedToothTriggerEvents(T_SECONDARY, s, 8, 0, 0.06, 360 - 25, 360, 0,
720 PASS_ENGINE_PARAMETER); 720 PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
void configureNeon2003TriggerShapeCrank(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureNeon2003TriggerShapeCrank(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CRANK_SENSOR, false); s->initialize(FOUR_STROKE_CRANK_SENSOR, false);
s->useRiseEdge = true; s->useRiseEdge = true;
s->setTriggerSynchronizationGap(3); s->setTriggerSynchronizationGap(3);
int m = 2; int m = 2;
s->addEvent2(m * 25, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 25, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 30, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 30, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 35, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 35, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 40, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 40, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 45, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 45, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 50, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 50, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 55, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 55, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 60, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 60, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 65, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 65, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 70, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 70, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 75, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 75, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 80, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 80, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 85, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 85, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 90, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 90, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 95, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 95, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 100, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 100, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 105, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 105, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 110, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 110, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 115, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 115, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 120, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 120, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 125, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 125, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 130, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 130, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 135, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 135, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 140, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 140, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 145,T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 145,T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 150, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 150, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 155, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 155, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 160, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 160, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 165, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 165, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 170, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 170, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 175, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 175, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 180, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 180, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 185, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 185, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
// gap 25 // gap 25
s->addEvent2(m * 210, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 210, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 215, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 215, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 220, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 220, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 225, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 225, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 230, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 230, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 235, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 235, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 240, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 240, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 245, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 245, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 250, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 250, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 255, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 255, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 260, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 260, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 265, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 265, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 270, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 270, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 275, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 275, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 280, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 280, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 285, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 285, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 290, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 290, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 295, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 295, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 300, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 300, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 305, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 305, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 310, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 310, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 315, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 315, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 320, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 320, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 325, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 325, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 330, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 330, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 335, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 335, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 340, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 340, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 345, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 345, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 350, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 350, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 355, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 355, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
} }
void configureNeon2003TriggerShapeCam(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureNeon2003TriggerShapeCam(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
// todo: move sync point so that two channel does not have false trigger issues // todo: move sync point so that two channel does not have false trigger issues
bool useOnlyPrimary = true; bool useOnlyPrimary = true;
@ -131,23 +131,23 @@ gap=1.43/0.71
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
if (useOnlyPrimary) { if (useOnlyPrimary) {
s->addEvent2(144, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(144, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(216, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(216, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(252, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(252, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(288, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(288, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(324, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(324, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // width = 144 s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX); // width = 144
s->addEvent2(504, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); // width = 36 s->addEvent2(504, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX); // width = 36
s->addEvent2(540, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(540, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(576, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(576, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(612, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(612, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(648, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(648, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(684, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(684, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} else { } else {
/** /**
@ -156,175 +156,175 @@ gap=1.43/0.71
* *
*/ */
s->addEvent2(25, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(25, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(30, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(30, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(35, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(35, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(40, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(40, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(45, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(45, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(50, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(50, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(60, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(60, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(65, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(65, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(70, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(70, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(75, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(75, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(80, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(80, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(85, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(85, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(90, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(90, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(95, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(100, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(100, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(105, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(105, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(110, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(110, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(115, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(115, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(120, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(120, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(125, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(125, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(130, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(130, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(135, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(135, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(140, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(140, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(144, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(144, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(145,T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(145,T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(150, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(150, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(155, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(155, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(160, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(160, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(165, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(165, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(170, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(170, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(175, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(175, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(180 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(180 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(185, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(185, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(210, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(210, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(215, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(215, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(216, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(216, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(220, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(220, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(225, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(225, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(230, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(230, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(235, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(235, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(240, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(240, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(245, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(245, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(250, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(250, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(252, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(252, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(255, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(255, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(260, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(260, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(265, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(265, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(270, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(270, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(275, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(275, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(280, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(280, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(285, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(285, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(288, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(288, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(290, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(290, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(295, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(295, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(300, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(300, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(305, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(305, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(310, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(310, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(315, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(315, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(320, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(320, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(324, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(324, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(325, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(325, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(330, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(330, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(335, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(335, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(340, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(340, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(345, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(345, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(350, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(350, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(355, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(355, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(385, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(385, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(390, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(390, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(395, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(395, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(400, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(400, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(405, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(405, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(410, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(410, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(415, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(415, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(420, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(420, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(425, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(425, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(430, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(430, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(435, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(435, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(440, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(440, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(445, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(445, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(450, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(450, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(455, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(455, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(460, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(460, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(465, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(465, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(470, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(470, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(475, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(475, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(480, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(480, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(485, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(485, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(490, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(490, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(495, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(495, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(500, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(500, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(504, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(504, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(505, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(505, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(510, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(510, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(515, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(515, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(520, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(520, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(525, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(525, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(530, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(530, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(535, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(535, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(540 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(540 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(540, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(540, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(545, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(545, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(570, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(570, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(575, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(575, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(576, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(576, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(580, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(580, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(585, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(585, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(590, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(590, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(595, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(595, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(600, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(600, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(605, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(605, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(610, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(610, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(612, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(612, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(615, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(615, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(620, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(620, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(625, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(625, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(630, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(630, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(635, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(635, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(640, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(640, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(645, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(645, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(648, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(648, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(650, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(650, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(655, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(655, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(660, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(660, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(665, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(665, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(670, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(670, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(675, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(675, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(680, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(680, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(684, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(684, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(685, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(685, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(690, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(690, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(695, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(695, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(700, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(700, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(705, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(705, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(710, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(710, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(715, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(715, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(720 - EPS_ANGLE, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
void configureDodgeStratusTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureDodgeStratusTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, false); s->initialize(FOUR_STROKE_CAM_SENSOR, false);
s->isSynchronizationNeeded = true; s->isSynchronizationNeeded = true;
@ -338,59 +338,59 @@ void configureDodgeStratusTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_
float base = 0; float base = 0;
// 2 teeth // 2 teeth
float angle = base + 120.0 - w; float angle = base + 120.0 - w;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
angle += g; angle += g;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += 120; base += 120;
// 3 teeth // 3 teeth
angle = base + 120.0 - w; angle = base + 120.0 - w;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
angle += g; angle += g;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
angle += g; angle += g;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += 120; base += 120;
// 2 teeth // 2 teeth
angle = base + 120.0 - w; angle = base + 120.0 - w;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
angle += g; angle += g;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += 120; base += 120;
// just one // just one
angle = base + 120.0 - w; angle = base + 120.0 - w;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += 120; base += 120;
// 3 teeth // 3 teeth
angle = base + 120.0 - w; angle = base + 120.0 - w;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
angle += g; angle += g;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
angle += g; angle += g;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += 120; base += 120;
// just one again // just one again
angle = base + 120.0 - w; angle = base + 120.0 - w;
s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(angle, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(angle + w, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
void configureNeon1995TriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureNeon1995TriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->setTriggerSynchronizationGap(0.8227); s->setTriggerSynchronizationGap(0.8227);
@ -402,54 +402,54 @@ void configureNeon1995TriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
s->initialState[T_PRIMARY] = 1; s->initialState[T_PRIMARY] = 1;
s->addEvent2(base - 720 + 600, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 600, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base - 720 + 604, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 604, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base - 720 + 616, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 616, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base - 720 + 620, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 620, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base - 720 + 643, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 643, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base - 720 + 648, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 648, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base - 720 + 671, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 671, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base - 720 + 676, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base - 720 + 676, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 20, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 20, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 60, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 60, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 75, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 75, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 79, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 79, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 101, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 101, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 106, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 106, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 130, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 130, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 135, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 135, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 200, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // width = 150 s->addEvent2(base + 200, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX); // width = 150
s->addEvent2(base + 236, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 236, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 239, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 239, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 250, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 250, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 255, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 255, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 277, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 277, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 282, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 282, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 305, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 305, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 310, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 310, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 374, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 374, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 395, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); // width = s->addEvent2(base + 395, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX); // width =
s->addEvent2(base + 418, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 418, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 436, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 436, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 441, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 441, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 463, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 463, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 468, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 468, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 492, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + 492, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 497, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + 497, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + 560, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // width = s->addEvent2(base + 560, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX); // width =
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
void initJeep18_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initJeep18_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->isSynchronizationNeeded = true; s->isSynchronizationNeeded = true;
s->setTriggerSynchronizationGap(1); s->setTriggerSynchronizationGap(1);
@ -458,63 +458,63 @@ void initJeep18_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
float off = 212; float off = 212;
s->addEvent2(534 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(534 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(536 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(536 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(554 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(554 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(556 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(556 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(574 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(574 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(576 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(576 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(594 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(594 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(596 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(596 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(654 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(654 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(656 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(656 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(674 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(674 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(676 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(676 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(694 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(694 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(696 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(696 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(714 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(714 - 720 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(716 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(716 - 720 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(54 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(54 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(56 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(56 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(74 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(74 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(76 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(76 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(94 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(94 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(96 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(96 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(114 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(114 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(116 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(116 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(148 + off, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // 360 s->addEvent2(148 + off, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX); // 360
s->addEvent2(174 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(174 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(176 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(176 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(194 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(194 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(196 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(196 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(214 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(214 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(216 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(216 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(234 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(234 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(236 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(236 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(294 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(294 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(296 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(296 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(314 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(314 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(316 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(316 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(334 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(334 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(336 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(336 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(354 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(354 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(356 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(356 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(414 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(414 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(416 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(416 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(434 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(434 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(436 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(436 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(454 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(454 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(456 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(456 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(474 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(474 + off, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(476 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(476 + off, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(508 + off, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); // 720 s->addEvent2(508 + off, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX); // 720
} }

128
firmware/controllers/trigger/decoders/trigger_gm.cpp
View File

@ -7,7 +7,7 @@
#include "trigger_gm.h" #include "trigger_gm.h"
void configureGmTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureGmTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CRANK_SENSOR, false); s->initialize(FOUR_STROKE_CRANK_SENSOR, false);
// all angles are x2 here - so, 5 degree width is 10 // all angles are x2 here - so, 5 degree width is 10
@ -15,26 +15,26 @@ void configureGmTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
float m = 2.0; float m = 2.0;
s->addEvent2(m * 60 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 60 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 60, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 60, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 120 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 120 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 120.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 120.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 180 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 180 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 180, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 240 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 240 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 240.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 240.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 300 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 300 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 300.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 300.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 350 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 350 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 350.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 350.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 360 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(m * 360 - w, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(m * 360.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(m * 360.0, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->setTriggerSynchronizationGap(6); s->setTriggerSynchronizationGap(6);
} }
@ -45,61 +45,61 @@ void configureGmTriggerShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
* http://www.ls2.com/forums/showthread.php/834483-LS-Timing-Reluctor-Wheels-Explained * http://www.ls2.com/forums/showthread.php/834483-LS-Timing-Reluctor-Wheels-Explained
* *
*/ */
void initGmLS24(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initGmLS24(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CRANK_SENSOR, false); s->initialize(FOUR_STROKE_CRANK_SENSOR, false);
trigger_wheel_e ch = T_PRIMARY; trigger_wheel_e ch = T_PRIMARY;
/** /**
* based on http://rusefi.com/forum/viewtopic.php?f=3&t=936&start=30 logs * based on http://rusefi.com/forum/viewtopic.php?f=3&t=936&start=30 logs
*/ */
s->addEvent2(22.2733333333334, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(22.2733333333334, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(27.59333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(27.59333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(51.18333333333338, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(51.18333333333338, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(57.58333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(57.58333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(81.17333333333337, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(81.17333333333337, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(87.61333333333339, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(87.61333333333339, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(111.30666666666671, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(111.30666666666671, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(117.81000000000004, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(117.81000000000004, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(141.50000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(141.50000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(148.05666666666673, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(148.05666666666673, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(153.41333333333338, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(153.41333333333338, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(178.29333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(178.29333333333338, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(183.51000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(183.51000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(208.3266666666667, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(208.3266666666667, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(213.50000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(213.50000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(238.26000000000005, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(238.26000000000005, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(243.51000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(243.51000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(268.27000000000004, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(268.27000000000004, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(273.53666666666675, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(273.53666666666675, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(298.35, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(298.35, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(321.86333333333334, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(321.86333333333334, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(328.4966666666667, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(328.4966666666667, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(333.81000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(333.81000000000006, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(358.66, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(358.66, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(363.8633333333334, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(363.8633333333334, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(388.7033333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(388.7033333333334, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(393.88000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(393.88000000000005, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(418.62000000000006, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(418.62000000000006, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(441.9566666666667, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(441.9566666666667, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(448.6700000000001, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(448.6700000000001, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(472.1000000000001, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(472.1000000000001, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(478.9333333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(478.9333333333334, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(484.08000000000004, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(484.08000000000004, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(509.1333333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(509.1333333333334, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(514.2666666666667, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(514.2666666666667, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(539.1733333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(539.1733333333334, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(562.5166666666668, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(562.5166666666668, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(569.1133333333333, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(569.1133333333333, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(592.5400000000001, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(592.5400000000001, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(599.1433333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(599.1433333333334, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(622.6300000000001, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(622.6300000000001, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(629.2633333333334, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(629.2633333333334, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(634.6, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(634.6, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(659.5, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(659.5, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(683.1133333333333, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(683.1133333333333, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(689.77, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(689.77, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(695.0666666666667, ch, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(695.0666666666667, ch, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0, ch, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720.0, ch, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;

214
firmware/controllers/trigger/decoders/trigger_honda.cpp
View File

@ -10,21 +10,21 @@
#define S24 (720.0f / 24 / 2) #define S24 (720.0f / 24 / 2)
static float addAccordPair(TriggerShape *s, float sb, trigger_wheel_e const waveIndex DECLARE_ENGINE_PARAMETER_S) { static float addAccordPair(TriggerShape *s, float sb, trigger_wheel_e const waveIndex DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->addEvent2(sb, waveIndex, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(sb, waveIndex, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
sb += S24; sb += S24;
s->addEvent2(sb, waveIndex, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(sb, waveIndex, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb += S24; sb += S24;
return sb; return sb;
} }
#define DIP 7.5f #define DIP 7.5f
static float addAccordPair3(TriggerShape *s, float sb DECLARE_ENGINE_PARAMETER_S) { static float addAccordPair3(TriggerShape *s, float sb DECLARE_ENGINE_PARAMETER_SUFFIX) {
sb += DIP; sb += DIP;
s->addEvent2(sb, T_CHANNEL_3, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(sb, T_CHANNEL_3, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
sb += DIP; sb += DIP;
s->addEvent2(sb, T_CHANNEL_3, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(sb, T_CHANNEL_3, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb += 2 * DIP; sb += 2 * DIP;
return sb; return sb;
} }
@ -33,65 +33,65 @@ static float addAccordPair3(TriggerShape *s, float sb DECLARE_ENGINE_PARAMETER_S
* Thank you Dip! * Thank you Dip!
* http://forum.pgmfi.org/viewtopic.php?f=2&t=15570start=210#p139007 * http://forum.pgmfi.org/viewtopic.php?f=2&t=15570start=210#p139007
*/ */
void configureHondaAccordCDDip(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureHondaAccordCDDip(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->initialState[T_SECONDARY] = TV_RISE; s->initialState[T_SECONDARY] = TV_RISE;
float sb = 0; float sb = 0;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(90, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(90, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb = 90; sb = 90;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(180, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(180, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
sb = 180; sb = 180;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(270, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(270, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb = 270; sb = 270;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360.0f - DIP, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360.0f - DIP, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
sb = 360; sb = 360;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(450, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(450, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb = 450; sb = 450;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(540, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(540, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
sb = 540; sb = 540;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(630, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(630, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb = 630; sb = 630;
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER); sb = addAccordPair3(s, sb PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0f - DIP, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720.0f - DIP, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
// s->addEvent2(720.0f - 12 * sb, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); // s->addEvent2(720.0f - 12 * sb, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
// s->addEvent2(720.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); // s->addEvent2(720.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(720.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
@ -105,7 +105,7 @@ void configureHondaAccordCDDip(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
void configureHonda_1_4_24(TriggerShape *s, bool withOneEventSignal, bool withFourEventSignal, void configureHonda_1_4_24(TriggerShape *s, bool withOneEventSignal, bool withFourEventSignal,
trigger_wheel_e const oneEventWave, trigger_wheel_e const oneEventWave,
trigger_wheel_e const fourEventWave, trigger_wheel_e const fourEventWave,
float prefix DECLARE_ENGINE_PARAMETER_S) { float prefix DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
@ -115,64 +115,64 @@ void configureHonda_1_4_24(TriggerShape *s, bool withOneEventSignal, bool withFo
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withOneEventSignal) if (withOneEventSignal)
s->addEvent2(sb - S24 / 2, oneEventWave, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(sb - S24 / 2, oneEventWave, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withOneEventSignal) if (withOneEventSignal)
s->addEvent2(sb - S24 / 2, oneEventWave, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(sb - S24 / 2, oneEventWave, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withFourEventSignal) { if (withFourEventSignal) {
s->addEvent2(1 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(1 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
} }
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withFourEventSignal) { if (withFourEventSignal) {
s->addEvent2(1 * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(1 * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb,T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb,T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withFourEventSignal) { if (withFourEventSignal) {
s->addEvent2(2 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(2 * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
} }
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withFourEventSignal) { if (withFourEventSignal) {
s->addEvent2(2 * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(2 * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
for (int i = 3; i <= 4; i++) { for (int i = 3; i <= 4; i++) {
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withFourEventSignal) { if (withFourEventSignal) {
s->addEvent2(i * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(i * 180.0f + prefix - tdcWidth, fourEventWave, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
} }
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
if (withFourEventSignal) { if (withFourEventSignal) {
s->addEvent2(i * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(i * 180.0f + prefix, fourEventWave, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
void configureHondaCbr600(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureHondaCbr600(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
// todo: finish this // todo: finish this
setToothedWheelConfiguration(s, 24, 0, FOUR_STROKE_CRANK_SENSOR PASS_ENGINE_PARAMETER); setToothedWheelConfiguration(s, 24, 0, FOUR_STROKE_CRANK_SENSOR PASS_ENGINE_PARAMETER_SUFFIX);
} }
void configureHondaCbr600custom(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureHondaCbr600custom(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
float w = 720 / 2 / 24; float w = 720 / 2 / 24;
// s->initialize(FOUR_STROKE_CAM_SENSOR, false); // s->initialize(FOUR_STROKE_CAM_SENSOR, false);
@ -186,89 +186,89 @@ void configureHondaCbr600custom(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
float a = 0; float a = 0;
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); // 30 s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX); // 30
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(52.4, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(52.4, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); // 60 s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX); // 60
for (int i = 0;i<10;i++) { for (int i = 0;i<10;i++) {
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(381.34f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(381.34f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
for (int i = 0;i<1;i++) { for (int i = 0;i<1;i++) {
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(449.1f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(449.1f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
for (int i = 0;i<8;i++) { for (int i = 0;i<8;i++) {
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
a += w; a += w;
s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
a += w; a += w;
s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a - 1, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(720.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
} }
void configureHondaAccordShifted(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureHondaAccordShifted(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
float w = 720 / 2 / 24; float w = 720 / 2 / 24;
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
float sb = S24; float sb = S24;
// like this there is no issue // like this there is no issue
// s->addEvent2(S24 + 0.001, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); // s->addEvent2(S24 + 0.001, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
// s->addEvent2(S24 + 0.1, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); // s->addEvent2(S24 + 0.1, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(S24 + 0.001, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(S24 + 0.001, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(S24 + 0.1, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(S24 + 0.1, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
sb += S24; sb += S24;
s->addEvent2(sb, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(sb, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
sb += S24; sb += S24;
s->addEvent2(S24 + 22, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(S24 + 22, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
for (int i = 0;i<23;i++) { for (int i = 0;i<23;i++) {
sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER); sb = addAccordPair(s, sb, T_SECONDARY PASS_ENGINE_PARAMETER_SUFFIX);
} }
@ -277,19 +277,19 @@ void configureHondaAccordShifted(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
} }
void configureOnePlus16(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { void configureOnePlus16(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
int totalTeethCount = 16; int totalTeethCount = 16;
int skippedCount = 0; int skippedCount = 0;
s->addEvent2(2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 2, 20 PASS_ENGINE_PARAMETER); addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 2, 20 PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(20, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(20, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 20, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 20, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER_SUFFIX);
addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 360, 360, NO_LEFT_FILTER, addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 360, 360, NO_LEFT_FILTER,
NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); NO_RIGHT_FILTER PASS_ENGINE_PARAMETER_SUFFIX);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;

130
firmware/controllers/trigger/decoders/trigger_mazda.cpp
View File

@ -20,7 +20,7 @@
#include "trigger_mazda.h" #include "trigger_mazda.h"
void initializeMazdaMiataNaShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeMazdaMiataNaShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->setTriggerSynchronizationGap2(1.4930 * 0.6f, 1.4930 * 1.3f); s->setTriggerSynchronizationGap2(1.4930 * 0.6f, 1.4930 * 1.3f);
s->useRiseEdge = false; s->useRiseEdge = false;
@ -32,26 +32,26 @@ void initializeMazdaMiataNaShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
/** /**
* http://rusefi.com/forum/viewtopic.php?f=3&t=729&p=12983#p12983 * http://rusefi.com/forum/viewtopic.php?f=3&t=729&p=12983#p12983
*/ */
s->addEvent2(52.960405, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(52.960405, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(122.635956, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(122.635956, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(216.897031, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(216.897031, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(232.640068, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(232.640068, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(288.819688, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(288.819688, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(302.646323, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(302.646323, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(412.448056, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(412.448056, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(482.816719, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(482.816719, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(577.035495, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(577.035495, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(592.878113, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(592.878113, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(662.899708, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(662.899708, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
// TT_MIATA_VVT // TT_MIATA_VVT
void initializeMazdaMiataNb2Crank(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeMazdaMiataNb2Crank(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR, false); s->initialize(FOUR_STROKE_SYMMETRICAL_CRANK_SENSOR, false);
float o = 160; float o = 160;
@ -59,13 +59,13 @@ void initializeMazdaMiataNb2Crank(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
s->tdcPosition = 60 + 655; s->tdcPosition = 60 + 655;
s->setTriggerSynchronizationGap2(0.35f, 0.98f); s->setTriggerSynchronizationGap2(0.35f, 0.98f);
s->addEvent2(o + 4 * 56.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(o + 4 * 56.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(o + 4 * 60.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(o + 4 * 60.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(o + 4 * 136.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(o + 4 * 136.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(o + 4 * 140.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(o + 4 * 140.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
} }
static void initializeMazdaMiataNb1ShapeWithOffset(TriggerShape *s, float offset DECLARE_ENGINE_PARAMETER_S) { static void initializeMazdaMiataNb1ShapeWithOffset(TriggerShape *s, float offset DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->setTriggerSynchronizationGap(0.11f); s->setTriggerSynchronizationGap(0.11f);
s->useRiseEdge = false; s->useRiseEdge = false;
@ -76,45 +76,45 @@ static void initializeMazdaMiataNb1ShapeWithOffset(TriggerShape *s, float offset
/** /**
* cam sensor is primary, crank sensor is secondary * cam sensor is primary, crank sensor is secondary
*/ */
s->addEvent2(20.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(20.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 66.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 66.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 70.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 70.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 136.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 136.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 140.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 140.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 246.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 246.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 250.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 250.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 316.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 316.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 320.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 320.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(340.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(340.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(380.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(380.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(400.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(400.0f, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 426.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 426.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 430.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 430.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 496.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 496.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 500.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 500.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 606.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 606.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 610.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 610.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 676.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(offset + 676.0f, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + 680.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(offset + 680.0f, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720.0f, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
void initializeMazdaMiataNb1Shape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeMazdaMiataNb1Shape(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
initializeMazdaMiataNb1ShapeWithOffset(s, 0 PASS_ENGINE_PARAMETER); initializeMazdaMiataNb1ShapeWithOffset(s, 0 PASS_ENGINE_PARAMETER_SUFFIX);
} }
void initializeMazdaMiataVVtTestShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeMazdaMiataVVtTestShape(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
initializeMazdaMiataNb1ShapeWithOffset(s, -22 PASS_ENGINE_PARAMETER); initializeMazdaMiataNb1ShapeWithOffset(s, -22 PASS_ENGINE_PARAMETER_SUFFIX);
} }
void configureMazdaProtegeSOHC(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureMazdaProtegeSOHC(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
// todo: move to into configuration definition s->needSecondTriggerInput = FALSE; // todo: move to into configuration definition s->needSecondTriggerInput = FALSE;
@ -126,23 +126,23 @@ void configureMazdaProtegeSOHC(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
float z = 0.093; float z = 0.093;
a = 180; a = 180;
s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += 180; a += 180;
s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += 180; a += 180;
s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
a += 180; a += 180;
s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a - z * 720, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
} }
void configureMazdaProtegeLx(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void configureMazdaProtegeLx(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
// todo: move to into configuration definition s->needSecondTriggerInput = FALSE; // todo: move to into configuration definition s->needSecondTriggerInput = FALSE;
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
@ -150,21 +150,21 @@ void configureMazdaProtegeLx(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
/** /**
* based on https://svn.code.sf.net/p/rusefi/code/trunk/misc/logs/1993_escort_gt/MAIN_rfi_report_2015-02-01%2017_39.csv * based on https://svn.code.sf.net/p/rusefi/code/trunk/misc/logs/1993_escort_gt/MAIN_rfi_report_2015-02-01%2017_39.csv
*/ */
s->addEvent2(95.329254, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(95.329254, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 14.876692, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 14.876692, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 82.693557, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 82.693557, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 137.119154, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 137.119154, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 192.378308, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 192.378308, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 261.556418, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 261.556418, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 373.060597, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 373.060597, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 443.503184, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 443.503184, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(95.329254 + 555.349776, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(95.329254 + 555.349776, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->tdcPosition = 137.119154; s->tdcPosition = 137.119154;
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;

48
firmware/controllers/trigger/decoders/trigger_mitsubishi.cpp
View File

@ -7,31 +7,31 @@
#include "trigger_mitsubishi.h" #include "trigger_mitsubishi.h"
void configureFordAspireTriggerShape(TriggerShape * s DECLARE_ENGINE_PARAMETER_S) { void configureFordAspireTriggerShape(TriggerShape * s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
float x = 121.90; float x = 121.90;
float y = 110.86; float y = 110.86;
s->addEvent2(x + y - 180, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(x + y - 180, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(x, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(x, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(x + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(x + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(x + 180, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(x + 180, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(x + 180 + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(x + 180 + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(x + 360, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(x + 360, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(x + 360 + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(x + 360 + y, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(x + 540, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(x + 540, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
/** /**
* TT_MITSUBISHI = 11 * TT_MITSUBISHI = 11
*/ */
void initializeMitsubishi4g18(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeMitsubishi4g18(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->useRiseEdge = false; s->useRiseEdge = false;
@ -39,17 +39,17 @@ void initializeMitsubishi4g18(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
int secondaryWidth = 70; int secondaryWidth = 70;
s->addEvent2(106.77999999999997, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(106.77999999999997, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(120.09999999999998, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(120.09999999999998, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(188.0775, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(188.0775, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(286.33, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(286.33, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(298.875, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(298.875, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(354.91999999999996, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(354.91999999999996, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(366.6825, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(366.6825, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(476.45, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(476.45, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(543.9749999999999, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(543.9749999999999, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(639.52, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(639.52, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(653.15, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(653.15, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720.0, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720.0, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }

38
firmware/controllers/trigger/decoders/trigger_nissan.cpp
View File

@ -8,7 +8,7 @@
#include "trigger_nissan.h" #include "trigger_nissan.h"
#include "trigger_universal.h" #include "trigger_universal.h"
static void initializeNissanSR20VE_4_optional_360(TriggerShape *s, bool with2nd DECLARE_ENGINE_PARAMETER_S) { static void initializeNissanSR20VE_4_optional_360(TriggerShape *s, bool with2nd DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, with2nd); s->initialize(FOUR_STROKE_CAM_SENSOR, with2nd);
s->isSynchronizationNeeded = true; s->isSynchronizationNeeded = true;
s->gapBothDirections = true; s->gapBothDirections = true;
@ -29,18 +29,18 @@ static void initializeNissanSR20VE_4_optional_360(TriggerShape *s, bool with2nd
if (with2nd) { if (with2nd) {
addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720, addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720,
left, right PASS_ENGINE_PARAMETER); left, right PASS_ENGINE_PARAMETER_SUFFIX);
} }
s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
left = right; left = right;
right = base; right = base;
if (with2nd) { if (with2nd) {
addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720, addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720,
left, right PASS_ENGINE_PARAMETER); left, right PASS_ENGINE_PARAMETER_SUFFIX);
} }
s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
// was is the the one with 360 opto sensor? // was is the the one with 360 opto sensor?
@ -50,43 +50,43 @@ static void initializeNissanSR20VE_4_optional_360(TriggerShape *s, bool with2nd
right = base - w; right = base - w;
if (with2nd) { if (with2nd) {
// addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720, // addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720,
// left, right PASS_ENGINE_PARAMETER); // left, right PASS_ENGINE_PARAMETER_SUFFIX);
} }
s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
left = right; left = right;
right = base; right = base;
if (with2nd) { if (with2nd) {
// addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720, // addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720,
// left, right PASS_ENGINE_PARAMETER); // left, right PASS_ENGINE_PARAMETER_SUFFIX);
} }
s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += 180; base += 180;
left = right; left = right;
right = base - w; right = base - w;
if (with2nd) { if (with2nd) {
// addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720, // addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720,
// left, right PASS_ENGINE_PARAMETER); // left, right PASS_ENGINE_PARAMETER_SUFFIX);
} }
s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
left = right; left = right;
right = base; right = base;
if (with2nd) { if (with2nd) {
// addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720, // addSkippedToothTriggerEvents(T_SECONDARY, s, total, 0, 0.5, 0, 720,
// left, right PASS_ENGINE_PARAMETER); // left, right PASS_ENGINE_PARAMETER_SUFFIX);
} }
s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += 180; base += 180;
left = right; left = right;
right = base - w; right = base - w;
s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
left = right; left = right;
right = base; right = base;
s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(right, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
} }
@ -94,10 +94,10 @@ static void initializeNissanSR20VE_4_optional_360(TriggerShape *s, bool with2nd
* Nissan Primera p11 year 1995-2002 * Nissan Primera p11 year 1995-2002
*/ */
void initializeNissanSR20VE_4(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeNissanSR20VE_4(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
initializeNissanSR20VE_4_optional_360(s, false PASS_ENGINE_PARAMETER); initializeNissanSR20VE_4_optional_360(s, false PASS_ENGINE_PARAMETER_SUFFIX);
} }
void initializeNissanSR20VE_4_360(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeNissanSR20VE_4_360(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
initializeNissanSR20VE_4_optional_360(s, true PASS_ENGINE_PARAMETER); initializeNissanSR20VE_4_optional_360(s, true PASS_ENGINE_PARAMETER_SUFFIX);
} }

22
firmware/controllers/trigger/decoders/trigger_rover.cpp
View File

@ -11,7 +11,7 @@
/** /**
* https://en.wikipedia.org/wiki/Rover_K-series_engine * https://en.wikipedia.org/wiki/Rover_K-series_engine
*/ */
void initializeRoverK(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeRoverK(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CRANK_SENSOR, false); s->initialize(FOUR_STROKE_CRANK_SENSOR, false);
float tooth = 20; float tooth = 20;
@ -23,32 +23,32 @@ void initializeRoverK(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
float base = 0; float base = 0;
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += tooth; base += tooth;
} }
base += tooth; base += tooth;
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += tooth; base += tooth;
} }
base += tooth; base += tooth;
for (int i = 0; i < 14; i++) { for (int i = 0; i < 14; i++) {
s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += tooth; base += tooth;
} }
base += tooth; base += tooth;
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += tooth; base += tooth;
} }
base += tooth; base += tooth;
for (int i = 0; i < 11; i++) { for (int i = 0; i < 11; i++) {
s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + tooth, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += tooth; base += tooth;
} }

100
firmware/controllers/trigger/decoders/trigger_subaru.cpp
View File

@ -10,7 +10,7 @@
/** /**
* This trigger is also used by Nissan and Mazda * This trigger is also used by Nissan and Mazda
*/ */
void initialize36_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initialize36_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
float wide = 30 * 2; float wide = 30 * 2;
@ -23,89 +23,89 @@ void initialize36_2_2_2(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
float base = 0; float base = 0;
for (int i = 0; i < 12; i++) { for (int i = 0; i < 12; i++) {
s->addEvent2(base + narrow / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + narrow / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + narrow, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + narrow, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += narrow; base += narrow;
} }
s->addEvent2(base + wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + wide, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + wide, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += wide; base += wide;
for (int i = 0; i < 15; i++) { for (int i = 0; i < 15; i++) {
s->addEvent2(base + narrow / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(base + narrow / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(base + narrow, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(base + narrow, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
base += narrow; base += narrow;
} }
s->addEvent2(720 - wide - wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(720 - wide - wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720 - wide, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720 - wide, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720 - wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(720 - wide / 2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
void initializeSubaru7_6(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initializeSubaru7_6(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
float magic = 333; float magic = 333;
float width = 5; float width = 5;
s->addEvent2(25 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(25 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(25, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(25, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 180 - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic - 180 - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 180 - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic - 180 - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 180 - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic - 180 - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 180 - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic - 180 - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 180 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic - 180 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 180, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic - 180, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(182 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(182 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(182, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(182, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(343 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(343 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(343, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(343, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(366 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(366 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(366, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(366, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(384 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(384 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(384, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(384, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 180 - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic + 180 - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 180 - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic + 180 - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 180 - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic + 180 - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 180 - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic + 180 - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 180 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic + 180 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 180, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic + 180, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(538 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(538 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(538, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(538, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 360 - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic + 360 - 87 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 360 - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic + 360 - 87, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 360 - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic + 360 - 55 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 360 - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic + 360 - 55, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 360 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(magic + 360 - width, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(magic + 360, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(magic + 360, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(720 - width, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->setTriggerSynchronizationGap2(4.9, 9); s->setTriggerSynchronizationGap2(4.9, 9);
s->setSecondTriggerSynchronizationGap2(0.6, 1.25); s->setSecondTriggerSynchronizationGap2(0.6, 1.25);

22
firmware/controllers/trigger/decoders/trigger_toyota.cpp
View File

@ -11,42 +11,42 @@
EXTERN_ENGINE; EXTERN_ENGINE;
void initialize2jzGE1_12(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initialize2jzGE1_12(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
float crankD = 360 / 12 / 2; // 15 float crankD = 360 / 12 / 2; // 15
float crankAngle = 10; float crankAngle = 10;
s->addEvent2(crankAngle, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); // 120 s->addEvent2(crankAngle, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX); // 120
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX);
crankAngle += crankD; crankAngle += crankD;
s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); // 120 s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX); // 120
crankAngle += crankD; crankAngle += crankD;
} }
s->addEvent2(75, T_PRIMARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); s->addEvent2(75, T_PRIMARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX);
for (int i = 0; i < 21; i++) { for (int i = 0; i < 21; i++) {
s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX);
crankAngle += crankD; crankAngle += crankD;
s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER); // 120 s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_FALL, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX); // 120
crankAngle += crankD; crankAngle += crankD;
} }
s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); s->addEvent2(crankAngle + crankD, T_SECONDARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX);
crankAngle += crankD; crankAngle += crankD;
s->addEvent2(720, T_PRIMARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_RISE, -1, 721 PASS_ENGINE_PARAMETER_SUFFIX);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
} }
void initialize2jzGE3_34(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void initialize2jzGE3_34(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
setToothedWheelConfiguration(s, 36, 2, FOUR_STROKE_CRANK_SENSOR PASS_ENGINE_PARAMETER); setToothedWheelConfiguration(s, 36, 2, FOUR_STROKE_CRANK_SENSOR PASS_ENGINE_PARAMETER_SUFFIX);
// s->initialize(FOUR_STROKE_CAM_SENSOR, true); // s->initialize(FOUR_STROKE_CAM_SENSOR, true);
// //

14
firmware/controllers/trigger/decoders/trigger_universal.cpp
View File

@ -12,24 +12,24 @@ angle_t getEngineCycle(operation_mode_e operationMode) {
} }
void addSkippedToothTriggerEvents(trigger_wheel_e wheel, TriggerShape *s, int totalTeethCount, int skippedCount, void addSkippedToothTriggerEvents(trigger_wheel_e wheel, TriggerShape *s, int totalTeethCount, int skippedCount,
float toothWidth, float offset, float engineCycle, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_S) { float toothWidth, float offset, float engineCycle, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssertVoid(totalTeethCount > 0, "total count"); efiAssertVoid(totalTeethCount > 0, "total count");
efiAssertVoid(skippedCount >= 0, "skipped count"); efiAssertVoid(skippedCount >= 0, "skipped count");
for (int i = 0; i < totalTeethCount - skippedCount - 1; i++) { for (int i = 0; i < totalTeethCount - skippedCount - 1; i++) {
float angleDown = engineCycle / totalTeethCount * (i + (1 - toothWidth)); float angleDown = engineCycle / totalTeethCount * (i + (1 - toothWidth));
float angleUp = engineCycle / totalTeethCount * (i + 1); float angleUp = engineCycle / totalTeethCount * (i + 1);
s->addEvent2(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight PASS_ENGINE_PARAMETER); s->addEvent2(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + angleUp, wheel, TV_FALL, filterLeft, filterRight PASS_ENGINE_PARAMETER); s->addEvent2(offset + angleUp, wheel, TV_FALL, filterLeft, filterRight PASS_ENGINE_PARAMETER_SUFFIX);
} }
float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth)); float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth));
s->addEvent2(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight PASS_ENGINE_PARAMETER); s->addEvent2(offset + angleDown, wheel, TV_RISE, filterLeft, filterRight PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(offset + engineCycle, wheel, TV_FALL, filterLeft, filterRight PASS_ENGINE_PARAMETER); s->addEvent2(offset + engineCycle, wheel, TV_FALL, filterLeft, filterRight PASS_ENGINE_PARAMETER_SUFFIX);
} }
void initializeSkippedToothTriggerShapeExt(TriggerShape *s, int totalTeethCount, int skippedCount, void initializeSkippedToothTriggerShapeExt(TriggerShape *s, int totalTeethCount, int skippedCount,
operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (totalTeethCount <= 0) { if (totalTeethCount <= 0) {
warning(CUSTOM_OBD_TRIGGER_SHAPE, "totalTeethCount is zero or less: %d", totalTeethCount); warning(CUSTOM_OBD_TRIGGER_SHAPE, "totalTeethCount is zero or less: %d", totalTeethCount);
s->shapeDefinitionError = true; s->shapeDefinitionError = true;
@ -42,6 +42,6 @@ void initializeSkippedToothTriggerShapeExt(TriggerShape *s, int totalTeethCount,
s->isSynchronizationNeeded = (totalTeethCount > 2) && (skippedCount != 0); s->isSynchronizationNeeded = (totalTeethCount > 2) && (skippedCount != 0);
addSkippedToothTriggerEvents(T_PRIMARY, s, totalTeethCount, skippedCount, 0.5, 0, getEngineCycle(operationMode), addSkippedToothTriggerEvents(T_PRIMARY, s, totalTeethCount, skippedCount, 0.5, 0, getEngineCycle(operationMode),
NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER_SUFFIX);
} }

50
firmware/controllers/trigger/main_trigger_callback.cpp
View File

@ -97,7 +97,7 @@ static void endSimultaniousInjection(InjectionEvent *event) {
for (int i = 0; i < engine->engineConfiguration->specs.cylindersCount; i++) { for (int i = 0; i < engine->engineConfiguration->specs.cylindersCount; i++) {
enginePins.injectors[i].setLow(); enginePins.injectors[i].setLow();
} }
engine->injectionEvents.addFuelEventsForCylinder(event->ownIndex PASS_ENGINE_PARAMETER); engine->injectionEvents.addFuelEventsForCylinder(event->ownIndex PASS_ENGINE_PARAMETER_SUFFIX);
} }
static void tempTurnPinHigh(InjectorOutputPin *output) { static void tempTurnPinHigh(InjectorOutputPin *output) {
@ -194,7 +194,7 @@ void seTurnPinLow(OutputSignalPair *pair) {
Engine *engine = pair->event->engine; Engine *engine = pair->event->engine;
EXPAND_Engine; EXPAND_Engine;
#endif #endif
engine->injectionEvents.addFuelEventsForCylinder(pair->event->ownIndex PASS_ENGINE_PARAMETER); engine->injectionEvents.addFuelEventsForCylinder(pair->event->ownIndex PASS_ENGINE_PARAMETER_SUFFIX);
} }
static void seScheduleByTime(scheduling_s *scheduling, efitimeus_t time, schfunc_t callback, OutputSignalPair *pair) { static void seScheduleByTime(scheduling_s *scheduling, efitimeus_t time, schfunc_t callback, OutputSignalPair *pair) {
@ -210,7 +210,7 @@ static void seScheduleByTime(scheduling_s *scheduling, efitimeus_t time, schfunc
scheduleByTime(scheduling, time, callback, pair); scheduleByTime(scheduling, time, callback, pair);
} }
static void scheduleFuelInjection(OutputSignalPair *pair, efitimeus_t nowUs, floatus_t delayUs, floatus_t durationUs, InjectionEvent *event DECLARE_ENGINE_PARAMETER_S) { static void scheduleFuelInjection(OutputSignalPair *pair, efitimeus_t nowUs, floatus_t delayUs, floatus_t durationUs, InjectionEvent *event DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (durationUs < 0) { if (durationUs < 0) {
warning(CUSTOM_NEGATIVE_DURATION, "duration cannot be negative: %d", durationUs); warning(CUSTOM_NEGATIVE_DURATION, "duration cannot be negative: %d", durationUs);
return; return;
@ -255,14 +255,14 @@ static void scheduleFuelInjection(OutputSignalPair *pair, efitimeus_t nowUs, flo
} }
static ALWAYS_INLINE void handleFuelInjectionEvent(int injEventIndex, InjectionEvent *event, static ALWAYS_INLINE void handleFuelInjectionEvent(int injEventIndex, InjectionEvent *event,
int rpm DECLARE_ENGINE_PARAMETER_S) { int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
/** /**
* todo: this is a bit tricky with batched injection. is it? Does the same * todo: this is a bit tricky with batched injection. is it? Does the same
* wetting coefficient works the same way for any injection mode, or is something * wetting coefficient works the same way for any injection mode, or is something
* x2 or /2? * x2 or /2?
*/ */
const floatms_t injectionDuration = ENGINE(wallFuel).adjust(event->outputs[0]->injectorIndex, ENGINE(fuelMs) PASS_ENGINE_PARAMETER); const floatms_t injectionDuration = ENGINE(wallFuel).adjust(event->outputs[0]->injectorIndex, ENGINE(fuelMs) PASS_ENGINE_PARAMETER_SUFFIX);
#if EFI_PRINTF_FUEL_DETAILS || defined(__DOXYGEN__) #if EFI_PRINTF_FUEL_DETAILS || defined(__DOXYGEN__)
printf("fuel fuelMs=%f adjusted=%f\t\n", ENGINE(fuelMs), injectionDuration); printf("fuel fuelMs=%f adjusted=%f\t\n", ENGINE(fuelMs), injectionDuration);
#endif /*EFI_PRINTF_FUEL_DETAILS */ #endif /*EFI_PRINTF_FUEL_DETAILS */
@ -271,9 +271,9 @@ static ALWAYS_INLINE void handleFuelInjectionEvent(int injEventIndex, InjectionE
* todo: pre-calculate 'numberOfInjections' * todo: pre-calculate 'numberOfInjections'
* see also injectorDutyCycle * see also injectorDutyCycle
*/ */
if (!isCrankingR(rpm) && injectionDuration * getNumberOfInjections(engineConfiguration->injectionMode PASS_ENGINE_PARAMETER) > getEngineCycleDuration(rpm PASS_ENGINE_PARAMETER)) { if (!isCrankingR(rpm) && injectionDuration * getNumberOfInjections(engineConfiguration->injectionMode PASS_ENGINE_PARAMETER_SUFFIX) > getEngineCycleDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX)) {
warning(CUSTOM_TOO_LONG_FUEL_INJECTION, "Too long fuel injection %fms", injectionDuration); warning(CUSTOM_TOO_LONG_FUEL_INJECTION, "Too long fuel injection %fms", injectionDuration);
} else if (isCrankingR(rpm) && injectionDuration * getNumberOfInjections(engineConfiguration->crankingInjectionMode PASS_ENGINE_PARAMETER) > getEngineCycleDuration(rpm PASS_ENGINE_PARAMETER)) { } else if (isCrankingR(rpm) && injectionDuration * getNumberOfInjections(engineConfiguration->crankingInjectionMode PASS_ENGINE_PARAMETER_SUFFIX) > getEngineCycleDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX)) {
warning(CUSTOM_TOO_LONG_CRANKING_FUEL_INJECTION, "Too long cranking fuel injection %fms", injectionDuration); warning(CUSTOM_TOO_LONG_CRANKING_FUEL_INJECTION, "Too long cranking fuel injection %fms", injectionDuration);
} }
@ -335,15 +335,15 @@ static ALWAYS_INLINE void handleFuelInjectionEvent(int injEventIndex, InjectionE
prevOutputName = outputName; prevOutputName = outputName;
} }
scheduleFuelInjection(pair, getTimeNowUs(), injectionStartDelayUs, MS2US(injectionDuration), event PASS_ENGINE_PARAMETER); scheduleFuelInjection(pair, getTimeNowUs(), injectionStartDelayUs, MS2US(injectionDuration), event PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
static void fuelClosedLoopCorrection(DECLARE_ENGINE_PARAMETER_F) { static void fuelClosedLoopCorrection(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
#if ! EFI_UNIT_TEST #if ! EFI_UNIT_TEST
if (ENGINE(rpmCalculator.rpmValue) < CONFIG(fuelClosedLoopRpmThreshold) || if (ENGINE(rpmCalculator.rpmValue) < CONFIG(fuelClosedLoopRpmThreshold) ||
ENGINE(sensors.clt) < CONFIG(fuelClosedLoopCltThreshold) || ENGINE(sensors.clt) < CONFIG(fuelClosedLoopCltThreshold) ||
getTPS(PASS_ENGINE_PARAMETER_F) > CONFIG(fuelClosedLoopTpsThreshold) || getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) > CONFIG(fuelClosedLoopTpsThreshold) ||
ENGINE(sensors.currentAfr) < engineConfiguration->fuelClosedLoopAfrLowThreshold || ENGINE(sensors.currentAfr) < engineConfiguration->fuelClosedLoopAfrLowThreshold ||
ENGINE(sensors.currentAfr) > engineConfiguration->fuelClosedLoopAfrHighThreshold) { ENGINE(sensors.currentAfr) > engineConfiguration->fuelClosedLoopAfrHighThreshold) {
engine->engineState.fuelPidCorrection = 0; engine->engineState.fuelPidCorrection = 0;
@ -361,7 +361,7 @@ static void fuelClosedLoopCorrection(DECLARE_ENGINE_PARAMETER_F) {
} }
static ALWAYS_INLINE void handleFuel(const bool limitedFuel, uint32_t trgEventIndex, int rpm DECLARE_ENGINE_PARAMETER_S) { static ALWAYS_INLINE void handleFuel(const bool limitedFuel, uint32_t trgEventIndex, int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 128, "lowstck#3"); efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 128, "lowstck#3");
efiAssertVoid(trgEventIndex < engine->engineCycleEventCount, "handleFuel/event index"); efiAssertVoid(trgEventIndex < engine->engineCycleEventCount, "handleFuel/event index");
@ -379,17 +379,17 @@ static ALWAYS_INLINE void handleFuel(const bool limitedFuel, uint32_t trgEventIn
*/ */
FuelSchedule *fs = &engine->injectionEvents; FuelSchedule *fs = &engine->injectionEvents;
if (!fs->isReady) { if (!fs->isReady) {
fs->addFuelEvents(PASS_ENGINE_PARAMETER_F); fs->addFuelEvents(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
#if FUEL_MATH_EXTREME_LOGGING || defined(__DOXYGEN__) #if FUEL_MATH_EXTREME_LOGGING || defined(__DOXYGEN__)
scheduleMsg(logger, "handleFuel ind=%d %d", trgEventIndex, getRevolutionCounter()); scheduleMsg(logger, "handleFuel ind=%d %d", trgEventIndex, getRevolutionCounter());
#endif /* FUEL_MATH_EXTREME_LOGGING */ #endif /* FUEL_MATH_EXTREME_LOGGING */
ENGINE(tpsAccelEnrichment.onNewValue(getTPS(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER)); ENGINE(tpsAccelEnrichment.onNewValue(getTPS(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX));
ENGINE(engineLoadAccelEnrichment.onEngineCycle(PASS_ENGINE_PARAMETER_F)); ENGINE(engineLoadAccelEnrichment.onEngineCycle(PASS_ENGINE_PARAMETER_SIGNATURE));
ENGINE(fuelMs) = getInjectionDuration(rpm PASS_ENGINE_PARAMETER) * CONFIG(globalFuelCorrection); ENGINE(fuelMs) = getInjectionDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX) * CONFIG(globalFuelCorrection);
for (int injEventIndex = 0; injEventIndex < CONFIG(specs.cylindersCount); injEventIndex++) { for (int injEventIndex = 0; injEventIndex < CONFIG(specs.cylindersCount); injEventIndex++) {
InjectionEvent *event = &fs->elements[injEventIndex]; InjectionEvent *event = &fs->elements[injEventIndex];
@ -399,7 +399,7 @@ static ALWAYS_INLINE void handleFuel(const bool limitedFuel, uint32_t trgEventIn
if (eventIndex != trgEventIndex) { if (eventIndex != trgEventIndex) {
continue; continue;
} }
handleFuelInjectionEvent(injEventIndex, event, rpm PASS_ENGINE_PARAMETER); handleFuelInjectionEvent(injEventIndex, event, rpm PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
@ -424,7 +424,7 @@ uint32_t *cyccnt = (uint32_t*) &DWT->CYCCNT;
* This is the main trigger event handler. * This is the main trigger event handler.
* Both injection and ignition are controlled from this method. * Both injection and ignition are controlled from this method.
*/ */
void mainTriggerCallback(trigger_event_e ckpSignalType, uint32_t trgEventIndex DECLARE_ENGINE_PARAMETER_S) { void mainTriggerCallback(trigger_event_e ckpSignalType, uint32_t trgEventIndex DECLARE_ENGINE_PARAMETER_SUFFIX) {
(void) ckpSignalType; (void) ckpSignalType;
ENGINE(m.beforeMainTrigger) = GET_TIMESTAMP(); ENGINE(m.beforeMainTrigger) = GET_TIMESTAMP();
@ -482,13 +482,13 @@ void mainTriggerCallback(trigger_event_e ckpSignalType, uint32_t trgEventIndex D
engine->ignitionEvents.isReady = false; // we need to rebuild ignition schedule engine->ignitionEvents.isReady = false; // we need to rebuild ignition schedule
engine->injectionEvents.isReady = false; engine->injectionEvents.isReady = false;
// todo: move 'triggerIndexByAngle' change into trigger initialization, why is it invoked from here if it's only about trigger shape & optimization? // todo: move 'triggerIndexByAngle' change into trigger initialization, why is it invoked from here if it's only about trigger shape & optimization?
prepareOutputSignals(PASS_ENGINE_PARAMETER_F); prepareOutputSignals(PASS_ENGINE_PARAMETER_SIGNATURE);
// we need this to apply new 'triggerIndexByAngle' values // we need this to apply new 'triggerIndexByAngle' values
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
if (CONFIG(fuelClosedLoopCorrectionEnabled)) { if (CONFIG(fuelClosedLoopCorrectionEnabled)) {
fuelClosedLoopCorrection(PASS_ENGINE_PARAMETER_F); fuelClosedLoopCorrection(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
} }
@ -506,11 +506,11 @@ void mainTriggerCallback(trigger_event_e ckpSignalType, uint32_t trgEventIndex D
* For fuel we schedule start of injection based on trigger angle, and then inject for * For fuel we schedule start of injection based on trigger angle, and then inject for
* specified duration of time * specified duration of time
*/ */
handleFuel(limitedFuel, trgEventIndex, rpm PASS_ENGINE_PARAMETER); handleFuel(limitedFuel, trgEventIndex, rpm PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* For spark we schedule both start of coil charge and actual spark based on trigger angle * For spark we schedule both start of coil charge and actual spark based on trigger angle
*/ */
handleSpark(limitedSpark, trgEventIndex, rpm PASS_ENGINE_PARAMETER); handleSpark(limitedSpark, trgEventIndex, rpm PASS_ENGINE_PARAMETER_SUFFIX);
#if EFI_HISTOGRAMS || defined(__DOXYGEN__) #if EFI_HISTOGRAMS || defined(__DOXYGEN__)
int diff = hal_lld_get_counter_value() - beforeCallback; int diff = hal_lld_get_counter_value() - beforeCallback;
if (diff > 0) if (diff > 0)
@ -536,10 +536,10 @@ static void showTriggerHistogram(void) {
static void showMainInfo(Engine *engine) { static void showMainInfo(Engine *engine) {
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
int rpm = engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F); int rpm = engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE);
float el = getEngineLoadT(PASS_ENGINE_PARAMETER_F); float el = getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE);
scheduleMsg(logger, "rpm %d engine_load %f", rpm, el); scheduleMsg(logger, "rpm %d engine_load %f", rpm, el);
scheduleMsg(logger, "fuel %fms timing %f", getInjectionDuration(rpm PASS_ENGINE_PARAMETER), engine->engineState.timingAdvance); scheduleMsg(logger, "fuel %fms timing %f", getInjectionDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX), engine->engineState.timingAdvance);
#endif #endif
} }

26
firmware/controllers/trigger/rpm_calculator.cpp
View File

@ -65,7 +65,7 @@ RpmCalculator::RpmCalculator() {
/** /**
* @return true if there was a full shaft revolution within the last second * @return true if there was a full shaft revolution within the last second
*/ */
bool RpmCalculator::isRunning(DECLARE_ENGINE_PARAMETER_F) { bool RpmCalculator::isRunning(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
efitick_t nowNt = getTimeNowNt(); efitick_t nowNt = getTimeNowNt();
if (engine->stopEngineRequestTimeNt != 0) { if (engine->stopEngineRequestTimeNt != 0) {
if (nowNt if (nowNt
@ -101,14 +101,14 @@ void RpmCalculator::assignRpmValue(int value) {
} }
} }
void RpmCalculator::setRpmValue(int value DECLARE_ENGINE_PARAMETER_S) { void RpmCalculator::setRpmValue(int value DECLARE_ENGINE_PARAMETER_SUFFIX) {
assignRpmValue(value); assignRpmValue(value);
if (previousRpmValue == 0 && rpmValue > 0) { if (previousRpmValue == 0 && rpmValue > 0) {
/** /**
* this would make sure that we have good numbers for first cranking revolution * this would make sure that we have good numbers for first cranking revolution
* #275 cranking could be improved * #275 cranking could be improved
*/ */
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
} }
@ -139,12 +139,12 @@ float RpmCalculator::getRpmAcceleration() {
*/ */
// todo: migrate to float return result or add a float version? this would have with calculations // todo: migrate to float return result or add a float version? this would have with calculations
// todo: add a version which does not check time & saves time? need to profile // todo: add a version which does not check time & saves time? need to profile
int RpmCalculator::getRpm(DECLARE_ENGINE_PARAMETER_F) { int RpmCalculator::getRpm(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
#if !EFI_PROD_CODE #if !EFI_PROD_CODE
if (mockRpm != MOCK_UNDEFINED) if (mockRpm != MOCK_UNDEFINED)
return mockRpm; return mockRpm;
#endif #endif
if (!isRunning(PASS_ENGINE_PARAMETER_F)) { if (!isRunning(PASS_ENGINE_PARAMETER_SIGNATURE)) {
revolutionCounterSinceStart = 0; revolutionCounterSinceStart = 0;
if (rpmValue != 0) { if (rpmValue != 0) {
rpmValue = 0; rpmValue = 0;
@ -176,7 +176,7 @@ bool isCranking(void) {
* This callback is invoked on interrupt thread. * This callback is invoked on interrupt thread.
*/ */
void rpmShaftPositionCallback(trigger_event_e ckpSignalType, void rpmShaftPositionCallback(trigger_event_e ckpSignalType,
uint32_t index DECLARE_ENGINE_PARAMETER_S) { uint32_t index DECLARE_ENGINE_PARAMETER_SUFFIX) {
RpmCalculator *rpmState = &engine->rpmCalculator; RpmCalculator *rpmState = &engine->rpmCalculator;
efitick_t nowNt = getTimeNowNt(); efitick_t nowNt = getTimeNowNt();
engine->m.beforeRpmCb = GET_TIMESTAMP(); engine->m.beforeRpmCb = GET_TIMESTAMP();
@ -188,7 +188,7 @@ void rpmShaftPositionCallback(trigger_event_e ckpSignalType,
angle_t crankAngle = NAN; angle_t crankAngle = NAN;
int signal = -1; int signal = -1;
if (ENGINE(sensorChartMode) == SC_TRIGGER) { if (ENGINE(sensorChartMode) == SC_TRIGGER) {
crankAngle = getCrankshaftAngleNt(nowNt PASS_ENGINE_PARAMETER); crankAngle = getCrankshaftAngleNt(nowNt PASS_ENGINE_PARAMETER_SUFFIX);
signal = 1000 * ckpSignalType + index; signal = 1000 * ckpSignalType + index;
} }
#endif #endif
@ -203,7 +203,7 @@ void rpmShaftPositionCallback(trigger_event_e ckpSignalType,
} }
// todo: wrap this with if (index == 0) statement this would make scAddData logic simpler // todo: wrap this with if (index == 0) statement this would make scAddData logic simpler
bool hadRpmRecently = rpmState->isRunning(PASS_ENGINE_PARAMETER_F); bool hadRpmRecently = rpmState->isRunning(PASS_ENGINE_PARAMETER_SIGNATURE);
if (hadRpmRecently) { if (hadRpmRecently) {
efitime_t diffNt = nowNt - rpmState->lastRpmEventTimeNt; efitime_t diffNt = nowNt - rpmState->lastRpmEventTimeNt;
@ -215,11 +215,11 @@ void rpmShaftPositionCallback(trigger_event_e ckpSignalType,
* *
*/ */
if (diffNt == 0) { if (diffNt == 0) {
rpmState->setRpmValue(NOISY_RPM PASS_ENGINE_PARAMETER); rpmState->setRpmValue(NOISY_RPM PASS_ENGINE_PARAMETER_SUFFIX);
} else { } else {
int mult = (int)getEngineCycle(engineConfiguration->operationMode) / 360; int mult = (int)getEngineCycle(engineConfiguration->operationMode) / 360;
int rpm = (int) (60 * US2NT(US_PER_SECOND_LL) * mult / diffNt); int rpm = (int) (60 * US2NT(US_PER_SECOND_LL) * mult / diffNt);
rpmState->setRpmValue(rpm > UNREALISTIC_RPM ? NOISY_RPM : rpm PASS_ENGINE_PARAMETER); rpmState->setRpmValue(rpm > UNREALISTIC_RPM ? NOISY_RPM : rpm PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
rpmState->onNewEngineCycle(); rpmState->onNewEngineCycle();
@ -252,7 +252,7 @@ static void onTdcCallback(void) {
* This trigger callback schedules the actual physical TDC callback in relation to trigger synchronization point. * This trigger callback schedules the actual physical TDC callback in relation to trigger synchronization point.
*/ */
static void tdcMarkCallback(trigger_event_e ckpSignalType, static void tdcMarkCallback(trigger_event_e ckpSignalType,
uint32_t index0 DECLARE_ENGINE_PARAMETER_S) { uint32_t index0 DECLARE_ENGINE_PARAMETER_SUFFIX) {
(void) ckpSignalType; (void) ckpSignalType;
bool isTriggerSynchronizationPoint = index0 == 0; bool isTriggerSynchronizationPoint = index0 == 0;
if (isTriggerSynchronizationPoint && ENGINE(isEngineChartEnabled)) { if (isTriggerSynchronizationPoint && ENGINE(isEngineChartEnabled)) {
@ -276,7 +276,7 @@ int getRevolutionCounter() {
/** /**
* @return Current crankshaft angle, 0 to 720 for four-stroke * @return Current crankshaft angle, 0 to 720 for four-stroke
*/ */
float getCrankshaftAngleNt(efitime_t timeNt DECLARE_ENGINE_PARAMETER_S) { float getCrankshaftAngleNt(efitime_t timeNt DECLARE_ENGINE_PARAMETER_SUFFIX) {
efitime_t timeSinceZeroAngleNt = timeNt efitime_t timeSinceZeroAngleNt = timeNt
- engine->rpmCalculator.lastRpmEventTimeNt; - engine->rpmCalculator.lastRpmEventTimeNt;
@ -285,7 +285,7 @@ float getCrankshaftAngleNt(efitime_t timeNt DECLARE_ENGINE_PARAMETER_S) {
* compiler is not smart enough to figure out that "A / ( B / C)" could be optimized into * compiler is not smart enough to figure out that "A / ( B / C)" could be optimized into
* "A * C / B" in order to replace a slower division with a faster multiplication. * "A * C / B" in order to replace a slower division with a faster multiplication.
*/ */
int rpm = engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F); int rpm = engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE);
return rpm == 0 ? NAN : timeSinceZeroAngleNt / getOneDegreeTimeNt(rpm); return rpm == 0 ? NAN : timeSinceZeroAngleNt / getOneDegreeTimeNt(rpm);
} }

36
firmware/controllers/trigger/spark_logic.cpp
View File

@ -30,7 +30,7 @@ int isIgnitionTimingError(void) {
return ignitionErrorDetection.sum(6) > 4; return ignitionErrorDetection.sum(6) > 4;
} }
void prepareIgnitionSchedule(IgnitionEvent *event DECLARE_ENGINE_PARAMETER_S); void prepareIgnitionSchedule(IgnitionEvent *event DECLARE_ENGINE_PARAMETER_SUFFIX);
static void turnSparkPinLow2(IgnitionEvent *event, IgnitionOutputPin *output) { static void turnSparkPinLow2(IgnitionEvent *event, IgnitionOutputPin *output) {
#if SPARK_EXTREME_LOGGING || defined(__DOXYGEN__) #if SPARK_EXTREME_LOGGING || defined(__DOXYGEN__)
@ -73,7 +73,7 @@ void turnSparkPinLow(IgnitionEvent *event) {
EXPAND_Engine; EXPAND_Engine;
#endif #endif
// now that we've just fired a coil let's prepare the new schedule for the next engine revolution // now that we've just fired a coil let's prepare the new schedule for the next engine revolution
prepareIgnitionSchedule(event PASS_ENGINE_PARAMETER); prepareIgnitionSchedule(event PASS_ENGINE_PARAMETER_SUFFIX);
} }
static void turnSparkPinHigh2(IgnitionEvent *event, IgnitionOutputPin *output) { static void turnSparkPinHigh2(IgnitionEvent *event, IgnitionOutputPin *output) {
@ -122,7 +122,7 @@ void turnSparkPinHigh(IgnitionEvent *event) {
static int globalSparkIdCoutner = 0; static int globalSparkIdCoutner = 0;
static ALWAYS_INLINE void handleSparkEvent(bool limitedSpark, uint32_t trgEventIndex, IgnitionEvent *iEvent, static ALWAYS_INLINE void handleSparkEvent(bool limitedSpark, uint32_t trgEventIndex, IgnitionEvent *iEvent,
int rpm DECLARE_ENGINE_PARAMETER_S) { int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
const floatms_t dwellMs = ENGINE(engineState.sparkDwell); const floatms_t dwellMs = ENGINE(engineState.sparkDwell);
if (cisnan(dwellMs) || dwellMs <= 0) { if (cisnan(dwellMs) || dwellMs <= 0) {
@ -172,7 +172,7 @@ static ALWAYS_INLINE void handleSparkEvent(bool limitedSpark, uint32_t trgEventI
* Spark event is often happening during a later trigger event timeframe * Spark event is often happening during a later trigger event timeframe
* TODO: improve precision * TODO: improve precision
*/ */
TRIGGER_SHAPE(findTriggerPosition(&iEvent->sparkPosition, iEvent->advance PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&iEvent->sparkPosition, iEvent->advance PASS_ENGINE_PARAMETER_SUFFIX));
#if EFI_UNIT_TEST || defined(__DOXYGEN__) #if EFI_UNIT_TEST || defined(__DOXYGEN__)
printf("spark dwell@ %d/%d spark@ %d/%d id=%d\r\n", iEvent->dwellPosition.eventIndex, (int)iEvent->dwellPosition.angleOffset, printf("spark dwell@ %d/%d spark@ %d/%d id=%d\r\n", iEvent->dwellPosition.eventIndex, (int)iEvent->dwellPosition.angleOffset,
@ -217,19 +217,19 @@ static ALWAYS_INLINE void handleSparkEvent(bool limitedSpark, uint32_t trgEventI
} }
void prepareIgnitionSchedule(IgnitionEvent *event DECLARE_ENGINE_PARAMETER_S) { void prepareIgnitionSchedule(IgnitionEvent *event DECLARE_ENGINE_PARAMETER_SUFFIX) {
// todo: clean up this implementation? does not look too nice as is. // todo: clean up this implementation? does not look too nice as is.
// change of sign here from 'before TDC' to 'after TDC' // change of sign here from 'before TDC' to 'after TDC'
const angle_t localAdvance = -ENGINE(engineState.timingAdvance) + ENGINE(angleExtra[event->cylinderIndex]) + CONFIG(timing_offset_cylinder[event->cylinderIndex]); const angle_t localAdvance = -ENGINE(engineState.timingAdvance) + ENGINE(angleExtra[event->cylinderIndex]) + CONFIG(timing_offset_cylinder[event->cylinderIndex]);
const int index = ENGINE(ignitionPin[event->cylinderIndex]); const int index = ENGINE(ignitionPin[event->cylinderIndex]);
const int coilIndex = ID2INDEX(getCylinderId(index PASS_ENGINE_PARAMETER)); const int coilIndex = ID2INDEX(getCylinderId(index PASS_ENGINE_PARAMETER_SUFFIX));
IgnitionOutputPin *output = &enginePins.coils[coilIndex]; IgnitionOutputPin *output = &enginePins.coils[coilIndex];
IgnitionOutputPin *secondOutput; IgnitionOutputPin *secondOutput;
if (CONFIG(ignitionMode) == IM_WASTED_SPARK && CONFIG(twoWireBatchIgnition)) { if (CONFIG(ignitionMode) == IM_WASTED_SPARK && CONFIG(twoWireBatchIgnition)) {
int secondIndex = index + CONFIG(specs.cylindersCount) / 2; int secondIndex = index + CONFIG(specs.cylindersCount) / 2;
int secondCoilIndex = ID2INDEX(getCylinderId(secondIndex PASS_ENGINE_PARAMETER)); int secondCoilIndex = ID2INDEX(getCylinderId(secondIndex PASS_ENGINE_PARAMETER_SUFFIX));
secondOutput = &enginePins.coils[secondCoilIndex]; secondOutput = &enginePins.coils[secondCoilIndex];
assertPinAssigned(secondOutput); assertPinAssigned(secondOutput);
} else { } else {
@ -243,7 +243,7 @@ void prepareIgnitionSchedule(IgnitionEvent *event DECLARE_ENGINE_PARAMETER_S) {
event->outputs[1] = secondOutput; event->outputs[1] = secondOutput;
event->advance = localAdvance; event->advance = localAdvance;
TRIGGER_SHAPE(findTriggerPosition(&event->dwellPosition, localAdvance - dwellAngle PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&event->dwellPosition, localAdvance - dwellAngle PASS_ENGINE_PARAMETER_SUFFIX));
#if FUEL_MATH_EXTREME_LOGGING || defined(__DOXYGEN__) #if FUEL_MATH_EXTREME_LOGGING || defined(__DOXYGEN__)
printf("addIgnitionEvent %s ind=%d\n", output->name, event->dwellPosition.eventIndex); printf("addIgnitionEvent %s ind=%d\n", output->name, event->dwellPosition.eventIndex);
@ -251,7 +251,7 @@ void prepareIgnitionSchedule(IgnitionEvent *event DECLARE_ENGINE_PARAMETER_S) {
#endif /* FUEL_MATH_EXTREME_LOGGING */ #endif /* FUEL_MATH_EXTREME_LOGGING */
} }
static void initializeIgnitionActions(IgnitionEventList *list DECLARE_ENGINE_PARAMETER_S) { static void initializeIgnitionActions(IgnitionEventList *list DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (cisnan(ENGINE(engineState.timingAdvance))) { if (cisnan(ENGINE(engineState.timingAdvance))) {
// error should already be reported // error should already be reported
// need to invalidate previous ignition schedule // need to invalidate previous ignition schedule
@ -265,12 +265,12 @@ static void initializeIgnitionActions(IgnitionEventList *list DECLARE_ENGINE_PAR
#if EFI_UNIT_TEST #if EFI_UNIT_TEST
list->elements[cylinderIndex].engine = engine; list->elements[cylinderIndex].engine = engine;
#endif #endif
prepareIgnitionSchedule(&list->elements[cylinderIndex] PASS_ENGINE_PARAMETER); prepareIgnitionSchedule(&list->elements[cylinderIndex] PASS_ENGINE_PARAMETER_SUFFIX);
} }
list->isReady = true; list->isReady = true;
} }
static ALWAYS_INLINE void prepareIgnitionSchedule(DECLARE_ENGINE_PARAMETER_F) { static ALWAYS_INLINE void prepareIgnitionSchedule(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
engine->m.beforeIgnitionSch = GET_TIMESTAMP(); engine->m.beforeIgnitionSch = GET_TIMESTAMP();
/** /**
@ -297,12 +297,12 @@ static ALWAYS_INLINE void prepareIgnitionSchedule(DECLARE_ENGINE_PARAMETER_F) {
IgnitionEventList *list = &engine->ignitionEvents; IgnitionEventList *list = &engine->ignitionEvents;
initializeIgnitionActions(list PASS_ENGINE_PARAMETER); initializeIgnitionActions(list PASS_ENGINE_PARAMETER_SUFFIX);
engine->m.ignitionSchTime = GET_TIMESTAMP() - engine->m.beforeIgnitionSch; engine->m.ignitionSchTime = GET_TIMESTAMP() - engine->m.beforeIgnitionSch;
} }
void handleSpark(bool limitedSpark, uint32_t trgEventIndex, int rpm void handleSpark(bool limitedSpark, uint32_t trgEventIndex, int rpm
DECLARE_ENGINE_PARAMETER_S) { DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (!isValidRpm(rpm) || !CONFIG(isIgnitionEnabled)) { if (!isValidRpm(rpm) || !CONFIG(isIgnitionEnabled)) {
// this might happen for instance in case of a single trigger event after a pause // this might happen for instance in case of a single trigger event after a pause
@ -310,7 +310,7 @@ void handleSpark(bool limitedSpark, uint32_t trgEventIndex, int rpm
} }
if (!engine->ignitionEvents.isReady) { if (!engine->ignitionEvents.isReady) {
prepareIgnitionSchedule(PASS_ENGINE_PARAMETER_F); prepareIgnitionSchedule(PASS_ENGINE_PARAMETER_SIGNATURE);
} }
/** /**
@ -344,7 +344,7 @@ void handleSpark(bool limitedSpark, uint32_t trgEventIndex, int rpm
IgnitionEvent *event = &engine->ignitionEvents.elements[i]; IgnitionEvent *event = &engine->ignitionEvents.elements[i];
if (event->dwellPosition.eventIndex != trgEventIndex) if (event->dwellPosition.eventIndex != trgEventIndex)
continue; continue;
handleSparkEvent(limitedSpark, trgEventIndex, event, rpm PASS_ENGINE_PARAMETER); handleSparkEvent(limitedSpark, trgEventIndex, event, rpm PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
} }
@ -357,7 +357,7 @@ void initSparkLogic(Logging *sharedLogger) {
* Number of sparks per physical coil * Number of sparks per physical coil
* @see getNumberOfInjections * @see getNumberOfInjections
*/ */
int getNumberOfSparks(ignition_mode_e mode DECLARE_ENGINE_PARAMETER_S) { int getNumberOfSparks(ignition_mode_e mode DECLARE_ENGINE_PARAMETER_SUFFIX) {
switch (mode) { switch (mode) {
case IM_ONE_COIL: case IM_ONE_COIL:
return engineConfiguration->specs.cylindersCount; return engineConfiguration->specs.cylindersCount;
@ -374,8 +374,8 @@ int getNumberOfSparks(ignition_mode_e mode DECLARE_ENGINE_PARAMETER_S) {
/** /**
* @see getInjectorDutyCycle * @see getInjectorDutyCycle
*/ */
percent_t getCoilDutyCycle(int rpm DECLARE_ENGINE_PARAMETER_S) { percent_t getCoilDutyCycle(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
floatms_t totalPerCycle = 1/**getInjectionDuration(rpm PASS_ENGINE_PARAMETER)*/ * getNumberOfSparks(engineConfiguration->ignitionMode PASS_ENGINE_PARAMETER); floatms_t totalPerCycle = 1/**getInjectionDuration(rpm PASS_ENGINE_PARAMETER_SUFFIX)*/ * getNumberOfSparks(engineConfiguration->ignitionMode PASS_ENGINE_PARAMETER_SUFFIX);
floatms_t engineCycleDuration = getCrankshaftRevolutionTimeMs(rpm) * (engineConfiguration->operationMode == TWO_STROKE ? 1 : 2); floatms_t engineCycleDuration = getCrankshaftRevolutionTimeMs(rpm) * (engineConfiguration->operationMode == TWO_STROKE ? 1 : 2);
return 100 * totalPerCycle / engineCycleDuration; return 100 * totalPerCycle / engineCycleDuration;
} }

20
firmware/controllers/trigger/trigger_central.cpp
View File

@ -42,11 +42,11 @@ static histogram_s triggerCallbackHistogram;
static Logging *logger; static Logging *logger;
efitime_t getCrankEventCounter(DECLARE_ENGINE_PARAMETER_F) { efitime_t getCrankEventCounter(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return engine->triggerCentral.triggerState.getTotalEventCounter(); return engine->triggerCentral.triggerState.getTotalEventCounter();
} }
efitime_t getStartOfRevolutionIndex(DECLARE_ENGINE_PARAMETER_F) { efitime_t getStartOfRevolutionIndex(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return engine->triggerCentral.triggerState.getStartOfRevolutionIndex(); return engine->triggerCentral.triggerState.getStartOfRevolutionIndex();
} }
@ -171,7 +171,7 @@ void hwHandleShaftSignal(trigger_event_e signal) {
maxTriggerReentraint = triggerReentraint; maxTriggerReentraint = triggerReentraint;
triggerReentraint++; triggerReentraint++;
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 128, "lowstck#8"); efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 128, "lowstck#8");
engine->triggerCentral.handleShaftSignal(signal PASS_ENGINE_PARAMETER); engine->triggerCentral.handleShaftSignal(signal PASS_ENGINE_PARAMETER_SUFFIX);
triggerReentraint--; triggerReentraint--;
triggerDuration = GET_TIMESTAMP() - triggerHanlderEntryTime; triggerDuration = GET_TIMESTAMP() - triggerHanlderEntryTime;
isInsideTriggerHandler = false; isInsideTriggerHandler = false;
@ -206,7 +206,7 @@ static char shaft_signal_msg_index[15];
static bool isUpEvent[6] = { false, true, false, true, false, true }; static bool isUpEvent[6] = { false, true, false, true, false, true };
static const char *eventId[6] = { CRANK1, CRANK1, CRANK2, CRANK2, CRANK3, CRANK3 }; static const char *eventId[6] = { CRANK1, CRANK1, CRANK2, CRANK2, CRANK3, CRANK3 };
static ALWAYS_INLINE void reportEventToWaveChart(trigger_event_e ckpSignalType, int index DECLARE_ENGINE_PARAMETER_S) { static ALWAYS_INLINE void reportEventToWaveChart(trigger_event_e ckpSignalType, int index DECLARE_ENGINE_PARAMETER_SUFFIX) {
itoa10(&shaft_signal_msg_index[2], index); itoa10(&shaft_signal_msg_index[2], index);
bool isUp = isUpEvent[(int) ckpSignalType]; bool isUp = isUpEvent[(int) ckpSignalType];
shaft_signal_msg_index[0] = isUp ? 'u' : 'd'; shaft_signal_msg_index[0] = isUp ? 'u' : 'd';
@ -219,7 +219,7 @@ static ALWAYS_INLINE void reportEventToWaveChart(trigger_event_e ckpSignalType,
} }
} }
void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PARAMETER_S) { void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssertVoid(engine!=NULL, "configuration"); efiAssertVoid(engine!=NULL, "configuration");
if (triggerShape.shapeDefinitionError) { if (triggerShape.shapeDefinitionError) {
@ -251,7 +251,7 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PAR
/** /**
* This invocation changes the state of triggerState * This invocation changes the state of triggerState
*/ */
triggerState.decodeTriggerEvent(signal, nowNt PASS_ENGINE_PARAMETER); triggerState.decodeTriggerEvent(signal, nowNt PASS_ENGINE_PARAMETER_SUFFIX);
/** /**
* If we only have a crank position sensor with four stroke, here we are extending crank revolutions with a 360 degree * If we only have a crank position sensor with four stroke, here we are extending crank revolutions with a 360 degree
@ -272,14 +272,14 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PAR
if (triggerIndexForListeners == 0) { if (triggerIndexForListeners == 0) {
timeAtVirtualZeroNt = nowNt; timeAtVirtualZeroNt = nowNt;
} }
reportEventToWaveChart(signal, triggerIndexForListeners PASS_ENGINE_PARAMETER); reportEventToWaveChart(signal, triggerIndexForListeners PASS_ENGINE_PARAMETER_SUFFIX);
if (!triggerState.shaft_is_synchronized) { if (!triggerState.shaft_is_synchronized) {
// we should not propagate event if we do not know where we are // we should not propagate event if we do not know where we are
return; return;
} }
if (triggerState.isValidIndex(PASS_ENGINE_PARAMETER_F)) { if (triggerState.isValidIndex(PASS_ENGINE_PARAMETER_SIGNATURE)) {
#if TRIGGER_EXTREME_LOGGING || defined(__DOXYGEN__) #if TRIGGER_EXTREME_LOGGING || defined(__DOXYGEN__)
scheduleMsg(logger, "trigger %d %d %d", triggerIndexForListeners, getRevolutionCounter(), (int)getTimeNowUs()); scheduleMsg(logger, "trigger %d %d %d", triggerIndexForListeners, getRevolutionCounter(), (int)getTimeNowUs());
#endif /* FUEL_MATH_EXTREME_LOGGING */ #endif /* FUEL_MATH_EXTREME_LOGGING */
@ -289,7 +289,7 @@ void TriggerCentral::handleShaftSignal(trigger_event_e signal DECLARE_ENGINE_PAR
*/ */
for (int i = 0; i < triggerListeneres.currentListenersCount; i++) { for (int i = 0; i < triggerListeneres.currentListenersCount; i++) {
ShaftPositionListener listener = (ShaftPositionListener) triggerListeneres.callbacks[i]; ShaftPositionListener listener = (ShaftPositionListener) triggerListeneres.callbacks[i];
(listener)(signal, triggerIndexForListeners PASS_ENGINE_PARAMETER); (listener)(signal, triggerIndexForListeners PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
@ -360,7 +360,7 @@ void printAllTriggers() {
engineConfiguration->operationMode = FOUR_STROKE_CAM_SENSOR; engineConfiguration->operationMode = FOUR_STROKE_CAM_SENSOR;
TriggerShape *s = &engine->triggerCentral.triggerShape; TriggerShape *s = &engine->triggerCentral.triggerShape;
s->initializeTriggerShape(NULL PASS_ENGINE_PARAMETER); s->initializeTriggerShape(NULL PASS_ENGINE_PARAMETER_SUFFIX);
fprintf(fp, "TRIGGERTYPE %d %d %s %f\r\n", triggerId, s->getLength(), getTrigger_type_e(tt), s->tdcPosition); fprintf(fp, "TRIGGERTYPE %d %d %s %f\r\n", triggerId, s->getLength(), getTrigger_type_e(tt), s->tdcPosition);

140
firmware/controllers/trigger/trigger_decoder.cpp
View File

@ -76,7 +76,7 @@ bool isTriggerDecoderError(void) {
return errorDetection.sum(6) > 4; return errorDetection.sum(6) > 4;
} }
bool TriggerState::isValidIndex(DECLARE_ENGINE_PARAMETER_F) { bool TriggerState::isValidIndex(DECLARE_ENGINE_PARAMETER_SIGNATURE) {
return currentCycle.current_index < TRIGGER_SHAPE(size); return currentCycle.current_index < TRIGGER_SHAPE(size);
} }
@ -145,7 +145,7 @@ static trigger_value_e eventType[6] = { TV_FALL, TV_RISE, TV_FALL, TV_RISE, TV_F
* @param signal type of event which just happened * @param signal type of event which just happened
* @param nowNt current time * @param nowNt current time
*/ */
void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t nowNt DECLARE_ENGINE_PARAMETER_S) { void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t nowNt DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssertVoid(signal <= SHAFT_3RD_RISING, "unexpected signal"); efiAssertVoid(signal <= SHAFT_3RD_RISING, "unexpected signal");
trigger_wheel_e triggerWheel = eventIndex[signal]; trigger_wheel_e triggerWheel = eventIndex[signal];
@ -384,7 +384,7 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
toothed_previous_duration = currentDuration; toothed_previous_duration = currentDuration;
toothed_previous_time = nowNt; toothed_previous_time = nowNt;
} }
if (!isValidIndex(PASS_ENGINE_PARAMETER_F) && !isInitializingTrigger) { if (!isValidIndex(PASS_ENGINE_PARAMETER_SIGNATURE) && !isInitializingTrigger) {
// let's not show a warning if we are just starting to spin // let's not show a warning if we are just starting to spin
if (engine->rpmCalculator.rpmValue != 0) { if (engine->rpmCalculator.rpmValue != 0) {
warning(CUSTOM_SYNC_ERROR, "sync error: index #%d above total size %d", currentCycle.current_index, TRIGGER_SHAPE(size)); warning(CUSTOM_SYNC_ERROR, "sync error: index #%d above total size %d", currentCycle.current_index, TRIGGER_SHAPE(size));
@ -427,7 +427,7 @@ void TriggerState::decodeTriggerEvent(trigger_event_e const signal, efitime_t no
} }
} }
void configure3_1_cam(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { void configure3_1_cam(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
@ -436,61 +436,61 @@ void configure3_1_cam(TriggerShape *s, operation_mode_e operationMode DECLARE_EN
trigger_wheel_e crank = T_SECONDARY; trigger_wheel_e crank = T_SECONDARY;
s->addEvent2(10, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(10, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(50, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(50, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
float a = 2 * crankW; float a = 2 * crankW;
// #1/3 // #1/3
s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
// #2/3 // #2/3
s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
// #3/3 // #3/3
a += crankW; a += crankW;
a += crankW; a += crankW;
// 2nd #1/3 // 2nd #1/3
s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
// 2nd #2/3 // 2nd #2/3
s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(a += crankW, crank, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
} }
void configureOnePlusOne(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { void configureOnePlusOne(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_SUFFIX) {
float engineCycle = getEngineCycle(operationMode); float engineCycle = getEngineCycle(operationMode);
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->addEvent2(180, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(180, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(360, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(540, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(540, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
} }
void configureOnePlus60_2(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { void configureOnePlus60_2(TriggerShape *s, operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
int totalTeethCount = 60; int totalTeethCount = 60;
int skippedCount = 2; int skippedCount = 2;
s->addEvent2(2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(2, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 2, 20 PASS_ENGINE_PARAMETER); addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 2, 20 PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(20, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(20, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 20, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 0, 360, 20, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER_SUFFIX);
addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 360, 360, NO_LEFT_FILTER, addSkippedToothTriggerEvents(T_SECONDARY, s, totalTeethCount, skippedCount, 0.5, 360, 360, NO_LEFT_FILTER,
NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); NO_RIGHT_FILTER PASS_ENGINE_PARAMETER_SUFFIX);
s->isSynchronizationNeeded = false; s->isSynchronizationNeeded = false;
s->useOnlyPrimaryForSync = true; s->useOnlyPrimaryForSync = true;
@ -501,7 +501,7 @@ static TriggerState initState CCM_OPTIONAL;
/** /**
* External logger is needed because at this point our logger is not yet initialized * External logger is needed because at this point our logger is not yet initialized
*/ */
void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMETER_S) { void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMETER_SUFFIX) {
const trigger_config_s *triggerConfig = &engineConfiguration->trigger; const trigger_config_s *triggerConfig = &engineConfiguration->trigger;
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 256, "init t"); efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 256, "init t");
@ -514,160 +514,160 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET
case TT_TOOTHED_WHEEL: case TT_TOOTHED_WHEEL:
initializeSkippedToothTriggerShapeExt(this, triggerConfig->customTotalToothCount, initializeSkippedToothTriggerShapeExt(this, triggerConfig->customTotalToothCount,
triggerConfig->customSkippedToothCount, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); triggerConfig->customSkippedToothCount, engineConfiguration->operationMode PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MAZDA_MIATA_NA: case TT_MAZDA_MIATA_NA:
initializeMazdaMiataNaShape(this PASS_ENGINE_PARAMETER); initializeMazdaMiataNaShape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MAZDA_MIATA_NB1: case TT_MAZDA_MIATA_NB1:
initializeMazdaMiataNb1Shape(this PASS_ENGINE_PARAMETER); initializeMazdaMiataNb1Shape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MAZDA_MIATA_VVT_TEST: case TT_MAZDA_MIATA_VVT_TEST:
initializeMazdaMiataVVtTestShape(this PASS_ENGINE_PARAMETER); initializeMazdaMiataVVtTestShape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MIATA_VVT: case TT_MIATA_VVT:
initializeMazdaMiataNb2Crank(this PASS_ENGINE_PARAMETER); initializeMazdaMiataNb2Crank(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_DODGE_NEON_1995: case TT_DODGE_NEON_1995:
configureNeon1995TriggerShape(this PASS_ENGINE_PARAMETER); configureNeon1995TriggerShape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_DODGE_STRATUS: case TT_DODGE_STRATUS:
configureDodgeStratusTriggerShape(this PASS_ENGINE_PARAMETER); configureDodgeStratusTriggerShape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_DODGE_NEON_2003_CAM: case TT_DODGE_NEON_2003_CAM:
configureNeon2003TriggerShapeCam(this PASS_ENGINE_PARAMETER); configureNeon2003TriggerShapeCam(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_DODGE_NEON_2003_CRANK: case TT_DODGE_NEON_2003_CRANK:
configureNeon2003TriggerShapeCam(this PASS_ENGINE_PARAMETER); configureNeon2003TriggerShapeCam(this PASS_ENGINE_PARAMETER_SUFFIX);
// configureNeon2003TriggerShapeCrank(triggerShape PASS_ENGINE_PARAMETER); // configureNeon2003TriggerShapeCrank(triggerShape PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_FORD_ASPIRE: case TT_FORD_ASPIRE:
configureFordAspireTriggerShape(this PASS_ENGINE_PARAMETER); configureFordAspireTriggerShape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_GM_7X: case TT_GM_7X:
configureGmTriggerShape(this PASS_ENGINE_PARAMETER); configureGmTriggerShape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MAZDA_DOHC_1_4: case TT_MAZDA_DOHC_1_4:
configureMazdaProtegeLx(this PASS_ENGINE_PARAMETER); configureMazdaProtegeLx(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_ONE_PLUS_ONE: case TT_ONE_PLUS_ONE:
configureOnePlusOne(this, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); configureOnePlusOne(this, engineConfiguration->operationMode PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_3_1_CAM: case TT_3_1_CAM:
configure3_1_cam(this, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); configure3_1_cam(this, engineConfiguration->operationMode PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_ONE_PLUS_TOOTHED_WHEEL_60_2: case TT_ONE_PLUS_TOOTHED_WHEEL_60_2:
configureOnePlus60_2(this, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); configureOnePlus60_2(this, engineConfiguration->operationMode PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_ONE: case TT_ONE:
setToothedWheelConfiguration(this, 1, 0, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); setToothedWheelConfiguration(this, 1, 0, engineConfiguration->operationMode PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MAZDA_SOHC_4: case TT_MAZDA_SOHC_4:
configureMazdaProtegeSOHC(this PASS_ENGINE_PARAMETER); configureMazdaProtegeSOHC(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MINI_COOPER_R50: case TT_MINI_COOPER_R50:
configureMiniCooperTriggerShape(this PASS_ENGINE_PARAMETER); configureMiniCooperTriggerShape(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_TOOTHED_WHEEL_60_2: case TT_TOOTHED_WHEEL_60_2:
setToothedWheelConfiguration(this, 60, 2, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); setToothedWheelConfiguration(this, 60, 2, engineConfiguration->operationMode PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_60_2_VW: case TT_60_2_VW:
setVwConfiguration(this PASS_ENGINE_PARAMETER); setVwConfiguration(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_TOOTHED_WHEEL_36_1: case TT_TOOTHED_WHEEL_36_1:
setToothedWheelConfiguration(this, 36, 1, engineConfiguration->operationMode PASS_ENGINE_PARAMETER); setToothedWheelConfiguration(this, 36, 1, engineConfiguration->operationMode PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_HONDA_4_24_1: case TT_HONDA_4_24_1:
configureHonda_1_4_24(this, true, true, T_CHANNEL_3, T_PRIMARY, 0 PASS_ENGINE_PARAMETER); configureHonda_1_4_24(this, true, true, T_CHANNEL_3, T_PRIMARY, 0 PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_HONDA_4_24: case TT_HONDA_4_24:
configureHonda_1_4_24(this, false, true, T_NONE, T_PRIMARY, 0 PASS_ENGINE_PARAMETER); configureHonda_1_4_24(this, false, true, T_NONE, T_PRIMARY, 0 PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_HONDA_1_24: case TT_HONDA_1_24:
configureHonda_1_4_24(this, true, false, T_PRIMARY, T_NONE, 10 PASS_ENGINE_PARAMETER); configureHonda_1_4_24(this, true, false, T_PRIMARY, T_NONE, 10 PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_HONDA_ACCORD_1_24_SHIFTED: case TT_HONDA_ACCORD_1_24_SHIFTED:
configureHondaAccordShifted(this PASS_ENGINE_PARAMETER); configureHondaAccordShifted(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_HONDA_1_4_24: case TT_HONDA_1_4_24:
configureHondaAccordCDDip(this PASS_ENGINE_PARAMETER); configureHondaAccordCDDip(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_HONDA_CBR_600: case TT_HONDA_CBR_600:
configureHondaCbr600(this PASS_ENGINE_PARAMETER); configureHondaCbr600(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_HONDA_CBR_600_CUSTOM: case TT_HONDA_CBR_600_CUSTOM:
configureHondaCbr600custom(this PASS_ENGINE_PARAMETER); configureHondaCbr600custom(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_MITSUBISHI: case TT_MITSUBISHI:
initializeMitsubishi4g18(this PASS_ENGINE_PARAMETER); initializeMitsubishi4g18(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_DODGE_RAM: case TT_DODGE_RAM:
initDodgeRam(this PASS_ENGINE_PARAMETER); initDodgeRam(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_JEEP_18_2_2_2: case TT_JEEP_18_2_2_2:
initJeep18_2_2_2(this PASS_ENGINE_PARAMETER); initJeep18_2_2_2(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_SUBARU_7_6: case TT_SUBARU_7_6:
initializeSubaru7_6(this PASS_ENGINE_PARAMETER); initializeSubaru7_6(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_36_2_2_2: case TT_36_2_2_2:
initialize36_2_2_2(this PASS_ENGINE_PARAMETER); initialize36_2_2_2(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_2JZ_3_34: case TT_2JZ_3_34:
initialize2jzGE3_34(this PASS_ENGINE_PARAMETER); initialize2jzGE3_34(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_2JZ_1_12: case TT_2JZ_1_12:
initialize2jzGE1_12(this PASS_ENGINE_PARAMETER); initialize2jzGE1_12(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_NISSAN_SR20VE: case TT_NISSAN_SR20VE:
initializeNissanSR20VE_4(this PASS_ENGINE_PARAMETER); initializeNissanSR20VE_4(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_NISSAN_SR20VE_360: case TT_NISSAN_SR20VE_360:
initializeNissanSR20VE_4_360(this PASS_ENGINE_PARAMETER); initializeNissanSR20VE_4_360(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_ROVER_K: case TT_ROVER_K:
initializeRoverK(this PASS_ENGINE_PARAMETER); initializeRoverK(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
case TT_GM_LS_24: case TT_GM_LS_24:
initGmLS24(this PASS_ENGINE_PARAMETER); initGmLS24(this PASS_ENGINE_PARAMETER_SUFFIX);
break; break;
default: default:
@ -681,7 +681,7 @@ void TriggerShape::initializeTriggerShape(Logging *logger DECLARE_ENGINE_PARAMET
* #192 BUG real hardware trigger events could be coming even while we are initializing trigger * #192 BUG real hardware trigger events could be coming even while we are initializing trigger
*/ */
initState.reset(); initState.reset();
calculateTriggerSynchPoint(&initState PASS_ENGINE_PARAMETER); calculateTriggerSynchPoint(&initState PASS_ENGINE_PARAMETER_SUFFIX);
} }
static void onFindIndex(TriggerState *state) { static void onFindIndex(TriggerState *state) {
@ -698,7 +698,7 @@ static void onFindIndex(TriggerState *state) {
* This function finds the index of synchronization event within TriggerShape * This function finds the index of synchronization event within TriggerShape
*/ */
uint32_t findTriggerZeroEventIndex(TriggerState *state, TriggerShape * shape, uint32_t findTriggerZeroEventIndex(TriggerState *state, TriggerShape * shape,
trigger_config_s const*triggerConfig DECLARE_ENGINE_PARAMETER_S) { trigger_config_s const*triggerConfig DECLARE_ENGINE_PARAMETER_SUFFIX) {
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
efiAssert(getRemainingStack(chThdGetSelfX()) > 128, "findPos", -1); efiAssert(getRemainingStack(chThdGetSelfX()) > 128, "findPos", -1);
#endif #endif
@ -715,7 +715,7 @@ uint32_t findTriggerZeroEventIndex(TriggerState *state, TriggerShape * shape,
// todo: should this variable be declared 'static' to reduce stack usage? // todo: should this variable be declared 'static' to reduce stack usage?
TriggerStimulatorHelper helper; TriggerStimulatorHelper helper;
uint32_t syncIndex = helper.doFindTrigger(shape, triggerConfig, state PASS_ENGINE_PARAMETER); uint32_t syncIndex = helper.doFindTrigger(shape, triggerConfig, state PASS_ENGINE_PARAMETER_SUFFIX);
if (syncIndex == EFI_ERROR_CODE) { if (syncIndex == EFI_ERROR_CODE) {
isInitializingTrigger = false; isInitializingTrigger = false;
return syncIndex; return syncIndex;
@ -736,7 +736,7 @@ uint32_t findTriggerZeroEventIndex(TriggerState *state, TriggerShape * shape,
*/ */
state->cycleCallback = onFindIndex; state->cycleCallback = onFindIndex;
helper.assertSyncPositionAndSetDutyCycle(syncIndex, state, shape, triggerConfig PASS_ENGINE_PARAMETER); helper.assertSyncPositionAndSetDutyCycle(syncIndex, state, shape, triggerConfig PASS_ENGINE_PARAMETER_SUFFIX);
isInitializingTrigger = false; isInitializingTrigger = false;
return syncIndex % shape->getSize(); return syncIndex % shape->getSize();

6
firmware/controllers/trigger/trigger_emulator_algo.cpp
View File

@ -99,7 +99,7 @@ static LocalVersionHolder emulatorConfigVersion;
extern WaveChart waveChart; extern WaveChart waveChart;
#endif /* EFI_ENGINE_SNIFFER */ #endif /* EFI_ENGINE_SNIFFER */
void setTriggerEmulatorRPM(int rpm DECLARE_ENGINE_PARAMETER_S) { void setTriggerEmulatorRPM(int rpm DECLARE_ENGINE_PARAMETER_SUFFIX) {
engineConfiguration->bc.triggerSimulatorFrequency = rpm; engineConfiguration->bc.triggerSimulatorFrequency = rpm;
/** /**
* All we need to do here is to change the periodMs * All we need to do here is to change the periodMs
@ -125,7 +125,7 @@ static void updateTriggerShapeIfNeeded(PwmConfig *state) {
scheduleMsg(logger, "Stimulator: updating trigger shape: %d/%d %d", emulatorConfigVersion.getVersion(), scheduleMsg(logger, "Stimulator: updating trigger shape: %d/%d %d", emulatorConfigVersion.getVersion(),
getGlobalConfigurationVersion(), currentTimeMillis()); getGlobalConfigurationVersion(), currentTimeMillis());
applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER); applyNonPersistentConfiguration(logger PASS_ENGINE_PARAMETER_SUFFIX);
TriggerShape *s = &engine->triggerCentral.triggerShape; TriggerShape *s = &engine->triggerCentral.triggerShape;
pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.waves[0].pinStates, s->wave.waves[1].pinStates, pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.waves[0].pinStates, s->wave.waves[1].pinStates,
@ -168,7 +168,7 @@ void initTriggerEmulatorLogic(Logging *sharedLogger) {
logger = sharedLogger; logger = sharedLogger;
TriggerShape *s = &engine->triggerCentral.triggerShape; TriggerShape *s = &engine->triggerCentral.triggerShape;
setTriggerEmulatorRPM(engineConfiguration->bc.triggerSimulatorFrequency PASS_ENGINE_PARAMETER); setTriggerEmulatorRPM(engineConfiguration->bc.triggerSimulatorFrequency PASS_ENGINE_PARAMETER_SUFFIX);
pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.waves[0].pinStates, s->wave.waves[1].pinStates, pin_state_t *pinStates[PWM_PHASE_MAX_WAVE_PER_PWM] = { s->wave.waves[0].pinStates, s->wave.waves[1].pinStates,
s->wave.waves[2].pinStates }; s->wave.waves[2].pinStates };
triggerSignal.weComplexInit("position sensor", s->getSize(), s->wave.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM, triggerSignal.weComplexInit("position sensor", s->getSize(), s->wave.switchTimes, PWM_PHASE_MAX_WAVE_PER_PWM,

16
firmware/controllers/trigger/trigger_simulator.cpp
View File

@ -29,7 +29,7 @@ extern bool printTriggerDebug;
#endif /* ! EFI_UNIT_TEST */ #endif /* ! EFI_UNIT_TEST */
void TriggerStimulatorHelper::nextStep(TriggerState *state, TriggerShape * shape, int i, void TriggerStimulatorHelper::nextStep(TriggerState *state, TriggerShape * shape, int i,
trigger_config_s const*triggerConfig DECLARE_ENGINE_PARAMETER_S) { trigger_config_s const*triggerConfig DECLARE_ENGINE_PARAMETER_SUFFIX) {
int stateIndex = i % shape->getSize(); int stateIndex = i % shape->getSize();
int prevIndex = (stateIndex + shape->getSize() - 1 ) % shape->getSize(); int prevIndex = (stateIndex + shape->getSize() - 1 ) % shape->getSize();
@ -61,30 +61,30 @@ void TriggerStimulatorHelper::nextStep(TriggerState *state, TriggerShape * shape
primaryWheelState = newPrimaryWheelState; primaryWheelState = newPrimaryWheelState;
trigger_event_e s = primaryWheelState ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING; trigger_event_e s = primaryWheelState ? SHAFT_PRIMARY_RISING : SHAFT_PRIMARY_FALLING;
if (isUsefulSignal(s, engineConfiguration)) if (isUsefulSignal(s, engineConfiguration))
state->decodeTriggerEvent(s, time PASS_ENGINE_PARAMETER); state->decodeTriggerEvent(s, time PASS_ENGINE_PARAMETER_SUFFIX);
} }
if (secondaryWheelState != newSecondaryWheelState) { if (secondaryWheelState != newSecondaryWheelState) {
secondaryWheelState = newSecondaryWheelState; secondaryWheelState = newSecondaryWheelState;
trigger_event_e s = secondaryWheelState ? SHAFT_SECONDARY_RISING : SHAFT_SECONDARY_FALLING; trigger_event_e s = secondaryWheelState ? SHAFT_SECONDARY_RISING : SHAFT_SECONDARY_FALLING;
if (isUsefulSignal(s, engineConfiguration)) if (isUsefulSignal(s, engineConfiguration))
state->decodeTriggerEvent(s, time PASS_ENGINE_PARAMETER); state->decodeTriggerEvent(s, time PASS_ENGINE_PARAMETER_SUFFIX);
} }
if (thirdWheelState != new3rdWheelState) { if (thirdWheelState != new3rdWheelState) {
thirdWheelState = new3rdWheelState; thirdWheelState = new3rdWheelState;
trigger_event_e s = thirdWheelState ? SHAFT_3RD_RISING : SHAFT_3RD_FALLING; trigger_event_e s = thirdWheelState ? SHAFT_3RD_RISING : SHAFT_3RD_FALLING;
if (isUsefulSignal(s, engineConfiguration)) if (isUsefulSignal(s, engineConfiguration))
state->decodeTriggerEvent(s, time PASS_ENGINE_PARAMETER); state->decodeTriggerEvent(s, time PASS_ENGINE_PARAMETER_SUFFIX);
} }
} }
void TriggerStimulatorHelper::assertSyncPositionAndSetDutyCycle(const uint32_t syncIndex, TriggerState *state, TriggerShape * shape, void TriggerStimulatorHelper::assertSyncPositionAndSetDutyCycle(const uint32_t syncIndex, TriggerState *state, TriggerShape * shape,
trigger_config_s const*triggerConfig DECLARE_ENGINE_PARAMETER_S) { trigger_config_s const*triggerConfig DECLARE_ENGINE_PARAMETER_SUFFIX) {
int startIndex = syncIndex + 1; int startIndex = syncIndex + 1;
for (uint32_t i = startIndex; i <= syncIndex + 2 * shape->getSize(); i++) { for (uint32_t i = startIndex; i <= syncIndex + 2 * shape->getSize(); i++) {
nextStep(state, shape, i, triggerConfig PASS_ENGINE_PARAMETER); nextStep(state, shape, i, triggerConfig PASS_ENGINE_PARAMETER_SUFFIX);
} }
int revolutionCounter = state->getTotalRevolutionCounter(); int revolutionCounter = state->getTotalRevolutionCounter();
if (revolutionCounter != 3) { if (revolutionCounter != 3) {
@ -103,9 +103,9 @@ void TriggerStimulatorHelper::assertSyncPositionAndSetDutyCycle(const uint32_t s
* @return trigger synchronization point index, or error code if not found * @return trigger synchronization point index, or error code if not found
*/ */
uint32_t TriggerStimulatorHelper::doFindTrigger(TriggerShape * shape, uint32_t TriggerStimulatorHelper::doFindTrigger(TriggerShape * shape,
trigger_config_s const*triggerConfig, TriggerState *state DECLARE_ENGINE_PARAMETER_S) { trigger_config_s const*triggerConfig, TriggerState *state DECLARE_ENGINE_PARAMETER_SUFFIX) {
for (int i = 0; i < 4 * PWM_PHASE_MAX_COUNT; i++) { for (int i = 0; i < 4 * PWM_PHASE_MAX_COUNT; i++) {
nextStep(state, shape, i, triggerConfig PASS_ENGINE_PARAMETER); nextStep(state, shape, i, triggerConfig PASS_ENGINE_PARAMETER_SUFFIX);
if (state->shaft_is_synchronized) if (state->shaft_is_synchronized)
return i; return i;

22
firmware/controllers/trigger/trigger_structure.cpp
View File

@ -42,13 +42,13 @@ TriggerShape::TriggerShape() :
memset(triggerIndexByAngle, 0, sizeof(triggerIndexByAngle)); memset(triggerIndexByAngle, 0, sizeof(triggerIndexByAngle));
} }
void TriggerShape::calculateTriggerSynchPoint(TriggerState *state DECLARE_ENGINE_PARAMETER_S) { void TriggerShape::calculateTriggerSynchPoint(TriggerState *state DECLARE_ENGINE_PARAMETER_SUFFIX) {
#if EFI_PROD_CODE || defined(__DOXYGEN__) #if EFI_PROD_CODE || defined(__DOXYGEN__)
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 256, "calc s"); efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 256, "calc s");
#endif #endif
trigger_config_s const*triggerConfig = &engineConfiguration->trigger; trigger_config_s const*triggerConfig = &engineConfiguration->trigger;
triggerShapeSynchPointIndex = findTriggerZeroEventIndex(state, this, triggerConfig PASS_ENGINE_PARAMETER); triggerShapeSynchPointIndex = findTriggerZeroEventIndex(state, this, triggerConfig PASS_ENGINE_PARAMETER_SUFFIX);
int length = getLength(); int length = getLength();
engine->engineCycleEventCount = length; engine->engineCycleEventCount = length;
@ -276,9 +276,9 @@ angle_t TriggerShape::getAngle(int index) const {
return getCycleDuration() * crankCycle + getSwitchAngle(remainder); return getCycleDuration() * crankCycle + getSwitchAngle(remainder);
} }
void TriggerShape::addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_S) { void TriggerShape::addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam, float filterLeft, float filterRight DECLARE_ENGINE_PARAMETER_SUFFIX) {
if (angle > filterLeft && angle < filterRight) if (angle > filterLeft && angle < filterRight)
addEvent2(angle, waveIndex, stateParam PASS_ENGINE_PARAMETER); addEvent2(angle, waveIndex, stateParam PASS_ENGINE_PARAMETER_SUFFIX);
} }
operation_mode_e TriggerShape::getOperationMode() { operation_mode_e TriggerShape::getOperationMode() {
@ -289,7 +289,7 @@ operation_mode_e TriggerShape::getOperationMode() {
extern bool printTriggerDebug; extern bool printTriggerDebug;
#endif #endif
void TriggerShape::addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam DECLARE_ENGINE_PARAMETER_S) { void TriggerShape::addEvent2(angle_t angle, trigger_wheel_e const waveIndex, trigger_value_e const stateParam DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssertVoid(operationMode != OM_NONE, "operationMode not set"); efiAssertVoid(operationMode != OM_NONE, "operationMode not set");
efiAssertVoid(waveIndex!= T_SECONDARY || needSecondTriggerInput, "secondary needed or not?"); efiAssertVoid(waveIndex!= T_SECONDARY || needSecondTriggerInput, "secondary needed or not?");
@ -394,7 +394,7 @@ void multi_wave_s::checkSwitchTimes(int size) {
checkSwitchTimes2(size, switchTimes); checkSwitchTimes2(size, switchTimes);
} }
void setVwConfiguration(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) { void setVwConfiguration(TriggerShape *s DECLARE_ENGINE_PARAMETER_SUFFIX) {
efiAssertVoid(s != NULL, "TriggerShape is NULL"); efiAssertVoid(s != NULL, "TriggerShape is NULL");
operation_mode_e operationMode = FOUR_STROKE_CRANK_SENSOR; operation_mode_e operationMode = FOUR_STROKE_CRANK_SENSOR;
@ -410,23 +410,23 @@ void setVwConfiguration(TriggerShape *s DECLARE_ENGINE_PARAMETER_S) {
float toothWidth = 0.5; float toothWidth = 0.5;
addSkippedToothTriggerEvents(T_PRIMARY, s, 60, 2, toothWidth, 0, engineCycle, addSkippedToothTriggerEvents(T_PRIMARY, s, 60, 2, toothWidth, 0, engineCycle,
NO_LEFT_FILTER, 690 PASS_ENGINE_PARAMETER); NO_LEFT_FILTER, 690 PASS_ENGINE_PARAMETER_SUFFIX);
float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth) ); float angleDown = engineCycle / totalTeethCount * (totalTeethCount - skippedCount - 1 + (1 - toothWidth) );
s->addEvent2(0 + angleDown + 12, T_PRIMARY, TV_RISE, NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); s->addEvent2(0 + angleDown + 12, T_PRIMARY, TV_RISE, NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(0 + engineCycle, T_PRIMARY, TV_FALL, NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER); s->addEvent2(0 + engineCycle, T_PRIMARY, TV_FALL, NO_LEFT_FILTER, NO_RIGHT_FILTER PASS_ENGINE_PARAMETER_SUFFIX);
s->setTriggerSynchronizationGap2(1.6, 4); s->setTriggerSynchronizationGap2(1.6, 4);
} }
void setToothedWheelConfiguration(TriggerShape *s, int total, int skipped, void setToothedWheelConfiguration(TriggerShape *s, int total, int skipped,
operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_S) { operation_mode_e operationMode DECLARE_ENGINE_PARAMETER_SUFFIX) {
#if EFI_ENGINE_CONTROL || defined(__DOXYGEN__) #if EFI_ENGINE_CONTROL || defined(__DOXYGEN__)
s->useRiseEdge = true; s->useRiseEdge = true;
initializeSkippedToothTriggerShapeExt(s, total, skipped, initializeSkippedToothTriggerShapeExt(s, total, skipped,
operationMode PASS_ENGINE_PARAMETER); operationMode PASS_ENGINE_PARAMETER_SUFFIX);
#endif #endif
} }

6
firmware/development/engine_emulator.cpp
View File

@ -44,11 +44,11 @@ static void emulate(void) {
for (int i = 400; i <= 1300; i++) { for (int i = 400; i <= 1300; i++) {
if (i % 50 != 0) if (i % 50 != 0)
continue; continue;
setTriggerEmulatorRPM(i PASS_ENGINE_PARAMETER); setTriggerEmulatorRPM(i PASS_ENGINE_PARAMETER_SUFFIX);
chThdSleepMilliseconds(PERIOD); chThdSleepMilliseconds(PERIOD);
} }
setTriggerEmulatorRPM(0 PASS_ENGINE_PARAMETER); setTriggerEmulatorRPM(0 PASS_ENGINE_PARAMETER_SUFFIX);
setFullLog(0); setFullLog(0);
setDiag(0); setDiag(0);
@ -103,5 +103,5 @@ void initEngineEmulator(Logging *sharedLogger, Engine *engine) {
#endif /* EFI_POTENTIOMETER */ #endif /* EFI_POTENTIOMETER */
//initECUstimulator(); //initECUstimulator();
initTriggerEmulator(sharedLogger PASS_ENGINE_PARAMETER); initTriggerEmulator(sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
} }

8
firmware/global.h
View File

@ -98,13 +98,13 @@ typedef unsigned int time_t;
extern EnginePins enginePins extern EnginePins enginePins
// Use this macro to declare a function which only takes magic references // Use this macro to declare a function which only takes magic references
#define DECLARE_ENGINE_PARAMETER_F void #define DECLARE_ENGINE_PARAMETER_SIGNATURE void
// Use this version of the macro as the suffix if method has other parameters // Use this version of the macro as the suffix if method has other parameters
#define DECLARE_ENGINE_PARAMETER_S #define DECLARE_ENGINE_PARAMETER_SUFFIX
// Pass this if only magic reference are needed // Pass this if only magic reference are needed
#define PASS_ENGINE_PARAMETER_F #define PASS_ENGINE_PARAMETER_SIGNATURE
// Pass this after some other parameters are passed // Pass this after some other parameters are passed
#define PASS_ENGINE_PARAMETER #define PASS_ENGINE_PARAMETER_SUFFIX
/** /**
* this macro allows the compiled to figure out the complete static address, that's a performance * this macro allows the compiled to figure out the complete static address, that's a performance

4
firmware/hw_layer/hardware.cpp
View File

@ -351,14 +351,14 @@ void initHardware(Logging *l) {
*/ */
if (SHOULD_INGORE_FLASH()) { if (SHOULD_INGORE_FLASH()) {
engineConfiguration->engineType = DEFAULT_ENGINE_TYPE; engineConfiguration->engineType = DEFAULT_ENGINE_TYPE;
resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER); resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
writeToFlashNow(); writeToFlashNow();
} else { } else {
readFromFlash(); readFromFlash();
} }
#else #else
engineConfiguration->engineType = DEFAULT_ENGINE_TYPE; engineConfiguration->engineType = DEFAULT_ENGINE_TYPE;
resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER); resetConfigurationExt(sharedLogger, engineConfiguration->engineType PASS_ENGINE_PARAMETER_SUFFIX);
#endif /* EFI_INTERNAL_FLASH */ #endif /* EFI_INTERNAL_FLASH */
#if EFI_HD44780_LCD #if EFI_HD44780_LCD

8
simulator/simulator/global.h
View File

@ -105,10 +105,10 @@ void applyNewConfiguration(void);
extern persistent_config_container_s persistentState; \ extern persistent_config_container_s persistentState; \
extern EnginePins enginePins extern EnginePins enginePins
#define DECLARE_ENGINE_PARAMETER_F void #define DECLARE_ENGINE_PARAMETER_SIGNATURE void
#define DECLARE_ENGINE_PARAMETER_S #define DECLARE_ENGINE_PARAMETER_SUFFIX
#define PASS_ENGINE_PARAMETER_F #define PASS_ENGINE_PARAMETER_SIGNATURE
#define PASS_ENGINE_PARAMETER #define PASS_ENGINE_PARAMETER_SUFFIX
#define CONFIG(x) persistentState.persistentConfiguration.engineConfiguration.x #define CONFIG(x) persistentState.persistentConfiguration.engineConfiguration.x
#define ENGINE(x) engine->x #define ENGINE(x) engine->x

12
simulator/simulator/rusEfiFunctionalTest.cpp
View File

@ -94,13 +94,13 @@ void rusEfiFunctionalTest(void) {
initializeConsole(&sharedLogger); initializeConsole(&sharedLogger);
initStatusLoop(); initStatusLoop();
initDataStructures(PASS_ENGINE_PARAMETER_F); initDataStructures(PASS_ENGINE_PARAMETER_SIGNATURE);
// todo: reduce code duplication with initEngineContoller // todo: reduce code duplication with initEngineContoller
resetConfigurationExt(NULL, DEFAULT_ENGINE_TYPE PASS_ENGINE_PARAMETER); resetConfigurationExt(NULL, DEFAULT_ENGINE_TYPE PASS_ENGINE_PARAMETER_SUFFIX);
prepareShapes(PASS_ENGINE_PARAMETER_F); prepareShapes(PASS_ENGINE_PARAMETER_SIGNATURE);
initAlgo(&sharedLogger); initAlgo(&sharedLogger);
commonInitEngineController(&sharedLogger); commonInitEngineController(&sharedLogger);
@ -113,7 +113,7 @@ void rusEfiFunctionalTest(void) {
initTriggerCentral(&sharedLogger); initTriggerCentral(&sharedLogger);
initTriggerEmulator(&sharedLogger PASS_ENGINE_PARAMETER); initTriggerEmulator(&sharedLogger PASS_ENGINE_PARAMETER_SUFFIX);
#if EFI_MAP_AVERAGING || defined(__DOXYGEN__) #if EFI_MAP_AVERAGING || defined(__DOXYGEN__)
initMapAveraging(&sharedLogger, engine); initMapAveraging(&sharedLogger, engine);
@ -125,9 +125,9 @@ void rusEfiFunctionalTest(void) {
runChprintfTest(); runChprintfTest();
initPeriodicEvents(PASS_ENGINE_PARAMETER_F); initPeriodicEvents(PASS_ENGINE_PARAMETER_SIGNATURE);
setTriggerEmulatorRPM(DEFAULT_SIM_RPM PASS_ENGINE_PARAMETER); setTriggerEmulatorRPM(DEFAULT_SIM_RPM PASS_ENGINE_PARAMETER_SUFFIX);
engineConfiguration->engineSnifferRpmThreshold = DEFAULT_SNIFFER_THR; engineConfiguration->engineSnifferRpmThreshold = DEFAULT_SNIFFER_THR;
} }

22
unit_tests/engine_test_helper.cpp
View File

@ -45,24 +45,24 @@ EngineTestHelper::EngineTestHelper(engine_type_e engineType) : engine (&persiste
setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 70, 1.01); setTableValue(config->cltFuelCorrBins, config->cltFuelCorr, CLT_CURVE_SIZE, 70, 1.01);
Engine *engine = &this->engine; Engine *engine = &this->engine;
prepareFuelMap(PASS_ENGINE_PARAMETER_F); prepareFuelMap(PASS_ENGINE_PARAMETER_SIGNATURE);
initAccelEnrichment(NULL PASS_ENGINE_PARAMETER); initAccelEnrichment(NULL PASS_ENGINE_PARAMETER_SUFFIX);
initSpeedDensity(PASS_ENGINE_PARAMETER_F); initSpeedDensity(PASS_ENGINE_PARAMETER_SIGNATURE);
resetConfigurationExt(NULL, engineType PASS_ENGINE_PARAMETER); resetConfigurationExt(NULL, engineType PASS_ENGINE_PARAMETER_SUFFIX);
prepareShapes(PASS_ENGINE_PARAMETER_F); prepareShapes(PASS_ENGINE_PARAMETER_SIGNATURE);
engine->engineConfiguration->mafAdcChannel = (adc_channel_e)TEST_MAF_CHANNEL; engine->engineConfiguration->mafAdcChannel = (adc_channel_e)TEST_MAF_CHANNEL;
initThermistors(NULL PASS_ENGINE_PARAMETER); initThermistors(NULL PASS_ENGINE_PARAMETER_SUFFIX);
// this is needed to have valid CLT and IAT. // this is needed to have valid CLT and IAT.
engine->updateSlowSensors(PASS_ENGINE_PARAMETER_F); engine->updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE);
prepareTimingMap(PASS_ENGINE_PARAMETER_F); prepareTimingMap(PASS_ENGINE_PARAMETER_SIGNATURE);
engine_configuration_s *engineConfiguration = engine->engineConfiguration; engine_configuration_s *engineConfiguration = engine->engineConfiguration;
engine->triggerCentral.triggerShape.initializeTriggerShape(NULL PASS_ENGINE_PARAMETER); engine->triggerCentral.triggerShape.initializeTriggerShape(NULL PASS_ENGINE_PARAMETER_SUFFIX);
engine->triggerCentral.addEventListener(rpmShaftPositionCallback, "rpm reporter", engine); engine->triggerCentral.addEventListener(rpmShaftPositionCallback, "rpm reporter", engine);
engine->triggerCentral.addEventListener(mainTriggerCallback, "main loop", engine); engine->triggerCentral.addEventListener(mainTriggerCallback, "main loop", engine);
} }
@ -96,7 +96,7 @@ void EngineTestHelper::applyTriggerShape() {
persistent_config_s *config = engine->config; persistent_config_s *config = engine->config;
board_configuration_s *boardConfiguration = &engineConfiguration->bc; board_configuration_s *boardConfiguration = &engineConfiguration->bc;
engine->triggerCentral.triggerShape.initializeTriggerShape(NULL PASS_ENGINE_PARAMETER); engine->triggerCentral.triggerShape.initializeTriggerShape(NULL PASS_ENGINE_PARAMETER_SUFFIX);
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
} }

8
unit_tests/global.h
View File

@ -44,10 +44,10 @@ class Engine;
/** /**
* @see firmware/global.h for explanation * @see firmware/global.h for explanation
*/ */
#define DECLARE_ENGINE_PARAMETER_F Engine *engine, engine_configuration_s *engineConfiguration, persistent_config_s *config, board_configuration_s *boardConfiguration #define DECLARE_ENGINE_PARAMETER_SIGNATURE Engine *engine, engine_configuration_s *engineConfiguration, persistent_config_s *config, board_configuration_s *boardConfiguration
#define DECLARE_ENGINE_PARAMETER_S , Engine *engine, engine_configuration_s *engineConfiguration, persistent_config_s *config, board_configuration_s *boardConfiguration #define DECLARE_ENGINE_PARAMETER_SUFFIX , Engine *engine, engine_configuration_s *engineConfiguration, persistent_config_s *config, board_configuration_s *boardConfiguration
#define PASS_ENGINE_PARAMETER_F engine, engineConfiguration, config, boardConfiguration #define PASS_ENGINE_PARAMETER_SIGNATURE engine, engineConfiguration, config, boardConfiguration
#define PASS_ENGINE_PARAMETER , engine, engineConfiguration, config, boardConfiguration #define PASS_ENGINE_PARAMETER_SUFFIX , engine, engineConfiguration, config, boardConfiguration
#define EXPAND_Engine engine_configuration_s *engineConfiguration = engine->engineConfiguration; \ #define EXPAND_Engine engine_configuration_s *engineConfiguration = engine->engineConfiguration; \
persistent_config_s *config = engine->config; \ persistent_config_s *config = engine->config; \

32
unit_tests/test_accel_enrichment.cpp
View File

@ -18,24 +18,24 @@ void testAccelEnrichment(void) {
EngineTestHelper eth(FORD_ASPIRE_1996); EngineTestHelper eth(FORD_ASPIRE_1996);
EXPAND_EngineTestHelper; EXPAND_EngineTestHelper;
engine->rpmCalculator.setRpmValue(600 PASS_ENGINE_PARAMETER); engine->rpmCalculator.setRpmValue(600 PASS_ENGINE_PARAMETER_SUFFIX);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
engine->tpsAccelEnrichment.setLength(4); engine->tpsAccelEnrichment.setLength(4);
engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER); engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("maxDelta", 0, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maxDelta", 0, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_SIGNATURE));
engine->tpsAccelEnrichment.onNewValue(10 PASS_ENGINE_PARAMETER); engine->tpsAccelEnrichment.onNewValue(10 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("maxDelta#1", 40, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maxDelta#1", 40, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_SIGNATURE));
engine->tpsAccelEnrichment.onNewValue(30 PASS_ENGINE_PARAMETER); engine->tpsAccelEnrichment.onNewValue(30 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("maxDelta#2", 80, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maxDelta#2", 80, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_SIGNATURE));
engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER); engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("maxDelta#3", 80, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maxDelta#3", 80, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_SIGNATURE));
engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER); engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("maxDelta#4", 80, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maxDelta#4", 80, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_SIGNATURE));
engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER); engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("maxDelta#5", 0, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maxDelta#5", 0, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_SIGNATURE));
engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER); engine->tpsAccelEnrichment.onNewValue(0 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("maxDelta", 0, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maxDelta", 0, engine->tpsAccelEnrichment.getMaxDelta(PASS_ENGINE_PARAMETER_SIGNATURE));
} }

14
unit_tests/test_engine_math.cpp
View File

@ -20,7 +20,7 @@ void testIgnitionPlanning(void) {
EngineTestHelper eth(FORD_ESCORT_GT); EngineTestHelper eth(FORD_ESCORT_GT);
EXPAND_EngineTestHelper; EXPAND_EngineTestHelper;
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("testIgnitionPlanning_AFR", 13.5, eth.engine.engineState.targetAFR); assertEqualsM("testIgnitionPlanning_AFR", 13.5, eth.engine.engineState.targetAFR);
assertEquals(IM_BATCH, engineConfiguration->injectionMode); assertEquals(IM_BATCH, engineConfiguration->injectionMode);
@ -38,14 +38,14 @@ void testEngineMath(void) {
assertEqualsM("6000 RPM", 5, getOneDegreeTimeMs(6000) * 180); assertEqualsM("6000 RPM", 5, getOneDegreeTimeMs(6000) * 180);
assertEquals(312.5, getTCharge(1000, 0, 300, 350 PASS_ENGINE_PARAMETER)); assertEquals(312.5, getTCharge(1000, 0, 300, 350 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(313.5833, getTCharge(1000, 50, 300, 350 PASS_ENGINE_PARAMETER)); assertEquals(313.5833, getTCharge(1000, 50, 300, 350 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(314.6667, getTCharge(1000, 100, 300, 350 PASS_ENGINE_PARAMETER)); assertEquals(314.6667, getTCharge(1000, 100, 300, 350 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(312.5, getTCharge(4000, 0, 300, 350 PASS_ENGINE_PARAMETER)); assertEquals(312.5, getTCharge(4000, 0, 300, 350 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(320.0833, getTCharge(4000, 50, 300, 350 PASS_ENGINE_PARAMETER)); assertEquals(320.0833, getTCharge(4000, 50, 300, 350 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(327.6667, getTCharge(4000, 100, 300, 350 PASS_ENGINE_PARAMETER)); assertEquals(327.6667, getTCharge(4000, 100, 300, 350 PASS_ENGINE_PARAMETER_SUFFIX));
} }
void testIgnitionMapGenerator(void) { void testIgnitionMapGenerator(void) {

78
unit_tests/test_fuel_map.cpp
View File

@ -29,7 +29,7 @@ void testMafFuelMath(void) {
setAfrMap(config->afrTable, 13); setAfrMap(config->afrTable, 13);
float fuelMs = getRealMafFuel(300, 6000 PASS_ENGINE_PARAMETER); float fuelMs = getRealMafFuel(300, 6000 PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("fuelMs", 26.7099, fuelMs); assertEqualsM("fuelMs", 26.7099, fuelMs);
} }
@ -58,20 +58,20 @@ void testFuelMap(void) {
printf("*** getInjectorLag\r\n"); printf("*** getInjectorLag\r\n");
// engine->engineState.vb // engine->engineState.vb
assertEqualsM("lag", 1.04, getInjectorLag(12 PASS_ENGINE_PARAMETER)); assertEqualsM("lag", 1.04, getInjectorLag(12 PASS_ENGINE_PARAMETER_SUFFIX));
for (int i = 0; i < VBAT_INJECTOR_CURVE_SIZE; i++) { for (int i = 0; i < VBAT_INJECTOR_CURVE_SIZE; i++) {
eth.engine.engineConfiguration->injector.battLagCorrBins[i] = i; eth.engine.engineConfiguration->injector.battLagCorrBins[i] = i;
eth.engine.engineConfiguration->injector.battLagCorr[i] = 0.5 + 2 * i; eth.engine.engineConfiguration->injector.battLagCorr[i] = 0.5 + 2 * i;
} }
eth.engine.updateSlowSensors(PASS_ENGINE_PARAMETER_F); eth.engine.updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE);
// because all the correction tables are zero // because all the correction tables are zero
printf("*************************************************** getRunningFuel 1\r\n"); printf("*************************************************** getRunningFuel 1\r\n");
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
float baseFuel = getBaseTableFuel(5, getEngineLoadT(PASS_ENGINE_PARAMETER_F)); float baseFuel = getBaseTableFuel(5, getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("base fuel", 5.05, getRunningFuel(baseFuel PASS_ENGINE_PARAMETER)); assertEqualsM("base fuel", 5.05, getRunningFuel(baseFuel PASS_ENGINE_PARAMETER_SUFFIX));
printf("*************************************************** setting IAT table\r\n"); printf("*************************************************** setting IAT table\r\n");
for (int i = 0; i < IAT_CURVE_SIZE; i++) { for (int i = 0; i < IAT_CURVE_SIZE; i++) {
@ -86,24 +86,24 @@ void testFuelMap(void) {
eth.engine.config->cltFuelCorr[i] = 100; eth.engine.config->cltFuelCorr[i] = 100;
} }
setInjectorLag(0 PASS_ENGINE_PARAMETER); setInjectorLag(0 PASS_ENGINE_PARAMETER_SUFFIX);
assertEquals(NAN, getIntakeAirTemperature(PASS_ENGINE_PARAMETER_F)); assertEquals(NAN, getIntakeAirTemperature(PASS_ENGINE_PARAMETER_SIGNATURE));
float iatCorrection = getIatFuelCorrection(-KELV PASS_ENGINE_PARAMETER); float iatCorrection = getIatFuelCorrection(-KELV PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("IAT", 2, iatCorrection); assertEqualsM("IAT", 2, iatCorrection);
engine->sensors.clt = getCoolantTemperature(PASS_ENGINE_PARAMETER_F); engine->sensors.clt = getCoolantTemperature(PASS_ENGINE_PARAMETER_SIGNATURE);
float cltCorrection = getCltFuelCorrection(PASS_ENGINE_PARAMETER_F); float cltCorrection = getCltFuelCorrection(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("CLT", 1, cltCorrection); assertEqualsM("CLT", 1, cltCorrection);
float injectorLag = getInjectorLag(getVBatt(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER); float injectorLag = getInjectorLag(getVBatt(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("injectorLag", 0, injectorLag); assertEqualsM("injectorLag", 0, injectorLag);
testMafValue = 5; testMafValue = 5;
// 1005 * 2 for IAT correction // 1005 * 2 for IAT correction
printf("*************************************************** getRunningFuel 2\r\n"); printf("*************************************************** getRunningFuel 2\r\n");
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
baseFuel = getBaseTableFuel(5, getEngineLoadT(PASS_ENGINE_PARAMETER_F)); baseFuel = getBaseTableFuel(5, getEngineLoadT(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("v1", 30150, getRunningFuel(baseFuel PASS_ENGINE_PARAMETER)); assertEqualsM("v1", 30150, getRunningFuel(baseFuel PASS_ENGINE_PARAMETER_SUFFIX));
testMafValue = 0; testMafValue = 0;
@ -111,28 +111,28 @@ void testFuelMap(void) {
printf("*************************************************** getStartingFuel\r\n"); printf("*************************************************** getStartingFuel\r\n");
// NAN in case we have issues with the CLT sensor // NAN in case we have issues with the CLT sensor
assertEqualsM("getStartingFuel nan", 4, getCrankingFuel3(NAN, 0 PASS_ENGINE_PARAMETER)); assertEqualsM("getStartingFuel nan", 4, getCrankingFuel3(NAN, 0 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("getStartingFuel#1", 17.8, getCrankingFuel3(0, 4 PASS_ENGINE_PARAMETER)); assertEqualsM("getStartingFuel#1", 17.8, getCrankingFuel3(0, 4 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("getStartingFuel#2", 8.4480, getCrankingFuel3(8, 15 PASS_ENGINE_PARAMETER)); assertEqualsM("getStartingFuel#2", 8.4480, getCrankingFuel3(8, 15 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("getStartingFuel#3", 6.48, getCrankingFuel3(70, 0 PASS_ENGINE_PARAMETER)); assertEqualsM("getStartingFuel#3", 6.48, getCrankingFuel3(70, 0 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("getStartingFuel#4", 2.6069, getCrankingFuel3(70, 50 PASS_ENGINE_PARAMETER)); assertEqualsM("getStartingFuel#4", 2.6069, getCrankingFuel3(70, 50 PASS_ENGINE_PARAMETER_SUFFIX));
} }
static void confgiureFordAspireTriggerShape(TriggerShape * s DECLARE_ENGINE_PARAMETER_S) { static void confgiureFordAspireTriggerShape(TriggerShape * s DECLARE_ENGINE_PARAMETER_SUFFIX) {
s->initialize(FOUR_STROKE_CAM_SENSOR, true); s->initialize(FOUR_STROKE_CAM_SENSOR, true);
s->addEvent2(53.747, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(53.747, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(121.90, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(121.90, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(232.76, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(232.76, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(300.54, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(300.54, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(360, T_PRIMARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(409.8412, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(409.8412, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(478.6505, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(478.6505, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(588.045, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER); s->addEvent2(588.045, T_SECONDARY, TV_RISE PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(657.03, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(657.03, T_SECONDARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER); s->addEvent2(720, T_PRIMARY, TV_FALL PASS_ENGINE_PARAMETER_SUFFIX);
assertEquals(53.747 / 720, s->wave.getSwitchTime(0)); assertEquals(53.747 / 720, s->wave.getSwitchTime(0));
assertEqualsM("@0", 1, s->wave.getChannelState(1, 0)); assertEqualsM("@0", 1, s->wave.getChannelState(1, 0));
@ -170,7 +170,7 @@ void testAngleResolver(void) {
engineConfiguration->globalTriggerAngleOffset = 175; engineConfiguration->globalTriggerAngleOffset = 175;
TriggerShape * ts = &engine->triggerCentral.triggerShape; TriggerShape * ts = &engine->triggerCentral.triggerShape;
ts->initializeTriggerShape(NULL PASS_ENGINE_PARAMETER); ts->initializeTriggerShape(NULL PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("index 2", 52.76, ts->eventAngles[3]); // this angle is relation to synch point assertEqualsM("index 2", 52.76, ts->eventAngles[3]); // this angle is relation to synch point
assertEqualsM("time 2", 0.3233, ts->wave.getSwitchTime(2)); assertEqualsM("time 2", 0.3233, ts->wave.getSwitchTime(2));
@ -184,37 +184,37 @@ void testAngleResolver(void) {
event_trigger_position_s injectionStart; event_trigger_position_s injectionStart;
printf("*************************************************** testAngleResolver 0\r\n"); printf("*************************************************** testAngleResolver 0\r\n");
TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -122 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -122 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("eventIndex@0", 2, injectionStart.eventIndex); assertEqualsM("eventIndex@0", 2, injectionStart.eventIndex);
assertEquals(0.24, injectionStart.angleOffset); assertEquals(0.24, injectionStart.angleOffset);
printf("*************************************************** testAngleResolver 0.1\r\n"); printf("*************************************************** testAngleResolver 0.1\r\n");
TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -80 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -80 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("eventIndex@0", 2, injectionStart.eventIndex); assertEqualsM("eventIndex@0", 2, injectionStart.eventIndex);
assertEquals(42.24, injectionStart.angleOffset); assertEquals(42.24, injectionStart.angleOffset);
printf("*************************************************** testAngleResolver 0.2\r\n"); printf("*************************************************** testAngleResolver 0.2\r\n");
TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -54 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -54 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("eventIndex@0", 2, injectionStart.eventIndex); assertEqualsM("eventIndex@0", 2, injectionStart.eventIndex);
assertEquals(68.2400, injectionStart.angleOffset); assertEquals(68.2400, injectionStart.angleOffset);
printf("*************************************************** testAngleResolver 0.3\r\n"); printf("*************************************************** testAngleResolver 0.3\r\n");
TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -53 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&injectionStart, -53 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(2, injectionStart.eventIndex); assertEquals(2, injectionStart.eventIndex);
assertEquals(69.24, injectionStart.angleOffset); assertEquals(69.24, injectionStart.angleOffset);
printf("*************************************************** testAngleResolver 1\r\n"); printf("*************************************************** testAngleResolver 1\r\n");
TRIGGER_SHAPE(findTriggerPosition(&injectionStart, 0 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&injectionStart, 0 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(2, injectionStart.eventIndex); assertEquals(2, injectionStart.eventIndex);
assertEquals(122.24, injectionStart.angleOffset); assertEquals(122.24, injectionStart.angleOffset);
printf("*************************************************** testAngleResolver 2\r\n"); printf("*************************************************** testAngleResolver 2\r\n");
TRIGGER_SHAPE(findTriggerPosition(&injectionStart, 56 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&injectionStart, 56 PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(2, injectionStart.eventIndex); assertEquals(2, injectionStart.eventIndex);
assertEquals(178.24, injectionStart.angleOffset); assertEquals(178.24, injectionStart.angleOffset);
TriggerShape t; TriggerShape t;
confgiureFordAspireTriggerShape(&t PASS_ENGINE_PARAMETER); confgiureFordAspireTriggerShape(&t PASS_ENGINE_PARAMETER_SUFFIX);
} }
void testPinHelper(void) { void testPinHelper(void) {

12
unit_tests/test_sensors.cpp
View File

@ -20,12 +20,12 @@ static void testMapDecoding(void) {
air_pressure_sensor_config_s s; air_pressure_sensor_config_s s;
s.type = MT_DENSO183; s.type = MT_DENSO183;
assertEqualsM("denso 0 volts", -6.64, decodePressure(0, &s PASS_ENGINE_PARAMETER)); assertEqualsM("denso 0 volts", -6.64, decodePressure(0, &s PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(31.244, decodePressure(1, &s PASS_ENGINE_PARAMETER)); assertEquals(31.244, decodePressure(1, &s PASS_ENGINE_PARAMETER_SUFFIX));
s.type = MT_MPX4250; s.type = MT_MPX4250;
assertEqualsM("MPX_4250 0 volts", 8, decodePressure(0, &s PASS_ENGINE_PARAMETER)); assertEqualsM("MPX_4250 0 volts", 8, decodePressure(0, &s PASS_ENGINE_PARAMETER_SUFFIX));
assertEquals(58.4, decodePressure(1, &s PASS_ENGINE_PARAMETER)); assertEquals(58.4, decodePressure(1, &s PASS_ENGINE_PARAMETER_SUFFIX));
} }
void testTps(void) { void testTps(void) {
@ -37,12 +37,12 @@ void testTps(void) {
engineConfiguration->tpsMax = 193; engineConfiguration->tpsMax = 193;
engineConfiguration->tpsMin = 43; engineConfiguration->tpsMin = 43;
assertEquals(49.3333, getTpsValue(4 * 117 PASS_ENGINE_PARAMETER)); assertEquals(49.3333, getTpsValue(4 * 117 PASS_ENGINE_PARAMETER_SUFFIX));
engineConfiguration->tpsMax = 43; engineConfiguration->tpsMax = 43;
engineConfiguration->tpsMin = 193; engineConfiguration->tpsMin = 193;
assertEqualsM("test#2", 50.6667, getTpsValue(4 * 117 PASS_ENGINE_PARAMETER)); assertEqualsM("test#2", 50.6667, getTpsValue(4 * 117 PASS_ENGINE_PARAMETER_SUFFIX));
} }
void testTpsRateOfChange(void) { void testTpsRateOfChange(void) {

174
unit_tests/test_trigger_decoder.cpp
View File

@ -51,10 +51,10 @@ static int getTriggerZeroEventIndex(engine_type_e engineType) {
EngineTestHelper eth(engineType); EngineTestHelper eth(engineType);
EXPAND_EngineTestHelper; EXPAND_EngineTestHelper;
initDataStructures(PASS_ENGINE_PARAMETER_F); initDataStructures(PASS_ENGINE_PARAMETER_SIGNATURE);
TriggerShape * shape = &eth.engine.triggerCentral.triggerShape; TriggerShape * shape = &eth.engine.triggerCentral.triggerShape;
return findTriggerZeroEventIndex(&eth.engine.triggerCentral.triggerState, shape, &engineConfiguration->trigger PASS_ENGINE_PARAMETER); return findTriggerZeroEventIndex(&eth.engine.triggerCentral.triggerState, shape, &engineConfiguration->trigger PASS_ENGINE_PARAMETER_SUFFIX);
} }
static void testDodgeNeonDecoder(void) { static void testDodgeNeonDecoder(void) {
@ -128,25 +128,25 @@ void test1995FordInline6TriggerDecoder(void) {
assertEqualsM("triggerShapeSynchPointIndex", 0, shape->getTriggerShapeSynchPointIndex()); assertEqualsM("triggerShapeSynchPointIndex", 0, shape->getTriggerShapeSynchPointIndex());
// this is needed to have valid CLT and IAT. todo: extract method // this is needed to have valid CLT and IAT. todo: extract method
engine->updateSlowSensors(PASS_ENGINE_PARAMETER_F); engine->updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE);
event_trigger_position_s position; event_trigger_position_s position;
assertEqualsM("globalTriggerAngleOffset", 0, engineConfiguration->globalTriggerAngleOffset); assertEqualsM("globalTriggerAngleOffset", 0, engineConfiguration->globalTriggerAngleOffset);
TRIGGER_SHAPE(findTriggerPosition(&position, 0 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&position, 0 PASS_ENGINE_PARAMETER_SUFFIX));
assertTriggerPosition(&position, 0, 0); assertTriggerPosition(&position, 0, 0);
TRIGGER_SHAPE(findTriggerPosition(&position, 200 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&position, 200 PASS_ENGINE_PARAMETER_SUFFIX));
assertTriggerPosition(&position, 3, 20); assertTriggerPosition(&position, 3, 20);
TRIGGER_SHAPE(findTriggerPosition(&position, 360 PASS_ENGINE_PARAMETER)); TRIGGER_SHAPE(findTriggerPosition(&position, 360 PASS_ENGINE_PARAMETER_SUFFIX));
assertTriggerPosition(&position, 6, 0); assertTriggerPosition(&position, 6, 0);
eth.applyTriggerShape(); eth.applyTriggerShape();
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
eth.fireTriggerEvents(48); eth.fireTriggerEvents(48);
assertEquals(2000, eth.engine.rpmCalculator.rpmValue); assertEquals(2000, eth.engine.rpmCalculator.rpmValue);
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
eth.fireTriggerEvents(48); eth.fireTriggerEvents(48);
IgnitionEventList *ecl = &eth.engine.ignitionEvents; IgnitionEventList *ecl = &eth.engine.ignitionEvents;
@ -161,31 +161,31 @@ void test1995FordInline6TriggerDecoder(void) {
assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized); assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized);
int r = 10; int r = 10;
state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r PASS_ENGINE_PARAMETER_SUFFIX);
assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized); // still no synchronization assertFalseM("shaft_is_synchronized", state.shaft_is_synchronized); // still no synchronization
state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, ++r PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, ++r PASS_ENGINE_PARAMETER_SUFFIX);
assertTrue(state.shaft_is_synchronized); // first signal rise synchronize assertTrue(state.shaft_is_synchronized); // first signal rise synchronize
assertEquals(0, state.getCurrentIndex()); assertEquals(0, state.getCurrentIndex());
state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r++ PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r++ PASS_ENGINE_PARAMETER_SUFFIX);
assertEquals(1, state.getCurrentIndex()); assertEquals(1, state.getCurrentIndex());
for (int i = 2; i < 10;) { for (int i = 2; i < 10;) {
state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, r++ PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, r++ PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("even", i++, state.getCurrentIndex()); assertEqualsM("even", i++, state.getCurrentIndex());
state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r++ PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r++ PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("odd", i++, state.getCurrentIndex()); assertEqualsM("odd", i++, state.getCurrentIndex());
} }
state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, r++ PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, r++ PASS_ENGINE_PARAMETER_SUFFIX);
assertEquals(10, state.getCurrentIndex()); assertEquals(10, state.getCurrentIndex());
state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r++ PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_FALLING, r++ PASS_ENGINE_PARAMETER_SUFFIX);
assertEquals(11, state.getCurrentIndex()); assertEquals(11, state.getCurrentIndex());
state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, r++ PASS_ENGINE_PARAMETER); state.decodeTriggerEvent(SHAFT_PRIMARY_RISING, r++ PASS_ENGINE_PARAMETER_SUFFIX);
assertEquals(0, state.getCurrentIndex()); // new revolution assertEquals(0, state.getCurrentIndex()); // new revolution
assertEqualsM("running dwell", 0.5, getSparkDwell(2000 PASS_ENGINE_PARAMETER)); assertEqualsM("running dwell", 0.5, getSparkDwell(2000 PASS_ENGINE_PARAMETER_SUFFIX));
} }
void testFordAspire(void) { void testFordAspire(void) {
@ -204,10 +204,10 @@ void testFordAspire(void) {
engineConfiguration->crankingChargeAngle = 65; engineConfiguration->crankingChargeAngle = 65;
engineConfiguration->crankingTimingAngle = 31; engineConfiguration->crankingTimingAngle = 31;
assertEqualsM("cranking dwell", 54.166670, getSparkDwell(200 PASS_ENGINE_PARAMETER)); assertEqualsM("cranking dwell", 54.166670, getSparkDwell(200 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("running dwell", 4, getSparkDwell(2000 PASS_ENGINE_PARAMETER)); assertEqualsM("running dwell", 4, getSparkDwell(2000 PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("higher rpm dwell", 3.25, getSparkDwell(6000 PASS_ENGINE_PARAMETER)); assertEqualsM("higher rpm dwell", 3.25, getSparkDwell(6000 PASS_ENGINE_PARAMETER_SUFFIX));
} }
void testTriggerDecoder2(const char *msg, engine_type_e type, int synchPointIndex, float channel1duty, float channel2duty) { void testTriggerDecoder2(const char *msg, engine_type_e type, int synchPointIndex, float channel1duty, float channel2duty) {
@ -216,7 +216,7 @@ void testTriggerDecoder2(const char *msg, engine_type_e type, int synchPointInde
EngineTestHelper eth(type); EngineTestHelper eth(type);
EXPAND_EngineTestHelper; EXPAND_EngineTestHelper;
initSpeedDensity(PASS_ENGINE_PARAMETER_F); initSpeedDensity(PASS_ENGINE_PARAMETER_SIGNATURE);
TriggerShape *t = &eth.engine.triggerCentral.triggerShape; TriggerShape *t = &eth.engine.triggerCentral.triggerShape;
@ -252,31 +252,31 @@ void testStartupFuelPumping(void) {
engine->engineConfiguration->tpsMax = 10; engine->engineConfiguration->tpsMax = 10;
mockTps = TPS_TS_CONVERSION * 6; mockTps = TPS_TS_CONVERSION * 6;
sf.update(PASS_ENGINE_PARAMETER_F); sf.update(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("pc#1", 1, sf.pumpsCounter); assertEqualsM("pc#1", 1, sf.pumpsCounter);
mockTps = TPS_TS_CONVERSION * 3; mockTps = TPS_TS_CONVERSION * 3;
sf.update(PASS_ENGINE_PARAMETER_F); sf.update(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("pumpsCounter#2", 1, sf.pumpsCounter); assertEqualsM("pumpsCounter#2", 1, sf.pumpsCounter);
sf.update(PASS_ENGINE_PARAMETER_F); sf.update(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("pc#3", 1, sf.pumpsCounter); assertEqualsM("pc#3", 1, sf.pumpsCounter);
engine->rpmCalculator.mockRpm = 10; engine->rpmCalculator.mockRpm = 10;
sf.update(PASS_ENGINE_PARAMETER_F); sf.update(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("pc#4", 0, sf.pumpsCounter); assertEqualsM("pc#4", 0, sf.pumpsCounter);
mockTps = TPS_TS_CONVERSION * 7; mockTps = TPS_TS_CONVERSION * 7;
engine->rpmCalculator.mockRpm = 0; engine->rpmCalculator.mockRpm = 0;
sf.update(PASS_ENGINE_PARAMETER_F); sf.update(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("pc#5", 1, sf.pumpsCounter); assertEqualsM("pc#5", 1, sf.pumpsCounter);
mockTps = TPS_TS_CONVERSION * 3; mockTps = TPS_TS_CONVERSION * 3;
sf.update(PASS_ENGINE_PARAMETER_F); sf.update(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("pc#6", 1, sf.pumpsCounter); assertEqualsM("pc#6", 1, sf.pumpsCounter);
mockTps = TPS_TS_CONVERSION * 7; mockTps = TPS_TS_CONVERSION * 7;
sf.update(PASS_ENGINE_PARAMETER_F); sf.update(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("pc#7", 2, sf.pumpsCounter); assertEqualsM("pc#7", 2, sf.pumpsCounter);
} }
@ -314,18 +314,18 @@ void testRpmCalculator(void) {
engineConfiguration->globalFuelCorrection = 3; engineConfiguration->globalFuelCorrection = 3;
eth.applyTriggerShape(); eth.applyTriggerShape();
setInjectorLag(0 PASS_ENGINE_PARAMETER); setInjectorLag(0 PASS_ENGINE_PARAMETER_SUFFIX);
engine->updateSlowSensors(PASS_ENGINE_PARAMETER_F); engine->updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE);
timeNow = 0; timeNow = 0;
assertEquals(0, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEquals(0, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEquals(4, TRIGGER_SHAPE(triggerIndexByAngle[240])); assertEquals(4, TRIGGER_SHAPE(triggerIndexByAngle[240]));
assertEquals(4, TRIGGER_SHAPE(triggerIndexByAngle[241])); assertEquals(4, TRIGGER_SHAPE(triggerIndexByAngle[241]));
eth.fireTriggerEvents(48); eth.fireTriggerEvents(48);
assertEqualsM("RPM", 1500, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM", 1500, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("index #1", 15, eth.engine.triggerCentral.triggerState.getCurrentIndex()); assertEqualsM("index #1", 15, eth.engine.triggerCentral.triggerState.getCurrentIndex());
@ -343,15 +343,15 @@ void testRpmCalculator(void) {
assertEqualsM("st value", 485000, st); assertEqualsM("st value", 485000, st);
// todo: why is this required here? we already have one 'prepareOutputSignals' in constructor, what's wrong with it? // todo: why is this required here? we already have one 'prepareOutputSignals' in constructor, what's wrong with it?
prepareOutputSignals(PASS_ENGINE_PARAMETER_F); prepareOutputSignals(PASS_ENGINE_PARAMETER_SIGNATURE);
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("fuel #1", 4.5450, eth.engine.fuelMs); assertEqualsM("fuel #1", 4.5450, eth.engine.fuelMs);
InjectionEvent *ie0 = &eth.engine.injectionEvents.elements[0]; InjectionEvent *ie0 = &eth.engine.injectionEvents.elements[0];
assertEqualsM("injection angle", 31.365, ie0->injectionStart.angleOffset); assertEqualsM("injection angle", 31.365, ie0->injectionStart.angleOffset);
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER_SUFFIX);
assertEquals(1500, eth.engine.rpmCalculator.rpmValue); assertEquals(1500, eth.engine.rpmCalculator.rpmValue);
assertEqualsM("dwell", 4.5, eth.engine.engineState.dwellAngle); assertEqualsM("dwell", 4.5, eth.engine.engineState.dwellAngle);
@ -380,11 +380,11 @@ void testRpmCalculator(void) {
schedulingQueue.clear(); schedulingQueue.clear();
timeNow += 5000; timeNow += 5000;
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER_SUFFIX);
timeNow += 5000; // 5ms timeNow += 5000; // 5ms
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER_SUFFIX);
timeNow += 5000; timeNow += 5000;
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("index #3", 3, eth.engine.triggerCentral.triggerState.getCurrentIndex()); assertEqualsM("index #3", 3, eth.engine.triggerCentral.triggerState.getCurrentIndex());
assertEqualsM("queue size 3", 4, schedulingQueue.size()); assertEqualsM("queue size 3", 4, schedulingQueue.size());
assertEqualsM("ev 3", st + 13333 - 1515, schedulingQueue.getForUnitText(0)->momentX); assertEqualsM("ev 3", st + 13333 - 1515, schedulingQueue.getForUnitText(0)->momentX);
@ -396,15 +396,15 @@ void testRpmCalculator(void) {
assertEquals(5, TRIGGER_SHAPE(triggerIndexByAngle[241])); assertEquals(5, TRIGGER_SHAPE(triggerIndexByAngle[241]));
timeNow += 5000; timeNow += 5000;
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 4.1", 0, schedulingQueue.size()); assertEqualsM("queue size 4.1", 0, schedulingQueue.size());
timeNow += 5000; // 5ms timeNow += 5000; // 5ms
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 4.2", 4, schedulingQueue.size()); assertEqualsM("queue size 4.2", 4, schedulingQueue.size());
timeNow += 5000; // 5ms timeNow += 5000; // 5ms
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 4.3", 4, schedulingQueue.size()); assertEqualsM("queue size 4.3", 4, schedulingQueue.size());
assertEqualsM("dwell", 4.5, eth.engine.engineState.dwellAngle); assertEqualsM("dwell", 4.5, eth.engine.engineState.dwellAngle);
@ -419,25 +419,25 @@ void testRpmCalculator(void) {
schedulingQueue.clear(); schedulingQueue.clear();
timeNow += 5000; timeNow += 5000;
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 5", 2, schedulingQueue.size()); assertEqualsM("queue size 5", 2, schedulingQueue.size());
// todo: assert queue elements // todo: assert queue elements
schedulingQueue.clear(); schedulingQueue.clear();
timeNow += 5000; // 5ms timeNow += 5000; // 5ms
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 6", 2, schedulingQueue.size()); assertEqualsM("queue size 6", 2, schedulingQueue.size());
assertEqualsM("6/0", st + 40944, schedulingQueue.getForUnitText(0)->momentX); assertEqualsM("6/0", st + 40944, schedulingQueue.getForUnitText(0)->momentX);
assertEqualsM("6/1", st + 41444, schedulingQueue.getForUnitText(1)->momentX); assertEqualsM("6/1", st + 41444, schedulingQueue.getForUnitText(1)->momentX);
schedulingQueue.clear(); schedulingQueue.clear();
timeNow += 5000; timeNow += 5000;
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 7", 0, schedulingQueue.size()); assertEqualsM("queue size 7", 0, schedulingQueue.size());
schedulingQueue.clear(); schedulingQueue.clear();
timeNow += 5000; // 5ms timeNow += 5000; // 5ms
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 8", 4, schedulingQueue.size()); assertEqualsM("queue size 8", 4, schedulingQueue.size());
// todo: assert queue elements completely // todo: assert queue elements completely
assertEqualsM("8/0", st + 53333 - 1515, schedulingQueue.getForUnitText(0)->momentX); assertEqualsM("8/0", st + 53333 - 1515, schedulingQueue.getForUnitText(0)->momentX);
@ -446,12 +446,12 @@ void testRpmCalculator(void) {
schedulingQueue.clear(); schedulingQueue.clear();
timeNow += 5000; timeNow += 5000;
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_FALLING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 9", 0, schedulingQueue.size()); assertEqualsM("queue size 9", 0, schedulingQueue.size());
schedulingQueue.clear(); schedulingQueue.clear();
timeNow += 5000; // 5ms timeNow += 5000; // 5ms
eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER); eth.engine.triggerCentral.handleShaftSignal(SHAFT_PRIMARY_RISING PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("queue size 10", 0, schedulingQueue.size()); assertEqualsM("queue size 10", 0, schedulingQueue.size());
schedulingQueue.clear(); schedulingQueue.clear();
} }
@ -470,7 +470,7 @@ void testTriggerDecoder(void) {
engine_configuration_s *engineConfiguration = &c.engineConfiguration; engine_configuration_s *engineConfiguration = &c.engineConfiguration;
board_configuration_s *boardConfiguration = &c.engineConfiguration.bc; board_configuration_s *boardConfiguration = &c.engineConfiguration.bc;
initializeSkippedToothTriggerShapeExt(s, 2, 0, FOUR_STROKE_CAM_SENSOR PASS_ENGINE_PARAMETER); initializeSkippedToothTriggerShapeExt(s, 2, 0, FOUR_STROKE_CAM_SENSOR PASS_ENGINE_PARAMETER_SUFFIX);
assertEqualsM("shape size", s->getSize(), 4); assertEqualsM("shape size", s->getSize(), 4);
assertEquals(s->wave.switchTimes[0], 0.25); assertEquals(s->wave.switchTimes[0], 0.25);
assertEquals(s->wave.switchTimes[1], 0.5); assertEquals(s->wave.switchTimes[1], 0.5);
@ -523,7 +523,7 @@ void testTriggerDecoder(void) {
EngineTestHelper eth(MITSU_4G93); EngineTestHelper eth(MITSU_4G93);
EXPAND_EngineTestHelper; EXPAND_EngineTestHelper;
initSpeedDensity(PASS_ENGINE_PARAMETER_F); initSpeedDensity(PASS_ENGINE_PARAMETER_SIGNATURE);
// TriggerShape *t = &eth.engine.triggerShape; // TriggerShape *t = &eth.engine.triggerShape;
// assertEquals(1, t->eventAngles[1]); // assertEquals(1, t->eventAngles[1]);
@ -547,7 +547,7 @@ void testTriggerDecoder(void) {
eth.persistentConfig.engineConfiguration.useOnlyRisingEdgeForTrigger = false; eth.persistentConfig.engineConfiguration.useOnlyRisingEdgeForTrigger = false;
eth.persistentConfig.engineConfiguration.bc.sensorChartMode = SC_DETAILED_RPM; eth.persistentConfig.engineConfiguration.bc.sensorChartMode = SC_DETAILED_RPM;
applyNonPersistentConfiguration(NULL PASS_ENGINE_PARAMETER); applyNonPersistentConfiguration(NULL PASS_ENGINE_PARAMETER_SUFFIX);
// assertEqualsM2("rpm#1", 16666.9746, eth.engine.triggerCentral.triggerState.instantRpmValue[0], 0.5); // assertEqualsM2("rpm#1", 16666.9746, eth.engine.triggerCentral.triggerState.instantRpmValue[0], 0.5);
// assertEqualsM2("rpm#2", 16666.3750, eth.engine.triggerCentral.triggerState.instantRpmValue[1], 0.5); // assertEqualsM2("rpm#2", 16666.3750, eth.engine.triggerCentral.triggerState.instantRpmValue[1], 0.5);
@ -570,8 +570,8 @@ void testTriggerDecoder(void) {
printf("!!!!!!!!!!!!!!!!!! Now trying with only rising edges !!!!!!!!!!!!!!!!!\r\n"); printf("!!!!!!!!!!!!!!!!!! Now trying with only rising edges !!!!!!!!!!!!!!!!!\r\n");
engineConfiguration->useOnlyRisingEdgeForTrigger = true; engineConfiguration->useOnlyRisingEdgeForTrigger = true;
applyNonPersistentConfiguration(NULL PASS_ENGINE_PARAMETER); applyNonPersistentConfiguration(NULL PASS_ENGINE_PARAMETER_SUFFIX);
prepareShapes(PASS_ENGINE_PARAMETER_F); prepareShapes(PASS_ENGINE_PARAMETER_SIGNATURE);
printTriggerDebug = false; printTriggerDebug = false;
} }
@ -631,12 +631,12 @@ static void setTestBug299small(EngineTestHelper *eth) {
setArrayValues(config->cltFuelCorrBins, CLT_CURVE_SIZE, 1); setArrayValues(config->cltFuelCorrBins, CLT_CURVE_SIZE, 1);
setArrayValues(engineConfiguration->injector.battLagCorr, VBAT_INJECTOR_CURVE_SIZE, 0); setArrayValues(engineConfiguration->injector.battLagCorr, VBAT_INJECTOR_CURVE_SIZE, 0);
// this is needed to update injectorLag // this is needed to update injectorLag
engine->updateSlowSensors(PASS_ENGINE_PARAMETER_F); engine->updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("CLT", 70, engine->sensors.clt); assertEqualsM("CLT", 70, engine->sensors.clt);
engineConfiguration->trigger.type = TT_ONE; engineConfiguration->trigger.type = TT_ONE;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
eth->applyTriggerShape(); eth->applyTriggerShape();
@ -648,12 +648,12 @@ static void setTestBug299(EngineTestHelper *eth) {
EXPAND_Engine EXPAND_Engine
assertEqualsM("RPM=0", 0, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM=0", 0, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
eth->fireTriggerEvents2(1, MS2US(20)); eth->fireTriggerEvents2(1, MS2US(20));
// still no RPM since need to cycles measure cycle duration // still no RPM since need to cycles measure cycle duration
assertEqualsM("RPM#1", 0, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM#1", 0, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
eth->fireTriggerEvents2(1, MS2US(20)); eth->fireTriggerEvents2(1, MS2US(20));
assertEqualsM("RPM#2", 3000, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM#2", 3000, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
schedulingQueue.executeAll(99999999); // this is needed to clear 'isScheduled' flag schedulingQueue.executeAll(99999999); // this is needed to clear 'isScheduled' flag
engine->iHead = NULL; // let's drop whatever was scheduled just to start from a clean state engine->iHead = NULL; // let's drop whatever was scheduled just to start from a clean state
@ -744,20 +744,20 @@ static void setTestBug299(EngineTestHelper *eth) {
testMafValue = 0; testMafValue = 0;
assertEqualsM("maf", 0, getMaf(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maf", 0, getMaf(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("iatC", 1, engine->engineState.iatFuelCorrection); assertEqualsM("iatC", 1, engine->engineState.iatFuelCorrection);
assertEqualsM("cltC", 1, engine->engineState.cltFuelCorrection); assertEqualsM("cltC", 1, engine->engineState.cltFuelCorrection);
assertEqualsM("lag", 0, engine->engineState.injectorLag); assertEqualsM("lag", 0, engine->engineState.injectorLag);
assertEqualsM("RPM", 3000, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM", 3000, engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("fuel#1", 1.5, engine->fuelMs); assertEqualsM("fuel#1", 1.5, engine->fuelMs);
assertEqualsM("duty for maf=0", 7.5, getInjectorDutyCycle(engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER)); assertEqualsM("duty for maf=0", 7.5, getInjectorDutyCycle(engine->rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX));
testMafValue = 3; testMafValue = 3;
assertEqualsM("maf", 3, getMaf(PASS_ENGINE_PARAMETER_F)); assertEqualsM("maf", 3, getMaf(PASS_ENGINE_PARAMETER_SIGNATURE));
} }
static void assertInjectors(const char *msg, int value0, int value1) { static void assertInjectors(const char *msg, int value0, int value1) {
@ -782,9 +782,9 @@ void testFuelSchedulerBug299smallAndMedium(void) {
setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 25); setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 25);
setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 25); setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 25);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("fuel#2", 12.5, engine->fuelMs); assertEqualsM("fuel#2", 12.5, engine->fuelMs);
assertEqualsM("duty for maf=3", 62.5, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER)); assertEqualsM("duty for maf=3", 62.5, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("qs#1", 4, schedulingQueue.size()); assertEqualsM("qs#1", 4, schedulingQueue.size());
timeNow += MS2US(20); timeNow += MS2US(20);
@ -843,7 +843,7 @@ void testFuelSchedulerBug299smallAndMedium(void) {
/** /**
* one more revolution * one more revolution
*/ */
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
t = &ENGINE(injectionEvents); t = &ENGINE(injectionEvents);
@ -919,7 +919,7 @@ void testFuelSchedulerBug299smallAndMedium(void) {
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
assertEqualsM("Queue.size#03", 5, schedulingQueue.size()); assertEqualsM("Queue.size#03", 5, schedulingQueue.size());
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertInjectorUpEvent("07@0", 0, MS2US(7.5), 1); assertInjectorUpEvent("07@0", 0, MS2US(7.5), 1);
assertInjectorDownEvent("07@1", 1, MS2US(10), 0); assertInjectorDownEvent("07@1", 1, MS2US(10), 0);
assertInjectorUpEvent("07@2", 2, MS2US(17.5), 0); assertInjectorUpEvent("07@2", 2, MS2US(17.5), 0);
@ -943,15 +943,15 @@ void testFuelSchedulerBug299smallAndMedium(void) {
setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 35); setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 35);
setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 35); setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 35);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("fuel#3", 17.5, engine->fuelMs); assertEqualsM("fuel#3", 17.5, engine->fuelMs);
// duty cycle above 75% is a special use-case because 'special' fuel event overlappes the next normal event in batch mode // duty cycle above 75% is a special use-case because 'special' fuel event overlappes the next normal event in batch mode
assertEqualsM("duty for maf=3", 87.5, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER)); assertEqualsM("duty for maf=3", 87.5, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX));
assertInjectionEvent("#03", &t->elements[0], 0, 0, 315, false); assertInjectionEvent("#03", &t->elements[0], 0, 0, 315, false);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("inj#0", 1, enginePins.injectors[0].currentLogicValue); assertEqualsM("inj#0", 1, enginePins.injectors[0].currentLogicValue);
@ -967,7 +967,7 @@ void testFuelSchedulerBug299smallAndMedium(void) {
schedulingQueue.executeAll(timeNow); schedulingQueue.executeAll(timeNow);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
timeNow += MS2US(20); timeNow += MS2US(20);
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
@ -982,7 +982,7 @@ void testFuelSchedulerBug299smallAndMedium(void) {
schedulingQueue.executeAll(timeNow); schedulingQueue.executeAll(timeNow);
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
t = &ENGINE(injectionEvents); t = &ENGINE(injectionEvents);
@ -1023,9 +1023,9 @@ void testFuelSchedulerBug299smallAndLarge(void) {
setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 35); setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 35);
setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 35); setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 35);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("Lfuel#2", 17.5, engine->fuelMs); assertEqualsM("Lfuel#2", 17.5, engine->fuelMs);
assertEqualsM("Lduty for maf=3", 87.5, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER)); assertEqualsM("Lduty for maf=3", 87.5, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX));
assertEqualsM("Lqs#1", 4, schedulingQueue.size()); assertEqualsM("Lqs#1", 4, schedulingQueue.size());
@ -1087,9 +1087,9 @@ void testFuelSchedulerBug299smallAndLarge(void) {
setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 4); setArrayValues(fuelMap.pointers[engineLoadIndex], FUEL_RPM_COUNT, 4);
setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 4); setArrayValues(fuelMap.pointers[engineLoadIndex + 1], FUEL_RPM_COUNT, 4);
engine->periodicFastCallback(PASS_ENGINE_PARAMETER_F); engine->periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("Lfuel#4", 2, engine->fuelMs); assertEqualsM("Lfuel#4", 2, engine->fuelMs);
assertEqualsM("Lduty for maf=3", 10, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F) PASS_ENGINE_PARAMETER)); assertEqualsM("Lduty for maf=3", 10, getInjectorDutyCycle(eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE) PASS_ENGINE_PARAMETER_SUFFIX));
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
@ -1130,22 +1130,22 @@ void testSparkReverseOrderBug319(void) {
engineConfiguration->specs.cylindersCount = 4; engineConfiguration->specs.cylindersCount = 4;
engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS; engineConfiguration->ignitionMode = IM_INDIVIDUAL_COILS;
setConstantDwell(45 PASS_ENGINE_PARAMETER); setConstantDwell(45 PASS_ENGINE_PARAMETER_SUFFIX);
// this is needed to update injectorLag // this is needed to update injectorLag
engine->updateSlowSensors(PASS_ENGINE_PARAMETER_F); engine->updateSlowSensors(PASS_ENGINE_PARAMETER_SIGNATURE);
assertEqualsM("CLT", 70, engine->sensors.clt); assertEqualsM("CLT", 70, engine->sensors.clt);
engineConfiguration->trigger.type = TT_ONE; engineConfiguration->trigger.type = TT_ONE;
incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_F); incrementGlobalConfigurationVersion(PASS_ENGINE_PARAMETER_SIGNATURE);
eth.applyTriggerShape(); eth.applyTriggerShape();
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
timeNow = 0; timeNow = 0;
setWholeTimingTable(0 PASS_ENGINE_PARAMETER); setWholeTimingTable(0 PASS_ENGINE_PARAMETER_SUFFIX);
timeNow += MS2US(20); timeNow += MS2US(20);
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
@ -1161,7 +1161,7 @@ void testSparkReverseOrderBug319(void) {
timeNow += MS2US(20); timeNow += MS2US(20);
eth.firePrimaryTriggerFall(); eth.firePrimaryTriggerFall();
assertEqualsM("RPM", 3000, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM", 3000, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("queue size", 7, schedulingQueue.size()); assertEqualsM("queue size", 7, schedulingQueue.size());
@ -1191,7 +1191,7 @@ void testSparkReverseOrderBug319(void) {
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
schedulingQueue.executeAll(timeNow); schedulingQueue.executeAll(timeNow);
assertEqualsM("RPM#2", 545, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM#2", 545, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("out-of-order #3", 0, enginePins.coils[3].outOfOrder); assertEqualsM("out-of-order #3", 0, enginePins.coils[3].outOfOrder);
@ -1206,7 +1206,7 @@ void testSparkReverseOrderBug319(void) {
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
schedulingQueue.executeAll(timeNow); schedulingQueue.executeAll(timeNow);
assertEqualsM("RPM#3", 3000, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM#3", 3000, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("out-of-order #5 on c4", 1, enginePins.coils[3].outOfOrder); assertEqualsM("out-of-order #5 on c4", 1, enginePins.coils[3].outOfOrder);
@ -1221,7 +1221,7 @@ void testSparkReverseOrderBug319(void) {
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();
schedulingQueue.executeAll(timeNow); schedulingQueue.executeAll(timeNow);
assertEqualsM("RPM#4", 3000, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_F)); assertEqualsM("RPM#4", 3000, eth.engine.rpmCalculator.getRpm(PASS_ENGINE_PARAMETER_SIGNATURE));
assertEqualsM("out-of-order #7", 1, enginePins.coils[3].outOfOrder); assertEqualsM("out-of-order #7", 1, enginePins.coils[3].outOfOrder);
@ -1278,8 +1278,8 @@ void testMissedSpark299(void) {
assertEquals(3000, eth.engine.rpmCalculator.rpmValue); assertEquals(3000, eth.engine.rpmCalculator.rpmValue);
setWholeTimingTable(3 PASS_ENGINE_PARAMETER); setWholeTimingTable(3 PASS_ENGINE_PARAMETER_SUFFIX);
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
timeNow += MS2US(20); timeNow += MS2US(20);
@ -1296,8 +1296,8 @@ void testMissedSpark299(void) {
eth.firePrimaryTriggerFall(); eth.firePrimaryTriggerFall();
schedulingQueue.executeAll(timeNow); schedulingQueue.executeAll(timeNow);
setWholeTimingTable(-5 PASS_ENGINE_PARAMETER); setWholeTimingTable(-5 PASS_ENGINE_PARAMETER_SUFFIX);
eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_F); eth.engine.periodicFastCallback(PASS_ENGINE_PARAMETER_SIGNATURE);
timeNow += MS2US(20); timeNow += MS2US(20);
eth.firePrimaryTriggerRise(); eth.firePrimaryTriggerRise();