Detailed Description

CAN reception handling. This file handles multiplexing incoming CAN frames as appropriate to the subsystems that consume them.

Date: Mar 19, 2020

Author: Matthew Kennedy, (c) 2020

Definition in file can_rx.cpp.

Functions
void	printCANRxFrame (const size_t busIndex, const CANRxFrame &rx)

void	serviceCanSubscribers (const size_t busIndex, const CANRxFrame &frame, efitick_t nowNt)

void	registerCanListener (CanListener &listener)

void	unregisterCanListener (CanListener &listener)

void	registerCanSensor (CanSensorBase &sensor)

uint32_t	getFourBytesLsb (const CANRxFrame &frame, int offset)

uint16_t	getTwoBytesLsb (const CANRxFrame &frame, int offset)

uint16_t	getTwoBytesMsb (const CANRxFrame &frame, int offset)

static int16_t	getShiftedLSB_intel (const CANRxFrame &frame, int offset)

static void	processCanRxImu_BoschM5_10_YawY (const CANRxFrame &frame)

static void	processCanRxImu_BoschM5_10_RollX (const CANRxFrame &frame)

static void	processCanRxImu_BoschM5_10_Z (const CANRxFrame &frame)

static void	processCanRxImu (const CANRxFrame &frame)

void	boardProcessCanRxMessage (const size_t, const CANRxFrame &, efitick_t)

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

Variables
static CanListenerTailSentinel	tailSentinel

CanListener *	canListeners_head = &tailSentinel

bool	verboseRxCan

std::optional< board_can_rx_type >	custom_board_can_rx

Function Documentation

◆ boardProcessCanRxMessage()

void boardProcessCanRxMessage	(	const size_t	,
		const CANRxFrame &	,
		efitick_t
	)

Definition at line 220 of file can_rx.cpp.

                                                                           {
 // this is here to indicate that migration is required
 // todo: remove in 2026
}

◆ getFourBytesLsb()

uint32_t getFourBytesLsb	(	const CANRxFrame &	frame,
		int	offset
	)

Definition at line 143 of file can_rx.cpp.

                                                              {
    return (frame.data8[offset + 3] << 24) +
        (frame.data8[offset + 2] << 16) +
        (frame.data8[offset + 1] << 8) +
        frame.data8[offset];
}

Referenced by processCanRequestCalibration().

Here is the caller graph for this function:

◆ getShiftedLSB_intel()

static int16_t getShiftedLSB_intel	(	const CANRxFrame &	frame,
		int	offset
	)

static

Definition at line 158 of file can_rx.cpp.

                                                                        {
    return getTwoBytesLsb(frame, offset) - 0x8000;
}

Referenced by processCanRxImu_BoschM5_10_RollX(), processCanRxImu_BoschM5_10_YawY(), and processCanRxImu_BoschM5_10_Z().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getTwoBytesLsb()

uint16_t getTwoBytesLsb	(	const CANRxFrame &	frame,
		int	offset
	)

Definition at line 150 of file can_rx.cpp.

                                                             {
    return (frame.data8[offset + 1] << 8) + frame.data8[offset];
}

Referenced by getShiftedLSB_intel(), processBMW_e46(), processBMW_e90(), and processCanUserControl().

Here is the caller graph for this function:

◆ getTwoBytesMsb()

uint16_t getTwoBytesMsb	(	const CANRxFrame &	frame,
		int	offset
	)

Definition at line 154 of file can_rx.cpp.

                                                             {
    return (frame.data8[offset] << 8) + frame.data8[offset + 1];
}

Referenced by processNissan(), and processNissanSecondVss().

Here is the caller graph for this function:

◆ printCANRxFrame()

void printCANRxFrame	(	const size_t	busIndex,
		const CANRxFrame &	rx
	)

this build-in CAN sniffer is very basic but that's our CAN sniffer

Definition at line 29 of file can_rx.cpp.

                                                                  {
    // only print info if we're in can debug mode
 
    int id = CAN_ID(rx);
 
    if (CAN_ISX(rx)) {
        // print extended IDs in hex only
        efiPrintf("CAN%d RX: ID %07x DLC %d: %02x %02x %02x %02x %02x %02x %02x %02x",
                busIndex + 1,
                id,
                rx.DLC,
                rx.data8[0], rx.data8[1], rx.data8[2], rx.data8[3],
                rx.data8[4], rx.data8[5], rx.data8[6], rx.data8[7]);
    } else {
        // internet people use both hex and decimal to discuss packed IDs, for usability it's better to print both right here
        efiPrintf("CAN%d RX: ID %03x(%d) DLC %d: %02x %02x %02x %02x %02x %02x %02x %02x",
                busIndex + 1,
                id, id, // once in hex, once in dec
                rx.DLC,
                rx.data8[0], rx.data8[1], rx.data8[2], rx.data8[3],
                rx.data8[4], rx.data8[5], rx.data8[6], rx.data8[7]);
    }
}

Referenced by processCanRxMessage(), IsoTpRx::readTimeout(), and CanStreamerState::receiveFrame().

Here is the caller graph for this function:

◆ processCanRxImu()

static void processCanRxImu ( const CANRxFrame & frame )

static

Definition at line 184 of file can_rx.cpp.

                                                     {
/*
    if (CAN_SID(frame) == 0x130) {
        float a = getShiftedLSB_intel(frame, 0);
        float b = getShiftedLSB_intel(frame, 4);
        efiPrintf("CAN_rx 130 %f %f", a, b);
    }
 
    if (engineConfiguration->imuType == IMU_VAG) {
        if (CAN_SID(frame) == VAG_YAW_RATE_G_LAT) {
            efiPrintf("CAN_rx VAG_YAW_RATE_G_LAT");
        } else if (CAN_SID(frame) == VAG_YAW_ACCEL_G_LONG) {
            efiPrintf("CAN_rx VAG_YAW_ACCEL_G_LONG");
        }
    }
    */
 
    if (engineConfiguration->imuType == IMU_MM5_10) {
        if (CAN_SID(frame) == MM5_10_YAW_Y) {
            processCanRxImu_BoschM5_10_YawY(frame);
        } else if (CAN_SID(frame) == MM5_10_ROLL_X) {
            processCanRxImu_BoschM5_10_RollX(frame);
        } else if (CAN_SID(frame) == MM5_10_Z) {
            processCanRxImu_BoschM5_10_Z(frame);
        }
    } else if (engineConfiguration->imuType == IMU_TYPE_MB_A0065422618) {
        if (CAN_SID(frame) == MM5_10_MB_YAW_Y_CANID) {
            processCanRxImu_BoschM5_10_YawY(frame);
        } else if (CAN_SID(frame) == MM5_10_MB_ROLL_X_CANID) {
            processCanRxImu_BoschM5_10_RollX(frame);
        }
    }
}

Referenced by processCanRxMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processCanRxImu_BoschM5_10_RollX()

static void processCanRxImu_BoschM5_10_RollX ( const CANRxFrame & frame )

static

Definition at line 171 of file can_rx.cpp.

                                                                      {
    float accX = getShiftedLSB_intel(frame, 4);
    efiPrintf("CAN_rx MM5_10_ROLL_X %f", accX);
 
    engine->sensors.accelerometer.lon = accX * MM5_10_ACC_QUANT;
}

Referenced by processCanRxImu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processCanRxImu_BoschM5_10_YawY()

static void processCanRxImu_BoschM5_10_YawY ( const CANRxFrame & frame )

static

Definition at line 162 of file can_rx.cpp.

                                                                     {
    float yaw = getShiftedLSB_intel(frame, 0);
    float accY = getShiftedLSB_intel(frame, 4);
 
    efiPrintf("CAN_rx MM5_10_YAW_Y %f %f", yaw, accY);
    engine->sensors.accelerometer.yawRate = yaw * MM5_10_RATE_QUANT;
    engine->sensors.accelerometer.lat = accY * MM5_10_ACC_QUANT;
}

Referenced by processCanRxImu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processCanRxImu_BoschM5_10_Z()

static void processCanRxImu_BoschM5_10_Z ( const CANRxFrame & frame )

static

Definition at line 178 of file can_rx.cpp.

                                                                  {
    float accZ = getShiftedLSB_intel(frame, 4);
    efiPrintf("CAN_rx MM5_10_Z %f", accZ);
    engine->sensors.accelerometer.vert = accZ * MM5_10_ACC_QUANT;
}

Referenced by processCanRxImu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processCanRxMessage()

void processCanRxMessage	(	const size_t	busIndex,
		const CANRxFrame &	frame,
		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:

◆ serviceCanSubscribers()

void serviceCanSubscribers	(	const size_t	busIndex,
		const CANRxFrame &	frame,
		efitick_t	nowNt
	)

Definition at line 71 of file can_rx.cpp.

                                                                                            {
    CanListener *current = canListeners_head;
    size_t iterationValidationCounter = 0;
 
    while (current) {
        current = current->processFrame(busIndex, frame, nowNt);
        if (iterationValidationCounter++ > 239) {
          criticalError("forever loop canListeners_head");
          return;
        }
    }
}

Referenced by processCanRxMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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);
}