Como controlar a velocidade do ventilador com a temperatura usando Arduino Uno
Criando um ventilador controlado por temperatura
Normalmente, para alterar a velocidade do ventilador, há um botão designado para controlar a velocidade do ventilador e pode ser ajustado manualmente. No entanto, podemos tornar a velocidade do ventilador dependente da temperatura de uma área. Portanto, a velocidade do ventilador se ajustará automaticamente à medida que a temperatura dessa área muda. Os componentes que usamos para criar um ventilador controlado por temperatura são:
- Arduino Uno
- Conectando fios
- Pão de pão
- Sensor de temperatura (LM35)
- Fã de DC
- Tela de cristal líquido (LCD)
- Potenciômetro
Portanto, o esquema para o circuito de controlar a velocidade do ventilador em relação à temperatura é dado como:
Conjunto de hardware para criar um ventilador controlado por temperatura usando Arduino Uno
A imagem postada abaixo mostra as conexões de cada componente interfinado com Arduino Uno.
Os fios rosa conectam o LCD com Arduino Uno e o fio cinza conecta o potenciômetro com o LCD para controlar o brilho do LCD.
Além disso, conectamos o sensor de temperatura diretamente nos pinos do Arduino para evitar qualquer distorção na saída do sensor. Para conectar os componentes com a fonte de alimentação, usamos os 5 volts e o solo do Arduino.
Código Arduino para o ventilador controlado por temperatura
O código Arduino compilado para controlar o ventilador com base nos valores de temperatura é dado abaixo:
#include // biblioteca para o LCD
LiquidCrystal LCD (9,8,5,4,3,2); // pinos Arduino para o LCD
int vcc = a0; // suprimento de pino A0 de LM35
int vout = a1; // A1 pino para a saída do LM35
int gnd = a2; // pino A2 para a saída do LM35
int valor; // variável usada para armazenar os valores provenientes do sensor
int fã = 11; // o pino onde o ventilador está conectado no Arduino
int tempmin = 86; // a temperatura para iniciar o ventilador
int tempmax = 127; // a temperatura máxima
int fãspeed; // variável para forte a velocidade do ventilador
int fanlcd; // variável para exibir a porcentagem de velocidade do ventilador no LCD
int tempc; // temperatura em grau Celsius
int tempf; // temperatura em Fahrenheit
Void Setup ()
// atribuindo modos aos pinos Arduino atribuídos
pinmode (ventilador, saída);
pinmode (VCC, saída);
pinmode (VOUT, entrada);
pinmode (gnd, saída);
// atribuindo estados ao VCC e pinos de terra usados para LM35
DigitalWrite (VCC, alto);
DigitalWrite (GND, baixo);
LCD.começar (16,2); // inicializando as dimensões do LCD
Serial.comece (9600); // inicializando a comunicação serial
LCD.setCursor (0, 0); // Definindo o local para os dados no LCD
LCD.print ("fã Arduino"); // dados a serem exibidos
LCD.setCursor (0, 1); // definindo o local para os dados no LCD
LCD.print ("controle de velocidade"); // dados a serem exibidos
atraso (3000); // tempo para o qual os dados serão exibidos
Void Loop ()
LCD.claro (); // limpando o LCD
tempf = temperatura (); /*chamando a função de temperatura para obter o valor da temperatura em Fahrenheit*/
Serial.impressão (tempf); // exibindo a temperatura em Fahrenheit
if (tempf = tempmin) && (tempf <= tempMax)) /* if temperature is higher than minimum temp and less than the maximum temperature then */
fãspeed = tempf; // Dê à velocidade do ventilador o valor do tempf
fanlcd = map (tempf, tempmin, tempmax, 0, 100); /*Escala a velocidade do ventilador para exibi -lo no LCD usando a função de mapa de 0 a 100*/
analogwrite (fã, fãspeed); // atribuindo o valor ao alfinete do ventilador
LCD.print ("Temperatura:"); // exibindo os dados
LCD.impressão (tempf); // exibe a temperatura em Fahrenheit
LCD.print ("f");
LCD.setCursor (0,1); // Definindo o local dos próximos dados a serem exibidos
LCD.print ("Velocidade do ventilador:"); // exibindo os dados
LCD.impressão (fanlcd); // exibe a velocidade do ventilador
LCD.print ("%"); // exibindo os dados
atraso (200); // tempo para o qual os dados serão exibidos no LCD
LCD.claro (); // limpando o LCD
int temperatura () // Nome da função
valor = analogread (vout); // lendo o valor do sensor
tempc = valor*0.48828125; // convertendo os valores do sensor em grau Celsius
retornar tempf = tempc*9/5+32; // convertendo os valores em Fahrenheit
Para projetar um ventilador controlado por temperatura, compilamos o código Arduino de tal maneira que primeiro definimos a biblioteca do LCD e atribuímos pinos Arduino para o LCD. Em seguida, definimos variáveis e os respectivos pinos Arduino para sensor de temperatura e ventilador para interface -lhes com Arduino Uno.
Como estamos tomando a temperatura em Fahrenheit, também definimos os limites mínimos e máximos para a temperatura que é de 86 Fahrenheit a 127 Fahrenheit.
Na função de configuração primeiro, atribuímos modos de pino aos pinos Arduino definidos anteriormente e depois ao VCC e pino de aterramento do sensor de temperatura. Depois disso, as dimensões do LCD são inicializadas e o nome do projeto é exibido no LCD.
Na função de loop primeiro, a função de temperatura é chamada para obter o valor da temperatura e, em seguida, se a condição for usada para verificar se a temperatura é menor que a temperatura mínima. Nesse caso, o ventilador não girará, então há outra condição se usa e operação e verifica se a temperatura estiver entre o intervalo dado da temperatura.
Nós usamos o Função do mapa Para dimensionar a velocidade do ventilador com os valores de temperatura no intervalo de 0 a 100 e, em seguida, esse valor é dado ao alfinete Arduino do ventilador usando analogwrite () função, e faz com que o ventilador gire a uma velocidade respectiva.
Em seguida, os dados para a temperatura e a velocidade do ventilador são exibidos no LCD usando o LCD.imprimir() função. Além disso, para converter os valores do sensor no grau Celsius, usamos a escala de 0.01V Aumento da tensão por grau Centigrado.
Portanto, se a tensão for de 1 volt, a temperatura será de 100 graus, então aqui para o sensor, temos no máximo 5 volts para que a temperatura seja de 500 em 5 volts. No entanto, o valor analógico máximo para o sensor é 1023, o que significa 5 volts e, para isso, dividimos a temperatura máxima pelo valor analógico máximo. Também convertemos a temperatura em Fahrenheit e o conceito de conversão pode ainda estar claro a tabela abaixo:
Mudança por grau Celsius = (temperatura máxima/valor analógico máximo);
0.488 = (500/1023);
Temperatura em graus = valor analógico*0.488;
Temperatura em Fahrenheit = temperatura em graus*9/5+32;
Simulação
Aqui neste projeto, criamos uma simulação em software Porteous. Na simulação publicada abaixo, vemos que estamos aumentando a temperatura manualmente. Portanto, a velocidade do ventilador continua aumentando à medida que aumentamos a temperatura:
Conclusão
As placas Arduino podem ser usadas para fazer uma variedade de projetos de si mesmos e isso dá aos iniciantes uma melhor compreensão do trabalho dos circuitos. Da mesma forma, para entender o funcionamento dos dispositivos, também podemos criar seus circuitos de uma maneira muito fácil. Neste guia, criamos um ventilador automático que depende dos valores do sensor de temperatura. Os ventiladores controlados por temperatura são usados principalmente nos dispositivos que precisam de resfriamento adequado em altas temperaturas e o exemplo mais comum são os PCs ou laptops para desktop.