incyclist-devices 3.0.20 → 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/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/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/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';

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

@@ -0,0 +1,4 @@
+export interface ISpeedSensor {
+    setWheelCircumference(wheelCircumference: number): Promise<void>;
+    getWheelCircumference(): number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "incyclist-devices",
-    "version": "3.0.20",
+    "version": "3.0.21",
     "scripts": {
         "lint": "eslint . --ext .ts",
         "build": "npm run build:esm && npm run build:cjs",