zigbee-herdsman-converters 14.0.582 → 14.0.585

package/converters/fromZigbee.js

@@ -1544,6 +1544,8 @@ const converters = {
             if (msg.data.hasOwnProperty('currentPositionLiftPercentage') && msg.data['currentPositionLiftPercentage'] <= 100) {
                 const value = msg.data['currentPositionLiftPercentage'];
                 result[postfixWithEndpointName('position', msg, model, meta)] = invert ? value : 100 - value;
+                result[postfixWithEndpointName('state', msg, model, meta)] =
+                    invert ? (value === 100 ? 'CLOSE' : 'OPEN') : (value === 0 ? 'CLOSE' : 'OPEN');
             }
             if (msg.data.hasOwnProperty('currentPositionTiltPercentage') && msg.data['currentPositionTiltPercentage'] <= 100) {
                 const value = msg.data['currentPositionTiltPercentage'];
@@ -2807,21 +2809,21 @@ const converters = {
             if (msg.data.hasOwnProperty('tuyaMovingState')) {
                 const value = msg.data['tuyaMovingState'];
                 const movingLookup = {0: 'UP', 1: 'STOP', 2: 'DOWN'};
-                result.moving = movingLookup[value];
+                result[postfixWithEndpointName('moving', msg, model, meta)] = movingLookup[value];
             }
             if (msg.data.hasOwnProperty('tuyaCalibration')) {
                 const value = msg.data['tuyaCalibration'];
                 const calibrationLookup = {0: 'ON', 1: 'OFF'};
-                result.calibration = calibrationLookup[value];
+                result[postfixWithEndpointName('calibration', msg, model, meta)] = calibrationLookup[value];
             }
             if (msg.data.hasOwnProperty('tuyaMotorReversal')) {
                 const value = msg.data['tuyaMotorReversal'];
                 const reversalLookup = {0: 'OFF', 1: 'ON'};
-                result.motor_reversal = reversalLookup[value];
+                result[postfixWithEndpointName('motor_reversal', msg, model, meta)] = reversalLookup[value];
             }
             if (msg.data.hasOwnProperty('moesCalibrationTime')) {
                 const value = parseFloat(msg.data['moesCalibrationTime']) / 10.0;
-                result.calibration_time = value;
+                result[postfixWithEndpointName('calibration_time', msg, model, meta)] = value;
             }
             return result;
         },

package/devices/iluminize.js

@@ -115,7 +115,7 @@ module.exports = [
         model: '5128.10',
         vendor: 'Iluminize',
         description: 'Zigbee 3.0 switch shutter SW with level control',
-        fromZigbee: [fz.cover_position_via_brightness, fz.cover_state_via_onoff],
+        fromZigbee: [fz.cover_position_via_brightness, fz.cover_state_via_onoff, fz.cover_position_tilt],
         toZigbee: [tz.cover_state, tz.cover_via_brightness],
         exposes: [e.cover_position()],
         ota: ota.zigbeeOTA,

package/devices/lonsonho.js

@@ -82,7 +82,8 @@ module.exports = [
             return {'left': 1, 'right': 2};
         },
         exposes: [
-            exposes.enum('moving', ea.STATE, ['UP', 'STOP', 'DOWN']),
+            exposes.enum('moving', ea.STATE, ['UP', 'STOP', 'DOWN']).withEndpoint('left'),
+            exposes.enum('moving', ea.STATE, ['UP', 'STOP', 'DOWN']).withEndpoint('right'),
             exposes.numeric('calibration_time', ea.STATE).withUnit('S').withDescription('Calibration time'),
             e.cover_position().withEndpoint('left'), exposes.binary('calibration', ea.ALL, 'ON', 'OFF')
                 .withEndpoint('left'), exposes.binary('motor_reversal', ea.ALL, 'ON', 'OFF').withEndpoint('left'),

package/devices/moes.js

@@ -247,7 +247,7 @@ module.exports = [
             tz.moesS_thermostat_min_temperature, tz.moesS_thermostat_moesSecoMode,
             tz.moesS_thermostat_system_mode, tz.moesS_thermostat_schedule_programming],
         exposes: [
-            e.battery(), e.child_lock(), e.eco_mode(), e.eco_temperature(), e.max_temperature(), e.min_temperature(),
+            e.battery(), e.child_lock(), e.eco_mode(), e.eco_temperature(), e.max_temperature().withValueMax(45), e.min_temperature(),
             e.valve_state(), e.position(), e.window_detection(),
             exposes.binary('window', ea.STATE, 'CLOSED', 'OPEN').withDescription('Window status closed or open '),
             exposes.climate()

package/devices/namron.js

@@ -28,6 +28,19 @@ module.exports = [
             await reporting.onOff(endpoint);
         },
     },
+    {
+        zigbeeModel: ['4512708'],
+        model: '4512708',
+        vendor: 'Namron',
+        description: 'Zigbee LED dimmer',
+        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);
+        },
+    },
     {
         zigbeeModel: ['4512733'],
         model: '4512733',

package/devices/philips.js

@@ -3,6 +3,8 @@ const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/lega
 const tz = require('../converters/toZigbee');
 const ota = require('../lib/ota');
 const reporting = require('../lib/reporting');
+const globalStore = require('../lib/store');
+const utils = require('../lib/utils');
 const e = exposes.presets;
 const ea = exposes.access;
 
@@ -40,6 +42,48 @@ const hueExtend = {
     }),
 };
 
+const fzLocal = {
+    hue_tap_dial: {
+        cluster: 'manuSpecificPhilips',
+        type: 'commandHueNotification',
+        options: [exposes.options.simulated_brightness()],
+        convert: (model, msg, publish, options, meta) => {
+            const buttonLookup = {1: 'button_1', 2: 'button_2', 3: 'button_3', 4: 'button_4', 20: 'dial'};
+            const button = buttonLookup[msg.data['button']];
+            const typeLookup = {0: 'press', 1: 'hold', 2: 'press_release', 3: 'hold_release'};
+            const type = typeLookup[msg.data['type']];
+            const direction = msg.data['unknown2'] <127 ? 'right' : 'left';
+            const time = msg.data['time'];
+            const payload = {};
+
+            if (button === 'dial') {
+                const adjustedTime = direction === 'right' ? time : 256 - time;
+                const dialType = 'rotate';
+                const speed = adjustedTime <= 25 ? 'step' : adjustedTime <= 75 ? 'slow' : 'fast';
+                payload.action = `${button}_${dialType}_${direction}_${speed}`;
+
+                // simulated brightness
+                if (options.simulated_brightness) {
+                    const opts = options.simulated_brightness;
+                    const deltaOpts = typeof opts === 'object' && opts.hasOwnProperty('delta') ? opts.delta : 35;
+                    const delta = direction === 'right' ? deltaOpts : deltaOpts * -1;
+                    const brightness = globalStore.getValue(msg.endpoint, 'brightness', 255) + delta;
+                    payload.brightness = utils.numberWithinRange(brightness, 0, 255);
+                    globalStore.putValue(msg.endpoint, 'brightness', payload.brightness);
+                }
+            } else {
+                payload.action = `${button}_${type}`;
+                // duration
+                if (type === 'press') globalStore.putValue(msg.endpoint, 'press_start', Date.now());
+                else if (type === 'hold' || type === 'hold_release') {
+                    payload.action_duration = (Date.now() - globalStore.getValue(msg.endpoint, 'press_start')) / 1000;
+                }
+            }
+            return payload;
+        },
+    },
+};
+
 module.exports = [
     {
         zigbeeModel: ['929003055801'],
@@ -2313,6 +2357,29 @@ module.exports = [
         description: 'Hue White and Color Ambiance A19 1100 lumen',
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
+    {
+        zigbeeModel: ['RDM002'],
+        model: '8719514440937/8719514440999',
+        vendor: 'Philips',
+        description: 'Hue Tap dial switch',
+        fromZigbee: [fz.ignore_command_step, fzLocal.hue_tap_dial, fz.battery],
+        toZigbee: [],
+        exposes: [e.battery(), e.action(['button_1_press', 'button_1_press_release', 'button_1_hold', 'button_1_hold_release',
+            'button_2_press', 'button_2_press_release', 'button_2_hold', 'button_2_hold_release',
+            'button_3_press', 'button_3_press_release', 'button_3_hold', 'button_3_hold_release',
+            'button_4_press', 'button_4_press_release', 'button_4_hold', 'button_4_hold_release',
+            'dial_rotate_left_step', 'dial_rotate_left_slow', 'dial_rotate_left_fast',
+            'dial_rotate_right_step', 'dial_rotate_right_slow', 'dial_rotate_right_fast']),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'manuSpecificPhilips', 'genPowerCfg']);
+            const options = {manufacturerCode: 0x100B, disableDefaultResponse: true};
+            await endpoint.write('genBasic', {0x0031: {value: 0x000B, type: 0x19}}, options);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        ota: ota.zigbeeOTA,
+    },
     {
         fingerprint: [{modelID: 'GreenPower_2', ieeeAddr: /^0x00000000004.....$/}],
         model: '8718696743133',

package/devices/robb.js

@@ -248,4 +248,30 @@ module.exports = [
             'recall_*', 'on', 'off', 'toggle', 'brightness_stop', 'brightness_move_up', 'brightness_move_down',
             'color_loop_set', 'enhanced_move_to_hue_and_saturation', 'hue_stop'])],
     },
+    {
+        zigbeeModel: ['ROB_200-026-0'],
+        model: 'ROB_200-026-0',
+        vendor: 'ROBB',
+        description: '2-gang in-wall switch',
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.power_on_behavior],
+        toZigbee: [tz.on_off, tz.power_on_behavior, tz.electrical_measurement_power],
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.energy()],
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 2};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint1);
+            await reporting.onOff(endpoint2);
+            await endpoint1.read('haElectricalMeasurement', ['acPowerMultiplier', 'acPowerDivisor']);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['haElectricalMeasurement', 'seMetering']);
+            await reporting.activePower(endpoint1);
+            await reporting.readMeteringMultiplierDivisor(endpoint1);
+            await reporting.currentSummDelivered(endpoint1, {min: 60, change: 1});
+        },
+    },
 ];

package/devices/sengled.js

@@ -3,18 +3,27 @@ const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/lega
 const tz = require('../converters/toZigbee');
 const ota = require('../lib/ota');
 const reporting = require('../lib/reporting');
-const extend = require('../lib/extend');
 const e = exposes.presets;
 
+// Make sure extend.ldight_* is not used (sengledExtend should be used instead)
+const extendDontUse = require('../lib/extend');
+const extend = {switch: extendDontUse.switch};
+const sengledExtend = {
+    light_onoff_brightness: (options={}) => extendDontUse.light_onoff_brightness({disableEffect: true, ...options}),
+    light_onoff_brightness_colortemp: (options={}) => extendDontUse.light_onoff_brightness_colortemp({disableEffect: true, ...options}),
+    light_onoff_brightness_colortemp_color: (options={}) =>
+        extendDontUse.light_onoff_brightness_colortemp_color({disableEffect: true, ...options}),
+};
+
 module.exports = [
     {
         zigbeeModel: ['E13-N11'],
         model: 'E13-N11',
         vendor: 'Sengled',
         description: 'Flood light with motion sensor light outdoor',
-        fromZigbee: extend.light_onoff_brightness().fromZigbee.concat([fz.ias_occupancy_alarm_1]),
-        toZigbee: extend.light_onoff_brightness().toZigbee,
-        exposes: extend.light_onoff_brightness().exposes.concat([e.occupancy()]),
+        fromZigbee: sengledExtend.light_onoff_brightness().fromZigbee.concat([fz.ias_occupancy_alarm_1]),
+        toZigbee: sengledExtend.light_onoff_brightness().toZigbee,
+        exposes: sengledExtend.light_onoff_brightness().exposes.concat([e.occupancy()]),
         ota: ota.zigbeeOTA,
     },
     {
@@ -22,7 +31,7 @@ module.exports = [
         model: 'E21-N13A',
         vendor: 'Sengled',
         description: 'Smart LED (A19)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -30,12 +39,12 @@ module.exports = [
         model: 'E21-N1EA',
         vendor: 'Sengled',
         description: 'Smart LED multicolor A19 bulb',
-        fromZigbee: extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).fromZigbee.concat([fz.metering]),
-        toZigbee: extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).toZigbee,
-        exposes: extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).exposes.concat([e.power(), e.energy()]),
+        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 extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]})
+            await sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]})
                 .configure(device, coordinatorEndpoint, logger);
             device.powerSource = 'Mains (single phase)';
             device.save();
@@ -52,7 +61,7 @@ module.exports = [
         model: 'E12-N1E',
         vendor: 'Sengled',
         description: 'Smart LED multicolor (BR30)',
-        extend: extend.light_onoff_brightness_colortemp_color(),
+        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -60,7 +69,7 @@ module.exports = [
         model: 'E1G-G8E',
         vendor: 'Sengled',
         description: 'Multicolor light strip (2M)',
-        extend: extend.light_onoff_brightness_colortemp_color(),
+        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -68,7 +77,7 @@ module.exports = [
         model: 'E11-U21U31',
         vendor: 'Sengled',
         description: 'Element touch (A19)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -76,11 +85,11 @@ module.exports = [
         model: 'E11-G13',
         vendor: 'Sengled',
         description: 'Element classic (A19)',
-        fromZigbee: extend.light_onoff_brightness().fromZigbee.concat([fz.metering]),
-        toZigbee: extend.light_onoff_brightness().toZigbee,
+        fromZigbee: sengledExtend.light_onoff_brightness().fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness().toZigbee,
         ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
-            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            await sengledExtend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             device.powerSource = 'Mains (single phase)';
             device.save();
 
@@ -90,14 +99,14 @@ module.exports = [
             await reporting.currentSummDelivered(endpoint);
             await reporting.instantaneousDemand(endpoint);
         },
-        exposes: extend.light_onoff_brightness().exposes.concat([e.power(), e.energy()]),
+        exposes: sengledExtend.light_onoff_brightness().exposes.concat([e.power(), e.energy()]),
     },
     {
         zigbeeModel: ['E11-G23', 'E11-G33'],
         model: 'E11-G23/E11-G33',
         vendor: 'Sengled',
         description: 'Element classic (A60)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -105,7 +114,7 @@ module.exports = [
         model: 'E11-N13/E11-N13A/E11-N14/E11-N14A',
         vendor: 'Sengled',
         description: 'Element extra bright (A19)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -113,7 +122,7 @@ module.exports = [
         model: 'Z01-CIA19NAE26',
         vendor: 'Sengled',
         description: 'Element touch (A19)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -121,7 +130,7 @@ module.exports = [
         model: 'Z01-A19NAE26',
         vendor: 'Sengled',
         description: 'Element plus (A19)',
-        extend: extend.light_onoff_brightness_colortemp(),
+        extend: sengledExtend.light_onoff_brightness_colortemp(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -129,7 +138,7 @@ module.exports = [
         model: 'Z01-A60EAE27',
         vendor: 'Sengled',
         description: 'Element Plus (A60)',
-        extend: extend.light_onoff_brightness_colortemp(),
+        extend: sengledExtend.light_onoff_brightness_colortemp(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -137,11 +146,11 @@ module.exports = [
         model: 'E11-N1EA',
         vendor: 'Sengled',
         description: 'Element plus color (A19)',
-        fromZigbee: extend.light_onoff_brightness().fromZigbee.concat([fz.metering]),
-        toZigbee: extend.light_onoff_brightness().toZigbee,
+        fromZigbee: sengledExtend.light_onoff_brightness().fromZigbee.concat([fz.metering]),
+        toZigbee: sengledExtend.light_onoff_brightness().toZigbee,
         ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
-            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            await sengledExtend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             device.powerSource = 'Mains (single phase)';
             device.save();
 
@@ -151,14 +160,14 @@ module.exports = [
             await reporting.currentSummDelivered(endpoint);
             await reporting.instantaneousDemand(endpoint);
         },
-        exposes: extend.light_onoff_brightness().exposes.concat([e.power(), e.energy()]),
+        exposes: sengledExtend.light_onoff_brightness().exposes.concat([e.power(), e.energy()]),
     },
     {
         zigbeeModel: ['E11-U2E'],
         model: 'E11-U2E',
         vendor: 'Sengled',
         description: 'Element color plus E27',
-        extend: extend.light_onoff_brightness_colortemp_color(),
+        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -166,7 +175,7 @@ module.exports = [
         model: 'E11-U3E',
         vendor: 'Sengled',
         description: 'Element color plus B22',
-        extend: extend.light_onoff_brightness_colortemp_color(),
+        extend: sengledExtend.light_onoff_brightness_colortemp_color(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -174,12 +183,12 @@ module.exports = [
         model: 'E1F-N5E',
         vendor: 'Sengled',
         description: 'Element color plus E12',
-        fromZigbee: extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).fromZigbee.concat([fz.metering]),
-        toZigbee: extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).toZigbee,
-        exposes: extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]}).exposes.concat([e.power(), e.energy()]),
+        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 extend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]})
+            await sengledExtend.light_onoff_brightness_colortemp_color({colorTempRange: [154, 500]})
                 .configure(device, coordinatorEndpoint, logger);
             device.powerSource = 'Mains (single phase)';
             device.save();
@@ -196,7 +205,7 @@ module.exports = [
         model: 'E12-N14',
         vendor: 'Sengled',
         description: 'Element Classic (BR30)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -204,7 +213,7 @@ module.exports = [
         model: 'E1ACA4ABE38A',
         vendor: 'Sengled',
         description: 'Element downlight smart LED bulb',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -261,7 +270,7 @@ module.exports = [
         model: 'E11-N1G',
         vendor: 'Sengled',
         description: 'Vintage LED edison bulb (ST19)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
     {
@@ -269,7 +278,7 @@ module.exports = [
         model: 'E1F-N9G',
         vendor: 'Sengled',
         description: 'Smart LED filament candle (E12)',
-        extend: extend.light_onoff_brightness(),
+        extend: sengledExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
 ];

package/devices/tuya.js

@@ -13,6 +13,7 @@ const zosung = require('../lib/zosung');
 const fzZosung = zosung.fzZosung;
 const tzZosung = zosung.tzZosung;
 const ez = zosung.presetsZosung;
+const globalStore = require('../lib/store');
 
 const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak', '_TZ3000_ew3ldmgx', '_TZ3000_gjnozsaz',
     '_TZ3000_jvzvulen', '_TZ3000_mraovvmm', '_TZ3000_nfnmi125', '_TZ3000_ps3dmato', '_TZ3000_w0qqde0g', '_TZ3000_u5u4cakc',
@@ -128,6 +129,131 @@ const tzLocal = {
             }
         },
     },
+    x5h_thermostat: {
+        key: ['system_mode', 'current_heating_setpoint', 'sensor', 'brightness_state', 'sound', 'frost_protection', 'week', 'factory_reset',
+            'local_temperature_calibration', 'heating_temp_limit', 'deadzone_temperature', 'upper_temp', 'preset', 'child_lock',
+            'schedule'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'system_mode':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.x5hState, value === 'heat');
+                break;
+            case 'preset': {
+                value = value.toLowerCase();
+                const lookup = {manual: 0, program: 1};
+                utils.validateValue(value, Object.keys(lookup));
+                value = lookup[value];
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.x5hMode, value);
+                break;
+            }
+            case 'upper_temp':
+                if (value >= 35 && value <= 95) {
+                    await tuya.sendDataPointValue(entity, tuya.dataPoints.x5hSetTempCeiling, value);
+                    const setpoint = globalStore.getValue(entity, 'currentHeatingSetpoint', 20);
+                    const setpointRaw = Math.round(setpoint * 10);
+                    await new Promise((r) => setTimeout(r, 500));
+                    await tuya.sendDataPointValue(entity, tuya.dataPoints.x5hSetTemp, setpointRaw);
+                } else {
+                    throw new Error('Supported values are in range [35, 95]');
+                }
+                break;
+            case 'deadzone_temperature':
+                if (value >= 0.5 && value <= 9.5) {
+                    value = Math.round(value * 10);
+                    await tuya.sendDataPointValue(entity, tuya.dataPoints.x5hTempDiff, value);
+                } else {
+                    throw new Error('Supported values are in range [0.5, 9.5]');
+                }
+                break;
+            case 'heating_temp_limit':
+                if (value >= 5 && value <= 60) {
+                    await tuya.sendDataPointValue(entity, tuya.dataPoints.x5hProtectionTempLimit, value);
+                } else {
+                    throw new Error('Supported values are in range [5, 60]');
+                }
+                break;
+            case 'local_temperature_calibration':
+                if (value >= -9.9 && value <= 9.9) {
+                    value = Math.round(value * 10);
+
+                    if (value < 0) {
+                        value = 0xFFFFFFFF + value + 1;
+                    }
+
+                    await tuya.sendDataPointValue(entity, tuya.dataPoints.x5hTempCorrection, value);
+                } else {
+                    throw new Error('Supported values are in range [-9.9, 9.9]');
+                }
+                break;
+            case 'factory_reset':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.x5hFactoryReset, value === 'ON');
+                break;
+            case 'week':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.x5hWorkingDaySetting,
+                    utils.getKey(tuya.thermostatWeekFormat, value, value, Number));
+                break;
+            case 'frost_protection':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.x5hFrostProtection, value === 'ON');
+                break;
+            case 'sound':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.x5hSound, value === 'ON');
+                break;
+            case 'brightness_state': {
+                value = value.toLowerCase();
+                const lookup = {off: 0, low: 1, medium: 2, high: 3};
+                utils.validateValue(value, Object.keys(lookup));
+                value = lookup[value];
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.x5hBackplaneBrightness, value);
+                break;
+            }
+            case 'sensor': {
+                value = value.toLowerCase();
+                const lookup = {'internal': 0, 'external': 1, 'both': 2};
+                utils.validateValue(value, Object.keys(lookup));
+                value = lookup[value];
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.x5hSensorSelection, value);
+                break;
+            }
+            case 'current_heating_setpoint':
+                if (value >= 5 && value <= 60) {
+                    value = Math.round(value * 10);
+                    await tuya.sendDataPointValue(entity, tuya.dataPoints.x5hSetTemp, value);
+                } else {
+                    throw new Error(`Unsupported value: ${value}`);
+                }
+                break;
+            case 'child_lock':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.x5hChildLock, value === 'LOCK');
+                break;
+            case 'schedule': {
+                const periods = value.split(' ');
+                const periodsNumber = 8;
+                const payload = [];
+
+                for (let i = 0; i < periodsNumber; i++) {
+                    const timeTemp = periods[i].split('/');
+                    const hm = timeTemp[0].split(':', 2);
+                    const h = parseInt(hm[0]);
+                    const m = parseInt(hm[1]);
+                    const temp = parseFloat(timeTemp[1]);
+
+                    if (h < 0 || h >= 24 || m < 0 || m >= 60 || temp < 5 || temp > 60) {
+                        throw new Error('Invalid hour, minute or temperature of: ' + periods[i]);
+                    }
+
+                    const tempHexArray = tuya.convertDecimalValueTo2ByteHexArray(Math.round(temp * 10));
+                    // 1 byte for hour, 1 byte for minutes, 2 bytes for temperature
+                    payload.push(h, m, ...tempHexArray);
+                }
+
+                await tuya.sendDataPointRaw(entity, tuya.dataPoints.x5hWeeklyProcedure, payload);
+                break;
+            }
+            default:
+                break;
+            }
+        },
+    },
     temperature_unit: {
         key: ['temperature_unit'],
         convertSet: async (entity, key, value, meta) => {
@@ -275,6 +401,114 @@ const fzLocal = {
             return result;
         },
     },
+    x5h_thermostat: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'x5h_thermostat');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+
+            switch (dp) {
+            case tuya.dataPoints.x5hState: {
+                return {system_mode: value ? 'heat' : 'off'};
+            }
+            case tuya.dataPoints.x5hWorkingStatus: {
+                return {running_state: value ? 'heat' : 'idle'};
+            }
+            case tuya.dataPoints.x5hSound: {
+                return {sound: value ? 'ON' : 'OFF'};
+            }
+            case tuya.dataPoints.x5hFrostProtection: {
+                return {frost_protection: value ? 'ON' : 'OFF'};
+            }
+            case tuya.dataPoints.x5hWorkingDaySetting: {
+                return {week: tuya.thermostatWeekFormat[value]};
+            }
+            case tuya.dataPoints.x5hFactoryReset: {
+                if (value) {
+                    clearTimeout(globalStore.getValue(msg.endpoint, 'factoryResetTimer'));
+                    const timer = setTimeout(() => publish({factory_reset: 'OFF'}), 60 * 1000);
+                    globalStore.putValue(msg.endpoint, 'factoryResetTimer', timer);
+                    meta.logger.info('The thermostat is resetting now. It will be available in 1 minute.');
+                }
+
+                return {factory_reset: value ? 'ON' : 'OFF'};
+            }
+            case tuya.dataPoints.x5hTempDiff: {
+                return {deadzone_temperature: parseFloat((value / 10).toFixed(1))};
+            }
+            case tuya.dataPoints.x5hProtectionTempLimit: {
+                return {heating_temp_limit: value};
+            }
+            case tuya.dataPoints.x5hBackplaneBrightness: {
+                const lookup = {0: 'off', 1: 'low', 2: 'medium', 3: 'high'};
+
+                if (value >= 0 && value <= 3) {
+                    globalStore.putValue(msg.endpoint, 'brightnessState', value);
+                    return {brightness_state: lookup[value]};
+                }
+
+                // Sometimes, for example on thermostat restart, it sends message like:
+                // {"dpValues":[{"data":{"data":[90],"type":"Buffer"},"datatype":4,"dp":104}
+                // It doesn't represent any brightness value and brightness remains the previous value
+                const lastValue = globalStore.getValue(msg.endpoint, 'brightnessState') || 1;
+                return {brightness_state: lookup[lastValue]};
+            }
+            case tuya.dataPoints.x5hWeeklyProcedure: {
+                const periods = [];
+                const periodSize = 4;
+                const periodsNumber = 8;
+
+                for (let i = 0; i < periodsNumber; i++) {
+                    const hours = value[i * periodSize];
+                    const minutes = value[i * periodSize + 1];
+                    const tempHexArray = [value[i * periodSize + 2], value[i * periodSize + 3]];
+                    const tempRaw = Buffer.from(tempHexArray).readUIntBE(0, tempHexArray.length);
+                    const strHours = hours.toString().padStart(2, '0');
+                    const strMinutes = minutes.toString().padStart(2, '0');
+                    const temp = parseFloat((tempRaw / 10).toFixed(1));
+                    periods.push(`${strHours}:${strMinutes}/${temp}`);
+                }
+
+                const schedule = periods.join(' ');
+                return {schedule};
+            }
+            case tuya.dataPoints.x5hChildLock: {
+                return {child_lock: value ? 'LOCK' : 'UNLOCK'};
+            }
+            case tuya.dataPoints.x5hSetTemp: {
+                const setpoint = parseFloat((value / 10).toFixed(1));
+                globalStore.putValue(msg.endpoint, 'currentHeatingSetpoint', setpoint);
+                return {current_heating_setpoint: setpoint};
+            }
+            case tuya.dataPoints.x5hSetTempCeiling: {
+                return {upper_temp: value};
+            }
+            case tuya.dataPoints.x5hCurrentTemp: {
+                const temperature = value & (1 << 15) ? value - (1 << 16) + 1 : value;
+                return {local_temperature: parseFloat((temperature / 10).toFixed(1))};
+            }
+            case tuya.dataPoints.x5hTempCorrection: {
+                return {local_temperature_calibration: parseFloat((value / 10).toFixed(1))};
+            }
+            case tuya.dataPoints.x5hMode: {
+                const lookup = {0: 'manual', 1: 'program'};
+                return {preset: lookup[value]};
+            }
+            case tuya.dataPoints.x5hSensorSelection: {
+                const lookup = {0: 'internal', 1: 'external', 2: 'both'};
+                return {sensor: lookup[value]};
+            }
+            case tuya.dataPoints.x5hOutputReverse: {
+                return {output_reverse: value};
+            }
+            default: {
+                meta.logger.warn(`fromZigbee:x5h_thermostat: Unrecognized DP #${dp} with data ${JSON.stringify(dpValue)}`);
+            }
+            }
+        },
+    },
     humidity10: {
         cluster: 'msRelativeHumidity',
         type: ['attributeReport', 'readResponse'],
@@ -1968,13 +2202,20 @@ module.exports = [
         vendor: 'TuYa',
         description: 'Smart light switch - 3 gang without neutral wire',
         extend: extend.switch(),
-        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('center'), e.switch().withEndpoint('right')],
+        toZigbee: extend.switch().toZigbee.concat([tz.moes_power_on_behavior, tz.tuya_backlight_mode]),
+        fromZigbee: extend.switch().fromZigbee.concat([fz.moes_power_on_behavior, fz.tuya_backlight_mode]),
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('center'), e.switch().withEndpoint('right'),
+            exposes.enum('power_on_behavior', ea.ALL, Object.values(tuya.moesSwitch.powerOnBehavior)),
+            exposes.enum('backlight_mode', ea.ALL, ['LOW', 'MEDIUM', 'HIGH'])
+                .withDescription('Indicator light status: LOW: Off | MEDIUM: On| HIGH: Inverted')],
         endpoint: (device) => {
             return {'left': 1, 'center': 2, 'right': 3};
         },
         whiteLabel: [{vendor: 'TUYATEC', model: 'GDKES-03TZXD'}],
         meta: {multiEndpoint: true},
         configure: async (device, coordinatorEndpoint, logger) => {
+            await device.getEndpoint(1).read('genBasic',
+                ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
             try {
                 for (const ID of [1, 2, 3]) {
                     const endpoint = device.getEndpoint(ID);
@@ -2215,6 +2456,39 @@ module.exports = [
             .withLocalTemperature(ea.STATE)
             .withSystemMode(['off', 'auto', 'heat'], ea.STATE_SET).withRunningState(['idle', 'heat'], ea.STATE)],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_2ekuz3dz'}],
+        model: 'X5H-GB-B',
+        vendor: 'TuYa',
+        description: 'Wall-mount thermostat',
+        fromZigbee: [fz.ignore_basic_report, fzLocal.x5h_thermostat],
+        toZigbee: [tzLocal.x5h_thermostat],
+        whiteLabel: [{vendor: 'Beok', model: 'TGR85-ZB'}],
+        exposes: [
+            exposes.climate().withSetpoint('current_heating_setpoint', 5, 60, 0.5, ea.STATE_SET)
+                .withLocalTemperature(ea.STATE).withLocalTemperatureCalibration(-9.9, 9.9, 0.1, ea.STATE_SET)
+                .withSystemMode(['off', 'heat'], ea.STATE_SET).withRunningState(['idle', 'heat'], ea.STATE)
+                .withPreset(['manual', 'program']).withSensor(['internal', 'external', 'both'], ea.STATE_SET),
+            exposes.text('schedule', ea.STATE_SET), e.child_lock(), e.week(),
+            exposes.enum('brightness_state', ea.STATE_SET, ['off', 'low', 'medium', 'high'])
+                .withDescription('Screen brightness'),
+            exposes.binary('sound', ea.STATE_SET, 'ON', 'OFF')
+                .withDescription('Switches beep sound when interacting with thermostat'),
+            exposes.binary('frost_protection', ea.STATE_SET, 'ON', 'OFF')
+                .withDescription('Antifreeze function'),
+            exposes.binary('factory_reset', ea.STATE_SET, 'ON', 'OFF')
+                .withDescription('Resets all settings to default. Doesn\'t unpair device.'),
+            exposes.numeric('heating_temp_limit', ea.STATE_SET).withUnit('°C').withValueMax(60)
+                .withValueMin(5).withValueStep(1).withPreset('default', 35, 'Default value')
+                .withDescription('Heating temperature limit'),
+            exposes.numeric('deadzone_temperature', ea.STATE_SET).withUnit('°C').withValueMax(9.5)
+                .withValueMin(0.5).withValueStep(0.5).withPreset('default', 1, 'Default value')
+                .withDescription('The delta between local_temperature and current_heating_setpoint to trigger Heat'),
+            exposes.numeric('upper_temp', ea.STATE_SET).withUnit('°C').withValueMax(95)
+                .withValueMin(35).withValueStep(1).withPreset('default', 60, 'Default value'),
+        ],
+        onEvent: tuya.onEventSetTime,
+    },
     {
         fingerprint: [{modelID: 'TS0222', manufacturerName: '_TYZB01_4mdqxxnn'},
             {modelID: 'TS0222', manufacturerName: '_TYZB01_m6ec2pgj'}],

package/devices/ubisys.js

@@ -4,6 +4,7 @@ const tz = require('../converters/toZigbee');
 const ota = require('../lib/ota');
 const utils = require('../lib/utils');
 const reporting = require('../lib/reporting');
+const constants = require('../lib/constants');
 const herdsman = require('zigbee-herdsman');
 const e = exposes.presets;
 const ea = exposes.access;
@@ -90,6 +91,15 @@ const ubisys = {
                 return {configure_device_setup: result};
             },
         },
+        thermostat_vacation_mode: {
+            cluster: 'hvacThermostat',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                if (msg.data.hasOwnProperty('ocupancy')) {
+                    return {vacation_mode: msg.data.ocupancy === 0};
+                }
+            },
+        },
     },
     tz: {
         configure_j1: {
@@ -503,6 +513,12 @@ const ubisys = {
                     manufacturerOptions.ubisysNull);
             },
         },
+        thermostat_vacation_mode: {
+            key: ['vacation_mode'],
+            convertGet: async (entity, key, meta) => {
+                await entity.read('hvacThermostat', ['ocupancy']);
+            },
+        },
     },
 };
 
@@ -771,4 +787,65 @@ module.exports = [
         },
         ota: ota.ubisys,
     },
+    {
+        zigbeeModel: ['H1'],
+        model: 'H1',
+        vendor: 'Ubisys',
+        description: 'Heating regulator',
+        fromZigbee: [fz.battery, fz.thermostat, fz.thermostat_weekly_schedule, ubisys.fz.thermostat_vacation_mode],
+        toZigbee: [
+            tz.thermostat_occupied_heating_setpoint, tz.thermostat_unoccupied_heating_setpoint,
+            tz.thermostat_local_temperature, tz.thermostat_system_mode,
+            tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule,
+            tz.thermostat_running_mode, ubisys.tz.thermostat_vacation_mode,
+            tz.thermostat_pi_heating_demand,
+        ],
+        exposes: [
+            e.battery(),
+            exposes.climate()
+                .withSystemMode(['off', 'heat'], ea.ALL)
+                .withRunningMode(['off', 'heat'])
+                .withSetpoint('occupied_heating_setpoint', 7, 30, 0.5)
+                .withLocalTemperature()
+                .withPiHeatingDemand(ea.STATE_GET),
+            exposes.binary('vacation_mode', ea.STATE_GET, true, false)
+                .withDescription('When Vacation Mode is active the schedule is disabled and unoccupied_heating_setpoint is used.'),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genBasic', 'genPowerCfg', 'genTime', 'hvacThermostat'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+
+            // reporting
+            // NOTE: temperature is 0.5 deg steps
+            // NOTE: unoccupied_heating_setpoint cannot be set via the device itself
+            //       so we do not need to setup reporting for this, as reporting slots
+            //       seem to be limited.
+            await reporting.thermostatSystemMode(endpoint);
+            await reporting.thermostatRunningMode(endpoint);
+            await reporting.thermostatTemperature(endpoint,
+                {min: 0, max: constants.repInterval.HOUR, change: 50});
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint,
+                {min: 0, max: constants.repInterval.HOUR, change: 50});
+            await reporting.thermostatPIHeatingDemand(endpoint);
+            await reporting.thermostatOcupancy(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint,
+                {min: constants.repInterval.HOUR, max: 43200, change: 1});
+
+
+            // read attributes
+            // NOTE: configuring reporting on hvacThermostat seems to trigger an imediat
+            //       report, so the values are available after configure has run.
+            //       this does not seem to be the case for genPowerCfg, so we read
+            //       the battery percentage
+            await endpoint.read('genPowerCfg', ['batteryPercentageRemaining']);
+
+            // write attributes
+            // NOTE: device checks in every 1h once the device has entered deepsleep
+            //       this might be a bit long if you want to set the temperature remotely
+            //       update this to every 15 minutes. (value is in 1/4th of a second)
+            await endpoint.write('genPollCtrl', {'checkinInterval': (4 * 60 * 15)});
+        },
+        ota: ota.ubisys,
+    },
 ];

package/lib/exposes.js

@@ -407,6 +407,14 @@ class Climate extends Base {
         return this;
     }
 
+    withRunningMode(modes, access=a.STATE_GET) {
+        assert(!this.endpoint, 'Cannot add feature after adding endpoint');
+        const allowed = ['off', 'cool', 'heat'];
+        modes.forEach((m) => assert(allowed.includes(m)));
+        this.features.push(new Enum('running_mode', access, modes).withDescription('The current running mode'));
+        return this;
+    }
+
     withFanMode(modes, access=a.ALL) {
         assert(!this.endpoint, 'Cannot add feature after adding endpoint');
         const allowed = ['off', 'low', 'medium', 'high', 'on', 'auto', 'smart'];

package/lib/reporting.js

@@ -170,6 +170,14 @@ module.exports = {
         const p = payload('runningState', 0, repInterval.HOUR, 0, overrides);
         await endpoint.configureReporting('hvacThermostat', p);
     },
+    thermostatRunningMode: async (endpoint, overrides) => {
+        const p = payload('runningMode', 0, repInterval.HOUR, 0, overrides);
+        await endpoint.configureReporting('hvacThermostat', p);
+    },
+    thermostatOcupancy: async (endpoint, overrides) => {
+        const p = payload('ocupancy', 0, repInterval.HOUR, 0, overrides);
+        await endpoint.configureReporting('hvacThermostat', p);
+    },
     thermostatTemperatureSetpointHold: async (endpoint, overrides) => {
         const p = payload('tempSetpointHold', 0, repInterval.HOUR, 0, overrides);
         await endpoint.configureReporting('hvacThermostat', p);

package/lib/tuya.js

@@ -669,6 +669,26 @@ const dataPoints = {
     // Moes switch with optional neutral
     moesSwitchPowerOnBehavior: 14,
     moesSwitchIndicateLight: 15,
+    // X5H thermostat
+    x5hState: 1,
+    x5hMode: 2,
+    x5hWorkingStatus: 3,
+    x5hSound: 7,
+    x5hFrostProtection: 10,
+    x5hSetTemp: 16,
+    x5hSetTempCeiling: 19,
+    x5hCurrentTemp: 24,
+    x5hTempCorrection: 27,
+    x5hWeeklyProcedure: 30,
+    x5hWorkingDaySetting: 31,
+    x5hFactoryReset: 39,
+    x5hChildLock: 40,
+    x5hSensorSelection: 43,
+    x5hFaultAlarm: 45,
+    x5hTempDiff: 101,
+    x5hProtectionTempLimit: 102,
+    x5hOutputReverse: 103,
+    x5hBackplaneBrightness: 104,
     // Connecte thermostat
     connecteState: 1,
     connecteMode: 2,

package/package.json

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