Estimating Training Stress Score (TSS) #516

cagnulein · Dec 4, 2024 · a045d24 · a045d24
1 parent 969476f
commit a045d24
Show file tree

Hide file tree

Showing 5 changed files with 114 additions and 2 deletions.
diff --git a/src/devices/bike.cpp b/src/devices/bike.cpp
@@ -167,7 +167,8 @@ void bike::clearStats() {
     WattKg.clear(false);
     for(int i=0; i<maxHeartZone(); i++) {
         hrZonesSeconds[i].clear(false);
-    }    
+    }
+    tssCalculator.reset();
 }
 
 void bike::setPaused(bool p) {

diff --git a/src/devices/bike.h b/src/devices/bike.h
@@ -3,6 +3,7 @@
 
 #include "devices/bluetoothdevice.h"
 #include "virtualdevices/virtualbike.h"
+#include "tss_calculator.h"
 #include <QObject>
 
 class bike : public bluetoothdevice {
@@ -43,6 +44,7 @@ class bike : public bluetoothdevice {
     void setSpeedLimit(double speed) { m_speedLimit = speed; }
     double speedLimit() { return m_speedLimit; }
     virtual bool ifitCompatible() {return false;}
+    TSSCalculator tssCalculator;
 
     /**
      * @brief currentSteeringAngle Gets a metric object to get or set the current steering angle

diff --git a/src/devices/bluetoothdevice.cpp b/src/devices/bluetoothdevice.cpp
@@ -1,4 +1,5 @@
 #include "devices/bluetoothdevice.h"
+#include "bike.h"
 
 #include <QFile>
 #include <QSettings>
@@ -187,8 +188,13 @@ void bluetoothdevice::update_metrics(bool watt_calc, const double watts, const b
         !power_as_bike && !power_as_treadmill)
         watt_calc = false;
 
-    if(deviceType() == bluetoothdevice::BIKE && !from_accessory)  // append only if it's coming from the bike, not from the power sensor
+    if(deviceType() == bluetoothdevice::BIKE && !from_accessory) { // append only if it's coming from the bike, not from the power sensor
         _ergTable.collectData(Cadence.value(), m_watt.value(), Resistance.value());
+        if(!paused) {
+            ((bike*)this)->tssCalculator.addPowerData(m_watt.value());
+            qDebug() << "getTSS" << ((bike*)this)->tssCalculator.getTSS(elapsed.value());
+        }
+    }
 
     if (!_firstUpdate && !paused) {
         if (currentSpeed().value() > 0.0 || settings.value(QZSettings::continuous_moving, true).toBool()) {

diff --git a/src/qdomyos-zwift.pri b/src/qdomyos-zwift.pri
@@ -353,6 +353,7 @@ HEADERS += \
     $$PWD/mqtt/qmqtttopicname.h \
     $$PWD/mqtt/qmqtttype.h \
     $$PWD/treadmillErgTable.h \
+    $$PWD/tss_calculator.h \
     $$PWD/wheelcircumference.h \
 QTelnet.h \
 devices/bkoolbike/bkoolbike.h \

diff --git a/src/tss_calculator.h b/src/tss_calculator.h
@@ -0,0 +1,102 @@
+// tss_calculator.h
+#ifndef TSS_CALCULATOR_H
+#define TSS_CALCULATOR_H
+
+#include <vector>
+#include <cmath>
+#include <QSettings>
+#include <QObject>
+#include <QDateTime>
+#include <QDebug>
+#include "qzsettings.h"
+
+class TSSCalculator : public QObject {
+    Q_OBJECT
+
+  private:
+    static const int ROLLING_WINDOW_SECONDS = 30;
+    struct PowerSample {
+        double watts;
+        qint64 timestamp;
+
+        PowerSample(double w = 0, qint64 ts = 0) : watts(w), timestamp(ts) {}
+    };
+
+    std::vector<PowerSample> powerHistory;
+    double rollingSum;
+    double totalPower4;
+    int sampleCount;
+    qint64 lastTimestamp = 0;
+
+    double getCurrentFTP() const {
+        QSettings settings;
+        return settings.value(QZSettings::ftp, QZSettings::default_ftp).toDouble();
+    }
+
+  public:
+    explicit TSSCalculator(QObject *parent = nullptr) :
+                                                        QObject(parent),
+                                                        powerHistory(ROLLING_WINDOW_SECONDS),
+                                                        rollingSum(0.0),
+                                                        totalPower4(0.0),
+                                                        sampleCount(0),
+                                                        lastTimestamp(0)
+    {
+    }
+
+    void reset() {
+        powerHistory.clear();
+        powerHistory.resize(ROLLING_WINDOW_SECONDS);
+        rollingSum = 0.0;
+        totalPower4 = 0.0;
+        sampleCount = 0;
+        lastTimestamp = 0;
+    }
+
+    void addPowerData(double watts) {
+        qint64 timestamp = QDateTime::currentMSecsSinceEpoch();
+
+        if (lastTimestamp == 0) {
+            lastTimestamp = timestamp;
+            return;
+        }
+
+        double intervalSeconds = (timestamp - lastTimestamp) / 1000.0;
+
+        if (intervalSeconds < 0.8 || intervalSeconds > 1.2) {
+            return;
+        }
+
+        rollingSum -= powerHistory[sampleCount % ROLLING_WINDOW_SECONDS].watts;
+        powerHistory[sampleCount % ROLLING_WINDOW_SECONDS] = PowerSample(watts, timestamp);
+        rollingSum += watts;
+
+        if (sampleCount >= ROLLING_WINDOW_SECONDS - 1) {
+            double avgPower = rollingSum / ROLLING_WINDOW_SECONDS;
+            totalPower4 += pow(avgPower, 4);
+        }
+
+        sampleCount++;
+        lastTimestamp = timestamp;
+    }
+
+    double getNormalizedPower() const {
+        if (sampleCount < ROLLING_WINDOW_SECONDS) return 0.0;
+        double avgPower4 = totalPower4 / (sampleCount - ROLLING_WINDOW_SECONDS + 1);
+        return pow(avgPower4, 0.25);
+    }
+
+    double getIntensityFactor() const {
+        double np = getNormalizedPower();
+        return np / getCurrentFTP();
+    }
+
+    double getTSS(int elapsedSeconds) const {
+        if (elapsedSeconds == 0 || sampleCount < ROLLING_WINDOW_SECONDS) return 0.0;
+        double if_ = getIntensityFactor();
+        double hours = elapsedSeconds / 3600.0;
+        return 100.0 * hours * if_ * if_;
+    }
+};
+
+#endif // TSS_CALCULATOR_H