zigbee-herdsman-converters 14.0.646 → 14.0.647

package/converters/fromZigbee.js

@@ -4090,160 +4090,6 @@ const converters = {
             }
         },
     },
-    tvtwo_thermostat: {
-        cluster: 'manuSpecificTuya',
-        type: ['commandDataResponse', 'commandDataReport'],
-        convert: (model, msg, publish, options, meta) => {
-            const dpValue = tuya.firstDpValue(msg, meta, 'tvtwo_thermostat');
-            const dp = dpValue.dp;
-            const value = tuya.getDataValue(dpValue);
-            const presetLookup = {0: 'auto', 1: 'manual', 2: 'holiday'};
-            switch (dp) {
-            case tuya.dataPoints.tvMode:
-                return {preset: presetLookup[value]};
-            case tuya.dataPoints.tvChildLock:
-                return {child_lock: value ? 'LOCK' : 'UNLOCK'};
-            case tuya.dataPoints.tvHolidayTemp:
-                return {holiday_temperature: (value / 10).toFixed(1)};
-            case tuya.dataPoints.tvHeatingSetpoint:
-                return {current_heating_setpoint: (value / 10).toFixed(1)};
-            case tuya.dataPoints.tvFrostDetection:
-                return {frost_protection: value ? 'ON' : 'OFF'};
-            case tuya.dataPoints.tvWindowDetection:
-                return {open_window: value ? 'ON' : 'OFF'};
-            case tuya.dataPoints.tvHeatingStop:
-                return {heating_stop: value ? 'ON' : 'OFF'};
-            case tuya.dataPoints.tvLocalTemp:
-                return {local_temperature: (value / 10).toFixed(1)};
-            case tuya.dataPoints.tvBattery:
-                return {battery_low: value === 0 ? true : false};
-            case tuya.dataPoints.tvTempCalibration:
-                return {local_temperature_calibration: value > 55 ?
-                    ((value - 0x100000000)/10).toFixed(1): (value/ 10).toFixed(1)};
-            case tuya.dataPoints.tvBoostTime:
-                // Setting minimum 0 - maximum 465 seconds
-                return {boost_timeset_countdown: value};
-            case tuya.dataPoints.tvComfortTemp:
-                return {comfort_temperature: (value / 10).toFixed(1)};
-            case tuya.dataPoints.tvEcoTemp:
-                return {eco_temperature: (value / 10).toFixed(1)};
-            case tuya.dataPoints.tvOpenWindowTemp:
-                return {open_window_temperature: (value / 10).toFixed(1)};
-            case tuya.dataPoints.tvErrorStatus:
-                return {fault_alarm: value};
-            case tuya.dataPoints.tvHolidayMode: {
-                const sy = value.slice(0, 4); const sm = value.slice(4, 6); const sd = value.slice(6, 8);
-                const sh = value.slice(8, 10); const smi = value.slice(10, 12); const ey = value.slice(12, 16);
-                const em = value.slice(16, 18); const ed = value.slice(18, 20); const eh = value.slice(20, 22);
-                const emi = value.slice(22, 24);
-                const hMode = 'start -->   ' + sy + ' - ' + sm + ' - ' + sd + '     ' + sh + ' : ' + smi +
-                '             stop -->   ' + ey + ' - ' + em + ' - ' + ed + '     ' + eh + ' : ' + emi;
-                return {holiday_start_stop: hMode};
-            }
-            case tuya.dataPoints.tvBoostMode:
-                // 115 online / Is the device online
-                return {online: value ? 'ON' : 'OFF'};
-            case tuya.dataPoints.tvWorkingDay:
-                // DP-31, Send and Report, ENUM,  Week select 0 - 5 days, 1 - 6 days, 2 - 7 days
-                return {working_day: value};
-            case tuya.dataPoints.tvMondaySchedule:
-                return {schedule_monday:
-                        '  ' + value[0] / 6 + 'h:' + value[1] + 'm ' + value[2] / 10 + '°C' +
-                        ', ' + value[3] / 6 + 'h:' + value[4] + 'm ' + value[5] / 10 + '°C' +
-                        ', ' + value[6] / 6 + 'h:' + value[7] + 'm ' + value[8] / 10 + '°C' +
-                        ', ' + value[9] / 6 + 'h:' + value[10] + 'm ' + value[11] / 10 + '°C' +
-                        ', ' + value[12] / 6 + 'h:' + value[13] + 'm ' + value[14] / 10 + '°C ' +
-                        ', ' + value[15] / 6 + 'h:' + value[16] + 'm ' + value[17] / 10 + '°C ' +
-                        ', ' + value[18] / 6 + 'h:' + value[19] + 'm ' + value[20] / 10 + '°C ' +
-                        ', ' + value[21] / 6 + 'h:' + value[22] + 'm ' + value[23] / 10 + '°C ' +
-                        ', ' + value[24] / 6 + 'h:' + value[25] + 'm ' + value[26] / 10 + '°C ' +
-                        ', ' + value[27] / 6 + 'h:' + value[28] + 'm ' + value[29] / 10 + '°C ',
-                };
-            case tuya.dataPoints.tvTuesdaySchedule:
-                return {schedule_tuesday:
-                    '  ' + value[0] / 6 + 'h:' + value[1] + 'm ' + value[2] / 10 + '°C' +
-                    ', ' + value[3] / 6 + 'h:' + value[4] + 'm ' + value[5] / 10 + '°C' +
-                    ', ' + value[6] / 6 + 'h:' + value[7] + 'm ' + value[8] / 10 + '°C' +
-                    ', ' + value[9] / 6 + 'h:' + value[10] + 'm ' + value[11] / 10 + '°C' +
-                    ', ' + value[12] / 6 + 'h:' + value[13] + 'm ' + value[14] / 10 + '°C ' +
-                    ', ' + value[15] / 6 + 'h:' + value[16] + 'm ' + value[17] / 10 + '°C ' +
-                    ', ' + value[18] / 6 + 'h:' + value[19] + 'm ' + value[20] / 10 + '°C ' +
-                    ', ' + value[21] / 6 + 'h:' + value[22] + 'm ' + value[23] / 10 + '°C ' +
-                    ', ' + value[24] / 6 + 'h:' + value[25] + 'm ' + value[26] / 10 + '°C ' +
-                    ', ' + value[27] / 6 + 'h:' + value[28] + 'm ' + value[29] / 10 + '°C ',
-                };
-            case tuya.dataPoints.tvWednesdaySchedule:
-                return {schedule_wednesday:
-                    '  ' + value[0] / 6 + 'h:' + value[1] + 'm ' + value[2] / 10 + '°C' +
-                    ', ' + value[3] / 6 + 'h:' + value[4] + 'm ' + value[5] / 10 + '°C' +
-                    ', ' + value[6] / 6 + 'h:' + value[7] + 'm ' + value[8] / 10 + '°C' +
-                    ', ' + value[9] / 6 + 'h:' + value[10] + 'm ' + value[11] / 10 + '°C' +
-                    ', ' + value[12] / 6 + 'h:' + value[13] + 'm ' + value[14] / 10 + '°C ' +
-                    ', ' + value[15] / 6 + 'h:' + value[16] + 'm ' + value[17] / 10 + '°C ' +
-                    ', ' + value[18] / 6 + 'h:' + value[19] + 'm ' + value[20] / 10 + '°C ' +
-                    ', ' + value[21] / 6 + 'h:' + value[22] + 'm ' + value[23] / 10 + '°C ' +
-                    ', ' + value[24] / 6 + 'h:' + value[25] + 'm ' + value[26] / 10 + '°C ' +
-                    ', ' + value[27] / 6 + 'h:' + value[28] + 'm ' + value[29] / 10 + '°C ',
-                };
-            case tuya.dataPoints.tvThursdaySchedule:
-                return {schedule_thursday:
-                    '  ' + value[0] / 6 + 'h:' + value[1] + 'm ' + value[2] / 10 + '°C' +
-                    ', ' + value[3] / 6 + 'h:' + value[4] + 'm ' + value[5] / 10 + '°C' +
-                    ', ' + value[6] / 6 + 'h:' + value[7] + 'm ' + value[8] / 10 + '°C' +
-                    ', ' + value[9] / 6 + 'h:' + value[10] + 'm ' + value[11] / 10 + '°C' +
-                    ', ' + value[12] / 6 + 'h:' + value[13] + 'm ' + value[14] / 10 + '°C ' +
-                    ', ' + value[15] / 6 + 'h:' + value[16] + 'm ' + value[17] / 10 + '°C ' +
-                    ', ' + value[18] / 6 + 'h:' + value[19] + 'm ' + value[20] / 10 + '°C ' +
-                    ', ' + value[21] / 6 + 'h:' + value[22] + 'm ' + value[23] / 10 + '°C ' +
-                    ', ' + value[24] / 6 + 'h:' + value[25] + 'm ' + value[26] / 10 + '°C ' +
-                    ', ' + value[27] / 6 + 'h:' + value[28] + 'm ' + value[29] / 10 + '°C ',
-                };
-            case tuya.dataPoints.tvFridaySchedule:
-                return {schedule_friday:
-                    '  ' + value[0] / 6 + 'h:' + value[1] + 'm ' + value[2] / 10 + '°C' +
-                    ', ' + value[3] / 6 + 'h:' + value[4] + 'm ' + value[5] / 10 + '°C' +
-                    ', ' + value[6] / 6 + 'h:' + value[7] + 'm ' + value[8] / 10 + '°C' +
-                    ', ' + value[9] / 6 + 'h:' + value[10] + 'm ' + value[11] / 10 + '°C' +
-                    ', ' + value[12] / 6 + 'h:' + value[13] + 'm ' + value[14] / 10 + '°C ' +
-                    ', ' + value[15] / 6 + 'h:' + value[16] + 'm ' + value[17] / 10 + '°C ' +
-                    ', ' + value[18] / 6 + 'h:' + value[19] + 'm ' + value[20] / 10 + '°C ' +
-                    ', ' + value[21] / 6 + 'h:' + value[22] + 'm ' + value[23] / 10 + '°C ' +
-                    ', ' + value[24] / 6 + 'h:' + value[25] + 'm ' + value[26] / 10 + '°C ' +
-                    ', ' + value[27] / 6 + 'h:' + value[28] + 'm ' + value[29] / 10 + '°C ',
-                };
-            case tuya.dataPoints.tvSaturdaySchedule:
-                return {schedule_saturday:
-                    '  ' + value[0] / 6 + 'h:' + value[1] + 'm ' + value[2] / 10 + '°C' +
-                    ', ' + value[3] / 6 + 'h:' + value[4] + 'm ' + value[5] / 10 + '°C' +
-                    ', ' + value[6] / 6 + 'h:' + value[7] + 'm ' + value[8] / 10 + '°C' +
-                    ', ' + value[9] / 6 + 'h:' + value[10] + 'm ' + value[11] / 10 + '°C' +
-                    ', ' + value[12] / 6 + 'h:' + value[13] + 'm ' + value[14] / 10 + '°C ' +
-                    ', ' + value[15] / 6 + 'h:' + value[16] + 'm ' + value[17] / 10 + '°C ' +
-                    ', ' + value[18] / 6 + 'h:' + value[19] + 'm ' + value[20] / 10 + '°C ' +
-                    ', ' + value[21] / 6 + 'h:' + value[22] + 'm ' + value[23] / 10 + '°C ' +
-                    ', ' + value[24] / 6 + 'h:' + value[25] + 'm ' + value[26] / 10 + '°C ' +
-                    ', ' + value[27] / 6 + 'h:' + value[28] + 'm ' + value[29] / 10 + '°C ',
-                };
-            case tuya.dataPoints.tvSundaySchedule:
-                return {schedule_sunday:
-                    '  ' + value[0] / 6 + 'h:' + value[1] + 'm ' + value[2] / 10 + '°C' +
-                    ', ' + value[3] / 6 + 'h:' + value[4] + 'm ' + value[5] / 10 + '°C' +
-                    ', ' + value[6] / 6 + 'h:' + value[7] + 'm ' + value[8] / 10 + '°C' +
-                    ', ' + value[9] / 6 + 'h:' + value[10] + 'm ' + value[11] / 10 + '°C' +
-                    ', ' + value[12] / 6 + 'h:' + value[13] + 'm ' + value[14] / 10 + '°C ' +
-                    ', ' + value[15] / 6 + 'h:' + value[16] + 'm ' + value[17] / 10 + '°C ' +
-                    ', ' + value[18] / 6 + 'h:' + value[19] + 'm ' + value[20] / 10 + '°C ' +
-                    ', ' + value[21] / 6 + 'h:' + value[22] + 'm ' + value[23] / 10 + '°C ' +
-                    ', ' + value[24] / 6 + 'h:' + value[25] + 'm ' + value[26] / 10 + '°C ' +
-                    ', ' + value[27] / 6 + 'h:' + value[28] + 'm ' + value[29] / 10 + '°C ',
-                };
-
-            default:
-                meta.logger.warn(`zigbee-herdsman-converters:tvtwo_thermostat: NOT RECOGNIZED DP #${
-                    dp} with data ${JSON.stringify(dpValue)}`);
-            }
-        },
-    },
     haozee_thermostat: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport'],

package/converters/toZigbee.js

@@ -3518,91 +3518,6 @@ const converters = {
             return tuya.sendDataPointRaw(entity, tuya.dataPoints.moesSschedule, payload);
         },
     },
-    tvtwo_thermostat: {
-        key: [
-            'child_lock', 'open_window', 'open_window_temperature', 'frost_protection', 'heating_stop',
-            'current_heating_setpoint', 'local_temperature_calibration', 'preset', 'boost_timeset_countdown',
-            'holiday_start_stop', 'holiday_temperature', 'comfort_temperature', 'eco_temperature',
-            'working_day', 'week_schedule_programming', 'online', 'holiday_mode_date',
-        ],
-        convertSet: async (entity, key, value, meta) => {
-            switch (key) {
-            case 'preset': {
-                const presetLookup = {'auto': 0, 'manual': 1, 'holiday': 3};
-                await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvMode, presetLookup[value]);
-                return {state: {preset: value}};}
-            case 'heating_stop':
-                if (value == 'ON') {
-                    await tuya.sendDataPointBool(entity, tuya.dataPoints.tvHeatingStop, 1);
-                } else {
-                    await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvMode, 1 /* manual */);
-                }
-                break;
-            case 'frost_protection':
-                if (value == 'ON') {
-                    await tuya.sendDataPointBool(entity, tuya.dataPoints.tvFrostDetection, 1);
-                } else {
-                    await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvMode, 1 /* manual */);
-                }
-                break;
-            case 'open_window':
-                await tuya.sendDataPointBool(entity, tuya.dataPoints.tvWindowDetection, value === 'ON');
-                break;
-            case 'child_lock':
-                await tuya.sendDataPointBool(entity, tuya.dataPoints.tvChildLock, value === 'LOCK');
-                break;
-            case 'local_temperature_calibration':
-                if (value > 0) value = value*10;
-                if (value < 0) value = value*10 + 0x100000000;
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvTempCalibration, value);
-                break;
-            case 'current_heating_setpoint':
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvHeatingSetpoint, value * 10);
-                await utils.sleep(500);
-                await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvMode, 1 /* manual */);
-                break;
-            case 'holiday_temperature':
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvHolidayTemp, value * 10);
-                break;
-            case 'comfort_temperature':
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvComfortTemp, value * 10);
-                break;
-            case 'eco_temperature':
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvEcoTemp, value * 10);
-                break;
-            case 'boost_timeset_countdown':
-                // set min 0 - max 465 sec boost time
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvBoostTime, value);
-                break;
-            case 'open_window_temperature':
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvOpenWindowTemp, value * 10);
-                break;
-            case 'holiday_start_stop': {
-                const numberPattern = /\d+/g;
-                value = value.match(numberPattern).join([]).toString();
-                return tuya.sendDataPointStringBuffer(entity, tuya.dataPoints.tvHolidayMode, value);
-            }
-            case 'online':
-                // 115 online / Is the device online
-                await tuya.sendDataPointBool(entity, tuya.dataPoints.tvBoostMode, value === 'ON');
-                break;
-            case 'working_day': {
-                // DP-31, Send and Report, ENUM,  Week select 0 - 5 days, 1 - 6 days, 2 - 7 days
-                const workLookup = {'0': 0, '1': 1, '2': 2, '3': 3};
-                const workDay = workLookup[value];
-                await tuya.sendDataPointEnum(entity, tuya.dataPoints.tvWorkingDay, workDay);
-                return {state: {working_day: value}};
-            }
-            case 'week_schedule_programming':
-                // DP-106, Send Only, raw, week_program3_day
-                await tuya.sendDataPointRaw(entity, tuya.dataPoints.tvWeekSchedule, value);
-                break;
-
-            default: // Unknown key
-                meta.logger.warn(`toZigbee.tvtwo_thermostat: Unhandled key ${key}`);
-            }
-        },
-    },
     haozee_thermostat_system_mode: {
         key: ['preset'],
         convertSet: async (entity, key, value, meta) => {

package/devices/awox.js

@@ -155,7 +155,7 @@ module.exports = [
         model: '33957',
         vendor: 'AwoX',
         description: 'LED light with color temperature',
-        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
         whiteLabel: [{vendor: 'EGLO', model: '12239'}],
     },
     {

package/devices/develco.js

@@ -25,6 +25,33 @@ const develcoLedControlMap = {
     0xFF: 'both',
 };
 
+
+const fwOnEvent = async (type, data, device, options, state) => {
+    /**
+     * Develco devices have a manufacturer specific field on genBasic
+     *   for sw and hw versions.
+     *
+     * We read those during deviceInterview
+     *   so that this information is usable during configure() calls
+     *   to skip some features on older devices that might cause
+     *   timeouts and other issues.
+     */
+    if (type === 'deviceInterview') { // WARN: also reading on deviceAnnounce hits a timeout!
+        try {
+            const data = await device.endpoints[0].read('genBasic', ['develcoPrimarySwVersion', 'develcoPrimaryHwVersion'],
+                manufacturerOptions);
+
+            if (data.hasOwnProperty('develcoPrimarySwVersion')) {
+                device.softwareBuildID = data.develcoPrimarySwVersion.join('.');
+            }
+
+            if (data.hasOwnProperty('develcoPrimaryHwVersion')) {
+                device.hardwareVersion = data.develcoPrimaryHwVersion.join('.');
+            }
+        } catch (error) {/* catch timeouts of sleeping devices */}
+    }
+};
+
 // develco specific convertors
 const develco = {
     fz: {
@@ -86,24 +113,6 @@ const develco = {
                 return result;
             },
         },
-        firmware_version: {
-            cluster: 'genBasic',
-            type: ['attributeReport', 'readResponse'],
-            convert: (model, msg, publish, options, meta) => {
-                const result = {};
-                if (msg.data.hasOwnProperty('develcoPrimarySwVersion')) {
-                    const firmware = msg.data.develcoPrimarySwVersion.join('.');
-                    result.current_firmware = firmware;
-                    meta.device.softwareBuildID = firmware;
-                }
-
-                if (msg.data.hasOwnProperty('develcoPrimaryHwVersion')) {
-                    meta.device.hardwareVersion = msg.data.develcoPrimaryHwVersion.join('.');
-                }
-
-                return result;
-            },
-        },
         fault_status: {
             cluster: 'genBinaryInput',
             type: ['attributeReport', 'readResponse'],
@@ -374,12 +383,11 @@ module.exports = [
         model: 'EMIZB-132',
         vendor: 'Develco',
         description: 'Wattle AMS HAN power-meter sensor',
-        fromZigbee: [develco.fz.metering, develco.fz.electrical_measurement, develco.fz.firmware_version],
+        fromZigbee: [develco.fz.metering, develco.fz.electrical_measurement],
         toZigbee: [tz.EMIZB_132_mode],
         ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
-            await endpoint.read('genBasic', ['develcoPrimarySwVersion', 'develcoPrimaryHwVersion'], manufacturerOptions);
             await reporting.bind(endpoint, coordinatorEndpoint, ['haElectricalMeasurement', 'seMetering']);
 
             try {
@@ -402,6 +410,7 @@ module.exports = [
         exposes: [e.power(), e.energy(), e.current(), e.voltage(), e.current_phase_b(), e.voltage_phase_b(), e.current_phase_c(),
             e.voltage_phase_c()],
         onEvent: async (type, data, device) => {
+            fwOnEvent(type, data, device);
             if (type === 'message' && data.type === 'attributeReport' && data.cluster === 'seMetering' && data.data['divisor']) {
                 // Device sends wrong divisior (512) while it should be fixed to 1000
                 // https://github.com/Koenkk/zigbee-herdsman-converters/issues/3066
@@ -415,16 +424,16 @@ module.exports = [
         vendor: 'Develco',
         description: 'Smoke detector with siren',
         fromZigbee: [fz.temperature, fz.battery, fz.ias_smoke_alarm_1_develco, fz.ignore_basic_report,
-            develco.fz.firmware_version, fz.ias_enroll, fz.ias_wd, develco.fz.fault_status],
+            fz.ias_enroll, fz.ias_wd, develco.fz.fault_status],
         toZigbee: [tz.warning, tz.ias_max_duration, tz.warning_simple],
         ota: ota.zigbeeOTA,
+        onEvent: fwOnEvent,
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(35);
 
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'ssIasZone', 'ssIasWd', 'genBasic', 'genBinaryInput']);
             await reporting.batteryVoltage(endpoint);
-            await endpoint.read('genBasic', ['develcoPrimarySwVersion', 'develcoPrimaryHwVersion'], manufacturerOptions);
             await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState', 'zoneId']);
             await endpoint.read('genBinaryInput', ['reliability', 'statusFlags']);
             await endpoint.read('ssIasWd', ['maxDuration']);
@@ -449,15 +458,15 @@ module.exports = [
         vendor: 'Develco',
         description: 'Fire detector with siren',
         fromZigbee: [fz.temperature, fz.battery, fz.ias_smoke_alarm_1_develco, fz.ignore_basic_report,
-            develco.fz.firmware_version, fz.ias_enroll, fz.ias_wd, develco.fz.fault_status],
+            fz.ias_enroll, fz.ias_wd, develco.fz.fault_status],
         toZigbee: [tz.warning, tz.ias_max_duration, tz.warning_simple],
         meta: {battery: {voltageToPercentage: '3V_2500'}},
+        onEvent: fwOnEvent,
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(35);
 
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'ssIasZone', 'ssIasWd', 'genBasic', 'genBinaryInput']);
             await reporting.batteryVoltage(endpoint);
-            await endpoint.read('genBasic', ['develcoPrimarySwVersion'], manufacturerOptions);
             await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState', 'zoneId']);
             await endpoint.read('genBinaryInput', ['reliability', 'statusFlags']);
             await endpoint.read('ssIasWd', ['maxDuration']);
@@ -519,16 +528,29 @@ module.exports = [
         description: 'Motion sensor',
         fromZigbee: [
             fz.temperature, fz.illuminance, fz.ias_occupancy_alarm_1, fz.battery,
-            develco.fz.led_control, develco.fz.ias_occupancy_timeout, develco.fz.firmware_version,
+            develco.fz.led_control, develco.fz.ias_occupancy_timeout,
         ],
         toZigbee: [develco.tz.led_control, develco.tz.ias_occupancy_timeout],
-        exposes: [
-            e.occupancy(), e.battery(), e.battery_low(),
-            e.tamper(), e.temperature(), e.illuminance_lux(),
-            exposes.enum('led_control', ea.ALL, ['off', 'fault_only', 'motion_only', 'both']).
-                withDescription('Control LED indicator usage.'),
-            exposes.numeric('occupancy_timeout', ea.ALL).withUnit('second').withValueMin(20).withValueMax(65535),
-        ],
+        onEvent: fwOnEvent,
+        exposes: (device, options) => {
+            const dynExposes = [];
+            dynExposes.push(e.occupancy());
+            if (device && device.softwareBuildID && device.softwareBuildID.split('.')[0] >= 3) {
+                dynExposes.push(exposes.numeric('occupancy_timeout', ea.ALL).withUnit('second').
+                    withValueMin(20).withValueMax(65535));
+            }
+            dynExposes.push(e.temperature());
+            dynExposes.push(e.illuminance_lux());
+            dynExposes.push(e.tamper());
+            dynExposes.push(e.battery_low());
+            dynExposes.push(e.battery());
+            if (device && device.softwareBuildID && device.softwareBuildID.split('.')[0] >= 4) {
+                dynExposes.push(exposes.enum('led_control', ea.ALL, ['off', 'fault_only', 'motion_only', 'both']).
+                    withDescription('Control LED indicator usage.'));
+            }
+            dynExposes.push(e.linkquality());
+            return dynExposes;
+        },
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         endpoint: (device) => {
             return {default: 35};
@@ -547,12 +569,14 @@ module.exports = [
             const endpoint35 = device.getEndpoint(35);
             await reporting.bind(endpoint35, coordinatorEndpoint, ['genPowerCfg']);
             await reporting.batteryVoltage(endpoint35, {min: constants.repInterval.HOUR, max: 43200, change: 100});
-            await endpoint35.read('genBasic', ['develcoPrimarySwVersion', 'develcoPrimaryHwVersion'], manufacturerOptions);
 
-            try {
+            // zigbee2mqtt#14277 some features are not available on older firmwares
+            if (device && device.softwareBuildID && device.softwareBuildID.split('.')[0] >= 3) {
                 await endpoint35.read('ssIasZone', ['develcoAlarmOffDelay'], manufacturerOptions);
+            }
+            if (device && device.softwareBuildID && device.softwareBuildID.split('.')[0] >= 4) {
                 await endpoint35.read('genBasic', ['develcoLedControl'], manufacturerOptions);
-            } catch (error) {/* some reports of timeouts on reading these */}
+            }
         },
     },
     {
@@ -677,14 +701,14 @@ module.exports = [
         model: 'SIRZB-110',
         vendor: 'Develco',
         description: 'Customizable siren',
-        fromZigbee: [fz.temperature, fz.battery, fz.ias_enroll, fz.ias_wd, develco.fz.firmware_version, fz.ias_siren],
+        fromZigbee: [fz.temperature, fz.battery, fz.ias_enroll, fz.ias_wd, fz.ias_siren],
         toZigbee: [tz.warning, tz.warning_simple, tz.ias_max_duration, tz.squawk],
+        onEvent: fwOnEvent,
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(43);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'ssIasZone', 'ssIasWd', 'genBasic']);
             await reporting.batteryVoltage(endpoint);
-            await endpoint.read('genBasic', ['develcoPrimarySwVersion', 'develcoPrimaryHwVersion'], manufacturerOptions);
             await endpoint.read('ssIasZone', ['iasCieAddr', 'zoneState', 'zoneId']);
             await endpoint.read('ssIasWd', ['maxDuration']);
 
@@ -743,8 +767,9 @@ module.exports = [
         model: 'IOMZB-110',
         vendor: 'Develco',
         description: 'IO module',
-        fromZigbee: [fz.on_off, develco.fz.input, develco.fz.firmware_version],
+        fromZigbee: [fz.on_off, develco.fz.input],
         toZigbee: [tz.on_off, develco.tz.input],
+        onEvent: fwOnEvent,
         meta: {multiEndpoint: true},
         exposes: [
             exposes.binary('input', ea.STATE_GET, true, false).withEndpoint('l1').withDescription('State of input 1'),
@@ -755,12 +780,9 @@ module.exports = [
             exposes.switch().withState('state', true, 'On/off state of switch 2').withEndpoint('l12'),
         ],
         configure: async (device, coordinatorEndpoint, logger) => {
-            const options = {manufacturerCode: 4117};
-
             const ep2 = device.getEndpoint(112);
             await reporting.bind(ep2, coordinatorEndpoint, ['genBinaryInput', 'genBasic']);
             await reporting.presentValue(ep2, {min: 0});
-            await ep2.read('genBasic', ['develcoPrimarySwVersion', 'develcoPrimaryHwVersion'], options);
 
             const ep3 = device.getEndpoint(113);
             await reporting.bind(ep3, coordinatorEndpoint, ['genBinaryInput']);

package/devices/lonsonho.js

@@ -84,7 +84,10 @@ module.exports = [
         exposes: [
             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'),
+            exposes.numeric('calibration_time', ea.STATE).withUnit('S').withDescription('Calibration time')
+                .withEndpoint('left'),
+            exposes.numeric('calibration_time', ea.STATE).withUnit('S').withDescription('Calibration time')
+                .withEndpoint('right'),
             e.cover_position().withEndpoint('left'), exposes.binary('calibration', ea.ALL, 'ON', 'OFF')
                 .withEndpoint('left'), exposes.binary('motor_reversal', ea.ALL, 'ON', 'OFF').withEndpoint('left'),
             e.cover_position().withEndpoint('right'), exposes.binary('calibration', ea.ALL, 'ON', 'OFF')

package/devices/moes.js

@@ -1,5 +1,5 @@
 const exposes = require('../lib/exposes');
-const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const fz = require('../converters/fromZigbee');
 const tz = require('../converters/toZigbee');
 const ota = require('../lib/ota');
 const tuya = require('../lib/tuya');
@@ -26,11 +26,13 @@ module.exports = [
         model: 'ZP-LZ-FR2U',
         vendor: 'Moes',
         description: 'Zigbee 3.0 dual USB wireless socket plug',
-        fromZigbee: [fz.on_off, fz.tuya_switch_power_outage_memory, fz.ts011f_plug_child_mode],
-        toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory, tz.ts011f_plug_child_mode],
+        fromZigbee: [fz.on_off, fz.tuya_switch_power_outage_memory, fz.ts011f_plug_indicator_mode, fz.ts011f_plug_child_mode],
+        toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory, tz.ts011f_plug_indicator_mode, tz.ts011f_plug_child_mode],
         exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),
             exposes.enum('power_outage_memory', ea.ALL, ['on', 'off', 'restore'])
-                .withDescription('Recover state after power outage'), e.child_lock()],
+                .withDescription('Recover state after power outage'),
+            exposes.enum('indicator_mode', ea.ALL, ['off', 'off/on', 'on/off', 'on'])
+                .withDescription('Plug LED indicator mode'), e.child_lock()],
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2};
         },

package/devices/philips.js

@@ -932,7 +932,7 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color(),
     },
     {
-        zigbeeModel: ['LCL001'],
+        zigbeeModel: ['LCL001', 'LCL006'],
         model: '8718699703424',
         vendor: 'Philips',
         description: 'Hue white and color ambiance LightStrip plus',

package/devices/tuya.js

@@ -1079,7 +1079,7 @@ module.exports = [
         },
     },
     {
-        fingerprint: [{modelID: 'TS0202', manufacturerName: '_TZ3000_mcxw5ehu'}],
+        fingerprint: tuya.fingerprint('TS0202', ['_TZ3000_mcxw5ehu', '_TZ3040_6ygjfyll']),
         model: 'IH012-RT01',
         vendor: 'TuYa',
         description: 'Motion sensor',
@@ -2014,7 +2014,6 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_cpmgn2cf'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_4eeyebrt'}, // Immax 07732B
             {modelID: 'TS0601', manufacturerName: '_TZE200_8whxpsiw'}, // EVOLVEO
-            {modelID: 'TS0601', manufacturerName: '_TZE200_bvu2wnxz'}, /* model: 'TRV06', vendor: 'AVATTO' */
         ],
         model: 'TS0601_thermostat',
         vendor: 'TuYa',
@@ -2059,15 +2058,16 @@ module.exports = [
                 .withFeature(exposes.text('holidays_schedule', ea.STATE_SET))],
     },
     {
-        fingerprint: [
-            {modelID: 'TS0601', manufacturerName: '_TZE200_hue3yfsn'}, /* model: 'TV02-Zigbee', vendor: 'TuYa' */
-            {modelID: 'TS0601', manufacturerName: '_TZE200_e9ba97vf'}, /* model: 'TV01-ZB', vendor: 'Moes' */
-            {modelID: 'TS0601', manufacturerName: '_TZE200_husqqvux'}, /* model: 'TSL-TRV-TV01ZG', vendor: 'Tesla Smart' */
-            {modelID: 'TS0601', manufacturerName: '_TZE200_lllliz3p'}, /* model: 'TV02-Zigbee', vendor: 'TuYa' */
-            {modelID: 'TS0601', manufacturerName: '_TZE200_mudxchsu'}, /* model: 'TV05-ZG curve', vendor: 'TuYa' */
-            {modelID: 'TS0601', manufacturerName: '_TZE200_7yoranx2'}, /* model: 'TV01-ZB', vendor: 'Moes' */
-            {modelID: 'TS0601', manufacturerName: '_TZE200_kds0pmmv'}, /* model: 'TV01-ZB', vendor: 'Moes' */
-        ],
+        fingerprint: tuya.fingerprint('TS0601', [
+            '_TZE200_hue3yfsn', /* model: 'TV02-Zigbee', vendor: 'TuYa' */
+            '_TZE200_e9ba97vf', /* model: 'TV01-ZB', vendor: 'Moes' */
+            '_TZE200_husqqvux', /* model: 'TSL-TRV-TV01ZG', vendor: 'Tesla Smart' */
+            '_TZE200_lnbfnyxd', /* model: 'TSL-TRV-TV01ZG', vendor: 'Tesla Smart' */
+            '_TZE200_lllliz3p', /* model: 'TV02-Zigbee', vendor: 'TuYa' */
+            '_TZE200_mudxchsu', /* model: 'TV05-ZG curve', vendor: 'TuYa' */
+            '_TZE200_7yoranx2', /* model: 'TV01-ZB', vendor: 'Moes' */
+            '_TZE200_kds0pmmv', /* model: 'TV01-ZB', vendor: 'Moes' */
+        ]),
         model: 'TV02-Zigbee',
         vendor: 'TuYa',
         description: 'Thermostat radiator valve',
@@ -2078,30 +2078,49 @@ module.exports = [
             {vendor: 'Unknown/id3.pl', model: 'GTZ08'},
         ],
         ota: ota.zigbeeOTA,
-        fromZigbee: [fz.ignore_basic_report, fz.ignore_tuya_set_time, fz.tvtwo_thermostat],
-        toZigbee: [tz.tvtwo_thermostat],
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
         onEvent: tuya.onEventSetLocalTime,
+        configure: tuya.configureMagicPacket,
         exposes: [
-            e.battery_low(), e.child_lock(), e.open_window(), e.open_window_temperature().withValueMin(0).withValueMax(30),
-            e.comfort_temperature().withValueMin(0).withValueMax(30), e.eco_temperature().withValueMin(0).withValueMax(30),
-            exposes.climate().withPreset(['auto', 'manual', 'holiday']).withLocalTemperatureCalibration(-5, 5, 0.1, ea.STATE_SET)
-                .withLocalTemperature(ea.STATE).withSetpoint('current_heating_setpoint', 0, 30, 0.5, ea.STATE_SET),
+            e.battery(), e.child_lock(), e.open_window(), e.open_window_temperature().withValueMin(5).withValueMax(30),
+            e.comfort_temperature().withValueMin(5).withValueMax(30), e.eco_temperature().withValueMin(5).withValueMax(30),
+            exposes.climate().withSystemMode(['off', 'heat'], ea.STATE_SET, 'When switched to the "off" mode, the device will display ' +
+                '"HS" and the valve will be fully closed. Press the pair button to cancel or switch back to "heat" mode. Battery life ' +
+                'can be prolonged by switching the heating off. After switching to `heat` mode, `preset` will be reset to `auto` and ' +
+                'after changing `preset` to `manual` temperature setpoint will be 20 degrees.').withPreset(['auto', 'manual', 'holiday'],
+                '`auto` uses schedule properties, check them. `manual` allows you to control the device, `holiday` uses ' +
+                '`holiday_start_stop` and `holiday_temperature` properties.').withLocalTemperatureCalibration(-5, 5, 0.1, ea.STATE_SET)
+                .withLocalTemperature(ea.STATE).withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET),
             exposes.numeric('boost_timeset_countdown', ea.STATE_SET).withUnit('second').withDescription('Setting '+
                     'minimum 0 - maximum 465 seconds boost time. The boost (♨) function is activated. The remaining '+
                     'time for the function will be counted down in seconds ( 465 to 0 ).').withValueMin(0).withValueMax(465),
             exposes.binary('frost_protection', ea.STATE_SET, 'ON', 'OFF').withDescription('When Anti-Freezing function'+
                     ' is activated, the temperature in the house is kept at 8 °C, the device display "AF".press the '+
                     'pair button to cancel.'),
-            exposes.binary('heating_stop', ea.STATE_SET, 'ON', 'OFF').withDescription('Battery life can be prolonged'+
-                    ' by switching the heating off. To achieve this, the valve is closed fully. To activate the '+
-                    'heating stop, the device display "HS", press the pair button to cancel.'),
-            e.holiday_temperature(),
-            exposes.text('holiday_start_stop', ea.STATE_SET).withDescription('The holiday mode( ⛱ ) will '+
-                    'automatically start at the set time starting point and run the holiday temperature.'),
-            // exposes.enum('working_day', ea.STATE_SET, ['0', '1', '2', '3']),
-            exposes.composite('schedule')/* .withFeature(exposes.text('week_schedule_programming', ea.STATE_SET)) */
-                .withDescription('week_schedule').withDescription('Auto Mode ⏱ - In this mode, '+
-                    'the device executes a preset week programming temperature time and temperature. '),
+            exposes.binary('heating_stop', ea.STATE_SET, 'ON', 'OFF').withDescription('Same as `system_mode`. Left for compatibility.'),
+            exposes.numeric('holiday_temperature', ea.STATE_SET).withUnit('°C').withDescription('Holiday temperature')
+                .withValueMin(5).withValueMax(30),
+            exposes.text('holiday_start_stop', ea.STATE_SET).withDescription('The holiday mode will automatically start ' +
+                'at the set time starting point and run the holiday temperature. Can be defined in the following format: ' +
+                '`startYear/startMonth/startDay startHours:startMinutes | endYear/endMonth/endDay endHours:endMinutes`. ' +
+                'For example: `2022/10/01 16:30 | 2022/10/21 18:10`. After the end of holiday mode, it switches to "auto" ' +
+                'mode and uses schedule.'),
+            exposes.enum('working_day', ea.STATE_SET, ['mon_sun', 'mon_fri+sat+sun', 'separate']).withDescription('`mon_sun` ' +
+                '- schedule for Monday used for each day (define it only for Monday). `mon_fri+sat+sun` - schedule for ' +
+                'workdays used from Monday (define it only for Monday), Saturday and Sunday are defined separately. `separate` ' +
+                '- schedule for each day is defined separately.'),
+            exposes.composite('schedule', 'schedule').withFeature(exposes.enum('week_day', ea.SET, ['monday', 'tuesday',
+                'wednesday', 'thursday', 'friday', 'saturday', 'sunday'])).withFeature(exposes.text('schedule', ea.SET))
+                .withDescription('Schedule will work with "auto" preset. In this mode, the device executes ' +
+                'a preset week programming temperature time and temperature. Before using these properties, check `working_day` ' +
+                'property. Each day can contain up to 10 segments. At least 1 segment should be defined. Different count of segments ' +
+                'can be defined for each day, e.g., 3 segments for Monday, 5 segments for Thursday, etc. It should be defined in the ' +
+                'following format: `hours:minutes/temperature`. Minutes can be only tens, i.e., 00, 10, 20, 30, 40, 50. Segments should ' +
+                'be divided by space symbol. Each day should end with the last segment of 24:00. Examples: `04:00/20 08:30/22 10:10/18 ' +
+                '18:40/24 22:50/19.5`; `06:00/21.5 17:20/26 24:00/18`. The temperature will be set from the beginning/start of one ' +
+                'period and until the next period, e.g., `04:00/20 24:00/22` means that from 00:00 to 04:00 temperature will be 20 ' +
+                'degrees and from 04:00 to 00:00 temperature will be 22 degrees.'),
             exposes.text('schedule_monday', ea.STATE),
             exposes.text('schedule_tuesday', ea.STATE),
             exposes.text('schedule_wednesday', ea.STATE),
@@ -2109,9 +2128,44 @@ module.exports = [
             exposes.text('schedule_friday', ea.STATE),
             exposes.text('schedule_saturday', ea.STATE),
             exposes.text('schedule_sunday', ea.STATE),
-            exposes.binary('online', ea.STATE_SET, 'ON', 'OFF').withDescription('Is the device online'),
+            exposes.binary('online', ea.STATE_SET, 'ON', 'OFF').withDescription('Turn on this property to poll current data from the ' +
+                'device. It can be used to periodically fetch a new local temperature since the device doesn\'t update itself. ' +
+                'Setting this property doesn\'t turn on the display.'),
             exposes.numeric('error_status', ea.STATE).withDescription('Error status'),
         ],
+        meta: {
+            tuyaDatapoints: [
+                [2, 'preset', tuya.valueConverterBasic.lookup({'auto': tuya.enum(0), 'manual': tuya.enum(1), 'holiday': tuya.enum(3)})],
+                [8, 'open_window', tuya.valueConverter.onOff],
+                [10, 'frost_protection', tuya.valueConverter.onOff],
+                [16, 'current_heating_setpoint', tuya.valueConverter.divideBy10],
+                [24, 'local_temperature', tuya.valueConverter.divideBy10],
+                [27, 'local_temperature_calibration', tuya.valueConverter.localTempCalibration],
+                [31, 'working_day', tuya.valueConverterBasic.lookup({'mon_sun': tuya.enum(0), 'mon_fri+sat+sun': tuya.enum(1),
+                    'separate': tuya.enum(2)})],
+                [32, 'holiday_temperature', tuya.valueConverter.divideBy10],
+                [35, 'battery_low', tuya.valueConverter.true0ElseFalse],
+                [40, 'child_lock', tuya.valueConverter.lockUnlock],
+                [45, 'error_status', tuya.valueConverter.raw],
+                [46, 'holiday_start_stop', tuya.valueConverter.thermostatHolidayStartStop],
+                [101, 'boost_timeset_countdown', tuya.valueConverter.raw],
+                [102, 'open_window_temperature', tuya.valueConverter.divideBy10],
+                [104, 'comfort_temperature', tuya.valueConverter.divideBy10],
+                [105, 'eco_temperature', tuya.valueConverter.divideBy10],
+                [106, 'schedule', tuya.valueConverter.thermostatScheduleDay],
+                [107, null, tuya.valueConverter.TV02SystemMode],
+                [107, 'system_mode', tuya.valueConverterBasic.lookup({'heat': false, 'off': true})],
+                [107, 'heating_stop', tuya.valueConverter.onOff],
+                [115, 'online', tuya.valueConverter.onOffNotStrict],
+                [108, 'schedule_monday', tuya.valueConverter.thermostatScheduleDay],
+                [112, 'schedule_tuesday', tuya.valueConverter.thermostatScheduleDay],
+                [109, 'schedule_wednesday', tuya.valueConverter.thermostatScheduleDay],
+                [113, 'schedule_thursday', tuya.valueConverter.thermostatScheduleDay],
+                [110, 'schedule_friday', tuya.valueConverter.thermostatScheduleDay],
+                [114, 'schedule_saturday', tuya.valueConverter.thermostatScheduleDay],
+                [111, 'schedule_sunday', tuya.valueConverter.thermostatScheduleDay],
+            ],
+        },
     },
     {
         fingerprint: [

package/lib/tuya.js

@@ -1178,6 +1178,27 @@ const fingerprint = (modelID, manufacturerNames) => {
     });
 };
 
+class Base {
+    constructor(value) {
+        this.value = value;
+    }
+
+    valueOf() {
+        return this.value;
+    }
+}
+class Enum extends Base {
+    constructor(value) {
+        super(value);
+    }
+}
+
+class Bitmap extends Base {
+    constructor(value) {
+        super(value);
+    }
+}
+
 const valueConverterBasic = {
     lookup: (map) => {
         return {
@@ -1186,7 +1207,7 @@ const valueConverterBasic = {
                 return map[v];
             },
             from: (v) => {
-                const value = Object.entries(map).find((i) => i[1] === v);
+                const value = Object.entries(map).find((i) => i[1].valueOf() === v);
                 if (!value) throw new Error(`Value '${v}' is not allowed, expected one of ${Object.values(map)}`);
                 return value[0];
             },
@@ -1222,11 +1243,140 @@ const valueConverter = {
     },
     true0ElseFalse: {from: (v) => v === 0},
     selfTestResult: valueConverterBasic.lookup({'checking': 0, 'success': 1, 'failure': 2, 'others': 3}),
+    lockUnlock: valueConverterBasic.lookup({'LOCK': true, 'UNLOCK': false}),
+    localTempCalibration: {
+        from: (v) => {
+            if (v > 55) v -= 0x100000000;
+            return v / 10;
+        },
+        to: (v) => {
+            if (v > 0) return v * 10;
+            if (v < 0) return v * 10 + 0x100000000;
+            return v;
+        },
+    },
+    thermostatHolidayStartStop: {
+        from: (v) => {
+            const start = {
+                year: v.slice(0, 4), month: v.slice(4, 6), day: v.slice(6, 8),
+                hours: v.slice(8, 10), minutes: v.slice(10, 12),
+            };
+            const end = {
+                year: v.slice(12, 16), month: v.slice(16, 18), day: v.slice(18, 20),
+                hours: v.slice(20, 22), minutes: v.slice(22, 24),
+            };
+            const startStr = `${start.year}/${start.month}/${start.day} ${start.hours}:${start.minutes}`;
+            const endStr = `${end.year}/${end.month}/${end.day} ${end.hours}:${end.minutes}`;
+            return `${startStr} | ${endStr}`;
+        },
+        to: (v) => {
+            const numberPattern = /\d+/g;
+            return v.match(numberPattern).join([]).toString();
+        },
+    },
+    thermostatScheduleDay: {
+        from: (v) => {
+            // day splitted to 10 min segments = total 144 segments
+            const maxPeriodsInDay = 10;
+            const periodSize = 3;
+            const schedule = [];
+
+            for (let i = 0; i < maxPeriodsInDay; i++) {
+                const time = v[i * periodSize];
+                const totalMinutes = time * 10;
+                const hours = totalMinutes / 60;
+                const rHours = Math.floor(hours);
+                const minutes = (hours - rHours) * 60;
+                const rMinutes = Math.round(minutes);
+                const strHours = rHours.toString().padStart(2, '0');
+                const strMinutes = rMinutes.toString().padStart(2, '0');
+                const temp = parseFloat(v[i * periodSize + 2] / 10);
+                schedule.push(`${strHours}:${strMinutes}/${temp}`);
+                if (rHours === 24) break;
+            }
+
+            return schedule.join(' ');
+        },
+        to: (v, meta) => {
+            const dayByte = {
+                monday: 1, tuesday: 2, wednesday: 4, thursday: 8,
+                friday: 16, saturday: 32, sunday: 64,
+            };
+            const weekDay = v.week_day;
+            if (Object.keys(dayByte).indexOf(weekDay) === -1) {
+                throw new Error('Invalid "week_day" property value: ' + weekDay);
+            }
+            let weekScheduleType;
+            if (meta.state && meta.state.working_day) weekScheduleType = meta.state.working_day;
+            const payload = [];
+
+            switch (weekScheduleType) {
+            case 'mon_sun':
+                payload.push(127);
+                break;
+            case 'mon_fri+sat+sun':
+                if (['saturday', 'sunday'].indexOf(weekDay) === -1) {
+                    payload.push(31);
+                    break;
+                }
+                payload.push(dayByte[weekDay]);
+                break;
+            case 'separate':
+                payload.push(dayByte[weekDay]);
+                break;
+            default:
+                throw new Error('Invalid "working_day" property, need to set it before');
+            }
+
+            // day splitted to 10 min segments = total 144 segments
+            const maxPeriodsInDay = 10;
+            const schedule = v.schedule.split(' ');
+            const schedulePeriods = schedule.length;
+            if (schedulePeriods > 10) throw new Error('There cannot be more than 10 periods in the schedule: ' + v);
+            if (schedulePeriods < 2) throw new Error('There cannot be less than 2 periods in the schedule: ' + v);
+            let prevHour;
+
+            for (const period of schedule) {
+                const timeTemp = period.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 || m % 10 !== 0 || temp < 5 || temp > 30 || temp % 0.5 !== 0) {
+                    throw new Error('Invalid hour, minute or temperature of: ' + period);
+                } else if (prevHour > h) {
+                    throw new Error(`The hour of the next segment can't be less than the previous one: ${prevHour} > ${h}`);
+                }
+                prevHour = h;
+                const segment = (h * 60 + m) / 10;
+                payload.push(segment, 0, temp * 10);
+            }
+
+            // Add "technical" periods to be valid payload
+            for (let i = 0; i < maxPeriodsInDay - schedulePeriods; i++) {
+                // by default it sends 9000b2, it's 24 hours and 18 degrees
+                payload.push(144, 0, 180);
+            }
+
+            return payload;
+        },
+    },
+    TV02SystemMode: {
+        from: (v) => {
+            return {system_mode: v === false ? 'heat' : 'off', heating_stop: v === false ? 'OFF' : 'ON'};
+        },
+    },
+    onOffNotStrict: {from: (v) => v ? 'ON' : 'OFF', to: (v) => v === 'ON'},
 };
 
 const tzDataPoints = {
-    key: ['state', 'brightness', 'min_brightness', 'max_brightness', 'power_on_behavior',
-        'countdown', 'light_type', 'silence', 'self_test'],
+    key: [
+        'state', 'brightness', 'min_brightness', 'max_brightness', 'power_on_behavior',
+        'countdown', 'light_type', 'silence', 'self_test', 'child_lock', 'open_window', 'open_window_temperature', 'frost_protection',
+        'system_mode', 'heating_stop', 'current_heating_setpoint', 'local_temperature_calibration', 'preset', 'boost_timeset_countdown',
+        'holiday_start_stop', 'holiday_temperature', 'comfort_temperature', 'eco_temperature', 'working_day', 'week_schedule_programming',
+        'online', 'holiday_mode_date', 'schedule',
+    ],
     convertSet: async (entity, key, value, meta) => {
         // A set converter is only called once; therefore we need to loop
         const state = {};
@@ -1240,11 +1390,19 @@ const tzDataPoints = {
             }
             if (dpEntry[3] && dpEntry[3].skip && dpEntry[3].skip(meta)) continue;
             const dpId = dpEntry[0];
-            const convertedValue = dpEntry[2].to(value);
+            const convertedValue = dpEntry[2].to(value, meta);
             if (typeof convertedValue === 'boolean') {
                 await sendDataPointBool(entity, dpId, convertedValue, 'dataRequest', 1);
             } else if (typeof convertedValue === 'number') {
                 await sendDataPointValue(entity, dpId, convertedValue, 'dataRequest', 1);
+            } else if (typeof convertedValue === 'string') {
+                await sendDataPointStringBuffer(entity, dpId, convertedValue, 'dataRequest', 1);
+            } else if (Array.isArray(convertedValue)) {
+                await sendDataPointRaw(entity, dpId, convertedValue, 'dataRequest', 1);
+            } else if (convertedValue instanceof Enum) {
+                await sendDataPointEnum(entity, dpId, convertedValue.valueOf(), 'dataRequest', 1);
+            } else if (convertedValue instanceof Bitmap) {
+                await sendDataPointBitmap(entity, dpId, convertedValue.valueOf(), 'dataRequest', 1);
             } else {
                 throw new Error(`Don't know how to send type '${typeof convertedValue}'`);
             }
@@ -1267,9 +1425,9 @@ const fzDataPoints = {
             if (dpEntry) {
                 const value = getDataValue(dpValue);
                 if (dpEntry[1]) {
-                    result[dpEntry[1]] = dpEntry[2].from(value);
+                    result[dpEntry[1]] = dpEntry[2].from(value, meta);
                 } else if (dpEntry[2]) {
-                    result = {...result, ...dpEntry[2].from(value)};
+                    result = {...result, ...dpEntry[2].from(value, meta)};
                 }
             } else {
                 meta.logger.warn(`Datapoint ${dpId} not defined for '${meta.device.manufacturerName}' ` +
@@ -1285,6 +1443,8 @@ module.exports = {
     skip,
     configureMagicPacket,
     fingerprint,
+    enum: (value) => new Enum(value),
+    bitmap: (value) => new Bitmap(value),
     valueConverter,
     valueConverterBasic,
     tzDataPoints,

package/package.json

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