incyclist-devices 2.0.38 → 2.1.1

package/lib/serial/daum/DaumAdapter.js

@@ -12,26 +12,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractDaumAdapter = void 0;
-const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
-const SmartTrainerCyclingMode_1 = __importDefault(require("./SmartTrainerCyclingMode"));
-const DaumPowerMeterCyclingMode_1 = __importDefault(require("./DaumPowerMeterCyclingMode"));
+const daum_erg_1 = __importDefault(require("../../modes/daum-erg"));
 const utils_1 = require("../../utils/utils");
-const adapter_1 = require("../adapter");
-const capabilities_1 = require("../../types/capabilities");
-class AbstractDaumAdapter extends adapter_1.SerialIncyclistDevice {
-}
-exports.AbstractDaumAdapter = AbstractDaumAdapter;
-class DaumAdapter extends AbstractDaumAdapter {
+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"));
+class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     constructor(settings, props) {
         super(settings, props);
         this.requests = [];
         this.adapterTime = 0;
         this.requestBusy = false;
         this.updateBusy = false;
-        this.stopped = false;
-        this.paused = false;
-        this.cyclingData = {
+        this.iv = undefined;
+        this.deviceData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -40,37 +35,25 @@ class DaumAdapter extends AbstractDaumAdapter {
             distanceInternal: 0,
             heartrate: 0
         };
-        this.deviceData = {};
         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
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Gear, types_1.IncyclistCapability.HeartRate,
+            types_1.IncyclistCapability.Control
         ];
     }
-    setCyclingMode(mode, settings) {
-        let selectedMode = this.cyclingMode;
-        if (typeof mode === 'string') {
-            if (!this.cyclingMode || this.cyclingMode.getName() !== mode) {
-                const supported = this.getSupportedCyclingModes();
-                const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
-                if (CyclingModeClass) {
-                    this.cyclingMode = new CyclingModeClass(this, settings);
-                    return;
-                }
-                selectedMode = this.getDefaultCyclingMode();
-            }
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
+    getPort() {
+        var _a;
+        return (_a = this.comms) === null || _a === void 0 ? void 0 : _a.getPort();
+    }
+    getSerialInterface() {
+        var _a;
+        return (_a = this.comms) === null || _a === void 0 ? void 0 : _a.serial;
     }
     sendInitCommands() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started && !this.stopped) {
                 try {
-                    if (this.getCyclingMode() instanceof ERGCyclingMode_1.default) {
-                        const power = this.deviceData.power;
+                    if (this.getCyclingMode() instanceof daum_erg_1.default) {
+                        const power = this.data.power;
                         const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
                         yield this.sendUpdate(request);
                         return true;
@@ -80,27 +63,14 @@ class DaumAdapter extends AbstractDaumAdapter {
                     return false;
                 }
             }
-            else {
-                return false;
-            }
+            return false;
         });
     }
-    getSupportedCyclingModes() {
-        return [ERGCyclingMode_1.default, SmartTrainerCyclingMode_1.default, DaumPowerMeterCyclingMode_1.default];
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
-    }
-    getDefaultCyclingMode() {
-        return new ERGCyclingMode_1.default(this);
-    }
     getCurrentBikeData() {
         throw new Error('Method not implemented.');
     }
-    getBike() {
-        return this.bike;
+    getComms() {
+        return this.comms;
     }
     isEqual(settings) {
         const as = this.settings;
@@ -123,7 +93,7 @@ class DaumAdapter extends AbstractDaumAdapter {
         this.distanceInternal = undefined;
         this.paused = false;
         this.stopped = false;
-        this.cyclingData = {
+        this.deviceData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -132,8 +102,7 @@ class DaumAdapter extends AbstractDaumAdapter {
             distanceInternal: 0,
             heartrate: 0
         };
-        this.deviceData = {};
-        this.currentRequest = {};
+        this.data = {};
         this.requests = [];
         const name = this.getCyclingMode().getName();
         const settings = this.getCyclingMode().getSettings();
@@ -145,7 +114,7 @@ class DaumAdapter extends AbstractDaumAdapter {
         });
         return __awaiter(this, void 0, void 0, function* () {
             const paused = yield _super.pause.call(this);
-            this.bike.pauseLogging();
+            this.comms.pauseLogging();
             return paused;
         });
     }
@@ -155,75 +124,170 @@ class DaumAdapter extends AbstractDaumAdapter {
         });
         return __awaiter(this, void 0, void 0, function* () {
             const resumed = yield _super.resume.call(this);
-            this.bike.resumeLogging();
+            this.comms.resumeLogging();
             return resumed;
         });
     }
+    waitForPrevCheckFinished() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.checkPromise) {
+                this.logEvent({ message: "waiting for previous check device", port: this.getPort() });
+                try {
+                    yield this.checkPromise;
+                }
+                catch (_a) { }
+                this.logEvent({ message: "previous check device completed", port: this.getPort() });
+                this.checkPromise = undefined;
+            }
+        });
+    }
+    check() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForPrevCheckFinished();
+            yield this.waitForPrevStartFinished();
+            if (this.isStopped())
+                return false;
+            this.checkPromise = this.performCheck();
+            try {
+                const res = yield this.checkPromise;
+                this.checkPromise = undefined;
+                return res;
+            }
+            catch (err) {
+                this.checkPromise = undefined;
+                throw err;
+            }
+        });
+    }
+    performCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    waitForPrevStartFinished() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.startPromise) {
+                this.logEvent({ message: "waiting for previous device launch", port: this.getPort() });
+                try {
+                    yield this.startPromise;
+                }
+                catch (_a) { }
+                this.logEvent({ message: "previous device launch attempt completed", port: this.getPort() });
+                this.startPromise = undefined;
+            }
+        });
+    }
     start(props) {
-        throw new Error('Method not implemented.');
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForPrevCheckFinished();
+            yield this.waitForPrevStartFinished();
+            const isRelaunch = this.started;
+            const message = isRelaunch ? 'relaunch of device' : 'initial start of device';
+            this.logEvent({ message });
+            try {
+                if (isRelaunch && this.isPaused())
+                    this.resume();
+                this.startPromise = this.performStart(props, isRelaunch).then((started) => __awaiter(this, void 0, void 0, function* () {
+                    if (!started) {
+                        this.logEvent({ message: 'start result: not started' });
+                        this.started = false;
+                        return false;
+                    }
+                    if (!isRelaunch) {
+                        try {
+                            const deviceInfo = yield this.getDeviceInfo();
+                            this.logEvent({ message: 'device info', deviceInfo });
+                        }
+                        catch (_a) { }
+                    }
+                    this.logEvent({ message: 'start result: success' });
+                    this.started = true;
+                    return true;
+                }));
+                const started = yield this.startPromise;
+                this.startPromise = undefined;
+                return started;
+            }
+            catch (err) {
+                this.logEvent({ message: 'start result: error', error: err.message });
+                this.startPromise = undefined;
+                this.started = false;
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
+        });
     }
-    stopUpdatePull() {
-        if (!this.iv)
-            return;
-        if (this.iv.sync)
-            clearInterval(this.iv.sync);
-        if (this.iv.update)
-            clearInterval(this.iv.update);
-        this.iv = undefined;
+    performStart(props, isRelaunch = false) {
+        throw new Error('Method not implemented.');
     }
     startUpdatePull() {
-        this.logEvent({ message: 'start update pull', iv: this.iv, ignoreBike: this.ignoreBike, ignoreHrm: this.ignoreHrm, ignorePower: this.ignorePower });
         if (this.iv)
             return;
-        if (this.ignoreBike && this.ignoreHrm && this.ignorePower)
-            return;
+        this.logEvent({ message: 'start update pull', port: this.getPort() });
         const ivSync = setInterval(() => {
-            this.bikeSync();
+            try {
+                this.bikeSync();
+            }
+            catch (_a) { }
         }, this.pullFrequency);
         const ivUpdate = setInterval(() => {
-            this.emitData(this.deviceData);
-            this.refreshRequests();
+            try {
+                this.emitData(this.data);
+                this.refreshRequests();
+            }
+            catch (_a) { }
         }, this.pullFrequency);
         this.iv = {
             sync: ivSync,
             update: ivUpdate
         };
     }
+    stopUpdatePull() {
+        if (!this.iv)
+            return;
+        this.logEvent({ message: 'stop update pull', port: this.getPort() });
+        clearInterval(this.iv.sync);
+        clearInterval(this.iv.update);
+        this.iv = undefined;
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.bike.isConnected())
+            if (!this.comms)
+                return false;
+            if (this.comms.isConnected())
                 return true;
             try {
-                const connected = yield this.bike.connect();
+                const connected = yield this.comms.connect();
                 return connected;
             }
             catch (err) {
-                yield this.bike.close();
+                yield this.comms.close();
                 return false;
             }
         });
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.bike.isConnected())
+            if (!this.comms)
+                return true;
+            if (!this.comms.isConnected())
                 return true;
-            return yield this.bike.close();
+            return yield this.comms.close();
         });
     }
-    logEvent(event) {
-        if (!this.logger)
-            return;
-        this.logger.logEvent(event);
-        const w = global.window;
-        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
-            console.log(`~~~ ${this.logger.getName()}`, event);
-        }
+    verifyConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.comms.isConnected()) {
+                const connected = yield this.comms.connect();
+                if (!connected)
+                    throw new Error('not connected');
+            }
+        });
     }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.bike.close();
-                const connected = yield this.bike.connect();
+                yield this.comms.close();
+                const connected = yield this.comms.connect();
                 return connected;
             }
             catch (err) {
@@ -231,38 +295,34 @@ class DaumAdapter extends AbstractDaumAdapter {
             }
         });
     }
+    logEvent(event) {
+        if (!this.logger || this.paused)
+            return;
+        this.logger.logEvent(event);
+        const w = global.window;
+        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
+            console.log(`~~~ ${this.logger.getName()}`, event);
+        }
+    }
     stop() {
-        if (this.stopped)
-            return Promise.resolve(true);
-        this.logEvent({ message: 'stop request' });
-        if (this.paused)
-            this.resume();
-        this.stopped = true;
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                return true;
+            this.logEvent({ message: 'stop request' });
+            if (this.paused)
+                this.resume();
             try {
-                if (this.iv) {
-                    if (this.iv.sync)
-                        clearInterval(this.iv.sync);
-                    if (this.iv.update)
-                        clearInterval(this.iv.update);
-                    this.iv = undefined;
-                }
-                if (this.bike.stopWorker && typeof this.bike.stopWorker === 'function')
-                    this.bike.stopWorker();
-                yield this.bike.close();
+                this.stopUpdatePull();
+                yield this.comms.close();
                 this.logEvent({ message: 'stop request completed' });
-                resolve(true);
+                this.stopped = true;
             }
             catch (err) {
-                this.logEvent({ message: 'stop error', error: err.message });
-                reject(err);
+                this.logEvent({ message: 'stop request failed', reason: err.message });
+                throw (err);
             }
-        }));
-    }
-    canSendUpdate() {
-        if (this.paused || this.stopped)
-            return false;
-        return super.canSendUpdate();
+            return this.stopped;
+        });
     }
     sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -274,39 +334,44 @@ class DaumAdapter extends AbstractDaumAdapter {
     }
     update() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.stopped)
+            if (!this.canEmitData() || this.updateBusy)
                 return;
             this.updateBusy = true;
-            this.getCurrentBikeData()
-                .then(bikeData => {
+            try {
+                const bikeData = yield this.getCurrentBikeData();
                 const incyclistData = this.updateData(bikeData);
                 const data = this.transformData(incyclistData);
                 this.updateBusy = false;
                 this.emitData(data);
-            })
-                .catch(err => {
-                this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
-                const incyclistData = this.updateData(this.cyclingData);
-                this.transformData(incyclistData);
+            }
+            catch (err) {
+                try {
+                    this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
+                    const incyclistData = this.updateData(this.deviceData);
+                    this.transformData(incyclistData);
+                }
+                catch (_a) { }
                 this.updateBusy = false;
-            });
+            }
         });
     }
     sendRequests() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.stopped || this.paused)
                 return;
+            if (this.requestBusy)
+                return;
             if (this.requests.length > 0) {
-                const processing = [...this.requests];
-                const cnt = processing.length;
-                processing.forEach((request, idx) => __awaiter(this, void 0, void 0, function* () {
-                    if (cnt > 1 && idx < cnt - 1) {
-                        this.logEvent({ message: 'ignoring bike update request', request });
-                        this.requests.shift();
-                        return;
-                    }
-                }));
-                const request = processing[0];
+                const cnt = this.requests.length;
+                if (cnt > 1) {
+                    this.requests.forEach((request, idx) => {
+                        if (idx !== cnt - 1) {
+                            this.logEvent({ message: 'ignoring bike update request', request });
+                        }
+                    });
+                    this.requests = [this.requests[cnt - 1]];
+                }
+                let request = this.requests[0];
                 try {
                     yield this.sendRequest(request);
                     this.requests.shift();
@@ -319,16 +384,7 @@ class DaumAdapter extends AbstractDaumAdapter {
     }
     bikeSync() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused || this.stopped) {
-                return;
-            }
-            if (this.updateBusy || this.requestBusy) {
-                return;
-            }
-            this.logEvent({ message: 'bikeSync', ignoreBike: this.ignoreBike });
-            if (!this.ignoreBike) {
-                yield this.sendRequests();
-            }
+            yield this.sendRequests();
             yield this.update();
         });
     }
@@ -346,8 +402,8 @@ class DaumAdapter extends AbstractDaumAdapter {
             data.time = bikeData.time;
         if (bikeData.slope)
             data.slope = bikeData.slope;
-        this.cyclingData = this.getCyclingMode().updateData(data);
-        return this.cyclingData;
+        this.deviceData = this.getCyclingMode().updateData(data);
+        return this.deviceData;
     }
     transformData(cyclingData) {
         let distance = 0;
@@ -367,16 +423,7 @@ class DaumAdapter extends AbstractDaumAdapter {
             deviceTime: cyclingData.time,
             deviceDistanceCounter: cyclingData.distanceInternal
         };
-        if (this.ignoreHrm)
-            delete data.heartrate;
-        if (this.ignorePower) {
-            delete data.power;
-            delete data.cadence;
-        }
-        if (this.ignoreBike) {
-            data = { heartrate: data.heartrate };
-        }
-        this.deviceData = data;
+        this.data = data;
         return data;
     }
     sendRequest(request) {
@@ -384,17 +431,17 @@ class DaumAdapter extends AbstractDaumAdapter {
             this.requestBusy = true;
             try {
                 this.logEvent({ message: 'sendRequest', request });
-                const bike = this.getBike();
+                const bike = this.getComms();
                 const isReset = (!request || request.reset || Object.keys(request).length === 0);
                 if (isReset) {
                     this.requestBusy = false;
                     return {};
                 }
                 if (request.slope !== undefined) {
-                    yield bike.setSlope(request.slope);
+                    yield bike.setTargetSlope(request.slope);
                 }
                 if (request.targetPower !== undefined) {
-                    yield bike.setPower(request.targetPower);
+                    yield bike.setTargetPower(request.targetPower);
                 }
                 this.requestBusy = false;
                 return request;
@@ -409,7 +456,7 @@ class DaumAdapter extends AbstractDaumAdapter {
     refreshRequests() {
         if (this.isPaused() || this.isStopped())
             return;
-        if (!this.cyclingData.isPedalling || this.cyclingData.pedalRpm === 0)
+        if (!this.deviceData.isPedalling || this.deviceData.pedalRpm === 0)
             return;
         let bikeRequest = this.getCyclingMode().sendBikeUpdate({ refresh: true }) || {};
         const prev = this.requests[this.requests.length - 1] || {};
@@ -420,7 +467,7 @@ class DaumAdapter extends AbstractDaumAdapter {
     }
     processClientRequest(request) {
         if (request.slope !== undefined) {
-            this.cyclingData.slope = request.slope;
+            this.deviceData.slope = request.slope;
         }
         return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
             let bikeRequest = this.getCyclingMode().sendBikeUpdate(request);
@@ -429,8 +476,14 @@ class DaumAdapter extends AbstractDaumAdapter {
             resolve(bikeRequest);
         }));
     }
-    check() {
-        throw new Error('Method not implemented.');
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
     }
 }
+DaumAdapter.controllers = {
+    modes: [daum_erg_1.default, daum_smarttrainer_1.default, daum_power_1.default],
+    default: daum_erg_1.default
+};
 exports.default = DaumAdapter;

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

@@ -0,0 +1,2 @@
+export declare const PROTOCOL_NAME = "Daum Classic";
+export declare const DEFAULT_GEAR = 10;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GEAR = exports.PROTOCOL_NAME = void 0;
+exports.PROTOCOL_NAME = "Daum Classic";
+exports.DEFAULT_GEAR = 10;

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

@@ -1,33 +1,20 @@
-import CyclingMode, { IncyclistBikeData } from '../../../modes/cycling-mode';
 import DaumAdapter from '../DaumAdapter';
-import { DeviceProperties } from '../../../types/device';
-import { SerialDeviceSettings } from '../../adapter';
-import SerialInterface from '../../serial-interface';
-export interface DaumClassicDeviceProperties extends DeviceProperties {
-    gear?: number;
-}
-export default class DaumClassicAdapter extends DaumAdapter<SerialDeviceSettings, DaumClassicDeviceProperties> {
+import { DaumClassicProperties } from './types';
+import { SerialDeviceSettings, SerialCommProps } from "../../types";
+import { IncyclistBikeData, ControllerConfig } from "../../../types";
+import Daum8008 from './comms';
+export default class DaumClassicAdapter extends DaumAdapter<SerialDeviceSettings, DaumClassicProperties, Daum8008> {
     static NAME: string;
-    name: string;
-    id: string;
-    started: boolean;
-    startPromise: Promise<unknown>;
-    checkPromise: Promise<boolean>;
-    constructor(settings: SerialDeviceSettings, props?: DaumClassicDeviceProperties);
-    setID(id: any): void;
-    getID(): string;
+    protected static controllers: ControllerConfig;
+    protected name: string;
+    protected id: string;
+    constructor(settings: SerialDeviceSettings, props?: DaumClassicProperties);
+    getBikeProps(props: SerialDeviceSettings): SerialCommProps;
     getName(): string;
-    setName(name: any): void;
-    getPort(): any;
+    setName(name: string): void;
     getProtocolName(): string;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
-    getSerialInterface(): SerialInterface;
-    check(): Promise<boolean>;
     performCheck(): Promise<boolean>;
-    startRide(props?: DaumClassicDeviceProperties): Promise<boolean>;
-    start(props?: DaumClassicDeviceProperties): Promise<boolean>;
-    launch(props: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<boolean>;
-    performStart(props?: DaumClassicDeviceProperties, isRelaunch?: boolean): Promise<unknown>;
+    performStart(props?: DaumClassicProperties, isRelaunch?: boolean): Promise<boolean>;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
+    getDeviceInfo(): Promise<any>;
 }