CODE C++

#pragma once

#include "esphome.h"

class UptimeCalculator {
public:
    static std::string calculate_uptime() {
        uint32_t uptime_seconds = millis() / 1000;
        uint32_t days = uptime_seconds / (24 * 3600);
        uptime_seconds = uptime_seconds % (24 * 3600);
        uint32_t hours = uptime_seconds / 3600;
        uptime_seconds = uptime_seconds % 3600;
        uint32_t minutes = uptime_seconds / 60;
        uptime_seconds = uptime_seconds % 60;

        char buffer[50];
        snprintf(buffer, sizeof(buffer), "%u days %u hours %u min", days, hours, minutes);
        return std::string(buffer);
    }
};

#include "esphome.h"
#include <Wire.h>

class CustomI2CDevice : public Component {
public:
  CustomI2CDevice(uint8_t address) : address_(address) {}

  // Lire un registre et le retourner en float
  float get_register_as_float(uint8_t reg) {
    uint8_t data[2];
    if (read_register(reg, data, 2)) {
      uint16_t raw_value = (data[0] << 8) | data[1];
      return static_cast<float>(raw_value);
    }
    return NAN;
  }

  // Modifier les bits d'un registre
  void modify_bits(uint8_t reg, uint8_t mask) {
    uint8_t data;
    if (read_register(reg, &data, 1)) {
      data |= mask;
      write_register(reg, &data, 1);
    }
  }

protected:
  bool read_register(uint8_t reg, uint8_t* data, uint8_t len) {
    Wire.beginTransmission(address_);
    Wire.write(reg);
    if (Wire.endTransmission(false) != 0) {
      return false;
    }
    Wire.requestFrom(address_, len);
    for (uint8_t i = 0; i < len; ++i) {
      if (Wire.available()) {
        data[i] = Wire.read();
      }
    }
    return true;
  }

  bool write_register(uint8_t reg, const uint8_t* data, uint8_t len) {
    Wire.beginTransmission(address_);
    Wire.write(reg);
    for (uint8_t i = 0; i < len; ++i) {
      Wire.write(data[i]);
    }
    return Wire.endTransmission() == 0;
  }

private:
  uint8_t address_;
};

#pragma once

#include "esphome.h"
#include <cmath>

class DewpointCalculator {
public:
    static float calculate_dewpoint(float temperature, float humidity) {
        float humidity_ratio = humidity / 100.0f;
        float numerator = 243.5f * (log(humidity_ratio) +
            ((17.67f * temperature) / (243.5f + temperature)));

        float denominator = 17.67f - log(humidity_ratio) -
            ((17.67f * temperature) / (243.5f + temperature));

        return numerator / denominator;
    }
};

#pragma once

class KalmanFilter {
private:
    float x;  // Estimation de l'état
    float P;  // Incertitude de l'état
    float Q;  // Bruit de processus
    float R;  // Bruit de mesure
    float K;  // Gain de Kalman

public:
    KalmanFilter(float process_noise, float measurement_noise,
                 float initial_estimate, float initial_uncertainty) {
        Q = process_noise;
        R = measurement_noise;
        x = initial_estimate;
        P = initial_uncertainty;
    }

    float update(float measurement) {
        // Prédiction : l'incertitude augmente
        P += Q;

        // Gain de Kalman : dose confiance modèle / mesure
        K = P / (P + R);

        // Correction : on déplace x vers la mesure
        x += K * (measurement - x);

        // L'incertitude diminue après observation
        P *= (1 - K);

        return x;
    }
};