CanDefs.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CANDEFS_HXX_
#define _OPENLCB_CANDEFS_HXX_
 
#include <cstdint>
 
#include "openlcb/Defs.hxx"
#include "can_frame.h"
#include "nmranet_config.h"
 
namespace openlcb
{
 
struct CanDefs {
    enum AliasStatus
    {
        UNDER_TEST, 
        RESERVED,   
        CONFLICT,   
        FREE        
    };
 
 
    enum ID
    {
        SRC_MASK            = 0x00000fff, 
        MTI_MASK            = 0x00fff000, 
        DST_MASK            = 0x00fff000, 
        CAN_FRAME_TYPE_MASK = 0x07000000, 
        FRAME_TYPE_MASK     = 0x08000000, 
        PRIORITY_MASK       = 0x10000000, 
        PADDING_MASK        = 0xe0000000, 
        STREAM_DG_RECV_MASK = 0x0fffffff, 
        SRC_SHIFT            =  0, 
        MTI_SHIFT            = 12, 
        DST_SHIFT            = 12, 
        CAN_FRAME_TYPE_SHIFT = 24, 
        FRAME_TYPE_SHIFT     = 27, 
        PRIORITY_SHIFT       = 28, 
        PADDING_SHIFT        = 29, 
        CONTROL_SRC_MASK      = 0x00000fff, 
        CONTROL_FIELD_MASK    = 0x07fff000, 
        CONTROL_SEQUENCE_MASK = 0x07000000, 
        CONTROL_TYPE_MASK     = 0x08000000, 
        CONTROL_PRIORITY_MASK = 0x10000000, 
        CONTROL_PADDING_MASK  = 0xe0000000, 
        CONTROL_SRC_SHIFT      =  0, 
        CONTROL_FIELD_SHIFT    = 12, 
        CONTROL_SEQUENCE_SHIFT = 24, 
        CONTROL_TYPE_SHIFT     = 27, 
        CONTROL_PRIORITY_SHIFT = 28, 
        CONTROL_PADDING_SHIFT  = 29  
    };
 
    // @TODO(balazs.racz) do we need this?
    typedef uint16_t CanMTI;
 
    enum CanFrameType
    {
        GLOBAL_ADDRESSED      = 1, 
        DATAGRAM_ONE_FRAME    = 2, 
        DATAGRAM_FIRST_FRAME  = 3, 
        DATAGRAM_MIDDLE_FRAME = 4, 
        DATAGRAM_FINAL_FRAME  = 5, 
        STREAM_DATA           = 7, 
    };
    
    enum FrameType
    {
        CONTROL_MSG = 0, 
        NMRANET_MSG = 1  
    };
    
    enum Priority
    {
        HIGH_PRIORITY   = 0, 
        NORMAL_PRIORITY = 1  
    };
 
    enum ControlField
    {
        RID_FRAME = 0x0700, 
        AMD_FRAME = 0x0701, 
        AME_FRAME = 0x0702, 
        AMR_FRAME = 0x0703  
    };
 
    enum AddressedPayloadFlags
    {
        NOT_FIRST_FRAME = 0x20,
        NOT_LAST_FRAME = 0x10,
    };
 
    enum ReservedAliasNodeId
    {
        RESERVED_ALIAS_NODE_BITS = 0xF000,
        RESERVED_ALIAS_NODE_MASK = 0xFFFFFFFFF000
    };
 
    static NodeAlias get_src(uint32_t can_id)
    {
        return (can_id & SRC_MASK) >> SRC_SHIFT;
    }
 
    static CanMTI get_mti(uint32_t can_id)
    {
        return ((can_id & MTI_MASK) >> MTI_SHIFT);
    }
 
    static NodeAlias get_dst(uint32_t can_id)
    {
        return (can_id & DST_MASK) >> DST_SHIFT;
    }
 
    static CanFrameType get_can_frame_type(uint32_t can_id)
    {
        return (CanFrameType)((can_id & CAN_FRAME_TYPE_MASK) >> CAN_FRAME_TYPE_SHIFT);
    }
 
    static FrameType get_frame_type(uint32_t can_id)
    {
        return (FrameType)((can_id & FRAME_TYPE_MASK) >> FRAME_TYPE_SHIFT);
    }
 
    static Priority get_priority(uint32_t can_id)
    {
        return (Priority)((can_id & PRIORITY_MASK) >> PRIORITY_SHIFT);
    }
 
    static bool is_cid_frame(uint32_t can_id)
    {
        return ((can_id >> CAN_FRAME_TYPE_SHIFT) & 0x1C) == 0x14;
    }
 
    static bool is_stream_frame(uint32_t can_id)
    {
        return ((can_id >> CAN_FRAME_TYPE_SHIFT) & 0xF) == 0xF;
    }
 
    static void set_mti(uint32_t *can_id, CanMTI mti)
    {
        *can_id &= ~MTI_MASK;
        *can_id |= mti << MTI_SHIFT;
    }
 
    static void set_src(uint32_t *can_id, NodeAlias src)
    {
        *can_id &= ~SRC_MASK;
        *can_id |= src << SRC_SHIFT;
    }
 
    static void set_dst(uint32_t *can_id, NodeAlias dst)
    {
        *can_id &= ~DST_MASK;
        *can_id |= dst << DST_SHIFT;
    }
 
    static void set_can_frame_type(uint32_t *can_id, CanFrameType type)
    {
        *can_id &= ~CAN_FRAME_TYPE_MASK;
        *can_id |= type << CAN_FRAME_TYPE_SHIFT;
    }
 
    static void set_frame_type(uint32_t *can_id, FrameType type)
    {
        *can_id &= ~FRAME_TYPE_MASK;
        *can_id |= type << FRAME_TYPE_SHIFT;
    }
 
    static void set_priority(uint32_t *can_id, Priority priority)
    {
        *can_id &= ~PRIORITY_MASK;
        *can_id |= priority << PRIORITY_SHIFT;
    }
 
    static void set_fields(uint32_t *can_id, NodeAlias src, Defs::MTI mti, CanFrameType can_type, FrameType type, Priority priority)
    {
        *can_id = (src      << SRC_SHIFT           ) +
                  (mti      << MTI_SHIFT           ) +
                  (can_type << CAN_FRAME_TYPE_SHIFT) +
                  (type     << FRAME_TYPE_SHIFT    ) +
                  (priority << PRIORITY_SHIFT      );
    }
 
    static void set_datagram_fields(uint32_t *can_id, NodeAlias src,
                                    NodeAlias dst, CanFrameType can_type)
    {
        *can_id = (src      << SRC_SHIFT           ) +
                  (dst      << DST_SHIFT           ) +
                  (can_type << CAN_FRAME_TYPE_SHIFT) +
                  (NMRANET_MSG << FRAME_TYPE_SHIFT ) +
                  (NORMAL_PRIORITY << PRIORITY_SHIFT);
    }
 
    static Defs::MTI nmranet_mti(uint32_t can_id);
 
    static uint32_t can_identifier(Defs::MTI mti, NodeAlias src);
 
    static ControlField get_control_field(uint32_t can_id)
    {
        return (ControlField)((can_id & CONTROL_FIELD_MASK) >> CONTROL_FIELD_SHIFT);
    }
 
#if 0
    static NodeAlias get_control_src(uint32_t can_id)
    {
        return (can_id & CONTROL_SRC_MASK) >> CONTROL_SRC_SHIFT;
    }
 
    static unsigned int get_control_sequence(uint32_t can_id)
    {
        return (can_id & CONTROL_SEQUENCE_MASK) >> CONTROL_SEQUENCE_SHIFT;
    }
 
#endif
 
    static uint32_t set_control_fields(
        NodeAlias src, uint16_t field, int sequence)
    {
        return (src << CONTROL_SRC_SHIFT) | (field << CONTROL_FIELD_SHIFT) |
            (sequence << CONTROL_SEQUENCE_SHIFT) | ((0) << CONTROL_TYPE_SHIFT) |
            ((1) << CONTROL_PRIORITY_SHIFT);
    }
 
    static void control_init(struct can_frame &frame, NodeAlias src, uint16_t field, int sequence)
    {
        SET_CAN_FRAME_ID_EFF(frame, set_control_fields(src, field, sequence));
        frame.can_dlc = 0;
    }
 
    static NodeID get_reserved_alias_node_id(NodeAlias alias)
    {
        return RESERVED_ALIAS_NODE_BITS | alias;
    }
 
    static bool is_reserved_alias_node_id(NodeID id)
    {
        return (id & RESERVED_ALIAS_NODE_MASK) == RESERVED_ALIAS_NODE_BITS;
    }
 
private:
    CanDefs();
};
 
}  // namespace openlcb
 
#endif // _OPENLCB_CANDEFS_HXX_