Alimenter un Arduino avec une pile : 9V, AA, 18650 et broche Vin

Alimenter un Arduino avec une pile, c'est la première étape pour libérer ton projet du câble USB de l'ordinateur et en faire une voiture robot, un capteur au fond du jardin ou un appareil qui tient dans la poche. La réponse courte : la façon la plus sûre de faire tourner un Arduino Uno sur piles est de brancher un pack de 7 à 12 V (6×AA ou deux cellules 18650 en série) sur le jack DC ou la broche Vin, ou de brancher une batterie externe (powerbank) sur le port USB. La broche 5V ne doit servir qu'avec une source 5 V propre que tu as mesurée et réglée, car elle contourne complètement le régulateur et les protections de la carte.

Une mauvaise alimentation est à l'origine de nombreux problèmes mystérieux chez les débutants : une carte qui redémarre dès que le servo bouge, une pile 9V vide en quelques heures, une batterie externe qui se coupe au bout de quelques secondes ou un régulateur trop chaud pour le toucher. Dans ce guide, tu vas découvrir chaque entrée par laquelle alimenter un Arduino, quelle pile brancher où, pourquoi les moteurs ont besoin de leur propre source, et comment calculer la consommation et l'autonomie. À la fin, on verra aussi ce qui change quand on alimente un ESP32 ou un Raspberry Pi Pico sur batterie.

5 façons d'alimenter un Arduino

L'Arduino Uno possède deux chemins d'alimentation distincts. Les 5 V venant de l'USB traversent un fusible réarmable de 500 mA (polyfuse) et un petit interrupteur MOSFET, puis arrivent directement sur la ligne 5 V de la carte. La tension du jack DC passe d'abord par une diode de protection contre l'inversion de polarité, se retrouve à ce point sur la broche Vin, puis un régulateur LDO de la famille 1117 l'abaisse à 5 V. Le 3,3 V est produit à partir de cette ligne 5 V par un second régulateur plus petit. Un comparateur surveille Vin : dès que Vin dépasse environ 6,6 V, il coupe automatiquement l'alimentation USB, si bien que les sources ne se gênent pas même quand l'adaptateur et l'USB sont branchés en même temps.

Alimentation par USB : la limite de 500 mA

L'USB est la manière la plus simple et la mieux protégée d'alimenter un Arduino. Un port USB 2.0 d'ordinateur fournit au maximum 500 mA ; le polyfuse de l'Uno chauffe et coupe le circuit quand le courant total dépasse cette valeur, puis se réarme seul en refroidissant. La carte consomme elle-même environ 45 à 50 mA, ce qui laisse à peu près 400 mA à partager entre capteurs, LED et modules. Un chargeur de téléphone ou une batterie externe s'utilisent sur le même port USB ; la seule différence est que la tension peut descendre jusqu'à 4,6 V avec des câbles fins et longs. Tant que la carte est alimentée par USB, chaque milliampère tiré sur la broche 5V est pris sur ce budget de 500 mA. C'est pourquoi brancher un servo ou un ruban LED sur l'alimentation USB fait déclencher le fusible, et le port de l'ordinateur peut aussi couper la liaison pour se protéger.

Jack DC et broche Vin : pourquoi 7 à 12 V ?

Le régulateur 5 V de la carte est un LDO linéaire : pour bien fonctionner, il lui faut environ 1 à 1,2 V de plus en entrée qu'en sortie. Ajoute la chute de 0,7 à 1 V de la diode de protection du jack, et il te faut au moins 7 V sur le jack pour que le 5 V reste stable. Avec une source de 6 V, la ligne 5 V tombe à 4,2–4,5 V ; la carte semble fonctionner, mais les mesures analogiques dérivent et les modules se comportent bizarrement. En haut de la plage, le problème est la chaleur : un régulateur linéaire transforme la tension en trop en chaleur. La puissance dissipée vaut P = (Vin − 5 V) × I. En règle générale, ne fais pas dissiper plus de 1 W au régulateur ; au-delà, le petit boîtier SOT-223 devient trop chaud pour être touché et finit par se mettre en sécurité.

La broche Vin est à la fois une entrée et une sortie. Quand tu alimentes la carte par le jack, Vin fournit la tension du jack moins environ 0,7 à 1 V ; tu peux y alimenter une petite charge de 9 à 12 V. Mais comme une diode de protection de 1 A se trouve sur le trajet du courant, les grosses charges comme les moteurs doivent être alimentées directement depuis la source, pas par Vin. Si tu branches un boîtier de piles sur la broche Vin, cette diode est contournée : le régulateur fonctionne toujours, mais si tu inverses le plus et le moins, plus rien ne protège la carte. Sur les nouveaux Uno R4 Minima et R4 WiFi, le jack et Vin acceptent 6 à 24 V et utilisent un convertisseur à découpage (buck) au lieu d'un régulateur linéaire ; ils ne chauffent donc pas, même à 12 V. Plus de détails dans Arduino Uno R4.

Broche 5V : quand peut-on contourner le régulateur sans risque ?

La broche 5V est reliée directement à la ligne d'alimentation de l'ATmega328P et des autres puces de la carte. En alimentant par cette broche, tu contournes le régulateur, la diode anti-inversion et le fusible USB. C'est pourquoi la documentation d'Arduino elle-même déconseille d'alimenter par les broches 5V et 3.3V. Bien fait, cela a pourtant des avantages : sans chute de tension ni perte de chaleur dans le régulateur, la batterie dure plus longtemps et tu peux fournir plus de courant aux modules. Une seule condition : la source doit être régulée et mesurée. L'ATmega328P est prévu pour fonctionner au maximum à 5,5 V, et 6 V est sa limite absolue ; même un bref instant au-dessus peut endommager la puce définitivement.

• Mesure d'abord : vérifie la sortie de la source au multimètre avant de la brancher à l'Arduino ; elle doit être entre 4,8 et 5,2 V.
• Jamais de piles en direct : 4 piles AA alcalines neuves montent à 6,4 V et dépassent la limite. Ne branche sur la broche 5V que la sortie d'un régulateur, d'un module buck ou boost.
• Attention à l'USB en même temps : si tu branches l'USB pendant que tu alimentes par la broche 5V, deux sources 5 V se retrouvent reliées à travers la carte ; le plus sûr est de débrancher l'alimentation externe pendant le téléversement.
• Ajoute un condensateur : un condensateur électrolytique de 100 à 470 µF sur la ligne 5 V externe, près de la carte, atténue les chutes lors des appels de courant (qu'est-ce qu'un condensateur ?).
• Solutions toutes prêtes : les modules régulateurs à 7805 (régulateur de tension 7805), un LM2596 réglé sur 5,0 V ou, pour la breadboard, le module d'alimentation MB102 fournissent un 5 V propre.

Broche 3.3V : combien de courant peux-tu tirer ?

La broche 3.3V de l'Uno n'est pas une entrée d'alimentation mais la sortie d'un petit régulateur, et sa limite officielle est de 50 mA. C'est suffisant pour des modules qui ne dépassent pas quelques dizaines de milliampères, comme un BME280, un MPU6050 ou un lecteur RFID RC522. Mais les modules à forts pics de courant la mettent en difficulté : le nRF24L01+PA+LNA avec antenne dépasse 100 mA en émission, le module Wi-Fi ESP-01 tire des pics de plusieurs centaines de milliampères et le SIM800L réclame des appels de courant jusqu'à 2 A. Pour le nRF24L01+PA+LNA et l'ESP-01, utilise un module régulateur AMS1117 3,3 V séparé, alimenté par la ligne 5 V. Le SIM800L, lui, ne fonctionne pas en 3,3 V mais entre 3,4 et 4,4 V et dépasse la limite de 1 A de l'AMS1117 ; alimente-le avec une seule cellule Li-ion ou un module buck réglé sur 4,0 V capable de fournir au moins 2 A. Sur l'Arduino Nano et ses clones, la broche 3.3V vient souvent de la puce USB-série elle-même et elle est encore plus faible que sur l'Uno ; là aussi, un régulateur séparé est plus sûr. Tu trouveras plus de détails sur l'alimentation des modules sans fil dans le guide du nRF24L01.

Choisir sa pile : 9V, AA, 18650 ou batterie externe

La pile 9V classique est l'option la plus conseillée grâce à son clip avec fiche jack, mais c'est aussi la moins efficace. Elle contient six minuscules éléments, donc sa capacité n'est que d'environ 400 à 600 mAh et sa résistance interne est élevée ; ajoute un servo ou quelques LED aux 50 mA de l'Uno et la tension passe vite sous 7 V, puis la carte commence à redémarrer. Sur une carte à régulateur linéaire, ce sont les mAh de la pile qui fixent directement l'autonomie, les volts en trop partent en chaleur. C'est pourquoi un boîtier 6×AA, qui donne les mêmes 9 V, tient environ quatre fois plus longtemps qu'une pile 9V. On explique les unités de capacité en détail dans que signifie mAh ?.

Les piles AA sont bon marché et se trouvent partout, mais il faut choisir le bon nombre. L'erreur la plus fréquente est d'utiliser 4×AA : 6 V ne suffisent pas pour le jack, car après les chutes de la diode et du régulateur il n'arrive qu'environ 4,2 V sur la ligne 5 V, et brancher le même pack sur la broche 5V donne 6,4 V avec des piles neuves, au-delà de la limite. Les bonnes combinaisons sont un pack de 6×AA (9 V) sur le jack DC et un pack de 3×AA (4,5 V) directement sur la broche 5V. Un Uno cadencé à 16 MHz sur 3×AA devient instable dès que chaque pile passe sous 1,25 V, tu ne peux donc pas utiliser toute la capacité. Les accus NiMH donnent 1,2 V par élément, si bien que 4×NiMH (4,8 V) est aussi un choix courant pour la broche 5V, mais des accus tout juste chargés peuvent dépasser 5,5 V pendant les premières minutes.

Batterie Li-ion 18650 et convertisseur élévateur

La 18650 est une cellule lithium-ion rechargeable de 18 mm de diamètre et 65 mm de long, celle qu'on trouve dans les batteries d'ordinateur portable et les batteries externes. Sa tension nominale est de 3,7 V ; elle mesure 4,2 V pleine et environ 3,0 V vide. Sa capacité réelle se situe entre 2000 et 3500 mAh ; les cellules marquées 6800 ou 9900 mAh sont presque toujours des contrefaçons. Une seule 18650 s'utilise avec un Arduino de deux façons : élever les 3,7 V à 5 V avec un convertisseur élévateur (boost, par exemple un module MT3608 ou une carte powerbank 18650 toute faite) pour alimenter l'USB ou la broche 5V, ou relier deux cellules en série et brancher le pack 2S (7,4 V) sur le jack DC. La seconde solution est la plus équilibrée pour l'Uno : à partir de 8,4 V, la tension reste dans la zone de confort du régulateur jusqu'à descendre à 3,5 V par cellule (7 V au total). Avec un boost, n'oublie pas que le courant tiré de la batterie est plus élevé qu'en sortie : un circuit qui demande 200 mA sous 5 V tire environ 307 mA sur une cellule de 3,7 V avec un rendement de 88 pour cent.

• La protection est indispensable : décharger une cellule Li-ion sous 3,0 V raccourcit sa vie et peut être dangereux. Utilise des cellules protégées ou une carte de protection (BMS).
• Le TP4056 est fait pour une seule cellule : le module TP4056 ne charge qu'une cellule (1S) jusqu'à 4,2 V. Ne charge jamais un pack 2S en série avec un TP4056 ; utilise un circuit de charge avec BMS 2S ou un chargeur équilibreur. Le câblage est détaillé dans module de charge TP4056.
• Gare aux courts-circuits : une 18650 peut débiter des dizaines d'ampères en court-circuit ; ne laisse pas de fils dénudés et ajoute un fusible et un interrupteur sur la ligne de la batterie.
• Réglage du boost : ne branche pas un module réglable comme le MT3608 sur l'Arduino avant d'avoir réglé sa sortie sur 5,0 V.
• Ne mélange pas les cellules : dans un pack en série, utilise des cellules de même marque, même capacité et même niveau de charge.

Pourquoi ma batterie externe se coupe-t-elle toute seule ?

Une batterie externe est un pack tout prêt avec des cellules lithium, un chargeur, une protection et un boost 5 V : c'est donc la façon la plus simple de faire tourner un Arduino sur batterie, il suffit de brancher le câble USB. Pourtant, la plupart des batteries externes surveillent le courant de sortie pour s'éteindre quand le téléphone est chargé, et coupent la sortie en 10 à 60 secondes dès que le courant passe sous 50 à 100 mA. Un Nano qui consomme 20 mA ou un Uno qui consomme 50 mA restent sous ce seuil : la carte fonctionne un moment puis s'éteint sans prévenir. Il y a deux parades : choisir une batterie externe avec un mode faible courant (sur certains modèles, on l'active en appuyant deux fois sur le bouton) ou faire tirer à l'Arduino une brève charge à intervalles réguliers. Pour la seconde méthode, branche une résistance de 47 Ω, 1 W entre la ligne 5V et le collecteur d'un transistor NPN (BC337 ou 2N2222), l'émetteur à GND et la base sur la broche D7 via une résistance de 1 kΩ. Quand le transistor conduit, la résistance tire environ 5 V / 47 Ω ≈ 106 mA et la batterie externe détecte une charge. Tu peux vérifier les valeurs avec le calculateur de loi d'Ohm.

1// Powerbank uyanık tutma / powerbank keep-alive
2// D7 -> 1 kΩ -> NPN beyzi, kolektör -> 47 Ω -> 5V / D7 -> 1 kΩ -> NPN base, collector -> 47 Ω -> 5V
3const int LOAD_PIN = 7;
4const unsigned long PERIOD_MS = 8000;  // her 8 saniyede bir / every 8 seconds
5const unsigned long PULSE_MS = 300;    // 300 ms yük / 300 ms of load
6
7unsigned long pulseStart = 0;
8bool loadOn = false;
9
10void setup() {
11  pinMode(LOAD_PIN, OUTPUT);
12  digitalWrite(LOAD_PIN, LOW);
13}
14
15void loop() {
16  unsigned long now = millis();
17  if (!loadOn && now - pulseStart >= PERIOD_MS) {
18    digitalWrite(LOAD_PIN, HIGH);   // ~106 mA çek / draw ~106 mA
19    loadOn = true;
20    pulseStart = now;
21  }
22  if (loadOn && now - pulseStart >= PULSE_MS) {
23    digitalWrite(LOAD_PIN, LOW);    // yükü kapat / switch the load off
24    loadOn = false;
25  }
26  // projenin kodu burada, delay() kullanmadan / your project code here, without delay()
27}

Comme le code utilise millis() au lieu de delay(), il ne bloque pas le reste de ton projet ; on explique cette approche en détail dans millis() au lieu de delay(). Tirer 106 mA pendant 300 ms toutes les 8 secondes ne représente en moyenne qu'environ 4 mA de plus. Si ta batterie externe se coupe encore, réduis la période à 5 secondes ou allonge l'impulsion à 500 ms ; chaque modèle a son propre seuil et son propre délai.

Alimentation séparée pour moteurs et servos, masse commune

Les moteurs et les servos sont les charges qui posent le plus de problèmes quand on alimente un Arduino sur batterie. Un servo tire un pic de plusieurs centaines de milliampères à l'instant où il démarre, et les moteurs à courant continu demandent plusieurs fois leur courant normal au démarrage ou lorsqu'ils sont bloqués. Ce pic peut faire s'effondrer un instant la ligne 5 V ; si la tension descend assez bas, la protection contre les sous-tensions (brown-out) de l'ATmega328P se déclenche et la carte redémarre toute seule. En plus, le bruit des balais des moteurs fausse les mesures des capteurs. La règle est simple : n'alimente pas plus d'un petit servo depuis la broche 5V de l'Arduino, et fais tourner tous les autres moteurs sur une source séparée. Pour comprendre le fonctionnement des servos et des moteurs CC, consulte servomoteur et commander un moteur CC avec le L298N.

1. Choisis une source séparée pour les moteurs : 5–6 V pour les servos (4×AA NiMH ou un LM2596 réglé sur 5–6 V), et pour les moteurs CC un pack adapté à leur tension (par exemple 2S 18650).
2. Relie le plus de cette source uniquement aux fils rouges des servos ou à l'entrée de puissance du driver moteur ; ne le relie pas à la broche 5V de l'Arduino.
3. Alimente l'Arduino par sa propre entrée : tu peux aussi brancher le même pack 2S sur le jack DC, du moment que le courant des moteurs ne traverse pas le régulateur de l'Arduino.
4. Relie le moins (GND) de la source à la broche GND de l'Arduino. Sans masse commune, le signal de commande ne fonctionne pas.
5. Branche le fil de signal orange ou jaune du servo sur une broche numérique de l'Arduino (par exemple D9) ; la bibliothèque Servo fonctionne aussi sur les broches sans marque PWM.
6. Ajoute un condensateur électrolytique de 470 à 1000 µF sur l'alimentation des servos, près d'eux ; respecte la polarité.
7. Avec un L298N, envoie l'alimentation des moteurs sur le bornier 12V ; si elle dépasse 12 V, retire le cavalier 5V-EN et alimente l'Arduino par sa propre source.

Comment calculer la consommation et l'autonomie ?

Dans un projet sur batterie, la vraie question est : "combien de temps ça va tenir ?". La formule de base est simple : Autonomie (heures) = Capacité (mAh) × 0,85 / Courant moyen (mA). Le facteur 0,85 tient compte du fait qu'une batterie ne délivre jamais toute sa capacité nominale : la capacité baisse avec un fort courant et par temps froid, le circuit s'arrête avant que la batterie soit totalement vide et les convertisseurs ajoutent des pertes. Pour les piles dont la tension chute tôt, comme la 9V, 0,7 est plus réaliste. Si ton projet passe l'essentiel de son temps en veille, calcule d'abord le courant moyen : Courant moyen = (Courant actif × durée active + Courant de veille × durée de veille) / durée totale. Plutôt que de calculer à la main, tu peux utiliser le calculateur d'autonomie de batterie : saisis la capacité, les courants en éveil et en veille et l'intervalle de réveil, il te donne l'autonomie en heures, en jours ou en mois.

Mesurer vaut toujours mieux que deviner. Mets ton multimètre sur le calibre courant (mA) et branche-le en série entre la batterie et le circuit pour voir la consommation réelle ; on montre comment faire dans comment utiliser un multimètre. Si la valeur est plus élevée que prévu, regarde d'abord la consommation propre de la carte : sur l'Uno, la puce USB-série (ATmega16U2), la LED d'alimentation et le régulateur consomment plus de 30 mA même quand l'ATmega328P dort. C'est pourquoi les projets qui demandent une longue autonomie privilégient des cartes sans puce USB comme l'Arduino Pro Mini ; un Pro Mini dont on a retiré la LED d'alimentation et le régulateur descend à quelques microampères en veille.

Étape par étape : faire fonctionner ton projet sur batterie

1. Pendant que le projet tourne sur USB, mesure au multimètre son courant moyen et son courant de pointe, y compris quand le servo ou le moteur bouge.
2. Sépare les charges gourmandes comme les moteurs, les servos et les rubans LED, et prévois une source séparée pour elles.
3. Choisis l'entrée de la carte : pour l'Uno, un pack de 7 à 12 V sur le jack DC, ou du 5 V régulé sur l'USB ou la broche 5V ; pour le Pico, 1,8 à 5,5 V sur VSYS.
4. Calcule la capacité nécessaire pour l'autonomie voulue, ou utilise le calculateur d'autonomie de batterie.
5. Ajoute un interrupteur marche/arrêt sur le plus de la batterie ; vérifie que les packs Li-ion ont une carte de protection (BMS).
6. Téléverse le code par USB, puis débranche l'USB et teste sur batterie ; contrôle au multimètre la tension sur la broche 5V pendant que le servo bouge.
7. Surveille la tension de la batterie dans le code et préviens quand elle passe sous une certaine valeur (code ci-dessous).

Mesurer la tension de la batterie avec l'Arduino

Plutôt que de deviner quand la batterie sera vide, tu peux mesurer sa tension. Les entrées analogiques de l'Arduino lisent au maximum 5 V : tu ne peux donc pas brancher directement sur A0 un pack 2S qui monte à 8,4 V, il te faut un pont diviseur de tension. Deux résistances de 100 kΩ et 10 kΩ divisent la tension par 11 : 8,4 V deviennent environ 0,76 V sur A0. Comme la ligne 5 V de la carte peut dériver quand la batterie faiblit, il est plus précis de mesurer avec la référence interne de 1,1 V, qui ne dépend pas de la tension d'alimentation. Tu peux choisir les valeurs de résistances pour ton pack avec le calculateur de pont diviseur et approfondir le sujet dans pont diviseur de tension.

1// 2S Li-ion paket gerilimini ölçme / measuring a 2S Li-ion pack voltage
2// Pil+ -> 100k -> A0 -> 10k -> GND / pack+ -> 100k -> A0 -> 10k -> GND
3const int BAT_PIN = A0;
4const int LED_PIN = 13;      // pil zayıf uyarısı / low-battery warning
5const float R1 = 100000.0;   // üst direnç / top resistor
6const float R2 = 10000.0;    // alt direnç / bottom resistor
7const float VREF = 1.1;      // dahili referans, multimetreyle düzelt / internal reference, calibrate with a multimeter
8const float LOW_V = 6.6;     // 2S için alt sınır (3,3 V/hücre) / low limit for 2S (3.3 V per cell)
9
10void setup() {
11  Serial.begin(9600);
12  pinMode(LED_PIN, OUTPUT);
13  analogReference(INTERNAL);   // 1,1 V referans (Uno/Nano) / 1.1 V reference (Uno/Nano)
14  analogRead(BAT_PIN);         // ilk ölçümü at / discard the first reading
15  delay(10);
16}
17
18void loop() {
19  long sum = 0;
20  for (int i = 0; i < 16; i++) {   // 16 ölçümün ortalaması / average of 16 readings
21    sum += analogRead(BAT_PIN);
22    delay(2);
23  }
24  float pinV = (sum / 16.0) * VREF / 1024.0;
25  float batV = pinV * (R1 + R2) / R2;
26
27  Serial.print("Pil / Battery: ");
28  Serial.print(batV, 2);
29  Serial.println(" V");
30
31  digitalWrite(LED_PIN, batV < LOW_V ? HIGH : LOW);   // zayıfsa LED yanar / LED on when low
32  delay(2000);
33}

Relie le haut du pont diviseur au plus de la batterie après l'interrupteur, pour que le pont ne vide pas la batterie quand l'appareil est éteint. La référence interne de 1,1 V peut varier d'environ ±10 % d'une puce à l'autre : compare la tension mesurée au multimètre avec celle du moniteur série et corrige VREF en conséquence (par exemple 1,08). Le pont consomme en permanence environ 76 µA, ce qui n'a pratiquement aucun effet sur l'autonomie. Le code est prévu pour l'Uno et le Nano ; sur le Mega, la référence s'appelle INTERNAL1V1. Le seuil de 6,6 V correspond à 3,3 V par cellule ; les cellules sont alors presque vides, et descendre sous 3,0 V par cellule les abîme. Si le pack alimente le jack DC, la ligne 5 V commence à chuter vers 7 V : régler LOW_V sur 7,0 est donc aussi pertinent.

Alimenter un ESP32 sur batterie

Les cartes de développement ESP32 fonctionnent en 3,3 V et peuvent être alimentées de trois façons : par le port USB, par la broche 5V (VIN sur certaines cartes) ou directement par la broche 3V3. Espressif demande explicitement de ne jamais les utiliser en même temps et de n'en choisir qu'une. La tension appliquée sur la broche 5V passe par le régulateur LDO 3,3 V de la carte (un AMS1117 sur la plupart des clones), tandis que la broche 3V3 n'accepte que 3,0 à 3,6 V régulés. En émission Wi-Fi, l'ESP32 tire des pics jusqu'à 240 mA ; il lui faut donc une source capable de fournir au moins 500 mA, sinon il redémarre avec l'erreur "Brownout detector was triggered" (détails dans erreur brownout). Ne branche pas une 18650 directement sur la broche 3V3 : pleine à 4,2 V, elle dépasse la limite. La broche 5V ne convient pas bien non plus, car l'AMS1117 a besoin d'une chute d'environ 1,1 V et, à mesure que la tension de la cellule baisse, la sortie descend sous 3,3 V. Les bonnes solutions : une 18650 avec un boost 5 V sur la broche 5V, un régulateur 3,3 V à faible chute (LDO) capable de fournir au moins 500 mA, ou une carte ESP32 avec chargeur Li-ion intégré. Ce qui décide vraiment de l'autonomie, c'est que l'ESP32 passe la plupart de son temps en sommeil profond (deep sleep) ; la puce y consomme environ 10 µA, mais la puce USB-série, la LED et le régulateur des cartes de développement peuvent faire grimper ce chiffre au milliampère. D'où l'écart entre 3 mois et 18 jours dans le tableau plus haut ; plus de détails dans ESP32 deep sleep.

1// ESP32: 18650 gerilimini ölç, sonra derin uykuya geç / measure the 18650, then deep sleep
2// Pil+ -> 100k -> GPIO34 -> 100k -> GND / cell+ -> 100k -> GPIO34 -> 100k -> GND
3const int BAT_PIN = 34;                         // yalnız giriş, ADC1 / input-only, ADC1
4const uint64_t SLEEP_US = 60ULL * 1000000ULL;   // 60 saniye / 60 seconds
5
6void setup() {
7  Serial.begin(115200);
8  uint32_t mv = 0;
9  for (int i = 0; i < 16; i++) {
10    mv += analogReadMilliVolts(BAT_PIN);        // kalibre milivolt / calibrated millivolts
11  }
12  float batV = (mv / 16.0) * 2.0 / 1000.0;      // bölücü yarıya indirir / the divider halves it
13  Serial.printf("Pil / Battery: %.2f V\n", batV);
14
15  if (batV < 3.3) {
16    Serial.println("Pil zayif / Battery low");  // işi atla, pili koru / skip the work, protect the cell
17  } else {
18    // sensörü oku, Wi-Fi ile gönder / read the sensor, send over Wi-Fi
19  }
20
21  esp_sleep_enable_timer_wakeup(SLEEP_US);      // 60 sn sonra uyan / wake up after 60 s
22  Serial.flush();
23  esp_deep_sleep_start();                       // loop() hiç çalışmaz / loop() never runs
24}
25
26void loop() {
27}

À chaque réveil, le code mesure la tension de la batterie, fait son travail et se rendort avec une minuterie de 60 secondes ; comme l'ESP32 relance le programme depuis le début en sortant du sommeil profond, loop() ne s'exécute jamais. GPIO 34 est une broche ADC1 en entrée seule qui fonctionne même avec le Wi-Fi actif, alors que les broches ADC2 ne sont pas utilisables avec le Wi-Fi. analogReadMilliVolts() s'appuie sur l'étalonnage d'usine de la puce pour renvoyer directement des millivolts. Le pont 100 kΩ + 100 kΩ ramène 4,2 V à 2,1 V et ne consomme que 21 µA ; si la mesure est bruitée, ajoute un condensateur de 100 nF entre GPIO 34 et GND. Pour tes premiers pas avec l'ESP32, qu'est-ce que l'ESP32 ? est un bon point de départ.

Alimenter un Raspberry Pi Pico sur batterie

Le Raspberry Pi Pico est l'une des cartes les plus pratiques sur batterie, car il embarque un régulateur à découpage buck-boost au lieu d'un régulateur linéaire. Donne à la broche VSYS n'importe quelle tension entre 1,8 et 5,5 V et la carte la convertit efficacement en 3,3 V ; elle continue même de fonctionner quand l'entrée passe sous 3,3 V. Tu peux ainsi brancher 2 ou 3 piles AA, une seule 18650 ou une LiPo d'une cellule directement entre VSYS et GND, sans module supplémentaire. Le seul point à surveiller est l'utilisation simultanée de l'USB : le 5 V de l'USB (VBUS) est relié à VSYS par une diode Schottky ; si la batterie est branchée directement sur VSYS et que tu branches l'USB, celui-ci essaie d'injecter du courant dans la batterie. La solution recommandée par Raspberry Pi est de relier la batterie à VSYS par sa propre diode Schottky (par exemple une 1N5817). La broche 3V3 fournit au maximum environ 300 mA aux circuits externes, et mettre la broche 3V3_EN à GND coupe le régulateur, donc toute la carte. Pour une vue d'ensemble de la carte, consulte qu'est-ce que le Raspberry Pi Pico ?.

1from machine import ADC, Pin
2import time
3
4vsys = ADC(29)            # VSYS/3 ölçer (Pico) / measures VSYS/3 (Pico)
5usb = Pin(24, Pin.IN)     # USB takılıysa 1 / 1 when USB is connected
6CONV = 3.3 / 65535        # ham değeri volta çevir / raw value to volts
7
8while True:
9    total = 0
10    for _ in range(16):   # 16 ölçümün ortalaması / average of 16 readings
11        total += vsys.read_u16()
12    volts = total / 16 * CONV * 3   # kart içindeki bölücü 3'e böler / on-board divider divides by 3
13    source = "USB" if usb.value() else "Pil / Battery"
14    print("{}: VSYS = {:.2f} V".format(source, volts))
15    if not usb.value() and volts < 3.3:   # 3xAA ya da 18650 için alt sınır / low limit for 3xAA or a 18650
16        print("Pil zayif! / Battery low!")
17    time.sleep(5)

Sur le Pico, GP29 mesure un tiers de VSYS grâce à un pont diviseur présent sur la carte, tandis que GP24 lit 1 quand l'USB est branché. Sans aucun composant en plus, tu connais donc à la fois la tension de la batterie et la source d'alimentation, USB ou batterie. Si tu as relié la batterie par une diode Schottky comme recommandé, VSYS se lit environ 0,2 à 0,3 V sous la tension de la batterie. La mesure suppose une référence ADC de 3,3 V ; grâce au régulateur buck-boost, cette référence reste stable même quand la batterie faiblit. Sur le Pico W, GP29 et GP24 sont partagées avec la puce sans fil, ce code ne fonctionne donc pas tel quel ; l'état de l'USB s'y lit avec Pin("WL_GPIO2"). Pour prolonger l'autonomie, utilise machine.lightsleep() au lieu de time.sleep() entre deux mesures.

Idées de projets sur batterie

• Voiture robot pilotée en Bluetooth : alimente moteurs et Arduino avec un pack 2S de 18650 ; tous les détails dans fabriquer une voiture Arduino.
• Robot éviteur d'obstacles : évite les redémarrages en alimentant les moteurs via le L298N sur une ligne séparée et l'Arduino par le jack DC (robot éviteur d'obstacles).
• Voltmètre avec jauge de batterie : affiche sur un écran LCD la valeur mesurée via un pont diviseur (fabriquer un voltmètre Arduino).
• Station d'humidité pour le jardin : garde un ESP32 en sommeil profond, mesure l'humidité du sol une fois par heure et fais-le tourner des mois avec une seule 18650.
• Enregistreur GPS portable : enregistre ton parcours de randonnée avec un GPS NEO-6M et une batterie externe.
• Veilleuse Pico sur piles : un Pico alimenté par 3×AA via VSYS allume des LED quand la pièce devient sombre.

Erreurs fréquentes et solutions

Une bonne alimentation, c'est la moitié d'un projet fiable : choisis la bonne entrée, alimente les moteurs à part, relie les masses et calcule l'autonomie dès le départ. Quand tu seras prêt à construire un projet sur batterie, jette un œil dans l'application BlueGrays à la voiture Bluetooth avec L298N, au robot éviteur d'obstacles, à la station d'arrosage intelligente, au voltmètre numérique avec écran LCD et au projet d'économie d'énergie ESP32 en deep sleep ; chacun détaille pas à pas le schéma, le câblage et le code.