Brancher des piles en série et en parallèle : tension et Arduino
Piles en série : la tension s'additionne ; en parallèle : la capacité. Exemples AA, 9 V et 18650, choix du support et bon pack pour Arduino, ESP32 et Pico.
Brancher des piles en série, c'est relier le pôle plus d'une pile au pôle moins de la suivante pour additionner les tensions : quatre piles AA de 1,5 V en série te donnent 6 V, mais la capacité reste celle d'une seule pile. En parallèle, tous les plus sont reliés entre eux, et tous les moins aussi : la tension ne change pas, la capacité et le courant disponible s'additionnent. Quand tu veux rendre ton projet Arduino, ESP32 ou Raspberry Pi Pico portable, savoir combien de piles utiliser et comment les brancher décide si ton projet tiendra des heures ou quelques minutes.
Dans cet article, tu vas voir avec des formules comment le montage en série et en parallèle modifie la tension et la capacité. On te montre des exemples concrets avec des piles AA, 9 V et 18650, pourquoi mélanger des piles différentes est dangereux, comment choisir le bon support et trouver la combinaison adaptée à ta carte. À la fin, tu trouveras du code prêt à l'emploi pour mesurer le niveau de la pile avec un pont diviseur sur Arduino, ESP32 et Pico.

Qu'est-ce que le montage de piles en série et comment ça marche ?
En série, tu alignes les piles comme une chaîne : le plus de la première va au moins de la deuxième, le plus de la deuxième au moins de la troisième ; le premier moins et le dernier plus restent libres et forment les bornes du pack. Le courant traverse toutes les piles l'une après l'autre, donc chacune débite le même courant et les tensions s'additionnent : V_total = V1 + V2 + … + Vn. La capacité, elle, ne s'additionne pas : quatre piles de 2500 mAh en série donnent toujours un pack de 2500 mAh, car chaque pile se vide en même temps. Par exemple, quatre AA alcalines donnent 4 × 1,5 = 6 V, et deux cellules 18650 donnent 2 × 3,7 = 7,4 V. En électronique, on note le nombre de cellules en série avec la lettre « S » : 2S signifie deux cellules en série, 3S trois.
Montage en parallèle : même tension, capacité en plus
En parallèle, toutes les bornes plus sont reliées en un point et toutes les bornes moins en un autre. La tension reste celle d'une seule pile, mais la capacité s'additionne : C_total = C1 + C2 + … + Cn. Comme le courant est réparti entre les piles, chacune est moins sollicitée, le pack dure plus longtemps et peut fournir un courant plus élevé. Le nombre de cellules en parallèle se note « P » : 2S2P désigne un pack de quatre cellules, deux groupes en série branchés en parallèle, qui offre 7,4 V et 5000 mAh avec des 18650 de 2500 mAh. Pour savoir quelle énergie un pack contient vraiment, regarde les wattheures : E (Wh) = V × Ah. Quatre piles de 1,5 V et 2,5 Ah donnent 15 Wh au total, que tu les branches en série (6 V × 2,5 Ah) ou en parallèle (1,5 V × 10 Ah) ; le type de montage ne change pas l'énergie, mais la tension et le courant sous lesquels elle est fournie.
| Caractéristique | Série | Parallèle | Série-parallèle (2S2P) |
|---|---|---|---|
| Branchement | Plus vers le moins de la pile suivante | Plus ensemble, moins ensemble | Deux groupes en série branchés en parallèle |
| Tension | S'additionne (n × V) | Inchangée (V) | 2 × V |
| Capacité (mAh) | Inchangée (C) | S'additionne (n × C) | 2 × C |
| Courant disponible | Celui d'une seule pile | Multiplié par n | Multiplié par 2 |
| Exemple 4 × AA (1,5 V, 2500 mAh) | 6 V, 2500 mAh | 1,5 V, 10 000 mAh | 3 V, 5000 mAh |
| Énergie totale | 15 Wh | 15 Wh | 15 Wh |
Types de piles : comparaison AA, 9 V et 18650
| Pile | Tension nominale | Tension pleine / vide | Capacité typique | Rechargeable ? |
|---|---|---|---|---|
| AA alcaline | 1,5 V | 1,6 V / 0,9–1,0 V | 2000–2800 mAh | Non |
| AA NiMH | 1,2 V | 1,4 V / 1,0 V | 1900–2500 mAh | Oui |
| 9 V alcaline | 9 V | 9,5 V / environ 6 V | 400–550 mAh | Non |
| 9 V NiMH | 8,4 V | environ 9,8 V / 7 V | 170–300 mAh | Oui |
| 18650 Li-ion | 3,6–3,7 V | 4,2 V / 2,5–3,0 V | 2000–3500 mAh | Oui (avec un circuit de charge dédié) |

Exemples prêts à l'emploi : quelle combinaison donne combien de volts ?
| Combinaison | Tension | Capacité | Usage adapté |
|---|---|---|---|
| 2 × AA en série | 3 V (NiMH : 2,4 V) | environ 2500 mAh | Circuits LED, circuits simples en 3 V |
| 3 × AA en série | 4,5 V | environ 2500 mAh | VSYS du Pico, broche 5V de l'Arduino (faiblit quand les piles se vident) |
| 4 × AA NiMH en série | 4,8 V | environ 2000 mAh | Broche 5V de l'Arduino, servomoteurs |
| 4 × AA alcalines en série | 6 V (6,4 V neuves) | environ 2500 mAh | Servos et moteurs DC ; à ne pas brancher directement sur la broche 5V de l'Uno |
| 6 × AA en série | 9 V | environ 2500 mAh | VIN ou jack DC de l'Arduino, alimentation de L298N |
| 1 × 9 V | 9 V | environ 500 mAh | Essais Arduino de courte durée, circuits à faible courant |
| 1S 18650 | 3,7 V (4,2 V pleine) | 2000–3500 mAh | ESP32 (via LDO), VSYS du Pico |
| 2S 18650 en série | 7,4 V (8,4 V pleine) | 2000–3500 mAh | VIN Arduino Uno / Nano, voiture robot |
| 1S2P 18650 | 3,7 V | 4000–7000 mAh | Projets ESP32 et Pico de longue durée |
Le risque de mélanger des piles différentes
Dans un pack en série, toutes les piles débitent le même courant, donc la plus faible se vide en premier. Les autres, encore pleines, continuent de forcer le courant à travers la pile vide, qui est alors chargée à l'envers (inversion de cellule). Résultat : échauffement, dégagement de gaz et, avec les piles alcalines, une fuite blanche et corrosive qui ronge les ressorts du support et les pistes en cuivre de la carte. En parallèle, le danger est différent : la pile à la tension la plus haute envoie du courant directement dans celle dont la tension est plus basse. Comme la résistance interne des piles est très faible (environ 20–50 mΩ pour une 18650), même 0,3 V d'écart entre deux cellules provoque un courant incontrôlé de plusieurs ampères qui échauffe les cellules. Mélanger neuf et usé, alcaline et NiMH, 2000 mAh et 3000 mAh gaspille donc de la capacité et crée un risque de sécurité.
- Même chimie : ne mets jamais d'alcalines, de NiMH et de Li-ion dans le même pack ; leurs tensions et leurs courbes de décharge sont différentes.
- Même marque, modèle et capacité : garde des résistances internes proches ; la cellule de plus faible capacité finit toujours par se vider la première.
- Même âge et même niveau de charge : remplace toutes les piles du pack en même temps ; remplacer une seule pile par une neuve déséquilibre le pack.
- Égalise les tensions avant de brancher des Li-ion en parallèle : l'écart entre les cellules doit rester sous 0,05 V ; mesure au multimètre et recharge les cellules séparément si besoin.
- Utilise un BMS pour les packs Li-ion en série : les packs 2S ou 3S doivent avoir une carte de protection avec équilibrage (BMS) contre la surcharge, la décharge profonde et le court-circuit.
- Fusible contre les courts-circuits : sur les packs capables de débiter un fort courant, un petit fusible ou un polyfuse sur la ligne plus réduit sérieusement le risque d'incendie.
Comment choisir un support de piles ?

- Le nombre d'emplacements fixe la tension : les supports AA et AAA tout faits sont presque toujours câblés en série ; choisis la tension voulue grâce au nombre d'emplacements.
- Modèles avec interrupteur et couvercle : un support avec interrupteur marche-arrêt te permet de couper le circuit sans retirer les piles ; un support avec couvercle évite que les piles sautent de leur logement dans les robots mobiles.
- Vérifie le câblage des supports 18650 : parmi les supports doubles pour 18650, certains sont câblés en série (7,4 V) et d'autres en parallèle (3,7 V). Mets les piles et mesure les fils de sortie au multimètre avant de brancher au circuit.
- Capacité en courant : les ressorts et les fils fins des supports bon marché provoquent une chute de tension sensible dès quelques centaines de milliampères. Pour les robots à moteurs DC, choisis des supports à fils épais et ressorts robustes.
- Clip pour pile 9 V : la pile 9 V se connecte à l'alimentation de l'Arduino avec un clip à pression et, si besoin, un adaptateur jack DC ; si les extrémités dénudées du clip se touchent, la pile est court-circuitée.
- Longueur des cellules protégées : les cellules 18650 avec circuit de protection peuvent atteindre 67–70 mm et ne pas rentrer dans les supports courts ; vérifie la longueur acceptée avant d'acheter.
La bonne combinaison pour Arduino, ESP32 et Pico
| Carte | Entrée d'alimentation | Plage acceptée | Pile recommandée |
|---|---|---|---|
| Arduino Uno / Nano | Broche VIN ou jack DC (Uno) | 7–12 V conseillé | 2S 18650 (7,4 V) ou 6 × AA (9 V) |
| Arduino Uno / Nano | Broche 5V | 5 V régulé (5,5 V maximum) | 4 × AA NiMH (4,8 V) ou pack avec régulateur |
| Carte de développement ESP32 | Broche 5V / VIN | 5 V (va au régulateur 3,3 V de la carte) | 1S 18650 + élévateur 5 V ou 4 × AA NiMH |
| Carte de développement ESP32 | Broche 3V3 | 3,0–3,6 V | 1S 18650 + régulateur 3,3 V à faible chute (LDO) |
| Raspberry Pi Pico | Broche VSYS | 1,8–5,5 V | 1S 18650, 3 × AA alcalines ou 3 × AA NiMH |
Tu estimes l'autonomie d'une pile avec cette formule : durée (h) = capacité (mAh) / courant moyen (mA) × 0,8. Le coefficient 0,8 représente la marge pour les pertes du régulateur, la température et le fait que la pile ne se vide jamais complètement. Un Arduino Uno seul consomme environ 45–50 mA ; avec quelques capteurs et LED, il atteint 60 mA. Avec un pack 2S 18650 de 2500 mAh, il tient 2500 / 60 × 0,8 ≈ 33 heures. Le même circuit sur une pile 9 V de 500 mAh ne tient que 500 / 60 × 0,8 ≈ 6,5 heures, et la tension d'une pile 9 V chutant vite sous charge, la durée réelle est encore plus courte. Un ESP32 avec le Wi-Fi actif consomme en moyenne 80–120 mA, avec des pointes jusqu'à 250 mA ; c'est pourquoi, dans les projets ESP32, une 18650 ou un pack 1S2P associé au deep sleep permet de tenir des jours, voire des semaines. Si tu ne veux pas faire le calcul à la main, utilise le calculateur d'autonomie de pile.
Mesurer la tension de la pile : montage du pont diviseur
Le moyen le plus simple de savoir à quel point la pile est chargée, c'est de mesurer sa tension. Mais les 8,4 V d'un pack 2S dépassent les 5 V que supporte l'entrée analogique de l'Arduino, et les 4,2 V d'une cellule 1S dépassent la limite de 3,3 V de l'ESP32 et du Pico. Tu montes donc avec deux résistances un pont diviseur de tension : V_sortie = V_pile × R2 / (R1 + R2). Deux résistances égales divisent la tension exactement par deux ; 8,4 V devient 4,2 V et 4,2 V devient 2,1 V. Comme le pont consomme en permanence du courant, utilise des résistances de 100 kΩ sur ESP32 et Pico pour préserver la pile ; sur l'Uno, 10 kΩ suffisent pour une lecture stable de l'ADC et ne consomment que 0,42 mA à 8,4 V. Tu peux ajuster les valeurs à ton pack avec le calculateur de pont diviseur.
| Branchement | Arduino Uno (2S 18650) | ESP32 (1S 18650) | Raspberry Pi Pico (1S 18650) |
|---|---|---|---|
| Plus de la pile (+) | Haut de R1 et VIN | Haut de R1 et entrée du LDO | Haut de R1 et VSYS |
| Point milieu R1 – R2 | A0 | GPIO 34 | GP26 (ADC0) |
| Bas de R2 | GND | GND | GND |
| Moins de la pile (−) | GND | GND | GND |
| Valeurs des résistances | R1 = R2 = 10 kΩ | R1 = R2 = 100 kΩ | R1 = R2 = 100 kΩ |
| Tension maximale sur la broche | 4,2 V | 2,1 V | 2,1 V |
Indicateur de niveau de pile avec Arduino
- Mets deux cellules 18650 dans le support double câblé en série et vérifie au multimètre que la sortie est entre 7,4 et 8,4 V.
- Relie le fil plus du support à la broche VIN de l'Uno (ou à l'adaptateur jack DC) et le fil moins à GND.
- Branche deux résistances de 10 kΩ en série entre le plus de la pile et GND ; amène le point de jonction des deux résistances sur A0.
- Tu utiliseras la LED intégrée (broche 13) comme alerte de pile faible ; aucune pièce supplémentaire n'est nécessaire.
- Téléverse le code, ouvre le moniteur série à 9600 bauds et compare la tension affichée avec la valeur du multimètre.
1const int BAT_PIN = A0; // bölücü orta noktası / divider midpoint
2const int LED_PIN = 13; // düşük pil uyarısı / low battery warning
3const float R1 = 10000.0; // üst direnç / top resistor
4const float R2 = 10000.0; // alt direnç / bottom resistor
5const float VREF = 5.0; // ADC referansı / ADC reference
6const float V_EMPTY = 6.4; // 2S boş (2 x 3,2 V) / 2S empty
7const float V_FULL = 8.4; // 2S dolu (2 x 4,2 V) / 2S full
8const float V_LOW = 6.8; // uyarı eşiği / warning threshold
9
10void setup() {
11 Serial.begin(9600);
12 pinMode(LED_PIN, OUTPUT);
13}
14
15void loop() {
16 long sum = 0;
17 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 samples
18 sum += analogRead(BAT_PIN);
19 delay(2);
20 }
21 float raw = sum / 16.0;
22 float vPin = raw * VREF / 1023.0; // pindeki gerilim / voltage at the pin
23 float vBat = vPin * (R1 + R2) / R2; // pil gerilimi / battery voltage
24 int pct = (int)((vBat - V_EMPTY) / (V_FULL - V_EMPTY) * 100.0);
25 pct = constrain(pct, 0, 100); // 0-100 aralığında tut / keep within 0-100
26
27 Serial.print(F("Pil / Battery: "));
28 Serial.print(vBat, 2);
29 Serial.print(F(" V %"));
30 Serial.println(pct);
31
32 digitalWrite(LED_PIN, vBat < V_LOW ? HIGH : LOW); // pil zayıfsa LED yanar / LED on when battery is low
33 delay(1000);
34}Pour réduire le bruit, le code prend 16 mesures sur A0 et en calcule la moyenne. La valeur brute va de 0 à 1023 ; multipliée par la référence de 5 V et divisée par 1023, elle donne la tension sur la broche, puis multipliée par le rapport du pont (R1 + R2) / R2 = 2, elle donne la tension de la pile. Le calcul du pourcentage considère 6,4 V (3,2 V par cellule) comme vide et 8,4 V comme plein. La courbe de décharge du Li-ion n'étant pas linéaire, ce pourcentage n'est qu'une estimation approximative : la cellule passe l'essentiel de son temps entre 3,6 et 3,9 V, puis chute rapidement à la fin. Quand la tension descend sous 6,8 V, la LED intégrée s'allume pour te dire qu'il est temps de recharger. Comme la mesure prend pour référence la ligne 5 V de la carte, une tension de ligne basse comme 4,8 V sous alimentation USB peut décaler la lecture de quelques pour cent ; pour un résultat plus précis, remplace la constante VREF par la valeur réelle que tu mesures sur la broche 5V.
Mesure de pile avec ESP32 et Raspberry Pi Pico
Une seule cellule 18650 est la source d'alimentation la plus pratique pour l'ESP32 et le Pico. Sur l'ESP32, relie le point milieu du pont au GPIO 34 ; cette broche est sur un canal ADC1 et reste lisible même quand le Wi-Fi est actif (les broches ADC2 entrent en conflit avec le Wi-Fi). La fonction analogReadMilliVolts(), disponible dans les versions 2.x et 3.x du cœur Arduino, utilise l'étalonnage d'usine de la carte et renvoie directement des millivolts ; tu n'as donc pas à gérer la non-linéarité de l'ADC de l'ESP32. Sur le Pico, tu peux brancher la cellule directement sur la broche VSYS, car le convertisseur buck-boost de la carte transforme une entrée de 1,8–5,5 V en 3,3 V. Relie la sortie du pont à GP26 ; en MicroPython, read_u16() renvoie une valeur de 0 à 65535. Sur le Pico standard, VSYS/3 est déjà relié en interne à GP29 et se lit avec ADC(29) sans résistance externe ; sur le Pico W, cette broche est partagée avec la puce sans fil, donc un pont externe est plus sûr.
1const int BAT_PIN = 34; // bölücü orta noktası (ADC1) / divider midpoint (ADC1)
2const float DIVIDER = 2.0; // (R1 + R2) / R2, 100k + 100k
3const float V_EMPTY = 3.2; // boş hücre / empty cell
4const float V_FULL = 4.2; // dolu hücre / full cell
5
6void setup() {
7 Serial.begin(115200);
8 analogReadResolution(12); // 12 bit çözünürlük / 12-bit resolution
9}
10
11void loop() {
12 uint32_t sum = 0;
13 for (int i = 0; i < 16; i++) {
14 sum += analogReadMilliVolts(BAT_PIN); // kalibre mV / calibrated mV
15 delay(2);
16 }
17 float vBat = (sum / 16.0) / 1000.0 * DIVIDER; // pil gerilimi / battery voltage
18 int pct = (int)((vBat - V_EMPTY) / (V_FULL - V_EMPTY) * 100.0);
19 pct = constrain(pct, 0, 100);
20 Serial.printf("Pil / Battery: %.2f V %%%d\n", vBat, pct);
21 delay(2000);
22}1from machine import ADC
2import time
3
4adc = ADC(26) # GP26 = ADC0, bölücü orta noktası / divider midpoint
5DIVIDER = 2.0 # 100k + 100k bölücü / 100k + 100k divider
6V_EMPTY = 3.2 # boş hücre / empty cell
7V_FULL = 4.2 # dolu hücre / full cell
8
9while True:
10 total = 0
11 for _ in range(16): # 16 ölçümün ortalaması / average of 16 samples
12 total += adc.read_u16()
13 time.sleep_ms(2)
14 v_bat = total / 16 * 3.3 / 65535 * DIVIDER # pil gerilimi / battery voltage
15 pct = (v_bat - V_EMPTY) / (V_FULL - V_EMPTY) * 100
16 pct = max(0, min(100, pct)) # 0-100 aralığında tut / keep within 0-100
17 print("Pil / Battery: {:.2f} V %{:.0f}".format(v_bat, pct))
18 time.sleep(2)Idées de projets sur pile
- Voiture robot : alimente l'Arduino et le pilote de moteurs avec un pack 2S 18650 ; les détails sont dans l'article fabriquer une voiture robot.
- Testeur de piles : fabrique un appareil de mesure avec pont diviseur et LCD qui affiche le niveau des piles ; l'article voltmètre Arduino est un bon point de départ.
- Station de capteurs longue durée : un ESP32 sur une seule 18650 peut mesurer, passer en deep sleep et envoyer des données pendant des semaines.
- Lampe de poche ou veilleuse rechargeable : monte une lampe portable rechargeable par USB avec une 1S 18650, un module de charge TP4056 et quelques LED.
- Console de jeu portable Pico : un Pico alimenté sur VSYS par 3 × AA devient une console de poche avec un petit écran et quelques boutons.
- Alarme de pile faible : un petit circuit d'alerte qui fait sonner un buzzer quand la tension du pack passe sous le seuil est le moyen le moins cher de protéger tes piles rechargeables de la décharge profonde.
Erreurs courantes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| L'Arduino redémarre sans cesse | La pile 9 V ne peut pas fournir le courant du moteur ou du servo | Branche les moteurs sur un pack séparé, utilise un 2S 18650 ou 6 × AA, relie les GND |
| Le pack donne la moitié de la tension attendue | Le support est câblé en parallèle ou une pile est à l'envers | Vérifie le sens de chaque pile, mesure la sortie au multimètre |
| Une des piles chauffe ou fuit | Piles neuves et usées ou de types différents mélangées | Remplace toutes les piles du pack par des piles neuves du même type |
| Le régulateur de l'Uno chauffe beaucoup | Tension supérieure à 12 V sur VIN (ex. deux piles 9 V en série = 18 V) | Reste entre 7 et 12 V ou utilise un convertisseur buck externe |
| L'ESP32 s'éteint en se connectant au Wi-Fi | Pile faible ou fil trop fin ; la tension s'effondre lors de la pointe de 250 mA | Utilise un fil épais et une cellule pleine, ajoute un condensateur de 470 µF sur la ligne 3V3 |
| La mesure de pile fluctue | Pont à haute résistance et bruit électrique | Fais une moyenne, place un condensateur de 100 nF entre la broche ADC et GND |
| La pile chauffe quand l'USB est branché sur le Pico | Pas de protection entre la pile et VSYS, la tension USB pousse du courant dans la pile | Ajoute une diode Schottky entre la pile et VSYS |
En résumé : si tu as besoin de tension, branche les piles en série ; si tu as besoin d'autonomie et de courant, en parallèle ; si tu as besoin des deux, monte des packs série-parallèle comme le 2S2P, et utilise toujours des piles du même type et du même âge. Un 2S 18650 pour l'Arduino, une seule 18650 ou 3 × AA pour l'ESP32 et le Pico, voilà le choix le plus équilibré pour la plupart des projets. Pour en savoir plus sur les façons d'alimenter ta carte, jette un œil à l'article alimentation de l'Arduino. Dans l'application BlueGrays, tu trouveras de nombreux projets, des circuits LED à la voiture robot et aux projets ESP32 économes en énergie, avec schéma et code pas à pas, et tu pourras tester tout de suite ton nouveau pack de piles dans un projet.
Questions fréquentes
Que se passe-t-il quand on branche des piles en série ?
En série, les tensions des piles s'additionnent, tandis que la capacité reste celle d'une seule pile. Par exemple, quatre piles AA de 1,5 V et 2500 mAh en série donnent un pack de 6 V et 2500 mAh. Comme chaque pile débite le même courant, les piles doivent être du même type et au même niveau de charge.
La tension augmente-t-elle si on branche des piles en parallèle ?
Non, en parallèle la tension reste celle d'une seule pile. Ce qui augmente, c'est la capacité et le courant disponible : deux 18650 de 3,7 V et 3000 mAh en parallèle donnent 3,7 V et 6000 mAh. Avant de brancher des cellules Li-ion en parallèle, il faut égaliser leurs tensions.
Combien de temps un Arduino tient-il avec une pile 9 V ?
Une pile 9 V alcaline standard fait environ 500 mAh et peut alimenter un Arduino Uno, qui consomme 45–50 mA seul, pendant 6 à 8 heures au maximum. Avec des capteurs, des LED ou des moteurs, cette durée tombe à quelques heures. Pour les projets longue durée, un pack 2S 18650 ou 6 × AA donne de bien meilleurs résultats.
Peut-on utiliser ensemble une pile usée et une pile neuve ?
Non, il ne faut pas. En série, la pile usée, plus faible, se vide la première et est chargée à l'envers par les autres, ce qui provoque échauffement et fuite. Remplace toujours toutes les piles du pack en même temps, par des piles neuves de même marque et de même type.
Puis-je alimenter un Arduino avec 4 piles AA ?
Quatre piles AA alcalines donnent 6,4 V neuves, ce qui est trop pour la broche 5V et trop peu pour l'entrée VIN : ce n'est donc pas un bon choix. Quatre piles NiMH rechargeables donnent 4,8 V et peuvent se brancher sur la broche 5V. Si tu veux utiliser VIN ou le jack DC, préfère 6 × AA (9 V) ou un 2S 18650 (7,4 V).
Comment recharger des piles 18650 branchées en série ?
Un pack 2S de deux 18650 en série se recharge avec un chargeur 2S de 8,4 V et une carte de protection BMS qui équilibre les cellules. Les modules monocellule comme le TP4056 ne chargent que jusqu'à 4,2 V et ne conviennent donc pas à un pack 2S. Tu peux aussi sortir les cellules du support et les recharger une par une.
Projets à réaliser après cet article
Voir tous les projets
Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Feu de circulation
Une copie miniature du feu tricolore que tu vois chaque jour dans la rue. Le rouge reste allumé deux secondes, l'orange brille un court instant, le vert reste deux secondes, puis on revient au rouge…

Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
Le projet d'ouverture de la série Raspberry Pi Pico ! On fait clignoter la LED verte intégrée du Pico pour vérifier que la carte fonctionne : le classique premier essai façon "Hello World". Aucun composant externe, juste le Pico et un câble USB. Le code est écrit en MicroPython, le langage officiellement pris en charge par la Raspberry Pi Foundation.

Voltmètre numérique avec écran LCD
Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

Voiture contrôlée par Bluetooth avec L298N
Transforme ton téléphone en télécommande et pilote ta propre voiture robot. L'Arduino reçoit, via un module Bluetooth, les ordres d'une appli de télécommande sur ton téléphone et fait tourner les…

Robot évitant les obstacles
Que diriez-vous de construire un véhicule intelligent qui trouve son propre chemin ?

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

