Open-Source-Datenlogger (OPENSDL) - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Ziel dieses Projekts ist es, ein kostengünstiges Messsystem für Gebäudeleistungsbewertungsstudien zu entwerfen, zu bauen und zu testen, das mindestens Temperatur, relative Luftfeuchtigkeit, Beleuchtungsstärke umfasst und um zusätzliche Sensoren erweiterbar ist, und den Prototyp dieser Geräte zu entwickeln.

Dies führt zu einem maßgeschneiderten und erschwinglichen System, das es den Beteiligten ermöglicht, die für die Bewertung der Gebäudeleistung erforderlichen Messungen auf effiziente und kostengünstige Weise durchzuführen, indem mehrere Umweltparameter gleichzeitig erfasst werden. Der entwickelte Open Source Data Logger (OPENSDL) wurde mit einem HOBO U12-012 Datenlogger verglichen. Dieses im Handel erhältliche Gegenstücksystem kann 3 Parameter messen, nämlich Temperatur, RH und Beleuchtungsstärke und einen externen Kanal für andere Sensortypen. Zur Messung jedes anderen Parameters wäre eine andere Sensorvorrichtung erforderlich. Die Eigenschaften der zu messenden Parameter sind auf die proprietäre Hard- und Software beschränkt, die das System auf die Messung bestimmter Parameter mit bestimmten Genauigkeiten beschränkt. Ein HOBO U12-012 kostet etwa 13.000 Yen (185 USD), während der OPENSDL 4.605 Yen (66 USD) kostet, was fast ein Drittel des kommerziellen Gegenstücks entspricht.

Ein Open-Source-Datenlogger zur Überwachung von Temperatur, RH und Lichtstärke (Beleuchtungsstärke) mit Hilfe eines Arduino Uno Dies ist ein DIY für die Entwicklung des OPENSDL-Datenloggers.

Erforderliche Zeit: 2-3 Stunden für Löten, 5 Stunden für Verpackung (4 Stunden - 3D-Druck und 1 Stunde für Laserschneiden) Erforderliche Fähigkeiten: Löten, wenig oder keine Kenntnisse in Programmierung und Elektronik

Benötigte Teile:

1. Arduino Uno mit Kabel
2. Datenlogger-Abschirmung
3. CR1220 Knopfzellenbatterie
4. BME280 Temperatur-Feuchte-Drucksensor Breakout-Board
5. TSL2561 Lichtsensor-Breakout-Board
6. ESP01-8266 WLAN-Modul
7. RJ-9-Stecker und -Buchse
8. Shield Stacking Header für Arduino
9. SD-Speicherkarte (beliebige Kapazität)
10. Vektortafel (26 x 18 Löcher)
11. 8 AA-Batterien Batteriehalter

Notwendige Werkzeuge:

• Lötkolben (35W)
• Lötdraht
• Kabelschneider
• Crimpwerkzeug
• Multimeter

Erforderliche Software: Arduino IDE (1.0.5 oder höher)

Verwendete Arduino-Bibliotheken:

• Drahtbibliothek
• SparkFun TSL2561-Bibliothek
• Cactus BME280 Multisensor-Bibliothek
• SD-Kartenbibliothek
• SPI-Bibliothek
• RTC-Bibliothek

Hinweis: Der BME280-Sensor ist ein sehr genauer Temperatur-, relativer Feuchtigkeits- und Drucksensor von Bosch. Ebenso ist der DS1307 eine genaue Echtzeituhr von Maxim und der TSL2561 ein genauer Lichtsensor. Es gibt weniger teure und weniger genaue Alternativen für diese Produkte, aber dieses Tutorial richtete sich an Personen, die daran interessiert waren, Daten für die Gebäudeleistungsbewertung und Gebäudeüberwachungsanwendungen zu sammeln, die eine hohe Präzision und Genauigkeit erfordern. Dies bedeutet, dass jedes spezifische Hardware-Setup und Software-Setup (Bibliotheken, Programmcode) ausschließlich für die angegebenen Produkte bestimmt war.

Schritt 1: Montage

Das Datenlogger-Schild kann einfach auf das Arduino Uno-Board gestapelt werden. Dieses Schild bietet die Datenprotokollierungsfunktionen (Zeiterfassung und Datenspeicherung). Der Schild musste gestapelt werden. In den dafür vorgesehenen runden Schlitz musste eine CR1220-Knopfzellenbatterie eingelegt werden, um die Uhr auch bei ausgeschaltetem Arduino am Laufen zu halten. Die SD-Speicherkarte muss in den dafür vorgesehenen Kartenslot auf der Platine eingesteckt werden. Eine einzigartige kundenspezifische Abschirmung wurde unter Verwendung von RJ-9-Steckerbuchsen und Arduino-Shield-Stacking-Headern entwickelt. Die entsprechenden Header wurden an den entsprechenden Stellen angelötet, damit das Shield perfekt auf das Arduino-Board passt. Der Arduino hat 18 Pins auf einer Seite und 14 Pins auf der anderen Seite. Die Header mit der gleichen Anzahl von Pins wurden im gleichen Abstand (18 Pins auseinander) wie bei Arduino verwendet. Der verbleibende zusätzliche Platz neben den Headern wurde zum Platzieren des RJ-9-Steckers verwendet.

Die Stiftleisten waren der beste Weg, um die erforderlichen Pins zu verwenden und sie gleichzeitig für andere Komponenten verfügbar zu machen. Die verwendeten Sensoren folgen dem I2C-Kommunikationsprotokoll, das 4 Pins von Arduino erfordert, nämlich: SDA (auch als A4 erhältlich), SCL (auch als A5 erhältlich), 3.3V & GND. Die vier Drähte, die aus dem RJ-9-Stecker herauskommen, wurden in diese vier Kopfstifte gelötet. Die Anzahl der benötigten RJ-9-Anschlüsse hängt von der Anzahl der Sensoren ab. In diesem Projekt wurden 3 RJ-9-Anschlüsse verwendet (zwei für BME280 & einer für TSL2561). Die vier Drähte, die aus dem RJ-9-Anschluss herauskamen, waren farbcodiert, und jeder Farbdraht wurde für alle RJ-9-Anschlüsse mit einem bestimmten Pin bezeichnet. Es ist zu beachten, dass der Farbcode bei verschiedenen RJ-9-Stücken variieren kann. In einem solchen Fall muss die Lage des Kabels am Stecker notiert werden. Der RJ-9-Stecker wurde nach dem Löten mit einem Feviqwik auf die Vektorplatine geklebt, damit er auf der Oberfläche fixiert wird. Diese Verbindungen können mit dem Durchgangsmodus des Multimeters überprüft werden. Im Durchgangsmodus sollte das Multimeter keinen Widerstand anzeigen. Verbinden Sie eine der Sonden des Multimeters mit dem Lötstift und eine andere Sonde mit dem Stift im RJ-9-Anschluss. Das Multimeter sollte einen Ton ausgeben, was bedeutet, dass die Lötstellen richtig sind und die Verbindungen richtig hergestellt wurden. Wenn der Ton nicht ausgegeben wird, überprüfen Sie die Lötstellen. Löten Sie auf ähnliche Weise den RJ-9-Stecker mit den gleichen Drähten, die an die gleichen Pinholes auf den Sensor-Breakout-Platinen angeschlossen sind, d. H. A4, A5, 3,3 V & GND. Der BME280-Sensor unterstützt zwei I2C-Adressen, was bedeutet, dass zwei BME280-Sensoren gleichzeitig an denselben Controller angeschlossen werden können. Dabei muss die Adresse eines der Sensoren durch Überbrücken der Lötpads am Sensor geändert werden. Ein ESP-01-Wireless-Verbindungschip erforderte die folgenden Verbindungen mit dem Arduino.

ESP-01 ---------Arduino Uno

10 --------------------TX

11 --------------------RX

Vcc ----------------CH_PD

Vcc -------------------Vcc

GND -----------------GND

Hinweis: - Die mehreren LEDs auf Arduino Uno wurden entfernt, um die Akkulaufzeit zu verbessern. Die LED-, RX- und TX-LEDs der Betriebsanzeige wurden durch Erhitzen der Lötstellen und Drücken der LED mit einer Pinzette entfernt.

Schritt 2: IDEs und Bibliotheken einrichten

Vor jeder Programmierung muss die Arduino IDE (Integrated Development Environment) heruntergeladen werden. Die Programmierung erfolgte auf dieser Plattform. Um mit verschiedenen Komponenten von OPENSDL zu interagieren, waren verschiedene Bibliotheken erforderlich. Die folgenden Bibliotheken wurden für die angegebenen Komponenten verwendet.

Komponente ------------------------------------------------- --------------Bücherei

BME280 Temperatur- und RH-Sensor ---------------------------------Cactus_io_BME280_I2C.h

Lichtsensor------------------------------------------------ ----------------SparkFun TSL2561.h

Echtzeituhr ----------------------------------------------- --------------RTClib.h

SD-Kartensteckplatz ------------------------------------------------------------ -------------SD.h

I2C-Verbindung ------------------------------------------------ --------------Draht.h

Eine separate Bibliothek für die Kommunikation mit dem ESP01 ist nicht erforderlich, da der im Arduino hochgeladene Code AT-Befehle enthält, die an den seriellen Monitor gesendet werden, von dem der ESP-01 die Anweisungen übernimmt. Im Grunde werden also die AT-Befehle, mit denen ESP01 ausgeführt wird, in den Serial Monitor gedruckt, die von ESP-01 als Eingabebefehl verwendet werden. Um diese Bibliotheken zu installieren, öffnen Sie nach dem Herunterladen die Arduino IDE, gehen Sie zu Sketch -> Bibliothek einschließen ->. Zip-Bibliothek hinzufügen und wählen Sie die heruntergeladenen Bibliotheken aus.

Schritt 3: Programmieren des Systems

Verbinden Sie vor der Programmierung des OPENSDL das Arduino mit einem Laptop. Gehen Sie nach der Verbindung zu Tools -> Port und wählen Sie den COM-Port aus, an dem der OPENSDL angeschlossen ist. Stellen Sie außerdem sicher, dass unter Tools -> Boards Arduino Uno ausgewählt ist.

Der OPENSDL wurde entwickelt, um in 2 Modi zu arbeiten. Im ersten Modus speichert es die Daten auf der SD-Karte auf dem Datenlogger-Schild. Im zweiten Modus sendet es die Daten mithilfe eines ESP-01 Wi-Fi-Chips über das Internet an eine Website. Das Programm für beide Modi ist unterschiedlich. Diese Codezeilen können direkt in den Arduino IDE-Editor kopiert und eingefügt und direkt verwendet werden. Im Code müssen wir einige Anpassungen gemäß unseren Anforderungen vornehmen:

1. Ändern Sie manuell den Wert der Verzögerung (1000) am Ende des Codes, um das Protokollierungsintervall zu ändern. Der Wert 1000 steht für das Intervall in Millisekunden.
2. Bearbeiten Sie die Codezeile mySensorData = SD.open("Logged01.csv", FILE_WRITE); und ersetzen Sie Logged01 durch den Dateinamen des gewünschten Dateinamens. Die Erweiterung der Datei kann auch geändert werden, indem die Erweiterung.csv direkt nach dem Dateinamen geändert wird.
3. Die Kalibrierungsgleichung, die durch Ermittlung der Korrelation zwischen dem Master-/Referenzsensor und dem BME280 erreicht wird, variiert mit jedem Sensor. Ersetzen Sie diese Codezeile durch die Gleichung zum Kalibrieren der Sensoren: Serial.print((1.0533*t2)-2.2374) – für Sensor mit Standardadresse (0x77), wobei t2 der vom Temperatursensor gelesene Wert ist.

Für die Programmierung des zweiten verfügbaren Modus von OPENSDL, dem drahtlosen System, wurde ein separates Programm bereitgestellt. Das ESP-01 muss gemäß den Anschlüssen wie in Schritt 2 beschrieben mit dem OPENSDL verbunden werden. Nachdem Sie die Verbindungen hergestellt haben, verbinden Sie das Arduino mit dem Laptop und laden Sie eine leere Skizze in das Arduino hoch. Versetzen Sie das ESP-01 in den Update-Modus und aktualisieren Sie die Firmware auf das neueste verfügbare Update. Stellen Sie nach dem Update sicher, dass Sie den Reset-Pin von Arduino mit dem 3,3-V-Pin verbinden, der den Arduino-Bootloader umgeht

Schritt 4: Herstellung

Zum Schutz und zur Verbesserung der Ästhetik wurde ein Gehäuse für OPENSDL geschaffen. Die Gehäuse wurden im 3D-Druck mit PLA-Material entwickelt und das Gehäuse für den Mikrocontroller wurde durch Laserschneiden der MDF-Platte und Zusammenkleben der Teile entwickelt. Die 3D-gedruckten Modelle wurden mit der SketchUp-Software entwickelt und die 2D-dxf-Zeichnungen für das Laserschneiden wurden mit AutoCAD erstellt.

Für den 3D-Druck wurden die mit SketchUp erstellten STL-Dateien in der Software Ultimaker Cura 3.2.1 geöffnet und überprüft. Stellen Sie sicher, dass PLA-Material verwendet wird und die Düse des verwendeten Druckers für den Druck von 0,4 mm ausgelegt ist. Die Bauplatte des 3D-Druckers benötigt möglicherweise Klebstoff, um das 3D-gedruckte Objekt zu kleben. Aber wenn der Druck abgeschlossen ist, erzeugt der Kleber eine starke Haftung zwischen dem gedruckten Objekt und der Bauplatte.

Schritt 5: Code

Der Code (.ino-Dateien) funktioniert in der Arduino IDE-Software. Hier ist der Link zu meiner Github-Seite für den Code und andere Details.

github.com/arihant93/OPENSDL

Zögern Sie nicht, Fragen zum Projekt zu stellen.

Vielen Dank.