Arduino Lüftersteuerung: Drehzahl per PWM nach Temperatur regeln
Arduino Lüftersteuerung: 2-Draht-Lüfter per MOSFET und PWM, 4-Pin-PC-Lüfter mit 25 kHz und Drehzahl per Tacho messen. Code für Uno, ESP32 und Pico.
Die Arduino Lüftersteuerung ist der praktischste Weg, die Drehzahl eines Lüfters automatisch an die Temperatur anzupassen: Ein Sensor misst die Umgebung, der Arduino rechnet den Wert in eine Drehzahl um und steuert den Lüfter mit einem PWM-Signal an. So dreht der Lüfter bei kühler Umgebung leise und langsam, wird mit steigender Wärme schneller und macht nicht unnötig bei voller Drehzahl Lärm. 3D-Drucker-Gehäuse, Netzteilboxen, Aquariumabdeckungen, Gewächshäuser und PC-Gehäuse sind die häufigsten Einsatzorte.
In dieser Anleitung behandeln wir zwei Wege: einen einfachen 2-Draht-Lüfter mit einem Logic-Level-MOSFET per PWM ansteuern und einen 4-Pin-PC-Lüfter über seine eigene Steuerleitung mit 25 kHz PWM regeln und die Drehzahl am Tacho-Ausgang auslesen. Du bekommst funktionierenden Code für Arduino Uno, ESP32 und Raspberry Pi Pico, baust mit map() eine Temperatur-Drehzahl-Kurve und lernst Hysterese sowie die Tricks für einen wirklich leisen Lüfter kennen.

Was ist Lüftersteuerung mit Arduino und wie funktioniert sie?
PC-Lüfter sind bürstenlose Gleichstrommotoren; eine kleine Treiberschaltung im Inneren bestromt die Spulen nacheinander. Die Drehzahl lässt sich auf zwei Arten ändern: die anliegende Spannung senken oder die Spannung sehr schnell ein- und ausschalten. Die zweite Methode ist PWM und die natürliche Sprache von Mikrocontrollern. Bei 50 % Duty Cycle wird der Lüfter die Hälfte der Zeit mit Energie versorgt; die Trägheit des Rotors glättet die Impulse und der Lüfter dreht etwa mit halber Drehzahl. Die Grundlagen findest du ausführlich im Beitrag Was ist PWM?. Entscheidend ist, wie viele Drähte der Lüfter hat, denn davon hängt deine Schaltung ab.
| Merkmal | 2-Draht-Lüfter | 3-Draht-Lüfter | 4-Pin-PWM-Lüfter |
|---|---|---|---|
| Anschlüsse | Rot (+), Schwarz (GND) | +, GND, gelber oder grüner Tacho | GND, +12 V, Tacho, PWM |
| Drehzahlregelung | Versorgung per MOSFET takten | Versorgung takten oder Spannung senken | Eigene PWM-Leitung, 25 kHz |
| Drehzahl auslesen | Nicht möglich | Möglich (wird bei PWM gestört) | Möglich, unabhängig von PWM |
| Zusätzliche Bauteile | MOSFET, Diode, Widerstände | MOSFET, Diode, Widerstände | Nur 10-kΩ-Pull-up |
| Niedrigste Drehzahl | Bleibt unter 30–40 % Duty stehen | Bleibt unter 30–40 % Duty stehen | Dreht meist mit 20–30 % Drehzahl weiter |
| Typischer Einsatz | Gehäuse- und Gerätelüfter | Ältere PC-Lüfter | Moderne PC- und CPU-Lüfter |
2-Draht-Lüfter per MOSFET mit PWM ansteuern
Ein Arduino-Pin liefert 5 V und sicher nur etwa 20 mA; einen 12-V-Lüfter, der 0,1–0,3 A zieht, kann er nicht direkt treiben. Deshalb setzen wir einen N-Kanal-MOSFET als Low-Side-Schalter dazwischen: Das rote Kabel des Lüfters geht an die externen 12 V, das schwarze an den Drain (D) des MOSFET, der Source (S) liegt an GND. Der Arduino-Pin steuert das Gate (G) über einen 220-Ω-Widerstand an. Ein 10-kΩ-Widerstand zwischen Gate und Source verhindert, dass der Lüfter beim Einschalten oder Reset des Arduino von selbst anläuft. Eine in Sperrrichtung über den Lüfter geschaltete Diode (Kathode an der +12-V-Seite) fängt Spannungsspitzen ab, die die Motorspule beim Abschalten erzeugt. Die Funktionsweise des MOSFET erklären wir ausführlicher im Beitrag MOSFET am Arduino verwenden.
| Bauteil | Empfohlener Wert | Aufgabe |
|---|---|---|
| N-Kanal-MOSFET (Uno, 5 V) | IRLZ44N, IRL540N, IRLB8721 | Schaltet die GND-Leitung des Lüfters per PWM |
| N-Kanal-MOSFET (ESP32/Pico, 3,3 V) | AO3400, IRLML2502 | Schaltet bei 3,3 V Gate-Spannung voll durch |
| Gate-Widerstand | 100–220 Ω | Begrenzt den Pin-Strom, dämpft Schwingen im Signal |
| Gate-Pull-down | 10 kΩ (zwischen Gate und Source) | Hält den MOSFET beim Einschalten gesperrt |
| Freilaufdiode | 1N5819 (Schottky) oder 1N4007 | Fängt die Spannungsspitze der Spule ab |
| Versorgung | 12-V-Netzteil, mindestens doppelter Lüfterstrom | Versorgt den Lüfter unabhängig vom Arduino |
Anschlusstabelle: Arduino Uno, ESP32 und Pico
Die folgende Tabelle deckt sowohl den direkten Anschluss des 4-Pin-Lüfters als auch das MOSFET-Gate für den 2-Draht-Lüfter ab; in beiden Schaltungen kommt das PWM-Signal vom selben Pin. Als Temperatursensor verwenden wir den DS18B20, der auf allen Boards funktioniert und auch als wasserdichte Version erhältlich ist; Details im Beitrag DS18B20 Temperatursensor.
| Anschluss | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Lüfter-PWM (blau) oder MOSFET-Gate | D9 | GPIO 25 | GP16 |
| Lüfter-Tacho (grün) + 10-kΩ-Pull-up | D2 (Pull-up an 5V) | GPIO 26 (Pull-up an 3V3) | GP17 (Pull-up an 3V3) |
| DS18B20-Daten + 4,7-kΩ-Pull-up | D4 | GPIO 4 | GP15 |
| DS18B20 VDD | 5V | 3V3 | 3V3 |
| Lüfter +12 V (gelb) | Externes 12-V-Netzteil | Externes 12-V-Netzteil | Externes 12-V-Netzteil |
| Lüfter-GND (schwarz) | GND (gemeinsam mit Netzteil) | GND (gemeinsam mit Netzteil) | GND (gemeinsam mit Netzteil) |
Schritt für Schritt: 2-Draht-Lüfter temperaturabhängig steuern (Arduino Uno)
- Installiere im Arduino-IDE-Bibliotheksverwalter die Bibliotheken OneWire und DallasTemperature.
- Schließe den DS18B20 an: VDD an 5V, GND an GND, Datenleitung an D4; setze einen 4,7-kΩ-Widerstand zwischen Datenleitung und 5V.
- Baue die MOSFET-Schaltung auf: Rot des Lüfters an +12 V, Schwarz an den Drain, Source an GND, Gate über 220 Ω an D9, zwischen Gate und Source 10 kΩ.
- Setze die Diode in Sperrrichtung an den Lüfter: das Ende mit dem Strich (Kathode) an +12 V, das andere Ende an das schwarze Kabel des Lüfters.
- Verbinde die GND des Netzteils mit der GND des Arduino, lade den Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
- Erwärme den Sensor mit den Fingern; über 30 °C siehst du, wie der Lüfter mit einem kurzen Vollgas-Impuls anläuft und dann mit der Temperatur schneller wird.
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const byte FAN_PIN = 9; // MOSFET gate (220 ohm) / MOSFET gate (220 ohm)
5const byte TEMP_PIN = 4; // DS18B20 veri / DS18B20 data
6
7const float T_ON = 30.0; // fan bu sıcaklıkta açılır / fan turns on here
8const float T_OFF = 27.0; // fan bu sıcaklıkta kapanır / fan turns off here
9const float T_MAX = 45.0; // tam hız sıcaklığı / full speed temperature
10const int PWM_MIN = 80; // fanın dönebildiği en düşük değer / lowest value that keeps the fan spinning
11
12OneWire oneWire(TEMP_PIN);
13DallasTemperature sensors(&oneWire);
14bool fanOn = false;
15int lastPwm = 0;
16
17void setup() {
18 Serial.begin(9600);
19 pinMode(FAN_PIN, OUTPUT);
20 // Timer1 ön bölücü = 1: D9 ve D10'da ~31 kHz PWM / Timer1 prescaler = 1: ~31 kHz PWM on D9 and D10
21 TCCR1B = (TCCR1B & 0b11111000) | 0x01;
22 sensors.begin();
23}
24
25void loop() {
26 sensors.requestTemperatures(); // ~750 ms sürer / takes ~750 ms
27 float t = sensors.getTempCByIndex(0);
28 int pwm;
29
30 if (t == DEVICE_DISCONNECTED_C) {
31 pwm = 255; // sensör yok: tam hız / no sensor: full speed
32 } else {
33 if (!fanOn && t >= T_ON) fanOn = true; // histerezis / hysteresis
34 if (fanOn && t <= T_OFF) fanOn = false;
35 if (fanOn) {
36 float tc = constrain(t, T_OFF, T_MAX);
37 pwm = map((long)(tc * 10), (long)(T_OFF * 10), (long)(T_MAX * 10), PWM_MIN, 255);
38 } else {
39 pwm = 0;
40 }
41 }
42
43 if (lastPwm == 0 && pwm > 0) { // kalkış darbesi / kick start
44 analogWrite(FAN_PIN, 255);
45 delay(500);
46 }
47 analogWrite(FAN_PIN, pwm);
48 lastPwm = pwm;
49
50 Serial.print(F("Sicaklik: "));
51 Serial.print(t, 1);
52 Serial.print(F(" C PWM: "));
53 Serial.println(pwm);
54 delay(250);
55}| Zeile / Einstellung | Wozu dient sie? |
|---|---|
| TCCR1B = (TCCR1B & 0b11111000) | 0x01 | Setzt den Vorteiler von Timer1 auf 1; die PWM an D9 und D10 steigt von 490 Hz auf etwa 31,4 kHz und das Lüfterbrummen verschwindet |
| T_ON / T_OFF | Hysterese: Der Lüfter schaltet bei 30 °C ein, aber erst bei 27 °C wieder aus; an der Schwelle gibt es kein Flattern |
| map(...) | Bildet den Bereich 27–45 °C linear auf PWM 80–255 ab; die Werte werden mit 10 multipliziert, damit die Nachkommastelle nicht verloren geht |
| PWM_MIN = 80 | Der niedrigste Wert, bei dem der Lüfter noch dreht (etwa 31 %); finde ihn für deinen Lüfter durch Ausprobieren |
| Anlaufimpuls | Steht der Lüfter, bekommt er zuerst 0,5 Sekunden volle Leistung; so starten auch Lüfter sicher, die mit niedrigem Duty nicht anlaufen |
| DEVICE_DISCONNECTED_C | Fällt der Sensor aus oder ist nicht lesbar, läuft der Lüfter mit voller Drehzahl; das Gerät überhitzt im Fehlerfall nicht |
Temperatur-Drehzahl-Kurve mit map und Hysterese
Die Temperatur-Drehzahl-Kurve legt fest, bei welcher Temperatur welche Drehzahl gilt. Die einfachste Form ist eine lineare Kurve mit zwei Punkten: bei der unteren Temperatur die niedrigste Drehzahl, bei der oberen volle Drehzahl, dazwischen eine Gerade. Genau das erledigt die Funktion map(); da sie aber mit Ganzzahlen arbeitet, bleibt die Genauigkeit erhalten, wenn du etwa 31,6 °C als 316 übergibst. Weil map() auch Werte außerhalb des Bereichs linear fortsetzt, musst du die Eingabe zuerst mit constrain() begrenzen; sonst erhältst du bei 60 °C einen sinnlosen Wert über 255. Die Details zur Funktion findest du im Beitrag Arduino map-Funktion. Die folgende Tabelle zeigt die Werte der Kurve für den Bereich 25–45 °C und 20 % Mindestdrehzahl; die Steigung beträgt 4 % pro Grad.
| Temperatur | Lüfterdrehzahl (%) | 8-Bit-PWM (0–255) | Uno Timer1 OCR1A (0–320) |
|---|---|---|---|
| 25 °C und darunter | 20 | 51 | 64 |
| 30 °C | 40 | 102 | 128 |
| 35 °C | 60 | 153 | 192 |
| 40 °C | 80 | 204 | 256 |
| 45 °C und darüber | 100 | 255 | 320 |
4-Pin-PC-Lüfter: 25 kHz PWM und Tacho auslesen
4-Pin-Lüfter folgen Intels Lüfterstandard: Pin 1 ist GND (schwarz), Pin 2 +12 V (gelb), Pin 3 Tacho (grün), Pin 4 PWM-Steuerung (blau). Der Lüfter wird immer mit vollen 12 V versorgt; die Drehzahl bestimmt das PWM-Signal auf der blauen Leitung, und der Standard verlangt dafür 25 kHz (21–28 kHz sind zulässig). Im Lüfter sitzt ein Widerstand, der die PWM-Leitung nach oben zieht; bleibt die Leitung offen, dreht der Lüfter deshalb mit voller Drehzahl. Der Tacho-Ausgang liefert pro Umdrehung 2 Impulse. Du zählst die Impulse mit einem Interrupt und berechnest die Drehzahl so: RPM = (Impulse ÷ 2) × (60 ÷ Messzeit in Sekunden). Zählst du in 1 Sekunde 40 Impulse, dreht der Lüfter mit 1200 RPM.
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const byte PWM_PIN = 9; // OC1A -> fan mavi kablo / fan blue wire
5const byte TACH_PIN = 2; // INT0 -> fan yeşil kablo / fan green wire
6const byte TEMP_PIN = 4; // DS18B20 veri / DS18B20 data
7const uint16_t PWM_TOP = 320; // 16 MHz / (2 * 320) = 25 kHz
8
9const float T_MIN = 25.0; // altında en düşük hız / minimum speed below this
10const float T_MAX = 45.0; // üstünde tam hız / full speed above this
11const byte DUTY_MIN = 20; // yüzde / percent
12
13OneWire oneWire(TEMP_PIN);
14DallasTemperature sensors(&oneWire);
15
16volatile uint16_t tachPulses = 0;
17unsigned long lastCalc = 0;
18
19void tachISR() {
20 tachPulses++; // her düşen kenar bir darbe / each falling edge is one pulse
21}
22
23void setFanPercent(byte percent) {
24 if (percent > 100) percent = 100;
25 OCR1A = (uint32_t)PWM_TOP * percent / 100;
26}
27
28void setup() {
29 Serial.begin(9600);
30 pinMode(PWM_PIN, OUTPUT);
31 TCCR1A = 0;
32 TCCR1B = 0;
33 TCNT1 = 0;
34 TCCR1A = _BV(COM1A1) | _BV(WGM11); // OC1A normal çıkış, mod 10 / OC1A non-inverting, mode 10
35 TCCR1B = _BV(WGM13) | _BV(CS10); // faz doğru PWM, TOP = ICR1, ön bölücü 1 / phase correct, TOP = ICR1, prescaler 1
36 ICR1 = PWM_TOP;
37 setFanPercent(DUTY_MIN);
38
39 pinMode(TACH_PIN, INPUT_PULLUP); // harici 10k pull-up önerilir / external 10k pull-up recommended
40 attachInterrupt(digitalPinToInterrupt(TACH_PIN), tachISR, FALLING);
41 sensors.begin();
42 lastCalc = millis();
43}
44
45void loop() {
46 sensors.requestTemperatures();
47 float t = sensors.getTempCByIndex(0);
48
49 byte duty;
50 if (t == DEVICE_DISCONNECTED_C) {
51 duty = 100; // sensör yok: tam hız / no sensor: full speed
52 } else {
53 float tc = constrain(t, T_MIN, T_MAX);
54 duty = map((long)(tc * 10), (long)(T_MIN * 10), (long)(T_MAX * 10), DUTY_MIN, 100);
55 }
56 setFanPercent(duty);
57
58 unsigned long now = millis();
59 unsigned long elapsed = now - lastCalc;
60 lastCalc = now;
61 noInterrupts();
62 uint16_t pulses = tachPulses;
63 tachPulses = 0;
64 interrupts();
65 unsigned long rpm = (unsigned long)pulses * 30000UL / elapsed; // 2 darbe = 1 tur / 2 pulses = 1 turn
66
67 Serial.print(F("Sicaklik: "));
68 Serial.print(t, 1);
69 Serial.print(F(" C Duty: %"));
70 Serial.print(duty);
71 Serial.print(F(" RPM: "));
72 Serial.println(rpm);
73 delay(1000);
74}Die Arduino-Funktion analogWrite kann keine 25 kHz erzeugen, deshalb konfigurieren wir Timer1 direkt. Im Modus 10 (Phase-Correct-PWM, Obergrenze ICR1) beträgt die Frequenz 16 MHz ÷ (2 × 1 × ICR1); ICR1 = 320 ergibt genau 25 kHz. Der Duty-Wert wird mit 0–320 ins Register OCR1A geschrieben, jeder Schritt entspricht also etwa 0,3 %. Die Tacho-Leitung hängt am Interrupt INT0 an D2; bei jeder fallenden Flanke wird der Zähler erhöht. In loop werden die Interrupts ganz kurz gesperrt, damit der Zähler sicher gelesen und zurückgesetzt wird. Die Logik der Interrupts findest du im Beitrag Arduino Interrupt.
Lüftersteuerung mit dem ESP32 (25 kHz per LEDC)
Beim ESP32 erzeugt die LEDC-Einheit die PWM, und 25 kHz stellst du in einer Zeile ein; dank des 80-MHz-Takts sind bei dieser Frequenz problemlos 8 Bit Auflösung möglich. Im Arduino-Core 3.x arbeiten die LEDC-Funktionen mit der Pinnummer, in 2.x mit der Kanalnummer; der folgende Code kompiliert dank der Prüfung ESP_ARDUINO_VERSION_MAJOR in beiden Versionen. Beim ESP32 kann jeder GPIO einen Interrupt auslösen; für den Tacho nutzen wir GPIO 26 und schützen den Zähler mit einem kritischen Abschnitt (portMUX), damit Interrupt und Hauptprogramm nicht gleichzeitig darauf zugreifen. Für einen 2-Draht-Lüfter kannst du GPIO 25 an das Gate eines MOSFET legen, der bei 3,3 V voll durchschaltet, und denselben Code verwenden; die Tacho-Zeilen ignorierst du dann.
1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int PWM_PIN = 25; // fan mavi kablo / fan blue wire
5const int TACH_PIN = 26; // fan yeşil kablo (10k -> 3V3) / fan green wire (10k -> 3V3)
6const int TEMP_PIN = 4; // DS18B20 veri / DS18B20 data
7const int PWM_FREQ = 25000; // 25 kHz
8const int PWM_RES = 8; // 0-255
9const int PWM_CH = 0; // yalnız core 2.x / core 2.x only
10
11const float T_MIN = 25.0;
12const float T_MAX = 45.0;
13const int DUTY_MIN = 51; // ~%20 / ~20 %
14
15OneWire oneWire(TEMP_PIN);
16DallasTemperature sensors(&oneWire);
17
18volatile uint32_t tachPulses = 0;
19portMUX_TYPE tachMux = portMUX_INITIALIZER_UNLOCKED;
20unsigned long lastCalc = 0;
21
22void IRAM_ATTR tachISR() {
23 portENTER_CRITICAL_ISR(&tachMux);
24 tachPulses++;
25 portEXIT_CRITICAL_ISR(&tachMux);
26}
27
28void fanWrite(int duty) {
29#if ESP_ARDUINO_VERSION_MAJOR >= 3
30 ledcWrite(PWM_PIN, duty); // core 3.x: pin ile / by pin
31#else
32 ledcWrite(PWM_CH, duty); // core 2.x: kanal ile / by channel
33#endif
34}
35
36void setup() {
37 Serial.begin(115200);
38#if ESP_ARDUINO_VERSION_MAJOR >= 3
39 ledcAttach(PWM_PIN, PWM_FREQ, PWM_RES);
40#else
41 ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
42 ledcAttachPin(PWM_PIN, PWM_CH);
43#endif
44 fanWrite(DUTY_MIN);
45 pinMode(TACH_PIN, INPUT_PULLUP);
46 attachInterrupt(digitalPinToInterrupt(TACH_PIN), tachISR, FALLING);
47 sensors.begin();
48 lastCalc = millis();
49}
50
51void loop() {
52 sensors.requestTemperatures();
53 float t = sensors.getTempCByIndex(0);
54 int duty;
55 if (t == DEVICE_DISCONNECTED_C) {
56 duty = 255; // sensör yok: tam hız / no sensor: full speed
57 } else {
58 float tc = constrain(t, T_MIN, T_MAX);
59 duty = map((long)(tc * 10), (long)(T_MIN * 10), (long)(T_MAX * 10), DUTY_MIN, 255);
60 }
61 fanWrite(duty);
62
63 unsigned long now = millis();
64 unsigned long elapsed = now - lastCalc;
65 lastCalc = now;
66 portENTER_CRITICAL(&tachMux);
67 uint32_t pulses = tachPulses;
68 tachPulses = 0;
69 portEXIT_CRITICAL(&tachMux);
70 unsigned long rpm = (unsigned long)pulses * 30000UL / elapsed; // 2 darbe = 1 tur / 2 pulses = 1 turn
71
72 Serial.printf("Sicaklik: %.1f C Duty: %d%% RPM: %lu\n", t, duty * 100 / 255, rpm);
73 delay(1000);
74}Lüftersteuerung mit Raspberry Pi Pico und MicroPython
Die PWM-Hardware des Pico erzeugt 25 kHz mühelos, und in MicroPython wird der Duty-Wert als 16-Bit-Zahl von 0 bis 65535 angegeben. Die für den DS18B20 nötigen Module onewire und ds18x20 sind in der MicroPython-Version des Pico bereits enthalten, du musst keine zusätzlichen Dateien kopieren. Die Tacho-Impulse zählen wir mit Pin.irq; beim Lesen des Zählers werden die Interrupts ganz kurz gesperrt, damit der Wert nicht halb aktualisiert wird. Bist du neu bei MicroPython, ist der Beitrag MicroPython-Grundlagen ein guter Einstieg.
1import machine, onewire, ds18x20, time
2from machine import Pin, PWM
3
4fan = PWM(Pin(16)) # fan mavi kablo / fan blue wire
5fan.freq(25000) # 25 kHz
6tach = Pin(17, Pin.IN, Pin.PULL_UP) # 10k -> 3V3 önerilir / 10k -> 3V3 recommended
7ds = ds18x20.DS18X20(onewire.OneWire(Pin(15)))
8roms = ds.scan()
9if not roms:
10 raise RuntimeError("DS18B20 bulunamadi / not found")
11
12T_MIN, T_MAX = 25.0, 45.0
13DUTY_MIN = 20 # yüzde / percent
14
15pulses = 0
16def on_pulse(pin):
17 global pulses
18 pulses += 1 # her düşen kenar / each falling edge
19
20tach.irq(trigger=Pin.IRQ_FALLING, handler=on_pulse)
21
22def set_percent(p):
23 p = max(0, min(100, p))
24 fan.duty_u16(int(p * 65535 / 100))
25
26def temp_to_percent(t):
27 if t <= T_MIN:
28 return DUTY_MIN
29 if t >= T_MAX:
30 return 100
31 return DUTY_MIN + (t - T_MIN) * (100 - DUTY_MIN) / (T_MAX - T_MIN)
32
33set_percent(DUTY_MIN)
34last = time.ticks_ms()
35while True:
36 ds.convert_temp()
37 time.sleep_ms(750) # 12 bit dönüşüm süresi / 12-bit conversion time
38 t = ds.read_temp(roms[0])
39 duty = temp_to_percent(t)
40 set_percent(duty)
41
42 now = time.ticks_ms()
43 elapsed = time.ticks_diff(now, last)
44 last = now
45 state = machine.disable_irq()
46 count = pulses
47 pulses = 0
48 machine.enable_irq(state)
49 rpm = count * 30000 // elapsed # 2 darbe = 1 tur / 2 pulses = 1 turn
50 print("Sicaklik: {:.1f} C Duty: %{} RPM: {}".format(t, int(duty), rpm))
51 time.sleep_ms(250)Tipps für einen leisen Lüfter
- PWM-Frequenz über die Hörgrenze legen: Die Standard-PWM mit 490 Hz erzeugt in den Lüfterspulen ein deutliches Brummen. Mit 31 kHz beim 2-Draht-Lüfter und 25 kHz beim 4-Pin-Lüfter verschwindet dieses Geräusch vollständig.
- Drehzahl sanft ändern: Statt den Duty-Wert schlagartig von 30 % auf 90 % zu setzen, erhöhe ihn pro Sekunde nur um wenige Prozent; das menschliche Ohr bemerkt plötzliche Drehzahlwechsel viel stärker als ein gleichmäßiges Rauschen.
- Hysterese verwenden: Schaltet der Lüfter an der Grenztemperatur ständig ein und aus, hörst du bei jedem Anlauf ein Klicken und schwankendes Geräusch; lass zwischen Ein- und Ausschaltschwelle 2–3 °C Abstand.
- Messwerte mitteln: Kleine Schwankungen des Sensorwerts lassen die Lüfterdrehzahl wandern. Der Mittelwert der letzten 5–10 Messungen beruhigt die Kurve; Methoden dazu findest du im Beitrag Sensordaten filtern.
- Große Lüfter langsam drehen: Ein 120-mm-Lüfter mit 800 RPM liefert einen ähnlichen Luftstrom wie ein 80-mm-Lüfter mit 2500 RPM, aber deutlich leiser.
- Vibrationen dämpfen: Montiere den Lüfter mit Gummientkopplern oder einer Silikondichtung und setze Gitter und Filter nicht zu dicht an den Rotor; mechanische Vibrationen sind oft lauter als elektrisches Rauschen.
- Die Mindestdrehzahl richtig wählen: Finde durch Ausprobieren den niedrigsten Duty-Wert, bei dem der Lüfter noch dreht, und lege die Untergrenze der Kurve etwas darüber; ein Lüfter, der an der Grenze dahinkriecht, klingt unregelmäßig.
Projektideen mit Lüftersteuerung
- Intelligenter Thermostat: Ein Regler, der die Heizung per Relais und den Lüfter per PWM steuert; Details im Beitrag Arduino Thermostat.
- Kühlung für das 3D-Drucker-Gehäuse: Ein leiser Abluftlüfter, der die Temperatur im Gehäuse unter 35 °C hält und die Drehzahl anzeigt; für das Display siehe die Anleitung zum OLED-Display.
- Gewächshaus-Belüftung: Lüfter, die mit Temperatur und Luftfeuchtigkeit zusammenarbeiten; das Smart-Gewächshaus-Projekt ist dafür eine gute Grundlage.
- Peltier-Kühlung: Kühle den Kühlkörper an der heißen Seite des Peltier-Moduls mit einem Lüfter, der abhängig von der Temperatur dieser Seite schneller dreht; siehe Peltier-Modul.
- Hausautomation: Überwache Lüfterdrehzahl und Temperatur mit dem ESP32 per MQTT und Home Assistant auf dem Handy.
- Konstante Temperatur per PID: Baue mit einer PID-Regelung statt der linearen Kurve ein Lüftersystem, das eine Box exakt auf 30 °C hält.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Der Lüfter dreht gar nicht | GND nicht gemeinsam oder MOSFET nicht Logic-Level | Verbinde die GND von Netzteil und Arduino, nimm einen MOSFET der L-Serie wie IRLZ44N |
| 4-Pin-Lüfter dreht immer mit voller Drehzahl | PWM-Leitung am falschen Pin oder offen | Prüfe, ob das blaue Kabel an D9, GPIO 25 oder GP16 liegt und die GND gemeinsam ist |
| Der Lüfter brummt leise | Standard-PWM mit 490 Hz | Erhöhe die Frequenz auf 25–31 kHz |
| Der Lüfter bleibt bei niedriger Drehzahl stehen | Duty liegt unter der Anlaufschwelle des Lüfters | Erhöhe PWM_MIN und verwende den Anlaufimpuls |
| RPM zeigt immer 0 | Tacho-Pull-up fehlt oder falscher Pin | Schließe 10 kΩ an die Logikspannung an und nimm einen interruptfähigen Pin |
| RPM-Werte sind sehr hoch und schwanken | Langes Kabel, Störungen oder PWM an der Low-Side eines 3-Draht-Lüfters | Kürze das Kabel, führe die Tacho-Leitung getrennt von der PWM-Leitung; lies bei 3-Draht-Lüftern die Drehzahl nur bei voller Drehzahl aus |
| Arduino resettet beim Anlaufen des Lüfters | Lüfter und Board hängen an derselben schwachen Quelle | Nimm ein separates 12-V-Netzteil für den Lüfter, ergänze Diode und 100-µF-Kondensator |
| MOSFET wird sehr heiß | 5-V-MOSFET an einem 3,3-V-Board oder fehlende Diode | Wähle einen MOSFET mit niedriger Schwelle wie AO3400 und setze die Freilaufdiode ein |
Die temperaturabhängige Lüftersteuerung bringt Sensorauslesung, PWM, Interrupts und Leistungselektronik in einem Projekt zusammen und ist deshalb eines der lehrreichsten Themen. Wenn du mit einem einfachen 2-Draht-Lüfter beginnst und zu einem 4-Pin-PC-Lüfter wechselst, hast du am Ende ein echtes Kühlsystem, das seine Drehzahl misst und leise arbeitet. In der BlueGrays-App findest du die Projekte, auf denen dieser Beitrag aufbaut, etwa Temperaturmessung mit dem DHT11 und PWM-Anwendungen mit ESP32 und Pico, Schritt für Schritt mit Schaltplänen und Code.
Häufige Fragen
Wie steuert man einen 12-V-Lüfter mit dem Arduino?
Einen 12-V-Lüfter kannst du nicht direkt an einen Arduino-Pin anschließen; der Pin liefert nur 5 V und höchstens etwa 20 mA. Einen 2-Draht-Lüfter schaltest du über einen Logic-Level-N-Kanal-MOSFET wie den IRLZ44N auf der Low-Side und legst PWM an. Bei 4-Pin-Lüftern wird der Lüfter direkt mit 12 V versorgt, und der Arduino steuert nur die blaue PWM-Leitung; in beiden Fällen müssen die GND gemeinsam sein.
Warum muss die PWM-Frequenz eines 4-Pin-Lüfters 25 kHz betragen?
Intels Standard für 4-Pin-Lüfter definiert für das Steuersignal den Bereich 21–28 kHz und 25 kHz als Zielwert. Diese Frequenz liegt über der Hörgrenze des Menschen (etwa 20 kHz), deshalb brummen die Spulen nicht. Auf die Standard-PWM des Arduino mit 490 Hz reagieren viele Lüfter nicht sauber oder machen Geräusche.
Wie berechnet man die Lüfterdrehzahl (RPM)?
Der Tacho-Ausgang von PC-Lüftern liefert pro Umdrehung 2 Impulse. Du teilst die in einem Zeitraum gezählten Impulse durch 2 und rechnest auf eine Minute um: RPM = Impulse ÷ 2 × 60 ÷ Zeit (Sekunden). Wurden zum Beispiel in 1 Sekunde 50 Impulse gezählt, dreht der Lüfter mit 1500 RPM.
Lässt sich ein 3-Pin-Lüfter per PWM steuern?
Ja, einen 3-Pin-Lüfter kannst du wie einen 2-Draht-Lüfter verlangsamen, indem du seine Versorgung per MOSFET taktest. Weil die Elektronik des Lüfters in den Aus-Phasen der PWM aber ohne Energie ist, wird das Tacho-Signal gestört und die Drehzahlmessung unzuverlässig. Willst du die Drehzahl korrekt messen, nimm einen 4-Pin-Lüfter oder senke die Spannung des 3-Pin-Lüfters mit einem DC-DC-Wandler.
Warum bleibt der Lüfter bei niedriger Drehzahl stehen oder läuft nicht an?
Jeder Lüfter hat ein Mindestleistungsniveau, bei dem er weiterdreht und aus dem Stand anlaufen kann; die meisten 12-V-Lüfter laufen unter etwa 5–7 V nicht an. Die Lösung ist, die Untergrenze der Kurve etwas über diesen Wert zu legen und den stehenden Lüfter zuerst mit einem halbsekündigen Vollgas-Impuls zu starten. Die meisten 4-Pin-Lüfter bleiben bei niedrigem Duty dagegen nicht stehen, sondern drehen mit ihrer Mindestdrehzahl weiter.
Welchen MOSFET braucht man für die Lüftersteuerung?
Für 5-V-Boards wie den Arduino Uno eignen sich Logic-Level-MOSFETs wie IRLZ44N, IRL540N oder IRLB8721. Für die 3,3-V-Ausgänge von ESP32 und Pico wähle Typen wie AO3400 oder IRLML2502, die bereits bei 2,5 V Gate-Spannung voll durchschalten. IRFZ44N und IRF540N brauchen 10 V Gate-Spannung; am Mikrocontroller bleiben sie halb offen und werden heiß.
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…

ESP32 LED-Überblendung mit PWM
Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
Die LED blinkt nicht mehr nur — sie atmet! Mit der PWM (Pulsweitenmodulation) des Raspberry Pi Pico steigt die Helligkeit langsam an und fällt wieder ab. Lerne die machine.PWM-Klasse, duty_u16() (16-Bit-Helligkeit 0–65535), PWM-Frequenz, range()-Schleifen und analogähnliche Ausgabe. Grundlage für RGB-Farbmischung, Motorsteuerung, Servos und Buzzer.

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

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 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

Intelligente Bewässerungsstation
Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.
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

