MOSFET am Arduino: 12-V-LED-Streifen, Motor und Pumpe schalten

Eine MOSFET-Schaltung am Arduino ist der effizienteste Weg, Lasten mit mehreren Ampere wie einen 12-V-LED-Streifen, einen Gleichstrommotor, eine Wasserpumpe oder ein Magnetschloss sicher zu schalten, obwohl ein Arduino-Pin nur etwa 20 mA liefern kann. Ein MOSFET ist ein spannungsgesteuerter elektronischer Schalter: Legst du 5 V an das Gate, wird die Strecke zwischen Drain und Source fast zu einem widerstandslosen Draht; bei 0 V sperrt sie vollständig. Ein richtig gewählter Logic-Level-MOSFET wird bei 3 A ohne Kühlkörper nur handwarm.

In diesem Artikel lernst du, wie ein MOSFET funktioniert, warum nicht jeder MOSFET zum Arduino passt (der Unterschied zwischen IRLZ44N und IRF520), welche Aufgabe Gate-Widerstand, Pull-down-Widerstand und Freilaufdiode haben und wie du Drehzahl und Helligkeit per PWM einstellst. Weiter unten findest du fertigen Code für LED-Streifen, Gleichstrommotor, Pumpe und Magnetschloss mit 12 V, Beispiele für ESP32 und Raspberry Pi Pico, die Berechnung von Verlustleistung und Kühlkörper sowie eine Vergleichstabelle MOSFET, Transistor und Relais.

Was ist ein MOSFET und wie funktioniert er?

Ein MOSFET (Metal Oxide Semiconductor Field Effect Transistor) ist ein Feldeffekttransistor mit drei Anschlüssen: Gate, Drain und Source. Das Gate ist durch eine dünne Oxidschicht vom Rest des Bauteils isoliert, deshalb fließt kein Dauerstrom hinein, und es verhält sich wie ein kleiner Kondensator. Steigt die Spannung zwischen Gate und Source (VGS) über eine bestimmte Schwelle, bildet sich zwischen Drain und Source ein leitender Kanal, durch den der Laststrom fließt. Ein klassischer Bipolartransistor wird über den Basisstrom gesteuert, ein MOSFET dagegen über die Spannung; der Arduino-Pin liefert nur in den wenigen Mikrosekunden Strom, in denen er das Gate auf- und entlädt.

In Arduino-Projekten verwendet man fast immer einen N-Kanal-MOSFET auf der Minusseite (GND-Seite) der Last; das nennt man Low-Side-Schalten. Der Pluspol der Last geht direkt an den Pluspol des externen Netzteils, der Minuspol an den Drain des MOSFET, und die Source kommt an GND. So entspricht die Gate-Source-Spannung genau der Spannung des Arduino-Pins. Diese Werte im Datenblatt solltest du kennen:

Logic-Level-MOSFET: IRLZ44N, IRF520 und weitere

Der häufigste Fehler: Man schaut auf VGS(th) und denkt „Schwelle 4 V, der Arduino liefert 5 V, also passt das“. Die Schwellenspannung ist aber der Punkt, an dem der Kanal gerade einmal 250 µA durchlässt; damit der MOSFET mehrere Ampere mit kleinem Widerstand führt, muss die Gatespannung deutlich darüber liegen. Die richtige Frage lautet: Bei welcher VGS garantiert das Datenblatt den RDS(on)? Ist er für 4,5 V oder 5 V angegeben, schaltet der MOSFET mit einem 5-V-Arduino voll durch; man nennt ihn dann Logic-Level-MOSFET. Steht der Wert nur für 10 V da, ist es ein Standard-MOSFET, den ein Arduino-Pin nur halb aufsteuert. In der Namensgebung von International Rectifier (heute Infineon) sind Typen mit IRL am Anfang (IRLZ44N, IRLB8721, IRL540N) Logic-Level, IRFZ44N, IRF520 und IRF540N dagegen Standardtypen.

Die Regel aus der Tabelle ist einfach: Für 5-V-Boards wie Uno, Nano und Mega wählst du einen MOSFET, dessen RDS(on) bei 4,5 V oder 5 V angegeben ist. Bei 3,3-V-Boards wie ESP32 und Pico ist es etwas schwieriger, weil die Datenblätter beliebter TO-220-MOSFETs wie IRLZ44N und IRLB8721 für 3,3 V keinen Wert garantieren; darauf kommen wir im ESP32-Abschnitt zurück. Wähle auch nicht nach dem Gehäuse: IRLZ44N und IRFZ44N stecken im gleichen Gehäuse mit fast gleicher Aufschrift, doch der eine Buchstabe (L) entscheidet beim Arduino über alles. Die Pinreihenfolge prüfst du mit dem Tool Transistor-Pinbelegung; bei TO-220-MOSFETs gilt, mit der beschrifteten Seite zu dir, von links nach rechts Gate, Drain, Source, und die Metallfahne ist mit dem Drain verbunden.

MOSFET am Arduino anschließen: Gate-Widerstand, Pull-down und gemeinsame Masse

Die Grundschaltung besteht aus fünf Teilen: MOSFET, Gate-Widerstand, Pull-down-Widerstand, Freilaufdiode bei induktiven Lasten und externes Netzteil. Die Tabelle zeigt die Verdrahtung für drei Boards; als Beispiellast dient ein 12-V-LED-Streifen oder ein Motor. Alle Codebeispiele in diesem Artikel nutzen diese Pins.

Der Gate-Widerstand (100–220 Ω) begrenzt den kurzen Stromstoß aus dem Pin, während die Gatekapazität geladen wird. Der IRLZ44N hat eine Eingangskapazität von etwa 1700 pF; ohne Widerstand sieht der Pin bei jedem Umschalten kurz fast einen Kurzschluss, und auf der Gateleitung entstehen Schwingungen (Ringing). Mit 220 Ω beträgt der Spitzenstrom höchstens 5 / 220 ≈ 23 mA, und das Gate ist trotzdem in wenigen Mikrosekunden geladen. Der Pull-down-Widerstand (10 kΩ) verhindert, dass das Gate offen in der Luft hängt, solange der Pin ein Eingang ist: beim Einschalten, beim Reset und beim Hochladen eines Sketches. Ein offenes Gate kann sich durch Störungen halb aufladen; der MOSFET bleibt dann halb leitend, der Motor läuft von selbst an und der MOSFET wird schnell zu heiß. Setze den Pull-down auf die MOSFET-Seite des Gate-Widerstands, direkt zwischen Gate und Source; so bleibt der MOSFET auch dann aus, wenn sich das Steuerkabel löst. Beide Widerstände bilden einen kleinen Spannungsteiler, der aber kaum ins Gewicht fällt: Am Gate kommen 5 × 10000 / 10220 ≈ 4,89 V an.

Freilaufdiode: Warum Motor, Pumpe und Magnetspule sie brauchen

Induktive Lasten wie Motoren, Pumpen, Magnetspulen, Relaisspulen und Lüfter wehren sich gegen ein plötzliches Abschalten des Stroms. Sobald der MOSFET sperrt, entlädt sich die magnetische Energie der Spule als Spannungsspitze am Drain, die weit über der Versorgungsspannung liegt (U = L × di/dt). Diese Spitze kann die VDS-Grenze des MOSFET überschreiten und ihn zerstören oder Störungen erzeugen, die den Arduino resetten. Abhilfe schafft eine Diode, die in Sperrrichtung parallel zur Last liegt: Kathode (Ring) an Plus, Anode an den Drain. Im Normalbetrieb sperrt die Diode; schaltet der MOSFET ab, fließt der Spulenstrom über die Diode weiter und klingt sanft ab. Die Body-Diode des MOSFET übernimmt diese Aufgabe nicht, weil sie zwischen Source und Drain liegt und nicht parallel zur Last. Mehr dazu findest du im Artikel Was ist eine Diode?.

Schritt für Schritt: 12-V-LED-Streifen mit Arduino dimmen

1. Teile bereitlegen: Arduino Uno, IRLZ44N, Widerstände mit 220 Ω und 10 kΩ, ein 10-kΩ-Potentiometer, ein 12-V-LED-Streifen und ein 12-V-Netzteil, das den Strom des Streifens liefern kann.
2. Strom des Streifens berechnen: Ein 5050-Streifen mit 60 LEDs/m nimmt etwa 14,4 W pro Meter auf, also 1,2 A bei 12 V. Zwei Meter brauchen 2,4 A; wähle das Netzteil mit 20 % Reserve (mindestens 3 A).
3. MOSFET einsetzen: Source des IRLZ44N an die GND-Schiene, Gate über 220 Ω an D9 und 10 kΩ zwischen Gate und GND.
4. Last anschließen: Das +12-V-Kabel des Streifens kommt an Plus des Netzteils, das Minuskabel an den Drain. Steckbrett-Kontakte vertragen etwa 1 A; bei mehr Strom nimm Schraubklemmen oder löte die Lastleitungen.
5. Potentiometer anschließen: Äußere Anschlüsse an 5V und GND, Schleifer an A0.
6. Massen verbinden und testen: Minus des Netzteils mit dem Arduino-GND verbinden, Code hochladen und dann das Netzteil einstecken.

1// IRLZ44N ile 12 V LED şerit parlaklık kontrolü / 12 V LED strip dimming with an IRLZ44N
2const int STRIP_PIN = 9;    // PWM pini, 220 Ω ile gate'e / PWM pin, to the gate via 220 Ω
3const int POT_PIN = A0;     // potansiyometre orta ucu / potentiometer wiper
4
5void setup() {
6  pinMode(STRIP_PIN, OUTPUT);
7  digitalWrite(STRIP_PIN, LOW);             // açılışta kapalı / off at startup
8  Serial.begin(9600);
9}
10
11void loop() {
12  int pot = analogRead(POT_PIN);            // 0–1023
13  float x = pot / 1023.0;                   // 0.0–1.0
14  int duty = (int)(x * x * 255.0 + 0.5);    // basit gama düzeltmesi / simple gamma correction
15  analogWrite(STRIP_PIN, duty);             // D9'da 490 Hz PWM / 490 Hz PWM on D9
16  Serial.print("Parlaklik / Brightness: %");
17  Serial.println(duty * 100 / 255);
18  delay(50);
19}

analogWrite() erzeugt an Pin 9 ein PWM-Signal, das etwa 490-mal pro Sekunde ein- und ausschaltet; 0 bedeutet ganz aus, 255 ganz an. Die PWM-Pins des Uno sind 3, 5, 6, 9, 10 und 11; Pin 5 und 6 arbeiten mit etwa 980 Hz. Da das Auge Helligkeit nicht linear wahrnimmt, sorgt das Quadrieren des Potiwerts (eine einfache Gammakorrektur) für eine viel feinere Regelung bei geringer Helligkeit. Die Grundlagen findest du im Artikel Was ist PWM?. Rechnen wir noch die Erwärmung nach: Bei 2,4 A setzt der IRLZ44N P = I² × RDS(on) = 2,4² × 0,025 ≈ 0,14 W um und wird damit nur lauwarm. Der LED-Streifen selbst nimmt dabei 28,8 W auf; der Verlust im MOSFET liegt unter einem Prozent.

Drehzahl von Motor und Pumpe per PWM regeln

Motor und Pumpe schaltest du mit derselben Schaltung wie den LED-Streifen; der einzige Unterschied ist die Freilaufdiode parallel zur Last. Motoren haben außerdem einen Anlaufstrom: Ein stehender Motor kann im ersten Moment das 3- bis 8-Fache seines Betriebsstroms ziehen. Lege MOSFET und Netzteil deshalb auf den Blockierstrom des Motors aus und nutze einen Sanftanlauf, statt sofort von 0 auf 255 zu springen. Mini-Tauchpumpen ziehen bei 3–6 V etwa 0,1–0,3 A, 12-V-Membranpumpen meist 0,5–1 A; für beide reicht der IRLZ44N locker. Versorge eine Mini-Pumpe aber mit ihrer eigenen Spannung (5–6 V) statt mit dem 12-V-Netzteil; die MOSFET-Schaltung bleibt gleich. Mehr zur Pumpenwahl und Bewässerung findest du im Artikel Mini-Wasserpumpe.

1// IRLZ44N ile motor/pompa hız kontrolü ve yumuşak kalkış / Motor or pump speed control with soft start (IRLZ44N)
2const int MOTOR_PIN = 9;     // 220 Ω ile gate'e / to the gate via 220 Ω
3const int POT_PIN = A0;      // hız ayarı / speed setting
4const int MIN_DUTY = 60;     // bunun altında motor yalnızca vızıldar / below this the motor only hums
5
6int current = 0;             // şu anki PWM değeri / current PWM value
7
8void setup() {
9  pinMode(MOTOR_PIN, OUTPUT);
10  digitalWrite(MOTOR_PIN, LOW);
11  // TCCR1B = (TCCR1B & 0b11111000) | 0x02;   // isteğe bağlı: D9/D10 PWM ≈3,9 kHz / optional: D9/D10 PWM ≈3.9 kHz
12}
13
14void loop() {
15  int target = map(analogRead(POT_PIN), 0, 1023, 0, 255);
16  if (target < MIN_DUTY) target = 0;         // çok düşük hızda tamamen durdur / stop completely at very low speed
17
18  if (current < target) current++;           // yavaşça hızlan / speed up gently
19  else if (current > target) current--;      // yavaşça yavaşla / slow down gently
20
21  analogWrite(MOTOR_PIN, current);
22  delay(8);                                  // 0→255 yaklaşık 2 s / 0→255 takes about 2 s
23}

Der Code nähert sich alle 8 ms um einen Schritt der Solldrehzahl vom Potentiometer; so läuft der Motor in etwa 2 Sekunden von 0 auf volle Drehzahl hoch, und der Anlaufstrom zieht das Netzteil nicht in die Knie. MIN_DUTY ist der kleinste PWM-Wert, bei dem sich der Motor zu drehen beginnt; ermittle ihn mit deinem Motor durch Ausprobieren. Die 490-Hz-PWM erzeugt ein hörbares Pfeifen im Motor. Die auskommentierte TCCR1B-Zeile hebt die Frequenz von D9 und D10 auf etwa 3,9 kHz an; da auch die Servo-Bibliothek Timer1 nutzt, verwende beides nicht zusammen. Die Frequenz noch weiter zu erhöhen ist verlockend, doch weil ein Arduino-Pin das Gate eines großen MOSFET bei jedem Umschalten erst in einigen Mikrosekunden lädt, steigen die Schaltverluste mit der Frequenz: Um 20 kHz kann schon ein 2-A-Motor mehr als 1 W Verlustleistung im MOSFET verursachen. Bei solchen Frequenzen setzt man einen Gate-Treiber wie den TC4427 ein.

Magnetschloss und Lasten mit kurzer Einschaltdauer

12-V-Magnettürschlösser ziehen 0,5–1 A, und die meisten sind nicht für Dauerbetrieb ausgelegt; bleiben sie lange bestromt, wird die Spule heiß. Der Code sollte das Schloss daher nur wenige Sekunden öffnen. Da die Magnetspule nur ein- und ausgeschaltet und nicht per PWM angesteuert wird, genügt eine 1N4007 als Freilaufdiode. Im folgenden Beispiel öffnet ein Druck auf den Taster an D2 das Schloss für 3 Sekunden; danach schließt es, auch wenn der Taster noch gedrückt ist. Um das Schloss mit einem RFID-Kartenleser oder einem Keypad auszulösen, änderst du nur die if-Bedingung; Schlosstypen und das Verhalten bei Stromausfall erklärt der Artikel Magnetschloss.

1// Butonla 3 saniyelik solenoid kilit açma / Open a solenoid lock for 3 seconds with a button
2const int LOCK_PIN = 9;                 // 220 Ω ile IRLZ44N gate'ine / to the IRLZ44N gate via 220 Ω
3const int BUTTON_PIN = 2;               // buton D2 ile GND arasında / button between D2 and GND
4const unsigned long OPEN_MS = 3000;     // kilidin açık kalma süresi / how long the lock stays open
5
6void setup() {
7  pinMode(LOCK_PIN, OUTPUT);
8  digitalWrite(LOCK_PIN, LOW);          // kilit kapalı / locked
9  pinMode(BUTTON_PIN, INPUT_PULLUP);    // basılınca LOW / LOW when pressed
10}
11
12void loop() {
13  if (digitalRead(BUTTON_PIN) == LOW) {
14    digitalWrite(LOCK_PIN, HIGH);       // solenoid çeker, kilit açılır / solenoid pulls in, lock opens
15    delay(OPEN_MS);
16    digitalWrite(LOCK_PIN, LOW);        // bobini soğumaya bırak / let the coil cool down
17    while (digitalRead(BUTTON_PIN) == LOW) {}   // buton bırakılana kadar bekle / wait until released
18    delay(50);                          // buton zıplamasını süz / debounce
19  }
20}

Warum das IRF520-Modul mit 5 V nicht ausreicht

Das IRF520-MOSFET-Modul, das in vielen Starter-Kits liegt, ist eine kleine Platine mit Schraubklemmen und Angaben wie „24 V, 5 A“. Neben dem MOSFET sitzen ein paar Widerstände und eine Signal-LED; die meisten Versionen haben keine Freilaufdiode. Das Problem ist der MOSFET selbst: Der IRF520 ist ein Standard-MOSFET mit einer Schwellenspannung von 2–4 V, und sein RDS(on) von 0,27 Ω ist nur bei VGS = 10 V garantiert. Laut den typischen Kennlinien im Datenblatt begrenzt der IRF520 bei 5 V Gatespannung den Strom ab etwa 2 A; bei einem Exemplar mit hoher Schwelle liegt diese Grenze unter 1 A. Dann verhält sich der MOSFET nicht mehr wie ein Schalter, sondern wie ein veränderlicher Widerstand.

Ein Beispiel: Du steuerst mit dem IRF520-Modul einen 12-V-Motor, der 2 A zieht. Fallen am MOSFET 1,5 V ab, entsteht eine Verlustleistung von P = 1,5 × 2 = 3 W. Bei einem Wärmewiderstand von 62 °C/W für ein TO-220-Gehäuse ohne Kühlkörper sind das rund 186 °C über der Umgebungstemperatur; der MOSFET überhitzt schnell und fällt aus, im besten Fall dreht der Motor nur langsam. Die 5 A auf dem Modul gelten nur mit 10 V am Gate. So sind die Anschlüsse des Moduls belegt:

• MOSFET tauschen: Löte den IRF520 aus und setze einen IRLZ44N mit gleicher Pinfolge (G-D-S) ein; die Platine funktioniert genauso, schaltet aber jetzt mit 5 V voll durch.
• Logic-Level-Modul verwenden: Fertige Module mit dem MOSFET AOD4184A (D4184) bieten bei 4,5 V höchstens 9,5 mΩ RDS(on) und arbeiten problemlos mit einem 5-V-Arduino.
• Gate mit höherer Spannung ansteuern: Ein Gate-Treiber wie der TC4427 an 12 V macht aus dem 5-V- oder 3,3-V-Signal des Arduino 12 V am Gate; so erreicht der IRF520 seine echte Leistung. Achte auf die Grenze der Gatespannung: ±20 V beim IRF520, ±16 V beim IRLZ44N.
• Für kleine Lasten so lassen: Unter 1 A (kurzer LED-Streifen, Mini-Pumpe) arbeitet das IRF520-Modul mit 5 V bei vertretbarer Erwärmung; wird der MOSFET zu heiß zum Anfassen, verkleinere die Last.

MOSFET mit ESP32 und Raspberry Pi Pico (3,3 V)

Da die Pins von ESP32 und Pico nur 3,3 V liefern, ist die Wahl des MOSFET noch wichtiger. Das Datenblatt des IRLZ44N gibt den RDS(on) nur bis hinunter zu 4 V an; laut den typischen Kennlinien führt er auch bei etwa 3 V noch einige Ampere problemlos, bei einem Exemplar mit hoher Schwelle ist das aber nicht garantiert. Faustregel: An 3,3-V-Boards nutzt du IRLZ44N oder IRLB8721 bis 2–3 A, misst bei laufender Last die Drain-Source-Spannung mit dem Multimeter und berechnest die Verlustleistung mit P = VDS × I; ohne Kühlkörper sollte ein TO-220 unter 1 W bleiben. Für größere Ströme nimmst du einen Treiber, der das Gate auf 5–12 V anhebt, für kleine Lasten einen AO3400A, dessen RDS(on) bei 2,5 V garantiert ist. Am ESP32 wählst du für den MOSFET Pins wie GPIO 25, 26, 27, 32 oder 33: GPIO 0, 2, 5, 12 und 15 sind Strapping-Pins, und GPIO 1, 3, 5, 14 und 15 können beim Booten kurz HIGH sein oder PWM ausgeben. An diesen Pins kann die Last beim Start ungewollt anlaufen, oder der Pull-down-Widerstand stört den Bootvorgang.

Der folgende ESP32-Code startet über den MOSFET eine Pumpe mit Sanftanlauf, sobald der Bodenfeuchtesensor trockene Erde meldet, gießt 5 Sekunden lang und stoppt die Pumpe dann sanft. Für die PWM nutzt er die Funktionen ledcAttach() und ledcWrite() aus dem ESP32-Arduino-Core 3.x; die älteren 2.x-Versionen nutzten stattdessen ledcSetup() und ledcAttachPin(), und ihr ledcWrite() erwartete eine Kanalnummer statt eines Pins. Die #if-Zeilen im Code wählen die passenden Aufrufe für den installierten Core, so lässt er sich mit beiden Versionen kompilieren. Weil das Gate mit 3,3 V über 100 Ω angesteuert wird, bleibt die Frequenz bei 1 kHz; so sind die Schaltverluste vernachlässigbar. Miss die Werte des Sensors für trockene und nasse Erde wie im Artikel Bodenfeuchtesensor in deiner eigenen Erde und passe die Schwelle DRY_LEVEL an.

1// ESP32 + MOSFET ile otomatik sulama pompası / Automatic watering pump with ESP32 + MOSFET
2const int PUMP_PIN = 25;                 // 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
3const int SOIL_PIN = 34;                 // toprak nem sensörü, ADC1 / soil moisture sensor, ADC1
4const int DRY_LEVEL = 2800;              // üstü kuru sayılır, kalibre et / above this counts as dry, calibrate
5const unsigned long WATER_MS = 5000;     // sulama süresi / watering time
6
7void pumpWrite(int duty) {               // 0–255 PWM, iki çekirdek sürümünde / on both core versions
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9  ledcWrite(PUMP_PIN, duty);             // 3.x: pin numarasıyla / 3.x: by pin number
10#else
11  ledcWrite(0, duty);                    // 2.x: kanal 0 ile / 2.x: by channel 0
12#endif
13}
14
15void pumpRamp(int from, int to) {        // yumuşak hız değişimi / smooth speed change
16  int step = (to > from) ? 5 : -5;
17  for (int d = from; d != to; d += step) {
18    pumpWrite(d);
19    delay(20);
20  }
21  pumpWrite(to);
22}
23
24void setup() {
25  Serial.begin(115200);
26#if ESP_ARDUINO_VERSION_MAJOR >= 3
27  ledcAttach(PUMP_PIN, 1000, 8);         // 1 kHz, 8 bit (0–255); çekirdek 3.x / core 3.x
28#else
29  ledcSetup(0, 1000, 8);                 // çekirdek 2.x: kanal 0 / core 2.x: channel 0
30  ledcAttachPin(PUMP_PIN, 0);
31#endif
32  pumpWrite(0);                          // pompa kapalı / pump off
33}
34
35void loop() {
36  int soil = analogRead(SOIL_PIN);       // 0–4095
37  Serial.printf("Toprak / Soil: %d\n", soil);
38  if (soil > DRY_LEVEL) {
39    pumpRamp(0, 255);                    // yaklaşık 1 s'de tam hıza / full speed in about 1 s
40    delay(WATER_MS);
41    pumpRamp(255, 0);                    // yumuşakça dur / stop gently
42    delay(60000);                        // suyun toprağa yayılmasını bekle / let the water soak in
43  }
44  delay(1000);
45}

Auf dem Raspberry Pi Pico genügt in MicroPython die Klasse machine.PWM; duty_u16() nimmt Werte von 0 bis 65535 an. Der folgende Code lässt einen 12-V-LED-Streifen am MOSFET an GP15 sanft „atmen“. Wie im Arduino-Beispiel wird der Wert für eine einfache Gammakorrektur quadriert, sodass der Übergang von dunkel zu hell natürlich wirkt. Auch die Pins des Pico liefern 3,3 V, deshalb gelten hier dieselben MOSFET-Regeln wie beim ESP32.

1# Pico + MOSFET ile 12 V LED şerit nefes efekti / 12 V LED strip breathing effect with Pico + MOSFET
2from machine import Pin, PWM
3import time
4
5strip = PWM(Pin(15))          # 100 Ω ile gate'e, gate–GND 10 kΩ / to the gate via 100 Ω, 10 kΩ gate–GND
6strip.freq(1000)              # 1 kHz: titreme görünmez / 1 kHz: no visible flicker
7
8def set_level(x):             # x: 0.0–1.0
9    strip.duty_u16(int(x * x * 65535))   # basit gama düzeltmesi / simple gamma correction
10
11while True:
12    for i in range(101):                 # yavaşça aydınlan / fade in
13        set_level(i / 100)
14        time.sleep_ms(20)
15    for i in range(100, -1, -1):         # yavaşça sön / fade out
16        set_level(i / 100)
17        time.sleep_ms(20)
18    time.sleep_ms(500)

Erwärmung, Verlustleistung und Kühlkörper

Die Erwärmung eines voll durchgeschalteten MOSFET folgt aus einer einzigen Formel: P = I² × RDS(on). Zwei Punkte sind wichtig. Erstens steigt RDS(on) mit der Temperatur; beim IRLZ44N beträgt er bei 100 °C etwa das 1,5-Fache des Werts bei 25 °C, daher rechnest du realistischer mit 38 mΩ statt 25 mΩ. Zweitens kann das Gehäuse nur begrenzt Wärme an die Luft abgeben: Ein TO-220 ohne Kühlkörper hat einen Wärmewiderstand (RθJA) von 62 °C/W, jedes Watt hebt die Chiptemperatur also um 62 °C über die Umgebung. Die Tabelle zeigt, wie warm der IRLZ44N mit 5 V am Gate ohne Kühlkörper wird:

Der Kühlkörper wird nach derselben Logik bemessen: Tj = TUmgebung + P × (RθJC + RθCS + RθSA). Fallen bei 10 A 3,8 W an und soll der Chip in einem 30 °C warmen Raum bei 100 °C bleiben, darf der gesamte Wärmewiderstand (100 − 30) / 3,8 ≈ 18 °C/W nicht überschreiten. Der IRLZ44N hat 1,4 °C/W zwischen Chip und Gehäuse, ein Übergang mit Wärmeleitpaste etwa 0,5 °C/W, also darf der Kühlkörper selbst höchstens 16 °C/W haben; das entspricht einem kleinen TO-220-Kühlkörper mit Rippen. Die Metallfahne des MOSFET liegt am Drain; montierst du mehrere MOSFETs auf denselben Kühlkörper, brauchst du eine Glimmer- oder Silikon-Isolierscheibe und eine Kunststoff-Isolierbuchse für die Schraube. Die zweite Wärmequelle bei PWM sind Schaltverluste; bei 490 Hz sind sie vernachlässigbar, mit steigender Frequenz wachsen sie aber.

MOSFET, Transistor und Relais im Vergleich

Kurz gesagt: Willst du eine Gleichstromlast schnell, lautlos und per PWM steuern, nimm einen MOSFET; schaltest du eine Lampe oder Steckdose am 230-V-Netz, nimm ein Relaismodul. Für kleine Lasten von einigen hundert Milliampere reicht auch ein günstiger Bipolartransistor; die Berechnung des Basiswiderstands findest du im Artikel Was ist ein Transistor?. Muss derselbe Motor in beide Richtungen drehen, genügt ein MOSFET nicht, sondern du brauchst eine H-Brücke mit vier Schaltern; nimm dafür einen L298N-Motortreiber oder ein H-Brücken-Modul mit MOSFETs.

Projektideen mit MOSFET

• Automatisches Schrank- oder Treppenlicht: Erkennt ein PIR-Sensor Bewegung, blendet ein 12-V-LED-Streifen per PWM sanft auf und geht nach einer Weile wieder aus.
• Dämmerungslampe: Mit einem LDR wird der Streifen schrittweise heller, je dunkler es im Raum wird.
• Intelligenter Lüfter: Je höher die mit dem DHT11 gemessene Temperatur, desto schneller dreht ein 12-V-PC-Lüfter.
• Automatische Pflanzenbewässerung: Ein Bodenfeuchtesensor und eine per MOSFET geschaltete Pumpe gießen deine Töpfe selbstständig; nimm für jede Pumpe einen eigenen MOSFET.
• Türschloss mit Karte: Liest ein RFID RC522 die richtige Karte, öffnet das 12-V-Magnetschloss für 3 Sekunden.
• Smartes Gewächshaus: Baue ein smartes Gewächshaus, das Lüfter, Pumpe und Heizung mit eigenen MOSFETs steuert.

Häufige Fehler und Lösungen

Ein MOSFET ist der sauberste Weg, den Arduino mit kräftigen Lasten aus der echten Welt zu verbinden: Mit einem passenden Logic-Level-Typ, einem Gate-Widerstand, einem Pull-down und einer Diode bei induktiven Lasten steuerst du jede Gleichstromlast vom LED-Streifen bis zur Pumpe leise und effizient. In der BlueGrays-App findest du Projekte wie LED-Dimmen per PWM, Helligkeitsregelung mit Potentiometer, eine smarte Bewässerungsstation und intelligente Beleuchtung mit Schaltplänen und Code Schritt für Schritt, sodass du die hier gelernte MOSFET-Schaltung sofort in ein Projekt umsetzen kannst.