simple_visual_effects.h

Go to the documentation of this file.

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

#ifndef HF_ITF_SIMPLE_VISUAL_EFFECTS_H
#define HF_ITF_SIMPLE_VISUAL_EFFECTS_H

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

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

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

      namespace SimpleVisualEffects
      {
         typedef enum _CMD
         {
            ON_CMD       = 1, 
            OFF_CMD      = 2, 
            BLINK_CMD    = 3, 
            FADE_CMD     = 4, 
            BREATHE_CMD  = 5, 
            __LAST_CMD__ = BREATHE_CMD
         } CMD;

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

         struct OnEffect
         {
            uint16_t duration;   

            OnEffect(uint16_t _duration = 0): duration(_duration) {}

            static constexpr uint16_t min_size = sizeof(uint16_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, duration);

               return min_size;
            }

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

               array.read(offset, duration);

               return min_size;
            }
         };

         struct BlinkEffect
         {
            uint16_t duty_cycle_on;      
            uint16_t duty_cycle_off;     
            uint16_t number_of_cycles;   

            BlinkEffect(uint16_t _duty_cycle_on = 0, uint16_t _duty_cycle_off = 0,
                        uint16_t _number_of_cycles = 1): duty_cycle_on(_duty_cycle_on),
               duty_cycle_off(_duty_cycle_off), number_of_cycles(_number_of_cycles) {}

            static constexpr uint16_t min_size = 3 * sizeof(uint16_t);

            static constexpr uint16_t min_number_of_cycles = 1;

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

               HF_ASSERT(number_of_cycles >= min_number_of_cycles,
               {
                  return 0;
               });

               offset += array.write(offset, duty_cycle_on);
               offset += array.write(offset, duty_cycle_off);
               offset += array.write(offset, number_of_cycles);

               return min_size;
            }

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

               offset += array.read(offset, duty_cycle_on);
               offset += array.read(offset, duty_cycle_off);
               offset += array.read(offset, number_of_cycles);

               HF_ASSERT(number_of_cycles >= min_number_of_cycles,
               {
                  return 0;
               })

               return min_size;
            }
         };

         struct FadeEffect
         {
            uint8_t  start;     
            uint8_t  end;       
            uint16_t duration;  

            FadeEffect(uint8_t _start = 0, uint8_t _end = 0, uint16_t _duration = 0):
               start(_start), end(_end), duration(_duration) {}

            static constexpr uint16_t min_size = 2 * sizeof(uint8_t) + sizeof(uint16_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);

               offset += array.write(offset, start);
               offset += array.write(offset, end);
               offset += array.write(offset, duration);

               return min_size;
            }

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

               offset += array.read(offset, start);
               offset += array.read(offset, end);
               offset += array.read(offset, duration);

               return min_size;
            }
         };

         struct BreatheEffect
         {
            uint8_t  start;        
            uint16_t start_hold;   
            uint16_t ste_duration; 

            uint8_t  end;          
            uint16_t end_hold;     
            uint16_t ets_duration; 

            uint16_t number_of_cycles; 

            BreatheEffect(uint8_t _start = 0, uint16_t _start_hold = 0,
                          uint16_t _ste_duration = 0,
                          uint8_t _end = 0, uint16_t _end_hold = 0, uint16_t _ets_duration = 0,
                          uint16_t _number_of_cycles = 1):
               start(_start), start_hold(_start_hold), ste_duration(_ste_duration),
               end(_end), end_hold(_end_hold), ets_duration(_ets_duration),
               number_of_cycles(_number_of_cycles) {}

            static constexpr uint16_t min_size = 2 * sizeof(uint8_t) + 5 * sizeof(uint16_t);

            static constexpr uint16_t min_number_of_cycles = 1;

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

               HF_ASSERT(number_of_cycles >= min_number_of_cycles,
               {
                  return 0;
               });

               offset += array.write(offset, start);
               offset += array.write(offset, start_hold);
               offset += array.write(offset, ste_duration);
               offset += array.write(offset, end);
               offset += array.write(offset, end_hold);
               offset += array.write(offset, ets_duration);
               offset += array.write(offset, number_of_cycles);

               return min_size;
            }

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

               offset += array.read(offset, start);
               offset += array.read(offset, start_hold);
               offset += array.read(offset, ste_duration);
               offset += array.read(offset, end);
               offset += array.read(offset, end_hold);
               offset += array.read(offset, ets_duration);
               offset += array.read(offset, number_of_cycles);

               HF_ASSERT(number_of_cycles >= min_number_of_cycles,
               {
                  return 0;
               });

               return min_size;
            }
         };

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

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

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

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

            Server(): InterfaceRole<SimpleVisualEffects::Base, HF::Interface::SERVER_ROLE>() {}

            virtual ~Server() {}

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

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

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

            virtual void on(const Protocol::Address &addr, const OnEffect &effect);

            virtual void off(const Protocol::Address &addr);

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_BLINK_CMD

            virtual void blink(const Protocol::Address &addr, const BlinkEffect &effect);
#endif

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_FADE_CMD

            virtual void fade(const Protocol::Address &addr, const FadeEffect &effect);
#endif

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_BREATHE_CMD

            virtual void breathe(const Protocol::Address &addr, const BreatheEffect &effect);
#endif

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

            protected:

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

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

            virtual ~Client() {}

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

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_ON_CMD

            void on(const Protocol::Address &addr, uint16_t duration);

            void on(uint16_t duration)
            {
               Protocol::Address addr;
               on(addr, duration);
            }
#endif

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_OFF_CMD

            void off(const Protocol::Address &addr);

            void off()
            {
               Protocol::Address addr;
               off(addr);
            }
#endif

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_BLINK_CMD

            void blink(const Protocol::Address &addr, const BlinkEffect &effect);

            void blink(const BlinkEffect &effect)
            {
               Protocol::Address addr;
               blink(addr, effect);
            }
#endif

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_FADE_CMD

            void fade(const Protocol::Address &addr, const FadeEffect &effect);

            void fade(const FadeEffect &effect)
            {
               Protocol::Address addr;
               fade(addr, effect);
            }
#endif

#ifdef HF_ITF_SIMPLE_VISUAL_EFFECTS_BREATHE_CMD

            void breathe(const Protocol::Address &addr, const BreatheEffect &effect);

            void breathe(const BreatheEffect &effect)
            {
               Protocol::Address addr;
               breathe(addr, effect);
            }
#endif

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

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

            // =============================================================================
         };

      }  // namespace SimpleVisualEffects

   }  // namespace Interfaces

}   // namespace HF

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

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

#endif /* HF_ITF_SIMPLE_VISUAL_EFFECTS_H */