HellaOilLevelSensor Class Reference

#include <hella_oil_level.h>

Inheritance diagram for HellaOilLevelSensor:

Collaboration diagram for HellaOilLevelSensor:

Public Member Functions
	HellaOilLevelSensor (SensorType type)
void	init (brain_pin_e pin)
void	deInit ()
void	onEdge (efitick_t nowNt)
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

Private Types
enum class	NextPulse { None , Temp , Level , Diag }

Private Attributes
brain_pin_e	m_pin = Gpio::Unassigned
Timer	m_pulseTimer
Timer	m_betweenPulseTimer
NextPulse	m_nextPulse = NextPulse::None

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)
Protected Member Functions inherited from Sensor
	Sensor (SensorType type)
Static Protected Attributes inherited from Sensor
static bool	s_inhibitSensorTimeouts = false

Detailed Description

Definition at line 5 of file hella_oil_level.h.

Member Enumeration Documentation

NextPulse

enum class HellaOilLevelSensor::NextPulse

strongprivate

Enumerator
None
Temp
Level
Diag

Definition at line 23 of file hella_oil_level.h.

{ None, Temp, Level, Diag };

Constructor & Destructor Documentation

HellaOilLevelSensor()

HellaOilLevelSensor::HellaOilLevelSensor ( SensorType  type )

inline

Definition at line 7 of file hella_oil_level.h.

: StoredValueSensor(type, MS2NT(2000)) {}

Member Function Documentation

deInit()

void HellaOilLevelSensor::deInit

(

)

Definition at line 30 of file hella_oil_level.cpp.

                                 {
    if (!isBrainPinValid(m_pin)) {
        return;
    }
 
#if EFI_PROD_CODE
    efiExtiDisablePin(m_pin);
#endif
 
    m_pin = Gpio::Unassigned;
}

Here is the call graph for this function:

init()

void HellaOilLevelSensor::init

(

brain_pin_e

pin

)

Definition at line 13 of file hella_oil_level.cpp.

                                              {
    if (!isBrainPinValid(pin)) {
        return;
    }
 
#if EFI_PROD_CODE
    if (efiExtiEnablePin(getSensorName(), pin, PAL_EVENT_MODE_BOTH_EDGES,
        hellaSensorExtiCallback, reinterpret_cast<void*>(this)) < 0) {
        return;
    }
#endif // EFI_PROD_CODE
 
    m_pin = pin;
 
    Register();
}

Here is the call graph for this function:

onEdge()

void HellaOilLevelSensor::onEdge

(

efitick_t

nowNt

)

Definition at line 42 of file hella_oil_level.cpp.

                                                {
    if (efiReadPin(m_pin)) {
        // Start pulse width timing at the rising edge
        m_pulseTimer.reset(nowNt);
 
        float timeBetweenPulses = m_betweenPulseTimer.getElapsedSecondsAndReset(nowNt);
 
        if (timeBetweenPulses > 0.89 * 0.780 && timeBetweenPulses < 1.11 * 0.780) {
            // 780ms nominal between Diag and next Temp pulse start, +-10%
 
            // This was the "long gap" break, next pulse is temperature.
            m_nextPulse = NextPulse::Temp;
        } else if (timeBetweenPulses > 0.89 * 0.110 && timeBetweenPulses < 1.11 * 0.110) {
            // 110ms nominal between each pulse (other than break)
 
            // Advance the state machine to decode the next pulse in the sequence
            switch (m_nextPulse) {
                case NextPulse::Temp:
                    m_nextPulse = NextPulse::Level;
                    break;
                case NextPulse::Level:
                    m_nextPulse = NextPulse::Diag;
                    break;
                default:
                    // We don't know how we got here, reset to safe state
                    m_nextPulse = NextPulse::None;
                    break;
            }
        } else {
            // The break was too long, ignore it for now.
            m_nextPulse = NextPulse::None;
        }
    } else {
        // Stop timing at the falling edge
        float lastPulseMs = 1000 * m_pulseTimer.getElapsedSeconds(nowNt);
 
        if (lastPulseMs > 100 || lastPulseMs < 20) {
            // Impossibly short or long pulse, something went wrong
            m_nextPulse = NextPulse::None;
            return;
        }
 
        if (m_nextPulse == NextPulse::Diag) {
            // TODO: decode diag pulse?
            return;
        } else if (m_nextPulse == NextPulse::Temp) {
            // 22ms = Short circuit temp sensor
            // 23ms = -40C
            // 87ms = 160C
            // 88ms = Temp sensor defective
 
            if (lastPulseMs < 22.8) {
                // Short circuit
                // invalidate(UnexpectedCode::Low);
            } else if (lastPulseMs > 87.2) {
                // Defective
                // invalidate(UnexpectedCode::High);
            } else {
                float tempC = interpolateClamped(23, -40, 87, 160, lastPulseMs);
                // setValidValue(tempC, nowNt);
            }
        } else if (m_nextPulse == NextPulse::Level) {
            // 22ms = Unreliable signal
            // 23ms = level 0mm
            // 87.86ms = level 150mm
 
            if (lastPulseMs < 22.8f) {
                // Unreliable
                invalidate(UnexpectedCode::Low);
            } else {
                float levelMm = interpolateClamped(23, 0, 87.86, 150, lastPulseMs);
                setValidValue(levelMm, nowNt);
            }
        }
    }
}

Here is the call graph for this function:

Field Documentation

m_betweenPulseTimer

Timer HellaOilLevelSensor::m_betweenPulseTimer

private

Definition at line 21 of file hella_oil_level.h.

Referenced by onEdge().

m_nextPulse

NextPulse HellaOilLevelSensor::m_nextPulse = NextPulse::None

private

Definition at line 24 of file hella_oil_level.h.

Referenced by onEdge().

m_pin

brain_pin_e HellaOilLevelSensor::m_pin = Gpio::Unassigned

private

Definition at line 15 of file hella_oil_level.h.

Referenced by deInit(), init(), and onEdge().

m_pulseTimer

Timer HellaOilLevelSensor::m_pulseTimer

private

Definition at line 18 of file hella_oil_level.h.

Referenced by onEdge().

---

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

• controllers/sensors/hella_oil_level.h
• controllers/sensors/hella_oil_level.cpp