incyclist-devices 2.1.10 → 2.1.12

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

@@ -37,6 +37,8 @@ export default class SerialPortComms<T extends CommsState, C extends Request, R
     isConnected(): boolean;
     pauseLogging(): void;
     resumeLogging(): void;
+    pause(): void;
+    resume(): void;
     logEvent(e: any): void;
     connect(): Promise<boolean>;
     onConnected(): void;

package/lib/serial/base/comms.js

@@ -51,6 +51,12 @@ class SerialPortComms {
     resumeLogging() {
         this.isLoggingPaused = false;
     }
+    pause() {
+        this.pauseLogging();
+    }
+    resume() {
+        this.resumeLogging();
+    }
     logEvent(e) {
         if (this.isLoggingPaused)
             return;

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

@@ -24,10 +24,16 @@ export declare class TCPPortBinding implements BindingPortInterface {
     writeOperation: null | Promise<any>;
     data: Buffer;
     private pendingRead;
+    private onDataHandler;
+    private onErrorHandler;
+    private onTimeoutHandler;
+    private onCloseHandler;
     constructor(socket: net.Socket, options: Required<OpenOptions>);
     get isOpen(): boolean;
     onData(data: Buffer): void;
     onError(err: Error): void;
+    onTimeout(): void;
+    onClose(): void;
     close(): Promise<void>;
     read(buffer: Buffer, offset: number, length: number): Promise<{
         buffer: Buffer;

package/lib/serial/bindings/tcp.js

@@ -141,6 +141,10 @@ exports.TCPBinding = {
 };
 class TCPPortBinding {
     constructor(socket, options) {
+        this.onDataHandler = this.onData.bind(this);
+        this.onErrorHandler = this.onError.bind(this);
+        this.onTimeoutHandler = this.onTimeout.bind(this);
+        this.onCloseHandler = this.onClose.bind(this);
         this.logger = new gd_eventlog_1.EventLogger('TCPPort');
         this.socket = socket;
         this.openOptions = options;
@@ -148,11 +152,11 @@ class TCPPortBinding {
         this.writeOperation = null;
         this.data = null;
         this.socket.removeAllListeners();
-        this.socket.on('data', this.onData.bind(this));
-        this.socket.on('error', this.onError.bind(this));
-        this.socket.on('close', () => { this.close(); });
-        this.socket.on('end', () => { this.close(); });
-        this.socket.on('timeout', () => { this.onError(new Error('socket timeout')); });
+        this.socket.on('data', this.onDataHandler);
+        this.socket.on('error', this.onErrorHandler);
+        this.socket.on('close', this.onCloseHandler);
+        this.socket.on('end', this.onCloseHandler);
+        this.socket.on('timeout', this.onTimeoutHandler);
     }
     get isOpen() {
         return this.socket !== null;
@@ -168,11 +172,21 @@ class TCPPortBinding {
         }
     }
     onError(err) {
+        this.logger.logEvent({ message: 'Port Error', error: err.message });
         if (this.pendingRead) {
             this.pendingRead(err);
             this.socket = null;
         }
     }
+    onTimeout() {
+        this.logger.logEvent({ message: 'Port Timeout' });
+        if (this.pendingRead) {
+            this.pendingRead(new Error('timeout'));
+        }
+    }
+    onClose() {
+        this.close();
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isOpen)
@@ -217,6 +231,10 @@ class TCPPortBinding {
                 return new Promise((resolve, reject) => {
                     this.pendingRead = err => {
                         if (err) {
+                            if (err.message === 'timeout') {
+                                resolve({ buffer: Buffer.from([]), bytesRead: 0 });
+                                return;
+                            }
                             return reject(err);
                         }
                         this.read(buffer, offset, length).then(resolve, reject);

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

@@ -1,15 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { IncyclistAdapterData, ControllerConfig, IAdapter, DeviceProperties, IncyclistBikeData } from '../../types';
 import { SerialDeviceSettings } from "../types";
 import { DaumSerialComms } from './types';
 import { SerialIncyclistDevice } from '../base/adapter';
 import SerialInterface from '../base/serial-interface';
+import EventEmitter from 'events';
 export default class DaumAdapter<S extends SerialDeviceSettings, P extends DeviceProperties, C extends DaumSerialComms> extends SerialIncyclistDevice<P> {
     protected static controllers: ControllerConfig;
     comms: C;
     distanceInternal: number;
     deviceData: IncyclistBikeData;
     requests: Array<any>;
-    iv: any;
+    iv: {
+        sync: NodeJS.Timeout;
+        update: NodeJS.Timeout;
+        emitter: EventEmitter;
+        stopRequested?: boolean;
+    };
     tsPrevData: number;
     adapterTime: number;
     requestBusy: boolean;
@@ -35,7 +43,8 @@ export default class DaumAdapter<S extends SerialDeviceSettings, P extends Devic
     start(props?: P): Promise<boolean>;
     performStart(props?: P, isRelaunch?: boolean, wasPaused?: boolean): Promise<boolean>;
     startUpdatePull(): void;
-    stopUpdatePull(): void;
+    protected cleanupInterval(): void;
+    stopUpdatePull(): Promise<void>;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     verifyConnection(): Promise<void>;

package/lib/serial/daum/DaumAdapter.js

@@ -18,6 +18,7 @@ const types_1 = require("../../types");
 const adapter_1 = require("../base/adapter");
 const daum_smarttrainer_1 = __importDefault(require("../../modes/daum-smarttrainer"));
 const daum_power_1 = __importDefault(require("../../modes/daum-power"));
+const events_1 = __importDefault(require("events"));
 class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     constructor(settings, props) {
         super(settings, props);
@@ -116,7 +117,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.stopUpdatePull();
             const paused = yield _super.pause.call(this);
-            (_a = this.comms) === null || _a === void 0 ? void 0 : _a.pauseLogging();
+            (_a = this.comms) === null || _a === void 0 ? void 0 : _a.pause();
             return paused;
         });
     }
@@ -127,7 +128,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const resumed = yield _super.resume.call(this);
-            (_a = this.comms) === null || _a === void 0 ? void 0 : _a.resumeLogging();
+            (_a = this.comms) === null || _a === void 0 ? void 0 : _a.resume();
             if (startUpdatePull)
                 yield this.startUpdatePull();
             return resumed;
@@ -247,17 +248,39 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         }, this.pullFrequency);
         this.iv = {
             sync: ivSync,
-            update: ivUpdate
+            update: ivUpdate,
+            emitter: new events_1.default()
         };
+        this.iv.emitter.once('stop', () => {
+            this.iv.stopRequested = true;
+        });
     }
-    stopUpdatePull() {
+    cleanupInterval() {
         if (!this.iv)
             return;
-        this.logEvent({ message: 'stop update pull', port: this.getPort() });
-        clearInterval(this.iv.sync);
-        clearInterval(this.iv.update);
+        if (this.iv.sync)
+            clearInterval(this.iv.sync);
+        if (this.iv.sync)
+            clearInterval(this.iv.update);
+        if (this.iv.emitter)
+            this.iv.emitter.removeAllListeners();
         this.iv = undefined;
     }
+    stopUpdatePull() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.iv || !this.iv.emitter)
+                return;
+            return new Promise(done => {
+                this.iv.emitter.on('stop-done', () => {
+                    this.logEvent({ message: 'stop update pull done', port: this.getPort() });
+                    this.cleanupInterval();
+                    done();
+                });
+                this.iv.emitter.emit('stop');
+                this.logEvent({ message: 'stop update pull', port: this.getPort() });
+            });
+        });
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.comms)
@@ -321,7 +344,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             if (this.paused)
                 this.resume();
             try {
-                this.stopUpdatePull();
+                yield this.stopUpdatePull();
                 yield this.comms.close();
                 this.logEvent({ message: 'stop request completed' });
                 this.stopped = true;
@@ -392,9 +415,15 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         });
     }
     bikeSync() {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendRequests();
-            yield this.update();
+            if (!((_a = this.iv) === null || _a === void 0 ? void 0 : _a.stopRequested))
+                yield this.sendRequests();
+            if (!((_b = this.iv) === null || _b === void 0 ? void 0 : _b.stopRequested))
+                yield this.update();
+            if ((_c = this.iv) === null || _c === void 0 ? void 0 : _c.stopRequested) {
+                this.iv.emitter.emit('stop-done', 'bikeSync');
+            }
         });
     }
     updateData(bikeData) {

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

@@ -5,6 +5,7 @@ import { DaumSerialComms } from "../types";
 import { OnDeviceStartCallback, DaumPremiumCommsState, DaumPremiumRequest, ResponseObject, Route } from "./types";
 import SerialPortComms from "../../base/comms";
 export default class Daum8i extends SerialPortComms<DaumPremiumCommsState, DaumPremiumRequest, ResponseObject> implements DaumSerialComms {
+    private onDataHandler;
     validatePath(path: string): string;
     getDefaultLoggerName(): string;
     getAckTimeoutValue(): number;
@@ -43,4 +44,6 @@ export default class Daum8i extends SerialPortComms<DaumPremiumCommsState, DaumP
     programUploadDone(): Promise<boolean>;
     startProgram(programId?: number): Promise<boolean>;
     programUpload(bikeType: string, route: Route, onStatusUpdate?: OnDeviceStartCallback): Promise<boolean>;
+    pause(): void;
+    resume(): void;
 }

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

@@ -20,6 +20,10 @@ const utils_2 = require("../../../utils/utils");
 const comms_1 = __importDefault(require("../../base/comms"));
 const consts_1 = require("./consts");
 class Daum8i extends comms_1.default {
+    constructor() {
+        super(...arguments);
+        this.onDataHandler = this.onData.bind(this);
+    }
     validatePath(path) {
         return (0, utils_1.validatePath)(path);
     }
@@ -33,7 +37,7 @@ class Daum8i extends comms_1.default {
         return consts_1.DEFAULT_TIMEOUT;
     }
     onConnected() {
-        this.sp.on('data', this.onData.bind(this));
+        this.sp.on('data', this.onDataHandler);
     }
     getInitialCommsState() {
         const state = super.getInitialCommsState();
@@ -574,5 +578,11 @@ class Daum8i extends comms_1.default {
             }
         });
     }
+    pause() {
+        super.pause();
+    }
+    resume() {
+        super.resume();
+    }
 }
 exports.default = Daum8i;

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

@@ -1,8 +1,8 @@
 export declare abstract class DaumSerialComms {
     serial: any;
     abstract getPort(): string;
-    abstract pauseLogging(): void;
-    abstract resumeLogging(): void;
+    abstract pause(): void;
+    abstract resume(): void;
     abstract isConnected(): boolean;
     abstract connect(): Promise<boolean>;
     abstract close(): Promise<boolean>;

package/package.json

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