incyclist-devices 2.0.32 → 2.0.33

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

@@ -190,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();
@@ -244,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,8 +36,38 @@ const validatePath = (path) => {
     const port = parts[1];
     return `${host}:${port}`;
 };
+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;
@@ -43,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,
@@ -64,7 +93,7 @@ class Daum8i {
         return this.path;
     }
     isConnected() {
-        return this.connected;
+        return this.connectState === 'Connected' || this.connectState === 'Disconnecting';
     }
     pauseLogging() {
         this.isLoggingPaused = true;
@@ -86,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;
@@ -253,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 = '';
@@ -277,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) {
@@ -511,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;
         });
     }
@@ -544,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/package.json

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