zigbee-herdsman-converters 14.0.632 → 14.0.634

package/converters/fromZigbee.js

@@ -706,30 +706,6 @@ const converters = {
             return result;
         },
     },
-    develco_metering: {
-        cluster: 'seMetering',
-        type: ['attributeReport', 'readResponse'],
-        convert: (model, msg, publish, options, meta) => {
-            const result = {};
-            if (msg.data.hasOwnProperty('develcoPulseConfiguration')) {
-                result[postfixWithEndpointName('pulse_configuration', msg, model, meta)] =
-                    msg.data['develcoPulseConfiguration'];
-            }
-
-            if (msg.data.hasOwnProperty('develcoInterfaceMode')) {
-                result[postfixWithEndpointName('interface_mode', msg, model, meta)] =
-                    constants.develcoInterfaceMode.hasOwnProperty(msg.data['develcoInterfaceMode']) ?
-                        constants.develcoInterfaceMode[msg.data['develcoInterfaceMode']] :
-                        msg.data['develcoInterfaceMode'];
-            }
-            if (msg.data.hasOwnProperty('status')) {
-                result['battery_low'] = (msg.data.status & 2) > 0;
-                result['check_meter'] = (msg.data.status & 1) > 0;
-            }
-
-            return result;
-        },
-    },
     electrical_measurement: {
         /**
          * When using this converter also add the following to the configure method of the device:
@@ -1927,49 +1903,6 @@ const converters = {
             return {...payload1, ...payload2};
         },
     },
-    develco_voc: {
-        cluster: 'develcoSpecificAirQuality',
-        type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('voc'), exposes.options.calibration('voc')],
-        convert: (model, msg, publish, options, meta) => {
-            const voc = parseFloat(msg.data['measuredValue']);
-            const vocProperty = postfixWithEndpointName('voc', msg, model, meta);
-
-            let airQuality;
-            const airQualityProperty = postfixWithEndpointName('air_quality', msg, model, meta);
-            if (voc <= 65) {
-                airQuality = 'excellent';
-            } else if (voc <= 220) {
-                airQuality = 'good';
-            } else if (voc <= 660) {
-                airQuality = 'moderate';
-            } else if (voc <= 2200) {
-                airQuality = 'poor';
-            } else if (voc <= 5500) {
-                airQuality = 'unhealthy';
-            } else if (voc > 5500) {
-                airQuality = 'out_of_range';
-            } else {
-                airQuality = 'unknown';
-            }
-            return {[vocProperty]: calibrateAndPrecisionRoundOptions(voc, options, 'voc'), [airQualityProperty]: airQuality};
-        },
-    },
-    develco_voc_battery: {
-        cluster: 'genPowerCfg',
-        type: ['attributeReport', 'readResponse'],
-        convert: (model, msg, publish, options, meta) => {
-            /*
-             * Per the technical documentation for AQSZB-110:
-             * To detect low battery the system can monitor the "BatteryVoltage" by setting up a reporting interval of every 12 hour.
-             * When a voltage of 2.5V is measured the battery should be replaced.
-             * Low batt LED indication–RED LED will blink twice every 60 second.
-             */
-            const result = converters.battery.convert(model, msg, publish, options, meta);
-            result.battery_low = (result.voltage <= 2500);
-            return result;
-        },
-    },
     tuya_temperature_humidity_sensor: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataReport', 'commandDataResponse'],
@@ -7818,39 +7751,6 @@ const converters = {
             return {action: `scene_${scenes[msg.data.level]}`};
         },
     },
-    develco_fw: {
-        cluster: 'genBasic',
-        type: ['attributeReport', 'readResponse'],
-        convert: (model, msg, publish, options, meta) => {
-            const result = {};
-            if (0x8000 in msg.data) {
-                const firmware = msg.data[0x8000].join('.');
-                result.current_firmware = firmware;
-                meta.device.softwareBuildID = firmware;
-            }
-
-            if (0x8020 in msg.data) {
-                meta.device.hardwareVersion = msg.data[0x8020].join('.');
-            }
-
-            return result;
-        },
-    },
-    develco_genbinaryinput: {
-        cluster: 'genBinaryInput',
-        type: ['attributeReport', 'readResponse'],
-        convert: (model, msg, publish, options, meta) => {
-            const result = {};
-            if (msg.data.hasOwnProperty('reliability')) {
-                const lookup = {0: 'no_fault_detected', 7: 'unreliable_other', 8: 'process_error'};
-                result.reliability = lookup[msg.data['reliability']];
-            }
-            if (msg.data.hasOwnProperty('statusFlags')) {
-                result.fault = (msg.data['statusFlags']===1);
-            }
-            return result;
-        },
-    },
     xiaomi_tvoc: {
         cluster: 'genAnalogInput',
         type: ['attributeReport', 'readResponse'],

package/converters/toZigbee.js

@@ -16,7 +16,6 @@ const manufacturerOptions = {
     osram: {manufacturerCode: herdsman.Zcl.ManufacturerCode.OSRAM},
     eurotronic: {manufacturerCode: herdsman.Zcl.ManufacturerCode.JENNIC},
     danfoss: {manufacturerCode: herdsman.Zcl.ManufacturerCode.DANFOSS},
-    develco: {manufacturerCode: herdsman.Zcl.ManufacturerCode.DEVELCO},
     hue: {manufacturerCode: herdsman.Zcl.ManufacturerCode.PHILIPS},
     ikea: {manufacturerCode: herdsman.Zcl.ManufacturerCode.IKEA_OF_SWEDEN},
     sinope: {manufacturerCode: herdsman.Zcl.ManufacturerCode.SINOPE_TECH},
@@ -3081,34 +3080,6 @@ const converters = {
             await entity.read('haDiagnostic', ['danfossMultimasterRole'], manufacturerOptions.danfoss);
         },
     },
-    develco_pulse_configuration: {
-        key: ['pulse_configuration'],
-        convertSet: async (entity, key, value, meta) => {
-            await entity.write('seMetering', {'develcoPulseConfiguration': value}, manufacturerOptions.develco);
-            return {readAfterWriteTime: 200, state: {'pulse_configuration': value}};
-        },
-        convertGet: async (entity, key, meta) => {
-            await entity.read('seMetering', ['develcoPulseConfiguration'], manufacturerOptions.develco);
-        },
-    },
-    develco_interface_mode: {
-        key: ['interface_mode'],
-        convertSet: async (entity, key, value, meta) => {
-            const payload = {'develcoInterfaceMode': utils.getKey(constants.develcoInterfaceMode, value, undefined, Number)};
-            await entity.write('seMetering', payload, manufacturerOptions.develco);
-            return {readAfterWriteTime: 200, state: {'interface_mode': value}};
-        },
-        convertGet: async (entity, key, meta) => {
-            await entity.read('seMetering', ['develcoInterfaceMode'], manufacturerOptions.develco);
-        },
-    },
-    develco_current_summation: {
-        key: ['current_summation'],
-        convertSet: async (entity, key, value, meta) => {
-            await entity.write('seMetering', {'develcoCurrentSummation': value}, manufacturerOptions.develco);
-            return {state: {'current_summation': value}};
-        },
-    },
     ZMCSW032D_cover_position: {
         key: ['position', 'tilt'],
         convertSet: async (entity, key, value, meta) => {

package/devices/develco.js

@@ -4,35 +4,247 @@ const tz = require('../converters/toZigbee');
 const constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
 const globalStore = require('../lib/store');
+const utils = require('../lib/utils');
 const ota = require('../lib/ota');
 const e = exposes.presets;
 const ea = exposes.access;
 
-const fzLocal = {
-    // SPLZB-134 and SPLZB-131 reports strange values sometimes
-    // https://github.com/Koenkk/zigbee2mqtt/issues/13329
-    develco_electrical_measurement: {
-        ...fz.electrical_measurement,
-        convert: (model, msg, publish, options, meta) => {
-            if (msg.data.rmsVoltage !== 0xFFFF && msg.data.rmsCurrent !== 0xFFFF && msg.data.activePower !== -0x8000) {
-                return fz.electrical_measurement.convert(model, msg, publish, options, meta);
-            }
+// develco specific cosntants
+const manufacturerOptions = {manufacturerCode: 0x1015};
+
+/* MOSZB-1xx - ledControl - bitmap8 - r/w
+ * 0x00 Disable LED when movement is detected.
+ * 0x01 Enables periodic fault flashes. These flashes are used to indicate e.g. low battery level.
+ * 0x02 Enables green application defined LED. This is e.g. used to indicate motion detection.
+ * Default value 0xFF ( seems to be fault + motion)
+ */
+const develcoLedControlMap = {
+    0x00: 'off',
+    0x01: 'fault_only',
+    0x02: 'motion_only',
+    0xFF: 'both',
+};
+
+// develco specific convertors
+const develco = {
+    fz: {
+        // SPLZB-134 and SPLZB-131 reports strange values sometimes
+        // https://github.com/Koenkk/zigbee2mqtt/issues/13329
+        electrical_measurement: {
+            ...fz.electrical_measurement,
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.data.rmsVoltage !== 0xFFFF && msg.data.rmsCurrent !== 0xFFFF && msg.data.activePower !== -0x8000) {
+                    return fz.electrical_measurement.convert(model, msg, publish, options, meta);
+                }
+            },
         },
-    },
-    develco_device_temperature: {
-        ...fz.device_temperature,
-        convert: (model, msg, publish, options, meta) => {
-            if (msg.data.currentTemperature !== -0x8000) {
-                return fz.device_temperature.convert(model, msg, publish, options, meta);
-            }
+        device_temperature: {
+            ...fz.device_temperature,
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.data.currentTemperature !== -0x8000) {
+                    return fz.device_temperature.convert(model, msg, publish, options, meta);
+                }
+            },
+        },
+        metering: {
+            ...fz.metering,
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.data.instantaneousDemand !== -0x800000) {
+                    return fz.metering.convert(model, msg, publish, options, meta);
+                }
+            },
+        },
+        pulse_configuration: {
+            cluster: 'seMetering',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                const result = {};
+                if (msg.data.hasOwnProperty('develcoPulseConfiguration')) {
+                    result[utils.postfixWithEndpointName('pulse_configuration', msg, model, meta)] =
+                        msg.data['develcoPulseConfiguration'];
+                }
+
+                return result;
+            },
+        },
+        interface_mode: {
+            cluster: 'seMetering',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                const result = {};
+                if (msg.data.hasOwnProperty('develcoInterfaceMode')) {
+                    result[utils.postfixWithEndpointName('interface_mode', msg, model, meta)] =
+                        constants.develcoInterfaceMode.hasOwnProperty(msg.data['develcoInterfaceMode']) ?
+                            constants.develcoInterfaceMode[msg.data['develcoInterfaceMode']] :
+                            msg.data['develcoInterfaceMode'];
+                }
+                if (msg.data.hasOwnProperty('status')) {
+                    result['battery_low'] = (msg.data.status & 2) > 0;
+                    result['check_meter'] = (msg.data.status & 1) > 0;
+                }
+
+                return result;
+            },
+        },
+        firmware_version: {
+            cluster: 'genBasic',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                const result = {};
+                if (0x8000 in msg.data) {
+                    const firmware = msg.data[0x8000].join('.');
+                    result.current_firmware = firmware;
+                    meta.device.softwareBuildID = firmware;
+                }
+
+                if (0x8020 in msg.data) {
+                    meta.device.hardwareVersion = msg.data[0x8020].join('.');
+                }
+
+                return result;
+            },
+        },
+        fault_status: {
+            cluster: 'genBinaryInput',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                const result = {};
+                if (msg.data.hasOwnProperty('reliability')) {
+                    const lookup = {0: 'no_fault_detected', 7: 'unreliable_other', 8: 'process_error'};
+                    result.reliability = lookup[msg.data['reliability']];
+                }
+                if (msg.data.hasOwnProperty('statusFlags')) {
+                    result.fault = (msg.data['statusFlags']===1);
+                }
+                return result;
+            },
+        },
+        voc: {
+            cluster: 'develcoSpecificAirQuality',
+            type: ['attributeReport', 'readResponse'],
+            options: [exposes.options.precision('voc'), exposes.options.calibration('voc')],
+            convert: (model, msg, publish, options, meta) => {
+                const voc = parseFloat(msg.data['measuredValue']);
+                const vocProperty = utils.postfixWithEndpointName('voc', msg, model, meta);
+
+                let airQuality;
+                const airQualityProperty = utils.postfixWithEndpointName('air_quality', msg, model, meta);
+                if (voc <= 65) {
+                    airQuality = 'excellent';
+                } else if (voc <= 220) {
+                    airQuality = 'good';
+                } else if (voc <= 660) {
+                    airQuality = 'moderate';
+                } else if (voc <= 2200) {
+                    airQuality = 'poor';
+                } else if (voc <= 5500) {
+                    airQuality = 'unhealthy';
+                } else if (voc > 5500) {
+                    airQuality = 'out_of_range';
+                } else {
+                    airQuality = 'unknown';
+                }
+                return {[vocProperty]: utils.calibrateAndPrecisionRoundOptions(voc, options, 'voc'), [airQualityProperty]: airQuality};
+            },
+        },
+        voc_battery: {
+            cluster: 'genPowerCfg',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                /*
+                 * Per the technical documentation for AQSZB-110:
+                 * To detect low battery the system can monitor the "BatteryVoltage" by setting up a reporting interval of every 12 hour.
+                 * When a voltage of 2.5V is measured the battery should be replaced.
+                 * Low batt LED indication–RED LED will blink twice every 60 second.
+                 */
+                const result = fz.battery.convert(model, msg, publish, options, meta);
+                result.battery_low = (result.voltage <= 2500);
+                return result;
+            },
+        },
+        led_control: {
+            cluster: 'genBasic',
+            type: ['attributeReport', 'readResponse'],
+            options: [],
+            convert: (model, msg, publish, options, meta) => {
+                const state = {};
+
+                if (msg.data.hasOwnProperty('develcoLedControl')) {
+                    state['led_control'] = develcoLedControlMap[msg.data['develcoLedControl']];
+                }
+
+                return state;
+            },
+        },
+        ias_occupancy_timeout: {
+            cluster: 'ssIasZone',
+            type: ['attributeReport', 'readResponse'],
+            options: [],
+            convert: (model, msg, publish, options, meta) => {
+                const state = {};
+
+                if (msg.data.hasOwnProperty('develcoAlarmOffDelay')) {
+                    state['occupancy_timeout'] = msg.data['develcoAlarmOffDelay'];
+                }
+
+                return state;
+            },
         },
     },
-    develco_metering: {
-        ...fz.metering,
-        convert: (model, msg, publish, options, meta) => {
-            if (msg.data.instantaneousDemand !== -0x800000) {
-                return fz.metering.convert(model, msg, publish, options, meta);
-            }
+    tz: {
+        pulse_configuration: {
+            key: ['pulse_configuration'],
+            convertSet: async (entity, key, value, meta) => {
+                await entity.write('seMetering', {'develcoPulseConfiguration': value}, manufacturerOptions);
+                return {readAfterWriteTime: 200, state: {'pulse_configuration': value}};
+            },
+            convertGet: async (entity, key, meta) => {
+                await entity.read('seMetering', ['develcoPulseConfiguration'], manufacturerOptions);
+            },
+        },
+        interface_mode: {
+            key: ['interface_mode'],
+            convertSet: async (entity, key, value, meta) => {
+                const payload = {'develcoInterfaceMode': utils.getKey(constants.develcoInterfaceMode, value, undefined, Number)};
+                await entity.write('seMetering', payload, manufacturerOptions.develco);
+                return {readAfterWriteTime: 200, state: {'interface_mode': value}};
+            },
+            convertGet: async (entity, key, meta) => {
+                await entity.read('seMetering', ['develcoInterfaceMode'], manufacturerOptions);
+            },
+        },
+        current_summation: {
+            key: ['current_summation'],
+            convertSet: async (entity, key, value, meta) => {
+                await entity.write('seMetering', {'develcoCurrentSummation': value}, manufacturerOptions);
+                return {state: {'current_summation': value}};
+            },
+        },
+        led_control: {
+            key: ['led_control'],
+            convertSet: async (entity, key, value, meta) => {
+                const ledControl = utils.getKey(develcoLedControlMap, value, value, Number);
+                await entity.write('genBasic', {'develcoLedControl': ledControl}, manufacturerOptions);
+                return {state: {led_control: value}};
+            },
+            convertGet: async (entity, key, meta) => {
+                await entity.read('genBasic', ['develcoLedControl'], manufacturerOptions);
+            },
+        },
+        ias_occupancy_timeout: {
+            key: ['occupancy_timeout'],
+            convertSet: async (entity, key, value, meta) => {
+                let timeoutValue = value;
+                if (timeoutValue < 20) {
+                    meta.logger.warn(`Minimum occupancy_timeout is 20, using 20 instead of ${timeoutValue}!`);
+                    timeoutValue = 20;
+                }
+                await entity.write('ssIasZone', {'develcoAlarmOffDelay': timeoutValue}, manufacturerOptions);
+                return {state: {occupancy_timeout: timeoutValue}};
+            },
+            convertGet: async (entity, key, meta) => {
+                await entity.read('ssIasZone', ['develcoAlarmOffDelay'], manufacturerOptions);
+            },
         },
     },
 };
@@ -43,7 +255,7 @@ module.exports = [
         model: 'SPLZB-131',
         vendor: 'Develco',
         description: 'Power plug',
-        fromZigbee: [fz.on_off, fzLocal.develco_electrical_measurement, fzLocal.develco_metering],
+        fromZigbee: [fz.on_off, develco.fz.electrical_measurement, develco.fz.metering],
         toZigbee: [tz.on_off],
         exposes: [e.switch(), e.power(), e.current(), e.voltage(), e.energy()],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -94,7 +306,7 @@ module.exports = [
         model: 'SPLZB-134',
         vendor: 'Develco',
         description: 'Power plug (type G)',
-        fromZigbee: [fz.on_off, fzLocal.develco_electrical_measurement, fzLocal.develco_metering, fzLocal.develco_device_temperature],
+        fromZigbee: [fz.on_off, develco.fz.electrical_measurement, develco.fz.metering, develco.fz.device_temperature],
         toZigbee: [tz.on_off],
         exposes: [e.switch(), e.power(), e.current(), e.voltage(), e.energy(), e.device_temperature()],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -144,13 +356,12 @@ module.exports = [
         model: 'EMIZB-132',
         vendor: 'Develco',
         description: 'Wattle AMS HAN power-meter sensor',
-        fromZigbee: [fzLocal.develco_metering, fzLocal.develco_electrical_measurement, fz.develco_fw],
+        fromZigbee: [develco.fz.metering, develco.fz.electrical_measurement, develco.fz.firmware_version],
         toZigbee: [tz.EMIZB_132_mode],
         ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
-            const options = {manufacturerCode: 4117};
-            await endpoint.read('genBasic', [0x8000, 0x8010, 0x8020], options);
+            await endpoint.read('genBasic', [0x8000, 0x8010, 0x8020], manufacturerOptions);
             await reporting.bind(endpoint, coordinatorEndpoint, ['haElectricalMeasurement', 'seMetering']);
 
             try {
@@ -186,17 +397,16 @@ module.exports = [
         vendor: 'Develco',
         description: 'Smoke detector with siren',
         fromZigbee: [fz.temperature, fz.battery, fz.ias_smoke_alarm_1_develco, fz.ignore_basic_report,
-            fz.develco_fw, fz.ias_enroll, fz.ias_wd, fz.develco_genbinaryinput],
+            develco.fz.firmware_version, fz.ias_enroll, fz.ias_wd, develco.fz.fault_status],
         toZigbee: [tz.warning, tz.ias_max_duration, tz.warning_simple],
         ota: ota.zigbeeOTA,
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {
-            const options = {manufacturerCode: 4117};
             const endpoint = device.getEndpoint(35);
 
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'ssIasZone', 'ssIasWd', 'genBasic', 'genBinaryInput']);
             await reporting.batteryVoltage(endpoint);
-            await endpoint.read('genBasic', [0x8000, 0x8010, 0x8020], options);
+            await endpoint.read('genBasic', [0x8000, 0x8010, 0x8020], manufacturerOptions);
             await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState', 'zoneId']);
             await endpoint.read('genBinaryInput', ['reliability', 'statusFlags']);
             await endpoint.read('ssIasWd', ['maxDuration']);
@@ -221,16 +431,15 @@ module.exports = [
         vendor: 'Develco',
         description: 'Fire detector with siren',
         fromZigbee: [fz.temperature, fz.battery, fz.ias_smoke_alarm_1_develco, fz.ignore_basic_report,
-            fz.develco_fw, fz.ias_enroll, fz.ias_wd, fz.develco_genbinaryinput],
+            develco.fz.firmware_version, fz.ias_enroll, fz.ias_wd, develco.fz.fault_status],
         toZigbee: [tz.warning, tz.ias_max_duration, tz.warning_simple],
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {
-            const options = {manufacturerCode: 4117};
             const endpoint = device.getEndpoint(35);
 
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'ssIasZone', 'ssIasWd', 'genBasic', 'genBinaryInput']);
             await reporting.batteryVoltage(endpoint);
-            await endpoint.read('genBasic', [0x8000], options);
+            await endpoint.read('genBasic', [0x8000], manufacturerOptions);
             await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState', 'zoneId']);
             await endpoint.read('genBinaryInput', ['reliability', 'statusFlags']);
             await endpoint.read('ssIasWd', ['maxDuration']);
@@ -249,15 +458,6 @@ module.exports = [
                 .withDescription('Indicates reason if any fault'),
             exposes.binary('fault', ea.STATE, true, false).withDescription('Indicates whether the device are in fault state')],
     },
-    {
-        zigbeeModel: ['MOSZB-130'],
-        model: 'MOSZB-130',
-        vendor: 'Develco',
-        description: 'Motion sensor',
-        fromZigbee: [fz.ias_occupancy_alarm_1],
-        toZigbee: [],
-        exposes: [e.occupancy(), e.battery_low(), e.tamper()],
-    },
     {
         zigbeeModel: ['WISZB-120'],
         model: 'WISZB-120',
@@ -285,22 +485,48 @@ module.exports = [
         toZigbee: [],
         exposes: [e.contact(), e.battery_low()],
     },
+    {
+        zigbeeModel: ['MOSZB-130'],
+        model: 'MOSZB-130',
+        vendor: 'Develco',
+        description: 'Motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_low(), e.tamper()],
+    },
     {
         zigbeeModel: ['MOSZB-140'],
         model: 'MOSZB-140',
         vendor: 'Develco',
         description: 'Motion sensor',
-        fromZigbee: [fz.temperature, fz.illuminance, fz.ias_occupancy_alarm_1, fz.battery],
-        toZigbee: [],
-        exposes: [e.occupancy(), e.battery(), e.battery_low(), e.tamper(), e.temperature(), e.illuminance_lux()],
+        fromZigbee: [
+            fz.temperature, fz.illuminance, fz.ias_occupancy_alarm_1, fz.battery,
+            develco.fz.led_control, develco.fz.ias_occupancy_timeout,
+        ],
+        toZigbee: [develco.tz.led_control, develco.tz.ias_occupancy_timeout],
+        exposes: [
+            e.occupancy(), e.battery(), e.battery_low(),
+            e.tamper(), e.temperature(), e.illuminance_lux(),
+            exposes.enum('led_control', ea.ALL, ['off', 'fault_only', 'motion_only', 'both']).
+                withDescription('Control LED indicator usage.'),
+            exposes.numeric('occupancy_timeout', ea.ALL).withUnit('second').withValueMin(20).withValueMax(65535),
+        ],
         meta: {battery: {voltageToPercentage: '3V_2500'}},
+        endpoint: (device) => {
+            return {default: 35};
+        },
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint1 = device.getEndpoint(35);
             await reporting.bind(endpoint1, coordinatorEndpoint, ['genPowerCfg']);
             await reporting.batteryVoltage(endpoint1, {min: constants.repInterval.HOUR, max: 43200, change: 100});
+            await endpoint1.read('genPowerCfg', ['batteryVoltage']);
+            await endpoint1.read('genBasic', ['develcoLedControl'], manufacturerOptions);
+            await endpoint1.read('ssIasZone', ['develcoAlarmOffDelay'], manufacturerOptions);
+
             const endpoint2 = device.getEndpoint(38);
             await reporting.bind(endpoint2, coordinatorEndpoint, ['msTemperatureMeasurement']);
             await reporting.temperature(endpoint2);
+
             const endpoint3 = device.getEndpoint(39);
             await reporting.bind(endpoint3, coordinatorEndpoint, ['msIlluminanceMeasurement']);
             await reporting.illuminance(endpoint3);
@@ -337,8 +563,8 @@ module.exports = [
         model: 'ZHEMI101',
         vendor: 'Develco',
         description: 'Energy meter',
-        fromZigbee: [fz.metering, fz.develco_metering],
-        toZigbee: [tz.develco_pulse_configuration, tz.develco_interface_mode, tz.develco_current_summation],
+        fromZigbee: [fz.metering, develco.fz.pulse_configuration, develco.fz.interface_mode],
+        toZigbee: [develco.tz.pulse_configuration, develco.tz.interface_mode, develco.tz.current_summation],
         endpoint: (device) => {
             return {'default': 2};
         },
@@ -401,7 +627,7 @@ module.exports = [
         model: 'AQSZB-110',
         vendor: 'Develco',
         description: 'Air quality sensor',
-        fromZigbee: [fz.develco_voc_battery, fz.develco_voc, fz.temperature, fz.humidity],
+        fromZigbee: [develco.fz.voc, develco.fz.voc_battery, fz.temperature, fz.humidity],
         toZigbee: [],
         exposes: [
             e.voc(), e.temperature(), e.humidity(),
@@ -414,11 +640,10 @@ module.exports = [
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(38);
-            const options = {manufacturerCode: 0x1015};
             await reporting.bind(endpoint, coordinatorEndpoint,
                 ['develcoSpecificAirQuality', 'msTemperatureMeasurement', 'msRelativeHumidity', 'genPowerCfg']);
             await endpoint.configureReporting('develcoSpecificAirQuality', [{attribute: 'measuredValue', minimumReportInterval: 60,
-                maximumReportInterval: 3600, reportableChange: 10}], options);
+                maximumReportInterval: 3600, reportableChange: 10}], manufacturerOptions);
             await reporting.temperature(endpoint, {min: constants.repInterval.MINUTE, max: constants.repInterval.MINUTES_10, change: 10});
             await reporting.humidity(endpoint, {min: constants.repInterval.MINUTE, max: constants.repInterval.MINUTES_10, change: 300});
             await reporting.batteryVoltage(endpoint, {min: constants.repInterval.HOUR, max: 43200, change: 100});
@@ -429,15 +654,14 @@ module.exports = [
         model: 'SIRZB-110',
         vendor: 'Develco Products A/S',
         description: 'Customizable siren',
-        fromZigbee: [fz.temperature, fz.battery, fz.ias_enroll, fz.ias_wd, fz.develco_fw, fz.ias_siren],
+        fromZigbee: [fz.temperature, fz.battery, fz.ias_enroll, fz.ias_wd, develco.fz.firmware_version, fz.ias_siren],
         toZigbee: [tz.warning, tz.warning_simple, tz.ias_max_duration, tz.squawk],
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {
-            const options = {manufacturerCode: 4117};
             const endpoint = device.getEndpoint(43);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'ssIasZone', 'ssIasWd', 'genBasic']);
             await reporting.batteryVoltage(endpoint);
-            await endpoint.read('genBasic', [0x8000], options);
+            await endpoint.read('genBasic', [0x8000], manufacturerOptions);
             await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState', 'zoneId']);
             await endpoint.read('ssIasWd', ['maxDuration']);
 

package/devices/hfh.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['On-Air Combi CTW,303-0136'],
+        model: '303-0136',
+        vendor: 'HFH Solutions',
+        description: 'LED controller',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [155, 495]}),
+    },
+];

package/devices/philips.js

@@ -700,6 +700,13 @@ module.exports = [
         description: 'Hue Flourish white and color ambiance table light with Bluetooth',
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
+    {
+        zigbeeModel: ['929003052601'],
+        model: '929003052601',
+        vendor: 'Philips',
+        description: 'Hue Flourish white and color ambiance table light with Bluetooth',
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+    },
     {
         zigbeeModel: ['LCG002'],
         model: '929001953101',
@@ -2803,7 +2810,7 @@ module.exports = [
         zigbeeModel: ['915005998101'],
         model: '915005998101',
         vendor: 'Philips',
-        description: 'Hue white ambiance ceiling black Enrave',
+        description: 'Hue white ambiance pendant black Enrave',
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
     },
     {
@@ -2813,4 +2820,11 @@ module.exports = [
         description: 'Hue Tuar outdoor wall light',
         extend: hueExtend.light_onoff_brightness(),
     },
+    {
+        zigbeeModel: ['915005998001'],
+        model: '915005998001',
+        vendor: 'Philips',
+        description: 'Hue white ambiance pendant white Enrave',
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
 ];

package/devices/tuya.js

@@ -897,6 +897,7 @@ module.exports = [
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_mzdax7ha'},
             {modelID: 'TS0505B', manufacturerName: '_TZB210_tmi0rihb'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_a4s41wm4'},
+            {modelID: 'TS0505B', manufacturerName: '_TZ3210_awrucboq'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_ijczzg9h'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_qxenlrin'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_iwbaamgh'},
@@ -907,7 +908,8 @@ module.exports = [
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_6amjviba'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3000_xr5m6kfg'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_xr5m6kfg'},
-            {modelID: 'TS0505B', manufacturerName: '_TZ3210_bf175wi4'}],
+            {modelID: 'TS0505B', manufacturerName: '_TZ3210_bf175wi4'},
+            {modelID: 'TS0505B', manufacturerName: '_TZB210_3zfp8mki'}],
         model: 'TS0505B',
         vendor: 'TuYa',
         description: 'Zigbee RGB+CCT light',
@@ -1137,8 +1139,6 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_ojzhk75b'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_swaamsoy'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_3p5ydos3'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_1agwnems'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_ip2akl4w'},
         ],
         model: 'TS0601_dimmer',
         vendor: 'TuYa',
@@ -1162,6 +1162,27 @@ module.exports = [
             {vendor: 'Moes', model: 'EDM-1ZBB-EU'},
         ],
     },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_ip2akl4w', '_TZE200_1agwnems']),
+        model: 'TS0601_dimmer_1',
+        vendor: 'TuYa',
+        description: 'Zigbee smart dimmer',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        configure: tuya.configureMagicPacket,
+        exposes: [tuya.exposes.lightBrightnessWithMinMax, tuya.exposes.powerOnBehavior, tuya.exposes.countdown, tuya.exposes.lightType],
+        meta: {
+            tuyaDatapoints: [
+                [1, 'state', tuya.valueConverter.onOff, {skip: tuya.skip.stateOnAndBrightnessPresent}],
+                [2, 'brightness', tuya.valueConverter.scale0_254to0_1000],
+                [3, 'min_brightness', tuya.valueConverter.scale0_254to0_1000],
+                [4, 'light_type', tuya.valueConverter.lightType],
+                [5, 'max_brightness', tuya.valueConverter.scale0_254to0_1000],
+                [6, 'countdown', tuya.valueConverter.countdown],
+                [14, 'power_on_behavior', tuya.valueConverter.powerOnBehavior],
+            ],
+        },
+    },
     {
         fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_oiymh3qu'}],
         model: 'TS011F_socket_module',

package/lib/ota/common.js

@@ -182,12 +182,12 @@ function sendQueryNextImageResponse(endpoint, image, logger) {
 }
 
 function imageNotify(endpoint) {
-    return endpoint.commandResponse('genOta', 'imageNotify', {payloadType: 0, queryJitter: 100});
+    return endpoint.commandResponse('genOta', 'imageNotify', {payloadType: 0, queryJitter: 100}, {sendWhen: 'immediate'});
 }
 
 async function requestOTA(endpoint) {
     // Some devices (e.g. Insta) take very long trying to discover the correct coordinator EP for OTA.
-    const queryNextImageRequest = endpoint.waitForCommand('genOta', 'queryNextImageRequest', null, 30000);
+    const queryNextImageRequest = endpoint.waitForCommand('genOta', 'queryNextImageRequest', null, 60000);
     try {
         await imageNotify(endpoint);
         return await queryNextImageRequest.promise;

package/lib/tuya.js

@@ -2,6 +2,10 @@
 
 const constants = require('./constants');
 const globalStore = require('./store');
+const exposes = require('./exposes');
+const utils = require('./utils');
+const e = exposes.presets;
+const ea = exposes.access;
 
 const dataTypes = {
     raw: 0, // [ bytes ]
@@ -1131,7 +1135,132 @@ async function sendDataPointStringBuffer(entity, dp, value, cmd, seq=undefined)
     );
 }
 
+const tuyaExposes = {
+    powerOnBehavior: exposes.enum('power_on_behavior', ea.STATE_SET, ['off', 'on', 'previous'])
+        .withDescription('Controls the behavior when the device is powered on'),
+    lightType: exposes.enum('light_type', ea.STATE_SET, ['led', 'incandescent', 'halogen'])
+        .withDescription('Type of light attached to the device'),
+    lightBrightnessWithMinMax: e.light_brightness().withMinBrightness().withMaxBrightness().setAccess(
+        'state', ea.STATE_SET).setAccess('brightness', ea.STATE_SET).setAccess(
+        'min_brightness', ea.STATE_SET).setAccess('max_brightness', ea.STATE_SET),
+    countdown: exposes.numeric('countdown', ea.STATE_SET).withValueMin(0).withValueMax(43200).withValueStep(1).withUnit('s')
+        .withDescription('Countdown to turn device off after a certain time'),
+};
+
+const skip = {
+    // Prevent state from being published when already ON and brightness is also published.
+    // This prevents 100% -> X% brightness jumps when the switch is already on
+    // https://github.com/Koenkk/zigbee2mqtt/issues/13800#issuecomment-1263592783
+    stateOnAndBrightnessPresent: (meta) => meta.message.hasOwnProperty('brightness') && meta.state.state === 'ON',
+};
+
+const configureMagicPacket = async (device, coordinatorEndpoint, logger) => {
+    const endpoint = device.endpoints[0];
+    await endpoint.read('genBasic', ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
+};
+
+const fingerprint = (modelID, manufacturerNames) => {
+    return manufacturerNames.map((manufacturerName) => {
+        return {modelID, manufacturerName};
+    });
+};
+
+const valueConverterBasic = {
+    lookup: (map) => {
+        return {
+            to: (v) => {
+                if (map[v] === undefined) throw new Error(`Value '${v}' is not allowed, expected one of ${Object.keys(map)}`);
+                return map[v];
+            },
+            from: (v) => {
+                const value = Object.entries(map).find((i) => i[1] === v);
+                if (!value) throw new Error(`Value '${v}' is not allowed, expected one of ${Object.values(map)}`);
+                return value[0];
+            },
+        };
+    },
+    scale: (min1, max1, min2, max2) => {
+        return {to: (v) => utils.mapNumberRange(v, min1, max1, min2, max2), from: (v) => utils.mapNumberRange(v, min2, max2, min1, max1)};
+    },
+    raw: () => {
+        return {to: (v) => v, from: (v) => v};
+    },
+    divideBy: (value) => {
+        return {to: (v) => v * value, from: (v) => v / value};
+    },
+};
+
+const valueConverter = {
+    trueFalse: valueConverterBasic.lookup({1: true, 0: false}),
+    onOff: valueConverterBasic.lookup({'ON': true, 'OFF': false}),
+    powerOnBehavior: valueConverterBasic.lookup({'off': 0, 'on': 1, 'previous': 2}),
+    lightType: valueConverterBasic.lookup({'led': 0, 'incandescent': 1, 'halogen': 2}),
+    countdown: valueConverterBasic.raw(),
+    scale0_254to0_1000: valueConverterBasic.scale(0, 254, 0, 1000),
+    scale0_1to0_1000: valueConverterBasic.scale(0, 1, 0, 1000),
+    divideBy100: valueConverterBasic.divideBy(100),
+};
+
+const tzDataPoints = {
+    key: ['state', 'brightness', 'min_brightness', 'max_brightness', 'power_on_behavior', 'countdown', 'light_type'],
+    convertSet: async (entity, key, value, meta) => {
+        // A set converter is only called once; therefore we need to loop
+        const state = {};
+        if (!meta.mapped.meta || !meta.mapped.meta.tuyaDatapoints) throw new Error('No datapoints map defined');
+        const datapoints = meta.mapped.meta.tuyaDatapoints;
+        for (const [key, value] of Object.entries(meta.message)) {
+            const convertedKey = meta.mapped.meta.multiEndpoint ? `${key}_${meta.endpoint_name}` : key;
+            const dpEntry = datapoints.find((d) => d[1] === convertedKey);
+            if (!dpEntry || !dpEntry[1]) {
+                throw new Error(`No datapoint defined for '${key}'`);
+            }
+            if (dpEntry[3] && dpEntry[3].skip && dpEntry[3].skip(meta)) continue;
+            const dpId = dpEntry[0];
+            const convertedValue = dpEntry[2].to(value);
+            if (typeof convertedValue === 'boolean') {
+                await sendDataPointBool(entity, dpId, convertedValue, 'dataRequest', 1);
+            } else if (typeof convertedValue === 'number') {
+                await sendDataPointValue(entity, dpId, convertedValue, 'dataRequest', 1);
+            } else {
+                throw new Error(`Don't know how to send type '${typeof convertedValue}'`);
+            }
+            state[convertedKey] = value;
+        }
+        return {state};
+    },
+};
+
+const fzDataPoints = {
+    cluster: 'manuSpecificTuya',
+    type: ['commandDataResponse', 'commandDataReport'],
+    convert: (model, msg, publish, options, meta) => {
+        const result = {};
+        if (!model.meta || !model.meta.tuyaDatapoints) throw new Error('No datapoints map defined');
+        const datapoints = model.meta.tuyaDatapoints;
+        for (const dpValue of msg.data.dpValues) {
+            const dpId = dpValue.dp;
+            const dpEntry = datapoints.find((d) => d[0] === dpId);
+            if (dpEntry) {
+                const value = getDataValue(dpValue);
+                result[dpEntry[1]] = dpEntry[2].from(value);
+            } else {
+                meta.logger.warn(`Datapoint ${dpId} not defined for '${meta.device.manufacturerName}' ` +
+                    `with data ${JSON.stringify(dpValue)}`);
+            }
+        }
+        return result;
+    },
+};
+
 module.exports = {
+    exposes: tuyaExposes,
+    skip,
+    configureMagicPacket,
+    fingerprint,
+    valueConverterBasic,
+    valueConverter,
+    tzDataPoints,
+    fzDataPoints,
     sendDataPoint,
     sendDataPoints,
     sendDataPointValue,

package/package.json

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