In diesem Artikel lernst du, wie du einen Lüfter mit einem Arduino Uno steuerst. Wir betrachten die verschiedenen Lüftertypen und Methoden zu deren Steuerung. Am Ende dieses Beitrags hast du ein solides Verständnis dafür, wie man einen Lüfter steuert und bist mit dem Wissen ausgestattet, dein eigenes Lüftersteuerungssystem zu erstellen.
Also, legen wir los!
Benötigte Teile
Im Folgenden findest du die für dieses Projekt benötigten Teile. Ich gehe davon aus, dass du bereits einen Lüfter hast, den du steuern möchtest, aber im nächsten Abschnitt findest du auch Links zu verschiedenen Lüftertypen.
Für einige der Schaltungen in diesem Blog verwenden wir einen 2N7000 MOSFET. Ich habe einen Link zu einem Kit mit verschiedenen Transistoren und MOSFETs bereitgestellt, das praktisch ist. Du kannst auch nur den 2N7000 MOSFET erwerben, aber diese werden meist in Packungen zu 100 Stück verkauft, was wahrscheinlich mehr ist, als du brauchst.
Wenn du Lüfter oder Geräte steuern möchtest, die mehr als 200mA Strom ziehen, sind kleine MOSFETs wie der 2N7000 nicht ausreichend. Du benötigst Power MOSFETs, die bis zu 100A schalten können!
Arduino Uno
Dupont-Kabelset
Breadboard
USB-Kabel für Arduino UNO
Trimmer-Kit
Widerstands- & LED-Kit
Relais-Modul
Transistor-Kit
Bewegungssensor
Temperatursensor
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Lüftertypen
In diesem Abschnitt werfen wir einen kurzen Blick auf die verschiedenen Lüftertypen, die man üblicherweise mit einem Arduino steuern möchte.
AC- versus DC-Lüfter
Beim Steuern eines Lüfters mit Arduino ist eine der wichtigsten Überlegungen, ob der Lüfter mit Wechselstrom (AC) oder Gleichstrom (DC) betrieben wird. Das Verständnis des Unterschieds ist entscheidend, um den passenden Lüfter auszuwählen und die Kompatibilität mit deinem Arduino-Setup sicherzustellen.
AC-Lüfter
AC-Lüfter sind dafür ausgelegt, mit der üblichen Haushaltsstromversorgung von 110V oder 220V zu arbeiten. Man findet sie oft als Deckenventilatoren oder in Geräten wie Klimaanlagen. Es gibt aber auch kleine AC-Schreibtischlüfter. AC-Lüfter laufen typischerweise mit fester Drehzahl. Unten siehst du ein Bild eines typischen AC-Lüfters:
Beachte, dass man meist nicht am Aussehen erkennen kann, ob ein Lüfter AC oder DC ist oder welche Spannung er benötigt. Du musst das Etikett prüfen (siehe oben), das diese Informationen liefert.
Um einen AC-Lüfter mit Arduino zu steuern, verwendet man typischerweise ein Relay oder ein Thyristor. Relais oder Thyristoren fungieren als steuerbare Schalter, die die hohe Spannung und den Strom eines AC-Lüfters handhaben können. Achtung: Beim Umgang mit hohen Spannungen sei sehr vorsichtig!
DC-Lüfter
DC-Lüfter hingegen arbeiten mit Gleichstrom. Sie werden häufig in elektronischen Geräten wie Computern, Laptops und anderen kleinen Kühlsystemen eingesetzt. Sie laufen typischerweise mit 6V oder 12V und können leicht mit einem Arduino gesteuert werden.
DC-Lüfter gibt es in verschiedenen Ausführungen, wie 2-, 3- und 4-Draht-Varianten. Schauen wir uns diese Varianten in den nächsten Abschnitten genauer an.
2-Draht DC-Lüfter
2-Draht DC-Lüfter sind die einfachste Art von DC-Lüftern. Sie haben zwei Drähte – einen roten für die Stromversorgung (VCC) und einen schwarzen für Masse (GND). Diese Lüfter laufen nativ mit fester Drehzahl, aber die Geschwindigkeit kann über Pulsweitenmodulation (PWM) geändert werden. Ich zeige dir mehrere Beispiele, wie das funktioniert. Unten ein Bild eines typischen 12V DC-Lüfters. Beachte die zwei Drähte für Strom und Masse.
3-Draht DC-Lüfter
3-Draht DC-Lüfter haben die üblichen zwei Drähte für Strom und Masse (rot und schwarz) sowie einen zusätzlichen Draht (typischerweise gelb), den Tachometer (TACH). Dieser Draht liefert ein Pulssignal, das die Drehzahl des Lüfters anzeigt. Durch Auslesen dieses Signals kannst du die Lüftergeschwindigkeit in deinem Arduino-Projekt überwachen.
Das Tachometersignal wird von einem Hall-Effekt-Sensor oder einem optischen Sensor erzeugt, der das Vorbeigehen bestimmter Markierungen oder Merkmale am Rotor oder Motor des Lüfters erkennt. Die Ausgabe ist ein Puls, dessen Frequenz der Lüftergeschwindigkeit entspricht. Höhere U/min führen zu höherer Pulsfrequenz, niedrigere U/min zu niedrigerer Frequenz.
Viele Computerlüfter sind 3-Draht-Lüfter, aber sie werden auch in vielen anderen Geräten verwendet. Unten ein Bild eines kleinen 3-Draht 12V DC-Lüfters für einen 3D-Drucker:
4-Draht DC-Lüfter
Ein 4-Draht DC-Lüfter ist eine weitere Lüfterart, die typischerweise als Computerlüfter verwendet wird. Er ist eine Erweiterung des 3-Draht-Lüfters und hat einen vierten Draht zur Steuerung der Lüftergeschwindigkeit. Wie bei 2- und 3-Draht-Lüftern ist der positive Versorgungsdraht meist rot, der Masse-Draht schwarz. Das Tachometersignal ist gelb, der zusätzliche Steuerdraht für die Geschwindigkeit meist blau.
Die Lüftergeschwindigkeit wird durch Senden eines PWM (Pulse Width Modulation) Signals auf dem Steuerdraht geregelt, das an einen MOSFET angeschlossen ist, der den Motor steuert. Für mehr Details siehe den folgenden Schaltplan.
Unten ein Bild eines typischen 12V 4-Draht DC-Lüfters, der als Computerlüfter verwendet wird:
Zusammenfassend laufen 2- und 3-Draht-Lüfter typischerweise mit konstanter Geschwindigkeit. 3-Draht-Lüfter liefern ein Tachometersignal zur Überwachung der Lüftergeschwindigkeit. 4-Draht-Lüfter laufen meist mit variabler Geschwindigkeit, gesteuert über ein PWM-Signal auf dem vierten Draht, erlauben aber auch die Geschwindigkeitsüberwachung über den dritten Draht.
Beachte, dass sowohl das Tachometersignal als auch der Steuerdraht Puls-Signale verwenden. Das Tachometersignal ist jedoch ein Ausgang, während der Steuerdraht ein Eingang ist. Die Geschwindigkeit wird über eine Pulsweitenmodulation mit variablem Tastverhältnis gesteuert, während das Tachometersignal ein konstantes 50% Tastverhältnis hat, dessen Frequenz sich mit der Geschwindigkeit ändert.
In den folgenden Abschnitten betrachten wir verschiedene Methoden, um einen Lüfter zu steuern.
Beispiel 1: Lüfter mit Relais schalten
Wir beginnen mit der einfachsten Möglichkeit, einen Lüfter zu steuern. Wir verbinden ein gängiges Relaismodul mit einem Arduino und schalten damit den Lüfter ein oder aus.
Beachte, dass du einen Lüfter normalerweise nicht direkt an einen Ausgangspin des Arduino anschließen kannst. Der Ausgangsstrom der GPIO-Pins eines Arduino ist auf 20mA (kurzzeitig 40mA) begrenzt. Abgesehen von sehr kleinen Lüftern verbrauchen fast alle Lüfter mehr Strom und benötigen auch höhere Spannungen als die 5V, die die GPIO-Pins liefern.
Breadboard-Verdrahtung
Einen Lüfter über ein Relais an einen Arduino anzuschließen ist sehr einfach. Schau dir das folgende Verdrahtungsdiagramm an.
Anschluss des Relais an den Arduino
Zuerst verbindest du die GND-Leitung des Arduino mit dem mit (-) oder GND markierten Pin des Relais (blaues Kabel). Dann verbindest du den 5V-Ausgang des Arduino mit dem positiven Versorgungspin (+) des Relais (rotes Kabel). Als Nächstes verbindest du das Signalkabel (gelb) vom Pin 3 mit dem mit (S) markierten Pin am Relaismodul. Dieses Kabel steuert das Relais, das den Lüfter ein- oder ausschaltet.
Anschluss der Stromversorgung
Als Nächstes verbindest du den Lüfter mit der Stromversorgung. Du benötigst ein Netzteil oder eine Batterie, die den Anforderungen des Lüfters entspricht. Wenn du also einen 12V, 180mA Lüfter hast, brauchst du ein Netzteil oder eine Batterie mit 12V, die mindestens 180mA liefern kann. Kurz gesagt: Die Batteriespannung darf nicht höher als die Lüfterspannung sein, aber der Strom sollte höher sein.
Im obigen Beispiel verwende ich eine 9V-Batterie mit 1000mAh, um einen 12V, 180mA Lüfter zu betreiben. Das funktioniert und ist zum Testen in Ordnung, aber der Lüfter läuft nicht mit voller Geschwindigkeit. Für eine echte Anwendung würde ich eine 12V-Batterie oder ein Netzteil verwenden.
Anschluss des Lüfters
Der Anschluss des Lüfters ist einfach. Wir verbinden den blauen/schwarzen Draht des Lüfters mit dem Minuspol (-) der Batterie. Der rote Draht geht zu den Schaltkontakten des Relais. Einer ist mit GND (Masse), einer mit NO (normalerweise offen) und einer mit NC (normalerweise geschlossen) markiert. Normalerweise offen bedeutet, der Schalter ist normalerweise offen und der Lüfter läuft nicht, bis das Relais aktiviert wird. Verbinde die roten Drähte von Batterie und Lüfter mit GND und NO. Die Reihenfolge spielt keine Rolle.
Beachte jedoch, dass viele Lüfter (insbesondere Computerlüfter) bürstenlose Motoren verwenden und eine interne Elektronik haben, die eine korrekte Polung erfordert. Während du die Drehrichtung eines einfachen DC-Motors durch Vertauschen von Plus und Minus ändern kannst, funktioniert das bei bürstenlosen Motoren in der Regel nicht. Sie laufen nur in eine Richtung mit korrekter Polung. Die Vorteile bürstenloser Motoren sind, dass sie leise sind, lange laufen können und keinen snubber diode benötigen.
Du kannst die obige Schaltung auch verwenden, um AC-Lüfter zu schalten, aber sei vorsichtig! Verwende auf jeden Fall ein Relaismodul statt eines einfachen Relais, da Relaismodule typischerweise Optokoppler zur elektrischen Trennung haben.
Code zur Steuerung des Lüfters mit Relais
Das Ein- und Ausschalten des Lüfters mit einem Arduino ist jetzt sehr einfach. Unten siehst du den Code, der den Lüfter periodisch für 5 Sekunden ein- und ausschaltet.
// Control a relay to switch on/off a fan
const int relayPin = 3;
void setup() {
pinMode(relayPin, OUTPUT);
}
void loop() {
digitalWrite(relayPin, HIGH);
delay(5000);
digitalWrite(relayPin, LOW);
delay(5000);
}
Lass uns den Code durchgehen und verstehen, wie er funktioniert.
Konstanten und Variablen
Wir beginnen mit der Definition der Konstante relayPin, die den Pin angibt, an den das Relais angeschlossen ist. In diesem Fall ist es Pin 3.
const int relayPin = 2;
Setup-Funktion
In der setup() Funktion setzen wir den Modus von relayPin auf OUTPUT. Das ist notwendig, weil wir an diesen Pin schreiben, um das Relais zu steuern.
void setup() {
pinMode(relayPin, OUTPUT);
}
Loop-Funktion
Die loop() Funktion enthält die Hauptlogik unseres Codes. Zuerst setzen wir den relayPin auf HIGH mit der Funktion digitalWrite(). Dadurch wird das Relais eingeschaltet und der Lüfter läuft. Dann warten wir 5000 Millisekunden (5 Sekunden) mit der Funktion delay().
void loop() {
digitalWrite(relayPin, HIGH);
delay(5000);
Nach der Verzögerung setzen wir den relayPin auf LOW mit der Funktion digitalWrite(). Dadurch wird das Relais ausgeschaltet und der Lüfter stoppt. Wir warten erneut 5000 Millisekunden (5 Sekunden) mit der Funktion delay().
digitalWrite(relayPin, LOW); delay(5000);
Dieser Vorgang des Ein- und Ausschaltens des Lüfters wird in einer Endlosschleife wiederholt, wodurch ein kontinuierlicher Zyklus entsteht, bei dem der Lüfter 5 Sekunden läuft und dann 5 Sekunden aus ist.
Mit dem obigen Code und der Schaltung kannst du einen Lüfter für vorgegebene Zeiträume ein- oder ausschalten. Du könntest nun die interne Uhr des Arduino verwenden, um den Lüfter zu einer bestimmten Zeit einzuschalten und für eine feste Dauer laufen zu lassen.
Im nächsten Abschnitt zeige ich dir, wie du ein PIR-Modul verwenden kannst, um einen Lüfter einzuschalten, wenn Bewegung erkannt wird.
Beispiel 2: Lüfter mit Bewegungsmelder schalten
Oft möchte man einen Lüfter nur laufen lassen, wenn Bewegung erkannt wird. Zum Beispiel zeigt das Bild unten einen bewegungsaktivierten Lüfter, den ich gebaut habe, um Lötgase abzusaugen. Du siehst den Bewegungssensor (PIR-Sensor) im Sockel des Lüfters.
Schaltung für bewegungsaktivierten Lüfter
Die folgende Schaltung zeigt, wie du etwas Ähnliches bauen kannst. Sie verwendet einen passiven Infrarotsensor (PIR), der Bewegung erkennt und ein Relais aktiviert, das wiederum den Lüfter einschaltet.
Die Schaltung ist im Wesentlichen identisch mit der zuvor gezeigten Relais-Lüfter-Schaltung. Wir müssen nur den Bewegungssensor hinzufügen. Verbinde also zuerst Batterie, Relais, Lüfter und Arduino wie gehabt. Dann verbindest du Plus und Minus des PIR-Sensors mit den positiven und negativen Stromschienen des Breadboards (blaue und rote Kabel). Schließlich verbindest du den Signalausgang des PIR-Sensors mit Pin 2 des Arduino (grünes Kabel).
Code für bewegungsaktivierten Lüfter
Unten findest du den Code für den bewegungsaktivierten Lüfter. Er liest den Bewegungssensor alle 100 ms aus und schaltet den Lüfter bei Bewegungserkennung für 10 Sekunden ein. Schau dir den Code kurz an, dann besprechen wir die Details.
// Switch on fan for 10 seconds via relay
// if PIR sensor detects motion
const int motionPin = 3;
const int relayPin = 2;
void setup() {
pinMode(motionPin, INPUT);
pinMode(relayPin, OUTPUT);
}
void loop() {
int motionState = digitalRead(motionPin);
if (motionState == HIGH) {
digitalWrite(relayPin, HIGH);
delay(10000); // 10 seconds
digitalWrite(relayPin, LOW);
}
delay(100);
}
Konstanten und Variablen
Wir beginnen mit der Definition der Konstanten motionPin und relayPin, die die Pins angeben, an die der PIR-Sensor bzw. das Relais angeschlossen sind.
const int motionPin = 3; const int relayPin = 2;
Setup-Funktion
In der setup() Funktion setzen wir den Modus für motionPin auf INPUT und für relayPin auf OUTPUT, da wir vom PIR-Sensor lesen und zum Relais schreiben.
void setup() {
pinMode(motionPin, INPUT);
pinMode(relayPin, OUTPUT);
}
Loop-Funktion
In der loop() Funktion lesen wir zuerst den Zustand des PIR-Sensors mit digitalRead(motionPin) und speichern ihn in der Variablen motionState.
void loop() {
int motionState = digitalRead(motionPin);
Wenn der motionState den Wert HIGH hat, was Bewegung anzeigt, schalten wir den Lüfter ein, indem wir den relayPin auf HIGH mit digitalWrite(relayPin, HIGH) setzen. Dann warten wir 10 Sekunden mit delay(10000), um den Lüfter laufen zu lassen. Danach schalten wir den Lüfter aus, indem wir den relayPin auf LOW mit digitalWrite(relayPin, LOW) setzen.
if (motionState == HIGH) {
digitalWrite(relayPin, HIGH);
delay(10000); // 10 seconds
digitalWrite(relayPin, LOW);
}
Zum Schluss fügen wir eine kleine Verzögerung von 100 ms mit delay(100) hinzu, um den PIR-Sensor nicht zu häufig auszulesen und dem Arduino Zeit für andere Aufgaben zu geben.
delay(100);
Und das war’s. Jetzt hast du einen bewegungsaktivierten Lüfter!
Beispiel 3: Lüftergeschwindigkeit mit PWM steuern
In den bisherigen Beispielen haben wir den Lüfter nur ein- oder ausgeschaltet. Aber was, wenn wir die Lüftergeschwindigkeit steuern wollen? In diesem Beispiel lernst du, wie das geht.
Üblicherweise verwenden wir Pulsweitenmodulation (PWM), um die Leistung zu steuern, die an ein Gerät geliefert wird. PWM ist eine Technik, bei der der Mittelwert eines Signals durch Variation des Tastverhältnisses einer Rechteckwelle angepasst wird. Durch Ändern des Tastverhältnisses können wir die Lüftergeschwindigkeit steuern. Siehe unser Tutorial zu How use Arduino to control an LED with a Potentiometer für mehr Details zu PWM.
Du kannst einen Lüfter jedoch nicht direkt an einen Arduino anschließen und so steuern, da ein Lüfter zu viel Strom zieht. In den bisherigen Beispielen haben wir ein Relais verwendet, um dieses Problem zu umgehen. Relais sind jedoch zu langsam für PWM und würden durch die mechanische Belastung eines PWM-Signals schnell verschleißen.
MOSFET
Deshalb verwenden wir einen MOSFET. Ein MOSFET (Metal-Oxide-Semiconductor Field-Effect Transistor) ist ein Transistor, der in elektronischen Schaltungen weit verbreitet ist. Er hat drei Anschlüsse (Drain, Gate, Source) und kann elektronische Signale verstärken und schalten. Der MOSFET steuert den Stromfluss zwischen Source und Drain über ein elektrisches Feld, das durch eine Spannung am Gate erzeugt wird. Er ist bekannt für seine hohe Schaltgeschwindigkeit, geringen Stromverbrauch und Fähigkeit, hohe Ströme und Spannungen zu handhaben.
In diesem Beispiel verwende ich einen 2N7000 MOSFET. Siehe das Schaltzeichensymbol und die Pinbelegung des 2N7000 unten.
Für mehr Details siehe das Datenblatt des 2N7000:
Der 2N7000 kann bis zu 60V und 200mA dauerhaft schalten. Das reicht für meinen kleinen Lüfter. Die Spannungs- und Stromanforderungen findest du meist auf dem Etikett. Das Bild unten zeigt das Etikett meines Lüfters, der mit 12V läuft und 0,18A = 180mA zieht. Der 2N7000 MOSFET ist daher gut geeignet, meinen Lüfter zu steuern.
Wenn du einen größeren Lüfter hast, der mehr Strom zieht, benötigst du einen größeren MOSFET. Es gibt viele Typen, einige können 100A und mehr schalten! Achte auf eine Spannungs- (V DSS ) und Strom- (I D ) Belastbarkeit, die über den Anforderungen deines Lüfters liegt. Das unter den benötigten Teilen vorgeschlagene Transistor-Kit bietet eine gute Auswahl.
Als Faustregel gilt: Wähle etwa das Doppelte der benötigten Werte, um auf der sicheren Seite zu sein und Kühlung zu vermeiden. Für kleinere Lüfter wie meinen hier brauchst du nicht so viel Sicherheitsreserve.
Schaltung zur Steuerung der Lüftergeschwindigkeit
In diesem Abschnitt zeige ich dir und erkläre die Schaltung, die du brauchst, um einen Lüfter mit einem MOSFET zu steuern. Sie ist sehr einfach. Schau mal:
Wir verbinden einen der PWM-Ausgänge des Arduino, hier GPIO 3, mit dem Gate (G) des 2N7000 MOSFET. Der 100Ω Widerstand (R2) ist ein Strombegrenzungswiderstand aus Sicherheitsgründen. Du kannst ihn auch weglassen. Der zweite Widerstand (R1) mit 100KΩ ist ein Pulldown-Widerstand, der sicherstellt, dass der MOSFET abschaltet, wenn das Gate nicht verbunden ist.
Der Lüfter ist an +12V und den Drain (D) des MOSFET angeschlossen, während der Source (S) mit Masse (GND) verbunden ist. Wenn das Gate des MOSFET einen PWM-Impuls erhält, öffnet er und Strom kann vom Drain zum Source fließen, wodurch der Lüfter mit Strom versorgt wird. Denk daran, dass bürstenlose Lüfter eine Polung haben. Wenn der Lüfter nicht dreht, überprüfe die korrekte Polung und auch die richtige Orientierung des MOSFET.
Wenn du einen Standard-DC-Motor oder einen nicht bürstenlosen Lüfter verwendest, solltest du eine Flyback Diode parallel zum Motor schalten, um Spannungsspitzen zu unterdrücken, die eine induktive Last wie Motor oder Magnetventil verursacht. Unten ein Bild der Schaltung mit zusätzlicher Freilaufdiode:
Code zur Steuerung der Lüftergeschwindigkeit
Hier ist das Codebeispiel zur Steuerung des Lüfters. Es schaltet den Lüfter für 3 Sekunden aus, dann für 3 Sekunden mit mittlerer Geschwindigkeit und anschließend für weitere 3 Sekunden mit voller Geschwindigkeit.
// Code to control Fan speed via PWM
int fanPin = 3;
void setup() {
pinMode(fanPin, OUTPUT);
}
void loop() {
// Fan off
analogWrite(fanPin, 0);
delay(3000);
// Medium speed
analogWrite(fanPin, 150);
delay(3000);
// Max speed
analogWrite(fanPin, 255);
delay(3000);
}
Lass uns den Code durchgehen und verstehen, wie er funktioniert.
Konstanten und Variablen
In diesem Code gibt es eine Variable namens fanPin. Diese speichert die Pinnummer, an die der Lüfter angeschlossen ist. In diesem Fall ist es Pin 3. Beachte, dass du einen PWM-Pin verwenden musst! PWM-Pins am Arduino Uno sind mit einem „~“ gekennzeichnet, z.B. ~3, ~5, ~6, ~9, ~10 und ~11.
int fanPin = 3;
Setup-Funktion
In der setup() Funktion setzen wir den Modus von fanPin auf OUTPUT. Das ist notwendig, weil wir an diesen Pin schreiben, um die Lüftergeschwindigkeit zu steuern.
void setup() {
pinMode(fanPin, OUTPUT);
}
Loop-Funktion
In der loop() Funktion steuern wir die Lüftergeschwindigkeit mit PWM. Wir haben drei Geschwindigkeitsstufen: aus, mittel und maximal.
Zuerst schalten wir den Lüfter aus, indem wir den PWM-Wert mit analogWrite(fanPin, 0) auf 0 setzen. Dann warten wir 3 Sekunden mit delay(3000).
// Fan off analogWrite(fanPin, 0); delay(3000);
Als Nächstes setzen wir die Lüftergeschwindigkeit auf mittlere Stufe, indem wir den PWM-Wert mit analogWrite(fanPin, 150) auf 150 setzen. Wieder warten wir 3 Sekunden.
// Medium speed analogWrite(fanPin, 150); delay(3000);
Schließlich setzen wir die Lüftergeschwindigkeit auf maximal, indem wir den PWM-Wert mit analogWrite(fanPin, 255) auf 255 setzen. Danach warten wir weitere 3 Sekunden, bevor die Schleife von vorne beginnt.
// Max speed analogWrite(fanPin, 255); delay(3000);
Diese Schleife läuft unendlich weiter und durchläuft die verschiedenen Lüftergeschwindigkeiten.
Mit diesem Code und der Schaltung kannst du die Geschwindigkeit so gut wie jedes Lüfters steuern. Es funktioniert für bürstenlose und gebürstete Lüfter, 2- und 3-Draht-Lüfter. Wenn du einen 4-Draht-Lüfter hast, der bereits eine interne Steuerung für die Geschwindigkeit besitzt, brauchst du die oben gezeigte MOSFET-Schaltung nicht, sondern kannst das PWM-Signal direkt einspeisen.
Beispiel 4: Temperaturgesteuerter Lüfter
Ein sehr häufiges Anwendungsbeispiel ist die Regelung der Lüftergeschwindigkeit basierend auf der Umgebungstemperatur. Ich zeige dir, wie das geht.
Zuerst brauchen wir einen Sensor zur Temperaturmessung. Es gibt viele verschiedene Temperatursensoren, und es ist nicht so wichtig, welchen du nimmst. Hier verwende ich den DHT11 Temperatur- & Feuchtigkeitssensor. Du kannst ihn als Modul oder als reinen Sensor bekommen. Beides ist in Ordnung und funktioniert gleich.
Wenn du mehr Details zum DHT11 und seinem Verwandten DHT22 brauchst, schau dir unser Tutorial an: DHT11/DHT22 Sensor with Arduino Tutorial. Statt des DHT11 kannst du auch den TMP36, den LM35 oder den DS18B20 verwenden. Diese sind ebenfalls geeignete Temperatursensoren, aber du musst Schaltung und Code etwas anpassen, wenn du sie benutzt.
Schaltung für temperaturgesteuerten Lüfter
Die Schaltung zur Steuerung der Lüftergeschwindigkeit mit einem DHT11 ist unten gezeigt. Du kannst den DHT11 durch einen DHT21 oder DHT22 ersetzen, ohne die Schaltung zu ändern.
Wie du siehst, verwenden wir dieselbe MOSFET-basierte Schaltung, um den Lüfter per PWM vom Pin 3 des Arduino zu steuern. Wir fügen nur den DHT11 hinzu und verbinden seinen IO-Pin mit Pin 2 des Arduino. Für die Stromversorgung verbindest du den VCC-Pin mit 5V und den GND-Pin mit Masse. Das folgende Bild zeigt die Pinbelegung des DHT11.
Beachte, dass Pin 3 nicht verwendet wird. Deshalb haben die DHT-Module nur drei Pins, während der Sensor vier Pins hat.
Unten ein Bild der fertigen Schaltung mit einem kleinen Lüfter, einer 9V-Batterie und einem Breadboard.
Code für temperaturgesteuerten Lüfter
Der folgende Code zeigt, wie du PWM (Pulsweitenmodulation) und die Temperaturwerte des DHT11-Sensors nutzt, um die Lüftergeschwindigkeit anzupassen.
// Control fan speed using PWM based
// on temperature reading from DHT11 sensor
#include "Adafruit_Sensor.h"
#include "DHT.h"
const int tempPin = 2;
const int fanPin = 3;
// Sensor types: DHT11, DHT22, DHT21
DHT dht = DHT(tempPin, DHT11);
void setup() {
dht.begin();
pinMode(fanPin , OUTPUT);
}
void loop() {
float temp = dht.readTemperature(); // Celsius
if (isnan(temp)) return;
int fanSpeed = map(temp, 20, 40, 0, 255);
fanSpeed = constrain(fanSpeed, 0, 255);
analogWrite(fanPin, fanSpeed);
delay(5000);
}
Lass uns den Code aufschlüsseln und verstehen, wie er funktioniert.
Bibliotheken
Der DHT11 verwendet ein vergleichsweise komplexes Kommunikationsprotokoll (siehe datasheet). Du könntest das selbst implementieren, aber es ist einfacher, eine Bibliothek zu verwenden. Es gibt mehrere Arduino-Bibliotheken für den DHT11-Sensor. Hier verwenden wir eine von Adafruit.
#include "Adafruit_Sensor.h" #include "DHT.h"
Du musst die Basisbibliothek „Adafruit_Sensor.h“ und deren „DHT.h“ Bibliothek installieren. Schau dir unser Tutorial an: DHT11/DHT22 Sensor with Arduino Tutorial, falls du mehr Details brauchst.
Konstanten und Variablen
Wir beginnen mit der Definition von zwei Konstanten: tempPin und fanPin. tempPin steht für die Pinnummer, an die der DHT11-Sensor angeschlossen ist, und fanPin für die Pinnummer, an die der Lüfter angeschlossen ist.
const int tempPin = 2; const int fanPin = 3;
Als Nächstes erstellen wir eine Instanz der DHT-Bibliothek und initialisieren sie mit tempPin und dem Sensortyp, der in diesem Fall DHT11 ist. Wenn du statt des DHT11 einen DHT21 oder DHT22 verwenden möchtest, ändere einfach die Konstante.
// Sensor types: DHT11, DHT22, DHT21 DHT dht = DHT(tempPin, DHT11);
Setup-Funktion
In der setup() Funktion initialisieren wir den DHT-Sensor mit der dht.begin() Funktion. Wir setzen auch den fanPin als Ausgangspin mit der pinMode() Funktion.
void setup() {
dht.begin();
pinMode(fanPin , OUTPUT);
}
Loop-Funktion
In der loop() Funktion lesen wir zuerst die Temperatur in Celsius vom DHT-Sensor mit der dht.readTemperature() Funktion. Wenn du Fahrenheit statt Celsius verwenden möchtest, rufe einfach dht.readTemperature(true) auf.
Wenn der Sensor die Temperatur nicht lesen kann, gibt er Not-a-Number (NaN) zurück. In diesem Fall verlassen wir die Funktion mit der return Anweisung.
Andernfalls mappen wir den Temperaturwert aus dem Bereich von 20 bis 40 Grad Celsius auf den Bereich von 0 bis 255. Dieser Wert wird zur Steuerung der Lüftergeschwindigkeit verwendet. Das bedeutet, bei 20 Grad Celsius ist die Lüftergeschwindigkeit noch 0, aber über 20 Grad beginnt der Lüfter sehr langsam zu drehen, bis er bei 40 Grad seine maximale Geschwindigkeit (255) erreicht.
Für viele Anwendungen möchtest du dieses Verhalten vielleicht ändern und den Lüfter mit mittlerer Geschwindigkeit starten, wenn eine bestimmte Temperaturschwelle erreicht wird, da sehr langsame Lüftergeschwindigkeiten kaum Kühlung bringen und der Lüfter bei kleinen PWM-Werten möglicherweise gar nicht anspringt.
float temp = dht.readTemperature(); if (isnan(temp)) return; int fanSpeed = map(temp, 20, 40, 0, 255);
Beachte, dass die map() Funktion nicht garantiert, dass fanSpeed im erlaubten Wertebereich [0..255] liegt. Zum Beispiel liefert sie für Temperaturen unter 20 Grad Celsius negative Werte!
Das wollen wir nicht, deshalb verwenden wir die constrain() Funktion, um den Lüftergeschwindigkeitswert auf den Bereich von 0 bis 255 zu begrenzen.
fanSpeed = constrain(fanSpeed, 0, 255);
Zum Schluss verwenden wir die analogWrite() Funktion, um die Lüftergeschwindigkeit zu setzen, indem wir fanPin und den Lüftergeschwindigkeitswert übergeben. Wie erwähnt, startet der Lüfter bei kleinen PWM-Werten (fanSpeed < 10) möglicherweise nicht. Probiere es mit deinem Lüfter aus und finde einen Mindestwert, der für deine Anwendung passt. Vielleicht möchtest du den Lüfter bei Überschreiten von 20 Grad mit einer Geschwindigkeit von 100 starten.
analogWrite(fanPin, fanSpeed);
Zum Schluss fügen wir eine Verzögerung von 5 Sekunden mit der delay() Funktion hinzu, bevor die Schleife wiederholt wird. So messen wir im Wesentlichen alle 5 Sekunden die Umgebungstemperatur und passen die Lüftergeschwindigkeit entsprechend an.
delay(5000);
Und das ist dein temperaturgesteuerter Lüfter!
Fazit
In diesem Blogbeitrag haben wir gelernt, wie man einen Lüfter mit Arduino steuert. Wir begannen mit den benötigten Teilen für dieses Projekt, darunter ein Arduino-Board, ein Lüfter und verschiedene elektronische Komponenten wie Relais, MOSFETs und Temperatursensoren.
Anschließend haben wir die verschiedenen auf dem Markt erhältlichen Lüftertypen untersucht, wie AC- und DC-Lüfter. Wir haben die Vor- und Nachteile der einzelnen Typen besprochen und wie sie in unterschiedlichen Szenarien eingesetzt werden können.
Danach sind wir auf die Details der Steuerung von DC-Lüftern eingegangen, insbesondere auf die 2-, 3- und 4-Draht-Konfigurationen. Wir haben erklärt, wie jeder Draht für unterschiedliche Zwecke verwendet wird, wie Stromversorgung, Masse, Tachometersignal und PWM-Steuerung.
Zur Veranschaulichung haben wir verschiedene Methoden gezeigt, wie man Lüfter mit Arduino steuern kann. Wir haben demonstriert, wie man einen AC- oder DC-Lüfter mit einem Relais schaltet.
Außerdem haben wir fortgeschrittene Techniken wie die Steuerung der Lüftergeschwindigkeit mit PWM über einen MOSFET vorgestellt. Wir haben erklärt, wie Pulsweitenmodulation verwendet werden kann, um die Lüftergeschwindigkeit zu variieren und so eine präzise Steuerung entsprechend den Kühlanforderungen zu ermöglichen.
Schließlich haben wir ein Beispiel gezeigt, wie man die Lüftergeschwindigkeit basierend auf der Umgebungstemperatur mit einem MOSFET steuert. Diese Anwendung ist nützlich in Umgebungen, in denen Temperaturregelung wichtig ist, wie in Elektronikgehäusen oder Serverräumen.
Wir hoffen, dieser Blogbeitrag hat dir wertvolle Einblicke und Inspiration für deine Lüftersteuerungsprojekte gegeben. Experimentiere gerne weiter und entdecke weitere Möglichkeiten mit Arduino und Lüftern!
Häufig gestellte Fragen
Hier sind einige häufig gestellte Fragen zur Steuerung eines Lüfters mit Arduino:
F: Was ist der Unterschied zwischen AC- und DC-Lüftern?
A: Der Hauptunterschied liegt in der Art der benötigten Stromversorgung. AC-Lüfter sind für den Betrieb mit Netzwechselstrom ausgelegt, während DC-Lüfter für Gleichstromquellen wie Batterien oder Netzteile konzipiert sind.
F: Wie schalte ich einen Lüfter mit einem Relais?
A: Um einen Lüfter mit einem Relais zu schalten, musst du das Relaismodul mit dem Arduino verbinden. Der Arduino steuert dann das Relais, das den Lüfter ein- oder ausschaltet. Du verbindest den Eingangs-Pin des Relais mit einem digitalen Pin des Arduino und die Ausgangspins des Relais mit der Stromversorgung des Lüfters.
F: Wie kann ich die Geschwindigkeit eines Lüfters mit Arduino steuern?
A: Zur Steuerung der Lüftergeschwindigkeit kannst du ein MOSFET-Modul verwenden. Indem du das MOSFET-Modul mit dem Arduino verbindest, kannst du die Spannung am Lüfter variieren und so die Geschwindigkeit steuern. Dies geschieht über Pulsweitenmodulation (PWM), die vom Arduino erzeugt wird.
F: Kann ich das Geschwindigkeitssignal eines Lüfters mit Arduino auslesen?
A: Ja, das kannst du. Einige Lüfter haben einen Tachometer-Ausgang, der ein Pulssignal proportional zur Lüftergeschwindigkeit liefert. Wenn du dieses Signal an einen digitalen Pin des Arduino anschließt, kannst du die Geschwindigkeit messen. Wenn der Lüfter keinen Geschwindigkeitsdraht hat, kannst du auch einen eigenen Geschwindigkeitsmonitor bauen. Siehe unser Tutorial Build Arduino Tachometer Using A3144 Hall Effect Sensor.
F: Kann ich die Lüftergeschwindigkeit basierend auf der Umgebungstemperatur steuern?
A: Ja, das ist möglich. Indem du einen Temperatursensor an den Arduino anschließt, kannst du die Umgebungstemperatur messen und die Lüftergeschwindigkeit entsprechend anpassen.
F: Kann ich die Lüftergeschwindigkeit basierend auf dem Umgebungslicht steuern?
A: Ja, das kannst du. Indem du einen Lichtsensor in einer Spannungsteiler-Schaltung an den Arduino anschließt, kannst du die Umgebungshelligkeit messen und die Lüftergeschwindigkeit entsprechend anpassen. Unten ist die Grundschaltung zur Messung von Licht.
Für mehr Details siehe unser Tutorial How to detect light using an Arduino.
F: Kann ich statt eines DHT11 einen DS18B20 Temperatursensor verwenden?
Ja, das kannst du, aber du musst den Code ändern. Hier ein kurzes Beispiel, wie du Temperaturdaten vom DS18B20 ausliest:
// https://github.com/matmunk/DS18B20
#include "DS18B20.h"
const int tempPin = 2;
DS18B20 ds(tempPin);
void setup() {
Serial.begin(9600);
}
void loop() {
while (ds.selectNext()) {
float temp = ds.getTempC();
...
delay(1000);
}
}
F: Kann ich die Drehrichtung eines Lüfters mit Arduino steuern?
Das kommt darauf an. Bürstenlose Lüfter und AC-Lüfter drehen meist nur in eine Richtung. Das Ändern der Polung zur Richtungsänderung funktioniert bei diesen Lüftern nicht. Wenn der Lüfter jedoch einen einfachen gebürsteten DC-Motor verwendet, kannst du die Richtung steuern. Dafür benötigst du eine H-Brücke oder ein Motortreiber-Board.
F: Kann ich mehrere Lüfter mit einem Arduino steuern?
Ja, du kannst mehrere Lüfter mit einem Arduino steuern, indem du geeignete elektronische Bauteile wie Relais oder MOSFETs verwendest. Jeder Lüfter benötigt seine eigene Steuerungsschaltung, aber alle können von einem einzigen Arduino-Board aus gesteuert werden.
Das sind nur einige der häufig gestellten Fragen zur Steuerung eines Lüfters mit Arduino. Wenn du weitere Fragen hast, stelle sie gerne im Kommentarbereich unten.
