Der Code basiert auf einem UNO R3 ATmega328p Board und der C++-Sprache unter Verwendung der Arduino IDE App.

Benötigte Bibliotheken: 
- DHT sensor library (von Adafruit)

Code:

/*
 * DHT11 Temperatur- und Luftfeuchtigkeitssensor Modul
 * Board: Arduino UNO R3 (ATmega328p)
 * 
 * Pinbelegung (DHT11 Modul mit 3 Pins):
 * - VCC   -> 5V
 * - GND   -> GND
 * - OUT   -> Pin 2 (Datenpin)
 * 
 * Pinbelegung (DHT11 Modul mit 4 Pins):
 * - VCC   -> 5V
 * - GND   -> GND
 * - DATA  -> Pin 2 (Datenpin)
 * - NC    -> nicht angeschlossen
 * 
 * Hinweis: 
 * - Bei manchen Modulen ist ein 10kΩ Pull-up-Widerstand 
 *   zwischen VCC und DATA bereits integriert.
 * - Falls nicht, einen 10kΩ Widerstand zwischen 5V und 
 *   Datenpin einbauen.
 * - Der Sensor benötigt ca. 1-2 Sekunden zwischen den Messungen.
 * - Messbereich: Temperatur 0-50°C, Luftfeuchtigkeit 20-90%
 */

#include <DHT.h>

// Pin-Definitionen
#define DHTPIN 2          // Datenpin
#define DHTTYPE DHT11     // Sensortyp: DHT11

// DHT-Objekt erstellen
DHT dht(DHTPIN, DHTTYPE);

// Variablen für Messwerte
float temperatur = 0.0;
float luftfeuchtigkeit = 0.0;
int fehlerZaehler = 0;

// Zeitmessung für Intervall
unsigned long letzteMessung = 0;
const unsigned long messIntervall = 2000; // 2 Sekunden

void setup() {
  // Serielle Kommunikation starten
  Serial.begin(9600);
  
  // DHT-Sensor initialisieren
  dht.begin();
  
  Serial.println("DHT11 Sensor gestartet");
  Serial.println("-----------------------------------");
  Serial.println("Warte auf ersten Messwert...");
  Serial.println();
  
  // Kurze Wartezeit für Sensor-Stabilisierung
  delay(1000);
}

void loop() {
  // Nur alle 2 Sekunden messen (DHT11 benötigt Zeit zwischen Messungen)
  if (millis() - letzteMessung >= messIntervall) {
    letzteMessung = millis();
    
    // Temperatur und Luftfeuchtigkeit lesen
    luftfeuchtigkeit = dht.readHumidity();
    temperatur = dht.readTemperature(); // in Celsius
    
    // Prüfen, ob die Messung gültig ist
    if (isnan(luftfeuchtigkeit) || isnan(temperatur)) {
      fehlerZaehler++;
      Serial.print("Fehler beim Auslesen des Sensors (Zähler: ");
      Serial.print(fehlerZaehler);
      Serial.println(")");
      
      // Bei zu vielen Fehlern Sensor neu initialisieren
      if (fehlerZaehler >= 5) {
        Serial.println("Sensor wird neu initialisiert...");
        dht.begin();
        fehlerZaehler = 0;
      }
      return;
    }
    
    // Fehlerzähler zurücksetzen bei erfolgreicher Messung
    fehlerZaehler = 0;
    
    // Messwerte ausgeben (auf 1 Dezimalstelle gerundet)
    Serial.println("=== Aktuelle Messwerte ===");
    Serial.print("Luftfeuchtigkeit: ");
    Serial.print(luftfeuchtigkeit, 1);
    Serial.println(" %");
    
    Serial.print("Temperatur: ");
    Serial.print(temperatur, 1);
    Serial.println(" °C");
    
    // Temperatur in Fahrenheit umrechnen (optional)
    float fahrenheit = (temperatur * 1.8) + 32;
    Serial.print("Temperatur: ");
    Serial.print(fahrenheit, 1);
    Serial.println(" °F");
    
    // Hitzindex berechnen (gefühltes Temperatur)
    float hitzIndex = dht.computeHeatIndex(temperatur, luftfeuchtigkeit, false);
    Serial.print("Hitzindex (gefuehlt): ");
    Serial.print(hitzIndex, 1);
    Serial.println(" °C");
    
    // Taupunkt berechnen (näherungsweise)
    float taupunkt = temperatur - ((100 - luftfeuchtigkeit) / 5);
    Serial.print("Taupunkt (ca.): ");
    Serial.print(taupunkt, 1);
    Serial.println(" °C");
    
    // Bewertung der Luftfeuchtigkeit
    Serial.print("Bewertung: ");
    if (luftfeuchtigkeit < 30) {
      Serial.println("Zu trocken - Luftbefeuchter empfohlen");
    } else if (luftfeuchtigkeit >= 30 && luftfeuchtigkeit < 50) {
      Serial.println("Optimaler Bereich");
    } else if (luftfeuchtigkeit >= 50 && luftfeuchtigkeit < 70) {
      Serial.println("Akzeptabler Bereich");
    } else if (luftfeuchtigkeit >= 70 && luftfeuchtigkeit < 80) {
      Serial.println("Etwas feucht - Entlueften empfohlen");
    } else {
      Serial.println("Zu feucht - Schimmelgefahr!");
    }
    
    // Temperaturbewertung
    Serial.print("Temperatur: ");
    if (temperatur < 10) {
      Serial.println("Kalt");
    } else if (temperatur >= 10 && temperatur < 20) {
      Serial.println("Mild");
    } else if (temperatur >= 20 && temperatur < 25) {
      Serial.println("Angenehm warm");
    } else if (temperatur >= 25 && temperatur < 30) {
      Serial.println("Warm");
    } else if (temperatur >= 30) {
      Serial.println("Heiss!");
    }
    
    Serial.println("-----------------------------------");
    
    // Zusätzliche Ausgabe als CSV-Format (für Logger)
    Serial.print("CSV: ");
    Serial.print(millis() / 1000); // Zeit in Sekunden
    Serial.print(",");
    Serial.print(temperatur, 1);
    Serial.print(",");
    Serial.println(luftfeuchtigkeit, 1);
    
    Serial.println();
  }
  
  // Optional: Messwert alle 2 Sekunden über serielle Schnittstelle senden
  // Kann für andere Anwendungen (z.B. Python-Script) genutzt werden
  // delay(100);
}

/*
 * Zusätzliche Funktionen für erweiterte Anwendungen
 */

// Funktion: Durchschnitt über mehrere Messungen
float mittelwertMessung(int anzahl) {
  float sumTemp = 0;
  float sumHum = 0;
  int gueltigeMessungen = 0;
  
  for (int i = 0; i < anzahl; i++) {
    float h = dht.readHumidity();
    float t = dht.readTemperature();
    
    if (!isnan(h) && !isnan(t)) {
      sumTemp += t;
      sumHum += h;
      gueltigeMessungen++;
    }
    delay(100);
  }
  
  if (gueltigeMessungen == 0) {
    return -999; // Fehlerwert
  }
  
  // Ausgabe der Durchschnittswerte
  Serial.print("Mittelwert (");
  Serial.print(gueltigeMessungen);
  Serial.print(" Messungen): Temp=");
  Serial.print(sumTemp / gueltigeMessungen, 1);
  Serial.print("°C, Feuchte=");
  Serial.print(sumHum / gueltigeMessungen, 1);
  Serial.println("%");
  
  return sumTemp / gueltigeMessungen;
}

// Funktion: Max/Min Werte über Zeitraum
void minMaxWerte(int dauerSekunden) {
  float minTemp = 100, maxTemp = -100;
  float minHum = 100, maxHum = -100;
  unsigned long startZeit = millis();
  
  Serial.print("Min/Max Werte über ");
  Serial.print(dauerSekunden);
  Serial.println(" Sekunden:");
  
  while (millis() - startZeit < dauerSekunden * 1000) {
    float h = dht.readHumidity();
    float t = dht.readTemperature();
    
    if (!isnan(h) && !isnan(t)) {
      if (t < minTemp) minTemp = t;
      if (t > maxTemp) maxTemp = t;
      if (h < minHum) minHum = h;
      if (h > maxHum) maxHum = h;
    }
    delay(200);
  }
  
  Serial.print("Temperatur: Min=");
  Serial.print(minTemp, 1);
  Serial.print("°C, Max=");
  Serial.print(maxTemp, 1);
  Serial.println("°C");
  
  Serial.print("Luftfeuchte: Min=");
  Serial.print(minHum, 1);
  Serial.print("%, Max=");
  Serial.print(maxHum, 1);
  Serial.println("%");
}

// Funktion: Alarm bei Grenzwertüberschreitung
void alarmPruefung(float tempMin, float tempMax, float humMin, float humMax) {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  if (isnan(h) || isnan(t)) return;
  
  if (t < tempMin || t > tempMax || h < humMin || h > humMax) {
    Serial.println("!!! ALARM !!! Grenzwert ueberschritten!");
    
    if (t < tempMin) {
      Serial.print("Temperatur zu niedrig: ");
      Serial.print(t, 1);
      Serial.println("°C");
    }
    if (t > tempMax) {
      Serial.print("Temperatur zu hoch: ");
      Serial.print(t, 1);
      Serial.println("°C");
    }
    if (h < humMin) {
      Serial.print("Luftfeuchtigkeit zu niedrig: ");
      Serial.print(h, 1);
      Serial.println("%");
    }
    if (h > humMax) {
      Serial.print("Luftfeuchtigkeit zu hoch: ");
      Serial.print(h, 1);
      Serial.println("%");
    }
    
    // Hier könnte man z.B. einen Summer oder LED einschalten
    // digitalWrite(BUZZER_PIN, HIGH);
  }
}