TractionModemDefs.hxx

 
#ifndef _TRACTIONMODEM_TRACTIONMODEMDEFS_HXX_
#define _TRACTIONMODEM_TRACTIONMODEMDEFS_HXX_
 
#include <string>
 
#include "openlcb/Velocity.hxx"
#include "utils/Crc.hxx"
 
namespace traction_modem
{
 
struct Defs
{
    using Payload = std::string;
 
    static constexpr uint32_t PREAMBLE = 0x41d2c37a;
    static constexpr char PREAMBLE_FIRST = 0x41;
 
    static constexpr uint16_t RESPONSE = 0x8000;
 
    enum Command : uint16_t
    {
        CMD_PING              = 0x0000, 
        CMD_NOP               = 0x0001, 
        CMD_REBOOT            = 0x0002, 
        CMD_BAUD_RATE_QUERY   = 0x0003, 
        CMD_BAUD_RATE_REQUEST = 0x0004, 
        CMD_SPEED_SET         = 0x0100, 
        CMD_FN_SET            = 0x0101, 
        CMD_ESTOP_SET         = 0x0102, 
        CMD_SPEED_QUERY       = 0x0110, 
        CMD_FN_QUERY          = 0x0111, 
        CMD_DC_DCC_PRESENT    = 0x0200, 
        CMD_WIRELESS_PRESENT  = 0x0201, 
        CMD_MEM_R             = 0x1000, 
        CMD_MEM_W             = 0x1001, 
 
        //
        // response commands
        //
        RESP_PING             = RESPONSE | CMD_PING,
        RESP_BAUD_RATE_QUERY  = RESPONSE | CMD_BAUD_RATE_QUERY,
        RESP_SPEED_SET        = RESPONSE | CMD_SPEED_SET,
        RESP_FN_SET           = RESPONSE | CMD_FN_SET,
        RESP_ESTOP_SET        = RESPONSE | CMD_ESTOP_SET,
        RESP_SPEED_QUERY      = RESPONSE | CMD_SPEED_QUERY,
        RESP_FN_QUERY         = RESPONSE | CMD_FN_QUERY,
        RESP_DC_DCC_PRESENT   = RESPONSE | CMD_DC_DCC_PRESENT,
        RESP_WIRELESS_PRESENT = RESPONSE | CMD_WIRELESS_PRESENT,
        RESP_MEM_R            = RESPONSE | CMD_MEM_R,
        RESP_MEM_W            = RESPONSE | CMD_MEM_W,
    };
 
    static constexpr unsigned LEN_HEADER = 4+2+2;
 
    static constexpr unsigned LEN_BASE = 14;
    static constexpr unsigned LEN_FN_SET = 6;
    static constexpr unsigned LEN_SPEED_SET = 1;
    static constexpr unsigned LEN_ESTOP_SET = 0;
    static constexpr unsigned LEN_WIRELESS_PRESENT = 1;
    static constexpr unsigned LEN_MEM_R = 6;
    static constexpr unsigned LEN_MEM_W = 5;
 
    static constexpr unsigned MAX_LEN = 512;
 
    static constexpr unsigned OFS_CMD = 4;
    static constexpr unsigned OFS_LEN = 6;
    static constexpr unsigned OFS_DATA = 8;
 
    struct Header
    {
        uint32_t preamble_; 
        uint16_t command_; 
        uint16_t length_; 
    };
 
    struct Message
    {
        Header header_; 
        uint8_t data[0]; 
    };
 
    // CRC definition of a message.
    struct CRC
    {
        union
        {
            uint16_t crc[3];
            struct
            {
                uint16_t all_; 
                uint16_t even_; 
                uint16_t odd_; 
            };
        };
 
        bool operator==(const CRC &c)
        {
            return (all_ == c.all_ && even_ == c.even_ && odd_ == c.odd_);
        }
 
        bool operator!=(const CRC &c)
        {
            return !(all_ == c.all_ && even_ == c.even_ && odd_ == c.odd_);
        }
    };
 
    static Payload get_wireless_present_payload(bool is_present)
    {
        Payload p;
        prepare(&p, CMD_WIRELESS_PRESENT, LEN_WIRELESS_PRESENT);
        append_uint8(&p, is_present ? 1 : 0);
 
        append_crc(&p);
        return p;
    }
 
    static Payload get_fn_set_payload(unsigned fn, uint16_t value)
    {
        Payload p;
        prepare(&p, CMD_FN_SET, LEN_FN_SET);
        append_uint32(&p, fn);
        append_uint16(&p, value);
 
        append_crc(&p);
        return p;
    }
 
    static Payload get_speed_set_payload(openlcb::Velocity v)
    {
        Payload p;
        prepare(&p, CMD_SPEED_SET, LEN_SPEED_SET);
        append_uint8(&p, v.get_dcc_128());
 
        append_crc(&p);
        return p;
    }
 
    static Payload get_estop_payload()
    {
        Payload p;
        prepare(&p, CMD_ESTOP_SET, LEN_ESTOP_SET);
        // no data in the payload
        append_crc(&p);
        return p;
    }
 
    static Payload get_memr_payload(
        uint8_t space, uint32_t address, uint8_t count)
    {
        Payload p;
        prepare(&p, CMD_MEM_R, LEN_MEM_R);
        append_uint32(&p, address);
        append_uint8(&p, space);
        append_uint8(&p, count);
 
        append_crc(&p);
        return p;
    }
 
    static Payload get_memw_payload(
        uint8_t space, uint32_t address, const std::string& data)
    {
        return get_memw_payload(space, address, (const uint8_t*)data.data(), data.size());
    }
 
    static Payload get_memw_payload(
        uint8_t space, uint32_t address, const uint8_t* buf, size_t count)
    {
        Payload p;
        prepare(&p, CMD_MEM_W, LEN_MEM_W + count);
        append_uint32(&p, address);
        append_uint8(&p, space);
        p.append((char*)buf, count);
 
        append_crc(&p);
        return p;
    }
 
    static void append_uint32(Payload *p, uint32_t v)
    {
        p->push_back(v >> 24);
        p->push_back((v >> 16) & 0xff);
        p->push_back((v >> 8) & 0xff);
        p->push_back((v)&0xff);
    }
 
    static void append_uint16(Payload *p, uint16_t v)
    {
        p->push_back((v >> 8) & 0xff);
        p->push_back((v)&0xff);
    }
 
    static void append_uint8(Payload *p, uint8_t v)
    {
        p->push_back((v)&0xff);
    }
 
    static void prepare(Payload *p, Command cmd, uint16_t len)
    {
        p->reserve(LEN_BASE + len);
        append_uint32(p, PREAMBLE);
        append_uint16(p, cmd);
        append_uint16(p, len);
    }
 
    static void append_crc(Payload *p)
    {
        CRC crc;
        crc3_crc16_ccitt(p->data() + sizeof(uint32_t),
            p->size() - sizeof(uint32_t), crc.crc);
        append_uint16(p, crc.all_);
        append_uint16(p, crc.even_);
        append_uint16(p, crc.odd_);
    }
 
    static uint32_t get_uint32(const Payload &p, unsigned ofs)
    {
        uint32_t ret;
        if ((ofs + 4) <= p.size())
        {
            memcpy(&ret, p.data() + ofs, 4);
            return be32toh(ret);
        }
        return 0;
    }
 
    static uint16_t get_uint16(const Payload &p, unsigned ofs)
    {
        uint16_t ret;
        if ((ofs + 2) <= p.size())
        {
            memcpy(&ret, p.data() + ofs, 2);
            return be16toh(ret);
        }
        return 0;
    }
 
    static const CRC get_crc(const Payload &p, uint16_t length)
    {
        CRC result;
        result.all_ = get_uint16(p, length + sizeof(Header));
        result.even_ = get_uint16(p, length + sizeof(Header) + 2);
        result.odd_ = get_uint16(p, length + sizeof(Header) + 4);
        return result;
    }
 
    static bool is_valid(const Payload &p)
    {
        if (get_uint32(p, 0) != PREAMBLE)
        {
            return false;
        }
        uint16_t len = get_uint16(p, OFS_LEN);
        if ((p.size() != LEN_BASE + len) || len > MAX_LEN)
        {
            return false;
        }
        return true;
    }
}; // struct Defs
 
} // namespace traction_modem
 
#endif // _TRACTIONMODEM_TRACTIONMODEMDEFS_HXX_