homebridge-zencontrol-tpi 1.1.0-next.4 → 1.1.0-next.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # homebridge-zencontrol-tpi
 
+## 1.1.0-next.6
+
+### Minor Changes
+
+- 1b01c14: Add windows
+
+## 1.1.0-next.5
+
+### Patch Changes
+
+- 9e59549: Fix blind accessory to have different UUID so it doesn't collide with relay accessory if it already exists
+
 ## 1.1.0-next.4
 
 ### Minor Changes

package/README.md

@@ -2,7 +2,80 @@
 
 A plugin for Homebridge that enables control over lights using Zencontrol Third Party Interface (TPI).
 
-## Testing
+## Features
+
+### Groups
+
+DALI Groups will be represented as light switches.
+
+### Individual lights
+
+Any light ECGs that aren't part of a group will be represented as a light switch.
+
+### Blinds
+
+Any blind controller that has its name (Location name) listed in the Blinds list in the plugin configuration will be represented
+as a window covering.
+
+If a system variable exists with the same name as the blind but with the word "Position" after it, then it will be used to reflect
+the position of the blind (0 = closed, 100 = open). This is because the blind controller arc level may not accurately reflect the
+blind position if it resets to 0 after some time.
+
+If the position system variable is available, HomeKit will send a Recall Min to the blind (instead of the expected Off), and you must
+setup a trigger + sequence to convert that to Off and to update the position system variable.
+
+### Windows
+
+If you have windows controlled by a system variable pair—one for control and one for position—you can list the control variable name in
+the plugin configuration.
+
+The plugin assumes that the control system variable is set to:
+* 0 for stopped
+* 1 for closing
+* 2 for opening
+
+There should be a position system variable with the same name as the control variable with the word "Position" after it. This has
+the same semantics as for blinds.
+
+### Relays
+
+Any relay that has its name (Location name) listed in the Switches list in the plugin configuration will be represented as a switch. Only named relays
+are handled to prevent pulling through relays that aren't appropriate.
+
+### Temperature
+
+System variables that end with the word "Temperature" will be represented as temperature sensor accessories.
+
+### Humidity
+
+System variables that end with the word "Humidity" will be represented as humidity sensor accessories.
+
+### Lux
+
+System variables that end with the word "Lux" will be represented as light sensor accessories.
+
+### CO2
+
+System variables that end with the word "CO2" will be represented as carbon dioxide sensor accessories.
+
+Set the CO2 level to treat as abnormal in the plugin configuration.
+
+## Development
+
+```shell
+nvm install
+nvm use
+npm install
+npm run build
+```
+
+When I make changes I like to test them on my local Homebridge, which is on another device accessible via ssh:
+
+```shell
+npm run build && rsync -a dist ubuntu@192.168.1.2:/var/lib/homebridge/node_modules/homebridge-zencontrol-tpi/
+```
+
+Then I restart Homebridge to load the updated code.
 
 ## Contributing
 

package/config.schema.json

@@ -17,6 +17,14 @@
 					"type": "string"
 				}
 			},
+			"windows": {
+				"type": "array",
+				"title": "Windows",
+				"description": "The names of system variables on your controllers that should be represented as windows.",
+				"items": {
+					"type": "string"
+				}
+			},
 			"relays": {
 				"type": "array",
 				"title": "Switches",

package/dist/blindAccessory.js

@@ -1,8 +1,11 @@
+const BLIND_OPEN = 100;
+const BLIND_CLOSED = 0;
 export class ZencontrolBlindPlatformAccessory {
     constructor(platform, accessory) {
         this.platform = platform;
         this.accessory = accessory;
-        this.currentPosition = 0; /* 0 = open, 100 = closed */
+        this.currentPosition = BLIND_OPEN;
+        this.positionState = this.platform.Characteristic.PositionState.STOPPED;
         this.accessory.getService(this.platform.Service.AccessoryInformation)
             .setCharacteristic(this.platform.Characteristic.Manufacturer, 'Zencontrol')
             .setCharacteristic(this.platform.Characteristic.Model, accessory.context.model || 'Unknown')
@@ -28,29 +31,89 @@ export class ZencontrolBlindPlatformAccessory {
         return this.targetPosition ?? 0;
     }
     async setTargetPosition(value) {
-        const targetPosition = value;
-        this.platform.log.debug(`Set blind ${this.accessory.displayName} (${this.accessory.context.address}) to ${targetPosition}`);
+        const targetPosition = value >= 50 ? BLIND_OPEN : BLIND_CLOSED;
+        this.platform.log.debug(`Set blind ${this.accessory.displayName} (${this.accessory.context.address}) to ${targetPosition === BLIND_OPEN ? 'open' : 'closed'}`);
         this.targetPosition = targetPosition;
+        if (this.positionStateTimeout) {
+            clearTimeout(this.positionStateTimeout);
+            this.positionStateTimeout = undefined;
+        }
         try {
-            await this.platform.sendArcLevel(this.accessory.context.address, this.targetPosition ? 254 : 0, false);
+            if (this.targetPosition === BLIND_CLOSED) {
+                this.platform.log.debug(`Updating blind position state to decreasing: ${this.accessory.displayName}`);
+                this.positionState = this.platform.Characteristic.PositionState.DECREASING;
+                this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
+                await this.platform.sendRecallMax(this.accessory.context.address);
+            }
+            else {
+                this.platform.log.debug(`Updating blind position state to increasing: ${this.accessory.displayName}`);
+                this.positionState = this.platform.Characteristic.PositionState.INCREASING;
+                this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
+                if (this.positionSystemVariableAddress) {
+                    await this.platform.sendRecallMin(this.accessory.context.address);
+                }
+                else {
+                    await this.platform.sendOff(this.accessory.context.address);
+                }
+            }
+            this.positionStateTimeout = setTimeout(() => {
+                this.platform.log.debug(`Updating blind position state to stopped: ${this.accessory.displayName}`);
+                this.positionStateTimeout = undefined;
+                this.positionState = this.platform.Characteristic.PositionState.STOPPED;
+                this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
+            }, 5000);
         }
         catch (error) {
-            this.platform.log.warn(`Failed to update state for ${this.accessory.displayName}`, error);
+            this.platform.log.warn(`Failed to control blind ${this.accessory.displayName}`, error);
+            this.positionState = this.platform.Characteristic.PositionState.STOPPED;
+            this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
         }
     }
     async getPositionState() {
-        return this.platform.Characteristic.PositionState.STOPPED;
+        return this.positionState;
     }
+    /* NB: blind controllers change back to 0 after a while, so they inaccurately report that they're open; this is why we prefer the system variable. */
     async receiveArcLevel(arcLevel) {
-        if (arcLevel === 255) {
-            /* A stop fade; ignore */
+        if (this.positionSystemVariableAddress) {
+            this.platform.log.debug(`Controller updated blind ${this.accessory.displayName} to arc level ${arcLevel}; ignoring as there is a system variable configured`);
             return;
         }
-        const value = arcLevel > 0 ? 100 : 0;
+        const value = arcLevel > 0 ? BLIND_CLOSED : BLIND_OPEN;
+        this.platform.log.debug(`Controller updated blind ${this.accessory.displayName} to ${value === BLIND_OPEN ? 'open' : 'closed'}`);
         if (value !== this.currentPosition) {
-            this.platform.log.debug(`Controller updated blind ${this.accessory.displayName} to ${value}`);
             this.currentPosition = value;
             this.service.updateCharacteristic(this.platform.Characteristic.CurrentPosition, value);
         }
+        /* Update target position otherwise HomeKit will observe the difference between current and target and think the blind is moving */
+        if (value !== this.targetPosition) {
+            this.targetPosition = value;
+            this.service.updateCharacteristic(this.platform.Characteristic.TargetPosition, value);
+        }
+    }
+    async receivePosition(position) {
+        if (position < 0 || position > 100) {
+            this.platform.log.warn(`Ignoring invalid blind position for ${this.accessory.displayName}: ${position}`);
+            return;
+        }
+        this.platform.log.debug(`Controller updated blind ${this.accessory.displayName} to position ${position}`);
+        if (position !== this.currentPosition) {
+            this.currentPosition = position;
+            this.service.updateCharacteristic(this.platform.Characteristic.CurrentPosition, position);
+        }
+        /* Update target position otherwise HomeKit will observe the difference between current and target and think the blind is moving */
+        if (position !== this.targetPosition) {
+            this.targetPosition = position;
+            this.service.updateCharacteristic(this.platform.Characteristic.TargetPosition, position);
+        }
+    }
+    async receiveSystemVariableChange(systemVariableAddress, value) {
+        if (systemVariableAddress === this.positionSystemVariableAddress) {
+            if (value !== null) {
+                await this.receivePosition(value);
+            }
+        }
+        else {
+            this.platform.log.warn(`Ignoring unknown system variable change in blind "${this.displayName}: ${systemVariableAddress}`);
+        }
     }
 }

package/dist/co2Accessory.js

@@ -34,4 +34,7 @@ export class ZencontrolCO2PlatformAccessory {
         this.platform.log(`Received CO2 for ${this.displayName}: ${co2}`);
         this.service.updateCharacteristic(this.platform.Characteristic.CarbonDioxideLevel, co2);
     }
+    async receiveSystemVariableChange(systemVariableAddress, value) {
+        await this.receiveCO2(value);
+    }
 }

package/dist/humidityAccessory.js

@@ -23,4 +23,7 @@ export class ZencontrolHumidityPlatformAccessory {
         this.platform.log(`Received humidity for ${this.displayName}: ${humidity}`);
         this.service.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, humidity);
     }
+    async receiveSystemVariableChange(systemVariableAddress, value) {
+        await this.receiveHumidity(value);
+    }
 }

package/dist/luxAccessory.js

@@ -27,4 +27,7 @@ export class ZencontrolLuxPlatformAccessory {
         this.platform.log(`Received lux for ${this.displayName}: ${lux}`);
         this.service.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, lux);
     }
+    async receiveSystemVariableChange(systemVariableAddress, value) {
+        this.receiveLux(value);
+    }
 }

package/dist/platform.js

@@ -1,10 +1,12 @@
 import { ZencontrolLightPlatformAccessory } from './lightAccessory.js';
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js';
+import { isZencontrolSystemVariableAccessory } from './types.js';
 import { ZenController, ZenProtocol, ZenAddress, ZenAddressType, ZenControlGearType, ZenConst } from 'zencontrol-tpi-node';
 import { ZencontrolTemperaturePlatformAccessory } from './temperatureAccessory.js';
 import { ZencontrolHumidityPlatformAccessory } from './humidityAccessory.js';
 import { ZencontrolRelayPlatformAccessory } from './relayAccessory.js';
 import { ZencontrolBlindPlatformAccessory } from './blindAccessory.js';
+import { ZencontrolWindowPlatformAccessory } from './windowAccessory.js';
 import { ZencontrolLuxPlatformAccessory } from './luxAccessory.js';
 import { ZencontrolCO2PlatformAccessory } from './co2Accessory.js';
 /**
@@ -57,7 +59,9 @@ export class ZencontrolTPIPlatform {
         this.api.on('didFinishLaunching', () => {
             log.debug('Executed didFinishLaunching callback');
             // run the method to discover / register your devices as accessories
-            this.discoverDevices();
+            this.discoverDevices().then(() => {
+                this.activateLiveEvents();
+            });
         });
     }
     /**
@@ -78,6 +82,7 @@ export class ZencontrolTPIPlatform {
         this.log.info('Discovering groups and devices');
         this.accessoriesByAddress.clear();
         const promises = [];
+        const positionVariables = [];
         for (const controller of this.zc.controllers) {
             /* Discover groups */
             promises.push(this.zc.queryGroupNumbers(controller).then((groups) => {
@@ -125,8 +130,8 @@ export class ZencontrolTPIPlatform {
                                 if (!label) {
                                     return;
                                 }
-                                if ((this.config.relays ?? []).indexOf(label) !== -1) {
-                                    const acc = this.addRelayAccessory({
+                                if ((this.config.blinds ?? []).indexOf(label) !== -1) {
+                                    const acc = this.addBlindAccessory({
                                         address: addressToString(ecg),
                                         label,
                                         model: 'Relay',
@@ -137,8 +142,8 @@ export class ZencontrolTPIPlatform {
                                         acc.receiveArcLevel(level);
                                     }
                                 }
-                                else if ((this.config.blinds ?? []).indexOf(label) !== -1) {
-                                    const acc = this.addBlindAccessory({
+                                else if ((this.config.relays ?? []).indexOf(label) !== -1) {
+                                    const acc = this.addRelayAccessory({
                                         address: addressToString(ecg),
                                         label,
                                         model: 'Relay',
@@ -161,51 +166,63 @@ export class ZencontrolTPIPlatform {
             }));
             for (let variable = 0; variable < ZenConst.MAX_SYSVAR; variable++) {
                 promises.push(this.zc.querySystemVariableName(controller, variable).then(async (label) => {
-                    if (label && label.toLocaleLowerCase().endsWith(' temperature')) {
-                        let value = await this.zc.querySystemVariable(controller, variable);
-                        /* This API doesn't respect magnitude so we have to guess */
-                        if (value !== null) {
-                            while (value > 100) {
-                                value /= 10;
-                            }
-                        }
+                    if (!label) {
+                        return;
+                    }
+                    const address = systemVariableToAddressString(controller, variable);
+                    if ((this.config.windows ?? []).indexOf(label) !== -1) {
+                        const value = await this.zc.querySystemVariable(controller, variable);
+                        const acc = this.addWindowAccessory({
+                            address,
+                            label,
+                            model: 'System Variable',
+                            serial: `SV ${controller.id}.${variable}`,
+                        });
+                        acc.receiveSystemVariableChange(address, value);
+                    }
+                    else if (label.toLocaleLowerCase().endsWith(' temperature')) {
+                        const value = await this.zc.querySystemVariable(controller, variable);
                         const acc = this.addTemperatureAccessory({
-                            address: systemVariableToAddressString(controller, variable),
+                            address,
                             label: label.substring(0, label.length - ' temperature'.length),
                             model: 'System Variable',
                             serial: `SV ${controller.id}.${variable}`,
                         });
-                        acc.receiveTemperature(value);
+                        acc.receiveSystemVariableChange(address, value);
                     }
-                    else if (label && label.toLocaleLowerCase().endsWith(' humidity')) {
+                    else if (label.toLocaleLowerCase().endsWith(' humidity')) {
                         const value = await this.zc.querySystemVariable(controller, variable);
                         const acc = this.addHumidityAccessory({
-                            address: systemVariableToAddressString(controller, variable),
+                            address,
                             label: label.substring(0, label.length - ' humidity'.length),
                             model: 'System Variable',
                             serial: `SV ${controller.id}.${variable}`,
                         });
-                        acc.receiveHumidity(value);
+                        acc.receiveSystemVariableChange(address, value);
                     }
-                    else if (label && label.toLocaleLowerCase().endsWith(' lux')) {
+                    else if (label.toLocaleLowerCase().endsWith(' lux')) {
                         const value = await this.zc.querySystemVariable(controller, variable);
                         const acc = this.addLuxAccessory({
-                            address: systemVariableToAddressString(controller, variable),
+                            address,
                             label: label.substring(0, label.length - ' lux'.length),
                             model: 'System Variable',
                             serial: `SV ${controller.id}.${variable}`,
                         });
-                        acc.receiveLux(value);
+                        acc.receiveSystemVariableChange(address, value);
                     }
-                    else if (label && label.toLocaleLowerCase().endsWith(' co2')) {
+                    else if (label.toLocaleLowerCase().endsWith(' co2')) {
                         const value = await this.zc.querySystemVariable(controller, variable);
                         const acc = this.addCO2Accessory({
-                            address: systemVariableToAddressString(controller, variable),
+                            address,
                             label: label.substring(0, label.length - ' co2'.length),
                             model: 'System Variable',
                             serial: `SV ${controller.id}.${variable}`,
                         });
-                        acc.receiveCO2(value);
+                        acc.receiveSystemVariableChange(address, value);
+                    }
+                    else if (label.toLocaleLowerCase().endsWith(' position')) {
+                        const value = await this.zc.querySystemVariable(controller, variable);
+                        positionVariables.push({ label, address, value });
                     }
                 }));
             }
@@ -218,6 +235,27 @@ export class ZencontrolTPIPlatform {
             /* Return so we don't remove accessories, as then the user will have to set them all up again! Adding them to rooms etc */
             return;
         }
+        /* Position variables; we come back and handle the position variables now that we've created all of the accessories */
+        for (const { label, address, value } of positionVariables) {
+            let foundAcc = undefined;
+            for (const [_, acc] of this.accessoriesByAddress) {
+                if (acc instanceof ZencontrolBlindPlatformAccessory || acc instanceof ZencontrolWindowPlatformAccessory) {
+                    if ((acc.displayName + ' position').toLocaleLowerCase() === label.toLocaleLowerCase()) {
+                        foundAcc = acc;
+                        break;
+                    }
+                }
+            }
+            if (foundAcc) {
+                this.log.info(`Found position system variable for ${foundAcc.displayName}: ${label}`);
+                foundAcc.positionSystemVariableAddress = address;
+                this.accessoriesByAddress.set(address, foundAcc);
+                foundAcc.receiveSystemVariableChange(address, value);
+            }
+            else {
+                this.log.debug(`Ignoring position system variable as no matching accessory found: ${label}`);
+            }
+        }
         // you can also deal with accessories from the cache which are no longer present by removing them from Homebridge
         // for example, if your plugin logs into a cloud account to retrieve a device list, and a user has previously removed a device
         // from this cloud account, then this device will no longer be present in the device list but will still be in the Homebridge cache
@@ -238,7 +276,6 @@ export class ZencontrolTPIPlatform {
             this.accessoryNeedsUpdate.splice(0, this.accessoryNeedsUpdate.length);
         }
         this.log.info('Device discovery complete');
-        this.activateLiveEvents();
     }
     addLightAccessory({ address, label, model, serial, ...options }) {
         // generate a unique id for the accessory this should be generated from
@@ -296,7 +333,7 @@ export class ZencontrolTPIPlatform {
         return acc;
     }
     addBlindAccessory({ address, label, model, serial }) {
-        const uuid = this.api.hap.uuid.generate(`relay @ ${address}`);
+        const uuid = this.api.hap.uuid.generate(`blind @ ${address}`);
         const existingAccessory = this.accessories.get(uuid);
         let acc;
         if (existingAccessory) {
@@ -314,6 +351,25 @@ export class ZencontrolTPIPlatform {
         this.discoveredCacheUUIDs.push(uuid);
         return acc;
     }
+    addWindowAccessory({ address, label, model, serial }) {
+        const uuid = this.api.hap.uuid.generate(`window @ ${address}`);
+        const existingAccessory = this.accessories.get(uuid);
+        let acc;
+        if (existingAccessory) {
+            this.log.debug('Restoring existing window accessory from cache:', existingAccessory.displayName);
+            this.updateAccessory(existingAccessory, { address, label, model, serial });
+            acc = new ZencontrolWindowPlatformAccessory(this, existingAccessory, address);
+        }
+        else {
+            this.log.info('Adding new window accessory:', label);
+            const accessory = new this.api.platformAccessory(label, uuid);
+            this.setupAccessory(accessory, { address, label, model, serial });
+            acc = new ZencontrolWindowPlatformAccessory(this, accessory, address);
+        }
+        this.accessoriesByAddress.set(address, acc);
+        this.discoveredCacheUUIDs.push(uuid);
+        return acc;
+    }
     addTemperatureAccessory({ address, label, model, serial }) {
         const uuid = this.api.hap.uuid.generate(`temperature @ ${address}`);
         const existingAccessory = this.accessories.get(uuid);
@@ -458,27 +514,18 @@ export class ZencontrolTPIPlatform {
             }
         };
         this.zc.systemVariableChangeCallback = (controller, variable, value) => {
-            const accessoryId = systemVariableToAddressString(controller, variable);
-            const acc = this.accessoriesByAddress.get(accessoryId);
-            if (acc instanceof ZencontrolTemperaturePlatformAccessory) {
-                acc.receiveTemperature(value).catch((reason) => {
-                    this.log.warn(`Failed to update temperature accessory "${acc.displayName}" color: ${reason}`);
-                });
+            const variableAddress = systemVariableToAddressString(controller, variable);
+            const acc = this.accessoriesByAddress.get(variableAddress);
+            if (!acc) {
+                return;
             }
-            else if (acc instanceof ZencontrolHumidityPlatformAccessory) {
-                acc.receiveHumidity(value).catch((reason) => {
-                    this.log.warn(`Failed to update humidity accessory "${acc.displayName}" color: ${reason}`);
+            if (isZencontrolSystemVariableAccessory(acc)) {
+                acc.receiveSystemVariableChange(variableAddress, value).catch((reason) => {
+                    this.log.warn(`Failed to update accessory "${acc.displayName}": ${reason}`);
                 });
             }
-            else if (acc instanceof ZencontrolLuxPlatformAccessory) {
-                acc.receiveLux(value).catch((reason) => {
-                    this.log.warn(`Failed to update lux accessory "${acc.displayName}" color: ${reason}`);
-                });
-            }
-            else if (acc instanceof ZencontrolCO2PlatformAccessory) {
-                acc.receiveCO2(value).catch((reason) => {
-                    this.log.warn(`Failed to update CO2 accessory "${acc.displayName}" color: ${reason}`);
-                });
+            else {
+                this.log.warn(`Received system variable change for unsupported accessory: ${acc?.displayName}`);
             }
         };
         this.log.info('Starting live event monitoring');
@@ -490,12 +537,63 @@ export class ZencontrolTPIPlatform {
             await this.applyInstant(accessoryId, address);
         }
         try {
-            await this.zc.daliArcLevel(address, arcLevel);
+            const result = await this.zc.daliArcLevel(address, arcLevel);
+            if (!result) {
+                this.log.warn(`Failed to send arc level ${arcLevel} for ${address}`);
+            }
         }
         catch (error) {
             this.log.warn(`Failed to send arc level for ${address}:`, error);
         }
     }
+    async sendOff(accessoryId) {
+        const address = this.parseAccessoryId(accessoryId);
+        try {
+            const result = await this.zc.daliOff(address);
+            if (!result) {
+                this.log.warn(`Failed to send off for ${address}`);
+            }
+        }
+        catch (error) {
+            this.log.warn(`Failed to send off for ${address}:`, error);
+        }
+    }
+    async sendRecallMin(accessoryId) {
+        const address = this.parseAccessoryId(accessoryId);
+        try {
+            const result = await this.zc.daliRecallMin(address);
+            if (!result) {
+                this.log.warn(`Failed to send recall min for ${address}`);
+            }
+        }
+        catch (error) {
+            this.log.warn(`Failed to send recall min for ${address}:`, error);
+        }
+    }
+    async sendRecallMax(accessoryId) {
+        const address = this.parseAccessoryId(accessoryId);
+        try {
+            const result = await this.zc.daliRecallMax(address);
+            if (!result) {
+                this.log.warn(`Failed to send recall max for ${address}`);
+            }
+        }
+        catch (error) {
+            this.log.warn(`Failed to send recall max for ${address}:`, error);
+        }
+    }
+    async setSystemVariable(address, value) {
+        const { controller, variable } = this.parseSystemVariableAddress(address);
+        try {
+            const result = await this.zc.setSystemVariable(controller, variable, value);
+            if (!result) {
+                this.log.warn(`Failed to set system variable ${controller.id}.${variable} to ${value}`);
+            }
+        }
+        catch (error) {
+            this.log.warn(`Failed to set system variable ${controller.id}.${variable} to ${value}: ${error}`);
+        }
+    }
     async sendColor(accessoryId, color, arcLevel, instant = true) {
         const address = this.parseAccessoryId(accessoryId);
         try {
@@ -545,6 +643,23 @@ export class ZencontrolTPIPlatform {
             throw new Error(`Unrecognised accessory ID: ${accessoryId}`);
         }
     }
+    parseSystemVariableAddress(address) {
+        const parts = address.split(' ');
+        if (parts.length < 2) {
+            throw new Error(`Unrecognised system variable adddress: ${address}`);
+        }
+        const controllerId = parseInt(parts[1]);
+        const controller = this.zc.controllers.find(c => c.id === controllerId);
+        if (!controller) {
+            throw new Error(`Unknown controller id: ${controllerId}`);
+        }
+        if (parts[0] === 'SV') {
+            return { controller, variable: Number(parts[2]) };
+        }
+        else {
+            throw new Error(`Unrecognised system variable address: ${address}`);
+        }
+    }
 }
 function addressToString(address) {
     switch (address.type) {

package/dist/temperatureAccessory.js

@@ -29,4 +29,7 @@ export class ZencontrolTemperaturePlatformAccessory {
         this.platform.log(`Received temperature for ${this.displayName}: ${temperature}`);
         this.service.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, temperature);
     }
+    async receiveSystemVariableChange(systemVariableAddress, value) {
+        this.receiveTemperature(value);
+    }
 }

package/dist/types.js

@@ -1 +1,4 @@
-export {};
+export function isZencontrolSystemVariableAccessory(acc) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (typeof acc.receiveSystemVariableChange === 'function');
+}

package/dist/windowAccessory.js

@@ -0,0 +1,119 @@
+const WINDOW_OPEN = 100;
+const WINDOW_CLOSED = 0;
+const WINDOW_OPENING = 2;
+const WINDOW_CLOSING = 1;
+/**
+ * Handle windows represented by a control system variable and a position system variable.
+ */
+export class ZencontrolWindowPlatformAccessory {
+    constructor(platform, accessory, controlSystemVariableAddress) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.controlSystemVariableAddress = controlSystemVariableAddress;
+        this.currentPosition = WINDOW_OPEN;
+        this.positionState = this.platform.Characteristic.PositionState.STOPPED;
+        this.accessory.getService(this.platform.Service.AccessoryInformation)
+            .setCharacteristic(this.platform.Characteristic.Manufacturer, 'Zencontrol')
+            .setCharacteristic(this.platform.Characteristic.Model, accessory.context.model || 'Unknown')
+            .setCharacteristic(this.platform.Characteristic.SerialNumber, accessory.context.serial || 'Unknown');
+        this.service = this.accessory.getService(this.platform.Service.Window) || this.accessory.addService(this.platform.Service.Window);
+        this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+        // https://developers.homebridge.io/#/service/Window
+        this.service.getCharacteristic(this.platform.Characteristic.CurrentPosition)
+            .onGet(this.getCurrentPosition.bind(this));
+        this.service.getCharacteristic(this.platform.Characteristic.TargetPosition)
+            .onGet(this.getTargetPosition.bind(this))
+            .onSet(this.setTargetPosition.bind(this));
+        this.service.getCharacteristic(this.platform.Characteristic.PositionState)
+            .onGet(this.getPositionState.bind(this));
+    }
+    get displayName() {
+        return this.accessory.displayName;
+    }
+    async getCurrentPosition() {
+        return this.currentPosition;
+    }
+    async getTargetPosition() {
+        return this.targetPosition ?? 0;
+    }
+    async setTargetPosition(value) {
+        const targetPosition = value >= 50 ? WINDOW_OPEN : WINDOW_CLOSED;
+        this.platform.log.debug(`Set window ${this.accessory.displayName} (${this.accessory.context.address}) to ${targetPosition === WINDOW_OPEN ? 'open' : 'closed'}`);
+        this.targetPosition = targetPosition;
+        if (this.positionStateTimeout) {
+            clearTimeout(this.positionStateTimeout);
+            this.positionStateTimeout = undefined;
+        }
+        try {
+            if (this.targetPosition === WINDOW_CLOSED) {
+                this.platform.log.debug(`Updating window position state to decreasing: ${this.accessory.displayName}`);
+                this.positionState = this.platform.Characteristic.PositionState.DECREASING;
+                this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
+                await this.platform.setSystemVariable(this.controlSystemVariableAddress, WINDOW_CLOSING);
+            }
+            else {
+                this.platform.log.debug(`Updating window position state to increasing: ${this.accessory.displayName}`);
+                this.positionState = this.platform.Characteristic.PositionState.INCREASING;
+                this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
+                await this.platform.setSystemVariable(this.controlSystemVariableAddress, WINDOW_OPENING);
+            }
+            this.positionStateTimeout = setTimeout(() => {
+                this.platform.log.debug(`Updating window position state to stopped: ${this.accessory.displayName}`);
+                this.positionStateTimeout = undefined;
+                this.positionState = this.platform.Characteristic.PositionState.STOPPED;
+                this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
+            }, 5000);
+        }
+        catch (error) {
+            this.platform.log.warn(`Failed to control window ${this.accessory.displayName}`, error);
+            this.positionState = this.platform.Characteristic.PositionState.STOPPED;
+            this.service.updateCharacteristic(this.platform.Characteristic.PositionState, this.positionState);
+        }
+    }
+    async getPositionState() {
+        return this.positionState;
+    }
+    async receiveControl(control) {
+        if (control < 0 || control > 2) {
+            this.platform.log.warn(`Ignoring invalid window control for ${this.accessory.displayName}: ${control}`);
+            return;
+        }
+        this.platform.log.debug(`Controller updated window ${this.accessory.displayName} to ${control === 0 ? 'stopped' : control === 1 ? 'closing' : 'opening'}`);
+        const position = control === 0 ? -1 : control === 1 ? WINDOW_CLOSED : WINDOW_OPEN;
+        if (position !== -1 && position !== this.targetPosition) {
+            this.targetPosition = position;
+            this.service.updateCharacteristic(this.platform.Characteristic.TargetPosition, position);
+        }
+    }
+    async receivePosition(position) {
+        if (position < 0 || position > 100) {
+            this.platform.log.warn(`Ignoring invalid window position for ${this.accessory.displayName}: ${position}`);
+            return;
+        }
+        this.platform.log.debug(`Controller updated window ${this.accessory.displayName} to position ${position}`);
+        if (position !== this.currentPosition) {
+            this.currentPosition = position;
+            this.service.updateCharacteristic(this.platform.Characteristic.CurrentPosition, position);
+        }
+        /* Update target position otherwise HomeKit will observe the difference between current and target and think the blind is moving */
+        if (position !== this.targetPosition) {
+            this.targetPosition = position;
+            this.service.updateCharacteristic(this.platform.Characteristic.TargetPosition, position);
+        }
+    }
+    async receiveSystemVariableChange(systemVariableAddress, value) {
+        if (systemVariableAddress === this.controlSystemVariableAddress) {
+            if (value !== null) {
+                this.receiveControl(value);
+            }
+        }
+        else if (systemVariableAddress === this.positionSystemVariableAddress) {
+            if (value !== null) {
+                this.receivePosition(value);
+            }
+        }
+        else {
+            this.platform.log.warn(`Ignoring unknown system variable change in blind "${this.displayName}: ${systemVariableAddress}`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "homebridge-zencontrol-tpi",
-	"version": "1.1.0-next.4",
+	"version": "1.1.0-next.6",
 	"description": "",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -34,7 +34,7 @@
 	},
 	"dependencies": {
 		"homebridge-lib": "^7.2.0",
-		"zencontrol-tpi-node": "^1.1.0"
+		"zencontrol-tpi-node": "^1.2.0"
 	},
 	"publishConfig": {
 		"access": "public"