incyclist-devices 2.0.6 → 2.0.8

package/lib/base/adpater.js

@@ -65,8 +65,9 @@ class IncyclistDevice extends events_1.default {
         if (!this.logger || this.paused)
             return;
         this.logger.logEvent(event);
-        if (process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
-            const logText = '~~~' + this.getInterface().toUpperCase();
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
+            const logText = '~~~ ' + this.getInterface().toUpperCase();
             console.log(logText, event);
         }
     }

package/lib/ble/base/comms.js

@@ -88,8 +88,9 @@ class BleComms extends events_1.default {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~~BLE:', event);
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ BLE', event);
         }
     }
     setLogger(logger) {
@@ -203,12 +204,12 @@ class BleComms extends events_1.default {
                     yield connector.connect();
                     if (disconnectSignalled)
                         return;
-                    yield connector.initialize();
-                    if (disconnectSignalled)
-                        return;
+                    const initialized = yield connector.initialize();
+                    if (!initialized || disconnectSignalled)
+                        return done(false);
                     yield this.subscribeAll(connector);
                     if (disconnectSignalled)
-                        return;
+                        return done(false);
                     this.connectState.isConnected = true;
                     this.state = "connected";
                     this.emit('connected');
@@ -229,6 +230,7 @@ class BleComms extends events_1.default {
         });
     }
     subscribeMultiple(characteristics, conn) {
+        this.logEvent({ message: 'subscribe', characteristics });
         return new Promise(resolve => {
             try {
                 const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
@@ -317,6 +319,9 @@ class BleComms extends events_1.default {
                     const { id, name, address } = this;
                     try {
                         this.peripheral = this.ble.peripheralCache.getPeripheral({ id, name, address });
+                        const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+                        if (!connector) {
+                        }
                     }
                     catch (err) {
                         this.logEvent({ message: 'error', fn: 'connect()', error: err.message, stack: err.stack });
@@ -342,7 +347,7 @@ class BleComms extends events_1.default {
                             if (this.ble.isScanning()) {
                                 yield this.ble.stopScan();
                             }
-                            const peripheral = yield this.ble.scanForDevice(this, {}).catch(() => null);
+                            const peripheral = yield this.ble.scanForDevice(this, {});
                             if (peripheral) {
                                 this.peripheral = peripheral;
                                 const connected = yield this.connectPeripheral(this.peripheral);
@@ -354,11 +359,10 @@ class BleComms extends events_1.default {
                             }
                         }
                         catch (err) {
-                            console.log('~~~ ERROR', err);
                             error = err;
                         }
                     }
-                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address }, error: error.message, stack: error.stack });
+                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address }, error: error.message });
                     this.connectState.isConnecting = false;
                     this.connectState.isConnected = false;
                     this.ble.stopConnectSensor();
@@ -368,7 +372,7 @@ class BleComms extends events_1.default {
             catch (err) {
                 this.connectState.isConnecting = false;
                 this.connectState.isConnected = false;
-                this.logEvent({ message: 'connect result: error', error: err.message });
+                this.logEvent({ message: 'connect result: error', error: err.message, stack: err.stack });
                 this.ble.stopConnectSensor();
                 return false;
             }

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

@@ -15,6 +15,7 @@ export interface ScanState {
     isBackgroundScan: boolean;
     timeout?: NodeJS.Timeout;
     peripherals?: Map<string, BlePeripheral>;
+    detected?: string[];
 }
 export interface ConnectState {
     isConnecting: boolean;

package/lib/ble/ble-interface.js

@@ -80,13 +80,16 @@ class BleInterface extends events_1.default {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~BLE:', event);
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ BLE', event);
         }
     }
     onStateChange(state) {
         if (state !== 'poweredOn') {
+            this.logEvent({ message: 'Ble disconnected', });
             this.connectState.isConnected = false;
+            this.stopConnectSensor();
         }
         else {
             this.connectState.isConnected = true;
@@ -225,7 +228,9 @@ class BleInterface extends events_1.default {
                     chachedPeripheralInfo.state = { isConfigured: false, isLoading: true, isInterrupted: false };
                     yield connector.connect();
                     peripheral.state = connector.getState();
-                    yield connector.initialize();
+                    const initialized = yield connector.initialize();
+                    if (!initialized)
+                        return null;
                     characteristics = connector.getCharachteristics();
                     this.logEvent({ message: 'characteristic info (+):', address: peripheral.address, info: characteristics.map(utils_1.getCharachteristicsInfo) });
                     chachedPeripheralInfo.characteristics = characteristics;
@@ -261,6 +266,7 @@ class BleInterface extends events_1.default {
         });
     }
     onPeripheralFound(p, callback, props = {}) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let peripheral = p;
             if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.localName) {
@@ -279,18 +285,30 @@ class BleInterface extends events_1.default {
             if (isPeripheralProcessed) {
                 return;
             }
+            if (scanForDevice) {
+                const alreadyDetected = ((_a = this.scanState.detected) === null || _a === void 0 ? void 0 : _a.find(p => p === peripheral.address)) !== undefined;
+                if (alreadyDetected)
+                    return;
+                this.scanState.detected.push(peripheral.address);
+            }
             if (scanForDevice) {
                 let found = false;
                 found =
-                    (request.name && peripheral.advertisement && request.name === peripheral.advertisement.localName) ||
-                        (request.address && request.address === peripheral.address);
+                    (request.name !== undefined && peripheral.advertisement && request.name === peripheral.advertisement.localName) ||
+                        (request.address !== undefined && request.address === peripheral.address);
+                this.logEvent({ message: 'search device: found device', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), scanForDevice, matching: found });
                 if (!found) {
                     return;
                 }
-                this.logEvent({ message: 'search device: found device', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), scanForDevice, callback: callback !== undefined });
                 this.scanState.peripherals.set(peripheral.address, peripheral);
                 const characteristics = yield this.getCharacteristics(peripheral);
-                callback(peripheral, characteristics);
+                if (characteristics) {
+                    callback(peripheral, characteristics);
+                }
+                else {
+                    callback(null);
+                }
+                this.stopScan();
                 return;
             }
             else {
@@ -299,13 +317,16 @@ class BleInterface extends events_1.default {
                 const { protocolFilter } = props;
                 const connector = this.peripheralCache.getConnector(p);
                 const characteristics = yield this.getCharacteristics(p);
+                if (!characteristics) {
+                    return callback(null);
+                }
                 const announcedServices = connector.getServices();
                 const services = announcedServices ? announcedServices.map(utils_1.uuid) : undefined;
                 peripheral = connector.getPeripheral();
                 const DeviceClasses = this.getAdapterFactory().getDeviceClasses(peripheral, { services }) || [];
                 const MatchingClasses = protocolFilter && DeviceClasses ? DeviceClasses.filter(C => protocolFilter.includes(C.protocol)) : DeviceClasses;
                 const DeviceClass = (0, comms_utils_1.getBestDeviceMatch)(MatchingClasses.filter(C => C.isMatching(characteristics.map(c => c.uuid))));
-                this.logEvent({ message: 'BLE scan: device connected', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), services, protocols: DeviceClasses.map(c => c.protocol) });
+                this.logEvent({ message: 'BLE scan: device connected', peripheral: (0, utils_1.getPeripheralInfo)(peripheral), services, protocols: DeviceClasses.map(c => c.protocol), found: DeviceClass !== undefined });
                 if (!DeviceClass)
                     return callback(null);
                 const { id, name, address } = (0, utils_1.getPeripheralInfo)(peripheral);
@@ -342,6 +363,7 @@ class BleInterface extends events_1.default {
             return new Promise((resolve, reject) => {
                 this.scanState.isScanning = true;
                 this.scanState.peripherals = new Map();
+                this.scanState.detected = [];
                 const onTimeout = () => {
                     if (!this.scanState.isScanning || !this.scanState.timeout)
                         return;
@@ -360,7 +382,7 @@ class BleInterface extends events_1.default {
                 if (protocol !== 'tacx') {
                     services = (device.getComms().getServices()) || [];
                 }
-                ble.startScanning(services, false, (err) => {
+                ble.startScanning(services, true, (err) => {
                     if (err) {
                         this.logEvent({ message: `${opStr} result: error`, request, error: err.message });
                         this.scanState.isScanning = false;
@@ -368,6 +390,8 @@ class BleInterface extends events_1.default {
                     }
                     ble.on('discover', (p) => {
                         this.onPeripheralFound(p, (peripheral, characteristics) => {
+                            if (!peripheral)
+                                return reject(new Error('could not connect'));
                             device.getComms().characteristics = characteristics;
                             process.nextTick(() => {
                                 if (this.scanState.timeout) {

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

@@ -6,6 +6,7 @@ export type ConnectorState = {
     isInitializing: boolean;
     isSubscribing: boolean;
     subscribed?: string[];
+    connectPromise?: Promise<void>;
 };
 export default class BlePeripheralConnector implements IBlePeripheralConnector {
     private state;
@@ -20,7 +21,7 @@ export default class BlePeripheralConnector implements IBlePeripheralConnector {
     connect(): Promise<void>;
     reconnect(): Promise<void>;
     onDisconnect(): void;
-    initialize(enforce?: boolean): Promise<void>;
+    initialize(enforce?: boolean): Promise<boolean>;
     isSubscribed(characteristicUuid: string): boolean;
     subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
     subscribe(characteristicUuid: string, timeout?: number): Promise<boolean>;

package/lib/ble/ble-peripheral.js

@@ -32,8 +32,9 @@ class BlePeripheralConnector {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~~BLE:', event);
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ BLE', event);
         }
     }
     connect() {
@@ -41,18 +42,25 @@ class BlePeripheralConnector {
             if (this.state.isConnected)
                 return;
             this.logEvent({ message: 'connect peripheral', peripheral: this.peripheral.address, state: this.state, peripheralState: this.peripheral.state });
+            const wasConnecting = this.state.isConnecting;
             this.state.isConnecting = true;
             try {
-                this.peripheral.on('disconnect', () => { this.onDisconnect(); });
-                if (!this.state.isConnected || (this.peripheral && this.peripheral.state !== 'connected')) {
-                    yield this.peripheral.connectAsync();
+                if (!wasConnecting) {
+                    this.peripheral.once('disconnect', () => { this.onDisconnect(); });
+                    if (!this.state.isConnected || (this.peripheral && this.peripheral.state !== 'connected')) {
+                        this.state.connectPromise = this.peripheral.connectAsync();
+                    }
                 }
+                if (this.state.connectPromise)
+                    yield this.state.connectPromise;
                 this.state.isConnected = this.peripheral.state === 'connected';
+                this.state.connectPromise = undefined;
                 return;
             }
             catch (err) {
                 this.logEvent({ message: 'Error', fn: 'connect()', error: err.message });
             }
+            this.state.connectPromise = undefined;
             this.state.isConnecting = false;
         });
     }
@@ -69,43 +77,55 @@ class BlePeripheralConnector {
         this.state.isConnecting = false;
         this.state.isInitialized = false;
         this.state.isInitializing = false;
+        this.state.connectPromise = undefined;
+        this.state.isSubscribing = false;
+        this.state.subscribed = [];
         this.emitter.emit('disconnect');
     }
     initialize(enforce = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.state.isInitialized && !enforce)
-                return;
             this.logEvent({ message: 'initialize', peripheral: this.peripheral.address, state: this.state, enforce });
+            if (this.state.isInitialized && !enforce)
+                return true;
             if (this.state.isInitialized && enforce) {
                 this.state.isInitialized = false;
             }
-            this.state.isInitializing = true;
-            this.characteristics = undefined;
-            this.services = undefined;
-            try {
-                const res = yield this.peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
-                if (this.state.isInitializing) {
-                    this.characteristics = res.characteristics;
-                    this.services = res.services.map(s => typeof (s) === 'string' ? s : s.uuid);
-                    this.state.isInitializing = false;
-                    this.state.isInitialized = this.characteristics !== undefined && this.services !== undefined;
-                    this.logEvent({ message: 'initialize done', peripheral: this.peripheral.address, state: this.state });
+            return new Promise((done) => __awaiter(this, void 0, void 0, function* () {
+                this.state.isInitializing = true;
+                this.characteristics = undefined;
+                this.services = undefined;
+                try {
+                    this.emitter.once('disconnect', () => {
+                        done(false);
+                    });
+                    const res = yield this.peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
+                    if (this.state.isInitializing) {
+                        this.characteristics = res.characteristics;
+                        this.services = res.services.map(s => typeof (s) === 'string' ? s : s.uuid);
+                        this.state.isInitializing = false;
+                        this.state.isInitialized = this.characteristics !== undefined && this.services !== undefined;
+                        this.logEvent({ message: 'initialize done', peripheral: this.peripheral.address, state: this.state });
+                        return done(true);
+                    }
+                    else {
+                        this.logEvent({ message: 'initialize interrupted', peripheral: this.peripheral.address });
+                    }
                 }
-                else {
-                    this.logEvent({ message: 'initialize interrupted', peripheral: this.peripheral.address });
+                catch (err) {
+                    this.logEvent({ message: 'error', fn: 'initialize', error: err.message, stack: err.stack });
+                    this.state.isInitializing = false;
+                    this.state.isInitialized = false;
+                    done(false);
                 }
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'initialize', error: err.message, stack: err.stack });
-                this.state.isInitializing = false;
-                this.state.isInitialized = false;
-            }
+            }));
         });
     }
     isSubscribed(characteristicUuid) {
-        return this.state.subscribed.find(c => c === characteristicUuid || (0, utils_1.uuid)(c) === characteristicUuid || c === (0, utils_1.uuid)(characteristicUuid)) !== undefined;
+        var _a;
+        return ((_a = this.state.subscribed) === null || _a === void 0 ? void 0 : _a.find(c => c === characteristicUuid || (0, utils_1.uuid)(c) === characteristicUuid || c === (0, utils_1.uuid)(characteristicUuid))) !== undefined;
     }
     subscribeAll(callback) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const cnt = this.characteristics.length;
             this.state.isSubscribing = true;
@@ -124,7 +144,7 @@ class BlePeripheralConnector {
                             this.on((0, utils_1.uuid)(c.uuid), callback);
                         }
                         this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, uuid: (0, utils_1.uuid)(c.uuid) });
-                        if (this.state.subscribed.find(uuid => uuid === c.uuid) === undefined) {
+                        if (((_a = this.state.subscribed) === null || _a === void 0 ? void 0 : _a.find(uuid => uuid === c.uuid)) === undefined) {
                             try {
                                 yield this.subscribe(c.uuid, 3000);
                                 subscribed.push(c.uuid);

package/lib/ble/fm/adapter.js

@@ -117,7 +117,7 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
                 this.resume();
             if (this.started && !wasPaused)
                 return true;
-            this.logEvent(Object.assign(Object.assign({ message: 'starting device' }, this.getSettings()), { protocol: this.getProtocolName(), props, isStarted: this.started }));
+            this.logEvent(Object.assign(Object.assign({ message: 'starting device' }, this.getSettings()), { protocol: this.getProtocolName(), props, isStarted: this.started, isConnected: this.getComms().isConnected() }));
             const { restart = wasPaused } = props;
             if (!restart && this.ble.isScanning() && !this.getComms().isConnected()) {
             }
@@ -131,11 +131,11 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
                     this.connectPromise = this.connect();
                 const res = yield Promise.race([
                     this.connectPromise.then((connected) => {
-                        this.connectPromise = undefined;
                         return { connected, reason: connected ? null : 'could not connect' };
                     }),
                     (0, utils_1.sleep)(timeout).then(() => ({ connected: false, reason: 'timeout' }))
                 ]);
+                this.connectPromise = undefined;
                 const connected = res.connected;
                 if (!connected) {
                     throw new Error(`could not start device, reason:${res.reason}`);

package/lib/ble/peripheral-cache.js

@@ -12,6 +12,8 @@ class BlePeripheralCache {
         return this.find(adapter.getSettings());
     }
     getConnector(peripheral) {
+        if (!peripheral)
+            return;
         const info = this.find({ address: peripheral.address });
         if (!info) {
             const item = this.add({ address: peripheral.address, ts: Date.now(), peripheral });
@@ -99,7 +101,7 @@ class BlePeripheralCache {
             const { address } = peripheral;
             cachedItemIdx = this._findIndex({ address });
         }
-        if (cachedItemIdx == -1)
+        if (cachedItemIdx === -1)
             return;
         this.peripherals.splice(cachedItemIdx);
     }

package/lib/ble/types.d.ts

@@ -66,7 +66,7 @@ export interface BlePeripheral extends EventEmitter, BlePeripheralIdentifier {
 export interface IBlePeripheralConnector {
     connect(): Promise<void>;
     reconnect(): Promise<void>;
-    initialize(enforce: boolean): Promise<void>;
+    initialize(enforce: boolean): Promise<boolean>;
     isSubscribed(characteristicUuid: string): boolean;
     subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
     subscribe(characteristicUuid: string, timeout?: number): Promise<boolean>;

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

@@ -21,8 +21,8 @@ export default class DaumClassicAdapter extends DaumAdapter {
     check(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    startRide(props: DaumClassicDeviceProperties): Promise<boolean>;
-    start(props: DaumClassicDeviceProperties): Promise<boolean>;
+    startRide(props?: DaumClassicDeviceProperties): Promise<boolean>;
+    start(props?: DaumClassicDeviceProperties): Promise<boolean>;
     launch(props: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
     performStart(props?: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<unknown>;
     getCurrentBikeData(): any;

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

@@ -131,16 +131,30 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             return resumed;
         });
     }
-    startRide(props) {
+    startRide(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'relaunch of device' });
-            return yield this.launch(props, true);
+            try {
+                yield this.launch(props, true);
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'start result: error', error: err.message });
+                throw err;
+            }
         });
     }
-    start(props) {
+    start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'initial start of device' });
-            return yield this.launch(props, false);
+            try {
+                yield this.launch(props, false);
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'start result: error', error: err.message });
+                throw err;
+            }
         });
     }
     launch(props, isRelaunch = false) {
@@ -178,7 +192,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             try {
                 this.logger.logEvent({ message: 'start attempt', isRelaunch, isConnected: this.bike.isConnected() });
                 if (!isRelaunch && !this.bike.isConnected())
-                    yield this.bike.saveConnect();
+                    yield this.connect();
                 yield this.getBike().resetDevice();
                 if (!startState.setProg) {
                     yield this.getBike().setProg(0);

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

@@ -44,6 +44,8 @@ export type DaumClassicUser = {
 };
 interface BikeData {
     cockpitVersion: number;
+    cockpitType: number;
+    serialNo: string;
     isPedalling: boolean;
     bikeType: number;
     person: DaumClassicUser;

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

@@ -77,6 +77,8 @@ class DaumClassicMockImpl {
 exports.DaumClassicMockImpl = DaumClassicMockImpl;
 const DEFAULT_BIKE_DATA = {
     cockpitVersion: 3,
+    serialNo: '4464:<;8',
+    cockpitType: 50,
     isPedalling: false,
     bikeType: 0,
     person: { weight: 75, length: 180, age: 30, sex: 0 }
@@ -208,7 +210,10 @@ class DaumClassicMockBinding extends binding_mock_1.MockPortBinding {
     onGetVersion(payload) {
         const bikeNo = payload.readUInt8(0);
         if (bikeNo >= 0 && bikeNo < 10) {
-            const response = Buffer.from([0x73, bikeNo, this.simulator.bikes[bikeNo].cockpitVersion]);
+            const { cockpitType, serialNo } = this.simulator.bikes[bikeNo] || {};
+            const response = Buffer.from([0x73, bikeNo, 0, 0, 0, 0, 0, 0, 0, 0, cockpitType]);
+            for (let i = 0; i < serialNo.length && i < 8; i++)
+                response.writeUInt8(serialNo.charCodeAt(i), i + 2);
             this.emitData(response);
         }
     }

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

@@ -8,6 +8,7 @@ export default class DaumPremiumAdapter extends DaumAdapter {
     commProps: SerialCommProps;
     _startRetryTimeout: number;
     constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
+    logEvent(event: any): void;
     getName(): string;
     getUniqueName(): string;
     getPort(): any;

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

@@ -60,6 +60,15 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
         this.distanceInternal = undefined;
         this.initData();
     }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ DaumPremium', event);
+        }
+    }
     getName() {
         return 'Daum8i';
     }
@@ -102,19 +111,19 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             var info = {};
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.logger.logEvent({ message: "checking device", port: this.getPort() });
+                this.logEvent({ message: "checking device", port: this.getPort() });
                 try {
+                    yield this.bike.close();
                     const connected = yield this.connect();
                     if (!connected)
                         resolve(false);
                     info.deviceType = yield this.bike.getDeviceType();
                     info.version = yield this.bike.getProtocolVersion();
-                    yield this.bike.close();
-                    this.logger.logEvent({ message: "checking device success", port: this.getPort(), info });
+                    this.logEvent({ message: "checking device success", port: this.getPort(), info });
                     resolve(true);
                 }
                 catch (err) {
-                    this.logger.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
+                    this.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
                     resolve(false);
                 }
             }));
@@ -142,27 +151,27 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
     }
     startRide(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'relaunch of device' });
+            this.logEvent({ message: 'relaunch of device' });
             try {
                 yield this.launch(props, true);
                 return true;
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message });
-                throw new Error(`could not start device, reason:${err.message}`);
+                this.logEvent({ message: 'start result: error', error: err.message });
+                throw err;
             }
         });
     }
     start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'initial start of device' });
+            this.logEvent({ message: 'initial start of device' });
             try {
                 yield this.launch(props, false);
                 return true;
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message });
-                throw new Error(`could not start device, reason:${err.message}`);
+                this.logEvent({ message: 'start result: error', error: err.message });
+                throw err;
             }
         });
     }

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

@@ -41,7 +41,8 @@ class Daum8i {
         const { logger, serial, path } = props;
         this.serial = serial;
         this.path = validatePath(path);
-        this.logger = logger || (process.env.DEBUG ? DEBUG_LOGGER : new gd_eventlog_1.EventLogger('DaumPremium'));
+        const w = global.window;
+        this.logger = logger || ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.DEBUG ? DEBUG_LOGGER : new gd_eventlog_1.EventLogger('DaumPremium'));
         this.isLoggingPaused = false;
         this.connected = false;
         this.blocked = false;
@@ -75,6 +76,10 @@ class Daum8i {
     logEvent(e) {
         if (!this.isLoggingPaused)
             this.logger.logEvent(e);
+        const w = global.window;
+        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
+            console.log('~~~ DaumPremium', e);
+        }
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -114,6 +119,7 @@ class Daum8i {
             }
             this.connected = false;
             if (this.sp) {
+                console.log('~~~ removing all listeners');
                 this.sp.removeAllListeners();
                 this.sp = null;
             }
@@ -149,6 +155,7 @@ class Daum8i {
         return __awaiter(this, void 0, void 0, function* () {
             this.connected = false;
             if (this.sp) {
+                console.log('~~~ removing all listeners');
                 this.sp.removeAllListeners();
                 this.sp = null;
             }
@@ -421,19 +428,18 @@ class Daum8i {
     }
     write(buffer) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise(done => {
+            return new Promise((done) => __awaiter(this, void 0, void 0, function* () {
                 this.state.writeBusy = true;
                 try {
-                    this.sp.write(buffer, () => {
-                        this.state.writeBusy = false;
-                        done();
-                    });
+                    yield this.sp.write(buffer);
+                    this.state.writeBusy = false;
+                    done();
                 }
                 catch (err) {
                     this.state.writeBusy = false;
                     done();
                 }
-            });
+            }));
         });
     }
     sendACK() {

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

@@ -143,9 +143,6 @@ class Daum8iMockBinding extends binding_mock_1.MockPortBinding {
             }
             this.writeOperation = (() => __awaiter(this, void 0, void 0, function* () {
                 yield (0, utils_1.resolveNextTick)();
-                if (!this.isOpen || !this.port) {
-                    throw new Error('Write canceled');
-                }
                 if (this.simulator._isSimulateACKTimeout) {
                     this.simulator._isSimulateACKTimeout = false;
                 }

package/lib/serial/kettler/ergo-racer/mock.js

@@ -164,7 +164,7 @@ class KettlerRacerMockBinding extends binding_mock_1.MockPortBinding {
                     handler(payload);
                 }
                 else {
-                    this, this.emitData('ERROR' + CRLF);
+                    this.emitData('ERROR' + CRLF);
                 }
             });
         });

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

@@ -31,6 +31,7 @@ export declare class SinglePathScanner {
     props: SerialScannerProps;
     logger: EventLogger;
     constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
+    logEvent(event: any): void;
     onStopRequest(resolve: any): Promise<void>;
     scan(): Promise<SerialDeviceSettings | undefined>;
 }
@@ -48,6 +49,7 @@ export default class SerialInterface extends EventEmitter implements IncyclistIn
     static getInstance(props: SerialInterfaceProps): SerialInterface;
     static _add(instance: SerialInterface): void;
     constructor(props: SerialInterfaceProps);
+    logEvent(event: any): void;
     setBinding(binding: BindingInterface): void;
     getName(): string;
     isConnected(): boolean;

package/lib/serial/serial-interface.js

@@ -32,9 +32,18 @@ class SinglePathScanner {
         this.props = props;
         this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
     }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ SerialScanner', event);
+        }
+    }
     onStopRequest(resolve) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stopping scan', path: this.path });
+            this.logEvent({ message: 'stopping scan', path: this.path });
             yield this.serial.closePort(this.path);
             this.isScanning = false;
             resolve(this.result);
@@ -46,7 +55,7 @@ class SinglePathScanner {
                 return;
             this.isScanning = true;
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.logger.logEvent({ message: 'starting scan', path: this.path });
+                this.logEvent({ message: 'starting scan', path: this.path });
                 this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
                 this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
                 let found = false;
@@ -65,12 +74,13 @@ class SinglePathScanner {
                         found = yield adapter.check();
                         if (found) {
                             const name = adapter.getName();
+                            yield this.serial.closePort(this.path).catch();
                             resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
                         }
                         yield (0, utils_1.sleep)(100);
                     }
                     catch (err) {
-                        this.logger.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+                        this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
                         yield (0, utils_1.sleep)(100);
                     }
                 }
@@ -113,12 +123,21 @@ class SerialInterface extends events_1.default {
         this.scanEvents.setMaxListeners(100);
         this.logger = props.logger || new gd_eventlog_1.EventLogger(`Serial:${ifaceName}`);
         this.connected = false;
-        this.logger.logEvent({ message: 'new serial interface', ifaceName });
+        this.logEvent({ message: 'new serial interface', ifaceName });
         if (binding) {
             this.setBinding(binding);
         }
         SerialInterface._add(this);
     }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ Serial', event);
+        }
+    }
     setBinding(binding) {
         this.binding = binding;
         serialport_1.default.getInstance().setBinding(this.ifaceName, binding);
@@ -138,7 +157,7 @@ class SerialInterface extends events_1.default {
             }
             try {
                 const SerialPort = this.binding;
-                const res = yield SerialPort.list();
+                yield SerialPort.list();
                 this.connected = true;
                 return true;
             }
@@ -156,7 +175,7 @@ class SerialInterface extends events_1.default {
     }
     openPort(path) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'opening port', path });
+            this.logEvent({ message: 'opening port', path });
             const port = serialport_1.default.getInstance().getSerialPort(this.ifaceName, { path });
             if (!port) {
                 return null;
@@ -164,20 +183,21 @@ class SerialInterface extends events_1.default {
             const existing = this.ports.findIndex(p => p.path === path);
             if (existing !== -1) {
                 const port = this.ports[existing].port;
-                if (port.isOpen)
+                if (port.isOpen) {
                     return port;
+                }
                 else {
                     this.ports.splice(existing, 1);
                 }
             }
             return new Promise((resolve) => {
                 port.once('error', (err) => {
-                    this.logger.logEvent({ message: 'error', path, error: err || err.message });
+                    this.logEvent({ message: 'error', path, error: err || err.message });
                     port.removeAllListeners();
                     resolve(null);
                 });
                 port.once('open', () => {
-                    this.logger.logEvent({ message: 'port opened', path });
+                    this.logEvent({ message: 'port opened', path });
                     port.removeAllListeners();
                     this.ports.push({ path, port });
                     resolve(port);
@@ -188,6 +208,7 @@ class SerialInterface extends events_1.default {
     }
     closePort(path) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'closing port' });
             const existing = this.ports.findIndex(p => p.path === path);
             if (existing === -1)
                 return true;
@@ -229,7 +250,7 @@ class SerialInterface extends events_1.default {
                     this.scanEvents.emit('timeout');
                 }, timeout);
             }
-            this.logger.logEvent({ message: 'checking for ports ' });
+            this.logEvent({ message: 'checking for ports' });
             this.isScanning = true;
             do {
                 try {
@@ -245,21 +266,21 @@ class SerialInterface extends events_1.default {
                     console.log('~~~ERROR', err);
                 }
                 if (!paths || paths.length === 0) {
-                    this.logger.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
+                    this.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
                     yield (0, utils_1.sleep)(1000);
                 }
                 if (Date.now() > toExpiresAt)
                     timeOutExpired = true;
             } while (this.isScanning && !timeOutExpired && paths.length === 0);
             if (paths.length === 0) {
-                this.logger.logEvent({ message: 'nothing to scan ' });
+                this.logEvent({ message: 'nothing to scan ' });
                 if (this.toScan) {
                     clearTimeout(this.toScan);
                     this.toScan = null;
                 }
                 return [];
             }
-            this.logger.logEvent({ message: 'scanning on ', paths: paths.map(p => p.path), timeout });
+            this.logEvent({ message: 'scanning on ', paths: paths.map(p => p.path), timeout });
             const scanners = paths.map(p => new SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
             try {
                 yield Promise.all(scanners.map(s => s.scan()
@@ -272,14 +293,14 @@ class SerialInterface extends events_1.default {
                     .catch()));
             }
             catch (err) {
-                this.logger.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+                this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
             }
             if (this.toScan) {
                 clearTimeout(this.toScan);
                 this.toScan = null;
             }
             this.isScanning = false;
-            this.logger.logEvent({ message: 'scan finished on', interface: this.ifaceName, paths: paths.map(p => p.path), devices: detected.map(d => {
+            this.logEvent({ message: 'scan finished on', interface: this.ifaceName, paths: paths.map(p => p.path), devices: detected.map(d => {
                     const res = Object.assign({}, d);
                     res.interface = this.ifaceName;
                     return res;

package/package.json

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