Fundamentos · 12 min de leitura

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.

Pilha AA de 1,5 V
Pilha AA: o tipo alcalino fornece 1,5 V e o tipo recarregável NiMH fornece 1,2 V; a capacidade fica entre 2000 e 2800 mAh, dependendo da marca e da corrente consumida.

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ísticaSérieParaleloSérie-paralelo (2S2P)
LigaçãoPositivo ao negativo da pilha seguintePositivos juntos, negativos juntosDois grupos em série ligados em paralelo
TensãoSoma-se (n × V)Não muda (V)2 × V
Capacidade (mAh)Não muda (C)Soma-se (n × C)2 × C
Capacidade de correnteIgual à de uma única célulaMultiplicada por nDobra
Exemplo com 4 × AA (1,5 V, 2500 mAh)6 V, 2500 mAh1,5 V, 10,000 mAh3 V, 5000 mAh
Energia total15 Wh15 Wh15 Wh

Tipos de pilhas e baterias: comparação entre AA, 9 V e 18650

Pilha / bateriaTensão nominalTensão cheia / vaziaCapacidade típicaRecarregável?
AA alcalina1,5 V1,6 V / 0,9–1,0 V2000–2800 mAhNão
AA NiMH1,2 V1,4 V / 1,0 V1900–2500 mAhSim
9 V alcalina9 V9,5 V / cerca de 6 V400–550 mAhNão
9 V NiMH8,4 Vcerca de 9,8 V / 7 V170–300 mAhSim
18650 Li-ion3,6–3,7 V4,2 V / 2,5–3,0 V2000–3500 mAhSim (com um circuito de carga próprio)
Bateria 18650 Li-Ion de 3,7 V
Célula 18650 Li-ion: 18 mm de diâmetro e 65 mm de comprimento; 3,7 V nominal, 4,2 V com carga completa. Uma única célula é ideal para o ESP32 e o Pico, e duas células em série (2S) para o Arduino Uno.

Exemplos prontos: qual combinação dá quantos volts?

CombinaçãoTensãoCapacidadeOnde usar
2 × AA em série3 V (NiMH: 2,4 V)cerca de 2500 mAhCircuitos com LED, circuitos simples de 3 V
3 × AA em série4,5 Vcerca de 2500 mAhVSYS do Pico, pino 5V do Arduino (enfraquece à medida que as pilhas descarregam)
4 × AA NiMH em série4,8 Vcerca de 2000 mAhPino 5V do Arduino, servo motores
4 × AA alcalinas em série6 V (6,4 V quando novas)cerca de 2500 mAhServo e motores CC; não ligue direto no pino 5V do Uno
6 × AA em série9 Vcerca de 2500 mAhVIN ou conector DC do Arduino, alimentação dos motores do L298N
1 × 9 V9 Vcerca de 500 mAhTestes rápidos com Arduino, circuitos de baixa corrente
1S 186503,7 V (4,2 V cheia)2000–3500 mAhESP32 (via LDO), VSYS do Pico
2S 18650 em série7,4 V (8,4 V cheia)2000–3500 mAhVIN do Arduino Uno / Nano, carrinho robô
1S2P 186503,7 V4000–7000 mAhProjetos 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.
O módulo carregador TP4056 serve apenas para uma única célula Li-ion (1S, 4,2 V). Como a saída é limitada a 4,2 V, ele não consegue carregar duas 18650 em série, e ligar o módulo a apenas uma célula de um pacote em série deixa as células desbalanceadas. Carregue pacotes 2S com um carregador 2S de 8,4 V e um BMS. Colocar em curto uma célula Li-ion sem proteção pode causar incêndio.

Como escolher um suporte de pilhas?

Suporte para pilhas AA ligado em série
Os suportes para pilhas AA são ligados em série internamente: um suporte para 2 pilhas dá 3 V, um para 4 dá 6 V e um para 6 dá 9 V. O fio vermelho é o positivo e o preto é o negativo.
  • 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

PlacaEntrada de alimentaçãoFaixa aceitaPilha / bateria recomendada
Arduino Uno / NanoPino VIN ou conector DC (Uno)7–12 V recomendado2S 18650 (7,4 V) ou 6 × AA (9 V)
Arduino Uno / NanoPino 5V5 V regulado (no máximo 5,5 V)4 × AA NiMH (4,8 V) ou um pacote regulado
Placa de desenvolvimento ESP32Pino 5V / VIN5 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 ESP32Pino 3V33,0–3,6 V1S 18650 + regulador de 3,3 V de baixa queda (LDO)
Raspberry Pi PicoPino VSYS1,8–5,5 V1S 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çãoArduino Uno (2S 18650)ESP32 (1S 18650)Raspberry Pi Pico (1S 18650)
Positivo da bateria (+)Ponta de cima do R1 e VINPonta de cima do R1 e entrada do LDOPonta de cima do R1 e VSYS
Ponto médio entre R1 e R2A0GPIO 34GP26 (ADC0)
Ponta de baixo do R2GNDGNDGND
Negativo da bateria (−)GNDGNDGND
Valores dos resistoresR1 = R2 = 10 kΩR1 = R2 = 100 kΩR1 = R2 = 100 kΩ
Tensão máxima no pino4,2 V2,1 V2,1 V
Se a tensão da bateria for maior que a tensão de operação da placa, nunca a ligue diretamente a um pino analógico: aplicar 8,4 V no pino A0 do Uno ou 4,2 V em um GPIO do ESP32 danifica permanentemente o estágio de entrada. Além disso, o negativo da bateria e o GND da placa precisam ser comuns; sem GND comum, o valor medido não faz sentido.

Indicador de nível de bateria com Arduino

  1. 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.
  2. Ligue o fio positivo do suporte ao pino VIN do Uno (ou a um adaptador para conector DC) e o fio negativo ao GND.
  3. 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.
  4. Você vai usar o LED integrado da placa (pino 13) como aviso de bateria fraca; nenhuma peça extra é necessária.
  5. 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.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
MicroPython
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

SintomaCausa provávelSolução
O Arduino reinicia o tempo todoUma bateria de 9 V não consegue fornecer a corrente do motor ou do servoLigue os motores a um pacote separado, use 2S 18650 ou 6 × AA e una os GNDs
O pacote fornece metade da tensão esperadaO suporte está ligado em paralelo ou uma pilha está invertidaConfira a posição de cada pilha e meça a saída com um multímetro
Uma das pilhas esquenta ou vazaForam misturadas pilhas velhas e novas ou de tipos diferentesTroque todas as pilhas do pacote por novas do mesmo tipo
O regulador do Uno esquenta muitoMais 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-FiBateria fraca ou fio fino; a tensão despenca no pico de 250 mAUse fio grosso e uma célula carregada, adicione um capacitor de 470 µF na linha 3V3
A leitura da bateria oscilaDivisor de alta resistência e ruído elétricoFaç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 PicoNão há proteção entre a bateria e o VSYS; a tensão da USB empurra corrente para a bateriaAdicione um diodo Schottky entre a bateria e o VSYS
Sempre, antes de ligar um pacote de baterias ao circuito, meça a tensão e a polaridade com um multímetro. Essa verificação de cinco segundos detecta um pacote invertido que queimaria sua placa ou um suporte com ligação errada que fornece metade da tensão. Você encontra a medição de tensão CC passo a passo no post como usar o multímetro.

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.

Ver todos os projetos
LED piscante
AR-1Iniciante

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.

4.6(200)
1246
Semáforo
AR-3Iniciante

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…

4.8(137)
440
LED piscando com ESP32
ES-1Iniciante

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.

4.7(37)
108
Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
PI-1Iniciante

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.

5.0(1)
10
Voltímetro digital com display LCD
AR-56Intermediário
Premium

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ê.

4.5(27)
36
Carrinho controlado por Bluetooth com L298N
AR-80Avançado
Premium

Carrinho controlado por Bluetooth com L298N

Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

5.0(39)
66
Robô que desvia de obstáculos
AR-81Avançado
Premium

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.

5.0(38)
49
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

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.

4.3(10)
16