can_msg_tx.cpp

Go to the documentation of this file.

/**
 * @file    can_msg_tx.cpp
 *
 * CAN message transmission
 *
 * @date Mar 13, 2020
 * @author Matthew Kennedy, (c) 2012-2020
 */
 
#include "pch.h"
 
#include "can_msg_tx.h"
#include "auto_generated_can_category.h"
 
#include "can.h"
 
#if EFI_SIMULATOR || EFI_UNIT_TEST
#include "fifo_buffer.h"
fifo_buffer<CANTxFrame, TEST_CAN_BUFFER_SIZE> txCanBuffer;
#endif // EFI_SIMULATOR
 
#if EFI_CAN_SUPPORT
/*static*/ CANDriver* CanTxMessage::s_devices[EFI_CAN_BUS_COUNT] = {
    nullptr,
    nullptr,
#if (EFI_CAN_BUS_COUNT >= 3)
    nullptr
#endif
};
 
/*static*/ void CanTxMessage::setDevice(size_t idx, CANDriver* device) {
    if (idx > efi::size(s_devices)) {
        criticalError("Attemp to install CAN%d bus!", idx + 1);
        return;
    }
    s_devices[idx] = device;
}
#endif // EFI_CAN_SUPPORT
 
CanTxMessage::CanTxMessage(CanCategory p_category, uint32_t eid, uint8_t dlc, size_t bus, bool isExtended) {
    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
}
 
CanTxMessage::~CanTxMessage() {
#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;
    }
 
    if (busIndex >= EFI_CAN_BUS_COUNT) {
        // Error already throuwn from CanTxMessage::setBus
        // just do not access out of bounds
        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 {
extern int txErrorCount[EFI_CAN_BUS_COUNT];
        engine->outputChannels.canWriteNotOk++;
        txErrorCount[busIndex]++;
    }
#endif // EFI_TUNER_STUDIO
#endif /* EFI_CAN_SUPPORT */
}
 
#if HAS_CAN_FRAME
void CanTxMessage::setDlc(uint8_t dlc) {
    // TODO: CAN vs CANFD
    if (dlc > sizeof(m_frame.data8)) {
        criticalError("CAN: incorrect DLC %d", dlc);
        return;
    }
 
    m_frame.DLC = dlc;
}
 
void CanTxMessage::setBus(size_t bus) {
    if (bus >= EFI_CAN_BUS_COUNT) {
        criticalError("CAN: CAN%d incorect bus", bus + 1);
        return;
    }
 
    busIndex = bus;
}
 
// LSB Little-endian System, "Intel"
void CanTxMessage::setShortValue(uint16_t value, size_t offset) {
    m_frame.data8[offset] = value & 0xFF;
    m_frame.data8[offset + 1] = value >> 8;
}
 
// MOTOROLA order, MSB (Most Significant Byte/Big Endian) comes first.
void CanTxMessage::setShortValueMsb(uint16_t value, size_t offset) {
    m_frame.data8[offset] = value >> 8;
    m_frame.data8[offset + 1] = value & 0xFF;
}
 
void CanTxMessage::setBit(size_t byteIdx, size_t bitIdx) {
    m_frame.data8[byteIdx] |= 1 << bitIdx;
}
 
uint8_t& CanTxMessage::operator[](size_t index) {
    return m_frame.data8[index];
}
#endif // HAS_CAN_FRAME