Stazione meteorologica su Arduino con esempio di grafico della pressione. Stazione meteo domestica su Arduino e invio dati a "Monitoraggio Persone"

16.06.2019 Consiglio

Il progetto della stazione meteorologica dal libro di V. Petin “Progetti utilizzando Controllore Arduino"2a edizione (progetto 5 appendice 2). L'ambiente utilizzato IDE di Arduino 1.8.5 su Windows 10.
È stato generato un errore durante l'esecuzione dello schizzo

In Internet si possono scaricare librerie per Arduino che hanno gli stessi nomi ma contenuti diversi. Lo schizzo potrebbe non funzionare se stai utilizzando la libreria sbagliata. A quanto pare mi sono imbattuto nelle librerie sbagliate. Ho aggiunto al progetto un sensore BMP180 per la misurazione pressione atmosferica e rielaborato lo schizzo.

Schema di collegamento

Scansione degli indirizzi

Per prima cosa connettiti a Sensore Arduino Indicatore BMP180 e LCD1602. Compila lo schizzo dello scanner I2C ed eseguilo per determinare gli indirizzi dei dispositivi sul bus I2C.

Ogni 5 secondi il programma esegue la scansione dei dispositivi e rilascia gli indirizzi sulla porta COM. Ho trovato due dispositivi con indirizzi 0x3F e 0x77. BMP180 per impostazione predefinita ha l'indirizzo 0x77, il che significa che l'indicatore LCD ha l'indirizzo 0x3F.
In alcuni circuiti i libri vengono confusi con i luoghi a cui sono collegati i segnali SDA e SCL Scheda Arduino. Dovrebbe essere: SDA - in A4, SCL - in A5. Se il modulo BMP180 ha cinque pin, al pin VIN vengono forniti +5 Volt.

Schema elettrico

Ora assemblare completamente il circuito. Ho utilizzato un LED RGB a catodo comune montato sulla scheda insieme a resistori da 150 ohm. Il catodo comune è collegato al pin GND, i restanti pin sono collegati secondo lo schema. Non è necessario apportare modifiche allo schizzo, poiché la luminosità dei LED cambia secondo una legge ciclica.
Il diagramma mostra la connessione LED RGB con un anodo comune, come nel libro.
Se sullo schermo LCD1602 non sono visibili caratteri, ruotare il controllo della luminosità. La spia consuma abbastanza corrente elevata, quindi usa un alimentatore con una corrente di almeno 2 A. Ho usato Hub USB con alimentatore esterno da 2 A.
Il circuito utilizzava una campana piezoelettrica ZP-22. La resistenza collegata al campanello è di 100 ohm. La frequenza del suono può essere modificata nel programma. Ho scelto una frequenza di 1000 Hz. Se trovi un cicalino con una frequenza sonora fissa, puoi accenderlo e spegnerlo semplicemente applicando e rimuovendo la tensione, come un normale LED. Quando inizia lo schizzo, un breve segnale sonoro. È possibile abilitare la segnalazione periodica mentre il programma è in esecuzione rimuovendo il commento dalla riga //bzz(100); nello schizzo.
Nel progetto ho utilizzato un sensore DHT11 sotto forma di modulo con una resistenza da 4,7 kOhm già montata. La resistenza può variare da 4,7 a 10 kOhm.
Collegare il pin Vcc del modulo orologio DS1302 al bus +5 Volt. In questo modo ridurrai il consumo della batteria, essenzialmente funzionerà solo quando l'Arduino è spento.

Programma (schizzo)

La libreria bmp085 viene utilizzata per la manutenzione del BMP180. Il valore della pressione dipende dall'altitudine della zona. Per il corretto valore della pressione atmosferica è necessario selezionare l'altitudine. Per fare ciò, modifica la riga dps.init(MODE_STANDARD, 10000, true); La mia altezza è di 100 m (10000 cm). Il frammento del calcolo della pressione è tratto dall'esempio BMP085_test2.ino della libreria bmp085.

Schizzo meteo_P

#includere
#includere
#includere
#include "DHT.h"
#includere
BMP085 dps = BMP085();
lungo Pressione = 0, Altitudine = 0;
tempo lungo senza segno1 = 0;

#definire il PIN DHTP 10
#define DHTTYPE 11 // 11 - DHT11, 22 - DHT22
DHT dht(DHTPIN, TIPO DHT);

intero kCePin = 4; // RST DS1302
int kIoPin = 3; // Dati DS1302
int kSclkPin = 2; //CLK DS1302
DS1302 rtc(kCePin, kIoPin, kSclkPin);

int REDpin = 9;
int PIN VERDE = 6;
int BLUpin = 11;

LiquidCrystal_I2C lcd(0x3f, 16, 2); // inserisci il tuo indirizzo 0x20...0xff indirizzo
memTime lungo senza segno;
int bzzPin = 8;

void HumTempRead() (
float ronzio = dht.readHumidity();
float temp = dht.readTemperature();
if (isnan(ronzio) || isnan(temp)) (
Serial.println("Impossibile leggere dal sensore DHT!");
lcd.setCursore(0, 1);
lcd.print("H=--% T=---");
lcd.setCursore(11, 1);
lcd.print((carattere)223);
lcd.setCursore(12, 1);
lcd.print("C ");
) altro (
lcd.setCursore(0, 1);
lcd.print("H=");
lcd.setCursore(2, 1);
lcd.print(ronzio);
lcd.setCursore(4, 1);
lcd.print("% T="+");
lcd.setCursore(9, 1);
lcd.print(temp);
lcd.setCursore(11, 1);
lcd.print((carattere)223);
lcd.setCursore(12, 1);
lcd.print("C ") ;
}
}

void setup_bzz() (
modalità pin(bzzPin, USCITA);
}

void bzz(int _bzzTime) (
tono(bzzPin, 1000, _bzzTime); // frequenza 1000 Hz
}

configurazione nulla() (
Serial.begin(9600);
Filo.begin();
ritardo(1000);

dps.init(MODE_STANDARD, 10000, vero); // 100 metri (altezza sul livello del mare in cm)

dht.begin();
setup_bzz();
bzz(100);

LCD.init();
lcd.retroilluminazione();
lcd.casa();
// lcd.setCursor(0, 0);

rtc.halt(falso);
rtc.writeProtect(falso);

//rtc.setDOW(VENERDI); // Imposta il giorno della settimana su VENERDI imposta il giorno della settimana
//rtc.setTime(4, 58, 0); //Impostato il tempo alle 12:00:00 (formato 24 ore) impostare l'ora
//rtc.setDate(6, 8, 2010); // Imposta la data al 6 agosto 2010 imposta la data (giorno, mese, anno)
}

lcd.setCursore(8, 0);
lcd.print(rtc.getTimeStr());

if ((millis() - memTime > 2000) o (millis()< memTime)) { // DHT11/22 1 time each 2 seconds
HumTempRead();
memTime = millis();
}
ritardo(100);

if (((millis() - tempo1) / 1000.0) >= 1.0) (
dps.calcTrueTemperature();
tempo1 = milli();
}
dps.getPressione(&Pressione);
Serial.print(" Pressione(Pa):");
Serial.println(Pressione);

lungo p2;
intero pi greco;
p2 = (Pressione / 133,3224); // Pa in mmHg.
pi = tronca(p2); // scartando la parte frazionaria del numero

lcd.setCursore(0, 0);
lcd.print("P=");
lcd.setCursore(2, 0);
lcd.print(pi); // uscita bancomat. pressione sul display LCD
lcd.setCursore(5, 0);
lcd.print("mm");
// ritardo(3000);
//bzz(100); // rimuovi il commento se vuoi ascoltare i segnali
{
for (int valore = 0 ; valore<= 255; value += 1) {
analogWrite(REDpin, valore);
analogWrite(GREENpin, 255 - valore);
analogWrite(BLUEpin, 255);
ritardo(5);
}

for (int valore = 0; valore<= 255; value += 1) {
analogWrite(REDpin, 255);
analogWrite(GREENpin, valore);
analogWrite(BLUEpin, 255 - valore);
ritardo(5);
}

for (int valore = 0; valore<= 255; value += 1) {
analogWrite(REDpin, 255 - valore);
analogWrite(GREENpin, 255);
analogWrite(pinBLU, valore);
ritardo(5);
}
}
}

Nel Catalogo file è possibile scaricare lo schizzo e le librerie utilizzate nel progetto.

Importa le librerie LiquidCrystal_I2C.zip, bmp085.zip, DS1302.zip e DHT.zip dall'archivio scaricato nell'IDE di Arduino. Vai al menù Schizzo Collega la libreria Aggiungi libreria .ZIP... e nella finestra seleziona l'archivio zip della libreria.
Carica lo schizzo meteo_P. Sostituisci l'indirizzo LCD1602 nello schizzo con il valore ottenuto scansionando il bus I2C. Compila ed esegui lo schizzo.
Se lo schizzo funziona, apri il monitor della porta e visualizza i messaggi visualizzati. Regolare l'altezza nell'istruzione dps.init(MODE_STANDARD, 10000 , true); per ottenere valori di pressione reali.
Imposta l'orologio. Decommentare la riga //rtc.setTime(4, 58, 0); e tra parentesi indicare l'ora corrente (ore, minuti e secondi separati da virgole) e ricaricare lo schizzo nel controller. Dopo aver impostato il tempo, commenta nuovamente questa riga ed esegui nuovamente lo schizzo.
Se l'illuminazione notturna ti infastidisce, puoi regolarla modificando la lunghezza del ritardo nei cicli for alla fine dello schizzo. Con ritardo(2); il ciclo dura 2-3 secondi, con ritardo(5); — da 4 a 5 secondi, con ritardo(30); - fino a 15-16 secondi. Le informazioni sull'indicatore verranno aggiornate con lo stesso intervallo.
Quando si utilizza la stazione meteorologica in modo autonomo, ad es. senza collegarsi alla porta USB del computer, commentare le righe dello sketch con la dicitura Serial... per disabilitare l'output delle informazioni sul monitor della porta COM.

PS. Nello schizzo del libro e negli esempi per la libreria DHT è indicata la linea di definizione #definire DHTTYPE DHT11. Lo schizzo si avvia, ma si blocca dopo alcune ore. L'orologio si ferma, il display non cambia. Nel monitor della porta viene visualizzato un messaggio vago, che contiene un collegamento a dht.
In questa riga ho rimosso le lettere DHT, cioè fatto #definire DHTTYPE 11. Successivamente, lo schizzo ha iniziato a funzionare stabilmente.

Articolo aggiornato il 25 giugno 2018

Risorse utilizzate
1. Petin V.A. Progetti che utilizzano il controller Arduino (Elettronica) 2a edizione, San Pietroburgo. BHV-Pietroburgo, 2015 464 pag.
2. Petin V. A., Binyakovsky A. A. Enciclopedia pratica di Arduino. - M., DMK Press, 2017. - 152 pag.
3. http://arduinolearning.com/code/i2c-scanner.php
4. http://arduino.ru/forum/programmirovanie/ds1302lcd1602
5. http://robotehnika18.rf/how-to-connect-lcd-1602-to-arduino-via-i2c/
6. esempio BMP085_test2.ino dalla libreria bmp085.zip
7. http://proginfo.ru/round/
8. http://homes-smart.ru/index.php?id=14&Itemid=149&option=com_content&view=article
9. http://iarduino.ru/lib/datasheet%20bmp180.pdf
10. http://it-donnet.ru/hd44780_dht11_arduino/

Come la maggior parte delle persone che lavorano, perseguire i propri progetti occupa l’unico tempo libero che ti rimane. Ecco perché non creavo nulla da molto tempo e non vedevo l’ora di fare qualcosa. Stranamente, questa opportunità è apparsa all'università. È settembre fuori dalla finestra, quarto anno e imminenti corsi sulla progettazione di circuiti. Ci è stato detto che i corsi potevano essere svolti in due varianti: cartacea e hardware.

Per 5 anni, i corsi cartacei nella nostra università sono stati svolti secondo il principio "prendi quelli vecchi e mettili insieme". Questo approccio non mi andava bene a causa della sua routine, quindi ho scelto immediatamente i corsi sull'hardware. Il microcontrollore Arduino è stato proposto come cuore del corso per la sua facilità di apprendimento. Dopo aver determinato il tipo di corso, rimaneva un'altra domanda: cosa si dovrebbe fare esattamente. Poiché non avevo esperienza nella programmazione di microcontrollori, ho subito aperto Google e ho iniziato a studiare progetti esistenti. Esistono molti progetti, alcuni abbastanza semplici, altri ingegnosi (scanner 3D, ad esempio), ma la stragrande maggioranza non ha alcuna applicazione pratica. E volevo solo qualcosa che non restasse sullo scaffale a raccogliere polvere. Dopo un'escursione di mezz'ora nel mondo di Arduino, mi sono interessato al tema delle stazioni meteorologiche domestiche e i progetti non mi sono sembrati molto difficili da realizzare (che è ciò che ha attirato maggiormente il nuovo arrivato).

È così che è stato scelto l'argomento del corso e col tempo non sembravano esserci problemi.

Selezione dei componenti

Guardando diversi progetti, mi sono reso conto che un Nano o anche un Pro Mini mi sarebbero bastati, ma ho comunque scelto Arduino Uno nella speranza di voler programmare per Arduino e di realizzare altri progetti in futuro. Non avevo mai tenuto in mano un saldatore prima, quindi per uno sviluppo più semplice ho deciso di acquistare anche Sensor Shield v4.

Più dettagli

La scheda facilita il collegamento rapido di sensori, moduli, servomotori, interfacce Seriali e I2C, inoltre visualizza tutte le porte del controller del form factor Duemilanova/Uno (collegabile anche alla serie mega, ma con limitazioni e conseguenti conseguenze) . Supporta altri scudi sopra di sé.

Ho scelto i seguenti sensori come fonti per i dati meteorologici:

Ho deciso per i sensori. Ma cosa fare con i dati provenienti dai sensori? Ho deciso di esporlo. Volevo una foto a colori, quindi ho scartato subito le soluzioni monocromatiche. Dopo diversi minuti di ricerca, è stato selezionato il display TFT da 1,8 pollici ST7735.

Più dettagli

Poiché il display utilizza un protocollo SPI a 4 fili per la comunicazione e dispone di un proprio frame buffer indirizzabile ai pixel, può essere utilizzato con qualsiasi tipo di microcontrollore. Il display da 1,8 pollici ha 128x160 pixel a colori. C'è anche uno slot per schede microSD, quindi puoi caricare facilmente immagini bitmap a colori dal file system della scheda microSD FAT16/FAT32.

Caratteristiche:

Diagonale display: 1,8 pollici, risoluzione 128x160 pixel, colore a 18 bit (262.144 colori)
Controller con indirizzamento pixel integrato del buffer di memoria video
Slot microSD integrato: utilizza più di 2 linee digitali
Compatibile con 3,3 e 5 V
Dimensioni: 34 mm x 56 mm x 6,5 m

Programmazione del controller Arduino

Dopo aver deciso i componenti per la stazione meteorologica, inizieremo a programmare il controller. L'IDE Arduino è stato utilizzato per eseguire il flashing del firmware Arduino. Utilizzate anche le librerie di Adafruit.

Prima di passare allo schizzo, diamo un'occhiata alle funzionalità:

Le letture vengono rilevate dai sensori ogni 10 secondi e sullo schermo vengono aggiornati solo gli indicatori che sono cambiati rispetto alla misurazione precedente
Trasferimento dati implementato tramite porta COM

Schizzo

#includere // libreria per la comunicazione con dispositivi I2C #include // Libreria principale per tutti i sensori #include // libreria per BMP180 #include // Libreria grafica principale #include // Libreria specifica dell'hardware #include // libreria per la comunicazione con dispositivi SPI #include "dht.h" // libreria per DHT #define DHT22_PIN 2 // collega il pin dati di DHT22 a 2 pin digitali #define TFT_CS 10 // collega il pin CS di TFT a 10 pin digitali #define TFT_RST 9 // collega il pin RST di TFT al pin digitale 9 // puoi anche collegarlo al reset di Arduino // in tal caso, imposta questo pin #define su 0! #define TFT_DC 8 // collega il pin DC di TFT a 8 pin digitali Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST); // inizializza TFT #define TFT_SCLK 13 // collega il pin SCLK di TFT a 13 pin digitali #define TFT_MOSI 11 // collega il pin MOSI di TFT a 11 pin digitali dht DHT; Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10085); //inizializza BMP180 int bmpFlag = 0; struct ( uint32_t totale; uint32_t ok; uint32_t crc_error; uint32_t time_out; uint32_t connect; uint32_t ack_l; uint32_t ack_h; uint32_t sconosciuto; ) stat = ( 0,0,0,0,0,0,0,0); // struttura per lo stato del dht void setup(void) ( Serial.begin(9600); Serial.println("Meteo Test"); Serial.println(""); if(!bmp.begin()) // controlla la connessione per BMP180 ( Serial.print("Ooops, nessun BMP180 rilevato... Controlla il cablaggio o l'ADDR I2C!"); bmpFlag = 1; ) tft.initR(INITR_BLACKTAB); // Inizializza TFT e riempi con il colore nero tft.fillScreen (ST7735_BLACK); tft.setRotation(tft.getRotation() + 1); tft.setTextSize(1.5); delay(500); // ritardo per garantire che TFT sia stato inizializzato) // ultimi dati misurati float oldTemperature = 0 , oldAltitude = 0, oldPressure = 0, oldDHTHumidity = 0, oldDHTTemperature; bool wasUpdate = false; void loop(void) ( if(Serial.available() > 0) // abbiamo i dati sulla porta seriale ( Serial.read(); // legge byte dalla porta seriale e invia gli ultimi dati misurati printValue("Pressure", oldPressure , " hPa", false); printValue("Temperatura", oldTemperatura, " C", false); printValue("Altitudine", oldAltitude, " m", false); printValue("Umidità", oldDHTHUmidità, "%", false); printValue("DHT_temperature", oldDHTTemperature, " C", false); Serial.println("END_TRANSMISSION"); ) evento sensors_event_t; temperatura float, altitudine; if(bmpFlag == 0)( bmp.getEvent(&event) ; // ottieni dati da BMP180 if (event.pressione) ( bmp.getTemperature(&temperatura); float seaLevelPressure = SENSORS_PRESSURE_SEALEVELHPA; Altitudine = bmp.pressioneToAltitude(seaLevelPressure, evento.pressione, temperatura); ) else ( Serial.println("Sensore error"); ) ) uint32_t start = micros(); int chk = DHT.read22(DHT22_PIN); // ottiene dati da DHT22 uint32_t stop = micros(); stat.total++; switch (chk) // controlla lo stato di DHT22 ( caso DHTLIB_OK: stat.ok++; rottura; caso DHTLIB_ERROR_CHECKSUM: stat.crc_error++; Serial.print("Errore di checksum,\t"); rottura; caso DHTLIB_ERROR_TIMEOUT: stat.time_out++; Serial.print("Errore di timeout,\t"); rottura; caso DHTLIB_ERROR_CONNECT: stat.connect++; Serial.print("Errore di connessione,\t"); rottura; caso DHTLIB_ERROR_ACK_L: stat.ack_l++; Serial.print("Errore riconoscimento basso,\t"); rottura; caso DHTLIB_ERROR_ACK_H: stat.ack_h++; Serial.print("Errore riconoscimento alto,\t"); rottura; predefinito: stat.sconosciuto++; Serial.print("Errore sconosciuto,\t"); rottura; ) se(bmpFlag! = 0 || !event.pressione) // aggiorna i dati (tft.fillRect(0, 30, 160, 6, ST7735_BLACK); tft.setCursor(0, 30); tft.setTextColor(ST7735_RED); printValue("ERRORE INIZIALIZZAZIONE BMP", 0 , "", true); ) else ( if(event.pressione != oldPressure) ( tft.fillRect(0, 30, 160, 7, ST7735_BLACK); tft.setCursor(0, 30); tft.setTextColor(ST7735_RED) ; printValue("Pressione", evento.pressione, " hPa", true); oldPressure = evento.pressione; wasUpdate = true; ) if(temperatura!= oldTemperature) ( tft.fillRect(0, 38, 160, 7, ST7735_BLACK ); tft.setCursor(0, 38); tft.setTextColor(ST7735_WHITE); printValue("Temperatura", temperatura, " C", true); oldTemperature = temperatura; wasUpdate = true; ) if(altitudine != oldAltitude) ( tft.fillRect(0, 46, 160, 7, ST7735_BLACK); tft.setCursor(0, 46); tft.setTextColor(ST7735_BLUE); printValue("Altitudine", altitudine, " m", true); oldAltitude = altitudine; wasUpdate = true; ) ) if(DHT.humidity != oldDHTHumidity) ( tft.fillRect(0, 54, 160, 7, ST7735_BLACK); tft.setCursor(0, 54); tft.setTextColor(ST7735_GREEN); printValue("Umidità", DHT.umidità, "%", true); oldDHTHumidità = DHT.umidità; wasUpdate = vero; ) if(DHT.temperatura != oldDHTTemperatura) ( tft.fillRect(0, 80, 160, 7, ST7735_BLACK); tft.setCursor(0, 80); tft.setTextColor(ST7735_YELLOW); printValue("DHT_temperatura", DHT. temperatura, " C", true); oldDHTTemperature = DHT.temperatura; wasUpdate = true; ) if(wasUpdate) ( Serial.println("END_TRANSMISSION"); ) wasUpdate = false; ritardo(10000); ) void printValue(char* titolo, doppio valore, char* misura, bool tftPrint) ( if(tftPrint) // stampa i dati su TFT ( tft.print(titolo); tft.print(": "); tft.print( valore); tft.println(misura); ) Serial.print(titolo); // invia i dati alla porta seriale Serial.print(": "); Serial.print(valore); Serial.println(misura); )

È ora di assemblare il corpo

La condizione principale del corso era un prototipo funzionante in una forma presentabile. Pertanto, ho dovuto acquistare una custodia e, armato di una lima, inserire in qualche modo la stazione meteorologica nella custodia.

La custodia è stata acquistata da un negozio di elettronica radiofonica locale.

Telaio

(La custodia nella foto è leggermente diversa. Ho un coperchio trasparente)

Quindi, utilizzando una lima, sono stati praticati dei fori per l'uscita dei sensori e l'alimentazione. Ho deciso di spostare i sensori all'esterno, perché mentre testavo il sistema senza custodia, ho notato che la parte posteriore dello schermo diventava molto calda, influenzando la temperatura all'interno della custodia.

Alloggiamento con aperture per sensori e alimentazione

Dato che ho dovuto saldare le gambe a 2 sensori e ho bruciato la traccia su uno di essi, ho deciso di non sfidare la sorte e di non saldare i fili ai sensori (mi eserciterò su qualcos'altro), e affinché la connessione per essere più o meno affidabile ho deciso di riavvolgere il nastro isolante.

Il sistema prima di essere “inserito” nell’alloggiamento

Dato che il case è molto più grande di quello dell'Arduino (non ce n'era uno più piccolo), ho dovuto inventare un supporto in modo che la scheda non si muovesse all'interno del case. Inoltre, dalla schiuma è stata ritagliata una figura e in essa c'era un rettangolo per lo schermo per nascondere l'interno della custodia. Non avevo la supercolla a portata di mano, quindi ho dovuto usare il nastro biadesivo.

Miracolo-yuda pesce-balena

Avvitare il coperchio, collegare l'alimentazione e attendere.

Stazione meteorologica completata nell'edificio

Dopo aver visualizzato i risultati sullo schermo, identifichiamo uno spiacevole errore nella misurazione dell'umidità: DHT22 produce diligentemente il valore 99,90% (1,00% è estremamente raro). Cominciamo a capire qual è il problema. La prima cosa che facciamo è guardare l'output dei valori sulla porta COM. Si sente bene. Dopo diverse ricariche, smontaggi e rimontaggi della custodia, mi viene in mente l'idea di cercare la risposta su Google. Come previsto, la Google russa non ha detto nulla di utile. OK. Iniziamo la ricerca in inglese e su uno dei forum incontriamo ragazzi con un problema simile. Le prime quattro pagine di discussione non danno nulla di utile, ma nella quinta pagina troviamo la risposta alla nostra domanda:

I sensori di umidità possono essere facilmente influenzati dai gas sbagliati o da un'esposizione molto prolungata a un'umidità elevata IIRC. Nella scheda tecnica c'è una procedura su come “resettare” il sensore, potresti provarla.

L'unica domanda rimasta era quando e come sono riuscito a danneggiare DHT22. Ma si stava avvicinando il momento di seguire il corso e così ho lasciato la soluzione a questo problema per dopo.

Epilogo

Il corso è stato superato. La stazione meteorologica è stata rinviata a tempo indeterminato fino alla chiusura di tutti gli sterili presso l'università. Tuttavia, siamo dovuti tornare alla stazione meteorologica prima di quanto pensassi. È successo così che a metà novembre ho cambiato posto di lavoro e nel nuovo team ho incontrato persone interessate alla piattaforma Arduino e simili. Pertanto, il mio interesse per questa piattaforma, senza avere il tempo di calmarmi, è divampato di nuovo. Ho tirato fuori la mia stazione meteorologica, l'ho collegata al computer e mi sono ricordato che avevo implementato il trasferimento dei dati da Arduino tramite la porta COM. E poi mi è venuta l'idea di scrivere un programma che riceva i dati tramite la porta COM da Arduino e li trasmetta al monitoraggio pubblico, ma questa è una storia completamente diversa.

Mi piacerebbe anche avere dei sensori wireless e comunque implementare una stazione meteo su Arduino Pro Mini. Ho quindi ordinato 4 Arduino Pro Mini con alimentatore da 3,3V, 4 moduli radio nRF24L01+ e alcuni sensori aggiuntivi, di cui cercherò di parlare anche la prossima volta. Nel frattempo aspetto il pacco, è previsto il collegamento di un orologio in tempo reale per poter salvare l'orario di aggiornamento dei dati e i dati stessi su una scheda microSD, a condizione che non ci sia connessione al client tramite la porta COM.

Puoi aiutare e trasferire alcuni fondi per lo sviluppo del sito

Un giorno, mentre passeggiavo per la città, vidi che aveva aperto un nuovo negozio di elettronica radiofonica. Entrando ho trovato un gran numero di Shield per Arduino perchè... Avevo a casa un Arduino Uno e un Arduino Nano e mi è venuta subito l'idea di giocare con i trasmettitori di segnale a distanza. Ho deciso di acquistare il trasmettitore e il ricevitore più economici a 433 MHz:

Trasmettitore di segnale.

Ricevitore di segnale.

Dopo aver registrato un semplice schizzo di trasmissione dati (un esempio tratto da qui), si è scoperto che i dispositivi di trasmissione possono essere abbastanza adatti per trasmettere dati semplici, come temperatura, umidità.

Il trasmettitore ha le seguenti caratteristiche:
1. Modello: MX-FS-03V
2. Portata (a seconda della presenza di oggetti bloccanti): 20-200 metri
3. Tensione operativa: 3,5 -12 V
4. Dimensioni del modulo: 19 * 19 mm
5. Modulazione del segnale: AM
6. Potenza del trasmettitore: 10 mW
7. Frequenza: 433 MHz
8. Lunghezza richiesta dell'antenna esterna: 25 cm
9. Facile da collegare (solo tre fili): DATI; VCC; Terra.

Caratteristiche del modulo ricevente:
1. Tensione operativa: CC 5 V
2. Corrente: 4 mA
3. Frequenza operativa: 433,92 MHz
4. Sensibilità: - 105 dB
5. Dimensioni del modulo: 30 * 14 * 7 mm
6. Antenna esterna richiesta: 32 cm.

Internet afferma che il raggio di trasmissione delle informazioni a 2Kb/sec può raggiungere fino a 150 m. Non l'ho controllato personalmente, ma in un bilocale è accettato ovunque.

Hardware per stazione meteo domestica

Dopo diversi esperimenti, ho deciso di collegare un sensore di temperatura, umidità e trasmettitore ad Arduino Nano.

Il sensore di temperatura DS18D20 è collegato ad Arduino come segue:

1) GND al meno del microcontrollore.
2) DQ tramite una resistenza di pull-up a terra e al pin D2 di Arduino
3) Vdd a +5V.

Il modulo trasmettitore MX-FS - 03V è alimentato a 5 Volt, l'uscita dati (ADATA) è collegata al pin D13.

Ho collegato un display LCD e un barometro BMP085 ad Arduino Uno.

Schema di collegamento ad Arduino Uno

Il ricevitore del segnale è collegato al pin D10.

Modulo BMP085 - sensore digitale di pressione atmosferica. Il sensore consente di misurare temperatura, pressione e altitudine sul livello del mare. Interfaccia di connessione: I2C. Tensione di alimentazione del sensore 1,8-3,6 V

Il modulo si collega ad Arduino allo stesso modo degli altri dispositivi I2C:

VCC-VCC (3,3 V);
TERRA-TERRA;
SCL - al pin analogico 5;
SDA - al pin analogico 4.

Costo molto basso
Alimentazione e I/O 3-5 V
Determinazione dell'umidità 20-80% con precisione del 5%.
Rilevamento della temperatura 0-50 gradi. con una precisione del 2%.
Frequenza di polling non superiore a 1 Hz (non più di una volta ogni 1 secondo)
Dimensioni 15,5 mm x 12 mm x 5,5 mm
4 pin con spaziatura tra i pin 0,1".

DHT ha 4 pin:

Vcc (alimentazione 3-5V)
Uscita dati: uscita dati
Non usato
Generale

Si collega al D8 di Arduino.

Parte software di una stazione meteorologica domestica

Il modulo trasmittente misura e trasmette la temperatura ogni 10 minuti.

Di seguito il programma:

/* Sketch versione 1.0 Invia la temperatura ogni 10 minuti. */ #include #include #include #define ONE_WIRE_BUS 2 //Pin per collegare il sensore Dallas OneWire oneWire(ONE_WIRE_BUS); Sensori di temperatura Dallas (&oneWire); Indirizzo dispositivo all'interno del termometro; void setup(void) ( //Serial.begin(9600); vw_set_ptt_inverted(true); // Necessario per DR3100 vw_setup(2000); // Imposta la velocità di trasmissione (bit/s) sensori.begin(); if (! sensori .getAddress(insideThermometer, 0)); printAddress(insideThermometer); sensori.setResolution(insideThermometer, 9); ) void printTemperature(DeviceAddress deviceAddress) ( float tempC = sensori.getTempC(deviceAddress); //Serial.print("Temp C : "); //Serial.println(tempC); //Formazione dei dati per l'invio int number = tempC; char simbolo = "c"; //Simbolo di servizio per determinare che si tratta di un sensore String strMsg = "z" ; strMsg += simbolo; strMsg += " "; strMsg += numero; strMsg += " "; char msg; strMsg.toCharArray(msg, 255); vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx (); / / Attende il completamento del trasferimento delay(200); ) void loop(void) ( for (int j=0; j<= 6; j++) { sensors.requestTemperatures(); printTemperature(insideThermometer); delay(600000); } } //Определение адреса void printAddress(DeviceAddress deviceAddress) { for (uint8_t i = 0; i < 8; i++) { if (deviceAddress[i] < 16); //Serial.print("0"); //Serial.print(deviceAddress[i], HEX); } }

Il dispositivo ricevente riceve i dati, misura la pressione e la temperatura nella stanza e li trasmette al display.

#include #include LiquidCrystal lcd(12, 10, 5, 4, 3, 2); #include sensore dht11; #define DHT11PIN 8 #include #include BMP085 dps = BMP085(); lungo Temperatura = 0, Pressione = 0, Altitudine = 0; void setup() ( Serial.begin(9600); vw_set_ptt_inverted(true); // Necessario per DR3100 vw_setup(2000); // Imposta la velocità di ricezione vw_rx_start(); // Avvia il monitoraggio della trasmissione lcd.begin(16, 2) ; Wire.begin(); ritardo(1000); dps.init(); //lcd.setCursor(14,0); //lcd.write(byte(0)); //lcd.home(); ) void loop() ( uint8_t buf; // Buffer per il messaggio uint8_t buflen = VW_MAX_MESSAGE_LEN; // Lunghezza buffer if (vw_get_message(buf, &buflen)) // Se il messaggio viene ricevuto ( // Inizia l'analisi int i; // If il messaggio non è indirizzato a noi, exit if (buf != "z") ( return; ) char command = buf; // Il comando è all'indice 2 // Il parametro numerico inizia all'indice 4 i = 4; int numero = 0; // Poiché la trasmissione avviene carattere per carattere, è necessario convertire il set di caratteri in un numero while (buf[i] != " ") ( numero *= 10; numero += buf[i] - "0"; i++; ) dps.getPressure(&Pressure); dps.getAltitude (&Altitude); dps.getTemperature(&Temperature); //Serial.print(comando); Serial.print(" "); Serial.println( numero); lcd.print("T="); lcd.setCursor(2,0); lcd.print(numero); lcd.setCursor(5,0); lcd.print("P="); lcd.print(Pressione/133,3); lcd.print("mmH"); lcd.setCursor(0,1); lcd.print("T="); lcd.print(Temperatura*0.1); lcd.print("H="); lcd.print(sensore.umidità); lcd.casa(); //ritardo(2000); int chk = sensore.read(DHT11PIN); switch (chk) ( case DHTLIB_OK: //Serial.println("OK"); break; case DHTLIB_ERROR_CHECKSUM: //Serial.println("Errore checksum"); break; case DHTLIB_ERROR_TIMEOUT: //Serial.println("Time out errore"); break; default: //Serial.println("Errore sconosciuto"); break; ) ) )

PS In futuro ho intenzione di aggiungere quanto segue:
- sensore di umidità al trasmettitore, rielaborare l'algoritmo di trasmissione dei dati
- sensore per la misurazione della velocità e della direzione del vento.
- aggiungi un altro display al dispositivo ricevente.
- trasferire il ricevitore e il trasmettitore su un microcontrollore separato.

Di seguito una foto di quanto accaduto:

Elenco dei radioelementi

Tipo	Denominazione	Quantità	Il mio blocco note
Parte trasmittente.
Scheda Arduino	Arduino Nano 3.0	1	Al blocco note
termometro	DS18B20	1	Al blocco note
Resistore	220 Ohm	1	Al blocco note
Modulo trasmettitore	MX-FS-03V (433 MHz)	1	Al blocco note
Parte ricevente radio.
Scheda Arduino	ArduinoUno	1	Al blocco note
Resistenza trimmer		1	Al blocco note
Resistore

È così che è stato scelto l'argomento del corso e col tempo non sembravano esserci problemi.