@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/vrey.js

@@ -0,0 +1,18 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        fingerprint: [
+            {modelID: 'TS0001', manufacturerName: '_TYZB01_reyozfcg'},
+            {modelID: 'TS0001', manufacturerName: '_TYZB01_4vgantdz'},
+        ],
+        model: 'VR-X701U',
+        vendor: 'Vrey',
+        description: '1 gang switch',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+];

package/devices/wally.js

@@ -0,0 +1,25 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['MultiSensor'],
+        model: 'U02I007C.01',
+        vendor: 'Wally',
+        description: 'WallyHome multi-sensor',
+        fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.temperature, fz.humidity, fz.U02I007C01_contact,
+            fz.U02I007C01_water_leak],
+        exposes: [e.battery(), e.temperature(), e.humidity(), e.action(['on', 'off']), e.contact(), e.water_leak()],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genPowerCfg', 'genOnOff', 'msTemperatureMeasurement', 'msRelativeHumidity'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.temperature(endpoint);
+            await reporting.humidity(endpoint);
+        },
+    },
+];

package/devices/waxman.js

@@ -0,0 +1,45 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['leakSMART Water Sensor V2'],
+        model: '8840100H',
+        vendor: 'Waxman',
+        description: 'leakSMART water sensor v2',
+        fromZigbee: [fz._8840100H_water_leak_alarm, fz.temperature, fz.battery],
+        toZigbee: [],
+        exposes: [e.battery(), e.temperature(), e.water_leak()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'haApplianceEventsAlerts', 'msTemperatureMeasurement']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.temperature(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['House Water Valve - MDL-TBD', 'leakSMART Water Valve v2.10'],
+        // Should work with all manufacturer model numbers for the 2.0 series:
+        // 8850000 3/4"
+        // 8850100 1"
+        // 8850200 1-1/4"
+        // 8850300 1-1/2"
+        // 8850310 2"
+        model: '8850100',
+        vendor: 'Waxman',
+        description: 'leakSMART automatic water shut-off valve 2.0',
+        fromZigbee: [fz.battery, fz.on_off],
+        toZigbee: [tz.on_off],
+        exposes: [e.battery(), e.switch()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'haApplianceEventsAlerts', 'genOnOff']);
+            await reporting.onOff(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+    },
+];

package/devices/weiser.js

@@ -0,0 +1,67 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const constants = require('../lib/constants');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['SMARTCODE_DEADBOLT_10'],
+        model: '9GED18000-009',
+        vendor: 'Weiser',
+        description: 'SmartCode 10',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        // Note - Keypad triggered deletions do not cause a zigbee event, though Adds work fine.
+        onEvent: async (type, data, device) => {
+            // When we receive a code updated message, lets read the new value
+            if (data.type === 'commandProgrammingEventNotification' &&
+                data.cluster === 'closuresDoorLock' &&
+                data.data &&
+                data.data.userid !== undefined &&
+                // Don't read RF events, we can do this with retrieve_state
+                (data.data.programeventsrc === undefined || constants.lockSourceName[data.data.programeventsrc] != 'rf')
+            ) {
+                await device.endpoints[0].command('closuresDoorLock', 'getPinCode', {userid: data.data.userid}, {});
+            }
+        },
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+    {
+        zigbeeModel: ['SMARTCODE_DEADBOLT_10T'],
+        model: '9GED21500-005',
+        vendor: 'Weiser',
+        description: 'SmartCode 10 Touch',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        // Note - Keypad triggered deletions do not cause a zigbee event, though Adds work fine.
+        onEvent: async (type, data, device) => {
+            // When we receive a code updated message, lets read the new value
+            if (data.type === 'commandProgrammingEventNotification' &&
+                data.cluster === 'closuresDoorLock' &&
+                data.data &&
+                data.data.userid !== undefined &&
+                // Don't read RF events, we can do this with retrieve_state
+                (data.data.programeventsrc === undefined || constants.lockSourceName[data.data.programeventsrc] != 'rf')
+            ) {
+                await device.endpoints[0].command('closuresDoorLock', 'getPinCode', {userid: data.data.userid}, {});
+            }
+        },
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+    },
+];

package/devices/weten.js

@@ -0,0 +1,13 @@
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0001', manufacturerName: '_TZ3000_wrhhi5h2'}],
+        model: '1GNNTS',
+        vendor: 'WETEN',
+        description: '1 gang no neutral touch wall switch',
+        extend: extend.switch(),
+        fromZigbee: [fz.on_off, fz.ignore_basic_report, fz.ignore_time_read],
+    },
+];

package/devices/wisdom.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['HK-DIM-SW'],
+        model: 'DMZ250',
+        vendor: 'Wisdom',
+        description: 'Zigbee led dimmer 5-250 Watt',
+        extend: extend.light_onoff_brightness(),
+    },
+];

package/devices/woox.js

@@ -0,0 +1,177 @@
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const tuya = require('../lib/tuya');
+const e = exposes.presets;
+const ea = exposes.access;
+
+const fzLocal = {
+    R7049_status: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            for (const dpValue of msg.data.dpValues) {
+                const dp = dpValue.dp; // First we get the data point ID
+                const value = tuya.getDataValue(dpValue); // This function will take care of converting the data to proper JS type
+                switch (dp) {
+                case 1:
+                    result.smoke = Boolean(!value);
+                    break;
+                case 8:
+                    result.test_alarm = value;
+                    break;
+                case 9: {
+                    const testAlarmResult = {0: 'checking', 1: 'check_success', 2: 'check_failure', 3: 'others'};
+                    result.test_alarm_result = testAlarmResult[value];
+                    break;
+                }
+                case 11:
+                    result.fault_alarm = Boolean(value);
+                    break;
+                case 14: {
+                    const batteryLevels = {0: 'low', 1: 'middle', 2: 'high'};
+                    result.battery_level = batteryLevels[value];
+                    result.battery_low = value === 0;
+                    break;
+                }
+                case 16:
+                    result.silence_siren = value;
+                    break;
+                case 20: {
+                    const alarm = {0: true, 1: false};
+                    result.alarm = alarm[value];
+                    break;
+                }
+                default:
+                    meta.logger.warn(`zigbee-herdsman-converters:Woox Smoke Detector: NOT RECOGNIZED DP #${
+                        dp} with data ${JSON.stringify(dpValue)}`);
+                }
+            }
+            return result;
+        },
+    },
+    woox_R7060: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandActiveStatusReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'woox_R7060');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+
+            switch (dp) {
+            case tuya.dataPoints.wooxSwitch:
+                return {state: value === 2 ? 'OFF' : 'ON'};
+            case 101:
+                return {battery: value};
+            default:
+                meta.logger.warn(`zigbee-herdsman-converters:WooxR7060: Unrecognized DP #${
+                    dp} with data ${JSON.stringify(dpValue)}`);
+            }
+        },
+    },
+};
+
+const tzLocal = {
+    R7049_silenceSiren: {
+        key: ['silence_siren'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointBool(entity, 16, value);
+        },
+    },
+    R7049_testAlarm: {
+        key: ['test_alarm'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointBool(entity, 8, value);
+        },
+    },
+    R7049_alarm: {
+        key: ['alarm'],
+        convertSet: async (entity, key, value, meta) => {
+            const linkAlarm = {true: 0, false: 1};
+            await tuya.sendDataPointEnum(entity, 20, linkAlarm[value]);
+        },
+    },
+};
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0101', manufacturerName: '_TZ3210_eymunffl'}],
+        model: 'R7060',
+        vendor: 'Woox',
+        description: 'Smart garden irrigation control',
+        fromZigbee: [fz.on_off, fz.ignore_tuya_set_time, fz.ignore_basic_report, fzLocal.woox_R7060],
+        toZigbee: [tz.on_off],
+        onEvent: tuya.onEventSetTime,
+        exposes: [e.switch(), e.battery()],
+        meta: {disableDefaultResponse: true},
+        configure: tuya.configureMagicPacket,
+    },
+    {
+        fingerprint: [{modelID: 'TS0505A', manufacturerName: '_TZ3000_keabpigv'}],
+        model: 'R9077',
+        vendor: 'Woox',
+        description: 'RGB+CCT LED',
+        extend: tuya.extend.light_onoff_brightness_colortemp_color(),
+        meta: {applyRedFix: true},
+    },
+    {
+        fingerprint: [{modelID: 'TS0201', manufacturerName: '_TZ3000_rusu2vzb'}],
+        model: 'R7048',
+        vendor: 'Woox',
+        description: 'Smart humidity & temperature sensor',
+        fromZigbee: [fz.battery, fz.temperature, fz.humidity],
+        toZigbee: [],
+        exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const bindClusters = ['msTemperatureMeasurement', 'msRelativeHumidity', 'genPowerCfg'];
+            await reporting.bind(endpoint, coordinatorEndpoint, bindClusters);
+            await reporting.temperature(endpoint);
+            await reporting.humidity(endpoint);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_aycxwiau'}],
+        model: 'R7049',
+        vendor: 'Woox',
+        description: 'Smart smoke alarm',
+        meta: {timeout: 30000, disableDefaultResponse: true},
+        fromZigbee: [fzLocal.R7049_status, fz.ignore_tuya_set_time, fz.ignore_time_read],
+        toZigbee: [tzLocal.R7049_silenceSiren, tzLocal.R7049_testAlarm, tzLocal.R7049_alarm],
+        exposes: [e.battery_low(),
+            exposes.binary('smoke', ea.STATE, true, false).withDescription('Smoke alarm status'),
+            exposes.binary('test_alarm', ea.STATE_SET, true, false).withDescription('Test alarm'),
+            exposes.enum('test_alarm_result', ea.STATE, ['checking', 'check_success', 'check_failure', 'others'])
+                .withDescription('Test alarm result'),
+            exposes.enum('battery_level', ea.STATE, ['low', 'middle', 'high']).withDescription('Battery level state'),
+            exposes.binary('alarm', ea.STATE_SET, true, false).withDescription('Alarm enable'),
+            exposes.binary('fault_alarm', ea.STATE, true, false).withDescription('Fault alarm status'),
+            exposes.binary('silence_siren', ea.STATE_SET, true, false).withDescription('Silence siren')],
+        onEvent: tuya.onEventsetTime,
+    },
+    {
+        fingerprint: [{modelID: 'TS0219', manufacturerName: '_TYZB01_ynsiasng'}, {modelID: 'TS0219', manufacturerName: '_TYZB01_bwsijaty'},
+            {modelID: 'TS0219', manufacturerName: '_TYZB01_rs7ff6o7'}],
+        model: 'R7051',
+        vendor: 'Woox',
+        description: 'Smart siren',
+        fromZigbee: [fz.battery, fz.ts0216_siren, fz.ias_alarm_only_alarm_1, fz.power_source],
+        toZigbee: [tz.warning, tz.ts0216_volume, tz.ts0216_duration],
+        exposes: [e.battery(), e.battery_voltage(), e.warning(), exposes.binary('alarm', ea.STATE, true, false),
+            exposes.binary('ac_connected', ea.STATE, true, false).withDescription('Is the device plugged in'),
+            exposes.numeric('volume', ea.ALL).withValueMin(0).withValueMax(100).withDescription('Volume of siren'),
+            exposes.numeric('duration', ea.ALL).withValueMin(0).withValueMax(3600).withDescription('Duration of siren')],
+        meta: {disableDefaultResponse: true},
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            const bindClusters = ['genPowerCfg'];
+            await reporting.bind(endpoint, coordinatorEndpoint, bindClusters);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+];

package/devices/wyze.js

@@ -0,0 +1,23 @@
+const exposes = require('../lib/exposes');
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['Ford'],
+        model: 'WLCKG1',
+        vendor: 'Wyze',
+        description: 'Lock',
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
+        toZigbee: [tz.lock],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.endpoints[0];
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.lock(), e.battery()],
+    },
+];