incyclist-devices 1.4.76 → 1.4.78

package/lib/ble/ble-device.js

@@ -316,7 +316,7 @@ class BleDevice extends ble_1.BleDeviceClass {
                         return;
                     }
                     if (withoutResponse) {
-                        this.logEvent({ message: 'writing' });
+                        this.logEvent({ message: 'writing', data: data.toString('hex'), withoutResponse });
                         characteristic.write(data, withoutResponse);
                         resolve(new ArrayBuffer(0));
                         return;

package/lib/ble/ble-interface.js

@@ -55,9 +55,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~BLE:', event);
-        }
+        console.log('~~BLE:', event);
     }
     onStateChange(state) {
         if (state !== ble_1.BleState.POWERED_ON) {
@@ -583,9 +581,12 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         if (scanForDevice && cntFound > 0)
                             return;
                         const d = this.createDevice(DeviceClass, peripheral, characteristics);
-                        if (!d)
+                        if (!d) {
+                            this.logEvent({ message: `${opStr}: could not create device `, DeviceClass });
                             return;
+                        }
                         try {
+                            this.logEvent({ message: `${opStr}: connecting `, device: d.name, profile: d.getProfile(), address: d.address });
                             yield d.connect();
                         }
                         catch (err) {

package/lib/ble/ble-peripheral.js

@@ -31,9 +31,7 @@ class BlePeripheralConnector {
         if (this.logger) {
             this.logger.logEvent(event);
         }
-        if (process.env.BLE_DEBUG) {
-            console.log('~~~BLE:', event);
-        }
+        console.log('~~~BLE:', event);
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -132,15 +130,15 @@ class BlePeripheralConnector {
         this.logEvent({ message: 'subscribe', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) })) });
         return new Promise((resolve, reject) => {
             try {
-                const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
-                this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid, uuid: (0, ble_1.uuid)(characteristic.uuid) });
+                const characteristic = this.characteristics.find(c => (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid) || (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid));
                 if (!characteristic) {
                     reject(new Error('Characteristic not found'));
                     return;
                 }
+                this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid, uuid: (0, ble_1.uuid)(characteristic.uuid) });
                 characteristic.removeAllListeners('data');
                 characteristic.on('data', (data, _isNotification) => {
-                    this.onData(characteristicUuid, data);
+                    this.onData((0, ble_1.uuid)(characteristicUuid), data);
                 });
                 const to = setTimeout(() => {
                     this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: 'timeout' });
@@ -163,18 +161,18 @@ class BlePeripheralConnector {
         });
     }
     onData(characteristicUuid, data) {
-        this.emitter.emit(characteristicUuid, characteristicUuid, data);
+        this.emitter.emit((0, ble_1.uuid)(characteristicUuid), characteristicUuid, data);
     }
     on(characteristicUuid, callback) {
         if (callback)
-            this.emitter.on(characteristicUuid, callback);
+            this.emitter.on((0, ble_1.uuid)(characteristicUuid), callback);
     }
     off(characteristicUuid, callback) {
         if (callback)
-            this.emitter.off(characteristicUuid, callback);
+            this.emitter.off((0, ble_1.uuid)(characteristicUuid), callback);
     }
     removeAllListeners(characteristicUuid) {
-        this.emitter.removeAllListeners(characteristicUuid);
+        this.emitter.removeAllListeners((0, ble_1.uuid)(characteristicUuid));
     }
     getState() {
         return this.peripheral.state;

package/lib/ble/ble.js

@@ -65,7 +65,7 @@ const uuid = (s) => {
         if (s.includes('-')) {
             const parts = s.split('-');
             const uuidNo = parseInt('0x' + parts[0]);
-            return uuidNo.toString(16);
+            return uuidNo.toString(16).toLowerCase();
         }
         return s;
     }

package/lib/ble/tacx.d.ts

@@ -24,6 +24,14 @@ declare type CrankData = {
     time?: number;
     cntUpdateMissing?: number;
 };
+declare type MessageInfo = {
+    message: string;
+    ts: number;
+    uuid: string;
+};
+declare type MessageLog = {
+    [uuid: string]: MessageInfo;
+};
 export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
     static services: string[];
     static characteristics: string[];
@@ -34,6 +42,8 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     tsPrevWrite: any;
     data: BleFeBikeData;
     hasFECData: boolean;
+    prevMessages: MessageLog;
+    messageCnt: number;
     constructor(props?: any);
     isMatching(characteristics: string[]): boolean;
     init(): Promise<boolean>;
@@ -44,9 +54,13 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     isHrm(): boolean;
     requestControl(): Promise<boolean>;
     parseCrankData(crankData: any): {
+        rpm?: undefined;
+        time?: undefined;
+    } | {
         rpm: number;
         time: any;
     };
+    parseCSC(_data: Buffer): IndoorBikeData;
     parsePower(_data: Buffer): IndoorBikeData;
     resetState(): void;
     parseFEState(capStateBF: number): void;

package/lib/ble/tacx.js

@@ -76,6 +76,8 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         this.tsPrevWrite = undefined;
         this.data = {};
         this.hasFECData = false;
+        this.messageCnt = 0;
+        this.prevMessages = {};
     }
     isMatching(characteristics) {
         if (!characteristics)
@@ -120,8 +122,10 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         });
     }
     parseCrankData(crankData) {
-        if (!this.prevCrankData)
-            this.prevCrankData = { revolutions: 0, time: 0, cntUpdateMissing: -1 };
+        if (!this.prevCrankData) {
+            this.prevCrankData = Object.assign(Object.assign({}, crankData), { cntUpdateMissing: -1 });
+            return {};
+        }
         const c = this.currentCrankData = crankData;
         const p = this.prevCrankData;
         let rpm = this.data.cadence;
@@ -150,7 +154,29 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
             this.prevCrankData.cntUpdateMissing = cntUpdateMissing + 1;
         return { rpm, time: this.timeOffset + c.time };
     }
+    parseCSC(_data) {
+        this.logEvent({ message: 'BLE CSC message', data: _data.toString('hex') });
+        const data = Buffer.from(_data);
+        let offset = 0;
+        const flags = data.readUInt8(offset);
+        offset++;
+        if (flags & 0x01) {
+            offset += 6;
+        }
+        if (flags & 0x02) {
+            const crankData = {
+                revolutions: data.readUInt16LE(offset),
+                time: data.readUInt16LE(offset + 2)
+            };
+            const { rpm, time } = this.parseCrankData(crankData);
+            this.data.cadence = rpm;
+            this.data.time = time;
+            offset += 4;
+        }
+        return this.data;
+    }
     parsePower(_data) {
+        this.logEvent({ message: 'BLE CSP message', data: _data.toString('hex') });
         const data = Buffer.from(_data);
         try {
             let offset = 4;
@@ -174,6 +200,7 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
             }
         }
         catch (err) {
+            this.logEvent({ message: 'error', fn: 'parsePower()', error: err.message || err, stack: err.stack });
         }
         const { instantaneousPower, cadence, time } = this.data;
         return { instantaneousPower, cadence, time, raw: data.toString('hex') };
@@ -349,6 +376,8 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
                 break;
         }
         this.parseFEState(flagStateBF);
+        if (power !== undefined && cadence !== undefined)
+            this.hasFECData = true;
         return this.data;
     }
     parseProductInformation(data) {
@@ -374,26 +403,40 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
         }
         const len = data.readUInt8(1);
         const messageId = data.readUInt8(4);
-        this.hasFECData = true;
         let res;
-        switch (messageId) {
-            case ANTMessages.generalFE:
-                res = this.parseGeneralFE(data.slice(4, len + 3));
-                break;
-            case ANTMessages.trainerData:
-                res = this.parseTrainerData(data.slice(4, len + 3));
-                break;
-            case ANTMessages.productInformation:
-                res = this.parseProductInformation(data.slice(4, len + 3));
-                break;
+        try {
+            switch (messageId) {
+                case ANTMessages.generalFE:
+                    res = this.parseGeneralFE(data.slice(4, len + 3));
+                    break;
+                case ANTMessages.trainerData:
+                    res = this.parseTrainerData(data.slice(4, len + 3));
+                    break;
+                case ANTMessages.productInformation:
+                    res = this.parseProductInformation(data.slice(4, len + 3));
+                    break;
+            }
+            if (res)
+                res.raw = data.toString('hex');
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'parseFECMessage()', error: err.message || err, stack: err.stack });
         }
-        res.raw = data.toString('hex');
         return res;
     }
     onData(characteristic, data) {
         try {
-            super.onData(characteristic, data);
             const uuid = characteristic.toLocaleLowerCase();
+            const message = data.toString('hex');
+            const ts = Date.now();
+            if (this.prevMessages[uuid]) {
+                const prev = this.prevMessages[uuid];
+                if (prev.message === message && prev.ts > ts - 500) {
+                    return;
+                }
+            }
+            this.prevMessages[uuid] = { uuid, ts, message };
+            this.messageCnt++;
             let res = undefined;
             if (uuid && uuid.startsWith(TACX_FE_C_RX)) {
                 res = this.parseFECMessage(data);
@@ -411,6 +454,10 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
                     case '2a37':
                         res = this.parseHrm(data);
                         break;
+                    case '2a5b':
+                        if (!this.hasFECData)
+                            res = this.parseCSC(data);
+                        break;
                     case '2ada':
                         if (!this.hasFECData)
                             res = this.parseFitnessMachineStatus(data);

package/package.json

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