mercredi 15 décembre 2021

ESP8266 & ESP32 : Connexion au Réseau WIFI

 


 ESP8266 & ESP32 : Connexion au Réseau WIFI

 

Dans cet article nous allons étudier la mise en œuvre d'une connexion fiable au réseau WIFI. En général on commence par implémenter un code sur table, et on installe le montage ensuite à l'endroit prévu. Ce n'est pas forcément la bonne méthode.

Il serait dommage de s'engager dans un développement conséquent, si au bout du compte, le module, une fois installé à l'endroit prévu, est inaccessible.

1. Perte de connexion

Il peut arriver qu'un module ESP8266 ou ESP32 perde sa connexion au réseau. Les raisons sont multiples :

  • couverture WIFI insuffisante
  • redémarrage du point d'accès
  • conditions atmosphériques, humidité en particulier
  • etc.

Il existe différentes techniques permettant une reconnexion automatique. Beaucoup de tutoriels existent sur le sujet :

https://randomnerdtutorials.com/solved-reconnect-esp32-to-wifi/

https://randomnerdtutorials.com/solved-reconnect-esp8266-nodemcu-to-wifi/

Il ne faut pas négliger ce point, et quelque soit la technique employée, il est préférable d'en utiliser une, et de la tester, plutôt que de ne rien faire.

2. Mesurer l'intensité du signal WIFI

La reconnexion automatique est un moyen de palier à une perte de connexion au réseau, mais est-ce suffisant ?

Il peut sembler évident que, si la reconnexion échoue, le problème a probablement une origine physique : éloignement, présence de murs épais, etc.

Avec un téléphone mobile, il est possible d'apprécier la force du signal WIFI. Mais il faut savoir que tous les téléphones ne se valent pas d'un point de vue réception. Il en va de même pour nos petits modules ESP8266 et ESP32.

Dans un coin de mon atelier où la couverture WIFI est assez mauvaise, j'ai testé quelques cartes :

  • WEMOS LOLIN D32 : OK
  • ESP32 DEVKIT C : OK
  • WEMOS D1 MINI : OK
  • HELTEC WiFi Kit 32 : KO
  • mon téléphone : KO

Il va sans dire que si j'avais un serveur ESP32 à mettre en place à cet endroit je ne choisirais certainement pas la HELTEC WiFi Kit 32.

Commençons pas charger un petit logiciel permettant de tester notre connexion :

https://bitbucket.org/henri_bachetti/basic-server/src/master/arduino/basic-web-server/basic-web-server.ino

Dans cet exemple, que l'on peut compiler pour ESP32 ou ESP8266, une gestion par événements comme celle décrite dans les tutoriels cités plus haut a été mise en place :
  • onStationConnected()
  • onStationDisconnected()
  • onStationGotIP()

L'implémentation pour un ESP32 ou un ESP8266 n'est pas fondamentalement différente.

Note pour les débutants : voici une petite astuce pour écrire du code pouvant se compiler sur les deux plateformes :

#ifdef ESP32
// code ESP32
#else
// code ESP8266
#endif

Il suffit ensuite de choisir la bonne carte dans le menu Outils/Type de Carte de l'IDE ARDUINO pour que la compilation se fasse avec la bonne option.

Au démarrage de la carte, la LED s'allume, et elle s'éteint lorsqu'elle est connectée au réseau. Si la carte n'est pas équipée d'une LED (ESP32 DevKitC par exemple), il est facile d'en ajouter une (avec une résistance de quelques KΩ en série) sur une GPIO et de modifier le code :

#define LED               LED_BUILTIN  // la LED de la carte
#define LED_CMD     LOW           // commande par un niveau bas (c'est souvent le cas)

A remplacer par :

#define LED              23
#define LED_CMD     HIGH

Dans cet exemple, la LED est sur la GPIO23 et elle se commande par un niveau haut. Elle est donc reliée par une résistance à GND.

Au démarrage l'adresse IP de la carte est affichée sur le moniteur série. Il suffit de s'y connecter avec un navigateur. La page affichée par le serveur est la suivante :

A l'aide de cette page, nous allons pouvoir tester la réactivité de notre serveur, à différents endroits de l'habitation. Le bouton ON permet d'allumer la LED de la carte, ensuite son libellé change pour devenir OFF, et permet d'éteindre la LED.

La puissance du signal est également affichée. Dans sa dernière version, la date et l'heure du dernier boot et le nombre de connexions au réseau WIFI sont également affichés, ce qui peut permettre de savoir à distance si le nombre de reconnexions est important ou non.

Si on le désire, un petit écran I2C OLED SSD1306 peut être relié au module, et permet d'afficher différentes informations :
  • nombre de connexions au réseau WIFI
  • date et heure du dernier boot
  • adresse MAC
  • adresse IP
  • RSSI, la puissance du signal

Les pins à relier sont les suivantes :

  • Vin    3.3V
  • GND    GND
  • ESP32 :
    • SCL    GPIO22
    • SDA    GPIO21
  • ESP8266 :
    • SCL    GPIO5 (D1)
    • SDA    GPIO4 (D2)

Ce petit écran est optionnel. S'il est absent, le serveur fonctionnera tout de même.

Si l'on raccorde l'écran, le montage devient autonome, et nous allons pouvoir déplacer celui-ci dans l'habitation, en l'alimentant à l'aide d'un bloc secteur, ou d'un POWER-BANK, et mesurer rapidement la force du signal WIFI là où c'est nécessaire.

Une carte WEMOS D1 MINI, assez éloignée du point d'accès, affiche les informations suivantes sur le moniteur série :

Connecting to AP-XXXXX
HTTP server started
Station disconnected: Disconnected from WiFi access point
WiFi lost connection. Reason: 2
Trying to reconnect to
AP-XXXXX
Station disconnected: Disconnected from WiFi access point
WiFi lost connection. Reason: 201
Trying to reconnect to
AP-XXXXX
Connected to AP successfully!
WiFi connected to
AP-XXXXX
IP address: 192.168.1.59
Station disconnected: Disconnected from WiFi access point
WiFi lost connection. Reason: 200
Trying to reconnect to Livebox-E987
Station disconnected: Disconnected from WiFi access point
WiFi lost connection. Reason: 201
Trying to reconnect to
AP-XXXXX
Station disconnected: Disconnected from WiFi access point
WiFi lost connection. Reason: 2
Trying to reconnect to
AP-XXXXX
Connected to AP successfully!
WiFi connected to
AP-XXXXX
IP address: 192.168.1.59

On constate qu'après s'être connecté une première fois avec succès, la connexion est perdue, puis retrouvée.

A cet endroit le niveau du signal est de -96 dBm, ce qui est faible.

A noter : en utilisant le même code, compilé et chargé dans une carte WEMOS LOLIN D32, le serveur affiche -88dBm, ce qui est un peu mieux. Toutes les cartes ESP8266 et ESP32 ne se valent pas d'un point de vue réception, et l'adoption d'une carte différente peut parfois sauver une situation problématique.

3. WIFI manager

Certains d'entre vous connaissent certainement la librairie WIFIManager.

Si ce n'est pas le cas, voici quelques explications : c'est une librairie qui permet de choisir le réseau WIFI auquel se connecter via une interface HTML.

Cela dispense donc de préciser dans le code le SSID et le mot de passe à utiliser, le choix étant fait par l'utilisateur lors du premier démarrage, à l'aide de n'importe quel appareil disposant du WIFI (téléphone, tablette, ordinateur).

Il existe beaucoup de tutoriels sur le sujet :

https://randomnerdtutorials.com/wifimanager-with-esp8266-autoconnect-custom-parameter-and-manage-your-ssid-and-password/

Le SSID et le mot de passe choisis sont enregistrés dans la mémoire FLASH de l'ESP et à chaque démarrage, celui-ci essaie de s'y connecter. S'il n'y parvient pas, il démarre un réseau en mode Access Point (192.168.4.1) et l'utilisateur peut s'y connecter pour faire son choix.

ATTENTION : cela veut clairement dire que si la connexion WIFI est de mauvaise qualité ou que le réseau est inaccessible à un moment donné, il faudra repasser par une configuration. D'où l'intérêt de rechercher une bonne qualité de connexion.

4. Essais

Le sketch a été compilé sur une WEMOS D1 MINI et une LOLIN D32. A l'endroit où les deux cartes ont été installées, le niveau du signal WIFI est de -80dBm à -86dBm. Au bout de quelques jours le nombre de connexions au réseau WIFI est de 1, ce qui indique clairement que le signal est suffisant.

Un autre montage WEMOS D1 MINI situé en cave montre un nombre de reconnexions de 7 au bout d'un mois, avec un niveau du signal WIFI égal à -83dBm.

5. Conclusion

Pour conclure, je conseillerais d'adopter systématiquement certaines habitudes afin de mettre toutes les chances de notre côté :

  • dans le code, mettre en place une reconnexion automatique
  • tester la connexion WIFI à l'endroit où l'on désire installer le montage, si possible avec plusieurs cartes différentes
  • choisir une "bonne carte" ESP8266 ou ESP32

Des solutions de secours existent, répéteur, point d'accès supplémentaire, pour les cas désespérés. On peut également essayer une carte ESP8266 ou ESP32 possédant un connecteur pour le raccordement d'une antenne WIFI externe.

Une connexion WIFI de grande qualité n'est pas forcément nécessaire dans toutes les situations. S'il s'agit d'envoyer des valeurs de température et d'humidité à un serveur toutes les 30 minutes, on peut se contenter d'une qualité moyenne. S'il s'agit de surveiller un réservoir d'eau et d'agir sur une vanne en fonction du niveau pour empêcher son débordement et une inondation, cela pourrait être plus problématique.


Cordialement

Henri

6. Mises à jour

27/12/2021 : affichage de la date et l'heure du dernier boot
                     affichage du nombre de connexions au réseau WIFI

 

samedi 4 décembre 2021

ESP32 : Prototypage

 

ESP32 : Prototypage


Dans cet article nous allons voir comment mettre en œuvre un ESP32 sur une carte de prototypage.

La carte se trouve facilement sur AliExpress : 3.65€ ESP-WROOM-32 compris.

1. Le but

Le but est de pouvoir disposer d'un ESP32 avec un minimum de composants périphériques, afin de pouvoir prototyper des montages à réaliser avec des modules nus, avant de les finaliser par l'étude d'un PCB maison.

Module ESP-WROMM-32 nu

1.2. Les avantages

Pourquoi préférer un module nu et pour quel type de montage?

1.2.1. Consommation

Utiliser un module nu est le seul moyen d'obtenir une consommation très faible en mode sommeil profond. On parvient facilement à atteindre 5µA.

Il sera impossible d'obtenir un tel résultat avec une carte de développement. La LOLIN32 par exemple, alimentée par sa broche 3.3V, consomme 1.7mA en mode veille, soit 340 fois plus.

Avec un module nu, l'énergie consommée sera de :

E = 5µA * 24 * 30 = 3600µAH, soit 3.6mAH par mois.

1.2.2. Encombrement

L'encombrement sera très réduit. Un module nu se suffit à lui-même et ne nécessite aucun composant externe pour pouvoir fonctionner, à part une alimentation.

1.2.3. Pérennité

La pérennité des cartes ESP32 n'est pas assurée sur le long terme. Si l'on désire enficher une carte sur un PCB maison, l'implantation devra être ré-étudiée à chaque fois que la carte évoluera, ou sera remplacée par un nouveau modèle. Par exemple la WEMOS LOLIN D32 a fortement évolué. Même le brochage est différent :

WEMOS LOLIN D32

 

WEMOS LOLIN D32

Sur le marché un module nu aura une durée de vie forcément supérieure.

1.2.4. Coût

Dernier atout : le coût d'un module nu est faible.

1.2. Quelles applications ? 

Si l'on n'a aucun impératif de consommation, un module nu n'est utile que si l'on cherche à gagner en encombrement, ou en pérennité.

Par ailleurs, si l'ESP32 est utilisé dans une application où il fonctionne en serveur WEB, la consommation sera de toutes façons importante, au minimum 100mA. L'intérêt du module nu en matière de consommation est faible, s'il est utilisé comme serveur.

Pour toute autre application, si l'ESP32 passe le plus clair de son temps en sommeil profond, et se réveille périodiquement pour envoyer des données à un serveur, le module nu est très intéressant :

  • capteurs de température, humidité, pression
  • surveillance de niveau
  • détection de passage
  • etc.

2. Le hardware

2.1. Convertisseur USB

Celui-ci n'est utile que pour la programmation de l'ESP32, et la mise au point. Quand le montage sera en exploitation ce convertisseur sera plus encombrant qu'autre chose. Pendant la phase de mise au point on utilisera un module séparé comme celui-ci :

Module FT232R 3.3V/5V

Ce convertisseur est équipé d'un cavalier permettant de le faire travailler sous 3.3V, ce qui est impératif pour un ESP32.

2.2. Régulateur de tension

Celui-ci sera ajouté, ou pas, en fonction de l'alimentation prévue :

  • batterie LITHIUM-ION : régulateur 3.3V 500mA LDO
  • batterie LIFEPO4 : aucun
  • secteur : régulateur 500mA au choix
    • 3.3V : alimentation par la broche 3.3V
    • 5V : alimentation par la broche 5V, ou VIN

Les régulateurs 3.3V 500mA LDO sont assez peu nombreux : ME6211, RT9013, RT9080.

Voir leurs caractéristiques ici : Les régulateurs LDO

A noter un nouveau venu dans la liste : le RT9080 et ses 2µA de consommation propre, qui équipe la carte FireBeetle.

3. La carte prototype

3.1. La carte de développement

Pour prototyper un montage à base de module nu, on peut bien entendu utiliser n'importe quelle carte de développement ESP32, à condition de bien maîtriser son schéma.

Autant partir d'une carte simple, une FireBeetle par exemple :

Schéma de la FireBeetle

Cette carte est une des meilleures du marché, avec ses 10µA de consommation en mode veille. Elle est relativement chère : une dizaine d'euros.

Avec la majeure partie des carte du commerce, on ne pourra malheureusement pas mesurer la vraie consommation en mode veille, car elle sont équipées de composants qui consomment eux-mêmes pas mal de courant, en particulier les cartes équipées de régulateurs AMS1117, qui consomme 5mA à lui tout seul.

 

Sur ce modèle on peut implanter soi-même un ESP32 sans aucune soudure !

Par contre elle est équipée de composants pouvant provoquer une surconsommation : LEDs, régulateur AMS1117. C'est pour cela que je ne la classe pas dans la catégorie des cartes de prototypage minimalistes.

3.2. Cartes de prototypage minimalistes

Seule une carte de prototypage de ce type permettra d'obtenir un résultat au plus près de la réalité au niveau consommation.

Une carte prototype minimaliste est à équiper de quelques composants :

  • un ESP32
  • deux boutons RESET et BOOT avec leurs résistances de pullup
  • deux connecteurs

Il en existe divers modèles, avec des brochages différents :

 



 

Ce dernier modèle est équipé d'un connecteur séparé à 3 broches pour le convertisseur USB/série. Elle est la seule a pouvoir être implantée sur une breadboard.

3.2.1. La préparation

Il faut d'abord souder l'ESP32 sur la carte. Les broches de ce microcontrôleur sont espacées de 1.27mm. Pour cette opération, la panne du fer à souder doit être très fine : 

Voici la panne, montrée ici à côté de l'ESP32. Il s'agit d'une WELLER dont la pointe a un diamètre de 0.8mm.

Il ne faut pas espérer réaliser cette opération avec de la soudure sans plomb. La soudure utilisée est de la Sn.Pb 60%/40% 0.5mm.

Je conseille de commencer par déposer une petite goutte de soudure sur l'un des pads de la carte, dans un angle. Ensuite :

  • positionner l'ESP32 et souder la broche correspondante sur ce pad, sans ajout de soudure
  • repositionner éventuellement l'ESP32 de manière plus précise
  • bien vérifier l'alignement des broches de l'ESP32 avec tous les pads
  • souder une broche dans l'angle opposé de l'ESP32
  • revérifier : c'est votre dernière chance pour repositionner l'ESP32
  • souder les autres broches

On trouve pas mal de vidéos sur le WEB : 

Je pense que c'est à la portée de n'importe quel amateur possédant un fer à souder correct. Un casque loupe peut être utile :

Souder ensuite les deux résistance, les boutons et les connecteurs.

La carte prototype que j'ai acheté n'était pas livrée avec ses 2 résistances de 10KΩ. Comme je disposais de modèles 0805, trop grosses, je les ai soudées en les décalant légèrement :

A noter : j'ai préféré implanter des connecteurs femelles à la place des connecteurs mâles livrés avec la carte. Les fils DUPONT mâles sont moins sujets à faux contacts.

3.2.2. Le premier essai

Un essai rapide peut être réalisé immédiatement.

Pour cela, contrairement à une carte ESP32, il faudra disposer d'une alimentation 3.3V pouvant débiter au moins 500mA. La broche VCC du convertisseur USB/série ne produit pas assez de courant pour alimenter un ESP32.

Ensuite il faudra relier quelques broches :

  • 3.3V de l'alimentation : broche 3.3V de l'ESP32
  • GND de l'alimentation : broche GND de l'ESP32
  • TX du convertisseur USB : broche RX de l'ESP32
  • RX du convertisseur USB : broche TX de l'ESP32
  • GND du convertisseur USB : broche GND de l'ESP32

On peut s'aider d'une breadboard pour réunir les masses :

Charger ensuite l'exemple HelloServer : HelloServer.ino

Remplacer ssid et password par ceux de votre box, et compiler.

Le chargement s'opère de la façon suivante :

  • appuyer sur le bouton BOOT (GPIO0)
  • appuyer sur le bouton RESET
  • relâcher le bouton RESET 
  • relâcher le bouton BOOT
  • téléverser

Connecting........_____...
Chip is ESP32-D0WDQ6 (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
Crystal is 40MHz
MAC: 24:62:ab:dd:af:f0
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 921600
Changed.
Configuring flash size...
Auto-detected Flash size: 4MB
Compressed 8192 bytes to 47...
Writing at 0x0000e000... (100 %)
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.0 seconds (effective 4085.3 kbit/s)...
Hash of data verified.
Compressed 18656 bytes to 12053...
Writing at 0x00001000... (100 %)
Wrote 18656 bytes (12053 compressed) at 0x00001000 in 0.1 seconds (effective 1037.3 kbit/s)...
Hash of data verified.
Compressed 653600 bytes to 399812...
Writing at 0x00010000... (4 %)
Writing at 0x00014000... (8 %)
Writing at 0x00018000... (12 %)
Writing at 0x0001c000... (16 %)
Writing at 0x00020000... (20 %)
Writing at 0x00024000... (24 %)
Writing at 0x00028000... (28 %)
Writing at 0x0002c000... (32 %)
Writing at 0x00030000... (36 %)
Writing at 0x00034000... (40 %)
Writing at 0x00038000... (44 %)
Writing at 0x0003c000... (48 %)
Writing at 0x00040000... (52 %)
Writing at 0x00044000... (56 %)
Writing at 0x00048000... (60 %)
Writing at 0x0004c000... (64 %)
Writing at 0x00050000... (68 %)
Writing at 0x00054000... (72 %)
Writing at 0x00058000... (76 %)
Writing at 0x0005c000... (80 %)
Writing at 0x00060000... (84 %)
Writing at 0x00064000... (88 %)
Writing at 0x00068000... (92 %)
Writing at 0x0006c000... (96 %)
Writing at 0x00070000... (100 %)
Wrote 653600 bytes (399812 compressed) at 0x00010000 in 6.4 seconds (effective 811.8 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 128...
Writing at 0x00008000... (100 %)
Wrote 3072 bytes (128 compressed) at 0x00008000 in 0.0 seconds (effective 1530.3 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Si le chargement ne se fait pas :

  • vérifier les soudures des boutons
  • vérifier les soudures des résistances
  • vérifier les connexions

Il n'a plus qu'à appuyer une fois sur RESET pour relancer l'ESP32. Le moniteur série affiche ceci :

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:10944
load:0x40080400,len:6388
entry 0x400806b4
 
.....
Connected to SSID-ABCDEF
IP address: 192.168.1.48
MDNS responder started
HTTP server started

Et si l'adresse IP affichée est entrée dans un navigateur :

hello from esp32!

Voilà c'est fini.

3.2.3. La consommation en mode veille

La consommation peut être mesurée à l'aide d'un multimètre en série avec l'alimentation. Mais attention, avec un multimètre sur le calibre mA ou µA l'ESP32 ne démarrera probablement pas.

Dans un premier temps, installer un fil DUPONT pour court-circuiter les bornes du multimètre. On le retirera ensuite. la breadboard trouve encore son utilité :

On voit bien les grip-fils du multimètre et le gros fil rouge qui le court-circuite.

Ensuite il suffit de charger un sketch minimal :

#include <WiFi.h>
#include <rom/rtc.h>
#include <driver/rtc_io.h>

// remplacer par vos identifiants
const char *ssid = "........";
const char *password = "........";

WiFiClient client;

void setup()
{
  byte ret;
  uint64_t wakeup_pin_mask;

  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)   {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi Connected");
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());
  Serial.println("DEEP-SLEEP");
  esp_deep_sleep_start();
}

void loop()
{
}

Après chargement et RESET, le moniteur série affiche ceci :

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:10944
load:0x40080400,len:6388
entry 0x400806b4
.....
WiFi Connected
IP: 192.168.1.48
DEEP-SLEEP

A partir du moment où DEEP-SLEEP est affiché, on peut mettre en route le multimètre sur le calibre mA et retirer le fil DUPONT. Il affichera probablement ZERO. Basculer sur le calibre µA. Pour ma part, il affiche 4.3µA !!!

4. Liens utiles

La suite ici :

ESP32 : prototypage (suite)

5. Conclusion

Le but que je poursuis est simple : pouvoir créer des capteurs WIFI, alimentés par une petite batterie LIPO 1000mAH maxi, et intégrables dans une boîte à encastrer Ø60mm, ou de petits boîtiers de dimensions réduites : 50x50mm.

Il reste bien entendu à ajouter un ou plusieurs capteurs pour rendre ce montage opérationnel. Ensuite, pourquoi ne pas explorer la possibilité de remonter les informations vers un serveur comme ThingSpeak ?

La suite de cet article coule de source :

  • améliorer le chargement, le rendre automatique
  • ajouter des capteurs
  • envoyer des données à un serveur
  • développer des mini-capteurs connectés


Cordialement

Henri