incyclist-devices 1.4.67 → 1.4.70

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

@@ -9,6 +9,7 @@ interface BleDeviceConstructProps extends BleDeviceProps {
 declare type CommandQueueItem = {
     uuid: string;
     data: Buffer;
+    timeout: number;
     resolve: any;
     reject: any;
 };
@@ -26,6 +27,7 @@ export declare abstract class BleDevice extends BleDeviceClass {
     isInitialized: boolean;
     subscribedCharacteristics: string[];
     writeQueue: CommandQueueItem[];
+    workerIv: NodeJS.Timeout;
     constructor(props?: BleDeviceConstructProps);
     logEvent(event: any): void;
     setLogger(logger: EventLogger): void;
@@ -36,12 +38,16 @@ export declare abstract class BleDevice extends BleDeviceClass {
     waitForConnectFinished(timeout: any): Promise<unknown>;
     hasService(serviceUuid: any): boolean;
     init(): Promise<boolean>;
+    initDevice(): Promise<boolean>;
     connectPeripheral(peripheral: BlePeripheral): Promise<void>;
     subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
     connect(props?: ConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
     abstract getProfile(): string;
     onData(characteristic: string, data: Buffer): void;
+    timeoutCheck(): void;
+    startWorker(): void;
+    stopWorker(): void;
     write(characteristicUuid: string, data: Buffer, withoutResponse?: boolean): Promise<ArrayBuffer>;
     read(characteristicUuid: string): Promise<Uint8Array>;
     getDeviceInfo(): Promise<BleDeviceInfo>;

package/lib/ble/ble-device.js

@@ -27,6 +27,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         this.subscribedCharacteristics = [];
         this.isInitialized = false;
         this.writeQueue = [];
+        this.workerIv = null;
         if (props.peripheral) {
             const { id, address, advertisement, state } = props.peripheral;
             this.peripheral = props.peripheral;
@@ -106,11 +107,15 @@ class BleDevice extends ble_1.BleDeviceClass {
         return this.services && this.services.find(s => s === serviceUuid || (0, ble_1.uuid)(serviceUuid)) !== undefined;
     }
     init() {
-        if (this.isInitialized)
-            return Promise.resolve(true);
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.initDevice();
+        });
+    }
+    initDevice() {
+        this.logEvent({ message: 'get device info' });
         return this.getDeviceInfo().then(() => {
             this.emit('deviceInfo', this.deviceInfo);
-            this.logEvent(Object.assign({ message: 'ftms device init done' }, this.deviceInfo));
+            this.logEvent(Object.assign({ message: 'device init done' }, this.deviceInfo));
             this.isInitialized = true;
             return true;
         });
@@ -223,6 +228,9 @@ class BleDevice extends ble_1.BleDeviceClass {
             const { id, name, address } = this;
             this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
             this.connectState.isDisconnecting = true;
+            if (this.workerIv) {
+                this.stopWorker();
+            }
             if (!this.connectState.isConnecting && !this.connectState.isConnected) {
                 this.connectState.isDisconnecting = false;
                 this.logEvent({ message: 'disconnect result: success', device: { id, name, address } });
@@ -254,11 +262,43 @@ class BleDevice extends ble_1.BleDeviceClass {
             }
         }
     }
+    timeoutCheck() {
+        const now = Date.now();
+        const updatedQueue = [];
+        let hasTimeout = false;
+        this.writeQueue.forEach(writeItem => {
+            if (writeItem.timeout && writeItem.timeout < now) {
+                if (writeItem.reject) {
+                    hasTimeout = true;
+                    writeItem.reject(new Error('timeout'));
+                }
+            }
+            else {
+                updatedQueue.push(writeItem);
+            }
+        });
+        if (hasTimeout)
+            this.writeQueue = updatedQueue;
+    }
+    startWorker() {
+        if (this.workerIv)
+            return;
+        this.workerIv = setInterval(() => { this.timeoutCheck(); }, 100);
+    }
+    stopWorker() {
+        if (!this.workerIv)
+            return;
+        clearInterval(this.workerIv);
+        this.workerIv = null;
+    }
     write(characteristicUuid, data, withoutResponse = false) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const connector = this.ble.getConnector(this.peripheral);
                 const isAlreadySubscribed = connector.isSubscribed(characteristicUuid);
+                if (!withoutResponse && !this.workerIv) {
+                    this.startWorker();
+                }
                 if (!withoutResponse && !isAlreadySubscribed) {
                     const connector = this.ble.getConnector(this.peripheral);
                     connector.removeAllListeners(characteristicUuid);
@@ -284,7 +324,7 @@ class BleDevice extends ble_1.BleDeviceClass {
                     else {
                         const writeId = this.writeQueue.length;
                         let messageDeleted = false;
-                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, resolve, reject });
+                        this.writeQueue.push({ uuid: characteristicUuid.toLocaleLowerCase(), data, timeout: Date.now() + 2500, resolve, reject });
                         const to = setTimeout(() => {
                             if (this.writeQueue.length > writeId && !messageDeleted)
                                 this.writeQueue.splice(writeId, 1);

package/lib/ble/ble-interface.js

@@ -590,14 +590,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
                             cntFound++;
                         const existing = devicesProcessed.find(device => device.id === d.id && device.getProfile() === d.getProfile());
                         if (!scanForDevice && cntFound > 0 && !existing) {
-                            this.logEvent({ message: `${opStr}: device found`, device: d.name, address: d.address, services: d.services.join(',') });
+                            this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
                             this.addDeviceToCache(d, peripheral.state === 'connected');
                             devicesProcessed.push(d);
                             this.emit('device', d);
                             return;
                         }
                         if (scanForDevice && cntFound > 0) {
-                            this.logEvent({ message: `${opStr}: device found`, device: d.name, address: d.address, services: d.services.join(',') });
+                            this.logEvent({ message: `${opStr}: device found`, device: d.name, profile: d.getProfile(), address: d.address, services: d.services.join(',') });
                             this.addDeviceToCache(d, peripheral.state === 'connected');
                             devicesProcessed.push(d);
                             this.emit('device', d);

package/lib/ble/fm.d.ts

@@ -53,6 +53,7 @@ export default class BleFitnessMachineDevice extends BleDevice {
     wheelSize: number;
     constructor(props?: any);
     isMatching(characteristics: string[]): boolean;
+    subscribeWriteResponse(cuuid: string): Promise<void>;
     init(): Promise<boolean>;
     onDisconnect(): void;
     getProfile(): string;

package/lib/ble/fm.js

@@ -104,35 +104,40 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
         const hasIndoorBike = characteristics.find(c => c === INDOOR_BIKE_DATA) !== undefined;
         return hasStatus && hasCP && hasIndoorBike;
     }
+    subscribeWriteResponse(cuuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connector = this.ble.getConnector(this.peripheral);
+            const isAlreadySubscribed = connector.isSubscribed(cuuid);
+            if (!isAlreadySubscribed) {
+                connector.removeAllListeners(cuuid);
+                let prev = undefined;
+                let prevTS = undefined;
+                connector.on(cuuid, (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(cuuid);
+            }
+        });
+    }
     init() {
         const _super = Object.create(null, {
-            init: { get: () => super.init }
+            initDevice: { get: () => super.initDevice }
         });
         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.subscribeWriteResponse(FTMS_CP);
+                yield _super.initDevice.call(this);
                 yield this.getFitnessMachineFeatures();
                 this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
             }
             catch (err) {
+                this.logEvent({ message: 'error', fn: 'BleFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
                 return Promise.resolve(false);
             }
         });
@@ -419,9 +424,11 @@ class BleFitnessMachineDevice extends ble_device_1.BleDevice {
     }
     setIndoorBikeSimulation(windSpeed, gradient, crr, cw) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasControl)
-                return;
             const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setIndoorBikeSimulation failed', reason: 'control is disabled' });
+                return false;
+            }
             const data = Buffer.alloc(7);
             data.writeUInt8(17, 0);
             data.writeInt16LE(Math.round(windSpeed * 1000), 1);
@@ -504,7 +511,8 @@ class FmAdapter extends Device_1.default {
         return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
     }
     getProfile() {
-        return 'Smart Trainer';
+        const profile = this.device ? this.device.getProfile() : undefined;
+        return profile || 'Smart Trainer';
     }
     getName() {
         return `${this.device.name}`;

package/lib/ble/tacx.js

@@ -42,7 +42,7 @@ const TACX_FE_C_TX = '6e40fec3';
 const SYNC_BYTE = 0xA4;
 const DEFAULT_CHANNEL = 5;
 const ACKNOWLEDGED_DATA = 0x4F;
-const PROFILE_ID = 'Tacx FE-C over BLE';
+const PROFILE_ID = 'Tacx SmartTrainer';
 const cwABike = {
     race: 0.35,
     triathlon: 0.29,
@@ -79,16 +79,16 @@ class TacxAdvancedFitnessMachineDevice extends fm_1.default {
     }
     init() {
         const _super = Object.create(null, {
-            init: { get: () => super.init }
+            initDevice: { get: () => super.initDevice }
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                this.logEvent({ message: 'get device info' });
-                yield _super.init.call(this);
-                this.logEvent({ message: 'device info', deviceInfo: this.deviceInfo, features: this.features });
+                yield _super.initDevice.call(this);
+                return true;
             }
             catch (err) {
-                return Promise.resolve(false);
+                this.logEvent({ message: 'error', fn: 'TacxAdvancedFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
+                return false;
             }
         });
     }

package/lib/ble/wahoo-kickr.d.ts

@@ -34,6 +34,7 @@ export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachine
     currentCrankData: CrankData;
     timeOffset: number;
     tsPrevWrite: any;
+    prevSlope: any;
     constructor(props?: any);
     isMatching(characteristics: string[]): boolean;
     init(): Promise<boolean>;

package/lib/ble/wahoo-kickr.js

@@ -37,7 +37,7 @@ const Device_1 = require("../Device");
 const gd_eventlog_1 = require("gd-eventlog");
 const fm_1 = __importStar(require("./fm"));
 const WAHOO_ADVANCED_FTMS = 'a026e00b';
-const WAHOO_ADVANCED_TRAINER_CP = 'a026e037';
+const WAHOO_ADVANCED_TRAINER_CP = 'a026e005';
 const cwABike = {
     race: 0.35,
     triathlon: 0.29,
@@ -52,6 +52,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         this.currentCrankData = undefined;
         this.timeOffset = 0;
         this.tsPrevWrite = undefined;
+        this.prevSlope = undefined;
         this.data = {};
     }
     isMatching(characteristics) {
@@ -62,33 +63,17 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
     }
     init() {
         const _super = Object.create(null, {
-            init: { get: () => super.init }
+            initDevice: { get: () => super.initDevice }
         });
         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 });
+                yield this.subscribeWriteResponse(WAHOO_ADVANCED_TRAINER_CP);
+                yield _super.initDevice.call(this);
+                return true;
             }
             catch (err) {
-                return Promise.resolve(false);
+                this.logEvent({ message: 'error', fn: 'WahooAdvancedFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
+                return false;
             }
         });
     }
@@ -195,7 +180,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
                 const opcode = Buffer.alloc(1);
                 opcode.writeUInt8(requestedOpCode, 0);
                 const message = Buffer.concat([opcode, data]);
-                const res = yield this.write(WAHOO_ADVANCED_FTMS, message);
+                const res = yield this.write(WAHOO_ADVANCED_TRAINER_CP, message);
                 const responseData = Buffer.from(res);
                 const result = responseData.readUInt8(0);
                 this.logEvent({ message: 'response', opCode: requestedOpCode, response: responseData.toString('hex') });
@@ -311,8 +296,23 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
     setSlope(slope) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'setSlope', slope });
-            const { windSpeed, crr, cw } = this;
-            return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
+            if (this.prevSlope !== undefined && slope === this.prevSlope)
+                return;
+            try {
+                const hasControl = yield this.requestControl();
+                if (!hasControl) {
+                    this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
+                    return false;
+                }
+                const res = yield this.setSimGrade(slope);
+                this.logEvent({ message: 'setSlope result', res });
+                this.prevSlope = slope;
+                return res;
+            }
+            catch (err) {
+                this.logEvent({ message: 'setSlope failed', reason: err.message || err });
+                this.prevSlope = undefined;
+            }
         });
     }
     reset() {
@@ -320,7 +320,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
     }
 }
 exports.default = WahooAdvancedFitnessMachineDevice;
-WahooAdvancedFitnessMachineDevice.services = ['a026ee0b'];
+WahooAdvancedFitnessMachineDevice.services = ['1818'];
 WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', WAHOO_ADVANCED_TRAINER_CP];
 ble_interface_1.default.register('WahooAdvancedFitnessMachineDevice', 'wahoo-fm', WahooAdvancedFitnessMachineDevice, WahooAdvancedFitnessMachineDevice.services);
 class WahooAdvancedFmAdapter extends fm_1.FmAdapter {

package/lib/daum/classic/utils.d.ts

@@ -1,7 +1,7 @@
 export declare const DEFAULT_AGE = 30;
 export declare const DEFAULT_USER_WEIGHT = 75;
 export declare const DEFAULT_BIKE_WEIGHT = 10;
-export declare function getCockpit(c: any): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8008 TRS" | "8080" | "Therapie" | "8008 TRS Pro" | "8008 TRS3" | "Unknown";
+export declare function getCockpit(c: any): "Cardio" | "Fitness" | "Vita De Luxe" | "8008" | "8008 TRS" | "8080" | "Therapie" | "8008 TRS Pro" | "8008 TRS3" | "ergo_lyps Cardio Pro" | "Unknown";
 export declare function getBikeType(type: any): 1 | 0;
 export declare function getGender(sex: any): 1 | 2;
 export declare function getLength(length: any): number;

package/lib/daum/classic/utils.js

@@ -24,6 +24,8 @@ function getCockpit(c) {
             return "8008 TRS Pro";
         case 160:
             return "8008 TRS3";
+        case 0x8D:
+            return "ergo_lyps Cardio Pro";
         default:
             return "Unknown";
     }

package/package.json

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