DHT22 - Wet­ter­sta­ti­on LAN Daten speichern

Der Tem­pe­ra­tur­sen­sor DHT22 misst die Daten, sie wer­den auf der SD-Karte des Ethernet-Shields gespei­chert und kön­nen im Brow­ser ver­ar­bei­tet werden.

So sieht es aus:

Der Sen­sor DHT22 misst die Tem­pe­ra­tur und die Luft­feuch­tig­keit. Das hier ver­wen­de­te Bau­teil besitzt drei Anschlüs­se.
Die Ver­si­on mit vier Pins muss in der Rei­hen­fol­ge 5V → Daten (Pin) → leer → GND geschal­tet werden.

Für die­se Anlei­tung benö­tigst du ein soge­nann­tes „Shield“, eine Pla­ti­ne, die ein­fach auf den Ardui­no auf­ge­steckt wird. Auf ihr befin­det sich ein LAN-Anschluss (RJ45). Alle digi­ta­len und ana­lo­gen Anschlüs­se ste­hen auch wei­ter­hin zur Verfügung.

➨SD-Karten-Modul

➨Ethernet-Shield

➨RTC-Modul

Benö­tig­te Bauteile:

• RTC-Modul
• Ethernet-Shield mit SD-Karten-Modul
• Lei­tungs­dräh­te

Baue die Schal­tung auf.
(Fah­re mit der Maus über das Bild, um die Bezeich­nun­gen der Bau­tei­le zu sehen)

Für das Pro­gramm brauchst du eine freie IP-Adresse und eine freie MAC-Adresse in dei­nem loka­len Netz­werk.
Im Regel­fall befin­det sich in einem loka­len Netz­werk ein DHCP-Server, der jedem Gerät im Netz­werk auto­ma­tisch eine IP-Adresse zuteilt. Im Pro­gramm wird eine über DHCP ver­ge­be­ne Adres­se verwendet.

Wenn du eine ➨sta­ti­sche IP ver­wen­den willst:

Wenn die Tem­pe­ra­tur­mes­sung über einenz län­ge­ren Zeit­raum (meh­re­re Tage) ein­ge­setzt wer­den soll, emp­fiehlt sich die Ver­ga­be einer fes­ten IP-Adresse, weil nach der soge­nann­ten „lea­se­time“ die IP wie­der neu ver­ge­ben wird.
➨ Wei­te­re Informationen

Die MAC-Adresse ist die Hardware-Adresse jeder ein­zel­nen Netz­werk­schnitt­stel­le (LAN oder WLAN), mit der jedes Gerät im Netz­werk ein­deu­tig iden­ti­fi­ziert wer­den kann.

Sie besteht aus sechs Bytes in hexa­de­zi­ma­ler Schreib­wei­se, die durch „:“ oder „-“ getrennt werden.

Du kannst die im Pro­gramm ver­wen­de­te „erfun­de­ne“ MAC-Adresse über­neh­men: Die Gefahr, dass sich ein Gerät mit der glei­chen MAC-Adresse im Netz­werk befin­det, ist äußerst gering.

Benö­tig­te Bibliotheken:

Ardui­no IDE 1.8x:
Sketch → Biblio­thek ein­bin­den → Biblio­the­ken verwalten

Ardui­no IDE 2.x:

Bin­de die benö­tig­ten Biblio­the­ken ein und lege die Varia­blen fest.:

# include <Ethernet.h>
# include <SimpleDHT.h>
# include <RTClib.h>
# include <SdFat.h>

// Bezeichnung der SD-Karte
SdFat SD;

// Bezeichnung der Textdatei
File Messung;

// Datenpin für das SD-Kartenmodul
int DatenPin = 4;

// Name des RTC-Moduls
RTC_DS3231 rtc;

int SENSOR_DHT22 = 8;

// Namen des Sensors (dht22)
SimpleDHT22 dht22(SENSOR_DHT22);

// MAC-Adresse und IP definieren
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// festeIP = false -> IP-Adresse über DHCP vergeben
bool festeIP = true;

// feste IP
IPAddress ip(192, 168, 1, 200);

// Name des Servers vergeben
EthernetServer server(80);

// Intervall in Millisekunden
// 600000 = 10 Minuten
// 3600000 = 60 Minuten
const long Intervall = 600000;
const unsigned int Minuten = Intervall/60000;

// Start der Zeitmessung
unsigned long StartZeit = 0;

Der setup-Teil. Beach­te die Kommentare.

void setup()
{
  // RTC-Modul starten
  rtc.begin();
  /*
    wenn Datum und Zeit nicht korrekt -> Datum/Zeit setzen
    Jahr, Monat, Tag, Stunde, Minute, Sekunde
    keine führende 0 setzen
    Beispiel:
    rtc.adjust(DateTime(2021, 3, 4, 17, 12, 30));
  */
  // rtc.adjust(DateTime(2021, 3, 4, 17, 12, 30));
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}

  // Ethernet starten feste IP
  if (festeIP) Ethernet.begin(mac, ip);

  // Ethernet starten DHCP
  else Ethernet.begin(mac);

  // Server starten
  server.begin();

  Serial.begin(9600);

  // zur Kontrolle IP-Adresse anzeigen
  // localIP -> Adresse, die im Browser eingegeben wird
  Serial.println(Ethernet.localIP());
  SD.begin(DatenPin);
}

Der loop-Teil. Beach­te die Kommentare.

void loop() 
{
  String Auswertung = "";

  float Temperatur;
  float Luftfeuchtigkeit;

  // auf Clienten warten ...
  EthernetClient Client = Server.available();

  // abgelaufene Zeit ermitteln
  unsigned long VerstricheneZeit = millis();

  // neue Messung und speichern, wenn das Zeitintervall erreicht ist
  if (VerstricheneZeit - StartZeit >= Intervall) 
  {
    // StartZeit zurücksetzen
    StartZeit = VerstricheneZeit;

    // Temperatur und Zeit messen
    dht22.read2(&Temperatur, &Luftfeuchtigkeit, NULL);
    DateTime aktuell = rtc.now();

    // in Datei speichern
    Messung = SD.open("Messung.txt", FILE_WRITE);
    if (Messung) 
    {
      char Datum[] = "DD.MM.YYYY";
      Messung.print(aktuell.toString(Datum));

      // Zeit schreiben
      char Zeit[] = " Uhrzeit: hh:mm:ss";
      Messung.println(aktuell.toString(Zeit));
      Messung.print(F(" | "));
      Messung.println(Temperatur);
      Messung.print(F(" °C | "));
      Messung.println(Luftfeuchtigkeit);
      Messung.print(F("%"));
      Messung.println(F("<br>"));

      // Datei schließen
      Messung.close();
    }
  }

  // neue Anfrage
  if (Client) 
  {
    // solange der Client verbunden ist ...
    while (Client.connected()) 
    {
      if (Client.available()) 
      {
        char Zeichen = Client.read();
        Auswertung += Zeichen;

        // \n = Seite vom Clienten vollständig geladen
        if (Zeichen == '\n') 
        {
          // HTTP-Anforderung senden
          Client.println(F("HTTP/1.1 200 OK"));
          Client.println(F("Content-Type: text/html"));

          // Leerzeile zwingend erforderlich
          Client.println();

          /*
            HTML-Seite aufbauen
            die folgenden Anweisungen müssen
            mit print oder println gesendet werden
            println "verschönert" den Quelltext
            (jede Anweisung in einer eigenen Zeile)
          */
          Client.println(F("<!doctype html>"));
          Client.println(F("<html>"));
          Client.println(F("<body>"));

          // Daten speichern
          if (Auswertung.indexOf("s") > 0) {
            dht22.read2(&Temperatur, &Luftfeuchtigkeit, NULL);
            DateTime aktuell = rtc.now();

            Messung = SD.open("Messung.txt", FILE_WRITE);
            if (Messung) {
              char Datum[] = "DD.MM.YYYY";
              Messung.print(aktuell.toString(Datum));

              // Zeit schreiben
              char Zeit[] = " Uhrzeit: hh:mm:ss";
              Messung.println(aktuell.toString(Zeit));
              Messung.print(F(" | "));
              Messung.println(Temperatur);
              Messung.print(F(" &deg;C | "));
              Messung.println(Luftfeuchtigkeit);
              Messung.print(F("%<br>"));
              
              // Datei schließen
              Messung.close();
            }
          }
          if (Auswertung.indexOf("l") > 0) {
            Messung = SD.open("Messung.txt");
            if (Messung) 
            {
              // solange sich Zeilen in der Datei befinden ...
              while (Messung.available()) 
              {
                // ... werden sie gelesen und auf der Webseite ausgegeben
                Client.write(Messung.read());
              }

              // Datei schließen
              Messung.close();
            }
          }

          // Datei löschen
          if (Auswertung.indexOf("e") > 0) 
          {
            if (SD.exists("Messung.txt")) 
            {
              // Datei entfernen
              SD.remove("Messung.txt");
              Client.println(F("Datei entfernt!<br>"));
            }
          }

          Client.println(F("<hr />Intervall:"));
          Client.println(Minuten);
          Client.println(F("Minuten<br><hr /> "));

          // Button anzeigen und formatieren
          Client.print(F("<input type='button' onClick=\"location.href='l'\ value='lesen'>"));
          Client.println(F("<input type='button' onClick=\"location.href='s'\" value='schreiben'>"));

          Client.print(F("<input type='button' "));
          Client.println(F(" onClick=\"location.href='e'\" value='entfernen'>"));
          Client.println(F(" value='entfernen'></body></html>"));

          // Zeit, um die Antwort zu übertragen
          delay(1);

          // Verbindung beenden
          Client.stop();
        }
      }
    }
  }
}

Ver­wand­te Aufgaben:

• DHT22 - Wet­ter­da­ten aufzeichnen
• Knif­fel - EEPROM verwenden
• Lot­to­zah­len mit einem Ethernet-Shield
• Lot­to­zah­len auf eine SD-Karte schreiben
• Lot­to­zah­len mit Zeits­tem­pel anzei­gen und auf einer SD-Karte speichern

Letzte Aktualisierung: 29. Nov 2021 @ 19:17