incyclist-devices 1.4.41 → 1.4.44

package/lib/ble/ble-device.js

@@ -93,7 +93,7 @@ class BleDevice extends ble_1.BleDeviceClass {
             const connectPeripheral = (peripheral) => __awaiter(this, void 0, void 0, function* () {
                 this.connectState.isConnecting = true;
                 const connected = this.ble.findConnected(peripheral);
-                if (!connected) {
+                if (!connected && peripheral.state !== 'connected') {
                     try {
                         yield peripheral.connectAsync();
                     }
@@ -102,15 +102,20 @@ class BleDevice extends ble_1.BleDeviceClass {
                     }
                 }
                 try {
-                    this.cleanupListeners();
+                    if (!this.characteristics)
+                        this.characteristics = [];
                     if (!connected) {
-                        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;
+                        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;

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

@@ -29,6 +29,7 @@ export default class BleInterface extends BleInterfaceClass {
     devices: BleDeviceInfo[];
     logger: EventLogger;
     deviceCache: any[];
+    peripheralCache: any[];
     static deviceClasses: BleDeviceClassInfo[];
     static _instance: BleInterface;
     static getInstance(props?: {

package/lib/ble/ble-interface.js

@@ -13,6 +13,8 @@ const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../utils");
 const ble_1 = require("./ble");
 const CONNECT_TIMEOUT = 5000;
+const DEFAULT_SCAN_TIMEOUT = 20000;
+const BACKGROUND_SCAN_TIMEOUT = 30000;
 class BleInterface extends ble_1.BleInterfaceClass {
     constructor(props = {}) {
         super(props);
@@ -20,6 +22,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
         this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
         this.devices = [];
         this.deviceCache = [];
+        this.peripheralCache = [];
         if (props.logger)
             this.logger = props.logger;
         else if (props.log) {
@@ -71,7 +74,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
         const timeout = props.timeout || 2000;
         const runBackgroundScan = () => {
             this.scanState.isBackgroundScan = true;
-            this.scan({ timeout: 5000, isBackgroundScan: true })
+            this.scan({ timeout: BACKGROUND_SCAN_TIMEOUT, isBackgroundScan: true })
                 .then(() => {
                 this.scanState.isBackgroundScan = false;
             })
@@ -260,13 +263,13 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    connectDevice(requested, timeout = CONNECT_TIMEOUT) {
+    connectDevice(requested, timeout = DEFAULT_SCAN_TIMEOUT + CONNECT_TIMEOUT) {
         return __awaiter(this, void 0, void 0, function* () {
             const { id, name, address, getProfile } = requested;
             const profile = getProfile && typeof (getProfile) === 'function' ? getProfile() : undefined;
             this.logEvent({ message: 'connectDevice', id, name, address, profile, isbusy: this.scanState.isConnecting });
             if (this.scanState.isConnecting) {
-                yield this.waitForConnectFinished(10000);
+                yield this.waitForConnectFinished(CONNECT_TIMEOUT);
             }
             this.scanState.isConnecting = true;
             let devices = [];
@@ -277,7 +280,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     this.logEvent({ message: 'retry connect device', id, name, address, profile, retryCount });
                 }
                 try {
-                    devices = yield this.scan({ timeout, device: requested });
+                    devices = yield this.scan({ timeout: DEFAULT_SCAN_TIMEOUT, device: requested });
                     if (devices.length === 0) {
                         retryCount++;
                         retry = retryCount < 5;
@@ -347,7 +350,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
     }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = 5000, deviceTypes = [], device } = props;
+            const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], device } = props;
             const scanForDevice = (device !== null && device !== undefined);
             const services = this.getServicesFromDeviceTypes(deviceTypes);
             const bleBinding = this.getBinding();
@@ -356,12 +359,12 @@ class BleInterface extends ble_1.BleInterfaceClass {
             if (!this.isConnected()) {
                 yield this.connect();
             }
+            const peripheralsProcessed = [];
             this.logEvent({ message: 'scan()', props, scanState: this.scanState, cache: this.deviceCache.map(p => ({ name: p.advertisement ? p.advertisement.localName : '', address: p.address })) });
             if (!props.isBackgroundScan && this.scanState.isBackgroundScan) {
                 yield this.stopScan();
                 this.scanState.isBackgroundScan = false;
             }
-            const detectedPeripherals = {};
             let opStr;
             if (scanForDevice) {
                 opStr = 'search device';
@@ -374,6 +377,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             if (this.scanState.isScanning) {
                 try {
+                    this.logEvent({ message: `${opStr}: waiting for previous scan to finish` });
                     yield this.waitForScanFinished(timeout);
                 }
                 catch (err) {
@@ -383,6 +387,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             return new Promise((resolve, reject) => {
                 this.scanState.isScanning = true;
+                if (props.isBackgroundScan)
+                    this.scanState.isBackgroundScan = true;
                 if (scanForDevice && device instanceof ble_1.BleDeviceClass) {
                     if (this.devices && this.devices.length > 0) {
                         const connectedDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));
@@ -432,16 +438,46 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         }
                     }
                 }
-                const onPeripheralFound = (peripheral, fromCache = false) => {
+                const onPeripheralFound = (peripheral, fromCache = false) => __awaiter(this, void 0, void 0, function* () {
                     if (fromCache)
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
                     if (!peripheral || !peripheral.advertisement)
                         return;
-                    if (!detectedPeripherals[peripheral.id]) {
+                    let existingPeripheral = this.peripheralCache.find(i => i.address === peripheral.address);
+                    if (existingPeripheral && Date.now() - existingPeripheral.ts > 600000) {
+                        existingPeripheral.ts = Date.now();
+                    }
+                    if (!existingPeripheral) {
+                        this.peripheralCache.push({ address: peripheral.address, ts: Date.now(), peripheral });
+                        existingPeripheral = this.peripheralCache.find(i => i.address === peripheral.address);
+                    }
+                    let shouldAddDevice = peripheralsProcessed.find(p => p === peripheral.address) === undefined;
+                    if (shouldAddDevice) {
                         if (process.env.BLE_DEBUG)
-                            console.log('discovered', peripheral);
-                        detectedPeripherals[peripheral.id] = peripheral;
-                        this.addPeripheralToCache(peripheral);
+                            console.log('discovered', peripheral.id, peripheral.address, peripheral.advertisement.localName);
+                        peripheralsProcessed.push(peripheral.address);
+                        let characteristics;
+                        if (!existingPeripheral.characteristics) {
+                            try {
+                                if (existingPeripheral.peripheral && existingPeripheral.peripheral.state !== 'connected')
+                                    yield peripheral.connectAsync();
+                                const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
+                                this.logEvent({ message: 'characteristic info (+):', info: res.characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
+                                if (peripheral.disconnect && typeof (peripheral.disconnect) === 'function')
+                                    peripheral.disconnect(() => { });
+                                existingPeripheral.characteristics = res.characteristics;
+                                characteristics = res.characteristics;
+                            }
+                            catch (err) {
+                                console.log(err);
+                            }
+                        }
+                        else {
+                            characteristics = existingPeripheral.characteristics;
+                            this.logEvent({ message: 'characteristic info (+):', info: characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
+                        }
+                        if (!fromCache)
+                            this.addPeripheralToCache(peripheral);
                         let DeviceClasses;
                         if (scanForDevice && (!deviceTypes || deviceTypes.length === 0)) {
                             const classes = BleInterface.deviceClasses.map(c => c.Class);
@@ -461,6 +497,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                             if (device && device.getProfile && device.getProfile() !== d.getProfile())
                                 return;
                             d.setInterface(this);
+                            d.characteristics = characteristics;
                             if (scanForDevice) {
                                 if ((device.id && device.id !== '' && d.id === device.id) ||
                                     (device.address && device.address !== '' && d.address === device.address) ||
@@ -496,9 +533,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                             }
                         });
                     }
-                    else {
-                    }
-                };
+                });
                 this.logEvent({ message: `${opStr}: start scanning`, requested: scanForDevice ? { name: device.name, address: device.address } : undefined, timeout });
                 this.deviceCache.forEach(peripheral => {
                     onPeripheralFound(peripheral, true);
@@ -510,7 +545,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         return reject(err);
                     }
                     bleBinding.on('discover', (p) => {
-                        console.log('~~~ discovered:', p.address, p.advertisement ? p.advertisement.localName : '');
                         onPeripheralFound(p);
                     });
                 });

package/lib/ble/fm.js

@@ -53,7 +53,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             offset += 2;
         }
         if (flags & IndoorBikeDataFlag.AverageSpeedPresent) {
-            this.data.averageSpeed = data.readUInt16LE(offset);
+            this.data.averageSpeed = data.readUInt16LE(offset) / 100;
             offset += 2;
         }
         if (flags & IndoorBikeDataFlag.InstantaneousCadence) {
@@ -61,7 +61,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             offset += 2;
         }
         if (flags & IndoorBikeDataFlag.AverageCadencePresent) {
-            this.data.averageCadence = data.readUInt16LE(offset);
+            this.data.averageCadence = data.readUInt16LE(offset) / 2;
             offset += 2;
         }
         if (flags & IndoorBikeDataFlag.TotalDistancePresent) {
@@ -89,7 +89,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             offset += 2;
         }
         if (flags & IndoorBikeDataFlag.MetabolicEquivalentPresent) {
-            this.data.metabolicEquivalent = data.readUInt16LE(offset);
+            this.data.metabolicEquivalent = data.readUInt16LE(offset) / 10;
             offset += 2;
         }
         if (flags & IndoorBikeDataFlag.ElapsedTimePresent) {
@@ -140,7 +140,7 @@ class FmAdapter extends Device_1.default {
     isHrm() { return false; }
     isPower() { return true; }
     getProfile() {
-        return 'Power Meter';
+        return 'Smart Trainer';
     }
     getName() {
         return `${this.device.name}`;

package/lib/ble/incyclist-protocol.js

@@ -88,7 +88,7 @@ class BleProtocol extends DeviceProtocol_1.default {
                     }
                 });
                 this.logger.logEvent({ message: 'scan started' });
-                yield this.ble.scan({ deviceTypes: supportedDeviceTypes });
+                yield this.ble.scan({ deviceTypes: supportedDeviceTypes, timeout: 20000 });
                 if (props && props.onScanFinished) {
                     props.onScanFinished(props.id);
                 }

package/package.json

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