Added tests for bike power functions

src/devices/apexbike/apexbike.cpp

@@ -97,10 +97,7 @@ void apexbike::update() {
         }
 
         if (requestResistance != -1) {
-            if (requestResistance > max_resistance)
-                requestResistance = max_resistance;
-            else if (requestResistance <= 0)
-                requestResistance = 1;
+            requestResistance = this->resistanceLimits().clip(requestResistance);
 
             if (requestResistance != currentResistance().value()) {
                 qDebug() << QStringLiteral("writing resistance ") + QString::number(requestResistance);

src/devices/apexbike/apexbike.h

@@ -38,8 +38,10 @@ class apexbike : public bike {
     apexbike(bool noWriteResistance, bool noHeartService, uint8_t bikeResistanceOffset, double bikeResistanceGain);
     bool connected() override;
 
+    minmax<resistance_t> resistanceLimits() override {return minmax<resistance_t>(1,32);}
+
   private:
-    const resistance_t max_resistance = 32;
+
     void btinit();
     void writeCharacteristic(uint8_t *data, uint8_t data_len, const QString &info, bool disable_log = false,
                              bool wait_for_response = false);

src/devices/bike.cpp

@@ -41,11 +41,21 @@ void bike::changeInclination(double grade, double percentage) {
 
 // originally made for renphobike, but i guess it could be very generic
 uint16_t bike::powerFromResistanceRequest(resistance_t requestResistance) {
+    auto minMaxR = this->resistanceLimits();
+    if(requestResistance<=minMaxR.min())
+        return 0;
+
     // this bike has resistance level to N.m so the formula is Power (kW) = Torque (N.m) x Speed (RPM) / 9.5488
-    double cadence = RequestedCadence.value();
+    double cadence = this->RequestedCadence.value();
     if (cadence <= 0)
         cadence = Cadence.value();
-    return (requestResistance * cadence) / 9.5488;
+
+    if(cadence <= this->cadenceLimits().min())
+        return 0;
+
+    requestResistance = minMaxR.clip(requestResistance);
+
+    return (requestResistance * this->cadenceLimits().clip(cadence)) / 9.5488;
 }
 
 void bike::changeRequestedPelotonResistance(int8_t resistance) { RequestedPelotonResistance = resistance; }
@@ -103,8 +113,52 @@ uint8_t bike::fanSpeed() { return FanSpeed; }
 bool bike::connected() { return false; }
 uint16_t bike::watts() { return 0; }
 metric bike::pelotonResistance() { return m_pelotonResistance; }
-resistance_t bike::pelotonToBikeResistance(int pelotonResistance) { return pelotonResistance; }
-resistance_t bike::resistanceFromPowerRequest(uint16_t power) { return power / 10; } // in order to have something
+
+resistance_t bike::pelotonToBikeResistance(int pelotonResistance) {
+
+    auto minMaxR = this->resistanceLimits();
+
+    for (resistance_t i = minMaxR.min(); i < minMaxR.max(); i++) {
+        if (bikeResistanceToPeloton(i) <= pelotonResistance && bikeResistanceToPeloton(i + 1) >= pelotonResistance) {
+            return i;
+        }
+    }
+    if (pelotonResistance < bikeResistanceToPeloton(minMaxR.min()))
+        return minMaxR.min();
+    else
+        return minMaxR.max();
+}
+resistance_t bike::resistanceFromPowerRequest(uint16_t power) {
+    qDebug() << QStringLiteral("resistanceFromPowerRequest") << Cadence.value();
+
+    QSettings settings;
+
+    double watt_gain = settings.value(QZSettings::watt_gain, QZSettings::default_watt_gain).toDouble();
+    double watt_offset = settings.value(QZSettings::watt_offset, QZSettings::default_watt_offset).toDouble();
+
+    auto minMaxR = this->resistanceLimits();
+
+    uint16_t power0 = (wattsFromResistance(minMaxR.min()) * watt_gain) + watt_offset;
+
+    // Is the requested power at or below the power of the minimum resistance the device provides?
+    if (power <= power0)
+        return minMaxR.min();
+
+    // Search from the 1st resistance level above minimum to the maximum
+    for (resistance_t i = 1 + minMaxR.min(); i < minMaxR.max(); i++) {
+        uint16_t power1 = wattsFromResistance(i)*watt_gain + watt_offset;
+
+        if(power0 <= power && power1>=power) {
+            qDebug() << QStringLiteral("resistanceFromPowerRequest") << power0 << power1 << power;
+            return i;
+        }
+
+        power0 = power1;
+    }
+
+    // requested power requires resistance beyond the maximum
+    return minMaxR.max();
+}
 void bike::cadenceSensor(uint8_t cadence) { Cadence.setValue(cadence); }
 void bike::powerSensor(uint16_t power) { m_watt.setValue(power, false); }
 

src/devices/bike.h

@@ -25,7 +25,9 @@ class bike : public bluetoothdevice {
     bool connected() override;
     virtual uint16_t watts();
     virtual resistance_t pelotonToBikeResistance(int pelotonResistance);
+    virtual double bikeResistanceToPeloton(double resistance) { return resistance; }
     virtual resistance_t resistanceFromPowerRequest(uint16_t power);
+    virtual uint16_t wattsFromResistance(double resistance) { return this->powerFromResistanceRequest(resistance); }
     virtual uint16_t powerFromResistanceRequest(resistance_t requestResistance);
     virtual bool ergManagedBySS2K() { return false; }
     bluetoothdevice::BLUETOOTH_TYPE deviceType() override;
@@ -48,6 +50,7 @@ class bike : public bluetoothdevice {
     virtual bool inclinationAvailableByHardware();
     bool ergModeSupportedAvailableByHardware() { return ergModeSupported; }
 
+    virtual minmax<int16_t> cadenceLimits() { return minmax<int16_t>(0, 250); }
   public Q_SLOTS:
     void changeResistance(resistance_t res) override;
     virtual void changeCadence(int16_t cad);

src/devices/bkoolbike/bkoolbike.cpp

@@ -732,17 +732,6 @@ void bkoolbike::controllerStateChanged(QLowEnergyController::ControllerState sta
     }
 }
 
-resistance_t bkoolbike::pelotonToBikeResistance(int pelotonResistance) {
-    for (resistance_t i = 0; i < max_resistance; i++) {
-        if (bikeResistanceToPeloton(i) <= pelotonResistance && bikeResistanceToPeloton(i + 1) >= pelotonResistance) {
-            return i;
-        }
-    }
-    if (pelotonResistance < bikeResistanceToPeloton(1))
-        return 0;
-    else
-        return max_resistance;
-}
 
 double bkoolbike::bikeResistanceToPeloton(double resistance) {
     QSettings settings;

src/devices/bkoolbike/bkoolbike.h

@@ -38,20 +38,18 @@ class bkoolbike : public bike {
     bkoolbike(bool noWriteResistance, bool noHeartService);
     void changePower(int32_t power) override;
     bool connected() override;
-    resistance_t pelotonToBikeResistance(int pelotonResistance);
 
+    minmax<resistance_t> resistanceLimits() override {return minmax<resistance_t>(1,100);}
   private:
     void writeCharacteristic(uint8_t *data, uint8_t data_len, const QString &info, bool disable_log = false,
                              bool wait_for_response = false);
     void startDiscover();
     void forceInclination(double inclination);
     uint16_t watts() override;
-    double bikeResistanceToPeloton(double resistance);
+    double bikeResistanceToPeloton(double resistance) override;
 
     QTimer *refresh;
 
-    const int max_resistance = 100;
-
     QList<QLowEnergyService *> gattCommunicationChannelService;
     QLowEnergyCharacteristic gattWriteCharControlPointId;
     QLowEnergyCharacteristic gattWriteCharCustomId;

src/devices/bluetooth.cpp

@@ -2291,7 +2291,7 @@ void bluetooth::connectedAndDiscovered() {
 #else
                 settings.setValue(QZSettings::ftms_accessory_address, b.deviceUuid().toString());
 #endif
-                ftmsAccessory = new smartspin2k(false, false, this->device()->maxResistance(), (bike *)this->device());
+                ftmsAccessory = new smartspin2k(false, false, this->device()->resistanceLimits().max(), (bike *)this->device());
                 // connect(heartRateBelt, SIGNAL(disconnected()), this, SLOT(restart()));
 
                 connect(ftmsAccessory, &smartspin2k::debug, this, &bluetooth::debug);

src/devices/bluetoothdevice.cpp

@@ -353,7 +353,6 @@ QStringList bluetoothdevice::metrics() {
     return r;
 }
 
-resistance_t bluetoothdevice::maxResistance() { return 100; }
 
 uint8_t bluetoothdevice::metrics_override_heartrate() {
 

src/devices/bluetoothdevice.h

@@ -2,6 +2,7 @@
 #define BLUETOOTHDEVICE_H
 
 #include "definitions.h"
+#include "minmax.h"
 #include "metric.h"
 #include "qzsettings.h"
 
@@ -420,10 +421,20 @@ class bluetoothdevice : public QObject {
      */
     virtual uint8_t metrics_override_heartrate();
 
+    /**
+     * @brief Overridden in subclasses to specify the range of resistance levels supported by the device.
+     */
+    virtual minmax<resistance_t> resistanceLimits() { return minmax<resistance_t>(0,100); }
+
     /**
      * @brief Overridden in subclasses to specify the maximum resistance level supported by the device.
      */
-    virtual resistance_t maxResistance();
+ //   virtual resistance_t maxResistance() { return 100; }
+
+    /**
+     * @brief Overridden in subclasses to specify the minimum resistance level supported by the device.
+     */
+  //  virtual resistance_t minResistance() { return 0; }
 
   public Q_SLOTS:
     virtual void start();

src/devices/chronobike/chronobike.cpp

@@ -93,11 +93,7 @@ void chronobike::update() {
         }
 
         if (requestResistance != -1) {
-            if (requestResistance > 15) {
-                requestResistance = 15;
-            } else if (requestResistance == 0) {
-                requestResistance = 1;
-            }
+            requestResistance = this->resistanceLimits().clip(requestResistance);
 
             if (requestResistance != currentResistance().value()) {
                 emit debug(QStringLiteral("writing resistance ") + QString::number(requestResistance));

src/devices/chronobike/chronobike.h

@@ -38,6 +38,8 @@ class chronobike : public bike {
     chronobike(bool noWriteResistance, bool noHeartService);
     bool connected() override;
 
+    minmax<resistance_t> resistanceLimits() override {return minmax<resistance_t>(1,15);}
+
   private:
     // void writeCharacteristic(uint8_t *data, uint8_t data_len, QString info, bool disable_log = false, // Unused
     //                         bool wait_for_response = false);

src/devices/computrainerbike/computrainerbike.cpp

@@ -74,28 +74,6 @@ computrainerbike::computrainerbike(bool noWriteResistance, bool noHeartService,
     // ********************************************************************************************************
 }
 
-resistance_t computrainerbike::resistanceFromPowerRequest(uint16_t power) {
-    qDebug() << QStringLiteral("resistanceFromPowerRequest") << Cadence.value();
-
-    QSettings settings;
-
-    double watt_gain = settings.value(QZSettings::watt_gain, QZSettings::default_watt_gain).toDouble();
-    double watt_offset = settings.value(QZSettings::watt_offset, QZSettings::default_watt_offset).toDouble();
-
-    for (resistance_t i = 1; i < max_resistance; i++) {
-        if (((wattsFromResistance(i) * watt_gain) + watt_offset) <= power &&
-            ((wattsFromResistance(i + 1) * watt_gain) + watt_offset) >= power) {
-            qDebug() << QStringLiteral("resistanceFromPowerRequest")
-                     << ((wattsFromResistance(i) * watt_gain) + watt_offset)
-                     << ((wattsFromResistance(i + 1) * watt_gain) + watt_offset) << power;
-            return i;
-        }
-    }
-    if (power < ((wattsFromResistance(1) * watt_gain) + watt_offset))
-        return 1;
-    else
-        return max_resistance;
-}
 
 uint16_t computrainerbike::wattsFromResistance(resistance_t resistance) {
 
@@ -183,10 +161,8 @@ void computrainerbike::innerWriteResistance() {
     bool erg_mode = settings.value(QZSettings::zwift_erg, QZSettings::default_zwift_erg).toBool();
 
     if (requestResistance != -1) {
-        if (requestResistance > max_resistance) {
-            requestResistance = max_resistance;
-        } else if (requestResistance < min_resistance) {
-            requestResistance = min_resistance;
+        if(!this->resistanceLimits().contains(requestResistance)) {
+            requestResistance = resistanceLimits().clip(requestResistance);
         } else if (requestResistance == 0) {
             requestResistance = 1;
         }

src/devices/computrainerbike/computrainerbike.h

@@ -35,14 +35,11 @@ class computrainerbike : public bike {
     computrainerbike(bool noWriteResistance, bool noHeartService, uint8_t bikeResistanceOffset,
                      double bikeResistanceGain);
     resistance_t pelotonToBikeResistance(int pelotonResistance) override;
-    resistance_t resistanceFromPowerRequest(uint16_t power) override;
-    resistance_t maxResistance() override { return max_resistance; }
+
+    minmax<resistance_t> resistanceLimits() override {return minmax<resistance_t>(-20,100);}
     bool inclinationAvailableByHardware() override;
     bool connected() override;
-
   private:
-    resistance_t max_resistance = 100;
-    resistance_t min_resistance = -20;
     uint16_t wattsFromResistance(resistance_t resistance);
     double GetDistanceFromPacket(QByteArray packet);
     QTime GetElapsedFromPacket(QByteArray packet);

src/devices/cscbike/cscbike.cpp

@@ -105,11 +105,7 @@ void cscbike::update() {
         }
 
         if (requestResistance != -1) {
-            if (requestResistance > 15) {
-                requestResistance = 15;
-            } else if (requestResistance == 0) {
-                requestResistance = 1;
-            }
+            requestResistance = this->resistanceLimits().clip(requestResistance);
 
             if (requestResistance != currentResistance().value()) {
                 emit debug(QStringLiteral("writing resistance ") + QString::number(requestResistance));

src/devices/cscbike/cscbike.h

@@ -38,6 +38,7 @@ class cscbike : public bike {
     cscbike(bool noWriteResistance, bool noHeartService, bool noVirtualDevice);
     bool connected() override;
 
+    minmax<resistance_t> resistanceLimits() override {return minmax<resistance_t>(1,15);}
   private:
     //    void writeCharacteristic(uint8_t *data, uint8_t data_len, QString info, bool disable_log = false, //Unused
     //                             bool wait_for_response = false);

src/devices/domyosbike/domyosbike.cpp

@@ -246,11 +246,7 @@ void domyosbike::update() {
             }
 
             if (requestResistance != -1) {
-                if (requestResistance > max_resistance) {
-                    requestResistance = max_resistance;
-                } else if (requestResistance < 1) {
-                    requestResistance = 1;
-                }
+                requestResistance = this->resistanceLimits().clip(requestResistance);
 
                 if (requestResistance != currentResistance().value()) {
                     qDebug() << QStringLiteral("writing resistance ") + QString::number(requestResistance);
@@ -391,7 +387,7 @@ void domyosbike::characteristicChanged(const QLowEnergyCharacteristic &character
         Resistance = 1;
     }
     emit resistanceRead(Resistance.value());
-    m_pelotonResistance = (Resistance.value() * 100) / max_resistance;
+    m_pelotonResistance = (Resistance.value() * 100) / this->resistanceLimits().max();
 
     bool disable_hr_frommachinery =
         settings.value(QZSettings::heart_ignore_builtin, QZSettings::default_heart_ignore_builtin).toBool();
@@ -666,21 +662,21 @@ bool domyosbike::connected() {
 }
 
 resistance_t domyosbike::pelotonToBikeResistance(int pelotonResistance) {
-    return (pelotonResistance * max_resistance) / 100;
+    return (pelotonResistance * this->resistanceLimits().max()) / 100;
 }
 
 resistance_t domyosbike::resistanceFromPowerRequest(uint16_t power) {
     qDebug() << QStringLiteral("resistanceFromPowerRequest") << currentCadence().value();
 
-    for (resistance_t i = 1; i < max_resistance; i++) {
+    for (resistance_t i = 1; i < this->resistanceLimits().max(); i++) {
         if (wattsFromResistance(i) <= power && wattsFromResistance(i + 1) >= power) {
             return i;
         }
     }
-    if (power < wattsFromResistance(1))
+    if (power < wattsFromResistance(this->resistanceLimits().min()))
         return 1;
     else
-        return max_resistance;
+        return this->resistanceLimits().max();
 }
 
 uint16_t domyosbike::wattsFromResistance(double resistance) {

src/devices/domyosbike/domyosbike.h

@@ -40,7 +40,8 @@ class domyosbike : public bike {
                uint8_t bikeResistanceOffset = 4, double bikeResistanceGain = 1.0);
     resistance_t resistanceFromPowerRequest(uint16_t power) override;
     resistance_t pelotonToBikeResistance(int pelotonResistance) override;
-    resistance_t maxResistance() override { return max_resistance; }
+    minmax<resistance_t> resistanceLimits() override {return minmax<resistance_t>(1,15);}
+
     ~domyosbike() override;
     bool connected() override;
 
@@ -59,7 +60,6 @@ class domyosbike : public bike {
     void startDiscover();
     uint16_t watts() override;
 
-    const resistance_t max_resistance = 15;
     QTimer *refresh;
     uint8_t firstVirtual = 0;
     uint8_t firstStateChanged = 0;