Divisor de voltaje: fórmula, cálculo de resistencias y Arduino

Un divisor de voltaje (también llamado divisor de tensión) es el circuito más sencillo para convertir una tensión en otra más pequeña y fácil de calcular usando dos resistencias en serie. La tensión de salida se obtiene con Vout = Vin × R2 / (R1 + R2): R1 va a la fuente, R2 va a tierra (GND) y la salida se toma del punto medio donde se unen. Por ejemplo, dos resistencias de 10 kΩ dividen 12 V exactamente por la mitad, a 6 V. Estas dos resistencias están en el corazón de innumerables circuitos: desde medir una batería de 12 V con Arduino y adaptar una señal de 5 V a los pines de 3,3 V de un ESP32 hasta leer sensores como la LDR y el termistor NTC.

En esta guía verás, con números reales, de dónde sale la fórmula, cómo elegir los valores de las resistencias y por qué la salida baja cuando conectas algo al divisor (el efecto de carga). Después montaremos paso a paso el código que mide la tensión de una batería con Arduino Uno, ESP32 y Raspberry Pi Pico, elegiremos las parejas de resistencias adecuadas para pasar de 5 V a 3,3 V y leeremos una LDR y un NTC con un divisor. Por último, explicaremos por qué un divisor de voltaje nunca debe usarse como fuente de alimentación.

¿Qué es un divisor de voltaje y cómo funciona?

La fórmula del divisor de voltaje sale directamente de la ley de Ohm. Por R1 y R2, conectadas en serie entre la fuente y tierra, circula la misma corriente: I = Vin / (R1 + R2). La tensión en R2, que es la salida, es esa corriente multiplicada por R2: Vout = I × R2 = Vin × R2 / (R1 + R2). En resumen, la tensión de la fuente se reparte entre las resistencias en proporción a sus valores; a la resistencia mayor le toca la parte mayor. La salida siempre es menor que la entrada, porque la relación R2 / (R1 + R2) es menor que 1. Tienes más detalles sobre cómo se reparte la tensión en un circuito en serie en Cálculo de resistencias en serie y en paralelo.

También puedes calcular al revés: si quieres bajar 12 V a 3,3 V y has elegido 10 kΩ para R2, obtienes R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ. Ese valor no se vende, así que eliges el siguiente valor normalizado hacia arriba, 27 kΩ, y la salida queda en 12 × 10 / 37 ≈ 3,24 V. Redondear R1 hacia arriba baja un poco la salida, que es el lado seguro para el pin. Un potenciómetro también es, en realidad, un divisor de voltaje ajustable: su cursor divide la pista resistiva en R1 y R2. Si no quieres hacer la cuenta a mano, la calculadora de divisor de voltaje te da la salida al instante a partir de la tensión de entrada y las resistencias. En electrónica verás el divisor de voltaje sobre todo en estas tareas:

• Medir tensiones altas: llevar fuentes como una batería de 12 V o un pack de litio de 7,4 V al rango que puede medir una entrada analógica.
• Bajar el nivel lógico: hacer que una señal de 5 V sea segura para las entradas de 3,3 V del ESP32 y la Raspberry Pi Pico.
• Leer sensores resistivos: convertir en tensión el cambio de resistencia de componentes como la LDR, el NTC, el sensor de flexión o el sensor de fuerza (FSR).
• Leer muchos botones con un pin: una escalera de resistencias da a cada botón una tensión distinta, de modo que cinco botones pueden compartir un solo pin analógico.
• Realimentación de reguladores: reguladores como el LM317 o el LM2596 ajustable mantienen estable su salida midiéndola a través de un divisor; en el LM317, Vout = 1,25 × (1 + R2 / R1).
• Crear una tensión de referencia: generar la mitad de la tensión de alimentación como referencia en circuitos con amplificadores operacionales.

Cómo elegir los valores de las resistencias

La fórmula solo se fija en la relación: 1 kΩ + 1 kΩ y 100 kΩ + 100 kΩ dividen igual, exactamente por la mitad. Pero en la práctica también importan los valores absolutos. Las resistencias pequeñas dejan pasar mucha corriente por el divisor; esa corriente es energía desperdiciada y en proyectos con batería la agota sin motivo. Las resistencias grandes consumen muy poca corriente, pero su salida es débil: una carga conectada o el condensador de muestreo de la entrada analógica alteran fácilmente la tensión de salida, y el ruido captado por los cables entra con más facilidad. La elección correcta es un equilibrio entre estos dos extremos:

1. Determina la tensión de entrada máxima. Una batería de plomo de 12 V puede llegar a 14,4 V mientras se carga; toma el peor caso de la tensión que vas a medir y añade un margen del 10 %.
2. Determina la tensión máxima que admite el pin. 5 V en el Arduino Uno y 3,3 V en el ESP32 y la Pico; como objetivo seguro elige unos 4,5 V en el Uno, 2,5 V en el ESP32 y 3,0 V en la Pico.
3. Calcula la relación: k = salida objetivo / entrada máxima. Por ejemplo, 4,5 / 14,4 ≈ 0,31.
4. Elige R2 (10 kΩ es un buen punto de partida en la mayoría de los casos) y halla R1 con R1 = R2 × (1 / k − 1). Redondea el resultado al siguiente valor hacia arriba de los valores normalizados de resistencias.
5. Comprueba la corriente y la potencia: I = Vin / (R1 + R2) y P = Vin² / (R1 + R2). En proyectos con batería intenta mantener la corriente en el rango de los microamperios.
6. Comprueba la resistencia de salida: R1 × R2 / (R1 + R2) debería estar por debajo de 10 kΩ en el Arduino Uno; si no, añade un condensador de 100 nF entre el pin analógico y GND.
7. Escribe la relación real en el código: recalcula la relación con los valores normalizados elegidos, mide con un multímetro una vez montado el circuito y calibra.

Efecto de carga: ¿qué pasa al conectar algo al divisor?

La fórmula supone que no se saca corriente de la salida. En cuanto conectas una carga, queda en paralelo con R2, la resistencia equivalente de la rama inferior se reduce y la tensión de salida baja. La forma fácil de calcularlo es ver el divisor como su equivalente de Thévenin: una fuente con la tensión que mides sin carga (Vth) y una resistencia interna Rth = R1 × R2 / (R1 + R2). Con una carga RL, la salida pasa a ser Vth × RL / (Rth + RL). La tabla muestra una fuente de 10 V dividida con 10 kΩ + 10 kΩ (Vth = 5 V, Rth = 5 kΩ) y distintas cargas en la salida:

La regla práctica: si la resistencia de la carga es al menos 100 veces la resistencia de salida del divisor (Rth), el error queda por debajo del 1 %. Si la carga es menor, reduce las resistencias o intercala un seguidor de tensión (búfer) con amplificador operacional. La entrada analógica de un microcontrolador tiene de por sí una resistencia muy alta, pero dentro hay un pequeño condensador de muestreo que se carga en cada conversión (unos 14 pF en el ATmega328P). Por eso la hoja de datos recomienda que la resistencia de salida de la fuente sea de unos 10 kΩ o menos. Si usas un divisor de valores más altos, añade un condensador de 100 nF entre el pin analógico y GND: mantiene lista la carga que hace falta en el momento del muestreo. Y si lees varios pines analógicos seguidos, descartar la primera lectura de cada pin elimina el error que deja el cambio de canal.

Por qué un divisor de voltaje no sirve como fuente de alimentación

La trampa más habitual de los principiantes es sacar 5 V de un adaptador de 12 V con dos resistencias e intentar alimentar con ellos un Arduino o un módulo. Sobre el papel, un divisor de 7 kΩ y 5 kΩ da exactamente 5 V a partir de 12 V, pero solo mientras no se saque corriente de la salida. Una placa que consume 50 mA se comporta como una carga de unos 100 Ω; en paralelo con los 5 kΩ de R2, la rama inferior baja a 98 Ω y la salida se desploma a 0,17 V. Si reduces las resistencias a 70 Ω y 50 Ω, el circuito consume 100 mA y genera 1,2 W de calor incluso sin nada conectado; con la carga, la salida sigue cayendo a 3,9 V y cada vez que cambia el consumo de la placa (Wi-Fi, un servo, un relé) la tensión también varía. Además, al quitar la carga la tensión vuelve a subir y puede dañar componentes sensibles.

Medir una batería de 12 V y pilas con Arduino

Las entradas analógicas del Arduino Uno leen como máximo 5 V; conectar directamente una batería de 12 V quemaría el pin. La solución es un divisor de 22 kΩ (R1) y 10 kΩ (R2): con una relación de 0,3125, los 14,4 V de carga llegan al pin como 4,5 V y el circuito puede medir hasta 16 V. A 12 V el divisor consume solo 0,375 mA y su resistencia de salida, de 6,9 kΩ, queda por debajo del límite recomendado de 10 kΩ. El ADC de 10 bits distingue unos 4,9 mV por paso; con el divisor eso equivale a una resolución de unos 15,6 mV en la entrada. Como el ESP32 y la Pico trabajan a 3,3 V, en ellos usamos una R1 mayor (56 kΩ):

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}

El código descarta la primera lectura para que se estabilice el condensador de muestreo del ADC y luego promedia 16 lecturas para reducir el ruido. El número leído se convierte primero en la tensión del pin (dividimos entre 1024 porque, según la hoja de datos del ATmega328P, ADC = Vin × 1024 / Vref) y después se multiplica por (R1 + R2) / R2 = 3,2 para obtener la tensión antes del divisor. La mayor fuente de error es Vref: el pin de 5V de un Uno alimentado por USB suele estar entre 4,7 y 5,1 V. Por eso mide el pin de 5V con un multímetro y escribe el valor en VREF; después mide con el multímetro la tensión real de la batería, compárala con el valor del monitor serie e introduce en el código CAL = real / medido. Este único paso corrige a la vez los errores de Vref y de tolerancia de las resistencias. Si conectas el divisor después del interruptor de encendido del aparato, no consume nada mientras está apagado; 0,375 mA suman unos 9 mAh al día, nada para la batería de un coche pero apreciable en una batería pequeña. Estas son parejas de resistencias adecuadas para otras fuentes:

Medir tensión con el ESP32

En el ESP32 el ADC es de 12 bits (0–4095), pero tiene dos diferencias importantes. La primera: los pines del ADC2 no se pueden leer con el Wi-Fi activo, así que conecta siempre el divisor a un pin del ADC1, GPIO 32–39 (los GPIO 34–39 son solo de entrada e ideales para esto). La segunda: el ADC no es lineal en los extremos; con la atenuación por defecto de 11 dB, Espressif recomienda aproximadamente 150–2450 mV como rango más preciso. El pin mostrará valores hasta unos 3,1 V, pero en esa zona el error crece. Por eso elegimos un divisor de 56 kΩ + 10 kΩ: 14,4 V llegan al pin como 2,18 V y se quedan en el rango preciso. En lugar del analogRead() en bruto usamos analogReadMilliVolts(), que devuelve directamente milivoltios usando los datos de calibración grabados en el chip en 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}

Medir tensión con la Raspberry Pi Pico (MicroPython)

En la Raspberry Pi Pico las entradas analógicas son GP26, GP27 y GP28 (ADC0–ADC2). La función read_u16() de MicroPython escala la lectura de 12 bits al rango 0–65535, y la referencia es ADC_VREF, que procede de los 3,3 V de la placa. Como el ADC de la Pico mide hasta 3,3 V, con 56 kΩ + 10 kΩ llegas hasta unos 21 V. Un detalle curioso: la propia Pico usa un divisor de voltaje. Un divisor en la placa divide entre tres la tensión de alimentación VSYS y la lleva a GP29 (ADC3); si multiplicas por 3 la tensión leída con ADC(29), ves la tensión de alimentación de la placa (en la Pico W, GP29 se comparte con el chip inalámbrico y esto no funciona directamente).

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)

Bajar una señal de 5 V a 3,3 V (para ESP32 y Pico)

Los pines del ESP32 y la Pico no toleran 5 V. Si la salida ECHO del HC-SR04, el pin TX de un Arduino Uno o la salida digital de un módulo alimentado a 5 V se conectan directamente a estas placas, los diodos de protección de la entrada se fuerzan y el pin puede estropearse con el tiempo. Para señales en un solo sentido, la solución más barata es un divisor de voltaje. El objetivo es una tensión que nunca supere 3,3 V pero que sea lo bastante alta para que la placa la lea como HIGH: el ESP32 toma el 75 % de su alimentación (unos 2,5 V) como nivel HIGH mínimo, y el RP2040 de la Pico, 2,0 V. Por eso una salida de entre 3,0 y 3,3 V deja un margen cómodo en ambas placas. Es también el método que recomienda la guía del sensor de distancia HC-SR04 para conectar el pin ECHO a placas de 3,3 V.

Junto con la capacidad del propio pin, el divisor forma un pequeño filtro RC. Los 6,7 kΩ de resistencia de salida de un divisor de 10 kΩ + 20 kΩ, con unos 15 pF de pin y protoboard, dan una constante de tiempo de unos 100 ns; a una UART de 115200 baudios (8,7 µs por bit) no le afecta, pero los flancos de las señales SPI de varios MHz se redondean. En líneas rápidas, mejor 1 kΩ + 2 kΩ. Recuerda también que un divisor solo funciona en un sentido, de la tensión más alta a la más baja. En el sentido contrario normalmente no hace falta nada: el Arduino Uno considera HIGH todo lo que supera 3,0 V, así que puede leer la salida de 3,3 V del ESP32, aunque con poco margen. En líneas bidireccionales como el I2C, en cambio, el divisor no sirve; ahí se usa un convertidor de nivel lógico con MOSFET.

Leer una LDR y un NTC con un divisor de voltaje

Los microcontroladores no pueden medir resistencia directamente, solo tensión. Cuando pones un sensor resistivo como una LDR o un NTC en serie con una resistencia fija formando un divisor de voltaje, el cambio de resistencia se convierte en un cambio de tensión en el punto medio. El valor de la resistencia fija determina la sensibilidad. Para obtener la mayor variación de tensión, la resistencia fija debe ser la media geométrica de la resistencia mínima y máxima del sensor en el rango que te interesa: R = √(Rmin × Rmax). Para una LDR de 1 kΩ con mucha luz y 100 kΩ con poca luz, sale √(1 k × 100 k) = 10 kΩ. A 5 V, con 10 kΩ la salida varía 4,09 V, mientras que con 1 kΩ o 100 kΩ la variación se reduce a 2,45 V. Por eso los kits de inicio traen resistencias de 10 kΩ. Hay otra ventaja: como el divisor y el ADC se alimentan de los mismos 5 V, la resistencia calculada no depende de la tensión de alimentación (medida ratiométrica), así que el código de abajo ni siquiera necesita un 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}

En el código la LDR está arriba, así que la lectura sube cuando hay más luz; su resistencia es R = 10 kΩ × (1024 / ADC − 1). El NTC está abajo y, cuando sube la temperatura, baja su resistencia y con ella la tensión leída. Para los NTC habituales de 10 kΩ a 25 °C con coeficiente B de 3950, la temperatura se obtiene con la ecuación Beta: 1 / T = 1 / T0 + ln(R / R0) / B (temperaturas en kelvin). Como la resistencia fija coincide con la del NTC a 25 °C, a temperatura ambiente la salida es exactamente la mitad de la alimentación, que es donde la sensibilidad es máxima. Para más precisión en un rango amplio de temperaturas, tratamos la ecuación de Steinhart-Hart y el autocalentamiento del NTC en la guía del termistor NTC.

Ideas de proyectos con divisor de voltaje

• Monitor de batería con alarma: vigila la batería de una autocaravana o de una instalación solar y haz sonar un zumbador cuando baje de 11,8 V; para opciones de alimentación en proyectos con batería, mira Alimentar Arduino con pilas.
• Voltímetro digital: muestra la tensión medida en una pantalla LCD u OLED; los pasos están en Cómo hacer un voltímetro con Arduino.
• Luz nocturna automática: con un divisor con LDR, enciende LED o un relé cuando oscurece.
• Seguidor solar: compara las tensiones de dos divisores con LDR para orientar un panel hacia la luz (seguidor solar).
• Cinco botones en un pin: monta una escalera de resistencias distintas y averigua qué botón se pulsa a partir del valor analógico (conectar botones).
• Termostato: mide la temperatura con un divisor con NTC y activa un ventilador o un calefactor mediante un relé a la temperatura que elijas.

Errores frecuentes y cómo solucionarlos

Un divisor de voltaje no es más que dos resistencias y una fórmula, pero aparece en casi cualquier proyecto que mida algo. Si eliges la relación con la fórmula y los valores absolutos equilibrando corriente y resistencia de salida, tienes en cuenta el efecto de carga y calibras el resultado con un multímetro, obtendrás medidas fiables. Puedes leer los fundamentos de la lectura analógica en ¿Qué es un ADC?. En la app BlueGrays encontrarás proyectos como leer la intensidad de luz con una LDR, una luz nocturna con LDR, un voltímetro digital con LCD, la medida de temperatura con NTC y un medidor de distancia con ESP32 y HC-SR04, explicados paso a paso con esquemas y código.