Relé de estado sólido SSR con Arduino: control de calentador
¿Cómo usar un relé SSR con Arduino? Diferencias con el mecánico, tipos DA/DD/AA, cruce por cero, disipador, ESP32 a 3,3 V, código Pico y SSR falsos.
El relé SSR (relé de estado sólido, Solid State Relay en inglés) es un interruptor electrónico que permite a un microcontrolador como Arduino, con una pequeña señal de 3–32 V, conectar y desconectar cargas de 230 V como un calentador, una lámpara, la resistencia de un horno o un hervidor sin ninguna pieza móvil. En un relé clásico una bobina atrae y suelta un contacto metálico; en el SSR lo hace un semiconductor activado por luz. Por eso no hace clic, sus contactos no se desgastan, no produce chispas y dura años aunque lo conmutes muchas veces por minuto. En proyectos de calefacción que necesitan conmutar a menudo, como termostatos, incubadoras, sous-vide y hornos, la pareja SSR y Arduino es casi un estándar.
Pero el SSR no es una caja mágica: en él cae una tensión de 1–1,6 V, lo que con corrientes altas significa mucho calor; incluso apagado deja pasar unos miliamperios de fuga; un SSR de salida AC no puede cortar una carga de corriente continua; y buena parte de los SSR baratos del mercado son copias que no soportan la corriente de su etiqueta. En este artículo aprenderás paso a paso cómo es un SSR por dentro, en qué se diferencia de un relé mecánico, qué significan los códigos DA, DD y AA de la etiqueta, qué es el cruce por cero, cómo calcular el disipador, cómo controlar un calentador con seguridad usando Arduino, ESP32 y Raspberry Pi Pico y cómo reconocer un SSR falso.
¿Qué es un SSR (relé de estado sólido) y cómo funciona?
Dentro de un SSR hay dos mundos separados. En el lado de entrada hay un LED infrarrojo con un circuito limitador de corriente; cuando aplicas tensión a los terminales 3 y 4, el LED se enciende. En el lado de salida hay un circuito de disparo sensible a la luz y el elemento de potencia que lleva la carga: en los modelos de salida AC, un triac o dos tiristores (SCR) en antiparalelo; en los de salida DC, un MOSFET. Como entre la entrada y la salida solo hay luz, ambos lados están aislados eléctricamente; es el mismo principio que un optoacoplador y suele ofrecer un aislamiento de 2500 V o más. Así, el GND de Arduino nunca toca la red eléctrica. En los modelos AC el triac se apaga solo cuando la corriente pasa por cero; es decir, al quitar la señal de entrada la carga se desconecta como máximo en medio periodo (10 ms a 50 Hz).
| Característica | Valor típico (clase SSR-25DA) |
|---|---|
| Tensión de entrada (control) | 3–32 V DC |
| Corriente de entrada | Aprox. 5–15 mA |
| Tensión de salida (carga) | 24–380 V AC |
| Corriente de salida nominal | 25 A (solo con un disipador adecuado) |
| Caída de tensión en conducción | 1,0–1,6 V |
| Corriente de fuga en apagado | Unos mA (1–10 mA según el modelo) |
| Aislamiento | 2500 V AC o más |
| Tiempo de conexión / desconexión | ≤ 10 ms (por el cruce por cero) |
| Terminales | 1–2: carga, 3 (+) y 4 (−): entrada de control |
Diferencia entre un SSR y un relé mecánico

| Característica | Relé mecánico | SSR (relé de estado sólido) |
|---|---|---|
| Elemento de conmutación | Bobina + contacto metálico | Triac, tiristor o MOSFET |
| Sonido | Hace clic | Silencioso |
| Vida útil | Unas 100 000 conmutaciones con carga | Conmutaciones prácticamente ilimitadas |
| Chispas e interferencias | Se forma un arco al abrir el contacto | Muy bajas en modelos con cruce por cero |
| Pérdidas en conducción | Muy bajas (contacto de miliohmios) | Caída de 1–1,6 V, se calienta |
| Fuga en apagado | Ninguna, separación total | Unos mA de corriente de fuga |
| AC y DC | Conmuta ambas | Solo AC o solo DC según el tipo |
| Corriente de control | 70–90 mA para la bobina (con módulo) | 5–15 mA, se conecta directo al pin |
| Tipo de fallo | El contacto puede pegarse o quedar abierto | Normalmente cortocircuito, es decir, siempre encendido |
| Precio | Barato | Más caro, y además necesita disipador |
Tipos DA y AA: ¿qué significan DA, DD y AA en la etiqueta del SSR?
El código de dos letras de la etiqueta indica primero el tipo de entrada y luego el de salida. Aquí hay una pequeña trampa de idioma: en español hablamos de CC (corriente continua) y CA (corriente alterna), pero los códigos de la etiqueta vienen del inglés, así que la D significa DC y la A significa AC. Por tanto, un SSR-25DA no es un "relé de corriente continua", sino un relé controlado con DC que conmuta una carga AC; y es el tipo más usado en proyectos con Arduino. El SSR-25DD se controla con DC y conmuta una carga DC (por ejemplo, una almohadilla calefactora o una bomba de 12 V). El SSR-25AA necesita tensión de red también en la entrada; no se usa directamente con un microcontrolador, sino con un termostato o un interruptor para manejar una carga grande. Si te lías, el artículo sobre la diferencia entre corriente AC y DC te ayudará a repasar la base.
| Código de la etiqueta | Entrada (control) | Salida (carga) | Uso típico |
|---|---|---|---|
| DA (p. ej. SSR-25DA) | 3–32 V DC | 24–380 V AC | Calentador, lámpara u horno de 230 V con Arduino |
| DD (p. ej. SSR-25DD) | 3–32 V DC | 5–60 V DC (según el modelo) | Almohadilla calefactora de 12/24 V, bomba, tira LED |
| AA (p. ej. SSR-25AA) | 90–250 V AC | 24–380 V AC | Manejar una carga AC grande con interruptor o termostato |
| Módulo G3MB-202P | 5 V DC | 100–240 V AC, máximo 2 A | Cargas AC pequeñas: lámpara, ventilador pequeño |
¿Qué es el cruce por cero (zero-cross) y por qué importa?
La tensión de red es una onda senoidal de 50 Hz que pasa por cero cada 10 ms. Cuando das la orden de encendido a un SSR con cruce por cero, la salida no conduce de inmediato: espera al primer instante en que la tensión se acerca a cero. Así el calentador o la bombilla incandescente se conectan en un punto cercano a cero y no en el pico de unos 325 V; el pico de corriente, la interferencia electromagnética y el zumbido se reducen mucho. Para cargas resistivas es perfecto. El precio es este: con un SSR de cruce por cero no puedes atenuar una lámpara con control de ángulo de fase; para eso hacen falta modelos de encendido instantáneo ("random turn-on"). Por la misma razón, la señal analogWrite de 490 Hz de Arduino no tiene sentido con un SSR, porque la señal cambia varias veces en cada medio periodo y el resultado es aleatorio (en el artículo sobre PWM puedes ver por qué importa la frecuencia). La forma correcta de regular la potencia de un calentador es el control por proporción de tiempo: por ejemplo, en una ventana de 2 segundos lo mantienes encendido 1,2 s y apagado 0,8 s y obtienes el 60 % de potencia. Como 2 segundos son 200 medios periodos, la resolución de este método es de aproximadamente el 0,5 %.
Necesidad de disipador: ¿cuánto se calienta un SSR?
El contacto de un relé mecánico tiene una resistencia casi nula; el triac de un SSR, en cambio, hace caer unos 1,2–1,6 V mientras conduce. La potencia disipada se calcula aproximadamente con la fórmula P = Vcaída × I. Un calentador de 2000 W consume a 230 V I = 2000 / 230 ≈ 8,7 A; si suponemos que en el SSR caen 1,3 V, se liberan P ≈ 1,3 × 8,7 ≈ 11 W de calor. Es suficiente para calentar la punta de un soldador pequeño, y un SSR sin disipador alcanza temperaturas peligrosas en pocos minutos. Como la carcasa de plástico por sí sola solo aguanta unos 2–3 W, el límite práctico sin disipador es de unos 2 A. Atornilla el SSR a un disipador de aluminio con una fina capa de pasta térmica, comprueba que la base metálica no pase de 80 °C y elige la corriente con holgura: en cargas resistivas, la corriente de la etiqueta del SSR debe ser al menos 2 veces la corriente de la carga, y en cargas inductivas como motores y transformadores, de 3 a 4 veces. Para el cálculo de potencia y corriente puedes usar la calculadora de la ley de Ohm y el artículo sobre el cálculo de potencia eléctrica.
| Corriente de carga (230 V) | Carga de ejemplo | Calor en el SSR (≈1,3 V) | Recomendación de refrigeración |
|---|---|---|---|
| 0,5 A | Bombilla incandescente de 100 W | ≈ 0,7 W | No hace falta disipador |
| 2 A | Calentador de 450 W | ≈ 2,6 W | En el límite; se recomienda un disipador pequeño |
| 4,3 A | Calentador de 1000 W | ≈ 5,6 W | Disipador mediano (≈ 5 °C/W o mejor) |
| 8,7 A | Calentador de 2000 W | ≈ 11 W | Disipador grande (≈ 2,5 °C/W) y un SSR de al menos 25 A |
| 13 A | Calentador de 3000 W | ≈ 17 W | Disipador con ventilador y un SSR de marca de 40 A |
Conexión del SSR: Arduino Uno, ESP32 y Raspberry Pi Pico
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Pin de control | D8 | GPIO 26 | GP15 |
| Entrada + del SSR (3) | Directo a D8 | 5V/VIN (con transistor) | VBUS (con transistor) |
| Entrada − del SSR (4) | GND | Colector del NPN | Colector del NPN |
| Base del NPN (BC547 / 2N2222) | - | 1 kΩ a GPIO 26, 10 kΩ a GND | 1 kΩ a GP15, 10 kΩ a GND |
| Emisor del NPN | - | GND | GND |
| Datos del DS18B20 | D2 | GPIO 4 | GP16 |
| VCC del DS18B20 | 5V | 3V3 | 3V3(OUT) |
| Pull-up de 4,7 kΩ | Datos – 5V | Datos – 3V3 | Datos – 3V3 |
Como los pines del Arduino Uno entregan 5 V y suministran sin problema hasta 20 mA, puedes conectar la entrada del SSR-DA directamente entre D8 y GND; como la entrada ya lleva un limitador de corriente, no hace falta una resistencia aparte. El ESP32 y la Pico, en cambio, trabajan a 3,3 V. Aunque la etiqueta diga "3–32 V DC", 3,3 V está muy cerca del límite inferior de ese rango; cuando el pin cae a 3,1 V bajo carga, o con un SSR copia que pide una tensión de entrada mayor, el relé a veces se activa y a veces no. Además, los pines de la Pico vienen configurados por defecto para solo unos 4 mA. Por eso, en placas de 3,3 V lo más fiable es alimentar el SSR a 5 V con un transistor NPN: el GPIO va a la base del transistor con una resistencia de 1 kΩ, el terminal + del SSR a 5 V, el − al colector y el emisor a GND. Cuando el GPIO está en HIGH, el transistor conduce y el SSR recibe unos 4,8 V. La resistencia de 10 kΩ que pongas entre la base y GND evita que el calentador se active por sí solo cuando el pin queda flotante al encender o reiniciar la placa. Todos los GND deben ser comunes; el motivo lo encuentras en el artículo sobre el GND común.
- Primero desconecta por completo la red: saca el enchufe o baja el magnetotérmico y comprueba que no hay tensión en los bornes.
- Atornilla el SSR al disipador con una fina capa de pasta térmica; conecta el disipador y la caja metálica a la toma de tierra de protección (cable amarillo-verde).
- Conecta el lado de control: une los terminales 3 (+) y 4 (−) al Arduino o al transistor según la tabla de arriba, carga el código con la red desconectada y comprueba que el LED del SSR parpadea.
- En el lado de la carga, conecta la fase (cable marrón) al terminal 1 del SSR y el terminal 2 al calentador; el neutro (azul) va directo al calentador. Pon en la línea de fase un fusible adecuado a la corriente de la carga.
- Elige la sección del cable según la corriente: al menos 1,5 mm² hasta 10 A y 2,5 mm² para 16 A; pon terminales de punta en los cables multifilares y aprieta bien los tornillos.
- Conecta en serie con el calentador un fusible térmico o un termostato bimetálico que funcione independientemente de Arduino; será la última protección si el SSR falla en cortocircuito.
- Coloca toda la parte de red en una caja aislante con tapa; no la energices sin cerrar la caja ni sin alimentarla desde una línea protegida por un diferencial.
Control de un calentador con Arduino: termostato por proporción de tiempo
El siguiente programa mide con un sensor de temperatura DS18B20 y regula la potencia del calentador con ventanas de tiempo de 2 segundos. El objetivo es 40 °C y la banda proporcional 5 °C: con 35 °C o menos el calentador trabaja al 100 %, a 37,5 °C al 50 % y a 40 °C al 0 %. Así se reduce el gran sobrepaso de los termostatos simples de encendido y apagado. El código no usa delay(); la medición y el tiempo de la ventana se gestionan con millis(), y la conversión del sensor, de unos 750 ms, se completa en segundo plano sin esperarla. Si el sensor se desconecta (-127 °C) o la temperatura supera el límite de seguridad de 70 °C, el calentador se apaga al instante. Para los detalles de conexión del sensor consulta el artículo del sensor de temperatura DS18B20; para compilar el código instala desde el Gestor de bibliotecas las bibliotecas OneWire y DallasTemperature.
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const uint8_t SSR_PIN = 8; // SSR giriş + (3) / SSR input + (3)
5const uint8_t ONE_WIRE_PIN = 2; // DS18B20 veri / DS18B20 data
6const float HEDEF_C = 40.0; // hedef sıcaklık / target temperature
7const float BANT_C = 5.0; // oransal bant / proportional band
8const float EMNIYET_C = 70.0; // üst güvenlik sınırı / safety cutoff
9const unsigned long PENCERE_MS = 2000; // zaman penceresi / time window
10
11OneWire oneWire(ONE_WIRE_PIN);
12DallasTemperature sensors(&oneWire);
13
14unsigned long pencereBasi = 0;
15unsigned long sonOlcum = 0;
16unsigned long acikSure = 0; // pencere içindeki açık süre / on-time in window
17
18void setup() {
19 pinMode(SSR_PIN, OUTPUT);
20 digitalWrite(SSR_PIN, LOW); // açılışta ısıtıcı kapalı / heater off at start
21 Serial.begin(9600);
22 sensors.begin();
23 sensors.setWaitForConversion(false); // bloklamadan ölç / non-blocking conversion
24 sensors.requestTemperatures(); // ilk ölçümü başlat / start first conversion
25}
26
27void loop() {
28 unsigned long simdi = millis();
29
30 if (simdi - sonOlcum >= 1000) { // saniyede bir ölç / measure once per second
31 sonOlcum = simdi;
32 float t = sensors.getTempCByIndex(0);
33 sensors.requestTemperatures(); // sonraki ölçümü başlat / start next conversion
34
35 float oran = 0.0; // güç oranı 0..1 / power ratio 0..1
36 if (t != DEVICE_DISCONNECTED_C && t < EMNIYET_C) {
37 oran = constrain((HEDEF_C - t) / BANT_C, 0.0, 1.0);
38 }
39 acikSure = (unsigned long)(oran * PENCERE_MS);
40
41 Serial.print(F("Sicaklik / Temp: "));
42 Serial.print(t, 1);
43 Serial.print(F(" C Guc / Power: %"));
44 Serial.println(oran * 100.0, 0);
45 }
46
47 if (simdi - pencereBasi >= PENCERE_MS) {
48 pencereBasi += PENCERE_MS; // yeni pencere / new window
49 }
50 digitalWrite(SSR_PIN, (simdi - pencereBasi < acikSure) ? HIGH : LOW);
51}SSR con ESP32: disparo a 3,3 V y termostato con histéresis
En el ESP32 veamos otro método: el control de encendido y apagado con histéresis. El calentador se enciende cuando la temperatura baja de 39 °C y se apaga al superar 41 °C; la banda muerta de 2 °C evita que el SSR conmute sin parar por pequeñas fluctuaciones del sensor. El SSR se alimenta a 5 V mediante un transistor NPN conectado al GPIO 26, como en la tabla. Elegimos el GPIO 26 a propósito: los GPIO 0, 2, 5, 12 y 15 son pines que determinan el comportamiento de arranque de la placa, y una carga conectada a ellos puede activarse sin querer al encender. El código se compila igual con el core 2.x y 3.x de Arduino para ESP32; solo si usas el core 3.x instala la versión 2.3.8 o más reciente de la biblioteca OneWire. En el siguiente paso puedes llevar este termostato a la Wi-Fi y ajustar la temperatura objetivo desde el móvil con Home Assistant.
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int SSR_PIN = 26; // NPN tabanına 1 kΩ ile / to NPN base via 1 kΩ
5const int ONE_WIRE_PIN = 4; // DS18B20 veri / DS18B20 data
6const float HEDEF_C = 40.0; // hedef sıcaklık / target temperature
7const float HISTEREZIS_C = 1.0; // ±1 °C ölü bant / ±1 °C dead band
8const float EMNIYET_C = 70.0; // güvenlik sınırı / safety cutoff
9
10OneWire oneWire(ONE_WIRE_PIN);
11DallasTemperature sensors(&oneWire);
12
13bool isitici = false;
14unsigned long sonOlcum = 0;
15
16void setup() {
17 pinMode(SSR_PIN, OUTPUT);
18 digitalWrite(SSR_PIN, LOW); // açılışta kapalı / off at start
19 Serial.begin(115200);
20 sensors.begin();
21}
22
23void loop() {
24 if (millis() - sonOlcum < 1000) return;
25 sonOlcum = millis();
26
27 sensors.requestTemperatures(); // yaklaşık 750 ms bekler / waits about 750 ms
28 float t = sensors.getTempCByIndex(0);
29
30 if (t == DEVICE_DISCONNECTED_C || t >= EMNIYET_C) {
31 isitici = false; // arıza ya da aşırı sıcaklık / fault or overheat
32 } else if (t < HEDEF_C - HISTEREZIS_C) {
33 isitici = true; // soğuk: ısıt / cold: heat
34 } else if (t > HEDEF_C + HISTEREZIS_C) {
35 isitici = false; // sıcak: kapat / hot: switch off
36 }
37 digitalWrite(SSR_PIN, isitici ? HIGH : LOW);
38
39 Serial.printf("Sicaklik / Temp: %.1f C SSR: %s\n", t, isitici ? "ACIK / ON" : "KAPALI / OFF");
40}Control de un SSR con Raspberry Pi Pico y MicroPython
En la Raspberry Pi Pico, MicroPython incluye ya los módulos onewire y ds18x20; no necesitas copiar ningún archivo adicional. El siguiente código es el mismo control por proporción de tiempo del ejemplo de Arduino: el DS18B20 va a GP16 y la base del transistor que maneja el SSR va a GP15 con una resistencia de 1 kΩ. Conecta el terminal + del SSR al pin VBUS (pin físico 40), que da 5 V cuando la Pico se alimenta por USB. Para los cálculos de tiempo se usan time.ticks_ms() y time.ticks_diff(); como estas funciones dan la diferencia correcta incluso cuando el contador se desborda, son seguras en un termostato que funciona mucho tiempo. Si no se encuentra el sensor o la lectura falla, la proporción de potencia se pone a cero, es decir, el calentador queda apagado. Si es la primera vez que usas la Pico, para instalar MicroPython consulta el artículo ¿Qué es la Raspberry Pi Pico?.
1from machine import Pin
2import onewire, ds18x20, time
3
4ssr = Pin(15, Pin.OUT, value=0) # NPN tabanı (1 kΩ) / NPN base (1 kΩ)
5sensor = ds18x20.DS18X20(onewire.OneWire(Pin(16))) # DS18B20 veri / DS18B20 data
6roms = sensor.scan()
7
8HEDEF_C = 40.0 # hedef sıcaklık / target temperature
9BANT_C = 5.0 # oransal bant / proportional band
10EMNIYET_C = 70.0 # güvenlik sınırı / safety cutoff
11PENCERE_MS = 2000 # zaman penceresi / time window
12
13def olcum_baslat():
14 try:
15 sensor.convert_temp() # dönüşümü başlat / start conversion
16 except Exception:
17 pass # sensör yok / no sensor
18
19oran = 0.0
20son_olcum = time.ticks_ms()
21pencere_basi = time.ticks_ms()
22olcum_baslat()
23
24while True:
25 simdi = time.ticks_ms()
26 if time.ticks_diff(simdi, son_olcum) >= 1000: # saniyede bir / once per second
27 son_olcum = simdi
28 try:
29 t = sensor.read_temp(roms[0])
30 if t >= EMNIYET_C:
31 oran = 0.0 # aşırı sıcaklık / overheat
32 else:
33 oran = min(max((HEDEF_C - t) / BANT_C, 0.0), 1.0)
34 print("Sicaklik / Temp: {:.1f} C Guc / Power: %{:.0f}".format(t, oran * 100))
35 except Exception:
36 oran = 0.0 # hata: ısıtıcı kapalı / error: heater off
37 print("Sensor hatasi / Sensor error")
38 olcum_baslat() # sonraki ölçüm / next conversion
39 if time.ticks_diff(simdi, pencere_basi) >= PENCERE_MS:
40 pencere_basi = time.ticks_add(pencere_basi, PENCERE_MS) # yeni pencere / new window
41 ssr.value(1 if time.ticks_diff(simdi, pencere_basi) < oran * PENCERE_MS else 0)Aviso sobre SSR falsos: ¿por qué se quema un relé que dice 40 A?
Gran parte de los SSR baratos del mercado son copias que imitan el aspecto de una marca conocida. De muchos falsos relés de 40 A que se han abierto sale un pequeño triac de 12–16 A; algunos no tienen circuito de cruce por cero ni circuito de protección (snubber) en la salida, y el aislamiento entre entrada y salida es mucho menor que el de la etiqueta. Estos relés se sobrecalientan con solo unos amperios, la carcasa de plástico se ablanda y casi siempre fallan en cortocircuito; es decir, el calentador ya no se apaga. Por eso, en proyectos de calefacción no consideres el SSR como único elemento de seguridad. Puedes reconocer un SSR falso por estas señales:
- Precio y peso: que sea varias veces más barato que los SSR de marca y que se note claramente más ligero en la mano.
- Misma carcasa, distinta corriente: que las versiones de 10 A, 25 A y 40 A se vendan exactamente del mismo tamaño, al mismo precio y con el mismo peso.
- Defectos de impresión y etiqueta: logotipo borroso o descentrado, nombre de marca con errores ortográficos, falta de número de serie o de fecha de fabricación.
- Relleno de resina: que el material de relleno de la parte inferior sea irregular, con burbujas o con huecos.
- Prueba de calentamiento: mide con un termómetro la temperatura de la base metálica durante la primera hora bajo carga; si incluso a la mitad de la corriente de la etiqueta supera rápidamente los 60 °C, no confíes en ese relé.
- Solución segura: compra marcas conocidas como Omron, Crydom, Carlo Gavazzi o Schneider a un vendedor fiable; y si usas un SSR de origen dudoso, hazlo como máximo a una cuarta parte de la corriente de su etiqueta.
Ideas de proyectos con SSR
- Termostato inteligente: mantén el calentador de una habitación a la temperatura objetivo; para la lógica básica mira el artículo del termostato con Arduino.
- Sous-vide y yogurtera: para mantener el agua constante con una precisión de ±0,5 °C, combina el control por proporción de tiempo con el control PID.
- Incubadora: mantén 37,5 °C estables durante días; añade un segundo sensor para vigilar la humedad.
- Mini horno de reflow: calienta un pequeño horno eléctrico siguiendo un perfil de soldadura con un termopar MAX6675 y un SSR.
- Enchufe inteligente: enciende y apaga aparatos de 230 V desde el móvil con un ESP32; los detalles están en el artículo del enchufe inteligente con ESP32.
- Calefacción de tuberías e invernadero: con una alarma de heladas, activa el cable calefactor cuando la temperatura baje a 2 °C.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| El LED del SSR está encendido pero la carga no funciona | El circuito de carga está abierto, el fusible saltó o la corriente de la carga está por debajo de la corriente mínima del SSR | Revisa la línea de fase y neutro; en cargas muy pequeñas usa un relé mecánico |
| La carga no se apaga nunca | Se maneja una carga DC con un SSR de salida AC o el SSR ha fallado en cortocircuito | Para DC usa un SSR de tipo DD o un MOSFET; cambia el SSR averiado |
| Con el SSR apagado, la bombilla LED luce débilmente o parpadea | Corriente de fuga del SSR | Añade una resistencia de carga adecuada en paralelo con la carga o elige un relé mecánico para esa carga |
| El multímetro marca 230 V en la salida del SSR apagado | Es normal en una medición sin carga por la corriente de fuga | Haz la medición con la carga conectada |
| El SSR y el disipador se calientan demasiado | Disipador pequeño, sin pasta térmica, corriente muy alta o SSR falso | Aumenta el disipador, recalcula la corriente y usa un SSR de marca |
| Con ESP32 o Pico a veces no se activa | 3,3 V queda en el límite inferior de la entrada | Alimenta el SSR a 5 V con un transistor NPN |
| Al arrancar la placa el calentador funciona un instante | El pin queda flotante al encender o se eligió un pin de arranque | Añade un pull-down de 10 kΩ y usa un pin seguro como el GPIO 26 |
| La potencia con analogWrite es inconsistente | El SSR de cruce por cero no puede seguir un PWM rápido | Usa una ventana de proporción de tiempo de 1–2 segundos |
Bien elegido y bien refrigerado, el SSR es la forma más silenciosa y duradera de controlar un calentador en proyectos con Arduino; solo tienes que elegir un SSR adecuado al tipo de carga, calcular la corriente con holgura, desconfiar de los relés falsos y añadir siempre una protección térmica independiente. Si quieres entender primero paso a paso la lógica del relé y la medición de temperatura, en la app BlueGrays encontrarás proyectos para encender una bombilla de 220 V con un botón y con un mando a distancia, iluminación inteligente con ESP32 y medición de temperatura, con esquemas y código.
Preguntas frecuentes
¿Se puede conectar un relé SSR directamente a Arduino?
Sí. En un SSR con entrada DC como el SSR-25DA puedes conectar el terminal 3 (+) a un pin digital de Arduino y el 4 (−) a GND; como la entrada solo consume 5–15 mA y lleva un limitador de corriente, no hace falta una resistencia aparte. El lado de la carga queda totalmente aislado de Arduino y debe cablearse además según las normas de la red eléctrica.
¿Funciona un relé SSR con 3,3 V?
La mayoría de los SSR con entrada de 3–32 V se activan con 3,3 V, pero ese valor está muy cerca del límite inferior y no es fiable, sobre todo en relés copia. Con ESP32 y Raspberry Pi Pico, la solución más robusta es alimentar el SSR a 5 V con un transistor NPN como el BC547 o el 2N2222.
¿Por qué se calienta un SSR y es obligatorio un disipador?
Mientras conduce, en el SSR caen unos 1–1,6 V y, multiplicados por la corriente, se convierten en calor; a 10 A son unos 13 W. Un SSR sin disipador suele funcionar con seguridad hasta unos 2 A; con corrientes mayores es imprescindible un disipador de aluminio montado con pasta térmica.
¿Se puede controlar un motor DC o una tira LED con un SSR?
Solo con un SSR de salida DC (tipo DD). Los SSR de salida AC, que llevan DA o AA en la etiqueta, usan un triac y, en corriente continua, una vez encendidos no se apagan. Para cargas DC de baja tensión, un MOSFET de nivel lógico suele ser una opción más barata y eficiente.
¿Se puede atenuar una lámpara con un SSR de cruce por cero?
No. Un SSR de cruce por cero solo puede conectarse cuando la tensión está cerca de cero, así que no puede hacer control de ángulo de fase; la lámpara o se enciende del todo o parpadea. Para atenuar hace falta un SSR de encendido instantáneo (random turn-on) con un circuito detector de cruce por cero o un módulo dimmer AC ya hecho; en calentadores, lo más correcto es el control por proporción de tiempo con un SSR de cruce por cero.
¿Por qué mido tensión en la salida de un SSR apagado?
Incluso apagados, los SSR dejan pasar unos miliamperios de fuga por el circuito de protección de la salida y la propia estructura del semiconductor. Sin carga conectada, la alta resistencia interna del multímetro hace que con esa pequeña corriente marque casi la tensión de red; es normal. Aun así, por eso no debes usar el SSR como seccionador de seguridad y siempre debes desenchufar antes de cualquier mantenimiento.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Temperatura y humedad con DHT11
¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

Bombilla 220V con Pulsador (Push)
Mientras mantienes pulsado el botón, una bombilla real de 220 voltios se queda encendida, y se apaga en cuanto lo sueltas.

Encender y apagar una bombilla de 220 V con un botón
¿Quieres encender y apagar una bombilla de verdad de casa con un pequeño botón? Cada vez que lo pulsas, el Arduino acciona un relé y la bombilla se enciende; si vuelves a pulsar, se apaga.

Encender una bombilla de 220 V con mando a distancia
Enciende y apaga una bombilla de verdad de tu casa con un mando a distancia, sin levantarte del sofá.

Medición de temperatura con NTC y pantalla LCD 2x16
Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

Iluminación inteligente de escaleras y pasillos
Pisas la escalera o entras en el pasillo y las luces se encienden escalón a escalón en la dirección en la que caminas.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

