simple_temperature.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_ITF_SIMPLE_TEMPERATURE_H
#define HF_ITF_SIMPLE_TEMPERATURE_H

#include "hanfun/common.h"

#include "hanfun/interface.h"

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

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

      namespace SimpleTemperature
      {
         typedef enum _Attributes
         {
            VALUE_ATTR     = 0x01, 
            MINIMUM_ATTR   = 0x02, 
            MAXIMUM_ATTR   = 0x03, 
            TOLERANCE_ATTR = 0x04, 
            __LAST_ATTR__  = TOLERANCE_ATTR,
         } Attributes;

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

            Temperature(int16_t value = 0, HF::Interface *owner = nullptr):
               Attribute<int16_t>(HF::Interface::SIMPLE_TEMPERATURE, ID, owner, value, WRITABBLE)
            {}
         };

         struct MininumTemperature: public HF::Attributes::Attribute<int16_t>
         {
            static constexpr uint8_t ID        = MINIMUM_ATTR;
            static constexpr bool    WRITABBLE = false;

            MininumTemperature(int16_t value = 0, HF::Interface *owner = nullptr):
               Attribute<int16_t>(HF::Interface::SIMPLE_TEMPERATURE, ID, owner, value, WRITABBLE)
            {}
         };

         struct MaximumTemperature: public HF::Attributes::Attribute<int16_t>
         {
            static constexpr uint8_t ID        = MAXIMUM_ATTR;
            static constexpr bool    WRITABBLE = false;

            MaximumTemperature(int16_t value = 0, HF::Interface *owner = nullptr):
               Attribute<int16_t>(HF::Interface::SIMPLE_TEMPERATURE, 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_TEMPERATURE, ID, owner, value, WRITABBLE)
            {}
         };

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

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

            Base() {}
         };

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

            int16_t _value;

            const int16_t _minimum;    
            const int16_t _maximum;    
            const uint16_t _tolerance; 

            public:

            Server(int16_t minimum = std::numeric_limits<int16_t>::min(),
                   int16_t maximum = std::numeric_limits<int16_t>::max(),
                   int16_t tolerance = 0):
               _value(0), _minimum(minimum), _maximum(maximum),
               _tolerance(tolerance)
            {}

            virtual ~Server() {}

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

            int16_t temperature();

            void temperature(int16_t __value);

            int16_t minimum_temperature();

            int16_t maximum_temperature();

            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<SimpleTemperature::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     = SimpleTemperature::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<int16_t> &attr)
            {
               UNUSED(addr);
               UNUSED(attr);
            }

            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_TEMPERATURE_H */