incyclist-devices 3.0.20 → 3.0.22

package/lib/esm/antv2/spd/adapter.js

@@ -1,9 +1,14 @@
 import AntAdapter from "../base/adapter.js";
 import { IncyclistCapability } from "../../types/index.js";
+import SpeedCyclingMode from "../../modes/speed.js";
 export default class AntSpdAdapter extends AntAdapter {
     static INCYCLIST_PROFILE_NAME = 'Speed Sensor';
     static ANT_PROFILE_NAME = 'SPD';
     static CAPABILITIES = [IncyclistCapability.Speed];
+    static controllers = {
+        modes: [SpeedCyclingMode],
+        default: SpeedCyclingMode
+    };
     mapToAdapterData(deviceData) {
         if (deviceData.CalculatedSpeed !== undefined) {
             this.data.speed = deviceData.CalculatedSpeed * 3.6;
@@ -13,7 +18,41 @@ export default class AntSpdAdapter extends AntAdapter {
             this.data.deviceDistanceCounter = deviceData.CalculatedDistance;
         }
     }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: 0,
+            speed: 0
+        };
+        data.speed = (deviceData.CalculatedSpeed !== undefined ? deviceData.CalculatedSpeed * 3.6 : data.speed);
+        data.time = (deviceData.SpeedEventTime !== undefined ? deviceData.SpeedEventTime : data.time);
+        data.isPedalling = data.speed > 0;
+        return data;
+    }
+    transformData(bikeData) {
+        if (bikeData === undefined)
+            return {};
+        let data = {
+            speed: bikeData.speed,
+            power: bikeData.power,
+            timestamp: Date.now()
+        };
+        if (bikeData.time)
+            data.deviceTime = bikeData.time;
+        this.data = data;
+        return data;
+    }
     hasData() {
         return this.deviceData.CalculatedSpeed !== undefined && this.deviceData.CalculatedSpeed !== null;
     }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        super.setCyclingMode(mode, settings, sendInitCommands);
+        try {
+            const sensor = this.sensor;
+            const wc = this.getCyclingMode().getSetting('wc');
+            sensor.setWheelCircumference(wc / 1000);
+        }
+        catch { }
+    }
 }

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/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/utils.js

@@ -41,6 +41,8 @@ export function getCharachteristicsInfo(c) {
     return `${serviceStr}${uuid}${nameStr} ${properties}`;
 }
 export const parseUUID = (str) => {
+    if (!str)
+        return str;
     const uuid = str.toUpperCase();
     if (str.startsWith('0x')) {
         const hex = uuid.slice(2);
@@ -95,6 +97,8 @@ export const beautifyUUID = (str, withX = false) => {
     return parts.join('-');
 };
 export const fullUUID = (str) => {
+    if (!str)
+        return str;
     const uuid = parseUUID(str);
     const parts = [
         uuid.substring(0, 8),

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.js";
+import { CyclingModeProperyType } from "./types.js";
+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/types/antv2/sc/adapter.d.ts

@@ -1,11 +1,16 @@
 import { SpeedCadenceSensorState, Profile } from "incyclist-ant-plus";
 import AntAdapter from "../base/adapter.js";
 import { LegacyProfile } from "../types.js";
-import { IncyclistCapability } from "../../types/index.js";
+import { ControllerConfig, IncyclistAdapterData, IncyclistBikeData, IncyclistCapability } from "../../types/index.js";
+import ICyclingMode from "../../modes/types.js";
 export default class AntSpdAdapter extends AntAdapter<SpeedCadenceSensorState> {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     protected static ANT_PROFILE_NAME: Profile;
     protected static CAPABILITIES: IncyclistCapability[];
+    protected static controllers: ControllerConfig;
     mapToAdapterData(deviceData: SpeedCadenceSensorState): void;
+    mapData(deviceData: SpeedCadenceSensorState): IncyclistBikeData;
+    transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
     hasData(): boolean;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
 }

package/lib/types/antv2/spd/adapter.d.ts

@@ -1,11 +1,16 @@
 import { SpeedSensorState, Profile } from "incyclist-ant-plus";
 import AntAdapter from "../base/adapter.js";
 import { LegacyProfile } from "../types.js";
-import { IncyclistCapability } from "../../types/index.js";
+import { ControllerConfig, IncyclistAdapterData, IncyclistBikeData, IncyclistCapability } from "../../types/index.js";
+import ICyclingMode from "../../modes/types.js";
 export default class AntSpdAdapter extends AntAdapter<SpeedSensorState> {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     protected static ANT_PROFILE_NAME: Profile;
     protected static CAPABILITIES: IncyclistCapability[];
+    protected static controllers: ControllerConfig;
     mapToAdapterData(deviceData: SpeedSensorState): void;
+    mapData(deviceData: SpeedSensorState): IncyclistBikeData;
+    transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
     hasData(): boolean;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
 }

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/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>;
 }