Carte wifi NodeMCU V3 Lua – ESP8266

La carte Wi-Fi NodeMCU V3 est la carte de développement ESP8266 la plus répandue : un microcontrôleur 32 bits avec Wi-Fi intégré, posé sur une carte qui se branche directement en USB et se programme comme un Arduino. Trente broches au pas de 2,54 mm, une alimentation par câble micro-USB, et aucune carte supplémentaire à prévoir.

Le module que nous livrons est un ESP-12E soudé sur la carte, avec la puce de conversion USB-série CH340G et un régulateur AMS1117-3,3 V. Deux boutons sont accessibles : FLASH et RST. « Lua » dans le nom rappelle le firmware d’origine de ces cartes : aujourd’hui, elle se programme le plus souvent depuis l’IDE Arduino.

Ce que la carte apporte

Un ESP8266 seul ne sait pas se connecter à un ordinateur : il faut lui ajouter une alimentation 3,3 V stable, un convertisseur USB-série, les résistances de démarrage et un moyen de le remettre en mode flash. La carte NodeMCU V3 fait tout ce travail :

• Un connecteur micro-USB qui alimente la carte et sert à téléverser les programmes, avec la puce CH340G des deux côtés de la liaison.
• Un régulateur 3,3 V capable d’alimenter le module et quelques petits composants externes.
• Les bonnes tensions au démarrage : les broches de configuration sont déjà tirées haut ou bas comme il faut, ce qui évite les erreurs de câblage classiques sur un module nu.
• Une alimentation protégée du 230 V en amont du câble USB, et une LED bleue sur la broche D4 pour vérifier d’un coup d’œil que la carte fonctionne.
• Le même brochage que 80 % des tutoriels ESP8266 : le code trouvé en ligne se téléverse sans adaptation.

Caractéristiques techniques

Brochage : les repères de la carte ne sont pas les numéros de GPIO

C’est le piège numéro un de cette carte. Les noms sérigraphiés (D0, D1, A0…) ne correspondent pas aux numéros de broches du microcontrôleur : D2 n’est pas GPIO2, c’est GPIO4. Un programme qui utilise GPIO2 en croyant viser D2 pilote en réalité la LED bleue.

Rangée de droite

Rangée de gauche

Les six broches à ne jamais câbler : GPIO6 à GPIO11, c’est-à-dire SD0, CLK, CMD, SD1, SD2 et SD3. Elles desservent la mémoire flash du module ; y brancher quoi que ce soit empêche la carte de lire son programme. Le reste des broches peut être utilisé sans précaution particulière.

Ce que chaque broche sait faire

• PWM : disponible sur toutes les sorties sauf D0, avec une résolution de 10 bits.
• Interruptions : sur toutes les broches sauf D0.
• I2C : le matériel n’en fournit pas, mais il s’implémente par logiciel sur n’importe quelle paire de broches — en pratique D1 (SCL) et D2 (SDA).
• SPI : D5, D6, D7 et D8.
• Veille profonde : relier D0 à RST, la carte se réveille toute seule au bout du temps programmé et descend sous 100 µA entre deux mesures.

Alimentation : ce qui est permis et ce qui ne l’est pas

Par USB, la carte se contente de ce que fournit l’ordinateur. Sur le terrain, deux solutions : VIN accepte 5 V depuis un adaptateur secteur, et 3V3 accepte une alimentation déjà régulée en 3,3 V — mais dans ce second cas vous court-circuitez le régulateur de la carte, donc la source doit être propre.

La sortie 3,3 V ne doit alimenter que de petits composants : un capteur, un afficheur, quelques LED. Un relais, un servomoteur ou un moteur se branchent sur une alimentation 5 V séparée, avec la masse commune — c’est la cause la plus fréquente des redémarrages intempestifs de l’ESP8266.

Deux règles de survie à retenir

• Tout ce qui est en 3,3 V se branche directement. C’est le cas de la plupart des capteurs et modules vendus pour l’Arduino : le capteur PIR, le DHT22, le BME280, les afficheurs I2C, les modules à base de pull-up.
• Une sortie en 5 V doit être abaissée. La sortie écho d’un capteur à ultrasons, un ancien module 5 V ou une sortie d’Arduino Uno réclament un diviseur de tension (deux résistances) ou un adaptateur de niveau. Envoyer du 5 V directement sur une broche abîme le microcontrôleur, parfois immédiatement, souvent après quelques semaines.

Applications

• Objet connecté autonome — des mesures relevées puis poussées vers un serveur ou un service en ligne, sans ordinateur à côté.
• Page web embarquée — la carte est son propre serveur : elle affiche ses mesures sur une page consultable depuis n’importe quel téléphone du réseau.
• Domotique — commander un relais, donc une lampe ou une pompe, depuis un téléphone.
• Station météo — température, humidité, pression, lue pendant des mois en veille profonde sur piles.
• Suivi à distance — arrosage du jardin, chambre froide d’un commerce, température d’un local technique.
• Passerelle sans fil — remonter vers Internet les données d’un capteur filaire qui n’a jamais été prévu pour cela.

Mini-projet : une station météo Wi-Fi en ligne de commande

Le montage complet tient sur une demi-heure : la carte lit la température et l’humidité, puis les publie sur une adresse IP consultable depuis n’importe quel navigateur du même réseau.

Ce qu’il faut

Le câblage

La résistance de tirage n’est pas décorative : sans elle, la ligne de données flotte entre deux bits et les lectures échouent une fois sur deux. Elle se place entre la broche de données et le 3,3 V, directement sur la plaque d’essai.

Le programme

À copier dans l’IDE Arduino, puis à téléverser sur la carte :

/*
 * Station meteo Wi-Fi - carte NodeMCU V3 (ESP8266) et capteur DHT22
 * Carte  : NodeMCU V3 Lua - ESP8266 (module ESP-12E, USB CH340G)
 * Capteur: DHT22 sur D2, soit GPIO4
 *
 * Bibliotheques a installer dans l'IDE Arduino :
 *   - le coeur "esp8266" (par le gestionnaire de cartes)
 *   - "DHT sensor library" d'Adafruit
 *   - "Adafruit Unified Sensor"
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */

#include "ESP8266WiFi.h"
#include "DHT.h"

#define PIN_DHT    D2          // GPIO4
#define TYPE_DHT   DHT22

const char* RESEAU = "NomDeVotreReseau";
const char* CLE    = "MotDePasseDuWifi";

DHT dht(PIN_DHT, TYPE_DHT);
WiFiServer serveur(80);
WiFiClient client;

float temperature = 0;
float humidite    = 0;
unsigned long derniereMesure = 0;

void lireCapteur() {
  // Le DHT22 ne se lit pas plus d'une fois tous les deux secondes.
  if (millis() - derniereMesure >= 2000) {
    float h = dht.readHumidity();
    float t = dht.readTemperature();

    if (isnan(h) || isnan(t)) {
      Serial.println("Lecture du capteur impossible");
    } else {
      humidite    = h;
      temperature = t;
    }
    derniereMesure = millis();
  }
}

void repondre() {
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: text/plain; charset=utf-8");
  client.println("Connection: close");
  client.println();

  client.print("Temperature : ");
  client.print(temperature);
  client.println(" C");

  client.print("Humidite    : ");
  client.print(humidite);
  client.println(" %");
}

void setup() {
  Serial.begin(115200);
  dht.begin();

  Serial.print("Connexion au reseau ");
  WiFi.begin(RESEAU, CLE);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.print("Adresse IP de la carte : ");
  Serial.println(WiFi.localIP());

  serveur.begin();
}

void loop() {
  lireCapteur();

  client = serveur.available();
  if (client) {
    client.setTimeout(2000);
    String requete = client.readStringUntil(10);   // 10 = code ASCII du retour a la ligne
    Serial.println(requete);

    repondre();
    delay(1);
    client.stop();
  }
}

La mise en service, étape par étape

1. Installer le pilote du CH340 si vous êtes sous Windows : sans lui, la carte n’apparaît pas dans la liste des ports. Sous macOS et sous la plupart des distributions Linux, rien à installer.
2. Ajouter le coeur ESP8266 à l’IDE Arduino : dans les préférences, renseignez l’URL du gestionnaire de cartes indiquée par le projet ESP8266 pour Arduino, puis installez le paquet « esp8266 » depuis le gestionnaire de cartes.
3. Installer les deux bibliothèques du capteur par le gestionnaire de bibliothèques : « DHT sensor library » et « Adafruit Unified Sensor ».
4. Choisir la carte « NodeMCU 1.0 (ESP-12E Module) » et une vitesse de téléversement de 115200 bauds.
5. Renseigner le nom et le mot de passe du réseau dans les deux premières lignes de constantes, puis téléverser.
6. Ouvrir le moniteur série à 115200 bauds : la carte affiche son adresse IP. Saisissez-la dans un navigateur du même réseau, vous lisez la température et l’humidité.

Comment ça marche

• La carte se connecte en mode station, comme un téléphone : elle obtient une adresse IP de votre box et la garde tant qu’elle est alimentée.
• Le serveur écoute sur le port 80. À chaque visite, il lit les deux dernières valeurs mesurées et les renvoie en texte brut. La page web la plus légère possible : quelques dizaines d’octets.
• La mesure est rafraîchie au maximum toutes les deux secondes : c’est la limite du DHT22, pas celle de la carte. Insister davantage fait remonter des valeurs fausses plutôt qu’un rafraîchissement plus rapide.
• isnan() filtre une lecture manquée : mieux vaut garder la valeur précédente qu’afficher un résultat inventé.

Pour aller plus loin sur cette base

• Ajouter un afficheur local — le LCD 16×02 en I2C se branche sur D1 et D2 et affiche les mêmes valeurs sans passer par un téléphone.
• Piloter un appareil — un module 1 relais 5 V commandé depuis la page web transforme la station en interrupteur à distance.
• Mesurer le sol d’une plante — un capteur d’humidité du sol en entrée analogique A0, et l’arrosage devient automatique.
• Mesurer dehors — la sonde DS18B20 résiste à l’eau et se câble sur une seule broche numérique.
• Faire remonter les données plus loin — la carte sait aussi se connecter seule à un serveur distant, sans qu’un navigateur soit ouvert.

Variante : en plus petit, la WeMos D1 mini

Le même ESP8266 existe dans un format nettement plus compact, sur une seule rangée de broches de chaque côté : la carte WeMos avec WiFi. À l’écran et dans le code, la différence est minime — même puce, même Wi-Fi, mêmes numéros de GPIO derrière les repères. Ce qui change : moins de place sur la plaque d’essai, et un brochage plus court. Pour un montage définitif enfermé dans un boîtier, la WeMos prend souvent moins de place que la NodeMCU ; pour un prototype sur plaque d’essai où l’on veut tout brancher d’un coup, la NodeMCU et ses 30 broches restent plus confortables.

Et si votre projet demande du Bluetooth en plus du Wi-Fi, deux coeurs au lieu d’un, ou davantage de broches, c’est du côté de l’ESP32 WROOM qu’il faut regarder — même famille, même façon de travailler, possibilités plus larges.

Questions fréquentes

La carte n’apparaît pas dans la liste des ports, que faire ?

C’est presque toujours le pilote USB-série. La NodeMCU V3 utilise une puce CH340G : sous Windows, il faut installer son pilote une fois pour toutes. Si la carte est bien alimentée, les voyants s’allument même sans pilote — la LED bleue qui clignote ne prouve donc pas que la liaison fonctionne. Sous Linux, vérifiez que le port apparaît après le branchement ; au besoin, le pilote est déjà présent dans le noyau récent.

Comment savoir quelle taille de mémoire flash porte ma carte ?

Téléversez un programme qui affiche ESP.getFlashChipRealSize() et lisez la valeur dans le moniteur série : elle s’exprime en octets. Ce réglage compte, car l’IDE Arduino doit être configuré sur la bonne taille de flash, sinon les programmes un peu volumineux ne se téléversent pas.

Puis-je alimenter un module relais ou un servomoteur depuis la carte ?

Non, pas de façon fiable. Un relais consomme à lui seul plus que ce que la sortie 3,3 V peut fournir, et un servomoteur en mouvement encore davantage : la tension s’écroule et la carte redémarre. Alimentez ces charges par une alimentation 5 V 2 A séparée, et reliez les masses (GND) entre elles. La carte ne sert alors qu’à envoyer le signal de commande.

Puis-je brancher un capteur d’Arduino Uno directement ?

Cela dépend du sens du signal. Tout capteur qui reçoit du 3,3 V ou moins se branche sans rien : la plupart des modules modernes fonctionnent de 3,3 à 5 V. En revanche, une sortie qui émet du 5 V — la sortie écho d’un capteur à ultrasons, par exemple — doit être abaissée par un diviseur de tension avant d’atteindre une broche de la carte. Le capteur PIR, lui, sort directement du 3,3 V : les deux sont compatibles.

Pourquoi la carte redémarre-t-elle en boucle ?

Trois causes, dans l’ordre de fréquence : une alimentation insuffisante (port USB faible, relais branché sur la carte, câble trop fin), une broche de démarrage maintenue dans le mauvais état (D3, D4 ou D8), ou une broche de la mémoire flash utilisée par erreur (SD0, CLK, CMD, SD1, SD2, SD3). Débranchez tout sauf l’USB : si la carte démarre normalement, c’est le câblage, pas la carte.

Arduino ou Lua, finalement ?

L’IDE Arduino, dans la très grande majorité des cas : c’est la voie la mieux documentée, celle pour laquelle les bibliothèques de capteurs existent, et celle que suivent les tutoriels que vous trouverez. Le firmware Lua d’origine a l’avantage de se piloter sans rien compiler, par une simple liaison série, mais il est aujourd’hui beaucoup moins utilisé. Un troisième choix, MicroPython, se situe entre les deux : du Python sur la carte, en échange d’un peu de mémoire consommée.

À combiner avec

Pour mesurer : le DHT22 pour la température et l’humidité, la sonde DS18B20 pour l’extérieur, le capteur de mouvement PIR pour la présence, le capteur d’humidité du sol pour les plantes. Pour agir : un module 1 relais 5 V et une alimentation 5 V 2 A séparée. Pour afficher : l’afficheur LCD 16×02 en I2C, à condition d’y ajouter son adaptateur I2C s’il n’en est pas déjà équipé. Et pour le montage lui-même : une plaque d’essai 830 points et des fils de prototypage.

Si votre projet demande plus de broches, du Bluetooth ou deux coeurs, regardez l’ESP32 WROOM ; s’il demande moins de place, la carte WeMos reprend exactement le même ESP8266 dans un format réduit.