homebridge-pitpat-treadmill 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file. The project follows Semantic Versioning.
 
+## [0.1.3] - 2026-10-09
+
+### Fixed
+
+- Attempt one controlled HCI controller reset when Noble remains outside the `poweredOn` state after a BLE link timeout.
+- Preserve normal reconnect backoff when the adapter cannot recover.
+
+## [0.1.2] - 2026-10-09
+
+### Fixed
+
+- Always use the hardware-validated 1.5 km/h minimum for remote starts.
+- Prevent `RotationSpeed` changes from starting a stopped treadmill.
+- Debounce HomeKit speed-slider updates to avoid BLE command floods.
+- Handle disconnects during command confirmation without unhandled HomeKit write errors.
+- Remove the unsupported `StatusFault` characteristic from the `Fanv2` service.
+
 ## [0.1.1] - 2026-10-09
 
 ### Changed

package/dist/accessories/treadmillAccessory.d.ts

@@ -11,14 +11,20 @@ export declare class TreadmillAccessory {
     private readonly fanService;
     private readonly telemetryService;
     private targetSpeedKph;
+    private activeCommand;
+    private pendingSpeedKph;
+    private speedUpdateTimer;
     constructor(accessory: PlatformAccessory, bleManager: BleManager, config: ValidatedConfig, api: API, log: Logger);
     private isActive;
     private currentSpeedPercentage;
     private currentFanState;
-    private statusFault;
     private setActive;
     private setSpeed;
+    private applyActive;
+    private scheduleSpeedUpdate;
+    private cancelPendingSpeedUpdate;
     private updateStatus;
     private updateConnectionState;
+    private refreshControlCharacteristics;
     private effectiveMaximumSpeed;
 }

package/dist/accessories/treadmillAccessory.js

@@ -10,6 +10,9 @@ export class TreadmillAccessory {
     fanService;
     telemetryService;
     targetSpeedKph = MINIMUM_COMMAND_SPEED_KPH;
+    activeCommand;
+    pendingSpeedKph;
+    speedUpdateTimer;
     constructor(accessory, bleManager, config, api, log) {
         this.accessory = accessory;
         this.bleManager = bleManager;
@@ -34,7 +37,6 @@ export class TreadmillAccessory {
             .onGet(() => this.currentSpeedPercentage())
             .onSet(async (value) => this.setSpeed(value));
         this.fanService.getCharacteristic(Characteristic.CurrentFanState).onGet(() => this.currentFanState());
-        this.fanService.getCharacteristic(Characteristic.StatusFault).onGet(() => this.statusFault());
         accessory
             .getService(Service.AccessoryInformation)
             ?.setCharacteristic(Characteristic.Manufacturer, 'PitPat (unofficial integration)')
@@ -63,40 +65,81 @@ export class TreadmillAccessory {
         }
         return this.api.hap.Characteristic.CurrentFanState.INACTIVE;
     }
-    statusFault() {
-        return this.bleManager.state === 'ready'
-            ? this.api.hap.Characteristic.StatusFault.NO_FAULT
-            : this.api.hap.Characteristic.StatusFault.GENERAL_FAULT;
-    }
     async setActive(value) {
         const active = Number(value) === this.api.hap.Characteristic.Active.ACTIVE;
-        if (!active) {
-            await this.bleManager.stopTreadmill();
+        if (this.activeCommand) {
+            await this.activeCommand;
             return;
         }
-        if (!this.config.allowRemoteStart) {
-            throw new this.api.hap.HapStatusError(-70412 /* this.api.hap.HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */);
-        }
-        await this.bleManager.startTreadmill(this.targetSpeedKph);
+        this.activeCommand = this.applyActive(active)
+            .catch((error) => {
+            this.log.warn(`[PiTPAT] HomeKit ${active ? 'start' : 'stop'} request was not applied: ${errorMessage(error)}`);
+            this.refreshControlCharacteristics();
+        })
+            .finally(() => {
+            this.activeCommand = undefined;
+        });
+        await this.activeCommand;
     }
     async setSpeed(value) {
         const percentage = Number(value);
         if (percentage === 0) {
-            await this.bleManager.stopTreadmill();
+            await this.setActive(this.api.hap.Characteristic.Active.INACTIVE);
             return;
         }
         const deviceMaximum = this.bleManager.status?.maximumSpeedKph ?? this.config.maximumSpeedKph;
         const requested = percentageToSpeed(percentage, this.effectiveMaximumSpeed(deviceMaximum));
         this.targetSpeedKph = Math.max(MINIMUM_COMMAND_SPEED_KPH, requested);
         if (this.bleManager.status?.runningState === RunningState.Running) {
-            await this.bleManager.setSpeed(this.targetSpeedKph);
-        }
-        else if (this.config.allowRemoteStart) {
-            await this.bleManager.startTreadmill(this.targetSpeedKph);
+            this.scheduleSpeedUpdate(this.targetSpeedKph);
         }
         else {
-            throw new this.api.hap.HapStatusError(-70412 /* this.api.hap.HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */);
+            // RotationSpeed must never start a stopped treadmill. Active is the only
+            // HomeKit control allowed to request a remote start.
+            this.refreshControlCharacteristics();
+        }
+    }
+    async applyActive(active) {
+        if (!active) {
+            this.cancelPendingSpeedUpdate();
+            if (this.bleManager.status?.runningState === RunningState.Stopped) {
+                return;
+            }
+            await this.bleManager.stopTreadmill();
+            return;
         }
+        if (!this.config.allowRemoteStart) {
+            throw new Error('remote start is disabled by configuration');
+        }
+        if (this.isActive() === this.api.hap.Characteristic.Active.ACTIVE) {
+            return;
+        }
+        // A remote start always uses the hardware-validated minimum. A separate,
+        // confirmed speed request may increase it only after Running is reported.
+        this.targetSpeedKph = MINIMUM_COMMAND_SPEED_KPH;
+        await this.bleManager.startTreadmill(MINIMUM_COMMAND_SPEED_KPH);
+    }
+    scheduleSpeedUpdate(speedKph) {
+        this.pendingSpeedKph = speedKph;
+        clearTimeout(this.speedUpdateTimer);
+        this.speedUpdateTimer = setTimeout(() => {
+            this.speedUpdateTimer = undefined;
+            const pendingSpeedKph = this.pendingSpeedKph;
+            this.pendingSpeedKph = undefined;
+            if (pendingSpeedKph === undefined || this.bleManager.status?.runningState !== RunningState.Running) {
+                return;
+            }
+            void this.bleManager.setSpeed(pendingSpeedKph).catch((error) => {
+                this.log.warn(`[PiTPAT] HomeKit speed request was not applied: ${errorMessage(error)}`);
+                this.refreshControlCharacteristics();
+            });
+        }, 750);
+        this.speedUpdateTimer.unref();
+    }
+    cancelPendingSpeedUpdate() {
+        clearTimeout(this.speedUpdateTimer);
+        this.speedUpdateTimer = undefined;
+        this.pendingSpeedKph = undefined;
     }
     updateStatus({ status }) {
         const { Characteristic } = this.api.hap;
@@ -105,19 +148,28 @@ export class TreadmillAccessory {
         this.fanService.updateCharacteristic(Characteristic.Active, this.isActive());
         this.fanService.updateCharacteristic(Characteristic.RotationSpeed, this.currentSpeedPercentage());
         this.fanService.updateCharacteristic(Characteristic.CurrentFanState, this.currentFanState());
-        this.fanService.updateCharacteristic(Characteristic.StatusFault, Characteristic.StatusFault.NO_FAULT);
         this.telemetryService.updateStatus(status);
         if (this.config.debug) {
             this.log.debug(`[PiTPAT] Speed updated: ${status.currentSpeedKph.toFixed(1)} km/h, state ${status.runningState}`);
         }
     }
     updateConnectionState(state) {
-        this.fanService.updateCharacteristic(this.api.hap.Characteristic.StatusFault, state === 'ready'
-            ? this.api.hap.Characteristic.StatusFault.NO_FAULT
-            : this.api.hap.Characteristic.StatusFault.GENERAL_FAULT);
+        if (state !== 'ready') {
+            this.cancelPendingSpeedUpdate();
+            this.refreshControlCharacteristics();
+        }
         this.telemetryService.updateConnection(state);
     }
+    refreshControlCharacteristics() {
+        const { Characteristic } = this.api.hap;
+        this.fanService.updateCharacteristic(Characteristic.Active, this.isActive());
+        this.fanService.updateCharacteristic(Characteristic.RotationSpeed, this.currentSpeedPercentage());
+        this.fanService.updateCharacteristic(Characteristic.CurrentFanState, this.currentFanState());
+    }
     effectiveMaximumSpeed(deviceMaximumSpeedKph) {
         return Math.min(this.config.maximumSpeedKph, deviceMaximumSpeedKph);
     }
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/bluetooth/bleManager.js

@@ -172,15 +172,23 @@ export class BleManager extends EventEmitter {
                     resolve(event.status);
                 }
             };
+            const onConnectionState = (state) => {
+                if (state === 'disconnected' || state === 'disconnecting') {
+                    cleanup();
+                    reject(new Error('BLE disconnected while waiting for treadmill confirmation'));
+                }
+            };
             const cleanup = () => {
                 clearTimeout(timer);
                 this.removeListener('status', onStatus);
+                this.removeListener('connectionState', onConnectionState);
             };
             const timer = setTimeout(() => {
                 cleanup();
                 reject(new Error('timed out waiting for treadmill confirmation'));
             }, timeoutMs);
             this.on('status', onStatus);
+            this.on('connectionState', onConnectionState);
         });
     }
     scheduleReconnect() {

package/dist/bluetooth/nobleTransport.d.ts

@@ -1,7 +1,11 @@
+import type { Logger } from 'homebridge';
 import type { BleConnection, BleTransport } from './transport.js';
 export declare class NobleTransport implements BleTransport {
+    private readonly log;
     private noble?;
+    constructor(log: Pick<Logger, 'warn'>);
     private loadNoble;
     connect(deviceIdentifier: string, timeoutMs: number): Promise<BleConnection>;
+    private ensurePoweredOn;
     private findPeripheral;
 }

package/dist/bluetooth/nobleTransport.js

@@ -39,7 +39,11 @@ class NobleConnection {
     }
 }
 export class NobleTransport {
+    log;
     noble;
+    constructor(log) {
+        this.log = log;
+    }
     async loadNoble() {
         if (!this.noble) {
             const module = await import('@stoprocent/noble');
@@ -49,7 +53,7 @@ export class NobleTransport {
     }
     async connect(deviceIdentifier, timeoutMs) {
         const noble = await this.loadNoble();
-        await noble.waitForPoweredOnAsync(timeoutMs);
+        await this.ensurePoweredOn(noble, timeoutMs);
         const peripheral = await this.findPeripheral(noble, deviceIdentifier, timeoutMs);
         await peripheral.connectAsync();
         try {
@@ -71,6 +75,25 @@ export class NobleTransport {
             throw error;
         }
     }
+    async ensurePoweredOn(noble, timeoutMs) {
+        try {
+            await noble.waitForPoweredOnAsync(timeoutMs);
+            return;
+        }
+        catch (error) {
+            if (noble.state === 'unauthorized' || noble.state === 'unsupported') {
+                throw error;
+            }
+            this.log.warn(`[PiTPAT] BLE adapter state is ${noble.state}; attempting one controller reset`);
+            noble.reset();
+            try {
+                await noble.waitForPoweredOnAsync(Math.min(timeoutMs, 10_000));
+            }
+            catch (recoveryError) {
+                throw new Error(`BLE adapter did not recover after reset (state ${noble.state}): ${errorMessage(recoveryError)}`, { cause: recoveryError });
+            }
+        }
+    }
     async findPeripheral(noble, configuredIdentifier, timeoutMs) {
         const expected = normalizeIdentifier(configuredIdentifier);
         return await new Promise((resolve, reject) => {
@@ -111,3 +134,6 @@ export class NobleTransport {
         });
     }
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/platform.js

@@ -40,7 +40,7 @@ export class PitPatPlatform {
             accessory = new this.api.platformAccessory(config.name, uuid, 3 /* this.api.hap.Categories.FAN */);
             this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
         }
-        this.bleManager = new BleManager(config, new NobleTransport(), this.log);
+        this.bleManager = new BleManager(config, new NobleTransport(this.log), this.log);
         new TreadmillAccessory(accessory, this.bleManager, config, this.api, this.log);
         void this.bleManager.start().catch(() => undefined);
         const staleAccessories = [...this.cachedAccessories.values()].filter((cached) => cached.UUID !== uuid);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-pitpat-treadmill",
   "displayName": "PitPat Treadmill",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Local Homebridge integration for PitPat treadmills over Bluetooth Low Energy.",
   "type": "module",
   "main": "dist/index.js",