#include <electronic_throttle_impl.h>

Inheritance diagram for EtbController:

[legend]

Collaboration diagram for EtbController:

[legend]

Public Member Functions
bool	init (dc_function_e function, DcMotor motor, pid_s pidParameters, const ValueProvider3D *pedalMap) override

void	setIdlePosition (percent_t pos) override

void	setWastegatePosition (percent_t pos) override

void	reset (const char *reason) override

void	update () override

void	onConfigurationChange (pid_s *previousConfiguration)

void	showStatus ()

expected< percent_t >	observePlant () override

expected< percent_t >	getSetpoint () override

expected< percent_t >	getSetpointEtb ()

expected< percent_t >	getSetpointWastegate () const

expected< percent_t >	getSetpointIdleValve () const

expected< percent_t >	getOpenLoop (percent_t target) override

expected< percent_t >	getClosedLoop (percent_t setpoint, percent_t observation) override

expected< percent_t >	getClosedLoopAutotune (percent_t setpoint, percent_t actualThrottlePosition)

dc_function_e	getFunction () const

void	checkJam (percent_t setpoint, percent_t observation)

void	setOutput (expected< percent_t > outputValue) override

const pid_state_s &	getPidState () const override

virtual percent_t	getThrottleTrim (float, percent_t) const

float	getCurrentTarget () const override

bool	isEtbMode () const override

void	setLuaAdjustment (percent_t adjustment) override

float	getLuaAdjustment () const

Public Member Functions inherited from IEtbController
virtual void	autoCalibrateTps (bool reportToTs=true)

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

Data Fields
float	prevOutput = 0

Data Fields inherited from electronic_throttle_s
float	targetWithIdlePosition = (float)0

float	trim = (float)0

float	boardEtbAdjustment = (float)0

float	luaAdjustment = (float)0

float	m_wastegatePosition = (float)0

float	m_lastPidDtMs = (float)0

percent_t	etbFeedForward = (percent_t)0

float	integralError = (float)0

float	etbCurrentTarget = (float)0

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

uint8_t	alignmentFill_at_38 [2] = {}

bool	etbRevLimitActive: 1 {}

bool	jamDetected: 1 {}

bool	validPlantPosition: 1 {}

bool	unusedBit_14_3: 1 {}

bool	unusedBit_14_4: 1 {}

bool	unusedBit_14_5: 1 {}

bool	unusedBit_14_6: 1 {}

bool	unusedBit_14_7: 1 {}

bool	unusedBit_14_8: 1 {}

bool	unusedBit_14_9: 1 {}

bool	unusedBit_14_10: 1 {}

bool	unusedBit_14_11: 1 {}

bool	unusedBit_14_12: 1 {}

bool	unusedBit_14_13: 1 {}

bool	unusedBit_14_14: 1 {}

bool	unusedBit_14_15: 1 {}

bool	unusedBit_14_16: 1 {}

bool	unusedBit_14_17: 1 {}

bool	unusedBit_14_18: 1 {}

bool	unusedBit_14_19: 1 {}

bool	unusedBit_14_20: 1 {}

bool	unusedBit_14_21: 1 {}

bool	unusedBit_14_22: 1 {}

bool	unusedBit_14_23: 1 {}

bool	unusedBit_14_24: 1 {}

bool	unusedBit_14_25: 1 {}

bool	unusedBit_14_26: 1 {}

bool	unusedBit_14_27: 1 {}

bool	unusedBit_14_28: 1 {}

bool	unusedBit_14_29: 1 {}

bool	unusedBit_14_30: 1 {}

bool	unusedBit_14_31: 1 {}

uint16_t	etbTpsErrorCounter = (uint16_t)0

uint16_t	etbPpsErrorCounter = (uint16_t)0

int8_t	etbErrorCode = (int8_t)0

int8_t	etbErrorCodeBlinker = (int8_t)0

int8_t	tcEtbDrop = (int8_t)0

uint8_t	alignmentFill_at_51 [1] = {}

scaled_channel< uint16_t, 100, 1 >	jamTimer = (uint16_t)0

int8_t	adjustedEtbTarget = (int8_t)0

uint8_t	state = (uint8_t)0

Protected Member Functions
DcMotor *	getMotor ()

Protected Attributes
bool	hadTpsError = false

bool	hadPpsError = false

Private Member Functions
bool	checkStatus ()

Private Attributes
dc_function_e	m_function = DC_None

SensorType	m_positionSensor = SensorType::Invalid

DcMotor *	m_motor = nullptr

Pid	m_pid

bool	m_shouldResetPid = false

ErrorAccumulator	m_targetErrorAccumulator

Timer	m_jamDetectTimer

const ValueProvider3D *	m_pedalProvider = nullptr

float	m_idlePosition = 0

bool	m_isAutotune = false

bool	m_lastIsPositive = false

Timer	m_cycleTimer

float	m_minCycleTps = 0

float	m_maxCycleTps = 0

float	m_a = 8

float	m_tu = 0.1f

uint8_t	m_autotuneCounter = 0

uint8_t	m_autotuneCurrentParam = 0

Timer	m_luaAdjustmentTimer

efitimeus_t	lastTickUs

Detailed Description

Definition at line 28 of file electronic_throttle_impl.h.

Member Function Documentation

◆ checkJam()

void EtbController::checkJam	(	percent_t	setpoint,
		percent_t	observation
	)

Definition at line 690 of file electronic_throttle.cpp.

                                                                      {
    float absError = std::abs(setpoint - observation);
 
    auto jamDetectThreshold = engineConfiguration->etbJamDetectThreshold;
    auto jamTimeout = engineConfiguration->etbJamTimeout;
 
    if (jamDetectThreshold != 0 && jamTimeout != 0) {
        auto nowNt = getTimeNowNt();
 
        if (absError > jamDetectThreshold && engine->module<IgnitionController>()->getIgnState()) {
            if (m_jamDetectTimer.hasElapsedSec(jamTimeout)) {
                efiPrintf(" ************* ETB is jammed! ***************");
                jamDetected = true;
 
                getLimpManager()->reportEtbProblem();
            }
        } else {
            m_jamDetectTimer.reset(nowNt);
            jamDetected = false;
        }
 
        jamTimer = m_jamDetectTimer.getElapsedSeconds(nowNt);
    }
}

Referenced by getClosedLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkStatus()

bool EtbController::checkStatus ( )

private

Returns: true if OK, false if should be disabled

Definition at line 593 of file electronic_throttle.cpp.

                                {
#if EFI_TUNER_STUDIO
    // Only debug throttle #1
    if (m_function == DC_Throttle1) {
        m_pid.postState(engine->outputChannels.etbStatus);
    } else if (m_function == DC_Wastegate) {
        m_pid.postState(engine->outputChannels.wastegateDcStatus);
    }
#endif /* EFI_TUNER_STUDIO */
 
    if (!isEtbMode()) {
        // no validation for h-bridge or idle mode
        return true;
    }
    // ETB-specific code belo. The whole mix-up between DC and ETB is shameful :(
 
    // Only allow autotune with stopped engine, and on the first throttle
    // Update local state about autotune
    m_isAutotune = Sensor::getOrZero(SensorType::Rpm) == 0
        && engine->etbAutoTune
        && m_function == DC_Throttle1;
 
    bool shouldCheckSensorFunction = engine->module<SensorChecker>()->analogSensorsShouldWork();
 
    if (!m_isAutotune && shouldCheckSensorFunction) {
        bool isTpsError = !Sensor::get(m_positionSensor).Valid;
 
        // If we have an error that's new, increment the counter
        if (isTpsError && !hadTpsError) {
            etbTpsErrorCounter++;
        }
 
        hadTpsError = isTpsError;
 
        bool isPpsError = !Sensor::get(SensorType::AcceleratorPedal).Valid;
 
        // If we have an error that's new, increment the counter
        if (isPpsError && !hadPpsError) {
            etbPpsErrorCounter++;
        }
 
        hadPpsError = isPpsError;
    } else {
        // Either sensors are expected to not work, or autotune is running, so reset the error counter
        etbTpsErrorCounter = 0;
        etbPpsErrorCounter = 0;
    }
 
    EtbStatus localReason = EtbStatus::None;
    if (etbTpsErrorCounter > ETB_INTERMITTENT_LIMIT) {
        localReason = EtbStatus::IntermittentTps;
#if EFI_SHAFT_POSITION_INPUT
    } else if (engineConfiguration->disableEtbWhenEngineStopped
      && !engine->triggerCentral.engineMovedRecently()
      && !engine->etbAutoTune) {
        localReason = EtbStatus::EngineStopped;
#endif // EFI_SHAFT_POSITION_INPUT
    } else if (etbPpsErrorCounter > ETB_INTERMITTENT_LIMIT) {
        localReason = EtbStatus::IntermittentPps;
    } else if (engine->engineState.lua.luaDisableEtb) {
        localReason = EtbStatus::Lua;
    } else if (!getLimpManager()->allowElectronicThrottle()) {
        localReason = EtbStatus::JamDetected;
    } else if(!isBoardAllowingLackOfPps() && !Sensor::isRedundant(SensorType::AcceleratorPedal)) {
        localReason = EtbStatus::Redundancy;
    }
 
    etbErrorCode = (int8_t)localReason;
 
    return localReason == EtbStatus::None;
}

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getClosedLoop()

expected< percent_t > EtbController::getClosedLoop	(	percent_t	setpoint,
		percent_t	observation
	)

overridevirtual

Implements ClosedLoopController< percent_t, percent_t >.

Definition at line 525 of file electronic_throttle.cpp.

                                                                                        {
    if (m_shouldResetPid) {
        m_pid.reset();
        onTransitionEvent(TransitionEvent::EtbPidReset);
        m_shouldResetPid = false;
    }
 
    if (m_isAutotune) {
        state = (uint8_t)EtbState::Autotune;
 
        m_targetErrorAccumulator.reset();
 
        return getClosedLoopAutotune(target, observation);
    } else {
        checkJam(target, observation);
 
        integralError = m_targetErrorAccumulator.accumulate(target - observation);
 
        float dt = m_cycleTimer.getElapsedSecondsAndReset(getTimeNowNt());
        m_lastPidDtMs = dt * 1000.0;
 
        // Normal case - use PID to compute closed loop part
        return m_pid.getOutput(target, observation, dt);
    }
}

Here is the call graph for this function:

◆ getClosedLoopAutotune()

expected< percent_t > EtbController::getClosedLoopAutotune	(	percent_t	setpoint,
		percent_t	actualThrottlePosition
	)

Definition at line 430 of file electronic_throttle.cpp.

                                                                                                           {
    // Estimate gain at current position - this should be well away from the spring and in the linear region
    // GetSetpoint sets this to 50%
    bool isPositive = actualThrottlePosition > target;
 
    float autotuneAmplitude = 20;
 
    // End of cycle - record & reset
    if (!isPositive && m_lastIsPositive) {
        // Determine period
        float tu = m_cycleTimer.getElapsedSecondsAndReset(getTimeNowNt());
 
        // Determine amplitude
        float a = m_maxCycleTps - m_minCycleTps;
 
        // Filter - it's pretty noisy since the ultimate period is not very many loop periods
        constexpr float alpha = 0.05;
        m_a  = alpha * a  + (1 - alpha) * m_a;
        m_tu = alpha * tu + (1 - alpha) * m_tu;
 
        // Reset bounds
        m_minCycleTps = 100;
        m_maxCycleTps = 0;
 
        // Math is for Åström–Hägglund (relay) auto tuning
        // https://warwick.ac.uk/fac/cross_fac/iatl/reinvention/archive/volume5issue2/hornsey
 
        // Amplitude of input (duty cycle %)
        float b = 2 * autotuneAmplitude;
 
        // Ultimate gain per A-H relay tuning rule
        float ku = 4 * b / (CONST_PI * m_a);
 
        // The multipliers below are somewhere near the "no overshoot"
        // and "some overshoot" flavors of the Ziegler-Nichols method
        // Kp
        float kp = 0.35f * ku;
        float ki = 0.25f * ku / m_tu;
        float kd = 0.08f * ku * m_tu;
 
        // Publish to TS state
#if EFI_TUNER_STUDIO
        // Every 5 cycles (of the throttle), cycle to the next value
        if (m_autotuneCounter >= 5) {
            m_autotuneCounter = 0;
            m_autotuneCurrentParam = (m_autotuneCurrentParam + 1) % 3; // three ETB calibs: P-I-D
        }
 
        m_autotuneCounter++;
 
        switch (m_autotuneCurrentParam) {
        case 0:
            tsCalibrationSetData(TsCalMode::EtbKp, kp);
            break;
        case 1:
            tsCalibrationSetData(TsCalMode::EtbKi, ki);
            break;
        case 2:
            tsCalibrationSetData(TsCalMode::EtbKd, kd);
            break;
        }
 
        // Also output to debug channels if configured
        if (engineConfiguration->debugMode == DBG_ETB_AUTOTUNE) {
            // a - amplitude of output (TPS %)
            engine->outputChannels.debugFloatField1 = m_a;
            // b - amplitude of input (Duty cycle %)
            engine->outputChannels.debugFloatField2 = b;
            // Tu - oscillation period (seconds)
            engine->outputChannels.debugFloatField3 = m_tu;
 
            engine->outputChannels.debugFloatField4 = ku;
            engine->outputChannels.debugFloatField5 = kp;
            engine->outputChannels.debugFloatField6 = ki;
            engine->outputChannels.debugFloatField7 = kd;
        }
#endif
        // TODO: directly update PID settings in engineConfiguration
    }
 
    m_lastIsPositive = isPositive;
 
    // Find the min/max of each cycle
    if (actualThrottlePosition < m_minCycleTps) {
        m_minCycleTps = actualThrottlePosition;
    }
 
    if (actualThrottlePosition > m_maxCycleTps) {
        m_maxCycleTps = actualThrottlePosition;
    }
 
    // Bang-bang control the output to induce oscillation
    return autotuneAmplitude * (isPositive ? -1 : 1);
}

Referenced by getClosedLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCurrentTarget()

float EtbController::getCurrentTarget ( ) const

inlineoverridevirtual

Implements IEtbController.

Definition at line 72 of file electronic_throttle_impl.h.

                                          {
    return etbCurrentTarget;
  }

◆ getFunction()

dc_function_e EtbController::getFunction ( ) const

inline

Definition at line 57 of file electronic_throttle_impl.h.

57{ return m_function; }

◆ getLuaAdjustment()

float EtbController::getLuaAdjustment ( ) const

positive adjustment opens TPS, negative closes TPS

Definition at line 392 of file electronic_throttle.cpp.

                                            {
    // If the lua position hasn't been set in 0.2 second, don't adjust!
    // This avoids a stuck throttle due to hung/rogue/etc Lua script
    if (m_luaAdjustmentTimer.getElapsedSeconds() > 0.2f) {
        return 0;
    } else {
        return luaAdjustment;
    }
}

Referenced by getSetpointEtb(), and getSetpointWastegate().

Here is the caller graph for this function:

◆ getMotor()

DcMotor * EtbController::getMotor ( )

inlineprotected

Definition at line 90 of file electronic_throttle_impl.h.

90{ return m_motor; }

EtbController::m_motor

DcMotor * m_motor

Definition electronic_throttle_impl.h:95

◆ getOpenLoop()

expected< percent_t > EtbController::getOpenLoop ( percent_t target )

overridevirtual

Implements ClosedLoopController< percent_t, percent_t >.

Definition at line 406 of file electronic_throttle.cpp.

                                                               {
    // Don't apply open loop for idle valve, only real ETB or wastegate
    switch(m_function){
        case DC_Throttle1:
        case DC_Throttle2: {
            etbFeedForward = interpolate2d(target, config->etbBiasBins, config->etbBiasValues);
            break;
        }
        case DC_Wastegate: {
            etbFeedForward = interpolate2d(target, config->dcWastegateBiasBins, config->dcWastegateBiasValues);
            break;
        }
        case DC_IdleValve: {
            etbFeedForward = 0;
            break;
        }
        default: { // or DC_None
            etbFeedForward = 0;
        }
    }
 
    return etbFeedForward;
}

◆ getPidState()

const pid_state_s & EtbController::getPidState ( ) const

inlineoverridevirtual

Implements IEtbController.

Definition at line 64 of file electronic_throttle_impl.h.

64{ return m_pid; };

◆ getSetpoint()

expected< percent_t > EtbController::getSetpoint ( )

overridevirtual

Implements ClosedLoopController< percent_t, percent_t >.

Definition at line 262 of file electronic_throttle.cpp.

                                               {
    switch (m_function) {
        case DC_Throttle1:
        case DC_Throttle2:
            return getSetpointEtb();
        case DC_IdleValve:
            return getSetpointIdleValve();
        case DC_Wastegate:
            return getSetpointWastegate();
        default:
            return unexpected;
    }
}

Here is the call graph for this function:

◆ getSetpointEtb()

expected< percent_t > EtbController::getSetpointEtb ( )

Definition at line 303 of file electronic_throttle.cpp.

                                                  {
    // Autotune runs with 50% target position
    if (m_isAutotune) {
        return 50.0f;
    }
 
//  // A few extra preconditions if throttle control is invalid
//  if (startupPositionError) {
//      return unexpected;
//  }
 
    // If the pedal map hasn't been set, we can't provide a setpoint.
    if (!m_pedalProvider) {
    state = (uint8_t)EtbState::NoPedal;
        return unexpected;
    }
 
    float sanitizedPedal = getSanitizedPedal();
 
    float rpm = Sensor::getOrZero(SensorType::Rpm);
  percent_t preBoard = m_pedalProvider->getValue(rpm, sanitizedPedal);
    etbCurrentTarget = boardAdjustEtbTarget(preBoard);
    boardEtbAdjustment = etbCurrentTarget - preBoard;
 
    percent_t etbIdlePosition = clampPercentValue(m_idlePosition);
    percent_t etbIdleAddition = PERCENT_DIV * engineConfiguration->etbIdleThrottleRange * etbIdlePosition;
 
    // Interpolate so that the idle adder just "compresses" the throttle's range upward.
    // [0, 100] -> [idle, 100]
    // 0% target from table -> idle position as target
    // 100% target from table -> 100% target position
    targetWithIdlePosition = interpolateClamped(0, etbIdleAddition, 100, 100, etbCurrentTarget);
 
    percent_t targetPosition = targetWithIdlePosition + getLuaAdjustment();
    // just an additional logging data point
    adjustedEtbTarget = targetPosition;
 
#if EFI_ANTILAG_SYSTEM
    if (engine->antilagController.isAntilagCondition) {
        targetPosition += engineConfiguration->ALSEtbAdd;
    }
#endif /* EFI_ANTILAG_SYSTEM */
 
  float vehicleSpeed = Sensor::getOrZero(SensorType::VehicleSpeed);
  float wheelSlip = Sensor::getOrZero(SensorType::WheelSlipRatio);
  tcEtbDrop = tcEtbDropTable.getValue(wheelSlip, vehicleSpeed);
 
    // Apply any adjustment that this throttle alone needs
    // Clamped to +-10 to prevent anything too wild
    trim = clampF(-10, getThrottleTrim(rpm, targetPosition), 10);
    targetPosition += trim + tcEtbDrop;
 
    // Clamp before rev limiter to avoid ineffective rev limit due to crazy out of range position target
    targetPosition = clampPercentValue(targetPosition);
 
    // Lastly, apply ETB rev limiter
    auto etbRpmLimit = engineConfiguration->etbRevLimitStart;
    if (etbRpmLimit != 0) {
        auto fullyLimitedRpm = etbRpmLimit + engineConfiguration->etbRevLimitRange;
 
        float targetPositionBefore = targetPosition;
        // Linearly taper throttle to closed from the limit across the range
        targetPosition = interpolateClamped(etbRpmLimit, targetPosition, fullyLimitedRpm, 0, rpm);
 
        // rev limit active if the position was changed by rev limiter
        etbRevLimitActive = std::abs(targetPosition - targetPositionBefore) > 0.1f;
    }
 
    float minPosition = engineConfiguration->etbMinimumPosition;
 
    // Keep the throttle just barely off the lower stop, and less than the user-configured maximum
    float maxPosition = engineConfiguration->etbMaximumPosition;
    // Don't allow max position over 100
    maxPosition = std::min(maxPosition, 100.0f);
 
    targetPosition = clampF(minPosition, targetPosition, maxPosition);
    m_adjustedTarget = targetPosition;
 
    return targetPosition;
}

Referenced by getSetpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSetpointIdleValve()

expected< percent_t > EtbController::getSetpointIdleValve ( ) const

Definition at line 276 of file electronic_throttle.cpp.

                                                              {
    // VW ETB idle mode uses an ETB only for idle (a mini-ETB sets the lower stop, and a normal cable
    // can pull the throttle up off the stop.), so we directly control the throttle with the idle position.
#if EFI_TUNER_STUDIO && (EFI_PROD_CODE || EFI_SIMULATOR)
    // todo: where do we want to log this? engine->outputChannels.etbTarget = m_idlePosition;
#endif // EFI_TUNER_STUDIO
    return clampPercentValue(m_idlePosition);
}

Referenced by getSetpoint().

Here is the caller graph for this function:

◆ getSetpointWastegate()

expected< percent_t > EtbController::getSetpointWastegate ( ) const

Definition at line 285 of file electronic_throttle.cpp.

                                                              {
    percent_t targetPosition = m_wastegatePosition + getLuaAdjustment();
 
    return clampPercentValue(targetPosition);
}

Referenced by getSetpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getThrottleTrim()

virtual percent_t EtbController::getThrottleTrim	(	float	,
		percent_t
	)		const

inlinevirtual

Reimplemented in EtbController2.

Definition at line 67 of file electronic_throttle_impl.h.

                                                                  {
        return 0;
    }

Referenced by getSetpointEtb().

Here is the caller graph for this function:

◆ init()

bool EtbController::init	(	dc_function_e	function,
		DcMotor *	motor,
		pid_s *	pidParameters,
		const ValueProvider3D *	pedalMap
	)

overridevirtual

Implements IEtbController.

Definition at line 170 of file electronic_throttle.cpp.

                                                                                                                           {
    state = (uint8_t)EtbState::InInit;
    if (function == DC_None) {
        // if not configured, don't init.
        state = (uint8_t)EtbState::NotEbt;
        etbErrorCode = (int8_t)EtbStatus::NotConfigured;
        return false;
    }
 
    m_function = function;
    m_positionSensor = functionToPositionSensor(function);
 
    // If we are a throttle, require redundant TPS sensor
    if (isEtbMode()) {
        // If no sensor is configured for this throttle, skip initialization.
        if (!Sensor::hasSensor(functionToTpsSensor(function))) {
            etbErrorCode = (int8_t)EtbStatus::TpsError;
            return false;
        }
 
        if (!isBoardAllowingLackOfPps() && !Sensor::isRedundant(m_positionSensor)) {
            etbErrorCode = (int8_t)EtbStatus::Redundancy;
            return false;
        }
    }
 
    m_motor = motor;
    m_pedalProvider = pedalProvider;
 
    m_pid.initPidClass(pidParameters);
 
#if !EFI_UNIT_TEST
    if (isEtbMode()) {
        m_pid.iTermMin = engineConfiguration->etb_iTermMin;
        m_pid.iTermMax = engineConfiguration->etb_iTermMax;
    } else {
        // Some defaults from setDefaultEtbParameters(), find better values for EWG and Idle or add config options
        m_pid.iTermMin = -30;
        m_pid.iTermMax = 30;
    }
#endif
 
    // Ignore 3% position error before complaining
    m_targetErrorAccumulator.init(3.0f, etbPeriodSeconds);
 
    state = (uint8_t)EtbState::SuccessfulInit;
    return true;
}

Here is the call graph for this function:

◆ isEtbMode()

bool EtbController::isEtbMode ( ) const

inlineoverridevirtual

Implements IEtbController.

Definition at line 76 of file electronic_throttle_impl.h.

                                    {
        return m_function == DC_Throttle1 || m_function == DC_Throttle2;
    }

Referenced by checkStatus(), init(), setOutput(), and update().

Here is the caller graph for this function:

◆ observePlant()

expected< percent_t > EtbController::observePlant ( )

overridevirtual

Implements ClosedLoopController< percent_t, percent_t >.

Definition at line 248 of file electronic_throttle.cpp.

                                                {
    expected<percent_t> plant = Sensor::get(m_positionSensor);
    validPlantPosition = plant.Valid;
    return plant;
}

Here is the call graph for this function:

◆ onConfigurationChange()

void EtbController::onConfigurationChange ( pid_s * previousConfiguration )

Definition at line 235 of file electronic_throttle.cpp.

                                                                      {
    if (m_motor && !m_pid.isSame(previousConfiguration)) {
      efiPrintf(" ETB m_shouldResetPid");
        m_shouldResetPid = true;
    }
 
    doInitElectronicThrottle(/*isStartupInit*/false);
}

Referenced by onConfigurationChangeElectronicThrottleCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

void EtbController::reset ( const char * reason )

overridevirtual

Implements IEtbController.

Definition at line 223 of file electronic_throttle.cpp.

                                            {
    efiPrintf("ETB reset %s", reason);
    m_shouldResetPid = true;
    etbTpsErrorCounter = 0;
    etbPpsErrorCounter = 0;
#if EFI_UNIT_TEST
    ebtResetCounter++;
#endif // EFI_UNIT_TEST
 
}

◆ setIdlePosition()

void EtbController::setIdlePosition ( percent_t pos )

overridevirtual

Implements IEtbController.

Definition at line 254 of file electronic_throttle.cpp.

                                                 {
    m_idlePosition = pos;
}

◆ setLuaAdjustment()

void EtbController::setLuaAdjustment ( percent_t adjustment )

overridevirtual

Implements IEtbController.

Definition at line 384 of file electronic_throttle.cpp.

                                                     {
    luaAdjustment = adjustment;
    m_luaAdjustmentTimer.reset();
}

◆ setOutput()

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

overridevirtual

Implements ClosedLoopController< percent_t, percent_t >.

Definition at line 551 of file electronic_throttle.cpp.

                                                             {
#if EFI_TUNER_STUDIO
    // Only report first-throttle stats
    if (m_function == DC_Throttle1) {
        engine->outputChannels.etb1DutyCycle = outputValue.value_or(0);
    }
#endif
 
    if (!m_motor) {
        state = (uint8_t)EtbState::NoMotor;
        return;
    }
 
    bool isEnabled;
    if (!isEtbMode()) {
      // technical debt: non-ETB usages of DC motor are still mixed into ETB controller?
        state = (uint8_t)EtbState::NotEbt;
        isEnabled = true;
    } else if (!getLimpManager()->allowElectronicThrottle()) {
        state = (uint8_t)EtbState::LimpProhibited;
        isEnabled = false;
    } else if (engineConfiguration->pauseEtbControl) {
        state = (uint8_t)EtbState::Paused;
        isEnabled = false;
    } else if (!outputValue) {
        state = (uint8_t)EtbState::NoOutput;
        isEnabled = false;
    } else {
        state = (uint8_t)EtbState::Active;
        isEnabled = true;
    }
 
    // If not ETB, or ETB is allowed, output is valid, and we aren't paused, output to motor.
    if (isEnabled) {
        m_motor->enable();
        m_motor->set(ETB_PERCENT_TO_DUTY(outputValue.Value));
    } else {
        // Otherwise disable the motor.
        m_motor->disable("no-ETB");
    }
}

Here is the call graph for this function:

◆ setWastegatePosition()

void EtbController::setWastegatePosition ( percent_t pos )

overridevirtual

Implements IEtbController.

Definition at line 258 of file electronic_throttle.cpp.

                                                      {
    m_wastegatePosition = pos;
}

◆ showStatus()

void EtbController::showStatus ( )

Definition at line 244 of file electronic_throttle.cpp.

                               {
    m_pid.showPidStatus("ETB");
}

Here is the call graph for this function:

◆ update()

void EtbController::update ( )

overridevirtual

Implements IEtbController.

Definition at line 665 of file electronic_throttle.cpp.

                           {
#if !EFI_UNIT_TEST
    // If we didn't get initialized, fail fast
    if (!m_motor) {
        state = (uint8_t)EtbState::FailFast;
        return;
    }
#endif // EFI_UNIT_TEST
 
    bool isOk = checkStatus();
 
    if (!isOk) {
        // If engine is stopped and so configured, skip the ETB update entirely
        // This is quieter and pulls less power than leaving it on all the time
        m_motor->disable("etb status");
        return;
    }
 
    ClosedLoopController::update();
 
    if (isEtbMode() && !validPlantPosition) {
        etbErrorCode = (int8_t)EtbStatus::TpsError;
    }
}