incyclist-devices 1.2.0 → 1.4.0

package/lib/ant/utils.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBrand = void 0;
-exports.getBrand = (manId) => {
+const getBrand = (manId) => {
     if (manId === undefined)
         return "ANT+";
     switch (manId) {
@@ -20,3 +20,4 @@ exports.getBrand = (manId) => {
             return "ANT+";
     }
 };
+exports.getBrand = getBrand;

package/lib/calculations.d.ts

@@ -1,14 +1,13 @@
-export default class Calculations {
-    static calculateSpeed(m: any, power: any, slope: any): any;
-    static calculateAccelSpeed(m: any, power: any, slope: any, speedPrev: any, t: any): number;
-    static calculateSpeedUncachedOld(m: any, power: any, slope: any): number;
-    static calculateSpeedUncached(m: any, power: any, slope: any): number;
-    static calculatePower(m: any, v: any, slope: any): number;
-    static calculateForce(m: any, v: any, slope: any): number;
-    static calculatePowerAccelaration(m: any, a: any, v: any): number;
-    static calculatePowerResistance(m: any, v: any, slope: any): number;
-    static crankPower(rpm: any, torque: any): number;
-    static crankTorque(rpm: any, power: any): number;
-    static crankRPM(power: any, torque: any): number;
-    static calculateSpeedDaum(gear: any, rpm: any, bikeType: any): number;
+export declare class IllegalArgumentException extends Error {
+    constructor(message: any);
 }
+export default class C {
+    static calculateSpeed(m: number, power: number, slope: 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?: {
+        numGears?: number;
+        wheelCirc?: number;
+    }): number;
+}
+export declare function solveCubic(p: any, q: any): any[];

package/lib/calculations.js

@@ -1,121 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const POS_BREMSGRIFF = 1;
-const POS_TRIATHLON = 3;
-let crX = 0.0033;
-let g = 9.80665;
-let clOL = 0.4594;
-let cOL = 0.05;
-let clUL = 0.3218;
-let cUL = 0.05;
-let clTri = 0.325;
-let cTri = 0.017;
-let airDensity = 1.2041;
-let rho = airDensity;
-let cWAs = [0.45, 0.35, 0.30, 0.25];
-let k = 0.01090;
-let cRR = 0.0036;
-var _speedCache = {};
-class Calculations {
-    static calculateSpeed(m, power, slope) {
-        var speed = undefined;
-        let key = Math.round(m) * 1000000 + Math.round(power) * 1000 + Math.round(slope * 10);
-        speed = _speedCache[key];
-        if (speed !== undefined)
-            return speed;
-        speed = this.calculateSpeedUncached(m, power, slope);
-        _speedCache[key] = speed;
-        return speed;
+exports.solveCubic = exports.IllegalArgumentException = void 0;
+const g = 9.80665;
+const rho = 1.2041;
+const cwABike = {
+    race: 0.35,
+    triathlon: 0.29,
+    mountain: 0.57
+};
+const k = 0.01090;
+const cRR = 0.0036;
+class IllegalArgumentException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "IllegalArgumentException";
     }
-    static calculateAccelSpeed(m, power, slope, speedPrev, t) {
-        let vPrev = speedPrev / 3.6;
-        let Pres = Calculations.calculatePower(m, vPrev, slope);
-        var P = power - Pres;
-        if (P > 0) {
-            let a = Math.sqrt(P / (m * t));
-            let v = vPrev + a * t;
-            return v * 3.6;
-        }
-        else {
-            P = P * -1;
-            let a = Math.sqrt(P / (m * t));
-            let v = vPrev - a * t;
-            return v * 3.6;
-        }
-    }
-    static calculateSpeedUncachedOld(m, power, slope) {
-        let c = cTri;
-        let cl = clTri;
-        let cr = crX;
-        let sl = Math.atan(slope / 100);
-        if (slope < 0) {
-            let crDyn = 0.1 * Math.cos(sl);
-            cl = clUL;
-            c = cUL;
-            cr = (1 + crDyn) * cr;
-        }
-        if (slope < -2) {
-            let crDyn = 0.1 * Math.cos(sl);
-            cl = clOL;
-            c = cOL;
-            cr = (1 + crDyn) * cr;
-        }
-        let c1 = 1.0 / (1.0 - c);
-        let a = m * g * (sl + cr) * c1;
-        let b = cl / 2.0 * c1;
-        let p = a / b;
-        let q = -1.0 * power / b;
-        var z = solveCubic(p, q);
-        if (z.length > 0) {
-            for (var i = 0; i < z.length; i++)
-                if (z[i] > 0)
-                    return z[i] * 3.6;
-        }
-        return 0;
-    }
-    static calculateSpeedUncached(m, power, slope) {
+}
+exports.IllegalArgumentException = IllegalArgumentException;
+class C {
+    static calculateSpeed(m, power, slope, props = {}) {
+        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");
+        if (slope === undefined || slope === null)
+            slope = 0;
+        const _rho = props.rho || rho;
+        const _cRR = props.cRR || cRR;
+        const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.atan(slope / 100);
-        let c1 = 0.5 * rho * cwA(slope) + 2 * k;
-        let c2 = (sl + cRR) * m * g;
+        let c1 = 0.5 * _rho * _cwA + 2 * k;
+        let c2 = (sl + _cRR) * m * g;
         let p = c2 / c1;
         let q = -1.0 * power / c1;
-        var z = solveCubic(p, q);
-        if (z.length > 0) {
-            for (var i = 0; i < z.length; i++)
-                if (z[i] > 0)
-                    return z[i] * 3.6;
+        var v = solveCubic(p, q).filter(value => value >= 0);
+        if (v.length === 1)
+            return v[0] * 3.6;
+        if (v.length > 1) {
+            if (props.previous) {
+                let speed = undefined;
+                let minDiff = undefined;
+                v.forEach(s => {
+                    if (!minDiff) {
+                        minDiff = Math.abs(s - props.previous);
+                        speed = s;
+                        return;
+                    }
+                    const diff = Math.abs(s - props.previous);
+                    if (diff < minDiff) {
+                        minDiff = diff;
+                        speed = s;
+                    }
+                });
+                return speed * 3.6;
+            }
+            for (var i = 0; i < v.length; i++)
+                if (v[i] > 0)
+                    return v[i] * 3.6;
         }
         return 0;
     }
-    static calculatePower(m, v, slope) {
+    static calculatePower(m, v, slope, props = {}) {
+        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");
+        if (slope === undefined || slope === null)
+            slope = 0;
+        let _rho = props.rho || rho;
+        let _cRR = props.cRR || cRR;
+        let _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.sin(Math.atan(slope / 100));
-        let P = (0.5 * rho * cwA(slope) + 2 * k) * Math.pow(v, 3.0) + (sl + cRR) * m * g * v;
+        let P = (0.5 * _rho * _cwA + 2 * k) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
         return P;
     }
-    static calculateForce(m, v, slope) {
-        let sl = Math.sin(Math.atan(slope / 100));
-        let F = (0.5 * rho * cwA(slope) + 2 * k) * Math.pow(v, 3.0) + (sl + cRR) * m * g * v;
-        return F;
-    }
-    static calculatePowerAccelaration(m, a, v) {
-        let P = m * a * v;
-        return P;
-    }
-    static calculatePowerResistance(m, v, slope) {
-        let P = (0.5 * rho * cwA(slope) + 2 * k) * Math.pow(v, 3.0) + cRR * m * g * v;
-        return P;
-    }
-    static crankPower(rpm, torque) {
-        return torque * rpm * 2 * Math.PI / 60.0;
-    }
-    static crankTorque(rpm, power) {
-        return power / (rpm * 2 * Math.PI / 60.0);
-    }
-    static crankRPM(power, torque) {
-        return power * 60 / (2 * Math.PI * torque);
-    }
     static calculateSpeedDaum(gear, rpm, bikeType) {
-        if (bikeType === 0 || bikeType === undefined || bikeType === "race") {
+        if (bikeType === 0 || bikeType === undefined || bikeType === "race" || bikeType === 'triathlon') {
             let lengthRPM = 210;
             let gearRatio = 1.75 + (gear - 1) * 0.098767;
             let distRotation = lengthRPM * gearRatio;
@@ -130,18 +90,23 @@ class Calculations {
             return speed;
         }
     }
-}
-exports.default = Calculations;
-function cwA(slope) {
-    let cw = cWAs[POS_TRIATHLON];
-    if (slope <= -5)
-        cw = cWAs[POS_BREMSGRIFF];
-    else if (slope > -5 && slope < -1) {
-        let pct = (slope + 5) / 4;
-        cw = cWAs[POS_TRIATHLON] + pct * (cWAs[POS_BREMSGRIFF] - cWAs[POS_TRIATHLON]);
+    static calculateSpeedBike(gear, rpm, chain, cassette, props) {
+        if (chain.length !== 2 || cassette.length !== 2)
+            throw new IllegalArgumentException("chain and cassette must be an array of 2 numbers");
+        if (cassette[0] < 1 || cassette[1] < 1)
+            throw new IllegalArgumentException("cassette must be an array of 2 positive numbers");
+        const bikeProps = props || {};
+        const minGearRatio = chain[0] / cassette[1];
+        const maxGearRatio = chain[1] / cassette[0];
+        const numGears = bikeProps.numGears || 28;
+        const wheelCirc = bikeProps.wheelCirc || 2125;
+        const gearRatio = minGearRatio + (maxGearRatio - minGearRatio) * (gear - 1) / (numGears - 1);
+        let distRotation = wheelCirc * gearRatio / 1000;
+        let speed = rpm * distRotation * 60 / 1000;
+        return speed;
     }
-    return cw;
 }
+exports.default = C;
 function acosh(x) {
     return Math.log(x + Math.sqrt(x * x - 1.0));
 }
@@ -159,13 +124,13 @@ function solveCubic(p, q) {
     let D = Math.pow(q / 2.0, 2) + Math.pow(p / 3.0, 3);
     let R = Math.sign(q) * Math.sqrt(Math.abs(p) / 3.0);
     if (p === 0) {
-        return [sqrtN(q, 3)];
+        return [sqrtN(-1 * q, 3)];
     }
     if (D === 0) {
         return [3 * q / p, -3 * q / (2 * p)];
     }
     if (D < 0 && p < 0) {
-        var results = [];
+        const results = [];
         let phi = Math.acos(q / (2 * Math.pow(R, 3)));
         results[0] = -2 * R * Math.cos(phi / 3);
         results[1] = -2 * R * Math.cos(phi / 3 + 2 * Math.PI / 3);
@@ -173,16 +138,14 @@ function solveCubic(p, q) {
         return results;
     }
     if (D > 0 && p < 0) {
-        let results = [];
+        const results = [];
         let phi = acosh(q / (2 * Math.pow(R, 3)));
         results[0] = -2 * R * Math.cosh(phi / 3);
         return results;
     }
-    if (p > 0) {
-        let results = [];
-        let phi = asinh(q / (2 * Math.pow(R, 3)));
-        results[0] = -2 * R * Math.sinh(phi / 3);
-        return results;
-    }
-    return [];
+    const results = [];
+    let phi = asinh(q / (2 * Math.pow(R, 3)));
+    results[0] = -2 * R * Math.sinh(phi / 3);
+    return results;
 }
+exports.solveCubic = solveCubic;

package/lib/daum/DaumAdapter.d.ts

@@ -1,21 +1,37 @@
 import { EventLogger } from 'gd-eventlog';
-import Device from '../Device';
+import CyclingMode from '../CyclingMode';
+import DeviceAdapterBase, { Bike, DeviceAdapter } from '../Device';
 interface DaumAdapter {
     getCurrentBikeData(): Promise<any>;
 }
-export default class DaumAdapterBase extends Device implements DaumAdapter {
+export default class DaumAdapterBase extends DeviceAdapterBase implements DeviceAdapter, DaumAdapter, Bike {
     bike: any;
     ignoreHrm: boolean;
     ignoreBike: boolean;
     ignorePower: boolean;
     distanceInternal: number;
     paused: boolean;
+    stopped: boolean;
     data: any;
     currentRequest: any;
     requests: Array<any>;
     iv: any;
     logger: EventLogger;
+    cyclingMode: CyclingMode;
+    userSettings: any;
+    bikeSettings: any;
+    tsPrevData: number;
+    adapterTime: number;
+    requestBusy: boolean;
+    updateBusy: boolean;
     constructor(props: any, bike: any);
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getSupportedCyclingModes(): Array<any>;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
+    setUserSettings(userSettings: any): void;
+    setBikeSettings(bikeSettings: any): void;
+    getWeight(): number;
     getCurrentBikeData(): Promise<any>;
     getBike(): any;
     isBike(): boolean;
@@ -23,18 +39,25 @@ export default class DaumAdapterBase extends Device implements DaumAdapter {
     isHrm(): boolean;
     setIgnoreHrm(ignore: any): void;
     setIgnoreBike(ignore: any): void;
+    isStopped(): boolean;
     initData(): void;
+    start(props?: any): Promise<any>;
     startUpdatePull(): void;
     connect(): void;
     close(): any;
     logEvent(event: any): void;
-    sendBikeUpdate(request: any): Promise<unknown>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    sendUpdate(data: any): Promise<void>;
+    sendUpdate(request: any): Promise<unknown>;
+    sendData(): void;
     update(): Promise<void>;
-    updateData(data: any, bikeData: any): any;
-    transformData(bikeData: any): any;
+    sendRequests(): Promise<void>;
+    bikeSync(): Promise<void>;
+    updateData(prev: any, bikeData: any): void;
+    transformData(): void;
+    sendRequest(request: any): Promise<any>;
+    refreshRequests(): void;
+    processClientRequest(request: any): Promise<unknown>;
 }
 export {};