incyclist-devices 2.3.0-beta.10 → 2.3.0-beta.12

package/lib/ble/base/interface.d.ts

@@ -42,7 +42,7 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     getBinding(): BleBinding;
     protected autoConnect(): void;
     connect(reconnect?: boolean): Promise<boolean>;
-    disconnect(cleanup?: boolean): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     registerConnected(peripheral: IBlePeripheral): void;
     protected isConnecting(): boolean;
@@ -59,6 +59,8 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected reconnect(): Promise<void>;
     protected startPeripheralScan(retry?: boolean): Promise<void>;
     protected stopPeripheralScan(): Promise<void>;
+    protected emitDisconnectAllPeripherals(): void;
+    protected disconnectAllPeripherals(): Promise<void>;
     protected isDiscovering(): boolean;
     protected discoverPeripherals(): Promise<void>;
     protected onPeripheralFound(peripheral: BleRawPeripheral): void;

package/lib/ble/base/interface.js

@@ -110,21 +110,24 @@ class BleInterface extends events_1.default {
             return success;
         });
     }
-    disconnect(cleanup) {
+    disconnect(connectionLost) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (!this.getBinding()) {
                 return false;
             }
-            if (!this.isConnected() && !cleanup)
+            if (!this.isConnected() && !connectionLost)
                 return true;
-            if (!cleanup)
+            if (!connectionLost)
                 this.logEvent({ message: 'disconnect request' });
             this.emit('disconnect-request');
             yield this.stopPeripheralScan();
-            const promises = this.connectedPeripherals.map(p => p.disconnect());
-            yield Promise.allSettled(promises);
-            this.connectedPeripherals = [];
+            if (connectionLost) {
+                this.emitDisconnectAllPeripherals();
+            }
+            else {
+                yield this.disconnectAllPeripherals();
+            }
             if (this.isConnecting())
                 yield ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.stop());
             this.getBinding().removeAllListeners();
@@ -274,6 +277,20 @@ class BleInterface extends events_1.default {
             });
         });
     }
+    emitDisconnectAllPeripherals() {
+        this.connectedPeripherals.forEach(p => {
+            const peripheral = p.getPeripheral();
+            peripheral.emit('disconnect');
+        });
+        this.connectedPeripherals = [];
+    }
+    disconnectAllPeripherals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = this.connectedPeripherals.map(p => p.disconnect());
+            yield Promise.allSettled(promises);
+            this.connectedPeripherals = [];
+        });
+    }
     isDiscovering() {
         var _a;
         return ((_a = this.discoverTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
@@ -369,11 +386,11 @@ class BleInterface extends events_1.default {
             try {
                 peripheral.on('error', (err) => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'Device error', error: err.message });
+                    this.logEvent({ message: 'peripheral error', error: err.message });
                 });
                 peripheral.on('disconnect', () => {
                     peripheral.removeAllListeners();
-                    this.logEvent({ message: 'Device disconnected' });
+                    this.logEvent({ message: 'peripheral disconnected' });
                 });
                 yield peripheral.connectAsync();
                 if (peripheral.discoverServicesAsync !== undefined) {

package/lib/ble/base/peripheral.d.ts

@@ -11,14 +11,17 @@ export declare class BlePeripheral implements IBlePeripheral {
         callback: (data: Buffer) => void;
     }>;
     protected disconnecting: boolean;
+    protected onErrorHandler: any;
     constructor(announcement: BlePeripheralAnnouncement);
     get services(): BleService[];
-    protected getPeripheral(): BleRawPeripheral;
+    getPeripheral(): BleRawPeripheral;
     connect(): Promise<boolean>;
-    disconnect(): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     isConnecting(): boolean;
     onDisconnect(callback: () => void): void;
+    protected onPeripheralDisconnect(): Promise<void>;
+    protected onPeripheralError(err: Error): void;
     discoverServices(): Promise<string[]>;
     discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
     subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
@@ -27,7 +30,7 @@ export declare class BlePeripheral implements IBlePeripheral {
     discoverAllCharacteristics(): Promise<string[]>;
     discoverSomeCharacteristics(characteristics: string[]): Promise<string[]>;
     subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
-    unsubscribeAll(): Promise<boolean>;
+    unsubscribeAll(connectionLost?: boolean): Promise<void>;
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
     protected getRawCharacteristic(uuid: string): BleRawCharacteristic;

package/lib/ble/base/peripheral.js

@@ -19,6 +19,7 @@ class BlePeripheral {
         this.characteristics = {};
         this.subscribed = [];
         this.disconnecting = false;
+        this.onErrorHandler = this.onPeripheralError.bind(this);
         this.ble = interface_1.BleInterface.getInstance();
     }
     get services() {
@@ -31,28 +32,37 @@ class BlePeripheral {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isConnected())
                 return true;
-            yield this.getPeripheral().connectAsync();
+            const peripheral = this.getPeripheral();
+            yield peripheral.connectAsync();
             this.ble.registerConnected(this);
+            peripheral.once('disconnect', () => { this.onPeripheralDisconnect(); });
+            peripheral.on('error', this.onErrorHandler);
             this.connected = true;
             return this.connected;
         });
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             this.disconnecting = true;
             if (!this.isConnected())
                 return true;
-            yield this.unsubscribeAll();
+            yield this.unsubscribeAll(connectionLost);
             Object.keys(this.characteristics).forEach(uuid => {
                 const c = this.characteristics[uuid];
                 c.removeAllListeners();
             });
-            if (!this.getPeripheral().disconnectAsync) {
-                this.getPeripheral().disconnectAsync = () => {
-                    return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
-                };
+            const peripheral = this.getPeripheral();
+            if (peripheral) {
+                if (!connectionLost) {
+                    if (!peripheral.disconnectAsync) {
+                        peripheral.disconnectAsync = () => {
+                            return new Promise((done) => { this.getPeripheral().disconnect(() => { done(); }); });
+                        };
+                    }
+                    yield this.getPeripheral().disconnectAsync();
+                }
+                peripheral.removeAllListeners();
             }
-            yield this.getPeripheral().disconnectAsync();
             this.connected = false;
             this.disconnecting = false;
             return !this.connected;
@@ -67,6 +77,20 @@ class BlePeripheral {
     onDisconnect(callback) {
         this.onDisconnectHandler = callback;
     }
+    onPeripheralDisconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'disconnect' });
+            try {
+                yield this.disconnect(true);
+            }
+            catch (_a) { }
+            if (this.onDisconnectHandler)
+                this.onDisconnectHandler();
+        });
+    }
+    onPeripheralError(err) {
+        this.logEvent({ message: 'peripheral error', error: err.message });
+    }
     discoverServices() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.getPeripheral().discoverServicesAsync) {
@@ -184,16 +208,16 @@ class BlePeripheral {
                     yield this.discoverAllCharacteristics();
                 }
                 const retry = [];
-                for (let i = 0; i < characteristics.length; i++) {
-                    const c = this.getRawCharacteristic(characteristics[i]);
+                for (const element of characteristics) {
+                    const c = this.getRawCharacteristic(element);
                     if (c === null || c === void 0 ? void 0 : c.properties.includes('notify')) {
                         const success = yield this.subscribe(c.uuid, callback);
                         if (!success)
                             retry.push(c);
                     }
                 }
-                for (let i = 0; i < retry.length; i++) {
-                    const c = retry[i];
+                for (const element of retry) {
+                    const c = element;
                     yield this.subscribe(c.uuid, callback);
                 }
                 return true;
@@ -247,13 +271,16 @@ class BlePeripheral {
         });
     }
     unsubscribeAll() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
+            if (connectionLost) {
+                this.subscribed = [];
+                return;
+            }
             const promises = [];
             this.subscribed.forEach(d => {
                 promises.push(this.unsubscribe(d.uuid));
             });
             yield Promise.allSettled(promises);
-            return true;
         });
     }
     read(characteristicUUID) {
@@ -305,6 +332,8 @@ class BlePeripheral {
         return this.characteristics[(0, utils_1.beautifyUUID)(uuid)];
     }
     logEvent(event) {
+        var _a;
+        event.peripheral = (_a = this.announcement) === null || _a === void 0 ? void 0 : _a.name;
         this.ble.logEvent(event);
     }
 }

package/lib/ble/base/sensor.js

@@ -101,11 +101,19 @@ class TBleSensor extends events_1.default {
     }
     reconnectSensor() {
         return __awaiter(this, void 0, void 0, function* () {
+            let connected = false;
+            let subscribed = false;
             let success = false;
             do {
-                success = yield this.startSensor(true);
+                if (!connected) {
+                    connected = yield this.startSensor(true);
+                }
+                if (connected && !subscribed) {
+                    subscribed = yield this.subscribe();
+                }
+                success = connected && subscribed;
                 if (!success) {
-                    yield (0, utils_1.sleep)(5000);
+                    yield (0, utils_1.sleep)(1000);
                 }
             } while (!success || this.stopRequested);
         });
@@ -119,10 +127,16 @@ class TBleSensor extends events_1.default {
     }
     read(characteristicUUID) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.read(characteristicUUID);
     }
     write(characteristicUUID, data, options) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.write(characteristicUUID, data, options);
     }
     onData(characteristic, data) {

package/lib/ble/fm/sensor.js

@@ -100,8 +100,6 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
             if (this.data.targetPower !== undefined && this.data.targetPower === power)
                 return true;
-            if (!this.hasControl)
-                return;
             const hasControl = yield this.requestControl();
             if (!hasControl) {
                 this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
@@ -111,15 +109,15 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             data.writeUInt8(5, 0);
             data.writeInt16LE(Math.round(power), 1);
             const res = yield this.writeFtmsMessage(5, data);
+            if (res === 5) {
+                this.hasControl = false;
+            }
             return (res === 1);
         });
     }
     setSlope(slope) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'setSlope', slope });
-            const hasControl = yield this.requestControl();
-            if (!hasControl)
-                return;
             const { windSpeed, crr, cw } = this;
             return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
         });
@@ -331,6 +329,9 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             data.writeUInt8(Math.round(crr * 10000), 5);
             data.writeUInt8(Math.round(cw * 100), 6);
             const res = yield this.writeFtmsMessage(17, data);
+            if (res === 5) {
+                this.hasControl = false;
+            }
             return (res === 1);
         });
     }

package/lib/ble/tacx/sensor.js

@@ -452,8 +452,14 @@ class TacxAdvancedFitnessMachineDevice extends sensor_1.default {
     sendMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'write', characteristic: this.tacxTx, data: message.toString('hex') });
-            yield this.write(this.tacxTx, message, { withoutResponse: true });
-            return true;
+            try {
+                yield this.write(this.tacxTx, message, { withoutResponse: true });
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'write failed', characteristic: this.tacxTx, reason: err.message });
+                return false;
+            }
         });
     }
     sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio) {

package/lib/direct-connect/base/peripheral.d.ts

@@ -21,7 +21,7 @@ export declare class DirectConnectPeripheral implements IBlePeripheral {
     constructor(announcement: MulticastDnsAnnouncement);
     get services(): BleService[];
     connect(): Promise<boolean>;
-    disconnect(): Promise<boolean>;
+    disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;
     isConnecting(): boolean;
     onDisconnect(callback: () => void): void;
@@ -31,14 +31,14 @@ export declare class DirectConnectPeripheral implements IBlePeripheral {
     unsubscribe(characteristicUUID: string): Promise<boolean>;
     subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
     subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
-    unsubscribeAll(): Promise<boolean>;
+    unsubscribeAll(connectionLost?: boolean): Promise<void>;
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
     protected startConnection(): Promise<boolean>;
     protected onPortError(err: Error): void;
     protected onPortClose(): Promise<void>;
     protected getPath(): string;
-    protected stopConnection(): Promise<boolean>;
+    protected stopConnection(connectionLost?: boolean): Promise<boolean>;
     protected getNextSeqNo(): number;
     protected send(seqNo: number, data: Buffer): Promise<Buffer>;
     protected getNextMessage(data: Buffer): Buffer;

package/lib/direct-connect/base/peripheral.js

@@ -55,10 +55,10 @@ class DirectConnectPeripheral {
         });
     }
     disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             try {
                 yield this.connectTask.stop();
-                yield this.stopConnection();
+                yield this.stopConnection(connectionLost);
                 delete this.socket;
             }
             catch (err) {
@@ -285,13 +285,16 @@ class DirectConnectPeripheral {
         });
     }
     unsubscribeAll() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
+            if (connectionLost) {
+                this.subscribed = [];
+                return;
+            }
             const promises = [];
             this.subscribed.forEach(characteristicUUID => {
                 promises.push(this.unsubscribe((0, utils_1.parseUUID)(characteristicUUID)));
             });
             yield Promise.allSettled(promises);
-            return true;
         });
     }
     read(characteristicUUID) {
@@ -397,9 +400,10 @@ class DirectConnectPeripheral {
     onPortClose() {
         return __awaiter(this, void 0, void 0, function* () {
             this.socket.removeAllListeners();
+            this.socket.on('error', () => { });
             this.logEvent({ message: 'port closed', path: this.getPath() });
             try {
-                yield this.disconnect();
+                yield this.disconnect(true);
             }
             catch (_a) { }
             if (this.onDisconnectHandler)
@@ -412,11 +416,11 @@ class DirectConnectPeripheral {
         return path;
     }
     stopConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (connectionLost = false) {
             this.eventEmitter.removeAllListeners();
             if (!this.isConnected())
                 return true;
-            yield this.unsubscribeAll();
+            yield this.unsubscribeAll(connectionLost);
             this.socket.removeAllListeners();
             return new Promise(done => {
                 const onClosed = () => {

package/lib/modes/ant-fe-adv-st-mode.d.ts

@@ -3,8 +3,8 @@ import SmartTrainerCyclingMode from "./antble-smarttrainer";
 import { UpdateRequest } from "./types";
 export default class AntAdvSimCyclingMode extends SmartTrainerCyclingMode {
     constructor(adapter: IncyclistDeviceAdapter, props?: any);
-    getName(): string;
     getDescription(): string;
+    getConfig(): import("./types").CyclingModeConfig;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
     protected checkForTempPowerAdjustments(request: UpdateRequest, newRequest?: UpdateRequest): void;
     protected checkEmptyRequest(newRequest: UpdateRequest): void;

package/lib/modes/ant-fe-adv-st-mode.js

@@ -10,12 +10,14 @@ class AntAdvSimCyclingMode extends antble_smarttrainer_1.default {
         super(adapter, props);
         this.initLogger('AdvmartTrainerMode');
     }
-    getName() {
-        return 'Advanced Smart Trainer';
-    }
     getDescription() {
         return 'Sends Slope to device. Respects Limits (from workout or settings). Calculates speed based on power and slope. ';
     }
+    getConfig() {
+        const config = super.getConfig();
+        config.name = 'Advanced Smart Trainer';
+        return config;
+    }
     checkForResetOrEmpty(request) {
         if (!request || request.reset) {
             this.prevRequest = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.3.0-beta.10",
+  "version": "2.3.0-beta.12",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",