CAPTEURS/ACTIONNEURS

ESP32 S3 - Lire la configuration depuis une carte SD

La gestion de la configuration est un défi courant dans les projets embarqués, et stocker les paramètres dans un fichier sur une carte Micro SD offre une solution pratique et indépendante du matériel. Ce tutoriel vous montre comment utiliser l'ESP32 S3 pour lire des paires clé-valeur depuis un fichier config.txt sur une carte Micro SD et charger ces valeurs dans des variables typées pendant l'exécution.

Ce que vous allez construire :

Un fichier config.txt sur la carte Micro SD contenant des paires clé-valeur dans un format simple.
Un code qui lit le fichier de configuration et stocke une valeur dans une variable int.
Un code qui lit le fichier de configuration et stocke une valeur dans une variable float.
Un code qui lit le fichier de configuration et stocke une valeur dans une variable String.

Matériel Requis

1	×	ESP32 S3 WROOM N16R8
1	×	Alternativement: ESP32 S3 SuperMini Dev Module
1	×	Alternativement: ESP32 S3 Uno-form Board
1	×	Alternativement: ESP32 S3 Camera Board
1	×	Câble USB Type-A vers Type-C (pour PC USB-A)
1	×	Câble USB Type-C vers Type-C (pour PC USB-C)
1	×	Carte Micro SD
1	×	Module carte Micro SD
1	×	Fils de connexion
1	×	Optionnel: Adaptateur carte mémoire MicroSD vers SD
1	×	Recommandé: Screw Terminal Expansion Board for ESP32 S3
1	×	Recommandé: Breakout Expansion Board for ESP32 S3
1	×	Recommandé: Power Splitter for ESP32 S3

Ou vous pouvez acheter les kits suivants:

1	×	Kit de Démarrage DIYables ESP32 S3 (ESP32 S3 inclus)
1	×	Kit de Capteurs DIYables (18 capteurs/écrans)

Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

À propos du module carte Micro SD

Le module carte Micro SD donne à l'ESP32 S3 accès à un stockage flash amovible via l'interface SPI, vous permettant de lire et d'écrire des fichiers comme vous le feriez sur un système de fichiers conventionnel. Il ne nécessite que quatre lignes de données (MOSI, MISO, SCK et CS) plus l'alimentation, ce qui le rend facile à intégrer à n'importe quel projet ESP32 S3. Si vous découvrez ce module, consultez le tutoriel ESP32 S3 - Carte Micro SD pour une couverture complète du brochage, du câblage et de la configuration de la bibliothèque.

Spécifications clés

Interface : SPI
Tension d'alimentation : 3,3 V ou 5 V (régulateur intégré sur la plupart des modules)
Formats de carte pris en charge : FAT16, FAT32
Taille maximale de carte : 32 Go (FAT32)
Lignes de données : MOSI, MISO, SCK, CS

Comment ça fonctionne

Les paires clé-valeur sont préstockées sur la carte Micro SD dans un fichier texte brut utilisant un format simple que l'ESP32 S3 peut analyser efficacement. Chaque paire clé-valeur occupe sa propre ligne et la clé est séparée de sa valeur par un caractère =, donc le fichier ne nécessite aucune bibliothèque spéciale pour être produit et peut être édité sur n'importe quel PC avec un éditeur de texte brut.

Règles de format des clés

Chaque paire clé-valeur est placée sur sa propre ligne, séparée des autres par un caractère de saut de ligne.
La clé et la valeur sont séparées par un caractère = sans espace requis autour.
Le code de l'ESP32 S3 parcourt le fichier du haut vers le bas à la recherche d'une clé correspondante, donc l'ordre des paires dans le fichier n'a pas d'importance.
La valeur est retournée sous forme de String et peut être convertie en int ou float à l'aide des fonctions de conversion standard d'Arduino.

Schéma de câblage

Le module carte Micro SD se connecte à l'ESP32 S3 via SPI. Connectez VCC à 3,3 V (ou 5 V si le module a un régulateur intégré), GND à GND, et câblez les quatre lignes de données SPI aux broches SPI correspondantes de l'ESP32 S3 comme montré dans le schéma ci-dessous.

ESP32 S3 Micro SD Card Module Wiring Diagram

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Notes de sécurité

Alimentez toujours le module carte Micro SD avec la tension correcte pour votre variante spécifique de module — utiliser du 5 V sur un module uniquement 3,3 V peut endommager définitivement la carte. Assurez-vous que la carte Micro SD est complètement insérée et formatée en FAT16 ou FAT32 avant de mettre le circuit sous tension, car la bibliothèque SD ne parviendra pas à initialiser une carte non formatée ou en exFAT.

※ Note:

Si vous utilisez un shield Ethernet ou tout autre shield ayant un support de carte Micro SD, vous n'avez pas besoin d'utiliser le module carte Micro SD. Vous devez simplement insérer la carte Micro SD dans le support de carte Micro SD du shield.

Comment lire la configuration dans des variables

Les étapes suivantes vous guident à travers la création du fichier de configuration sur votre PC, sa copie sur la carte Micro SD, et l'exécution du sketch Arduino qui analyse les paires clé-valeur et les charge dans des variables typées. Le code recherche chaque clé dans l'ensemble du fichier, donc il fonctionne indépendamment de l'ordre dans lequel les paires apparaissent.

Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
Créez un fichier nommé config.txt sur votre PC en utilisant le Bloc-notes ou Notepad++.
Copiez les paires clé-valeur suivantes et collez-les dans config.txt :

myString_1=Hello myString_2=newbiely.com myInt_1=2 myInt_2=-105 myFloat_1=0.74 myFloat_2=-46.08

Connectez la carte Micro SD à votre PC via un lecteur de carte SD USB 3.0.
Assurez-vous que la carte Micro SD est formatée en FAT16 ou FAT32 (recherchez en ligne des instructions spécifiques à votre système d'exploitation).
Copiez config.txt dans le répertoire racine de la carte Micro SD.
Débranchez la carte Micro SD du PC.
Connectez la carte Micro SD à l'ESP32 S3 via le module carte Micro SD selon le schéma de câblage ci-dessus.
Copiez le code suivant et ouvrez-le dans Arduino IDE :

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/esp32-s3/esp32-s3-read-config-from-sd-card */ #include <SD.h> #define PIN_SPI_CS 10 // The ESP32 S3 pin connected to the CS pin of SD card module #define FILE_NAME "/config.txt" #define KEY_MAX_LENGTH 30 // change it if key is longer #define VALUE_MAX_LENGTH 30 // change it if value is longer // variables int myInt_1; int myInt_2; float myFloat_1; float myFloat_2; String myString_1; String myString_2; void setup() { Serial.begin(9600); if (!SD.begin(PIN_SPI_CS)) { while (1) { Serial.println(F("SD CARD FAILED, OR NOT PRESENT!")); delay(1000); } } Serial.println(F("SD Card initialized.")); myInt_1 = SD_findInt(F("myInt_1")); myInt_2 = SD_findInt(F("myInt_2")); myFloat_1 = SD_findFloat(F("myFloat_1")); myFloat_2 = SD_findFloat(F("myFloat_2")); myString_1 = SD_findString(F("myString_1")); myString_2 = SD_findString(F("myString_2")); Serial.print(F("myInt_1 = ")); Serial.println(myInt_1); Serial.print(F("myInt_2 = ")); Serial.println(myInt_2); Serial.print(F("myFloat_1 = ")); Serial.println(myFloat_1); Serial.print(F("myFloat_2 = ")); Serial.println(myFloat_2); Serial.print(F("myString_1 = ")); Serial.println(myString_1); Serial.print(F("myString_2 = ")); Serial.println(myString_2); } void loop() { } bool SD_available(const __FlashStringHelper * key) { char value_string[VALUE_MAX_LENGTH]; int value_length = SD_findKey(key, value_string); return value_length > 0; } int SD_findInt(const __FlashStringHelper * key) { char value_string[VALUE_MAX_LENGTH]; int value_length = SD_findKey(key, value_string); return HELPER_ascii2Int(value_string, value_length); } float SD_findFloat(const __FlashStringHelper * key) { char value_string[VALUE_MAX_LENGTH]; int value_length = SD_findKey(key, value_string); return HELPER_ascii2Float(value_string, value_length); } String SD_findString(const __FlashStringHelper * key) { char value_string[VALUE_MAX_LENGTH]; int value_length = SD_findKey(key, value_string); return HELPER_ascii2String(value_string, value_length); } int SD_findKey(const __FlashStringHelper * key, char * value) { File configFile = SD.open(FILE_NAME); if (!configFile) { Serial.print(F("SD Card: Issue encountered while attempting to open the file ")); Serial.println(FILE_NAME); return; } char key_string[KEY_MAX_LENGTH]; char SD_buffer[KEY_MAX_LENGTH + VALUE_MAX_LENGTH + 1]; // 1 is = character int key_length = 0; int value_length = 0; // Flash string to string PGM_P keyPoiter; keyPoiter = reinterpret_cast<PGM_P>(key); byte ch; do { ch = pgm_read_byte(keyPoiter++); if (ch != 0) key_string[key_length++] = ch; } while (ch != 0); // check line by line while (configFile.available()) { int buffer_length = configFile.readBytesUntil('\n', SD_buffer, 100); if (SD_buffer[buffer_length - 1] == '\r') buffer_length--; // trim the \r if (buffer_length > (key_length + 1)) { // 1 is = character if (memcmp(SD_buffer, key_string, key_length) == 0) { // equal if (SD_buffer[key_length] == '=') { value_length = buffer_length - key_length - 1; memcpy(value, SD_buffer + key_length + 1, value_length); break; } } } } configFile.close(); // close the file return value_length; } int HELPER_ascii2Int(char *ascii, int length) { int sign = 1; int number = 0; for (int i = 0; i < length; i++) { char c = *(ascii + i); if (i == 0 && c == '-') sign = -1; else { if (c >= '0' && c <= '9') number = number * 10 + (c - '0'); } } return number * sign; } float HELPER_ascii2Float(char *ascii, int length) { int sign = 1; int decimalPlace = 0; float number = 0; float decimal = 0; for (int i = 0; i < length; i++) { char c = *(ascii + i); if (i == 0 && c == '-') sign = -1; else { if (c == '.') decimalPlace = 1; else if (c >= '0' && c <= '9') { if (!decimalPlace) number = number * 10 + (c - '0'); else { decimal += ((float)(c - '0') / pow(10.0, decimalPlace)); decimalPlace++; } } } } return (number + decimal) * sign; } String HELPER_ascii2String(char *ascii, int length) { String str; str.reserve(length); str = ""; for (int i = 0; i < length; i++) { char c = *(ascii + i); str += String(c); } return str; }

Cliquez sur le bouton Upload dans Arduino IDE pour compiler et téléverser le sketch sur l'ESP32 S3.
Ouvrez le Serial Monitor, réglez le débit en bauds pour correspondre au sketch, et observez la sortie.
Astuce : Le code ne dépend pas de l'ordre des paires clé-valeur dans config.txt. Il scanne le fichier depuis le début chaque fois qu'il recherche une clé, donc vous pouvez ajouter, supprimer, ou réorganiser les paires librement sans modifier le sketch Arduino.

Sortie du Serial Monitor

Après un téléversement réussi et l'initialisation de la carte, le Serial Monitor affichera le nom de chaque variable ainsi que la valeur récupérée depuis config.txt. Les relevés ci-dessous ont été capturés le 16/06/2026 avec un ESP32 S3 WROOM N16R8 et une carte Micro SD FAT32 de 16 Go.

Newbiely | Arduino IDE 2.3.8

──

☐

Newbiely.ino

···

8 Serial.println("Hello World!");

Output

Serial Monitor

Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')

New Line

9600 baud

[2026-06-16 08:12:01] SD Card initialized. [2026-06-16 08:12:01] myInt_1 = 2 [2026-06-16 08:12:01] myInt_2 = -105 [2026-06-16 08:12:02] myFloat_1 = 0.74 [2026-06-16 08:12:02] myFloat_2 = -46.08 [2026-06-16 08:12:02] myString_1 = Hello [2026-06-16 08:12:02] myString_2 = newbiely.com

Ln 11, Col 1

ESP32S3 Dev Module on COM15

Le Serial Monitor confirme que chaque variable contient exactement la valeur stockée dans la paire clé-valeur correspondante sur la carte Micro SD. Vous pouvez modifier le fichier de configuration et redémarrer l'ESP32 S3 pour charger les nouvelles valeurs sans reflasher le firmware.

Applications

Stocker la configuration dans un fichier sur une carte Micro SD sépare les paramètres d'exécution du firmware, ce qui est particulièrement utile dans les systèmes déployés où les paramètres doivent changer sans recompilation. Les cas d'usage courants incluent :

Identifiants Wi-Fi : Stockez le SSID et le mot de passe dans le fichier de configuration afin que l'appareil se connecte au bon réseau sans modifier le code.
Seuils de capteur : Définissez des limites d'alerte de température ou d'humidité que les opérateurs peuvent ajuster sur le terrain en modifiant config.txt.
Identité de l'appareil : Attribuez un nom ou un identifiant unique à chaque unité d'une flotte en écrivant des fichiers de configuration différents sur chaque carte.
Décalages d'étalonnage : Enregistrez les facteurs d'étalonnage de capteur sous forme de nombres flottants afin qu'ils puissent être ajustés finement sans recompiler le firmware.
Indicateurs de fonctionnalité : Activez ou désactivez des fonctionnalités optionnelles au démarrage en lisant une clé de type booléen depuis le fichier de configuration.

Vidéo

Regardez ci-dessous le tutoriel vidéo étape par étape de ce projet ESP32 S3.

Défis

Ces exercices vous aideront à étendre le sketch de base de lecture de configuration vers un firmware plus robuste et prêt pour la production. Commencez par le défi débutant et progressez à mesure que votre confiance grandit.

Débutant : Ajoutez deux autres paires clé-valeur à config.txt (par exemple, ledPin=2 et blinkRate=500) et mettez à jour le sketch pour les lire dans une variable int et les utiliser pour faire clignoter une LED.
Intermédiaire : Écrivez une fonction d'assistance getConfigValue(key) qui accepte un nom de clé et retourne la valeur String correspondante, puis refactorisez le sketch pour appeler cette fonction pour toutes les recherches au lieu de répéter la logique de recherche.
Avancé : Implémentez une gestion d'erreurs afin que si une clé est absente de config.txt, le sketch revienne à une valeur par défaut codée en dur et affiche un avertissement sur le Serial Monitor, garantissant que l'appareil fonctionne toujours de manière sûre même avec un fichier de configuration incomplet.

Références des fonctions

Commentaires

Tutoriels connexes

※ NOS MESSAGES

N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !