simple_humidity.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_ITF_SIMPLE_HUMIDITY_H
#define HF_ITF_SIMPLE_HUMIDITY_H

#include "hanfun/common.h"

#include "hanfun/interface.h"

namespace HF
{
   namespace Interfaces
   {
      namespace SimpleHumidity
      {
         class Server;
      }

      HF::Attributes::IAttribute *create_attribute(HF::Interfaces::SimpleHumidity::Server *server,
                                                   uint8_t uid);

      namespace SimpleHumidity
      {
         typedef enum _Attributes
         {
            VALUE_ATTR     = 0x01, 
            TOLERANCE_ATTR = 0x02, 
            __LAST_ATTR__  = TOLERANCE_ATTR,
         } Attributes;

         struct Humidity: public HF::Attributes::Attribute<uint16_t>
         {
            static constexpr uint8_t ID        = VALUE_ATTR;
            static constexpr bool    WRITABBLE = false;

            Humidity(uint16_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint16_t>(HF::Interface::SIMPLE_HUMIDITY, ID, owner, value, WRITABBLE)
            {}
         };

         struct Tolerance: public HF::Attributes::Attribute<uint16_t>
         {
            static constexpr uint8_t ID        = TOLERANCE_ATTR;
            static constexpr bool    WRITABBLE = false;

            Tolerance(uint16_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint16_t>(HF::Interface::SIMPLE_HUMIDITY, ID, owner, value, WRITABBLE)
            {}
         };

         inline HF::Attributes::IAttribute *create_attribute(uint8_t uid)
         {
            return Interfaces::create_attribute(static_cast<SimpleHumidity::Server *>(nullptr),
                                                uid);
         }

         struct Base: public Interface<HF::Interface::SIMPLE_HUMIDITY>
         {
            protected:

            Base() {}
         };

         class Server: public InterfaceRole<SimpleHumidity::Base, HF::Interface::SERVER_ROLE>
         {
            protected:

            uint16_t _value;

            const uint16_t _tolerance;

            public:

            Server(uint16_t tolerance = 0): _value(0), _tolerance(tolerance)
            {}

            virtual ~Server() {}

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

            uint16_t humidity();

            void humidity(uint16_t __value);

            uint16_t tolerance();

            // =============================================================================
            // Attributes API
            // =============================================================================

            HF::Attributes::IAttribute *attribute(uint8_t uid)
            {
               return Interfaces::create_attribute(this, uid);
            }

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const;
         };

         class Client: public InterfaceRole<SimpleHumidity::Base, HF::Interface::CLIENT_ROLE>
         {
            public:

            // ======================================================================
            // Commands
            // ======================================================================

            void read_all(Protocol::Address &addr);

            template<Attributes _Attribute>
            void read(Protocol::Address &addr)
            {
               Protocol::Message message;

               message.itf.role   = SERVER_ROLE;
               message.itf.id     = SimpleHumidity::Client::uid();
               message.itf.member = _Attribute;
               message.type       = Protocol::Message::GET_ATTR_REQ;

               send(addr, message);
            }

            // ======================================================================

            // ======================================================================
            // Events
            // ======================================================================

            virtual void read_resp(const Protocol::Address &addr,
                                   const HF::Attributes::Attribute<uint16_t> &attr)
            {
               UNUSED(addr);
               UNUSED(attr);
            }

            // ======================================================================

            protected:

            Common::Result handle_attribute(Protocol::Packet &packet, Common::ByteArray &payload,
                                            uint16_t offset);

         };

      }
   }
}

#endif /* HF_ITF_SIMPLE_HUMIDITY_H */