eoReCom.h

Go to the documentation of this file.

/******************************************************************************
 DISCLAIMER

 THIS SOFTWARE PRODUCT ("SOFTWARE") IS PROPRIETARY TO ENOCEAN GMBH, OBERHACHING,
 GERMANY (THE "OWNER") AND IS PROTECTED BY COPYRIGHT AND INTERNATIONAL TREATIES OR
 PROTECTED AS TRADE SECRET OR AS OTHER INTELLECTUAL PROPERTY RIGHT. ALL RIGHTS, TITLE AND
 INTEREST IN AND TO THE SOFTWARE, INCLUDING ANY COPYRIGHT, TRADE SECRET OR ANY OTHER
 INTELLECTUAL PROPERTY EMBODIED IN THE SOFTWARE, AND ANY RIGHTS TO REPRODUCE,
 DISTRIBUTE, MODIFY, DISPLAY OR OTHERWISE USE THE SOFTWARE SHALL EXCLUSIVELY VEST IN THE
 OWNER. ANY UNAUTHORIZED REPRODUCTION, DISTRIBUTION, MODIFICATION, DISPLAY OR OTHER
 USE OF THE SOFTWARE WITHOUT THE EXPLICIT PERMISSION OF OWNER IS PROHIBITED AND WILL
 CONSTITUTE AN INFRINGEMENT OF THE OWNER'S RIGHT AND MAY BE SUBJECT TO CIVIL OR
 CRIMINAL SANCTION.

 THIS SOFTWARE IS PROVIDED BY THE OWNER "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN PARTICULAR, THE OWNER DOES NOT WARRANT
 THAT THE SOFTWARE SHALL BE ERROR FREE AND WORKS WITHOUT INTERRUPTION.

 IN NO EVENT SHALL THE OWNER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************************************************************/

#ifndef EO_REMOTE_COMISSIONING_H_
#define EO_REMOTE_COMISSIONING_H_
#include "eoGateway.h"
#include "eoGenericProfile.h"
typedef enum
{
  RECOM_OK = 0x00,
  RECOM_WRONG_ID = 0x01,
  RECOM_WRONG_UNLOCK_CODE = 0x02,
  RECOM_WRONG_EEP = 0x03,
  RECOM_WRONG_MANUFACTURER_ID = 0x04,
  RECOM_WRONG_DATA_SIZE = 0x05,
  RECOM_NO_CODE_SET = 0x06,
  RECOM_NOT_SEND = 0x07,
  RECOM_RPC_FAIL = 0x08,
  RECOM_MSG_TIMEOUT = 0x09,
  RECOM_MSG_TOO_LONG = 0x0A,
  RECOM_MSG_PART_RECEIVED = 0x0B,
  RECOM_MSG_PART_NOT_RECEIVED = 0x0C,
  RECOM_ADDR_OUT_OF_RANGE = 0x0D,
  RECOM_CODE_DATA_SIZE_EXCEED = 0x0E,
  RECOM_SESSION_CLOSED = 0x10,
  RECOM_INSUFFICENT_RIGHTS = 0x11
} eoReComReturn;

typedef enum
{
  FN_RECOM_ACK = 0x240, //Remote Commissioning Acknowledge
  FN_RECOM_GET_METADATA = 0x210, //Get Link Table Metadata Query
  FN_RECOM_GET_METADATA_RESPONSE = 0x810, //Get Link Table Metadata Response
  FN_RECOM_GET_TABLE = 0x211, //Get Link Table Query
  FN_RECOM_GET_TABLE_RESPONSE = 0x811, //Get Link Table Response
  FN_RECOM_SET_TABLE = 0x212, //Set Link Table Query
  FN_RECOM_GET_GP_TABLE = 0x213, //Get Link Table GP Entry Query
  FN_RECOM_GET_GP_TABLE_RESPONSE = 0x813, //Get Link Table GP Entry Response
  FN_RECOM_SET_GP_TABLE = 0x214, //Set Link Table GP Entry Query
  FN_RECOM_SET_LEARN_MODE = 0x220, //Remote Set Learn Mode
  FN_RECOM_TRIG_OUTBOUND_TEACH_REQ = 0x221, //Trigger Outbound Remote Teach Request
  FN_RECOM_GET_DEVICE_CONFIG = 0x230, //Get Device Configuration Query
  FN_RECOM_GET_DEVICE_CONFIG_RESPONSE = 0x830, //Get Device Configuration Response
  FN_RECOM_SET_DEVICE_CONFIG = 0x231, //Set Device Configuration Query
  FN_RECOM_GET_LINK_BASED_CONFIG = 0x232, //Get Link Based Configuration Query
  FN_RECOM_GET_LINK_BASED_CONFIG_RESPONSE = 0x832, //Get Link Based Configuration Response
  FN_RECOM_SET_LINK_BASED_CONFIG = 0x233, //Set Link Based Configuration Query
  FN_RECOM_APPLY_CHANGES = 0x226, //Apply Changes Command
  FN_RECOM_RESET_TO_DEFAULTS = 0x224, //Reset to Defaults
  FN_RECOM_RADIO_LINK_TEST_CONTROL = 0x225, //Radio Link Test Control
  FN_RECOM_GET_PRODUCT_ID = 0x227, //Get Product ID Query
  FN_RECOM_GET_PRODUCT_RESPONSE = 0x827, //Get Product ID Response
  FN_RECOM_GET_REPEATER_FUNCTIONS = 0x250, //Get Repeater Functions Query
  FN_RECOM_GET_REPEATER_FUNCTIONS_RESPONSE = 0x850, //Get Repeater Functions Response
  FN_RECOM_SET_REPEATER_FUNCTIONS = 0x251, //Set Repeater Functions Query
  FN_RECOM_SET_REPEATER_FILTER = 0x252 //Set Repeater Filter Query
} FN_RECOM_CODE;

typedef enum
{
  RECOM_NOT_SUPPORTED = 0x00,
  RECOM_SUPPORTED = 0x01
} RECOM_SUPPORT;

typedef enum
{
  RECOM_INBOUND_TABLE = 0x00,
  RECOM_OUTBOUND_TABLE = 0x01
} RECOM_TABLE_DIR;

typedef enum
{
  RECOM_CHANGES_NOT_APPLY = 0x00,
  RECOM_CHANGES_APPLY = 0x01
} RECOM_CHANGES;

typedef enum
{
  RECOM_LEARN_IN = 0x00,
  RECOM_LEARN_OUT = 0x01,
  RECOM_EXIT_LEARN = 0x02
} RECOM_LEARN_MODE;

typedef enum
{
  RECOM_NO_DEFAULT_RESET = 0x00,
  RECOM_DEFAULT_RESET = 0x01
} RECOM_RESET;

typedef enum
{
  RECOM_REPEATER_OFF = 0x00,
  RECOM_REPEATER_ON = 0x01,
  RECOM_FILTERED_REPEATER_ON = 0x02
} RECOM_REPEATER_FUNC;

typedef enum
{
  RECOM_REPEATER_LEVEL_1 = 0x01,
  RECOM_REPEATER_LEVEL_2 = 0x02
} RECOM_REPEATER_LEVEL;

typedef enum
{
  RECOM_REPEATER_AND = 0x00,
  RECOM_REPEATER_OR = 0x01
} RECOM_REPEATER_FILTER;

typedef enum
{
  RECOM_REPEATER_BLOCK = 0x00,
  RECOM_REPEATER_APPLY = 0x01,
  RECOM_REPEATER_DELETE_FILTER = 0x02,
  RECOM_REPEATER_DELETE_ALL = 0x03
} RECOM_REPEATER_FILTER_CONTROL;

typedef enum
{
  RECOM_FILTER_SOURCE_ID = 0x00,
  RECOM_FILTER_RORG = 0x01,
  RECOM_FILTER_DBM = 0x02,
  RECOM_FILTER_DESTINATION_ID = 0x03
} RECOM_REPEATER_FILTER_TYPE;

typedef struct
{
  RECOM_SUPPORT remoteTeachOutbound;
  RECOM_SUPPORT remoteTeachInbound;
  RECOM_SUPPORT outboundLinkTable;
  RECOM_SUPPORT inboundLinkTable;
  uint8_t lengthOfOutbound;
  uint8_t maxOfOutbound;
  uint8_t lengthOfInbound;
  uint8_t maxOfInbound;
} QUERY_METADATA_RESPONSE;

typedef struct
{
  RECOM_TABLE_DIR tableDir;
  uint8_t startIndex;
  uint8_t endIndex;
} QUERY_LINK_TABLE;

typedef struct gplinkTable
{
  RECOM_TABLE_DIR tableDir;
  uint8_t index;
  uint8_t length;
  uint8_t * gp_ti;
  gplinkTable() : tableDir(RECOM_INBOUND_TABLE),index(0),length(0),gp_ti(NULL) {};
} GP_LINK_TABLE;

typedef struct
{
  uint8_t index;
  uint32_t ID;
  uint8_t EEP_RORG;
  uint8_t EEP_FUNC;
  uint8_t EEP_TYPE;
  uint8_t channel;
} LINK_TABLE;

typedef struct
{
  RECOM_LEARN_MODE mode;
  uint8_t inboundIndex;
} QUERY_SET_LEARN_MODE;

typedef struct
{
  uint16_t startIndex;
  uint16_t endIndex;
  uint8_t length;
} QUERY_DEVICE_CONFIG;

typedef struct
{
  uint16_t index;
  uint8_t length;
  uint32_t rawValue;
} DEVICE_CONFIG;

typedef struct
{
  RECOM_TABLE_DIR tableDir;
  uint16_t tableIndex;
  uint16_t startIndex;
  uint16_t endIndex;
  uint8_t length;
} QUERY_LINK_BASED_CONFIG;
typedef struct
{
  RECOM_TABLE_DIR tableDir;
  uint8_t tableIndex;
  uint16_t index;
  uint8_t length;
  uint32_t rawValue;
} LINK_BASED_CONFIG;


typedef struct
{
  RECOM_CHANGES linkTableChanges;
  RECOM_CHANGES configChanges;
} QUERY_APPLY_CHANGES;

typedef struct
{
  RECOM_RESET configParam;
  RECOM_RESET inboundTable;
  RECOM_RESET outboundTable;
} QUERY_RESET_DEFAULTS;

typedef struct
{
  bool isEnabled;
  uint8_t numOfRLT;
} QUERY_RADIO_LINK_TEST;

typedef struct
{
  uint16_t manufacturerId;
  uint32_t productReference;
} QUERY_PRODUCT_ID_RESPONSE;

typedef struct
{
  RECOM_REPEATER_FUNC repeaterFunc;
  RECOM_REPEATER_LEVEL repeaterLevel;
  RECOM_REPEATER_FILTER repeaterFilter;
} REPEATER_FUNCTIONS;

typedef struct
{
  RECOM_REPEATER_FILTER_CONTROL repeaterFunc;
  RECOM_REPEATER_FILTER_TYPE repeaterLevel;
  uint32_t value;
} QUERY_SET_REPEATER_FILTER;

class eoReCom
{
private:
  bool shallBeRepeated;
  eoGateway *gateway;
  eoReManMessage reManMessage;
  eoReturn initPacket(FN_RECOM_CODE const fnCode, uint8_t const length);

  eoReturn GetRawValue(uint8_t length,uint8_t offset,eoReManMessage const &reManMessage,uint32_t &value) const;

  eoReturn SetRawValue(uint8_t length,uint8_t offset,eoReManMessage &reManMessage,uint32_t const &value) const;

  uint8_t keyToUse;

  eoReturn sendMessage()
  {
    return gateway->Send(reManMessage, shallBeRepeated, keyToUse);
  }

public:
  eoReCom(eoGateway *gateway);
  ~eoReCom();
  bool GetShallBeRepeated() const
  {
    return shallBeRepeated;
  };
  void SetShallBeRepeated(bool repeat)
  {
    shallBeRepeated = repeat;
  };

  bool GetKeyToUse() const
  {
    return keyToUse;
  };
  void SetKeyToUse(uint8_t key)
  {
    keyToUse = key;
  };
  eoReturn GetMetadata(uint32_t destinationID);
  eoReturn ParseGetMetadataResponse(QUERY_METADATA_RESPONSE  &response) const;
  eoReturn GetLinkTable(QUERY_LINK_TABLE const &query, uint32_t const destinationID);
  eoReturn ParseGetLinkTableResponse(std::vector<LINK_TABLE> &response, RECOM_TABLE_DIR &tableDir) const;
  eoReturn SetLinkTable(std::vector<LINK_TABLE> const &query, RECOM_TABLE_DIR tableDir, uint32_t destinationID);
  eoReturn GetGPLinkTable(GP_LINK_TABLE const &query, uint32_t destinationID);
  eoReturn ParseGetGPLinkTableResponse(GP_LINK_TABLE &query) const;
  eoReturn SetGPLinkTable(GP_LINK_TABLE const &query, uint32_t destinationID);

  eoReturn RemoteSetLearnMode(QUERY_SET_LEARN_MODE const &learnMode, uint32_t destinationID);
  eoReturn TriggerOutboundTeachRequest(uint8_t channel, uint32_t destinationID);
  eoReturn GetDeviceConfig(QUERY_DEVICE_CONFIG const &deviceConf, uint32_t destinationID);
  eoReturn ParseDeviceConfigResponse(std::vector<DEVICE_CONFIG> &deviceConf) const;
  eoReturn SetDeviceConfig(std::vector<DEVICE_CONFIG> const &deviceConf, uint32_t destinationID);
  eoReturn GetLinkBasedConfig(QUERY_LINK_BASED_CONFIG const &linkConfig, uint32_t destinationID);
  eoReturn SetLinkBasedConfig(std::vector<LINK_BASED_CONFIG> const &linkConfig, uint32_t destinationID);
  eoReturn ParseLinkBasedConfigResponse(std::vector<LINK_BASED_CONFIG> &linkConfig) const;
  eoReturn ApplyChanges(QUERY_APPLY_CHANGES const &changes, uint32_t destinationID);
  eoReturn ResetDefaults(QUERY_RESET_DEFAULTS const &defaults, uint32_t destinationID);
  eoReturn RadioLinkTest(QUERY_RADIO_LINK_TEST const &radioLink, uint32_t destinationID);
  eoReturn GetProductID(uint32_t destinationID = BROADCAST_ID);
  eoReturn ParseGetProductIDResponse(QUERY_PRODUCT_ID_RESPONSE &response) const;
  eoReturn GetRepeater(uint32_t destinationID);
  eoReturn ParseGetRepeaterResponse(REPEATER_FUNCTIONS &response) const;
  eoReturn SetRepeater(REPEATER_FUNCTIONS const &repeaterFunc, uint32_t destinationID);
  eoReturn SetRepeaterFilter(QUERY_SET_REPEATER_FILTER const &repeaterFunc, uint32_t destinationID);

};
#endif // !defined(EA_4BFBF49B_3520_48f7_BACB_B62331BA4509__INCLUDED_)