incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/ble/fm/adapter.js

@@ -0,0 +1,190 @@
+"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 gd_eventlog_1 = require("gd-eventlog");
+const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
+const ble_erg_mode_1 = __importDefault(require("../../modes/ble-erg-mode"));
+const comms_1 = __importDefault(require("./comms"));
+const adapter_1 = require("../adapter");
+const consts_1 = require("./consts");
+const utils_1 = require("../../utils/utils");
+const capabilities_1 = require("../../types/capabilities");
+class BleFmAdapter extends adapter_1.BleControllableAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.distanceInternal = 0;
+        this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
+        const { id, address, name } = settings;
+        const logger = this.logger;
+        const ble = this.ble;
+        this.device = new comms_1.default({ id, address, name, ble, logger });
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence,
+            capabilities_1.IncyclistCapability.Control
+        ];
+    }
+    isSame(device) {
+        if (!(device instanceof BleFmAdapter))
+            return false;
+        return this.isEqual(device.settings);
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    getName() {
+        return `${this.device.name}`;
+    }
+    getDisplayName() {
+        return this.getName();
+    }
+    getSupportedCyclingModes() {
+        return [ble_st_mode_1.default, ble_erg_mode_1.default, power_meter_1.default];
+    }
+    getDefaultCyclingMode() {
+        return new ble_st_mode_1.default(this);
+    }
+    onDeviceData(deviceData) {
+        super.onDeviceData(deviceData);
+        if (!this.started || this.paused || !this.onDataFn)
+            return;
+        this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
+        if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
+            let incyclistData = this.mapData(deviceData);
+            incyclistData = this.getCyclingMode().updateData(incyclistData);
+            this.data = this.transformData(incyclistData);
+            this.onDataFn(this.data);
+            this.lastUpdate = Date.now();
+        }
+    }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: undefined,
+            speed: 0,
+            heartrate: 0,
+            distanceInternal: 0,
+            slope: undefined,
+            time: undefined
+        };
+        data.power = (deviceData.instantaneousPower !== undefined ? deviceData.instantaneousPower : data.power);
+        data.pedalRpm = (deviceData.cadence !== undefined ? deviceData.cadence : data.pedalRpm);
+        data.time = (deviceData.time !== undefined ? deviceData.time : data.time);
+        data.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
+        return data;
+    }
+    transformData(bikeData) {
+        if (bikeData === undefined)
+            return;
+        let distance = 0;
+        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
+            distance = Math.round(bikeData.distanceInternal - this.distanceInternal);
+        }
+        if (bikeData.distanceInternal !== undefined)
+            this.distanceInternal = bikeData.distanceInternal;
+        let data = {
+            speed: bikeData.speed,
+            slope: bikeData.slope,
+            power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
+            cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
+            distance,
+            timestamp: Date.now()
+        };
+        return data;
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started)
+                return true;
+            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            const { restart } = props;
+            if (!restart && this.ble.isScanning())
+                yield this.ble.stopScan();
+            try {
+                let bleDevice;
+                if (!this.device || !restart) {
+                    bleDevice = (yield this.ble.connectDevice(this.device));
+                    this.device = bleDevice;
+                }
+                else
+                    bleDevice = this.device;
+                if (bleDevice) {
+                    bleDevice.setLogger(this.logger);
+                    const mode = this.getCyclingMode();
+                    if (mode && mode.getSetting('bikeType')) {
+                        const bikeType = mode.getSetting('bikeType').toLowerCase();
+                        bleDevice.setCrr(consts_1.cRR);
+                        switch (bikeType) {
+                            case 'race':
+                                bleDevice.setCw(consts_1.cwABike.race);
+                                break;
+                            case 'triathlon':
+                                bleDevice.setCw(consts_1.cwABike.triathlon);
+                                break;
+                            case 'mountain':
+                                bleDevice.setCw(consts_1.cwABike.mountain);
+                                break;
+                        }
+                    }
+                    let hasControl = yield bleDevice.requestControl();
+                    if (!hasControl) {
+                        let retry = 1;
+                        while (!hasControl && retry < 3) {
+                            yield (0, utils_1.sleep)(1000);
+                            hasControl = yield bleDevice.requestControl();
+                            retry++;
+                        }
+                    }
+                    if (!hasControl)
+                        throw new Error('could not establish control');
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
+                    bleDevice.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    bleDevice.on('disconnected', this.emit);
+                    if (bleDevice.isHrm() && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
+                        this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+                    }
+                    this.resetData();
+                    this.stopped = false;
+                    this.started = true;
+                    this.paused = false;
+                    return true;
+                }
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
+        });
+    }
+    sendUpdate(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.paused || !this.device)
+                return;
+            const update = this.getCyclingMode().sendBikeUpdate(request);
+            this.logger.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
+            const device = this.device;
+            if (update.slope !== undefined) {
+                yield device.setSlope(update.slope);
+            }
+            if (update.targetPower !== undefined) {
+                yield device.setTargetPower(update.targetPower);
+            }
+        });
+    }
+}
+exports.default = BleFmAdapter;

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

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+import { BleWriteProps, IBlePeripheralConnector } from "../types";
+import { BleComms } from "../ble-comms";
+import { IndoorBikeData, IndoorBikeFeatures } from "./types";
+export default class BleFitnessMachineDevice extends BleComms {
+    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);
+    isMatching(characteristics: string[]): boolean;
+    subscribeWriteResponse(cuuid: string): Promise<void>;
+    subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
+    init(): Promise<boolean>;
+    onDisconnect(): void;
+    getProfile(): string;
+    getServiceUUids(): string[];
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    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>;
+    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;
+}

package/lib/ble/{fm.js → fm/comms.js}

@@ -8,26 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
-exports.FmAdapter = void 0;
-const ble_device_1 = require("./ble-device");
-const ble_interface_1 = __importDefault(require("./ble-interface"));
-const device_1 = __importDefault(require("../device"));
-const gd_eventlog_1 = require("gd-eventlog");
-const power_meter_1 = __importDefault(require("../modes/power-meter"));
-const ble_st_mode_1 = __importDefault(require("./ble-st-mode"));
-const ble_erg_mode_1 = __importDefault(require("./ble-erg-mode"));
-const consts_1 = require("./consts");
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
+const ble_comms_1 = require("../ble-comms");
+const consts_1 = require("../consts");
 const bit = (nr) => (1 << nr);
 const IndoorBikeDataFlag = {
     MoreData: bit(0),
@@ -82,7 +65,7 @@ const TargetSettingFeatureFlag = {
     SpinDownControlSupported: bit(15),
     TargetedCadenceConfigurationSupported: bit(16)
 };
-class BleFitnessMachineDevice extends ble_device_1.BleDevice {
+class BleFitnessMachineDevice extends ble_comms_1.BleComms {
     constructor(props) {
         super(props);
         this.features = undefined;
@@ -540,207 +523,3 @@ exports.default = BleFitnessMachineDevice;
 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;
-ble_interface_1.default.register('BleFitnessMachineDevice', 'fm', BleFitnessMachineDevice, BleFitnessMachineDevice.services);
-class FmAdapter extends device_1.default {
-    constructor(device, protocol) {
-        super(protocol);
-        this.ignore = false;
-        this.paused = false;
-        this.distanceInternal = 0;
-        this.device = device;
-        this.ble = protocol.ble;
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
-        if (this.device)
-            this.device.setLogger(this.logger);
-    }
-    isBike() { return this.device.isBike() || this.device.isPower(); }
-    isHrm() { return this.device.isHrm(); }
-    isPower() { return this.device.isPower(); }
-    isSame(device) {
-        if (!(device instanceof FmAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
-    }
-    getProfile() {
-        const profile = this.device ? this.device.getProfile() : undefined;
-        return profile || 'Smart Trainer';
-    }
-    getName() {
-        return `${this.device.name}`;
-    }
-    getDisplayName() {
-        return this.getName();
-    }
-    getSupportedCyclingModes() {
-        return [ble_st_mode_1.default, ble_erg_mode_1.default, power_meter_1.default];
-    }
-    setCyclingMode(mode, settings) {
-        let selectedMode;
-        if (typeof mode === 'string') {
-            const supported = this.getSupportedCyclingModes();
-            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
-            if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.cyclingMode = this.getDefaultCyclingMode();
-        return this.cyclingMode;
-    }
-    getDefaultCyclingMode() {
-        return new ble_st_mode_1.default(this);
-    }
-    getPort() {
-        return 'ble';
-    }
-    setIgnoreBike(ignore) {
-        this.ignore = ignore;
-    }
-    setIgnorePower(ignore) {
-        this.ignore = ignore;
-    }
-    onDeviceData(deviceData) {
-        if (this.prevDataTS && Date.now() - this.prevDataTS < 1000)
-            return;
-        this.prevDataTS = Date.now();
-        this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
-        let incyclistData = this.mapData(deviceData);
-        incyclistData = this.getCyclingMode().updateData(incyclistData);
-        const data = this.transformData(incyclistData);
-        if (this.onDataFn && !this.ignore && !this.paused)
-            this.onDataFn(data);
-    }
-    mapData(deviceData) {
-        const data = {
-            isPedalling: false,
-            power: 0,
-            pedalRpm: undefined,
-            speed: 0,
-            heartrate: 0,
-            distanceInternal: 0,
-            slope: undefined,
-            time: undefined
-        };
-        data.power = (deviceData.instantaneousPower !== undefined ? deviceData.instantaneousPower : data.power);
-        data.pedalRpm = (deviceData.cadence !== undefined ? deviceData.cadence : data.pedalRpm);
-        data.time = (deviceData.time !== undefined ? deviceData.time : data.time);
-        data.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
-        return data;
-    }
-    transformData(bikeData) {
-        if (this.ignore) {
-            return {};
-        }
-        if (bikeData === undefined)
-            return;
-        let distance = 0;
-        if (this.distanceInternal !== undefined && bikeData.distanceInternal !== undefined) {
-            distance = Math.round(bikeData.distanceInternal - this.distanceInternal);
-        }
-        if (bikeData.distanceInternal !== undefined)
-            this.distanceInternal = bikeData.distanceInternal;
-        let data = {
-            speed: bikeData.speed,
-            slope: bikeData.slope,
-            power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
-            cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
-            distance,
-            timestamp: Date.now()
-        };
-        return data;
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'ftms: start requested', profile: this.getProfile(), props });
-            const { restart } = props || {};
-            if (!restart && this.ble.isScanning())
-                yield this.ble.stopScan();
-            try {
-                let bleDevice;
-                if (!this.device || !restart) {
-                    bleDevice = (yield this.ble.connectDevice(this.device));
-                    this.device = bleDevice;
-                }
-                else
-                    bleDevice = this.device;
-                if (bleDevice) {
-                    bleDevice.setLogger(this.logger);
-                    const mode = this.getCyclingMode();
-                    if (mode && mode.getSetting('bikeType')) {
-                        const bikeType = mode.getSetting('bikeType').toLowerCase();
-                        this.device.setCrr(cRR);
-                        switch (bikeType) {
-                            case 'race':
-                                this.device.setCw(cwABike.race);
-                                break;
-                            case 'triathlon':
-                                this.device.setCw(cwABike.triathlon);
-                                break;
-                            case 'mountain':
-                                this.device.setCw(cwABike.mountain);
-                                break;
-                        }
-                    }
-                    let hasControl = yield this.device.requestControl();
-                    if (!hasControl) {
-                        let retry = 1;
-                        while (!hasControl && retry < 3) {
-                            yield sleep(1000);
-                            hasControl = yield this.device.requestControl();
-                            retry++;
-                        }
-                    }
-                    if (!hasControl)
-                        throw new Error('could not establish control');
-                    const startRequest = this.getCyclingMode().getBikeInitRequest();
-                    yield this.sendUpdate(startRequest);
-                    bleDevice.on('data', (data) => {
-                        this.onDeviceData(data);
-                    });
-                    bleDevice.on('disconnected', this.emit);
-                    return true;
-                }
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
-                throw new Error(`could not start device, reason:${err.message}`);
-            }
-        });
-    }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stop requested', profile: this.getProfile() });
-            this.distanceInternal = 0;
-            this.device.reset();
-            return this.device.disconnect();
-        });
-    }
-    sendUpdate(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.paused || !this.device)
-                return;
-            const update = this.getCyclingMode().sendBikeUpdate(request);
-            this.logger.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
-            if (update.slope !== undefined) {
-                yield this.device.setSlope(update.slope);
-            }
-            if (update.targetPower !== undefined) {
-                yield this.device.setTargetPower(update.targetPower);
-            }
-        });
-    }
-    pause() { this.paused = true; return Promise.resolve(true); }
-    resume() { this.paused = false; return Promise.resolve(true); }
-}
-exports.FmAdapter = FmAdapter;

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

@@ -0,0 +1,6 @@
+export declare const cwABike: {
+    race: number;
+    triathlon: number;
+    mountain: number;
+};
+export declare const cRR = 0.0036;

package/lib/ble/fm/consts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cRR = exports.cwABike = void 0;
+exports.cwABike = {
+    race: 0.35,
+    triathlon: 0.29,
+    mountain: 0.57
+};
+exports.cRR = 0.0036;

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

@@ -0,0 +1,5 @@
+import BleFmComms from './comms';
+import BleFmAdapter from './adapter';
+import { IndoorBikeData } from './types';
+import { cRR, cwABike } from './consts';
+export { BleFmAdapter, BleFmComms, IndoorBikeData, cRR, cwABike };

package/lib/ble/fm/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cwABike = exports.cRR = exports.BleFmComms = exports.BleFmAdapter = void 0;
+const comms_1 = __importDefault(require("./comms"));
+exports.BleFmComms = comms_1.default;
+const adapter_1 = __importDefault(require("./adapter"));
+exports.BleFmAdapter = adapter_1.default;
+const consts_1 = require("./consts");
+Object.defineProperty(exports, "cRR", { enumerable: true, get: function () { return consts_1.cRR; } });
+Object.defineProperty(exports, "cwABike", { enumerable: true, get: function () { return consts_1.cwABike; } });

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

@@ -0,0 +1,25 @@
+export type IndoorBikeData = {
+    speed?: number;
+    averageSpeed?: number;
+    cadence?: number;
+    averageCadence?: number;
+    totalDistance?: number;
+    resistanceLevel?: number;
+    instantaneousPower?: number;
+    averagePower?: number;
+    totalEnergy?: number;
+    energyPerHour?: number;
+    energyPerMinute?: number;
+    heartrate?: number;
+    metabolicEquivalent?: number;
+    time?: number;
+    remainingTime?: number;
+    raw?: string;
+    targetPower?: number;
+    targetInclination?: number;
+    status?: string;
+};
+export type IndoorBikeFeatures = {
+    fitnessMachine: number;
+    targetSettings: number;
+};

package/lib/ble/fm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,17 @@
+import BleAdapter from '../adapter';
+import { DeviceProperties } from '../../types/device';
+import { BleDeviceSettings } from '../types';
+import { HrmData } from './types';
+import { DeviceData } from '../../types/data';
+export default class HrmAdapter extends BleAdapter {
+    ignore: boolean;
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    isSame(device: BleAdapter): boolean;
+    getProfile(): string;
+    getName(): string;
+    getDisplayName(): string;
+    getPort(): string;
+    setIgnoreHrm(ignore: any): void;
+    onDeviceData(deviceData: HrmData): void;
+    mapData(deviceData: HrmData): DeviceData;
+}

package/lib/ble/hr/adapter.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const adapter_1 = __importDefault(require("../adapter"));
+const comm_1 = __importDefault(require("./comm"));
+const capabilities_1 = require("../../types/capabilities");
+class HrmAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.ignore = false;
+        this.logger = new gd_eventlog_1.EventLogger('Ble-HR');
+        const { id, address, name } = settings;
+        const logger = this.logger;
+        const ble = this.ble;
+        this.device = new comm_1.default({ id, address, name, ble, logger });
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.HeartRate
+        ];
+    }
+    isSame(device) {
+        if (!(device instanceof HrmAdapter))
+            return false;
+        return this.isEqual(device.settings);
+    }
+    getProfile() {
+        return 'Heartrate Monitor';
+    }
+    getName() {
+        return `${this.device.name}`;
+    }
+    getDisplayName() {
+        const { name } = this.device;
+        const { heartrate: hrm } = this.deviceData;
+        const hrmStr = hrm ? ` (${hrm})` : '';
+        return `${name}${hrmStr}`;
+    }
+    getPort() {
+        return 'ble';
+    }
+    setIgnoreHrm(ignore) {
+        this.ignore = ignore;
+    }
+    onDeviceData(deviceData) {
+        super.onDeviceData(deviceData);
+        if (!this.started || this.paused || !this.onDataFn)
+            return;
+        if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {
+            this.logger.logEvent({ message: 'onDeviceData', data: deviceData });
+            this.data = this.mapData(this.deviceData);
+            this.onDataFn(this.data);
+            this.lastUpdate = Date.now();
+        }
+    }
+    mapData(deviceData) {
+        const { heartrate } = deviceData;
+        return { heartrate };
+    }
+}
+exports.default = HrmAdapter;

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

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { BleComms } from '../ble-comms';
+import { HrmData } from './types';
+export default class BleHrmDevice extends BleComms {
+    static services: string[];
+    static characteristics: string[];
+    static detectionPriority: number;
+    heartrate: number;
+    rr: number;
+    constructor(props?: any);
+    getProfile(): string;
+    getServiceUUids(): string[];
+    parseHrm(_data: Uint8Array): HrmData;
+    onData(characteristic: string, data: Buffer): boolean;
+}