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