zigbee-herdsman-converters 14.0.614 → 14.0.617

package/converters/fromZigbee.js

@@ -5119,7 +5119,7 @@ const converters = {
                 '105_14': 'press_2_and_3_and_4', '105_15': 'press_all', '105_16': 'press_energy_bar', '106_0': 'release',
             };
 
-            const ID = `${commandID}_${msg.data.commandFrame.raw.join('_')}`;
+            const ID = `${commandID}_${msg.data.commandFrame.raw.slice(0, 1).join('_')}`;
             if (!lookup.hasOwnProperty(ID)) {
                 meta.logger.error(`PTM 216Z: missing command '${ID}'`);
             } else {

package/converters/toZigbee.js

@@ -1430,6 +1430,7 @@ const converters = {
             }
             const minHeatSetpointLimit = result;
             await entity.write('hvacThermostat', {minHeatSetpointLimit});
+            return {state: {min_heat_setpoint_limit: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['minHeatSetpointLimit']);
@@ -1446,11 +1447,46 @@ const converters = {
             }
             const maxHeatSetpointLimit = result;
             await entity.write('hvacThermostat', {maxHeatSetpointLimit});
+            return {state: {max_heat_setpoint_limit: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['maxHeatSetpointLimit']);
         },
     },
+    thermostat_min_cool_setpoint_limit: {
+        key: ['min_cool_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const minCoolSetpointLimit = result;
+            await entity.write('hvacThermostat', {minCoolSetpointLimit});
+            return {state: {min_cool_setpoint_limit: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['minCoolSetpointLimit']);
+        },
+    },
+    thermostat_max_cool_setpoint_limit: {
+        key: ['max_cool_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const maxCoolSetpointLimit = result;
+            await entity.write('hvacThermostat', {maxCoolSetpointLimit});
+            return {state: {max_cool_setpoint_limit: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['maxCoolSetpointLimit']);
+        },
+    },
     thermostat_ac_louver_position: {
         key: ['ac_louver_position'],
         convertSet: async (entity, key, value, meta) => {

package/devices/aurora_lighting.js

@@ -79,6 +79,13 @@ const batteryRotaryDimmer = (...endpointsIds) => ({
 });
 
 module.exports = [
+    {
+        zigbeeModel: ['RGBCXStrip50AU'],
+        model: 'AU-A1ZBSCRGBCX',
+        vendor: 'Aurora',
+        description: 'RGBW LED strip controller',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [166, 400]}),
+    },
     {
         zigbeeModel: ['TWGU10Bulb50AU'],
         model: 'AU-A1GUZBCX5',

package/devices/ecodim.js

@@ -38,6 +38,11 @@ module.exports = [
                 {ID: 1, profileID: 260, deviceID: 257, inputClusters: [0, 3, 4, 5, 6, 8, 2821, 4096], outputClusters: [25]},
                 {ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33]},
             ]},
+            {type: 'Router', manufacturerName: 'EcoDim BV', modelID: 'EcoDim-Zigbee 3.0', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 257, inputClusters: [0, 3, 4, 5, 6, 8, 2821, 4096], outputClusters: [25]},
+                {ID: 67, inputClusters: [], outputClusters: []},
+                {ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33]},
+            ]},
         ],
         zigbeeModel: ['Dimmer-Switch-ZB3.0'],
         model: 'Eco-Dim.07/Eco-Dim.10',

package/devices/ikea.js

@@ -924,6 +924,7 @@ module.exports = [
 
             await endpoint.read('manuSpecificIkeaAirPurifier', ['controlPanelLight', 'childLock', 'filterRunTime']);
         },
+        ota: ota.tradfri,
     },
     {
         zigbeeModel: ['TRADFRIbulbE14WScandleopal470lm', 'TRADFRIbulbE12WScandleopal450lm'],

package/devices/kwikset.js

@@ -55,15 +55,16 @@ module.exports = [
         model: '99140-031',
         vendor: 'Kwikset',
         description: 'SmartCode traditional electronic deadbolt',
-        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],
+        meta: {pinCodeCount: 30},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
             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_user()],
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
     },
     {
         zigbeeModel: ['SMARTCODE_DEADBOLT_5'],

package/devices/ledvance.js

@@ -199,6 +199,29 @@ module.exports = [
         extend: extend.ledvance.light_onoff_brightness(),
         ota: ota.ledvance,
     },
-
+    {
+        zigbeeModel: ['A60 FIL DIM T'],
+        model: '4058075729209',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Filament Classic A 52 E27 Amber dimmable',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+    {
+        zigbeeModel: ['EDISON60 FIL DIM T'],
+        model: '4058075729223',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Filament Edison 52 E27 Amber dimmable',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+    {
+        zigbeeModel: ['GLOBE60 FIL DIM T'],
+        model: '4058075729247',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Filament Globe125 52 E27 Amber dimmable',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
 
 ];

package/devices/owon.js

@@ -227,4 +227,52 @@ module.exports = [
             exposes.numeric('reactive_power_l3', ea.STATE).withUnit('VAr').withDescription('Phase 3 reactive power'),
         ],
     },
+    {
+        zigbeeModel: ['PCT504'],
+        model: 'PCT504',
+        vendor: 'OWON',
+        description: 'HVAC fan coil',
+        fromZigbee: [fz.fan, fz.thermostat, fz.humidity, fz.occupancy, fz.legacy.hvac_user_interface],
+        toZigbee: [tz.fan_mode, tz.thermostat_system_mode,
+            tz.thermostat_occupied_heating_setpoint, tz.thermostat_unoccupied_heating_setpoint,
+            tz.thermostat_occupied_cooling_setpoint, tz.thermostat_unoccupied_cooling_setpoint,
+            tz.thermostat_min_heat_setpoint_limit, tz.thermostat_max_heat_setpoint_limit,
+            tz.thermostat_min_cool_setpoint_limit, tz.thermostat_max_cool_setpoint_limit,
+            tz.thermostat_local_temperature, tz.thermostat_running_state,
+            tz.thermostat_keypad_lockout],
+        exposes: [e.humidity(), e.occupancy(),
+            exposes.climate().withSystemMode(['off', 'heat', 'cool', 'fan_only']).withRunningState(['idle', 'heat', 'cool', 'fan_only'])
+                .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withSetpoint('unoccupied_heating_setpoint', 5, 30, 0.5)
+                .withSetpoint('occupied_cooling_setpoint', 7, 35, 0.5).withSetpoint('unoccupied_cooling_setpoint', 7, 35, 0.5)
+                .withLocalTemperature(),
+            e.fan().withModes(['low', 'medium', 'high', 'on', 'auto']), e.keypad_lockout(),
+            e.max_heat_setpoint_limit(5, 30, 0.5), e.min_heat_setpoint_limit(5, 30, 0.5),
+            e.max_cool_setpoint_limit(7, 35, 0.5), e.min_cool_setpoint_limit(7, 35, 0.5)],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genBasic', 'genIdentify', 'genGroups', 'hvacThermostat', 'hvacUserInterfaceCfg', 'hvacFanCtrl',
+                'msTemperatureMeasurement', 'msOccupancySensing'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.fanMode(endpoint);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['hvacThermostat']);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
+            await reporting.thermostatUnoccupiedHeatingSetpoint(endpoint);
+            await reporting.thermostatOccupiedCoolingSetpoint(endpoint);
+            await reporting.thermostatUnoccupiedCoolingSetpoint(endpoint);
+            await reporting.thermostatTemperature(endpoint, {min: 60, max: 600, change: 0.1});
+            await reporting.thermostatSystemMode(endpoint);
+            await reporting.humidity(endpoint, {min: 60, max: 600, change: 1});
+            await reporting.thermostatKeypadLockMode(endpoint);
+
+            await endpoint.read('hvacThermostat', ['systemMode', 'runningState', 'occupiedHeatingSetpoint', 'unoccupiedHeatingSetpoint',
+                'occupiedCoolingSetpoint', 'unoccupiedCoolingSetpoint', 'localTemp'],
+            'minHeatSetpointLimit', 'maxHeatSetpointLimit', 'minCoolSetpointLimit', 'maxCoolSetpointLimit');
+            await endpoint.read('msRelativeHumidity', ['measuredValue']);
+
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['msOccupancySensing']);
+            await reporting.occupancy(endpoint2, {min: 1, max: 600, change: 1});
+            await endpoint2.read('msOccupancySensing', ['occupancy']);
+        },
+    },
 ];

package/devices/salus_controls.js

@@ -87,7 +87,12 @@ module.exports = [
         ota: ota.salus,
     },
     {
-        zigbeeModel: ['SS909ZB'],
+        zigbeeModel: [
+            'SS909ZB',
+            'PS600\u0000\u0000 �\u0001 ��\u0000\u0000\t\u0001@\u0011�u\u0000\u0000\u0018&\n\u0005\u0000B',
+            'PS600\u0000\u0000 �\u0001 ��\u0000\u0000\t\u0001@\u0011�u\u0000\u0000\u0018\u0006\n\u0005\u0000',
+            'PS600\u0000\u0000 �\u0001 ��\u0000\u0000\t\u0001@\u0011�u\u0000\u0000\u0018\u0006\n\u0005\u0000B',
+        ],
         model: 'PS600',
         vendor: 'Salus Controls',
         description: 'Pipe temperature sensor',

package/devices/sengled.js

@@ -61,8 +61,22 @@ module.exports = [
         model: 'E12-N1E',
         vendor: 'Sengled',
         description: 'Smart LED multicolor (BR30)',
-        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
+        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'],

package/devices/sonoff.js

@@ -5,6 +5,7 @@ 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 = {
@@ -18,6 +19,16 @@ 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 = [
@@ -189,4 +200,17 @@ module.exports = [
             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();
+        },
+    },
 ];

package/devices/tuya.js

@@ -277,6 +277,28 @@ const tzLocal = {
 };
 
 const fzLocal = {
+    tuya_dinrail_switch2: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataReport', 'commandDataResponse', 'commandActiveStatusReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'tuya_dinrail_switch2');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+            const state = value ? 'ON' : 'OFF';
+
+            switch (dp) {
+            case tuya.dataPoints.state: // DPID that we added to common
+                return {state: state};
+            case tuya.dataPoints.dinrailPowerMeterTotalEnergy2:
+                return {energy: value/100};
+            case tuya.dataPoints.dinrailPowerMeterPower2:
+                return {power: value};
+            default:
+                meta.logger.warn(`zigbee-herdsman-converters:TuyaDinRailSwitch: NOT RECOGNIZED DP ` +
+                    `#${dp} with data ${JSON.stringify(dpValue)}`);
+            }
+        },
+    },
     hpsz: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport'],
@@ -918,7 +940,12 @@ module.exports = [
         // Requires alarm_1_with_timeout https://github.com/Koenkk/zigbee2mqtt/issues/2818#issuecomment-776119586
         fromZigbee: [fz.ias_occupancy_alarm_1_with_timeout, fz.battery, fz.ignore_basic_report],
         toZigbee: [],
-        exposes: [e.occupancy(), e.battery_low(), e.linkquality()],
+        exposes: [e.occupancy(), e.battery_low(), e.linkquality(), e.battery(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
     },
     {
         fingerprint: [{modelID: 'TS0202', manufacturerName: '_TYZB01_dr6sduka'},
@@ -987,6 +1014,7 @@ module.exports = [
         fingerprint: [{modelID: 'TS0207', manufacturerName: '_TZ3000_m0vaazab'},
             {modelID: 'TS0207', manufacturerName: '_TZ3000_ufttklsz'},
             {modelID: 'TS0207', manufacturerName: '_TZ3000_nkkl7uzv'},
+            {modelID: 'TS0207', manufacturerName: '_TZ3000_gszjt2xx'},
             {modelID: 'TS0207', manufacturerName: '_TZ3000_5k5vh43t'}],
         model: 'TS0207_repeater',
         vendor: 'TuYa',
@@ -2104,6 +2132,19 @@ module.exports = [
         },
         exposes: [e.switch().setAccess('state', ea.STATE_SET), e.voltage(), e.power(), e.current(), e.energy()],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_bkkmqmyo'}],
+        model: 'DDS238-2',
+        vendor: 'TuYa',
+        description: 'Zigbee smart energy meter',
+        fromZigbee: [fzLocal.tuya_dinrail_switch2],
+        toZigbee: [tz.tuya_switch_state],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic']);
+        },
+        exposes: [e.switch().setAccess('state', ea.STATE_SET), e.energy(), e.power()],
+    },
     {
         fingerprint: [{modelID: 'TS1101', manufacturerName: '_TZ3000_xfs39dbf'}],
         model: 'TS1101_dimmer_module_1ch',
@@ -3028,7 +3069,8 @@ module.exports = [
         ],
     },
     {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_qoy0ekbd'}],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_qoy0ekbd'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_znbl8dj5'}],
         model: 'CX-0726',
         vendor: 'TuYa',
         description: 'Temperature & humidity LCD sensor',

package/lib/constants.js

@@ -24,6 +24,7 @@ const thermostatControlSequenceOfOperations = {
 const thermostatProgrammingOperationModes = {
     0: 'setpoint',
     1: 'schedule',
+    4: 'eco',
 };
 
 const thermostatSystemModes = {

package/lib/exposes.js

@@ -588,6 +588,10 @@ module.exports = {
         lock_action: () => new Enum('action', access.STATE, ['unknown', 'lock', 'unlock', 'lock_failure_invalid_pin_or_id', 'lock_failure_invalid_schedule', 'unlock_failure_invalid_pin_or_id', 'unlock_failure_invalid_schedule', 'one_touch_lock', 'key_lock', 'key_unlock', 'auto_lock', 'schedule_lock', 'schedule_unlock', 'manual_lock', 'manual_unlock', 'non_access_user_operational_event']).withDescription('Triggered action on the lock'),
         lock_action_source_name: () => new Enum('action_source_name', access.STATE, ['keypad', 'rfid', 'manual', 'rf']).withDescription('Source of the triggered action on the lock'),
         lock_action_user: () => new Numeric('action_user', access.STATE).withDescription('ID of user that triggered the action on the lock'),
+        max_cool_setpoint_limit: (min, max, step) => new Numeric('max_cool_setpoint_limit', access.ALL).withUnit('°C').withDescription('Maximum Cooling set point limit').withValueMin(min).withValueMax(max).withValueStep(step),
+        min_cool_setpoint_limit: (min, max, step) => new Numeric('min_cool_setpoint_limit', access.ALL).withUnit('°C').withDescription('Minimum Cooling point limit').withValueMin(min).withValueMax(max).withValueStep(step),
+        max_heat_setpoint_limit: (min, max, step) => new Numeric('max_heat_setpoint_limit', access.ALL).withUnit('°C').withDescription('Maximum Heating set point limit').withValueMin(min).withValueMax(max).withValueStep(step),
+        min_heat_setpoint_limit: (min, max, step) => new Numeric('min_heat_setpoint_limit', access.ALL).withUnit('°C').withDescription('Minimum Heating set point limit').withValueMin(min).withValueMax(max).withValueStep(step),
         max_temperature: () => new Numeric('max_temperature', access.STATE_SET).withUnit('°C').withDescription('Maximum temperature').withValueMin(15).withValueMax(35),
         max_temperature_limit: () => new Numeric('max_temperature_limit', access.STATE_SET).withUnit('°C').withDescription('Maximum temperature limit').withValueMin(0).withValueMax(35),
         min_temperature: () => new Numeric('min_temperature', access.STATE_SET).withUnit('°C').withDescription('Minimum temperature').withValueMin(1).withValueMax(15),
@@ -608,7 +612,7 @@ module.exports = {
         power_outage_memory: () => new Binary('power_outage_memory', access.ALL, true, false).withDescription('Enable/disable the power outage memory, this recovers the on/off mode after power failure'),
         presence: () => new Binary('presence', access.STATE, true, false).withDescription('Indicates whether the device detected presence'),
         pressure: () => new Numeric('pressure', access.STATE).withUnit('hPa').withDescription('The measured atmospheric pressure'),
-        programming_operation_mode: () => new Enum('programming_operation_mode', access.ALL, ['setpoint', 'schedule']).withDescription('Controls how programming affects the thermostat. Possible values: setpoint (only use specified setpoint), schedule (follow programmed setpoint schedule). Changing this value does not clear programmed schedules.'),
+        programming_operation_mode: () => new Enum('programming_operation_mode', access.ALL, ['setpoint', 'schedule', 'eco']).withDescription('Controls how programming affects the thermostat. Possible values: setpoint (only use specified setpoint), schedule (follow programmed setpoint schedule). Changing this value does not clear programmed schedules.'),
         smoke: () => new Binary('smoke', access.STATE, true, false).withDescription('Indicates whether the device detected smoke'),
         soil_moisture: () => new Numeric('soil_moisture', access.STATE).withUnit('%').withDescription('Measured soil moisture value'),
         sos: () => new Binary('sos', access.STATE, true, false).withDescription('SOS alarm'),

package/lib/tuya.js

@@ -595,6 +595,8 @@ const dataPoints = {
     dinrailPowerMeterCurrent: 18,
     dinrailPowerMeterPower: 19,
     dinrailPowerMeterVoltage: 20,
+    dinrailPowerMeterTotalEnergy2: 101,
+    dinrailPowerMeterPower2: 103,
     // tuya smart air box
     tuyaSabCO2: 2,
     tuyaSabTemp: 18,

package/package.json

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