#include <electronic_throttle_impl.h>

Inheritance diagram for EtbImpl< TBase >:

Collaboration diagram for EtbImpl< TBase >:

[legend]

Public Member Functions
template<typename... TArgs>
	EtbImpl (TArgs &&... args)

void	update () override

void	autoCalibrateTps (bool reportToTs) override

ACPhase	doAutocal (ACPhase phase)

Private Types
enum class	ACPhase { Stopped , Start , Open , Close , TransmitPrimaryMax , TransmitPrimaryMin , TransmitSecondaryMax , TransmitSecondaryMin }

Private Attributes
ACPhase	m_autocalPhase = ACPhase::Stopped

Timer	m_autocalTimer

bool	m_isAutocalTs

float	m_primaryMax

float	m_secondaryMax

float	m_primaryMin

float	m_secondaryMin

Detailed Description

template<typename TBase>
class EtbImpl< TBase >

Definition at line 155 of file electronic_throttle_impl.h.

Member Enumeration Documentation

◆ ACPhase

template<typename TBase >

enum class EtbImpl::ACPhase

strongprivate

Enumerator
Stopped
Start
Open
Close
TransmitPrimaryMax
TransmitPrimaryMin
TransmitSecondaryMax
TransmitSecondaryMin

Definition at line 157 of file electronic_throttle_impl.h.

                       {
        Stopped,
 
        Start,
 
        // Drive the motor open
        Open,
 
        // Drive the motor closed
        Close,
 
        // Write learned values to TS
        TransmitPrimaryMax,
        TransmitPrimaryMin,
        TransmitSecondaryMax,
        TransmitSecondaryMin,
    };

Constructor & Destructor Documentation

◆ EtbImpl()

template<typename TBase >

template<typename... TArgs>

EtbImpl< TBase >::EtbImpl ( TArgs &&... args )

inline

Definition at line 177 of file electronic_throttle_impl.h.

177: TBase(std::forward<TArgs>(args)...) { }

TBase

Member Function Documentation

◆ autoCalibrateTps()

template<typename TBase >

void EtbImpl< TBase >::autoCalibrateTps ( bool reportToTs )

inlineoverride

Definition at line 197 of file electronic_throttle_impl.h.

                                                    {
        // Only auto calibrate throttles
        if (TBase::getFunction() == DC_Throttle1 || TBase::getFunction() == DC_Throttle2 || TBase::getFunction() == DC_Wastegate) {
            m_isAutocalTs = reportToTs;
            m_autocalPhase = ACPhase::Start;
        }
    }

◆ doAutocal()

template<typename TBase >

ACPhase EtbImpl< TBase >::doAutocal ( ACPhase phase )

inline

Definition at line 205 of file electronic_throttle_impl.h.

                                     {
        // Don't allow if engine is running!
        if (Sensor::getOrZero(SensorType::Rpm) > 0) {
            efiPrintf(" ****************** ERROR: Not while RPM ********************");
            return ACPhase::Stopped;
        }
 
        auto motor = TBase::getMotor();
        if (!motor) {
            efiPrintf(" ****************** ERROR: No DC motor ********************");
            return ACPhase::Stopped;
        }
 
        TBase::etbErrorCode = (uint8_t)EtbStatus::AutoCalibrate;
 
        auto myFunction = TBase::getFunction();
 
        switch (phase) {
        case ACPhase::Start:
            // Open the throttle
            motor->set(0.5f);
            motor->enable();
            return ACPhase::Open;
        case ACPhase::Open:
            if (m_autocalTimer.hasElapsedMs(1000)) {
                // Capture open position
                m_primaryMax = Sensor::getRaw(functionToTpsSensorPrimary(myFunction));
                m_secondaryMax = Sensor::getRaw(functionToTpsSensorSecondary(myFunction));
 
                // Next: close the throttle
                motor->set(-0.5f);
                return ACPhase::Close;
            }
            break;
        case ACPhase::Close:
            if (m_autocalTimer.hasElapsedMs(1000)) {
                // Capture closed position
                m_primaryMin = Sensor::getRaw(functionToTpsSensorPrimary(myFunction));
                m_secondaryMin = Sensor::getRaw(functionToTpsSensorSecondary(myFunction));
 
                // Disable the motor, we're done
                motor->disable("autotune");
 
                // Check that the calibrate actually moved the throttle
                if (std::abs(m_primaryMax - m_primaryMin) < 0.5f) {
                    firmwareError(ObdCode::OBD_TPS_Configuration, "Auto calibrate failed, check your wiring!\r\nClosed voltage: %.1fv Open voltage: %.1fv", m_primaryMin, m_primaryMax);
                    return ACPhase::Stopped;
                }
 
                if (!m_isAutocalTs) {
                    if (myFunction == DC_Throttle1) {
                        engineConfiguration->tpsMin = convertVoltageTo10bitADC(m_primaryMin);
                        engineConfiguration->tpsMax = convertVoltageTo10bitADC(m_primaryMax);
                        engineConfiguration->tps1SecondaryMin = convertVoltageTo10bitADC(m_secondaryMin);
                        engineConfiguration->tps1SecondaryMax = convertVoltageTo10bitADC(m_secondaryMax);
                    } else if (myFunction == DC_Throttle2) {
                        engineConfiguration->tps2Min = convertVoltageTo10bitADC(m_primaryMin);
                        engineConfiguration->tps2Max = convertVoltageTo10bitADC(m_primaryMax);
                        engineConfiguration->tps2SecondaryMin = convertVoltageTo10bitADC(m_secondaryMin);
                        engineConfiguration->tps2SecondaryMax = convertVoltageTo10bitADC(m_secondaryMax);
                    } else if (myFunction == DC_Wastegate) {
                        engineConfiguration->wastegatePositionClosedVoltage = m_primaryMin;
                        engineConfiguration->wastegatePositionOpenedVoltage = m_primaryMax;
                    } else {
                        /* TODO */
                    }
                    return ACPhase::Stopped;
                }
 
                // Next: start transmitting results
                tsCalibrationSetData(functionToCalModePriMax(myFunction), m_primaryMax);
                return ACPhase::TransmitPrimaryMax;
            }
            break;
        case ACPhase::TransmitPrimaryMax:
            if (tsCalibrationIsIdle()) {
                tsCalibrationSetData(functionToCalModePriMin(myFunction), m_primaryMin);
                return ACPhase::TransmitPrimaryMin;
            }
            break;
        case ACPhase::TransmitPrimaryMin:
            if (tsCalibrationIsIdle()) {
                tsCalibrationSetData(functionToCalModeSecMax(myFunction), m_secondaryMax);
                // No secondary sensor?
                if (tsCalibrationIsIdle())
                    return ACPhase::Stopped;
                return ACPhase::TransmitSecondaryMax;
            }
            break;
        case ACPhase::TransmitSecondaryMax:
            if (tsCalibrationIsIdle()) {
                tsCalibrationSetData(functionToCalModeSecMin(myFunction), m_secondaryMin);
                return ACPhase::TransmitSecondaryMin;
            }
            break;
        case ACPhase::TransmitSecondaryMin:
            if (tsCalibrationIsIdle()) {
                // Done!
                return ACPhase::Stopped;
            }
            break;
        case ACPhase::Stopped: break;
        }
 
        // by default, stay in the same phase
        return phase;
    }

Referenced by EtbImpl< TBase >::update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update()

template<typename TBase >

void EtbImpl< TBase >::update ( )

inlineoverride

Definition at line 179 of file electronic_throttle_impl.h.

                           {
#if EFI_TUNER_STUDIO
        if (m_autocalPhase != ACPhase::Stopped) {
            ACPhase nextPhase = doAutocal(m_autocalPhase);
 
            // if we changed phase, reset the phase timer
            if (m_autocalPhase != nextPhase) {
                m_autocalTimer.reset();
                m_autocalPhase = nextPhase;
            }
        } else
#endif /* EFI_TUNER_STUDIO */
 
        {
            TBase::update();
        }
    }