@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/schwaiger.js

@@ -0,0 +1,62 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['SPW35Z-D0'],
+        model: 'ZHS-15',
+        vendor: 'Schwaiger',
+        description: 'Power socket on/off with power consumption monitoring',
+        fromZigbee: [fz.on_off, fz.electrical_measurement],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.rmsVoltage(endpoint);
+            await reporting.rmsCurrent(endpoint);
+            await reporting.activePower(endpoint);
+        },
+        exposes: [e.switch(), e.power(), e.current(), e.voltage()],
+    },
+    {
+        zigbeeModel: ['ZBT-RGBWLight-GLS0844', 'HAL300'],
+        model: 'HAL300',
+        vendor: 'Schwaiger',
+        description: 'Tint LED bulb E27 806 lumen, dimmable, color, white 1800-6500K',
+        extend: extend.light_onoff_brightness_colortemp_color(),
+    },
+    {
+        zigbeeModel: ['ZBT-DIMLight-Candle0800'],
+        model: 'HAL600',
+        vendor: 'Schwaiger',
+        description: 'LED candle bulb E14 470 lumen, dimmable, color, white 2700K',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        fingerprint: [{modelID: 'ZBT-CCTLight-GU100904', manufacturerName: 'LDS'}],
+        model: 'HAL500',
+        vendor: 'Schwaiger',
+        description: 'LED bulb GU10 350 lumen, dimmable, color, white 2700-6500K',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+    },
+    {
+        zigbeeModel: ['ZBT-DIMLight-GU100800'],
+        model: 'HAL400',
+        vendor: 'Schwaiger',
+        description: 'LED Schwaiger HAL400 GU10 dimmable, warm white',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['ZBT-RGBWLight-C4700114'],
+        model: 'HAL800',
+        vendor: 'Schwaiger',
+        description: 'LED candle bulb E14 470 lumen, dimmable, color, white 1800-6500K',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555]}),
+    },
+];

package/devices/seastar_intelligence.js

@@ -0,0 +1,16 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['020B0B'],
+        model: '020B0B',
+        vendor: 'Fischer & Honsel',
+        description: 'LED Tischleuchte Beta Zig',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+        endpoint: (device) => {
+            // https://github.com/Koenkk/zigbee-herdsman-converters/issues/5463
+            const endpoint = device.endpoints.find((e) => e.inputClusters.includes(6)).ID;
+            return {'default': endpoint};
+        },
+    },
+];

package/devices/securifi.js

@@ -0,0 +1,39 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const ota = require('../lib/ota');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['PP-WHT-US'],
+        model: 'PP-WHT-US',
+        vendor: 'Securifi',
+        description: 'Peanut Smart Plug',
+        fromZigbee: [fz.on_off, fz.electrical_measurement],
+        toZigbee: [tz.on_off],
+        ota: ota.securifi,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
+            endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {
+                acVoltageMultiplier: 180, acVoltageDivisor: 39321, acCurrentMultiplier: 72,
+                acCurrentDivisor: 39321, acPowerMultiplier: 10255, acPowerDivisor: 39321});
+            await reporting.onOff(endpoint);
+            await reporting.rmsVoltage(endpoint, {change: 110}); // Voltage reports in 0.00458V
+            await reporting.rmsCurrent(endpoint, {change: 55}); // Current reports in 0.00183A
+            await reporting.activePower(endpoint, {change: 2}); // Power reports in 0.261W
+        },
+        exposes: [e.switch(), e.power(), e.current(), e.voltage()],
+    },
+    {
+        zigbeeModel: ['ZB2-BU01'],
+        model: 'B01M7Y8BP9',
+        vendor: 'Securifi',
+        description: 'Almond Click multi-function button',
+        fromZigbee: [fz.almond_click],
+        exposes: [e.action(['single', 'double', 'long'])],
+        toZigbee: [],
+    },
+];

package/devices/sengled.js

@@ -0,0 +1,332 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const ota = require('../lib/ota');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+// Make sure extend.ldight_* is not used (sengledExtend should be used instead)
+const extendDontUse = require('../lib/extend');
+const extend = {switch: extendDontUse.switch};
+const sengledExtend = {
+    light_onoff_brightness: (options={}) => extendDontUse.light_onoff_brightness(
+        {disableEffect: true, disablePowerOnBehavior: true, ...options}),
+    light_onoff_brightness_colortemp: (options={}) => extendDontUse.light_onoff_brightness_colortemp(
+        {disableEffect: true, disablePowerOnBehavior: true, ...options}),
+    light_onoff_brightness_colortemp_color: (options={}) =>
+        extendDontUse.light_onoff_brightness_colortemp_color({disableEffect: true, disablePowerOnBehavior: true, ...options}),
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['E13-N11'],
+        model: 'E13-N11',
+        vendor: 'Sengled',
+        description: 'Flood light with motion sensor light outdoor',
+        fromZigbee: sengledExtend.light_onoff_brightness().fromZigbee.concat([fz.ias_occupancy_alarm_1]),
+        toZigbee: sengledExtend.light_onoff_brightness().toZigbee,
+        exposes: sengledExtend.light_onoff_brightness().exposes.concat([e.occupancy()]),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E21-N13A'],
+        model: 'E21-N13A',
+        vendor: 'Sengled',
+        description: 'Smart LED (A19)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E21-N1EA'],
+        model: 'E21-N1EA',
+        vendor: 'Sengled',
+        description: 'Smart LED multicolor A19 bulb',
+        fromZigbee: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).toZigbee,
+        exposes: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).exposes.concat([e.power(), e.energy()]),
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]})
+                .configure(device, coordinatorEndpoint, logger);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['E12-N1E'],
+        model: 'E12-N1E',
+        vendor: 'Sengled',
+        description: 'Smart LED multicolor (BR30)',
+        fromZigbee: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).toZigbee,
+        exposes: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).exposes.concat([e.power(), e.energy()]),
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]})
+                .configure(device, coordinatorEndpoint, logger);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['E1G-G8E'],
+        model: 'E1G-G8E',
+        vendor: 'Sengled',
+        description: 'Multicolor light strip (2M)',
+        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E11-U21U31'],
+        model: 'E11-U21U31',
+        vendor: 'Sengled',
+        description: 'Element touch (A19)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E11-G13'],
+        model: 'E11-G13',
+        vendor: 'Sengled',
+        description: 'Element classic (A19)',
+        fromZigbee: sengledExtend.light_onoff_brightness().fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness().toZigbee,
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await sengledExtend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+        exposes: sengledExtend.light_onoff_brightness().exposes.concat([e.power(), e.energy()]),
+    },
+    {
+        zigbeeModel: ['E11-G23', 'E11-G33'],
+        model: 'E11-G23/E11-G33',
+        vendor: 'Sengled',
+        description: 'Element classic (A60)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E11-N13', 'E11-N13A', 'E11-N14', 'E11-N14A'],
+        model: 'E11-N13/E11-N13A/E11-N14/E11-N14A',
+        vendor: 'Sengled',
+        description: 'Element extra bright (A19)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['Z01-CIA19NAE26'],
+        model: 'Z01-CIA19NAE26',
+        vendor: 'Sengled',
+        description: 'Element touch (A19)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['Z01-A19NAE26'],
+        model: 'Z01-A19NAE26',
+        vendor: 'Sengled',
+        description: 'Element plus (A19)',
+        fromZigbee: sengledExtend.light_onoff_brightness_colortemp_color().fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness_colortemp_color().toZigbee,
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await sengledExtend.light_onoff_brightness_colortemp_color().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+        exposes: sengledExtend.light_onoff_brightness_colortemp_color().exposes.concat([e.power(), e.energy()]),
+    },
+    {
+        zigbeeModel: ['Z01-A60EAE27'],
+        model: 'Z01-A60EAE27',
+        vendor: 'Sengled',
+        description: 'Element Plus (A60)',
+        extend: sengledExtend.light_onoff_brightness_colortemp(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E11-N1EA'],
+        model: 'E11-N1EA',
+        vendor: 'Sengled',
+        description: 'Element plus color (A19)',
+        fromZigbee: sengledExtend.light_onoff_brightness_colortemp_color().fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness_colortemp_color().toZigbee,
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await sengledExtend.light_onoff_brightness_colortemp_color().configure(device, coordinatorEndpoint, logger);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+        exposes: sengledExtend.light_onoff_brightness_colortemp_color().exposes.concat([e.power(), e.energy()]),
+    },
+    {
+        zigbeeModel: ['E11-U2E'],
+        model: 'E11-U2E',
+        vendor: 'Sengled',
+        description: 'Element color plus E27',
+        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E11-U3E'],
+        model: 'E11-U3E',
+        vendor: 'Sengled',
+        description: 'Element color plus B22',
+        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E1F-N5E'],
+        model: 'E1F-N5E',
+        vendor: 'Sengled',
+        description: 'Element color plus E12',
+        fromZigbee: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).toZigbee,
+        exposes: sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).exposes.concat([e.power(), e.energy()]),
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]})
+                .configure(device, coordinatorEndpoint, logger);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['E12-N14'],
+        model: 'E12-N14',
+        vendor: 'Sengled',
+        description: 'Element Classic (BR30)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E1A-AC2'],
+        model: 'E1ACA4ABE38A',
+        vendor: 'Sengled',
+        description: 'Element downlight smart LED bulb',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E1D-G73'],
+        model: 'E1D-G73WNA',
+        vendor: 'Sengled',
+        description: 'Smart window and door sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        ota: ota.zigbeeOTA,
+        exposes: [e.contact(), e.battery_low(), e.battery(), e.battery_voltage(), e.tamper()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['E2D-G73'],
+        model: 'E2D-G73',
+        vendor: 'Sengled',
+        description: 'Smart window and door sensor G2',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        ota: ota.zigbeeOTA,
+        exposes: [e.contact(), e.battery_low(), e.battery(), e.battery_voltage(), e.tamper()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['E1C-NB6'],
+        model: 'E1C-NB6',
+        vendor: 'Sengled',
+        description: 'Smart plug',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E1C-NB7'],
+        model: 'E1C-NB7',
+        vendor: 'Sengled',
+        description: 'Smart plug with energy tracker',
+        fromZigbee: [fz.on_off, fz.metering],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+        },
+        exposes: [e.switch(), e.power(), e.energy()],
+    },
+    {
+        zigbeeModel: ['E1E-G7F'],
+        model: 'E1E-G7F',
+        vendor: 'Sengled',
+        description: 'Smart switch',
+        fromZigbee: [fz.E1E_G7F_action],
+        exposes: [e.action(['on', 'up', 'down', 'off', 'on_double', 'on_long', 'off_double', 'off_long'])],
+        toZigbee: [],
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E11-N1G'],
+        model: 'E11-N1G',
+        vendor: 'Sengled',
+        description: 'Vintage LED edison bulb (ST19)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['E1F-N9G'],
+        model: 'E1F-N9G',
+        vendor: 'Sengled',
+        description: 'Smart LED filament candle (E12)',
+        extend: sengledExtend.light_onoff_brightness(),
+        ota: ota.zigbeeOTA,
+    },
+];

package/devices/sercomm.js

@@ -0,0 +1,140 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['SZ-ESW01'],
+        model: 'SZ-ESW01',
+        vendor: 'Sercomm',
+        description: 'Telstra smart plug',
+        fromZigbee: [fz.on_off, fz.metering],
+        exposes: [e.switch(), e.power()],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+            endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 1000000, multiplier: 1});
+        },
+    },
+    {
+        zigbeeModel: ['SZ-ESW01-AU'],
+        model: 'SZ-ESW01-AU',
+        vendor: 'Sercomm',
+        description: 'Telstra smart plug',
+        exposes: [e.switch(), e.power(), e.energy(), e.current(), e.voltage()],
+        fromZigbee: [fz.on_off, fz.metering, fz.electrical_measurement],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 1000000, multiplier: 1});
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.rmsVoltage(endpoint);
+            await reporting.rmsCurrent(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['SZ-ESW02'],
+        model: 'SZ-ESW02',
+        vendor: 'Sercomm',
+        description: 'Telstra smart plug 2',
+        fromZigbee: [fz.on_off, fz.metering],
+        exposes: [e.switch(), e.power()],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+            endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 1000000, multiplier: 1});
+        },
+    },
+    {
+        zigbeeModel: ['XHS2-SE'],
+        model: 'XHS2-SE',
+        vendor: 'Sercomm',
+        description: 'Magnetic door & window contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.temperature, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'genPowerCfg']);
+            await reporting.temperature(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.temperature(), e.battery()],
+    },
+    {
+        zigbeeModel: ['SZ-DWS04', 'SZ-DWS04N_SF'],
+        model: 'SZ-DWS04',
+        vendor: 'Sercomm',
+        description: 'Magnetic door & window contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.temperature, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'genPowerCfg']);
+            await reporting.temperature(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.temperature(), e.battery()],
+    },
+    {
+        zigbeeModel: ['SZ-DWS08N', 'SZ-DWS08', 'SZ-DWS08N-CZ3'],
+        model: 'SZ-DWS08',
+        vendor: 'Sercomm',
+        description: 'Magnetic door & window contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.temperature, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'genPowerCfg']);
+            await reporting.temperature(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.temperature(), e.battery()],
+    },
+    {
+        zigbeeModel: ['SZ-PIR02_SF', 'SZ-PIR02'],
+        model: 'AL-PIR02',
+        vendor: 'Sercomm',
+        description: 'PIR motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['SZ-PIR04N', 'SZ-PIR04N_EU'],
+        model: 'SZ-PIR04N',
+        vendor: 'Sercomm',
+        description: 'PIR motion & temperature sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1, fz.illuminance, fz.temperature, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercent: '3V_2500_3200'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msIlluminanceMeasurement', 'msTemperatureMeasurement', 'genPowerCfg']);
+            await reporting.illuminance(endpoint);
+            await reporting.temperature(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.occupancy(), e.tamper(), e.illuminance(), e.temperature(), e.battery(), e.battery_voltage()],
+    },
+];

package/devices/shenzhen_homa.js

@@ -0,0 +1,53 @@
+const exposes = require('../lib/exposes');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['HOMA1008', '00A'],
+        model: 'HLD812-Z-SC',
+        vendor: 'Shenzhen Homa',
+        description: 'Smart LED driver',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['HOMA1009'],
+        model: 'HLD503-Z-CT',
+        vendor: 'Shenzhen Homa',
+        description: 'Smart LED driver',
+        extend: extend.light_onoff_brightness_colortemp(),
+    },
+    {
+        zigbeeModel: ['HOMA1002', 'HOMA0019', 'HOMA0006', 'HOMA000F', '019'],
+        model: 'HLC610-Z',
+        vendor: 'Shenzhen Homa',
+        description: 'Wireless dimmable controller',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['HOMA1031'],
+        model: 'HLC821-Z-SC',
+        vendor: 'Shenzhen Homa',
+        description: 'ZigBee AC phase-cut dimmer',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['HOMA1005'],
+        model: 'HLC614-ZLL',
+        vendor: 'Shenzhen Homa',
+        description: '3 channel relay module',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3')],
+        meta: {multiEndpoint: true},
+        endpoint: (device) => {
+            return {l1: 1, l2: 2, l3: 3};
+        },
+    },
+    {
+        zigbeeModel: ['HOMA1064', '012'],
+        model: 'HLC833-Z-SC',
+        vendor: 'Shenzhen Homa',
+        description: 'Wireless dimmable controller',
+        extend: extend.light_onoff_brightness(),
+    },
+];