So erstellen Sie einen Datenlogger für Temperatur, pH und gelösten Sauerstoff - Gunook

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

Ziele:

• Machen Sie einen Datenlogger für ≤ 500 $. Es speichert Daten für Temperatur, pH und DO mit Zeitstempel und über I2C-Kommunikation.
• Warum I2C (Inter-Integrated Circuit)? Man kann beliebig viele Sensoren in einer Reihe stapeln, vorausgesetzt, jeder von ihnen hat eine eindeutige Adresse.

Schritt 1:

Schritt 2: Kaufen Sie die Teile unten:

1. Arduino MEGA 2560, $ 35,
2. Netzteil für Arduino-Board, $5.98,
3. LCD-Modul I2C (Display), 8,99 $,
4. Echtzeituhr (RTC) Breakout, $7,5,
5. Breakout-Board für MicroSD-Karte, $ 7,5,
6. 4 GB SD-Karte, $ 6,98,
7. Wasserdichter DS18B20 Digitalsensor, $9.95,
8. pH-Sonde + Kits + Standardpuffer, $ 149,15,
9. DO-Sonde + Kits + Standardpuffer, $247.45,
10. Steckbrett, Überbrückungskabel, $7.98,
11. (Optional) Spannungsisolator, $ 24,

Gesamt: 510,48 $

* Bestimmte Teile (wie das generische Board) können von anderen Anbietern (eBay, chinesischer Verkäufer) zu einem niedrigeren Preis gekauft werden. Es wird empfohlen, pH- und DO-Sonden von Atlas Scientific zu beziehen.

* Zur Überprüfung von Leitfähigkeit und Spannung wird ein Multimeter empfohlen. Es kostet ungefähr $10-15 (https://goo.gl/iAMDJo)

Schritt 3: Verkabelung

• Verwenden Sie Jumper-/DuPont-Kabel, um die Teile wie in der Skizze unten gezeigt zu verbinden.
• Verwenden Sie das Multimeter, um die Leitung zu überprüfen.
• Überprüfen Sie die positive Spannungsversorgung (VCC) und Masse (GND) (es ist leicht zu verwechseln, wenn Sie mit der Schaltung nicht vertraut sind)
• Stecken Sie das Netzteil ein und überprüfen Sie die Betriebsanzeige in jedem Teil. Verwenden Sie im Zweifelsfall das Multimeter, um die Spannung zwischen VCC und GND zu überprüfen (5V).

Schritt 4: Bereiten Sie die PH-, DO-Schaltungen und die SD-Karte vor

1. Umschalten auf I2C für pH- und DO-Kreise
2. Die pH- und DO-Breakouts werden mit serieller Kommunikation als Standardmodus Senden/Empfangen (TX/RX) geliefert. Um die Taktleitung (SCL) im I2C-Modus und die Datenleitung (SDA) zu verwenden, wechseln Sie den Modus durch (1): Ziehen Sie die VCC-, TX-, RX-Kabel ab, (2): springen Sie TX auf Masse für Sonde, PGND (nicht GND)), (3) VCC an den Stromkreis anschließen, (4): warten, bis die LED von Grün auf Blau wechselt. Weitere Details finden Sie auf Seite 39 (Datenblatt für pH-Kreislauf,
3. Machen Sie den gleichen Schritt mit der DO-Schaltung
4. (Wenn Sie wissen, wie Sie den Beispielcode auf die Platine hochladen, können Sie dies über den seriellen Monitor tun)
5. SD-Karte im FAT-Format formatieren

Schritt 5: Software vorbereiten

1. Laden Sie die integrierte Entwicklungsumgebung (IDE) von Arduino herunter,
2. Installieren Sie die Bibliothek in der Arduino IDE:
3. Die meisten von ihnen werden mit Arduino-Software geliefert. LiquidCrystal_I2C.h ist über GitHub verfügbar
4. Installieren Sie den Treiber für USB. Für echtes Arduino müssen Sie möglicherweise keinen installieren. Für einen generischen Treiber müssen Sie den CH340-Treiber installieren (GitHub:
5. Überprüfen Sie, ob Sie die Platine richtig angeschlossen haben, indem Sie einen blinkenden LED-Test durchführen
6. So finden Sie die MAC-Adresse des digitalen Temperatursensors 18B20. Verwenden der I2C-Scanner-Vorlage in Arduino IDE mit angeschlossener Sonde. Jedes Gerät hat eine eindeutige MAC-Adresse, sodass Sie beliebig viele Temperatursonden mit einer gemeinsamen Leitung verwenden können (#9). 18B20 verwendet ein Eindraht-I2C, es handelt sich also um einen Sonderfall der I2C-Kommunikationsmethode. Im Folgenden finden Sie eine Methode zum Auffinden von MAC – Medical Access Control („ROM“, wenn Sie das folgende Verfahren ausführen).

Schritt 6: Codierung starten

• Kopieren Sie den folgenden Code in die Arduino IDE:
• Oder laden Sie den Code (.ino) herunter und ein neues Fenster sollte in der Arduino IDE erscheinen.

/*

Referenz-Tutorials:

1. Temperatur, Redox, pH-Logger:

2. Secured Digital (SD) Shield:

Dieser Code gibt Daten an den seriellen Arduino-Monitor aus. Geben Sie Befehle in den seriellen Arduino-Monitor ein, um den EZO pH Circuit im I2C-Modus zu steuern.

Abgeändert aus den oben referenzierten Tutorials, hauptsächlich aus dem I2C-Code von Atlas-Scientific

Zuletzt aktualisiert: 26. Juli 2017 von Binh Nguyen

*/

#include // I2C aktivieren.

#define pH_address 99 //Standard-I2C-ID-Nummer für den EZO pH-Kreislauf.

#define DO_address 97 //Standard-I2C-ID-Nummer für EZO DO Circuit.

#include "RTClib.h" // Datums- und Zeitfunktionen mit einer DS1307 RTC, die über I2C und Wire lib verbunden ist

RTC_DS1307 rtc;

#include // Für SD-Bibliothek

#include // SD-Karte zum Speichern von Daten

const int chipSelect = 53; // muss den Adafruit SD Breakout herausfinden//https://learn.adafruit.com/adafruit-micro-sd-breakout-board-card-tutorial/wiring

// DO = MISO, DI = MOSI, auf ATmega-Pin #: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)

char logFileName = "dataLT.txt"; // LogFileName ändern, um Ihr Experiment zu identifizieren, zum Beispiel PBR_01_02, datalog1

lange ID = 1; //die ID-Nummer, um die Protokollreihenfolge einzugeben

#enthalten

LiquidCrystal_I2C lcd(0x27, 20, 4);

#enthalten

#enthalten

#define ONE_WIRE_BUS 9 // Definiere den Pin # für den Temperaturfühler

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperatursensoren(&oneWire);

DeviceAddress ProbeP = { 0x28, 0xC2, 0xE8, 0x37, 0x07, 0x00, 0x00, 0xBF}; // MAC-Adresse, eindeutig für jede Sonde

String dataString; // die Hauptvariante zum Speichern aller Daten

Zeichenfolge dataString2; // eine temporäre Variante zum Speichern von Temperatur/pH/DO für den Ausdruck

char-Computerdaten[20]; //Anweisung von Atlas Scientific: Wir erstellen ein 20-Byte-Zeichen-Array, um eingehende Daten von einem PC/Mac/anderen zu speichern.

Byte empfangen_vom_Computer=0; //Wir müssen wissen, wie viele Zeichen empfangen wurden.

byte serial_event=0; // ein Flag, das signalisiert, wenn Daten vom PC/Mac/anderen empfangen wurden.

Bytecode=0; // wird verwendet, um den I2C-Antwortcode zu halten.

char pH_data[20]; // Wir erstellen ein 20-Byte-Zeichenarray, um eingehende Daten von der pH-Schaltung zu speichern.

Byte in_char=0; // Wird als 1-Byte-Puffer verwendet, um gebundene Bytes aus dem pH-Kreislauf zu speichern.

Byte i=0; //Zähler, der für das ph_data-Array verwendet wird.

int time_=1800; // wird verwendet, um die erforderliche Verzögerung abhängig von dem an den EZO-Klassen-pH-Kreislauf gesendeten Befehl zu ändern.

float pH_float; //float var verwendet, um den Float-Wert des pH-Wertes zu halten.

char DO_data[20];

// Float-Temp_C;

Void setup () // Hardware-Initialisierung.

{

Serial.begin (9600); // serielle Schnittstelle aktivieren.

Wire.begin(pH_Adresse); // I2C-Port für pH-Sonde aktivieren

Wire.begin(DO_address);

lcd.init();

lcd.begin(20, 4);

LCD-Rücklicht();

lcd.home();

lcd.print("Hallo PBR!");

lcd.setCursor(0, 1);

lcd.print("Initialisierung…");

Serial.print ("RTC ist …");

if (! rtc.begin())

{

Serial.println ("RTC: Echtzeituhr … NICHT GEFUNDEN");

while (1); // (Serial.println("RTC: Echtzeituhr…GEFUNDEN"));

}

Serial.println ("LAUFEND");

Serial.print ("Echtzeituhr …");

if (! rtc.isrunning())

{rtc.adjust(DateTime(F(_DATE_), F(_TIME_)));

}

Serial.println ("ARBEITEN");

lcd.setCursor(0, 0);

lcd.println("RTC: OK");

Serial.print("SD-Karte…"); // prüfen, ob die Karte vorhanden ist und initialisiert werden kann:

if (!SD.begin(chipSelect))

{ Serial.println ("Fehlgeschlagen"); // mach nichts mehr:

Rückkehr;

}

Serial.println("OK");

lcd.setCursor(0, 1);

lcd.println("SD-Karte: OK");

Serial.print ("Protokolldatei: ");

Serial.print (logFileName);

Serial.print("…");

Datei logFile = SD.open(logFileName, FILE_WRITE); // öffne die Datei. "datalog" und drucken Sie die Kopfzeile

if (logDatei)

{

logFile.println(",,, "); //zeigen an, dass im vorherigen Lauf Daten vorhanden waren

String-Header = "Datum -Uhrzeit, Temp(C), pH, DO";

logFile.println (Kopfzeile);

logFile.close();

Serial.println ("READY");

//Seriell.println (Datenzeichenfolge); // auch auf den seriellen Port drucken:

}

else { Serial.println ("Fehler beim Öffnen des Datenprotokolls"); } // Wenn die Datei nicht geöffnet ist, wird ein Fehler angezeigt:

lcd.setCursor(0, 2);

lcd.print("Protokolldatei:");

lcd.println (logFileName);

Verzögerung (1000);

sensoren.begin();

sensor.setResolution (ProbeP, 10); ///10 ist die Auflösung (10bit)

lcd.clear();

id = 0;

}

Leere Schleife ()

{ //die Hauptschleife.

dataString = String(id);

dataString = String(', ');

DateTime now = rtc.now();

dataString = String(now.year(), DEC);

dataString += String('/');

dataString += String(now.month(), DEC);

dataString += String('/');

dataString += String(now.day(), DEC);

dataString += String(' ');

dataString += String(now.hour(), DEC);

dataString += String(':');

dataString += String(now.minute(), DEC);

dataString += String(':');

dataString += String(now.second(), DEC);

lcd.home();

lcd.print (Datenzeichenfolge);

sensoren.requestTemperatures();

DisplayTemperatur (SondeP);

Wire.beginTransmission(pH_Adresse); // Rufen Sie die Schaltung mit ihrer ID-Nummer auf

Wire.write('r'); // harter Code r zum ständigen Lesen

Wire.endTransmission(); //Beenden Sie die I2C-Datenübertragung.

Verzögerungszeit_); // Warten Sie die richtige Zeit, bis die Schaltung ihre Anweisung abgeschlossen hat.

Wire.requestFrom(pH_Adresse, 20, 1); // Rufen Sie die Schaltung auf und fordern Sie 20 Bytes an (dies kann mehr sein, als wir brauchen)

while(Wire.available()) // Gibt es Bytes zum Empfangen?

{

in_char = Wire.read(); // ein Byte empfangen.

if ((in_char > 31) && (in_char <127)) //überprüfe, ob das Zeichen verwendbar ist (druckbar)

{

pH_data= in_char; // Laden Sie dieses Byte in unser Array.

i+=1;

}

if(in_char==0) //wenn wir sehen, dass uns ein Nullbefehl gesendet wurde.

{

i=0; // den Zähler i auf 0 zurücksetzen.

Wire.endTransmission(); // Beenden Sie die I2C-Datenübertragung.

brechen; //beende die while-Schleife.

}

}

serielles_event=0; // Setzen Sie das serielle Ereignis-Flag zurück.

dataString2 += ", ";

dataString2 += String(pH_data);

Wire.beginTransmission(DO_address); // Rufen Sie die Schaltung mit ihrer ID-Nummer auf

Wire.write('r');

Wire.endTransmission(); // die I2C-Datenübertragung beenden

Verzögerungszeit_); // Warten Sie die richtige Zeit, bis die Schaltung ihre Anweisung abgeschlossen hat

Wire.requestFrom(DO_address, 20, 1); // Rufen Sie die Schaltung auf und fordern Sie 20 Bytes an

while(Wire.available()) //sind Bytes zu empfangen.

{

in_char = Wire.read(); // ein Byte empfangen.

if ((in_char > 31) && (in_char <127)) //überprüfe ob das Zeichen verwendbar (druckbar) ist, ansonsten enthält das in_char ein Symbol am Anfang in der.txt Datei

{ DO_data= in_char; // dieses Byte in unser Array laden

i+=1; //incuriere den Zähler für das Array-Element

}

if(in_char==0)

{ //wenn wir sehen, dass uns ein Nullbefehl gesendet wurde

i=0; // den Zähler i auf 0 zurücksetzen.

Wire.endTransmission(); // Beenden Sie die I2C-Datenübertragung.

brechen; //beende die while-Schleife.

}

}

serielles_event=0; // das serielle Ereignis-Flag zurücksetzen

pH_float = atof (pH_data);

dataString2 += ", ";

dataString2 += String(DO_data);

lcd.setCursor(0, 1);

lcd.print("Temperatur/pH/DO");

lcd.setCursor(0, 2);

lcd.print (Datenzeichenfolge2);

Datenzeichenfolge += ', ';

Datenzeichenfolge += Datenzeichenfolge2;

Datei dataFile = SD.open(logFileName, FILE_WRITE); // öffne die Datei. Beachten Sie, dass immer nur eine Datei gleichzeitig geöffnet sein kann. Sie müssen diese also schließen, bevor Sie eine andere öffnen.

if (dataFile) // wenn die Datei verfügbar ist, schreibe hinein:

{

dataFile.println (dataString);

dataFile.close();

Serial.println (dataString); // auch auf den seriellen Port drucken:

}

else { Serial.println ("Fehler beim Öffnen der Datenprotokolldatei"); } // Wenn die Datei nicht geöffnet ist, wird ein Fehler angezeigt:

lcd.setCursor(0, 3);

lcd.print("Lauft (x5m):");

lcd.setCursor(15, 3);

lcd.print(id);

id++; // Erhöhen Sie eine ID in der nächsten Iteration

dataString = "";

Verzögerung(300000); // Verzögerung 5 Minuten = 5*60*1000 ms

lcd.clear();

} //Hauptschleife beenden

void displayTemperature(DeviceAddress deviceAddress)

{

float tempC = sensoren.getTempC(deviceAddress);

if (tempC == -127.00) lcd.print("Temperaturfehler");

sonst dataString2 = String(tempC);

}//der Code endet hier

• Wählen Sie den richtigen COM-Port über die Arduino IDE unter Tools/Port
• Wählen Sie das richtige Arduino-Board. Ich habe Mega 2560 verwendet, weil es mehr internen Speicher hat. Arduino Nano oder Uno funktioniert mit diesem Setup einwandfrei.
• Code prüfen und codieren und Code hochladen

Schritt 7: Ergebnisse der Verkabelung (können verbessert werden) und des LCD-Displays

• Hinweis: Ich bin nach 2-3 Monaten Dauerbetrieb auf das Rauschen von der DO-Sonde zur pH-Sonde gestoßen. Laut Atlas Scientific wird ein Inline-Spannungstrenner empfohlen, wenn pH- und Leitfähigkeitssonden zusammen arbeiten. Weitere Details finden Sie auf Seite 9 (https://goo.gl/d62Rqv)
• Die protokollierten Daten (der erste enthält ungedruckte Zeichen vor den pH- und DO-Daten). Ich habe nach Code gefiltert, indem ich nur druckbare Zeichen zugelassen habe.

Schritt 8: Daten importieren und ein Diagramm erstellen

1. Importieren von Daten aus Text auf der Registerkarte DATEN (Excel 2013)
2. Trennen Sie die Daten durch Kommas (deshalb sind Kommas nach jeder Dateneingabe hilfreich)
3. Plotten Sie die Daten. Jede der unten aufgeführten Daten hat etwa 1700 Punkte. Das Messintervall beträgt 5 Minuten (einstellbar). Das Minimum für DO- und pH-Kreise zum Lesen der Daten beträgt 1,8 Sekunden.

Schritt 9: Kalibrierung

1. Der digitale Temperatursensor (18B20) kann kalibriert werden, indem die Differenz direkt an die angepasst wird. Andernfalls, wenn die Kompensation und die Steilheit eine Kalibrierung erfordern, können Sie die Werte in Zeile #453, DallasTemperature.cpp im Ordner \libraries\DallasTemperature ändern.
2. Bei pH- und DO-Sonden können Sie die Sonden mit den begleitenden Lösungen kalibrieren. Sie müssen den Beispielcode von Atlas Scientific verwenden und den Anweisungen dieser Datei folgen.
3. Bitte befolgen Sie die Seiten 26 und 50 für die pH-Sonde (https://goo.gl/d62Rqv) für die Kalibrierung und Temperaturkompensation sowie die Seiten 7-8 und 50 für die DO-Sonde (https://goo.gl/mA32mp). Laden Sie zunächst den von Atlas bereitgestellten generischen Code erneut hoch, öffnen Sie den Serial Monitor und geben Sie einen geeigneten Befehl ein.

Schritt 10: Zu viel Verkabelung?

1. Sie können die SD-Karte und das Echtzeituhrmodul entfernen, indem Sie Dragino Yun Shield für Arduino-Boards verwenden (https://goo.gl/J9PBTH). Der Code musste geändert werden, um mit Yun Shield zu funktionieren. Hier ist ein guter Anfang (https://goo.gl/c1x8Dm)
2. Immer noch zu viel Verkabelung: Atlas Scientific hat eine Anleitung für ihre EZO-Schaltungen (https://goo.gl/dGyb12) und die lötfreie Platine (https://goo.gl/uWF51n) erstellt. Die Integration der digitalen Temperatur 18B20 ist hier (https://goo.gl/ATcnGd). Sie müssen mit Befehlen auf Raspbian (einer Version von Debian Linux) vertraut sein, das auf Raspberry Pi (https://goo.gl/549xvk) ausgeführt wird.

Schritt 11: Bestätigung:

Dies ist mein Nebenprojekt während meiner Postdoc-Forschung, bei der ich an einem fortschrittlichen Photobioreaktor zur Kultivierung von Mikroalgen gearbeitet habe. Daher hielt ich es für notwendig, den Parteien die Bedingungen zuzuschreiben, die dies ermöglichen. Erstens der Zuschuss, DE-EE0007093: „Atmospheric CO2 Enrichment and Delivery (ACED),“vom U. S. Department of Energy, Office of Energy Efficiency and Renewable Energy Targeted Algal Biofuels and Bioproducts. Ich danke Dr. Bruce E. Rittmann vom Biodesign Swette Center for Environmental Biotechnology, Arizona State Univesity, dass er mir die Gelegenheit gegeben hat, an Elektronik und Arduino herumzubasteln. Ich wurde in Umwelttechnik ausgebildet, hauptsächlich Chemie, ein bisschen Mikrobiologie.