Arduino Projekt für drahtlose Wetterstation

In diesem Tutorial lernen wir, wie man eine Arduino-basierte drahtlose Wetterstation herstellt. Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.

Übersicht

Die Außentemperatur und Luftfeuchtigkeit werden mit dem DHT22-Sensor gemessen und diese Daten werden drahtlos an die Inneneinheit mit den NRF24L01-Transceiver-Modulen gesendet. An der Inneneinheit befindet sich auch ein weiterer DHT22-Sensor zur Messung der Innentemperatur und -feuchtigkeit sowie ein DS3231-Echtzeituhrmodul, das die Zeit verfolgen kann, selbst wenn der Arduino Strom verliert. Alle diese Daten werden auf einem 0,96-Zoll-OLED-Display gedruckt.

Schaltplan der drahtlosen Arduino-Wetterstation

Werfen wir einen Blick auf den Schaltplan und wie dieses Projekt funktioniert. Beachten Sie, dass ich bereits detaillierte Tutorials zur Funktionsweise jedes dieser Module habe. Weitere Details finden Sie in diesen:NRF24L01-Tutorial, DHT22-Tutorial, DS3231-Tutorial .

Die für dieses Projekt benötigten Komponenten erhalten Sie über die folgenden Links:

NRF24L01 Transceiver-Modul……….
DHT22-Sensor…………….……………………
DS3231 Echtzeituhr………………….. Amazon / Banggood/AliExpress
Arduino Nano ………………………….……..

Sowohl das Echtzeituhrmodul als auch das OLED-Display verwenden das I2C-Protokoll für die Kommunikation mit dem Arduino, sodass sie mit den I2C-Pins oder den analogen Pins Nr. 4 und 5 auf der Arduino Nano-Platine verbunden sind. Direkt neben dem Transceiver-Modul NRF24L01 befindet sich ein Kondensator, um die Stromversorgung stabiler zu halten. Es gibt auch einen Pull-up-Widerstand, der mit dem DHT22-Datenstift verbunden ist, damit der Sensor richtig funktioniert.

Für die Stromversorgung habe ich ein 12-V-DC-Netzteil für das Innengerät verwendet, und auf der anderen Seite habe ich für die Stromversorgung des Außengeräts zwei Li-on-Batterien verwendet, die etwa 7,5 V erzeugen. Mit dieser Konfiguration könnte die Außeneinheit etwa 10 Tage laufen, bevor sich die Batterien entladen, da wir regelmäßig Daten übertragen und den Arduino in der Zwischenzeit in den Schlafmodus versetzen, in dem der Stromverbrauch nur etwa 7 mA beträgt.

Kundenspezifisches PCB-Design

Um die elektronischen Komponenten organisiert zu halten, entwarf ich gemäß dem Schaltplan eine benutzerdefinierte Leiterplatte mit der kostenlosen Online-Schaltungsdesign-Software EasyEDA. Wir können feststellen, dass die gleiche Platine sowohl für das Innen- als auch für das Außengerät verwendet werden kann, nur das Arduino-Board sollte anders programmiert werden.

Sobald wir das Design hier abgeschlossen haben, können wir einfach die Gerber-Datei exportieren, die für die Herstellung der Leiterplatte verwendet wird. Sie können die EasyEDA-Projektdateien der drahtlosen Arduino-Wetterstation hier überprüfen.

Dann können wir unser PCB bei JLCPCB bestellen, das eigentlich der Sponsor dieses Videos ist.

Hier können wir die Gerber-Datei einfach per Drag-and-Drop ziehen und nach dem Hochladen können wir unser PCB im Gerber-Viewer überprüfen. Wenn alles in Ordnung ist, können wir weitermachen, die Eigenschaften auswählen, die wir für unsere Leiterplatte wünschen, und dann können wir unsere Leiterplatte zu einem günstigen Preis bestellen. Beachten Sie, dass Sie bei Ihrer ersten Bestellung bei JLCPCB bis zu 10 PCBs für nur 2 $ erhalten können.

Trotzdem sind nach einigen Tagen die Platinen eingetroffen. Die Qualität der Leiterplatten ist super und alles ist genau so wie im Design.

Ich begann mit der Montage der Elektronikkomponenten dieses Projekts, indem ich Stiftleisten auf die Platine lötete. Auf diese Weise können wir die Komponenten bei Bedarf einfach verbinden und trennen.

Dann habe ich auch den Kondensator und den Pull-up-Widerstand eingefügt und gelötet. Wenn dieser Schritt erledigt ist, können wir die Komponenten jetzt einfach auf die Stiftleisten der Platine aufstecken.

Als nächstes machte ich weiter mit der Herstellung der Fälle für das Projekt. Zu diesem Zweck habe ich 8 mm dickes MDF-Brett verwendet und mit einer Kreissäge alle Stücke auf Maß geschnitten.

Um genaue Temperatur- und Feuchtigkeitsmessungen zu erhalten, müssen die Seiten der Gehäuse Luft in das Gehäuse eindringen lassen. Also habe ich mit einem Bohrer und einer Raspel mehrere Schlitze an den Seitenwänden sowohl der Innen- als auch der Außeneinheit gemacht.

Ich habe auch einen Schlitz für das OLED-Display auf der Frontplatte gemacht, sowie ein kleines Stück Aluminium zurechtgeschnitten, das ich später als Dekoration auf der Frontplatte anbringen werde.

Für die Montage der Gehäuse habe ich einen Holzleim und einige Klammern sowie einige Schrauben verwendet.

Ich malte die Fälle mit einer Sprühfarbe. Ich habe weiße Farbe für das Außengerät und schwarze für das Innengerät verwendet. Nachdem der Lack getrocknet war, habe ich die Platinen einfach in die Gehäuse gesteckt.

An der Rückseite der Inneneinheit habe ich eine Strombuchse und einen Netzschalter eingefügt, und an der Außeneinheit habe ich eine einfache Drahtbrücke als Netzschalter verwendet.

Und das war's, unsere drahtlose Arduino-Wetterstation funktioniert jetzt, aber in diesem Video können Sie sich noch ansehen, wie das Programm funktioniert.

Code der drahtlosen Arduino-Wetterstation

Code der Außeneinheit der Arduino-Wetterstation:

/* Arduino Wireless Communication Tutorial Outdoor unit – Transmitter von Dejan Nedelkovski, www.HowToMechatronics.comLibraries:NRF24L01 – TMRh20/RF24 , https://github.com/tmrh20/RF24/DHT22 – DHTlib, https://github.com/RobTillaart/Arduino/tree/master/libraries/DHTlibLowPower – https://github.com/rocketscream/Low-Power */#include #include #include #include #include #define dataPin 8 // DHT22 data pindht DHT; // Erstellt ein DHT-ObjektRF24-Radio (10, 9); // CE, CSNconst byte address[6] ="00001";char thChar[32] ="";String thString ="";void setup() { radio.begin(); radio.openWritingPipe (Adresse); radio.setPALevel (RF24_PA_MIN); radio.stopListening ();} void loop () {int readData =DHT.read22 (dataPin); // Liest die Daten vom Sensor int t =DHT.temperature; // Ruft die Temperaturwerte ab int h =DHT.humidity; // Ruft die Werte der Feuchtigkeit ab thString =String(t) + String(h); thString.toCharArray(thChar, 12); // Sende die Daten drahtlos an die Inneneinheit für (int i =0; i <=3; i++) {// Sende die Daten 3 mal radio.write (&thChar, sizeof(thChar)); Verzögerung (50); } // Schlaf für 2 Minuten, 15 * 8 =120 s für (int sleepCounter =15; sleepCounter> 0; sleepCounter--) {LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF); }}

Codesprache:Arduino (arduino)

Beschreibung: Die Außeneinheit ist der Sender der drahtlosen Kommunikation, daher müssen wir hier zuerst die RF24-Bibliothek, die DHT-Bibliothek sowie die LowPower-Bibliothek einbeziehen, die verwendet wird, um den Arduino in den Schlafmodus zu versetzen.

Nachdem wir ihre Instanzen, die Pins, mit denen die Module verbunden sind, und einige Variablen definiert haben, müssen wir im Setup-Abschnitt die drahtlose Kommunikationsadresse initialisieren. Dann lesen wir im Schleifenabschnitt zuerst die Daten vom DHT22-Sensor oder das sind Temperatur und Luftfeuchtigkeit. Anfänglich sind diese Werte Ganzzahlen und getrennt, also konvertiere ich sie in eine einzelne String-Variable, füge sie in das Zeichenarray ein und sende diese Daten mit der Funktion radio.write() an die Inneneinheit. Mit der for-Schleife senden wir die Daten dreimal, um sicherzustellen, dass der Empfänger Daten erhält, falls der Controller zum Zeitpunkt des Sendens beschäftigt ist.

Am Ende versetzen wir den Arduino für eine bestimmte Zeit in den Schlafmodus, um den Stromverbrauch zu minimieren.

Code der Inneneinheit der Arduino-Wetterstation:

/* Arduino Wireless Communication Tutorial Innengerät – Empfänger von Dejan Nedelkovski, www.HowToMechatronics.com Bibliotheken:DS3231 – http://www.rinkydinkelectronics.com/library.php?id=73 U8G2 – https://github.com/olikraus/u8g2*/#include #include #include #include #include #include #include #define dataPin 8 // DHT22 sensordht DHT; // Erstellt ein DHT-ObjektDS3231 rtc(SDA, SCL);U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);RF24 radio(10, 9); // CE, CSNconst byte address[6] ="00001";char text[6] ="";int readDHT22, t, h;String inTemp, inHum, outTemp, outHum;String rtcTime, rtcDate;int draw_state =0; unsigned long previousMillis =0;long interval =3000;#define Temperature_20Icon_width 27#define Temperature_20Icon_height 47static const unsigned char Temperature_20Icon_bits[] U8X8_PROGMEM ={ 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0xc0, 0xe1, 0x00, 0x00, 0xe0, 0xc0, 0x01, 0x00, 0x60, 0x80, 0xf9, 0x03, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x79, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0xf9, 0x03, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x8c, 0x79, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0xf9, 0x03, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x79, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0xf9, 0x03, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x70, 0x9e, 0x03, 0x00, 0x38, 0x1e, 0x07, 0x00, 0x18, 0x3e, 0x0e, 0x00, 0x1c, 0x3f, 0x0c, 0x00, 0x0c, 0x7f, 0x18, 0x00, 0x8c, 0xff, 0x18, 0x00, 0x8e, 0xff, 0x38, 0x00, 0xc6, 0xff, 0x31, 0x00, 0xc6, 0xff, 0x31, 0x00, 0xc6, 0xff, 0x31, 0x00, 0x8e, 0xff, 0x38, 0x00, 0x1, 0x8, 0x8c, 0x8c, 0x8c 0x0c, 0x7f, 0x1c, 0x00, 0x3c, 0x1c, 0x0e, 0x00, 0x78, 0x00, 0x06, 0x00, 0xe0, 0x80, 0x07, 0x00, 0xe0, 0xff, 0x03, 0x00, 0xff, 0x, 0x80, 0x, 0x80, 0x0 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0xdc, 0x01, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x86, 0x03, 0x00, 0x00, 0x06, 0x03, 0x00, 0x00, 0x03, 0x07, 0x00, 0x80, 0x03, 0x06, 0x00, 0x80, 0x01, 0x0c, 0x00, 0xc0, 0x01, 0x1c, 0x00, 0xc0, 0x00, 0x18, 0x00, 0x e0, 0x00, 0x38, 0x00, 0x60, 0x00, 0x30, 0x00, 0x70, 0x00, 0x70, 0x00, 0x30, 0x00, 0xe0, 0x00, 0x38, 0x00, 0xc0, 0x00, 0x10, 0x18, 0x18, 0x18, 0x18 0x00, 0x80, 0x01, 0x0c, 0x00, 0x80, 0x03, 0x0e, 0x00, 0x80, 0x03, 0x06, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, 0x06, 0x03, 0x00, 0x00, 0x06, 0x03, 0x00, 0x00, 0x06, 0x63, 0x00, 0x00, 0x06, 0x63, 0x00, 0x00, 0x06, 0x63, 0x00, 0x00, 0x06, 0xe3, 0x00, 0x00, 0x06, 0xc7, 0x00, 0x00, 0x06, 0xc6, 0x01, 0x00, 0x07, 0x86, 0x03, 0x00, 0x03, 0x0e, 0x1f, 0x00, 0x03, 0x0e, 0x1e, 0x80, 0x01, 0x1c, 0x00, 0xc0, 0x01, 0x38 0x00 0xe0 0x00 0x78 0x00 0x70 0x00 0xf0 0x00 0x38 0x00 0xe0 0x07 0x1f 0x00 0x80 0xff 0x0f 0x00 0x3 0x3 0x00, 0x00, 0x00}; void setup () { radio.begin (); radio.openReadingPipe (0, Adresse); radio.setPALevel (RF24_PA_MIN); radio.startListening(); u8g2.begin(); rtc.begin();}void loop() { if (radio.available()) {radio.read(&text, sizeof(text)); // Eingehende Daten lesen outTemp =String(text[0]) + String(text[1]) + char(176) + "C"; // Außentemperatur outHum =String(text[2]) + String(text[3]) + "%"; // Luftfeuchtigkeit im Freien} unsigned long currentMillis =millis(); if (aktuelleMillis - vorherigeMillis> Intervall) { vorherigeMillis =aktuelleMillis; u8g2.firstPage(); do {switch (draw_state) { case 0:drawDate(); Unterbrechung; Fall 1:drawInTemperature(); Unterbrechung; Fall 2:drawInHumidity(); Unterbrechung; Fall 3:drawOutTemperature(); Unterbrechung; Fall 4:drawOutHumidity(); Unterbrechung; } } while ( u8g2.nextPage() ); draw_state++; Wenn (draw_state> 4) {draw_state =0; } }}void drawDate() {String dowa =rtc.getDOWStr(); dowa.remove(3); rtcDate =dowa + " " + rtc.getDateStr(); u8g2.setFont(u8g2_font_timB14_tr); u8g2.setCursor(0, 15); rtcTime =rtc.getTimeStr(); // DS3231 RTC-Zeit rtcTime.remove (5); u8g2.print (rtcDatum); u8g2.setFont(u8g2_font_fub30_tf); u8g2.setCursor(8, 58); u8g2.print (rtcTime);} void drawInTemperature () { readDHT22 =DHT.read22 (dataPin); // Liest die Daten vom Sensor t =DHT.temperature; // Ruft die Werte der Temperatur ab inTemp =String(t) + char(176) + "C"; u8g2.setFont(u8g2_font_helvR14_tr); u8g2.setCursor(24, 15); u8g2.print("INNEN"); u8g2.setFont(u8g2_font_fub30_tf); u8g2.setCursor(36, 58); u8g2.print (inTemp); u8g2.drawXBMP (0, 17, Temperature_20Icon_width, Temperature_20Icon_height, Temperature_20Icon_bits);}void drawInHumidity() { h =DHT.humidity; // Ruft die Werte der Feuchtigkeit ab inHum =String(h) + "%"; u8g2.setFont(u8g2_font_helvR14_tr); u8g2.setCursor(24, 15); u8g2.print("INNEN"); u8g2.setFont(u8g2_font_fub30_tf); u8g2.setCursor(36, 58); u8g2.print (inHum); u8g2.drawXBMP(0, 17, Humidity_20Icon_width, Humidity_20Icon_height, Humidity_20Icon_bits);}void drawOutTemperature() {u8g2.setFont(u8g2_font_helvR14_tr); u8g2.setCursor(12, 15); u8g2.print("AUSSEN"); u8g2.setFont(u8g2_font_fub30_tf); u8g2.setCursor(36, 58); u8g2.print (outTemp); u8g2.drawXBMP (0, 17, Temperature_20Icon_width, Temperature_20Icon_height, Temperature_20Icon_bits);}void drawOutHumidity() {u8g2.setFont(u8g2_font_helvR14_tr); u8g2.setCursor(12, 15); u8g2.print("AUSSEN"); u8g2.setFont(u8g2_font_fub30_tf); u8g2.setCursor(36, 58); u8g2.print (outHum); u8g2.drawXBMP(0, 17, Humidity_20Icon_width, Humidity_20Icon_height, Humidity_20Icon_bits);} Codesprache:Arduino (arduino)

Beschreibung: Auf der anderen Seite, an der Inneneinheit oder dem Empfänger, müssen wir zwei weitere Bibliotheken einbinden, eine für das DS3231-Echtzeituhrmodul und eine für das OLED-Display, die U8G2-Bibliothek. Auf die gleiche Weise wie zuvor müssen wir die Instanzen, die Pins und einige Variablen definieren, die für das Programm unten benötigt werden. Auch hier müssen wir die Temperatur- und Feuchtigkeitssymbole als Bitmaps definieren.

Bitmap des Temperatursymbols:

#define Temperature_20Icon_width 27#define Temperature_20Icon_height 47static const unsigned char Temperature_20Icon_bits[] U8X8_PROGMEM ={ 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x80, 0x7f, 0xe0, 0xe0.0, 0xe0.0 , 0x00, 0x00, 0xe0, 0xc0, 0x01, 0x00, 0x60, 0x80, 0xf9, 0x03, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x79, 0x00, 0x60, 0x80, 0x01 , 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0xf9, 0x03, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x8c, 0x79, 0x00, 0x60, 0x9e, 0x01, 0x00 , 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0xf9, 0x03, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x79, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60 , 0x9e, 0x01, 0x00, 0x60, 0x9e, 0xf9, 0x03, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x60, 0x9e, 0x01, 0x00, 0x70, 0x9e, 0x03, 0x00, 0x38, 0x1e 0x07 , 0x 00, 0xc6, 0xff, 0x31, 0x00, 0xc6, 0xff, 0x31, 0x00, 0x8e, 0xff, 0x38, 0x00, 0x8c, 0xff, 0x18, 0x00, 0x0c, 0x7f, 0x1c, 0x00, 0x0, 0x0, 0x0, 0x3c, 0x0c 0x78, 0x00, 0x06, 0x00, 0xe0, 0x80, 0x07, 0x00, 0xe0, 0xff, 0x03, 0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0, 0x0, 0x0; 0x0, 0x} /code> Codesprache:Arduino (arduino)

 
 Zu diesem Zweck können wir GIMP verwenden, einen Open-Source-Bildeditor, mit dem wir alles zeichnen und dann als Bitmap (.xbm) exportieren können.
  
 
 Dann können wir diese Datei mit einem Notepad öffnen und von dort die Bitmap in den Arduino-Code kopieren.
  
 
 Beachten Sie, dass wir hier die Bitmap mit dem PROGMEM-Variablenmodifikator als konstant definieren können, und auf diese Weise wird die Bitmap im Flash-Speicher statt im SRAM des Arduino-Boards gespeichert.
 static const unsigned char Temperature_20Icon_bits[] U8X8_PROGMEM // im Flash-Speicher speichern static unsigned char Temperature_20Icon_bits[] // im SRAM speichern
 
 Im Einrichtungsabschnitt müssen wir die drahtlose Kommunikation sowie das OLED-Display und das Echtzeituhrmodul initialisieren.
 
 Dann prüfen wir im Schleifenabschnitt ständig, ob eingehende Daten zum Lesen über die NRF24L01-Module verfügbar sind. Wenn wahr, lesen wir es mit der Funktion radio.read() und speichern die ersten beiden Zeichen in der Temperatur-String-Variablen und die nächsten beiden Zeichen in der Feuchtigkeits-String-Variablen.
 
 Dann verwenden wir die millis () -Funktion, um die verschiedenen Daten auf dem Display in Intervallen anzuzeigen, die mit der Intervallvariablen definiert sind, die ich auf 3 Sekunden eingestellt habe. Wir verwenden die Funktion millis(), da auf diese Weise der Rest des Codes wiederholt ausgeführt werden kann, während das Programm bei Verwendung der Funktion delay() auf diesen Zeitraum wartet, sodass wir auf diese Weise wahrscheinlich die eingehenden Daten verpassen würden von der Außeneinheit.
 
 Als nächstes drucken wir mit den Funktionen firstPage() und nextPage() der U8G2-Bibliothek die fünf verschiedenen Bildschirme, die mit den benutzerdefinierten Funktionen definiert sind.
 
 Die benutzerdefinierte Funktion drawDate() erhält die Datums- und Zeitinformationen vom Echtzeituhrmodul und gibt sie entsprechend auf dem Display aus. Die Funktion drawInTemperature() liest die Innentemperatur und gibt sie passend auf dem Display aus. Tatsächlich wird dieselbe Methode zum Drucken aller Bildschirme auf dem Display verwendet.
 
 Das wäre alles, ich hoffe, Sie haben dieses Arduino-Projekt genossen und etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen.
 

            

            
               Arduino Wireless Network mit mehreren NRF24L01-Modulen         
                DIY-Kamera-Slider mit Schwenk- und Neigekopf – Arduino-basiertes Projekt