@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/sonoff.js

@@ -0,0 +1,262 @@
+const exposes = require('../lib/exposes');
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const constants = require('../lib/constants');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+const ea = exposes.access;
+const ota = require('../lib/ota');
+
+const fzLocal = {
+    router_config: {
+        cluster: 'genLevelCtrl',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('currentLevel')) {
+                result.light_indicator_level = msg.data['currentLevel'];
+            }
+        },
+    },
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['BASICZBR3'],
+        model: 'BASICZBR3',
+        vendor: 'SONOFF',
+        description: 'Zigbee smart switch',
+        extend: extend.switch({disablePowerOnBehavior: true}),
+        fromZigbee: [fz.on_off_skip_duplicate_transaction],
+    },
+    {
+        zigbeeModel: ['ZBMINI-L'],
+        model: 'ZBMINI-L',
+        vendor: 'SONOFF',
+        description: 'Zigbee smart switch (no neutral)',
+        ota: ota.zigbeeOTA,
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            // Unbind genPollCtrl to prevent device from sending checkin message.
+            // Zigbee-herdsmans responds to the checkin message which causes the device
+            // to poll slower.
+            // https://github.com/Koenkk/zigbee2mqtt/issues/11676
+            await device.getEndpoint(1).unbind('genPollCtrl', coordinatorEndpoint);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
+    {
+        zigbeeModel: ['ZBMINIL2'],
+        model: 'ZBMINIL2',
+        vendor: 'SONOFF',
+        description: 'Zigbee smart switch (no neutral)',
+        ota: ota.zigbeeOTA,
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            // Unbind genPollCtrl to prevent device from sending checkin message.
+            // Zigbee-herdsmans responds to the checkin message which causes the device
+            // to poll slower.
+            // https://github.com/Koenkk/zigbee2mqtt/issues/11676
+            await device.getEndpoint(1).unbind('genPollCtrl', coordinatorEndpoint);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
+    {
+        zigbeeModel: ['01MINIZB'],
+        model: 'ZBMINI',
+        vendor: 'SONOFF',
+        description: 'Zigbee two way smart switch',
+        extend: extend.switch({disablePowerOnBehavior: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            // Has Unknown power source: https://github.com/Koenkk/zigbee2mqtt/issues/5362, force it here.
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
+    {
+        zigbeeModel: ['S31 Lite zb'],
+        model: 'S31ZB',
+        vendor: 'SONOFF',
+        description: 'Zigbee smart plug (US version)',
+        extend: extend.switch({disablePowerOnBehavior: true}),
+        fromZigbee: [fz.on_off_skip_duplicate_transaction],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+    {
+        fingerprint: [
+            // ModelID is from the temperature/humidity sensor (SNZB-02) but this is SNZB-04, wrong modelID in firmware?
+            // https://github.com/Koenkk/zigbee-herdsman-converters/issues/1449
+            {type: 'EndDevice', manufacturerName: 'eWeLink', modelID: 'TH01', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 1026, inputClusters: [0, 3, 1280, 1], outputClusters: [3]},
+            ]},
+        ],
+        zigbeeModel: ['DS01'],
+        model: 'SNZB-04',
+        vendor: 'SONOFF',
+        whiteLabel: [{vendor: 'eWeLink', model: 'RHK06'}],
+        description: 'Contact sensor',
+        exposes: [e.contact(), e.battery_low(), e.battery(), e.battery_voltage()],
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint, {min: 3600, max: 7200});
+            await reporting.batteryPercentageRemaining(endpoint, {min: 3600, max: 7200});
+        },
+    },
+    {
+        zigbeeModel: ['WB01', 'WB-01'],
+        model: 'SNZB-01',
+        vendor: 'SONOFF',
+        whiteLabel: [{vendor: 'eWeLink', model: 'RHK07'}],
+        description: 'Wireless button',
+        exposes: [e.battery(), e.action(['single', 'double', 'long']), e.battery_voltage()],
+        fromZigbee: [fz.ewelink_action, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genPowerCfg']);
+            await reporting.batteryVoltage(endpoint, {min: 3600, max: 7200});
+            await reporting.batteryPercentageRemaining(endpoint, {min: 3600, max: 7200});
+        },
+    },
+    {
+        fingerprint: [
+            // ModelID is from the button (SNZB-01) but this is SNZB-02, wrong modelID in firmware?
+            // https://github.com/Koenkk/zigbee2mqtt/issues/4338
+            {type: 'EndDevice', manufacturerName: 'eWeLink', modelID: 'WB01', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 770, inputClusters: [0, 3, 1026, 1029, 1], outputClusters: [3]},
+            ]},
+            {type: 'EndDevice', manufacturerName: 'eWeLink', modelID: '66666', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 770, inputClusters: [0, 3, 1026, 1029, 1], outputClusters: [3]},
+            ]},
+            {type: 'EndDevice', manufacturerName: 'eWeLink', modelID: 'DS01', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 770, inputClusters: [0, 3, 1026, 1029, 1], outputClusters: [3]},
+            ]},
+        ],
+        zigbeeModel: ['TH01'],
+        model: 'SNZB-02',
+        vendor: 'SONOFF',
+        whiteLabel: [{vendor: 'eWeLink', model: 'RHK08'}],
+        description: 'Temperature and humidity sensor',
+        exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
+        fromZigbee: [fz.SNZB02_temperature, fz.humidity, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            try {
+                const endpoint = device.getEndpoint(1);
+                const bindClusters = ['msTemperatureMeasurement', 'msRelativeHumidity', 'genPowerCfg'];
+                await reporting.bind(endpoint, coordinatorEndpoint, bindClusters);
+                await reporting.temperature(endpoint, {min: 5, max: constants.repInterval.MINUTES_30, change: 20});
+                await reporting.humidity(endpoint);
+                await reporting.batteryVoltage(endpoint, {min: 3600, max: 7200});
+                await reporting.batteryPercentageRemaining(endpoint, {min: 3600, max: 7200});
+            } catch (e) {/* Not required for all: https://github.com/Koenkk/zigbee2mqtt/issues/5562 */
+                logger.error(`Configure failed: ${e}`);
+            }
+        },
+    },
+    {
+        zigbeeModel: ['SNZB-02D'],
+        model: 'SNZB-02D',
+        vendor: 'SONOFF',
+        description: 'Temperature and humidity sensor with screen',
+        exposes: [e.battery(), e.temperature(), e.humidity()],
+        fromZigbee: [fz.temperature, fz.humidity, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const bindClusters = ['msTemperatureMeasurement', 'msRelativeHumidity', 'genPowerCfg'];
+            await reporting.bind(endpoint, coordinatorEndpoint, bindClusters);
+            await reporting.temperature(endpoint, {min: 5, max: constants.repInterval.MINUTES_30, change: 20});
+            await reporting.humidity(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint, {min: 3600, max: 7200});
+        },
+    },
+    {
+        fingerprint: [
+            {type: 'EndDevice', manufacturerName: 'eWeLink', modelID: '66666', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 1026, inputClusters: [0, 3, 1280, 1], outputClusters: [3]},
+            ]},
+        ],
+        zigbeeModel: ['MS01', 'MSO1'],
+        model: 'SNZB-03',
+        vendor: 'SONOFF',
+        whiteLabel: [{vendor: 'eWeLink', model: 'RHK09'}],
+        description: 'Motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const bindClusters = ['genPowerCfg'];
+            await reporting.bind(endpoint, coordinatorEndpoint, bindClusters);
+            // 3600/7200 prevents disconnect
+            // https://github.com/Koenkk/zigbee2mqtt/issues/13600#issuecomment-1283827935
+            await reporting.batteryVoltage(endpoint, {min: 3600, max: 7200});
+            await reporting.batteryPercentageRemaining(endpoint, {min: 3600, max: 7200});
+        },
+        exposes: [e.occupancy(), e.battery_low(), e.battery(), e.battery_voltage()],
+    },
+    {
+        zigbeeModel: ['S26R2ZB'],
+        model: 'S26R2ZB',
+        vendor: 'SONOFF',
+        description: 'Zigbee smart plug',
+        extend: extend.switch({disablePowerOnBehavior: true}),
+    },
+    {
+        zigbeeModel: ['S40LITE'],
+        model: 'S40ZBTPB',
+        vendor: 'SONOFF',
+        description: '15A Zigbee smart plug',
+        extend: extend.switch({disablePowerOnBehavior: true}),
+        fromZigbee: [fz.on_off_skip_duplicate_transaction],
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+    {
+        zigbeeModel: ['DONGLE-E_R'],
+        model: 'ZBDongle-E',
+        vendor: 'SONOFF',
+        description: 'Sonoff Zigbee 3.0 USB Dongle Plus (EFR32MG21) with router firmware',
+        fromZigbee: [fz.linkquality_from_basic, fzLocal.router_config],
+        toZigbee: [],
+        exposes: [exposes.numeric('light_indicator_level').withDescription('Brightness of the indicator light').withAccess(ea.STATE)],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
+    {
+        zigbeeModel: ['ZBCurtain'],
+        model: 'ZBCurtain',
+        vendor: 'SONOFF',
+        description: 'Zigbee smart curtain motor',
+        fromZigbee: [fz.cover_position_tilt, fz.battery],
+        toZigbee: [tz.cover_state, tz.cover_position_tilt],
+        exposes: [e.cover_position(), e.battery()],
+    },
+    {
+        zigbeeModel: ['Z111PL0H-1JX', 'SA-029-1'],
+        model: 'SA-028/SA-029',
+        vendor: 'SONOFF',
+        whiteLabel: [{vendor: 'Woolley', model: 'SA-029-1'}],
+        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);
+        },
+    },
+];

package/devices/spotmau.js

@@ -0,0 +1,36 @@
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['1719SP-PS1-02'],
+        model: 'SP-PS1-02',
+        vendor: 'Spotmau',
+        description: 'Smart wall switch - 1 gang',
+        extend: extend.switch(),
+        endpoint: (device) => {
+            return {default: 16};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(16), coordinatorEndpoint, ['genOnOff', 'genBasic']);
+        },
+    },
+    {
+        zigbeeModel: ['1719SP-PS2-02'],
+        model: 'SP-PS2-02',
+        vendor: 'Spotmau',
+        description: 'Smart wall switch - 2 gang',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right')],
+        endpoint: (device) => {
+            return {'left': 16, 'right': 17};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(16), coordinatorEndpoint, ['genOnOff', 'genBasic']);
+            await reporting.bind(device.getEndpoint(17), coordinatorEndpoint, ['genOnOff', 'genBasic']);
+        },
+    },
+];

package/devices/sprut.js

@@ -0,0 +1,317 @@
+const exposes = require('../lib/exposes');
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const reporting = require('../lib/reporting');
+const ota = require('../lib/ota');
+const constants = require('../lib/constants');
+const e = exposes;
+const ep = exposes.presets;
+const eo = exposes.options;
+const ea = exposes.access;
+const {calibrateAndPrecisionRoundOptions, getOptions} = require('../lib/utils');
+
+const sprutCode = 0x6666;
+const manufacturerOptions = {manufacturerCode: sprutCode};
+const switchActionValues = ['OFF', 'ON'];
+const co2Lookup = {
+    co2_autocalibration: 'sprutCO2AutoCalibration',
+    co2_manual_calibration: 'sprutCO2Calibration',
+};
+
+const fzLocal = {
+    temperature: {
+        cluster: 'msTemperatureMeasurement',
+        type: ['attributeReport', 'readResponse'],
+        options: [eo.precision('temperature'), eo.calibration('temperature')],
+        convert: (model, msg, publish, options, meta) => {
+            const temperature = parseFloat(msg.data['measuredValue']) / 100.0;
+            return {temperature: calibrateAndPrecisionRoundOptions(temperature, options, 'temperature')};
+        },
+    },
+    occupancy_level: {
+        cluster: 'msOccupancySensing',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('sprutOccupancyLevel')) {
+                return {occupancy_level: msg.data['sprutOccupancyLevel']};
+            }
+        },
+    },
+    voc: {
+        cluster: 'sprutVoc',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('voc')) {
+                return {voc: msg.data['voc']};
+            }
+        },
+    },
+    noise: {
+        cluster: 'sprutNoise',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('noise')) {
+                return {noise: msg.data['noise'].toFixed(2)};
+            }
+        },
+    },
+    noise_detected: {
+        cluster: 'sprutNoise',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('noiseDetected')) {
+                return {noise_detected: msg.data['noiseDetected'] === 1};
+            }
+        },
+    },
+    occupancy_timeout: {
+        cluster: 'msOccupancySensing',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            return {occupancy_timeout: msg.data['pirOToUDelay']};
+        },
+    },
+    noise_timeout: {
+        cluster: 'sprutNoise',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            return {noise_timeout: msg.data['noiseAfterDetectDelay']};
+        },
+    },
+    occupancy_sensitivity: {
+        cluster: 'msOccupancySensing',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            return {occupancy_sensitivity: msg.data['sprutOccupancySensitivity']};
+        },
+    },
+    noise_detect_level: {
+        cluster: 'sprutNoise',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            return {noise_detect_level: msg.data['noiseDetectLevel']};
+        },
+    },
+    co2_config: {
+        key: ['co2_autocalibration', 'co2_manual_calibration'],
+        cluster: 'msCO2',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('sprutCO2AutoCalibration')) {
+                return {co2_autocalibration: switchActionValues[msg.data['sprutCO2AutoCalibration']]};
+            }
+            if (msg.data.hasOwnProperty('sprutCO2Calibration')) {
+                return {co2_manual_calibration: switchActionValues[msg.data['sprutCO2Calibration']]};
+            }
+        },
+    },
+    th_heater: {
+        key: ['th_heater'],
+        cluster: 'msRelativeHumidity',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('sprutHeater')) {
+                return {th_heater: switchActionValues[msg.data['sprutHeater']]};
+            }
+        },
+    },
+};
+
+const tzLocal = {
+    sprut_ir_remote: {
+        key: ['play_store', 'learn_start', 'learn_stop', 'clear_store', 'play_ram', 'learn_ram_start', 'learn_ram_stop'],
+        convertSet: async (entity, key, value, meta) => {
+            const options = {
+                frameType: 0, manufacturerCode: sprutCode, disableDefaultResponse: true,
+                disableResponse: true, reservedBits: 0, direction: 0, writeUndiv: false,
+                transactionSequenceNumber: null,
+            };
+
+            switch (key) {
+            case 'play_store':
+                await entity.command('sprutIrBlaster', 'playStore',
+                    {param: value['rom']}, options);
+                break;
+            case 'learn_start':
+                await entity.command('sprutIrBlaster', 'learnStart',
+                    {value: value['rom']}, options);
+                break;
+            case 'learn_stop':
+                await entity.command('sprutIrBlaster', 'learnStop',
+                    {value: value['rom']}, options);
+                break;
+            case 'clear_store':
+                await entity.command('sprutIrBlaster', 'clearStore',
+                    {}, options);
+                break;
+            case 'play_ram':
+                await entity.command('sprutIrBlaster', 'playRam',
+                    {}, options);
+                break;
+            case 'learn_ram_start':
+                await entity.command('sprutIrBlaster', 'learnRamStart',
+                    {}, options);
+                break;
+            case 'learn_ram_stop':
+                await entity.command('sprutIrBlaster', 'learnRamStop',
+                    {}, options);
+                break;
+            }
+        },
+    },
+    occupancy_timeout: {
+        key: ['occupancy_timeout'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            await entity.write('msOccupancySensing', {pirOToUDelay: value}, getOptions(meta.mapped, entity));
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('msOccupancySensing', ['pirOToUDelay']);
+        },
+    },
+    noise_timeout: {
+        key: ['noise_timeout'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            await entity.write('sprutNoise', {noiseAfterDetectDelay: value}, getOptions(meta.mapped, entity));
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('sprutNoise', ['noiseAfterDetectDelay']);
+        },
+    },
+    occupancy_sensitivity: {
+        key: ['occupancy_sensitivity'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msOccupancySensing', {'sprutOccupancySensitivity': value}, options);
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('msOccupancySensing', ['sprutOccupancySensitivity'], manufacturerOptions);
+        },
+    },
+    noise_detect_level: {
+        key: ['noise_detect_level'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('sprutNoise', {'noiseDetectLevel': value}, options);
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('sprutNoise', ['noiseDetectLevel'], manufacturerOptions);
+        },
+    },
+    temperature_offset: {
+        key: ['temperature_offset'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            const newValue = parseFloat(value) * 100.0;
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msTemperatureMeasurement', {'sprutTemperatureOffset': newValue}, options);
+            return {state: {[key]: value}};
+        },
+    },
+    co2_config: {
+        key: ['co2_autocalibration', 'co2_manual_calibration'],
+        convertSet: async (entity, key, value, meta) => {
+            let newValue = value;
+            newValue = switchActionValues.indexOf(value);
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msCO2', {[co2Lookup[key]]: newValue}, options);
+
+
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('msCO2', [co2Lookup[key]], manufacturerOptions);
+        },
+    },
+    th_heater: {
+        key: ['th_heater'],
+        convertSet: async (entity, key, value, meta) => {
+            let newValue = value;
+            newValue = switchActionValues.indexOf(value);
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msRelativeHumidity', {'sprutHeater': newValue}, options);
+
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('msRelativeHumidity', ['sprutHeater'], manufacturerOptions);
+        },
+    },
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['WBMSW3'],
+        model: 'WB-MSW-ZIGBEE v.3',
+        vendor: 'Sprut.device',
+        description: 'Wall-mounted Zigbee sensor',
+        fromZigbee: [fzLocal.temperature, fz.illuminance, fz.humidity, fz.occupancy, fzLocal.occupancy_level, fz.co2, fzLocal.voc,
+            fzLocal.noise, fzLocal.noise_detected, fz.on_off, fzLocal.occupancy_timeout, fzLocal.noise_timeout, fzLocal.co2_config,
+            fzLocal.th_heater, fzLocal.occupancy_sensitivity, fzLocal.noise_detect_level],
+        toZigbee: [tz.on_off, tzLocal.sprut_ir_remote, tzLocal.occupancy_timeout, tzLocal.noise_timeout, tzLocal.co2_config,
+            tzLocal.th_heater, tzLocal.temperature_offset, tzLocal.occupancy_sensitivity, tzLocal.noise_detect_level],
+        exposes: [ep.temperature(), ep.illuminance(), ep.illuminance_lux(), ep.humidity(), ep.occupancy(), ep.occupancy_level(), ep.co2(),
+            ep.voc(), ep.noise(), ep.noise_detected(ea.STATE_GET), ep.switch().withEndpoint('l1'), ep.switch().withEndpoint('l2'),
+            ep.switch().withEndpoint('l3'),
+            e.numeric('noise_timeout', ea.ALL).withValueMin(0).withValueMax(2000).withUnit('s')
+                .withDescription('Time in seconds after which noise is cleared after detecting it (default: 60)'),
+            e.numeric('occupancy_timeout', ea.ALL).withValueMin(0).withValueMax(2000).withUnit('s')
+                .withDescription('Time in seconds after which occupancy is cleared after detecting it (default: 60)'),
+            e.numeric('temperature_offset', ea.SET).withValueMin(-10).withValueMax(10).withUnit('°C')
+                .withDescription('Self-heating compensation. The compensation value is subtracted from the measured temperature'),
+            e.numeric('occupancy_sensitivity', ea.ALL).withValueMin(0).withValueMax(2000)
+                .withDescription('If the sensor is triggered by the slightest movement, reduce the sensitivity, '+
+                    'otherwise increase it (default: 50)'),
+            e.numeric('noise_detect_level', ea.ALL).withValueMin(0).withValueMax(150).withUnit('dBA')
+                .withDescription('The minimum noise level at which the detector will work (default: 50)'),
+            e.enum('co2_autocalibration', ea.ALL, switchActionValues)
+                .withDescription('Automatic calibration of the CO2 sensor. If ON, the CO2 sensor will automatically calibrate '+
+                    'every 7 days. (MH-Z19B sensor)'),
+            e.enum('co2_manual_calibration', ea.ALL, switchActionValues)
+                .withDescription('Ventilate the room for 20 minutes, turn on manual calibration, and turn it off after one second. '+
+                    'After about 5 minutes the CO2 sensor will show 400ppm. Calibration completed. (MH-Z19B sensor)'),
+            e.enum('th_heater', ea.ALL, switchActionValues)
+                .withDescription('Turn on when working in conditions of high humidity (more than 70 %, RH) or condensation, '+
+                    'if the sensor shows 0 or 100 %.'),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            const binds = ['genBasic', 'msTemperatureMeasurement', 'msIlluminanceMeasurement', 'msRelativeHumidity',
+                'msOccupancySensing', 'msCO2', 'sprutVoc', 'sprutNoise', 'sprutIrBlaster', 'genOta'];
+            await reporting.bind(endpoint1, coordinatorEndpoint, binds);
+
+            // report configuration
+            await reporting.temperature(endpoint1);
+            await reporting.illuminance(endpoint1);
+            await reporting.humidity(endpoint1);
+            await reporting.occupancy(endpoint1);
+
+            let payload = reporting.payload('sprutOccupancyLevel', 10, constants.repInterval.MINUTE, 5);
+            await endpoint1.configureReporting('msOccupancySensing', payload, manufacturerOptions);
+
+            payload = reporting.payload('noise', 10, constants.repInterval.MINUTE, 5);
+            await endpoint1.configureReporting('sprutNoise', payload);
+
+            // led_red
+            await device.getEndpoint(2).read('genOnOff', ['onOff']);
+
+            // led_green
+            await device.getEndpoint(3).read('genOnOff', ['onOff']);
+
+            // buzzer
+            await device.getEndpoint(4).read('genOnOff', ['onOff']);
+        },
+        endpoint: (device) => {
+            return {'default': 1, 'l1': 2, 'l2': 3, 'l3': 4};
+        },
+        meta: {multiEndpoint: true},
+        ota: ota.zigbeeOTA,
+    },
+];