Como alimentar o Arduino com bateria: 9V, AA, 18650 e pino Vin

Alimentar um Arduino com bateria é o primeiro passo para livrar o seu projeto do cabo USB do computador e transformá-lo em um carrinho robô, um sensor no jardim ou um aparelho que cabe no bolso. A resposta curta: a forma mais segura de rodar um Arduino Uno com bateria é ligar um pack de 7–12 V (6×AA ou duas células 18650 em série) ao conector DC ou ao pino Vin, ou então conectar um power bank à porta USB. O pino 5V só deve ser usado com uma fonte de 5 V limpa, que você mediu e ajustou, porque esse pino ignora completamente o regulador e as proteções da placa.

Uma alimentação ruim está por trás de muitos dos problemas misteriosos que os iniciantes enfrentam: a placa que reinicia sempre que o servo se move, a bateria 9V que acaba em poucas horas, o power bank que desliga depois de alguns segundos ou o regulador quente demais para tocar. Neste guia você vai conhecer todas as entradas que podem alimentar um Arduino, qual bateria vai em qual entrada, por que os motores precisam de uma fonte própria e como calcular o consumo de corrente e a autonomia. No final, também vamos ver o que muda ao alimentar um ESP32 e um Raspberry Pi Pico com bateria.

5 formas de alimentar um Arduino

Dentro de um Arduino Uno há dois caminhos de alimentação separados. Os 5 V que chegam pela USB passam por um fusível rearmável de 500 mA (polyfuse) e por uma pequena chave MOSFET e vão direto para o barramento de 5 V da placa. Já a tensão do conector DC passa primeiro por um diodo de proteção contra polaridade invertida, aparece nesse ponto no pino Vin e depois é reduzida a 5 V por um regulador LDO da família 1117. Os 3,3 V são gerados a partir desse barramento de 5 V por um segundo regulador, menor. Um comparador na placa monitora o Vin: quando o Vin passa de cerca de 6,6 V, ele desconecta automaticamente a alimentação USB, de modo que as fontes não brigam entre si mesmo com o adaptador e a USB ligados ao mesmo tempo.

Alimentação pela USB: o limite de 500 mA

A USB é a forma mais fácil e mais protegida de alimentar um Arduino. Uma porta USB 2.0 de computador fornece no máximo 500 mA; o polyfuse do Uno esquenta e corta o circuito quando a corrente total passa disso e religa sozinho depois que esfria. A própria placa consome cerca de 45–50 mA, o que deixa uns 400 mA para seus sensores, LEDs e módulos dividirem. Um carregador de celular ou um power bank pode usar a mesma porta USB; a única diferença é que, com cabos finos e longos, a tensão pode cair até 4,6 V. Enquanto a placa roda pela USB, cada miliampere que você puxa do pino 5V sai desse orçamento de 500 mA. Por isso, pendurar um servo ou uma fita de LED na alimentação USB faz o fusível desarmar, e a porta do computador também pode cortar a conexão para se proteger.

Conector DC e pino Vin: por que 7–12 V?

O regulador de 5 V da placa é um LDO linear e, para funcionar direito, precisa de cerca de 1–1,2 V a mais na entrada do que na saída. Some a isso a queda de 0,7–1 V do diodo de proteção do conector e você vai precisar de pelo menos 7 V no conector para ter 5 V firmes. Com uma fonte de 6 V, o barramento de 5 V cai para 4,2–4,5 V; a placa pode parecer funcionar, mas as leituras analógicas variam e os módulos se comportam de forma estranha. No limite superior, o problema é o calor: um regulador linear transforma a tensão excedente em calor. A potência dissipada é P = (Vin − 5 V) × I. Como regra, não faça o regulador dissipar mais de 1 W; nesse ponto o pequeno encapsulamento SOT-223 fica quente demais para tocar e acaba se desligando sozinho.

O pino Vin é ao mesmo tempo entrada e saída. Quando você alimenta a placa pelo conector, o Vin fica com a tensão do conector menos cerca de 0,7–1 V, então dá para alimentar por ele uma pequena carga de 9–12 V. Mas, como há um diodo de proteção de 1 A no caminho da corrente, cargas grandes como motores devem ser alimentadas direto da fonte, não pelo Vin. Quando você liga um suporte de pilhas ao pino Vin, esse diodo de proteção fica de fora: o regulador continua funcionando, mas, se você inverter o positivo e o negativo, nada protege a placa. Nos novos Uno R4 Minima e R4 WiFi, o conector e o Vin aceitam 6–24 V e usam um conversor chaveado (buck) no lugar do regulador linear, então não esquentam nem com 12 V. Para mais detalhes, veja Arduino Uno R4.

Pino 5V: quando é seguro pular o regulador?

O pino 5V está ligado direto à linha de alimentação do ATmega328P e dos outros chips da placa. Alimentar por esse pino pula o regulador, o diodo contra polaridade invertida e o fusível da USB. É por isso que a própria documentação do Arduino não recomenda alimentar pelos pinos 5V e 3.3V. Feito do jeito certo, porém, há vantagens: sem a queda de tensão e a perda de calor do regulador, a bateria dura mais e você pode fornecer mais corrente aos módulos. Só há uma condição: a fonte precisa ser regulada e medida. O ATmega328P foi projetado para trabalhar com até 5,5 V, e 6 V é o seu máximo absoluto; mesmo um instante acima disso pode danificar o chip de vez.

• Meça antes: confira a saída da fonte com um multímetro antes de ligá-la ao Arduino; ela deve ficar entre 4,8 e 5,2 V.
• Nada de pilhas direto: 4×AA alcalinas novas chegam a 6,4 V e passam do limite. Ligue ao pino 5V somente a saída de um regulador ou de um módulo buck ou boost.
• Cuidado com a USB ao mesmo tempo: se você conectar a USB enquanto alimenta pelo pino 5V, duas fontes de 5 V ficam interligadas pela placa; desligar a fonte externa enquanto carrega o código é a opção mais segura.
• Coloque um capacitor: um capacitor eletrolítico de 100–470 µF na linha externa de 5 V, perto da placa, suaviza as quedas durante picos repentinos de corrente (o que é um capacitor?).
• Opções prontas: módulos reguladores com 7805 (regulador de tensão 7805), um LM2596 ajustado em 5,0 V ou o módulo de alimentação MB102 para protoboard fornecem 5 V limpos.

Pino 3.3V: quanta corrente dá para puxar?

O pino 3.3V do Uno não é uma entrada de alimentação; é a saída de um pequeno regulador, e o limite oficial é de 50 mA. Isso basta para módulos que ficam em poucas dezenas de miliamperes, como um BME280, um MPU6050 ou um leitor RFID RC522. Módulos com picos de corrente altos, porém, passam do ponto: o nRF24L01+PA+LNA com antena ultrapassa 100 mA ao transmitir, o módulo Wi-Fi ESP-01 tem picos de várias centenas de miliamperes e o SIM800L pede rajadas de até 2 A. Para o nRF24L01+PA+LNA e o ESP-01, use um módulo regulador AMS1117 de 3,3 V separado, alimentado pelo barramento de 5 V. Já o SIM800L funciona com 3,4–4,4 V, e não com 3,3 V, e passa do limite de 1 A do AMS1117; alimente-o com uma única célula Li-ion ou com um módulo buck ajustado em 4,0 V que forneça pelo menos 2 A. No Arduino Nano e nos seus clones, o pino 3.3V muitas vezes é alimentado de dentro do chip USB-serial e é ainda mais fraco que no Uno, então um regulador separado também é a escolha mais segura. Você encontra mais sobre a alimentação de módulos sem fio no guia do nRF24L01.

Opções de bateria: 9V, AA, 18650 e power bank

A clássica bateria 9V é a opção mais recomendada, graças ao clipe com plugue que encaixa direto no conector, mas também é a menos eficiente. Ela tem seis células pequenas por dentro, então sua capacidade fica em torno de apenas 400–600 mAh e sua resistência interna é alta; some um servo ou alguns LEDs aos 50 mA do Uno e a tensão logo cai abaixo de 7 V e a placa começa a reiniciar. Em uma placa com regulador linear, a capacidade em mAh da bateria define diretamente a autonomia, e os volts a mais só viram calor. Por isso, um suporte de 6×AA, que dá os mesmos 9 V, dura cerca de quatro vezes mais que uma bateria 9V. Explicamos as unidades de capacidade em detalhes em O que significa mAh?.

As pilhas AA são baratas e encontradas em qualquer lugar, mas é preciso escolher o número certo de células. O erro mais comum é usar 4×AA: 6 V não bastam para o conector, porque depois das quedas do diodo e do regulador só cerca de 4,2 V chegam ao barramento de 5 V, enquanto ligar o mesmo pack ao pino 5V significa 6,4 V com pilhas novas, o que passa do limite. As combinações certas são um pack de 6×AA (9 V) no conector DC e um pack de 3×AA (4,5 V) direto no pino 5V. Um Uno rodando a 16 MHz com 3×AA começa a ficar instável quando cada pilha cai abaixo de 1,25 V, então você não aproveita a capacidade inteira. As pilhas recarregáveis NiMH dão 1,2 V cada, por isso 4×NiMH (4,8 V) também é uma escolha popular para o pino 5V, mas células recém-carregadas podem passar de 5,5 V nos primeiros minutos.

Células Li-ion 18650 e conversores boost

A 18650 é uma célula recarregável de íons de lítio com 18 mm de diâmetro e 65 mm de comprimento, usada em baterias de notebook e em power banks. Sua tensão nominal é de 3,7 V; ela mede 4,2 V quando cheia e cerca de 3,0 V quando vazia. A capacidade real fica entre 2000 e 3500 mAh; células com 6800 ou 9900 mAh no rótulo são quase sempre falsificadas. Uma única 18650 pode ser usada com um Arduino de duas formas: elevando 3,7 V para 5 V com um conversor boost (por exemplo, um módulo MT3608 ou uma placa de power bank para 18650 pronta) e alimentando a USB ou o pino 5V, ou ligando duas células em série e conectando o pack 2S (7,4 V) ao conector DC. A segunda é a opção mais equilibrada para o Uno: começando em 8,4 V, a tensão fica na faixa confortável do regulador até cair para 3,5 V por célula (7 V no total). Ao usar um conversor boost, lembre-se de que a corrente puxada da bateria é maior que a da saída: um circuito que precisa de 200 mA em 5 V puxa cerca de 307 mA de uma célula de 3,7 V com 88% de eficiência.

• Proteção é obrigatória: descarregar uma célula Li-ion abaixo de 3,0 V encurta sua vida útil e pode ser perigoso. Use células protegidas ou uma placa de proteção (BMS).
• O TP4056 é para uma célula: o módulo TP4056 carrega apenas uma célula (1S) até 4,2 V. Nunca carregue um pack 2S em série com um TP4056; use um circuito de carga com BMS 2S ou um carregador com balanceamento. Os detalhes de ligação estão em módulo carregador TP4056.
• Cuidado com curto-circuito: uma 18650 pode fornecer dezenas de amperes em curto; não deixe fios desencapados e coloque um fusível e uma chave na linha da bateria.
• Ajuste do boost: não ligue módulos ajustáveis como o MT3608 ao Arduino antes de ajustar a saída em 5,0 V.
• Não misture células: em um pack em série, use células da mesma marca, com a mesma capacidade e o mesmo nível de carga.

Por que o meu power bank desliga sozinho?

Um power bank é um pack pronto com células de lítio, circuito de carga, proteção e boost de 5 V por dentro, então é o jeito mais fácil de rodar um Arduino com bateria: basta conectar o cabo USB. Só que a maioria dos power banks monitora a corrente de saída para poder desligar quando o celular termina de carregar, e corta a saída em 10–60 segundos quando a corrente cai abaixo de 50–100 mA. Um Nano puxando 20 mA ou um Uno puxando 50 mA fica abaixo desse limite, então a placa funciona por um tempo e depois desliga em silêncio. Há duas saídas: escolher um power bank com modo de baixa corrente (em alguns modelos ele é ativado apertando o botão duas vezes) ou fazer o Arduino puxar uma carga curta em intervalos regulares. Para o segundo método, ligue um resistor de 47 Ω, 1 W do barramento de 5 V ao coletor de um transistor NPN (BC337 ou 2N2222), o emissor ao GND e a base ao pino D7 por um resistor de 1 kΩ. Quando o transistor conduz, o resistor puxa cerca de 5 V / 47 Ω ≈ 106 mA e o power bank enxerga uma carga. Você mesmo pode conferir os valores com a calculadora da lei de 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}

Como o código usa millis() em vez de delay(), ele não trava o resto do projeto; explicamos essa abordagem em detalhes em millis() vs delay(). Puxar 106 mA durante 300 ms a cada 8 segundos acrescenta só cerca de 4 mA na média. Se o seu power bank ainda desligar, reduza o período para 5 segundos ou aumente o pulso para 500 ms; cada modelo usa um limite e um tempo de espera diferentes.

Alimentação separada para motores e servos, GND comum

Motores e servos são as cargas que mais dão problema quando você alimenta um Arduino com bateria. Um servo puxa um pico de corrente de várias centenas de miliamperes no instante em que começa a se mover, e motores CC puxam várias vezes a corrente normal na partida ou quando travam. Esse pico pode derrubar o barramento de 5 V por um instante; se a tensão cair o bastante, a detecção de subtensão (brown-out) do ATmega328P entra em ação e a placa reinicia sozinha. Além disso, o ruído das escovas dos motores atrapalha as leituras dos sensores. A regra é simples: alimente no máximo um servo pequeno pelo pino 5V do Arduino e rode todos os outros motores com uma fonte separada. Para entender como funcionam servos e motores CC, veja servo motor e controle de motor CC com L298N.

1. Escolha uma fonte separada para os motores: 5–6 V para servos (4×AA NiMH ou um LM2596 ajustado em 5–6 V) e, para motores CC, um pack compatível com a tensão do motor (por exemplo, 2S 18650).
2. Ligue o positivo da fonte só aos fios vermelhos dos servos ou à entrada de alimentação do driver de motor; não ligue ao pino 5V do Arduino.
3. Alimente o Arduino pela entrada dele: você também pode ligar o mesmo pack 2S ao conector DC, desde que a corrente dos motores não passe pelo regulador do Arduino.
4. Ligue o negativo (GND) da fonte ao pino GND do Arduino. Sem um GND comum, o sinal de controle não funciona.
5. Ligue o fio de sinal laranja ou amarelo do servo a um dos pinos digitais do Arduino (por exemplo, D9); a biblioteca Servo também funciona em pinos sem a marca PWM.
6. Coloque um capacitor eletrolítico de 470–1000 µF na alimentação dos servos, perto deles; atenção à polaridade.
7. Se estiver usando um L298N, ligue a alimentação dos motores ao borne de 12V; se a fonte passar de 12 V, tire o jumper 5V-EN e alimente o Arduino com uma fonte própria.

Como calcular a corrente e a autonomia?

A pergunta de verdade em um projeto a bateria é “quanto tempo vai durar?”. A fórmula básica é simples: Autonomia (horas) = Capacidade da bateria (mAh) × 0,85 / Corrente média (mA). O fator 0,85 leva em conta que uma bateria nunca entrega toda a capacidade nominal: a capacidade cai com correntes altas e no frio, o circuito para antes de a bateria esgotar por completo e os conversores acrescentam perdas. Para baterias cuja tensão cai cedo, como a 9V, usar 0,7 é mais realista. Se o seu projeto passa a maior parte do tempo dormindo, calcule primeiro a corrente média: Corrente média = (Corrente ativa × tempo ativo + Corrente em sono × tempo em sono) / tempo total. Em vez de fazer a conta à mão, você pode usar a calculadora de duração da bateria; informe a capacidade, as correntes acordado e em sono e o intervalo entre despertares, e ela mostra a autonomia em horas, dias ou meses.

Medir sempre é melhor que chutar. Coloque o multímetro na escala de corrente (mA) e ligue-o em série entre a bateria e o circuito para ver o consumo real; mostramos como em como usar um multímetro. Se a leitura for maior do que você esperava, olhe primeiro o consumo da própria placa: no Uno, o chip USB-serial (ATmega16U2), o LED de alimentação e o regulador puxam mais de 30 mA mesmo com o ATmega328P dormindo. Por isso, projetos que precisam de muita autonomia preferem placas sem chip USB, como o Arduino Pro Mini; um Pro Mini sem o LED de alimentação e sem o regulador chega a microamperes no modo sleep.

Passo a passo: coloque o seu projeto para rodar com bateria

1. Com o projeto rodando pela USB, meça a corrente média e a de pico com um multímetro; meça também enquanto o servo ou o motor está se movendo.
2. Separe as cargas de corrente alta, como motores, servos e fitas de LED, e planeje uma fonte separada para elas.
3. Escolha a entrada da placa: no Uno, um pack de 7–12 V no conector DC ou 5 V regulados na USB ou no pino 5V; no Pico, 1,8–5,5 V no VSYS.
4. Calcule a capacidade necessária para a autonomia que você quer ou use a calculadora de duração da bateria.
5. Coloque uma chave liga/desliga na linha positiva da bateria; confira se os packs Li-ion têm placa de proteção (BMS).
6. Carregue o código pela USB, depois desconecte a USB e teste com a bateria; confira com o multímetro a tensão no pino 5V enquanto o servo se move.
7. Monitore a tensão da bateria pelo código e dê um aviso quando ela cair abaixo de um valor definido (código abaixo).

Medindo a tensão da bateria com o Arduino

Em vez de adivinhar quando a bateria vai acabar, você pode medir a tensão dela. As entradas analógicas do Arduino leem no máximo 5 V, então não dá para ligar um pack 2S, que chega a 8,4 V, direto no A0; você precisa de um divisor de tensão. Dois resistores de 100 kΩ e 10 kΩ dividem a tensão por 11: 8,4 V viram cerca de 0,76 V no A0. Como o barramento de 5 V da placa pode variar à medida que a bateria enfraquece, é mais preciso medir em relação à referência interna de 1,1 V, que não depende da tensão de alimentação. Você pode escolher os valores dos resistores para o seu pack com a calculadora de divisor de tensão e ler mais em divisor de tensão.

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}

Ligue a ponta de cima do divisor ao positivo da bateria depois da chave liga/desliga, para que o divisor não descarregue a bateria com o aparelho desligado. A referência interna de 1,1 V pode variar cerca de ±10% de um chip para outro: compare a tensão da bateria medida com o multímetro com a do Monitor Serial e corrija o VREF (por exemplo, para 1.08). O divisor puxa cerca de 76 µA o tempo todo, o que praticamente não afeta a autonomia. O código é para o Uno e o Nano; no Mega, a referência se chama INTERNAL1V1. O limite de 6,6 V corresponde a 3,3 V por célula; nesse ponto as células estão quase vazias, e descer abaixo de 3,0 V por célula as danifica. Se o pack alimenta o conector DC, o barramento de 5 V começa a cair por volta de 7 V, então definir LOW_V como 7.0 também faz sentido.

Alimentando um ESP32 com bateria

As placas de desenvolvimento ESP32 trabalham com 3,3 V e podem ser alimentadas de três formas: pela porta USB, pelo pino 5V (VIN em algumas placas) ou direto pelo pino 3V3. A Espressif deixa claro que essas opções não devem ser usadas ao mesmo tempo e que só uma deve ser escolhida. A tensão aplicada ao pino 5V passa pelo regulador LDO de 3,3 V da placa (um AMS1117 na maioria dos clones), enquanto o pino 3V3 só aceita 3,0–3,6 V regulados. Ao transmitir por Wi-Fi, o ESP32 tem picos de até 240 mA, então precisa de uma fonte que forneça pelo menos 500 mA; caso contrário, reinicia com o erro “Brownout detector was triggered” (detalhes em brownout no ESP32). Não ligue uma 18650 sozinha direto no pino 3V3: com 4,2 V quando cheia, ela passa do limite. O pino 5V também não é uma boa opção, porque o AMS1117 precisa de uma queda de cerca de 1,1 V, então, conforme a tensão da célula cai, a saída fica abaixo de 3,3 V. As opções certas são uma 18650 com boost de 5 V no pino 5V, um regulador de 3,3 V de baixa queda (LDO) que forneça pelo menos 500 mA ou uma placa ESP32 com carregador Li-ion embutido. O que realmente define a autonomia, porém, é o ESP32 passar a maior parte do tempo em deep sleep (sono profundo); o chip consome cerca de 10 µA nesse modo, mas o chip USB-serial, o LED e o regulador das placas de desenvolvimento podem levar esse valor à casa dos miliamperes. É daí que vem a diferença entre 3 meses e 18 dias na tabela acima; para mais detalhes, veja deep sleep do ESP32.

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}

A cada despertar, o código mede a tensão da bateria, faz o seu trabalho e volta a dormir com um timer de 60 segundos; como o ESP32 reinicia o programa do começo ao acordar do deep sleep, o loop() nunca é executado. O GPIO 34 é um pino ADC1 somente de entrada e funciona com o Wi-Fi ligado, enquanto os pinos ADC2 não podem ser usados junto com o Wi-Fi. A analogReadMilliVolts() usa a calibração de fábrica do chip para devolver milivolts diretamente. O divisor de 100 kΩ + 100 kΩ reduz 4,2 V para 2,1 V e puxa apenas 21 µA; se a leitura estiver ruidosa, coloque um capacitor de 100 nF entre o GPIO 34 e o GND. Para os seus primeiros passos com o ESP32, O que é o ESP32? é um bom ponto de partida.

Alimentando um Raspberry Pi Pico com bateria

O Raspberry Pi Pico é uma das placas mais fáceis de rodar com bateria, porque, em vez de um regulador linear, ele tem um regulador chaveado buck-boost. Aplique ao pino VSYS qualquer tensão entre 1,8 e 5,5 V e a placa a converte com eficiência para 3,3 V; ela continua funcionando mesmo quando a entrada cai abaixo de 3,3 V. Isso significa que 2 ou 3 pilhas AA, uma única 18650 ou uma LiPo de uma célula podem ser ligadas direto entre VSYS e GND, sem nenhum módulo extra. O único cuidado é o uso junto com a USB: os 5 V da USB (VBUS) chegam ao VSYS por um diodo Schottky, então, se a bateria estiver ligada direto ao VSYS e você conectar a USB, a USB tenta empurrar corrente para dentro da bateria. A solução recomendada pela Raspberry Pi é ligar a bateria ao VSYS por um diodo Schottky próprio (por exemplo, um 1N5817). O pino 3V3 fornece no máximo cerca de 300 mA para circuitos externos, e levar o pino 3V3_EN ao GND desliga o regulador e, portanto, a placa inteira. Para uma visão geral da placa, veja O que é o 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)

No Pico, o GP29 mede um terço do VSYS por um divisor na própria placa, enquanto o GP24 lê 1 quando a USB está conectada. Assim, sem nenhuma peça extra, você descobre tanto a tensão da bateria quanto se a placa está rodando pela USB ou pela bateria. Se você ligou a bateria por um diodo Schottky, como recomendado, o VSYS mostra cerca de 0,2–0,3 V a menos que a tensão da bateria. A leitura supõe que a referência do ADC é de 3,3 V; graças ao regulador buck-boost, essa referência fica estável mesmo quando a bateria enfraquece. No Pico W, o GP29 e o GP24 são compartilhados com o chip sem fio, então este código não funciona como está; lá, o estado da USB é lido com Pin("WL_GPIO2"). Para aumentar a autonomia, use machine.lightsleep() em vez de time.sleep() entre as leituras.

Ideias de projetos com bateria

• Carrinho robô controlado por Bluetooth: alimente os motores e o Arduino com um pack 2S de 18650; detalhes em como fazer um carrinho robô.
• Robô que desvia de obstáculos: evite reinicializações alimentando os motores pelo L298N em uma linha separada e o Arduino pelo conector DC (robô que desvia de obstáculos).
• Voltímetro com indicador de bateria: mostre em um LCD o valor medido com um divisor de tensão (como fazer um voltímetro com Arduino).
• Estação de umidade para o jardim: mantenha um ESP32 em deep sleep, meça a umidade do solo uma vez por hora e faça-o funcionar por meses com uma única 18650.
• Registrador GPS portátil: grave o percurso da sua trilha com um GPS NEO-6M e um power bank.
• Luz noturna com Pico a pilha: um Pico alimentado por 3×AA pelo VSYS acende LEDs quando o ambiente escurece.

Erros comuns e como resolvê-los

Uma boa alimentação é metade do que faz um projeto funcionar com estabilidade: escolha a entrada certa, alimente os motores separadamente, una os terras e calcule a autonomia desde o início. Quando estiver pronto para montar um projeto a bateria, confira no app BlueGrays o carrinho controlado por Bluetooth com L298N, o robô que desvia de obstáculos, a estação de irrigação inteligente, o voltímetro digital com LCD e os projetos de economia de bateria com deep sleep do ESP32; cada um mostra o esquema do circuito, as ligações e o código passo a passo.