incyclist-devices 2.3.29 → 2.3.32

package/lib/antv2/fe/adapter.js

@@ -61,7 +61,8 @@ class AntFEAdapter extends adapter_1.default {
                     this.promiseSendUpdate = fe.sendTrackResistance(update.slope);
                 }
                 if (update.targetPower !== undefined) {
-                    this.promiseSendUpdate = fe.sendTargetPower(update.targetPower);
+                    const tp = update.targetPower > 0 ? update.targetPower : 0;
+                    this.promiseSendUpdate = fe.sendTargetPower(tp);
                 }
                 yield this.promiseSendUpdate;
                 delete this.promiseSendUpdate;
@@ -112,6 +113,7 @@ class AntFEAdapter extends adapter_1.default {
             power: adapterData.power,
             speed: adapterData.speed,
             cadence: adapterData.pedalRpm,
+            gearStr: adapterData.gearStr,
             timestamp: Date.now()
         });
         if (adapterData.distanceInternal !== undefined) {

package/lib/base/adpater.d.ts

@@ -19,6 +19,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     protected user: User;
     protected data: IncyclistAdapterData;
     constructor(settings: DeviceSettings, props?: P);
+    supportsVirtualShifting(): boolean;
     getLogger(): EventLogger;
     isDebugEnabled(): boolean;
     logEvent(event: any): void;

package/lib/base/adpater.js

@@ -31,6 +31,9 @@ class IncyclistDevice extends events_1.default {
         this.data = {};
         this.cyclingMode = this.getDefaultCyclingMode();
     }
+    supportsVirtualShifting() {
+        return false;
+    }
     getLogger() { return this.logger; }
     isDebugEnabled() {
         const w = global.window;

package/lib/ble/base/interface.d.ts

@@ -105,6 +105,7 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected getExpectedServices(): string[];
     logEvent(event: any): void;
     logError(err: Error, fn: string, args?: any): void;
+    protected reset(): Promise<void>;
 }
 export declare class BleInterfaceFactory extends InterfaceFactory {
     protected iface: BleInterface;

package/lib/ble/base/interface.js

@@ -675,6 +675,24 @@ class BleInterface extends events_1.default {
         const logInfo = args || {};
         this.logEvent(Object.assign(Object.assign({ message: 'Error', fn }, logInfo), { error: err.message, stack: err.stack }));
     }
+    reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connectTask) {
+                yield this.connectTask.stop();
+            }
+            if (this.disconnectTask) {
+                yield this.disconnectTask.stop();
+            }
+            if (this.scanTask) {
+                yield this.scanTask.stop();
+            }
+            if (this.discoverTask) {
+                yield this.discoverTask.stop();
+            }
+            this.removeAllListeners();
+            this.internalEvents.removeAllListeners();
+        });
+    }
 }
 exports.BleInterface = BleInterface;
 BleInterface.INTERFACE_NAME = 'ble';

package/lib/ble/fm/adapter.js

@@ -106,7 +106,8 @@ class BleFmAdapter extends adapter_1.default {
             cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
             distance,
             heartrate: bikeData.heartrate,
-            timestamp: Date.now()
+            timestamp: Date.now(),
+            gearStr: bikeData.gearStr
         };
         return data;
     }
@@ -245,7 +246,8 @@ class BleFmAdapter extends adapter_1.default {
                         yield device.setSlope(update.slope);
                     }
                     if (update.targetPower !== undefined) {
-                        yield device.setTargetPower(update.targetPower);
+                        const tp = update.targetPower > 0 ? update.targetPower : 0;
+                        yield device.setTargetPower(tp);
                     }
                 }
             }

package/lib/ble/zwift/play/sensor.d.ts

@@ -1,4 +1,4 @@
-import { LegacyProfile } from "incyclist-devices/lib/antv2/types";
+import { LegacyProfile } from "../../../antv2/types";
 import { TBleSensor } from "../../base/sensor";
 import { BleProtocol } from "../../types";
 import { EventEmitter } from "events";

package/lib/modes/antble-smarttrainer.d.ts

@@ -1,6 +1,7 @@
-import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+import ICyclingMode, { CyclingModeConfig, CyclingModeProperyType, UpdateRequest } from "./types";
 import PowerBasedCyclingModeBase from "./power-base";
-import { IAdapter } from "../types";
+import { IAdapter, IncyclistBikeData } from "../types";
+type VirtshiftMode = 'Disabled' | 'SlopeDelta' | 'Adapter' | 'Simulated';
 export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
     protected static config: {
         name: string;
@@ -26,10 +27,29 @@ export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase i
             options?: undefined;
         })[];
     };
+    protected gearDelta: number;
+    protected gear: number;
+    protected tsStart: number;
+    protected simPower: number;
+    protected simSlope: number;
+    protected readonly gearRatios: number[];
     constructor(adapter: IAdapter, props?: any);
     getBikeInitRequest(): UpdateRequest;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
-    protected checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    getConfig(): CyclingModeConfig;
+    protected checkSlopeNoShiftig(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected checkSlopeWithAdapterShifting(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected getSlopeDelta(): number;
+    protected checkSlopeWithSlopeDelta(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected checkSlopeWithSimulatedShifting(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    checkGearChange(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected verifySimPower(): void;
     protected checkEmptyRequest(newRequest: UpdateRequest): void;
+    protected getVirtualShiftMode(): VirtshiftMode;
+    updateData(bikeData: IncyclistBikeData, log?: boolean): IncyclistBikeData;
     sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+    protected setInitialGear(data: IncyclistBikeData): void;
+    protected getGearString(): string;
 }
+export {};

package/lib/modes/antble-smarttrainer.js

@@ -1,13 +1,53 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("./types");
 const power_base_1 = __importDefault(require("./power-base"));
+const calculations_1 = __importStar(require("../utils/calculations"));
+const MIN_POWER = 25;
 class SmartTrainerCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
+        this.gearDelta = 0;
+        this.gearRatios = [
+            0.75, 0.87, 0.99, 1.11, 1.23, 1.38, 1.53, 1.68, 1.86, 2.04, 2.22, 2.40,
+            2.61, 2.82, 3.03, 3.24, 3.49, 3.74, 3.99, 4.24, 4.54, 4.84, 5.14, 5.49
+        ];
         this.initLogger('SmartTrainerMode');
     }
     getBikeInitRequest() {
@@ -23,7 +63,20 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             return this.prevRequest;
         }
     }
-    checkSlope(request, newRequest = {}) {
+    getConfig() {
+        const config = super.getConfig();
+        let virtshift = config.properties.find(p => p.key === 'virtshift');
+        if (!virtshift) {
+            virtshift = { key: 'virtshift', name: 'Virtual Shifting', description: 'Enable virtual shifting', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Disabled', 'Enabled', 'Mixed'], default: 'Disabled' };
+            config.properties.push(virtshift);
+        }
+        if (this.adapter.supportsVirtualShifting()) {
+            virtshift.default = 'Enabled';
+            virtshift.options = ['Disabled', 'Enabled'];
+        }
+        return config;
+    }
+    checkSlopeNoShiftig(request, newRequest = {}) {
         if (request.slope !== undefined) {
             const targetSlope = newRequest.slope = parseFloat(request.slope.toFixed(1));
             this.data.slope = newRequest.slope;
@@ -36,6 +89,118 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             }
         }
     }
+    checkSlopeWithAdapterShifting(request, newRequest = {}) {
+        return this.checkSlopeNoShiftig(request, newRequest);
+    }
+    getSlopeDelta() {
+        return this.gearDelta * 0.5;
+    }
+    checkSlopeWithSlopeDelta(request, newRequest = {}) {
+        if (request.slope !== undefined) {
+            const targetSlope = newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
+            const requestedSlope = targetSlope + this.getSlopeDelta();
+            try {
+                const slopeAdj = requestedSlope >= 0 ? this.getSetting('slopeAdj') : this.getSetting('slopeAdjDown');
+                newRequest.slope = slopeAdj !== undefined ? requestedSlope * slopeAdj / 100 : requestedSlope;
+            }
+            catch (_a) {
+                console.error('# Error calculating requested slope');
+            }
+        }
+    }
+    checkSlopeWithSimulatedShifting(request, newRequest = {}) {
+        var _a, _b, _c, _d;
+        if (this.gear === undefined) {
+            this.checkSlopeNoShiftig(request, newRequest);
+            return;
+        }
+        if (request.slope !== undefined) {
+            const prev = (_a = this.data.slope) !== null && _a !== void 0 ? _a : 0;
+            this.data.slope = parseFloat(request.slope.toFixed(1));
+            delete request.slope;
+            delete newRequest.slope;
+            this.simSlope = this.data.slope;
+            try {
+                const slopeAdj = this.simSlope >= 0 ? this.getSetting('slopeAdj') : this.getSetting('slopeAdjDown');
+                if (slopeAdj !== undefined)
+                    this.simSlope = this.simSlope * slopeAdj / 100;
+            }
+            catch (_e) {
+            }
+            if (this.data.slope !== prev) {
+                const virtualSpeed = (0, calculations_1.calculateVirtualSpeed)(this.data.pedalRpm, this.gearRatios[this.gear - 1]);
+                const m = (_c = (_b = this.adapter) === null || _b === void 0 ? void 0 : _b.getWeight()) !== null && _c !== void 0 ? _c : 85;
+                this.simPower = calculations_1.default.calculatePower(m, virtualSpeed, (_d = this.simSlope) !== null && _d !== void 0 ? _d : 0);
+                this.verifySimPower();
+            }
+        }
+        newRequest.targetPower = this.simPower;
+    }
+    checkSlope(request, newRequest = {}) {
+        const virtshiftMode = this.getVirtualShiftMode();
+        switch (virtshiftMode) {
+            case 'SlopeDelta':
+                this.checkSlopeWithSlopeDelta(request, newRequest);
+                break;
+            case 'Simulated':
+                this.checkSlopeWithSimulatedShifting(request, newRequest);
+                break;
+            case 'Adapter':
+                this.checkSlopeWithAdapterShifting(request, newRequest);
+                break;
+            case 'Disabled':
+            default:
+                this.checkSlopeNoShiftig(request, newRequest);
+                break;
+        }
+    }
+    checkGearChange(request, newRequest = {}) {
+        var _a, _b, _c, _d;
+        const virtshiftMode = this.getVirtualShiftMode();
+        switch (virtshiftMode) {
+            case 'SlopeDelta':
+                if (request.gearDelta !== undefined) {
+                    this.gearDelta += request.gearDelta;
+                    request.slope = this.data.slope;
+                    delete request.gearDelta;
+                }
+                break;
+            case 'Simulated':
+                if (request.gearDelta !== undefined) {
+                    if (this.gear === undefined) {
+                        this.gear = 10 + request.gearDelta;
+                    }
+                    else {
+                        this.gear += request.gearDelta;
+                    }
+                    if (this.gear < 1) {
+                        this.gear = 1;
+                    }
+                    if (this.gear > this.gearRatios.length) {
+                        this.gear = this.gearRatios.length;
+                    }
+                    delete request.gearDelta;
+                    const virtualSpeed = (0, calculations_1.calculateVirtualSpeed)(this.data.pedalRpm, this.gearRatios[this.gear - 1]);
+                    const m = (_b = (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.getWeight()) !== null && _b !== void 0 ? _b : 85;
+                    this.simPower = calculations_1.default.calculatePower(m, virtualSpeed, (_d = (_c = this.simSlope) !== null && _c !== void 0 ? _c : this.data.slope) !== null && _d !== void 0 ? _d : 0);
+                    this.verifySimPower();
+                }
+                break;
+            case 'Adapter':
+            case 'Disabled':
+            default:
+                break;
+        }
+    }
+    verifySimPower() {
+        if (this.simPower < 0) {
+            this.simPower = 0;
+        }
+        if (this.data.pedalRpm > 0 && this.simPower < MIN_POWER) {
+            this.simPower = MIN_POWER;
+        }
+    }
     checkEmptyRequest(newRequest) {
         if (Object.keys(newRequest).length === 0) {
             if (this.prevRequest) {
@@ -44,14 +209,57 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             }
         }
     }
+    getVirtualShiftMode() {
+        const virtshiftMode = this.getSetting('virtshift');
+        if (virtshiftMode === 'Disabled') {
+            return 'Disabled';
+        }
+        if (this.adapter.supportsVirtualShifting()) {
+            if (virtshiftMode === 'Enabled') {
+                return 'Adapter';
+            }
+        }
+        else {
+            return virtshiftMode === 'Mixed' ? 'SlopeDelta' : 'Simulated';
+        }
+    }
+    updateData(bikeData, log) {
+        var _a, _b, _c, _d;
+        const prev = Object.assign({}, this.data);
+        const data = super.updateData(bikeData, log);
+        const mode = this.getVirtualShiftMode();
+        let virtualSpeed;
+        data.gearStr = this.getGearString();
+        if (mode !== 'Simulated') {
+            return data;
+        }
+        if (data.power > 0 && !this.tsStart) {
+            this.tsStart = Date.now();
+        }
+        if (this.gear === undefined && this.tsStart && data.power > 0 && (Date.now() - this.tsStart > 3000)) {
+            this.setInitialGear(data);
+            data.gearStr = this.getGearString();
+        }
+        else if (this.gear !== undefined) {
+            if (prev.power !== data.power || prev.pedalRpm !== data.pedalRpm) {
+                virtualSpeed = (0, calculations_1.calculateVirtualSpeed)(data.pedalRpm, this.gearRatios[this.gear - 1]);
+                const m = (_b = (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.getWeight()) !== null && _b !== void 0 ? _b : 85;
+                this.simPower = calculations_1.default.calculatePower(m, virtualSpeed, (_d = (_c = this.simSlope) !== null && _c !== void 0 ? _c : data.slope) !== null && _d !== void 0 ? _d : 0);
+                this.verifySimPower();
+            }
+        }
+        return data;
+    }
     sendBikeUpdate(incoming) {
         this.logger.logEvent({ message: "processing update request", request: incoming, prev: this.prevRequest, data: this.getData() });
         let newRequest = {};
         const request = Object.assign({}, incoming);
         try {
             const req = this.checkForResetOrEmpty(request);
-            if (req)
+            if (req) {
                 return req;
+            }
+            this.checkGearChange(request, newRequest);
             this.checkSlope(request, newRequest);
             this.checkEmptyRequest(newRequest);
             this.prevRequest = JSON.parse(JSON.stringify(newRequest));
@@ -62,6 +270,25 @@ class SmartTrainerCyclingMode extends power_base_1.default {
         }
         return newRequest;
     }
+    setInitialGear(data) {
+        var _a, _b;
+        const m = (_b = (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.getWeight()) !== null && _b !== void 0 ? _b : 85;
+        const virtualSpeeds = this.gearRatios.map(r => (0, calculations_1.calculateVirtualSpeed)(data.pedalRpm, r));
+        const requiredPowers = virtualSpeeds.map(v => { var _a; return calculations_1.default.calculatePower(m, v, (_a = data.slope) !== null && _a !== void 0 ? _a : 0); });
+        const deltas = requiredPowers.map((p, i) => ({ gear: i + 1, delta: Math.abs(p - data.power) }));
+        deltas.sort((a, b) => a.delta - b.delta);
+        this.gear = deltas[0].gear;
+    }
+    getGearString() {
+        const mode = this.getVirtualShiftMode();
+        if (mode === "Disabled")
+            return undefined;
+        if (mode === 'Simulated' && (this.gear === undefined || this.gear === null))
+            return '';
+        if (mode === "SlopeDelta")
+            return this.gearDelta > 0 ? `+${this.gearDelta}` : `${this.gearDelta}`;
+        return this.gear.toString();
+    }
 }
 SmartTrainerCyclingMode.config = {
     name: "Smart Trainer",
@@ -70,7 +297,7 @@ SmartTrainerCyclingMode.config = {
     properties: [
         { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
         { key: 'slopeAdj', name: 'Bike Reality Factor', description: 'Percentage of slope that should be sent to the SmartTrainer. Should be used in case the slopes are feeling too hard', type: types_1.CyclingModeProperyType.Integer, default: 100, min: 0, max: 200 },
-        { key: 'slopeAdjDown', name: 'Bike Reality Factor downhill', description: 'Percentage of slope that should be sent during downhill sections. Should be used to avoid spinning out', type: types_1.CyclingModeProperyType.Integer, default: 50, min: 0, max: 100 }
+        { key: 'slopeAdjDown', name: 'Bike Reality Factor downhill', description: 'Percentage of slope that should be sent during downhill sections. Should be used to avoid spinning out', type: types_1.CyclingModeProperyType.Integer, default: 50, min: 0, max: 100 },
     ]
 };
 exports.default = SmartTrainerCyclingMode;

package/lib/modes/daum-classic-standard.d.ts

@@ -1,4 +1,4 @@
-import ICyclingMode, { Settings, UpdateRequest } from "./types";
+import ICyclingMode, { CyclingModeConfig, Settings, UpdateRequest } from "./types";
 import { IncyclistBikeData } from "../types";
 import SmartTrainerCyclingMode from "./antble-smarttrainer";
 import { IncyclistDeviceAdapter } from "../base/adpater";
@@ -11,6 +11,7 @@ export default class DaumClassicCyclingMode extends SmartTrainerCyclingMode impl
     event: DaumClassicEvent;
     constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
     getBikeInitRequest(): UpdateRequest;
+    getConfig(): CyclingModeConfig;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
     protected updateSpeedAndDistance(_power: number, _slope: any, _bikeType: any, data: IncyclistBikeData, prevData: any): number;
 }

package/lib/modes/daum-classic-standard.js

@@ -25,6 +25,12 @@ class DaumClassicCyclingMode extends antble_smarttrainer_1.default {
     getBikeInitRequest() {
         return { slope: 0 };
     }
+    getConfig() {
+        if (this.localConfig)
+            return this.localConfig;
+        let cm = this.constructor;
+        return cm.config;
+    }
     checkForResetOrEmpty(request) {
         if (!request || request.reset) {
             this.prevRequest = {};

package/lib/modes/types.d.ts

@@ -5,6 +5,7 @@ export type UpdateRequest = {
     maxPower?: number;
     targetPower?: number;
     targetPowerDelta?: number;
+    gearDelta?: number;
     reset?: boolean;
     refresh?: boolean;
     init?: boolean;

package/lib/serial/daum/DaumAdapter.d.ts

@@ -61,5 +61,6 @@ export default class DaumAdapter<S extends SerialDeviceSettings, P extends Devic
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<UpdateRequest>;
+    protected reset(): void;
     getDeviceInfo(): Promise<any>;
 }

package/lib/serial/daum/DaumAdapter.js

@@ -529,6 +529,20 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
             fn();
         });
     }
+    reset() {
+        if (this.iv) {
+            const { sync, update, emitter } = this.iv;
+            if (sync)
+                clearInterval(sync);
+            if (update)
+                clearInterval(update);
+            if (emitter)
+                emitter.removeAllListeners();
+        }
+        if (this.internalEmitter) {
+            this.internalEmitter.removeAllListeners();
+        }
+    }
     getDeviceInfo() {
         return __awaiter(this, void 0, void 0, function* () {
             throw new Error('Method not implemented.');

package/lib/types/adapter.d.ts

@@ -34,6 +34,7 @@ export interface IAdapter extends EventEmitter, IBike, ISensor {
     getName(): string;
     getID(): string;
     getUniqueName(): string;
+    supportsVirtualShifting(): boolean;
     getDisplayName(): string;
     getSettings(): DeviceSettings;
     isSame(adapter: IAdapter): boolean;

package/lib/types/data.d.ts

@@ -6,6 +6,7 @@ export type IncyclistAdapterData = {
     heartrate?: number;
     distance?: number;
     timestamp?: number;
+    gearStr?: string;
     deviceTime?: number;
     deviceDistanceCounter?: number;
     internalDistanceCounter?: number;
@@ -19,5 +20,6 @@ export type IncyclistBikeData = {
     distanceInternal?: number;
     time?: number;
     gear?: number;
+    gearStr?: string;
     slope?: number;
 };

package/lib/utils/calculations.d.ts

@@ -10,4 +10,5 @@ export default class C {
         wheelCirc?: number;
     }): number;
 }
+export declare const calculateVirtualSpeed: (rpm: number, gearRatio: number, wheelCirc?: number) => number;
 export declare function solveCubic(p: any, q: any): any[];

package/lib/utils/calculations.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IllegalArgumentException = void 0;
+exports.calculateVirtualSpeed = exports.IllegalArgumentException = void 0;
 exports.solveCubic = solveCubic;
 const g = 9.80665;
 const rho = 1.2041;
@@ -103,6 +103,18 @@ class C {
     }
 }
 exports.default = C;
+const calculateVirtualSpeed = (rpm, gearRatio, wheelCirc = 2125) => {
+    if (rpm === undefined || rpm === null || rpm < 0)
+        throw new IllegalArgumentException("rpm must be a positive number");
+    if (!gearRatio || gearRatio < 0)
+        throw new IllegalArgumentException("gearRatio must be a positive number");
+    if (!wheelCirc || wheelCirc < 0)
+        throw new IllegalArgumentException("wheelCirc must be a positive number");
+    let distRotation = wheelCirc * gearRatio / 1000;
+    let speed = rpm * distRotation * 60 / 1000;
+    return speed / 3.6;
+};
+exports.calculateVirtualSpeed = calculateVirtualSpeed;
 function acosh(x) {
     return Math.log(x + Math.sqrt(x * x - 1.0));
 }

package/lib/utils/utils.js

@@ -26,39 +26,46 @@ const resolveNextTick = () => {
 };
 exports.resolveNextTick = resolveNextTick;
 function runWithRetries(fn, maxRetries, timeBetween) {
-    return new Promise((resolve, reject) => {
-        let retries = 0;
-        let tLastFailure = undefined;
-        let busy = false;
-        let iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            const tNow = Date.now();
-            if (busy) {
-                return;
-            }
-            if (tLastFailure === undefined || tNow - tLastFailure > timeBetween) {
-                try {
-                    busy = true;
-                    const data = yield fn();
-                    clearInterval(iv);
-                    iv = undefined;
-                    busy = false;
-                    return resolve(data);
+    return __awaiter(this, void 0, void 0, function* () {
+        let iv;
+        const res = yield new Promise((resolve, reject) => {
+            let retries = 0;
+            let tLastFailure = undefined;
+            let busy = false;
+            iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                const tNow = Date.now();
+                if (busy) {
+                    return;
                 }
-                catch (err) {
-                    tLastFailure = Date.now();
-                    retries++;
-                    if (retries >= maxRetries) {
+                if (tLastFailure === undefined || tNow - tLastFailure > timeBetween) {
+                    try {
+                        busy = true;
+                        const data = yield fn();
                         clearInterval(iv);
                         iv = undefined;
                         busy = false;
-                        return reject(err);
+                        return resolve(data);
                     }
-                    else {
-                        busy = false;
+                    catch (err) {
+                        tLastFailure = Date.now();
+                        retries++;
+                        if (retries >= maxRetries) {
+                            clearInterval(iv);
+                            iv = undefined;
+                            busy = false;
+                            return reject(err);
+                        }
+                        else {
+                            busy = false;
+                        }
                     }
                 }
-            }
-        }), 50);
+            }), 50);
+        });
+        if (iv) {
+            clearInterval(iv);
+        }
+        return res;
     });
 }
 function floatVal(d) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.3.29",
+  "version": "2.3.32",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",
@@ -16,15 +16,16 @@
   "devDependencies": {
     "@serialport/binding-mock": "^10.2.2",
     "@serialport/bindings-cpp": "^10.8.0",
-    "@stoprocent/noble": "^1.15.2",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.15.18",
+    "@stoprocent/noble": "^2.3.5",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.43.0",
+    "@typescript-eslint/parser": "^8.43.0",
     "bonjour-service": "^1.3.0",
-    "eslint": "^8.57.1",
-    "eslint-config-react-app": "^7.0.1",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.3.4",
-    "typescript": "^5.8.3"
+    "eslint": "^9.35.0",
+    "jest": "^30.1.3",
+    "ts-jest": "^29.4.1",
+    "typescript": "^5.9.2"
   },
   "scripts": {
     "lint": "eslint . --ext .ts",
@@ -43,7 +44,18 @@
     "lib": "./src"
   },
   "eslintConfig": {
-    "extends": "react-app",
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+      "ecmaVersion": "latest",
+      "sourceType": "module"
+    },
+    "plugins": [
+      "@typescript-eslint"
+    ],
     "rules": {
       "jsx-a11y/anchor-is-valid": [
         "off"