incyclist-devices 2.3.43 → 2.4.0

package/lib/ble/fm/adapter.js

@@ -24,6 +24,7 @@ const utils_1 = require("../../utils/utils");
 const utils_2 = require("../utils");
 const play_1 = require("../zwift/play");
 const features_1 = require("../../features");
+const fm_resistance_1 = __importDefault(require("../../modes/fm-resistance"));
 const ZWIFT_PLAY_UUID = '0000000119ca465186e5fa29dcdd09d1';
 class BleFmAdapter extends adapter_1.default {
     constructor(settings, props) {
@@ -66,6 +67,9 @@ class BleFmAdapter extends adapter_1.default {
             modes.push(antble_erg_1.default);
         if (features.setSlope === undefined || features.setSlope)
             modes.push(antble_smarttrainer_1.default);
+        if (features.setResistance) {
+            modes.push(fm_resistance_1.default);
+        }
         return modes;
     }
     getDefaultCyclingMode() {
@@ -79,10 +83,13 @@ class BleFmAdapter extends adapter_1.default {
             return new antble_smarttrainer_1.default(this);
         if (features.setPower === undefined || features.setPower)
             return new antble_erg_1.default(this);
+        if (features.setResistance) {
+            return new fm_resistance_1.default(this);
+        }
         return new power_meter_1.default(this);
     }
     mapData(deviceData) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const data = {
             isPedalling: false,
             power: 0,
@@ -98,6 +105,10 @@ class BleFmAdapter extends adapter_1.default {
         data.time = (_c = deviceData === null || deviceData === void 0 ? void 0 : deviceData.time) !== null && _c !== void 0 ? _c : data.time;
         data.isPedalling = data.pedalRpm > 0 || (data.pedalRpm === undefined && data.power > 0);
         data.heartrate = deviceData.heartrate || data.heartrate;
+        const features = (_d = this.getSensor()) === null || _d === void 0 ? void 0 : _d.features;
+        if ((features === null || features === void 0 ? void 0 : features.setResistance) || ((_e = features === null || features === void 0 ? void 0 : features.fmInfo) === null || _e === void 0 ? void 0 : _e.includes('resistanceLevel'))) {
+            data.resistance = deviceData.resistanceLevel;
+        }
         return data;
     }
     transformData(bikeData) {
@@ -250,7 +261,7 @@ class BleFmAdapter extends adapter_1.default {
         if (features.power === false && this.hasCapability(types_1.IncyclistCapability.Power)) {
             this.capabilities = this.capabilities.filter(cap => cap !== types_1.IncyclistCapability.Power);
         }
-        if (features.setPower === false && features.setSlope === false) {
+        if (features.setPower === false && features.setSlope === false && features.setResistance === false) {
             this.logEvent({ message: 'downgrade to Power Meter', name: this.getSettings().name, interface: this.getSettings().interface });
             this.capabilities = this.capabilities.filter(cap => cap !== types_1.IncyclistCapability.Control);
         }
@@ -283,6 +294,10 @@ class BleFmAdapter extends adapter_1.default {
                             yield device.setTargetPower(tp);
                             res.targetPower = tp;
                         }
+                        if (update.targetResistance !== undefined) {
+                            yield device.setTargetResistanceLevel(update.targetResistance);
+                            res.targetResistance = update.targetResistance;
+                        }
                         if (update.gearRatio !== undefined) {
                             if (!this.zwiftPlay) {
                                 this.initVirtualShifting();
@@ -300,6 +315,9 @@ class BleFmAdapter extends adapter_1.default {
                     });
                     this.promiseSendUpdate = send();
                     const confirmed = yield this.promiseSendUpdate;
+                    if (confirmed) {
+                        this.getCyclingMode().confirmed(confirmed);
+                    }
                     delete this.promiseSendUpdate;
                     return confirmed;
                 }
@@ -324,7 +342,7 @@ class BleFmAdapter extends adapter_1.default {
                         yield this.sendUpdate(request, true);
                         return true;
                     }
-                    else if (mode.isSIM() && this.supportsVirtualShifting()) {
+                    else if ((mode.isSIM() && this.supportsVirtualShifting()) || mode.isResistance()) {
                         yield this.sendInitialRequest();
                         return true;
                     }

package/lib/ble/fm/sensor.d.ts

@@ -30,15 +30,19 @@ export default class BleFitnessMachineDevice extends TBleSensor {
     getWindSpeed(): number;
     requestControl(): Promise<boolean>;
     setTargetPower(power: number): Promise<boolean>;
+    setTargetResistanceLevel(resistanceLevel: number): Promise<boolean>;
     setSlope(slope: any): Promise<boolean>;
     protected parseHrm(_data: Uint8Array): IndoorBikeData;
     protected parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
     protected parseFitnessMachineStatus(_data: Uint8Array): IndoorBikeData;
     getFitnessMachineFeatures(): Promise<IndoorBikeFeatures | undefined>;
+    protected buildFitnessMachineInfo(fitnessMachine: number): string[];
+    protected buildTargetSettingsInfo(targetSettings: number): string[];
     protected writeFtmsMessage(requestedOpCode: any, data: any, props?: BleWriteProps): Promise<number>;
     setTargetInclination(inclination: number): Promise<boolean>;
     setIndoorBikeSimulation(windSpeed: number, gradient: number, crr: number, cw: number): Promise<boolean>;
     startRequest(): Promise<boolean>;
     stopRequest(): Promise<boolean>;
     PauseRequest(): Promise<boolean>;
+    protected getName(): string;
 }

package/lib/ble/fm/sensor.js

@@ -81,11 +81,13 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
     getWindSpeed() { return this.windSpeed; }
     requestControl() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (this.hasControl)
+            var _a, _b, _c;
+            if (this.hasControl) {
                 return true;
-            if (((_a = this.features) === null || _a === void 0 ? void 0 : _a.setPower) === false && ((_b = this.features) === null || _b === void 0 ? void 0 : _b.setSlope) === false)
+            }
+            if (((_a = this.features) === null || _a === void 0 ? void 0 : _a.setPower) === false && ((_b = this.features) === null || _b === void 0 ? void 0 : _b.setSlope) === false && ((_c = this.features) === null || _c === void 0 ? void 0 : _c.setResistance) === false) {
                 return true;
+            }
             this.logEvent({ message: 'requestControl' });
             this.isCheckingControl = true;
             const data = Buffer.alloc(1);
@@ -103,7 +105,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
     }
     setTargetPower(power) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
+            this.logEvent({ message: 'setTargetPower', device: this.getName(), power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
             if (this.data.targetPower !== undefined && this.data.targetPower === power)
                 return true;
             const hasControl = yield this.requestControl();
@@ -121,9 +123,31 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             return (res === 1);
         });
     }
+    setTargetResistanceLevel(resistanceLevel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'setTargetResistanceLevel', device: this.getName(), resistanceLevel, skip: (this.data.resistanceLevel !== undefined && this.data.resistanceLevel === resistanceLevel) });
+            if (this.data.resistanceLevel !== undefined && this.data.resistanceLevel === resistanceLevel)
+                return true;
+            const hasControl = yield this.requestControl();
+            if (!hasControl) {
+                this.logEvent({ message: 'setTargetResistanceLevel failed', reason: 'control is disabled' });
+                return true;
+            }
+            const data = Buffer.alloc(3);
+            data.writeUInt8(4, 0);
+            let resistance = Math.min(resistanceLevel, 100);
+            resistance = Math.max(resistance, 0);
+            data.writeInt16LE(Math.round(resistance * 10), 1);
+            const res = yield this.writeFtmsMessage(4, data);
+            if (res === 5) {
+                this.hasControl = false;
+            }
+            return (res === 1);
+        });
+    }
     setSlope(slope) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'setSlope', slope });
+            this.logEvent({ message: 'setSlope', device: this.getName(), slope });
             const { windSpeed, crr, cw } = this;
             return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
         });
@@ -210,7 +234,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
                 }
             }
             catch (err) {
-                this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', data: data.toString('hex'), offset, error: err.message, stack: err.stack });
+                this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', device: this.getName(), data: data.toString('hex'), offset, error: err.message, stack: err.stack });
             }
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
@@ -265,7 +289,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             }
         }
         catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message, data: data.toString('hex'), stack: err.stack });
+            this.logEvent({ message: 'error', fn: 'parseFitnessMachineStatus()', error: err.message, device: this.getName(), data: data.toString('hex'), stack: err.stack });
         }
         return Object.assign(Object.assign({}, this.data), { raw: `2ada:${data.toString('hex')}` });
     }
@@ -289,8 +313,13 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
                     const setSlope = (targetSettings & consts_2.TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported) !== 0
                         || (targetSettings & consts_2.TargetSettingFeatureFlag.InclinationTargetSettingSupported) !== 0;
                     const setPower = (targetSettings & consts_2.TargetSettingFeatureFlag.PowerTargetSettingSupported) !== 0;
-                    this._features = { fitnessMachine, targetSettings, power, heartrate, cadence, setPower, setSlope };
-                    this.logEvent({ message: 'supported Features: ', fatures: this._features, power, heartrate, cadence });
+                    const setResistance = (targetSettings & consts_2.TargetSettingFeatureFlag.ResistanceTargetSettingSupported) !== 0;
+                    const fmInfo = this.buildFitnessMachineInfo(fitnessMachine);
+                    const tsInfo = this.buildTargetSettingsInfo(targetSettings);
+                    this._features = { fitnessMachine, targetSettings, power, heartrate, cadence, setPower, setSlope, setResistance };
+                    this.logEvent({ message: 'supported features', device: this.getName(), fmFeatures: fmInfo.join('|'), tsFeatures: tsInfo.join('|'), features: this._features });
+                    this._features.fmInfo = fmInfo;
+                    this._features.tsInfo = tsInfo;
                     return this._features;
                 }
                 else {
@@ -298,15 +327,77 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
                 }
             }
             catch (err) {
-                this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack });
+                this.logEvent({ message: 'could not read FitnessMachineFeatures', error: err.message, stack: err.stack, device: this.getName() });
                 return undefined;
             }
         });
     }
+    buildFitnessMachineInfo(fitnessMachine) {
+        const info = [];
+        const check = (flag, name) => {
+            if (fitnessMachine & flag)
+                info.push(name);
+        };
+        try {
+            check(consts_2.FitnessMachineFeatureFlag.AverageSpeedSupported, 'avgSpeed');
+            check(consts_2.FitnessMachineFeatureFlag.CadenceSupported, 'cadence');
+            check(consts_2.FitnessMachineFeatureFlag.TotalDistanceSupported, 'totalDistance');
+            check(consts_2.FitnessMachineFeatureFlag.InclinationSupported, 'inclination');
+            check(consts_2.FitnessMachineFeatureFlag.ElevationGainSupported, 'elevationGain');
+            check(consts_2.FitnessMachineFeatureFlag.PaceSupported, 'pace');
+            check(consts_2.FitnessMachineFeatureFlag.StepCountSupported, 'stepCount');
+            check(consts_2.FitnessMachineFeatureFlag.ResistanceLevelSupported, 'resistanceLevel');
+            check(consts_2.FitnessMachineFeatureFlag.StrideCountSupported, 'strideCount');
+            check(consts_2.FitnessMachineFeatureFlag.ExpendedEnergySupported, 'expendedEnergy');
+            check(consts_2.FitnessMachineFeatureFlag.HeartRateMeasurementSupported, 'heartrate');
+            check(consts_2.FitnessMachineFeatureFlag.MetabolicEquivalentSupported, 'metabolicEquivalent');
+            check(consts_2.FitnessMachineFeatureFlag.ElapsedTimeSupported, 'elapsedTime');
+            check(consts_2.FitnessMachineFeatureFlag.RemainingTimeSupported, 'remainingTime');
+            check(consts_2.FitnessMachineFeatureFlag.PowerMeasurementSupported, 'power');
+            check(consts_2.FitnessMachineFeatureFlag.ForceOnBeltAndPowerOutputSupported, 'force');
+            check(consts_2.FitnessMachineFeatureFlag.UserDataRetentionSupported, 'userDataRetention');
+        }
+        catch (err) {
+            this.logEvent({ message: 'could not read FitnessMachineInfo', error: err.message, stack: err.stack, device: this.getName() });
+            return undefined;
+        }
+        return info;
+    }
+    buildTargetSettingsInfo(targetSettings) {
+        const info = [];
+        const check = (flag, name) => {
+            if (targetSettings & flag)
+                info.push(name);
+        };
+        try {
+            check(consts_2.TargetSettingFeatureFlag.SpeedTargetSettingSupported, 'speed');
+            check(consts_2.TargetSettingFeatureFlag.InclinationTargetSettingSupported, 'inclination');
+            check(consts_2.TargetSettingFeatureFlag.ResistanceTargetSettingSupported, 'resistance');
+            check(consts_2.TargetSettingFeatureFlag.PowerTargetSettingSupported, 'power');
+            check(consts_2.TargetSettingFeatureFlag.HeartRateTargetSettingSupported, 'heartrate');
+            check(consts_2.TargetSettingFeatureFlag.TargetedExpendedEnergyConfigurationSupported, 'expendedEnergy');
+            check(consts_2.TargetSettingFeatureFlag.TargetedStepNumberConfigurationSupported, 'steps');
+            check(consts_2.TargetSettingFeatureFlag.TargetedStrideNumberConfigurationSupported, 'strides');
+            check(consts_2.TargetSettingFeatureFlag.TargetedDistanceConfigurationSupported, 'distance');
+            check(consts_2.TargetSettingFeatureFlag.TargetedTrainingTimeConfigurationSupported, 'trainingTime');
+            check(consts_2.TargetSettingFeatureFlag.TargetedTimeInTwoHeartRateZonesConfigurationSupported, 'timeInTwoHRZones');
+            check(consts_2.TargetSettingFeatureFlag.TargetedTimeInThreeHeartRateZonesConfigurationSupported, 'timeInThreeHRZones');
+            check(consts_2.TargetSettingFeatureFlag.TargetedTimeInFiveHeartRateZonesConfigurationSupported, 'timeInFiveHRZones');
+            check(consts_2.TargetSettingFeatureFlag.IndoorBikeSimulationParametersSupported, 'SIM');
+            check(consts_2.TargetSettingFeatureFlag.WheelCircumferenceConfigurationSupported, 'wheelCircumference');
+            check(consts_2.TargetSettingFeatureFlag.SpinDownControlSupported, 'spindown');
+            check(consts_2.TargetSettingFeatureFlag.TargetedCadenceConfigurationSupported, 'cadence');
+        }
+        catch (err) {
+            this.logEvent({ message: 'could not read TargetSettingsInfo', error: err.message, stack: err.stack, device: this.getName() });
+            return undefined;
+        }
+        return info;
+    }
     writeFtmsMessage(requestedOpCode, data, props) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
+                this.logEvent({ message: 'fmts:write', device: this.getName(), data: data.toString('hex') });
                 let res;
                 let tsStart = Date.now();
                 if (props === null || props === void 0 ? void 0 : props.timeout) {
@@ -325,11 +416,11 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
                 if (opCode !== 128 || request !== requestedOpCode)
                     throw new Error('Illegal response ');
                 const duration = Date.now() - tsStart;
-                this.logEvent({ message: 'fmts:write result', res: responseData.toString('hex'), result, duration });
+                this.logEvent({ message: 'fmts:write result', device: this.getName(), res: responseData.toString('hex'), result, duration });
                 return result;
             }
             catch (err) {
-                this.logEvent({ message: 'fmts:write failed', opCode: requestedOpCode, reason: err.message });
+                this.logEvent({ message: 'fmts:write failed', device: this.getName(), opCode: requestedOpCode, reason: err.message });
                 return 4;
             }
         });
@@ -341,6 +432,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
                 return true;
             if (((_a = this.features) === null || _a === void 0 ? void 0 : _a.setSlope) === false)
                 return true;
+            this.logEvent({ message: 'setTargetInclination', device: this.getName(), inclination });
             const hasControl = yield this.requestControl();
             if (!hasControl) {
                 this.logEvent({ message: 'setTargetInclination failed', reason: 'control is disabled' });
@@ -358,9 +450,10 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             var _a;
             if (((_a = this.features) === null || _a === void 0 ? void 0 : _a.setPower) === false)
                 return true;
+            this.logEvent({ message: 'setIndoorBikeSimulation', device: this.getName(), windSpeed, gradient, crr, cw });
             const hasControl = yield this.requestControl();
             if (!hasControl) {
-                this.logEvent({ message: 'setIndoorBikeSimulation failed', reason: 'control is disabled' });
+                this.logEvent({ message: 'setIndoorBikeSimulation failed', device: this.getName(), reason: 'control is disabled' });
                 return false;
             }
             const data = Buffer.alloc(7);
@@ -417,6 +510,10 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             return (res === 1);
         });
     }
+    getName() {
+        var _a, _b;
+        return (_b = (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.getInfo().name) !== null && _b !== void 0 ? _b : 'ble-fm-device';
+    }
 }
 BleFitnessMachineDevice.profile = 'Smart Trainer';
 BleFitnessMachineDevice.protocol = 'fm';

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

@@ -27,4 +27,7 @@ export type IndoorBikeFeatures = {
     cadence?: boolean;
     setSlope?: boolean;
     setPower?: boolean;
+    setResistance?: boolean;
+    fmInfo?: string[];
+    tsInfo?: string[];
 };

package/lib/modes/ant-fe-adv-st-mode.d.ts

@@ -8,6 +8,7 @@ export default class AntAdvSimCyclingMode extends SmartTrainerCyclingMode {
         name: string;
         isERG?: boolean;
         isSIM?: boolean;
+        isResistance?: boolean;
         description: string;
         properties: import("./types").CyclingModeProperty[];
     };

package/lib/modes/base.d.ts

@@ -8,6 +8,7 @@ export declare abstract class CyclingModeBase extends CyclingMode implements ICy
     protected static config: CyclingModeConfig;
     protected static isERG: boolean;
     protected prevUpdate: UpdateRequest;
+    protected prevConfirmed: UpdateRequest;
     static supportsERGMode(): boolean;
     constructor(adapter: IAdapter, props?: any);
     setAdapter(adapter: IAdapter): void;
@@ -26,6 +27,7 @@ export declare abstract class CyclingModeBase extends CyclingMode implements ICy
     getModeProperty(name: string): any;
     protected updateRequired(request?: UpdateRequest): boolean;
     buildUpdate(request?: UpdateRequest): UpdateRequest;
+    confirmed(request: UpdateRequest): void;
     abstract getBikeInitRequest(): UpdateRequest;
     abstract sendBikeUpdate(request: UpdateRequest): UpdateRequest;
     abstract updateData(data: IncyclistBikeData): IncyclistBikeData;

package/lib/modes/base.js

@@ -91,6 +91,9 @@ class CyclingModeBase extends types_1.CyclingMode {
         }
         return this.sendBikeUpdate(request);
     }
+    confirmed(request) {
+        this.prevConfirmed = Object.assign({}, request);
+    }
 }
 exports.CyclingModeBase = CyclingModeBase;
 CyclingModeBase.config = { name: '', description: '', properties: [] };

package/lib/modes/fm-resistance.d.ts

@@ -0,0 +1,39 @@
+import { IncyclistDeviceAdapter } from "../base/adpater";
+import { IncyclistBikeData } from "../types";
+import PowerBasedCyclingModeBase from "./power-base";
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
+export default class FMResistanceMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+    protected static config: {
+        isERG: boolean;
+        isSIM: boolean;
+        isResistance: boolean;
+        name: string;
+        description: string;
+        properties: {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: number;
+            min: number;
+            max: number;
+        }[];
+    };
+    protected confirmedResistance?: number;
+    protected requestedResistance?: number;
+    constructor(adapter: IncyclistDeviceAdapter, props?: any);
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected checkSlope(request: UpdateRequest): void;
+    protected checkTargetResistanceSet(request: UpdateRequest, newRequest: UpdateRequest): void;
+    protected checkGearDeltaSet(request: UpdateRequest, newRequest: UpdateRequest): void;
+    updateData(bikeData: IncyclistBikeData, log?: boolean): IncyclistBikeData;
+    confirmed(request: UpdateRequest): void;
+    protected getCurrentResistanceTarget(): number;
+    protected getConfirmedResistanceTarget(): number;
+    protected getCurrentResistance(): number;
+    protected getInitialGear(): number;
+    protected getGear(resistance: number): number;
+    protected calculateTargetResistance(gear: number): number;
+}

package/lib/modes/fm-resistance.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const power_base_1 = __importDefault(require("./power-base"));
+const types_1 = require("./types");
+class FMResistanceMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.initLogger('FMResistanceMode');
+        this.data.slope = 0;
+    }
+    getBikeInitRequest() {
+        return { targetResistance: this.calculateTargetResistance(this.getInitialGear()) };
+    }
+    sendBikeUpdate(incoming) {
+        if (this.logger)
+            this.logger.logEvent({ message: "processing update request", request: incoming, prev: this.prevRequest, data: this.getData() });
+        let newRequest = {};
+        const request = Object.assign({}, incoming);
+        try {
+            const req = this.checkForResetOrEmpty(request);
+            if (req) {
+                delete req.refresh;
+                return req;
+            }
+            this.checkSlope(request);
+            this.checkGearDeltaSet(request, newRequest);
+            this.checkTargetResistanceSet(request, newRequest);
+            this.checkRefresh(request, newRequest);
+            this.checkEmptyRequest(newRequest);
+            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        }
+        catch (err) {
+            if (this.logger)
+                this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message, stack: err.stack });
+        }
+        if (newRequest.targetResistance !== undefined) {
+            this.requestedResistance = newRequest.targetResistance;
+        }
+        return newRequest;
+    }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return { reset: true };
+        }
+        if (Object.keys(request).length === 0 && this.prevRequest) {
+            return { targetResistance: this.prevRequest.targetResistance, refresh: true };
+        }
+    }
+    checkSlope(request) {
+        if (request.slope !== undefined) {
+            this.data.slope = request.slope;
+            delete request.slope;
+        }
+    }
+    checkTargetResistanceSet(request, newRequest) {
+        if (request.targetResistance !== undefined) {
+            let resistance = Math.floor(request.targetResistance);
+            resistance = Math.max(resistance, 0);
+            resistance = Math.min(resistance, 100);
+            newRequest.targetResistance = resistance;
+            delete request.refresh;
+        }
+    }
+    checkGearDeltaSet(request, newRequest) {
+        let resistance = this.getCurrentResistanceTarget();
+        let gear = this.getGear(resistance);
+        if (request.gearDelta !== undefined) {
+            gear += request.gearDelta;
+            gear = Math.max(gear, 1);
+            gear = Math.min(gear, 26);
+            resistance = this.calculateTargetResistance(gear);
+            newRequest.targetResistance = resistance;
+            delete request.gearDelta;
+        }
+    }
+    updateData(bikeData, log) {
+        const data = super.updateData(bikeData, log);
+        if (data.resistance !== undefined) {
+            data.gear = this.getGear(data.resistance);
+            data.gearStr = `${data.gear}`;
+            if (this.getCurrentResistanceTarget() !== this.getCurrentResistance()) {
+                const gear = this.getGear(this.getConfirmedResistanceTarget());
+                if (this.getCurrentResistanceTarget() === this.getConfirmedResistanceTarget()) {
+                    data.gearStr = `${gear}`;
+                }
+                else if (this.getCurrentResistanceTarget() > this.getConfirmedResistanceTarget()) {
+                    data.gearStr = `${gear} \u2191`;
+                }
+                else {
+                    data.gearStr = `${gear} \u2193`;
+                }
+            }
+        }
+        return data;
+    }
+    confirmed(request) {
+        if (request.targetResistance !== undefined) {
+            this.confirmedResistance = request.targetResistance;
+        }
+    }
+    getCurrentResistanceTarget() {
+        var _a;
+        return (_a = this.requestedResistance) !== null && _a !== void 0 ? _a : this.calculateTargetResistance(this.getInitialGear());
+    }
+    getConfirmedResistanceTarget() {
+        return this.confirmedResistance;
+    }
+    getCurrentResistance() {
+        return this.getData().resistance;
+    }
+    getInitialGear() {
+        return Number(this.getSetting('startGear'));
+    }
+    getGear(resistance) {
+        let r = Math.max(resistance !== null && resistance !== void 0 ? resistance : 0, 0);
+        r = Math.min(r, 100);
+        return Math.floor(r / 4) + 1;
+    }
+    calculateTargetResistance(gear) {
+        let g = Math.max(gear, 0);
+        g = Math.min(g, 26);
+        return (g - 1) * 4;
+    }
+}
+FMResistanceMode.config = {
+    isERG: false,
+    isSIM: false,
+    isResistance: true,
+    name: "Resistance",
+    description: "Resistance levels are set by the app based on selected gear. Calculates speed based on power and slope.",
+    properties: [
+        { key: 'startGear', name: 'Initial Gear', description: 'Initial Gear', type: types_1.CyclingModeProperyType.Integer, default: 5, min: 1, max: 26 }
+    ]
+};
+exports.default = FMResistanceMode;

package/lib/modes/types.d.ts

@@ -5,6 +5,8 @@ export type UpdateRequest = {
     maxPower?: number;
     targetPower?: number;
     targetPowerDelta?: number;
+    targetResistance?: number;
+    targetResistanceDelta?: number;
     gearDelta?: number;
     reset?: boolean;
     refresh?: boolean;
@@ -42,6 +44,7 @@ export default interface ICyclingMode {
     getProperty(name: string): CyclingModeProperty;
     getBikeInitRequest(): UpdateRequest;
     buildUpdate(request: UpdateRequest): UpdateRequest;
+    confirmed(request: UpdateRequest): void;
     updateData(data: IncyclistBikeData): IncyclistBikeData;
     setSettings(settings: any): any;
     setSetting(name: string, value: any): void;
@@ -54,6 +57,7 @@ export default interface ICyclingMode {
 export type CyclingModeConfig = {
     isERG?: boolean;
     isSIM?: boolean;
+    isResistance?: boolean;
     name: string;
     description: string;
     properties: CyclingModeProperty[];
@@ -77,5 +81,7 @@ export declare class CyclingMode implements ICyclingMode {
     getConfig(): CyclingModeConfig;
     isERG(): boolean;
     isSIM(): boolean;
+    isResistance(): boolean;
     getData(): Partial<IncyclistBikeData>;
+    confirmed(request: UpdateRequest): void;
 }

package/lib/modes/types.js

@@ -61,8 +61,13 @@ class CyclingMode {
     isSIM() {
         return this.getConfig().isSIM;
     }
+    isResistance() {
+        return this.getConfig().isResistance;
+    }
     getData() {
         return {};
     }
+    confirmed(request) {
+    }
 }
 exports.CyclingMode = CyclingMode;

package/lib/types/data.d.ts

@@ -22,4 +22,5 @@ export type IncyclistBikeData = {
     gear?: number;
     gearStr?: string;
     slope?: number;
+    resistance?: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.3.43",
+  "version": "2.4.0",
   "dependencies": {
     "@protobuf-ts/runtime": "^2.11.1",
     "@serialport/bindings-interface": "^1.2.2",