incyclist-devices 1.4.92 → 1.4.93

package/lib/Device.d.ts

@@ -55,7 +55,8 @@ export default class IncyclistDevice implements DeviceAdapter {
     detected: boolean;
     selected: boolean;
     onDataFn: OnDeviceDataCallback;
-    constructor(proto: DeviceProtocol);
+    settings: any;
+    constructor(proto: DeviceProtocol, settings?: any);
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
@@ -66,7 +67,10 @@ export default class IncyclistDevice implements DeviceAdapter {
     getPort(): string;
     getProtocol(): DeviceProtocol;
     getProtocolName(): string | undefined;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
     setIgnoreHrm(ignore: any): void;
     setIgnorePower(ignore: any): void;
     setIgnoreBike(ignore: any): void;

package/lib/Device.js

@@ -4,11 +4,12 @@ exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
 class IncyclistDevice {
-    constructor(proto) {
+    constructor(proto, settings) {
         this.protocol = proto;
         this.detected = false;
         this.selected = false;
         this.onDataFn = undefined;
+        this.settings = settings;
     }
     isBike() { throw new Error('not implemented'); }
     isPower() { throw new Error('not implemented'); }
@@ -22,7 +23,30 @@ class IncyclistDevice {
     getProtocolName() {
         return this.protocol ? this.protocol.getName() : undefined;
     }
-    setCyclingMode(mode, settings) { }
+    getSupportedCyclingModes() { throw new Error('not implemented'); }
+    getDefaultCyclingMode() { throw new Error('not implemented'); }
+    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.settings.cyclingMode = new CyclingModeClass(this, settings);
+                return;
+            }
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.settings.cyclingMode = selectedMode;
+        this.settings.cyclingMode.setSettings(settings);
+    }
+    getCyclingMode() {
+        if (!this.settings.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.settings.cyclingMode;
+    }
     setIgnoreHrm(ignore) { }
     setIgnorePower(ignore) { }
     setIgnoreBike(ignore) { }

package/lib/kettler/ergo-racer/ERGCyclingMode.d.ts

@@ -0,0 +1,24 @@
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from '../../CyclingMode';
+import KettlerAdapter from "./adapter";
+import PowerBasedCyclingModeBase from '../../modes/power-base';
+export declare type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    constructor(adapter: KettlerAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+}

package/lib/kettler/ergo-racer/ERGCyclingMode.js

@@ -0,0 +1,144 @@
+"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 power_base_1 = __importDefault(require("../../modes/power-base"));
+const MIN_SPEED = 10;
+const config = {
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power is either set by a workout",
+    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 training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+    ]
+};
+class ERGCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.hasBikeUpdate = false;
+        this.event = {};
+        this.initLogger('ERGMode');
+    }
+    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 { pedalRpm, slope, power, speed } = this.data;
+            return { pedalRpm, slope, power, speed };
+        };
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
+        let newRequest = {};
+        try {
+            if (!request || request.reset || Object.keys(request).length === 0) {
+                this.prevRequest = {};
+                return request.reset ? { reset: true } : {};
+            }
+            const prevData = this.data || {};
+            if (request.targetPower !== undefined) {
+                delete request.slope;
+                delete request.refresh;
+            }
+            if (request.refresh) {
+                delete request.refresh;
+                if (this.prevRequest)
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                else {
+                    this.prevRequest = this.getBikeInitRequest();
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                }
+            }
+            if (request.slope !== undefined) {
+                if (!this.data)
+                    this.data = {};
+                this.data.slope = request.slope;
+                delete request.slope;
+            }
+            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+                request.targetPower = request.maxPower;
+                newRequest.targetPower = request.targetPower;
+            }
+            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 (prevData.power && prevData.power < request.minPower)
+                    newRequest.targetPower = request.minPower;
+            }
+            if (!newRequest.targetPower && newRequest.maxPower && prevData.power > newRequest.maxPower) {
+                newRequest.targetPower = newRequest.maxPower;
+            }
+            if (!newRequest.targetPower && newRequest.minPower && prevData.power < newRequest.minPower) {
+                newRequest.targetPower = newRequest.minPower;
+            }
+            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').toLowerCase();
+        try {
+            let power = bikeData.power || 0;
+            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            const distanceInternal = prevData.distanceInternal || 0;
+            const m = this.getWeight();
+            const t = this.getTimeSinceLastUpdate();
+            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+            if (power === 0 && speed < MIN_SPEED) {
+                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = (power === 0 && speed < MIN_SPEED) ? 0 : speed;
+                data.distanceInternal = (power === 0 && speed < MIN_SPEED) ? distanceInternal : distanceInternal + distance;
+            }
+            data.power = Math.round(power);
+            data.slope = slope;
+            data.pedalRpm = bikeData.pedalRpm || 0;
+            if (data.time !== undefined && data.speed > 0)
+                data.time += t;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = bikeData.isPedalling;
+        }
+        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 = ERGCyclingMode;

package/lib/kettler/ergo-racer/adapter.d.ts

@@ -28,7 +28,6 @@ export interface KettlerDeviceSettings extends DeviceSettings {
 }
 export default class KettlerRacerAdapter extends DeviceAdapterBase implements DeviceAdapter, Bike {
     private id;
-    private settings;
     private ignoreHrm;
     private ignoreBike;
     private ignorePower;
@@ -43,7 +42,7 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     private requestBusy;
     private comms;
     private prevDistance;
-    constructor(protocol: DeviceProtocol, settings: DeviceSettings);
+    constructor(protocol: DeviceProtocol, settings: KettlerDeviceSettings);
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
@@ -96,8 +95,6 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     waitForOpened(retries?: boolean): Promise<boolean>;
     waitForClosed(): Promise<boolean>;
     getSupportedCyclingModes(): any[];
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
     setUserSettings(userSettings: any): void;
     setBikeSettings(bikeSettings: any): void;

package/lib/kettler/ergo-racer/adapter.js

@@ -36,12 +36,12 @@ const gd_eventlog_1 = require("gd-eventlog");
 const comms_1 = __importDefault(require("../comms"));
 const utils_1 = require("../../utils");
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
 class KettlerRacerAdapter extends Device_1.default {
     constructor(protocol, settings) {
-        super(protocol);
+        super(protocol, settings);
         this.requests = [];
         this.logger = new gd_eventlog_1.EventLogger('KettlerRacer');
-        this.settings = settings;
         this.ignoreHrm = false;
         this.ignorePower = false;
         this.ignoreBike = false;
@@ -624,32 +624,10 @@ class KettlerRacerAdapter extends Device_1.default {
         });
     }
     getSupportedCyclingModes() {
-        return [power_meter_1.default];
-    }
-    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.settings.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.settings.cyclingMode = selectedMode;
-        this.settings.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.settings.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.settings.cyclingMode;
+        return [power_meter_1.default, ERGCyclingMode_1.default];
     }
     getDefaultCyclingMode() {
-        return new power_meter_1.default(this);
+        return new ERGCyclingMode_1.default(this);
     }
     setUserSettings(userSettings) {
         this.settings.userSettings = userSettings;

package/package.json

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