opend_hanfun_api_fp.h

Go to the documentation of this file.

#ifndef __OPEND_HANFUN_API_FP_H__
#define __OPEND_HANFUN_API_FP_H__

#include "opend_hanfun_api.h"


namespace DeviceManagement
{
  struct Entries:public HF::Core::DeviceManagement::Entries
  {
    HF::Common::Result save (const HF::Core::DeviceManagement::Device &device);

    HF::Common::Result destroy (const HF::Core::DeviceManagement::Device &device);
  };

  struct Server:public HF::Core::DeviceManagement::Server <Entries>
  {
    Server(HF::Core::Unit0 &unit):
      HF::Core::DeviceManagement::Server <Entries>(unit),
      _next_address (HF::Protocol::BROADCAST_ADDR)
    {}

    virtual ~Server() {}

    uint16_t next_address (uint16_t addr)
    {
      _next_address = addr;
      return _next_address;
    }

    bool available (uint16_t address);

    bool deregister (uint16_t address);

    protected:

    using HF::Core::DeviceManagement::Server <Entries>::deregister;

    uint16_t _next_address;

    uint16_t next_address ();
  };
}

namespace BindManagement
{
  struct Entries:public HF::Core::BindManagement::Entries
  {
    typedef HF::Core::BindManagement::Entry Entry;
    typedef HF::Core::BindManagement::EntryPtr EntryPtr;

    HF::Common::Result save (const Entry &entry);

    HF::Common::Result destroy (const Entry &entry);

    void insert (Entry &entry);
  };

  struct Server:public HF::Core::BindManagement::Server <Entries>
  {
    Server(HF::Devices::Concentrator::IUnit0 &unit):
           HF::Core::BindManagement::Server <Entries>(unit)
    {}
  };

}

namespace Commands
{
  typedef HF::Interfaces::Alert::Server Alert;
  typedef HF::Interfaces::LevelControl::Client LevelControl;
  typedef HF::Interfaces::OnOff::Client OnOff;
  typedef HF::Interfaces::SimplePowerMeter::Server SimplePowerMeter;

  struct Unit:public HF::Units::Unit <HF::Profiles::GenericApplicationLogic, Alert,
                                      LevelControl, OnOff, SimplePowerMeter>
  {
    Unit(uint8_t id, HF::IDevice &device):HF::Units::Unit <HF::Profiles::GenericApplicationLogic,
                                                           Alert, LevelControl, OnOff,
                                                           SimplePowerMeter>(id, device)
    {}

    Alert &alert ()
    {
      return *const_cast <Alert *>(get <0>());
    }

    LevelControl &level_control ()
    {
      return *const_cast <LevelControl *>(get <1>());
    }

    OnOff &on_off ()
    {
      return *const_cast <OnOff *>(get <2>());
    }

    SimplePowerMeter &simple_power_meter ()
    {
      return *const_cast <SimplePowerMeter *>(get <3>());
    }

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

typedef HF::Devices::Concentrator::Unit0 <HF::Core::DeviceInformation::Server,
                                          DeviceManagement::Server,
                                          HF::Core::AttributeReporting::Server,
                                          BindManagement::Server> Unit0;

struct FP:public HF::Devices::Concentrator::Abstract <Unit0>
{
  Commands::Unit commands;

  static FP * instance();

  virtual ~FP()
  {}

  void receive (HF::Protocol::Packet &packet, HF::Common::ByteArray &payload, uint16_t offset);

  using HF::Devices::Concentrator::Abstract <Unit0>::link;

  std::forward_list <HF::Transport::Link *> &links()
  {
    return _links;
  }

  bool has_bind (uint16_t dev_addr_1, uint16_t dev_addr_2);

  uint8_t bind (uint16_t dev_addr_1, uint16_t dev_addr_2);

  bool unbind (uint16_t dev_addr_1, uint16_t dev_addr_2);

  private:

  FP():HF::Devices::Concentrator::Abstract <Unit0>(),
    commands(1, *this)
  {}
};

openD_status_t openD_hanfunApi_fp_init( HF::Transport::Layer *transport );

openD_status_t openD_hanfunApi_fp_devMgmtRequest( openD_hanfunApi_devMgmtReq_t *hMgmtRequest, uint16_t address = 0, uint8_t dectMode = 0 );

openD_status_t openD_hanfunApi_fp_bindMgmtRequest( openD_hanfunApi_bindMgmtReq_t *hBindRequest, uint16_t address1 = 0, uint16_t address2 = 0 );

openD_status_t openD_hanfunApi_fp_profileRequest( openD_hanfunApi_profileReq_t *hProfileRequest, uint16_t address = 0, uint16_t unit = 0 );


#endif /* __OPEND_HANFUN_API_FP_H__ */