incyclist-devices 1.4.33 → 1.4.36

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

@@ -9,7 +9,7 @@ export interface ConnectState {
     isConnecting: boolean;
     isConnected: boolean;
     timeout?: NodeJS.Timeout;
-    isOpened: boolean;
+    isInitSuccess: boolean;
 }
 export interface BleDeviceInfo {
     device: BleDeviceClass;

package/lib/ble/ble-interface.js

@@ -10,12 +10,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
+const utils_1 = require("../utils");
 const ble_1 = require("./ble");
 class BleInterface extends ble_1.BleInterfaceClass {
     constructor(props = {}) {
         super(props);
         this.scanState = { isScanning: false, timeout: undefined };
-        this.connectState = { isConnecting: false, isConnected: false, isOpened: false };
+        this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
         this.devices = [];
         if (props.logger)
             this.logger = props.logger;
@@ -73,31 +74,49 @@ class BleInterface extends ble_1.BleInterfaceClass {
             this.logEvent({ message: 'connect request' });
             if (!this.getBinding())
                 return Promise.reject(new Error('no binding defined'));
-            if (!this.connectState.isOpened) {
-                this.connectState.timeout = setTimeout(() => {
-                    this.connectState.isConnected = false;
-                    this.connectState.isConnecting = false;
-                    this.connectState.timeout = null;
-                    this.logEvent({ message: 'connect result: timeout' });
-                    reject(new Error('timeout'));
-                }, timeout);
-                try {
+            this.connectState.timeout = setTimeout(() => {
+                this.connectState.isConnected = false;
+                this.connectState.isConnecting = false;
+                this.connectState.timeout = null;
+                this.logEvent({ message: 'connect result: timeout' });
+                reject(new Error('timeout'));
+            }, timeout);
+            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.isOpened = true;
-                        }
-                        catch (err) {
-                            self.connectState.isOpened = 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) {
+                    clearTimeout(this.connectState.timeout);
+                    this.connectState.timeout = null;
+                    this.getBinding().removeAllListeners('stateChange');
+                    this.getBinding().on('stateChange', this.onStateChange.bind(this));
+                    this.connectState.isConnected = true;
+                    this.connectState.isConnecting = false;
+                    this.logEvent({ message: 'connect result: success' });
+                    return resolve(true);
+                }
+                else {
                     this.getBinding().once('error', (err) => {
                         this.connectState.isConnected = true;
                         this.connectState.isConnecting = false;
@@ -116,17 +135,20 @@ class BleInterface extends ble_1.BleInterfaceClass {
                             this.logEvent({ message: 'connect result: success' });
                             return resolve(true);
                         }
+                        else {
+                            this.logEvent({ message: 'BLE state change', state });
+                        }
                     });
                 }
-                catch (err) {
-                    this.connectState.isConnected = false;
-                    this.connectState.isConnecting = false;
-                    if (this.connectState.timeout)
-                        clearTimeout(this.connectState.timeout);
-                    this.connectState.timeout = null;
-                    this.logEvent({ message: 'connect result: error', error: err.message });
-                    return reject(new Error('bluetooth unavailable, cause: ' + err.message));
-                }
+            }
+            catch (err) {
+                this.connectState.isConnected = false;
+                this.connectState.isConnecting = false;
+                if (this.connectState.timeout)
+                    clearTimeout(this.connectState.timeout);
+                this.connectState.timeout = null;
+                this.logEvent({ message: 'connect result: error', error: err.message });
+                return reject(new Error('bluetooth unavailable, cause: ' + err.message));
             }
         });
     }
@@ -209,8 +231,33 @@ class BleInterface extends ble_1.BleInterfaceClass {
     }
     connectDevice(requested, timeout = 2000) {
         return __awaiter(this, void 0, void 0, function* () {
-            const devices = yield this.scan({ timeout, device: requested });
-            const { id, address, name } = requested;
+            const { id, name, address } = requested;
+            this.logEvent({ message: 'connectDevice', id, name, address });
+            let devices = [];
+            let retry = false;
+            let retryCount = 0;
+            do {
+                if (retryCount > 0) {
+                    this.logEvent({ message: 'retry connect device', retryCount });
+                }
+                try {
+                    devices = yield this.scan({ timeout, device: requested });
+                    if (devices.length === 0) {
+                        retryCount++;
+                        retry = retryCount < 5;
+                    }
+                }
+                catch (err) {
+                    if (err.message === 'scanning already in progress') {
+                        this.logEvent({ message: 'scan busy' });
+                        yield utils_1.sleep(1000);
+                        retryCount++;
+                        retry = retryCount < 5;
+                        continue;
+                    }
+                    throw err;
+                }
+            } while (devices.length === 0 && retry);
             if (devices.length === 0)
                 throw new Error('device not found');
             if (devices[0]) {
@@ -237,8 +284,10 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             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) => {
@@ -295,9 +344,12 @@ class BleInterface extends ble_1.BleInterfaceClass {
                                         this.scanState.timeout = null;
                                         bleBinding.stopScanning(() => {
                                             this.scanState.isScanning = false;
+                                            resolve([d]);
                                         });
                                     }
-                                    resolve([d]);
+                                    else {
+                                        resolve([d]);
+                                    }
                                 }
                             });
                         }
@@ -306,9 +358,9 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 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}` : '') });
-                    resolve(this.devices.map(i => i.device));
                     bleBinding.stopScanning(() => {
                         this.scanState.isScanning = false;
+                        resolve(this.devices.map(i => i.device));
                     });
                 }, timeout);
             });

package/lib/ble/ble.d.ts

@@ -23,6 +23,7 @@ export interface BleBinding extends EventEmitter {
     startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
     stopScanning(callback?: () => void): void;
     _bindings: any;
+    state: string;
 }
 export declare type ScanProps = {
     timeout?: number;

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) {
@@ -113,7 +113,7 @@ class HrmAdapter extends Device_1.default {
             }
             catch (err) {
                 this.logger.logEvent({ message: 'start result: error', error: err.message });
-                return false;
+                throw new Error(`could not start device, reason:${err.message}`);
             }
         });
     }

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,
@@ -226,7 +227,7 @@ class PwrAdapter extends Device_1.default {
             }
             catch (err) {
                 this.logger.logEvent({ message: 'start result: error', error: err.message });
-                return false;
+                throw new Error(`could not start device, reason:${err.message}`);
             }
         });
     }

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.33",
+  "version": "1.4.36",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",