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

Implement `Nitrous Control` settings with arming functionality #6783 (#7103)

This commit is contained in:
kifir23917 2024-11-27 23:43:45 +02:00 committed by GitHub
parent 88571cfc86
commit d58aeb045d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 571 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
firmware/console/binary/live_data.cpp
View File

@ -59,6 +59,15 @@ const shift_torque_reduction_state_s* getLiveData(size_t) {
#endif
}
template<>
const nitrous_control_state_s* getLiveData(size_t) {
#if EFI_LAUNCH_CONTROL
return &engine->nitrousController;
#else
return nullptr;
#endif
}
template<>
const antilag_system_state_s* getLiveData(size_t) {
#if EFI_ANTILAG_SYSTEM

1
firmware/controllers/algo/algo.mk
View File

@ -10,6 +10,7 @@ CONTROLLERS_ALGO_SRC_CPP = $(PROJECT_DIR)/controllers/algo/advance_map.cpp \
$(PROJECT_DIR)/controllers/algo/wall_fuel.cpp \
$(PROJECT_DIR)/controllers/algo/launch_control.cpp \
$(PROJECT_DIR)/controllers/algo/shift_torque_reduction_controller.cpp \
$(PROJECT_DIR)/controllers/algo/nitrous_controller.cpp \
$(PROJECT_DIR)/controllers/algo/antilag_system.cpp \
$(PROJECT_DIR)/controllers/algo/dynoview.cpp \
$(PROJECT_DIR)/controllers/algo/runtime_state.cpp \

2
firmware/controllers/algo/engine.h
View File

@ -31,6 +31,7 @@
#include "injector_model.h"
#include "launch_control.h"
#include "shift_torque_reduction_controller.h"
#include "nitrous_controller.h"
#include "antilag_system.h"
#include "start_stop.h"
#include "trigger_scheduler.h"
@ -198,6 +199,7 @@ public:
SoftSparkLimiter softSparkLimiter;
// technically not directly related to EFI_LAUNCH_CONTROL since useful for TCU
SoftSparkLimiter hardSparkLimiter;
NitrousController nitrousController;
#endif // EFI_LAUNCH_CONTROL
#if EFI_ANTILAG_SYSTEM

1
firmware/controllers/algo/engine2.cpp
View File

@ -174,6 +174,7 @@ void EngineState::periodicFastCallback() {
#if EFI_LAUNCH_CONTROL
engine->launchController.update();
engine->shiftTorqueReductionController.update();
engine->nitrousController.update();
#endif //EFI_LAUNCH_CONTROL
float l_ignitionLoad = getIgnitionLoad();

10
firmware/controllers/algo/engine_configuration_defaults.h
View File

@ -48,4 +48,14 @@ namespace engine_configuration_defaults {
/* Staged injection: */
constexpr bool ENABLE_STAGED_INJECTION = false;
/* Nitrous control */
constexpr bool NITROUS_CONTROL_ENABLED = false;
constexpr nitrous_arming_method_e NITROUS_CONTROL_ARMING_METHOD = DIGITAL_SWITCH_INPUT;
constexpr switch_input_pin_e NITROUS_CONTROL_TRIGGER_PIN = Gpio::Unassigned;
constexpr bool NITROUS_CONTROL_TRIGGER_PIN_INVERTED = false;
constexpr pin_input_mode_e NITROUS_CONTROL_TRIGGER_PIN_MODE = PI_DEFAULT;
constexpr lua_gauge_e NITROUS_LUA_GAUGE = LUA_GAUGE_1;
constexpr lua_gauge_meaning_e NITROUS_LUA_GAUGE_MEANING = LUA_GAUGE_LOWER_BOUND;
constexpr float NITROUS_LUA_GAUGE_ARMING_VALUE = 0.0f;
}

5
firmware/controllers/algo/nitrous_control_state.txt Normal file
View File

@ -0,0 +1,5 @@
struct_no_prefix nitrous_control_state_s
bit isArmed
end_struct

102
firmware/controllers/algo/nitrous_controller.cpp Normal file
View File

@ -0,0 +1,102 @@
//
// Created by kifir on 11/25/24.
//
#include "pch.h"
#if EFI_LAUNCH_CONTROL
#include "nitrous_controller.h"
void NitrousController::update() {
if (engineConfiguration->nitrousControlEnabled) {
updateArmingState();
}
}
void NitrousController::updateArmingState() {
switch (engineConfiguration->nitrousControlArmingMethod) {
case DIGITAL_SWITCH_INPUT: {
isArmed = checkTriggerPinState();
break;
}
case LUA_GAUGE: {
isArmed = checkLuaGauge();
break;
}
default: { // Unexpected value!!!
isArmed = false;
break;
}
}
}
bool NitrousController::checkTriggerPinState() const {
bool result = false;
#if !EFI_SIMULATOR
const switch_input_pin_e triggerPin = engineConfiguration->nitrousControlTriggerPin;
if (isBrainPinValid(triggerPin)) {
result = engineConfiguration->nitrousControlTriggerPinInverted ^ efiReadPin(triggerPin);
}
#endif // !EFI_SIMULATOR
return result;
}
bool NitrousController::checkLuaGauge() const {
bool result = false;
const SensorResult currentSensorResult = Sensor::get(getLuaGauge());
if (currentSensorResult.Valid) {
const float currentValue = currentSensorResult.Value;
const float armingValue = engineConfiguration->nitrousLuaGaugeArmingValue;
switch (engineConfiguration->nitrousLuaGaugeMeaning) {
case LUA_GAUGE_LOWER_BOUND: {
result = (armingValue <= currentValue);
break;
}
case LUA_GAUGE_UPPER_BOUND: {
result = (currentValue <= armingValue);
break;
}
}
}
return result;
}
SensorType NitrousController::getLuaGauge() const {
SensorType result = SensorType::LuaGauge1;
switch (engineConfiguration->nitrousLuaGauge) {
case LUA_GAUGE_1: {
break;
}
case LUA_GAUGE_2: {
result = SensorType::LuaGauge2;
break;
}
case LUA_GAUGE_3: {
result = SensorType::LuaGauge3;
break;
}
case LUA_GAUGE_4: {
result = SensorType::LuaGauge4;
break;
}
case LUA_GAUGE_5: {
result = SensorType::LuaGauge5;
break;
}
case LUA_GAUGE_6: {
result = SensorType::LuaGauge6;
break;
}
case LUA_GAUGE_7: {
result = SensorType::LuaGauge7;
break;
}
case LUA_GAUGE_8: {
result = SensorType::LuaGauge8;
break;
}
}
return result;
}
#endif // EFI_LAUNCH_CONTROL

18
firmware/controllers/algo/nitrous_controller.h Normal file
View File

@ -0,0 +1,18 @@
//
// Created by kifir on 11/25/24.
//
#pragma once
#include "nitrous_control_state_generated.h"
class NitrousController : public nitrous_control_state_s {
public:
void update();
private:
void updateArmingState();
bool checkTriggerPinState() const;
bool checkLuaGauge() const;
SensorType getLuaGauge() const;
};

21
firmware/controllers/algo/rusefi_enums.h
View File

@ -606,6 +606,27 @@ typedef enum __attribute__ ((__packed__)) {
LAUNCH_BUTTON = 1,
} torqueReductionActivationMode_e;
typedef enum __attribute__ ((__packed__)) {
DIGITAL_SWITCH_INPUT = 0,
LUA_GAUGE = 1,
} nitrous_arming_method_e;
typedef enum __attribute__ ((__packed__)) {
LUA_GAUGE_1 = 0,
LUA_GAUGE_2 = 1,
LUA_GAUGE_3 = 2,
LUA_GAUGE_4 = 3,
LUA_GAUGE_5 = 4,
LUA_GAUGE_6 = 5,
LUA_GAUGE_7 = 6,
LUA_GAUGE_8 = 7,
} lua_gauge_e;
typedef enum __attribute__ ((__packed__)) {
LUA_GAUGE_LOWER_BOUND = 0,
LUA_GAUGE_UPPER_BOUND = 1,
} lua_gauge_meaning_e;
typedef enum __attribute__ ((__packed__)) {
SWITCH_INPUT_ANTILAG = 0,
ALWAYS_ON_ANTILAG = 1,

7
firmware/integration/LiveData.yaml
View File

@ -82,6 +82,13 @@ Usages:
constexpr: "engine->shiftTorqueReductionController"
conditional_compilation: "EFI_LAUNCH_CONTROL"
- name: nitrous_control_state
cppFileName: nitrous_controller
java: NitrousController.java
folder: controllers/algo
constexpr: "engine->nitrousController"
conditional_compilation: "EFI_LAUNCH_CONTROL"
- name: antilag_system_state
cppFileName: antilag_system
java: AntilagSystem.java

58
firmware/integration/rusefi_config.txt
View File

@ -1724,15 +1724,67 @@ uint8_t autoscale knockFuelTrim;Fuel trim when knock, max 30%;"%", 1, 0, 0, 30,
float knockSpectrumSensitivity;;"sense", 1, 0, 0, 1, 2
float knockFrequency;"Estimated knock frequency, ignore cylinderBore if this one > 0";"Hz", 1, 0, 0, 20000, 2
injector_compensation_mode_e secondaryInjectorCompensationMode;None = I have a MAP-referenced fuel pressure regulator\nFixed rail pressure = I have an atmosphere-referenced fuel pressure regulator (returnless, typically)\nSensed rail pressure = I have a fuel pressure sensor;
float secondaryInjectorFuelReferencePressure;This is the pressure at which your injector flow is known.\nFor example if your injectors flow 400cc/min at 3.5 bar, enter 350kpa here.;"kPa", 1, 0, 50, 700000, 0
injector_compensation_mode_e secondaryInjectorCompensationMode;None = I have a MAP-referenced fuel pressure regulator\nFixed rail pressure = I have an atmosphere-referenced fuel pressure regulator (returnless, typically)\nSensed rail pressure = I have a fuel pressure sensor;
float secondaryInjectorFuelReferencePressure;This is the pressure at which your injector flow is known.\nFor example if your injectors flow 400cc/min at 3.5 bar, enter 350kpa here.;"kPa", 1, 0, 50, 700000, 0
SentInput EtbSentInput;SENT input connected to ETB
SentInput FuelHighPressureSentInput;SENT input used for high pressure fuel sensor
SentFuelHighPressureType FuelHighPressureSentType;If you have SENT High Pressure Fuel Sensor please select type. For analog TPS leave None
#define END_OF_CALIBRATION_PADDING 108
bit nitrousControlEnabled
bit nitrousControlTriggerPinInverted
bit unusedFancy3
bit unusedFancy4
bit unusedFancy5
bit unusedFancy6
bit unusedFancy7
bit unusedFancy8
bit unusedFancy9
bit unusedFancy10
bit unusedFancy11
bit unusedFancy12
bit unusedFancy13
bit unusedFancy14
bit unusedFancy15
bit unusedFancy16
bit unusedFancy17
bit unusedFancy18
bit unusedFancy19
bit unusedFancy20
bit unusedFancy21
bit unusedFancy22
bit unusedFancy23
bit unusedFancy24
bit unusedFancy25
bit unusedFancy26
bit unusedFancy27
bit unusedFancy28
bit unusedFancy29
bit unusedFancy30
bit unusedFancy31
bit unusedFancy32
! 'unusedFancy32' is the 32nd bit here, you would need another bit region if more bits are desired
#define nitrous_arming_method_e_enum "Digital Switch Input", "Lua Gauge"
custom nitrous_arming_method_e 1 bits, S08, @OFFSET@, [3:3], @@nitrous_arming_method_e_enum@@
nitrous_arming_method_e nitrousControlArmingMethod;
switch_input_pin_e nitrousControlTriggerPin;Pin that activates nitrous control
pin_input_mode_e nitrousControlTriggerPinMode;
#define lua_gauge_e_enum "Lua Gauge 1", "Lua Gauge 2", "Lua Gauge 3", "Lua Gauge 4", "Lua Gauge 5", "Lua Gauge 6", "Lua Gauge 7", "Lua Gauge 8"
custom lua_gauge_e 1 bits, S08, @OFFSET@, [0:2], @@lua_gauge_e_enum@@
lua_gauge_e nitrousLuaGauge;
#define lua_gauge_meaning_e_enum "Lower Bound", "Upper Bound"
custom lua_gauge_meaning_e 1 bits, S08, @OFFSET@, [3:3], @@lua_gauge_meaning_e_enum@@
lua_gauge_meaning_e nitrousLuaGaugeMeaning;
float nitrousLuaGaugeArmingValue;;"", 1, 0, -30000, 30000, 3
#define END_OF_CALIBRATION_PADDING 94
uint8_t[END_OF_CALIBRATION_PADDING] unusedOftenChangesDuringFirmwareUpdate;;"units", 1, 0, 0, 1, 0
! end of engine_configuration_s

29
firmware/tunerstudio/tunerstudio.template.ini
View File

@ -2076,6 +2076,7 @@ menuDialog = main
menu = "&Advanced"
subMenu = smLaunchControl, @@smLaunchControl_NAME@@
subMenu = ShiftTorqueReductionDialog, "Shift Torque Reduction (Flat Shift)"
subMenu = NitrousControlDialog, "Nitrous Control"
subMenu = ignitionCylExtra, "Cylinder offsets", 0@@if_ts_show_odd_fire
subMenu = std_separator
@ -4957,7 +4958,7 @@ dialog = tcuControls, "Transmission Settings"
panel = LaunchButtonDialog, {torqueReductionActivationMode == @@torqueReductionActivationMode_e_LAUNCH_BUTTON@@}
dialog = TorqueReductionSettings, "Settings"
field = "Limit Torque Reduction Time", limitTorqueReductionTime
field = "Limit Torque Reduction Time", limitTorqueReductionTime
field = "Torque Reduction Time", torqueReductionTime, {limitTorqueReductionTime != 0}
field = "Torque Reduction Arming RPM", torqueReductionArmingRpm
field = "Torque Reduction Arming APP", torqueReductionArmingApp
@ -4965,7 +4966,7 @@ dialog = tcuControls, "Transmission Settings"
field = "Torque Reduction Ignition Cut", torqueReductionIgnitionCut
dialog = ShiftTorqueReductionSettingsDialog, "", yAxis
field = "Enable Shift Torque Reduction", torqueReductionEnabled
field = "Enable Shift Torque Reduction", torqueReductionEnabled
panel = TorqueReductionActivationModeDialog, {torqueReductionEnabled == 1}
panel = TorqueReductionSettings, {torqueReductionEnabled == 1 && ((torqueReductionActivationMode == @@torqueReductionActivationMode_e_TORQUE_REDUCTION_BUTTON@@ && torqueReductionTriggerPin != 0) || (torqueReductionActivationMode == @@torqueReductionActivationMode_e_LAUNCH_BUTTON@@ && launchActivatePin != 0))}
@ -4973,6 +4974,30 @@ dialog = tcuControls, "Transmission Settings"
panel = ShiftTorqueReductionSettingsDialog, West
panel = shift_torque_reduction_stateDialog, East
dialog = NitrousControlButtonDialog, "Digital Switch Input"
field = "Nitrous Control Button", nitrousControlTriggerPin
field = "Nitrous Control Inverted", nitrousControlTriggerPinInverted, {nitrousControlTriggerPin != 0}
field = "Nitrous Control Mode", nitrousControlTriggerPinMode, {nitrousControlTriggerPin != 0}
dialog = NitrousControlLuaGaugeDialog, "Lua Gauge"
field = "Lua Gauge", nitrousLuaGauge
field = "Value Meaning", nitrousLuaGaugeMeaning
field = "Arming Value", nitrousLuaGaugeArmingValue
dialog = NitrousControlArmingMethodDialog, "Arming Method", yAxis
field = "Arming Method", nitrousControlArmingMethod
panel = NitrousControlButtonDialog, {nitrousControlArmingMethod == @@nitrous_arming_method_e_DIGITAL_SWITCH_INPUT@@}
panel = NitrousControlLuaGaugeDialog, {nitrousControlArmingMethod == @@nitrous_arming_method_e_LUA_GAUGE@@}
dialog = NitrousControlSettingsDialog, "", yAxis
field = "Enable Nitrous Control", nitrousControlEnabled
panel = NitrousControlArmingMethodDialog, {nitrousControlEnabled == 1}
; panel = NitrousControlSettings, {nitrousControlEnabled == 1 && ((nitrousControlArmingMethod == @@nitrous_arming_method_e_DIGITAL_SWITCH_INPUT@@ && nitrousControlTriggerPin != 0) || (nitrousControlArmingMethod == @@nitrous_arming_method_e_LUA_GAUGE@@))}
dialog = NitrousControlDialog
panel = NitrousControlSettingsDialog, West
panel = nitrous_control_stateDialog, East
dialog = smLaunchControl, "", border
panel = smLaunchControlWest, West
panel = launch_control_stateDialog, East

128
unit_tests/tests/nitrous_control/test_nitrous_arming.cpp Normal file
View File

@ -0,0 +1,128 @@
//
// Created by kifir on 11/27/24.
//
#include "pch.h"
#include "util/test_base.h"
namespace {
class NitrousArmingTest: public TestBase
{
protected:
static constexpr switch_input_pin_e TEST_NITROUS_CONTROL_ARMING_PIN = Gpio::A13;
static constexpr lua_gauge_e TEST_NITROUS_LUA_GAUGE = LUA_GAUGE_3;
static constexpr SensorType TEST_NITROUS_LUA_GAUGE_SENSOR = SensorType::LuaGauge3;
static constexpr float TEST_NITROUS_LUA_GAUGE_ARMING_VALUE = 239.17;
static const EngineConfig TEST_ENGINE_CONFIG;
void checkArmingAfterPeriodicFastCallback(bool shouldBeArmed, const char* context);
};
const EngineConfig NitrousArmingTest::TEST_ENGINE_CONFIG = EngineConfig()
.setNitrousControlTriggerPin({ TEST_NITROUS_CONTROL_ARMING_PIN })
.setNitrousLuaGauge({ TEST_NITROUS_LUA_GAUGE })
.setNitrousLuaGaugeArmingValue({ TEST_NITROUS_LUA_GAUGE_ARMING_VALUE });
void NitrousArmingTest::checkArmingAfterPeriodicFastCallback(const bool shouldBeArmed, const char* const context) {
periodicFastCallback();
EXPECT_EQ(engine->nitrousController.isArmed, shouldBeArmed) << context;
}
TEST_F(NitrousArmingTest, checkDefault) {
setUpEngineConfiguration(EngineConfig());
checkArmingAfterPeriodicFastCallback(false, "default");
}
TEST_F(NitrousArmingTest, checkDigitalSwitchInputArmingMethod) {
setUpEngineConfiguration(
TEST_ENGINE_CONFIG.clone()
.setNitrousControlEnabled({ true })
.setNitrousControlArmingMethod({ DIGITAL_SWITCH_INPUT })
);
checkArmingAfterPeriodicFastCallback(false, "default");
setMockState(TEST_NITROUS_CONTROL_ARMING_PIN, true);
checkArmingAfterPeriodicFastCallback(true, "arming pin is turned on");
setMockState(TEST_NITROUS_CONTROL_ARMING_PIN, false);
checkArmingAfterPeriodicFastCallback(false, "arming pin is turned off");
}
TEST_F(NitrousArmingTest, checkDigitalSwitchInputArmingMethodInverted) {
setUpEngineConfiguration(
TEST_ENGINE_CONFIG.clone()
.setNitrousControlEnabled({ true })
.setNitrousControlArmingMethod({ DIGITAL_SWITCH_INPUT })
.setNitrousControlTriggerPinInverted({ true })
);
checkArmingAfterPeriodicFastCallback(true, "default");
setMockState(TEST_NITROUS_CONTROL_ARMING_PIN, true);
checkArmingAfterPeriodicFastCallback(false, "arming pin is turned on");
setMockState(TEST_NITROUS_CONTROL_ARMING_PIN, false);
checkArmingAfterPeriodicFastCallback(true, "arming pin is turned off");
}
TEST_F(NitrousArmingTest, checkDisabledNitrousControl) {
setUpEngineConfiguration(
TEST_ENGINE_CONFIG.clone()
.setNitrousControlEnabled({ false })
.setNitrousControlArmingMethod({ DIGITAL_SWITCH_INPUT })
);
checkArmingAfterPeriodicFastCallback(false, "default");
setMockState(TEST_NITROUS_CONTROL_ARMING_PIN, false);
checkArmingAfterPeriodicFastCallback(false, "arming pin is turned on");
setMockState(TEST_NITROUS_CONTROL_ARMING_PIN, false);
checkArmingAfterPeriodicFastCallback(false, "arming pin is turned off");
}
TEST_F(NitrousArmingTest, checkLuaGaugeLowerBound) {
setUpEngineConfiguration(
TEST_ENGINE_CONFIG.clone()
.setNitrousControlEnabled({ true })
.setNitrousControlArmingMethod({ LUA_GAUGE })
.setNitrousLuaGaugeMeaning({ LUA_GAUGE_LOWER_BOUND })
);
checkArmingAfterPeriodicFastCallback(false, "default");
Sensor::setMockValue(TEST_NITROUS_LUA_GAUGE_SENSOR, TEST_NITROUS_LUA_GAUGE_ARMING_VALUE - EPS5D);
checkArmingAfterPeriodicFastCallback(false, "under Lua arming value");
Sensor::setMockValue(TEST_NITROUS_LUA_GAUGE_SENSOR, TEST_NITROUS_LUA_GAUGE_ARMING_VALUE);
checkArmingAfterPeriodicFastCallback(true, "Lua arming value");
Sensor::setMockValue(TEST_NITROUS_LUA_GAUGE_SENSOR, TEST_NITROUS_LUA_GAUGE_ARMING_VALUE + EPS5D);
checkArmingAfterPeriodicFastCallback(true, "above Lua arming value");
}
TEST_F(NitrousArmingTest, checkLuaGaugeUpperBound) {
setUpEngineConfiguration(
TEST_ENGINE_CONFIG.clone()
.setNitrousControlEnabled({ true })
.setNitrousControlArmingMethod({ LUA_GAUGE })
.setNitrousLuaGaugeMeaning({ LUA_GAUGE_UPPER_BOUND })
);
checkArmingAfterPeriodicFastCallback(false, "default");
Sensor::setMockValue(TEST_NITROUS_LUA_GAUGE_SENSOR, TEST_NITROUS_LUA_GAUGE_ARMING_VALUE - EPS5D);
checkArmingAfterPeriodicFastCallback(true, "under Lua arming value");
Sensor::setMockValue(TEST_NITROUS_LUA_GAUGE_SENSOR, TEST_NITROUS_LUA_GAUGE_ARMING_VALUE);
checkArmingAfterPeriodicFastCallback(true, "Lua arming value");
Sensor::setMockValue(TEST_NITROUS_LUA_GAUGE_SENSOR, TEST_NITROUS_LUA_GAUGE_ARMING_VALUE + EPS5D);
checkArmingAfterPeriodicFastCallback(false, "above Lua arming value");
}
}

1
unit_tests/tests/tests.mk
View File

@ -71,6 +71,7 @@ TESTS_SRC_CPP = \
tests/shift_torque_reduction/test_shift_torque_reduction_flat_shift_condition.cpp \
tests/shift_torque_reduction/test_shift_torque_reduction_spark_skip_ratio.cpp \
tests/shift_torque_reduction/test_shift_torque_reduction_angle_advance.cpp \
tests/nitrous_control/test_nitrous_arming.cpp \
tests/test_fft.cpp \
tests/lua/test_lua_basic.cpp \
tests/lua/test_bit_range_msb.cpp \

42
unit_tests/tests/util/engine_config.cpp
View File

@ -177,4 +177,44 @@ EngineConfig EngineConfig::setSecondaryInjectorCompensationMode(
) {
m_secondaryInjectorCompensationMode = value;
return *this;
}
}
EngineConfig EngineConfig::setNitrousControlEnabled(const std::optional<bool> value) {
m_nitrousControlEnabled = value;
return *this;
}
EngineConfig EngineConfig::setNitrousControlArmingMethod(const std::optional<nitrous_arming_method_e> value) {
m_nitrousControlArmingMethod = value;
return *this;
}
EngineConfig EngineConfig::setNitrousControlTriggerPin(const std::optional<switch_input_pin_e> value) {
m_nitrousControlTriggerPin = value;
return *this;
}
EngineConfig EngineConfig::setNitrousControlTriggerPinInverted(const std::optional<bool> value) {
m_nitrousControlTriggerPinInverted = value;
return *this;
}
EngineConfig EngineConfig::setNitrousControlTriggerPinMode(const std::optional<pin_input_mode_e> value) {
m_nitrousControlTriggerPinMode = value;
return *this;
}
EngineConfig EngineConfig::setNitrousLuaGauge(const std::optional<lua_gauge_e> value) {
m_nitrousLuaGauge = value;
return *this;
}
EngineConfig EngineConfig::setNitrousLuaGaugeMeaning(const std::optional<lua_gauge_meaning_e> value) {
m_nitrousLuaGaugeMeaning = value;
return *this;
}
EngineConfig EngineConfig::setNitrousLuaGaugeArmingValue(const std::optional<float> value) {
m_nitrousLuaGaugeArmingValue = value;
return *this;
}

30
unit_tests/tests/util/engine_config.h
View File

@ -59,6 +59,16 @@ public:
// Staged injection
std::optional<bool> getStagedInjectionEnabled() const { return m_isStagedInjectionEnabled; }
// Nitrous control
std::optional<bool> getNitrousControlEnabled() const { return m_nitrousControlEnabled; }
std::optional<nitrous_arming_method_e> getNitrousControlArmingMethod() const { return m_nitrousControlArmingMethod; }
std::optional<switch_input_pin_e> getNitrousControlTriggerPin() const { return m_nitrousControlTriggerPin; }
std::optional<bool> getNitrousControlTriggerPinInverted() const { return m_nitrousControlTriggerPinInverted; }
std::optional<pin_input_mode_e> getNitrousControlTriggerPinMode() const { return m_nitrousControlTriggerPinMode; }
std::optional<lua_gauge_e> getNitrousLuaGauge() const { return m_nitrousLuaGauge; }
std::optional<lua_gauge_meaning_e> getNitrousLuaGaugeMeaning() const { return m_nitrousLuaGaugeMeaning; }
std::optional<float> getNitrousLuaGaugeArmingValue() const { return m_nitrousLuaGaugeArmingValue; }
// We do not core about performance in tests, but we want to use builder-like style, so setters return new instance
// of configuration:
@ -105,6 +115,16 @@ public:
// Staged injection
EngineConfig setStagedInjectionEnabled(std::optional<bool> value);
// Nitrous control
EngineConfig setNitrousControlEnabled(std::optional<bool> value);
EngineConfig setNitrousControlArmingMethod(std::optional<nitrous_arming_method_e> value);
EngineConfig setNitrousControlTriggerPin(std::optional<switch_input_pin_e> value);
EngineConfig setNitrousControlTriggerPinInverted(std::optional<bool> value);
EngineConfig setNitrousControlTriggerPinMode(std::optional<pin_input_mode_e> value);
EngineConfig setNitrousLuaGauge(std::optional<lua_gauge_e> value);
EngineConfig setNitrousLuaGaugeMeaning(std::optional<lua_gauge_meaning_e> value);
EngineConfig setNitrousLuaGaugeArmingValue(std::optional<float> value);
private:
// Launch Control
std::optional<switch_input_pin_e> m_launchActivatePin;
@ -149,4 +169,14 @@ private:
// Staged injection
std::optional<bool> m_isStagedInjectionEnabled;
// Nitrous control
std::optional<bool> m_nitrousControlEnabled;
std::optional<nitrous_arming_method_e> m_nitrousControlArmingMethod;
std::optional<switch_input_pin_e> m_nitrousControlTriggerPin;
std::optional<bool> m_nitrousControlTriggerPinInverted;
std::optional<pin_input_mode_e> m_nitrousControlTriggerPinMode;
std::optional<lua_gauge_e> m_nitrousLuaGauge;
std::optional<lua_gauge_meaning_e> m_nitrousLuaGaugeMeaning;
std::optional<float> m_nitrousLuaGaugeArmingValue;
};

12
unit_tests/tests/util/test_base.cpp
View File

@ -74,6 +74,18 @@ void TestBase::setUpEngineConfiguration(const EngineConfig& config) {
// Staged injection
getTestEngineConfiguration().configureEnableStagedInjection(config.getStagedInjectionEnabled());
// Nitrous control
getTestEngineConfiguration().configureNitrousControlEnabled(config.getNitrousControlEnabled());
getTestEngineConfiguration().configureNitrousControlArmingMethod(config.getNitrousControlArmingMethod());
getTestEngineConfiguration().configureNitrousControlTriggerPin(config.getNitrousControlTriggerPin());
getTestEngineConfiguration().configureNitrousControlTriggerPinInverted(
config.getNitrousControlTriggerPinInverted()
);
getTestEngineConfiguration().configureNitrousControlTriggerPinMode(config.getNitrousControlTriggerPinMode());
getTestEngineConfiguration().configureNitrousLuaGauge(config.getNitrousLuaGauge());
getTestEngineConfiguration().configureNitrousLuaGaugeMeaning(config.getNitrousLuaGaugeMeaning());
getTestEngineConfiguration().configureNitrousLuaGaugeArmingValue(config.getNitrousLuaGaugeArmingValue());
}
void TestBase::periodicFastCallback() {

91
unit_tests/tests/util/test_engine_configuration.cpp
View File

@ -386,6 +386,97 @@ void TestEngineConfiguration::configureEnableStagedInjection(const std::optional
}
}
void TestEngineConfiguration::configureNitrousControlEnabled(const std::optional<bool> nitrousControlEnabled) {
if (nitrousControlEnabled.has_value()) {
engineConfiguration->nitrousControlEnabled = nitrousControlEnabled.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousControlEnabled,
engine_configuration_defaults::NITROUS_CONTROL_ENABLED
); // check default value
}
}
void TestEngineConfiguration::configureNitrousControlArmingMethod(
const std::optional<nitrousArmingMethod_e> armingMethod
) {
if (armingMethod.has_value()) {
engineConfiguration->nitrousControlArmingMethod = armingMethod.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousControlArmingMethod,
engine_configuration_defaults::NITROUS_CONTROL_ARMING_METHOD
); // check default value
}
}
void TestEngineConfiguration::configureNitrousControlTriggerPin(const std::optional<switch_input_pin_e> triggerPin) {
if (triggerPin.has_value()) {
engineConfiguration->nitrousControlTriggerPin = triggerPin.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousControlTriggerPin,
engine_configuration_defaults::NITROUS_CONTROL_TRIGGER_PIN
); // check default value
}
}
void TestEngineConfiguration::configureNitrousControlTriggerPinInverted(const std::optional<bool> triggerPinInverted) {
if (triggerPinInverted.has_value()) {
engineConfiguration->nitrousControlTriggerPinInverted = triggerPinInverted.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousControlTriggerPinInverted,
engine_configuration_defaults::NITROUS_CONTROL_TRIGGER_PIN_INVERTED
); // check default value
}
}
void TestEngineConfiguration::configureNitrousControlTriggerPinMode(
const std::optional<pin_input_mode_e> triggerPinMode
) {
if (triggerPinMode.has_value()) {
engineConfiguration->nitrousControlTriggerPinMode = triggerPinMode.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousControlTriggerPinMode,
engine_configuration_defaults::NITROUS_CONTROL_TRIGGER_PIN_MODE
); // check default value
}
}
void TestEngineConfiguration::configureNitrousLuaGauge(const std::optional<luaGauge_e> luaGauge) {
if (luaGauge.has_value()) {
engineConfiguration->nitrousLuaGauge = luaGauge.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousLuaGauge,
engine_configuration_defaults::NITROUS_LUA_GAUGE
); // check default value
}
}
void TestEngineConfiguration::configureNitrousLuaGaugeMeaning(const std::optional<luaGaugeMeaning_e> luaGaugeMeaning) {
if (luaGaugeMeaning.has_value()) {
engineConfiguration->nitrousLuaGaugeMeaning = luaGaugeMeaning.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousLuaGaugeMeaning,
engine_configuration_defaults::NITROUS_LUA_GAUGE_MEANING
); // check default value
}
}
void TestEngineConfiguration::configureNitrousLuaGaugeArmingValue(const std::optional<float> luaGaugeArmingValue) {
if (luaGaugeArmingValue.has_value()) {
engineConfiguration->nitrousLuaGaugeArmingValue = luaGaugeArmingValue.value();
} else {
ASSERT_EQ(
engineConfiguration->nitrousLuaGaugeArmingValue,
engine_configuration_defaults::NITROUS_LUA_GAUGE_ARMING_VALUE
); // check default value
}
}
TestEngineConfiguration::TestEngineConfiguration() {
}

10
unit_tests/tests/util/test_engine_configuration.h
View File

@ -61,6 +61,16 @@ public:
// Staged injection
void configureEnableStagedInjection(std::optional<bool> isStagedInjectionEnabled);
// Nitrous control
void configureNitrousControlEnabled(std::optional<bool> nitrousControlEnabled);
void configureNitrousControlArmingMethod(std::optional<nitrousArmingMethod_e> armingMethod);
void configureNitrousControlTriggerPin(std::optional<switch_input_pin_e> triggerPin);
void configureNitrousControlTriggerPinInverted(std::optional<bool> triggerPinInverted);
void configureNitrousControlTriggerPinMode(std::optional<pin_input_mode_e> triggerPinMode);
void configureNitrousLuaGauge(std::optional<luaGauge_e> luaGauge);
void configureNitrousLuaGaugeMeaning(std::optional<luaGaugeMeaning_e> luaGaugeMeaning);
void configureNitrousLuaGaugeArmingValue(std::optional<float> luaGaugeArmingValue);
private:
TestEngineConfiguration();
static TestEngineConfiguration instance;