mbed_can.cpp

Go to the documentation of this file.

 
#include "mbed.h"
#include "Can.hxx"
#ifdef TARGET_LPC2368
#include "lpc23xx.h"
 
int tx_led = 0;
 
#endif
 
#ifdef TARGET_LPC1768
#include "LPC17xx.h"
 
extern DigitalOut d1;
DigitalOut& tx_led = d1;
 
#endif
 
class MbedCanDriver : public Can
{
public:
    enum Instance {
        CAN1,
        CAN2
    };
    MbedCanDriver(Instance instance, const char *dev, int frequency)
        : Can(dev)
        , mbedCan_(
              instance == CAN1 ? P0_0 : P0_4, instance == CAN1 ? P0_1 : P0_5)
        , SR_(instance == CAN1 ? &LPC_CAN1->SR : &LPC_CAN2->SR)
    {
        mbedCan_.frequency(frequency);
        mbedCan_.attach(this, &MbedCanDriver::interrupt);
    }
private:
    void enable() override {}; 
    void disable() override {}; 
    void flush_buffers() override {}; 
    void interrupt();
    void tx_msg() OVERRIDE;
 
    mbed::CAN mbedCan_;
    volatile uint32_t* SR_;
    char txPending_;
};
 
void MbedCanDriver::tx_msg()
{
    if (txPending_)
        return;
    if (!(*SR_ & 0x4))
        return; // TX buffer is holding a packet
 
    struct can_frame *can_frame;
    taskENTER_CRITICAL();
    if (!txBuf->data_read_pointer(&can_frame))
    {
        taskEXIT_CRITICAL();
        return;
    }
    CANMessage msg(can_frame->can_id, (const char*)can_frame->data,
                   can_frame->can_dlc, can_frame->can_rtr ? CANRemote : CANData,
                   can_frame->can_eff ? CANExtended : CANStandard);
    if (!mbedCan_.write(msg))
    {
        // NOTE(balazs.racz): This means that the CAN layer didn't find an
        // available TX buffer to send the CAN message. However, since
        // txPending == 0 at this point, that can only happen if someone else
        // was also writing frames to this CAN device. We won't handle that
        // case now.
        overrunCount++;
    }
    else
    {
        txBuf->consume(1);
        txBuf->signal_condition();
    }
    txPending_ = 1;
    tx_led = 1;
    taskEXIT_CRITICAL();
}
 
void MbedCanDriver::interrupt()
{
    int woken = 0;
    CANMessage msg;
    if (mbedCan_.read(msg))
    {
        struct can_frame* can_frame;
        if (rxBuf->data_write_pointer(&can_frame))
        {
            can_frame->can_id = msg.id;
            can_frame->can_rtr = msg.type == CANRemote ? 1 : 0;
            can_frame->can_eff = msg.format == CANStandard ? 0 : 1;
            can_frame->can_err = 0;
            can_frame->can_dlc = msg.len;
            memcpy(can_frame->data, msg.data, msg.len);
            rxBuf->advance(1);
            rxBuf->signal_condition_from_isr();
        }
        else
        {
            ++overrunCount;
        }
    }
#if defined(TARGET_LPC2368) || defined(TARGET_LPC1768)
    if (*SR_ & 0x4)
    {
        // Transmit buffer 1 empty => transmit finished.
        struct can_frame *can_frame;
        if (txBuf->data_read_pointer(&can_frame))
        {
            CANMessage msg(can_frame->can_id, (const char*)can_frame->data,
                           can_frame->can_dlc,
                           can_frame->can_rtr ? CANRemote : CANData,
                           can_frame->can_eff ? CANExtended : CANStandard);
            if (mbedCan_.write(msg))
            {
                tx_led = 1;
                txPending_ = 1;
                txBuf->consume(1);
                txBuf->signal_condition_from_isr();
            }
            else
            {
                // NOTE(balazs.racz): This is an inconsistency -- if *SR&0x4
                // then TX1 buffer is empty, so if write fails, then... a task
                // switch occured while serving an interrupt handler?
                overrunCount++;
                tx_led = 0;
                txPending_ = 0;
            }
        }
        else
        {
            tx_led = 0;
            txPending_ = 0;
        }
    }
#else
#error you need to define how to figure out whether the transmit buffer is empty.
#endif
    if (woken)
    {
#ifdef TARGET_LPC1768
        portYIELD();
#elif defined(TARGET_LPC2368)
#else
#error define how to yield on your CPU.
#endif
    }
}
 
MbedCanDriver can0(MbedCanDriver::CAN2, "/dev/can0", config_nmranet_can_bitrate());
MbedCanDriver can1(MbedCanDriver::CAN1, "/dev/can1", config_can2_bitrate() ? config_can2_bitrate() : config_nmranet_can_bitrate());