eoSerialEvents.h

/******************************************************************************
 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 EOSERIALEVENTS_H_
#define EOSERIALEVENTS_H_
#include "eoPacket.h"
#include <vector>

typedef enum
{
  CO_DUTYCYCLE_LIMIT_UNREACHED = 0x00,
  CO_DUTYCYCLE_LIMIT_REACHED = 0x01
} CO_DUTYCYCLE_LIMIT;

typedef enum
{
  SA_RECLAIM_NOT_SUCCESSFUL = 1,
  SA_CONFIRM_LEARN = 2,
  SA_LEARN_ACK = 3,
  CO_READY = 4,
  SA_READY = 4,
  CO_EVENT_SECUREDEVICES = 0x05,
  SA_DUTYCYCLE_LIMIT = 6,
  CO_EVENT_DUTYCYCLE_LIMIT = 0x06,
  CO_EVENT_TRANSMISSION_FAILED = 0x07,
  CO_TX_DONE = 0x08,
  CO_LRN_MODE_DISABLED = 0x09
} SA_EVENT_TYPE;

typedef enum
{
  SA_LEARN_IN = 0x00,
  SA_EEP_NOT_ACCEPTED = 0x11,
  SA_PM_FULL = 0x12,
  SA_CONTROLLER_FULL = 0x13,
  SA_RSSI_NOT_GOOD = 0x14,
  SA_LEARN_OUT = 0x20,
  SA_NOT_SUPPORTED = 0xFF
} SA_CONFIRM_CODE;

class  eoSerialEvent
{
public:
  static eoSerialEvent* parsePacket(eoPacket &packet);
  SA_EVENT_TYPE getEventType() const  { return event; };
protected:
  SA_EVENT_TYPE event;
  eoPacket* preparePacket(uint8_t u8Length) const;
  eoSerialEvent();
};
class  eoEventReclaimNotSuccesfull : public eoSerialEvent
{
public:
  eoEventReclaimNotSuccesfull();
};
class  eoEventConfirmLearn : public eoSerialEvent
{
public:
  static eoEventConfirmLearn* createFromPacket(eoPacket &packet);
  eoEventConfirmLearn(uint8_t priorityOfPostMasterCandidate,uint16_t manufacturerID,uint8_t eep_rorg,uint8_t eep_func,
                      uint8_t eep_type,uint8_t rssi,uint32_t postMasterCandidate, uint32_t  smartAckClient,uint8_t hopCount);
  /*Priority of the postmaster candidate 0xnn Already post master 0b xxxx 1xxx
    Place for mailbox 0b xxxx x1xx
    Good RSSI 0b xxxx xx1x
    Local 0b xxxx xxx1
    */
  uint8_t priorityOfPostMasterCandidate;
  uint16_t manufacturerID;
  uint8_t eep_rorg;
  uint8_t eep_func;
  uint8_t eep_type;
  uint8_t rssi;
  uint32_t postMasterCandidate;
  uint32_t  smartAckClient;
  uint8_t hopCount;
  static eoPacket createResponse(uint16_t responseTime, SA_CONFIRM_CODE code);
};
class  eoEventLearnAck : public eoSerialEvent
{
public:
  static eoEventLearnAck* createFromPacket(eoPacket& packet);
  eoEventLearnAck(uint16_t responseTime, SA_CONFIRM_CODE confirmCode);
  uint16_t responseTime;
  SA_CONFIRM_CODE confirmCode;
};

typedef enum
{
  READY_MODE_STANDARD_SECURITY = 0,
  READY_MODE_EXTENDED_SECURITY = 1,
  READY_MODE_UNKNOWN,
} READY_MODE_t;

typedef enum
{
  RESET_VOLTATE_DROP = 0,
  RESET_RESET_PIN = 1,
  RESET_WATCHDOG = 2,
  RESET_FLYWHEEL = 3,
  RESET_PARITY = 4,
  RESET_MEMORY_ERROR = 5,
  RESET_INVALID_MEMORY = 6,
  RESET_PIN0 = 7,
  RESET_PIN1 = 8,
  RESET_UNKOWN = 9,
  RESET_UART = 10,
} WAKEUP_CAUSE_t;

class  eoEventReady : public eoSerialEvent
{
public:
  static eoEventReady* createFromPacket(eoPacket& packet);
  eoEventReady(WAKEUP_CAUSE_t wakeUpCause);
  WAKEUP_CAUSE_t wakeUpCause;
  READY_MODE_t mode;
};

typedef enum
{
  SEC_EVENT_TI_FAILED = 0,
  SEC_EVENT_RESERVED = 1,
  SEC_EVENT_RES_WRONG_KEY = 2,
  SEC_EVENT_CONF_COUNT_TEL_CMAC = 3,
  SEC_EVENT_CONF_TELEGRAM_CORRUPT = 0x04,
  SEC_EVENT_NO_PSK = 0x05,
  SEC_EVENT_NO_PSK_AVAILABLE  = 0x06,
  SEC_EVENT_RLCCMAC_INCORRECT = 0x07,
  SEC_EVENT_STANDARD_TELEGRAM= 0x08,
  SEC_EVENT_TI_SUCCESS = 0x09,
  SEC_EVENT_VALID_RLC = 0x0A,
} SECURE_EVENT_CAUSE_t;

class  eoEventSecureDevice : public eoSerialEvent
{
public:
  static eoEventSecureDevice* createFromPacket(eoPacket& packet);
  eoEventSecureDevice(SECURE_EVENT_CAUSE_t eventCause, uint32_t  deviceId);
  SECURE_EVENT_CAUSE_t eventCause;
  uint32_t  deviceId;
};
class  eoEventDutyCycleLimit : public eoSerialEvent
{
public:
  static eoEventDutyCycleLimit* createFromPacket(eoPacket& packet);
  eoEventDutyCycleLimit(CO_DUTYCYCLE_LIMIT eventCause);
  CO_DUTYCYCLE_LIMIT eventCause;
};

typedef enum
{
  EVENT_TRANSMISSION_CSMA_FAILED = 0,
  EVENT_NO_ACK_RECEIVED = 1,
} EVENT_TRANSMISSION_FAILED_t;
class  eoEventTransmitFailed : public eoSerialEvent
{
public:
  static eoEventTransmitFailed* createFromPacket(eoPacket& packet);
  eoEventTransmitFailed(EVENT_TRANSMISSION_FAILED_t eventCause);
  EVENT_TRANSMISSION_FAILED_t eventCause;
};

class  eoEventTXDone : public eoSerialEvent
{
public:
  eoEventTXDone();
};
class  eoEventLRNModeDisabled : public eoSerialEvent
{
public:
  eoEventLRNModeDisabled();
};
#endif /* EOSERIALCOMMAND_H_ */