incyclist-devices 1.4.23 → 1.4.26

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,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

@@ -0,0 +1,20 @@
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from '../CyclingMode';
+import PowerBasedCyclingModeBase from './power-base';
+import { DeviceAdapter } from '../Device';
+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(bikeData: IncyclistBikeData, props?: {
+        log: boolean;
+    }): IncyclistBikeData;
+}

package/lib/modes/power-meter.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+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 power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('PowerMeterMode');
+        this.data = { speed: 0, slope: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
+    }
+    getName() {
+        return exports.config.name;
+    }
+    getDescription() {
+        return exports.config.description;
+    }
+    getProperties() {
+        return exports.config.properties;
+    }
+    getProperty(name) {
+        return exports.config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    sendBikeUpdate(request = {}) {
+        const prevData = this.data || {};
+        const prevSlope = prevData.slope || 0;
+        if (request.slope && request.slope !== prevSlope) {
+            this.data.slope = request.slope;
+            this.updateData(this.data, { log: false });
+        }
+        this.logger.logEvent({ message: "processing update request", request });
+        return {};
+    }
+    updateData(bikeData, props = { log: true }) {
+        try {
+            const prevData = this.data || {};
+            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) {
+                power = 0;
+            }
+            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 + distance);
+            data.slope = slope;
+            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 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

@@ -1,4 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,22 +27,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulator = void 0;
 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 +72,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/lib/types/route.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteType = void 0;
 var RouteType;
 (function (RouteType) {
     RouteType["FREE_RIDE"] = "free ride";

package/lib/types/user.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gender = void 0;
 var Gender;
 (function (Gender) {
     Gender["MALE"] = "M";

package/lib/utils.js

@@ -9,9 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = (ms) => {
+exports.Queue = exports.hexstr = exports.intVal = exports.floatVal = exports.runWithRetries = exports.sleep = void 0;
+const sleep = (ms) => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
+exports.sleep = sleep;
 function runWithRetries(fn, maxRetries, timeBetween) {
     return new Promise((resolve, reject) => {
         let retries = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.23",
+  "version": "1.4.26",
   "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"