incyclist-devices 2.3.12 → 2.3.14

package/lib/ble/fm/comms.js

@@ -0,0 +1,506 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const consts_1 = require("../consts");
+const comms_1 = require("../base/comms");
+const utils_1 = require("../utils");
+const bit = (nr) => (1 << nr);
+const IndoorBikeDataFlag = {
+    MoreData: bit(0),
+    AverageSpeedPresent: bit(1),
+    InstantaneousCadence: bit(2),
+    AverageCadencePresent: bit(3),
+    TotalDistancePresent: bit(4),
+    ResistanceLevelPresent: bit(5),
+    InstantaneousPowerPresent: bit(6),
+    AveragePowerPresent: bit(7),
+    ExpendedEnergyPresent: bit(8),
+    HeartRatePresent: bit(9),
+    MetabolicEquivalentPresent: bit(10),
+    ElapsedTimePresent: bit(11),
+    RemainingTimePresent: bit(12)
+};
+const FitnessMachineFeatureFlag = {
+    AverageSpeedSupported: bit(0),
+    CadenceSupported: bit(1),
+    TotalDistanceSupported: bit(2),
+    InclinationSupported: bit(3),
+    ElevationGainSupported: bit(4),
+    PaceSupported: bit(5),
+    StepCountSupported: bit(6),
+    ResistanceLevelSupported: bit(7),
+    StrideCountSupported: bit(8),
+    ExpendedEnergySupported: bit(9),
+    HeartRateMeasurementSupported: bit(10),
+    MetabolicEquivalentSupported: bit(11),
+    ElapsedTimeSupported: bit(12),
+    RemainingTimeSupported: bit(13),
+    PowerMeasurementSupported: bit(14),
+    ForceOnBeltAndPowerOutputSupported: bit(15),
+    UserDataRetentionSupported: bit(16)
+};
+const TargetSettingFeatureFlag = {
+    SpeedTargetSettingSupported: bit(0),
+    InclinationTargetSettingSupported: bit(1),
+    ResistanceTargetSettingSupported: bit(2),
+    PowerTargetSettingSupported: bit(3),
+    HeartRateTargetSettingSupported: bit(4),
+    TargetedExpendedEnergyConfigurationSupported: bit(5),
+    TargetedStepNumberConfigurationSupported: bit(6),
+    TargetedStrideNumberConfigurationSupported: bit(7),
+    TargetedDistanceConfigurationSupported: bit(8),
+    TargetedTrainingTimeConfigurationSupported: bit(9),
+    TargetedTimeInTwoHeartRateZonesConfigurationSupported: bit(10),
+    TargetedTimeInThreeHeartRateZonesConfigurationSupported: bit(11),
+    TargetedTimeInFiveHeartRateZonesConfigurationSupported: bit(12),
+    IndoorBikeSimulationParametersSupported: bit(13),
+    WheelCircumferenceConfigurationSupported: bit(14),
+    SpinDownControlSupported: bit(15),
+    TargetedCadenceConfigurationSupported: bit(16)
+};
+class BleFitnessMachineDevice extends comms_1.BleComms {
+    constructor(props) {
+        super(props);
+        this.features = undefined;
+        this.hasControl = false;
+        this.isCheckingControl = false;
+        this.isCPSubscribed = false;
+        this.crr = 0.0033;
+        this.cw = 0.6;
+        this.windSpeed = 0;
+        this.wheelSize = 2100;
+        this.reset();
+        this.services = BleFitnessMachineDevice.services;
+    }
+    static isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasStatus = announced.find(c => c === consts_1.FTMS_STATUS) !== undefined;
+        const hasCP = announced.find(c => c === consts_1.FTMS_CP) !== undefined;
+        const hasIndoorBike = announced.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
+        return hasStatus && hasCP && hasIndoorBike;
+    }
+    subscribeWriteResponse(cuuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'subscribe to CP response', characteristics: cuuid });
+            const connector = this.ble.peripheralCache.getConnector(this.peripheral);
+            const isAlreadySubscribed = connector.isSubscribed(cuuid);
+            if (!isAlreadySubscribed) {
+                connector.removeAllListeners(cuuid);
+                let prev = undefined;
+                let prevTS = undefined;
+                connector.on(cuuid, (uuid, data) => {
+                    const message = data.toString('hex');
+                    if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
+                        return;
+                    }
+                    prevTS = Date.now();
+                    prev = message;
+                    this.onData(uuid, data);
+                });
+                yield connector.subscribe(cuuid);
+            }
+        });
+    }
+    subscribeAll(conn) {
+        const characteristics = [consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP];
+        if (!this.features || (this.features && this.features.cadence))
+            characteristics.push(consts_1.CSC_MEASUREMENT);
+        if (!this.features || (this.features && this.features.power))
+            characteristics.push(consts_1.CSP_MEASUREMENT);
+        if (!this.features || (this.features && this.features.heartrate))
+            characteristics.push(consts_1.HR_MEASUREMENT);
+        return this.subscribeMultiple(characteristics, conn);
+    }
+    init() {
+        const _super = Object.create(null, {
+            initDevice: { get: () => super.initDevice }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield _super.initDevice.call(this);
+                yield this.getFitnessMachineFeatures();
+                this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'BleFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    onDisconnect() {
+        const _super = Object.create(null, {
+            onDisconnect: { get: () => super.onDisconnect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.onDisconnect.call(this);
+            this.hasControl = false;
+        });
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    getProtocol() {
+        return BleFitnessMachineDevice.protocol;
+    }
+    getServiceUUids() {
+        return BleFitnessMachineDevice.services;
+    }
+    parseHrm(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt8(0);
+            if (flags % 1 === 0) {
+                this.data.heartrate = data.readUInt8(1);
+            }
+            else {
+                this.data.heartrate = data.readUInt16LE(1);
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseHrm()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2a37:${data.toString('hex')}` });
+    }
+    setCrr(crr) { this.crr = crr; }
+    getCrr() { return this.crr; }
+    setCw(cw) { this.cw = cw; }
+    getCw() { return this.cw; }
+    setWindSpeed(windSpeed) { this.windSpeed = windSpeed; }
+    getWindSpeed() { return this.windSpeed; }
+    parseIndoorBikeData(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt16LE(0);
+            let offset = 2;
+            if ((flags & IndoorBikeDataFlag.MoreData) === 0) {
+                this.data.speed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
+                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
+                this.data.cadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
+                this.data.averageCadence = data.readUInt16LE(offset) / 2;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
+                const dvLow = data.readUInt8(offset);
+                offset += 1;
+                const dvHigh = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.totalDistance = (dvHigh << 8) + dvLow;
+            }
+            if (flags & IndoorBikeDataFlag.ResistanceLevelPresent) {
+                this.data.resistanceLevel = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.InstantaneousPowerPresent) {
+                this.data.instantaneousPower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.AveragePowerPresent) {
+                this.data.averagePower = data.readInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ExpendedEnergyPresent) {
+                this.data.totalEnergy = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerHour = data.readUInt16LE(offset);
+                offset += 2;
+                this.data.energyPerMinute = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.HeartRatePresent) {
+                this.data.heartrate = data.readUInt8(offset);
+                offset += 1;
+            }
+            if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
+                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
+                this.data.time = data.readUInt16LE(offset);
+                offset += 2;
+            }
+            if (flags & IndoorBikeDataFlag.RemainingTimePresent) {
+                this.data.remainingTime = data.readUInt16LE(offset);
+                offset += 2;
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
+    }
+    parseFitnessMachineStatus(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const OpCode = data.readUInt8(0);
+            switch (OpCode) {
+                case 8:
+                    this.data.targetPower = data.readInt16LE(1);
+                    break;
+                case 6:
+                    this.data.targetInclination = data.readInt16LE(1) / 10;
+                    break;
+                case 4:
+                    this.data.status = "STARTED";
+                    break;
+                case 3:
+                case 2:
+                    this.data.status = "STOPPED";
+                    break;
+                case 20:
+                    const spinDownStatus = data.readUInt8(1);
+                    switch (spinDownStatus) {
+                        case 1:
+                            this.data.status = "SPIN DOWN REQUESTED";
+                            break;
+                        case 2:
+                            this.data.status = "SPIN DOWN SUCCESS";
+                            break;
+                        case 3:
+                            this.data.status = "SPIN DOWN ERROR";
+                            break;
+                        case 4:
+                            this.data.status = "STOP PEDALING";
+                            break;
+                        default: break;
+                    }
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message | err, stack: err.stack });
+        }
+        return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
+    }
+    getFitnessMachineFeatures() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.features)
+                return this.features;
+            try {
+                const data = yield this.read('2acc');
+                const buffer = data ? Buffer.from(data) : undefined;
+                if (buffer) {
+                    const fitnessMachine = buffer.readUInt32LE(0);
+                    const targetSettings = buffer.readUInt32LE(4);
+                    const power = (fitnessMachine & FitnessMachineFeatureFlag.PowerMeasurementSupported) !== 0;
+                    const heartrate = (fitnessMachine & FitnessMachineFeatureFlag.HeartRateMeasurementSupported) !== 0;
+                    const cadence = (fitnessMachine & FitnessMachineFeatureFlag.CadenceSupported) !== 0;
+                    const setSlope = (targetSettings & TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0
+                        || (targetSettings & TargetSettingFeatureFlag.InclinationTargetSettingSupported) !== 0;
+                    const setPower = (targetSettings & TargetSettingFeatureFlag.PowerTargetSettingSupported) !== 0;
+                    this.features = { fitnessMachine, targetSettings, power, heartrate, cadence, setPower, setSlope };
+                    this.logEvent({ message: 'supported Features: ', fatures: this.features, power, heartrate, cadence });
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack });
+                return undefined;
+            }
+        });
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return false;
+        const uuid = characteristic.toLocaleLowerCase();
+        let res = undefined;
+        switch (uuid) {
+            case consts_1.INDOOR_BIKE_DATA:
+                res = this.parseIndoorBikeData(data);
+                break;
+            case '2a37':
+                res = this.parseHrm(data);
+                break;
+            case consts_1.FTMS_STATUS:
+                res = this.parseFitnessMachineStatus(data);
+                break;
+            case '2a63':
+            case '2a5b':
+            case '347b0011-7635-408b-8918-8ff3949ce592':
+                break;
+            default:
+                break;
+        }
+        if (res) {
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+    writeFtmsMessage(requestedOpCode, data, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
+                const res = yield this.write(consts_1.FTMS_CP, data, props);
+                const responseData = Buffer.from(res);
+                const opCode = responseData.readUInt8(0);
+                const request = responseData.readUInt8(1);
+                const result = responseData.readUInt8(2);
+                if (opCode !== 128 || request !== requestedOpCode)
+                    throw new Error('Illegal response ');
+                this.logEvent({ message: 'fmts:write result', res, result });
+                return result;
+            }
+            catch (err) {
+                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
+                return 4;
+            }
+        });
+    }
+    requestControl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let to = undefined;
+            if (this.isCheckingControl) {
+                to = setTimeout(() => { }, 3500);
+            }
+            if (this.hasControl)
+                return true;
+            this.logEvent({ message: 'requestControl' });
+            this.isCheckingControl = true;
+            const data = Buffer.alloc(1);
+            data.writeUInt8(0, 0);
+            const res = yield this.writeFtmsMessage(0, data, { timeout: 5000 });
+            if (res === 1) {
+                this.hasControl = true;
+            }
+            else {
+                this.logEvent({ message: 'requestControl failed' });
+            }
+            this.isCheckingControl = false;
+            if (to)
+                clearTimeout(to);
+            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;
+            if (!this.hasControl)
+                return;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                return true;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(5, 0);
+            data.writeInt16LE(Math.round(power), 1);
+            const res = yield this.writeFtmsMessage(5, data);
+            return (res === 1);
+        });
+    }
+    setSlope(slope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setSlope', slope });
+            const hasControl = yield this.requestControl();
+            if (!hasControl)
+                return;
+            const { windSpeed, crr, cw } = this;
+            return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
+        });
+    }
+    setTargetInclination(inclination) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.data.targetInclination !== undefined && this.data.targetInclination === inclination)
+                return true;
+            if (!this.hasControl)
+                return;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(3, 0);
+            data.writeInt16LE(Math.round(inclination * 10), 1);
+            const res = yield this.writeFtmsMessage(3, data);
+            return (res === 1);
+        });
+    }
+    setIndoorBikeSimulation(windSpeed, gradient, crr, cw) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setIndoorBikeSimulation failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(7);
+            data.writeUInt8(17, 0);
+            data.writeInt16LE(Math.round(windSpeed * 1000), 1);
+            data.writeInt16LE(Math.round(gradient * 100), 3);
+            data.writeUInt8(Math.round(crr * 10000), 5);
+            data.writeUInt8(Math.round(cw * 100), 6);
+            const res = yield this.writeFtmsMessage(17, data);
+            return (res === 1);
+        });
+    }
+    startRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'startRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(1);
+            data.writeUInt8(7, 0);
+            const res = yield this.writeFtmsMessage(7, data);
+            return (res === 1);
+        });
+    }
+    stopRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'stopRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(1, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
+        });
+    }
+    PauseRequest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'PauseRequest failed', reason: 'control is disabled' });
+                return false;
+            }
+            const data = Buffer.alloc(2);
+            data.writeUInt8(8, 0);
+            data.writeUInt8(2, 1);
+            const res = yield this.writeFtmsMessage(8, data);
+            return (res === 1);
+        });
+    }
+    reset() {
+        this.data = {};
+    }
+}
+BleFitnessMachineDevice.protocol = 'fm';
+BleFitnessMachineDevice.services = [consts_1.FTMS];
+BleFitnessMachineDevice.characteristics = ['2acc', consts_1.INDOOR_BIKE_DATA, '2ad6', '2ad8', consts_1.FTMS_CP, consts_1.FTMS_STATUS];
+BleFitnessMachineDevice.detectionPriority = 100;
+exports.default = BleFitnessMachineDevice;

package/lib/ble/fm/sensor.js

@@ -144,9 +144,9 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
     }
     parseIndoorBikeData(_data) {
         const data = Buffer.from(_data);
+        let offset = 2;
         try {
             const flags = data.readUInt16LE(0);
-            let offset = 2;
             if ((flags & consts_2.IndoorBikeDataFlag.MoreData) === 0) {
                 this.data.speed = data.readUInt16LE(offset) / 100;
                 offset += 2;
@@ -196,7 +196,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             }
             if (flags & consts_2.IndoorBikeDataFlag.MetabolicEquivalentPresent) {
                 this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
-                offset += 2;
+                offset += 1;
             }
             if (flags & consts_2.IndoorBikeDataFlag.ElapsedTimePresent) {
                 this.data.time = data.readUInt16LE(offset);
@@ -207,7 +207,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             }
         }
         catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', error: err.message | err, stack: err.stack });
+            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', data: data.toString('hex'), offset, error: err.message | err, stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
     }

package/lib/ble/hr/comm.d.ts

@@ -0,0 +1,19 @@
+import { LegacyProfile } from '../../antv2/types';
+import { BleComms } from '../base/comms';
+import { BleProtocol } from '../types';
+import { HrmData } from './types';
+export default class BleHrmDevice extends BleComms {
+    static protocol: BleProtocol;
+    static services: string[];
+    static characteristics: string[];
+    static detectionPriority: number;
+    heartrate: number;
+    rr: number;
+    constructor(props?: any);
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
+    getServiceUUids(): string[];
+    static isMatching(characteristics: string[]): boolean;
+    parseHrm(_data: Uint8Array): HrmData;
+    onData(characteristic: string, data: Buffer): boolean;
+}

package/lib/ble/hr/comm.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comms_1 = require("../base/comms");
+const consts_1 = require("../consts");
+const utils_1 = require("../utils");
+class BleHrmDevice extends comms_1.BleComms {
+    constructor(props) {
+        super(props);
+        this.heartrate = undefined;
+        this.rr = undefined;
+    }
+    getProfile() {
+        return 'Heartrate Monitor';
+    }
+    getProtocol() {
+        return BleHrmDevice.protocol;
+    }
+    getServiceUUids() {
+        return BleHrmDevice.services;
+    }
+    static isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasHRMeasurement = announced.find(c => c === consts_1.HR_MEASUREMENT) !== undefined;
+        return hasHRMeasurement;
+    }
+    parseHrm(_data) {
+        const data = Buffer.from(_data);
+        try {
+            const flags = data.readUInt8(0);
+            let offset = 2;
+            if (flags % 1 === 0) {
+                this.heartrate = data.readUInt8(1);
+            }
+            else {
+                this.heartrate = data.readUInt16LE(1);
+                offset = 3;
+            }
+            if (flags % 0xF) {
+                this.rr = (data.readUInt16LE(offset)) / 1024;
+            }
+        }
+        catch (err) {
+        }
+        const { heartrate, rr } = this;
+        return { heartrate, rr, raw: data.toString('hex') };
+    }
+    onData(characteristic, data) {
+        const hasData = super.onData(characteristic, data);
+        if (!hasData)
+            return;
+        if (characteristic.toLocaleLowerCase() === '2a37') {
+            const res = this.parseHrm(data);
+            this.emit('data', res);
+            return false;
+        }
+        return true;
+    }
+}
+BleHrmDevice.protocol = 'hr';
+BleHrmDevice.services = ['180d'];
+BleHrmDevice.characteristics = [consts_1.HR_MEASUREMENT, '2a38', '2a39', '2a3c'];
+BleHrmDevice.detectionPriority = 1;
+exports.default = BleHrmDevice;

package/lib/ble/peripheral-cache.d.ts

@@ -0,0 +1,45 @@
+import BleAdapter from "./base/adapter";
+import { BleComms } from "./base/comms";
+import { BleDeviceData } from "./base/types";
+import BlePeripheralConnector from "./ble-peripheral";
+import { BleCharacteristic, BlePeripheral } from "./types";
+export interface PeripheralState {
+    isLoading: boolean;
+    isConfigured: boolean;
+    isInterrupted: boolean;
+}
+export interface PeripheralCacheItem {
+    address: string;
+    name?: string;
+    id?: string;
+    ts: number;
+    peripheral: BlePeripheral;
+    state?: PeripheralState;
+    characteristics?: BleCharacteristic[];
+    connector?: BlePeripheralConnector;
+}
+export default class BlePeripheralCache {
+    peripherals: PeripheralCacheItem[];
+    findAdapter(adapter: BleAdapter<BleDeviceData, BleComms>): PeripheralCacheItem;
+    getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
+    getPeripheral(query: {
+        id?: string;
+        address?: string;
+        name?: string;
+    }): BlePeripheral;
+    handleStopScan(): void;
+    find(query: {
+        name?: string;
+        id?: string;
+        address?: string;
+        peripheral?: BlePeripheral;
+    }): PeripheralCacheItem;
+    filter(services: string[]): PeripheralCacheItem[];
+    protected _findIndex(query: {
+        name?: string;
+        id?: string;
+        address?: string;
+    }): number;
+    add(item: PeripheralCacheItem): PeripheralCacheItem;
+    remove(query: PeripheralCacheItem | BlePeripheral): void;
+}