Divisor de tensão: fórmula, escolha dos resistores e exemplos com Arduino

Um divisor de tensão é o circuito mais simples para transformar uma tensão em outra menor e previsível usando dois resistores em série. A tensão de saída é dada por Vout = Vin × R2 / (R1 + R2): R1 vai ligado à fonte, R2 vai ligado ao terra (GND) e a saída é tirada do ponto médio, onde os dois se encontram. Por exemplo, dois resistores de 10 kΩ dividem 12 V exatamente ao meio, em 6 V. Esses dois resistores estão no coração de inúmeros circuitos: medir uma bateria de 12 V com um Arduino, baixar um sinal de sensor de 5 V para os pinos de 3,3 V de um ESP32 e ler sensores como LDRs e termistores NTC.

Neste guia, você vai ver, com números reais, de onde vem a fórmula, como escolher os valores dos resistores e por que a saída cai quando você liga algo ao divisor (o efeito de carga). Depois, vamos montar passo a passo códigos que medem a tensão de uma bateria com Arduino Uno, ESP32 e Raspberry Pi Pico, escolher os pares de resistores certos para converter 5 V em 3,3 V e ler um LDR e um NTC com um divisor. Por fim, vamos explicar por que um divisor de tensão nunca deve ser usado no lugar de uma fonte de alimentação.

O que é um divisor de tensão e como ele funciona?

A fórmula do divisor de tensão sai direto da lei de Ohm. A mesma corrente passa por R1 e R2, que estão ligados em série entre a fonte e o terra: I = Vin / (R1 + R2). A tensão sobre R2, que é a saída, é essa corrente multiplicada por R2: Vout = I × R2 = Vin × R2 / (R1 + R2). Resumindo, a tensão da fonte se divide entre os resistores na proporção dos seus valores; o resistor maior fica com a parte maior. A saída é sempre menor que a entrada, porque a razão R2 / (R1 + R2) é menor que 1. Você encontra mais detalhes sobre como a tensão se divide em circuitos em série em Resistores em série e em paralelo.

Você também pode fazer o caminho inverso: se quer baixar 12 V para 3,3 V e escolheu 10 kΩ para R2, chega a R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ. Esse valor não é vendido, então você escolhe o próximo valor padrão acima, 27 kΩ, e a saída passa a ser 12 × 10 / 37 ≈ 3,24 V. Arredondar R1 para cima baixa um pouco a saída, o que é o lado seguro para o pino. Um potenciômetro também é, na verdade, um divisor de tensão ajustável: o cursor divide a pista resistiva em R1 e R2. Se preferir não fazer as contas à mão, a calculadora de divisor de tensão dá a saída na hora a partir da tensão de entrada e dos resistores. Na eletrônica, você vai ver divisores de tensão fazendo principalmente estes trabalhos:

• Medir tensões mais altas: trazer fontes como uma bateria de 12 V ou um pack de lítio de 7,4 V para a faixa que uma entrada analógica consegue medir.
• Reduzir o nível de sinal: tornar um sinal de 5 V seguro para as entradas de 3,3 V de um ESP32 ou Raspberry Pi Pico.
• Ler sensores resistivos: transformar em tensão a variação de resistência de componentes como LDRs, NTCs, sensores flex e sensores de força (FSR).
• Ler vários botões em um só pino: uma escada de resistores dá a cada botão uma tensão diferente, então cinco botões podem compartilhar um único pino analógico.
• Realimentação de reguladores: reguladores como o LM317 e o LM2596 ajustável mantêm a saída estável medindo-a por um divisor; no LM317, Vout = 1,25 × (1 + R2 / R1).
• Criar uma tensão de referência: gerar metade da tensão de alimentação como referência em circuitos com amp-op.

Como escolher os valores dos resistores

A fórmula só se importa com a razão: 1 kΩ + 1 kΩ e 100 kΩ + 100 kΩ dividem na mesma proporção, exatamente ao meio. Na prática, porém, os valores absolutos também importam. Resistores pequenos deixam passar muita corrente pelo divisor; essa corrente é energia desperdiçada e, em projetos alimentados por bateria, drena a bateria à toa. Resistores grandes consomem pouquíssima corrente, mas a saída deles é fraca: uma carga ligada ou o capacitor de amostragem dentro da entrada analógica perturba facilmente a tensão de saída, e o ruído captado pelos fios entra com mais facilidade. A escolha certa é um equilíbrio entre esses dois extremos:

1. Descubra a maior tensão de entrada. Uma bateria de chumbo-ácido de 12 V pode chegar a 14,4 V durante a carga; considere o pior caso da tensão que você vai medir e acrescente uma margem de 10%.
2. Descubra a maior tensão que o pino aceita. 5 V no Arduino Uno, 3,3 V no ESP32 e no Pico; como alvos seguros, escolha cerca de 4,5 V no Uno, 2,5 V no ESP32 e 3,0 V no Pico.
3. Calcule a razão: k = saída desejada / maior entrada. Por exemplo, 4,5 / 14,4 ≈ 0,31.
4. Escolha R2 (10 kΩ é um bom ponto de partida na maioria dos casos) e encontre R1 com R1 = R2 × (1 / k − 1). Arredonde o resultado para cima, para o próximo dos valores padrão de resistores.
5. Confira a corrente e a potência: I = Vin / (R1 + R2) e P = Vin² / (R1 + R2). Em projetos com bateria, tente manter a corrente na faixa dos microampères.
6. Confira a resistência de saída: R1 × R2 / (R1 + R2) deve ficar abaixo de 10 kΩ no Arduino Uno; se não ficar, acrescente um capacitor de 100 nF entre o pino analógico e o GND.
7. Coloque a razão real no código: recalcule a razão com os valores padrão que você escolheu e, depois de montar o circuito, meça com um multímetro e calibre.

Efeito de carga: o que acontece quando você liga algo ao divisor?

A fórmula supõe que nenhuma corrente é tirada da saída. Assim que você liga uma carga, ela fica em paralelo com R2, a resistência equivalente do ramo inferior diminui e a tensão de saída cai. O jeito fácil de calcular isso é tratar o divisor como o seu equivalente de Thévenin: uma fonte com a tensão que você mede sem carga (Vth) e uma resistência interna Rth = R1 × R2 / (R1 + R2). Com uma carga RL, a saída passa a ser Vth × RL / (Rth + RL). A tabela abaixo mostra uma fonte de 10 V dividida por 10 kΩ + 10 kΩ (Vth = 5 V, Rth = 5 kΩ) com diferentes cargas na saída:

A regra prática: se a resistência da carga for pelo menos 100 vezes a resistência de saída do divisor (Rth), o erro fica abaixo de 1%. Se a carga for menor, diminua os resistores ou coloque um seguidor de tensão com amp-op (buffer) no meio. A entrada analógica de um microcontrolador tem, por si só, uma resistência muito alta, mas dentro dela há um pequeno capacitor de amostragem que é carregado a cada conversão (cerca de 14 pF no ATmega328P). Por isso o datasheet recomenda uma resistência de saída da fonte de cerca de 10 kΩ ou menos. Se você usar um divisor de valores mais altos, acrescente um capacitor de 100 nF entre o pino analógico e o GND: ele mantém pronta a carga necessária no momento da amostragem. E, se você lê vários pinos analógicos em sequência, descartar a primeira leitura de cada pino elimina o erro que sobra da troca de canal.

Por que um divisor de tensão não pode ser usado como fonte de alimentação

A armadilha mais comum de quem está começando é tirar 5 V de uma fonte de 12 V com dois resistores e tentar alimentar um Arduino ou um módulo com isso. No papel, um divisor de 7 kΩ e 5 kΩ dá exatamente 5 V a partir de 12 V, mas só enquanto nenhuma corrente é tirada da saída. Uma placa que consome 50 mA se comporta como uma carga de cerca de 100 Ω; em paralelo com o R2 de 5 kΩ, o ramo inferior cai para 98 Ω e a saída despenca para 0,17 V. Se você reduzir os resistores para 70 Ω e 50 Ω, o circuito passa a consumir 100 mA e transforma 1,2 W em calor mesmo sem nada ligado; com a carga conectada, a saída ainda cai para 3,9 V, e toda vez que a corrente da placa muda (Wi-Fi, um servo, um relé) a tensão muda junto. Além disso, quando a carga é retirada, a tensão volta a subir e pode danificar componentes sensíveis.

Medindo a tensão de uma bateria de 12 V e de células com Arduino

As entradas analógicas do Arduino Uno leem no máximo 5 V; ligar uma bateria de 12 V diretamente destruiria o pino. A solução é um divisor de 22 kΩ (R1) e 10 kΩ (R2): com razão de 0,3125, uma tensão de carga de 14,4 V chega ao pino como 4,5 V, e o circuito consegue medir até 16 V. Com 12 V, o divisor consome só 0,375 mA, e a sua resistência de saída de 6,9 kΩ fica abaixo do limite recomendado de 10 kΩ. O ADC de 10 bits resolve cerca de 4,9 mV por passo; com o divisor, isso dá uma resolução de cerca de 15,6 mV na entrada. Como o ESP32 e o Pico trabalham com 3,3 V, usamos um R1 maior (56 kΩ) nessas placas:

1// 12 V akü gerilimini gerilim bölücüyle ölçme / Measuring a 12 V battery with a voltage divider
2// Kaynak + -> 22k (R1) -> A0 -> 10k (R2) -> GND / Source + -> 22k (R1) -> A0 -> 10k (R2) -> GND
3// Kaynağın eksisi Arduino GND'sine bağlı / Source minus is tied to the Arduino GND
4const int VIN_PIN = A0;
5const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 22000.0;    // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 10000.0;    // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;     // kalibrasyon: gerçek / okunan / calibration: real / measured
9const float LOW_V = 11.8;    // düşük akü eşiği (V) / low battery threshold (V)
10
11float readInputVoltage() {
12  analogRead(VIN_PIN);                        // ilk okumayı at / discard the first reading
13  long sum = 0;
14  for (int i = 0; i < 16; i++) {              // 16 ölçümün ortalaması / average of 16 readings
15    sum += analogRead(VIN_PIN);
16    delay(2);
17  }
18  float vPin = (sum / 16.0) * VREF / 1024.0;  // pindeki gerilim / voltage at the pin
19  return vPin * (R1 + R2) / R2 * CAL;         // bölücüden önceki gerilim / voltage before the divider
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(LED_BUILTIN, OUTPUT);
25}
26
27void loop() {
28  float v = readInputVoltage();
29  Serial.print(F("Giris / Input: "));
30  Serial.print(v, 2);
31  Serial.println(F(" V"));
32  digitalWrite(LED_BUILTIN, v < LOW_V ? HIGH : LOW);  // akü zayıfsa LED yanar / LED on when the battery is low
33  delay(1000);
34}

O código descarta a primeira leitura para o capacitor de amostragem do ADC se estabilizar e depois tira a média de 16 leituras para reduzir o ruído. O número lido é primeiro convertido na tensão do pino (dividimos por 1024 porque o datasheet do ATmega328P dá ADC = Vin × 1024 / Vref) e depois multiplicado por (R1 + R2) / R2 = 3,2 para obter a tensão antes do divisor. A maior fonte de erro é o Vref: o pino 5V de um Uno alimentado pelo USB costuma ficar em qualquer valor entre 4,7 e 5,1 V. Então meça o pino 5V com um multímetro e coloque o valor em VREF; depois meça a tensão real da bateria com o multímetro, compare com o valor do Monitor Serial e coloque CAL = real / medido no código. Esse único passo corrige ao mesmo tempo os erros do Vref e da tolerância dos resistores. Se você ligar o divisor depois da chave liga/desliga do aparelho, ele não consome corrente enquanto o aparelho está desligado; 0,375 mA somam cerca de 9 mAh por dia, o que não é nada para uma bateria de carro, mas faz diferença para uma bateria pequena. Pares de resistores adequados para outras fontes:

Medindo tensão com o ESP32

No ESP32, o ADC é de 12 bits (0–4095), mas há duas diferenças importantes. Primeiro, os pinos do ADC2 não podem ser lidos com o Wi-Fi ligado, então sempre ligue o divisor a um dos pinos do ADC1, GPIO 32–39 (GPIO 34–39 são só de entrada e ideais para esse trabalho). Segundo, o ADC não é linear nos extremos: com a atenuação padrão de 11 dB, a Espressif recomenda cerca de 150–2450 mV como a faixa mais precisa. O pino mostra valores até cerca de 3,1 V, mas o erro cresce nessa região. Por isso escolhemos um divisor de 56 kΩ + 10 kΩ: 14,4 V chegam ao pino como 2,18 V e ficam na faixa precisa. Em vez do analogRead() bruto, usamos analogReadMilliVolts(), que devolve milivolts diretamente usando os dados de calibração gravados no chip na fábrica:

1// ESP32: 56k + 10k bölücüyle 12 V ölçme / ESP32: measuring 12 V with a 56k + 10k divider
2const int VIN_PIN = 34;        // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
3const float R1 = 56000.0;      // üst direnç (ohm) / top resistor (ohms)
4const float R2 = 10000.0;      // alt direnç (ohm) / bottom resistor (ohms)
5const float CAL = 1.000;       // multimetreyle ayarla / tune with a multimeter
6
7void setup() {
8  Serial.begin(115200);
9  analogReadResolution(12);    // 0-4095 (varsayılan / default)
10}
11
12void loop() {
13  uint32_t mv = 0;
14  for (int i = 0; i < 32; i++) {
15    mv += analogReadMilliVolts(VIN_PIN);     // kalibre edilmiş milivolt / calibrated millivolts
16  }
17  float vPin = mv / 32.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
18  float vIn = vPin * (R1 + R2) / R2 * CAL;   // bölücüden önceki gerilim / voltage before the divider
19  Serial.printf("Pin: %.3f V  Giris / Input: %.2f V\n", vPin, vIn);
20  delay(1000);
21}

Medindo tensão com o Raspberry Pi Pico (MicroPython)

No Raspberry Pi Pico, as entradas analógicas são GP26, GP27 e GP28 (ADC0–ADC2). O read_u16() do MicroPython escala a leitura de 12 bits para a faixa 0–65535, e a referência é o ADC_VREF, que vem dos 3,3 V da placa. Como o ADC do Pico mede até 3,3 V, um divisor de 56 kΩ + 10 kΩ permite chegar a cerca de 21 V. Um detalhe interessante: o próprio Pico usa um divisor de tensão. Um divisor na placa divide por três a tensão de alimentação VSYS e a envia ao GP29 (ADC3); multiplique por 3 a tensão lida com ADC(29) e você vê a tensão de alimentação da placa (no Pico W, o GP29 é compartilhado com o chip sem fio, então isso não funciona diretamente).

1from machine import ADC
2import time
3
4adc = ADC(26)            # GP26 = ADC0 (pin 31)
5VREF = 3.3               # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
6R1 = 56000               # üst direnç (ohm) / top resistor (ohms)
7R2 = 10000               # alt direnç (ohm) / bottom resistor (ohms)
8CAL = 1.000              # kalibrasyon katsayısı / calibration factor
9
10
11def read_input_voltage(samples=32):
12    total = 0
13    for _ in range(samples):
14        total += adc.read_u16()                  # 0-65535
15    v_pin = total / samples * VREF / 65535       # pindeki gerilim / voltage at the pin
16    return v_pin * (R1 + R2) / R2 * CAL          # bölücüden önceki gerilim / voltage before the divider
17
18
19while True:
20    v_in = read_input_voltage()
21    print("Giris / Input: {:.2f} V".format(v_in))
22    time.sleep(1)

Baixando um sinal de 5 V para 3,3 V (para ESP32 e Pico)

Os pinos do ESP32 e do Pico não toleram 5 V. Se a saída ECHO do HC-SR04, o pino TX de um Arduino Uno ou a saída digital de um módulo alimentado com 5 V for ligada direto nessas placas, os diodos de proteção da entrada ficam sobrecarregados e o pino pode falhar com o tempo. Para sinais de mão única, a solução mais barata é um divisor de tensão. O objetivo é uma tensão que nunca passe de 3,3 V, mas ainda seja alta o bastante para a placa ler como HIGH: o ESP32 considera 75% da sua alimentação (cerca de 2,5 V) como nível HIGH mínimo, e o RP2040 do Pico usa 2,0 V. Então uma saída entre 3,0 e 3,3 V dá uma margem confortável nas duas placas. Esse também é o método recomendado no guia do sensor de distância HC-SR04 para ligar o pino ECHO a placas de 3,3 V.

Junto com a capacitância do próprio pino, o divisor forma um pequeno filtro RC. A resistência de saída de 6,7 kΩ de um divisor de 10 kΩ + 20 kΩ e cerca de 15 pF de capacitância do pino e da protoboard dão uma constante de tempo de uns 100 ns; uma UART de 115200 baud (8,7 µs por bit) nem percebe, mas as bordas de sinais SPI de alguns MHz ficam arredondadas. Em linhas rápidas, prefira 1 kΩ + 2 kΩ. Lembre-se também de que um divisor só funciona em um sentido, da tensão mais alta para a mais baixa. No outro sentido, normalmente você não precisa de nada: o Arduino Uno considera HIGH qualquer valor acima de 3,0 V, então consegue ler a saída de 3,3 V do ESP32, ainda que com uma margem pequena. Já em linhas bidirecionais como o I2C, um divisor não serve; ali se usa um conversor de nível lógico baseado em MOSFET.

Lendo um LDR e um NTC com um divisor de tensão

Microcontroladores não conseguem medir resistência diretamente, só tensão. Quando você coloca um sensor resistivo como um LDR ou um NTC em série com um resistor fixo para formar um divisor de tensão, a variação de resistência vira uma variação de tensão no ponto médio. O valor do resistor fixo define a sensibilidade. Para obter a maior variação de tensão, o resistor fixo deve ser a média geométrica da menor e da maior resistência do sensor na faixa que interessa: R = √(Rmin × Rmax). Para um LDR que marca 1 kΩ na luz forte e 100 kΩ na penumbra, isso dá √(1 k × 100 k) = 10 kΩ. Com 5 V, usando 10 kΩ a saída varia 4,09 V, enquanto com 1 kΩ ou 100 kΩ a variação cai para 2,45 V. É por isso que os kits iniciantes vêm com resistores de 10 kΩ. Há ainda outra vantagem: como o divisor e o ADC funcionam com os mesmos 5 V, a resistência calculada não depende da tensão de alimentação (uma medição raciométrica), então o código abaixo nem precisa de um valor de Vref.

1// LDR ve NTC'yi gerilim bölücüyle okuma / Reading an LDR and an NTC with voltage dividers
2// A0: 5V -> LDR -> A0 -> 10k -> GND
3// A1: 5V -> 10k -> A1 -> NTC 10k (B = 3950) -> GND
4const float R_FIXED = 10000.0;  // sabit dirençler (ohm) / fixed resistors (ohms)
5const float R0 = 10000.0;       // NTC'nin 25 °C direnci / NTC resistance at 25 °C
6const float BETA = 3950.0;      // NTC B katsayısı / NTC beta coefficient
7const float T0 = 298.15;        // 25 °C kelvin cinsinden / 25 °C in kelvin
8
9void setup() {
10  Serial.begin(9600);
11}
12
13void loop() {
14  analogRead(A0);                         // kanal değişti, ilk okumayı at / channel changed, discard first reading
15  int ldrRaw = analogRead(A0);
16  analogRead(A1);
17  int ntcRaw = analogRead(A1);
18  if (ldrRaw < 1) ldrRaw = 1;             // sıfıra bölmeyi önle / avoid division by zero
19
20  // Oransal ölçüm: besleme gerilimi hesaptan düşer / ratiometric: the supply voltage cancels out
21  float rLdr = R_FIXED * (1024.0 / ldrRaw - 1.0);
22  float rNtc = R_FIXED * ntcRaw / (1024.0 - ntcRaw);
23  float tempC = 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;  // Beta denklemi / Beta equation
24
25  Serial.print(F("LDR: "));
26  Serial.print(rLdr / 1000.0, 1);
27  Serial.print(F(" kOhm   NTC: "));
28  Serial.print(rNtc / 1000.0, 2);
29  Serial.print(F(" kOhm   "));
30  Serial.print(tempC, 1);
31  Serial.println(F(" C"));
32  delay(1000);
33}

No código, o LDR fica em cima, então a leitura sobe à medida que a luz fica mais forte; a resistência dele é R = 10 kΩ × (1024 / ADC − 1). O NTC fica embaixo e, à medida que a temperatura sobe, a resistência dele, e portanto a tensão lida, cai. Para os NTCs comuns de 10 kΩ a 25 °C com coeficiente B de 3950, a temperatura vem da equação Beta: 1 / T = 1 / T0 + ln(R / R0) / B (temperaturas em kelvin). Como o resistor fixo é igual à resistência do NTC a 25 °C, a saída na temperatura ambiente é exatamente metade da alimentação, que é onde a sensibilidade é maior. Para mais precisão em uma faixa ampla de temperatura, tratamos da equação de Steinhart-Hart e do autoaquecimento do NTC no guia do termistor NTC.

Ideias de projetos com divisor de tensão

• Monitor de bateria e alarme de bateria fraca: acompanhe a bateria de um motorhome ou de um sistema fotovoltaico e faça um buzzer tocar quando ela cair abaixo de 11,8 V; para opções de alimentação em projetos com bateria, veja Como alimentar o Arduino com bateria.
• Voltímetro digital: mostre a tensão medida em um display LCD ou OLED; os passos estão em Como fazer um voltímetro com Arduino.
• Luz noturna automática: use um divisor com LDR para acender LEDs ou acionar um relé quando escurecer.
• Seguidor solar: compare as tensões de dois divisores com LDR para virar um painel em direção à luz (seguidor solar).
• Cinco botões em um pino: monte uma escada de resistores diferentes e descubra qual botão foi apertado pelo valor analógico (como ligar botões).
• Termostato: meça a temperatura com um divisor com NTC e acione uma ventoinha ou um aquecedor por um relé na temperatura que você definir.

Erros comuns e como corrigi-los

Um divisor de tensão é só dois resistores e uma fórmula, mas aparece em algum ponto de quase todo projeto que mede alguma coisa. Escolha a razão com a fórmula, escolha os valores absolutos equilibrando corrente e resistência de saída, leve em conta o efeito de carga e calibre o resultado com um multímetro, e você terá leituras confiáveis. A base sobre leituras analógicas está em O que é ADC?. No app BlueGrays, você encontra projetos como medição da intensidade da luz com LDR, luz noturna com LDR, voltímetro digital com display LCD, medição de temperatura com NTC e medidor de distância HC-SR04 com ESP32, cada um explicado passo a passo com esquema do circuito e código.