Detailed Description

Main logic is here!

Date: Feb 7, 2013

Author: Andrey Belomutskiy, (c) 2012-2020

This file is part of rusEfi - see http://rusefi.com

rusEfi is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

rusEfi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file main_trigger_callback.cpp.

Functions
void	endSimultaneousInjection (InjectionEvent *event)

void	turnInjectionPinLow (InjectionEvent *event)

static void	turnInjectionPinLowStage2 (InjectionEvent *event)

static void	handleFuel (efitick_t nowNt, float currentPhase, float nextPhase)

void	mainTriggerCallback (uint32_t trgEventIndex, efitick_t edgeTimestamp, angle_t currentPhase, angle_t nextPhase)

Variables
bool	printFuelDebug = false

Function Documentation

◆ endSimultaneousInjection()

void endSimultaneousInjection ( InjectionEvent * event )

Definition at line 50 of file main_trigger_callback.cpp.

                                                      {
     endSimultaneousInjectionOnlyTogglePins();
     event->update();
 }

Referenced by InjectionEvent::onTriggerTooth().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handleFuel()

static void handleFuel	(	efitick_t	nowNt,
		float	currentPhase,
		float	nextPhase
	)

static

Definition at line 213 of file main_trigger_callback.cpp.

                                                                              {
     ScopePerf perf(PE::HandleFuel);
  
     efiAssertVoid(ObdCode::CUSTOM_STACK_6627, hasLotsOfRemainingStack(), "lowstck#3");
  
     LimpState limitedFuelState = getLimpManager()->allowInjection();
  
     // todo: eliminate state copy logic by giving limpManager it's owm limp_manager.txt and leveraging LiveData
     engine->outputChannels.fuelCutReason = (int8_t)limitedFuelState.reason;
     bool limitedFuel = !limitedFuelState.value;
     if (limitedFuel) {
         return;
     }
  
     // This is called in the fast callback already, but since we may have just achieved engine sync (and RPM)
     // for the first time, force update the schedule so that we can inject immediately if necessary
     FuelSchedule *fs = getFuelSchedule();
     if (!fs->isReady) {
         fs->addFuelEvents();
     }
  
 #if FUEL_MATH_EXTREME_LOGGING
     if (printFuelDebug) {
         efiPrintf("handleFuel [%.1f, %.1f) %d", currentPhase, nextPhase, getRevolutionCounter());
     }
 #endif /* FUEL_MATH_EXTREME_LOGGING */
  
     fs->onTriggerTooth(nowNt, currentPhase, nextPhase);
 }

Referenced by mainTriggerCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mainTriggerCallback()

void mainTriggerCallback	(	uint32_t	trgEventIndex,
		efitick_t	edgeTimestamp,
		angle_t	currentPhase,
		angle_t	nextPhase
	)

This is the main trigger event handler. Both injection and ignition are controlled from this method.

In case on a major error we should not process any more events.

For fuel we schedule start of injection based on trigger angle, and then inject for specified duration of time

For spark we schedule both start of coil charge and actual spark based on trigger angle

Definition at line 247 of file main_trigger_callback.cpp.

                                                                                                                    {
     ScopePerf perf(PE::MainTriggerCallback);
  
 #if ! HW_CHECK_MODE
     if (hasFirmwareError()) {
         /**
          * In case on a major error we should not process any more events.
          */
         return;
     }
 #endif // HW_CHECK_MODE
  
     int rpm = engine->rpmCalculator.getCachedRpm();
     if (rpm == 0) {
         // this happens while we just start cranking
  
         // todo: check for 'trigger->is_synchnonized?'
         return;
     }
     if (rpm == NOISY_RPM) {
         warning(ObdCode::OBD_Crankshaft_Position_Sensor_A_Circuit_Malfunction, "noisy trigger");
         return;
     }
  
  
     if (trgEventIndex == 0) {
  
         if (getTriggerCentral()->checkIfTriggerConfigChanged()) {
             getIgnitionEvents()->isReady = false; // we need to rebuild complete ignition schedule
             getFuelSchedule()->isReady = false;
             // moved 'triggerIndexByAngle' into trigger initialization (why was it invoked from here if it's only about trigger shape & optimization?)
             // see updateTriggerWaveform() -> prepareOutputSignals()
  
             // we need this to apply new 'triggerIndexByAngle' values
             engine->periodicFastCallback();
         }
     }
  
     /**
      * For fuel we schedule start of injection based on trigger angle, and then inject for
      * specified duration of time
      */
     handleFuel(edgeTimestamp, currentPhase, nextPhase);
  
     engine->module<TriggerScheduler>()->scheduleEventsUntilNextTriggerTooth(
         rpm, edgeTimestamp, currentPhase, nextPhase);
  
     /**
      * For spark we schedule both start of coil charge and actual spark based on trigger angle
      */
     onTriggerEventSparkLogic(rpm, edgeTimestamp, currentPhase, nextPhase);
 }

Referenced by TriggerCentral::handleShaftSignal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ turnInjectionPinLow()

void turnInjectionPinLow ( InjectionEvent * event )

Definition at line 55 of file main_trigger_callback.cpp.

                                                 {
     efitick_t nowNt = getTimeNowNt();
  
     for (size_t i = 0; i < efi::size(event->outputs); i++) {
         InjectorOutputPin *output = event->outputs[i];
         if (output) {
             output->close(nowNt);
         }
     }
     event->update();
 }

Referenced by InjectionEvent::onTriggerTooth().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ turnInjectionPinLowStage2()

static void turnInjectionPinLowStage2 ( InjectionEvent * event )

static

Definition at line 67 of file main_trigger_callback.cpp.

                                                              {
     efitick_t nowNt = getTimeNowNt();
  
     for (size_t i = 0; i < efi::size(event->outputsStage2); i++) {
         InjectorOutputPin *output = event->outputsStage2[i];
         if (output) {
             output->close(nowNt);
         }
     }
 }