zigbee-herdsman-converters 15.0.68 → 15.0.70

package/converters/toZigbee.js

@@ -2271,7 +2271,7 @@ const converters = {
     xiaomi_auto_off: {
         key: ['auto_off'],
         convertSet: async (entity, key, value, meta) => {
-            if (['ZNCZ04LM', 'ZNCZ12LM'].includes(meta.mapped.model)) {
+            if (['ZNCZ04LM', 'ZNCZ12LM', 'SP-EUC01'].includes(meta.mapped.model)) {
                 await entity.write('aqaraOpple', {0x0202: {value: value ? 1 : 0, type: 0x10}}, manufacturerOptions.xiaomi);
             } else if (['ZNCZ11LM'].includes(meta.mapped.model)) {
                 const payload = value ?
@@ -2284,6 +2284,13 @@ const converters = {
             }
             return {state: {auto_off: value}};
         },
+        convertGet: async (entity, key, meta) => {
+            if (['ZNCZ04LM', 'ZNCZ12LM', 'SP-EUC01'].includes(meta.mapped.model)) {
+                await entity.read('aqaraOpple', [0x0202], manufacturerOptions.xiaomi);
+            } else {
+                throw new Error('Not supported');
+            }
+        },
     },
     GZCGQ11LM_detection_period: {
         key: ['detection_period'],
@@ -2356,7 +2363,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             if (['ZNCZ04LM', 'ZNCZ12LM', 'ZNCZ15LM', 'QBCZ14LM', 'QBCZ15LM', 'QBKG19LM', 'QBKG20LM', 'QBKG25LM', 'QBKG26LM',
                 'QBKG28LM', 'QBKG31LM', 'QBKG34LM', 'DLKZMK11LM', 'SSM-U01', 'WS-EUK01', 'WS-EUK02',
-                'WS-EUK03', 'WS-EUK04'].includes(meta.mapped.model)) {
+                'WS-EUK03', 'WS-EUK04', 'SP-EUC01'].includes(meta.mapped.model)) {
                 await entity.write('aqaraOpple', {0x0203: {value: value ? 1 : 0, type: 0x10}}, manufacturerOptions.xiaomi);
             } else if (['ZNCZ11LM'].includes(meta.mapped.model)) {
                 const payload = value ?
@@ -2372,7 +2379,7 @@ const converters = {
         convertGet: async (entity, key, meta) => {
             if (['ZNCZ04LM', 'ZNCZ12LM', 'ZNCZ15LM', 'QBCZ15LM', 'QBCZ14LM', 'QBKG19LM', 'QBKG20LM', 'QBKG25LM', 'QBKG26LM',
                 'QBKG28LM', 'QBKG31LM', 'QBKG34LM', 'DLKZMK11LM', 'SSM-U01', 'WS-EUK01', 'WS-EUK02',
-                'WS-EUK03', 'WS-EUK04'].includes(meta.mapped.model)) {
+                'WS-EUK03', 'WS-EUK04', 'SP-EUC01'].includes(meta.mapped.model)) {
                 await entity.read('aqaraOpple', [0x0203], manufacturerOptions.xiaomi);
             } else {
                 throw new Error('Not supported');

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/bosch.js

@@ -49,7 +49,7 @@ const displayOrientation = {
 // Radiator Thermostat II
 const tzLocal = {
     bosch_thermostat: {
-        key: ['window_open', 'boost', 'system_mode'],
+        key: ['window_open', 'boost', 'system_mode', 'pi_heating_demand'],
         convertSet: async (entity, key, value, meta) => {
             if (key === 'window_open') {
                 value = value.toUpperCase();
@@ -66,7 +66,7 @@ const tzLocal = {
                 return {state: {boost: value}};
             }
             if (key === 'system_mode') {
-                // Map system_mode (Off/Auto/Heat) to Boschg operating mode
+                // Map system_mode (Off/Auto/Heat) to Bosch operating mode
                 value = value.toLowerCase();
 
                 let opMode = operatingModes.manual; // OperatingMode 1 = Manual (Default)
@@ -79,6 +79,12 @@ const tzLocal = {
                 await entity.write('hvacThermostat', {0x4007: {value: opMode, type: herdsman.Zcl.DataType.enum8}}, boschManufacturer);
                 return {state: {system_mode: value}};
             }
+            if (key === 'pi_heating_demand') {
+                await entity.write('hvacThermostat',
+                    {0x4020: {value: value, type: herdsman.Zcl.DataType.enum8}},
+                    boschManufacturer);
+                return {state: {pi_heating_demand: value}};
+            }
         },
         convertGet: async (entity, key, meta) => {
             switch (key) {
@@ -91,6 +97,9 @@ const tzLocal = {
             case 'system_mode':
                 await entity.read('hvacThermostat', [0x4007], boschManufacturer);
                 break;
+            case 'pi_heating_demand':
+                await entity.read('hvacThermostat', [0x4020], boschManufacturer);
+                break;
 
             default: // Unknown key
                 throw new Error(`Unhandled key toZigbee.bosch_thermostat.convertGet ${key}`);
@@ -426,7 +435,7 @@ const definition = [
                 .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5)
                 .withLocalTemperatureCalibration(-5, 5, 0.1)
                 .withSystemMode(['off', 'heat', 'auto'])
-                .withPiHeatingDemand(ea.STATE),
+                .withPiHeatingDemand(ea.ALL),
             exposes.binary('boost', ea.ALL, 'ON', 'OFF')
                 .withDescription('Activate Boost heating'),
             exposes.binary('window_open', ea.ALL, 'ON', 'OFF')
@@ -473,6 +482,13 @@ const definition = [
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: 1,
             }], boschManufacturer);
+            // report boost as it's disabled by thermostat after some time
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x4043, type: herdsman.Zcl.DataType.enum8},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 1,
+            }], boschManufacturer);
 
             await endpoint.read('hvacThermostat', ['localTemperatureCalibration']);
             await endpoint.read('hvacThermostat', [0x4007, 0x4020, 0x4042, 0x4043], boschManufacturer);

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/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/ledvance.js

@@ -8,7 +8,7 @@ module.exports = [
         model: '4058075208384',
         vendor: 'LEDVANCE',
         description: 'SMART+ Classic A60 E27 Tunable white',
-        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370], disablePowerOnBehavior: true}),
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
         ota: ota.ledvance,
     },
     {
@@ -55,7 +55,7 @@ module.exports = [
         model: 'AC25697',
         vendor: 'LEDVANCE',
         description: 'SMART+ CLASSIC MULTICOLOUR 60 10W E27',
-        extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500], disablePowerOnBehavior: true}),
+        extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
         ota: ota.ledvance,
     },
     {

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/osram.js

@@ -335,7 +335,7 @@ module.exports = [
         model: 'AC03648',
         vendor: 'OSRAM',
         description: 'SMART+ spot GU5.3 tunable white',
-        extend: extend.ledvance.light_onoff_brightness_colortemp({colorTempRange: [153, 370], disablePowerOnBehavior: true}),
+        extend: extend.ledvance.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
         ota: ota.ledvance,
     },
     {
@@ -412,7 +412,7 @@ module.exports = [
         model: '4062172044776_1',
         vendor: 'OSRAM',
         description: 'Zigbee 3.0 DALI CONV LI dimmer for DALI-based luminaires (only one device)',
-        extend: extend.ledvance.light_onoff_brightness({disablePowerOnBehavior: true}),
+        extend: extend.ledvance.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -425,7 +425,7 @@ module.exports = [
             fz.command_toggle, fz.command_move, fz.command_stop],
         extend: extend.ledvance.light_onoff_brightness({noConfigure: true}),
         exposes: [e.action(['toggle', 'brightness_move_up', 'brightness_move_down', 'brightness_stop']),
-            ...extend.ledvance.light_onoff_brightness({noConfigure: true, disablePowerOnBehavior: true}).exposes],
+            ...extend.ledvance.light_onoff_brightness({noConfigure: true}).exposes],
         ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
             await reporting.bind(device.getEndpoint(10), coordinatorEndpoint, ['genLevelCtrl', 'genOnOff']);

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/philips.js

@@ -2813,7 +2813,7 @@ module.exports = [
         extend: philips.extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
     {
-        zigbeeModel: ['915005997501', '915005997401'],
+        zigbeeModel: ['915005997501', '915005997401', '929003542401'],
         model: '915005997501',
         vendor: 'Philips',
         description: 'Hue Bluetooth white & color ambiance ceiling lamp Infuse large',

package/devices/smartwings.js

@@ -16,8 +16,8 @@ module.exports = [
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'closuresWindowCovering']);
-            await reporting.batteryPercentageRemaining(endpoint);
-            await reporting.currentPositionLiftPercentage(endpoint);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
         },
         exposes: [e.cover_position(), e.battery()],
     },

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'],
@@ -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/xiaomi.js

@@ -1927,10 +1927,8 @@ module.exports = [
         exposes: [
             e.switch(), e.power().withAccess(ea.STATE_GET), e.energy(), e.device_temperature().withAccess(ea.STATE),
             e.voltage(), e.current(), e.consumer_connected(), e.led_disabled_night(),
-            e.power_outage_memory(), exposes.binary('auto_off', ea.STATE_SET, true, false)
-                .withDescription('Turn the device automatically off when attached device consumes less than 2W for 20 minutes'),
-            exposes.numeric('overload_protection', exposes.access.ALL).withValueMin(100).withValueMax(2300).withUnit('W')
-                .withDescription('Maximum allowed load, turns off if exceeded')],
+            e.power_outage_memory(), e.auto_off(20),
+            e.overload_protection(100, 2300)],
         ota: ota.zigbeeOTA,
     },
     {
@@ -1944,10 +1942,8 @@ module.exports = [
         exposes: [
             e.switch(), e.power().withAccess(ea.STATE_GET), e.energy(), e.device_temperature().withAccess(ea.STATE),
             e.voltage(), e.current(), e.consumer_connected(), e.led_disabled_night(),
-            e.power_outage_memory(), exposes.binary('auto_off', ea.STATE_SET, true, false)
-                .withDescription('Turn the device automatically off when attached device consumes less than 2W for 20 minutes'),
-            exposes.numeric('overload_protection', exposes.access.ALL).withValueMin(100).withValueMax(2300).withUnit('W')
-                .withDescription('Maximum allowed load, turns off if exceeded')],
+            e.power_outage_memory(), e.auto_off(20),
+            e.overload_protection(100, 2300)],
         ota: ota.zigbeeOTA,
     },
     {
@@ -1957,7 +1953,8 @@ module.exports = [
         vendor: 'Xiaomi',
         fromZigbee: [fz.on_off, fz.xiaomi_basic, fz.electrical_measurement, fz.metering,
             fz.aqara_opple, fz.xiaomi_power, fz.device_temperature],
-        toZigbee: [tz.on_off, tz.xiaomi_switch_power_outage_memory],
+        toZigbee: [tz.on_off, tz.xiaomi_switch_power_outage_memory, tz.xiaomi_led_disabled_night,
+            tz.xiaomi_overload_protection, tz.xiaomi_auto_off, tz.xiaomi_socket_button_lock],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
@@ -2006,9 +2003,10 @@ module.exports = [
                 globalStore.putValue(device, 'interval', interval);
             }
         },
-        exposes: [e.switch(), e.power(), e.energy(), e.power_outage_memory(),
-            e.voltage(), e.current(),
-            e.device_temperature().withDescription('Device temperature (polled every 30 min)')],
+        exposes: [e.switch(), e.power(), e.energy(), e.power_outage_memory(), e.voltage(), e.current(),
+            e.device_temperature().withDescription('Device temperature (polled every 30 min)'),
+            e.consumer_connected(), e.led_disabled_night(), e.overload_protection(100, 2300),
+            e.auto_off(20), e.button_lock()],
         ota: ota.zigbeeOTA,
     },
     {
@@ -2021,9 +2019,7 @@ module.exports = [
             tz.xiaomi_switch_power_outage_memory, tz.xiaomi_auto_off],
         exposes: [e.switch(), e.power().withAccess(ea.STATE_GET), e.energy(), e.device_temperature(), e.voltage(),
             e.power_outage_memory(), e.led_disabled_night(),
-            exposes.binary('auto_off', ea.STATE_SET, true, false)
-                .withDescription('If the power is constantly lower than 2W within half an hour, ' +
-                    'the plug will be automatically turned off')],
+            e.auto_off(30)],
         onEvent: async (type, data, device) => {
             device.skipTimeResponse = true;
             // According to the Zigbee the genTime.time should be the seconds since 1 January 2020 UTC
@@ -2829,8 +2825,7 @@ module.exports = [
         exposes: [e.switch(), e.power().withAccess(ea.STATE), e.energy(), e.device_temperature().withAccess(ea.STATE),
             e.voltage(), e.current(), e.consumer_connected().withAccess(ea.STATE),
             e.power_outage_memory(), e.led_disabled_night(), e.button_lock(),
-            exposes.numeric('overload_protection', exposes.access.ALL).withValueMin(100).withValueMax(2500).withUnit('W')
-                .withDescription('Maximum allowed load, turns off if exceeded')],
+            e.overload_protection(100, 2500)],
         ota: ota.zigbeeOTA,
     },
     {
@@ -2900,8 +2895,7 @@ module.exports = [
             e.current(), e.power_outage_memory(), e.led_disabled_night(), e.button_lock(),
             exposes.enum('button_switch_mode', exposes.access.ALL, ['relay', 'relay_and_usb'])
                 .withDescription('Control both relay and usb or only the relay with the physical switch button'),
-            exposes.numeric('overload_protection', exposes.access.ALL).withValueMin(100).withValueMax(2500).withUnit('W')
-                .withDescription('Maximum allowed load, turns off if exceeded')],
+            e.overload_protection(100, 2500)],
         ota: ota.zigbeeOTA,
     },
     {
@@ -2927,8 +2921,7 @@ module.exports = [
             e.switch(), e.power().withAccess(ea.STATE), e.energy(),
             e.device_temperature().withAccess(ea.STATE), e.voltage(),
             e.current(), e.power_outage_memory(), e.led_disabled_night(), e.button_lock(),
-            exposes.numeric('overload_protection', exposes.access.ALL).withValueMin(100).withValueMax(2500).withUnit('W')
-                .withDescription('Maximum allowed load, turns off if exceeded')],
+            e.overload_protection(100, 2500)],
         ota: ota.zigbeeOTA,
     },
     {

package/lib/exposes.js

@@ -541,6 +541,7 @@ module.exports = {
         angle_axis: (name) => new Numeric(name, access.STATE).withValueMin(-90).withValueMax(90).withUnit('°'),
         aqi: () => new Numeric('aqi', access.STATE).withDescription('Air quality index'),
         auto_lock: () => new Switch().withState('auto_lock', false, 'Enable/disable auto lock', access.STATE_SET, 'AUTO', 'MANUAL'),
+        auto_off: (offTime) => new Binary('auto_off', access.ALL, true, false).withDescription(`Turn the device automatically off when attached device consumes less than 2W for ${offTime} minutes`),
         auto_relock_time: () => new Numeric('auto_relock_time', access.ALL).withValueMin(0).withUnit('s').withDescription('The number of seconds to wait after unlocking a lock before it automatically locks again. 0=disabled'),
         away_mode: () => new Switch().withState('away_mode', false, 'Enable/disable away mode', access.STATE_SET),
         away_preset_days: () => new Numeric('away_preset_days', access.STATE_SET).withDescription('Away preset days').withValueMin(0).withValueMax(100),
@@ -615,6 +616,7 @@ module.exports = {
         occupancy_level: () => new Numeric('occupancy_level', access.STATE).withDescription('The measured occupancy value'),
         open_window: () => new Binary('open_window', access.STATE_SET, 'ON', 'OFF').withDescription('Enables/disables the status on the device'),
         open_window_temperature: () => new Numeric('open_window_temperature', access.STATE_SET).withUnit('°C').withDescription('Open window temperature').withValueMin(0).withValueMax(35),
+        overload_protection: (min, max) => new Numeric('overload_protection', access.ALL).withUnit('W').withValueMin(min).withValueMax(max).withDescription('Maximum allowed load, turns off if exceeded'),
         pm10: () => new Numeric('pm10', access.STATE).withUnit('µg/m³').withDescription('Measured PM10 (particulate matter) concentration'),
         pm25: () => new Numeric('pm25', access.STATE).withUnit('µg/m³').withDescription('Measured PM2.5 (particulate matter) concentration'),
         position: () => new Numeric('position', access.STATE).withUnit('%').withDescription('Position'),

package/lib/extend.js

@@ -144,24 +144,36 @@ const extend = {
 };
 {
     extend.ledvance = {
-        light_onoff_brightness: (options={}) => ({
-            ...extend.light_onoff_brightness(options),
-            toZigbee: extend.light_onoff_brightness(options).toZigbee.concat([tz.ledvance_commands]),
-        }),
-        light_onoff_brightness_colortemp: (options={}) => ({
-            ...extend.light_onoff_brightness_colortemp({disableColorTempStartup: true, ...options}),
-            toZigbee: extend.light_onoff_brightness_colortemp({disableColorTempStartup: true, ...options})
-                .toZigbee.concat([tz.ledvance_commands]),
-        }),
-        light_onoff_brightness_color: (options={}) => ({
-            ...extend.light_onoff_brightness_color({supportsHS: true, ...options}),
-            toZigbee: extend.light_onoff_brightness_color({supportsHS: true, ...options}).toZigbee.concat([tz.ledvance_commands]),
-        }),
-        light_onoff_brightness_colortemp_color: (options={}) => ({
-            ...extend.light_onoff_brightness_colortemp_color({supportsHS: true, disableColorTempStartup: true, ...options}),
-            toZigbee: extend.light_onoff_brightness_colortemp_color({supportsHS: true, disableColorTempStartup: true, ...options})
-                .toZigbee.concat([tz.ledvance_commands]),
-        }),
+        light_onoff_brightness: (options={}) => {
+            options = {disablePowerOnBehavior: true, ...options};
+            return {
+                ...extend.light_onoff_brightness(options),
+                toZigbee: extend.light_onoff_brightness(options).toZigbee.concat([tz.ledvance_commands]),
+            };
+        },
+        light_onoff_brightness_colortemp: (options={}) => {
+            options = {disablePowerOnBehavior: true, ...options};
+            return {
+                ...extend.light_onoff_brightness_colortemp({disableColorTempStartup: true, ...options}),
+                toZigbee: extend.light_onoff_brightness_colortemp({disableColorTempStartup: true, ...options})
+                    .toZigbee.concat([tz.ledvance_commands]),
+            };
+        },
+        light_onoff_brightness_color: (options={}) => {
+            options = {disablePowerOnBehavior: true, ...options};
+            return {
+                ...extend.light_onoff_brightness_color({supportsHS: true, ...options}),
+                toZigbee: extend.light_onoff_brightness_color({supportsHS: true, ...options}).toZigbee.concat([tz.ledvance_commands]),
+            };
+        },
+        light_onoff_brightness_colortemp_color: (options={}) => {
+            options = {disablePowerOnBehavior: true, ...options};
+            return {
+                ...extend.light_onoff_brightness_colortemp_color({supportsHS: true, disableColorTempStartup: true, ...options}),
+                toZigbee: extend.light_onoff_brightness_colortemp_color({supportsHS: true, disableColorTempStartup: true, ...options})
+                    .toZigbee.concat([tz.ledvance_commands]),
+            };
+        },
     };
 }
 

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/lib/xiaomi.js

@@ -552,7 +552,7 @@ const numericAttributes2Payload = async (msg, meta, model, options, dataObject)
             }
             break;
         case '512':
-            if (['ZNCZ15LM', 'QBCZ14LM', 'QBCZ15LM'].includes(model.model)) {
+            if (['ZNCZ15LM', 'QBCZ14LM', 'QBCZ15LM', 'SP-EUC01'].includes(model.model)) {
                 payload.button_lock = value === 1 ? 'OFF' : 'ON';
             } else {
                 const mode = {0x01: 'control_relay', 0x00: 'decoupled'}[value];

package/package.json

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