incyclist-devices 2.1.13 → 2.1.15

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

@@ -58,6 +58,7 @@ export default class SerialPortComms<T extends CommsState, C extends Request, R
     onData(data: any, depth?: number): Promise<void>;
     send(command: C): Promise<R>;
     portWrite(buffer: Buffer): Promise<void>;
+    portRead(size?: number): Promise<any>;
     write(buffer: Buffer): Promise<void>;
     ensurePrevCmdFinish(logPayload: any): Promise<void>;
     ensureConnection(): Promise<void>;

package/lib/serial/base/comms.js

@@ -240,6 +240,15 @@ class SerialPortComms {
             }
         });
     }
+    portRead(size) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sp) {
+                this.logEvent({ message: 'write failed', error: 'port is not opened' });
+                return;
+            }
+            return yield this.sp.read(size);
+        });
+    }
     write(buffer) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.writePromise) {

package/lib/serial/base/serial-interface.js

@@ -208,8 +208,7 @@ class SerialInterface extends events_1.default {
                 if (attemptNo === 0)
                     this.logEvent({ message: 'checking for ports', interface: this.ifaceName, port, excludes: this.inUse });
                 else
-                    this.logEvent({ message: 'checking for ports retry', interface: this.ifaceName, retry: attemptNo });
-                attemptNo++;
+                    attemptNo++;
                 try {
                     if (isTcpip) {
                         const _binding = binding;
@@ -223,7 +222,7 @@ class SerialInterface extends events_1.default {
                     this.logEvent({ message: 'error', fn: 'scan#detect ports', error: err.message, interface: this.ifaceName, port, excludes: this.inUse });
                 }
                 paths = paths.filter(p => !this.inUse.includes(p.path));
-                if (!paths || paths.length === 0) {
+                if ((!paths || paths.length === 0) && attemptNo === 1) {
                     this.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
                     yield (0, utils_1.sleep)(1000);
                 }

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

@@ -105,21 +105,22 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 if (!isRelaunch && !this.getComms().isConnected()) {
                     yield this.verifyConnection();
                 }
-                yield this.getComms().resetDevice();
-                if (!startState.setProg) {
+                if (!wasPaused)
+                    yield this.getComms().resetDevice();
+                if (!wasPaused && !startState.setProg) {
                     yield this.getComms().setProg(0);
                     startState.setProg = true;
                 }
-                if (!startState.setPerson) {
+                if (!wasPaused && !startState.setPerson) {
                     yield this.getComms().setPerson(user);
                     startState.setPerson = true;
                 }
-                if (!startState.setBikeType) {
+                if (!wasPaused && !startState.setBikeType) {
                     const bikeType = this.getCyclingMode().getSetting('bikeType') || 'race';
                     yield this.getComms().setBikeType(bikeType.toLowerCase());
                     startState.setBikeType = true;
                 }
-                if (!startState.startProg) {
+                if (!wasPaused && !startState.startProg) {
                     yield this.getComms().startProg();
                     startState.startProg = true;
                 }

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

@@ -6,6 +6,7 @@ import { DeviceType, IncyclistBikeData, User } from '../../../types';
 export default class Daum8008 extends SerialPortComms<DaumClassicCommsState, DaumClassicRequest, DaumClassicResponse> implements DaumSerialComms {
     protected bikeNo: number;
     protected prevFailedPayload: any;
+    protected expected: any;
     constructor(props: SerialCommProps);
     validatePath(path: string): string;
     getDefaultLoggerName(): string;

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

@@ -22,6 +22,7 @@ class Daum8008 extends comms_1.default {
     constructor(props) {
         super(props);
         this.bikeNo = 0;
+        this.expected = undefined;
     }
     validatePath(path) {
         return path;
@@ -36,13 +37,7 @@ class Daum8008 extends comms_1.default {
     }
     initForResponse(expected) {
         return __awaiter(this, void 0, void 0, function* () {
-            const parser = this.portPipe(new ByteLength({ length: expected }));
-            if (!parser)
-                return;
-            parser.on('data', (data) => {
-                this.portUnpipe();
-                this.recvState.data.enqueue({ type: 'Response', data });
-            });
+            this.expected = expected;
         });
     }
     waitForResponse() {
@@ -52,10 +47,9 @@ class Daum8008 extends comms_1.default {
             let start = Date.now();
             let tsTimeout = start + timeout;
             while (waitingForResponse && Date.now() < tsTimeout) {
-                const response = this.recvState.data.dequeue();
-                if (response) {
-                    return response;
-                }
+                const data = yield this.portRead(this.expected);
+                if (data)
+                    return { type: 'Response', data };
                 yield (0, utils_1.sleep)(5);
             }
             throw new types_1.ResponseTimeout();

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

@@ -66,12 +66,14 @@ export declare class DaumClassicSimulator {
     _timeoutResponse: number;
     _simulateNoReponseCnt: number;
     _simulateIllegalResponseCnt: number;
+    _simulatePartialDelayed: number;
     openHandles: Array<NodeJS.Timeout>;
     constructor();
     reset(): void;
     simulateTimeout(ms: number): void;
     simulateNoResponse(cnt?: number): void;
     simulateIllegalResponse(cnt?: number): void;
+    simulatePartialDelayed(cnt?: number): void;
     addHandle(handle: NodeJS.Timeout): void;
     cleanup(): void;
     isPedalling(): 0 | 1;
@@ -84,7 +86,7 @@ export declare class DaumClassicMockBinding extends MockPortBinding {
     getPath(): string;
     initHandlers(): void;
     write(buffer: Buffer): Promise<void>;
-    emitData(data: string | Buffer): void;
+    emitData(data: string | Buffer): Promise<void>;
     onCheckCockpit(payload: Buffer): void;
     onGetAddress(_payload: Buffer): void;
     onGetVersion(payload: Buffer): void;

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

@@ -91,6 +91,7 @@ class DaumClassicSimulator {
         this._timeoutResponse = 0;
         this._simulateNoReponseCnt = 0;
         this._simulateIllegalResponseCnt = 0;
+        this._simulatePartialDelayed = 0;
         this.openHandles = [];
         for (let i = 0; i < 10; i++)
             this.bikes.push(Object.assign({}, DEFAULT_BIKE_DATA));
@@ -119,6 +120,9 @@ class DaumClassicSimulator {
     simulateIllegalResponse(cnt = 1) {
         this._simulateIllegalResponseCnt += cnt;
     }
+    simulatePartialDelayed(cnt = 1) {
+        this._simulatePartialDelayed += cnt;
+    }
     addHandle(handle) {
         this.openHandles.push(handle);
     }
@@ -202,9 +206,29 @@ class DaumClassicMockBinding extends binding_mock_1.MockPortBinding {
         });
     }
     emitData(data) {
-        if (!this.isOpen || !this.port)
-            return;
-        super.emitData(data);
+        const _super = Object.create(null, {
+            emitData: { get: () => super.emitData }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isOpen || !this.port)
+                return;
+            if (this.simulator._simulatePartialDelayed > 0) {
+                this.simulator._simulatePartialDelayed--;
+                let buffer;
+                if (Buffer.isBuffer(data))
+                    buffer = data;
+                else
+                    buffer = Buffer.from(data);
+                const data1 = buffer.subarray(0, buffer.length - 1);
+                const data2 = buffer.subarray(buffer.length - 1, buffer.length);
+                _super.emitData.call(this, data1);
+                yield (0, utils_1.sleep)(10);
+                _super.emitData.call(this, data2);
+            }
+            else {
+                _super.emitData.call(this, data);
+            }
+        });
     }
     onCheckCockpit(payload) {
         const bikeNo = payload.readUInt8(0);

package/package.json

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