Solid-State-Relais (SSR) Arduino: Heizung sicher schalten
Solid-State-Relais mit Arduino nutzen: Unterschied zum Relais, DA/AA-Typen, Nulldurchgang, Kühlkörper, ESP32 mit 3,3 V, Pico-Code und Warnung vor Fake-SSRs.
Ein SSR (Solid-State-Relais, auf Deutsch Halbleiterrelais) ist ein elektronischer Schalter, mit dem ein Mikrocontroller wie der Arduino über ein kleines Signal von 3–32 V Lasten wie eine 230-V-Heizung, eine Lampe, ein Backofen-Heizelement oder einen Wasserkocher schaltet, und zwar völlig ohne bewegliche Teile. Beim klassischen Relais zieht eine Spule einen Metallkontakt an; beim SSR übernimmt das ein lichtgesteuerter Halbleiter. Deshalb klickt es nicht, die Kontakte verschleißen nicht, es entstehen keine Funken, und es hält auch bei vielen Schaltvorgängen pro Minute jahrelang. Gerade bei Heizungsprojekten mit häufigem Ein- und Ausschalten wie Thermostat, Brutkasten, Sous-vide und Ofen sind SSR und Arduino fast der Standard.
Ein SSR ist aber keine Zauberbox: An ihm fällt eine Spannung von 1–1,6 V ab, was bei hohen Strömen viel Wärme bedeutet; im ausgeschalteten Zustand lässt es einige Milliampere Leckstrom durch; ein SSR mit AC-Ausgang kann eine Gleichstromlast nicht abschalten; und ein großer Teil der billigen SSRs auf dem Markt sind Kopien, die den aufgedruckten Strom nicht tragen können. In diesem Artikel lernst du Schritt für Schritt den Aufbau des SSR, den Unterschied zum mechanischen Relais, die Kürzel DA, DD und AA auf dem Etikett, den Nulldurchgang, die Kühlkörper-Berechnung, die sichere Heizungssteuerung mit Arduino, ESP32 und Raspberry Pi Pico und wie du ein gefälschtes SSR erkennst.
Was ist ein SSR (Solid-State-Relais) und wie funktioniert es?
In einem SSR stecken zwei getrennte Welten. Auf der Eingangsseite sitzt zusammen mit einer Strombegrenzung eine Infrarot-LED; sie leuchtet, wenn du an Anschluss 3 und 4 Spannung anlegst. Auf der Ausgangsseite befinden sich eine lichtempfindliche Zündschaltung und das Leistungselement, das die eigentliche Last trägt: bei AC-Modellen ein Triac oder zwei antiparallele Thyristoren (SCR), bei DC-Modellen ein MOSFET. Zwischen Eingang und Ausgang gibt es nur Licht, daher sind beide Seiten galvanisch getrennt; das Prinzip ist dasselbe wie beim Optokoppler und bietet typisch 2500 V Isolation oder mehr. So berührt die Masse (GND) des Arduino nie das Stromnetz. Bei AC-Modellen erlischt der Triac von selbst, sobald der Strom durch null geht; wenn du das Eingangssignal wegnimmst, schaltet die Last also spätestens nach einer Halbperiode (bei 50 Hz 10 ms) ab.
| Merkmal | Typischer Wert (Klasse SSR-25DA) |
|---|---|
| Eingangsspannung (Steuerung) | 3–32 V DC |
| Eingangsstrom | ca. 5–15 mA |
| Ausgangsspannung (Last) | 24–380 V AC |
| Nennstrom am Ausgang | 25 A (nur mit passendem Kühlkörper) |
| Spannungsabfall im Einschaltzustand | 1,0–1,6 V |
| Leckstrom im Ausschaltzustand | Einige mA (je nach Modell 1–10 mA) |
| Isolation | 2500 V AC und mehr |
| Ein- / Ausschaltzeit | ≤ 10 ms (wegen Nulldurchgang) |
| Anschlüsse | 1–2: Last, 3 (+) und 4 (−): Steuereingang |
Unterschied zwischen SSR und mechanischem Relais

| Merkmal | Mechanisches Relais | SSR (Solid-State-Relais) |
|---|---|---|
| Schaltelement | Spule + Metallkontakt | Triac, Thyristor oder MOSFET |
| Geräusch | Klickt | Lautlos |
| Lebensdauer | Etwa 100.000 Schaltungen unter Last | Praktisch unbegrenzt viele Schaltungen |
| Funken und Störungen | Beim Öffnen entsteht ein Lichtbogen | Bei Nulldurchgangs-Modellen sehr gering |
| Verlust im Einschaltzustand | Sehr gering (Kontakt im Milliohm-Bereich) | 1–1,6 V Abfall, erwärmt sich |
| Leckstrom im Ausschaltzustand | Keiner, vollständige Trennung | Einige mA Leckstrom |
| AC und DC | Schaltet beides | Je nach Typ nur AC oder nur DC |
| Steuerstrom | 70–90 mA für die Spule (über Modul) | 5–15 mA, direkt am Pin anschließbar |
| Ausfallart | Kontakt kann kleben oder offen bleiben | Meist Kurzschluss, also dauerhaft an |
| Preis | Günstig | Teurer, dazu kommt der Kühlkörper |
DA- und AA-Typen: Was bedeuten DA, DD, AA auf dem SSR-Etikett?
Der zweistellige Code auf dem SSR-Etikett nennt zuerst den Typ des Eingangs, dann den des Ausgangs. Dabei gibt es eine kleine Sprachfalle: Im Türkischen steht DA für Gleichstrom und AA für Wechselstrom, doch die Kürzel auf dem Etikett stammen aus dem Englischen, wobei D für DC und A für AC steht. Ein SSR-25DA ist also kein „Gleichstromrelais“, sondern ein Relais, das mit DC gesteuert wird und eine AC-Last schaltet; das ist auch der in Arduino-Projekten am häufigsten genutzte Typ. Ein SSR-25DD wird mit DC gesteuert und schaltet eine DC-Last (zum Beispiel ein 12-V-Heizpad oder eine Pumpe). Ein SSR-25AA verlangt auch am Eingang Netzspannung; es wird nicht direkt mit einem Mikrocontroller genutzt, sondern eher, damit ein Thermostat oder Schalter eine große Last treibt. Wenn dich das verwirrt, hilft dir der Artikel Unterschied zwischen AC- und DC-Strom, die Grundlagen aufzufrischen.
| Etikettcode | Eingang (Steuerung) | Ausgang (Last) | Typische Anwendung |
|---|---|---|---|
| DA (z. B. SSR-25DA) | 3–32 V DC | 24–380 V AC | 230-V-Heizung, Lampe, Ofen mit Arduino |
| DD (z. B. SSR-25DD) | 3–32 V DC | 5–60 V DC (je nach Modell unterschiedlich) | 12/24-V-Heizpad, Pumpe, LED-Streifen |
| AA (z. B. SSR-25AA) | 90–250 V AC | 24–380 V AC | Große AC-Last per Schalter oder Thermostat treiben |
| Modul G3MB-202P | 5 V DC | 100–240 V AC, maximal 2 A | Kleine AC-Lasten: Lampe, kleiner Lüfter |
Was ist der Nulldurchgang (Zero-Cross) und warum ist er wichtig?
Die Netzspannung ist eine 50-Hz-Sinuswelle und geht alle 10 ms durch null. Wenn du einem Nulldurchgangs-SSR das Einschaltsignal gibst, schaltet es den Ausgang nicht sofort durch, sondern wartet auf den ersten Moment, in dem die Spannung nahe null liegt. So schaltet die Heizung oder Glühlampe nicht im Spannungsscheitel bei etwa 325 V ein, sondern nahe null; Einschaltstromstoß, elektromagnetische Störungen und Brummen sinken stark. Für ohmsche Lasten ist das ideal. Der Preis: Mit einem Nulldurchgangs-SSR kannst du eine Lampe nicht per Phasenanschnitt dimmen; dafür braucht es sogenannte „Random-Turn-On“-Modelle, die sofort einschalten. Aus demselben Grund ist das 490-Hz-analogWrite-Signal des Arduino für ein SSR sinnlos, weil sich das Signal in jeder Halbperiode mehrmals ändert und das Ergebnis zufällig wird (im Artikel PWM siehst du, warum die Frequenz wichtig ist). Der richtige Weg, die Heizleistung zu regeln, ist die zeitproportionale Steuerung: Hältst du die Last in einem 2-Sekunden-Fenster 1,2 Sekunden an und 0,8 Sekunden aus, erhältst du 60 % Leistung. Da 2 Sekunden 200 Halbperioden entsprechen, liegt die Auflösung dieser Methode bei etwa 0,5 %.
Kühlkörper-Bedarf: Wie heiß wird ein SSR?
Der Kontakt eines mechanischen Relais hat nahezu null Widerstand; der Triac eines SSR dagegen lässt im leitenden Zustand etwa 1,2–1,6 V abfallen. Die Verlustleistung ergibt sich grob aus P = U_Abfall × I. Eine 2000-W-Heizung zieht bei 230 V I = 2000 / 230 ≈ 8,7 A; bei 1,3 V Abfall am SSR entstehen P ≈ 1,3 × 8,7 ≈ 11 W Wärme. Das reicht, um eine kleine Lötkolbenspitze zu heizen, und ein SSR-Gehäuse ohne Kühlkörper erreicht in wenigen Minuten gefährliche Temperaturen. Da das Kunststoffgehäuse allein nur etwa 2–3 W abführen kann, liegt die praktische Grenze ohne Kühlkörper bei etwa 2 A. Schraube das SSR mit einer dünnen Schicht Wärmeleitpaste auf einen Aluminium-Kühlkörper, achte darauf, dass die Metallbasis nicht über 80 °C kommt, und wähle den Nennstrom großzügig: Bei ohmschen Lasten sollte der Nennstrom des SSR mindestens das Doppelte des Laststroms betragen, bei induktiven Lasten wie Motoren und Transformatoren das 3- bis 4-Fache. Für die Leistungs- und Stromberechnung kannst du den Ohmschen-Gesetz-Rechner und den Artikel Elektrische Leistung berechnen nutzen.
| Laststrom (230 V) | Beispiellast | Wärme im SSR (≈1,3 V) | Kühlempfehlung |
|---|---|---|---|
| 0,5 A | 100-W-Glühlampe | ≈ 0,7 W | Kein Kühlkörper nötig |
| 2 A | 450-W-Heizung | ≈ 2,6 W | Grenzwertig; kleiner Kühlkörper empfohlen |
| 4,3 A | 1000-W-Heizung | ≈ 5,6 W | Mittelgroßer Kühlkörper (≈ 5 °C/W oder besser) |
| 8,7 A | 2000-W-Heizung | ≈ 11 W | Großer Kühlkörper (≈ 2,5 °C/W) und mindestens 25-A-SSR |
| 13 A | 3000-W-Heizung | ≈ 17 W | Kühlkörper mit Lüfter und echtes 40-A-Marken-SSR |
SSR anschließen: Arduino Uno, ESP32 und Raspberry Pi Pico
| Anschluss | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Steuerpin | D8 | GPIO 26 | GP15 |
| SSR-Eingang + (3) | direkt an D8 | 5V/VIN (mit Transistor) | VBUS (mit Transistor) |
| SSR-Eingang − (4) | GND | NPN-Kollektor | NPN-Kollektor |
| NPN-Basis (BC547 / 2N2222) | - | über 1 kΩ an GPIO 26, 10 kΩ gegen GND | über 1 kΩ an GP15, 10 kΩ gegen GND |
| NPN-Emitter | - | GND | GND |
| DS18B20 Daten | D2 | GPIO 4 | GP16 |
| DS18B20 VCC | 5V | 3V3 | 3V3(OUT) |
| 4,7-kΩ-Pull-up | Daten – 5V | Daten – 3V3 | Daten – 3V3 |
Da die Pins des Arduino Uno 5 V liefern und bequem bis zu 20 mA bereitstellen, kannst du den Eingang des SSR-DA direkt zwischen D8 und GND schalten; weil im Eingang eine Strombegrenzung sitzt, brauchst du keinen zusätzlichen Widerstand. ESP32 und Pico arbeiten dagegen mit 3,3 V. Auch wenn auf dem Etikett „3–32 V DC“ steht, liegt 3,3 V sehr nah an der Untergrenze; sinkt der Pin unter Last auf 3,1 V oder ist es ein Nachbau-SSR mit höherer Eingangsspannung, schaltet das Relais mal und mal nicht. Außerdem sind die Pins des Pico standardmäßig nur auf etwa 4 mA ausgelegt. Deshalb ist es bei 3,3-V-Boards am zuverlässigsten, das SSR über einen NPN-Transistor aus 5 V zu treiben: Der GPIO geht über 1 kΩ an die Transistorbasis, der Plus-Anschluss des SSR an 5 V, der Minus-Anschluss an den Kollektor und der Emitter an GND. Ist der GPIO HIGH, schaltet der Transistor durch, und das SSR sieht etwa 4,8 V. Ein 10-kΩ-Widerstand zwischen Basis und GND verhindert, dass die Heizung von selbst anläuft, wenn der Pin beim Einschalten oder Neustart des Boards offen ist. Alle Massen müssen gemeinsam sein; den Grund findest du im Artikel Gemeinsame Masse (GND).
- Trenne zuerst das Netz vollständig: Stecker ziehen oder Sicherung ausschalten und prüfen, dass an den Klemmen keine Spannung anliegt.
- Schraube das SSR mit einer dünnen Schicht Wärmeleitpaste auf den Kühlkörper; verbinde Kühlkörper und Metallgehäuse mit dem Schutzleiter (gelb-grünes Kabel).
- Schließe die Steuerseite an: Verbinde die Anschlüsse 3 (+) und 4 (−) gemäß der Tabelle oben mit dem Arduino oder dem Transistor, lade den Code bei getrenntem Netz hoch und prüfe, ob die LED am SSR blinkt.
- Verbinde auf der Lastseite die Phase (braunes Kabel) mit Anschluss 1 des SSR und Anschluss 2 mit der Heizung; der Neutralleiter (blau) geht direkt zur Heizung. Setze in die Phasenleitung eine zum Laststrom passende Sicherung.
- Wähle den Kabelquerschnitt nach dem Strom: bis 10 A mindestens 1,5 mm², für 16 A 2,5 mm²; setze auf die Enden mehrdrähtiger Kabel Aderendhülsen und ziehe die Schrauben fest an.
- Schalte in Reihe zur Heizung eine vom Arduino unabhängige Thermosicherung oder einen Bimetall-Thermostat; falls das SSR mit Kurzschluss ausfällt, ist das die letzte Sicherheit.
- Setze den gesamten Netzteil in ein geschlossenes, isolierendes Gehäuse; nimm es erst in Betrieb, wenn das Gehäuse zu ist und die Schaltung über eine Leitung mit Fehlerstromschutzschalter versorgt wird.
Heizungssteuerung mit Arduino: zeitproportionaler Thermostat
Das folgende Programm misst mit einem DS18B20-Temperatursensor und stellt die Heizleistung über 2-Sekunden-Zeitfenster ein. Das Ziel ist 40 °C, das Proportionalband 5 °C: Bei 35 °C und darunter läuft die Heizung mit 100 %, bei 37,5 °C mit 50 % und bei 40 °C mit 0 % Leistung. So wird das starke Überschwingen einfacher Ein/Aus-Thermostate geringer. Der Code verwendet delay() nicht; Messung und Fensterzeit laufen über millis(), und die etwa 750 ms dauernde Wandlung des Sensors wird im Hintergrund abgeschlossen, ohne darauf zu warten. Löst sich der Sensor (-127 °C) oder überschreitet die Temperatur die Sicherheitsgrenze von 70 °C, wird die Heizung sofort abgeschaltet. Details zum Sensoranschluss findest du im Artikel DS18B20-Temperatursensor; zum Kompilieren installierst du im Bibliotheksverwalter die Bibliotheken OneWire und 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 mit dem ESP32: 3,3-V-Ansteuerung und Thermostat mit Hysterese
Beim ESP32 zeigen wir eine andere Methode: die Ein/Aus-Regelung mit Hysterese. Fällt die Temperatur unter 39 °C, schaltet die Heizung ein, steigt sie über 41 °C, schaltet sie aus; das 2 °C breite Totband verhindert, dass das SSR wegen kleiner Schwankungen am Sensor ständig ein- und ausschaltet. Das SSR wird wie in der Tabelle über einen NPN-Transistor an GPIO 26 aus 5 V getrieben. GPIO 26 haben wir bewusst gewählt: GPIO 0, 2, 5, 12 und 15 bestimmen beim Start das Boot-Verhalten des Boards, und eine daran angeschlossene Last kann beim Einschalten ungewollt ausgelöst werden. Der Code lässt sich mit dem ESP32 Arduino Core 2.x und 3.x gleich kompilieren; nutzt du Core 3.x, installiere nur die OneWire-Bibliothek in Version 2.3.8 oder neuer. Im nächsten Schritt kannst du diesen Thermostat ins WLAN bringen und die Zieltemperatur per Smartphone über Home Assistant einstellen.
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}Raspberry Pi Pico und MicroPython: SSR steuern
Auf dem Raspberry Pi Pico sind die Module onewire und ds18x20 in MicroPython bereits enthalten; du musst keine zusätzlichen Dateien kopieren. Der folgende Code ist dieselbe zeitproportionale Regelung wie im Arduino-Beispiel: Der DS18B20 hängt an GP16, die Basis des Transistors, der das SSR treibt, über 1 kΩ an GP15. Verbinde den Plus-Anschluss des SSR mit dem Pin VBUS (physischer Pin 40), der 5 V liefert, wenn der Pico per USB versorgt wird. Für die Zeitberechnung dienen time.ticks_ms() und time.ticks_diff(); diese Funktionen liefern auch bei Zählerüberlauf die richtige Differenz und sind daher bei einem lange laufenden Thermostat sicher. Wird der Sensor nicht gefunden oder gibt das Lesen einen Fehler, wird der Leistungsanteil auf null gesetzt, die Heizung bleibt also aus. Wenn du den Pico zum ersten Mal nutzt, findest du die MicroPython-Installation im Artikel Was ist der 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)Warnung vor gefälschten SSRs: Warum brennt ein Relais mit der Aufschrift 40 A?
Ein großer Teil der billigen SSRs auf dem Markt sind Kopien, die das Aussehen einer bekannten Marke nachahmen. Aus vielen zerlegten gefälschten 40-A-Relais kommt ein kleiner Triac mit 12–16 A zum Vorschein; manchen fehlen die Nulldurchgangsschaltung oder die Schutzbeschaltung (Snubber) am Ausgang, und die Isolation zwischen Ein- und Ausgang ist viel niedriger als angegeben. Diese Relais überhitzen schon bei wenigen Ampere, das Kunststoffgehäuse wird weich, und sie fallen meist mit Kurzschluss aus; die Heizung schaltet dann nie wieder ab. Betrachte das SSR deshalb bei Heizungsprojekten nie als einziges Sicherheitselement. Ein gefälschtes SSR erkennst du an diesen Anzeichen:
- Preis und Gewicht: Es ist um ein Vielfaches billiger als echte Marken-SSRs und fühlt sich in der Hand deutlich leichter an.
- Gleiches Gehäuse, anderer Strom: Die Versionen mit 10 A, 25 A und 40 A werden in exakt derselben Größe, zum selben Preis und mit demselben Gewicht verkauft.
- Druck- und Etikettfehler: Verblasstes oder verrutschtes Logo, falsch geschriebener Markenname, keine Seriennummer oder kein Herstellungsdatum.
- Vergussmasse: Die Füllmasse an der Unterseite ist ungleichmäßig, blasig oder stellenweise leer.
- Erwärmungstest: Miss in der ersten Stunde unter Last die Temperatur der Metallbasis mit einem Thermometer; steigt sie schon bei halbem Nennstrom schnell über 60 °C, vertraue dem Relais nicht.
- Sichere Lösung: Kaufe bekannte Marken wie Omron, Crydom, Carlo Gavazzi oder Schneider bei einem zuverlässigen Händler; nutze ein SSR unklarer Herkunft höchstens mit einem Viertel des Nennstroms.
Projektideen mit SSR
- Smarter Thermostat: Halte den Raumheizer auf der Zieltemperatur; die Grundlogik findest du im Artikel Arduino-Thermostat.
- Sous-vide und Joghurtmaschine: Kombiniere die zeitproportionale Steuerung mit PID-Regelung, um das Wasser auf ±0,5 °C konstant zu halten.
- Brutkasten: Halte 37,5 °C tagelang stabil; füge für die Feuchtigkeitsüberwachung einen zweiten Sensor hinzu.
- Mini-Reflow-Ofen: Heize einen kleinen Elektroofen mit einem MAX6675-Thermoelement und SSR nach einem Lötprofil.
- Smarte Steckdose: Schalte 230-V-Geräte mit dem ESP32 per Smartphone ein und aus; Details im Artikel ESP32 Smart Plug.
- Rohr- und Gewächshausheizung: Schalte mit dem Frostalarm das Heizkabel ein, wenn die Temperatur auf 2 °C fällt.
Häufige Fehler und ihre Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| LED am SSR leuchtet, Last läuft nicht | Lastkreis offen, Sicherung ausgelöst oder Laststrom unter dem Mindeststrom des SSR | Phase und Neutralleiter prüfen; bei sehr kleinen Lasten ein mechanisches Relais nutzen |
| Last schaltet nie ab | DC-Last an einem SSR mit AC-Ausgang oder SSR mit Kurzschluss defekt | Für DC ein SSR vom Typ DD oder MOSFET nutzen; defektes SSR ersetzen |
| LED-Lampe glimmt oder blinkt im Ausschaltzustand leicht | Leckstrom des SSR | Einen passenden Lastwiderstand parallel zur Last schalten oder für diese Last ein mechanisches Relais wählen |
| Multimeter zeigt am Ausgang des ausgeschalteten SSR 230 V | Bei Messung ohne Last wegen des Leckstroms normal | Die Messung mit angeschlossener Last durchführen |
| SSR und Kühlkörper werden sehr heiß | Kühlkörper zu klein, keine Wärmeleitpaste, Strom zu hoch oder SSR gefälscht | Kühlkörper vergrößern, Strom neu berechnen, echtes Marken-SSR nutzen |
| Mit ESP32 oder Pico schaltet es manchmal nicht | 3,3 V liegt an der Untergrenze des Eingangs | Das SSR über einen NPN-Transistor aus 5 V treiben |
| Heizung läuft beim Einschalten des Boards kurz an | Pin ist beim Start offen oder ein Boot-Pin wurde gewählt | 10-kΩ-Pull-down ergänzen, einen sicheren Pin wie GPIO 26 nutzen |
| Leistungsregelung mit analogWrite ist unstetig | Ein Nulldurchgangs-SSR kann schnellem PWM nicht folgen | Ein zeitproportionales Fenster von 1–2 Sekunden nutzen |
Richtig gewählt und gut gekühlt ist das SSR bei Arduino-Projekten der leiseste und langlebigste Weg, eine Heizung zu steuern; wähle nur ein SSR passend zum Lasttyp, rechne den Strom großzügig, nimm dich vor gefälschten Relais in Acht und baue immer einen unabhängigen Übertemperaturschutz ein. Wenn du zuerst Schritt für Schritt die Relais-Logik und die Temperaturmessung verstehen willst, findest du in der BlueGrays-App Projekte wie eine 220-V-Glühlampe per Taster und Fernbedienung schalten, ESP32-Smart-Beleuchtung und Temperaturmessung mit Schaltplänen und Code.
Häufige Fragen
Kann ich ein SSR direkt an den Arduino anschließen?
Ja. Bei einem SSR mit DC-Eingang wie dem SSR-25DA kannst du Anschluss 3 (+) an einen digitalen Pin des Arduino und Anschluss 4 (−) an GND legen; da der Eingang nur 5–15 mA zieht und eine Strombegrenzung enthält, brauchst du keinen zusätzlichen Widerstand. Die Lastseite ist vom Arduino vollständig isoliert und muss nach den Regeln für Netzspannung separat verdrahtet werden.
Funktioniert ein SSR mit 3,3 V?
Die meisten SSRs mit 3–32 V Eingang schalten bei 3,3 V, doch dieser Wert liegt sehr nah an der Untergrenze und ist besonders bei Nachbauten nicht zuverlässig. Mit ESP32 und Raspberry Pi Pico ist es am robustesten, das SSR über einen NPN-Transistor wie BC547 oder 2N2222 aus 5 V zu treiben.
Warum wird ein SSR heiß und ist ein Kühlkörper Pflicht?
Im leitenden Zustand fallen am SSR etwa 1–1,6 V ab, und multipliziert mit dem Strom wird daraus Wärme; bei 10 A sind das etwa 13 W. Ohne Kühlkörper arbeitet ein SSR meist bis etwa 2 A sicher; bei größeren Strömen ist ein mit Wärmeleitpaste montierter Aluminium-Kühlkörper Pflicht.
Kann man mit einem SSR einen DC-Motor oder LED-Streifen steuern?
Nur mit einem SSR mit DC-Ausgang (Typ DD). SSRs mit AC-Ausgang, auf denen DA oder AA steht, verwenden einen Triac und schalten bei Gleichstrom nach dem Einschalten nicht mehr ab. Für DC-Lasten mit niedriger Spannung ist oft ein Logic-Level-MOSFET die günstigere und effizientere Wahl.
Lässt sich eine Lampe mit einem Nulldurchgangs-SSR dimmen?
Nein. Ein Nulldurchgangs-SSR kann nur bei Spannung nahe null einschalten und daher keinen Phasenanschnitt machen; die Lampe leuchtet entweder voll oder flackert. Zum Dimmen brauchst du ein SSR mit sofortigem Einschalten (Random Turn-On) und eine Schaltung mit Nulldurchgangserkennung oder ein fertiges AC-Dimmermodul; bei Heizungen ist die zeitproportionale Steuerung mit Nulldurchgangs-SSR die richtige Methode.
Warum messe ich am Ausgang eines ausgeschalteten SSR Spannung?
Auch im ausgeschalteten Zustand lassen SSRs wegen der Schutzbeschaltung am Ausgang und der Halbleiterstruktur einige Milliampere Leckstrom durch. Ohne angeschlossene Last zeigt das Multimeter mit seinem hohen Innenwiderstand bei diesem kleinen Strom fast die Netzspannung an; das ist normal. Nutze das SSR deshalb nicht als Trennschalter und ziehe vor Wartungsarbeiten immer den Stecker.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

220V Glühbirne mit Druckknopf (Push)
Solange du den Knopf gedrückt hältst, leuchtet eine echte 220-Volt-Glühbirne, und sobald du loslässt, geht sie aus.

220-V-Glühbirne mit Taster ein- und ausschalten
Willst du eine echte Glühbirne aus dem Haushalt mit einem kleinen Taster ein- und ausschalten? Bei jedem Druck schaltet der Arduino ein Relais um und die Lampe geht an, beim nächsten Druck wieder aus.

220-V-Glühbirne mit Fernbedienung schalten
Schalte eine echte Glühbirne in deiner Wohnung mit einer Fernbedienung ein und aus, ohne vom Sofa aufzustehen.

Temperaturmessung mit NTC und 2x16 Lcd Display
Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.

Intelligente Treppen- und Korridorbeleuchtung
Betrittst du die Treppe oder den Flur, gehen die Lichter Stufe für Stufe in deiner Laufrichtung an.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

