RitonDuino - Février 2019

RitonDuino: février 2019 http://riton-duino.blogspot.com/2019/02/?
m=1
Plus Créer un blog Connexion
RitonDuino
Accueil Table des matières Actus ARDUINO ESP8266 ESP32 STM32 STM8 Electronique Audio
Alimentation Affichage Batteries Capteurs Modules CartesPucesRfid Communication Moteurs
Domotique Labo et Atelier Mesure Forums et Blogs Migration sous BITBUCKET
RitonDuino : PRESENTATION
ESP8266 et ESP32 sur batterie
► 2023 (19)
► 2022 (25)
► 2021 (41)
► 2020 (57)
▼ 2019 (59)
► décembre (7)
► novembre (6)
► octobre (4)
► septembre (5)
► août (3)
Vous connaissez certainement ces petits modules WIFI et je ne vais pas vous les décrire une ► juillet (6)
Nième fois.
► juin (4)
Dans cet article nous allons plutôt nous intéresser à l'élaboration d'une solution à base ► mai (4)
d'ESP8266 ou ESP32 alimentée par batterie. ► avril (2)
► mars (8)
Nous en profiterons pour explorer aussi certains sujets pour les plus ou moins débutants :
▼ février (4)
• les cartes de prototypage
ESP8266 et ESP32 sur batterie
• le câblage
Alimenter un ARDUINO sur Pile ou
• le chargement par l'IDE ARDUINO Batterie
Un WEB server ARDUINO sur
• le sommeil profond ou deep-sleep
Ethernet (avec graphes H...
• le réveil périodique Les extensions de GPIOs de
l'ARDUINO
• le réveil par une entrée digitale
• envoyer un mail ► janvier (6)
Avant tout, il est important de savoir que le sommeil profond entraîne la coupure du modem ► 2018 (29)
WIFI, et donc l'ESP8266 ou l'ESP32 se retrouvera dans l'incapacité de communiquer.
Les montages réalisés dans une optique serveur WEB ne pourront bénéficier de cette technique
d'économie d'énergie. Si vous envisagez la réalisation d'un serveur WEB alimenté par batterie,
orientez-vous plutôt sur une alimentation secteur ou une alimentation par batterie + recharge
solaire. Actus (53)
Affichage (8)
1. Alimentation sur batterie
Alimentation (32)
Avant d'aller plus loin, il faut savoir que : ARDUINO (74)
• la tension d'alimentation de l'ESP8266 ne peut dépasser 3.6V Audio (17)
• il ne peut fonctionner en dessous de 2.5V Batteries (22)
1 of 42 28/10/2023 21:35
RitonDuino: février 2019 http://riton-duino.blogspot.com/2019/02/?m=1
• la tension d'alimentation de l'ESP32 ne peut dépasser 3.6V Capteurs (10)
• il ne peut fonctionner en dessous de 2.3V. Cartes (1)
L'alimentation par batterie passera de préférence par les solutions suivantes : Communication (18)
• 2 batteries NIMH en série Domotique (37)
• 1 batterie LifePo4 (l'idéal) Electronique (38)
• 3 batteries NIMH en série + 1 régulateur 3.3V ou 3V ESP32 (30)
• 1 batterie LITHIUM-ION ou LIPO + 1 régulateur 3.3V ou 3V ESP8266 (25)
La solution consistant à utiliser 2 batteries NIMH en série paraît optimale pour l'ESP8266 mais index (230)
elle ne l'est pas pour les batteries :
La tension à pleine charge sera de 2.8V. Labo et Atelier (23)
L'ESP8266 pourra fonctionner jusqu'à 2.5V
Mesure (15)
A 2.5V les batteries seront loin d'être vides. Il restera environ 30% de capacité, et il sera
obligatoire de les décharger avant de les recharger afin d'éviter l'effet mémoire. Certains Modules (15)
chargeurs font cela automatiquement.
Moteurs (6)
Par contre la solution à 2 batteries NIMH est un peu plus intéressante pour l'ESP32 car sa RASPBERRY (4)
tension minimale de fonctionnement de 2.3V se rapproche de la tension minimale des batteries
: 2 x 1.1V. STM32 (9)
STM8 (1)
Un ESP8266 consomme un courant important lors de la connexion WIFI :
Rechercher
https://www.ondrovo.com/a/20170207-esp-consumption/ Afficher mon profil complet
Il est inutile de vouloir l'alimenter avec une source incapable de fournir ce courant (une batterie
9V par exemple).
La capacité de la batterie à utiliser dépendra de plusieurs facteurs :
• consommation de la carte utilisée
• consommation des capteurs
• courant de repos du régulateur de tension
• fréquence des réveils
• etc.
Dans le présent article vous trouverez la description de quelques cartes ESP8266 et ESP32
avec leurs consommations respectives.
Articles
Dans cet autre article vous trouverez les caractéristiques de consommation de nombreux
Commentaires
capteurs de température, humidité, pression et lumière :
https://riton-duino.blogspot.com/2018/12/les-capteurs-de-temperature-humidite.html
Lisez également celui-ci : https://riton-duino.blogspot.com/2019/02/alimenter-un-arduino-sur-

pile-ou.html
Ce article vous fournira aussi d'autres renseignements :
• utilisation éventuelle d'un régulateur
• calcul de l'autonomie
• vérification de la consommation
ARDUINO :
• surveillance de la tension de la batterie l'alimentation (VCC,
VIN, etc.)
Si vous tenez absolument à alimenter l'ESP8266 ou l'ESP32 avec une batterie LITHIUM-ION ou ARDUINO :
LIPO, cet article vous aidera dans le choix de votre régulateur : l'alimentation (VCC,
2 of 42 28/10/2023 21:35
https://riton-duino.blogspot.com/2018/11/les-regulateurs-ldo.html VIN, etc.) Après avoir

Le modèle choisi devra être capable de débiter 500mA. écrit de multiples
articles sur
l'alimentation d'un
ARDUINO, d...
2. L'ESP8266
L'ESP8266 peut être chargé avec différentes firmwares :
• le firmware "AT commands"
• le firmware NodeMCU ESP8266 et ESP32 sur

batterie
• le firmware MicroPython ESP8266 et ESP32 sur
batterie Vous
• etc.
connaissez
• et enfin un firmware développé par vous-même avec l'IDE ARDUINO ou le SDK certainement ces
petits modules WIFI et
Espressif
je ne vais pas vous les
Le firmware AT n'est utile que dans le cadre du pilotage d'un ESP8266 par un autre décrire une Nième
fois....
microcontrôleur ARDUINO ou autre, en passant par la ligne série. Cette solution était
auparavant assez utilisée mais elle est en perte de vitesse. Il est difficile d'obtenir un résultat
performant en utilisant ce moyen.
Et pourquoi s'encombrer d'un ARDUINO alors qu'un ESP8266 sait tout faire et bien mieux ?
Justifier ce choix par un nombre de GPIOs et d'entrées ADC plus important pour l'ARDUINO
n'est valable que lorsque l'on a affaire à un ESP01, et il est possible d'étendre les GPIOs avec un
Alimenter un
expander I2C ou SPI. Et autant passer sur un ESP32 pour avoir plus d'entrées ADC, d'autant plus
ARDUINO sur Pile ou
que la résolution est supérieure. Batterie
Alimenter un
Le firmware NodeMCU et son langage LUA : apparemment le deep-sleep existe. Je ne l'ai pas ARDUINO sur Pile ou
essayé. Batterie Cet article
vise à examiner en
Le firmware MicroPython dispose aussi du deep-sleep. profondeur la
possibilité d'alimenter
Je n'ai pas encore essayé MicroPython sur ESP8266 mais j'avoue que je me laisserais
un montage ARDUINO
facilement tenter. s...
Dans cet article nous nous intéresserons pour l'instant uniquement au langage C / C++ en
utilisant l'IDE ARDUINO.
Dans une solution basse consommation à base d'ESP8266 il est intéressant d'utiliser le module
nu et de l'implanter sur un PCB maison. D'une part cela permet d'être sûr qu'aucun composant
superflu ne viendra augmenter la consommation du montage, d'autre part l'encombrement sera
réduit.
Par contre pour des besoins de prototypage, il est tout de même plus intéressant de disposer
d'une carte enfichable sur une breadboard.
Nous allons commencer par un petit schéma de base :
3 of 42 28/10/2023 21:35
Ce schéma représente le minimum vital pour pouvoir travailler. L'ESP8266 est équipé de
quelques composants et connexions :
• RESET : un bouton-poussoir permettant le redémarrage
• FLASH : un bouton-poussoir permettant le chargement
• R1 : résistance de pull-up du de la broche RST
• R2 : résistance de pull-up de la broche EN
• R3 : résistance de pull-up du de la broche GPIO0
• R4 : résistance de pull-up du de la broche GPIO2
• FTDI : un connecteur de chargement
• GPIO15 relié à GND
On peut facilement l'essayer sur une breadboard.
Le connecteur FTDI reçoit les signaux d'un convertisseur USB / série. RX et TX sont croisés
bien entendu. On peut aussi alimenter le montage à l'aide du 3.3V du convertisseur.
Il est impératif de choisir un convertisseur 3.3V ou un modèle possédant un cavalier permettant
de le basculer en 3.3V :
4 of 42 28/10/2023 21:35
Il vaut mieux rapprocher les boutons RESET et FLASH pour pouvoir les manipuler avec un seul
doigt.
Le chargement par l'IDE ARDUINO se passe de la façon suivante :
• lancer le chargement
• presser les boutons RESET et FLASH
• relâcher le bouton RESET en maintenant le bouton FLASH enfoncé jusqu'au début

du chargement (Téléversement ...)
Si le message "error: espcomm_upload_mem failed" s'affiche, revoyez votre câblage, y compris

les pins RX TX qui doivent être croisées. Personne n'est à l'abri d'une erreur.
Les cartes du type WEMOS D1 MINI ou NodeMCU vous dispensent de ces manipulations de
boutons. Il suffit de lancer le chargement
Il est également possible d'obtenir le chargement automatique d'un module ESP8266 nu, tout
en conservant le chargement manuel, grâce à l'ajout de quelques composants :
5 of 42 28/10/2023 21:35
Contrairement à ce qui se passe sur une carte NodeMCU qui a besoin des signaux DTR et RTS,
j'ai voulu utiliser un seul fil : DTR ou RTS.
Le front descendant du signal DTR ou RTS est transformé en impulsion à travers un
condensateur pour provoquer le reset (en bleu sur l'oscillogramme ci-dessous), tandis que le
signal complet est appliqué sur GPIO0 (en jaune sur l'oscillogramme ci-dessous) pour démarrer
l'ESP8266 en mode bootloader.
Pourquoi cette manière de procéder ? parce que la majeure partie des convertisseurs USB /
série proposent un signal DTR ou RTS, rarement les deux.
Le condensateur C2 permet d'envoyer juste une impulsion de reset à la pin RST de l'ESP8266.
La diode D1 permet d'éliminer la surtension sur la pin RST lors de la décharge du condensateur
C2, surtension visible sur l'oscillogramme ci-dessous.
Le transistor Q1 transmet l'intégralité du signal DTR ou RTS à la pin GPIO0 :
6 of 42 28/10/2023 21:35
En bleu : la pin RST

En jaune : la pin GPIO0
Ce montage est utilisable de ceux manières :
• avec un convertisseur USB / série simple (3.3V + GND + RX + TX)
• appuyer sur les boutons RESET et FLASH
• relâcher le bouton RESET au début du chargement (Téléversement ...)
• relâcher le bouton FLASH quand le chargement à commencé
• avec un convertisseur USB / série complet (3.3V + GND + RX + TX + DTR ou RTS)
• c'est tout
Il existe différents types de cartes dites "breakout" permettant d'implanter un module ESP8266
sur une breadboard.
Ce sont des cartes simples ne possédant ni convertisseur USB / série ni régulateur de tension.
On les trouve sous la dénomination ESP8266 WhiteBoard.
Elles peuvent être équipées d'un régulateur 3.3V et certaines connexions sont déjà réalisées :
• résistance de 10KΩ entre CH_PD (ou EN) et +3.3V
• résistance de 10KΩ entre GPIO2 et +3.3V
• GPIO15 relié à GND
Si l'on veut utiliser une carte de ce type, il nous suffit donc d'ajouter :
7 of 42 28/10/2023 21:35
• le bouton RESET
• le bouton FLASH
• la résistance R1
• la résistance R3
• un FTDI
Ces cartes sont très encombrantes, en particulier en largeur, mais elles conviennent
parfaitement au prototypage.
Alimentée en 3.3V, elle devrait avoir la même consommation que le module nu, c'est à dire entre
20µA et 30µA en sommeil profond.
Cet autre modèle existe, encore plus nu, plus étroit (merci à NB pour l'info) :
https://oshpark.com/shared_projects/BREwuIR9
Il nécessite des barettes mâles SMD au pas de 2.54 :
aliexpress.com
Cette carte est un peu plus riche. Elles possède :
• 11 GPIOs
• un régulateur 3.3V
• un convertisseur USB / série CH340
• des résistances de pull-up sur les broches RST, EN, GPIO0 et GPIO2
• une résistance de pull-down sur la broche GPIO15
8 of 42 28/10/2023 21:35
• quelques condensateurs de découplage
Cette carte occupe un volume raisonnable.

Alimentée en 3.3V, elle devrait consommer environ 100µA en sommeil profond.
Cette carte, plus ancienne, est plus encombrante. Elle offre à peu près les mêmes
caractéristiques que la précédente, avec 17 GPIOs.
Cette carte occupe un volume important.

Alimentée en 3.3V, elle devrait consommer environ 100µA en sommeil profond.
Cette carte est très peu encombrante. Elle possède seulement 2 GPIOs.
Un ESP01 sur lequel la LED rouge a été éliminée peut avoir une consommation très basse (20 à
30µA). Cela se fait très facilement en la faisant sauter avec l'ongle.
Par contre elle ne vous offrira pas la possibilité de se réveiller périodiquement, sauf si vous
reliez la pin GPIO16 à la pin RESET à l'aide d'un petit fil soudé sur les pattes du processeur. Je
vous conseille le fil à wrapper, un fer à souder avec pointe fine et une bonne loupe frontale.
Pour l'enficher sur une breadboard vous aurez besoin de ceci :
Pour charger l'ESP01 le câblage est celui-ci :
9 of 42 28/10/2023 21:35
Ce schéma est inspiré de celui de l'ESP8266 plus haut (voir les explications ICI). Il permet
d'obtenir un chargement automatique ou manuel.
Nous allons nous intéresser à un seul mode de sommeil, le deep-sleep, seul capable d'assurer
une consommation suffisamment faible pour pouvoir fonctionner sur batterie avec une
autonomie suffisante.
Le sommeil profond est obtenu par un appel à une méthode de la librairie ESP :
ESP.deepSleep(µs);
L'ESP8266 sera réveillé soit quand le temps spécifié sera écoulé, soit sur un signal sur une de
ses entrées.
En fait, contrairement à ce qui se passe sur un ARDUINO, le réveil par GPIO n'existe pas sur un
ESP8266. Nous devons provoquer un reset et le logiciel devra aller consulter les informations
de reset et lire l'état de la GPIO pour connaître la cause du réveil.
Vous allez certainement remarquer que cela implique un redémarrage complet, avec
déroulement du startup, de l'initialisation de la librairie C / C++ et donc une énorme perte de
temps.
Oui, mais il ne faut pas oublier qu'il faudra aussi reconnecter le modem au réseau WIFI, ce qui
prend aussi beaucoup de temps.
L'ESP8266, tout comme l'ESP32 n'est pas conçu pour traiter rapidement des interruptions
internes ou externes quand il est en sommeil profond, comme pourraient le faire un ATMEGA
ou un STM32.
Nous allons partir d'un exemple concret, un montage destiné à de la surveillance :
• un capteur de température (réveil cyclique)
• deux capteurs de passage PIR (réveil par une GPIO)
Comme notre montage n'a pas la possibilité de se comporter comme un serveur WEB, nous
pouvons envoyer des événements sous diverse formes :
• envoyer une requête HTTP à un serveur
• envoyer des données en JSON à un serveur DOMOTICZ ou JEEDOM
• envoyer un mail
• etc.
Pour cet exemple j'ai choisi d'envoyer un mail.
10 of 42 28/10/2023 21:35
On trouve beaucoup de documentation sur le WEB :

https://projetsdiy.fr/esp8266-client-web-exemples-communication-tcp-ip-esp8266wifi-
esp8266httpclient/
https://projetsdiy.fr/esp8266-client-web-envoyer-donnees-domoticz-tcpip-api-json/
https://projetsdiy.fr/envoyer-donnees-jeedom-api-json-http-esp8266/
Pour obtenir les deux modes de réveil il va nous falloir ajouter quelques petites choses à notre
carte :
Pour réveiller l'ESP8266 en sommeil il nous faut générer une impulsion de courte durée sur la
pin RST. Au repos cette PIN est à UN. Il va falloir générer un ZÉRO pendant un temps court :
1ms par exemple.
Or la sortie d'un PIR est à ZÉRO au repos et génère lors des détections de passage une
impulsion positive très longue qui ne convient évidemment pas.
En regardant le schéma, à gauche, la sortie du PIR attaque un condensateur puis la base d'un
transistor NPN. La constante de temps 1µF x 1KΩ est de 1ms.
Le front montant du signal du PIR va produire une impulsion positive sur la base du transistor
qui va conduire et ramener le potentiel de la pin RST à ZÉRO durant environ 1ms.
La sortie du PIR1 est reliée également à GPIO4 et la sortie du PIR2 à GPIO12 afin que le logiciel
puisse consulter l'état de ces entrées.
Les deux résistances R1, R2, R4 et R5 permettent de décharger le condensateur et de revenir à

l'état de repos.
J'ai utilisé des boutons poussoirs pour simuler les PIRs. Si de vrais capteurs PIR sont utilisés
les résistances R1 et R2 sont inutiles.
Elles doivent seulement être présentes si des contacts secs sont utilisés (interrupteur, relais,
ILS, etc). Elles servent de résistances pull-down.
Si à l'entrée nous avions autre chose qu'un PIR, il faudrait adapter.
Dans le cas d'une source produisant une impulsion vers le bas, on pourrait remplacer le NPN
par un PNP :
11 of 42 28/10/2023 21:35
Comme nous avons deux entrées pour les PIRs, il nous faudrait implémenter deux de ces
circuits.
Si la source produit une impulsion trop courte, l'ESP8266 va redémarrer mais le logiciel n'aura
pas le temps de lire la GPIO. Il faudrait dans ce cas insérer un monostable :
Ce circuit produit une impulsion positive de 500ms sur GPIO4, largement suffisante pour que
l'ESP8266 aie le temps de démarrer.
Ce monostable déclenche sur un front montant en entrée. Pour implémenter un monostable

déclenchant sur front descendant, remplacer tout simplement la porte OR (CD4071) par un
porte AND (CD4081).
Comme nous avons deux entrées à surveiller, il nous faudrait implémenter deux de ces circuits.
Le deuxième cas, le réveil périodique, est obtenu en reliant GPIO16 à la pin RST. GPIO16 est une
pin utilisée par le circuit RTC de l'ESP8266 qui lorsque le timer arrivera à échéance, générera
l'impulsion qui nous intéresse.
L'électronique de déclenchement de réveil pour l'ESP8266 est assez

conséquente, surtout si plusieurs entrées de réveil doivent être implémentées. Pour chaque
entrée on a besoin de :
• 1 condensateur
• 3 résistances
• 1 transistor
Si les impulsions sur les entrées sont courtes c'est encore pire. Pour chaque entrée on a besoin
de :
• 2 condensateurs
• 4 résistances
12 of 42 28/10/2023 21:35
• 1 monostable
• 1 transistor
Le circuit utilisé, le CD4071 possède 4 portes OR, donc il est possible d'implémenter 4 entrées
avec un seul CD4071, mais c'est une piètre consolation.
Comparativement l'ESP32 n'a besoin d'aucun composant additionnel.

Si vous envisagez de réveiller un ESP8266 par une ou plusieurs entrées digitales, optez plutôt
pour l'ESP32.
Voir paragraphe 3. L'ESP32.
Nous voici donc avec un schéma permettant de mettre en œuvre les deux cas de réveil qui
nous intéressent.
Voici un exemple de sketch :
#include <ESP8266WiFi.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#define SMTP_PORT 587

#define MOTION_PIN1 4
#define MOTION_PIN2 12
#define ONE_WIRE_PIN 5
#define SLEEP_TIME (30*60)
enum rst_reason {
REASON_DEFAULT_RST = 0, /* normal startup by power on */
REASON_WDT_RST = 1, /* hardware watch dog reset */
REASON_EXCEPTION_RST = 2, /* exception reset, GPIO status won’t change */
REASON_SOFT_WDT_RST = 3, /* software watch dog reset, GPIO status won’t change */
REASON_SOFT_RESTART = 4, /* software restart ,system_restart */
REASON_DEEP_SLEEP_AWAKE = 5, /* wake up from deep-sleep */
REASON_EXT_SYS_RST =6 /* external system reset */
};
struct rst_info
{
uint32 reason;
uint32 exccause;
uint32 epc1;
uint32 epc2;
uint32 epc3;
uint32 excvaddr;
uint32 depc;
};
const char* ssid = "Livebox-XXXX";

const char* password = "XXXXXXXXXXXXXXXXXXXXXXXXXX";
char server[] = "smtp.xxxxxx.xx";
// Change to your base64, ASCII encoded user
const char userID[] = "XxXxXxXxXxXx";
// change to your base64, ASCII encoded password
const char userPWD[] = "YyYyYyYyYyYyYy";
// sender
const char sender[] = "sender@xxxxxx.xx";
// recipent
const char recipient[] = "xxxxx.xxxxxxxx@gmail.com";
WiFiClient client;
OneWire oneWire(ONE_WIRE_PIN );
DallasTemperature DS18B20(&oneWire);
void setup()
{
int motionPin1;
int motionPin2;
rst_info *resetInfo;
13 of 42 28/10/2023 21:35
byte ret;
Serial.begin(115200);
resetInfo = ESP.getResetInfoPtr();
Serial.print( "Wakeup reason: ");
Serial.println((*resetInfo).reason);
pinMode(MOTION_PIN1, INPUT_PULLUP);
pinMode(MOTION_PIN2, INPUT_PULLUP);
motionPin1 = digitalRead(MOTION_PIN1);
motionPin2 = digitalRead(MOTION_PIN2);
Serial.print("Motion1: ");
Serial.println(motionPin1);
Serial.print("Motion2: ");
Serial.println(motionPin2);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi Connected");
Serial.print("IPess: ");
Serial.println(WiFi.localIP());
switch (resetInfo->reason) {
case REASON_DEFAULT_RST:
ret = sendEmail("**** Just Started ****");
break;
case REASON_WDT_RST:
ret = sendEmail("**** Watchdog Reset ****");
break;
case REASON_EXCEPTION_RST:
ret = sendEmail("**** Exception Reset ****");
break;
case REASON_SOFT_WDT_RST:
ret = sendEmail("**** Software Watchdog Reset ****");
break;
case REASON_SOFT_RESTART:
ret = sendEmail("**** Software Reset ****");
break;
case REASON_DEEP_SLEEP_AWAKE:
if (motionPin1) {
ret = sendEmail("**** Motion1 Detected ****");
}
if (motionPin2) {
}
if (!motionPin1 && !motionPin2) {
char temp[6];
char s[32];
dtostrf(getTemperature(), 5, 2, temp);
sprintf(s, "**** temperture is %s ****", temp);
ret = sendEmail(s);
}
break;
case REASON_EXT_SYS_RST:
ret = sendEmail("**** System Reset ****");
break;
}
Serial.print("Going into deep sleep for ");
Serial.print(SLEEP_TIME);
Serial.println(" seconds");
ESP.deepSleep(1000000L * SLEEP_TIME);
}
void loop()
{
}
14 of 42 28/10/2023 21:35
byte sendEmail(const char *data)

{
byte thisByte = 0;
byte respCode;
if (client.connect(server, SMTP_PORT) == 1) {
Serial.println(F("connected"));
} else {
Serial.println(F("connection failed"));
return 0;
}
if (!recv()) return 0;
Serial.println(F("Sending HELLO"));
client.println("EHLO www.example.com");
Serial.println(F("Sending auth login"));
client.println("auth login");
Serial.println(F("Sending User"));
client.println(userID);
Serial.println(F("Sending Password"));
client.println(userPWD);
Serial.print(F("Sending From ")); Serial.println(sender);
client.print(F("MAIL From: ")); client.println(sender);
Serial.print(F("Sending To ")); Serial.println(recipient);
client.print(F("RCPT To: ")); client.println(recipient);
Serial.println(F("Sending DATA"));
client.println(F("DATA"));
Serial.println(F("Sending email"));
client.print(F("To: ")); client.println(recipient);
client.print(F("From: ")); client.println(sender);
client.println(F("Subject: My first Email from ESp8266\r\n"));
client.print(F("From ESP8266 N° "));
client.println(ESP.getChipId(), HEX);
Serial.println(data);
client.println(data);
client.println(F("."));
Serial.println(F("Sending QUIT"));
client.println(F("QUIT"));
client.stop();
Serial.println(F("disconnected"));
return 1;
}
byte recv()
{
byte respCode;
byte thisByte;
int loopCount = 0;
while (!client.available()) {
delay(1);
loopCount++;
if (loopCount > 10000) {
client.stop();
Serial.println(F("\r\nTimeout"));
return 0;
}
}
respCode = client.peek();
while (client.available()) {
15 of 42 28/10/2023 21:35
thisByte = client.read();
Serial.write(thisByte);
}
if (respCode >= '4') {
return 0;
}
return 1;
}
float getTemperature() {
float tempC;
do {
DS18B20.requestTemperatures();
tempC = DS18B20.getTempCByIndex(0);
delay(100);
} while (tempC == 85.0 || tempC == (-127.0));
return tempC;
}
Comme on peut le constater ce code envoie un mail différent pour chaque cause de reset :
reset système, réveil, exception, etc.
La lecture des pins GPIO4 et GPIO12 permet de déterminer la cause du réveil.
Comme il n'est pas possible de détecter l'impulsion sur GPIO16 dans le logiciel, on considère
que le timer a déclenché le réveil si GPIO4 et GPIO12 sont à zéro.
Il vous faudra bien sûr remplacer certaines valeurs :
Le SSID de votre box
Le mot de passe WIFI de votre box :
L'adresse de votre serveur de messagerie :
Le port SMTP utilisé par votre serveur :
Votre identifiant de messagerie codé en base64 :

Votre mot de passe de messagerie codé en base64 :
L'adresse mail de l'expéditeur du message :
L'adresse mail du destinataire du message :
Pour encoder un identifiant ou un mot de passe en base64 :
Sous LINUX utiliser la commande base64.
Sinon :
https://www.base64encode.org/
Il vous faudra bien entendu installer le support ESP8266 :

https://github.com/esp8266/Arduino#installing-with-boards-manager
16 of 42 28/10/2023 21:35
Il vous faut aussi installer deux librairies :

https://github.com/PaulStoffregen/OneWire.git
https://github.com/milesburton/Arduino-Temperature-Control-Library.git
De préférence installez la dernière version.
3. L'ESP32
Ici encore nous nous intéresserons pour l'instant uniquement au langage C / C++ en utilisant
l'IDE ARDUINO.
Je n'ai pas testé de module ESP32 seul.
A première vue, le schéma minimal devrait être celui-ci :
Le connecteur marqué FTDI permet de raccorder un convertisseur USB / série.

Il faut bien sûr croiser TX et RX.
Rappel: il est impératif de choisir un convertisseur 3.3V ou un modèle possédant un cavalier
permettant de le basculer en 3.3V :
17 of 42 28/10/2023 21:35
Ce schéma devrait pouvoir permettre d'obtenir le chargement de l'ESP32 sans avoir à agir sur
les boutons RESET (EN) et BOOT.
La pin GPIO0 possède déjà sa propre résistance interne de pull-up.
Ce sont des cartes simples ne possédant ni convertisseur USB / série ni régulateur de tension.
Cette carte est la seule que j'aie testé.

Elle possède un port USB, un convertisseur USB / série CH340, un régulateur 3.3V et des
boutons EN (RESET) et BOOT. Il faut appuyer sur BOOT avant le chargement par l'IDE ARDUINO.
Il est possible de se passer du port USB si l'on désire alimenter la carte directement en 3.3V, en
éliminant du même coup la consommation du CH340.
Un FTDI sera câblé sur les broches de la carte :
• GND du FTDI sur GND de la carte
• RX du FTDI sur TX0 de la carte
• TX du FTDI sur RX0 de la carte
• DTR du FTDI sur EN de la carte
Le CTS du FTDI aurait pu être connecté sur la pin GPIO0 mais celle-ci n'est pas disponible sur
18 of 42 28/10/2023 21:35
les broches de la carte. Il faudra appuyer sur BOOT avant le chargement par l'IDE ARDUINO.
Cette carte consomme trop en sommeil profond : 3mA.

On est loin des 5µA attendus, mais elle nous permettra d'effectuer la mise en œuvre logicielle
sans problème.
Cette carte semble être une des moins gourmande du marché, avec 10µA de consommation en
sommeil profond.
Elle dispose d'un connecteur pour une batterie LITHIUM-ION ou LIPO. Elle est capable de
recharger la batterie à partir du 5V ou de son connecteur USB.
Un TP4056 est implanté sur la carte.
Cette carte est censée consommer 150µA en sommeil profond.
Elle dispose également d'un connecteur pour une batterie LITHIUM-ION ou LIPO. Elle est
capable de recharger la batterie à partir de son connecteur USB.
Cette carte est censée consommer 170µA en sommeil profond.
Elle dispose également d'un connecteur pour une batterie LITHIUM-ION ou LIPO. Elle est
capable de recharger la batterie à partir de son connecteur USB.
Le sommeil profond a un fonctionnement différent de celui de l'ESP8266.
19 of 42 28/10/2023 21:35
L'ESP32 est capable de faire la distinction entre plusieurs sources de réveil :
• un réveil par une GPIO (ext0)
• un réveil par plusieurs GPIOs (ext1)
• un réveil par le touchpad
• un réveil par RTC
Il est possible d'activer l'une ou l'autre ou plusieurs.
Réveil par une GPIO (0, 2, 4, 12 à 15, 25 à 27, 32 à 39) :
esp_sleep_enable_ext0_wakeup(gpio, state);
Dans ce mode, les GPIOs peuvent bénéficier de résistances internes de pull-up ou pull-down :
#include <driver/rtc_io.h>
rtc_gpio_pullup_en(gpio);
rtc_gpio_pulldown_en(gpio);
Réveil par plusieurs GPIOs (32 à 39) :
esp_sleep_enable_ext1_wakeup(gpios, state);
Dans ce mode, les GPIOs devront être équipées de pull-up ou pull-down matérielles externes.
Réveil par le touchpad :
touchAttachInterrupt(pad, callback, threshold);

esp_sleep_enable_touchpad_wakeup();
Réveil par la RTC :
esp_sleep_enable_timer_wakeup(µs);
Activation du mode deep-sleep :
esp_deep_sleep_start();
Lors du réveil la fonction esp_sleep_get_wakeup_cause() sera appelée pour connaître la cause

du réveil :
switch (esp_sleep_get_wakeup_cause()) {
case ESP_SLEEP_WAKEUP_EXT0:
Serial.println("Wakeup by EXT0");
break;
Serial.println("Wakeup by EXT1");
break;
case ESP_SLEEP_WAKEUP_TIMER:
Serial.println("Wakeup by RTC");
break;
case ESP_SLEEP_WAKEUP_TOUCHPAD:
Serial.println("Wakeup by TouchPad");
break;
}
Si le réveil par plusieurs GPIOs a été activé, il est possible de déterminer quelle GPIO a
provoqué le réveil :
uint64_t wakeupBit = esp_sleep_get_ext1_wakeup_status();

if (wakeupBit & GPIO_SEL_33) {
// GPIO 33 woke up
}
else if (wakeupBit & GPIO_SEL_34) {
// GPIO 34
}
20 of 42 28/10/2023 21:35
Et enfin, si le réveil par le touchpad a été activé, il est possible de déterminer quelle touche a
provoqué le réveil :
touch_pad_t touchPin = esp_sleep_get_touchpad_wakeup_status();

switch(touchPin) {
case 0 : Serial.println("Touch detected on GPIO 4"); break;
default : Serial.println("Wakeup not by touchpad"); break;
}
Nous allons partir du même exemple de client mail que pour l'ESP8266 :
• un capteur de température (réveil cyclique)
• un ou deux capteurs de passage PIR (réveil par GPIO)
Voici un petit schéma :
Comme vous pouvez le constater, par rapport au même schéma utilisant un ESP8266, celui-ci
est beaucoup plus simple.
Les boutons poussoirs simulent les PIRs. Si de vrais capteurs PIR sont utilisés les résistances
R2 et R3 sont inutiles.
Bien sûr, si l'on utilise une ESP-WROOM-32, seuls les boutons poussoirs doivent être câblés.
21 of 42 28/10/2023 21:35
Si un seul bouton poussoir est utilisé sur GPIO33 :

Dans ce cas, connecter un bouton poussoir entre 3.3V et GPIO33, sans résistance de pull-down.
Si deux boutons poussoirs sont utilisés sur les GPIO32 et GPIO33 :

Dans ce cas, connecter deux boutons poussoirs entre 3.3V et GPIO32 et GPIO33, avec 2
résistances de pull-down.
Le problème est simplifié par rapport à l'ESP8266. Il est possible de spécifier sur quelle GPIO le
processeur peut être réveillé. Dans l'exemple, GPIO_32 et GPIO_33 sont utilisées.
Contrairement à ce qui se passait sur l'ESP8266 le front montant ou descendant de la source

de réveil peut être choisi.
Il n'y aura pas de modification hardware à apporter pour inverser le signal.
On pourra également activer des résistances internes de pull-up ou pull-down en cas de besoin.
Également il n'y aura pas besoin de maintenir le signal sur la ou les GPIOs si les impulsions de
réveil sont courtes.
Ici également, il n'y a pas de modification hardware à réaliser pour prendre en compte le réveil
par la RTC.
Le sketch suivant est prévu pour fonctionner dans deux modes :
Un seul bouton poussoir sur la GPIO33 :

Dans ce cas, connecter un bouton poussoir entre 3.3V et GPIO33, sans résistance de pull-down.
Commenter la ligne suivante :
//#define EXT1_WAKEUP
Deux boutons poussoirs sur les GPIO32 et GPIO33 :

Dans ce cas, connecter deux boutons poussoirs entre 3.3V et GPIO32 et GPIO33, avec 2
résistances de pull-down.
Décommenter la ligne suivante :
#define EXT1_WAKEUP
Le sketch :
#include <WiFi.h>
#include <rom/rtc.h>
#include <driver/rtc_io.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define ONE_WIRE_PIN 5
#define SLEEP_TIME (30*60)
#define EXT1_WAKEUP
#ifdef EXT1_WAKEUP
#define BUTTON_PIN_BITMASK 0x300000000
#endif

// Change to your base64, ASCII encoded user
// change to your base64, ASCII encoded password
22 of 42 28/10/2023 21:35
// sender
// recipent
WiFiClient client;
OneWire oneWire(ONE_WIRE_PIN );
DallasTemperature DS18B20(&oneWire);
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("IPess: ");
Serial.println(WiFi.localIP());
switch (esp_sleep_get_wakeup_cause()) {
ret = sendEmail("**** Motion Detected ****");
break;
#ifdef EXT1_WAKEUP
wakeup_pin_mask = esp_sleep_get_ext1_wakeup_status();
if (wakeup_pin_mask & GPIO_SEL_32) {
}
if (wakeup_pin_mask & GPIO_SEL_33) {
}
else {
}
break;
#endif
case ESP_SLEEP_WAKEUP_TIMER:
char temp[6];
char s[32];
dtostrf(getTemperature(), 5, 2, temp);
sprintf(s, "**** temperture is %s ****", temp);
ret = sendEmail(s);
break;
case ESP_SLEEP_WAKEUP_TOUCHPAD:
ret = sendEmail("**** TOUCH ****");
break;
case ESP_SLEEP_WAKEUP_ULP:
ret = sendEmail("**** ULP ****");
break;
default:
ret = sendEmail("**** Just Started ****");
break;
}
Serial.print("Going into deep sleep for ");
Serial.print(SLEEP_TIME);
Serial.println(" seconds");
delay(50);
esp_sleep_enable_timer_wakeup(1000000L * SLEEP_TIME);
#ifdef EXT1_WAKEUP
esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK, ESP_EXT1_WAKEUP_ANY_HIGH);
// internal pull-ups not available !!!
#else
esp_sleep_enable_ext0_wakeup(GPIO_NUM_33, 1);
23 of 42 28/10/2023 21:35
rtc_gpio_pulldown_en(GPIO_NUM_33);
#endif
esp_deep_sleep_start();
}
void loop()
{
}
byte sendEmail(const char *data)

{
byte thisByte = 0;
byte respCode;
if (client.connect(server, SMTP_PORT) == 1) {
Serial.println(F("connected"));
} else {
Serial.println(F("connection failed"));
return 0;
}
Serial.println(F("Sending HELLO"));
client.println("EHLO www.example.com");
Serial.println(F("Sending auth login"));
client.println("auth login");
Serial.println(F("Sending User"));
client.println(userID);
Serial.println(F("Sending Password"));
client.println(userPWD);
Serial.print(F("Sending From ")); Serial.println(sender);
client.print(F("MAIL From: ")); client.println(sender);
Serial.print(F("Sending To ")); Serial.println(recipient);
client.print(F("RCPT To: ")); client.println(recipient);
Serial.println(F("Sending DATA"));
client.println(F("DATA"));
Serial.println(F("Sending email"));
client.print(F("To: ")); client.println(recipient);
client.print(F("From: ")); client.println(sender);
client.println(F("Subject: My first Email from ESP32\r\n"));
client.print(F("From ESP32 N° "));
uint64_t chipID = ESP.getEfuseMac();
client.println((uint16_t)(chipID >> 32), HEX);
Serial.println(data);
client.println(data);
client.println(F("."));
Serial.println(F("Sending QUIT"));
client.println(F("QUIT"));
client.stop();
Serial.println(F("disconnected"));
return 1;
}
byte recv()
{
byte respCode;
byte thisByte;
int loopCount = 0;
while (!client.available()) {
24 of 42 28/10/2023 21:35
delay(1);
loopCount++;
if (loopCount > 10000) {
client.stop();
Serial.println(F("\r\nTimeout"));
return 0;
}
}
respCode = client.peek();
while (client.available()) {
thisByte = client.read();
Serial.write(thisByte);
}
if (respCode >= '4') {

// efail();
return 0;
}
return 1;
}
float getTemperature() {
float tempC;
do {
DS18B20.requestTemperatures();
tempC = DS18B20.getTempCByIndex(0);
delay(100);
} while (tempC == 85.0 || tempC == (-127.0));
return tempC;
}
Le code est simplifié par rapport à celui de l'ESP8266.
Il vous faudra bien sûr remplacer certaines valeurs (ssid, password, etc.) comme dans
l'exemple de l'ESP8266.
La directive suivante permet d'attendre un réveil sur les deux GPIOs 32 et 33 :
#define EXT1_WAKEUP
Si la directive est commentée, seule la GPIO 33 est surveillée :
// #define EXT1_WAKEUP
Il vous faudra bien entendu installer le support ESP32 :

https://github.com/espressif/arduino-esp32/blob/master/docs/arduino-
ide/boards_manager.md
Il vous faut aussi installer deux librairies :

https://github.com/PaulStoffregen/OneWire.git
https://github.com/milesburton/Arduino-Temperature-Control-Library.git
De préférence installez la dernière version.
4. Conclusion
J'ai réalisé le montage ESP8266 avec un ESP8266-12E soudé sur une carte adaptatrice simple.
Il consomme 19µA au repos.
Une batterie de 200mAH suffirait pour l'alimenter pendant plus d'un an en sommeil profond,
mais comme ce montage se réveille toutes les 30 minutes, pour avoir une bonne idée de la
consommation globale il faudra tenir compte de la consommation pendant les périodes d'éveil
(connexion WIFI plus ou moins longue, temps de transmission, etc.).
L'électronique de déclenchement de réveil pour l'ESP8266 est conséquente, surtout si plusieurs

entrées de réveil doivent être implémentées, alors que l'ESP32 n'a besoin d'aucun composant
additionnel.
25 of 42 28/10/2023 21:35
Pour l'instant le montage à base d'ESP32-WROOM-32 consomme trop : 3mA en deep-sleep.

La carte choisie n'est pas adaptée à ce que j'avais l'intention de faire.
J'espère que ce petit document vous aidera.
Cordialement
Henri
5. Lien utiles
Les capteurs de température, humidité, pression & luminosité
Alimenter un ARDUINO sur Pile ou Batterie
Les régulateurs LDO
ESP32 Deep Sleep & Its Wake-up Sources
6. Mises à jour
25/02/2019 : ajout 3. L'ESP32
26/02/2019 : ajout 1. Alimentation sur batterie
3.3.3. La FireBeatle
3.3.4. La WEMOS LOLIN D32
3.3.5. La WEMOS TTGO
ESP8266 : utilisation de 2 capteurs PIR
2.4.4. Remarques
27/02/2019 : 2.3.4. La carte ESP8266-01 : ajout chargement automatique
à février 23, 2019 43 commentaires:
Libellés : Alimentation, Batteries, Communication, ESP32, ESP8266, index
Alimenter un ARDUINO sur Pile ou Batterie
Cet article vise à examiner en profondeur la possibilité d'alimenter un montage ARDUINO sur
piles ou batteries.
Sur certains forums il est courant de devoir répondre à des question naïves :
26 of 42 28/10/2023 21:35
Afin de répondre immédiatement à ces questions : une pile 9V de 170mAH ne peut absolument
pas fournir de courant important. De plus sa capacité vous garantit quelques heures de
fonctionnement avec une carte ARDUINO UNO ou NANO sans moteur ni relais, et pas plus.
Tous les processeurs actuels peuvent fonctionner dans deux modes :
Le processeur tourne à sa vitesse normale et consomme plusieurs mA. Faire fonctionner un

processeur dans ce mode sur batterie pendant une longue période requiert une batterie énorme
:
Par exemple une UNO consommant 25mA de manière permanente demande une énergie
conséquente : 600mAH par jour, 18000mAH par mois.
Activer le mode veille du processeur permet de le faire fonctionner en basse vitesse. Le réveil
du processeur peut être effectué soit par le timer RTC ou une interruption sur une pin digitale.
Certains composants sur la carte peuvent consommer aussi :
• LED power
• régulateur
• convertisseur USB / série
• etc.
Pour correctement aborder un projet basse consommation il faudra de préférence choisir une
carte ARDUINO PRO MINI modifiée, une STM32 BLUE PILL ou une carte à base de STM32 M0.
Par exemple une PRO MINI en mode veille consommant 5µA de manière permanente demande
une énergie ridicule : 0.12mAH par jour, 3.6mAH par mois, 44mAH par an.
J'ai déjà écrit quelques articles sur la consommation des cartes ARDUINO et la PRO MINI :
https://riton-duino.blogspot.com/2018/12/consommation-dune-carte-arduino.html
https://riton-duino.blogspot.com/2018/02/arduino-pro-mini-basse-consommation.html
Je tiens à préciser que l'élaboration d'une solution basse consommation fonctionnant sur
batterie requiert de bonnes connaissances aussi bien en matière d'électronique qu'en matière
de logiciel.
Du matériel de mesure est souvent indispensable, tel un multimètre capable de mesurer des
courants faibles de l'ordre du µA .
La suite de l'article n'est malheureusement pas accessible facilement au débutant.
1. Piles ou batteries
En dehors de fait que contrairement à une pile une batterie se recharge, il faut considérer les
caractéristiques de chaque technologie, en particulier la tension nominale et maximale en fin
de charge :
Technologie Recharge Tension nominale Tension maximale Tension minimale

Plomb Oui 2.1V 2.33V 1.8V (*)
Alcaline Non 1.5V
Ni-MH Oui 1.2V 1.4V 1.1V
LITHIUM-ION Oui 3.7V 4.2V 3V
LIPO Oui 3.7V 4.2V 3V
LiFePO4 Oui 3.3V 3.6V 2.5V
(*) certaines batteries cycliques acceptent de voir leur tension chuter à 1.6V.
Afin de protéger les circuits alimentés la tension de fin de charge sera prise en compte. La
tension nominale n'est qu'indicative.
La tension minimale est celle en dessous de laquelle la batterie, si on la décharge trop
27 of 42 28/10/2023 21:35
profondément, subira des dommage souvent irréversibles.
Le choix d'une pile ou d'une batterie devra tenir compte de certains paramètres :
• tension et courant de service
• environnement
• prix
• autonomie envisagée (périodicité de la recharge)
• disponibilité des chargeurs
Les piles ont le gros inconvénient de ne pas être rechargeables ce qui les désavantage d'un
point de vue écologique et financier.
Elles ont par contre l'avantage d'un courant d'auto-décharge très faible.
Ces batteries ont un encombrement important et sont lourdes.
Ces batteries sont peu utilisées pour alimenter des montages n'ayant pas besoin directement
d'une tension de 12V.
Elles sont cependant capables de fonctionner correctement par grand froid, ce qui les rend
indispensables dans les applications censées fonctionner à l'extérieur.
Les batteries au plomb du type cyclique (chariot élévateur, fauteuil roulant, alimentation solaire,
onduleur, etc.) supportent d'être fortement déchargées.
Les batteries au plomb classiques (batteries de voiture) ne le supportent pas.
Le principal défaut des batteries NI-MH est leur effet mémoire. Cela réduit leur utilisation à des
systèmes autonomes où la recharge de la batterie intervient lorsque celle-ci est vide ou
presque.
Les nouvelles batteries NI-MH ont un taux d'auto-décharge faible. Il s'agit des batteries LSD
(Low Self Discharge) :
• Duracell Stay Charged
• Varta Ready2Use
• Sanyo Eneloop
• Tenergy Centura
Elles sont vendues pré-chargées.
Les chargeurs du commerce sont nombreux, mais les modules chargeurs à intégrer dans un
montage sont rares. Il est cependant possible d'en fabriquer à l'aide de circuits intégrés :
• LTC4060
• MAX712
Ces circuits peuvent être laissés branchés en permanence sur la batterie, le courant de fuite de
leur broche de mesure de la tension batterie est très faible : 1 µA à 5µA.
Ces batteries disposent d'un rapport capacité / encombrement important.
Les LIPO sont le plus souvent plates et peuvent se glisser facilement dans un boîtier.
Les chargeurs du commerce sont nombreux, et le choix de modules chargeurs à intégrer dans
un montage est large.
Ces batteries disposent aussi d'un rapport capacité / encombrement important.
28 of 42 28/10/2023 21:35
Elles ont le gros avantage de fournir une tension maximale de 3.6V compatible avec un grand
nombre de processeurs, circuits et modules du marché.
2. Tension et courant de service

Choisir une technologie passe par la connaissance des composants que l'on va devoir
alimenter. Il faut étudier les datasheets de chacun d'eux afin de déterminer la tension optimale
et les courants consommés.
Je vous propose quelques exemples. Pour plus de précisions à propos des composants, suivre
les liens :
Module Tension d'alimentation Courant nominal Courant de veille

ARDUINO UNO NANO 4V - 6V 25mA 6mA
ARDUINO PRO MINI 2.7V - 6V 5.5mA 1.4mA
ARDUINO PRO MINI modifiée 2.7V - 6V 5.5mA 5µA
15mA @ 16MHz
STM32 BLUE PILL 2V - 3.6V 1.4µA
50mA @ 72MHz
Capteurs température et humidité 1.4V - 5V 10µA - 600µA 0.1µA - 50µA

Capteur de présence 3.3V - 12V 260µA 60µA
NRF24L01 1.9V - 3.6V 12mA 1µA
RFM95 1.8V - 3.7V 120mA 1µA
HC-05 1.8V - 3.6V 40mA 8mA
ESP8266 (1) 2.5V - 3.6V 80 - 170mA 20µA (2)
ESP32 (1) 2.3V - 3.6V 80 - 240mA 5µA
ESP01 (carte) 2.3V - 3.6V 80 - 240mA 30µA (3)
(1) Il s'agit de la consommation du module seul :
Les cartes ESP8266 du genre NodeMCU consomment forcément plus.

Pour utiliser un module ESP8266 sur breadboard sans composants annexes, il existe des
cartes nues :
(2) La datasheet précise : 20µA à 2.5V, mais j'ai essayé un ESP-12E sous 3.3V qui avait une
consommation de 19µA en deep-sleep.
(3) Il s'agit d'un ESP01 sur lequel la LED rouge a été éliminée. Cela se fait très facilement en la
faisant sauter avec l'ongle :
29 of 42 28/10/2023 21:35
Attention : pendant la phase de connexion au réseau WIFI, un ESP8266 ou ESP32 peut

consommer jusqu'à plus de 400mA.
La tension de service de la batterie devra être la plus proche possible de celle requise par le
module le plus exigeant en matière de tension.
Si par exemple le besoin est d'alimenter un ARDUINO PRO MINI et un NRF24L01, la batterie
devra fournir au minimum 2.7V et au maximum 3.6V.
Le NRF24L01 ne supportera pas la tension maximale. Un régulateur 3.3V sera utilisé.

Comme l'ARDUINO PRO MINI peut se contenter de 3.3V, le régulateur pourra alimenter les deux
composants.
Le NRF24L01 fonctionnera encore lorsque la batterie atteindra sa tension minimale de 3V, ainsi
que l'ARDUINO.
L'ARDUINO et le NRF24L01 peuvent être alimentés sans danger avec cette batterie et ceci sans
régulateur.
Le NRF24L01 fonctionnera encore lorsque la batterie atteindra sa tension minimale de 2.5V.
L'ARDUINO décrochera à 2.7V.
Ce montage ne permet pas de profiter totalement de la capacité de la batterie.
On pourrait envisager de remplacer la PRO MINI par une STM32 BLUE PILL qui elle fonctionnera
encore sous 2V.
Le NRF24L01 ne supportera pas la tension maximale. Un régulateur 3.3V sera utilisé.

Comme l'ARDUINO PRO MINI peut se contenter de 3.3V, le régulateur pourra alimenter les deux
composants.
Le NRF24L01 fonctionnera encore lorsque la batterie atteindra sa tension minimale de 3.3,
ainsi que l'ARDUINO.
L'ARDUINO et le NRF24L01 peuvent être alimentés sans danger avec ces batteries et ceci sans
régulateur.
Le NRF24L01 fonctionnera encore lorsque la batterie atteindra sa tension minimale de 2.2V.
L'ARDUINO décrochera à 2.7V.
Ce montage ne permet absolument pas de profiter de la capacité de la batterie.
On pourrait envisager de remplacer la PRO MINI par une STM32 BLUE PILL qui elle fonctionnera
encore sous 2V.
3. Besoins en matière de régulation

En fonction des composants et de la batterie choisis les besoins en matière de régulation
peuvent être différents.
Comme on le voit dans le tableau précédent, certains modules supportent au maximum 3.6V et
il est hors de question de les alimenter en 5V ou directement par une batterie LITHIUM-ION qui
fournira une tension de 4.2V à pleine charge.
La batterie LiFePO4 peut être une solution intéressante.
Si l'on utilise une LITHIUM-ION il faudra obligatoirement intercaler un régulateur entre celle-ci et
les modules.
Vous trouverez un large choix ici:
https://riton-duino.blogspot.com/2018/11/les-regulateurs-ldo.html
30 of 42 28/10/2023 21:35
4. Environnement
En fonction de l'environnement et surtout de la température, certains choix s'imposent :
Pratiquement, seules les batteries au plomb sont capables de fonctionner correctement par
grand froid.
Il faudra bien étudier la datasheet de la batterie avant de faire son choix.
5. Autonomie
Avant tout, attention : les batteries LITHIUM-ION chez ALI-EXPRESS ou autre chinoiseries sont
annoncées avec des capacités délirantes.
J'ai par exemple testé des batteries 18650 6000mAH qui font en réalité moins de 1000mAH.
Voir ICI
En fonction des choix effectués, le besoin en autonomie sera extrêmement variable.

Considérons 3 modes de fonctionnement possibles :
• mode autonome
• recharge périodique
• recharge permanente
Le montage est alimenté par une batterie et celle-ci est rechargée manuellement lorsque sa
capacité atteint son minimum.
En fonction des technologies, certains choix de batterie vont s'imposer :
Une batterie au plomb classique sera inadaptée. Ces batteries ne supportant pas d'être
déchargées en dessous de 1.8V par élément.
Tous les autres types de batterie peuvent convenir.
Le montage est alimenté par une batterie rechargée périodiquement, par exemple par un
chargeur solaire.
Là aussi, en fonction des technologies, certains choix de batterie seront à proscrire :
Une batterie NI-MH sera inadaptée. Ces batteries ne supportant pas d'être rechargées si la
capacité restante est trop élevée (effet mémoire). Une batterie au plomb classique peut
convenir à condition que la tension ne descende pas en dessous de 1.8V par élément.
Tous les autres types de batterie peuvent convenir.
La durée de fonctionnement entre deux recharges sera déterminante pour le choix de la

capacité de la batterie.
Dans le cas d'une recharge par panneau solaire, on prendra en compte :
• la durée maximale d'ensoleillement journalier (courte en hiver)
• la durée maximale d'ensoleillement réduit (temps couvert)
Pendant une période de temps couvert, un panneau solaire peut fort bien ne fournir que 10%
de sa puissance nominale.
Le montage est alimenté par une batterie rechargée en permanence, par exemple par un
chargeur secteur.
Ce type d'alimentation convient dans le cas où l'on a besoin d'une alimentation de secours en
cas de disparition de la tension secteur. La batterie sert de tampon.
Pratiquement, seule une batterie au plomb peut convenir. On appelle ce type de charge
"floating". Il est préférable d'investir dans une batterie cyclique si les coupures secteur
envisagées sont de longue durée.
Tous les autres types de batterie sont à éviter.
On peut aussi utiliser une super-capacité comme réserve tampon.
31 of 42 28/10/2023 21:35
Quand le choix des composants est fait, il va falloir premièrement déterminer si le

fonctionnement en mode veille est possible.
Certains composants comme le HC-05 n'en possèdent pas.
Certains autres composants comme le NRF24L01, le RFM95, les ESP8266 et ESP32 en

possèdent un mais il est évidemment activable uniquement si le module est utilisé en mode
client. En mode serveur, la réception est activée en permanence, donc le mode veille n'est pas
activable.
Pour développer une solution basse consommation, le mode veille du micro-contrôleur doit être
activé, mais aussi celui des modules qui en possèdent un.
Généralement on considère que si le mode veille n'est pas activable, la possibilité d'alimenter
un processeur à l'aide d'une batterie en mode autonome est fortement compromise.
En effet si l'on considère qu'un ARDUINO NANO consomme une trentaine de mA en étant
éveillée en permanence, la consommation d'énergie sera de :
30 * 24 * 365 = 262800mAH par an
Soit l'équivalent de 100 batteries 18650 de 2600mAH chacune.
En faisant le calcul dans l'autre sens, une batterie de 2600mAH aura une autonomie égale à :
2600 / 30 / 24 = 3.6 jours
L'alimentation d'une carte de ce type sans mode veille est bien sûr envisageable mais pas de
manière permanente.
Mon voltmètre / ampèremètre USB peut être alimenté par deux batteries 18650, mais il est
équipé d'un interrupteur marche / arrêt.
Le bilan des consommations va directement permettre de déterminer la capacité de la batterie.

Ce bilan se décompose ainsi :
• le courant en mode veille
• le courant en mode éveillé, qui est périodique
Prenons comme exemple un capteur de température autonome alimenté par une batterie
LITHIUM-ION.
Le courant en mode éveillé sera équivalent à :
• ARDUINO PRO MINI modifié : 5.6mA
• capteur DS18B20 : 4mA
• module NRF24L01 : 12mA
• régulateur LM2936 : 15µA
La lecture de la température sur le DS18B20 et l'émission du résultat par le NRF24L01 ne se

produiront pas simultanément. On peut donc dire que le courant maximal sera d'environ 18mA.
Le courant va varier énormément entre le moment où le processeur va se réveiller, mesurer la
température et émettre le résultat. Sans un appareil de mesure adéquat, cela va être difficile à
estimer.
Après quelques mesures à l'aide d'un banc de mesure de consommation (voir paragraphe
suivant) on peut estimer que la phase de réveil va durer un trentaine de ms et le courant moyen
sera de 10mA.
L'émission a lieu 4 fois par heure pendant 30ms, donc 120ms au total, ce qui représente
1/30000è d'heure.
La consommation en mode éveillé est donc de 10mAH / 30000 = 0.333µAH.
Le courant en mode veille sera équivalent à :
• ARDUINO PRO MINI modifié : 5µA
32 of 42 28/10/2023 21:35
• capteur DS18B20 : 1µA
• module NRF24L01 : 1µA
La consommation en mode veille est donc de 22µA.
Fixons-nous un objectif d'autonomie : 365 jours.
Le bilan de consommation d'énergie sera le suivant :

Consommation d'énergie en mode veille : 22µAH x 24 x 365 = 192mAH
Consommation d'énergie en mode éveillé : 0.33µAH x 24 x 365 = 3mAH
Nous obtenons donc un total de 195mAH.
En prenant en compte le fait qu'une batterie LITHIUM-ION a un léger courant d'auto-décharge,

une batterie de 250mAH sera parfaitement à l'aise dans ce montage.
Cela nous conduit à adopter une batterie au format 16340 (ou CR123), intéressante pour son
faible encombrement, ou une petite LIPO.
Imaginons que nous remplacions la PRO MINI par une NANO. Nous ne pourrons pas l'alimenter
par une batterie de 3.7V. Il en faudra 2 et alimenter par la broche VIN.
Le courant en mode éveillé sera équivalent à :
• ARDUINO NANO : 32mA
• capteur DS18B20 : 4mA
• module NRF24L01 : 12mA
On estime que le courant moyen sera de 35mA.
La consommation en mode éveillé est donc de 35mAH / 30000 = 1.16µAH.
Le courant en mode veille sera équivalent à :
• ARDUINO NANO : 12.5mA
• capteur DS18B20 : 1µA
• module NRF24L01 : 1µA
La consommation en mode veille est donc de 12.5mA.
Pour un objectif d'autonomie de 365 jours le bilan de consommation d'énergie sera le suivant :
Consommation d'énergie en mode veille : 12.5mAH x 24 x 365 = 109000mAH
Consommation d'énergie en mode éveillé : 1.16µAH x 24 x 365 = 10mAH
Nous obtenons donc un total de 109010mAH.
Ce n'est pas la peine d'aller plus loin. Il faudrait une batterie de camion. Le fonctionnement en
mode autonome pour ce genre de cas est inadapté. Autant adopter une alimentation secteur ou
un rechargement par énergie solaire.
Un détecteur de passage autonome alimenté par une batterie LITHIUM-ION.
Le capteur de présence HC-SR501 consomme 60µA en mode veille, ce qui est nettement
supérieur au 1µA d'un DS18B20. On peut déjà dire que la batterie de ce montage devra avoir
capacité supérieure si l'on veut disposer d'une autonomie d'un an.
Le principe de calcul sera le même que pour l'exemple N°1, sauf qu'il va vous falloir estimer le
nombre de passages dans la journée pour calculer la dépense d'énergie en mode éveillé.
Vous avez un montage à base d'ARDUINO classique 5V (UNO, NANO) et vous aimeriez
l'alimenter par batterie.
Si ce montage effectue une tâche périodique et passe la majeure partie de son temps à ne rien
33 of 42 28/10/2023 21:35
faire, tout n'est pas perdu :
Le TPL5110 est un circuit temporisateur. Il permet d'alimenter un montage périodiquement,

avec une période allant de 100ms jusqu'à deux heures.
Ce module AdaFruit consomme 20µA.

Il embarque un MOSFET canal P DMG3415 pouvant délivrer 4A.
Ce schéma comporte 2 batteries 3.7V et un régulateur 5V pouvant délivrer 250mA. Ce

régulateur consomme 4µA au repos.
Si vous avez besoin de plus ou moins de courant, il peut être remplacé par d'autres modèles :
• HT7150 : 30mA (2.5µA de courant de repos)
• HT7550 : 100mA (2.5µA de courant de repos)
• HT7850 : 250mA (4µA de courant de repos)
Lorsque votre montage a terminé son travail, il n'a plus qu'à le signaler par la broche DONE (5V)
pour couper l'alimentation.
Cela implique une légère modification de votre montage :

- un petit fil à ajouter
- une petite modification du logiciel
6. Vériﬁcation
Après avoir élaboré le montage électronique et le code, il va falloir procéder à la vérification de
la consommation.
Quel moyen utiliser ?
Un banc de mesure comme celui-ci est très appréciable :

https://riton-duino.blogspot.com/2018/07/banc-de-mesure-de-consommation.html
Ou bien celui-ci :
34 of 42 28/10/2023 21:35
https://riton-duino.blogspot.com/2018/11/usb-un-voltmetre-amperemetre.html
Sinon, on peut utiliser un multimètre. Celui-ci ne sera pas capable cependant de tracer une
courbe de consommation sur la durée, à moins d'investir dans un multimètre haut de gamme.
Une recommandation :
On ne mesure jamais la consommation d'un processeur avec un multimètre sur le calibre µA.
La résistance du shunt est trop importante et empêche le processeur de démarrer et encore
plus de démarrer le WIFI si c'est un ESP8266 ou un ESP32.
Mon multimètre (20000 points) a une résistance (shunt) de 3Ω sur le calibre mA. Sur le calibre
µA il passe à 100Ω.
Un ESP8266 qui démarre consomme au minimum 300 mA et jusqu'à plus de 400.
Avec un shunt de 100Ω en série il ne démarrera jamais.
Un shunt de 3Ω produira une chute de 1V. Il n'est même pas sûr que le démarrage s'effectue (on
peut peut-être améliorer la chose avec un gros condensateur en parallèle sur les broche 5V et
GND ?).
Pour mesurer la consommation d'un processeur en mode veille, on peut placer un bouton-
poussoir en parallèle sur le multimètre :
Appuyer sur le bouton-poussoir pendant la phase de démarrage et le relâcher une fois que l'on
est sûr que le processeur est en mode veille.
7. Surveillance
Une fois que le montage est en situation réelle, la surveillance de la tension batterie est vitale
pour la durée de vie de celle-ci. Cette surveillance sera de préférence automatisée, c'est à dire
que le micro-contrôleur devra mesurer la tension de la batterie périodiquement.
La tension de la batterie peut être utilisée afin de déterminer la capacité restante.
Pour une batterie LITHIUM-ION :
• 4.2V : 100%
• 3.85V : 75%
• 3.42V : 25%
• 3.0V : 3%
Cette information peut être utilisée de différentes manières :
• faire clignoter une LED
• activer un buzzer
• remonter l'information à un serveur
• refuser d'assurer le fonctionnement
• etc.
Faire clignoter une LED ou faire retentir un buzzer est possible tant que le courant moyen
consommé est faible. A partir du moment où la batterie a atteint son seuil critique de tension
minimale admissible, il vaut mieux ne plus avertir, car cela entraînerait le décès de la batterie.
35 of 42 28/10/2023 21:35
La mesure de la tension de la batterie doit être effectuée à l'aide de l'ADC du micro-contrôleur.

La mesure d'une tension batterie doit être précise.
Avec un ARDUINO, deux cas peuvent se présenter :
Ce cas est rare. Il correspond par exemple à l'utilisation de deux piles 1.5V ou une batterie de
3.7V pour alimenter un ARDUINO PRO MINI et des modules supportant cette tension, sans
régulateur.
Dans ce cas, la tension d'alimentation peut être mesurée directement sans composant
supplémentaire à l'aide de ce code (provenant d'ICI) :
#define VREF 1.1

unsigned int analogReadReference(void)
{
/* Elimine toutes charges résiduelles */
ADMUX = 0x4F;
delayMicroseconds(5);
/* Sélectionne la référence interne à 1.1 volts comme point de mesure */
ADMUX = 0x4E;
delayMicroseconds(200);
/* Active le convertisseur analogique -> numérique */
ADCSRA |= (1 << ADEN);
/* Lance une conversion analogique -> numérique */
ADCSRA |= (1 << ADSC);
/* Attend la fin de la conversion */
while(ADCSRA & (1 << ADSC));
/* Récupère le résultat de la conversion */
return ADCL | (ADCH << 8);
}
void loop() {
float voltage = (1023 * VREF) / analogReadReference();
}
La tension de la référence interne est peu précise (10%).

Celle-ci peut être mesurée sur la broche VREF de l'ARDUINO lorsque ce code s'exécute. On
prendra soin de modifier la valeur de VREF dans le code afin d'obtenir une plus grande
précision.
Dans ce cas, la tension d'alimentation doit être mesurée à l'aide d'un pont diviseur, car sinon,
l'entrée de l'ADC sera saturée ou endommagée :
Il est possible et même conseillé d'utiliser des valeurs de résistance importantes afin de
minimiser la consommation du pont diviseur.
Une valeur proche du MΩ aura une consommation de 3.3µA sous 3.3V, c'est à dire supérieure à
celle du microcontrôleur.
Attention cependant : choisir une valeur très élevée (10MΩ par exemple) rendra la mesure très
sensible aux perturbation électromagnétiques.
La tension sur l'entrée analogique doit être inférieure à la tension de référence.
Exemple :
36 of 42 28/10/2023 21:35
On mesure une tension de batterie LITHIUM-ION (3.7V nominaux mais 4.2V à pleine charge) :
Ue = tension d'entrée
Us = tension de sortie
Sur le schéma :
R2 = 1MΩ
R3 = 330KΩ
Le rapport du pont diviseur est de 330000 / (1000000 + 330000) = 0.248
Us = Ue * R3 / (R2 + R3) = 4.2 * 330000 / (1000000 + 330000) = 1,042V
1.04V est en dessous de 1.1V -> c'est OK
Le courant consommé par le pont diviseur sera de :
Courant = Ue / (R2 + R3) = 4.2V / (1000000 + 330000) = 3µA
On mesurera la tension de la batterie comme ceci :
#define VREF 1.1 // à mesurer au multimètre sur la broche VREF
unsigned int adc = analogRead(0);
// 0.248 = rapport du pont diviseur
float v = adc * VREF / 1023 / 0.248;
La tension de la référence interne varie également en fonction de la température, et elle varie de

façon non linéaire :
http://ww1.microchip.com/downloads/en/AppNotes/doc8060.pdf
Cela ne va pas être facile d'obtenir une mesure fiable en extérieur, à moins d'utiliser une tension
de référence externe précise et variant peu en fonction de la température.
On peut utiliser un très bon régulateur comme source de tension d'alimentation et il peut servir
en même temps de tension de référence.
La tension du régulateur HT7533-1 par exemple varie de 0.5mV par degré.
Entre -10° et 40° on obtiendra 25mV de variation, ce qui est acceptable.
On pourrait l'utiliser comme référence pour l'ADC. Nous n'utilisons plus la référence interne 1.1V
mais la référence par défaut : 3.3V.
La tension sur l'entrée analogique doit être inférieure à la tension de référence.
Il faut recalculer le pont diviseur :
R2 = 390KΩ
R3 = 1MΩ
Le rapport du pont diviseur est de 1000000÷(390000+1000000) = 0.719
Us = Ue * R3 / (R2 + R3) = 4,2×1000000÷(390000+1000000) = 3.02V
3.02V est en dessous de 3.3V -> C'est OK
Éventuellement on peut mesurer la tension du régulateur au froid (frigo) et au chaud (radiateur)

tout en mesurant la température avec un thermomètre pour appliquer une petite correction
dans le logiciel.
Le calcul de la capacité restante peut être effectué comme ceci, à l'aide d'une table. Le code
inclut la mesure de la tension :
#define VREF 1.1 // à mesurer au multimètre sur la broche VREF
struct batteryCapacity
{
float voltage;
int capacity;
};
const batteryCapacity remainingCapacity[] = {

4.20, 100,
4.10, 96,
4.00, 92,
3.96, 89,
3.92, 85,
37 of 42 28/10/2023 21:35
3.89, 81,
3.86, 77,
3.83, 73,
3.80, 69,
3.77, 65,
3.75, 62,
3.72, 58,
3.70, 55,
3.66, 51,
3.62, 47,
3.58, 43,
3.55, 40,
3.51, 35,
3.48, 32,
3.44, 26,
3.40, 24,
3.37, 20,
3.35, 17,
3.27, 13,
3.20, 9,
3.1, 6,
3.00, 3,
};
const int ncell = sizeof(remainingCapacity) / sizeof(struct batteryCapacity);
unsigned int getBatteryCapacity(void)

{
analogReference(INTERNAL);
unsigned int adc = analogRead(0);
float voltage = adc * VREF / 1023 / 0.248;
for (int i = 0 ; i < ncell ; i++){
if (voltage > remainingCapacity[i].voltage) {
return remainingCapacity[i].capacity;
}
}
return 0;
}
Si l'on utilise la première méthode de mesure sans pont diviseur, le code sera celui-ci :
unsigned int getBatteryCapacity(void)

{
float voltage = (1023 * VREF) / analogReadReference();
for (int i = 0 ; i < ncell ; i++){
if (voltage > remainingCapacity[i].voltage) {
return remainingCapacity[i].capacity;
}
}
return 0;
}
8. Recharge
Le choix d'un chargeur - surtout NI-MH - est critique. Il doit être automatique et précis. Il ne
s'agit pas de détruire les batteries mais de les charger.
La recharge de la batterie va pouvoir s'opérer de différentes manières :
• remplacement des batteries
• chargeur extérieur
• chargeur intégré
Ce mode de recharge et bien adapté aux batteries NI-MH, LITHIUM-ION, LIPO ou LifePo4, en
utilisation autonome.
38 of 42 28/10/2023 21:35
Les batteries vides sont remplacées par des batteries pleines. Cela suppose de pouvoir les
démonter facilement, et le montage doit être équipé d'un support de batterie facilement
accessible.
On utilise un chargeur du commerce pour recharger les batteries vides.
Un très bon chargeur NI-MH : le VoltCraft IPC-1-L :
Deux très bons chargeurs LITHIUM-ION :

Le Xtar MC2 :
Le Xtar VC4 :
Ce mode de recharge et adapté à tout types de batteries, en utilisation autonome ou recharge

périodique.
Un connecteur de recharge doit être prévu sur le montage où l'on vient brancher le chargeur en
cas de besoin.
Un très bon chargeur : le IMAX B6
Il est capable de charger des batteries NI-MH, LITHIUM-ION et LIPO.

Il est pourvu de connecteurs d'équilibrage.
Pour une batterie au plomb, choisir le chargeur en fonction de la capacité de la batterie. Il doit
délivrer un courant équivalent au 1/10ème de la capacité de celle-ci.
39 of 42 28/10/2023 21:35
Un chargeur de batterie au plomb doit être compensé en température car la tension de fin de
charge varie en fonction de celle-ci.
Ce mode de recharge et bien adapté aux batteries Plomb, LIPO et LITHIUM-ION, en utilisation
autonome, recharge périodique ou permanente.
Pour une batterie plomb utilisée en floating, on trouve facilement des chargeurs secteur
adaptés.
Les batteries NI-MH sont difficilement rechargeables par ce moyen. On ne trouve pas de
modules adaptés ou très peu, et pour un seul élément. Il est cependant possible d'en fabriquer
un à l'aide de circuits intégrés :
• LTC4060
• MAX712
Pour les batteries LITHIUM-ION, on trouve d'excellents modules, par exemple à base de
TP4056, capable de fournir 1A :
Il peut facilement être intégré dans un montage ou soudé sur un PCB. Pour recharger la batterie
on branche sur le connecteur USB un petit chargeur de téléphone mobile.
Il est possible de charger des batteries 16340 de faible capacité avec ce chargeur, en utilisant
une source 5V limitée en courant.
Le module peut être laissé connecté en permanence sur la batterie car il consomme très peu
sur celle-ci : quelques µA.
On peut lui appliquer en entrée une tension maximale de 8V. Cette tension peut par exemple
provenir d'un panneau solaire 5V.
L'idéal avec les batteries LITHIUM est d'arriver à 20% de décharge avant d'enclencher la
recharge.
Cela n'empêche pas que l'on puisse les décharger entièrement, sans descendre toutefois en
dessous de la barre des 3V. Descendre en dessous peut être destructeur.
Laisser la batterie en charge permanente n'est pas très bon pour sa durée de vie. Mais
normalement avec le TP4056 ce n'est pas le cas.
J'ai réalisé quelques essais :
• un TP4056
• une batterie 18650 sur la sortie BAT
• une résistance de 200KΩ sur la sortie OUT
• un voltmètre sur la sortie OUT
• recharge par USB avec ampèremètre en série
La résistance consomme 20µA, c'est à dire l'équivalent d'un ESP8266 en mode veille.
En recharge :
La LED rouge du TP4056 est allumée. En fin de charge l'ampèremètre USB mesure un courant
de 100mA.
Le TP4056 coupe la charge lorsque la tension arrive à 4.23V. La LED bleue s'allume.
La sortie OUT ne se coupe pas, en tous cas pas dans cette configuration.
40 of 42 28/10/2023 21:35
En décharge :
Une résistance de 10Ω est branchée sur la sortie OUT.
La LED rouge du TP4056 reste éteinte. L'ampèremètre USB mesure un courant de 0mA, ce qui
prouve que la charge ne démarre pas.
Le TP4056 ré-enclenche la recharge lorsque la tension chute à 4.07V, ce qui correspond à 95%
de capacité.
Ce n'est pas l'idéal, mais c'est mieux que rien.
L'idéal serait d'imaginer un mécanisme à base de comparateur, qui autoriserait la recharge à

partir du moment où il reste 80% de capacité, ce qui correspond grosso modo à 3.9V.
Le TP4056 possède une patte CE (chip enable) qui met le chargeur hors service lorsqu'elle est
à zéro.
Malheureusement cette patte n'est pas accessible sur les modules du commerce. Elle est reliée
au +5V.
Il devrait être possible de dessouder cette patte de la carte et d'y souder un petit fil que l'on
piloterait par une sortie du microcontrôleur en fonction de la tension de la batterie.
9. Attention : danger
Une batterie est capable de délivrer des courants importants, plus de 20A pour une 18650
courante.
Lorsque l'on élabore un montage devant fonctionner sur batterie un court-circuit peut être
particulièrement destructeur.
Le montage doit être vérifié avant d'être mis sous tension. On vérifiera en priorité l'absence de
court-circuit entre les bornes de d'alimentation, surtout s'il s'agit d'un PCB que l'on a fabriqué
soi-même.
10. Conclusion
Je vous ai exposé le fruit de pas mal d'années de pratique en matière d'électronique et de
logiciel embarqué basse consommation. J'espère que cela vous sera utile.
Quelques montages sur batterie sont proposés sur ce blog, ainsi que d'autres articles traitant
de batteries :
https://riton-duino.blogspot.com/2018/01/un-thermometre-mysensors-sur-batterie.html
https://riton-duino.blogspot.com/2019/05/un-thermometre-hygrometre-mysensors-sur.html
https://riton-duino.blogspot.com/2018/04/un-detecteur-de-mouvement-mysensors-sur.html
https://riton-duino.blogspot.com/2018/05/batteries-lithium-ion.html
https://riton-duino.blogspot.com/2018/10/batteries-lithium-ion-recharge-en-serie.html
Cordialement
Henri
11. Mises à jour

24/06/2019 : 8.3.1. Le TP4056 en test
12/07/2019 : 5.3. Le TPL5110
02/05/2020 : 9. Attention : danger
à février 18, 2019 52 commentaires:
Libellés : Alimentation, ARDUINO, Batteries, ESP32, ESP8266, index
Articles plus récents Accueil Articles plus anciens
Inscription à : Articles (Atom)
41 of 42 28/10/2023 21:35
Thème Éthéré. Fourni par Blogger.
42 of 42 28/10/2023 21:35

RitonDuino - Février 2019

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

RitonDuino - Février 2019

Transféré par

Droits d'auteur :

Formats disponibles

RitonDuino: février 2019 http://riton-duino.blogspot.com/2019/02/?

Plus Créer un blog Connexion

Alimentation Affichage Batteries Capteurs Modules CartesPucesRfid Communication Moteurs

Domotique Labo et Atelier Mesure Forums et Blogs Migration sous BITBUCKET

• envoyer un mail ► janvier (6)

Avant d'aller plus loin, il faut savoir que : ARDUINO (74)

• la tension d'alimentation de l'ESP8266 ne peut dépasser 3.6V Audio (17)

• il ne peut fonctionner en dessous de 2.5V Batteries (22)

• la tension d'alimentation de l'ESP32 ne peut dépasser 3.6V Capteurs (10)

• il ne peut fonctionner en dessous de 2.3V. Cartes (1)

Un ESP8266 consomme un courant important lors de la connexion WIFI :

https://www.ondrovo.com/a/20170207-esp-consumption/ Afficher mon profil complet

La capacité de la batterie à utiliser dépendra de plusieurs facteurs :

• consommation de la carte utilisée

• consommation des capteurs

• courant de repos du régulateur de tension

• fréquence des réveils

Lisez également celui-ci : https://riton-duino.blogspot.com/2019/02/alimenter-un-arduino-sur-

• utilisation éventuelle d'un régulateur

https://riton-duino.blogspot.com/2018/11/les-regulateurs-ldo.html VIN, etc.) Après avoir

• le firmware "AT commands"

• le firmware NodeMCU ESP8266 et ESP32 sur

Nous allons commencer par un petit schéma de base :

• RESET : un bouton-poussoir permettant le redémarrage

• FLASH : un bouton-poussoir permettant le chargement

• R1 : résistance de pull-up du de la broche RST

• R2 : résistance de pull-up de la broche EN

• R3 : résistance de pull-up du de la broche GPIO0

• R4 : résistance de pull-up du de la broche GPIO2

• FTDI : un connecteur de chargement

• GPIO15 relié à GND

On peut facilement l'essayer sur une breadboard.

Le chargement par l'IDE ARDUINO se passe de la façon suivante :

• presser les boutons RESET et FLASH

• relâcher le bouton RESET en maintenant le bouton FLASH enfoncé jusqu'au début

Si le message "error: espcomm_upload_mem failed" s'affiche, revoyez votre câblage, y compris

Le transistor Q1 transmet l'intégralité du signal DTR ou RTS à la pin GPIO0 :

En bleu : la pin RST

Ce montage est utilisable de ceux manières :

• avec un convertisseur USB / série simple (3.3V + GND + RX + TX)

• appuyer sur les boutons RESET et FLASH

• relâcher le bouton RESET au début du chargement (Téléversement ...)

• relâcher le bouton FLASH quand le chargement à commencé

• avec un convertisseur USB / série complet (3.3V + GND + RX + TX + DTR ou RTS)

• résistance de 10KΩ entre CH_PD (ou EN) et +3.3V

• résistance de 10KΩ entre GPIO2 et +3.3V

• GPIO15 relié à GND

Il nécessite des barettes mâles SMD au pas de 2.54 :

Cette carte est un peu plus riche. Elles possède :

• un convertisseur USB / série CH340

• une résistance de pull-down sur la broche GPIO15

• quelques condensateurs de découplage

Cette carte occupe un volume raisonnable.

Cette carte occupe un volume important.

Pour l'enficher sur une breadboard vous aurez besoin de ceci :

Pour charger l'ESP01 le câblage est celui-ci :

Nous allons partir d'un exemple concret, un montage destiné à de la surveillance :

• un capteur de température (réveil cyclique)

• deux capteurs de passage PIR (réveil par une GPIO)

• envoyer une requête HTTP à un serveur

• envoyer des données en JSON à un serveur DOMOTICZ ou JEEDOM

Pour cet exemple j'ai choisi d'envoyer un mail.

On trouve beaucoup de documentation sur le WEB :