Medidor de Vazão de Ar Residencial com Arduino: Construção e Monitoramento

Componentes e materiais

	Arduino UNO	×	1
	Jumpers (genéricos) 25 fios no total	×	25
	Protoboard (genérico)	×	1
	Potenciômetro Rotativo, 10 kΩ	×	1
	Adafruit RGB Backlight LCD 16x2	×	1
	Resistor Passante, 220 kΩ	×	1
	Sensor de Tensão Diymall DC 0-25V	×	1
	Amplificador de Sinal DROK AD620	×	1
	Anemômetro de Copo (Cup Blade)	×	1

Ferramentas necessárias

Ferro de solda (genérico)

Sobre este projeto

Contexto

Fomos encarregados de criar um medidor de vazão de ar que pudesse ser usado em ambiente residencial. Infelizmente, na indústria HVAC atual, os únicos dispositivos de detecção de fluxo de ar no mercado são para sistemas projetados para aplicações industriais. Os dispositivos atualmente usados para calcular a taxa de fluxo de ar em registros de tamanho industrial são ou grandes demais para registros residenciais ou não conseguem calcular a taxa de fluxo devido às menores vazões de um sistema HVAC residencial.

Como funciona

Para gerar um sinal a partir do fluxo de ar, usamos um anemômetro de copo para capturar o ar. Fizemos pás personalizadas impressas em 3D usando Autodesk Inventor para otimizar o desempenho das pás do ventilador na captura do ar. Também imprimimos em 3D um gabinete para colocar o anemômetro.

Para ler o sinal que o anemômetro emitia, escolheu-se um sensor de tensão. O sinal do sensor também precisava ser amplificado para ter uma leitura mais precisa no sensor de tensão. O amplificador pega a tensão de saída do anemômetro e a amplifica por um fator de 10. Esse fator pode ser aumentado ou diminuído entre 1.5 e 1000 vezes baseado na tensão de entrada.

Um Arduino Uno foi usado para ler o sinal analógico do sensor de tensão e controlar o que era apresentado na tela LCD. Para este problema específico, queríamos a velocidade do vento em CFM (pés cúbicos por minuto), então exibimos assim na tela.

A Construção

Eletrônica

O primeiro passo na construção é começar com o anemômetro. Abaixo algumas fotos do dispositivo.

Olhe a imagem "Visão Superior do Anemômetro". O ponto onde as pás se conectam ao anemômetro é em formato de L e muito fino. Isso não aguentará bem altas velocidades, então aqui projetamos novas pás. Queríamos pás mais grossas e um design de fixação mais robusto. O propósito das pás maiores era reduzir a folga de ar transversal entre a pá e a unidade de habitação (onde o ventilador ficará), o que aumentaria a quantidade de ar capturada pela pá e a tensão produzida pelo motor. Abaixo fotos de onde as pás se conectam ao anemômetro.

Você pode pensar: isso fará muita diferença? Ótima pergunta. Para responder, realizamos testes de análise de tensão no Autodesk Inventor para ver o quão mais robusto o novo design é. A imagem abaixo mostra os resultados.

Podemos ver que as novas pás são muito mais eficazes em altas velocidades. Os arquivos STL para as pás estão anexados na seção de arquivos. NÃO ANEXE AS NOVAS PÁS AINDA.

Em seguida, precisamos colocar o anemômetro modificado na unidade de habitação. Os arquivos STL para a unidade de habitação estão na seção de arquivos. Sem pás no anemômetro, deslize-o pelo furo na parte inferior da habitação. Cole a base do anemômetro a dois círculos de madeira fina (da Hobby Lobby). Fure 4 pequenos furos através dos círculos e do gabinete de plástico ABS. Um furo será para passar o fio, os outros três para parafusos. A imagem abaixo mostra como ficará.

Em seguida, precisamos ligar o anemômetro ao amplificador. Abaixo uma imagem do amplificador.

*Nota: todos os fios conectados ao amplificador são macho-macho

Pegue dois fios macho-macho, as cores não importam, mas chamarei pelas cores que usamos. Solde um fio vermelho no círculo +S à direita. Solde a outra ponta ao fio vermelho vindo do anemômetro. Solde um fio preto no círculo -S à direita. Solde a outra ponta ao fio amarelo vindo do anemômetro. Fita isolante também funciona bem para mantê-los no lugar.

Agora precisamos ligar o amplificador a uma fonte de bateria. Solde um fio amarelo no GND do lado direito. Solde a outra ponta ao fio preto vindo de um conector de pacote de bateria. Solde um fio branco no círculo Vln do lado direito. Solde a outra ponta ao fio vermelho vindo de um conector de pacote de bateria.

Em seguida, ligue o amplificador ao sensor de tensão. Solde um fio azul no GND do amplificador, a outra ponta no VCC do sensor de tensão. Solde um fio verde no Vout do amplificador, a outra ponta no GND do sensor de tensão.

Agora ligaremos o sensor de tensão ao Arduino e finalizaremos a fiação. O diagrama de fiação na seção de esquemáticos mostra como ligar esta parte.

Toques Finais

As partes mais difíceis estão feitas! Agora que tudo está ligado, podemos colocar a eletrônica no medidor de vazão. Use uma placa de espuma como teto para o topo da habitação do ventilador. Usamos cola gorila para mantê-la no lugar. Você pode então colocar a eletrônica na placa de espuma e usar mais espuma para fechar a eletrônica. Nas imagens abaixo, você vê como a espuma foi usada para fechar a eletrônica.

Também foram feitos furos na espuma para permitir acesso do Arduino e do amplificador às suas respectivas fontes de alimentação de bateria 9V. Isso pode ser visto na imagem abaixo.

Em seguida, construiremos o funil. Usamos material PVC para as placas do funil. Eram 4 placas em formato de trapézio. Para conectar as placas entre si, usamos cola gorila e calafetagem. O mesmo método foi usado para conectar o funil à habitação do ventilador. Na extremidade grande do funil, colocou-se vedação de clima ao redor do perímetro. Isso foi feito para criar uma vedação quando o funil é pressionado contra uma ventilação. A seção transversal da extremidade grande do funil é 14" x 14". A imagem abaixo mostra uma vista frontal do funil.

Calibração

Uma vez tudo construído, calibramos nosso medidor de vazão. Testamos com um dispositivo que conhecia o fluxo de ar exato. Nosso primeiro código exibiu a tensão lida pelo sensor na tela LCD. Usamos esses dados coletados para criar equações para fazer a tela LCD exibir CFM. Os dados abaixo mostram como calibramos.

No gráfico, você vê duas curvas: o fluxo de ar inicial e o fluxo de ar real. São diferentes porque ao funilar o ar, a velocidade diminui ligeiramente. Aqui usaremos a equação de melhor ajuste para o fluxo de ar real:

y = 1.1409x² + 44.958x no nosso código Arduino. O código será dividido em três partes: áreas com velocidade do vento zero, velocidades pequenas a médias, e grandes velocidades. Você poderia usar a equação acima para modelar toda a faixa de velocidade do vento, mas encontramos uma equação melhor para modelar a faixa pequena a média. As faixas serão representadas pelas seguintes equações:

• CFM Grande: y = 1.1409x² + 44.958x
• CFM Médio a Baixo: y = 40x + 20
• CFM Zero: y = 0

Você encontra o código na seção posterior.

Uma vez carregado o código no Arduino, o medidor de vazão está pronto!

Calibre Você Mesmo (Opcional)

Digamos que você queira calibrar sozinho. Talvez queira medir o fluxo de ar em m/s ou mph. Aqui explicamos os passos para calibrar.

1. Encontre uma forma de saber a taxa de fluxo real primeiro. A forma mais barata é comprar um anemômetro de loja. Aqui está um que funcionaria.
2. Coloque o anemômetro na frente de um ventilador com diferentes configurações de velocidade. O ventilador pode ser como o mostrado na imagem abaixo.



3. Registre a velocidade do vento do anemômetro em cada configuração diferente.
4. Faça o medidor ler a tensão de saída do ventilador. Carregue o código "Código do Sensor de Tensão" no Arduino.
5. Agora que o medidor lê tensão, registre a tensão em cada configuração de velocidade do ventilador.
6. Use Excel para criar um gráfico de dispersão "Velocidade do Vento vs. Tensão".
7. Use o recurso de linha de tendência para encontrar uma equação que modele com precisão "Velocidade do Vento vs. Tensão".
8. Se achar que sua linha de tendência não é muito linear, pode encontrar equações separadas para as porções inferior e superior do gráfico.
9. Agora substitua suas equações pelas minhas no "Código do Medidor de Vazão". Carregue o código no Arduino e pronto!

Código

Código do Medidor de Vazão (Flowmeter Code)

1. #include <LiquidCrystal.h>
2.
3. LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
4. // Pinos que serão usados
5.
6. // Valores dos resistores no sensor
7. float R1=30000;
8. float R2=7500;
9.
10. void setup()
11. {
12.   Serial.begin (9600);
13.   lcd.begin(16, 2);
14.   // Permite uso da tela LCD
15.
16. }
17.
18. void loop()
19. // Início do loop
20. {
21.   int sensorValue = analogRead(A0);
22.   // Lê valor do sensor
23.
24.   float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));
25.   // Equação para tensão real
26.
27.   //*********************************************************//
28.   // A equação para CFM é uma função por partes da tensão,
29.   // então if statements foram usados para dividir as funções
30.   // em suas respectivas regiões abaixo
31.   //*********************************************************//
32.
33.   if (voltage > 1)
34.   // Primeira região da função para CFM grande
35.   {
36.     float cfm = (1.1409*(voltage))*((voltage))+44.258*(voltage);
37.     Serial.println(cfm);
38.     // Exibe CFM
39.     lcd.print("CFM = ");
40.     lcd.setCursor(0, 1);
41.     lcd.print(cfm);
42.     delay(1000);
43.     // delay 1000 ms
44.     lcd.clear();
45.     // Limpa para repetição
46.     delay(1000);
47.   }
48.
49.   else if (.01 < voltage && voltage < 1)
50.   // Segunda região para CFM médio a baixo
51.   {
52.     float cfm = (40*(voltage)+20);
53.     Serial.println(cfm);
54.     lcd.print("CFM = ");
55.     lcd.setCursor(0, 1);
56.     lcd.print(cfm);
57.     delay(1000);
58.     lcd.clear();
59.     delay(1000);
60.   }
61.
62.   else
63.   // Se ventilador não gira, CFM será zero
64.   {
65.     float cfm = 0;
66.     Serial.println(cfm);
67.     lcd.print("CFM = ");
68.     lcd.setCursor(0, 1);
69.     lcd.print(cfm);
70.     delay(1000);
71.     lcd.clear();
72.     delay(1000);
73.   }
74.
75. }

Código para Sensor de Tensão (Code for Voltage Sensor)

Este é o código para ler a tensão se você quiser calibrar sozinho.

// Valores dos resistores no sensor
float R1=30000;
float R2=7500;

void setup() {
  Serial.begin (9600);
}

void loop() {
  // Lê valor do sensor
  int sensorValue = analogRead(A0);
  // Equação para tensão real
  float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));
  // Imprime tensão no computador
  Serial.println(voltage);
  delay(1000);
}

Código do Sensor de Tensão para LCD (Voltage Sensor Code)

Este é o código que você usa para calibrar o Medidor de Vazão você mesmo.

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// Pinos que serão usados
// Valores dos resistores no sensor
float R1=30000;
float R2=7500;

void setup() {
  // Permite uso da tela LCD
  Serial.begin (9600);
  lcd.begin(16, 2);
}

void loop() {
  // Lê valor do sensor
  int sensorValue = analogRead(A0);
  // Equação para tensão real
  float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));
  // Mostra tensão na tela LCD
  Serial.println(voltage);
  lcd.print("V = ");
  lcd.setCursor(0, 1);
  lcd.print(voltage);
  delay(1000);
  lcd.clear();
  delay(1000);
}

Esquemáticos