incyclist-devices 1.4.24 → 1.4.25

package/lib/DeviceProtocol.d.ts

@@ -56,6 +56,7 @@ export default class DeviceProtocolBase {
     scan(props: ScanProps): void;
     stopScan(): void;
     isScanning(): boolean;
+    add(props: DeviceSettings): void;
     getDevices(): Array<Device>;
     setAnt(antClass: any): void;
     getAnt(): any;

package/lib/DeviceProtocol.js

@@ -21,6 +21,7 @@ class DeviceProtocolBase {
     scan(props) { throw new Error('not implemented'); }
     stopScan() { throw new Error('not implemented'); }
     isScanning() { throw new Error('not implemented'); }
+    add(props) { throw new Error('Method not implemented.'); }
     getDevices() { return this.devices; }
     setAnt(antClass) { DeviceProtocolBase.setAnt(antClass); }
     getAnt() { return DeviceProtocolBase.getAnt(); }

package/lib/calculations.js

@@ -7,7 +7,6 @@ const cwABike = {
     triathlon: 0.29,
     mountain: 0.57
 };
-const k = 0.01090;
 const cRR = 0.0036;
 class IllegalArgumentException extends Error {
     constructor(message) {
@@ -28,7 +27,7 @@ class C {
         const _cRR = props.cRR || cRR;
         const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.atan(slope / 100);
-        let c1 = 0.5 * _rho * _cwA + 2 * k;
+        let c1 = 0.5 * _rho * _cwA;
         let c2 = (sl + _cRR) * m * g;
         let p = c2 / c1;
         let q = -1.0 * power / c1;
@@ -70,7 +69,7 @@ class C {
         let _cRR = props.cRR || cRR;
         let _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.sin(Math.atan(slope / 100));
-        let P = (0.5 * _rho * _cwA + 2 * k) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
+        let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
         return P;
     }
     static calculateSpeedDaum(gear, rpm, bikeType) {

package/lib/daum/DaumAdapter.d.ts

@@ -13,7 +13,7 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     distanceInternal: number;
     paused: boolean;
     stopped: boolean;
-    daumRunData: IncyclistBikeData;
+    cyclingData: IncyclistBikeData;
     deviceData: DeviceData;
     currentRequest: any;
     requests: Array<any>;
@@ -56,7 +56,7 @@ export default class DaumAdapterBase extends DeviceAdapterBase implements Device
     update(): Promise<void>;
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
-    updateData(prev: any, bikeData: any): void;
+    updateData(prev: any, bikeData: any): IncyclistBikeData;
     transformData(): DeviceData;
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;

package/lib/daum/DaumAdapter.js

@@ -22,7 +22,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Device_1 = __importStar(require("../Device"));
 const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
 const SmartTrainerCyclingMode_1 = __importDefault(require("./SmartTrainerCyclingMode"));
-const PowerMeterCyclingMode_1 = __importDefault(require("./PowerMeterCyclingMode"));
+const DaumPowerMeterCyclingMode_1 = __importDefault(require("./DaumPowerMeterCyclingMode"));
 const utils_1 = require("../utils");
 class DaumAdapterBase extends Device_1.default {
     constructor(props, bike) {
@@ -34,7 +34,7 @@ class DaumAdapterBase extends Device_1.default {
         this.bike = bike;
         this.stopped = false;
         this.paused = false;
-        this.daumRunData = {
+        this.cyclingData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -67,7 +67,7 @@ class DaumAdapterBase extends Device_1.default {
         this.cyclingMode.setSettings(settings);
     }
     getSupportedCyclingModes() {
-        return [ERGCyclingMode_1.default, SmartTrainerCyclingMode_1.default, PowerMeterCyclingMode_1.default];
+        return [ERGCyclingMode_1.default, SmartTrainerCyclingMode_1.default, DaumPowerMeterCyclingMode_1.default];
     }
     getCyclingMode() {
         if (!this.cyclingMode)
@@ -128,7 +128,7 @@ class DaumAdapterBase extends Device_1.default {
         this.distanceInternal = undefined;
         this.paused = false;
         this.stopped = false;
-        this.daumRunData = {
+        this.cyclingData = {
             isPedalling: false,
             time: 0,
             power: 0,
@@ -229,12 +229,15 @@ class DaumAdapterBase extends Device_1.default {
             this.updateBusy = true;
             this.getCurrentBikeData()
                 .then(bikeData => {
-                this.updateData(this.daumRunData, bikeData);
+                this.updateData(this.cyclingData, bikeData);
                 this.transformData();
                 this.updateBusy = false;
             })
                 .catch(err => {
                 this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
+                const { isPedalling, power, pedalRpm, speed, distanceInternal, heartrate, slope } = this.cyclingData;
+                this.updateData(this.cyclingData, { isPedalling, power, pedalRpm, speed, distanceInternal, heartrate, slope });
+                this.transformData();
                 this.updateBusy = false;
             });
         });
@@ -289,27 +292,28 @@ class DaumAdapterBase extends Device_1.default {
         data.time = bikeData.time;
         if (bikeData.slope)
             data.slope = bikeData.slope;
-        this.daumRunData = this.getCyclingMode().updateData(data);
+        this.cyclingData = this.getCyclingMode().updateData(data);
+        return this.cyclingData;
     }
     transformData() {
-        if (this.daumRunData === undefined)
+        if (this.cyclingData === undefined)
             return;
         let distance = 0;
-        if (this.distanceInternal !== undefined && this.daumRunData.distanceInternal !== undefined) {
-            distance = utils_1.intVal(this.daumRunData.distanceInternal - this.distanceInternal);
+        if (this.distanceInternal !== undefined && this.cyclingData.distanceInternal !== undefined) {
+            distance = utils_1.intVal(this.cyclingData.distanceInternal - this.distanceInternal);
         }
-        if (this.daumRunData.distanceInternal !== undefined)
-            this.distanceInternal = this.daumRunData.distanceInternal;
+        if (this.cyclingData.distanceInternal !== undefined)
+            this.distanceInternal = this.cyclingData.distanceInternal;
         let data = {
-            speed: utils_1.floatVal(this.daumRunData.speed),
-            slope: utils_1.floatVal(this.daumRunData.slope),
-            power: utils_1.intVal(this.daumRunData.power),
-            cadence: utils_1.intVal(this.daumRunData.pedalRpm),
-            heartrate: utils_1.intVal(this.daumRunData.heartrate),
+            speed: utils_1.floatVal(this.cyclingData.speed),
+            slope: utils_1.floatVal(this.cyclingData.slope),
+            power: utils_1.intVal(this.cyclingData.power),
+            cadence: utils_1.intVal(this.cyclingData.pedalRpm),
+            heartrate: utils_1.intVal(this.cyclingData.heartrate),
             distance,
             timestamp: Date.now(),
-            deviceTime: this.daumRunData.time,
-            deviceDistanceCounter: this.daumRunData.distanceInternal
+            deviceTime: this.cyclingData.time,
+            deviceDistanceCounter: this.cyclingData.distanceInternal
         };
         if (this.ignoreHrm)
             delete data.heartrate;
@@ -350,7 +354,7 @@ class DaumAdapterBase extends Device_1.default {
         });
     }
     refreshRequests() {
-        if (!this.daumRunData.isPedalling || this.daumRunData.pedalRpm === 0)
+        if (!this.cyclingData.isPedalling || this.cyclingData.pedalRpm === 0)
             return;
         let bikeRequest = this.getCyclingMode().sendBikeUpdate({ refresh: true }) || {};
         const prev = this.requests[this.requests.length - 1] || {};
@@ -361,7 +365,7 @@ class DaumAdapterBase extends Device_1.default {
     }
     processClientRequest(request) {
         if (request.slope !== undefined) {
-            this.daumRunData.slope = request.slope;
+            this.cyclingData.slope = request.slope;
         }
         return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
             let bikeRequest = this.getCyclingMode().sendBikeUpdate(request);

package/lib/daum/DaumPowerMeterCyclingMode.d.ts

@@ -0,0 +1,8 @@
+import CyclingMode, { UpdateRequest } from "../CyclingMode";
+import PowerMeterCyclingMode from "../modes/power-meter";
+export default class DaumPowerMeterCyclingMode extends PowerMeterCyclingMode implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/daum/DaumPowerMeterCyclingMode.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const power_meter_1 = __importDefault(require("../modes/power-meter"));
+class DaumPowerMeterCyclingMode extends power_meter_1.default {
+    constructor() {
+        super(...arguments);
+        this.hasBikeUpdate = false;
+    }
+    getBikeInitRequest() {
+        return { slope: 0 };
+    }
+    sendBikeUpdate(request) {
+        super.sendBikeUpdate(request);
+        this.prevRequest = {};
+        return {};
+    }
+}
+exports.default = DaumPowerMeterCyclingMode;

package/lib/daum/ERGCyclingMode.d.ts

@@ -1,17 +1,14 @@
-import { EventLogger } from "gd-eventlog";
-import CyclingMode, { CyclingModeBase, CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
 import DaumAdapter from "./DaumAdapter";
+import PowerBasedCyclingModeBase from "../modes/power-base";
 export declare type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
     starting?: boolean;
     tsStart?: number;
 };
-export default class ERGCyclingMode extends CyclingModeBase implements CyclingMode {
-    logger: EventLogger;
-    data: IncyclistBikeData;
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
-    prevUpdateTS: number;
     hasBikeUpdate: boolean;
     chain: number[];
     cassette: number[];

package/lib/daum/ERGCyclingMode.js

@@ -3,9 +3,9 @@ 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 power_base_1 = __importDefault(require("../modes/power-base"));
 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",
@@ -14,15 +14,12 @@ const config = {
         { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
     ]
 };
-class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
+class ERGCyclingMode extends power_base_1.default {
     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 });
+        this.initLogger('ERGMode');
     }
     getName() {
         return config.name;
@@ -132,7 +129,6 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
         const prevRequest = this.prevRequest || {};
         const data = this.data || {};
         const bikeType = this.getSetting('bikeType').toLowerCase();
-        console.log('~~~ bikeType', bikeType);
         delete this.event.gearUpdated;
         delete this.event.rpmUpdated;
         if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
@@ -140,32 +136,25 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
             this.event.tsStart = Date.now();
         }
         try {
-            let rpm = bikeData.pedalRpm || 0;
-            let gear = bikeData.gear || 0;
+            const rpm = bikeData.pedalRpm || 0;
+            const 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 ts = Date.now();
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-            if (rpm === 0 || bikeData.isPedalling === false) {
-                speed = 0;
+            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            const distanceInternal = prevData.distanceInternal || 0;
+            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
                 power = 0;
             }
-            else {
-                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType });
-                let v = speed / 3.6;
-                distanceInternal += Math.round(v * duration);
-            }
+            const m = this.getWeight();
+            const t = this.getTimeSinceLastUpdate();
+            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
             data.speed = parseFloat(speed.toFixed(1));
             data.power = Math.round(power);
-            data.distanceInternal = distanceInternal;
+            data.distanceInternal = Math.round(distanceInternal + distance);
             data.slope = slope;
             data.pedalRpm = rpm;
             data.gear = gear;
-            if (data.time !== undefined)
-                data.time += duration;
+            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
+                data.time += t;
             else
                 data.time = 0;
             data.heartrate = bikeData.heartrate;
@@ -176,7 +165,6 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
             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 });
@@ -188,7 +176,7 @@ class ERGCyclingMode extends CyclingMode_1.CyclingModeBase {
     calculateTargetPower(request, updateMode = true) {
         const bikeType = this.getSetting('bikeType').toLowerCase();
         const defaultPower = this.getSetting('startPower');
-        let m = this.adapter.getWeight();
+        let m = this.getWeight();
         const prevData = this.data || {};
         let target;
         if (prevData.pedalRpm && prevData.gear && (!updateMode || prevData.pedalRpm !== 0)) {

package/lib/daum/classic/DaumClassicAdapter.js

@@ -109,7 +109,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                         startState.startProg = true;
                     }
                     if (!startState.setGear) {
-                        yield this.bike.setGear(this.daumRunData.gear || (opts.gear || 10));
+                        yield this.bike.setGear(this.cyclingData.gear || (opts.gear || 10));
                         startState.setGear = true;
                     }
                     const startRequest = this.getCyclingMode().getBikeInitRequest();

package/lib/daum/premium/DaumClassicCyclingMode.d.ts

@@ -1,7 +1,7 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../CyclingMode";
 import DaumAdapter from "../DaumAdapter";
-import PowerMeterCyclingMode from "../PowerMeterCyclingMode";
-export default class DaumClassicCyclingMode extends PowerMeterCyclingMode implements CyclingMode {
+import DaumPowerMeterCyclingMode from "../DaumPowerMeterCyclingMode";
+export default class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode implements CyclingMode {
     constructor(adapter: DaumAdapter, props?: Settings);
     getName(): string;
     getDescription(): string;

package/lib/daum/premium/DaumClassicCyclingMode.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const CyclingMode_1 = require("../../CyclingMode");
-const PowerMeterCyclingMode_1 = __importDefault(require("../PowerMeterCyclingMode"));
+const DaumPowerMeterCyclingMode_1 = __importDefault(require("../DaumPowerMeterCyclingMode"));
 const config = {
     name: "Daum Classic",
     description: "The device calculates speed and power based on slope. Incyclist will not modify any values recived from the device\nThis mode will not respect maximum power and/or workout limits",
@@ -13,7 +13,7 @@ const config = {
         { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
     ]
 };
-class DaumClassicCyclingMode extends PowerMeterCyclingMode_1.default {
+class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.logger = adapter ? adapter.logger : undefined;

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -98,7 +98,7 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
                         info.person = yield this.bike.setPerson(user);
                     }
                     if (!this.getCyclingMode().getModeProperty('eppSupport')) {
-                        const gear = yield this.bike.setGear(this.daumRunData.gear || (opts.gear || 10));
+                        const gear = yield this.bike.setGear(this.cyclingData.gear || (opts.gear || 10));
                         return gear;
                     }
                     return;

package/lib/modes/power-base.d.ts

@@ -0,0 +1,20 @@
+import { IncyclistBikeData, Settings, CyclingModeBase } from '../CyclingMode';
+import { DeviceAdapter } from '../Device';
+import { EventLogger } from 'gd-eventlog';
+export default class PowerBasedCyclingModeBase extends CyclingModeBase {
+    data: IncyclistBikeData;
+    prevUpdateTS: number;
+    logger: EventLogger;
+    constructor(adapter: DeviceAdapter, props?: Settings);
+    initLogger(defaultLogName: any): void;
+    getWeight(): any;
+    getTimeSinceLastUpdate(): number;
+    calculateSpeedAndDistance(power: number, slope: number, m: number, t: number, props?: {}): {
+        speed: number;
+        distance: number;
+    };
+    calculatePowerAndDistance(speed: number, slope: number, m: number, t: number, props?: {}): {
+        power: number;
+        distance: number;
+    };
+}

package/lib/modes/power-base.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CyclingMode_1 = require("../CyclingMode");
+const Device_1 = require("../Device");
+const calculations_1 = __importDefault(require("../calculations"));
+const gd_eventlog_1 = require("gd-eventlog");
+class PowerBasedCyclingModeBase extends CyclingMode_1.CyclingModeBase {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.prevUpdateTS = 0;
+        this.data = { speed: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
+    }
+    initLogger(defaultLogName) {
+        const a = this.adapter;
+        this.logger = (a && a.getLogger) ? a.getLogger() : undefined;
+        if (!this.logger)
+            this.logger = new gd_eventlog_1.EventLogger(defaultLogName);
+    }
+    getWeight() {
+        const a = this.adapter;
+        const m = (a && a.getWeight && a.getWeight()) ? a.getWeight() : Device_1.DEFAULT_BIKE_WEIGHT + Device_1.DEFAULT_USER_WEIGHT;
+        return m;
+    }
+    getTimeSinceLastUpdate() {
+        const ts = Date.now();
+        const duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+        this.prevUpdateTS = ts;
+        return duration;
+    }
+    calculateSpeedAndDistance(power, slope, m, t, props = {}) {
+        const prevData = this.data || {};
+        const vPrev = (prevData.speed || 0) / 3.6;
+        const EkinPrev = 1 / 2 * m * vPrev * vPrev;
+        let powerToMaintainSpeed = calculations_1.default.calculatePower(m, vPrev, slope, props);
+        const powerDelta = powerToMaintainSpeed - power;
+        const Ekin = EkinPrev - powerDelta * t;
+        const v = Math.sqrt(2 * Ekin / m);
+        const speed = v * 3.6;
+        const distance = v * t;
+        this.data.speed = speed;
+        return { speed, distance };
+    }
+    calculatePowerAndDistance(speed, slope, m, t, props = {}) {
+        const prevData = this.data || {};
+        const vPrev = (prevData.speed || 0) / 3.6;
+        const EkinPrev = 1 / 2 * m * vPrev * vPrev;
+        const Ekin = 1 / 2 * m * speed * speed;
+        const powerDelta = t !== 0 ? (EkinPrev - Ekin) / t : 0;
+        const powerToMaintainSpeed = calculations_1.default.calculatePower(m, vPrev, slope, props);
+        const power = powerToMaintainSpeed - powerDelta;
+        const v = speed / 3.6;
+        const distance = v * t;
+        this.data.power = power;
+        return { power, distance };
+    }
+}
+exports.default = PowerBasedCyclingModeBase;

package/lib/modes/power-meter.d.ts

@@ -1,18 +1,20 @@
-import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest, CyclingModeBase } from '../CyclingMode';
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from '../CyclingMode';
+import PowerBasedCyclingModeBase from './power-base';
 import { DeviceAdapter } from '../Device';
-export default class PowerMeterCyclingMode extends CyclingModeBase implements CyclingMode {
-    logger: EventLogger;
-    data: IncyclistBikeData;
-    prevRequest: UpdateRequest;
-    prevUpdateTS: number;
-    hasBikeUpdate: boolean;
+export declare const config: {
+    name: string;
+    description: string;
+    properties: any[];
+};
+export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     constructor(adapter: DeviceAdapter, props?: Settings);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];
     getProperty(name: string): CyclingModeProperty;
     getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
+    sendBikeUpdate(request?: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData, props?: {
+        log: boolean;
+    }): IncyclistBikeData;
 }

package/lib/modes/power-meter.js

@@ -3,84 +3,68 @@ 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 Device_1 = require("../Device");
-const calculations_1 = __importDefault(require("../calculations"));
-const config = {
+const power_base_1 = __importDefault(require("./power-base"));
+exports.config = {
     name: 'PowerMeter',
     description: 'Power and cadence are taken from device. Speed is calculated from power and current slope\nThis mode will not respect maximum power and/or workout limits',
     properties: []
 };
-class PowerMeterCyclingMode extends CyclingMode_1.CyclingModeBase {
+class PowerMeterCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.prevUpdateTS = 0;
-        this.hasBikeUpdate = false;
-        const a = adapter;
-        this.logger = (a && a.getLogger) ? a.getLogger() : undefined;
-        if (!this.logger)
-            this.logger = new gd_eventlog_1.EventLogger('PowerMeter');
+        this.initLogger('PowerMeterMode');
+        this.data = { speed: 0, slope: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
     }
     getName() {
-        return config.name;
+        return exports.config.name;
     }
     getDescription() {
-        return config.description;
+        return exports.config.description;
     }
     getProperties() {
-        return config.properties;
+        return exports.config.properties;
     }
     getProperty(name) {
-        return config.properties.find(p => p.name === name);
+        return exports.config.properties.find(p => p.name === name);
     }
     getBikeInitRequest() {
         return {};
     }
-    sendBikeUpdate(request) {
-        if (request.slope)
+    sendBikeUpdate(request = {}) {
+        const prevData = this.data || {};
+        const prevSlope = prevData.slope || 0;
+        if (request.slope && request.slope !== prevSlope) {
             this.data.slope = request.slope;
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest });
-        this.prevRequest = {};
+            this.updateData(this.data, { log: false });
+        }
+        this.logger.logEvent({ message: "processing update request", request });
         return {};
     }
-    updateData(data) {
+    updateData(bikeData, props = { log: true }) {
         try {
             const prevData = this.data || {};
-            const prevRequest = this.prevRequest || {};
-            const bikeData = JSON.parse(JSON.stringify(data));
-            let power = data.power || 0;
-            let speed = data.speed || 0;
-            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            let distanceInternal = prevData.distanceInternal || 0;
+            const data = JSON.parse(JSON.stringify(bikeData));
+            let power = bikeData.power || 0;
+            const slope = prevData.slope || 0;
+            const distanceInternal = prevData.distanceInternal || 0;
             if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
-                speed = 0;
                 power = 0;
             }
-            let ts = Date.now();
-            const a = this.adapter;
-            const m = a.getWeight ? a.getWeight() : Device_1.DEFAULT_BIKE_WEIGHT + Device_1.DEFAULT_USER_WEIGHT;
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-            const vPrev = (prevData.speed || 0) / 3.6;
-            const EkinPrev = 1 / 2 * m * vPrev * vPrev;
-            let powerRequired = calculations_1.default.calculatePower(m, vPrev, prevData.slope || 0);
-            const powerDelta = powerRequired - power;
-            const Ekin = EkinPrev - powerDelta * duration;
-            const v = Math.sqrt(2 * Ekin / m);
-            speed = v * 3.6;
-            distanceInternal += Math.round(v * duration);
-            data.speed = parseFloat(speed.toFixed(1));
+            const m = this.getWeight();
+            let t = this.getTimeSinceLastUpdate();
+            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t);
+            data.speed = speed;
             data.power = Math.round(power);
-            data.distanceInternal = Math.round(distanceInternal);
+            data.distanceInternal = Math.round(distanceInternal + distance);
             data.slope = slope;
-            this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: {}, prevSpeed: prevData.speed });
-            this.data = JSON.parse(JSON.stringify(data));
-            this.prevUpdateTS = ts;
+            if (props.log)
+                this.logger.logEvent({ message: "updateData result", data, bikeData, prevSpeed: prevData.speed });
+            this.data = data;
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
         }
-        return data;
+        return this.data;
     }
 }
 exports.default = PowerMeterCyclingMode;

package/lib/modes/simulator.d.ts

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

package/lib/modes/simulator.js

@@ -0,0 +1,118 @@
+"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: "Simulator",
+    description: "Simulates a ride with constant speed or power output",
+    properties: [
+        { key: 'mode', name: 'Simulation Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
+        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
+        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
+        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
+    ]
+};
+class SimulatorCyclingMode 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('SIMMode');
+        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() {
+        return {};
+    }
+    sendBikeUpdate(request) {
+        this.logger.logEvent({ message: 'bike update request', request });
+        const r = request || { refresh: true };
+        if (r.refresh) {
+            if (Object.keys(r).length === 1)
+                return this.prevRequest || {};
+            delete r.refresh;
+        }
+        if (request.slope !== undefined) {
+            if (!this.data)
+                this.data = {};
+            this.data.slope = request.slope;
+        }
+        this.prevRequest = request ? JSON.parse(JSON.stringify(request)) : {};
+        return r;
+    }
+    updateData(bikeData) {
+        const prevData = JSON.parse(JSON.stringify(this.data || {}));
+        const prevSpeed = prevData.speed;
+        const prevRequest = this.prevRequest || {};
+        const data = this.data || {};
+        const mode = this.getSetting('mode');
+        delete this.event.gearUpdated;
+        delete this.event.rpmUpdated;
+        try {
+            let rpm = 90;
+            let power = (mode === 'Power' || !mode) ? Number(this.getSetting('power')) : bikeData.power || 0;
+            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            let speed = mode === 'Speed' ? Number(this.getSetting('speed')) : bikeData.speed || 0;
+            let m = 75;
+            let distanceInternal = prevData.distanceInternal || 0;
+            let ts = Date.now();
+            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+            if (mode === 'Power' || !mode) {
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            else if (mode === 'Speed') {
+                power = calculations_1.default.calculatePower(m, speed / 3.6, slope, { bikeType: 'race' });
+            }
+            if (prevRequest.targetPower) {
+                power = prevRequest.targetPower;
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            if (prevRequest.maxPower && power > prevRequest.maxPower) {
+                power = prevRequest.maxPower;
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            else if (prevRequest.minPower && power < prevRequest.minPower) {
+                power = prevRequest.minPower;
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            let v = speed / 3.6;
+            distanceInternal += Math.round(v * duration);
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.distanceInternal = distanceInternal;
+            data.slope = slope;
+            data.pedalRpm = rpm;
+            if (data.time !== undefined)
+                data.time += duration;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = 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;
+    }
+}
+exports.default = SimulatorCyclingMode;

package/lib/simulator/Simulator.js

@@ -23,7 +23,7 @@ const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
 const DeviceRegistry_1 = __importDefault(require("../DeviceRegistry"));
 const Device_1 = __importDefault(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
-const simulator_mode_1 = __importDefault(require("./simulator-mode"));
+const simulator_1 = __importDefault(require("../modes/simulator"));
 const DEFAULT_SETTINGS = { name: 'Simulator', port: '', isBot: false };
 class Simulator extends Device_1.default {
     constructor(protocol, props = DEFAULT_SETTINGS) {
@@ -59,11 +59,11 @@ class Simulator extends Device_1.default {
     }
     getSupportedCyclingModes() {
         const supported = [];
-        supported.push(simulator_mode_1.default);
+        supported.push(simulator_1.default);
         return supported;
     }
     getDefaultCyclingMode() {
-        return new simulator_mode_1.default(this);
+        return new simulator_1.default(this);
     }
     getCyclingMode() {
         if (!this.cyclingMode)

package/package.json

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