TriggerScheduler Class Reference

#include <trigger_scheduler.h>

Inheritance diagram for TriggerScheduler:

Collaboration diagram for TriggerScheduler:

Public Member Functions
void	schedule (const char *msg, AngleBasedEvent *event, angle_t angle, action_s action)
bool	scheduleOrQueue (const char *msg, AngleBasedEvent *event, efitick_t edgeTimestamp, angle_t angle, action_s action, float currentPhase, float nextPhase)
void	scheduleEventsUntilNextTriggerTooth (float rpm, efitick_t edgeTimestamp, float currentPhase, float nextPhase)
AngleBasedEvent *	getElementAtIndexForUnitTest (int index)
Public Member Functions inherited from EngineModule
virtual void	onConfigurationChange (engine_configuration_s const *)
virtual void	onSlowCallback ()
virtual void	onFastCallback ()
virtual void	onIgnitionStateChanged (bool)
virtual bool	needsDelayedShutoff ()

Private Member Functions
void	schedule (const char *msg, AngleBasedEvent *event, action_s action)
bool	assertNotInList (AngleBasedEvent *head, AngleBasedEvent *element)

Private Attributes
AngleBasedEvent *	m_angleBasedEventsHead = nullptr

Detailed Description

Definition at line 5 of file trigger_scheduler.h.

Member Function Documentation

assertNotInList()

bool TriggerScheduler::assertNotInList ( AngleBasedEvent *  head, AngleBasedEvent *  element  )

private

for example, this might happen in case of sudden RPM change if event was not scheduled by angle but was scheduled by time. In case of scheduling by time with slow RPM the whole next fast revolution might be within the wait

Definition at line 5 of file trigger_scheduler.cpp.

                                                                                      {
    /* this code is just to validate state, no functional load*/
    decltype(head) current;
    int counter = 0;
    LL_FOREACH2(head, current, nextToothEvent) {
        if (++counter > QUEUE_LENGTH_LIMIT) {
            firmwareError(ObdCode::CUSTOM_ERR_LOOPED_QUEUE, "Looped queue?");
            return false;
        }
 
        if (current == element) {
            /**
             * for example, this might happen in case of sudden RPM change if event
             * was not scheduled by angle but was scheduled by time. In case of scheduling
             * by time with slow RPM the whole next fast revolution might be within the wait
             */
            warning(ObdCode::CUSTOM_RE_ADDING_INTO_EXECUTION_QUEUE, "re-adding element into event_queue");
            return true;
        }
    }
 
    return false;
}

Referenced by schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

getElementAtIndexForUnitTest()

AngleBasedEvent * TriggerScheduler::getElementAtIndexForUnitTest

(

int

index

)

Definition at line 169 of file trigger_scheduler.cpp.

                                                                          {
    AngleBasedEvent * current;
 
    LL_FOREACH2(m_angleBasedEventsHead, current, nextToothEvent)
    {
        if (index == 0)
            return current;
        index--;
    }
    criticalError("getElementAtIndexForUnitText: null");
    return nullptr;
}

schedule() [1/2]

void TriggerScheduler::schedule ( const char *  msg, AngleBasedEvent *  event, action_s  action  )

private

Definition at line 67 of file trigger_scheduler.cpp.

                                                                                        {
    if (event->getAngle() < 0) {
        // at the moment we expect API consumer to wrap angle. shall we do the wrapping in the enginePhase setter?
        // i.e. what is the best level to take care of the range constraint?
        criticalError("Negative angle %s %f", msg, event->getAngle());
    }
 
    event->action = action;
 
    {
        chibios_rt::CriticalSectionLocker csl;
 
        // TODO: This is O(n), consider some other way of detecting if in a list,
        // and consider doubly linked or other list tricks.
 
        if (!assertNotInList(m_angleBasedEventsHead, event)) {
            // Use Append to retain some semblance of event ordering in case of
            // time skew.  Thus on events are always followed by off events.
            LL_APPEND2(m_angleBasedEventsHead, event, nextToothEvent);
        }
    }
}

Here is the call graph for this function:

schedule() [2/2]

void TriggerScheduler::schedule	(	const char *	msg,
		AngleBasedEvent *	event,
		angle_t	angle,
		action_s	action
	)

Definition at line 29 of file trigger_scheduler.cpp.

                                                                                                       {
    event->setAngle(angle);
 
    schedule(msg, event, action);
}

Referenced by schedule(), and scheduleOrQueue().

Here is the call graph for this function:

Here is the caller graph for this function:

scheduleEventsUntilNextTriggerTooth()

void TriggerScheduler::scheduleEventsUntilNextTriggerTooth	(	float	rpm,
		efitick_t	edgeTimestamp,
		float	currentPhase,
		float	nextPhase
	)

Definition at line 90 of file trigger_scheduler.cpp.

                                                                                             {
 
    if (!isValidRpm(rpm)) {
         // this might happen for instance in case of a single trigger event after a pause
        return;
    }
 
    AngleBasedEvent *current, *tmp, *keephead;
    AngleBasedEvent *keeptail = nullptr;
 
    {
        chibios_rt::CriticalSectionLocker csl;
 
        keephead = m_angleBasedEventsHead;
        m_angleBasedEventsHead = nullptr;
    }
 
    LL_FOREACH_SAFE2(keephead, current, tmp, nextToothEvent)
    {
        if (current->shouldSchedule(currentPhase, nextPhase)) {
            // time to fire a spark which was scheduled previously
 
            // Yes this looks like O(n^2), but that's only over the entire engine
            // cycle.  It's really O(mn + nn) where m = # of teeth and n = # events
            // fired per cycle.  The number of teeth outweigh the number of events, at
            // least for 60-2....  So odds are we're only firing an event or two per
            // tooth, which means the outer loop is really only O(n).  And if we are
            // firing many events per teeth, then it's likely the events before this
            // one also fired and thus the call to LL_DELETE2 is closer to O(1).
            LL_DELETE2(keephead, current, nextToothEvent);
 
            scheduling_s * sDown = &current->eventScheduling;
 
#if SPARK_EXTREME_LOGGING
            efiPrintf("time to invoke [%.1f, %.1f) %d %d",
                  currentPhase, nextPhase, getRevolutionCounter(), time2print(getTimeNowUs()));
#endif /* SPARK_EXTREME_LOGGING */
 
            // In case this event was scheduled by overdwell protection, cancel it so
            // we can re-schedule at the correct time
            // [tag:overdwell]
            engine->scheduler.cancel(sDown);
 
            scheduleByAngle(
                sDown,
                edgeTimestamp,
                current->getAngleFromNow(currentPhase),
                current->action
            );
        } else {
            keeptail = current; // Used for fast list concatenation
        }
    }
 
    if (keephead) {
        chibios_rt::CriticalSectionLocker csl;
 
        // Put any new entries onto the end of the keep list
        keeptail->nextToothEvent = m_angleBasedEventsHead;
        m_angleBasedEventsHead = keephead;
    }
}

Here is the call graph for this function:

scheduleOrQueue()

bool TriggerScheduler::scheduleOrQueue	(	const char *	msg,
		AngleBasedEvent *	event,
		efitick_t	edgeTimestamp,
		angle_t	angle,
		action_s	action,
		float	currentPhase,
		float	nextPhase
	)

Schedules 'action' to occur at engine cycle angle 'angle'.

Returns

true if event corresponds to current tooth and was time-based scheduler false if event was put into queue for scheduling at a later tooth

Definition at line 41 of file trigger_scheduler.cpp.

                                             {
    event->setAngle(angle);
 
    // *kludge* naming mess: if (shouldSchedule) { scheduleByAngle } else { schedule } see header for more details
    if (event->shouldSchedule(currentPhase, nextPhase)) {
        // if we're due now, just schedule the event
        scheduleByAngle(
            &event->eventScheduling,
            edgeTimestamp,
            event->getAngleFromNow(currentPhase),
            action
        );
 
        return true;
    } else {
        // If not due now, add it to the queue to be scheduled later
        schedule(msg, event, action);
 
        return false;
    }
}

Here is the call graph for this function:

Field Documentation

m_angleBasedEventsHead

AngleBasedEvent* TriggerScheduler::m_angleBasedEventsHead = nullptr

private

That's the linked list of pending events scheduled in relation to trigger At the moment we iterate over the whole list while looking for events for specific trigger index We can make it an array of lists per trigger index, but that would take some RAM and probably not needed yet.

Definition at line 38 of file trigger_scheduler.h.

Referenced by getElementAtIndexForUnitTest(), schedule(), and scheduleEventsUntilNextTriggerTooth().

---

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

• controllers/system/timer/trigger_scheduler.h
• controllers/system/timer/trigger_scheduler.cpp