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

Der Tem­pe­ra­tur­sen­sor DHT22 (DHT11) misst Tem­pe­ra­tur und Luft­feuch­tig­keit, die Daten wer­den auf der SD-Kar­te des Ether­net-Shields gespei­chert und kön­nen im Brow­ser betrach­tet werden.

So sieht es aus:

Bei­spie­le für DHT11/DHT22 Sensoren

Pin­be­le­gung:

DHT11
GND Daten 5V

DHT22
5V Daten GND

Die Pin­be­le­gung kann sich von der hier gezeig­ten unter­schei­den. Ach­te auf die Beschrif­tung auf dem Modul!

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-Kar­ten-Modul

➨Ether­net-Shield

➨RTC-Modul

Benö­tig­te Bauteile:

• RTC-Modul
• Ether­net-Shield mit SD-Karten-Modul
• DHT11 oder DHT22
• 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-Adres­se und eine freie MAC-Adres­se in dei­nem loka­len Netz­werk.
Im Regel­fall befin­det sich in einem loka­len Netz­werk ein DHCP-Ser­ver, der jedem Gerät im Netz­werk auto­ma­tisch eine IP-Adres­se zuteilt. Im Pro­gramm wird eine über DHCP ver­ge­be­ne Adres­se verwendet.

Die MAC-Adres­se ist die Hard­ware-Adres­se 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-Adres­se über­neh­men: Die Gefahr, dass sich ein Gerät mit der glei­chen MAC-Adres­se im Netz­werk befin­det, ist äußerst gering.

Benö­tig­te Bibliotheken:

Nach dem Start des Pro­gramms wird die IP des Ether­net-Shields im Seri­el­len Moni­tor angezeigt:

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

# include <Ethernet.h>
# include <RTClib.h>
# include <DHT.h>
# include <SD.h>

// Bezeichnung der Textdatei
File Messung;

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

// Name des RTC-Moduls
RTC_DS3231 rtc;

int SENSOR_DHT = 8;

// Sensortyp festlegen
// DHT22
# define SensorTyp DHT22 

// oder DHT11
// # define SensorTyp DHT11

// Sensor einen Namen zuweisen
DHT dht(SENSOR_DHT, SensorTyp); 


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

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

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

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

/* 
  Intervall in Millisekunden
  600000 = 10 Minuten
  3600000 = 60 Minuten
  Intervall wird auf der Seite angezeigt
*/
const long Intervall = 1200000;
const unsigned int Minuten = Intervall / 60000;

// Start der Zeitmessung
unsigned long StartZeit = 0;

Der set­up-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(2023, 3, 10, 7, 2, 30));
  */

  Serial.begin(9600);
  delay(500);

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

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

  // Server starten
  Server.begin();

  // zur Kontrolle IP-Adresse anzeigen
  // localIP -> Adresse, die im Browser eingegeben wird
  Serial.print(F("IP des Ethernet-Shields: "));
  Serial.println(Ethernet.localIP());

  // SD-Karte starten
  SD.begin(DatenPin);

  // DHT-Sensor starten
  dht.begin();
}

Der loop-Teil. Beach­te die Kommentare.

void loop() 
{
  String Auswertung = "";

  // Variablen für Temperatur und Luftfeuchtigkeit
  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, Luftfeuchtigkeit messen und Zeit ermitteln
    Temperatur = dht.readTemperature();
    Luftfeuchtigkeit = dht.readHumidity();
    DateTime aktuell = rtc.now();

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

      // Zeit schreiben
      char Zeit[] = " Uhrzeit: hh:mm:ss";
      Messung.println(aktuell.toString(Zeit));

      // Messdaten schreiben
      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) 
          {
            Temperatur = dht.readTemperature();
            Luftfeuchtigkeit = dht.readHumidity();
            DateTime aktuell = rtc.now();

            Messung = SD.open("Messung.txt", FILE_WRITE);

            // wenn die Datei vorhanden ist
            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(" | "));
              
              // Temperatur und Luftfeuchtigkeit schreiben
              Messung.println(Temperatur);
              Messung.print(F(" &deg;C | "));
              Messung.println(Luftfeuchtigkeit);
              Messung.print(F("%"));
              Messung.println(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 />"));
          Client.println(F("Intervall: "));
          Client.println(Minuten);
          Client.println(F("Minuten<br> "));
          Client.println(F("<hr />"));

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

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

          Client.println(F("<hr />"));

          // IPs anzeigen
          Client.print(F("<b>Eigene IP: "));
          Client.print(Client.remoteIP());
          Client.print(F("<br>IP des Ethernet-Shields: "));
          Client.print(Ethernet.localIP());
          Client.println(F("</body>"));
          Client.println(F("</html>"));

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

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

Ver­wand­te Aufgaben:

• DHT11/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-Kar­­te schreiben
• Lot­to­zah­len mit Zeit­stem­pel anzei­gen und auf einer SD-Kar­­te speichern

Letzte Aktualisierung: 5. Mai 2023 @ 12:18