incyclist-devices 3.0.20 → 3.0.22

package/lib/cjs/antv2/sc/adapter.js

@@ -5,10 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const adapter_js_1 = __importDefault(require("../base/adapter.js"));
 const index_js_1 = require("../../types/index.js");
+const speed_js_1 = __importDefault(require("../../modes/speed.js"));
 class AntSpdAdapter extends adapter_js_1.default {
     static INCYCLIST_PROFILE_NAME = 'Speed + Cadence Sensor';
     static ANT_PROFILE_NAME = 'SC';
     static CAPABILITIES = [index_js_1.IncyclistCapability.Speed, index_js_1.IncyclistCapability.Cadence];
+    static controllers = {
+        modes: [speed_js_1.default],
+        default: speed_js_1.default
+    };
     mapToAdapterData(deviceData) {
         if (deviceData.CalculatedSpeed !== undefined) {
             this.data.speed = deviceData.CalculatedSpeed * 3.6;
@@ -22,9 +27,45 @@ class AntSpdAdapter extends adapter_js_1.default {
             this.data.timestamp = Date.now();
         }
     }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: 0,
+            speed: 0
+        };
+        data.pedalRpm = (deviceData.CalculatedCadence !== undefined ? deviceData.CalculatedCadence : data.pedalRpm);
+        data.speed = (deviceData.CalculatedSpeed !== undefined ? deviceData.CalculatedSpeed * 3.6 : data.speed);
+        data.time = (deviceData.SpeedEventTime !== undefined ? deviceData.SpeedEventTime : data.time);
+        data.isPedalling = (data.pedalRpm ?? 0) > 0 || data.speed > 0;
+        return data;
+    }
+    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;
+    }
     hasData() {
         return ((this.deviceData.CalculatedSpeed !== undefined && this.deviceData.CalculatedSpeed !== null) ||
             (this.deviceData.CalculatedCadence !== undefined && this.deviceData.CalculatedCadence !== 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 { }
+    }
 }
 exports.default = AntSpdAdapter;

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

@@ -5,10 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const adapter_js_1 = __importDefault(require("../base/adapter.js"));
 const index_js_1 = require("../../types/index.js");
+const speed_js_1 = __importDefault(require("../../modes/speed.js"));
 class AntSpdAdapter extends adapter_js_1.default {
     static INCYCLIST_PROFILE_NAME = 'Speed Sensor';
     static ANT_PROFILE_NAME = 'SPD';
     static CAPABILITIES = [index_js_1.IncyclistCapability.Speed];
+    static controllers = {
+        modes: [speed_js_1.default],
+        default: speed_js_1.default
+    };
     mapToAdapterData(deviceData) {
         if (deviceData.CalculatedSpeed !== undefined) {
             this.data.speed = deviceData.CalculatedSpeed * 3.6;
@@ -18,8 +23,42 @@ class AntSpdAdapter extends adapter_js_1.default {
             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 { }
+    }
 }
 exports.default = AntSpdAdapter;

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

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

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_js_1 = require("./base.js");
+const types_js_1 = require("./types.js");
+const calculations_js_1 = __importDefault(require("../utils/calculations.js"));
+const consts_js_1 = require("../base/consts.js");
+class SpeedCyclingMode extends base_js_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_js_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+            { key: 'wc', name: 'Wheel Circumference', description: 'Circumference in mm', type: types_js_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/antv2/sc/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 + Cadence Sensor';
     static ANT_PROFILE_NAME = 'SC';
     static CAPABILITIES = [IncyclistCapability.Speed, IncyclistCapability.Cadence];
+    static controllers = {
+        modes: [SpeedCyclingMode],
+        default: SpeedCyclingMode
+    };
     mapToAdapterData(deviceData) {
         if (deviceData.CalculatedSpeed !== undefined) {
             this.data.speed = deviceData.CalculatedSpeed * 3.6;
@@ -17,8 +22,44 @@ export default class AntSpdAdapter extends AntAdapter {
             this.data.timestamp = Date.now();
         }
     }
+    mapData(deviceData) {
+        const data = {
+            isPedalling: false,
+            power: 0,
+            pedalRpm: 0,
+            speed: 0
+        };
+        data.pedalRpm = (deviceData.CalculatedCadence !== undefined ? deviceData.CalculatedCadence : data.pedalRpm);
+        data.speed = (deviceData.CalculatedSpeed !== undefined ? deviceData.CalculatedSpeed * 3.6 : data.speed);
+        data.time = (deviceData.SpeedEventTime !== undefined ? deviceData.SpeedEventTime : data.time);
+        data.isPedalling = (data.pedalRpm ?? 0) > 0 || data.speed > 0;
+        return data;
+    }
+    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;
+    }
     hasData() {
         return ((this.deviceData.CalculatedSpeed !== undefined && this.deviceData.CalculatedSpeed !== null) ||
             (this.deviceData.CalculatedCadence !== undefined && this.deviceData.CalculatedCadence !== 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 { }
+    }
 }