#include <AemXSeriesLambda.h>

Inheritance diagram for AemXSeriesWideband:

[legend]

Collaboration diagram for AemXSeriesWideband:

[legend]

Public Member Functions
	AemXSeriesWideband (uint8_t sensorIndex, SensorType type)

bool	acceptFrame (const size_t busIndex, const CANRxFrame &frame) const override final

void	refreshState (void)

void	refreshSmoothedLambda (float lambda)

Public Member Functions inherited from CanSensorBase
	CanSensorBase (uint32_t eid, SensorType type, efidur_t timeout)

void	showInfo (const char *sensorName) const override

Public Member Functions inherited from StoredValueSensor
SensorResult	get () const final override

	StoredValueSensor (SensorType type, efidur_t timeoutNt)

void	invalidate ()

void	invalidate (UnexpectedCode why)

void	setValidValue (float value, efitick_t timestamp)

void	showInfo (const char *sensorName) const override

virtual void	setTimeout (int timeoutMs)

Public Member Functions inherited from Sensor
bool	Register ()

const char *	getSensorName () const

virtual bool	hasSensor () const

virtual float	getRaw () const

virtual bool	isRedundant () const

void	unregister ()

SensorType	type () const

Public Member Functions inherited from CanListener
	CanListener (uint32_t id)

CanListener *	processFrame (const size_t busIndex, const CANRxFrame &frame, efitick_t nowNt)

uint32_t	getId ()

void	setNext (CanListener *next)

virtual CanListener *	request ()

CanListener *	getNext () const

Data Fields
bool	hasSeenRx = false

Data Fields inherited from wideband_state_s
uint8_t	stateCode = (uint8_t)0

uint8_t	heaterDuty = (uint8_t)0

uint8_t	pumpDuty = (uint8_t)0

uint8_t	alignmentFill_at_3 [1] = {}

bool	isValid: 1 {}

bool	canSilent: 1 {}

bool	allowed: 1 {}

bool	fwUnsupported: 1 {}

bool	fwOutdated: 1 {}

bool	unusedBit_9_5: 1 {}

bool	unusedBit_9_6: 1 {}

bool	unusedBit_9_7: 1 {}

bool	unusedBit_9_8: 1 {}

bool	unusedBit_9_9: 1 {}

bool	unusedBit_9_10: 1 {}

bool	unusedBit_9_11: 1 {}

bool	unusedBit_9_12: 1 {}

bool	unusedBit_9_13: 1 {}

bool	unusedBit_9_14: 1 {}

bool	unusedBit_9_15: 1 {}

bool	unusedBit_9_16: 1 {}

bool	unusedBit_9_17: 1 {}

bool	unusedBit_9_18: 1 {}

bool	unusedBit_9_19: 1 {}

bool	unusedBit_9_20: 1 {}

bool	unusedBit_9_21: 1 {}

bool	unusedBit_9_22: 1 {}

bool	unusedBit_9_23: 1 {}

bool	unusedBit_9_24: 1 {}

bool	unusedBit_9_25: 1 {}

bool	unusedBit_9_26: 1 {}

bool	unusedBit_9_27: 1 {}

bool	unusedBit_9_28: 1 {}

bool	unusedBit_9_29: 1 {}

bool	unusedBit_9_30: 1 {}

bool	unusedBit_9_31: 1 {}

uint16_t	tempC = (uint16_t)0

scaled_channel< uint16_t, 1000, 1 >	nernstVoltage = (uint16_t)0

uint16_t	esr = (uint16_t)0

uint8_t	alignmentFill_at_14 [2] = {}

Protected Member Functions
void	decodeFrame (const CANRxFrame &frame, efitick_t nowNt) override

bool	decodeAemXSeries (const CANRxFrame &frame, efitick_t nowNt)

bool	decodeRusefiStandard (const CANRxFrame &frame, efitick_t nowNt)

void	decodeRusefiDiag (const CANRxFrame &frame)

Protected Member Functions inherited from Sensor
	Sensor (SensorType type)

Private Member Functions
can_wbo_type_e	sensorType () const

uint32_t	getReCanId () const

uint32_t	getAemCanId () const

bool	isHeaterAllowed ()

Private Attributes
const uint8_t	m_sensorIndex

uint8_t	m_stateCode

bool	m_afrIsValid

bool	m_isFault

efitick_t	m_lastUpdate = 0

Additional Inherited Members
Static Public Member Functions inherited from Sensor
static void	showAllSensorInfo ()

static void	showInfo (SensorType type)

static void	resetRegistry ()

static const Sensor *	getSensorOfType (SensorType type)

static SensorResult	get (SensorType type)

static float	getOrZero (SensorType type)

static float	getRaw (SensorType type)

static bool	isRedundant (SensorType type)

static bool	hasSensor (SensorType type)

static void	setMockValue (SensorType type, float value, bool mockRedundant=false)

static void	setInvalidMockValue (SensorType type)

static void	resetMockValue (SensorType type)

static void	resetAllMocks ()

static void	inhibitTimeouts (bool inhibit)

static const char *	getSensorName (SensorType type)

Static Protected Attributes inherited from Sensor
static bool	s_inhibitSensorTimeouts = false

Detailed Description

Definition at line 16 of file AemXSeriesLambda.h.

Constructor & Destructor Documentation

◆ AemXSeriesWideband()

AemXSeriesWideband::AemXSeriesWideband	(	uint8_t	sensorIndex,
		SensorType	type
	)

Definition at line 14 of file AemXSeriesLambda.cpp.

    : CanSensorBase(
        0,  // ID passed here doesn't matter since we override acceptFrame
        type,
        sensor_timeout
    )
    , m_sensorIndex(sensorIndex)
{
    stateCode = m_stateCode = static_cast<uint8_t>(wbo::Status::CanSilent);// silent, initial state is "no one has spoken to us so far"
    isValid = m_isFault = m_afrIsValid = false;
    // wait for first rusEFI WBO standard frame with protocol version field
    fwUnsupported = true;
    // Do not light "FW: need update" indicator until we get some data from WBO
    fwOutdated = false;
}

Member Function Documentation

◆ acceptFrame()

bool AemXSeriesWideband::acceptFrame	(	const size_t	busIndex,
		const CANRxFrame &	frame
	)		const

finaloverridevirtual

Reimplemented from CanListener.

Definition at line 44 of file AemXSeriesLambda.cpp.

                                                                                         {
#if !EFI_UNIT_TEST
    if (busIndex != getWidebandBus()) {
        return false;
    }
#endif
 
    if (frame.DLC != 8) {
        return false;
    }
 
    can_wbo_type_e type = sensorType();
 
    if (type == DISABLED) {
        return false;
    }
 
    // RusEFI wideband uses standard CAN IDs
    if ((!CAN_ISX(frame)) && (type == RUSEFI)) {
        // 0th sensor is 0x190 and 0x191, 1st sensor is 0x192 and 0x193
        uint32_t rusefiBaseId = getReCanId();
        return ((CAN_SID(frame) == rusefiBaseId) || (CAN_SID(frame) == rusefiBaseId + 1));
    }
 
    // AEM uses extended CAN ID
    if ((CAN_ISX(frame)) && (type == AEM)) {
        // 0th sensor is 0x00000180, 1st sensor is 0x00000181, etc
        uint32_t aemXSeriesId = getAemCanId();
        return (CAN_EID(frame) == aemXSeriesId);
    }
 
    return false;
}

Here is the call graph for this function:

◆ decodeAemXSeries()

bool AemXSeriesWideband::decodeAemXSeries	(	const CANRxFrame &	frame,
		efitick_t	nowNt
	)

protected

Returns: true if valid, false if invalid

Definition at line 164 of file AemXSeriesLambda.cpp.

                                                                                  {
    // we don't care
    fwUnsupported = false;
    fwOutdated = false;
 
    // reports in 0.0001 lambda per LSB
    uint16_t lambdaInt = SWAP_UINT16(frame.data16[0]);
    float lambdaFloat = 0.0001f * lambdaInt;
 
    // bit 6 indicates sensor fault
    m_isFault = frame.data8[7] & 0x40;
    // bit 7 indicates valid
    m_afrIsValid = frame.data8[6] & 0x80;
 
    if ((m_isFault) || (!m_afrIsValid)) {
        invalidate();
        return false;
    }
 
    setValidValue(lambdaFloat, nowNt);
    refreshSmoothedLambda(lambdaFloat);
    return true;
}

Referenced by decodeFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decodeFrame()

void AemXSeriesWideband::decodeFrame	(	const CANRxFrame &	frame,
		efitick_t	nowNt
	)

overrideprotectedvirtual

Implements CanListener.

Definition at line 133 of file AemXSeriesLambda.cpp.

                                                                             {
    bool accepted = false;
    // accept frame has already guaranteed that this message belongs to us
    // We just have to check if it's AEM or rusEFI
    if (sensorType() == RUSEFI) {
        uint32_t id = CAN_ID(frame);
        hasSeenRx = true;
 
        // rusEFI custom format
        if ((id & 0x1) != 0) {
            // low bit is set, this is the "diag" frame
            decodeRusefiDiag(frame);
        } else {
            // low bit not set, this is standard frame
            accepted = decodeRusefiStandard(frame, nowNt);
        }
    } else /* if (sensorType() == AEM) */ {
        accepted = decodeAemXSeries(frame, nowNt);
    }
 
    if (accepted) {
        m_lastUpdate = nowNt;
    }
 
    // Do refresh on each CAN packet
    refreshState();
}

Here is the call graph for this function:

◆ decodeRusefiDiag()

void AemXSeriesWideband::decodeRusefiDiag ( const CANRxFrame & frame )

protected

Definition at line 241 of file AemXSeriesLambda.cpp.

                                                                 {
    if (fwUnsupported) {
        return;
    }
 
    auto data = reinterpret_cast<const wbo::DiagData*>(&frame.data8[0]);
 
    // convert to percent
    heaterDuty = data->HeaterDuty / 2.55f;
    pumpDuty = data->PumpDuty / 2.55f;
 
    // convert to volts
    nernstVoltage = data->NernstDc * 0.001f;
 
    // no conversion, just ohms
    esr = data->Esr;
 
    // This state is handle in refreshState()
    //if (!isHeaterAllowed()) {
    //    m_stateCode = HACK_CRANKING_VALUE;
    //    return;
    //}
 
    m_stateCode = static_cast<uint8_t>(data->status);
 
    if ((isStatusError(static_cast<wbo::Status>(data->status))) && isHeaterAllowed()) {
        auto code = m_sensorIndex == 0 ? ObdCode::Wideband_1_Fault : ObdCode::Wideband_2_Fault;
        warning(code, "Wideband #%d fault: %s", (m_sensorIndex + 1), wbo::describeStatus(data->status));
    }
}

Referenced by decodeFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decodeRusefiStandard()

bool AemXSeriesWideband::decodeRusefiStandard	(	const CANRxFrame &	frame,
		efitick_t	nowNt
	)

protected

Definition at line 188 of file AemXSeriesLambda.cpp.

                                                                                      {
    auto data = reinterpret_cast<const wbo::StandardData*>(&frame.data8[0]);
 
    if (data->Version > RUSEFI_WIDEBAND_VERSION) {
        firmwareError(ObdCode::OBD_WB_FW_Mismatch, "Wideband controller index %d has newer protocol version (0x%02x while 0x%02x supported), please update ECU FW!",
            m_sensorIndex, data->Version, RUSEFI_WIDEBAND_VERSION);
        fwUnsupported = true;
        return false;
    }
 
    if (data->Version < RUSEFI_WIDEBAND_VERSION_MIN) {
        firmwareError(ObdCode::OBD_WB_FW_Mismatch, "Wideband controller index %d has outdated protocol version (0x%02x while minimum 0x%02x expected), please update WBO!",
            m_sensorIndex, data->Version, RUSEFI_WIDEBAND_VERSION_MIN);
        fwUnsupported = true;
        return false;
    }
 
    fwUnsupported = false;
    // compatible, but not latest
    fwOutdated = (data->Version != RUSEFI_WIDEBAND_VERSION);
    // TODO: request and check builddate
 
    tempC = data->TemperatureC;
    float lambda = 0.0001f * data->Lambda;
    m_afrIsValid = data->Valid & 0x01;
 
    if (!m_afrIsValid) {
        invalidate();
    } else {
        setValidValue(lambda, nowNt);
        refreshSmoothedLambda(lambda);
    }
 
    return true;
}

Referenced by decodeFrame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAemCanId()

uint32_t AemXSeriesWideband::getAemCanId ( ) const

private

Definition at line 39 of file AemXSeriesLambda.cpp.

                                               {
    // 0th sensor is 0x00000180, 1st sensor is 0x00000181, etc
    return aem_base + engineConfiguration->canWbo[m_sensorIndex].aemId;
}

Referenced by acceptFrame().

Here is the caller graph for this function:

◆ getReCanId()

uint32_t AemXSeriesWideband::getReCanId ( ) const

private

Definition at line 34 of file AemXSeriesLambda.cpp.

                                              {
    // 0th sensor is 0x190 and 0x191, 1st sensor is 0x192 and 0x193
    return rusefi_base + 2 * engineConfiguration->canWbo[m_sensorIndex].reId;
}

Referenced by acceptFrame().

Here is the caller graph for this function:

◆ isHeaterAllowed()

bool AemXSeriesWideband::isHeaterAllowed ( )

private

Definition at line 78 of file AemXSeriesLambda.cpp.

                                         {
    return ((sensorType() == AEM) || (engine->engineState.heaterControlEnabled));
}

Referenced by decodeRusefiDiag(), and refreshState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refreshSmoothedLambda()

void AemXSeriesWideband::refreshSmoothedLambda ( float lambda )

Definition at line 224 of file AemXSeriesLambda.cpp.

                                                           {
    switch (type()) {
    case SensorType::Lambda1: {
            expAverageLambda1.setSmoothingFactor(engineConfiguration->afrExpAverageAlpha);
            smoothedLambda1Sensor.setValidValue(expAverageLambda1.initOrAverage(lambda), getTimeNowNt());
            break;
    }
    case SensorType::Lambda2: {
            expAverageLambda2.setSmoothingFactor(engineConfiguration->afrExpAverageAlpha);
            smoothedLambda2Sensor.setValidValue(expAverageLambda2.initOrAverage(lambda), getTimeNowNt());
            break;
    }
    default:
        break;
    }
}

Referenced by decodeAemXSeries(), and decodeRusefiStandard().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refreshState()

void AemXSeriesWideband::refreshState ( void )

Definition at line 82 of file AemXSeriesLambda.cpp.

                                      {
    can_wbo_type_e type = sensorType();
 
    // Report ECU to WBO allow state
    allowed = isHeaterAllowed();
    if (getTimeNowNt() - sensor_timeout > m_lastUpdate) {
        canSilent = true;
        isValid = false;
        return;
    }
    canSilent = false;
 
    if (type == RUSEFI) {
        // This is RE WBO
        isValid = m_afrIsValid;
        // Report state code from WBO
        stateCode = m_stateCode;
        return;
    } else if (type == AEM) {
        // This is AEM with two flags only and no debug fields
        heaterDuty = 0;
        pumpDuty = 0;
        tempC = 0;
        nernstVoltage = 0;
 
        if (m_isFault) {
            stateCode = HACK_INVALID_AEM;
            isValid = false;
        } else {
            // TODO: better status code?
            stateCode = m_afrIsValid ?
                static_cast<uint8_t>(wbo::Status::RunningClosedLoop) :
                static_cast<uint8_t>(wbo::Status::Warmup);
            isValid = m_afrIsValid;
        }
        return;
    } else {
        // disabled or analog
        // clear all livedata
        heaterDuty = 0;
        pumpDuty = 0;
        tempC = 0;
        nernstVoltage = 0;
        isValid = false;
        return;
    }
 
    // non configured
    stateCode = static_cast<uint8_t>(wbo::Status::CanSilent);
}

Referenced by decodeFrame(), and getLiveData().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sensorType()

can_wbo_type_e AemXSeriesWideband::sensorType ( ) const

private

Definition at line 30 of file AemXSeriesLambda.cpp.

                                                    {
    return engineConfiguration->canWbo[m_sensorIndex].type;
}

Referenced by acceptFrame(), decodeFrame(), isHeaterAllowed(), and refreshState().

Here is the caller graph for this function:

Field Documentation

◆ hasSeenRx

bool AemXSeriesWideband::hasSeenRx = false

Definition at line 26 of file AemXSeriesLambda.h.

Referenced by decodeFrame(), and uaefi_slowCallback().

◆ m_afrIsValid

bool AemXSeriesWideband::m_afrIsValid

private

Definition at line 49 of file AemXSeriesLambda.h.

Referenced by AemXSeriesWideband(), decodeAemXSeries(), decodeRusefiStandard(), and refreshState().

◆ m_isFault

bool AemXSeriesWideband::m_isFault

private

Definition at line 51 of file AemXSeriesLambda.h.

Referenced by AemXSeriesWideband(), decodeAemXSeries(), and refreshState().

◆ m_lastUpdate

efitick_t AemXSeriesWideband::m_lastUpdate = 0

private

Definition at line 53 of file AemXSeriesLambda.h.

Referenced by decodeFrame(), and refreshState().

◆ m_sensorIndex

const uint8_t AemXSeriesWideband::m_sensorIndex

private

Definition at line 45 of file AemXSeriesLambda.h.

Referenced by decodeRusefiDiag(), decodeRusefiStandard(), getAemCanId(), getReCanId(), and sensorType().

◆ m_stateCode

uint8_t AemXSeriesWideband::m_stateCode

private

Definition at line 47 of file AemXSeriesLambda.h.

Referenced by AemXSeriesWideband(), decodeRusefiDiag(), and refreshState().

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

controllers/sensors/impl/AemXSeriesLambda.h
controllers/sensors/impl/AemXSeriesLambda.cpp

Public Member Functions

Data Fields

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AemXSeriesWideband()

Member Function Documentation

◆ acceptFrame()

◆ decodeAemXSeries()

◆ decodeFrame()

◆ decodeRusefiDiag()

◆ decodeRusefiStandard()

◆ getAemCanId()

◆ getReCanId()

◆ isHeaterAllowed()

◆ refreshSmoothedLambda()

◆ refreshState()

◆ sensorType()

Field Documentation

◆ hasSeenRx

◆ m_afrIsValid

◆ m_isFault

◆ m_lastUpdate

◆ m_sensorIndex

◆ m_stateCode