Como ligar pilhas em série e em paralelo: tensão e Arduino
Em série a tensão se soma, em paralelo a capacidade se soma. Veja exemplos com AA, 9 V e 18650, como escolher o suporte de pilhas e o pacote certo para Arduino, ESP32 e Pico.
Ligar pilhas em série significa conectar o positivo de uma ao negativo da seguinte, de modo que as tensões se somam: quatro pilhas AA de 1,5 V em série dão 6 V, mas a capacidade continua igual à de uma única célula. Em paralelo, todos os positivos são unidos entre si e todos os negativos também; a tensão não muda, mas a capacidade e a corrente que você pode puxar se somam. Quando você quer tirar seu projeto com Arduino, ESP32 ou Raspberry Pi Pico da tomada e torná-lo portátil, saber quantas pilhas de qual tipo usar e como ligá-las decide se o projeto vai funcionar por horas ou só por alguns minutos.
Neste post você vai ver, com fórmulas, como as ligações em série e em paralelo mudam a tensão e a capacidade. Passamos passo a passo por exemplos reais com pilhas AA, baterias de 9 V e células 18650, por que misturar pilhas diferentes é perigoso, como escolher o suporte de pilhas certo e como encontrar a combinação ideal para a sua placa. No final há um código pronto para usar que mede o nível da bateria com um divisor de tensão no Arduino, no ESP32 e no Pico.

O que é a ligação de pilhas em série e como funciona?
Na ligação em série, você enfileira as pilhas ponta a ponta, como uma corrente: o positivo da primeira vai ao negativo da segunda, o positivo da segunda ao negativo da terceira, e o primeiro negativo e o último positivo, que ficam livres, viram os terminais do pacote. Como a corrente passa por todas as pilhas, uma após a outra, todas as células conduzem a mesma corrente e as tensões se somam: V_total = V1 + V2 + … + Vn. A capacidade não se soma; quatro pilhas de 2500 mAh em série continuam formando um pacote de 2500 mAh, porque todas as células descarregam a mesma carga ao mesmo tempo. Por exemplo, quatro AA alcalinas dão 4 × 1,5 = 6 V, e duas células 18650 dão 2 × 3,7 = 7,4 V. Em eletrônica, o número de células em série é indicado pela letra “S”: 2S significa duas células em série, 3S significa três.
Ligação em paralelo: mesma tensão, mais capacidade
Na ligação em paralelo, todos os terminais positivos se encontram em um ponto e todos os negativos em outro. A tensão fica igual à de uma única pilha, mas a capacidade se soma: C_total = C1 + C2 + … + Cn. Como a corrente da carga é dividida entre as células, cada uma é menos exigida, o pacote dura mais e consegue fornecer correntes maiores com folga. O número de células em paralelo é indicado por “P”; 2S2P é um pacote de quatro células em que dois grupos em série são ligados em paralelo e, com 18650 de 2500 mAh, ele fornece 7,4 V e 5000 mAh. Para ver quanta energia um pacote realmente armazena, olhe os watts-hora: E (Wh) = V × Ah. Seja ligando quatro pilhas de 1,5 V e 2,5 Ah em série (6 V × 2,5 Ah) ou em paralelo (1,5 V × 10 Ah), a energia total é 15 Wh; a ligação não muda a energia, e sim a tensão e a corrente com que essa energia é entregue.
| Característica | Série | Paralelo | Série-paralelo (2S2P) |
|---|---|---|---|
| Ligação | Positivo ao negativo da pilha seguinte | Positivos juntos, negativos juntos | Dois grupos em série ligados em paralelo |
| Tensão | Soma-se (n × V) | Não muda (V) | 2 × V |
| Capacidade (mAh) | Não muda (C) | Soma-se (n × C) | 2 × C |
| Capacidade de corrente | Igual à de uma única célula | Multiplicada por n | Dobra |
| Exemplo com 4 × AA (1,5 V, 2500 mAh) | 6 V, 2500 mAh | 1,5 V, 10,000 mAh | 3 V, 5000 mAh |
| Energia total | 15 Wh | 15 Wh | 15 Wh |
Tipos de pilhas e baterias: comparação entre AA, 9 V e 18650
| Pilha / bateria | Tensão nominal | Tensão cheia / vazia | Capacidade típica | Recarregável? |
|---|---|---|---|---|
| AA alcalina | 1,5 V | 1,6 V / 0,9–1,0 V | 2000–2800 mAh | Não |
| AA NiMH | 1,2 V | 1,4 V / 1,0 V | 1900–2500 mAh | Sim |
| 9 V alcalina | 9 V | 9,5 V / cerca de 6 V | 400–550 mAh | Não |
| 9 V NiMH | 8,4 V | cerca de 9,8 V / 7 V | 170–300 mAh | Sim |
| 18650 Li-ion | 3,6–3,7 V | 4,2 V / 2,5–3,0 V | 2000–3500 mAh | Sim (com um circuito de carga próprio) |

Exemplos prontos: qual combinação dá quantos volts?
| Combinação | Tensão | Capacidade | Onde usar |
|---|---|---|---|
| 2 × AA em série | 3 V (NiMH: 2,4 V) | cerca de 2500 mAh | Circuitos com LED, circuitos simples de 3 V |
| 3 × AA em série | 4,5 V | cerca de 2500 mAh | VSYS do Pico, pino 5V do Arduino (enfraquece à medida que as pilhas descarregam) |
| 4 × AA NiMH em série | 4,8 V | cerca de 2000 mAh | Pino 5V do Arduino, servo motores |
| 4 × AA alcalinas em série | 6 V (6,4 V quando novas) | cerca de 2500 mAh | Servo e motores CC; não ligue direto no pino 5V do Uno |
| 6 × AA em série | 9 V | cerca de 2500 mAh | VIN ou conector DC do Arduino, alimentação dos motores do L298N |
| 1 × 9 V | 9 V | cerca de 500 mAh | Testes rápidos com Arduino, circuitos de baixa corrente |
| 1S 18650 | 3,7 V (4,2 V cheia) | 2000–3500 mAh | ESP32 (via LDO), VSYS do Pico |
| 2S 18650 em série | 7,4 V (8,4 V cheia) | 2000–3500 mAh | VIN do Arduino Uno / Nano, carrinho robô |
| 1S2P 18650 | 3,7 V | 4000–7000 mAh | Projetos com ESP32 e Pico de longa duração |
O risco de misturar pilhas diferentes
Em um pacote em série, todas as células conduzem a mesma corrente, então a mais fraca se esgota primeiro. As outras ainda estão cheias e continuam forçando corrente pela célula descarregada, que acaba sendo carregada ao contrário (inversão de célula). O resultado é aquecimento, liberação de gás e, nas pilhas alcalinas, um vazamento branco e corrosivo que destrói as molas do suporte e as trilhas de cobre da placa. Na ligação em paralelo o perigo é outro: a célula de tensão mais alta empurra corrente diretamente para a de tensão mais baixa. Como as pilhas têm resistência interna muito baixa (cerca de 20–50 mΩ em uma 18650), até uma diferença de 0,3 V entre duas células significa uma corrente descontrolada de vários ampères, que aquece as células. Por isso, misturar pilhas novas com velhas, alcalinas com NiMH ou de 2000 mAh com de 3000 mAh desperdiça capacidade e ainda cria um risco de segurança.
- Mesma química: Nunca coloque células alcalinas, NiMH e Li-ion no mesmo pacote; as tensões e as curvas de descarga delas são diferentes.
- Mesma marca, modelo e capacidade: Mantenha as resistências internas das células próximas; a célula de menor capacidade sempre se esgota antes.
- Mesma idade e nível de carga: Troque todas as pilhas do pacote juntas; substituir só uma por uma nova desequilibra o pacote.
- Iguale a tensão antes de ligar células Li-ion em paralelo: Mantenha a diferença entre as células abaixo de 0,05 V; meça com um multímetro e, se necessário, carregue as células separadamente.
- Use BMS em pacotes Li-ion em série: Pacotes 2S ou 3S devem ser usados com uma placa de proteção com balanceamento (BMS), que protege as células contra sobrecarga, descarga excessiva e curto-circuito.
- Fusível contra curto-circuito: Em pacotes capazes de fornecer correntes altas, um pequeno fusível ou polyfuse na linha positiva reduz bastante o risco de incêndio.
Como escolher um suporte de pilhas?

- O número de compartimentos define a tensão: Suportes prontos para AA e AAA quase sempre são ligados em série internamente; escolha a tensão que você precisa pelo número de compartimentos.
- Modelos com chave e tampa: Um suporte com chave liga-desliga permite cortar o circuito sem tirar as pilhas; um suporte com tampa impede que as pilhas saltem para fora em robôs em movimento.
- Confira a ligação dos suportes 18650: Alguns suportes duplos para 18650 são ligados em série (7,4 V) e outros em paralelo (3,7 V). Coloque as células e meça os fios de saída com um multímetro antes de ligar ao circuito.
- Capacidade de corrente: As molas e os fios finos dos suportes baratos causam uma queda de tensão perceptível com algumas centenas de miliampères. Para robôs com motores CC, escolha suportes com fios grossos e molas firmes.
- Clipe para bateria de 9 V: A bateria de 9 V se conecta à entrada de alimentação do Arduino com um clipe de encaixe e, opcionalmente, um adaptador para conector DC; se as pontas expostas do clipe se tocarem, a bateria entra em curto.
- Comprimento das células protegidas: Células 18650 com circuito de proteção podem chegar a 67–70 mm e talvez não caibam em suportes curtos; confira o comprimento que o seu suporte aceita antes de comprar.
A combinação certa para Arduino, ESP32 e Pico
| Placa | Entrada de alimentação | Faixa aceita | Pilha / bateria recomendada |
|---|---|---|---|
| Arduino Uno / Nano | Pino VIN ou conector DC (Uno) | 7–12 V recomendado | 2S 18650 (7,4 V) ou 6 × AA (9 V) |
| Arduino Uno / Nano | Pino 5V | 5 V regulado (no máximo 5,5 V) | 4 × AA NiMH (4,8 V) ou um pacote regulado |
| Placa de desenvolvimento ESP32 | Pino 5V / VIN | 5 V (vai para o regulador de 3,3 V da placa) | 1S 18650 + conversor elevador de 5 V ou 4 × AA NiMH |
| Placa de desenvolvimento ESP32 | Pino 3V3 | 3,0–3,6 V | 1S 18650 + regulador de 3,3 V de baixa queda (LDO) |
| Raspberry Pi Pico | Pino VSYS | 1,8–5,5 V | 1S 18650, 3 × AA alcalinas ou 3 × AA NiMH |
Você pode estimar quanto tempo uma bateria vai durar com esta fórmula: tempo (horas) = capacidade (mAh) / corrente média (mA) × 0,8. O fator 0,8 é uma margem para as perdas do regulador, a temperatura e o fato de a bateria não poder ser descarregada por completo. Um Arduino Uno sozinho consome cerca de 45–50 mA e chega a 60 mA com alguns sensores e LEDs. Com um pacote 2S 18650 de 2500 mAh, ele funciona por 2500 / 60 × 0,8 ≈ 33 horas. O mesmo circuito com uma bateria de 9 V de 500 mAh dura só 500 / 60 × 0,8 ≈ 6,5 horas e, como a tensão da bateria de 9 V cai rápido sob carga, o tempo real é ainda menor. Um ESP32 com Wi-Fi ligado consome 80–120 mA em média e até 250 mA em picos curtos; por isso, em projetos com ESP32, uma 18650 ou um pacote 1S2P, usado junto com o deep sleep, pode funcionar por dias ou até semanas. Se não quiser fazer a conta à mão, use a calculadora de autonomia da bateria.
Medindo a tensão da bateria: a ligação do divisor de tensão
O jeito mais fácil de saber quão cheia está uma bateria é medir a tensão dela. Mas os 8,4 V de um pacote 2S são mais do que os 5 V que uma entrada analógica do Arduino suporta, e os 4,2 V de uma célula 1S passam do limite de 3,3 V do ESP32 e do Pico. Por isso, você monta um divisor de tensão com dois resistores: V_saída = V_bat × R2 / (R1 + R2). Dois resistores iguais cortam a tensão exatamente pela metade; 8,4 V viram 4,2 V e 4,2 V viram 2,1 V. Como o divisor consome corrente continuamente, use resistores de 100 kΩ no ESP32 e no Pico para preservar a autonomia da bateria; no Uno, 10 kΩ bastam para uma leitura estável do ADC e consomem só 0,42 mA a 8,4 V. Você pode ajustar os valores para o seu pacote com a calculadora de divisor de tensão.
| Ligação | Arduino Uno (2S 18650) | ESP32 (1S 18650) | Raspberry Pi Pico (1S 18650) |
|---|---|---|---|
| Positivo da bateria (+) | Ponta de cima do R1 e VIN | Ponta de cima do R1 e entrada do LDO | Ponta de cima do R1 e VSYS |
| Ponto médio entre R1 e R2 | A0 | GPIO 34 | GP26 (ADC0) |
| Ponta de baixo do R2 | GND | GND | GND |
| Negativo da bateria (−) | GND | GND | GND |
| Valores dos resistores | R1 = R2 = 10 kΩ | R1 = R2 = 100 kΩ | R1 = R2 = 100 kΩ |
| Tensão máxima no pino | 4,2 V | 2,1 V | 2,1 V |
Indicador de nível de bateria com Arduino
- Coloque duas células 18650 no suporte duplo ligado em série e confirme com um multímetro que a saída está entre 7,4 e 8,4 V.
- Ligue o fio positivo do suporte ao pino VIN do Uno (ou a um adaptador para conector DC) e o fio negativo ao GND.
- Ligue dois resistores de 10 kΩ em série do positivo da bateria até o GND; leve o ponto em que os dois resistores se encontram até o A0.
- Você vai usar o LED integrado da placa (pino 13) como aviso de bateria fraca; nenhuma peça extra é necessária.
- Carregue o código, abra o Monitor Serial em 9600 baud e compare a tensão na tela com o valor que o multímetro mostra.
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}Para reduzir o ruído, o código faz 16 leituras do A0 e calcula a média. O valor bruto fica na faixa de 0–1023; ele é multiplicado pela referência de 5 V e dividido por 1023 para obter a tensão no pino e depois multiplicado pela razão do divisor (R1 + R2) / R2 = 2 para obter a tensão da bateria. O cálculo da porcentagem considera 6,4 V (3,2 V por célula) como vazio e 8,4 V como cheio. Como a curva de descarga do Li-ion não é linear, essa porcentagem é uma estimativa aproximada: a célula passa a maior parte do tempo entre 3,6 e 3,9 V e, no fim, cai rapidamente. Quando a tensão cai abaixo de 6,8 V, o LED integrado acende para avisar que é hora de carregar a bateria. Como a medição usa a linha de 5 V da placa como referência, uma linha baixa, como 4,8 V quando a placa é alimentada pela USB, pode deslocar a leitura em alguns por cento; para um resultado mais preciso, substitua a constante VREF pelo valor real que você medir no pino 5V.
Medição da bateria com ESP32 e Raspberry Pi Pico
Uma única célula 18650 é a fonte de alimentação mais prática para o ESP32 e o Pico. No ESP32, ligue o ponto médio do divisor ao GPIO 34; esse pino está em um canal do ADC1 e pode ser lido mesmo com o Wi-Fi ligado (os pinos do ADC2 entram em conflito com o Wi-Fi). A função analogReadMilliVolts(), disponível nas versões 2.x e 3.x do core do Arduino, retorna diretamente milivolts usando a calibração de fábrica da placa, então você não precisa lidar com o comportamento não linear do ADC do ESP32. No Pico, você pode ligar a célula direto ao pino VSYS, porque o conversor buck-boost da placa transforma uma entrada de 1,8–5,5 V em 3,3 V. Ligue a saída do divisor ao GP26; no MicroPython, read_u16() retorna um valor entre 0 e 65535. No Pico padrão, VSYS/3 já está ligado internamente ao GP29 e pode ser lido com ADC(29) sem resistor externo; no Pico W esse pino é compartilhado com o chip sem fio, então um divisor externo é mais seguro.
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)Ideias de projetos alimentados por bateria
- Carrinho robô: alimente o Arduino e o driver de motor com um pacote 2S 18650; os detalhes estão no post como fazer um carrinho robô.
- Testador de pilhas: monte um medidor com um divisor de tensão e um LCD que mostre quão cheias estão as pilhas; o post voltímetro com Arduino é um bom ponto de partida.
- Estação de sensores de longa duração: um ESP32 alimentado por uma única 18650 pode fazer uma medição, entrar em deep sleep e continuar enviando dados por semanas.
- Lanterna ou luz noturna recarregável: monte uma lâmpada portátil que carrega pela USB com uma 1S 18650, um módulo carregador TP4056 e alguns LEDs.
- Console de jogos portátil com Pico: um Pico alimentado pelo VSYS com 3 × AA vira um jogo de bolso com um pequeno display e alguns botões.
- Alarme de bateria fraca: um pequeno circuito de aviso que faz soar um buzzer quando a tensão do pacote cai abaixo de um limite é o jeito mais barato de proteger suas baterias recarregáveis contra descarga excessiva.
Erros comuns e como corrigi-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| O Arduino reinicia o tempo todo | Uma bateria de 9 V não consegue fornecer a corrente do motor ou do servo | Ligue os motores a um pacote separado, use 2S 18650 ou 6 × AA e una os GNDs |
| O pacote fornece metade da tensão esperada | O suporte está ligado em paralelo ou uma pilha está invertida | Confira a posição de cada pilha e meça a saída com um multímetro |
| Uma das pilhas esquenta ou vaza | Foram misturadas pilhas velhas e novas ou de tipos diferentes | Troque todas as pilhas do pacote por novas do mesmo tipo |
| O regulador do Uno esquenta muito | Mais de 12 V aplicados no VIN (ex.: duas de 9 V em série = 18 V) | Fique na faixa de 7–12 V ou use um conversor buck externo |
| O ESP32 desliga ao se conectar ao Wi-Fi | Bateria fraca ou fio fino; a tensão despenca no pico de 250 mA | Use fio grosso e uma célula carregada, adicione um capacitor de 470 µF na linha 3V3 |
| A leitura da bateria oscila | Divisor de alta resistência e ruído elétrico | Faça a média e coloque um capacitor de 100 nF entre o pino do ADC e o GND |
| A bateria esquenta com a USB ligada ao Pico | Não há proteção entre a bateria e o VSYS; a tensão da USB empurra corrente para a bateria | Adicione um diodo Schottky entre a bateria e o VSYS |
Resumindo: se você precisa de tensão, ligue as pilhas em série; se precisa de autonomia e corrente, ligue em paralelo; se precisa das duas coisas, monte pacotes série-paralelo como o 2S2P e use sempre pilhas do mesmo tipo e da mesma idade. Uma 2S 18650 para o Arduino e uma única 18650 ou 3 × AA para o ESP32 e o Pico é a escolha mais equilibrada para a maioria dos projetos. Para mais detalhes sobre as formas de alimentar sua placa, dê uma olhada no post alimentação do Arduino. No app BlueGrays você encontra muitos projetos, de circuitos com LED a carrinhos robô e projetos com ESP32 que economizam bateria, com esquema do circuito e código passo a passo, para testar seu novo pacote de baterias em um projeto na hora.
Perguntas frequentes
O que acontece quando você liga pilhas em série?
Na ligação em série, as tensões das pilhas se somam, enquanto a capacidade continua igual à de uma única pilha. Por exemplo, ligar quatro pilhas AA de 1,5 V e 2500 mAh em série resulta em um pacote de 6 V e 2500 mAh. Como todas as pilhas conduzem a mesma corrente, elas precisam ser do mesmo tipo e ter o mesmo nível de carga.
A tensão aumenta se as pilhas forem ligadas em paralelo?
Não, na ligação em paralelo a tensão continua igual à de uma única pilha. O que aumenta é a capacidade e a corrente que você pode puxar; duas 18650 de 3,7 V e 3000 mAh em paralelo dão 3,7 V e 6000 mAh. É preciso igualar as tensões das células Li-ion antes de ligá-las em paralelo.
Quanto tempo um Arduino funciona com uma bateria de 9 V?
Uma bateria alcalina de 9 V comum tem cerca de 500 mAh e consegue manter um Arduino Uno sozinho, consumindo 45–50 mA, por no máximo 6–8 horas. À medida que você adiciona sensores, LEDs ou motores, isso cai para algumas horas. Para projetos de longa duração, um pacote 2S 18650 ou 6 × AA dá resultados muito melhores.
Dá para usar pilhas velhas e novas juntas?
Não é recomendado. Na ligação em série, a pilha velha e fraca se esgota primeiro e é carregada ao contrário pelas outras, o que causa aquecimento e vazamento. Sempre troque todas as pilhas do pacote juntas, por novas da mesma marca e do mesmo tipo.
Posso alimentar um Arduino com 4 pilhas AA?
Quatro pilhas AA alcalinas fornecem 6,4 V quando novas, o que é demais para o pino 5V e pouco para a entrada VIN, então não é a escolha certa. Quatro pilhas recarregáveis NiMH fornecem 4,8 V, então podem ser ligadas ao pino 5V. Se você quiser usar o VIN ou o conector DC, escolha 6 × AA (9 V) ou uma 2S 18650 (7,4 V).
Como carregar baterias 18650 ligadas em série?
Um pacote 2S formado por duas 18650 em série é carregado com um carregador 2S de 8,4 V e uma placa de proteção BMS que balanceia as células. Módulos de célula única como o TP4056 carregam só até 4,2 V, então não servem para um pacote 2S. Como alternativa, você pode tirar as células do suporte e carregá-las uma por uma.
Projetos para montar depois desta leitura
Ver todos os projetos
LED piscante
O primeiro contato com a eletrônica: acender e apagar um único LED. O Arduino acende e apaga o LED em intervalos curtos, fazendo a luz piscar rapidamente.

Semáforo
Uma pequena versão do semáforo que você vê na rua todos os dias. O vermelho fica aceso por dois segundos, o amarelo acende por um instante, o verde fica aceso por dois segundos e depois volta ao…

LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
O primeiro projeto da série Raspberry Pi Pico! Fazemos o LED verde integrado piscar para verificar se a placa funciona — um primeiro experimento no estilo clássico "Hello World". SEM componentes externos, apenas o Pico e um cabo USB. O código foi escrito em MicroPython (a linguagem com suporte oficial da Raspberry Pi Foundation). Aprenda a usar a classe machine.Pin, o modo Pin.OUT, os métodos led.on()/off() e time.sleep() no Thonny IDE.

Voltímetro digital com display LCD
Descubra a tensão de uma pilha ou de um adaptador de alimentação com um medidor feito por você.

Carrinho controlado por Bluetooth com L298N
Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

Robô que desvia de obstáculos
Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

