protocol.hpp

#pragma once
#include "core/device/vdb/crc32.hpp"
#include <array>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
namespace VDB {
uint32_t time_ms();
void delay_ms(uint32_t ms);
} // namespace VDB
 
// #define VDPTRACE
#define VDPDEBUG
#define VDPWARN
 
#ifdef VDPWARN
#define VDPWarnf(fmt, ...) printf("WARN: " fmt "\n", ##__VA_ARGS__)
#else
#define VDPWarnf(...)
#endif
 
#ifdef VDPDEBUG
#define VDPDebugf(fmt, ...) printf("DEBUG: " fmt "\n", ##__VA_ARGS__)
#else
#define VDPDebugf(...)
#endif
 
#ifdef VDPTRACE
#define VDPTracef(fmt, ...) printf("TRACE: " fmt "\n", ##__VA_ARGS__)
#else
#define VDPTracef(...)
#endif
 
namespace VDP {
constexpr size_t MAX_CHANNELS = 256;
 
class Part;
// Shared Part Pointer to delete an object that has no pointer pointing to it
//
using PartPtr = std::shared_ptr<Part>;
// Packet of bytes stored in a vector of 8 bit unsigned integers
using Packet = std::vector<uint8_t>;
 
// defines a channel id as an 8bit unsigned integer
using ChannelID = uint8_t;
class Channel {
  public:
    template <typename MutexType> friend class RegistryListener;
    friend class RegistryController;
    explicit Channel(PartPtr data) : data(data) {}
    PartPtr data;
    /*
     * @return The Channel ID from 0 - 256
     */
    ChannelID getID() const;
 
  private:
    Channel(PartPtr data, ChannelID channel_id) : data(data), id(channel_id) {}
 
    ChannelID id = 0;
    Packet packet_scratch_space;
    bool acked = false;
    // std::vector
};

void dump_packet_hex(const Packet &pac);
void dump_packet_8bit(const Packet &pac);

enum class PacketType : uint8_t {
  Broadcast = 0b00000000,
  Data = 0b10000000
};
enum class PacketFunction : uint8_t {
  Send = 0b00000000,
  Acknowledge = 0b00100000,
  Response = 0b01000000,
  Request = 0b01100000
};
struct PacketHeader {
    PacketType type;
    PacketFunction func;
};
enum PacketValidity : uint8_t {
    Ok,
    BadChecksum,
    TooSmall,
};
PacketValidity validate_packet(const VDP::Packet &packet);
enum class Type : uint8_t {
    Record = 0,
    String = 1,
    // Enum
 
    Double = 3,
    Float = 4,
 
    Uint8 = 5,
    Uint16 = 6,
    Uint32 = 7,
    Uint64 = 8,
 
    Int8 = 9,
    Int16 = 10,
    Int32 = 11,
    Int64 = 12,
 
};
 
std::string to_string(Type t);
 
class PacketReader;
class PacketWriter;
class Visitor;
void add_indents(std::stringstream &ss, size_t indent);

class Part {
    friend class PacketReader;
    friend class PacketWriter;
    friend class Record;
 
  public:
    Part(std::string name);
    /*
     * Deleter for the Part, used to delete the data once it is no longer needed
     * i.e after it has been sent to the debug board
     */
    virtual ~Part();
    std::string pretty_print() const;
    std::string pretty_print_data() const;
    /*
     * sets the data the part contains, meant to be overrided
     */
    virtual void fetch() = 0;
 
    virtual void response();
 
    template<typename T>
      PartPtr to_PartPtr(){
        return std::make_shared<T>(this);
      };
 
    virtual VDP::PartPtr clone() = 0;
    virtual void read_data_from_message(PacketReader &reader) = 0;
 
    std::string get_name() const;
 
    virtual void Visit(Visitor *) = 0;
 
  protected:
    // These are needed to decode correctly but you shouldn't call them directly
    virtual void write_schema(PacketWriter &sofar) const = 0;
    virtual void write_message(PacketWriter &sofar) const = 0;
    virtual void pprint(std::stringstream &ss, size_t indent) const = 0;
    virtual void pprint_data(std::stringstream &ss, size_t indent) const = 0;
 
    std::string name;
};
/*
 * Defines a PacketReader, it reads packets
 */
class PacketReader {
  public:
    PacketReader(Packet pac);
    PacketReader(Packet pac, size_t start);
    uint8_t get_byte();
    Type get_type();
    std::string get_string();

    template <typename Number> Number get_number() {
        // ensures that the function is only used on numbers
        static_assert(
          std::is_floating_point<Number>::value || std::is_integral<Number>::value,
          "This function should only be used on numbers"
        );
        // checks that the size of the number its trying to read combined with its location
        // doesnt put it past the packet size
        if (read_head + sizeof(Number) > pac.size()) {
            printf(
              "%s:%d: Reading a number[%d] at position %d would read past "
              "buffer of "
              "size %d\n",
              __FILE__, __LINE__, sizeof(Number), read_head, pac.size()
            );
            return 0;
        }
        Number value = 0;
        // copies the the number at the reader head to the Number's stored value and
        // adds the size of the number to the read head so it moves on to the next set of bits
        std::memcpy(&value, &pac[read_head], sizeof(Number));
        read_head += sizeof(Number);
        return value;
    }
 
  private:
    Packet pac;
    size_t read_head;
};
class PacketWriter {
  public:
    explicit PacketWriter(Packet &scratch_space);
    void clear();
    size_t size();
    void write_byte(uint8_t b);
    void write_type(Type t);
    void write_string(const std::string &str);
    void write_channel_acknowledge(const Channel &chan);
    void write_channel_broadcast(const Channel &chan);
    void write_response(std::deque<Channel> &channels);
    void write_data_message(const Channel &part);
    void write_request();
    const Packet &get_packet() const;
    template <typename Number> void write_number(const Number &num) {
        std::array<uint8_t, sizeof(Number)> bytes;
        std::memcpy(&bytes, &num, sizeof(Number));
        for (const uint8_t b : bytes) {
            write_byte(b);
        }
    }
 
  private:
    Packet &sofar;
};

class AbstractDevice {
  public:
    virtual bool send_packet(const VDP::Packet &packet) = 0;
    virtual void register_receive_callback(std::function<void(const VDP::Packet &packet)> callback) = 0;
    virtual ~AbstractDevice();
};

PartPtr make_decoder(PacketReader &pac);
uint8_t make_header_byte(PacketHeader head);
PacketHeader decode_header_byte(uint8_t hb);
std::pair<ChannelID, PartPtr> decode_broadcast(const Packet &packet);
 
std::pair<ChannelID, PartPtr> decode_data(const Packet &packet);
 
} // namespace VDP