simple_light_sensor.h

Go to the documentation of this file.

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

#ifndef HF_ITF_SIMPLE_LIGHT_SENSOR_H
#define HF_ITF_SIMPLE_LIGHT_SENSOR_H

#include "hanfun/protocol.h"
#include "hanfun/interface.h"

namespace HF
{
   namespace Interfaces
   {
      // Forward declaration.
      namespace SimpleLightSensor
      {
         class Server;
      }

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

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

         // =============================================================================
         // Attribute Helper classes
         // =============================================================================

         struct Value: public HF::Attributes::Attribute<uint32_t>
         {
            static constexpr uint8_t ID       = VALUE_ATTR; 
            static constexpr bool    WRITABLE = false;      

            Value(uint32_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint32_t>(HF::Interface::SIMPLE_LIGHT_SENSOR, ID, owner, value, WRITABLE)
            {}
         };

         struct Minimum: public HF::Attributes::Attribute<uint32_t>
         {
            static constexpr uint8_t ID       = MINIMUM_ATTR; 
            static constexpr bool    WRITABLE = false;        

            Minimum(uint32_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint32_t>(HF::Interface::SIMPLE_LIGHT_SENSOR, ID, owner, value, WRITABLE)
            {}
         };

         struct Maximum: public HF::Attributes::Attribute<uint32_t>
         {
            static constexpr uint8_t ID       = MAXIMUM_ATTR; 
            static constexpr bool    WRITABLE = false;        

            Maximum(uint32_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint32_t>(HF::Interface::SIMPLE_LIGHT_SENSOR, ID, owner, value, WRITABLE)
            {}
         };

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

            Tolerance(uint32_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint32_t>(HF::Interface::SIMPLE_LIGHT_SENSOR, ID, owner, value, WRITABLE)
            {}
         };

         HF::Attributes::IAttribute *create_attribute(uint8_t uid);

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

            Base(): Interface<HF::Interface::SIMPLE_LIGHT_SENSOR>() {}
         };

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

            uint32_t _value;     
            uint32_t _minimum;   
            uint32_t _maximum;   
            uint32_t _tolerance; 

            public:

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

            virtual ~Server() {}

            // =============================================================================
            // Get/Set API.
            // =============================================================================

            uint32_t value() const;

            void value(uint32_t __value);

            uint32_t minimum() const;

            void minimum(uint32_t __value);

            uint32_t maximum() const;

            void maximum(uint32_t __value);

            uint32_t tolerance() const;

            void tolerance(uint32_t __value);

            // =============================================================================
            // Attribute API.
            // =============================================================================

            HF::Attributes::IAttribute *attribute(uint8_t uid);

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

         };

         struct Client: public InterfaceRole<SimpleLightSensor::Base, HF::Interface::CLIENT_ROLE>
         {
            Client(): InterfaceRole<SimpleLightSensor::Base, HF::Interface::CLIENT_ROLE>() {}

            virtual ~Client() {}

            // ======================================================================
            // 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     = SimpleLightSensor::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<uint32_t> &attr)
            {
               UNUSED(addr);
               UNUSED(attr);
            }

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

            protected:

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

      }  // namespace SimpleLightSensor

   }  // namespace Interfaces

}   // namespace HF

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


std::ostream &operator<<(std::ostream &stream,
                         const HF::Interfaces::SimpleLightSensor::Attributes attribute);
#endif /* HF_ITF_SIMPLE_LIGHT_SENSOR_H */