incyclist-devices 2.0.38 → 2.1.0

package/lib/modes/ant-fe-adv-st-mode.d.ts

@@ -0,0 +1,12 @@
+import { IncyclistDeviceAdapter } from "..";
+import SmartTrainerCyclingMode from "./antble-smarttrainer";
+import { UpdateRequest } from "./types";
+export default class AntAdvSimCyclingMode extends SmartTrainerCyclingMode {
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected checkForTempPowerAdjustments(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected checkEmptyRequest(newRequest: UpdateRequest): void;
+    sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+}

package/lib/modes/ant-fe-adv-st-mode.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const antble_smarttrainer_1 = __importDefault(require("./antble-smarttrainer"));
+const MAX_DEVIATION = 10;
+class AntAdvSimCyclingMode extends antble_smarttrainer_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('AdvmartTrainerMode');
+    }
+    getName() {
+        return 'Advanced Smart Trainer';
+    }
+    getDescription() {
+        return 'Sends Slope to device. Respects Limits (from workout or settings). Calculates speed based on power and slope. ';
+    }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return { reset: true };
+        }
+        if (request.slope === undefined && request.targetPowerDelta === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+    }
+    checkForTempPowerAdjustments(request, newRequest = {}) {
+        if (request.targetPowerDelta && this.prevRequest && this.prevRequest.targetPower) {
+            newRequest.targetPower = this.prevRequest.targetPower + request.targetPowerDelta;
+            if (newRequest.targetPower < 10)
+                newRequest.targetPower = this.prevRequest.targetPower;
+            delete request.targetPowerDelta;
+        }
+    }
+    checkEmptyRequest(newRequest) {
+        if (Object.keys(newRequest).length === 0) {
+            if (this.prevRequest) {
+                newRequest.slope = this.prevRequest.slope;
+                newRequest.targetPower = this.prevRequest.targetPower;
+                newRequest.refresh = true;
+            }
+        }
+    }
+    sendBikeUpdate(incoming) {
+        var _a;
+        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, newRequest);
+            let data = this.getData();
+            if (data.power) {
+                const { minPower, maxPower } = request;
+                let targetPower = request.targetPower;
+                if (minPower !== undefined && maxPower !== undefined && minPower === maxPower)
+                    targetPower = maxPower;
+                if (targetPower !== undefined && Math.abs(data.power - targetPower) > MAX_DEVIATION)
+                    newRequest.targetPower = targetPower;
+                else if (minPower !== undefined && data.power < minPower)
+                    newRequest.targetPower = minPower;
+                else if (request.maxPower !== undefined && data.power > request.maxPower)
+                    newRequest.targetPower = maxPower;
+                else if ((_a = this.prevRequest) === null || _a === void 0 ? void 0 : _a.targetPower) {
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                }
+                if (newRequest.targetPower) {
+                    this.checkForTempPowerAdjustments(request, newRequest);
+                }
+            }
+            this.checkEmptyRequest(newRequest);
+            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message, stack: err.stack });
+        }
+        return newRequest;
+    }
+}
+exports.default = AntAdvSimCyclingMode;

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

@@ -0,0 +1,31 @@
+import { IncyclistDeviceAdapter } from "..";
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+import PowerBasedCyclingModeBase from "./power-base";
+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;
+        })[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getBikeInitRequest(): UpdateRequest;
+}

package/lib/modes/antble-erg.js

@@ -0,0 +1,28 @@
+"use strict";
+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"));
+class ERGCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('ERGMode');
+    }
+    getBikeInitRequest() {
+        const startPower = Number(this.getSetting('startPower'));
+        this.prevRequest = { targetPower: startPower };
+        return { targetPower: startPower };
+    }
+}
+ERGCyclingMode.config = {
+    isERG: true,
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power targets are set by workout or remain stable throughout the 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/antble-smarttrainer.d.ts

@@ -0,0 +1,23 @@
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+import PowerBasedCyclingModeBase from "./power-base";
+import { IncyclistDeviceAdapter } from "../types/adapter";
+export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+    protected static config: {
+        name: string;
+        description: string;
+        properties: {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+        }[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getBikeInitRequest(): UpdateRequest;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;
+    protected checkEmptyRequest(newRequest: UpdateRequest): void;
+    sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+}

package/lib/modes/antble-smarttrainer.js

@@ -0,0 +1,65 @@
+"use strict";
+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"));
+class SmartTrainerCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('SmartTrainerMode');
+    }
+    getBikeInitRequest() {
+        this.prevRequest = { slope: 0 };
+        return { slope: 0 };
+    }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return { reset: true };
+        }
+        if (request.slope === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+    }
+    checkSlope(request, newRequest = {}) {
+        if (request.slope !== undefined) {
+            newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
+        }
+    }
+    checkEmptyRequest(newRequest) {
+        if (Object.keys(newRequest).length === 0) {
+            if (this.prevRequest) {
+                newRequest.slope = this.prevRequest.slope;
+                newRequest.refresh = true;
+            }
+        }
+    }
+    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)
+                return req;
+            this.checkSlope(request, newRequest);
+            this.checkEmptyRequest(newRequest);
+            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message, stack: err.stack });
+        }
+        return newRequest;
+    }
+}
+SmartTrainerCyclingMode.config = {
+    name: "Smart Trainer",
+    description: "Calculates speed based on power and slope. Slope is set to the device",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
+    ]
+};
+exports.default = SmartTrainerCyclingMode;

package/lib/modes/base.d.ts

@@ -0,0 +1,29 @@
+import { IncyclistDeviceAdapter } from "../types/adapter";
+import ICyclingMode, { CyclingMode, CyclingModeConfig, CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "./types";
+export declare abstract class CyclingModeBase extends CyclingMode implements ICyclingMode {
+    adapter: IncyclistDeviceAdapter;
+    settings: Settings;
+    properties: Settings;
+    localConfig: CyclingModeConfig;
+    protected static config: CyclingModeConfig;
+    protected static isERG: boolean;
+    static supportsERGMode(): boolean;
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    setAdapter(adapter: IncyclistDeviceAdapter): void;
+    setConfig(config: CyclingModeConfig): void;
+    getConfig(): CyclingModeConfig;
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    setSettings(settings?: any): void;
+    setSetting(name: string, value: any): void;
+    getSetting(name: string): any;
+    getSettingDefault(name: string): any;
+    getSettings(): Settings;
+    setModeProperty(name: string, value: any): void;
+    getModeProperty(name: string): any;
+    abstract getBikeInitRequest(): UpdateRequest;
+    abstract sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    abstract updateData(data: IncyclistBikeData): IncyclistBikeData;
+}

package/lib/modes/{cycling-mode.js → base.js}

@@ -1,47 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CyclingModeBase = exports.CyclingModeProperyType = void 0;
-var CyclingModeProperyType;
-(function (CyclingModeProperyType) {
-    CyclingModeProperyType["Integer"] = "Integer";
-    CyclingModeProperyType["Boolean"] = "Boolean";
-    CyclingModeProperyType["Float"] = "Float";
-    CyclingModeProperyType["String"] = "String";
-    CyclingModeProperyType["SingleSelect"] = "SingleSelect";
-    CyclingModeProperyType["MultiSelect"] = "MultiSelect";
-})(CyclingModeProperyType || (exports.CyclingModeProperyType = CyclingModeProperyType = {}));
-class CyclingModeBase {
+exports.CyclingModeBase = void 0;
+const types_1 = require("./types");
+class CyclingModeBase extends types_1.CyclingMode {
+    static supportsERGMode() {
+        return this.config.isERG === true;
+    }
     constructor(adapter, props) {
+        super(adapter, props);
         this.settings = {};
         this.properties = {};
-        if (!adapter)
-            throw new Error('IllegalArgument: adapter is null');
         this.setAdapter(adapter);
         this.setSettings(props);
     }
     setAdapter(adapter) {
         this.adapter = adapter;
     }
-    getBikeInitRequest() {
-        return {};
+    setConfig(config) {
+        this.localConfig = config;
+    }
+    getConfig() {
+        if (this.localConfig)
+            return this.localConfig;
+        let cm = this.constructor;
+        return cm.config;
     }
     getName() {
-        throw new Error("Method not implemented.");
+        return this.getConfig().name;
     }
     getDescription() {
-        throw new Error("Method not implemented.");
-    }
-    sendBikeUpdate(request) {
-        throw new Error("Method not implemented.");
-    }
-    updateData(data) {
-        throw new Error("Method not implemented.");
+        return this.getConfig().description;
     }
     getProperties() {
-        throw new Error("Method not implemented.");
+        return this.getConfig().properties;
     }
     getProperty(name) {
-        throw new Error("Method not implemented.");
+        return this.getConfig().properties.find(p => p.name === name);
     }
     setSettings(settings) {
         if (settings) {
@@ -55,10 +49,12 @@ class CyclingModeBase {
         const res = this.settings[name];
         if (res !== undefined)
             return res;
+        return this.getSettingDefault(name);
+    }
+    getSettingDefault(name) {
         const prop = this.getProperties().find(p => p.key === name);
         if (prop && prop.default !== undefined)
             return prop.default;
-        return undefined;
     }
     getSettings() {
         return this.settings;
@@ -77,3 +73,4 @@ class CyclingModeBase {
     }
 }
 exports.CyclingModeBase = CyclingModeBase;
+CyclingModeBase.config = { name: '', description: '', properties: [] };

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

@@ -0,0 +1,16 @@
+import ICyclingMode, { IncyclistBikeData, Settings, UpdateRequest } from "./types";
+import { IncyclistDeviceAdapter } from "../types/adapter";
+import SmartTrainerCyclingMode from "./antble-smarttrainer";
+type DaumClassicEvent = {
+    noData?: boolean;
+    slopeUpdate?: boolean;
+    initialCall?: boolean;
+};
+export default class DaumClassicCyclingMode extends SmartTrainerCyclingMode implements ICyclingMode {
+    event: DaumClassicEvent;
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    getBikeInitRequest(): UpdateRequest;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected updateSpeedAndDistance(_power: number, _slope: any, _bikeType: any, data: IncyclistBikeData, prevData: any): number;
+}
+export {};

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

@@ -0,0 +1,54 @@
+"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 types_1 = require("./types");
+const antble_smarttrainer_1 = __importDefault(require("./antble-smarttrainer"));
+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: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain'], default: 'Race' },
+    ]
+};
+class DaumClassicCyclingMode extends antble_smarttrainer_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.logger = adapter ? adapter.getLogger() : undefined;
+        if (!this.logger)
+            this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+        this.setConfig(config);
+        this.event = { noData: true, initialCall: true, slopeUpdate: false };
+    }
+    getBikeInitRequest() {
+        return { slope: 0 };
+    }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return {};
+        }
+        if (Object.keys(request).length === 0 && this.prevRequest) {
+            return { slope: this.prevRequest.slope, refresh: true };
+        }
+        if (request.slope === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+    }
+    updateSpeedAndDistance(_power, _slope, _bikeType, data, prevData) {
+        const distanceInternal = prevData.distanceInternal || 0;
+        const t = this.getTimeSinceLastUpdate();
+        if (data.pedalRpm === 0 || data.isPedalling === false) {
+            data.speed = 0;
+            data.power = 0;
+        }
+        else {
+            let v = data.speed / 3.6;
+            data.distanceInternal = distanceInternal + v * t;
+        }
+        return t;
+    }
+}
+exports.default = DaumClassicCyclingMode;

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

@@ -0,0 +1,49 @@
+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 {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    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;
+        })[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    copyBikeData(data: IncyclistBikeData, bikeData: IncyclistBikeData): IncyclistBikeData;
+    updateData(bikeData: IncyclistBikeData): IncyclistBikeData;
+    private checkForEvents;
+    private cleanupPrevEvents;
+    private checkIsStarting;
+    calculateTargetPower(request: any, updateMode?: boolean): any;
+}

package/lib/{serial/daum/ERGCyclingMode.js → modes/daum-erg.js}

@@ -3,18 +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 calculations_1 = __importDefault(require("../../utils/calculations"));
-const power_base_1 = __importDefault(require("../../modes/power-base"));
-const MIN_SPEED = 10;
-const config = {
-    name: "ERG",
-    description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
-    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 },
-    ]
-};
+const types_1 = require("./types");
+const calculations_1 = __importDefault(require("../utils/calculations"));
+const power_base_1 = __importDefault(require("./power-base"));
 class ERGCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
@@ -22,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, init: true };
@@ -133,61 +112,46 @@ class ERGCyclingMode extends power_base_1.default {
         this.event.rpmUpdated = false;
         return newRequest;
     }
+    copyBikeData(data, bikeData) {
+        const newData = super.copyBikeData(data, bikeData);
+        if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
+            newData.power = 0;
+        }
+        if (newData.gear === undefined)
+            newData.gear = 0;
+        return newData;
+    }
     updateData(bikeData) {
-        const prevData = JSON.parse(JSON.stringify(this.data || {}));
-        const prevSpeed = prevData.speed;
-        const prevRequest = this.prevRequest || {};
-        const data = this.data || {};
-        const bikeType = this.getSetting('bikeType').toLowerCase();
+        try {
+            const prevData = JSON.parse(JSON.stringify(this.getData()));
+            this.cleanupPrevEvents();
+            this.checkIsStarting(prevData);
+            const data = super.updateData(bikeData);
+            this.checkForEvents(bikeData, prevData);
+            return data;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message, stack: err.stack });
+            return this.getData();
+        }
+    }
+    checkForEvents(bikeData, prevData) {
+        if (bikeData.gear !== prevData.gear) {
+            this.event.gearUpdated = true;
+        }
+        if (bikeData.pedalRpm && bikeData.pedalRpm !== prevData.pedalRpm) {
+            this.event.rpmUpdated = true;
+        }
+    }
+    cleanupPrevEvents() {
         delete this.event.gearUpdated;
         delete this.event.rpmUpdated;
+    }
+    checkIsStarting(prevData) {
         if (Object.keys(prevData).length === 0 || prevData.speed === undefined || prevData.speed === 0) {
             this.event.starting = true;
             this.event.tsStart = Date.now();
         }
-        try {
-            const rpm = bikeData.pedalRpm || 0;
-            const gear = bikeData.gear || 0;
-            let power = bikeData.power || 0;
-            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            const distanceInternal = prevData.distanceInternal || 0;
-            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
-                power = 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 = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
-                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
-            }
-            else {
-                data.speed = speed;
-                data.distanceInternal = distanceInternal + distance;
-            }
-            data.power = Math.round(power);
-            data.slope = slope;
-            data.pedalRpm = rpm;
-            data.gear = gear;
-            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
-                data.time += t;
-            else
-                data.time = 0;
-            data.heartrate = bikeData.heartrate;
-            data.isPedalling = bikeData.isPedalling;
-            if (gear !== prevData.gear) {
-                this.event.gearUpdated = true;
-            }
-            if (rpm && rpm !== prevData.pedalRpm) {
-                this.event.rpmUpdated = true;
-            }
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err, stack: err.stack });
-        }
-        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
-        this.data = data;
-        return data;
     }
     calculateTargetPower(request, updateMode = true) {
         const bikeType = this.getSetting('bikeType').toLowerCase();
@@ -206,5 +170,13 @@ class ERGCyclingMode extends power_base_1.default {
         return target;
     }
 }
-ERGCyclingMode.isERG = true;
+ERGCyclingMode.config = {
+    isERG: true,
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
+    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/daum-power.d.ts

@@ -0,0 +1,5 @@
+import ICyclingMode, { UpdateRequest } from "./types";
+import PowerMeterCyclingMode from "./power-meter";
+export default class DaumPowerMeterCyclingMode extends PowerMeterCyclingMode implements ICyclingMode {
+    getBikeInitRequest(): UpdateRequest;
+}

package/lib/{serial/daum/DaumPowerMeterCyclingMode.js → modes/daum-power.js}

@@ -3,19 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+const power_meter_1 = __importDefault(require("./power-meter"));
 class DaumPowerMeterCyclingMode extends power_meter_1.default {
-    constructor() {
-        super(...arguments);
-        this.hasBikeUpdate = false;
-    }
     getBikeInitRequest() {
         return { slope: 0 };
     }
-    sendBikeUpdate(request) {
-        super.sendBikeUpdate(request);
-        this.prevRequest = {};
-        return {};
-    }
 }
 exports.default = DaumPowerMeterCyclingMode;