Pic32mxCan.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_PIC32MX_PIC32MXCAN_HXX_
#define _FREERTOS_DRIVERS_PIC32MX_PIC32MXCAN_HXX_
 
#include "Devtab.hxx"
 
#include "GenericTypeDefs.h"
#include <xc.h>
extern "C" {
#include "peripheral/CAN.h"
#include "peripheral/int.h"
}
 
class Pic32mxCan : public Node
{
public:
    Pic32mxCan(CAN_MODULE module, const char *dev, unsigned irq_vector);
 
    ~Pic32mxCan();
 
    inline void isr()
    {
        int woken = 0;
        if ((CANGetModuleEvent(hw_) & CAN_RX_EVENT) != 0)
        //    if(CANGetPendingEventCode(hw_) == CAN_CHANNEL1_EVENT)
        {
            /* This means that channel 1 caused the event.
             * The CAN_RX_CHANNEL_NOT_EMPTY event is persistent. You
             * could either read the channel in the ISR
             * to clear the event condition or as done
             * here, disable the event source, and set
             * an application flag to indicate that a message
             * has been received. The event can be
             * enabled by the application when it has processed
             * one message.
             *
             * Note that leaving the event enabled would
             * cause the CPU to keep executing the ISR since
             * the CAN_RX_CHANNEL_NOT_EMPTY event is persistent (unless
             * the not empty condition is cleared.)
             * */
            CANEnableChannelEvent(
                hw_, CAN_CHANNEL1, CAN_RX_CHANNEL_NOT_EMPTY, FALSE);
            Device::select_wakeup_from_isr(&rxSelect_, &woken);
        }
        if ((CANGetModuleEvent(hw_) & CAN_TX_EVENT) != 0)
        //    if(CANGetPendingEventCode(hw_) == CAN_CHANNEL0_EVENT)
        {
            /* Same with the TX event. */
            CANEnableChannelEvent(
                hw_, CAN_CHANNEL0, CAN_TX_CHANNEL_NOT_FULL, FALSE);
            Device::select_wakeup_from_isr(&txSelect_, &woken);
        }
        INTClearFlag(can_int());
    }
 
private:
    void enable();  
    void disable(); 
    void flush_buffers() OVERRIDE {} 
    ssize_t read(File *file, void *buf, size_t count);
    ssize_t write(File *file, const void *buf, size_t count);
    bool select(File* file, int mode) OVERRIDE;
 
    INT_SOURCE can_int()
    {
        return (INT_SOURCE)(INT_SOURCE_CAN(hw_));
    }
 
    INT_VECTOR can_vector()
    {
        return (INT_VECTOR)(INT_VECTOR_CAN(hw_));
    }
 
    CAN_MODULE hw_;
    int overrunCount_;
    unsigned irqVector_;
    void *messageFifoArea_;
    // Select for the transmit buffers.
    SelectInfo txSelect_;
    // Select for the receive buffers.
    SelectInfo rxSelect_;
 
    DISALLOW_COPY_AND_ASSIGN(Pic32mxCan);
};
 
 
#endif // _FREERTOS_DRIVERS_PIC32MX_PIC32MXCAN_HXX_