zigbee-herdsman-converters 14.0.537 → 14.0.540

package/converters/fromZigbee.js

@@ -2257,9 +2257,7 @@ const converters = {
             const value = tuya.getDataValue(dpValue);
 
             switch (dp) {
-            case tuya.dataPoints.coverPosition: { // Started moving to position (triggered from Zigbee)
-                return {running: true};
-            }
+            case tuya.dataPoints.coverPosition: // Started moving to position (triggered from Zigbee)
             case tuya.dataPoints.coverArrived: { // Arrived at position
                 const running = dp === tuya.dataPoints.coverArrived ? false : true;
                 const invert = tuya.isCoverInverted(meta.device.manufacturerName) ? !options.invert_cover : options.invert_cover;
@@ -7308,7 +7306,7 @@ const converters = {
             case 4:
                 return {battery: value};
             case 1:
-                return {battery_low: value.toFixed(1)};
+                return {battery_low: value === 1};
             default:
                 meta.logger.warn(`s_lux_zb_illuminance: NOT RECOGNIZED DP #${dp} with data ${JSON.stringify(dpValue)}`);
             }

package/devices/custom_devices_diy.js

@@ -6,6 +6,37 @@ const extend = require('../lib/extend');
 const e = exposes.presets;
 const ea = exposes.access;
 
+const tzLocal = {
+    node_config: {
+        key: ['report_delay'],
+        convertSet: async (entity, key, rawValue, meta) => {
+            const lookup = {'OFF': 0x00, 'ON': 0x01};
+            const value = lookup.hasOwnProperty(rawValue) ? lookup[rawValue] : parseInt(rawValue, 10);
+            const payloads = {
+                report_delay: ['genPowerCfg', {0x0201: {value, type: 0x21}}],
+            };
+            await entity.write(payloads[key][0], payloads[key][1]);
+            return {
+                state: {[key]: rawValue},
+            };
+        },
+    },
+};
+
+const fzLocal = {
+    node_config: {
+        cluster: 'genPowerCfg',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty(0x0201)) {
+                result.report_delay = msg.data[0x0201];
+            }
+            return result;
+        },
+    },
+};
+
 module.exports = [
     {
         zigbeeModel: ['ti.router'],
@@ -257,17 +288,15 @@ module.exports = [
         model: 'EFEKTA_miniPWS',
         vendor: 'Custom devices (DiY)',
         description: '[Mini plant wattering sensor](http://efektalab.com/miniPWS)',
-        fromZigbee: [fz.soil_moisture, fz.battery],
-        toZigbee: [tz.factory_reset],
+        fromZigbee: [fz.soil_moisture, fz.battery, fzLocal.node_config],
+        toZigbee: [tz.factory_reset, tzLocal.node_config],
         configure: async (device, coordinatorEndpoint, logger) => {
             const firstEndpoint = device.getEndpoint(1);
             await reporting.bind(firstEndpoint, coordinatorEndpoint, ['genPowerCfg', 'msSoilMoisture']);
-            const overides = {min: 0, max: 21600, change: 0};
-            await reporting.batteryVoltage(firstEndpoint, overides);
-            await reporting.batteryPercentageRemaining(firstEndpoint, overides);
-            await reporting.soil_moisture(firstEndpoint, overides);
         },
-        exposes: [e.soil_moisture(), e.battery()],
+        exposes: [e.soil_moisture(), e.battery(),
+            exposes.numeric('report_delay', ea.STATE_SET).withUnit('min').withDescription('Adjust Report Delay, by default 60 minutes')
+                .withValueMin(1).withValueMax(180)],
     },
     {
         zigbeeModel: ['EFEKTA_eON213wz'],

package/devices/danalock.js

@@ -10,14 +10,15 @@ module.exports = [
         model: 'V3-BTZB/V3-BTZBE',
         vendor: 'Danalock',
         description: 'BT/ZB smartlock',
-        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
-        toZigbee: [tz.lock],
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock, tz.lock_userstatus],
+        meta: {pinCodeCount: 20},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
             await reporting.lockState(endpoint);
             await reporting.batteryPercentageRemaining(endpoint);
         },
-        exposes: [e.lock(), e.battery(), e.lock_action(), e.lock_action_source_name(), e.lock_action_source_user()],
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_source_user()],
     },
 ];

package/devices/heiman.js

@@ -117,6 +117,15 @@ module.exports = [
         toZigbee: [],
         exposes: [e.gas(), e.battery_low(), e.tamper()],
     },
+    {
+        zigbeeModel: ['RH3070'],
+        model: 'HS1CG',
+        vendor: 'Heiman',
+        description: 'Smart combustible gas sensor',
+        fromZigbee: [fz.ias_gas_alarm_1],
+        toZigbee: [],
+        exposes: [e.gas(), e.battery_low(), e.tamper()],
+    },
     {
         zigbeeModel: ['GAS_V15'],
         model: 'HS1CG_M',

package/devices/ikea.js

@@ -36,10 +36,10 @@ const bulbOnEvent = async (type, data, device, options, state) => {
 
         // NOTE: execute_if_off default is false
         //       we only restore if true, to save unneeded network writes
-        if (state.color_options !== undefined && state.color_options.execute_if_off === true) {
+        if (state !== undefined && state.color_options !== undefined && state.color_options.execute_if_off === true) {
             device.endpoints[0].write('lightingColorCtrl', {'options': 1});
         }
-        if (state.level_config !== undefined && state.level_config.execute_if_off === true) {
+        if (state !== undefined && state.level_config !== undefined && state.level_config.execute_if_off === true) {
             device.endpoints[0].write('genLevelCtrl', {'options': 1});
         }
     }

package/devices/lellki.js

@@ -23,6 +23,9 @@ module.exports = [
             return {l1: 1, l2: 2, l3: 3, l4: 4, l5: 5};
         },
         configure: async (device, coordinatorEndpoint, logger) => {
+            await device.getEndpoint(1).read('genBasic', [
+                'manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
+
             for (const ID of [1, 2, 3, 4, 5]) {
                 await reporting.bind(device.getEndpoint(ID), coordinatorEndpoint, ['genOnOff']);
             }

package/devices/m/303/274ller_licht.js

@@ -155,6 +155,10 @@ module.exports = [
         exposes: [e.action(['on', 'off', 'brightness_step_up', 'brightness_step_down', 'brightness_move_up', 'brightness_move_down',
             'brightness_stop', 'color_temperature_move'])],
         toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.powerSource = 'Battery';
+            device.save();
+        },
     },
     {
         zigbeeModel: ['tint-ColorTemperature', 'tint-ColorTemperature2'],

package/devices/niko.js

@@ -219,4 +219,19 @@ module.exports = [
             exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']).withEndpoint('l2'),
         ],
     },
+    {
+        zigbeeModel: ['Connectable dimmer,3-200W,2-wire'],
+        model: '552-72201',
+        vendor: 'Niko',
+        description: 'Connectable dimmer',
+        fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fz.command_move, fz.command_stop],
+        toZigbee: [tz.light_onoff_brightness, tz.level_config],
+        exposes: [e.light_brightness().withLevelConfig()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint);
+            await reporting.brightness(endpoint);
+        },
+    },
 ];

package/devices/owon.js

@@ -4,7 +4,78 @@ const tz = require('../converters/toZigbee');
 const constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
 const e = exposes.presets;
+const ea = exposes.access;
 
+const fzLocal = {
+    PC321_metering: {
+        cluster: 'seMetering',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const payload = {};
+            if (msg.data.hasOwnProperty('owonL1Energy')) {
+                payload.energy_l1 = msg.data['owonL1Energy'][1] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL2Energy')) {
+                payload.energy_l2 = msg.data['owonL2Energy'][1] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL3Energy')) {
+                payload.energy_l3 = msg.data['owonL3Energy'][1] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL1ReactiveEnergy')) {
+                payload.reactive_energy_l1 = msg.data['owonL1ReactiveEnergy'][1] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL2ReactiveEnergy')) {
+                payload.reactive_energy_l2 = msg.data['owonL2ReactiveEnergy'][1] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL3ReactiveEnergy')) {
+                payload.reactive_energy_l3 = msg.data['owonL3ReactiveEnergy'][1] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL1PhasePower')) {
+                payload.power_l1 = msg.data['owonL1PhasePower'];
+            }
+            if (msg.data.hasOwnProperty('owonL2PhasePower')) {
+                payload.power_l2 = msg.data['owonL2PhasePower'];
+            }
+            if (msg.data.hasOwnProperty('owonL3PhasePower')) {
+                payload.power_l3 = msg.data['owonL3PhasePower'];
+            }
+            if (msg.data.hasOwnProperty('owonL1PhaseReactivePower')) {
+                payload.reactive_power_l1 = msg.data['owonL1PhaseReactivePower'];
+            }
+            if (msg.data.hasOwnProperty('owonL2PhaseReactivePower')) {
+                payload.reactive_power_l2 = msg.data['owonL2PhaseReactivePower'];
+            }
+            if (msg.data.hasOwnProperty('owonL3PhaseReactivePower')) {
+                payload.reactive_power_l3 = msg.data['owonL3PhaseReactivePower'];
+            }
+            if (msg.data.hasOwnProperty('owonL1PhaseVoltage')) {
+                payload.voltage_l1 = msg.data['owonL1PhaseVoltage'] / 10.0;
+            }
+            if (msg.data.hasOwnProperty('owonL2PhaseVoltage')) {
+                payload.voltage_l2 = msg.data['owonL2PhaseVoltage'] / 10.0;
+            }
+            if (msg.data.hasOwnProperty('owonL3PhaseVoltage')) {
+                payload.voltage_l3 = msg.data['owonL3PhaseVoltage'] / 10.0;
+            }
+            if (msg.data.hasOwnProperty('owonL1PhaseCurrent')) {
+                payload.current_l1 = msg.data['owonL1PhaseCurrent'] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL2PhaseCurrent')) {
+                payload.current_l2 = msg.data['owonL2PhaseCurrent'] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonL3PhaseCurrent')) {
+                payload.current_l3 = msg.data['owonL3PhaseCurrent'] / 1000.0;
+            }
+            if (msg.data.hasOwnProperty('owonFrequency')) {
+                payload.frequency = msg.data['owonFrequency'];
+            }
+            if (msg.data.hasOwnProperty('owonReactiveEnergySum')) {
+                payload.reactive_energy_sum = msg.data['owonReactiveEnergySum'];
+            }
+            return payload;
+        },
+    },
+};
 module.exports = [
     {
         zigbeeModel: ['WSP404'],
@@ -119,4 +190,41 @@ module.exports = [
             device.save();
         },
     },
+    {
+        zigbeeModel: ['PC321'],
+        model: 'PC321',
+        vendor: 'OWON',
+        description: '3-Phase clamp power meter',
+        fromZigbee: [fz.metering, fzLocal.PC321_metering],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            if (device.powerSource === 'Unknown') {
+                device.powerSource = 'Mains (single phase)';
+                device.save();
+            }
+        },
+        exposes: [e.energy(),
+            exposes.numeric('voltage_l1', ea.STATE).withUnit('V').withDescription('Phase 1 voltage'),
+            exposes.numeric('voltage_l2', ea.STATE).withUnit('V').withDescription('Phase 2 voltage'),
+            exposes.numeric('voltage_l3', ea.STATE).withUnit('V').withDescription('Phase 3 voltage'),
+            exposes.numeric('current_l1', ea.STATE).withUnit('A').withDescription('Phase 1 current'),
+            exposes.numeric('current_l2', ea.STATE).withUnit('A').withDescription('Phase 2 current'),
+            exposes.numeric('current_l3', ea.STATE).withUnit('A').withDescription('Phase 3 current'),
+            exposes.numeric('energy_l1', ea.STATE).withUnit('kWh').withDescription('Phase 1 energy'),
+            exposes.numeric('energy_l2', ea.STATE).withUnit('kWh').withDescription('Phase 2 energy'),
+            exposes.numeric('energy_l3', ea.STATE).withUnit('kWh').withDescription('Phase 3 energy'),
+            exposes.numeric('reactive_energy_l1', ea.STATE).withUnit('kVArh').withDescription('Phase 1 reactive energy'),
+            exposes.numeric('reactive_energy_l2', ea.STATE).withUnit('kVArh').withDescription('Phase 2 reactive energy'),
+            exposes.numeric('reactive_energy_l3', ea.STATE).withUnit('kVArh').withDescription('Phase 3 reactive energy'),
+            exposes.numeric('power_l1', ea.STATE).withUnit('W').withDescription('Phase 1 power'),
+            exposes.numeric('power_l2', ea.STATE).withUnit('W').withDescription('Phase 2 power'),
+            exposes.numeric('power_l3', ea.STATE).withUnit('W').withDescription('Phase 3 power'),
+            exposes.numeric('reactive_power_l1', ea.STATE).withUnit('VAr').withDescription('Phase 1 reactive power'),
+            exposes.numeric('reactive_power_l2', ea.STATE).withUnit('VAr').withDescription('Phase 2 reactive power'),
+            exposes.numeric('reactive_power_l3', ea.STATE).withUnit('VAr').withDescription('Phase 3 reactive power'),
+        ],
+    },
 ];

package/devices/philips.js

@@ -1671,9 +1671,9 @@ module.exports = [
         zigbeeModel: ['929002376801'],
         model: '929002376801',
         vendor: 'Philips',
-        description: 'Hue Iris (generation 4)',
+        description: 'Hue Iris kobber limited edition (generation 4)',
         meta: {turnsOffAtBrightness1: true},
-        extend: hueExtend.light_onoff_brightness_color(),
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
         ota: ota.zigbeeOTA,
     },
     {

package/devices/sengled.js

@@ -237,7 +237,6 @@ module.exports = [
             await reporting.instantaneousDemand(endpoint);
         },
         exposes: [e.switch(), e.power(), e.energy()],
-        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['E1E-G7F'],

package/devices/tuya.js

@@ -14,7 +14,7 @@ const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak',
     '_TZ3000_jvzvulen', '_TZ3000_mraovvmm', '_TZ3000_nfnmi125', '_TZ3000_ps3dmato', '_TZ3000_w0qqde0g', '_TZ3000_u5u4cakc',
     '_TZ3000_rdtixbnu', '_TZ3000_typdpbpg', '_TZ3000_kx0pris5', '_TZ3000_amdymr7l', '_TZ3000_z1pnpsdo', '_TZ3000_ksw8qtmt',
     '_TZ3000_nzkqcvvs', '_TZ3000_1h2x4akh', '_TZ3000_9vo5icau', '_TZ3000_cehuw1lw', '_TZ3000_ko6v90pg', '_TZ3000_f1bapcit',
-    '_TZ3000_cjrngdr3', '_TZ3000_zloso4jk', '_TZ3000_r6buo8ba'];
+    '_TZ3000_cjrngdr3', '_TZ3000_zloso4jk', '_TZ3000_r6buo8ba', '_TZ3000_iksasdbv', '_TZ3000_dd8wwzcy'];
 
 const tzLocal = {
     TS0504B_color: {
@@ -43,6 +43,20 @@ const tzLocal = {
             }
         },
     },
+    power_on_behavior: {
+        key: ['power_on_behavior'],
+        convertSet: async (entity, key, value, meta) => {
+            value = value.toLowerCase();
+            const lookup = {'off': 0, 'on': 1, 'previous': 2};
+            utils.validateValue(value, Object.keys(lookup));
+            const pState = lookup[value];
+            await entity.write('manuSpecificTuya_3', {'powerOnBehavior': pState}, {disableDefaultResponse: true});
+            return {state: {power_on_behavior: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificTuya_3', ['powerOnBehavior']);
+        },
+    },
     zb_sm_cover: {
         key: ['state', 'position', 'reverse_direction', 'top_limit', 'bottom_limit', 'favorite_position', 'goto_positon', 'report'],
         convertSet: async (entity, key, value, meta) => {
@@ -166,6 +180,19 @@ const fzLocal = {
             }
         },
     },
+    power_on_behavior: {
+        cluster: 'manuSpecificTuya_3',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const attribute = 'powerOnBehavior';
+            const lookup = {0: 'off', 1: 'on', 2: 'previous'};
+
+            if (msg.data.hasOwnProperty(attribute)) {
+                const property = utils.postfixWithEndpointName('power_on_behavior', msg, model);
+                return {[property]: lookup[msg.data[attribute]]};
+            }
+        },
+    },
     zb_sm_cover: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataReport', 'commandDataResponse'],
@@ -220,7 +247,7 @@ const fzLocal = {
                 case 116: // report confirmation
                     break;
                 case 121: // running state
-                    result.running_state = {0: 'OPENING', 1: 'STOPPED', 2: 'CLOSING'}[value];
+                    result.motor_state = {0: 'OPENING', 1: 'STOPPED', 2: 'CLOSING'}[value];
                     result.running = (value !== 1) ? true : false;
                     break;
                 default: // Unknown code
@@ -523,6 +550,7 @@ module.exports = [
             {modelID: 'TS0202', manufacturerName: '_TZ3000_otvn3lne'},
             {modelID: 'TS0202', manufacturerName: '_TZ3000_tiwq83wk'},
             {modelID: 'TS0202', manufacturerName: '_TZ3000_ykwcwxmz'},
+            {modelID: 'TS0202', manufacturerName: '_TZ3000_hgu1dlak'},
             {modelID: 'WHD02', manufacturerName: '_TZ3000_hktqahrq'}],
         model: 'TS0202',
         vendor: 'TuYa',
@@ -688,13 +716,7 @@ module.exports = [
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic']);
         },
-        exposes: (device, options) => {
-            if (device && device.manufacturerName === '_TZE200_pisltm67') {
-                return [e.illuminance_lux(), e.linkquality()];
-            } else {
-                return [e.battery(), e.illuminance_lux(), e.battery_low(), e.linkquality()];
-            }
-        },
+        exposes: [e.battery(), e.illuminance_lux(), e.battery_low(), e.linkquality()],
     },
     {
         zigbeeModel: ['TS130F'],
@@ -1931,9 +1953,11 @@ module.exports = [
         model: 'TS0004',
         vendor: 'TuYa',
         description: 'Smart light switch - 4 gang with neutral wire',
-        extend: extend.switch(),
-        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
-            e.switch().withEndpoint('l4')],
+        fromZigbee: [fz.on_off, fzLocal.power_on_behavior, fz.ignore_basic_report],
+        toZigbee: [tz.on_off, tzLocal.power_on_behavior],
+        exposes: [e.switch().withEndpoint('l1'), e.power_on_behavior().withEndpoint('l1'), e.switch().withEndpoint('l2'),
+            e.power_on_behavior().withEndpoint('l2'), e.switch().withEndpoint('l3'), e.power_on_behavior().withEndpoint('l3'),
+            e.switch().withEndpoint('l4'), e.power_on_behavior().withEndpoint('l4')],
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4};
         },
@@ -2568,7 +2592,7 @@ module.exports = [
         exposes: [
             e.cover_position().setAccess('position', ea.STATE_SET),
             exposes.enum('goto_positon', ea.SET, ['25', '50', '75', 'FAVORITE']),
-            exposes.enum('running_state', ea.STATE, ['OPENING', 'CLOSING', 'STOPPED']),
+            exposes.enum('motor_state', ea.STATE, ['OPENING', 'CLOSING', 'STOPPED']),
             exposes.numeric('active_power', ea.STATE).withDescription('Active power').withUnit('mWt'),
             exposes.numeric('cycle_count', ea.STATE).withDescription('Cycle count'),
             exposes.numeric('cycle_time', ea.STATE).withDescription('Cycle time').withUnit('ms'),

package/devices/xiaomi.js

@@ -1538,14 +1538,14 @@ module.exports = [
         model: 'GZCGQ01LM',
         vendor: 'Xiaomi',
         description: 'MiJia light intensity sensor',
-        fromZigbee: [fz.battery, fz.illuminance],
+        fromZigbee: [fz.battery, fz.illuminance, fz.aqara_opple],
         toZigbee: [],
         meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'msIlluminanceMeasurement']);
-            await reporting.batteryVoltage(endpoint);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msIlluminanceMeasurement']);
             await reporting.illuminance(endpoint, {min: 15, max: constants.repInterval.HOUR, change: 500});
+            await endpoint.read('genPowerCfg', ['batteryVoltage']);
         },
         exposes: [e.battery(), e.battery_voltage(), e.illuminance(), e.illuminance_lux()],
     },

package/devices/zemismart.js

@@ -144,6 +144,9 @@ module.exports = [
         },
         meta: {multiEndpoint: true},
         configure: async (device, coordinatorEndpoint, logger) => {
+            await device.getEndpoint(1).read('genBasic', [
+                'manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
+
             await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
             await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
             await reporting.onOff(device.getEndpoint(1));
@@ -189,6 +192,30 @@ module.exports = [
         toZigbee: [tz.tuya_cover_control, tz.tuya_cover_options, tz.tuya_data_point_test],
         exposes: [e.cover_position().setAccess('position', ea.STATE_SET)],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_1n2kyphz'}],
+        model: 'TB26-4',
+        vendor: 'Zemismart',
+        description: '4-gang smart wall switch',
+        exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l4').setAccess('state', ea.STATE_SET)],
+        fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
+        toZigbee: [tz.tuya_switch_state],
+        meta: {multiEndpoint: true},
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 1, 'l3': 1, 'l4': 1};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(2)) await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(3)) await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(4)) await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_9mahtqtg'}],
         model: 'TB26-6',

package/devices/zen.js

@@ -15,7 +15,8 @@ module.exports = [
             tz.thermostat_unoccupied_heating_setpoint, tz.thermostat_setpoint_raise_lower, tz.thermostat_running_state,
             tz.thermostat_remote_sensing, tz.thermostat_control_sequence_of_operation, tz.thermostat_system_mode,
             tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule, tz.thermostat_relay_status_log],
-        exposes: [exposes.climate().withSetpoint('occupied_heating_setpoint', 10, 30, 0.5).withLocalTemperature()
+        exposes: [exposes.climate().withSetpoint('occupied_heating_setpoint', 10, 30, 0.5)
+            .withSetpoint('occupied_cooling_setpoint', 10, 31, 0.5).withLocalTemperature()
             .withSystemMode(['off', 'auto', 'heat', 'cool']).withRunningState(['idle', 'heat', 'cool'])
             .withLocalTemperatureCalibration(-30, 30, 0.1).withPiHeatingDemand()],
         configure: async (device, coordinatorEndpoint, logger) => {

package/lib/ota/inovelli.js

@@ -18,8 +18,8 @@ async function getImageMeta(current, logger, device) {
         .sort((a, b) => {
             const aRadix = a.version.match(/[A-F]/) ? 16 : 10;
             const bRadix = b.version.match(/[A-F]/) ? 16 : 10;
-            const aVersion = parseInt(a.version.replace(/\./g, ''), aRadix);
-            const bVersion = parseInt(b.version.replace(/\./g, ''), bRadix);
+            const aVersion = parseFloat(a.version, aRadix);
+            const bVersion = parseFloat(b.version, bRadix);
             // doesn't matter which order they are in
             if (aVersion < bVersion) {
                 return -1;
@@ -37,7 +37,7 @@ async function getImageMeta(current, logger, device) {
     }
     // version in the firmare removes the zero padding and support hex versioning
     return {
-        fileVersion: parseInt(image.version, image.version.match(/[A-F]/) ? 16 : 10),
+        fileVersion: parseFloat(image.version, image.version.match(/[A-F]/) ? 16 : 10),
         url: image.firmware,
     };
 }

package/lib/xiaomi.js

@@ -158,7 +158,7 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             }
             break;
         case '3':
-            if (['WXCJKG11LM', 'WXCJKG12LM', 'WXCJKG13LM', 'MCCGQ14LM'].includes(model.model)) {
+            if (['WXCJKG11LM', 'WXCJKG12LM', 'WXCJKG13LM', 'MCCGQ14LM', 'GZCGQ01LM'].includes(model.model)) {
                 // The temperature value is constant 25 °C and does not change, so we ignore it
                 // https://github.com/Koenkk/zigbee2mqtt/issues/11126
                 // https://github.com/Koenkk/zigbee-herdsman-converters/pull/3585
@@ -225,6 +225,9 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                 // payload.water_leak = value === 1;
             } else if (['JTYJ-GD-01LM/BW'].includes(model.model)) {
                 payload.smoke_density = value;
+            } else if (['GZCGQ01LM'].includes(model.model)) {
+                // DEPRECATED: change illuminance_lux -> illuminance
+                payload.illuminance_lux = calibrateAndPrecisionRoundOptions(value, options, 'illuminance_lux');
             } else {
                 payload.state = value === 1 ? 'ON' : 'OFF';
             }

package/package.json

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