eoEEP_A520xx.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.
 ******************************************************************************/

#if !defined(eoEEP_A520_H__INCLUDED_)
#define eoEEP_A520_H__INCLUDED_

#include "eoA5EEProfile.h"
#include "eoISimpleBidirectionalProfile.h"
typedef enum
{
  ENERGY_INPUT = 0x00,
  ENERGY_STORAGE = 0x01,
  BATTERY_CAPACITY = 0x02,
  CONTACT_COVER = 0x03,
  TEMPERATURE_FAIL = 0x04,
  WINDOW_DETECTION = 0x05,
  ACTUATOR_OBSTRUCTED = 0x06,
  RUN_INTI_SEQ = 0x07,
  LIFT_SET = 0x08,
  VALVE_OPEN = 0x09,
  VALVE_CLOSED = 0x0A,
  SUMMER_BIT = 0x0B,
  SET_POINT_SELECTION = 0x0C,
  SET_POINT_INVERSE = 0x0D,
  SELECT_FUNCTION = 0x0E,
  ON_OFF = 0x0F,
  EXTERNAL_DISABLEMENT = 0x10,
  DISABLE_REMOTE_CONTROL = 0x11,
  OTHER_DISABLEMENT = 0x12,
  WINDOW_DISABLEMENT = 0x13,
  KEYCARD_DISABLEMENT = 0x14,
  ALARM_STATE = 0x15,
  FAN_OVERRIDE = 0x16,
  CONTROLLER_STATE = 0x17,
  ENERGY_HOLDOFF = 0x18,
  SERVICE_ON = 0x19,
  FEED_TEMP = 0x1A,
  CURRENT_TEMP = 0x1B,
  MEASUREMENT_STATUS = 0x1C,
  STATUS_REQUEST = 0x1D,
  BUTTON_LOCK = 0x1E,
  TEMP_SELECTION = 0x1F,
  FAILURE = 0x20,
  MEASUREMENT_CONTROL = 0x21,
  WAKEUP_CYCLE = 0x22,
  DISPLAY_ORIENTATION = 0x23,
  NODE_LOW_BATTERY = 0x24,
  NODE_EXT_COMM_ERROR = 0x25,
  INTERNAL_SENSOR_ERROR = 0x26,
  FAN_SPEED_ERROR = 0x27,
  GENERAL_ERROR = 0x28,
  AUTO_SPEED_SUPPORT = 0x29,
  SUMMER_BYPASS = 0x2A,
  FROST_PROTECTION_ACTIVE = 0x2B,
  RESET_ERROR = 0x2C,
  RESET_FILTER_TIMER = 0x2D,
} HVCA_INDEX;

typedef enum
{
  MODE_AUTO = 0x00,
  MODE_HEAT = 0x01,
  MODE_MORING_WARMUP = 0x02,
  MODE_COOL = 0x03,
  MODE_NIGHT_PURGE = 0x04,
  MODE_PRECOOL = 0x05,
  MODE_OFF = 0x06,
  MODE_TEST = 0x07,
  MODE_EMERGENCY_HEAT = 0x08,
  MODE_FAN_ONLY = 0x09,
  MODE_FREE_COOL = 0x0A,
  MODE_ICE = 0x0B,
  MODE_MAX_HEAT = 0x0C,
  MODE_ECONOMIC = 0x0D,
  MODE_DEHUMIDITY = 0x0E,
  MODE_CALIBRATION = 0x0F,
  MODE_EMERGENCY_COOL = 0x10,
  MODE_EMERGENCY_STEAM = 0x11,
  MODE_MAX_COOL = 0x12,
  MODE_HVC_LOAD = 0x13,
  MODE_NO_LOAD = 0x14,
  MODE_AUTO_HEAT = 0x1F,
  MODE_AUTO_COOL = 0x20
} HVAC_MODE;

typedef enum
{
  VANE_AUTO = 0x00,
  VANE_HORIZONTAL = 0x01,
  VANE_POS_2 = 0x02,
  VANE_POS_3 = 0x03,
  VANE_POS_4 = 0x04,
  VANE_VERTICAL = 0x05,
  VANE_SWING = 0x06,
  VANE_VERT_SWING = 0x0B,
  VANE_HORIZ_SWING = 0x0C,
  VANE_BOTH_SWING = 0x0D,
  VANE_STOP_SWING = 0x0E
} HVCA_VANE_POSITION;

typedef enum
{
  HVCA_OCCUPIED = 0x00,
  HVCA_STANDBY = 0x01,
  HVCA_UNOCCUPIED = 0x02,
  HVCA_OFF = 0X03
} HVCA_ROOM_OCCUPANCY;

typedef enum
{
  HVCA_OCCUPIED_20 = 0x00,
  HVCA_UNOCCUPIED_20 = 0x01,
  HVCA_STANDBY_20 = 0x02,
  HVCA_FROST_20 = 0X03
} HVCA_ROOM_OCCUPANCY_TYPE_20;

typedef enum
{
  HVCA_STAGE_0 = 0x00,
  HVCA_STAGE_1 = 0x01,
  HVCA_STAGE_2 = 0x02,
  HVCA_STAGE_3 = 0x03,
  HVCA_AUTO = 0x1F
} HVCA_FANSPEED;

typedef enum
{
  HVCA_AUTO_MOD = 0x00,
  HVCA_HEAT_MOD = 0x01,
  HVCA_COOL_MOD = 0x02,
  HVCA_OFF_MOD = 0x03
} HVCA_CONTROLLER_MODE;

typedef enum
{
  MEASUREMENT_ERROR = 0x11,
  BATTERY_EMPTY = 0x12,
  FROST_PROTECTION = 0x14,
  BLOCKED_VALVE = 0x21,
  END_POINT_DETECTION = 0x24,
  NO_VALVE = 0x28,
  NOT_TEACHED_IN = 0x31,
  NO_RESPONSE_FROM_CONTROLLER = 0x35,
  TEACH_IN_ERROR = 0x36
} HVCA_FAILURE_CODE;

typedef enum
{
  MEASUREMENT_ACTIVE = 0x00,
  MEASUREMENT_INACTIVE = 0x01
} HVCA_MEASUREMENT_STATUS;

typedef enum
{
  MEASUREMENT_ENABLE = 0x00,
  MEASUREMENT_DISABLE = 0x01
} HVCA_MEASUREMENT_CONTROL;

typedef enum
{
  STATUS_NO_CHANGE = 0x00,
  STATUS_REQUESTED = 0x01
} HVCA_STATUS_REQUEST;

typedef enum
{
  BUTTON_UNLOCKED = 0x00,
  BUTTON_LOCKED = 0x01
} HVCA_BUTTON_LOCK;

typedef enum
{
  FEED_TEMP_SELECT = 0x00,
  TEMP_SETPOINT_SELECT = 0x01
} HVCA_TEMP_SELECTION;

typedef enum
{
  NO_FAILURE_FLAG = 0x00,
  FAILURE_FLAG = 0x01
} HVCA_FAILURE;

typedef enum
{
  SEC_10 = 0x00,
  SEC_60 = 0x01,
  SEC_90 = 0x02,
  SEC_120 = 0x03,
  SEC_150 = 0x04,
  SEC_180 = 0x05,
  SEC_210 = 0x06,
  SEC_240 = 0x07,
  SEC_270 = 0x08,
  SEC_300 = 0x09,
  SEC_330 = 0x0A,
  SEC_360 = 0x0B,
  SEC_390 = 0x0C,
  SEC_420 = 0x0D,
  SEC_450 = 0x0E,
  SEC_480 = 0x0F,
  SEC_510 = 0x10,
  SEC_540 = 0x11,
  SEC_570 = 0x12,
  SEC_600 = 0x13,
  SEC_630 = 0x14,
  SEC_660 = 0x15,
  SEC_690 = 0x16,
  SEC_720 = 0x17,
  SEC_750 = 0x18,
  SEC_780 = 0x19,
  SEC_810 = 0x1A,
  SEC_840 = 0x1B,
  SEC_870 = 0x1C,
  SEC_900 = 0x1D,
  SEC_930 = 0x1E,
  SEC_960 = 0x1F,
  SEC_990 = 0x20,
  SEC_1020 = 0x21,
  SEC_1050 = 0x22,
  SEC_1080 = 0x23,
  SEC_1110 = 0x24,
  SEC_1140 = 0x25,
  SEC_1170 = 0x26,
  SEC_1200 = 0x27,
  SEC_1230 = 0x28,
  SEC_1260 = 0x29,
  SEC_1290 = 0x2A,
  SEC_1320 = 0x2B,
  SEC_1350 = 0x2C,
  SEC_1380 = 0x2D,
  SEC_1410 = 0x2E,
  SEC_1440 = 0x2F,
  SEC_1470 = 0x30,
  SEC_1500 = 0x31,
  HRS_3 = 0x32,
  HRS_6 = 0x33,
  HRS_9 = 0x34,
  HRS_12 = 0x35,
  HRS_15 = 0x36,
  HRS_18 = 0x37,
  HRS_21 = 0x38,
  HRS_24 = 0x39,
  HRS_27 = 0x3A,
  HRS_30 = 0x3B,
  HRS_33 = 0x3C,
  HRS_36 = 0x3D,
  HRS_39 = 0x3E,
  HRS_42 = 0x3F
} HVCA_WAKEUP_CYCLE;

typedef enum
{
  ORIENTATION_0 = 0x00,
  ORIENTATION_90 = 0x01,
  ORIENTATION_180 = 0x02,
  ORIENTATION_270 = 0x03
} HVCA_DISPLAY_ORIENTATION;

typedef enum
{
  HVCA_NO_CHANGE = 0x00,
  HVCA_OPEN_VALVE = 0x01,
  HVCA_RUN_INIT = 0x02,
  HVCA_CLOSE_VALVE = 0x03
} HVCA_SERVICE_COMMAND;

typedef enum
{
  HVCA_MIN_SPEED = 0x00,
  HVCA_SPEED_1 = 0x01,
  HVCA_SPEED_2 = 0x02,
  HVCA_SPEED_3 = 0x03,
  HVCA_MAX_SPEED = 0x04,
  HVCA_SPEED_AUTO = 0x05,
  HVCA_NO_CHANGE_SPEED = 0x07,
} HVCA_ACTUAL_SPEED_SETTING;

typedef enum
{
  HVCA_NO_TIMER_EXPIRED = 0x00,
  HVCA_1_10_MIN_LEFT = 0x01,
  HVCA_11_20_MIN_LEFT = 0x02,
  HVCA_21_30_MIN_LEFT = 0x03,
  HVCA_31_40_MIN_LEFT = 0x04,
  HVCA_41_50_MIN_LEFT = 0x05,
  HVCA_51_60_MIN_LEFT = 0x06,
  HVCA_MORE_60_MIN_LEFT = 0x07
} HVCA_ACTUAL_TIMER_SETTING;

typedef enum
{
  HVCA_NO_TIMER = 0x00,
  HVCA_10_MIN_SET = 0x01,
  HVCA_20_MIN_SET = 0x02,
  HVCA_30_MIN_SET = 0x03,
  HVCA_40_MIN_SET = 0x04,
  HVCA_50_MIN_SET = 0x05,
  HVCA_60_MIN_SET = 0x06,
  HVCA_2_HOUR_SET = 0x07,
  HVCA_3_HOUR_SET = 0x08,
  HVCA_4_HOUR_SET = 0x09,
  HVCA_5_HOUR_SET = 0x0A,
  HVCA_6_HOUR_SET = 0x0B,
  HVCA_7_HOUR_SET = 0x0C,
  HVCA_8_HOUR_SET = 0x0D,
  HVCA_9_HOUR_SET = 0x0E,
  HVCA_10_HOUR_SET = 0x0F,
  HVCA_11_HOUR_SET = 0x10,
  HVCA_12_HOUR_SET = 0x11,
  HVCA_13_HOUR_SET = 0x12,
  HVCA_14_HOUR_SET = 0x13,
  HVCA_15_HOUR_SET = 0x14,
  HVCA_16_HOUR_SET = 0x15,
  HVCA_17_HOUR_SET = 0x16,
  HVCA_18_HOUR_SET = 0x17,
  HVCA_19_HOUR_SET = 0x18,
  HVCA_20_HOUR_SET = 0x19,
  HVCA_21_HOUR_SET = 0x1A,
  HVCA_22_HOUR_SET = 0x1B,
  HVCA_23_HOUR_SET = 0x1C,
  HVCA_24_HOUR_SET = 0x1D,
} HVCA_NEW_TIMER_SETTING;

typedef enum
{
  HVCA_DO_NOT_RESET = 0x00,
  HVCA_DO_RESET = 0x01
} HVCA_ERROR_RESET_COMMAND;


typedef enum
{
  HVCA_DIRECTION_1 = 0x00,
  HVCA_DIRECTION_2 = 0x01
} HVCA_DIRECTION;

class eoEEP_A520xx: public eoA5EEProfile, public eoISimpleBidirectionalProfile
{

private:
  eoMessage outMessage;
  eoEEPChannelInfo *outChannels;
  uint8_t outChannelCount;
  //internal helper tries to set the channel for Direction and type
  eoReturn SetChannels(SIMPLE_DIRECTION direction,uint8_t type);
public:
  eoReturn SetType(uint8_t type);
  eoEEP_A520xx();
  virtual ~eoEEP_A520xx();
  eoReturn GetValue(CHANNEL_TYPE type, uint32_t &value, uint8_t index);
  eoReturn SetValue(CHANNEL_TYPE type, uint32_t value, uint8_t index);
  eoReturn GetValue(CHANNEL_TYPE type, float &value, uint8_t index);
  eoReturn SetValue(CHANNEL_TYPE type, float value, uint8_t index);
  virtual eoReturn Create(eoMessage &m);
  virtual eoChannelInfo* GetChannel(CHANNEL_TYPE type, uint8_t subFlag);

  virtual eoChannelInfo* GetOutChannel(CHANNEL_TYPE type, uint8_t subType);
  virtual eoChannelInfo* GetOutChannel(CHANNEL_TYPE type);
  virtual eoChannelInfo* GetOutChannel(uint8_t channelNumber);
  eoReturn SetDirection(HVCA_DIRECTION direction);
  virtual eoReturn SetDirection(SIMPLE_DIRECTION directionToSet);
  virtual void ClearValues();
};

#endif