protocol.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_PROTOCOL_H
#define HF_PROTOCOL_H

#include "hanfun/common.h"

// =============================================================================
// API
// =============================================================================

namespace HF
{
   // Forward declaration.
   namespace Transport
   {
      struct Link;
   }

   namespace Protocol
   {
      constexpr uint16_t BROADCAST_ADDR = 0x7FFF;

      constexpr uint8_t BROADCAST_UNIT = 0xFF;

      constexpr uint16_t MAX_PAYLOAD = 0x01FF;

      // =============================================================================
      // Classes
      // =============================================================================

      struct Message
      {
         typedef enum _Type
         {
            COMMAND_REQ                   = 0x01, 
            COMMAND_RESP_REQ              = 0x02, 
            COMMAND_RES                   = 0x03, 

            GET_ATTR_REQ                  = 0x04, 
            GET_ATTR_RES                  = 0x05, 

            SET_ATTR_REQ                  = 0x06, 
            SET_ATTR_RESP_REQ             = 0x07, 
            SET_ATTR_RES                  = 0x08, 

            GET_ATTR_PACK_REQ             = 0x09, 
            GET_ATTR_PACK_RES             = 0x0A, 

            SET_ATTR_PACK_REQ             = 0x0B, 
            SET_ATTR_PACK_RESP_REQ        = 0x0C, 
            SET_ATTR_PACK_RES             = 0x0D, 

            ATOMIC_SET_ATTR_PACK_REQ      = 0x0E, 
            ATOMIC_SET_ATTR_PACK_RESP_REQ = 0x0F, 
            ATOMIC_SET_ATTR_PACK_RES      = 0x10, 
         } Type;

         struct Interface: public Common::Interface
         {
            static const uint16_t min_size = Common::Interface::min_size // Interface UID.
                                             + sizeof(uint8_t);          // Interface Member.

            uint8_t member;            

            Interface(uint16_t uid = 0, uint8_t role = 0, uint8_t member = 0):
               Common::Interface(uid, role), member(member)
            {}

            uint16_t size() const;

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         // =============================================================================
         // API
         // =============================================================================

         uint8_t   reference;          
         Type      type;               

         Interface itf;                

         Common::ByteArray payload;

         uint16_t length;

         Message(uint16_t size = 0, Type _type = COMMAND_REQ):
            reference(0), type(_type), payload(Common::ByteArray(size)), length(0)
         {
            assert(size <= MAX_PAYLOAD);
         }

         Message(const Message &parent, uint16_t size);

         static constexpr uint16_t min_size = sizeof(uint8_t)       // Application Reference.
                                              + sizeof(uint8_t)     // Message Type.
                                              + Interface::min_size // Interface UID + Member.
                                              + sizeof(uint16_t);   // Payload Length Value.

         uint16_t size() const;

         uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);

         bool isCommand() const;

         bool isCommandResponse() const;
      };

      struct Address
      {
         uint16_t mod    : 1;    
         uint16_t device : 15;   

         uint8_t  unit;          

         typedef enum _Type
         {
            DEVICE = 0,   
            GROUP  = 1,   
         } Type;

         Address(uint16_t _dev = BROADCAST_ADDR, uint8_t _unit = BROADCAST_UNIT,
                 Type _mod = DEVICE):
            mod(_mod), device(_dev), unit(_unit)
         {}

         static constexpr uint16_t min_size = sizeof(uint16_t)    // Device Address + Flag.
                                              + sizeof(uint8_t);  // Unit Address.

         uint16_t size() const;

         uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);

         bool is_broadcast()
         {
            return device == BROADCAST_ADDR && unit == BROADCAST_UNIT;
         }

         bool is_local(uint16_t address)
         {
            return this->device == address;
         }

         int compare(const Address &other) const
         {
            auto serialize = [this](const Address &a)
                             {
                                return (((a.mod & 0x01) << 15) | (a.device & BROADCAST_ADDR)) |
                                       a.unit;
                             };

            uint32_t t = serialize(*this);
            uint32_t o = serialize(other);

            return t - o;
         }
      };

      struct Packet
      {
         Address source;           
         Address destination;      

         Message message;

         Transport::Link *link;

         Packet(): link(nullptr) {}

         Packet(Message &message): message(message), link(nullptr) {}

         Packet(Address &dst_addr, Message &message, uint8_t unit = BROADCAST_UNIT):
            destination(dst_addr), message(message), link(nullptr)
         {
            source.mod    = Address::DEVICE;
            source.device = BROADCAST_ADDR;
            source.unit   = unit;
         }

         Packet(Address &src_addr, Address &dst_addr, Message &message):
            source(src_addr), destination(dst_addr), message(message), link(nullptr)
         {}

         static constexpr uint16_t header_min_size = Address::min_size   // Source Address.
                                                     + Address::min_size // Destination Address.
                                                     + sizeof(uint16_t); // Transport Layer header.

         static constexpr uint16_t min_size = header_min_size        // Network header size.
                                              + Message::min_size;   // Message size.

         uint16_t size() const;

         uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
      };

      struct Response
      {
         // =============================================================================
         // API
         // =============================================================================

         constexpr static uint16_t min_size = sizeof(uint8_t);

         Common::Result            code;

         Response(Common::Result code = Common::Result::OK): code(code) {}

         template<typename T>
         Response(T code = static_cast<T>(Common::Result::OK)):
            code(static_cast<Common::Result>(code)) {}

         uint16_t size() const;

         uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
      };

      // =============================================================================
      // Filter classes
      // =============================================================================

      namespace Filters
      {
         class ResponseRequired
         {
            protected:

            struct Entry
            {
               uint16_t           address; 
               Message::Type      type;    
               Message::Interface itf;     

               Entry(uint16_t _address, Message::Type _type, Message::Interface _itf):
                  address(_address), type(_type), itf(_itf)
               {}

               Entry(const Packet &packet): address(packet.destination.device),
                  type(packet.message.type), itf(packet.message.itf)
               {}
            };

            std::list<Entry> db;

            public:

            bool operator()(const HF::Protocol::Packet &packet);

            uint16_t size() const
            {
               return db.size();
            }
         };

      }  // namespace Filters

      // =============================================================================
      // Operators
      // =============================================================================

      inline bool operator==(Address const &lhs, Address const &rhs)
      {
         return (lhs.device == rhs.device) && (lhs.unit == rhs.unit) && (lhs.mod == rhs.mod);
      }

      inline bool operator!=(Address const &lhs, Address const &rhs)
      {
         return !(lhs == rhs);
      }

      inline bool operator<(Address const &lhs, Address const &rhs)
      {
         return (lhs.device < rhs.device) ||
                (lhs.device == rhs.device &&
                 (lhs.mod < rhs.mod || (lhs.mod == rhs.mod && lhs.unit < rhs.unit)));
      }

      // =============================================================================
      // Helper Functions
      // =============================================================================

      bool request(Message::Type type, bool response = false);

      bool response(Message::Type type);

      bool matches(Message::Type lhs, Message::Type rhs);

   }  // namespace Protocol

}  // namespace HF

// =============================================================================
// Stream Helpers
// =============================================================================

std::ostream &operator<<(std::ostream &stream, const HF::Protocol::Message::Type type);

std::ostream &operator<<(std::ostream &stream, const HF::Protocol::Message &message);

std::ostream &operator<<(std::ostream &stream, const HF::Protocol::Address &address);

std::ostream &operator<<(std::ostream &stream, const HF::Protocol::Packet &packet);

#endif /* HF_PROTOCOL_H */