#include <boost_control.h>

Inheritance diagram for BoostController:

[legend]

Collaboration diagram for BoostController:

[legend]

Public Member Functions
void	init (IPwm pmw, const ValueProvider3D openLoopMap, const ValueProvider3D closedLoopTargetMap, pid_s pidParams)

void	onFastCallback () override

void	resetLua ()

void	onConfigurationChange (engine_configuration_s const *previousConfig) override

expected< float >	observePlant () override

expected< float >	getSetpoint () override

expected< percent_t >	getOpenLoop (float target) override

expected< percent_t >	getClosedLoop (float target, float manifoldPressure) override

void	setOutput (expected< percent_t > outputValue) override

Public Member Functions inherited from EngineModule
virtual void	onSlowCallback ()

virtual void	onIgnitionStateChanged (bool)

virtual bool	needsDelayedShutoff ()

Public Member Functions inherited from ClosedLoopController< float, percent_t >
expected< percent_t >	update ()

Private Member Functions
percent_t	getClosedLoopImpl (float target, float manifoldPressure)

Private Attributes
Pid	m_pid

const ValueProvider3D *	m_openLoopMap = nullptr

const ValueProvider3D *	m_closedLoopTargetMap = nullptr

IPwm *	m_pwm = nullptr

Additional Inherited Members
Data Fields inherited from boost_control_s
bool	isTpsInvalid: 1 {}

bool	m_shouldResetPid: 1 {}

bool	isBelowClosedLoopThreshold: 1 {}

bool	isNotClosedLoop: 1 {}

bool	isZeroRpm: 1 {}

bool	hasInitBoost: 1 {}

bool	rpmTooLow: 1 {}

bool	tpsTooLow: 1 {}

bool	mapTooLow: 1 {}

bool	isPlantValid: 1 {}

bool	isBoostControlled: 1 {}

bool	unusedBit_11_11: 1 {}

bool	unusedBit_11_12: 1 {}

bool	unusedBit_11_13: 1 {}

bool	unusedBit_11_14: 1 {}

bool	unusedBit_11_15: 1 {}

bool	unusedBit_11_16: 1 {}

bool	unusedBit_11_17: 1 {}

bool	unusedBit_11_18: 1 {}

bool	unusedBit_11_19: 1 {}

bool	unusedBit_11_20: 1 {}

bool	unusedBit_11_21: 1 {}

bool	unusedBit_11_22: 1 {}

bool	unusedBit_11_23: 1 {}

bool	unusedBit_11_24: 1 {}

bool	unusedBit_11_25: 1 {}

bool	unusedBit_11_26: 1 {}

bool	unusedBit_11_27: 1 {}

bool	unusedBit_11_28: 1 {}

bool	unusedBit_11_29: 1 {}

bool	unusedBit_11_30: 1 {}

bool	unusedBit_11_31: 1 {}

scaled_channel< int16_t, 2, 1 >	luaTargetAdd = (int16_t)0

scaled_channel< int16_t, 100, 1 >	boostOutput = (int16_t)0

float	luaTargetMult = (float)0

float	openLoopPart = (float)0

float	luaOpenLoopAdd = (float)0

scaled_channel< int8_t, 2, 1 >	boostControllerClosedLoopPart = (int8_t)0

uint8_t	alignmentFill_at_21 [1]

scaled_channel< int16_t, 30, 1 >	boostControlTarget = (int16_t)0

Detailed Description

Definition at line 16 of file boost_control.h.

Member Function Documentation

◆ getClosedLoop()

expected< percent_t > BoostController::getClosedLoop	(	float	target,
		float	manifoldPressure
	)

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 163 of file boost_control.cpp.

                                                                                        {
     boostControllerClosedLoopPart = getClosedLoopImpl(target, manifoldPressure);
  
     m_pid.postState(engine->outputChannels.boostStatus);
  
     boostControlTarget = target;
  
     return (float)boostControllerClosedLoopPart;
 }

Here is the call graph for this function:

◆ getClosedLoopImpl()

percent_t BoostController::getClosedLoopImpl	(	float	target,
		float	manifoldPressure
	)

private

Definition at line 133 of file boost_control.cpp.

                                                                                  {
     // If we're in open loop only mode, make no closed loop correction.
     isNotClosedLoop = engineConfiguration->boostType != CLOSED_LOOP;
     if (isNotClosedLoop) {
         return 0;
     }
  
     // Reset PID if requested
     if (m_shouldResetPid) {
         m_pid.reset();
         m_shouldResetPid = false;
     }
  
     // If the engine isn't running, don't correct.
     isZeroRpm = Sensor::getOrZero(SensorType::Rpm) == 0;
     if (isZeroRpm) {
         m_pid.reset();
         return 0;
     }
  
     isBelowClosedLoopThreshold = manifoldPressure < engineConfiguration->minimumBoostClosedLoopMap;
     if (isBelowClosedLoopThreshold) {
         // We're below the CL threshold, inhibit CL for now
         m_pid.reset();
         return 0;
     }
  
     return m_pid.getOutput(target, manifoldPressure, FAST_CALLBACK_PERIOD_MS / 1000.0f);
 }

Referenced by getClosedLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getOpenLoop()

expected< percent_t > BoostController::getOpenLoop ( float target )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 94 of file boost_control.cpp.

                                                              {
     // Boost control open loop doesn't care about target - only TPS/RPM
     UNUSED(target);
  
     float rpm = Sensor::getOrZero(SensorType::Rpm);
     auto driverIntent = Sensor::get(SensorType::DriverThrottleIntent);
  
     isTpsInvalid = !driverIntent.Valid;
  
     if (isTpsInvalid) {
         return unexpected;
     }
  
     efiAssert(ObdCode::OBD_PCM_Processor_Fault, m_openLoopMap != nullptr, "boost open loop", unexpected);
  
     percent_t openLoop = luaOpenLoopAdd + m_openLoopMap->getValue(rpm, driverIntent.Value);
  
 #if EFI_ENGINE_CONTROL
     // Add any blends if configured
     for (size_t i = 0; i < efi::size(config->boostOpenLoopBlends); i++) {
         auto result = calculateBlend(config->boostOpenLoopBlends[i], rpm, driverIntent.Value);
  
         engine->outputChannels.boostOpenLoopBlendParameter[i] = result.BlendParameter;
         engine->outputChannels.boostOpenLoopBlendBias[i] = result.Bias;
         engine->outputChannels.boostOpenLoopBlendOutput[i] = result.Value;
  
         openLoop += result.Value;
     }
 #endif // EFI_ENGINE_CONTROL
  
     // Add gear-based adder
     auto gear = Sensor::getOrZero(SensorType::DetectedGear);
     float gearAdder = engineConfiguration->gearBasedOpenLoopBoostAdder[static_cast<int>(gear) + 1];
     openLoop += gearAdder;
  
     openLoopPart = openLoop;
     return openLoop;
 }

Here is the call graph for this function:

◆ getSetpoint()

expected< float > BoostController::getSetpoint ( )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 57 of file boost_control.cpp.

                                              {
     // If we're in open loop only mode, disregard any target computation.
     // Open loop needs to work even in case of invalid closed loop config
     isNotClosedLoop = engineConfiguration->boostType != CLOSED_LOOP;
     if (isNotClosedLoop) {
         boostControllerClosedLoopPart = 0;
         return (float)boostControllerClosedLoopPart;
     }
  
     float rpm = Sensor::getOrZero(SensorType::Rpm);
  
     auto driverIntent = Sensor::get(SensorType::DriverThrottleIntent);
     isTpsInvalid = !driverIntent.Valid;
  
     if (isTpsInvalid) {
         return unexpected;
     }
  
     efiAssert(ObdCode::OBD_PCM_Processor_Fault, m_closedLoopTargetMap != nullptr, "boost closed loop target", unexpected);
  
     float target = m_closedLoopTargetMap->getValue(rpm, driverIntent.Value);
 #if EFI_ENGINE_CONTROL
     // Add any blends if configured
     for (size_t i = 0; i < efi::size(config->boostClosedLoopBlends); i++) {
         auto result = calculateBlend(config->boostClosedLoopBlends[i], rpm, driverIntent.Value);
  
         engine->outputChannels.boostClosedLoopBlendParameter[i] = result.BlendParameter;
         engine->outputChannels.boostClosedLoopBlendBias[i] = result.Bias;
         engine->outputChannels.boostClosedLoopBlendOutput[i] = result.Value;
  
         target += result.Value;
     }
 #endif //EFI_ENGINE_CONTROL
  
     return target * luaTargetMult + luaTargetAdd;
 }

Here is the call graph for this function:

◆ init()

void BoostController::init	(	IPwm *	pmw,
		const ValueProvider3D *	openLoopMap,
		const ValueProvider3D *	closedLoopTargetMap,
		pid_s *	pidParams
	)

Definition at line 24 of file boost_control.cpp.

                                                                                                                                       {
     m_pwm = pwm;
     m_openLoopMap = openLoopMap;
     m_closedLoopTargetMap = closedLoopTargetMap;
  
     m_pid.initPidClass(pidParams);
     resetLua();
  
     hasInitBoost = true;
 }

Referenced by initBoostCtrl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ observePlant()

expected< float > BoostController::observePlant ( )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 47 of file boost_control.cpp.

                                               {
     expected<float> map = Sensor::get(SensorType::Map);
     if (!map.Valid && engineConfiguration->boostType != CLOSED_LOOP) {
         // if we're in open loop only let's somewhat operate even without valid Map sensor
         map = 0;
     }
     isPlantValid = map.Valid;
     return map;
 }

Here is the call graph for this function:

◆ onConfigurationChange()

void BoostController::onConfigurationChange ( engine_configuration_s const * previousConfig )

overridevirtual

Reimplemented from EngineModule.

Definition at line 41 of file boost_control.cpp.

                                                                                          {
     if (!previousConfig || !m_pid.isSame(&previousConfig->boostPid)) {
         m_shouldResetPid = true;
     }
 }

Here is the call graph for this function:

◆ onFastCallback()

void BoostController::onFastCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 195 of file boost_control.cpp.

                                      {
     if (!hasInitBoost) {
         return;
     }
  
     m_pid.iTermMin = -20;
     m_pid.iTermMax = 20;
  
     rpmTooLow = Sensor::getOrZero(SensorType::Rpm) < engineConfiguration->boostControlMinRpm;
     tpsTooLow = Sensor::getOrZero(SensorType::Tps1) < engineConfiguration->boostControlMinTps;
     mapTooLow = Sensor::getOrZero(SensorType::Map) < engineConfiguration->boostControlMinMap;
  
   isBoostControlled = !(rpmTooLow || tpsTooLow || mapTooLow);
  
     if (!isBoostControlled) {
         // Passing unexpected will use the safe duty cycle configured by the user
         setOutput(unexpected);
     } else {
         ClosedLoopController::update();
     }
 }

Here is the call graph for this function:

◆ resetLua()

void BoostController::resetLua ( )

Definition at line 35 of file boost_control.cpp.

                                {
     luaTargetAdd = 0;
     luaTargetMult = 1;
     luaOpenLoopAdd = 0;
 }

Referenced by init().

Here is the caller graph for this function:

◆ setOutput()

void BoostController::setOutput ( expected< percent_t > outputValue )

overridevirtual

Implements ClosedLoopController< float, percent_t >.

Definition at line 173 of file boost_control.cpp.

                                                       {
     // this clamping is just for happier gauge #6339
     boostOutput = clampPercentValue(output.value_or(engineConfiguration->boostControlSafeDutyCycle));
  
     if (!engineConfiguration->isBoostControlEnabled) {
         // If not enabled, force 0% output
         boostOutput = 0;
     }
  
     float duty = PERCENT_TO_DUTY(boostOutput);
  
     if (m_pwm) {
         m_pwm->setSimplePwmDutyCycle(duty);
     }
  
 #if EFI_ELECTRONIC_THROTTLE_BODY
     // inject wastegate position into DC controllers, pretty weird workflow to be honest
     // todo: should it be DC controller pulling?
     setEtbWastegatePosition(boostOutput);
 #endif // EFI_ELECTRONIC_THROTTLE_BODY
 }

Referenced by onFastCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ m_closedLoopTargetMap

const ValueProvider3D* BoostController::m_closedLoopTargetMap = nullptr

private

Definition at line 42 of file boost_control.h.

Referenced by getSetpoint(), and init().

◆ m_openLoopMap

const ValueProvider3D* BoostController::m_openLoopMap = nullptr

private

Definition at line 41 of file boost_control.h.

Referenced by getOpenLoop(), and init().

◆ m_pid

Pid BoostController::m_pid

private

Definition at line 39 of file boost_control.h.

Referenced by getClosedLoop(), getClosedLoopImpl(), init(), onConfigurationChange(), and onFastCallback().

◆ m_pwm

IPwm* BoostController::m_pwm = nullptr

private

Definition at line 43 of file boost_control.h.

Referenced by init(), and setOutput().

The documentation for this class was generated from the following files:

controllers/actuators/boost_control.h
controllers/actuators/boost_control.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ getClosedLoop()

◆ getClosedLoopImpl()

◆ getOpenLoop()

◆ getSetpoint()

◆ init()

◆ observePlant()

◆ onConfigurationChange()

◆ onFastCallback()

◆ resetLua()

◆ setOutput()

Field Documentation

◆ m_closedLoopTargetMap

◆ m_openLoopMap

◆ m_pid

◆ m_pwm