incyclist-devices 2.3.34 → 2.3.35

package/lib/ble/zwift/play/sensor.js

@@ -10,13 +10,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BleZwiftPlaySensor = void 0;
+const zwift_hub_1 = require("../../../proto/zwift_hub");
 const sensor_1 = require("../../base/sensor");
 const utils_1 = require("../../utils");
 const crypto_1 = require("crypto");
 const events_1 = require("events");
 class BleZwiftPlaySensor extends sensor_1.TBleSensor {
     constructor(peripheral, props) {
-        super(peripheral, props);
+        if (peripheral &&
+            'startSensor' in peripheral && typeof peripheral.startSensor === 'function' &&
+            'getPeripheral' in peripheral && typeof peripheral.getPeripheral === 'function') {
+            super(peripheral.getPeripheral(), props);
+            this.isFM = true;
+        }
+        else {
+            super(peripheral, props);
+            this.isFM = false;
+        }
         this.emitter = new events_1.EventEmitter();
         this.setInitialState();
     }
@@ -42,18 +52,66 @@ class BleZwiftPlaySensor extends sensor_1.TBleSensor {
     }
     onData(characteristic, data, isNotify) {
         const uuid = (0, utils_1.beautifyUUID)(characteristic).toLowerCase();
+        console.log('# data', uuid, data === null || data === void 0 ? void 0 : data.toString('hex'));
         if (uuid === '00000002-19ca-4651-86e5-fa29dcdd09d1') {
-            this.onPlayMeasurement(data);
+            this.onMeasurement(data);
         }
         else if (uuid === '00000004-19ca-4651-86e5-fa29dcdd09d1') {
-            this.onPairResponse(data);
+            this.onResponse(data);
         }
         else {
-            console.log('data received ', isNotify ? 'N' : 'I', uuid, data.toString('hex'));
         }
         return true;
     }
-    onPlayMeasurement(d) {
+    requestDataUpdate(dataId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sendHubRequest({ dataId });
+        });
+    }
+    setSimulationData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (!this.isHubServiceActive) {
+                yield this.initHubService(false);
+            }
+            const crrx100000 = Math.round((_a = data === null || data === void 0 ? void 0 : data.crrx100000) !== null && _a !== void 0 ? _a : 5100);
+            const cWax10000 = Math.round((_b = data === null || data === void 0 ? void 0 : data.cWax10000) !== null && _b !== void 0 ? _b : 400);
+            const windx100 = Math.round((_c = data === null || data === void 0 ? void 0 : data.windx100) !== null && _c !== void 0 ? _c : 0);
+            const inclineX100 = Math.round((_d = data === null || data === void 0 ? void 0 : data.inclineX100) !== null && _d !== void 0 ? _d : 0);
+            const simulation = { inclineX100, crrx100000, cWax10000, windx100 };
+            yield this.sendHubCommand({ simulation });
+            yield this.requestDataUpdate(512);
+        });
+    }
+    setGearRatio(gearRatio) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.log('# set gear ratio', gearRatio);
+                if (!this.isHubServiceActive) {
+                    yield this.initHubService();
+                }
+                const gearRatioX10000 = Math.round(gearRatio * 10000);
+                const bikeWeightx100 = 10 * 100;
+                const riderWeightx100 = 75 * 100;
+                const command = {
+                    physical: { bikeWeightx100, gearRatioX10000, riderWeightx100 }
+                };
+                yield this.sendHubCommand(command);
+                yield this.requestDataUpdate(512);
+            }
+            catch (err) {
+                console.log('# set gear ratio failed', err);
+            }
+            return gearRatio;
+        });
+    }
+    sendPlayCommand(id, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = Buffer.concat([Buffer.from([id]), command]);
+            return yield this.write('00000003-19ca-4651-86e5-fa29dcdd09d1', data, { withoutResponse: true });
+        });
+    }
+    onMeasurement(d) {
         const data = Buffer.from(d);
         if ((data === null || data === void 0 ? void 0 : data.length) < 1) {
             console.log('Invalid click measurement data', data.toString('hex'));
@@ -62,84 +120,183 @@ class BleZwiftPlaySensor extends sensor_1.TBleSensor {
         const type = data.readUInt8(0);
         const message = data.subarray(1);
         if (type === 0x37) {
-            this.onButtonMessage(message);
+            this.onClickButtonMessage(message);
         }
         else if (type === 0x19) {
             this.onPingMessage(message);
         }
+        else if (type === 0x42) {
+            console.log('# init confirmed');
+        }
+        else if (type === 0x03) {
+            this.onRidingData(message);
+        }
+        else if (type === 0x3c) {
+            this.onDeviceInformation(message);
+        }
         else {
             console.log('Unknown click measurement type', type, message.toString('hex'));
             this.emit('data', { raw: data.toString('hex') });
         }
         return true;
     }
-    onButtonMessage(d) {
-        var _a, _b;
-        const message = Buffer.from(d);
+    initHubService() {
+        return __awaiter(this, arguments, void 0, function* (setSimulation = true) {
+            console.log('# init Hub Service');
+            if (this.isHubServiceActive)
+                return true;
+            if (!this.isPaired) {
+                yield this.pair();
+            }
+            if (!this.isSubscribed) {
+                yield this.subscribe();
+                this.isSubscribed = true;
+            }
+            return new Promise((done) => {
+                let timeout = setTimeout(() => {
+                    done(false);
+                }, 2000);
+                this.once('hub-riding-data', () => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                        timeout = undefined;
+                    }
+                    this.isHubServiceActive = true;
+                    console.log('# init hub service completed');
+                    if (setSimulation) {
+                        this.setSimulationData().then(() => {
+                            done(true);
+                        })
+                            .catch(() => {
+                            done(true);
+                        });
+                    }
+                    else {
+                        done(true);
+                    }
+                });
+                this.sendPlayCommand(0x41, Buffer.from([0x08, 0x05]))
+                    .catch(err => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                        timeout = undefined;
+                    }
+                    console.log('# init hub service timeout');
+                    done(false);
+                    this.logEvent({ message: 'could not init hub service', reason: err.message });
+                });
+            });
+        });
+    }
+    sendHubRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = Buffer.from(zwift_hub_1.HubRequest.toBinary(request));
+            console.log('# sending hub request', request, message);
+            this.logEvent({ mesage: 'send zwift hub request', request });
+            return yield this.sendPlayCommand(0x00, message);
+        });
+    }
+    sendHubCommand(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const message = Buffer.from(zwift_hub_1.HubCommand.toBinary(command));
+            console.log('# sending hub command', command, message);
+            this.logEvent({ mesage: 'send zwift hub command', command });
+            return yield this.sendPlayCommand(0x04, message);
+        });
+    }
+    onRidingData(m) {
         try {
-            if (message.readUInt8(0) === 0x8 && message.length === 4) {
-                const value = Buffer.from(message.subarray(1));
-                const messageStr = value.toString('hex');
-                if (messageStr === this.prevClickMessage) {
-                    return;
+            this.tsLastRidingData = Date.now();
+            const data = zwift_hub_1.HubRidingData.fromBinary(m);
+            this.emit('hub-riding-data', data);
+            console.log('#riding data', data);
+            this.logEvent({ message: 'riding data received', power: data.power, cadence: data.cadence, Speed: data.speedX100 / 100, heartrate: data.hR, unknown1: data.unknown1, unknown2: data.unknown2 });
+        }
+        catch (err) {
+            this.logEvent({ message: 'Error', fn: 'onRidingData', error: err.message, stack: err.stack });
+        }
+    }
+    onDeviceInformation(m) {
+        try {
+            const envelope = zwift_hub_1.DeviceDataEnvelope.fromBinary(m);
+            const { messageType, payload } = envelope;
+            if (messageType < 16) {
+                const deviceInfo = zwift_hub_1.DeviceInformationContent.fromBinary(payload);
+                console.log('# deviceInfo', deviceInfo);
+                this.emit('hub-device-info', deviceInfo);
+                this.logEvent({ message: 'hub device info update', deviceInfo });
+            }
+            else if (messageType >= 512 && messageType < 526) {
+                const si = zwift_hub_1.DeviceSettings.fromBinary(payload);
+                console.log('# settings', si === null || si === void 0 ? void 0 : si.subContent);
+                this.emit('hub-settings', si === null || si === void 0 ? void 0 : si.subContent);
+                this.logEvent({ message: 'hub settings update', settings: si === null || si === void 0 ? void 0 : si.subContent });
+            }
+        }
+        catch (err) {
+            let payload = 'unknown';
+            try {
+                payload = m.toString('hex');
+            }
+            catch (_a) { }
+            this.logEvent({ message: 'Error', fn: 'onRidingData', error: err.message, stack: err.stack, payload });
+        }
+    }
+    onClickButtonMessage(d) {
+        try {
+            const message = Buffer.from(d);
+            const messageStr = message.toString('hex');
+            if (messageStr === this.prevClickMessage) {
+                return;
+            }
+            const status = zwift_hub_1.ClickKeyPadStatus.fromBinary(message);
+            if (status.buttonPlus === zwift_hub_1.PlayButtonStatus.OFF) {
+                const prev = Object.assign({}, this.upState);
+                this.upState = { pressed: false, timestamp: Date.now() };
+                if (prev.pressed) {
+                    this.emit('key-pressed', { key: 'up', duration: this.upState.timestamp - prev.timestamp, deviceType: this.deviceType });
                 }
-                switch (messageStr) {
-                    case '001001':
-                        this.upState = { pressed: true, timestamp: Date.now() };
-                        break;
-                    case '011001':
-                        if ((_a = this.upState) === null || _a === void 0 ? void 0 : _a.pressed) {
-                            const prev = Object.assign({}, this.upState);
-                            this.upState = { pressed: false, timestamp: Date.now() };
-                            this.emit('key-pressed', { key: 'up', duration: this.upState.timestamp - prev.timestamp, deviceType: this.deviceType });
-                        }
-                        else if ((_b = this.downState) === null || _b === void 0 ? void 0 : _b.pressed) {
-                            const prev = Object.assign({}, this.downState);
-                            this.downState = { pressed: false, timestamp: Date.now() };
-                            this.emit('key-pressed', { key: 'down', duration: this.downState.timestamp - prev.timestamp, deviceType: this.deviceType });
-                        }
-                        else {
-                            this.upState = { pressed: false, timestamp: Date.now() };
-                            this.downState = { pressed: false, timestamp: Date.now() };
-                        }
-                        break;
-                    case '011000':
-                        this.downState = { pressed: true, timestamp: Date.now() };
-                        break;
+            }
+            else {
+                this.upState = { pressed: true, timestamp: Date.now() };
+            }
+            if (status.buttonMinus === zwift_hub_1.PlayButtonStatus.OFF) {
+                const prev = Object.assign({}, this.downState);
+                this.downState = { pressed: false, timestamp: Date.now() };
+                if (prev.pressed) {
+                    this.emit('key-pressed', { key: 'down', duration: this.downState.timestamp - prev.timestamp, deviceType: this.deviceType });
                 }
-                this.prevClickMessage = messageStr;
             }
             else {
-                this.logEvent({ message: 'Click measurement received', raw: message.toString('hex') });
+                this.downState = { pressed: true, timestamp: Date.now() };
             }
+            this.prevClickMessage = messageStr;
         }
         catch (err) {
             this.logEvent({ message: 'error', fn: 'onButtonMessage', error: err.message, stack: err.stack });
         }
     }
-    onPingMessage(d) {
+    onPingMessage(message) {
+        const idle = zwift_hub_1.Idle.fromBinary(message);
+        console.log('# ping message', idle);
         this.emit('data', { deviceType: this.deviceType, paired: this.paired, alive: true, ts: Date.now() });
     }
-    onPairResponse(d) {
+    onResponse(d) {
         const data = Buffer.from(d);
-        const len = data.length;
-        if (len === 6 && data.toString() === 'RideOn') {
-            this.encrypted = false;
-            this.paired = true;
-            this.emitter.emit('paired');
-            try {
-                this.emit('data', { deviceType: this.deviceType, paired: true, ts: Date.now() });
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'onPairResponse', error: err.message, stack: err.stack });
-            }
+        if ((data === null || data === void 0 ? void 0 : data.length) < 1) {
+            console.log('Invalid response data', data.toString('hex'));
+            return false;
+        }
+        const type = data.readUInt8(0);
+        const message = data.subarray(1);
+        if (type === 0x3c) {
+            this.onDeviceInformation(message);
         }
-        else if (len > 8 && Buffer.from(data.subarray(0, 6)).toString() === 'RideOn') {
-            const message = Buffer.from(data.subarray(6, 2)).toString('hex');
-            if (message === '0900') {
-                this.encrypted = true;
+        else {
+            const len = data.length;
+            if (len === 6 && data.toString() === 'RideOn') {
+                this.encrypted = false;
                 this.paired = true;
-                this.deviceKey = data.subarray(8);
                 this.emitter.emit('paired');
                 try {
                     this.emit('data', { deviceType: this.deviceType, paired: true, ts: Date.now() });
@@ -148,11 +305,26 @@ class BleZwiftPlaySensor extends sensor_1.TBleSensor {
                     this.logEvent({ message: 'error', fn: 'onPairResponse', error: err.message, stack: err.stack });
                 }
             }
-            else {
-                this.logEvent({ message: 'Pairing failed! ', reason: 'unknown message', raw: message });
+            else if (len > 8 && Buffer.from(data.subarray(0, 6)).toString() === 'RideOn') {
+                const message = Buffer.from(data.subarray(6, 2)).toString('hex');
+                if (message === '0900') {
+                    this.encrypted = true;
+                    this.paired = true;
+                    this.deviceKey = data.subarray(8);
+                    this.emitter.emit('paired');
+                    try {
+                        this.emit('data', { deviceType: this.deviceType, paired: true, ts: Date.now() });
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'onPairResponse', error: err.message, stack: err.stack });
+                    }
+                }
+                else {
+                    this.logEvent({ message: 'Pairing failed! ', reason: 'unknown message', raw: message });
+                }
             }
+            return true;
         }
-        return true;
     }
     read(characteristic_1) {
         const _super = Object.create(null, {
@@ -172,6 +344,8 @@ class BleZwiftPlaySensor extends sensor_1.TBleSensor {
     pair() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
+            if (this.isPaired)
+                return true;
             let manufacturerData;
             try {
                 if (this.peripheral.getManufacturerData) {
@@ -197,7 +371,7 @@ class BleZwiftPlaySensor extends sensor_1.TBleSensor {
                 this.logEvent({ message: 'Play protocol pairing info', deviceType: this.deviceType, encrypted: this.encrypted, manufacturerData });
                 let message;
                 if (!this.encrypted) {
-                    message = Buffer.from('RideOn');
+                    message = this.isFM ? Buffer.concat([Buffer.from('RideOn'), Buffer.from([0x02, 0x01])]) : Buffer.from('RideOn');
                 }
                 else {
                     const { publicKey, privateKey } = this.createKeyPair();
@@ -206,10 +380,12 @@ class BleZwiftPlaySensor extends sensor_1.TBleSensor {
                     message = Buffer.concat([Buffer.from('RideOn'), Buffer.from([0x01, 0x02]), this.publicKey]);
                 }
                 yield this.write((0, utils_1.fullUUID)('00000003-19ca-4651-86e5-fa29dcdd09d1'), message, { withoutResponse: true });
+                this.isPaired = true;
                 return true;
             }
             catch (err) {
                 this.logEvent({ message: 'error', fn: 'pair', error: err.message, stack: err.stack });
+                this.isPaired = false;
                 return false;
             }
         });

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

@@ -0,0 +1,6 @@
+export type HubRequest = {
+    DataId: number;
+};
+export type IHubHelper = {
+    createHubRequest(request: HubRequest): any;
+};

package/lib/ble/zwift/play/types.js

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

package/lib/direct-connect/base/peripheral.d.ts

@@ -18,9 +18,12 @@ export declare class DirectConnectPeripheral implements IBlePeripheral {
     protected eventEmitter: EventEmitter<[never]>;
     protected subscribed: Array<string>;
     protected onDisconnectHandler: () => void;
+    protected discoveredServiceUUIds: Array<string>;
     constructor(announcement: MulticastDnsAnnouncement);
     getInfo(): BleDeviceIdentifier;
     get services(): BleService[];
+    getAnnouncedServices(): string[];
+    getDiscoveredServices(): string[];
     connect(): Promise<boolean>;
     disconnect(connectionLost?: boolean): Promise<boolean>;
     isConnected(): boolean;

package/lib/direct-connect/base/peripheral.js

@@ -51,6 +51,13 @@ class DirectConnectPeripheral {
         const services = (_b = (_a = this.announcement) === null || _a === void 0 ? void 0 : _a.serviceUUIDs) !== null && _b !== void 0 ? _b : [];
         return services.map(s => ({ uuid: s }));
     }
+    getAnnouncedServices() {
+        var _a;
+        return (_a = this.announcement) === null || _a === void 0 ? void 0 : _a.serviceUUIDs.map(s => (0, utils_1.beautifyUUID)(s));
+    }
+    getDiscoveredServices() {
+        return this.discoveredServiceUUIds;
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isConnected())
@@ -104,6 +111,7 @@ class DirectConnectPeripheral {
                     return [];
                 }
                 this.logEvent({ message: 'DiscoverServices response', path: this.getPath(), rc, uuids, raw: response.toString('hex') });
+                this.discoveredServiceUUIds = res.body.serviceDefinitions.map(s => (0, utils_1.beautifyUUID)(s.serviceUUID));
                 return res.body.serviceDefinitions.map(s => s.serviceUUID);
             }
             catch (err) {

package/lib/modes/antble-smarttrainer.d.ts

@@ -50,7 +50,6 @@ export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase i
     updateData(bikeData: IncyclistBikeData, log?: boolean): IncyclistBikeData;
     getData(): Partial<IncyclistBikeData>;
     sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
-    protected setInitialGear(data: IncyclistBikeData): void;
     protected getGearString(): string;
 }
 export {};

package/lib/modes/antble-smarttrainer.js

@@ -51,6 +51,12 @@ class SmartTrainerCyclingMode extends power_base_1.default {
         this.initLogger('SmartTrainerMode');
     }
     getBikeInitRequest() {
+        const virtshiftMode = this.getVirtualShiftMode();
+        if (virtshiftMode === 'Adapter') {
+            this.gear = this.getSetting('startGear');
+            const gearRatio = this.gearRatios[this.gear - 1];
+            return { slope: 0, gearRatio };
+        }
         this.prevRequest = { slope: 0 };
         return { slope: 0 };
     }
@@ -66,13 +72,19 @@ class SmartTrainerCyclingMode extends power_base_1.default {
     getConfig() {
         const config = super.getConfig();
         let virtshift = config.properties.find(p => p.key === 'virtshift');
+        let startGear = config.properties.find(p => p.key === 'startGear');
         if (!virtshift) {
-            virtshift = { key: 'virtshift', name: 'Virtual Shifting', description: 'Enable virtual shifting', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Disabled', 'Enabled', 'Mixed'], default: 'Disabled' };
+            virtshift = { key: 'virtshift', name: 'Virtual Shifting', description: 'Enable virtual shifting', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Disabled', 'Incyclist', 'Mixed'], default: 'Disabled' };
             config.properties.push(virtshift);
         }
         if (this.adapter.supportsVirtualShifting()) {
             virtshift.default = 'Enabled';
-            virtshift.options = ['Disabled', 'Enabled'];
+            virtshift.options = ['Disabled', 'Incyclist', 'SmartTrainer', 'Mixed'];
+            virtshift.default = 'SmartTrainer';
+        }
+        if (!startGear) {
+            startGear = { key: 'startGear', name: 'Initial Gear', description: 'Initial Gear', type: types_1.CyclingModeProperyType.Integer, default: 10, min: 1, max: 24, condition: (s) => (s === null || s === void 0 ? void 0 : s.virtshift) === 'Incyclist' || (s === null || s === void 0 ? void 0 : s.virtshift) === 'SmartTrainer' };
+            config.properties.push(startGear);
         }
         return config;
     }
@@ -170,7 +182,8 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             case 'Simulated':
                 if (request.gearDelta !== undefined) {
                     if (this.gear === undefined) {
-                        this.gear = 10 + request.gearDelta;
+                        const initialGear = this.getSetting('startGear');
+                        this.gear = initialGear + request.gearDelta;
                     }
                     else {
                         this.gear += request.gearDelta;
@@ -192,6 +205,47 @@ class SmartTrainerCyclingMode extends power_base_1.default {
                 }
                 break;
             case 'Adapter':
+                if (request.gearRatio !== undefined) {
+                    newRequest.gearRatio = request.gearRatio;
+                    if (this.gear === undefined) {
+                        const requestedRatio = request.gearRatio;
+                        let closestIndex = 0;
+                        let minDiff = Math.abs(this.gearRatios[0] - requestedRatio);
+                        for (let i = 1; i < this.gearRatios.length; i++) {
+                            const diff = Math.abs(this.gearRatios[i] - requestedRatio);
+                            if (diff < minDiff) {
+                                minDiff = diff;
+                                closestIndex = i;
+                            }
+                        }
+                        this.gear = closestIndex + 1;
+                    }
+                }
+                else if (request.gearDelta !== undefined) {
+                    if (this.gear === undefined) {
+                        const initialGear = this.getSetting('startGear');
+                        this.gear = initialGear + request.gearDelta;
+                    }
+                    else {
+                        this.gear += request.gearDelta;
+                    }
+                    if (this.gear < 1) {
+                        this.gear = 1;
+                    }
+                    if (this.gear > this.gearRatios.length) {
+                        this.gear = this.gearRatios.length;
+                    }
+                    delete request.gearDelta;
+                    newRequest.gearRatio = this.gearRatios[this.gear];
+                }
+                else {
+                    if (this.gear === undefined) {
+                        const initialGear = this.getSetting('startGear');
+                        this.gear = initialGear + request.gearDelta;
+                    }
+                    newRequest.gearRatio = this.gearRatios[this.gear];
+                }
+                break;
             case 'Disabled':
             default:
                 break;
@@ -218,17 +272,22 @@ class SmartTrainerCyclingMode extends power_base_1.default {
         if (virtshiftMode === 'Disabled') {
             return 'Disabled';
         }
-        if (this.adapter.supportsVirtualShifting()) {
-            if (virtshiftMode === 'Enabled') {
-                return 'Adapter';
-            }
+        else if (virtshiftMode === 'Incyclist') {
+            return 'Simulated';
+        }
+        else if (virtshiftMode === 'SmartTrainer') {
+            return 'Adapter';
+        }
+        else if (virtshiftMode === 'Mixed') {
+            return 'SlopeDelta';
         }
-        else {
-            return virtshiftMode === 'Mixed' ? 'SlopeDelta' : 'Simulated';
+        else if (virtshiftMode === 'Enabled') {
+            return this.adapter.supportsVirtualShifting() ? 'Adapter' : 'Simulated';
         }
+        return 'Disabled';
     }
     updateData(bikeData, log) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const prev = Object.assign({}, this.data);
         const data = super.updateData(bikeData, log);
         const mode = this.getVirtualShiftMode();
@@ -241,14 +300,14 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             this.tsStart = Date.now();
         }
         if (this.gear === undefined && this.tsStart && data.power > 0 && (Date.now() - this.tsStart > 3000)) {
-            this.setInitialGear(data);
+            this.gear = (_a = this.getSetting('startGear')) !== null && _a !== void 0 ? _a : 0;
             data.gearStr = this.getGearString();
         }
         else if (this.gear !== undefined) {
             if (prev.power !== data.power || prev.pedalRpm !== data.pedalRpm) {
                 virtualSpeed = (0, calculations_1.calculateVirtualSpeed)(data.pedalRpm, this.gearRatios[this.gear - 1]);
-                const m = (_b = (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.getWeight()) !== null && _b !== void 0 ? _b : 85;
-                this.simPower = calculations_1.default.calculatePower(m, virtualSpeed, (_d = (_c = this.simSlope) !== null && _c !== void 0 ? _c : data.slope) !== null && _d !== void 0 ? _d : 0);
+                const m = (_c = (_b = this.adapter) === null || _b === void 0 ? void 0 : _b.getWeight()) !== null && _c !== void 0 ? _c : 85;
+                this.simPower = calculations_1.default.calculatePower(m, virtualSpeed, (_e = (_d = this.simSlope) !== null && _d !== void 0 ? _d : data.slope) !== null && _e !== void 0 ? _e : 0);
                 this.verifySimPower();
             }
         }
@@ -279,16 +338,6 @@ class SmartTrainerCyclingMode extends power_base_1.default {
         }
         return newRequest;
     }
-    setInitialGear(data) {
-        var _a, _b;
-        const m = (_b = (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.getWeight()) !== null && _b !== void 0 ? _b : 85;
-        const virtualSpeeds = this.gearRatios.map(r => (0, calculations_1.calculateVirtualSpeed)(data.pedalRpm, r));
-        const requiredPowers = virtualSpeeds.map(v => { var _a; return calculations_1.default.calculatePower(m, v, (_a = data.slope) !== null && _a !== void 0 ? _a : 0); });
-        const deltas = requiredPowers.map((p, i) => ({ gear: i + 1, delta: Math.abs(p - data.power) }));
-        deltas.sort((a, b) => a.delta - b.delta);
-        this.gear = deltas[0].gear;
-        this.logger.logEvent({ message: 'set initial gear', gear: this.gear, m, rpm: data.pedalRpm, power: data.power });
-    }
     getGearString() {
         const mode = this.getVirtualShiftMode();
         if (mode === "Disabled")

package/lib/modes/types.d.ts

@@ -10,6 +10,7 @@ export type UpdateRequest = {
     refresh?: boolean;
     init?: boolean;
     gear?: number;
+    gearRatio?: number;
     forced?: boolean;
 };
 export declare enum CyclingModeProperyType {
@@ -29,6 +30,7 @@ export type CyclingModeProperty = {
     max?: number;
     default?: any;
     options?: any[];
+    condition?: (setting: any) => boolean;
 };
 export type Settings = {
     [key: string]: any;