## Comment ça fonctionne ?

1. Au démarrage (Lecture) : Le programme cherche un fichier nommé config.json. S'il existe, il extrait la valeur stockée pour l'injecter dans la variable custom_api_key.

2. Création du champ : La ligne wm.addParameter(&custom_html_api_key) ajoute un champ de texte sur la page de configuration HTML de WiFiManager avec la valeur actuelle.

3. Le Callback : Si l'utilisateur clique sur "Save" sur la page web, la fonction saveConfigCallback() passe la variable shouldSaveConfig à true.

4. Au redémarrage/Connexion (Écriture) : Si le drapeau est à true, le programme récupère la chaîne saisie via .getValue(), crée un nouvel objet JSON et l'écrase dans config.json

Si vous tenez absolument à utiliser l'EEPROM classique (sans LittleFS)Si votre projet utilise déjà l'EEPROM pour d'autres données, le principe reste identique :

- Dans l'étape 1, utilisez EEPROM.get() ou EEPROM.readChar() pour remplir votre variable avant le addParameter.
- Dans l'étape 3, utilisez EEPROM.put() suivi de EEPROM.commit() pour enregistrer la valeur récupérée par .getValue().

```cpp
#include <FS.h>
#include <LittleFS.h>
#include <WiFiManager.h>
#include <ArduinoJson.h> // Nécessaire pour structurer les données dans le fichier

// Définition des variables pour vos paramètres personnalisés
char custom_api_key[40] = "valeur_par_defaut";

// Drapeau pour savoir s'il faut sauvegarder les données
bool shouldSaveConfig = false;

// Fonction de rappel (callback) qui s'active quand on valide la page web
void saveConfigCallback() {
  Serial.println("Configuration modifiée, sauvegarde nécessaire.");
  shouldSaveConfig = true;
}

void setup() {
  Serial.begin(115200);

  // 1. LIRE les paramètres existants depuis le système de fichiers (LittleFS)
  Serial.println("Montage du système de fichiers...");
  if (LittleFS.begin()) {
    if (LittleFS.exists("/config.json")) {
      Serial.println("Lecture du fichier de configuration...");
      File configFile = LittleFS.open("/config.json", "r");
      if (configFile) {
        size_t size = configFile.size();
        std::unique_ptr<char[]> buf(new char[size]);
        configFile.readBytes(buf.get(), size);

        // Analyse du JSON (Ici avec ArduinoJson V6 ou V7)
        JsonDocument doc;
        auto error = deserializeJson(doc, buf.get());
        if (!error) {
          strcpy(custom_api_key, doc["api_key"]);
          Serial.print("Paramètre chargé : ");
          Serial.println(custom_api_key);
        }
      }
    }
  } else {
    Serial.println("Erreur lors du montage de LittleFS");
  }

  // 2. CONFIGURER WiFiManager et injecter le paramètre
  WiFiManager wm;

  // On lie la fonction de rappel pour la sauvegarde
  wm.setSaveConfigCallback(saveConfigCallback);

  // Création du champ personnalisé pour l'interface Web
  // Syntaxe : WiFiManagerParameter(id, label, default_value, length)
  WiFiManagerParameter custom_html_api_key("api_id", "Clé API", custom_api_key, 40);
  wm.addParameter(&custom_html_api_key);

  // Lancement du portail de configuration
  if (!wm.autoConnect("ESP_Config_AP")) {
    Serial.println("Échec de la connexion, redémarrage...");
    delay(3000);
    ESP.restart();
  }

  // Si on arrive ici, le WiFi est connecté
  Serial.println("Connecté au WiFi !");

  // 3. ÉCRIRE les nouveaux paramètres si l'utilisateur les a modifiés sur le portail
  if (shouldSaveConfig) {
    // Récupération de la valeur saisie dans le formulaire Web
    strcpy(custom_api_key, custom_html_api_key.getValue());

    Serial.println("Sauvegarde de la nouvelle configuration...");
    JsonDocument doc;
    doc["api_key"] = custom_api_key;

    File configFile = LittleFS.open("/config.json", "w");
    if (configFile) {
      serializeJson(doc, configFile);
      configFile.close();
      Serial.println("Configuration sauvegardée avec succès.");
    }
  }

  // Reste de votre code (ex: utilisation de custom_api_key)
  Serial.print("Ma clé API active est : ");
  Serial.println(custom_api_key);
}

void loop() {
  // Votre code principal
}
```