diff --git a/tasmota/xdrv_23_zigbee_0_constants.ino b/tasmota/xdrv_23_zigbee_0_constants.ino
index c042ee0f8..1d797528c 100644
--- a/tasmota/xdrv_23_zigbee_0_constants.ino
+++ b/tasmota/xdrv_23_zigbee_0_constants.ino
@@ -1123,6 +1123,7 @@ enum ZCL_Global_Commands {
#define ZF(s) static const char ZS_ ## s[] PROGMEM = #s;
#define Z(s) ZS_ ## s
+#define Z_(s) Zo_ ## s
// ZDP Enumeration, see Zigbee spec 2.4.5
String getZDPStatusMessage(uint8_t status) {
diff --git a/tasmota/xdrv_23_zigbee_5__constants.ino b/tasmota/xdrv_23_zigbee_5__constants.ino
new file mode 100644
index 000000000..42aa3237a
--- /dev/null
+++ b/tasmota/xdrv_23_zigbee_5__constants.ino
@@ -0,0 +1,831 @@
+/*
+ xdrv_23_zigbee_5__constants.ino - zigbee support for Tasmota
+
+ Copyright (C) 2020 Theo Arends and Stephan Hadinger
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifdef USE_ZIGBEE
+
+// Below is a compilation of Strings used in Zigbee commands and converters.
+// Instead of using pointer to strings (4 bytes), we are using an offset (16 bits)
+// into an array of strings - which leads to a 1/3 more compact structure.
+
+// To generate the code below use https://tasmota.hadinger.fr/util
+// and copy/paste the entire arrays `Z_PostProcess` and `Z_Commands` concatenated
+// Note: the 'C' syntax is irrelevant, the parser only looks for `Z_()`
+
+// In addition the Python3 code used is below:
+
+/*Python code to generate code below
+
+import re
+pat = r"Z\(([^\)]+)\)" # extract text in Z() macro
+
+def clean(s):
+ return s.strip(" \t\n\r")
+
+def strings_to_pmem(arg):
+ #strings = arg.split("\n")
+ strings = re.findall(pat, arg)
+
+ # do some basic cleaning
+ strings_cleaned = [ clean(x) for x in strings if clean(x) != ""]
+
+ # remove duplicates
+ strings_cleaned = list(dict.fromkeys(strings_cleaned))
+
+ out_s = "const char Z_strings[] PROGMEM = \n"
+ out_i = "enum Z_offsets {\n"
+
+ index = 0;
+ # add a first empty string
+ out_s += " \"\\x00\"\n"
+ out_i += " Zo_ = " + str(index) + ",\n"
+ index += 1
+
+ for s in strings_cleaned:
+ out_s += " \"" + s + "\" \"\\x00\"\n"
+ out_i += " Zo_" + s + " = " + str(index) + ",\n"
+ index += len(s) + 1 # add one for null char
+
+ out_s += " \"\\x00\";"
+ out_i += "};"
+
+ return ("", out_s, out_i)
+
+
+*/
+
+/*
+ DO NOT EDIT
+*/
+
+const char Z_strings[] PROGMEM =
+ "\x00"
+ "ZCLVersion" "\x00"
+ "AppVersion" "\x00"
+ "StackVersion" "\x00"
+ "HWVersion" "\x00"
+ "Manufacturer" "\x00"
+ "ModelId" "\x00"
+ "DateCode" "\x00"
+ "PowerSource" "\x00"
+ "GenericDeviceClass" "\x00"
+ "GenericDeviceType" "\x00"
+ "ProductCode" "\x00"
+ "ProductURL" "\x00"
+ "SWBuildID" "\x00"
+ "MainsVoltage" "\x00"
+ "MainsFrequency" "\x00"
+ "BatteryVoltage" "\x00"
+ "BatteryPercentage" "\x00"
+ "CurrentTemperature" "\x00"
+ "MinTempExperienced" "\x00"
+ "MaxTempExperienced" "\x00"
+ "OverTempTotalDwell" "\x00"
+ "IdentifyTime" "\x00"
+ "GroupNameSupport" "\x00"
+ "SceneCount" "\x00"
+ "CurrentScene" "\x00"
+ "CurrentGroup" "\x00"
+ "SceneValid" "\x00"
+ "NameSupport" "\x00"
+ "Power" "\x00"
+ "StartUpOnOff" "\x00"
+ "SwitchType" "\x00"
+ "Dimmer" "\x00"
+ "DimmerOptions" "\x00"
+ "DimmerRemainingTime" "\x00"
+ "OnOffTransitionTime" "\x00"
+ "OnLevel" "\x00"
+ "OnTransitionTime" "\x00"
+ "OffTransitionTime" "\x00"
+ "DefaultMoveRate" "\x00"
+ "AlarmCount" "\x00"
+ "Time" "\x00"
+ "TimeStatus" "\x00"
+ "TimeZone" "\x00"
+ "DstStart" "\x00"
+ "DstEnd" "\x00"
+ "DstShift" "\x00"
+ "StandardTime" "\x00"
+ "LocalTime" "\x00"
+ "LastSetTime" "\x00"
+ "ValidUntilTime" "\x00"
+ "TimeEpoch" "\x00"
+ "LocationType" "\x00"
+ "LocationMethod" "\x00"
+ "LocationAge" "\x00"
+ "QualityMeasure" "\x00"
+ "NumberOfDevices" "\x00"
+ "AnalogInActiveText" "\x00"
+ "AnalogInDescription" "\x00"
+ "AnalogInInactiveText" "\x00"
+ "AnalogInMaxValue" "\x00"
+ "AnalogInMinValue" "\x00"
+ "AnalogInOutOfService" "\x00"
+ "AqaraRotate" "\x00"
+ "AnalogInPriorityArray" "\x00"
+ "AnalogInReliability" "\x00"
+ "AnalogInRelinquishDefault" "\x00"
+ "AnalogInResolution" "\x00"
+ "AnalogInStatusFlags" "\x00"
+ "AnalogInEngineeringUnits" "\x00"
+ "AnalogInApplicationType" "\x00"
+ "Aqara_FF05" "\x00"
+ "AnalogOutDescription" "\x00"
+ "AnalogOutMaxValue" "\x00"
+ "AnalogOutMinValue" "\x00"
+ "AnalogOutOutOfService" "\x00"
+ "AnalogOutValue" "\x00"
+ "AnalogOutPriorityArray" "\x00"
+ "AnalogOutReliability" "\x00"
+ "AnalogOutRelinquishDefault" "\x00"
+ "AnalogOutResolution" "\x00"
+ "AnalogOutStatusFlags" "\x00"
+ "AnalogOutEngineeringUnits" "\x00"
+ "AnalogOutApplicationType" "\x00"
+ "AnalogDescription" "\x00"
+ "AnalogOutOfService" "\x00"
+ "AnalogValue" "\x00"
+ "AnalogPriorityArray" "\x00"
+ "AnalogReliability" "\x00"
+ "AnalogRelinquishDefault" "\x00"
+ "AnalogStatusFlags" "\x00"
+ "AnalogEngineeringUnits" "\x00"
+ "AnalogApplicationType" "\x00"
+ "BinaryInActiveText" "\x00"
+ "BinaryInDescription" "\x00"
+ "BinaryInInactiveText" "\x00"
+ "BinaryInOutOfService" "\x00"
+ "BinaryInPolarity" "\x00"
+ "BinaryInValue" "\x00"
+ "BinaryInPriorityArray" "\x00"
+ "BinaryInReliability" "\x00"
+ "BinaryInStatusFlags" "\x00"
+ "BinaryInApplicationType" "\x00"
+ "BinaryOutActiveText" "\x00"
+ "BinaryOutDescription" "\x00"
+ "BinaryOutInactiveText" "\x00"
+ "BinaryOutMinimumOffTime" "\x00"
+ "BinaryOutMinimumOnTime" "\x00"
+ "BinaryOutOutOfService" "\x00"
+ "BinaryOutPolarity" "\x00"
+ "BinaryOutValue" "\x00"
+ "BinaryOutPriorityArray" "\x00"
+ "BinaryOutReliability" "\x00"
+ "BinaryOutRelinquishDefault" "\x00"
+ "BinaryOutStatusFlags" "\x00"
+ "BinaryOutApplicationType" "\x00"
+ "BinaryActiveText" "\x00"
+ "BinaryDescription" "\x00"
+ "BinaryInactiveText" "\x00"
+ "BinaryMinimumOffTime" "\x00"
+ "BinaryMinimumOnTime" "\x00"
+ "BinaryOutOfService" "\x00"
+ "BinaryValue" "\x00"
+ "BinaryPriorityArray" "\x00"
+ "BinaryReliability" "\x00"
+ "BinaryRelinquishDefault" "\x00"
+ "BinaryStatusFlags" "\x00"
+ "BinaryApplicationType" "\x00"
+ "MultiInStateText" "\x00"
+ "MultiInDescription" "\x00"
+ "MultiInNumberOfStates" "\x00"
+ "MultiInOutOfService" "\x00"
+ "MultiInValue" "\x00"
+ "MultiInReliability" "\x00"
+ "MultiInStatusFlags" "\x00"
+ "MultiInApplicationType" "\x00"
+ "MultiOutStateText" "\x00"
+ "MultiOutDescription" "\x00"
+ "MultiOutNumberOfStates" "\x00"
+ "MultiOutOutOfService" "\x00"
+ "MultiOutValue" "\x00"
+ "MultiOutPriorityArray" "\x00"
+ "MultiOutReliability" "\x00"
+ "MultiOutRelinquishDefault" "\x00"
+ "MultiOutStatusFlags" "\x00"
+ "MultiOutApplicationType" "\x00"
+ "MultiStateText" "\x00"
+ "MultiDescription" "\x00"
+ "MultiNumberOfStates" "\x00"
+ "MultiOutOfService" "\x00"
+ "MultiValue" "\x00"
+ "MultiReliability" "\x00"
+ "MultiRelinquishDefault" "\x00"
+ "MultiStatusFlags" "\x00"
+ "MultiApplicationType" "\x00"
+ "TotalProfileNum" "\x00"
+ "MultipleScheduling" "\x00"
+ "EnergyFormatting" "\x00"
+ "EnergyRemote" "\x00"
+ "ScheduleMode" "\x00"
+ "CheckinInterval" "\x00"
+ "LongPollInterval" "\x00"
+ "ShortPollInterval" "\x00"
+ "FastPollTimeout" "\x00"
+ "CheckinIntervalMin" "\x00"
+ "LongPollIntervalMin" "\x00"
+ "FastPollTimeoutMax" "\x00"
+ "PhysicalClosedLimit" "\x00"
+ "MotorStepSize" "\x00"
+ "Status" "\x00"
+ "ClosedLimit" "\x00"
+ "Mode" "\x00"
+ "LockState" "\x00"
+ "LockType" "\x00"
+ "ActuatorEnabled" "\x00"
+ "DoorState" "\x00"
+ "DoorOpenEvents" "\x00"
+ "DoorClosedEvents" "\x00"
+ "OpenPeriod" "\x00"
+ "AqaraVibrationMode" "\x00"
+ "AqaraVibrationsOrAngle" "\x00"
+ "AqaraVibration505" "\x00"
+ "AqaraAccelerometer" "\x00"
+ "WindowCoveringType" "\x00"
+ "PhysicalClosedLimitLift" "\x00"
+ "PhysicalClosedLimitTilt" "\x00"
+ "CurrentPositionLift" "\x00"
+ "CurrentPositionTilt" "\x00"
+ "NumberofActuationsLift" "\x00"
+ "NumberofActuationsTilt" "\x00"
+ "ConfigStatus" "\x00"
+ "CurrentPositionLiftPercentage" "\x00"
+ "CurrentPositionTiltPercentage" "\x00"
+ "InstalledOpenLimitLift" "\x00"
+ "InstalledClosedLimitLift" "\x00"
+ "InstalledOpenLimitTilt" "\x00"
+ "InstalledClosedLimitTilt" "\x00"
+ "VelocityLift" "\x00"
+ "AccelerationTimeLift" "\x00"
+ "DecelerationTimeLift" "\x00"
+ "IntermediateSetpointsLift" "\x00"
+ "IntermediateSetpointsTilt" "\x00"
+ "Hue" "\x00"
+ "Sat" "\x00"
+ "RemainingTime" "\x00"
+ "X" "\x00"
+ "Y" "\x00"
+ "DriftCompensation" "\x00"
+ "CompensationText" "\x00"
+ "CT" "\x00"
+ "ColorMode" "\x00"
+ "NumberOfPrimaries" "\x00"
+ "Primary1X" "\x00"
+ "Primary1Y" "\x00"
+ "Primary1Intensity" "\x00"
+ "Primary2X" "\x00"
+ "Primary2Y" "\x00"
+ "Primary2Intensity" "\x00"
+ "Primary3X" "\x00"
+ "Primary3Y" "\x00"
+ "Primary3Intensity" "\x00"
+ "WhitePointX" "\x00"
+ "WhitePointY" "\x00"
+ "ColorPointRX" "\x00"
+ "ColorPointRY" "\x00"
+ "ColorPointRIntensity" "\x00"
+ "ColorPointGX" "\x00"
+ "ColorPointGY" "\x00"
+ "ColorPointGIntensity" "\x00"
+ "ColorPointBX" "\x00"
+ "ColorPointBY" "\x00"
+ "ColorPointBIntensity" "\x00"
+ "Illuminance" "\x00"
+ "IlluminanceMinMeasuredValue" "\x00"
+ "IlluminanceMaxMeasuredValue" "\x00"
+ "IlluminanceTolerance" "\x00"
+ "IlluminanceLightSensorType" "\x00"
+ "IlluminanceLevelStatus" "\x00"
+ "IlluminanceTargetLevel" "\x00"
+ "Temperature" "\x00"
+ "TemperatureMinMeasuredValue" "\x00"
+ "TemperatureMaxMeasuredValue" "\x00"
+ "TemperatureTolerance" "\x00"
+ "PressureUnit" "\x00"
+ "Pressure" "\x00"
+ "PressureMinMeasuredValue" "\x00"
+ "PressureMaxMeasuredValue" "\x00"
+ "PressureTolerance" "\x00"
+ "PressureScaledValue" "\x00"
+ "PressureMinScaledValue" "\x00"
+ "PressureMaxScaledValue" "\x00"
+ "PressureScaledTolerance" "\x00"
+ "PressureScale" "\x00"
+ "FlowRate" "\x00"
+ "FlowMinMeasuredValue" "\x00"
+ "FlowMaxMeasuredValue" "\x00"
+ "FlowTolerance" "\x00"
+ "Humidity" "\x00"
+ "HumidityMinMeasuredValue" "\x00"
+ "HumidityMaxMeasuredValue" "\x00"
+ "HumidityTolerance" "\x00"
+ "Occupancy" "\x00"
+ "OccupancySensorType" "\x00"
+ "ZoneState" "\x00"
+ "ZoneType" "\x00"
+ "ZoneStatus" "\x00"
+ "CompanyName" "\x00"
+ "MeterTypeID" "\x00"
+ "DataQualityID" "\x00"
+ "CustomerName" "\x00"
+ "Model" "\x00"
+ "PartNumber" "\x00"
+ "ProductRevision" "\x00"
+ "SoftwareRevision" "\x00"
+ "UtilityName" "\x00"
+ "POD" "\x00"
+ "AvailablePower" "\x00"
+ "PowerThreshold" "\x00"
+ "NumberOfResets" "\x00"
+ "PersistentMemoryWrites" "\x00"
+ "LastMessageLQI" "\x00"
+ "LastMessageRSSI" "\x00"
+ "Identify" "\x00"
+ "xxxx" "\x00"
+ "IdentifyQuery" "\x00"
+ "AddGroup" "\x00"
+ "xxxx00" "\x00"
+ "ViewGroup" "\x00"
+ "GetGroup" "\x00"
+ "01xxxx" "\x00"
+ "GetAllGroups" "\x00"
+ "00" "\x00"
+ "RemoveGroup" "\x00"
+ "RemoveAllGroups" "\x00"
+ "ViewScene" "\x00"
+ "xxxxyy" "\x00"
+ "RemoveScene" "\x00"
+ "RemoveAllScenes" "\x00"
+ "RecallScene" "\x00"
+ "GetSceneMembership" "\x00"
+ "PowerOffEffect" "\x00"
+ "xxyy" "\x00"
+ "PowerOnRecall" "\x00"
+ "PowerOnTimer" "\x00"
+ "xxyyyyzzzz" "\x00"
+ "xx0A00" "\x00"
+ "DimmerUp" "\x00"
+ "00190200" "\x00"
+ "DimmerDown" "\x00"
+ "01190200" "\x00"
+ "DimmerStop" "\x00"
+ "ResetAlarm" "\x00"
+ "xxyyyy" "\x00"
+ "ResetAllAlarms" "\x00"
+ "xx000A00" "\x00"
+ "HueSat" "\x00"
+ "xxyy0A00" "\x00"
+ "Color" "\x00"
+ "xxxxyyyy0A00" "\x00"
+ "xxxx0A00" "\x00"
+ "ShutterOpen" "\x00"
+ "ShutterClose" "\x00"
+ "ShutterStop" "\x00"
+ "ShutterLift" "\x00"
+ "xx" "\x00"
+ "ShutterTilt" "\x00"
+ "Shutter" "\x00"
+ "DimmerMove" "\x00"
+ "xx0A" "\x00"
+ "DimmerStepUp" "\x00"
+ "00xx0A00" "\x00"
+ "DimmerStepDown" "\x00"
+ "01xx0A00" "\x00"
+ "DimmerStep" "\x00"
+ "xx190A00" "\x00"
+ "01" "\x00"
+ "HueMove" "\x00"
+ "xx19" "\x00"
+ "HueStepUp" "\x00"
+ "HueStepDown" "\x00"
+ "03xx0A00" "\x00"
+ "HueStep" "\x00"
+ "SatMove" "\x00"
+ "SatStep" "\x00"
+ "xx190A" "\x00"
+ "ColorMove" "\x00"
+ "xxxxyyyy" "\x00"
+ "ColorStep" "\x00"
+ "ColorTempMoveUp" "\x00"
+ "01xxxx000000000000" "\x00"
+ "ColorTempMoveDown" "\x00"
+ "03xxxx000000000000" "\x00"
+ "ColorTempMoveStop" "\x00"
+ "00xxxx000000000000" "\x00"
+ "ColorTempMove" "\x00"
+ "xxyyyy000000000000" "\x00"
+ "ColorTempStepUp" "\x00"
+ "01xxxx0A0000000000" "\x00"
+ "ColorTempStepDown" "\x00"
+ "03xxxx0A0000000000" "\x00"
+ "ColorTempStep" "\x00"
+ "xxyyyy0A0000000000" "\x00"
+ "ArrowClick" "\x00"
+ "ArrowHold" "\x00"
+ "ArrowRelease" "\x00"
+ "ZoneStatusChange" "\x00"
+ "xxxxyyzz" "\x00"
+ "xxyyzzzz" "\x00"
+ "AddScene" "\x00"
+ "xxyyyyzz" "\x00"
+ "StoreScene" "\x00"
+ "\x00";
+
+
+enum Z_offsets {
+ Zo_ = 0,
+ Zo_ZCLVersion = 1,
+ Zo_AppVersion = 12,
+ Zo_StackVersion = 23,
+ Zo_HWVersion = 36,
+ Zo_Manufacturer = 46,
+ Zo_ModelId = 59,
+ Zo_DateCode = 67,
+ Zo_PowerSource = 76,
+ Zo_GenericDeviceClass = 88,
+ Zo_GenericDeviceType = 107,
+ Zo_ProductCode = 125,
+ Zo_ProductURL = 137,
+ Zo_SWBuildID = 148,
+ Zo_MainsVoltage = 158,
+ Zo_MainsFrequency = 171,
+ Zo_BatteryVoltage = 186,
+ Zo_BatteryPercentage = 201,
+ Zo_CurrentTemperature = 219,
+ Zo_MinTempExperienced = 238,
+ Zo_MaxTempExperienced = 257,
+ Zo_OverTempTotalDwell = 276,
+ Zo_IdentifyTime = 295,
+ Zo_GroupNameSupport = 308,
+ Zo_SceneCount = 325,
+ Zo_CurrentScene = 336,
+ Zo_CurrentGroup = 349,
+ Zo_SceneValid = 362,
+ Zo_NameSupport = 373,
+ Zo_Power = 385,
+ Zo_StartUpOnOff = 391,
+ Zo_SwitchType = 404,
+ Zo_Dimmer = 415,
+ Zo_DimmerOptions = 422,
+ Zo_DimmerRemainingTime = 436,
+ Zo_OnOffTransitionTime = 456,
+ Zo_OnLevel = 476,
+ Zo_OnTransitionTime = 484,
+ Zo_OffTransitionTime = 501,
+ Zo_DefaultMoveRate = 519,
+ Zo_AlarmCount = 535,
+ Zo_Time = 546,
+ Zo_TimeStatus = 551,
+ Zo_TimeZone = 562,
+ Zo_DstStart = 571,
+ Zo_DstEnd = 580,
+ Zo_DstShift = 587,
+ Zo_StandardTime = 596,
+ Zo_LocalTime = 609,
+ Zo_LastSetTime = 619,
+ Zo_ValidUntilTime = 631,
+ Zo_TimeEpoch = 646,
+ Zo_LocationType = 656,
+ Zo_LocationMethod = 669,
+ Zo_LocationAge = 684,
+ Zo_QualityMeasure = 696,
+ Zo_NumberOfDevices = 711,
+ Zo_AnalogInActiveText = 727,
+ Zo_AnalogInDescription = 746,
+ Zo_AnalogInInactiveText = 766,
+ Zo_AnalogInMaxValue = 787,
+ Zo_AnalogInMinValue = 804,
+ Zo_AnalogInOutOfService = 821,
+ Zo_AqaraRotate = 842,
+ Zo_AnalogInPriorityArray = 854,
+ Zo_AnalogInReliability = 876,
+ Zo_AnalogInRelinquishDefault = 896,
+ Zo_AnalogInResolution = 922,
+ Zo_AnalogInStatusFlags = 941,
+ Zo_AnalogInEngineeringUnits = 961,
+ Zo_AnalogInApplicationType = 986,
+ Zo_Aqara_FF05 = 1010,
+ Zo_AnalogOutDescription = 1021,
+ Zo_AnalogOutMaxValue = 1042,
+ Zo_AnalogOutMinValue = 1060,
+ Zo_AnalogOutOutOfService = 1078,
+ Zo_AnalogOutValue = 1100,
+ Zo_AnalogOutPriorityArray = 1115,
+ Zo_AnalogOutReliability = 1138,
+ Zo_AnalogOutRelinquishDefault = 1159,
+ Zo_AnalogOutResolution = 1186,
+ Zo_AnalogOutStatusFlags = 1206,
+ Zo_AnalogOutEngineeringUnits = 1227,
+ Zo_AnalogOutApplicationType = 1253,
+ Zo_AnalogDescription = 1278,
+ Zo_AnalogOutOfService = 1296,
+ Zo_AnalogValue = 1315,
+ Zo_AnalogPriorityArray = 1327,
+ Zo_AnalogReliability = 1347,
+ Zo_AnalogRelinquishDefault = 1365,
+ Zo_AnalogStatusFlags = 1389,
+ Zo_AnalogEngineeringUnits = 1407,
+ Zo_AnalogApplicationType = 1430,
+ Zo_BinaryInActiveText = 1452,
+ Zo_BinaryInDescription = 1471,
+ Zo_BinaryInInactiveText = 1491,
+ Zo_BinaryInOutOfService = 1512,
+ Zo_BinaryInPolarity = 1533,
+ Zo_BinaryInValue = 1550,
+ Zo_BinaryInPriorityArray = 1564,
+ Zo_BinaryInReliability = 1586,
+ Zo_BinaryInStatusFlags = 1606,
+ Zo_BinaryInApplicationType = 1626,
+ Zo_BinaryOutActiveText = 1650,
+ Zo_BinaryOutDescription = 1670,
+ Zo_BinaryOutInactiveText = 1691,
+ Zo_BinaryOutMinimumOffTime = 1713,
+ Zo_BinaryOutMinimumOnTime = 1737,
+ Zo_BinaryOutOutOfService = 1760,
+ Zo_BinaryOutPolarity = 1782,
+ Zo_BinaryOutValue = 1800,
+ Zo_BinaryOutPriorityArray = 1815,
+ Zo_BinaryOutReliability = 1838,
+ Zo_BinaryOutRelinquishDefault = 1859,
+ Zo_BinaryOutStatusFlags = 1886,
+ Zo_BinaryOutApplicationType = 1907,
+ Zo_BinaryActiveText = 1932,
+ Zo_BinaryDescription = 1949,
+ Zo_BinaryInactiveText = 1967,
+ Zo_BinaryMinimumOffTime = 1986,
+ Zo_BinaryMinimumOnTime = 2007,
+ Zo_BinaryOutOfService = 2027,
+ Zo_BinaryValue = 2046,
+ Zo_BinaryPriorityArray = 2058,
+ Zo_BinaryReliability = 2078,
+ Zo_BinaryRelinquishDefault = 2096,
+ Zo_BinaryStatusFlags = 2120,
+ Zo_BinaryApplicationType = 2138,
+ Zo_MultiInStateText = 2160,
+ Zo_MultiInDescription = 2177,
+ Zo_MultiInNumberOfStates = 2196,
+ Zo_MultiInOutOfService = 2218,
+ Zo_MultiInValue = 2238,
+ Zo_MultiInReliability = 2251,
+ Zo_MultiInStatusFlags = 2270,
+ Zo_MultiInApplicationType = 2289,
+ Zo_MultiOutStateText = 2312,
+ Zo_MultiOutDescription = 2330,
+ Zo_MultiOutNumberOfStates = 2350,
+ Zo_MultiOutOutOfService = 2373,
+ Zo_MultiOutValue = 2394,
+ Zo_MultiOutPriorityArray = 2408,
+ Zo_MultiOutReliability = 2430,
+ Zo_MultiOutRelinquishDefault = 2450,
+ Zo_MultiOutStatusFlags = 2476,
+ Zo_MultiOutApplicationType = 2496,
+ Zo_MultiStateText = 2520,
+ Zo_MultiDescription = 2535,
+ Zo_MultiNumberOfStates = 2552,
+ Zo_MultiOutOfService = 2572,
+ Zo_MultiValue = 2590,
+ Zo_MultiReliability = 2601,
+ Zo_MultiRelinquishDefault = 2618,
+ Zo_MultiStatusFlags = 2641,
+ Zo_MultiApplicationType = 2658,
+ Zo_TotalProfileNum = 2679,
+ Zo_MultipleScheduling = 2695,
+ Zo_EnergyFormatting = 2714,
+ Zo_EnergyRemote = 2731,
+ Zo_ScheduleMode = 2744,
+ Zo_CheckinInterval = 2757,
+ Zo_LongPollInterval = 2773,
+ Zo_ShortPollInterval = 2790,
+ Zo_FastPollTimeout = 2808,
+ Zo_CheckinIntervalMin = 2824,
+ Zo_LongPollIntervalMin = 2843,
+ Zo_FastPollTimeoutMax = 2863,
+ Zo_PhysicalClosedLimit = 2882,
+ Zo_MotorStepSize = 2902,
+ Zo_Status = 2916,
+ Zo_ClosedLimit = 2923,
+ Zo_Mode = 2935,
+ Zo_LockState = 2940,
+ Zo_LockType = 2950,
+ Zo_ActuatorEnabled = 2959,
+ Zo_DoorState = 2975,
+ Zo_DoorOpenEvents = 2985,
+ Zo_DoorClosedEvents = 3000,
+ Zo_OpenPeriod = 3017,
+ Zo_AqaraVibrationMode = 3028,
+ Zo_AqaraVibrationsOrAngle = 3047,
+ Zo_AqaraVibration505 = 3070,
+ Zo_AqaraAccelerometer = 3088,
+ Zo_WindowCoveringType = 3107,
+ Zo_PhysicalClosedLimitLift = 3126,
+ Zo_PhysicalClosedLimitTilt = 3150,
+ Zo_CurrentPositionLift = 3174,
+ Zo_CurrentPositionTilt = 3194,
+ Zo_NumberofActuationsLift = 3214,
+ Zo_NumberofActuationsTilt = 3237,
+ Zo_ConfigStatus = 3260,
+ Zo_CurrentPositionLiftPercentage = 3273,
+ Zo_CurrentPositionTiltPercentage = 3303,
+ Zo_InstalledOpenLimitLift = 3333,
+ Zo_InstalledClosedLimitLift = 3356,
+ Zo_InstalledOpenLimitTilt = 3381,
+ Zo_InstalledClosedLimitTilt = 3404,
+ Zo_VelocityLift = 3429,
+ Zo_AccelerationTimeLift = 3442,
+ Zo_DecelerationTimeLift = 3463,
+ Zo_IntermediateSetpointsLift = 3484,
+ Zo_IntermediateSetpointsTilt = 3510,
+ Zo_Hue = 3536,
+ Zo_Sat = 3540,
+ Zo_RemainingTime = 3544,
+ Zo_X = 3558,
+ Zo_Y = 3560,
+ Zo_DriftCompensation = 3562,
+ Zo_CompensationText = 3580,
+ Zo_CT = 3597,
+ Zo_ColorMode = 3600,
+ Zo_NumberOfPrimaries = 3610,
+ Zo_Primary1X = 3628,
+ Zo_Primary1Y = 3638,
+ Zo_Primary1Intensity = 3648,
+ Zo_Primary2X = 3666,
+ Zo_Primary2Y = 3676,
+ Zo_Primary2Intensity = 3686,
+ Zo_Primary3X = 3704,
+ Zo_Primary3Y = 3714,
+ Zo_Primary3Intensity = 3724,
+ Zo_WhitePointX = 3742,
+ Zo_WhitePointY = 3754,
+ Zo_ColorPointRX = 3766,
+ Zo_ColorPointRY = 3779,
+ Zo_ColorPointRIntensity = 3792,
+ Zo_ColorPointGX = 3813,
+ Zo_ColorPointGY = 3826,
+ Zo_ColorPointGIntensity = 3839,
+ Zo_ColorPointBX = 3860,
+ Zo_ColorPointBY = 3873,
+ Zo_ColorPointBIntensity = 3886,
+ Zo_Illuminance = 3907,
+ Zo_IlluminanceMinMeasuredValue = 3919,
+ Zo_IlluminanceMaxMeasuredValue = 3947,
+ Zo_IlluminanceTolerance = 3975,
+ Zo_IlluminanceLightSensorType = 3996,
+ Zo_IlluminanceLevelStatus = 4023,
+ Zo_IlluminanceTargetLevel = 4046,
+ Zo_Temperature = 4069,
+ Zo_TemperatureMinMeasuredValue = 4081,
+ Zo_TemperatureMaxMeasuredValue = 4109,
+ Zo_TemperatureTolerance = 4137,
+ Zo_PressureUnit = 4158,
+ Zo_Pressure = 4171,
+ Zo_PressureMinMeasuredValue = 4180,
+ Zo_PressureMaxMeasuredValue = 4205,
+ Zo_PressureTolerance = 4230,
+ Zo_PressureScaledValue = 4248,
+ Zo_PressureMinScaledValue = 4268,
+ Zo_PressureMaxScaledValue = 4291,
+ Zo_PressureScaledTolerance = 4314,
+ Zo_PressureScale = 4338,
+ Zo_FlowRate = 4352,
+ Zo_FlowMinMeasuredValue = 4361,
+ Zo_FlowMaxMeasuredValue = 4382,
+ Zo_FlowTolerance = 4403,
+ Zo_Humidity = 4417,
+ Zo_HumidityMinMeasuredValue = 4426,
+ Zo_HumidityMaxMeasuredValue = 4451,
+ Zo_HumidityTolerance = 4476,
+ Zo_Occupancy = 4494,
+ Zo_OccupancySensorType = 4504,
+ Zo_ZoneState = 4524,
+ Zo_ZoneType = 4534,
+ Zo_ZoneStatus = 4543,
+ Zo_CompanyName = 4554,
+ Zo_MeterTypeID = 4566,
+ Zo_DataQualityID = 4578,
+ Zo_CustomerName = 4592,
+ Zo_Model = 4605,
+ Zo_PartNumber = 4611,
+ Zo_ProductRevision = 4622,
+ Zo_SoftwareRevision = 4638,
+ Zo_UtilityName = 4655,
+ Zo_POD = 4667,
+ Zo_AvailablePower = 4671,
+ Zo_PowerThreshold = 4686,
+ Zo_NumberOfResets = 4701,
+ Zo_PersistentMemoryWrites = 4716,
+ Zo_LastMessageLQI = 4739,
+ Zo_LastMessageRSSI = 4754,
+ Zo_Identify = 4770,
+ Zo_xxxx = 4779,
+ Zo_IdentifyQuery = 4784,
+ Zo_AddGroup = 4798,
+ Zo_xxxx00 = 4807,
+ Zo_ViewGroup = 4814,
+ Zo_GetGroup = 4824,
+ Zo_01xxxx = 4833,
+ Zo_GetAllGroups = 4840,
+ Zo_00 = 4853,
+ Zo_RemoveGroup = 4856,
+ Zo_RemoveAllGroups = 4868,
+ Zo_ViewScene = 4884,
+ Zo_xxxxyy = 4894,
+ Zo_RemoveScene = 4901,
+ Zo_RemoveAllScenes = 4913,
+ Zo_RecallScene = 4929,
+ Zo_GetSceneMembership = 4941,
+ Zo_PowerOffEffect = 4960,
+ Zo_xxyy = 4975,
+ Zo_PowerOnRecall = 4980,
+ Zo_PowerOnTimer = 4994,
+ Zo_xxyyyyzzzz = 5007,
+ Zo_xx0A00 = 5018,
+ Zo_DimmerUp = 5025,
+ Zo_00190200 = 5034,
+ Zo_DimmerDown = 5043,
+ Zo_01190200 = 5054,
+ Zo_DimmerStop = 5063,
+ Zo_ResetAlarm = 5074,
+ Zo_xxyyyy = 5085,
+ Zo_ResetAllAlarms = 5092,
+ Zo_xx000A00 = 5107,
+ Zo_HueSat = 5116,
+ Zo_xxyy0A00 = 5123,
+ Zo_Color = 5132,
+ Zo_xxxxyyyy0A00 = 5138,
+ Zo_xxxx0A00 = 5151,
+ Zo_ShutterOpen = 5160,
+ Zo_ShutterClose = 5172,
+ Zo_ShutterStop = 5185,
+ Zo_ShutterLift = 5197,
+ Zo_xx = 5209,
+ Zo_ShutterTilt = 5212,
+ Zo_Shutter = 5224,
+ Zo_DimmerMove = 5232,
+ Zo_xx0A = 5243,
+ Zo_DimmerStepUp = 5248,
+ Zo_00xx0A00 = 5261,
+ Zo_DimmerStepDown = 5270,
+ Zo_01xx0A00 = 5285,
+ Zo_DimmerStep = 5294,
+ Zo_xx190A00 = 5305,
+ Zo_01 = 5314,
+ Zo_HueMove = 5317,
+ Zo_xx19 = 5325,
+ Zo_HueStepUp = 5330,
+ Zo_HueStepDown = 5340,
+ Zo_03xx0A00 = 5352,
+ Zo_HueStep = 5361,
+ Zo_SatMove = 5369,
+ Zo_SatStep = 5377,
+ Zo_xx190A = 5385,
+ Zo_ColorMove = 5392,
+ Zo_xxxxyyyy = 5402,
+ Zo_ColorStep = 5411,
+ Zo_ColorTempMoveUp = 5421,
+ Zo_01xxxx000000000000 = 5437,
+ Zo_ColorTempMoveDown = 5456,
+ Zo_03xxxx000000000000 = 5474,
+ Zo_ColorTempMoveStop = 5493,
+ Zo_00xxxx000000000000 = 5511,
+ Zo_ColorTempMove = 5530,
+ Zo_xxyyyy000000000000 = 5544,
+ Zo_ColorTempStepUp = 5563,
+ Zo_01xxxx0A0000000000 = 5579,
+ Zo_ColorTempStepDown = 5598,
+ Zo_03xxxx0A0000000000 = 5616,
+ Zo_ColorTempStep = 5635,
+ Zo_xxyyyy0A0000000000 = 5649,
+ Zo_ArrowClick = 5668,
+ Zo_ArrowHold = 5679,
+ Zo_ArrowRelease = 5689,
+ Zo_ZoneStatusChange = 5702,
+ Zo_xxxxyyzz = 5719,
+ Zo_xxyyzzzz = 5728,
+ Zo_AddScene = 5737,
+ Zo_xxyyyyzz = 5746,
+ Zo_StoreScene = 5755,
+};
+
+
+/*
+ DO NOT EDIT
+*/
+
+
+#endif // USE_ZIGBEE
diff --git a/tasmota/xdrv_23_zigbee_5_converters.ino b/tasmota/xdrv_23_zigbee_5_converters.ino
index 421c3ae0a..3c1b6941a 100644
--- a/tasmota/xdrv_23_zigbee_5_converters.ino
+++ b/tasmota/xdrv_23_zigbee_5_converters.ino
@@ -98,7 +98,7 @@ typedef struct Z_AttributeConverter {
uint8_t type;
uint8_t cluster_short;
uint16_t attribute;
- const char * name;
+ uint16_t name_offset;
int8_t multiplier; // multiplier for numerical value, (if > 0 multiply by x, if <0 device by x)
uint8_t cb; // callback func from Z_ConvOperators
// Z_AttrConverter func;
@@ -141,470 +141,376 @@ enum Z_ConvOperators {
Z_BatteryPercentage, // memorize Battery Percentage in RAM
};
-ZF(ZCLVersion) ZF(AppVersion) ZF(StackVersion) ZF(HWVersion) ZF(Manufacturer) ZF(ModelId)
-ZF(GenericDeviceClass) ZF(GenericDeviceType) ZF(ProductCode) ZF(ProductURL)
-ZF(DateCode) ZF(PowerSource) ZF(SWBuildID) ZF(Power) ZF(SwitchType) ZF(Dimmer) ZF(DimmerOptions)
-ZF(DimmerRemainingTime) ZF(OnOffTransitionTime) ZF(StartUpOnOff)
-ZF(MainsVoltage) ZF(MainsFrequency) ZF(BatteryVoltage) ZF(BatteryPercentage)
-ZF(CurrentTemperature) ZF(MinTempExperienced) ZF(MaxTempExperienced) ZF(OverTempTotalDwell)
-ZF(IdentifyTime) ZF(GroupNameSupport)
-ZF(SceneCount) ZF(CurrentScene) ZF(CurrentGroup) ZF(SceneValid)
-ZF(AlarmCount) ZF(Time) ZF(TimeStatus) ZF(TimeZone) ZF(DstStart) ZF(DstEnd)
-ZF(DstShift) ZF(StandardTime) ZF(LocalTime) ZF(LastSetTime) ZF(ValidUntilTime) ZF(TimeEpoch)
-
-ZF(LocationType) ZF(LocationMethod) ZF(LocationAge) ZF(QualityMeasure) ZF(NumberOfDevices)
-
-ZF(AnalogInActiveText) ZF(AnalogInDescription) ZF(AnalogInInactiveText) ZF(AnalogInMaxValue)
-ZF(AnalogInMinValue) ZF(AnalogInOutOfService) ZF(AqaraRotate) ZF(AnalogInPriorityArray)
-ZF(AnalogInReliability) ZF(AnalogInRelinquishDefault) ZF(AnalogInResolution) ZF(AnalogInStatusFlags)
-ZF(AnalogInEngineeringUnits) ZF(AnalogInApplicationType) ZF(Aqara_FF05)
-
-ZF(AnalogOutDescription) ZF(AnalogOutMaxValue) ZF(AnalogOutMinValue) ZF(AnalogOutOutOfService)
-ZF(AnalogOutValue) ZF(AnalogOutPriorityArray) ZF(AnalogOutReliability) ZF(AnalogOutRelinquishDefault)
-ZF(AnalogOutResolution) ZF(AnalogOutStatusFlags) ZF(AnalogOutEngineeringUnits) ZF(AnalogOutApplicationType)
-
-ZF(AnalogDescription) ZF(AnalogOutOfService) ZF(AnalogValue) ZF(AnalogPriorityArray) ZF(AnalogReliability)
-ZF(AnalogRelinquishDefault) ZF(AnalogStatusFlags) ZF(AnalogEngineeringUnits) ZF(AnalogApplicationType)
-
-ZF(BinaryInActiveText) ZF(BinaryInDescription) ZF(BinaryInInactiveText) ZF(BinaryInOutOfService)
-ZF(BinaryInPolarity) ZF(BinaryInValue) ZF(BinaryInPriorityArray) ZF(BinaryInReliability)
-ZF(BinaryInStatusFlags) ZF(BinaryInApplicationType)
-
-ZF(BinaryOutActiveText) ZF(BinaryOutDescription) ZF(BinaryOutInactiveText) ZF(BinaryOutMinimumOffTime)
-ZF(BinaryOutMinimumOnTime) ZF(BinaryOutOutOfService) ZF(BinaryOutPolarity) ZF(BinaryOutValue)
-ZF(BinaryOutPriorityArray) ZF(BinaryOutReliability) ZF(BinaryOutRelinquishDefault) ZF(BinaryOutStatusFlags)
-ZF(BinaryOutApplicationType)
-
-ZF(BinaryActiveText) ZF(BinaryDescription) ZF(BinaryInactiveText) ZF(BinaryMinimumOffTime)
-ZF(BinaryMinimumOnTime) ZF(BinaryOutOfService) ZF(BinaryValue) ZF(BinaryPriorityArray) ZF(BinaryReliability)
-ZF(BinaryRelinquishDefault) ZF(BinaryStatusFlags) ZF(BinaryApplicationType)
-
-ZF(MultiInStateText) ZF(MultiInDescription) ZF(MultiInNumberOfStates) ZF(MultiInOutOfService)
-ZF(MultiInValue) ZF(MultiInReliability) ZF(MultiInStatusFlags) ZF(MultiInApplicationType)
-
-ZF(MultiOutStateText) ZF(MultiOutDescription) ZF(MultiOutNumberOfStates) ZF(MultiOutOutOfService)
-ZF(MultiOutValue) ZF(MultiOutPriorityArray) ZF(MultiOutReliability) ZF(MultiOutRelinquishDefault)
-ZF(MultiOutStatusFlags) ZF(MultiOutApplicationType)
-
-ZF(MultiStateText) ZF(MultiDescription) ZF(MultiNumberOfStates) ZF(MultiOutOfService) ZF(MultiValue)
-ZF(MultiReliability) ZF(MultiRelinquishDefault) ZF(MultiStatusFlags) ZF(MultiApplicationType)
-
-ZF(TotalProfileNum) ZF(MultipleScheduling) ZF(EnergyFormatting) ZF(EnergyRemote) ZF(ScheduleMode)
-
-ZF(CheckinInterval) ZF(LongPollInterval) ZF(ShortPollInterval) ZF(FastPollTimeout) ZF(CheckinIntervalMin)
-ZF(LongPollIntervalMin) ZF(FastPollTimeoutMax)
-
-ZF(PhysicalClosedLimit) ZF(MotorStepSize) ZF(Status) ZF(ClosedLimit) ZF(Mode)
-
-ZF(LockState) ZF(LockType) ZF(ActuatorEnabled) ZF(DoorState) ZF(DoorOpenEvents)
-ZF(DoorClosedEvents) ZF(OpenPeriod)
-
-ZF(AqaraVibrationMode) ZF(AqaraVibrationsOrAngle) ZF(AqaraVibration505) ZF(AqaraAccelerometer)
-
-ZF(WindowCoveringType) ZF(PhysicalClosedLimitLift) ZF(PhysicalClosedLimitTilt) ZF(CurrentPositionLift)
-ZF(CurrentPositionTilt) ZF(NumberofActuationsLift) ZF(NumberofActuationsTilt) ZF(ConfigStatus)
-ZF(CurrentPositionLiftPercentage) ZF(CurrentPositionTiltPercentage) ZF(InstalledOpenLimitLift)
-ZF(InstalledClosedLimitLift) ZF(InstalledOpenLimitTilt) ZF(InstalledClosedLimitTilt) ZF(VelocityLift)
-ZF(AccelerationTimeLift) ZF(DecelerationTimeLift) ZF(IntermediateSetpointsLift)
-ZF(IntermediateSetpointsTilt)
-
-ZF(Hue) ZF(Sat) ZF(RemainingTime) ZF(X) ZF(Y) ZF(DriftCompensation) ZF(CompensationText) ZF(CT)
-ZF(ColorMode) ZF(NumberOfPrimaries) ZF(Primary1X) ZF(Primary1Y) ZF(Primary1Intensity) ZF(Primary2X)
-ZF(Primary2Y) ZF(Primary2Intensity) ZF(Primary3X) ZF(Primary3Y) ZF(Primary3Intensity) ZF(WhitePointX)
-ZF(WhitePointY) ZF(ColorPointRX) ZF(ColorPointRY) ZF(ColorPointRIntensity) ZF(ColorPointGX) ZF(ColorPointGY)
-ZF(ColorPointGIntensity) ZF(ColorPointBX) ZF(ColorPointBY) ZF(ColorPointBIntensity)
-
-ZF(Illuminance) ZF(IlluminanceMinMeasuredValue) ZF(IlluminanceMaxMeasuredValue) ZF(IlluminanceTolerance)
-ZF(IlluminanceLightSensorType) ZF(IlluminanceLevelStatus) ZF(IlluminanceTargetLevel)
-
-ZF(Temperature) ZF(TemperatureMinMeasuredValue) ZF(TemperatureMaxMeasuredValue) ZF(TemperatureTolerance)
-
-ZF(PressureUnit) ZF(Pressure) ZF(PressureMinMeasuredValue) ZF(PressureMaxMeasuredValue) ZF(PressureTolerance)
-ZF(PressureScaledValue) ZF(PressureMinScaledValue) ZF(PressureMaxScaledValue) ZF(PressureScaledTolerance)
-ZF(PressureScale)
-
-ZF(FlowRate) ZF(FlowMinMeasuredValue) ZF(FlowMaxMeasuredValue) ZF(FlowTolerance)
-
-ZF(Humidity) ZF(HumidityMinMeasuredValue) ZF(HumidityMaxMeasuredValue) ZF(HumidityTolerance)
-
-ZF(Occupancy) ZF(OccupancySensorType)
-
-ZF(ZoneState) ZF(ZoneType) ZF(ZoneStatus)
-
-ZF(CompanyName) ZF(MeterTypeID) ZF(DataQualityID) ZF(CustomerName) ZF(Model) ZF(PartNumber)
-ZF(SoftwareRevision) ZF(POD) ZF(AvailablePower) ZF(PowerThreshold) ZF(ProductRevision) ZF(UtilityName)
-
-ZF(NumberOfResets) ZF(PersistentMemoryWrites) ZF(LastMessageLQI) ZF(LastMessageRSSI)
// list of post-processing directives
const Z_AttributeConverter Z_PostProcess[] PROGMEM = {
- { Zuint8, Cx0000, 0x0000, Z(ZCLVersion), 1, Z_Nop },
- { Zuint8, Cx0000, 0x0001, Z(AppVersion), 1, Z_Nop },
- { Zuint8, Cx0000, 0x0002, Z(StackVersion), 1, Z_Nop },
- { Zuint8, Cx0000, 0x0003, Z(HWVersion), 1, Z_Nop },
- { Zstring, Cx0000, 0x0004, Z(Manufacturer), 1, Z_ManufKeep }, // record Manufacturer
- { Zstring, Cx0000, 0x0005, Z(ModelId), 1, Z_ModelKeep }, // record Model
- { Zstring, Cx0000, 0x0006, Z(DateCode), 1, Z_Nop },
- { Zenum8, Cx0000, 0x0007, Z(PowerSource), 1, Z_Nop },
- { Zenum8, Cx0000, 0x0008, Z(GenericDeviceClass), 1, Z_Nop },
- { Zenum8, Cx0000, 0x0009, Z(GenericDeviceType), 1, Z_Nop },
- { Zoctstr, Cx0000, 0x000A, Z(ProductCode), 1, Z_Nop },
- { Zstring, Cx0000, 0x000B, Z(ProductURL), 1, Z_Nop },
- { Zstring, Cx0000, 0x4000, Z(SWBuildID), 1, Z_Nop },
+ { Zuint8, Cx0000, 0x0000, Z_(ZCLVersion), 1, Z_Nop },
+ { Zuint8, Cx0000, 0x0001, Z_(AppVersion), 1, Z_Nop },
+ { Zuint8, Cx0000, 0x0002, Z_(StackVersion), 1, Z_Nop },
+ { Zuint8, Cx0000, 0x0003, Z_(HWVersion), 1, Z_Nop },
+ { Zstring, Cx0000, 0x0004, Z_(Manufacturer), 1, Z_ManufKeep }, // record Manufacturer
+ { Zstring, Cx0000, 0x0005, Z_(ModelId), 1, Z_ModelKeep }, // record Model
+ { Zstring, Cx0000, 0x0006, Z_(DateCode), 1, Z_Nop },
+ { Zenum8, Cx0000, 0x0007, Z_(PowerSource), 1, Z_Nop },
+ { Zenum8, Cx0000, 0x0008, Z_(GenericDeviceClass), 1, Z_Nop },
+ { Zenum8, Cx0000, 0x0009, Z_(GenericDeviceType), 1, Z_Nop },
+ { Zoctstr, Cx0000, 0x000A, Z_(ProductCode), 1, Z_Nop },
+ { Zstring, Cx0000, 0x000B, Z_(ProductURL), 1, Z_Nop },
+ { Zstring, Cx0000, 0x4000, Z_(SWBuildID), 1, Z_Nop },
// { Zunk, Cx0000, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other values
// Cmd 0x0A - Cluster 0x0000, attribute 0xFF01 - proprietary
- { Zmap8, Cx0000, 0xFF01, nullptr, 0, Z_AqaraSensor }, // Occupancy (map8)
+ { Zmap8, Cx0000, 0xFF01, Z_(), 0, Z_AqaraSensor }, // Occupancy (map8)
// Power Configuration cluster
- { Zuint16, Cx0001, 0x0000, Z(MainsVoltage), 1, Z_Nop },
- { Zuint8, Cx0001, 0x0001, Z(MainsFrequency), 1, Z_Nop },
- { Zuint8, Cx0001, 0x0020, Z(BatteryVoltage), -10,Z_Nop }, // divide by 10
- { Zuint8, Cx0001, 0x0021, Z(BatteryPercentage), -2, Z_BatteryPercentage }, // divide by 2
+ { Zuint16, Cx0001, 0x0000, Z_(MainsVoltage), 1, Z_Nop },
+ { Zuint8, Cx0001, 0x0001, Z_(MainsFrequency), 1, Z_Nop },
+ { Zuint8, Cx0001, 0x0020, Z_(BatteryVoltage), -10,Z_Nop }, // divide by 10
+ { Zuint8, Cx0001, 0x0021, Z_(BatteryPercentage), -2, Z_BatteryPercentage }, // divide by 2
// Device Temperature Configuration cluster
- { Zint16, Cx0002, 0x0000, Z(CurrentTemperature), 1, Z_Nop },
- { Zint16, Cx0002, 0x0001, Z(MinTempExperienced), 1, Z_Nop },
- { Zint16, Cx0002, 0x0002, Z(MaxTempExperienced), 1, Z_Nop },
- { Zuint16, Cx0002, 0x0003, Z(OverTempTotalDwell), 1, Z_Nop },
+ { Zint16, Cx0002, 0x0000, Z_(CurrentTemperature), 1, Z_Nop },
+ { Zint16, Cx0002, 0x0001, Z_(MinTempExperienced), 1, Z_Nop },
+ { Zint16, Cx0002, 0x0002, Z_(MaxTempExperienced), 1, Z_Nop },
+ { Zuint16, Cx0002, 0x0003, Z_(OverTempTotalDwell), 1, Z_Nop },
// Identify cluster
- { Zuint16, Cx0003, 0x0000, Z(IdentifyTime), 1, Z_Nop },
+ { Zuint16, Cx0003, 0x0000, Z_(IdentifyTime), 1, Z_Nop },
// Groups cluster
- { Zmap8, Cx0004, 0x0000, Z(GroupNameSupport), 1, Z_Nop },
+ { Zmap8, Cx0004, 0x0000, Z_(GroupNameSupport), 1, Z_Nop },
// Scenes cluster
- { Zuint8, Cx0005, 0x0000, Z(SceneCount), 1, Z_Nop },
- { Zuint8, Cx0005, 0x0001, Z(CurrentScene), 1, Z_Nop },
- { Zuint16, Cx0005, 0x0002, Z(CurrentGroup), 1, Z_Nop },
- { Zbool, Cx0005, 0x0003, Z(SceneValid), 1, Z_Nop },
- //{ Zmap8, Cx0005, 0x0004, Z(NameSupport), 1, Z_Nop },
+ { Zuint8, Cx0005, 0x0000, Z_(SceneCount), 1, Z_Nop },
+ { Zuint8, Cx0005, 0x0001, Z_(CurrentScene), 1, Z_Nop },
+ { Zuint16, Cx0005, 0x0002, Z_(CurrentGroup), 1, Z_Nop },
+ { Zbool, Cx0005, 0x0003, Z_(SceneValid), 1, Z_Nop },
+ //{ Zmap8, Cx0005, 0x0004, Z_(NameSupport), 1, Z_Nop },
// On/off cluster
- { Zbool, Cx0006, 0x0000, Z(Power), 1, Z_Nop },
- { Zenum8, Cx0006, 0x4003, Z(StartUpOnOff), 1, Z_Nop },
- { Zbool, Cx0006, 0x8000, Z(Power), 1, Z_Nop }, // See 7280
+ { Zbool, Cx0006, 0x0000, Z_(Power), 1, Z_Nop },
+ { Zenum8, Cx0006, 0x4003, Z_(StartUpOnOff), 1, Z_Nop },
+ { Zbool, Cx0006, 0x8000, Z_(Power), 1, Z_Nop }, // See 7280
// On/Off Switch Configuration cluster
- { Zenum8, Cx0007, 0x0000, Z(SwitchType), 1, Z_Nop },
+ { Zenum8, Cx0007, 0x0000, Z_(SwitchType), 1, Z_Nop },
// Level Control cluster
- { Zuint8, Cx0008, 0x0000, Z(Dimmer), 1, Z_Nop },
- { Zmap8, Cx0008, 0x000F, Z(DimmerOptions), 1, Z_Nop },
- { Zuint16, Cx0008, 0x0001, Z(DimmerRemainingTime), 1, Z_Nop },
- { Zuint16, Cx0008, 0x0010, Z(OnOffTransitionTime), 1, Z_Nop },
- // { Zuint8, Cx0008, 0x0011, Z(OnLevel), 1, Z_Nop },
- // { Zuint16, Cx0008, 0x0012, Z(OnTransitionTime), 1, Z_Nop },
- // { Zuint16, Cx0008, 0x0013, Z(OffTransitionTime), 1, Z_Nop },
- // { Zuint16, Cx0008, 0x0014, Z(DefaultMoveRate), 1, Z_Nop },
+ { Zuint8, Cx0008, 0x0000, Z_(Dimmer), 1, Z_Nop },
+ { Zmap8, Cx0008, 0x000F, Z_(DimmerOptions), 1, Z_Nop },
+ { Zuint16, Cx0008, 0x0001, Z_(DimmerRemainingTime), 1, Z_Nop },
+ { Zuint16, Cx0008, 0x0010, Z_(OnOffTransitionTime), 1, Z_Nop },
+ // { Zuint8, Cx0008, 0x0011, Z_(OnLevel), 1, Z_Nop },
+ // { Zuint16, Cx0008, 0x0012, Z_(OnTransitionTime), 1, Z_Nop },
+ // { Zuint16, Cx0008, 0x0013, Z_(OffTransitionTime), 1, Z_Nop },
+ // { Zuint16, Cx0008, 0x0014, Z_(DefaultMoveRate), 1, Z_Nop },
// Alarms cluster
- { Zuint16, Cx0009, 0x0000, Z(AlarmCount), 1, Z_Nop },
+ { Zuint16, Cx0009, 0x0000, Z_(AlarmCount), 1, Z_Nop },
// Time cluster
- { ZUTC, Cx000A, 0x0000, Z(Time), 1, Z_Nop },
- { Zmap8, Cx000A, 0x0001, Z(TimeStatus), 1, Z_Nop },
- { Zint32, Cx000A, 0x0002, Z(TimeZone), 1, Z_Nop },
- { Zuint32, Cx000A, 0x0003, Z(DstStart), 1, Z_Nop },
- { Zuint32, Cx000A, 0x0004, Z(DstEnd), 1, Z_Nop },
- { Zint32, Cx000A, 0x0005, Z(DstShift), 1, Z_Nop },
- { Zuint32, Cx000A, 0x0006, Z(StandardTime), 1, Z_Nop },
- { Zuint32, Cx000A, 0x0007, Z(LocalTime), 1, Z_Nop },
- { ZUTC, Cx000A, 0x0008, Z(LastSetTime), 1, Z_Nop },
- { ZUTC, Cx000A, 0x0009, Z(ValidUntilTime), 1, Z_Nop },
- { ZUTC, Cx000A, 0xFF00, Z(TimeEpoch), 1, Z_Nop }, // Tasmota specific, epoch
+ { ZUTC, Cx000A, 0x0000, Z_(Time), 1, Z_Nop },
+ { Zmap8, Cx000A, 0x0001, Z_(TimeStatus), 1, Z_Nop },
+ { Zint32, Cx000A, 0x0002, Z_(TimeZone), 1, Z_Nop },
+ { Zuint32, Cx000A, 0x0003, Z_(DstStart), 1, Z_Nop },
+ { Zuint32, Cx000A, 0x0004, Z_(DstEnd), 1, Z_Nop },
+ { Zint32, Cx000A, 0x0005, Z_(DstShift), 1, Z_Nop },
+ { Zuint32, Cx000A, 0x0006, Z_(StandardTime), 1, Z_Nop },
+ { Zuint32, Cx000A, 0x0007, Z_(LocalTime), 1, Z_Nop },
+ { ZUTC, Cx000A, 0x0008, Z_(LastSetTime), 1, Z_Nop },
+ { ZUTC, Cx000A, 0x0009, Z_(ValidUntilTime), 1, Z_Nop },
+ { ZUTC, Cx000A, 0xFF00, Z_(TimeEpoch), 1, Z_Nop }, // Tasmota specific, epoch
// RSSI Location cluster
- { Zdata8, Cx000B, 0x0000, Z(LocationType), 1, Z_Nop },
- { Zenum8, Cx000B, 0x0001, Z(LocationMethod), 1, Z_Nop },
- { Zuint16, Cx000B, 0x0002, Z(LocationAge), 1, Z_Nop },
- { Zuint8, Cx000B, 0x0003, Z(QualityMeasure), 1, Z_Nop },
- { Zuint8, Cx000B, 0x0004, Z(NumberOfDevices), 1, Z_Nop },
+ { Zdata8, Cx000B, 0x0000, Z_(LocationType), 1, Z_Nop },
+ { Zenum8, Cx000B, 0x0001, Z_(LocationMethod), 1, Z_Nop },
+ { Zuint16, Cx000B, 0x0002, Z_(LocationAge), 1, Z_Nop },
+ { Zuint8, Cx000B, 0x0003, Z_(QualityMeasure), 1, Z_Nop },
+ { Zuint8, Cx000B, 0x0004, Z_(NumberOfDevices), 1, Z_Nop },
// Analog Input cluster
- // { 0xFF, Cx000C, 0x0004, Z(AnalogInActiveText), 1, Z_Nop },
- { Zstring, Cx000C, 0x001C, Z(AnalogInDescription), 1, Z_Nop },
- // { 0xFF, Cx000C, 0x002E, Z(AnalogInInactiveText), 1, Z_Nop },
- { Zsingle, Cx000C, 0x0041, Z(AnalogInMaxValue), 1, Z_Nop },
- { Zsingle, Cx000C, 0x0045, Z(AnalogInMinValue), 1, Z_Nop },
- { Zbool, Cx000C, 0x0051, Z(AnalogInOutOfService), 1, Z_Nop },
- { Zsingle, Cx000C, 0x0055, Z(AqaraRotate), 1, Z_Nop },
- // { 0xFF, Cx000C, 0x0057, Z(AnalogInPriorityArray),1, Z_Nop },
- { Zenum8, Cx000C, 0x0067, Z(AnalogInReliability), 1, Z_Nop },
- // { 0xFF, Cx000C, 0x0068, Z(AnalogInRelinquishDefault),1, Z_Nop },
- { Zsingle, Cx000C, 0x006A, Z(AnalogInResolution), 1, Z_Nop },
- { Zmap8, Cx000C, 0x006F, Z(AnalogInStatusFlags), 1, Z_Nop },
- { Zenum16, Cx000C, 0x0075, Z(AnalogInEngineeringUnits),1, Z_Nop },
- { Zuint32, Cx000C, 0x0100, Z(AnalogInApplicationType),1, Z_Nop },
- { Zuint16, Cx000C, 0xFF05, Z(Aqara_FF05), 1, Z_Nop },
+ // { 0xFF, Cx000C, 0x0004, Z_(AnalogInActiveText), 1, Z_Nop },
+ { Zstring, Cx000C, 0x001C, Z_(AnalogInDescription), 1, Z_Nop },
+ // { 0xFF, Cx000C, 0x002E, Z_(AnalogInInactiveText), 1, Z_Nop },
+ { Zsingle, Cx000C, 0x0041, Z_(AnalogInMaxValue), 1, Z_Nop },
+ { Zsingle, Cx000C, 0x0045, Z_(AnalogInMinValue), 1, Z_Nop },
+ { Zbool, Cx000C, 0x0051, Z_(AnalogInOutOfService), 1, Z_Nop },
+ { Zsingle, Cx000C, 0x0055, Z_(AqaraRotate), 1, Z_Nop },
+ // { 0xFF, Cx000C, 0x0057, Z_(AnalogInPriorityArray),1, Z_Nop },
+ { Zenum8, Cx000C, 0x0067, Z_(AnalogInReliability), 1, Z_Nop },
+ // { 0xFF, Cx000C, 0x0068, Z_(AnalogInRelinquishDefault),1, Z_Nop },
+ { Zsingle, Cx000C, 0x006A, Z_(AnalogInResolution), 1, Z_Nop },
+ { Zmap8, Cx000C, 0x006F, Z_(AnalogInStatusFlags), 1, Z_Nop },
+ { Zenum16, Cx000C, 0x0075, Z_(AnalogInEngineeringUnits),1, Z_Nop },
+ { Zuint32, Cx000C, 0x0100, Z_(AnalogInApplicationType),1, Z_Nop },
+ { Zuint16, Cx000C, 0xFF05, Z_(Aqara_FF05), 1, Z_Nop },
// Analog Output cluster
- { Zstring, Cx000D, 0x001C, Z(AnalogOutDescription), 1, Z_Nop },
- { Zsingle, Cx000D, 0x0041, Z(AnalogOutMaxValue), 1, Z_Nop },
- { Zsingle, Cx000D, 0x0045, Z(AnalogOutMinValue), 1, Z_Nop },
- { Zbool, Cx000D, 0x0051, Z(AnalogOutOutOfService),1, Z_Nop },
- { Zsingle, Cx000D, 0x0055, Z(AnalogOutValue), 1, Z_Nop },
- // { Zunk, Cx000D, 0x0057, Z(AnalogOutPriorityArray),1, Z_Nop },
- { Zenum8, Cx000D, 0x0067, Z(AnalogOutReliability), 1, Z_Nop },
- { Zsingle, Cx000D, 0x0068, Z(AnalogOutRelinquishDefault),1, Z_Nop },
- { Zsingle, Cx000D, 0x006A, Z(AnalogOutResolution), 1, Z_Nop },
- { Zmap8, Cx000D, 0x006F, Z(AnalogOutStatusFlags), 1, Z_Nop },
- { Zenum16, Cx000D, 0x0075, Z(AnalogOutEngineeringUnits),1, Z_Nop },
- { Zuint32, Cx000D, 0x0100, Z(AnalogOutApplicationType),1, Z_Nop },
+ { Zstring, Cx000D, 0x001C, Z_(AnalogOutDescription), 1, Z_Nop },
+ { Zsingle, Cx000D, 0x0041, Z_(AnalogOutMaxValue), 1, Z_Nop },
+ { Zsingle, Cx000D, 0x0045, Z_(AnalogOutMinValue), 1, Z_Nop },
+ { Zbool, Cx000D, 0x0051, Z_(AnalogOutOutOfService),1, Z_Nop },
+ { Zsingle, Cx000D, 0x0055, Z_(AnalogOutValue), 1, Z_Nop },
+ // { Zunk, Cx000D, 0x0057, Z_(AnalogOutPriorityArray),1, Z_Nop },
+ { Zenum8, Cx000D, 0x0067, Z_(AnalogOutReliability), 1, Z_Nop },
+ { Zsingle, Cx000D, 0x0068, Z_(AnalogOutRelinquishDefault),1, Z_Nop },
+ { Zsingle, Cx000D, 0x006A, Z_(AnalogOutResolution), 1, Z_Nop },
+ { Zmap8, Cx000D, 0x006F, Z_(AnalogOutStatusFlags), 1, Z_Nop },
+ { Zenum16, Cx000D, 0x0075, Z_(AnalogOutEngineeringUnits),1, Z_Nop },
+ { Zuint32, Cx000D, 0x0100, Z_(AnalogOutApplicationType),1, Z_Nop },
// Analog Value cluster
- { Zstring, Cx000E, 0x001C, Z(AnalogDescription), 1, Z_Nop },
- { Zbool, Cx000E, 0x0051, Z(AnalogOutOfService), 1, Z_Nop },
- { Zsingle, Cx000E, 0x0055, Z(AnalogValue), 1, Z_Nop },
- { Zunk, Cx000E, 0x0057, Z(AnalogPriorityArray), 1, Z_Nop },
- { Zenum8, Cx000E, 0x0067, Z(AnalogReliability), 1, Z_Nop },
- { Zsingle, Cx000E, 0x0068, Z(AnalogRelinquishDefault),1, Z_Nop },
- { Zmap8, Cx000E, 0x006F, Z(AnalogStatusFlags), 1, Z_Nop },
- { Zenum16, Cx000E, 0x0075, Z(AnalogEngineeringUnits),1, Z_Nop },
- { Zuint32, Cx000E, 0x0100, Z(AnalogApplicationType),1, Z_Nop },
+ { Zstring, Cx000E, 0x001C, Z_(AnalogDescription), 1, Z_Nop },
+ { Zbool, Cx000E, 0x0051, Z_(AnalogOutOfService), 1, Z_Nop },
+ { Zsingle, Cx000E, 0x0055, Z_(AnalogValue), 1, Z_Nop },
+ { Zunk, Cx000E, 0x0057, Z_(AnalogPriorityArray), 1, Z_Nop },
+ { Zenum8, Cx000E, 0x0067, Z_(AnalogReliability), 1, Z_Nop },
+ { Zsingle, Cx000E, 0x0068, Z_(AnalogRelinquishDefault),1, Z_Nop },
+ { Zmap8, Cx000E, 0x006F, Z_(AnalogStatusFlags), 1, Z_Nop },
+ { Zenum16, Cx000E, 0x0075, Z_(AnalogEngineeringUnits),1, Z_Nop },
+ { Zuint32, Cx000E, 0x0100, Z_(AnalogApplicationType),1, Z_Nop },
// Binary Input cluster
- { Zstring, Cx000F, 0x0004, Z(BinaryInActiveText), 1, Z_Nop },
- { Zstring, Cx000F, 0x001C, Z(BinaryInDescription), 1, Z_Nop },
- { Zstring, Cx000F, 0x002E, Z(BinaryInInactiveText),1, Z_Nop },
- { Zbool, Cx000F, 0x0051, Z(BinaryInOutOfService),1, Z_Nop },
- { Zenum8, Cx000F, 0x0054, Z(BinaryInPolarity), 1, Z_Nop },
- { Zstring, Cx000F, 0x0055, Z(BinaryInValue), 1, Z_Nop },
- // { 0xFF, Cx000F, 0x0057, Z(BinaryInPriorityArray),1, Z_Nop },
- { Zenum8, Cx000F, 0x0067, Z(BinaryInReliability), 1, Z_Nop },
- { Zmap8, Cx000F, 0x006F, Z(BinaryInStatusFlags), 1, Z_Nop },
- { Zuint32, Cx000F, 0x0100, Z(BinaryInApplicationType),1, Z_Nop },
+ { Zstring, Cx000F, 0x0004, Z_(BinaryInActiveText), 1, Z_Nop },
+ { Zstring, Cx000F, 0x001C, Z_(BinaryInDescription), 1, Z_Nop },
+ { Zstring, Cx000F, 0x002E, Z_(BinaryInInactiveText),1, Z_Nop },
+ { Zbool, Cx000F, 0x0051, Z_(BinaryInOutOfService),1, Z_Nop },
+ { Zenum8, Cx000F, 0x0054, Z_(BinaryInPolarity), 1, Z_Nop },
+ { Zstring, Cx000F, 0x0055, Z_(BinaryInValue), 1, Z_Nop },
+ // { 0xFF, Cx000F, 0x0057, Z_(BinaryInPriorityArray),1, Z_Nop },
+ { Zenum8, Cx000F, 0x0067, Z_(BinaryInReliability), 1, Z_Nop },
+ { Zmap8, Cx000F, 0x006F, Z_(BinaryInStatusFlags), 1, Z_Nop },
+ { Zuint32, Cx000F, 0x0100, Z_(BinaryInApplicationType),1, Z_Nop },
// Binary Output cluster
- { Zstring, Cx0010, 0x0004, Z(BinaryOutActiveText), 1, Z_Nop },
- { Zstring, Cx0010, 0x001C, Z(BinaryOutDescription), 1, Z_Nop },
- { Zstring, Cx0010, 0x002E, Z(BinaryOutInactiveText),1, Z_Nop },
- { Zuint32, Cx0010, 0x0042, Z(BinaryOutMinimumOffTime),1, Z_Nop },
- { Zuint32, Cx0010, 0x0043, Z(BinaryOutMinimumOnTime),1, Z_Nop },
- { Zbool, Cx0010, 0x0051, Z(BinaryOutOutOfService),1, Z_Nop },
- { Zenum8, Cx0010, 0x0054, Z(BinaryOutPolarity), 1, Z_Nop },
- { Zbool, Cx0010, 0x0055, Z(BinaryOutValue), 1, Z_Nop },
- // { Zunk, Cx0010, 0x0057, Z(BinaryOutPriorityArray),1, Z_Nop },
- { Zenum8, Cx0010, 0x0067, Z(BinaryOutReliability), 1, Z_Nop },
- { Zbool, Cx0010, 0x0068, Z(BinaryOutRelinquishDefault),1, Z_Nop },
- { Zmap8, Cx0010, 0x006F, Z(BinaryOutStatusFlags), 1, Z_Nop },
- { Zuint32, Cx0010, 0x0100, Z(BinaryOutApplicationType),1, Z_Nop },
+ { Zstring, Cx0010, 0x0004, Z_(BinaryOutActiveText), 1, Z_Nop },
+ { Zstring, Cx0010, 0x001C, Z_(BinaryOutDescription), 1, Z_Nop },
+ { Zstring, Cx0010, 0x002E, Z_(BinaryOutInactiveText),1, Z_Nop },
+ { Zuint32, Cx0010, 0x0042, Z_(BinaryOutMinimumOffTime),1, Z_Nop },
+ { Zuint32, Cx0010, 0x0043, Z_(BinaryOutMinimumOnTime),1, Z_Nop },
+ { Zbool, Cx0010, 0x0051, Z_(BinaryOutOutOfService),1, Z_Nop },
+ { Zenum8, Cx0010, 0x0054, Z_(BinaryOutPolarity), 1, Z_Nop },
+ { Zbool, Cx0010, 0x0055, Z_(BinaryOutValue), 1, Z_Nop },
+ // { Zunk, Cx0010, 0x0057, Z_(BinaryOutPriorityArray),1, Z_Nop },
+ { Zenum8, Cx0010, 0x0067, Z_(BinaryOutReliability), 1, Z_Nop },
+ { Zbool, Cx0010, 0x0068, Z_(BinaryOutRelinquishDefault),1, Z_Nop },
+ { Zmap8, Cx0010, 0x006F, Z_(BinaryOutStatusFlags), 1, Z_Nop },
+ { Zuint32, Cx0010, 0x0100, Z_(BinaryOutApplicationType),1, Z_Nop },
// Binary Value cluster
- { Zstring, Cx0011, 0x0004, Z(BinaryActiveText), 1, Z_Nop },
- { Zstring, Cx0011, 0x001C, Z(BinaryDescription), 1, Z_Nop },
- { Zstring, Cx0011, 0x002E, Z(BinaryInactiveText), 1, Z_Nop },
- { Zuint32, Cx0011, 0x0042, Z(BinaryMinimumOffTime), 1, Z_Nop },
- { Zuint32, Cx0011, 0x0043, Z(BinaryMinimumOnTime), 1, Z_Nop },
- { Zbool, Cx0011, 0x0051, Z(BinaryOutOfService), 1, Z_Nop },
- { Zbool, Cx0011, 0x0055, Z(BinaryValue), 1, Z_Nop },
- // { Zunk, Cx0011, 0x0057, Z(BinaryPriorityArray), 1, Z_Nop },
- { Zenum8, Cx0011, 0x0067, Z(BinaryReliability), 1, Z_Nop },
- { Zbool, Cx0011, 0x0068, Z(BinaryRelinquishDefault),1, Z_Nop },
- { Zmap8, Cx0011, 0x006F, Z(BinaryStatusFlags), 1, Z_Nop },
- { Zuint32, Cx0011, 0x0100, Z(BinaryApplicationType),1, Z_Nop },
+ { Zstring, Cx0011, 0x0004, Z_(BinaryActiveText), 1, Z_Nop },
+ { Zstring, Cx0011, 0x001C, Z_(BinaryDescription), 1, Z_Nop },
+ { Zstring, Cx0011, 0x002E, Z_(BinaryInactiveText), 1, Z_Nop },
+ { Zuint32, Cx0011, 0x0042, Z_(BinaryMinimumOffTime), 1, Z_Nop },
+ { Zuint32, Cx0011, 0x0043, Z_(BinaryMinimumOnTime), 1, Z_Nop },
+ { Zbool, Cx0011, 0x0051, Z_(BinaryOutOfService), 1, Z_Nop },
+ { Zbool, Cx0011, 0x0055, Z_(BinaryValue), 1, Z_Nop },
+ // { Zunk, Cx0011, 0x0057, Z_(BinaryPriorityArray), 1, Z_Nop },
+ { Zenum8, Cx0011, 0x0067, Z_(BinaryReliability), 1, Z_Nop },
+ { Zbool, Cx0011, 0x0068, Z_(BinaryRelinquishDefault),1, Z_Nop },
+ { Zmap8, Cx0011, 0x006F, Z_(BinaryStatusFlags), 1, Z_Nop },
+ { Zuint32, Cx0011, 0x0100, Z_(BinaryApplicationType),1, Z_Nop },
// Multistate Input cluster
- // { Zunk, Cx0012, 0x000E, Z(MultiInStateText), 1, Z_Nop },
- { Zstring, Cx0012, 0x001C, Z(MultiInDescription), 1, Z_Nop },
- { Zuint16, Cx0012, 0x004A, Z(MultiInNumberOfStates),1, Z_Nop },
- { Zbool, Cx0012, 0x0051, Z(MultiInOutOfService), 1, Z_Nop },
- { Zuint16, Cx0012, 0x0055, Z(MultiInValue), 0, Z_AqaraCube },
- { Zenum8, Cx0012, 0x0067, Z(MultiInReliability), 1, Z_Nop },
- { Zmap8, Cx0012, 0x006F, Z(MultiInStatusFlags), 1, Z_Nop },
- { Zuint32, Cx0012, 0x0100, Z(MultiInApplicationType),1, Z_Nop },
+ // { Zunk, Cx0012, 0x000E, Z_(MultiInStateText), 1, Z_Nop },
+ { Zstring, Cx0012, 0x001C, Z_(MultiInDescription), 1, Z_Nop },
+ { Zuint16, Cx0012, 0x004A, Z_(MultiInNumberOfStates),1, Z_Nop },
+ { Zbool, Cx0012, 0x0051, Z_(MultiInOutOfService), 1, Z_Nop },
+ { Zuint16, Cx0012, 0x0055, Z_(MultiInValue), 0, Z_AqaraCube },
+ { Zenum8, Cx0012, 0x0067, Z_(MultiInReliability), 1, Z_Nop },
+ { Zmap8, Cx0012, 0x006F, Z_(MultiInStatusFlags), 1, Z_Nop },
+ { Zuint32, Cx0012, 0x0100, Z_(MultiInApplicationType),1, Z_Nop },
// Multistate output
- // { Zunk, Cx0013, 0x000E, Z(MultiOutStateText), 1, Z_Nop },
- { Zstring, Cx0013, 0x001C, Z(MultiOutDescription), 1, Z_Nop },
- { Zuint16, Cx0013, 0x004A, Z(MultiOutNumberOfStates),1, Z_Nop },
- { Zbool, Cx0013, 0x0051, Z(MultiOutOutOfService), 1, Z_Nop },
- { Zuint16, Cx0013, 0x0055, Z(MultiOutValue), 1, Z_Nop },
- // { Zunk, Cx0013, 0x0057, Z(MultiOutPriorityArray),1, Z_Nop },
- { Zenum8, Cx0013, 0x0067, Z(MultiOutReliability), 1, Z_Nop },
- { Zuint16, Cx0013, 0x0068, Z(MultiOutRelinquishDefault),1, Z_Nop },
- { Zmap8, Cx0013, 0x006F, Z(MultiOutStatusFlags), 1, Z_Nop },
- { Zuint32, Cx0013, 0x0100, Z(MultiOutApplicationType),1, Z_Nop },
+ // { Zunk, Cx0013, 0x000E, Z_(MultiOutStateText), 1, Z_Nop },
+ { Zstring, Cx0013, 0x001C, Z_(MultiOutDescription), 1, Z_Nop },
+ { Zuint16, Cx0013, 0x004A, Z_(MultiOutNumberOfStates),1, Z_Nop },
+ { Zbool, Cx0013, 0x0051, Z_(MultiOutOutOfService), 1, Z_Nop },
+ { Zuint16, Cx0013, 0x0055, Z_(MultiOutValue), 1, Z_Nop },
+ // { Zunk, Cx0013, 0x0057, Z_(MultiOutPriorityArray),1, Z_Nop },
+ { Zenum8, Cx0013, 0x0067, Z_(MultiOutReliability), 1, Z_Nop },
+ { Zuint16, Cx0013, 0x0068, Z_(MultiOutRelinquishDefault),1, Z_Nop },
+ { Zmap8, Cx0013, 0x006F, Z_(MultiOutStatusFlags), 1, Z_Nop },
+ { Zuint32, Cx0013, 0x0100, Z_(MultiOutApplicationType),1, Z_Nop },
// Multistate Value cluster
- // { Zunk, Cx0014, 0x000E, Z(MultiStateText), 1, Z_Nop },
- { Zstring, Cx0014, 0x001C, Z(MultiDescription), 1, Z_Nop },
- { Zuint16, Cx0014, 0x004A, Z(MultiNumberOfStates), 1, Z_Nop },
- { Zbool, Cx0014, 0x0051, Z(MultiOutOfService), 1, Z_Nop },
- { Zuint16, Cx0014, 0x0055, Z(MultiValue), 1, Z_Nop },
- { Zenum8, Cx0014, 0x0067, Z(MultiReliability), 1, Z_Nop },
- { Zuint16, Cx0014, 0x0068, Z(MultiRelinquishDefault),1, Z_Nop },
- { Zmap8, Cx0014, 0x006F, Z(MultiStatusFlags), 1, Z_Nop },
- { Zuint32, Cx0014, 0x0100, Z(MultiApplicationType), 1, Z_Nop },
+ // { Zunk, Cx0014, 0x000E, Z_(MultiStateText), 1, Z_Nop },
+ { Zstring, Cx0014, 0x001C, Z_(MultiDescription), 1, Z_Nop },
+ { Zuint16, Cx0014, 0x004A, Z_(MultiNumberOfStates), 1, Z_Nop },
+ { Zbool, Cx0014, 0x0051, Z_(MultiOutOfService), 1, Z_Nop },
+ { Zuint16, Cx0014, 0x0055, Z_(MultiValue), 1, Z_Nop },
+ { Zenum8, Cx0014, 0x0067, Z_(MultiReliability), 1, Z_Nop },
+ { Zuint16, Cx0014, 0x0068, Z_(MultiRelinquishDefault),1, Z_Nop },
+ { Zmap8, Cx0014, 0x006F, Z_(MultiStatusFlags), 1, Z_Nop },
+ { Zuint32, Cx0014, 0x0100, Z_(MultiApplicationType), 1, Z_Nop },
// Power Profile cluster
- { Zuint8, Cx001A, 0x0000, Z(TotalProfileNum), 1, Z_Nop },
- { Zbool, Cx001A, 0x0001, Z(MultipleScheduling), 1, Z_Nop },
- { Zmap8, Cx001A, 0x0002, Z(EnergyFormatting), 1, Z_Nop },
- { Zbool, Cx001A, 0x0003, Z(EnergyRemote), 1, Z_Nop },
- { Zmap8, Cx001A, 0x0004, Z(ScheduleMode), 1, Z_Nop },
+ { Zuint8, Cx001A, 0x0000, Z_(TotalProfileNum), 1, Z_Nop },
+ { Zbool, Cx001A, 0x0001, Z_(MultipleScheduling), 1, Z_Nop },
+ { Zmap8, Cx001A, 0x0002, Z_(EnergyFormatting), 1, Z_Nop },
+ { Zbool, Cx001A, 0x0003, Z_(EnergyRemote), 1, Z_Nop },
+ { Zmap8, Cx001A, 0x0004, Z_(ScheduleMode), 1, Z_Nop },
// Poll Control cluster
- { Zuint32, Cx0020, 0x0000, Z(CheckinInterval), 1, Z_Nop },
- { Zuint32, Cx0020, 0x0001, Z(LongPollInterval), 1, Z_Nop },
- { Zuint16, Cx0020, 0x0002, Z(ShortPollInterval), 1, Z_Nop },
- { Zuint16, Cx0020, 0x0003, Z(FastPollTimeout), 1, Z_Nop },
- { Zuint32, Cx0020, 0x0004, Z(CheckinIntervalMin), 1, Z_Nop },
- { Zuint32, Cx0020, 0x0005, Z(LongPollIntervalMin), 1, Z_Nop },
- { Zuint16, Cx0020, 0x0006, Z(FastPollTimeoutMax), 1, Z_Nop },
+ { Zuint32, Cx0020, 0x0000, Z_(CheckinInterval), 1, Z_Nop },
+ { Zuint32, Cx0020, 0x0001, Z_(LongPollInterval), 1, Z_Nop },
+ { Zuint16, Cx0020, 0x0002, Z_(ShortPollInterval), 1, Z_Nop },
+ { Zuint16, Cx0020, 0x0003, Z_(FastPollTimeout), 1, Z_Nop },
+ { Zuint32, Cx0020, 0x0004, Z_(CheckinIntervalMin), 1, Z_Nop },
+ { Zuint32, Cx0020, 0x0005, Z_(LongPollIntervalMin), 1, Z_Nop },
+ { Zuint16, Cx0020, 0x0006, Z_(FastPollTimeoutMax), 1, Z_Nop },
// Shade Configuration cluster
- { Zuint16, Cx0100, 0x0000, Z(PhysicalClosedLimit), 1, Z_Nop },
- { Zuint8, Cx0100, 0x0001, Z(MotorStepSize), 1, Z_Nop },
- { Zmap8, Cx0100, 0x0002, Z(Status), 1, Z_Nop },
- { Zuint16, Cx0100, 0x0010, Z(ClosedLimit), 1, Z_Nop },
- { Zenum8, Cx0100, 0x0011, Z(Mode), 1, Z_Nop },
+ { Zuint16, Cx0100, 0x0000, Z_(PhysicalClosedLimit), 1, Z_Nop },
+ { Zuint8, Cx0100, 0x0001, Z_(MotorStepSize), 1, Z_Nop },
+ { Zmap8, Cx0100, 0x0002, Z_(Status), 1, Z_Nop },
+ { Zuint16, Cx0100, 0x0010, Z_(ClosedLimit), 1, Z_Nop },
+ { Zenum8, Cx0100, 0x0011, Z_(Mode), 1, Z_Nop },
// Door Lock cluster
- { Zenum8, Cx0101, 0x0000, Z(LockState), 1, Z_Nop },
- { Zenum8, Cx0101, 0x0001, Z(LockType), 1, Z_Nop },
- { Zbool, Cx0101, 0x0002, Z(ActuatorEnabled), 1, Z_Nop },
- { Zenum8, Cx0101, 0x0003, Z(DoorState), 1, Z_Nop },
- { Zuint32, Cx0101, 0x0004, Z(DoorOpenEvents), 1, Z_Nop },
- { Zuint32, Cx0101, 0x0005, Z(DoorClosedEvents), 1, Z_Nop },
- { Zuint16, Cx0101, 0x0006, Z(OpenPeriod), 1, Z_Nop },
+ { Zenum8, Cx0101, 0x0000, Z_(LockState), 1, Z_Nop },
+ { Zenum8, Cx0101, 0x0001, Z_(LockType), 1, Z_Nop },
+ { Zbool, Cx0101, 0x0002, Z_(ActuatorEnabled), 1, Z_Nop },
+ { Zenum8, Cx0101, 0x0003, Z_(DoorState), 1, Z_Nop },
+ { Zuint32, Cx0101, 0x0004, Z_(DoorOpenEvents), 1, Z_Nop },
+ { Zuint32, Cx0101, 0x0005, Z_(DoorClosedEvents), 1, Z_Nop },
+ { Zuint16, Cx0101, 0x0006, Z_(OpenPeriod), 1, Z_Nop },
// Aqara Lumi Vibration Sensor
- { Zuint16, Cx0101, 0x0055, Z(AqaraVibrationMode), 0, Z_AqaraVibration },
- { Zuint16, Cx0101, 0x0503, Z(AqaraVibrationsOrAngle), 1, Z_Nop },
- { Zuint32, Cx0101, 0x0505, Z(AqaraVibration505), 1, Z_Nop },
- { Zuint48, Cx0101, 0x0508, Z(AqaraAccelerometer), 0, Z_AqaraVibration },
+ { Zuint16, Cx0101, 0x0055, Z_(AqaraVibrationMode), 0, Z_AqaraVibration },
+ { Zuint16, Cx0101, 0x0503, Z_(AqaraVibrationsOrAngle), 1, Z_Nop },
+ { Zuint32, Cx0101, 0x0505, Z_(AqaraVibration505), 1, Z_Nop },
+ { Zuint48, Cx0101, 0x0508, Z_(AqaraAccelerometer), 0, Z_AqaraVibration },
// Window Covering cluster
- { Zenum8, Cx0102, 0x0000, Z(WindowCoveringType), 1, Z_Nop },
- { Zuint16, Cx0102, 0x0001, Z(PhysicalClosedLimitLift),1, Z_Nop },
- { Zuint16, Cx0102, 0x0002, Z(PhysicalClosedLimitTilt),1, Z_Nop },
- { Zuint16, Cx0102, 0x0003, Z(CurrentPositionLift), 1, Z_Nop },
- { Zuint16, Cx0102, 0x0004, Z(CurrentPositionTilt), 1, Z_Nop },
- { Zuint16, Cx0102, 0x0005, Z(NumberofActuationsLift),1, Z_Nop },
- { Zuint16, Cx0102, 0x0006, Z(NumberofActuationsTilt),1, Z_Nop },
- { Zmap8, Cx0102, 0x0007, Z(ConfigStatus), 1, Z_Nop },
- { Zuint8, Cx0102, 0x0008, Z(CurrentPositionLiftPercentage),1, Z_Nop },
- { Zuint8, Cx0102, 0x0009, Z(CurrentPositionTiltPercentage),1, Z_Nop },
- { Zuint16, Cx0102, 0x0010, Z(InstalledOpenLimitLift),1, Z_Nop },
- { Zuint16, Cx0102, 0x0011, Z(InstalledClosedLimitLift),1, Z_Nop },
- { Zuint16, Cx0102, 0x0012, Z(InstalledOpenLimitTilt),1, Z_Nop },
- { Zuint16, Cx0102, 0x0013, Z(InstalledClosedLimitTilt),1, Z_Nop },
- { Zuint16, Cx0102, 0x0014, Z(VelocityLift), 1, Z_Nop },
- { Zuint16, Cx0102, 0x0015, Z(AccelerationTimeLift),1, Z_Nop },
- { Zuint16, Cx0102, 0x0016, Z(DecelerationTimeLift), 1, Z_Nop },
- { Zmap8, Cx0102, 0x0017, Z(Mode), 1, Z_Nop },
- { Zoctstr, Cx0102, 0x0018, Z(IntermediateSetpointsLift),1, Z_Nop },
- { Zoctstr, Cx0102, 0x0019, Z(IntermediateSetpointsTilt),1, Z_Nop },
+ { Zenum8, Cx0102, 0x0000, Z_(WindowCoveringType), 1, Z_Nop },
+ { Zuint16, Cx0102, 0x0001, Z_(PhysicalClosedLimitLift),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0002, Z_(PhysicalClosedLimitTilt),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0003, Z_(CurrentPositionLift), 1, Z_Nop },
+ { Zuint16, Cx0102, 0x0004, Z_(CurrentPositionTilt), 1, Z_Nop },
+ { Zuint16, Cx0102, 0x0005, Z_(NumberofActuationsLift),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0006, Z_(NumberofActuationsTilt),1, Z_Nop },
+ { Zmap8, Cx0102, 0x0007, Z_(ConfigStatus), 1, Z_Nop },
+ { Zuint8, Cx0102, 0x0008, Z_(CurrentPositionLiftPercentage),1, Z_Nop },
+ { Zuint8, Cx0102, 0x0009, Z_(CurrentPositionTiltPercentage),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0010, Z_(InstalledOpenLimitLift),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0011, Z_(InstalledClosedLimitLift),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0012, Z_(InstalledOpenLimitTilt),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0013, Z_(InstalledClosedLimitTilt),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0014, Z_(VelocityLift), 1, Z_Nop },
+ { Zuint16, Cx0102, 0x0015, Z_(AccelerationTimeLift),1, Z_Nop },
+ { Zuint16, Cx0102, 0x0016, Z_(DecelerationTimeLift), 1, Z_Nop },
+ { Zmap8, Cx0102, 0x0017, Z_(Mode), 1, Z_Nop },
+ { Zoctstr, Cx0102, 0x0018, Z_(IntermediateSetpointsLift),1, Z_Nop },
+ { Zoctstr, Cx0102, 0x0019, Z_(IntermediateSetpointsTilt),1, Z_Nop },
// Color Control cluster
- { Zuint8, Cx0300, 0x0000, Z(Hue), 1, Z_Nop },
- { Zuint8, Cx0300, 0x0001, Z(Sat), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0002, Z(RemainingTime), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0003, Z(X), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0004, Z(Y), 1, Z_Nop },
- { Zenum8, Cx0300, 0x0005, Z(DriftCompensation), 1, Z_Nop },
- { Zstring, Cx0300, 0x0006, Z(CompensationText), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0007, Z(CT), 1, Z_Nop },
- { Zenum8, Cx0300, 0x0008, Z(ColorMode), 1, Z_Nop },
- { Zuint8, Cx0300, 0x0010, Z(NumberOfPrimaries), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0011, Z(Primary1X), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0012, Z(Primary1Y), 1, Z_Nop },
- { Zuint8, Cx0300, 0x0013, Z(Primary1Intensity), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0015, Z(Primary2X), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0016, Z(Primary2Y), 1, Z_Nop },
- { Zuint8, Cx0300, 0x0017, Z(Primary2Intensity), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0019, Z(Primary3X), 1, Z_Nop },
- { Zuint16, Cx0300, 0x001A, Z(Primary3Y), 1, Z_Nop },
- { Zuint8, Cx0300, 0x001B, Z(Primary3Intensity), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0030, Z(WhitePointX), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0031, Z(WhitePointY), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0032, Z(ColorPointRX), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0033, Z(ColorPointRY), 1, Z_Nop },
- { Zuint8, Cx0300, 0x0034, Z(ColorPointRIntensity), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0036, Z(ColorPointGX), 1, Z_Nop },
- { Zuint16, Cx0300, 0x0037, Z(ColorPointGY), 1, Z_Nop },
- { Zuint8, Cx0300, 0x0038, Z(ColorPointGIntensity), 1, Z_Nop },
- { Zuint16, Cx0300, 0x003A, Z(ColorPointBX), 1, Z_Nop },
- { Zuint16, Cx0300, 0x003B, Z(ColorPointBY), 1, Z_Nop },
- { Zuint8, Cx0300, 0x003C, Z(ColorPointBIntensity), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x0000, Z_(Hue), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x0001, Z_(Sat), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0002, Z_(RemainingTime), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0003, Z_(X), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0004, Z_(Y), 1, Z_Nop },
+ { Zenum8, Cx0300, 0x0005, Z_(DriftCompensation), 1, Z_Nop },
+ { Zstring, Cx0300, 0x0006, Z_(CompensationText), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0007, Z_(CT), 1, Z_Nop },
+ { Zenum8, Cx0300, 0x0008, Z_(ColorMode), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x0010, Z_(NumberOfPrimaries), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0011, Z_(Primary1X), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0012, Z_(Primary1Y), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x0013, Z_(Primary1Intensity), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0015, Z_(Primary2X), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0016, Z_(Primary2Y), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x0017, Z_(Primary2Intensity), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0019, Z_(Primary3X), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x001A, Z_(Primary3Y), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x001B, Z_(Primary3Intensity), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0030, Z_(WhitePointX), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0031, Z_(WhitePointY), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0032, Z_(ColorPointRX), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0033, Z_(ColorPointRY), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x0034, Z_(ColorPointRIntensity), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0036, Z_(ColorPointGX), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x0037, Z_(ColorPointGY), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x0038, Z_(ColorPointGIntensity), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x003A, Z_(ColorPointBX), 1, Z_Nop },
+ { Zuint16, Cx0300, 0x003B, Z_(ColorPointBY), 1, Z_Nop },
+ { Zuint8, Cx0300, 0x003C, Z_(ColorPointBIntensity), 1, Z_Nop },
// Illuminance Measurement cluster
- { Zuint16, Cx0400, 0x0000, Z(Illuminance), 1, Z_Nop }, // Illuminance (in Lux)
- { Zuint16, Cx0400, 0x0001, Z(IlluminanceMinMeasuredValue), 1, Z_Nop }, //
- { Zuint16, Cx0400, 0x0002, Z(IlluminanceMaxMeasuredValue), 1, Z_Nop }, //
- { Zuint16, Cx0400, 0x0003, Z(IlluminanceTolerance), 1, Z_Nop }, //
- { Zenum8, Cx0400, 0x0004, Z(IlluminanceLightSensorType), 1, Z_Nop }, //
- { Zunk, Cx0400, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other values
+ { Zuint16, Cx0400, 0x0000, Z_(Illuminance), 1, Z_Nop }, // Illuminance (in Lux)
+ { Zuint16, Cx0400, 0x0001, Z_(IlluminanceMinMeasuredValue), 1, Z_Nop }, //
+ { Zuint16, Cx0400, 0x0002, Z_(IlluminanceMaxMeasuredValue), 1, Z_Nop }, //
+ { Zuint16, Cx0400, 0x0003, Z_(IlluminanceTolerance), 1, Z_Nop }, //
+ { Zenum8, Cx0400, 0x0004, Z_(IlluminanceLightSensorType), 1, Z_Nop }, //
+ { Zunk, Cx0400, 0xFFFF, Z_(), 0, Z_Nop }, // Remove all other values
// Illuminance Level Sensing cluster
- { Zenum8, Cx0401, 0x0000, Z(IlluminanceLevelStatus), 1, Z_Nop }, // Illuminance (in Lux)
- { Zenum8, Cx0401, 0x0001, Z(IlluminanceLightSensorType), 1, Z_Nop }, // LightSensorType
- { Zuint16, Cx0401, 0x0010, Z(IlluminanceTargetLevel), 1, Z_Nop }, //
- { Zunk, Cx0401, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other values
+ { Zenum8, Cx0401, 0x0000, Z_(IlluminanceLevelStatus), 1, Z_Nop }, // Illuminance (in Lux)
+ { Zenum8, Cx0401, 0x0001, Z_(IlluminanceLightSensorType), 1, Z_Nop }, // LightSensorType
+ { Zuint16, Cx0401, 0x0010, Z_(IlluminanceTargetLevel), 1, Z_Nop }, //
+ { Zunk, Cx0401, 0xFFFF, Z_(), 0, Z_Nop }, // Remove all other values
// Temperature Measurement cluster
- { Zint16, Cx0402, 0x0000, Z(Temperature), -100, Z_Nop }, // divide by 100
- { Zint16, Cx0402, 0x0001, Z(TemperatureMinMeasuredValue), -100, Z_Nop }, //
- { Zint16, Cx0402, 0x0002, Z(TemperatureMaxMeasuredValue), -100, Z_Nop }, //
- { Zuint16, Cx0402, 0x0003, Z(TemperatureTolerance), -100, Z_Nop }, //
- { Zunk, Cx0402, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other values
+ { Zint16, Cx0402, 0x0000, Z_(Temperature), -100, Z_Nop }, // divide by 100
+ { Zint16, Cx0402, 0x0001, Z_(TemperatureMinMeasuredValue), -100, Z_Nop }, //
+ { Zint16, Cx0402, 0x0002, Z_(TemperatureMaxMeasuredValue), -100, Z_Nop }, //
+ { Zuint16, Cx0402, 0x0003, Z_(TemperatureTolerance), -100, Z_Nop }, //
+ { Zunk, Cx0402, 0xFFFF, Z_(), 0, Z_Nop }, // Remove all other values
// Pressure Measurement cluster
- { Zunk, Cx0403, 0x0000, Z(PressureUnit), 0, Z_AddPressureUnit }, // Pressure Unit
- { Zint16, Cx0403, 0x0000, Z(Pressure), 1, Z_Nop }, // Pressure
- { Zint16, Cx0403, 0x0001, Z(PressureMinMeasuredValue), 1, Z_Nop }, //
- { Zint16, Cx0403, 0x0002, Z(PressureMaxMeasuredValue), 1, Z_Nop }, //
- { Zuint16, Cx0403, 0x0003, Z(PressureTolerance), 1, Z_Nop }, //
- { Zint16, Cx0403, 0x0010, Z(PressureScaledValue), 1, Z_Nop }, //
- { Zint16, Cx0403, 0x0011, Z(PressureMinScaledValue), 1, Z_Nop }, //
- { Zint16, Cx0403, 0x0012, Z(PressureMaxScaledValue), 1, Z_Nop }, //
- { Zuint16, Cx0403, 0x0013, Z(PressureScaledTolerance), 1, Z_Nop }, //
- { Zint8, Cx0403, 0x0014, Z(PressureScale), 1, Z_Nop }, //
- { Zunk, Cx0403, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other Pressure values
+ { Zunk, Cx0403, 0x0000, Z_(PressureUnit), 0, Z_AddPressureUnit }, // Pressure Unit
+ { Zint16, Cx0403, 0x0000, Z_(Pressure), 1, Z_Nop }, // Pressure
+ { Zint16, Cx0403, 0x0001, Z_(PressureMinMeasuredValue), 1, Z_Nop }, //
+ { Zint16, Cx0403, 0x0002, Z_(PressureMaxMeasuredValue), 1, Z_Nop }, //
+ { Zuint16, Cx0403, 0x0003, Z_(PressureTolerance), 1, Z_Nop }, //
+ { Zint16, Cx0403, 0x0010, Z_(PressureScaledValue), 1, Z_Nop }, //
+ { Zint16, Cx0403, 0x0011, Z_(PressureMinScaledValue), 1, Z_Nop }, //
+ { Zint16, Cx0403, 0x0012, Z_(PressureMaxScaledValue), 1, Z_Nop }, //
+ { Zuint16, Cx0403, 0x0013, Z_(PressureScaledTolerance), 1, Z_Nop }, //
+ { Zint8, Cx0403, 0x0014, Z_(PressureScale), 1, Z_Nop }, //
+ { Zunk, Cx0403, 0xFFFF, Z_(), 0, Z_Nop }, // Remove all other Pressure values
// Flow Measurement cluster
- { Zuint16, Cx0404, 0x0000, Z(FlowRate), -10, Z_Nop }, // Flow (in m3/h)
- { Zuint16, Cx0404, 0x0001, Z(FlowMinMeasuredValue), 1, Z_Nop }, //
- { Zuint16, Cx0404, 0x0002, Z(FlowMaxMeasuredValue), 1, Z_Nop }, //
- { Zuint16, Cx0404, 0x0003, Z(FlowTolerance), 1, Z_Nop }, //
- { Zunk, Cx0404, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other values
+ { Zuint16, Cx0404, 0x0000, Z_(FlowRate), -10, Z_Nop }, // Flow (in m3/h)
+ { Zuint16, Cx0404, 0x0001, Z_(FlowMinMeasuredValue), 1, Z_Nop }, //
+ { Zuint16, Cx0404, 0x0002, Z_(FlowMaxMeasuredValue), 1, Z_Nop }, //
+ { Zuint16, Cx0404, 0x0003, Z_(FlowTolerance), 1, Z_Nop }, //
+ { Zunk, Cx0404, 0xFFFF, Z_(), 0, Z_Nop }, // Remove all other values
// Relative Humidity Measurement cluster
- { Zuint16, Cx0405, 0x0000, Z(Humidity), -100, Z_Nop }, // Humidity
- { Zuint16, Cx0405, 0x0001, Z(HumidityMinMeasuredValue), 1, Z_Nop }, //
- { Zuint16, Cx0405, 0x0002, Z(HumidityMaxMeasuredValue), 1, Z_Nop }, //
- { Zuint16, Cx0405, 0x0003, Z(HumidityTolerance), 1, Z_Nop }, //
- { Zunk, Cx0405, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other values
+ { Zuint16, Cx0405, 0x0000, Z_(Humidity), -100, Z_Nop }, // Humidity
+ { Zuint16, Cx0405, 0x0001, Z_(HumidityMinMeasuredValue), 1, Z_Nop }, //
+ { Zuint16, Cx0405, 0x0002, Z_(HumidityMaxMeasuredValue), 1, Z_Nop }, //
+ { Zuint16, Cx0405, 0x0003, Z_(HumidityTolerance), 1, Z_Nop }, //
+ { Zunk, Cx0405, 0xFFFF, Z_(), 0, Z_Nop }, // Remove all other values
// Occupancy Sensing cluster
- { Zmap8, Cx0406, 0x0000, Z(Occupancy), 1, Z_Nop }, // Occupancy (map8)
- { Zenum8, Cx0406, 0x0001, Z(OccupancySensorType), 1, Z_Nop }, // OccupancySensorType
- { Zunk, Cx0406, 0xFFFF, nullptr, 0, Z_Nop }, // Remove all other values
+ { Zmap8, Cx0406, 0x0000, Z_(Occupancy), 1, Z_Nop }, // Occupancy (map8)
+ { Zenum8, Cx0406, 0x0001, Z_(OccupancySensorType), 1, Z_Nop }, // OccupancySensorType
+ { Zunk, Cx0406, 0xFFFF, Z_(), 0, Z_Nop }, // Remove all other values
// IAS Cluster (Intruder Alarm System)
- { Zenum8, Cx0500, 0x0000, Z(ZoneState), 1, Z_Nop }, // Occupancy (map8)
- { Zenum16, Cx0500, 0x0001, Z(ZoneType), 1, Z_Nop }, // Occupancy (map8)
- { Zmap16, Cx0500, 0x0002, Z(ZoneStatus), 1, Z_Nop }, // Occupancy (map8)
+ { Zenum8, Cx0500, 0x0000, Z_(ZoneState), 1, Z_Nop }, // Occupancy (map8)
+ { Zenum16, Cx0500, 0x0001, Z_(ZoneType), 1, Z_Nop }, // Occupancy (map8)
+ { Zmap16, Cx0500, 0x0002, Z_(ZoneStatus), 1, Z_Nop }, // Occupancy (map8)
// Meter Identification cluster
- { Zstring, Cx0B01, 0x0000, Z(CompanyName), 1, Z_Nop },
- { Zuint16, Cx0B01, 0x0001, Z(MeterTypeID), 1, Z_Nop },
- { Zuint16, Cx0B01, 0x0004, Z(DataQualityID), 1, Z_Nop },
- { Zstring, Cx0B01, 0x0005, Z(CustomerName), 1, Z_Nop },
- { Zoctstr, Cx0B01, 0x0006, Z(Model), 1, Z_Nop },
- { Zoctstr, Cx0B01, 0x0007, Z(PartNumber), 1, Z_Nop },
- { Zoctstr, Cx0B01, 0x0008, Z(ProductRevision), 1, Z_Nop },
- { Zoctstr, Cx0B01, 0x000A, Z(SoftwareRevision), 1, Z_Nop },
- { Zstring, Cx0B01, 0x000B, Z(UtilityName), 1, Z_Nop },
- { Zstring, Cx0B01, 0x000C, Z(POD), 1, Z_Nop },
- { Zint24, Cx0B01, 0x000D, Z(AvailablePower), 1, Z_Nop },
- { Zint24, Cx0B01, 0x000E, Z(PowerThreshold), 1, Z_Nop },
+ { Zstring, Cx0B01, 0x0000, Z_(CompanyName), 1, Z_Nop },
+ { Zuint16, Cx0B01, 0x0001, Z_(MeterTypeID), 1, Z_Nop },
+ { Zuint16, Cx0B01, 0x0004, Z_(DataQualityID), 1, Z_Nop },
+ { Zstring, Cx0B01, 0x0005, Z_(CustomerName), 1, Z_Nop },
+ { Zoctstr, Cx0B01, 0x0006, Z_(Model), 1, Z_Nop },
+ { Zoctstr, Cx0B01, 0x0007, Z_(PartNumber), 1, Z_Nop },
+ { Zoctstr, Cx0B01, 0x0008, Z_(ProductRevision), 1, Z_Nop },
+ { Zoctstr, Cx0B01, 0x000A, Z_(SoftwareRevision), 1, Z_Nop },
+ { Zstring, Cx0B01, 0x000B, Z_(UtilityName), 1, Z_Nop },
+ { Zstring, Cx0B01, 0x000C, Z_(POD), 1, Z_Nop },
+ { Zint24, Cx0B01, 0x000D, Z_(AvailablePower), 1, Z_Nop },
+ { Zint24, Cx0B01, 0x000E, Z_(PowerThreshold), 1, Z_Nop },
// Diagnostics cluster
- { Zuint16, Cx0B05, 0x0000, Z(NumberOfResets), 1, Z_Nop },
- { Zuint16, Cx0B05, 0x0001, Z(PersistentMemoryWrites),1, Z_Nop },
- { Zuint8, Cx0B05, 0x011C, Z(LastMessageLQI), 1, Z_Nop },
- { Zuint8, Cx0B05, 0x011D, Z(LastMessageRSSI), 1, Z_Nop },
+ { Zuint16, Cx0B05, 0x0000, Z_(NumberOfResets), 1, Z_Nop },
+ { Zuint16, Cx0B05, 0x0001, Z_(PersistentMemoryWrites),1, Z_Nop },
+ { Zuint8, Cx0B05, 0x011C, Z_(LastMessageLQI), 1, Z_Nop },
+ { Zuint8, Cx0B05, 0x011D, Z_(LastMessageRSSI), 1, Z_Nop },
};
@@ -630,13 +536,13 @@ const __FlashStringHelper* zigbeeFindAttributeByName(const char *command,
uint8_t *cb) {
for (uint32_t i = 0; i < ARRAY_SIZE(Z_PostProcess); i++) {
const Z_AttributeConverter *converter = &Z_PostProcess[i];
- if (nullptr == converter->name) { continue; } // avoid strcasecmp_P() from crashing
- if (0 == strcasecmp_P(command, converter->name)) {
+ if (0 == pgm_read_word(&converter->name_offset)) { continue; } // avoid strcasecmp_P() from crashing
+ if (0 == strcasecmp_P(command, Z_strings + pgm_read_word(&converter->name_offset))) {
if (cluster) { *cluster = CxToCluster(pgm_read_byte(&converter->cluster_short)); }
if (attribute) { *attribute = pgm_read_word(&converter->attribute); }
if (multiplier) { *multiplier = pgm_read_byte(&converter->multiplier); }
if (cb) { *cb = pgm_read_byte(&converter->cb); }
- return (const __FlashStringHelper*) converter->name;
+ return (const __FlashStringHelper*) (Z_strings + pgm_read_word(&converter->name_offset));
}
}
return nullptr;
@@ -1132,7 +1038,7 @@ void ZCLFrame::parseReadAttributes(JsonObject& json, uint8_t offset) {
uint16_t conv_attribute = pgm_read_word(&converter->attribute);
if ((conv_cluster == _cluster_id) && (conv_attribute == attrid)) {
- attr_names[(const __FlashStringHelper*) converter->name] = true;
+ attr_names[(const __FlashStringHelper*) (Z_strings + pgm_read_word(&converter->name_offset))] = true;
break;
}
}
@@ -1178,7 +1084,7 @@ void ZCLFrame::parseReadConfigAttributes(JsonObject& json, uint8_t offset) {
uint16_t conv_attribute = pgm_read_word(&converter->attribute);
if ((conv_cluster == _cluster_id) && (conv_attribute == attrid)) {
- attr_details[(const __FlashStringHelper*) converter->name] = true;
+ attr_details[(const __FlashStringHelper*) (Z_strings + pgm_read_word(&converter->name_offset))] = true;
break;
}
}
@@ -1611,7 +1517,7 @@ void ZCLFrame::postProcessAttributes(uint16_t shortaddr, JsonObject& json) {
if ((conv_cluster == cluster) &&
((conv_attribute == attribute) || (conv_attribute == 0xFFFF)) ) {
- String new_name_str = (const __FlashStringHelper*) converter->name;
+ String new_name_str = (const __FlashStringHelper*) (Z_strings + pgm_read_word(&converter->name_offset));
if (suffix > 1) { new_name_str += suffix; } // append suffix number
// else if (Settings.flag4.zb_index_ep) {
// if (zigbee_devices.countEndpoints(shortaddr) > 0) {
diff --git a/tasmota/xdrv_23_zigbee_6_commands.ino b/tasmota/xdrv_23_zigbee_6_commands.ino
index b6c2d2c11..1a3e5b103 100644
--- a/tasmota/xdrv_23_zigbee_6_commands.ino
+++ b/tasmota/xdrv_23_zigbee_6_commands.ino
@@ -24,11 +24,11 @@
\*********************************************************************************************/
typedef struct Z_CommandConverter {
- const char * tasmota_cmd;
+ uint16_t tasmota_cmd_offset;
uint16_t cluster;
uint8_t cmd; // normally 8 bits, 0xFF means it's a parameter
uint8_t direction; // direction of the command. 0x01 client->server, 0x02 server->client, 0x03 both, 0x80 requires custom decoding
- const char * param;
+ uint16_t param_offset;
} Z_CommandConverter;
typedef struct Z_XYZ_Var { // Holds values for vairables X, Y and Z
@@ -40,29 +40,6 @@ typedef struct Z_XYZ_Var { // Holds values for vairables X, Y and Z
uint8_t z_type = 0;
} Z_XYZ_Var;
-ZF(Identify) ZF(IdentifyQuery)
-ZF(AddGroup) ZF(ViewGroup) ZF(GetGroup) ZF(GetAllGroups) ZF(RemoveGroup) ZF(RemoveAllGroups)
-ZF(AddScene) ZF(ViewScene) ZF(RemoveScene) ZF(RemoveAllScenes) ZF(RecallScene) ZF(StoreScene) ZF(GetSceneMembership)
-//ZF(Power) ZF(Dimmer)
-ZF(PowerOffEffect) ZF(PowerOnRecall) ZF(PowerOnTimer)
-ZF(DimmerUp) ZF(DimmerDown) ZF(DimmerStop)
-ZF(ResetAlarm) ZF(ResetAllAlarms)
-//ZF(Hue) ZF(Sat) ZF(CT)
-ZF(HueSat) ZF(Color)
-ZF(ShutterOpen) ZF(ShutterClose) ZF(ShutterStop) ZF(ShutterLift) ZF(ShutterTilt) ZF(Shutter)
-//ZF(Occupancy)
-ZF(DimmerMove) ZF(DimmerStep) ZF(DimmerStepUp) ZF(DimmerStepDown)
-ZF(HueMove) ZF(HueStep) ZF(HueStepUp) ZF(HueStepDown) ZF(SatMove) ZF(SatStep) ZF(ColorMove) ZF(ColorStep)
-ZF(ColorTempMoveUp) ZF(ColorTempMoveDown) ZF(ColorTempMoveStop) ZF(ColorTempMove)
-ZF(ColorTempStep) ZF(ColorTempStepUp) ZF(ColorTempStepDown)
-ZF(ArrowClick) ZF(ArrowHold) ZF(ArrowRelease) ZF(ZoneStatusChange)
-
-ZF(xxxx00) ZF(xxxx) ZF(01xxxx) ZF(03xxxx) ZF(00) ZF(01) ZF() ZF(xxxxyy) ZF(00190200) ZF(01190200) ZF(xxyyyy) ZF(xx)
-ZF(xx000A00) ZF(xx0A00) ZF(xxyy0A00) ZF(xxxxyyyy0A00) ZF(xxxx0A00) ZF(xx0A) ZF(xxyy)
-ZF(xx190A00) ZF(xx19) ZF(xx190A) ZF(xxxxyyyy) ZF(xxxxyyzz) ZF(xxyyzzzz) ZF(xxyyyyzz) ZF(xxyyyyzzzz)
-ZF(01xxxx000000000000) ZF(03xxxx000000000000) ZF(00xxxx000000000000) ZF(xxyyyy000000000000)
-ZF(00xx0A00) ZF(01xx0A00) ZF(03xx0A00) ZF(01xxxx0A0000000000) ZF(03xxxx0A0000000000) ZF(xxyyyy0A0000000000)
-
// Cluster specific commands
// Note: the table is both for sending commands, but also displaying received commands
// - tasmota_cmd: the human-readable name of the command as entered or displayed, use '|' to split into multiple commands when displayed
@@ -72,91 +49,91 @@ ZF(00xx0A00) ZF(01xx0A00) ZF(03xx0A00) ZF(01xxxx0A0000000000) ZF(03xxxx0A0000000
// - param: the paylod template, x/y/z are substituted with arguments, little endian. For command display, payload must match until x/y/z character or until the end of the paylod. '??' means ignore.
const Z_CommandConverter Z_Commands[] PROGMEM = {
// Identify cluster
- { Z(Identify), 0x0003, 0x00, 0x01, Z(xxxx) }, // Identify device, time in seconds
- { Z(IdentifyQuery), 0x0003, 0x01, 0x01, Z() }, // Identify Query (no param)
+ { Z_(Identify), 0x0003, 0x00, 0x01, Z_(xxxx) }, // Identify device, time in seconds
+ { Z_(IdentifyQuery), 0x0003, 0x01, 0x01, Z_() }, // Identify Query (no param)
// Group adress commands
- { Z(AddGroup), 0x0004, 0x00, 0x01, Z(xxxx00) }, // Add group id, group name is not supported
- { Z(ViewGroup), 0x0004, 0x01, 0x01, Z(xxxx) }, // Ask for the group name
- { Z(GetGroup), 0x0004, 0x02, 0x01, Z(01xxxx) }, // Get one group membership
- { Z(GetAllGroups), 0x0004, 0x02, 0x01, Z(00) }, // Get all groups membership
- { Z(RemoveGroup), 0x0004, 0x03, 0x01, Z(xxxx) }, // Remove one group
- { Z(RemoveAllGroups),0x0004, 0x04, 0x01, Z() }, // Remove all groups
+ { Z_(AddGroup), 0x0004, 0x00, 0x01, Z_(xxxx00) }, // Add group id, group name is not supported
+ { Z_(ViewGroup), 0x0004, 0x01, 0x01, Z_(xxxx) }, // Ask for the group name
+ { Z_(GetGroup), 0x0004, 0x02, 0x01, Z_(01xxxx) }, // Get one group membership
+ { Z_(GetAllGroups), 0x0004, 0x02, 0x01, Z_(00) }, // Get all groups membership
+ { Z_(RemoveGroup), 0x0004, 0x03, 0x01, Z_(xxxx) }, // Remove one group
+ { Z_(RemoveAllGroups),0x0004, 0x04, 0x01, Z_() }, // Remove all groups
// Scenes
//{ "AddScene", 0x0005, 0x00, 0x01, "xxxxyy0100" },
- { Z(ViewScene), 0x0005, 0x01, 0x01, Z(xxxxyy) },
- { Z(RemoveScene), 0x0005, 0x02, 0x01, Z(xxxxyy) },
- { Z(RemoveAllScenes),0x0005, 0x03, 0x01, Z(xxxx) },
- { Z(RecallScene), 0x0005, 0x05, 0x01, Z(xxxxyy) },
- { Z(GetSceneMembership),0x0005, 0x06, 0x01, Z(xxxx) },
+ { Z_(ViewScene), 0x0005, 0x01, 0x01, Z_(xxxxyy) },
+ { Z_(RemoveScene), 0x0005, 0x02, 0x01, Z_(xxxxyy) },
+ { Z_(RemoveAllScenes),0x0005, 0x03, 0x01, Z_(xxxx) },
+ { Z_(RecallScene), 0x0005, 0x05, 0x01, Z_(xxxxyy) },
+ { Z_(GetSceneMembership),0x0005, 0x06, 0x01, Z_(xxxx) },
// Light & Shutter commands
- { Z(PowerOffEffect), 0x0006, 0x40, 0x81, Z(xxyy) }, // Power Off With Effect
- { Z(PowerOnRecall), 0x0006, 0x41, 0x81, Z() }, // Power On With Recall Global Scene
- { Z(PowerOnTimer), 0x0006, 0x42, 0x81, Z(xxyyyyzzzz) }, // Power On with Timed Off
- { Z(Power), 0x0006, 0xFF, 0x01, Z() }, // 0=Off, 1=On, 2=Toggle
- { Z(Dimmer), 0x0008, 0x04, 0x01, Z(xx0A00) }, // Move to Level with On/Off, xx=0..254 (255 is invalid)
- { Z(DimmerUp), 0x0008, 0x06, 0x01, Z(00190200) }, // Step up by 10%, 0.2 secs
- { Z(DimmerDown), 0x0008, 0x06, 0x01, Z(01190200) }, // Step down by 10%, 0.2 secs
- { Z(DimmerStop), 0x0008, 0x03, 0x01, Z() }, // Stop any Dimmer animation
- { Z(ResetAlarm), 0x0009, 0x00, 0x01, Z(xxyyyy) }, // Reset alarm (alarm code + cluster identifier)
- { Z(ResetAllAlarms), 0x0009, 0x01, 0x01, Z() }, // Reset all alarms
- { Z(Hue), 0x0300, 0x00, 0x01, Z(xx000A00) }, // Move to Hue, shortest time, 1s
- { Z(Sat), 0x0300, 0x03, 0x01, Z(xx0A00) }, // Move to Sat
- { Z(HueSat), 0x0300, 0x06, 0x01, Z(xxyy0A00) }, // Hue, Sat
- { Z(Color), 0x0300, 0x07, 0x01, Z(xxxxyyyy0A00) }, // x, y (uint16)
- { Z(CT), 0x0300, 0x0A, 0x01, Z(xxxx0A00) }, // Color Temperature Mireds (uint16)
- { Z(ShutterOpen), 0x0102, 0x00, 0x01, Z() },
- { Z(ShutterClose), 0x0102, 0x01, 0x01, Z() },
- { Z(ShutterStop), 0x0102, 0x02, 0x01, Z() },
- { Z(ShutterLift), 0x0102, 0x05, 0x01, Z(xx) }, // Lift percentage, 0%=open, 100%=closed
- { Z(ShutterTilt), 0x0102, 0x08, 0x01, Z(xx) }, // Tilt percentage
- { Z(Shutter), 0x0102, 0xFF, 0x01, Z() },
+ { Z_(PowerOffEffect), 0x0006, 0x40, 0x81, Z_(xxyy) }, // Power Off With Effect
+ { Z_(PowerOnRecall), 0x0006, 0x41, 0x81, Z_() }, // Power On With Recall Global Scene
+ { Z_(PowerOnTimer), 0x0006, 0x42, 0x81, Z_(xxyyyyzzzz) }, // Power On with Timed Off
+ { Z_(Power), 0x0006, 0xFF, 0x01, Z_() }, // 0=Off, 1=On, 2=Toggle
+ { Z_(Dimmer), 0x0008, 0x04, 0x01, Z_(xx0A00) }, // Move to Level with On/Off, xx=0..254 (255 is invalid)
+ { Z_(DimmerUp), 0x0008, 0x06, 0x01, Z_(00190200) }, // Step up by 10%, 0.2 secs
+ { Z_(DimmerDown), 0x0008, 0x06, 0x01, Z_(01190200) }, // Step down by 10%, 0.2 secs
+ { Z_(DimmerStop), 0x0008, 0x03, 0x01, Z_() }, // Stop any Dimmer animation
+ { Z_(ResetAlarm), 0x0009, 0x00, 0x01, Z_(xxyyyy) }, // Reset alarm (alarm code + cluster identifier)
+ { Z_(ResetAllAlarms), 0x0009, 0x01, 0x01, Z_() }, // Reset all alarms
+ { Z_(Hue), 0x0300, 0x00, 0x01, Z_(xx000A00) }, // Move to Hue, shortest time, 1s
+ { Z_(Sat), 0x0300, 0x03, 0x01, Z_(xx0A00) }, // Move to Sat
+ { Z_(HueSat), 0x0300, 0x06, 0x01, Z_(xxyy0A00) }, // Hue, Sat
+ { Z_(Color), 0x0300, 0x07, 0x01, Z_(xxxxyyyy0A00) }, // x, y (uint16)
+ { Z_(CT), 0x0300, 0x0A, 0x01, Z_(xxxx0A00) }, // Color Temperature Mireds (uint16)
+ { Z_(ShutterOpen), 0x0102, 0x00, 0x01, Z_() },
+ { Z_(ShutterClose), 0x0102, 0x01, 0x01, Z_() },
+ { Z_(ShutterStop), 0x0102, 0x02, 0x01, Z_() },
+ { Z_(ShutterLift), 0x0102, 0x05, 0x01, Z_(xx) }, // Lift percentage, 0%=open, 100%=closed
+ { Z_(ShutterTilt), 0x0102, 0x08, 0x01, Z_(xx) }, // Tilt percentage
+ { Z_(Shutter), 0x0102, 0xFF, 0x01, Z_() },
// Blitzwolf PIR
- { Z(Occupancy), 0xEF00, 0x01, 0x82, Z()}, // Specific decoder for Blitzwolf PIR, empty name means special treatment
+ { Z_(Occupancy), 0xEF00, 0x01, 0x82, Z_()}, // Specific decoder for Blitzwolf PIR, empty name means special treatment
// Decoders only - normally not used to send, and names may be masked by previous definitions
- { Z(Dimmer), 0x0008, 0x00, 0x01, Z(xx) },
- { Z(DimmerMove), 0x0008, 0x01, 0x01, Z(xx0A) },
- { Z(DimmerStepUp), 0x0008, 0x02, 0x01, Z(00xx0A00) },
- { Z(DimmerStepDown), 0x0008, 0x02, 0x01, Z(01xx0A00) },
- { Z(DimmerStep), 0x0008, 0x02, 0x01, Z(xx190A00) },
- { Z(DimmerMove), 0x0008, 0x05, 0x01, Z(xx0A) },
- { Z(DimmerUp), 0x0008, 0x06, 0x01, Z(00) },
- { Z(DimmerDown), 0x0008, 0x06, 0x01, Z(01) },
- { Z(DimmerStop), 0x0008, 0x07, 0x01, Z() },
- { Z(HueMove), 0x0300, 0x01, 0x01, Z(xx19) },
- { Z(HueStepUp), 0x0300, 0x02, 0x01, Z(01xx0A00) },
- { Z(HueStepDown), 0x0300, 0x02, 0x01, Z(03xx0A00) },
- { Z(HueStep), 0x0300, 0x02, 0x01, Z(xx190A00) },
- { Z(SatMove), 0x0300, 0x04, 0x01, Z(xx19) },
- { Z(SatStep), 0x0300, 0x05, 0x01, Z(xx190A) },
- { Z(ColorMove), 0x0300, 0x08, 0x01, Z(xxxxyyyy) },
- { Z(ColorStep), 0x0300, 0x09, 0x01, Z(xxxxyyyy0A00) },
- { Z(ColorTempMoveUp), 0x0300, 0x4B, 0x01, Z(01xxxx000000000000) },
- { Z(ColorTempMoveDown),0x0300, 0x4B, 0x01, Z(03xxxx000000000000) },
- { Z(ColorTempMoveStop),0x0300, 0x4B, 0x01, Z(00xxxx000000000000) },
- { Z(ColorTempMove), 0x0300, 0x4B, 0x01, Z(xxyyyy000000000000) },
- { Z(ColorTempStepUp), 0x0300, 0x4C, 0x01, Z(01xxxx0A0000000000) },
- { Z(ColorTempStepDown),0x0300, 0x4C, 0x01, Z(03xxxx0A0000000000) },
- { Z(ColorTempStep), 0x0300, 0x4C, 0x01, Z(xxyyyy0A0000000000) }, //xx = 0x01 up, 0x03 down, yyyy = step
+ { Z_(Dimmer), 0x0008, 0x00, 0x01, Z_(xx) },
+ { Z_(DimmerMove), 0x0008, 0x01, 0x01, Z_(xx0A) },
+ { Z_(DimmerStepUp), 0x0008, 0x02, 0x01, Z_(00xx0A00) },
+ { Z_(DimmerStepDown), 0x0008, 0x02, 0x01, Z_(01xx0A00) },
+ { Z_(DimmerStep), 0x0008, 0x02, 0x01, Z_(xx190A00) },
+ { Z_(DimmerMove), 0x0008, 0x05, 0x01, Z_(xx0A) },
+ { Z_(DimmerUp), 0x0008, 0x06, 0x01, Z_(00) },
+ { Z_(DimmerDown), 0x0008, 0x06, 0x01, Z_(01) },
+ { Z_(DimmerStop), 0x0008, 0x07, 0x01, Z_() },
+ { Z_(HueMove), 0x0300, 0x01, 0x01, Z_(xx19) },
+ { Z_(HueStepUp), 0x0300, 0x02, 0x01, Z_(01xx0A00) },
+ { Z_(HueStepDown), 0x0300, 0x02, 0x01, Z_(03xx0A00) },
+ { Z_(HueStep), 0x0300, 0x02, 0x01, Z_(xx190A00) },
+ { Z_(SatMove), 0x0300, 0x04, 0x01, Z_(xx19) },
+ { Z_(SatStep), 0x0300, 0x05, 0x01, Z_(xx190A) },
+ { Z_(ColorMove), 0x0300, 0x08, 0x01, Z_(xxxxyyyy) },
+ { Z_(ColorStep), 0x0300, 0x09, 0x01, Z_(xxxxyyyy0A00) },
+ { Z_(ColorTempMoveUp), 0x0300, 0x4B, 0x01, Z_(01xxxx000000000000) },
+ { Z_(ColorTempMoveDown),0x0300, 0x4B, 0x01, Z_(03xxxx000000000000) },
+ { Z_(ColorTempMoveStop),0x0300, 0x4B, 0x01, Z_(00xxxx000000000000) },
+ { Z_(ColorTempMove), 0x0300, 0x4B, 0x01, Z_(xxyyyy000000000000) },
+ { Z_(ColorTempStepUp), 0x0300, 0x4C, 0x01, Z_(01xxxx0A0000000000) },
+ { Z_(ColorTempStepDown),0x0300, 0x4C, 0x01, Z_(03xxxx0A0000000000) },
+ { Z_(ColorTempStep), 0x0300, 0x4C, 0x01, Z_(xxyyyy0A0000000000) }, //xx = 0x01 up, 0x03 down, yyyy = step
// Tradfri
- { Z(ArrowClick), 0x0005, 0x07, 0x01, Z(xx) }, // xx == 0x01 = left, 0x00 = right
- { Z(ArrowHold), 0x0005, 0x08, 0x01, Z(xx) }, // xx == 0x01 = left, 0x00 = right
- { Z(ArrowRelease), 0x0005, 0x09, 0x01, Z() },
+ { Z_(ArrowClick), 0x0005, 0x07, 0x01, Z_(xx) }, // xx == 0x01 = left, 0x00 = right
+ { Z_(ArrowHold), 0x0005, 0x08, 0x01, Z_(xx) }, // xx == 0x01 = left, 0x00 = right
+ { Z_(ArrowRelease), 0x0005, 0x09, 0x01, Z_() },
// Response for Indetify cluster
- { Z(IdentifyQuery), 0x0003, 0x00, 0x02, Z(xxxx) }, // timeout in seconds
+ { Z_(IdentifyQuery), 0x0003, 0x00, 0x02, Z_(xxxx) }, // timeout in seconds
// IAS - Intruder Alarm System + leak/fire detection
- { Z(ZoneStatusChange),0x0500, 0x00, 0x82, Z(xxxxyyzz) }, // xxxx = zone status, yy = extended status, zz = zone id, Delay is ignored
+ { Z_(ZoneStatusChange),0x0500, 0x00, 0x82, Z_(xxxxyyzz) }, // xxxx = zone status, yy = extended status, zz = zone id, Delay is ignored
// responses for Group cluster commands
- { Z(AddGroup), 0x0004, 0x00, 0x82, Z(xxyyyy) }, // xx = status, yy = group id
- { Z(ViewGroup), 0x0004, 0x01, 0x82, Z(xxyyyy) }, // xx = status, yy = group id, name ignored
- { Z(GetGroup), 0x0004, 0x02, 0x82, Z(xxyyzzzz) }, // xx = capacity, yy = count, zzzz = first group id, following groups ignored
- { Z(RemoveGroup), 0x0004, 0x03, 0x82, Z(xxyyyy) }, // xx = status, yy = group id
+ { Z_(AddGroup), 0x0004, 0x00, 0x82, Z_(xxyyyy) }, // xx = status, yy = group id
+ { Z_(ViewGroup), 0x0004, 0x01, 0x82, Z_(xxyyyy) }, // xx = status, yy = group id, name ignored
+ { Z_(GetGroup), 0x0004, 0x02, 0x82, Z_(xxyyzzzz) }, // xx = capacity, yy = count, zzzz = first group id, following groups ignored
+ { Z_(RemoveGroup), 0x0004, 0x03, 0x82, Z_(xxyyyy) }, // xx = status, yy = group id
// responses for Scene cluster commands
- { Z(AddScene), 0x0005, 0x00, 0x82, Z(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
- { Z(ViewScene), 0x0005, 0x01, 0x82, Z(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
- { Z(RemoveScene), 0x0005, 0x02, 0x82, Z(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
- { Z(RemoveAllScenes),0x0005, 0x03, 0x82, Z(xxyyyy) }, // xx = status, yyyy = group id
- { Z(StoreScene), 0x0005, 0x04, 0x82, Z(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
- { Z(GetSceneMembership),0x0005, 0x06, 0x82,Z(xxyyzzzz) }, // specific
+ { Z_(AddScene), 0x0005, 0x00, 0x82, Z_(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
+ { Z_(ViewScene), 0x0005, 0x01, 0x82, Z_(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
+ { Z_(RemoveScene), 0x0005, 0x02, 0x82, Z_(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
+ { Z_(RemoveAllScenes),0x0005, 0x03, 0x82, Z_(xxyyyy) }, // xx = status, yyyy = group id
+ { Z_(StoreScene), 0x0005, 0x04, 0x82, Z_(xxyyyyzz) }, // xx = status, yyyy = group id, zz = scene id
+ { Z_(GetSceneMembership),0x0005, 0x06, 0x82,Z_(xxyyzzzz) }, // specific
};
/*********************************************************************************************\
@@ -376,7 +353,7 @@ void convertClusterSpecific(JsonObject& json, uint16_t cluster, uint8_t cmd, boo
// Match if:
// - payload exactly matches conv->param (conv->param may be longer)
// - payload matches conv->param until 'x', 'y' or 'z'
- const char * p = conv->param;
+ const char * p = Z_strings + pgm_read_word(&conv->param_offset);
//AddLog_P2(LOG_LEVEL_INFO, PSTR(">>>++1 param = %s"), p);
bool match = true;
for (uint8_t i = 0; i < payload.len(); i++) {
@@ -396,8 +373,8 @@ void convertClusterSpecific(JsonObject& json, uint16_t cluster, uint8_t cmd, boo
p += 2;
}
if (match) {
- command_name = (const __FlashStringHelper*) conv->tasmota_cmd;
- parseXYZ(conv->param, payload, &xyz);
+ command_name = (const __FlashStringHelper*) (Z_strings + pgm_read_word(&conv->tasmota_cmd_offset));
+ parseXYZ(Z_strings + pgm_read_word(&conv->param_offset), payload, &xyz);
if (0xFF == conv_cmd) {
// shift all values
xyz.z = xyz.y;
@@ -541,10 +518,10 @@ const __FlashStringHelper* zigbeeFindCommand(const char *command, uint16_t *clus
uint8_t conv_direction = pgm_read_byte(&conv->direction);
uint8_t conv_cmd = pgm_read_byte(&conv->cmd);
uint16_t conv_cluster = pgm_read_word(&conv->cluster);
- if ((conv_direction & 0x01) && (0 == strcasecmp_P(command, conv->tasmota_cmd))) {
+ if ((conv_direction & 0x01) && (0 == strcasecmp_P(command, Z_strings + pgm_read_word(&conv->tasmota_cmd_offset)))) {
*cluster = conv_cluster;
*cmd = conv_cmd;
- return (const __FlashStringHelper*) conv->param;
+ return (const __FlashStringHelper*) (Z_strings + pgm_read_word(&conv->param_offset));
}
}
diff --git a/tasmota/xdrv_23_zigbee_A_impl.ino b/tasmota/xdrv_23_zigbee_A_impl.ino
index adcf985bd..80e26ec19 100644
--- a/tasmota/xdrv_23_zigbee_A_impl.ino
+++ b/tasmota/xdrv_23_zigbee_A_impl.ino
@@ -253,9 +253,9 @@ void ZbSendReportWrite(const JsonObject &val_pubwrite, uint16_t device, uint16_t
type_id = local_type_id;
break;
}
- } else if (converter->name) {
+ } else if (pgm_read_word(&converter->name_offset)) {
// AddLog_P2(LOG_LEVEL_DEBUG, PSTR("Comparing '%s' with '%s'"), attr_name, converter->name);
- if (0 == strcasecmp_P(key, converter->name)) {
+ if (0 == strcasecmp_P(key, Z_strings + pgm_read_word(&converter->name_offset))) {
// match
cluster_id = local_cluster_id;
attr_id = local_attr_id;
@@ -564,7 +564,7 @@ void ZbSendRead(const JsonVariant &val_attr, uint16_t device, uint16_t groupaddr
uint16_t local_cluster_id = CxToCluster(pgm_read_byte(&converter->cluster_short));
// uint8_t local_type_id = pgm_read_byte(&converter->type);
- if ((converter->name) && (0 == strcasecmp_P(key, converter->name))) {
+ if ((pgm_read_word(&converter->name_offset)) && (0 == strcasecmp_P(key, Z_strings + pgm_read_word(&converter->name_offset)))) {
// match name
// check if there is a conflict with cluster
// TODO