CanWrite Class Reference

#include <can.h>

Inheritance diagram for CanWrite:

Collaboration diagram for CanWrite:

Public Member Functions
	CanWrite ()
void	PeriodicTask (efitick_t nowNt) override
	Called periodically. Override this method to do work for your controller.
Public Member Functions inherited from PeriodicController< 512 >
	PeriodicController (const char *name, tprio_t priority, float frequencyHz)
	PeriodicController (const char *name)
void	setPeriod (int periodMs)
Public Member Functions inherited from ThreadController< TStackSize >
	ThreadController (const char *name, tprio_t priority)
void	start ()
	Start the thread.
void	stop ()
	Request thread termination and waits for termination.

Additional Inherited Members
Protected Member Functions inherited from PeriodicController< 512 >
virtual void	OnStarted ()
	Called before running the periodic task. Optionally override this method to set up.
Protected Member Functions inherited from ThreadController< TStackSize >
void	main () override
Protected Attributes inherited from ThreadController< TStackSize >
const char *const	m_name

Detailed Description

Definition at line 58 of file can.h.

Constructor & Destructor Documentation

CanWrite()

CanWrite::CanWrite

(

)

Definition at line 24 of file can_tx.cpp.

    : PeriodicController("CAN TX", PRIO_CAN_TX, CAN_CYCLE_FREQ)
{
}

Member Function Documentation

PeriodicTask()

void CanWrite::PeriodicTask ( efitick_t  nowNt )

overridevirtual

Called periodically. Override this method to do work for your controller.

Implements PeriodicController< 512 >.

Definition at line 50 of file can_tx.cpp.

                                     {
    ScopePerf pc(PE::CanThreadTx);
    CanCycle cycle(m_cycleCount);
 
    //in case we have Verbose Can enabled, we should keep user configured period
    if (engineConfiguration->enableVerboseCanTx) {
      // slow down verbose CAN while in serial CAN
    int canSleepPeriodMs = (engine->pauseCANdueToSerial ? 5 : 1) * engineConfiguration->canSleepPeriodMs;
 
        auto roundedInterval = roundTxPeriodToCycle(canSleepPeriodMs);
        if (cycle.isInterval(roundedInterval)) {
                void sendCanVerbose();
                sendCanVerbose();
        }
    }
 
    CanListener* current = canListeners_head;
 
    while (current) {
        current = current->request();
    }
 
    if (cycle.isInterval(CI::_MAX_Cycle)) {
        //we now reset cycleCount since we reached max cycle count
        m_cycleCount = 0;
    }
 
    updateDash(cycle);
 
  if (engineConfiguration->enableExtendedCanBroadcast || isHwQcMode()) {
      if (cycle.isInterval(CI::_100ms)) {
        sendQcBenchEventCounters();
        sendQcBenchRawAnalogValues();
#ifdef HW_HELLEN_8CHAN
        sendQcBenchEventCounters(/*bus*/1);
        sendQcBenchRawAnalogValues(/*bus*/1);
#endif
      }
 
      if (cycle.isInterval(CI::_250ms)) {
          sendQcBenchBoardStatus();
#ifdef HW_HELLEN_8CHAN
          sendQcBenchBoardStatus(/*bus*/1);
#endif
          sendQcBenchButtonCounters();
          sendQcBenchAuxDigitalCounters();
      }
    }
 
    if (engineConfiguration->enableAemXSeries && cycle.isInterval(CI::_50ms) && boardEnableSendWidebandInfo()) {
        sendWidebandInfo();
    }
 
    m_cycleCount++;
}

Here is the call graph for this function:

---

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

• controllers/can/can.h
• controllers/can/can_tx.cpp