dimanche 23 août 2020

ARDUINO + ESP8266 : est-ce bien raisonnable ?

 

ARDUINO + ESP8266 :

est-ce bien raisonnable ?

 

En 2014 le premier ESP8266 dit ESP01 sortait. Ce microcontrôleur disposait de seulement 2 GPIOs. Il était utilisé principalement couplé à une carte ARDUINO, afin de bénéficier des nombreuses entrées / sorties de celle-ci.

Pour ce faire la majorité des cartes ESP01 étaient équipées d'un logiciel dit "FIRMWARE AT", permettant le dialogue avec l'ARDUINO.

Le FIRMWARE AT reçoit des commandes de la part de l'ARDUINO par la ligne série et lui renvoie un résultat :

  • AT+GMR : demande de la version
  • AT+CWMODE : fixe le mode (station, point d'accès)
  • AT+CWJAP : connexion à un point d'accès
  • etc.

Cette technologie est-elle encore viable à l'heure où de nombreuses cartes ESP8266 et ESP32, beaucoup plus riches qu'un ESP01, existent sur le marché ?

Que choisir ? un ARDUINO + ESP01, ou un ESP8266 / ESP32 tout seul ?

Nous allons essayer de mettre en œuvre les deux solutions, et nous aider de deux petits exemples de serveur WEB sur ESP32 afin de montrer les différences.

1. L'ESP01

1.1. ESP01 + convertisseur USB

Nous allons dans un premier temps utiliser l'ESP01 seul, en le reliant au PC  à l'aide d'un convertisseur USB / série.

Rappelons le brochage d'un ESP01 :

Il faut impérativement utiliser un convertisseur USB / série 3.3V ou possédant un switch ou un cavalier 5V / 3.3V. Je conseille plutôt un FT232R :


Seulement 4 fils sont nécessaires :

FT232R ESP01
VCC VCC
GND GND
TX RX
RX TX

Le premier point à vérifier est la présence du FIRMWARE AT.

On peut pour cela utiliser le moniteur série de l'IDE ARDUINO, avec les réglages suivants :

  • 115200 baud
  • fin de ligne NL + CR

Entrer la commande suivante :

AT

L'ESP01 doit répondre :

OK

Entrer la commande suivante :

AT+GMR

L'ESP01 doit répondre :

AT version:1.2.0.0(Jul  1 2016 20:04:45)
SDK version:1.5.4.1(39cb9a32)
v1.0.0
Mar 11 2018 18:27:31
OK

La version peut bien entendu être différente, en fonction de l'origine de la carte.

Si l'ESP01 ne répond pas, il est peut-être configuré avec un autre baudrate. Il faut essayer 9600 ou d'autres vitesses.

1.1.1. Recharger le FIRMWARE AT avec ESPTOOL

Si l'ESP01 ne répond toujours pas, il se peut que le FIRMWARE AT soit absent, soit il a été effacé par son propriétaire, soit remplacé par un autre sketch, soit il a été livré tel quel (ce qui est extrêmement rare).
Dans ce cas il faut le recharger. Il existe différents tutoriels sur le WEB dont la documentation "AT Instruction Set" d'ESPRESSIF :

https://www.espressif.com/sites/default/files/documentation/4a-esp8266_at_instruction_set_en.pdf

Voir : 1.2. Downloading AT Firmware into the Flash

Avant de commencer il est impératif de connaître le type de mémoire FLASH implanté sur la carte, le petit circuit à 8 pattes. Il vaut mieux disposer d'une bonne loupe :

Par exemple : t25s80 ou pn25F08 = 8Mbits

Ici un tutoriel utilisant ESPTOOL, fonctionnant sur toutes plateformes :

https://robertoostenveld.nl/esp8266-at-firmware/ 

ATTENTION : l'auteur utilise un ESP01 équipé de 512K de mémoire FLASH (FLASH 4Mbits).

Pour un ESP01 équipé d'une FLASH 8Mbits les commandes sont légèrement différentes, en particulier l'emplacement des données "esp_init_data_default" : voir la doc ESPRESSIF : 1.2.4. 8 Mbit Flash

Voici les commandes à entrer pour recharger  le FIRMWARE AT sur une carte 8Mbits (les cartes les plus courantes actuellement) :

esptool.py --port /dev/ttyUSB1 erase_flash
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0x00000 boot_v1.2.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0x01000 at/512+512/user1.1024.new.2.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0xFE000 blank.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0x7E000 blank.bin
esptool.py --port /dev/ttyUSB1 --baud 115200 write_flash --flash_mode dio 0xFC000 esp_init_data_default_v05.bin

J'ai essayé pour vous : cela fonctionne parfaitement.

Où se trouve ESPTOOL ?

ESPTOOL est installé par défaut dans le répertoire suivant :

arduino15/packages/esp8266/hardware/esp8266/2.5.2/tools/esptool/esptool.py

Le répertoire arduino15 se trouve ici :

Sous Linux : /home/username/.arduino15

Sous Windows : C:\Users\username\AppData\Local\Arduino15

Sur Mac : /Users/username/Library/Arduino15

Il y a deux solutions : modifier la variable d'environnement PATH pour lui ajouter le chemin où est installé ESPTOOL, ou utiliser le chemin complet.

1.1.2. Recharger le FIRMWARE AT avec FLASH DOWNLOAD TOOL

D'autre tutoriels utilisent FLASH DOWNLOAD TOOL, une application graphique (Windows uniquement) :

https://www.instructables.com/id/Flash-or-Upgrade-Firmware-on-ESP8266-ESP-01-Module/

Travaillant sous Linux, je n'ai pas essayé ce logiciel.

1.2. ESP01 + ARDUINO

Les ressources WEB (tutoriels, forums) sont en général plutôt simplistes et se contentent de présenter la manière de connecter un ARDUINO et un ESP01, et d'envoyer une page HTML "Hello World", rarement plus, d'où une certaine frustration des débutants, parfaitement compréhensible.

Ce tutoriel par contre, beaucoup plus complet, vous enseignera l'art et la manière de développer un serveur WEB à l'aide de commandes AT :

Tutoriel de J-M-L du forum ARDUINO

On constatera assez facilement que le code est assez conséquent (400 lignes) :

https://forum.arduino.cc/index.php?action=dlattach;topic=501923.0;attach=227323

La page WEB développée est simple, mais elle comporte néanmoins des boutons, ce qui n'est pas le cas de la majorité des tutoriels rencontrés sur le WEB :

Sincèrement je ne pense pas que ce genre de développement soit accessible à un débutant. A chacun donc de se faire sa propre idée en fonction de ses compétences et de sa compréhension de ce tutoriel.

1.3.1. Le matériel

L'ESP01 doit être alimenté en 3.3V / 500mA minimum. Il convient donc de se procurer un régulateur adéquat.

D'autre par l'entrée RX de l'ESP01 n'est pas censée supporter les 5V de la sortie TX d'un ARDUINO. Un pont diviseur sera nécessaire :

L'auteur du tutoriel ci-dessus utilise un adaptateur permettant d'assurer les fonctions alimentation et adaptation de niveau :

Certains tutoriels présentent l'ESP01 alimenté par la broche 3.3V d'une carte UNO.

Or le 3.3V d'une carte UNO est délivré par un régulateur LP2985 capable de fournir 150mA au maximum, ce qui sera insuffisant pour établir une connexion WIFI qui réclame plus de 400mA.

Avec une carte NANO, dont le 3.3V est fourni par le chip CH340, le courant sera également insuffisant.

Il faudra également alimenter l'ARDUINO en 5V par sa broche VCC ou en 7.5V ou plus par sa broche VIN ou JACK, à moins d'opter pour une carte ARDUINO 3.3V, une PRO MINI 8MHz par exemple.

On voit bien que cette solution est déjà complexe rien que pour la partie hardware.

1.3.2. La ligne série

La ligne série utilisée pour le dialogue entre l'ESP01 et l'ARDUINO est généralement la ligne série hardware de l'ARDUINO (broches RX TX) .

Cela supprime donc toute possibilité d'utiliser la sortie standard de l'ARDUINO pour afficher des informations sur le terminal, et complique te chargement du sketch (il faut libérer RX TX).

Il est possible d'utiliser deux GPIOs et un objet du type SoftwareSerial afin de libérer la ligne série matérielle.

Avec une ligne SoftwareSerial on utilisera de préférence un baudrate plus faible (9600 ou 19200 baud, peut-être plus ?). Le baudrate de l'ESP01 peut être configuré à l'aide du moniteur série ARDUINO et de la commande AT+UART_DEF :

AT+UART_DEF=9600,8,1,0,3

Enfin, les utilisateurs de cartes MEGA2560 pourront utiliser une autre liaison série hardware Serial1, Serial2 ou Serial3, afin de réserver la ligne Serial au chargement et au terminal.

1.3.3. Les ressources HTML

Il faut bien comprendre que le code HTML est envoyé à l'ESP01 par l'ARDUINO, en plusieurs morceaux si nécessaire, et que la mémoire RAM de l'ARDUINO est limitée : 2Ko (8Ko pour une MEGA). C'est peu.

Si l'on envisage de stocker des fichier ressources (HTML, JS, images), l'ARDUINO n'aura d'autre choix que d'embarquer une mémoire externe (µSD, FLASH SPI, etc.).

Le code devra assurer l'intégralité de la gestion de ces ressources et la taille mémoire de l'ARDUINO sera vite un handicap.

On comprend vite qu'un serveur WEB développé avec cette technique sera très limité.

1.3. ESP01 seul

L'ESP01 seul a des ressources limitées :

  • 2 GPIOs
  • I2C possible sur ces 2 GPIOs

Il sera difficile de raccorder plus d'un ou deux modules :

  • relais
  • LEDs
  • boutons
  • afficheur I2C, expander

Les possibilités matérielles sont assez limitées mais par contre l'ESP01 dispose de toutes les ressources d'un ESP8266 classique : capacité de calcul, mémoire RAM, FLASH, qu'un ARDUINO aura du mal à concurrencer.

Pour résumer si les deux GPIOs suffisent autant utiliser l'ESP01 seul, sans ARDUINO.

1.4. Carte UNO WIFI

Depuis quelques années des cartes toutes intégrées sont disponibles sur le marché :

Ces cartes UNO sont équipées d'un ESP01 et le connecteur USB permet de communiquer soit avec l'ATMEGA328 soit avec l'ESP01, en fonction de la position de DIP-SWITCHES. Les broches de l'ESP01 sont disponibles : voir en haut à droite.

Il est fortement conseillé de lire la documentation :

https://robotdyn.com/uno-wifi-r3-atmega328p-esp8266-32mb-flash-usb-ttl-ch340g-micro-usb.html

Cette carte a toutefois un inconvénient : il faut sans arrêt changer de configuration :

  • CH340 sur l'ATMEGA328 : chargement du sketch
  • ESP01 sur l'ATMEGA328 : exécution

Il faut donc basculer 4 switches à chaque fois. Galère ... 

On peut opter également pour une liaison SoftwareSerial en ajoutant deux fils, ce qui aura aussi un inconvénient : la vitesse réduite.

1.5. Firmware maison

Qu'il s'agisse d'un couple ARDUINO + ESP01 ou d'une carte ARDUINO WIFI rien n'empêche quiconque de développer pour ses propres besoins un firmware spécialisé afin de communiquer avec d'autres moyens qu'HTTP : MQTT par exemple, ou UDP.

Il est parfaitement possible également d'imaginer un FIRMWARE intelligent qui stockerait les pages HTML dans la mémoire FLASH de l'ESP01, et proposerait une interface permettant de les afficher en passant le nom de la page, avec une liste d'arguments variables, un peu comme on le ferait avec un écran NEXTION.

Mais dans ce cas on se demande quelle est la valeur ajoutée de l'ARDUINO ?
Un ESP8266 ou ESP32 ferait tout cela certainement mieux.

2. L'ESP8266 et l'ESP32

2.1. ESP8266

 
Une carte ESP8266 (D1 MINI par exemple) possède un certain nombre d'entrées sorties :
  • GPIOs (leur nombre dépend de la carte)
  • I2C
  • SPI
  • 1 entrée analogique

On peut examiner cette page afin de déterminer quelle carte sera capable de couvrir les besoins :

https://randomnerdtutorials.com/esp8266-pinout-reference-gpios/ 

2.2. ESP32

 

Une carte ESP32 possède un plus grand nombre d'entrées sorties (16 sorties PWM), ainsi que 18 entrées analogiques, et deux sorties DAC !

De plus, 10 GPIOS peuvent être utilisées avec des touches capacitives.

Voir ici :

https://randomnerdtutorials.com/esp32-pinout-reference-gpios/ 

2.3. Des avantages incontestables

On voit rapidement que le manque d'entrées / sorties d'un ESP8266 ou d'un ESP32 par rapport à une carte ARDUINO est un argument qui ne tient pas.

Dans le pire des cas on pourra ajouter un module expander MCP23008 ou MCP23017 :

https://riton-duino.blogspot.com/2019/02/les-extensions-de-gpios-de-larduino.html

On constatera également que d'un point de vue prix de revient le coût d'une carte ESP32 est sensiblement équivalent à celui d'un couple ARDUINO UNO + ESP01.

L'encombrement du couple ARDUINO UNO + ESP01 est également en défaveur de cette solution, ainsi que les liaisons par fils DUPONT, sources de problèmes (faux contacts).

Une dernière chose : un serveur WEB développé à l'aide d'un ESP8266 ou ESP32 disposera de ressources largement supérieures à celles d'un ARDUINO :
  • puissance de calcul
  • espace mémoire FLASH, RAM
  • espace de stockage des pages WEB

Il faut aussi noter que pour les personnes qui désireraient une intégration maximale, un module seul, soudé sur PCB, peut apporter une solution ultra-compacte :

Module ESP32


2.1. Implémenter un serveur WEB

Il existe différentes possibilités de développer un serveur WEB avec un ESP8266 ou un ESP32.

Les ressources WEB (tutoriels, cours, forums) sont également très nombreuses, beaucoup plus nombreuses que celles liées aux solutions ARDUINO + ESP01, et d'un tout autre niveau.

Sur ce blog certains projets WEB utilisent un ESP8266 ou un ESP32 :

https://riton-duino.blogspot.com/2020/03/serveur-esp32-implementation-et-test.html

https://riton-duino.blogspot.com/2020/04/un-afficheur-tft-pour-domoticz-ou.html 

https://riton-duino.blogspot.com/2020/03/arduino-ethernet-esp32-comparons.html 

https://riton-duino.blogspot.com/2020/01/un-logger-analogique-et-digital-version.html

D'autres articles plus généralistes en parlent également :

https://riton-duino.blogspot.com/2019/02/esp8266-sur-batterie.html

Dans les paragraphes suivants j'évoque les différentes possibilités d'implémentation, sans entrer dans les détails, mis à part que je fournis deux petits exemples. Il est aussi du ressort de chacun d'apprendre à se documenter sans que le travail soit prémâché. Pourquoi réécrire ce qui l'est déjà ?

Je pense que l'effort de documentation et de formation aux techniques de développement ESP8266 ou ESP32 sera moins important que celui qui sera nécessaire pour mener à bien un développement complexe à base d'ARDUINO + ESP01, et que le résultat sera autrement moins tributaire des limitations, aussi bien en matière de performances qu'en matière de vitesse de développement.

2.1.1. SPIFFS ou LittleFS

Lorsque l'on développe un serveur WEB on en vient rapidement à ne plus générer de contenu HTML avec des lignes de code, mais à l'aide de fichiers HTML stockés dans un espace dit "système de fichiers", organisé comme un disque dur.

Un ESP8266 ou un ESP32 offrira un système de fichiers en FLASH permettant le stockage de ces fichiers, ainsi que des images ou des fichiers JavaScript, tout cela sans avoir à ajouter d'espace de stockage supplémentaire (carte µSD ou FLASH SPI).

L'IDE ARDUINO permet le chargement de ces ressources à l'aide de deux plugins :

https://github.com/me-no-dev/arduino-esp32fs-plugin
https://github.com/esp8266/arduino-esp8266fs-plugin

Ces deux plugins créeront deux choix disponibles dans le menu outils :
  • ESP32 Sketch Data Upload
  • ESP8266 Sketch Data Upload

Il sera donc facile de charger les ressources à partir de l'IDE. Les fichiers à charger seront simplement placés dans un sous-répertoire data du projet.

Ensuite dans le code il suffira de lire ces fichiers et de les envoyer sur la sortie standard du serveur.

Les exemples sont nombreux sur le WEB :

https://byfeel.info/utilisation-de-la-memoire-spiffs-sur-esp8266/

Il est à noter que la librairie EspAsyncWebServer propose une méthode qui permet d'éviter de faire cela manuellement :

class AsyncWebServerRequest {
    void send(FS &fs, const String& path, const String& contentType=String(), bool download=false, AwsTemplateProcessor callback=nullptr);

Exemple :

  request->send(SPIFFS, "/index.html", "text/html", false);

Le fichier index.html sera chargé à partir de la FLASH de l'ESP8266 / ESP32, sans que l'on aie à s'en préoccuper. Je parle plus loin de cette librairie.

2.1.2. WifiServer

Les librairies ESP8266WifiServer et WifiServer (ESP32) sont assez bas niveau :

https://randomnerdtutorials.com/esp32-web-server-arduino-ide/

Je déconseille leur usage sauf si c'est dans un but de formation, si l'on désire traiter une requête HTTP soi-même "from scratch" par exemple. C'est assez barbare et peu de gens l'utilisent.

2.1.3. WebServer

Les librairies ESP8266WebServer ou WebServer (ESP32) disposent d'APIs de plus haut niveau permettant de réaliser un développement en peu de temps. Elles permettent d'associer des fonctions à chaque URL à traiter :

https://tttapa.github.io/ESP8266/Chap10%20-%20Simple%20Web%20Server.html

Exemple :

Dans la fonction Setup :

  server.on("/", handleRoot);

Le handler :

void handleRoot(void)
{
  server.send(200, "text/html", message);     // message = texte HTML à afficher
}

Simplissime, n'est ce pas ?

2.1.4. AsyncWebServer

Enfin la librairie EspAsyncWebServer est capable de gérer des pages HTML à l'aide de templates. Les templates sont des fichiers HTML contenant des tags nommés permettant la substitution de variables (PLACEHOLDER).

Cette librairie est très largement documentée sur le WEB.

Ce projet l'utilise :

https://riton-duino.blogspot.com/2020/03/serveur-esp32-implementation-et-test.html

2.1.5. Petits exemples

ESP32 Web server

Ici se trouve un petit exemple ESP32 reproduisant la même page HTML que le tutoriel vu au paragraphe 1.3. ESP01 + ARDUINO :

esp32-simple-webserver

La librairie WebServer est utilisée. Sur un ESP8266 on utiliserait la librairie ESP8266WebServer, le code serait assez peu différent.

On peut remarquer :

  • 105 lignes de code seulement au lieu de 400
  • simplicité : je l'ai écrit en une vingtaine de minutes (la fonction Setup est en grande partie reprise d'un autre projet)
  • le fichier root.h contient la page HTML avec deux tags %TEMP% et %PRESSURE%, qui sont remplacées dans le code par leurs valeurs à l'aide de simples appels à String::replace()

Cet exemple montre que le code est beaucoup plus simple que la version ARDUINO+ESP01, et montre également que l'on peut bénéficier de ressources logicielles inutilisables sur un ARDUINO, en particulier la classe String, qui provoquerait une fragmentation de la mémoire de celui-ci :

https://riton-duino.blogspot.com/2020/02/arduino-la-fragmentation-memoire.html

Bien entendu, cette solution à base d'ESP8266 ou d'ESP32 sera incomparablement plus évolutive qu'une solution à base d'ARDUINO+ESP01, et permettra de développer un serveur beaucoup plus riche, tout en réduisant fortement la charge de travail.

ESP32 Access point

Ici on peut trouver également un petit exemple de serveur WEB fonctionnant en point d'accès WIFI :

esp32-simple-accesspoint

L'adresse IP de ce point d'accès est affiché sur le terminal au démarrage (normalement 192.168.4.1).

3. Conclusion

Est-il raisonnable à l'heure actuelle de s'orienter vers une solution à base d'ARDUINO + ESP01 ?

A moins d'avoir envie de se convaincre que c'est une piètre solution, j'ai bien peur que non.

En tous cas, cette technique ne permettra pas d'aller bien loin de par la pauvreté des ressources matérielles (CPU, mémoire) d'un ARDUINO.

Qu'en est-il du HTML, du JAVASCRIPT ?
Que ce soit avec une carte ARDUINO, un ESP8266 ou un ESP32, dans tous les cas la connaissance de ces deux langages est indispensable. Envisager un développement WEB sans connaissances dans ces domaines est tout bonnement impossible.

On trouve de nombreux tutoriels sur le WEB et on peut facilement tester une page HTML avec un simple navigateur, en chargeant simplement le fichier.


Cordialement
Henri

4. Mises à jour

24/08/2020 : 2.1.5. Petit exemple
                     1.1.2. Recharger le FIRMWARE AT avec FLASH DOWNLOAD TOOL


Aucun commentaire:

Publier un commentaire