eoSerialCommand.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 EOSERIALCOMMAND_H_
#define EOSERIALCOMMAND_H_
#include "eoHalTypes.h"
#include "eoApiDef.h"
#include "eoPacket.h"
#include "eoSerialEvents.h"
#include <vector>
class eoGateway;


typedef enum
{
  CO_WR_SLEEP = 1,
  CO_WR_RESET = 2,
  CO_RD_VERSION = 3,
  CO_RD_SYS_LOG = 4,
  CO_WR_SYS_LOG = 5,
  CO_WR_BIST = 6,
  CO_WR_IDBASE = 7,
  CO_RD_IDBASE = 8,
  CO_WR_REPEATER = 9,
  CO_RD_REPEATER = 10,
  CO_WR_FILTER_ADD = 11,
  CO_WR_FILTER_DEL = 12,
  CO_WR_FILTER_DEL_ALL = 13,
  CO_WR_FILTER_ENABLE = 14,
  CO_RD_FILTER = 15,
  CO_WR_WAIT_MATURITY = 16,
  CO_WR_SUBTEL = 17,
  CO_WR_MEM = 18,
  CO_RD_MEM = 19,
  CO_RD_MEM_ADDRESS = 20,
  CO_RD_SECURITY = 21,
  CO_WR_SECURITY = 22,
  CO_WR_MODE = 28,
  CO_RD_SECUREDEVICE_COUNT = 29,
  CO_RD_SECUREDEVICE_BY_ID = 30,
  CO_WR_SECUREDEVICE_ADD_PSK = 31,
  CO_WR_SECUREDEVICE_SENDTEACHIN = 32,
  CO_WR_TEMPORARY_RLC_WINDOW = 33,
  CO_RD_SECUREDEVICE_PSK = 34,
  CO_RD_DUTYCYCLE_LIMIT = 35,
  CO_SET_BAUDRATE = 36,
  CO_GET_FREQUENCY_INFO = 37,
  // 38 is not used
  CO_GET_STEPCODE = 39,
  CO_WR_SECUREDEVICE_CLEAR_LIST = 40,
  //41-45 are deprecated / not used
  CO_WR_REMAN_CODE  = 46,
  CO_WR_STARTUP_DELAY = 47,
  CO_WR_REMAN_REPEATING = 48,
  CO_RD_REMAN_REPEATING = 49,
  CO_SET_NOISETHRESHOLD = 50,
  CO_GET_NOISETHRESHOLD = 51,
  CO_WR_RLC_SAVE_PERIOD = 52,
  CO_WR_RLC_LEGACY_MODE = 53,
  CO_WR_SECUREDEVICEV2_ADD = 54,
  CO_RD_SECUREDEVICEV2_BY_INDEX = 55,
  CO_WR_RSSITEST_MODE = 58,
  CO_RD_RSSITEST_MODE = 59,
  CO_WR_SECUREDEVICE_MAINTENANCEKEY = 60,
  CO_RD_SECUREDEVICE_MAINTENANCEKEY = 61,
  CO_WR_TRANSPARENT_MODE = 62,
  CO_RD_TRANSPARENT_MODE = 63,
  CO_WR_TX_ONLY_MODE = 64,
  CO_RD_TX_ONLY_MODE = 65,
} COMMON_COMMAND_TYPE;

typedef enum
{
  BLOCK_RADIO = 0x00,
  APPLY_RADIO = 0x80,
  BLOCK_REPEATED = 0x40,
  APPLY_REPEATED = 0xC0
} FILTER_KIND;

typedef enum
{
  SOURCE_ID = 0,
  CHOICE = 1,
  DBM = 2,
  DESTINATION_ID = 0
} FILTER_TYPE;

typedef enum
{
  FLASH = 0,
  RAM_0 = 0x01,
  DATA_RAM = 0x02,
  IDATA_RAM = 0x03,
  XDATA_RAM= 0x04,
} MEMORY_TYPE;

typedef enum
{
  OR = 0,
  AND = 1
} FILTER_OPERATOR;

typedef struct
{
  uint8_t appVersion[4]; //Application versions
  char appDescription[16]; //Applications description
  uint8_t apiVersion[4]; //API version
  uint32_t chipID; //Unique ID
  uint32_t chipVersion; //Reserved for internal use
} CO_RD_VERSION_RESPONSE;

typedef struct
{
  MEMORY_TYPE memoryType;
  uint32_t memoryAddress;
  uint16_t dataLength;
} CO_RD_MEMORY;

typedef struct
{
  std::vector<uint8_t> memoryData;
} CO_RD_MEMORY_RESPONSE;

typedef struct
{
  MEMORY_TYPE memoryType;
  uint32_t memoryAddress;
  std::vector<uint8_t> memoryData;
} CO_WR_MEMORY;

typedef struct
{
  uint32_t baseID; //Base ID
  uint8_t remainingWrites; //Remaining write cycles for Base ID
} CO_RD_IDBASE_RESPONSE;

typedef struct
{
  bool repEnable; //Repeater enable
  uint8_t repLevel; //Repeater level
} CO_RD_REPEATER_RESPONSE;

typedef struct
{
  FILTER_TYPE filterType; //Filter type
  uint32_t filterValue; //Filter value
} CO_RD_FILTER_RESPONSE;



typedef enum
{
  EC_VOLTAGE_DROP = 0x00,
  EC_RESET_PIN = 0x01,
  EC_WATCHDOG_TIMER = 0x02,
  EC_FLYWHEEL_TIMER = 0x03,
  EC_PARITY_ERROR = 0x04,
  EC_PARITY_MEM_ERROR = 0x05,
  EC_MEM_ERRPR = 0x06,
  EC_WAKE_PIN_0 = 0x07,
  EC_WAKE_PIN_1 = 0x08,
  EC_UNKNOWN = 0x09
} EC_RESET_CAUSE;

typedef enum
{
  MODE_COMPATIBLE = 0x00,
  MODE_ADVANCED = 0x01
} WR_MODE_CODE;

typedef struct
{
  uint8_t priPostmaster;
  uint32_t manufacturerID;
  uint8_t eep[3];
  uint8_t rssi;
  uint32_t postmasterID;
  uint32_t smartAckID;
  uint8_t hopCount;
} SA_CONFIRM_LEARN_REQUEST;

typedef struct
{
  uint16_t responseTime;
  SA_CONFIRM_CODE confirmCode;
} SA_LEARN_ACK_RESPONSE;

typedef struct
{
  EC_RESET_CAUSE resetCause;
} CO_READY_RESPONSE;

typedef enum
{
  SA_WR_LEARNMODE = 1,
  SA_RD_LEARNMODE = 2,
  SA_WR_LEARNCONFIRM = 3,
  SA_WR_CLIENTLEARNRQ = 4,
  SA_WR_RESET = 5,
  SA_RD_LEARNEDCLIENTS = 6,
  SA_WR_RECLAIMS = 7,
  SA_WR_POSTMASTER = 8
} SA_COMMAND_TYPE;

typedef enum
{
  SA_CC_LEARNIN = 0X00,
  SA_CC_LEARNOUT = 0X20
} SMARTACK_CONFIRM_CODE;

typedef enum
{
  SA_EL_SIMPLE = 0X00,
  SA_EL_ADVANCE = 0X01,
  SA_EL_ADVANCE_REP = 0X02
} SA_EXTENDED_LEARNMODE;

typedef struct
{
  bool enabled;
  SA_EXTENDED_LEARNMODE extended;
} SA_RD_LEARNMODE_RESPONSE;

typedef struct
{
  uint32_t clientID;
  uint32_t postmasterID;
  uint8_t mailboxIndex;

} SA_RD_LEARNEDCLIENTS_RESPONSE;



typedef struct
{
  uint8_t availableCycle;
  uint8_t numOfSlots;
  uint16_t slotPeriod;
  uint16_t slotPeriodLeft;
  uint8_t loadAfterCycle;
} CO_RD_DUTYCYCLE_RESPONSE;

typedef struct
{
  uint8_t code[4];
}
CO_REMAN_CODE;
typedef enum
{
  MHZ_315=0x00,
  MHZ_868_3 = 0x01,
  MHZ_902_875 = 0x02,
  MHZ_925 = 0x03,
  MHZ_928 = 0x04,
  GHZ_2_4 = 0x20
} ESP3_FREQUENCY;

typedef enum
{
  ERP1 = 0x00,
  ERP2 = 0x01,
  IEEE_802_15_4 = 0x10,
  BLUETOOTH = 0x20,
  LONGRANGE = 0x30,
} ESP3_PROTOCOL;


typedef struct
{
  ESP3_FREQUENCY frequency;
  ESP3_PROTOCOL protocol;
} CO_RD_FREQUENY_RESPONSE;
typedef struct
{
  uint8_t stepcode;
  uint8_t statuscode;
} CO_RD_STEPCODE_RESPONSE;

typedef enum
{
  TX_ONLY_OFF = 0,
  TX_ONLY_ON=1,
  TX_ONLY_WITH_ON_AUTO_SLEEP =2,
  TX_ONLY_MAX
} CO_TX_ONLY_MODE;

class eoSerialCommand
{

public:
  eoSerialCommand(eoGateway *gateway);
  virtual ~eoSerialCommand();
  eoReturn GetFrequencyInfo(CO_RD_FREQUENY_RESPONSE &response);
  eoReturn GetStepCode(CO_RD_STEPCODE_RESPONSE &response);
  eoReturn Sleep(const uint32_t sleepPeriod);
  eoReturn Reset();
  eoReturn ReadVersion(CO_RD_VERSION_RESPONSE &version);
  eoReturn ReadMemory(CO_RD_MEMORY const &readMemory, CO_RD_MEMORY_RESPONSE &response);
  eoReturn WriteMemory(CO_WR_MEMORY const &writeMemory);
  eoReturn BIST();
  eoReturn WriteIDBase(const uint32_t baseID);
  eoReturn ReadIDBase(CO_RD_IDBASE_RESPONSE &response);
  eoReturn WriteRepeater(bool repEnable, const uint8_t repLevel);
  eoReturn ReadRepeater(CO_RD_REPEATER_RESPONSE &response);
  eoReturn AddFilter(const FILTER_TYPE filterType, const uint32_t filterValue, const FILTER_KIND filterKind);
  eoReturn DeleteFilter(const FILTER_TYPE filterType, const uint32_t filterValue);
  eoReturn DeleteAllFilter();
  eoReturn EnableFilter(const bool filterEnabled, const FILTER_OPERATOR filterOperator);
  eoReturn ReadFilter(CO_RD_FILTER_RESPONSE *filter, uint8_t *filterCount, uint8_t maxFilterCount);
  eoReturn WaitMaturity(const bool waitMaturity);
  eoReturn SmartAckConfirmLearn(uint16_t responseTime, SA_CONFIRM_CODE confirmCode);
  eoReturn SmartAckLearnAck(SA_LEARN_ACK_RESPONSE &response);
  eoReturn Ready(CO_READY_RESPONSE &response);
  eoReturn SmartAckWriteLearnMode(bool enable, SA_EXTENDED_LEARNMODE extended, uint32_t timeout);
  eoReturn SmartAckReadLearnMode(SA_RD_LEARNMODE_RESPONSE &response);
  eoReturn SmartAckLearnConfirm(uint16_t responseTime, SMARTACK_CONFIRM_CODE confirmCode, uint32_t postmasterID, uint32_t clientID);
  eoReturn SmartAckSendLearnRequest(uint16_t manufacturerID, uint32_t EEP);
  eoReturn SmartAckReset(uint32_t clientID);
  eoReturn SmartAckLearnedClients(SA_RD_LEARNEDCLIENTS_RESPONSE *clients, uint8_t *learnedCount, uint8_t maxLearnedCount);
  eoReturn SmartAckSetReclaimTries(uint8_t reclaimCount);
  eoReturn SmartAckSetPostmaster(uint8_t mailboxCount);
  eoReturn EventSmartAckConfirmLearn (SA_CONFIRM_LEARN_REQUEST &request);
  eoReturn WriteMode (WR_MODE_CODE mode);
  eoReturn DutyCycleReadLimit(CO_RD_DUTYCYCLE_RESPONSE &response);
  eoReturn EventDutyCycleLimit (CO_DUTYCYCLE_LIMIT &request);
  eoReturn DutyCycleLimit (CO_DUTYCYCLE_LIMIT limit);

  eoReturn WriteStartupDelay(uint8_t delay);

  eoReturn WriteRemanRepeating(bool enabled);
  eoReturn ReadRemanRepeating(bool &isEnabled);
  eoReturn SetNoiseTreshold(uint8_t rssiLevel);
  eoReturn GetNoiseTreshold(uint8_t &rssiLevel);
  eoReturn WriteRssiTestMode(bool enable,uint16_t timeOut);

  eoReturn ReadRssiTestMode(bool &isEnabled);

  eoReturn WriteTransparentMode(bool enable);
  eoReturn ReadTransparentMode(bool &isEnabled);

  eoReturn WriteTXOnlyMode(CO_TX_ONLY_MODE txOnlyMode);
  eoReturn ReadTXOnlyMode(CO_TX_ONLY_MODE & txOnlyMode);

  eoPacket GetSerialPacket();
private:
  eoGateway *gateway;
  eoReturn initPacket(uint8_t type, uint8_t command, uint8_t length);
  eoPacket serialPacket;
};

#endif /* EOSERIALCOMMAND_H_ */