homebridge-tuya-plus 3.13.0 → 3.13.1-dev.1

package/lib/IrrigationSystemAccessory.js

@@ -0,0 +1,611 @@
+const BaseAccessory = require('./BaseAccessory');
+
+/**
+ * IrrigationSystemAccessory
+ *
+ * A fully-fledged HomeKit irrigation controller for Tuya multi-valve devices
+ * (e.g. the 4-zone faucet/valve timers that expose `switch_1..switch_n`, a
+ * `battery_percentage` and a `rain_sensor_state`).
+ *
+ * HomeKit modelling (one bridged accessory, category SPRINKLER):
+ *
+ *   IrrigationSystem  (primary service — the "system" tile + master on/off)
+ *     ├─ Valve  "Zone A"   (linked, ValveType=IRRIGATION, ServiceLabelIndex 1)
+ *     ├─ Valve  "Zone B"   (linked, ServiceLabelIndex 2)
+ *     ├─ ...
+ *   Battery            (BatteryLevel + StatusLowBattery)
+ *   ContactSensor      (rain — or LeakSensor, configurable)
+ *
+ * Each Valve carries its own SetDuration/RemainingDuration so the Home app shows
+ * the familiar per-zone "Duration" picker and a live countdown. A zone whose
+ * duration is 0 runs indefinitely (until it is turned off again) — handy for
+ * long manual watering tasks. All writes are coalesced into a single Tuya
+ * command (the device is a laggy, battery-powered Wi-Fi unit), so turning the
+ * whole system on/off — or running a scene that toggles several zones at once —
+ * results in one network round-trip rather than a burst of them.
+ */
+class IrrigationSystemAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.SPRINKLER;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Configuration helpers
+     * ------------------------------------------------------------------ */
+
+    // Resolve the list of valves/zones from the device config. Defaults to the
+    // 4-zone A/B/C/D layout of the reference device (switch_1..switch_4 on
+    // DP 1..4). A `valves` array lets non-sequential / custom devices map their
+    // own data-points and names.
+    _getValveConfigs() {
+        // Self-contained (no reliance on instance state) so it is safe to call
+        // both during early service reconciliation and later when wiring
+        // characteristics.
+        const defaultDuration = isFinite(this.device.context.defaultDuration) ? parseInt(this.device.context.defaultDuration) : 600;
+
+        if (Array.isArray(this.device.context.valves) && this.device.context.valves.length) {
+            return this.device.context.valves.map((valve, i) => {
+                if (!valve || !isFinite(valve.dp) || parseInt(valve.dp) <= 0) {
+                    throw new Error(`The valve definition #${i + 1} is missing a valid 'dp': ${JSON.stringify(valve)}`);
+                }
+                return {
+                    dp: String(parseInt(valve.dp)),
+                    name: (('' + (valve.name || '')).trim()) || ('Zone ' + (i + 1)),
+                    index: i + 1,
+                    duration: isFinite(valve.defaultDuration) ? parseInt(valve.defaultDuration) : defaultDuration
+                };
+            });
+        }
+
+        const count = Math.max(1, parseInt(this.device.context.valveCount) || 4);
+        const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        const configs = [];
+        for (let i = 0; i < count; i++) {
+            configs.push({
+                dp: String(i + 1),
+                name: 'Valve ' + (letters[i] || (i + 1)),
+                index: i + 1,
+                duration: defaultDuration
+            });
+        }
+        return configs;
+    }
+
+    _hasBattery() {
+        return !this._coerceBoolean(this.device.context.noBattery, false);
+    }
+
+    _hasRainSensor() {
+        return !this._coerceBoolean(this.device.context.noRainSensor, false);
+    }
+
+    _usesLeakSensor() {
+        return ('' + (this.device.context.rainSensorType || 'contact')).trim().toLowerCase() === 'leak';
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Service registration / cache reconciliation
+     * ------------------------------------------------------------------ */
+
+    _registerPlatformAccessory() {
+        this._verifyCachedPlatformAccessory();
+        this._justRegistered = true;
+
+        super._registerPlatformAccessory();
+    }
+
+    _verifyCachedPlatformAccessory() {
+        if (this._justRegistered) return;
+
+        const {Service, Characteristic} = this.hap;
+
+        // --- IrrigationSystem (primary) ---
+        let irrigation = this.accessory.getService(Service.IrrigationSystem);
+        if (irrigation) this._checkServiceName(irrigation, this.device.context.name);
+        else irrigation = this.accessory.addService(Service.IrrigationSystem, this.device.context.name);
+        irrigation.setPrimaryService(true);
+
+        // --- Valves (one per zone), linked to the irrigation system ---
+        const valveConfigs = this._getValveConfigs();
+        const validValveSubtypes = [];
+        valveConfigs.forEach(cfg => {
+            const subtype = 'valve-' + cfg.dp;
+            validValveSubtypes.push(subtype);
+
+            let valve = this.accessory.getServiceById(Service.Valve, subtype);
+            if (valve) this._checkServiceName(valve, cfg.name);
+            else valve = this.accessory.addService(Service.Valve, cfg.name, subtype);
+
+            // Linking is what makes the Home app nest the zones under the single
+            // irrigation tile instead of scattering them as separate tiles.
+            // addLinkedService is idempotent, so it is safe to call on every
+            // cache reconcile.
+            irrigation.addLinkedService(valve);
+        });
+
+        // --- Battery (optional) ---
+        if (this._hasBattery()) {
+            if (!this.accessory.getService(Service.Battery)) {
+                this.accessory.addService(Service.Battery, this.device.context.name + ' Battery');
+            }
+        }
+
+        // --- Rain sensor (optional): Contact (default) or Leak ---
+        if (this._hasRainSensor()) {
+            const WantedSensor = this._usesLeakSensor() ? Service.LeakSensor : Service.ContactSensor;
+            const UnwantedSensor = this._usesLeakSensor() ? Service.ContactSensor : Service.LeakSensor;
+            // Drop the other sensor type if the user switched `rainSensorType`.
+            const stale = this.accessory.getService(UnwantedSensor);
+            if (stale) this.accessory.removeService(stale);
+            if (!this.accessory.getService(WantedSensor)) {
+                this.accessory.addService(WantedSensor, this.device.context.name + ' Rain');
+            }
+        }
+
+        // --- Remove services that no longer belong (config changed) ---
+        this.accessory.services
+            .filter(service => service.UUID === Service.Valve.UUID && !validValveSubtypes.includes(service.subtype))
+            .forEach(service => {
+                this.log.info('Removing stale valve service %s', service.displayName);
+                this.accessory.removeService(service);
+            });
+
+        if (!this._hasBattery()) {
+            const battery = this.accessory.getService(Service.Battery);
+            if (battery) this.accessory.removeService(battery);
+        }
+        if (!this._hasRainSensor()) {
+            [Service.ContactSensor, Service.LeakSensor].forEach(S => {
+                const svc = this.accessory.getService(S);
+                if (svc) this.accessory.removeService(svc);
+            });
+        }
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Characteristic wiring
+     * ------------------------------------------------------------------ */
+
+    _registerCharacteristics(dps) {
+        this._verifyCachedPlatformAccessory();
+
+        const {Service, Characteristic} = this.hap;
+
+        // Tunables
+        this._defaultDuration = isFinite(this.device.context.defaultDuration) ? parseInt(this.device.context.defaultDuration) : 600;
+        // Max selectable duration. HAP's default max for SetDuration/
+        // RemainingDuration is 3600s (1h); raise it so longer runs aren't
+        // silently clamped. Apple's Home app honours the advertised maxValue.
+        this._maxDuration = isFinite(this.device.context.maxDuration) ? parseInt(this.device.context.maxDuration) : 7200;
+        this._lowBatteryThreshold = isFinite(this.device.context.lowBatteryThreshold) ? parseInt(this.device.context.lowBatteryThreshold) : 20;
+        this._debounce = isFinite(this.device.context.commandDebounce) ? parseInt(this.device.context.commandDebounce) : 500;
+        this._cascadeOn = this._coerceBoolean(this.device.context.masterTurnsOnAllZones, true);
+        this._cascadeOff = this._coerceBoolean(this.device.context.masterTurnsOffAllZones, true);
+
+        this.dpBattery = this._getCustomDP(this.device.context.dpBattery) || '46';
+        this.dpCharging = this._getCustomDP(this.device.context.dpCharging) || '101';
+        this.dpRain = this._getCustomDP(this.device.context.dpRain) || '49';
+        this._rainOnValue = ('' + (this.device.context.rainOnValue || 'rain')).trim();
+        this._rainInverted = this._coerceBoolean(this.device.context.rainInverted, false);
+
+        // Per-zone runtime state
+        this._valves = this._getValveConfigs();
+        this._timers = {};       // dp -> setTimeout handle for auto-shutoff
+        this._endTimes = {};     // dp -> ms timestamp when the run ends
+        this._pendingWrite = null;
+
+        // Persisted, user-editable per-zone durations and names.
+        this.accessory.context.durations = this.accessory.context.durations || {};
+        this.accessory.context.zoneNames = this.accessory.context.zoneNames || {};
+
+        const irrigation = this.accessory.getService(Service.IrrigationSystem);
+
+        // --- IrrigationSystem characteristics ---
+        irrigation.getCharacteristic(Characteristic.ProgramMode)
+            .updateValue(Characteristic.ProgramMode.NO_PROGRAM_SCHEDULED);
+
+        this._systemActiveChar = irrigation.getCharacteristic(Characteristic.Active)
+            .updateValue(this._anyValveOn() ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE)
+            .onGet(() => this._anyValveOn() ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE)
+            .onSet(value => this._setSystemActive(value));
+
+        this._systemInUseChar = irrigation.getCharacteristic(Characteristic.InUse)
+            .updateValue(this._anyValveOn() ? Characteristic.InUse.IN_USE : Characteristic.InUse.NOT_IN_USE);
+
+        this._systemRemainingChar = irrigation.getCharacteristic(Characteristic.RemainingDuration)
+            .setProps({maxValue: this._maxDuration})
+            .updateValue(0)
+            .onGet(() => this._systemRemaining());
+
+        // --- Valve characteristics ---
+        this._valves.forEach(cfg => {
+            const valve = this.accessory.getServiceById(Service.Valve, 'valve-' + cfg.dp);
+            const on = !!dps[cfg.dp];
+
+            valve.getCharacteristic(Characteristic.ValveType)
+                .updateValue(Characteristic.ValveType.IRRIGATION);
+            valve.getCharacteristic(Characteristic.IsConfigured)
+                .updateValue(Characteristic.IsConfigured.CONFIGURED);
+            valve.getCharacteristic(Characteristic.ServiceLabelIndex)
+                .updateValue(cfg.index);
+
+            // ConfiguredName so each zone shows its own name in the Home app
+            // (otherwise every zone inherits the accessory/system name).
+            if (Characteristic.ConfiguredName) {
+                const savedName = this.accessory.context.zoneNames[cfg.dp] || cfg.name;
+                valve.getCharacteristic(Characteristic.ConfiguredName)
+                    .updateValue(savedName)
+                    .onSet(value => { this.accessory.context.zoneNames[cfg.dp] = value; });
+            }
+
+            valve.getCharacteristic(Characteristic.SetDuration)
+                .setProps({maxValue: this._maxDuration})
+                .updateValue(this._getDuration(cfg))
+                .onGet(() => this._getDuration(cfg))
+                .onSet(value => this._setDuration(cfg, value));
+
+            valve.getCharacteristic(Characteristic.RemainingDuration)
+                .setProps({maxValue: this._maxDuration})
+                .updateValue(0)
+                .onGet(() => this._valveRemaining(cfg));
+
+            valve.getCharacteristic(Characteristic.Active)
+                .updateValue(on ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE)
+                .onGet(() => (this.getStateAsync(cfg.dp) ? 1 : 0))
+                .onSet(value => this._setValveActive(cfg, value));
+
+            valve.getCharacteristic(Characteristic.InUse)
+                .updateValue(on ? Characteristic.InUse.IN_USE : Characteristic.InUse.NOT_IN_USE);
+
+            // Reflect any zone already running at startup (e.g. turned on at the
+            // device, or Homebridge restarted mid-run) and (re)arm its timer.
+            if (on) this._reflectValve(cfg, true);
+        });
+
+        // --- Battery ---
+        if (this._hasBattery()) {
+            const battery = this.accessory.getService(Service.Battery);
+            const level = this._batteryLevel(dps[this.dpBattery]);
+            battery.getCharacteristic(Characteristic.BatteryLevel)
+                .updateValue(level)
+                .onGet(() => this._batteryLevel(this.getStateAsync(this.dpBattery)));
+            battery.getCharacteristic(Characteristic.StatusLowBattery)
+                .updateValue(this._lowBattery(level))
+                .onGet(() => this._lowBattery(this._batteryLevel(this.getStateAsync(this.dpBattery))));
+            // ChargingState follows the device's charging data-point when it
+            // reports one (solar / USB-C rechargeable units); devices that
+            // don't report charging fall back to NOT_CHARGEABLE.
+            battery.getCharacteristic(Characteristic.ChargingState)
+                .updateValue(this._chargingState(dps[this.dpCharging]))
+                .onGet(() => this._chargingState(this.getStateAsync(this.dpCharging)));
+        }
+
+        // --- Rain sensor ---
+        if (this._hasRainSensor()) {
+            if (this._usesLeakSensor()) {
+                const leak = this.accessory.getService(Service.LeakSensor);
+                leak.getCharacteristic(Characteristic.LeakDetected)
+                    .updateValue(this._rainDetected(dps[this.dpRain]) ? Characteristic.LeakDetected.LEAK_DETECTED : Characteristic.LeakDetected.LEAK_NOT_DETECTED)
+                    .onGet(() => this._rainDetected(this.getStateAsync(this.dpRain)) ? 1 : 0);
+            } else {
+                const contact = this.accessory.getService(Service.ContactSensor);
+                contact.getCharacteristic(Characteristic.ContactSensorState)
+                    .updateValue(this._contactState(dps[this.dpRain]))
+                    .onGet(() => this._contactState(this.getStateAsync(this.dpRain)));
+            }
+        }
+
+        this._syncAggregate();
+
+        // --- React to device-side changes (physical buttons, our own writes
+        //     being confirmed, battery/rain telemetry) ---
+        this.device.on('change', (changes) => this._onDeviceChange(changes));
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Device change handling
+     * ------------------------------------------------------------------ */
+
+    _onDeviceChange(changes) {
+        const {Service, Characteristic} = this.hap;
+
+        let valveChanged = false;
+        this._valves.forEach(cfg => {
+            if (!changes.hasOwnProperty(cfg.dp)) return;
+            valveChanged = true;
+            this._reflectValve(cfg, !!changes[cfg.dp]);
+        });
+
+        if (changes.hasOwnProperty(this.dpBattery) && this._hasBattery()) {
+            const battery = this.accessory.getService(Service.Battery);
+            if (battery) {
+                const level = this._batteryLevel(changes[this.dpBattery]);
+                battery.getCharacteristic(Characteristic.BatteryLevel).updateValue(level);
+                battery.getCharacteristic(Characteristic.StatusLowBattery).updateValue(this._lowBattery(level));
+            }
+        }
+
+        if (changes.hasOwnProperty(this.dpCharging) && this._hasBattery()) {
+            const battery = this.accessory.getService(Service.Battery);
+            if (battery) battery.getCharacteristic(Characteristic.ChargingState)
+                .updateValue(this._chargingState(changes[this.dpCharging]));
+        }
+
+        if (changes.hasOwnProperty(this.dpRain) && this._hasRainSensor()) {
+            if (this._usesLeakSensor()) {
+                const leak = this.accessory.getService(Service.LeakSensor);
+                if (leak) leak.getCharacteristic(Characteristic.LeakDetected)
+                    .updateValue(this._rainDetected(changes[this.dpRain]) ? 1 : 0);
+            } else {
+                const contact = this.accessory.getService(Service.ContactSensor);
+                if (contact) contact.getCharacteristic(Characteristic.ContactSensorState)
+                    .updateValue(this._contactState(changes[this.dpRain]));
+            }
+        }
+
+        if (valveChanged) this._syncAggregate();
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Valve activation + timer logic
+     * ------------------------------------------------------------------ */
+
+    // Called from HomeKit (Valve.Active onSet). Writes to the device and
+    // mirrors the state locally.
+    _setValveActive(cfg, value) {
+        const {Characteristic} = this.hap;
+        const on = value === Characteristic.Active.ACTIVE || value === true || value === 1;
+
+        const service = this._valveService(cfg);
+        // Guard against iOS firing duplicate onSet callbacks.
+        if (service && service.getCharacteristic(Characteristic.Active).value === (on ? 1 : 0) &&
+            !!this.device.state[cfg.dp] === on) {
+            return;
+        }
+
+        this._queueWrite(cfg.dp, on);
+        this._reflectValve(cfg, on);
+        this._syncAggregate();
+    }
+
+    // Mirror a zone's on/off state into HomeKit and (dis)arm its auto-shutoff
+    // timer. Does NOT write to the device — call _queueWrite separately for that.
+    _reflectValve(cfg, on) {
+        const {Characteristic} = this.hap;
+        const service = this._valveService(cfg);
+        if (!service) return;
+
+        const activeChar = service.getCharacteristic(Characteristic.Active);
+        const inUseChar = service.getCharacteristic(Characteristic.InUse);
+        const remainingChar = service.getCharacteristic(Characteristic.RemainingDuration);
+
+        this._clearTimer(cfg.dp);
+
+        if (on) {
+            const duration = this._getDuration(cfg);
+            if (activeChar.value !== Characteristic.Active.ACTIVE) activeChar.updateValue(Characteristic.Active.ACTIVE);
+            if (inUseChar.value !== Characteristic.InUse.IN_USE) inUseChar.updateValue(Characteristic.InUse.IN_USE);
+
+            if (duration > 0) {
+                this._endTimes[cfg.dp] = Date.now() + duration * 1000;
+                remainingChar.updateValue(duration);
+                this._timers[cfg.dp] = setTimeout(() => {
+                    this.log.info('%s: zone "%s" timer expired, shutting off', this.device.context.name, cfg.name);
+                    this._queueWrite(cfg.dp, false);
+                    this._reflectValve(cfg, false);
+                    this._syncAggregate();
+                }, duration * 1000);
+            } else {
+                // Indefinite run — no auto-shutoff, no countdown.
+                this._endTimes[cfg.dp] = null;
+                remainingChar.updateValue(0);
+            }
+        } else {
+            this._endTimes[cfg.dp] = null;
+            if (activeChar.value !== Characteristic.Active.INACTIVE) activeChar.updateValue(Characteristic.Active.INACTIVE);
+            if (inUseChar.value !== Characteristic.InUse.NOT_IN_USE) inUseChar.updateValue(Characteristic.InUse.NOT_IN_USE);
+            remainingChar.updateValue(0);
+        }
+    }
+
+    _clearTimer(dp) {
+        if (this._timers[dp]) {
+            clearTimeout(this._timers[dp]);
+            this._timers[dp] = null;
+        }
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Master (whole-system) on/off
+     * ------------------------------------------------------------------ */
+
+    _setSystemActive(value) {
+        const {Characteristic} = this.hap;
+        const on = value === Characteristic.Active.ACTIVE || value === true || value === 1;
+
+        if (on && !this._cascadeOn) return;     // master is a passive enable
+        if (!on && !this._cascadeOff) return;
+
+        // Act on what the user sees (the valve's HomeKit Active value) so the
+        // cascade self-heals stale optimistic states and doesn't reset the
+        // countdown on a zone that is already running. Only zones that actually
+        // change are touched; _flushWrites then coalesces them into a single
+        // Tuya command and drops any that already match the real device state.
+        this._valves.forEach(cfg => {
+            const service = this._valveService(cfg);
+            const currentlyOn = !!(service && service.getCharacteristic(Characteristic.Active).value);
+            if (currentlyOn === on) return;
+            this._queueWrite(cfg.dp, on);
+            this._reflectValve(cfg, on);
+        });
+        this._syncAggregate();
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Duration helpers
+     * ------------------------------------------------------------------ */
+
+    _getDuration(cfg) {
+        const saved = this.accessory.context.durations[cfg.dp];
+        return isFinite(saved) ? saved : cfg.duration;
+    }
+
+    _setDuration(cfg, value) {
+        const {Characteristic} = this.hap;
+        const seconds = Math.max(0, parseInt(value) || 0);
+        this.accessory.context.durations[cfg.dp] = seconds;
+        this.log.info('%s: zone "%s" duration set to %s', this.device.context.name, cfg.name, seconds ? (seconds + 's') : 'indefinite');
+
+        // If the zone is running, re-base its countdown on the new duration.
+        const service = this._valveService(cfg);
+        if (service && service.getCharacteristic(Characteristic.InUse).value === Characteristic.InUse.IN_USE) {
+            this._clearTimer(cfg.dp);
+            const remainingChar = service.getCharacteristic(Characteristic.RemainingDuration);
+            if (seconds > 0) {
+                this._endTimes[cfg.dp] = Date.now() + seconds * 1000;
+                remainingChar.updateValue(seconds);
+                this._timers[cfg.dp] = setTimeout(() => {
+                    this._queueWrite(cfg.dp, false);
+                    this._reflectValve(cfg, false);
+                    this._syncAggregate();
+                }, seconds * 1000);
+            } else {
+                this._endTimes[cfg.dp] = null;
+                remainingChar.updateValue(0);
+            }
+            this._syncAggregate();
+        }
+    }
+
+    _valveRemaining(cfg) {
+        const end = this._endTimes[cfg.dp];
+        if (!end) return 0;
+        const remaining = Math.round((end - Date.now()) / 1000);
+        return remaining > 0 ? remaining : 0;
+    }
+
+    _systemRemaining() {
+        let max = 0;
+        this._valves.forEach(cfg => {
+            const r = this._valveRemaining(cfg);
+            if (r > max) max = r;
+        });
+        return max;
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Aggregation: roll zone state up to the IrrigationSystem service
+     * ------------------------------------------------------------------ */
+
+    _anyValveOn() {
+        return this._valves.some(cfg => !!this.device.state[cfg.dp]);
+    }
+
+    _syncAggregate() {
+        const {Characteristic} = this.hap;
+        const anyOn = this._valves.some(cfg => {
+            const service = this._valveService(cfg);
+            return service && service.getCharacteristic(Characteristic.InUse).value === Characteristic.InUse.IN_USE;
+        });
+
+        if (this._systemInUseChar) {
+            const v = anyOn ? Characteristic.InUse.IN_USE : Characteristic.InUse.NOT_IN_USE;
+            if (this._systemInUseChar.value !== v) this._systemInUseChar.updateValue(v);
+        }
+        if (this._systemActiveChar) {
+            const v = anyOn ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE;
+            if (this._systemActiveChar.value !== v) this._systemActiveChar.updateValue(v);
+        }
+        if (this._systemRemainingChar) {
+            this._systemRemainingChar.updateValue(this._systemRemaining());
+        }
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Battery + rain mapping
+     * ------------------------------------------------------------------ */
+
+    _batteryLevel(value) {
+        const n = parseInt(value);
+        if (!isFinite(n)) return 0;
+        return Math.max(0, Math.min(100, n));
+    }
+
+    _lowBattery(level) {
+        const {Characteristic} = this.hap;
+        return level <= this._lowBatteryThreshold
+            ? Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW
+            : Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+    }
+
+    // CHARGING / NOT_CHARGING from the device's boolean charging data-point.
+    // Devices that don't report charging (no such data-point) → NOT_CHARGEABLE.
+    _chargingState(value) {
+        const {Characteristic} = this.hap;
+        if (typeof value !== 'boolean') return Characteristic.ChargingState.NOT_CHARGEABLE;
+        return value
+            ? Characteristic.ChargingState.CHARGING
+            : Characteristic.ChargingState.NOT_CHARGING;
+    }
+
+    // True when the device reports rain.
+    _rainDetected(value) {
+        let raining;
+        if (typeof value === 'boolean') raining = value;
+        else raining = ('' + value).trim().toLowerCase() === this._rainOnValue.toLowerCase();
+        return this._rainInverted ? !raining : raining;
+    }
+
+    _contactState(value) {
+        const {Characteristic} = this.hap;
+        // "Rain" is treated as the triggered/abnormal state → CONTACT_NOT_DETECTED.
+        return this._rainDetected(value)
+            ? Characteristic.ContactSensorState.CONTACT_NOT_DETECTED
+            : Characteristic.ContactSensorState.CONTACT_DETECTED;
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Batched writes — coalesce DP updates into a single Tuya command
+     * ------------------------------------------------------------------ */
+
+    _queueWrite(dp, value) {
+        if (!this._pendingWrite) this._pendingWrite = {dps: {}};
+        this._pendingWrite.dps[String(dp)] = value;
+
+        if (this._pendingWrite.timer) clearTimeout(this._pendingWrite.timer);
+        this._pendingWrite.timer = setTimeout(() => this._flushWrites(), this._debounce);
+    }
+
+    _flushWrites() {
+        const pending = this._pendingWrite;
+        this._pendingWrite = null;
+        if (!pending) return;
+
+        if (!this.device.connected) {
+            this.log.debug('%s: skipping write, device not connected', this.device.context.name);
+            return;
+        }
+
+        const dps = {};
+        let count = 0;
+        Object.keys(pending.dps).forEach(dp => {
+            if (pending.dps[dp] !== this.device.state[dp]) {
+                dps[dp] = pending.dps[dp];
+                count++;
+            }
+        });
+
+        if (count) this.device.update(dps);
+    }
+
+    _valveService(cfg) {
+        const {Service} = this.hap;
+        return this.accessory.getServiceById(Service.Valve, 'valve-' + cfg.dp);
+    }
+}
+
+module.exports = IrrigationSystemAccessory;

package/lib/OilDiffuserAccessory.js

@@ -2,7 +2,7 @@ const BaseAccessory = require('./BaseAccessory');
 
 class OilDiffuserAccessory extends BaseAccessory {
     static getCategory(Categories) {
-        return Categories.DEHUMIDIFIER;
+        return Categories.AIR_DEHUMIDIFIER;
     }
 
     constructor(...props) {