incyclist-devices 1.4.56 → 1.4.57

package/lib/Device.d.ts

@@ -34,7 +34,7 @@ export interface DeviceAdapter extends Device {
     getName(): string;
     getPort(): string;
     getProtocol(): DeviceProtocol;
-    getProtocolName(): string;
+    getProtocolName(): string | undefined;
     setIgnoreHrm(ignore: boolean): void;
     setIgnorePower(ignore: boolean): void;
     setIgnoreBike(ignore: boolean): void;

package/lib/ant/AntAdapter.d.ts

@@ -17,6 +17,12 @@ export default class AntAdapter extends DeviceAdapter {
     logger: EventLogger;
     lastUpdate?: number;
     updateFrequency: number;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
     constructor(protocol: any);
     isSame(device: DeviceAdapter): boolean;
     setSensor(sensor: any): void;
@@ -26,6 +32,7 @@ export default class AntAdapter extends DeviceAdapter {
     setIgnorePower(ignore: any): void;
     getProfile(): string;
     getPort(): string;
+    getWeight(): number;
     setChannel(channel: any): void;
     setStick(stick: any): void;
     isStopped(): boolean;

package/lib/ant/AntAdapter.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_UPDATE_FREQUENCY = void 0;
 const Device_1 = __importDefault(require("../Device"));
+const Device_2 = require("../Device");
 exports.DEFAULT_UPDATE_FREQUENCY = 1000;
 class AntAdapter extends Device_1.default {
     constructor(protocol) {
@@ -49,6 +50,17 @@ class AntAdapter extends Device_1.default {
     getPort() {
         return this.port;
     }
+    getWeight() {
+        let userWeight = Device_2.DEFAULT_USER_WEIGHT;
+        let bikeWeight = Device_2.DEFAULT_BIKE_WEIGHT;
+        if (this.userSettings && this.userSettings.weight) {
+            userWeight = Number(this.userSettings.weight);
+        }
+        if (this.bikeSettings && this.bikeSettings.weight) {
+            bikeWeight = Number(this.bikeSettings.weight);
+        }
+        return bikeWeight + userWeight;
+    }
     setChannel(channel) {
         this.channel = channel;
     }
@@ -78,6 +90,10 @@ class AntAdapter extends Device_1.default {
         });
     }
     start(props) {
+        if (props && props.user)
+            this.userSettings = props.user;
+        if (props && props.bikeSettings)
+            this.bikeSettings = props.bikeSettings;
         return new Promise(resolve => {
             this.stopped = false;
             resolve(true);

package/lib/ble/pwr.d.ts

@@ -54,6 +54,12 @@ export declare class PwrAdapter extends DeviceAdapter {
     mode: CyclingMode;
     distanceInternal: number;
     prevDataTS: number;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
     constructor(device: BleDeviceClass, protocol: BleProtocol);
     isBike(): boolean;
     isHrm(): boolean;
@@ -65,6 +71,7 @@ export declare class PwrAdapter extends DeviceAdapter {
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
     getPort(): string;
+    getWeight(): number;
     setIgnoreBike(ignore: any): void;
     setIgnorePower(ignore: any): void;
     onDeviceData(deviceData: PowerData): void;

package/lib/ble/pwr.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) {
@@ -15,7 +34,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PwrAdapter = void 0;
 const ble_device_1 = require("./ble-device");
 const ble_interface_1 = __importDefault(require("./ble-interface"));
-const Device_1 = __importDefault(require("../Device"));
+const Device_1 = __importStar(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
 const power_meter_1 = __importDefault(require("../modes/power-meter"));
 class BleCyclingPowerDevice extends ble_device_1.BleDevice {
@@ -172,6 +191,17 @@ class PwrAdapter extends Device_1.default {
     getPort() {
         return 'ble';
     }
+    getWeight() {
+        let userWeight = Device_1.DEFAULT_USER_WEIGHT;
+        let bikeWeight = Device_1.DEFAULT_BIKE_WEIGHT;
+        if (this.userSettings && this.userSettings.weight) {
+            userWeight = Number(this.userSettings.weight);
+        }
+        if (this.bikeSettings && this.bikeSettings.weight) {
+            bikeWeight = Number(this.bikeSettings.weight);
+        }
+        return bikeWeight + userWeight;
+    }
     setIgnoreBike(ignore) {
         this.ignore = ignore;
     }
@@ -230,6 +260,10 @@ class PwrAdapter extends Device_1.default {
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (props && props.user)
+                this.userSettings = props.user;
+            if (props && props.bikeSettings)
+                this.bikeSettings = props.bikeSettings;
             this.logger.logEvent({ message: 'start requested', profile: this.getProfile(), props });
             try {
                 const bleDevice = yield this.ble.connectDevice(this.device);

package/lib/daum/DaumAdapter.js

@@ -108,8 +108,8 @@ class DaumAdapterBase extends Device_1.default {
         }
     }
     getWeight() {
-        const userWeight = this.userSettings.weight || Device_1.DEFAULT_USER_WEIGHT;
-        const bikeWeight = this.bikeSettings.weight || Device_1.DEFAULT_BIKE_WEIGHT;
+        const userWeight = Number(this.userSettings.weight || Device_1.DEFAULT_USER_WEIGHT);
+        const bikeWeight = Number(this.bikeSettings.weight || Device_1.DEFAULT_BIKE_WEIGHT);
         return bikeWeight + userWeight;
     }
     getCurrentBikeData() {
@@ -318,13 +318,13 @@ class DaumAdapterBase extends Device_1.default {
             return;
         let distance = 0;
         if (this.distanceInternal !== undefined && this.cyclingData.distanceInternal !== undefined) {
-            distance = (0, utils_1.intVal)(this.cyclingData.distanceInternal - this.distanceInternal);
+            distance = this.cyclingData.distanceInternal - this.distanceInternal;
         }
         if (this.cyclingData.distanceInternal !== undefined)
             this.distanceInternal = this.cyclingData.distanceInternal;
         let data = {
-            speed: (0, utils_1.floatVal)(this.cyclingData.speed),
-            slope: (0, utils_1.floatVal)(this.cyclingData.slope),
+            speed: this.cyclingData.speed,
+            slope: this.cyclingData.slope,
             power: (0, utils_1.intVal)(this.cyclingData.power),
             cadence: (0, utils_1.intVal)(this.cyclingData.pedalRpm),
             heartrate: (0, utils_1.intVal)(this.cyclingData.heartrate),
@@ -366,7 +366,7 @@ class DaumAdapterBase extends Device_1.default {
             }
             catch (err) {
                 this.requestBusy = false;
-                this.logEvent({ message: 'error', fn: 'sendRequest()', error: err.message || err });
+                this.logEvent({ message: 'sendRequest error', error: err.message || err });
                 return;
             }
         });

package/lib/daum/ERGCyclingMode.js

@@ -147,7 +147,7 @@ class ERGCyclingMode extends power_base_1.default {
             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.speed = speed;
             data.power = Math.round(power);
             data.distanceInternal = distanceInternal + distance;
             data.slope = slope;

package/lib/daum/classic/DaumClassicAdapter.js

@@ -83,7 +83,11 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.logEvent({ message: 'start()', props });
             const opts = props || {};
-            const { user } = props;
+            const { user, bikeSettings } = opts;
+            if (user && user.weight)
+                this.userSettings.weight = user.weight;
+            if (bikeSettings && bikeSettings.weight)
+                this.bikeSettings.weight = bikeSettings.weight;
             this.initData();
             let startState = {};
             return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -68,6 +68,10 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             console.log('~~~setPersonSupport:', this.getCyclingMode().getModeProperty('setPersonSupport'));
             console.log('~~~eppSupport:', this.getCyclingMode().getModeProperty('eppSupport'));
             const opts = props || {};
+            if (opts.user && opts.user.weight)
+                this.userSettings.weight = opts.user.weight;
+            if (opts.bikeSettings && opts.bikeSettings.weight)
+                this.bikeSettings.weight = opts.bikeSettings.weight;
             const user = opts.user || this.userSettings;
             const route = opts.route;
             var info = {};

package/lib/modes/simulator.d.ts

@@ -1,13 +1,14 @@
 import { EventLogger } from "gd-eventlog";
-import CyclingMode, { CyclingModeBase, CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
 import { Simulator } from "../simulator/Simulator";
+import PowerBasedCyclingModeBase from "./power-base";
 export declare type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
     starting?: boolean;
     tsStart?: number;
 };
-export default class SimulatorCyclingMode extends CyclingModeBase implements CyclingMode {
+export default class SimulatorCyclingMode extends PowerBasedCyclingModeBase {
     logger: EventLogger;
     data: IncyclistBikeData;
     prevRequest: UpdateRequest;

package/lib/modes/simulator.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 calculations_1 = __importDefault(require("../calculations"));
+const power_base_1 = __importDefault(require("./power-base"));
 const config = {
     name: "Simulator",
     description: "Simulates a ride with constant speed or power output",
@@ -14,9 +14,10 @@ const config = {
         { 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 },
+        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
     ]
 };
-class SimulatorCyclingMode extends CyclingMode_1.CyclingModeBase {
+class SimulatorCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.prevUpdateTS = 0;
@@ -62,41 +63,52 @@ class SimulatorCyclingMode extends CyclingMode_1.CyclingModeBase {
         const prevSpeed = prevData.speed;
         const prevRequest = this.prevRequest || {};
         const data = this.data || {};
+        const bikeType = (this.getSetting('bikeType') || 'Race').toLowerCase();
         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 power = (!mode || mode.toLowerCase() === 'power') ? 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 speed = mode.toLowerCase() === 'speed' ? Number(this.getSetting('speed')) : bikeData.speed || 0;
+            let m = this.getWeight();
             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' });
+            const t = this.getTimeSinceLastUpdate();
+            let distance = 0;
+            if (!mode || mode.toLowerCase() === 'power') {
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
             }
-            else if (mode === 'Speed') {
-                power = calculations_1.default.calculatePower(m, speed / 3.6, slope, { bikeType: 'race' });
+            else if (mode.toLowerCase() === 'speed') {
+                const res = this.calculatePowerAndDistance(speed, slope, m, t, { bikeType });
+                power = res.power;
+                distance = res.distance;
             }
             if (prevRequest.targetPower) {
                 power = prevRequest.targetPower;
-                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
             }
             if (prevRequest.maxPower && power > prevRequest.maxPower) {
                 power = prevRequest.maxPower;
-                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
             }
             else if (prevRequest.minPower && power < prevRequest.minPower) {
                 power = prevRequest.minPower;
-                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
             }
-            let v = speed / 3.6;
-            distanceInternal += (v * duration);
-            data.speed = parseFloat(speed.toFixed(1));
+            data.speed = speed;
             data.power = Math.round(power);
-            data.distanceInternal = distanceInternal;
+            data.distanceInternal = distanceInternal + distance;
             data.slope = slope;
             data.pedalRpm = rpm;
             if (data.time !== undefined)

package/lib/simulator/Simulator.d.ts

@@ -24,6 +24,12 @@ export declare class Simulator extends DeviceAdapter {
     data: IncyclistBikeData;
     isBot: boolean;
     ignoreHrm: boolean;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
     constructor(protocol?: DeviceProtocol, props?: SimulatorSettings);
     isBike(): boolean;
     isHrm(): boolean;
@@ -32,6 +38,7 @@ export declare class Simulator extends DeviceAdapter {
     getID(): string;
     getName(): string;
     getPort(): string;
+    getWeight(): number;
     setIgnoreHrm(ignore: any): void;
     getSupportedCyclingModes(): Array<any>;
     getDefaultCyclingMode(): CyclingMode;

package/lib/simulator/Simulator.js

@@ -37,6 +37,7 @@ const DeviceRegistry_1 = __importDefault(require("../DeviceRegistry"));
 const Device_1 = __importDefault(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
 const simulator_1 = __importDefault(require("../modes/simulator"));
+const Device_2 = require("../Device");
 const DEFAULT_SETTINGS = { name: 'Simulator', port: '', isBot: false };
 class Simulator extends Device_1.default {
     constructor(protocol, props = DEFAULT_SETTINGS) {
@@ -72,6 +73,17 @@ class Simulator extends Device_1.default {
     getID() { return Simulator.NAME; }
     getName() { return Simulator.NAME; }
     getPort() { return 'local'; }
+    getWeight() {
+        let userWeight = Device_2.DEFAULT_USER_WEIGHT;
+        let bikeWeight = Device_2.DEFAULT_BIKE_WEIGHT;
+        if (this.userSettings && this.userSettings.weight) {
+            userWeight = Number(this.userSettings.weight);
+        }
+        if (this.bikeSettings && this.bikeSettings.weight) {
+            bikeWeight = Number(this.bikeSettings.weight);
+        }
+        return bikeWeight + userWeight;
+    }
     setIgnoreHrm(ignore) {
         this.ignoreHrm = ignore;
     }
@@ -108,6 +120,10 @@ class Simulator extends Device_1.default {
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
+            if (props && props.user)
+                this.userSettings = props.user;
+            if (props && props.bikeSettings)
+                this.bikeSettings = props.bikeSettings;
             return new Promise((resolve) => {
                 if (!this.isBot)
                     this.logger.logEvent({ message: 'start', iv: this.iv });
@@ -117,6 +133,12 @@ class Simulator extends Device_1.default {
                 this.started = true;
                 this.time = Date.now();
                 this.startTS = this.time;
+                if (this.isBot) {
+                    this.startTS = props.activity ? Date.parse(props.activity.startTime) : this.startTS - 1500;
+                    const sm = this.getCyclingMode();
+                    sm.prevUpdateTS = this.startTS;
+                    this.update();
+                }
                 if (this.iv !== undefined) {
                     clearInterval(this.iv);
                     this.iv = undefined;
@@ -192,8 +214,9 @@ class Simulator extends Device_1.default {
     update() {
         const startDelay = this.getCyclingMode().getSetting('delay');
         const timeSinceStart = Date.now() - this.startTS;
-        if (startDelay && timeSinceStart < startDelay * 1000)
+        if (!this.isBot && startDelay && timeSinceStart < startDelay * 1000) {
             return;
+        }
         const prevDist = this.data.distanceInternal;
         this.data = this.getCyclingMode().updateData(this.data);
         let data = {
@@ -204,7 +227,7 @@ class Simulator extends Device_1.default {
             distance: this.data.distanceInternal - prevDist,
             heartrate: Math.round(this.data.power - 10 + Math.random() * 20),
             timestamp: Date.now(),
-            deviceTime: Math.round((Date.now() - this.startTS) / 1000),
+            deviceTime: (Date.now() - this.startTS) / 1000,
             deviceDistanceCounter: this.data.distanceInternal
         };
         this.paused = (this.data.speed === 0);

package/package.json

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