Wie man die Lüftergeschwindigkeit mit der Temperatur mit Arduino uno steuert
Erstellen eines temperaturgesteuerten Lüfters
Um die Lüftergeschwindigkeit zu ändern, gibt es einen festgelegten Knopf zur Steuerung der Geschwindigkeit des Lüfters und kann manuell angepasst werden. Wir können jedoch die Geschwindigkeit des Lüfters von der Temperatur eines Bereichs abhängen. Die Geschwindigkeit des Lüfters passt sich also automatisch an, wenn sich die Temperatur dieses Bereichs ändert. Die Komponenten, die wir zum Erstellen eines temperaturgesteuerten Lüfters verwendet haben, sind:
- Arduino uno
- Drähte verbinden
- Brotbrett
- Temperatursensor (LM35)
- DC -Fan
- Flüssigkristallanzeige (LCD)
- Potentiometer
Das Schema für die Schaltung, die Lüftergeschwindigkeit in Bezug auf die Temperatur zu steuern, wird also als:
Hardware -Montage zum Erstellen eines temperaturgesteuerten Lüfters mit Arduino Uno
Das unten veröffentlichte Bild zeigt die Verbindungen jeder Komponente, die mit Arduino Uno verbunden ist.
Die rosa Drähte verbinden das LCD mit Arduino Uno und der graue Draht verbindet das Potenzentiometer mit LCD, um die Helligkeit des LCD zu steuern.
Darüber hinaus haben wir den Temperatursensor direkt an den Stiften von Arduino angeschlossen, um eine Verzerrung des Ausgangs des Sensors zu vermeiden. Um die Komponenten mit der Stromversorgung zu verbinden, haben wir die 5 Volt und den Boden des Arduino verwendet.
Arduino-Code für den temperaturgesteuerten Lüfter
Der Arduino -Code, der zur Steuerung von Lüfter basierend auf Temperaturwerten zusammengestellt wurde, ist unten angegeben:
#include // Bibliothek für den LCD
Liquidcrystal LCD (9,8,5,4,3,2); // Arduino -Pins für die LCD
int vcc = a0; // A0 -Pin -Versorgung von LM35
int vout = a1; // A1 -Pin für die Ausgabe des LM35
int gnd = a2; // A2 -Pin für die Ausgabe des LM35
int Wert; // Variable zum Speichern der Werte aus dem Sensor verwendet
int fan = 11; // Der Pin, in dem der Lüfter auf Arduino verbunden ist
int tempmin = 86; // die Temperatur, um den Lüfter zu starten
int tempmax = 127; // die maximale Temperatur
int fanspeed; // variable für stark die Geschwindigkeit des Lüfters
int fanlcd; // Variable für die Anzeige der prozentualen Lüftergeschwindigkeit auf LCD
int tempc; // Temperatur in Grad Celsius
int tempf; // Temperatur in Fahrenheit
void setup ()
// Zuordnungsmodi den zugewiesenen Arduino -Stiften zuweisen
PinMode (Lüfter, Ausgabe);
PinMode (VCC, Ausgabe);
PinMode (vout, Eingabe);
PinMode (GND, Ausgabe);
// Zuordnungszustände dem VCC- und Bodennadeln zuweisen, die für LM35 verwendet werden
DigitalWrite (VCC, High);
DigitalWrite (GND, niedrig);
LCD.Beginnen Sie (16,2); // Initialisierung der Dimensionen von LCD
Serie.Beginnen Sie (9600); // Initialisierung der seriellen Kommunikation
LCD.setCursor (0, 0); // Festlegen der Stelle für die Daten auf LCD
LCD.Print ("Arduino Fan"); // Daten, die angezeigt werden sollen
LCD.setCursor (0, 1); // Einstellen der Stelle für die Daten auf LCD
LCD.print ("Speed Control"); // Daten zu angezeigt werden
Verzögerung (3000); // Zeit, für die die Daten angezeigt werden
Hohlraumschleife ()
LCD.clear (); // das LCD klären
tempf = temperatur (); /*Aufrufen der Temperaturfunktion, um den Wert der Temperatur in Fahrenheit zu erhalten*///
Serie.Print (tempf); // die Temperatur in Fahrenheit anzeigen
if (tempf = tempmin) && (tempf <= tempMax)) /* if temperature is higher than minimum temp and less than the maximum temperature then */
fanSpeed = tempf; // Geben Sie der Lüftergeschwindigkeit den Wert von TEMPF an
fanlcd = map (tempf, tempmin, tempmax, 0, 100); /*Skalierung der Lüftergeschwindigkeit, um sie auf LCD mit der Kartenfunktion von 0 bis 100*/anzuzeigen
Analogwrite (Fan, Fanspeed); // Zuweisen des Wertes dem Pin des Lüfters
LCD.print ("Temperatur:"); // Anzeigen der Daten
LCD.print (tempf); // Zeigen Sie die Temperatur in Fahrenheit an
LCD.print ("f");
LCD.setCursor (0,1); // Definieren Sie den Ort der nächsten Daten, die angezeigt werden sollen
LCD.print ("Lüftergeschwindigkeit:"); // Anzeigen der Daten
LCD.print (fanlcd); // Zeigen Sie die Lüftergeschwindigkeit an
LCD.drucken ("%"); // die Daten anzeigen
Verzögerung (200); // Zeit, für die die Daten auf LCD angezeigt werden
LCD.clear (); // das LCD klären
int temperatur () // Funktionsname
value = Analograd (vout); // Lesen Sie den Wert des Sensors
tempc = value*0.48828125; // Die Werte des Sensors in Grad Celsius konvertieren
return tempf = tempc*9/5+32; // Die Werte in Fahrenheit konvertieren
Um einen temperaturgesteuerten Lüfter zu entwerfen, haben wir den Arduino-Code so zusammengestellt, dass wir zuerst die LCD-Bibliothek definiert und Arduino-Pins für die LCD zugewiesen haben. Als Nächst.
Da wir die Temperatur in Fahrenheit einnehmen, haben wir auch die minimalen und maximalen Grenzen für die Temperatur definiert, die von 86 Fahrenheit bis 127 Fahrenheit liegt.
In der Setup -Funktion zuerst haben wir den zuvor definierten Arduino -Stiften Pinmodi und dann dem VCC- und Erdungsstift des Temperatursensors zugewiesen. Danach werden die Dimensionen des LCD initialisiert und der Projektname auf dem LCD angezeigt.
In der Schleifenfunktion wird zuerst die Temperaturfunktion aufgerufen, um den Wert der Temperatur zu erhalten. Wenn der Zustand verwendet wird, um zu prüfen, ob die Temperatur geringer ist als die Mindesttemperatur. In diesem Fall dreht sich der Lüfter nicht, dann gibt es einen anderen, wenn und der Betrieb und der Betrieb und prüft, ob die Temperatur zwischen dem angegebenen Bereich der Temperatur liegt.
Wir haben die benutzt Kartenfunktion um die Geschwindigkeit des Lüfters mit den Temperaturwerten im Bereich von 0 bis 100 zu skalieren, und dann wird dieser Wert dem Arduino -Pin des Lüfters verwendet Analogwrite () Funktion und es lässt den Lüfter mit jeweils Geschwindigkeit drehen.
Dann werden die Daten für die Temperatur und die Lüftergeschwindigkeit auf dem LCD mit dem angezeigt LCD.drucken() Funktion. Um die Werte des Sensors in den Grad Celsius umzuwandeln, haben wir die Skala von 0 verwendet.01 V Erhöhung der Spannung pro Grad Celprade.
Wenn also die Spannung 1 Volt beträgt, beträgt die Temperatur 100 Grad. Hier für den Sensor haben wir maximal 5 Volt, sodass die Temperatur 500 auf 5 Volt beträgt. Der maximale Analogwert für den Sensor beträgt jedoch 1023. Wir haben auch die Temperatur in Fahrenheit umgewandelt, und das Konzept für die Umwandlung kann die folgende Tabelle weiter ausführen:
Änderung pro Grad Celsius = (maximale Temperatur/maximaler Analogwert);
0.488 = (500/1023);
Temperatur in Grad = Analogwert*0.488;
Temperatur in Fahrenheit = Temperatur in Grad*9/5+32;
Simulation
Hier in diesem Projekt haben wir eine Simulation in Porteous Software erstellt. In der unten veröffentlichten Simulation sehen wir, dass wir die Temperatur manuell erhöhen. Die Lüftergeschwindigkeit nimmt also immer wieder zu, wenn wir die Temperatur erhöhen:
Abschluss
Die Arduino-Boards können verwendet werden, um eine Vielzahl von Do-it-yourself-Projekten zu erstellen, und das den Anfängern ein besseres Verständnis für die Arbeit der Schaltungen gibt. In ähnlicher Weise können wir ihre Schaltkreise auch auf eine sehr einfache Weise erstellen, um die Arbeit der Geräte zu verstehen. In diesem Leitfaden haben wir einen automatischen Lüfter erstellt, der von den Werten des Temperatursensors abhängt. Die temperaturgesteuerten Lüfter werden hauptsächlich in den Geräten verwendet, die bei hohen Temperaturen eine ausreichende Kühlung benötigen. Das häufigste Beispiel ist die Desktop-PCs oder Laptops.