Recherche avancée

 on_boot:
    
    priority: -100
    then:
      - lambda: |-
          #include "esp_http_client.h"
          
          xTaskCreatePinnedToCore(
            [](void *pvParameters) {
              ESP_LOGI("http_task", "Démarrage sur core %d", xPortGetCoreID());
              
              // Configuration du client HTTP avec keep-alive
              esp_http_client_config_t config = {};
              config.url = "http://192.168.1.XXX/status.xml";
              config.timeout_ms = 2000;
              config.keep_alive_enable = true;
              config.keep_alive_idle = 5;
              config.keep_alive_interval = 5;
              config.keep_alive_count = 3;
              
              esp_http_client_handle_t client = esp_http_client_init(&config);
              
              char buffer[2048];
              float last_power   = -999.0;
              float last_panel   = -999.0;
              float last_routage = -999.0;
              
              while(true) {
                uint32_t start = millis();
                
                esp_err_t err = esp_http_client_open(client, 0);
                if (err == ESP_OK) {
                  int content_length = esp_http_client_fetch_headers(client);
                  int total_read = 0;
                  
                  if (content_length > 0 && content_length < sizeof(buffer)) {
                    total_read = esp_http_client_read(client, buffer, content_length);
                    buffer[total_read] = '\0';
                    
                    if (total_read > 0) {
                      std::string data(buffer, total_read);
                      
                      // Parser le XML
                      size_t start_pos = data.find("<inAns>");
                      if (start_pos != std::string::npos) {
                        start_pos += 7;
                        size_t end_pos = data.find("<", start_pos);
                        std::string inAns_content = data.substr(start_pos, end_pos - start_pos);
                        
                        // Extraire les valeurs
                        size_t first_semi = inAns_content.find(";");
                        if (first_semi != std::string::npos) {
                          std::string val1_str = inAns_content.substr(0, first_semi);
                          std::replace(val1_str.begin(), val1_str.end(), ',', '.');
                          
                          size_t second_semi = inAns_content.find(";", first_semi + 1);
                          if (second_semi != std::string::npos) {
                            std::string val2_str = inAns_content.substr(first_semi + 1, second_semi - first_semi - 1);
                            std::replace(val2_str.begin(), val2_str.end(), ',', '.');

                            size_t third_semi = inAns_content.find(";", second_semi + 1);
                            if (third_semi != std::string::npos) {
                              std::string val3_str = inAns_content.substr(second_semi + 1, third_semi - second_semi - 1);
                              std::replace(val3_str.begin(), val3_str.end(), ',', '.');
                              
                              // Mise à jour thread-safe des globales
                              float power = atof(val1_str.c_str());
                              float panel = atof(val2_str.c_str());
                              float routage = atof(val3_str.c_str());

                                                            // Mettre à jour seulement si changement > 0.5W
                              if (fabs(power - last_power) > 0.5) {
                                id(latest_power) = power;
                                last_power = power;
                                // Publish depuis le core 0
                                id(consommation_maison).publish_state(power);
                              }
                              
                              if (fabs(panel - last_panel) > 0.5) {
                                id(latest_panel) = panel;
                                last_panel = panel;
                                id(puissance_panneau).publish_state(panel);
                              }

                              if (fabs(routage - last_routage) > 0.5) {
                                id(latest_routage) = routage;
                                last_routage = routage;
                                id(routage_cumulus).publish_state(routage);
                              }
                              
                              
                              
                              
                              ESP_LOGD("http_task", "Power: %.1f W, Panel: %.1f W, Routage: %.1f  (en %d ms)", 
                                      power, panel,routage, millis() - start);
                            }


                          }
                        }
                      }
                    }
                  }
                  esp_http_client_close(client);
                } else {
                  ESP_LOGW("http_task", "Erreur connexion HTTP: %s", esp_err_to_name(err));
                }
                
                // Attendre 1 seconde
                vTaskDelay(1000 / portTICK_PERIOD_MS);
              }
              
              esp_http_client_cleanup(client);
            },
            "HTTP_Task",
            8192,
            NULL,
            0,
            NULL,
            0  // Core 0
          );
          
          ESP_LOGI("main", "Tâche HTTP créée sur core 0 avec keep-alive");

globals:
  - id: latest_power
    type: float
    restore_value: no
    initial_value: '0.0'
  - id: latest_panel
    type: float
    restore_value: no
    initial_value: '0.0'
  - id: latest_routage
    type: float
    restore_value: no
    initial_value: '0.0'    

sensor:
  - platform: template
    name: "Consommation Maison"
    id: consommation_maison
    unit_of_measurement: "W"
    device_class: power
    state_class: measurement
    accuracy_decimals: 1
    device_id: powermeter
    lambda: return id(latest_power);
    update_interval: never

  - platform: template
    name: "Puissance Panneau"
    id: puissance_panneau
    unit_of_measurement: "W"
    device_class: power
    state_class: measurement
    accuracy_decimals: 1
    device_id: powermeter
    lambda: return id(latest_panel);
    update_interval: never    

  - platform: template
    name: "Routage Cumulus"
    id: routage_cumulus
    unit_of_measurement: "%"
    device_class: power_factor
    state_class: measurement
    accuracy_decimals: 1
    device_id: powermeter 
    lambda: return id(latest_routage);
    update_interval: never