zigbee-herdsman-converters 14.0.292 → 14.0.296

package/converters/fromZigbee.js

@@ -108,6 +108,26 @@ const converters = {
             if (msg.data.hasOwnProperty('tempSetpointHoldDuration')) {
                 result[postfixWithEndpointName('temperature_setpoint_hold_duration', msg, model)] = msg.data['tempSetpointHoldDuration'];
             }
+            if (msg.data.hasOwnProperty('minHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['minHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('min_heat_setpoint_limit', msg, model)] = value;
+            }
+            if (msg.data.hasOwnProperty('maxHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['maxHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('max_heat_setpoint_limit', msg, model)] = value;
+            }
+            if (msg.data.hasOwnProperty('absMinHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['absMinHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('abs_min_heat_setpoint_limit', msg, model)] = value;
+            }
+            if (msg.data.hasOwnProperty('absMaxHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['absMaxHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('abs_max_heat_setpoint_limit', msg, model)] = value;
+            }
             return result;
         },
     },
@@ -3007,6 +3027,62 @@ const converters = {
             if (msg.data.hasOwnProperty('danfossLoadEstimate')) {
                 result[postfixWithEndpointName('load_estimate', msg, model)] = msg.data['danfossLoadEstimate'];
             }
+            // Danfoss Icon Converters
+            if (msg.data.hasOwnProperty('danfossRoomStatusCode')) {
+                result[postfixWithEndpointName('room_status_code', msg, model)] =
+                    constants.danfossRoomStatusCode.hasOwnProperty(msg.data['danfossRoomStatusCode']) ?
+                        constants.danfossRoomStatusCode[msg.data['danfossRoomStatusCode']] :
+                        msg.data['danfossRoomStatusCode'];
+            }
+            if (msg.data.hasOwnProperty('danfossOutputStatus')) {
+                result[postfixWithEndpointName('output_status', msg, model)] =
+                    constants.danfossOutputStatus.hasOwnProperty(msg.data['danfossOutputStatus']) ?
+                        constants.danfossOutputStatus[msg.data['danfossOutputStatus']] :
+                        msg.data['danfossOutputStatus'];
+            }
+            return result;
+        },
+    },
+    danfoss_icon_battery: {
+        cluster: 'genPowerCfg',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('batteryPercentageRemaining')) {
+                // Some devices do not comply to the ZCL and report a
+                // batteryPercentageRemaining of 100 when the battery is full (should be 200).
+                const dontDividePercentage = model.meta && model.meta.battery && model.meta.battery.dontDividePercentage;
+                let percentage = msg.data['batteryPercentageRemaining'];
+                percentage = dontDividePercentage ? percentage : percentage / 2;
+
+                result[postfixWithEndpointName('battery', msg, model)] = precisionRound(percentage, 2);
+            }
+            return result;
+        },
+    },
+    danfoss_icon_regulator: {
+        cluster: 'haDiagnostic',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('danfossSystemStatusCode')) {
+                result[postfixWithEndpointName('system_status_code', msg, model)] =
+                constants.danfossSystemStatusCode.hasOwnProperty(msg.data['danfossSystemStatusCode']) ?
+                    constants.danfossSystemStatusCode[msg.data['danfossSystemStatusCode']] :
+                    msg.data['danfossSystemStatusCode'];
+            }
+            if (msg.data.hasOwnProperty('danfossSystemStatusWater')) {
+                result[postfixWithEndpointName('system_status_water', msg, model)] =
+                constants.danfossSystemStatusWater.hasOwnProperty(msg.data['danfossSystemStatusWater']) ?
+                    constants.danfossSystemStatusWater[msg.data['danfossSystemStatusWater']] :
+                    msg.data['danfossSystemStatusWater'];
+            }
+            if (msg.data.hasOwnProperty('danfossMultimasterRole')) {
+                result[postfixWithEndpointName('multimaster_role', msg, model)] =
+                constants.danfossMultimasterRole.hasOwnProperty(msg.data['danfossMultimasterRole']) ?
+                    constants.danfossMultimasterRole[msg.data['danfossMultimasterRole']] :
+                    msg.data['danfossMultimasterRole'];
+            }
             return result;
         },
     },
@@ -5366,22 +5442,30 @@ const converters = {
     tradfri_occupancy: {
         cluster: 'genOnOff',
         type: 'commandOnWithTimedOff',
-        options: [exposes.options.occupancy_timeout()],
+        options: [exposes.options.occupancy_timeout(), exposes.options.illuminance_below_threshold_check()],
         convert: (model, msg, publish, options, meta) => {
-            if (msg.data.ctrlbits === 1) return;
+            const onlyWhenOnFlag = (msg.data.ctrlbits & 1) != 0;
+            if (onlyWhenOnFlag &&
+                (!options || !options.hasOwnProperty('illuminance_below_threshold_check') ||
+                  options.illuminance_below_threshold_check) &&
+                !globalStore.hasValue(msg.endpoint, 'timer')) return;
 
             const timeout = options && options.hasOwnProperty('occupancy_timeout') ?
                 options.occupancy_timeout : msg.data.ontime / 10;
 
             // Stop existing timer because motion is detected and set a new one.
             clearTimeout(globalStore.getValue(msg.endpoint, 'timer'));
+            globalStore.clearValue(msg.endpoint, 'timer');
 
             if (timeout !== 0) {
-                const timer = setTimeout(() => publish({occupancy: false}), timeout * 1000);
+                const timer = setTimeout(() => {
+                    publish({occupancy: false});
+                    globalStore.clearValue(msg.endpoint, 'timer');
+                }, timeout * 1000);
                 globalStore.putValue(msg.endpoint, 'timer', timer);
             }
 
-            return {occupancy: true};
+            return {occupancy: true, illuminance_above_threshold: onlyWhenOnFlag};
         },
     },
     almond_click: {
@@ -6865,10 +6949,10 @@ const converters = {
                 }
                 break;
             case tuya.dataPoints.tvWindowDetection:
-                result = {window_detection: {1: false, 0: true}[value]};
+                result = {window_detection: {1: true, 0: false}[value]};
                 break;
             case tuya.dataPoints.tvFrostDetection:
-                result = {frost_detection: {1: false, 0: true}[value]};
+                result = {frost_detection: {1: true, 0: false}[value]};
                 break;
             case tuya.dataPoints.tvHeatingSetpoint:
                 result = {current_heating_setpoint: (value / 10).toFixed(1)};
@@ -6931,6 +7015,23 @@ const converters = {
             return {people: msg.data.presentValue};
         },
     },
+    sihas_action: {
+        cluster: 'genOnOff',
+        type: ['commandOn', 'commandOff', 'commandToggle'],
+        convert: (model, msg, publish, options, meta) => {
+            const lookup = {'commandToggle': 'long', 'commandOn': 'double', 'commandOff': 'single'};
+            let buttonMapping = null;
+            if (model.model === 'SBM300ZB2') {
+                buttonMapping = {1: '1', 2: '2'};
+            } else if (model.model === 'SBM300ZB3') {
+                buttonMapping = {1: '1', 2: '2', 3: '3'};
+            } else if (model.model === 'MSM-300ZB') {
+                buttonMapping = {1: '1', 2: '2', 3: '3', 4: '4'};
+            }
+            const button = buttonMapping ? `${buttonMapping[msg.endpoint.ID]}_` : '';
+            return {action: `${button}${lookup[msg.type]}`};
+        },
+    },
     hoch_din: {
         cluster: 'manuSpecificTuya',
         type: ['commandGetData', 'commandSetDataResponse'],
@@ -7035,6 +7136,17 @@ const converters = {
             return result;
         },
     },
+    tuya_operation_mode: {
+        cluster: 'genOnOff',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('tuyaOperationMode')) {
+                const value = msg.data['tuyaOperationMode'];
+                const lookup = {0: 'command', 1: 'event'};
+                return {operation_mode: lookup[value]};
+            }
+        },
+    },
     // #endregion
 
     // #region Ignore converters (these message dont need parsing).

package/converters/toZigbee.js

@@ -1327,6 +1327,38 @@ const converters = {
             await entity.read('hvacThermostat', ['runningMode']);
         },
     },
+    thermostat_min_heat_setpoint_limit: {
+        key: ['min_heat_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const minHeatSetpointLimit = result;
+            await entity.write('hvacThermostat', {minHeatSetpointLimit});
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['minHeatSetpointLimit']);
+        },
+    },
+    thermostat_max_heat_setpoint_limit: {
+        key: ['max_heat_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const maxHeatSetpointLimit = result;
+            await entity.write('hvacThermostat', {maxHeatSetpointLimit});
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['maxHeatSetpointLimit']);
+        },
+    },
     electrical_measurement_power: {
         key: ['power'],
         convertGet: async (entity, key, meta) => {
@@ -2484,6 +2516,36 @@ const converters = {
             await entity.read('hvacThermostat', ['danfossLoadEstimate'], manufacturerOptions.danfoss);
         },
     },
+    danfoss_output_status: {
+        key: ['output_status'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['danfossOutputStatus'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_room_status_code: {
+        key: ['room_status_code'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['danfossRoomStatusCode'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_system_status_code: {
+        key: ['system_status_code'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('haDiagnostic', ['danfossSystemStatusCode'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_system_status_water: {
+        key: ['system_status_water'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('haDiagnostic', ['danfossSystemStatusWater'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_multimaster_role: {
+        key: ['multimaster_role'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('haDiagnostic', ['danfossMultimasterRole'], manufacturerOptions.danfoss);
+        },
+    },
     ZMCSW032D_cover_position: {
         key: ['position', 'tilt'],
         convertSet: async (entity, key, value, meta) => {
@@ -5868,7 +5930,7 @@ const converters = {
         key: [
             'system_mode', 'window_detection', 'frost_detection', 'child_lock',
             'current_heating_setpoint', 'local_temperature_calibration',
-            'holiday_temperature', 'comfort_temperature', 'eco_temperature', 'boost_mode',
+            'holiday_temperature', 'comfort_temperature', 'eco_temperature',
             'open_window_temperature', 'heating_stop', 'preset',
         ],
         convertSet: async (entity, key, value, meta) => {
@@ -5882,13 +5944,18 @@ const converters = {
                 }
                 break;
             case 'window_detection':
-                await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvWindowDetection, (value) ? 0 : 1);
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.tvWindowDetection, value);
                 break;
             case 'frost_detection':
-                await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvFrostDetection, (value) ? 0 : 1);
+                if (value == false) {
+                    await tuya.sendDataPointBool(entity, tuya.dataPoints.tvFrostDetection, 0);
+                    await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvMode, 1);
+                } else {
+                    await tuya.sendDataPointBool(entity, tuya.dataPoints.tvFrostDetection, 1);
+                }
                 break;
             case 'child_lock':
-                await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvChildLock, {'unlock': 0, 'lock': 1}[value.toLowerCase()]);
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.tvChildLock, value === 'LOCK');
                 break;
             case 'local_temperature_calibration':
                 value = Math.round(value * 10);
@@ -5949,6 +6016,22 @@ const converters = {
             await endpoint.read('genAnalogInput', ['presentValue']);
         },
     },
+    tuya_operation_mode: {
+        key: ['operation_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            // modes:
+            // 0 - 'command' mode. keys send commands. useful for group control
+            // 1 - 'event' mode. keys send events. useful for handling
+            const lookup = {command: 0, event: 1};
+            const endpoint = meta.device.getEndpoint(1);
+            await endpoint.write('genOnOff', {'tuyaOperationMode': lookup[value.toLowerCase()]});
+            return {state: {operation_mode: value.toLowerCase()}};
+        },
+        convertGet: async (entity, key, meta) => {
+            const endpoint = meta.device.getEndpoint(1);
+            await endpoint.read('genOnOff', ['tuyaOperationMode']);
+        },
+    },
     // #endregion
 
     // #region Ignore converters

package/devices/adeo.js

@@ -76,4 +76,13 @@ module.exports = [
         },
         exposes: [e.power(), e.switch(), e.energy()],
     },
+    {
+        zigbeeModel: ['LDSENK10'],
+        model: 'LDSENK10',
+        vendor: 'ADEO',
+        description: 'LEXMAN motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_low(), e.tamper()],
+    },
 ];

package/devices/danfoss.js

@@ -122,4 +122,133 @@ module.exports = [
             endpoint.write('genTime', values);
         },
     },
+    {
+        fingerprint: [
+            {modelID: '0x8020', manufacturerName: 'Danfoss'}, // RT24V Display
+            {modelID: '0x8021', manufacturerName: 'Danfoss'}, // RT24V Display  Floor sensor
+            {modelID: '0x8030', manufacturerName: 'Danfoss'}, // RTbattery Display
+            {modelID: '0x8031', manufacturerName: 'Danfoss'}, // RTbattery Display Infrared
+            {modelID: '0x8034', manufacturerName: 'Danfoss'}, // RTbattery Dial
+            {modelID: '0x8035', manufacturerName: 'Danfoss'}], // RTbattery Dial Infrared
+        model: 'Icon',
+        vendor: 'Danfoss',
+        description: 'Icon floor heating (regulator, Zigbee module & thermostats)',
+        fromZigbee: [
+            fz.danfoss_icon_regulator,
+            fz.danfoss_thermostat,
+            fz.danfoss_icon_battery,
+            fz.thermostat],
+        toZigbee: [
+            tz.thermostat_local_temperature,
+            tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_system_mode,
+            tz.thermostat_min_heat_setpoint_limit,
+            tz.thermostat_max_heat_setpoint_limit,
+            tz.danfoss_output_status,
+            tz.danfoss_room_status_code,
+            tz.danfoss_system_status_water,
+            tz.danfoss_system_status_code,
+            tz.danfoss_multimaster_role,
+        ],
+        meta: {multiEndpoint: true},
+        // ota: ota.zigbeeOTA,
+        endpoint: (device) => {
+            return {
+                'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4, 'l5': 5,
+                'l6': 6, 'l7': 7, 'l8': 8, 'l9': 9, 'l10': 10,
+                'l11': 11, 'l12': 12, 'l13': 13, 'l14': 14, 'l15': 15, 'l16': 232,
+            };
+        },
+        exposes: [].concat(((endpointsCount) => {
+            const features = [];
+            for (let i = 1; i <= endpointsCount; i++) {
+                const epName = `l${i}`;
+                if (i!=16) {
+                    features.push(e.battery().withEndpoint(epName));
+                    features.push(exposes.climate().withSetpoint('occupied_heating_setpoint', 4, 30, 0.5)
+                        .withLocalTemperature().withSystemMode(['heat']).withEndpoint(epName));
+                    features.push(exposes.numeric('abs_min_heat_setpoint_limit', ea.STATE)
+                        .withUnit('°C').withEndpoint(epName)
+                        .withDescription('Absolute min temperature allowed on the device'));
+                    features.push(exposes.numeric('abs_max_heat_setpoint_limit', ea.STATE)
+                        .withUnit('°C').withEndpoint(epName)
+                        .withDescription('Absolute max temperature allowed on the device'));
+                    features.push(exposes.numeric('min_heat_setpoint_limit', ea.ALL)
+                        .withValueMin(4).withValueMax(30).withValueStep(0.5).withUnit('°C')
+                        .withEndpoint(epName).withDescription('Min temperature limit set on the device'));
+                    features.push(exposes.numeric('max_heat_setpoint_limit', ea.ALL)
+                        .withValueMin(4).withValueMax(30).withValueStep(0.5).withUnit('°C')
+                        .withEndpoint(epName).withDescription('Max temperature limit set on the device'));
+                    features.push(exposes.enum('setpoint_change_source', ea.STATE, ['manual', 'schedule', 'externally'])
+                        .withEndpoint(epName));
+                    features.push(exposes.enum('output_status', ea.STATE_GET, ['inactive', 'active'])
+                        .withEndpoint(epName).withDescription('Danfoss Output Status [Active vs Inactive])'));
+                    features.push(exposes.enum('room_status_code', ea.STATE_GET, ['no_error', 'missing_rt',
+                        'rt_touch_error', 'floor_sensor_short_circuit', 'floor_sensor_disconnected'])
+                        .withEndpoint(epName).withDescription('Thermostat status'));
+                } else {
+                    features.push(exposes.enum('system_status_code', ea.STATE_GET, ['no_error', 'missing_expansion_board',
+                        'missing_radio_module', 'missing_command_module', 'missing_master_rail', 'missing_slave_rail_no_1',
+                        'missing_slave_rail_no_2', 'pt1000_input_short_circuit', 'pt1000_input_open_circuit',
+                        'error_on_one_or_more_output']).withEndpoint('l16').withDescription('Regulator Status'));
+                    features.push(exposes.enum('system_status_water', ea.STATE_GET, ['hot_water_flow_in_pipes', 'cool_water_flow_in_pipes'])
+                        .withEndpoint('l16').withDescription('Water Status of Regulator'));
+                    features.push(exposes.enum('multimaster_role', ea.STATE_GET, ['invalid_unused', 'master', 'slave_1', 'slave_2'])
+                        .withEndpoint('l16').withDescription('Regulator role (Master vs Slave)'));
+                }
+            }
+
+            return features;
+        })(16)),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const options = {manufacturerCode: 0x1246};
+
+            for (let i = 1; i <= 15; i++) {
+                const endpoint = device.getEndpoint(i);
+                if (typeof endpoint !== 'undefined') {
+                    await reporting.bind(endpoint, coordinatorEndpoint,
+                        ['genPowerCfg', 'hvacThermostat', 'hvacUserInterfaceCfg']);
+                    await reporting.batteryPercentageRemaining(endpoint,
+                        {min: constants.repInterval.HOUR, max: 43200, change: 1});
+                    await reporting.thermostatTemperature(endpoint,
+                        {min: 0, max: constants.repInterval.MINUTES_10, change: 10});
+                    await reporting.thermostatOccupiedHeatingSetpoint(endpoint,
+                        {min: 0, max: constants.repInterval.MINUTES_10, change: 10});
+
+                    await endpoint.configureReporting('hvacThermostat', [{
+                        attribute: 'danfossOutputStatus',
+                        minimumReportInterval: constants.repInterval.MINUTE,
+                        maximumReportInterval: constants.repInterval.MINUTES_10,
+                        reportableChange: 1,
+                    }], options);
+
+                    // Danfoss Icon Thermostat Specific
+                    await endpoint.read('hvacThermostat', [
+                        'danfossOutputStatus',
+                        'danfossRoomStatusCode'], options);
+
+                    // Standard Thermostat
+                    await endpoint.read('hvacThermostat', ['localTemp']);
+                    await endpoint.read('hvacThermostat', ['occupiedHeatingSetpoint']);
+                    await endpoint.read('hvacThermostat', ['systemMode']);
+                    await endpoint.read('hvacThermostat', ['setpointChangeSource']);
+                    await endpoint.read('hvacThermostat', ['absMinHeatSetpointLimit']);
+                    await endpoint.read('hvacThermostat', ['absMaxHeatSetpointLimit']);
+                    await endpoint.read('hvacThermostat', ['minHeatSetpointLimit']);
+                    await endpoint.read('hvacThermostat', ['maxHeatSetpointLimit']);
+                    await endpoint.read('genPowerCfg', ['batteryPercentageRemaining']);
+                }
+            }
+
+            // Danfoss Icon Regulator Specific
+            const endpoint232 = device.getEndpoint(232);
+
+            await reporting.bind(endpoint232, coordinatorEndpoint, ['haDiagnostic']);
+
+            await endpoint232.read('haDiagnostic', [
+                'danfossSystemStatusCode',
+                'danfossSystemStatusWater',
+                'danfossMultimasterRole'], options);
+        },
+    },
 ];

package/devices/ikea.js

@@ -194,10 +194,8 @@ module.exports = [
         model: 'LED1624G9',
         vendor: 'IKEA',
         description: 'TRADFRI LED bulb E14/E26/E27 600 lumen, dimmable, color, opal white',
-        extend: extend.light_onoff_brightness_color(),
-        ota: ota.tradfri,
+        extend: tradfriExtend.light_onoff_brightness_colortemp_color(),
         meta: {supportsHueAndSaturation: false},
-        onEvent: bulbOnEvent,
     },
     {
         zigbeeModel: ['TRADFRI bulb E26 CWS 800lm', 'TRADFRI bulb E27 CWS 806lm'],
@@ -488,7 +486,9 @@ module.exports = [
         toZigbee: [],
         exposes: [e.battery(), e.occupancy(),
             exposes.numeric('requested_brightness_level', ea.STATE).withValueMin(76).withValueMax(254),
-            exposes.numeric('requested_brightness_percent', ea.STATE).withValueMin(30).withValueMax(100)],
+            exposes.numeric('requested_brightness_percent', ea.STATE).withValueMin(30).withValueMax(100),
+            exposes.binary('illuminance_above_threshold', ea.STATE, true, false)
+                .withDescription('Indicates whether the device detected bright light (works only in night mode)')],
         ota: ota.tradfri,
         meta: {battery: {dontDividePercentage: true}},
         configure: async (device, coordinatorEndpoint, logger) => {

package/devices/lupus.js

@@ -54,7 +54,7 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['PRS3CH2_00.00.05.10TC', 'PRS3CH2_00.00.05.11TC'],
+        zigbeeModel: ['PRS3CH2_00.00.05.10TC', 'PRS3CH2_00.00.05.11TC', 'PRS3CH2_00.00.05.12TC'],
         model: '12127',
         vendor: 'Lupus',
         description: '2 chanel relay',

package/devices/philips.js

@@ -2165,4 +2165,22 @@ module.exports = [
         meta: {turnsOffAtBrightness1: true},
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['LTF001'],
+        model: '6109231C5',
+        vendor: 'Philips',
+        description: 'Hue white ambiance Apogee square',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['LTF002'],
+        model: '6109331C5',
+        vendor: 'Philips',
+        description: 'Hue white ambiance Apogee round',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+    },
 ];

package/devices/sercomm.js

@@ -70,7 +70,7 @@ module.exports = [
         exposes: [e.contact(), e.battery_low(), e.tamper(), e.temperature(), e.battery()],
     },
     {
-        zigbeeModel: ['SZ-DWS08N'],
+        zigbeeModel: ['SZ-DWS08N', 'SZ-DWS08'],
         model: 'SZ-DWS08',
         vendor: 'Sercomm',
         description: 'Magnetic door & window contact sensor',

package/devices/shinasystem.js

@@ -11,7 +11,7 @@ module.exports = [
         zigbeeModel: ['CSM-300Z'],
         model: 'CSM-300ZB',
         vendor: 'ShinaSystem',
-        description: 'Sihas multipurpose sensor',
+        description: 'SiHAS multipurpose sensor',
         meta: {battery: {voltageToPercentage: '3V_2100'}},
         fromZigbee: [fz.battery, fz.sihas_people_cnt],
         toZigbee: [tz.sihas_set_people],
@@ -30,7 +30,7 @@ module.exports = [
         zigbeeModel: ['USM-300Z'],
         model: 'USM-300ZB',
         vendor: 'ShinaSystem',
-        description: 'Sihas multipurpose sensor',
+        description: 'SiHAS multipurpose sensor',
         meta: {battery: {voltageToPercentage: '3V_2100'}},
         fromZigbee: [fz.battery, fz.temperature, fz.humidity, fz.occupancy, fz.illuminance],
         toZigbee: [],
@@ -51,7 +51,7 @@ module.exports = [
         zigbeeModel: ['SBM300Z1'],
         model: 'SBM300Z1',
         vendor: 'ShinaSystem',
-        description: 'IOT smart switch 1 gang',
+        description: 'SiHAS IOT smart switch 1 gang',
         extend: extend.switch(),
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -63,7 +63,7 @@ module.exports = [
         zigbeeModel: ['SBM300Z2'],
         model: 'SBM300Z2',
         vendor: 'ShinaSystem',
-        description: 'IOT smart switch 2 gang',
+        description: 'SiHAS IOT smart switch 2 gang',
         extend: extend.switch(),
         exposes: [e.switch().withEndpoint('top'), e.switch().withEndpoint('bottom')],
         endpoint: (device) => {
@@ -81,7 +81,7 @@ module.exports = [
         zigbeeModel: ['SBM300Z3'],
         model: 'SBM300Z3',
         vendor: 'ShinaSystem',
-        description: 'IOT smart switch 3 gang',
+        description: 'SiHAS IOT smart switch 3 gang',
         extend: extend.switch(),
         exposes: [e.switch().withEndpoint('top'), e.switch().withEndpoint('center'), e.switch().withEndpoint('bottom')],
         endpoint: (device) => {
@@ -101,7 +101,7 @@ module.exports = [
         zigbeeModel: ['SBM300Z4'],
         model: 'SBM300Z4',
         vendor: 'ShinaSystem',
-        description: 'IOT smart switch 4 gang',
+        description: 'SiHAS IOT smart switch 4 gang',
         extend: extend.switch(),
         exposes: [e.switch().withEndpoint('top_left'), e.switch().withEndpoint('bottom_left'),
             e.switch().withEndpoint('top_right'), e.switch().withEndpoint('bottom_right')],
@@ -124,7 +124,7 @@ module.exports = [
         zigbeeModel: ['SBM300Z5'],
         model: 'SBM300Z5',
         vendor: 'ShinaSystem',
-        description: 'IOT smart switch 5 gang',
+        description: 'SiHAS IOT smart switch 5 gang',
         extend: extend.switch(),
         exposes: [e.switch().withEndpoint('top_left'), e.switch().withEndpoint('top_right'), e.switch().withEndpoint('center_left'),
             e.switch().withEndpoint('bottom_left'), e.switch().withEndpoint('bottom_right')],
@@ -149,7 +149,7 @@ module.exports = [
         zigbeeModel: ['SBM300Z6'],
         model: 'SBM300Z6',
         vendor: 'ShinaSystem',
-        description: 'IOT smart switch 6 gang',
+        description: 'SiHAS IOT smart switch 6 gang',
         extend: extend.switch(),
         exposes: [e.switch().withEndpoint('top_left'), e.switch().withEndpoint('bottom_left'), e.switch().withEndpoint('center_left'),
             e.switch().withEndpoint('center_right'), e.switch().withEndpoint('top_right'), e.switch().withEndpoint('bottom_right')],
@@ -172,4 +172,114 @@ module.exports = [
             await reporting.onOff(device.getEndpoint(6));
         },
     },
+    {
+        zigbeeModel: ['BSM-300Z'],
+        model: 'BSM-300ZB',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.battery, fz.sihas_action],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'long'])],
+    },
+    {
+        zigbeeModel: ['TSM-300Z'],
+        model: 'TSM-300ZB',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS temperature/humidity sensor',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.temperature, fz.humidity, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'msRelativeHumidity', 'genPowerCfg']);
+            await reporting.temperature(endpoint, {min: 30, max: 300, change: 30});
+            await reporting.humidity(endpoint, {min: 30, max: 3600, change: 50});
+            await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
+        },
+        exposes: [e.temperature(), e.humidity(), e.battery(), e.battery_voltage()],
+    },
+    {
+        zigbeeModel: ['DSM-300Z'],
+        model: 'DSM-300ZB',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS contact sensor',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['ssIasZone', 'genPowerCfg']);
+            await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState', 'zoneId']);
+            await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
+        },
+        exposes: [e.contact(), e.battery(), e.battery_voltage()],
+    },
+    {
+        zigbeeModel: ['MSM-300Z'],
+        model: 'MSM-300ZB',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control 4 button',
+        fromZigbee: [fz.sihas_action, fz.battery],
+        toZigbee: [],
+        exposes: [e.action(['1_single', '1_double', '1_long', '2_single', '2_double', '2_long',
+            '3_single', '3_double', '3_long', '4_single', '4_double', '4_long']), e.battery(), e.battery_voltage()],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
+        },
+    },
+    {
+        zigbeeModel: ['SBM300ZB1'],
+        model: 'SBM300ZB1',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.battery, fz.sihas_action],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'long'])],
+    },
+    {
+        zigbeeModel: ['SBM300ZB2'],
+        model: 'SBM300ZB2',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control 2 button',
+        fromZigbee: [fz.sihas_action, fz.battery],
+        toZigbee: [],
+        exposes: [e.action(['1_single', '1_double', '1_long', '2_single', '2_double', '2_long']), e.battery(), e.battery_voltage()],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
+        },
+    },
+    {
+        zigbeeModel: ['SBM300ZB3'],
+        model: 'SBM300ZB3',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control 3 button',
+        fromZigbee: [fz.sihas_action, fz.battery],
+        toZigbee: [],
+        exposes: [e.action(['1_single', '1_double', '1_long', '2_single', '2_double', '2_long',
+            '3_single', '3_double', '3_long']), e.battery(), e.battery_voltage()],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
+        },
+    },
 ];

package/devices/the_light_group.js

@@ -1,5 +1,7 @@
 const exposes = require('../lib/exposes');
 const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
 const e = exposes.presets;
 
 module.exports = [
@@ -21,4 +23,17 @@ module.exports = [
             return {l1: 1, l2: 2, l3: 3, l4: 4};
         },
     },
+    {
+        zigbeeModel: ['S24013'],
+        model: 'S24013',
+        vendor: 'The Light Group',
+        description: 'SLC SmartOne AC dimmer mini 200W Zigbee LN',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint);
+        },
+    },
 ];

package/devices/tuya.js

@@ -103,6 +103,7 @@ module.exports = [
     {
         fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3000_qqjaziws'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3000_jtmhndw2'},
+            {modelID: 'TS0505B', manufacturerName: '_TZ3000_ezlg0pht'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_5snkkrxw'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3000_12sxjap4'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3000_x2fqbdun'},
@@ -423,6 +424,7 @@ module.exports = [
     {
         fingerprint: [
             {modelID: 'TS0502B', manufacturerName: '_TZ3210_s1x7gcq0'},
+            {modelID: 'TS0502B', manufacturerName: '_TZ3000_muqovqv0'},
             {modelID: 'TS0502B', manufacturerName: '_TZ3210_hi1ym4bl'},
             {modelID: 'TS0502B', manufacturerName: '_TZ3210_psgq7ysz'},
             {modelID: 'TS0502B', manufacturerName: '_TZ3000_zw7wr5uo'},
@@ -744,13 +746,12 @@ module.exports = [
     {
         zigbeeModel: ['kud7u2l'],
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_ckud7u2l'}, {modelID: 'TS0601', manufacturerName: '_TZE200_ywdxldoj'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_cwnjrr72'}, {modelID: 'TS0601', manufacturerName: '_TZE200_chyvmhay'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_a4bpgplm'}],
+            {modelID: 'TS0601', manufacturerName: '_TZE200_cwnjrr72'}, {modelID: 'TS0601', manufacturerName: '_TZE200_chyvmhay'}],
         model: 'TS0601_thermostat',
         vendor: 'TuYa',
         description: 'Radiator valve with thermostat',
         whiteLabel: [{vendor: 'Moes', model: 'HY368'}, {vendor: 'Moes', model: 'HY369RT'}, {vendor: 'SHOJZJ', model: '378RT'},
-            {vendor: 'Silvercrest', model: 'TVR01'}, {vendor: 'Haozee', model: 'TRV601'}],
+            {vendor: 'Silvercrest', model: 'TVR01'}],
         meta: {tuyaThermostatPreset: tuya.thermostatPresets, tuyaThermostatSystemMode: tuya.thermostatSystemModes3},
         ota: ota.zigbeeOTA,
         onEvent: tuya.onEventSetLocalTime,
@@ -865,7 +866,7 @@ module.exports = [
         extend: extend.switch(),
     },
     {
-        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_cphmq0q7'},
+        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_cphmq0q7', applicationVersion: 67},
             {modelID: 'TS011F', manufacturerName: '_TZ3000_ew3ldmgx'},
             {modelID: 'TS011F', manufacturerName: '_TZ3000_ps3dmato'},
             {modelID: 'TS011F', manufacturerName: '_TZ3000_mraovvmm'},
@@ -906,7 +907,8 @@ module.exports = [
             .withDescription('Recover state after power outage')],
     },
     {
-        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_dpo1ysak'}],
+        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_dpo1ysak'},
+            {modelID: 'TS011F', manufacturerName: '_TZ3000_cphmq0q7', applicationVersion: 69}],
         model: 'TS011F_plug_3',
         description: 'Smart plug (with power monitoring by polling)',
         vendor: 'TuYa',
@@ -914,6 +916,7 @@ module.exports = [
         toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
             endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {acCurrentDivisor: 1000, acCurrentMultiplier: 1});
             endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 100, multiplier: 1});
             device.save();
@@ -1411,20 +1414,26 @@ module.exports = [
         model: 'YSR-MINI-Z',
         vendor: 'TuYa',
         description: '2 in 1 dimming remote control and scene control',
-        exposes: [e.battery(), e.action([
-            'on', 'off',
-            'brightness_move_up', 'brightness_step_up', 'brightness_step_down', 'brightness_move_down', 'brightness_stop',
-            'color_temperature_step_down', 'color_temperature_step_up',
-            '1_single', '1_double', '1_hold', '2_single', '2_double', '2_hold',
-            '3_single', '3_double', '3_hold', '4_single', '4_double', '4_hold',
-        ])],
+        exposes: [
+            e.battery(),
+            e.action(['on', 'off',
+                'brightness_move_up', 'brightness_step_up', 'brightness_step_down', 'brightness_move_down', 'brightness_stop',
+                'color_temperature_step_down', 'color_temperature_step_up',
+                '1_single', '1_double', '1_hold', '2_single', '2_double', '2_hold',
+                '3_single', '3_double', '3_hold', '4_single', '4_double', '4_hold',
+            ]),
+            exposes.enum('operation_mode', ea.ALL, ['command', 'event']).withDescription(
+                'Operation mode: "command" - for group control, "event" - for clicks'),
+        ],
         fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_step, fz.command_move, fz.command_stop,
-            fz.command_step_color_temperature, fz.tuya_on_off_action],
-        toZigbee: [],
+            fz.command_step_color_temperature, fz.tuya_on_off_action, fz.tuya_operation_mode],
+        toZigbee: [tz.tuya_operation_mode],
+        onEvent: tuya.onEventSetLocalTime,
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
             await reporting.batteryPercentageRemaining(endpoint);
+            await endpoint.read('genOnOff', ['tuyaOperationMode']);
         },
     },
     {

package/devices/yale.js

@@ -100,6 +100,13 @@ module.exports = [
         description: 'Assure lock SL',
         extend: lockExtend(),
     },
+    {
+        zigbeeModel: ['YRL226 TS'],
+        model: 'YRL226 TS',
+        vendor: 'Yale',
+        description: 'Assure lock SL',
+        extend: lockExtend(),
+    },
     {
         // Appears to be a slightly rebranded Assure lock SL
         // Just with Lockwood | Assa Abloy branding instead of Yale

package/lib/constants.js

@@ -91,6 +91,44 @@ const danfossWindowOpen = {
     4: 'external_open',
 };
 
+const danfossRoomStatusCode = {
+    0x0000: 'no_error',
+    0x0101: 'missing_rt',
+    0x0201: 'rt_touch_error',
+    0x0401: 'floor_sensor_short_circuit',
+    0x0801: 'floor_sensor_disconnected',
+};
+
+const danfossOutputStatus = {
+    0: 'inactive',
+    1: 'active',
+};
+
+const danfossSystemStatusWater = {
+    0: 'hot_water_flow_in_pipes',
+    1: 'cool_water_flow_in_pipes',
+};
+
+const danfossSystemStatusCode = {
+    0x0000: 'no_error',
+    0x0101: 'missing_expansion_board',
+    0x0201: 'missing_radio_module',
+    0x0401: 'missing_command_module',
+    0x0801: 'missing_master_rail',
+    0x1001: 'missing_slave_rail_no_1',
+    0x2001: 'missing_slave_rail_no_2',
+    0x4001: 'pt1000_input_short_circuit',
+    0x8001: 'pt1000_input_open_circuit',
+    0x0102: 'error_on_one_or_more_output',
+};
+
+const danfossMultimasterRole = {
+    0: 'invalid_unused',
+    1: 'master',
+    2: 'slave_1',
+    3: 'slave_2',
+};
+
 const keypadLockoutMode = {
     0: 'unlock',
     1: 'lock1',
@@ -196,6 +234,11 @@ module.exports = {
     fanMode,
     temperatureDisplayMode,
     danfossWindowOpen,
+    danfossRoomStatusCode,
+    danfossOutputStatus,
+    danfossSystemStatusWater,
+    danfossSystemStatusCode,
+    danfossMultimasterRole,
     keypadLockoutMode,
     lockSourceName,
     armMode,

package/lib/exposes.js

@@ -486,6 +486,7 @@ module.exports = {
         transition: () => new Numeric(`transition`, access.SET).withValueMin(0).withDescription('Controls the transition time (in seconds) of on/off, brightness, color temperature (if applicable) and color (if applicable) changes. Defaults to `0` (no transition).'),
         legacy: () => new Binary(`legacy`, access.SET, true, false).withDescription(`Set to false to disable the legacy integration (highly recommended), will change structure of the published payload (default true).`),
         measurement_poll_interval: () => new Numeric(`measurement_poll_interval`, access.SET).withValueMin(0).withDescription(`This device does not support reporting electric measurements so it is polled instead. The default poll interval is 60 seconds.`),
+        illuminance_below_threshold_check: () => new Binary(`illuminance_below_threshold_check`, access.SET, true, false).withDescription(`Set to false to also send messages when illuminance is above threshold in night mode (default true).`),
     },
     presets: {
         action: (values) => new Enum('action', access.STATE, values).withDescription('Triggered action (e.g. a button click)'),

package/npm-shrinkwrap.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.292",
+  "version": "14.0.296",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

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