incyclist-devices 2.0.31 → 2.0.33

package/lib/serial/adapter.d.ts

@@ -14,6 +14,7 @@ export declare class SerialIncyclistDevice extends ControllableDevice {
     isEqual(settings: SerialDeviceSettings): boolean;
     getPort(): string;
     getUniqueName(): string;
+    getSerialInterface(): SerialInterface;
     getInterface(): string;
     setMaxUpdateFrequency(ms: number): void;
     setPullFrequency(ms: number): void;

package/lib/serial/adapter.js

@@ -40,6 +40,9 @@ class SerialIncyclistDevice extends adpater_1.ControllableDevice {
     getUniqueName() {
         return `${this.getName()} (${this.getPort()})`;
     }
+    getSerialInterface() {
+        throw new Error('not implemented');
+    }
     getInterface() {
         return 'serial';
     }

package/lib/serial/bindings/tcp.d.ts

@@ -7,14 +7,14 @@ export interface TCPOpenOptions extends OpenOptions {
     timeout?: number;
 }
 export declare interface TCPBindingInterface<T extends BindingPortInterface = BindingPortInterface, R extends OpenOptions = OpenOptions, P extends PortInfo = PortInfo> extends BindingInterface<TCPPortBinding, TCPOpenOptions> {
-    list(port?: number): Promise<P[]>;
+    list(port?: number, excludeList?: string[]): Promise<P[]>;
 }
 export declare class CanceledError extends Error {
     canceled: true;
     constructor(message: string);
 }
 export declare function scanPort(host: string, port: number): Promise<boolean>;
-export declare function scanSubNet(sn: string, port: number): Promise<string[]>;
+export declare function scanSubNet(sn: string, port: number, excludeHosts?: string[]): Promise<string[]>;
 export declare function getSubnets(): string[];
 export declare const TCPBinding: TCPBindingInterface;
 export declare class TCPPortBinding implements BindingPortInterface {

package/lib/serial/bindings/tcp.js

@@ -50,10 +50,11 @@ function scanPort(host, port) {
     });
 }
 exports.scanPort = scanPort;
-function scanSubNet(sn, port) {
+function scanSubNet(sn, port, excludeHosts) {
     const range = [];
     for (let i = 1; i < 255; i++)
-        range.push(i);
+        if (!excludeHosts || !excludeHosts.includes(`${sn}.${i}`))
+            range.push(i);
     return Promise.all(range.map(j => scanPort(`${sn}.${j}`, port).then(success => success ? `${sn}.${j}` : null).catch()))
         .then(hosts => hosts.filter(h => h !== null))
         .catch();
@@ -86,13 +87,14 @@ function getSubnets() {
 }
 exports.getSubnets = getSubnets;
 exports.TCPBinding = {
-    list(port) {
+    list(port, excludeList) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!port)
                 return [];
             const subnets = getSubnets();
-            const hosts = [];
-            yield Promise.all(subnets.map(sn => scanSubNet(sn, port).then(found => { hosts.push(...found); })));
+            let hosts = [];
+            const excludeHosts = excludeList.map(e => e && e.includes(':') ? e.split(':')[0] : e);
+            yield Promise.all(subnets.map(sn => scanSubNet(sn, port, excludeHosts).then(found => { hosts.push(...found); })));
             return hosts.map(host => ({
                 path: `${host}:${port}`,
                 manufacturer: undefined,

package/lib/serial/daum/DaumAdapter.js

@@ -199,8 +199,10 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
         if (this.stopped)
             return Promise.resolve(true);
         this.logEvent({ message: 'stop request' });
+        if (this.paused)
+            this.resume();
         this.stopped = true;
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             try {
                 if (this.iv) {
                     if (this.iv.sync)
@@ -211,15 +213,15 @@ class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
                 }
                 if (this.bike.stopWorker && typeof this.bike.stopWorker === 'function')
                     this.bike.stopWorker();
+                yield this.bike.close();
                 this.logEvent({ message: 'stop request completed' });
-                this.paused = undefined;
                 resolve(true);
             }
             catch (err) {
                 this.logEvent({ message: 'stop error', error: err.message });
                 reject(err);
             }
-        });
+        }));
     }
     canSendUpdate() {
         if (this.paused || this.stopped)

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

@@ -2,6 +2,7 @@ import CyclingMode from '../../../modes/cycling-mode';
 import DaumAdapter from '../DaumAdapter';
 import { DeviceProperties } from '../../../types/device';
 import { SerialDeviceSettings } from '../../adapter';
+import SerialInterface from '../../serial-interface';
 export interface DaumClassicDeviceProperties extends DeviceProperties {
     gear?: number;
 }
@@ -21,6 +22,7 @@ export default class DaumClassicAdapter extends DaumAdapter {
     getProtocolName(): string;
     getSupportedCyclingModes(): Array<any>;
     getDefaultCyclingMode(): CyclingMode;
+    getSerialInterface(): SerialInterface;
     check(): Promise<boolean>;
     performCheck(): Promise<boolean>;
     pause(): Promise<boolean>;

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

@@ -80,6 +80,10 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
     getDefaultCyclingMode() {
         return new daum_classic_1.default(this);
     }
+    getSerialInterface() {
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
+    }
     check() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isStopped())

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

@@ -1,4 +1,5 @@
 import { DeviceProperties } from '../../../types/device';
+import { SerialInterface } from '../..';
 import { SerialDeviceSettings } from '../../adapter';
 import { SerialCommProps } from '../../comm';
 import DaumAdapter from '../DaumAdapter';
@@ -14,6 +15,7 @@ export default class DaumPremiumAdapter extends DaumAdapter {
     getPort(): any;
     getInterface(): string;
     getProtocolName(): string;
+    getSerialInterface(): SerialInterface;
     isEqual(settings: SerialDeviceSettings): boolean;
     getSupportedCyclingModes(): Array<any>;
     check(): Promise<boolean>;

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

@@ -90,6 +90,10 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
     getProtocolName() {
         return PROTOCOL_NAME;
     }
+    getSerialInterface() {
+        var _a;
+        return (_a = this.bike) === null || _a === void 0 ? void 0 : _a.serial;
+    }
     isEqual(settings) {
         if (this.getInterface() === device_1.INTERFACE.TCPIP) {
             const as = this.settings;
@@ -186,9 +190,7 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
             const { route, onStatusUpdate, gear } = props;
             var info = {};
             this.initData();
-            if (isRelaunch) {
-                yield this.stop();
-            }
+            yield this.stop();
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     yield this.connect();
@@ -240,7 +242,7 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
             if (!this.bike.isConnected()) {
                 const connected = yield this.bike.connect();
                 if (!connected)
-                    return;
+                    throw new Error('not connected');
             }
             return this.getBike().getTrainingData();
         });

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

@@ -1,13 +1,39 @@
 /// <reference types="node" />
 import { ReservedCommands } from './utils';
 import { SerialInterface, SerialPortProvider } from '../..';
-import { Queue } from '../../../utils/utils';
 import { EventLogger } from 'gd-eventlog';
 import { User } from "../../../types/user";
 import { Route } from "../../../types/route";
 import { SerialCommProps } from "../../comm";
 import { SerialPortStream } from "@serialport/stream";
 import { OnDeviceStartCallback } from "./types";
+import { Queue } from "../../../utils/utils";
+export type ResponseObject = {
+    type: ResponseType;
+    data?: string;
+    error?: Error;
+};
+export type ResponseType = 'ACK' | 'NAK' | 'Response' | 'Error';
+export type Daum8iCommsState = {
+    waitingForStart?: boolean;
+    waitingForACK?: boolean;
+    waitingForEnd?: boolean;
+    partialCmd?: any;
+    data: Queue<ResponseObject>;
+};
+export type ConnectionState = 'Connecting' | 'Connected' | 'Disconnected' | 'Disconnecting';
+export declare class CheckSumError extends Error {
+    constructor();
+}
+export declare class ACKTimeout extends Error {
+    constructor();
+}
+export declare class BusyTimeout extends Error {
+    constructor();
+}
+export declare class ResponseTimeout extends Error {
+    constructor();
+}
 export default class Daum8i {
     logger: EventLogger;
     serial: SerialInterface;
@@ -18,17 +44,16 @@ export default class Daum8i {
     };
     port: string;
     settings: any;
-    sp: SerialPortStream;
     props: any;
-    connected: boolean;
-    blocked: boolean;
-    state: any;
+    protected sp: SerialPortStream;
+    protected connectState: ConnectionState;
+    protected connectPromise: Promise<SerialPortStream>;
+    protected disconnectPromise: Promise<boolean>;
+    protected writePromise: Promise<void>;
+    protected sendCmdPromise: Promise<string>;
+    protected actualBikeType?: string;
+    protected recvState: Daum8iCommsState;
     bikeData: any;
-    processor: any;
-    error: Error;
-    queue: Queue<any>;
-    cmdCurrent: any;
-    cmdStart: number;
     isLoggingPaused: boolean;
     spp: SerialPortProvider;
     serialportProps: any;
@@ -40,29 +65,25 @@ export default class Daum8i {
     resumeLogging(): void;
     logEvent(e: any): void;
     connect(): Promise<boolean>;
+    closePort(): Promise<boolean>;
+    cleanupPort(): void;
     close(): Promise<boolean>;
     flush(): Promise<void>;
-    getLogState(): {
-        sending: any;
-        busy: any;
-        writeBusy: any;
-        opening: any;
-        connecting: any;
-        waitingForStart: any;
-        waitingForEnd: any;
-        waitingForAck: any;
-        retry: any;
-    };
     onPortClose(): Promise<void>;
-    onPortError(error: any): Promise<void>;
-    forceClose(updateState?: boolean): Promise<void>;
-    sendTimeout(message: any): void;
-    checkForResponse(): boolean;
+    onPortError(error: Error): Promise<void>;
+    isSending(): boolean;
+    rejectCurrent(error: Error): void;
     getTimeoutValue(cmd?: any): number;
     onData(data: any, depth?: number): any;
+    waitWithTimeout(promise: Promise<any>, timeout: number, onTimeout?: () => void): Promise<any>;
     sendDaum8iCommand(command: string, payload?: string | any[]): Promise<string>;
-    writeDone(): void;
-    write(buffer: Buffer): Promise<void>;
+    onIgnored(payload: string): void;
+    onACK(): void;
+    onNAK: () => void;
+    waitForACK(): Promise<boolean>;
+    waitForResponse(): Promise<string>;
+    portWrite(buffer: Buffer): Promise<void>;
+    write(buffer: Buffer, ackExpected?: boolean): Promise<void>;
     sendACK(): Promise<void>;
     sendNAK(): Promise<void>;
     sendReservedDaum8iCommand(command: ReservedCommands, data?: Buffer): Promise<any[]>;

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

@@ -9,9 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseTimeout = exports.BusyTimeout = exports.ACKTimeout = exports.CheckSumError = void 0;
 const constants_1 = require("../constants");
 const utils_1 = require("./utils");
 const gd_eventlog_1 = require("gd-eventlog");
+const utils_2 = require("../../../utils/utils");
 const DEFAULT_TIMEOUT = 10000;
 const MAX_DATA_BLOCK_SIZE = 512;
 const DS_BITS_OFF = 0;
@@ -34,9 +36,38 @@ const validatePath = (path) => {
     const port = parts[1];
     return `${host}:${port}`;
 };
-const drain = (sp) => new Promise(resolve => { sp.drain(resolve); });
+class CheckSumError extends Error {
+    constructor() {
+        super();
+        this.message = 'checksum incorrect';
+    }
+}
+exports.CheckSumError = CheckSumError;
+class ACKTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'ACK timeout';
+    }
+}
+exports.ACKTimeout = ACKTimeout;
+class BusyTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'BUSY timeout';
+    }
+}
+exports.BusyTimeout = BusyTimeout;
+class ResponseTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'RESP timeout';
+    }
+}
+exports.ResponseTimeout = ResponseTimeout;
 class Daum8i {
     constructor(props) {
+        this.onNAK = () => {
+        };
         this.props = props || {};
         const { logger, serial, path } = props;
         this.serial = serial;
@@ -44,12 +75,9 @@ class Daum8i {
         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;
-        this.state = {
-            ack: { wait: false, startWait: undefined },
-            commandsInQueue: {},
-        };
+        this.connectState = 'Disconnected';
+        this.connectPromise = null;
+        this.recvState = { data: new utils_2.Queue() };
         this.settings = {};
         this.bikeData = {
             userWeight: 75,
@@ -65,7 +93,7 @@ class Daum8i {
         return this.path;
     }
     isConnected() {
-        return this.connected;
+        return this.connectState === 'Connected' || this.connectState === 'Disconnecting';
     }
     pauseLogging() {
         this.isLoggingPaused = true;
@@ -87,159 +115,124 @@ class Daum8i {
             if (this.isConnected() && this.sp) {
                 return true;
             }
+            if (this.connectState === 'Connecting') {
+                if (this.connectPromise) {
+                    try {
+                        yield this.connectPromise;
+                    }
+                    catch (_a) {
+                    }
+                }
+                return this.isConnected();
+            }
             try {
-                const port = yield this.serial.openPort(this.path);
+                this.connectState = 'Connecting';
+                this.connectPromise = this.serial.openPort(this.path);
+                const port = yield this.connectPromise;
+                this.connectPromise = null;
                 if (port !== null) {
-                    this.connected = true;
+                    this.connectState = 'Connected';
                     this.sp = port;
                     this.sp.on('close', this.onPortClose.bind(this));
-                    this.sp.on('error', (error) => { this.onPortError(error); });
-                    this.sp.on('data', (data) => { this.onData(data); });
+                    this.sp.on('error', this.onPortError.bind(this));
+                    this.sp.on('data', this.onData.bind(this));
                     return true;
                 }
                 else {
+                    this.connectState = 'Disconnected';
                     return false;
                 }
             }
-            catch (_a) {
+            catch (_b) {
+                this.connectState = 'Disconnected';
                 return false;
             }
         });
     }
+    closePort() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sp)
+                return true;
+            try {
+                yield this.flush();
+                yield this.serial.closePort(this.path);
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not close ', reason: err.message });
+                return false;
+            }
+        });
+    }
+    cleanupPort() {
+        if (this.sp) {
+            this.sp.removeAllListeners();
+        }
+        this.sp = null;
+        this.recvState.data.clear();
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected() && this.serial && this.sp) {
+            let isDisconnected = false;
+            if (this.disconnectPromise) {
                 try {
-                    yield this.flush();
-                    yield this.serial.closePort(this.path);
+                    isDisconnected = yield this.disconnectPromise;
                 }
-                catch (err) {
-                    this.logEvent({ message: 'could not close ', reason: err.message });
-                    return false;
+                catch (_a) {
                 }
+                return isDisconnected;
             }
-            this.connected = false;
-            if (this.sp) {
-                this.sp.removeAllListeners();
-                this.sp = null;
+            if (this.connectState === 'Disconnected') {
+                this.cleanupPort();
+                return true;
             }
-            return true;
+            else if (this.connectState === 'Disconnecting' || this.connectState === 'Connected' || this.connectState === 'Connecting') {
+                this.connectState = 'Disconnecting';
+                this.disconnectPromise = this.closePort();
+                isDisconnected = yield this.disconnectPromise;
+                this.connectPromise = null;
+                this.disconnectPromise = null;
+                if (isDisconnected)
+                    this.connectState = 'Disconnected';
+                this.cleanupPort();
+            }
+            return isDisconnected;
         });
     }
     flush() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.state.writeBusy)
-                return;
-            return new Promise(done => {
-                const iv = setInterval(() => {
-                    if (!this.state.writeBusy) {
-                        clearInterval(iv);
-                        this.writeDone();
-                        done();
-                    }
-                }, 100);
-            });
+            if (this.writePromise) {
+                yield this.waitWithTimeout(this.writePromise, 1000);
+                this.writePromise = null;
+            }
         });
     }
-    getLogState() {
-        let s = undefined;
-        const { sending, busy, opening, connecting, writeBusy, waitingForStart, waitingForAck, waitingForEnd, retry } = this.state;
-        if (sending) {
-            s = {};
-            s.command = sending.command;
-            s.payload = sending.payload;
-        }
-        return { sending: s, busy, writeBusy, opening, connecting, waitingForStart, waitingForEnd, waitingForAck, retry };
-    }
     onPortClose() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.connected = false;
-            if (this.sp) {
-                this.sp.removeAllListeners();
-                this.sp = null;
-            }
+            if (this.connectState !== 'Disconnected' && this.connectState !== 'Disconnecting')
+                this.logEvent({ message: "port closed:", port: this.path });
+            this.connectState = 'Disconnected';
+            this.cleanupPort();
         });
     }
     onPortError(error) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: "port error:", port: this.path, error: error.message, connected: this.connected, state: this.getLogState() });
-            this.error = error;
-            if (this.blocked) {
-                if (!this.state.closed) {
-                    yield this.close();
-                }
+            if (this.connectState === 'Disconnecting' || this.connectState === 'Disconnected') {
                 return;
             }
-            if (this.state.sending) {
-                if (this.state.sending.reject)
-                    this.state.sending.reject(error);
-                this.writeDone();
-                yield this.close();
-                return;
+            this.logEvent({ message: "port error:", port: this.path, error: error.message, connected: this.isConnected(), state: this.connectState });
+            if (this.isSending()) {
+                this.rejectCurrent(error);
             }
-            this.state.busy = false;
+            if (this.connectState === 'Connected')
+                this.close();
         });
     }
-    forceClose(updateState = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.sp)
-                return;
-            try {
-                yield this.close();
-                this.writeDone();
-                if (this.queue !== undefined)
-                    this.queue.clear();
-            }
-            catch (_a) { }
-            this.connected = false;
-            if (updateState)
-                this.state = { opened: false, closed: true, busy: false };
-        });
-    }
-    sendTimeout(message) {
-        this.logEvent({ message: `sendCommand:${message || 'timeout'}`, port: this.path, cmd: this.cmdCurrent });
-        delete this.state.commandsInQueue[this.cmdCurrent.command];
-        if (this.cmdCurrent.callbackErr !== undefined) {
-            let cb = this.cmdCurrent.callbackErr;
-            this.state.busy = false;
-            this.cmdCurrent = undefined;
-            this.cmdStart = undefined;
-            cb(408, { message: message || "timeout" });
-        }
+    isSending() {
+        return (this.writePromise !== undefined && this.writePromise !== null) || (this.sendCmdPromise !== null && this.sendCmdPromise !== undefined);
     }
-    checkForResponse() {
-        const d = Date.now();
-        const s = this.state.sending;
-        if (s === undefined)
-            return false;
-        const rejectFn = s.reject;
-        const reject = (err) => {
-            if (rejectFn && typeof rejectFn === 'function') {
-                rejectFn(err);
-            }
-        };
-        const error = this.state.error;
-        if (error !== undefined) {
-            reject(error);
-            return false;
-        }
-        try {
-            if (this.state.waitingForACK) {
-                const timeoutACK = this.state.ack ? this.state.ack.timeout : this.state.sending.timeout;
-                if (d < timeoutACK)
-                    return true;
-                reject(new Error('ACK timeout'));
-                return false;
-            }
-            if (d < this.state.sending.timeout)
-                return true;
-            reject(new Error('RESP timeout'));
-            return false;
-        }
-        catch (err) {
-            this.logEvent({ message: 'checkForResponse: Exception', port: this.path, error: err.message, stack: err.stack });
-        }
-        return true;
+    rejectCurrent(error) {
+        this.recvState.data.enqueue({ type: 'Error', error });
     }
     getTimeoutValue(cmd) {
         let timeout = DEFAULT_TIMEOUT;
@@ -254,18 +247,13 @@ class Daum8i {
         return __awaiter(this, void 0, void 0, function* () {
             let cmd = '';
             const MAX_DEPTH = 5;
-            if (this.state.waitingForEnd) {
-                cmd = this.state.partialCmd;
+            if (this.recvState.waitingForEnd) {
+                cmd = this.recvState.partialCmd;
             }
             const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data, 'latin1');
-            const s = this.state.sending;
-            if (s === undefined) {
-                this.logEvent({ message: 'onData:IGNORED', data: bufferData.toString('hex') });
-                return;
-            }
-            const { portName, resolve } = this.state.sending;
             let incoming = bufferData;
-            this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(incoming) });
+            if (depth === 0)
+                this.logEvent({ message: 'sendCommand:RECV', data: (0, utils_1.hexstr)(incoming), state: this.recvState });
             for (let i = 0; i < incoming.length; i++) {
                 const getRemaining = () => {
                     let remaining = '';
@@ -278,179 +266,222 @@ class Daum8i {
                 };
                 const c = incoming.readUInt8(i);
                 if (c === 0x06) {
-                    this.state.waitingForStart = true;
-                    this.state.waitingForACK = false;
+                    this.recvState.waitingForStart = true;
+                    this.recvState.waitingForACK = false;
                     const remaining = getRemaining();
-                    this.logEvent({ message: "sendCommand:ACK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
+                    this.recvState.data.enqueue({ type: 'ACK' });
                     if (remaining && remaining !== '' && depth < MAX_DEPTH)
                         return this.onData(remaining, depth + 1);
                 }
                 else if (c === 0x15) {
-                    this.state.waitingForStart = true;
-                    this.state.waitingForACK = false;
+                    this.recvState.waitingForStart = true;
+                    this.recvState.waitingForACK = false;
                     const remaining = getRemaining();
-                    this.logEvent({ message: "sendCommand:NAK received:", port: portName, remaining: (0, utils_1.hexstr)(remaining) });
+                    this.recvState.data.enqueue({ type: 'NAK' });
                     if (remaining && remaining !== '' && depth < MAX_DEPTH)
                         return this.onData(remaining, depth + 1);
                 }
                 else if (c === 0x01) {
-                    this.state.waitingForEnd = true;
+                    this.recvState.waitingForStart = false;
+                    this.recvState.waitingForEnd = true;
                 }
                 else if (c === 0x17) {
                     const remaining = getRemaining();
-                    if (this.state.waitingForACK) {
-                        this.logEvent({ message: "sendCommand:ignored:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${(0, utils_1.hexstr)(cmd)}]`, remaining: (0, utils_1.hexstr)(remaining) });
-                        this.state.waitingForEnd = false;
+                    this.recvState.waitingForEnd = false;
+                    const cmdStr = cmd.substring(0, cmd.length - 2);
+                    const checksumExtracted = cmd.slice(-2);
+                    const checksumCalculated = (0, utils_1.checkSum)((0, utils_1.getAsciiArrayFromStr)(cmdStr), []);
+                    if (checksumExtracted === checksumCalculated) {
+                        const payload = cmd.substring(3, cmd.length - 2);
+                        this.recvState.data.enqueue({ type: 'Response', data: payload });
                     }
                     else {
-                        this.logEvent({ message: "sendCommand:received:", duration: Date.now() - this.state.sending.tsRequest, port: portName, cmd: `${cmd} [${(0, utils_1.hexstr)(cmd)}]`, remaining: (0, utils_1.hexstr)(remaining) });
-                        this.state.waitingForEnd = false;
-                        const cmdStr = cmd.substring(0, cmd.length - 2);
-                        const checksumExtracted = cmd.slice(-2);
-                        const checksumCalculated = (0, utils_1.checkSum)((0, utils_1.getAsciiArrayFromStr)(cmdStr), []);
-                        if (checksumExtracted === checksumCalculated) {
-                            yield this.sendACK();
-                            if (this.state.sending && this.state.sending.responseCheckIv) {
-                                clearInterval(this.state.sending.responseCheckIv);
-                            }
-                            this.state = {
-                                sending: undefined,
-                                busy: false,
-                                writeBusy: false,
-                                waitingForStart: false,
-                                waitingForEnd: false,
-                                waitingForACK: false,
-                            };
-                            const payload = cmd.substring(3, cmd.length - 2);
-                            resolve(payload);
-                        }
-                        else {
-                            yield this.sendNAK();
-                        }
+                        const error = new CheckSumError();
+                        this.recvState.data.enqueue({ type: 'Error', error, data: cmd });
+                        this.recvState.waitingForACK = false;
+                        this.recvState.waitingForStart = true;
+                        this.recvState.waitingForEnd = false;
                     }
                     cmd = '';
                     if (remaining && depth < 5)
                         return this.onData(remaining, depth + 1);
                 }
                 else {
-                    if (this.state.waitingForEnd)
+                    if (this.recvState.waitingForEnd)
                         cmd += String.fromCharCode(c);
                 }
             }
-            if (this.state.waitingForEnd) {
-                this.state.partialCmd = cmd;
+            if (this.recvState.waitingForEnd) {
+                this.recvState.partialCmd = cmd;
             }
         });
     }
-    sendDaum8iCommand(command, payload = '') {
-        const tsRequest = Date.now();
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            if (this.blocked)
-                return reject(new Error('blocked'));
-            if (!this.state.busy) {
-                this.state.busy = true;
+    waitWithTimeout(promise, timeout, onTimeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let to;
+            const toPromise = (ms) => {
+                return new Promise(resolve => { to = setTimeout(resolve, ms); });
+            };
+            let res;
+            try {
+                res = yield Promise.race([promise, toPromise(timeout).then(() => { if (onTimeout)
+                        onTimeout(); })]);
             }
-            else {
-                const message = (0, utils_1.buildMessage)(command, payload);
+            catch (_a) {
+            }
+            clearTimeout(to);
+            return res;
+        });
+    }
+    sendDaum8iCommand(command, payload = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = (0, utils_1.buildMessage)(command, payload);
+            const tsRequest = Date.now();
+            if (this.sendCmdPromise) {
                 this.logEvent({ message: 'sendCommand:waiting', port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message) });
-                const busyWait = () => {
-                    return new Promise((done) => {
-                        let start = Date.now();
-                        let timeout = start + 5000;
-                        const iv = setInterval(() => {
-                            if (this.state.busy) {
-                                if (Date.now() > timeout) {
-                                    clearInterval(iv);
-                                    done(false);
-                                }
-                            }
-                            else {
-                                clearInterval(iv);
-                                done(true);
-                            }
-                        }, 10);
-                    });
-                };
-                const res = yield busyWait();
-                if (!res) {
+                const onTimeout = () => {
                     this.logEvent({ message: 'sendCommand:busy timeout', port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message), duration: Date.now() - tsRequest });
-                    return reject(new Error('BUSY timeout'));
+                    throw new Error('BUSY timeout');
+                };
+                this.waitWithTimeout(this.sendCmdPromise, 5000, onTimeout);
+                this.sendCmdPromise = null;
+            }
+            this.sendCmdPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.logEvent({ message: "sendCommand:sending:", port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message) });
+                    if (!this.isConnected()) {
+                        const connected = yield this.connect();
+                        if (!connected) {
+                            reject(new Error('not connected'));
+                            return;
+                        }
+                    }
+                    let retryCnt = 0;
+                    let ok = false;
+                    do {
+                        yield this.write(Buffer.from(message));
+                        ok = yield this.waitForACK();
+                        if (!ok) {
+                            yield (0, utils_2.sleep)(1000);
+                            retryCnt++;
+                        }
+                    } while (!ok && retryCnt < 5);
+                    const res = yield this.waitForResponse();
+                    this.sendCmdPromise = null;
+                    resolve(res);
+                }
+                catch (err) {
+                    this.logEvent({ message: "sendCommand:error:", port: this.path, error: err.message, stack: err.stack });
+                    this.sendCmdPromise = null;
+                    reject(err);
+                }
+            }));
+            return this.sendCmdPromise;
+        });
+    }
+    onIgnored(payload) {
+        this.logEvent({ message: 'onData:IGNORED', port: this.path, data: payload });
+    }
+    onACK() {
+    }
+    waitForACK() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.recvState.waitingForACK = true;
+            const timeout = this.getTimeoutValue();
+            let waitingForACK = true;
+            let start = Date.now();
+            let tsTimeout = start + timeout;
+            while (waitingForACK && Date.now() < tsTimeout) {
+                const response = this.recvState.data.dequeue();
+                if (!response) {
+                    yield (0, utils_2.sleep)(5);
+                }
+                else {
+                    if (response.type === 'ACK' || response.type === 'NAK') {
+                        this.logEvent({ message: `sendCommand:${response.type} received:`, port: this.path });
+                        waitingForACK = false;
+                        return (response.type === 'ACK');
+                    }
                 }
-                this.state.busy = true;
             }
-            const port = this.sp;
-            const portName = this.path;
-            this.state.received = [];
-            try {
-                const message = (0, utils_1.buildMessage)(command, payload);
-                const start = Date.now();
-                const timeout = start + this.getTimeoutValue();
-                this.logEvent({ message: "sendCommand:sending:", port: this.path, cmd: command, hex: (0, utils_1.hexstr)(message) });
-                this.state.writeBusy = true;
-                if (!this.connected || port === undefined) {
-                    this.logEvent({ message: "sendCommand:error: not connected", port: this.path });
-                    this.writeDone();
-                    return reject(new Error('not connected'));
+            throw new ACKTimeout();
+        });
+    }
+    waitForResponse() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timeout = this.getTimeoutValue();
+            let waitingForResponse = true;
+            let start = Date.now();
+            let tsTimeout = start + timeout;
+            let retry = 0;
+            while (waitingForResponse && Date.now() < tsTimeout && retry < 5) {
+                const response = this.recvState.data.dequeue();
+                if (!response) {
+                    yield (0, utils_2.sleep)(5);
                 }
-                yield this.write(Buffer.from(message));
-                this.state.waitingForACK = true;
-                this.state.writeBusy = false;
-                this.state.retry = 0;
-                this.state.ack = { start, timeout };
-                this.state.sending = { command, payload, start, timeout, port, portName, tsRequest, resolve, reject };
-                const iv = setInterval(() => {
-                    const stillWaiting = this.checkForResponse();
-                    if (!stillWaiting) {
-                        clearInterval(iv);
-                        this.writeDone();
+                else {
+                    if (response.type === 'Response') {
+                        this.logEvent({ message: `sendCommand:received:`, port: this.path, cmd: response.data });
+                        yield this.sendACK();
+                        waitingForResponse = false;
+                        return response.data;
+                    }
+                    if (response.type === 'Error') {
+                        this.logEvent({ message: `sendCommand:received:ERROR`, port: this.path, error: response.error.message });
+                        if (response.error instanceof CheckSumError && retry < 5) {
+                            yield this.sendNAK();
+                            retry++;
+                        }
+                        else {
+                            throw response.error;
+                        }
                     }
-                }, 10);
-                this.state.sending.responseCheckIv = iv;
+                }
+            }
+            throw new ResponseTimeout();
+        });
+    }
+    portWrite(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sp) {
+                this.logEvent({ message: 'write failed', error: 'port is not opened' });
+                return;
+            }
+            try {
+                yield this.sp.write(buffer);
             }
             catch (err) {
-                this.logEvent({ message: "sendCommand:error:", port: portName, error: err.message, stack: err.stack });
-                this.writeDone();
-                reject(err);
+                this.logEvent({ message: 'write failed', error: err.message });
             }
-        }));
-    }
-    writeDone() {
-        this.state.writeBusy = false;
-        this.state.busy = false;
-        if (this.state.sending && this.state.sending.responseCheckIv) {
-            clearInterval(this.state.sending.responseCheckIv);
-        }
-        this.state.sending = undefined;
-        this.state.waitingForStart = false;
-        this.state.waitingForEnd = false;
-        this.state.waitingForACK = false;
+        });
     }
-    write(buffer) {
+    write(buffer, ackExpected = true) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((done) => __awaiter(this, void 0, void 0, function* () {
-                this.state.writeBusy = true;
+            if (this.writePromise) {
                 try {
-                    yield this.sp.write(buffer);
-                    this.state.writeBusy = false;
-                    done();
+                    yield this.writePromise;
                 }
-                catch (err) {
-                    this.state.writeBusy = false;
-                    done();
+                catch (_a) {
                 }
-            }));
+                this.writePromise = null;
+            }
+            this.writePromise = this.portWrite(buffer);
+            if (ackExpected)
+                this.recvState.waitingForACK = true;
+            yield this.writePromise;
+            this.writePromise = null;
         });
     }
     sendACK() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: "sendCommand:sending ACK", port: this.path, queue: this.state.commandsInQueue });
-            yield this.write(Buffer.from([0x06]));
+            this.logEvent({ message: "sendCommand:sending ACK", port: this.path });
+            yield this.write(Buffer.from([0x06]), false);
         });
     }
     sendNAK() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: "sendCommand:sending NAK", port: this.path, queue: this.state.commandsInQueue });
-            yield this.write(Buffer.from([0x15]));
+            this.logEvent({ message: "sendCommand:sending NAK", port: this.path });
+            yield this.write(Buffer.from([0x15]), false);
         });
     }
     sendReservedDaum8iCommand(command, data) {
@@ -512,7 +543,7 @@ class Daum8i {
             else {
                 throw (new Error(`unknown actual device type ${typeof str === 'string' ? (0, utils_1.ascii)(str.charAt(0)) : str}`));
             }
-            this.state.actualBikeType = deviceType;
+            this.actualBikeType = deviceType;
             return deviceType;
         });
     }
@@ -545,7 +576,7 @@ class Daum8i {
                 deviceType = constants_1.ACTUAL_BIKE_TYPE.MOUNTAIN;
             else
                 throw (new Error('unknown actual device type'));
-            this.state.actualBikeType = deviceType;
+            this.actualBikeType = deviceType;
             return deviceType;
         });
     }

package/lib/serial/kettler/comms.d.ts

@@ -46,6 +46,7 @@ export default class KettlerSerialComms<T extends Command> extends EventEmitter
     _setSendState(state: SendState): void;
     _setCurrentCmd(cmd: T): void;
     stopCurrentTimeoutCheck(): void;
+    getSerialInterface(): SerialInterface;
     onPortOpen(): void;
     onPortClose(): Promise<void>;
     onPortError(err: any): void;

package/lib/serial/kettler/comms.js

@@ -102,6 +102,9 @@ class KettlerSerialComms extends events_1.default {
             this.currentTimeout = undefined;
         }
     }
+    getSerialInterface() {
+        return this.serial;
+    }
     onPortOpen() {
         this.logger.logEvent({ message: 'port opened', port: this.getPort() });
         this.state = SerialCommsState.Connected;

package/lib/serial/kettler/ergo-racer/adapter.d.ts

@@ -5,6 +5,7 @@ import { Command } from "../../../types/command";
 import CyclingMode, { IncyclistBikeData } from "../../../modes/cycling-mode";
 import { SerialDeviceSettings, SerialIncyclistDevice } from "../../adapter";
 import { DeviceData } from "../../../types/data";
+import SerialInterface from "../../serial-interface";
 export interface KettlerRacerCommand extends Command {
 }
 export interface KettlerExtendedBikeData {
@@ -44,6 +45,7 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     getID(): string;
     getName(): string;
     getPort(): string;
+    getSerialInterface(): SerialInterface;
     _getComms(): SerialComms<KettlerRacerCommand>;
     _setComms(comms: SerialComms<KettlerRacerCommand>): void;
     getLogger(): EventLogger;

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

@@ -58,6 +58,10 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
         const settings = this.settings;
         return settings.port;
     }
+    getSerialInterface() {
+        if (this.comms)
+            return this.comms.getSerialInterface();
+    }
     _getComms() {
         return this.comms;
     }

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

@@ -30,6 +30,7 @@ export declare class SinglePathScanner {
     isScanning: boolean;
     props: SerialScannerProps;
     logger: EventLogger;
+    isFound: boolean;
     constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
     logEvent(event: any): void;
     onStopRequest(resolve: any): Promise<void>;
@@ -45,6 +46,7 @@ export default class SerialInterface extends EventEmitter implements IncyclistIn
     logger: EventLogger;
     toScan: NodeJS.Timeout;
     connected: boolean;
+    inUse: string[];
     static _instances: SerialInterface[];
     static getInstance(props: SerialInterfaceProps): SerialInterface;
     static _add(instance: SerialInterface): void;
@@ -53,6 +55,8 @@ export default class SerialInterface extends EventEmitter implements IncyclistIn
     setBinding(binding: BindingInterface): void;
     getName(): string;
     isConnected(): boolean;
+    setInUse(path: string): void;
+    releaseInUse(path: string): void;
     connect(): Promise<boolean>;
     disconnect(): Promise<boolean>;
     openPort(path: string): Promise<SerialPortStream | null>;

package/lib/serial/serial-interface.js

@@ -18,6 +18,7 @@ const serialport_1 = __importDefault(require("./serialport"));
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../utils/utils");
 const adapters_1 = __importDefault(require("../adapters"));
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
 const DEFAULT_SCAN_TIMEOUT = 10000;
 exports.SerialInterfaceType = {
     SERIAL: 'serial',
@@ -29,6 +30,7 @@ class SinglePathScanner {
         this.serial = serial;
         this.result = undefined;
         this.isScanning = false;
+        this.isFound = false;
         this.props = props;
         this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
     }
@@ -44,7 +46,8 @@ class SinglePathScanner {
     onStopRequest(resolve) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'stopping scan', path: this.path });
-            yield this.serial.closePort(this.path);
+            if (!this.isFound)
+                yield this.serial.closePort(this.path);
             this.isScanning = false;
             resolve(this.result);
         });
@@ -73,8 +76,8 @@ class SinglePathScanner {
                         const adapter = adapters_1.default.create(adapterSettings);
                         found = yield adapter.check();
                         if (found) {
+                            this.isFound = true;
                             const name = adapter.getName();
-                            yield this.serial.closePort(this.path).catch();
                             resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
                         }
                         yield (0, utils_1.sleep)(100);
@@ -117,6 +120,7 @@ class SerialInterface extends events_1.default {
         this.ifaceName = ifaceName;
         this.binding = undefined;
         this.ports = [];
+        this.inUse = [];
         this.isScanning = false;
         this.isStopScanRequested = false;
         this.scanEvents = new events_1.default();
@@ -148,6 +152,18 @@ class SerialInterface extends events_1.default {
     isConnected() {
         return this.connected;
     }
+    setInUse(path) {
+        this.logEvent({ message: 'block port for further scans', port: path });
+        if (!this.inUse.includes(path))
+            this.inUse.push(path);
+    }
+    releaseInUse(path) {
+        if (this.inUse.includes(path)) {
+            this.logEvent({ message: 're-enable port for further scans', port: path });
+            const idx = this.inUse.findIndex(r => r === path);
+            this.inUse.splice(idx, 1);
+        }
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
@@ -255,13 +271,18 @@ class SerialInterface extends events_1.default {
                     this.scanEvents.emit('timeout');
                 }, timeout);
             }
-            this.logEvent({ message: 'checking for ports' });
             this.isScanning = true;
+            let attemptNo = 0;
             do {
+                if (attemptNo === 0)
+                    this.logEvent({ message: 'checking for ports', port, excludes: this.inUse });
+                else
+                    this.logEvent({ message: 'checking for ports retry', retry: attemptNo });
+                attemptNo++;
                 try {
                     if (this.getName() === 'tcpip') {
                         const _binding = binding;
-                        paths = (yield _binding.list(port)) || [];
+                        paths = (yield _binding.list(port, this.inUse)) || [];
                     }
                     else {
                         paths = (yield binding.list()) || [];
@@ -277,6 +298,7 @@ class SerialInterface extends events_1.default {
                 if (Date.now() > toExpiresAt)
                     timeOutExpired = true;
             } while (this.isScanning && !timeOutExpired && paths.length === 0);
+            paths = paths.filter(p => !this.inUse.includes(p.path));
             if (paths.length === 0) {
                 this.logEvent({ message: 'nothing to scan ' });
                 if (this.toScan) {
@@ -291,6 +313,9 @@ class SerialInterface extends events_1.default {
                 yield Promise.all(scanners.map(s => s.scan()
                     .then(device => {
                     if (device) {
+                        const adapter = adapter_factory_1.default.getInstance().createInstance(device);
+                        const path = adapter.getPort();
+                        this.inUse.push(path);
                         detected.push(device);
                         this.emit('device', device);
                     }

package/package.json

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