zigbee-herdsman-converters 14.0.582 → 14.0.583

package/converters/fromZigbee.js

@@ -2807,21 +2807,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/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/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/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'],
@@ -2215,6 +2449,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.583",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [