incyclist-devices 1.4.20 → 1.4.23

package/lib/Device.d.ts

@@ -12,6 +12,7 @@ export declare type DeviceData = {
     timestamp?: number;
     deviceTime?: number;
     deviceDistanceCounter?: number;
+    internalDistanceCounter?: number;
 };
 export declare type OnDeviceDataCallback = (data: DeviceData) => void;
 export declare type OnDeviceStartCallback = (completed: number, total: number) => void;

package/lib/ant/antfe/AntFEAdapter.d.ts

@@ -16,6 +16,7 @@ export default class AntFEAdapter extends AntAdapter {
     getName(): string;
     getDisplayName(): string;
     onAttached(): void;
+    getLogData(data: any, excludeList: any): any;
     onDeviceData(deviceData: any): void;
     onDeviceEvent(data: any): void;
     updateData(data: any, deviceData: any): any;

package/lib/ant/antfe/AntFEAdapter.js

@@ -58,6 +58,13 @@ class AntFEAdapter extends AntAdapter_1.default {
         this.logger.logEvent({ message: 'Device connected' });
         this.connected = true;
     }
+    getLogData(data, excludeList) {
+        const logData = JSON.parse(JSON.stringify(data));
+        excludeList.forEach((key) => {
+            delete logData[key];
+        });
+        return logData;
+    }
     onDeviceData(deviceData) {
         if (!this.started || this.isStopped())
             return;
@@ -65,7 +72,8 @@ class AntFEAdapter extends AntAdapter_1.default {
         try {
             if (this.onDataFn && !(this.ignoreHrm && this.ignoreBike && this.ignorePower) && !this.paused) {
                 if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
+                    const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
+                    this.logger.logEvent({ message: 'onDeviceData', data: logData });
                     this.data = this.updateData(this.data, deviceData);
                     const data = this.transformData(this.data);
                     this.onDataFn(data);

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

@@ -37,11 +37,12 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     private iv;
     private requests;
     private data;
-    private idata;
+    private internalData;
     private kettlerData;
     private updateBusy;
     private requestBusy;
     private comms;
+    private prevDistance;
     constructor(protocol: DeviceProtocol, settings: DeviceSettings);
     isBike(): boolean;
     isPower(): boolean;
@@ -76,7 +77,7 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     parseExtendedStatus(data: string): KettlerExtendedBikeData;
     parseStatus(data: string): KettlerBikeData;
     check(): Promise<boolean>;
-    start(props?: any): Promise<any>;
+    start(props?: any): Promise<IncyclistBikeData>;
     startUpdatePull(): void;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
@@ -91,7 +92,7 @@ export default class KettlerRacerAdapter extends DeviceAdapterBase implements De
     sendData(): void;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
-    waitForOpened(): Promise<boolean>;
+    waitForOpened(retries?: boolean): Promise<boolean>;
     waitForClosed(): Promise<boolean>;
     getSupportedCyclingModes(): any[];
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;

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

@@ -220,7 +220,7 @@ class KettlerRacerAdapter extends Device_1.default {
             }
             const distance = parseInt(states[3]);
             if (!isNaN(distance)) {
-                result.distance = distance;
+                result.distance = distance * 100;
             }
             const requestedPower = parseInt(states[4]);
             if (!isNaN(requestedPower)) {
@@ -228,7 +228,7 @@ class KettlerRacerAdapter extends Device_1.default {
             }
             const energy = parseInt(states[5]);
             if (!isNaN(energy)) {
-                result.requestedPower = energy;
+                result.energy = energy;
             }
             const timeStr = states[6];
             const time = timeStr.split(':');
@@ -284,46 +284,49 @@ class KettlerRacerAdapter extends Device_1.default {
         });
     }
     start(props) {
-        this.logger.logEvent({ message: 'start()' });
-        var info = {};
-        return utils_1.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!info.checkDone) {
-                    info.checkDone = yield this.check();
-                }
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start()' });
+            var info = {};
+            yield this.waitForOpened(true);
+            return utils_1.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
                 try {
-                    if (!info.started) {
-                        info.started = yield this.startTraining();
+                    if (!info.checkDone) {
+                        info.checkDone = yield this.check();
                     }
+                    try {
+                        if (!info.started) {
+                            info.started = yield this.startTraining();
+                        }
+                    }
+                    catch (e) {
+                        this.logger.logEvent({ message: 'Error', error: e.message });
+                    }
+                    try {
+                        yield this.setPower(100);
+                    }
+                    catch (e) {
+                        this.logger.logEvent({ message: 'Error', error: e.message });
+                    }
+                    if (!info.data) {
+                        yield this.update();
+                        info.data = this.data;
+                    }
+                    return info.data;
                 }
-                catch (e) {
-                    this.logger.logEvent({ message: 'Error', error: e.message });
-                }
-                try {
-                    yield this.setPower(100);
-                }
-                catch (e) {
-                    this.logger.logEvent({ message: 'Error', error: e.message });
-                }
-                if (!info.data) {
-                    yield this.update();
-                    info.data = this.data;
-                }
-                return info.data;
-            }
-            catch (err) {
-                try {
-                    yield this.reset();
-                }
-                catch (e) {
-                    this.logger.logEvent({ message: 'Error', error: e.message });
+                catch (err) {
+                    try {
+                        yield this.reset();
+                    }
+                    catch (e) {
+                        this.logger.logEvent({ message: 'Error', error: e.message });
+                    }
+                    throw (new Error(`could not start device, reason:${err.message}`));
                 }
-                throw (new Error(`could not start device, reason:${err.message}`));
-            }
-        }), 5, 1000)
-            .then(data => {
-            this.startUpdatePull();
-            return data;
+            }), 5, 1000)
+                .then((data) => {
+                this.startUpdatePull();
+                return data;
+            });
         });
     }
     startUpdatePull() {
@@ -394,6 +397,10 @@ class KettlerRacerAdapter extends Device_1.default {
     }
     transformData(internalData, bikeData) {
         let data = {};
+        const prevDistance = this.prevDistance || 0;
+        let distance = internalData.distanceInternal - prevDistance;
+        if (distance < 0)
+            distance = internalData.distanceInternal < 100 ? internalData.distanceInternal : 0;
         data.heartrate = internalData.heartrate;
         data.timestamp = Date.now();
         data.deviceTime = bikeData.time;
@@ -401,8 +408,10 @@ class KettlerRacerAdapter extends Device_1.default {
             data.speed = internalData.speed;
             data.power = internalData.power;
             data.cadence = internalData.pedalRpm;
-            data.distance = internalData.distanceInternal;
+            data.distance = distance;
             data.deviceDistanceCounter = bikeData.distance;
+            data.internalDistanceCounter = internalData.distanceInternal;
+            this.prevDistance = internalData.distanceInternal;
         }
         if (this.ignoreHrm)
             delete this.data.heartrate;
@@ -415,13 +424,14 @@ class KettlerRacerAdapter extends Device_1.default {
     update() {
         return __awaiter(this, void 0, void 0, function* () {
             this.updateBusy = true;
-            this.getStatus()
+            return this.getStatus()
                 .then((bikeData) => {
                 if (bikeData) {
                     try {
                         this.kettlerData = bikeData;
                         let data = this.mapData(bikeData);
                         data = this.getCyclingMode().updateData(data);
+                        this.internalData = data;
                         this.data = this.transformData(data, bikeData);
                     }
                     catch (err) {
@@ -533,34 +543,38 @@ class KettlerRacerAdapter extends Device_1.default {
             resolve(bikeRequest);
         }));
     }
-    waitForOpened() {
-        return utils_1.runWithRetries(() => {
-            return new Promise((resolve, reject) => {
-                try {
-                    if (this.comms.isConnected()) {
-                        resolve(true);
-                        return;
-                    }
-                    const cleanup = () => {
-                        this.comms.removeAllListeners();
-                    };
-                    const onOpen = () => {
-                        resolve(true);
-                        cleanup();
-                    };
-                    const onError = (err) => { reject(err); cleanup(); };
-                    const onClose = () => { cleanup(); };
-                    this.comms.on('opened', onOpen);
-                    this.comms.on('closed', onClose);
-                    this.comms.on('error', onError);
-                    this.logger.logEvent({ message: 'opening', port: this.getPort() });
-                    this.comms.open();
-                }
-                catch (err) {
-                    this.logger.logEvent({ message: 'error', fn: 'waitForOpened()', error: err.message || err });
-                    reject(err);
+    waitForOpened(retries = false) {
+        const run = (resolve, reject) => {
+            try {
+                if (this.comms.isConnected()) {
+                    resolve(true);
+                    return;
                 }
-            });
+                const cleanup = () => {
+                    this.comms.removeAllListeners();
+                };
+                const onOpen = () => {
+                    resolve(true);
+                    cleanup();
+                };
+                const onError = (err) => { reject(err); cleanup(); };
+                const onClose = () => { cleanup(); };
+                this.comms.on('opened', onOpen);
+                this.comms.on('closed', onClose);
+                this.comms.on('error', onError);
+                this.logger.logEvent({ message: 'opening', port: this.getPort() });
+                this.comms.open();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'error', fn: 'waitForOpened()', error: err.message || err });
+                reject(err);
+            }
+        };
+        if (!retries) {
+            return new Promise((resolve, reject) => run(resolve, reject));
+        }
+        return utils_1.runWithRetries(() => {
+            return new Promise((resolve, reject) => run(resolve, reject));
         }, 3, 1000);
     }
     waitForClosed() {

package/lib/simulator/Simulator.d.ts

@@ -1,6 +1,11 @@
-import DeviceProtocolBase, { DeviceSettings } from '../DeviceProtocol';
+import DeviceProtocolBase, { DeviceSettings, DeviceProtocol } from '../DeviceProtocol';
 import DeviceAdapter from '../Device';
 import { EventLogger } from 'gd-eventlog';
+import CyclingMode, { IncyclistBikeData } from '../CyclingMode';
+interface SimulatorSettings extends DeviceSettings {
+    isBot?: boolean;
+    settings?: any;
+}
 export declare class Simulator extends DeviceAdapter {
     static NAME: string;
     logger: EventLogger;
@@ -14,13 +19,23 @@ export declare class Simulator extends DeviceAdapter {
     slope: number;
     limit: any;
     startProps?: any;
-    constructor(protocol?: any);
+    cyclingMode: CyclingMode;
+    startTS: number;
+    data: IncyclistBikeData;
+    isBot: boolean;
+    ignoreHrm: boolean;
+    constructor(protocol?: DeviceProtocol, props?: SimulatorSettings);
     isBike(): boolean;
     isHrm(): boolean;
     isPower(): boolean;
     getID(): string;
     getName(): string;
     getPort(): string;
+    setIgnoreHrm(ignore: any): void;
+    getSupportedCyclingModes(): Array<any>;
+    getDefaultCyclingMode(): CyclingMode;
+    getCyclingMode(): CyclingMode;
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
     start(props?: any): Promise<unknown>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
@@ -30,12 +45,12 @@ export declare class Simulator extends DeviceAdapter {
     slower(): void;
     update(): void;
     calculateDistance(speedKps: any, timeS: any): number;
-    sendUpdate(request: any): any;
+    sendUpdate(request: any): import("../CyclingMode").UpdateRequest;
 }
 export default class SimulatorProtocol extends DeviceProtocolBase {
     static NAME: string;
     constructor();
-    add(settings: DeviceSettings): void;
+    add(settings: SimulatorSettings): any;
     getName(): string;
     getInterfaces(): string[];
     isBike(): boolean;
@@ -43,3 +58,4 @@ export default class SimulatorProtocol extends DeviceProtocolBase {
     isPower(): boolean;
     getDevices(): import("../DeviceProtocol").Device[];
 }
+export {};

package/lib/simulator/Simulator.js

@@ -1,4 +1,13 @@
 "use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -14,9 +23,10 @@ const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
 const DeviceRegistry_1 = __importDefault(require("../DeviceRegistry"));
 const Device_1 = __importDefault(require("../Device"));
 const gd_eventlog_1 = require("gd-eventlog");
-const calculations_1 = __importDefault(require("../calculations"));
+const simulator_mode_1 = __importDefault(require("./simulator-mode"));
+const DEFAULT_SETTINGS = { name: 'Simulator', port: '', isBot: false };
 class Simulator extends Device_1.default {
-    constructor(protocol) {
+    constructor(protocol, props = DEFAULT_SETTINGS) {
         const proto = protocol || DeviceRegistry_1.default.findByName('Simulator');
         super(proto);
         this.logger = new gd_eventlog_1.EventLogger(Simulator.NAME);
@@ -27,8 +37,16 @@ class Simulator extends Device_1.default {
         this.time = undefined;
         this.iv = undefined;
         this.started = false;
+        this.paused = false;
         this.slope = 0;
         this.limit = {};
+        this.startTS = undefined;
+        this.data = { isPedalling: false, power: 0, pedalRpm: 0, speed: 0, heartrate: 0, distanceInternal: 0 };
+        this.isBot = props.isBot || false;
+        this.ignoreHrm = false;
+        const name = this.getCyclingMode().getName();
+        const modeSettings = this.isBot ? props.settings || {} : this.getCyclingMode().getSettings();
+        this.setCyclingMode(name, modeSettings);
     }
     isBike() { return true; }
     isHrm() { return false; }
@@ -36,28 +54,66 @@ class Simulator extends Device_1.default {
     getID() { return Simulator.NAME; }
     getName() { return Simulator.NAME; }
     getPort() { return 'local'; }
-    start(props) {
-        this.startProps = props;
-        return new Promise((resolve) => {
-            this.logger.logEvent({ message: 'start', iv: this.iv });
-            if (this.started) {
-                return resolve({ started: true, error: undefined });
+    setIgnoreHrm(ignore) {
+        this.ignoreHrm = ignore;
+    }
+    getSupportedCyclingModes() {
+        const supported = [];
+        supported.push(simulator_mode_1.default);
+        return supported;
+    }
+    getDefaultCyclingMode() {
+        return new simulator_mode_1.default(this);
+    }
+    getCyclingMode() {
+        if (!this.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.cyclingMode;
+    }
+    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.cyclingMode = new CyclingModeClass(this, settings);
+                return;
             }
-            this.paused = (this.speed === 0);
-            this.started = true;
-            this.time = Date.now();
-            if (this.iv !== undefined) {
-                clearInterval(this.iv);
-                this.iv = undefined;
-            }
-            this.speed = 30;
-            this.iv = setInterval(() => this.update(), 1000);
-            resolve({ started: true, error: undefined });
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.cyclingMode = selectedMode;
+        this.cyclingMode.setSettings(settings);
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.startProps = props;
+            return new Promise((resolve) => {
+                if (!this.isBot)
+                    this.logger.logEvent({ message: 'start', iv: this.iv });
+                if (this.started) {
+                    return resolve({ started: true, error: undefined });
+                }
+                this.started = true;
+                this.time = Date.now();
+                this.startTS = this.time;
+                if (this.iv !== undefined) {
+                    clearInterval(this.iv);
+                    this.iv = undefined;
+                }
+                this.iv = setInterval(() => this.update(), 1000);
+                if (!this.isBot)
+                    this.logger.logEvent({ message: 'started' });
+                resolve({ started: true, error: undefined });
+            });
         });
     }
     stop() {
         return new Promise((resolve, reject) => {
-            this.logger.logEvent({ message: 'stop', iv: this.iv });
+            if (!this.isBot)
+                this.logger.logEvent({ message: 'stop', iv: this.iv });
             this.started = false;
             clearInterval(this.iv);
             this.iv = undefined;
@@ -69,7 +125,8 @@ class Simulator extends Device_1.default {
         return new Promise((resolve, reject) => {
             if (!this.started)
                 return reject(new Error('illegal state - pause() has been called before start()'));
-            this.logger.logEvent({ message: 'pause', iv: this.iv });
+            if (!this.isBot)
+                this.logger.logEvent({ message: 'pause', iv: this.iv });
             this.paused = true;
             resolve(true);
         });
@@ -78,7 +135,8 @@ class Simulator extends Device_1.default {
         return new Promise((resolve, reject) => {
             if (!this.started)
                 reject(new Error('illegal state - resume() has been called before start()'));
-            this.logger.logEvent({ message: 'resume', iv: this.iv });
+            if (!this.isBot)
+                this.logger.logEvent({ message: 'resume', iv: this.iv });
             this.paused = false;
             resolve(true);
         });
@@ -114,29 +172,26 @@ class Simulator extends Device_1.default {
         }
     }
     update() {
-        let prevTime = this.time;
-        this.time = Date.now();
-        let timespan = this.time - prevTime;
-        if (this.limit.slope) {
-            this.slope = this.limit.slope;
-        }
-        if (this.speed === undefined)
-            this.speed = 30;
-        this.power = calculations_1.default.calculatePower(75, this.speed / 3.6, this.slope);
-        if (this.limit.targetPower) {
-            this.power = this.limit.targetPower;
-            this.speed = calculations_1.default.calculateSpeed(75, this.power, this.slope);
-        }
-        if (this.limit.maxPower && this.power > this.limit.maxPower) {
-            this.power = this.limit.maxPower;
-            this.speed = calculations_1.default.calculateSpeed(75, this.power, this.slope);
-        }
-        else if (this.limit.minPower && this.power < this.limit.minPower) {
-            this.power = this.limit.minPower;
-            this.speed = calculations_1.default.calculateSpeed(75, this.power, this.slope);
-        }
-        let distance = this.calculateDistance(this.speed, timespan / 1000);
-        let data = { speed: this.speed, cadence: Math.round(this.cadence), power: Math.round(this.power), timespan, distance };
+        const startDelay = this.getCyclingMode().getSetting('delay');
+        const timeSinceStart = Date.now() - this.startTS;
+        if (startDelay && timeSinceStart < startDelay * 1000)
+            return;
+        const prevDist = this.data.distanceInternal;
+        this.data = this.getCyclingMode().updateData(this.data);
+        let data = {
+            speed: this.data.speed,
+            slope: this.data.slope,
+            power: this.data.power,
+            cadence: this.data.pedalRpm,
+            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),
+            deviceDistanceCounter: this.data.distanceInternal
+        };
+        this.paused = (this.data.speed === 0);
+        if (this.ignoreHrm)
+            delete data.heartrate;
         if (this.onDataFn) {
             this.onDataFn(data);
         }
@@ -145,15 +200,9 @@ class Simulator extends Device_1.default {
         return timeS * speedKps / 3.6;
     }
     sendUpdate(request) {
-        this.logger.logEvent({ message: 'bike update request', request });
-        const r = request || { refresh: true };
-        if (r.refresh) {
-            if (Object.keys(r).length === 1)
-                return this.limit;
-            delete r.refresh;
-        }
-        this.limit = r;
-        return this.limit;
+        if (this.paused)
+            return;
+        return this.getCyclingMode().sendBikeUpdate(request);
     }
 }
 exports.Simulator = Simulator;
@@ -161,9 +210,12 @@ Simulator.NAME = 'Simulator';
 class SimulatorProtocol extends DeviceProtocol_1.default {
     constructor() {
         super();
-        this.devices.push(new Simulator(this));
+        this.devices = [];
     }
     add(settings) {
+        let device = new Simulator(this, settings);
+        this.devices.push(device);
+        return device;
     }
     getName() {
         return SimulatorProtocol.NAME;

package/lib/simulator/simulator-mode.d.ts

@@ -0,0 +1,28 @@
+import { EventLogger } from "gd-eventlog";
+import CyclingMode, { CyclingModeBase, CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import { Simulator } from "./Simulator";
+export declare type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class SimulatorCyclingMode extends CyclingModeBase implements CyclingMode {
+    logger: EventLogger;
+    data: IncyclistBikeData;
+    prevRequest: UpdateRequest;
+    prevUpdateTS: number;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    constructor(adapter: Simulator, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): IncyclistBikeData;
+    calculateTargetPower(request: any, updateMode?: boolean): void;
+}

package/lib/simulator/simulator-mode.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const CyclingMode_1 = require("../CyclingMode");
+const calculations_1 = __importDefault(require("../calculations"));
+const config = {
+    name: "Simulator",
+    description: "Simulates a ride with constant speed or power output",
+    properties: [
+        { key: 'mode', name: 'Simulation Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
+        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
+        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
+        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
+    ]
+};
+class SimulatorCyclingMode extends CyclingMode_1.CyclingModeBase {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.prevUpdateTS = 0;
+        this.hasBikeUpdate = false;
+        this.event = {};
+        this.logger = adapter.logger || new gd_eventlog_1.EventLogger('SIMMode');
+        this.data = {};
+        this.logger.logEvent({ message: 'constructor', props });
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    sendBikeUpdate(request) {
+        this.logger.logEvent({ message: 'bike update request', request });
+        const r = request || { refresh: true };
+        if (r.refresh) {
+            if (Object.keys(r).length === 1)
+                return this.prevRequest || {};
+            delete r.refresh;
+        }
+        if (request.slope !== undefined) {
+            if (!this.data)
+                this.data = {};
+            this.data.slope = request.slope;
+        }
+        this.prevRequest = request ? JSON.parse(JSON.stringify(request)) : {};
+        return r;
+    }
+    updateData(bikeData) {
+        const prevData = JSON.parse(JSON.stringify(this.data || {}));
+        const prevSpeed = prevData.speed;
+        const prevRequest = this.prevRequest || {};
+        const data = this.data || {};
+        const mode = this.getSetting('mode');
+        delete this.event.gearUpdated;
+        delete this.event.rpmUpdated;
+        try {
+            let rpm = 90;
+            let power = (mode === 'Power' || !mode) ? Number(this.getSetting('power')) : bikeData.power || 0;
+            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            let speed = mode === 'Speed' ? Number(this.getSetting('speed')) : bikeData.speed || 0;
+            let m = 75;
+            let distanceInternal = prevData.distanceInternal || 0;
+            let ts = Date.now();
+            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+            if (mode === 'Power' || !mode) {
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            else if (mode === 'Speed') {
+                power = calculations_1.default.calculatePower(m, speed / 3.6, slope, { bikeType: 'race' });
+            }
+            if (prevRequest.targetPower) {
+                power = prevRequest.targetPower;
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            if (prevRequest.maxPower && power > prevRequest.maxPower) {
+                power = prevRequest.maxPower;
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            else if (prevRequest.minPower && power < prevRequest.minPower) {
+                power = prevRequest.minPower;
+                speed = calculations_1.default.calculateSpeed(m, power, slope, { bikeType: 'race' });
+            }
+            let v = speed / 3.6;
+            distanceInternal += Math.round(v * duration);
+            data.speed = parseFloat(speed.toFixed(1));
+            data.power = Math.round(power);
+            data.distanceInternal = distanceInternal;
+            data.slope = slope;
+            data.pedalRpm = rpm;
+            if (data.time !== undefined)
+                data.time += duration;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = true;
+            this.prevUpdateTS = ts;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
+        this.data = data;
+        return data;
+    }
+    calculateTargetPower(request, updateMode = true) {
+    }
+}
+exports.default = SimulatorCyclingMode;

package/lib/utils.js

@@ -17,16 +17,18 @@ function runWithRetries(fn, maxRetries, timeBetween) {
         let retries = 0;
         let tLastFailure = undefined;
         let busy = false;
-        const iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        let iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             const tNow = Date.now();
-            if (busy)
+            if (busy) {
                 return;
+            }
             if (tLastFailure === undefined || tNow - tLastFailure > timeBetween) {
                 try {
                     busy = true;
                     const data = yield fn();
-                    busy = false;
                     clearInterval(iv);
+                    iv = undefined;
+                    busy = false;
                     return resolve(data);
                 }
                 catch (err) {
@@ -34,6 +36,7 @@ function runWithRetries(fn, maxRetries, timeBetween) {
                     retries++;
                     if (retries >= maxRetries) {
                         clearInterval(iv);
+                        iv = undefined;
                         busy = false;
                         return reject(err);
                     }

package/package.json

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