ESP8266. Comment se connecter au réseau WiFi (ESP8266WiFi et ESP8266WiFiMulti)

Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

La librairie ESP8266WiFi est une adaptation de la librairie standard Arduino pour les modules ESP8266 faite par Espressif. Elle est hyper simple à utiliser et quelques lignes de code suffisent pour établir une connexion WiFi depuis le micro-contrôleur. La difficulté réside plus dans la multitudes des librairies existantes. ESP8266WiFi, ESP8266wifi, ESP8266WiFiMulti, ESP8266HTTPClient… Difficile de s’y retrouver lorsqu’on débute.

 

Dans ce tutoriel, nous allons apprendre comment se connecter simplement à un réseau WiFi avec un ESP8266 à l’aide de la librairie standard. Nous verrons également à quoi servent les autres librairies énoncées précédemment.

Librairies ESP8266WiFi et ESP8266wifi, la confusion !

Si vous débutez avec les modules ESP8266, vous avez sans doute rencontré ces deux librairies qui portent un nom très similaire dans les nombreux tutoriels proposés sur internet. La différence est subtile – wifi en minuscule – mais peut rapidement poser des problème, surtout lorsqu’on débute.

ESP8266WiFi

ESP8266WiFi est la librairie “officielle” du kit de développement pour les ESP8266. La librairie est installée en même temps que le SDK ESP8266 depuis le gestionnaire de cartes.

A LIRE AUSSI :
ESP8266. Débuter sur IDE Arduino. Librairies, GPIO, programmation Web Serveur, Client Web, drivers

La librairie est livrée avec de nombreux exemples. Le dépôt GitHub se trouve ici.

La librairie est très bien documentéepar Espressif.

C’est la librairie standard pour les modules ESP8266 développée par Espressif, le fabricants des SoC. Il est préférable d’utiliser cette librairie en priorité car elle est mise à jour régulièrement.

ESP8266wifi

ESP8266wifi est une librairie équivalente développée par Jonas Ekstrand disponible sur GitHub. Elle n’est pas disponible depuis le gestionnaire de bibliothèque. Il faudra l’installer manuellement en décompressant le dépôt dans le répertoire libraries de l’IDE Arduino. La librairie de Jonas Ekstrand est beaucoup plus complète que la librairie originale.

Cette librairie combine plusieurs fonctions. Elle permet de gérer l’ESP8266 comme un point d’accès, de surveiller l’arriver de messages, de gérer la re-connexion automatique… La dernière mise à jour date de 2017. Il est préférable de l’éviter.

Ici, nous allons utiliser l’adaptation de la librairie Arduino ESP8266WiFi.

Différents modes de connexion WiFi disponibles

ESP8266 est une librairie très complète qui propose plusieurs modes de connexion Wi-Fi

Station Le mode Station (STA) est utilisé pour connecter le module ESP à un point d’accès Wi-Fi. C’est le mode par défaut.

Point d’accès (Access Point) transforme l’ESP8266 en point d’accès (AP), c’est à dire que d’autres appareils peuvent de connecter sur l’ESP8266. Ce mode de fonctionnement est  aussi appelé point d’accès logiciel (soft-AP).

Attention, dans ce mode l’ESP8266 n’est pas connecté à internet. Dans ce mode, on créé une page HTML qui permettra de saisir des paramètres de connexion à un réseau WiFi ou ce que l’on veut d’autre. C’est par exemple le mode utilisé par ESP Easy Mega (ou ESP Easy).

espeasy mega esp32 configuration wifi mode ap

On pourra utiliser ce mode dans différents cas

  • Pour développer des accessoires domotiques ou des objets connectés sans compiler “en dur” les paramètres de connexion au réseau WiFi. Pour faire ça, je vous conseille plutôt d’utiliser la librairie WiFiManager dont s’est la spécialité.
A LIRE AUSSI :
ESP8266. Comment utiliser la librairie WiFiManager pour gérer les connexions WiFi
  • Echanger des données entre deux (ou plus) modules ESP8266 sans avoir besoin d’un routeur WiFi.

Autres modes : client, serveur, UDP

Client n’est pas un mode de connexion au sens strict. On crée des clients qui peuvent accéder aux services fournis par un serveur afin d’envoyer, de recevoir et de traiter des données.

Serveur permet de démarrer un petit serveur Web sur l’ESP8266

UDP permet d’envoyer et de recevoir des messages  UDP (User Datagram Protocol). L’UDP utilise un modèle de transmission simple «envoyer et oubliez» sans garantie de livraison, de commande ou de protection contre les doublons. En contrepartie, la transmission de données est ultra-rapide. On pourra par exemple utiliser l’UDP pour développer un télécommande WiFi pour piloter un drone, bras robotique, voiture RC.

Installer le SDK ESP8266

Si vous débutez avec les cartes de développement ESP8266, vous devez commencer par installer le SDK ESP8266 sur l’IDE Arduino.

A LIRE AUSSI :
ESP8266. Débuter sur IDE Arduino. Librairies, GPIO, programmation Web Serveur, Client Web, drivers

Comment se connecter à un réseau WiFi avec la librairie ESP8266WiFi

Voici un exemple de code qui permet de se connecter au réseau WiFi local.

Avant de téléverser le code, remplacer l’identifiant du réseau Wi-Fi enter_your_ssid et le mot de passe enter_your_password dans le code

#include <ESP8266WiFi.h> 

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

  WiFi.begin("enter_your_ssid", "enter_your_password");

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

  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {}

Comment fonctionne le code ?

L’utilisation de la librairie ESP8266WiFi est ultra simple. Il suffit de connaître l’identifiant du réseau WiFi sur lequel on souhaite connecter le module NodeMCU ainsi que le mot de passe. La méthode WiFi.begin() prend deux paramètres qui sont l’identifiant réseau et le mot de passe

WiFi.begin("enter_your_ssid", "enter_your_password");

La méthode WiFi.status permet de connaître à tout moment l’état de la connexion. La méthode renvoie un code compris entre 0 et 6 auquel correspond une constante dont voici la signification

  • 0: WL_IDLE_STATUS lorsque le Wi-Fi est en train de changer d’état
  • 1: WL_NO_SSID_AVAIL si le SSID configuré ne peut pas être atteint
  • 3: WL_CONNECTED une fois la connexion établie
  • 4: WL_CONNECT_FAILED si le mot de passe est incorrect
  • 6: WL_DISCONNECTED si le module n’est pas configuré en mode station

Dans la plupart, il suffit de se connecter à la mise sous tension dans le setup()

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

Remarques :

  • Ce code fonctionne également très bien dans le code où l’on met en veille profonde le module ESP8266.
  • Ce code ne prévoie pas la mise en veille du module si le réseau WiFi n’est pas disponible ce qui risque de drainer la batterie

Pour gérer correctement la re-connexion automatique en cas de perte de signal WiFi, je vous conseille de vous tourner vers la librairie WiFiManager qui gère automatiquement les re-connexions.

A LIRE AUSSI :
ESP8266. Comment utiliser la librairie WiFiManager pour gérer les connexions WiFi

Mettre en veille (deep-sleep) l’ESP8266 si le réseau WiFi n’est pas disponible

Plutôt que de rester dans une boucle infinie en attendant que le réseau WiFi soit disponible, il est préférable de mettre en veille le module ESP8266 durant un certain délais et recommencer ultérieurement.

Créer un nouveau croquis et coller le code ci-dessous

#include <ESP8266WiFi.h>  

const char* ssid      = "saisir_identifiant_reseau"; 
const char* password  = "saisir_mot_de_passe_reseau"; 
#define wifi_max_try  10 // Nombre de tentative de connexion
#define duration_deep_sleep 10   // mettre en veille 10 secondes si le reseau wifi n est pas disponible

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

  WiFi.begin(ssid, password);

  Serial.print("Connecting");
  int count_try = 0;
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    count_try++;
    if ( count_try >= wifi_max_try ) {
      Serial.println("\n");
      Serial.println("Impossible to establish WiFi connexion, sleep a little !");
      ESP.deepSleep(duration_deep_sleep * 1000000);
    }
  }
  Serial.println();

  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
   
}

Pour activer le mode deep sleep du NodeMCU, il faut connecter la broche RST à la broche D0 avec un jumper ou un fil.

A LIRE AUSSI :
ESP8266, activer le mode Deep Sleep, réveil (wake up) avec un détecteur de mouvement PIR
Attention, déconnecter les broches RST et D0 avant de pouvoir téléverser le code.

 

wemos d1 mini activate deep-sleep mode esp8266

On active le mode deep-sleep de l’ESP8266 en reliant les broches RST et D0

Comment fonctionne ce code

On ajoute un compteur qui est incrémenté à chaque passage dans le while (ici toutes les 500ms)

int count_try = 0;

Dès que le compteur est égal (ou dépasse) le nombre de tentatives, on active la mise en veille en appelant la méthode ESP.deepsleep(). La durée de mise en veille est indiquée en microsecondes. 1 seconde = 1000000 microsecondes

if ( count_try >= wifi_max_try ) {
  ESP.deepSleep(duration_deep_sleep * 1000000);

}

La librairie ESP8266WiFiMulti

Enfin, dernière librairie intéressant à connaître, la librairie ESP8266WiFiMulti. Elle permet de définir plusieurs réseaux WiFi et laisse le choix à l’ESP8266 de se connecter au réseau en fonction de sa disponibilité et de la force du signal. C’est un composant de la librairie standard ESP8266WiFi.

Elle est très simple à utiliser. On commence par créer un objet wifiMulti.

ESP8266WiFiMulti wifiMulti;

On ajoute les différents points d’accès dans une liste à l’aide de la classe wifiMulti.addAP()

wifiMulti.addAP("ssid1","psk1");
wifiMulti.addAP("ssid2","psk2");

On ouvre une connexion avec la classe run().

wifiMulti.run()

On dispose de plusieurs clés permettant de tester le bon fonctionnement de la connexion :

  • WL_CONNECTED la connexion est établie
  • WL_NO_SSID_AVAIL aucun point d’accès indiqué dans la liste n’est disponible
  • WL_CONNECT_FAILED échec de connexion. Probablement que le mot de passe est mauvais ou un filtrage par adresse MAC a été mis en place sur le routeur.

Pour tracer ce qui se passe, vous pouvez ajouter cette option dans le setup() qui permet d’envoyer les messages de debug sur le port série .

Serial.setDebugOutput(true);

Attribuer une adresse IP fixe à une carte ESP8266 ou ESP01

Lorsqu’on développe un objet connecté au WiFi avec un ESP32, ESP8266 ou ESP-01 (ou n’importe quel autre micro-contrôleur d’ailleurs), il est beaucoup plus pratique d’attribuer une adresse IP fixe. On pourra ainsi toujours se connecter à l’objet sur le réseau local même en cas de changement de routeur ou de box internet.

Tout est expliqué en détail dans ce tutoriel.

A LIRE AUSSI :
Comment attribuer une IP fixe à un projet ESP32 ESP8266 ou ESP01

En exemple de watchdog

Voici un petit exemple pour découvrir le fonctionnement de la librairie. On va se connecter au serveur de test (Node.js ou SocketTest) et lui envoyer le temps écoulé depuis le démarrage de l’ESP8266 (obtenu avec la fonction millis()) ainsi que l’adresse IP du module. On restera à l’écoute jusqu’à ce qu’on ait reçu une réponse du serveur (You are alive!).

Un watchdog peut être utile pour surveiller que le module est toujours en fonctionnent et envoyer une alerte. Pour cet exemple, j’ai adapté le code de l’exemple WiFiClient installé en même temps que la carte Wemos D1 R2 & mini.

On doit donc commencer par établir une connexion avec le réseau WiFi. C’est la classe WiFi.begin qui s’en charge.

WiFi.begin(ssid, password);

On continue le déroulement du programme que lorsqu’une connexion a été établie. Attention, c’est un code parfaitement inadapté à une fonctionnement sur batterie. Dans ce cas, il est préférable de mettre un compteur et mettre en sommeil l’ESP pour recommencer plus tard après plusieurs tentatives infructueuses.

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

Maintenant qu’on dispose d’une connexion WiFi, on va envoyer à intervalle régulier un message au serveur. Pour cela, on doit créer un objet client qui se connectera au serveur.

WiFiClient client;

if (!client.connect(host, port)) {
  Serial.println("connection failed");
  return;
}

On construit ensuite une chaine dans laquelle on va encoder les données envoyées au serveur. Ici le temps passé depuis le démarrage de l’ESP8266 ainsi que l’adresse IP de ce dernier.

String url = "/watchdog?command=watchdog&uptime=";
    url += String(millis());
    url += "&ip=";
    url += WiFi.localIP().toString();

Il ne reste plus qu’à envoyer le message au serveur

client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" + 
               "Connection: close\r\n\r\n");

Si comme moi, vous trouvez que l’écriture de cette commande est difficile, nous allons voir comment améliorer ça juste après.

Voici le code complet du sketch.

/*
 * TCP/IP communication ESP8266WiFi
 * Copyright (C) 2017 https://www.projetsdiy.fr - http://www.diyprojects.io
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <ESP8266WiFi.h>
const char* ssid     = "enter_your_ssid";      // SSID
const char* password = "enter_your_password";  // Password
const char* host = "enter_server_IP";  // IP du serveur - Server IP
const int   port = 8080;               // Port du serveur - Server Port
const int   watchdog = 5000;           // Fréquence du watchdog - Watchdog frequency
unsigned long previousMillis = millis(); 

void setup() {
  Serial.begin(115200);
  Serial.print("Connecting to ");
  Serial.println(ssid);
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");  
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  unsigned long currentMillis = millis();

  if ( currentMillis - previousMillis > watchdog ) {
    previousMillis = currentMillis;
    WiFiClient client;
  
    if (!client.connect(host, port)) {
      Serial.println("connection failed");
      return;
    }

    String url = "/watchdog?command=watchdog&uptime=";
    url += String(millis());
    url += "&ip=";
    url += WiFi.localIP().toString();
    
    // Envoi la requete au serveur - This will send the request to the server
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" + 
               "Connection: close\r\n\r\n");
    unsigned long timeout = millis();
    while (client.available() == 0) {
      if (millis() - timeout > 5000) {
        Serial.println(">>> Client Timeout !");
        client.stop();
        return;
      }
    }
  
    // Read all the lines of the reply from server and print them to Serial
    while(client.available()){
      String line = client.readStringUntil('\r');
      Serial.print(line);
    }
  }
}

Connexion sécurisée HTTPS : WiFiClientSecure

La sécurisation de la connexion HTTP n’est pas prise en charge nativement par la librairie ESP8266WiFi. Pour cela, il faut intégrer la librairie WiFiClientSecure.h. Si vous en avez besoin, voici un exemple disponible sur GitHub ainsi que la discussion qui traite du sujet.

La librairie ESP8266HTTPClient

Comme vous avez pu voir dans l’exemple précédent, on envoi un message au serveur à l’aide de la fonction client.print() dans laquelle on passe une chaine de caractère qui contient la commande HTTP. C’est efficace mais pas forcément super sympa à utiliser surtout si on est pas un pro du Web. Pour faire quelque chose de “plus propre” et plus poussé, il existe la librairie ESP8266HTTPClient. C’est aussi une adaptation d’une librairie Arduino (ArduinoHTTPClient) pour l’ESP8266. Elle est disponible depuis le gestionnaire de bibliothèque de l’IDE Arduino.

On va donc créer un objet http au début du sketch

HTTPClient http;

On construit l’url exactement de la même façon que précédemment.

String url = "/watchdog?command=watchdog&uptime=";
    url += String(millis());
    url += "&ip=";
    url += WiFi.localIP().toString();

Avant d’envoyer la requête on passe les paramètres à l’objet http comme ceci

http.begin(host,port,url);

On dispose maintenant de trois classes distincts correspond aux requêtes HTTP les plus classiques : GET (demande de données), POST (envoi de données) et PUT (envoi de fichier). Ici on va faire un requête GET pour simuler la réception d’une réponse du serveur

int httpCode = http.GET();

Chaque classe renvoi un code permettant de savoir si la requête à pu aboutir. Le code respecte la norme RFC7231 (source).

typedef enum {
    HTTP_CODE_CONTINUE = 100,
    HTTP_CODE_SWITCHING_PROTOCOLS = 101,
    HTTP_CODE_PROCESSING = 102,
    HTTP_CODE_OK = 200,
    HTTP_CODE_CREATED = 201,
    HTTP_CODE_ACCEPTED = 202,
    HTTP_CODE_NON_AUTHORITATIVE_INFORMATION = 203,
    HTTP_CODE_NO_CONTENT = 204,
    HTTP_CODE_RESET_CONTENT = 205,
    HTTP_CODE_PARTIAL_CONTENT = 206,
    HTTP_CODE_MULTI_STATUS = 207,
    HTTP_CODE_ALREADY_REPORTED = 208,
    HTTP_CODE_IM_USED = 226,
    HTTP_CODE_MULTIPLE_CHOICES = 300,
    HTTP_CODE_MOVED_PERMANENTLY = 301,
    HTTP_CODE_FOUND = 302,
    HTTP_CODE_SEE_OTHER = 303,
    HTTP_CODE_NOT_MODIFIED = 304,
    HTTP_CODE_USE_PROXY = 305,
    HTTP_CODE_TEMPORARY_REDIRECT = 307,
    HTTP_CODE_PERMANENT_REDIRECT = 308,
    HTTP_CODE_BAD_REQUEST = 400,
    HTTP_CODE_UNAUTHORIZED = 401,
    HTTP_CODE_PAYMENT_REQUIRED = 402,
    HTTP_CODE_FORBIDDEN = 403,
    HTTP_CODE_NOT_FOUND = 404,
    HTTP_CODE_METHOD_NOT_ALLOWED = 405,
    HTTP_CODE_NOT_ACCEPTABLE = 406,
    HTTP_CODE_PROXY_AUTHENTICATION_REQUIRED = 407,
    HTTP_CODE_REQUEST_TIMEOUT = 408,
    HTTP_CODE_CONFLICT = 409,
    HTTP_CODE_GONE = 410,
    HTTP_CODE_LENGTH_REQUIRED = 411,
    HTTP_CODE_PRECONDITION_FAILED = 412,
    HTTP_CODE_PAYLOAD_TOO_LARGE = 413,
    HTTP_CODE_URI_TOO_LONG = 414,
    HTTP_CODE_UNSUPPORTED_MEDIA_TYPE = 415,
    HTTP_CODE_RANGE_NOT_SATISFIABLE = 416,
    HTTP_CODE_EXPECTATION_FAILED = 417,
    HTTP_CODE_MISDIRECTED_REQUEST = 421,
    HTTP_CODE_UNPROCESSABLE_ENTITY = 422,
    HTTP_CODE_LOCKED = 423,
    HTTP_CODE_FAILED_DEPENDENCY = 424,
    HTTP_CODE_UPGRADE_REQUIRED = 426,
    HTTP_CODE_PRECONDITION_REQUIRED = 428,
    HTTP_CODE_TOO_MANY_REQUESTS = 429,
    HTTP_CODE_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
    HTTP_CODE_INTERNAL_SERVER_ERROR = 500,
    HTTP_CODE_NOT_IMPLEMENTED = 501,
    HTTP_CODE_BAD_GATEWAY = 502,
    HTTP_CODE_SERVICE_UNAVAILABLE = 503,
    HTTP_CODE_GATEWAY_TIMEOUT = 504,
    HTTP_CODE_HTTP_VERSION_NOT_SUPPORTED = 505,
    HTTP_CODE_VARIANT_ALSO_NEGOTIATES = 506,
    HTTP_CODE_INSUFFICIENT_STORAGE = 507,
    HTTP_CODE_LOOP_DETECTED = 508,
    HTTP_CODE_NOT_EXTENDED = 510,
    HTTP_CODE_NETWORK_AUTHENTICATION_REQUIRED = 511
}

Il est donc très facile de savoir si le message a bien été reçu par le serveur. On récupère le contenu du message (payload) à l’aide de la classe http.getString().

if (httpCode) {
  if (httpCode == 200) {
    String payload = http.getString();
    Serial.println(payload);
  }
}

Voici le code modifié basée. L’ESP8266 cherchera le meilleur réseau WiFi sur lequel se connecter. Durant la phase d’inactivité, le WiFi est coupé à l’aide de la classe WiFi.disconnect().

/*
 * TCP/IP communication ESP8266HTTPClient
 * Copyright (C) 2017 https://www.projetsdiy.fr - http://www.diyprojects.io
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <ESP8266WiFiMulti.h>

const char* host = "192.168.1.33";
const int  port = 8080;
const int   watchdog = 5000;
unsigned long previousMillis = millis(); 

ESP8266WiFiMulti wifiMulti;
HTTPClient http;

void setup() {
  Serial.begin(115200);
  delay(10);

  // We start by connecting to a WiFi network
  wifiMulti.addAP("ssid1", "psk1");
  wifiMulti.addAP("ssid2", "psk2");

  Serial.println("Connecting Wifi...");
  if(wifiMulti.run() == WL_CONNECTED) {
    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.print(WiFi.localIP());
  }
  Serial.setDebugOutput(true);
  
}

int value = 0;

void loop() {
  unsigned long currentMillis = millis();

  if ( currentMillis - previousMillis > watchdog ) {
    previousMillis = currentMillis;

    if(wifiMulti.run() != WL_CONNECTED) {
      Serial.println("!!");
    } else {  
      Serial.println("WiFi connected");
      Serial.println("IP address: ");
      Serial.println(WiFi.localIP());
    
      String url = "/watchdog?command=watchdog&uptime=";
      url += String(millis());
      url += "&ip=";
      url += WiFi.localIP().toString();
      
      Serial.print("connecting to ");
      Serial.println(host);
      Serial.print("Requesting URL: ");
      Serial.println(url);
     
      http.begin(host,port,url);
      int httpCode = http.GET();
      if (httpCode) {
        if (httpCode == 200) {
          String payload = http.getString();
          Serial.println(payload);
        }
      }
      Serial.println("closing connection");
      http.end();
      WiFi.disconnect();
    }
  }
}

On peut attendre une éventuelle réponse du serveur. Si vos transmettez à un serveur domotique, il y a de grande change qu’il vous renvoi un status:OK, au minimum, vous devriez recevoir une réponse de code 200 signifiant que le message a correctement été réceptionné par le serveur. Vous pouvez imaginer d’autre traitements en fonction de la réponse : mettre dans un pile et recommencer ultérieurement, supprimer la mesure ou au contraire la stocker dans un journal, ajouter dans un journal l’événement et le message d’erreur (pour faciliter la mise au point), piloter le GPIO (faire clignoter une LED)…

Un serveur de test en Node.js pour communiquer avec l’ESP8266

Pour tester les différentes librairies, je vous propose de développer rapidement un petit serveur Node.js. Dans les prochains tutoriels, nous irons plus loin en mettant en place une communication complète avec quelques serveurs domotiques (Jeedom, Domoticz, Home Assistant). Si vous débutez avec Node.js, suivez ce tutoriel pour installer et découvrir Node.js

Pour ce serveur, vous aurez besoin d’installer les packages moment, express.

sudo npm moment express

Ouvrez un éditeur de texte et créez un nouveau fichier appelé server.js en y collant ce code

/*
*   Serveur de test pour librairies ESP8266WiFi et ESP8266HTTPClient
*   Test server for ESP8266WiFi and ESP8266HTTPClient libraries
*   https://www.projetsdiy.fr - 2017
*/
var express = require('express');
var moment = require('moment');
var app = express();

app.get('/', function(req, res) {
  res.send('HTTP ESP8266 Test Server')
});

app.use('/watchdog', function (req, res, next) {
  var t = moment.duration(parseInt(req.param('uptime')), 'milliseconds')
  var _message = req.param('ip') + " uptime " + t.hours() + "h " + t.minutes() + "m " + t.seconds() +"s";
  console.log("watchdog from " + _message);
  res.send("You are alive!");
});

app.listen(8080);

Ouvrez le Terminal (ou PowerShell sous Windows). Placez vous dans le répertoire dans lequel vous avez enregistré le fichier server.js et démarrez le serveur avec la commande node server.js  ou nodemon server.js  (nodemon s’occupe de redémarrer le serveur à chaque modification des fichiers).

A chaque message reçu, le serveur récupère les données passées en paramètres et construit un message d’information qui est ensuite envoyé sur le Terminal.

serveur test communication tcp ip http esp8266wifi

SocketTest : un serveur de test

Si vous n’avez pas le courage de vous lancer avec Node.js, vous pouvez opter pour SocketTest qui est un petit programme qui démarre un serveur de test sur votre machine. Vous pouvez le récupérer sur Sourceforge ici. SocketTest fonctionne sur macOS (lancez SocketTest.jar), Windows (SocketTest.exe) et Linux (SocketTest.sh).

 sockettest sourceforge test esp8266wifi

Allez à l’onglet Server puis indiquez l’adresse ip de votre machine. Il faut absolument indiquer l’adresse ip de la machine sur lequel fonctionne SocketTest pour que ça fonctionne.

Ensuite démarrez le serveur en cliquant sur Start Listening. Vous allez recevoir vos premiers messages (en fonction de la fréquence d’envoi définie par la variable watchdog).

sockettest watchdog esp8266wifi

Vous pouvez envoyer une réponse à l’ESP8266 en le saisissant dans le champ message puis en cliquant sur Send. Par exemple ici, j’ai répondu OK qui apparait dans la console sous S: OK. Si vous avez ouvert le moniteur série sur l’IDE Arduino, vous pourrez voir le message reçu. Si vous ne répondez pas dans le temps prévu dans le programme (ici 5 secondes), vous aurez un message d’erreur (>>> Client Timeout !) avant que le client ne se déconnecte.

Remarque. Les réponses envoyées par SocketTest ne sont pas réceptionnées avec la librairie ESP8266HTTPClient. A creuser…

sockettst watchdog send response esp8266wifi client

Vous connaissez maintenant les 3 principales librairies permettant de faire communiquer un programme Arduino/ESP8266 en TCP/IP à l’aide de requêtes HTTP. Il nous reste maintenant à mettre en pratique tout ça sur des cas concrets. Nous verrons dans les prochains tutoriels comment envoyer simplement des mesures de température (ou n’importe quoi d’autre d’ailleurs) à Domoticz, Jeedom et Home Assistant.

Avez-vous aimé cet article ?
[Total: 4 Moyenne: 5]
Partager sur facebook
Partager sur twitter
Partager sur linkedin
Partager sur pinterest
Partager sur email
Partager sur telegram

Vous avez aimé ce projet ? Ne manquez plus aucun projet en vous abonnant à notre lettre d’information hebdomadaire!

quel modèle esp8266 choisir
Quel modèle d'ESP8266EX choisir en 2020 ?
guide choix esp32 development board
Quel ESP32 choisir en 2020 ?

Vous rencontrez un problème avec ce sujet ?

Peut-être que quelqu’un a déjà trouvé la solution, visitez le forum avant de poser votre question

9 Commentaires
  1. Bonjour,
    Suite aux lectures des divers Projets DIY concernant les modules ESP en les modes WiFi, j’ai remarqué que les variables int doivent être transformées en String avant de les soumettre à la fonction client.print

    Mes essais de conversions String(variable_x _int()) n’ont pas été pris en compte ni par ce genre de conversion WiFi.localIP().toString() lorsque l’on est dans la fonction client WebServer.available(); .
    J’ai donc converti ma variable_int en créan une variable _String et par simplement variable_String = variable_int !

    Je n’ai peut être mal formulé mes lignes de commandes, je ne suis pas un féru comme bien d’entre vous.
    Il existe surement d’autres façons de régler ce problème !

    Merci encore, j’ai pu avancer dans mes réalisations.
    L’Arsène.

  2. Bonjour,
    Je me suis beaucoup inspiré de vos projets et vous en remercie.
    Dans ce projets il est question de faire apparaitre (entre autres) sur la page web la valeur de la variable millis à la ligne url += String(millis());
    Je souhaiterai vous soumettre ma question qui parait bête mais dont je n’ai pas trouvé de réponse précise sur le net ! Comment faire apparaitre une variable int Ma_variable par expemple, sur la page web ?
    D’avance je vous remercie pour votre réponse.
    L’Arsène
    .

  3. Bonjour,
    Je désirerais, avec un esp8266 + A7 ou Sim808, envoyer un fichier contenu dans ma sdcard dans un répertoire
    de mon site et cela depuis n’importe quel endroit à l’extérieur loin de mon domicile, donc sans passer par ma wifi.
    Je n’arrive pas à avoir, depuis pas mal de temps, un exemple s’y rapportant, il y a toujours la wifi avec son id° et
    Mtpasse…
    J’ai un esp8266, un module SdCard et un module A7 ou SIM808 et le soft Arduino.
    Pour écrire sur SD >> c’est OK, pour les trames GPGGA >> c’est OK, pour les SMS >> c’est OK mais
    pour le FTP sur mon site, c’est KO !!!
    Merci pour votre aide !
    Philippe

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Domotique et objets connectés à faire soi-même
Vous avez aimé ce tutoriel

Ne manquez plus les prochains projets

Recevez chaque semaine le récapitulatif des tutoriels et projets.

Vous pouvez vous désabonner à tout moment.