MemoryConfigDefs.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_MEMORYCONFIGDEFS_HXX_
#define _OPENLCB_MEMORYCONFIGDEFS_HXX_
 
#include "openlcb/DatagramDefs.hxx"
#include "openlcb/Defs.hxx"
#include "utils/macros.h"
 
namespace openlcb
{
 
struct MemoryConfigDefs
{
    using DatagramPayload = string;
 
    enum commands
    {
        COMMAND_MASK              = 0xFC,
        COMMAND_FLAG_MASK         = 0x03, 
        COMMAND_PRESENT_MASK      = 0x01, 
        COMMAND_REPLY_BIT_FOR_RW  = 0x10, 
        COMMAND_WRITE             = 0x00, 
        COMMAND_WRITE_UNDER_MASK  = 0x08, 
        COMMAND_WRITE_REPLY       = 0x10, 
        COMMAND_WRITE_FAILED      = 0x18, 
        COMMAND_WRITE_STREAM      = 0x20, 
        COMMAND_WRITE_STREAM_REPLY= 0x30, 
        COMMAND_WRITE_STREAM_FAILED= 0x38, 
        COMMAND_READ              = 0x40, 
        COMMAND_READ_REPLY        = 0x50, 
        COMMAND_READ_FAILED       = 0x58, 
        COMMAND_READ_STREAM       = 0x60, 
        COMMAND_READ_STREAM_REPLY = 0x70, 
        COMMAND_READ_STREAM_FAILED= 0x78, 
        COMMAND_MAX_FOR_RW        = 0x80, 
        COMMAND_OPTIONS           = 0x80,
        COMMAND_OPTIONS_REPLY     = 0x82,
        COMMAND_INFORMATION       = 0x84,
        COMMAND_INFORMATION_REPLY = 0x86,
        COMMAND_LOCK              = 0x88, 
        COMMAND_LOCK_REPLY        = 0x8A, 
        COMMAND_UNIQUE_ID         = 0x8C, 
        COMMAND_UNIQUE_ID_REPLY   = 0x8D, 
        COMMAND_UPDATE_COMPLETE   = 0xA8, 
        COMMAND_RESET             = 0xA9, 
        COMMAND_FACTORY_RESET     = 0xAA, 
        COMMAND_ENTER_BOOTLOADER  = 0xAB, 
        COMMAND_FREEZE            = 0xA1, 
        COMMAND_UNFREEZE          = 0xA0, 
        COMMAND_PRESENT    = 0x01, 
        COMMAND_CDI        = 0x03, 
        COMMAND_ALL_MEMORY = 0x02, 
        COMMAND_CONFIG     = 0x01, 
    };
 
    enum spaces
    {
        SPACE_SPECIAL    = 0xFC, 
        SPACE_CDI        = 0xFF, 
        SPACE_ALL_MEMORY = 0xFE, 
        SPACE_CONFIG     = 0xFD, 
        SPACE_ACDI_SYS   = 0xFC, 
        SPACE_ACDI_USR   = 0xFB, 
        SPACE_FDI        = 0xFA, 
        SPACE_FUNCTION   = 0xF9, 
        SPACE_DCC_CV     = 0xF8, 
        SPACE_FIRMWARE   = 0xEF, 
    };
 
    enum available
    {
        AVAIL_WUM   = 0x8000, 
        AVAIL_UR    = 0x4000, 
        AVAIL_UW    = 0x2000, 
        AVAIL_SR    = 0x1000, 
        AVAIL_R0xFC = 0x0800, 
        AVAIL_R0xFB = 0x0400, 
        AVAIL_W0xFB = 0x0200, 
    };
 
    enum lengths
    {
        LENGTH_1         = 0x80, 
        LENGTH_2         = 0x40, 
        LENGTH_4         = 0x20, 
        LENGTH_63        = 0x10, 
        LENGTH_ARBITRARY = 0x02, 
        LENGTH_STREAM    = 0x01, 
    };
 
    enum flags
    {
        FLAG_RO   = 0x01, 
        FLAG_NZLA = 0x02, 
    };
 
    enum errors
    {
        ERROR_SPACE_NOT_KNOWN = Defs::ERROR_INVALID_ARGS | 0x0001,
        ERROR_OUT_OF_BOUNDS = Defs::ERROR_INVALID_ARGS | 0x0002,
        ERROR_WRITE_TO_RO = Defs::ERROR_INVALID_ARGS | 0x0003,
    };
 
    static constexpr unsigned MAX_DATAGRAM_RW_BYTES = 64;
 
    static bool is_special_space(uint8_t space)
    {
        return space > SPACE_SPECIAL;
    }
 
    static DatagramPayload write_datagram(
        uint8_t space, uint32_t offset, const string &data = "")
    {
        DatagramPayload p;
        p.reserve(7 + data.size());
        p.push_back(DatagramDefs::CONFIGURATION);
        p.push_back(COMMAND_WRITE);
        p.push_back(0xff & (offset >> 24));
        p.push_back(0xff & (offset >> 16));
        p.push_back(0xff & (offset >> 8));
        p.push_back(0xff & (offset));
        if (is_special_space(space))
        {
            p[1] |= space & ~SPACE_SPECIAL;
        }
        else
        {
            p.push_back(space);
        }
        p += data;
        return p;
    }
 
    static DatagramPayload read_datagram(
        uint8_t space, uint32_t offset, uint8_t length)
    {
        DatagramPayload p;
        p.reserve(7);
        p.push_back(DatagramDefs::CONFIGURATION);
        p.push_back(COMMAND_READ);
        p.push_back(0xff & (offset >> 24));
        p.push_back(0xff & (offset >> 16));
        p.push_back(0xff & (offset >> 8));
        p.push_back(0xff & (offset));
        if (is_special_space(space))
        {
            p[1] |= space & ~SPACE_SPECIAL;
        }
        else
        {
            p.push_back(space);
        }
        p.push_back(length);
        return p;
    }
 
    static DatagramPayload read_stream_datagram(uint8_t space, uint32_t offset,
        uint8_t dst_stream_id, uint32_t length = 0xFFFFFFFF)
    {
        DatagramPayload p;
        p.reserve(13);
        p.push_back(DatagramDefs::CONFIGURATION);
        p.push_back(COMMAND_READ_STREAM);
        p.push_back(0xff & (offset >> 24));
        p.push_back(0xff & (offset >> 16));
        p.push_back(0xff & (offset >> 8));
        p.push_back(0xff & (offset));
        if (is_special_space(space))
        {
            p[1] |= space & ~SPACE_SPECIAL;
        }
        else
        {
            p.push_back(space);
        }
        p.push_back(0xff); // src ID
        p.push_back(dst_stream_id); // dst ID
        p.push_back(0xff & (length >> 24));
        p.push_back(0xff & (length >> 16));
        p.push_back(0xff & (length >> 8));
        p.push_back(0xff & (length));
        return p;
    }
    
    static bool payload_min_length_check(
        const DatagramPayload &payload, unsigned extra)
    {
        auto *bytes = payload_bytes(payload);
        size_t sz = payload.size();
        if (sz < 6 + extra)
        {
            return false;
        }
        if (((bytes[1] & COMMAND_FLAG_MASK) == 0) && (sz < 7 + extra))
        {
            return false;
        }
        return true;
    }
 
    static uint8_t get_space(const DatagramPayload &payload)
    {
        auto *bytes = payload_bytes(payload);
        if (bytes[1] & COMMAND_FLAG_MASK)
        {
            return COMMAND_MASK + (bytes[1] & COMMAND_FLAG_MASK);
        }
        return bytes[6];
    }
 
    static unsigned get_payload_offset(const DatagramPayload &payload)
    {
        auto *bytes = payload_bytes(payload);
        if (bytes[1] & COMMAND_FLAG_MASK)
        {
            return 6;
        }
        else
        {
            return 7;
        }
    }
 
    static uint32_t get_address(const DatagramPayload &payload)
    {
        auto *bytes = payload_bytes(payload);
        uint32_t a = bytes[2];
        a <<= 8;
        a |= bytes[3];
        a <<= 8;
        a |= bytes[4];
        a <<= 8;
        a |= bytes[5];
        return a;
    }
 
    static const uint8_t *payload_bytes(const DatagramPayload &payload)
    {
        return (uint8_t *)payload.data();
    }
 
private:
    MemoryConfigDefs();
};
 
} // namespace openlcb
 
#endif // _OPENLCB_MEMORYCONFIGDEFS_HXX_