Hvordan kontrollere viftehastigheten med temperatur ved bruk av Arduino Uno

Arduino -tavlene har gitt brukerne en plattform som kan brukes til å utføre en rekke oppgaver ved å koble seg sammen et antall inngangsutdataenheter. Tilsvarende gir Arduino også en læringsplattform for nybegynnere å lære og forstå arbeidet med forskjellige kretsløp. Ved hjelp av Arduino -brett kan vi lage kretsløp av forskjellige enheter som ofte brukes i vårt daglige liv. Så vi har opprettet en temperaturkontrollert vifte ved hjelp av Arduino UNO-brettet.

Opprette en temperaturkontrollert vifte

Normalt for å endre viftehastigheten er det en utpekt knott for å kontrollere viftenes hastighet, og den kan justeres manuelt. Vi kan imidlertid gjøre hastigheten på viften avhengig av temperaturen i et område. Så hastigheten på viften vil automatisk justere seg selv når temperaturen på området endres. Komponentene vi har brukt til å lage en temperaturkontrollert vifte er:

• Arduino Uno
• Koble til ledninger
• Brødbrett
• Temperatursensor (LM35)
• DC -fan
• Liquid Crystal Display (LCD)
• Potensiometer

Så skjematisk for kretsen for å kontrollere viftehastigheten med hensyn til temperaturen er gitt som:

Maskinvareenhet for å lage en temperaturkontrollert vifte med Arduino Uno

Bildet som er lagt ut nedenfor viser tilkoblingene til hver komponent som er koblet til Arduino Uno.

De rosa ledningene kobler LCD med Arduino UNO og den grå ledningen kobler potensiometer med LCD for å kontrollere LCD -lysets lysstyrke.

Videre har vi koblet til temperatursensoren direkte på pinnene i Arduino for å unngå forvrengning i utgangen av sensoren. For å koble komponentene med strømforsyningen har vi brukt de 5 volt og bakken til Arduino.

Arduino-kode for den temperaturkontrollerte viften

Arduino -koden samlet for kontrollerende vifte basert på temperaturverdier er gitt nedenfor:

#include // bibliotek for LCD
LiquidCrystal LCD (9,8,5,4,3,2); // Arduino -pinner for LCD
int vcc = A0; // A0 PIN -levering av LM35
int vout = a1; // A1 -pinnen for utgangen fra LM35
int GND = A2; // A2 -pinnen for utgangen fra LM35
int verdi; // variabel brukt til lagring av verdiene som kommer fra sensoren
int fan = 11; // PIN -koden der viften er koblet på Arduino
int tempmin = 86; // Temperaturen for å starte viften
int tempmax = 127; // maksimal temperatur
int fanspeed; // variabel for sterk viftehastighet
int fanlcd; // variabel for å vise prosentviftehastigheten på LCD
int tempc; // temperatur i grad Celsius
int tempf; // temperatur i Fahrenheit
void setup ()
// Tilordne modus til de tildelte Arduino -pinnene
pinmode (vifte, utgang);
PinMode (VCC, utgang);
pinmode (vout, input);
pinmode (GND, utgang);
// tildeler stater til VCC og bakkestiftene som brukes til LM35
DigitalWrite (VCC, høy);
DigitalWrite (GND, lav);
LCD.Begynn (16,2); // Initialisere dimensjonene til LCD
Serie.Begynn (9600); // Initialisere seriell kommunikasjon
LCD.setcursor (0, 0); // Angi stedet for dataene på LCD
LCD.print ("arduino fan"); // data som skal vises
LCD.setcursor (0, 1); // Angi stedet for dataene på LCD
LCD.print ("speed control"); // data som skal vises
forsinkelse (3000); // tid som dataene skal vises

ugyldig sløyfe ()

LCD.Clear (); // tømme LCD
tempf = temperatur (); /*Ringer temperaturfunksjonen for å få verdien av temperaturen i Fahrenheit*/
Serie.Print (tempf); // Vis temperaturen i Fahrenheit
if (tempf = tempmin) && (tempf <= tempMax)) /* if temperature is higher than minimum temp and less than the maximum temperature then */

FANSPEED = tempf; // gi viftehastigheten verdien av tempf
fanLCD = kart (tempf, tempmin, tempmax, 0, 100); /*Skalere viftehastigheten for å vise den på LCD ved hjelp av kartfunksjon fra 0 til 100*/
analogwrite (fan, fanshasteed); // tilordne verdien til viftenes pinne

LCD.print ("temperatur:"); // vise dataene
LCD.print (tempf); // Vis temperaturen i Fahrenheit
LCD.print ("f");
LCD.setcursor (0,1); // Definere stedet for de neste dataene som skal vises
LCD.print ("viftehastighet:"); // Vis dataene
LCD.print (fanlcd); // Vis viftehastigheten
LCD.print ("%"); // vise dataene
forsinkelse (200); // tid som dataene skal vises på LCD
LCD.Clear (); // tømme LCD

int temperatur () // funksjonsnavn
Verdi = Analogread (vout); // Lese verdien av sensor
tempc = verdi*0.48828125; // Konvertere verdiene til sensor til grad Celsius
retur tempf = tempc*9/5+32; // Konvertere verdiene i Fahrenheit

For å designe en temperaturkontrollert vifte, har vi samlet Arduino-koden på en slik måte at vi først har definert biblioteket med LCD og tildelt Arduino-pinner for LCD. Deretter har vi definert variabler og de respektive Arduino -pinnene for temperatursensor og vifte for å grensesnitt dem med Arduino Uno.

Siden vi tar temperaturen i Fahrenheit, har vi også definert minimums- og maksimumsgrensene for temperaturen som er fra 86 Fahrenheit til 127 Fahrenheit.

I oppsettfunksjonen først har vi tildelt PIN -modus til Arduino -pinnene som er definert tidligere og deretter til VCC og bakkestift for temperatursensoren. Etter det blir dimensjonene til LCD -er initialisert og prosjektnavnet vises på LCD.

I sløyfefunksjonen først kalles temperaturfunksjonen for å få verdien av temperaturen, og hvis tilstanden brukes til å sjekke om temperaturen er mindre enn minimumstemperatur. I dette tilfellet vil viften ikke snu, er det en annen hvis tilstand som bruker og drift og sjekker om temperaturen er mellom det gitte området for temperaturen.

Vi har brukt Kartfunksjon For å skalere hastigheten på viften med temperaturverdiene i området fra 0 til 100, og deretter blir den verdien gitt til Arduino -pinnen til viften ved hjelp av viften AnalogWrite () funksjon, og det får viften til å rotere i respektiv hastighet.

Deretter vises dataene for temperaturen og viftehastigheten på LCD -en ved hjelp av LCD.skrive ut() funksjon. For å konvertere sensorenes verdier til den grad Celsius har vi brukt skalaen på 0.01V økning i spenningen per grads centigrade.

Så hvis spenningen er 1 volt, vil temperaturen være 100 grader, så her for sensoren, har vi maksimalt 5 volt slik at temperaturen vil være 500 på 5 volt. Imidlertid er den maksimale analoge verdien for sensoren 1023 som betyr 5 volt, og for det har vi delt maksimal temperatur med maksimal analog verdi. Vi har også konvertert temperaturen i Fahrenheit, og konseptet for konvertering kan videre være tydelig fra tabellen nedenfor:

Endring per grad Celsius = (maksimal temperatur/maksimal analog verdi);
0.488 = (500/1023);
Temperatur i grader = analog verdi*0.488;
Temperatur i Fahrenheit = temperatur i grader*9/5+32;

Simulering

Her i dette prosjektet har vi laget en simulering i porteous programvare. I simuleringen som er lagt ut nedenfor ser vi at vi øker temperaturen manuelt. Så viftehastigheten fortsetter å øke når vi øker temperaturen:

Konklusjon

Arduino-styrene kan brukes til å lage en rekke gjør-det-selv-prosjekter, og det gir nybegynnere en bedre forståelse av kretsløpene som fungerer. Tilsvarende, for å forstå arbeidet med enhetene, kan vi også lage kretsløp på en veldig enkel måte. I denne guiden har vi laget en automatisk fan som avhenger av verdiene til temperatursensoren. Temperaturkontrollerte vifter brukes stort sett på enhetene som trenger tilstrekkelig avkjøling ved høye temperaturer, og det vanligste eksemplet er stasjonære PC-er eller bærbare datamaskiner.