#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	resetQuantity ()

void	onFastCallback () final

Public Member Functions inherited from EngineModule
virtual void	initNoConfiguration ()

virtual void	setDefaultConfiguration ()

virtual void	onConfigurationChange (engine_configuration_s const *)

virtual void	onSlowCallback ()

virtual void	onEngineStop ()

virtual void	onIgnitionStateChanged (bool)

virtual bool	needsDelayedShutoff ()

virtual void	onEnginePhase (float, efitick_t, angle_t, angle_t)

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

float	hpfp_p_control_percent = (float)0

float	hpfp_i_control_percent = (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 71 of file high_pressure_fuel_pump.h.

Member Typedef Documentation

◆ interface_t

using HpfpController::interface_t = HpfpController

Definition at line 74 of file high_pressure_fuel_pump.h.

Member Function Documentation

◆ onFastCallback()

void HpfpController::onFastCallback ( )

finalvirtual

Reimplemented from EngineModule.

Definition at line 153 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) {
        resetQuantity();
        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 210 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();
}

Here is the call graph for this function:

◆ pinTurnOn()

void HpfpController::pinTurnOn ( HpfpController * self )

staticprivate

Definition at line 190 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.
    //
    // We do not need precise control of valve _duration_ since
    // For the solenoid type pump, the pump has a certain volume. You can activate the solenoid to request that the pump start pressurizing.
    // Once it reaches a certain pressure, it is effectively self running and won't unlatch until the pump reaches the top.
  // Since the solenoid latches itself, you don't have to keep it activated for the whole lobe. You just need to activate it until it latches and then let it do the rest of the work.
  // see also https://rusefi.com/forum/viewtopic.php?f=5&t=2192
 
    scheduleByAngle(&self->m_event.eventScheduling,
            self->m_event.eventScheduling.getMomentNt(),
            self->m_deadangle + engineConfiguration->hpfpActivationAngle,
            action_s::make<pinTurnOff>( self ));
}

Here is the call graph for this function:

◆ resetQuantity()

void HpfpController::resetQuantity ( )

inline

Reset internal state due to a stopped engine.

Definition at line 79 of file high_pressure_fuel_pump.h.

                         {
        hpfp_i_control_percent = 0;
        m_pressureTarget_kPa = 0;
    }

Referenced by onFastCallback().

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 218 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: some 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,
            action_s::make<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: schedule only 'scheduleNextCycle' directly since we do not need output control part of the logic here!
        engine->module<TriggerScheduler>()->schedule(
            HPFP_CONTROLLER,
            &m_event, lobeAngle,
            action_s::make<pinTurnOff>( this ));
    }
}