Voglio collezionare fallo da solo strumento che misurerà la pressione atmosferica e la temperatura. Il sensore di temperatura deve essere remoto e stretto, in quanto deve misurare la temperatura a una certa distanza dal dispositivo. Vorrei avere un dispositivo portatile con un campo di lavoro da -30 ° C a 50 ° C. Ma ciò richiede che tutti i componenti siano in grado di funzionare in questo intervallo di temperature. I componenti che possono funzionare in un intervallo di temperatura esteso sono più costosi ed è più difficile acquistarli.
Per realizzare il mio sogno in realtà, sarò aiutato dal consiglio di amministrazione, che ho descritto nell'articolo "Scheda GY-BMP280-3.3 per la misurazione della pressione barometrica e della temperatura».
Dalla pratica, è noto che durante l'assemblaggio e la configurazione elettronico prodotti prima della sua fabbricazione, è necessario verificare la manutenzione di tutti i materiali e componenti di ciascuno separatamente. Altrimenti, puoi confonderti in seguito e, di conseguenza, il prodotto elettronico non funzionerà e sarà molto difficile trovare la causa del malfunzionamento.
Cominciamo
Primo stadio. Installa una shell software gratuita sul tuo computer Arduino IDE per scrivere programmi (schizzi), compilarli e poi scriverli sul microcontrollore Mega328P installato sulla scheda. Ti consiglio di scaricare la versione shell di ARDUINO 1.6.5. Perché? Inizialmente, il progetto ARDUINO era uno, ora gli sviluppatori si sono dispersi e continuano a sviluppare il sistema ARDUINO, ma ognuno a modo suo, con piccole sfumature. Ho usato la versione ARDUINO 1.6.5. Dovrebbe essere installato e testato per la collaborazione con la scheda Arduino Uno usando gli esempi più semplici.
Secondo stadio. Controlliamo la scheda GY-BMP280-3.3 per misurare la pressione barometrica e la temperatura. Prendiamo 4 fili, li colleghiamo GY-BMP280-3.3 e Arduino Uno, come mostrato nella foto e nel diagramma. Le curve sottili linee multicolori sono conduttori.
Iniziamo a controllare la scheda GY-BMP280-3.3. Per fare ciò, è necessario installare la libreria nell'IDE di Arduino, scritta dai programmatori che lavorano sul sito. Di norma, dopo aver installato la libreria nell'IDE di Arduino, vengono visualizzati esempi (esempi) di codice. Modificando leggermente il codice di esempio, possiamo compilarlo in dati comprensibili per il microcontrollore e quindi inviarlo alla memoria del microcontrollore. Puoi trovare un esempio (esempio) prestando attenzione alle due foto sullo schermo in basso.
Dopo aver scritto i dati sul microcontrollore della scheda Arduino Uno, inizia immediatamente l'esecuzione del programma (codice) e invia i dati tramite cavo USB al computer a cui è collegata la scheda Arduino Uno.E possiamo vedere il risultato della misurazione della scheda GY-BMP280-3.3 nella finestra IDE di Arduino, chiamata "monitor della porta seriale".
Possiamo vedere il risultato delle misurazioni sulla scheda GY-BMP280-3.3 nel programma standard Hyper Terminal di Windows, dopo aver chiuso la shell Arduino Uno e aver impostato una sessione nel programma Hyper Terminal. Cioè, possiamo ottenere i risultati della scheda GY-BMP280-3.3 collegando Arduino Uno a qualsiasi computer con un cavo USB su cui è installato il driver per la scheda Arduino Uno. Esistono diverse librerie per lavorare con GY-BMP280-3.3. Tutto ha funzionato per me con la biblioteca. Il file scaricato da questo sito sarà simile al seguente: bd7e4a37c1f4dba2ebde9b9cd49f45ce.zip. Deve essere rinominato come: iarduino_Pressure_BMP.zip. Ora dobbiamo installare la libreria iarduino_Pressure_BMP nella shell IDE di Arduino.
Avvia l'IDE Arduino, vai al menu Sketch / Include Librari / Add.ZIP Library ... quindi seleziona il file iarduino_Pressure_BMP.zip e fai clic sul pulsante Apri. È inoltre necessario installare le librerie:,. Dopo aver installato le librerie, riavviamo la shell IDE di Arduino, ovvero la chiudiamo e la riavviamo. Quindi selezionare il menu File / Samples / iarduino Pressure BMP (sensori di pressione) / esempio.
Vediamo il codice nella finestra.
Il codice dovrà essere leggermente modificato.
Nella quinta riga, rimuovere due barre "//" e aggiungere (0x76) o (0x77) nell'undicesima riga. (0x76) è l'indirizzo della scheda del barometro. La mia scheda GY-BMP280-3.3 collegata al bus I2C si è rivelata avere lo stesso indirizzo (0x76). Come scoprire il numero del dispositivo collegato al bus I2C? Otterrai la risposta a questa domanda leggendo l'articolo completo.
Quindi, abbiamo corretto il codice nella finestra, ora iniziamo a controllare e compilare il codice nel menu Sketch / Check / Compile. Se la verifica e la compilazione del codice hanno esito positivo, quindi nel menu Sketch / Load, iniziamo la registrazione del programma in Arduino Uno.
Se il download ha esito positivo, quindi aprendo il monitor della porta seriale nel menu: Strumenti / Monitor porta seriale, vedremo i dati inviati dalla scheda GY-BMP280-3.3.
Nella schermata seguente, il risultato della scheda GY-BMP280-3.3 funziona su un computer su cui non è installata la shell IDE Arduino. I dati vengono ricevuti dal programma PuTTY.
Allo stesso tempo, è stato fotografato un barometro aneroide da laboratorio, che si trovava vicino alla scheda GY-BMP280-3.3. Confrontando le letture dello strumento, è possibile trarre conclusioni sull'accuratezza della scheda GY-BMP280-3.3. Barometro aneroide certificato da laboratorio statale.
Terzo stadio. Verifica del display LCD con il modulo di interfaccia I2C. Troviamo un display LDC con un modulo di interfaccia che si collega tramite il bus I2C a Arduino UNO.
Controlliamo il suo funzionamento usando esempi dalla shell IDE di Arduino. Ma prima di ciò, determiniamo l'indirizzo del modulo di interfaccia. Il mio modulo di interfaccia ha un indirizzo di 0x3F. Ho inserito questo indirizzo nella linea di schizzo: LiquidCrystal_I2C lcd (0x3F, 16.2);
Ho determinato questo indirizzo usando lo schizzo "I2C address address scanner" descritto in.
Ho lanciato la shell IDE di Arduino, dall'articolo ho copiato il codice del programma e incollato la sua finestra IDE di Arduino.
Ho iniziato la compilazione, quindi ho scritto il codice sulla scheda UNO Arduino, alla quale erano collegate la scheda GY-BMP280-3.3 e il display LDC con il modulo di interfaccia I2C. Quindi nel monitor della porta seriale ho ottenuto il seguente risultato. Il mio modulo di interfaccia ha un indirizzo di 0x3F.
Quarta tappa. Verifica del sensore di temperatura DS18b20. Lo colleghiamo come segue.
La libreria OneWire Arduino per lavorare con il sensore di temperatura DS18b20 è già installata.
Aprire il campione DS18x20_Temperature, compilare, caricare, guardare il risultato della misurazione nel monitor della porta seriale. Se tutto funziona, vai al passaggio successivo.
Quinta tappa. montaggio casa stazioni meteorologiche su GY-BMP280-3.3 e Ds18b20.
Montiamo il dispositivo secondo lo schema:
Ho ricevuto il codice per il dispositivo combinando tutti gli esempi in uno e impostando l'output sullo schermo LDC. Ecco cosa ho ottenuto:
// Uncomment per un'implementazione software del bus I2C: //
// #define pin_SW_SDA 3 // Assegna qualsiasi pin Arduino affinché funzioni come una linea SDA del bus software I2C.
// #define pin_SW_SCL 9 // Assegna qualsiasi pin Arduino per operare come linea SCL sul bus software I2C.
// Uncomment per compatibilità con la maggior parte delle schede: //
#include
#include // La libreria iarduino utilizzerà i metodi e le funzioni della libreria Wire.
#include // Libreria per il funzionamento del tipo LDC 1602 sul bus I2C
//
#include // Collega la libreria iarduino_Pressure_BMP per funzionare con BMP180 o BMP280.
sensore iarduino_Pressure_BMP (0x76); // Dichiara un oggetto sensore per lavorare con un sensore di pressione usando le funzioni e i metodi della libreria iarduino_Pressure_BMP.
LiquidCrystal_I2C lcd (0x3F, 16.2);
OneWire ds (10);
void setup () {
lcd.init ();
lcd.backlight ();
Serial.begin (9600); // Avvia il trasferimento dei dati al monitor della porta seriale a 9600 baud.
ritardo (1000); // Stiamo aspettando il completamento dei transitori quando si applica il potere
sensor.begin (73); // Inizia a lavorare con il sensore. L'altitudine attuale sarà presa come 73 m. - l'altezza della città di Buzuluk sul livello del mare
} //
void loop () {
// Leggi i dati e visualizza: temperatura in ° C, pressione in mm. rt., cambia in altezza rispetto a quanto specificato nella funzione di inizio (default 0 metri).
lcd.setCursor (0,0); // definisce il punto di uscita "P =" sul LDC
lcd.print ("P =");
lcd.print (sensor.pressure / 1000.3); // divide il valore di P emesso da BMP280 per 1000 e imposta l'output di 3 decimali
lcd.setCursor (12.0); // definisce il punto di uscita "kPa" sul LDC
lcd.print ("kPa");
lcd.setCursor (0,1);
lcd.print ("T =");
lcd.print (sensor.temperature, 1); // imposta l'output di 1 decimale
lcd.setCursor (6.1);
// lcd.print ("C");
// lcd.setCursor (9,1);
// lcd.print ("H =");
// lcd.print (sensor.altitude, 1);
if (sensor.read (1)) {Serial.println ((String) "CEHCOP BMP" + sensor.type + ": \ t P =" + sensor.pressure + "\ tMM.PT.CT, \ t T = "+ sensor.temperature +" * C, \ t \ t B = "+ sensor.altitude +" M. ");}
else {Serial.println ("HET OTBETA OT CEHCOPA");}
// Leggi i dati e visualizza: temperatura in ° C e pressione in Pa, pressione in mm. rt., cambia in altezza rispetto a quanto specificato nella funzione di inizio (default 0 metri).
if (sensor.read (2)) {Serial.println ((String) "CEHCOP BMP" + sensor.type + ": \ t P =" + sensor.pressure + "\ tPa, \ t \ t T =" + sensor.temperature + "* C, \ t \ t B =" + sensor.altitude + "M.");}
else {Serial.println ("HET OTBETA OT CEHCOPA");}
byte i;
byte presente = 0;
byte type_s;
dati byte [12];
byte addr [8];
galleggiante celsius, fahrenheit;
if (! ds.search (addr)) {
Serial.println ("Niente più indirizzi.");
Serial.println ();
ds.reset_search ();
ritardo (250);
tornare;
}
Serial.print ("ROM =");
per (i = 0; i & lt; 8; i ++) {
Serial.write ('');
Serial.print (addr [i], HEX);
}
if (OneWire :: crc8 (addr, 7)! = addr [7]) {
Serial.println ("CRC non è valido!");
tornare;
}
Serial.println ();
// il primo byte ROM indica quale chip
switch (addr [0]) {
caso 0x10:
Serial.println ("Chip = DS18S20"); // o vecchio DS1820
type_s = 1;
break;
caso 0x28:
Serial.println ("Chip = DS18B20");
type_s = 0;
break;
caso 0x22:
Serial.println ("Chip = DS1822");
type_s = 0;
break;
DEFAULT:
Serial.println ("Il dispositivo non è un dispositivo della famiglia DS18x20.");
tornare;
}
ds.reset ();
ds.select (addr);
ds.write (0x44, 1); // avvia la conversione, con il parassita acceso alla fine
ritardo (1000); // forse bastano 750ms, forse no
// qui potremmo fare un ds.depower (), ma il reset ci penserà.
present = ds.reset ();
ds.select (addr);
ds.write (0xBE); // Leggi Scratchpad
Serial.print ("Data =");
Serial.print (presente, HEX);
Serial.print ("");
per (i = 0; i & lt; 9; i ++) {// abbiamo bisogno di 9 byte
data [i] = ds.read ();
Serial.print (data [i], HEX);
Serial.print ("");
}
Serial.print ("CRC =");
Serial.print (OneWire :: crc8 (data, 8), HEX);
Serial.println ();
// Converti i dati in temperatura effettiva
// poiché il risultato è un numero intero con segno a 16 bit, dovrebbe
// essere memorizzato in un tipo "int16_t", che è sempre 16 bit
// anche se compilato su un processore a 32 bit.
int16_t raw = (data [1] & lt; & lt; 8) | dati [0];
if (type_s) {
raw = raw & lt; & lt; 3; // Risoluzione predefinita a 9 bit
if (data [7] == 0x10) {
// "conteggio rimanente" fornisce una risoluzione completa di 12 bit
raw = (raw & amp; 0xFFF0) + 12 - data [6];
}
} altro {
byte cfg = (data [4] & amp; 0x60);
// a una risoluzione inferiore, i bit bassi sono indefiniti, quindi azzeriamoli
if (cfg == 0x00) raw = raw & amp; ~ 7; // Risoluzione a 9 bit, 93.75 ms
altrimenti if (cfg == 0x20) raw = raw & amp; ~ 3; // Res 10 bit, 187,5 ms
altrimenti if (cfg == 0x40) raw = raw & amp; ~ 1; // Res. 11 bit, 375 ms
//// il valore predefinito è risoluzione 12 bit, tempo di conversione 750 ms
}
celsius = (float) raw / 16.0;
fahrenheit = centigrado * 1,8 + 32,0;
Serial.print ("Temperature =");
Serial.print (celsius);
Serial.print ("Celsius,");
Serial.print (fahrenheit);
Serial.println ("Fahrenheit");
lcd.setCursor (8.1); // definisce il punto di uscita "Tds =" sul LDC
lcd.print ("Tds =");
lcd.print (celsius, 1);
ritardo (3000);
}Ecco cosa ho ottenuto:
La scheda GY-BMP280-3.3 emette pressione in pascal, il che non è molto conveniente. Non sono riuscito a risolvere il problema di come rendere i dati di pressione di uscita della scheda GY-BMP280-3.3 in kilopascal. Ho risolto questo problema nella linea di uscita del display LDC.
lcd.print (sensor.pressure / 1000.3); // divide il valore di P emesso da BMP280 per 1000 e imposta l'output di 3 cifre decimali
La scheda GY-BMP280-3.3 fornisce anche valori di altitudine.
sensor.begin (73); // Inizia a lavorare con il sensore. L'altitudine attuale sarà presa come 73 m. - l'altezza della città di Buzuluk sul livello del mare
Se ti rilasserai in mare e cambierai "sensor.begin (73);" su "sensor.begin (0);" nel codice, quindi compilare e salvare il programma sulla stazione meteorologica domestica su GY-BMP280-3.3 e Ds18b20, e creare un'altezza sul display LDC, si otterrà anche un altimetro.
// lcd.setCursor (9,1);
// lcd.print ("H =");
// lcd.print (sensor.altitude, 1); // Stampa i valori di altezza in metri con un decimale
L'alimentazione è fornita al circuito nella mia versione tramite un cavo USB. È possibile utilizzare un convertitore di impulsi boost a bassa tensione da 5 V / 600 mA e la stazione meteorologica diventerà portatile. Questo tipo di alimentatore è ben descritto in articolo.
Compilazione riuscita!