incyclist-devices 1.5.10 → 1.5.12

package/lib/ble/ble-erg-mode.d.ts

@@ -1,18 +1,18 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../cycling-mode";
-import { DeviceAdapter } from "../device";
-import PowerBasedCyclingModeBase from "../modes/power-base";
-export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    static isERG: boolean;
-    prevRequest: UpdateRequest;
-    hasBikeUpdate: boolean;
-    chain: number[];
-    cassette: number[];
-    constructor(adapter: DeviceAdapter, props?: any);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(bikeData: IncyclistBikeData): any;
-}
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../cycling-mode";
+import { DeviceAdapter } from "../device";
+import PowerBasedCyclingModeBase from "../modes/power-base";
+export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    static isERG: boolean;
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    constructor(adapter: DeviceAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+}

package/lib/ble/ble-erg-mode.js

@@ -1,132 +1,132 @@
-"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 config = {
-    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: 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 MIN_SPEED = 10;
-class BleERGCyclingMode extends power_base_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.hasBikeUpdate = false;
-        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;
-                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;
-            }
-            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 = BleERGCyclingMode;
-BleERGCyclingMode.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 config = {
+    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: 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 MIN_SPEED = 10;
+class BleERGCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.hasBikeUpdate = false;
+        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;
+                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;
+            }
+            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 = BleERGCyclingMode;
+BleERGCyclingMode.isERG = true;

package/lib/ble/ble-interface.d.ts

@@ -1,100 +1,100 @@
-/// <reference types="node" />
-import { EventLogger } from 'gd-eventlog';
-import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BlePeripheral, BleBinding, BleCharacteristic, BleDeviceDescription } from './ble';
-export interface ScanState {
-    isScanning: boolean;
-    isConnecting: boolean;
-    isBackgroundScan: boolean;
-    timeout?: NodeJS.Timeout;
-}
-export interface ConnectState {
-    isConnecting: boolean;
-    isConnected: boolean;
-    timeout?: NodeJS.Timeout;
-    isInitSuccess: boolean;
-}
-export interface PeripheralState {
-    isLoading: boolean;
-    isConfigured: boolean;
-    isInterrupted: boolean;
-}
-export interface BleDeviceInfo {
-    device: BleDeviceClass;
-    isConnected: boolean;
-}
-export interface BleDeviceClassInfo {
-    Class: typeof BleDeviceClass;
-    type: string;
-    services: string[];
-    id: string;
-}
-export interface PeripheralCacheItem {
-    address: string;
-    ts: number;
-    peripheral: BlePeripheral;
-    state?: PeripheralState;
-    characteristics?: BleCharacteristic[];
-}
-export default class BleInterface extends BleInterfaceClass {
-    scanState: ScanState;
-    connectState: ConnectState;
-    devices: BleDeviceInfo[];
-    peripheralCache: any[];
-    logger: EventLogger;
-    static deviceClasses: BleDeviceClassInfo[];
-    static _instance: BleInterface;
-    static getInstance(props?: {
-        binding?: BleBinding;
-        log?: boolean;
-        logger?: EventLogger;
-    }): BleInterface;
-    constructor(props?: {
-        binding?: BleBinding;
-        log?: boolean;
-        logger?: EventLogger;
-    });
-    static register(id: string, type: string, Class: typeof BleDeviceClass, services: string[]): void;
-    logEvent(event: any): void;
-    onStateChange(state: any): void;
-    onError(err: any): void;
-    connect(props?: ConnectProps): Promise<boolean>;
-    disconnect(): Promise<boolean>;
-    isConnected(): boolean;
-    getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
-    getAllSupportedServices(): any[];
-    getAllSupportedDeviceTypes(): (typeof BleDeviceClass)[];
-    getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
-    getServicesFromDevice(device: BleDeviceClass): string[];
-    waitForConnectFinished(timeout: any): Promise<unknown>;
-    addPeripheralToCache(peripheral: any, props?: {}): void;
-    onDisconnect(peripheral: any): void;
-    getConnector(peripheral: BlePeripheral): any;
-    findPeripheral(peripheral: BlePeripheral | {
-        id?: string;
-        address?: string;
-        name?: string;
-    }): BlePeripheral;
-    getCharacteristics(peripheral: any): Promise<any>;
-    getDeviceClasses(peripheral: any, props?: {
-        deviceTypes?: (typeof BleDeviceClass)[];
-        profile?: string;
-        services?: string[];
-    }): (typeof BleDeviceClass)[];
-    createDevice(DeviceClass: (typeof BleDeviceClass), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): BleDeviceClass;
-    connectDevice(requested: BleDeviceClass | BleDeviceDescription, timeout?: number): Promise<BleDeviceClass>;
-    waitForScanFinished(timeout: any): Promise<unknown>;
-    getBestDeviceMatch(DeviceClasses: (typeof BleDeviceClass)[]): typeof BleDeviceClass;
-    scan(props: ScanProps): Promise<BleDeviceClass[]>;
-    stopScan(): Promise<boolean>;
-    isScanning(): boolean;
-    addConnectedDevice(device: BleDeviceClass): void;
-    addDeviceToCache(device: BleDeviceClass, isConnected: boolean): void;
-    findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
-    findDeviceInCache(device: {
-        id?: string;
-        address?: string;
-        name?: string;
-        profile: string;
-    }): BleDeviceClass;
-    removeConnectedDevice(device: BleDeviceClass): void;
-}
+/// <reference types="node" />
+import { EventLogger } from 'gd-eventlog';
+import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BlePeripheral, BleBinding, BleCharacteristic, BleDeviceDescription } from './ble';
+export interface ScanState {
+    isScanning: boolean;
+    isConnecting: boolean;
+    isBackgroundScan: boolean;
+    timeout?: NodeJS.Timeout;
+}
+export interface ConnectState {
+    isConnecting: boolean;
+    isConnected: boolean;
+    timeout?: NodeJS.Timeout;
+    isInitSuccess: boolean;
+}
+export interface PeripheralState {
+    isLoading: boolean;
+    isConfigured: boolean;
+    isInterrupted: boolean;
+}
+export interface BleDeviceInfo {
+    device: BleDeviceClass;
+    isConnected: boolean;
+}
+export interface BleDeviceClassInfo {
+    Class: typeof BleDeviceClass;
+    type: string;
+    services: string[];
+    id: string;
+}
+export interface PeripheralCacheItem {
+    address: string;
+    ts: number;
+    peripheral: BlePeripheral;
+    state?: PeripheralState;
+    characteristics?: BleCharacteristic[];
+}
+export default class BleInterface extends BleInterfaceClass {
+    scanState: ScanState;
+    connectState: ConnectState;
+    devices: BleDeviceInfo[];
+    peripheralCache: any[];
+    logger: EventLogger;
+    static deviceClasses: BleDeviceClassInfo[];
+    static _instance: BleInterface;
+    static getInstance(props?: {
+        binding?: BleBinding;
+        log?: boolean;
+        logger?: EventLogger;
+    }): BleInterface;
+    constructor(props?: {
+        binding?: BleBinding;
+        log?: boolean;
+        logger?: EventLogger;
+    });
+    static register(id: string, type: string, Class: typeof BleDeviceClass, services: string[]): void;
+    logEvent(event: any): void;
+    onStateChange(state: any): void;
+    onError(err: any): void;
+    connect(props?: ConnectProps): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
+    getAllSupportedServices(): any[];
+    getAllSupportedDeviceTypes(): (typeof BleDeviceClass)[];
+    getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
+    getServicesFromDevice(device: BleDeviceClass): string[];
+    waitForConnectFinished(timeout: any): Promise<unknown>;
+    addPeripheralToCache(peripheral: any, props?: {}): void;
+    onDisconnect(peripheral: any): void;
+    getConnector(peripheral: BlePeripheral): any;
+    findPeripheral(peripheral: BlePeripheral | {
+        id?: string;
+        address?: string;
+        name?: string;
+    }): BlePeripheral;
+    getCharacteristics(peripheral: any): Promise<any>;
+    getDeviceClasses(peripheral: any, props?: {
+        deviceTypes?: (typeof BleDeviceClass)[];
+        profile?: string;
+        services?: string[];
+    }): (typeof BleDeviceClass)[];
+    createDevice(DeviceClass: (typeof BleDeviceClass), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): BleDeviceClass;
+    connectDevice(requested: BleDeviceClass | BleDeviceDescription, timeout?: number): Promise<BleDeviceClass>;
+    waitForScanFinished(timeout: any): Promise<unknown>;
+    getBestDeviceMatch(DeviceClasses: (typeof BleDeviceClass)[]): typeof BleDeviceClass;
+    scan(props: ScanProps): Promise<BleDeviceClass[]>;
+    stopScan(): Promise<boolean>;
+    isScanning(): boolean;
+    addConnectedDevice(device: BleDeviceClass): void;
+    addDeviceToCache(device: BleDeviceClass, isConnected: boolean): void;
+    findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
+    findDeviceInCache(device: {
+        id?: string;
+        address?: string;
+        name?: string;
+        profile: string;
+    }): BleDeviceClass;
+    removeConnectedDevice(device: BleDeviceClass): void;
+}