zigbee-herdsman-converters 14.0.477 → 14.0.480

package/converters/fromZigbee.js

@@ -4272,6 +4272,55 @@ const converters = {
             }
         },
     },
+    connecte_thermostat: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'connecte_thermostat');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+
+            switch (dp) {
+            case tuya.dataPoints.connecteState:
+                return {state: value ? 'ON' : 'OFF'};
+            case tuya.dataPoints.connecteMode:
+                switch (value) {
+                case 0: // manual
+                    return {system_mode: 'heat', away_mode: 'OFF'};
+                case 1: // home (auto)
+                    return {system_mode: 'auto', away_mode: 'OFF'};
+                case 2: // away (auto)
+                    return {system_mode: 'auto', away_mode: 'ON'};
+                }
+                break;
+            case tuya.dataPoints.connecteHeatingSetpoint:
+                return {current_heating_setpoint: value};
+            case tuya.dataPoints.connecteLocalTemp:
+                return {local_temperature: value};
+            case tuya.dataPoints.connecteTempCalibration:
+                return {local_temperature_calibration: value};
+            case tuya.dataPoints.connecteChildLock:
+                return {child_lock: value ? 'LOCK' : 'UNLOCK'};
+            case tuya.dataPoints.connecteTempFloor:
+                return {external_temperature: value};
+            case tuya.dataPoints.connecteSensorType:
+                return {sensor: {0: 'internal', 1: 'external', 2: 'both'}[value]};
+            case tuya.dataPoints.connecteHysteresis:
+                return {hysteresis: value};
+            case tuya.dataPoints.connecteRunningState:
+                return {running_state: value ? 'heat' : 'idle'};
+            case tuya.dataPoints.connecteTempProgram:
+                break;
+            case tuya.dataPoints.connecteOpenWindow:
+                return {window_detection: value ? 'ON' : 'OFF'};
+            case tuya.dataPoints.connecteMaxProtectTemp:
+                return {max_temperature_protection: value};
+            default:
+                meta.logger.warn(`zigbee-herdsman-converters:connecte_thermostat: Unrecognized DP #${
+                    dp} with data ${JSON.stringify(dpValue)}`);
+            }
+        },
+    },
     saswell_thermostat: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport'],
@@ -5477,7 +5526,7 @@ const converters = {
             return payload;
         },
     },
-    RTCGQ12LM_occupancy_illuminance: {
+    aqara_occupancy_illuminance: {
         // This is for occupancy sensor that only send a message when motion detected,
         // but do not send a motion stop.
         // Therefore we need to publish the no_motion detected by ourselves.
@@ -5490,7 +5539,7 @@ const converters = {
                 // The occupancy sensor only sends a message when motion detected.
                 // Therefore we need to publish the no_motion detected by ourselves.
                 let timeout = meta && meta.state && meta.state.hasOwnProperty('detection_interval') ?
-                    meta.state.detection_interval : 60;
+                    meta.state.detection_interval : ['RTCGQ14LM'].includes(model.model) ? 30 : 60;
                 timeout = options && options.hasOwnProperty('occupancy_timeout') && options.occupancy_timeout >= timeout ?
                     options.occupancy_timeout : timeout + 2;
 

package/converters/toZigbee.js

@@ -3005,6 +3005,68 @@ const converters = {
             await entity.read('closuresWindowCovering', [isPosition ? 'currentPositionLiftPercentage' : 'currentPositionTiltPercentage']);
         },
     },
+    connecte_thermostat: {
+        key: [
+            'child_lock', 'current_heating_setpoint', 'local_temperature_calibration', 'max_temperature_protection', 'window_detection',
+            'hysteresis', 'state', 'away_mode', 'sensor', 'system_mode',
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'state':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.connecteState, value === 'ON');
+                break;
+            case 'child_lock':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.connecteChildLock, value === 'LOCK');
+                break;
+            case 'local_temperature_calibration':
+                if (value < 0) value = 0xFFFFFFFF + value + 1;
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.connecteTempCalibration, value);
+                break;
+            case 'hysteresis':
+                // value = Math.round(value * 10);
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.connecteHysteresis, value);
+                break;
+            case 'max_temperature_protection':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.connecteMaxProtectTemp, Math.round(value));
+                break;
+            case 'current_heating_setpoint':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.connecteHeatingSetpoint, value);
+                break;
+            case 'sensor':
+                await tuya.sendDataPointEnum(
+                    entity,
+                    tuya.dataPoints.connecteSensorType,
+                    {'internal': 0, 'external': 1, 'both': 2}[value]);
+                break;
+            case 'system_mode':
+                switch (value) {
+                case 'heat':
+                    await tuya.sendDataPointEnum(entity, tuya.dataPoints.connecteMode, 0 /* manual */);
+                    break;
+                case 'auto':
+                    await tuya.sendDataPointEnum(entity, tuya.dataPoints.connecteMode, 1 /* auto */);
+                    break;
+                }
+                break;
+            case 'away_mode':
+                switch (value) {
+                case 'ON':
+                    await tuya.sendDataPointEnum(entity, tuya.dataPoints.connecteMode, 2 /* auto */);
+                    break;
+                case 'OFF':
+                    await tuya.sendDataPointEnum(entity, tuya.dataPoints.connecteMode, 0 /* manual */);
+                    break;
+                }
+                break;
+            case 'window_detection':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.connecteOpenWindow, value === 'ON');
+                break;
+            default: // Unknown key
+                throw new Error(`Unhandled key toZigbee.connecte_thermostat ${key}`);
+            }
+        },
+    },
+
     moes_thermostat_child_lock: {
         key: ['child_lock'],
         convertSet: async (entity, key, value, meta) => {
@@ -6311,16 +6373,13 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
             case 'ext_switch_type':
-                meta.logger.debug(`toZigbee.ZB006X_settings: Send key/value [${key}|${value}]`);
                 await tuya.sendDataPointEnum(entity, 103, {'unknown': 0, 'toggle_sw': 1,
                     'momentary_sw': 2, 'rotary_sw': 3, 'auto_config': 4}[value]);
                 break;
             case 'load_detection_mode':
-                meta.logger.debug(`toZigbee.ZB006X_settings: Send key/value [${key}|${value}]`);
                 await tuya.sendDataPointEnum(entity, 105, {'none': 0, 'first_power_on': 1, 'every_power_on': 2}[value]);
                 break;
             case 'control_mode':
-                meta.logger.debug(`toZigbee.ZB006X_settings: Send key/value [${key}|${value}]`);
                 await tuya.sendDataPointEnum(entity, 109, {'local': 0, 'remote': 1, 'both': 2}[value]);
                 break;
             default: // Unknown key

package/devices/connecte.js

@@ -0,0 +1,50 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const tuya = require('../lib/tuya');
+const e = exposes.presets;
+const ea = exposes.access;
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_4hbx5cvx'}],
+        model: '4500994',
+        vendor: 'Connecte',
+        description: 'Smart thermostat',
+        fromZigbee: [fz.connecte_thermostat],
+        toZigbee: [tz.connecte_thermostat],
+        onEvent: tuya.onEventSetTime,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            // Do a "magic" read on the basic cluster to trigger the thermostat start reporting.
+            await endpoint.read('genBasic', ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
+        },
+        exposes: [
+            exposes.binary('state', ea.STATE_SET, 'ON', 'OFF')
+                .withDescription('On/off state of the switch'),
+            e.child_lock(),
+            e.window_detection(),
+            exposes.climate()
+                .withSetpoint('current_heating_setpoint', 5, 35, 1, ea.STATE_SET)
+                .withLocalTemperature(ea.STATE)
+                .withLocalTemperatureCalibration(-9, 9, 1, ea.STATE_SET)
+                .withSystemMode(['heat', 'auto'], ea.STATE_SET)
+                .withRunningState(['idle', 'heat'], ea.STATE)
+                .withAwayMode()
+                .withSensor(['internal', 'external', 'both']),
+            exposes.numeric('external_temperature', ea.STATE)
+                .withUnit('°C')
+                .withDescription('Current temperature measured on the external sensor (floor)'),
+            exposes.numeric('hysteresis', ea.STATE_SET)
+                .withDescription('The difference between the temperature at which the thermostat switches off, ' +
+                'and the temperature at which it switches on again.')
+                .withValueMin(1)
+                .withValueMax(9),
+            exposes.numeric('max_temperature_protection', ea.STATE_SET)
+                .withUnit('°C')
+                .withDescription('Max guarding temperature')
+                .withValueMin(20)
+                .withValueMax(95),
+        ],
+    },
+];

package/devices/fantem.js

@@ -13,15 +13,18 @@ module.exports = [
         vendor: 'Fantem',
         description: 'Smart dimmer module without neutral',
         extend: extend.light_onoff_brightness({noConfigure: true}),
-        fromZigbee: [...extend.light_onoff_brightness({noConfigure: true}).fromZigbee, fz.ZB006X_settings],
+        fromZigbee: [...extend.light_onoff_brightness({noConfigure: true}).fromZigbee, fz.command_on, fz.command_off,
+            fz.command_move, fz.command_stop, fz.ZB006X_settings],
         toZigbee: [...extend.light_onoff_brightness({noConfigure: true}).toZigbee, tz.ZB006X_settings],
         exposes: [e.light_brightness(),
+            e.action(['on', 'off', 'brightness_move_down', 'brightness_move_up', 'brightness_stop']),
             exposes.enum('ext_switch_type', ea.STATE_SET, ['unknown', 'toggle_sw', 'momentary_sw', 'rotary_sw', 'auto_config'])
                 .withDescription('External switch type'),
             exposes.enum('load_detection_mode', ea.STATE_SET, ['none', 'first_power_on', 'every_power_on'])
                 .withDescription('Load detection mode'),
             exposes.enum('control_mode', ea.STATE_SET, ['local', 'remote', 'both']).withDescription('Control mode'),
         ],
+        meta: {disableActionGroup: true},
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);

package/devices/innr.js

@@ -159,6 +159,14 @@ module.exports = [
         extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555], supportsHS: true}),
         meta: {applyRedFix: true, turnsOffAtBrightness1: true},
     },
+    {
+        zigbeeModel: ['BY 286 C'],
+        model: 'BY 286 C',
+        vendor: 'Innr',
+        description: 'B22 bulb RGBW',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555], supportsHS: true}),
+        meta: {applyRedFix: true, turnsOffAtBrightness1: true},
+    },
     {
         zigbeeModel: ['RB 165'],
         model: 'RB 165',

package/devices/lidl.js

@@ -496,6 +496,17 @@ module.exports = [
             device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
         },
     },
+    {
+        fingerprint: [{modelID: 'TS0504B', manufacturerName: '_TZ3210_sroezl0s'}],
+        model: '14153806L',
+        vendor: 'Lidl',
+        description: 'Livarno smart LED ceiling light',
+        ...extend.light_onoff_brightness_colortemp_color({disableColorTempStartup: true, colorTempRange: [153, 500]}),
+        meta: {applyRedFix: true, enhancedHue: false},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_r0xgkft5'}],
         model: '14156506L',

package/devices/schneider_electric.js

@@ -4,6 +4,7 @@ const tz = require('../converters/toZigbee');
 const constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
+const utils = require('../lib/utils');
 const e = exposes.presets;
 const ea = exposes.access;
 
@@ -17,6 +18,67 @@ const tzLocal = {
     },
 };
 
+const fzLocal = {
+    schneider_powertag: {
+        cluster: 'greenPower',
+        type: ['commandNotification', 'commandCommisioningNotification'],
+        convert: async (model, msg, publish, options, meta) => {
+            if (msg.type !== 'commandNotification') {
+                return;
+            }
+
+            const commandID = msg.data.commandID;
+            if (utils.hasAlreadyProcessedMessage(msg, msg.data.frameCounter, `${msg.device.ieeeAddr}_${commandID}`)) return;
+
+            const rxAfterTx = (msg.data.options & (1<<11));
+            const ret = {};
+
+            switch (commandID) {
+            case 0xA1:
+                Object.entries(msg.data.commandFrame.attributes).forEach(([attr, val]) => {
+                    switch (attr) {
+                    case 'totalActivePower':
+                        ret['power'] = val;
+                        break;
+                    case 'currentSummDelivered':
+                        ret['energy'] = ((parseInt(val[0]) << 32) + parseInt(val[1])) / 1000.0;
+                        break;
+                    }
+                });
+
+                break;
+            case 0xA3:
+                // Should handle this cluster as well
+                break;
+            }
+
+            if (rxAfterTx) {
+                // Send Schneider specific ACK to make PowerTag happy
+                const networkParameters = await msg.device.zh.getNetworkParameters();
+                const payload = {
+                    options: 0b000,
+                    tempMaster: msg.data.gppNwkAddr,
+                    tempMasterTx: networkParameters.channel - 11,
+                    srcID: msg.data.srcID,
+                    gpdCmd: 0xFE,
+                    gpdPayload: {
+                        commandID: 0xFE,
+                        buffer: Buffer.alloc(1), // I hope it's zero initialised
+                    },
+                };
+
+                await msg.endpoint.commandResponse('greenPower', 'response', payload,
+                    {
+                        srcEndpoint: 242,
+                        disableDefaultResponse: true,
+                    });
+            }
+
+            return ret;
+        },
+    },
+};
+
 module.exports = [
     {
         zigbeeModel: ['PUCK/SHUTTER/1'],
@@ -714,4 +776,22 @@ module.exports = [
             await reporting.onOff(endpoint2);
         },
     },
+    {
+        zigbeeModel: ['CCT592011_AS'],
+        model: 'CCT592011',
+        vendor: 'Schneider Electric',
+        description: 'Wiser water leakage sensor',
+        fromZigbee: [fz.ias_water_leak_alarm_1],
+        toZigbee: [],
+        exposes: [e.battery_low(), e.water_leak(), e.tamper()],
+    },
+    {
+        fingerprint: [{modelID: 'GreenPower_254', ieeeAddr: /^0x00000000e.......$/}],
+        model: 'A9MEM1570',
+        vendor: 'Schneider Electric',
+        description: 'PowerTag power sensor',
+        fromZigbee: [fzLocal.schneider_powertag],
+        toZigbee: [],
+        exposes: [e.power(), e.energy()],
+    },
 ];

package/devices/tuya.js

@@ -178,6 +178,15 @@ module.exports = [
         exposes: [e.temperature(), e.humidity(), e.co2(), e.voc(), e.formaldehyd().withUnit('ppm'),
             e.pm25().withValueMin(0).withValueMax(999).withValueStep(1)],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_ogkdpgy2'}],
+        model: 'TS0601_co2_sensor',
+        vendor: 'TuYa',
+        description: 'NDIR co2 sensor',
+        fromZigbee: [fz.tuya_air_quality],
+        toZigbee: [],
+        exposes: [e.co2()],
+    },
     {
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_7bztmfm1'}],
         model: 'TS0601_smart_CO_air_box',
@@ -272,6 +281,7 @@ module.exports = [
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_leyz4rju'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_jd3z4yig'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_dgdjiw1c'},
+            {modelID: 'TS0505B', manufacturerName: '_TZ3210_mzdax7ha'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_a4s41wm4'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_qxenlrin'}],
         model: 'TS0505B',
@@ -301,7 +311,6 @@ module.exports = [
     {
         fingerprint: [{modelID: 'TS0504B', manufacturerName: '_TZ3000_ukuvyhaa'},
             {modelID: 'TS0504B', manufacturerName: '_TZ3210_bfvybixd'},
-            {modelID: 'TS0504B', manufacturerName: '_TZ3210_sroezl0s'},
             {modelID: 'TS0504B', manufacturerName: '_TZ3210_i2i0bsnv'},
             {modelID: 'TS0504B', manufacturerName: '_TZ3210_1elppmba'}],
         model: 'TS0504B',
@@ -1391,7 +1400,7 @@ module.exports = [
     },
     {
         fingerprint: [].concat(...TS011Fplugs.map((manufacturerName) => {
-            return [69, 68, 65, 64].map((applicationVersion) => {
+            return [69, 68, 65, 64, 74].map((applicationVersion) => {
                 return {modelID: 'TS011F', manufacturerName, applicationVersion};
             });
         })),

package/devices/xiaomi.js

@@ -874,7 +874,7 @@ module.exports = [
         model: 'RTCGQ12LM',
         vendor: 'Xiaomi',
         description: 'Aqara T1 human body movement and illuminance sensor',
-        fromZigbee: [fz.RTCGQ12LM_occupancy_illuminance, fz.aqara_opple, fz.battery],
+        fromZigbee: [fz.aqara_occupancy_illuminance, fz.aqara_opple, fz.battery],
         toZigbee: [tz.aqara_detection_interval],
         exposes: [e.occupancy(), e.illuminance().withUnit('lx').withDescription('Measured illuminance in lux'),
             exposes.numeric('detection_interval', ea.ALL).withValueMin(2).withValueMax(65535).withUnit('s')
@@ -906,6 +906,27 @@ module.exports = [
         },
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['lumi.motion.ac02'],
+        model: 'RTCGQ14LM',
+        vendor: 'Xiaomi',
+        whiteLabel: [{vendor: 'Xiaomi', model: 'MS-S02'}],
+        description: 'Aqara P1 human body movement and illuminance sensor',
+        fromZigbee: [fz.aqara_occupancy_illuminance, fz.aqara_opple, fz.battery],
+        toZigbee: [tz.aqara_detection_interval, tz.aqara_motion_sensitivity],
+        exposes: [e.occupancy(), e.illuminance().withUnit('lx').withDescription('Measured illuminance in lux'),
+            exposes.enum('motion_sensitivity', ea.ALL, ['low', 'medium', 'high']),
+            exposes.numeric('detection_interval', ea.ALL).withValueMin(2).withValueMax(65535).withUnit('s')
+                .withDescription('Time interval for detecting actions'), e.temperature(), e.battery()],
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('genPowerCfg', ['batteryVoltage']);
+            await endpoint.read('aqaraOpple', [0x0102], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x010c], {manufacturerCode: 0x115f});
+        },
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['lumi.motion.ac01'],
         model: 'RTCZCGQ11LM',

package/lib/tuya.js

@@ -645,6 +645,20 @@ const dataPoints = {
     // Moes switch with optional neutral
     moesSwitchPowerOnBehavior: 14,
     moesSwitchIndicateLight: 15,
+    // Connecte thermostat
+    connecteState: 1,
+    connecteMode: 2,
+    connecteHeatingSetpoint: 16,
+    connecteLocalTemp: 24,
+    connecteTempCalibration: 28,
+    connecteChildLock: 30,
+    connecteTempFloor: 101,
+    connecteSensorType: 102,
+    connecteHysteresis: 103,
+    connecteRunningState: 104,
+    connecteTempProgram: 105,
+    connecteOpenWindow: 106,
+    connecteMaxProtectTemp: 107,
 };
 
 const thermostatWeekFormat = {

package/lib/xiaomi.js

@@ -238,7 +238,7 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                     mapping = 'right';
                 }
                 payload[`state_${mapping}`] = value === 1 ? 'ON' : 'OFF';
-            } else if (['RTCGQ12LM'].includes(model.model)) {
+            } else if (['RTCGQ12LM', 'RTCGQ14LM'].includes(model.model)) {
                 payload.illuminance = calibrateAndPrecisionRoundOptions(value, options, 'illuminance');
             } else if (['WSDCGQ01LM', 'WSDCGQ11LM'].includes(model.model)) {
                 // https://github.com/Koenkk/zigbee2mqtt/issues/798
@@ -277,6 +277,13 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                 payload.motion_sensitivity = {1: 'low', 2: 'medium', 3: 'high'}[value];
             } else if (['RTCZCGQ11LM'].includes(model.model)) {
                 payload.approach_distance = {0: 'far', 1: 'medium', 2: 'near'}[value];
+            } else if (['RTCGQ14LM'].includes(model.model)) {
+                payload.detection_interval = value;
+            }
+            break;
+        case '106':
+            if (['RTCGQ14LM'].includes(model.model)) {
+                payload.motion_sensitivity = {1: 'low', 2: 'medium', 3: 'high'}[value];
             }
             break;
         case '149':

package/package.json

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