incyclist-devices 1.4.18 → 1.4.21

package/lib/Device.d.ts

@@ -12,6 +12,7 @@ export declare type DeviceData = {
     timestamp?: number;
     deviceTime?: number;
     deviceDistanceCounter?: number;
+    internalDistanceCounter?: number;
 };
 export declare type OnDeviceDataCallback = (data: DeviceData) => void;
 export declare type OnDeviceStartCallback = (completed: number, total: number) => void;

package/lib/kettler/comms.js

@@ -16,7 +16,7 @@ const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../utils");
 const events_1 = __importDefault(require("events"));
 const DEFAULT_RCV_TIMEOUT = 1500;
-const DEFAULT_OPEN_TIMEOUT = 1500;
+const DEFAULT_OPEN_TIMEOUT = 3000;
 const DEBUG_LOGGER = {
     log: (e, ...args) => console.log(e, ...args),
     logEvent: (event) => console.log(JSON.stringify(event))
@@ -200,6 +200,7 @@ class KettlerSerialComms extends events_1.default {
                 cmd.onError(err);
             this.sendState = SendState.Idle;
             this.currentCmd = undefined;
+            this.stopCurrentTimeoutCheck();
         };
         try {
             this.logger.logEvent({ message: "sendCommand:sending:", cmd: logStr, msg, port: this.getPort() });
@@ -208,16 +209,17 @@ class KettlerSerialComms extends events_1.default {
             this.sp.write(msg + CRLF, (err) => {
                 this.sendState = SendState.Receiving;
                 this.currentCmd = cmd;
-                if (timeout) {
-                    this.currentTimeout = setTimeout(() => {
-                        if (this.sendState === SendState.Receiving) {
-                            onError(new Error("response timeout"));
-                        }
-                    }, timeout);
-                }
                 if (err)
                     onError(err);
             });
+            this.currentTimeout = setTimeout(() => {
+                if (this.sendState === SendState.Sending) {
+                    onError(new Error("send timeout"));
+                }
+                if (this.sendState === SendState.Receiving) {
+                    onError(new Error("response timeout"));
+                }
+            }, timeout);
         }
         catch (err) {
             onError(err);
@@ -232,7 +234,7 @@ class KettlerSerialComms extends events_1.default {
             this.write(cmd);
     }
     send(cmd) {
-        this.logger.logEvent({ message: 'send()', cmd: cmd.logStr, port: this.getPort(), queueSize: this.queue.size() });
+        this.logger.logEvent({ message: 'add command to queue', cmd: cmd.logStr, msg: cmd.message, port: this.getPort(), queueSize: this.queue.size() });
         this.queue.enqueue(cmd);
     }
 }

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

@@ -37,11 +37,12 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     private iv;
     private requests;
     private data;
-    private idata;
+    private internalData;
     private kettlerData;
     private updateBusy;
     private requestBusy;
     private comms;
+    private prevDistance;
     constructor(protocol: DeviceProtocol, settings: DeviceSettings);
     isBike(): boolean;
     isPower(): boolean;
@@ -76,7 +77,7 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     parseExtendedStatus(data: string): KettlerExtendedBikeData;
     parseStatus(data: string): KettlerBikeData;
     check(): Promise<boolean>;
-    start(props?: any): Promise<any>;
+    start(props?: any): Promise<IncyclistBikeData>;
     startUpdatePull(): void;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
@@ -91,7 +92,7 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     sendData(): void;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
-    waitForOpened(): Promise<boolean>;
+    waitForOpened(retries?: boolean): Promise<boolean>;
     waitForClosed(): Promise<boolean>;
     getSupportedCyclingModes(): any[];
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;

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

@@ -220,7 +220,7 @@ class KettlerRacerAdapter extends Device_1.default {
             }
             const distance = parseInt(states[3]);
             if (!isNaN(distance)) {
-                result.distance = distance;
+                result.distance = distance * 100;
             }
             const requestedPower = parseInt(states[4]);
             if (!isNaN(requestedPower)) {
@@ -228,7 +228,7 @@ class KettlerRacerAdapter extends Device_1.default {
             }
             const energy = parseInt(states[5]);
             if (!isNaN(energy)) {
-                result.requestedPower = energy;
+                result.energy = energy;
             }
             const timeStr = states[6];
             const time = timeStr.split(':');
@@ -284,47 +284,49 @@ class KettlerRacerAdapter extends Device_1.default {
         });
     }
     start(props) {
-        this.logger.logEvent({ message: 'start()' });
-        var info = {};
-        return utils_1.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!info.checkDone) {
-                    info.checkDone = yield this.check();
-                }
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start()' });
+            var info = {};
+            yield this.waitForOpened(true);
+            return utils_1.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    if (!info.started) {
-                        info.started = yield this.startTraining();
+                    if (!info.checkDone) {
+                        info.checkDone = yield this.check();
                     }
+                    try {
+                        if (!info.started) {
+                            info.started = yield this.startTraining();
+                        }
+                    }
+                    catch (e) {
+                        this.logger.logEvent({ message: 'Error', error: e.message });
+                    }
+                    try {
+                        yield this.setPower(100);
+                    }
+                    catch (e) {
+                        this.logger.logEvent({ message: 'Error', error: e.message });
+                    }
+                    if (!info.data) {
+                        yield this.update();
+                        info.data = this.data;
+                    }
+                    return info.data;
                 }
-                catch (e) {
-                    this.logger.logEvent({ message: 'Error', error: e.message });
-                }
-                try {
-                    yield this.setPower(100);
-                }
-                catch (e) {
-                    this.logger.logEvent({ message: 'Error', error: e.message });
-                }
-                if (!info.data) {
-                    yield this.update();
-                    info.data = this.data;
-                }
-                return info.data;
-            }
-            catch (err) {
-                console.log('~~~ Error', err);
-                try {
-                    yield this.reset();
-                }
-                catch (e) {
-                    this.logger.logEvent({ message: 'Error', error: e.message });
+                catch (err) {
+                    try {
+                        yield this.reset();
+                    }
+                    catch (e) {
+                        this.logger.logEvent({ message: 'Error', error: e.message });
+                    }
+                    throw (new Error(`could not start device, reason:${err.message}`));
                 }
-                throw (new Error(`could not start device, reason:${err.message}`));
-            }
-        }), 5, 1000)
-            .then(data => {
-            this.startUpdatePull();
-            return data;
+            }), 5, 1000)
+                .then((data) => {
+                this.startUpdatePull();
+                return data;
+            });
         });
     }
     startUpdatePull() {
@@ -395,6 +397,10 @@ class KettlerRacerAdapter extends Device_1.default {
     }
     transformData(internalData, bikeData) {
         let data = {};
+        const prevDistance = this.prevDistance || 0;
+        let distance = internalData.distanceInternal - prevDistance;
+        if (distance < 0)
+            distance = internalData.distanceInternal < 100 ? internalData.distanceInternal : 0;
         data.heartrate = internalData.heartrate;
         data.timestamp = Date.now();
         data.deviceTime = bikeData.time;
@@ -402,8 +408,10 @@ class KettlerRacerAdapter extends Device_1.default {
             data.speed = internalData.speed;
             data.power = internalData.power;
             data.cadence = internalData.pedalRpm;
-            data.distance = internalData.distanceInternal;
+            data.distance = distance;
             data.deviceDistanceCounter = bikeData.distance;
+            data.internalDistanceCounter = internalData.distanceInternal;
+            this.prevDistance = internalData.distanceInternal;
         }
         if (this.ignoreHrm)
             delete this.data.heartrate;
@@ -416,13 +424,14 @@ class KettlerRacerAdapter extends Device_1.default {
     update() {
         return __awaiter(this, void 0, void 0, function* () {
             this.updateBusy = true;
-            this.getStatus()
+            return this.getStatus()
                 .then((bikeData) => {
                 if (bikeData) {
                     try {
                         this.kettlerData = bikeData;
                         let data = this.mapData(bikeData);
                         data = this.getCyclingMode().updateData(data);
+                        this.internalData = data;
                         this.data = this.transformData(data, bikeData);
                     }
                     catch (err) {
@@ -534,34 +543,38 @@ class KettlerRacerAdapter extends Device_1.default {
             resolve(bikeRequest);
         }));
     }
-    waitForOpened() {
-        return utils_1.runWithRetries(() => {
-            return new Promise((resolve, reject) => {
-                try {
-                    if (this.comms.isConnected()) {
-                        resolve(true);
-                        return;
-                    }
-                    const cleanup = () => {
-                        this.comms.removeAllListeners();
-                    };
-                    const onOpen = () => {
-                        resolve(true);
-                        cleanup();
-                    };
-                    const onError = (err) => { reject(err); cleanup(); };
-                    const onClose = () => { cleanup(); };
-                    this.comms.on('opened', onOpen);
-                    this.comms.on('closed', onClose);
-                    this.comms.on('error', onError);
-                    this.logger.logEvent({ message: 'opening', port: this.getPort() });
-                    this.comms.open();
-                }
-                catch (err) {
-                    this.logger.logEvent({ message: 'error', fn: 'waitForOpened()', error: err.message || err });
-                    reject(err);
+    waitForOpened(retries = false) {
+        const run = (resolve, reject) => {
+            try {
+                if (this.comms.isConnected()) {
+                    resolve(true);
+                    return;
                 }
-            });
+                const cleanup = () => {
+                    this.comms.removeAllListeners();
+                };
+                const onOpen = () => {
+                    resolve(true);
+                    cleanup();
+                };
+                const onError = (err) => { reject(err); cleanup(); };
+                const onClose = () => { cleanup(); };
+                this.comms.on('opened', onOpen);
+                this.comms.on('closed', onClose);
+                this.comms.on('error', onError);
+                this.logger.logEvent({ message: 'opening', port: this.getPort() });
+                this.comms.open();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'error', fn: 'waitForOpened()', error: err.message || err });
+                reject(err);
+            }
+        };
+        if (!retries) {
+            return new Promise((resolve, reject) => run(resolve, reject));
+        }
+        return utils_1.runWithRetries(() => {
+            return new Promise((resolve, reject) => run(resolve, reject));
         }, 3, 1000);
     }
     waitForClosed() {

package/lib/utils.js

@@ -17,16 +17,18 @@ function runWithRetries(fn, maxRetries, timeBetween) {
         let retries = 0;
         let tLastFailure = undefined;
         let busy = false;
-        const iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        let iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             const tNow = Date.now();
-            if (busy)
+            if (busy) {
                 return;
+            }
             if (tLastFailure === undefined || tNow - tLastFailure > timeBetween) {
                 try {
                     busy = true;
                     const data = yield fn();
-                    busy = false;
                     clearInterval(iv);
+                    iv = undefined;
+                    busy = false;
                     return resolve(data);
                 }
                 catch (err) {
@@ -34,6 +36,7 @@ function runWithRetries(fn, maxRetries, timeBetween) {
                     retries++;
                     if (retries >= maxRetries) {
                         clearInterval(iv);
+                        iv = undefined;
                         busy = false;
                         return reject(err);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.18",
+  "version": "1.4.21",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",