incyclist-devices 1.4.43 → 1.4.46

package/lib/CyclingMode.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclingModeBase = exports.CyclingModeProperyType = void 0;
 var CyclingModeProperyType;
 (function (CyclingModeProperyType) {
     CyclingModeProperyType["Integer"] = "Integer";

package/lib/Device.d.ts

@@ -28,6 +28,7 @@ export interface DeviceAdapter extends Device {
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
+    isSame(device: DeviceAdapter): boolean;
     getID(): string;
     getDisplayName(): string;
     getName(): string;
@@ -58,6 +59,7 @@ export default class IncyclistDevice implements DeviceAdapter {
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
+    isSame(device: DeviceAdapter): boolean;
     getID(): string;
     getDisplayName(): string;
     getName(): string;

package/lib/Device.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
 class IncyclistDevice {
@@ -12,6 +13,7 @@ class IncyclistDevice {
     isBike() { throw new Error('not implemented'); }
     isPower() { throw new Error('not implemented'); }
     isHrm() { throw new Error('not implemented'); }
+    isSame(device) { throw new Error('not implemented'); }
     getID() { throw new Error('not implemented'); }
     getDisplayName() { return this.getName(); }
     getName() { throw new Error('not implemented'); }

package/lib/DeviceProtocol.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERFACE = void 0;
 exports.INTERFACE = {
     SERIAL: 'serial',
     ANT: 'ant',

package/lib/DeviceSupport.js

@@ -1,32 +1,49 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
+    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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleFitnessMachineDevice = exports.BleCyclingPowerDevice = exports.BleHrmDevice = exports.BleInterface = exports.CyclingModeProperyType = exports.BleProtocol = exports.AntScanner = exports.Protocols = exports.Device = exports.INTERFACE = exports.DeviceRegistry = exports.DeviceProtocolBase = void 0;
 const DeviceRegistry_1 = __importDefault(require("./DeviceRegistry"));
 exports.DeviceRegistry = DeviceRegistry_1.default;
 const Device_1 = __importDefault(require("./Device"));
 exports.Device = Device_1.default;
 const DeviceProtocol_1 = __importStar(require("./DeviceProtocol"));
 exports.DeviceProtocolBase = DeviceProtocol_1.default;
-exports.INTERFACE = DeviceProtocol_1.INTERFACE;
+Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return DeviceProtocol_1.INTERFACE; } });
 const Simulator_1 = __importDefault(require("./simulator/Simulator"));
 const DaumPremiumProtocol_1 = __importDefault(require("./daum/premium/DaumPremiumProtocol"));
 const DaumClassicProtocol_1 = __importDefault(require("./daum/classic/DaumClassicProtocol"));
 const protocol_1 = __importDefault(require("./kettler/ergo-racer/protocol"));
 const AntScanner_1 = require("./ant/AntScanner");
-exports.AntScanner = AntScanner_1.AntScanner;
+Object.defineProperty(exports, "AntScanner", { enumerable: true, get: function () { return AntScanner_1.AntScanner; } });
 const incyclist_protocol_1 = __importDefault(require("./ble/incyclist-protocol"));
 exports.BleProtocol = incyclist_protocol_1.default;
 const CyclingMode_1 = require("./CyclingMode");
-exports.CyclingModeProperyType = CyclingMode_1.CyclingModeProperyType;
+Object.defineProperty(exports, "CyclingModeProperyType", { enumerable: true, get: function () { return CyclingMode_1.CyclingModeProperyType; } });
 const ble_interface_1 = __importDefault(require("./ble/ble-interface"));
 exports.BleInterface = ble_interface_1.default;
 const hrm_1 = __importDefault(require("./ble/hrm"));

package/lib/ant/AntAdapter.d.ts

@@ -18,6 +18,7 @@ export default class AntAdapter extends DeviceAdapter {
     lastUpdate?: number;
     updateFrequency: number;
     constructor(protocol: any);
+    isSame(device: DeviceAdapter): boolean;
     setSensor(sensor: any): void;
     getID(): string;
     setIgnoreHrm(ignore: any): void;

package/lib/ant/AntAdapter.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_UPDATE_FREQUENCY = void 0;
 const Device_1 = __importDefault(require("../Device"));
 exports.DEFAULT_UPDATE_FREQUENCY = 1000;
 class AntAdapter extends Device_1.default {
@@ -21,6 +22,12 @@ class AntAdapter extends Device_1.default {
         this.data = {};
         this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
     }
+    isSame(device) {
+        if (!(device instanceof AntAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
+    }
     setSensor(sensor) {
         this.sensor = sensor;
     }

package/lib/ant/AntScanner.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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) {
@@ -8,17 +31,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AntScanner = exports.AntProtocol = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const DeviceProtocol_1 = __importStar(require("../DeviceProtocol"));
 const AntHrmAdapter_1 = __importDefault(require("./anthrm/AntHrmAdapter"));

package/lib/ant/antfe/AntFEAdapter.js

@@ -52,7 +52,7 @@ class AntFEAdapter extends AntAdapter_1.default {
     getDisplayName() {
         const { DeviceID, ManId, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${utils_1.getBrand(ManId)} FE ${DeviceID}${hrmStr}`;
+        return `${(0, utils_1.getBrand)(ManId)} FE ${DeviceID}${hrmStr}`;
     }
     onAttached() {
         this.logger.logEvent({ message: 'Device connected' });
@@ -233,7 +233,7 @@ class AntFEAdapter extends AntAdapter_1.default {
                                 trackResistanceSent: false,
                                 userSent: false,
                             };
-                            utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () {
+                            (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
                                 if (this.isStopped())
                                     resolve(false);
                                 try {
@@ -299,18 +299,18 @@ class AntFEAdapter extends AntAdapter_1.default {
             try {
                 const isReset = (!request || request.reset || Object.keys(request).length === 0);
                 if (request.slope !== undefined) {
-                    yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTrackResistance(request.slope); }), 2, 100);
                 }
                 if (request.targetPower !== undefined) {
-                    yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
+                    yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.targetPower); }), 2, 100);
                 }
                 else if (request.maxPower !== undefined) {
                     if (this.data.power && this.data.power > request.maxPower)
-                        yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.maxPower); }), 2, 100);
+                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.maxPower); }), 2, 100);
                 }
                 else if (request.minPower !== undefined) {
                     if (this.data.power && this.data.power < request.minPower)
-                        yield utils_2.runWithRetries(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.minPower); }), 2, 100);
+                        yield (0, utils_2.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () { return yield this.sendTargetPower(request.minPower); }), 2, 100);
                 }
             }
             catch (err) {
@@ -395,7 +395,7 @@ class AntFEAdapter extends AntAdapter_1.default {
             this.currentCmd = this.queue.dequeue();
             this.currentCmd.tsStart = Date.now();
             const { msg, logStr } = this.currentCmd;
-            this.logger.logEvent({ message: "sending", cmd: logStr, msg: utils_2.hexstr(msg), queueSize: this.queue.size() });
+            this.logger.logEvent({ message: "sending", cmd: logStr, msg: (0, utils_2.hexstr)(msg), queueSize: this.queue.size() });
             if (this.stick)
                 this.stick.write(msg);
         }

package/lib/ant/anthrm/AntHrmAdapter.js

@@ -43,7 +43,7 @@ class AntHrmAdapter extends AntAdapter_1.default {
     getDisplayName() {
         const { DeviceID, manID, ComputedHeartRate } = this.deviceData;
         const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${utils_1.getBrand(manID)} Hrm ${DeviceID}${hrmStr}`;
+        return `${(0, utils_1.getBrand)(manID)} Hrm ${DeviceID}${hrmStr}`;
     }
     onDeviceData(deviceData) {
         if (!this.started)

package/lib/ant/antpwr/pwr-adapter.js

@@ -48,7 +48,7 @@ class AntFEAdapter extends AntAdapter_1.default {
     }
     getDisplayName() {
         const { DeviceID, ManId } = this.deviceData;
-        return `${utils_1.getBrand(ManId)} PWR ${DeviceID}`;
+        return `${(0, utils_1.getBrand)(ManId)} PWR ${DeviceID}`;
     }
     getCyclingMode() {
         if (!this.mode)

package/lib/ant/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrand = (manId) => {
+exports.getBrand = void 0;
+const getBrand = (manId) => {
     if (manId === undefined)
         return "ANT+";
     switch (manId) {
@@ -19,3 +20,4 @@ exports.getBrand = (manId) => {
             return "ANT+";
     }
 };
+exports.getBrand = getBrand;

package/lib/ble/ble-device.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
-import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps } from "./ble";
+import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps, BleDeviceInfo } from "./ble";
+import BlePeripheralConnector from "./ble-peripheral";
 interface BleDeviceConstructProps extends BleDeviceProps {
     log?: boolean;
     logger?: EventLogger;
@@ -15,17 +16,25 @@ export declare abstract class BleDevice extends BleDeviceClass {
     characteristics: any[];
     state?: string;
     logger?: EventLogger;
+    deviceInfo: BleDeviceInfo;
+    isInitialized: boolean;
+    subscribedCharacteristics: string[];
     constructor(props?: BleDeviceConstructProps);
     logEvent(event: any): void;
     setInterface(ble: BleInterfaceClass): void;
-    private cleanupListeners;
-    private onDisconnect;
+    cleanupListeners(): void;
+    onDisconnect(): void;
     waitForConnectFinished(timeout: any): Promise<unknown>;
+    hasService(serviceUuid: any): boolean;
+    init(): Promise<boolean>;
+    connectPeripheral(peripheral: BlePeripheral): Promise<void>;
+    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
     connect(props?: ConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
     abstract getProfile(): string;
     abstract onData(characteristic: string, data: Buffer): void;
-    abstract write(characteristic: string, data: Buffer): Promise<boolean>;
-    abstract read(characteristic: string): Promise<Buffer>;
+    write(characteristicUuid: string, data: Buffer, withoutResponse?: boolean): Promise<boolean>;
+    read(characteristicUuid: string): Promise<Uint8Array>;
+    getDeviceInfo(): Promise<BleDeviceInfo>;
 }
 export {};

package/lib/ble/ble-device.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleDevice = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const ble_1 = require("./ble");
 const CONNECT_WAIT_TIMEOUT = 10000;
@@ -16,12 +17,15 @@ class BleDevice extends ble_1.BleDeviceClass {
     constructor(props) {
         super();
         this.characteristics = [];
+        this.deviceInfo = {};
         this.id = props.id;
         this.address = props.address;
         this.name = props.name;
         this.services = props.services;
         this.ble = props.ble;
         this.characteristics = [];
+        this.subscribedCharacteristics = [];
+        this.isInitialized = false;
         if (props.peripheral) {
             const { id, address, advertisement, state } = props.peripheral;
             this.peripheral = props.peripheral;
@@ -54,15 +58,18 @@ class BleDevice extends ble_1.BleDeviceClass {
             this.characteristics = [];
         }
         else {
+            const connector = this.ble.getConnector(this.peripheral);
             this.characteristics.forEach(c => {
-                c.unsubscribe();
-                c.removeAllListeners('data');
+                connector.removeAllListeners((0, ble_1.uuid)(c.uuid));
             });
         }
     }
     onDisconnect() {
+        this.logEvent({ message: 'device disconnected', address: this.address, profile: this.getProfile() });
         this.state = "disconnected";
         if (!this.connectState.isDisconnecting) {
+            this.peripheral.state = 'disconnected';
+            this.connectState.isConnected = false;
             this.connect();
         }
         this.emit('disconnected');
@@ -88,85 +95,82 @@ class BleDevice extends ble_1.BleDeviceClass {
             }, 100);
         });
     }
+    hasService(serviceUuid) {
+        return this.services && this.services.find(s => s === serviceUuid || (0, ble_1.uuid)(serviceUuid)) !== undefined;
+    }
+    init() {
+        if (this.isInitialized)
+            return Promise.resolve(true);
+        return this.getDeviceInfo().then(() => {
+            this.emit('deviceInfo', this.deviceInfo);
+            this.isInitialized = true;
+            return true;
+        });
+    }
+    connectPeripheral(peripheral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.connectState.isConnecting = true;
+            try {
+                const connector = this.ble.getConnector(peripheral);
+                yield connector.connect();
+                yield connector.initialize();
+                yield this.subscribeAll(connector);
+                this.connectState.isConnected = true;
+                this.state = "connected";
+                this.emit('connected');
+                yield this.init();
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'connectPeripheral()', error: err.message, stack: err.stack });
+            }
+            this.connectState.isConnecting = false;
+        });
+    }
+    subscribeAll(conn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connector = conn || this.ble.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 });
+            }
+        });
+    }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const connectPeripheral = (peripheral) => __awaiter(this, void 0, void 0, function* () {
-                this.connectState.isConnecting = true;
-                const connected = this.ble.findConnected(peripheral);
-                if (!connected && peripheral.state !== 'connected') {
-                    try {
-                        yield peripheral.connectAsync();
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'cannot connect', error: err.message || err });
-                    }
-                }
-                try {
-                    if (!this.characteristics)
-                        this.characteristics = [];
-                    if (!connected) {
-                        if (!this.characteristics || this.characteristics.length === 0) {
-                            this.logEvent({ message: 'connect: discover characteristics start' });
-                            const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
-                            const { characteristics } = res;
-                            this.logEvent({ message: 'connect: discover characteristics result',
-                                result: characteristics.map(c => ({ uuid: ble_1.uuid(c.uuid), properties: c.properties.join(','), service: ble_1.uuid(c._serviceUuid) }))
-                            });
-                            this.characteristics = characteristics;
-                        }
-                        else {
-                        }
-                    }
-                    else {
-                        this.characteristics = connected.characteristics;
-                    }
-                    this.connectState.isConnecting = false;
-                    this.connectState.isConnected = true;
-                    this.state = "connected";
-                    this.emit('connected');
-                    this.ble.addConnectedDevice(this);
-                    this.peripheral.once('disconnect', () => { this.onDisconnect(); });
-                    this.characteristics.forEach(c => {
-                        if (c.properties.find(p => p === 'notify')) {
-                            c.on('data', (data, _isNotification) => {
-                                this.onData(ble_1.uuid(c.uuid), data);
-                            });
-                            if (!connected) {
-                                this.logEvent({ message: 'subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid });
-                                c.subscribe((err) => {
-                                    if (err)
-                                        this.logEvent({ message: 'cannot subscribe', device: this.name, address: this.address, service: c._serviceUuid, characteristic: c.uuid, error: err.message || err });
-                                });
-                            }
-                        }
-                    });
-                }
-                catch (err) {
-                    this.logEvent({ message: 'cannot connect', error: err.message || err });
-                    this.connectState.isConnecting = false;
-                    this.connectState.isConnected = false;
-                }
-            });
             try {
+                this.logEvent({ message: 'connect', address: this.peripheral ? this.peripheral.address : this.address, state: this.connectState });
                 if (this.connectState.isConnecting) {
                     yield this.waitForConnectFinished(CONNECT_WAIT_TIMEOUT);
                 }
                 if (this.connectState.isConnected) {
-                    this.characteristics.forEach(c => {
-                        if (c.properties.find(p => p === 'notify')) {
-                            c.on('data', (data, _isNotification) => {
-                                this.onData(ble_1.uuid(c.uuid), data);
-                            });
-                        }
-                    });
+                    try {
+                        yield this.subscribeAll();
+                        yield this.init();
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'cannot reconnect', error: err.message || err });
+                        return false;
+                    }
                     return true;
                 }
                 this.connectState.isConnecting = true;
+                if (!this.peripheral) {
+                    const { id, name, address } = this;
+                    try {
+                        this.peripheral = this.ble.findPeripheral({ id, name, address });
+                    }
+                    catch (err) {
+                        console.log('~~~ error', err);
+                    }
+                }
                 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 } });
-                    yield connectPeripheral(this.peripheral);
+                    yield this.connectPeripheral(this.peripheral);
                     this.logEvent({ message: 'connect result: success', mode: 'peripheral', device: { id, name, address } });
                     return true;
                 }
@@ -179,10 +183,10 @@ class BleDevice extends ble_1.BleDeviceClass {
                             if (this.ble.isScanning()) {
                                 yield this.ble.stopScan();
                             }
-                            const devices = yield this.ble.scan({ device: this });
+                            const devices = yield this.ble.scan({ requested: this });
                             if (devices && devices.length > 0) {
                                 this.peripheral = devices[0].peripheral;
-                                yield connectPeripheral(this.peripheral);
+                                yield this.connectPeripheral(this.peripheral);
                                 this.logEvent({ message: 'connect result: success', mode: 'device', device: { id, name, address } });
                                 return true;
                             }
@@ -231,5 +235,70 @@ class BleDevice extends ble_1.BleDeviceClass {
             }
         });
     }
+    write(characteristicUuid, data, withoutResponse = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.subscribedCharacteristics.find(c => c === characteristicUuid) === undefined) {
+                const connector = this.ble.getConnector(this.peripheral);
+                connector.on(characteristicUuid, (uuid, data) => {
+                    this.onData(uuid, data);
+                });
+                yield connector.subscribe(characteristicUuid);
+                this.subscribedCharacteristics.push(characteristicUuid);
+            }
+            return new Promise((resolve, reject) => {
+                const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+                if (!characteristic) {
+                    reject(new Error('Characteristic not found'));
+                    return;
+                }
+                characteristic.write(data, withoutResponse, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(true);
+                });
+            });
+        });
+    }
+    read(characteristicUuid) {
+        return new Promise((resolve, reject) => {
+            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+            if (!characteristic) {
+                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.BleDevice = BleDevice;

package/lib/ble/ble-erg-mode.d.ts

@@ -0,0 +1,24 @@
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
+import PowerBasedCyclingModeBase from "../modes/power-base";
+import { FmAdapter } from "./fm";
+export declare type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    constructor(adapter: FmAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+}