incyclist-devices 2.2.9 → 2.3.0

package/lib/ble/wahoo/sensor.js

@@ -0,0 +1,356 @@
+"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 consts_1 = require("../../base/consts");
+const consts_2 = require("../consts");
+const consts_3 = require("./consts");
+const sensor_1 = __importDefault(require("../fm/sensor"));
+const utils_1 = require("../utils");
+class BleWahooDevice extends sensor_1.default {
+    constructor(peripheral, props) {
+        super(peripheral, props);
+        this.prevCrankData = undefined;
+        this.currentCrankData = undefined;
+        this.timeOffset = 0;
+        this.tsPrevWrite = undefined;
+        this.prevSlope = undefined;
+        this.isRequestControlBusy = false;
+        this.weight = consts_1.DEFAULT_BIKE_WEIGHT + consts_1.DEFAULT_USER_WEIGHT;
+        this.data = {};
+        this.wahooCP = consts_3.WAHOO_ADVANCED_TRAINER_CP;
+    }
+    isMatching(serviceUUIDs) {
+        const uuids = serviceUUIDs.map(uuid => (0, utils_1.beautifyUUID)(uuid));
+        return uuids.includes((0, utils_1.beautifyUUID)(consts_2.CSP)) && uuids.includes((0, utils_1.beautifyUUID)(consts_3.WAHOO_ADVANCED_FTMS));
+    }
+    reset() {
+        this.data = {};
+        this.isSimMode = undefined;
+        this.simModeSettings = undefined;
+    }
+    getRequiredCharacteristics() {
+        return [consts_2.INDOOR_BIKE_DATA, consts_2.FTMS_STATUS, consts_2.CSP_MEASUREMENT, consts_2.HR_MEASUREMENT];
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        const uuid = characteristic.toLowerCase();
+        let res = undefined;
+        switch (uuid) {
+            case consts_2.CSP_MEASUREMENT:
+                res = this.parsePower(data);
+                break;
+            case consts_2.INDOOR_BIKE_DATA:
+                res = this.parseIndoorBikeData(data);
+                break;
+            case consts_2.HR_MEASUREMENT:
+                res = this.parseHrm(data);
+                break;
+            case consts_2.FTMS_STATUS:
+                res = this.parseFitnessMachineStatus(data);
+                break;
+            default:
+                this.logEvent({ message: 'data', uuid, data: data.toString('hex') });
+                break;
+        }
+        if (res) {
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+    requestControl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasControl)
+                return true;
+            this.logEvent({ message: 'requestControl' });
+            if (this.isRequestControlBusy)
+                return false;
+            this.isRequestControlBusy = true;
+            try {
+                const data = Buffer.alloc(2);
+                data.writeUInt8(0xEE, 0);
+                data.writeUInt8(0xFC, 1);
+                const res = yield this.writeWahooFtmsMessage(32, data, { timeout: 10000 });
+                if (res === true) {
+                    this.hasControl = true;
+                }
+                else {
+                    this.logEvent({ message: 'requestControl failed' });
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'requestControl()', error: err.message, stack: err.stack });
+            }
+            this.isRequestControlBusy = false;
+            return this.hasControl;
+        });
+    }
+    setTargetPower(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
+            if (this.data.targetPower !== undefined && this.data.targetPower === power)
+                return true;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                return false;
+            }
+            return yield this.setErgMode(power);
+        });
+    }
+    setSlope(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setSlope', slope });
+            if (this.prevSlope !== undefined && slope === this.prevSlope)
+                return;
+            try {
+                if (!this.isSimMode) {
+                    const { weight, crr, cw } = this;
+                    const hasSimMode = yield this.setSimMode(weight, crr, cw);
+                    if (!hasSimMode)
+                        throw new Error('Sim Mode not enabled');
+                }
+                const res = yield this.setSimGrade(slope);
+                this.logEvent({ message: 'setSlope result', res });
+                this.prevSlope = slope;
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'setSlope failed', reason: err.message || err });
+                this.prevSlope = undefined;
+                return false;
+            }
+        });
+    }
+    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.data.cadence;
+        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.data.instantaneousPower = data.readUInt16LE(2);
+            if (flags & 0x1)
+                data.readUInt8(offset++);
+            if (flags & 0x4) {
+                offset += 2;
+            }
+            if (flags & 0x10) {
+                offset += 6;
+            }
+            if (flags & 0x20) {
+                const crankData = {
+                    revolutions: data.readUInt16LE(offset),
+                    time: data.readUInt16LE(offset + 2)
+                };
+                const { rpm, time } = this.parseCrankData(crankData);
+                this.data.cadence = rpm;
+                this.data.time = time;
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parsePower', error: err.message, stack: err.stack });
+        }
+        const { instantaneousPower, cadence, time } = this.data;
+        return { instantaneousPower, cadence, time, raw: data.toString('hex') };
+    }
+    writeWahooFtmsMessage(requestedOpCode, data, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const opcode = Buffer.alloc(1);
+                opcode.writeUInt8(requestedOpCode, 0);
+                const message = Buffer.concat([opcode, data]);
+                this.logEvent({ message: 'wahoo cp:write', data: message.toString('hex') });
+                const res = yield this.write(this.wahooCP, message, props);
+                const responseData = Buffer.from(res);
+                const result = responseData.readUInt8(0);
+                return result === 1;
+            }
+            catch (err) {
+                this.logEvent({ message: 'wahoo cp:write failed', opCode: requestedOpCode, reason: err.message });
+                return false;
+            }
+        });
+    }
+    setPowerAdjusting() {
+        this.tsPrevWrite = Date.now();
+    }
+    isPowerAdjusting() {
+        if (this.tsPrevWrite === undefined)
+            return false;
+        if (this.tsPrevWrite < Date.now() - consts_3.ErgWriteDelay) {
+            this.tsPrevWrite = undefined;
+            return false;
+        }
+        return true;
+    }
+    setErgMode(power) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setErgMode', power });
+            try {
+                if (this.isPowerAdjusting())
+                    return false;
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(power), 0);
+                const res = yield this.writeWahooFtmsMessage(66, data);
+                if (res === true) {
+                    this.setPowerAdjusting();
+                    this.data.targetPower = power;
+                    this.isSimMode = false;
+                    this.simModeSettings = undefined;
+                }
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setErgMode', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimMode(weight, crr, cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimMode', weight, crr, cw });
+            try {
+                if (this.isSimMode && this.simModeSettings) {
+                    if (weight === this.simModeSettings.weight &&
+                        crr === this.simModeSettings.crr &&
+                        cw === this.simModeSettings.cw)
+                        return true;
+                }
+                const hasControl = yield this.requestControl();
+                if (!hasControl) {
+                    this.logEvent({ message: 'setSimMode failed', reason: 'control is disabled' });
+                    return false;
+                }
+                this.weight = weight;
+                this.crr = crr;
+                this.cw = cw;
+                const data = Buffer.alloc(6);
+                data.writeInt16LE(Math.round(weight * 100), 0);
+                data.writeInt16LE(Math.round(crr * 10000), 2);
+                data.writeInt16LE(Math.round(cw * 1000), 4);
+                const res = yield this.writeWahooFtmsMessage(67, data);
+                this.isSimMode = true;
+                this.simModeSettings = { weight, crr, cw };
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimMode', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimCRR(crr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimCRR', crr });
+            try {
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(crr * 10000), 0);
+                const res = yield this.writeWahooFtmsMessage(68, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimCRR', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimWindResistance(cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimWindResistance', cw });
+            try {
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(cw * 1000), 0);
+                const res = yield this.writeWahooFtmsMessage(69, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimWindResistance', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimGrade(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimGrade', slope });
+            try {
+                let s = slope;
+                if (s < -100)
+                    s = -100;
+                if (s > 100)
+                    s = 100;
+                const slopeVal = Math.min(Math.round((1 + s / 100) * 65535 / 2.0), 65535);
+                const data = Buffer.alloc(2);
+                data.writeUInt16LE(slopeVal, 0);
+                const res = yield this.writeWahooFtmsMessage(70, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimGrade', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    setSimWindSpeed(v) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'setSimWindSpeed', v });
+            try {
+                const value = (Math.max(-32.767, Math.min(32.767, v)) + 32.767) * 1000;
+                const data = Buffer.alloc(2);
+                data.writeInt16LE(Math.round(value), 0);
+                const res = yield this.writeWahooFtmsMessage(71, data);
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'setSimWindSpeed', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+}
+BleWahooDevice.profile = 'Smart Trainer';
+BleWahooDevice.protocol = 'wahoo';
+BleWahooDevice.services = [consts_2.CSP, consts_3.WAHOO_ADVANCED_FTMS];
+BleWahooDevice.characteristics = [consts_2.FTMS_FEATURE, consts_2.INDOOR_BIKE_DATA, consts_2.RES_LEVEL_RANGE, consts_2.POWER_RANGE, consts_2.FTMS_CP, consts_2.FTMS_STATUS, consts_3.WAHOO_ADVANCED_TRAINER_CP];
+BleWahooDevice.detectionPriority = 5;
+exports.default = BleWahooDevice;

package/lib/direct-connect/base/comms.d.ts

@@ -0,0 +1,3 @@
+import { BleComms } from "../../ble/base/comms";
+export declare class DirectConnectComms extends BleComms {
+}

package/lib/direct-connect/base/comms.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectConnectComms = void 0;
+const comms_1 = require("../../ble/base/comms");
+class DirectConnectComms extends comms_1.BleComms {
+}
+exports.DirectConnectComms = DirectConnectComms;

package/lib/direct-connect/base/interface.d.ts

@@ -0,0 +1,75 @@
+import EventEmitter from "events";
+import { DeviceSettings, InterfaceProps } from "../../types";
+import { EventLogger } from "gd-eventlog";
+import { DirectConnectBinding, MulticastDnsAnnouncement } from "../bindings";
+import { DirectConnectScanProps } from "../types";
+import { BleDeviceSettings, BleProtocol, IBleInterface, IBlePeripheral } from '../../ble/types';
+import { InteruptableTask, TaskState } from "../../utils/task";
+import { BleAdapterFactory } from "../../ble";
+import { TBleSensor } from "../../ble/base/sensor";
+import { InterfaceFactory } from "../../ble/base/types";
+interface Announcement {
+    service: MulticastDnsAnnouncement;
+    ts: number;
+}
+export default class DirectConnectInterface extends EventEmitter implements IBleInterface<MulticastDnsAnnouncement> {
+    protected static _instance: DirectConnectInterface;
+    static readonly INTERFACE_NAME: string;
+    protected logger: EventLogger;
+    protected props: InterfaceProps;
+    protected logEnabled: boolean;
+    protected binding: DirectConnectBinding;
+    protected debug: boolean;
+    protected logDisabled: boolean;
+    protected internalEvents: EventEmitter;
+    protected services: Announcement[];
+    protected scanTask: InteruptableTask<TaskState, DeviceSettings[]>;
+    protected matching?: Array<string>;
+    protected instance: number;
+    protected connected: boolean;
+    static getInstance(props?: InterfaceProps): DirectConnectInterface;
+    constructor(props: InterfaceProps);
+    createPeripheral(announcement: MulticastDnsAnnouncement): IBlePeripheral;
+    createDeviceSetting(service: MulticastDnsAnnouncement): BleDeviceSettings;
+    createPeripheralFromSettings(settings: DeviceSettings): IBlePeripheral;
+    getLogger(): EventLogger;
+    setLogger(logger: EventLogger): void;
+    getName(): string;
+    setBinding(binding: DirectConnectBinding): void;
+    getBinding(): DirectConnectBinding;
+    autoConnect(): void;
+    connect(reconnect?: boolean): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    scan(props: DirectConnectScanProps): Promise<DeviceSettings[]>;
+    stopScan(): Promise<boolean>;
+    onScanDone(): DeviceSettings[];
+    pauseLogging(): void;
+    resumeLogging(): void;
+    isLoggingPaused(): boolean;
+    waitForPeripheral(settings: DeviceSettings): Promise<IBlePeripheral>;
+    protected reconnect(): Promise<void>;
+    protected isScanning(): boolean;
+    protected startScan(): Promise<void>;
+    private emitCachedDevices;
+    protected emitDevice(service: MulticastDnsAnnouncement): void;
+    protected buildDeviceSettings(matching?: string[]): {
+        interface: string;
+        name: string;
+    }[];
+    protected addService(service: MulticastDnsAnnouncement): void;
+    protected find(service: MulticastDnsAnnouncement): Announcement;
+    protected getAll(): Announcement[];
+    setDebug(enabled: boolean): void;
+    logEvent(event: any): void;
+    logError(err: Error, fn: string, args?: any): void;
+    protected getProtocol(announcement: MulticastDnsAnnouncement): BleProtocol;
+    protected getBestDeviceMatch(DeviceClasses: (typeof TBleSensor)[]): typeof TBleSensor;
+    protected getAdapterFactory(): BleAdapterFactory<any>;
+}
+export declare class DirectConnectInterfaceFactory extends InterfaceFactory {
+    protected iface: DirectConnectInterface;
+    constructor();
+    getInterface(): DirectConnectInterface;
+}
+export {};