VvtController Class Reference

#include <vvt.h>

Inheritance diagram for VvtController:

Collaboration diagram for VvtController:

Public Member Functions
	VvtController (int index)
void	init (const ValueProvider3D *targetMap, IPwm *pwm)
void	onFastCallback () override
void	onConfigurationChange (engine_configuration_s const *previousConfig) override
expected< angle_t >	observePlant () override
expected< angle_t >	getSetpoint () override
expected< percent_t >	getOpenLoop (angle_t target) override
expected< percent_t >	getClosedLoop (angle_t setpoint, angle_t observation) override
void	setOutput (expected< percent_t > outputValue) override
uint8_t	getCamIndex ()
Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()
virtual void	setDefaultConfiguration ()
virtual void	onSlowCallback ()
virtual void	onEngineStop ()
virtual void	onIgnitionStateChanged (bool)
virtual bool	needsDelayedShutoff ()
virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)
Public Member Functions inherited from ClosedLoopController< angle_t, percent_t >
void	update ()

Private Attributes
const int	index
const uint8_t	m_bank
const uint8_t	m_cam
Pid	m_pid
bool	m_engineRunningLongEnough = false
bool	m_isRpmHighEnough = false
bool	m_isCltWarmEnough = false
const ValueProvider3D *	m_targetMap = nullptr
IPwm *	m_pwm = nullptr

Additional Inherited Members
Data Fields inherited from vvt_s
scaled_channel< int16_t, 10, 1 >	vvtTarget = (int16_t)0
scaled_channel< uint8_t, 2, 1 >	vvtOutput = (uint8_t)0
uint8_t	alignmentFill_at_3 [1] = {}

Detailed Description

Definition at line 26 of file vvt.h.

Constructor & Destructor Documentation

VvtController()

VvtController::VvtController

(

int

index

)

Definition at line 20 of file vvt.cpp.

    : index(p_index)
    , m_bank(BANK_BY_INDEX(p_index))
    , m_cam(CAM_BY_INDEX(p_index))
{
}

Member Function Documentation

getCamIndex()

uint8_t VvtController::getCamIndex ( )

inline

Definition at line 44 of file vvt.h.

                          {
        return m_cam;
    }

getClosedLoop()

expected< percent_t > VvtController::getClosedLoop ( angle_t  setpoint, angle_t  observation  )

overridevirtual

Implements ClosedLoopController< angle_t, percent_t >.

Definition at line 104 of file vvt.cpp.

                                                                                    {
    // User labels say "advance" and "retard"
    // "advance" means that additional solenoid duty makes indicated VVT position more positive
    // "retard" means that additional solenoid duty makes indicated VVT position more negative
    bool isInverted = shouldInvertVvt(m_cam);
    m_pid.setErrorAmplification(isInverted ? -1.0f : 1.0f);
 
    float retVal = m_pid.getOutput(target, observation);
 
#if EFI_TUNER_STUDIO
    m_pid.postState(engine->outputChannels.vvtStatus[index]);
#endif /* EFI_TUNER_STUDIO */
 
    return retVal;
}

Here is the call graph for this function:

getOpenLoop()

expected< percent_t > VvtController::getOpenLoop ( angle_t  target )

overridevirtual

Implements ClosedLoopController< angle_t, percent_t >.

Definition at line 88 of file vvt.cpp.

                                                             {
    // TODO: could we do VVT open loop?
    UNUSED(target);
    return 0;
}

Here is the call graph for this function:

getSetpoint()

expected< angle_t > VvtController::getSetpoint ( )

overridevirtual

Implements ClosedLoopController< angle_t, percent_t >.

Definition at line 64 of file vvt.cpp.

                                             {
    float rpm = Sensor::getOrZero(SensorType::Rpm);
    bool enabled = m_engineRunningLongEnough &&
#if EFI_PROD_CODE || EFI_UNIT_TEST
// simulator functional test does not have CLT or flag?
                        m_isCltWarmEnough &&
#endif
                        m_isRpmHighEnough;
    if (!enabled) {
        return unexpected;
    }
 
    float load = getFuelingLoad();
    float target = m_targetMap->getValue(rpm, load);
 
#if EFI_TUNER_STUDIO
    engine->outputChannels.vvtTargets[index] = target;
#endif
 
    vvtTarget = target;
 
    return target;
}

Here is the call graph for this function:

init()

void VvtController::init	(	const ValueProvider3D *	targetMap,
		IPwm *	pwm
	)

Definition at line 27 of file vvt.cpp.

                                                                    {
    // Use the same settings for the Nth cam in every bank (ie, all exhaust cams use the same PID)
    m_pid.initPidClass(&engineConfiguration->auxPid[m_cam]);
 
    m_targetMap = targetMap;
    m_pwm = pwm;
}

Here is the call graph for this function:

observePlant()

expected< angle_t > VvtController::observePlant ( )

overridevirtual

Implements ClosedLoopController< angle_t, percent_t >.

Definition at line 56 of file vvt.cpp.

                                              {
#if EFI_SHAFT_POSITION_INPUT
    return engine->triggerCentral.getVVTPosition(m_bank, m_cam);
#else
    return unexpected;
#endif // EFI_SHAFT_POSITION_INPUT
}

Here is the call graph for this function:

onConfigurationChange()

void VvtController::onConfigurationChange ( engine_configuration_s const *  previousConfig )

overridevirtual

Reimplemented from EngineModule.

Definition at line 50 of file vvt.cpp.

                                                                                       {
    if (!previousConfig || !m_pid.isSame(&previousConfig->auxPid[m_cam])) {
        m_pid.reset();
    }
}

Here is the call graph for this function:

onFastCallback()

void VvtController::onFastCallback ( )

overridevirtual

Reimplemented from EngineModule.

Definition at line 35 of file vvt.cpp.

                                   {
    if (!m_pwm || !m_targetMap) {
        // not init yet
        return;
    }
 
    m_isRpmHighEnough = Sensor::getOrZero(SensorType::Rpm) > engineConfiguration->vvtControlMinRpm;
    m_isCltWarmEnough = Sensor::getOrZero(SensorType::Clt) > engineConfiguration->vvtControlMinClt;
 
    auto nowNt = getTimeNowNt();
    m_engineRunningLongEnough = engine->rpmCalculator.getSecondsSinceEngineStart(nowNt) > engineConfiguration->vvtActivationDelayMs / MS_PER_SECOND;
 
    update();
}

Here is the call graph for this function:

setOutput()

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

overridevirtual

Implements ClosedLoopController< angle_t, percent_t >.

Definition at line 120 of file vvt.cpp.

                                                             {
#if EFI_SHAFT_POSITION_INPUT
    vvtOutput = outputValue.value_or(0);
 
    if (outputValue) {
        m_pwm->setSimplePwmDutyCycle(PERCENT_TO_DUTY(outputValue.Value));
    } else {
        m_pwm->setSimplePwmDutyCycle(0);
 
        // we need to avoid accumulating iTerm while engine is not running
        m_pid.reset();
    }
#endif // EFI_SHAFT_POSITION_INPUT
}

Here is the call graph for this function:

Field Documentation

index

const int VvtController::index

private

Definition at line 49 of file vvt.h.

Referenced by getClosedLoop(), getSetpoint(), init(), observePlant(), onConfigurationChange(), onFastCallback(), and setOutput().

m_bank

const uint8_t VvtController::m_bank

private

Definition at line 51 of file vvt.h.

Referenced by observePlant().

m_cam

const uint8_t VvtController::m_cam

private

Definition at line 53 of file vvt.h.

Referenced by getCamIndex(), getClosedLoop(), init(), observePlant(), and onConfigurationChange().

m_engineRunningLongEnough

bool VvtController::m_engineRunningLongEnough = false

private

Definition at line 58 of file vvt.h.

Referenced by getSetpoint(), and onFastCallback().

m_isCltWarmEnough

bool VvtController::m_isCltWarmEnough = false

private

Definition at line 60 of file vvt.h.

Referenced by getSetpoint(), and onFastCallback().

m_isRpmHighEnough

bool VvtController::m_isRpmHighEnough = false

private

Definition at line 59 of file vvt.h.

Referenced by getSetpoint(), and onFastCallback().

m_pid

Pid VvtController::m_pid

private

Definition at line 55 of file vvt.h.

Referenced by getClosedLoop(), init(), onConfigurationChange(), and setOutput().

m_pwm

IPwm* VvtController::m_pwm = nullptr

private

Definition at line 63 of file vvt.h.

Referenced by init(), onFastCallback(), and setOutput().

m_targetMap

const ValueProvider3D* VvtController::m_targetMap = nullptr

private

Definition at line 62 of file vvt.h.

Referenced by getSetpoint(), init(), and onFastCallback().

---

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

• controllers/actuators/vvt.h
• controllers/actuators/vvt.cpp