incyclist-devices 1.4.97 → 1.4.100

package/lib/ant/antpwr/AntPWRAdapter.js

@@ -1,252 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __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 AntAdapter_1 = __importDefault(require("../AntAdapter"));
-const utils_1 = require("../utils");
-const floatVal = (d) => d ? parseFloat(d) : d;
-const intVal = (d) => d ? parseInt(d) : d;
-const hex = (v) => Math.abs(v).toString(16).toUpperCase();
-const DEFAULT_START_TIMEOUT = 5000;
-class AntFEAdapter extends AntAdapter_1.default {
-    constructor(DeviceID, port, stick, protocol) {
-        super(protocol);
-        this.logger = new gd_eventlog_1.EventLogger('Ant+PWR');
-        this.logger.logEvent({ message: 'Ant+PWR Adapter created', DeviceID, port });
-        this.deviceID = DeviceID;
-        this.port = port;
-        this.stick = stick;
-        this.deviceData = {
-            DeviceID
-        };
-        this.data = {};
-        this.started = false;
-        this.starting = false;
-        this.connected = false;
-    }
-    isBike() { return true; }
-    isHrm() { return false; }
-    isPower() { return true; }
-    getProfile() {
-        return 'Power Meter';
-    }
-    getName() {
-        return `Ant+PWR ${this.deviceID}`;
-    }
-    getDisplayName() {
-        const { DeviceID, ManId } = this.deviceData;
-        return `${utils_1.getBrand(ManId)} PWR ${DeviceID}`;
-    }
-    onAttached() {
-        this.logger.logEvent({ message: 'Device connected' });
-        this.connected = true;
-    }
-    getLogData(data, excludeList) {
-        const logData = JSON.parse(JSON.stringify(data));
-        excludeList.forEach((key) => {
-            delete logData[key];
-        });
-        return logData;
-    }
-    onDeviceData(deviceData) {
-        if (!this.started || this.isStopped())
-            return;
-        this.deviceData = deviceData;
-        try {
-            if (this.onDataFn && !(this.ignoreBike && this.ignorePower) && !this.paused) {
-                if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
-                    const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
-                    this.logger.logEvent({ message: 'onDeviceData', data: logData });
-                    this.data = this.updateData(this.data, deviceData);
-                    const data = this.transformData(this.data);
-                    this.onDataFn(data);
-                    this.lastUpdate = Date.now();
-                }
-            }
-        }
-        catch (err) {
-        }
-    }
-    onDeviceEvent(data) {
-        try {
-            const cmdInfo = this.currentCmd;
-            if (!cmdInfo)
-                return;
-            const msg = cmdInfo.msg.readUInt8(2);
-            const Constants = this.getProtocol().getAnt().Constants;
-            const { expectedResponse } = cmdInfo;
-            if (data.message === msg) {
-                if (expectedResponse === undefined && data.code === Constants.EVENT_TRANSFER_TX_COMPLETED) {
-                    this.currentCmd.response = { success: true, message: hex(data.message), code: hex(data.code) };
-                    return;
-                }
-                if (expectedResponse === undefined && data.code !== Constants.EVENT_TRANSFER_TX_COMPLETED) {
-                    this.currentCmd.response = { success: false, message: hex(data.message), code: hex(data.code) };
-                    return;
-                }
-            }
-            if (data.message === 1) {
-                if (expectedResponse !== undefined && data.code === expectedResponse) {
-                    this.currentCmd.response = { success: true, message: hex(data.message), code: hex(data.code) };
-                    return;
-                }
-                if (expectedResponse === undefined && (data.code === Constants.EVENT_TRANSFER_TX_COMPLETED || data.code === 3)) {
-                    this.currentCmd.response = { success: true, message: hex(data.message), code: hex(data.code) };
-                    return;
-                }
-                if (data.code === Constants.EVENT_TRANSFER_TX_FAILED || data.code === Constants.EVENT_CHANNEL_COLLISION) {
-                    this.currentCmd.response = { success: false, message: hex(data.message), code: hex(data.code) };
-                    return;
-                }
-            }
-            if (this.currentCmd !== undefined && data.message === Constants.MESSAGE_CHANNEL_ACKNOWLEDGED_DATA && data.code === 31) {
-                this.logger.log("could not send (TRANSFER_IN_PROGRESS)");
-                this.currentCmd.response = { success: false, message: hex(data.message), code: hex(data.code) };
-                return;
-            }
-            this.logger.logEvent({ message: "Incoming Event ", event: { message: hex(data.message), code: hex(data.code) } });
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'Error', fn: 'parseEvent', event: { message: hex(data.message), code: hex(data.code) }, error: err.message || err });
-        }
-    }
-    updateData(data, deviceData) {
-        return;
-        if (data.distanceOffs === undefined)
-            data.distanceOffs = 0;
-        data.speed = (deviceData.VirtualSpeed !== undefined ? deviceData.VirtualSpeed : deviceData.RealSpeed) * 3.6;
-        data.slope = (deviceData.Incline !== undefined ? deviceData.Incline : data.slope);
-        data.power = (deviceData.InstantaneousPower !== undefined ? deviceData.InstantaneousPower : data.power);
-        data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
-        data.heartrate = (deviceData.HeartRate !== undefined ? deviceData.HeartRate : data.heartrate);
-        if (deviceData.Distance !== undefined && deviceData.Distance !== 0) {
-            data.distanceInternal = deviceData.Distance - data.distanceOffs;
-            data.distance = data.distanceInternal / 1000;
-        }
-        else {
-            if (this.lastUpdate && deviceData.Cadence !== undefined && deviceData.Cadence > 0 && data.speed) {
-                const t = (Date.now() - this.lastUpdate) / 1000;
-                const prevDistance = data.distanceInternal || 0;
-                data.distanceInternal = Math.round(data.speed / 3.6 * t) + prevDistance;
-                data.distance = data.distanceInternal / 1000;
-            }
-        }
-        return data;
-    }
-    transformData(bikeData) {
-        return;
-        if (bikeData === undefined)
-            return;
-        let distance = 0;
-        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = intVal(bikeData.distanceInternal - this.distanceInternal);
-        }
-        if (bikeData.distanceInternal !== undefined)
-            this.distanceInternal = bikeData.distanceInternal;
-        let data = {
-            speed: floatVal(bikeData.speed),
-            slope: floatVal(bikeData.slope),
-            power: intVal(bikeData.power),
-            cadence: intVal(bikeData.pedalRpm),
-            heartrate: intVal(bikeData.heartrate),
-            distance,
-            timestamp: Date.now()
-        };
-        if (this.ignorePower) {
-            delete data.power;
-            delete data.cadence;
-        }
-        if (this.ignoreBike) {
-            data = { heartrate: data.heartrate };
-        }
-        if (this.ignoreHrm)
-            delete data.heartrate;
-        return data;
-    }
-    start(props) {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.start.call(this, props);
-            this.logger.logEvent({ message: 'start()', props });
-            const opts = props || {};
-            const { args = {} } = opts;
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                if (this.ignoreBike && this.ignorePower) {
-                    this.logger.logEvent({ message: 'start() not done: bike disabled' });
-                    return resolve(false);
-                }
-                if (this.starting) {
-                    this.logger.logEvent({ message: 'start() not done: bike starting' });
-                    return resolve(false);
-                }
-                if (this.started) {
-                    this.logger.logEvent({ message: 'start() done: bike was already started' });
-                    return resolve(true);
-                }
-                this.starting = true;
-                const Ant = this.getProtocol().getAnt();
-                const protocol = this.getProtocol();
-                let start = Date.now();
-                let timeout = start + (args.timeout || DEFAULT_START_TIMEOUT);
-                const iv = setInterval(() => {
-                    if (Date.now() > timeout) {
-                        clearInterval(iv);
-                        this.starting = false;
-                        reject(new Error('timeout'));
-                    }
-                    if (this.isStopped()) {
-                        clearInterval(iv);
-                        this.starting = false;
-                        reject(new Error('stopped'));
-                    }
-                }, 100);
-                protocol.attachSensors(this, Ant.BicyclePowerSensor, 'powerData')
-                    .then(() => {
-                    this.starting = false;
-                    this.started = true;
-                    clearInterval(iv);
-                    resolve(true);
-                })
-                    .catch(err => reject(err));
-            }));
-        });
-    }
-    stop() {
-        const _super = Object.create(null, {
-            stop: { get: () => super.stop }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.stop.call(this);
-            this.logger.logEvent({ message: 'stop()' });
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.starting = false;
-                return resolve(true);
-                this.started = false;
-                if (this.ignoreHrm)
-                    return resolve(false);
-                try {
-                    const protocol = this.getProtocol();
-                    yield protocol.detachSensor(this);
-                    resolve(true);
-                }
-                catch (err) {
-                    reject(err);
-                }
-            }));
-        });
-    }
-}
-exports.default = AntFEAdapter;

package/lib/daum/PowerMeterCyclingMode.d.ts

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

package/lib/daum/PowerMeterCyclingMode.js

@@ -1,78 +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: "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;
-        this.logger = adapter ? adapter.logger : 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 { slope: 0 };
-    }
-    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 m = this.adapter.getWeight();
-            speed = calculations_1.default.calculateSpeed(m, power, slope);
-            let v = speed / 3.6;
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-            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/daum/classic/ERGCyclingMode.d.ts

@@ -1,23 +0,0 @@
-import { EventLogger } from "gd-eventlog";
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from "../../CyclingMode";
-import DaumClassicAdapter from "./DaumClassicAdapter";
-export default class ERGCyclingMode implements CyclingMode {
-    adapter: DaumClassicAdapter;
-    logger: EventLogger;
-    prevData: IncyclistBikeData;
-    prevRequest: UpdateRequest;
-    prevUpdateTS: number;
-    hasBikeUpdate: boolean;
-    settings: Settings;
-    constructor(adapter: DaumClassicAdapter, props?: Settings);
-    setAdapter(adapter: DaumClassicAdapter): void;
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    setSetting(name: string, value: any): void;
-    getSetting(name: string): any;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
-    caclulateTargetPower(request: any, updateMode?: boolean): any;
-}

package/lib/daum/classic/ERGCyclingMode.js

@@ -1,171 +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 settings = {
-    name: "ERG",
-    description: "Ergometer mode:\n Keeps power constant. Calculates speed based on power and slope",
-    properties: [
-        { name: 'Starting Power', description: 'Starting power in watts', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50 }
-    ]
-};
-class ERGCyclingMode {
-    constructor(adapter, props) {
-        this.prevUpdateTS = 0;
-        this.hasBikeUpdate = false;
-        this.settings = {};
-        this.setAdapter(adapter);
-        this.logger = new gd_eventlog_1.EventLogger('ERGMode');
-    }
-    setAdapter(adapter) {
-        this.adapter = adapter;
-    }
-    getName() {
-        return settings.name;
-    }
-    getDescription() {
-        return settings.description;
-    }
-    getProperties() {
-        return settings.properties;
-    }
-    getProperty(name) {
-        return undefined;
-    }
-    setSetting(name, value) {
-        this.settings[name] = value;
-    }
-    getSetting(name) {
-        const res = this.settings[name];
-        if (res)
-            return res;
-        const prop = this.getProperty(name);
-        if (prop && prop.default)
-            return prop.default;
-        return undefined;
-    }
-    sendBikeUpdate(request) {
-        this.logger.logEvent({ message: "setValues request", request, prev: this.prevRequest });
-        try {
-            if (!request || request.reset || Object.keys(request).length === 0) {
-                this.prevRequest = undefined;
-                return request;
-            }
-            if (request.refresh) {
-                if (this.prevRequest !== undefined && !this.hasBikeUpdate) {
-                    request.slope = this.prevRequest.slope;
-                    request.targetPower = this.prevRequest.targetPower;
-                    request.minPower = this.prevRequest.minPower;
-                    request.maxPower = this.prevRequest.maxPower;
-                    return request;
-                }
-                else {
-                    return this.caclulateTargetPower(request);
-                }
-            }
-            const isSlopeUpdate = request.slope !== undefined && Object.keys(request).length === 1;
-            if (request.targetPower !== undefined) {
-                delete request.slope;
-            }
-            else if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
-                request.targetPower = request.maxPower;
-                delete request.slope;
-            }
-            else {
-                if (request.slope !== undefined || (this.prevData !== undefined && this.prevData.slope !== undefined)) {
-                    request = this.caclulateTargetPower(request, false);
-                }
-                if (request.maxPower !== undefined) {
-                    if (request.targetPower !== undefined && request.targetPower > request.maxPower) {
-                        request.targetPower = request.maxPower;
-                    }
-                }
-                if (request.minPower !== undefined) {
-                    if (request.targetPower !== undefined && request.targetPower < request.minPower) {
-                        request.targetPower = request.minPower;
-                    }
-                }
-            }
-            if (!isSlopeUpdate)
-                this.prevRequest = JSON.parse(JSON.stringify(request));
-        }
-        catch (err) {
-            this.logger.logEvent({ message: "setValues Exception", error: err.message, stack: err.stack });
-        }
-        this.logger.logEvent({ message: "setValues result", data: request });
-        this.hasBikeUpdate = false;
-        return request;
-    }
-    updateData(data) {
-        this.logger.logEvent({ message: "updateData", data });
-        const getSlope = () => {
-            if (data.slope)
-                return data.slope;
-            if (this.prevData && this.prevData.slope)
-                return this.prevData.slope;
-            if (this.prevRequest && this.prevRequest.slope)
-                return this.prevRequest.slope;
-            return 0;
-        };
-        try {
-            const prevData = this.prevData || {};
-            let rpm = data.pedalRpm || 0;
-            let gear = data.gear || 0;
-            let power = data.power || 0;
-            let slope = getSlope();
-            let speed = data.speed || 0;
-            let m = this.adapter.getWeight();
-            let distanceInternal = prevData.distanceInternal || 0;
-            let distance = Math.round(distanceInternal / 100);
-            let ts = Date.now();
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 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 (this.prevData === undefined || gear !== prevData.gear || rpm !== prevData.pedalRpm) {
-                this.hasBikeUpdate = true;
-            }
-            this.prevData = data;
-            this.prevUpdateTS = ts;
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
-        }
-        this.logger.logEvent({ message: "updateData result", data });
-        return data;
-    }
-    caclulateTargetPower(request, updateMode = true) {
-        const bikeType = 'race';
-        const defaultPower = this.getSetting('Starting Power') || 50;
-        const m = this.adapter.getWeight();
-        const prevData = this.prevData || {};
-        if (prevData.pedalRpm !== undefined && prevData.gear !== undefined && (!updateMode || prevData.pedalRpm !== 0)) {
-            var speed = calculations_1.default.calculateSpeedDaum(prevData.gear, prevData.pedalRpm, bikeType);
-            var power = calculations_1.default.calculatePower(m, speed / 3.6, 0);
-            request.targetPower = power;
-        }
-        else {
-            request.targetPower = request.targetPower || defaultPower;
-        }
-        delete request.slope;
-        return request;
-    }
-}
-exports.default = ERGCyclingMode;

package/lib/daum/indoorbike.d.ts

@@ -1,24 +0,0 @@
-import { EventLogger } from 'gd-eventlog';
-export default class IndoorBikeProcessor {
-    bike: any;
-    prevTS: any;
-    prevDistance: any;
-    prevRpm: any;
-    prevSpeed: any;
-    prevGear: any;
-    prevPower: any;
-    prevSlope: any;
-    prevSettings: any;
-    lastUpdate: any;
-    hasBikeUpdate: boolean;
-    logger: EventLogger;
-    constructor(bike: any, opts?: any);
-    reset(): void;
-    setValues(data: any): any;
-    isAccelMode(): any;
-    getSlope(data: any): any;
-    getBikeType(props: any): any;
-    getWeight(props: any): any;
-    getValues(data: any, props?: {}): any;
-    caclulateTargetPower(data: any, updateMode?: boolean): any;
-}