incyclist-devices 1.5.38 → 2.0.0

package/lib/{kettler → serial/kettler}/ergo-racer/adapter.js

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -31,27 +12,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const device_1 = __importStar(require("../../device"));
 const gd_eventlog_1 = require("gd-eventlog");
 const comms_1 = __importDefault(require("../comms"));
-const utils_1 = require("../../utils");
-const power_meter_1 = __importDefault(require("../../modes/power-meter"));
-const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
-class KettlerRacerAdapter extends device_1.default {
-    constructor(protocol, settings) {
-        super(protocol, settings);
+const utils_1 = require("../../../utils/utils");
+const power_meter_1 = __importDefault(require("../../../modes/power-meter"));
+const erg_1 = __importDefault(require("./modes/erg"));
+const adapter_1 = require("../../adapter");
+const capabilities_1 = require("../../../types/capabilities");
+const PROTOCOL_NAME = 'Kettler Racer';
+class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
+    constructor(settings, props) {
+        super(settings, props);
         this.requests = [];
         this.logger = new gd_eventlog_1.EventLogger('KettlerRacer');
-        this.ignoreHrm = false;
-        this.ignorePower = false;
-        this.ignoreBike = false;
         this.paused = false;
         this.iv = null;
-        this.comms = new comms_1.default({ protocol, port: this.settings.port, logger: this.logger });
+        this.comms = new comms_1.default({ interface: settings.interface, port: settings.port, logger: this.logger });
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Gear, capabilities_1.IncyclistCapability.HeartRate,
+            capabilities_1.IncyclistCapability.Control
+        ];
     }
     isBike() { return true; }
     isPower() { return true; }
     isHrm() { return true; }
+    getProtocolName() {
+        return PROTOCOL_NAME;
+    }
     isSame(device) {
         if (!(device instanceof KettlerRacerAdapter))
             return false;
@@ -68,16 +55,8 @@ class KettlerRacerAdapter extends device_1.default {
         return this.settings.name || this.getProtocolName();
     }
     getPort() {
-        return this.settings.port;
-    }
-    setIgnoreHrm(ignore) {
-        this.ignoreHrm = ignore;
-    }
-    setIgnorePower(ignore) {
-        this.ignorePower = ignore;
-    }
-    setIgnoreBike(ignore) {
-        this.ignoreBike = ignore;
+        const settings = this.settings;
+        return settings.port;
     }
     _getComms() {
         return this.comms;
@@ -88,23 +67,9 @@ class KettlerRacerAdapter extends device_1.default {
     getLogger() {
         return this.logger;
     }
-    getUserSettings() {
-        return this.settings.userSettings || { weight: device_1.DEFAULT_USER_WEIGHT };
-    }
-    getWeight() {
-        let userWeight = device_1.DEFAULT_USER_WEIGHT;
-        let bikeWeight = device_1.DEFAULT_BIKE_WEIGHT;
-        if (this.settings.userSettings && this.settings.userSettings.weight) {
-            userWeight = this.settings.userSettings.weight;
-        }
-        if (this.settings.bikeSettings && this.settings.bikeSettings.weight) {
-            userWeight = this.settings.bikeSettings.weight;
-        }
-        return bikeWeight + userWeight;
-    }
     setComputerMode() {
         return this.send('setComputerMode', 'CP').then(response => {
-            this.logger.logEvent({ response });
+            this.logEvent({ response });
             if (response === 'ACK' || response === 'RUN') {
                 return true;
             }
@@ -115,7 +80,7 @@ class KettlerRacerAdapter extends device_1.default {
     }
     setClientMode() {
         return this.send('setClientMode', 'CM').then(response => {
-            this.logger.logEvent({ response });
+            this.logEvent({ response });
             if (response === 'ACK' || response === 'RUN') {
                 return true;
             }
@@ -126,7 +91,7 @@ class KettlerRacerAdapter extends device_1.default {
     }
     reset() {
         return this.send('reset', 'RS').then(response => {
-            this.logger.logEvent({ response });
+            this.logEvent({ response });
             if (response === 'ACK' || response === 'RUN') {
                 return true;
             }
@@ -137,21 +102,21 @@ class KettlerRacerAdapter extends device_1.default {
     }
     getIdentifier() {
         return this.send('getIdentifier', 'ID').then(response => {
-            this.logger.logEvent({ response });
+            this.logEvent({ response });
             return response.substring(0, 3);
         });
     }
-    getInterface() {
+    getKettlerInterface() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.send('getInterface', 'KI');
-            this.logger.logEvent({ interface: res });
+            this.logEvent({ interface: res });
             return res;
         });
     }
     getVersion() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.send('getVersion', 'VE');
-            this.logger.logEvent({ version: res });
+            this.logEvent({ version: res });
             return res;
         });
     }
@@ -267,14 +232,14 @@ class KettlerRacerAdapter extends device_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             var info = {};
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.logger.logEvent({ message: "check()", port: this.getPort() });
+                this.logEvent({ message: "checking device", port: this.getPort() });
                 let iv = undefined;
                 try {
                     if (!info.opened)
                         info.opened = yield this.waitForOpened();
                     iv = setTimeout(() => {
-                        this.logger.logEvent({ message: "check() timeout", port: this.getPort() });
-                        reject(new Error(`timeout`));
+                        this.logEvent({ message: "checking device failed", port: this.getPort(), reason: 'timeout' });
+                        resolve(false);
                     }, 5000);
                     if (!info.pcMode)
                         info.pcMode = yield this.setClientMode();
@@ -283,27 +248,28 @@ class KettlerRacerAdapter extends device_1.default {
                     if (!info.version)
                         info.version = yield this.getVersion();
                     try {
-                        yield this.getInterface();
+                        yield this.getKettlerInterface();
                     }
                     catch (e) {
-                        this.logger.logEvent({ message: 'Error', error: e.message });
+                        this.logEvent({ message: 'could not get kettler interface', error: e.message });
                     }
                     clearTimeout(iv);
-                    resolve(info);
+                    this.logEvent({ message: "checking device success", port: this.getPort(), info });
+                    resolve(true);
                 }
                 catch (err) {
-                    this.logger.logEvent({ message: 'Error', error: err.message });
+                    this.logEvent({ message: "checking device failed", port: this.getPort(), reason: err.message || err });
                     if (iv)
                         clearTimeout(iv);
                     iv = undefined;
-                    reject(err);
+                    resolve(false);
                 }
             }));
         });
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start()' });
+            this.logEvent({ message: 'start()' });
             var info = {};
             yield this.waitForOpened(true);
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
@@ -317,13 +283,13 @@ class KettlerRacerAdapter extends device_1.default {
                         }
                     }
                     catch (e) {
-                        this.logger.logEvent({ message: 'Error', error: e.message });
+                        this.logEvent({ message: 'Error', error: e.message });
                     }
                     try {
                         yield this.setPower(100);
                     }
                     catch (e) {
-                        this.logger.logEvent({ message: 'Error', error: e.message });
+                        this.logEvent({ message: 'Error', error: e.message });
                     }
                     if (!info.data) {
                         yield this.update();
@@ -336,37 +302,38 @@ class KettlerRacerAdapter extends device_1.default {
                         yield this.reset();
                     }
                     catch (e) {
-                        this.logger.logEvent({ message: 'Error', error: e.message });
+                        this.logEvent({ message: 'Error', error: e.message });
                     }
                     throw (new Error(`could not start device, reason:${err.message}`));
                 }
             }), 5, 1000)
                 .then((data) => {
                 this.startUpdatePull();
-                return data;
+                return true;
             });
         });
     }
     startUpdatePull() {
         if (this.iv)
             return;
-        this.logger.logEvent({ message: 'start regular device update' });
-        if (this.ignoreBike && this.ignoreHrm && this.ignorePower)
-            return;
+        this.logEvent({ message: 'start regular device update' });
         const ivSync = setInterval(() => {
             this.bikeSync();
-        }, 1000);
+        }, this.pullFrequency);
         const ivUpdate = setInterval(() => {
-            this.sendData();
+            this.emitData(this.data);
             this.refreshRequests();
-        }, 1000);
+        }, this.pullFrequency);
         this.iv = {
             sync: ivSync,
             update: ivUpdate
         };
     }
+    canSendUpdate() {
+        return !this.isPaused();
+    }
     stop() {
-        this.logger.logEvent({ message: 'stop request' });
+        this.logEvent({ message: 'stop request' });
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             try {
                 if (this.iv) {
@@ -377,31 +344,17 @@ class KettlerRacerAdapter extends device_1.default {
                     this.iv = undefined;
                 }
                 yield this.waitForClosed();
-                this.logger.logEvent({ message: 'stop request completed' });
+                this.logEvent({ message: 'stop request completed' });
                 this.paused = undefined;
                 resolve(true);
             }
             catch (err) {
-                this.logger.logEvent({ message: 'stop error', error: err.message });
+                this.logEvent({ message: 'stop error', error: err.message });
                 this.paused = undefined;
                 reject(err);
             }
         }));
     }
-    pause() {
-        this.logger.logEvent({ message: 'pause' });
-        return new Promise(resolve => {
-            this.paused = true;
-            resolve(true);
-        });
-    }
-    resume() {
-        this.logger.logEvent({ message: 'resume' });
-        return new Promise(resolve => {
-            this.paused = false;
-            resolve(true);
-        });
-    }
     mapData(bikeData) {
         let data = {};
         data.isPedalling = bikeData.cadence > 0;
@@ -422,21 +375,13 @@ class KettlerRacerAdapter extends device_1.default {
         data.heartrate = internalData.heartrate;
         data.timestamp = Date.now();
         data.deviceTime = bikeData.time;
-        if (!this.ignoreBike) {
-            data.speed = internalData.speed;
-            data.power = internalData.power;
-            data.cadence = internalData.pedalRpm;
-            data.distance = distance;
-            data.deviceDistanceCounter = bikeData.distance;
-            data.internalDistanceCounter = internalData.distanceInternal;
-            this.prevDistance = internalData.distanceInternal;
-        }
-        if (this.ignoreHrm)
-            delete this.data.heartrate;
-        if (this.ignorePower) {
-            delete this.data.power;
-            delete this.data.cadence;
-        }
+        data.speed = internalData.speed;
+        data.power = internalData.power;
+        data.cadence = internalData.pedalRpm;
+        data.distance = distance;
+        data.deviceDistanceCounter = bikeData.distance;
+        data.internalDistanceCounter = internalData.distanceInternal;
+        this.prevDistance = internalData.distanceInternal;
         return data;
     }
     update() {
@@ -451,15 +396,16 @@ class KettlerRacerAdapter extends device_1.default {
                         data = this.getCyclingMode().updateData(data);
                         this.internalData = data;
                         this.data = this.transformData(data, bikeData);
+                        this.emitData(this.data);
                     }
                     catch (err) {
-                        this.logger.logEvent({ message: 'bike update error', error: err.message });
+                        this.logEvent({ message: 'bike update error', error: err.message });
                     }
                 }
                 this.updateBusy = false;
             })
                 .catch(err => {
-                this.logger.logEvent({ message: 'bike update error', error: err.message });
+                this.logEvent({ message: 'bike update error', error: err.message });
                 this.updateBusy = false;
             });
         });
@@ -468,7 +414,7 @@ class KettlerRacerAdapter extends device_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.requestBusy = true;
             try {
-                this.logger.logEvent({ message: 'sendRequest', request });
+                this.logEvent({ message: 'sendRequest', request });
                 const isReset = (!request || request.reset || Object.keys(request).length === 0);
                 if (isReset) {
                     this.requestBusy = false;
@@ -485,7 +431,7 @@ class KettlerRacerAdapter extends device_1.default {
             }
             catch (err) {
                 this.requestBusy = false;
-                this.logger.logEvent({ message: 'error', fn: 'sendRequest()', error: err.message || err });
+                this.logEvent({ message: 'error', fn: 'sendRequest()', error: err.message || err });
                 return;
             }
         });
@@ -497,7 +443,7 @@ class KettlerRacerAdapter extends device_1.default {
                 const cnt = processing.length;
                 processing.forEach((request, idx) => __awaiter(this, void 0, void 0, function* () {
                     if (cnt > 1 && idx < cnt - 1) {
-                        this.logger.logEvent({ message: 'ignoring bike update request', request });
+                        this.logEvent({ message: 'ignoring bike update request', request });
                         this.requests.shift();
                         return;
                     }
@@ -508,7 +454,7 @@ class KettlerRacerAdapter extends device_1.default {
                     this.requests.shift();
                 }
                 catch (err) {
-                    this.logger.logEvent({ message: 'bike update error', error: err.message, stack: err.stack, request });
+                    this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack, request });
                 }
             }
         });
@@ -521,10 +467,8 @@ class KettlerRacerAdapter extends device_1.default {
             if (this.updateBusy || this.requestBusy) {
                 return;
             }
-            this.logger.logEvent({ message: 'bikeSync' });
-            if (!this.ignoreBike) {
-                yield this.sendRequests();
-            }
+            this.logEvent({ message: 'bikeSync' });
+            yield this.sendRequests();
             yield this.update();
         });
     }
@@ -532,21 +476,17 @@ class KettlerRacerAdapter extends device_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.paused)
                 return;
-            this.logger.logEvent({ message: 'sendUpdate', request, waiting: this.requests.length });
+            this.logEvent({ message: 'sendUpdate', request, waiting: this.requests.length });
             return yield this.processClientRequest(request);
         });
     }
-    sendData() {
-        if (this.onDataFn)
-            this.onDataFn(this.data);
-    }
     refreshRequests() {
         if (this.kettlerData.cadence === 0)
             return;
         let bikeRequest = this.getCyclingMode().sendBikeUpdate({ refresh: true }) || {};
         const prev = this.requests[this.requests.length - 1] || {};
         if (bikeRequest.targetPower !== undefined && bikeRequest.targetPower !== prev.targetPower) {
-            this.logger.logEvent({ message: 'add request', request: bikeRequest });
+            this.logEvent({ message: 'add request', request: bikeRequest });
             this.requests.push(bikeRequest);
         }
     }
@@ -556,44 +496,43 @@ class KettlerRacerAdapter extends device_1.default {
         }
         return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
             let bikeRequest = this.getCyclingMode().sendBikeUpdate(request);
-            this.logger.logEvent({ message: 'add request', request: bikeRequest });
+            this.logEvent({ message: 'add request', request: bikeRequest });
             this.requests.push(bikeRequest);
             resolve(bikeRequest);
         }));
     }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.waitForOpened(true);
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.waitForClosed();
+        });
+    }
     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();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!retries) {
+                return yield this.comms.open();
             }
-            catch (err) {
-                this.logger.logEvent({ message: 'error', fn: 'waitForOpened()', error: err.message || err });
-                reject(err);
+            else {
+                let opened;
+                let tries = 0;
+                while (!opened && tries < 3) {
+                    try {
+                        opened = yield this.comms.open();
+                        if (opened)
+                            return true;
+                    }
+                    catch (err) {
+                    }
+                    tries++;
+                    yield (0, utils_1.sleep)(500);
+                }
+                return false;
             }
-        };
-        if (!retries) {
-            return new Promise((resolve, reject) => run(resolve, reject));
-        }
-        return (0, utils_1.runWithRetries)(() => {
-            return new Promise((resolve, reject) => run(resolve, reject));
-        }, 3, 1000);
+        });
     }
     waitForClosed() {
         return new Promise((resolve, reject) => {
@@ -614,26 +553,20 @@ class KettlerRacerAdapter extends device_1.default {
                 this.comms.on('closed', onClose);
                 this.comms.on('opened', onOpen);
                 this.comms.on('error', onError);
-                this.logger.logEvent({ message: 'closing', port: this.getPort() });
+                this.logEvent({ message: 'closing', port: this.getPort() });
                 this.comms.close();
             }
             catch (err) {
-                this.logger.logEvent({ message: 'error', fn: 'waitForClosed()', error: err.message || err });
+                this.logEvent({ message: 'error', fn: 'waitForClosed()', error: err.message || err });
                 reject(err);
             }
         });
     }
     getSupportedCyclingModes() {
-        return [power_meter_1.default, ERGCyclingMode_1.default];
+        return [power_meter_1.default, erg_1.default];
     }
     getDefaultCyclingMode() {
-        return new ERGCyclingMode_1.default(this);
-    }
-    setUserSettings(userSettings) {
-        this.settings.userSettings = userSettings;
-    }
-    setBikeSettings(bikeSettings) {
-        this.settings.bikeSettings = bikeSettings;
+        return new erg_1.default(this);
     }
 }
 exports.default = KettlerRacerAdapter;

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

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+import { MockBindingInterface, MockPortBinding, CreatePortOptions } from '@serialport/binding-mock';
+import { BindingInterface, PortInfo } from '@serialport/bindings-interface';
+import { User } from '../../../types/user';
+export type MockProps = {
+    interface: string;
+    path: string;
+};
+export interface KettlerRacerMockBindingInterface extends BindingInterface<KettlerRacerMockBinding> {
+    reset(): void;
+    createPort(path: string, opt?: CreatePortOptions): void;
+}
+export declare const KettlerRacerMock: MockBindingInterface;
+export declare class KettlerRacerMockImpl {
+    static _instance: KettlerRacerMockImpl;
+    static getInstance(): KettlerRacerMockImpl;
+    static reset(): void;
+    simulators: Map<string, KettlerRacerSimulator>;
+    ports: {
+        path: string;
+        binding: KettlerRacerMockBinding;
+    }[];
+    constructor();
+    setSimulator(path: string, simulator: KettlerRacerSimulator): void;
+    getSimulator(path: any): KettlerRacerSimulator;
+    reset(): void;
+    createPort(path: string, options?: CreatePortOptions): void;
+    list(): Promise<PortInfo[]>;
+    open(options: any): Promise<KettlerRacerMockBinding>;
+}
+export declare class KettlerRacerSimulator {
+    identifier: string;
+    version: string;
+    bikeType: string;
+    ifVersion: string;
+    power: number;
+    requestedPower: number;
+    person: User;
+    cadence: number;
+    distance: number;
+    speed: number;
+    heartrate: number;
+    time: number;
+    energy: number;
+}
+export declare class KettlerRacerMockBinding extends MockPortBinding {
+    waitingForCommand: boolean;
+    waitingForAck: boolean;
+    prevCommand: Buffer;
+    simulator: KettlerRacerSimulator;
+    handlers: Map<string, (payload: string) => void>;
+    constructor(parent: MockPortBinding);
+    getPath(): string;
+    initHandlers(): void;
+    write(buffer: Buffer): Promise<void>;
+    processData(buffer: Buffer): Promise<void>;
+    onSetComputerMode(_payload: string): void;
+    onSetClientMode(_payload: string): void;
+    onReset(_payload: string): void;
+    onGetIdentifier(_payload: string): void;
+    onGetVersion(_payload: string): void;
+    onGetKettlerInfo(_payload: string): void;
+    onSetPower(payload: string): void;
+    onGetStatus(): void;
+    sendResponse(msg: string): void;
+}