zigbee-herdsman-converters 15.0.43 → 15.0.44

package/converters/fromZigbee.js

@@ -3068,6 +3068,21 @@ const converters = {
             }
         },
     },
+    livolo_pir_state: {
+        cluster: 'genPowerCfg',
+        type: ['raw'],
+        convert: (model, msg, publish, options, meta) => {
+            const stateHeader = Buffer.from([122, 209]);
+            if (msg.data.indexOf(stateHeader) === 0) {
+                if (msg.data[10] === 7) {
+                    const status = msg.data[14];
+                    return {
+                        occupancy: status & 1 ? true : false,
+                    };
+                }
+            }
+        },
+    },
     easycode_action: {
         cluster: 'closuresDoorLock',
         type: 'raw',
@@ -3126,6 +3141,11 @@ const converters = {
             [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,2,11]  left: 0, right: 0  (off)
             [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,1,11]  left: 1, right: 0  (left on)
             [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,0,11]  left: 0, right: 1  (right on)
+
+            pir sensor
+            [124,210,21,216,128,  225,52,225,34,0,75,18,0,  19,13,0]       after interview
+            [122,209,             245,94,225,34,0,75,18,0,  7,1,7,1,1,11]  occupancy: true
+            [122,209,             245,94,225,34,0,75,18,0,  7,1,7,1,0,11]  occupancy: false
             */
             const malformedHeader = Buffer.from([0x7c, 0xd2, 0x15, 0xd8, 0x00]);
             const infoHeader = Buffer.from([0x7c, 0xd2, 0x15, 0xd8, 0x80]);
@@ -3170,6 +3190,11 @@ const converters = {
                     meta.device.modelID = 'TI0001-cover';
                     meta.device.save();
                 }
+                if (msg.data.includes(Buffer.from([19, 13, 0]), 13)) {
+                    if (meta.logger) meta.logger.debug('Detected Livolo Pir Sensor');
+                    meta.device.modelID = 'TI0001-pir';
+                    meta.device.save();
+                }
             }
         },
     },

package/devices/essentialb.js

@@ -8,11 +8,60 @@ module.exports = [
         description: 'Smart LED bulb',
         extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
     },
+    {
+        zigbeeModel: ['EB-E14-FLA-CCT'],
+        model: 'EB-E14-FLA-CCT',
+        vendor: 'EssentielB',
+        description: 'E14 flame CCT light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-A60-CCT-FC'],
+        model: 'EB-E27-A60-CCT-FC',
+        vendor: 'EssentielB',
+        description: 'E27 A60 CCT filament clear light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-A60-CCT'],
+        model: 'EB-E27-A60-CCT',
+        vendor: 'EssentielB',
+        description: 'E27 A60 CCT light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-A60-RGBW'],
+        model: 'EB-E27-A60-RGBW',
+        vendor: 'EssentielB',
+        description: 'E27 A60 RGBW light bulb',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+    },
+    {
+        zigbeeModel: ['EB-E27-G95-CCT-FV'],
+        model: 'EB-E27-G95-CCT-FV',
+        vendor: 'EssentielB',
+        description: 'Filament vintage globe light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
     {
         zigbeeModel: ['EB-E27-ST64-CCT-FV'],
         model: 'EB-E27-ST64-CCT-FV',
         vendor: 'EssentielB',
-        description: 'Filament vintage light bulb',
-        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 454]}),
+        description: 'Filament vintage edison light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-GU10-MR16-CCT'],
+        model: 'EB-GU10-MR16-CCT',
+        vendor: 'EssentielB',
+        description: 'GU10 MR16 CCT light bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['EB-GU10-MR16-RGBW'],
+        model: 'EB-GU10-MR16-RGBW',
+        vendor: 'EssentielB',
+        description: 'GU10 MR16 RGBW light bulb',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
     },
 ];

package/devices/ewelink.js

@@ -22,7 +22,7 @@ module.exports = [
         model: 'SA-003-Zigbee',
         vendor: 'eWeLink',
         description: 'Zigbee smart plug',
-        extend: extend.switch(),
+        extend: extend.switch({disablePowerOnBehavior: true}),
         fromZigbee: [fz.on_off_skip_duplicate_transaction],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/livolo.js

@@ -246,4 +246,41 @@ module.exports = [
             }
         },
     },
+    {
+        zigbeeModel: ['TI0001-pir'],
+        model: 'TI0001-pir',
+        description: 'Zigbee motion Sensor',
+        vendor: 'Livolo',
+        exposes: [
+            e.occupancy(),
+        ],
+        fromZigbee: [fz.livolo_pir_state],
+        toZigbee: [],
+        configure: poll,
+        onEvent: async (type, data, device) => {
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            }
+            if (['start', 'deviceAnnounce'].includes(type)) {
+                await poll(device);
+                if (!globalStore.hasValue(device, 'interval')) {
+                    const interval = setInterval(async () => await poll(device), 10*1000);
+                    globalStore.putValue(device, 'interval', interval);
+                }
+            }
+            if (data.cluster === 'genPowerCfg' && data.type === 'raw') {
+                const dp = data.data[10];
+                if (data.data[0] === 0x7a && data.data[1] === 0xd1) {
+                    const endpoint = device.getEndpoint(6);
+                    if (dp === 0x01) {
+                        const options = {manufacturerCode: 0x1ad2, disableDefaultResponse: true, disableResponse: true,
+                            reservedBits: 3, direction: 1, writeUndiv: true};
+                        const payload = {0x2002: {value: [0, 0, 0, 0, 0, 0, 0], type: 0x0e}};
+                        await endpoint.readResponse('genPowerCfg', 0xe9, payload, options);
+                    }
+                }
+            }
+        },
+    },
 ];

package/devices/lonsonho.js

@@ -27,7 +27,7 @@ module.exports = [
         description: 'Curtain switch',
         fromZigbee: [fz.cover_position_tilt, tuya.fz.backlight_mode_low_medium_high, fz.tuya_cover_options],
         toZigbee: [tz.cover_state, tz.cover_position_tilt, tz.tuya_cover_calibration, tz.tuya_cover_reversal,
-            tuya.tz.backlight_indicator_mode],
+            tuya.tz.backlight_indicator_mode_1],
         meta: {coverInverted: true},
         exposes: [e.cover_position(), exposes.enum('moving', ea.STATE, ['UP', 'STOP', 'DOWN']),
             exposes.binary('calibration', ea.ALL, 'ON', 'OFF'), exposes.binary('motor_reversal', ea.ALL, 'ON', 'OFF'),

package/devices/namron.js

@@ -116,6 +116,7 @@ module.exports = [
         vendor: 'Namron',
         description: 'ZigBee dimmer 400W',
         extend: extend.light_onoff_brightness({noConfigure: true}),
+        ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);

package/devices/third_reality.js

@@ -165,6 +165,7 @@ module.exports = [
         description: 'Zigbee / BLE smart plug with power',
         fromZigbee: [fz.on_off, fz.electrical_measurement],
         toZigbee: [tz.on_off],
+        ota: ota.zigbeeOTA,
         exposes: [e.switch(), e.power(), e.current(), e.voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/tuya.js

@@ -1447,7 +1447,7 @@ module.exports = [
         description: 'Curtain/blind switch',
         fromZigbee: [fz.cover_position_tilt, tuya.fz.backlight_mode_low_medium_high, fz.tuya_cover_options],
         toZigbee: [tz.cover_state, tz.cover_position_tilt, tz.tuya_cover_calibration, tz.tuya_cover_reversal,
-            tuya.tz.backlight_indicator_mode],
+            tuya.tz.backlight_indicator_mode_1],
         meta: {coverInverted: true},
         whiteLabel: [{vendor: 'LoraTap', model: 'SC400'}],
         exposes: [e.cover_position(), exposes.enum('moving', ea.STATE, ['UP', 'STOP', 'DOWN']),
@@ -2041,7 +2041,7 @@ module.exports = [
         vendor: 'TuYa',
         description: '3 gang switch module',
         whiteLabel: [{vendor: 'OXT', model: 'SWTZ23'}],
-        extend: tuya.extend.switch({switchType: true, endpoints: ['l1', 'l2', 'l3']}),
+        extend: tuya.extend.switch({switchType: true, backlightModeOffOn: true, endpoints: ['l1', 'l2', 'l3']}),
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2, 'l3': 3};
         },
@@ -2517,7 +2517,7 @@ module.exports = [
         vendor: 'TuYa',
         fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, tuya.fz.power_outage_memory,
             tuya.fz.indicator_mode],
-        toZigbee: [tz.on_off, tuya.tz.power_on_behavior, tuya.tz.backlight_indicator_mode],
+        toZigbee: [tz.on_off, tuya.tz.power_on_behavior, tuya.tz.backlight_indicator_mode_1],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
@@ -3441,7 +3441,7 @@ module.exports = [
             tuyaDatapoints: [
                 [1, 'presence', tuya.valueConverter.trueFalse1],
                 [2, 'radar_sensitivity', tuya.valueConverter.raw],
-                [102, 'occupancy', tuya.valueConverterBasic.trueFalse2],
+                [102, 'occupancy', tuya.valueConverter.trueFalse2],
                 [103, 'illuminance_lux', tuya.valueConverter.raw],
                 [105, 'tumble_switch', tuya.valueConverter.plus1],
                 [106, 'tumble_alarm_time', tuya.valueConverter.raw],

package/devices/xiaomi.js

@@ -134,11 +134,17 @@ const fzLocal = {
                     Object.assign(result, heartbeat);
                     break;
                 }
+                case 0x027d:
+                    result['schedule'] = {1: 'ON', 0: 'OFF'}[value];
+                    break;
+                case 0x0276: {
+                    const schedule = trv.decodeSchedule(value);
+                    result['schedule_settings'] = trv.stringifySchedule(schedule);
+                    break;
+                }
                 case 0xfff2:
                 case 0x00ff: // 4e:27:49:bb:24:b6:30:dd:74:de:53:76:89:44:c4:81
-                case 0x0276: // 04:3e:01:e0:00:00:09:60:04:38:00:00:06:a4:05:64:00:00:08:98:81:e0:00:00:08:98
                 case 0x027c: // 0x00
-                case 0x027d: // 0x00
                 case 0x0280: // 0x00/0x01
                     meta.logger.debug(`zigbee-herdsman-converters:aqara_trv: Unhandled key ${key} = ${value}`);
                     break;
@@ -345,7 +351,7 @@ const fzLocal = {
 const tzLocal = {
     aqara_trv: {
         key: ['system_mode', 'preset', 'window_detection', 'valve_detection', 'child_lock', 'away_preset_temperature',
-            'calibrate', 'sensor', 'sensor_temp', 'identify'],
+            'calibrate', 'sensor', 'sensor_temp', 'identify', 'schedule', 'schedule_settings'],
         convertSet: async (entity, key, value, meta) => {
             const aqaraHeader = (counter, params, action) => {
                 const header = [0xaa, 0x71, params.length + 3, 0x44, counter];
@@ -453,13 +459,25 @@ const tzLocal = {
             case 'identify':
                 await entity.command('genIdentify', 'identify', {identifytime: 5}, {});
                 break;
+            case 'schedule':
+                await entity.write('aqaraOpple', {0x027d: {value: {'OFF': 0, 'ON': 1}[value], type: 0x20}},
+                    {manufacturerCode: 0x115f});
+                break;
+            case 'schedule_settings': {
+                const schedule = trv.parseSchedule(value);
+                trv.validateSchedule(schedule);
+                const buffer = trv.encodeSchedule(schedule);
+                await entity.write('aqaraOpple', {0x0276: {value: buffer, type: 0x41}}, {manufacturerCode: 0x115f});
+                break;
+            }
             default: // Unknown key
                 meta.logger.warn(`zigbee-herdsman-converters:aqara_trv: Unhandled key ${key}`);
             }
         },
         convertGet: async (entity, key, meta) => {
             const dict = {'system_mode': 0x0271, 'preset': 0x0272, 'window_detection': 0x0273, 'valve_detection': 0x0274,
-                'child_lock': 0x0277, 'away_preset_temperature': 0x0279, 'calibrated': 0x027b, 'sensor': 0x027e};
+                'child_lock': 0x0277, 'away_preset_temperature': 0x0279, 'calibrated': 0x027b, 'sensor': 0x027e,
+                'schedule': 0x027d, 'schedule_settings': 0x0276};
 
             if (dict.hasOwnProperty(key)) {
                 await entity.read('aqaraOpple', [dict[key]], {manufacturerCode: 0x115F});
@@ -2993,6 +3011,11 @@ module.exports = [
             e.battery(),
             e.power_outage_count(),
             e.device_temperature(),
+            exposes.switch().withState('schedule', true,
+                'When being ON, the thermostat will change its state based on your settings',
+                ea.ALL, 'ON', 'OFF'),
+            exposes.text('schedule_settings', ea.ALL)
+                .withDescription('Smart schedule configuration (default: mon,tue,wed,thu,fri|8:00,24.0|18:00,17.0|23:00,22.0|8:00,22.0)'),
         ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/lib/tuya.js

@@ -1162,6 +1162,7 @@ const tuyaExposes = {
         .withDescription('Intensity of the backlight'),
     backlightModeOffNormalInverted: () => exposes.enum('backlight_mode', ea.ALL, ['off', 'normal', 'inverted'])
         .withDescription('Mode of the backlight'),
+    backlightModeOffOn: () => exposes.binary('backlight_mode', ea.ALL, 'ON', 'OFF').withDescription(`Mode of the backlight`),
     indicatorMode: () => exposes.enum('indicator_mode', ea.ALL, ['off', 'off/on', 'on/off', 'on']).withDescription('LED indicator mode'),
     indicatorModeNoneRelayPos: () => exposes.enum('indicator_mode', ea.ALL, ['none', 'relay', 'pos'])
         .withDescription('Mode of the indicator light'),
@@ -1560,7 +1561,7 @@ const tuyaTz = {
             await entity.read('manuSpecificTuya_3', ['switchType']);
         },
     },
-    backlight_indicator_mode: {
+    backlight_indicator_mode_1: {
         key: ['backlight_mode', 'indicator_mode'],
         convertSet: async (entity, key, value, meta) => {
             const lookup = key === 'backlight_mode' ? {'low': 0, 'medium': 1, 'high': 2, 'off': 0, 'normal': 1, 'inverted': 2} :
@@ -1574,6 +1575,19 @@ const tuyaTz = {
             await entity.read('genOnOff', ['tuyaBacklightMode']);
         },
     },
+    backlight_indicator_mode_2: {
+        key: ['backlight_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = {'off': 0, 'on': 1};
+            value = value.toLowerCase();
+            utils.validateValue(value, Object.keys(lookup));
+            await entity.write('genOnOff', {tuyaBacklightSwitch: lookup[value]});
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('genOnOff', ['tuyaBacklightSwitch']);
+        },
+    },
     child_lock: {
         key: ['child_lock'],
         convertSet: async (entity, key, value, meta) => {
@@ -1727,6 +1741,17 @@ const tuyaFz = {
             }
         },
     },
+    backlight_mode_off_on: {
+        cluster: 'genOnOff',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('tuyaBacklightSwitch')) {
+                const value = msg.data['tuyaBacklightSwitch'];
+                const backlightLookup = {0: 'off', 1: 'on'};
+                return {backlight_mode: backlightLookup[value]};
+            }
+        },
+    },
     indicator_mode: {
         cluster: 'genOnOff',
         type: ['attributeReport', 'readResponse'],
@@ -1830,21 +1855,28 @@ const tuyaExtend = {
             toZigbee.push(tuyaTz.switch_type);
             exposes.push(tuyaExposes.switchType());
         }
-        if (options.backlightModeLowMediumHigh || options.backlightModeOffNormalInverted || options.indicatorMode) {
-            if (options.backlightModeLowMediumHigh) {
-                fromZigbee.push(tuyaFz.backlight_mode_low_medium_high);
-                exposes.push(tuyaExposes.backlightModeLowMediumHigh());
-            }
-            if (options.backlightModeOffNormalInverted) {
-                fromZigbee.push(tuyaFz.backlight_mode_off_normal_inverted);
-                exposes.push(tuyaExposes.backlightModeOffNormalInverted());
-            }
-            if (options.indicatorMode) {
-                fromZigbee.push(tuyaFz.indicator_mode);
-                exposes.push(tuyaExposes.indicatorMode());
-            }
-            toZigbee.push(tuyaTz.backlight_indicator_mode);
+
+        if (options.backlightModeLowMediumHigh) {
+            fromZigbee.push(tuyaFz.backlight_mode_low_medium_high);
+            exposes.push(tuyaExposes.backlightModeLowMediumHigh());
+            toZigbee.push(tuyaTz.backlight_indicator_mode_1);
+        }
+        if (options.backlightModeOffNormalInverted) {
+            fromZigbee.push(tuyaFz.backlight_mode_off_normal_inverted);
+            exposes.push(tuyaExposes.backlightModeOffNormalInverted());
+            toZigbee.push(tuyaTz.backlight_indicator_mode_1);
+        }
+        if (options.indicatorMode) {
+            fromZigbee.push(tuyaFz.indicator_mode);
+            exposes.push(tuyaExposes.indicatorMode());
+            toZigbee.push(tuyaTz.backlight_indicator_mode_1);
         }
+        if (options.backlightModeOffOn) {
+            fromZigbee.push(tuyaFz.backlight_mode_off_on);
+            exposes.push(tuyaExposes.backlightModeOffOn());
+            toZigbee.push(tuyaTz.backlight_indicator_mode_2);
+        }
+
         if (options.electricalMeasurements) {
             fromZigbee.push(fz.electrical_measurement, fz.metering);
             exposes.push(e.power(), e.current(), e.voltage().withAccess(ea.STATE), e.energy());

package/lib/xiaomi.d.ts

@@ -0,0 +1,11 @@
+declare type Day = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+
+export interface TrvScheduleConfigEvent {
+    time: number;
+    temperature: number;
+}
+
+export interface TrvScheduleConfig {
+    days: Day[];
+    events: TrvScheduleConfigEvent[];
+}

package/lib/xiaomi.js

@@ -891,6 +891,151 @@ const fp1 = {
     },
 };
 
+/**
+ * @param {Buffer} buffer
+ * @param {number} offset
+ * @return {number}
+ */
+function readTemperature(buffer, offset) {
+    return buffer.readUint16BE(offset) / 100;
+}
+
+/**
+ * @param {Buffer} buffer
+ * @param {number} offset
+ * @param {number} temperature
+ * @return {void}
+ */
+function writeTemperature(buffer, offset, temperature) {
+    buffer.writeUint16BE(temperature * 100, offset);
+}
+
+/**
+ * @type {Day[]}
+ */
+const dayNames = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+
+/**
+ * @param {Buffer} buffer
+ * @param {number} offset
+ * @return {Day[]}
+ */
+function readDaySelection(buffer, offset) {
+    const selectedDays = [];
+
+    dayNames.forEach((day, index) => {
+        if ((buffer[offset] >> index + 1) % 2 !== 0) {
+            selectedDays.push(day);
+        }
+    });
+
+    return selectedDays;
+}
+
+/**
+ * @param {Day[]} selectedDays
+ */
+function validateDaySelection(selectedDays) {
+    selectedDays.filter((selectedDay) => !dayNames.includes(selectedDay)).forEach((invalidValue) => {
+        throw new Error(`The value "${invalidValue}" is not a valid day (available values: ${dayNames.join(', ')})`);
+    });
+}
+
+/**
+ * @param {Buffer} buffer
+ * @param {number} offset
+ * @param {Day[]} selectedDays
+ */
+function writeDaySelection(buffer, offset, selectedDays) {
+    validateDaySelection(selectedDays);
+
+    const bitMap = dayNames.reduce((repeat, dayName, index) => {
+        const isDaySelected = selectedDays.includes(dayName);
+        return repeat | isDaySelected << index + 1;
+    }, 0);
+
+    buffer.writeUInt8(bitMap, offset);
+}
+
+const timeNextDayFlag = 1 << 15;
+
+/**
+ * @param {Buffer} buffer
+ * @param {number} offset
+ * @return {number}
+ */
+function readTime(buffer, offset) {
+    const minutesWithDayFlag = buffer.readUint16BE(offset);
+    return minutesWithDayFlag & ~timeNextDayFlag;
+}
+
+/**
+ * @param {number} time
+ * @return {void}
+ */
+function validateTime(time) {
+    const isPositiveInteger = (value) => typeof value === 'number' && Number.isInteger(value) && value >= 0;
+
+    if (!isPositiveInteger(time)) {
+        throw new Error(`Time must be a positive integer number`);
+    }
+
+    if (time >= 24 * 60) {
+        throw new Error(`Time must be between 00:00 and 23:59`);
+    }
+}
+
+/**
+ * @param {Buffer} buffer
+ * @param {number} offset
+ * @param {number} time
+ * @param {boolean} isNextDay
+ * @return {void}
+ */
+function writeTime(buffer, offset, time, isNextDay) {
+    validateTime(time);
+
+    let minutesWithDayFlag = time;
+
+    if (isNextDay) {
+        minutesWithDayFlag = minutesWithDayFlag | timeNextDayFlag;
+    }
+
+    buffer.writeUint16BE(minutesWithDayFlag, offset);
+}
+
+/**
+ * Formats a number of minutes into a user-readable 24-hour time notation in the form hh:mm.
+ * @param {number} timeMinutes
+ * @return {string}
+ */
+function formatTime(timeMinutes) {
+    const hours = Math.floor(timeMinutes / 60);
+    const minutes = timeMinutes % 60;
+    return `${hours}:${String(minutes).padStart(2, '0')}`;
+}
+
+/**
+ * Parses a 24-hour time notation string in the form hh:mm into a number of minutes.
+ * @param {string} timeString
+ * @return {number}
+ */
+function parseTime(timeString) {
+    const parts = timeString.split(':');
+
+    if (parts.length !== 2) {
+        throw new Error(`Cannot parse time string ${timeString}`);
+    }
+
+    const hours = parseInt(parts[0]);
+    const minutes = parseInt(parts[1]);
+
+    return hours * 60 + minutes;
+}
+
+const stringifiedScheduleFragmentSeparator = '|';
+const stringifiedScheduleValueSeparator = ',';
+
 const trv = {
     decodeFirmwareVersionString(value) {
         // Add prefix to follow Aqara's versioning schema: https://www.aqara.com/en/version/radiator-thermostat-e1
@@ -964,6 +1109,167 @@ const trv = {
 
         return payload;
     },
+
+    /**
+     * Decode a Zigbee schedule configuration message into a schedule configuration object.
+     * @param {Buffer} buffer
+     * @return {TrvScheduleConfig}
+     */
+    decodeSchedule(buffer) {
+        return {
+            days: readDaySelection(buffer, 1),
+            events: [
+                {time: readTime(buffer, 2), temperature: readTemperature(buffer, 6)},
+                {time: readTime(buffer, 8), temperature: readTemperature(buffer, 12)},
+                {time: readTime(buffer, 14), temperature: readTemperature(buffer, 18)},
+                {time: readTime(buffer, 20), temperature: readTemperature(buffer, 24)},
+            ],
+        };
+    },
+
+    /**
+     * @param {TrvScheduleConfig} schedule
+     * @return {void}
+     */
+    validateSchedule(schedule) {
+        const eventCount = 4;
+
+        if (typeof schedule !== 'object') {
+            throw new Error('The provided value must be a schedule object');
+        }
+
+        if (schedule.days == null || !Array.isArray(schedule.days) || schedule.days.length === 0) {
+            throw new Error(`The schedule object must contain an array of days with at least one entry`);
+        }
+
+        validateDaySelection(schedule.days);
+
+        if (schedule.events == null || !Array.isArray(schedule.events) || schedule.events.length !== eventCount) {
+            throw new Error(`The schedule object must contain an array of ${eventCount} time/temperature events`);
+        }
+
+        schedule.events.forEach((event) => {
+            if (typeof event !== 'object') {
+                throw new Error('The provided time/temperature event must be an object');
+            }
+
+            validateTime(event.time);
+
+            if (typeof event.temperature !== 'number') {
+                throw new Error(`The provided time/temperature entry must contain a numeric temperature`);
+            }
+
+            if (event.temperature < 5 || event.temperature > 30) {
+                throw new Error(`The temperature must be between 5 and 30 °C`);
+            }
+        });
+
+        // Calculate time durations between events
+        const durations = schedule.events
+            .map((entry, index, entries) => {
+                if (index === 0) {
+                    return 0;
+                }
+
+                const time = entry.time;
+                const fullDay = 24 * 60;
+                const previousTime = entries[index - 1].time;
+                const isNextDay = time < previousTime;
+
+                if (isNextDay) {
+                    return (fullDay - previousTime) + time;
+                } else {
+                    return time - previousTime;
+                }
+            })
+            // Remove first entry which is not a duration
+            .slice(1);
+
+        const minDuration = 60;
+        const hasInvalidDurations = durations.some((duration) => duration < minDuration);
+
+        if (hasInvalidDurations) {
+            throw new Error(`The individual times must be at least 1 hour apart`);
+        }
+
+        const maxTotalDuration = 24 * 60;
+        const totalDuration = durations.reduce((total, duration) => total + duration, 0);
+
+        if (totalDuration > maxTotalDuration) {
+            // this implicitly also makes sure that there is at most one "next day" switch
+            throw new Error(`The start and end times must be at most 24 hours apart`);
+        }
+    },
+
+    /**
+     * Encodes a schedule object into Zigbee message format.
+     * @param {TrvScheduleConfig} schedule
+     * @return {Buffer}
+     */
+    encodeSchedule(schedule) {
+        const buffer = Buffer.alloc(26);
+        buffer.writeUInt8(0x04);
+
+        writeDaySelection(buffer, 1, schedule.days);
+
+        schedule.events.forEach((event, index, events) => {
+            const offset = 2 + index * 6;
+            const isNextDay = index > 0 && event.time < events[index - 1].time;
+
+            writeTime(buffer, offset, event.time, isNextDay);
+            writeTemperature(buffer, offset + 4, event.temperature);
+        });
+
+        return buffer;
+    },
+
+    /**
+     * Converts a schedule config object into a configuration string.
+     * @param {TrvScheduleConfig} schedule
+     * @return {string}
+     */
+    stringifySchedule(schedule) {
+        const stringifiedScheduleFragments = [schedule.days.join(stringifiedScheduleValueSeparator)];
+
+        for (const event of schedule.events) {
+            const formattedTemperature = Number.isInteger(event.temperature) ?
+                event.temperature.toFixed(1) : // add ".0" for usability to signal that floats can be used
+                String(event.temperature);
+
+            const entryFragments = [formatTime(event.time), formattedTemperature];
+
+            stringifiedScheduleFragments.push(entryFragments.join(stringifiedScheduleValueSeparator));
+        }
+
+        return stringifiedScheduleFragments.join(stringifiedScheduleFragmentSeparator);
+    },
+
+    /**
+     * Parses a schedule configuration string into a configuration object.
+     * @param {string} stringifiedSchedule
+     * @return {TrvScheduleConfig}
+     */
+    parseSchedule(stringifiedSchedule) {
+        const schedule = {days: [], events: []};
+
+        if (!stringifiedSchedule) {
+            return schedule;
+        }
+
+        const stringifiedScheduleFragments = stringifiedSchedule.split(stringifiedScheduleFragmentSeparator);
+
+        stringifiedScheduleFragments.forEach((fragment, index) => {
+            if (index === 0) {
+                schedule.days.push(...fragment.split(stringifiedScheduleValueSeparator));
+            } else {
+                const entryFragments = fragment.split(stringifiedScheduleValueSeparator);
+                const entry = {time: parseTime(entryFragments[0]), temperature: parseFloat(entryFragments[1])};
+                schedule.events.push(entry);
+            }
+        });
+
+        return schedule;
+    },
 };
 
 module.exports = {

package/package.json

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