Arduino Heizungssteuerung mit Komfort Zeiten

Hallo zusammen,

wie im Thread von Maxi1610 angesprochen (Arduino Heizungssteuerung) möchte ich ebenfalls eine Heizungssteuerung bauen.

Damit möchte ich einen Nebenraum (Büro) im Altbau heizen. Der vorhandene elektrische Radiator benötigt jedoch jede Menge elektrische Energie. Das Ziel ist den Raum zu temperieren und anhand definierten Komfortzeiten zu heizen.
Die Hysterese, Einstellen der Soll-Temperatur via Potentiometer und Ausgabe der Soll-, sowie Ist-Temperatur via LCD funktioniert. Nun möchte ich die Schaltung um ein RTC DS1307 Modul erweitern und die Komfortzeiten hinzufügen.

Lösungsansatz:
Prüfen, ob die aktuelle Zeit (Stunden 24h Format) innerhalb der Komfortzeit ist. Wenn ja, wird der Radiator eingeschaltet und auf die Solltemperatur geheizt. Ansonsten bleibt die Temperatur bei einem konstanten Sollwert (="Frostwächter"). In der Testphase werde ich die zum Aufheizen notwendige Vorlaufzeit ermitteln und im Programm hinzufügen.

An was scheitere ich?
Meine Internet Recherchen (Forum, Google und Youtube) zeigten viele Beispiel-Codes auf, jedoch hatte ich bei jedem Probleme beim Uploaden auf den Arduino.

Aktuell fehlt mir die Übersicht über Befehle, welche mit dem RTC Modul kompatibel sind. Ich weiß absolut nicht was ich machen muss, damit ich die aktuelle Zeit in eine Variable speichern kann.

Könnt ihr mir so eine Übersicht liefern?
Für die "normalen" Befehle habe ich bereits eine gefunden.
https://www.arduino.cc/reference/de/#structure

Aktuell steht mir folgendes Material zur Verfügung:

  • Arduino Starer Kit (Uno R3)
  • Temperaturfühler TMP36GZ
  • Zeitmodul DS1307 (library DS1307RTC-1.4.1)
  • Relais um 230V zu schalten

wir sehen nicht was du probiert hast und wir sehen deine Fehlermeldung nicht.
Daher wäre es zunächst gut,
a) wenn du bestätigen kannst dass der Upload von einem Sketch wie z.b. Blink grundsätzlich funktioniert
b) wenn du den Code postest der bei dir einen Fehler wirft
c) die Fehlermeldung postest die du bekommst

Schau Dir die Example von Paul Stoffregen an, GitHub - PaulStoffregen/Time: Time library for Arduino
Da ist alles drin was Du brauchst.

Ansonsten braucht es einen Code als Rumpf und Du erklärst kurz, wo es klemmt.

Hallo,

Was sind das für Probleme,
Vorschlag Bau noch ein Display dazu, damit Du was sehen kannst , Sollwert Uhrzeit usw. Du kannst auch auf das Poti verzichten und arbeitest mit einem 3Tasten Menue, Letztlich willst Du ja auch die ein/aus zeiten mal ändern können.
Auf youToube wirst Du nicht das richtige finden. Befasse dich mit den Grundlagen, dazu gibts die einfachen Beispiele in der IDE. Taster abfragen, LED einschalten, Analogwert einlesen usw. Der Rest ist dann recht einfach. Bei fast jeder Lib sind Beispiele , die zeigen wie man sie verwendet. Vermeide delay() das hält den Arduino an , er macht eine pause, und kann nichts anderes mehr machen. Wenn Du mit Zeiten arbeiten willst nimm millis() oder frag Deine RTC ab.

Es gibt doch Beispiele aus der lib zur Uhr, da kannst Du sehen wie man an Stunde, Minute, Sekunde kommt. Wen Du eine Abfrage machen willst,kannst Du das über einen kleinen Umweg zu einer Variablen machen.

zeit=stunde *3600 + minute *60 + sekunde

damit kannst Du dann vergleichen
if ( zeit > einschatzeit )

und was ein oder ausschalten.

Mit den Relais musst Du aufpassen , nicht alle sind wirklich für 220V geeignet, auch wenn es draufsteht.

Falls Du die Lust verlieren solltest eine Schaltuhr kostet 10€
Heinz

Nachtrag : Warum willst Du einen Sensor verwenden von -40-125Grad
schau Dir die Temp Sensoren DS18B20 an

Hallo zusammen,

vielen Dank für eure schnellen Reaktionen.
Mir ist aufgefallen, dass ihr auf vollständige Codes besteht.
Deshalb bestehe ich darauf, dass auch ihr die Posts zur Gänze lest und die gestellten Fragen beantwortet. :wink: Natürlich sind Fragen erlaubt!

Wie im ursprünglichen Post erwähnt bin ich auf der Suche nach einer Übersicht der einzelnen Befehle.

Ich habe die aufgelisteten Komponenten verwendet, weil diese im Starter Kit inkludiert waren.
Austausch, Verbesserung sowie Erweiterungen ist angedacht.

Mittlerweile habe ich das Problem gelöst.
Anbei der aktuelle Sketch.
Über konstruktive Verbesserungsvorschläge würde ich mich freuen.
Gruß

/*
Titel: Heizungssteuerung - Komfort

Zielzustand:
Die Steuerung soll die IST Temperatur erkennen und mit der SOLL Temperatur vergleichen.
Die SOLL Temperatur kann mittels Potentiometer eingestellt werden.
SOLL und IST Temperatur werden auf dem LCD abgebildet.
Um Ressourcen zu schonen, werden Komfort Zeiten definiert.
Befindet sich die aktuelle Zeit innerhalb der Komfort Zeit, wird der Raum auf die SOLL Temperatur geheizt.
Wenn nicht, übernimmt die Steuerung die Aufgabe eines Frostwächters.

verwendetes Equipment (aus Arduino Starter Kit): 
- Arduino Uno R3 , Breadboard und div Jumper Wire
- Temperatursensor TMP36GZ für IST Temperatur
- LCD 16x2 
- LED grün, rot, blau + Vorschaltwiderstände
- Potentiometer 10kOhm für SOLL Temperatur
- Potentiometer 10kOhm für Kontrast LCD
- Relais 230V (5V Steuerspannung, aus elegoo 37 Sensor Kit)

geplante Erweiterung:
- Erkennung Wochentage, da andere Komfortzeit am Wochenende
- Wechsel des Temperaturfühlers, in der Hoffnung auf eine kleinere Fehlertoleranz (oder Bildung eines Mittelwerts über definierten Zeitraum)
- größeres Display und Einstellmöglichkeit der Komfort Zeiten am Arduino selbst
*/

#include <LiquidCrystal.h>
#include <Wire.h>
#include <RTC.h>
LiquidCrystal lcd(12, 11, 10, 9, 8, 7); //Pins für LCD Display

static DS1307 RTC;
const int SensorPin = A0; //Analoger Eingang des Temperaturfühlers
const int PotPin = A1; //Analoger Eingang der einstellbaren SOLL Temperatur (Potentiometer)
const int Frost = 12.0; //Konstante Frostwächter Temperatur = SOLL Temperatur, wenn aktuelle Zeit nicht innerhalb der Komfort Zeit
int HourNow; //Variable zum Speichern und vergleichen der aktuellen Zeit

bool ComfortTime;

int PinHeizen = 2; //Ausgang LED rot und Aktion Relais Radiator EIN
int PinKuehlen = 3; //Ausgang LED blau und Aktion Relais Radiator AUS
int PinComfort = 4; //Ausgang LED grün, Temperatur im gewünschten Bereich

void setup() 
{

// Initialisierung des LCD und RTC Moduls, Aufbau einer seriellen Schnittstelle
lcd.begin (16,2);
RTC.begin();
Serial.begin(9600);

//Definition der Output Pins
pinMode(PinHeizen, OUTPUT);
pinMode(PinKuehlen, OUTPUT);
pinMode(PinComfort, OUTPUT);
digitalWrite(PinHeizen, LOW);
digitalWrite(PinKuehlen,LOW);
digitalWrite(PinComfort, LOW);
}

void loop() 
{
 
 // Berechnung IST Temperatur
 int sensorVal = analogRead(SensorPin);     
 Serial.print("Sensor Wert: ");
 Serial.print(sensorVal);

 float voltage = (sensorVal/1024.0)*5.0;   //Umrechnung auf Spannung, da der analoge Eingang einen Wert zwischen 0 und 1024 liefert
 Serial.print(", Spannung [V]: ");
 Serial.print(voltage);

 float TempIST = (voltage-0.5)*100;       // -0,5V, weil Fühler kann auch negative Werte erfassen. Wird hier jedoch nicht benötigt.
 Serial.print(", IST Grad [°C]: ");
 Serial.println(TempIST);


//Einlesen der SOLL Temperatur
 int PotVal = analogRead(PotPin);
 Serial.print("Poti Wert: ");
 Serial.print(PotVal);

 float PotVoltage = (PotVal/10000.0)*5.0;   // weil Potentiometer 10k hat.
 Serial.print(", Poti Spannung [V]: ");
 Serial.print(PotVoltage);

 float TempSOLL = (PotVoltage)*100;
 Serial.print(", SOLL Grad [°C]: ");
 Serial.println(TempSOLL);


//Ausgabe am LCD
lcd.clear();
lcd.print("Temp-SOLL:  ");
lcd.print(TempSOLL,1);
lcd.setCursor(0,1);
lcd.print("Temp- IST:  ");
lcd.print(TempIST,1);


//Prüfen ob aktuelle Zeit in Komfort Zeit
HourNow = RTC.getHours();

if (6<= HourNow && HourNow <=7)
{
  ComfortTime == true;
}
else 
{
  ComfortTime == false;
}

//Wenn Komfort Zeit JA, dann heize auf SOLL Temp + Hysterese
if (ComfortTime == true);
{
  
//Schalthysterese
if (TempIST < TempSOLL -2) //Heizung Ein
{
  digitalWrite(PinHeizen, HIGH);
  digitalWrite(PinKuehlen, LOW);
  }

if (TempIST > TempSOLL +2) // Heizung aus
{
  digitalWrite(PinHeizen, LOW);
  digitalWrite(PinKuehlen, HIGH);
}

//Anzeige innerhalb Komfort Bereich Temperatur (LED grün)
if ((TempSOLL-4.5) <= TempIST && TempIST <= (TempSOLL+0.5)) 
{
  digitalWrite(PinComfort, HIGH);
}

else
{
  digitalWrite(PinComfort,LOW);
}

delay(2000);
}

//Wenn Komfort Zeit NEIN, dann heize auf Frostwächter Temp
if (ComfortTime == false);
{
//Schalthysterese
if (TempIST < Frost -2) //Heizung Ein
{
  digitalWrite(PinHeizen, HIGH);
  digitalWrite(PinKuehlen, LOW);
  }

if (TempIST > Frost +2) // Heizung aus
{
  digitalWrite(PinHeizen, LOW);
  digitalWrite(PinKuehlen, HIGH);
}

if ((Frost-4.5) <= TempIST && TempIST <= (Frost+0.5)) //Anzeige innerhalb Komfort Bereich Temperatur
{
  digitalWrite(PinComfort, HIGH);
}

else
{
  digitalWrite(PinComfort,LOW);
}

delay(2000);
}
}

C / C++ kennt keine Befehle nur Funktionen und Anweisungen und Steuerelemente.

Zur Hardware Die Du verwendest brauchst Du eine geeignete Ansteuerung (Lesen udn schreiben von Daten, Umwandeln von analogen Signalwerten). Wie das geschehen muß stht in Datenblatt des jeweiligen Bauteils. Viele Bauteile/ Module gibt es bereits Bibliotheken. Zu den bibliotheken gibt es Besschreibungen und Beispielsketche. Notfalls muß man sich den Code der Bibliotheken anschauen um zu verstehen welche Funktionan bereitsgestellt werden.

Nein Wir bestehen auf lauffähigen Code, der das Problem/Fehler hervorruft, damit wir den Fehler finden können.
oder Falls der Sketch nicht kompiliert einen Coder der eben den Fehler auch bei uns macht.
Eine Kopie der Fehlermeldungen/Warnungen der bei kompilieren generiert wird ist dann auch notwendig zusammen mit den Quellen der verwendeten Bibliotheken. (wir könnten ja andere Bibliotheken haben die funktionieren.

Grüße Uwe

Hallo Uwe,

danke dafür.
Ich nehme mit, dass es keine generelle Übersicht über Funktionen / Anweisungen gibt, welche sich direkt mit RTC Modulen befassen. Jede Library hat seine eigenen Funktionen/Anweisungen und ohne die Keywords (keywords.txt), aus der Library, wird der Code nichts.

Hast du einen Vorschlag, wie ich meinen Code vereinfachen kann?

Gruß

Hallo,
das hat mit der keywords.txt absolut nichts zu tun. Die sorgt nur dafür das die IDE im Editor den Text farbig (rot ) darstelllt. Ob die Methoden einer Lib dem Compiler bekannt sind hängt davon ab ob du sie mit #include bekannt gemacht hast.
Die von Dir bereits angesprochene Referenz ist da sehr hilfreich, drin findest Du auch die Standard Arduino Lib´s und die Doku dazu. Für andere Libs gibts zum Teil sehr umfangreiche Dokus. ( z.B FastLED)

ein C++ Buch ist auch hilfreich oder auch
https://de.wikibooks.org/wiki/C%2B%2B-Programmierung/_Inhaltsverzeichnis
oder
https://www.cplusplus.com/reference/

oder auch hier aus dem Nachbarforum
https://www.arduinoforum.de/referenz.php

Heinz

  • verzichte auf die Nachkommastellen bei den Temperaturen
  • pins können sich nicht ändern: mache sie const
  • der Wertebereich ist zweistellig, ein int ist da overkill - byte reicht
  • das lcd nicht mit jedem Umlauf ein clear() ausführen und nur beschreiben, wenn notwendig
  • keine delays()
  • baue Dir Funktionen und teile den Code auf, einmal Anzeige, einmal rechnen (und vielleicht auch die serielle Ausgabe)

Hallo Heinz,

danke dafür. Ich werde die Links und Unterlagen studieren.

Gruß

Hallo,

danke für die Verbesserungsvorschläge.
Ich werde diese einbinden.

Gruß

Ein DS3231 RTC ist auf Längen genauer darum ist dieses Zeitmodul vorzuziehen.

Such nach einer Bibliothek für diesen RTC. Mit der Bibliothek werden Beispiele mitgeliefert. Dort sind die Funktionen durch einen Sketch erklährt.

Grüße Uwe

Die Time-lib von Paul läuft auch mit der 3231 (#15), auch wenn 1307 ausgewählt wurde.
Die Adressierung der Uhr geht bis Adresse 0x06 und ist bei beiden gleich.

@wuro Datenblätter: https://datasheets.maximintegrated.com/en/ds/DS3231.pdf
und https://datasheets.maximintegrated.com/en/ds/DS1307.pdf

Noch ein Zusatz: Du hast zwei Zeilen fürs Display.
Mach in der ersten Zeile nen kleinen Kalender - also Datum Uhrzeit und in der unteren Zeile Soll und Ist jeweils zweistellig ohne Nachkomma. Und vielleicht noch einen kleinen Block, der Dir zeigt, ob geheizt wird oder nicht.
Platz ist dafür da.

Kann ich das als DS3231 verstehen? :wink: :wink:

1 Like

Komm, ich hab wenigstens das richtige DaBla verlinkt :wink: :slight_smile:
Beste Grüße und Danke!

Status Update:
Mittlerweile kann zwischen "Arbeitswoche" (Mo-Fr) und Wochenende (Sa-So) unterschieden und individuelle Komfort Zeiten programmiert werden. Die Fehlertoleranz des Temperatursensors wird durch die Bildung des MIttelwertes aus 10 Messungen
geglättet.
Außerhalb der Komfort Zeiten wird die Soll Temperatur durch die Frostwächter Temperatur übersteuert.

Das LCD zeigt folgendes an
Zeile 1 (abwechselnd á 20 Sekunden):
Datum und Uhrzeit - Komfort Zeitraum 1 - Komfort Zeitraum 2
Zeile2 : Temperatur Soll und Temperatur Ist

Aktuell warte ich darauf, dass das größere Display. Sobald das geliefert wurde, starte ich mit den geplanten Erweiterungen. :slight_smile:

Was haltet ihr vom Code?

/*
Titel: Heizungssteuerung - Komfort

Zielzustand:
Die Steuerung soll die IST Temperatur erkennen, mit der SOLL Temperatur vergleichen und entsprechende Aktionen setzen.
Die SOLL Temperatur kann mittels Potentiometer eingestellt werden.
Um Ressourcen zu schonen, werden Komfort Zeiten definiert.
Befindet sich die aktuelle Zeit innerhalb der Komfort Zeit, wird der Raum auf die SOLL Temperatur geheizt.
Wenn nicht, übernimmt die Steuerung die Aufgabe eines Frostwächters.

SOLL und IST Temperatur werden auf dem LCD abgebildet.
Des Weiteren werden, im Abstand von 30 Sekunden, entwedes das Datum und Uhrzeit oder der Beginn und das Ende der Komfortzeit angezeigt.

verwendetes Equipment (aus Arduino Starter Kit, Elegoo Sensor Kit und separates LCD I2C Display): 
- Arduino Uno R3 , Breadboard und div Jumper Wire
- Temperatursensor TMP36GZ für IST Temperatur
- Potentiometer 10kOhm für SOLL Temperatur
- LCD 16x2 I2C blau
- LED grün, rot, blau + Vorschaltwiderstände
- Relais 230V (5V Steuerspannung)

geplante Erweiterung:
- größeres Display und Einstellmöglichkeit der Komfort Zeiten am Arduino selbst
- ermöglichen des manuellen Eingriffs, sodass die Heizung auch außerhalb der Komfort Zeiten, für einen bestimmten Zeitraum, eingeschaltet werden kann.
*/

#include <LiquidCrystal.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <RTC.h>
LiquidCrystal_I2C lcd(0x27,16,2); //Definition des LCD

static DS1307 RTC;

//Einstellbare Komfort Zeit (Beginn und Ende) und Frostwächter Temperatur
byte ComfortBegin1 = 6;   //Komfort Zeit Beginn
byte ComfortEnd1 = 7;     //Komfort Zeit Ende

byte ComfortBegin2 = 8;   //Komfort Zeit Beginn
byte ComfortEnd2 = 10;    //Komfort Zeit Ende

byte TempFrost = 12;      // Frostwächter Temperatur
byte Delay = 4;           //Schalthysterese [Soll - Hysterese]

//Pinbelegung Input
const int SensorPin = A0; // Temperatursensor für IST Temperatur
const int PotPin = A1;    //Potentiometer für SOLL Temperatur

//Pinbelegung Output
const int PinHeizen = 2;      // = Aktion Heizelement via Relais und nur rote LED einschalten
const int PinKuehlen = 3;     // = Aktion Heizelement via Relais ausschalten und nur blaue LED einschalten
const int PinComfort = 4;     // = Signalisierung, dass Temperatur innerhalb der Hysterese

//Variablen zur Berechnung (intern)
bool Heating = false;
bool Cooling = false;
bool HeatingFrost = false;
bool CoolingFrost = false;
bool ComfortTime = false;
byte DoW;                 // Day of Week, 1 = Sonntag

int i=10;                 // Array zur Ermittlerung der durchschnittlichen IST Temperatur, verhinder ein "flackern" des Eingangssignals, verlangsamt jedoch die Steuerung, 5 Sekunden inaktiv, da For Schleife durchläuft
float TempArray[10];
float sensorVal;          // Variablen zum Umrechnen des analogen Werts in die IST Temperatur
float voltage;

float TempIST;
byte TempAverage=20;
byte TempSOLL;
byte TempPrint;
byte HourNow;

void setup() 
{
lcd.init ();                //LCD initialisieren und Hintergrundbeleuchtung einschalten
lcd.backlight();
Serial.begin(9600);         //Serielle Schnittstelle für Problembehebung via PC
RTC.begin();                //Real Time Clock starten

pinMode(PinHeizen, OUTPUT);
pinMode(PinKuehlen, OUTPUT);
pinMode(PinComfort, OUTPUT);
digitalWrite(PinHeizen, LOW);
digitalWrite(PinKuehlen,LOW);
digitalWrite(PinComfort, LOW);

// Berichtigung Datum und Uhrzeit, wenn falsche Ausgabe
/*
RTC.setDay(12);
RTC.setMonth(12);
RTC.setYear(2021);
RTC.setHours(13);
RTC.setMinutes(52);
RTC.setSeconds(30);
RTC.setWeek(1);   // Day of Week, 1 = Sonntag
*/
}

void loop ()                //Ablaufbeschreibung    
{
  Eingabe();
  Visualisierung();
  Berechnung();

  if (ComfortTime == true)
  {
    Aktion();
  }
  else if (ComfortTime == false)
  {
    Frost();
  }
}

void Eingabe() 
{
    float PotVal = analogRead(PotPin);
 Serial.print("Poti Wert: ");
 Serial.print(PotVal);

 float PotVoltage = (PotVal/10000.0)*5.0;   // weil Potentiometer 10k hat. Ob das funktioniert, weiß ich nicht.
 Serial.print(", Poti Spannung [V]: ");
 Serial.print(PotVoltage);

 TempSOLL = (PotVoltage)*100;
 Serial.print(", SOLL Grad [°C]: ");
 Serial.println(TempSOLL,1);

/*////////////////// Durchschnitt Messwert /////////////*/
// Glättung des analogen Eingangwertes

 for (i=0; i<=10; ++i)
 {
 sensorVal = analogRead(SensorPin);     // Berechnung IST Temperatur
 voltage = (sensorVal/1024.0)*5.0;
 TempIST = (voltage-0.5)*100;       // -0,5V, weil Fühler kann auch negative Werte erfassen. Wird hier jedoch nicht benötigt.
 TempArray[i]=TempIST; 
 delay(500);
 }

 TempAverage = (TempArray[0]+TempArray[1]+TempArray[2]+TempArray[3]+TempArray[4]+TempArray[5]+TempArray[6]+TempArray[7]+TempArray[8]+TempArray[9])/10;
 
 Serial.print("Sensor Wert: ");
 Serial.print(sensorVal);
 Serial.print(", Spannung [V]: ");
 Serial.print(voltage);
 Serial.print(", IST Grad [°C]: ");
 Serial.println(TempAverage,1);
}

void Visualisierung()
{
/*////////////// SERIELLE AUSGABE //////////////////////*/
/*
Serial.println();
Serial.print(RTC.getDay());
Serial.print(".");
Serial.print(RTC.getMonth());
Serial.print(".");
Serial.print(RTC.getYear());
Serial.print(" ");
Serial.print(RTC.getHours());
Serial.print(":");
Serial.println(RTC.getMinutes());

Serial.print("Hour Now: ");
Serial.println(HourNow);
Serial.print("Comfort Time: ");
Serial.println(ComfortTime);
Serial.print("Status Comfort Temp: ");
Serial.println(digitalRead(PinComfort));
Serial.print("Wochentag: ");
Serial.println(RTC.getWeek()); //=Wochentag
Serial.println();
/*
/*////////////// LCD AUSGABE //////////////////////*/

lcd.setCursor(0,0);
if (0<=RTC.getSeconds()&& RTC.getSeconds()<=19)       //Abwechselnde Anzeige des LCD Displays Zeile 1 (Zeiten <-> Datum und Uhrzeit)
{
  lcd.print("Comf1: ");
  if (ComfortBegin1<10)   //Wenn Zeit einstellig (1-9), dann soll zuerst eine Null ausgegeben werden. 9:7 --> 09:07
  {
    lcd.print("0");
    lcd.print(ComfortBegin1);
  }
  else {  lcd.print(ComfortBegin1);}
  
  lcd.print("-");
  if (ComfortEnd1<10)
  {
    lcd.print("0");
    lcd.print(ComfortEnd1);
  }
  else {  lcd.print(ComfortEnd1);}
  
  lcd.print(" Uhr   ");
}
else if (20<=RTC.getSeconds()&& RTC.getSeconds()<=39)
{
   lcd.print("Comf2: ");
  if (ComfortBegin2<10)   //Wenn Zeit einstellig (1-9), dann soll zuerst eine Null ausgegeben werden. 9:7 --> 09:07
  {
    lcd.print("0");
    lcd.print(ComfortBegin2);
  }
  else {  lcd.print(ComfortBegin2);}
  
  lcd.print("-");
  if (ComfortEnd2<10)
  {
    lcd.print("0");
    lcd.print(ComfortEnd2);
  }
  else {  lcd.print(ComfortEnd2);}
  lcd.print(" Uhr   ");
}
else
{
if( RTC.getDay() <10)        //Wenn Datum einstellig (1-9), dann soll zuerst eine Null ausgegeben werden. 1.1.2021 --> 01.01.2021
{
  lcd.print("0");
  lcd.print(RTC.getDay());
}
else {lcd.print(RTC.getDay());}

lcd.print(".");

if( RTC.getMonth() <10)
{
  lcd.print("0");
  lcd.print(RTC.getMonth());
}
else {lcd.print(RTC.getMonth());}

lcd.print(".");
lcd.print(RTC.getYear());
lcd.print(" ");
if( RTC.getHours() <10)
{
  lcd.print("0");
  lcd.print(RTC.getHours());
}
else {lcd.print(RTC.getHours());}   //Wenn Uhrzeit einstellig (1-9), dann soll zuerst eine Null ausgegeben werden. 9:7 --> 09:07

lcd.print(":");

if( RTC.getMinutes() <10)
{
  lcd.print("0");
  lcd.print(RTC.getMinutes());
}
else {lcd.print(RTC.getMinutes());}
}

lcd.setCursor(0,1);
lcd.print("SOLL:");
lcd.print(TempPrint,1);
lcd.print("   IST:");
lcd.print(TempAverage,1);
}

void Berechnung()
{

  DoW = RTC.getWeek();
  HourNow=RTC.getHours();

  if(ComfortBegin1<= HourNow && HourNow <ComfortEnd1 && 2<= DoW && DoW <=6 || ComfortBegin2<= HourNow && HourNow <ComfortEnd2 && 1== DoW && DoW ==7 )   // Abrage, ob die aktuelle Stunde innerhalb der gewünschten Komfortzeit1 liegt (Wochentags zwischen 6 und 7)
  {
    ComfortTime = true;
  }
  else 
  {
    ComfortTime = false;
  }

if (ComfortTime == true)    //Wenn ja, soll die einstellbare Soll Temperatur angezeigt werden
{
  TempPrint = TempSOLL;
}

else if (ComfortTime == false)    // Wenn nein, soll die Frostwächter Temperatur angezeigt werden
{
  TempPrint = TempFrost;
}

if (TempAverage < (TempSOLL -Delay) && ComfortTime == true) //Heizung ein
{
  Heating = true;  
  Cooling = false;
}

if (TempAverage > TempSOLL  && ComfortTime == true) // Heizung aus
{
  Heating = false;
  Cooling = true;
}

if (TempAverage < (TempFrost -Delay) && ComfortTime == false) //Frostwächter ein
{
  HeatingFrost = true;  
  CoolingFrost = false;
  }

if (TempAverage > TempFrost && ComfortTime == false) // Frostwächter aus
{
  HeatingFrost = false;
  CoolingFrost = true;
}
}

void Aktion()
{  
if (Heating)    //Schalten der Output Pins entsprechen den Berechnungen
{
  digitalWrite(PinHeizen, HIGH);
  digitalWrite(PinKuehlen, LOW);
  }

if (Cooling)
{
  digitalWrite(PinHeizen, LOW);
  digitalWrite(PinKuehlen, HIGH);
  }

if (!Heating && !Cooling)       //Eleminierung aller anderen Zustände
{
  digitalWrite(PinHeizen, LOW);
  digitalWrite(PinKuehlen, LOW);
}

if (TempAverage >(TempSOLL-Delay) && TempAverage < TempSOLL && ComfortTime == true)   //Signalisierung, dass Temperatur innerhalb der Hysterese
{
  digitalWrite(PinComfort, HIGH);
}
else {digitalWrite(PinComfort, LOW);}

}

void Frost()
{
if (HeatingFrost)
{
  digitalWrite(PinHeizen, HIGH);   
  digitalWrite(PinKuehlen, LOW);
  }

if (CoolingFrost)
{
  digitalWrite(PinHeizen, LOW);
  digitalWrite(PinKuehlen, HIGH);
  }

  if (!HeatingFrost && !CoolingFrost) //Eleminierung aller anderen Zustände
{
  digitalWrite(PinHeizen, LOW);
  digitalWrite(PinKuehlen, LOW);
}

if (TempAverage >(TempFrost-Delay) && TempAverage < TempFrost && ComfortTime == false) //Signalisierung, dass Temperatur innerhalb der Hysterese
{
  digitalWrite(PinComfort, HIGH);
}
else {digitalWrite(PinComfort, LOW);}

}

hat Potential.

Mache ich eine Zeile draus.
Schreib eine neue kleine funktion:

void lcdVorNull(const unsigned int zahl)
{
  if (zahl < 10)
    lcd.print('0')
    lcd.print(zahl);
}

Dann wird das oben:

  if (0 <= RTC.getSeconds() && RTC.getSeconds() <= 19)  //Abwechselnde Anzeige des LCD Displays Zeile 1 (Zeiten <-> Datum und Uhrzeit)
  {
    lcd.print("Comf1: ");
    lcdVorNull(ComfortBegin1);
    /*
      if (ComfortBegin1 < 10) //Wenn Zeit einstellig (1-9), dann soll zuerst eine Null ausgegeben werden. 9:7 --> 09:07
      {
      lcd.print("0");
      lcd.print(ComfortBegin1);
      }
      else {  lcd.print(ComfortBegin1);}
    */
    lcd.print("-");
    lcdVorNull(ComfortEnd1);
    /*
      if (ComfortEnd1 < 10)
      {
      lcd.print("0");
      lcd.print(ComfortEnd1);
      }
      else {  lcd.print(ComfortEnd1);}
    */
    lcd.print(" Uhr   ");
  }

Im Übrigen schreibst Du den Display ständig neu - würde ich nicht machen....

lies dich ein zum Thema "Arduino F-Makro" (google ist dein Freund) und ändere deine LCD und Serial prints

 Serial.print(F(", Spannung [V]: "));

Ich hab das mal umgeschrieben auf ne Handvoll Zeilen - und @noiasca hats schon vorweg genommen... Die prints sind mit dem Makro auszulagern, aber macht m.E. erst ab 3 bytes Sinn..
Dann hier Deine Ausgabe auf dem Display: (ungetestet und unkompiliert - die RTC lib kenn ich nicht)


void Visualisierung()
{
  static int8_t lastSecond = -1;
  int8_t mySecond=RTC.getSeconds()
  if (lastSecond != mySecond)
  {
    lastSecond = mySecond);
    lcd.setCursor(0, 0);
    switch (lastSecond)
    {
      case 0:
        {
          lcd.print(F("Comf1: "));
          lcdVorNull(ComfortBegin1);
          lcd.print("-");
          lcdVorNull(ComfortEnd1);
          lcd.print(F(" Uhr   "));
        }
        break;
      case 20:
        {
          lcd.print(F("Comf2: "));
          lcdVorNull(ComfortBegin2);
          lcd.print("-");
          lcdVorNull(ComfortEnd2);
          lcd.print(F(" Uhr   "));
        }
        break;
      case 40:
        {
          lcdVorNull(RTC.getDay());
          lcd.print(".");
          lcdVorNull(RTC.getMonth());
          lcd.print(".");
          lcdVorNull(RTC.getYear());
          lcd.print(" ");
          lcdVorNull(RTC.getHours());
          lcd.print(":");
          lcdVorNull(RTC.getMinutes());
          lcd.setCursor(0, 1);
          lcd.print("SOLL:");
          lcd.print(TempPrint, 1);
          lcd.print(F("   IST:"));
          lcd.print(TempAverage, 1);
        }
        break;
    }
  }
}

[edit]
Einen hab ich noch...

void Aktion()
{
  digitalWrite(PinHeizen, Heating);
  digitalWrite(PinKuehlen, Cooling);
  if (TempAverage > (TempSOLL - Delay) && TempAverage < TempSOLL && ComfortTime == true) //Signalisierung, dass Temperatur innerhalb der Hysterese
  {
    digitalWrite(PinComfort, HIGH);
  }
  else {digitalWrite(PinComfort, LOW);}
}

Dann bin ich erstmal weg hier.

Die #include <LiquidCrystal.h> Auskommentieren ist nicht notwendig .