Detailed Description

Date: Mar 19, 2020

Author: Matthew Kennedy, (c) 2020

Definition in file can.h.

Data Structures
class	CanWrite

class	CanCycle

Typedefs
using	CI = CanInterval

Enumerations
enum class	CanInterval : uint16_t { None = 0 , _5ms = 1 << 0 , _10ms = 1 << 1 , _20ms = 1 << 2 , _50ms = 1 << 3 , _100ms = 1 << 4 , _200ms = 1 << 5 , _250ms = 1 << 6 , _500ms = 1 << 7 , _1000ms = 1 << 8 , _MAX_Cycle = _1000ms }

Functions
void	resetCanWriteCycle ()

void	processCanRxMessage (const size_t busIndex, const CANRxFrame &msg, efitick_t nowNt)

void	registerCanListener (CanListener &listener)

void	unregisterCanListener (CanListener &listener)

void	registerCanSensor (CanSensorBase &sensor)

constexpr CI	operator\| (CI lhs, CI rhs)

constexpr CI	operator& (CI lhs, CI rhs)

constexpr CI &	operator\|= (CI &lhs, CI rhs)

Typedef Documentation

◆ CI

using CI = CanInterval

Definition at line 68 of file can.h.

Enumeration Type Documentation

◆ CanInterval

enum class CanInterval : uint16_t

strong

Enumerator
None
_5ms
_10ms
_20ms
_50ms
_100ms
_200ms
_250ms
_500ms
_1000ms
_MAX_Cycle

Definition at line 29 of file can.h.

                       : uint16_t {
    None    = 0,
    _5ms    = 1 << 0,
    _10ms   = 1 << 1,
    _20ms   = 1 << 2,
    _50ms   = 1 << 3,
    _100ms  = 1 << 4,
    _200ms  = 1 << 5,
    _250ms  = 1 << 6,
    _500ms  = 1 << 7,
    _1000ms = 1 << 8,
    _MAX_Cycle = _1000ms,
};

Function Documentation

◆ operator&()

constexpr CI operator&	(	CI	lhs,
		CI	rhs
	)

constexpr

Definition at line 76 of file can.h.

                                        {
    using T = std::underlying_type_t<CI>;
    return static_cast<CI>(static_cast<T>(lhs) & static_cast<T>(rhs));
}

◆ operator|()

constexpr CI operator\|	(	CI	lhs,
		CI	rhs
	)

constexpr

Definition at line 71 of file can.h.

                                        {
    using T = std::underlying_type_t<CI>;
    return static_cast<CI>(static_cast<T>(lhs) | static_cast<T>(rhs));
}

◆ operator|=()

constexpr CI & operator\|=	(	CI &	lhs,
		CI	rhs
	)

constexpr

Definition at line 81 of file can.h.

                                           {
    lhs = lhs | rhs;
    return lhs;
}

◆ processCanRxMessage()

void processCanRxMessage	(	const size_t	busIndex,
		const CANRxFrame &	msg,
		efitick_t	nowNt
	)

Definition at line 227 of file can_rx.cpp.

                                                                                          {
    if (verboseRxCan ||
        (engineConfiguration->verboseCan && busIndex == 0) ||
        (engineConfiguration->verboseCan2 && busIndex == 1) ||
#if (EFI_CAN_BUS_COUNT >= 3)
        (engineConfiguration->verboseCan3 && busIndex == 2) ||
#endif
        0) {
        printCANRxFrame(busIndex, frame);
    }
 
    // TODO use call_board_override
    if (custom_board_can_rx.has_value()) {
        custom_board_can_rx.value()(busIndex, frame, nowNt);
    }
 
    // see AemXSeriesWideband as an example of CanSensorBase/CanListener
    serviceCanSubscribers(busIndex, frame, nowNt);
 
    // todo: convert to CanListener or not?
    //Vss is configurable, should we handle it here:
    processCanRxVss(frame, nowNt);
 
    if (!engineConfiguration->useSpiImu) {
        // todo: convert to CanListener or not?
        processCanRxImu(frame);
    }
 
/*
static Timer dashAliveTimer;
 
  if (CAN_EID(frame) == (int)bench_test_packet_ids_e::DASH_ALIVE) {
    // todo: add an indicator that dash is connected?
    dashAliveTimer.reset();
  }
*/
 
    processCanQcBenchTest(frame);
    processCanEcuControl(frame);
 
    processLuaCan(busIndex, frame);
 
    {
        obdOnCanPacketRx(frame, busIndex);
    }
 
#if EFI_ENGINE_CONTROL
    if (CAN_EID(frame) == GDI4_BASE_ADDRESS && frame.data8[7] == GDI4_MAGIC) {
//      efiPrintf("CAN GDI4 says hi");
        getLimpManager()->externalGdiCanBusComms.reset();
    }
#endif // EFI_ENGINE_CONTROL
 
    handleWidebandCan(busIndex, frame);
#if EFI_USE_OPENBLT
#include "openblt/efi_blt_ids.h"
    if ((CAN_SID(frame) == BOOT_COM_CAN_RX_MSG_ID) && (frame.DLC == 2)) {
        /* TODO: gracefull shutdown? */
        if (((busIndex == 0) && (engineConfiguration->canOpenBLT)) ||
            ((busIndex == 1) && (engineConfiguration->can2OpenBLT))) {
            jump_to_openblt();
        }
    }
#endif
}

Here is the call graph for this function:

◆ registerCanListener()

void registerCanListener ( CanListener & listener )

Definition at line 86 of file can_rx.cpp.

                                                {
    // Do this under lock?
 
    // If the listener already has a next, it's already registered
    if (!listener.getNext()) {
        listener.setNext(canListeners_head);
        canListeners_head = &listener;
    }
}

Referenced by CanTransport::init(), initCanGpioMsiobox(), IsoTpRx::IsoTpRx(), and registerCanSensor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ registerCanSensor()

void registerCanSensor ( CanSensorBase & sensor )

Definition at line 116 of file can_rx.cpp.

                                              {
    registerCanListener(sensor);
    sensor.Register();
}

Referenced by initCanSensors(), initEgt(), and initLambda().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resetCanWriteCycle()

void resetCanWriteCycle ( )

Definition at line 45 of file can_tx.cpp.

                            {
  m_cycleCount = 0;
}

◆ unregisterCanListener()

void unregisterCanListener ( CanListener & listener )

Definition at line 96 of file can_rx.cpp.

                                                  {
    // Do this under lock?
 
    // listener is at head of list...
    if (canListeners_head == &listener) {
        canListeners_head = listener.getNext();
    } else {
        CanListener *current = canListeners_head;
 
        while (current->getNext() && (current->getNext() != &listener)) {
            current = current->getNext();
        }
        if (current->getNext()) {
            current->setNext(listener.getNext());
        }
    }
 
    listener.setNext(nullptr);
}