simple_thermostat.h

Go to the documentation of this file.

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

#ifndef HF_ITF_SIMPLE_THERMOSTAT_H
#define HF_ITF_SIMPLE_THERMOSTAT_H

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

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

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

      namespace SimpleThermostat
      {
         typedef enum _CMD
         {
            BOOST_START_CMD = 0x01,
            BOOST_STOP_CMD  = 0x02,
            __LAST_CMD__    = 0xFF,
         } CMD;

         typedef enum _Attributes
         {
            SUPPORTED_MODES_ATTR       = 0x01, 
            HEAT_COOL_MODE_ATTR        = 0x02, 
            FAN_MODE_ATTR              = 0x03, 
            HEAT_MODE_TEMP_ATTR        = 0x04, 
            COOL_MODE_TEMP_ATTR        = 0x05, 
            AUTO_MODE_HEAT_TEMP_ATTR   = 0x06, 
            AUTO_MODE_COOL_TEMP_ATTR   = 0x07, 
            HEAT_MODE_TEMP_OFFSET_ATTR = 0x08, 
            COOL_MODE_TEMP_OFFSET_ATTR = 0x09, 
            BOOST_DURATION_ATTR        = 0x0A, 
            __LAST_ATTR__              = BOOST_DURATION_ATTR
         } Attributes;

         typedef enum _SupportedModesMasks
         {
            HEAT_MODE      = 0x01, 
            COOL_MODE      = 0x02, 
            AUTO_MODE      = 0x04, 
            FAN_OFF_MODE   = 0x10, 
            FAN_ON_MODE    = 0x20, 
            FAN_AUTO_MODE  = 0x40, 
            ALL_MODES_MASK = HEAT_MODE | COOL_MODE | AUTO_MODE | FAN_ON_MODE |
                             FAN_OFF_MODE | FAN_AUTO_MODE,
         } SupportedModesMasks;

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

         struct SupportedModes: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = SUPPORTED_MODES_ATTR;  
            static constexpr bool    WRITABLE = false;                 

            SupportedModes(uint8_t mode = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::SIMPLE_THERMOSTAT, ID, owner, mode, WRITABLE)
            {}
         };

         struct HeatCoolMode: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = HEAT_COOL_MODE_ATTR;  
            static constexpr bool    WRITABLE = true;                 

            HeatCoolMode(uint8_t mode = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::SIMPLE_THERMOSTAT, ID, owner, mode, WRITABLE)
            {}
         };

         struct FanMode: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = FAN_MODE_ATTR;  
            static constexpr bool    WRITABLE = true;           

            FanMode(uint8_t mode = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::SIMPLE_THERMOSTAT, ID, owner, mode, WRITABLE)
            {}
         };

         template<uint8_t _ID>
         struct Attribute: public HF::Attributes::Attribute<int16_t>
         {
            static constexpr uint8_t ID       = _ID;  
            static constexpr bool    WRITABLE = true; 

            Attribute(int16_t value = 0, HF::Interface *owner = nullptr):
               HF::Attributes::Attribute<int16_t>(HF::Interface::SIMPLE_THERMOSTAT, ID, owner,
                                                  value,
                                                  WRITABLE)
            {}
         };

         typedef Attribute<HEAT_MODE_TEMP_ATTR> HeatModeTemperature;

         typedef Attribute<COOL_MODE_TEMP_ATTR> CoolModeTemperature;

         typedef Attribute<AUTO_MODE_HEAT_TEMP_ATTR> AutoModeHeatTemperature;

         typedef Attribute<AUTO_MODE_COOL_TEMP_ATTR> AutoModeCoolTemperature;

         typedef Attribute<HEAT_MODE_TEMP_OFFSET_ATTR> HeatModeTemperatureOffset;

         typedef Attribute<COOL_MODE_TEMP_OFFSET_ATTR> CoolModeTemperatureOffset;

         struct BoostDuration: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = BOOST_DURATION_ATTR; 
            static constexpr bool    WRITABLE = true;                

            BoostDuration(uint8_t mode = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::SIMPLE_THERMOSTAT, ID, owner, mode, WRITABLE)
            {}
         };

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

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

            Base() {}
         };

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

            uint8_t _supported_modes;              
            uint8_t _mode;                         

#if HF_ITF_STS_FAN_MODE
            uint8_t _fan_mode;                     
#endif
#if HF_ITF_STS_HEAT_MODE
            int16_t _heat_mode_temperature;        
#endif
#if HF_ITF_STS_COOL_MODE
            int16_t _cool_mode_temperature;        
#endif
#if HF_ITF_STS_AUTO_MODE
            int16_t _auto_mode_heat_temperature;   
            int16_t _auto_mode_cool_temperature;   
#endif
#if HF_ITF_STS_HEAT_MODE && HF_ITF_STS_HEAT_OFFSET_ATTR
            int16_t _heat_mode_temperature_offset; 
#endif
#if HF_ITF_STS_COOL_MODE && HF_ITF_STS_COOL_OFFSET_ATTR
            int16_t _cool_mode_temperature_offset; 
#endif
#if HF_ITF_STS_BOOST_CMD
            uint8_t _boost_duration;               
#endif
            public:

            Server(const uint8_t __supported_modes = ALL_MODES_MASK):
               _supported_modes(__supported_modes)
            {}

            virtual ~Server() {}

            // ======================================================================
            // Events
            // ======================================================================
#if HF_ITF_STS_BOOST_CMD

            virtual Common::Result boost_start(const Protocol::Address &source)
            {
               UNUSED(source);
               return Common::Result::OK;
            }

            virtual Common::Result boost_stop(const Protocol::Address &source)
            {
               UNUSED(source);
               return Common::Result::OK;
            }
#endif

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

            uint8_t supported_modes() const;

            void supported_modes(uint8_t __supported_modes);

            uint8_t mode() const;

            virtual void mode(uint8_t __mode);

#if HF_ITF_STS_FAN_MODE

            uint8_t fan_mode() const;

            virtual void fan_mode(uint8_t __fan_mode);
#endif

#if HF_ITF_STS_HEAT_MODE

            int16_t heat_mode_temperature() const;

            virtual void heat_mode_temperature(int16_t __temperature);
#endif

#if HF_ITF_STS_COOL_MODE

            int16_t cool_mode_temperature() const;

            virtual void cool_mode_temperature(int16_t __temperature);
#endif

#if HF_ITF_STS_AUTO_MODE

            int16_t auto_mode_heat_temperature() const;

            virtual void auto_mode_heat_temperature(int16_t __temperature);

            int16_t auto_mode_cool_temperature() const;

            virtual void auto_mode_cool_temperature(int16_t __temperature);
#endif

#if HF_ITF_STS_HEAT_MODE && HF_ITF_STS_HEAT_OFFSET_ATTR

            int16_t heat_mode_temperature_offset() const;

            virtual void heat_mode_temperature_offset(int16_t __offset);
#endif

#if HF_ITF_STS_COOL_MODE && HF_ITF_STS_COOL_OFFSET_ATTR

            int16_t cool_mode_temperature_offset() const;

            virtual void cool_mode_temperature_offset(int16_t __offset);
#endif

#if HF_ITF_STS_BOOST_CMD

            uint8_t boost_duration() const;

            virtual void boost_duration(uint8_t __duration);
#endif

            // =============================================================================
            // Attribute 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;
#if HF_ITF_STS_BOOST_CMD
            protected:

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

         struct Client: public InterfaceRole<SimpleThermostat::Base, HF::Interface::CLIENT_ROLE>
         {
            // ======================================================================
            // Commands
            // ======================================================================
#if HF_ITF_STS_BOOST_CMD

            void boost_start(const Protocol::Address &address);

            void boost_stop(const Protocol::Address &address);
#endif
            // ======================================================================

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

#if HF_ITF_STS_BOOST_CMD

            virtual void boost_start(const Protocol::Address &source, Common::Result result)
            {
               UNUSED(source);
               UNUSED(result);
            }

            virtual void boost_stop(const Protocol::Address &source, Common::Result result)
            {
               UNUSED(source);
               UNUSED(result);
            }
#endif
            // =============================================================================

#if HF_ITF_STS_BOOST_CMD
            protected:

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

      }  // namespace SimpleThermostat

   }  // namespace Interfaces

}   // namespace HF

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

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

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

#endif /* HF_ITF_SIMPLE_THERMOSTAT_H */