incyclist-devices 2.2.9 → 2.3.0

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

@@ -1,75 +1,3 @@
-import EventEmitter from "events";
-import { EventLogger } from "gd-eventlog";
-import { LegacyProfile } from "../../antv2/types";
-import BleInterface from "../ble-interface";
-import BlePeripheralConnector from "../ble-peripheral";
-import { BleCharacteristic, BleCommsConnectProps, BleDeviceConstructProps, BleDeviceInfo, BleDeviceSettings, BlePeripheral, BleProtocol, BleWriteProps, ConnectState, IBlePeripheralConnector } from "../types";
-type CommandQueueItem = {
-    uuid: string;
-    data: Buffer;
-    timeout: number;
-    resolve: any;
-    reject: any;
-};
-export interface MessageLog {
-    uuid: string;
-    timestamp: any;
-    data: string;
+import { IBleSensor } from "../types";
+export declare class BleSensor implements IBleSensor {
 }
-export declare class BleComms extends EventEmitter {
-    static services: string[];
-    static protocol: BleProtocol;
-    id: string;
-    paused: boolean;
-    address: string;
-    name: string;
-    services: string[];
-    ble: BleInterface;
-    peripheral?: BlePeripheral;
-    characteristics: BleCharacteristic[];
-    state?: string;
-    logger?: EventLogger;
-    deviceInfo: BleDeviceInfo;
-    isInitialized: boolean;
-    subscribedCharacteristics: string[];
-    writeQueue: CommandQueueItem[];
-    workerIv: NodeJS.Timeout;
-    prevMessages: MessageLog[];
-    connectState: ConnectState;
-    constructor(props?: BleDeviceConstructProps);
-    getConnectState(): ConnectState;
-    isConnected(): boolean;
-    pause(): void;
-    resume(): void;
-    getServiceUUids(): string[];
-    getProfile(): LegacyProfile;
-    getProtocol(): BleProtocol;
-    getSettings(): BleDeviceSettings;
-    getServices(): string[];
-    logEvent(event: any): void;
-    setLogger(logger: EventLogger): void;
-    setInterface(ble: BleInterface): void;
-    static isMatching(characteristics: string[]): boolean;
-    reset(): void;
-    cleanupListeners(): void;
-    onDisconnect(): Promise<void>;
-    waitForConnectFinished(timeout: any): Promise<unknown>;
-    hasService(serviceUuid: any): boolean;
-    init(): Promise<boolean>;
-    initDevice(): Promise<boolean>;
-    connectPeripheral(peripheral: BlePeripheral): Promise<boolean>;
-    subscribeMultiple(characteristics: string[], conn?: IBlePeripheralConnector): Promise<void>;
-    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
-    unsubscribeAll(conn?: BlePeripheralConnector): void;
-    connect(props?: BleCommsConnectProps): Promise<boolean>;
-    disconnect(): Promise<boolean>;
-    checkForDuplicate(characteristic: string, data: Buffer): boolean;
-    onData(characteristic: string, _data: Buffer): boolean;
-    timeoutCheck(): void;
-    startWorker(): void;
-    stopWorker(): void;
-    write(characteristicUuid: string, data: Buffer, props?: BleWriteProps): Promise<ArrayBuffer>;
-    read(characteristicUuid: string): Promise<Uint8Array>;
-    getDeviceInfo(): Promise<BleDeviceInfo>;
-}
-export {};

package/lib/ble/base/comms.js

@@ -1,599 +1,6 @@
 "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 });
-exports.BleComms = void 0;
-const events_1 = __importDefault(require("events"));
-const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../../utils/utils");
-const ble_interface_1 = __importDefault(require("../ble-interface"));
-const utils_2 = require("../utils");
-const CONNECT_WAIT_TIMEOUT = 10000;
-const BLE_TIMEOUT = 1000;
-class BleComms extends events_1.default {
-    constructor(props) {
-        super();
-        this.characteristics = [];
-        this.deviceInfo = {};
-        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
-        this.id = props.id;
-        this.address = props.address;
-        this.name = props.name;
-        this.services = props.services;
-        this.ble = ble_interface_1.default.getInstance();
-        this.characteristics = [];
-        this.subscribedCharacteristics = [];
-        this.isInitialized = false;
-        this.writeQueue = [];
-        this.workerIv = null;
-        this.prevMessages = [];
-        this.paused = false;
-        if (props.peripheral) {
-            const { id, address, advertisement, state } = props.peripheral;
-            this.peripheral = props.peripheral;
-            this.id = id;
-            this.address = address;
-            this.name = advertisement.localName;
-            this.services = advertisement.serviceUuids;
-            this.state = state;
-        }
-        if (props.logger) {
-            this.logger = props.logger;
-        }
-        else if (props.log !== false) {
-            this.logger = new gd_eventlog_1.EventLogger('BleDevice');
-        }
-    }
-    getConnectState() {
-        return this.connectState;
-    }
-    isConnected() {
-        return this.connectState.isConnected;
-    }
-    pause() {
-        this.ble.pauseLogging();
-        this.paused = true;
-    }
-    resume() {
-        this.paused = false;
-        this.ble.resumeLogging();
-    }
-    getServiceUUids() {
-        throw new Error("Method not implemented.");
-    }
-    getProfile() {
-        throw new Error("Method not implemented.");
-    }
-    getProtocol() {
-        throw new Error("Method not implemented.");
-    }
-    getSettings() {
-        const { id, address, name } = this;
-        return { id, name, address, interface: 'ble', protocol: this.getProtocol() };
-    }
-    getServices() {
-        return this.services;
-    }
-    logEvent(event) {
-        if (this.paused)
-            return;
-        if (this.logger) {
-            this.logger.logEvent(event);
-        }
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
-            console.log('~~~ BLE', event);
-        }
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    setInterface(ble) {
-        this.ble = ble;
-    }
-    static isMatching(characteristics) {
-        return true;
-    }
-    reset() {
-        if (this.connectState.isConnecting)
-            this.ble.stopConnectSensor();
-    }
-    cleanupListeners() {
-        if (this.characteristics === undefined) {
-            this.characteristics = [];
-        }
-        else {
-            if (this.peripheral) {
-                const connector = this.ble.peripheralCache.getConnector(this.peripheral);
-                this.characteristics.forEach(c => {
-                    connector.removeAllListeners((0, utils_2.uuid)(c.uuid));
-                });
-            }
-            else {
-                this.characteristics = [];
-            }
-        }
-    }
-    onDisconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
-            this.state = "disconnected";
-            const wasConnecting = this.connectState.isConnecting;
-            this.connectState.isConnecting = false;
-            this.connectState.isConnected = false;
-            if (!this.connectState.isDisconnecting) {
-                this.peripheral.state = 'disconnected';
-                this.cleanupListeners();
-                this.subscribedCharacteristics = [];
-                this.ble.onDisconnect(this.peripheral);
-                if (wasConnecting) {
-                    this.emit('connection-failed');
-                }
-                else {
-                    this.connect({ reconnect: true });
-                }
-            }
-        });
-    }
-    waitForConnectFinished(timeout) {
-        const waitStart = Date.now();
-        const waitTimeout = waitStart + timeout;
-        return new Promise((resolve, reject) => {
-            const waitIv = setInterval(() => {
-                try {
-                    if (this.connectState.isConnecting && Date.now() > waitTimeout) {
-                        clearInterval(waitIv);
-                        return reject(new Error('connection already in progress'));
-                    }
-                    if (!this.connectState.isConnecting) {
-                        clearInterval(waitIv);
-                        return resolve(true);
-                    }
-                }
-                catch (err) {
-                    this.logEvent({ message: 'error', fn: '', error: err.message, stack: err.stack });
-                }
-            }, 100);
-        });
-    }
-    hasService(serviceUuid) {
-        return this.services && this.services.find(s => s === serviceUuid || (0, utils_2.uuid)(serviceUuid)) !== undefined;
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.initDevice();
-        });
-    }
-    initDevice() {
-        this.logEvent({ message: 'get device info' });
-        return this.getDeviceInfo().then((info) => {
-            this.emit('deviceInfo', info);
-            this.logEvent(Object.assign({ message: 'device init done' }, info));
-            this.isInitialized = true;
-            return true;
-        });
-    }
-    connectPeripheral(peripheral) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.connectState.isConnecting = true;
-            let disconnectSignalled = false;
-            return new Promise((done) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const connector = this.ble.peripheralCache.getConnector(peripheral);
-                    const disconnectHandler = () => {
-                        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
-                        this.state = "disconnected";
-                        disconnectSignalled = true;
-                        this.cleanupListeners();
-                        this.subscribedCharacteristics = [];
-                        this.connectState.isConnecting = false;
-                        this.connectState.isConnected = false;
-                        this.ble.onDisconnect(this.peripheral);
-                        done(false);
-                    };
-                    connector.removeAllListeners('disconnect');
-                    connector.once('disconnect', disconnectHandler);
-                    yield connector.connect();
-                    if (disconnectSignalled)
-                        return;
-                    const initialized = yield connector.initialize();
-                    if (!initialized || disconnectSignalled)
-                        return done(false);
-                    yield this.subscribeAll(connector);
-                    if (disconnectSignalled)
-                        return done(false);
-                    this.connectState.isConnected = true;
-                    this.state = "connected";
-                    this.emit('connected');
-                    connector.removeAllListeners('disconnect');
-                    connector.on('disconnect', this.onDisconnect.bind(this));
-                    const success = yield this.init();
-                    done(success);
-                    return;
-                }
-                catch (err) {
-                    this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
-                }
-                this.connectState.isConnecting = false;
-                if (disconnectSignalled)
-                    return;
-                done(true);
-            }));
-        });
-    }
-    subscribeMultiple(characteristics, conn) {
-        this.logEvent({ message: 'subscribe', characteristics });
-        return new Promise(resolve => {
-            try {
-                const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
-                const subscribeSingle = (c) => {
-                    connector.removeAllListeners(c);
-                    connector.on(c, (uuid, data) => {
-                        this.onData(uuid, data);
-                    });
-                    return connector.subscribe(c).then(res => {
-                        this.subscribedCharacteristics.push(c);
-                        return res;
-                    }).catch(err => {
-                        this.logEvent({ message: 'subscription failed', characteristic: c, error: err.message });
-                    });
-                };
-                const promises = characteristics
-                    .filter(c => {
-                    if (this.characteristics) {
-                        const existing = this.characteristics.find(rc => rc.uuid === c || (0, utils_2.uuid)(rc.uuid) === c);
-                        if (!existing)
-                            return false;
-                    }
-                    const isAlreadySubscribed = connector.isSubscribed(c);
-                    return !isAlreadySubscribed;
-                })
-                    .map(c => subscribeSingle(c));
-                Promise.all(promises).then(() => resolve());
-            }
-            catch (err) {
-                this.logEvent({ message: 'Error', fn: 'subscribeMultiple()', error: err.message, stack: err.stack });
-            }
-        });
-    }
-    subscribeAll(conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
-                const subscribed = yield connector.subscribeAll((uuid, data) => { this.onData(uuid, data); });
-                subscribed.forEach(c => this.subscribedCharacteristics.push(c));
-            }
-            catch (err) {
-                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
-            }
-        });
-    }
-    unsubscribeAll(conn) {
-        const connector = conn || this.ble.peripheralCache.getConnector(this.peripheral);
-        connector.unsubscribeAll();
-    }
-    connect(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.ble.resumeLogging();
-            if (!this.ble.isConnected()) {
-                try {
-                    yield this.ble.connect();
-                    if (!this.ble.isConnected())
-                        return false;
-                }
-                catch (err) {
-                    return false;
-                }
-            }
-            yield (0, utils_1.sleep)(Math.random() * 100);
-            yield this.ble.waitForSensorConnectionFinish();
-            this.ble.startConnectSensor();
-            const { reconnect } = props || {};
-            try {
-                this.logEvent({ message: reconnect ? 'reconnect' : 'connect', name: this.name, id: this.id, address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
-                if (!reconnect && this.connectState.isConnecting) {
-                    yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
-                }
-                if (this.connectState.isConnected) {
-                    try {
-                        yield this.subscribeAll();
-                        yield this.init();
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'cannot reconnect', error: err.message || err });
-                        this.ble.stopConnectSensor();
-                        return false;
-                    }
-                    this.ble.stopConnectSensor();
-                    return true;
-                }
-                this.connectState.isConnecting = true;
-                if (!this.peripheral) {
-                    const { id, name, address } = this;
-                    try {
-                        this.peripheral = this.ble.peripheralCache.getPeripheral({ id, name, address });
-                        const connector = this.ble.peripheralCache.getConnector(this.peripheral);
-                        if (!connector) {
-                        }
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'error', fn: 'connect()', error: err.message, stack: err.stack });
-                    }
-                }
-                if (this.peripheral) {
-                    const { id, address, advertisement } = this.peripheral;
-                    const name = advertisement === null || advertisement === void 0 ? void 0 : advertisement.localName;
-                    this.logEvent({ message: 'connect requested', mode: 'peripheral', device: { id, name, address: address } });
-                    const connected = yield this.connectPeripheral(this.peripheral);
-                    this.logEvent({ message: 'connect result: ', connected, mode: 'peripheral', device: { id, name, address } });
-                    this.connectState.isConnecting = false;
-                    this.connectState.isConnected = connected;
-                    this.ble.stopConnectSensor();
-                    return connected;
-                }
-                else {
-                    const { id, name, address } = this;
-                    let error;
-                    if (this.address || this.id || this.name) {
-                        this.logEvent({ message: 'connect requested', mode: 'device', device: { id, name, address } });
-                        try {
-                            if (this.ble.isScanning()) {
-                                yield this.ble.stopScan();
-                            }
-                            const peripheral = yield this.ble.scanForDevice(this, {});
-                            if (peripheral) {
-                                this.peripheral = peripheral;
-                                const connected = yield this.connectPeripheral(this.peripheral);
-                                this.logEvent({ message: 'connect result: ', connected, mode: 'device', device: { id, name, address } });
-                                this.connectState.isConnecting = false;
-                                this.connectState.isConnected = connected;
-                                this.ble.stopConnectSensor();
-                                return connected;
-                            }
-                        }
-                        catch (err) {
-                            error = err;
-                        }
-                    }
-                    this.logEvent({ message: 'connect result: failure', mode: 'device', device: { id, name, address }, error: error.message });
-                    this.connectState.isConnecting = false;
-                    this.connectState.isConnected = false;
-                    this.ble.stopConnectSensor();
-                    return false;
-                }
-            }
-            catch (err) {
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                this.logEvent({ message: 'connect result: error', error: err.message, stack: err.stack });
-                this.ble.stopConnectSensor();
-                return false;
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { id, name, address } = this;
-            this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
-            this.ble.pauseLogging();
-            this.connectState.isDisconnecting = true;
-            if (this.workerIv) {
-                this.stopWorker();
-            }
-            if (!this.connectState.isConnecting && !this.connectState.isConnected) {
-                this.connectState.isDisconnecting = false;
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
-                return true;
-            }
-            if (this.connectState.isConnecting) {
-                this.cleanupListeners();
-                setTimeout(() => { this.connectState.isDisconnecting = false; }, 1000);
-                this.logEvent({ message: 'disconnect result: unclear - connect ongoing', device: { id, name, address } });
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                return true;
-            }
-            if (this.connectState.isConnected) {
-                this.cleanupListeners();
-                this.unsubscribeAll();
-                this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
-                this.connectState.isDisconnecting = false;
-                this.connectState.isConnecting = false;
-                this.connectState.isConnected = false;
-                return true;
-            }
-        });
-    }
-    checkForDuplicate(characteristic, data) {
-        const prev = this.prevMessages.find(i => i.uuid === characteristic);
-        if (prev) {
-            if (prev.data === data.toString('hex') && prev.timestamp > Date.now() - 500) {
-                prev.timestamp = Date.now();
-                return true;
-            }
-            else {
-                prev.data = data.toString('hex');
-                prev.timestamp = Date.now();
-            }
-        }
-        else {
-            this.prevMessages.push({ uuid: characteristic, timestamp: Date.now(), data: data.toString('hex') });
-        }
-        return false;
-    }
-    onData(characteristic, _data) {
-        const data = Buffer.from(_data);
-        const isDuplicate = this.checkForDuplicate(characteristic, data);
-        if (isDuplicate) {
-            return false;
-        }
-        this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
-        if (this.writeQueue.length > 0) {
-            const writeIdx = this.writeQueue.findIndex(i => (0, utils_2.matches)(i.uuid, characteristic));
-            if (writeIdx !== -1) {
-                const writeItem = this.writeQueue[writeIdx];
-                this.writeQueue.splice(writeIdx, 1);
-                if (writeItem.resolve)
-                    writeItem.resolve(data);
-                return false;
-            }
-        }
-        return true;
-    }
-    timeoutCheck() {
-        const now = Date.now();
-        const updatedQueue = [];
-        let hasTimeout = false;
-        this.writeQueue.forEach(writeItem => {
-            if (writeItem.timeout && writeItem.timeout < now) {
-                if (writeItem.reject) {
-                    hasTimeout = true;
-                    writeItem.reject(new Error('timeout'));
-                }
-            }
-            else {
-                updatedQueue.push(writeItem);
-            }
-        });
-        if (hasTimeout)
-            this.writeQueue = updatedQueue;
-    }
-    startWorker() {
-        if (this.workerIv)
-            return;
-        this.workerIv = setInterval(() => { this.timeoutCheck(); }, 100);
-    }
-    stopWorker() {
-        if (!this.workerIv)
-            return;
-        clearInterval(this.workerIv);
-        this.workerIv = null;
-    }
-    write(characteristicUuid, data, props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected())
-                throw new Error('not connected');
-            try {
-                const { withoutResponse, timeout } = props || {};
-                let fireAndForget = withoutResponse;
-                const connector = this.ble.peripheralCache.getConnector(this.peripheral);
-                const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
-                if (!withoutResponse && !this.workerIv) {
-                    this.startWorker();
-                }
-                if (!withoutResponse && !isAlreadySubscribed) {
-                    const connector = this.ble.peripheralCache.getConnector(this.peripheral);
-                    connector.removeAllListeners(characteristicUuid);
-                    connector.on(characteristicUuid, (uuid, data) => {
-                        this.onData(uuid, data);
-                    });
-                    this.logEvent({ message: 'write:subscribing ', characteristic: characteristicUuid });
-                    try {
-                        yield connector.subscribe(characteristicUuid);
-                        this.subscribedCharacteristics.push(characteristicUuid);
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'write:subscribing failed', characteristic: characteristicUuid, error: err.message });
-                        fireAndForget = true;
-                    }
-                }
-                return new Promise((resolve, reject) => {
-                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_2.uuid)(c.uuid) === characteristicUuid);
-                    if (!characteristic) {
-                        this.logEvent({ message: 'write: Characteristic not found', characteristicUuid, characteristics: this.characteristics.map(c => c.uuid) });
-                        reject(new Error(`Characteristic not found`));
-                        return;
-                    }
-                    if (fireAndForget) {
-                        this.logEvent({ message: 'writing', data: data.toString('hex'), withoutResponse: 'true' });
-                        characteristic.write(data, true);
-                        resolve(new ArrayBuffer(0));
-                        return;
-                    }
-                    else {
-                        const writeId = this.writeQueue.length;
-                        let messageDeleted = false;
-                        const writeTimeout = timeout !== undefined ? timeout : BLE_TIMEOUT;
-                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, timeout: Date.now() + writeTimeout, resolve, reject });
-                        const to = setTimeout(() => {
-                            if (this.writeQueue.length > writeId && !messageDeleted)
-                                this.writeQueue.splice(writeId, 1);
-                            this.logEvent({ message: 'writing response', err: 'timeout' });
-                            reject(new Error('timeout'));
-                        }, 5000);
-                        this.logEvent({ message: 'writing' });
-                        characteristic.write(data, withoutResponse, (err) => {
-                            clearTimeout(to);
-                            this.logEvent({ message: 'writing response', err });
-                            if (err) {
-                                this.writeQueue.splice(writeId, 1);
-                                messageDeleted = true;
-                                reject(err);
-                            }
-                        });
-                    }
-                });
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'write', error: err.message || err, stack: err.stack });
-            }
-        });
-    }
-    read(characteristicUuid) {
-        return new Promise((resolve, reject) => {
-            if (!this.isConnected())
-                return reject(new Error('not connected'));
-            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_2.uuid)(c.uuid) === characteristicUuid);
-            if (!characteristic) {
-                this.logEvent({ message: 'read: Characteristic not found', characteristicUuid, characteristics: this.characteristics.map(c => c.uuid) });
-                reject(new Error('Characteristic not found'));
-                return;
-            }
-            characteristic.read((err, data) => {
-                if (err && data instanceof Error)
-                    reject(err);
-                else if (data instanceof Error)
-                    reject(data);
-                else
-                    resolve(data);
-            });
-        });
-    }
-    getDeviceInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = this.deviceInfo;
-            const readValue = (c) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const b = yield this.read(c);
-                    const buffer = b ? Buffer.from(b) : undefined;
-                    return buffer ? buffer.toString() : undefined;
-                }
-                catch (_a) {
-                    return undefined;
-                }
-            });
-            info.model = info.model || (yield readValue('2a24'));
-            info.serialNo = info.serialNo || (yield readValue('2a25'));
-            info.fwRevision = info.fwRevision || (yield readValue('2a26'));
-            info.hwRevision = info.hwRevision || (yield readValue('2a27'));
-            info.swRevision = info.swRevision || (yield readValue('2a28'));
-            info.manufacturer = info.manufacturer || (yield readValue('2a29'));
-            this.deviceInfo = info;
-            return info;
-        });
-    }
+exports.BleSensor = void 0;
+class BleSensor {
 }
-exports.BleComms = BleComms;
-BleComms.services = [];
+exports.BleSensor = BleSensor;