RailCom.hxx

Go to the documentation of this file.

 
#ifndef _DCC_RAILCOM_HXX_
#define _DCC_RAILCOM_HXX_
 
#include <cstdint>
#include <string>
#include <vector>
 
#include "dcc/railcom.h"
 
namespace dcc
{
 
struct Feedback : public DCCFeedback
{
    void reset(uint32_t feedback_key)
    {
        this->feedbackKey = feedback_key;
        ch1Size = 0;
        ch2Size = 0;
        channel = 0;
    }
 
    void add_ch1_data(uint8_t data)
    {
        if (ch1Size < sizeof(ch1Data))
        {
            ch1Data[ch1Size++] = data;
        }
    }
 
    void add_ch2_data(uint8_t data)
    {
        if (ch2Size < sizeof(ch2Data))
        {
            ch2Data[ch2Size++] = data;
        }
    }
};
 
std::string railcom_debug(const Feedback& fb);
 
extern const uint8_t railcom_decode[256];
extern const uint8_t railcom_encode[64];
 
struct RailcomDefs
{
    // These values appear in the railcom_decode table to mean special symbols.
    enum
    {
        INV = 0xff,
        ACK = 0xfe,
        NACK = 0xfd,
        BUSY = 0xfc,
 
        RESVD1 = 0xfb,
        RESVD2 = 0xfa,
    };
 
    // These values need to be sent on the UART
    enum
    {
        CODE_ACK = 0xf0,
        CODE_ACK2 = 0x0f,
        CODE_NACK = 0x3c,
        CODE_BUSY = 0xE1,
    };
 
    static uint16_t encode12(uint8_t nibble, uint8_t data)
    {
        return (railcom_encode[((nibble << 2) | (data >> 6)) & 0x3F] << 8) |
            railcom_encode[data & 0x3f];
    }
 
    static void append12(uint8_t nibble, uint8_t data, uint8_t* dst)
    {
        *dst++ = railcom_encode[((nibble << 2) | (data >> 6)) & 0x3F]; 
        *dst++ = railcom_encode[data & 0x3f]; 
    }
 
    static void append36(uint8_t nibble, uint32_t data, uint8_t* dst)
    {
        *dst++ = railcom_encode[((nibble << 2) | (data >> 30)) & 0x3F]; 
        *dst++ = railcom_encode[(data >> 24) & 0x3F]; 
        *dst++ = railcom_encode[(data >> 18) & 0x3F]; 
        *dst++ = railcom_encode[(data >> 12) & 0x3F]; 
        *dst++ = railcom_encode[(data >> 6) & 0x3F]; 
        *dst++ = railcom_encode[data & 0x3F]; 
    }
 
    static void add_did_feedback(uint64_t decoder_id, Feedback *fb);
 
    static void add_shortinfo_feedback(uint16_t requested_address,
        uint8_t max_fn, uint8_t psupp, uint8_t ssupp, Feedback *fb);
 
    static void add_assign_feedback(uint8_t changeflags, uint16_t changecount,
        uint8_t supp2, uint8_t supp3, Feedback *fb);
 
private:
    RailcomDefs();
};
 
 
enum RailcomMobilePacketId
{
    RMOB_POM = 0,
    RMOB_ADRHIGH = 1,
    RMOB_ADRLOW = 2,
    RMOB_EXT = 3,
    RMOB_DYN = 7,
    RMOB_XPOM0 = 8,
    RMOB_XPOM1 = 9,
    RMOB_XPOM2 = 10,
    RMOB_XPOM3 = 11,
    RMOB_SUBID = 12,
    RMOB_LOGON_ASSIGN_FEEDBACK = 13,
    RMOB_LOGON_ENABLE_FEEDBACK = 15,
};
 
struct RailcomPacket
{
    enum
    {
        GARBAGE,
        ACK,
        NACK,
        BUSY,
        MOB_POM,
        MOB_ADRHIGH,
        MOB_ADRLOW,
        MOB_EXT,
        MOB_DYN,
        MOB_XPOM0,
        MOB_XPOM1,
        MOB_XPOM2,
        MOB_XPOM3,
        MOB_SUBID
    };
    uint8_t hw_channel;
    uint8_t railcom_channel;
    uint8_t type;
    uint32_t argument;
    RailcomPacket(uint8_t _hw_channel, uint8_t _railcom_channel, uint8_t _type,
        uint32_t _argument)
        : hw_channel(_hw_channel)
        , railcom_channel(_railcom_channel)
        , type(_type)
        , argument(_argument)
    {
    }
};
 
void parse_railcom_data(
    const dcc::Feedback &fb, std::vector<struct RailcomPacket> *output);
 
}  // namespace dcc
 
#endif // _DCC_RAILCOM_HXX_