Cédrix
8.4 KiB
8.4 KiB
Voici une version retravaillée : présentation contextualisée, code commenté, sortie expliquée ligne par ligne, et quelques précisions techniques sur ce que mesurent réellement les fonctions de l'API ESP.
# Premier programme ESP-01 : afficher les informations système
## Objectif
Le sketch ci-dessous est un petit utilitaire de diagnostic : une fois téléversé sur un ESP-01, il publie toutes les dix secondes sur la console série un état détaillé du microcontrôleur — identifiant, fréquence, tension d'alimentation, version du SDK — ainsi qu'un état de la mémoire flash. C'est l'équivalent d'un `uname -a` couplé à un `df` pour l'ESP8266.
Cet exemple sert deux objectifs :
- **valider la chaîne complète** (adaptateur, mode flash, IDE, board package) en réussissant un premier téléversement ;
- **identifier précisément le module** en main : la flash réelle ne correspond pas toujours à ce qui est annoncé par le vendeur, et il peut être utile de le constater avant d'aller plus loin.
> **Prérequis** : un ESP-01 programmable depuis l'IDE Arduino. Voir les articles dédiés à l'[adaptateur USB-série](https://varlog.a5l.fr/post/adaptateur-usb-vers-esp-01-activer-le-mode-programmation) et à la [configuration de l'IDE pour l'ESP-01](https://varlog.a5l.fr/post/esp-01-presentation-premiers-pas).
## Le programme
```cpp
// Demande au SDK de connecter l'ADC interne à la mesure de VCC
// plutôt qu'à la broche TOUT. Doit être déclaré en dehors de setup()
// pour être pris en compte au démarrage.
ADC_MODE(ADC_VCC);
void setup() {
Serial.begin(115200);
delay(100); // petit délai pour stabiliser l'UART
}
void loop() {
/* ----- ESP8266EX ----- */
Serial.println("INFO ESP8266EX");
Serial.printf("Numéro de série de l'ESP8266EX .....: %u\n",
ESP.getChipId());
float frequenceCpu = float(ESP.getCpuFreqMHz());
Serial.printf("Fréquence du CPU ...................: %4.1f MHz\n",
frequenceCpu);
// getVcc() renvoie la tension en millivolts
float vcc = float(ESP.getVcc()) / 1000.0;
Serial.printf("Alimentation .......................: %4.2f V\n", vcc);
// La version du core Arduino-ESP8266 contient des underscores
// (ex: 2_7_4) ; on les remplace par des points pour la lisibilité.
String coreVersion = ESP.getCoreVersion();
coreVersion.replace('_', '.');
Serial.print("Version du gestionnaire de carte ...: ");
Serial.println(coreVersion);
Serial.printf("Version du SDK .....................: %s\n\n",
ESP.getSdkVersion());
/* ----- Mémoire flash ----- */
Serial.println("INFO FLASH");
Serial.printf("Numéro de série du chip ............: %u\n",
ESP.getFlashChipId());
float frequenceFlash = float(ESP.getFlashChipSpeed()) / 1000000.0;
Serial.printf("Fréquence ..........................: %4.1f MHz\n",
frequenceFlash);
Serial.printf("Capacité effective .................: %u octets\n",
ESP.getFlashChipRealSize());
Serial.printf("Capacité paramétrée dans l'EDI .....: %u octets\n",
ESP.getFlashChipSize());
Serial.printf("Taille du sketch ...................: %u octets\n",
ESP.getSketchSize());
Serial.printf("Mémoire disponible .................: %u octets\n\n\n",
ESP.getFreeSketchSpace());
delay(10000);
}
Téléverser et lire la sortie
- Sélectionner
Outils → Type de carte → Generic ESP8266 Module. - Régler le port série sur celui de l'adaptateur.
- Placer l'ESP-01 en mode flash (jumper GPIO0 ↔ GND), téléverser, retirer le jumper, redémarrer.
- Ouvrir le moniteur série à 115200 bauds, fin de ligne NL & CR.
Sortie attendue (les valeurs varient d'un module à l'autre) :
INFO ESP8266EX
Numéro de série de l'ESP8266EX .....: 10106374
Fréquence du CPU ...................: 80.0 MHz
Alimentation .......................: 3.47 V
Version du gestionnaire de carte ...: 2.7.4
Version du SDK .....................: 2.2.2-dev(38a443e)
INFO FLASH
Numéro de série du chip ............: 1327304
Fréquence ..........................: 40.0 MHz
Capacité effective .................: 1048576 octets
Capacité paramétrée dans l'EDI .....: 1048576 octets
Taille du sketch ...................: 268288 octets
Mémoire disponible .................: 778240 octets
Lecture des informations
Bloc ESP8266EX
| Information | Méthode | Commentaire |
|---|---|---|
| Numéro de série du SoC | ESP.getChipId() |
Entier 24 bits dérivé de l'adresse MAC du module. Identifie de manière unique un ESP8266 donné. |
| Fréquence du CPU | ESP.getCpuFreqMHz() |
80 MHz par défaut, peut passer à 160 MHz avec system_update_cpu_freq(160) ou via les options de carte de l'IDE. |
| Alimentation | ESP.getVcc() |
Tension VCC en millivolts. Nécessite ADC_MODE(ADC_VCC) et que la broche TOUT (ADC0) soit laissée libre. |
| Version du core | ESP.getCoreVersion() |
Version du board package esp8266 by ESP8266 Community. C'est lui qui fournit l'API Arduino utilisée ici. |
| Version du SDK | ESP.getSdkVersion() |
Version du SDK NONOS d'Espressif, utilisé en interne par le core. Ne pas confondre avec la version du core. |
Lecture de la sortie d'exemple : le module est un ESP8266 cadencé à 80 MHz, alimenté à environ 3,47 V (légèrement au-dessus du nominal de 3,3 V, ce qui reste dans la plage tolérée 3,0–3,6 V), compilé avec le board package 2.7.4 (basé sur le SDK NONOS 2.2.2).
Bloc Flash
| Information | Méthode | Commentaire |
|---|---|---|
| Numéro de série de la flash | ESP.getFlashChipId() |
Concaténation du manufacturer ID et du device ID renvoyés par la commande JEDEC. Utile pour identifier la puce flash réellement soudée. |
| Fréquence | ESP.getFlashChipSpeed() |
Vitesse de l'horloge SPI en Hz. 40 MHz est la valeur standard ; 80 MHz est possible mais instable sur certains lots. |
| Capacité effective | ESP.getFlashChipRealSize() |
Taille physique de la puce flash, lue dans son JEDEC ID. C'est la vérité matérielle. |
| Capacité paramétrée | ESP.getFlashChipSize() |
Taille que l'IDE a annoncée au firmware (paramètre Flash Size dans Outils). Doit correspondre à la capacité effective. |
| Taille du sketch | ESP.getSketchSize() |
Place occupée par le programme actuel. |
| Mémoire disponible | ESP.getFreeSketchSpace() |
Place restante utilisable pour un téléversement OTA. Pas la RAM libre — pour cela utiliser ESP.getFreeHeap(). |
Dans la sortie d'exemple, la flash physique fait 1 Mo (1 048 576 octets) et l'IDE a été paramétré avec la même valeur : c'est cohérent.
Piège classique : si
getFlashChipRealSize()etgetFlashChipSize()diffèrent, le module est mal configuré dans l'IDE. Les conséquences vont de plantages aléatoires au refus de monter le système de fichiers SPIFFS/LittleFS. C'est l'un des intérêts principaux de ce sketch : détecter ce désaccord avant d'investiguer un comportement étrange.
Variante : ajouter quelques infos utiles
Quelques méthodes complémentaires qu'il peut être pertinent d'ajouter au programme selon les besoins :
Serial.printf("RAM libre (heap) ...................: %u octets\n",
ESP.getFreeHeap());
Serial.printf("Fragmentation du heap ..............: %u %%\n",
ESP.getHeapFragmentation());
Serial.printf("Plus gros bloc libre ...............: %u octets\n",
ESP.getMaxFreeBlockSize());
Serial.printf("Adresse MAC ........................: %s\n",
WiFi.macAddress().c_str()); // nécessite #include <ESP8266WiFi.h>
Serial.printf("Cause du dernier reset .............: %s\n",
ESP.getResetReason().c_str());
Ces valeurs sont particulièrement intéressantes pour diagnostiquer des plantages : getResetReason() indique si le module a redémarré sur un watchdog, un brown-out, un reset matériel ou une exception logicielle.
Pour aller plus loin
- L'ESP-01 : présentation et premiers pas
- Adaptateur USB vers ESP-01 : activer le mode programmation
- ESP8266 : commandes AT
- Documentation officielle de l'API
ESPdu core Arduino : https://arduino-esp8266.readthedocs.io/en/latest/libraries.html#esp-specific-apis