openlcb/Defs.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_DEFS_HXX_
#define _OPENLCB_DEFS_HXX_
 
#include <cstdint>
 
#include "utils/macros.h"
 
namespace openlcb
{
 
typedef uint64_t NodeID;
 
typedef uint16_t NodeAlias;
 
typedef string Payload;
 
static const NodeAlias NOT_RESPONDING = 0xF000;
 
struct NodeHandle
{
    NodeID id; 
    NodeAlias alias; 
    explicit NodeHandle(NodeID _id) : id(_id), alias(0) {}
    explicit NodeHandle(NodeAlias _alias) : id(0), alias(_alias) {}
    NodeHandle(NodeID _id, NodeAlias _alias) : id(_id), alias(_alias) {}
    NodeHandle() : id(0), alias(0) {}
 
    void clear()
    {
        id = 0;
        alias = 0;
    }
 
    bool operator==(const NodeHandle& o) const
    {
        return id == o.id && alias == o.alias;
    }
};
 
enum class EventState
{
    VALID = 0,
    INVALID = 1,
    RESERVED = 2,
    UNKNOWN = 3
};
 
struct Defs
{
    enum MTI
    {
        MTI_EXACT                     = 0xFFFF, 
        MTI_NONE                      = 0x0000, 
        MTI_INITIALIZATION_COMPLETE   = 0x0100, 
        MTI_VERIFY_NODE_ID_ADDRESSED  = 0x0488, 
        MTI_VERIFY_NODE_ID_GLOBAL     = 0x0490, 
        MTI_VERIFIED_NODE_ID_NUMBER   = 0x0170, 
        MTI_OPTIONAL_INTERACTION_REJECTED = 0x0068, 
        MTI_TERMINATE_DUE_TO_ERROR    = 0x00A8, 
        MTI_PROTOCOL_SUPPORT_INQUIRY  = 0x0828, 
        MTI_PROTOCOL_SUPPORT_REPLY    = 0x0668, 
        MTI_CONSUMER_IDENTIFY         = 0x08F4, 
        MTI_CONSUMER_IDENTIFIED_RANGE   = 0x04A4, 
        MTI_CONSUMER_IDENTIFIED_UNKNOWN = 0x04C7, 
        MTI_CONSUMER_IDENTIFIED_VALID   = 0x04C4, 
        MTI_CONSUMER_IDENTIFIED_INVALID = 0x04C5, 
        MTI_CONSUMER_IDENTIFIED_RESERVED = 0x04C6, 
        MTI_PRODUCER_IDENTIFY         = 0x0914, 
        MTI_PRODUCER_IDENTIFIED_RANGE   = 0x0524, 
        MTI_PRODUCER_IDENTIFIED_UNKNOWN = 0x0547, 
        MTI_PRODUCER_IDENTIFIED_VALID   = 0x0544, 
        MTI_PRODUCER_IDENTIFIED_INVALID = 0x0545, 
        MTI_PRODUCER_IDENTIFIED_RESERVED = 0x0546, 
        MTI_EVENTS_IDENTIFY_ADDRESSED = 0x0968, 
        MTI_EVENTS_IDENTIFY_GLOBAL    = 0x0970, 
        MTI_LEARN_EVENT               = 0x0594, 
        MTI_EVENT_REPORT              = 0x05B4, 
        MTI_TRACTION_CONTROL_COMMAND  = 0x05EB,
        MTI_TRACTION_CONTROL_REPLY    = 0x01E9,
        MTI_TRACTION_PROXY_COMMAND    = 0x05EA,
        MTI_TRACTION_PROXY_REPLY      = 0x01E8,
        MTI_XPRESSNET                 = 0x09C0, 
        MTI_IDENT_INFO_REQUEST        = 0x0DE8, 
        MTI_IDENT_INFO_REPLY          = 0x0A08, 
        MTI_DATAGRAM                  = 0x1C48, 
        MTI_DATAGRAM_OK               = 0x0A28, 
        MTI_DATAGRAM_REJECTED         = 0x0A48, 
        MTI_STREAM_INITIATE_REQUEST   = 0x0CC8, 
        MTI_STREAM_INITIATE_REPLY     = 0x0868, 
        MTI_STREAM_DATA               = 0x1F88, 
        MTI_STREAM_PROCEED            = 0x0888, 
        MTI_STREAM_COMPLETE           = 0x08A8, 
        MTI_MODIFIER_MASK = 0x0003, 
        MTI_EVENT_MASK    = 0x0004, 
        MTI_ADDRESS_MASK  = 0x0008, 
        MTI_SIMPLE_MASK   = 0x0010, 
        MTI_TYPE_MASK     = 0x03e0, 
        MTI_PRIORITY_MASK = 0x0c00, 
        MTI_DATAGRAM_MASK = 0x1000, 
        MTI_SPECIAL_MASK  = 0x2000, 
        MTI_RESERVED_MASK = 0xc000, 
        MTI_MODIFIER_SHIFT =  0, 
        MTI_EVENT_SHIFT    =  2, 
        MTI_ADDRESS_SHIFT  =  3, 
        MTI_SIMPLE_SHIFT   =  4, 
        MTI_TYPE_SHIFT     =  5, 
        MTI_PRIORITY_SHIFT = 10, 
        MTI_DATAGRAM_SHIFT = 12, 
        MTI_SPECIAL_SHIFT  = 13, 
        MTI_RESERVED_SHIFT = 14  
    };
 
    enum ErrorCodes
    {
        ERROR_CODE_OK = 0,
 
        ERROR_PERMANENT = 0x1000,
        ERROR_TEMPORARY = 0x2000,
 
        ERROR_SRC_NOT_PERMITTED = 0x1020,
        ERROR_OPENMRN_NOT_FOUND = 0x1030,
        ERROR_UNIMPLEMENTED = 0x1040,
        ERROR_INVALID_ARGS = 0x1080,
 
        ERROR_OPENLCB_TIMEOUT = 0x2030,
        ERROR_OUT_OF_ORDER = 0x2040,
 
        ERROR_INVALID_ARGS_MESSAGE_TOO_SHORT = ERROR_INVALID_ARGS | 1,
 
        ERROR_UNIMPLEMENTED_MTI = ERROR_UNIMPLEMENTED | 3,
        ERROR_UNIMPLEMENTED_CMD = ERROR_UNIMPLEMENTED | 2,
        ERROR_UNIMPLEMENTED_SUBCMD = ERROR_UNIMPLEMENTED | 1,
 
        ERROR_OPENMRN_ALREADY_EXISTS = ERROR_OPENMRN_NOT_FOUND | 2,
 
        // Codes defined by the firmware upgrade standard
 
        ERROR_FIRMWARE_INCOMPATIBLE = ERROR_INVALID_ARGS | 8,
        ERROR_FIRMWARE_CORRUPTED = ERROR_INVALID_ARGS | 9,
        ERROR_FIRMWARE_CSUM = 0x2088,
 
        // Internal error codes generated by the stack.
        ERROR_DST_NOT_FOUND = 0x40000, //< on CAN. Permanent error code.
        // There is a conflict with MinGW macros here.
        OPENMRN_TIMEOUT = 0x80000,       //< Timeout waiting for ack/nack.
        ERROR_DST_REBOOT = 0x100000,   //< Target node has rebooted.
        ERROR_REJECTED = 0x200000,     //< Target node has rejectedthe request.
    };
 
    enum Protocols
    {
        SIMPLE_PROTOCOL_SUBSET  = 0x800000000000,
        DATAGRAM                = 0x400000000000,
        STREAM                  = 0x200000000000,
        MEMORY_CONFIGURATION    = 0x100000000000,
        RESERVATION             = 0x080000000000,
        EVENT_EXCHANGE          = 0x040000000000,
        IDENTIFICATION          = 0x020000000000,
        LEARN_CONFIGURATION     = 0x010000000000,
        REMOTE_BUTTON           = 0x008000000000,
        ABBREVIATED_DEFAULT_CDI = 0x004000000000,
        DISPLAY_PROTOCOL        = 0x002000000000,
        SIMPLE_NODE_INFORMATION = 0x001000000000,
        CDI                     = 0x000800000000,
        TRACTION_CONTROL        = 0x000400000000,
        TRACTION_FDI            = 0x000200000000,
        TRACTION_PROXY          = 0x000100000000,
        TRACTION_SIMPLE_TRAIN_INFO
                                = 0x000080000000,
        FUNCTION_CONFIGURATION  = 0x000040000000,
        FIRMWARE_UPGRADE        = 0x000020000000,
        FIRMWARE_UPGRADE_ACTIVE = 0x000010000000,
        RESERVED_MASK           = 0x00000FFFFFFF
    };
 
    static constexpr uint64_t EMERGENCY_OFF_EVENT = 0x010000000000FFFFULL;
 
    static constexpr uint64_t CLEAR_EMERGENCY_OFF_EVENT = 0x010000000000FFFEULL;
 
    static constexpr uint64_t EMERGENCY_STOP_EVENT = 0x010000000000FFFDULL;
 
    static constexpr uint64_t CLEAR_EMERGENCY_STOP_EVENT = 0x010000000000FFFCULL;
 
    static constexpr uint64_t POWER_STANDARD_BROWNOUT_EVENT = 0x010000000000FFF0ULL;
 
    static constexpr uint64_t NODE_POWER_BROWNOUT_EVENT = 0x010000000000FFF1ULL;
 
    static constexpr uint64_t NODE_IDENT_BUTTON_EVENT = 0x010000000000FE00ULL;
 
    enum LinkStatus
    {
        LINK_UP,  
        LINK_DOWN 
    };
    
    static bool get_mti_address(MTI mti)
    {
        return (mti & MTI_ADDRESS_MASK);
    }
 
    static bool get_mti_event(MTI mti)
    {
        return (mti & MTI_EVENT_MASK);
    }
 
    static bool get_mti_datagram(MTI mti)
    {
        return (mti & MTI_DATAGRAM_MASK);
    }
 
    static unsigned int mti_priority(MTI mti)
    {
        return (mti & MTI_PRIORITY_MASK) >> MTI_PRIORITY_SHIFT;
    }
 
    static const size_t MAX_ADDRESSED_SIZE = 14;
 
private:
    Defs();
};
 
inline EventState invert_event_state(EventState state)
{
    switch (state)
    {
        case EventState::VALID:
            return EventState::INVALID;
        case EventState::INVALID:
            return EventState::VALID;
        default:
            return state;
    }
}
 
inline EventState to_event_state(bool state)
{
    return state ? EventState::VALID : EventState::INVALID;
}
 
inline Defs::MTI operator+(const Defs::MTI &value, EventState state)
{
    int code = static_cast<int>(value);
    code += static_cast<int>(state);
    return static_cast<Defs::MTI>(code);
}
 
inline Defs::MTI operator ++ (Defs::MTI &value, int)
{
    Defs::MTI result = value;
    value = static_cast<Defs::MTI>(static_cast<int>(value) + 1);
    return result;
}
 
inline Defs::MTI& operator ++ (Defs::MTI &value)
{
    value = static_cast<Defs::MTI>(static_cast<int>(value) + 1);
    return value;
}
 
inline Defs::MTI operator -- (Defs::MTI &value, int)
{
    Defs::MTI result = value;
    value = static_cast<Defs::MTI>(static_cast<int>(value) - 1);
    return result;
}
 
inline Defs::MTI& operator -- (Defs::MTI &value)
{
    value = static_cast<Defs::MTI>(static_cast<int>(value) - 1); 
    return value;
}
 
}; /* namespace openlcb */
 
#endif  // _OPENLCB_DEFS_HXX_