incyclist-devices 1.4.34 → 1.4.37

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
-import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleCharacteristic, BleDeviceProps, ConnectProps } from "./ble";
+import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps } from "./ble";
 interface ConnectState {
     isConnecting: boolean;
     isConnected: boolean;
@@ -17,7 +17,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     services: string[];
     ble: BleInterfaceClass;
     peripheral?: BlePeripheral;
-    characteristics: BleCharacteristic[];
+    characteristics: any[];
     state?: string;
     connectState: ConnectState;
     logger?: EventLogger;

package/lib/ble/ble-device.js

@@ -71,11 +71,14 @@ class BleDevice extends ble_1.BleDeviceClass {
         return __awaiter(this, void 0, void 0, function* () {
             const connectPeripheral = (peripheral) => __awaiter(this, void 0, void 0, function* () {
                 this.connectState.isConnecting = true;
-                try {
-                    yield peripheral.connectAsync();
-                }
-                catch (err) {
-                    this.logEvent({ message: 'cannot connect', error: err.message || err });
+                const connected = this.ble.findConnected(peripheral);
+                if (!connected) {
+                    try {
+                        yield peripheral.connectAsync();
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'cannot connect', error: err.message || err });
+                    }
                 }
                 this.connectState.isConnecting = false;
                 this.connectState.isConnected = true;
@@ -85,16 +88,24 @@ class BleDevice extends ble_1.BleDeviceClass {
                 this.ble.addConnectedDevice(this);
                 this.peripheral.once('disconnect', () => { this.onDisconnect(); });
                 try {
-                    const { characteristics } = yield peripheral.discoverSomeServicesAndCharacteristicsAsync(this.services || [], []);
-                    characteristics.forEach(c => {
+                    if (!connected) {
+                        const { characteristics } = yield peripheral.discoverSomeServicesAndCharacteristicsAsync(this.services || [], []);
+                        this.characteristics = characteristics;
+                    }
+                    else {
+                        this.characteristics = connected.characteristics;
+                    }
+                    this.characteristics.forEach(c => {
                         if (c.properties.find(p => p === 'notify')) {
                             c.on('data', (data, _isNotification) => {
                                 this.onData(ble_1.uuid(c.uuid), data);
                             });
-                            c.subscribe((err) => {
-                                if (err)
-                                    this.logEvent({ message: 'cannot subscribe', error: err.message || err });
-                            });
+                            if (!connected) {
+                                c.subscribe((err) => {
+                                    if (err)
+                                        this.logEvent({ message: 'cannot subscribe', error: err.message || err });
+                                });
+                            }
                         }
                     });
                 }

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventLogger } from 'gd-eventlog';
-import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BleBinding } from './ble';
+import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BlePeripheral, BleBinding } from './ble';
 export interface ScanState {
     isScanning: boolean;
     timeout?: NodeJS.Timeout;
@@ -53,5 +53,6 @@ export default class BleInterface extends BleInterfaceClass {
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
     addConnectedDevice(device: BleDeviceClass): void;
+    findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
     removeConnectedDevice(device: BleDeviceClass): void;
 }

package/lib/ble/ble-interface.js

@@ -84,21 +84,26 @@ class BleInterface extends ble_1.BleInterfaceClass {
             try {
                 if (!this.connectState.isInitSuccess) {
                     const binding = this.getBinding()._bindings;
-                    const binding_init_original = binding.init.bind(binding);
-                    const self = this;
-                    binding.init = function () {
-                        try {
-                            binding_init_original();
-                            self.connectState.isInitSuccess = true;
-                        }
-                        catch (err) {
-                            self.connectState.isInitSuccess = false;
-                            self.connectState.isConnected = false;
-                            self.connectState.isConnecting = false;
-                            self.logEvent({ message: 'connect result: error', error: err.message });
-                            return reject(new Error(err.message));
-                        }
-                    };
+                    if (binding) {
+                        const binding_init_original = binding.init.bind(binding);
+                        const self = this;
+                        binding.on('error', (err) => { this.getBinding().emit('error', err); });
+                        binding.init = function () {
+                            try {
+                                binding_init_original();
+                                self.connectState.isInitSuccess = true;
+                            }
+                            catch (err) {
+                                self.connectState.isInitSuccess = false;
+                                self.connectState.isConnected = false;
+                                self.connectState.isConnecting = false;
+                                self.logEvent({ message: 'connect result: error', error: err.message });
+                                return reject(new Error(err.message));
+                            }
+                        };
+                    }
+                    else {
+                    }
                 }
                 const state = this.getBinding().state;
                 if (state === ble_1.BleState.POWERED_ON) {
@@ -278,9 +283,10 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 yield this.connect();
             }
             const detectedPeripherals = {};
-            this.devices = [];
-            if (scanForDevice)
-                this.logEvent({ message: 'search device request', device, deviceTypes });
+            if (scanForDevice) {
+                const { id, address, name } = device;
+                this.logEvent({ message: 'search device request', device: { id, address, name }, deviceTypes });
+            }
             else
                 this.logEvent({ message: 'scan start', services });
             return new Promise((resolve, reject) => {
@@ -289,7 +295,15 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     return reject(new Error('scanning already in progress'));
                 }
                 this.scanState.isScanning = true;
-                bleBinding.startScanning(services, true, (err) => {
+                if (scanForDevice && device instanceof ble_1.BleDeviceClass) {
+                    const existing = this.devices.find(i => i.device.address === device.address && i.isConnected);
+                    if (existing) {
+                        device.peripheral = existing.device.peripheral;
+                        this.logEvent({ message: 'scan: device already connected', device: device.name, address: device.address });
+                        return resolve([device]);
+                    }
+                }
+                bleBinding.startScanning([], true, (err) => {
                     if (err) {
                         this.logEvent({ message: 'scan result: error', error: err.message });
                         this.scanState.isScanning = false;
@@ -299,6 +313,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         if (!peripheral || !peripheral.advertisement)
                             return;
                         if (!detectedPeripherals[peripheral.id]) {
+                            if (process.env.BLE_DEBUG)
+                                console.log('discovered', peripheral);
                             detectedPeripherals[peripheral.id] = peripheral;
                             let DeviceClasses;
                             if (scanForDevice && (!deviceTypes || deviceTypes.length === 0)) {
@@ -316,6 +332,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                                     return;
                                 const C = DeviceClass;
                                 const d = new C({ peripheral });
+                                if (device.getProfile && device.getProfile() !== d.getProfile())
+                                    return;
                                 d.setInterface(this);
                                 if (scanForDevice) {
                                     if ((device.id && device.id !== '' && d.id === device.id) ||
@@ -325,7 +343,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                                 }
                                 else
                                     cntFound++;
-                                const existing = this.devices.find(i => i.device.id === d.id);
+                                const existing = this.devices.find(i => i.device.id === d.id && i.device.getProfile() === d.getProfile());
                                 if (cntFound > 0 && !existing) {
                                     this.logEvent({ message: 'scan: device found', device: d.name, address: d.address, services: d.services.join(',') });
                                     this.devices.push({ device: d, isConnected: false });
@@ -336,6 +354,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                                         clearTimeout(this.scanState.timeout);
                                         this.scanState.timeout = null;
                                         bleBinding.stopScanning(() => {
+                                            this.getBinding().removeAllListeners('discover');
                                             this.scanState.isScanning = false;
                                             resolve([d]);
                                         });
@@ -346,11 +365,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
                                 }
                             });
                         }
+                        else {
+                        }
                     });
                 });
                 this.scanState.timeout = setTimeout(() => {
                     this.scanState.timeout = null;
                     this.logEvent({ message: 'scan result: devices found', devices: this.devices.map(i => i.device.name + (!i.device.name || i.device.name === '') ? `addr=${i.device.address}` : '') });
+                    this.getBinding().removeAllListeners('discover');
                     bleBinding.stopScanning(() => {
                         this.scanState.isScanning = false;
                         resolve(this.devices.map(i => i.device));
@@ -365,6 +387,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
         }
         if (!this.getBinding())
             return Promise.reject(new Error('no binding defined'));
+        this.getBinding().removeAllListeners('discover');
         this.logEvent({ message: 'scan stop request' });
         return new Promise(resolve => {
             this.getBinding().stopScanning(() => {
@@ -385,6 +408,12 @@ class BleInterface extends ble_1.BleInterfaceClass {
         }
         this.devices.push({ device, isConnected: true });
     }
+    findConnected(device) {
+        const connected = this.devices.find(i => i.device.id === device.id && i.isConnected);
+        if (connected)
+            return connected.device;
+        return undefined;
+    }
     removeConnectedDevice(device) {
         const existigDevice = this.devices.find(i => i.device.id === device.id);
         if (existigDevice) {

package/lib/ble/ble.d.ts

@@ -51,6 +51,7 @@ export declare abstract class BleInterfaceClass extends EventEmitter {
     abstract isScanning(): boolean;
     abstract addConnectedDevice(device: BleDeviceClass): void;
     abstract removeConnectedDevice(device: BleDeviceClass): void;
+    abstract findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
     getBinding(): BleBinding;
     setBinding(binding: BleBinding): void;
 }

package/lib/ble/hrm.d.ts

@@ -19,7 +19,7 @@ export default class BleHrmDevice extends BleDevice {
     constructor(props?: any);
     getProfile(): string;
     getServiceUUids(): string[];
-    parseHrm(data: Buffer): HrmData;
+    parseHrm(_data: Uint8Array): HrmData;
     onData(characteristic: string, data: Buffer): void;
     write(characteristic: any, data: any): Promise<boolean>;
     read(characteristic: any): Promise<Buffer>;

package/lib/ble/hrm.js

@@ -28,20 +28,20 @@ class BleHrmDevice extends ble_device_1.BleDevice {
     getServiceUUids() {
         return BleHrmDevice.services;
     }
-    parseHrm(data) {
+    parseHrm(_data) {
+        const data = Buffer.from(_data);
         try {
-            const ab = new Uint8Array(data);
-            const flags = ab[0];
-            let offset = 1;
+            const flags = data.readUInt8(0);
+            let offset = 2;
             if (flags % 1 === 0) {
-                this.heartrate = ab[1];
+                this.heartrate = data.readUInt8(1);
             }
             else {
-                this.heartrate = ab[1] + ab[2] * 256;
-                offset = 2;
+                this.heartrate = data.readUInt16LE(1);
+                offset = 3;
             }
             if (flags % 0xF) {
-                this.rr = (ab[offset + 1] + ab[offset + 2] * 256) / 1024;
+                this.rr = (data.readUInt16LE(offset)) / 1024;
             }
         }
         catch (err) {

package/lib/ble/pwr.d.ts

@@ -14,7 +14,7 @@ declare type PowerData = {
     accTorque?: number;
     time: number;
     rpm: number;
-    raw?: Buffer;
+    raw?: string;
 };
 declare type CrankData = {
     revolutions?: number;
@@ -39,7 +39,7 @@ export default class BleCyclingPowerDevice extends BleDevice {
         rpm: number;
         time: any;
     };
-    parsePower(data: Buffer): PowerData;
+    parsePower(_data: Uint8Array): PowerData;
     onData(characteristic: string, data: Buffer): void;
     write(characteristic: any, data: any): Promise<boolean>;
     read(characteristic: any): Promise<Buffer>;

package/lib/ble/pwr.js

@@ -66,7 +66,8 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
             this.prevCrankData.cntUpdateMissing = cntUpdateMissing + 1;
         return { rpm, time: this.timeOffset + c.time };
     }
-    parsePower(data) {
+    parsePower(_data) {
+        const data = Buffer.from(_data);
         try {
             let offset = 4;
             const flags = data.readUInt16LE(0);
@@ -91,7 +92,7 @@ class BleCyclingPowerDevice extends ble_device_1.BleDevice {
         catch (err) {
         }
         const { instantaneousPower, balance, accTorque, rpm, time } = this;
-        return { instantaneousPower, balance, accTorque, rpm, time, raw: data };
+        return { instantaneousPower, balance, accTorque, rpm, time, raw: data.toString('hex') };
     }
     onData(characteristic, data) {
         if (characteristic.toLocaleLowerCase() === '2a63') {
@@ -176,7 +177,7 @@ class PwrAdapter extends Device_1.default {
         const data = {
             isPedalling: false,
             power: 0,
-            pedalRpm: 0,
+            pedalRpm: undefined,
             speed: 0,
             heartrate: 0,
             distanceInternal: 0,

package/lib/modes/power-meter.js

@@ -47,7 +47,7 @@ class PowerMeterCyclingMode extends power_base_1.default {
             let power = bikeData.power || 0;
             const slope = prevData.slope || 0;
             const distanceInternal = prevData.distanceInternal || 0;
-            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
+            if (bikeData.pedalRpm === 0 || bikeData.isPedalling === false) {
                 power = 0;
             }
             const m = this.getWeight();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.34",
+  "version": "1.4.37",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",