profiles.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_PROFILES_H
#define HF_PROFILES_H

#include "common.h"

#include "hanfun/interface.h"
#include "hanfun/interfaces/alert.h"
#include "hanfun/interfaces/on_off.h"
#include "hanfun/interfaces/level_control.h"
#include "hanfun/interfaces/simple_power_meter.h"
#include "hanfun/interfaces/simple_temperature.h"
#include "hanfun/interfaces/simple_humidity.h"
#include "hanfun/interfaces/simple_thermostat.h"
#include "hanfun/interfaces/simple_air_pressure.h"
#include "hanfun/interfaces/simple_button.h"
#include "hanfun/interfaces/simple_visual_effects.h"
#include "hanfun/interfaces/simple_light_sensor.h"
#include "hanfun/interfaces/colour_control.h"
#include "hanfun/interfaces/simple_keypad.h"

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

namespace HF
{
   namespace Profiles
   {
      enum UID
      {
         // =============================================================================
         // Home Control Unit Types
         // =============================================================================

         SIMPLE_ONOFF_SWITCHABLE = 0x0100,

         SIMPLE_ONOFF_SWITCH = 0x0101,

         SIMPLE_LEVEL_CONTROLLABLE = 0x0102,

         SIMPLE_LEVEL_CONTROL = 0x0103,

         SIMPLE_LEVEL_CONTROLLABLE_SWITCHABLE = 0x0104,

         SIMPLE_LEVEL_CONTROL_SWITCH = 0x0105,

         AC_OUTLET = 0x0106,

         AC_OUTLET_WITH_POWER_METERING = 0x0107,

         SIMPLE_LIGHT = 0x0108,

         DIMMABLE_LIGHT = 0x0109,

         DIMMER_SWITCH = 0x010A,

         SIMPLE_DOOR_LOCK = 0x010B,

         DOOR_BELL = 0x010C,

         SIMPLE_POWER_METER = 0x010D,

         SIMPLE_TEMPERATURE_SENSOR = 0x010E,

         SIMPLE_HUMIDITY_SENSOR = 0x010F,

         SIMPLE_AIR_PRESSURE_SENSOR = 0x0110,

         SIMPLE_BUTTON = 0x0111,

         CONTROLABLE_THERMOSTAT = 0x0112,

         SIMPLE_LED = 0x0113,

         ENVIRONMENT_MONITOR = 0x0114,

         COLOUR_BULB = 0x0115,

         DIMMABLE_COLOUR_BULB = 0x0116,

         TRACKER = 0x0117,

         SIMPLE_KEYPAD = 0x0118,

         // =============================================================================
         // Security Unit Types
         // =============================================================================

         SIMPLE_DETECTOR = 0x0200,

         DOOR_OPEN_CLOSE_DETECTOR = 0x0201,

         WINDOW_OPEN_CLOSE_DETECTOR = 0x0202,

         MOTION_DETECTOR = 0x0203,

         SMOKE_DETECTOR = 0x0204,

         GAS_DETECTOR = 0x0205,

         FLOOD_DETECTOR = 0x0206,

         GLASS_BREAK_DETECTOR = 0x0207,

         VIBRATION_DETECTOR = 0x0208,

         SIMPLE_LIGHT_SENSOR = 0x0209,

         SIREN = 0x0280,

         ALERTABLE = 0x0281,

         // =============================================================================
         // Home care Unit Types
         // =============================================================================

         SIMPLE_PENDANT = 0x0300,

         // =============================================================================
         // Application Unit Types
         // =============================================================================

         USER_INTERFACE_LOCK = 0x0401,

         USER_INTERFACE = 0x0410,

         GENERIC_APPLICATION = 0x0411,

         // =============================================================================
         // Proprietary Unit Types
         // =============================================================================

         // Use an ID from within the specified range to identify a proprietary unit type.

         PROPRIETARY_START = 0xFF00,

         PROPRIETARY_END = 0xFFFF,
      };

      Common::Interface const *interfaces(uint16_t profile, uint16_t &count);

      struct IProfile
      {
         virtual ~IProfile() {}

         virtual uint16_t uid() const = 0;

         virtual HF::Attributes::List attributes(Common::Interface itf, uint8_t pack_id,
                                                 const HF::Attributes::UIDS &uids) const = 0;
      };

      template<uint16_t _uid>
      struct AbstractProfile: public IProfile
      {
         virtual ~AbstractProfile()
         {}

         uint16_t uid() const
         {
            return _uid;
         }

         HF::Attributes::List attributes(Common::Interface itf, uint8_t pack_id,
                                         const HF::Attributes::UIDS &uids) const
         {
            UNUSED(itf);
            UNUSED(pack_id);
            UNUSED(uids);

            return HF::Attributes::List();
         }

         Common::Result handle(Protocol::Packet &packet, Common::ByteArray &payload,
                               uint16_t offset)
         {
            UNUSED(packet);
            UNUSED(payload);
            UNUSED(offset);

            return Common::Result::FAIL_ARG;
         }
      };

      template<uint16_t _uid, class Interface>
      struct Profile: public AbstractProfile<_uid>, public Interface
      {
         virtual ~Profile()
         {}

         using AbstractProfile<_uid>::uid;
         using Interface::handle;
         using Interface::attributes;

         HF::Attributes::List attributes(Common::Interface itf, uint8_t pack_id,
                                         const HF::Attributes::UIDS &uids) const
         {
            if (Interface::uid() == itf.id)
            {
               return HF::Attributes::get(*this, pack_id, uids);
            }
            else
            {
               return HF::Attributes::List();
            }
         }
      };

      template<uint16_t _uid, typename... _Interfaces>
      class ProfileN: public AbstractProfile<_uid>,
         public Interfaces::Container<ProfileN<_uid, _Interfaces...>,
                                      HF::Interfaces::Proxy<_Interfaces,
                                                            ProfileN<_uid, _Interfaces...>>...>
      {
         typedef ProfileN<_uid, _Interfaces...> profile_t;
         typedef Interfaces::Container<ProfileN<_uid, _Interfaces...>,
                                       HF::Interfaces::Proxy<_Interfaces,
                                                             ProfileN<_uid,
                                                                      _Interfaces...>>
                                       ...> container_t;

         public:

         virtual ~ProfileN()
         {}

         Common::Result handle(Protocol::Packet &packet, Common::ByteArray &payload,
                               uint16_t offset)
         {
            return container_t::handle(packet, payload, offset);
         }

         virtual void send(const Protocol::Address &addr, Protocol::Message &message) = 0;

         virtual void notify(const HF::Attributes::IAttribute &old_value,
                             const HF::Attributes::IAttribute &new_value) const = 0;

         HF::Attributes::List attributes(Common::Interface itf, uint8_t pack_id,
                                         const HF::Attributes::UIDS &uids) const
         {
            HF::Attributes::List result;

            container_t::attributes(result, itf, pack_id, uids);

            return result;
         }

         protected:

         ProfileN(): container_t(*this)
         {}
      };

      template<uint16_t _uid, typename Interface1, typename Interface2>
      struct Profile2: public ProfileN<_uid, Interface1, Interface2>
      {
         virtual ~Profile2()
         {}

         typedef Profile2<_uid, Interface1, Interface2> profile_t;
         typedef HF::Interfaces::Proxy<Interface1, profile_t> first_itf_t;
         typedef HF::Interfaces::Proxy<Interface2, profile_t> second_itf_t;

         Interface1 *first()
         {
            return const_cast<Interface1 *>(profile_t::template get<0>());
         }

         Interface2 *second()
         {
            return const_cast<Interface2 *>(profile_t::template get<1>());
         }

         const Interface1 *first() const
         {
            return const_cast<Interface1 *>(profile_t::template get<0>());
         }

         const Interface2 *second() const
         {
            return const_cast<Interface2 *>(profile_t::template get<1>());
         }
      };

      template<Profiles::UID _uid>
      struct Detector: public AbstractProfile<_uid>, protected Interfaces::Alert::Server
      {
         Detector()
         {
            Interfaces::Alert::Server::disableAll();
            Interfaces::Alert::Server::enable(0);
         }

         virtual ~Detector()
         {}

         using AbstractProfile<_uid>::uid;
         using Interfaces::Alert::Server::handle;

         void alert(Protocol::Address &addr, bool state)
         {
            Interfaces::Alert::Server::state(0, state);
            Interfaces::Alert::Server::status(addr, Detector::uid());
         }

         void alert(bool state)
         {
            Protocol::Address addr;
            this->alert(addr, state);
         }

         using Interfaces::Alert::Server::attributes;

         HF::Attributes::List attributes(Common::Interface itf, uint8_t pack_id,
                                         const HF::Attributes::UIDS &uids) const
         {
            if (Interfaces::Alert::Server::uid() == itf.id)
            {
               return HF::Attributes::get(*this, pack_id, uids);
            }
            else
            {
               return HF::Attributes::List();
            }
         }
      };

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

      class SimpleOnOffSwitchable: public Profile<SIMPLE_ONOFF_SWITCHABLE,
                                                  Interfaces::OnOff::Server>
      {
         public:

         virtual ~SimpleOnOffSwitchable() {}
      };

      class SimpleOnOffSwitch: public Profile<SIMPLE_ONOFF_SWITCH, Interfaces::OnOff::Client>
      {
         public:

         virtual ~SimpleOnOffSwitch() {}
      };

      class SimpleLevelControllable:
         public Profile<SIMPLE_LEVEL_CONTROLLABLE, Interfaces::LevelControl::Server>
      {
         public:

         virtual ~SimpleLevelControllable() {}
      };

      class SimpleLevelControl: public Profile<SIMPLE_LEVEL_CONTROL,
                                               Interfaces::LevelControl::Client>
      {
         public:

         virtual ~SimpleLevelControl() {}
      };

      template<typename OnOffServer = Interfaces::OnOff::Server,
               typename LevelControlServer = Interfaces::LevelControl::Server>
      class SimpleLevelControllableSwitchable:
         public Profile2<SIMPLE_LEVEL_CONTROLLABLE_SWITCHABLE, OnOffServer, LevelControlServer>
      {
         static_assert(std::is_base_of<Interfaces::OnOff::Server, OnOffServer>::value,
                       "OnOff::Server MUST be of type Interfaces::OnOff::Server !");

         static_assert(std::is_base_of<Interfaces::LevelControl::Server,
                                       LevelControlServer>::value,
                       "LevelControl::Server MUST be of type Interfaces::LevelControl::Server !");

         public:

         virtual ~SimpleLevelControllableSwitchable() {}

         OnOffServer *on_off()
         {
            return this->first();
         }

         LevelControlServer *level_control()
         {
            return this->second();
         }
      };

      template<typename OnOffClient = Interfaces::OnOff::Client,
               typename LevelControlClient = Interfaces::LevelControl::Client>
      class SimpleLevelControlSwitch:
         public Profile2<SIMPLE_LEVEL_CONTROL_SWITCH, OnOffClient, LevelControlClient>
      {
         static_assert(std::is_base_of<Interfaces::OnOff::Client, OnOffClient>::value,
                       "OnOff::Client MUST be of type Interfaces::OnOff::Client !");

         static_assert(std::is_base_of<Interfaces::LevelControl::Client,
                                       LevelControlClient>::value,
                       "LevelControl::Client MUST be of type Interfaces::LevelControl::Client !");
         public:

         virtual ~SimpleLevelControlSwitch() {}

         OnOffClient *on_off()
         {
            return this->first();
         }

         LevelControlClient *level_control()
         {
            return this->second();
         }
      };

      class AC_Outlet: public Profile<AC_OUTLET, Interfaces::OnOff::Server>
      {
         public:

         virtual ~AC_Outlet() {}
      };

      template<typename OnOffServer = Interfaces::OnOff::Server,
               typename SimplePowerMeterServer = Interfaces::SimplePowerMeter::Server>
      class AC_OutletWithPowerMetering:
         public Profile2<AC_OUTLET_WITH_POWER_METERING, OnOffServer, SimplePowerMeterServer>
      {
         static_assert(std::is_base_of<Interfaces::OnOff::Server, OnOffServer>::value,
                       "OnOff::Server MUST be of type Interfaces::OnOff::Server !");

         static_assert(std::is_base_of<Interfaces::SimplePowerMeter::Server,
                                       SimplePowerMeterServer>::value,
                       "SimplePowerMeterServer MUST be of type Interfaces::SimplePowerMeter::Server !");

         public:

         virtual ~AC_OutletWithPowerMetering() {}

         OnOffServer *on_off()
         {
            return this->first();
         }

         SimplePowerMeterServer *power_meter()
         {
            return this->second();
         }
      };

      class SimpleLight: public Profile<SIMPLE_LIGHT, Interfaces::OnOff::Server>
      {
         public:

         virtual ~SimpleLight() {}
      };

      template<typename OnOffServer = Interfaces::OnOff::Server,
               typename LevelControlServer = Interfaces::LevelControl::Server>
      class DimmableLight: public Profile2<DIMMABLE_LIGHT, OnOffServer, LevelControlServer>
      {
         static_assert(std::is_base_of<Interfaces::OnOff::Server, OnOffServer>::value,
                       "OnOff::Server MUST be of type Interfaces::OnOff::Server !");

         static_assert(std::is_base_of<Interfaces::LevelControl::Server,
                                       LevelControlServer>::value,
                       "LevelControl::Client MUST be of type Interfaces::LevelControl::Server !");

         public:

         virtual ~DimmableLight() {}

         OnOffServer *on_off()
         {
            return this->first();
         }

         LevelControlServer *level_control()
         {
            return this->second();
         }
      };

      template<typename OnOffClient = Interfaces::OnOff::Client,
               typename LevelControlClient = Interfaces::LevelControl::Client>
      class DimmerSwitch: public Profile2<DIMMER_SWITCH, OnOffClient, LevelControlClient>
      {
         static_assert(std::is_base_of<Interfaces::OnOff::Client, OnOffClient>::value,
                       "OnOff::Server MUST be of type Interfaces::OnOff::Client !");

         static_assert(std::is_base_of<Interfaces::LevelControl::Client,
                                       LevelControlClient>::value,
                       "LevelControl::Server MUST be of type Interfaces::LevelControl::Client !");

         public:

         virtual ~DimmerSwitch() {}

         OnOffClient *on_off()
         {
            return this->first();
         }

         LevelControlClient *level_control()
         {
            return this->second();
         }
      };

      class SimpleDoorLock: public Profile<SIMPLE_DOOR_LOCK, Interfaces::OnOff::Server>
      {
         public:

         virtual ~SimpleDoorLock() {}
      };

      class DoorBell: public Profile<DOOR_BELL, Interfaces::Alert::Server>
      {
         public:

         virtual ~DoorBell() {}
      };

      class SimplePowerMeter: public Profile<SIMPLE_POWER_METER,
                                             Interfaces::SimplePowerMeter::Server>
      {
         public:

         virtual ~SimplePowerMeter() {}
      };

      class SimpleTemperatureSensor: public Profile<SIMPLE_TEMPERATURE_SENSOR,
                                                    Interfaces::SimpleTemperature::Server>
      {
         public:

         virtual ~SimpleTemperatureSensor() {}
      };

      class SimpleHumiditySensor: public Profile<SIMPLE_HUMIDITY_SENSOR,
                                                 Interfaces::SimpleHumidity::Server>
      {
         public:

         virtual ~SimpleHumiditySensor() {}
      };

      template<typename OnOffServer = Interfaces::OnOff::Server,
               typename SimpleThermostatServer = Interfaces::SimpleThermostat::Server>
      class ControlableThermostat: public Profile2<CONTROLABLE_THERMOSTAT, OnOffServer,
                                                   SimpleThermostatServer>
      {
         static_assert(std::is_base_of<Interfaces::OnOff::Server, OnOffServer>::value,
                       "OnOffServer MUST be of type Interfaces::OnOff::Server !");

         static_assert(std::is_base_of<Interfaces::SimpleThermostat::Server,
                                       SimpleThermostatServer>::value,
                       "SimpleThermostatServer MUST be of type Interfaces::SimpleThermostat::Server !");

         public:

         virtual ~ControlableThermostat() {}

         OnOffServer *on_off()
         {
            return this->first();
         }

         SimpleThermostatServer *simple_thermostat()
         {
            return this->second();
         }
      };

      class SimpleAirPressureSensor: public Profile<SIMPLE_AIR_PRESSURE_SENSOR,
                                                    Interfaces::SimpleAirPressure::Server>
      {
         public:

         virtual ~SimpleAirPressureSensor() {}
      };

      class SimpleButton: public Profile<SIMPLE_BUTTON, Interfaces::SimpleButton::Server>
      {
         public:

         virtual ~SimpleButton() {}
      };

      class SimpleLED: public Profile<SIMPLE_LED, Interfaces::SimpleVisualEffects::Server>
      {
         public:

         virtual ~SimpleLED() {}
      };

      class EnvironmentMonitor: public ProfileN<ENVIRONMENT_MONITOR,
                                                Interfaces::SimpleTemperature::Server,
                                                Interfaces::SimpleHumidity::Server,
                                                Interfaces::SimpleAirPressure::Server>
      {
         public:

         virtual ~EnvironmentMonitor() {}
      };

      template<typename OnOffServer = Interfaces::OnOff::Server,
               typename ColourControlServer = Interfaces::ColourControl::Server>
      class ColourBulb:
         public Profile2<COLOUR_BULB, OnOffServer, ColourControlServer>
      {
         static_assert(std::is_base_of<Interfaces::OnOff::Server, OnOffServer>::value,
                       "OnOffServer MUST be of type Interfaces::OnOff::Server !");

         static_assert(std::is_base_of<Interfaces::ColourControl::IServer,
                                       ColourControlServer>::value,
                       "ColourControlServer MUST be of type Interfaces::ColourControl::IServer !");

         public:

         virtual ~ColourBulb() {}

         OnOffServer *on_off()
         {
            return this->first();
         }

         ColourControlServer *colour_control()
         {
            return this->second();
         }
      };

      template<typename OnOffServer = Interfaces::OnOff::Server,
               typename ColourControlServer = Interfaces::ColourControl::Server,
               typename LevelControlServer = Interfaces::LevelControl::Server>
      class DimmableColourBulb:
         public ProfileN<DIMMABLE_COLOUR_BULB, OnOffServer, ColourControlServer, LevelControlServer>
      {
         typedef ProfileN<DIMMABLE_COLOUR_BULB, OnOffServer, ColourControlServer,
                          LevelControlServer> profile_t;

         static_assert(std::is_base_of<Interfaces::OnOff::Server, OnOffServer>::value,
                       "OnOffServer MUST be of type Interfaces::OnOff::Server !");

         static_assert(std::is_base_of<Interfaces::ColourControl::IServer,
                                       ColourControlServer>::value,
                       "ColourControlServer MUST be of type Interfaces::ColourControl::IServer !");

         static_assert(std::is_base_of<Interfaces::LevelControl::Server,
                                       LevelControlServer>::value,
                       "LevelControlServer MUST be of type Interfaces::LevelControl::Server !");

         public:

         virtual ~DimmableColourBulb()
         {}

         OnOffServer *on_off()
         {
            return const_cast<OnOffServer *>(profile_t::template get<0>());
         }

         ColourControlServer *colour_control()
         {
            return const_cast<ColourControlServer *>(profile_t::template get<1>());
         }

         LevelControlServer *level_control()
         {
            return const_cast<LevelControlServer *>(profile_t::template get<2>());
         }
      };

      class Tracker: public AbstractProfile<TRACKER>
      {
         public:

         virtual ~Tracker() {}

         virtual void periodic(uint32_t time)
         {
            UNUSED(time);
         }
      };

      class SimpleKeypad: public Profile<SIMPLE_KEYPAD,
                                         Interfaces::SimpleKeypad::Server>
      {
         public:

         virtual ~SimpleKeypad()
         {}
      };

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

      class SimpleDetector: public Detector<SIMPLE_DETECTOR>
      {
         public:

         virtual ~SimpleDetector() {}
      };

      class DoorOpenCloseDetector: public Detector<DOOR_OPEN_CLOSE_DETECTOR>
      {
         public:

         virtual ~DoorOpenCloseDetector() {}
      };

      class WindowOpenCloseDetector: public Detector<WINDOW_OPEN_CLOSE_DETECTOR>
      {
         public:

         virtual ~WindowOpenCloseDetector() {}
      };

      class MotionDetector: public Detector<MOTION_DETECTOR>
      {
         public:

         virtual ~MotionDetector() {}
      };

      class SmokeDetector: public Detector<SMOKE_DETECTOR>
      {
         public:

         virtual ~SmokeDetector() {}
      };

      class GasDetector: public Detector<GAS_DETECTOR>
      {
         public:

         virtual ~GasDetector() {}
      };

      class FloodDetector: public Detector<FLOOD_DETECTOR>
      {
         public:

         virtual ~FloodDetector() {}
      };

      class GlassBreakDetector: public Detector<GLASS_BREAK_DETECTOR>
      {
         public:

         virtual ~GlassBreakDetector() {}
      };

      class VibrationDetector: public Detector<VIBRATION_DETECTOR>
      {
         public:

         virtual ~VibrationDetector() {}
      };

      class SimpleLightSensor: public Profile<SIMPLE_LIGHT_SENSOR,
                                              Interfaces::SimpleLightSensor::Server>
      {
         public:

         virtual ~SimpleLightSensor()
         {}
      };

      class Siren: public Profile<SIREN, Interfaces::OnOff::Server>
      {
         public:

         virtual ~Siren() {}
      };

      class Alertable: public Profile<ALERTABLE, Interfaces::Alert::Client>
      {
         public:

         virtual ~Alertable() {}
      };

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

      class SimplePendant: public Detector<SIMPLE_PENDANT>
      {
         public:

         virtual ~SimplePendant() {}
      };

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

      class UserInterfaceLock: public Profile<USER_INTERFACE_LOCK, Interfaces::OnOff::Server>
      {
         public:

         virtual ~UserInterfaceLock() {}
      };

      class UserInterface: public AbstractProfile<USER_INTERFACE>
      {
         public:

         virtual ~UserInterface() {}

         virtual void periodic(uint32_t time)
         {
            UNUSED(time);
         }
      };

      class GenericApplicationLogic: public AbstractProfile<GENERIC_APPLICATION>
      {
         public:

         virtual ~GenericApplicationLogic() {}

         virtual void periodic(uint32_t time)
         {
            UNUSED(time);
         }
      };
   }  // namespace Profiles

}  // namespace HF

#endif /* HF_PROFILES_H */