incyclist-devices 1.4.97 → 1.4.100

package/lib/daum/indoorbike.js

@@ -1,178 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const calculations_1 = __importDefault(require("../calculations"));
-const gd_eventlog_1 = require("gd-eventlog");
-const constants_1 = require("./constants");
-const DEFAULT_BIKE_WEIGHT = 10;
-const DEFAULT_USER_WEIGHT = 75;
-class IndoorBikeProcessor {
-    constructor(bike, opts) {
-        const props = opts || {};
-        this.bike = bike;
-        this.logger = props.logger || new gd_eventlog_1.EventLogger('IndoorBike');
-        this.reset();
-    }
-    reset() {
-        this.prevTS = 0;
-        this.prevDistance = 0;
-        this.prevRpm = 0;
-        this.prevSpeed = 0;
-        this.prevPower = 0;
-        this.prevGear = undefined;
-        this.prevSlope = 0;
-        this.prevSettings = undefined;
-        this.hasBikeUpdate = false;
-        this.lastUpdate = {};
-    }
-    setValues(data) {
-        this.logger.logEvent({ message: "setValues request", data, prev: this.prevSettings });
-        try {
-            if (!data || data.reset || Object.keys(data).length === 0) {
-                this.prevSettings = undefined;
-                return data;
-            }
-            if (data.refresh) {
-                if (this.prevSettings !== undefined) {
-                    data.slope = this.prevSettings.slope;
-                    data.targetPower = this.prevSettings.targetPower;
-                    data.minPower = this.prevSettings.minPower;
-                    data.maxPower = this.prevSettings.maxPower;
-                    return data;
-                }
-                else {
-                    return this.caclulateTargetPower(data);
-                }
-            }
-            let updateMode = false;
-            const isSlopeUpdate = data.slope !== undefined && Object.keys(data).length === 1;
-            if (data.targetPower !== undefined) {
-                data.slope = undefined;
-                this.bike.settings.targetPower = data.targetPower;
-            }
-            else if (data.maxPower !== undefined && data.minPower !== undefined && data.maxPower === data.minPower) {
-                data.targetPower = data.maxPower;
-                data.slope = undefined;
-                this.bike.settings.targetPower = data.targetPower;
-            }
-            else {
-                if (data.slope !== undefined || this.prevSlope !== undefined) {
-                    this.bike.settings.slope = data.slope !== undefined ? data.slope : this.prevSlope;
-                    data = this.caclulateTargetPower(data, updateMode);
-                }
-                if (data.maxPower !== undefined) {
-                    this.bike.settings.maxPower = data.maxPower;
-                    if (data.targetPower !== undefined && data.targetPower > data.maxPower) {
-                        data.targetPower = data.maxPower;
-                    }
-                }
-                if (data.minPower !== undefined) {
-                    this.bike.settings.minPower = data.minPower;
-                    if (data.targetPower !== undefined && data.targetPower < data.minPower) {
-                        data.targetPower = data.minPower;
-                    }
-                }
-            }
-            if (!isSlopeUpdate)
-                this.prevSettings = JSON.parse(JSON.stringify(data));
-        }
-        catch (err) {
-            this.logger.logEvent({ message: "setValues Exception", error: err.message, stack: err.stack });
-        }
-        this.logger.logEvent({ message: "setValues result", data });
-        return data;
-    }
-    isAccelMode() {
-        if (!this.bike || !this.bike.settings)
-            return false;
-        return this.bike.settings.accelMode;
-    }
-    getSlope(data) {
-        if (data.slope !== undefined && data.slope !== null)
-            return data.slope;
-        if (!this.bike || !this.bike.settings || !this.bike.settings.slope)
-            return 0;
-        return parseFloat(this.bike.settings.slope.toFixed(1));
-    }
-    getBikeType(props) {
-        if (props.bikeType)
-            return props.bikeType;
-        if (!this.bike || !this.bike.settings || this.bike.settings.bikeType === undefined)
-            return constants_1.ACTUAL_BIKE_TYPE.RACE;
-    }
-    getWeight(props) {
-        if (props.bikeWeight || props.userWeight) {
-            const bikeWeight = props.bikeWeight || DEFAULT_BIKE_WEIGHT;
-            const userWeight = props.userWeight || DEFAULT_USER_WEIGHT;
-            return bikeWeight + userWeight;
-        }
-        if (!this.bike)
-            return DEFAULT_BIKE_WEIGHT + DEFAULT_USER_WEIGHT;
-        return this.bike.getUserWeight() + this.bike.getBikeWeight();
-    }
-    getValues(data, props = {}) {
-        this.logger.logEvent({ message: "getValues request", data });
-        try {
-            let rpm = data.pedalRpm || 0;
-            let gear = data.gear || 0;
-            let power = data.power || 0;
-            let slope = this.getSlope(data);
-            let speed = data.speed || 0;
-            let m = this.getWeight(props);
-            let distanceInternal = this.prevDistance || 0;
-            let distance = Math.round(distanceInternal / 100);
-            let ts = Date.now();
-            let duration = this.prevTS === 0 ? 0 : ((ts - this.prevTS) / 1000);
-            if (rpm === 0 || data.isPedalling === false) {
-                speed = 0;
-                power = 0;
-            }
-            else {
-                speed = calculations_1.default.calculateSpeed(m, power, slope);
-                let v = speed / 3.6;
-                distanceInternal += Math.round(v * duration);
-                distance = Math.round(distanceInternal / 100);
-            }
-            data.speed = parseFloat(speed.toFixed(1));
-            data.power = Math.round(power);
-            data.distanceInternal = Math.round(distanceInternal);
-            data.distance = distance;
-            data.slope = slope;
-            data.pedalRpm = rpm;
-            if (gear !== this.prevGear || (this.lastUpdate.rpm && Math.abs(rpm - this.lastUpdate.rpm) > 2)) {
-                this.hasBikeUpdate = true;
-                this.lastUpdate.rpm = rpm;
-            }
-            this.prevDistance = distanceInternal;
-            this.prevTS = ts;
-            this.prevSpeed = speed;
-            this.prevPower = power;
-            this.prevSlope = slope;
-            this.prevGear = gear;
-            this.prevRpm = rpm;
-        }
-        catch (error) {
-            this.logger.logEvent({ message: 'Error', error });
-        }
-        this.logger.logEvent({ message: "getValues result", data, settings: this.bike.settings });
-        return data;
-    }
-    caclulateTargetPower(data, updateMode = true) {
-        let bike = this.bike;
-        let bikeType = bike.settings.bikeType;
-        let m = bike.getUserWeight() + bike.getBikeWeight();
-        if (this.prevRpm !== undefined && (!updateMode || this.prevRpm !== 0) && this.prevGear !== undefined) {
-            var speed = calculations_1.default.calculateSpeedDaum(this.prevGear, this.prevRpm, bikeType);
-            var power = calculations_1.default.calculatePower(m, speed / 3.6, 0);
-            data.targetPower = power;
-        }
-        else {
-            data.targetPower = this.bike.settings.targetPower || 50;
-        }
-        data.slope = undefined;
-        return data;
-    }
-}
-exports.default = IndoorBikeProcessor;

package/lib/kettler/ergo-racer/modes/power-meter.d.ts

@@ -1,18 +0,0 @@
-import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest, CyclingModeBase } from '../../../CyclingMode';
-import { DeviceAdapter } from '../../../Device';
-export default class PowerMeterCyclingMode extends CyclingModeBase implements CyclingMode {
-    logger: EventLogger;
-    data: IncyclistBikeData;
-    prevRequest: UpdateRequest;
-    prevUpdateTS: number;
-    hasBikeUpdate: boolean;
-    constructor(adapter: DeviceAdapter, props?: Settings);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
-}

package/lib/kettler/ergo-racer/modes/power-meter.js

@@ -1,86 +0,0 @@
-"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 Device_1 = require("../../../Device");
-const calculations_1 = __importDefault(require("../../../calculations"));
-const config = {
-    name: 'PowerMeter',
-    description: 'Power and cadence are taken from device. Speed is calculated from power and current slope\nThis mode will not respect maximum power and/or workout limits',
-    properties: []
-};
-class PowerMeterCyclingMode extends CyclingMode_1.CyclingModeBase {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.prevUpdateTS = 0;
-        this.hasBikeUpdate = false;
-        const a = adapter;
-        this.logger = (a && a.getLogger) ? a.getLogger() : undefined;
-        if (!this.logger)
-            this.logger = new gd_eventlog_1.EventLogger('PowerMeter');
-    }
-    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) {
-        if (request.slope)
-            this.data.slope = request.slope;
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest });
-        this.prevRequest = {};
-        return {};
-    }
-    updateData(data) {
-        try {
-            const prevData = this.data || {};
-            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 distanceInternal = prevData.distanceInternal || 0;
-            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
-                speed = 0;
-                power = 0;
-            }
-            let ts = Date.now();
-            const a = this.adapter;
-            const m = a.getWeight ? a.getWeight() : Device_1.DEFAULT_BIKE_WEIGHT + Device_1.DEFAULT_USER_WEIGHT;
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-            const vPrev = (prevData.speed || 0) / 3.6;
-            const EkinPrev = 1 / 2 * m * vPrev * vPrev;
-            let powerRequired = calculations_1.default.calculatePower(m, vPrev, prevData.slope || 0);
-            const powerDelta = powerRequired - power;
-            const Ekin = EkinPrev - powerDelta * duration;
-            const v = Math.sqrt(2 * Ekin / m);
-            speed = v * 3.6;
-            distanceInternal += Math.round(v * duration);
-            data.speed = parseFloat(speed.toFixed(1));
-            data.power = Math.round(power);
-            data.distanceInternal = Math.round(distanceInternal);
-            data.slope = slope;
-            this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest: {}, prevSpeed: prevData.speed });
-            this.data = JSON.parse(JSON.stringify(data));
-            this.prevUpdateTS = ts;
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
-        }
-        return data;
-    }
-}
-exports.default = PowerMeterCyclingMode;

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

@@ -1,28 +0,0 @@
-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

@@ -1,120 +0,0 @@
-"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;