incyclist-devices 2.2.8 → 2.2.10-beta.0

package/lib/antv2/base/adapter.js

@@ -438,8 +438,10 @@ class AntAdapter extends adpater_1.default {
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             let stopped;
-            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.internalEmitter.emit('stop');
+            if (this.stopped)
+                return;
+            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.promiseWaitForData = null;
             if (this.startStatus) {
                 this.startStatus.interrupted = true;

package/lib/antv2/base/interface.d.ts

@@ -45,6 +45,8 @@ export default class AntInterface extends EventEmitter implements IncyclistInter
     scannerWaitForConnection(): Promise<void>;
     scan(props?: AntScanProps): Promise<AntDeviceSettings[]>;
     isScanning(): boolean;
+    protected stopAllSensors(sensors: Array<ISensor>): Promise<void>;
+    protected stopDevices(detected: AntDeviceSettings[]): Promise<void>;
     stopScan(): Promise<boolean>;
     startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
     private blockChannel;

package/lib/antv2/base/interface.js

@@ -16,6 +16,7 @@ const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
 const sensor_factory_1 = __importDefault(require("../factories/sensor-factory"));
 const utils_1 = require("../../utils/utils");
+const incyclist_devices_1 = require("incyclist-devices");
 class AntInterface extends events_1.default {
     static getInstance(props = {}) {
         if (AntInterface._instance === undefined)
@@ -237,6 +238,8 @@ class AntInterface extends events_1.default {
                 this.activeScan.emitter.on('stop', () => __awaiter(this, void 0, void 0, function* () {
                     this.activeScan.emitter.removeAllListeners();
                     this.emit('stop-scan');
+                    yield this.stopDevices(detected);
+                    yield this.stopAllSensors(sensors);
                     const stopped = yield this.activeScan.channel.stopScanner();
                     this.logEvent({ message: 'scan stopped' });
                     removeListeners(channel);
@@ -276,6 +279,38 @@ class AntInterface extends events_1.default {
     isScanning() {
         return this.scanPromise !== undefined && this.scanPromise !== null;
     }
+    stopAllSensors(sensors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stopping all sensors ' });
+            let promises = [];
+            sensors.forEach((sensor) => {
+                promises.push(this.stopSensor(sensor).catch(err => {
+                    var _a;
+                    this.logger.logEvent({ message: 'could not stop sensor', error: err.message, channel: (_a = sensor.getChannel()) === null || _a === void 0 ? void 0 : _a.getChannelNo(), stack: err.stack });
+                }));
+            });
+            if (promises.length > 0) {
+                yield Promise.allSettled(promises);
+            }
+            this.logger.logEvent({ message: 'sensors stopped' });
+        });
+    }
+    stopDevices(detected) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stopping devices' });
+            let promises = [];
+            detected.forEach((settings) => {
+                const adapter = incyclist_devices_1.AdapterFactory.create(settings);
+                promises.push(adapter.stop().catch(err => {
+                    this.logger.logEvent({ message: 'could not stop device', error: err.message, deviceID: settings.deviceID, stack: err.stack });
+                }));
+            });
+            if (promises.length > 0) {
+                yield Promise.allSettled(promises);
+            }
+            this.logger.logEvent({ message: 'devices stopped' });
+        });
+    }
     stopScan() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'stopping scan ..' });
@@ -348,7 +383,7 @@ class AntInterface extends events_1.default {
                 return true;
             }
             const channel = sensor.getChannel();
-            if (channel) {
+            if (channel !== undefined) {
                 try {
                     if (!channel.flush) {
                         this.logEvent({ message: 'old version of ant-channel detected' });
@@ -371,8 +406,7 @@ class AntInterface extends events_1.default {
                 }
             }
             else {
-                this.logEvent({ message: 'could not stop sensor', deviceID: sensor.getDeviceID(), error: 'no channel attached' });
-                return false;
+                return true;
             }
         });
     }

package/lib/modes/antble-smarttrainer.d.ts

@@ -1,7 +1,13 @@
-import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+import ICyclingMode, { CyclingModeProperyType, IVirtualShifting, UpdateRequest } from "./types";
 import PowerBasedCyclingModeBase from "./power-base";
 import { IAdapter } from "../types";
-export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+export type GearConfigEntry = {
+    chainConfig: number[];
+    cassetteConfig: number[];
+    wheelCirc: number;
+    numGears: number;
+};
+export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode, IVirtualShifting {
     protected static config: {
         name: string;
         isSIM: boolean;
@@ -26,10 +32,18 @@ export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase i
             options?: undefined;
         })[];
     };
+    protected gear: any;
     constructor(adapter: IAdapter, props?: any);
     getBikeInitRequest(): UpdateRequest;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
     protected checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;
     protected checkEmptyRequest(newRequest: UpdateRequest): void;
     sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+    initGears(): Promise<number>;
+    gearUp(numGears: number): Promise<number>;
+    protected switchGear: (gear: any, prevGear: any) => number;
+    protected findBestGear(): any;
+    getCurrentGearConfig(): GearConfigEntry;
+    protected getDefaultCadence(): number;
+    protected getDefaultPower(): number;
 }

package/lib/modes/antble-smarttrainer.js

@@ -1,13 +1,45 @@
 "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 types_1 = require("./types");
 const power_base_1 = __importDefault(require("./power-base"));
+const calculations_1 = __importDefault(require("../utils/calculations"));
+const NUM_GEARS = 30;
+const GearConfig = {
+    race: { chainConfig: [34, 50], cassetteConfig: [11, 36], wheelCirc: 2125, numGears: NUM_GEARS },
+    mountain: { chainConfig: [26, 36], cassetteConfig: [10, 44], wheelCirc: 2344, numGears: NUM_GEARS },
+    triathlon: { chainConfig: [36, 52], cassetteConfig: [11, 30], wheelCirc: 2125, numGears: NUM_GEARS },
+};
 class SmartTrainerCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
+        this.switchGear = (gear, prevGear) => {
+            var _a;
+            const { chainConfig, cassetteConfig, wheelCirc, numGears } = this.getCurrentGearConfig();
+            const { pedalRpm, speed, power, slope } = (_a = this.getData()) !== null && _a !== void 0 ? _a : {};
+            const m = this.getWeight();
+            let cadence = pedalRpm !== null && pedalRpm !== void 0 ? pedalRpm : this.getDefaultCadence();
+            let currentPower = power !== null && power !== void 0 ? power : this.getDefaultPower();
+            const prevGearSpeed = calculations_1.default.calculateSpeedBike(prevGear, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
+            const targetGearSpeed = calculations_1.default.calculateSpeedBike(gear, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
+            const targetGearPower = calculations_1.default.calculatePower(m, targetGearSpeed / 3.6, 0);
+            const prevGearPower = calculations_1.default.calculatePower(m, prevGearSpeed / 3.6, 0);
+            const targetPower = currentPower + (targetGearPower - prevGearPower);
+            const slopeTarget = calculations_1.default.calculateSlope(m, targetPower, speed / 3.6);
+            console.log('Gear', gear, 'power', targetPower, 'speed', speed.toFixed(1), 'slope', slope.toFixed(1), 'virtual slope', slopeTarget.toFixed(1));
+            return slopeTarget;
+        };
         this.initLogger('SmartTrainerMode');
     }
     getBikeInitRequest() {
@@ -28,11 +60,16 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             newRequest.slope = parseFloat(request.slope.toFixed(1));
             this.data.slope = newRequest.slope;
             try {
+                if (this.gear !== undefined) {
+                    const slopeTarget = this.switchGear(this.gear, this.gear);
+                    newRequest.slope = slopeTarget;
+                }
                 const slopeAdj = this.getSetting('slopeAdj');
                 if (slopeAdj !== undefined)
                     newRequest.slope = newRequest.slope * slopeAdj / 100;
             }
-            catch (_a) {
+            catch (err) {
+                this.logger.logEvent({ message: "error", fn: '', error: err.message, request, prev: this.prevRequest, data: this.getData() });
             }
         }
     }
@@ -61,6 +98,66 @@ class SmartTrainerCyclingMode extends power_base_1.default {
         }
         return newRequest;
     }
+    initGears() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.gear = this.findBestGear();
+            return this.gear;
+        });
+    }
+    gearUp(numGears) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let target = this.gear + numGears;
+            if (target > NUM_GEARS)
+                target = NUM_GEARS;
+            if (target < 1)
+                target = 1;
+            this.gear = target;
+            return this.gear;
+        });
+    }
+    findBestGear() {
+        var _a;
+        const { chainConfig, cassetteConfig, wheelCirc, numGears } = this.getCurrentGearConfig();
+        const { pedalRpm, speed, power, slope } = (_a = this.getData()) !== null && _a !== void 0 ? _a : {};
+        const m = this.getWeight();
+        let cadence = pedalRpm !== null && pedalRpm !== void 0 ? pedalRpm : this.getDefaultCadence();
+        let currentPower = power !== null && power !== void 0 ? power : this.getDefaultPower();
+        let minDiff, gearInitial;
+        if (speed === 0) {
+            const speedInitial = calculations_1.default.calculateSpeed(m, currentPower, slope);
+            for (let i = 1; i <= numGears; i++) {
+                const speed = calculations_1.default.calculateSpeedBike(i, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
+                const diff = Math.abs(speed - speedInitial);
+                if (!minDiff || diff < minDiff) {
+                    minDiff = diff;
+                    gearInitial = i;
+                }
+            }
+        }
+        else {
+            for (let i = 1; i <= numGears; i++) {
+                const speed = calculations_1.default.calculateSpeedBike(i, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
+                const targetPower = calculations_1.default.calculatePower(m, speed / 3.6, slope);
+                const diff = Math.abs(currentPower - targetPower);
+                if (!minDiff || diff < minDiff) {
+                    minDiff = diff;
+                    gearInitial = i;
+                }
+            }
+        }
+        return gearInitial;
+    }
+    getCurrentGearConfig() {
+        var _a;
+        const type = (_a = this.getSetting('bikeType')) !== null && _a !== void 0 ? _a : 'Race';
+        return GearConfig[type.toLowerCase()];
+    }
+    getDefaultCadence() {
+        return 90;
+    }
+    getDefaultPower() {
+        return 120;
+    }
 }
 SmartTrainerCyclingMode.config = {
     name: "Smart Trainer",

package/lib/modes/types.d.ts

@@ -47,6 +47,10 @@ export default interface ICyclingMode {
     setModeProperty(name: string, value: any): void;
     getModeProperty(name: string): any;
 }
+export interface IVirtualShifting {
+    initGears(): Promise<number>;
+    gearUp(numGears: number): Promise<number>;
+}
 export type CyclingModeConfig = {
     isERG?: boolean;
     isSIM?: boolean;
@@ -69,7 +73,7 @@ export declare class CyclingMode implements ICyclingMode {
     getSetting(_name: string): void;
     getSettings(): Settings;
     setModeProperty(_name: string, _value: any): void;
-    getModeProperty(_name: string): void;
+    getModeProperty(_name: string): any;
     getConfig(): CyclingModeConfig;
     isERG(): boolean;
     isSIM(): boolean;

package/lib/utils/calculations.d.ts

@@ -3,6 +3,7 @@ export declare class IllegalArgumentException extends Error {
 }
 export default class C {
     static calculateSpeed(m: number, power: number, slope: number, props?: any): number;
+    static calculateSlope(m: number, P: number, v: number, props?: any): number;
     static calculatePower(m: number, v: number, slope: number, props?: any): number;
     static calculateSpeedDaum(gear: number, rpm: number, bikeType?: string | number): number;
     static calculateSpeedBike(gear: number, rpm: number, chain: number[], cassette: number[], props?: {

package/lib/utils/calculations.js

@@ -19,13 +19,14 @@ class IllegalArgumentException extends Error {
 exports.IllegalArgumentException = IllegalArgumentException;
 class C {
     static calculateSpeed(m, power, slope, props = {}) {
+        var _a, _b, _c, _d;
         if (m === undefined || m === null || m < 0)
             throw new IllegalArgumentException("m must be a positive number");
         if (power === undefined || power === null || power < 0)
             throw new IllegalArgumentException("power must be a positive number");
-        const _rho = props.rho || rho;
-        const _cRR = props.cRR || cRR;
-        const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
+        const _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
+        const _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
+        const _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : ((_d = cwABike[props.bikeType || 'race']) !== null && _d !== void 0 ? _d : cwABike.race);
         let sl = Math.atan(slope / 100);
         let c1 = 0.5 * _rho * _cwA;
         let c2 = (sl + _cRR) * m * g;
@@ -58,14 +59,29 @@ class C {
         }
         return 0;
     }
+    static calculateSlope(m, P, v, props = {}) {
+        var _a, _b, _c;
+        if (m === undefined || m === null || m < 0)
+            throw new IllegalArgumentException("m must be a positive number");
+        if (P === undefined || P === null || P < 0)
+            throw new IllegalArgumentException("power must be a positive number");
+        if (v === undefined || v === null || v === 0)
+            throw new IllegalArgumentException("v must be a positive number");
+        const _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
+        const _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
+        const _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : (cwABike[props.bikeType || 'race'] || cwABike.race);
+        const sl = (P - (0.5 * _rho * _cwA) * Math.pow(v, 3.0)) / (m * g * v) - _cRR;
+        return Math.tan(Math.asin(sl)) * 100;
+    }
     static calculatePower(m, v, slope, props = {}) {
+        var _a, _b, _c;
         if (m === undefined || m === null || m < 0)
             throw new IllegalArgumentException("m must be a positive number");
         if (v === undefined || v === null || v < 0)
             throw new IllegalArgumentException("v must be a positive number");
-        let _rho = props.rho || rho;
-        let _cRR = props.cRR || cRR;
-        let _cwA = props.cwA || cwABike[props.bikeType || 'race'];
+        let _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
+        let _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
+        let _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : cwABike[props.bikeType || 'race'];
         let sl = Math.sin(Math.atan(slope / 100));
         let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
         return P;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.2.8",
+  "version": "2.2.10-beta.0",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",