zigbee-herdsman-converters 15.0.43 → 15.0.45

package/converters/fromZigbee.js

@@ -3068,6 +3068,21 @@ const converters = {
             }
         },
     },
+    livolo_pir_state: {
+        cluster: 'genPowerCfg',
+        type: ['raw'],
+        convert: (model, msg, publish, options, meta) => {
+            const stateHeader = Buffer.from([122, 209]);
+            if (msg.data.indexOf(stateHeader) === 0) {
+                if (msg.data[10] === 7) {
+                    const status = msg.data[14];
+                    return {
+                        occupancy: status & 1 ? true : false,
+                    };
+                }
+            }
+        },
+    },
     easycode_action: {
         cluster: 'closuresDoorLock',
         type: 'raw',
@@ -3126,6 +3141,11 @@ const converters = {
             [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,2,11]  left: 0, right: 0  (off)
             [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,1,11]  left: 1, right: 0  (left on)
             [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,0,11]  left: 0, right: 1  (right on)
+
+            pir sensor
+            [124,210,21,216,128,  225,52,225,34,0,75,18,0,  19,13,0]       after interview
+            [122,209,             245,94,225,34,0,75,18,0,  7,1,7,1,1,11]  occupancy: true
+            [122,209,             245,94,225,34,0,75,18,0,  7,1,7,1,0,11]  occupancy: false
             */
             const malformedHeader = Buffer.from([0x7c, 0xd2, 0x15, 0xd8, 0x00]);
             const infoHeader = Buffer.from([0x7c, 0xd2, 0x15, 0xd8, 0x80]);
@@ -3170,6 +3190,11 @@ const converters = {
                     meta.device.modelID = 'TI0001-cover';
                     meta.device.save();
                 }
+                if (msg.data.includes(Buffer.from([19, 13, 0]), 13)) {
+                    if (meta.logger) meta.logger.debug('Detected Livolo Pir Sensor');
+                    meta.device.modelID = 'TI0001-pir';
+                    meta.device.save();
+                }
             }
         },
     },
@@ -4125,123 +4150,6 @@ const converters = {
             }
         },
     },
-    haozee_thermostat: {
-        cluster: 'manuSpecificTuya',
-        type: ['commandDataResponse', 'commandDataReport'],
-        convert: (model, msg, publish, options, meta) => {
-            const dpValue = tuya.firstDpValue(msg, meta, 'haozee_thermostat');
-            const dp = dpValue.dp; // First we get the data point ID
-            const value = tuya.getDataValue(dpValue);
-            const presetLookup = {0: 'auto', 1: 'manual', 2: 'off', 3: 'on'};
-            const systemModeLookup = {0: 'auto', 1: 'auto', 2: 'off', 3: 'heat'};
-            switch (dp) {
-            case tuya.dataPoints.haozeeSystemMode:
-                return {preset: presetLookup[value], system_mode: systemModeLookup[value]};
-            case tuya.dataPoints.haozeeHeatingSetpoint:
-                return {current_heating_setpoint: (value / 10).toFixed(1)};
-            case tuya.dataPoints.haozeeLocalTemp:
-                return {local_temperature: (value / 10).toFixed(1)};
-            case tuya.dataPoints.haozeeBoostHeatingCountdown:
-                // quick heating countdown - not supported by this device
-                return {boost_heating_countdown: value};
-            case tuya.dataPoints.haozeeWindowDetection:
-                // window check
-                return {window_detection: value ? 'ON' : 'OFF'};
-            case tuya.dataPoints.haozeeWindowState:
-                // window state
-                return {window: value ? 'OPEN' : 'CLOSED'};
-            case tuya.dataPoints.haozeeChildLock:
-                return {child_lock: value ? 'LOCK' : 'UNLOCK'};
-            case tuya.dataPoints.haozeeBattery:
-                // battery
-                return {battery: value};
-            case tuya.dataPoints.haozeeFaultAlarm:
-                return {error: value ? 'ON': 'OFF'};
-            case tuya.dataPoints.haozeeScheduleMonday:
-                // Monday
-                return {
-                    'monday_schedule': ' ' + value[1] + 'h:' + value[2] + 'm ' + value[4] / 10 + '°C' +
-                        ',  ' + value[5] + 'h:' + value[6] + 'm ' + value[8] / 10 + '°C' +
-                        ',  ' + value[9] + 'h:' + value[10] + 'm ' + value[12] / 10 + '°C' +
-                        ',  ' + value[13] + 'h:' + value[14] + 'm ' + value[16] / 10 + '°C ',
-                };
-            case tuya.dataPoints.haozeeScheduleTuesday:
-                // Tuesday
-                return {
-                    'tuesday_schedule': ' ' + value[1] + 'h:' + value[2] + 'm ' + value[4] / 10 + '°C' +
-                        ',  ' + value[5] + 'h:' + value[6] + 'm ' + value[8] / 10 + '°C' +
-                        ',  ' + value[9] + 'h:' + value[10] + 'm ' + value[12] / 10 + '°C' +
-                        ',  ' + value[13] + 'h:' + value[14] + 'm ' + value[16] / 10 + '°C ',
-                };
-            case tuya.dataPoints.haozeeScheduleWednesday:
-                // wednesday
-                return {
-                    'wednesday_schedule': ' ' + value[1] + 'h:' + value[2] + 'm ' + value[4] / 10 + '°C' +
-                        ',  ' + value[5] + 'h:' + value[6] + 'm ' + value[8] / 10 + '°C' +
-                        ',  ' + value[9] + 'h:' + value[10] + 'm ' + value[12] / 10 + '°C' +
-                        ',  ' + value[13] + 'h:' + value[14] + 'm ' + value[16] / 10 + '°C ',
-                };
-            case tuya.dataPoints.haozeeScheduleThursday:
-                // Thursday
-                return {
-                    'thursday_schedule': ' ' + value[1] + 'h:' + value[2] + 'm ' + value[4] / 10 + '°C' +
-                        ',  ' + value[5] + 'h:' + value[6] + 'm ' + value[8] / 10 + '°C' +
-                        ',  ' + value[9] + 'h:' + value[10] + 'm ' + value[12] / 10 + '°C' +
-                        ',  ' + value[13] + 'h:' + value[14] + 'm ' + value[16] / 10 + '°C ',
-                };
-            case tuya.dataPoints.haozeeScheduleFriday:
-                // Friday
-                return {
-                    'friday_schedule': ' ' + value[1] + 'h:' + value[2] + 'm ' + value[4] / 10 + '°C' +
-                        ',  ' + value[5] + 'h:' + value[6] + 'm ' + value[8] / 10 + '°C' +
-                        ',  ' + value[9] + 'h:' + value[10] + 'm ' + value[12] / 10 + '°C' +
-                        ',  ' + value[13] + 'h:' + value[14] + 'm ' + value[16] / 10 + '°C ',
-                };
-            case tuya.dataPoints.haozeeScheduleSaturday:
-                // Saturday
-                return {
-                    'saturday_schedule': ' ' + value[1] + 'h:' + value[2] + 'm ' + value[4] / 10 + '°C' +
-                        ',  ' + value[5] + 'h:' + value[6] + 'm ' + value[8] / 10 + '°C' +
-                        ',  ' + value[9] + 'h:' + value[10] + 'm ' + value[12] / 10 + '°C' +
-                        ',  ' + value[13] + 'h:' + value[14] + 'm ' + value[16] / 10 + '°C ',
-                };
-            case tuya.dataPoints.haozeeScheduleSunday:
-
-                // Sunday
-                return {
-                    'sunday_schedule': ' ' + value[1] + 'h:' + value[2] + 'm ' + value[4] / 10 + '°C' +
-                        ',  ' + value[5] + 'h:' + value[6] + 'm ' + value[8] / 10 + '°C' +
-                        ',  ' + value[9] + 'h:' + value[10] + 'm ' + value[12] / 10 + '°C' +
-                        ',  ' + value[13] + 'h:' + value[14] + 'm ' + value[16] / 10 + '°C ',
-                };
-
-            case tuya.dataPoints.haozeeRunningState:
-                // working status 0 - pause 1 -working
-                return {'heating': value ? 'ON' : 'OFF'};
-            case tuya.dataPoints.haozeeBoostHeating:
-                // rapid heating -> boolean - not supported by this device
-                return {'boost_heating': value ? 'ON' : 'OFF'};
-            case tuya.dataPoints.haozeeTempCalibration:
-                // temperature calibration
-                return {'local_temperature_calibration': ( value/10 ).toFixed(1)};
-            case tuya.dataPoints.haozeeValvePosition:
-                // valve position
-                return {'position': ( value/10 ).toFixed(1)};
-            case tuya.dataPoints.haozeeMinTemp:
-                // lower limit temperature
-                return {'min_temperature': ( value/10 ).toFixed(1)};
-            case tuya.dataPoints.haozeeMaxTemp:
-                // max limit temperature
-                return {'max_temperature': ( value/10 ).toFixed(1)};
-            case tuya.dataPoints.haozeeSoftVersion:
-                // software
-                break;
-            default:
-                meta.logger.warn(`zigbee-herdsman-converters:haozee: NOT RECOGNIZED DP #${
-                    dp} with data ${JSON.stringify(dpValue)}`);
-            }
-        },
-    },
     tuya_air_quality: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataReport', 'commandDataResponse'],

package/converters/toZigbee.js

@@ -102,6 +102,12 @@ const converters = {
             await entity.read('genPowerCfg', ['batteryPercentageRemaining']);
         },
     },
+    battery_voltage: {
+        key: ['battery', 'voltage'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('genPowerCfg', ['batteryVoltage']);
+        },
+    },
     power_on_behavior: {
         key: ['power_on_behavior'],
         convertSet: async (entity, key, value, meta) => {
@@ -1260,7 +1266,12 @@ const converters = {
             if (val === undefined) {
                 val = utils.getKey(constants.thermostatControlSequenceOfOperations, value, value, Number);
             }
-            await entity.write('hvacThermostat', {ctrlSeqeOfOper: val});
+            const attributes = {ctrlSeqeOfOper: val};
+            await entity.write('hvacThermostat', attributes);
+            // NOTE: update the cluster attribute we store as this is used by
+            //       SMaBiT AV2010/32's dynamic expose function.
+            entity.saveClusterAttributeKeyValue('hvacThermostat', attributes);
+            return {readAfterWriteTime: 250, state: {control_sequence_of_operation: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['ctrlSeqeOfOper']);
@@ -3474,79 +3485,6 @@ const converters = {
             return tuya.sendDataPointRaw(entity, tuya.dataPoints.moesSschedule, payload);
         },
     },
-    haozee_thermostat_preset: {
-        key: ['preset'],
-        convertSet: async (entity, key, value, meta) => {
-            const lookup = {'auto': 0, 'manual': 1, 'off': 2, 'on': 3};
-            await tuya.sendDataPointEnum(entity, tuya.dataPoints.haozeeSystemMode, lookup[value]);
-        },
-    },
-    haozee_thermostat_system_mode: {
-        key: ['system_mode'],
-        convertSet: async (entity, key, value, meta) => {
-            // mapping 'heat' system mode to 100% heating (same as preset 'ON'),
-            // mapping 'auto' system mode to heating up to the set point temperature (same as preset 'MANUAL')
-            // mapping 'off' system mode to idle (same as preset 'OFF')
-            // programmed schedule can be enabled by using preset mode 'AUTO' instead of 'MANUAL'
-            const lookup = {'auto': 1, 'off': 2, 'heat': 3};
-            await tuya.sendDataPointEnum(entity, tuya.dataPoints.haozeeSystemMode, lookup[value]);
-        },
-    },
-    haozee_thermostat_current_heating_setpoint: {
-        key: ['current_heating_setpoint'],
-        convertSet: async (entity, key, value, meta) => {
-            const temp = Math.round(value*10);
-            await tuya.sendDataPointValue(entity, tuya.dataPoints.haozeeHeatingSetpoint, temp);
-        },
-    },
-    haozee_thermostat_boost_heating: {
-        key: ['boost_heating'],
-        convertSet: async (entity, key, value, meta) => {
-            await tuya.sendDataPointBool(entity, tuya.dataPoints.haozeeBoostHeating, value === 'ON');
-        },
-    },
-    haozee_thermostat_boost_heating_countdown: {
-        key: ['boost_heating_countdown'],
-        convertSet: async (entity, key, value, meta) => {
-            await tuya.sendDataPointValue(entity, tuya.dataPoints.haozeeBoostHeatingCountdown, value);
-        },
-    },
-    haozee_thermostat_window_detection: {
-        key: ['window_detection'],
-        convertSet: async (entity, key, value, meta) => {
-            await tuya.sendDataPointBool(entity, tuya.dataPoints.haozeeWindowDetection, value === 'ON');
-        },
-    },
-    haozee_thermostat_child_lock: {
-        key: ['child_lock'],
-        convertSet: async (entity, key, value, meta) => {
-            await tuya.sendDataPointBool(entity, tuya.dataPoints.haozeeChildLock, value === 'LOCK');
-        },
-    },
-    haozee_thermostat_temperature_calibration: {
-        key: ['local_temperature_calibration'],
-        convertSet: async (entity, key, value, meta) => {
-            let temp = Math.round(value * 10);
-            if (temp < 0) {
-                temp = 0xFFFFFFFF + temp + 1;
-            }
-            await tuya.sendDataPointValue(entity, tuya.dataPoints.haozeeTempCalibration, temp);
-        },
-    },
-    haozee_thermostat_max_temperature: {
-        key: ['max_temperature'],
-        convertSet: async (entity, key, value, meta) => {
-            const temp = Math.round(value*10);
-            await tuya.sendDataPointValue(entity, tuya.dataPoints.haozeeMaxTemp, temp);
-        },
-    },
-    haozee_thermostat_min_temperature: {
-        key: ['min_temperature'],
-        convertSet: async (entity, key, value, meta) => {
-            const temp = Math.round(value*10);
-            await tuya.sendDataPointValue(entity, tuya.dataPoints.haozeeMinTemp, temp);
-        },
-    },
     hgkg_thermostat_standby: {
         key: ['system_mode'],
         convertSet: async (entity, key, value, meta) => {

package/devices/bitron.js

@@ -4,6 +4,7 @@ const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
 const e = exposes.presets;
+const ea = exposes.access;
 
 module.exports = [
     {
@@ -190,13 +191,43 @@ module.exports = [
         vendor: 'SMaBiT (Bitron Video)',
         description: 'Wireless wall thermostat with relay',
         fromZigbee: [fz.legacy.thermostat_att_report, fz.battery, fz.hvac_user_interface],
-        toZigbee: [tz.thermostat_control_sequence_of_operation, tz.thermostat_occupied_heating_setpoint,
-            tz.thermostat_occupied_cooling_setpoint, tz.thermostat_local_temperature_calibration, tz.thermostat_local_temperature,
-            tz.thermostat_running_state, tz.thermostat_temperature_display_mode, tz.thermostat_keypad_lockout, tz.thermostat_system_mode],
-        exposes: [e.battery(), exposes.climate().withSetpoint('occupied_heating_setpoint', 7, 30, 0.5).withLocalTemperature()
-            .withSystemMode(['off', 'heat']).withRunningState(['idle', 'heat'])
-            .withLocalTemperatureCalibration(), e.keypad_lockout()],
-        meta: {battery: {voltageToPercentage: '3V_2500_3200'}},
+        toZigbee: [
+            tz.thermostat_control_sequence_of_operation, tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_occupied_cooling_setpoint, tz.thermostat_local_temperature_calibration,
+            tz.thermostat_local_temperature, tz.thermostat_running_state, tz.thermostat_temperature_display_mode,
+            tz.thermostat_keypad_lockout, tz.thermostat_system_mode, tz.battery_voltage,
+        ],
+        exposes: (device, options) => {
+            const dynExposes = [];
+            let ctrlSeqeOfOper = device ? device.getEndpoint(1).getClusterAttributeValue('hvacThermostat', 'ctrlSeqeOfOper') : null;
+            const modes = [];
+
+            // NOTE: ctrlSeqeOfOper defaults to 2 for this device (according to the manual)
+            if (ctrlSeqeOfOper == null) ctrlSeqeOfOper = 2;
+
+            // NOTE: set cool and/or heat support based on ctrlSeqeOfOper (see lib/constants -> thermostatControlSequenceOfOperations)
+            // WARN: a restart of zigbee2mqtt is required after changing ctrlSeqeOfOper for expose data to be re-calculated
+            if (ctrlSeqeOfOper >= 2) {
+                modes.push('heat');
+            }
+            if (ctrlSeqeOfOper < 2 || ctrlSeqeOfOper > 3) {
+                modes.push('cool');
+            }
+
+            dynExposes.push(exposes.climate()
+                .withSetpoint('occupied_heating_setpoint', 7, 30, 0.5)
+                .withLocalTemperature()
+                .withSystemMode(['off'].concat(modes))
+                .withRunningState(['idle'].concat(modes))
+                .withLocalTemperatureCalibration()
+                .withControlSequenceOfOperation(['heating_only', 'cooling_only'], ea.ALL));
+            dynExposes.push(e.keypad_lockout());
+            dynExposes.push(e.battery().withAccess(ea.STATE_GET));
+            dynExposes.push(e.battery_low());
+            dynExposes.push(e.linkquality());
+            return dynExposes;
+        },
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             const binds = [
@@ -204,12 +235,12 @@ module.exports = [
             ];
             await reporting.bind(endpoint, coordinatorEndpoint, binds);
             await reporting.thermostatTemperature(endpoint);
-            await reporting.thermostatTemperatureCalibration(endpoint);
             await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
             await reporting.thermostatOccupiedCoolingSetpoint(endpoint);
             await reporting.thermostatRunningState(endpoint);
             await reporting.batteryAlarmState(endpoint);
             await reporting.batteryVoltage(endpoint);
+            await endpoint.read('hvacThermostat', ['ctrlSeqeOfOper', 'localTemperatureCalibration']);
         },
     },
     {

package/devices/custom_devices_diy.js

@@ -473,7 +473,7 @@ module.exports = [
             await firstEndpoint.configureReporting('genPowerCfg', payload1);
         },
         exposes: [e.soil_moisture(), e.battery(), e.temperature(),
-            exposes.numeric('report_delay', ea.STATE_SET).withUnit('Minutes').withValueMin(1).withValueMax(240)
+            exposes.numeric('report_delay', ea.STATE_SET).withUnit('min').withValueMin(1).withValueMax(240)
                 .withDescription('Adjust Report Delay. Setting the time in minutes, by default 15 minutes')],
     },
     {
@@ -823,7 +823,7 @@ module.exports = [
             await reporting.batteryPercentageRemaining(endpoint, overides);
         },
         exposes: [e.battery(), e.temperature(), e.humidity(),
-            exposes.numeric('report_delay', ea.STATE_SET).withUnit('Minutes')
+            exposes.numeric('report_delay', ea.STATE_SET).withUnit('min')
                 .withDescription('Adjust Report Delay. Setting the time in minutes, by default 5 minutes')
                 .withValueMin(1).withValueMax(60),
             exposes.binary('enable_temperature', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable Temperature Control'),

package/devices/essentialb.js

@@ -8,11 +8,60 @@ module.exports = [
         description: 'Smart LED bulb',
         extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
     },
+    {
+        zigbeeModel: ['EB-E14-FLA-CCT'],
+        model: 'EB-E14-FLA-CCT',
+        vendor: 'EssentielB',
+        description: 'E14 flame CCT light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-A60-CCT-FC'],
+        model: 'EB-E27-A60-CCT-FC',
+        vendor: 'EssentielB',
+        description: 'E27 A60 CCT filament clear light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-A60-CCT'],
+        model: 'EB-E27-A60-CCT',
+        vendor: 'EssentielB',
+        description: 'E27 A60 CCT light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-A60-RGBW'],
+        model: 'EB-E27-A60-RGBW',
+        vendor: 'EssentielB',
+        description: 'E27 A60 RGBW light bulb',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-G95-CCT-FV'],
+        model: 'EB-E27-G95-CCT-FV',
+        vendor: 'EssentielB',
+        description: 'Filament vintage globe light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
     {
         zigbeeModel: ['EB-E27-ST64-CCT-FV'],
         model: 'EB-E27-ST64-CCT-FV',
         vendor: 'EssentielB',
-        description: 'Filament vintage light bulb',
-        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 454]}),
+        description: 'Filament vintage edison light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-GU10-MR16-CCT'],
+        model: 'EB-GU10-MR16-CCT',
+        vendor: 'EssentielB',
+        description: 'GU10 MR16 CCT light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-GU10-MR16-RGBW'],
+        model: 'EB-GU10-MR16-RGBW',
+        vendor: 'EssentielB',
+        description: 'GU10 MR16 RGBW light bulb',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
     },
 ];

package/devices/ewelink.js

@@ -22,7 +22,7 @@ module.exports = [
         model: 'SA-003-Zigbee',
         vendor: 'eWeLink',
         description: 'Zigbee smart plug',
-        extend: extend.switch(),
+        extend: extend.switch({disablePowerOnBehavior: true}),
         fromZigbee: [fz.on_off_skip_duplicate_transaction],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/frankever.js

@@ -17,7 +17,7 @@ module.exports = [
         exposes: [e.switch().setAccess('state', ea.STATE_SET),
             exposes.numeric('threshold', exposes.access.STATE_SET).withValueMin(0).withValueMax(100).withUnit('%')
                 .withDescription('Valve open percentage (multiple of 10)'),
-            exposes.numeric('timer', exposes.access.STATE_SET).withValueMin(0).withValueMax(600).withUnit('minutes')
+            exposes.numeric('timer', exposes.access.STATE_SET).withValueMin(0).withValueMax(600).withUnit('min')
                 .withDescription('Countdown timer in minutes')],
     },
 ];

package/devices/ikea.js

@@ -741,7 +741,6 @@ module.exports = [
             exposes.binary('illuminance_above_threshold', ea.STATE, true, false)
                 .withDescription('Indicates whether the device detected bright light (works only in night mode)')],
         ota: ota.tradfri,
-        meta: {battery: {dontDividePercentage: true}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);

package/devices/livolo.js

@@ -246,4 +246,41 @@ module.exports = [
             }
         },
     },
+    {
+        zigbeeModel: ['TI0001-pir'],
+        model: 'TI0001-pir',
+        description: 'Zigbee motion Sensor',
+        vendor: 'Livolo',
+        exposes: [
+            e.occupancy(),
+        ],
+        fromZigbee: [fz.livolo_pir_state],
+        toZigbee: [],
+        configure: poll,
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => await poll(device), 10*1000);
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+            if (data.cluster === 'genPowerCfg' && data.type === 'raw') {
+                const dp = data.data[10];
+                if (data.data[0] === 0x7a && data.data[1] === 0xd1) {
+                    const endpoint = device.getEndpoint(6);
+                    if (dp === 0x01) {
+                        const options = {manufacturerCode: 0x1ad2, disableDefaultResponse: true, disableResponse: true,
+                            reservedBits: 3, direction: 1, writeUndiv: true};
+                        const payload = {0x2002: {value: [0, 0, 0, 0, 0, 0, 0], type: 0x0e}};
+                        await endpoint.readResponse('genPowerCfg', 0xe9, payload, options);
+                    }
+                }
+            }
+        },
+    },
 ];

package/devices/lonsonho.js

@@ -27,7 +27,7 @@ module.exports = [
         description: 'Curtain switch',
         fromZigbee: [fz.cover_position_tilt, tuya.fz.backlight_mode_low_medium_high, fz.tuya_cover_options],
         toZigbee: [tz.cover_state, tz.cover_position_tilt, tz.tuya_cover_calibration, tz.tuya_cover_reversal,
-            tuya.tz.backlight_indicator_mode],
+            tuya.tz.backlight_indicator_mode_1],
         meta: {coverInverted: true},
         exposes: [e.cover_position(), exposes.enum('moving', ea.STATE, ['UP', 'STOP', 'DOWN']),
             exposes.binary('calibration', ea.ALL, 'ON', 'OFF'), exposes.binary('motor_reversal', ea.ALL, 'ON', 'OFF'),

package/devices/mercator.js

@@ -183,6 +183,10 @@ module.exports = [
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genIdentify', 'manuSpecificTuya', 'hvacFanCtrl']);
             await reporting.onOff(endpoint);
             await reporting.fanMode(endpoint);
+
+            // Device ships with {fanModeSequence: 1} which restricts physical speed
+            // button to low/high. Set to 0 to allow low/med/high from physical press.
+            await endpoint.write('hvacFanCtrl', {fanModeSequence: 0});
         },
     },
     {

package/devices/moes.js

@@ -308,9 +308,9 @@ module.exports = [
                 'You can set up to 4 stages of temperature every for WEEKDAY ➀➁➂➃➄,  SATURDAY ➅ and SUNDAY ➆.'),
             exposes.binary('boost_heating', ea.STATE_SET, 'ON', 'OFF').withDescription('Boost Heating: press and hold "+" for 3 seconds, ' +
                 'the device will enter the boost heating mode, and the ▷╵◁ will flash. The countdown will be displayed in the APP'),
-            exposes.numeric('boost_heating_countdown', ea.STATE).withUnit('minutes').withDescription('Countdown in minutes')
+            exposes.numeric('boost_heating_countdown', ea.STATE).withUnit('min').withDescription('Countdown in minutes')
                 .withValueMin(0).withValueMax(15),
-            exposes.numeric('boost_heating_countdown_time_set', ea.STATE_SET).withUnit('seconds')
+            exposes.numeric('boost_heating_countdown_time_set', ea.STATE_SET).withUnit('s')
                 .withDescription('Boost Time Setting 100 sec - 900 sec, (default = 300 sec)').withValueMin(100)
                 .withValueMax(900).withValueStep(100)],
     },

package/devices/namron.js

@@ -116,6 +116,7 @@ module.exports = [
         vendor: 'Namron',
         description: 'ZigBee dimmer 400W',
         extend: extend.light_onoff_brightness({noConfigure: true}),
+        ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);

package/devices/neo.js

@@ -19,7 +19,7 @@ module.exports = [
             exposes.binary('temperature_alarm', ea.STATE_SET, true, false),
             exposes.binary('alarm', ea.STATE_SET, true, false),
             exposes.enum('melody', ea.STATE_SET, Array.from(Array(18).keys()).map((x)=>(x+1).toString())),
-            exposes.numeric('duration', ea.STATE_SET).withUnit('second').withValueMin(0).withValueMax(1800),
+            exposes.numeric('duration', ea.STATE_SET).withUnit('s').withValueMin(0).withValueMax(1800),
             exposes.numeric('temperature_min', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(80),
             exposes.numeric('temperature_max', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(80),
             exposes.numeric('humidity_min', ea.STATE_SET).withUnit('%').withValueMin(1).withValueMax(100),
@@ -46,7 +46,7 @@ module.exports = [
             e.battery_low(),
             exposes.binary('alarm', ea.STATE_SET, true, false),
             exposes.enum('melody', ea.STATE_SET, Array.from(Array(18).keys()).map((x)=>(x+1).toString())),
-            exposes.numeric('duration', ea.STATE_SET).withUnit('second').withValueMin(0).withValueMax(1800),
+            exposes.numeric('duration', ea.STATE_SET).withUnit('s').withValueMin(0).withValueMax(1800),
             exposes.enum('volume', ea.STATE_SET, ['low', 'medium', 'high']),
             exposes.numeric('battpercentage', ea.STATE).withUnit('%'),
         ],