InjectionEvent Class Reference

#include <fuel_schedule.h>

Collaboration diagram for InjectionEvent:

Public Member Functions
	InjectionEvent ()=default
bool	update ()
void	onTriggerTooth (efitick_t nowNt, float currentPhase, float nextPhase)
WallFuel &	getWallFuel ()
void	setIndex (uint8_t index)

Data Fields
InjectorOutputPin *	outputs [MAX_WIRES_COUNT] {}
InjectorOutputPin *	outputsStage2 [MAX_WIRES_COUNT] {}
float	injectionStartAngle = 0

Private Member Functions
bool	updateInjectionAngle ()
expected< float >	computeInjectionAngle () const

Private Attributes
bool	isSimultaneous = false
uint8_t	ownIndex = 0
uint8_t	cylinderNumber = 0
WallFuel	wallFuel {}

Detailed Description

Definition at line 16 of file fuel_schedule.h.

Constructor & Destructor Documentation

InjectionEvent()

InjectionEvent::InjectionEvent ( )

default

Member Function Documentation

computeInjectionAngle()

expected< float > InjectionEvent::computeInjectionAngle ( ) const

private

Definition at line 78 of file fuel_schedule.cpp.

                                                            {
    floatus_t oneDegreeUs = getEngineRotationState()->getOneDegreeUs(); // local copy
    if (std::isnan(oneDegreeUs)) {
        // in order to have fuel schedule we need to have current RPM
        // wonder if this line slows engine startup?
        return unexpected;
    }
 
    float fuelMs = getEngineState()->injectionDuration;
    if (std::isnan(fuelMs)) {
        return unexpected;
    }
 
    // injection phase may be scheduled by injection end, so we need to step the angle back
    // for the duration of the injection
    angle_t injectionDurationAngle = getInjectionAngleCorrection(fuelMs, oneDegreeUs);
 
    // User configured offset - degrees after TDC combustion
    floatus_t injectionOffset = getEngineState()->injectionOffset;
    if (std::isnan(injectionOffset)) {
        // injection offset map not ready - we are not ready to schedule fuel events
        return unexpected;
    }
 
    angle_t openingAngle = injectionOffset - injectionDurationAngle;
    assertAngleRange(openingAngle, "openingAngle_r", ObdCode::CUSTOM_ERR_6554);
    wrapAngle(openingAngle, "addFuel#1", ObdCode::CUSTOM_ERR_6555);
    // TODO: should we log per-cylinder injection timing? #76
    getTunerStudioOutputChannels()->injectionOffset = openingAngle;
 
    // Convert from cylinder-relative to cylinder-1-relative
    openingAngle += getPerCylinderFiringOrderOffset(ownIndex, cylinderNumber);
 
    efiAssert(ObdCode::CUSTOM_ERR_ASSERT, !std::isnan(openingAngle), "findAngle#3", false);
    assertAngleRange(openingAngle, "findAngle#a33", ObdCode::CUSTOM_ERR_6544);
 
    wrapAngle(openingAngle, "addFuel#2", ObdCode::CUSTOM_ERR_6555);
 
#if EFI_UNIT_TEST
//  printf("registerInjectionEvent openingAngle=%.2f inj %d\r\n", openingAngle, cylinderNumber);
#endif
 
    return openingAngle;
}

Referenced by updateInjectionAngle().

Here is the call graph for this function:

Here is the caller graph for this function:

getWallFuel()

WallFuel & InjectionEvent::getWallFuel

(

)

Definition at line 39 of file fuel_schedule.cpp.

                                      {
    return wallFuel;
}

Referenced by getLiveData(), resetAccel(), and updateFuelInfo().

Here is the caller graph for this function:

onTriggerTooth()

void InjectionEvent::onTriggerTooth	(	efitick_t	nowNt,
		float	currentPhase,
		float	nextPhase
	)

Definition at line 78 of file main_trigger_callback.cpp.

                                                                                        {
    auto eventAngle = injectionStartAngle;
 
    // Determine whether our angle is going to happen before (or near) the next tooth
    if (!isPhaseInRange(eventAngle, currentPhase, nextPhase)) {
        return;
    }
 
    // Select fuel mass from the correct cylinder
    auto injectionMassGrams = getEngineState()->injectionMass[this->cylinderNumber];
 
    // Perform wall wetting adjustment on fuel mass, not duration, so that
    // it's correct during fuel pressure (injector flow) or battery voltage (deadtime) transients
    // TODO: is it correct to wall wet on both pulses?
    injectionMassGrams = wallFuel.adjust(injectionMassGrams);
 
    // Disable staging in simultaneous mode
    float stage2Fraction = isSimultaneous ? 0 : getEngineState()->injectionStage2Fraction;
 
    // Compute fraction of fuel on stage 2, remainder goes on stage 1
    const float injectionMassStage2 = stage2Fraction * injectionMassGrams;
    float injectionMassStage1 = injectionMassGrams - injectionMassStage2;
 
#if EFI_VEHICLE_SPEED
    {
        // Log this fuel as consumed
 
        bool isCranking = getEngineRotationState()->isCranking();
        int numberOfInjections = isCranking ? getNumberOfInjections(engineConfiguration->crankingInjectionMode) : getNumberOfInjections(engineConfiguration->injectionMode);
 
        float actualInjectedMass = numberOfInjections * (injectionMassStage1 + injectionMassStage2);
 
#ifdef MODULE_ODOMETER
        engine->module<TripOdometer>()->consumeFuel(actualInjectedMass, nowNt);
#endif // MODULE_ODOMETER
 
    }
#endif // EFI_VEHICLE_SPEED
 
    const floatms_t injectionDurationStage1 = engine->module<InjectorModelPrimary>()->getInjectionDuration(injectionMassStage1);
    const floatms_t injectionDurationStage2 = injectionMassStage2 > 0 ? engine->module<InjectorModelSecondary>()->getInjectionDuration(injectionMassStage2) : 0;
 
#if EFI_PRINTF_FUEL_DETAILS
    if (printFuelDebug) {
        printf("fuel injectionDuration=%.2fms adjusted=%.2fms\n",
                getEngineState()->injectionDuration,
          injectionDurationStage1);
    }
#endif /*EFI_PRINTF_FUEL_DETAILS */
 
    if (this->cylinderNumber == 0) {
        if (engine->outputChannels.actualLastInjection) {
            engine->outputChannels.actualLastInjectionRatio = injectionDurationStage1 / engine->outputChannels.actualLastInjection;
        } else {
            engine->outputChannels.actualLastInjectionRatio = 0;
        }
        if (engine->outputChannels.actualLastInjectionStage2) {
            engine->outputChannels.actualLastInjectionRatioStage2 = injectionDurationStage2 / engine->outputChannels.actualLastInjectionStage2;
        } else {
            engine->outputChannels.actualLastInjectionRatioStage2 = 0;
        }
        engine->outputChannels.actualLastInjection = injectionDurationStage1;
        engine->outputChannels.actualLastInjectionStage2 = injectionDurationStage2;
    }
 
    if (std::isnan(injectionDurationStage1) || std::isnan(injectionDurationStage2)) {
        warning(ObdCode::CUSTOM_OBD_NAN_INJECTION, "NaN injection pulse");
        return;
    }
    if (injectionDurationStage1 < 0) {
        warning(ObdCode::CUSTOM_OBD_NEG_INJECTION, "Negative injection pulse %.2f", injectionDurationStage1);
        return;
    }
 
    // If somebody commanded an impossibly short injection, do nothing.
    // Durations under 50us-ish aren't safe for the scheduler
    // as their order may be swapped, resulting in a stuck open injector
    // see https://github.com/rusefi/rusefi/pull/596 for more details
    if (injectionDurationStage1 < 0.050f)
    {
        return;
    }
 
    floatus_t durationUsStage1 = MS2US(injectionDurationStage1);
    floatus_t durationUsStage2 = MS2US(injectionDurationStage2);
 
    // Only bother with the second stage if it's long enough to be relevant
    bool hasStage2Injection = durationUsStage2 > 50;
 
#if EFI_PRINTF_FUEL_DETAILS
    if (printFuelDebug) {
        InjectorOutputPin *output = outputs[0];
        printf("handleFuelInjectionEvent fuelout %s injection_duration %dus engineCycleDuration=%.1fms\t\n", output->getName(), (int)durationUsStage1,
                (int)MS2US(getCrankshaftRevolutionTimeMs(Sensor::getOrZero(SensorType::Rpm))) / 1000.0);
    }
#endif /*EFI_PRINTF_FUEL_DETAILS */
 
    action_s startAction, endActionStage1, endActionStage2;
    // We use different callbacks based on whether we're running sequential mode or not - everything else is the same
    if (isSimultaneous) {
        startAction = action_s::make<startSimultaneousInjection>();
        endActionStage1 = action_s::make<endSimultaneousInjection>(this);
    } else {
        auto const taggedPointer{TaggedPointer<decltype(this)>::make(this, hasStage2Injection)};
 
        // sequential or batch
        startAction = action_s::make<turnInjectionPinHigh>( taggedPointer.getRaw() );
        endActionStage1 = action_s::make<turnInjectionPinLow>( this );
        endActionStage2 = action_s::make<turnInjectionPinLowStage2>( this );
    }
 
    // Correctly wrap injection start angle
    float angleFromNow = eventAngle - currentPhase;
    if (angleFromNow < 0) {
        angleFromNow += getEngineState()->engineCycle;
    }
 
    // Schedule opening (stage 1 + stage 2 open together)
    efitick_t startTime = scheduleByAngle(nullptr, nowNt, angleFromNow, startAction);
 
    // Schedule closing stage 1
    efitick_t turnOffTimeStage1 = startTime + US2NT((int)durationUsStage1);
    getScheduler()->schedule("inj", nullptr, turnOffTimeStage1, endActionStage1);
 
    // Schedule closing stage 2 (if applicable)
    if (hasStage2Injection && endActionStage2) {
        efitick_t turnOffTimeStage2 = startTime + US2NT((int)durationUsStage2);
        getScheduler()->schedule("inj stage 2", nullptr, turnOffTimeStage2, endActionStage2);
    }
 
#if EFI_DETAILED_LOGGING
    printf("scheduling injection angle=%.2f/delay=%d injectionDuration=%d %d\r\n", angleFromNow, (int)NT2US(startTime - nowNt), (int)durationUsStage1, (int)durationUsStage2);
#endif
#if EFI_DETAILED_LOGGING
    efiPrintf("handleFuel pin=%s eventIndex %d duration=%.2fms %d", outputs[0]->name,
            injEventIndex,
            injectionDurationStage1,
            getRevolutionCounter());
    efiPrintf("handleFuel pin=%s delay=%.2f %d", outputs[0]->name, NT2US(startTime - nowNt),
            getRevolutionCounter());
#endif /* EFI_DETAILED_LOGGING */
}

Referenced by FuelSchedule::onTriggerTooth().

Here is the call graph for this function:

Here is the caller graph for this function:

setIndex()

void InjectionEvent::setIndex ( uint8_t  index )

inline

Definition at line 27 of file fuel_schedule.h.

                                 {
        ownIndex = index;
    }

Referenced by FuelSchedule::FuelSchedule().

Here is the caller graph for this function:

update()

bool InjectionEvent::update

(

)

Returns

false in case of error, true if success

also fire the 2nd half of the injectors so that we can implement a batch mode on individual wires

Definition at line 142 of file fuel_schedule.cpp.

                            {
    bool updatedAngle = updateInjectionAngle();
 
    if (!updatedAngle) {
        return false;
    }
 
    injection_mode_e mode = getCurrentInjectionMode();
    engine->outputChannels.currentInjectionMode = static_cast<uint8_t>(mode);
 
    int injectorIndex;
    if (mode == IM_SIMULTANEOUS || mode == IM_SINGLE_POINT) {
        // These modes only have one injector
        injectorIndex = 0;
    } else if (mode == IM_SEQUENTIAL || mode == IM_BATCH) {
        // Map order index -> cylinder index (firing order)
        injectorIndex = getCylinderNumberAtIndex(ownIndex);
    } else {
        firmwareError(ObdCode::CUSTOM_OBD_UNEXPECTED_INJECTION_MODE, "Unexpected injection mode %d", mode);
        injectorIndex = 0;
    }
 
    InjectorOutputPin *secondOutput;
    InjectorOutputPin* secondOutputStage2;
 
    if (mode == IM_BATCH) {
        /**
         * also fire the 2nd half of the injectors so that we can implement a batch mode on individual wires
         */
        // Compute the position of this cylinder's twin in the firing order
        // Each injector gets fired as a primary (the same as sequential), but also
        // fires the injector 360 degrees later in the firing order.
        int secondOrder = (ownIndex + (engineConfiguration->cylindersCount / 2)) % engineConfiguration->cylindersCount;
        int secondIndex = getCylinderNumberAtIndex(secondOrder);
        secondOutput = &enginePins.injectors[secondIndex];
        secondOutputStage2 = &enginePins.injectorsStage2[secondIndex];
    } else {
        secondOutput = nullptr;
        secondOutputStage2 = nullptr;
    }
 
    InjectorOutputPin *output = &enginePins.injectors[injectorIndex];
 
    outputs[0] = output;
    outputs[1] = secondOutput;
    isSimultaneous = mode == IM_SIMULTANEOUS;
    // Stash the cylinder number so we can select the correct fueling bank later
    cylinderNumber = injectorIndex;
 
    outputsStage2[0] = &enginePins.injectorsStage2[injectorIndex];
    outputsStage2[1] = secondOutputStage2;
 
    if (!isSimultaneous && !output->isInitialized()) {
        // todo: extract method for this index math
        warning(ObdCode::CUSTOM_OBD_INJECTION_NO_PIN_ASSIGNED, "no_pin_inj #%s", output->getName());
    }
 
    return true;
}

Referenced by FuelSchedule::addFuelEvents().

Here is the call graph for this function:

Here is the caller graph for this function:

updateInjectionAngle()

bool InjectionEvent::updateInjectionAngle ( )

private

Definition at line 123 of file fuel_schedule.cpp.

                                          {
    auto result = computeInjectionAngle();
 
    if (result) {
        // If injector duty cycle is high, lock injection SOI so that we
        // don't miss injections at or above 100% duty
        if (getEngineState()->shouldUpdateInjectionTiming) {
            injectionStartAngle = result.Value;
        }
 
        return true;
    } else {
        return false;
    }
}

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

cylinderNumber

uint8_t InjectionEvent::cylinderNumber = 0

private

Definition at line 44 of file fuel_schedule.h.

Referenced by computeInjectionAngle(), onTriggerTooth(), and update().

injectionStartAngle

float InjectionEvent::injectionStartAngle = 0

Definition at line 52 of file fuel_schedule.h.

Referenced by onTriggerTooth(), and updateInjectionAngle().

isSimultaneous

bool InjectionEvent::isSimultaneous = false

private

This is a performance optimization for IM_SIMULTANEOUS fuel strategy. It's more efficient to handle all injectors together if that's the case

Definition at line 42 of file fuel_schedule.h.

Referenced by onTriggerTooth(), and update().

outputs

InjectorOutputPin* InjectionEvent::outputs[MAX_WIRES_COUNT] {}

Definition at line 50 of file fuel_schedule.h.

{};

Referenced by onTriggerTooth(), turnInjectionPinLow(), and update().

outputsStage2

InjectorOutputPin* InjectionEvent::outputsStage2[MAX_WIRES_COUNT] {}

Definition at line 51 of file fuel_schedule.h.

{};

Referenced by turnInjectionPinLowStage2(), and update().

ownIndex

uint8_t InjectionEvent::ownIndex = 0

private

Definition at line 43 of file fuel_schedule.h.

Referenced by computeInjectionAngle(), setIndex(), and update().

wallFuel

WallFuel InjectionEvent::wallFuel {}

private

Definition at line 46 of file fuel_schedule.h.

{};

Referenced by getWallFuel(), and onTriggerTooth().

---

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

• controllers/engine_cycle/fuel_schedule.h
• controllers/engine_cycle/fuel_schedule.cpp
• controllers/engine_cycle/main_trigger_callback.cpp