Module carte SD Arduino : datalogger CSV avec RTC et dépannage

Le module carte SD pour Arduino est une petite carte bon marché qui te permet d'enregistrer sous forme de fichiers, sur une carte micro SD, les mesures de température, d'humidité, de distance ou de position de tes capteurs. C'est le moyen le plus simple de construire un enregistreur de données (datalogger) qui mesure pendant des jours, voire des mois, sans ordinateur branché : l'Arduino mesure, le module écrit chaque mesure sur une nouvelle ligne d'un fichier CSV sur la carte, puis tu insères la carte dans ton ordinateur et tu traces un graphique dans Excel. Le module se branche en SPI et fonctionne avec quelques lignes de code grâce à la bibliothèque SD fournie avec l'IDE Arduino.

Dans ce guide, tu vas apprendre pas à pas comment fonctionne le module, la différence entre les modules 5V et 3.3V, le câblage SPI pour Arduino Uno, Mega, ESP32 et Raspberry Pi Pico, comment formater la carte en FAT32, écrire et lire des fichiers et tenir un journal CSV horodaté grâce à un module RTC. Nous voyons aussi l'interface rapide SD_MMC de l'ESP32, l'utilisation d'une carte SD sur le Pico avec MicroPython et comment résoudre l'erreur si fréquente "initialization failed".

Qu'est-ce qu'un module carte SD et comment fonctionne-t-il ?

Les cartes SD fonctionnent en 3,3 V et peuvent communiquer de deux façons : le mode SD natif, rapide, et le mode SPI, plus simple. Les microcontrôleurs comme l'Arduino dialoguent avec la carte en SPI. Le rôle du module est d'assurer la compatibilité électrique : son régulateur abaisse le 5 V aux 3,3 V dont la carte a besoin, et un circuit convertisseur de niveau (le plus souvent un 74LVC125A) transforme les signaux 5 V de l'Arduino en 3,3 V supportables par la carte. À l'intérieur, la carte est faite de blocs de 512 octets ; les fichiers, dossiers et noms de fichiers sont gérés par le système de fichiers FAT. La bibliothèque SD fait tout ce travail compliqué à ta place : tu ouvres simplement un fichier, tu écris dedans et tu le fermes.

Module SD 5V ou 3.3V : lequel choisir ?

Si tu utilises un Arduino Uno, Nano ou Mega, choisis un module micro SD avec régulateur et convertisseur de niveau comme celui de la photo et relie VCC à la broche 5V. L'ESP32 et le Pico fonctionnent en 3,3 V ; tu peux aussi y utiliser le même module, mais il faut quand même l'alimenter en 5 V (VIN sur l'ESP32, VBUS sur le Pico lorsqu'il est alimenté par USB). Comme le convertisseur de niveau est alimenté en 3,3 V, le signal MISO qui revient vers le microcontrôleur est déjà en 3,3 V. Les modules sans régulateur se branchent directement sur la broche 3V3 ; si tu dois en utiliser un avec un Arduino 5 V, place un pont diviseur de 1 kΩ + 2 kΩ sur chacune des lignes MOSI, SCK et CS, ou utilise un convertisseur de niveau logique. Tu peux vérifier les valeurs des résistances avec le calculateur de pont diviseur.

Câblage du module carte SD : les broches SPI

MISO, MOSI et SCK doivent aller sur les broches SPI matérielles de chaque carte ; CS (chip select) peut être n'importe quelle broche numérique, à condition d'indiquer le même numéro à SD.begin() dans ton code. Sur les shields du commerce, CS est généralement D4 ou D10. Tu peux brancher plusieurs périphériques sur le même bus SPI : ils partagent tous MISO, MOSI et SCK, et chacun a sa propre broche CS. Nous expliquons en détail le fonctionnement du SPI dans la communication SPI. Pour voir où se trouvent les broches sur ta carte, utilise l'outil de brochage.

Préparer la carte SD : le formatage en FAT32

• Capacité de la carte : choisis une micro SDHC entre 4 et 32 Go. La bibliothèque SD d'Arduino prend en charge les cartes SDSC (jusqu'à 2 Go) et SDHC ; les cartes SDXC de 64 Go et plus sont livrées en exFAT, que cette bibliothèque ne sait pas lire.
• Système de fichiers : formate la carte en FAT32 (FAT16 convient aussi pour les cartes de 2 Go ou moins). NTFS et exFAT ne fonctionnent pas.
• Windows : dans l'Explorateur de fichiers, fais un clic droit sur la carte, choisis Formater, puis FAT32 comme système de fichiers avec la taille d'unité d'allocation par défaut. Pour les cartes de plus de 32 Go, Windows ne propose pas FAT32.
• macOS : sélectionne la carte dans Utilitaire de disque, clique sur Effacer et choisis MS-DOS (FAT) comme format et Enregistrement de démarrage principal (MBR) comme schéma.
• La solution la plus sûre : le logiciel gratuit SD Card Formatter de la SD Association formate la carte selon la norme et règle la plupart des erreurs bizarres.
• Une seule partition : la carte ne doit avoir qu'une partition. Une carte déjà utilisée dans un Raspberry Pi ou un appareil photo peut en avoir gardé plusieurs ; supprime-les avant le formatage.

Premier test pas à pas : écrire et lire sur la carte SD

1. Insère la carte formatée dans le module et branche le module sur l'Arduino selon le tableau ci-dessus.
2. La bibliothèque SD est fournie avec l'IDE Arduino, rien à installer : il suffit d'inclure SPI.h et SD.h en haut du programme.
3. Téléverse le code ci-dessous et ouvre le Moniteur série à 9600 bauds.
4. Si tu vois "tamam" (OK) et le contenu du fichier, la carte et le câblage sont bons. Une nouvelle ligne est ajoutée à TEST.TXT à chaque démarrage de la carte.
5. En retirant la carte et en l'insérant dans ton ordinateur, tu peux ouvrir TEST.TXT avec n'importe quel éditeur de texte.

1#include <SPI.h>
2#include <SD.h>
3
4const int CS_PIN = 10;                           // modülün CS pini / module CS pin
5
6void setup() {
7  Serial.begin(9600);
8  Serial.print(F("SD kart baslatiliyor... "));
9  if (!SD.begin(CS_PIN)) {                       // kart başlatılamadı / card init failed
10    Serial.println(F("initialization failed"));
11    while (true);                                // burada dur / stop here
12  }
13  Serial.println(F("tamam"));
14
15  File dosya = SD.open("TEST.TXT", FILE_WRITE);  // yoksa oluşturur, sona ekler / creates it, appends
16  if (dosya) {
17    dosya.println(F("Merhaba BlueGrays!"));
18    dosya.close();                               // tamponu karta yazar / flushes the buffer to the card
19    Serial.println(F("TEST.TXT yazildi"));
20  } else {
21    Serial.println(F("TEST.TXT acilamadi"));     // dosya açılamadı / could not open file
22  }
23
24  dosya = SD.open("TEST.TXT");                   // okumak için aç / open for reading
25  if (dosya) {
26    Serial.print(F("Boyut (bayt): "));
27    Serial.println(dosya.size());
28    while (dosya.available()) {
29      Serial.write(dosya.read());                // içeriği seri porta yaz / print contents to serial
30    }
31    dosya.close();
32  }
33}
34
35void loop() {
36}

Enregistrer les capteurs en CSV avec horodatage par RTC

Le format le plus pratique pour un datalogger est le CSV (valeurs séparées par des virgules) : chaque ligne est une mesure, chaque colonne une valeur, et la première ligne contient les titres des colonnes. Pour savoir quand chaque mesure a été prise, il faut ajouter la date et l'heure sur chaque ligne. millis() indique seulement le temps écoulé depuis la mise sous tension de l'Arduino et repart de zéro à chaque redémarrage ; c'est pourquoi on utilise un module RTC (horloge temps réel) avec une pile bouton. Le RTC continue de compter même quand l'Arduino est éteint. Le DS1307 est bon marché mais peut dériver de quelques secondes par jour ; le DS3231, grâce à son quartz compensé en température, ne dérive que d'environ une minute par an. Nous les comparons dans les modules horloge RTC.

Le montage : le module SD va sur les broches SPI comme dans le tableau ci-dessus, le module RTC sur le bus I2C (sur l'Uno SDA = A4, SCL = A5, VCC = 5V) et la broche de données du capteur DHT22 sur D2 ; avec un capteur nu, ajoute une résistance de 10 kΩ entre la broche de données et VCC. Installe les bibliothèques RTClib (Adafruit) et DHT sensor library depuis le Gestionnaire de bibliothèques. Pour le câblage détaillé du capteur, consulte le capteur de température et d'humidité DHT11 et DHT22.

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4#include <RTClib.h>
5#include <DHT.h>
6
7const int CS_PIN = 10;                           // SD modülü CS / SD module CS
8const unsigned long ARALIK = 10000;              // 10 saniyede bir kayıt / log every 10 seconds
9
10RTC_DS1307 rtc;                                  // DS3231 için RTC_DS3231 / RTC_DS3231 for a DS3231
11DHT dht(2, DHT22);                               // veri pini D2, DHT11 de olur / data pin D2, DHT11 also works
12unsigned long sonKayit = 0;
13
14void setup() {
15  Serial.begin(9600);
16  dht.begin();
17  if (!rtc.begin()) {
18    Serial.println(F("RTC bulunamadi"));         // RTC yok / RTC not found
19    while (true);
20  }
21  if (!rtc.isrunning()) {                        // saat hiç kurulmamış / clock never set
22    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));  // derleme anına kur / set to compile time
23  }
24  if (!SD.begin(CS_PIN)) {
25    Serial.println(F("SD kart hatasi"));         // SD başlatılamadı / SD init failed
26    while (true);
27  }
28  if (!SD.exists("VERI.CSV")) {                  // yeni dosyaya başlık satırı / header row for a new file
29    File f = SD.open("VERI.CSV", FILE_WRITE);
30    if (f) {
31      f.println(F("tarih,saat,sicaklik_C,nem_yuzde"));
32      f.close();
33    }
34  }
35}
36
37void loop() {
38  if (millis() - sonKayit < ARALIK) return;      // zamanı gelmedi / not time yet
39  sonKayit = millis();
40
41  float t = dht.readTemperature();
42  float h = dht.readHumidity();
43  if (isnan(t) || isnan(h)) {                    // sensör okunamadı / sensor read failed
44    Serial.println(F("DHT okuma hatasi"));
45    return;
46  }
47
48  DateTime simdi = rtc.now();
49  char ts[8], hs[8], satir[48];
50  dtostrf(t, 1, 1, ts);                          // AVR'de sprintf %f desteklemez / AVR sprintf has no %f
51  dtostrf(h, 1, 1, hs);
52  snprintf(satir, sizeof(satir), "%04d-%02d-%02d,%02d:%02d:%02d,%s,%s",
53           simdi.year(), simdi.month(), simdi.day(),
54           simdi.hour(), simdi.minute(), simdi.second(), ts, hs);
55
56  File f = SD.open("VERI.CSV", FILE_WRITE);      // sona ekle / append
57  if (f) {
58    f.println(satir);
59    f.close();                                   // her kayıtta kapat: güç kesilse de veri kalır / close every time so data survives a power cut
60    Serial.println(satir);
61  } else {
62    Serial.println(F("VERI.CSV acilamadi"));
63  }
64}

Toutes les 10 secondes, le code lit la température et l'humidité, récupère la date et l'heure du RTC et ajoute à la fin de VERI.CSV une ligne comme 2026-11-04,14:05:30,23.5,45.2. Comme le fichier est fermé après chaque enregistrement, les données déjà écrites survivent même à une coupure de courant. Sur les cartes AVR, sprintf() ne gère pas les nombres à virgule (%f) : les valeurs sont donc d'abord converties en texte avec dtostrf(). Comme l'attente utilise millis() au lieu de delay(), loop() peut faire d'autres choses en même temps. Si le RTC n'a jamais été réglé, il est mis à l'heure de la compilation du code. Avec un DS3231, il suffit d'écrire RTC_DS3231 au lieu de RTC_DS1307 et de tester lostPower() au lieu de isrunning().

Quelle place cela prend-il ? Une ligne fait environ 31 octets. Avec un enregistrement toutes les 10 secondes, on obtient 8 640 lignes par jour, soit environ 260 Ko ; sur un an, cela représente à peu près 95 Mo. À ce rythme, une carte de 8 Go tient donc des décennies. La vraie limite n'est pas la carte mais l'alimentation : si le projet doit fonctionner sur piles, calcule d'abord leur autonomie avec le calculateur d'autonomie de batterie.

Ouvrir les données de la carte SD dans Excel

1. Coupe l'alimentation de l'Arduino, retire la carte du module et insère-la dans ton ordinateur.
2. Copie VERI.CSV sur l'ordinateur ; travailler sur une copie est plus sûr que directement sur la carte.
3. Ouvre un classeur vide dans Excel et sélectionne le fichier via Données > À partir d'un fichier texte/CSV.
4. Dans la fenêtre d'aperçu, choisis Virgule comme délimiteur et clique sur Charger ; les colonnes se séparent en date, heure, température et humidité.
5. Sélectionne les colonnes de température et d'humidité et insère un graphique en courbes depuis l'onglet Insertion pour voir leur évolution dans le temps.

1// Excel'de ondalık ayırıcı virgülse / if Excel uses a decimal comma
2// Bu iki fonksiyonu kayıt kodunda loop()'un üstüne ekle / add these two functions above loop() in the logging sketch
3void noktayiVirgulYap(char *s) {
4  for (; *s; s++) {
5    if (*s == '.') *s = ',';                     // 23.5 -> 23,5
6  }
7}
8
9void excelSatiri(char *satir, size_t boyut, const DateTime &simdi, char *ts, char *hs) {
10  noktayiVirgulYap(ts);
11  noktayiVirgulYap(hs);
12  snprintf(satir, boyut, "%04d-%02d-%02d;%02d:%02d:%02d;%s;%s",   // ayırıcı ; / separator ;
13           simdi.year(), simdi.month(), simdi.day(),
14           simdi.hour(), simdi.minute(), simdi.second(), ts, hs);
15}
16
17// loop() içinde snprintf satırının yerine / in loop(), replace the snprintf line with:
18//   excelSatiri(satir, sizeof(satir), simdi, ts, hs);
19// Başlık satırı da / header row too: tarih;saat;sicaklik_C;nem_yuzde

Si tu préfères envoyer les mesures en direct dans Excel pendant que l'Arduino est relié à l'ordinateur, sans retirer la carte, jette un œil aux méthodes Data Streamer et PLX-DAQ dans envoyer les données d'Arduino vers Excel. La carte SD, elle, est indispensable pour les projets qui tournent sur le terrain, loin de tout ordinateur.

Utiliser une carte SD avec l'ESP32 (SPI)

Le cœur Arduino de l'ESP32 fournit sa propre bibliothèque SD, qui s'utilise presque de la même façon, avec trois différences importantes : les chemins commencent par / ("/olcumler.csv"), les noms longs sont autorisés et FILE_WRITE réécrit le fichier depuis zéro. Pour ajouter à la fin, il faut utiliser FILE_APPEND ; si tu reprends le code de l'Uno tel quel, tes anciennes données seront effacées à chaque démarrage. Les broches SPI par défaut sont SCK 18, MISO 19 et MOSI 23, et on utilise généralement le GPIO 5 pour CS. Le type et la capacité de la carte se lisent aussi en une ligne :

1#include <SPI.h>
2#include <SD.h>
3
4const int CS_PIN = 5;                            // VSPI: SCK 18, MISO 19, MOSI 23 / default VSPI pins
5const char *DOSYA = "/olcumler.csv";             // yol / ile başlar / path starts with /
6
7void setup() {
8  Serial.begin(115200);
9  if (!SD.begin(CS_PIN)) {                       // varsayılan SPI hızı 4 MHz / default SPI clock 4 MHz
10    Serial.println("Card Mount Failed");
11    return;
12  }
13  uint8_t tur = SD.cardType();
14  if (tur == CARD_NONE) {
15    Serial.println("Kart takili degil");         // kart yok / no card inserted
16    return;
17  }
18  Serial.printf("Kart tipi: %s\n", tur == CARD_SDHC ? "SDHC" : (tur == CARD_SD ? "SDSC" : "MMC"));
19  Serial.printf("Boyut: %llu MB\n", SD.cardSize() / (1024 * 1024));
20
21  if (!SD.exists(DOSYA)) {                       // uzun dosya adı serbest / long file names are fine
22    File f = SD.open(DOSYA, FILE_WRITE);         // FILE_WRITE dosyayı sıfırlar / FILE_WRITE truncates
23    if (f) {
24      f.println("sure_s,isik_ham");
25      f.close();
26    }
27  }
28}
29
30void loop() {
31  File f = SD.open(DOSYA, FILE_APPEND);          // ESP32'de sona ekleme / append on ESP32
32  if (f) {
33    f.printf("%lu,%d\n", millis() / 1000, analogRead(34));   // GPIO34'teki LDR / LDR on GPIO34
34    f.close();
35  }
36  delay(5000);
37}

Le code enregistre toutes les 5 secondes la valeur brute (0–4095) d'une photorésistance (LDR) reliée au GPIO 34. Sur l'ESP32, tu n'as même pas besoin d'un module RTC pour avoir l'heure réelle : il peut se connecter au Wi-Fi, récupérer l'heure sur un serveur NTP et horodater chaque ligne avec getLocalTime(). Si les fils sont longs ou si la carte est capricieuse, baisse la vitesse SPI : SD.begin(5, SPI, 1000000) démarre la carte à 1 MHz. Dans un enregistreur sur batterie, utiliser le deep sleep entre deux mesures multiplie l'autonomie.

ESP32 SD_MMC : l'interface SD rapide et l'ESP32-CAM

En plus du SPI, l'ESP32 dispose d'un contrôleur SDMMC qui parle le protocole rapide propre à la carte. En mode 4 bits, la bibliothèque SD_MMC est plusieurs fois plus rapide que le SPI, idéale pour de gros fichiers comme des photos ou du son. Sur l'ESP32 classique, les broches sont imposées : CLK GPIO 14, CMD GPIO 15, D0 GPIO 2, D1 GPIO 4, D2 GPIO 12, D3 GPIO 13, et ces lignes ont besoin de résistances de pull-up de 10 kΩ. En mode 1 bit, seules CLK, CMD et D0 sont utilisées ; c'est plus lent, mais les GPIO 4, 12 et 13 sont libérés. Le lecteur micro SD de l'ESP32-CAM est câblé sur ces broches, et le mode 1 bit évite que la LED flash du GPIO 4 clignote à chaque accès à la carte.

1#include "FS.h"
2#include "SD_MMC.h"
3
4void setup() {
5  Serial.begin(115200);
6  // 1-bit mod: yalnız CLK 14, CMD 15, D0 2 / 1-bit mode: only CLK 14, CMD 15, D0 2
7  if (!SD_MMC.begin("/sdcard", true)) {
8    Serial.println("SD_MMC baglanamadi");        // kart bağlanamadı / mount failed
9    return;
10  }
11  Serial.printf("Bos alan: %llu MB\n", (SD_MMC.totalBytes() - SD_MMC.usedBytes()) / (1024 * 1024));
12
13  File f = SD_MMC.open("/gunluk.txt", FILE_APPEND);
14  if (f) {
15    f.println("ESP32-CAM acildi");               // açılış kaydı / boot log line
16    f.close();
17  }
18}
19
20void loop() {
21}

Carte SD avec le Raspberry Pi Pico (MicroPython)

Sous MicroPython, la carte SD est gérée par le pilote sdcard.py de micropython-lib. Si tu as mpremote sur ton ordinateur, installe-le avec mpremote mip install sdcard, ou copie le fichier sur le Pico avec Thonny. La carte est montée comme dossier /sd avec os.mount(), puis s'utilise avec les commandes de fichiers Python habituelles (open, write). Le code ci-dessous lit le capteur de température interne du Pico et écrit une ligne CSV toutes les 10 secondes. Si tu découvres le Pico, lis d'abord qu'est-ce que le Raspberry Pi Pico.

1from machine import Pin, SPI, ADC
2import os, time
3import sdcard                                    # micropython-lib sürücüsü / micropython-lib driver
4
5spi = SPI(0, baudrate=1000000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
6sd = sdcard.SDCard(spi, Pin(17, Pin.OUT))        # CS = GP17; kart yoksa OSError / OSError if no card
7os.mount(os.VfsFat(sd), "/sd")                   # kart artık /sd klasörü / the card is now the /sd folder
8
9sensor = ADC(4)                                  # dahili sıcaklık sensörü / internal temperature sensor
10DOSYA = "/sd/pico_log.csv"
11
12if "pico_log.csv" not in os.listdir("/sd"):      # yeni dosyaya başlık / header for a new file
13    with open(DOSYA, "w") as f:
14        f.write("tarih,saat,sicaklik_C\n")
15
16while True:
17    v = sensor.read_u16() * 3.3 / 65535
18    t = 27 - (v - 0.706) / 0.001721              # RP2040 veri sayfası formülü / RP2040 datasheet formula
19    y, ay, g, sa, dk, sn = time.localtime()[:6]
20    with open(DOSYA, "a") as f:                  # "a" = sona ekle / append
21        f.write("{:04d}-{:02d}-{:02d},{:02d}:{:02d}:{:02d},{:.1f}\n".format(y, ay, g, sa, dk, sn, t))
22    print(sa, dk, sn, t)
23    time.sleep(10)                               # 10 saniye bekle / wait 10 seconds

Le Pico n'a pas d'horloge sauvegardée par pile : connecté à Thonny, son horloge est réglée automatiquement depuis l'ordinateur, mais en fonctionnement autonome elle démarre au 1er janvier 2021. Pour un horodatage exact, tu peux ajouter un module DS3231 ou, sur un Pico W, récupérer l'heure sur Internet par NTP. S'il n'y a pas de carte ou si le câblage est faux, le pilote lève OSError: no SD card. Si tu programmes le Pico avec l'IDE Arduino (cœur arduino-pico), tu peux suivre la même méthode avec la bibliothèque SD ; les broches SPI0 par défaut correspondent au tableau et il suffit d'écrire SD.begin(17) pour CS.

Éviter la perte de données : alimentation, fréquence d'écriture et durée de vie de la carte

• Sans close() ni flush(), rien n'arrive sur la carte : la bibliothèque accumule d'abord les données dans un tampon de 512 octets. Si tu gardes le fichier ouvert en permanence, appelle flush() toutes les quelques lignes.
• Ne retire pas la carte pendant l'écriture : arracher la carte ou couper l'alimentation en pleine écriture peut corrompre le système de fichiers. Ajouter un bouton qui arrête l'enregistrement et une LED qui indique qu'il est en cours est une bonne habitude.
• Soigne l'alimentation : la carte consomme jusqu'à 100 mA en écriture. Un condensateur de 10–100 µF entre VCC et GND du module réduit les chutes de tension et les erreurs d'écriture aléatoires.
• N'ouvre et ne ferme pas trop souvent : si tu prends des dizaines de mesures par seconde, ouvrir et fermer le fichier à chaque ligne est lent ; garde les mesures en RAM et écris-les par paquets de 10–20 lignes.
• Durée de vie de la carte : les cartes SD répartissent les écritures sur différentes cellules en interne (wear leveling) ; un enregistreur qui écrit quelques lignes par minute ne l'usera pas avant des années. Choisis tout de même une carte de marque reconnue.
• Découpe le fichier : ouvrir un fichier différent chaque jour (par exemple 20261104.CSV) garde des fichiers légers et, en cas de problème, tu ne perds que les données de ce jour-là.

Idées de projets avec le module carte SD

• Station météo avec enregistrement : enregistre chaque heure la température, l'humidité et la pression avec un BME280 et trace le graphique d'une saison entière.
• Journal d'arrosage : enregistre les valeurs du capteur d'humidité du sol et les moments où la pompe tourne pour étudier ton rythme d'arrosage.
• Enregistreur de parcours GPS : sauvegarde en CSV ton trajet à vélo ou en randonnée avec un GPS NEO-6M, puis affiche-le sur une carte.
• Registre des entrées par badge : écris dans un fichier chaque badge lu avec un RFID RC522, avec la date et l'heure.
• Suivi de consommation électrique : mesure et enregistre le courant qu'un appareil consomme au fil de la journée avec un capteur de courant ACS712.
• Lecteur MP3 : le DFPlayer Mini lit des fichiers audio depuis son propre lecteur micro SD ; l'Arduino ne fait qu'envoyer des commandes.

Erreurs fréquentes et solutions

Un module carte SD transforme un projet qui ne fait que mesurer en un appareil qui garde une trace, et quelques jours de vraies données en disent bien plus qu'une seule mesure. Dans l'application BlueGrays, tu trouveras l'enregistreur de température ESP32 avec DHT22, RTC DS1307, micro SD et OLED, des horloges numériques à RTC et des projets de mesure de température et d'humidité, avec schémas de câblage et code pas à pas.