From a3fb8b480e46139720be09b7351f69a99290ff98 Mon Sep 17 00:00:00 2001 From: amatilda Date: Wed, 30 Oct 2024 23:31:41 +0300 Subject: [PATCH] fix basic maping and add new id for Thermostat --- .../zunoG2/cores/ZWSupport/ZWCCBasic.c | 11 +- .../zunoG2/cores/ZWSupport/ZWCCThermostat.c | 225 ++++++++++++------ .../zunoG2/cores/ZWSupport/ZWCCThermostat.h | 78 +----- .../zunoG2/cores/includes/ZUNO_Definitions.h | 34 ++- .../zunoG2/cores/includes/ZUNO_StaticData.h | 2 +- 5 files changed, 183 insertions(+), 167 deletions(-) diff --git a/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCBasic.c b/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCBasic.c index 2438ac81..51c0d3cb 100644 --- a/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCBasic.c +++ b/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCBasic.c @@ -92,7 +92,7 @@ void __zuno_BasicUniversalDimingStop(uint8_t channel) { break ; } } - +uint8_t __zuno_CCThermostatModeTobasicGet(size_t channel); void __zuno_BasicUniversalGetCurrentValueDurationTargetValue(uint8_t channel, uint8_t *current_value, uint8_t *duration_table_8, uint8_t *target_value) { size_t type; size_t currentValue; @@ -129,12 +129,9 @@ void __zuno_BasicUniversalGetCurrentValueDurationTargetValue(uint8_t channel, ui #endif default: switch (type) { - #if defined(WITH_CC_THERMOSTAT_MODE) || defined(WITH_CC_THERMOSTAT_SETPOINT) #if defined(WITH_CC_THERMOSTAT_MODE) || defined(WITH_CC_THERMOSTAT_SETPOINT) case ZUNO_THERMOSTAT_CHANNEL_NUMBER: - #endif - currentValue = __zuno_BasicUniversalGetter1P(channel); - currentValue = currentValue ? 0xFF : 0x00; + currentValue = __zuno_CCThermostatModeTobasicGet(channel); break; #endif default: @@ -159,7 +156,7 @@ void __zuno_BasicUniversalGetCurrentValueDurationTargetValue(uint8_t channel, ui } #ifdef WITH_CC_BASIC -size_t zuno_CCThermostatModeTobasic(size_t channel, size_t value); +uint8_t __zuno_CCThermostatModeTobasicSet(uint8_t channel, uint8_t value); int zuno_CCSoundSwitchBasicSet(size_t channel, size_t toneIdentifier, const ZUNOCommandHandlerOption_t *options); static int _basic_set(byte channel, const ZwBasicSetFrame_t *paket, const ZUNOCommandHandlerOption_t *options) { size_t value; @@ -178,7 +175,7 @@ static int _basic_set(byte channel, const ZwBasicSetFrame_t *paket, const ZUNOCo switch (type) { #if defined(WITH_CC_THERMOSTAT_MODE) || defined(WITH_CC_THERMOSTAT_SETPOINT) case ZUNO_THERMOSTAT_CHANNEL_NUMBER: - value = zuno_CCThermostatModeTobasic(channel, value); + value = __zuno_CCThermostatModeTobasicSet(channel, value); break; #endif #ifdef WITH_CC_SWITCH_BINARY diff --git a/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.c b/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.c index 98018cd9..9f3788b3 100644 --- a/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.c +++ b/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.c @@ -1,80 +1,161 @@ #include "Arduino.h" #include "ZWCCThermostat.h" #if defined(WITH_CC_THERMOSTAT_MODE) || defined(WITH_CC_THERMOSTAT_SETPOINT) + +static uint32_t _get_compresed_combi_value(uint8_t channel) +{ + return (ZUNO_CFG_CHANNEL(channel).params[0]); +} + +static uint32_t _get_mode_support_mask(uint8_t channel) +{ + uint32_t mask; + uint8_t sub_type; + uint8_t params1; + + sub_type = ZUNO_CFG_CHANNEL(channel).sub_type; + mask = ((sub_type & (THERMOSTAT_FLAGS_OFF|THERMOSTAT_FLAGS_HEAT|THERMOSTAT_FLAGS_COOL)) | ((sub_type & (THERMOSTAT_FLAGS_FURNACE)) << 4)); + mask = mask | (((sub_type & (THERMOSTAT_FLAGS_DRY|THERMOSTAT_FLAGS_MOIST|THERMOSTAT_FLAGS_AUTO_CHANGEOVER)) << 0x4) | ((sub_type & (THERMOSTAT_FLAGS_FULL_POWER)) << 0x8)); + params1 = ZUNO_CFG_CHANNEL(channel).params[0x1]; + mask = mask | (((params1 << 0x8) << 0x3) & (THERMOSTAT_FLAGS_MASK_PARAM_01 << 0x3)); + return (mask); +} + +static bool _get_termostat_set_point_is_valid(uint8_t channel, uint8_t componentId) +{ + uint32_t support_mode_mask; + + support_mode_mask = _get_mode_support_mask(channel); + if ((support_mode_mask & (0x1 << componentId)) != 0x0) + return (true); + return (false); +} + +static uint32_t _get_termostat_set_point_support_mask_interpretation_a(uint8_t channel) +{ + uint32_t mask; + uint32_t mask_a; + + mask = _get_mode_support_mask(channel); + mask_a = (mask & ((0x1 << THERMOSTAT_MODE_FURNACE)|(0x1 << THERMOSTAT_MODE_DRY)|(0x1 << THERMOSTAT_MODE_MOIST)|(0x1 << THERMOSTAT_MODE_AUTO_CHANGEOVER)|(0x1 << THERMOSTAT_MODE_FULL_POWER)| + (0x1 << THERMOSTAT_MODE_ENERGY_SAVE_HEATING)|(0x1 << THERMOSTAT_MODE_ENERGY_SAVE_COOLING)|(0x1 << THERMOSTAT_MODE_AWAY_COOLING)|(0x1 << THERMOSTAT_MODE_AWAY_HEATING))) >> 0x4; + mask_a = mask_a | (mask & ((0x1 << THERMOSTAT_MODE_HEAT)|(0x1 << THERMOSTAT_MODE_COOL))); + return (mask_a); +} + +static uint32_t _get_termostat_mode_support_mask(uint8_t channel) +{ + uint32_t mask; + + mask = _get_mode_support_mask(channel); + if ((mask & ((0x1 << THERMOSTAT_MODE_AWAY_HEATING) | (0x1 << THERMOSTAT_MODE_AWAY_COOLING))) != 0x0) + mask = (mask & (~((0x1 << THERMOSTAT_MODE_AWAY_HEATING) | (0x1 << THERMOSTAT_MODE_AWAY_COOLING)))) | (0x1 << THERMOSTAT_MODE_AWAY_HEATING); + return (mask); +} + +static bool _termostat_mode_is_valid(uint8_t channel, uint8_t componentId) +{ + uint32_t support_mode_mask; + + support_mode_mask = _get_termostat_mode_support_mask(channel); + if ((support_mode_mask & (0x1 << componentId)) != 0x0) + return (true); + return (false); +} + static int _supported_report_mode(uint8_t channel, ZUNOCommandPacketReport_t *frame_report) {//Processed to get the value of the thermostatmode components - ZwThermostatModeSupportedReportFrame_t *lp; - uint8_t sub_type; + ZwThermostatModeSupportedReportFrame_t *report; + uint32_t support_mode_mask; + uint8_t len; - lp = (ZwThermostatModeSupportedReportFrame_t *)frame_report->info.packet.cmd; - sub_type = ZUNO_CFG_CHANNEL(channel).sub_type;//It contains a bitmask of thermostat + support_mode_mask = _get_termostat_mode_support_mask(channel); + report = (ZwThermostatModeSupportedReportFrame_t *)frame_report->info.packet.cmd; + len = ((((sizeof(support_mode_mask) * 0x8) - __builtin_clz(support_mode_mask)) >> 0x3) + 0x1); // lp->byte2.cmdClass = COMMAND_CLASS_THERMOSTAT_MODE; set in - fillOutgoingPacket // lp->byte2.cmd = THERMOSTAT_MODE_SUPPORTED_REPORT; set in - fillOutgoingPacket - lp->byte2.bitMask1 = (sub_type & 0x07) | ((sub_type & 0x08) << 4); - sub_type >>= 4; - lp->byte2.bitMask2 = (sub_type & 0x07) | ((sub_type & 0x08) << 4); - frame_report->info.packet.len = sizeof(lp->byte2); + memcpy(&report->bitMask[0x0], &support_mode_mask, len); + frame_report->info.packet.len = sizeof(report[0x0]) + len; return (ZUNO_COMMAND_ANSWERED); } -static size_t _bitTestComponentId(size_t channel, size_t componentId) { - size_t offset; +static const uint8_t _termostat_mode_basic_null[] = {THERMOSTAT_MODE_OFF, THERMOSTAT_MODE_ENERGY_SAVE_HEATING, THERMOSTAT_MODE_ENERGY_SAVE_COOLING, THERMOSTAT_MODE_AWAY_HEATING}; +static const uint8_t _termostat_mode_basic[] = {THERMOSTAT_MODE_HEAT, THERMOSTAT_MODE_COOL}; - switch (componentId) { - case THERMOSTAT_MODE_OFF: - offset = THERMOSTAT_FLAGS_OFF; - break ; - case THERMOSTAT_MODE_HEAT: - offset = THERMOSTAT_FLAGS_HEAT; - break ; - case THERMOSTAT_MODE_COOL: - offset = THERMOSTAT_FLAGS_COOL; - break ; - case THERMOSTAT_MODE_FURNACE: - offset = THERMOSTAT_FLAGS_FURNACE; - break ; - case THERMOSTAT_MODE_DRY: - offset = THERMOSTAT_FLAGS_DRY; - break ; - case THERMOSTAT_MODE_MOIST: - offset = THERMOSTAT_FLAGS_MOIST; - break ; - case THERMOSTAT_MODE_AUTO_CHANGEOVER: - offset = THERMOSTAT_FLAGS_AUTO_CHANGEOVER; - break ; - #if THERMOSTAT_MODE_AUTO_CHANGEOVER != THERMOSTAT_MODE_AUTO - case THERMOSTAT_MODE_AUTO: - offset = THERMOSTAT_FLAGS_AUTO; - break ; - #endif - case THERMOSTAT_MODE_FULL_POWER: - offset = THERMOSTAT_FLAGS_FULL_POWER; - break ; - default: - return (false); - break ; +static int8_t _termostat_mode_basic_set(const uint8_t *array, size_t lenght, uint32_t support_mode_mask) { + size_t i; + + i = 0x0; + while (i < lenght) + { + if ((support_mode_mask & (0x1 << array[i])) != 0x0) + return (array[i]); + i++; } - if ((ZUNO_CFG_CHANNEL(channel).sub_type & offset) != 0x0) - return (true); - return (false); + return (-1); } -size_t zuno_CCThermostatModeTobasic(size_t channel, size_t value) { - if (value == 0x0) - return (0x0); - value = THERMOSTAT_MODE_HEAT; - while (value <= THERMOSTAT_MODE_FULL_POWER) { - if (_bitTestComponentId(channel, value) == true) - return (value); - value++; +static uint8_t __zuno_CCThermostatModeTobasicSet_any(uint32_t support_mode_mask, int8_t id_cmp, uint8_t id_default) { + int8_t id_find; + + id_find = 0x0; + while (support_mode_mask != 0x0) { + if ((support_mode_mask & 0x1) != 0x0) { + if (id_cmp != id_find) + return (id_find); + } + support_mode_mask = support_mode_mask >> 0x1; + id_find++; } - return (0x0); + return (id_default); +} + +static uint8_t __zuno_CCThermostatModeTobasicSet_null(uint32_t support_mode_mask) { + int8_t id_null; + int8_t id_ff; + + if ((id_null = _termostat_mode_basic_set(&_termostat_mode_basic_null[0x0], (sizeof(_termostat_mode_basic_null) / sizeof(_termostat_mode_basic_null[0x0])), support_mode_mask)) >= 0x0) + return (id_null); + id_ff = _termostat_mode_basic_set(&_termostat_mode_basic[0x0], (sizeof(_termostat_mode_basic) / sizeof(_termostat_mode_basic[0x0])), support_mode_mask); + return (__zuno_CCThermostatModeTobasicSet_any(support_mode_mask, id_ff, _termostat_mode_basic_null[0x0])); +} + +static uint8_t __zuno_CCThermostatModeTobasicSet_ff(uint32_t support_mode_mask) { + int8_t id_null; + int8_t id_ff; + + if ((id_ff = _termostat_mode_basic_set(&_termostat_mode_basic[0x0], (sizeof(_termostat_mode_basic) / sizeof(_termostat_mode_basic[0x0])), support_mode_mask)) >= 0x0) + return (id_ff); + id_null = __zuno_CCThermostatModeTobasicSet_null(support_mode_mask); + return (__zuno_CCThermostatModeTobasicSet_any(support_mode_mask, id_null, _termostat_mode_basic[0x0])); +} + +uint8_t __zuno_CCThermostatModeTobasicSet(uint8_t channel, uint8_t value) { + uint32_t support_mode_mask; + + support_mode_mask = _get_termostat_mode_support_mask(channel); + if (value == 0x00) + return (__zuno_CCThermostatModeTobasicSet_null(support_mode_mask)); + return (__zuno_CCThermostatModeTobasicSet_ff(support_mode_mask)); +} + +uint8_t __zuno_CCThermostatModeTobasicGet(size_t channel) { + uint8_t value; + uint32_t support_mode_mask; + + value = zuno_universalGetter1P(channel); + support_mode_mask = _get_termostat_mode_support_mask(channel); + if (__zuno_CCThermostatModeTobasicSet_null(support_mode_mask) == value) + return (0x0); + if (__zuno_CCThermostatModeTobasicSet_ff(support_mode_mask) == value) + return (0xFF); + return (0xFE); } static int _set_mode(size_t channel, const ZwThermostatModeSetFrame_t *cmd) { - size_t componentId; + uint8_t componentId; componentId = cmd->v2.level & THERMOSTAT_MASK_4_BIT; - if (_bitTestComponentId(channel, componentId) == false) + if (_termostat_mode_is_valid(channel, componentId) == false) return (ZUNO_COMMAND_BLOCKED_FAILL); zuno_universalSetter1P(channel, componentId); zunoSendReport(channel + 1); @@ -114,16 +195,17 @@ int zuno_CCThermostatModeHandler(uint8_t channel, const ZUNOCommandCmd_t *cmd, Z } static int _supported_report_setpoint(uint8_t channel, ZUNOCommandPacketReport_t *frame_report) {//Processed to get the value of the thermostatmode components - ZwThermostatSetpointSupportedReportFrame_t *lp; - uint8_t sub_type; + ZwThermostatSetpointSupportedReportFrame_t *report; + uint32_t support_mode_mask; + uint8_t len; - lp = (ZwThermostatSetpointSupportedReportFrame_t *)frame_report->info.packet.cmd; - sub_type = ZUNO_CFG_CHANNEL(channel).sub_type;//It contains a bitmask of thermostat + support_mode_mask = _get_termostat_set_point_support_mask_interpretation_a(channel); + report = (ZwThermostatSetpointSupportedReportFrame_t *)frame_report->info.packet.cmd; // lp->byte2.cmdClass = COMMAND_CLASS_THERMOSTAT_SETPOINT; set in - fillOutgoingPacket // lp->byte2.cmd = THERMOSTAT_SETPOINT_SUPPORTED_REPORT; set in - fillOutgoingPacket - lp->byte2.bitMask1 = sub_type & 0x7E; - lp->byte2.bitMask2 = (sub_type >> 7) << 3;//This field MUST be encoded according to Table 142, interpretation A: - frame_report->info.packet.len = sizeof(lp->byte2); + len = ((((sizeof(support_mode_mask) * 0x8) - __builtin_clz(support_mode_mask)) >> 0x3) + 0x1); + memcpy(&report->bitMask[0x0], &support_mode_mask, len); + frame_report->info.packet.len = sizeof(report[0x0]) + len; return (ZUNO_COMMAND_ANSWERED); } @@ -168,11 +250,11 @@ static int _setpoint_get(size_t channel, const ZwThermostatSetpointGetFrame_t * componentId = componentId & THERMOSTAT_MASK_4_BIT;//Setpoint Type (4 bits) report->cmdClass = COMMAND_CLASS_THERMOSTAT_SETPOINT; report->cmd = THERMOSTAT_SETPOINT_REPORT; - if (_bitTestComponentId(channel, componentId) == true) { + if (_get_termostat_set_point_is_valid(channel, componentId) == true) { report->level = componentId; report->level2 = THERMOSTAT_SETPOINT_PARAMETR(THERMOSTAT_SETPOINT_SIZE, THERMOSTAT_SETPOINT_SCALE(channel), THERMOSTAT_SETPOINT_PRECISION); out = zuno_universalGetter2P(channel, componentId); - out = _limit_setpoint(ZUNO_CFG_CHANNEL(channel).params[0], out); + out = _limit_setpoint(_get_compresed_combi_value(channel), out); report->value[0x0] = (uint8_t)(out >> (sizeof(out) * 8 / 2)); report->value[0x1] = (uint8_t)(out & 0xFF); count = THERMOSTAT_SETPOINT_SIZE; @@ -189,18 +271,15 @@ static int _setpoint_get(size_t channel, const ZwThermostatSetpointGetFrame_t * static int _set_setpoint(uint8_t channel, const ZUNOCommandCmd_t *cmd) { ZwThermostatSetpointSetFrame_t *lp; - size_t sub_type; uint16_t value; lp = (ZwThermostatSetpointSetFrame_t *)cmd->cmd; - sub_type = ZUNO_CFG_CHANNEL(channel).sub_type;//It contains a bitmask of thermostat - sub_type = (sub_type & 0x7E) | ((sub_type >> 7) << 3);//This field MUST be encoded according to Table 142, interpretation A: - if ((sub_type & (0x1 << (lp->byte1.level & THERMOSTAT_SETPOINT_SET_LEVEL_SETPOINT_TYPE_MASK))) == 0x0) + if (_get_termostat_set_point_is_valid(channel, (lp->byte1.level & THERMOSTAT_SETPOINT_SET_LEVEL_SETPOINT_TYPE_MASK)) == false) return (ZUNO_COMMAND_BLOCKED_FAILL); if ((lp->byte1.level2 & (THERMOSTAT_SETPOINT_SET_LEVEL2_SIZE_MASK | THERMOSTAT_SETPOINT_SET_LEVEL2_SCALE_MASK)) != (THERMOSTAT_SETPOINT_SIZE | (THERMOSTAT_SETPOINT_SCALE(channel) << THERMOSTAT_SETPOINT_SET_LEVEL2_SCALE_SHIFT))) return (ZUNO_COMMAND_BLOCKED_FAILL); value = lp->byte2.value2 | (lp->byte2.value1 << (sizeof(value) * 8 / 2)); - value =_limit_setpoint(ZUNO_CFG_CHANNEL(channel).params[0], value); + value =_limit_setpoint(_get_compresed_combi_value(channel), value); zuno_universalSetter2P(channel, lp->byte2.level & THERMOSTAT_MASK_4_BIT, value); return (ZUNO_COMMAND_PROCESSED); } @@ -218,8 +297,8 @@ static int _setpoint_capabilities_get(size_t channel, const ZwThermostatSetpoint data = &report->data[0x0]; int16_t up_limit; int16_t down_limit; - _get_limits_setpoint(ZUNO_CFG_CHANNEL(channel).params[0], down_limit, up_limit); - if (_bitTestComponentId(channel, componentId) == true) { + _get_limits_setpoint(_get_compresed_combi_value(channel), down_limit, up_limit); + if (_get_termostat_set_point_is_valid(channel, componentId) == true) { report->properties1 = componentId; data[0] = THERMOSTAT_SETPOINT_PARAMETR(THERMOSTAT_SETPOINT_SIZE, THERMOSTAT_SETPOINT_SCALE(channel), THERMOSTAT_SETPOINT_PRECISION); data[1] = down_limit >> 8; diff --git a/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.h b/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.h index 7c454f42..a04d936d 100644 --- a/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.h +++ b/hardware/arduino/zunoG2/cores/ZWSupport/ZWCCThermostat.h @@ -211,46 +211,11 @@ /************************************************************/ /* Thermostat Mode Supported Report V3 command class structs */ /************************************************************/ -typedef struct ZwThermostatModeSupportedReport1ByteFrame_s +typedef struct ZwThermostatModeSupportedReportFrame_s { uint8_t cmdClass;/* The command class */ uint8_t cmd;/* The command */ - uint8_t bitMask1; -} ZwThermostatModeSupportedReport1ByteFrame_t; - -typedef struct ZwThermostatModeSupportedReport2ByteFrame_s -{ - uint8_t cmdClass;/* The command class */ - uint8_t cmd;/* The command */ - uint8_t bitMask1;/* MSB */ - uint8_t bitMask2;/* LSB */ -} ZwThermostatModeSupportedReport2ByteFrame_t; - -typedef struct ZwThermostatModeSupportedReport3ByteFrame_s -{ - uint8_t cmdClass;/* The command class */ - uint8_t cmd;/* The command */ - uint8_t bitMask1;/* MSB */ - uint8_t bitMask2; - uint8_t bitMask3;/* LSB */ -} ZwThermostatModeSupportedReport3ByteFrame_t; - -typedef struct ZwThermostatModeSupportedReport4ByteFrame_s -{ - uint8_t cmdClass;/* The command class */ - uint8_t cmd;/* The command */ - uint8_t bitMask1;/* MSB */ - uint8_t bitMask2; - uint8_t bitMask3; - uint8_t bitMask4;/* LSB */ -} ZwThermostatModeSupportedReport4ByteFrame_t; - -typedef union ZwThermostatModeSupportedReportFrame_u -{ - ZwThermostatModeSupportedReport1ByteFrame_t byte1; - ZwThermostatModeSupportedReport2ByteFrame_t byte2; - ZwThermostatModeSupportedReport3ByteFrame_t byte3; - ZwThermostatModeSupportedReport4ByteFrame_t byte4; + uint8_t bitMask[]; } ZwThermostatModeSupportedReportFrame_t; @@ -391,46 +356,11 @@ typedef union ZwThermostatModeSetFrame_u /************************************************************/ /* Thermostat Setpoint Supported Report V3 command class structs */ /************************************************************/ -typedef struct ZwThermostatSetpointSupportedReport1ByteFrame_s +typedef struct ZwThermostatSetpointSupportedReportFrame_s { uint8_t cmdClass;/* The command class */ uint8_t cmd;/* The command */ - uint8_t bitMask1; -} ZwThermostatSetpointSupportedReport1ByteFrame_t; - -typedef struct ZwThermostatSetpointSupportedReport2ByteFrame_s -{ - uint8_t cmdClass;/* The command class */ - uint8_t cmd;/* The command */ - uint8_t bitMask1;/* MSB */ - uint8_t bitMask2;/* LSB */ -} ZwThermostatSetpointSupportedReport2ByteFrame_t; - -typedef struct ZwThermostatSetpointSupportedReport3ByteFrame_s -{ - uint8_t cmdClass;/* The command class */ - uint8_t cmd;/* The command */ - uint8_t bitMask1;/* MSB */ - uint8_t bitMask2; - uint8_t bitMask3;/* LSB */ -} ZwThermostatSetpointSupportedReport3ByteFrame_t; - -typedef struct ZwThermostatSetpointSupportedReport4ByteFrame_s -{ - uint8_t cmdClass;/* The command class */ - uint8_t cmd;/* The command */ - uint8_t bitMask1;/* MSB */ - uint8_t bitMask2; - uint8_t bitMask3; - uint8_t bitMask4;/* LSB */ -} ZwThermostatSetpointSupportedReport4ByteFrame_t; - -typedef union ZwThermostatSetpointSupportedReportFrame_u -{ - ZwThermostatSetpointSupportedReport1ByteFrame_t byte1; - ZwThermostatSetpointSupportedReport2ByteFrame_t byte2; - ZwThermostatSetpointSupportedReport3ByteFrame_t byte3; - ZwThermostatSetpointSupportedReport4ByteFrame_t byte4; + uint8_t bitMask[]; } ZwThermostatSetpointSupportedReportFrame_t; diff --git a/hardware/arduino/zunoG2/cores/includes/ZUNO_Definitions.h b/hardware/arduino/zunoG2/cores/includes/ZUNO_Definitions.h index 098b2c92..cfce1526 100644 --- a/hardware/arduino/zunoG2/cores/includes/ZUNO_Definitions.h +++ b/hardware/arduino/zunoG2/cores/includes/ZUNO_Definitions.h @@ -900,17 +900,27 @@ typedef struct ZunoMeterTblHistoryValue_s #define THERMOSTAT_FLAGS_AUTO_CHANGEOVER 0x40 #define THERMOSTAT_FLAGS_AUTO THERMOSTAT_FLAGS_AUTO_CHANGEOVER #define THERMOSTAT_FLAGS_FULL_POWER 0x80 - - -#define THERMOSTAT_MODE_OFF 0x00 -#define THERMOSTAT_MODE_HEAT 0x01 -#define THERMOSTAT_MODE_COOL 0x02 -#define THERMOSTAT_MODE_FURNACE 0x07 -#define THERMOSTAT_MODE_DRY 0x08 -#define THERMOSTAT_MODE_MOIST 0x09 -#define THERMOSTAT_MODE_AUTO_CHANGEOVER 0x0A -#define THERMOSTAT_MODE_AUTO THERMOSTAT_MODE_AUTO_CHANGEOVER -#define THERMOSTAT_MODE_FULL_POWER 0x0F +#define THERMOSTAT_FLAGS_MASK_SUB_TYPE (THERMOSTAT_FLAGS_OFF | THERMOSTAT_FLAGS_HEAT | THERMOSTAT_FLAGS_COOL | THERMOSTAT_FLAGS_FURNACE | THERMOSTAT_FLAGS_DRY | THERMOSTAT_FLAGS_MOIST | THERMOSTAT_FLAGS_AUTO_CHANGEOVER | THERMOSTAT_FLAGS_FULL_POWER) + +#define THERMOSTAT_FLAGS_ENERGY_SAVE_HEATING (0x1 << 0x8) +#define THERMOSTAT_FLAGS_ENERGY_SAVE_COOLING (0x1 << 0x9) +#define THERMOSTAT_FLAGS_AWAY_HEATING (0x1 << 0xA) +#define THERMOSTAT_FLAGS_AWAY_COOLING (0x1 << 0xB) +#define THERMOSTAT_FLAGS_MASK_PARAM_01 (THERMOSTAT_FLAGS_ENERGY_SAVE_HEATING | THERMOSTAT_FLAGS_ENERGY_SAVE_COOLING | THERMOSTAT_FLAGS_AWAY_HEATING | THERMOSTAT_FLAGS_AWAY_COOLING) + +#define THERMOSTAT_MODE_OFF 0x00 +#define THERMOSTAT_MODE_HEAT 0x01 +#define THERMOSTAT_MODE_COOL 0x02 +#define THERMOSTAT_MODE_FURNACE 0x07 +#define THERMOSTAT_MODE_DRY 0x08 +#define THERMOSTAT_MODE_MOIST 0x09 +#define THERMOSTAT_MODE_AUTO_CHANGEOVER 0x0A +#define THERMOSTAT_MODE_AUTO THERMOSTAT_MODE_AUTO_CHANGEOVER +#define THERMOSTAT_MODE_ENERGY_SAVE_HEATING 0x0B +#define THERMOSTAT_MODE_ENERGY_SAVE_COOLING 0x0C +#define THERMOSTAT_MODE_AWAY_HEATING 0x0D +#define THERMOSTAT_MODE_AWAY_COOLING 0x0E +#define THERMOSTAT_MODE_FULL_POWER 0x0F @@ -919,7 +929,7 @@ typedef struct ZunoMeterTblHistoryValue_s #define THERMOSTAT_RANGE_NEG 0x20 #define THERMOSTAT_RANGE_POS 0x40 #define THERMOSTAT_LIMITS_MASK 0x1F -#define THERMOSTAT_PROPERTIES_COMBINER(UNITS, POS_NEG, LIMITS) (UNITS | POS_NEG | (LIMITS & THERMOSTAT_LIMITS_MASK)) +#define THERMOSTAT_PROPERTIES_COMBINER(UNITS, POS_NEG, LIMITS, MODES) (UNITS | POS_NEG | (LIMITS & THERMOSTAT_LIMITS_MASK) | ((MODES) & THERMOSTAT_FLAGS_MASK_PARAM_01)) // Switch color #define SWITCH_COLOR_FLAGS_WARM_WHITE 0x01 #define SWITCH_COLOR_FLAGS_COLD_WHITE 0x02 diff --git a/hardware/arduino/zunoG2/cores/includes/ZUNO_StaticData.h b/hardware/arduino/zunoG2/cores/includes/ZUNO_StaticData.h index ba3d37e1..03eb2259 100644 --- a/hardware/arduino/zunoG2/cores/includes/ZUNO_StaticData.h +++ b/hardware/arduino/zunoG2/cores/includes/ZUNO_StaticData.h @@ -164,7 +164,7 @@ typedef struct _ZUNO_BASE_CC_DESCRIPTION #define ZUNO_BLINDS(GETTER, SETTER) {ZUNO_SWITCH_MULTILEVEL_CHANNEL_NUMBER, SPECIFIC_TYPE_CLASS_C_MOTOR_CONTROL, 0, (void*)GETTER, (void*)SETTER, (void*)0, (void*)0} #define ZUNO_SENSOR_BINARY(TYPE, GETTER) {ZUNO_SENSOR_BINARY_CHANNEL_NUMBER, TYPE, 0, (void*)GETTER, (void*)0, (void*)0, (void*)0} #define ZUNO_SENSOR_MULTILEVEL(TYPE, SCALE, SIZE, PRECISION, GETTER) {ZUNO_SENSOR_MULTILEVEL_CHANNEL_NUMBER, TYPE, SENSOR_MULTILEVEL_PROPERTIES_COMBINER(SCALE, SIZE, PRECISION), (void*)GETTER, MACRO_CAST_POINTER_TO_VOID(0), (void*)0, (void*)0} -#define ZUNO_THERMOSTAT(MODES, UNITS, NEG_POS, LIMITS, GETTER1, SETTER1, GETTER2, SETTER2 ) {ZUNO_THERMOSTAT_CHANNEL_NUMBER, MODES, THERMOSTAT_PROPERTIES_COMBINER(UNITS, NEG_POS, LIMITS), (void*) GETTER1, (void*) SETTER1, (void*) GETTER2, (void*) SETTER2} +#define ZUNO_THERMOSTAT(MODES, UNITS, NEG_POS, LIMITS, GETTER1, SETTER1, GETTER2, SETTER2) {ZUNO_THERMOSTAT_CHANNEL_NUMBER, ((MODES) & THERMOSTAT_FLAGS_MASK_SUB_TYPE), THERMOSTAT_PROPERTIES_COMBINER(UNITS, NEG_POS, LIMITS, MODES), (void*) GETTER1, (void*) SETTER1, (void*) GETTER2, (void*) SETTER2} #define ZUNO_SWITCH_COLOR(COLORS, GETTER, SETTER) {ZUNO_SWITCH_COLOR_CHANNEL_NUMBER, COLORS, 0, (void*)GETTER, (void*)SETTER, (void*)0, (void*)0} #define ZUNO_SWITCH_COLORB(COLORS, GETTER, SETTER, BRIGHTNESS_GETTER, BRIGHTNESS_SETTER) {ZUNO_SWITCH_COLOR_CHANNEL_NUMBER, COLORS, 0, (void*)GETTER, (void*)SETTER, (void*)BRIGHTNESS_GETTER, (void*)BRIGHTNESS_SETTER} #define ZUNO_DOORLOCK(GETTER, SETTER) {ZUNO_DOORLOCK_CHANNEL_NUMBER, 0x0, 0x1, (void*)GETTER, (void*)SETTER, (void*)0, (void*)0}