incyclist-devices 1.4.56 → 1.4.59

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/ble-interface.d.ts

@@ -61,6 +61,8 @@ export default class BleInterface extends BleInterfaceClass {
     disconnect(): Promise<boolean>;
     isConnected(): boolean;
     getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
+    getAllSupportedServices(): any[];
+    getAllSupportedDeviceTypes(): (typeof BleDeviceClass)[];
     getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
     getServicesFromDevice(device: BleDeviceClass): string[];
     waitForConnectFinished(timeout: any): Promise<unknown>;

package/lib/ble/ble-interface.js

@@ -18,8 +18,6 @@ const ble_1 = require("./ble");
 const ble_peripheral_1 = __importDefault(require("./ble-peripheral"));
 const CONNECT_TIMEOUT = 5000;
 const DEFAULT_SCAN_TIMEOUT = 20000;
-const BACKGROUND_SCAN_TIMEOUT = 30000;
-const DEFAULT_SERVICES = ['1818', '180d', '1826'];
 class BleInterface extends ble_1.BleInterfaceClass {
     constructor(props = {}) {
         super(props);
@@ -76,14 +74,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
         const timeout = props.timeout || 2000;
         const runBackgroundScan = () => {
             return;
-            this.scanState.isBackgroundScan = true;
-            this.scan({ timeout: BACKGROUND_SCAN_TIMEOUT, isBackgroundScan: true })
-                .then(() => {
-                this.scanState.isBackgroundScan = false;
-            })
-                .catch(() => {
-                this.scanState.isBackgroundScan = false;
-            });
         };
         return new Promise((resolve, reject) => {
             if (this.connectState.isConnected) {
@@ -223,6 +213,25 @@ class BleInterface extends ble_1.BleInterfaceClass {
         }
         return [];
     }
+    getAllSupportedServices() {
+        const supported = BleInterface.deviceClasses;
+        const res = [];
+        if (supported && supported.length > 0) {
+            supported.forEach(dc => {
+                if (dc && dc.services) {
+                    dc.services.forEach(s => {
+                        if (!res.includes(s))
+                            res.push(s);
+                    });
+                }
+            });
+        }
+        return res;
+    }
+    getAllSupportedDeviceTypes() {
+        const supported = BleInterface.deviceClasses;
+        return supported.map(dc => dc.Class);
+    }
     getServicesFromDeviceTypes(deviceTypes) {
         let services = [];
         try {
@@ -369,7 +378,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             this.scanState.isConnecting = true;
             const existing = this.devices.find(i => (!profile || i.device.getProfile() === profile) && (i.device.address === requested.address || i.device.id === requested.id || i.device.name === requested.name));
             if (existing) {
-                const connected = yield existing.device.connect();
+                yield existing.device.connect();
                 this.scanState.isConnecting = false;
                 return existing.device;
             }
@@ -461,7 +470,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     requested.profile;
             const { id, address, name } = requested || {};
             const scanForDevice = (requested !== null && requested !== undefined);
-            const services = (props.isBackgroundScan || !deviceTypes || deviceTypes.length === 0) ? DEFAULT_SERVICES : this.getServicesFromDeviceTypes(deviceTypes);
+            const services = (props.isBackgroundScan || !deviceTypes || deviceTypes.length === 0) ? this.getAllSupportedServices() : this.getServicesFromDeviceTypes(deviceTypes);
             const bleBinding = this.getBinding();
             if (!bleBinding)
                 return Promise.reject(new Error('no binding defined'));
@@ -485,7 +494,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             else {
                 opStr = 'scan';
-                this.logEvent({ message: 'scan start', services });
+                const supported = BleInterface.deviceClasses.map(dc => ({ id: dc.id, type: dc.type, services: dc.services }));
+                this.logEvent({ message: 'scan start', services, supported });
             }
             if (this.scanState.isScanning) {
                 try {
@@ -506,6 +516,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         const knownDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));
                         this.logEvent({ message: `${opStr}: check if already registered`, device: { name, address }, knownDevices });
                         const existing = this.devices.find(i => (i.device.address === address || i.device.name === name || i.device.id === id));
+                        if (existing)
+                            this.logEvent({ message: `${opStr}: device already registered`, device: { name, address } });
                     }
                 }
                 const onTimeout = () => {
@@ -527,14 +539,18 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 const onPeripheralFound = (peripheral, fromCache = false) => __awaiter(this, void 0, void 0, function* () {
                     if (fromCache)
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
+                    else {
+                        const { id, name, address } = peripheral;
+                        this.logEvent({ message: 'BLE scan: found device', peripheral: { id, name, address } });
+                    }
                     if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
                         return;
+                    if (peripheral.address === undefined || peripheral.address === '')
+                        peripheral.address = peripheral.id;
                     const isPeripheralProcessed = peripheralsProcessed.find(p => p === peripheral.address) !== undefined;
                     if (isPeripheralProcessed)
                         return;
                     peripheralsProcessed.push(peripheral.address);
-                    let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
-                    const str = fromCache ? 'added' : 'detected';
                     const characteristics = yield this.getCharacteristics(peripheral);
                     const DeviceClasses = this.getDeviceClasses(peripheral, { profile });
                     let cntFound = 0;

package/lib/ble/incyclist-protocol.js

@@ -39,7 +39,7 @@ const ble_interface_1 = __importDefault(require("./ble-interface"));
 const fm_1 = __importStar(require("./fm"));
 const hrm_1 = __importStar(require("./hrm"));
 const pwr_1 = __importStar(require("./pwr"));
-const supportedDeviceTypes = [hrm_1.default, pwr_1.default, fm_1.default];
+const wahoo_kickr_1 = __importDefault(require("./wahoo-kickr"));
 class BleProtocol extends DeviceProtocol_1.default {
     constructor(binding) {
         super();
@@ -79,9 +79,13 @@ class BleProtocol extends DeviceProtocol_1.default {
                 if (fromDevice)
                     device = bleDevice;
                 else {
-                    device = this.ble.findDeviceInCache(Object.assign(Object.assign({}, props()), { profile: 'Smart Trainer' }));
-                    if (!device)
-                        device = new fm_1.default(props());
+                    device = this.ble.findDeviceInCache(Object.assign(Object.assign({}, props()), { profile }));
+                    if (!device) {
+                        if (profile.toLocaleLowerCase() === 'wahoo smart trainer')
+                            device = new wahoo_kickr_1.default(props());
+                        else
+                            device = new fm_1.default(props());
+                    }
                 }
                 return new fm_1.FmAdapter(device, this);
             case 'cp':
@@ -109,6 +113,7 @@ class BleProtocol extends DeviceProtocol_1.default {
                     }
                 });
                 this.logger.logEvent({ message: 'scan started' });
+                const supportedDeviceTypes = this.ble.getAllSupportedDeviceTypes();
                 yield this.ble.scan({ deviceTypes: supportedDeviceTypes, timeout: 20000 });
                 if (props && props.onScanFinished) {
                     props.onScanFinished(props.id);

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.59",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",