Ratgeber · 9 Min. Lesezeit

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.

DS18B20 digitaler Temperatursensor
DS18B20: digitaler Temperatursensor mit nur einer Datenleitung und ±0,5 °C Genauigkeit. Bei der Lüftersteuerung in diesem Beitrag messen wir die Temperatur mit diesem Sensor.

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.

Merkmal2-Draht-Lüfter3-Draht-Lüfter4-Pin-PWM-Lüfter
AnschlüsseRot (+), Schwarz (GND)+, GND, gelber oder grüner TachoGND, +12 V, Tacho, PWM
DrehzahlregelungVersorgung per MOSFET taktenVersorgung takten oder Spannung senkenEigene PWM-Leitung, 25 kHz
Drehzahl auslesenNicht möglichMöglich (wird bei PWM gestört)Möglich, unabhängig von PWM
Zusätzliche BauteileMOSFET, Diode, WiderständeMOSFET, Diode, WiderständeNur 10-kΩ-Pull-up
Niedrigste DrehzahlBleibt unter 30–40 % Duty stehenBleibt unter 30–40 % Duty stehenDreht meist mit 20–30 % Drehzahl weiter
Typischer EinsatzGehäuse- und GerätelüfterÄltere PC-LüfterModerne 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.

BauteilEmpfohlener WertAufgabe
N-Kanal-MOSFET (Uno, 5 V)IRLZ44N, IRL540N, IRLB8721Schaltet die GND-Leitung des Lüfters per PWM
N-Kanal-MOSFET (ESP32/Pico, 3,3 V)AO3400, IRLML2502Schaltet bei 3,3 V Gate-Spannung voll durch
Gate-Widerstand100–220 ΩBegrenzt den Pin-Strom, dämpft Schwingen im Signal
Gate-Pull-down10 kΩ (zwischen Gate und Source)Hält den MOSFET beim Einschalten gesperrt
Freilaufdiode1N5819 (Schottky) oder 1N4007Fängt die Spannungsspitze der Spule ab
Versorgung12-V-Netzteil, mindestens doppelter LüfterstromVersorgt den Lüfter unabhängig vom Arduino
Der häufigste Fehler ist die Verwendung von MOSFETs ohne Logic-Level wie IRFZ44N oder IRF540N. Diese Bauteile sind für 10 V Gate-Spannung ausgelegt; bei 5 V bleiben sie halb offen, der Lüfter dreht langsam und der MOSFET wird heiß. Nimm Typen mit einem L im Namen (IRLZ44N, IRL540N). Außerdem müssen die GND des Arduino und die GND des 12-V-Netzteils unbedingt verbunden sein; ohne gemeinsame Masse hat das PWM-Signal keinen Bezug und der Lüfter dreht gar nicht oder verhält sich zufällig.

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.

AnschlussArduino UnoESP32Raspberry Pi Pico
Lüfter-PWM (blau) oder MOSFET-GateD9GPIO 25GP16
Lüfter-Tacho (grün) + 10-kΩ-Pull-upD2 (Pull-up an 5V)GPIO 26 (Pull-up an 3V3)GP17 (Pull-up an 3V3)
DS18B20-Daten + 4,7-kΩ-Pull-upD4GPIO 4GP15
DS18B20 VDD5V3V33V3
Lüfter +12 V (gelb)Externes 12-V-NetzteilExternes 12-V-NetzteilExternes 12-V-Netzteil
Lüfter-GND (schwarz)GND (gemeinsam mit Netzteil)GND (gemeinsam mit Netzteil)GND (gemeinsam mit Netzteil)
Schließe den Pull-up-Widerstand der Tacho-Leitung niemals an 12 V an. Der Tacho-Ausgang ist ein Open-Collector; der Lüfter zieht die Leitung nur nach GND, den High-Pegel bestimmt dein Pull-up. Bei 12 V wird der Arduino-Eingang überlastet, und die 3,3-V-Pins von ESP32 und Pico können sofort zerstört werden. Verbinde den Pull-up immer mit der Logikspannung des Boards (5 V beim Uno, 3,3 V bei ESP32 und Pico).

Schritt für Schritt: 2-Draht-Lüfter temperaturabhängig steuern (Arduino Uno)

  1. Installiere im Arduino-IDE-Bibliotheksverwalter die Bibliotheken OneWire und DallasTemperature.
  2. Schließe den DS18B20 an: VDD an 5V, GND an GND, Datenleitung an D4; setze einen 4,7-kΩ-Widerstand zwischen Datenleitung und 5V.
  3. 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Ω.
  4. 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.
  5. Verbinde die GND des Netzteils mit der GND des Arduino, lade den Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
  6. 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.
C++ (Arduino IDE)
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 / EinstellungWozu dient sie?
TCCR1B = (TCCR1B & 0b11111000) | 0x01Setzt 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_OFFHysterese: 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 = 80Der niedrigste Wert, bei dem der Lüfter noch dreht (etwa 31 %); finde ihn für deinen Lüfter durch Ausprobieren
AnlaufimpulsSteht 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_CFä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.

TemperaturLüfterdrehzahl (%)8-Bit-PWM (0–255)Uno Timer1 OCR1A (0–320)
25 °C und darunter205164
30 °C40102128
35 °C60153192
40 °C80204256
45 °C und darüber100255320

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.

C++ (Arduino IDE)
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.

Diese Timer1-Konfiguration deaktiviert analogWrite an D9 und D10 sowie die Servo-Bibliothek, die Timer1 nutzt. Hast du in deinem Projekt auch einen Servo, lass den Lüfter auf Timer1 und wechsle für den Servo zu einer Bibliothek wie ServoTimer2, die Timer2 verwendet, oder portiere das Projekt auf den ESP32. Außerdem drehen die meisten 4-Pin-Lüfter selbst bei 0 % Duty mit ihrer Mindestdrehzahl weiter; willst du den Lüfter ganz stoppen, musst du die 12-V-Versorgung über einen separaten P-Kanal-MOSFET oder ein Relais trennen.

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.

C++ (Arduino IDE)
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.

MicroPython
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

SymptomMögliche UrsacheLösung
Der Lüfter dreht gar nichtGND nicht gemeinsam oder MOSFET nicht Logic-LevelVerbinde die GND von Netzteil und Arduino, nimm einen MOSFET der L-Serie wie IRLZ44N
4-Pin-Lüfter dreht immer mit voller DrehzahlPWM-Leitung am falschen Pin oder offenPrüfe, ob das blaue Kabel an D9, GPIO 25 oder GP16 liegt und die GND gemeinsam ist
Der Lüfter brummt leiseStandard-PWM mit 490 HzErhöhe die Frequenz auf 25–31 kHz
Der Lüfter bleibt bei niedriger Drehzahl stehenDuty liegt unter der Anlaufschwelle des LüftersErhöhe PWM_MIN und verwende den Anlaufimpuls
RPM zeigt immer 0Tacho-Pull-up fehlt oder falscher PinSchließe 10 kΩ an die Logikspannung an und nimm einen interruptfähigen Pin
RPM-Werte sind sehr hoch und schwankenLanges Kabel, Störungen oder PWM an der Low-Side eines 3-Draht-LüftersKü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üftersLüfter und Board hängen an derselben schwachen QuelleNimm 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 DiodeWähle einen MOSFET mit niedriger Schwelle wie AO3400 und setze die Freilaufdiode ein
Mache für die niedrigste Drehzahl deines Lüfters einen kurzen Test: Starte bei 100 % Duty, senke alle 3 Sekunden um 5 % und beobachte im Seriellen Monitor die RPM. Ein Wert 5–10 % über dem Punkt, an dem die Drehzahl auf null fällt, ist eine sichere Untergrenze für die Kurve. Bei einem 2-Draht-Lüfter ohne Tacho kannst du denselben Test mit Auge und Ohr machen.

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ß.

Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

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…

4.7(47)
83
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

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.

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Atem-Effekt)
PI-14Anfänger

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.

4
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

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.

4.5(19)
32
Temperaturmessung mit NTC und 2x16 Lcd Display
AR-44Anfänger
Premium

Temperaturmessung mit NTC und 2x16 Lcd Display

Miss die Umgebungstemperatur mit einem Sensor, der aussieht wie eine kleine Perle.

4.5(33)
44
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

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.

4.8(38)
57
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12
Intelligente Bewässerungsstation
AR-83Fortgeschritten
Premium

Intelligente Bewässerungsstation

Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

5.0(42)
57