incyclist-devices 2.3.12 → 2.3.14

package/lib/ble/elite/comms.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const comms_1 = require("../base/comms");
+const consts_1 = require("../consts");
+const utils_1 = require("../utils");
+class BleEliteDevice extends comms_1.BleComms {
+    constructor(props) {
+        super(props);
+        this.instantaneousPower = undefined;
+        this.balance = undefined;
+        this.accTorque = undefined;
+        this.rpm = undefined;
+        this.timeOffset = 0;
+        this.time = undefined;
+        this.currentCrankData = undefined;
+        this.prevCrankData = undefined;
+    }
+    static isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasCPMeasurement = announced.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
+        const hasCPFeature = announced.find(c => c === consts_1.CSP_FEATURE) !== undefined;
+        return hasCPMeasurement && hasCPFeature;
+    }
+    getProfile() {
+        return 'Power Meter';
+    }
+    getProtocol() {
+        return _1.BleEliteComms.protocol;
+    }
+    getServiceUUids() {
+        return BleEliteDevice.services;
+    }
+    parseCrankData(crankData) {
+        if (!this.prevCrankData)
+            this.prevCrankData = { revolutions: 0, time: 0, cntUpdateMissing: -1 };
+        const c = this.currentCrankData = crankData;
+        const p = this.prevCrankData;
+        let rpm = this.rpm;
+        let hasUpdate = c.time !== p.time;
+        if (hasUpdate) {
+            let time = c.time - p.time;
+            let revs = c.revolutions - p.revolutions;
+            if (c.time < p.time) {
+                time += 0x10000;
+                this.timeOffset += 0x10000;
+            }
+            if (c.revolutions < p.revolutions)
+                revs += 0x10000;
+            rpm = 1024 * 60 * revs / time;
+        }
+        else {
+            if (p.cntUpdateMissing < 0 || p.cntUpdateMissing > 2) {
+                rpm = 0;
+            }
+        }
+        const cntUpdateMissing = p.cntUpdateMissing;
+        this.prevCrankData = this.currentCrankData;
+        if (hasUpdate)
+            this.prevCrankData.cntUpdateMissing = 0;
+        else
+            this.prevCrankData.cntUpdateMissing = cntUpdateMissing + 1;
+        return { rpm, time: this.timeOffset + c.time };
+    }
+    parsePower(_data) {
+        const data = Buffer.from(_data);
+        try {
+            let offset = 4;
+            const flags = data.readUInt16LE(0);
+            this.instantaneousPower = data.readUInt16LE(2);
+            if (flags & 0x1)
+                this.balance = data.readUInt8(offset++);
+            if (flags & 0x4) {
+                this.accTorque = data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & 0x10) {
+            }
+            if (flags & 0x20) {
+                const crankData = {
+                    revolutions: data.readUInt16LE(offset),
+                    time: data.readUInt16LE(offset + 2)
+                };
+                const { rpm, time } = this.parseCrankData(crankData);
+                this.rpm = rpm;
+                this.time = time;
+                offset += 4;
+            }
+        }
+        catch (err) {
+        }
+        const { instantaneousPower, balance, accTorque, rpm, time } = this;
+        return { instantaneousPower, balance, accTorque, rpm, time, raw: `2a63:${data.toString('hex')}` };
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        if ((0, utils_1.matches)(characteristic, consts_1.CSP_MEASUREMENT)) {
+            const res = this.parsePower(data);
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+    subscribeAll(conn) {
+        const characteristics = [consts_1.CSP_MEASUREMENT];
+        return this.subscribeMultiple(characteristics, conn);
+    }
+    reset() {
+        this.instantaneousPower = undefined;
+        this.balance = undefined;
+        this.accTorque = undefined;
+        this.rpm = undefined;
+        this.timeOffset = 0;
+        this.time = undefined;
+        this.currentCrankData = undefined;
+        this.prevCrankData = undefined;
+    }
+}
+BleEliteDevice.protocol = 'elite';
+BleEliteDevice.services = [consts_1.ELITE_TRAINER_SVC];
+BleEliteDevice.characteristics = [consts_1.CSP_MEASUREMENT, consts_1.CSP_FEATURE, '2a5d', '2a3c'];
+BleEliteDevice.detectionPriority = 10;
+exports.default = BleEliteDevice;

package/lib/ble/elite/index.d.ts

@@ -0,0 +1,3 @@
+import BleEliteAdapter from "./adapter";
+import BleEliteComms from "./comms";
+export { BleEliteAdapter, BleEliteComms };

package/lib/ble/elite/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleEliteComms = exports.BleEliteAdapter = void 0;
+const adapter_1 = __importDefault(require("./adapter"));
+exports.BleEliteAdapter = adapter_1.default;
+const comms_1 = __importDefault(require("./comms"));
+exports.BleEliteComms = comms_1.default;

package/lib/ble/fm/comms.d.ts

@@ -0,0 +1,49 @@
+import { BleProtocol, BleWriteProps, IBlePeripheralConnector } from "../types";
+import { IndoorBikeData, IndoorBikeFeatures } from "./types";
+import { BleComms } from "../base/comms";
+import { LegacyProfile } from "../../antv2/types";
+export default class BleFitnessMachineDevice extends BleComms {
+    static protocol: BleProtocol;
+    static services: string[];
+    static characteristics: string[];
+    static detectionPriority: number;
+    data: IndoorBikeData;
+    features: IndoorBikeFeatures;
+    hasControl: boolean;
+    isCheckingControl: boolean;
+    isCPSubscribed: boolean;
+    crr: number;
+    cw: number;
+    windSpeed: number;
+    wheelSize: number;
+    constructor(props?: any);
+    static isMatching(characteristics: string[]): boolean;
+    subscribeWriteResponse(cuuid: string): Promise<void>;
+    subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
+    init(): Promise<boolean>;
+    onDisconnect(): Promise<void>;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
+    getServiceUUids(): string[];
+    parseHrm(_data: Uint8Array): IndoorBikeData;
+    setCrr(crr: number): void;
+    getCrr(): number;
+    setCw(cw: number): void;
+    getCw(): number;
+    setWindSpeed(windSpeed: number): void;
+    getWindSpeed(): number;
+    parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
+    parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
+    getFitnessMachineFeatures(): Promise<IndoorBikeFeatures | undefined>;
+    onData(characteristic: string, data: Buffer): boolean;
+    writeFtmsMessage(requestedOpCode: any, data: any, props?: BleWriteProps): Promise<number>;
+    requestControl(): Promise<boolean>;
+    setTargetPower(power: number): Promise<boolean>;
+    setSlope(slope: any): Promise<boolean>;
+    setTargetInclination(inclination: number): Promise<boolean>;
+    setIndoorBikeSimulation(windSpeed: number, gradient: number, crr: number, cw: number): Promise<boolean>;
+    startRequest(): Promise<boolean>;
+    stopRequest(): Promise<boolean>;
+    PauseRequest(): Promise<boolean>;
+    reset(): void;
+}