@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/feibit.js

@@ -0,0 +1,172 @@
+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 extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['FZB56+ZSW2FYM1.1'],
+        model: 'TZSW22FW-L4',
+        vendor: 'Feibit',
+        description: 'Smart light switch - 2 gang',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('top'), e.switch().withEndpoint('bottom')],
+        endpoint: (device) => {
+            return {'top': 16, 'bottom': 17};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(16), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(17), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+    {
+        zigbeeModel: ['FB56+ZSW1GKJ2.3'],
+        model: 'SKY01-TS1-101',
+        vendor: 'Feibit',
+        description: 'Smart light switch - 1 gang',
+        extend: extend.switch(),
+    },
+    {
+        zigbeeModel: ['FNB56-SOS03FB1.5'],
+        model: 'SEB01ZB',
+        vendor: 'Feibit',
+        description: 'SOS button',
+        fromZigbee: [fz.ias_sos_alarm_2, fz.battery],
+        toZigbee: [],
+        exposes: [e.sos(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['FNB56-BOT06FB2.3', 'FNB56-BOT06FB2.8', 'FB56-BOT02HM1.2', 'FNB56-BOT06FB2.8'],
+        model: 'SBM01ZB',
+        vendor: 'Feibit',
+        description: 'Human body movement sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.batteryAlarmState(endpoint);
+        },
+        exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['FNB56-THM14FB2.4', 'FNB54-THM17ML1.1', 'FB56-THM12HM1.2', 'FNB56-THM14FB2.5'],
+        model: 'STH01ZB',
+        vendor: 'Feibit',
+        description: 'Smart temperature & humidity Sensor',
+        fromZigbee: [fz.temperature, fz.humidity, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        exposes: [e.temperature(), e.humidity(), e.battery()],
+    },
+    {
+        zigbeeModel: ['FNB56-SMF06FB1.6', 'FNB56-SMF06FB2.0'],
+        model: 'SSA01ZB',
+        vendor: 'Feibit',
+        description: 'Smoke detector',
+        fromZigbee: [fz.ias_smoke_alarm_1, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.batteryAlarmState(endpoint);
+        },
+        exposes: [e.smoke(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['FNB56-COS06FB1.7', 'FNB56-COS06FB2.1'],
+        model: 'SCA01ZB',
+        vendor: 'Feibit',
+        description: 'Smart carbon monoxide sensor',
+        fromZigbee: [fz.ias_carbon_monoxide_alarm_1, fz.battery],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.batteryAlarmState(endpoint);
+        },
+        exposes: [e.carbon_monoxide(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['FNB56-GAS05FB1.4', 'FNB56-GAS05FB1.8'],
+        model: 'SGA01ZB',
+        vendor: 'Feibit',
+        description: 'Combustible gas sensor',
+        fromZigbee: [fz.ias_gas_alarm_2],
+        toZigbee: [],
+        exposes: [e.gas()],
+    },
+    {
+        zigbeeModel: ['FNB56-WTS05FB2.0', 'FNB56-WTS05FB2.4'],
+        model: 'SWA01ZB',
+        vendor: 'Feibit',
+        description: 'Water leakage sensor',
+        fromZigbee: [fz.ias_water_leak_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.water_leak(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['FNB56-DOS07FB2.4', 'FB56-DOS02HM1.2'],
+        model: 'SDM01ZB',
+        vendor: 'Feibit',
+        description: 'Door or window contact switch',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.battery()],
+    },
+    {
+        zigbeeModel: ['FB56+SKT14AL2.1', 'FTB56+SKT1BCW1.0'],
+        model: 'SFS01ZB',
+        vendor: 'Feibit',
+        description: 'Power plug',
+        extend: extend.switch(),
+    },
+    {
+        zigbeeModel: ['FB56+ZSW1HKJ2.2', 'FB56+ZSW1HKJ1.1'],
+        model: 'SLS301ZB_2',
+        vendor: 'Feibit',
+        description: 'Smart light switch - 2 gang',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right')],
+        endpoint: (device) => {
+            return {'left': 16, 'right': 17};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(16), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(17), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+    {
+        zigbeeModel: ['FB56+ZSW1IKJ2.2', 'FB56+ZSW1IKJ1.1'],
+        model: 'SLS301ZB_3',
+        vendor: 'Feibit',
+        description: 'Smart light switch - 3 gang',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right'), e.switch().withEndpoint('center')],
+        endpoint: (device) => {
+            return {'left': 16, 'center': 17, 'right': 18};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(16), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(17), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(18), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+    {
+        zigbeeModel: ['FB56+ZSN08KJ2.2'],
+        model: 'SSS401ZB',
+        vendor: 'Feibit',
+        description: 'Smart 4 key scene wall switch',
+        toZigbee: [tz.on_off],
+        fromZigbee: [fz.command_recall],
+        exposes: [e.action(['recall_*']), e.switch()],
+    },
+];

package/devices/fireangel.js

@@ -0,0 +1,15 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['Alarm_SD_Device'],
+        model: 'W2-Module',
+        description: 'Carbon monoxide sensor',
+        vendor: 'FireAngel',
+        fromZigbee: [fz.W2_module_carbon_monoxide, fz.battery],
+        toZigbee: [],
+        exposes: [e.carbon_monoxide(), e.battery()],
+    },
+];

package/devices/frankever.js

@@ -0,0 +1,23 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const e = exposes.presets;
+const ea = exposes.access;
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_wt9agwf3'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_5uodvhgc'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_1n2zev06'}],
+        model: 'FK_V02',
+        vendor: 'FrankEver',
+        description: 'Zigbee smart water valve',
+        fromZigbee: [fz.frankever_valve],
+        toZigbee: [tz.tuya_switch_state, tz.frankever_threshold, tz.frankever_timer],
+        exposes: [e.switch().setAccess('state', ea.STATE_SET),
+            exposes.numeric('threshold', exposes.access.STATE_SET).withValueMin(0).withValueMax(100).withUnit('%')
+                .withDescription('Valve open percentage (multiple of 10)'),
+            exposes.numeric('timer', exposes.access.STATE_SET).withValueMin(0).withValueMax(600).withUnit('min')
+                .withDescription('Countdown timer in minutes')],
+    },
+];

package/devices/garza.js

@@ -0,0 +1,11 @@
+const tuya = require('../lib/tuya');
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_sln7ah6r'}],
+        model: 'Garza-Standard-A60',
+        vendor: 'Garza Smart',
+        description: 'Standard A60 bulb',
+        extend: tuya.extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+    },
+];

package/devices/ge.js

@@ -0,0 +1,111 @@
+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 extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['SoftWhite'],
+        model: 'PSB19-SW27',
+        vendor: 'GE',
+        description: 'Link smart LED light bulb, A19 soft white (2700K)',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['ZLL Light'],
+        model: '22670',
+        vendor: 'GE',
+        description: 'Link smart LED light bulb, A19/BR30 soft white (2700K)',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['Daylight'],
+        model: 'PQC19-DY01',
+        vendor: 'GE',
+        description: 'Link smart LED light bulb, A19/BR30 cold white (5000K)',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['45852'],
+        model: '45852GE',
+        vendor: 'GE',
+        description: 'ZigBee plug-in smart dimmer',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['45853'],
+        model: '45853GE',
+        vendor: 'GE',
+        description: 'Plug-in smart switch',
+        fromZigbee: [fz.on_off, fz.metering, fz.ignore_basic_report],
+        toZigbee: [tz.on_off, tz.ignore_transition],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.instantaneousDemand(endpoint, {min: 10, change: 2});
+        },
+        exposes: [e.switch(), e.power(), e.energy()],
+    },
+    {
+        zigbeeModel: ['45856'],
+        model: '45856GE',
+        vendor: 'GE',
+        description: 'In-wall smart switch',
+        fromZigbee: [fz.on_off, fz.metering],
+        toZigbee: [tz.on_off],
+        exposes: [e.switch(), e.energy(), e.power()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 10000, multiplier: 1});
+        },
+    },
+    {
+        zigbeeModel: ['45857'],
+        model: '45857GE',
+        vendor: 'GE',
+        description: 'ZigBee in-wall smart dimmer',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['Smart Switch'],
+        model: 'PTAPT-WH02',
+        vendor: 'GE',
+        description: 'Quirky smart switch',
+        extend: extend.switch(),
+        endpoint: (device) => {
+            return {'default': 2};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZHA Smart Plug'],
+        model: 'POTLK-WH02',
+        vendor: 'GE',
+        description: 'Outlink smart remote outlet',
+        extend: extend.switch(),
+    },
+];

package/devices/gewiss.js

@@ -0,0 +1,48 @@
+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 extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['GWA1521_Actuator_1_CH_PF'],
+        model: 'GWA1521',
+        description: 'Switch actuator 1 channel with input',
+        vendor: 'Gewiss',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['GWA1522_Actuator_2_CH'],
+        model: 'GWA1522',
+        description: 'Switch actuator 2 channels with input',
+        vendor: 'Gewiss',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2')],
+        meta: {multiEndpoint: true},
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 2};
+        },
+    },
+    {
+        zigbeeModel: ['GWA1531_Shutter'],
+        model: 'GWA1531',
+        description: 'Shutter actuator',
+        vendor: 'Gewiss',
+        fromZigbee: [fz.cover_position_tilt, fz.ignore_basic_report],
+        toZigbee: [tz.cover_state, tz.cover_position_tilt],
+        meta: {coverInverted: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresWindowCovering']);
+            await reporting.currentPositionLiftPercentage(endpoint);
+        },
+        exposes: [e.cover_position()],
+    },
+];

package/devices/gidealed.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['A11'],
+        model: 'ZC05M',
+        vendor: 'GIDEALED',
+        description: 'Smart Zigbee RGB LED strip controller',
+        extend: extend.light_onoff_brightness_colortemp_color({supportsHS: true, colorTempRange: [153, 370]}),
+    },
+];

package/devices/giderwel.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['A10'],
+        model: 'GD-ZCRGB012',
+        vendor: 'GIDERWEL',
+        description: 'Smart Zigbee RGB LED strip controller',
+        extend: extend.light_onoff_brightness_color({supportsHS: false}),
+    },
+];

package/devices/giex.js

@@ -0,0 +1,222 @@
+const exposes = require('../lib/exposes');
+const tuya = require('../lib/tuya');
+
+const {presets: ep, access: ea} = exposes;
+
+const CAPACITY = 'capacity';
+const DURATION = 'duration';
+const MINUTES_IN_A_DAY = 1440;
+const OFF = 'OFF';
+const ON = 'ON';
+const SAFETY_MIN_SECS = 10;
+const SECONDS_IN_12_HOURS = 43200;
+
+const toLocalTime = (time, timezone) => {
+    if (time === '--:--:--') {
+        return time;
+    }
+
+    const local = new Date(`2000-01-01T${time}.000${timezone}`); // Using 1970 instead produces edge cases
+    return local.toTimeString().split(' ').shift();
+};
+
+const keys = {
+    giexWaterValve: {
+        battery: 'battery',
+        currentTemperature: 'current_temperature',
+        cycleIrrigationInterval: 'cycle_irrigation_interval',
+        cycleIrrigationNumTimes: 'cycle_irrigation_num_times',
+        irrigationEndTime: 'irrigation_end_time',
+        irrigationStartTime: 'irrigation_start_time',
+        irrigationTarget: 'irrigation_target',
+        lastIrrigationDuration: 'last_irrigation_duration',
+        mode: 'mode',
+        state: 'state',
+        waterConsumed: 'water_consumed',
+    },
+};
+
+const dataPoints = {
+    giexWaterValve: {
+        battery: 108,
+        currentTemperature: 106,
+        cycleIrrigationInterval: 105,
+        cycleIrrigationNumTimes: 103,
+        irrigationEndTime: 102,
+        irrigationStartTime: 101,
+        irrigationTarget: 104,
+        lastIrrigationDuration: 114,
+        mode: 1,
+        state: 2,
+        waterConsumed: 111,
+    },
+};
+
+const fzModelConverters = {
+    QT06_1: {
+        // _TZE200_sh1btabb timezone is GMT+8
+        time: (value) => toLocalTime(value, '+08:00'),
+    },
+};
+
+const fzLocal = {
+    giexWaterValve: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const modelConverters = fzModelConverters[model.model] || {};
+            for (const dpValue of msg.data.dpValues) {
+                const value = tuya.getDataValue(dpValue);
+                const {dp} = dpValue;
+                switch (dp) {
+                case dataPoints.giexWaterValve.state:
+                    return {[keys.giexWaterValve.state]: value ? ON: OFF};
+                case dataPoints.giexWaterValve.mode:
+                    return {[keys.giexWaterValve.mode]: value ? CAPACITY: DURATION};
+                case dataPoints.giexWaterValve.irrigationTarget:
+                    return {[keys.giexWaterValve.irrigationTarget]: value};
+                case dataPoints.giexWaterValve.cycleIrrigationNumTimes:
+                    return {[keys.giexWaterValve.cycleIrrigationNumTimes]: value};
+                case dataPoints.giexWaterValve.cycleIrrigationInterval:
+                    return {[keys.giexWaterValve.cycleIrrigationInterval]: value};
+                case dataPoints.giexWaterValve.waterConsumed:
+                    return {[keys.giexWaterValve.waterConsumed]: value};
+                case dataPoints.giexWaterValve.irrigationStartTime:
+                    return {[keys.giexWaterValve.irrigationStartTime]: modelConverters.time?.(value) || value};
+                case dataPoints.giexWaterValve.irrigationEndTime:
+                    return {[keys.giexWaterValve.irrigationEndTime]: modelConverters.time?.(value) || value};
+                case dataPoints.giexWaterValve.lastIrrigationDuration:
+                    return {[keys.giexWaterValve.lastIrrigationDuration]: value.split(',').shift()}; // Remove meaningless ,0 suffix
+                case dataPoints.giexWaterValve.battery:
+                    return {[keys.giexWaterValve.battery]: value};
+                case dataPoints.giexWaterValve.currentTemperature:
+                    return; // Do Nothing - value ignored because it isn't a valid temperature reading (misdocumented and usage unclear)
+                default: // Unknown data point warning
+                    meta.logger.warn(`fzLocal.giexWaterValve: Unrecognized DP #${dp} with VALUE = ${value}`);
+                }
+            }
+        },
+    },
+};
+
+const tzModelConverters = {
+    QT06_2: {
+        // _TZE200_a7sghmms irrigation time should not be less than 10 secs as per GiEX advice
+        irrigationTarget: (value, mode) => value > 0 && value < SAFETY_MIN_SECS && mode === DURATION ? SAFETY_MIN_SECS : value,
+    },
+};
+
+const tzLocal = {
+    giexWaterValve:
+    {
+        key: [
+            keys.giexWaterValve.mode,
+            keys.giexWaterValve.irrigationTarget,
+            keys.giexWaterValve.state,
+            keys.giexWaterValve.cycleIrrigationNumTimes,
+            keys.giexWaterValve.cycleIrrigationInterval,
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            const modelConverters = tzModelConverters[meta.mapped?.model] || {};
+            switch (key) {
+            case keys.giexWaterValve.state:
+                await tuya.sendDataPointBool(entity, dataPoints.giexWaterValve.state, value === ON);
+                break;
+            case keys.giexWaterValve.mode:
+                await tuya.sendDataPointBool(entity, dataPoints.giexWaterValve.mode, value === CAPACITY);
+                return {state: {[keys.giexWaterValve.mode]: value}};
+            case keys.giexWaterValve.irrigationTarget: {
+                const mode = meta.state?.[keys.giexWaterValve.mode];
+                const sanitizedValue = modelConverters.irrigationTarget?.(value, mode) || value;
+                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValve.irrigationTarget, sanitizedValue);
+                return {state: {[keys.giexWaterValve.irrigationTarget]: sanitizedValue}};
+            }
+            case keys.giexWaterValve.cycleIrrigationNumTimes:
+                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValve.cycleIrrigationNumTimes, value);
+                return {state: {[keys.giexWaterValve.cycleIrrigationNumTimes]: value}};
+            case keys.giexWaterValve.cycleIrrigationInterval:
+                await tuya.sendDataPointValue(entity, dataPoints.giexWaterValve.cycleIrrigationInterval, value);
+                return {state: {[keys.giexWaterValve.cycleIrrigationInterval]: value}};
+            default: // Unknown key warning
+                meta.logger.warn(`tzLocal.giexWaterValve: Unhandled KEY ${key}`);
+            }
+        },
+    },
+};
+
+const exportTemplates = {
+    giexWaterValve: {
+        vendor: 'GiEX',
+        description: 'Water irrigation valve',
+        onEvent: tuya.onEventSetLocalTime,
+        fromZigbee: [fzLocal.giexWaterValve],
+        toZigbee: [tzLocal.giexWaterValve],
+        exposes: [
+            ep.battery(),
+            exposes.binary(keys.giexWaterValve.state, ea.STATE_SET, ON, OFF)
+                .withDescription('State'),
+            exposes.enum(keys.giexWaterValve.mode, ea.STATE_SET, [DURATION, CAPACITY])
+                .withDescription('Irrigation mode'),
+            exposes.numeric(keys.giexWaterValve.cycleIrrigationNumTimes, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(100)
+                .withDescription('Number of cycle irrigation times, set to 0 for single cycle'),
+            exposes.numeric(keys.giexWaterValve.irrigationStartTime, ea.STATE)
+                .withDescription('Last irrigation start time'),
+            exposes.numeric(keys.giexWaterValve.irrigationEndTime, ea.STATE)
+                .withDescription('Last irrigation end time'),
+            exposes.numeric(keys.giexWaterValve.lastIrrigationDuration, ea.STATE)
+                .withDescription('Last irrigation duration'),
+            exposes.numeric(keys.giexWaterValve.waterConsumed, ea.STATE)
+                .withUnit('L')
+                .withDescription('Last irrigation water consumption'),
+        ],
+    },
+};
+
+module.exports = [
+    // _TZE200_sh1btabb uses minutes, timezone is GMT+8
+    {
+        ...exportTemplates.giexWaterValve,
+        model: 'QT06_1',
+        fingerprint: [
+            {modelID: 'TS0601', manufacturerName: '_TZE200_sh1btabb'},
+        ],
+        exposes: [
+            ...exportTemplates.giexWaterValve.exposes,
+            exposes.numeric(keys.giexWaterValve.irrigationTarget, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(MINUTES_IN_A_DAY)
+                .withUnit('minutes or litres')
+                .withDescription('Irrigation target, duration in minutes or capacity in litres (depending on mode)'),
+            exposes.numeric(keys.giexWaterValve.cycleIrrigationInterval, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(MINUTES_IN_A_DAY)
+                .withUnit('min')
+                .withDescription('Cycle irrigation interval'),
+        ],
+    },
+    // _TZE200_a7sghmms uses seconds, timezone is local
+    {
+        ...exportTemplates.giexWaterValve,
+        model: 'QT06_2',
+        fingerprint: [
+            {modelID: 'TS0601', manufacturerName: '_TZE200_a7sghmms'},
+        ],
+        exposes: [
+            ...exportTemplates.giexWaterValve.exposes,
+            exposes.numeric(keys.giexWaterValve.irrigationTarget, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(SECONDS_IN_12_HOURS)
+                .withUnit('seconds or litres')
+                .withDescription('Irrigation target, duration in seconds or capacity in litres (depending on mode), ' +
+                    'set to 0 to leave the valve on indefinitely, ' +
+                    'for safety reasons the target will be forced to a minimum of 10 seconds in duration mode'),
+            exposes.numeric(keys.giexWaterValve.cycleIrrigationInterval, ea.STATE_SET)
+                .withValueMin(0)
+                .withValueMax(SECONDS_IN_12_HOURS)
+                .withUnit('sec')
+                .withDescription('Cycle irrigation interval'),
+        ],
+    },
+];

package/devices/girier.js

@@ -0,0 +1,19 @@
+const tuya = require('../lib/tuya');
+const reporting = require('../lib/reporting');
+
+module.exports = [
+    {
+        fingerprint: [
+            {modelID: 'TS0001', manufacturerName: '_TZ3000_majwnphg'},
+            {modelID: 'TS0001', manufacturerName: '_TZ3000_6axxqqi2'},
+            {modelID: 'TS0001', manufacturerName: '_TZ3000_zw7yf6yk'},
+        ],
+        model: 'JR-ZDS01',
+        vendor: 'Girier',
+        description: '1 gang mini switch',
+        extend: tuya.extend.switch({switchType: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+];