Merge branch 'master' into applewatch-as-treadmill-speed

Author: cagnulein

.gitignore

@@ -53,4 +53,4 @@ src/inner_templates/googlemaps/cesium-key.js
 /tst/Devices/.vs
 src/inner_templates/googlemaps/cesium-key.js
 src/qdomyos-zwift.pro.user.49de507
-/.vs
+/.vs

src/devices/cscbike/cscbike.cpp

@@ -30,19 +30,24 @@ cscbike::cscbike(bool noWriteResistance, bool noHeartService, bool noVirtualDevi
 }
 
 void cscbike::enableManualResistancePowerAdjustment(resistance_t resistance) {
-    if (!jorotoBike) {
+    if (!jorotoBike && !useCustomResistancePowerTable()) {
         return;
     }
 
-    resistance_t clampedResistance = qBound<resistance_t>(1, resistance, 15);
+    resistance_t clampedResistance =
+        jorotoBike ? qBound<resistance_t>(1, resistance, 15) : clampedCustomResistance(resistance);
     manualResistanceTarget = clampedResistance;
     manualResistancePowerAdjustmentActive = true;
     Resistance = clampedResistance;
     emit resistanceRead(Resistance.value());
 
     if (!manualResistancePowerAdjustmentToastShown && homeform::singleton()) {
         homeform::singleton()->setToastRequested(
-            QStringLiteral("Manual resistance power adjustment enabled: power now scales with the Resistance tile value."));
+            jorotoBike
+                ? QStringLiteral(
+                      "Manual resistance power adjustment enabled: power now scales with the Resistance tile value.")
+                : QStringLiteral(
+                      "Custom CSC power table enabled: power now follows the configured resistance/watt points."));
         manualResistancePowerAdjustmentToastShown = true;
     }
 }
@@ -60,10 +65,65 @@ uint16_t cscbike::manualResistanceAdjustedWatts() {
     return qRound(cadenceOnlyWatts * manualResistancePowerMultiplier());
 }
 
+uint16_t cscbike::customResistanceAdjustedWatts() {
+    if (currentCadence().value() == 0) {
+        return 0;
+    }
+
+    QSettings settings;
+    const double resistanceLevel1 =
+        settings.value(QZSettings::cscbike_custom_resistance_level_1,
+                       QZSettings::default_cscbike_custom_resistance_level_1)
+            .toDouble();
+    const double watt1 =
+        settings.value(QZSettings::cscbike_custom_watt_1, QZSettings::default_cscbike_custom_watt_1).toDouble();
+    const double resistanceLevel2 =
+        settings.value(QZSettings::cscbike_custom_resistance_level_2,
+                       QZSettings::default_cscbike_custom_resistance_level_2)
+            .toDouble();
+    const double watt2 =
+        settings.value(QZSettings::cscbike_custom_watt_2, QZSettings::default_cscbike_custom_watt_2).toDouble();
+    const double resistance = clampedCustomResistance(manualResistanceTarget);
+
+    if (resistanceLevel1 == resistanceLevel2) {
+        return qMax(0, qRound((watt1 + watt2) / 2.0));
+    }
+
+    const double slope = (watt2 - watt1) / (resistanceLevel2 - resistanceLevel1);
+    const double watts = watt1 + ((resistance - resistanceLevel1) * slope);
+    return qMax(0, qRound(watts));
+}
+
 double cscbike::manualResistancePowerMultiplier() {
     const double normalizedResistance = (qBound(1, static_cast<int>(manualResistanceTarget), 15) - 1) / 14.0;
     return 1.0 + (normalizedResistance * normalizedResistance * 2.0);
 }
+
+bool cscbike::useCustomResistancePowerTable() const {
+    QSettings settings;
+    return settings
+        .value(QZSettings::cscbike_custom_resistance_power_table,
+               QZSettings::default_cscbike_custom_resistance_power_table)
+        .toBool();
+}
+
+resistance_t cscbike::clampedCustomResistance(resistance_t resistance) const {
+    QSettings settings;
+    int resistanceMin =
+        qRound(settings.value(QZSettings::zwift_erg_resistance_down,
+                              QZSettings::default_zwift_erg_resistance_down)
+                   .toDouble());
+    int resistanceMax =
+        qRound(settings.value(QZSettings::zwift_erg_resistance_up,
+                              QZSettings::default_zwift_erg_resistance_up)
+                   .toDouble());
+
+    if (resistanceMin > resistanceMax) {
+        qSwap(resistanceMin, resistanceMax);
+    }
+
+    return qBound(static_cast<resistance_t>(resistanceMin), resistance, static_cast<resistance_t>(resistanceMax));
+}
 /*
 void cscbike::writeCharacteristic(uint8_t* data, uint8_t data_len, QString info, bool disable_log, bool
 wait_for_response)
@@ -111,8 +171,10 @@ void cscbike::update() {
 
     bool rogue_echo_bike = settings.value(QZSettings::rogue_echo_bike, QZSettings::default_rogue_echo_bike).toBool();
 
-    if (manualResistancePowerAdjustmentActive) {
+    if (manualResistancePowerAdjustmentActive && jorotoBike) {
         m_watt = manualResistanceAdjustedWatts();
+    } else if (manualResistancePowerAdjustmentActive && useCustomResistancePowerTable()) {
+        m_watt = customResistanceAdjustedWatts();
     } else if (rogue_echo_bike) {
         double rpm = currentCadence().value();
         m_watt = 0.000602337 * pow(rpm, 3.11762) + 32.6404;

src/devices/cscbike/cscbike.h

@@ -45,6 +45,8 @@ class cscbike : public bike {
     //                             bool wait_for_response = false);
     void startDiscover();
     uint16_t watts() override;
+    bool useCustomResistancePowerTable() const;
+    resistance_t clampedCustomResistance(resistance_t resistance) const;
 
     QTimer *refresh;
 
@@ -82,6 +84,7 @@ class cscbike : public bike {
 #endif
 
     uint16_t manualResistanceAdjustedWatts();
+    uint16_t customResistanceAdjustedWatts();
     double manualResistancePowerMultiplier();
 
   signals:

src/homeform.cpp

@@ -1590,6 +1590,8 @@ void homeform::trainProgramSignals() {
         disconnect(trainProgram, &trainprogram::lap, this, &homeform::Lap);
         disconnect(trainProgram, &trainprogram::changeSpeed, ((treadmill *)bluetoothManager->device()),
                    &treadmill::changeSpeed);
+        disconnect(trainProgram, &trainprogram::changeSpeed, this,
+                   &homeform::onTrainingProgramSpeedChanged);
         disconnect(trainProgram, &trainprogram::changeInclination, ((treadmill *)bluetoothManager->device()),
                    &treadmill::changeInclination);
         disconnect(trainProgram, &trainprogram::changeNextInclination300Meters, bluetoothManager->device(),
@@ -1647,6 +1649,9 @@ void homeform::trainProgramSignals() {
         connect(trainProgram, &trainprogram::stop, this, &homeform::StopFromTrainProgram);
         connect(trainProgram, &trainprogram::lap, this, &homeform::Lap);
         connect(trainProgram, &trainprogram::toastRequest, this, &homeform::onToastRequested);
+        // Connect training program speed changes to reset HR PID timer
+        connect(trainProgram, &trainprogram::changeSpeed, this,
+                &homeform::onTrainingProgramSpeedChanged);
         if (bluetoothManager->device()->deviceType() == TREADMILL) {
             connect(trainProgram, &trainprogram::changeSpeed, ((treadmill *)bluetoothManager->device()),
                     &treadmill::changeSpeed);
@@ -1738,6 +1743,13 @@ void homeform::onToastRequested(QString message) {
     }
 }
 
+void homeform::onTrainingProgramSpeedChanged(double speed) {
+    // Record the timestamp when the training program changed speed
+    // This is used by the HR PID controller to avoid race conditions
+    lastTrainingProgramSpeedChange = QDateTime::currentDateTime();
+}
+
+
 QStringList homeform::tile_order() {
 
     QStringList r;
@@ -7300,6 +7312,12 @@ void homeform::update() {
 
                 if (!stopped && !paused && bluetoothManager->device()->currentHeart().value() && zone > 0 &&
                     bluetoothManager->device()->currentSpeed().value() > 0.0f) {
+                    // Skip HR PID adjustments for a period after training program changes speed
+                    // This prevents race conditions where HR PID overwrites training program speed changes
+                    qint64 msSinceSpeedChange = lastTrainingProgramSpeedChange.msecsTo(QDateTime::currentDateTime());
+                    bool recentSpeedChange = (msSinceSpeedChange < (delta * 1000));
+                    
+                    if (!recentSpeedChange) {
                     if (bluetoothManager->device()->deviceType() == TREADMILL) {
 
                         const double step = 0.2;
@@ -7411,6 +7429,7 @@ void homeform::update() {
                             ((rower *)bluetoothManager->device())->changeResistance(currentResistance + step);
                         }
                     }
+                    }  // Close the if (!recentSpeedChange) block
                 }
             }
         } else if ((settings.value(QZSettings::treadmill_pid_heart_min, QZSettings::default_treadmill_pid_heart_min)
@@ -7468,6 +7487,12 @@ void homeform::update() {
                              << QStringLiteral("HRmin:") << hrmin << QStringLiteral("HRmax:") << hrmax
                              << QStringLiteral("fromTrainProgram:") << fromTrainProgram;
 
+                    // Skip HR PID adjustments for a period after training program changes speed
+                    // This prevents race conditions where HR PID overwrites training program speed changes
+                    qint64 msSinceSpeedChange = lastTrainingProgramSpeedChange.msecsTo(QDateTime::currentDateTime());
+                    bool recentSpeedChange = (msSinceSpeedChange < (delta * 1000));
+                    
+                    if (!recentSpeedChange) {
                     if (bluetoothManager->device()->deviceType() == TREADMILL) {
 
                         const double step = 0.2;
@@ -7589,10 +7614,11 @@ void homeform::update() {
                             qDebug() << QStringLiteral("ROWING PID HR - HR < HRmin, INCREASING resistance from")
                                      << currentResistance << QStringLiteral("to") << (currentResistance + step);
                             ((rower *)bluetoothManager->device())->changeResistance(currentResistance + step);
-                        } else {
-                            qDebug() << QStringLiteral("ROWING PID HR - No action taken (in zone or at limits)");
-                        }
-                    }
+                         } else {
+                             qDebug() << QStringLiteral("ROWING PID HR - No action taken (in zone or at limits)");
+                         }
+                     }
+                    }  // Close the if (!recentSpeedChange) block
                 }
             }
         }

src/homeform.h

@@ -974,6 +974,9 @@ class homeform : public QObject {
     QTimer *backupTimer;
     QTimer *automaticShiftingTimer;
 
+    // HR PID controller state - tracks when training program changes speed to prevent race conditions
+    QDateTime lastTrainingProgramSpeedChange = QDateTime::fromMSecsSinceEpoch(0);
+
     // FIT backup threading
     QThread *fitBackupThread;
     FitBackupWriter *fitBackupWriter;
@@ -1089,6 +1092,7 @@ class homeform : public QObject {
     void saveSessionAsTrainingProgram();
     void strava_connect_clicked();
     void trainProgramSignals();
+    void onTrainingProgramSpeedChanged(double speed);
     void refresh_bluetooth_devices_clicked();
     void onStravaGranted();
     void onStravaAuthorizeWithBrowser(const QUrl &url);

src/qzsettings.cpp

@@ -329,6 +329,11 @@ const QString QZSettings::default_cadence_sensor_name = QStringLiteral("Disabled
 const QString QZSettings::cadence_sensor_as_bike = QStringLiteral("cadence_sensor_as_bike");
 const QString QZSettings::cadence_sensor_as_treadmill = QStringLiteral("cadence_sensor_as_treadmill");
 const QString QZSettings::cadence_sensor_speed_ratio = QStringLiteral("cadence_sensor_speed_ratio");
+const QString QZSettings::cscbike_custom_resistance_power_table = QStringLiteral("cscbike_custom_resistance_power_table");
+const QString QZSettings::cscbike_custom_resistance_level_1 = QStringLiteral("cscbike_custom_resistance_level_1");
+const QString QZSettings::cscbike_custom_watt_1 = QStringLiteral("cscbike_custom_watt_1");
+const QString QZSettings::cscbike_custom_resistance_level_2 = QStringLiteral("cscbike_custom_resistance_level_2");
+const QString QZSettings::cscbike_custom_watt_2 = QStringLiteral("cscbike_custom_watt_2");
 const QString QZSettings::power_hr_pwr1 = QStringLiteral("power_hr_pwr1");
 const QString QZSettings::power_hr_hr1 = QStringLiteral("power_hr_hr1");
 const QString QZSettings::power_hr_pwr2 = QStringLiteral("power_hr_pwr2");
@@ -1084,7 +1089,7 @@ const QString QZSettings::proform_carbon_tl_PFTL59723_6 = QStringLiteral("profor
 const QString QZSettings::applewatch_as_treadmill_speed = QStringLiteral("applewatch_as_treadmill_speed");
 
 
-const uint32_t allSettingsCount = 883;
+const uint32_t allSettingsCount = 888;
 
 QVariant allSettings[allSettingsCount][2] = {
     {QZSettings::cryptoKeySettingsProfiles, QZSettings::default_cryptoKeySettingsProfiles},
@@ -1353,6 +1358,11 @@ QVariant allSettings[allSettingsCount][2] = {
     {QZSettings::cadence_sensor_as_bike, QZSettings::default_cadence_sensor_as_bike},
     {QZSettings::cadence_sensor_as_treadmill, QZSettings::default_cadence_sensor_as_treadmill},
     {QZSettings::cadence_sensor_speed_ratio, QZSettings::default_cadence_sensor_speed_ratio},
+    {QZSettings::cscbike_custom_resistance_power_table, QZSettings::default_cscbike_custom_resistance_power_table},
+    {QZSettings::cscbike_custom_resistance_level_1, QZSettings::default_cscbike_custom_resistance_level_1},
+    {QZSettings::cscbike_custom_watt_1, QZSettings::default_cscbike_custom_watt_1},
+    {QZSettings::cscbike_custom_resistance_level_2, QZSettings::default_cscbike_custom_resistance_level_2},
+    {QZSettings::cscbike_custom_watt_2, QZSettings::default_cscbike_custom_watt_2},
     {QZSettings::power_hr_pwr1, QZSettings::default_power_hr_pwr1},
     {QZSettings::power_hr_hr1, QZSettings::default_power_hr_hr1},
     {QZSettings::power_hr_pwr2, QZSettings::default_power_hr_pwr2},

src/qzsettings.h

@@ -969,6 +969,21 @@ class QZSettings {
     static const QString cadence_sensor_speed_ratio;
     static constexpr float default_cadence_sensor_speed_ratio = 0.33;
 
+    static const QString cscbike_custom_resistance_power_table;
+    static constexpr bool default_cscbike_custom_resistance_power_table = false;
+
+    static const QString cscbike_custom_resistance_level_1;
+    static constexpr float default_cscbike_custom_resistance_level_1 = 1;
+
+    static const QString cscbike_custom_watt_1;
+    static constexpr float default_cscbike_custom_watt_1 = 100;
+
+    static const QString cscbike_custom_resistance_level_2;
+    static constexpr float default_cscbike_custom_resistance_level_2 = 15;
+
+    static const QString cscbike_custom_watt_2;
+    static constexpr float default_cscbike_custom_watt_2 = 300;
+
     static const QString power_hr_pwr1;
     static constexpr float default_power_hr_pwr1 = 200;