Zuverlässige persönliche Wetterstation mit Arduino, ESP8266 und ThingSpeak bauen

Komponenten und Zubehör

Komponente	Menge
Adafruit BMP180 (Druck & Temperatur)	1
DHT11 Temperatur- & Feuchtigkeitssensor (4 Pins)	1
LDR (lichtabhängiger Widerstand)	1
Espressif ESP8266 ESP-01	1
Arduino Nano R3	1
Widerstand 4,75 kΩ	1
Widerstand 51 kΩ	1
LM2596 DC-DC Step-Down Power Modul	1
DC-Hohlsteckerbuchse	1
Schalter	1
12V-2A Steckernetzteil	1
PCB (Platine)	1
Male Header 40-polig 1 Reihe (2,54 mm)	1
Female Header 8-polig 1 Reihe (2,54 mm)	5
Kunststoffgehäuse	1

Benötigte Werkzeuge und Maschinen

• Abisolierzange
• Heißklebepistole
• Lötkolben
• Schraubendreher
• Feile (für Handarbeit)

Apps und Online-Dienste

• Arduino IDE
• ThingSpeak API

Über dieses Projekt

Intro: Eine persönliche Wetterstation bauen

Man sitzt in seinem Zimmer, fängt an zu schwitzen oder zu frieren und fragt sich: Wie hoch ist wohl die Temperatur in meinem Zimmer? Wie die Luftfeuchtigkeit? Genau das ist mir vor einiger Zeit passiert.

Daraus entstand die Idee zur persönlichen Wetterstation, die Temperatur, Luftfeuchtigkeit, Luftdruck und Lichtintensität des Raums überwacht und die Daten auf einen privaten Kanal auf thingspeak.com hochlädt.

Los geht's!

Schritt 1: Kurzes Video

Hier ist ein kurzes Video, das alles in 5 Minuten zusammenfasst. Auf YouTube ansehen

Schritt 2: Elektronische Komponenten für die persönliche Wetterstation

Beschreibung: Wir verwenden den DHT11 für Luftfeuchtigkeit, den BMP180 für Temperatur und Luftdruck und einen lichtabhängigen Widerstand (LDR) für eine grobe Lichtintensitätsmessung. Der Arduino Nano sammelt die Sensordaten und sendet sie an den ESP8266 zum Hochladen auf Ihren privaten ThingSpeak-Kanal. Wir versorgen den Arduino Nano über ein 12V-2A Steckernetzteil; Sensoren und ESP8266 erhalten die heruntergeregelte Spannung vom LM2596-basierten Step-Down-Wandler.

Schritt 3: Werkzeuge und zusätzliche Artikel

Beschreibung: Wir nutzen Abisolierzange zum Abisolieren, Feile zum Glätten von Schnitten/Löchern am Gehäuse, Heißklebepistole zum Fixieren der Komponenten im Gehäuse, Schraubendreher zum Verschließen des Deckels und Lötkolben mit Lötzinn zum Bestücken der Lochrasterplatine (GCB). Eine 4×4×2 Zoll Kunststoffbox dient als Gehäuse. Wir benötigen außerdem Male/Female-Berg-Strips und Female-Stecker für die saubere Montage auf der GCB.

Schritt 4: Software-Anforderungen

Um die Sensordaten zu sehen, benötigen wir einen privaten Kanal auf thingspeak.com und die Arduino IDE zum Schreiben des Codes für den Arduino Nano. (Ich gehe davon aus, dass Sie über PC/Laptop und einen WLAN-Router mit Internetzugang verfügen.)

• Privater Kanal auf Thingspeak.com
• Arduino IDE (bevorzugt neueste Version)

Die neueste Arduino IDE erhalten Sie von arduino.cc. Jetzt erstellen wir einen privaten Kanal auf ThingSpeak.

Schritt 5: Privaten Kanal auf ThingSpeak.com erstellen

1. Browser öffnen, zu thingspeak.com gehen, rechts oben auf „Sign Up“ klicken
2. Details ausfüllen und auf „Create account“ klicken
3. Auf „New Channel“ klicken
4. Erneut Details für den Kanal eingeben und 4 Felder aktivieren (wir senden 4 Sensorwerte), nach unten scrollen und „Save Channel“ klicken
5. Auf dieser Seite auf „API Keys“ klicken und den „Write API Key“ notieren

Das war's – jetzt haben Sie Ihren privaten ThingSpeak-Kanal.

Schritt 6: Schaltplan für die persönliche Wetterstation

Hier ist der Schaltplan. Auch die Fritzing-Datei ist angehängt. Die Verbindungen sind recht einfach:

• BMP180 an I2C des Arduino Nano
• LDR als Spannungsteiler mit 51 kΩ Widerstand, Mittelabgriff an A1
• DHT11 Data-Pin mit 4,7 kΩ Pull-up an A0
• ESP8266 TX/RX an D10/D11 des Nano, CH_PD an 3,3V
• LM2596 Ausgang auf 3,3V einstellen (Potentiometer am Modul). Ausgang an VCC/GND von BMP180, DHT11, LDR, ESP8266
• LM2596 Eingang vom 12V-2A Netzteil, das auch Vin/GND des Arduino Nano versorgt

Nun bauen wir die Schaltung auf einer Lochrasterplatine auf.

Schritt 7: Schaltung auf Lochrasterplatine (GCB) aufbauen

Die Hardware-Werkzeuge und Zusatzartikel aus Schritt 3 kommen jetzt zum Einsatz.

• Female-Berg-Strips für Arduino Nano und ESP8266-Platzierung auf GCB
• Lötkolben und Lötzinn für elektrische Verbindungen
• Female-Stecker zum Verlängern der Reichweite aller Sensoren und des LM2596-Moduls (diese werden an Deckel und Wand des Gehäuses geklebt)
• Male-Berg-Strips als Anschluss-Punkte für die Female-Verlängerungen
• Schaltplan auf GCB realisieren mit Drähten (abisolieren) oder geschmolzenen Lötzinn-Schienen
• Vor dem Einschalten auf Kurzschlüsse prüfen mit Multimeter

Schritt 8: Code

Der Code für die persönliche Wetterstation ist ziemlich einfach. Ich habe ihn gut kommentiert für leichte Portierbarkeit. Bevor Sie den Code flashen, beachten Sie Folgendes:

• Stellen Sie sicher, dass alle Bibliotheken installiert sind
• Ersetzen Sie die Bindestriche in Zeile 14 durch die SSID Ihres Access Points (WLAN-Router)
• Ersetzen Sie die Bindestriche in Zeile 15 durch das PASSWORT Ihres WLAN-Netzwerks
• Ersetzen Sie die Bindestriche in Zeile 17 durch Ihren ThingSpeak Write API Key
• Beim Programmieren des Arduino Nano muss die 12V-Gleichstromversorgung AUS sein

Hier ist der Link zum GitHub (Personal Weather Station) für Code und verwendete Bibliotheken: GitHub Repository

#include <SoftwareSerial.h>
#include <Wire.h>
#include <dht.h>
#include <Adafruit_BMP085.h>

#define DEBUG 0 // auf 1 setzen für Debug-Ausgabe im Serial Monitor
#define dht_pin A0
#define lightSensor A1

dht DHT;
Adafruit_BMP085 bmp;
SoftwareSerial esp8266Module(10, 11); // RX, TX

String network = "----";      // Ihre WLAN-SSID
String password = "-------------"; // Ihr WLAN-Passwort
#define IP "184.106.153.149"  // IP von thingspeak.com
String GET = "GET /update?key=----------------"; // Ihr Channel Key

void setup() {
  if(DEBUG){ Serial.begin(9600); }
  esp8266Module.begin(9600);
  if (!bmp.begin()) {
    if(DEBUG){ Serial.println("Kein gültiger BMP085 Sensor gefunden, Verkabelung prüfen!"); }
    while (1) {}
  }
  delay(2000);
}

void loop() {
  setupEsp8266();
  DHT.read11(dht_pin);
  double humi = DHT.humidity;
  double bmp_temp = bmp.readTemperature();
  double bmp_pressure = bmp.readPressure();
  int lightIntensity = analogRead(lightSensor);
  updateTemp(String(bmp_temp), String(lightIntensity), String(bmp_pressure), String(humi));
  delay(30000);
}

// ESP8266 einrichten, Station-Modus, mit WLAN verbinden
void setupEsp8266() {
  if(DEBUG){ Serial.println("ESP8266 Reset"); }
  esp8266Module.flush();
  esp8266Module.println(F("AT+RST"));
  delay(7000);
  if (esp8266Module.find("OK")) {
    if(DEBUG){ Serial.println("OK gefunden"); Serial.println("Modus ändern"); }
    esp8266Module.flush();
    changingMode();
    delay(5000);
    esp8266Module.flush();
    connectToWiFi();
  } else {
    if(DEBUG){ Serial.println("OK nicht gefunden"); }
  }
}

bool changingMode() {
  esp8266Module.println(F("AT+CWMODE=1"));
  if (esp8266Module.find("OK")) {
    if(DEBUG){ Serial.println("Modus geändert"); }
    return true;
  } else if(esp8266Module.find("NO CHANGE")){
    if(DEBUG){ Serial.println("Bereits in Modus 1"); }
    return true;
  } else {
    if(DEBUG){ Serial.println("Fehler beim Moduswechsel"); }
    return false;
  }
}

bool connectToWiFi() {
  if(DEBUG){ Serial.println("Verbinde mit WLAN"); }
  String cmd = F("AT+CWJAP=\"");
  cmd += network;
  cmd += F("\",\"");
  cmd += password;
  cmd += F("\"");
  esp8266Module.println(cmd);
  delay(15000);
  if (esp8266Module.find("OK")) {
    if(DEBUG){ Serial.println("Mit Access Point verbunden"); }
    return true;
  } else {
    if(DEBUG){ Serial.println("Keine Verbindung zum Access Point"); }
    return false;
  }
}

// Sensordaten an ThingSpeak senden
void updateTemp(String voltage1, String voltage2, String voltage3, String voltage4) {
  String cmd = "AT+CIPSTART=\"TCP\",\"";
  cmd += IP;
  cmd += "\",80";
  esp8266Module.println(cmd);
  delay(5000);
  if(esp8266Module.find("Error")){
    if(DEBUG){ Serial.println("FEHLER beim SENDEN"); }
    return;
  }
  cmd = GET + "&field1=" + voltage1 + "&field2=" + voltage2 + "&field3=" + voltage3 + "&field4=" + voltage4 + "\r\n";
  esp8266Module.print("AT+CIPSEND=");
  esp8266Module.println(cmd.length());
  delay(15000);
  if(esp8266Module.find(">")) {
    esp8266Module.print(cmd);
    if(DEBUG){ Serial.println("Daten gesendet"); }
  } else {
    esp8266Module.println("AT+CIPCLOSE");
    if(DEBUG){ Serial.println("Verbindung geschlossen"); }
  }
}

Bibliothek und Code für Personal Weather Station

Readme beachten: GitHub Repository

Schritt 9: Gehäuse vorbereiten

Wir müssen Löcher verschiedener Form und Größe in die 4×4×2 Zoll Box bohren/schneiden. Löcher für DC-Buchse und Schalter an einer beliebigen Wand des Gehäuses. Auch Löcher für die Sensoren auf dem Deckel.

Heißes Messer zum Schneiden des Kunststoffs verwenden. Feile zum Glätten der Löcher.

Schritt 10: Deckel schließen

Die bestückte GCB in das Gehäuse legen. Schalter und DC-Buchse in die Wandlöcher, Sensoren in die Deckellöcher einsetzen. Position finalisieren und mit Heißkleber fixieren. Schließlich mit Schraubendreher den Deckel verschließen.

Fertig – Ihre persönliche Wetterstation! Schalten Sie das Netzteil ein und sehen Sie Temperatur, Luftfeuchtigkeit, Luftdruck und Lichtintensität Ihres Raums von überall auf der Welt über Smartphone/PC/Laptop/Tablet auf Ihrem privaten ThingSpeak-Kanal.

Das war's für dieses Projekt. Bei Fragen kommentieren. Danke fürs Lesen!

Schaltpläne

schematic.fzz