incyclist-devices 1.4.100 → 1.5.0

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

@@ -1,144 +1,144 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const CyclingMode_1 = require("../../CyclingMode");
-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 a workout",
-    properties: [
-        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
-    ]
-};
-class ERGCyclingMode extends power_base_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.hasBikeUpdate = false;
-        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 };
-    }
-    sendBikeUpdate(request) {
-        const getData = () => {
-            if (!this.data)
-                return {};
-            const { pedalRpm, slope, power, speed } = this.data;
-            return { pedalRpm, slope, power, speed };
-        };
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
-        let newRequest = {};
-        try {
-            if (!request || request.reset || Object.keys(request).length === 0) {
-                this.prevRequest = {};
-                return request.reset ? { reset: true } : {};
-            }
-            const prevData = this.data || {};
-            if (request.slope !== undefined) {
-                if (!this.data)
-                    this.data = {};
-                this.data.slope = request.slope;
-            }
-            delete request.slope;
-            if (request.targetPower !== undefined) {
-                delete request.refresh;
-            }
-            if (request.refresh) {
-                delete request.refresh;
-                if (this.prevRequest)
-                    newRequest.targetPower = this.prevRequest.targetPower;
-                else {
-                    this.prevRequest = this.getBikeInitRequest();
-                    newRequest.targetPower = this.prevRequest.targetPower;
-                }
-            }
-            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
-                request.targetPower = request.maxPower;
-                newRequest.targetPower = request.targetPower;
-            }
-            if (request.maxPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
-                    newRequest.targetPower = request.maxPower;
-                }
-                newRequest.maxPower = request.maxPower;
-            }
-            if (request.minPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
-                    newRequest.targetPower = request.minPower;
-                }
-                newRequest.minPower = request.minPower;
-                if (prevData.power && prevData.power < request.minPower)
-                    newRequest.targetPower = request.minPower;
-            }
-            if (!newRequest.targetPower && newRequest.maxPower && prevData.power > newRequest.maxPower) {
-                newRequest.targetPower = newRequest.maxPower;
-            }
-            if (!newRequest.targetPower && newRequest.minPower && prevData.power < newRequest.minPower) {
-                newRequest.targetPower = newRequest.minPower;
-            }
-            this.prevRequest = JSON.parse(JSON.stringify(request));
-        }
-        catch (err) {
-            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
-        }
-        return newRequest;
-    }
-    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 {
-            let power = bikeData.power || 0;
-            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            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 = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
-                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
-            }
-            else {
-                data.speed = (power === 0 && speed < MIN_SPEED) ? 0 : speed;
-                data.distanceInternal = (power === 0 && speed < MIN_SPEED) ? distanceInternal : distanceInternal + distance;
-            }
-            data.power = Math.round(power);
-            data.slope = slope;
-            data.pedalRpm = bikeData.pedalRpm || 0;
-            if (data.time !== undefined && data.speed > 0)
-                data.time += t;
-            else
-                data.time = 0;
-            data.heartrate = bikeData.heartrate;
-            data.isPedalling = bikeData.isPedalling;
-        }
-        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;
-    }
-}
-exports.default = ERGCyclingMode;
-ERGCyclingMode.isERG = true;
+"use strict";
+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 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 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);
+        this.hasBikeUpdate = false;
+        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 };
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { pedalRpm, slope, power, speed } = this.data;
+            return { pedalRpm, slope, power, speed };
+        };
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
+        let newRequest = {};
+        try {
+            if (!request || request.reset || Object.keys(request).length === 0) {
+                this.prevRequest = {};
+                return request.reset ? { reset: true } : {};
+            }
+            const prevData = this.data || {};
+            if (request.slope !== undefined) {
+                if (!this.data)
+                    this.data = {};
+                this.data.slope = request.slope;
+            }
+            delete request.slope;
+            if (request.targetPower !== undefined) {
+                delete request.refresh;
+            }
+            if (request.refresh) {
+                delete request.refresh;
+                if (this.prevRequest)
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                else {
+                    this.prevRequest = this.getBikeInitRequest();
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                }
+            }
+            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+                request.targetPower = request.maxPower;
+                newRequest.targetPower = request.targetPower;
+            }
+            if (request.maxPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
+                    newRequest.targetPower = request.maxPower;
+                }
+                newRequest.maxPower = request.maxPower;
+            }
+            if (request.minPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
+                    newRequest.targetPower = request.minPower;
+                }
+                newRequest.minPower = request.minPower;
+                if (prevData.power && prevData.power < request.minPower)
+                    newRequest.targetPower = request.minPower;
+            }
+            if (!newRequest.targetPower && newRequest.maxPower && prevData.power > newRequest.maxPower) {
+                newRequest.targetPower = newRequest.maxPower;
+            }
+            if (!newRequest.targetPower && newRequest.minPower && prevData.power < newRequest.minPower) {
+                newRequest.targetPower = newRequest.minPower;
+            }
+            this.prevRequest = JSON.parse(JSON.stringify(request));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
+        }
+        return newRequest;
+    }
+    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 {
+            let power = bikeData.power || 0;
+            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            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 = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = (power === 0 && speed < MIN_SPEED) ? 0 : speed;
+                data.distanceInternal = (power === 0 && speed < MIN_SPEED) ? distanceInternal : distanceInternal + distance;
+            }
+            data.power = Math.round(power);
+            data.slope = slope;
+            data.pedalRpm = bikeData.pedalRpm || 0;
+            if (data.time !== undefined && data.speed > 0)
+                data.time += t;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = bikeData.isPedalling;
+        }
+        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;
+    }
+}
+exports.default = ERGCyclingMode;
+ERGCyclingMode.isERG = true;

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

@@ -1,101 +1,101 @@
-import { DeviceSettings } from "../../DeviceProtocol";
-import DeviceAdapterBase, { DeviceAdapter, DeviceData, Bike } from "../../Device";
-import { DeviceProtocol } from "../../DeviceProtocol";
-import { EventLogger } from "gd-eventlog";
-import SerialComms from "../comms";
-import { Command } from "../../types/command";
-import CyclingMode, { IncyclistBikeData } from "../../CyclingMode";
-import { User } from "../../types/user";
-export interface KettlerRacerCommand extends Command {
-}
-export interface KettlerExtendedBikeData {
-}
-export interface KettlerBikeData {
-    heartrate?: number;
-    cadence?: number;
-    speed?: number;
-    distance?: number;
-    requestedPower?: number;
-    energy?: number;
-    timestamp?: number;
-    time: number;
-    power: number;
-}
-export interface KettlerDeviceSettings extends DeviceSettings {
-    userSettings?: User;
-    bikeSettings?: any;
-    cyclingMode?: CyclingMode;
-}
-export default class KettlerRacerAdapter extends DeviceAdapterBase implements DeviceAdapter, Bike {
-    private id;
-    private ignoreHrm;
-    private ignoreBike;
-    private ignorePower;
-    private logger;
-    private paused;
-    private iv;
-    private requests;
-    private data;
-    private internalData;
-    private kettlerData;
-    private updateBusy;
-    private requestBusy;
-    private comms;
-    private prevDistance;
-    constructor(protocol: DeviceProtocol, settings: KettlerDeviceSettings);
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    setID(id: any): void;
-    getID(): string;
-    getName(): string;
-    getPort(): string;
-    setIgnoreHrm(ignore: boolean): void;
-    setIgnorePower(ignore: boolean): void;
-    setIgnoreBike(ignore: boolean): void;
-    _getComms(): SerialComms<KettlerRacerCommand>;
-    _setComms(comms: SerialComms<KettlerRacerCommand>): void;
-    getLogger(): EventLogger;
-    getUserSettings(): User;
-    getWeight(): number;
-    setComputerMode(): Promise<boolean>;
-    setClientMode(): Promise<boolean>;
-    reset(): Promise<boolean>;
-    getIdentifier(): Promise<string>;
-    getInterface(): Promise<string>;
-    getVersion(): Promise<string>;
-    getCalibration(): Promise<string>;
-    startTraining(): Promise<string>;
-    unknownSN(): Promise<string>;
-    setBaudrate(baudrate: number): Promise<string>;
-    setPower(power: number): Promise<KettlerBikeData>;
-    getExtendedStatus(): Promise<KettlerExtendedBikeData>;
-    getStatus(): Promise<KettlerBikeData>;
-    getDB(): Promise<string>;
-    send(logStr: string, message: string, timeout?: any): Promise<any>;
-    parseExtendedStatus(data: string): KettlerExtendedBikeData;
-    parseStatus(data: string): KettlerBikeData;
-    check(): Promise<boolean>;
-    start(props?: any): Promise<IncyclistBikeData>;
-    startUpdatePull(): void;
-    stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    mapData(bikeData: KettlerBikeData): IncyclistBikeData;
-    transformData(internalData: IncyclistBikeData, bikeData: KettlerBikeData): DeviceData;
-    update(): Promise<void>;
-    sendRequest(request: any): Promise<any>;
-    sendRequests(): Promise<void>;
-    bikeSync(): Promise<void>;
-    sendUpdate(request: any): Promise<unknown>;
-    sendData(): void;
-    refreshRequests(): void;
-    processClientRequest(request: any): Promise<unknown>;
-    waitForOpened(retries?: boolean): Promise<boolean>;
-    waitForClosed(): Promise<boolean>;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setUserSettings(userSettings: any): void;
-    setBikeSettings(bikeSettings: any): void;
-}
+import { DeviceSettings } from "../../protocol";
+import DeviceAdapterBase, { DeviceAdapter, DeviceData, Bike } from "../../device";
+import { DeviceProtocol } from "../../protocol";
+import { EventLogger } from "gd-eventlog";
+import SerialComms from "../comms";
+import { Command } from "../../types/command";
+import CyclingMode, { IncyclistBikeData } from "../../cycling-mode";
+import { User } from "../../types/user";
+export interface KettlerRacerCommand extends Command {
+}
+export interface KettlerExtendedBikeData {
+}
+export interface KettlerBikeData {
+    heartrate?: number;
+    cadence?: number;
+    speed?: number;
+    distance?: number;
+    requestedPower?: number;
+    energy?: number;
+    timestamp?: number;
+    time: number;
+    power: number;
+}
+export interface KettlerDeviceSettings extends DeviceSettings {
+    userSettings?: User;
+    bikeSettings?: any;
+    cyclingMode?: CyclingMode;
+}
+export default class KettlerRacerAdapter extends DeviceAdapterBase implements DeviceAdapter, Bike {
+    private id;
+    private ignoreHrm;
+    private ignoreBike;
+    private ignorePower;
+    private logger;
+    private paused;
+    private iv;
+    private requests;
+    private data;
+    private internalData;
+    private kettlerData;
+    private updateBusy;
+    private requestBusy;
+    private comms;
+    private prevDistance;
+    constructor(protocol: DeviceProtocol, settings: KettlerDeviceSettings);
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    isSame(device: DeviceAdapter): boolean;
+    setID(id: any): void;
+    getID(): string;
+    getName(): string;
+    getPort(): string;
+    setIgnoreHrm(ignore: boolean): void;
+    setIgnorePower(ignore: boolean): void;
+    setIgnoreBike(ignore: boolean): void;
+    _getComms(): SerialComms<KettlerRacerCommand>;
+    _setComms(comms: SerialComms<KettlerRacerCommand>): void;
+    getLogger(): EventLogger;
+    getUserSettings(): User;
+    getWeight(): number;
+    setComputerMode(): Promise<boolean>;
+    setClientMode(): Promise<boolean>;
+    reset(): Promise<boolean>;
+    getIdentifier(): Promise<string>;
+    getInterface(): Promise<string>;
+    getVersion(): Promise<string>;
+    getCalibration(): Promise<string>;
+    startTraining(): Promise<string>;
+    unknownSN(): Promise<string>;
+    setBaudrate(baudrate: number): Promise<string>;
+    setPower(power: number): Promise<KettlerBikeData>;
+    getExtendedStatus(): Promise<KettlerExtendedBikeData>;
+    getStatus(): Promise<KettlerBikeData>;
+    getDB(): Promise<string>;
+    send(logStr: string, message: string, timeout?: any): Promise<any>;
+    parseExtendedStatus(data: string): KettlerExtendedBikeData;
+    parseStatus(data: string): KettlerBikeData;
+    check(): Promise<boolean>;
+    start(props?: any): Promise<IncyclistBikeData>;
+    startUpdatePull(): void;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    mapData(bikeData: KettlerBikeData): IncyclistBikeData;
+    transformData(internalData: IncyclistBikeData, bikeData: KettlerBikeData): DeviceData;
+    update(): Promise<void>;
+    sendRequest(request: any): Promise<any>;
+    sendRequests(): Promise<void>;
+    bikeSync(): Promise<void>;
+    sendUpdate(request: any): Promise<unknown>;
+    sendData(): void;
+    refreshRequests(): void;
+    processClientRequest(request: any): Promise<unknown>;
+    waitForOpened(retries?: boolean): Promise<boolean>;
+    waitForClosed(): Promise<boolean>;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
+    setUserSettings(userSettings: any): void;
+    setBikeSettings(bikeSettings: any): void;
+}