incyclist-devices 1.5.37 → 2.0.0-beta.1

package/lib/ble/hr/comm.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ble_comms_1 = require("../ble-comms");
+class BleHrmDevice extends ble_comms_1.BleComms {
+    constructor(props) {
+        super(props);
+        this.heartrate = undefined;
+        this.rr = undefined;
+    }
+    getProfile() {
+        return 'Heartrate Monitor';
+    }
+    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.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/types.d.ts

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

package/lib/ble/hr/types.js

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

package/lib/ble/index.d.ts

@@ -0,0 +1,8 @@
+import BleInterface from './ble-interface';
+import BleAdapterFactory from './adapter-factory';
+import { BleHrmAdapter } from './hr';
+import { BlePwrAdapter } from './cp';
+import { BleFmAdapter } from './fm';
+import { BleWahooAdapter } from './wahoo';
+import { BleTacxAdapter } from './tacx';
+export { BleAdapterFactory, BleInterface, BleHrmAdapter, BlePwrAdapter, BleFmAdapter, BleWahooAdapter, BleTacxAdapter };

package/lib/ble/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleTacxAdapter = exports.BleWahooAdapter = exports.BleFmAdapter = exports.BlePwrAdapter = exports.BleHrmAdapter = exports.BleInterface = exports.BleAdapterFactory = void 0;
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+exports.BleInterface = ble_interface_1.default;
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+exports.BleAdapterFactory = adapter_factory_1.default;
+const hr_1 = require("./hr");
+Object.defineProperty(exports, "BleHrmAdapter", { enumerable: true, get: function () { return hr_1.BleHrmAdapter; } });
+const cp_1 = require("./cp");
+Object.defineProperty(exports, "BlePwrAdapter", { enumerable: true, get: function () { return cp_1.BlePwrAdapter; } });
+const fm_1 = require("./fm");
+Object.defineProperty(exports, "BleFmAdapter", { enumerable: true, get: function () { return fm_1.BleFmAdapter; } });
+const wahoo_1 = require("./wahoo");
+Object.defineProperty(exports, "BleWahooAdapter", { enumerable: true, get: function () { return wahoo_1.BleWahooAdapter; } });
+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);

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

@@ -0,0 +1,10 @@
+import { BleFmAdapter } from '../fm';
+import BleAdapter from '../adapter';
+import { DeviceProperties } from '../../types/device';
+import { BleDeviceSettings, BleStartProperties } from '../types';
+export default class BleTacxFEAdapter extends BleFmAdapter {
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    isSame(device: BleAdapter): boolean;
+    getProfile(): string;
+    start(props?: BleStartProperties): Promise<any>;
+}

package/lib/ble/tacx/adapter.js

@@ -0,0 +1,93 @@
+"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 fm_1 = require("../fm");
+const comms_1 = __importDefault(require("./comms"));
+const adpater_1 = require("../../base/adpater");
+const capabilities_1 = require("../../types/capabilities");
+class BleTacxFEAdapter extends fm_1.BleFmAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.logger = new gd_eventlog_1.EventLogger('BLE-FEC-Tacx');
+        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 BleTacxFEAdapter))
+            return false;
+        return this.isEqual(device.settings);
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            if (this.ble.isScanning())
+                yield this.ble.stopScan();
+            try {
+                const bleDevice = yield this.ble.connectDevice(this.device);
+                bleDevice.setLogger(this.logger);
+                if (bleDevice) {
+                    this.device = bleDevice;
+                    const mode = this.getCyclingMode();
+                    if (mode && mode.getSetting('bikeType')) {
+                        const bikeType = mode.getSetting('bikeType').toLowerCase();
+                        bleDevice.setCrr(fm_1.cRR);
+                        switch (bikeType) {
+                            case 'race':
+                                bleDevice.setCw(fm_1.cwABike.race);
+                                break;
+                            case 'triathlon':
+                                bleDevice.setCw(fm_1.cwABike.triathlon);
+                                break;
+                            case 'mountain':
+                                bleDevice.setCw(fm_1.cwABike.mountain);
+                                break;
+                        }
+                    }
+                    const { user, wheelDiameter, gearRatio, bikeWeight = adpater_1.DEFAULT_BIKE_WEIGHT } = props || {};
+                    const userWeight = (user && user.weight ? user.weight : adpater_1.DEFAULT_USER_WEIGHT);
+                    bleDevice.sendTrackResistance(0.0);
+                    bleDevice.sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio);
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
+                    bleDevice.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    this.resetData();
+                    this.stopped = false;
+                    this.started = true;
+                    this.paused = false;
+                    if (bleDevice.isHrm() && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
+                        this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+                    }
+                    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}`);
+            }
+        });
+    }
+}
+exports.default = BleTacxFEAdapter;

package/lib/ble/{tacx.d.ts → tacx/comms.d.ts}

@@ -1,30 +1,9 @@
 /// <reference types="node" />
-import BleProtocol from './incyclist-protocol';
-import { BleDeviceClass } from './ble';
-import DeviceAdapter from '../device';
-import BleFitnessMachineDevice, { FmAdapter, IndoorBikeData } from './fm';
-import BlePeripheralConnector from './ble-peripheral';
-interface BleFeBikeData extends IndoorBikeData {
-    EquipmentType?: 'Treadmill' | 'Elliptical' | 'StationaryBike' | 'Rower' | 'Climber' | 'NordicSkier' | 'Trainer' | 'General';
-    RealSpeed?: number;
-    VirtualSpeed?: number;
-    HeartRateSource?: 'HandContact' | 'EM' | 'ANT+';
-    State?: 'OFF' | 'READY' | 'IN_USE' | 'FINISHED';
-    EventCount?: number;
-    AccumulatedPower?: number;
-    TrainerStatus?: number;
-    TargetStatus?: 'OnTarget' | 'LowSpeed' | 'HighSpeed';
-    HwVersion?: number;
-    ManId?: number;
-    ModelNum?: number;
-    SwVersion?: number;
-    SerialNumber?: number;
-}
-declare type CrankData = {
-    revolutions?: number;
-    time?: number;
-    cntUpdateMissing?: number;
-};
+import { CrankData } from "../cp";
+import { IndoorBikeData } from "../fm";
+import BleFitnessMachineDevice from "../fm/comms";
+import { IBlePeripheralConnector } from "../types";
+import { BleFeBikeData } from "./types";
 export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
     static services: string[];
     static characteristics: string[];
@@ -42,7 +21,7 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     constructor(props?: any);
     isMatching(characteristics: string[]): boolean;
     setCharacteristicUUIDs(uuids: string[]): void;
-    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
+    subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
     init(): Promise<boolean>;
     getProfile(): string;
     getServiceUUids(): string[];
@@ -79,14 +58,3 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     setSlope(slope: any): Promise<boolean>;
     reset(): void;
 }
-export declare class TacxBleFEAdapter extends FmAdapter {
-    static PROFILE: string;
-    device: TacxAdvancedFitnessMachineDevice;
-    constructor(device: BleDeviceClass, protocol: BleProtocol);
-    isSame(device: DeviceAdapter): boolean;
-    getProfile(): string;
-    start(props?: any): Promise<any>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-}
-export {};

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

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 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) {
@@ -31,23 +12,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TacxBleFEAdapter = void 0;
-const ble_interface_1 = __importDefault(require("./ble-interface"));
-const ble_1 = require("./ble");
-const device_1 = require("../device");
-const gd_eventlog_1 = require("gd-eventlog");
-const fm_1 = __importStar(require("./fm"));
-const consts_1 = require("./consts");
-const SYNC_BYTE = 0xA4;
-const DEFAULT_CHANNEL = 5;
-const ACKNOWLEDGED_DATA = 0x4F;
-const PROFILE_ID = 'Tacx SmartTrainer';
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
+const consts_1 = require("../consts");
+const comms_1 = __importDefault(require("../fm/comms"));
+const utils_1 = require("../utils");
 var ANTMessages;
 (function (ANTMessages) {
     ANTMessages[ANTMessages["calibrationCommand"] = 1] = "calibrationCommand";
@@ -66,7 +33,11 @@ var ANTMessages;
     ANTMessages[ANTMessages["manufactererData"] = 80] = "manufactererData";
     ANTMessages[ANTMessages["productInformation"] = 81] = "productInformation";
 })(ANTMessages || (ANTMessages = {}));
-class TacxAdvancedFitnessMachineDevice extends fm_1.default {
+const PROFILE_ID = 'Tacx SmartTrainer';
+const SYNC_BYTE = 0xA4;
+const DEFAULT_CHANNEL = 5;
+const ACKNOWLEDGED_DATA = 0x4F;
+class TacxAdvancedFitnessMachineDevice extends comms_1.default {
     constructor(props) {
         super(props);
         this.prevCrankData = undefined;
@@ -82,15 +53,15 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
     isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasTacxCP = characteristics.find(c => (0, ble_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
-            characteristics.find(c => (0, ble_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
+        const hasTacxCP = characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
+            characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
         return hasTacxCP;
     }
     setCharacteristicUUIDs(uuids) {
         uuids.forEach(c => {
-            if ((0, ble_1.matches)(c, consts_1.TACX_FE_C_RX))
+            if ((0, utils_1.matches)(c, consts_1.TACX_FE_C_RX))
                 this.tacxRx = c;
-            if ((0, ble_1.matches)(c, consts_1.TACX_FE_C_TX))
+            if ((0, utils_1.matches)(c, consts_1.TACX_FE_C_TX))
                 this.tacxTx = c;
         });
     }
@@ -484,7 +455,7 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         try {
             const uuid = characteristic.toLocaleLowerCase();
             let res = undefined;
-            if (uuid && (0, ble_1.matches)(uuid, this.tacxRx)) {
+            if (uuid && (0, utils_1.matches)(uuid, this.tacxRx)) {
                 res = this.parseFECMessage(data);
             }
             else {
@@ -693,73 +664,3 @@ TacxAdvancedFitnessMachineDevice.services = [consts_1.TACX_FE_C_BLE];
 TacxAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.TACX_FE_C_RX, consts_1.TACX_FE_C_TX];
 TacxAdvancedFitnessMachineDevice.PROFILE = PROFILE_ID;
 TacxAdvancedFitnessMachineDevice.detectionPriority = 10;
-ble_interface_1.default.register('TacxBleFEDevice', 'tacx-ble-fec', TacxAdvancedFitnessMachineDevice, TacxAdvancedFitnessMachineDevice.services);
-class TacxBleFEAdapter extends fm_1.FmAdapter {
-    constructor(device, protocol) {
-        super(device, protocol);
-        this.device = device;
-        this.ble = protocol.ble;
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.logger = new gd_eventlog_1.EventLogger('BLE-FEC-Tacx');
-        if (this.device)
-            this.device.setLogger(this.logger);
-    }
-    isSame(device) {
-        if (!(device instanceof TacxBleFEAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
-    }
-    getProfile() {
-        return TacxBleFEAdapter.PROFILE;
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'tacx: start requested', profile: this.getProfile(), props });
-            if (this.ble.isScanning())
-                yield this.ble.stopScan();
-            try {
-                const bleDevice = yield this.ble.connectDevice(this.device);
-                bleDevice.setLogger(this.logger);
-                if (bleDevice) {
-                    this.device = bleDevice;
-                    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;
-                        }
-                    }
-                    const { user, wheelDiameter, gearRatio } = props || {};
-                    const userWeight = (user && user.weight ? user.weight : device_1.DEFAULT_USER_WEIGHT);
-                    const bikeWeight = device_1.DEFAULT_BIKE_WEIGHT;
-                    this.device.sendTrackResistance(0.0);
-                    this.device.sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio);
-                    const startRequest = this.getCyclingMode().getBikeInitRequest();
-                    yield this.sendUpdate(startRequest);
-                    bleDevice.on('data', (data) => {
-                        this.onDeviceData(data);
-                    });
-                    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}`);
-            }
-        });
-    }
-    pause() { this.paused = true; return Promise.resolve(true); }
-    resume() { this.paused = false; return Promise.resolve(true); }
-}
-exports.TacxBleFEAdapter = TacxBleFEAdapter;
-TacxBleFEAdapter.PROFILE = PROFILE_ID;

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

@@ -0,0 +1,4 @@
+import BleTacxComms from "./comms";
+import BleTacxAdapter from "./adapter";
+import { BleFeBikeData } from "./types";
+export { BleTacxAdapter, BleTacxComms, BleFeBikeData };

package/lib/ble/tacx/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.BleTacxComms = exports.BleTacxAdapter = void 0;
+const comms_1 = __importDefault(require("./comms"));
+exports.BleTacxComms = comms_1.default;
+const adapter_1 = __importDefault(require("./adapter"));
+exports.BleTacxAdapter = adapter_1.default;

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

@@ -0,0 +1,25 @@
+import { IndoorBikeData } from "../fm";
+export interface BleFeBikeData extends IndoorBikeData {
+    EquipmentType?: 'Treadmill' | 'Elliptical' | 'StationaryBike' | 'Rower' | 'Climber' | 'NordicSkier' | 'Trainer' | 'General';
+    RealSpeed?: number;
+    VirtualSpeed?: number;
+    HeartRateSource?: 'HandContact' | 'EM' | 'ANT+';
+    State?: 'OFF' | 'READY' | 'IN_USE' | 'FINISHED';
+    EventCount?: number;
+    AccumulatedPower?: number;
+    TrainerStatus?: number;
+    TargetStatus?: 'OnTarget' | 'LowSpeed' | 'HighSpeed';
+    HwVersion?: number;
+    ManId?: number;
+    ModelNum?: number;
+    SwVersion?: number;
+    SerialNumber?: number;
+}
+export type MessageInfo = {
+    message: string;
+    ts: number;
+    uuid: string;
+};
+export type MessageLog = {
+    [uuid: string]: MessageInfo;
+};

package/lib/ble/tacx/types.js

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

package/lib/ble/types.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from "stream";
+import { DeviceProperties, DeviceSettings } from "../types/device";
+export interface BleDeviceSettings extends DeviceSettings {
+    id?: string;
+    profile: string;
+    protocol: string;
+    address?: string;
+}
+export interface BleDeviceProperties extends DeviceProperties {
+    wheelDiameter?: number;
+    gearRatio?: number;
+}
+export interface BleStartProperties extends BleDeviceProperties {
+    restart?: boolean;
+}
+export interface BlePeripheral extends EventEmitter, BlePeripheralIdentifier {
+    services: string[];
+    advertisement: any;
+    state: string;
+    connectAsync(): Promise<void>;
+    disconnect(cb: (err?: Error) => void): Promise<void>;
+    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<any>;
+}
+export interface IBlePeripheralConnector {
+    connect(): Promise<void>;
+    reconnect(): Promise<void>;
+    initialize(enforce: boolean): Promise<void>;
+    isSubscribed(characteristicUuid: string): boolean;
+    subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
+    subscribe(characteristicUuid: string, timeout?: number): Promise<boolean>;
+    onDisconnect(): void;
+    onData(characteristicUuid: string, data: any): void;
+    on(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
+    off(characteristicUuid: string, callback: (characteristicUuid: string, data: any) => void): void;
+    removeAllListeners(characteristicUuid: string): void;
+    getState(): string;
+    getCharachteristics(): BleCharacteristic[];
+    getServices(): string[];
+    getPeripheral(): BlePeripheral;
+}
+export interface BleCharacteristic extends EventEmitter {
+    uuid: string;
+    properties: string[];
+    subscribe(callback: (err: Error) => void): void;
+    read(callback: (err: Error, data: Buffer) => void): void;
+    write(data: Buffer, withoutResponse: boolean, callback?: (err: Error) => void): void;
+}
+export type BleDeviceProps = {
+    id?: string;
+    address?: string;
+    name?: string;
+    services?: string[];
+    peripheral?: BlePeripheral;
+};
+export type ConnectProps = {
+    timeout?: number;
+    reconnect?: boolean;
+};
+export interface BleWriteProps {
+    withoutResponse?: boolean;
+    timeout?: number;
+}
+export interface BlePeripheralIdentifier {
+    id?: string;
+    address?: string;
+    name?: string;
+}
+export interface BlePeripheralDescription extends BlePeripheralIdentifier {
+    profile: string;
+}
+export interface ConnectState {
+    isConnecting: boolean;
+    isConnected: boolean;
+    isDisconnecting: boolean;
+}
+export type BleDeviceInfo = {
+    manufacturer?: string;
+    hwRevision?: string;
+    swRevision?: string;
+    fwRevision?: string;
+    model?: string;
+    serialNo?: string;
+};
+export declare abstract class BleDeviceCommsClass extends EventEmitter {
+    static services: string[];
+    id?: string;
+    address?: string;
+    name?: string;
+    connectState: ConnectState;
+    getConnectState(): ConnectState;
+    isConnected(): boolean;
+    abstract getProfile(): string;
+    abstract getServiceUUids(): string[];
+    abstract connect(props?: ConnectProps): Promise<boolean>;
+    abstract disconnect(): Promise<boolean>;
+    abstract getDeviceInfo(): Promise<BleDeviceInfo>;
+    abstract getServices(): string[];
+    setCharacteristicUUIDs(uuids: string[]): void;
+}

package/lib/ble/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleDeviceCommsClass = void 0;
+const stream_1 = require("stream");
+class BleDeviceCommsClass extends stream_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
+    }
+    getConnectState() {
+        return this.connectState;
+    }
+    isConnected() {
+        return this.connectState.isConnected;
+    }
+    setCharacteristicUUIDs(uuids) { }
+}
+exports.BleDeviceCommsClass = BleDeviceCommsClass;
+BleDeviceCommsClass.services = [];

package/lib/ble/utils.d.ts

@@ -0,0 +1,7 @@
+import { BleComms } from "./ble-comms";
+export declare function uuid(s: string): string;
+export declare function matches(uuid1: string, uuid2: string): boolean;
+export declare function getBestDeviceMatch(DeviceClasses: (typeof BleComms)[]): typeof BleComms;
+export declare function getDevicesFromServices(deviceTypes: (typeof BleComms)[], services: string | string[]): (typeof BleComms)[];
+export declare function getServicesFromDeviceTypes(deviceTypes: (typeof BleComms)[]): string[];
+export declare function getServicesFromDevice(device: BleComms): string[];