#include <high_pressure_fuel_pump.h>

Inheritance diagram for HpfpController:

Collaboration diagram for HpfpController:

[legend]

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

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. More...

volatile angle_t	m_deadtime = 0
	Computed solenoid deadtime in degrees. More...

Additional Inherited Members
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	isHpfpInactive: 1 {}

bool	unusedBit_6_3: 1 {}

bool	unusedBit_6_4: 1 {}

bool	unusedBit_6_5: 1 {}

bool	unusedBit_6_6: 1 {}

bool	unusedBit_6_7: 1 {}

bool	unusedBit_6_8: 1 {}

bool	unusedBit_6_9: 1 {}

bool	unusedBit_6_10: 1 {}

bool	unusedBit_6_11: 1 {}

bool	unusedBit_6_12: 1 {}

bool	unusedBit_6_13: 1 {}

bool	unusedBit_6_14: 1 {}

bool	unusedBit_6_15: 1 {}

bool	unusedBit_6_16: 1 {}

bool	unusedBit_6_17: 1 {}

bool	unusedBit_6_18: 1 {}

bool	unusedBit_6_19: 1 {}

bool	unusedBit_6_20: 1 {}

bool	unusedBit_6_21: 1 {}

bool	unusedBit_6_22: 1 {}

bool	unusedBit_6_23: 1 {}

bool	unusedBit_6_24: 1 {}

bool	unusedBit_6_25: 1 {}

bool	unusedBit_6_26: 1 {}

bool	unusedBit_6_27: 1 {}

bool	unusedBit_6_28: 1 {}

bool	unusedBit_6_29: 1 {}

bool	unusedBit_6_30: 1 {}

bool	unusedBit_6_31: 1 {}

float	m_pressureTarget_kPa = (float)0

angle_t	nextLobe = (angle_t)0

float	di_nextStart = (float)0

Detailed Description

Definition at line 82 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
     int rpm = Sensor::getOrZero(SensorType::Rpm);
  
     isHpfpInactive = rpm < rpm_spinning_cutoff ||
             !isGdiEngine() ||
             engineConfiguration->hpfpPumpVolume == 0 ||
             !enginePins.hpfpValve.isInitialized();
     // What conditions can we not handle?
     if (isHpfpInactive) {
         m_quantity.reset();
         m_requested_pump = 0;
         m_deadtime = 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_deadtime = 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 204 of file high_pressure_fuel_pump.cpp.

                                                     {
     enginePins.hpfpValve.setLow(HPFP_CONTROLLER);
  
     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);
  
     // 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.scheduling,
             self->m_event.scheduling.getMomentNt(),
             self->m_deadtime + 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 210 of file high_pressure_fuel_pump.cpp.

                                        {
     noValve = !enginePins.hpfpValve.isInitialized();
     if (noValve) {
         m_running = false;
         return;
     }
  
     angle_t lobe = m_lobe.findNextLobe();
     angle_t angle_requested = m_requested_pump;
  
     angleAboveMin = angle_requested > engineConfiguration->hpfpMinAngle;
     if (angleAboveMin) {
         di_nextStart = lobe - angle_requested - m_deadtime;
         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(lobe, "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",
             &m_event, lobe,
             { pinTurnOff, this });
     }
 }