incyclist-devices 1.5.38 → 2.0.0

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 consts_1 = require("../consts");
+const comms_1 = require("../base/comms");
 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 comms_1.BleComms {
     constructor(props) {
         super(props);
         this.features = undefined;
@@ -96,7 +79,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         this.data = {};
         this.services = BleFitnessMachineDevice.services;
     }
-    isMatching(characteristics) {
+    static isMatching(characteristics) {
         if (!characteristics)
             return false;
         const hasStatus = characteristics.find(c => c === consts_1.FTMS_STATUS) !== undefined;
@@ -107,7 +90,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     subscribeWriteResponse(cuuid) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'subscribe to CP response', characteristics: cuuid });
-            const connector = this.ble.getConnector(this.peripheral);
+            const connector = this.ble.peripheralCache.getConnector(this.peripheral);
             const isAlreadySubscribed = connector.isSubscribed(cuuid);
             if (!isAlreadySubscribed) {
                 connector.removeAllListeners(cuuid);
@@ -127,36 +110,14 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         });
     }
     subscribeAll(conn) {
-        return new Promise(resolve => {
-            const characteristics = [consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP];
-            const timeout = Date.now() + 5500;
-            const iv = setInterval(() => {
-                const subscriptionStatus = characteristics.map(c => this.subscribedCharacteristics.find(s => s === c) !== undefined);
-                const done = subscriptionStatus.filter(s => s === true).length === characteristics.length;
-                if (done || Date.now() > timeout) {
-                    clearInterval(iv);
-                    resolve();
-                }
-            }, 100);
-            try {
-                const connector = conn || this.ble.getConnector(this.peripheral);
-                for (let i = 0; i < characteristics.length; i++) {
-                    const c = characteristics[i];
-                    const isAlreadySubscribed = connector.isSubscribed(c);
-                    if (!isAlreadySubscribed) {
-                        connector.removeAllListeners(c);
-                        connector.on(c, (uuid, data) => {
-                            this.onData(uuid, data);
-                        });
-                        connector.subscribe(c);
-                        this.subscribedCharacteristics.push(c);
-                    }
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
-            }
-        });
+        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, {
@@ -167,39 +128,32 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                 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 Promise.resolve(false);
+                return false;
             }
         });
     }
     onDisconnect() {
-        super.onDisconnect();
-        this.hasControl = false;
+        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;
     }
-    isBike() {
-        return this.features === undefined ||
-            ((this.features.targetSettings & TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0);
-    }
-    isPower() {
-        if (this.hasService('1818'))
-            return true;
-        if (this.features === undefined)
-            return false;
-        const { fitnessMachine } = this.features;
-        if (fitnessMachine & FitnessMachineFeatureFlag.PowerMeasurementSupported)
-            return true;
-    }
-    isHrm() {
-        return this.hasService('180d') || (this.features && (this.features.fitnessMachine & FitnessMachineFeatureFlag.HeartRateMeasurementSupported) !== 0);
-    }
     parseHrm(_data) {
         const data = Buffer.from(_data);
         try {
@@ -344,8 +298,14 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                 if (buffer) {
                     const fitnessMachine = buffer.readUInt32LE(0);
                     const targetSettings = buffer.readUInt32LE(4);
-                    this.features = { fitnessMachine, targetSettings };
-                    this.logEvent({ message: 'supported Features: ', fatures: this.features });
+                    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) {
@@ -537,210 +497,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     }
 }
 exports.default = BleFitnessMachineDevice;
+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;
-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,30 @@
+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;
+    power?: boolean;
+    heartrate?: boolean;
+    cadence?: boolean;
+    setSlope?: boolean;
+    setPower?: boolean;
+};

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,14 @@
+import BleAdapter from '../base/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;
+    mapData(deviceData: HrmData): DeviceData;
+}

package/lib/ble/hr/adapter.js

@@ -0,0 +1,45 @@
+"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("../base/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}`;
+    }
+    mapData(deviceData) {
+        const { heartrate } = deviceData;
+        return { heartrate };
+    }
+}
+exports.default = HrmAdapter;

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

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+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[];
+    parseHrm(_data: Uint8Array): HrmData;
+    onData(characteristic: string, data: Buffer): boolean;
+}

package/lib/ble/hr/comm.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comms_1 = require("../base/comms");
+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;
+    }
+    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;
+    }
+}
+exports.default = BleHrmDevice;
+BleHrmDevice.protocol = 'hr';
+BleHrmDevice.services = ['180d'];
+BleHrmDevice.characteristics = ['2a37', '2a38', '2a39', '2a3c'];
+BleHrmDevice.detectionPriority = 1;

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

@@ -0,0 +1,4 @@
+import { HrmData } from './types';
+import BleHrmAdapter from './adapter';
+import BleHrmComms from './comm';
+export { HrmData, BleHrmAdapter, BleHrmComms };

package/lib/ble/hr/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.BleHrmComms = exports.BleHrmAdapter = void 0;
+const adapter_1 = __importDefault(require("./adapter"));
+exports.BleHrmAdapter = adapter_1.default;
+const comm_1 = __importDefault(require("./comm"));
+exports.BleHrmComms = comm_1.default;

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

@@ -0,0 +1,7 @@
+import { BleMockPeripheral } from "../bindings/mock";
+interface BleHrMockPeripheral extends BleMockPeripheral {
+    setNotifyFrequency: (ms: number) => void;
+    setHeartrate: (hr: number) => void;
+}
+export declare const HrMock: BleHrMockPeripheral;
+export {};

package/lib/ble/hr/mock.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HrMock = void 0;
+const types_1 = require("../bindings/types");
+class HeartRateMeasuremenCharacteristic extends types_1.StaticNotifyCharacteristic {
+    constructor(uuid, description, heartrate = 0) {
+        super(uuid, description);
+        this.heartrate = heartrate;
+        this.value = Buffer.from(this.heartrate.toString());
+    }
+    notify() {
+        const buffer = Buffer.alloc(2);
+        buffer.writeUInt8(0, 0);
+        buffer.writeUInt8(this.heartrate, 1);
+        this.emit('data', buffer);
+    }
+}
+const HR = {
+    uuid: "180d",
+    characteristics: [
+        new HeartRateMeasuremenCharacteristic('2a37', 'Heart Rate Measurement', 60)
+    ]
+};
+const DIS = {
+    uuid: '180a',
+    characteristics: [
+        new types_1.StaticReadCharacteristic('2a23', 'System Id', '0'),
+        new types_1.StaticReadCharacteristic('2a24', 'Model Number', '1'),
+        new types_1.StaticReadCharacteristic('2a25', 'Serial Number', '4711'),
+        new types_1.StaticReadCharacteristic('2a26', 'Firmware Revision', '1'),
+        new types_1.StaticReadCharacteristic('2a27', 'Hardware Revision', '1'),
+        new types_1.StaticReadCharacteristic('2a28', 'Software Revision', '1'),
+        new types_1.StaticReadCharacteristic('2a29', 'Manufacturer Name', 'Incyclist')
+    ]
+};
+exports.HrMock = {
+    services: [HR, DIS],
+    id: "a87b6100820d48b1401bf83a8cf6f046",
+    name: "HRM-Mock",
+    address: "a87b6100820d48b1401bf83a8cf6f046",
+    setNotifyFrequency: (ms) => {
+        HR.characteristics[0].notifyFrequency = ms;
+    },
+    setHeartrate: (hr) => {
+        HR.characteristics[0].heartrate = hr;
+    }
+};

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

@@ -0,0 +1,5 @@
+export type HrmData = {
+    heartrate: number;
+    rr: number;
+    raw: string;
+};