CanIf.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_CANIF_HXX_
#define _UTILS_CANIF_HXX_
 
#include "can_frame.h"
#include "utils/Hub.hxx"
 
struct CanMessageData : public can_frame
{
    CanMessageData()
    {
        can_id = 0;
        CLR_CAN_FRAME_ERR(*this);
        CLR_CAN_FRAME_RTR(*this);
        SET_CAN_FRAME_EFF(*this);
        can_dlc = 0;
    }
 
    typedef uint32_t id_type;
 
    static const id_type STANDARD_FRAME_BIT = (1U << 30);
 
    static const uint32_t CAN_EXT_FRAME_FILTER = 0;
    static const uint32_t CAN_EXT_FRAME_MASK = ~0x1FFFFFFFU;
 
    static const uint32_t CAN_STD_FRAME_FILTER = STANDARD_FRAME_BIT;
    static const uint32_t CAN_STD_FRAME_MASK = ~0x7FFU;
 
 
    id_type id()
    {
        if (IS_CAN_FRAME_EFF(*this))
        {
            return GET_CAN_FRAME_ID_EFF(*this);
        }
        else
        {
            return GET_CAN_FRAME_ID(*this) | STANDARD_FRAME_BIT;
        }
    }
 
    struct can_frame *mutable_frame()
    {
        return this;
    }
 
    const struct can_frame &frame() const
    {
        return *this;
    }
 
    void *unused;
};
 
typedef FlowInterface<Buffer<CanMessageData>> IncomingFrameHandler;
typedef StateFlow<Buffer<CanMessageData>, QList<1>> IncomingFrameFlow;
typedef FlowInterface<Buffer<CanHubData>> OutgoingFrameHandler;
 
class CanIf;
 
class CanFrameWriteFlow : public OutgoingFrameHandler
{
public:
    CanFrameWriteFlow(CanIf *service)
        : ifCan_(service)
    {
    }
 
    Pool *pool() OVERRIDE;
 
    void send(
        Buffer<CanHubData> *message, unsigned priority = UINT_MAX) OVERRIDE;
 
private:
    CanIf *ifCan_;
};
 
class CanFrameReadFlow : public OutgoingFrameHandler
{
public:
    CanFrameReadFlow(CanIf *service)
        : ifCan_(service)
    {
    }
 
    Pool *pool() OVERRIDE;
 
    void send(
        Buffer<CanHubData> *message, unsigned priority = UINT_MAX) OVERRIDE;
 
private:
    CanIf *ifCan_;
};
 
class CanIf
{
public:
    CanIf(Service *service, CanHubFlow *device);
    ~CanIf();
 
    typedef DispatchFlow<Buffer<CanMessageData>, 4> FrameDispatchFlow;
 
    Service *service()
    {
        return frameDispatcher_.service();
    }
 
    FrameDispatchFlow *frame_dispatcher()
    {
        return &frameDispatcher_;
    }
 
    OutgoingFrameHandler *frame_write_flow()
    {
        return &frameWriteFlow_;
    }
 
    OutgoingFrameHandler *loopback_frame_write_flow()
    {
        return &frameReadFlow_;
    }
 
private:
    friend class CanFrameWriteFlow;
    // friend class CanFrameReadFlow;
 
    CanHubFlow *device_;
 
    CanFrameWriteFlow frameWriteFlow_;
 
    CanFrameReadFlow frameReadFlow_;
 
    FrameDispatchFlow frameDispatcher_;
 
    CanHubPortInterface *hub_port()
    {
        return &frameReadFlow_;
    }
    CanHubFlow *device()
    {
        return device_;
    }
};
 
#endif // _UTILS_CANIF_HXX_