incyclist-devices 1.4.63 → 1.4.66

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

@@ -11,7 +11,6 @@ declare type CommandQueueItem = {
     data: Buffer;
     resolve: any;
     reject: any;
-    timeout: any;
 };
 export declare abstract class BleDevice extends BleDeviceClass {
     id: string;

package/lib/ble/ble-device.js

@@ -253,34 +253,58 @@ class BleDevice extends ble_1.BleDeviceClass {
     }
     write(characteristicUuid, data, withoutResponse = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!withoutResponse && this.subscribedCharacteristics.find(c => c === characteristicUuid) === undefined) {
+            try {
                 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;
+                const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
+                if (!withoutResponse && !isAlreadySubscribed) {
+                    const connector = this.ble.getConnector(this.peripheral);
+                    connector.removeAllListeners(characteristicUuid);
+                    connector.on(characteristicUuid, (uuid, data) => {
+                        this.onData(uuid, data);
+                    });
+                    this.logEvent({ message: 'write:subscribing ', characteristic: characteristicUuid });
+                    yield connector.subscribe(characteristicUuid);
+                    this.subscribedCharacteristics.push(characteristicUuid);
                 }
-                if (withoutResponse) {
-                    characteristic.write(data, withoutResponse);
-                    resolve(new ArrayBuffer(0));
-                    return;
-                }
-                const writeId = this.writeQueue.length;
-                this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, resolve, reject, timeout: Date.now() + 1000 });
-                characteristic.write(data, withoutResponse, (err) => {
-                    if (err) {
-                        this.writeQueue.splice(writeId, 1);
-                        reject(err);
+                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;
+                    }
+                    if (withoutResponse) {
+                        this.logEvent({ message: 'writing' });
+                        characteristic.write(data, withoutResponse);
+                        resolve(new ArrayBuffer(0));
+                        return;
+                    }
+                    else {
+                        const writeId = this.writeQueue.length;
+                        let messageDeleted = false;
+                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, resolve, reject });
+                        const to = setTimeout(() => {
+                            console.log('~~~ write timeout');
+                            if (this.writeQueue.length > writeId && !messageDeleted)
+                                this.writeQueue.splice(writeId, 1);
+                            this.logEvent({ message: 'writing response', err: 'timeout' });
+                            reject(new Error('timeout'));
+                        }, 5000);
+                        this.logEvent({ message: 'writing' });
+                        characteristic.write(data, withoutResponse, (err) => {
+                            clearTimeout(to);
+                            this.logEvent({ message: 'writing response', err });
+                            if (err) {
+                                this.writeQueue.splice(writeId, 1);
+                                messageDeleted = true;
+                                reject(err);
+                            }
+                        });
                     }
                 });
-            });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: '', error: err.message || err, stack: err.stack });
+            }
         });
     }
     read(characteristicUuid) {

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) {
@@ -540,8 +538,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     if (fromCache)
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
                     else {
-                        const { id, name, address } = peripheral;
-                        this.logEvent({ message: 'BLE scan: found device', peripheral: { id, name, address } });
+                        const { id, name, address, advertisement = {} } = peripheral;
+                        this.logEvent({ message: 'BLE scan: found device', peripheral: { id, name, address, services: advertisement.serviceUuids } });
                     }
                     if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
                         return;
@@ -552,7 +550,11 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         return;
                     peripheralsProcessed.push(peripheral.address);
                     const characteristics = yield this.getCharacteristics(peripheral);
-                    const DeviceClasses = this.getDeviceClasses(peripheral, { profile });
+                    const connector = this.getConnector(peripheral);
+                    const connectedPeripheral = connector.getPeripheral();
+                    const { id, name, address, advertisement = {} } = connectedPeripheral;
+                    const DeviceClasses = this.getDeviceClasses(connectedPeripheral, { profile });
+                    this.logEvent({ message: 'BLE scan: device connected', peripheral: { id, name, address, services: advertisement.serviceUuids, classes: DeviceClasses.map(c => c.prototype.constructor.name) } });
                     let cntFound = 0;
                     DeviceClasses.forEach((DeviceClass) => __awaiter(this, void 0, void 0, function* () {
                         if (!DeviceClass)

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

@@ -22,6 +22,7 @@ export default class BlePeripheralConnector {
     reconnect(): Promise<void>;
     onDisconnect(): void;
     initialize(enforce?: boolean): Promise<void>;
+    isSubscribed(characteristicUuid: string): boolean;
     subscribeAll(callback: (characteristicUuid: string, data: any) => void): Promise<string[]>;
     subscribe(characteristicUuid: string): Promise<boolean>;
     onData(characteristicUuid: string, data: any): void;
@@ -31,4 +32,5 @@ export default class BlePeripheralConnector {
     getState(): string;
     getCharachteristics(): BleCharacteristic[];
     getServices(): string[];
+    getPeripheral(): BlePeripheral;
 }

package/lib/ble/ble-peripheral.js

@@ -86,6 +86,9 @@ class BlePeripheralConnector {
             this.state.isInitialized = this.characteristics !== undefined && this.services !== undefined;
         });
     }
+    isSubscribed(characteristicUuid) {
+        return this.state.subscribed.find(c => c === characteristicUuid || (0, ble_1.uuid)(c) === characteristicUuid || c === (0, ble_1.uuid)(characteristicUuid)) !== undefined;
+    }
     subscribeAll(callback) {
         return __awaiter(this, void 0, void 0, function* () {
             const cnt = this.characteristics.length;
@@ -109,7 +112,6 @@ class BlePeripheralConnector {
                             try {
                                 yield this.subscribe(c.uuid);
                                 subscribed.push(c.uuid);
-                                this.state.subscribed.push(c.uuid);
                             }
                             catch (err) {
                                 this.logEvent({ message: 'cannot subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, error: err.message || err });
@@ -127,21 +129,37 @@ class BlePeripheralConnector {
         });
     }
     subscribe(characteristicUuid) {
+        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) => {
-            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;
+            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) });
+                if (!characteristic) {
+                    reject(new Error('Characteristic not found'));
+                    return;
+                }
+                characteristic.removeAllListeners('data');
+                characteristic.on('data', (data, _isNotification) => {
+                    this.onData(characteristicUuid, data);
+                });
+                const to = setTimeout(() => {
+                    this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: 'timeout' });
+                    reject(new Error('timeout'));
+                }, 3000);
+                characteristic.subscribe((err) => {
+                    clearTimeout(to);
+                    this.logEvent({ message: 'subscribe result', characteristic: characteristicUuid, error: err });
+                    if (err)
+                        reject(err);
+                    else {
+                        this.state.subscribed.push(characteristicUuid);
+                        resolve(true);
+                    }
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message || err, stack: err.stack });
             }
-            characteristic.on('data', (data, _isNotification) => {
-                this.onData(characteristicUuid, data);
-            });
-            characteristic.subscribe((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(true);
-            });
         });
     }
     onData(characteristicUuid, data) {
@@ -167,5 +185,8 @@ class BlePeripheralConnector {
     getServices() {
         return this.services;
     }
+    getPeripheral() {
+        return this.peripheral;
+    }
 }
 exports.default = BlePeripheralConnector;

package/lib/ble/fm.d.ts

@@ -45,6 +45,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     data: IndoorBikeData;
     features: IndoorBikeFeatures;
     hasControl: boolean;
+    isCheckingControl: boolean;
     isCPSubscribed: boolean;
     crr: number;
     cw: number;

package/lib/ble/fm.js

@@ -86,6 +86,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         super(props);
         this.features = undefined;
         this.hasControl = false;
+        this.isCheckingControl = false;
         this.isCPSubscribed = false;
         this.crr = 0.0033;
         this.cw = 0.6;
@@ -99,6 +100,23 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                const connector = this.ble.getConnector(this.peripheral);
+                const isAlreadySubscribed = connector.isSubscribed(FTMS_CP);
+                if (!isAlreadySubscribed) {
+                    connector.removeAllListeners(FTMS_CP);
+                    let prev = undefined;
+                    let prevTS = undefined;
+                    connector.on(FTMS_CP, (uuid, data) => {
+                        const message = data.toString('hex');
+                        if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
+                            return;
+                        }
+                        prevTS = Date.now();
+                        prev = message;
+                        this.onData(uuid, data);
+                    });
+                    yield connector.subscribe(FTMS_CP);
+                }
                 this.logEvent({ message: 'get device info' });
                 yield _super.init.call(this);
                 yield this.getFitnessMachineFeatures();
@@ -300,6 +318,7 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     writeFtmsMessage(requestedOpCode, data) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
                 const res = yield this.write(FTMS_CP, data);
                 const responseData = Buffer.from(res);
                 const opCode = responseData.readUInt8(0);
@@ -307,19 +326,25 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
                 const result = responseData.readUInt8(2);
                 if (opCode !== 128 || request !== requestedOpCode)
                     throw new Error('Illegal response ');
+                this.logEvent({ message: 'fmts:write result', res, result });
                 return result;
             }
             catch (err) {
-                this.logEvent({ message: 'writeFtmsMessage failed', opCode: requestedOpCode, reason: err.message });
+                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
                 return 4;
             }
         });
     }
     requestControl() {
         return __awaiter(this, void 0, void 0, function* () {
+            let to = undefined;
+            if (this.isCheckingControl) {
+                to = setTimeout(() => { }, 3500);
+            }
             if (this.hasControl)
                 return true;
             this.logEvent({ message: 'requestControl' });
+            this.isCheckingControl = true;
             const data = Buffer.alloc(1);
             data.writeUInt8(0, 0);
             const res = yield this.writeFtmsMessage(0, data);
@@ -329,6 +354,9 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             else {
                 this.logEvent({ message: 'requestControl failed' });
             }
+            this.isCheckingControl = false;
+            if (to)
+                clearTimeout(to);
             return this.hasControl;
         });
     }
@@ -340,6 +368,10 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
             if (!this.hasControl)
                 return;
             const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                return true;
+            }
             const data = Buffer.alloc(3);
             data.writeUInt8(5, 0);
             data.writeInt16LE(Math.round(power), 1);
@@ -350,7 +382,8 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     setSlope(slope) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'setSlope', slope });
-            if (!this.hasControl)
+            const hasControl = yield this.requestControl();
+            if (!hasControl)
                 return;
             const { windSpeed, crr, cw } = this;
             return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
@@ -582,7 +615,7 @@ class FmAdapter extends Device_1.default {
                                 break;
                         }
                     }
-                    this.device.requestControl();
+                    yield this.device.requestControl();
                     const startRequest = this.getCyclingMode().getBikeInitRequest();
                     yield this.sendUpdate(startRequest);
                     bleDevice.on('data', (data) => {

package/lib/ble/wahoo-kickr.js

@@ -36,7 +36,7 @@ const ble_interface_1 = __importDefault(require("./ble-interface"));
 const Device_1 = require("../Device");
 const gd_eventlog_1 = require("gd-eventlog");
 const fm_1 = __importStar(require("./fm"));
-const WAHOO_ADVANCED_FTMS = 'a026e005';
+const WAHOO_ADVANCED_FTMS = 'a026e00b';
 const WAHOO_ADVANCED_TRAINER_CP = 'a026e037';
 const cwABike = {
     race: 0.35,
@@ -60,6 +60,23 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                const connector = this.ble.getConnector(this.peripheral);
+                const isAlreadySubscribed = connector.isSubscribed(WAHOO_ADVANCED_TRAINER_CP);
+                if (!isAlreadySubscribed) {
+                    connector.removeAllListeners(WAHOO_ADVANCED_TRAINER_CP);
+                    let prev = undefined;
+                    let prevTS = undefined;
+                    connector.on(WAHOO_ADVANCED_TRAINER_CP, (uuid, data) => {
+                        const message = data.toString('hex');
+                        if (prevTS && prev && message === prev && Date.now() - prevTS < 500) {
+                            return;
+                        }
+                        prevTS = Date.now();
+                        prev = message;
+                        this.onData(uuid, data);
+                    });
+                    yield connector.subscribe(WAHOO_ADVANCED_TRAINER_CP);
+                }
                 this.logEvent({ message: 'get device info' });
                 yield _super.init.call(this);
                 this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });

package/lib/daum/ERGCyclingMode.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const CyclingMode_1 = require("../CyclingMode");
 const calculations_1 = __importDefault(require("../calculations"));
 const power_base_1 = __importDefault(require("../modes/power-base"));
+const MIN_SPEED = 10;
 const config = {
     name: "ERG",
     description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
@@ -147,9 +148,15 @@ class ERGCyclingMode extends power_base_1.default {
             const m = this.getWeight();
             const t = this.getTimeSinceLastUpdate();
             const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
-            data.speed = speed;
+            if (power === 0 && speed < MIN_SPEED) {
+                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = speed;
+                data.distanceInternal = distanceInternal + distance;
+            }
             data.power = Math.round(power);
-            data.distanceInternal = distanceInternal + distance;
             data.slope = slope;
             data.pedalRpm = rpm;
             data.gear = gear;

package/lib/modes/power-meter.js

@@ -62,8 +62,8 @@ class PowerMeterCyclingMode extends power_base_1.default {
                 data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
             }
             else {
-                data.speed = (power === 0 && speed < MIN_SPEED) ? 0 : speed;
-                data.distanceInternal = (power === 0 && speed < MIN_SPEED) ? distanceInternal : distanceInternal + distance;
+                data.speed = speed;
+                data.distanceInternal = distanceInternal + distance;
             }
             if (props.log)
                 this.logger.logEvent({ message: "updateData result", data, bikeData, prevSpeed: prevData.speed, stopped: speed < MIN_SPEED });

package/lib/modes/simulator.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const CyclingMode_1 = require("../CyclingMode");
 const power_base_1 = __importDefault(require("./power-base"));
+const MIN_SPEED = 10;
 const config = {
     name: "Simulator",
     description: "Simulates a ride with constant speed or power output",
@@ -106,6 +107,14 @@ class SimulatorCyclingMode extends power_base_1.default {
                 speed = res.speed;
                 distance = res.distance;
             }
+            if (power === 0 && speed < MIN_SPEED) {
+                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = speed;
+                data.distanceInternal = distanceInternal + distance;
+            }
             data.speed = speed;
             data.power = Math.round(power);
             data.distanceInternal = distanceInternal + distance;

package/lib/simulator/Simulator.js

@@ -218,6 +218,8 @@ class Simulator extends Device_1.default {
             return;
         }
         const prevDist = this.data.distanceInternal;
+        const d = this.data;
+        const prevTime = d.deviceTime;
         this.data = this.getCyclingMode().updateData(this.data);
         let data = {
             speed: this.data.speed,
@@ -230,6 +232,9 @@ class Simulator extends Device_1.default {
             deviceTime: (Date.now() - this.startTS) / 1000,
             deviceDistanceCounter: this.data.distanceInternal
         };
+        if (this.isBot) {
+            this.logger.logEvent(Object.assign({ message: 'Coach update', prevDist, prevTime }, data));
+        }
         this.paused = (this.data.speed === 0);
         if (this.ignoreHrm)
             delete data.heartrate;

package/package.json

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