incyclist-devices 2.0.38 → 2.1.0

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

@@ -0,0 +1,23 @@
+import ICyclingMode, { CyclingModeProperyType, IncyclistBikeData, Settings, UpdateRequest } from "./types";
+import { IncyclistDeviceAdapter } from "../types/adapter";
+import PowerMeterCyclingMode from "./power-meter";
+export default class DaumClassicCyclingMode extends PowerMeterCyclingMode implements ICyclingMode {
+    prevInternalDistance: number;
+    distanceOffset: number;
+    protected static config: {
+        name: string;
+        description: string;
+        properties: {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+        }[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    getBikeInitRequest(): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/{serial/daum/premium/modes/daum-classic.js → modes/daum-premium-standard.js}

@@ -4,16 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const cycling_mode_1 = require("../../../../modes/cycling-mode");
-const DaumPowerMeterCyclingMode_1 = __importDefault(require("../../DaumPowerMeterCyclingMode"));
-const config = {
-    name: "Daum Classic",
-    description: "The device calculates speed and power based on slope. Incyclist will not modify any values recived from the device\nThis mode will not respect maximum power and/or workout limits",
-    properties: [
-        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
-    ]
-};
-class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode_1.default {
+const types_1 = require("./types");
+const power_meter_1 = __importDefault(require("./power-meter"));
+class DaumClassicCyclingMode extends power_meter_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.logger = adapter ? adapter.getLogger() : undefined;
@@ -22,65 +15,60 @@ class DaumClassicCyclingMode extends DaumPowerMeterCyclingMode_1.default {
         this.setModeProperty('eppSupport', true);
         this.setModeProperty('setPersonSupport', true);
     }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
-    }
     getBikeInitRequest() {
         return {};
     }
-    getSettings() {
-        const settings = super.getSettings();
-        settings['setPerson'] = true;
-        return settings;
-    }
-    getSetting(name) {
-        if (name === 'setPerson')
-            return true;
-        return super.getSetting(name);
-    }
     updateData(data) {
         try {
-            const prevData = this.data || {};
+            const prevData = Object.assign({}, this.getData());
             const prevRequest = this.prevRequest || {};
             const bikeData = JSON.parse(JSON.stringify(data));
             let power = data.power || 0;
             let speed = data.speed || 0;
             let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
             let distanceBike = data.distanceInternal || 0;
-            let distancePrev = prevData.distanceInternal || 0;
-            let distanceInternal = distanceBike;
+            let distancePrev = this.prevInternalDistance || 0;
+            let distanceInternal = distanceBike + (this.distanceOffset || 0);
+            let time = prevData.time || 0;
             let ts = Date.now();
+            let t = this.getTimeSinceLastUpdate();
             if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
                 speed = 0;
                 power = 0;
             }
             if (distanceBike < distancePrev) {
-                this.logger.logEvent({ message: '~~~ distance overflow', distanceBike, distancePrev });
+                this.logger.logEvent({ message: 'distance overflow', distanceBike, distancePrev });
                 let v = speed / 3.6;
-                let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-                distanceInternal = distancePrev + v * duration;
+                const calculateDistance = distancePrev + (this.distanceOffset || 0) + v * t;
+                this.distanceOffset = calculateDistance - distanceBike;
+                distanceInternal = calculateDistance;
             }
             data.speed = parseFloat(speed.toFixed(1));
             data.power = Math.round(power);
             data.distanceInternal = distanceInternal;
             data.slope = slope;
+            data.time = speed > 0 ? time + t : time;
             this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: {}, prevSpeed: prevData.speed });
             this.data = JSON.parse(JSON.stringify(data));
             this.prevUpdateTS = ts;
+            this.prevInternalDistance = distanceBike;
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
         }
         return data;
     }
+    sendBikeUpdate(request) {
+        super.sendBikeUpdate(request);
+        this.prevRequest = {};
+        return {};
+    }
 }
+DaumClassicCyclingMode.config = {
+    name: "Daum Classic",
+    description: "The device calculates speed and power based on slope. Incyclist will not modify any values recived from the device\nThis mode will not respect maximum power and/or workout limits",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
+    ]
+};
 exports.default = DaumClassicCyclingMode;

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

@@ -0,0 +1,82 @@
+import { EventLogger } from "gd-eventlog";
+import ICyclingMode, { CyclingModeProperyType, IncyclistBikeData, Settings, UpdateRequest } from "./types";
+import { IncyclistDeviceAdapter } from "..";
+import { CyclingModeBase } from "./base";
+interface STUpdateRequest extends UpdateRequest {
+    calculatedPower?: number;
+    delta?: number;
+    enforced?: boolean;
+    belowMin?: boolean;
+    aboveMax?: boolean;
+}
+export declare enum direction {
+    up = "up",
+    down = "down"
+}
+interface STEvent {
+    gearUpdate?: direction;
+    rpmUpdate?: boolean;
+    targetNotReached?: number;
+}
+export default class SmartTrainerCyclingMode extends CyclingModeBase implements ICyclingMode {
+    logger: EventLogger;
+    data?: IncyclistBikeData;
+    prevRequest?: STUpdateRequest;
+    prevUpdateTS: number;
+    chain: number[];
+    cassette: number[];
+    event: STEvent;
+    protected static config: {
+        name: string;
+        description: string;
+        properties: ({
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+            validation?: undefined;
+            condition?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: number;
+            options?: undefined;
+            validation?: undefined;
+            condition?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: boolean;
+            options?: undefined;
+            validation?: undefined;
+            condition?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            validation: string;
+            default: string;
+            condition: (s: any) => any;
+            options?: undefined;
+        })[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    getData(): IncyclistBikeData;
+    getSlope(): number;
+    getWeight(): number;
+    getBikeInitRequest(): STUpdateRequest;
+    useGearSimulation(): boolean;
+    getMinMaxGears(source: string): [number, number];
+    sendBikeUpdate(request: STUpdateRequest): STUpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+    calculateSpeed(gear: any, rpm: any, slope: any, bikeSpeed: any, props?: any): any;
+    calculateTargetPower(request: STUpdateRequest, speed?: number): STUpdateRequest;
+}
+export {};

package/lib/{serial/daum/SmartTrainerCyclingMode.js → modes/daum-smarttrainer.js}

@@ -5,28 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.direction = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
-const cycling_mode_1 = require("../../modes/cycling-mode");
-const calculations_1 = __importDefault(require("../../utils/calculations"));
-const utils_1 = require("./classic/utils");
+const types_1 = require("./types");
+const calculations_1 = __importDefault(require("../utils/calculations"));
+const utils_1 = require("../serial/daum/classic/utils");
+const base_1 = require("./base");
 const SEC_DELAY = 3;
-const config = {
-    name: "SmartTrainer",
-    description: "Calculates power based on speed and slope.",
-    properties: [
-        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 50 },
-        { key: 'minPower', name: 'Minimum Power', description: 'Minimum power in declines', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 50 },
-        { key: 'simulation', name: 'Simulate ', description: 'Simulate ', type: cycling_mode_1.CyclingModeProperyType.Boolean, default: false },
-        { key: 'chainRings', name: 'Chain Rings', description: 'Simulated chain rings (format: <min>-<max>)', type: cycling_mode_1.CyclingModeProperyType.String, validation: '', default: '36-52', condition: (s) => s.simulation },
-        { key: 'cassetteRings', name: 'Cassette', description: 'Simulated cassette (format: <min>-<max>)', type: cycling_mode_1.CyclingModeProperyType.String, validation: '', default: '11-30', condition: (s) => s.simulation },
-    ]
-};
 var direction;
 (function (direction) {
     direction["up"] = "up";
     direction["down"] = "down";
 })(direction || (exports.direction = direction = {}));
-class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
+class SmartTrainerCyclingMode extends base_1.CyclingModeBase {
     constructor(adapter, props) {
         super(adapter, props);
         this.prevUpdateTS = 0;
@@ -34,18 +23,14 @@ class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
         this.logger = adapter ? adapter.getLogger() : undefined;
         if (!this.logger)
             this.logger = new gd_eventlog_1.EventLogger('SmartTrainer');
+        this.data = { speed: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
     }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
+    getData() {
+        return this.data;
     }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
+    getSlope() {
+        const { slope } = this.data;
+        return slope || 0;
     }
     getWeight() {
         const a = this.adapter;
@@ -347,4 +332,16 @@ class SmartTrainerCyclingMode extends cycling_mode_1.CyclingModeBase {
         return request;
     }
 }
+SmartTrainerCyclingMode.config = {
+    name: "SmartTrainer",
+    description: "Calculates power based on speed and slope.",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: types_1.CyclingModeProperyType.Integer, default: 50 },
+        { key: 'minPower', name: 'Minimum Power', description: 'Minimum power in declines', type: types_1.CyclingModeProperyType.Integer, default: 50 },
+        { key: 'simulation', name: 'Simulate ', description: 'Simulate ', type: types_1.CyclingModeProperyType.Boolean, default: false },
+        { key: 'chainRings', name: 'Chain Rings', description: 'Simulated chain rings (format: <min>-<max>)', type: types_1.CyclingModeProperyType.String, validation: '', default: '36-52', condition: (s) => s.simulation },
+        { key: 'cassetteRings', name: 'Cassette', description: 'Simulated cassette (format: <min>-<max>)', type: types_1.CyclingModeProperyType.String, validation: '', default: '11-30', condition: (s) => s.simulation },
+    ]
+};
 exports.default = SmartTrainerCyclingMode;

package/lib/modes/kettler-erg.d.ts

@@ -0,0 +1,44 @@
+import ICyclingMode, { CyclingModeProperyType, IncyclistBikeData, UpdateRequest } from './types';
+import PowerBasedCyclingModeBase from './power-base';
+import { IncyclistDeviceAdapter } from '../types/adapter';
+export type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+    protected static config: {
+        isERG: boolean;
+        name: string;
+        description: string;
+        properties: ({
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+            min?: undefined;
+            max?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: number;
+            min: number;
+            max: number;
+            options?: undefined;
+        })[];
+    };
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+}

package/lib/{serial/kettler/ergo-racer/modes/erg.js → modes/kettler-erg.js}

@@ -3,17 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const cycling_mode_1 = require("../../../../modes/cycling-mode");
-const power_base_1 = __importDefault(require("../../../../modes/power-base"));
+const types_1 = require("./types");
+const power_base_1 = __importDefault(require("./power-base"));
 const MIN_SPEED = 10;
-const config = {
-    name: "ERG",
-    description: "Calculates speed based on power and slope. Power is either set by a workout",
-    properties: [
-        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
-    ]
-};
 class ERGCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
@@ -21,18 +13,6 @@ class ERGCyclingMode extends power_base_1.default {
         this.event = {};
         this.initLogger('ERGMode');
     }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
-    }
     getBikeInitRequest() {
         const startPower = this.getSetting('startPower');
         return { targetPower: startPower };
@@ -131,6 +111,7 @@ class ERGCyclingMode extends power_base_1.default {
                 data.time = 0;
             data.heartrate = bikeData.heartrate;
             data.isPedalling = bikeData.isPedalling;
+            this.prevUpdateTS = Date.now();
         }
         catch (err) {
             this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
@@ -140,5 +121,13 @@ class ERGCyclingMode extends power_base_1.default {
         return data;
     }
 }
-ERGCyclingMode.isERG = true;
+ERGCyclingMode.config = {
+    isERG: true,
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power is either set by a workout",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: types_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+    ]
+};
 exports.default = ERGCyclingMode;

package/lib/modes/power-base.d.ts

@@ -1,20 +1,45 @@
-import { IncyclistBikeData, Settings, CyclingModeBase } from './cycling-mode';
+import { CyclingModeConfig, IncyclistBikeData, Settings, UpdateRequest } from './types';
 import { EventLogger } from 'gd-eventlog';
-import { ControllableDeviceAdapter } from '..';
+import { IncyclistDeviceAdapter } from '..';
+import { CyclingModeBase } from './base';
 export default class PowerBasedCyclingModeBase extends CyclingModeBase {
     data: IncyclistBikeData;
     prevUpdateTS: number;
     logger: EventLogger;
-    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
+    prevRequest: UpdateRequest | undefined;
+    protected static config: CyclingModeConfig;
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    getData(): IncyclistBikeData;
+    getSlope(): number;
     initLogger(defaultLogName: any): void;
     getWeight(): number;
     getTimeSinceLastUpdate(): number;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected checkForTempPowerAdjustments(request: UpdateRequest): void;
+    protected checkRefresh(request: UpdateRequest, newRequest: UpdateRequest): void;
+    protected checkTargetPowerSet(request: UpdateRequest, newRequest: UpdateRequest): void;
+    protected checkSlope(request: UpdateRequest): void;
+    protected checkEmptyRequest(newRequest: UpdateRequest): void;
+    protected checkMinPower(request: UpdateRequest, newRequest: UpdateRequest): void;
+    protected checkMaxPower(request: UpdateRequest, newRequest: UpdateRequest): void;
     calculateSpeedAndDistance(power: number, slope: number, m: number, t: number, props?: {}): {
         speed: number;
         distance: number;
     };
+    protected updateSpeedAndDistance(power: number, slope: any, bikeType: any, data: IncyclistBikeData, prevData: any): number;
+    protected getCalcBasics(bikeData: IncyclistBikeData): {
+        data: IncyclistBikeData;
+        prevData: any;
+        prevRequest: UpdateRequest;
+        bikeType: any;
+        slope: any;
+    };
+    copyBikeData(data: IncyclistBikeData, bikeData: IncyclistBikeData): IncyclistBikeData;
     calculatePowerAndDistance(speed: number, slope: number, m: number, t: number, props?: {}): {
         power: number;
         distance: number;
     };
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData, log?: boolean): IncyclistBikeData;
 }

package/lib/modes/power-base.js

@@ -3,16 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const cycling_mode_1 = require("./cycling-mode");
 const adpater_1 = require("../base/adpater");
 const calculations_1 = __importDefault(require("../utils/calculations"));
 const gd_eventlog_1 = require("gd-eventlog");
-class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
+const base_1 = require("./base");
+const MIN_SPEED = 10;
+class PowerBasedCyclingModeBase extends base_1.CyclingModeBase {
     constructor(adapter, props) {
         super(adapter, props);
         this.prevUpdateTS = 0;
         this.data = { speed: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
     }
+    getData() {
+        return this.data;
+    }
+    getSlope() {
+        const { slope } = this.data;
+        return slope || 0;
+    }
     initLogger(defaultLogName) {
         const a = this.adapter;
         this.logger = a.getLogger();
@@ -28,11 +36,86 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
     getTimeSinceLastUpdate() {
         const ts = Date.now();
         const duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-        this.prevUpdateTS = ts;
         return duration;
     }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return { reset: true };
+        }
+        if (Object.keys(request).length === 0 && this.prevRequest) {
+            return { targetPower: this.prevRequest.targetPower, refresh: true };
+        }
+    }
+    checkForTempPowerAdjustments(request) {
+        if (request.targetPowerDelta && this.prevRequest && this.prevRequest.targetPower) {
+            request.targetPower = this.prevRequest.targetPower + request.targetPowerDelta;
+            if (request.targetPower < 10)
+                request.targetPower = this.prevRequest.targetPower;
+            delete request.targetPowerDelta;
+        }
+    }
+    checkRefresh(request, newRequest) {
+        if (request.refresh && request.targetPower === undefined) {
+            delete request.refresh;
+            if (this.prevRequest)
+                newRequest.targetPower = this.prevRequest.targetPower;
+        }
+    }
+    checkTargetPowerSet(request, newRequest) {
+        let target = undefined;
+        if (request.targetPower !== undefined)
+            target = request.targetPower;
+        if (request.targetPower === undefined && request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+            target = request.minPower;
+        }
+        if (target !== undefined) {
+            delete request.refresh;
+            newRequest.targetPower = Number(target);
+        }
+    }
+    checkSlope(request) {
+        if (request.slope !== undefined) {
+            this.data.slope = request.slope;
+            delete request.slope;
+        }
+    }
+    checkEmptyRequest(newRequest) {
+        if (Object.keys(newRequest).length === 0) {
+            if (this.prevRequest) {
+                newRequest.targetPower = this.prevRequest.targetPower;
+                newRequest.refresh = true;
+            }
+        }
+    }
+    checkMinPower(request, newRequest) {
+        if (request.minPower !== undefined) {
+            const target = newRequest.targetPower !== undefined ? newRequest.targetPower : this.prevRequest.targetPower;
+            if (target && target < request.minPower) {
+                newRequest.targetPower = request.minPower;
+            }
+            else {
+                if (this.prevRequest)
+                    newRequest.targetPower = this.prevRequest.targetPower;
+            }
+            newRequest.minPower = request.minPower;
+        }
+    }
+    checkMaxPower(request, newRequest) {
+        if (request.maxPower !== undefined) {
+            const target = newRequest.targetPower !== undefined ? newRequest.targetPower : this.prevRequest.targetPower;
+            if (target && target > request.maxPower) {
+                newRequest.targetPower = request.maxPower;
+            }
+            else {
+                if (this.prevRequest)
+                    newRequest.targetPower = this.prevRequest.targetPower;
+            }
+            newRequest.maxPower = request.maxPower;
+        }
+    }
     calculateSpeedAndDistance(power, slope, m, t, props = {}) {
-        const prevData = this.data || {};
+        const prevData = this.getData();
         const vPrev = (prevData.speed || 0) / 3.6;
         const EkinPrev = 1 / 2 * m * vPrev * vPrev;
         let powerToMaintainSpeed = calculations_1.default.calculatePower(m, vPrev, slope, props);
@@ -57,8 +140,57 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
             return { speed, distance };
         }
     }
+    updateSpeedAndDistance(power, slope, bikeType, data, prevData) {
+        const distanceInternal = prevData.distanceInternal || 0;
+        const m = this.getWeight();
+        const t = this.getTimeSinceLastUpdate();
+        const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+        if (power === 0 && speed < MIN_SPEED) {
+            data.speed = prevData.speed < 1 ? 0 : prevData.speed - 1;
+            data.distanceInternal = distanceInternal || 0 + data.speed / 3.6 * t;
+        }
+        else {
+            data.speed = speed;
+            data.distanceInternal = distanceInternal + distance;
+        }
+        return t;
+    }
+    getCalcBasics(bikeData) {
+        var _a;
+        const prevData = JSON.parse(JSON.stringify(this.getData()));
+        const data = Object.assign({}, this.getData());
+        const prevRequest = this.prevRequest || {};
+        const bikeType = (_a = this.getSetting('bikeType')) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+        this.copyBikeData(data, bikeData);
+        return { data, prevData, prevRequest, bikeType, slope };
+    }
+    copyBikeData(data, bikeData) {
+        var _a;
+        const keys = Object.keys(bikeData);
+        keys.forEach(key => {
+            if (bikeData[key] === null)
+                delete data[key];
+            if (key === 'slope')
+                return;
+            else if (bikeData[key] !== undefined)
+                data[key] = bikeData[key];
+        });
+        if (data.distanceInternal === undefined)
+            data.distanceInternal = 0;
+        if (data.time === undefined)
+            data.time = 0;
+        if (data.slope === undefined)
+            data.slope = 0;
+        if (bikeData.isPedalling === undefined)
+            data.isPedalling = data.pedalRpm > 0;
+        if (((_a = this.prevRequest) === null || _a === void 0 ? void 0 : _a.slope) !== undefined) {
+            data.slope = this.prevRequest.slope;
+        }
+        return data;
+    }
     calculatePowerAndDistance(speed, slope, m, t, props = {}) {
-        const prevData = this.data || {};
+        const prevData = this.getData();
         const vPrev = (prevData.speed || 0) / 3.6;
         const EkinPrev = 1 / 2 * m * vPrev * vPrev;
         const vTarget = (speed || 0) / 3.6;
@@ -71,5 +203,50 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
         this.data.power = power;
         return { power, distance };
     }
+    getBikeInitRequest() {
+        return {};
+    }
+    sendBikeUpdate(incoming) {
+        if (this.logger)
+            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)
+                return req;
+            this.checkSlope(request);
+            this.checkForTempPowerAdjustments(request);
+            this.checkTargetPowerSet(request, newRequest);
+            this.checkRefresh(request, newRequest);
+            this.checkMaxPower(request, newRequest);
+            this.checkMinPower(request, newRequest);
+            this.checkEmptyRequest(newRequest);
+            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        }
+        catch (err) {
+            if (this.logger)
+                this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message, stack: err.stack });
+        }
+        return newRequest;
+    }
+    updateData(bikeData, log = true) {
+        try {
+            const { data, prevData, slope, bikeType } = this.getCalcBasics(bikeData);
+            const t = this.updateSpeedAndDistance(data.power, slope, bikeType, data, prevData);
+            data.time = (data.speed > 0) ? data.time + t : data.time;
+            if (log && this.logger)
+                this.logger.logEvent({ message: "updateData result", mode: this.getName(), data, bikeData });
+            this.data = data;
+            this.prevUpdateTS = Date.now();
+            return data;
+        }
+        catch (err) {
+            if (this.logger)
+                this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+            return this.getData();
+        }
+    }
 }
+PowerBasedCyclingModeBase.config = { name: '', description: '', properties: [] };
 exports.default = PowerBasedCyclingModeBase;