#include <high_pressure_fuel_pump.h>

Inheritance diagram for HpfpController:

[legend]

Collaboration diagram for HpfpController:

[legend]

Public Types
using	interface_t = HpfpController

Public Member Functions
void	onFastCallback () final

Public Member Functions inherited from EngineModule
virtual void	onConfigurationChange (engine_configuration_s const *)

virtual void	onSlowCallback ()

virtual void	onIgnitionStateChanged (bool)

virtual bool	needsDelayedShutoff ()

Data Fields
angle_t	m_deadangle = 0
	Computed solenoid deadtime in degrees.

Data Fields inherited from high_pressure_fuel_pump_s
angle_t	m_requested_pump = (angle_t)0

float	fuel_requested_percent = (float)0

float	fuel_requested_percent_pi = (float)0

bool	noValve: 1 {}

bool	angleAboveMin: 1 {}

bool	isHpfpActive: 1 {}

bool	HpfpValveState: 1 {}

bool	unusedBit_7_4: 1 {}

bool	unusedBit_7_5: 1 {}

bool	unusedBit_7_6: 1 {}

bool	unusedBit_7_7: 1 {}

bool	unusedBit_7_8: 1 {}

bool	unusedBit_7_9: 1 {}

bool	unusedBit_7_10: 1 {}

bool	unusedBit_7_11: 1 {}

bool	unusedBit_7_12: 1 {}

bool	unusedBit_7_13: 1 {}

bool	unusedBit_7_14: 1 {}

bool	unusedBit_7_15: 1 {}

bool	unusedBit_7_16: 1 {}

bool	unusedBit_7_17: 1 {}

bool	unusedBit_7_18: 1 {}

bool	unusedBit_7_19: 1 {}

bool	unusedBit_7_20: 1 {}

bool	unusedBit_7_21: 1 {}

bool	unusedBit_7_22: 1 {}

bool	unusedBit_7_23: 1 {}

bool	unusedBit_7_24: 1 {}

bool	unusedBit_7_25: 1 {}

bool	unusedBit_7_26: 1 {}

bool	unusedBit_7_27: 1 {}

bool	unusedBit_7_28: 1 {}

bool	unusedBit_7_29: 1 {}

bool	unusedBit_7_30: 1 {}

bool	unusedBit_7_31: 1 {}

float	m_pressureTarget_kPa = (float)0

angle_t	nextLobe = (angle_t)0

float	di_nextStart = (float)0

float	HpfdActivationPhase = (float)0

float	HpfdDeactivationPhase = (float)0

Private Member Functions
void	scheduleNextCycle ()

Static Private Member Functions
static void	pinTurnOn (HpfpController *self)

static void	pinTurnOff (HpfpController *self)

Private Attributes
AngleBasedEvent	m_event

HpfpQuantity	m_quantity

HpfpLobe	m_lobe

volatile bool	m_running = false
	Whether events are being scheduled or not.

Detailed Description

Definition at line 82 of file high_pressure_fuel_pump.h.

Member Typedef Documentation

◆ interface_t

using HpfpController::interface_t = HpfpController

Definition at line 85 of file high_pressure_fuel_pump.h.

Member Function Documentation

◆ onFastCallback()

void HpfpController::onFastCallback ( )

finalvirtual

Reimplemented from EngineModule.

Definition at line 156 of file high_pressure_fuel_pump.cpp.

                                    {
    // Pressure current/target calculation
    float rpm = Sensor::getOrZero(SensorType::Rpm);
 
    isHpfpActive = !(rpm < rpm_spinning_cutoff ||
            !isGdiEngine() ||
            engineConfiguration->hpfpPumpVolume == 0 ||
            !enginePins.hpfpValve.isInitialized());
    // What conditions can we not handle?
    if (!isHpfpActive) {
        m_quantity.reset();
        m_requested_pump = 0;
        m_deadangle = 0;
    } else {
#if EFI_PROD_CODE && EFI_SHAFT_POSITION_INPUT
        criticalAssertVoid(engine->triggerCentral.triggerShape.getSize() > engineConfiguration->hpfpCamLobes * 6, "Too few trigger tooth for this number of HPFP lobes");
#endif // EFI_PROD_CODE
        // Convert deadtime from ms to degrees based on current RPM
        float deadtime_ms = interpolate2d(
            Sensor::get(SensorType::BatteryVoltage).value_or(VBAT_FALLBACK_VALUE),
            config->hpfpDeadtimeVoltsBins,
            config->hpfpDeadtimeMS);
        m_deadangle = deadtime_ms * rpm * (360.f / 60.f / 1000.f);
 
        // We set deadtime first, then pump, in case pump used to be 0.  Pump is what
        // determines whether we do anything or not.
        m_requested_pump = m_quantity.pumpAngleFuel(rpm, this);
 
        if (!m_running) {
            m_running = true;
            scheduleNextCycle();
        }
    }
}

Here is the call graph for this function:

◆ pinTurnOff()

void HpfpController::pinTurnOff ( HpfpController * self )

staticprivate

Definition at line 206 of file high_pressure_fuel_pump.cpp.

                                                    {
    enginePins.hpfpValve.setLow(HPFP_CONTROLLER);
    self->HpfpValveState = false;
    self->HpfdDeactivationPhase = getTriggerCentral()->getCurrentEnginePhase(getTimeNowNt()).value_or(-1);
 
    self->scheduleNextCycle();
}

Referenced by scheduleNextCycle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pinTurnOn()

void HpfpController::pinTurnOn ( HpfpController * self )

staticprivate

Definition at line 193 of file high_pressure_fuel_pump.cpp.

                                                   {
    enginePins.hpfpValve.setHigh(HPFP_CONTROLLER);
    self->HpfpValveState = true;
    self->HpfdActivationPhase = getTriggerCentral()->getCurrentEnginePhase(getTimeNowNt()).value_or(-1);
 
    // By scheduling the close after we already open, we don't have to worry if the engine
    // stops, the valve will be turned off in a certain amount of time regardless.
    scheduleByAngle(&self->m_event.eventScheduling,
            self->m_event.eventScheduling.getMomentNt(),
            self->m_deadangle + engineConfiguration->hpfpActivationAngle,
            { pinTurnOff, self });
}

Referenced by scheduleNextCycle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scheduleNextCycle()

void HpfpController::scheduleNextCycle ( )

private

We are good to use just one m_event instance because new events are scheduled when we turn off valve.

Definition at line 214 of file high_pressure_fuel_pump.cpp.

                                       {
    noValve = !enginePins.hpfpValve.isInitialized();
    if (noValve) {
        m_running = false;
        return;
    }
 
    angle_t lobeAngle = m_lobe.findNextLobe();
    //TODO: integrate livedata into HpfpLobe
    nextLobe = m_lobe.m_lobe_index;
    angle_t angle_requested = m_requested_pump;
 
    angleAboveMin = angle_requested > engineConfiguration->hpfpMinAngle;
    if (angleAboveMin) {
        // TODO: som manuals suggest also substracting peak time (converted to angle)
        di_nextStart = lobeAngle - angle_requested - m_deadangle;
        wrapAngle(di_nextStart, "di_nextStart", ObdCode::CUSTOM_ERR_6557);
 
 
        /**
         * We are good to use just one m_event instance because new events are scheduled when we turn off valve.
         */
        engine->module<TriggerScheduler>()->schedule(
            "hpfp",
            &m_event,
            di_nextStart,
            { pinTurnOn, this });
 
        // Off will be scheduled after turning the valve on
    } else {
        wrapAngle(lobeAngle, "lobe", ObdCode::CUSTOM_ERR_6557);
        // Schedule this, even if we aren't opening the valve this time, since this
        // will schedule the next lobe.
        // todo: would it have been cleaner to schedule 'scheduleNextCycle' directly?
        engine->module<TriggerScheduler>()->schedule(
            HPFP_CONTROLLER,
            &m_event, lobeAngle,
            { pinTurnOff, this });
    }
}