simple_power_meter.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_ITF_SIMPLE_POWER_METER_H
#define HF_ITF_SIMPLE_POWER_METER_H

#include "hanfun/common.h"

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

// =============================================================================
// Configuration
// =============================================================================

#if HF_ITF_SPM_REPORT_CMD

   #if !HF_ITF_SPM_REPORT_INTERVAL_ATTR
      #define HF_ITF_SPM_REPORT_INTERVAL_ATTR   1
   #endif

#endif

#if HF_ITF_SPM_RESET_CMD

   #if !HF_ITF_SPM_ENERGY_ATTR
      #undef HF_ITF_SPM_ENERGY_ATTR
      #define HF_ITF_SPM_ENERGY_ATTR            1
   #endif

   #if !HF_ITF_SPM_ENERGY_AT_RESET_ATTR
      #undef HF_ITF_SPM_ENERGY_AT_RESET_ATTR
      #define HF_ITF_SPM_ENERGY_AT_RESET_ATTR   1
   #endif

   #if !HF_ITF_SPM_TIME_AT_RESET_ATTR
      #undef HF_ITF_SPM_TIME_AT_RESET_ATTR
      #define HF_ITF_SPM_TIME_AT_RESET_ATTR     1
   #endif

#endif

// =============================================================================
// Define
// =============================================================================

#define ATTR_SETTER(__type, __arg, __uid)                                           \
   {                                                                                \
      __type old = __arg;                                                           \
                                                                                    \
      __arg = value;                                                                \
                                                                                    \
      HF::Attributes::Attribute<__type> *old_attr =                                 \
         static_cast<HF::Attributes::Attribute<__type> *>(create_attribute(__uid)); \
      old_attr->set(old);                                                           \
                                                                                    \
      HF::Attributes::Attribute<__type> *new_attr =                                 \
         static_cast<HF::Attributes::Attribute<__type> *>(attribute(__uid));        \
                                                                                    \
      notify(*old_attr, *new_attr);                                                 \
                                                                                    \
      delete old_attr;                                                              \
      delete new_attr;                                                              \
   }

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

namespace HF
{
   namespace Interfaces
   {
      // Forward declaration
      namespace SimplePowerMeter
      {
         class Server;
      }

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

      namespace SimplePowerMeter
      {
         typedef enum _CMD
         {
            REPORT_CMD            = 0x01,          
            MEASUREMENT_RESET_CMD = 0x01           
         } CMD;

         typedef enum _Attributes
         {
            ENERGY_ATTR             = 0x01,          
            ENERGY_AT_RESET_ATTR    = 0x02,          
            TIME_AT_RESET_ATTR      = 0x03,          
            POWER_ATTR              = 0x04,          
            AVG_POWER_ATTR          = 0x05,          
            AVG_POWER_INTERVAL_ATTR = 0x06,          
            VOLTAGE_ATTR            = 0x07,          
            CURRENT_ATTR            = 0x08,          
            FREQUENCY_ATTR          = 0x09,          
            POWER_FACTOR_ATTR       = 0x0A,          
            REPORT_INTERVAL_ATTR    = 0x0B,          
            __LAST_ATTR__           = REPORT_INTERVAL_ATTR,
         } Attributes;

         struct Measurement
         {
            static constexpr uint16_t min_size = sizeof(uint8_t)      // Precision size.
                                                 + sizeof(uint32_t);  // Value size.

            uint8_t  unit;  
            uint32_t value; 

            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);

               offset += array.write(offset, static_cast<uint8_t>(unit));
               array.write(offset, value);

               return min_size;
            }

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

               uint8_t temp;
               offset += array.read(offset, temp);

               unit    = static_cast<Common::Precision>(temp);

               offset += array.read(offset, value);

               return min_size;
            }

            int compare(const Measurement &other) const
            {
               int res = value - other.value;

               return res;
            }

            float changed(const Measurement &other) const
            {
               return (((float) (value - other.value)) / other.value);
            }
         };

         struct Report
         {
            Measurement energy;                       

            Measurement last_energy;                  
            Measurement last_time;                    

            Measurement power;                        
            Measurement avg_power;                    

            uint16_t    avg_power_interval;           

            uint8_t     power_factor;                 

            Measurement voltage;                      
            Measurement current;                      
            Measurement frequency;                    

            std::array<bool, __LAST_ATTR__ + 1> enabled;

            Report();

            static constexpr uint16_t min_size = sizeof(uint8_t);  // Number of attributes.

            uint16_t size() const;

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

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

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

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

            Base() {}

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

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

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

            /* Attributes */
#if HF_ITF_SPM_ENERGY_ATTR
            Measurement _energy;           
#endif

#if HF_ITF_SPM_ENERGY_AT_RESET_ATTR
            Measurement _last_energy;      
#endif

#if HF_ITF_SPM_TIME_AT_RESET_ATTR
            Measurement _last_time;        
#endif

#if HF_ITF_SPM_POWER_ATTR
            Measurement _power;            
#endif

#if HF_ITF_SPM_AVG_POWER_ATTR
            Measurement _avg_power;        
#endif

#if HF_ITF_SPM_AVG_POWER_INTERVAL_ATTR
            uint16_t _avg_power_interval;  
#endif

#if HF_ITF_SPM_POWER_FACTOR_ATTR
            uint8_t _power_factor;         
#endif

#if HF_ITF_SPM_VOLTAGE_ATTR
            Measurement _voltage;          
#endif

#if HF_ITF_SPM_CURRENT_ATTR
            Measurement _current;          
#endif

#if HF_ITF_SPM_FREQUENCY_ATTR
            Measurement _frequency;        
#endif

#if HF_ITF_SPM_REPORT_CMD
            uint16_t _report_interval;     

            uint32_t _last_periodic;       
#endif

            public:

            Server();

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

            void periodic(uint32_t time);

            // ======================================================================
            // Getters & Setters
            // ======================================================================

#if HF_ITF_SPM_ENERGY_ATTR

            Measurement energy()
            {
               return _energy;
            }

            void energy(Measurement &value)
            {
               ATTR_SETTER(Measurement, _energy, ENERGY_ATTR);
            }
#endif

#if HF_ITF_SPM_ENERGY_AT_RESET_ATTR

            Measurement last_energy()
            {
               return _last_energy;
            }

            void last_energy(Measurement &value)
            {
               ATTR_SETTER(Measurement, _last_energy, ENERGY_AT_RESET_ATTR);
            }
#endif

#if HF_ITF_SPM_TIME_AT_RESET_ATTR

            Measurement last_time()
            {
               return _last_time;
            }

            void last_time(Measurement &value)
            {
               ATTR_SETTER(Measurement, _last_time, TIME_AT_RESET_ATTR);
            }
#endif

#if HF_ITF_SPM_POWER_ATTR

            Measurement power()
            {
               return _power;
            }

            void power(Measurement &value)
            {
               ATTR_SETTER(Measurement, _power, POWER_ATTR);
            }
#endif

#if HF_ITF_SPM_AVG_POWER_ATTR

            Measurement avg_power()
            {
               return _avg_power;
            }

            void avg_power(Measurement &value)
            {
               ATTR_SETTER(Measurement, _avg_power, AVG_POWER_ATTR);
            }
#endif

#if HF_ITF_SPM_AVG_POWER_INTERVAL_ATTR

            uint16_t avg_power_interval()
            {
               return _avg_power_interval;
            }

            void avg_power_interval(uint16_t value)
            {
               ATTR_SETTER(uint16_t, _avg_power_interval, AVG_POWER_INTERVAL_ATTR);
            }
#endif

#if HF_ITF_SPM_POWER_FACTOR_ATTR

            uint8_t power_factor()
            {
               return _power_factor;
            }

            void power_factor(uint8_t value)
            {
               ATTR_SETTER(uint8_t, _power_factor, POWER_FACTOR_ATTR);
            }
#endif

#if HF_ITF_SPM_VOLTAGE_ATTR

            Measurement voltage()
            {
               return _voltage;
            }

            void voltage(Measurement &value)
            {
               ATTR_SETTER(Measurement, _voltage, VOLTAGE_ATTR);
            }
#endif

#if HF_ITF_SPM_CURRENT_ATTR

            Measurement current()
            {
               return _current;
            }

            void current(Measurement &value)
            {
               ATTR_SETTER(Measurement, _current, CURRENT_ATTR);
            }
#endif

#if HF_ITF_SPM_FREQUENCY_ATTR

            Measurement frequency()
            {
               return _frequency;
            }

            void frequency(Measurement &value)
            {
               ATTR_SETTER(Measurement, _frequency, FREQUENCY_ATTR);
            }
#endif

#if HF_ITF_SPM_REPORT_CMD

            uint16_t report_interval()
            {
               return _report_interval;
            }

            void report_interval(uint16_t value)
            {
               ATTR_SETTER(uint16_t, _report_interval, REPORT_INTERVAL_ATTR);
            }
#endif


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

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

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

            protected:

            virtual Report *report();
         };

         struct Client: public InterfaceRole<SimplePowerMeter::Base, HF::Interface::CLIENT_ROLE>
         {
            // ======================================================================
            // Events
            // ======================================================================

            virtual void report(Protocol::Address &source, Report &report)
            {
               UNUSED(source);
               UNUSED(report);
            }

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

            protected:

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

      }  // namespace SimplePowerMeter

   }  // namespace Interfaces

}   // namespace HF

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

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

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

#endif /* HF_ITF_SIMPLE_POWER_METER */