Arduino-gestütztes Wohnraum-Luftdurchflussmessgerät: Bau & Überwachung

Komponenten und Zubehör

	Arduino UNO	×	1
	Jumper Wires (universell) Insgesamt 25 Kabel	×	25
	Breadboard (universell)	×	1
	Drehpotentiometer, 10 kOhm	×	1
	Adafruit RGB Backlight LCD - 16x2	×	1
	Durchgangswiderstand, 220 kOhm	×	1
	Diymall Spannungssensor DC 0-25V	×	1
	DROK Signalverstärker AD620	×	1
	Schaufelrad-Anemometer (Cup Blade Anemometer)	×	1

Benötigte Werkzeuge und Maschinen

Lötkolben (universell)

Über dieses Projekt

Hintergrund

Wir wurden beauftragt, ein Luftdurchflussmessgerät zu entwickeln, das im Wohnbereich eingesetzt werden kann. Leider sind in der heutigen HLK-Industrie die einzigen verfügbaren Luftstromsensoren für Systeme ausgelegt, die für industrielle Anwendungen konzipiert sind. Die derzeit zur Berechnung der Luftstromrate in industriellen Registern verwendeten Geräte sind entweder zu groß für Wohnraumregister oder können die Luftstromrate aufgrund der geringeren Luftauslässe eines Wohnraum-HLK-Systems nicht berechnen.

Funktionsweise

Zur Signalgenerierung aus dem Luftstrom verwendeten wir ein Schaufelrad-Anemometer, um die Luft einzufangen. Wir erstellten benutzerdefinierte 3D-gedruckte Schaufeln mit Autodesk Inventor, um die Leistung der Lüfterschaufeln beim Einfangen der Luft zu optimieren. Zudem 3D-druckten wir ein Gehäuse, in dem das Anemometer platziert wird.

Zum Auslesen des Signals, das das Anemometer ausgab, wurde ein Spannungssensor gewählt. Das Signal des Sensors musste zudem verstärkt werden, um eine genauere Messung am Spannungssensor zu erhalten. Der Verstärker nimmt die Ausgangsspannung des Anemometers und verstärkt sie um den Faktor 10. Dieser Faktor kann je nach Eingangsspannung zwischen 1,5- und 1000-fach erhöht oder verringert werden.

Ein Arduino Uno wurde verwendet, um das analoge Signal vom Spannungssensor auszulesen und zu steuern, was auf dem LCD-Bildschirm angezeigt wird. Für dieses spezifische Problem wollten wir die Windgeschwindigkeit in CFM (Kubikfuß pro Minute) anzeigen, daher wird dies auf dem Bildschirm so dargestellt.

Der Bau

Elektronik

Der erste Konstruktionsschritt ist der Start mit dem Anemometer. Unten sehen Sie einige Fotos des Geräts.

Betrachten Sie das Bild „Anemometer Top View“. Die Stelle, an der die Schaufeln mit dem Anemometer verbunden sind, ist L-förmig und sehr dünn. Das hält hohen Geschwindigkeiten nicht gut stand – hier haben wir neue Schaufeln entworfen. Wir wollten dickere Schaufeln und ein stabileres Griff-Design. Der Zweck der größeren Schaufeln war, den quergerichteten Luftspalt zwischen Schaufel und Gehäuseeinheit (wo der Lüfter sitzt) zu verringern, was wiederum die Menge der vom Schöpfer eingefangenen Luft und die vom Motor erzeugte Spannung erhöht. Unten sehen Sie Fotos der Befestigungsstelle der Schaufeln am Anemometer.

Sie fragen sich vielleicht: Macht das wirklich einen Unterschied? Gute Frage. Um das zu beantworten, führten wir Spannungsanalysen in Autodesk Inventor durch, um zu sehen, wie viel stabiler das neue Design ist. Das Bild unten zeigt die Ergebnisse.

Man sieht, dass die neuen Schaufeln bei hohen Geschwindigkeiten deutlich effektiver sind. Die STL-Dateien für die Schaufeln finden Sie im Dateibereich. NOCH NICHT DIE NEUEN SCHAUFELN BEFESTIGEN.

Als Nächstes muss das modifizierte Anemometer in das Gehäuse eingesetzt werden. Die STL-Dateien für das Gehäuse sind im Dateibereich. Ohne Schaufeln im Anemometer dieses durch das Loch am Boden des Gehäuses nach oben schieben. Den Boden des Anemometers mit Gorilla-Kleber auf zwei dünne Holzscheiben (von Hobby Lobby) kleben. 4 kleine Löcher durch die Scheiben und das ABS-Kunststoffgehäuse bohren. Ein Loch für die Kabeldurchführung, die anderen drei für Schrauben. Das Bild unten zeigt, wie es aussieht.

Als Nächstes das Anemometer mit dem Verstärker verdrahten. Unten ist ein Bild des Verstärkers.

* Hinweis: Alle an den Verstärker angeschlossenen Kabel sind Male-to-Male

Zwei Male-to-Male-Kabel nehmen (Farben egal, ich nenne sie nach unseren Projektfarben). Rotes Kabel an den +S-Kreis rechts löten. Das andere Ende an das rote Kabel vom Anemometer löten. Schwarzes Kabel an den -S-Kreis rechts löten. Das andere Ende an das gelbe Kabel vom Anemometer löten. Isolierband funktioniert gut, um sie an Ort und Stelle zu halten.

Als Nächstes den Verstärker mit einer Batterieversorgung verdrahten. Gelbes Kabel an GND rechts löten. Das andere Ende an das schwarze Kabel eines Batteriehalters löten. Weißes Kabel an den Vln-Kreis rechts löten. Das andere Ende an das rote Kabel eines Batteriehalters löten.

Als Nächstes den Verstärker mit dem Spannungssensor verdrahten. Blaues Kabel an GND am Verstärker, anderes Ende an VCC am Spannungssensor löten. Grünes Kabel an Vout am Verstärker, anderes Ende an GND am Spannungssensor löten.

Nun den Spannungssensor mit dem Arduino verdrahten und die Verkabelung abschließen. Das Verdrahtungsdiagramm im Schaltplan-Bereich zeigt, wie dieser Teil verdrahtet wird.

Feinschliff

Die schwierigsten Teile sind erledigt! Jetzt, da alles verdrahtet ist, können wir die Elektronik auf dem Durchflussmessgerät platzieren. Ein Stück Schaumstoffplatte als Decke für die Oberseite des Lüftergehäuses verwenden. Wir nutzten Gorilla-Kleber, um es zu fixieren. Die Elektronik auf der Schaumstoffplatte platzieren und weitere Schaumstoffplatten verwenden, um die Elektronik zu umschließen. In den Bildern unten sehen Sie, wie der Schaumstoff zur Umschließung der Elektronik genutzt wurde.

Außerdem wurden Löcher in den Schaumstoff geschnitten, um Arduino und Verstärker Zugang zu ihren jeweiligen 9V-Batteriestromquellen zu geben. Das ist im Bild unten zu sehen.

Als Nächstes den Trichter bauen. Wir verwendeten PVC-Material für die Trichterwände. Es waren 4 trapezförmige Platten. Zum Verbinden der Platten untereinander nutzten wir Gorilla-Kleber und Dichtmasse. Dieselbe Methode wurde verwendet, um den Trichter mit dem Lüftergehäuse zu verbinden. Am großen Ende des Trichters wurde Dichtungsband um den Umfang gelegt. Dies diente zur Abdichtung, wenn der Trichter an einen Lüftungsschacht gedrückt wird. Der Querschnitt des großen Trichterendes beträgt 14'' × 14''. Das Bild unten zeigt eine Frontansicht des Trichters.

Kalibrierung

Nach Fertigstellung kalibrierten wir unser Durchflussmessgerät. Wir testeten es mit einem Gerät, das den exakten Luftstrom kannte. Unser erster Code zeigte die vom Sensor gelesene Spannung auf dem LCD an. Wir nutzten diese gesammelten Daten, um Gleichungen zu erstellen, damit der LCD-Bildschirm CFM anzeigt. Die Daten unten zeigen, wie wir kalibrierten.

Im Graphen sehen Sie zwei Kurven: den initialen Luftstrom und den tatsächlichen Luftstrom. Sie unterscheiden sich, weil die Geschwindigkeit beim Eintrichtern der Luft leicht abnimmt. Hier verwenden wir die beste Anpassungsgleichung für den tatsächlichen Luftstrom:

y = 1.1409x² + 44.958x in unserem Arduino-Code. Der Code wird in drei Bereiche unterteilt: Bereiche mit Windgeschwindigkeit null, kleine bis mittlere Windgeschwindigkeiten und große Windgeschwindigkeiten. Man könnte die obige Gleichung für den gesamten Windgeschwindigkeitsbereich nutzen, aber wir fanden eine bessere Gleichung für den kleinen bis mittleren Bereich. Die Bereiche werden durch folgende Gleichungen dargestellt:

Großer CFM:

y = 1.1409x² + 44.958x

Mittlerer bis niedriger CFM:

y = 40x + 20

Null CFM:

y = 0

Den Code finden Sie im späteren Abschnitt.

Nach Hochladen des Codes auf den Arduino ist das Durchflussmessgerät fertig!

Selbst kalibrieren (optional)

Angenommen, Sie möchten selbst kalibrieren. Vielleicht wollen Sie den Luftstrom in m/s oder mph messen. Hier führen wir Sie durch die Kalibrierungsschritte.

Schritt 1: Einen Weg finden, die tatsächliche Flussrate zu bestimmen. Der günstigste Weg: Ein Anemometer kaufen. Hier ist eines, das funktionieren würde.

Schritt 2: Das Anemometer vor einen Ventilator mit verschiedenen Geschwindigkeitsstufen platzieren. Der Ventilator könnte wie im Bild unten aussehen.

Schritt 3: Die Windgeschwindigkeit des Anemometers bei jeder Stufe aufzeichnen.

Schritt 4: Das Durchflussmessgerät muss die Ausgangsspannung des Ventilators auslesen. Dazu den Code „Voltage Sensor Code“ auf den Arduino hochladen.

Schritt 5: Nun, da das Durchflussmessgerät Spannung liest, die Spannung bei jeder Ventilatorstufe aufzeichnen.

Schritt 6: In Excel ein Streudiagramm „Windgeschwindigkeit vs. Spannung“ erstellen.

Schritt 7: Trendlinien-Funktion nutzen, um eine Gleichung zu finden, die „Windgeschwindigkeit vs. Spannung“ genau modelliert.

Schritt 8: Falls die Trendlinie nicht sehr linear ist, separate Gleichungen für untere und obere Graphenbereiche finden.

Schritt 9: Ihre Gleichungen für meine im „Flowmeter Code“ einsetzen. Nach Hochladen auf den Arduino sind Sie fertig!

Code

Flowmeter Code C/C++

1. #include <LiquidCrystal.h>
2.
3. LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
4. // Dies sind die verwendeten Pins
5.
6. // Unten die Widerstandswerte im Sensor
7. float R1 = 30000;
8. float R2 = 7500;
9.
10. void setup()
11. {
12.   Serial.begin(9600);
13.   lcd.begin(16, 2);
14.   // LCD-Bildschirm aktivieren
15.
16. }
17.
18. void loop()
19. // Beginn der Schleife
20. {
21.   int sensorValue = analogRead(A0);
22.   // Sensorwert auslesen
23.
24.   float voltage = ((5 * sensorValue * (R1 + R2)) / (1024 * R2));
25.   // Gleichung für die echte Spannung
26.
27.   //*********************************************************//
28.   // Die CFM-Gleichung ist eine stückweise Funktion der Spannung,
29.   // daher wurden if-Statements verwendet, um die Funktionen in
30.   // ihre jeweiligen Bereiche aufzuteilen
31.   //*********************************************************//
32.
33.   if (voltage > 1)
34.   // Erster Bereich der Funktion für großen CFM
35.   {
36.     float cfm = (1.1409 * (voltage)) * ((voltage)) + 44.258 * (voltage);
37.     Serial.println(cfm);
38.     // CFM anzeigen
39.     lcd.print("CFM = ");
40.     lcd.setCursor(0, 1);
41.     lcd.print(cfm);
42.     delay(1000);
43.     // 1000 ms Verzögerung
44.     lcd.clear();
45.     // Für Wiederholung löschen
46.     delay(1000);
47.   }
48.
49.   else if (0.01 < voltage && voltage < 1)
50.   // Zweiter Bereich für mittleren bis niedrigen CFM
51.   {
52.     float cfm = (40 * (voltage) + 20);
53.     Serial.println(cfm);
54.     // CFM anzeigen
55.     lcd.print("CFM = ");
56.     lcd.setCursor(0, 1);
57.     lcd.print(cfm);
58.     delay(1000);
59.     // 1000 ms Verzögerung
60.     lcd.clear();
61.     // Für Wiederholung löschen
62.     delay(1000);
63.   }
64.
65.   else
66.   // Wenn Lüfter nicht dreht, ist CFM null
67.   {
68.     float cfm = 0;
69.     Serial.println(cfm);
70.     lcd.print("CFM = ");
71.     lcd.setCursor(0, 1);
72.     lcd.print(cfm);
73.     delay(1000);
74.     lcd.clear();
75.     delay(1000);
76.   }
77. }

Code für Spannungssensor C/C++

Dies ist der Code zum Auslesen der Spannung, falls Sie selbst kalibrieren möchten.

// Widerstandswerte im Sensor
float R1 = 30000;
float R2 = 7500;

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

void loop() {
  // Sensorwert auslesen
  int sensorValue = analogRead(A0);
  // Gleichung für die echte Spannung
  float voltage = ((5 * sensorValue * (R1 + R2)) / (1024 * R2));
  // Spannung am Computer ausgeben
  Serial.println(voltage);
  delay(1000);
}

Spannungssensor-Code C/C++

Dies ist der Code, den Sie zur eigenen Kalibrierung des Durchflussmessgeräts verwenden.

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// Dies sind die verwendeten Pins

// Widerstandswerte im Sensor
float R1 = 30000;
float R2 = 7500;

void setup() {
  // LCD-Bildschirm aktivieren
  Serial.begin(9600);
  lcd.begin(16, 2);
}

void loop() {
  // Sensorwert auslesen
  int sensorValue = analogRead(A0);
  // Gleichung für die echte Spannung
  float voltage = ((5 * sensorValue * (R1 + R2)) / (1024 * R2));
  // Spannung auf LCD anzeigen
  Serial.println(voltage);
  lcd.print("V = ");
  lcd.setCursor(0, 1);
  lcd.print(voltage);
  delay(1000);
  lcd.clear();
  delay(1000);
}

Custom Parts und Gehäuse

(STL-Dateien für Schaufeln und Gehäuse im Originalprojekt verfügbar)

Schaltpläne