incyclist-devices 3.0.19 → 3.0.21

package/lib/cjs/base/consts.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+exports.DEFAULT_PROPS = exports.DEFAULT_WHEEL_CIRCUMFERENCE = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
+exports.DEFAULT_WHEEL_CIRCUMFERENCE = 2.118;
 exports.DEFAULT_PROPS = {
     userWeight: exports.DEFAULT_USER_WEIGHT,
     bikeWeight: exports.DEFAULT_BIKE_WEIGHT

package/lib/cjs/ble/base/adapter.js

@@ -359,17 +359,14 @@ class BleAdapter extends adpater_js_1.default {
         sensor.off('data', this.onDeviceDataHandler);
         let connected = false;
         if (sensor.isReconnectBusy()) {
-            connected = await sensor.reconnectSensor(false);
-        }
-        if (connected) {
-            sensor.on('data', this.onDeviceDataHandler);
-            return true;
+            connected = await sensor.reconnectSensor(true);
+            if (connected) {
+                sensor.on('data', this.onDeviceDataHandler);
+            }
+            return connected;
         }
         await sensor.getPeripheral().disconnect();
         const success = await super.restart(pause);
-        if (success) {
-            sensor.on('data', this.onDeviceDataHandler);
-        }
         return success;
     }
     async stop() {

package/lib/cjs/ble/base/interface.js

@@ -405,7 +405,12 @@ class BleInterface extends node_events_1.EventEmitter {
         }
         const isWahoo = this.checkForWahooEnhancement(announcement);
         if (isWahoo) {
-            this.processWahooAnnouncement(announcement);
+            this.processEnrichedAnnouncement(announcement);
+            return;
+        }
+        const isTacx = this.checkForTacxEnhancement(announcement);
+        if (isTacx) {
+            this.processEnrichedAnnouncement(announcement);
             return;
         }
         this.addService(announcement);
@@ -419,7 +424,7 @@ class BleInterface extends node_events_1.EventEmitter {
         }
         return false;
     }
-    processWahooAnnouncement(announcement) {
+    processEnrichedAnnouncement(announcement) {
         if (this.isCompleting(announcement)) {
             return;
         }
@@ -429,6 +434,19 @@ class BleInterface extends node_events_1.EventEmitter {
                 this.addService(announcement);
         });
     }
+    checkForTacxEnhancement(announcement) {
+        const name = announcement?.name?.toUpperCase();
+        if (name.startsWith('TACX')) {
+            const supported = announcement.serviceUUIDs.map(s => (0, utils_js_1.beautifyUUID)(s));
+            const tacxService = (0, utils_js_1.beautifyUUID)('6E40FEC1-B5A3-F393-E0A9-E50E24DCCA9E');
+            const cp = (0, utils_js_1.beautifyUUID)('1818');
+            const fe = (0, utils_js_1.beautifyUUID)('1826');
+            if (supported.includes(cp) && !supported.includes(fe) && !supported.includes(tacxService)) {
+                return true;
+            }
+        }
+        return false;
+    }
     buildAnnouncement(peripheral) {
         return {
             advertisement: peripheral.advertisement,

package/lib/cjs/ble/base/peripheral.js

@@ -163,8 +163,9 @@ class BlePeripheral {
     async _discoverServices() {
         if (!this.getPeripheral())
             return [];
+        const { name, address } = this.getInfo();
         if (this.getPeripheral().discoverServicesAsync) {
-            this.logEvent({ message: 'discover services', address: this.getPeripheral().address });
+            this.logEvent({ message: 'discover services', name, address });
             const peripheral = this.getPeripheral();
             let services = [];
             if (peripheral?.discoverServicesAsync) {
@@ -172,14 +173,14 @@ class BlePeripheral {
                     .catch(() => []);
             }
             this.discoveredServiceUUIds = services.map(s => (0, utils_js_2.beautifyUUID)(s.uuid));
-            this.logEvent({ message: 'discover services result', address: this.getPeripheral().address, services: this.discoveredServiceUUIds });
+            this.logEvent({ message: 'discover services result', name, address, services: this.discoveredServiceUUIds });
             return services.map(s => s.uuid);
         }
         else {
-            this.logEvent({ message: 'discover services and characteristics', address: this.getPeripheral().address });
+            this.logEvent({ message: 'discover services and characteristics', name, address });
             const res = await this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
             this.discoveredServiceUUIds = res.services.map(s => (0, utils_js_2.beautifyUUID)(s.uuid));
-            this.logEvent({ message: 'discover services result', address: this.getPeripheral().address, services: this.discoveredServiceUUIds });
+            this.logEvent({ message: 'discover services result', name, address, services: this.discoveredServiceUUIds });
             return res.services.map(s => s.uuid);
         }
     }
@@ -193,10 +194,12 @@ class BlePeripheral {
     async _discoverCharacteristics(serviceUUID) {
         if (!this.getPeripheral())
             return [];
-        this.logEvent({ message: 'discover services and characteristics', service: serviceUUID, address: this.getPeripheral().address });
+        const { name, address } = this.getInfo();
+        this.logEvent({ message: 'discover services and characteristics', name, address, service: serviceUUID });
         const res = await this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([serviceUUID], [])
             .catch(() => ({ services: [], characteristics: [] }));
         res.characteristics.forEach(c => this.characteristics[(0, utils_js_2.beautifyUUID)(c.uuid)] = c);
+        this.logEvent({ message: 'discover services and characteristics result', name, address, service: serviceUUID });
         return res.characteristics.map(c => {
             const { uuid, properties, name, _serviceUuid } = c;
             return { uuid, properties, name, _serviceUuid };
@@ -318,6 +321,15 @@ class BlePeripheral {
                     if (!success)
                         retry.push(c);
                 }
+                else {
+                    const uuid = (0, utils_js_2.beautifyUUID)(element);
+                    if (c?.properties) {
+                        this.logEvent({ message: 'cannot subscribe', uuid, reason: 'invalid type', properties: c.properties.join('|') });
+                    }
+                    else {
+                        this.logEvent({ message: 'cannot subscribe', uuid, reason: 'not found' });
+                    }
+                }
             }
             for (const element of retry) {
                 const c = element;
@@ -332,12 +344,17 @@ class BlePeripheral {
     }
     async discoverAllCharacteristics() {
         try {
+            const { name, address } = this.getInfo();
+            this.logEvent({ message: 'discover all characteristics', name, address });
             const res = await this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
             const found = [];
+            const uuids = [];
             res.characteristics.forEach(c => {
                 this.characteristics[(0, utils_js_2.beautifyUUID)(c.uuid)] = c;
                 found.push(c.uuid);
+                uuids.push((0, utils_js_2.beautifyUUID)(c.uuid));
             });
+            this.logEvent({ message: 'discover all characteristics result', name, address, uuids: uuids.join('|') });
             return found;
         }
         catch (err) {

package/lib/cjs/ble/base/sensor.js

@@ -12,6 +12,7 @@ class TBleSensor extends node_events_1.EventEmitter {
     stopRequested = false;
     subscribeSuccess = false;
     reconnectPromise;
+    connectPromise;
     onDataHandler;
     logEvent(event, ...args) {
         try {
@@ -76,7 +77,8 @@ class TBleSensor extends node_events_1.EventEmitter {
             this.logEvent({ message: 'no peripheral' });
             return false;
         }
-        const connected = await this.peripheral.connect();
+        this.connectPromise = this.connectPromise ?? this.peripheral.connect();
+        const connected = await this.connectPromise;
         if (!connected)
             return false;
         if (!reconnect)
@@ -128,6 +130,9 @@ class TBleSensor extends node_events_1.EventEmitter {
         let connected = false;
         let subscribed = false;
         let success = false;
+        if (connectionLost) {
+            this.emit('connctionLost');
+        }
         await (0, utils_js_1.sleep)(500);
         do {
             try {
@@ -147,6 +152,9 @@ class TBleSensor extends node_events_1.EventEmitter {
             if (!this.stopRequested && !success)
                 this.logEvent({ message: 'reconnect sensor retry', name, address });
         } while (!success || this.stopRequested);
+        if (connectionLost && success) {
+            this.emit('connctionRecovered');
+        }
         this.logEvent({ message: 'reconnect sensor completed', success, stopRequested: this.stopRequested });
         return success;
     }
@@ -156,6 +164,9 @@ class TBleSensor extends node_events_1.EventEmitter {
     isConnected() {
         return this.peripheral?.isConnected();
     }
+    isReady() {
+        return this.isConnected() && this.connectPromise === undefined && this.reconnectPromise === undefined;
+    }
     isSubscribed() {
         return this.subscribeSuccess;
     }

package/lib/cjs/ble/characteristics/csc/measurement.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CscMeasurement = void 0;
+const consts_js_1 = require("../../../base/consts.js");
 class CscMeasurement {
     data;
     prevCrankData = undefined;
@@ -8,13 +9,16 @@ class CscMeasurement {
     prevWheelData = undefined;
     currentWheelData = undefined;
     timeOffset = 0;
-    cw = 2.1;
+    cw = consts_js_1.DEFAULT_WHEEL_CIRCUMFERENCE;
     constructor(data = {}) {
         this.data = data;
     }
     setWheelCircumference(wheelCircumference) {
         this.cw = wheelCircumference;
     }
+    getWheelCircumference() {
+        return this.cw;
+    }
     parse(buffer, features) {
         const data = Buffer.from(buffer);
         let offset = 0;
@@ -89,7 +93,7 @@ class CscMeasurement {
             }
             const seconds = time / 1024;
             const rps = revs / seconds;
-            speed = rps * this.cw;
+            speed = rps * this.cw * 3.6;
         }
         else if (p.cntUpdateMissing < 0 || p.cntUpdateMissing > 2) {
             speed = 0;

package/lib/cjs/ble/csc/adapter.js

@@ -8,9 +8,14 @@ const gd_eventlog_1 = require("gd-eventlog");
 const adapter_js_1 = __importDefault(require("../base/adapter.js"));
 const index_js_1 = require("../../types/index.js");
 const sensor_js_1 = require("./sensor.js");
+const speed_js_1 = __importDefault(require("../../modes/speed.js"));
 class BleCSCAdapter extends adapter_js_1.default {
     static INCYCLIST_PROFILE_NAME = 'Speed + Cadence Sensor';
     static CAPABILITIES = [index_js_1.IncyclistCapability.Speed, index_js_1.IncyclistCapability.Cadence];
+    static controllers = {
+        modes: [speed_js_1.default],
+        default: speed_js_1.default
+    };
     constructor(settings, props) {
         super(settings, props);
         this.logger = new gd_eventlog_1.EventLogger('Ble-CSC');
@@ -48,8 +53,30 @@ class BleCSCAdapter extends adapter_js_1.default {
         return this.getName();
     }
     mapData(deviceData) {
-        const { cadence, speed } = deviceData;
-        return { cadence, speed: speed * 3.6 };
+        const { cadence, speed = 0 } = deviceData;
+        return { cadence, speed };
+    }
+    transformData(bikeData) {
+        if (bikeData === undefined)
+            return;
+        let data = {
+            speed: bikeData.speed,
+            power: bikeData.power,
+            cadence: bikeData.pedalRpm,
+            timestamp: Date.now()
+        };
+        if (bikeData.time)
+            data.deviceTime = bikeData.time;
+        this.data = data;
+        return data;
+    }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        super.setCyclingMode(mode, settings, sendInitCommands);
+        try {
+            const wc = this.getCyclingMode().getSetting('wc');
+            this.getSensor().setWheelCircumference(wc / 1000);
+        }
+        catch { }
     }
 }
 exports.BleCSCAdapter = BleCSCAdapter;

package/lib/cjs/ble/csc/sensor.js

@@ -15,12 +15,12 @@ class BleCyclingSpeedCadenceDevice extends sensor_js_1.TBleSensor {
     data;
     parsers = {};
     featureParser;
+    measurement = new measurement_js_1.CscMeasurement();
     constructor(peripheral, props) {
         super(peripheral, props);
         this.data = {};
-        const measurement = new measurement_js_1.CscMeasurement();
         this.featureParser = new features_js_1.CscFeatures();
-        this.parsers[(0, utils_js_1.beautifyUUID)(consts_js_1.CSC_MEASUREMENT)] = measurement;
+        this.parsers[(0, utils_js_1.beautifyUUID)(consts_js_1.CSC_MEASUREMENT)] = this.measurement;
     }
     getRequiredCharacteristics() {
         return [consts_js_1.CSC_MEASUREMENT];
@@ -34,6 +34,7 @@ class BleCyclingSpeedCadenceDevice extends sensor_js_1.TBleSensor {
         }
         catch (err) {
             this.logEvent({ message: 'read failed', characteristic: consts_js_1.CSC_FEATURE, reason: err.message });
+            return {};
         }
     }
     onData(characteristic, characteristicData) {
@@ -54,5 +55,11 @@ class BleCyclingSpeedCadenceDevice extends sensor_js_1.TBleSensor {
     reset() {
         this.data = {};
     }
+    async setWheelCircumference(wheelCircumference) {
+        this.measurement.setWheelCircumference(wheelCircumference);
+    }
+    getWheelCircumference() {
+        return this.measurement.getWheelCircumference();
+    }
 }
 exports.BleCyclingSpeedCadenceDevice = BleCyclingSpeedCadenceDevice;

package/lib/cjs/ble/fm/adapter.js

@@ -327,6 +327,9 @@ class BleFmAdapter extends adapter_js_1.default {
                 delete this.promiseSendUpdate;
                 return confirmed;
             }
+            if (!device.isReady()) {
+                this.logEvent({ message: 'send bike update failed', reason: 'not connected' });
+            }
         }
         catch (error) {
             const err = error;

package/lib/cjs/ble/wahoo/adapter.js

@@ -7,6 +7,7 @@ const gd_eventlog_1 = require("gd-eventlog");
 const index_js_1 = require("../fm/index.js");
 const sensor_js_1 = __importDefault(require("./sensor.js"));
 const index_js_2 = require("../../types/index.js");
+const calculations_js_1 = __importDefault(require("../../utils/calculations.js"));
 class BleWahooAdapter extends index_js_1.BleFmAdapter {
     static INCYCLIST_PROFILE_NAME = 'Smart Trainer';
     constructor(settings, props) {
@@ -29,6 +30,15 @@ class BleWahooAdapter extends index_js_1.BleFmAdapter {
     updateSensor(peripheral) {
         this.device = new sensor_js_1.default(peripheral, { logger: this.logger });
     }
+    mapData(deviceData) {
+        const data = super.mapData(deviceData);
+        if (!deviceData.instantaneousPower && !deviceData.cadence && (deviceData.speed ?? 0) > 0) {
+            const m = this.getWeight();
+            data.isPedalling = true;
+            data.power = calculations_js_1.default.calculatePower(m, data.speed / 3.6, 0);
+        }
+        return data;
+    }
     async checkCapabilities() {
         this.logEvent({ message: 'device capabilities updated', name: this.getSettings().name, interface: this.getSettings().interface, capabilities: this.capabilities });
     }

package/lib/cjs/ble/wahoo/sensor.js

@@ -23,6 +23,9 @@ class BleWahooDevice extends sensor_js_1.default {
     isSimMode;
     isRequestControlBusy = false;
     weight = consts_js_1.DEFAULT_BIKE_WEIGHT + consts_js_1.DEFAULT_USER_WEIGHT;
+    prevWheelRevolutions = undefined;
+    prevWheelEventTime = undefined;
+    wheelCircumference = 2.096;
     simModeSettings;
     constructor(peripheral, props) {
         super(peripheral, props);
@@ -163,17 +166,40 @@ class BleWahooDevice extends sensor_js_1.default {
     }
     parsePower(_data) {
         const data = Buffer.from(_data);
+        let balance;
+        let accTorque;
+        let speed;
+        let wheelRevolutions, wheelEventTime;
         try {
             let offset = 4;
             const flags = data.readUInt16LE(0);
             this.data.instantaneousPower = data.readUInt16LE(2);
             if (flags & 0x1)
-                data.readUInt8(offset++);
+                balance = data.readUInt8(offset++);
             if (flags & 0x4) {
+                accTorque = data.readUInt16LE(offset);
                 offset += 2;
             }
             if (flags & 0x10) {
+                wheelRevolutions = data.readUInt32LE(offset);
+                wheelEventTime = data.readUInt16LE(offset + 4);
                 offset += 6;
+                if (this.prevWheelRevolutions !== undefined && this.prevWheelEventTime !== undefined) {
+                    const wheelRevDelta = wheelRevolutions - this.prevWheelRevolutions;
+                    const wheelTimeDelta = (wheelEventTime - this.prevWheelEventTime + 65536) % 65536;
+                    const timeSeconds = (wheelTimeDelta / 1024);
+                    if (timeSeconds > 0 && wheelRevDelta >= 0) {
+                        const distance = wheelRevDelta * this.wheelCircumference;
+                        speed = distance / timeSeconds * 3.6;
+                        this.data.speed = speed;
+                    }
+                    else if (timeSeconds > 0 && wheelRevDelta === 0) {
+                        speed = 0;
+                        this.data.speed = speed;
+                    }
+                }
+                this.prevWheelRevolutions = wheelRevolutions;
+                this.prevWheelEventTime = wheelEventTime;
             }
             if (flags & 0x20) {
                 const crankData = {
@@ -188,8 +214,8 @@ class BleWahooDevice extends sensor_js_1.default {
         catch (err) {
             this.logEvent({ message: 'error', fn: 'parsePower', error: err.message, stack: err.stack });
         }
-        const { instantaneousPower, cadence, time } = this.data;
-        return { instantaneousPower, cadence, time, raw: data.toString('hex') };
+        const { instantaneousPower, cadence, speed: dataSpeed, time } = this.data;
+        return { instantaneousPower, speed: dataSpeed, cadence, time, raw: '2a63:' + data.toString('hex') };
     }
     supportsHeartRate() {
         try {
@@ -341,5 +367,11 @@ class BleWahooDevice extends sensor_js_1.default {
             return false;
         }
     }
+    async setWheelCircumference(wheelCircumference) {
+        this.wheelCircumference = wheelCircumference;
+    }
+    getWheelCircumference() {
+        return this.wheelCircumference;
+    }
 }
 exports.default = BleWahooDevice;

package/lib/cjs/modes/speed.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("./base");
+const types_1 = require("./types");
+const calculations_js_1 = __importDefault(require("../utils/calculations.js"));
+const consts_js_1 = require("../base/consts.js");
+class SpeedCyclingMode extends base_1.CyclingModeBase {
+    data;
+    prevUpdateTS = 0;
+    prevRequest;
+    static config = {
+        name: "SpeedSensor",
+        description: "Calculates power based on speed and slope.",
+        properties: [
+            { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+            { key: 'wc', name: 'Wheel Circumference', description: 'Circumference in mm', type: types_1.CyclingModeProperyType.Integer, default: Math.ceil(consts_js_1.DEFAULT_WHEEL_CIRCUMFERENCE * 1000) },
+        ]
+    };
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.data = { speed: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
+    }
+    getData() {
+        return this.data;
+    }
+    getSlope() {
+        const { slope } = this.data;
+        return slope || 0;
+    }
+    getWeight() {
+        const a = this.adapter;
+        const defaultWeight = consts_js_1.DEFAULT_BIKE_WEIGHT + consts_js_1.DEFAULT_USER_WEIGHT;
+        const m = (a) ? a.getWeight() || defaultWeight : defaultWeight;
+        return m;
+    }
+    getTimeSinceLastUpdate() {
+        const ts = Date.now();
+        const duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+        return duration;
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    updateData(data, log = true) {
+        const prevData = this.data;
+        const prevRequest = this.prevRequest ?? {};
+        const slope = (prevRequest.slope !== undefined ? prevRequest.slope : prevData.slope ?? 0);
+        const { pedalRpm = 0 } = data ?? {};
+        const bikeType = this.getSetting('bikeType')?.toLowerCase();
+        if (data.isPedalling === false || data.speed === 0) {
+            this.data = {
+                ...data,
+                speed: 0,
+                isPedalling: false,
+                power: 0,
+                slope
+            };
+            this.prevUpdateTS = Date.now();
+            return this.data;
+        }
+        const m = this.getWeight();
+        const t = this.getTimeSinceLastUpdate();
+        const v = (data.speed ?? 0) / 3.6;
+        const power = calculations_js_1.default.calculatePower(m, v, 0, { bikeType });
+        const { speed: calcSpeed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+        const prevTime = this.data.time ?? 0;
+        const prevDistance = this.data.distanceInternal ?? 0;
+        const updated = {
+            ...data,
+            time: prevTime + t,
+            isPedalling: data.isPedalling ?? (v > 0 || pedalRpm > 0),
+            slope,
+            power,
+            speed: calcSpeed,
+            distanceInternal: prevDistance + distance
+        };
+        if (log && this.logger)
+            this.logEvent({ message: "updateData result", mode: this.getName(), data: updated, bikeData: data });
+        this.data = updated;
+        this.prevUpdateTS = Date.now();
+        return updated;
+    }
+    sendBikeUpdate(request) {
+        if (request.slope !== undefined) {
+            this.data.slope = request.slope;
+        }
+        return {};
+    }
+    calculatePowerAndDistance(speed, slope, m, t, props = {}) {
+        const prevData = this.getData();
+        const vPrev = (prevData.speed || 0) / 3.6;
+        const EkinPrev = 1 / 2 * m * vPrev * vPrev;
+        const vTarget = (speed || 0) / 3.6;
+        const Ekin = 1 / 2 * m * vTarget * vTarget;
+        const powerDelta = t !== 0 ? (EkinPrev - Ekin) / t : 0;
+        const powerToMaintainSpeed = calculations_js_1.default.calculatePower(m, vPrev, slope, props);
+        const power = powerToMaintainSpeed - powerDelta;
+        const v = speed / 3.6;
+        const distance = v * t;
+        this.data.power = power;
+        return { power, distance };
+    }
+    calculateSpeedAndDistance(power, slope, m, t, props = {}) {
+        const prevData = this.getData();
+        const vPrev = (prevData.speed || 0) / 3.6;
+        const EkinPrev = 1 / 2 * m * vPrev * vPrev;
+        let powerToMaintainSpeed = calculations_js_1.default.calculatePower(m, vPrev, slope, props);
+        if (t >= 30) {
+            const speed = calculations_js_1.default.calculateSpeed(m, power, slope, props);
+            return { speed, distance: 0 };
+        }
+        const powerDelta = powerToMaintainSpeed - power;
+        const Ekin = EkinPrev - powerDelta * t;
+        if (Ekin > 0) {
+            const v = Math.sqrt(2 * Ekin / m);
+            const speed = v * 3.6;
+            const distance = v * t;
+            this.data.speed = speed;
+            return { speed, distance };
+        }
+        else {
+            const v = vPrev * 0.5;
+            const speed = v * 3.6;
+            const distance = v * t;
+            this.data.speed = speed;
+            return { speed, distance };
+        }
+    }
+}
+exports.default = SpeedCyclingMode;

package/lib/cjs/types/sensor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/base/consts.js

@@ -1,5 +1,6 @@
 export const DEFAULT_BIKE_WEIGHT = 10;
 export const DEFAULT_USER_WEIGHT = 75;
+export const DEFAULT_WHEEL_CIRCUMFERENCE = 2.118;
 export const DEFAULT_PROPS = {
     userWeight: DEFAULT_USER_WEIGHT,
     bikeWeight: DEFAULT_BIKE_WEIGHT

package/lib/esm/ble/base/adapter.js

@@ -354,17 +354,14 @@ export default class BleAdapter extends IncyclistDevice {
         sensor.off('data', this.onDeviceDataHandler);
         let connected = false;
         if (sensor.isReconnectBusy()) {
-            connected = await sensor.reconnectSensor(false);
-        }
-        if (connected) {
-            sensor.on('data', this.onDeviceDataHandler);
-            return true;
+            connected = await sensor.reconnectSensor(true);
+            if (connected) {
+                sensor.on('data', this.onDeviceDataHandler);
+            }
+            return connected;
         }
         await sensor.getPeripheral().disconnect();
         const success = await super.restart(pause);
-        if (success) {
-            sensor.on('data', this.onDeviceDataHandler);
-        }
         return success;
     }
     async stop() {

package/lib/esm/ble/base/interface.js

@@ -402,7 +402,12 @@ export class BleInterface extends EventEmitter {
         }
         const isWahoo = this.checkForWahooEnhancement(announcement);
         if (isWahoo) {
-            this.processWahooAnnouncement(announcement);
+            this.processEnrichedAnnouncement(announcement);
+            return;
+        }
+        const isTacx = this.checkForTacxEnhancement(announcement);
+        if (isTacx) {
+            this.processEnrichedAnnouncement(announcement);
             return;
         }
         this.addService(announcement);
@@ -416,7 +421,7 @@ export class BleInterface extends EventEmitter {
         }
         return false;
     }
-    processWahooAnnouncement(announcement) {
+    processEnrichedAnnouncement(announcement) {
         if (this.isCompleting(announcement)) {
             return;
         }
@@ -426,6 +431,19 @@ export class BleInterface extends EventEmitter {
                 this.addService(announcement);
         });
     }
+    checkForTacxEnhancement(announcement) {
+        const name = announcement?.name?.toUpperCase();
+        if (name.startsWith('TACX')) {
+            const supported = announcement.serviceUUIDs.map(s => beautifyUUID(s));
+            const tacxService = beautifyUUID('6E40FEC1-B5A3-F393-E0A9-E50E24DCCA9E');
+            const cp = beautifyUUID('1818');
+            const fe = beautifyUUID('1826');
+            if (supported.includes(cp) && !supported.includes(fe) && !supported.includes(tacxService)) {
+                return true;
+            }
+        }
+        return false;
+    }
     buildAnnouncement(peripheral) {
         return {
             advertisement: peripheral.advertisement,