incyclist-devices 1.4.24 → 1.4.27

package/lib/modes/power-base.js

@@ -0,0 +1,70 @@
+"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;
+        if (Ekin > 0) {
+            const v = Math.sqrt(2 * Ekin / m);
+            const speed = v * 3.6;
+            const distance = v * t;
+            this.data.speed = speed;
+            return { speed, distance };
+        }
+        else {
+            const v = vPrev * 0.5;
+            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 vTarget = (speed || 0) / 3.6;
+        const Ekin = 1 / 2 * m * vTarget * vTarget;
+        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.27",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",
@@ -22,6 +22,7 @@
     "typescript": "^4.5.2"
   },
   "scripts": {
+    "lint": "eslint . --ext .ts",
     "build": "tsc",
     "test": "jest --coverage",
     "dev": "nodemon --watch src -e ts,js --exec npm run build"