incyclist-devices 3.0.19 → 3.0.21

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

@@ -160,8 +160,9 @@ export 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) {
@@ -169,14 +170,14 @@ export class BlePeripheral {
                     .catch(() => []);
             }
             this.discoveredServiceUUIds = services.map(s => 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 => 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);
         }
     }
@@ -190,10 +191,12 @@ export 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[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 };
@@ -315,6 +318,15 @@ export class BlePeripheral {
                     if (!success)
                         retry.push(c);
                 }
+                else {
+                    const uuid = 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;
@@ -329,12 +341,17 @@ export 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[beautifyUUID(c.uuid)] = c;
                 found.push(c.uuid);
+                uuids.push(beautifyUUID(c.uuid));
             });
+            this.logEvent({ message: 'discover all characteristics result', name, address, uuids: uuids.join('|') });
             return found;
         }
         catch (err) {

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

@@ -9,6 +9,7 @@ export class TBleSensor extends EventEmitter {
     stopRequested = false;
     subscribeSuccess = false;
     reconnectPromise;
+    connectPromise;
     onDataHandler;
     logEvent(event, ...args) {
         try {
@@ -73,7 +74,8 @@ export class TBleSensor extends 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)
@@ -125,6 +127,9 @@ export class TBleSensor extends EventEmitter {
         let connected = false;
         let subscribed = false;
         let success = false;
+        if (connectionLost) {
+            this.emit('connctionLost');
+        }
         await sleep(500);
         do {
             try {
@@ -144,6 +149,9 @@ export class TBleSensor extends 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;
     }
@@ -153,6 +161,9 @@ export class TBleSensor extends EventEmitter {
     isConnected() {
         return this.peripheral?.isConnected();
     }
+    isReady() {
+        return this.isConnected() && this.connectPromise === undefined && this.reconnectPromise === undefined;
+    }
     isSubscribed() {
         return this.subscribeSuccess;
     }

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

@@ -1,3 +1,4 @@
+import { DEFAULT_WHEEL_CIRCUMFERENCE } from "../../../base/consts.js";
 export class CscMeasurement {
     data;
     prevCrankData = undefined;
@@ -5,13 +6,16 @@ export class CscMeasurement {
     prevWheelData = undefined;
     currentWheelData = undefined;
     timeOffset = 0;
-    cw = 2.1;
+    cw = 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;
@@ -86,7 +90,7 @@ export 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/esm/ble/csc/adapter.js

@@ -2,9 +2,14 @@ import { EventLogger } from 'gd-eventlog';
 import BleAdapter from '../base/adapter.js';
 import { IncyclistCapability } from '../../types/index.js';
 import { BleCyclingSpeedCadenceDevice } from './sensor.js';
+import SpeedCyclingMode from '../../modes/speed.js';
 export class BleCSCAdapter extends BleAdapter {
     static INCYCLIST_PROFILE_NAME = 'Speed + Cadence Sensor';
     static CAPABILITIES = [IncyclistCapability.Speed, IncyclistCapability.Cadence];
+    static controllers = {
+        modes: [SpeedCyclingMode],
+        default: SpeedCyclingMode
+    };
     constructor(settings, props) {
         super(settings, props);
         this.logger = new EventLogger('Ble-CSC');
@@ -42,7 +47,29 @@ export class BleCSCAdapter extends BleAdapter {
         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 { }
     }
 }

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

@@ -12,12 +12,12 @@ export class BleCyclingSpeedCadenceDevice extends TBleSensor {
     data;
     parsers = {};
     featureParser;
+    measurement = new CscMeasurement();
     constructor(peripheral, props) {
         super(peripheral, props);
         this.data = {};
-        const measurement = new CscMeasurement();
         this.featureParser = new CscFeatures();
-        this.parsers[beautifyUUID(CSC_MEASUREMENT)] = measurement;
+        this.parsers[beautifyUUID(CSC_MEASUREMENT)] = this.measurement;
     }
     getRequiredCharacteristics() {
         return [CSC_MEASUREMENT];
@@ -31,6 +31,7 @@ export class BleCyclingSpeedCadenceDevice extends TBleSensor {
         }
         catch (err) {
             this.logEvent({ message: 'read failed', characteristic: CSC_FEATURE, reason: err.message });
+            return {};
         }
     }
     onData(characteristic, characteristicData) {
@@ -51,4 +52,10 @@ export class BleCyclingSpeedCadenceDevice extends TBleSensor {
     reset() {
         this.data = {};
     }
+    async setWheelCircumference(wheelCircumference) {
+        this.measurement.setWheelCircumference(wheelCircumference);
+    }
+    getWheelCircumference() {
+        return this.measurement.getWheelCircumference();
+    }
 }

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

@@ -322,6 +322,9 @@ export default class BleFmAdapter extends BleAdapter {
                 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/esm/ble/wahoo/adapter.js

@@ -2,6 +2,7 @@ import { EventLogger } from 'gd-eventlog';
 import { BleFmAdapter } from '../fm/index.js';
 import BleWahooDevice from './sensor.js';
 import { IncyclistCapability } from '../../types/index.js';
+import calc from '../../utils/calculations.js';
 export default class BleWahooAdapter extends BleFmAdapter {
     static INCYCLIST_PROFILE_NAME = 'Smart Trainer';
     constructor(settings, props) {
@@ -24,6 +25,15 @@ export default class BleWahooAdapter extends BleFmAdapter {
     updateSensor(peripheral) {
         this.device = new BleWahooDevice(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 = calc.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/esm/ble/wahoo/sensor.js

@@ -18,6 +18,9 @@ export default class BleWahooDevice extends BleFitnessMachineDevice {
     isSimMode;
     isRequestControlBusy = false;
     weight = DEFAULT_BIKE_WEIGHT + DEFAULT_USER_WEIGHT;
+    prevWheelRevolutions = undefined;
+    prevWheelEventTime = undefined;
+    wheelCircumference = 2.096;
     simModeSettings;
     constructor(peripheral, props) {
         super(peripheral, props);
@@ -158,17 +161,40 @@ export default class BleWahooDevice extends BleFitnessMachineDevice {
     }
     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 = {
@@ -183,8 +209,8 @@ export default class BleWahooDevice extends BleFitnessMachineDevice {
         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 {
@@ -336,4 +362,10 @@ export default class BleWahooDevice extends BleFitnessMachineDevice {
             return false;
         }
     }
+    async setWheelCircumference(wheelCircumference) {
+        this.wheelCircumference = wheelCircumference;
+    }
+    getWheelCircumference() {
+        return this.wheelCircumference;
+    }
 }

package/lib/esm/modes/speed.js

@@ -0,0 +1,127 @@
+import { CyclingModeBase } from "./base";
+import { CyclingModeProperyType } from "./types";
+import calc from '../utils/calculations.js';
+import { DEFAULT_BIKE_WEIGHT, DEFAULT_USER_WEIGHT, DEFAULT_WHEEL_CIRCUMFERENCE } from "../base/consts.js";
+export default class SpeedCyclingMode extends 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: CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+            { key: 'wc', name: 'Wheel Circumference', description: 'Circumference in mm', type: CyclingModeProperyType.Integer, default: Math.ceil(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 = DEFAULT_BIKE_WEIGHT + 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 = calc.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 = calc.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 = calc.calculatePower(m, vPrev, slope, props);
+        if (t >= 30) {
+            const speed = calc.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 };
+        }
+    }
+}

package/lib/esm/types/sensor.js

@@ -0,0 +1 @@
+export {};

package/lib/types/base/consts.d.ts

@@ -1,4 +1,5 @@
 import { DeviceProperties } from "../types/index.js";
 export declare const DEFAULT_BIKE_WEIGHT = 10;
 export declare const DEFAULT_USER_WEIGHT = 75;
+export declare const DEFAULT_WHEEL_CIRCUMFERENCE = 2.118;
 export declare const DEFAULT_PROPS: DeviceProperties;

package/lib/types/ble/base/interface.d.ts

@@ -79,7 +79,8 @@ export declare class BleInterface extends EventEmitter implements IBleInterface<
     protected discoverPeripherals(): Promise<void>;
     protected onPeripheralFound(peripheral: BleRawPeripheral): void;
     protected checkForWahooEnhancement(announcement: BlePeripheralAnnouncement): boolean;
-    protected processWahooAnnouncement(announcement: BlePeripheralAnnouncement): void;
+    protected processEnrichedAnnouncement(announcement: BlePeripheralAnnouncement): void;
+    protected checkForTacxEnhancement(announcement: BlePeripheralAnnouncement): boolean;
     protected buildAnnouncement(peripheral: BleRawPeripheral): BlePeripheralAnnouncement;
     protected updateWithServices(announcement: BlePeripheralAnnouncement): Promise<BlePeripheralAnnouncement>;
     protected discoverServices(announcement: BlePeripheralAnnouncement): Promise<string[]>;

package/lib/types/ble/base/sensor.d.ts

@@ -9,6 +9,7 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     protected stopRequested: boolean;
     protected subscribeSuccess: boolean;
     protected reconnectPromise: Promise<boolean> | undefined;
+    protected connectPromise: Promise<boolean> | undefined;
     protected onDataHandler: any;
     logEvent(event: any, ...args: any): void;
     constructor(peripheral: IBlePeripheral, props?: {
@@ -32,6 +33,7 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     doReconnectSensor(connectionLost?: boolean): Promise<boolean>;
     reset(): void;
     isConnected(): boolean;
+    isReady(): boolean;
     isSubscribed(): boolean;
     protected onDisconnect(): void;
     read(characteristicUUID: string): Promise<Buffer>;

package/lib/types/ble/characteristics/csc/measurement.d.ts

@@ -14,6 +14,7 @@ export declare class CscMeasurement implements CharacteristicParser<CyclingCaden
     protected cw: number;
     constructor(data?: CyclingCadenceAndSpeed);
     setWheelCircumference(wheelCircumference: any): void;
+    getWheelCircumference(): number;
     parse(buffer: Buffer, features?: Feature): CyclingCadenceAndSpeed;
     protected parseCrankData(crankData: any): {
         rpm?: undefined;

package/lib/types/ble/csc/adapter.d.ts

@@ -1,12 +1,14 @@
 import BleAdapter from '../base/adapter.js';
 import { BleDeviceSettings, IBlePeripheral } from '../types.js';
-import { DeviceProperties, IncyclistCapability, IAdapter, IncyclistAdapterData } from '../../types/index.js';
+import { DeviceProperties, IncyclistCapability, IAdapter, IncyclistAdapterData, ControllerConfig, IncyclistBikeData } from '../../types/index.js';
 import { LegacyProfile } from '../../antv2/types.js';
 import { BleCyclingSpeedCadenceDevice } from './sensor.js';
 import { CSCData } from './types.js';
+import ICyclingMode from '../../modes/types.js';
 export declare class BleCSCAdapter extends BleAdapter<CSCData, BleCyclingSpeedCadenceDevice> {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     protected static CAPABILITIES: IncyclistCapability[];
+    protected static controllers: ControllerConfig;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     protected checkCapabilities(): Promise<void>;
     isSame(device: IAdapter): boolean;
@@ -14,4 +16,6 @@ export declare class BleCSCAdapter extends BleAdapter<CSCData, BleCyclingSpeedCa
     getProfile(): LegacyProfile;
     getDisplayName(): string;
     mapData(deviceData: CSCData): IncyclistAdapterData;
+    transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
 }

package/lib/types/ble/csc/sensor.d.ts

@@ -2,9 +2,10 @@ import { LegacyProfile } from '../../antv2/types.js';
 import { BleProtocol } from '../types.js';
 import { TBleSensor } from '../base/sensor.js';
 import { CharacteristicParser } from '../characteristics/types.js';
-import { CyclingCadenceAndSpeed } from '../characteristics/csc/measurement.js';
+import { CscMeasurement, CyclingCadenceAndSpeed } from '../characteristics/csc/measurement.js';
 import { BleCSCFeatures, CscFeatures } from '../characteristics/csc/features.js';
-export declare class BleCyclingSpeedCadenceDevice extends TBleSensor {
+import { ISpeedSensor } from '../../types/sensor.js';
+export declare class BleCyclingSpeedCadenceDevice extends TBleSensor implements ISpeedSensor {
     static readonly profile: LegacyProfile;
     static readonly protocol: BleProtocol;
     static readonly services: string[];
@@ -13,9 +14,12 @@ export declare class BleCyclingSpeedCadenceDevice extends TBleSensor {
     protected data: CyclingCadenceAndSpeed;
     protected parsers: Record<string, CharacteristicParser<any>>;
     protected featureParser: CscFeatures;
+    protected measurement: CscMeasurement;
     constructor(peripheral: any, props?: any);
     protected getRequiredCharacteristics(): Array<string>;
     getFeatures(): Promise<BleCSCFeatures>;
     onData(characteristic: string, characteristicData: Buffer): boolean;
     reset(): void;
+    setWheelCircumference(wheelCircumference: number): Promise<void>;
+    getWheelCircumference(): number;
 }

package/lib/types/ble/types.d.ts

@@ -175,6 +175,7 @@ export interface IBleSensor extends EventEmitter {
     stopSensor(): Promise<boolean>;
     reset(): void;
     isConnected(): boolean;
+    isReady(): boolean;
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
 }

package/lib/types/ble/wahoo/adapter.d.ts

@@ -1,12 +1,14 @@
 import { BleFmAdapter } from '../fm/index.js';
 import { BleDeviceProperties, BleDeviceSettings, IBlePeripheral } from '../types.js';
-import { IAdapter } from '../../types/index.js';
+import { IAdapter, IncyclistBikeData } from '../../types/index.js';
 import { LegacyProfile } from '../../antv2/types.js';
+import { IndoorBikeData } from './types.js';
 export default class BleWahooAdapter extends BleFmAdapter {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
     isSame(device: IAdapter): boolean;
     getProfile(): LegacyProfile;
     updateSensor(peripheral: IBlePeripheral): void;
+    mapData(deviceData: IndoorBikeData): IncyclistBikeData;
     protected checkCapabilities(): Promise<void>;
 }

package/lib/types/ble/wahoo/sensor.d.ts

@@ -18,6 +18,9 @@ export default class BleWahooDevice extends BleFitnessMachineDevice {
     isSimMode: boolean;
     isRequestControlBusy: boolean;
     weight: number;
+    prevWheelRevolutions: number | undefined;
+    prevWheelEventTime: number | undefined;
+    wheelCircumference: number;
     simModeSettings: {
         weight: number;
         crr: number;
@@ -46,4 +49,6 @@ export default class BleWahooDevice extends BleFitnessMachineDevice {
     setSimWindResistance(cw: number): Promise<boolean>;
     setSimGrade(slope: number): Promise<boolean>;
     setSimWindSpeed(v: number): Promise<boolean>;
+    setWheelCircumference(wheelCircumference: number): Promise<void>;
+    getWheelCircumference(): number;
 }

package/lib/types/modes/speed.d.ts

@@ -0,0 +1,43 @@
+import { IAdapter, IncyclistBikeData } from "../types";
+import { CyclingModeBase } from "./base";
+import ICyclingMode, { CyclingModeProperyType, Settings, UpdateRequest } from "./types";
+export default class SpeedCyclingMode extends CyclingModeBase implements ICyclingMode {
+    data: IncyclistBikeData;
+    prevUpdateTS: number;
+    prevRequest: UpdateRequest | undefined;
+    protected static config: {
+        name: string;
+        description: string;
+        properties: ({
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: number;
+            options?: undefined;
+        })[];
+    };
+    constructor(adapter: IAdapter, props?: Settings);
+    getData(): Partial<IncyclistBikeData>;
+    getSlope(): number;
+    getWeight(): number;
+    getTimeSinceLastUpdate(): number;
+    getBikeInitRequest(): UpdateRequest;
+    updateData(data: IncyclistBikeData, log?: boolean): IncyclistBikeData;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    protected calculatePowerAndDistance(speed: number, slope: number, m: number, t: number, props?: {}): {
+        power: number;
+        distance: number;
+    };
+    protected calculateSpeedAndDistance(power: number, slope: number, m: number, t: number, props?: {}): {
+        speed: number;
+        distance: number;
+    };
+}

package/lib/types/types/index.d.ts

@@ -5,3 +5,4 @@ export * from './device.js';
 export type * from './interface.js';
 export * from './user.js';
 export type * from './sport.js';
+export type * from './sensor.js';