zigbee-herdsman-converters 15.0.69 → 15.0.71

package/devices/automaton.js

@@ -0,0 +1,44 @@
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const tuya = require('../lib/tuya');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        fingerprint: tuya.fingerprint('TS011F', ['_TZ3000_j0ktmul1']),
+        model: 'AUT000069',
+        vendor: 'AutomatOn',
+        description: 'Underfloor heating controller - 5 zones',
+        fromZigbee: [fz.on_off, fz.ignore_basic_report, tuya.fz.power_on_behavior_2, tuya.fz.child_lock],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_2, tuya.tz.child_lock],
+        exposes: [
+            e.child_lock(),
+            e.switch().withEndpoint('l1'),
+            e.switch().withEndpoint('l2'),
+            e.switch().withEndpoint('l3'),
+            e.switch().withEndpoint('l4'),
+            e.switch().withEndpoint('l5'),
+            e.power_on_behavior().withEndpoint('l1'),
+            e.power_on_behavior().withEndpoint('l2'),
+            e.power_on_behavior().withEndpoint('l3'),
+            e.power_on_behavior().withEndpoint('l4'),
+            e.power_on_behavior().withEndpoint('l5'),
+        ],
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4, 'l5': 5};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(5), coordinatorEndpoint, ['genOnOff']);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
+];

package/devices/casaia.js

@@ -39,6 +39,7 @@ module.exports = [
         fromZigbee: [fz.electrical_measurement, fz.metering, fz.on_off],
         toZigbee: [tz.on_off],
         exposes: [e.switch(), e.power(), e.energy()],
+        meta: {publishDuplicateTransaction: true},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);

package/devices/giex.js

@@ -1,135 +1,222 @@
 const exposes = require('../lib/exposes');
 const tuya = require('../lib/tuya');
-const e = exposes.presets;
-const ea = exposes.access;
+
+const {presets: ep, access: ea} = exposes;
+
+const CAPACITY = 'capacity';
+const DURATION = 'duration';
+const MINUTES_IN_A_DAY = 1440;
+const OFF = 'OFF';
+const ON = 'ON';
+const SAFETY_MIN_SECS = 10;
+const SECONDS_IN_12_HOURS = 43200;
+
+const toLocalTime = (time, timezone) => {
+    if (time === '--:--:--') {
+        return time;
+    }
+
+    const local = new Date(`2000-01-01T${time}.000${timezone}`); // Using 1970 instead produces edge cases
+    return local.toTimeString().split(' ').shift();
+};
+
+const keys = {
+    giexWaterValve: {
+        battery: 'battery',
+        currentTemperature: 'current_temperature',
+        cycleIrrigationInterval: 'cycle_irrigation_interval',
+        cycleIrrigationNumTimes: 'cycle_irrigation_num_times',
+        irrigationEndTime: 'irrigation_end_time',
+        irrigationStartTime: 'irrigation_start_time',
+        irrigationTarget: 'irrigation_target',
+        lastIrrigationDuration: 'last_irrigation_duration',
+        mode: 'mode',
+        state: 'state',
+        waterConsumed: 'water_consumed',
+    },
+};
 
 const dataPoints = {
-    // GIEX Water Valve
-    giexWaterValveState: 2,
-    giexWaterValveMode: 1,
-    giexWaterValveIrrigationTarget: 104,
-    giexWaterValveWaterConsumed: 111,
-    giexWaterValveIrrigationStartTime: 101,
-    giexWaterValveIrrigationEndTime: 102,
-    giexWaterValveLastIrrigationDuration: 114,
-    giexWaterValveBattery: 108,
-    giexWaterValveCycleIrrigationNumTimes: 103,
-    giexWaterValveCycleIrrigationInterval: 105,
-    giexWaterValveCurrentTempurature: 106,
+    giexWaterValve: {
+        battery: 108,
+        currentTemperature: 106,
+        cycleIrrigationInterval: 105,
+        cycleIrrigationNumTimes: 103,
+        irrigationEndTime: 102,
+        irrigationStartTime: 101,
+        irrigationTarget: 104,
+        lastIrrigationDuration: 114,
+        mode: 1,
+        state: 2,
+        waterConsumed: 111,
+    },
+};
+
+const fzModelConverters = {
+    QT06_1: {
+        // _TZE200_sh1btabb timezone is GMT+8
+        time: (value) => toLocalTime(value, '+08:00'),
+    },
 };
 
 const fzLocal = {
-    giex_water_valve:
-    {
+    giexWaterValve: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport'],
         convert: (model, msg, publish, options, meta) => {
+            const modelConverters = fzModelConverters[model.model] || {};
             for (const dpValue of msg.data.dpValues) {
                 const value = tuya.getDataValue(dpValue);
-                const dp = dpValue.dp;
+                const {dp} = dpValue;
                 switch (dp) {
-                case dataPoints.giexWaterValveState: {
-                    return {state: value ? 'ON': 'OFF'};
-                }
-                case dataPoints.giexWaterValveMode: {
-                    return {mode: value ? 'capacity': 'duration'};
-                }
-                case dataPoints.giexWaterValveIrrigationTarget: {
-                    return {irrigation_target: value};
-                }
-                case dataPoints.giexWaterValveCycleIrrigationNumTimes: {
-                    return {cycle_irrigation_num_times: value};
-                }
-                case dataPoints.giexWaterValveCycleIrrigationInterval: {
-                    return {cycle_irrigation_interval: value};
-                }
-                case dataPoints.giexWaterValveWaterConsumed: {
-                    return {water_consumed: value};
-                }
-                case dataPoints.giexWaterValveIrrigationStartTime: {
-                    return {irrigation_start_time: value};
-                }
-                case dataPoints.giexWaterValveIrrigationEndTime: {
-                    return {irrigation_end_time: value};
-                }
-                case dataPoints.giexWaterValveLastIrrigationDuration: {
-                    return {last_irrigation_duration: value};
-                }
-                case dataPoints.giexWaterValveBattery: {
-                    return {battery: value};
-                }
-                case dataPoints.giexWaterValveCurrentTempurature: {
-                    return; // Do Nothing - value ignored because isn't a valid tempurature reading.  Misdocumented and usage unclear
-                }
-                default: {
-                    meta.logger.warn(`fz:giex_water_valve: NOT RECOGNIZED DP #${dp} with VALUE = ${value}`);
-                }
+                case dataPoints.giexWaterValve.state:
+                    return {[keys.giexWaterValve.state]: value ? ON: OFF};
+                case dataPoints.giexWaterValve.mode:
+                    return {[keys.giexWaterValve.mode]: value ? CAPACITY: DURATION};
+                case dataPoints.giexWaterValve.irrigationTarget:
+                    return {[keys.giexWaterValve.irrigationTarget]: value};
+                case dataPoints.giexWaterValve.cycleIrrigationNumTimes:
+                    return {[keys.giexWaterValve.cycleIrrigationNumTimes]: value};
+                case dataPoints.giexWaterValve.cycleIrrigationInterval:
+                    return {[keys.giexWaterValve.cycleIrrigationInterval]: value};
+                case dataPoints.giexWaterValve.waterConsumed:
+                    return {[keys.giexWaterValve.waterConsumed]: value};
+                case dataPoints.giexWaterValve.irrigationStartTime:
+                    return {[keys.giexWaterValve.irrigationStartTime]: modelConverters.time?.(value) || value};
+                case dataPoints.giexWaterValve.irrigationEndTime:
+                    return {[keys.giexWaterValve.irrigationEndTime]: modelConverters.time?.(value) || value};
+                case dataPoints.giexWaterValve.lastIrrigationDuration:
+                    return {[keys.giexWaterValve.lastIrrigationDuration]: value.split(',').shift()}; // Remove meaningless ,0 suffix
+                case dataPoints.giexWaterValve.battery:
+                    return {[keys.giexWaterValve.battery]: value};
+                case dataPoints.giexWaterValve.currentTemperature:
+                    return; // Do Nothing - value ignored because it isn't a valid temperature reading (misdocumented and usage unclear)
+                default: // Unknown data point warning
+                    meta.logger.warn(`fzLocal.giexWaterValve: Unrecognized DP #${dp} with VALUE = ${value}`);
                 }
             }
         },
     },
 };
 
+const tzModelConverters = {
+    QT06_2: {
+        // _TZE200_a7sghmms irrigation time should not be less than 10 secs as per GiEX advice
+        irrigationTarget: (value, mode) => value > 0 && value < SAFETY_MIN_SECS && mode === DURATION ? SAFETY_MIN_SECS : value,
+    },
+};
+
 const tzLocal = {
-    giex_water_valve:
+    giexWaterValve:
     {
-        key: ['mode', 'irrigation_target', 'state', 'cycle_irrigation_num_times', 'cycle_irrigation_interval'],
+        key: [
+            keys.giexWaterValve.mode,
+            keys.giexWaterValve.irrigationTarget,
+            keys.giexWaterValve.state,
+            keys.giexWaterValve.cycleIrrigationNumTimes,
+            keys.giexWaterValve.cycleIrrigationInterval,
+        ],
         convertSet: async (entity, key, value, meta) => {
+            const modelConverters = tzModelConverters[meta.mapped?.model] || {};
             switch (key) {
-            case 'mode': {
-                let mode = 0;
-                if (value === 'duration') mode = 0;
-                else if (value === 'capacity') mode = 1;
-                await tuya.sendDataPointBool(entity, dataPoints.giexWaterValveMode, mode);
-                return {state: {mode: value}};
-            }
-            case 'irrigation_target':
-                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValveIrrigationTarget, value);
-                return {state: {irrigation_target: value}};
-            case 'state':
-                await tuya.sendDataPointBool(entity, dataPoints.giexWaterValveState, value === 'ON');
+            case keys.giexWaterValve.state:
+                await tuya.sendDataPointBool(entity, dataPoints.giexWaterValve.state, value === ON);
                 break;
-            case 'cycle_irrigation_num_times':
-                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValveCycleIrrigationNumTimes, value);
-                return {state: {cycle_irrigation_num_times: value}};
-            case 'cycle_irrigation_interval':
-                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValveCycleIrrigationInterval, value);
-                return {state: {cycle_irrigation_interval: value}};
+            case keys.giexWaterValve.mode:
+                await tuya.sendDataPointBool(entity, dataPoints.giexWaterValve.mode, value === CAPACITY);
+                return {state: {[keys.giexWaterValve.mode]: value}};
+            case keys.giexWaterValve.irrigationTarget: {
+                const mode = meta.state?.[keys.giexWaterValve.mode];
+                const sanitizedValue = modelConverters.irrigationTarget?.(value, mode) || value;
+                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValve.irrigationTarget, sanitizedValue);
+                return {state: {[keys.giexWaterValve.irrigationTarget]: sanitizedValue}};
+            }
+            case keys.giexWaterValve.cycleIrrigationNumTimes:
+                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValve.cycleIrrigationNumTimes, value);
+                return {state: {[keys.giexWaterValve.cycleIrrigationNumTimes]: value}};
+            case keys.giexWaterValve.cycleIrrigationInterval:
+                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValve.cycleIrrigationInterval, value);
+                return {state: {[keys.giexWaterValve.cycleIrrigationInterval]: value}};
             default: // Unknown key warning
-                meta.logger.warn(`tz.GIEX_water_valve: Unhandled key ${key}`);
+                meta.logger.warn(`tzLocal.giexWaterValve: Unhandled KEY ${key}`);
             }
         },
     },
 };
 
+const exportTemplates = {
+    giexWaterValve: {
+        vendor: 'GiEX',
+        description: 'Water irrigation valve',
+        onEvent: tuya.onEventSetLocalTime,
+        fromZigbee: [fzLocal.giexWaterValve],
+        toZigbee: [tzLocal.giexWaterValve],
+        exposes: [
+            ep.battery(),
+            exposes.binary(keys.giexWaterValve.state, ea.STATE_SET, ON, OFF)
+                .withDescription('State'),
+            exposes.enum(keys.giexWaterValve.mode, ea.STATE_SET, [DURATION, CAPACITY])
+                .withDescription('Irrigation mode'),
+            exposes.numeric(keys.giexWaterValve.cycleIrrigationNumTimes, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(100)
+                .withDescription('Number of cycle irrigation times, set to 0 for single cycle'),
+            exposes.numeric(keys.giexWaterValve.irrigationStartTime, ea.STATE)
+                .withDescription('Last irrigation start time'),
+            exposes.numeric(keys.giexWaterValve.irrigationEndTime, ea.STATE)
+                .withDescription('Last irrigation end time'),
+            exposes.numeric(keys.giexWaterValve.lastIrrigationDuration, ea.STATE)
+                .withDescription('Last irrigation duration'),
+            exposes.numeric(keys.giexWaterValve.waterConsumed, ea.STATE)
+                .withUnit('L')
+                .withDescription('Last irrigation water consumption'),
+        ],
+    },
+};
+
 module.exports = [
+    // _TZE200_sh1btabb uses minutes, timezone is GMT+8
     {
+        ...exportTemplates.giexWaterValve,
+        model: 'QT06_1',
         fingerprint: [
             {modelID: 'TS0601', manufacturerName: '_TZE200_sh1btabb'},
+        ],
+        exposes: [
+            ...exportTemplates.giexWaterValve.exposes,
+            exposes.numeric(keys.giexWaterValve.irrigationTarget, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(MINUTES_IN_A_DAY)
+                .withUnit('minutes or litres')
+                .withDescription('Irrigation target, duration in minutes or capacity in litres (depending on mode)'),
+            exposes.numeric(keys.giexWaterValve.cycleIrrigationInterval, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(MINUTES_IN_A_DAY)
+                .withUnit('min')
+                .withDescription('Cycle irrigation interval'),
+        ],
+    },
+    // _TZE200_a7sghmms uses seconds, timezone is local
+    {
+        ...exportTemplates.giexWaterValve,
+        model: 'QT06_2',
+        fingerprint: [
             {modelID: 'TS0601', manufacturerName: '_TZE200_a7sghmms'},
         ],
-        model: 'QT06',
-        vendor: 'GiEX',
-        description: 'Water irrigation valve',
-        onEvent: tuya.onEventSetLocalTime,
-        fromZigbee: [fzLocal.giex_water_valve],
-        toZigbee: [tzLocal.giex_water_valve],
         exposes: [
-            e.battery(),
-            exposes.binary('state', ea.STATE_SET, 'ON', 'OFF').withDescription('State'),
-            exposes.enum('mode', ea.STATE_SET, ['duration', 'capacity']).withDescription('Irrigation mode'),
-            exposes.numeric('irrigation_target', exposes.access.STATE_SET).withValueMin(0).withValueMax(3600).withUnit('seconds or litres')
-                .withDescription('Irrigation target, duration in seconds or capacity in litres (depending on mode)'),
-            exposes.numeric('cycle_irrigation_num_times', exposes.access.STATE_SET).withValueMin(0).withValueMax(100)
-                .withDescription('Number of cycle irrigation times, set to 0 for single cycle'),
-            exposes.numeric('cycle_irrigation_interval', exposes.access.STATE_SET).withValueMin(0).withValueMax(3600).withUnit('sec')
+            ...exportTemplates.giexWaterValve.exposes,
+            exposes.numeric(keys.giexWaterValve.irrigationTarget, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(SECONDS_IN_12_HOURS)
+                .withUnit('seconds or litres')
+                .withDescription('Irrigation target, duration in seconds or capacity in litres (depending on mode), ' +
+                    'set to 0 to leave the valve on indefinitely, ' +
+                    'for safety reasons the target will be forced to a minimum of 10 seconds in duration mode'),
+            exposes.numeric(keys.giexWaterValve.cycleIrrigationInterval, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(SECONDS_IN_12_HOURS)
+                .withUnit('sec')
                 .withDescription('Cycle irrigation interval'),
-            exposes.numeric('irrigation_start_time', ea.STATE).withDescription('Last irrigation start time (GMT)'),
-            exposes.numeric('irrigation_end_time', ea.STATE).withDescription('Last irrigation end time (GMT)'),
-            exposes.numeric('last_irrigation_duration', exposes.access.STATE)
-                .withDescription('Last irrigation duration'),
-            exposes.numeric('water_consumed', exposes.access.STATE).withUnit('L')
-                .withDescription('Last irrigation water consumption'),
         ],
     },
 ];

package/devices/girier.js

@@ -6,6 +6,7 @@ module.exports = [
         fingerprint: [
             {modelID: 'TS0001', manufacturerName: '_TZ3000_majwnphg'},
             {modelID: 'TS0001', manufacturerName: '_TZ3000_6axxqqi2'},
+            {modelID: 'TS0001', manufacturerName: '_TZ3000_zw7yf6yk'},
         ],
         model: 'JR-ZDS01',
         vendor: 'Girier',

package/devices/hzc.js

@@ -0,0 +1,21 @@
+const fz = require('../converters/fromZigbee');
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['WaterLeakageSensor-ZB3.0'],
+        model: 'S900W-ZG',
+        vendor: 'HZC',
+        description: 'Water leak sensor',
+        fromZigbee: [fz.ias_water_leak_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.water_leak(), e.battery_low(), e.battery()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+];

package/devices/lellki.js

@@ -121,7 +121,7 @@ module.exports = [
         extend: extend.switch(),
         fromZigbee: [fz.on_off_force_multiendpoint, fz.electrical_measurement, fz.metering, fz.ignore_basic_report,
             tuya.fz.power_outage_memory],
-        toZigbee: [tz.on_off, tuya.tz.power_on_behavior],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_1],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);

package/devices/owon.js

@@ -241,6 +241,7 @@ module.exports = [
                 device.save();
             }
         },
+        meta: {publishDuplicateTransaction: true},
         exposes: [e.energy(),
             exposes.numeric('voltage_l1', ea.STATE).withUnit('V').withDescription('Phase 1 voltage'),
             exposes.numeric('voltage_l2', ea.STATE).withUnit('V').withDescription('Phase 2 voltage'),

package/devices/tuya.js

@@ -133,20 +133,6 @@ const tzLocal = {
             return {state: {[key]: value}};
         },
     },
-    power_on_behavior: {
-        key: ['power_on_behavior'],
-        convertSet: async (entity, key, value, meta) => {
-            value = value.toLowerCase();
-            const lookup = {'off': 0, 'on': 1, 'previous': 2};
-            utils.validateValue(value, Object.keys(lookup));
-            const pState = lookup[value];
-            await entity.write('manuSpecificTuya_3', {'powerOnBehavior': pState}, {disableDefaultResponse: true});
-            return {state: {power_on_behavior: value}};
-        },
-        convertGet: async (entity, key, meta) => {
-            await entity.read('manuSpecificTuya_3', ['powerOnBehavior']);
-        },
-    },
     zb_sm_cover: {
         key: ['state', 'position', 'reverse_direction', 'top_limit', 'bottom_limit', 'favorite_position', 'goto_positon', 'report'],
         convertSet: async (entity, key, value, meta) => {
@@ -540,19 +526,6 @@ const fzLocal = {
             }
         },
     },
-    power_on_behavior: {
-        cluster: 'manuSpecificTuya_3',
-        type: ['attributeReport', 'readResponse'],
-        convert: (model, msg, publish, options, meta) => {
-            const attribute = 'powerOnBehavior';
-            const lookup = {0: 'off', 1: 'on', 2: 'previous'};
-
-            if (msg.data.hasOwnProperty(attribute)) {
-                const property = utils.postfixWithEndpointName('power_on_behavior', msg, model, meta);
-                return {[property]: lookup[msg.data[attribute]]};
-            }
-        },
-    },
     zb_sm_cover: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataReport', 'commandDataResponse'],
@@ -814,6 +787,7 @@ module.exports = [
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_bq5c8xfe'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_bjawzodf'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_qyflbnbj'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_9yapgbuv'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zl1kmjqx'}],
         model: 'TS0601_temperature_humidity_sensor',
         vendor: 'TuYa',
@@ -1719,7 +1693,6 @@ module.exports = [
             {modelID: 'TS0201', manufacturerName: '_TZ3000_yd2e749y'},
             {modelID: 'TS0201', manufacturerName: '_TZ3000_6uzkisv2'},
             {modelID: 'TS0201', manufacturerName: '_TZ3000_xr3htd96'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_9yapgbuv'},
         ],
         model: 'WSD500A',
         vendor: 'TuYa',
@@ -1918,7 +1891,7 @@ module.exports = [
         vendor: 'TuYa',
         fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report,
             tuya.fz.power_outage_memory, tuya.fz.switch_type],
-        toZigbee: [tz.on_off, tuya.tz.power_on_behavior, tuya.tz.switch_type],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_1, tuya.tz.switch_type],
         configure: async (device, coordinatorEndpoint, logger) => {
             await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
@@ -1963,9 +1936,9 @@ module.exports = [
         model: 'TS000F_power',
         description: 'Switch with power monitoring',
         vendor: 'TuYa',
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, tuya.fz.power_on_behavior,
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, tuya.fz.power_on_behavior_1,
             tuya.fz.switch_type],
-        toZigbee: [tz.on_off, tuya.tz.power_on_behavior, tuya.tz.switch_type],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_1, tuya.tz.switch_type],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
@@ -2593,7 +2566,7 @@ module.exports = [
         vendor: 'TuYa',
         fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, tuya.fz.power_outage_memory,
             tuya.fz.indicator_mode],
-        toZigbee: [tz.on_off, tuya.tz.power_on_behavior, tuya.tz.backlight_indicator_mode_1],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_1, tuya.tz.backlight_indicator_mode_1],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
@@ -3208,8 +3181,8 @@ module.exports = [
         model: 'TS0004',
         vendor: 'TuYa',
         description: 'Smart light switch - 4 gang with neutral wire',
-        fromZigbee: [fz.on_off, fzLocal.power_on_behavior, fz.ignore_basic_report],
-        toZigbee: [tz.on_off, tzLocal.power_on_behavior],
+        fromZigbee: [fz.on_off, tuya.fz.power_on_behavior_2, fz.ignore_basic_report],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_2],
         exposes: [e.switch().withEndpoint('l1'), e.power_on_behavior().withEndpoint('l1'), e.switch().withEndpoint('l2'),
             e.power_on_behavior().withEndpoint('l2'), e.switch().withEndpoint('l3'), e.power_on_behavior().withEndpoint('l3'),
             e.switch().withEndpoint('l4'), e.power_on_behavior().withEndpoint('l4')],
@@ -3414,7 +3387,7 @@ module.exports = [
         vendor: 'TuYa',
         fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, tuya.fz.power_outage_memory,
             fz.tuya_relay_din_led_indicator],
-        toZigbee: [tz.on_off, tuya.tz.power_on_behavior, tz.tuya_relay_din_led_indicator],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_1, tz.tuya_relay_din_led_indicator],
         whiteLabel: [{vendor: 'MatSee Plus', model: 'ATMS1602Z'}, {vendor: 'Tongou', model: 'TO-Q-SY1-JZT'}],
         ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -3440,7 +3413,7 @@ module.exports = [
         description: 'Din smart relay (without power monitoring)',
         vendor: 'TuYa',
         fromZigbee: [fz.on_off, fz.ignore_basic_report, tuya.fz.power_outage_memory, fz.tuya_relay_din_led_indicator],
-        toZigbee: [tz.on_off, tuya.tz.power_on_behavior, tz.tuya_relay_din_led_indicator],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior_1, tz.tuya_relay_din_led_indicator],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
@@ -3989,10 +3962,10 @@ module.exports = [
         vendor: 'TuYa',
         description: '1 channel dimmer',
         fromZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true, disableMoveStep: true, disableTransition: true})
-            .fromZigbee.concat([tuya.fz.power_on_behavior, fzLocal.TS110E_switch_type, fzLocal.TS110E]),
+            .fromZigbee.concat([tuya.fz.power_on_behavior_1, fzLocal.TS110E_switch_type, fzLocal.TS110E]),
         toZigbee: utils.replaceInArray(
             extend.light_onoff_brightness({disablePowerOnBehavior: true, disableMoveStep: true, disableTransition: true})
-                .toZigbee.concat([tuya.tz.power_on_behavior, tzLocal.TS110E_options]),
+                .toZigbee.concat([tuya.tz.power_on_behavior_1, tzLocal.TS110E_options]),
             [tz.light_onoff_brightness],
             [tzLocal.TS110E_light_onoff_brightness],
         ),
@@ -4009,8 +3982,8 @@ module.exports = [
         vendor: 'TuYa',
         description: '1 channel dimmer',
         whiteLabel: [{vendor: 'RTX', model: 'QS-Zigbee-D02-TRIAC-LN'}],
-        fromZigbee: [fzLocal.TS110E, fzLocal.TS110E_light_type, tuya.fz.power_on_behavior, fz.on_off],
-        toZigbee: [tzLocal.TS110E_onoff_brightness, tzLocal.TS110E_options, tuya.tz.power_on_behavior, tz.light_brightness_move],
+        fromZigbee: [fzLocal.TS110E, fzLocal.TS110E_light_type, tuya.fz.power_on_behavior_1, fz.on_off],
+        toZigbee: [tzLocal.TS110E_onoff_brightness, tzLocal.TS110E_options, tuya.tz.power_on_behavior_1, tz.light_brightness_move],
         exposes: [
             e.light_brightness().withMinBrightness().withMaxBrightness(),
             tuya.exposes.lightType().withAccess(ea.ALL), e.power_on_behavior().withAccess(ea.ALL)],
@@ -4027,10 +4000,10 @@ module.exports = [
         vendor: 'TuYa',
         description: '2 channel dimmer',
         fromZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true, disableMoveStep: true, disableTransition: true})
-            .fromZigbee.concat([tuya.fz.power_on_behavior, fzLocal.TS110E_switch_type, fzLocal.TS110E]),
+            .fromZigbee.concat([tuya.fz.power_on_behavior_1, fzLocal.TS110E_switch_type, fzLocal.TS110E]),
         toZigbee: utils.replaceInArray(
             extend.light_onoff_brightness({disablePowerOnBehavior: true, disableMoveStep: true, disableTransition: true})
-                .toZigbee.concat([tuya.tz.power_on_behavior, tzLocal.TS110E_options]),
+                .toZigbee.concat([tuya.tz.power_on_behavior_1, tzLocal.TS110E_options]),
             [tz.light_onoff_brightness],
             [tzLocal.TS110E_light_onoff_brightness],
         ),
@@ -4057,8 +4030,8 @@ module.exports = [
         model: 'TS110E_2gang_2',
         vendor: 'TuYa',
         description: '2 channel dimmer',
-        fromZigbee: [fzLocal.TS110E, fzLocal.TS110E_light_type, tuya.fz.power_on_behavior, fz.on_off],
-        toZigbee: [tzLocal.TS110E_onoff_brightness, tzLocal.TS110E_options, tuya.tz.power_on_behavior, tz.light_brightness_move],
+        fromZigbee: [fzLocal.TS110E, fzLocal.TS110E_light_type, tuya.fz.power_on_behavior_1, fz.on_off],
+        toZigbee: [tzLocal.TS110E_onoff_brightness, tzLocal.TS110E_options, tuya.tz.power_on_behavior_1, tz.light_brightness_move],
         meta: {multiEndpoint: true},
         exposes: [
             e.light_brightness().withMinBrightness().withMaxBrightness().withEndpoint('l1'),

package/devices/universal_electronics_inc.js

@@ -76,4 +76,44 @@ module.exports = [
             }
         },
     },
+    {
+        zigbeeModel: ['H34450BA00-00007'],
+        model: 'UEHK2AZ0',
+        vendor: 'Universal Electronics Inc',
+        description: 'Xfinity security keypad',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [
+            fz.command_arm_with_transaction, fz.temperature, fz.battery, fz.ias_occupancy_alarm_1,
+            fz.identify, fz.ias_contact_alarm_1, fz.ias_ace_occupancy_with_timeout,
+        ],
+        toZigbee: [tz.arm_mode],
+        exposes: [
+            e.battery(), e.battery_voltage(), e.occupancy(), e.battery_low(),
+            e.tamper(), e.presence(), e.contact(), e.temperature(),
+            exposes.numeric('action_code', ea.STATE).withDescription('Pin code introduced.'),
+            exposes.numeric('action_transaction', ea.STATE).withDescription('Last action transaction number.'),
+            exposes.text('action_zone', ea.STATE).withDescription('Alarm zone. Default value 0'),
+            e.action([
+                'disarm', 'arm_day_zones', 'identify', 'arm_night_zones', 'arm_all_zones', 'exit_delay', 'emergency',
+            ])],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            const clusters = ['msTemperatureMeasurement', 'genPowerCfg', 'ssIasZone', 'ssIasAce', 'genBasic', 'genIdentify'];
+            await reporting.bind(endpoint, coordinatorEndpoint, clusters);
+            await reporting.temperature(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+        onEvent: async (type, data, device) => {
+            if (type === 'message' && data.type === 'commandGetPanelStatus' && data.cluster === 'ssIasAce' &&
+                globalStore.hasValue(device.getEndpoint(1), 'panelStatus')) {
+                const payload = {
+                    panelstatus: globalStore.getValue(device.getEndpoint(1), 'panelStatus'),
+                    secondsremain: 0x00, audiblenotif: 0x00, alarmstatus: 0x00,
+                };
+                await device.getEndpoint(1).commandResponse(
+                    'ssIasAce', 'getPanelStatusRsp', payload, {}, data.meta.zclTransactionSequenceNumber,
+                );
+            }
+        },
+    },
 ];

package/lib/tuya.js

@@ -1519,7 +1519,7 @@ const valueConverter = {
 };
 
 const tuyaTz = {
-    power_on_behavior: {
+    power_on_behavior_1: {
         key: ['power_on_behavior', 'power_outage_memory'],
         convertSet: async (entity, key, value, meta) => {
             // Legacy: remove power_outage_memory
@@ -1534,6 +1534,20 @@ const tuyaTz = {
             await entity.read('genOnOff', ['moesStartUpOnOff']);
         },
     },
+    power_on_behavior_2: {
+        key: ['power_on_behavior'],
+        convertSet: async (entity, key, value, meta) => {
+            value = value.toLowerCase();
+            const lookup = {'off': 0, 'on': 1, 'previous': 2};
+            utils.validateValue(value, Object.keys(lookup));
+            const pState = lookup[value];
+            await entity.write('manuSpecificTuya_3', {'powerOnBehavior': pState});
+            return {state: {power_on_behavior: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificTuya_3', ['powerOnBehavior']);
+        },
+    },
     switch_type: {
         key: ['switch_type'],
         convertSet: async (entity, key, value, meta) => {
@@ -1675,7 +1689,7 @@ const tuyaFz = {
             await msg.endpoint.command('manuSpecificTuya', 'mcuGatewayConnectionStatus', payload, {});
         },
     },
-    power_on_behavior: {
+    power_on_behavior_1: {
         cluster: 'genOnOff',
         type: ['attributeReport', 'readResponse'],
         convert: (model, msg, publish, options, meta) => {
@@ -1686,6 +1700,18 @@ const tuyaFz = {
             }
         },
     },
+    power_on_behavior_2: {
+        cluster: 'manuSpecificTuya_3',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const attribute = 'powerOnBehavior';
+            const lookup = {0: 'off', 1: 'on', 2: 'previous'};
+            if (msg.data.hasOwnProperty(attribute)) {
+                const property = utils.postfixWithEndpointName('power_on_behavior', msg, model, meta);
+                return {[property]: lookup[msg.data[attribute]]};
+            }
+        },
+    },
     power_outage_memory: {
         cluster: 'genOnOff',
         type: ['attributeReport', 'readResponse'],
@@ -1830,11 +1856,11 @@ const tuyaExtend = {
         if (options.powerOutageMemory) {
             // Legacy, powerOnBehavior is preferred
             fromZigbee.push(tuyaFz.power_outage_memory);
-            toZigbee.push(tuyaTz.power_on_behavior);
+            toZigbee.push(tuyaTz.power_on_behavior_1);
             exposes.push(tuyaExposes.powerOutageMemory());
         } else {
-            fromZigbee.push(tuyaFz.power_on_behavior);
-            toZigbee.push(tuyaTz.power_on_behavior);
+            fromZigbee.push(tuyaFz.power_on_behavior_1);
+            toZigbee.push(tuyaTz.power_on_behavior_1);
             exposes.push(e.power_on_behavior());
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "15.0.69",
+  "version": "15.0.71",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [