# 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

1. Sélectionner `Outils → Type de carte → Generic ESP8266 Module`.
2. Régler le port série sur celui de l'adaptateur.
3. Placer l'ESP-01 en mode flash (jumper GPIO0 ↔ GND), téléverser, retirer le jumper, redémarrer.
4. 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 :

```cpp
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](https://varlog.a5l.fr/post/esp-01-presentation-premiers-pas)
- [Adaptateur USB vers ESP-01 : activer le mode programmation](https://varlog.a5l.fr/post/adaptateur-usb-vers-esp-01-activer-le-mode-programmation)
- [ESP8266 : commandes AT](https://varlog.a5l.fr/post/esp8266-commandes-at)
- Documentation officielle de l'API `ESP` du core Arduino : <https://arduino-esp8266.readthedocs.io/en/latest/libraries.html#esp-specific-apis>
```