zigbee-herdsman-converters 14.0.590 → 14.0.591

package/README.md

@@ -23,6 +23,7 @@ If any of those commands finish with an error your PR won't pass the tests and w
 - `supportsHueAndSaturation`: see toZigbee.light_color (default: false)
 - `timeout`: timeout for commands to this device used in toZigbee. (default: 10000)
 - `coverInverted`: Set to true for cover controls that report position=100 as open (default: false)
+- `coverStateFromTilt`: Set cover state based on tilt
 - `turnsOffAtBrightness1`: Indicates light turns off when brightness 1 is set (default: false)
 - `pinCodeCount`: Amount of pincodes the lock can handle
 - `disableActionGroup`: Prevents some converters adding the action_group to the payload (default: false)

package/converters/fromZigbee.js

@@ -1542,15 +1542,22 @@ const converters = {
             // For zigbee-herdsman-converters: open = 100, close = 0
             // ubisys J1 will report 255 if lift or tilt positions are not known, so skip that.
             const invert = model.meta && model.meta.coverInverted ? !options.invert_cover : options.invert_cover;
+            const coverStateFromTilt = model.meta && model.meta.coverStateFromTilt;
             if (msg.data.hasOwnProperty('currentPositionLiftPercentage') && msg.data['currentPositionLiftPercentage'] <= 100) {
                 const value = msg.data['currentPositionLiftPercentage'];
                 result[postfixWithEndpointName('position', msg, model, meta)] = invert ? value : 100 - value;
-                result[postfixWithEndpointName('state', msg, model, meta)] =
-                    invert ? (value === 100 ? 'CLOSE' : 'OPEN') : (value === 0 ? 'CLOSE' : 'OPEN');
+                if (!coverStateFromTilt) {
+                    result[postfixWithEndpointName('state', msg, model, meta)] =
+                        invert ? (value === 100 ? 'CLOSE' : 'OPEN') : (value === 0 ? 'CLOSE' : 'OPEN');
+                }
             }
             if (msg.data.hasOwnProperty('currentPositionTiltPercentage') && msg.data['currentPositionTiltPercentage'] <= 100) {
                 const value = msg.data['currentPositionTiltPercentage'];
                 result[postfixWithEndpointName('tilt', msg, model, meta)] = invert ? value : 100 - value;
+                if (coverStateFromTilt) {
+                    result[postfixWithEndpointName('state', msg, model, meta)] =
+                        invert ? (value === 100 ? 'CLOSE' : 'OPEN') : (value === 0 ? 'CLOSE' : 'OPEN');
+                }
             }
             return result;
         },
@@ -6820,6 +6827,17 @@ const converters = {
             case 7: {
                 return {battery: value};
             }
+            case 10: {
+                let data = 'disabled';
+                if (value == 1) {
+                    data = '24h';
+                } else if (value == 2) {
+                    data = '48h';
+                } else if (value == 3) {
+                    data = '72h';
+                }
+                return {weather_delay: data};
+            }
             case 11: {
                 // value reported in seconds
                 return {timer_time_left: value / 60};
@@ -6833,6 +6851,43 @@ const converters = {
                 // value reported in seconds
                 return {last_valve_open_duration: value / 60};
             }
+            case 16: {
+                const tresult = {
+                    cycle_timer_1: '',
+                    cycle_timer_2: '',
+                    cycle_timer_3: '',
+                    cycle_timer_4: '',
+                };
+                for (let index = 0; index < 40; index += 12) {
+                    const timer = tuya.convertRawToCycleTimer(value.slice(index));
+                    if (timer.irrigationDuration > 0) {
+                        tresult['cycle_timer_' + (index / 13 + 1)] = timer.starttime +
+                            ' / ' + timer.endtime + ' / ' +
+                            timer.irrigationDuration + ' / ' +
+                            timer.pauseDuration + ' / ' +
+                            timer.weekdays + ' / ' + timer.active;
+                    }
+                }
+                return tresult;
+            }
+            case 17: {
+                const tresult = {
+                    normal_schedule_timer_1: '',
+                    normal_schedule_timer_2: '',
+                    normal_schedule_timer_3: '',
+                    normal_schedule_timer_4: '',
+                };
+                for (let index = 0; index < 40; index += 13) {
+                    const timer = tuya.convertRawToTimer(value.slice(index));
+                    if (timer.duration > 0) {
+                        tresult['normal_schedule_timer_' + (index / 13 + 1)] = timer.time +
+                        ' / ' + timer.duration +
+                        ' / ' + timer.weekdays +
+                        ' / ' + timer.active;
+                    }
+                }
+                return tresult;
+            }
             default: {
                 meta.logger.warn(`zigbee-herdsman-converters:RTXZVG1Valve: NOT RECOGNIZED DP ` +
                     `#${dp} with data ${JSON.stringify(dpValue)}`);

package/converters/toZigbee.js

@@ -3992,14 +3992,132 @@ const converters = {
             return {state: {timer: value}};
         },
     },
-    ZVG1_timer_state: {
-        key: ['timer_state'],
-        convertSet: async (entity, key, value, meta) => {
-            let timerState = 2;
-            if (value === 'disabled') timerState = 0;
-            else if (value === 'active') timerState = 1;
-            await tuya.sendDataPointValue(entity, 11, timerState, 'dataRequest', 1);
-            return {state: {timer_state: value}};
+    ZVG1_weather_delay: {
+        key: ['weather_delay'],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = {'disabled': 0, '24h': 1, '48h': 2, '72h': 3};
+            await tuya.sendDataPointEnum(entity, 10, lookup[value]);
+        },
+    },
+    ZVG1_cycle_timer: {
+        key: ['cycle_timer_1', 'cycle_timer_2', 'cycle_timer_3', 'cycle_timer_4'],
+        convertSet: async (entity, key, value, meta) => {
+            let data = [0];
+            const footer = [0x64];
+            if (value == '') {
+                // delete
+                data.push(0x04);
+                data.push(parseInt(key.substr(-1)));
+                await tuya.sendDataPointRaw(entity, 16, data);
+                const ret = {state: {}};
+                ret['state'][key] = value;
+                return ret;
+            } else {
+                if ((meta.state.hasOwnProperty(key) && meta.state[key] == '') ||
+                    !meta.state.hasOwnProperty(key)) {
+                    data.push(0x03);
+                } else {
+                    data.push(0x02);
+                    data.push(parseInt(key.substr(-1)));
+                }
+            }
+
+            const tarray = value.replace(/ /g, '').split('/');
+            if (tarray.length < 4) {
+                throw new Error('Please check the format of the timer string');
+            }
+            if (tarray.length < 5) {
+                tarray.push('MoTuWeThFrSaSu');
+            }
+
+            if (tarray.length < 6) {
+                tarray.push('1');
+            }
+
+            const starttime = tarray[0];
+            const endtime = tarray[1];
+            const irrigationDuration = tarray[2];
+            const pauseDuration = tarray[3];
+            const weekdays = tarray[4];
+            const active = parseInt(tarray[5]);
+
+            if (!(active == 0 || active == 1)) {
+                throw new Error('Active value only 0 or 1 allowed');
+            }
+            data.push(active);
+
+            const weekdaysPart = tuya.convertWeekdaysTo1ByteHexArray(weekdays);
+            data = data.concat(weekdaysPart);
+
+            data = data.concat(tuya.convertTimeTo2ByteHexArray(starttime));
+            data = data.concat(tuya.convertTimeTo2ByteHexArray(endtime));
+
+            data = data.concat(tuya.convertDecimalValueTo2ByteHexArray(irrigationDuration));
+            data = data.concat(tuya.convertDecimalValueTo2ByteHexArray(pauseDuration));
+
+            data = data.concat(footer);
+            await tuya.sendDataPointRaw(entity, 16, data);
+            const ret = {state: {}};
+            ret['state'][key] = value;
+            return ret;
+        },
+    },
+    ZVG1_normal_schedule_timer: {
+        key: ['normal_schedule_timer_1', 'normal_schedule_timer_2', 'normal_schedule_timer_3', 'normal_schedule_timer_4'],
+        convertSet: async (entity, key, value, meta) => {
+            let data = [0];
+            const footer = [0x07, 0xe6, 0x08, 0x01, 0x01];
+            if (value == '') {
+                // delete
+                data.push(0x04);
+                data.push(parseInt(key.substr(-1)));
+                await tuya.sendDataPointRaw(entity, 17, data);
+                const ret = {state: {}};
+                ret['state'][key] = value;
+                return ret;
+            } else {
+                if ((meta.state.hasOwnProperty(key) && meta.state[key] == '') || !meta.state.hasOwnProperty(key)) {
+                    data.push(0x03);
+                } else {
+                    data.push(0x02);
+                    data.push(parseInt(key.substr(-1)));
+                }
+            }
+
+            const tarray = value.replace(/ /g, '').split('/');
+            if (tarray.length < 2) {
+                throw new Error('Please check the format of the timer string');
+            }
+            if (tarray.length < 3) {
+                tarray.push('MoTuWeThFrSaSu');
+            }
+
+            if (tarray.length < 4) {
+                tarray.push('1');
+            }
+
+            const time = tarray[0];
+            const duration = tarray[1];
+            const weekdays = tarray[2];
+            const active = parseInt(tarray[3]);
+
+            if (!(active == 0 || active == 1)) {
+                throw new Error('Active value only 0 or 1 allowed');
+            }
+
+            data = data.concat(tuya.convertTimeTo2ByteHexArray(time));
+
+            const durationPart = tuya.convertDecimalValueTo2ByteHexArray(duration);
+            data = data.concat(durationPart);
+
+            const weekdaysPart = tuya.convertWeekdaysTo1ByteHexArray(weekdays);
+            data = data.concat(weekdaysPart);
+            data = data.concat([64, active]);
+            data = data.concat(footer);
+            await tuya.sendDataPointRaw(entity, 17, data);
+            const ret = {state: {}};
+            ret['state'][key] = value;
+            return ret;
         },
     },
     EMIZB_132_mode: {

package/devices/current_products_corp.js

@@ -12,6 +12,7 @@ module.exports = [
         description: 'Gen. 2 hybrid E-Wand',
         fromZigbee: [fz.cover_position_tilt, fz.battery],
         toZigbee: [tz.cover_state, tz.cover_position_tilt],
+        meta: {coverStateFromTilt: true},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'closuresWindowCovering']);

package/devices/gledopto.js

@@ -330,6 +330,13 @@ module.exports = [
         description: 'Zigbee smart filament LED bulb',
         extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [158, 495]}),
     },
+    {
+        zigbeeModel: ['GL-S-006P'],
+        model: 'GL-S-006P',
+        vendor: 'Gledopto',
+        description: 'Zigbee GU10 LED lamp',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [158, 495]}),
+    },
     {
         zigbeeModel: ['GL-MC-001P'],
         model: 'GL-MC-001P',

package/devices/ikea.js

@@ -319,6 +319,13 @@ module.exports = [
         description: 'TRADFRI LED bulb E27 1000 lumen, dimmable, opal white',
         extend: tradfriExtend.light_onoff_brightness(),
     },
+    {
+        zigbeeModel: ['TRADFRIbulbE26WWglobeclear250lm'],
+        model: 'LED2008G3',
+        vendor: 'IKEA',
+        description: 'TRADFRI LED bulb E26 250 lumen, wireless dimmable warm white/globe clear',
+        extend: tradfriExtend.light_onoff_brightness(),
+    },
     {
         zigbeeModel: ['TRADFRIbulbG125E27WSopal470lm', 'TRADFRIbulbG125E26WSopal450lm'],
         model: 'LED1936G5',

package/devices/osram.js

@@ -331,7 +331,8 @@ module.exports = [
             fz.legacy.osram_lightify_switch_cmdOff, fz.legacy.osram_lightify_switch_cmdMove, fz.battery,
             fz.legacy.osram_lightify_switch_cmdMoveToLevelWithOnOff],
         exposes: [e.battery(), e.action([
-            'up', 'up_hold', 'up_release', 'down_release', 'circle_release', 'circle_hold', 'down', 'down_hold', 'circle_click'])],
+            'on', 'brightness_move_up', 'brightness_move_down', 'brightness_stop', 'color_temperature_move', 'hue_move', 'hue_stop',
+            'move_to_saturation', 'off', 'brightness_move_to_level'])],
         toZigbee: [],
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         ota: ota.ledvance,

package/devices/rtx.js

@@ -6,22 +6,74 @@ const ea = exposes.access;
 
 module.exports = [
     {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_akjefhj5'}, {modelID: 'TS0601', manufacturerName: '_TZE200_2wg5qrjy'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_81isopgh'}],
+        fingerprint: [
+            {modelID: 'TS0601', manufacturerName: '_TZE200_akjefhj5'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_2wg5qrjy'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_81isopgh'},
+        ],
         model: 'ZVG1',
         vendor: 'RTX',
         description: 'Zigbee smart water valve',
         fromZigbee: [fz.ZVG1, fz.ignore_tuya_set_time, fz.ignore_basic_report],
-        toZigbee: [tz.tuya_switch_state, tz.ZVG1_timer, tz.ZVG1_timer_state],
+        toZigbee: [tz.tuya_switch_state, tz.ZVG1_weather_delay, tz.ZVG1_timer, tz.ZVG1_cycle_timer, tz.ZVG1_normal_schedule_timer],
         exposes: [e.switch().setAccess('state', ea.STATE_SET), e.battery(),
-            exposes.enum('timer_state', ea.STATE_SET, ['disabled', 'active', 'enabled']),
-            exposes.numeric('timer', exposes.access.STATE_SET).withValueMin(0).withValueMax(240).withUnit('min')
+            exposes.enum('weather_delay', ea.STATE_SET, ['disabled', '24h', '48h', '72h']),
+            exposes.enum('timer_state', ea.STATE, ['disabled', 'active', 'enabled']),
+            exposes.numeric('timer', ea.STATE_SET).withValueMin(0).withValueMax(60).withUnit('min')
                 .withDescription('Auto off after specific time'),
-            exposes.numeric('timer_time_left', exposes.access.STATE).withUnit('min')
+            exposes.numeric('timer_time_left', ea.STATE).withUnit('min')
                 .withDescription('Auto off timer time left'),
-            exposes.numeric('last_valve_open_duration', exposes.access.STATE).withUnit('min')
+            exposes.numeric('last_valve_open_duration', ea.STATE).withUnit('min')
                 .withDescription('Time the valve was open when state on'),
-            exposes.numeric('water_consumed', exposes.access.STATE).withUnit('l')
-                .withDescription('Liters of water consumed')],
+            exposes.numeric('water_consumed', ea.STATE).withUnit('l')
+                .withDescription('Liters of water consumed'),
+            exposes.text('cycle_timer_1', ea.STATE_SET).withDescription('Format 08:00 / 20:00 / 15 / 60 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '20:00 = end time ' +
+                '15 = irrigation duration in minutes ' +
+                '60 = pause duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)'),
+            exposes.text('cycle_timer_2', ea.STATE_SET).withDescription('Format 08:00 / 20:00 / 15 / 60 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '20:00 = end time ' +
+                '15 = irrigation duration in minutes ' +
+                '60 = pause duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)'),
+            exposes.text('cycle_timer_3', ea.STATE_SET).withDescription('Format 08:00 / 20:00 / 15 / 60 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '20:00 = end time ' +
+                '15 = irrigation duration in minutes ' +
+                '60 = pause duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)'),
+            exposes.text('cycle_timer_4', ea.STATE_SET).withDescription('Format 08:00 / 20:00 / 15 / 60 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '20:00 = end time ' +
+                '15 = irrigation duration in minutes ' +
+                '60 = pause duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)'),
+            exposes.text('normal_schedule_timer_1', ea.STATE_SET).withDescription('Format 08:00 / 15 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '15 = duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)'),
+            exposes.text('normal_schedule_timer_2', ea.STATE_SET).withDescription('Format 08:00 / 15 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '15 = duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)'),
+            exposes.text('normal_schedule_timer_3', ea.STATE_SET).withDescription('Format 08:00 / 15 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '15 = duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)'),
+            exposes.text('normal_schedule_timer_4', ea.STATE_SET).withDescription('Format 08:00 / 15 / MoTuWeThFrSaSu / 1 (' +
+                '08:00 = start time ' +
+                '15 = duration in minutes ' +
+                'MoTu..= active weekdays ' +
+                '1 = deactivate timer with 0)')],
     },
 ];

package/devices/tuya.js

@@ -914,6 +914,7 @@ module.exports = [
     {
         fingerprint: [{modelID: 'TS0207', manufacturerName: '_TZ3000_m0vaazab'},
             {modelID: 'TS0207', manufacturerName: '_TZ3000_ufttklsz'},
+            {modelID: 'TS0207', manufacturerName: '_TZ3000_nkkl7uzv'},
             {modelID: 'TS0207', manufacturerName: '_TZ3000_5k5vh43t'}],
         model: 'TS0207_repeater',
         vendor: 'TuYa',

package/lib/tuya.js

@@ -113,6 +113,116 @@ function logUnexpectedDataValue(where, msg, dpValue, meta, valueKind, expectedMi
     }
 }
 
+function convertRawToCycleTimer(value) {
+    let timernr = 0;
+    let starttime = '00:00';
+    let endtime = '00:00';
+    let irrigationDuration = 0;
+    let pauseDuration = 0;
+    let weekdays = 'once';
+    let timeractive = 0;
+    if (value.length > 11) {
+        timernr = value[1];
+        timeractive = value[2];
+        if (value[3] > 0) {
+            weekdays = (value[3] & 0x40 ? 'Mo' : '') +
+            (value[3] & 0x20 ? 'Tu' : '') +
+            (value[3] & 0x10 ? 'We' : '') +
+            (value[3] & 0x08 ? 'Th' : '') +
+            (value[3] & 0x04 ? 'Fr' : '') +
+            (value[3] & 0x02 ? 'Sa' : '') +
+            (value[3] & 0x01 ? 'Su' : '');
+        } else {
+            weekdays = 'once';
+        }
+        let minsincemidnight = value[4] * 256 + value[5];
+        starttime = String(parseInt(minsincemidnight / 60)).padStart(2, '0') + ':' + String(minsincemidnight % 60).padStart(2, '0');
+        minsincemidnight = value[6] * 256 + value[7];
+        endtime = String(parseInt(minsincemidnight / 60)).padStart(2, '0') + ':' + String(minsincemidnight % 60).padStart(2, '0');
+        irrigationDuration = value[8] * 256 + value[9];
+        pauseDuration = value[10] * 256 + value[11];
+    }
+    return {
+        timernr: timernr,
+        starttime: starttime,
+        endtime: endtime,
+        irrigationDuration: irrigationDuration,
+        pauseDuration: pauseDuration,
+        weekdays: weekdays,
+        active: timeractive,
+    };
+}
+
+function convertRawToTimer(value) {
+    let timernr = 0;
+    let starttime = '00:00';
+    let duration = 0;
+    let weekdays = 'once';
+    let timeractive = '';
+    if (value.length > 12) {
+        timernr = value[1];
+        const minsincemidnight = value[2] * 256 + value[3];
+        starttime = String(parseInt(minsincemidnight / 60)).padStart(2, '0') + ':' + String(minsincemidnight % 60).padStart(2, '0');
+        duration = value[4] * 256 + value[5];
+        if (value[6] > 0) {
+            weekdays = (value[6] & 0x40 ? 'Mo' : '') +
+            (value[6] & 0x20 ? 'Tu' : '') +
+            (value[6] & 0x10 ? 'We' : '') +
+            (value[6] & 0x08 ? 'Th' : '') +
+            (value[6] & 0x04 ? 'Fr' : '') +
+            (value[6] & 0x02 ? 'Sa' : '') +
+            (value[6] & 0x01 ? 'Su' : '');
+        } else {
+            weekdays = 'once';
+        }
+        timeractive = value[8];
+    }
+    return {timernr: timernr, time: starttime, duration: duration, weekdays: weekdays, active: timeractive};
+}
+
+function convertTimeTo2ByteHexArray(time) {
+    const timeArray = time.split(':');
+    if (timeArray.length != 2) {
+        throw new Error('Time format incorrect');
+    }
+    const timeHour = parseInt(timeArray[0]);
+    const timeMinute = parseInt(timeArray[1]);
+
+    if (timeHour > 23 || timeMinute > 59) {
+        throw new Error('Time incorrect');
+    }
+    return convertDecimalValueTo2ByteHexArray(timeHour * 60 + timeMinute);
+}
+
+function convertWeekdaysTo1ByteHexArray(weekdays) {
+    let nr = 0;
+    if (weekdays == 'once') {
+        return nr;
+    }
+    if (weekdays.includes('Mo')) {
+        nr |= 0x40;
+    }
+    if (weekdays.includes('Tu')) {
+        nr |= 0x20;
+    }
+    if (weekdays.includes('We')) {
+        nr |= 0x10;
+    }
+    if (weekdays.includes('Th')) {
+        nr |= 0x08;
+    }
+    if (weekdays.includes('Fr')) {
+        nr |= 0x04;
+    }
+    if (weekdays.includes('Sa')) {
+        nr |= 0x02;
+    }
+    if (weekdays.includes('Su')) {
+        nr |= 0x01;
+    }
+    return [nr];
+}
+
 function convertDecimalValueTo4ByteHexArray(value) {
     const hexValue = Number(value).toString(16).padStart(8, '0');
     const chunk1 = hexValue.substr(0, 2);
@@ -1039,6 +1149,10 @@ module.exports = {
     dpValueFromStringBuffer,
     dpValueFromRaw,
     dpValueFromBitmap,
+    convertRawToCycleTimer,
+    convertRawToTimer,
+    convertTimeTo2ByteHexArray,
+    convertWeekdaysTo1ByteHexArray,
     convertDecimalValueTo4ByteHexArray,
     convertDecimalValueTo2ByteHexArray,
     onEventSetTime,

package/package.json

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