homebridge-tydom 0.23.3 → 0.23.4

package/lib/accessories/garageDoorOpener.js

@@ -10,12 +10,28 @@ const setupGarageDoorOpener = (accessory, controller) => {
     const { context } = accessory;
     const { client } = controller;
     const { CurrentDoorState, TargetDoorState } = hap_1.Characteristic;
-    const GARAGE_DOOR_DELAY = 15 * 1000;
+    const GARAGE_DOOR_DELAY = 20 * 1000;
     const { deviceId, endpointId, state } = context;
     const assignState = (update) => {
         Object.assign(state, update);
     };
+    const getDoorStateLabel = (currentDoorState) => {
+        switch (currentDoorState) {
+            case CurrentDoorState.OPEN:
+                return 'OPEN';
+            case CurrentDoorState.CLOSED:
+                return 'CLOSED';
+            case CurrentDoorState.OPENING:
+                return 'OPENING';
+            case CurrentDoorState.CLOSING:
+                return 'CLOSING';
+            case CurrentDoorState.STOPPED:
+                return 'STOPPED';
+        }
+        return 'UNKNOWN';
+    };
     const assignCurrentDoorState = (currentDoorState) => {
+        (0, debug_1.debug)(`assignCurrentDoorState=${(0, chalk_1.chalkString)(getDoorStateLabel(currentDoorState))}`);
         Object.assign(state, { currentDoorState });
         service.updateCharacteristic(CurrentDoorState, currentDoorState);
     };
@@ -31,14 +47,14 @@ const setupGarageDoorOpener = (accessory, controller) => {
         currentDoorState: CurrentDoorState.CLOSED,
         targetDoorState: TargetDoorState.CLOSED,
         lastUpdatedAt: 0,
-        computedPosition: 0 // 0 <-> GARAGE_DOOR_DELAY
+        computedPosition: 0 // 0 <-> 100%
     });
     const getNextCurrentDoorState = (targetDoorState) => {
         switch (state.currentDoorState) {
             case CurrentDoorState.OPEN: {
                 switch (targetDoorState) {
                     case TargetDoorState.CLOSED:
-                        return CurrentDoorState.OPENING;
+                        return CurrentDoorState.CLOSING;
                     case TargetDoorState.OPEN:
                         return CurrentDoorState.OPEN;
                 }
@@ -49,7 +65,7 @@ const setupGarageDoorOpener = (accessory, controller) => {
                     case TargetDoorState.CLOSED:
                         return CurrentDoorState.CLOSED;
                     case TargetDoorState.OPEN:
-                        return CurrentDoorState.CLOSING;
+                        return CurrentDoorState.OPENING;
                 }
                 break;
             }
@@ -71,7 +87,7 @@ const setupGarageDoorOpener = (accessory, controller) => {
     };
     const computeCurrentPosition = () => {
         const { lastUpdatedAt, computedPosition: lastComputedPosition, currentDoorState } = state;
-        const elapsed = lastUpdatedAt - Date.now();
+        const elapsed = Date.now() - lastUpdatedAt;
         switch (currentDoorState) {
             case CurrentDoorState.STOPPED: {
                 return lastComputedPosition;
@@ -83,10 +99,10 @@ const setupGarageDoorOpener = (accessory, controller) => {
                 return 0;
             }
             case CurrentDoorState.OPENING: {
-                return Math.min(100, lastComputedPosition + elapsed / GARAGE_DOOR_DELAY);
+                return Math.min(100, lastComputedPosition + 100 * (elapsed / GARAGE_DOOR_DELAY));
             }
             case CurrentDoorState.CLOSING: {
-                return Math.max(0, lastComputedPosition - elapsed / GARAGE_DOOR_DELAY);
+                return Math.max(0, lastComputedPosition - 100 * (elapsed / GARAGE_DOOR_DELAY));
             }
         }
         return 0;
@@ -134,7 +150,9 @@ const setupGarageDoorOpener = (accessory, controller) => {
                 lastUpdatedAt: Date.now(),
                 computedPosition: computeCurrentPosition()
             });
+            // debug(`computedPosition=${chalkNumber(state.computedPosition)}`);
             let nextCurrentDoorState = getNextCurrentDoorState(targetDoorState);
+            // debug(`nextCurrentDoorState=${chalkString(getDoorStateLabel(nextCurrentDoorState))}`);
             if (nextCurrentDoorState === state.currentDoorState) {
                 (0, debug_1.debug)(`nextCurrentDoorState=${(0, chalk_1.chalkNumber)(nextCurrentDoorState)} === state.currentDoorState`);
                 callback();
@@ -142,30 +160,48 @@ const setupGarageDoorOpener = (accessory, controller) => {
             }
             await toggleGarageDoor();
             assignCurrentDoorState(nextCurrentDoorState);
-            callback();
             // Handle Stopped state, if we are stopped, wait one second and trigger again to reverse course
             // eg. Stopped -> Closing if target is Closed
             if (nextCurrentDoorState === CurrentDoorState.STOPPED) {
-                await (0, basic_1.waitFor)(1000);
+                await (0, basic_1.waitFor)('stopping', 1000);
                 assignState({
                     targetDoorState: targetDoorState,
                     lastUpdatedAt: Date.now(),
                     computedPosition: computeCurrentPosition()
                 });
+                // debug(`computedPosition=${chalkNumber(state.computedPosition)}`);
                 nextCurrentDoorState = getNextCurrentDoorState(targetDoorState);
+                // debug(`nextCurrentDoorState=${chalkString(getDoorStateLabel(nextCurrentDoorState))}`);
                 await toggleGarageDoor();
                 assignCurrentDoorState(nextCurrentDoorState);
             }
+            callback();
             // Finally update pending states
             switch (nextCurrentDoorState) {
-                case CurrentDoorState.OPENING:
-                    await (0, basic_1.waitFor)((100 - state.computedPosition) * GARAGE_DOOR_DELAY);
-                    assignCurrentDoorState(CurrentDoorState.OPEN);
+                case CurrentDoorState.OPENING: {
+                    const delay = ((100 - state.computedPosition) * GARAGE_DOOR_DELAY) / 100;
+                    // debug(`delay=${chalkNumber(delay)}`);
+                    try {
+                        await (0, basic_1.waitFor)(`${deviceId}.pending`, delay);
+                        assignCurrentDoorState(CurrentDoorState.OPEN);
+                    }
+                    catch (err) {
+                        // debug(`Aborted OPEN update with delay=${chalkNumber(delay)}`);
+                    }
                     break;
-                case CurrentDoorState.CLOSING:
-                    await (0, basic_1.waitFor)(state.computedPosition * GARAGE_DOOR_DELAY);
-                    assignCurrentDoorState(CurrentDoorState.CLOSED);
+                }
+                case CurrentDoorState.CLOSING: {
+                    const delay = (state.computedPosition * GARAGE_DOOR_DELAY) / 100;
+                    // debug(`delay=${chalkNumber(delay)}`);
+                    try {
+                        await (0, basic_1.waitFor)(`${deviceId}.pending`, delay);
+                        assignCurrentDoorState(CurrentDoorState.CLOSED);
+                    }
+                    catch (err) {
+                        // debug(`Aborted CLOSED update with delay=${chalkNumber(delay)}`);
+                    }
                     break;
+                }
             }
         }
         catch (err) {
@@ -173,6 +209,29 @@ const setupGarageDoorOpener = (accessory, controller) => {
         }
     })
         .getValue();
+    // const switchService = addAccessoryService(accessory, Service.Switch, `${accessory.displayName} Switch`, true);
+    // debugAddSubService(switchService, accessory);
+    // service.addLinkedService(switchService);
+    // switchService
+    //   .getCharacteristic(Characteristic.On)
+    //   .on(CharacteristicEventTypes.SET, async (value: CharacteristicValue, callback: CharacteristicSetCallback) => {
+    //     debugSet(Characteristic.On, service, value);
+    //     if (!value) {
+    //       callback();
+    //       return;
+    //     }
+    //     try {
+    //       await toggleGarageDoor();
+    //       debugSetResult(Characteristic.On, service, value);
+    //       callback();
+    //       setTimeout(() => {
+    //         service.updateCharacteristic(Characteristic.On, false);
+    //       }, 1000);
+    //     } catch (err) {
+    //       callback(err as Error);
+    //     }
+    //   })
+    //   .updateValue(false);
 };
 exports.setupGarageDoorOpener = setupGarageDoorOpener;
 const updateGarageDoorOpener = (accessory, _controller, updates, type) => {

package/lib/controller.js

@@ -110,7 +110,7 @@ class TydomController extends events_1.EventEmitter {
             }
             const category = categoryFromSettings || (0, tydom_1.resolveEndpointCategory)({ firstUsage, metadata });
             if (!category) {
-                this.log.warn(`Unsupported firstUsage="${firstUsage}" for endpoint with id="${endpointId}"`);
+                this.log.warn(`Unsupported firstUsage="${firstUsage}" for endpoint with deviceId="${deviceId}"`);
                 (0, utils_1.debug)({ endpoint });
                 return;
             }

package/lib/platform.js

@@ -94,7 +94,7 @@ class TydomPlatform {
         const { platformAccessory: PlatformAccessory } = this.api;
         const { group } = context;
         const accessoryName = category === 13 /* Categories.WINDOW */ && group ? group.name || name : name;
-        this.log.info(`Creating accessory named="${accessoryName}" with id="${id}"`);
+        this.log.info(`Creating accessory named="${accessoryName}" with deviceId="${context.deviceId}"`);
         const accessory = new PlatformAccessory(accessoryName, id, category);
         Object.assign(accessory.context, context);
         await this.updateAccessory(accessory, context);
@@ -102,7 +102,7 @@ class TydomPlatform {
     }
     async updateAccessory(accessory, context) {
         const { displayName: name, UUID: id } = accessory;
-        this.log.info(`Updating accessory named="${name}" with id="${id}"`);
+        this.log.info(`Updating accessory named="${name}" with deviceId="${context.deviceId}"`);
         Object.assign(accessory.context, context);
         const tydomAccessorySetup = (0, accessory_1.getTydomAccessorySetup)(accessory);
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion

package/lib/utils/basic.d.ts

@@ -1,4 +1,4 @@
 export declare const stringIncludes: (array: unknown[], value: string | number) => boolean;
 export declare const sameArrays: (source: unknown[], array: unknown[]) => boolean;
 export declare const asNumber: (maybeNumber: unknown) => number;
-export declare const waitFor: (ms: number) => Promise<void>;
+export declare const waitFor: (key: string, ms: number) => Promise<void>;

package/lib/utils/basic.js

@@ -8,5 +8,18 @@ const sameArrays = (source, array) => source.length === array.length && (0, loda
 exports.sameArrays = sameArrays;
 const asNumber = (maybeNumber) => parseInt(`${maybeNumber}`, 10);
 exports.asNumber = asNumber;
-const waitFor = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const timeouts = new Map();
+const waitFor = async (key, ms) => {
+    if (timeouts.has(key)) {
+        const { timeout, reject } = timeouts.get(key);
+        clearTimeout(timeout);
+        timeouts.delete(key);
+        reject();
+    }
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(resolve, ms);
+        timeouts.set(key, { timeout, reject });
+    });
+    timeouts.delete(key);
+};
 exports.waitFor = waitFor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tydom",
-  "version": "0.23.3",
+  "version": "0.23.4",
   "description": "Homebridge plugin to manage Tydom devices by Delta Dore",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",