level_control.h

Go to the documentation of this file.

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

#ifndef HF_ITF_LEVEL_CONTROL_H
#define HF_ITF_LEVEL_CONTROL_H

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

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

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

      namespace LevelControl
      {
         typedef enum _CMD
         {
            SET_LEVEL_CMD      = 0x01,                   
            INCREASE_LEVEL_CMD = 0x02,                   
            DECREASE_LEVEL_CMD = 0x03,                   
            __LAST_CMD__       = DECREASE_LEVEL_CMD
         } CMD;

         typedef enum _Attributes
         {
            LEVEL_ATTR    = 0x01,      
            __LAST_ATTR__ = LEVEL_ATTR,
         } Attributes;

         struct Message
         {
            uint8_t level;

            Message(uint8_t level = 0): level(level) {}

            static constexpr uint16_t min_size = sizeof(uint8_t);

            uint16_t size() const
            {
               return min_size;
            }

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

               array.write(offset, level);

               return min_size;
            }

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

               array.read(offset, level);

               return min_size;
            }
         };

         struct Level: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID        = LEVEL_ATTR;
            static constexpr bool    WRITABBLE = true;

            Level(uint8_t level = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::LEVEL_CONTROL, ID, owner, level, WRITABBLE)
            {}
         };

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

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

            Base() {}

            using Interface<HF::Interface::LEVEL_CONTROL>::payload_size;

            uint16_t payload_size(Protocol::Message::Interface &itf) const
            {
               UNUSED(itf);
               return payload_size_helper<Level>();
            }

            void check_and_fix(float &value)
            {
               if (value < 0)
               {
                  value = 0;
               }
               else if (value > 100)
               {
                  value = 100;
               }
            }

            void check_and_fix(int16_t &value)
            {
               if (value < 0)
               {
                  value = 0;
               }
               else if (value > 255)
               {
                  value = 255;
               }
            }
         };

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

            uint8_t _level;

            public:

            Server(): _level(0) {}

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

            uint8_t level();

            void level(uint8_t new_level);

            void level(float new_level);

#ifdef HF_ITF_LEVEL_CONTROL_INCREASE_LEVEL_CMD

            void increase(uint8_t increment);

            void increase(float increment);
#endif

#ifdef HF_ITF_LEVEL_CONTROL_DECREASE_LEVEL_CMD

            void decrease(uint8_t decrement);

            void decrease(float decrement);
#endif

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

            virtual void level_change(Protocol::Address &source,
                                      uint8_t old_level,
                                      uint8_t new_level);

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

            // =============================================================================
            // 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
            {
               UNUSED(pack_id);
               /* *INDENT-OFF* */
               return HF::Attributes::UIDS ({ LevelControl::LEVEL_ATTR });
               /* *INDENT-ON* */
            }

            protected:

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

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

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

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

            void level(Protocol::Address &addr, uint8_t new_level);

            void level(uint8_t new_level)
            {
               Protocol::Address addr;
               level(addr, new_level);
            }

            void level(Protocol::Address &addr, float new_level);

            void level(float new_level)
            {
               Protocol::Address addr;
               level(addr, new_level);
            }

#ifdef HF_ITF_LEVEL_CONTROL_INCREASE_LEVEL_CMD

            void increase_level(Protocol::Address &addr, uint8_t increment);

            void increase_level(uint8_t increment)
            {
               Protocol::Address addr;
               increase_level(addr, increment);
            }

            void increase_level(Protocol::Address &addr, float increment);

            void increase_level(float increment)
            {
               Protocol::Address addr;
               increase_level(addr, increment);
            }
#endif

#ifdef HF_ITF_LEVEL_CONTROL_DECREASE_LEVEL_CMD

            void decrease_level(Protocol::Address &addr, uint8_t decrement);

            void decrease_level(uint8_t decrement)
            {
               Protocol::Address addr;
               decrease_level(addr, decrement);
            }

            void decrease_level(Protocol::Address &addr, float decrement);

            void decrease_level(float decrement)
            {
               Protocol::Address addr;
               decrease_level(addr, decrement);
            }
#endif
            // =============================================================================
         };

      }  // namespace LevelControl

   }  // namespace Interfaces

}   // namespace HF

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

std::ostream &operator<<(std::ostream &stream, const HF::Interfaces::LevelControl::CMD command);

std::ostream &operator<<(std::ostream &stream,
                         const HF::Interfaces::LevelControl::Attributes attribute);

#endif /* LEVEL_CONTROL_H_ */