Fundamentos de circuitos: serie, paralelo, Kirchhoff y condensadores

En el capítulo 2 trabajamos con una sola resistencia colgada de una sola fuente. Con la ley de Ohm y la fórmula de potencia bastaba: una tensión, una corriente, un componente. El problema es que ningún circuito real tiene un solo componente. En cuanto conectas un LED con su resistencia, un botón con su pull-up y un sensor con su filtro, la pregunta deja de ser “¿cuánta corriente pasa?” y pasa a ser “¿cuánta corriente pasa por cada rama, y qué tensión aparece en cada punto?”.

Este capítulo responde esa pregunta. Vamos a construir, en orden, las herramientas que permiten analizar cualquier circuito de corriente continua: primero el vocabulario (nodo, rama, malla, circuito abierto y cerrado), después las dos formas de conectar componentes (serie y paralelo), después las dos leyes de Kirchhoff que generalizan todo, y finalmente los dos patrones que más vas a usar en robótica e IoT: el divisor de tensión y la red RC con un condensador. Cerramos con lo práctico: cómo se ve todo eso en una protoboard, cómo se dibuja en un esquemático y cómo se verifica en un simulador antes de gastar componentes. Y como este es un curso de Elixir, escribimos un módulo que hace todos los cálculos por nosotros.

El vocabulario mínimo: abierto, cerrado y cortocircuito

Un circuito es un camino conductor cerrado por el que puede circular corriente desde un terminal de la fuente hasta el otro. Esa definición tiene tres estados posibles y conviene tenerlos claros antes de seguir.

Un circuito cerrado tiene el camino completo. La corriente circula, los componentes hacen su trabajo, hay una caída de tensión en cada uno y la suma de esas caídas es igual a la tensión de la fuente. Es el estado normal de funcionamiento.

Un circuito abierto tiene el camino interrumpido: un interruptor apagado, un cable suelto, una pista de PCB cortada, una resistencia quemada. La corriente es cero. La consecuencia menos intuitiva es que en un circuito abierto la tensión completa de la fuente aparece a través de la interrupción. Si mides con el multímetro entre los dos lados de un interruptor abierto en un circuito de 9 V, vas a leer 9 V, no 0 V. La razón: si no hay corriente, no hay caída en las resistencias (Ohm: V = I × R = 0 × R = 0), así que toda la tensión tiene que caer en el único elemento que no conduce.

Un cortocircuito es lo contrario: un camino de resistencia casi nula que puentea un componente o, en el peor caso, une los dos terminales de la fuente directamente. Por Ohm, I = V / R con R tendiendo a cero da una corriente que tiende a infinito. En la práctica la limita la resistencia interna de la fuente y la de los cables, y el resultado es calor: cables que se derriten, baterías LiPo que se hinchan, reguladores que entran en protección térmica o mueren. Todo circuito alimentado por una fuente capaz de dar corriente alta necesita un fusible, un limitador o una fuente con protección.

flowchart LR
    subgraph cerrado["Circuito cerrado"]
        direction LR
        F1["Fuente 9 V"] --> S1["Interruptor ON"] --> R1["R = 470 ohm"] --> G1["Retorno GND"] --> F1
    end
    subgraph abierto["Circuito abierto"]
        direction LR
        F2["Fuente 9 V"] --> S2["Interruptor OFF<br/>9 V a traves de el"] -.->|"I = 0"| R2["R = 470 ohm<br/>0 V de caida"] --> G2["Retorno GND"] --> F2
    end
    subgraph corto["Cortocircuito"]
        direction LR
        F3["Fuente 9 V"] --> X3["Cable de 0,02 ohm"] --> G3["Retorno GND"] --> F3
        X3 -.->|"I muy alta = calor"| X3
    end

Sobre esa base aparecen los cuatro términos que estructuran todo el análisis:

Término	Definición	Cómo identificarlo en un dibujo
Nodo	Punto de unión de dos o más componentes. Todo el cobre conectado sin componentes en medio es un solo nodo, aunque el dibujo lo estire por media hoja	Sigue una línea del esquemático; mientras no cruces un componente, sigues en el mismo nodo
Nodo esencial	Nodo donde se unen tres o más ramas	Es donde la corriente realmente se reparte
Rama	Camino entre dos nodos esenciales que lleva una única corriente	Un componente, o varios en serie sin derivaciones
Malla	Camino cerrado que vuelve al punto de partida sin pasar dos veces por el mismo nodo	Es un “hueco” del circuito, como el marco de una ventana

La propiedad clave del nodo: todos los puntos de un mismo nodo están al mismo potencial. Si mides con el multímetro dos puntos del mismo nodo, lees 0 V. Esto es lo que hace legibles los esquemáticos y lo que hace que la protoboard funcione, porque una fila de la protoboard es, literalmente, un nodo.

Conexión en serie

Dos componentes están en serie cuando comparten un nodo al que no llega ninguna otra rama. Es decir, la corriente que sale de uno no tiene otro lugar adonde ir que entrar en el siguiente. De ahí la primera regla:

En una conexión serie, la corriente es la misma en todos los componentes.

Y de ahí, aplicando la ley de Ohm a cada resistencia, la segunda:

La tensión de la fuente se reparte entre los componentes, en proporción a su resistencia.

La resistencia equivalente de un conjunto en serie es la suma:

R_total = R1 + R2 + R3 + ... + Rn

Ejemplo numérico completo

Fuente de 9 V con tres resistencias en serie: R1 = 220 Ω, R2 = 330 Ω, R3 = 470 Ω.

1. Resistencia total: 220 + 330 + 470 = 1020 Ω.
2. Corriente (la misma en las tres): I = 9 / 1020 = 0,008824 A = 8,82 mA.
3. Caída en cada una:
   • V1 = 0,008824 × 220 = 1,941 V
   • V2 = 0,008824 × 330 = 2,912 V
   • V3 = 0,008824 × 470 = 4,147 V
4. Comprobación: 1,941 + 2,912 + 4,147 = 9,000 V. La suma da exactamente la tensión de la fuente, y eso no es casualidad: es la segunda ley de Kirchhoff, que veremos en un momento.
5. Potencia total: P = 9 × 0,008824 = 79,4 mW. La mayor la disipa R3: 4,147 × 0,008824 = 36,6 mW. Todas caben de sobra en resistencias de 1/4 W (250 mW).

flowchart LR
    V["Fuente<br/>9 V"] -->|"I = 8,82 mA"| A(( ))
    A --> R1["R1 = 220 ohm<br/>cae 1,941 V"]
    R1 --> B(( ))
    B --> R2["R2 = 330 ohm<br/>cae 2,912 V"]
    R2 --> C(( ))
    C --> R3["R3 = 470 ohm<br/>cae 4,147 V"]
    R3 --> G["GND"]
    G --> V
    A -.->|"mismo I en toda la rama"| C

Qué implica la serie en la práctica

• Los LED no se conectan en serie con la misma resistencia sin pensar. Si pones dos LED rojos (≈1,8 V cada uno) en serie con una fuente de 3,3 V, quedan 3,6 V de caída necesaria contra 3,3 V disponibles: no encienden. Con 5 V sí funciona, y la resistencia limitadora se calcula sobre el sobrante: (5 − 3,6) / 0,010 = 140 Ω.
• Un interruptor va siempre en serie con lo que controla: al abrirlo, corta la única corriente que existe en esa rama.
• El multímetro en modo amperímetro se conecta en serie, porque tiene que ser atravesado por la corriente que quiere medir. Es el error clásico del capítulo anterior: ponerlo en paralelo con la fuente equivale a un cortocircuito a través del fusible del instrumento.
• Las resistencias en serie suman potencia de disipación. Si necesitas disipar 1 W y solo tienes resistencias de 1/4 W, cuatro de ellas en serie (con un cuarto del valor cada una) reparten la disipación.

Conexión en paralelo

Dos componentes están en paralelo cuando comparten ambos nodos: los dos extremos están unidos. La consecuencia inmediata:

En una conexión paralelo, la tensión es la misma en todos los componentes.

Y como cada rama ve la misma tensión pero puede tener distinta resistencia, cada una toma su propia corriente:

La corriente total de la fuente es la suma de las corrientes de las ramas.

La resistencia equivalente sale de sumar conductancias (el inverso de la resistencia):

1 / R_eq = 1/R1 + 1/R2 + ... + 1/Rn

Para el caso de dos resistencias existe la forma corta, muy usada de memoria:

R_eq = (R1 × R2) / (R1 + R2)      "producto sobre suma"

Ejemplo numérico completo

Fuente de 9 V con R1 = 220 Ω y R2 = 330 Ω en paralelo.

1. Cada resistencia ve los 9 V completos.
2. I1 = 9 / 220 = 40,91 mA
3. I2 = 9 / 330 = 27,27 mA
4. Corriente total: 40,91 + 27,27 = 68,18 mA
5. Resistencia equivalente: 9 / 0,06818 = 132 Ω. Por producto sobre suma: (220 × 330) / 550 = 72600 / 550 = 132 Ω. Coinciden.

Fíjate en el resultado: 132 Ω es menor que la más pequeña de las dos. Siempre ocurre. Añadir una rama en paralelo es abrir otro camino para la corriente, así que la oposición total baja. Como regla mental: dos resistencias iguales en paralelo dan la mitad del valor; tres iguales, un tercio.

flowchart LR
    V["Fuente 9 V"] -->|"I total = 68,18 mA"| N1(("Nodo A<br/>9 V"))
    N1 -->|"I1 = 40,91 mA"| R1["R1 = 220 ohm"]
    N1 -->|"I2 = 27,27 mA"| R2["R2 = 330 ohm"]
    R1 --> N2(("Nodo B<br/>0 V"))
    R2 --> N2
    N2 -->|"vuelve 68,18 mA"| V

Qué implica el paralelo en la práctica

• Todo lo que alimentas desde una misma fuente está en paralelo con ella. El microcontrolador, el sensor, el módulo de radio: todos ven los mismos 3,3 V y cada uno consume lo suyo. Por eso el dimensionamiento de una fuente es una suma de corrientes, no de tensiones.
• El multímetro en modo voltímetro se conecta en paralelo con el componente cuya caída quieres medir.
• Un condensador de desacoplo se pone en paralelo con la alimentación del chip, lo más cerca posible de sus pines.
• Dos resistencias en paralelo permiten valores que no existen en el cajón. ¿Necesitas 75 Ω y solo tienes de 100 Ω? Dos de 150 Ω en paralelo dan 75 Ω exactos.

Circuitos mixtos: la técnica de reducción

Casi ningún circuito real es puramente serie o puramente paralelo. La técnica es siempre la misma: identificar el bloque más interno que sea claramente serie o paralelo, reducirlo a una resistencia equivalente, y repetir hasta quedarse con una sola resistencia y una sola fuente. Después se “des-reduce” hacia atrás para recuperar las tensiones y corrientes individuales.

Tomemos: fuente de 12 V, R1 = 1 kΩ en serie con el paralelo de R2 = 2 kΩ y R3 = 3 kΩ.

flowchart TD
    P0["Circuito original<br/>12 V, R1 = 1k en serie con R2 = 2k paralelo R3 = 3k"]
    P1["Paso 1 - reducir el paralelo<br/>R23 = 2k x 3k / 5k = 1,2 k"]
    P2["Paso 2 - sumar la serie<br/>Rt = 1k + 1,2k = 2,2 k"]
    P3["Paso 3 - corriente total<br/>I = 12 / 2200 = 5,4545 mA"]
    P4["Paso 4 - repartir tensiones<br/>V_R1 = 5,4545 V<br/>V_R23 = 6,5455 V"]
    P5["Paso 5 - abrir el paralelo<br/>I2 = 6,5455 / 2000 = 3,2727 mA<br/>I3 = 6,5455 / 3000 = 2,1818 mA"]
    P6["Verificacion<br/>3,2727 + 2,1818 = 5,4545 mA"]
    P0 --> P1 --> P2 --> P3 --> P4 --> P5 --> P6

El paso 6 es el que nunca hay que saltarse: toda reducción se verifica volviendo a sumar. Si las corrientes de las ramas no reconstruyen la corriente total, hay un error aritmético o un error de topología (creíste que dos componentes estaban en paralelo y no lo estaban).

Un truco para no equivocarse con la topología: en el esquemático, rotula los nodos con letras antes de calcular nada. Dos componentes están en paralelo si y solo si sus dos extremos tienen las mismas letras. Dos componentes están en serie si comparten una letra que no aparece en ningún tercer componente.

Las leyes de Kirchhoff

Serie y paralelo son casos particulares. Cuando el circuito tiene varias fuentes, o una topología que no se deja reducir (un puente, una malla cruzada), hace falta la artillería general: las dos leyes que Gustav Kirchhoff formuló en 1845 y que siguen siendo la base de todo simulador de circuitos, ngspice incluido.

Primera ley: de corrientes (KCL)

La suma algebraica de las corrientes que entran a un nodo es igual a la suma de las que salen. Equivalentemente: la suma de todas las corrientes de un nodo, con signo, es cero.

Es conservación de carga. La carga no se acumula en un punto de cable; lo que entra, sale. Si a un nodo llegan 25,9 mA por una rama y salen 19,4 mA por otra, la tercera rama tiene que llevarse los 6,5 mA restantes, en el sentido que sea.

Segunda ley: de tensiones (KVL)

Recorriendo cualquier malla cerrada y volviendo al punto de partida, la suma algebraica de las tensiones es cero. Las fuentes aportan, los componentes pasivos restan.

Es conservación de energía. Si vuelves al mismo punto, vuelves al mismo potencial; no puedes “ganar” tensión dando una vuelta. Esto es exactamente lo que comprobamos en el ejemplo serie: 1,941 + 2,912 + 4,147 = 9,000.

flowchart TB
    subgraph kcl["Primera ley - corrientes en el nodo A"]
        direction LR
        E1["Entra I1 = 25,862 mA"] --> NA(("Nodo A"))
        E2["Entra I2 = -6,426 mA<br/>(el signo dice que en realidad sale)"] --> NA
        NA --> S1["Sale I3 = 19,436 mA"]
    end
    subgraph kvl["Segunda ley - malla izquierda"]
        direction LR
        M1["Fuente V1 = +9 V"] --> M2["Caida en R1 = -2,586 V"] --> M3["Caida en R3 = -6,414 V"] --> M4["Suma = 0 V"]
    end

Un circuito de dos fuentes resuelto paso a paso

Este circuito no se reduce con serie/paralelo, porque tiene dos fuentes empujando contra el mismo nodo:

• Fuente V1 = 9 V a través de R1 = 100 Ω hasta el nodo A.
• Fuente V2 = 5 V a través de R2 = 220 Ω hasta el mismo nodo A.
• Desde el nodo A, R3 = 330 Ω hacia GND.
• Ambas fuentes tienen su terminal negativo en GND.

Método 1 — análisis de mallas con KVL. Definimos I1 como la corriente que entra al nodo A desde V1, e I2 como la que entra desde V2. Por KCL, la corriente que baja por R3 es I1 + I2. Escribimos KVL en las dos mallas:

Malla 1:  9 = 100·I1 + 330·(I1 + I2)   →   430·I1 + 330·I2 = 9
Malla 2:  5 = 220·I2 + 330·(I1 + I2)   →   330·I1 + 550·I2 = 5

Resolvemos por determinantes (regla de Cramer):

det   = 430·550 − 330·330 = 236500 − 108900 = 127600
I1    = (9·550 − 330·5) / 127600 = (4950 − 1650) / 127600 =  3300 / 127600 =  25,862 mA
I2    = (430·5 − 9·330) / 127600 = (2150 − 2970) / 127600 =  −820 / 127600 =  −6,426 mA
I3    = I1 + I2 = 19,436 mA

El signo negativo de I2 es información, no un error. Significa que la corriente circula al revés de como la supusimos: en vez de entrar al nodo A desde V2, sale del nodo A hacia V2. La fuente de 5 V no está entregando energía, la está recibiendo, porque el nodo A está a 6,41 V, por encima de sus 5 V. Si V2 fuera una batería recargable, se estaría cargando. Esta es una de las razones para hacer el análisis antes de conectar: dos fuentes de distinta tensión unidas a un mismo nodo se empujan entre sí.

Método 2 — análisis nodal con KCL. Mucho más corto. Llamamos Va a la tensión del nodo A y escribimos que todo lo que entra sale:

(9 − Va)/100 + (5 − Va)/220 = Va/330

Multiplicando por 6600 (mínimo común múltiplo):

66·(9 − Va) + 30·(5 − Va) = 20·Va
594 − 66·Va + 150 − 30·Va = 20·Va
744 = 116·Va
Va = 6,4138 V

Y desde ahí, cada corriente sale directa por Ohm:

I1 = (9 − 6,4138)/100 =  25,862 mA
I2 = (5 − 6,4138)/220 =  −6,426 mA
I3 =      6,4138/330  =  19,436 mA

Idénticos. Para circuitos con muchas ramas que llegan a pocos nodos, el análisis nodal genera menos ecuaciones y es el que usan internamente los simuladores.

El divisor de tensión

De todos los circuitos que vas a ver en robótica e IoT, el más frecuente es este: dos resistencias en serie entre una tensión y GND, con la salida tomada del punto medio.

flowchart TB
    VIN["V_in"] --> R1["R1<br/>resistencia superior"]
    R1 --> OUT(("V_out<br/>nodo medio"))
    OUT --> R2["R2<br/>resistencia inferior"]
    R2 --> GND["GND"]
    OUT -->|"a la entrada ADC<br/>o al pin GPIO"| CARGA["Carga R_L"]
    CARGA --> GND

Aplicando lo de la sección serie: la corriente es V_in / (R1 + R2) y la caída en R2 es esa corriente por R2. Reordenando:

V_out = V_in × R2 / (R1 + R2)

La fórmula solo depende de la proporción entre las resistencias, no de sus valores absolutos. 1 kΩ / 2 kΩ y 10 kΩ / 20 kΩ dan la misma salida. Lo que cambia es la corriente que consume el divisor permanentemente.

Ejemplo: leer una batería de 12 V con un ADC de 3,3 V

El ADC de un ESP32 o de una Raspberry Pi con conversor externo no tolera más de 3,3 V. Queremos medir hasta 12 V.

Necesitamos que 12 × R2/(R1+R2) ≤ 3,3, es decir una relación R2/(R1+R2) ≤ 0,275. Con valores de la serie E12, R1 = 10 kΩ y R2 = 3,6 kΩ:

V_out = 12 × 3600 / 13600 = 3,176 V

Queda 124 mV de margen bajo el límite, suficiente para tolerar la tolerancia del 5 % de las resistencias solo si eliges resistencias del 1 %. Con resistencias del 5 % el peor caso (R1 en su valor mínimo y R2 en el máximo) da 12 × 3780 / (9500 + 3780) = 3,416 V, por encima del límite. La tolerancia importa en los divisores que protegen entradas.

La corriente en reposo del divisor es 12 / 13600 = 0,88 mA. Eso son 10,6 mW quemados de forma permanente, incluso con el microcontrolador dormido. En un nodo IoT a batería es inaceptable: con 13,6 kΩ el divisor solo consume 7,7 Ah al año. La solución habitual es subir las resistencias (100 kΩ / 36 kΩ da 88 µA) o conmutar el divisor con un MOSFET que solo lo conecte al momento de medir.

El efecto de la carga: el error que todos cometen una vez

La fórmula del divisor asume que no sale corriente por el nodo medio. En cuanto conectas algo que consume, ese algo queda en paralelo con R2 y la salida baja.

Divisor R1 = 1 kΩ, R2 = 2 kΩ, V_in = 5 V. Sin carga: V_out = 5 × 2000/3000 = 3,333 V.

Ahora conectamos una carga de R_L = 10 kΩ:

R2 ∥ R_L = (2000 × 10000) / 12000 = 1666,7 Ω
V_out    = 5 × 1666,7 / (1000 + 1666,7) = 5 × 0,625 = 3,125 V

La salida cayó un 6,2 %. De ahí la regla práctica:

Regla del 10×: la resistencia de la carga debe ser al menos 10 veces mayor que la resistencia inferior del divisor. Con eso el error queda bajo el 1 % aproximadamente. Si no puedes garantizarlo, no uses un divisor: usa un amplificador operacional como seguidor de tensión (buffer), que presenta una impedancia de entrada altísima.

Este es el motivo por el que un divisor de tensión no sirve como fuente de alimentación. Alimentar un módulo de 3,3 V que consume 80 mA desde 5 V con un divisor es imposible: la carga equivalente es de 41 Ω, aplastaría el divisor, y además cualquier variación de consumo del módulo movería la tensión. Para eso existen los reguladores lineales y los conversores conmutados, que veremos más adelante. El divisor sirve para señales, no para potencia.

Divisor de corriente

El dual del divisor de tensión. Dos resistencias en paralelo reparten una corriente que entra al nodo, y la rama con menos resistencia se lleva más corriente:

I1 = I_total × R2 / (R1 + R2)

Ojo con el cruce: la corriente por R1 depende de R2. Es intuitivo si lo piensas al revés: si R2 es enorme, casi toda la corriente se va por R1.

Condensadores

Una resistencia se opone a la corriente. Un condensador se opone al cambio de tensión. Físicamente son dos placas conductoras separadas por un aislante (el dieléctrico): la corriente no atraviesa el condensador, pero al aplicar tensión se acumula carga en una placa y se retira de la otra, y ese movimiento de carga es una corriente mientras dura.

La ecuación fundamental relaciona carga, capacidad y tensión:

Q = C × V          Q en coulombs, C en faradios, V en voltios

Y la relación dinámica, la que explica todo su comportamiento:

I = C × (dV/dt)

Léela así: la corriente por un condensador es proporcional a la velocidad con que cambia su tensión. Si la tensión es constante (corriente continua estable), dV/dt = 0 y la corriente es cero: el condensador se comporta como un circuito abierto. Si la tensión intenta cambiar de golpe, dV/dt es enorme y el condensador exige (o entrega) una corriente enorme para permitirlo. Por eso un condensador cargado que se cortocircuita suelta una chispa.

La energía almacenada:

E = ½ × C × V²        en julios

Unidades y códigos de marcado

El faradio es una unidad gigantesca, así que en la práctica se trabaja con submúltiplos:

Unidad	Símbolo	En faradios	Rango típico de uso
Picofaradio	pF	10⁻¹² F	Osciladores de cristal, compensación de RF
Nanofaradio	nF	10⁻⁹ F	Desacoplo, filtros de señal, antirrebote
Microfaradio	µF	10⁻⁶ F	Reservas de energía, filtrado de fuentes
Milifaradio	mF	10⁻³ F	Poco usado; se escribe como miles de µF
Faradio	F	1 F	Supercondensadores, respaldo de reloj

Equivalencias que conviene memorizar: 1 µF = 1000 nF = 1 000 000 pF. Y 0,1 µF = 100 nF, que es el valor de desacoplo más usado del planeta.

Los condensadores cerámicos pequeños no traen el valor escrito en claro, sino un código de tres cifras en picofaradios, donde la tercera cifra es el número de ceros:

Marca impresa	Cálculo	Valor	Equivalente
104	10 × 10⁴ pF	100 000 pF	100 nF = 0,1 µF
105	10 × 10⁵ pF	1 000 000 pF	1 µF
223	22 × 10³ pF	22 000 pF	22 nF
102	10 × 10² pF	1 000 pF	1 nF
470	47 × 10⁰ pF	47 pF	47 pF

Cuidado con el último caso: 470 son 47 pF, no 470 pF. Para 470 pF la marca sería 471.

Tipos de condensador y cuándo usar cada uno

Tipo	Rango típico	Polarizado	Fortaleza	Debilidad	Uso habitual
Cerámico MLCC	1 pF – 10 µF	No	ESR muy baja, respuesta rápida, barato	Pierde capacidad con la tensión aplicada y con la temperatura (los Y5V, hasta un 80 %)	Desacoplo junto a cada chip, filtros
Electrolítico de aluminio	1 µF – 10 000 µF	Sí	Mucha capacidad por peso y precio	ESR alta, se seca con los años, explota si se invierte	Reserva de energía en fuentes, filtrado de rizado
Tántalo	0,1 µF – 470 µF	Sí	Muy compacto, estable	Falla en cortocircuito y puede arder; caro	Reguladores en placas compactas
Film (poliéster, polipropileno)	1 nF – 10 µF	No	Muy estable y preciso, tolera picos	Voluminoso	Filtros de audio, temporización precisa
Supercondensador	0,1 F – 100 F	Sí	Capacidad enorme	Tensión máxima muy baja (2,5 – 2,7 V), fuga alta	Respaldo de reloj de tiempo real, apagado ordenado

Dos reglas de selección que evitan la mayoría de los accidentes:

1. La tensión nominal debe ser al menos el doble de la tensión de trabajo. Un condensador de 6,3 V en un riel de 5 V está al límite y envejecerá rápido; usa uno de 16 V o 25 V.
2. Los polarizados tienen un sentido obligatorio. La banda impresa en el cuerpo marca el negativo; la pata larga es el positivo. Invertirlo en un electrolítico produce, en cuestión de segundos, un olor característico y una carcasa reventada.

Condensadores en serie y en paralelo

Aquí las fórmulas están invertidas respecto a las resistencias, y es una de las confusiones más comunes:

Paralelo:  C_eq = C1 + C2 + ... + Cn         (se suman)
Serie:     1/C_eq = 1/C1 + 1/C2 + ... + 1/Cn (inversos)

Tiene sentido físico: poner dos condensadores en paralelo es como agrandar las placas, así que cabe más carga. Ponerlos en serie es como alejar las placas, así que cabe menos, pero cada uno soporta parte de la tensión (dos de 100 nF y 25 V en serie dan 50 nF a 50 V).

La constante de tiempo RC

Este es el concepto que hay que dominar. Una resistencia en serie con un condensador forma una red RC, y su comportamiento se describe con un solo número, la constante de tiempo tau:

τ = R × C        con R en ohmios y C en faradios, τ sale en segundos

Al aplicar una tensión V_cc a la red, el condensador se carga siguiendo una exponencial:

V(t) = V_cc × (1 − e^(−t/τ))

Y al descargarse a través de la misma resistencia:

V(t) = V_inicial × e^(−t/τ)

Lo importante es la tabla de referencia, porque en la práctica nadie calcula exponenciales de memoria:

Tiempo transcurrido	Tensión en carga	Tensión en descarga
1 τ	63,2 %	36,8 %
2 τ	86,5 %	13,5 %
3 τ	95,0 %	5,0 %
4 τ	98,2 %	1,8 %
5 τ	99,3 %	0,7 %

Regla de las 5 tau: a efectos prácticos, un condensador se considera completamente cargado (o descargado) tras cinco constantes de tiempo.

Ejemplo: R = 10 kΩ, C = 10 µF. τ = 10 000 × 0,00001 = 0,1 s. El condensador alcanza el 63 % en 100 ms y está prácticamente cargado en 500 ms. Si quieres un parpadeo perceptible, esos son los órdenes de magnitud.

stateDiagram-v2
    [*] --> Descargado: alimentacion apagada
    Descargado --> Cargando: se cierra el interruptor
    Cargando --> Cargando: I = C x dV/dt<br/>la corriente decae mientras sube V
    Cargando --> Cargado: han pasado 5 tau<br/>V = 99,3 % de Vcc
    Cargado --> Cargado: I = 0<br/>se comporta como circuito abierto
    Cargado --> Descargando: se abre la fuente y se cierra el camino a GND
    Descargando --> Descargado: 5 tau despues<br/>V = 0,7 % del inicial
    Cargado --> [*]: cortocircuito accidental<br/>I muy alta, chispa

La red RC como filtro pasa bajos

Si en vez de un escalón aplicas una señal que varía, la red RC deja pasar lo lento y atenúa lo rápido. La frontera se llama frecuencia de corte:

f_c = 1 / (2 × π × R × C)        en hercios

Con R = 10 kΩ y C = 100 nF: f_c = 1 / (6,2832 × 10⁴ × 10⁻⁷) = 159 Hz. Todo lo que oscile por debajo de 159 Hz pasa casi intacto; por encima, se atenúa a razón de 20 dB por década. Esto es exactamente lo que se pone delante de la entrada de un ADC para que el ruido eléctrico del motor de al lado no ensucie las lecturas del sensor de temperatura.

Los tres usos que vas a repetir siempre

1. Desacoplo. Un condensador de 100 nF entre VCC y GND, físicamente pegado a los pines de alimentación de cada chip. Cuando el microcontrolador conmuta miles de transistores a la vez, pide un pico de corriente que los cables de alimentación, por su inductancia, no pueden entregar instantáneamente. El condensador local sí puede, porque está a milímetros. Sin él aparecen reinicios espurios y comunicaciones I2C que fallan de forma aleatoria. Es el componente más barato y el que más problemas evita.

2. Reserva o bulk. Un electrolítico de 100 µF o más a la entrada del regulador, para absorber los picos grandes: el arranque de un motor, la transmisión de un módulo WiFi (un ESP32 puede pedir 500 mA durante unos milisegundos al transmitir). Sin él, la tensión del riel se hunde y el microcontrolador se resetea justo cuando envía datos, un síntoma clásico y desconcertante.

3. Antirrebote (debounce). Un pulsador mecánico no cierra limpio: las láminas rebotan y generan decenas de transiciones en 1 a 20 ms. Una red RC con R = 10 kΩ y C = 100 nF (τ = 1 ms) suaviza esos rebotes hasta que el pin del microcontrolador ve una sola transición.

sequenceDiagram
    participant B as Pulsador mecanico
    participant RC as Red RC 10k + 100nF
    participant P as Pin GPIO
    participant N as Proceso Elixir
    B->>RC: cierre con 8 rebotes en 3 ms
    Note over RC: tau = 1 ms<br/>la tension no alcanza a seguir<br/>cada rebote individual
    RC->>P: una sola transicion limpia de alto a bajo
    P->>N: mensaje {:circuits_gpio, spec, timestamp, 0}
    N->>N: descarta eventos a menos de 20 ms<br/>del anterior (segunda barrera, en software)
    N->>N: emite :boton_presionado una unica vez

En la práctica se usan las dos barreras: la RC filtra el grueso del ruido eléctrico y el software descarta los eventos demasiado cercanos en el tiempo. Así se ve el filtro en software con Circuits.GPIO, la biblioteca estándar del ecosistema Nerves:

defmodule Boton do
  @moduledoc """
  Vigila un pulsador conectado a un pin GPIO con resistencia pull-up interna.
  El pulsador une el pin a GND, asi que el estado en reposo es 1 y presionado es 0.
  El filtro descarta transiciones separadas por menos de @ventana_ms.
  """
  use GenServer
  require Logger

  @ventana_ms 20

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  @impl true
  def init(opts) do
    spec = Keyword.fetch!(opts, :spec)
    destino = Keyword.get(opts, :destino, self())

    {:ok, gpio} = Circuits.GPIO.open(spec, :input, pull_mode: :pullup)
    :ok = Circuits.GPIO.set_interrupts(gpio, :both)

    {:ok, %{gpio: gpio, destino: destino, ultimo_ns: 0, estado: Circuits.GPIO.read(gpio)}}
  end

  @impl true
  def handle_info({:circuits_gpio, _spec, timestamp_ns, valor}, estado) do
    # El timestamp llega en nanosegundos de reloj monotonico.
    delta_ms = div(timestamp_ns - estado.ultimo_ns, 1_000_000)

    cond do
      delta_ms < @ventana_ms ->
        # Rebote: mismo evento fisico, lo ignoramos.
        {:noreply, estado}

      valor == estado.estado ->
        # Sin cambio real de nivel, no hay nada que reportar.
        {:noreply, %{estado | ultimo_ns: timestamp_ns}}

      true ->
        evento = if valor == 0, do: :boton_presionado, else: :boton_soltado
        send(estado.destino, evento)
        Logger.debug("Evento de boton: #{evento}")
        {:noreply, %{estado | ultimo_ns: timestamp_ns, estado: valor}}
    end
  end

  @impl true
  def terminate(_razon, %{gpio: gpio}) do
    Circuits.GPIO.close(gpio)
    :ok
  end
end

Las funciones usadas son las reales de Circuits.GPIO: open/3 con el identificador del pin y las opciones, set_interrupts/2 para recibir mensajes ante cambios de nivel, read/1 para leer el estado actual y close/1 para liberar el recurso. El formato del mensaje que llega al proceso es {:circuits_gpio, identificador, timestamp, valor}. El identificador del pin cambia según la versión de la biblioteca y la plataforma (puede ser un número, una cadena como "GPIO18" o una tupla de chip y línea), por eso lo recibimos como parámetro :spec en vez de escribirlo dentro del módulo.

La protoboard: cómo está cableada por dentro

La protoboard (o breadboard) es una matriz de contactos metálicos con resortes internos que permiten armar circuitos sin soldar. Toda su utilidad y todos sus problemas vienen de entender qué agujeros están unidos entre sí, porque cada grupo unido es un nodo.

Una protoboard estándar de 830 puntos tiene:

• Cuatro buses longitudinales (las tiras marcadas con líneas roja y azul, dos arriba y dos abajo). Todos los agujeros de una misma tira están unidos a lo largo. Se usan para VCC y GND.
• Dos bloques centrales de filas, separados por un canal. Cada fila tiene cinco agujeros unidos entre sí, y las filas están numeradas y separadas 2,54 mm (una décima de pulgada, el paso estándar de los componentes DIP).
• El canal central no conduce. Su ancho está pensado para que un circuito integrado DIP se monte a caballo, con cada fila de patas en un bloque distinto, de modo que las patas enfrentadas no queden cortocircuitadas.

flowchart TB
    subgraph bus_sup["Buses superiores - un nodo cada tira completa"]
        VCCS["Tira roja: VCC, todos los agujeros unidos a lo largo"]
        GNDS["Tira azul: GND, todos los agujeros unidos a lo largo"]
    end
    subgraph bloque_a["Bloque superior de filas - columnas a b c d e"]
        F1["Fila 1: a1 b1 c1 d1 e1 unidos entre si"]
        F2["Fila 2: a2 b2 c2 d2 e2 unidos entre si"]
        F3["Fila 3: a3 b3 c3 d3 e3 unidos entre si"]
    end
    CANAL["CANAL CENTRAL - aislante, aqui va el integrado DIP"]
    subgraph bloque_b["Bloque inferior de filas - columnas f g h i j"]
        G1["Fila 1: f1 g1 h1 i1 j1 unidos entre si"]
        G2["Fila 2: f2 g2 h2 i2 j2 unidos entre si"]
        G3["Fila 3: f3 g3 h3 i3 j3 unidos entre si"]
    end
    subgraph bus_inf["Buses inferiores"]
        VCCI["Tira roja"]
        GNDI["Tira azul"]
    end
    bus_sup --> bloque_a --> CANAL --> bloque_b --> bus_inf
    F1 -.->|"NO estan unidas:<br/>el canal separa"| G1
    F1 -.->|"NO estan unidas:<br/>filas distintas"| F2

De ese mapa se deducen las reglas de uso:

• Dos componentes están en serie si comparten una fila y ninguna otra cosa entra en esa fila.
• Dos componentes están en paralelo si sus dos extremos comparten las mismas dos filas.
• Cada fila da cinco agujeros, uno ocupado por el componente: quedan cuatro para derivaciones. Si necesitas más nodos en un punto, usa un puente a una fila libre.
• Puentea siempre los buses de arriba con los de abajo si vas a usar los dos lados, y en muchas protoboards los buses están partidos por la mitad: fíjate si la línea roja tiene una interrupción a mitad de la placa. Si la tiene y no la puenteas, la mitad derecha de tu circuito simplemente no tendrá alimentación, y perderás una hora buscando el error en otro lado.

Limitaciones reales de la protoboard

Limitación	Valor típico	Consecuencia
Corriente máxima por contacto	1 A (algunas menos)	No sirve para motores medianos ni para cargas de potencia
Resistencia de contacto	10 a 100 mΩ por punto, y crece con el uso	Caídas de tensión inexplicables en circuitos con corriente alta
Capacitancia parásita entre filas vecinas	2 a 5 pF	Falla en señales de alta frecuencia y en osciladores
Inductancia de los cables largos	Decenas de nH	Ruido en conmutación rápida; por eso el desacoplo va corto
Fatiga mecánica	Cientos de inserciones	Los contactos ceden y aparecen fallos intermitentes

Las intermitencias de protoboard son la causa número uno de “mi circuito funcionaba ayer”. Antes de reescribir código, presiona los cables, cambia de fila y verifica continuidad con el multímetro. Un cable de calibre incorrecto (AWG 26 o más fino) agranda el contacto y deja de hacer presión: usa cable rígido AWG 22, que es el calibre para el que está diseñada la protoboard.

Leer y escribir esquemáticos

El dibujo de la protoboard sirve para armar; el esquemático sirve para pensar. Un esquemático no representa posiciones físicas: representa conexiones lógicas, es decir, nodos. Dos cables que se cruzan en el dibujo no están conectados a menos que haya un punto grueso (una “junta”) en el cruce.

Las convenciones que hacen legible un esquemático son pocas y valen la pena:

• La alimentación va arriba, la masa abajo. La corriente “cae” visualmente de VCC a GND.
• La señal fluye de izquierda a derecha: entradas a la izquierda, salidas a la derecha.
• Cada componente lleva un designador y un valor. R1 10k, C3 100n, D2 1N4148, U1 ESP32-WROOM. La letra indica la familia: R resistencia, C condensador, L inductor, D diodo, Q transistor, U circuito integrado, J conector, SW interruptor, Y cristal.
• Los símbolos de masa se repiten en vez de dibujar el cable. Todos los símbolos de GND del esquemático son el mismo nodo, aunque estén en esquinas opuestas de la hoja. Lo mismo con las etiquetas de red (SDA, SCL, +3V3): dos puntos con la misma etiqueta están conectados.
• Los condensadores de desacoplo se dibujan agrupados cerca del integrado que protegen, aunque en la placa vayan repartidos.

El flujo completo de trabajo, del papel al circuito que funciona:

flowchart LR
    IDEA["Idea del circuito<br/>que quiero lograr"] --> ESQ["Esquematico<br/>KiCad o papel"]
    ESQ --> CALC["Calculo a mano<br/>Ohm, Kirchhoff, divisor, tau"]
    CALC --> SIM["Simulacion<br/>ngspice, Falstad, LTspice"]
    SIM -->|"resultados coherentes"| PROTO["Montaje en protoboard"]
    SIM -->|"resultados absurdos"| ESQ
    PROTO --> MED["Medicion con multimetro<br/>tension en cada nodo"]
    MED -->|"coincide con el calculo"| CODIGO["Codigo Elixir / Nerves<br/>que controla el circuito"]
    MED -->|"no coincide"| DIAG["Diagnostico:<br/>fila equivocada, bus partido,<br/>polaridad invertida, contacto flojo"]
    DIAG --> PROTO
    CODIGO --> PCB["PCB definitiva"]

El paso que la gente se salta es el de medir cada nodo antes de escribir código. Si el divisor entrega 4,1 V donde esperabas 3,3 V, ningún ajuste de software lo va a arreglar, y peor: puede haber dañado la entrada del microcontrolador antes de que te enteres.

Simulación: verificar antes de conectar

Simular un circuito de continua tarda segundos y cuesta cero componentes quemados. Estas son las herramientas más usadas:

Herramienta	Tipo	Fortaleza	Cuándo usarla
Falstad Circuit Simulator	Web, interactivo	Anima la corriente en tiempo real; se entiende de inmediato	Aprender y verificar intuiciones sobre serie, paralelo y RC
ngspice	CLI, motor SPICE libre	Preciso, scriptable, se automatiza desde otro programa	Análisis reproducible y verificación numérica
LTspice	Escritorio, gratuito	Modelos de componentes reales muy completos	Diseño de fuentes y circuitos analógicos serios
KiCad	Suite de diseño libre	Esquemático + PCB + simulación con ngspice integrado	Cuando el circuito va a terminar en una placa fabricada
Wokwi	Web	Simula microcontroladores completos con periféricos	Probar firmware junto con el circuito
Tinkercad Circuits	Web	Protoboard virtual con aspecto realista	Enseñar el montaje físico antes de tocar la protoboard
Fritzing	Escritorio	Dibujos de protoboard muy claros	Documentar montajes para otros

Un ejemplo real con ngspice

SPICE describe circuitos con una netlist: una línea por componente, indicando entre qué nodos va. El nodo 0 es siempre la masa. Este archivo simula el divisor cargado del que hablamos antes:

* Divisor de tension 1k/2k desde 5 V, con y sin carga de 10k
V1  in   0   DC 5
R1  in   out 1k
R2  out  0   2k
RL  out  0   10k
.op
.end

Se ejecuta con ngspice divisor.cir y el comando .op (operating point) imprime la tensión de cada nodo y la corriente por la fuente. El resultado debe dar v(out) = 3,125 V, exactamente lo que calculamos a mano. Si comentas la línea de RL anteponiendo un asterisco, la salida sube a 3,333 V. Esa comparación, hecha en veinte segundos, es la mejor forma de interiorizar el efecto de la carga.

Para la red RC hace falta un análisis transitorio, porque queremos ver la evolución en el tiempo:

* Carga de un condensador: R = 10k, C = 10uF, tau = 0,1 s
V1  in  0   PULSE(0 5 0 1n 1n 1 2)
R1  in  out 10k
C1  out 0   10u IC=0
.tran 1m 500m UIC
.control
run
print v(out)
.endc
.end

La fuente PULSE(0 5 0 1n 1n 1 2) genera un escalón de 0 a 5 V con flancos de 1 nanosegundo, ancho de 1 segundo y periodo de 2 segundos: en la práctica, un escalón limpio. .tran 1m 500m UIC simula 500 ms con paso de 1 ms partiendo de las condiciones iniciales declaradas (UIC, use initial conditions). En la salida deberías encontrar que a los 100 ms la tensión ronda 3,16 V, es decir el 63,2 % de 5 V, tal como predice la tabla de tau.

Los cálculos del capítulo, en Elixir

Todo lo anterior son fórmulas que se aplican una y otra vez. Escribirlas una vez en un módulo evita errores aritméticos y, más importante, deja los cálculos versionados junto al firmware. Guarda esto como circuitos.exs y ejecútalo con elixir circuitos.exs.

defmodule Circuitos do
  @moduledoc """
  Calculos de circuitos resistivos y RC en corriente continua.
  Todas las funciones trabajan en unidades base del SI:
  ohmios, voltios, amperios, faradios y segundos.
  """

  @doc "Resistencia equivalente de una lista de resistencias en serie."
  def serie(resistencias) when is_list(resistencias), do: Enum.sum(resistencias)

  @doc "Resistencia equivalente de una lista de resistencias en paralelo."
  def paralelo([]), do: :infinito
  def paralelo([r]), do: r

  def paralelo(resistencias) when is_list(resistencias) do
    suma_inversos = Enum.reduce(resistencias, 0.0, fn r, acc -> acc + 1 / r end)
    1 / suma_inversos
  end

  @doc "Capacidad equivalente de condensadores en paralelo: se suman."
  def capacidad_paralelo(condensadores) when is_list(condensadores),
    do: Enum.sum(condensadores)

  @doc "Capacidad equivalente de condensadores en serie: suma de inversos."
  def capacidad_serie(condensadores) when is_list(condensadores) do
    suma_inversos = Enum.reduce(condensadores, 0.0, fn c, acc -> acc + 1 / c end)
    1 / suma_inversos
  end

  @doc "Ley de Ohm: corriente que circula por una resistencia."
  def corriente(tension, resistencia), do: tension / resistencia

  @doc "Potencia disipada a partir de tension y corriente."
  def potencia(tension, corriente), do: tension * corriente

  @doc "Potencia disipada por una resistencia conocida la corriente."
  def potencia_por_corriente(corriente, resistencia),
    do: corriente * corriente * resistencia

  @doc "Divisor de tension ideal, sin carga en la salida."
  def divisor(v_in, r1, r2), do: v_in * r2 / (r1 + r2)

  @doc "Divisor de tension con una carga conectada a la salida."
  def divisor_cargado(v_in, r1, r2, r_carga) do
    r_eq = paralelo([r2, r_carga])
    v_in * r_eq / (r1 + r_eq)
  end

  @doc "Error porcentual que introduce la carga en un divisor."
  def error_por_carga(v_in, r1, r2, r_carga) do
    ideal = divisor(v_in, r1, r2)
    real = divisor_cargado(v_in, r1, r2, r_carga)
    (real - ideal) / ideal * 100
  end

  @doc "Divisor de corriente: fraccion que se va por la rama r_rama."
  def divisor_corriente(i_total, r_rama, r_otra),
    do: i_total * r_otra / (r_rama + r_otra)

  @doc """
  Tension de un nodo por analisis nodal.
  `ramas_con_fuente` es una lista de tuplas {tension_de_la_fuente, resistencia}.
  `resistencias_a_tierra` es una lista de resistencias que van del nodo a GND.
  """
  def tension_nodo(ramas_con_fuente, resistencias_a_tierra) do
    numerador =
      Enum.reduce(ramas_con_fuente, 0.0, fn {v, r}, acc -> acc + v / r end)

    denominador =
      Enum.reduce(ramas_con_fuente, 0.0, fn {_v, r}, acc -> acc + 1 / r end) +
        Enum.reduce(resistencias_a_tierra, 0.0, fn r, acc -> acc + 1 / r end)

    numerador / denominador
  end

  @doc """
  Regla de Cramer para un sistema de dos ecuaciones, util en analisis de mallas.
  Coeficientes {a11, a12, a21, a22} y terminos independientes {b1, b2}.
  """
  def cramer2({a11, a12, a21, a22}, {b1, b2}) do
    det = a11 * a22 - a12 * a21

    if det == 0 do
      {:error, :sistema_singular}
    else
      x = (b1 * a22 - a12 * b2) / det
      y = (a11 * b2 - b1 * a21) / det
      {:ok, {x, y}}
    end
  end

  @doc "Constante de tiempo de una red RC, en segundos."
  def tau(r, c), do: r * c

  @doc "Tension en el condensador durante la carga, en el instante t."
  def carga(v_final, r, c, t), do: v_final * (1 - :math.exp(-t / tau(r, c)))

  @doc "Tension en el condensador durante la descarga, en el instante t."
  def descarga(v_inicial, r, c, t), do: v_inicial * :math.exp(-t / tau(r, c))

  @doc "Frecuencia de corte de un filtro RC pasa bajos, en hercios."
  def frecuencia_corte(r, c), do: 1 / (2 * :math.pi() * r * c)

  @doc "Energia almacenada en un condensador cargado, en julios."
  def energia(c, v), do: 0.5 * c * v * v
end

defmodule Informe do
  @moduledoc "Imprime los ejemplos resueltos del capitulo."

  def redondear(valor, decimales \\ 3), do: Float.round(valor * 1.0, decimales)

  def titulo(texto) do
    IO.puts("")
    IO.puts("=== #{texto} ===")
  end

  def linea(etiqueta, valor, unidad) do
    IO.puts("  #{String.pad_trailing(etiqueta, 28)} #{redondear(valor)} #{unidad}")
  end

  def serie do
    titulo("Serie: 9 V con 220, 330 y 470 ohm")
    rt = Circuitos.serie([220, 330, 470])
    i = Circuitos.corriente(9, rt)
    linea("Resistencia total", rt, "ohm")
    linea("Corriente comun", i * 1000, "mA")

    Enum.each([{"R1", 220}, {"R2", 330}, {"R3", 470}], fn {nombre, r} ->
      linea("Caida en #{nombre}", i * r, "V")
    end)

    linea("Potencia total", Circuitos.potencia(9, i) * 1000, "mW")
  end

  def paralelo do
    titulo("Paralelo: 9 V con 220 y 330 ohm")
    req = Circuitos.paralelo([220, 330])
    linea("Resistencia equivalente", req, "ohm")
    linea("Corriente por 220", Circuitos.corriente(9, 220) * 1000, "mA")
    linea("Corriente por 330", Circuitos.corriente(9, 330) * 1000, "mA")
    linea("Corriente total", Circuitos.corriente(9, req) * 1000, "mA")
  end

  def mixto do
    titulo("Mixto: 12 V, R1 = 1k en serie con 2k paralelo 3k")
    r23 = Circuitos.paralelo([2000, 3000])
    rt = Circuitos.serie([1000, r23])
    i = Circuitos.corriente(12, rt)
    v23 = i * r23
    linea("R2 paralelo R3", r23, "ohm")
    linea("Resistencia total", rt, "ohm")
    linea("Corriente total", i * 1000, "mA")
    linea("Tension sobre R1", i * 1000.0, "V")
    linea("Tension sobre el paralelo", v23, "V")
    linea("Corriente por R2", Circuitos.corriente(v23, 2000) * 1000, "mA")
    linea("Corriente por R3", Circuitos.corriente(v23, 3000) * 1000, "mA")
  end

  def kirchhoff do
    titulo("Kirchhoff: dos fuentes contra un mismo nodo")
    # Malla 1: 430*I1 + 330*I2 = 9 ; Malla 2: 330*I1 + 550*I2 = 5
    {:ok, {i1, i2}} = Circuitos.cramer2({430, 330, 330, 550}, {9, 5})
    linea("I1 desde la fuente de 9 V", i1 * 1000, "mA")
    linea("I2 desde la fuente de 5 V", i2 * 1000, "mA")
    linea("I3 por la resistencia 330", (i1 + i2) * 1000, "mA")

    va = Circuitos.tension_nodo([{9, 100}, {5, 220}], [330])
    linea("Tension del nodo (nodal)", va, "V")
    linea("Tension del nodo (mallas)", (i1 + i2) * 330, "V")
  end

  def divisores do
    titulo("Divisor de tension")
    linea("5 V con 1k/2k sin carga", Circuitos.divisor(5, 1000, 2000), "V")
    linea("Mismo divisor con 10k", Circuitos.divisor_cargado(5, 1000, 2000, 10_000), "V")
    linea("Error por la carga", Circuitos.error_por_carga(5, 1000, 2000, 10_000), "%")
    linea("12 V con 10k/3k6", Circuitos.divisor(12, 10_000, 3600), "V")
    linea("Consumo del divisor 12 V", Circuitos.corriente(12, 13_600) * 1000, "mA")
  end

  def condensadores do
    titulo("Redes RC")
    r = 10_000
    c = 10.0e-6
    t = Circuitos.tau(r, c)
    linea("Tau con 10k y 10uF", t, "s")
    linea("Tension en 1 tau", Circuitos.carga(5, r, c, t), "V")
    linea("Tension en 3 tau", Circuitos.carga(5, r, c, 3 * t), "V")
    linea("Tension en 5 tau", Circuitos.carga(5, r, c, 5 * t), "V")
    linea("Corte del filtro 10k/100nF", Circuitos.frecuencia_corte(10_000, 100.0e-9), "Hz")
    linea("Energia en 100uF a 5 V", Circuitos.energia(100.0e-6, 5) * 1000, "mJ")
    linea("Dos de 100nF en serie", Circuitos.capacidad_serie([100.0e-9, 100.0e-9]) * 1.0e9, "nF")
    linea("Dos de 100nF en paralelo", Circuitos.capacidad_paralelo([100.0e-9, 100.0e-9]) * 1.0e9, "nF")
  end

  def todo do
    serie()
    paralelo()
    mixto()
    kirchhoff()
    divisores()
    condensadores()
    IO.puts("")
  end
end

Informe.todo()

Ejecutarlo imprime todos los números del capítulo. Vale la pena modificar los valores y volver a correrlo: es la forma más rápida de desarrollar intuición sobre qué pasa cuando subes una resistencia o cambias un condensador.

Si prefieres tenerlo dentro de un proyecto Mix y protegerlo con pruebas, el módulo Circuitos se copia tal cual a lib/circuitos.ex y las verificaciones quedan así:

defmodule CircuitosTest do
  use ExUnit.Case, async: true

  @tolerancia 0.001

  test "serie suma resistencias" do
    assert Circuitos.serie([220, 330, 470]) == 1020
  end

  test "paralelo de dos iguales da la mitad" do
    assert_in_delta Circuitos.paralelo([1000, 1000]), 500.0, @tolerancia
  end

  test "paralelo coincide con producto sobre suma" do
    esperado = 220 * 330 / (220 + 330)
    assert_in_delta Circuitos.paralelo([220, 330]), esperado, @tolerancia
  end

  test "divisor sin carga reparte segun la proporcion" do
    assert_in_delta Circuitos.divisor(5, 1000, 2000), 3.3333, 0.001
  end

  test "la carga siempre baja la salida del divisor" do
    ideal = Circuitos.divisor(5, 1000, 2000)
    real = Circuitos.divisor_cargado(5, 1000, 2000, 10_000)
    assert real < ideal
    assert_in_delta real, 3.125, @tolerancia
  end

  test "nodal y mallas dan el mismo resultado" do
    va_nodal = Circuitos.tension_nodo([{9, 100}, {5, 220}], [330])
    {:ok, {i1, i2}} = Circuitos.cramer2({430, 330, 330, 550}, {9, 5})
    va_mallas = (i1 + i2) * 330
    assert_in_delta va_nodal, va_mallas, @tolerancia
  end

  test "kirchhoff de corrientes se cumple en el nodo" do
    {:ok, {i1, i2}} = Circuitos.cramer2({430, 330, 330, 550}, {9, 5})
    va = (i1 + i2) * 330
    i3 = va / 330
    assert_in_delta i1 + i2, i3, 1.0e-9
  end

  test "el condensador alcanza 63,2 por ciento en una tau" do
    r = 10_000
    c = 10.0e-6
    assert_in_delta Circuitos.carga(5, r, c, Circuitos.tau(r, c)), 3.1606, 0.001
  end

  test "condensadores en serie reducen la capacidad" do
    assert_in_delta Circuitos.capacidad_serie([100.0e-9, 100.0e-9]), 50.0e-9, 1.0e-12
  end

  test "sistema singular se reporta como error" do
    assert Circuitos.cramer2({1, 2, 2, 4}, {3, 6}) == {:error, :sistema_singular}
  end
end

La prueba de “kirchhoff de corrientes” es especialmente útil como red de seguridad: si alguna vez modificas las fórmulas, esa igualdad tiene que seguir cumpliéndose, porque es una ley física, no una decisión de diseño.

Valores comerciales: la serie E12

Las resistencias no existen en cualquier valor. La serie E12 (tolerancia del 10 %) cubre una década con doce valores, que se repiten multiplicados por potencias de diez:

10  12  15  18  22  27  33  39  47  56  68  82

Así, existen 220 Ω, 330 Ω, 470 Ω, 1 kΩ, 2,2 kΩ, 4,7 kΩ, 10 kΩ, 22 kΩ, 47 kΩ, 100 kΩ. No existe una resistencia comercial de 250 Ω en E12; hay de 220 Ω y de 270 Ω. Cuando tu cálculo da 250 Ω, redondeas al valor comercial más cercano que sea seguro: para limitar corriente en un LED, siempre hacia arriba.

La serie E24 (5 %) añade valores intermedios (11, 13, 16, 20, 24, 30, 36, 43, 51, 62, 75, 91) y la E96 (1 %) es la que se usa cuando la precisión importa, como en el divisor que protege una entrada de ADC.

Para elegir la potencia de la resistencia, una tabla de referencia rápida con las presentaciones habituales:

Potencia nominal	Disipación segura recomendada	Uso típico
1/8 W (125 mW)	Hasta 60 mW	Montaje superficial, señales
1/4 W (250 mW)	Hasta 125 mW	El estándar de protoboard
1/2 W (500 mW)	Hasta 250 mW	LED de potencia media, divisores en 24 V
1 W	Hasta 500 mW	Cargas resistivas, resistencias de sensado
2 W y más	Hasta la mitad de lo nominal	Frenado de motores, disipación deliberada

La regla de “usar como máximo la mitad de la potencia nominal” no es exagerada: una resistencia de 1/4 W disipando 240 mW alcanza temperaturas que derriten el plástico de la protoboard y desvían su propio valor.

Errores comunes

Error	Causa	Solución
El circuito de la mitad derecha de la protoboard no funciona	Los buses de alimentación están partidos por la mitad en muchos modelos	Verificar la interrupción en la línea roja/azul y puentear las dos mitades con cables cortos
El divisor entrega menos tensión de la calculada	Hay una carga conectada a la salida que queda en paralelo con R2	Aplicar la regla del 10×, bajar las resistencias del divisor o poner un seguidor de tensión
El divisor calienta y consume batería con el equipo dormido	Resistencias demasiado bajas: consume permanentemente	Subir los valores (100 kΩ / 36 kΩ) o conmutar el divisor con un MOSFET solo al medir
El electrolítico se hinchó, se abrió o huele mal	Polaridad invertida o tensión nominal insuficiente	La banda del cuerpo es el negativo; usar condensadores con al menos el doble de la tensión de trabajo
Un condensador cerámico “104” mide 60 nF en vez de 100 nF	Dieléctricos Y5V/Z5U pierden capacidad con la tensión aplicada y la temperatura	Usar dieléctricos X7R o C0G donde el valor importe; sobredimensionar si no
El microcontrolador se reinicia justo al transmitir por WiFi	Falta condensador de reserva: el pico de corriente hunde el riel	Añadir 100 µF electrolítico a la entrada del regulador y 100 nF junto a cada chip
Comunicación I2C que falla de forma aleatoria	Ausencia de condensadores de desacoplo cerca de los integrados	100 nF entre VCC y GND lo más cerca posible de los pines de alimentación
Un pulsador genera varios eventos por pulsación	Rebote mecánico de los contactos, de 1 a 20 ms	RC de 10 kΩ + 100 nF y, además, ventana de 20 ms en software
El multímetro no marca nada y saltó su fusible interno	Amperímetro conectado en paralelo: equivale a un cortocircuito	El amperímetro va siempre en serie; reemplazar el fusible y verificar la posición del selector antes de tocar nada
La resistencia se quemó pese a estar bien calculada por Ohm	Se calculó la corriente pero no la potencia disipada	Calcular P = I² × R y elegir una resistencia con al menos el doble de esa potencia nominal
Dos componentes que “deberían” estar en paralelo dan un resultado raro	Están en filas distintas de la protoboard, o comparten solo un extremo	Rotular los nodos con letras y verificar que ambos extremos coincidan
El resultado del análisis da una corriente negativa	El sentido supuesto era el contrario al real	No es un error: el signo indica el sentido; el módulo del valor es correcto
Intermitencias que aparecen al mover la placa	Contactos fatigados o cable de calibre demasiado fino	Usar cable rígido AWG 22, cambiar de fila y verificar continuidad
La simulación da resultados absurdos (tensiones enormes)	Falta el nodo 0 de masa en la netlist, o un nodo quedó flotando	Todo circuito SPICE necesita referencia a masa y ningún nodo puede quedar sin camino a ella

Ejercicios propuestos

1. Reducción con lápiz. Dibuja un circuito de 9 V con R1 = 470 Ω en serie con el paralelo de R2 = 1 kΩ, R3 = 1 kΩ y R4 = 2,2 kΩ. Calcula la resistencia total, la corriente por cada rama y la potencia disipada en cada resistencia. Verifica que la suma de las cuatro potencias sea igual a la potencia entregada por la fuente.

2. Verificación con el módulo. Reproduce el ejercicio anterior usando el módulo Circuitos y añade una función Informe.ejercicio_uno/0 que imprima todos los valores. Compara con tus cálculos a mano; si difieren, encuentra dónde.

3. Divisor bajo especificación. Diseña un divisor que convierta 24 V en una tensión que no supere 3,0 V, consumiendo menos de 100 µA en reposo, con resistencias de la serie E12. Calcula el consumo real, la impedancia de salida del divisor (R1 ∥ R2) y decide si necesita un seguidor de tensión antes del ADC.

4. El signo negativo. Modifica el ejemplo de las dos fuentes cambiando V2 de 5 V a 8 V. Recalcula con Cramer y con análisis nodal. ¿En qué punto I2 cambia de signo? Encuentra analíticamente el valor exacto de V2 para el cual I2 = 0, y explica qué significa físicamente.

5. Dimensionar una RC. Necesitas un antirrebote cuya constante de tiempo sea de 5 ms usando un condensador de 100 nF. ¿Qué resistencia hace falta? ¿Cuánto tarda la señal en llegar al 95 % tras soltar el botón? ¿Ese retardo es perceptible para un usuario?

6. Filtro para un sensor. Un sensor analógico entrega una señal útil por debajo de 20 Hz, pero llega contaminada con ruido de 50 Hz de la red eléctrica. Diseña un filtro RC pasa bajos con frecuencia de corte de 25 Hz usando un condensador de 1 µF. Calcula la resistencia y verifica la impedancia que ese filtro añade en serie con la entrada del ADC.

7. Simulación comparada. Escribe la netlist SPICE de los ejercicios 3 y 6, ejecútala en ngspice y compara los números con los de tu módulo Elixir. Documenta cualquier diferencia mayor al 1 % y explica su origen.

8. Del esquemático a la protoboard. Dibuja el esquemático del circuito del ejercicio 1 con designadores y valores, y a continuación planifica en papel en qué fila de la protoboard va cada pata, indicando qué filas forman qué nodos. Después móntalo y mide cada nodo con el multímetro.

9. Condensadores en el cajón. Solo tienes condensadores de 100 nF y necesitas 250 nF exactos con la mayor tensión nominal posible. Propón una combinación de serie y paralelo, calcula la capacidad resultante y la tensión que soportaría el conjunto si cada unidad es de 50 V.

10. Antirrebote en Nerves. Adapta el módulo Boton para que, además de emitir :boton_presionado y :boton_soltado, detecte una pulsación larga: si el pin permanece en 0 más de 1000 ms, debe emitir :pulsacion_larga. Piensa qué pasa si el usuario mantiene presionado durante diez segundos y decide si el evento debe repetirse.

Lo que viene

Ya tienes las herramientas de análisis: sabes identificar nodos y mallas, reducir serie y paralelo, aplicar las dos leyes de Kirchhoff cuando la reducción no alcanza, dimensionar un divisor sin que la carga te lo arruine y calcular una constante de tiempo RC. También sabes traducir un esquemático a una protoboard, verificar tus números en un simulador antes de conectar nada y automatizar los cálculos desde Elixir.

Lo que falta es el catálogo. Hasta aquí los componentes fueron abstracciones: “una resistencia”, “un condensador”. En el capítulo 4 vamos a abrir la caja: resistencias y su código de colores, LED y su tensión directa, diodos y su papel como protección, transistores como interruptores controlados, reguladores de tensión, sensores, y las herramientas de trabajo (multímetro, soldador, pinzas, fuente de laboratorio) con los criterios para elegirlas y usarlas sin quemar nada. Con ese catálogo, más el análisis de este capítulo, vas a poder leer cualquier hoja de datos y decidir si un componente sirve para tu circuito.

El índice completo del curso vive en /tecnologias/elixir-robotics/00-indice/.