incyclist-devices 2.0.0-beta.1 → 2.0.1

package/lib/ble/fm/adapter.js

@@ -17,7 +17,7 @@ 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 adapter_1 = require("../base/adapter");
 const consts_1 = require("./consts");
 const utils_1 = require("../../utils/utils");
 const capabilities_1 = require("../../types/capabilities");
@@ -50,23 +50,27 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
         return this.getName();
     }
     getSupportedCyclingModes() {
-        return [ble_st_mode_1.default, ble_erg_mode_1.default, power_meter_1.default];
+        var _a;
+        const modes = [power_meter_1.default];
+        const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
+        if (!features)
+            return [power_meter_1.default, ble_st_mode_1.default, ble_erg_mode_1.default];
+        if (features.setPower === undefined || features.setPower)
+            modes.push(ble_erg_mode_1.default);
+        if (features.setSlope === undefined || features.setSlope)
+            modes.push(ble_st_mode_1.default);
+        return modes;
     }
     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();
-        }
+        var _a;
+        const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
+        if (!features)
+            return new ble_st_mode_1.default(this);
+        if (features.setSlope === undefined || features.setSlope)
+            return new ble_st_mode_1.default(this);
+        if (features.setPower === undefined || features.setPower)
+            return new ble_erg_mode_1.default(this);
+        return new power_meter_1.default(this);
     }
     mapData(deviceData) {
         const data = {
@@ -83,6 +87,7 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
         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);
+        data.heartrate = deviceData.heartrate || data.heartrate;
         return data;
     }
     transformData(bikeData) {
@@ -100,73 +105,104 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
             power: bikeData.power !== undefined ? Math.round(bikeData.power) : undefined,
             cadence: bikeData.pedalRpm !== undefined ? Math.round(bikeData.pedalRpm) : undefined,
             distance,
+            heartrate: bikeData.heartrate,
             timestamp: Date.now()
         };
         return data;
     }
     start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.started)
+            const wasPaused = this.paused;
+            this.resume();
+            if (this.started && !wasPaused)
                 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;
+            this.logEvent(Object.assign(Object.assign({ message: 'start requested' }, this.getSettings()), { protocol: this.getProtocolName(), props }));
+            const { restart = wasPaused } = props;
+            if (!restart && this.ble.isScanning() && !this.getComms().isConnected()) {
+            }
+            let scanOnly = props.scanOnly;
+            if (this.ble.isScanning() && this.getComms().isConnected()) {
+                scanOnly = true;
+            }
+            else {
+                const { timeout = 20000 } = props || {};
+                if (!this.connectPromise)
+                    this.connectPromise = this.connect();
+                const res = yield Promise.race([
+                    this.connectPromise.then((connected) => {
+                        this.connectPromise = undefined;
+                        return { connected, reason: connected ? null : 'could not connect' };
+                    }),
+                    (0, utils_1.sleep)(timeout).then(() => ({ connected: false, reason: 'timeout' }))
+                ]);
+                const connected = res.connected;
+                if (!connected) {
+                    throw new Error(`could not start device, reason:${res.reason}`);
                 }
-                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;
+            }
+            try {
+                const comms = this.device;
+                if (comms) {
+                    if (!scanOnly) {
+                        const mode = this.getCyclingMode();
+                        if (mode && mode.getSetting('bikeType')) {
+                            const bikeType = mode.getSetting('bikeType').toLowerCase();
+                            comms.setCrr(consts_1.cRR);
+                            switch (bikeType) {
+                                case 'race':
+                                    comms.setCw(consts_1.cwABike.race);
+                                    break;
+                                case 'triathlon':
+                                    comms.setCw(consts_1.cwABike.triathlon);
+                                    break;
+                                case 'mountain':
+                                    comms.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++;
+                        let hasControl = yield comms.requestControl();
+                        if (!hasControl) {
+                            let retry = 1;
+                            while (!hasControl && retry < 3) {
+                                yield (0, utils_1.sleep)(1000);
+                                hasControl = yield comms.requestControl();
+                                retry++;
+                            }
                         }
+                        if (!hasControl)
+                            throw new Error('could not establish control');
+                        const startRequest = this.getCyclingMode().getBikeInitRequest();
+                        yield this.sendUpdate(startRequest);
+                    }
+                    if (!this.started && !wasPaused) {
+                        comms.on('data', (data) => {
+                            this.onDeviceData(data);
+                        });
+                        comms.on('disconnected', this.emit);
                     }
-                    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)) {
+                    const before = this.capabilities.join(',');
+                    if (comms.features.heartrate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
                         this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
                     }
+                    if (comms.features.cadence && !this.hasCapability(capabilities_1.IncyclistCapability.Cadence)) {
+                        this.capabilities.push(capabilities_1.IncyclistCapability.Cadence);
+                    }
+                    if (comms.features.power && !this.hasCapability(capabilities_1.IncyclistCapability.Power)) {
+                        this.capabilities.push(capabilities_1.IncyclistCapability.Power);
+                    }
+                    const after = this.capabilities.join(',');
+                    if (before !== after) {
+                        this.emit('device-info', this.getSettings(), { capabilities: this.capabilities });
+                    }
                     this.resetData();
                     this.stopped = false;
                     this.started = true;
-                    this.paused = false;
+                    this.resume();
                     return true;
                 }
             }
             catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
+                this.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
                 throw new Error(`could not start device, reason:${err.message}`);
             }
         });
@@ -175,16 +211,39 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
         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);
+            try {
+                const update = this.getCyclingMode().sendBikeUpdate(request);
+                this.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);
+                }
             }
-            if (update.targetPower !== undefined) {
-                yield device.setTargetPower(update.targetPower);
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'sendUpdate()', request, error: err.message, stack: err.stack });
             }
         });
     }
+    setCyclingMode(mode, settings) {
+        const modeChange = this.cyclingMode.getName() !== mode;
+        const prevMode = this.getCyclingMode();
+        super.setCyclingMode(mode, settings);
+        const isPaused = this.isPaused();
+        if (modeChange && this.started && !this.stopped) {
+            if (prevMode instanceof ble_st_mode_1.default) {
+                const power = this.data.power;
+                const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
+                if (isPaused)
+                    this.resume();
+                this.sendUpdate(request).then().catch().finally(() => {
+                    if (isPaused)
+                        this.pause();
+                });
+            }
+        }
+    }
 }
 exports.default = BleFmAdapter;

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

@@ -1,8 +1,10 @@
 /// <reference types="node" />
-import { BleWriteProps, IBlePeripheralConnector } from "../types";
-import { BleComms } from "../ble-comms";
+import { BleProtocol, BleWriteProps, IBlePeripheralConnector } from "../types";
 import { IndoorBikeData, IndoorBikeFeatures } from "./types";
+import { BleComms } from "../base/comms";
+import { LegacyProfile } from "../../antv2/types";
 export default class BleFitnessMachineDevice extends BleComms {
+    static protocol: BleProtocol;
     static services: string[];
     static characteristics: string[];
     static detectionPriority: number;
@@ -16,16 +18,14 @@ export default class BleFitnessMachineDevice extends BleComms {
     windSpeed: number;
     wheelSize: number;
     constructor(props?: any);
-    isMatching(characteristics: string[]): boolean;
+    static isMatching(characteristics: string[]): boolean;
     subscribeWriteResponse(cuuid: string): Promise<void>;
     subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
     init(): Promise<boolean>;
-    onDisconnect(): void;
-    getProfile(): string;
+    onDisconnect(): Promise<void>;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
     getServiceUUids(): string[];
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
     parseHrm(_data: Uint8Array): IndoorBikeData;
     setCrr(crr: number): void;
     getCrr(): number;

package/lib/ble/fm/comms.js

@@ -9,8 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_comms_1 = require("../ble-comms");
 const consts_1 = require("../consts");
+const comms_1 = require("../base/comms");
 const bit = (nr) => (1 << nr);
 const IndoorBikeDataFlag = {
     MoreData: bit(0),
@@ -65,7 +65,7 @@ const TargetSettingFeatureFlag = {
     SpinDownControlSupported: bit(15),
     TargetedCadenceConfigurationSupported: bit(16)
 };
-class BleFitnessMachineDevice extends ble_comms_1.BleComms {
+class BleFitnessMachineDevice extends comms_1.BleComms {
     constructor(props) {
         super(props);
         this.features = undefined;
@@ -79,7 +79,7 @@ class BleFitnessMachineDevice extends ble_comms_1.BleComms {
         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;
@@ -90,7 +90,7 @@ class BleFitnessMachineDevice extends ble_comms_1.BleComms {
     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);
@@ -110,36 +110,14 @@ class BleFitnessMachineDevice extends ble_comms_1.BleComms {
         });
     }
     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, {
@@ -150,39 +128,32 @@ class BleFitnessMachineDevice extends ble_comms_1.BleComms {
                 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 {
@@ -327,8 +298,14 @@ class BleFitnessMachineDevice extends ble_comms_1.BleComms {
                 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) {
@@ -520,6 +497,7 @@ class BleFitnessMachineDevice extends ble_comms_1.BleComms {
     }
 }
 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;

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

@@ -22,4 +22,9 @@ export type IndoorBikeData = {
 export type IndoorBikeFeatures = {
     fitnessMachine: number;
     targetSettings: number;
+    power?: boolean;
+    heartrate?: boolean;
+    cadence?: boolean;
+    setSlope?: boolean;
+    setPower?: boolean;
 };

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

@@ -1,4 +1,4 @@
-import BleAdapter from '../adapter';
+import BleAdapter from '../base/adapter';
 import { DeviceProperties } from '../../types/device';
 import { BleDeviceSettings } from '../types';
 import { HrmData } from './types';
@@ -10,8 +10,5 @@ export default class HrmAdapter extends BleAdapter {
     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

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const adapter_1 = __importDefault(require("../adapter"));
+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 {
@@ -37,23 +37,6 @@ class HrmAdapter extends adapter_1.default {
         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 };

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

@@ -1,14 +1,18 @@
 /// <reference types="node" />
-import { BleComms } from '../ble-comms';
+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(): string;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
     getServiceUUids(): string[];
     parseHrm(_data: Uint8Array): HrmData;
     onData(characteristic: string, data: Buffer): boolean;

package/lib/ble/hr/comm.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_comms_1 = require("../ble-comms");
-class BleHrmDevice extends ble_comms_1.BleComms {
+const comms_1 = require("../base/comms");
+class BleHrmDevice extends comms_1.BleComms {
     constructor(props) {
         super(props);
         this.heartrate = undefined;
@@ -10,6 +10,9 @@ class BleHrmDevice extends ble_comms_1.BleComms {
     getProfile() {
         return 'Heartrate Monitor';
     }
+    getProtocol() {
+        return BleHrmDevice.protocol;
+    }
     getServiceUUids() {
         return BleHrmDevice.services;
     }
@@ -47,6 +50,7 @@ class BleHrmDevice extends ble_comms_1.BleComms {
     }
 }
 exports.default = BleHrmDevice;
+BleHrmDevice.protocol = 'hr';
 BleHrmDevice.services = ['180d'];
 BleHrmDevice.characteristics = ['2a37', '2a38', '2a39', '2a3c'];
 BleHrmDevice.detectionPriority = 1;

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/index.d.ts

@@ -5,4 +5,5 @@ import { BlePwrAdapter } from './cp';
 import { BleFmAdapter } from './fm';
 import { BleWahooAdapter } from './wahoo';
 import { BleTacxAdapter } from './tacx';
-export { BleAdapterFactory, BleInterface, BleHrmAdapter, BlePwrAdapter, BleFmAdapter, BleWahooAdapter, BleTacxAdapter };
+import { BleDeviceSettings, BleInterfaceProps } from './types';
+export { BleAdapterFactory, BleInterface, BleInterfaceProps, BleDeviceSettings, BleHrmAdapter, BlePwrAdapter, BleFmAdapter, BleWahooAdapter, BleTacxAdapter };

package/lib/ble/index.js

@@ -19,8 +19,8 @@ Object.defineProperty(exports, "BleWahooAdapter", { enumerable: true, get: funct
 const tacx_1 = require("./tacx");
 Object.defineProperty(exports, "BleTacxAdapter", { enumerable: true, get: function () { return tacx_1.BleTacxAdapter; } });
 const af = adapter_factory_1.default.getInstance();
-af.register('hr', 'Heartrate Monitor', hr_1.BleHrmAdapter, hr_1.BleHrmComms);
-af.register('cp', 'Power Meter', cp_1.BlePwrAdapter, cp_1.BlePwrComms);
-af.register('fm', 'Smart Trainer', fm_1.BleFmAdapter, fm_1.BleFmComms);
-af.register('wahoo', 'Smart Trainer', wahoo_1.BleWahooAdapter, wahoo_1.BleWahooComms);
-af.register('tacx', 'Smart Trainer', tacx_1.BleTacxAdapter, tacx_1.BleTacxComms);
+af.register('hr', hr_1.BleHrmAdapter, hr_1.BleHrmComms);
+af.register('cp', cp_1.BlePwrAdapter, cp_1.BlePwrComms);
+af.register('fm', fm_1.BleFmAdapter, fm_1.BleFmComms);
+af.register('wahoo', wahoo_1.BleWahooAdapter, wahoo_1.BleWahooComms);
+af.register('tacx', tacx_1.BleTacxAdapter, tacx_1.BleTacxComms);