Mal wieder millis()..... ;)

Hi,

ich habe mal wieder ne verständnisfrage den mein Kopf scheint mal wieder ein Overload zu haben. Ich habe 2 Luftfeuchte Sensoren (DHT11 & DHT22) die ich in einem Abstand von 2s nacheinander auslesen möchte. Also Sensor DHT11 nach 2s, Sensor DHT22 nach weiteren 2s, DHT11 wieder nach weiteren 2s…ihr wisst was ich meine. Leider habe ich einen schweren Denkfehler drin und grübel nun schon sehr lange darüber nach ohne auf die Lösung zu kommen. Mir ist klar wie ich es mit Delay hinbekomme, aber ich möchte es in millis machen. Dachte mir das beide millis funktionen voneinander abhändig sein müssen, aber wie? Hier mal ein Auszugvom relevanten Code:

int interval_in = 4000;
int interval_out = 2000;

void setup(void) // Setup wird einmalig durchlaufen
{
  prev_in = millis();
  prev_out = millis(); 
}

void HumidityInside() // Loop für die Luftfeuchte "Inside"
{  
  if((millis() - prev_in) > interval_in) { // Delay mit Millis damit der µC nach andere Dinge paralell abarbeiten kann
  prev_in = millis(); // Aktuelle millis Zeit in "prev_in" speichern
  DHT.read11(DHT11_PIN); // DHT11_PIN einlesen
  float Humidity_In = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_In >= 20 && Humidity_In <= 90){ // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_In,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_hi = Humidity_In,0; // Innen - Luftfeuchte holen und speichern
   }
  }
}


void HumidityOutside() // Loop für die Luftfeuchte "Outside"
{
  if((millis() - prev_out) > interval_out) { // Delay mit Millis damit der µC nach andere Dinge paralell abarbeiten kann
  prev_out = millis(); // Aktuelle millis Zeit in "prev_out" speichern
  DHT.read22(DHT22_PIN); // DHT22_PIN einlesen
  float Humidity_Out = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_Out >= 0 && Humidity_Out <= 100){ // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_Out,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_ho = Humidity_Out,0; // Innen - Luftfeuchte holen und speichern
    }
  }
}

void loop(void) // Diese Loop wird ständig wiederholt
{ 
  HumidityInside(); // Ausgabe der Luftfeuchte vom "HumidityInside" 
  HumidityOutside(); // Ausgabe der Luftfeuchte vom "HumidityOutside"
}

In dieser Konstellation ist es ja so das ein Sensor alle 2s aufgelesen wird, der andere alle 4s…ist dann aber so das ja alle 4s, 8s, 12s etc… trotzdem beide “gleichzeitig” ausgelesen werden… :~

Help…please…

Grüße Thomas

#define DHT11_PIN A0
#define DHT22_PIN A1

int State = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated
long interval = 2000;           // interval at which to blink (milliseconds)

void setup() {
  pinMode(DHT11_PIN, INPUT); 
  pinMode(DHT22_PIN, INPUT);   
}

void loop()
{
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;   
    if (State == LOW)
      HumidityInside();
    else
      HumidityOutside();
  }
}

void HumidityInside() // Loop für die Luftfeuchte "Inside"
{  
  DHT.read11(DHT11_PIN); // DHT11_PIN einlesen
  float Humidity_In = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_In >= 20 && Humidity_In <= 90)
  { // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_In,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_hi = Humidity_In,0; // Innen - Luftfeuchte holen und speichern
  }
}

void HumidityOutside() // Loop für die Luftfeuchte "Outside"
{
  DHT.read22(DHT22_PIN); // DHT22_PIN einlesen
  float Humidity_Out = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_Out >= 0 && Humidity_Out <= 100)
  { // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_Out,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_ho = Humidity_Out,0; // Innen - Luftfeuchte holen und speichern
  }
}

Megaionstorm:

#define DHT11_PIN A0

#define DHT22_PIN A1

int State = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated
long interval = 2000;           // interval at which to blink (milliseconds)

void setup() {
  pinMode(DHT11_PIN, INPUT);
  pinMode(DHT22_PIN, INPUT);   
}

void loop()
{
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;   
    if (State == LOW)
      HumidityInside();
    else
      HumidityOutside();
  }
}

void HumidityInside() // Loop für die Luftfeuchte “Inside”

  DHT.read11(DHT11_PIN); // DHT11_PIN einlesen
  float Humidity_In = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_In >= 20 && Humidity_In <= 90)
  { // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_In,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text “%”
    temp_hi = Humidity_In,0; // Innen - Luftfeuchte holen und speichern
  }
}

void HumidityOutside() // Loop für die Luftfeuchte “Outside”
{
  DHT.read22(DHT22_PIN); // DHT22_PIN einlesen
  float Humidity_Out = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_Out >= 0 && Humidity_Out <= 100)
  { // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_Out,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text “%”
    temp_ho = Humidity_Out,0; // Innen - Luftfeuchte holen und speichern
  }
}

öhm, du müstest die variable “State” noch ändern in dem if- und dem else-block oder hab ich was falsch verstanden?

Hallo Megaionstorm,

danke für deine Antwort, aber ist es dann nicht so der Humidity_Inside zwar alle 2s aufgerufen wird, aber sonst hallt die ganze zeit Humidity_Outside?! Das wäre ja nicht so gewollt....Oder verstehe ich das falsch?

Dachte so irgendwie:

int interval_in = 2000;
int interval_out = 2000;

void HumidityInside() // Loop für die Luftfeuchte "Inside"
{
  if((millis() - prev_in) > interval_in) { // Delay mit Millis damit der µC nach andere Dinge paralell abarbeiten kann
  prev_out = millis(); // Aktuelle millis Zeit in "prev" speichern
  DHT.read11(DHT11_PIN); // DHT11_i_PIN einlesen
  float Humidity_In = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_In >= 20 && Humidity_In <= 90){ // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_In,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_hi = Humidity_In,0; // Innen - Luftfeuchte holen und speichern
   }
  }
}

void HumidityOutside() // Loop für die Luftfeuchte "Inside"
{
  if((millis() - prev_out) > interval_out) { // Delay mit Millis damit der µC nach andere Dinge paralell abarbeiten kann
  prev_in = millis(); // Aktuelle millis Zeit in "prev" speichern
  DHT.read22(DHT22_PIN); // DHT11_o_PIN einlesen
  float Humidity_Out = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_Out >= 0 && Humidity_Out <= 100){ // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_Out,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_ho = Humidity_Out,0; // Innen - Luftfeuchte holen und speichern
    }
  }
}

Das Programm sollte eigentlich so funktionieren das der DHT11 und der DHT22 abwechselnd alle 2 Sekunden abgefragt werden.

void loop()
{
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis;   
    if (State == LOW)
    {
      HumidityInside();
      State = HIGH;
    }
      else
      {
        HumidityOutside();
        State = LOW;
      }
  }
}

Kleine Korrektur !

Hi,

sorry aber das klappt irgendwie nicht wirklich. =(

Ich könnt kotzen.....habe grad auch gesehen das folgendes passiert: Wenn ich einen Sensor rausziehe, nimmt er automatisch den Wert des noch verfügbaren Sensors an (im Display)..... ebenso wenn ich es mit dem anderen mache. Habe den DHT11 & DHT22 im Einsatz inkl. 100nF pro Sensor. Das ganze mit dem verzögern beim Auslesen rührt daher das die Sensoren als flasche werte angezeigt haben. Und ich nachgelesen habe das die Sensoren mindestens 2s pause benötigen.....

Benutzt Du die Adafruit Library für den DHT ?

Hi,

nein ich benutze diese http://arduino.cc/playground/Main/DHTLib

Habe in der Adafruit Library folgenden Hinweis gefunden:

// Connect pin 1 (on the left) of the sensor to +5V // Connect pin 2 of the sensor to whatever your DHTPIN is // Connect pin 4 (on the right) of the sensor to GROUND // Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

Hast Du schon einmal das Testprogramm aus dem Playground ausprobiert ?

Ja, der 10k ist bei beiden drin. Zwischen Vcc und GND noch einen 100nF und Pin3 des Sensors zusätzlich auf GND gelegt. Ich poste mal meinen gesamten Code morgen. OK?

Der komplette Code wird wohl am hilfreichsten sein !

Sodele,

hier mal mein gesamten Code. Ich versuche grad den Fehler zu reproduzieren. Leider ist es mir nicht gelungen es zuverlässig zu reproduzieren. Was ich bereits herausgefunden habe ist: Wenn ich die Min oder Max Taste “Rechtzeitig” drücke, passiert wieder dieser Fehler. Allerdings kann ich nicht sagen ob der Fehler während der normalen Anzeige kommt. Ich habe das gefühl das es nur dann passiert wenn ich die Min/Max Werte abrufe…Also nochmals der detailierter Fehler: Es wird die ganze Zeit die Temperatur und Luftfeuchte im Display angezeigt. Innenluftfeuchte kommt vom DHT11 und Aussen vom DHT22. Beide sind mit 100nF & 10k wie vorgesehen, beschaltet. Tempereturen werden von DS18B20 geliefert. Ab und an, wenn man die Min / Max Taste drückt, wird / wurde ein falscher Min / Max Wert gespeichert. Oder zumindest wird es dann erst sichtbar… Mir ist bewusst das die Sensoren schwanken können, aber wenn ich Momentan im Raum ca. 60% Luftfeuchte habe, und ich dann die Taste drücke, zeigt er mir an, das ich z.B. 30% Luftfeuchte hatte… Mir ist es schleierhaft wie diese ernormen Abweichungen zu stande kommen, gehe jedoch von aus das die Sensoren (DHT11 & 22) zu oft, oder zu schnell ausgelesen werden, oder durch irgendwas anderes gestört werden beim auslesen…also z.B. die Interrupt vom DCF oder die Abfrage der DS18B20.

Bevor ich es vergesse, dieser 1001ste Thermometer funktioniert geauso wie ich es haben möchte, bis auf den beschriebenen Fehler. Ebenso die kurz aufeinander folgende aufrufe des Befehls “sensors.requestTemperatures();” sind absicht…Hoffe das jemand den Fehler im Code sieht… :~

Hier der Code Teil 1:

// Hier werden die verwendete "Librarys" eingebunden
#include <OneWire.h> // OneWire Library (Nötig für den Bus an dem die DS18B20 hängen)
#include <DallasTemperature.h> // Dallas Library für die DS18B20
#include <LiquidCrystal.h> // LCD Library
#include <dht.h> // DHT11 Library (Für Feuchtesensor nötig)
#include <DCF77.h> // DCF77 Library für Pollin DCF Modul
#include <Utils.h> // Wird vom der DCF77 Library benötigt
#include <Time.h> // Time Library 

// Initialisierung der Pins und Werte
int ledPin = 9; // Hier ist der NPN Transistor BC547 über 1k5 Ohm an der Basis angeschlossen 
int analogPin = 0; // Am AnalogPin 0 ist der LDR (RS-Online Bestell Nr.: 596-141) über ein Spg. Teiler angeschlossen. 5V --> 100k --> A0 --> LDR --> GND 
int val = 0; // LDR Wert wird erstmal auf 0 gesetzt
int fadeValue = 200; // Initialisierungs PWM Wert (78,43%) für Backlight
const int analogPin1 = 16; // Min. Temp. Taster auf Pin 16
const int analogPin2 = 17; // Max. Temp. Taster auf Pin 17
const int analogPin3 = 15; // Uhrzeit Taster auf Pin 15
const int analogPin4 = 18; // HilfsPin für LCD Pin D7
int interval = 10000; // Intervalzeit für Temperaturabfrage (10s)
int interval_in = 4000;
int interval_out = 3000;
unsigned long prev; // Variable "prev" wird als "unsigned long" deklariert
unsigned long prev_in;
unsigned long prev_out;
int tempupdate = 0; // Tempupdate Variable mit 0 initialisieren
float temp_ti_min = 100; // Min. Temp. Inside mit 100 initialisieren (Trick damit geupdated wird.)
float temp_hi_min = 100; // Min. Hum. Inside mit 100 initialisieren (Trick damit geupdated wird.)
float temp_to_min = 100; // Min. Temp. Outside mit 100 initialisieren (Trick damit geupdated wird.)
float temp_ho_min = 100; // Min. Hum. Outside mit 100 initialisieren (Trick damit geupdated wird.)
float temp_ti_max = 0; // Max. Temp. Inside mit 0 initialisieren 
float temp_hi_max = 0; // Max. Hum. Inside mit 0 initialisieren 
float temp_to_max = 0; // Max. Temp. Outside mit 0 initialisieren 
float temp_ho_max = 0; // Max. Hum. Outside mit 0 initialisieren 
float temp_ti = 0; // Temp. Inside mit 0 initialisieren 
float temp_hi = 0; // Hum. Inside mit 0 initialisieren 
float temp_to = 0; // Temp. Outside mit 0 initialisieren 
float temp_ho = 0; // Hum. Outside mit 0 initialisieren 
int buttonState = 0; // Status Variable für die Buttons
int buttonState2 = 0; // Status Variable für die Buttons
int buttonStateClock = LOW; // ButtonStateClock mit "LOW" initialisieren
int lastbuttonStateClock = LOW; //LastButtonStateClock mit "LOW" initialisieren
int lastbuttonStateClock2 = LOW; // LastButtonStateClock2 mit "LOW" initialisieren
int buttonCount = 1; // Button Counter (Initialisierung mit 1 weil kein PullDown am Pin)
int screen = 0; // Screen 0 setzten (Temperaturanzeige)
long lastDebounceTime = 0; // DebounceTime auf 0 setzten
long debounceDelay = 100; // Entprellzeit (in ms) für Button

// Pollin DCF77 Modul Artikelnr.: 810054
#define DCF_PIN 2 // DCF Data Pin auf Arduino Pin 2
#define DCF_INTERRUPT 0 // Interrupt für Pin 2

time_t time; // Time Library starten
DCF77 DCF = DCF77(DCF_PIN,DCF_INTERRUPT); // DCF77 Library starten

// Der OneWire Bus für DS18B20 hängt an Pin 8
#define ONE_WIRE_BUS 8

// LCD wird mit folgenden Pins initialisiert
LiquidCrystal lcd(1, 0, 5, 4, 3, 18);

// Errichtet eine Instanz um mit anderen OneWire Geräten zu kommunizieren zu können
OneWire oneWire(ONE_WIRE_BUS);

// Verweis das die Dallas Temperatur Sensoren am OneWire Bus dran sind 
DallasTemperature sensors(&oneWire);

// DHT Library starten
dht DHT;
// Definiere Pin für Innen- und Aussen Feuchtesensor 
#define DHT11_PIN 6 // Innensensor
#define DHT22_PIN 7 // Aussensensor


// Die DS18B20 Sensoren werden per Seriennummer "Hard" gecoded
// Hier gibt es ein Tutorial wie man an die Seriennummer kommt:
// http://www.hacktronics.com/Tutorials/arduino-1-wire-address-finder.html

// Seriennummer der verwendeten Dallas DS18B20 Sensoren
DeviceAddress insideThermometer = { 
  0x28, 0x26, 0xD5, 0xD1, 0x03, 0x00, 0x00, 0xFC }; // Seriennummer für den "insideThermometer"
DeviceAddress outsideThermometer = { 
  0x28, 0x6D, 0xF0, 0xD1, 0x03, 0x00, 0x00, 0x5B }; // Seriennummer für den "outsideThermometer"

// Zeichentabelle für "Eigene" Zeichen
// Um eigene Zeichen zu erstellen kann die Seite verwendet werden:
// http://www.quinapalus.com/hd44780udg.html

// Zeichen "haken"
byte haken[8] = {
  B00000, // Zeile 1
  B00001, // Zeile 2
  B00011, // Zeile 3
  B10110, // Zeile 4
  B11100, // Zeile 5
  B01000, // Zeile 6
  B00000, // Zeile 7
  B00000, // Zeile 8
};

// Zeichen "update"
byte update[8] = {
  B00000, // Zeile 1
  B00100, // Zeile 2
  B00100, // Zeile 3
  B01110, // Zeile 4
  B01110, // Zeile 5
  B11111, // Zeile 6
  B11111, // Zeile 7
  B00000, // Zeile 8
};

// Zeichen "del"
byte del[8] = {
  B00000, // Zeile 1
  B00000, // Zeile 2
  B00000, // Zeile 3
  B00000, // Zeile 4
  B00000, // Zeile 5
  B00000, // Zeile 6
  B00000, // Zeile 7
  B00000, // Zeile 8
};


void setup(void) // Setup wird einmalig durchlaufen
{
  pinMode(ledPin, OUTPUT); // ledPin 13 (Backlight Ansteuerung per NPN Transistor (BC547)) wird als Ausgang deklariert
  analogWrite(ledPin, 200); // Schreibe ein PWM Wert von 200 (78,43%) als Initialwert für Backlight
  pinMode(analogPin1, INPUT); // analogPin1 (Min. Temp. Taster) wird als Eingang deklariert
  pinMode(analogPin2, INPUT); // analogPin2 (Max. Temp. Taster) wird als Eingang deklariert
  pinMode(analogPin3, INPUT); // analogPin3 (Umschaltaster Uhrzeit / Temp-Feuchte)
  pinMode(analogPin4, OUTPUT); // analogPin4 (Hilfs Pin für LCD)
  prev = millis(); // Millis (Zeit seitdem der µC läuft) wird in Variable "prev" geschrieben
  prev_in = millis();
  prev_out = millis(); 
  sensors.begin(); // Sensoren (DS18B20) initialisieren 
  sensors.setResolution(insideThermometer, 12); // Auflösung des Wertebereichs auf 12 bit
  sensors.setResolution(outsideThermometer, 12); // Auflösung des Wertebereichs auf 12 bit
  lcd.begin(20,4); // LCD initialisieren und auf 20 Zeichen, 4 Zeilen setzten
  lcd.clear(); // Alles auf LCD löschen
  DCF.Start(); // DCF starten
  
  // Hier werden "Eigene" Zeichen aus den "byte" (vor der setup deklariert) für das Display erstellt
  
  lcd.createChar(0, haken); // Erstellt Zeichen "haken" und kann über // lcd.print(char(0)); // im Programm jederzeit aufgerufen werden
  lcd.createChar(1, update); // Erstellt Zeichen "update" und kann über // lcd.print(char(1)); // im Programm jederzeit aufgerufen werden
  lcd.createChar(2, del); // Erstellt Zeichen "del" und kann über // lcd.print(char(2)); // im Programm jederzeit aufgerufen werden

  // Screen 1
  lcd.setCursor(2,1); // Cursorbeginn auf Zeichen 2, Zeile 2
  lcd.print("Found "); // Text "Found "
  lcd.print(sensors.getDeviceCount(), DEC); // DEC gibt die Anzahl der gefundenen Sensoren aus
  //Entscheidung ob "sensor" oder "sensors" ausgegeben wird
  if (sensors.getDeviceCount() == 2) { 
    lcd.print(" sensors"); // gibt bei 2 Sensoren "sensors" aus
  } 
  else {
    lcd.print(" sensor"); // gibt bei 1 Sensor "sensor" aus
  }
  
  // Hier werden die Haken dargestellt
  if (sensors.getDeviceCount() == 1) { // Hier wird die Anzahl der Sensoren geholt
    lcd.setCursor(2,2); // Cursorbeginn auf Zeichen 2, Zeile 3
    lcd.print(char(0)); // Zeichne "Haken"
  }
  if (sensors.getDeviceCount() == 2) { // Hier wird die Anzahl der Sensoren geholt
    lcd.setCursor(2,2); // Cursorbeginn auf Zeichen 2, Zeile 3
    lcd.print(char(0)); // Zeichne "Haken"
    lcd.setCursor(3,2); // Cursorbeginn auf Zeichen 3, Zeile 3
    lcd.print(char(0)); // Zeichne "Haken"
  }
  delay(2000); // Anzeige für 2s darstellen
  lcd.clear(); // Alles auf LCD löschen

  //Screen 2 (Initialscreen für Loop Schleife)
  lcd.setCursor(0, 0); // Cursorbeginn auf Zeichen 0, Zeile 1
  lcd.print("Wohnzimmer:"); // Text "Wohnzimmer:" 
  lcd.setCursor(0, 2); // Cursorbeginn auf Zeichen 0, Zeile 3
  lcd.print("Aussen:"); // Text "Aussen:"
  sensors.requestTemperatures(); // Temp Werte holen lassen
  lcd.setCursor(10, 1); // Cursorbeginn auf Zeichen 6, Zeile 2
  InTemperature(); //Ausgabe des Temp. Wertes vom "InTemperature"
  lcd.setCursor(17, 1); // Cursorbeginn auf Zeichen 13, Zeile 2
  HumidityInside(); // Ausgabe der Luftfeuchte vom "HumidityInside" 
  lcd.setCursor(10, 3); // Cursorbeginn auf Zeichen 6, Zeile 2
  OutTemperature(); //Ausgabe des Temp. Wertes vom "OutTemperature"
  lcd.setCursor(17, 3); // Cursorbeginn auf Zeichen 13, Zeile 2
  HumidityOutside(); // Ausgabe der Luftfeuchte vom "HumidityInside"
}

Teil 2:

void InTemperature() // Einlese Loop die DS18B20 Sensoren
{
  float tempC = sensors.getTempC(insideThermometer); // Temp. Werte werden mit Float in einer Anhängigkeit der Sensor Seriennummer gespeichert.
  if (tempC == -127.00) { // Wenn Temp. Sensor Wert "-127.00"
    lcd.print("NoDev."); // wird der Text "NoDev." ausgegeben
    if (tempC == 85.00) { // Wenn Temp. Sensor Wert "85.00"
      lcd.print("Error"); // wird "Error " ausgegeben
    }
  } 
  else if (tempC < 0.0){ // Wenn Temp. < 0.0°C 
    if (tempC <= -10.0){ // Wenn Temp. <= -10.0°C 
      lcd.setCursor(7,1); // Cursorbeginn auf Zeichen 8, Zeile 2
      lcd.print("  "); // Text " "
      lcd.setCursor(9,1); // Cursorbeginn auf Zeichen 9, Zeile 2
    }
    else {
      lcd.setCursor(8,1); // Cursorbeginn auf Zeichen 9, Zeile 2
      lcd.print("  "); // Text " "
      lcd.setCursor(10,1); // Cursorbeginn auf Zeichen 10, Zeile 2
    }
  }
  else if (tempC < 10.0){ // Wenn Temp. < 10.0°C 
    lcd.setCursor(9,1); // Cursorbeginn auf Zeichen 10, Zeile 2
    lcd.print("  "); // Text " "
    lcd.setCursor(11,1); // Cursorbeginn auf Zeichen 11, Zeile 2
  }
  else { // Sonst normale Ausgabe
    lcd.setCursor(8,1); // Cursorbeginn auf Zeichen 10, Zeile 4
    lcd.print("  "); // Text " "
    lcd.setCursor(10,1); // Cursorbeginn auf Zeichen 10, Zeile 2
  }
  temp_ti = tempC,1; // Aktuelle Temp. in Variable temp_ti schreiben
  lcd.print(tempC,1); // Schreibe Temperatur mit nur 1 Nachkommastelle (,1)
  lcd.print(char(223)); // Erstelle mit char(223) das ° Zeichen
  lcd.print("C "); // Text "C "
}

void OutTemperature() // Einlese Loop die DS18B20 Sensoren
{
  float tempC = sensors.getTempC(outsideThermometer); // Temp. Werte werden mit Float in einer Anhängigkeit der Sensor Seriennummer gespeichert.
  if (tempC == -127.00) { // Wenn Temp. Sensor Wert "-127.00"
    lcd.print("NoDev."); // wird der Text "NoDev." ausgegeben
    if (tempC == 85.00) { // Wenn Temp. Sensor Wert "85.00"
      lcd.print("Error"); // wird "Error " ausgegeben
    }
  } 
  else if (tempC < 0.0){ // Wenn Temp. < 0.0°C 
    if (tempC <= -10.0){ // Wenn Temp. <= -10.0°C 
      lcd.setCursor(7,3); // Cursorbeginn auf Zeichen 8, Zeile 4
      lcd.print("  "); // Text " "
      lcd.setCursor(9,3); // Cursorbeginn auf Zeichen 9, Zeile 4
    }
    else {
      lcd.setCursor(8,3); // Cursorbeginn auf Zeichen 9, Zeile 4
      lcd.print("  "); // Text " "
      lcd.setCursor(10,3); // Cursorbeginn auf Zeichen 6, Zeile 4
    }
  }
  else if (tempC < 10.0){ // Wenn Temp. < 10.0°C 
    lcd.setCursor(9,3); // Cursorbeginn auf Zeichen 10, Zeile 4
    lcd.print("  "); // Text " "
    lcd.setCursor(11,3); // Cursorbeginn auf Zeichen 11, Zeile 4
  }
  else { // Sonst normale Ausgabe
    lcd.setCursor(8,3); // Cursorbeginn auf Zeichen 10, Zeile 4
    lcd.print("  "); // Text " "
    lcd.setCursor(10,3); // Cursorbeginn auf Zeichen 10, Zeile 4
  }
  temp_to = tempC,1; // Aktuelle Temp. in Variable temp_to schreiben
  lcd.print(tempC,1); // Schreibe Temperatur mit nur 1 Nachkommastelle (,1)
  lcd.print(char(223)); // Erstelle mit char(223) das ° Zeichen
  lcd.print("C "); // Text "C " 
}

void HumidityInside() // Loop für die Luftfeuchte "Inside"
{
  if((millis() - prev_in) > interval_in) { // Delay mit Millis damit der µC nach andere Dinge paralell abarbeiten kann
  prev_in = millis(); // Aktuelle millis Zeit in "prev" speichern
  DHT.read11(DHT11_PIN); // DHT11_i_PIN einlesen
  float Humidity_In = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_In >= 20 && Humidity_In <= 90){ // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_In,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_hi = Humidity_In,0; // Innen - Luftfeuchte holen und speichern
   }
  }
}

void HumidityOutside() // Loop für die Luftfeuchte "Inside"
{
  if((millis() - prev_out) > interval_out) { // Delay mit Millis damit der µC nach andere Dinge paralell abarbeiten kann
  prev_out = millis(); // Aktuelle millis Zeit in "prev" speichern
  DHT.read22(DHT22_PIN); // DHT11_o_PIN einlesen
  float Humidity_Out = DHT.humidity; // Luftfeuchte in float Variable speichern
  if (Humidity_Out >= 0 && Humidity_Out <= 100){ // Erst speichern wenn Feuchtesensor plausieblen Wert zwischen 20 % und 90 % liefert
    lcd.print(Humidity_Out,0); // Luftfeuchte ohne Nachkommastelle anzeigen
    lcd.print("%"); // Text "%"
    temp_ho = Humidity_Out,0; // Innen - Luftfeuchte holen und speichern
    }
  }
}

Teil 3:

void Backlight() // Loop für Backlight Steuerung (val>650 & val<550 als Hysterese)
{
  val = analogRead(analogPin);   // Den Analogen Pin einlesen und den Wert in "val" speichern (Bereich 0 - 1023)
  if (val >850) { // Wenn der "val" Wert >650
    for(fadeValue ; fadeValue >= 1; fadeValue -=1) { // Fade in von max zu min per increment in 5 Schritten:
      analogWrite(ledPin, fadeValue); // Schreibe PWM Wert von "fadeValue" auf den LED Pin          
      delay(30);  // Warte 30ms 
    } 
  }
  if (val <700) { // Wenn der "val" Wert >650
    for(fadeValue ; fadeValue <= 15; fadeValue +=1) { // Fade in von max zu min per increment in 5 Schritten:
      analogWrite(ledPin, fadeValue); // Schreibe PWM Wert von "fadeValue" auf den LED Pin          
      delay(30);  // Warte 30ms 
    } 
  }
  if (val >=550 && val <=650) { // Wenn der "val" Wert >650
    for(fadeValue ; fadeValue >= 20; fadeValue -=5) { // Fade in von max zu min per increment in 5 Schritten:
      analogWrite(ledPin, fadeValue); // Schreibe PWM Wert von "fadeValue" auf den LED Pin          
      delay(30);  // Warte 30ms 
    } 
  }
  if (val <=450) { // Wenn der "val" Wert <550
    for(fadeValue ; fadeValue <= 200; fadeValue +=5) { // Fade out von min zu max per decrement in 5 Schritten:
      analogWrite(ledPin, fadeValue); // Schreibe PWM Wert von "fadeValue" auf den LED Pin           
      delay(30);  // Warte 30ms 
    }
  }
}



void UpdateMinMax() // Speicherung der minimalen und maximalen Temperatur / Luftfeuchte  
{
  if (temp_ti < temp_ti_min){ // Wenn Innen - Temperatur kleiner Innen - Temp. Min. Speicher
    temp_ti_min = temp_ti; // Dann Innen - Temp. abspeichern
  }
  if (temp_hi < temp_hi_min){ // Wenn Innen - Luftfeuchte kleiner Innen - Temp. Min. Speicher
    temp_hi_min = temp_hi; // Dann Innen - Temp. abspeichern
  }
  if (temp_ti > temp_ti_max){ // Wenn Innen - Temperatur größer Innen - Temp. Max. Speicher
    temp_ti_max = temp_ti; // Dann Innen - Temp. abspeichern
  }
  if (temp_hi > temp_hi_max){ // Wenn Innen - Luftfeuchte größer Innen - Temp. Max. Speicher
    temp_hi_max = temp_hi; // Dann Innen - Temp. abspeichern
  }    
  if (temp_to < temp_to_min){ // Wenn Aussen - Temperatur kleiner Aussen - Temp. Min. Speicher
    temp_to_min = temp_to; // Dann Aussen - Temp. abspeichern
  }
  if (temp_ho < temp_ho_min){ // Wenn Aussen - Luftfeuchte kleiner Aussen - Temp. Min. Speicher
    temp_ho_min = temp_ho; // Dann Aussen - Temp. abspeichern
  }
  if (temp_to > temp_to_max){ // Wenn Aussen - Temperatur größer Aussen - Temp. Max. Speicher
    temp_to_max = temp_to; // Dann Aussen - Temp. abspeichern
  }
  if (temp_ho > temp_ho_max){ // Wenn Aussen - Luftfeuchte größer Aussen - Temp. Max. Speicher
    temp_ho_max = temp_ho; // Dann Aussen - Temp. abspeichern
  }    
}


void ShowMin() // Minimale Temp. / Luftfeuchte auf LCD darstellen
{
  tempupdate = 0; // Tempupdate auf 0 setzten
  lcd.setCursor(0,1); // Cursorbeginn auf Zeichen 0, Zeile 2
  lcd.print("           "); // Text "          "
  lcd.setCursor(0,1); // Cursorbeginn auf Zeichen 0, Zeile 2
  lcd.print("Min:"); // Text "Min:"
   if (temp_ti_min < 0.0){ // Wenn Temp. < 0.0°C 
    if (temp_ti_min <= -10.0){ // Wenn Temp. <= -10.0°C 
      lcd.setCursor(9,1); // Cursorbeginn auf Zeichen 9, Zeile 2
    }
    else{
      lcd.setCursor(10,1); // Cursorbeginn auf Zeichen 10, Zeile 2
    }
  }
  else if (temp_ti_min < 10.0){ // Wenn Temp. < 10.0°C 
    lcd.setCursor(11,1); // Cursorbeginn auf Zeichen 11, Zeile 2
  }
  else { // Sonst normale Ausgabe
    lcd.setCursor(10,1); // Cursorbeginn auf Zeichen 10, Zeile 2
  }
  lcd.print(temp_ti_min,1); // Min. Temp. darstellen und auf 1 Stelle begrenzen 
  lcd.print(char(223)); // Erstelle mit char(223) das ° Zeichen
  lcd.print("C "); // Text "C " 
  lcd.setCursor(17,1); // Cursorbeginn auf Zeichen 17, Zeile 2
  lcd.print(temp_hi_min,0); // Min. Luftfeuchte darstellen und ohne Nachkommastelle darstellen
  lcd.print("%"); // Text ("%")
  lcd.setCursor(0,3); // Cursorbeginn auf Zeichen 0, Zeile 4
  lcd.print("           "); // Text "          "
  lcd.setCursor(0,3); // Cursorbeginn auf Zeichen 0, Zeile 4
  lcd.print("Min:"); // Text "Min:"
  if (temp_to_min < 0.0){ // Wenn Temp. < 0.0°C 
    if (temp_to_min <= -10.0){ // Wenn Temp. <= -10.0°C 
      lcd.setCursor(9,3); // Cursorbeginn auf Zeichen 9, Zeile 4
    }
    else{
      lcd.setCursor(10,3); // Cursorbeginn auf Zeichen 10, Zeile 4
    }
  }
  else if (temp_to_min < 10.0){ // Wenn Temp. < 10.0°C 
    lcd.setCursor(11,3); // Cursorbeginn auf Zeichen 11, Zeile 4
  }
  else { // Sonst normale Ausgabe
    lcd.setCursor(10,3); // Cursorbeginn auf Zeichen 10, Zeile 4
  }
  lcd.print(temp_to_min,1); // Min. Temp. darstellen und auf 1 Stelle begrenzen 
  lcd.print(char(223)); // Erstelle mit char(223) das ° Zeichen
  lcd.print("C "); // Text "C " 
  lcd.setCursor(17,3); // Cursorbeginn auf Zeichen 17, Zeile 4
  lcd.print(temp_ho_min,0); // Min. Luftfeuchte darstellen und ohne Nachkommastelle darstellen
  lcd.print("%"); // Text ("%")
  sensors.requestTemperatures(); // Temp Werte holen lassen
  delay(1000); // Werte für 1s darstellen
  buttonState = digitalRead(analogPin1); // Min. Taster überwachen
  if (buttonState == HIGH) {  // Wenn Min. Taster nicht gedrückt ist normale Anzeige  
    lcd.setCursor(0,1); // Cursorbeginn auf Zeichen 0, Zeile 2
    lcd.print("            "); // Trick um "Min:" Text zu löschen ohne "lcd.clear" aufzurufen
    InTemperature(); // Ausgabe des Temp. Wertes vom "InTemperature"
    lcd.setCursor(17, 1); // Cursorbeginn auf Zeichen 17, Zeile 2
    HumidityInside(); // Ausgabe der Luftfeuchte vom "HumidityInside"
    lcd.setCursor(0,3); // Cursorbeginn auf Zeichen 0, Zeile 4
    lcd.print("            "); // Trick um "Min:" Text zu löschen ohne "lcd.clear" aufzurufen
    OutTemperature(); // Ausgabe des Temp. Wertes vom "OutTmperature"
    lcd.setCursor(17, 3); // Cursorbeginn auf Zeichen 17, Zeile 4
    HumidityOutside(); // Ausgabe der Luftfeuchte vom "HumidityOutside" 
  } else { // Wenn Min. Taster noch immer gedrückt wird, dann alle gespeicherten Werte zurücksetzten
    tempupdate = 1; //Tempupdate auf 1 setzten um nach Anzeige ein Update des Screens zu erzeugen
    temp_ti_min = 100; // Min. Temp. Inside auf 100 zurücksetzten (Trick damit geupdated wird.)
    temp_hi_min = 100; // Min. Hum. Inside auf 100 zurücksetzten (Trick damit geupdated wird.)
    temp_to_min = 100; // Min. Temp. Outside auf 100 zurücksetzten (Trick damit geupdated wird.)
    temp_ho_min = 100; // Min. Hum. Outside auf 100 zurücksetzten (Trick damit geupdated wird.)
    lcd.clear(); // Anzeige löschen
    lcd.setCursor(2,1); // Cursorbeginn auf Zeichen 2, Zeile 2
    lcd.print("Stored Min. data"); // Text "Stored Min. data"
    lcd.setCursor(2,2); // Cursorbeginn auf Zeichen 2, Zeile 3
    lcd.print("deleted!"); // Text "deleted!"
    delay(2000); // 2s den Text anzeigen
    }
}

Teil 4:

void ShowMax() // Maximale Temp. / Luftfeuchte auf LCD darstellen
{
  tempupdate = 0; // Tempupdate auf 0 setzten 
  lcd.setCursor(0,1); // Cursorbeginn auf Zeichen 0, Zeile 2
  lcd.print("           "); // Text "          "
  lcd.setCursor(0,1); // Cursorbeginn auf Zeichen 0, Zeile 2
  lcd.print("Max:"); // Text "Max:"
   if (temp_ti_max < 0.0){ // Wenn Temp. < 0.0°C 
    if (temp_ti_max <= -10.0){ // Wenn Temp. <= -10.0°C 
      lcd.setCursor(9,1); // Cursorbeginn auf Zeichen 9, Zeile 2
    }
    else{
      lcd.setCursor(10,1); // Cursorbeginn auf Zeichen 10, Zeile 2
    }
  }
  else if (temp_ti_max < 10.0){ // Wenn Temp. < 10.0°C 
    lcd.setCursor(11,1); // Cursorbeginn auf Zeichen 11, Zeile 2
  }
  else { // Sonst normale Ausgabe
    lcd.setCursor(10,1); // Cursorbeginn auf Zeichen 10, Zeile 2
  }
  lcd.print(temp_ti_max,1); // Max. Temp. darstellen und auf 1 Stelle begrenzen 
  lcd.print(char(223)); // Erstelle mit char(223) das ° Zeichen
  lcd.print("C "); // Text "C " 
  lcd.setCursor(17,1); // Cursorbeginn auf Zeichen 17, Zeile 2
  lcd.print(temp_hi_max,0); // Max. Luftfeuchte darstellen und ohne Nachkommastelle darstellen
  lcd.print("%"); // Text ("%")
  lcd.setCursor(0,3); // Cursorbeginn auf Zeichen 0, Zeile 4
  lcd.print("           "); // Text "          "
  lcd.setCursor(0,3); // Cursorbeginn auf Zeichen 0, Zeile 4
  lcd.print("Max:"); // Text "Max:"
  if (temp_to_max < 0.0){ // Wenn Temp. < 0.0°C 
    if (temp_to_max <= -10.0){ // Wenn Temp. <= -10.0°C 
      lcd.setCursor(9,3); // Cursorbeginn auf Zeichen 9, Zeile 4
    }
    else{
      lcd.setCursor(10,3); // Cursorbeginn auf Zeichen 10, Zeile 4
    }
  }
  else if (temp_to_max < 10.0){ // Wenn Temp. < 10.0°C 
    lcd.setCursor(11,3); // Cursorbeginn auf Zeichen 11, Zeile 4
  }
  else { // Sonst normale Ausgabe
    lcd.setCursor(10,3); // Cursorbeginn auf Zeichen 10, Zeile 4
  }
  lcd.print(temp_to_max,1); // Max. Temp. darstellen und auf 1 Stelle begrenzen 
  lcd.print(char(223)); // Erstelle mit char(223) das ° Zeichen
  lcd.print("C "); // Text "C " 
  lcd.setCursor(17,3); // Cursorbeginn auf Zeichen 17, Zeile 4
  lcd.print(temp_ho_max,0); // Max. Luftfeuchte darstellen und ohne Nachkommastelle darstellen
  lcd.print("%"); // Text ("%")
  sensors.requestTemperatures(); // Temp Werte holen lassen
  delay(1000); // Werte für 1s darstellen
  buttonState2 = digitalRead(analogPin2); // Min. Taster überwachen
  if (buttonState2 == HIGH) {  // Wenn Min. Taster nicht gedrückt ist normale Anzeige  
    lcd.setCursor(0,1); // Cursorbeginn auf Zeichen 0, Zeile 2
    lcd.print("            "); // Trick um "Max:" Text zu löschen ohne "lcd.clear" aufzurufen
    InTemperature(); // Ausgabe des Temp. Wertes vom "InTemperature"
    lcd.setCursor(17, 1); // Cursorbeginn auf Zeichen 17, Zeile 2
    HumidityInside(); // Ausgabe der Luftfeuchte vom "HumidityInside"
    lcd.setCursor(0,3); // Cursorbeginn auf Zeichen 0, Zeile 4
    lcd.print("            "); // Trick um "Max:" Text zu löschen ohne "lcd.clear" aufzurufen 
    OutTemperature(); // Ausgabe des Temp. Wertes vom "OutTmperature"
    lcd.setCursor(17, 3); // Cursorbeginn auf Zeichen 17, Zeile 4
    HumidityOutside(); // Ausgabe der Luftfeuchte vom "HumidityOutside" 
  } else { // Wenn Max. Taster noch immer gedrückt wird, dann alle gespeicherten Werte zurücksetzten
    tempupdate = 1; //Tempupdate auf 1 setzten um nach Anzeige ein Update des Screens zu erzeugen
    temp_ti_max = 0; // Max. Temp. Inside auf 0 zurücksetzten (Trick damit geupdated wird.)
    temp_hi_max = 0; // Max. Hum. Inside auf 0 zurücksetzten (Trick damit geupdated wird.)
    temp_to_max = 0; // Max. Temp. Outside auf 0 zurücksetzten (Trick damit geupdated wird.)
    temp_ho_max = 0; // Max. Hum. Outside auf 0 zurücksetzten (Trick damit geupdated wird.)
    lcd.clear(); // Anzeige löschen
    lcd.setCursor(2,1); // Cursorbeginn auf Zeichen 2, Zeile 2
    lcd.print("Stored Max. data"); // Text "Stored Min. data"
    lcd.setCursor(2,2); // Cursorbeginn auf Zeichen 2, Zeile 3
    lcd.print("deleted!"); // Text "deleted!"
    delay(2000); // 2s den Text anzeigen
    }
}


void ShowActual () // Aktuelle Temperatur und Luftfeuchte darstellen
{
  tempupdate = 0; // Tempupdate auf 0 setzten
  if((millis() - prev) > interval) { // Delay mit Millis damit der µC nach andere Dinge paralell abarbeiten kann
    prev = millis(); // Aktuelle millis Zeit in "prev" speichern
    lcd.setCursor(0, 1); // Cursorbeginn auf Zeichen 0, Zeile 2
    lcd.print(char(1)); // Zeichne (char(1)) "update"
    sensors.requestTemperatures(); // Temp Werte holen lassen
    InTemperature(); // Ausgabe des Temp. Wertes vom "InTemperature"
    lcd.setCursor(17, 1); // Cursorbeginn auf Zeichen 17, Zeile 2
    HumidityInside(); // Ausgabe der Luftfeuchte vom "HumidityInside" 
    lcd.setCursor(0, 1); // Cursorbeginn auf Zeichen 0, Zeile 2
    lcd.print(char(2)); // Zeichne (char(2)) "del"
    lcd.setCursor(0, 3); // Cursorbeginn auf Zeichen 0, Zeile 4
    lcd.print(char(1)); // Zeichne (char(1)) "update"
    sensors.requestTemperatures(); // Temp Werte holen lassen
    OutTemperature(); // Ausgabe des Temp. Wertes vom "OutTemperature"
    lcd.setCursor(17, 3); // Cursorbeginn auf Zeichen 17, Zeile 4
    HumidityOutside(); // Ausgabe der Luftfeuchte vom "HumidityInside" 
    lcd.setCursor(0, 3); // Cursorbeginn auf Zeichen 0, Zeile 4
    lcd.print(char(2)); // Zeichne (char(2)) "del"   
  }
}

void ShowActualClock () // Aktuelle Temperatur und Luftfeuchte darstellen
{
  tempupdate = 0; // Tempupdate auf 0 setzten
  lcd.clear(); // LCD löschen
  lcd.setCursor(0, 0); // Cursorbeginn auf Zeichen 0, Zeile 1
  lcd.print("Wohnzimmer:"); // Text "Wohnzimmer:" 
  lcd.setCursor(0, 2); // Cursorbeginn auf Zeichen 0, Zeile 3
  lcd.print("Aussen:"); // Text "Aussen:"
  sensors.requestTemperatures(); // Temp Werte holen lassen
  InTemperature(); //Ausgabe des Temp. Wertes vom "InTemperature"
  lcd.setCursor(17, 1); // Cursorbeginn auf Zeichen 17, Zeile 2
  HumidityInside(); // Ausgabe der Luftfeuchte vom "HumidityInside" 
  OutTemperature(); // Ausgabe des Temp. Wertes vom "OutTemperature"
  lcd.setCursor(17, 3); // Cursorbeginn auf Zeichen 17, Zeile 4
  HumidityOutside(); // Ausgabe der Luftfeuchte vom "HumidityOutside"
}

Teil 5:

void digitalClockDisplay() // Uhrzeit Ausgabe auf LCD
{
  tempupdate = 1; // Tempupdate auf 1 setzten
  UpdateMinMax();
  time_t DCFtime = DCF.getTime(); // Prüfen ob neue Zeit vorhanden ist
  if (DCFtime!=0) {
    setTime(DCFtime); // Neue Zeit setzten
  }
  lcd.setCursor(0,0); // Cursorbeginn auf Zeichen 0, Zeile 1
  lcd.print("                    "); // Text "                    "
  lcd.setCursor(0,1); // Cursorbeginn auf Zeichen 0, Zeile 2
  lcd.print("     "); // Text "     "
  if (hour() < 10){
  lcd.setCursor(7,1); // Cursorbeginn auf Zeichen 7, Zeile 2
  } else {
      lcd.setCursor(6,1); // Cursorbeginn auf Zeichen 6, Zeile 2
  }
  lcd.print(hour()); // Stunden
  printDigits(minute()); // : Minuten
  printDigits(second()); // : Sekunden
  lcd.print("       "); // Text "       "
  lcd.setCursor(0,2); // Cursorbeginn auf Zeichen 0, Zeile 3
  if (day() < 10 && month() < 10){ // Wenn Tag < 10 und Monat < 10   
    lcd.print("      "); // Text "      "
  } else if (day() > 10 && month() < 10 || day() < 10 && month() > 10 ){ // Wenn Tag > 10 und Monat < 10 oder Tag < 10 und Monat > 10
      lcd.print("     "); // Text "     "
    } else { // alles andere
        lcd.print("    "); // Text "    "
      }
  lcd.print(day()); // Tag
  lcd.print("."); // Text "."
  lcd.print(month()); // Monat
  lcd.print("."); // Text "."
  lcd.print(year()); // Jahr
  lcd.print("       "); // Text "       "
  lcd.setCursor(0,3); // Cursorbeginn auf Zeichen 0, Zeile 4
  lcd.print("                    "); // Text "                    "
}

void printDigits(int digits) // Funktion um die : zwischen Std. / Min. / Sek. darzustellen 
{
  lcd.print(":"); // Text ":"
  if(digits < 10) // Wenn Stunden weniger 10
      lcd.print('0'); // setzte 0 voran
      lcd.print(digits); // Ausgabe Digits
}


void SwitchButton () // Uhrzeit / Temperatur Taster überwachen
{
  int reading = digitalRead(analogPin3); // Taster einlesen
  if (reading != lastbuttonStateClock2) { // Prüfen ob Taster gedrückt wurde 
    lastDebounceTime = millis(); // Debounce Timer reset
  }   
  if ((millis() - lastDebounceTime) > debounceDelay) {
    buttonStateClock = reading;
  }  
  lastbuttonStateClock2 = reading; 
  if(buttonStateClock != lastbuttonStateClock) {
    lastbuttonStateClock = reading;
    buttonCount++;
  }
  if(buttonCount % 4==0) { // ButtonCount mit Mudolo zwischen 0 und 1 toggeln
    screen = 1; // setzt Screen auf 1
  }
  else {
    screen = 0; // oder Screen auf 0
  }
}


void loop(void) // Diese Loop wird ständig wiederholt
{ 
  Backlight(); // Aufruf der "Backlight" Loop
  UpdateMinMax(); // Min. und Max. Temp. / Luftfeuchte ermitteln und speichern
  SwitchButton(); // Uhrzeit / Temperatur Taster überwachen und Screen toggeln
  buttonState = digitalRead(analogPin1); // Min. Taster überwachen
  buttonState2 = digitalRead(analogPin2); // Max. Taster überwachen

  if (buttonState == HIGH && screen == 0 && tempupdate == 0) { // Wenn kein Taster gedrückt ist und Tempupdate = 0 
    ShowActual(); // dann aktuelle Werte darstellen
  }     
  if 
    (buttonState == LOW && screen == 0 && tempupdate == 0) {  // Wenn Min. Taster gedrückt ist und Tempupdate = 0   
    ShowMin(); // zeige Minimale Temperaturen und Luftfeuchte
  } 
  if 
    (buttonState2 == LOW && screen == 0 && tempupdate == 0) { // Wenn Max. Taster gedrückt ist und Tempupdate = 0   
    ShowMax(); // zeige Maximale Temperaturen und Luftfeuchte
  } 
  if (screen == 1 ) { // Wenn kein Taster gedrückt ist und Screen == 1
    digitalClockDisplay(); // dann aktuelle Uhrzeit und Datum darstellen
  } 
  if (screen == 0 && tempupdate == 1) { // Wenn kein Taster gedrückt ist, Screen == 0 und Tempupdate = 1 
    ShowActualClock(); // dann zurück zur Temperaturanzeige aber vorher den Screen löschen
  } 
}

So, das ist mein gesamter Code bis jetzt. Wie gesagt, eigentlich ist es schon fertig, bis auf den Fehler den ich gelegentlich bekomme. Alle Sensoren befinden sich auf dem Steckbrett und sollten demnach relativ identische Werte liefern. Ich habe öfters mal im Code versucht durch Tricks ein lcd.clear() zu vermeiden, da dadurch die Anzeige “flackert”. Ich denke ihr werded schon sehen wo ich wie was gemacht habe… :wink: Ist zwar nicht so dolle der Code, aber funktioniert bis auf meinen Fehler…

So, inzwischen konnte ich folgendes beobachten. Ich habe alle meine "verzögerungen" auskommentiert. Ebenso die DS18B20 und habe anschließend die Loop so aufgebaut das nur noch NONSTOP DHT11 & DHT22 ohne jede verzögerung ausgelesen werden. Und siehe da......der Fehler ist zu sehen. Also scheint es wohl wirklich ein Timing Problem zu sein.......

Ich probiere jetzt mal deinen Code nochmals anderst einzubinden um den Interval entsprechend zu erhöhen....