incyclist-devices 1.3.0 → 1.4.1

package/lib/daum/DaumAdapter.js

@@ -8,22 +8,83 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const Device_1 = require("../Device");
-function floatVal(d) {
-    if (d === undefined)
-        return d;
-    return parseFloat(d);
-}
-function intVal(d) {
-    if (d === undefined)
-        return d;
-    return parseInt(d);
-}
+const Device_1 = __importDefault(require("../Device"));
+const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
+const SmartTrainerCyclingMode_1 = __importDefault(require("./SmartTrainerCyclingMode"));
+const PowerMeterCyclingMode_1 = __importDefault(require("./PowerMeterCyclingMode"));
+const utils_1 = require("../utils");
+const DEFAULT_BIKE_WEIGHT = 10;
+const DEFAULT_USER_WEIGHT = 75;
 class DaumAdapterBase extends Device_1.default {
     constructor(props, bike) {
         super(props);
+        this.requests = [];
+        this.adapterTime = 0;
+        this.requestBusy = false;
+        this.updateBusy = false;
         this.bike = bike;
+        this.stopped = false;
+        this.paused = false;
+        this.data = {};
+        const options = props || {};
+        this.cyclingMode = options.cyclingMode;
+        this.setUserSettings(options.userSettings);
+        this.setBikeSettings(options.bikeSettings);
+    }
+    setCyclingMode(mode, settings) {
+        let selectedMode;
+        if (typeof mode === 'string') {
+            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);
+    }
+    getSupportedCyclingModes() {
+        return [ERGCyclingMode_1.default, SmartTrainerCyclingMode_1.default, PowerMeterCyclingMode_1.default];
+    }
+    getCyclingMode() {
+        if (!this.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.cyclingMode;
+    }
+    getDefaultCyclingMode() {
+        return new ERGCyclingMode_1.default(this);
+    }
+    setUserSettings(userSettings) {
+        this.userSettings = userSettings || {};
+        if (this.bike) {
+            if (!this.bike.settings)
+                this.bike.settings = { user: {} };
+            if (!this.bike.settings.user)
+                this.bike.settings.user = {};
+            this.bike.settings.user.weight = this.userSettings.weight || DEFAULT_USER_WEIGHT;
+        }
+    }
+    setBikeSettings(bikeSettings) {
+        this.bikeSettings = bikeSettings || {};
+        if (this.bike) {
+            if (!this.bike.settings)
+                this.bike.settings = {};
+            this.bike.settings.weight = this.userSettings.weight || DEFAULT_BIKE_WEIGHT;
+        }
+    }
+    getWeight() {
+        const userWeight = this.userSettings.weight || DEFAULT_USER_WEIGHT;
+        const bikeWeight = this.bikeSettings.weight || DEFAULT_BIKE_WEIGHT;
+        return bikeWeight + userWeight;
     }
     getCurrentBikeData() {
         throw new Error('Method not implemented.');
@@ -46,12 +107,30 @@ class DaumAdapterBase extends Device_1.default {
     setIgnoreBike(ignore) {
         this.ignoreBike = ignore;
     }
+    isStopped() {
+        return this.stopped;
+    }
     initData() {
         this.distanceInternal = undefined;
-        this.paused = undefined;
-        this.data = {};
+        this.paused = false;
+        this.stopped = false;
+        this.data = {
+            time: 0,
+            slope: 0,
+            distance: 0,
+            speed: 0,
+            isPedalling: false,
+            power: 0,
+            distanceInternal: 0
+        };
         this.currentRequest = {};
         this.requests = [];
+        const name = this.getCyclingMode().getName();
+        const settings = this.getCyclingMode().getSettings();
+        this.setCyclingMode(name, settings);
+    }
+    start(props) {
+        throw new Error('Method not implemented.');
     }
     startUpdatePull() {
         if (this.iv)
@@ -59,7 +138,11 @@ class DaumAdapterBase extends Device_1.default {
         if (this.ignoreBike && this.ignoreHrm && this.ignorePower)
             return;
         this.iv = setInterval(() => {
-            this.update();
+            this.bikeSync();
+        }, 1000);
+        this.iv = setInterval(() => {
+            this.sendData();
+            this.refreshRequests();
         }, 1000);
     }
     connect() {
@@ -74,43 +157,9 @@ class DaumAdapterBase extends Device_1.default {
             return;
         this.logger.logEvent(event);
     }
-    sendBikeUpdate(request) {
-        return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-            if (request.slope) {
-                this.data.slope = request.slope;
-            }
-            try {
-                if (this.bike.processor !== undefined) {
-                    this.bike.processor.setValues(request);
-                }
-                this.logEvent({ message: "sendBikeUpdate():sending", request });
-                if (request.slope !== undefined) {
-                    yield this.bike.setSlope(request.slope);
-                }
-                if (request.targetPower !== undefined) {
-                    yield this.bike.setPower(request.targetPower);
-                }
-                if (request.minPower !== undefined && request.maxPower !== undefined && request.minPower === request.maxPower) {
-                    yield this.bike.setPower(request.minPower);
-                }
-                if (request.maxPower !== undefined) {
-                }
-                if (request.minPower !== undefined) {
-                }
-                if (request.maxHrm !== undefined) {
-                }
-                if (request.minHrm !== undefined) {
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'sendBikeUpdate error', error: err.message });
-                resolve(undefined);
-            }
-            resolve(request);
-        }));
-    }
     stop() {
         this.logEvent({ message: 'stop request' });
+        this.stopped = true;
         return new Promise((resolve, reject) => {
             try {
                 if (this.iv) {
@@ -128,63 +177,86 @@ class DaumAdapterBase extends Device_1.default {
         });
     }
     pause() {
+        this.logEvent({ message: 'pause' });
         return new Promise(resolve => {
             this.paused = true;
             resolve(true);
         });
     }
     resume() {
+        this.logEvent({ message: 'resume' });
         return new Promise(resolve => {
             this.paused = false;
             resolve(true);
         });
     }
-    sendUpdate(data) {
+    sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.paused)
                 return;
-            this.logEvent({ message: 'sendUpdate', data });
-            this.requests.push(data);
+            this.logEvent({ message: 'sendUpdate', request, waiting: this.requests.length });
+            return yield this.processClientRequest(request);
         });
     }
+    sendData() {
+        if (this.onDataFn)
+            this.onDataFn(this.data);
+    }
     update() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused)
-                return;
-            if (!this.ignoreBike) {
-                if (this.requests.length === 0) {
-                    this.sendUpdate({ refresh: true });
-                }
-                if (this.requests.length > 0) {
-                    const processing = [...this.requests];
-                    processing.forEach((request) => __awaiter(this, void 0, void 0, function* () {
-                        try {
-                            this.logEvent({ message: 'bike update request', request });
-                            yield this.sendBikeUpdate(request);
-                            this.requests.shift();
-                        }
-                        catch (err) {
-                            this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack, request });
-                        }
-                    }));
-                }
-            }
+            this.updateBusy = true;
             this.getCurrentBikeData()
                 .then(bikeData => {
-                let data = JSON.parse(JSON.stringify(this.data));
-                data = this.updateData(data, bikeData);
-                this.data = this.transformData(data);
-                if (this.onDataFn) {
-                    console.log('~~~updateBike:', this.ignoreHrm, this.data);
-                    this.onDataFn(this.data);
-                }
+                this.updateData(this.data, bikeData);
+                this.transformData();
+                this.updateBusy = false;
             })
                 .catch(err => {
                 this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
+                this.updateBusy = false;
             });
         });
     }
-    updateData(data, bikeData) {
+    sendRequests() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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];
+                try {
+                    yield this.sendRequest(request);
+                    this.requests.shift();
+                }
+                catch (err) {
+                    this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack, request });
+                }
+            }
+        });
+    }
+    bikeSync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.paused) {
+                return;
+            }
+            if (this.updateBusy || this.requestBusy) {
+                return;
+            }
+            this.logEvent({ message: 'bikeSync' });
+            if (!this.ignoreBike) {
+                yield this.sendRequests();
+            }
+            yield this.update();
+        });
+    }
+    updateData(prev, bikeData) {
+        let data = {};
         data.isPedalling = bikeData.cadence > 0;
         data.power = bikeData.power;
         data.pedalRpm = bikeData.cadence;
@@ -192,28 +264,31 @@ class DaumAdapterBase extends Device_1.default {
         data.heartrate = bikeData.heartrate;
         data.distance = bikeData.distance / 100;
         data.distanceInternal = bikeData.distance;
-        data.time = bikeData.time;
         data.gear = bikeData.gear;
-        if (this.bike.processor !== undefined) {
-            data = this.bike.processor.getValues(data);
+        if (this.tsPrevData && data.isPedalling) {
+            this.adapterTime = Date.now() - this.tsPrevData;
         }
-        return data;
+        this.tsPrevData = Date.now();
+        data.time = Math.round(this.adapterTime || 0);
+        if (bikeData.slope)
+            data.slope = bikeData.slope;
+        this.data = this.getCyclingMode().updateData(data);
     }
-    transformData(bikeData) {
-        if (bikeData === undefined)
+    transformData() {
+        if (this.data === undefined)
             return;
         let distance = 0;
-        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = intVal(bikeData.distanceInternal - this.distanceInternal);
+        if (this.distanceInternal !== undefined && this.data.distanceInternal !== undefined) {
+            distance = (0, utils_1.intVal)(this.data.distanceInternal - this.distanceInternal);
         }
-        if (bikeData.distanceInternal !== undefined)
-            this.distanceInternal = bikeData.distanceInternal;
+        if (this.data.distanceInternal !== undefined)
+            this.distanceInternal = this.data.distanceInternal;
         let data = {
-            speed: floatVal(bikeData.speed),
-            slope: floatVal(bikeData.slope),
-            power: intVal(bikeData.power),
-            cadence: intVal(bikeData.pedalRpm),
-            heartrate: intVal(bikeData.heartrate),
+            speed: (0, utils_1.floatVal)(this.data.speed),
+            slope: (0, utils_1.floatVal)(this.data.slope),
+            power: (0, utils_1.intVal)(this.data.power),
+            cadence: (0, utils_1.intVal)(this.data.pedalRpm),
+            heartrate: (0, utils_1.intVal)(this.data.heartrate),
             distance,
             timestamp: Date.now()
         };
@@ -226,7 +301,55 @@ class DaumAdapterBase extends Device_1.default {
         if (this.ignoreBike) {
             data = { heartrate: data.heartrate };
         }
-        return data;
+        this.data = data;
+    }
+    sendRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.requestBusy = true;
+            try {
+                this.logEvent({ message: 'sendRequest', request });
+                const bike = this.getBike();
+                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);
+                }
+                if (request.targetPower !== undefined) {
+                    yield bike.setPower(request.targetPower);
+                }
+                this.requestBusy = false;
+                return request;
+            }
+            catch (err) {
+                this.requestBusy = false;
+                this.logEvent({ message: 'error', fn: 'sendRequest()', error: err.message || err });
+                return;
+            }
+        });
+    }
+    refreshRequests() {
+        if (!this.data.isPedalling || this.data.pedalRpm === 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.logEvent({ message: 'add request', request: bikeRequest });
+            this.requests.push(bikeRequest);
+        }
+    }
+    processClientRequest(request) {
+        if (request.slope !== undefined) {
+            this.data.slope = request.slope;
+        }
+        return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+            let bikeRequest = this.getCyclingMode().sendBikeUpdate(request);
+            this.logEvent({ message: 'add request', request: bikeRequest });
+            this.requests.push(bikeRequest);
+            resolve(bikeRequest);
+        }));
     }
 }
 exports.default = DaumAdapterBase;

package/lib/daum/ERGCyclingMode.d.ts

@@ -0,0 +1,28 @@
+import { EventLogger } from "gd-eventlog";
+import CyclingMode, { CyclingModeBase, CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import DaumAdapter from "./DaumAdapter";
+export declare type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class ERGCyclingMode extends CyclingModeBase implements CyclingMode {
+    logger: EventLogger;
+    data: IncyclistBikeData;
+    prevRequest: UpdateRequest;
+    prevUpdateTS: number;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    constructor(adapter: DaumAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+    calculateTargetPower(request: any, updateMode?: boolean): any;
+}

package/lib/daum/ERGCyclingMode.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const CyclingMode_1 = require("../CyclingMode");
+const calculations_1 = __importDefault(require("../calculations"));
+const config = {
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of raining', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+    ]
+};
+class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.prevUpdateTS = 0;
+        this.hasBikeUpdate = false;
+        this.event = {};
+        this.logger = adapter.logger || new gd_eventlog_1.EventLogger('ERGMode');
+        this.data = {};
+        this.logger.logEvent({ message: 'constructor', props });
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        const startPower = this.getSetting('startPower');
+        return { targetPower: startPower };
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { gear, pedalRpm, slope, power, speed } = this.data;
+            return { gear, pedalRpm, slope, power, speed };
+        };
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event: this.event });
+        let newRequest = {};
+        try {
+            if (!request || request.reset || Object.keys(request).length === 0) {
+                this.prevRequest = {};
+                return request || {};
+            }
+            const prevData = this.data || {};
+            if (request.targetPower !== undefined) {
+                delete request.slope;
+                delete request.refresh;
+            }
+            if (this.event.starting && request.targetPower === undefined) {
+                const startPower = this.getSetting('startPower');
+                if (this.event.tsStart && Date.now() - this.event.tsStart > 5000) {
+                    delete this.event.starting;
+                    delete this.event.tsStart;
+                }
+                const target = this.calculateTargetPower(request);
+                if (target <= startPower && (!request.minPower || target >= request.minPower)) {
+                    return {};
+                }
+                else {
+                    delete this.event.starting;
+                    delete this.event.tsStart;
+                }
+            }
+            if (request.refresh) {
+                delete request.refresh;
+                if (this.prevRequest !== undefined && !this.event.gearUpdated && !this.event.rpmUpdated) {
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                }
+                else {
+                    newRequest.targetPower = this.calculateTargetPower(request);
+                }
+                if (this.prevRequest !== undefined && Object.keys(this.prevRequest).length > 0) {
+                    request = Object.assign({}, this.prevRequest);
+                }
+                else {
+                    newRequest.targetPower = this.calculateTargetPower(request);
+                }
+            }
+            if (request.slope !== undefined) {
+                if (!this.data)
+                    this.data = {};
+                this.data.slope = request.slope;
+            }
+            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+                request.targetPower = request.maxPower;
+            }
+            if (request.targetPower === undefined) {
+                newRequest.targetPower = this.calculateTargetPower(request);
+            }
+            else {
+                newRequest.targetPower = request.targetPower;
+            }
+            delete request.slope;
+            if (request.maxPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
+                    newRequest.targetPower = request.maxPower;
+                }
+                newRequest.maxPower = request.maxPower;
+            }
+            if (request.minPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
+                    newRequest.targetPower = request.minPower;
+                }
+                newRequest.minPower = request.minPower;
+            }
+            if (newRequest.targetPower !== undefined && prevData.power !== undefined && newRequest.targetPower === prevData.power) {
+                delete newRequest.targetPower;
+            }
+            this.prevRequest = JSON.parse(JSON.stringify(request));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
+        }
+        return newRequest;
+    }
+    updateData(bikeData) {
+        const prevData = JSON.parse(JSON.stringify(this.data || {}));
+        const prevSpeed = prevData.speed;
+        const prevRequest = this.prevRequest || {};
+        const data = this.data || {};
+        const bikeType = this.getSetting('bikeType');
+        delete this.event.gearUpdated;
+        delete this.event.rpmUpdated;
+        if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
+            this.event.starting = true;
+            this.event.tsStart = Date.now();
+        }
+        try {
+            let rpm = bikeData.pedalRpm || 0;
+            let gear = bikeData.gear || 0;
+            let power = bikeData.power || 0;
+            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            let speed;
+            let m = this.adapter.getWeight();
+            let distanceInternal = prevData.distanceInternal || 0;
+            let distance = Math.round(distanceInternal / 100);
+            let ts = Date.now();
+            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+            if (rpm === 0 || bikeData.isPedalling === false) {
+                speed = 0;
+                power = 0;
+            }
+            else {
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType });
+                let v = speed / 3.6;
+                distanceInternal += Math.round(v * duration);
+                distance = Math.round(distanceInternal / 100);
+            }
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.distanceInternal = Math.round(distanceInternal);
+            data.distance = distance;
+            data.slope = slope;
+            data.pedalRpm = rpm;
+            data.gear = gear;
+            if (data.time)
+                data.time += duration;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = bikeData.isPedalling;
+            if (gear !== prevData.gear) {
+                this.event.gearUpdated = true;
+            }
+            if (rpm && rpm !== prevData.pedalRpm) {
+                this.event.rpmUpdated = true;
+            }
+            this.prevUpdateTS = ts;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
+        this.data = data;
+        return data;
+    }
+    calculateTargetPower(request, updateMode = true) {
+        const bikeType = this.getSetting('bikeType').toLowerCase();
+        const defaultPower = this.getSetting('startPower');
+        let m = this.adapter.getWeight();
+        const prevData = this.data || {};
+        let target;
+        if (prevData.pedalRpm && prevData.gear && (!updateMode || prevData.pedalRpm !== 0)) {
+            const speed = calculations_1.default.calculateSpeedDaum(prevData.gear, prevData.pedalRpm, bikeType);
+            var power = calculations_1.default.calculatePower(m, speed / 3.6, 0, { bikeType });
+            target = Math.round(power);
+        }
+        else {
+            target = Math.round(request.targetPower || defaultPower);
+        }
+        return target;
+    }
+}
+exports.default = ERGCyclingMode;

package/lib/daum/PowerMeterCyclingMode.d.ts

@@ -0,0 +1,18 @@
+import { EventLogger } from "gd-eventlog";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest, CyclingModeBase } from "../CyclingMode";
+import DaumAdapter from "./DaumAdapter";
+export default class PowerMeterCyclingMode extends CyclingModeBase implements CyclingMode {
+    logger: EventLogger;
+    data: IncyclistBikeData;
+    prevRequest: UpdateRequest;
+    prevUpdateTS: number;
+    hasBikeUpdate: boolean;
+    constructor(adapter: DaumAdapter, props?: Settings);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+}