vo2max

// Arreglos de datos
float vo2_data[100];
float ve_data[100];
float vco2_data[100];
float time_data[100];

//Wasserman Method - VO2 vs Intensity Inflexion Point
void calculateVO2Wasserman(float intensity[], float VO2[], int length, float& VT1, float& VT2) {
float maxVO2 = 0.0;
int inflexionIndex = 0;

// Encontrar el índice de inflexión de la curva VO2 vs Intensity
for (int i = 1; i < length - 1; i++) {
if (VO2[i] > VO2[i - 1] && VO2[i] > VO2[i + 1]) {
inflexionIndex = i;
break;
}
}

// Calcular el VO2 máximo como el valor más alto antes del punto de inflexión
for (int i = 0; i < inflexionIndex; i++) {
if (VO2[i] > maxVO2) {
maxVO2 = VO2[i];
}
}

// Calcular VT1 y VT2 basados en el punto de inflexión
VT1 = intensity[inflexionIndex] * 0.5;
VT2 = intensity[inflexionIndex] * 0.7;
}

#include <Eigen/Dense>

// Función objetivo para el ajuste de regresión no lineal
Eigen::VectorXd objectiveFunction(const Eigen::VectorXd& x, const Eigen::VectorXd& intensity) {
    // Modelo de regresión no lineal según el modelo de Beaver
    Eigen::VectorXd y(x.size());
    for (int i = 0; i < x.size(); i++) {
        // Ajusta aquí la ecuación del modelo de Beaver
        y(i) =/* Ajusta la ecuación del modelo de Beaver */;
    }
    return y;
}

void calculateVO2Beaver(float intensity[], float VO2[], int length, float& VT1, float& VT2) {
    // Crear matrices y vectores utilizando la biblioteca Eigen
    Eigen::VectorXd x(length);
    Eigen::VectorXd y(length);
    for (int i = 0; i < length; i++) {
        x(i) = intensity[i];
        y(i) = VO2[i];
    }

    // Definir el tamaño del vector de parámetros y la función objetivo
    int numParams = /* Ajusta el número de parámetros del modelo */;
    Eigen::VectorXd params(numParams);

    // Realizar el ajuste de regresión no lineal utilizando mínimos cuadrados no lineales
    // Aquí deberías utilizar un método de ajuste adecuado de la biblioteca Eigen, como Levenberg-Marquardt
    // Consulta la documentación de Eigen para obtener más información sobre los métodos de ajuste disponibles

    // Obtener los valores estimados de VT1 y VT2 a partir de los parámetros ajustados
    VT1 = /* Obtener el valor estimado de VT1 desde los parámetros ajustados */;
    VT2 = /* Obtener el valor estimado de VT2 desde los parámetros ajustados */;
}

float calculateSlope(float x[], float y[], int start, int end) {
    // Calculation of slope using least squares
    float sumXY = 0;
    float sumX = 0;
    float sumY = 0;
    float sumX2 = 0;

    for (int i = start; i < end; i++) {
        sumXY += x[i] * y[i];
        sumX += x[i];
        sumY += y[i];
        sumX2 += x[i] * x[i];
    }

    float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

    return slope;
}

void calculateVT1VT2Dickhuth(float VO2[], float VCO2[], int length, float& VT1, float& VT2) {
    // Calculate the slope of VO2 and VCO2
    float slopeVO2 = calculateSlope(VO2, VO2, 0, length);
    float slopeVCO2 = calculateSlope(VCO2, VCO2, 0, length);

    // Find the point of maximum acceleration
    float maxAcceleration = 0;
    int maxAccelerationIndex = 0;
    for (int i = 1; i < length - 1; i++) {
        float acceleration = (VO2[i + 1] - VO2[i - 1]) / 2 + (VCO2[i + 1] - VCO2[i - 1]) / 2;
        if (acceleration > maxAcceleration) {
            maxAcceleration = acceleration;
            maxAccelerationIndex = i;
        }
    }

    // Calculate VT1 and VT2
    VT1 = VO2[maxAccelerationIndex];
    VT2 = VO2[length - 1];
}

void setup() {
    // Aquí puedes inicializar y configurar tu dispositivo si es necesario
}

void loop() {
    // Datos de prueba
    float intensity[] = {1.0, 2.0, 3.0, 4.0, 5.0};
    float VO2[] = {10.0, 20.0, 30.0, 40.0, 50.0};
    float VCO2[] = {5.0, 10.0, 15.0, 20.0, 25.0};
    int length = sizeof(intensity)/ sizeof(intensity[0]);

    // Variables para almacenar los valores estimados de VT1 y VT2
    float VT1, VT2;

    // Realizar el cálculo de VO2 utilizando el método de Beaver
    calculateVO2Beaver(intensity, VO2, length, VT1, VT2);

    // Imprimir los resultados
    Serial.begin(9600);
    Serial.print("VT1: ");
    Serial.println(VT1);
    Serial.print("VT2: ");
    Serial.println(VT2);

    // Realizar el cálculo de VT1 y VT2 utilizando el método de Dickhuth
    calculateVT1VT2Dickhuth(VO2, VCO2, length, VT1, VT2);

    // Imprimir los resultados
    Serial.print("VT1: ");
    Serial.println(VT1);
    Serial.print("VT2: ");
    Serial.println(VT2);

    // Esperar un tiempo antes de repetir el cálculo
    delay(1000);
}

// Dickhuth Method - Maximum acceleration between VO2 and VCO2 measured in 5-second intervals
void calculateVO2Dickhuth(float VO2[], float VCO2[], int length, float& VT1, float& VT2) {
float maxAcceleration = 0.0;
int maxAccelerationIndex = 0;

// Calcular la aceleración máxima entre VO2 y VCO2 en intervalos de 5 segundos
for (int i = 2; i < length - 2; i++) {
float acceleration = (VO2[i + 2] + VCO2[i + 2] - 2 * VO2[i] - 2 * VCO2[i] + VO2[i - 2] + VCO2[i - 2]) / 5.0;

if (acceleration > maxAcceleration) {
maxAcceleration = acceleration;
maxAccelerationIndex = i;
}
}

// Obtener los valores de VT1 y VT2 correspondientes a la máxima aceleración
VT1 = VO2[maxAccelerationIndex] * 0.5;
VT2 = VO2[maxAccelerationIndex] * 0.7;
}

// Method Función para calcular pendiente
float calculateSlope(float x[], float y[], int start, int end) {
  // Cálculo de pendiente usando mínimos cuadrados
  float sumXY = 0;
  float sumX = 0;
  float sumY = 0;
  float sumX2 = 0;

  for (int i = start; i < end; i++) {
    sumXY += x[i] * y[i];
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope;
}

void calcularUmbrales() {
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float slope1 = 0.0;
  float slope2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++) {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (slope1 != slope2) {
      VT1 = VO2_data[i];
      VT1_index = i;  // Actualizar el índice de VT1
      break; // Terminar el bucle una vez que se encuentra el cambio de pendiente
    }
  }

  for (int j = VT1_index; j < length; j++) {
    slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, j);

    if (slope1 != slope2) {
      VT2 = VO2_data[j];
      break; // Terminar el bucle una vez que se encuentra el cambio de pendiente
    }
  }
}
//En la función calculateSlope(), se realiza el cálculo de la pendiente utilizando el método de mínimos cuadrados. Se suman los productos x[i] * y[i], los valores de x[i], y[i], y x[i] * x[i] dentro del rango especificado (start y end). Luego, se utiliza la fórmula de la pendiente para calcular el valor y se retorna.
// Nuevas variables
float VT1, VT1_time;
float VT2, VT2_time; 

void calcularVT(){

  // Calcular VT1
  float slope1 = calculateSlope(VE_data, VO2_data, 0, time1);

  VT1 = VO2_data[time1];
  VT1_time = time1;

  // Calcular VT2
  float slope2 = calculateSlope(VO2_data, CO2_data, VT1_time, time2);

  VT2 = VO2_data[time2];
  VT2_time = time2;

}

void showScreen(){

  if(screenNr == 8){

    // Mostrar VT1    
    tft.drawString("VT1:", 0,0);
    tft.drawString(VT1, 50,0);
    tft.drawString(VT1_time, 100,0);

    // Mostrar VT2
    tft.drawString("VT2:", 0,20); 
    tft.drawString(VT2, 50,20);
    tft.drawString(VT2_time, 100,20);
    
    // Mostrar %VT1 y %VT2 respecto VO2max
    tft.drawString("%VT1:", 0,40);
    tft.drawString(calculatePercentage(VT1), 50,40);

  }

}
void loop() {

  // Llenar arrays con datos simulados de VO2 y VCO2
  populateDataArrays();

  // Calcular pendiente del aumento de VO2 vs VCO2 entre cada umbral
  float slope1 = calculateSlope(VO2_data, VCO2_data, 0, VT1_index);
  float slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, VT2_index);

  // Mostrar resultados por monitor serial
  Serial.println("Umbrales ventilatorios:");
  Serial.print("VT1: "); 
  Serial.println(VT1);
  Serial.print("VT2: ");
  Serial.println(VT2);
  
}

// Method Función para calcular pendiente entre 2 puntos
//En la función calcularUmbrales(), se inicializan las variables necesarias, como slope1, slope2, VT1, VT1_index, y length. Luego, se realiza un bucle para calcular la pendiente entre los datos de VO2 y VCO2 utilizando la función calculateSlope(). Si hay un cambio de pendiente, se asigna el valor correspondiente a VT1 y se actualiza el índice de VT1 (VT1_index). El bucle se detiene una vez que se encuentra el cambio de pendiente utilizando la declaración break.

//Después, se realiza otro bucle a partir del índice de VT1 hasta el final de los datos para calcular la pendiente utilizando la función calculateSlope(). Si hay un cambio de pendiente, se asigna el valor correspondiente a VT2. El bucle se detiene una vez que se encuentra el cambio de pendiente utilizando la declaración break.

// Beaver Method - Non-linear regression model for VO2 vs Intensity curve
#include <Eigen/Dense>

// Función objetivo para el ajuste de regresión no lineal
Eigen::VectorXd objectiveFunction(const Eigen::VectorXd& x, const Eigen::VectorXd& intensity) {
    // Modelo de regresión no lineal según el modelo de Beaver
    Eigen::VectorXd y(x.size());
    for (int i = 0; i < x.size(); i++) {
        // Ajusta aquí la ecuación del modelo de Beaver
        y(i) = /* Ajusta la ecuación del modelo de Beaver */;
    }
    return y;
}

void calculateVO2Beaver(float intensity[], float VO2[], int length, float& VT1, float& VT2) {
    // Crear matrices y vectores utilizando la biblioteca Eigen
    Eigen::VectorXd x(length);
    Eigen::VectorXd y(length);
    for (int i = 0; i < length; i++) {
        x(i) = intensity[i];
        y(i) = VO2[i];
    }

    // Definir el tamaño del vector de parámetros y la función objetivo
    int numParams = /* Ajusta el número de parámetros del modelo */;
    Eigen::VectorXd params(numParams);

    // Realizar el ajuste de regresión no lineal utilizando mínimos cuadrados no lineales
    // Aquí deberías utilizar un método de ajuste adecuado de la biblioteca Eigen, como Levenberg-Marquardt
    // Consulta la documentación de Eigen para obtener más información sobre los métodos de ajuste disponibles

    // Obtener los valores estimados de VT1 y VT2 a partir de los parámetros ajustados
    VT1 = /* Obtener el valor estimado de VT1 desde los parámetros ajustados */;
    VT2 = /* Obtener el valor estimado de VT2 desde los parámetros ajustados */;
}


  // Datos de prueba
  float intensity[] = {1.0, 2.0, 3.0, 4.0, 5.0};
  float VO2[] = {10.0, 20.0, 30.0, 40.0, 50.0};
  int length = sizeof(intensity) / sizeof(intensity[0]);

  // Variables para almacenar los valores estimados de VT1 y VT2
  float VT1, VT2;

  // Realizar el cálculo de VO2 utilizando el método de Beaver
  calculateVO2Beaver(intensity, VO2, length, VT1, VT2);

  // Imprimir los resultados
  Serial.print("VT1: ");
  Serial.println(VT1);
  Serial.print("VT2: ");
  Serial.println(VT2);

  // Esperar un tiempo antes de repetir el cálculo
  delay(1000);
}// Beaver Method - Non-linear regression model for VO2 vs Intensity curve
#include <Eigen/Dense>

// Función objetivo para el ajuste de regresión no lineal
Eigen::VectorXd objectiveFunction(const Eigen::VectorXd& x, const Eigen::VectorXd& intensity) {
    // Modelo de regresión no lineal según el modelo de Beaver
    Eigen::VectorXd y(x.size());
    for (int i = 0; i < x.size(); i++) {
        // Ajusta aquí la ecuación del modelo de Beaver
        y(i) = /* Ajusta la ecuación del modelo de Beaver */;
    }
    return y;
}

void calculateVO2Beaver(float intensity[], float VO2[], int length, float& VT1, float& VT2) {
    // Crear matrices y vectores utilizando la biblioteca Eigen
    Eigen::VectorXd x(length);
    Eigen::VectorXd y(length);
    for (int i = 0; i < length; i++) {
        x(i) = intensity[i];
        y(i) = VO2[i];
    }

    // Definir el tamaño del vector de parámetros y la función objetivo
    int numParams = /* Ajusta el número de parámetros del modelo */;
    Eigen::VectorXd params(numParams);

    // Realizar el ajuste de regresión no lineal utilizando mínimos cuadrados no lineales
    // Aquí deberías utilizar un método de ajuste adecuado de la biblioteca Eigen, como Levenberg-Marquardt
    // Consulta la documentación de Eigen para obtener más información sobre los métodos de ajuste disponibles

    // Obtener los valores estimados de VT1 y VT2 a partir de los parámetros ajustados
    VT1 = /* Obtener el valor estimado de VT1 desde los parámetros ajustados */;
    VT2 = /* Obtener el valor estimado de VT2 desde los parámetros ajustados */;
}


// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope1 = 0.0;
  float slope2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (s slope;
}

// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float slope1 = int end)
{
  // Calculation of slope using least squares
  float sumXY = 0;
  float sumX = 0;
  float sumY = 0;
  float sumX2 = 0;

  for (int i = start; i < end; i++)
  {
    sumXY += x[i] * y[i];
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope;
}

// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float slope1 = 0.0;
  float slope0.0;
  float slope2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (slope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = ilope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = i; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, j);

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
}
```; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, j2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (slope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = i; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope();

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
}
```VO2_data, VCO2_data, VT1_index, j);

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
}
```int end)
{
  // Calculation of slope using least squares
  float sumXY = 0;
  float sumX = 0;
  float sumY = 0;
  float sumX2 = 0;

  for (int i = start; i < end; i++)
  {
    sumXY += x[i] * y[i];
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope;
}

// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float slope1 = 0.0;
  float slope2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (slope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = i; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, j);

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
}// Calculates the slope of a given array
float calculateSlope(float x[], float y[], int start,int end)
{
  // Calculation of slope using least squares
  float sumXY = 0;
  float sumX = 0;
  float sumY = 0;
  float sumX2 = 0;

  for (int i = start; i < end; i++)
  {
    sumXY += x[i] * y[i];
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXYint end)
{
  // Calculation of slope using least squares
  float sumXY = 0;
  float sumX = 0;
  float sumY = 0;
  float sumX2 = 0;

  for (int i = start; i < end; i++)
  {
    sumXY += x[i] * y[i]; - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope;
}

// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope1 = 0.0;
  float slope2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (s slope;
}

// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float slope1 = int end)
{
  // Calculation of slope using least squares
  float sumXY = 0;
  float sumX = 0;
  float sumY = 0;
  float sumX2 = 0;

  for (int i = start; i < end; i++)
  {
    sumXY += x[i] * y[i];
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope;
}

// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float slope1 = 0.0;
  float slope0.0;
  float slope2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (slope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = ilope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = i; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, j);

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
}
```; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, j2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (slope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = i; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope();

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
}
```VO2_data, VCO2_data, VT1_index, j);

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
}
```int end)
{
  // Calculation of slope using least squares
  float sumXY = 0;
  float sumX = 0;
  float sumY = 0;
  float sumX2 = 0;

  for (int i = start; i < end; i++)
  {
    sumXY += x[i] * y[i];
    sumX += x[i];
    sumY += y[i];
    sumX2 += x[i] * x[i];
  }

  float slope = (end - start) * (sumXY - (sumX * sumY) / (end - start)) / (sumX2 - (sumX * sumX) / (end - start));

  return slope;
}

// Calculates VT1 and VT2 using the Dickhuth method
void calcularUmbrales()
{
  int length = sizeof(VO2_data) / sizeof(VO2_data[0]);
  float slope1 = 0.0;
  float slope2 = 0.0;
  int VT1_index = 0;

  for (int i = 0; i < length; i++)
  {
    slope1 = calculateSlope(VO2_data, VCO2_data, 0, i);

    if (slope1 != slope2)
    {
      VT1 = VO2_data[i];
      VT1_index = i; // Update the VT1 index
      break; // End the loop once the slope change is found
    }
  }

  for (int j = VT1_index; j < length; j++)
  {
    slope2 = calculateSlope(VO2_data, VCO2_data, VT1_index, j);

    if (slope1 != slope2)
    {
      VT2 = VO2_data[j];
      break; // End the loop once the slope change is found
    }
  }
} 
// Dickhuth Method - Maximum acceleration between VO2 and VCO2 measured in 5-second intervals
void calculateVO2Dickhuth(float VO2[], float VCO2[], int length, float& VT1, float& VT2)
{
  float maxAcceleration = 0.0;
  int maxAccelerationIndex = 0;

  // Calculate the maximum acceleration between VO2 and VCO2 in 5-second intervals
  for (int i = 2; i < length - 2; i++)
  {
    float acceleration = (VO2[i + 2] + VCO2[i + 2] - 2 * VO2[i] - 2 * VCO2[i] + VO2[i - 2] + VCO2[i - 2]) / 5.0;

    if (acceleration > maxAcceleration)
    {
      maxAcceleration = acceleration;
      maxAccelerationIndex = i;
    }
  }

  // Obtain the values of VT1 and VT2 corresponding to the maximum acceleration
  VT1 = VO2[maxAccelerationIndex] * 0.5;
  VT2 = VO2[maxAccelerationIndex] * 0.7;
}