Come Realizzare un Data Logger per Temperatura, PH e Ossigeno Disciolto: 11 Passaggi (Illustrato)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Obiettivi:

• Crea un registratore di dati per ≤ $ 500. Memorizza i dati per temperatura, pH e DO con un timestamp e utilizzando la comunicazione I2C.
• Perché I2C (Circuito Inter-Integrato)? Si possono impilare tanti sensori sulla stessa linea dato che ognuno di essi ha un indirizzo univoco.

Passo 1:

Passaggio 2: acquista le parti di seguito:

1. Arduino MEGA 2560, $ 35,
2. Adattatore di alimentazione per scheda Arduino, $ 5,98,
3. Modulo LCD I2C (display), $ 8,99,
4. Breakout dell'orologio in tempo reale (RTC), $ 7,5,
5. Scheda breakout per schede MicroSD, $ 7,5,
6. Scheda SD da 4 GB, $ 6,98,
7. Sensore digitale impermeabile DS18B20, $ 9,95,
8. Sonda pH + kit + tamponi standard, $ 149,15,
9. Sonda DO + kit + tamponi standard, $ 247,45,
10. Tagliere, cavo jumper, $ 7,98,
11. (Opzionale) Isolatore di tensione, $ 24,

Totale: $ 510,48

* Alcune parti (come la scheda generica) potrebbero essere acquistate da altri venditori (eBay, venditore cinese) a un prezzo inferiore. Le sonde pH e DO sono consigliate per ottenerle da Atlas Scientific.

* Si consiglia un multimetro per controllare la conduttività e la tensione. Costa circa $ 10-15 (https://goo.gl/iAMDJo)

Passaggio 3: cablaggio

• Utilizzare cavi jumper/DuPont per collegare le parti come mostrato nello schizzo sottostante.
• Usa il multimetro per controllare la conduzione.
• Controllare l'alimentazione a tensione positiva (VCC) e la massa (GND) (è facile confondere se non si ha familiarità con il circuito)
• Collegare l'adattatore di alimentazione e controllare l'indicatore di alimentazione in ogni parte. In caso di dubbi, utilizzare il multimetro per verificare che la tensione tra VCC e GND sia (5V)

Passaggio 4: preparare i circuiti PH, DO, scheda SD

1. Passa a I2C per i circuiti pH e DO
2. I breakout pH e DO vengono forniti con la comunicazione seriale come modalità predefinita di trasmissione/ricezione (TX/RX). Per utilizzare la modalità I2C Clock line (SCL) e Data line (SDA), cambiare la modalità di (1): scollegare i cavi VCC, TX, RX, (2): passare da TX a Ground per sonda, PGND (non GND), (3) collegare VCC al circuito, (4): attendere che il LED cambi da Verde a Blu. Maggiori dettagli a pagina 39 (Scheda tecnica per circuito pH,
3. Fai lo stesso passo con il circuito DO
4. (se sai come caricare il codice di esempio sulla scheda, puoi farlo tramite Serial monitor)
5. Formatta la scheda SD in formato FAT

Passaggio 5: preparare il software

1. Scarica Arduino Integrated Development Environment (IDE),
2. Installa la libreria sull'IDE Arduino:
3. La maggior parte di essi viene fornita con il software Arduino. LiquidCrystal_I2C.h è disponibile tramite GitHub
4. Installa il driver per USB. Per Arduino autentico, potrebbe non essere necessario installarne uno. Per uno generico, è necessario installare il driver CH340 (GitHub:
5. Verificare se si collega correttamente la scheda eseguendo un test del LED lampeggiante
6. Come trovare l'indirizzo MAC della temperatura digitale 18B20. Utilizzo del modello di scanner I2C in Arduino IDE con la sonda collegata. Ogni dispositivo ha un indirizzo MAC univoco, quindi puoi utilizzare tante sonde di temperatura con una linea condivisa (#9). 18B20 utilizza un I2C a un filo, quindi è un caso speciale di metodo di comunicazione I2C. Di seguito è riportato un metodo per trovare MAC – Medical Access Control ("ROM" quando si esegue la procedura di seguito).

Passaggio 6: inizia a codificare

• Copia incolla il codice qui sotto nell'IDE di Arduino:
• Oppure scarica il codice (.ino) e dovrebbe apparire una nuova finestra nell'IDE di Arduino.

/*

Tutorial di riferimento:

1. Registratore di temperatura, ORP, pH:

2. Protezione digitale protetta (SD):

Questo codice restituirà i dati al monitor seriale Arduino. Digita i comandi nel monitor seriale Arduino per controllare il circuito EZO pH in modalità I2C.

Modificato dai tutorial di riferimento sopra, principalmente dal codice I2C di Atlas-Scientific

Ultimo aggiornamento: 26 luglio 2017 da Binh Nguyen

*/

#include //abilita I2C.

#define pH_address 99 //numero ID I2C predefinito per il circuito EZO pH.

#define DO_address 97 //numero ID I2C predefinito per il circuito EZO DO.

#include "RTClib.h" // Funzioni di data e ora utilizzando un RTC DS1307 connesso tramite I2C e Wire lib

RTC_DS1307 rtc;

#include // Per la libreria SD

#include // Scheda SD per memorizzare i dati

const int chipSelect = 53; // devo capire per Adafruit SD breakout//https://learn.adafruit.com/adafruit-micro-sd-breakout-board-card-tutorial/wiring

//DO=MISO, DI=MOSI, su ATmega pin#: 50(MISO), 51(MOSI), 52(SCK), 53(SS)

char logFileName = "dataLT.txt"; // modifica logFileName per identificare il tuo esperimento, ad esempio PBR_01_02, datalog1

ID lungo = 1; //il numero identificativo per inserire l'ordine del registro

#includere

LiquidCrystal_I2C lcd(0x27, 20, 4);

#includere

#includere

#define ONE_WIRE_BUS 9 //definisce il pin # per la sonda di temperatura

OneWire oneWire(ONE_WIRE_BUS);

DallasSensori di temperatura(&oneWire);

DeviceAddress ProbeP = { 0x28, 0xC2, 0xE8, 0x37, 0x07, 0x00, 0x00, 0xBF }; //indirizzo MAC, unico per ogni sonda

stringa dataString; // la variante principale per memorizzare tutti i dati

stringa dataString2; // una variante temporanea per memorizzare Temperatura/pH/DO per la stampa

char computerdata[20]; //istruzione di Atlas Scientific: creiamo un array di caratteri di 20 byte per contenere i dati in arrivo da un pc/mac/altro.

byte ricevuto_dal_computer=0; //abbiamo bisogno di sapere quanti caratteri sono stati ricevuti.

byte serial_event=0;//un flag per segnalare quando i dati sono stati ricevuti dal pc/mac/other.

codice byte=0; //usato per contenere il codice di risposta I2C.

char pH_data[20]; //creiamo un array di caratteri di 20 byte per contenere i dati in arrivo dal circuito pH.

byte in_char=0; //usato come buffer da 1 byte per memorizzare in byte legati dal circuito pH.

byte i=0; //contatore utilizzato per l'array ph_data.

int tempo_=1800; //usato per modificare il ritardo necessario in base al comando inviato al circuito EZO Class pH.

float pH_float; //float var usato per contenere il valore float del pH.

char DO_data[20];

//float temp_C;

void setup() //inizializzazione hardware.

{

Serial.begin(9600); //abilita la porta seriale.

Wire.begin(pH_address); //abilita la porta I2C per la sonda pH

Wire.begin(DO_address);

lcd.init();

lcd.begin(20, 4);

lcd.backlight();

lcd.home();

lcd.print("Ciao PBR!");

lcd.setCursor(0, 1);

lcd.print("Inizializzazione in corso…");

Serial.print("RTC è…");

if (! rtc.begin())

{

Serial.println("RTC: Orologio in tempo reale…NON TROVATO");

while (1);// (Serial.println("RTC: Orologio in tempo reale…TROVATO"));

}

Serial.println("IN CORSO");

Serial.print("Orologio in tempo reale…");

if (! rtc.isrunning())

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

}

Serial.println("FUNZIONANTE");

lcd.setCursor(0, 0);

lcd.println("RTC: OK");

Serial.print("Scheda SD…"); // verifica se la scheda è presente e può essere inizializzata:

if (!SD.begin(chipSelect))

{ Serial.println("Fallito"); // non fare altro:

Restituzione;

}

Serial.println("OK");

lcd.setCursor(0, 1);

lcd.println("Scheda SD: OK");

Serial.print("File di registro: ");

Serial.print(logFileName);

Serial.print("…");

File logFile = SD.open(logFileName, FILE_WRITE); //apro il file. "datalog" e stampa l'intestazione

if (file di log)

{

logFile.println(",,, "); //indica che c'erano dati nell'esecuzione precedente

Intestazione stringa = "Date -Time, Temp(C), pH, DO";

logFile.println(header);

logFile.close();

Serial.println("PRONTO");

//Serial.println(dataString); // stampa anche sulla porta seriale:

}

else { Serial.println("errore durante l'apertura del registro dati"); } // se il file non è aperto, compare un errore:

lcd.setCursor(0, 2);

lcd.print("File di registro:");

lcd.println(logFileName);

ritardo(1000);

sensori.begin();

sensori.setResolution(ProbeP, 10); //10 è la risoluzione (10bit)

lcd.clear();

ID = 0;

}

ciclo vuoto()

{ //il ciclo principale.

dataString = Stringa (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(stringa di dati);

sensori.requestTemperatures();

displayTemperature(ProbeP);

Wire.beginTransmission(pH_address); //chiama il circuito con il suo numero ID

Wire.write('r'); //codice fisso r da leggere continuamente

Wire.endTransmission(); //termina la trasmissione dei dati I2C.

ritardo_); //attendere il tempo corretto affinché il circuito completi le sue istruzioni.

Wire.requestFrom(pH_address, 20, 1); //chiama il circuito e richiedi 20 byte (questo potrebbe essere più del necessario)

while(Wire.available()) //ci sono byte da ricevere?

{

in_char = Wire.read(); //ricevo un byte.

if ((in_char > 31) && (in_char <127)) //verifica se il carattere è utilizzabile (stampabile)

{

pH_data= in_char; //carica questo byte nel nostro array.

io+=1;

}

if(in_char==0) //se vediamo che ci è stato inviato un comando null.

{

io=0; //ripristina il contatore i a 0.

Wire.endTransmission(); //termina la trasmissione dei dati I2C.

rottura; //esce dal ciclo while.

}

}

evento_seriale=0; //reimposta il flag dell'evento seriale.

dataString2 += ", ";

dataString2 += String(pH_data);

Wire.beginTransmission(DO_address); //chiama il circuito con il suo numero ID

Wire.write('r');

Wire.endTransmission(); //termina la trasmissione dei dati I2C

ritardo_); //attendere il tempo corretto affinché il circuito completi le sue istruzioni

Wire.requestFrom(DO_address, 20, 1); //chiama il circuito e richiedi 20 byte

while(Wire.available()) //ci sono byte da ricevere.

{

in_char = Wire.read(); //ricevo un byte.

if ((in_char > 31) && (in_char <127)) //verifica se il char è utilizzabile (stampabile), altrimenti in_char contiene un simbolo all'inizio del file.txt

{ DO_data= in_char; // carica questo byte nel nostro array

io+=1; //incorre il contatore per l'elemento dell'array

}

if(in_char==0)

{ //se vediamo che ci è stato inviato un comando null

io=0; //ripristina il contatore i a 0.

Wire.endTransmission(); //termina la trasmissione dei dati I2C.

rottura; //esce dal ciclo while.

}

}

evento_seriale=0; //ripristina il flag dell'evento seriale

pH_float = atof (pH_data);

dataString2 += ", ";

dataString2 += String(DO_data);

lcd.setCursor(0, 1);

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

lcd.setCursor(0, 2);

lcd.print(stringa dati2);

dataString += ', ';

dataString += dataString2;

File dataFile = SD.open(logFileName, FILE_WRITE); //apro il file. nota che può essere aperto solo un file alla volta, quindi devi chiudere questo prima di aprirne un altro.

if (dataFile) // se il file è disponibile, scrivici:

{

dataFile.println(dataString);

dataFile.close();

Serial.println(dataString); // stampa anche sulla porta seriale:

}

else { Serial.println("errore durante l'apertura del file datalog"); } // se il file non è aperto, compare un errore:

lcd.setCursor(0, 3);

lcd.print("In esecuzione(x5m):");

lcd.setCursor(15, 3);

lcd.print(id);

id++; // aumenta un ID alla prossima iterazione

dataString = "";

ritardo(300000); //ritardo 5 minuti = 5*60*1000 ms

lcd.clear();

} //termina il ciclo principale

void displayTemperature(DeviceAddress deviceAddress)

{

float tempC = sensor.getTempC(deviceAddress);

if (tempC == -127.00) lcd.print("Errore di temperatura");

else dataString2 = String(tempC);

}//il codice finisce qui

• Scegli la porta COM giusta tramite Arduino IDE in Strumenti/Porta
• Scegli la scheda Arduino giusta. Ho usato Mega 2560 perché ha più memoria interna. Arduino Nano o Uno funziona bene con questa configurazione.
• Controlla, codifica e carica il codice

Passaggio 7: risultati sul cablaggio (possono essere migliorati) e sul display LCD

• Avviso: ho riscontrato il rumore dalla sonda DO alla sonda pH dopo 2-3 mesi di funzionamento continuo. Secondo Atlas Scientific, si consiglia un isolatore di tensione in linea quando le sonde di pH e conducibilità funzionano insieme. Maggiori dettagli sono a pagina 9 (https://goo.gl/d62Rqv)
• I dati registrati (il primo ha caratteri non stampati prima dei dati di pH e DO). Ho filtrato il codice consentendo solo caratteri stampabili.

Passaggio 8: importa i dati e crea un grafico

1. Importa dati da testo nella scheda DATI (Excel 2013)
2. Separare i dati con la virgola (ecco perché è utile avere delle virgole dopo ogni input di dati)
3. Traccia i dati. Ciascun dato sotto ha circa 1700 punti. L'intervallo di misurazione è di 5 minuti (regolabile). Il minimo per i circuiti DO e pH per leggere i dati è di 1,8 secondi.

Passaggio 9: calibrazione

1. Il sensore di temperatura digitale (18B20) può essere calibrato regolando la differenza direttamente al. Diversamente, se la compensazione e la pendenza richiedono calibrazione, si può fare modificando i valori alla riga #453, DallasTemperature.cpp nella cartella \libraries\DallasTemperature.
2. Per le sonde di pH e DO, è possibile calibrare le sonde con le soluzioni di accompagnamento. Devi usare il codice di esempio di Atlas Scientific e seguire le istruzioni di questo file.
3. Si prega di seguire le pagine 26 e 50 per la sonda pH (https://goo.gl/d62Rqv) per la calibrazione e la compensazione della temperatura, e anche le pagine 7-8 e 50 per la sonda DO (https://goo.gl/mA32mp). Per prima cosa, ricaricare il codice generico fornito da Atlas, aprire il monitor seriale e digitare un comando appropriato.

Passaggio 10: troppi cavi?

1. Puoi eliminare la scheda SD e il modulo orologio in tempo reale utilizzando Dragino Yun Shield per schede Arduino (https://goo.gl/J9PBTH). Il codice doveva essere modificato per funzionare con Yun Shield. Ecco un buon punto di partenza (https://goo.gl/c1x8Dm)
2. Ancora troppi cablaggi: l'Atlas Scientific ha realizzato una guida per i suoi circuiti EZO (https://goo.gl/dGyb12) e la scheda senza saldatura (https://goo.gl/uWF51n). L'integrazione della temperatura digitale 18B20 è qui (https://goo.gl/ATcnGd). Devi avere familiarità con i comandi su Raspbian (una versione di Debian Linux) in esecuzione su Raspberry Pi (https://goo.gl/549xvk)

Passaggio 11: Riconoscimento:

Questo è il mio progetto parallelo durante la mia ricerca post-dottorato in cui ho lavorato su un fotobioreattore avanzato per coltivare microalghe. Quindi ho pensato che fosse necessario dare credito alle parti che hanno fornito le condizioni per far sì che ciò accadesse. In primo luogo, la sovvenzione, DE-EE0007093: "Arricchimento e rilascio di CO2 atmosferica (ACED)," del Dipartimento dell'energia degli Stati Uniti, dell'Ufficio per l'efficienza energetica e dei biocarburanti e bioprodotti algali mirati alle energie rinnovabili. Ringrazio il Dr. Bruce E. Rittmann del Biodesign Swette Center for Environmental Biotechnology, Arizona State University per avermi fornito l'opportunità di armeggiare con l'elettronica e Arduino. Mi sono formato in ingegneria ambientale, principalmente chimica, un po' di microbiologia.