Arduino temperaturgesteuerte DC-Lüfterkreise

In diesem Artikel werden wir einige einfache automatische temperaturgesteuerte Gleichstrom-Lüfterschaltungen auf Arduino-Basis konstruieren, die einen Lüfter oder andere daran angeschlossene Geräte einschalten, wenn die Umgebungstemperatur einen vorbestimmten Schwellenwert erreicht. Wir werden für dieses Projekt DHT11-Sensor und Arduino verwenden.

Überblick

Das Schöne an Mikrocontrollern ist, dass wir die angeschlossenen Peripheriegeräte sehr genau steuern können. In diesem Projekt muss der Benutzer nur die Schwellentemperatur in das Programm eingeben, der Mikrocontroller kümmert sich um den Rest der Funktion.

Im Internet sind unzählige Projekte für automatische Temperaturregler verfügbar, die nicht auf Mikrocontrollern basieren, z. B. die Verwendung von Komparatoren und Transistoren.

Sie sind sehr einfach und funktionieren gut, aber das Problem tritt auf, wenn der Schwellenwert mit einem voreingestellten Widerstand oder Potentiometer kalibriert wird.

Wir haben eine blinde Idee beim Kalibrieren und der Benutzer muss möglicherweise eine Trial-and-Error-Methode durchführen, um den Sweet Spot zu finden.

Diese Probleme werden von Mikrocontrollern überwunden. Der Benutzer muss in diesem Projekt lediglich die Temperatur in Celsius eingeben, sodass keine Kalibrierung erforderlich ist.

Dieses Projekt kann dort eingesetzt werden, wo die Innentemperatur des Kreislaufs stabilisiert oder vor Überhitzung geschützt werden muss.

In Abbildung 1 schließen wir einen CPU-Lüfter als Ausgang an. Mit diesem Setup kann die interne Umgebungstemperatur eines geschlossenen Stromkreises gesteuert werden.

Wenn die Schwellentemperatur erreicht ist, schaltet sich der Lüfter ein. Wenn die Temperatur unter den Schwellenwert fällt, schaltet sich der Lüfter aus. Es handelt sich also im Grunde genommen um einen automatisierten Prozess.

In Abbildung 2 haben wir ein Relais zur Steuerung von Geräten angeschlossen, die mit Netzspannung betrieben werden, z. B. Tischlüfter.

Wenn die Raumtemperatur die Schwellentemperatur erreicht, schaltet sich der Lüfter ein und aus, wenn der Raum abkühlt.

Dies ist möglicherweise der beste Weg, um Strom zu sparen, und dies kann ein Paradies für faule Leute sein, die möchten, dass andere den Lüfter einschalten, wenn sie sich warm fühlen.

Schaltplan mit DC-Lüftersteuerung

Dieses Setup kann für Schaltkreise bereitgestellt werden, die in einer Box enthalten sind. Die LED leuchtet auf, wenn der voreingestellte Schwellenwert erreicht ist, und schaltet auch den Lüfter ein.

Anschließen eines Relais zur Steuerung größerer Lüfter

Diese Schaltung hat die ähnliche Funktion wie die vorherige Schaltung, jetzt wird der Lüfter durch ein Relais ersetzt.

Dieser Stromkreis kann einen Tisch- oder Deckenventilator oder ein anderes Gerät steuern, das die Umgebungstemperatur abkühlen kann.

Das angeschlossene Gerät schaltet sich aus, sobald die Temperatur unter dem voreingestellten Schwellenwert liegt.

Das hier dargestellte Schaltbild des temperaturgesteuerten Gleichstromlüfters sind nur einige von vielen Möglichkeiten. Sie können die Schaltung und das Programm für Ihren eigenen Zweck anpassen.

HINWEIS 1: #Pin 7 wird ausgegeben.

HINWEIS 2: Dieses Programm ist nur mit dem DHT11-Sensor kompatibel.

Programm für die oben erläuterte automatische Temperaturreglerschaltung mit Arduino:

Programmcode

//--------------------Program developed by R.Girish---------------------//
#include
dht DHT
#define DHTxxPIN A1
int p = A0
int n = A2
int ack
int op = 7
int th = 30 // set thershold tempertaure in Celsius
void setup(){
Serial.begin(9600) // May be removed after testing
pinMode(p,OUTPUT)
pinMode(n,OUTPUT)
pinMode(op,OUTPUT)
digitalWrite(op,LOW)
}
void loop()
{
digitalWrite(p,1)
digitalWrite(n,0)
ack=0
int chk = DHT.read11(DHTxxPIN)
switch (chk)
{
case DHTLIB_ERROR_CONNECT:
ack=1
break
}
if(ack==0)
{
// you may remove these lines after testing, from here
Serial.print('Temperature(°C) = ')
Serial.println(DHT.temperature)
Serial.print('Humidity(%) = ')
Serial.println(DHT.humidity)
Serial.print(' ')
// To here
if (DHT.temperature>=th)
{
delay(3000)
if(DHT.temperature>=th) digitalWrite(op,HIGH)
}
if(DHT.temperature {
delay(3000)
if(DHT.temperature }
}
if(ack==1)
{
// may be removed after testing from here
Serial.print('NO DATA')
Serial.print(' ')
// To here
digitalWrite(op,LOW)
delay(500)
}
}
//-------------------------Program developed by R.Girish---------------------//

Hinweis: Im Programm

int th = 30 // Stellen Sie die Schwellentemperatur in Celsius ein.

Ersetzen Sie '30' durch den gewünschten Wert.

Zweites Design

Das unten diskutierte zweite Projekt eines temperaturgesteuerten Gleichstromlüfterkreises erfasst automatisch die Umgebungstemperatur und passt die Drehzahl des Lüftermotors an, um die Umgebungstemperatur unter Kontrolle zu halten. Diese automatische Verarbeitung erfolgt über einen Arduino und einen Temperatursensor IC LM35.

Durch:Ankit Negi

UNSER ZIEL:

1). Sobald die Umgebungstemperatur über 25 Grad Celsius steigt (Sie können diesen Wert im Programm je nach Bedarf ändern, siehe Arbeitsabschnitt), läuft der Motor an.

2). Und mit jedem Grad des Temperaturanstiegs steigt auch die Motordrehzahl.

3). Der Motor läuft mit seiner Höchstgeschwindigkeit, sobald die Temperatur auf 40 Grad Celsius steigt (dieser Wert kann im Programm geändert werden).

TEMPERATURSENSOR LM35:

Um die oben erwähnte Aufgabe zu erfüllen, werden wir temp verwenden. Sensor LM35, wie er weit verbreitet und leicht verfügbar ist.

Der LM35 hat 3 Stifte, wie Sie in der Abbildung sehen können.

1. Vin-- Dieser Pin ist zwischen 4 und 20 V an die Gleichstromversorgung angeschlossen.
2. Vout - Dieser Pin gibt einen Ausgang in Form einer Spannung aus.
3. GND - Dieser Pin ist mit dem GND-Anschluss des Stromkreises verbunden.

LM35 erkennt bei Anschluss an die Stromversorgung die Temperatur der Umgebung und sendet eine äquivalente Spannung entsprechend dem Temperaturanstieg pro Grad über seinen Ausgangspin.

Der LM35 kann jede Temperatur erfassen. zwischen -50 Grad und +150 Grad Celsius und erhöht die Leistung um 10 Millivolt bei 1 Grad Temperaturanstieg. Somit beträgt die maximale Spannung, die es als Ausgang geben kann, 1,5 Volt.

WARUM ARDUINO FÜR DIESES DC FAN CONTROLLER-PROJEKT?

Arduino muss den vom Ausgangspin des LM35 empfangenen Analogwert in einen Digitalwert ändern und sendet den entsprechenden Digitalausgang (PWM) an die Basis des Mosfet.

Wir werden auch verwenden Arduino-Befehle zum Drucken der Temperatur, entsprechender Analogwert und digitaler Ausgang zum Mosfet auf dem seriellen Monitor der ARDUINO IDE.

WAS IST DIE ROLLE DES LEISTUNGSMOSFETS?

Diese Schaltung ist nutzlos, wenn sie keinen Hochstrommotor betreiben kann. Daher wird zum Betrieb solcher Motoren ein Power Mosfet verwendet.

WARUM WIRD DIODE VERWENDET?

Die Diode schützt den Mosfet vor der hinteren EMF, die der Motor während des Betriebs erzeugt.

TEILELISTE FÜR DAS PROJEKT:

1. LM35

2. ARDUINO

3. LEISTUNGSMOSFET (IRF1010E)

4. DIODE (1N4007)

5. LÜFTER (Motor)

6. LÜFTERSTROMVERSORGUNG

SCHALTPLAN:

Stellen Sie die Verbindungen wie im Schaltplan gezeigt her.

a) Verbinden Sie den Vin-Pin von lm358 mit 5 V Arduino
b) Verbinden Sie den Vout-Pin von lm358 mit A0 von Arduino
c) Verbinden Sie den Erdungsstift von lm358 mit GND von Arduino
d) Verbinden Sie die Basis des Mosfets mit dem PWM-Pin 10 des Arduino

CODE:

float x// initialise variables
int y
int z
void setup()
{
pinMode(A0,INPUT) // initialize analog pin A0 as input pin
Serial.begin(9600) // begin serial communication
pinMode(10,OUTPUT) // initialize digital pin 10 as output pin
}
void loop()
{
x=analogRead(A0) // read analog value from sensor's output pin connected to A0 pin
y=(500*x)/1023// conversion of analog value received from sensor to corresponding degree Celsius (*formula explained in working section)
z=map(x,0,1023,0,255) // conversion of analog value to digital value
Serial.print('analog value ')
Serial.print( x) // print analog value from sensor's output pin connected to A0 pin on serial monitor( called 'analog value')
Serial.print(' temperature ')
Serial.print( y) // print the temprature on serial monitor( called 'temprature')
Serial.print(' mapped value ')
Serial.print( z*10) // multiply mapped value by 10 and print it ( called ' mapped value ' )
Serial.println()
delay(1000) // 1 sec delay between each print.
if(y>25)
{analogWrite(10,z*10) // when temp. rises above 25 deg, multiply digital value by 10 and write it on PWM pin 10 ( ** explained in working section)
}
else
{analogWrite(10,0) // in any other case PWM on pin 10 must be 0
}
}

ARBEITEN (Code verstehen):

EIN). VARIABLE X-

Dies ist einfach der Analogwert, der von Pin Nr. 1 empfangen wird. A0 vom Ausgangspin des LM35.

B). VARIABLE AND-

Nur aufgrund dieser Variablen läuft unser Lüftermotor entsprechend der entsprechenden Temperatur. Diese Variable ändert den Analogwert, d. H. Die Variable x, auf die entsprechende Umgebungstemperatur.

Y = (500 · x) / 1023
1. Der erste Analogwert muss auf die entsprechende Spannung geändert werden, d.h.
1023: 5v
Daher (5000 Millivolt * x) / 1023 V.
2. Jetzt wissen wir, dass für jeden Grad Temperaturanstieg der entsprechende Spannungsausgang um 10 mV ansteigt, d.h.
1 Grad Celsius: 10 Millivolt
Daher (5000 Millivolt * x) / (1023 * 10) GRAD

C). VARIABLE Z-

z = Karte (x, 0, 1023, 0,255)
Diese Variable ändert den Analogwert in den Digitalwert für den PWM-Ausgang an Pin 10.

HINWEIS :: Wir wissen, dass lm35 maximal 1,5 Volt liefern kann und das auch bei Temp. Ist 150 Grad. das ist nicht praktisch.

Dies bedeutet, dass wir für 40 Grad Celsius 0,40 Volt und für 25 Grad 0,25 Volt erhalten. Da diese Werte für ein korrektes PWM auf Mosfet sehr niedrig sind, müssen wir es mit einem Faktor multiplizieren.

Daher multiplizieren wir es mit 10 und geben stattdessen diesen Wert als Analogausgang an den PWM-Pin 10, d.h.

** analogWrite (10, z * 10)

Für 0,25 Volt erhält Mosfet nun 0,25 * 10 = 2,5 Volt

Für 0,40 Volt erhält Mosfet 0,40 * 10 = 4 Volt, bei denen der Motor fast mit seiner vollen Drehzahl läuft

FALL 1. Wenn temp. Ist weniger als 25 Grad

In diesem Fall sendet Arduino wie in der letzten Codezeile 0 PWM-Spannung an Pin 10

** sonst
{analogWrite (10,0) // In jedem anderen Fall muss PWM an Pin 10 0 sein
} **

Da die PWM-Spannung an der Basis des Mosfet 0 ist, bleibt sie ausgeschaltet und der Motor wird vom Stromkreis getrennt.

Siehe simulierte Schaltung in diesem Fall.

Wie Sie sehen können, beträgt die Temperatur daher 20 Grad

Analogwert = 41
Temperatur = 20
Zugeordneter Wert = 100

Da die Temperatur jedoch weniger als 25 Grad beträgt, erhält Mosfet 0 Volt, wie in Abb. (Durch blauen Punkt gekennzeichnet).
FALL 2. Wenn temp. Ist größer als 25 Grad

Wenn die Temperatur 25 Grad erreicht, wird, wie im Code angegeben, das pwm-Signal an die Basis des Mosfets gesendet, und mit jedem Grad Temperaturanstieg steigt auch diese PWM-Spannung an, d.h.

if(y>25)
{analogWrite(10,z*10)
} which is z* 10.

Siehe simulierte Schaltung in diesem Fall.

Wie Sie sehen können, wenn sich die Temperatur von 20 Grad auf 40 Grad erhöht, ändern sich alle drei Werte und bei 40 Grad Celsius

Analogwert = 82
Temperatur = 40
Zugeordneter Wert = 200

Da die Temperatur größer als 25 Grad ist, erhält Mosfet die entsprechende PWM-Spannung, wie in Abb. Gezeigt (angezeigt durch einen roten Punkt).

Daher läuft der Motor bei 25 Grad an und mit dem entsprechenden Anstieg der Temperatur pro Grad steigt auch die pwm-Spannung von Pin 10 zur Basis des Mosfets an. Daher steigt die Motordrehzahl linear mit der Temperaturerhöhung an und wird für 40 Grad Celsius nahezu maximal.

Wenn Sie weitere Fragen zu der oben erläuterten automatischen temperaturgesteuerten Gleichstromlüfterschaltung mit Lüfter und Arduino haben, können Sie jederzeit das Kommentarfeld unten verwenden und Ihre Gedanken an uns senden. Wir werden versuchen, frühestens zurück zu kommen.