¿Qué es un condensador? Tipos, código 104 y constante RC

Un condensador es un componente básico que almacena carga eléctrica entre dos placas conductoras que no se tocan y la devuelve muy rápido cuando hace falta. Piensa en él como un pequeño depósito de energía, pero muy rápido: aporta carga cuando la tensión cae, absorbe los picos repentinos, bloquea la corriente continua (DC) una vez cargado y, en cambio, deja pasar la corriente alterna (AC) y el ruido. Incluso un Arduino Uno lleva muchos condensadores; sirven para estabilizar la alimentación, evitar los rebotes de los pulsadores, fijar tiempos y convertir una señal PWM en una tensión suave.

En esta guía aprenderás cómo funciona un condensador, las unidades pF, nF y µF, la diferencia entre condensadores cerámicos, electrolíticos y de tantalio, cómo leer la polaridad y la tensión máxima, qué significan códigos como 104, la constante de tiempo RC (τ = R·C) y cómo conectar condensadores en serie y en paralelo. Al final haremos un experimento con Arduino, ESP32 y Raspberry Pi Pico que dibuja la curva de carga de un condensador y mide su capacidad.

¿Qué es un condensador y cómo funciona?

Dentro de todo condensador hay dos superficies conductoras separadas por una capa aislante llamada dieléctrico. Al aplicar una tensión entre sus terminales, los electrones se acumulan en una placa y se retiran de la otra; entre las placas aparece un campo eléctrico y la energía se guarda en ese campo. La carga almacenada se calcula con Q = C · V, donde C es la capacidad en faradios y V la tensión en voltios. La energía almacenada es E = ½ · C · V²; por ejemplo, un condensador de 1000 µF cargado a 16 V guarda 0,128 julios. La corriente y la tensión se relacionan con I = C · ΔV/Δt: el condensador se opone a los cambios bruscos de su tensión y por eso suaviza las fluctuaciones.

Puedes imaginar un condensador como un depósito de agua: vacío se llena deprisa, a medida que se llena el flujo se frena y al final se detiene. Por eso, en un circuito de continua, deja de pasar corriente por el condensador en cuanto está cargado. En cambio, cuanto más sube la frecuencia, menos se opone a la corriente; esa oposición se llama reactancia capacitiva y se calcula con Xc = 1 / (2π · f · C). Un condensador de 100 nF presenta unos 1,6 kΩ a 1 kHz, pero solo 0,16 Ω a 10 MHz. Es decir, para el ruido de alta frecuencia es casi un cortocircuito, y ese es todo el secreto de los condensadores de desacoplo.

Unidades de capacidad: pF, nF y µF

El faradio es una unidad enorme, así que en electrónica casi siempre se usan sus submúltiplos. La conversión es sencilla: cada escalón es un factor 1000. 1 µF = 1000 nF = 1.000.000 pF, de modo que 0,1 µF, 100 nF y 100.000 pF son el mismo valor. Cuando no se dispone del símbolo µ, se escribe una u (10uF), y en esquemas antiguos puedes ver MFD para microfaradio. Los valores que más verás en proyectos con Arduino son 22 pF, 100 nF (0,1 µF), 10 µF, 100 µF y 1000 µF.

Tipos de condensadores: cerámicos, electrolíticos, de tantalio y otros

• Cerámico: Pequeño, barato y sin polaridad. Su resistencia interna (ESR) es muy baja, por eso es el que mejor filtra el ruido rápido. La estabilidad depende del dieléctrico: C0G (NP0) es muy estable, X7R es bueno, mientras que Y5V puede perder más de la mitad de su valor con la temperatura y la tensión aplicada.
• Electrolítico de aluminio: Ofrece mucha capacidad en poco volumen, pero tiene polaridad y el líquido interior se seca con el tiempo. En el cuerpo figura un límite de 85 °C o 105 °C y la vida útil a esa temperatura (p. ej., 2000 horas); como regla aproximada, cada 10 °C menos duplica su vida.
• Tantalio: Más pequeño y estable que un electrolítico del mismo valor, pero sensible a la tensión inversa y a los picos de corriente; cuando falla puede quedar en cortocircuito y arder. Elige uno con al menos el doble de tu tensión de trabajo.
• De película: Sin polaridad, estable y de bajas pérdidas; se usa en audio, temporización precisa y filtros de red de 230 V (clase X2). Su desventaja es que los valores grandes son voluminosos.
• Supercondensador: Tiene capacidades del orden del faradio, pero solo soporta unos 2,7 V por celda. No almacena tanta energía como una batería; a cambio, se carga y descarga en segundos y aguanta cientos de miles de ciclos.

Cómo leer la polaridad (+/−) y la tensión máxima

• Electrolítico de patillas: La patilla larga es la positiva (+) y la corta la negativa (−). La franja clara del envoltorio lleva signos menos y marca el lado negativo. Si las patillas están cortadas, guíate por la franja.
• Electrolítico SMD (tipo lata): La media luna negra o de color de la parte superior indica el lado negativo.
• Tantalio: Ojo, aquí es al revés: la franja o raya de un condensador de tantalio marca la patilla positiva.
• Cerámicos y de película: No tienen polaridad; se pueden colocar en cualquier sentido.
• En los esquemas: Un condensador sin polaridad se dibuja con dos líneas rectas paralelas. En uno polarizado, una de las placas aparece curva o rellena y un signo + marca el lado positivo.

La tensión máxima impresa en el cuerpo (p. ej., 16 V, 25 V, 50 V) es la tensión continua más alta que el condensador soporta de forma permanente, y nunca debe superarse. La regla segura es elegir un condensador de al menos 1,5 a 2 veces la tensión más alta del circuito: 10 V o 16 V en un circuito de Arduino de 5 V, 25 V con un adaptador de 12 V y 35 V o 50 V con 24 V. Usar una tensión mayor de la necesaria no tiene ningún inconveniente; el componente solo es más grande y algo más caro.

Cómo leer el código de un condensador: ¿qué significa 104?

Para ahorrar espacio, los condensadores cerámicos y de película indican su valor con un código de tres cifras. La unidad es siempre el picofaradio: las dos primeras cifras son el número y la tercera, cuántos ceros hay que añadir. Así, 104 = 10 seguido de 4 ceros = 100.000 pF = 100 nF = 0,1 µF. Los códigos de dos cifras indican el valor directamente en pF (22 = 22 pF) y, si la tercera cifra es 0, no se añade ningún cero (220 = 22 pF). En la notación con letra, la letra es a la vez unidad y coma: 4n7 = 4,7 nF, 2p2 = 2,2 pF. Para descifrarlo rápido, usa la herramienta Código de condensador.

La letra que sigue al código indica la tolerancia: J = ±5 %, K = ±10 %, M = ±20 %, Z = +80 % / −20 %. En los condensadores de película puede aparecer además un código de tensión delante; por ejemplo, 2A104J significa 100 V (2A), 100 nF (104) y ±5 % (J). Los códigos de tensión más habituales son 1C = 16 V, 1H = 50 V, 2A = 100 V y 2J = 630 V. Los electrolíticos no usan código; el valor se imprime directamente (470 µF 16 V). Los condensadores cerámicos SMD, en cambio, normalmente no llevan ninguna marca, así que solo puedes saber su valor por el embalaje o midiéndolos.

Carga, descarga y constante de tiempo RC (τ = R·C)

Cuando cargas un condensador a través de una resistencia, su tensión no salta de golpe, sino que sube siguiendo una curva exponencial: Vc = Vf · (1 − e^(−t/RC)) (Vf es la tensión de la fuente y t el tiempo transcurrido). Al descargarse baja al mismo ritmo: Vc = V0 · e^(−t/RC). El producto R·C se llama constante de tiempo y se escribe τ (tau); ohmios por faradios dan segundos. Por ejemplo, con una resistencia de 10 kΩ y un condensador de 100 µF, τ = 10.000 × 0,0001 = 1 segundo. Con 1 kΩ y 100 nF, τ es de solo 0,1 milisegundos.

En la práctica se considera que un condensador está totalmente cargado o descargado tras unos 5τ; en el ejemplo de 10 kΩ y 100 µF, eso son 5 segundos. Este comportamiento es la base de los temporizadores, de los circuitos antirrebote para pulsadores, de las lámparas que se apagan poco a poco y del chip 555. Para repasar los valores de resistencias lee ¿Qué es una resistencia?, y para ver cómo cambia la curva con distintos valores de R y C prueba la herramienta Constante de tiempo RC. La relación entre tensión, corriente y resistencia la explicamos a fondo en Ley de Ohm.

Filtrado y desacoplo: ¿por qué hay un 100 nF junto a cada chip?

Los microcontroladores y demás chips consumen pulsos de corriente muy cortos, de nanosegundos, en cada flanco de reloj. Si la fuente está lejos, la inductancia de los cables no puede responder a esas demandas repentinas; aparecen pequeñas caídas y ruido en la alimentación, y el resultado son reinicios aleatorios, lecturas analógicas poco fiables o bloqueos. La solución es colocar un condensador cerámico de 100 nF entre los pines VCC y GND de cada chip, lo más cerca posible. Funciona como un diminuto depósito de energía justo al lado del chip y deriva el ruido de alta frecuencia a GND. Se le llama condensador de desacoplo (decoupling) o de bypass. Para cambios de carga lentos y grandes se añade en la entrada de alimentación un electrolítico de 10–1000 µF (condensador de reserva o bulk).

• 100 nF para cada chip: Entre VCC y GND, con patillas cortas y lo más cerca posible del pin de alimentación del chip.
• Reguladores lineales como el 7805: El fabricante recomienda 0,33 µF en la entrada y 0,1 µF en la salida; en la práctica también se suelen añadir 10–100 µF en la salida. Más detalles en Regulador de tensión 7805.
• Servomotores: Colocar 100–470 µF en la alimentación del servo, cerca de él, ayuda a evitar que el Arduino se reinicie cuando el servo se mueve (¿Qué es un servomotor?).
• Tiras LED WS2812B: Se recomienda un condensador de 500–1000 µF y al menos 6,3 V entre los terminales + y − del adaptador (WS2812B NeoPixel).
• Motores de continua: Un cerámico de 100 nF soldado directamente entre los terminales del motor reduce mucho el ruido eléctrico que generan las escobillas (Motor DC con L298N).
• Módulos inalámbricos: Al transmitir, la corriente se dispara de golpe. Añadir 10 µF en los pines de alimentación del nRF24L01 y 100–470 µF entre 3,3 V y GND en el ESP32 reduce las desconexiones y los reinicios por brownout.

Si conectas una resistencia y un condensador en serie obtienes un filtro paso bajo: deja pasar las frecuencias por debajo de cierto valor y atenúa las de encima. La frecuencia de corte es fc = 1 / (2π · R · C). La salida PWM del Arduino Uno es una onda cuadrada de 490 Hz (980 Hz en los pines 5 y 6); con un filtro de 10 kΩ y 10 µF (fc ≈ 1,6 Hz) esa onda se convierte en una tensión continua casi plana y obtienes una salida analógica sencilla. El precio es el tiempo de respuesta: con τ = 0,1 s tarda alrededor de medio segundo en asentarse en un nuevo valor. Más en ¿Qué es PWM?. Una fuente rectificada también se filtra con un gran condensador de filtrado, y el rizado que queda es aproximadamente ΔV ≈ I / (f · C): con 1 A de carga, rectificación de onda completa a 100 Hz y 4700 µF, unos 2,1 V.

Condensadores en serie y en paralelo

Las fórmulas de los condensadores son justo las contrarias a las de las resistencias. En paralelo las capacidades se suman: C = C1 + C2 + … y la tensión máxima es la del componente de menor tensión. En serie la capacidad total es incluso menor que la del condensador más pequeño: 1/C = 1/C1 + 1/C2 + … Dos condensadores iguales en serie dan la mitad de capacidad y, sobre el papel, sus tensiones se suman; pero como sus corrientes de fuga no son iguales, la tensión se reparte de forma desigual, por eso se coloca en paralelo con cada uno una resistencia de equilibrado del mismo valor (p. ej., 100 kΩ). Si no tienes el valor que necesitas, puedes obtenerlo combinando dos condensadores; usa la herramienta Serie / paralelo C para el cálculo y consulta cálculo de resistencias en serie y paralelo para el equivalente con resistencias.

Experimento con Arduino: curva de carga y medida de la capacidad

La mejor manera de ver la teoría con tus propios ojos es medir la tensión de un condensador mientras se carga. Un pin digital del Arduino cargará el condensador a través de una resistencia de 10 kΩ y una entrada analógica leerá su tensión. El tiempo que tarda en llegar al 63,2 % de la tensión de la fuente es una τ, y a partir de ahí calculamos la capacidad con C = τ / R. Necesitas: un Arduino Uno, un condensador electrolítico de 100 µF, una resistencia de 10 kΩ, una protoboard y unos cuantos cables jumper.

1. Coloca el condensador en la protoboard: la patilla + en una fila y la − en la línea de GND.
2. Conecta un extremo de la resistencia de 10 kΩ a D8 y el otro a la fila donde está la patilla + del condensador.
3. Lleva un cable desde esa misma fila hasta A0 y conecta el GND del Arduino a la línea de GND de la protoboard.
4. Sube el código de abajo y abre el Monitor Serie a 115200 baudios.
5. El código primero descarga el condensador y luego lo carga; cada 20 ms imprime el tiempo transcurrido y la tensión, y al final muestra la τ medida y la capacidad.
6. Para ver la curva como gráfico, pon PLOT a true en el código, súbelo de nuevo y abre Herramientas > Serial Plotter.

1// Kondansatör şarj eğrisi ve kapasite ölçümü / Capacitor charge curve and capacitance meter
2const int CHARGE_PIN = 8;       // 10 kΩ direnç bu pinden beslenir / the 10 kΩ resistor is driven from this pin
3const int SENSE_PIN = A0;       // kondansatörün + bacağı / capacitor + leg
4const float R_OHM = 10000.0;    // şarj direnci (ohm) / charge resistor (ohms)
5const float VREF = 5.0;         // Uno ADC referansı / Uno ADC reference
6const bool PLOT = false;        // true: Seri Çizici için yalnız gerilim / true: voltage only for the Serial Plotter
7
8void setup() {
9  Serial.begin(115200);
10  pinMode(CHARGE_PIN, OUTPUT);
11}
12
13void loop() {
14  // 1) Boşalt: pin LOW, kondansatör direnç üzerinden boşalır / discharge through the resistor
15  digitalWrite(CHARGE_PIN, LOW);
16  while (analogRead(SENSE_PIN) > 4) { }           // ~20 mV altı; ADC ofsetine pay bırak / below ~20 mV, leaves room for ADC offset
17  delay(1000);                                  // kalan yükü de boşalt / drain what is left
18
19  // 2) Şarj et, eğriyi yazdır, τ'yu yakala / charge, print the curve, catch τ
20  unsigned long t0 = millis();
21  unsigned long lastPrint = 0;
22  unsigned long tauMs = 0;
23  digitalWrite(CHARGE_PIN, HIGH);
24  while (true) {
25    int raw = analogRead(SENSE_PIN);
26    unsigned long t = millis() - t0;
27    if (tauMs == 0 && raw >= 647) tauMs = t;     // 1023 x 0,632 = 647 → bir τ / one τ
28    if (t - lastPrint >= 20) {                   // 20 ms'de bir yazdır / print every 20 ms
29      lastPrint = t;
30      float v = raw * VREF / 1023.0;
31      if (!PLOT) {
32        Serial.print(t);
33        Serial.print('\t');
34      }
35      Serial.println(v, 3);
36    }
37    if (raw >= 1010 || t > 60000) break;         // ~%99 dolu ya da zaman aşımı / ~99% full or timeout
38  }
39
40  // 3) Sonuç: C = τ / R / result: C = τ / R
41  if (!PLOT) {
42    float uF = (tauMs / 1000.0) / R_OHM * 1000000.0;
43    Serial.print(F("tau = "));
44    Serial.print(tauMs);
45    Serial.print(F(" ms   C = "));
46    Serial.print(uF, 1);
47    Serial.println(F(" uF"));
48  }
49  delay(3000);
50}

Así funciona el código: con el pin en LOW, el condensador se descarga a través de la misma resistencia de 10 kΩ. En cuanto el pin pasa a HIGH, millis() empieza a contar; cuando la lectura analógica llega a 647 (el 63,2 % de 1023), el tiempo transcurrido se guarda como τ. Cuando la lectura alcanza 1010 (aprox. el 99 %), la carga se da por terminada. Con 100 µF y 10 kΩ deberías ver aproximadamente 1000 ms y 100 µF. Los electrolíticos suelen tener una tolerancia de ±20 %, así que resultados entre 80 y 120 µF son normales. Para saber más sobre medir tiempos, consulta millis y delay.

El mismo experimento con ESP32 y Raspberry Pi Pico

En el ESP32 los pines trabajan a 3,3 V y el ADC es de 12 bits (0–4095). El ADC del ESP32 no es lineal cerca de los extremos de su rango, así que en lugar de valores brutos usamos analogReadMilliVolts(), que devuelve milivoltios calibrados. Como pin de medida elegimos el GPIO 34, del grupo ADC1, que no se ve afectado por el Wi-Fi. Como el ADC no mide de forma fiable por encima de unos 3,1 V, detectamos el final de la carga por tiempo y no por tensión: una vez encontrada τ, la medida termina al cumplirse 5τ. Para lo básico, lee ¿Qué es el ESP32?.

1// ESP32 ile kondansatör şarj eğrisi / Capacitor charge curve with ESP32
2const int CHARGE_PIN = 25;      // 10 kΩ direnç bu pinden beslenir / the 10 kΩ resistor is driven from this pin
3const int SENSE_PIN = 34;       // ADC1, yalnız giriş / ADC1, input only
4const float R_OHM = 10000.0;    // şarj direnci (ohm) / charge resistor (ohms)
5
6void setup() {
7  Serial.begin(115200);
8  pinMode(CHARGE_PIN, OUTPUT);
9}
10
11void loop() {
12  digitalWrite(CHARGE_PIN, LOW);                       // boşalt / discharge
13  unsigned long d0 = millis();
14  // ADC ~150 mV altını okuyamaz, 200 mV'a inmesini bekle / the ADC cannot read below ~150 mV, wait for 200 mV
15  while (analogReadMilliVolts(SENSE_PIN) > 200 && millis() - d0 < 60000) { }
16  delay(millis() - d0 + 1000);                         // aynı süre kadar daha bekle / wait as long again
17
18  unsigned long t0 = millis();
19  unsigned long tauMs = 0;
20  digitalWrite(CHARGE_PIN, HIGH);                      // şarj et / charge
21  while (true) {
22    unsigned long t = millis() - t0;
23    uint32_t mv = analogReadMilliVolts(SENSE_PIN);     // kalibre edilmiş mV / calibrated mV
24    if (tauMs == 0 && mv >= 2086) tauMs = t;           // 3300 mV x 0,632 → bir τ / one τ
25    Serial.println(mv);                                // Seri Çizici için / for the Serial Plotter
26    if ((tauMs > 0 && t >= 5 * tauMs) || t > 60000) break;   // 5τ ≈ %99 dolu / 5τ ≈ 99% full
27    delay(20);
28  }
29  Serial.printf("tau = %lu ms   C = %.1f uF\n", tauMs, tauMs / 1000.0 / R_OHM * 1000000.0);
30  delay(3000);
31}

En la Raspberry Pi Pico, el mismo experimento ocupa pocas líneas de MicroPython. Las entradas analógicas de la Pico son GP26, GP27 y GP28; read_u16() devuelve la medida de 12 bits escalada al rango 0–65535. El código imprime en cada línea el tiempo y la tensión, así que puedes copiar la salida en una hoja de cálculo y dibujar la curva tú mismo. Si no sabes cómo instalar MicroPython en la Pico, empieza por ¿Qué es la Raspberry Pi Pico?.

1# Pico ile kondansatör şarj eğrisi / Capacitor charge curve with Pico
2from machine import Pin, ADC
3import time
4
5charge = Pin(15, Pin.OUT)       # 10 kΩ direnç bu pinden beslenir / resistor driven from this pin
6adc = ADC(26)                   # GP26 = ADC0, kondansatörün + bacağı / capacitor + leg
7R = 10000                       # şarj direnci (ohm) / charge resistor (ohms)
8
9def volts():
10    return adc.read_u16() * 3.3 / 65535
11
12charge.value(0)                 # önce boşalt / discharge first
13d0 = time.ticks_ms()
14while volts() > 0.1 and time.ticks_diff(time.ticks_ms(), d0) < 60000:
15    pass                        # ADC sıfırda birkaç on mV gösterebilir / the ADC may read a few tens of mV at 0 V
16time.sleep_ms(time.ticks_diff(time.ticks_ms(), d0) + 1000)   # aynı süre kadar daha bekle / wait as long again
17
18t0 = time.ticks_ms()
19charge.value(1)                 # şarjı başlat / start charging
20tau = None
21while True:
22    t = time.ticks_diff(time.ticks_ms(), t0)
23    v = volts()
24    if tau is None and v >= 3.3 * 0.632:    # 2,086 V → bir τ / one τ
25        tau = t
26    print(t, round(v, 3))
27    if (tau is not None and t >= 5 * tau) or t > 60000:
28        break
29    time.sleep_ms(20)
30
31if tau is not None:
32    print("tau =", tau, "ms  C =", round(tau / 1000 / R * 1e6, 1), "uF")

Ideas de proyectos con condensadores

• Antirrebote por hardware: Coloca 100 nF – 1 µF entre los terminales del pulsador; junto con una resistencia pull-up de 10 kΩ forma un filtro con τ = 1–10 ms y los rebotes se apagan antes de llegar a tu código.
• Tensión analógica a partir de PWM: Con un filtro RC convierte una salida PWM en una tensión suave de 0 a 5 V y mídela con el multímetro.
• LED intermitente con un 555: En el temporizador 555, dos resistencias y un condensador fijan la frecuencia: f ≈ 1,44 / ((R1 + 2·R2) · C). Calcula los valores con la herramienta Temporizador 555.
• Lámpara que se apaga lentamente: Después del interruptor, coloca un condensador de 1000 µF en paralelo con la alimentación del LED y su resistencia; al cortar la corriente con el interruptor, el LED no se apaga de golpe, sino poco a poco a medida que se descarga el condensador. La resistencia y la capacidad determinan juntas la duración.
• Sensores capacitivos: Un sensor capacitivo de humedad del suelo mide la capacidad que cambia con el agua de la tierra; como sus electrodos no quedan expuestos, no se corroe.
• Capacímetro sencillo: Combina el experimento anterior con una pantalla LCD I2C y muestra en ella el valor de tus condensadores.

Errores frecuentes y cómo solucionarlos

• Pensar que 104 son 104 µF: 104 son 100 nF; los códigos de tres cifras siempre están en picofaradios.
• Montar un electrolítico al revés: El condensador se calienta, se hincha o revienta; la patilla de la franja va al lado de GND (en el tantalio, la franja es el positivo).
• Elegir una tensión máxima demasiado baja: Un condensador de 10 V en una línea de 12 V falla pronto; deja un margen de al menos 1,5 a 2 veces.
• Colocar lejos el condensador de desacoplo: A 10 cm del chip, un 100 nF pierde su efecto por la inductancia del cable; mantén las patillas cortas y ponlo pegado a los pines de alimentación.
• El Arduino se reinicia al arrancar un motor: La tensión de alimentación cae un instante; alimenta el motor por separado, añade 100–470 µF a la alimentación y une las masas (¿Por qué se reinicia mi Arduino?).
• Error "Failed to connect to ESP32: Timed out waiting for packet header" en el ESP32: En algunas placas el circuito de programación automática no acierta con los tiempos; añadir un condensador de 1–10 µF entre EN y GND suele eliminar la necesidad de pulsar el botón BOOT.

Después de la resistencia y el LED, el condensador es la pieza más fundamental que debes aprender; en cuanto entiendas τ = R·C y te acostumbres a poner 100 nF junto a cada chip, tus circuitos funcionarán mucho más estables. Como siguiente paso, puedes pasar a la bobina en ¿Qué es una bobina?. En la app BlueGrays encontrarás proyectos de control de LED con pulsador, medida de luz con LDR, atenuación de LED con PWM y WS2812B con esquemas y código paso a paso, para que pruebes enseguida en circuitos reales lo que has aprendido sobre condensadores.