incyclist-devices 1.4.53 → 1.4.54

package/lib/ant/antfe/AntFEAdapter.d.ts

@@ -1,5 +1,41 @@
+/// <reference types="node" />
 import AntAdapter from '../AntAdapter';
 import { Queue } from '../../utils';
+import CyclingMode, { IncyclistBikeData } from '../../CyclingMode';
+export declare type AntFEDeviceData = {
+    DeviceID: number;
+    Temperature?: number;
+    ZeroOffset?: number;
+    SpinDownTime?: number;
+    EquipmentType?: 'Treadmill' | 'Elliptical' | 'StationaryBike' | 'Rower' | 'Climber' | 'NordicSkier' | 'Trainer' | 'General';
+    ElapsedTime?: number;
+    Distance?: number;
+    RealSpeed?: number;
+    VirtualSpeed?: number;
+    HeartRate?: number;
+    HeartRateSource?: 'HandContact' | 'EM' | 'ANT+';
+    State?: 'OFF' | 'READY' | 'IN_USE' | 'FINISHED';
+    CycleLength?: number;
+    Incline?: number;
+    Resistance?: number;
+    METs?: number;
+    CaloricBurnRate?: number;
+    Calories?: number;
+    _EventCount0x19?: number;
+    Cadence?: number;
+    AccumulatedPower?: number;
+    InstantaneousPower?: number;
+    AveragePower?: number;
+    TrainerStatus?: number;
+    TargetStatus?: 'OnTarget' | 'LowSpeed' | 'HighSpeed';
+    HwVersion?: number;
+    ManId?: number;
+    ModelNum?: number;
+    SwVersion?: number;
+    SerialNumber?: number;
+    PairedDevices?: any[];
+    RawData: Buffer;
+};
 export default class AntFEAdapter extends AntAdapter {
     started: boolean;
     starting: boolean;
@@ -8,6 +44,7 @@ export default class AntFEAdapter extends AntAdapter {
     queue?: Queue<any>;
     workerId?: any;
     currentCmd?: any;
+    cyclingMode: CyclingMode;
     constructor(DeviceID: any, port: any, stick: any, protocol: any);
     isBike(): boolean;
     isHrm(): boolean;
@@ -15,11 +52,15 @@ export default class AntFEAdapter extends AntAdapter {
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;
+    getSupportedCyclingModes(): Array<any>;
+    setCyclingMode(mode: string | CyclingMode, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
     onAttached(): void;
     getLogData(data: any, excludeList: any): any;
-    onDeviceData(deviceData: any): void;
+    onDeviceData(deviceData: AntFEDeviceData): void;
+    mapData(deviceData: AntFEDeviceData): IncyclistBikeData;
     onDeviceEvent(data: any): void;
-    updateData(data: any, deviceData: any): any;
     transformData(bikeData: any): any;
     start(props?: any): Promise<any>;
     stop(): Promise<boolean>;

package/lib/ant/antfe/AntFEAdapter.js

@@ -16,6 +16,8 @@ const gd_eventlog_1 = require("gd-eventlog");
 const AntAdapter_1 = __importDefault(require("../AntAdapter"));
 const utils_1 = require("../utils");
 const utils_2 = require("../../utils");
+const ant_fe_st_mode_1 = __importDefault(require("./ant-fe-st-mode"));
+const ant_fe_erg_mode_1 = __importDefault(require("./ant-fe-erg-mode"));
 const floatVal = (d) => d ? parseFloat(d) : d;
 const intVal = (d) => d ? parseInt(d) : d;
 const hex = (v) => Math.abs(v).toString(16).toUpperCase();
@@ -54,6 +56,34 @@ class AntFEAdapter extends AntAdapter_1.default {
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
         return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}${hrmStr}`;
     }
+    getSupportedCyclingModes() {
+        return [ant_fe_st_mode_1.default, ant_fe_erg_mode_1.default];
+    }
+    setCyclingMode(mode, settings) {
+        let selectedMode;
+        if (typeof mode === 'string') {
+            const supported = this.getSupportedCyclingModes();
+            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
+            if (CyclingModeClass) {
+                this.cyclingMode = new CyclingModeClass(this, settings);
+                return;
+            }
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.cyclingMode = selectedMode;
+        this.cyclingMode.setSettings(settings);
+    }
+    getCyclingMode() {
+        if (!this.cyclingMode)
+            this.cyclingMode = this.getDefaultCyclingMode();
+        return this.cyclingMode;
+    }
+    getDefaultCyclingMode() {
+        return new ant_fe_st_mode_1.default(this);
+    }
     onAttached() {
         this.logger.logEvent({ message: 'Device connected' });
         this.connected = true;
@@ -74,8 +104,9 @@ class AntFEAdapter extends AntAdapter_1.default {
                 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);
+                    let incyclistData = this.mapData(deviceData);
+                    incyclistData = this.getCyclingMode().updateData(incyclistData);
+                    const data = this.transformData(incyclistData);
                     this.onDataFn(data);
                     this.lastUpdate = Date.now();
                 }
@@ -84,6 +115,25 @@ class AntFEAdapter extends AntAdapter_1.default {
         catch (err) {
         }
     }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: undefined,
+            speed: 0,
+            heartrate: 0,
+            distanceInternal: 0,
+            slope: undefined,
+            time: undefined
+        };
+        data.speed = (deviceData.VirtualSpeed !== undefined ? deviceData.VirtualSpeed : (deviceData.RealSpeed || 0)) * 3.6;
+        data.slope = (deviceData.Incline !== undefined ? deviceData.Incline : data.slope);
+        data.power = (deviceData.InstantaneousPower !== undefined ? deviceData.InstantaneousPower : data.power);
+        data.time = (deviceData.ElapsedTime !== undefined ? deviceData.ElapsedTime : data.time);
+        data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
+        data.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
+        return data;
+    }
     onDeviceEvent(data) {
         try {
             const cmdInfo = this.currentCmd;
@@ -127,43 +177,21 @@ class AntFEAdapter extends AntAdapter_1.default {
             this.logger.logEvent({ message: 'Error', fn: 'parseEvent', event: { message: hex(data.message), code: hex(data.code) }, error: err.message || err });
         }
     }
-    updateData(data, deviceData) {
-        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) {
         if (bikeData === undefined)
             return;
         let distance = 0;
         if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = intVal(bikeData.distanceInternal - this.distanceInternal);
+            distance = Math.round(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),
+            speed: bikeData.speed,
+            slope: bikeData.slope,
+            power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
+            cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
+            heartrate: bikeData.heartrate !== undefined ? Math.round(bikeData.heartrate) : undefined,
             distance,
             timestamp: Date.now()
         };
@@ -295,14 +323,17 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: "sendBikeUpdate():", request });
+            if (this.paused)
+                return;
+            const update = this.getCyclingMode().sendBikeUpdate(request);
+            this.logger.logEvent({ message: 'send bike update requested', update, request });
             try {
                 const isReset = (!request || request.reset || Object.keys(request).length === 0);
-                if (request.slope !== undefined) {
-                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
+                if (update.slope !== undefined) {
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(update.slope); }), 2, 100);
                 }
-                if (request.targetPower !== undefined) {
-                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
+                if (update.targetPower !== undefined) {
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(update.targetPower); }), 2, 100);
                 }
                 else if (request.maxPower !== undefined) {
                     if (this.data.power && this.data.power > request.maxPower)

package/lib/ant/antfe/ant-fe-erg-mode.d.ts

@@ -0,0 +1,5 @@
+import BleERGCyclingMode from "../../ble/ble-erg-mode";
+import { DeviceAdapter } from "../../Device";
+export default class AntFeERGCyclingMode extends BleERGCyclingMode {
+    constructor(adapter: DeviceAdapter, props?: any);
+}

package/lib/ant/antfe/ant-fe-erg-mode.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ble_erg_mode_1 = __importDefault(require("../../ble/ble-erg-mode"));
+class AntFeERGCyclingMode extends ble_erg_mode_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('AntERGMode');
+    }
+}
+exports.default = AntFeERGCyclingMode;

package/lib/ant/antfe/ant-fe-st-mode.d.ts

@@ -0,0 +1,7 @@
+import FtmsCyclingMode from "../../ble/ble-st-mode";
+import { UpdateRequest } from "../../CyclingMode";
+import { DeviceAdapter } from "../../Device";
+export default class AntStCyclingMode extends FtmsCyclingMode {
+    constructor(adapter: DeviceAdapter, props?: any);
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/ant/antfe/ant-fe-st-mode.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ble_st_mode_1 = __importDefault(require("../../ble/ble-st-mode"));
+class AntStCyclingMode extends ble_st_mode_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('AntSTMode');
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { gear, pedalRpm, slope, power, speed } = this.data;
+            return { gear, pedalRpm, slope, power, speed };
+        };
+        const event = {};
+        if (this.data === undefined)
+            event.noData = true;
+        if (request.slope !== undefined && (event.noData || Math.abs(request.slope - this.data.slope) >= 0.1))
+            event.slopeUpdate = true;
+        if (this.prevRequest === undefined)
+            event.initialCall = true;
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event });
+        let newRequest = {};
+        if (request.slope === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
+            return this.prevRequest;
+        }
+        if (request.slope !== undefined) {
+            newRequest.slope = parseFloat(request.slope.toFixed(1));
+            this.data.slope = newRequest.slope;
+        }
+        if (request.targetPower !== undefined) {
+            newRequest.targetPower = request.targetPower;
+        }
+        if (request.minPower && request.maxPower && request.minPower === request.maxPower) {
+            newRequest.targetPower = request.minPower;
+        }
+        const prevData = this.data;
+        if (newRequest.targetPower === undefined && prevData && prevData.power) {
+            if (request.minPower !== undefined && prevData.power < request.minPower)
+                newRequest.targetPower = request.minPower;
+            if (request.maxPower !== undefined && prevData.power > request.maxPower)
+                newRequest.targetPower = request.maxPower;
+        }
+        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        return newRequest;
+    }
+}
+exports.default = AntStCyclingMode;

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

@@ -1,12 +1,12 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import { DeviceAdapter } from "../Device";
 import PowerBasedCyclingModeBase from "../modes/power-base";
-import { FmAdapter } from "./fm";
 export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
     chain: number[];
     cassette: number[];
-    constructor(adapter: FmAdapter, props?: any);
+    constructor(adapter: DeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

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

@@ -1,10 +1,10 @@
 import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import { DeviceAdapter } from "../Device";
 import PowerBasedCyclingModeBase from "../modes/power-base";
-import { FmAdapter } from "./fm";
 export default class FtmsCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
     prevRequest: UpdateRequest;
     hasBikeUpdate: boolean;
-    constructor(adapter: FmAdapter, props?: any);
+    constructor(adapter: DeviceAdapter, props?: any);
     getName(): string;
     getDescription(): string;
     getProperties(): CyclingModeProperty[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.53",
+  "version": "1.4.54",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",