Circuiti per ventole CC a temperatura controllata Arduino

In questo articolo costruiremo un paio di semplici circuiti di ventole cc a temperatura controllata automatici basati su Arduino che accenderanno una ventola o qualsiasi altro gadget ad essa collegato, quando la temperatura ambiente raggiunge un livello di soglia predeterminato. Utilizzeremo il sensore DHT11 e arduino per questo progetto.

Panoramica

La bellezza dei microcontrollori è che otteniamo un controllo molto preciso sulle periferiche ad esso collegate. In questo progetto l'utente deve solo inserire la temperatura di soglia nel programma, il microcontrollore si occuperà del resto della funzione.

Ci sono tonnellate di progetti di termoregolatori automatici non basati su microcontrollori disponibili su Internet, come l'utilizzo di comparatori e transistor.

Sono molto semplici e funzionano bene, ma il problema sorge durante la calibrazione del livello di soglia utilizzando un resistore o un potenziometro preimpostato.

Abbiamo un'idea cieca durante la calibrazione e l'utente potrebbe dover eseguire un metodo di prova ed errore per trovare il punto debole.

Questi problemi sono superati dai microcontrollori, l'utente deve solo inserire la temperatura in Celsius in questo progetto, quindi non c'è bisogno di calibrazione.

Questo progetto può essere utilizzato laddove è necessario stabilizzare la temperatura interna del circuito o salvarlo dal surriscaldamento.

Nel diagramma 1, stiamo collegando una ventola della CPU come uscita. Questa configurazione può essere utilizzata per controllare la temperatura ambiente interna di un circuito chiuso.

Quando viene raggiunta la temperatura di soglia il ventilatore si accende. Quando la temperatura scende al di sotto della soglia di temperatura, il ventilatore si spegne. Quindi è fondamentalmente un processo automatizzato.

Nello schema 2, abbiamo collegato un relè per il controllo di dispositivi che funziona a tensione di rete come ventilatore da tavolo.

Quando la temperatura ambiente raggiunge la temperatura di soglia, il ventilatore si accende e si spegne quando l'ambiente si raffredda.

Questo potrebbe essere il modo migliore per risparmiare energia e questo può essere il paradiso per i pigri che desiderano che gli altri accendano la ventola quando si sentono caldi.

Schema del circuito che mostra un controllo della ventola CC

Questa configurazione può essere utilizzata per circuiti racchiusi in una scatola. Il LED si accende quando viene raggiunto il livello di soglia preimpostato e accende anche la ventola.

Collegamento di un relè per il controllo di fan più grandi

Questo circuito svolge la funzione simile del circuito precedente, ora la ventola è sostituita dal relè.

Questo circuito può controllare un ventilatore da tavolo o da soffitto o qualsiasi altro gadget in grado di raffreddare la temperatura ambiente.

Il dispositivo collegato si spegne non appena la temperatura raggiunge il livello di soglia preimpostato.

Lo schema del circuito del ventilatore cc a temperatura controllata illustrato qui è solo alcune delle molte possibilità. Puoi personalizzare il circuito e il programma per i tuoi scopi.

NOTA 1: #Pin 7 viene emesso.

NOTA 2: questo programma è compatibile solo con il sensore DHT11.

Programma per il circuito di regolazione automatica della temperatura sopra spiegato utilizzando Arduino:

Codice programma

//--------------------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---------------------//

Nota: nel programma

int th = 30 // imposta la temperatura di soglia in Celsius.

Sostituisci '30' con il valore desiderato.

Secondo design

Il secondo progetto di circuito del ventilatore cc a temperatura controllata discusso di seguito rileva automaticamente la temperatura ambiente e regola la velocità del motore del ventilatore per mantenere sotto controllo la temperatura circostante. Questa elaborazione automatica viene eseguita tramite un Arduino e un sensore di temperatura IC LM35.

Di:Ankit Negi

IL NOSTRO OBIETTIVO:

1). Non appena la temperatura dell'ambiente circostante aumenta oltre i 25 gradi Celsius (è possibile modificare questo valore nel programma in base alle proprie necessità, spiegato nella sezione di lavoro) il motore si avvia.

2). E con ogni grado di aumento della temperatura, aumenta anche la velocità del motore.

3). Il motore funziona alla sua velocità massima non appena la temperatura sale a 40 gradi Celsius (questo valore può essere modificato nel programma).

SENSORE DI TEMPERATURA LM35:

Per ottenere il compito sopra menzionato, useremo temp. Sensore LM35 in quanto ampiamente utilizzato e facilmente reperibile.

LM35 ha 3 pin come puoi vedere in figura.

1. Vin - questo pin è collegato all'alimentazione cc tra 4 e 20 v.
2. Vout: questo pin fornisce un'uscita sotto forma di tensione.
3. GND - questo pin è collegato al terminale gnd del circuito.

LM35, quando è collegato all'alimentazione, rileva il temperatura dell'ambiente circostante e invia una tensione equivalente in base all'aumento di temperatura per grado attraverso il suo pin di uscita.

LM35 può rilevare qualsiasi temperatura. tra -50 gradi e +150 gradi Celsius e aumenta l'uscita di 10 millivolt con un aumento della temperatura di 1 grado. Pertanto la tensione massima che può fornire in uscita è di 1,5 volt.

PERCHÉ ARDUINO PER QUESTO PROGETTO DI FAN CONTROLLER DC?

Arduino è necessario per modificare il valore analogico ricevuto dal pin di uscita di LM35 in valore digitale e invia la corrispondente uscita digitale (PWM) alla base del mosfet.

Useremo anche comandi arduino per stampare la temperatura, corrispondente valore analogico e uscita digitale a mosfet su monitor seriale di ARDUINO IDE.

QUAL È IL RUOLO DEL MOSFET DI POTENZA?

Questo circuito non sarà di alcuna utilità se non può far funzionare il motore ad alta corrente. Quindi per far funzionare tali motori viene utilizzato il mosfet di potenza.

PERCHÉ VIENE UTILIZZATO DIODE?

Il diodo è utilizzato per proteggere il mosfet dall'E.M.F posteriore generato dal motore durante il funzionamento.

ELENCO DELLE PARTI PER IL PROGETTO:

1. LM35

2. ARDUINO

3. MOSFET DI POTENZA (IRF1010E)

4. DIODO (1N4007)

5. FAN (motore)

6. ALIMENTAZIONE VENTOLA

SCHEMA ELETTRICO:

Effettuare i collegamenti come mostrato nello schema del circuito.

a) Collegare il pin vin di lm358 a 5v di arduino
b) Collega il pin vout di lm358 ad A0 di arduino
c) Collegare il pin di terra di lm358 a GND di arduino
d) Collega la base del mosfet al pin 10 PWM di arduino

CODICE:

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
}
}

FUNZIONANTE (codice di comprensione):

UN). VARIABILE X-

Questo è semplicemente il valore analogico ricevuto dal pin n. A0 dal pin di uscita dell'LM35.

B). VARIABILE E

Solo a causa di questa variabile, il nostro motore del ventilatore funziona in base alla temperatura corrispondente. Ciò che fa questa variabile è che cambia il valore analogico, cioè la variabile x, alla corrispondente temperatura dell'ambiente circostante.

Y = (500 * x) / 1023
1. Il primo valore analogico deve essere modificato nella tensione corrispondente, ad es.
1023: 5v
Quindi, (5000 millivolt * x) / 1023 V
2. Ora sappiamo che per ogni aumento di grado della temperatura la tensione di uscita corrispondente aumenta di 10 mv, ovvero
1 grado Celsius: 10 millivolt
Quindi, (5000 millivolt * x) / (1023 * 10) GRADI

C). Z VARIABILE

z = mappa (x, 0, 1023, 0,255)
questa variabile cambia il valore analogico in valore digitale per l'uscita PWM sul pin 10.

NOTA :: Sappiamo che lm35 può fornire un massimo di 1.5 volt e che anche quando temp. È di 150 gradi. che non è pratico.

Ciò significa che per 40 gradi Celsius otteniamo 0,40 volt e per 25 gradi otteniamo 0,25 volt. Poiché questi valori sono molto bassi per una corretta pwm su mosfet, dobbiamo moltiplicarli per un fattore.

Quindi lo moltiplichiamo per 10 e invece diamo questo valore come uscita analogica al pin PWM 10, ad es.

** analogWrite (10, z * 10)

Ora, per 0,25 volt il mosfet ottiene 0,25 * 10 = 2,5 volt

Per .40 volt il mosfet ottiene 0,40 * 10 = 4 volt a cui il motore funziona quasi alla massima velocità

CASO 1. Quando temp. È inferiore a 25 gradi

In questo caso arduino invia 0 tensione PWM al pin 10 come nell'ultima riga di codice

** altro
{analogWrite (10,0) // in ogni altro caso PWM sul pin 10 deve essere 0
} **

Poiché la tensione pwm sulla base del mosfet è 0, rimane spento e il motore viene scollegato dal circuito.

Vedi circuito simulato in questo caso.

Come puoi vedere la temperatura è di 20 gradi da qui

Valore analogico = 41
Temperatura = 20
Valore mappato = 100

Ma poiché la temperatura è inferiore a 25 gradi, il mosfet ottiene 0 volt come mostrato in fig (indicato dal punto blu).
CASO 2. Quando temp. È maggiore di 25 gradi

Quando la temperatura raggiunge i 25 gradi, come specificato nel codice il segnale pwm viene inviato alla base del mosfet e con ogni aumento della temperatura di grado anche questa tensione PWM aumenta, ad es

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

Vedi circuito simulato in questo caso.

Come puoi vedere quando la temperatura aumenta da 20 gradi fino a 40 gradi, tutti e tre i valori cambiano a 40 gradi Celsius

Valore analogico = 82
Temperatura = 40
Valore mappato = 200

Poiché la temperatura è maggiore di 25 gradi, il mosfet ottiene la tensione PWM corrispondente come mostrato in fig (indicato dal punto rosso).

Quindi il motore inizia a funzionare a 25 gradi e con il corrispondente aumento della temperatura per grado aumenta anche la tensione pwm dal pin 10 alla base del mosfet. Quindi la velocità del motore aumenta linearmente con l'aumento della temperatura e diventa quasi massima per 40 gradi Celsius.

Se hai ulteriori domande sul circuito della ventola cc a temperatura controllata sopra spiegato utilizzando la ventola e Arduino, puoi sempre utilizzare la casella dei commenti qui sotto e inviarci i tuoi pensieri. Cercheremo di tornare al più presto.