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 et à la configuration de l'IDE pour l'ESP-01.

Le programme

// 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() et getFlashChipSize() 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 ESP du core Arduino : https://arduino-esp8266.readthedocs.io/en/latest/libraries.html#esp-specific-apis

8.1 KiB Raw Permalink Blame History Unescape Escape