CanTxMessage Class Reference

#include <can_msg_tx.h>

Inheritance diagram for CanTxMessage:

Collaboration diagram for CanTxMessage:

Public Member Functions
	CanTxMessage (CanCategory category, uint32_t eid, uint8_t dlc=8, size_t bus=0, bool isExtended=false)
	~CanTxMessage ()
uint8_t &	operator[] (size_t)
	Read & write the raw underlying 8-byte buffer.
void	setShortValue (uint16_t value, size_t offset)
	Write a 16-bit short value to the buffer. Note: this writes in Intel little endian byte order.
void	setShortValueMsb (uint16_t value, size_t offset)
void	setBit (size_t byteIdx, size_t bitIdx)
	Set a single bit in the transmit buffer. Useful for single-bit flags.
void	setDlc (uint8_t dlc)
void	setBus (size_t bus)
const CANTxFrame *	getFrame () const
void	setArray (const uint8_t *data, size_t len)
template<size_t N>
void	setArray (const uint8_t(&data)[N])

Static Public Member Functions
static void	setDevice (size_t idx, CANDriver *device)

Data Fields
CanCategory	category
size_t	busIndex = 0

Protected Attributes
CANTxFrame	m_frame

Static Private Attributes
static CANDriver *	s_devices [EFI_CAN_BUS_COUNT]

Detailed Description

Represent a message to be transmitted over CAN.

Usage:

• Create an instance of CanTxMessage
• Set any data you'd like to transmit either using the subscript operator to directly access bytes, or any of the helper functions.
• Upon destruction, the message is transmitted.

Definition at line 31 of file can_msg_tx.h.

Constructor & Destructor Documentation

CanTxMessage()

CanTxMessage::CanTxMessage ( CanCategory  category, uint32_t  eid, uint8_t  dlc = 8, size_t  bus = 0, bool  isExtended = false  )

explicit

Create a new CAN message, with the specified extended ID.

Definition at line 40 of file can_msg_tx.cpp.

                                                                                                         {
    category = p_category;
#if HAS_CAN_FRAME
#ifndef STM32H7XX
    // ST bxCAN device
    m_frame.IDE = isExtended ? CAN_IDE_EXT : CAN_IDE_STD;
    m_frame.RTR = CAN_RTR_DATA;
#else /* if STM32H7XX */
    // Bosch M_CAN FDCAN device
    m_frame.common.XTD = isExtended;
    m_frame.common.RTR = 0;
#endif
 
    if (isExtended) {
        CAN_EID(m_frame) = eid;
    } else {
        if (eid >= 0x800) {
            criticalError("Looks like extended CAN ID %x %s", eid, getCanCategory(category));
            return;
        }
        CAN_SID(m_frame) = eid;
    }
 
    setDlc(dlc);
 
    setBus(bus);
 
    setArrayValues(m_frame.data8, 0);
#endif // HAS_CAN_FRAME
}

Here is the call graph for this function:

~CanTxMessage()

CanTxMessage::~CanTxMessage

(

)

Destruction of an instance of CanTxMessage will transmit the message over the wire.

Definition at line 71 of file can_msg_tx.cpp.

                            {
#if EFI_SIMULATOR || EFI_UNIT_TEST
    txCanBuffer.put(m_frame);
 
#if EFI_UNIT_TEST
    printf("%s Sending CAN%d message: ID=%x/l=%x %x %x %x %x %x %x %x %x \n",
           getCanCategory(category),
           busIndex + 1,
           (unsigned int)CAN_ID(m_frame),
           m_frame.DLC,
           m_frame.data8[0], m_frame.data8[1],
           m_frame.data8[2], m_frame.data8[3],
           m_frame.data8[4], m_frame.data8[5],
           m_frame.data8[6], m_frame.data8[7]);
#endif
#endif // EFI_SIMULATOR
 
#if EFI_CAN_SUPPORT
    ScopePerf pc(PE::CanDriverTx);
 
    if (!engine->allowCanTx) {
        return;
    }
 
    auto device = s_devices[busIndex];
    if (!device) {
        criticalError("Send: CAN%d device not configured %s %x", busIndex + 1, getCanCategory(category),
           (unsigned int)CAN_ID(m_frame));
        return;
    }
 
    bool verboseCan = engineConfiguration->verboseCan && busIndex == 0;
    verboseCan |= engineConfiguration->verboseCan2 && busIndex == 1;
#if (EFI_CAN_BUS_COUNT >= 3)
    verboseCan |= engineConfiguration->verboseCan3 && busIndex == 2;
#endif
 
    if (verboseCan) {
        efiPrintf("%s Sending CAN%d message: ID=%x/l=%x %x %x %x %x %x %x %x %x",
                getCanCategory(category),
                busIndex + 1,
                (unsigned int)CAN_ID(m_frame),
                m_frame.DLC,
                m_frame.data8[0], m_frame.data8[1],
                m_frame.data8[2], m_frame.data8[3],
                m_frame.data8[4], m_frame.data8[5],
                m_frame.data8[6], m_frame.data8[7]);
    }
 
    // 100 ms timeout
    msg_t msg = canTransmit(device, CAN_ANY_MAILBOX, &m_frame, TIME_MS2I(100));
#if EFI_TUNER_STUDIO
    if (msg == MSG_OK) {
        engine->outputChannels.canWriteOk++;
    } else {
        engine->outputChannels.canWriteNotOk++;
    }
#endif // EFI_TUNER_STUDIO
#endif /* EFI_CAN_SUPPORT */
}

Here is the call graph for this function:

Member Function Documentation

getFrame()

const CANTxFrame * CanTxMessage::getFrame ( ) const

inline

Definition at line 81 of file can_msg_tx.h.

                                       {
        return &m_frame;
    }

operator[]()

uint8_t & CanTxMessage::operator[]

(

size_t

index

)

Read & write the raw underlying 8-byte buffer.

Definition at line 157 of file can_msg_tx.cpp.

                                              {
    return m_frame.data8[index];
}

setArray() [1/2]

void CanTxMessage::setArray ( const uint8_t *  data, size_t  len  )

inline

Definition at line 85 of file can_msg_tx.h.

                                                   {
        for (size_t i = 0; i < std::min(len, size_t(8)); i++) {
            m_frame.data8[i] = data[i];
        }
    }

Referenced by setArray().

Here is the caller graph for this function:

setArray() [2/2]

template<size_t N>

void CanTxMessage::setArray ( const uint8_t(&)  data[N] )

inline

Definition at line 92 of file can_msg_tx.h.

                                            {
        setArray(data, N);
    }

Here is the call graph for this function:

setBit()

void CanTxMessage::setBit	(	size_t	byteIdx,
		size_t	bitIdx
	)

Set a single bit in the transmit buffer. Useful for single-bit flags.

Definition at line 153 of file can_msg_tx.cpp.

                                                       {
    m_frame.data8[byteIdx] |= 1 << bitIdx;
}

Referenced by canDashboardHaltech(), and canMazdaRX8().

Here is the caller graph for this function:

setBus()

void CanTxMessage::setBus

(

size_t

bus

)

Definition at line 137 of file can_msg_tx.cpp.

                                    {
    busIndex = bus;
}

Referenced by CanTxMessage().

Here is the caller graph for this function:

setDevice()

void CanTxMessage::setDevice ( size_t  idx, CANDriver *  device  )

static

Configures the device for all messages to transmit from.

Definition at line 31 of file can_msg_tx.cpp.

                                                            {
    if (idx > efi::size(s_devices)) {
        criticalError("Attemp to install CAN%d bus!", idx + 1);
        return;
    }
    s_devices[idx] = device;
}

Referenced by initCan().

Here is the caller graph for this function:

setDlc()

void CanTxMessage::setDlc

(

uint8_t

dlc

)

Definition at line 133 of file can_msg_tx.cpp.

                                     {
    m_frame.DLC = dlc;
}

Referenced by CanTxMessage(), and lua_txCan().

Here is the caller graph for this function:

setShortValue()

void CanTxMessage::setShortValue	(	uint16_t	value,
		size_t	offset
	)

Write a 16-bit short value to the buffer. Note: this writes in Intel little endian byte order.

Definition at line 142 of file can_msg_tx.cpp.

                                                              {
    m_frame.data8[offset] = value & 0xFF;
    m_frame.data8[offset + 1] = value >> 8;
}

Referenced by canDashboardBmwE46(), canDashboardBmwE90(), canDashboardFiat(), canDashboardNissanVQ(), canDashboardVAG(), canDashboardVagMqb(), and canMazdaRX8().

Here is the caller graph for this function:

setShortValueMsb()

void CanTxMessage::setShortValueMsb	(	uint16_t	value,
		size_t	offset
	)

Same as above but big endian Motorola for instance DBC 8|16@0

Definition at line 148 of file can_msg_tx.cpp.

                                                                 {
    m_frame.data8[offset] = value >> 8;
    m_frame.data8[offset + 1] = value & 0xFF;
}

Referenced by canDashboardGenesisCoupe(), canDashboardHaltech(), canDashboardHondaK(), canDashboardNissanVQ(), and canDashboardW202().

Here is the caller graph for this function:

Field Documentation

busIndex

size_t CanTxMessage::busIndex = 0

Definition at line 53 of file can_msg_tx.h.

Referenced by obdSendPacket(), setBus(), and ~CanTxMessage().

category

CanCategory CanTxMessage::category

Definition at line 44 of file can_msg_tx.h.

Referenced by CanTxMessage(), and ~CanTxMessage().

m_frame

CANTxFrame CanTxMessage::m_frame

protected

Definition at line 100 of file can_msg_tx.h.

Referenced by CanTxMessage(), CanTxTyped< TData >::get(), getFrame(), CanTxTyped< TData >::operator->(), operator[](), setArray(), setBit(), setDlc(), setShortValue(), setShortValueMsb(), and ~CanTxMessage().

s_devices

CANDriver * CanTxMessage::s_devices

staticprivate

Initial value:

= {
    nullptr,
    nullptr,
#if (EFI_CAN_BUS_COUNT >= 3)
    nullptr
#endif
}

Definition at line 23 of file can_msg_tx.h.

Referenced by setDevice(), and ~CanTxMessage().

---

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

• hw_layer/drivers/can/can_msg_tx.h
• hw_layer/drivers/can/can_msg_tx.cpp