incyclist-devices 2.1.7 → 2.1.9

package/lib/antv2/base/interface.js

@@ -176,15 +176,17 @@ class AntInterface extends events_1.default {
                         }
                     }
                 };
+                const onData = this.onData.bind(this);
+                const onError = this.onError.bind(this);
                 const addListeners = (channel) => {
                     channel.on('detected', onDetected);
-                    channel.on('data', this.onData.bind(this));
-                    channel.on('error', this.onError.bind(this));
+                    channel.on('data', onData);
+                    channel.on('error', onError);
                 };
                 const removeListeners = (channel) => {
                     channel.off('detected', onDetected);
-                    channel.off('data', this.onData.bind(this));
-                    channel.off('error', this.onError.bind(this));
+                    channel.off('data', onData);
+                    channel.off('error', onError);
                 };
                 yield this.scannerWaitForConnection();
                 if (!this.isConnected()) {
@@ -255,8 +257,10 @@ class AntInterface extends events_1.default {
     stopScan() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'stopping scan ..' });
-            if (!this.isScanning())
+            if (!this.isScanning()) {
+                this.logEvent({ message: 'stopping scan done ..' });
                 return true;
+            }
             return new Promise(done => {
                 this.activeScan.emitter.emit('stop');
                 this.once('scan stopped', (res) => {

package/lib/base/adpater.js

@@ -76,9 +76,10 @@ class IncyclistDevice extends events_1.default {
         });
     }
     resume() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isStarted() && !this.isStopped())
-                this.logger.logEvent({ message: 'resuming device', device: this.getName() });
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.logEvent({ message: 'resuming device', device: this.getName() });
             this.paused = false;
             return true;
         });

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

@@ -12,6 +12,7 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     protected dataMsgCount: number;
     protected lastDataTS: number;
     protected device: TDevice;
+    protected onDeviceDataHandler: any;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     getUniqueName(): string;
     connect(): Promise<boolean>;
@@ -32,7 +33,8 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     getSettings(): BleDeviceSettings;
     setProperties(props: BleDeviceProperties): void;
     check(): Promise<boolean>;
-    start(props?: BleStartProperties): Promise<any>;
+    startPreChecks(props: BleStartProperties): Promise<'done' | 'connected' | 'connection-failed'>;
+    start(props?: BleStartProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;

package/lib/ble/base/adapter.js

@@ -18,6 +18,7 @@ const INTERFACE_NAME = 'ble';
 class BleAdapter extends adpater_1.default {
     constructor(settings, props) {
         super(settings, props);
+        this.onDeviceDataHandler = this.onDeviceData.bind(this);
         if (this.settings.interface !== INTERFACE_NAME)
             throw new Error('Incorrect interface');
         this.deviceData = {};
@@ -139,23 +140,38 @@ class BleAdapter extends adpater_1.default {
     check() {
         return this.start({ scanOnly: true });
     }
-    start(props = {}) {
+    startPreChecks(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            const wasPaused = this.paused;
             const wasStopped = this.stopped;
-            this.resume();
-            if (this.started && !wasStopped)
-                return true;
             this.stopped = false;
+            if (wasPaused)
+                this.resume();
+            if (this.started && !wasPaused && !wasStopped) {
+                return 'done';
+            }
+            if (this.started && wasPaused) {
+                return 'done';
+            }
             const connected = yield this.connect();
             if (!connected)
+                return 'connection-failed';
+            return 'connected';
+        });
+    }
+    start(props = {}) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const preCheckResult = yield this.startPreChecks(props);
+            if (preCheckResult === 'done')
+                return this.started;
+            if (preCheckResult === 'connection-failed')
                 throw new Error(`could not start device, reason:could not connect`);
-            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            this.logEvent({ message: 'starting device', device: this.getName(), props, isStarted: this.started });
             try {
                 const comms = this.device;
                 if (comms) {
-                    comms.on('data', (data) => {
-                        this.onDeviceData(data);
-                    });
+                    comms.on('data', this.onDeviceDataHandler);
                     this.resetData();
                     this.stopped = false;
                     this.started = true;
@@ -165,14 +181,16 @@ class BleAdapter extends adpater_1.default {
             }
             catch (err) {
                 this.logger.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
+                (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.pause();
                 throw new Error(`could not start device, reason:${err.message}`);
             }
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stop requested', protocol: this.getProtocolName() });
+            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.device.reset();
+            this.device.off('data', this.onDeviceDataHandler);
             const stopped = this.device.disconnect();
             if (stopped) {
                 this.stopped = true;

package/lib/ble/bindings/linux.d.ts

@@ -9,6 +9,7 @@ export declare class BleLinuxBinding extends EventEmitter implements BleBinding
     static getInstance(): any;
     startScanning(serviceUUIDs?: string[] | undefined, allowDuplicates?: boolean | undefined, callback?: ((error?: Error | undefined) => void) | undefined): void;
     stopScanning(callback?: (() => void) | undefined): void;
+    setServerDebug(enabled: boolean): void;
     pauseLogging(): void;
     resumeLogging(): void;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;

package/lib/ble/bindings/linux.js

@@ -23,6 +23,8 @@ class BleLinuxBinding extends events_1.default {
     stopScanning(callback) {
         throw new Error('Method not implemented.');
     }
+    setServerDebug(enabled) {
+    }
     pauseLogging() {
     }
     resumeLogging() {

package/lib/ble/bindings/mock.js

@@ -29,6 +29,8 @@ class Binding extends events_1.default {
         return Binding._instance;
     }
     init() { }
+    setServerDebug(enabled) {
+    }
     pauseLogging() {
     }
     resumeLogging() {

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

@@ -14,6 +14,7 @@ export interface ScanState {
     timeout?: NodeJS.Timeout;
     peripherals?: Map<string, BlePeripheral>;
     detected?: string[];
+    emitter?: EventEmitter;
 }
 export interface ConnectState {
     isConnecting: boolean;
@@ -54,24 +55,25 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     getBinding(): BleBinding;
     setBinding(binding: BleBinding): void;
     getName(): string;
+    protected getReconnectPause(): number;
     startConnectSensor(): void;
     stopConnectSensor(): void;
     waitForSensorConnectionFinish(): Promise<void>;
     getAdapterFactory(): BleAdapterFactory;
-    pauseLogging(): void;
+    pauseLogging(debugOnly?: boolean): void;
     resumeLogging(): void;
-    isDebugEnabled(): boolean;
-    logEvent(event: any): void;
-    onStateChange(state: BleInterfaceState): void;
-    onError(err: any): void;
+    protected isDebugEnabled(): boolean;
+    protected logEvent(event: any): void;
+    protected onStateChange(state: BleInterfaceState): void;
+    protected onError(err: any): void;
     connect(to?: number): Promise<boolean>;
     disconnect(): Promise<boolean>;
     isConnected(): boolean;
-    waitForConnectFinished(timeout: any): Promise<unknown>;
     onDisconnect(peripheral: any): void;
-    getCharacteristics(peripheral: BlePeripheral): Promise<BleCharacteristic[]>;
-    waitForScanFinished(timeout: any): Promise<unknown>;
-    onPeripheralFound(p: BlePeripheral, callback: any, props?: {
+    protected scannerWaitForConnection(tsTimeoutExpired?: number): Promise<void>;
+    protected getCharacteristics(peripheral: BlePeripheral): Promise<BleCharacteristic[]>;
+    protected waitForScanFinished(timeout: any): Promise<unknown>;
+    protected onPeripheralFound(p: BlePeripheral, callback: any, props?: {
         request?: BleDeviceSettings;
         comms?: BleComms;
         protocolFilter?: BleProtocol[] | null;

package/lib/ble/ble-interface.js

@@ -59,6 +59,9 @@ class BleInterface extends events_1.default {
     getName() {
         return 'ble';
     }
+    getReconnectPause() {
+        return 1000;
+    }
     startConnectSensor() {
         this.sensorIsConnecting = true;
     }
@@ -76,15 +79,19 @@ class BleInterface extends events_1.default {
     getAdapterFactory() {
         return adapter_factory_1.default.getInstance();
     }
-    pauseLogging() {
-        this.logEvent({ message: 'pause logging on BLE Interface' });
-        this.loggingPaused = true;
+    pauseLogging(debugOnly = false) {
+        if (this.loggingPaused)
+            return;
+        this.logEvent({ message: 'pause logging on BLE Interface', debugOnly });
+        this.loggingPaused = debugOnly;
         try {
             this.getBinding().pauseLogging();
         }
         catch (_a) { }
     }
     resumeLogging() {
+        if (!this.loggingPaused)
+            return;
         const event = { message: 'resume logging on BLE Interface' };
         this.logger.logEvent(event);
         if (this.isDebugEnabled()) {
@@ -221,25 +228,23 @@ class BleInterface extends events_1.default {
     isConnected() {
         return this.connectState.isConnected;
     }
-    waitForConnectFinished(timeout) {
-        const waitStart = Date.now();
-        const waitTimeout = waitStart + timeout;
-        return new Promise((resolve, reject) => {
-            const waitIv = setInterval(() => {
-                if (this.scanState.isConnecting && Date.now() > waitTimeout) {
-                    clearInterval(waitIv);
-                    return reject(new Error('Connecting already in progress'));
-                }
-                if (!this.scanState.isConnecting) {
-                    clearInterval(waitIv);
-                    return resolve(true);
-                }
-            }, 100);
-        });
-    }
     onDisconnect(peripheral) {
         this.peripheralCache.remove(peripheral);
     }
+    scannerWaitForConnection(tsTimeoutExpired) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timeoutExpired = () => {
+                if (!tsTimeoutExpired)
+                    return false;
+                return Date.now() >= tsTimeoutExpired;
+            };
+            while (!this.isConnected() && this.scanState.isScanning && !timeoutExpired()) {
+                const connected = yield this.connect();
+                if (!connected)
+                    yield (0, utils_2.sleep)(this.getReconnectPause());
+            }
+        });
+    }
     getCharacteristics(peripheral) {
         return __awaiter(this, void 0, void 0, function* () {
             let characteristics = undefined;
@@ -369,6 +374,10 @@ class BleInterface extends events_1.default {
             const request = comms.getSettings();
             const { protocol } = request;
             const ble = this.getBinding();
+            try {
+                this.getBinding().setServerDebug(true);
+            }
+            catch (_a) { }
             if (!this.isConnected()) {
                 yield this.connect();
             }
@@ -401,6 +410,10 @@ class BleInterface extends events_1.default {
                     this.logEvent({ message: `${opStr}: stop scanning`, request });
                     ble.stopScanning(() => {
                         this.scanState.isScanning = false;
+                        try {
+                            this.getBinding().setServerDebug(false);
+                        }
+                        catch (_a) { }
                         reject(new Error('device not found'));
                         return;
                     });
@@ -430,6 +443,10 @@ class BleInterface extends events_1.default {
                                 ble.stopScanning(() => {
                                     ble.removeAllListeners('discover');
                                     this.scanState.isScanning = false;
+                                    try {
+                                        this.getBinding().setServerDebug(false);
+                                    }
+                                    catch (_a) { }
                                     resolve(peripheral);
                                 });
                             });
@@ -447,13 +464,17 @@ class BleInterface extends events_1.default {
     }
     scan(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = DEFAULT_SCAN_TIMEOUT, protocol, protocols } = props;
+            this.resumeLogging();
+            this.logEvent({ message: 'starting scan ..' });
+            const { timeout, protocol, protocols } = props;
             const requestedProtocols = protocols || [];
             if (protocol && !requestedProtocols.find(p => p === protocol))
                 requestedProtocols.push(protocol);
             const protocolFilter = requestedProtocols.length > 0 ? requestedProtocols : null;
             const services = protocolFilter === null ? this.getAdapterFactory().getAllSupportedServices() : (0, comms_utils_1.getServicesFromProtocols)(protocolFilter);
             const ble = this.getBinding();
+            if (!ble)
+                throw new Error('no binding defined');
             const opStr = 'scan';
             if (this.scanState.isScanning) {
                 try {
@@ -466,49 +487,49 @@ class BleInterface extends events_1.default {
                 }
             }
             this.scanState.isScanning = true;
+            this.scanState.emitter = new events_1.default();
             const tsStart = Date.now();
-            const tsTimeoutExpired = tsStart + timeout;
-            while (!this.isConnected() && this.scanState.isScanning && Date.now() < tsTimeoutExpired) {
-                const connected = yield this.connect();
-                if (!connected)
-                    yield (0, utils_2.sleep)(1000);
-            }
-            if (Date.now() > tsTimeoutExpired) {
-                return [];
-            }
-            if (!this.scanState.isScanning) {
+            const tsTimeoutExpired = timeout ? tsStart + timeout : undefined;
+            yield this.scannerWaitForConnection(tsTimeoutExpired);
+            if (Date.now() > tsTimeoutExpired || !this.scanState.isScanning) {
                 return [];
             }
-            const adjustedScanTimeout = tsStart - Date.now() + timeout;
+            const adjustedScanTimeout = timeout;
             const supported = adapter_factory_1.default.getInstance().getAll().map(i => i.protocol);
             this.logEvent({ message: 'scan start', services, supported });
             return new Promise((resolve, reject) => {
                 this.scanState.peripherals = new Map();
                 const detected = [];
                 const requested = protocolFilter;
-                const onTimeout = () => {
+                const onTimeoutOrStopped = (wasTimeout = false) => __awaiter(this, void 0, void 0, function* () {
                     if (!this.scanState.isScanning || !this.scanState.timeout)
                         return;
-                    this.scanState.timeout = null;
+                    if (this.scanState.timeout) {
+                        clearTimeout(this.scanState.timeout);
+                        this.scanState.timeout = null;
+                    }
                     const devices = detected.map(d => {
                         const { id, name, address, protocol } = d;
                         return { id, name, address, protocol };
                     });
-                    this.logEvent({ message: `${opStr} result: timeout, devices found`, requested, devices });
+                    if (wasTimeout)
+                        this.logEvent({ message: `${opStr} result: timeout, devices found`, requested, devices });
                     ble.removeAllListeners('discover');
-                    this.logEvent({ message: `${opStr}: stop scanning`, requested });
-                    ble.stopScanning(() => {
-                        this.scanState.isScanning = false;
-                        resolve(detected);
-                    });
+                    yield ble.stopScanning();
+                    resolve(detected);
                     this.emittingAdapters.forEach(a => {
                         a.comms.off('data', a.cb);
                         a.comms.unsubscribeAll();
                     });
                     this.emittingAdapters = [];
-                };
-                this.logEvent({ message: `${opStr}: start scanning`, requested, timeout });
-                this.scanState.timeout = setTimeout(onTimeout, adjustedScanTimeout);
+                    this.emit('scan stopped', true);
+                });
+                if (timeout)
+                    this.scanState.timeout = setTimeout(onTimeoutOrStopped, adjustedScanTimeout);
+                this.scanState.emitter.on('stop', () => {
+                    this.emit('stop-scan');
+                    onTimeoutOrStopped();
+                });
                 ble.startScanning(protocolFilter ? services : [], false, (err) => {
                     if (err) {
                         this.logEvent({ message: `${opStr} result: error`, requested, error: err.message });
@@ -546,24 +567,21 @@ class BleInterface extends events_1.default {
     }
     stopScan() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'scan stop request' });
-            if (!this.scanState.isScanning) {
-                this.logEvent({ message: 'scan stop result: not scanning' });
+            this.logEvent({ message: 'stopping scan ..' });
+            this.pauseLogging(true);
+            if (!this.isScanning()) {
+                this.logEvent({ message: 'stopping scan done ..' });
                 return true;
             }
-            const ble = this.getBinding();
-            if (!ble)
-                throw new Error('no binding defined');
-            ble.removeAllListeners('discover');
-            this.peripheralCache.handleStopScan();
-            ble.stopScanning();
-            this.emittingAdapters.forEach(a => {
-                a.comms.unsubscribeAll();
-                a.comms.off('data', a.cb);
+            yield new Promise(done => {
+                var _a;
+                (_a = this.scanState.emitter) === null || _a === void 0 ? void 0 : _a.emit('stop');
+                this.once('scan stopped', (res) => {
+                    done(res);
+                });
             });
-            this.emittingAdapters = [];
             this.scanState.isScanning = false;
-            this.logEvent({ message: 'scan stop result: success' });
+            this.logEvent({ message: 'stopping scan done ..' });
             return true;
         });
     }

package/lib/ble/cp/comm.js

@@ -18,8 +18,9 @@ class BleCyclingPowerDevice extends comms_1.BleComms {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasCPMeasurement = characteristics.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
-        const hasCPFeature = characteristics.find(c => c === consts_1.CSP_FEATURE) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasCPMeasurement = announced.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
+        const hasCPFeature = announced.find(c => c === consts_1.CSP_FEATURE) !== undefined;
         return hasCPMeasurement && hasCPFeature;
     }
     getProfile() {

package/lib/ble/elite/comms.js

@@ -19,8 +19,9 @@ class BleEliteDevice extends comms_1.BleComms {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasCPMeasurement = characteristics.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
-        const hasCPFeature = characteristics.find(c => c === consts_1.CSP_FEATURE) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasCPMeasurement = announced.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
+        const hasCPFeature = announced.find(c => c === consts_1.CSP_FEATURE) !== undefined;
         return hasCPMeasurement && hasCPFeature;
     }
     getProfile() {

package/lib/ble/fm/comms.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const consts_1 = require("../consts");
 const comms_1 = require("../base/comms");
+const utils_1 = require("../utils");
 const bit = (nr) => (1 << nr);
 const IndoorBikeDataFlag = {
     MoreData: bit(0),
@@ -82,9 +83,10 @@ class BleFitnessMachineDevice extends comms_1.BleComms {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasStatus = characteristics.find(c => c === consts_1.FTMS_STATUS) !== undefined;
-        const hasCP = characteristics.find(c => c === consts_1.FTMS_CP) !== undefined;
-        const hasIndoorBike = characteristics.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasStatus = announced.find(c => c === consts_1.FTMS_STATUS) !== undefined;
+        const hasCP = announced.find(c => c === consts_1.FTMS_CP) !== undefined;
+        const hasIndoorBike = announced.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
         return hasStatus && hasCP && hasIndoorBike;
     }
     subscribeWriteResponse(cuuid) {

package/lib/ble/hr/comm.d.ts

@@ -14,6 +14,7 @@ export default class BleHrmDevice extends BleComms {
     getProfile(): LegacyProfile;
     getProtocol(): BleProtocol;
     getServiceUUids(): string[];
+    static isMatching(characteristics: string[]): boolean;
     parseHrm(_data: Uint8Array): HrmData;
     onData(characteristic: string, data: Buffer): boolean;
 }

package/lib/ble/hr/comm.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const comms_1 = require("../base/comms");
+const consts_1 = require("../consts");
+const utils_1 = require("../utils");
 class BleHrmDevice extends comms_1.BleComms {
     constructor(props) {
         super(props);
@@ -16,6 +18,13 @@ class BleHrmDevice extends comms_1.BleComms {
     getServiceUUids() {
         return BleHrmDevice.services;
     }
+    static isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasHRMeasurement = announced.find(c => c === consts_1.HR_MEASUREMENT) !== undefined;
+        return hasHRMeasurement;
+    }
     parseHrm(_data) {
         const data = Buffer.from(_data);
         try {
@@ -51,6 +60,6 @@ class BleHrmDevice extends comms_1.BleComms {
 }
 BleHrmDevice.protocol = 'hr';
 BleHrmDevice.services = ['180d'];
-BleHrmDevice.characteristics = ['2a37', '2a38', '2a39', '2a3c'];
+BleHrmDevice.characteristics = [consts_1.HR_MEASUREMENT, '2a38', '2a39', '2a3c'];
 BleHrmDevice.detectionPriority = 1;
 exports.default = BleHrmDevice;

package/lib/ble/tacx/adapter.d.ts

@@ -2,7 +2,7 @@ import { BleFmAdapter } from '../fm';
 import { BleDeviceSettings, BleStartProperties } from '../types';
 import { DeviceProperties, IAdapter } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
-export default class BleTacxFEAdapter extends BleFmAdapter {
+export default class BleTacxAdapter extends BleFmAdapter {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;

package/lib/ble/tacx/adapter.js

@@ -17,7 +17,7 @@ const fm_1 = require("../fm");
 const comms_1 = __importDefault(require("./comms"));
 const consts_1 = require("../../base/consts");
 const types_1 = require("../../types");
-class BleTacxFEAdapter extends fm_1.BleFmAdapter {
+class BleTacxAdapter extends fm_1.BleFmAdapter {
     constructor(settings, props) {
         super(settings, props);
         this.logger = new gd_eventlog_1.EventLogger('BLE-FEC-Tacx');
@@ -31,7 +31,7 @@ class BleTacxFEAdapter extends fm_1.BleFmAdapter {
         ];
     }
     isSame(device) {
-        if (!(device instanceof BleTacxFEAdapter))
+        if (!(device instanceof BleTacxAdapter))
             return false;
         return this.isEqual(device.settings);
     }
@@ -102,5 +102,5 @@ class BleTacxFEAdapter extends fm_1.BleFmAdapter {
         });
     }
 }
-BleTacxFEAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
-exports.default = BleTacxFEAdapter;
+BleTacxAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
+exports.default = BleTacxAdapter;

package/lib/ble/tacx/comms.js

@@ -53,8 +53,9 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasTacxCP = characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
-            characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasTacxCP = announced.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
+            announced.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
         return hasTacxCP;
     }
     setCharacteristicUUIDs(uuids) {

package/lib/ble/types.d.ts

@@ -10,6 +10,7 @@ export interface BleBinding extends EventEmitter {
     stopScanning(callback?: () => void): void;
     pauseLogging(): any;
     resumeLogging(): any;
+    setServerDebug(enabled: boolean): any;
     _bindings: any;
     state: BleInterfaceState;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;

package/lib/ble/wahoo/comms.js

@@ -34,8 +34,9 @@ class BleWahooDevice extends comms_1.default {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasWahooCP = characteristics.find(c => (0, utils_1.matches)(c, consts_2.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
-        const hasFTMS = characteristics.find(c => (0, utils_1.matches)(c, consts_2.FTMS_CP)) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasWahooCP = announced.find(c => (0, utils_1.matches)(c, consts_2.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
+        const hasFTMS = announced.find(c => (0, utils_1.matches)(c, consts_2.FTMS_CP)) !== undefined;
         return hasWahooCP && !hasFTMS;
     }
     init() {

package/lib/serial/daum/DaumAdapter.d.ts

@@ -33,7 +33,7 @@ export default class DaumAdapter<S extends SerialDeviceSettings, P extends Devic
     performCheck(): Promise<boolean>;
     waitForPrevStartFinished(): Promise<void>;
     start(props?: P): Promise<boolean>;
-    performStart(props?: P, isRelaunch?: boolean): Promise<boolean>;
+    performStart(props?: P, isRelaunch?: boolean, wasPaused?: boolean): Promise<boolean>;
     startUpdatePull(): void;
     stopUpdatePull(): void;
     connect(): Promise<boolean>;

package/lib/serial/daum/DaumAdapter.js

@@ -112,9 +112,10 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         const _super = Object.create(null, {
             pause: { get: () => super.pause }
         });
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const paused = yield _super.pause.call(this);
-            this.comms.pauseLogging();
+            (_a = this.comms) === null || _a === void 0 ? void 0 : _a.pauseLogging();
             return paused;
         });
     }
@@ -122,9 +123,10 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         const _super = Object.create(null, {
             resume: { get: () => super.resume }
         });
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const resumed = yield _super.resume.call(this);
-            this.comms.resumeLogging();
+            (_a = this.comms) === null || _a === void 0 ? void 0 : _a.resumeLogging();
             return resumed;
         });
     }
@@ -178,16 +180,20 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         });
     }
     start(props) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.waitForPrevCheckFinished();
             yield this.waitForPrevStartFinished();
             const isRelaunch = this.started;
             const message = isRelaunch ? 'relaunch of device' : 'initial start of device';
-            this.logEvent({ message });
+            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.logEvent({ message });
             try {
-                if (isRelaunch && this.isPaused())
+                let wasPaused = false;
+                if (isRelaunch && this.isPaused()) {
                     this.resume();
-                this.startPromise = this.performStart(props, isRelaunch).then((started) => __awaiter(this, void 0, void 0, function* () {
+                    wasPaused = true;
+                }
+                this.startPromise = this.performStart(props, isRelaunch, wasPaused).then((started) => __awaiter(this, void 0, void 0, function* () {
                     if (!started) {
                         this.logEvent({ message: 'start result: not started' });
                         this.started = false;
@@ -198,7 +204,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
                             const deviceInfo = yield this.getDeviceInfo();
                             this.logEvent({ message: 'device info', deviceInfo });
                         }
-                        catch (_a) { }
+                        catch (_b) { }
                     }
                     this.logEvent({ message: 'start result: success' });
                     this.started = true;
@@ -216,7 +222,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             }
         });
     }
-    performStart(props, isRelaunch = false) {
+    performStart(props, isRelaunch = false, wasPaused = false) {
         throw new Error('Method not implemented.');
     }
     startUpdatePull() {

package/lib/serial/daum/classic/adapter.d.ts

@@ -14,7 +14,7 @@ export default class DaumClassicAdapter extends DaumAdapter<SerialDeviceSettings
     setName(name: string): void;
     getProtocolName(): string;
     performCheck(): Promise<boolean>;
-    performStart(props?: DaumClassicProperties, isRelaunch?: boolean): Promise<boolean>;
+    performStart(props?: DaumClassicProperties, isRelaunch?: boolean, wasPaused?: boolean): Promise<boolean>;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
     getDeviceInfo(): Promise<any>;
 }

package/lib/serial/daum/classic/adapter.js

@@ -92,7 +92,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             });
         });
     }
-    performStart(props = {}, isRelaunch = false) {
+    performStart(props = {}, isRelaunch = false, wasPaused = false) {
         this.stopUpdatePull();
         this.setBikeProps(props);
         const user = this.getUser();

package/lib/serial/daum/premium/adapter.d.ts

@@ -20,7 +20,7 @@ export default class DaumPremiumAdapter extends DaumAdapter<SerialDeviceSettings
     performCheck(): Promise<boolean>;
     getStartRetries(): number;
     getStartRetryTimeout(): number;
-    performStart(props?: DaumPremiumDeviceProperties, _isRelaunch?: boolean): Promise<boolean>;
+    performStart(props?: DaumPremiumDeviceProperties, _isRelaunch?: boolean, wasPaused?: boolean): Promise<boolean>;
     requiresProgramUpload(): boolean;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
     getDeviceInfo(): Promise<any>;

package/lib/serial/daum/premium/adapter.js

@@ -122,14 +122,19 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
     getStartRetryTimeout() {
         return START_RETRY_TIMEOUT;
     }
-    performStart(props = {}, _isRelaunch = false) {
+    performStart(props = {}, _isRelaunch = false, wasPaused = false) {
         return __awaiter(this, void 0, void 0, function* () {
             this.setBikeProps(props);
             this.initData();
-            yield this.stop();
+            if (!wasPaused)
+                yield this.stop();
             var info = {};
             yield (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
+                    if (wasPaused) {
+                        info.deviceType = 'Resumed';
+                        info.version = "Resumed";
+                    }
                     info.connected = yield this.connect();
                     if (!info.connected)
                         throw new Error('not connected');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",