Residential Air Flowmeter

Have you ever wanted to measure the speed of air coming out of your vents at home? Well then we have the perfect project for you.

Jun 18, 2019

•

13109 views

•

9 respects

environmental sensing

data collection

monitoring

Components and supplies

Breadboard (generic)

Through Hole Resistor, 220 kohm

Cup Blade Anemometer

Jumper wires (generic)

RGB Backlight LCD - 16x2

Diymall Voltage Sensor Dc0-25v

DROK Signal Amplifier AD620

Rotary Potentiometer, 10 kohm

Arduino UNO

Tools and machines

Soldering iron (generic)

Project description

Code

Voltage Sensor Code

c_cpp

This is the code you use to calibrate the Flowmeter yourself.

1#include <LiquidCrystal.h>
2
3LiquidCrystal lcd(12, 11, 5, 4, 3, 2);                                     // These are the pins that will be used
4
5//   Below are the values of the resistors in the sensor
6float R1=30000;                                                         
7float   R2=7500;
8
9void setup() 
10{
11  
12// This allows the LCD screen to be   used
13Serial.begin (9600);
14lcd.begin(16, 2);                                                       
15
16
17}
18
19void   loop()                                                           
20{
21 
22//   Reads the sensor value  
23int sensorValue = analogRead(A0);                                      
24
25//   Equation for the real voltage
26float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                    
27
28
29// Shows voltage on the LCD screen
30Serial.println(voltage);
31lcd.print("V   = ");
32lcd.setCursor(0, 1);
33lcd.print(voltage);
34delay(1000);
35lcd.clear();
36delay(1000);
37
38
39}

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);                                     // These are the pins that will be used

//   Below are the values of the resistors in the sensor
float R1=30000;                                                         
float   R2=7500;

void setup() 
{
  
// This allows the LCD screen to be   used
Serial.begin (9600);
lcd.begin(16, 2);                                                       


}

void   loop()                                                           
{
 
//   Reads the sensor value  
int sensorValue = analogRead(A0);                                      

//   Equation for the real voltage
float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                    


// Shows voltage on the LCD screen
Serial.println(voltage);
lcd.print("V   = ");
lcd.setCursor(0, 1);
lcd.print(voltage);
delay(1000);
lcd.clear();
delay(1000);


}

Flowmeter Code

c_cpp

11.	#include <LiquidCrystal.h>  
22.	  
33.	LiquidCrystal lcd(12,  11, 5, 4, 3, 2);                                          
44.	// These are the  pins that will be used  
55.	  
66.	 // Below are the values of the resistors  in the sensor 
77.	float R1=30000;                    
88.	  
99.	float  R2=7500;  
1010.	  
1111.	void setup()   
1212.	{  
1313.	    
1414.	Serial.begin  (9600);  
1515.	lcd.begin(16, 2);                                                              
1616.	  // This allows the LCD screen to be used  
1717.	  
1818.	  
1919.	}  
2020.	  
2121.	void loop()                                                                     
2222.	//  Beginning of the loop  
2323.	{  
2424.	    
2525.	int sensorValue = analogRead(A0);                                              
2626.	 // Reads  the sensor value  
2727.	  
2828.	float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                           
2929.	  // Equation for the real voltage   
3030.	  
3131.	  
3232.	//*********************************************************//  
3333.	// The equation for CFM is a piecewise function of voltage,   
3434.	//  so if statements were used to divide the functions into  
3535.	// their respective  regions below  
3636.	//*********************************************************//  
3737.	  
3838.	  
3939.	if (voltage > 1)                                                               
4040.	  // First region of the function for large CFM  
4141.	{  
4242.	    
4343.	float  cfm = (1.1409*(voltage))*((voltage))+44.258*(voltage);      
4444.	  
4545.	Serial.println(cfm);                                                           
4646.	 // Displays  CFM  
4747.	lcd.print("CFM = ");  
4848.	lcd.setCursor(0, 1);  
4949.	lcd.print(cfm);  
5050.	delay(1000);                                                                   
5151.	  // 1000 ms delay  
5252.	lcd.clear();                                                                   
5353.	  // Clears for repeat  
5454.	delay(1000);  
5555.	  
5656.	}  
5757.	  
5858.	else  if (.01 < voltage < 1)                                                    
5959.	  // Second region for middle to low CFM  
6060.	{  
6161.	  
6262.	float cfm  = (40*(voltage)+20);  
6363.	  
6464.	Serial.println(cfm);                                                           
6565.	//  Displays CFM  
6666.	lcd.print("CFM = ");  
6767.	lcd.setCursor(0, 1);  
6868.	lcd.print(cfm);  
6969.	delay(1000);                                                                  
7070.	  // 1000 ms delay  
7171.	lcd.clear();                                                                   
7272.	  // Clears for repeat  
7373.	delay(1000);  
7474.	    
7575.	}  
7676.	  
7777.	else                                                                           
7878.	  // If fan is not spinning, the CFM will be zero  
7979.	{  
8080.	  float cfm  = 0;  
8181.	  
8282.	  Serial.println(cfm);  
8383.	lcd.print("CFM = ");  
8484.	lcd.setCursor(0, 1);  
8585.	lcd.print(cfm);  
8686.	delay(1000);  
8787.	lcd.clear();  
8888.	delay(1000);  
8989.	}  
9090.	  
9191.	  
9292.	}  
93

1.	#include <LiquidCrystal.h>  
2.	  
3.	LiquidCrystal lcd(12,  11, 5, 4, 3, 2);                                          
4.	// These are the  pins that will be used  
5.	  
6.	 // Below are the values of the resistors  in the sensor 
7.	float R1=30000;                    
8.	  
9.	float  R2=7500;  
10.	  
11.	void setup()   
12.	{  
13.	    
14.	Serial.begin  (9600);  
15.	lcd.begin(16, 2);                                                              
16.	  // This allows the LCD screen to be used  
17.	  
18.	  
19.	}  
20.	  
21.	void loop()                                                                     
22.	//  Beginning of the loop  
23.	{  
24.	    
25.	int sensorValue = analogRead(A0);                                              
26.	 // Reads  the sensor value  
27.	  
28.	float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                           
29.	  // Equation for the real voltage   
30.	  
31.	  
32.	//*********************************************************//  
33.	// The equation for CFM is a piecewise function of voltage,   
34.	//  so if statements were used to divide the functions into  
35.	// their respective  regions below  
36.	//*********************************************************//  
37.	  
38.	  
39.	if (voltage > 1)                                                               
40.	  // First region of the function for large CFM  
41.	{  
42.	    
43.	float  cfm = (1.1409*(voltage))*((voltage))+44.258*(voltage);      
44.	  
45.	Serial.println(cfm);                                                           
46.	 // Displays  CFM  
47.	lcd.print("CFM = ");  
48.	lcd.setCursor(0, 1);  
49.	lcd.print(cfm);  
50.	delay(1000);                                                                   
51.	  // 1000 ms delay  
52.	lcd.clear();                                                                   
53.	  // Clears for repeat  
54.	delay(1000);  
55.	  
56.	}  
57.	  
58.	else  if (.01 < voltage < 1)                                                    
59.	  // Second region for middle to low CFM  
60.	{  
61.	  
62.	float cfm  = (40*(voltage)+20);  
63.	  
64.	Serial.println(cfm);                                                           
65.	//  Displays CFM  
66.	lcd.print("CFM = ");  
67.	lcd.setCursor(0, 1);  
68.	lcd.print(cfm);  
69.	delay(1000);                                                                  
70.	  // 1000 ms delay  
71.	lcd.clear();                                                                   
72.	  // Clears for repeat  
73.	delay(1000);  
74.	    
75.	}  
76.	  
77.	else                                                                           
78.	  // If fan is not spinning, the CFM will be zero  
79.	{  
80.	  float cfm  = 0;  
81.	  
82.	  Serial.println(cfm);  
83.	lcd.print("CFM = ");  
84.	lcd.setCursor(0, 1);  
85.	lcd.print(cfm);  
86.	delay(1000);  
87.	lcd.clear();  
88.	delay(1000);  
89.	}  
90.	  
91.	  
92.	}

Voltage Sensor Code

c_cpp

This is the code you use to calibrate the Flowmeter yourself.

1#include <LiquidCrystal.h>
2
3LiquidCrystal lcd(12, 11, 5, 4, 3, 2);                                    // These are the pins that will be used
4
5//  Below are the values of the resistors in the sensor
6float R1=30000;                                                         
7float  R2=7500;
8
9void setup() 
10{
11  
12// This allows the LCD screen to be  used
13Serial.begin (9600);
14lcd.begin(16, 2);                                                       
15
16
17}
18
19void  loop()                                                           
20{
21 
22//  Reads the sensor value  
23int sensorValue = analogRead(A0);                                      
24
25//  Equation for the real voltage
26float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                   
27
28
29// Shows voltage on the LCD screen
30Serial.println(voltage);
31lcd.print("V  = ");
32lcd.setCursor(0, 1);
33lcd.print(voltage);
34delay(1000);
35lcd.clear();
36delay(1000);
37
38
39}

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);                                    // These are the pins that will be used

//  Below are the values of the resistors in the sensor
float R1=30000;                                                         
float  R2=7500;

void setup() 
{
  
// This allows the LCD screen to be  used
Serial.begin (9600);
lcd.begin(16, 2);                                                       


}

void  loop()                                                           
{
 
//  Reads the sensor value  
int sensorValue = analogRead(A0);                                      

//  Equation for the real voltage
float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                   


// Shows voltage on the LCD screen
Serial.println(voltage);
lcd.print("V  = ");
lcd.setCursor(0, 1);
lcd.print(voltage);
delay(1000);
lcd.clear();
delay(1000);


}

Flowmeter Code

c_cpp

11.	#include <LiquidCrystal.h>  
22.	  
33.	LiquidCrystal lcd(12,
4  11, 5, 4, 3, 2);                                          
54.	// These are the
6  pins that will be used  
75.	  
86.	 // Below are the values of the resistors
9  in the sensor 
107.	float R1=30000;                    
118.	  
129.	float
13  R2=7500;  
1410.	  
1511.	void setup()   
1612.	{  
1713.	    
1814.	Serial.begin
19  (9600);  
2015.	lcd.begin(16, 2);                                                              
2116.	
22  // This allows the LCD screen to be used  
2317.	  
2418.	  
2519.	}  
2620.	
27  
2821.	void loop()                                                                     
2922.	//
30  Beginning of the loop  
3123.	{  
3224.	    
3325.	int sensorValue = analogRead(A0);
34                                              
3526.	 // Reads  the sensor value
36  
3727.	  
3828.	float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                           
3929.	
40  // Equation for the real voltage   
4130.	  
4231.	  
4332.	//*********************************************************//
44  
4533.	// The equation for CFM is a piecewise function of voltage,   
4634.	//
47  so if statements were used to divide the functions into  
4835.	// their respective
49  regions below  
5036.	//*********************************************************//
51  
5237.	  
5338.	  
5439.	if (voltage > 1)                                                               
5540.	
56  // First region of the function for large CFM  
5741.	{  
5842.	    
5943.	float
60  cfm = (1.1409*(voltage))*((voltage))+44.258*(voltage);      
6144.	  
6245.	Serial.println(cfm);
63                                                           
6446.	 // Displays
65  CFM  
6647.	lcd.print("CFM = ");  
6748.	lcd.setCursor(0, 1);  
6849.	lcd.print(cfm);
69  
7050.	delay(1000);                                                                   
7151.	
72  // 1000 ms delay  
7352.	lcd.clear();                                                                   
7453.	
75  // Clears for repeat  
7654.	delay(1000);  
7755.	  
7856.	}  
7957.	  
8058.	else
81  if (.01 < voltage < 1)                                                    
8259.	
83  // Second region for middle to low CFM  
8460.	{  
8561.	  
8662.	float cfm
87  = (40*(voltage)+20);  
8863.	  
8964.	Serial.println(cfm);                                                           
9065.	//
91  Displays CFM  
9266.	lcd.print("CFM = ");  
9367.	lcd.setCursor(0, 1);  
9468.	lcd.print(cfm);
95  
9669.	delay(1000);                                                                  
9770.	
98  // 1000 ms delay  
9971.	lcd.clear();                                                                   
10072.	
101  // Clears for repeat  
10273.	delay(1000);  
10374.	    
10475.	}  
10576.	
106  
10777.	else                                                                           
10878.	
109  // If fan is not spinning, the CFM will be zero  
11079.	{  
11180.	  float cfm
112  = 0;  
11381.	  
11482.	  Serial.println(cfm);  
11583.	lcd.print("CFM = ");
116  
11784.	lcd.setCursor(0, 1);  
11885.	lcd.print(cfm);  
11986.	delay(1000);
120  
12187.	lcd.clear();  
12288.	delay(1000);  
12389.	}  
12490.	  
12591.	
126  
12792.	}  
128

1.	#include <LiquidCrystal.h>  
2.	  
3.	LiquidCrystal lcd(12,
  11, 5, 4, 3, 2);                                          
4.	// These are the
  pins that will be used  
5.	  
6.	 // Below are the values of the resistors
  in the sensor 
7.	float R1=30000;                    
8.	  
9.	float
  R2=7500;  
10.	  
11.	void setup()   
12.	{  
13.	    
14.	Serial.begin
  (9600);  
15.	lcd.begin(16, 2);                                                              
16.	
  // This allows the LCD screen to be used  
17.	  
18.	  
19.	}  
20.	
  
21.	void loop()                                                                     
22.	//
  Beginning of the loop  
23.	{  
24.	    
25.	int sensorValue = analogRead(A0);
                                              
26.	 // Reads  the sensor value
  
27.	  
28.	float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                           
29.	
  // Equation for the real voltage   
30.	  
31.	  
32.	//*********************************************************//
  
33.	// The equation for CFM is a piecewise function of voltage,   
34.	//
  so if statements were used to divide the functions into  
35.	// their respective
  regions below  
36.	//*********************************************************//
  
37.	  
38.	  
39.	if (voltage > 1)                                                               
40.	
  // First region of the function for large CFM  
41.	{  
42.	    
43.	float
  cfm = (1.1409*(voltage))*((voltage))+44.258*(voltage);      
44.	  
45.	Serial.println(cfm);
                                                           
46.	 // Displays
  CFM  
47.	lcd.print("CFM = ");  
48.	lcd.setCursor(0, 1);  
49.	lcd.print(cfm);
  
50.	delay(1000);                                                                   
51.	
  // 1000 ms delay  
52.	lcd.clear();                                                                   
53.	
  // Clears for repeat  
54.	delay(1000);  
55.	  
56.	}  
57.	  
58.	else
  if (.01 < voltage < 1)                                                    
59.	
  // Second region for middle to low CFM  
60.	{  
61.	  
62.	float cfm
  = (40*(voltage)+20);  
63.	  
64.	Serial.println(cfm);                                                           
65.	//
  Displays CFM  
66.	lcd.print("CFM = ");  
67.	lcd.setCursor(0, 1);  
68.	lcd.print(cfm);
  
69.	delay(1000);                                                                  
70.	
  // 1000 ms delay  
71.	lcd.clear();                                                                   
72.	
  // Clears for repeat  
73.	delay(1000);  
74.	    
75.	}  
76.	
  
77.	else                                                                           
78.	
  // If fan is not spinning, the CFM will be zero  
79.	{  
80.	  float cfm
  = 0;  
81.	  
82.	  Serial.println(cfm);  
83.	lcd.print("CFM = ");
  
84.	lcd.setCursor(0, 1);  
85.	lcd.print(cfm);  
86.	delay(1000);
  
87.	lcd.clear();  
88.	delay(1000);  
89.	}  
90.	  
91.	
  
92.	}

Code for Voltage Sensor

c_cpp

This is the code to read the voltage if you want to calibrate it yourself

1 // Below are the values of the resistors in the sensor
2float R1=30000;                                                         
3float R2=7500;
4
5void  setup() {
6
7Serial.begin (9600);
8 
9}
10
11void loop() {
12
13// Reads  the sensor value
14int sensorValue = analogRead(A0);                                      
15
16//  Equation for the real voltage
17float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                  
18
19// Prints voltage on computer
20Serial.printIn(voltage);                                              
21delay(1000);
22}

 // Below are the values of the resistors in the sensor
float R1=30000;                                                         
float R2=7500;

void  setup() {

Serial.begin (9600);
 
}

void loop() {

// Reads  the sensor value
int sensorValue = analogRead(A0);                                      

//  Equation for the real voltage
float voltage = ((5*sensorValue*(R1+R2))/(1024*R2));                  

// Prints voltage on computer
Serial.printIn(voltage);                                              
delay(1000);
}

Downloadable files

Wiring Diagram

Documentation

Housing STL File

Fan Blade STL file

Housing STL File

Comments

Only logged in users can leave comments

Ardunicko

0 Followers

•

0 Projects

Intro