Relè a stato solido SSR con Arduino: guida a collegamento e uso
Come usare un relè a stato solido SSR con Arduino? Differenze con il relè meccanico, tipi DA/DD/AA, zero crossing, dissipatore, ESP32, Pico e SSR falsi.
Il relè SSR (relè a stato solido, Solid State Relay) è un interruttore elettronico che permette a un microcontrollore come Arduino, con un piccolo segnale da 3–32 V, di accendere e spegnere carichi a 230 V come stufe, lampade, resistenze da forno o bollitori senza alcuna parte in movimento. In un relè classico una bobina attira un contatto metallico; nell'SSR lo stesso lavoro lo fa un semiconduttore comandato dalla luce. Per questo non fa clic, i contatti non si usurano, non produce scintille e dura anni anche se commuta molte volte al minuto. Nei progetti con riscaldatori che si accendono e spengono di continuo, come termostati, incubatrici, sous-vide e forni, la coppia SSR e Arduino è quasi uno standard.
Ma l'SSR non è una scatola magica: ai suoi capi cade una tensione di 1–1,6 V, che con correnti elevate significa molto calore; anche da spento lascia passare qualche milliampere di dispersione; un SSR con uscita AC non riesce a spegnere un carico in corrente continua; e buona parte degli SSR economici in circolazione sono copie che non reggono la corrente scritta sull'etichetta. In questo articolo scoprirai passo dopo passo com'è fatto un SSR, la differenza con il relè meccanico, i codici DA, DD e AA sull'etichetta, lo zero crossing, il calcolo del dissipatore, il controllo sicuro di un riscaldatore con Arduino, ESP32 e Raspberry Pi Pico e come riconoscere un SSR falso.
Cos'è un SSR (relè a stato solido) e come funziona?
Dentro un SSR ci sono due mondi separati. Sul lato ingresso c'è un LED a infrarossi con un circuito limitatore di corrente: si accende quando applichi tensione ai terminali 3 e 4. Sul lato uscita ci sono un circuito di innesco sensibile alla luce e l'elemento di potenza che porta il carico: nei modelli con uscita AC un triac o due tiristori (SCR) in antiparallelo, in quelli con uscita DC un MOSFET. Tra ingresso e uscita c'è solo luce, quindi i due lati sono isolati elettricamente; il principio è lo stesso di un optoisolatore e garantisce tipicamente un isolamento di 2500 V o più. Così il GND di Arduino non tocca mai la rete. Nei modelli AC il triac si spegne da solo quando la corrente passa per lo zero: quando togli il segnale in ingresso, il carico si spegne al massimo entro mezzo periodo (10 ms a 50 Hz).
| Caratteristica | Valore tipico (classe SSR-25DA) |
|---|---|
| Tensione di ingresso (controllo) | 3–32 V DC |
| Corrente di ingresso | Circa 5–15 mA |
| Tensione di uscita (carico) | 24–380 V AC |
| Corrente nominale di uscita | 25 A (solo con dissipatore adeguato) |
| Caduta di tensione da acceso | 1,0–1,6 V |
| Corrente di dispersione da spento | Qualche mA (1–10 mA a seconda del modello) |
| Isolamento | 2500 V AC o più |
| Tempo di accensione / spegnimento | ≤ 10 ms (a causa dello zero crossing) |
| Terminali | 1–2: carico, 3 (+) e 4 (−): ingresso di controllo |
Differenza tra SSR e relè meccanico

| Caratteristica | Relè meccanico | SSR (relè a stato solido) |
|---|---|---|
| Elemento di commutazione | Bobina + contatto metallico | Triac, tiristore o MOSFET |
| Rumore | Fa clic | Silenzioso |
| Durata | Circa 100 mila commutazioni sotto carico | Commutazioni praticamente illimitate |
| Scintille e disturbi | Si forma un arco all'apertura del contatto | Molto bassi nei modelli con zero crossing |
| Perdite da acceso | Molto basse (contatto con resistenza di milliohm) | Caduta di 1–1,6 V, si scalda |
| Dispersione da spento | Nessuna, separazione completa | Qualche mA di corrente di dispersione |
| AC e DC | Commuta entrambe | Solo AC o solo DC a seconda del tipo |
| Corrente di controllo | 70–90 mA per la bobina (tramite modulo) | 5–15 mA, collegabile direttamente al pin |
| Tipo di guasto | Il contatto può incollarsi o restare aperto | Spesso cortocircuito, cioè sempre acceso |
| Prezzo | Economico | Più caro, serve anche il dissipatore |
Tipi DA e AA: cosa significano DA, DD, AA sull'etichetta dell'SSR?
Il codice di due lettere sull'etichetta indica prima il tipo di ingresso, poi quello di uscita. Le lettere derivano dall'inglese: D sta per DC (corrente continua) e A per AC (corrente alternata). Quindi un SSR-25DA è un relè controllato in DC che commuta un carico AC, ed è il tipo più usato nei progetti Arduino. L'SSR-25DD è controllato in DC e commuta un carico DC (per esempio un tappetino riscaldante o una pompa a 12 V). L'SSR-25AA richiede la tensione di rete anche all'ingresso; non si usa direttamente con un microcontrollore, ma è adatto quando un termostato o un interruttore deve pilotare un carico grande. Se hai dubbi, l'articolo sulla differenza tra corrente AC e DC ti aiuta a ripassare le basi.
| Codice etichetta | Ingresso (controllo) | Uscita (carico) | Uso tipico |
|---|---|---|---|
| DA (es. SSR-25DA) | 3–32 V DC | 24–380 V AC | Stufa, lampada, forno a 230 V con Arduino |
| DD (es. SSR-25DD) | 3–32 V DC | 5–60 V DC (varia a seconda del modello) | Tappetino riscaldante a 12/24 V, pompa, strip LED |
| AA (es. SSR-25AA) | 90–250 V AC | 24–380 V AC | Comando di un grande carico AC con interruttore o termostato |
| Modulo G3MB-202P | 5 V DC | 100–240 V AC, massimo 2 A | Piccoli carichi AC: lampada, piccola ventola |
Cos'è lo zero crossing e perché è importante?
La tensione di rete è un'onda sinusoidale a 50 Hz e passa per lo zero ogni 10 ms. Quando dai il comando di accensione a un SSR con zero crossing, l'uscita non conduce subito: aspetta il primo momento in cui la tensione si avvicina a zero. In questo modo la stufa o la lampada a incandescenza si accende vicino allo zero e non al picco di circa 325 V; impulso di corrente, disturbi elettromagnetici e ronzio diminuiscono molto. Per i carichi resistivi è l'ideale. Il prezzo da pagare: con un SSR a zero crossing non puoi regolare una lampada con il controllo di fase; per quello servono i modelli "random turn-on", che si accendono subito. Per lo stesso motivo il segnale analogWrite a 490 Hz di Arduino non ha senso per un SSR: cambia più volte in ogni semiperiodo e il risultato è casuale (nell'articolo sul PWM vedi perché la frequenza conta). Il modo giusto per regolare la potenza di un riscaldatore è il controllo a proporzione di tempo: per esempio, in una finestra di 2 secondi lo tieni acceso 1,2 secondi e spento 0,8 secondi e ottieni il 60% della potenza. Poiché 2 secondi sono 200 semiperiodi, la risoluzione di questo metodo è circa lo 0,5%.
Dissipatore: quanto si scalda un SSR?
Il contatto di un relè meccanico ha resistenza quasi nulla; il triac dell'SSR, invece, in conduzione ha una caduta di circa 1,2–1,6 V. La potenza dissipata si calcola all'incirca con P = Vcaduta × I. Una stufa da 2000 W a 230 V assorbe I = 2000 / 230 ≈ 8,7 A; supponendo 1,3 V di caduta sull'SSR, si sviluppano P ≈ 1,3 × 8,7 ≈ 11 W di calore. È abbastanza per scaldare la punta di un piccolo saldatore, e un SSR senza dissipatore raggiunge temperature pericolose in pochi minuti. Poiché il solo involucro di plastica smaltisce al massimo 2–3 W, senza dissipatore il limite pratico è circa 2 A. Fissa l'SSR a un dissipatore di alluminio con un sottile strato di pasta termica, assicurati che la base metallica non superi gli 80 °C e scegli la corrente con margine: nei carichi resistivi la corrente di targa dell'SSR deve essere almeno 2 volte quella del carico, nei carichi induttivi come motori e trasformatori 3–4 volte. Per i calcoli di potenza e corrente puoi usare il calcolatore della legge di Ohm e l'articolo sul calcolo della potenza elettrica.
| Corrente del carico (230 V) | Carico di esempio | Calore nell'SSR (≈1,3 V) | Raffreddamento consigliato |
|---|---|---|---|
| 0,5 A | Lampada a incandescenza da 100 W | ≈ 0,7 W | Dissipatore non necessario |
| 2 A | Stufa da 450 W | ≈ 2,6 W | Al limite; consigliato un piccolo dissipatore |
| 4,3 A | Stufa da 1000 W | ≈ 5,6 W | Dissipatore medio (≈ 5 °C/W o meglio) |
| 8,7 A | Stufa da 2000 W | ≈ 11 W | Dissipatore grande (≈ 2,5 °C/W) e SSR da almeno 25 A |
| 13 A | Stufa da 3000 W | ≈ 17 W | Dissipatore ventilato e SSR originale da 40 A |
Collegamento dell'SSR: Arduino Uno, ESP32 e Raspberry Pi Pico
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Pin di controllo | D8 | GPIO 26 | GP15 |
| Ingresso SSR + (3) | Direttamente a D8 | 5V/VIN (con transistor) | VBUS (con transistor) |
| Ingresso SSR − (4) | GND | Collettore NPN | Collettore NPN |
| Base NPN (BC547 / 2N2222) | - | GPIO 26 con 1 kΩ, GND con 10 kΩ | GP15 con 1 kΩ, GND con 10 kΩ |
| Emettitore NPN | - | GND | GND |
| Dati DS18B20 | D2 | GPIO 4 | GP16 |
| VCC DS18B20 | 5V | 3V3 | 3V3(OUT) |
| Pull-up da 4,7 kΩ | Dati – 5V | Dati – 3V3 | Dati – 3V3 |
I pin di Arduino Uno forniscono 5 V e senza problemi fino a 20 mA, quindi puoi collegare l'ingresso dell'SSR-DA direttamente tra D8 e GND; dentro l'ingresso c'è già un limitatore di corrente, quindi non serve una resistenza. ESP32 e Pico funzionano invece a 3,3 V. Anche se sull'etichetta c'è scritto "3–32 V DC", 3,3 V è molto vicino al limite inferiore: se il pin scende a 3,1 V sotto carico, o con una copia di SSR che richiede più tensione in ingresso, il relè a volte scatta e a volte no. Inoltre i pin del Pico per impostazione predefinita sono configurati per circa 4 mA. Per questo, sulle schede a 3,3 V il metodo più affidabile è pilotare l'SSR a 5 V con un transistor NPN: il GPIO va alla base del transistor con una resistenza da 1 kΩ, il + dell'SSR a 5 V, il − al collettore e l'emettitore a GND. Con il GPIO a HIGH il transistor conduce e l'SSR vede circa 4,8 V. La resistenza da 10 kΩ tra base e GND evita che la stufa parta da sola quando il pin è flottante durante l'accensione o il riavvio della scheda. Tutti i GND devono essere in comune; il motivo lo trovi nell'articolo sul GND comune.
- Prima scollega completamente la rete: stacca la spina o abbassa l'interruttore e verifica che sui morsetti non ci sia tensione.
- Fissa l'SSR al dissipatore con un sottile strato di pasta termica; collega dissipatore e scatola metallica alla messa a terra di protezione (cavo giallo-verde).
- Collega il lato di controllo: i terminali 3 (+) e 4 (−) ad Arduino o al transistor secondo la tabella qui sopra, carica il codice senza la rete collegata e controlla che il LED sull'SSR lampeggi.
- Sul lato carico collega la fase (cavo marrone) al terminale 1 dell'SSR e il terminale 2 alla stufa; il neutro (blu) va direttamente alla stufa. Sulla linea di fase metti un fusibile adatto alla corrente del carico.
- Scegli la sezione dei cavi in base alla corrente: almeno 1,5 mm² fino a 10 A, 2,5 mm² per 16 A; metti i puntalini sui cavi a più fili e stringi bene le viti.
- Collega in serie alla stufa un fusibile termico o un termostato bimetallico indipendente da Arduino: se l'SSR va in cortocircuito, questa è l'ultima protezione.
- Metti tutta la parte di rete in una scatola isolante con coperchio; non dare tensione prima di chiuderla e senza alimentarla da una linea protetta da un interruttore differenziale.
Controllo di un riscaldatore con Arduino: termostato a proporzione di tempo
Il programma seguente misura con un sensore di temperatura DS18B20 e regola la potenza del riscaldatore con finestre temporali di 2 secondi. L'obiettivo è 40 °C e la banda proporzionale 5 °C: a 35 °C o meno il riscaldatore lavora al 100%, a 37,5 °C al 50% e a 40 °C allo 0%. Così si riduce il forte overshoot dei semplici termostati on/off. Il codice non usa delay(); misura e finestre temporali sono gestite con millis() e la conversione del sensore, che dura circa 750 ms, si completa in background senza attese. Se il sensore si scollega (-127 °C) o la temperatura supera il limite di sicurezza di 70 °C, il riscaldatore si spegne subito. Per i dettagli sul collegamento del sensore vedi l'articolo sul sensore di temperatura DS18B20; per compilare il codice installa le librerie OneWire e DallasTemperature dal Gestore librerie.
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: comando a 3,3 V e termostato con isteresi
Sull'ESP32 vediamo un altro metodo: il controllo on/off con isteresi. Quando la temperatura scende sotto i 39 °C il riscaldatore si accende, quando supera i 41 °C si spegne; la banda morta di 2 °C evita che l'SSR si accenda e spenga di continuo per le piccole oscillazioni del sensore. L'SSR è pilotato a 5 V con un transistor NPN collegato al GPIO 26, come nella tabella. Abbiamo scelto apposta il GPIO 26: i GPIO 0, 2, 5, 12 e 15 sono pin che determinano il comportamento di boot della scheda e un carico collegato a questi pin può attivarsi involontariamente all'avvio. Il codice si compila allo stesso modo con l'ESP32 Arduino core 2.x e 3.x; solo se usi il core 3.x installa la versione 2.3.8 o successiva della libreria OneWire. Come passo successivo puoi portare questo termostato sul Wi-Fi e impostare la temperatura target dal telefono tramite 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}Controllo di un SSR con Raspberry Pi Pico e MicroPython
Su Raspberry Pi Pico i moduli onewire e ds18x20 sono già inclusi in MicroPython; non devi copiare altri file. Il codice seguente è lo stesso controllo a proporzione di tempo dell'esempio Arduino: il DS18B20 è collegato a GP16 e la base del transistor che pilota l'SSR a GP15 tramite una resistenza da 1 kΩ. Collega il + dell'SSR al pin VBUS (pin fisico 40), che fornisce 5 V quando il Pico è alimentato via USB. Per i calcoli di tempo si usano time.ticks_ms() e time.ticks_diff(): queste funzioni danno la differenza corretta anche in caso di overflow del contatore, quindi sono sicure in un termostato che funziona a lungo. Se il sensore non viene trovato o la lettura dà errore, il rapporto di potenza va a zero, cioè il riscaldatore resta spento. Se usi il Pico per la prima volta, per l'installazione di MicroPython vedi l'articolo Cos'è 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)Avviso sugli SSR falsi: perché un relè da 40 A brucia?
Gran parte degli SSR economici in commercio sono copie che imitano l'aspetto di un marchio noto. Dentro molti falsi relè da 40 A aperti si trova un piccolo triac da 12–16 A; alcuni non hanno il circuito di zero crossing né il circuito di protezione (snubber) in uscita, e anche l'isolamento ingresso-uscita è molto inferiore a quello dichiarato. Questi relè si surriscaldano già con pochi ampere, l'involucro di plastica si ammorbidisce e spesso si guastano in cortocircuito, cioè il riscaldatore non si spegne più. Per questo, nei progetti con riscaldatori, non considerare l'SSR come unico elemento di sicurezza. Puoi riconoscere un SSR falso da questi segnali:
- Prezzo e peso: costa diverse volte meno degli SSR di marca originali e in mano risulta nettamente più leggero.
- Stesso involucro, corrente diversa: le versioni da 10 A, 25 A e 40 A vendute con dimensioni, prezzo e peso identici.
- Difetti di stampa ed etichetta: logo sbiadito o storto, nome del marchio con errori, nessun numero di serie o data di produzione.
- Resina di riempimento: il materiale sul lato inferiore è irregolare, con bolle o con vuoti.
- Test di riscaldamento: misura con un termometro la temperatura della base metallica nella prima ora sotto carico; se supera rapidamente i 60 °C anche a metà della corrente nominale, non fidarti del relè.
- Soluzione sicura: compra marchi noti come Omron, Crydom, Carlo Gavazzi o Schneider da un venditore affidabile; usa un SSR di origine incerta al massimo a un quarto della corrente di targa.
Idee di progetti con SSR
- Termostato intelligente: mantieni il riscaldatore della stanza alla temperatura desiderata; per la logica di base vedi l'articolo sul termostato con Arduino.
- Sous-vide e yogurtiera: per tenere l'acqua costante con una precisione di ±0,5 °C, combina il controllo a proporzione di tempo con il controllo PID.
- Incubatrice: mantieni stabili i 37,5 °C per giorni; aggiungi un secondo sensore per monitorare l'umidità.
- Mini forno reflow: scalda un piccolo forno elettrico seguendo il profilo di saldatura con una termocoppia MAX6675 e un SSR.
- Presa intelligente: accendi e spegni dal telefono dispositivi a 230 V con ESP32; i dettagli sono nell'articolo sulla presa intelligente con ESP32.
- Riscaldatore per tubi e serre: con un allarme antigelo attiva il cavo riscaldante quando la temperatura scende a 2 °C.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il LED dell'SSR è acceso, il carico non funziona | Circuito del carico aperto, fusibile saltato o corrente del carico sotto la corrente minima dell'SSR | Controlla fase e neutro; per carichi molto piccoli usa un relè meccanico |
| Il carico non si spegne mai | Carico DC pilotato con un SSR a uscita AC oppure SSR in cortocircuito | Per il DC usa un SSR di tipo DD o un MOSFET; sostituisci l'SSR guasto |
| Da spento la lampadina LED si accende debolmente o lampeggia | Corrente di dispersione dell'SSR | Aggiungi in parallelo al carico una resistenza di carico adatta o scegli un relè meccanico per questo carico |
| Il multimetro misura 230 V all'uscita dell'SSR spento | È normale in una misura a vuoto a causa della dispersione | Esegui la misura con il carico collegato |
| SSR e dissipatore si scaldano molto | Dissipatore piccolo, niente pasta termica, corrente troppo alta o SSR falso | Ingrandisci il dissipatore, ricalcola la corrente, usa un SSR originale di marca |
| Con ESP32 o Pico a volte non scatta | I 3,3 V sono al limite inferiore dell'ingresso | Pilota l'SSR a 5 V con un transistor NPN |
| All'accensione della scheda il riscaldatore parte per un attimo | All'avvio il pin è flottante o è stato scelto un pin di boot | Aggiungi un pull-down da 10 kΩ, usa un pin sicuro come il GPIO 26 |
| La regolazione di potenza con analogWrite è incoerente | L'SSR con zero crossing non segue un PWM veloce | Usa una finestra a proporzione di tempo di 1–2 secondi |
Se scelto correttamente e ben raffreddato, l'SSR è il modo più silenzioso e duraturo per controllare un riscaldatore nei progetti Arduino; basta scegliere l'SSR adatto al tipo di carico, calcolare la corrente con margine, stare attenti ai relè falsi e aggiungere sempre una protezione termica indipendente. Se vuoi capire passo dopo passo la logica dei relè e la misura della temperatura, nell'app BlueGrays trovi progetti con schemi e codice per accendere una lampadina a 220 V con pulsante e telecomando, illuminazione intelligente con ESP32 e misura della temperatura.
Domande frequenti
Si può collegare un relè SSR direttamente ad Arduino?
Sì. Puoi collegare il terminale 3 (+) di un SSR con ingresso DC come l'SSR-25DA a un pin digitale di Arduino e il 4 (−) a GND; l'ingresso assorbe solo 5–15 mA e ha già un limitatore di corrente, quindi non serve una resistenza. Il lato carico è completamente isolato da Arduino e va cablato a parte secondo le norme per la rete elettrica.
Un relè SSR funziona a 3,3 V?
La maggior parte degli SSR con ingresso 3–32 V scatta a 3,3 V, ma questo valore è molto vicino al limite inferiore e non è affidabile, soprattutto con relè copia. Con ESP32 e Raspberry Pi Pico la soluzione più robusta è pilotare l'SSR a 5 V con un transistor NPN come il BC547 o il 2N2222.
Perché l'SSR si scalda, il dissipatore è obbligatorio?
In conduzione ai capi dell'SSR cadono circa 1–1,6 V e, moltiplicati per la corrente, diventano calore: a 10 A sono circa 13 W. Senza dissipatore un SSR funziona in sicurezza in genere fino a circa 2 A; con correnti maggiori serve un dissipatore di alluminio montato con pasta termica.
Con un SSR si può controllare un motore DC o una strip LED?
Solo con un SSR a uscita DC (tipo DD). Gli SSR a uscita AC con scritto DA o AA sull'etichetta usano un triac e, in corrente continua, una volta accesi non si spengono più. Per i carichi DC a bassa tensione un MOSFET a livello logico è spesso una scelta più economica ed efficiente.
Con un SSR a zero crossing si può regolare una lampada?
No. Un SSR a zero crossing può accendersi solo quando la tensione è vicina a zero, quindi non può fare il controllo di fase: la lampada o è accesa del tutto o sfarfalla. Per regolare l'intensità servono un SSR ad accensione immediata (random turn-on) con un circuito di rilevamento dello zero oppure un modulo dimmer AC già pronto; per i riscaldatori, invece, il metodo giusto è lo zero crossing con controllo a proporzione di tempo.
Perché misuro tensione all'uscita di un SSR spento?
Anche da spenti, gli SSR lasciano passare qualche milliampere di dispersione a causa del circuito di protezione in uscita e della struttura del semiconduttore. Senza carico collegato, l'alta resistenza interna del multimetro con questa piccola corrente mostra quasi la tensione di rete; è normale. Proprio per questo non usare l'SSR come sezionatore di sicurezza e prima di ogni intervento stacca sempre la spina.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

Lampadina 220V con pulsante (Push)
Finché tieni premuto il pulsante, una vera lampadina da 220 volt resta accesa, e si spegne appena lo lasci.

Accendere e spegnere una lampadina 220V con un pulsante
Vuoi accendere e spegnere una vera lampadina di casa con un piccolo pulsante? Ogni volta che lo premi, l'Arduino fa scattare un relè e la lampadina si accende; premendo di nuovo si spegne.

Accendere una lampadina 220V con il telecomando
Accendi e spegni una vera lampadina di casa con un telecomando, senza alzarti dal divano.

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

ESP32 DHT22 Temperatura e umidità (con display LCD)
Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

Illuminazione intelligente di scale e corridoi
Metti piede sulle scale o nel corridoio e le luci si accendono gradino dopo gradino nella direzione in cui cammini.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

