Heizsystem

Nun folgt das Programm:

Meine Vorstellung:

  1. Aufgabenstellung
  2. Grundlagen
  3. Ausführung in Java
  4. Verschiedene Fälle

1. Aufgabenstellung

Es soll möglichst realistisch versucht werden ein Zentralheizungssystem eines gewöhnlichen Hauses nachzustellen. Es werden dafür folgende Werte benötigt: Außerdem soll danach die Rechnung in ein Java Programm übertragen werden und die Temperatur des Wassers und die Innentemperatur soll zeitlich passend dargestellt werden und mittels Thread über einen längeren Zeitraum gezeichnet werden.

2. Grundlagen

  1. Wärmeverlust durch Wände,....
  2. Wärmespeichervermögen des Hauses
  3. Energie zur Warmwasseraufbereitung
  4. Wärmeabgabe an den Heizkörpern

Wärmeverlust durch Wände,....

Als erstes berechnen wir den Wärmeverlust durch die Wände, Fenster, Boden und Decke. Dazubenötigen wir die Fläche der Raumbegrenzungen und deren k-Wert.

Teil des Hauses
Fläche
k-Wert
Außenwand
250 m²
0.4
W/(m²*K)
Dach
100 m²
0.3
W/(m²*K)
Keller
100 m²
0.4
W/(m²*K)
Fenster
30 m²
1.2
W/(m²*K)

Wenn man nun noch die maximale Temperaturdifferenz kennt kann man den maximalen Wärmeverlust errechnen. In unseren Breiten ist die kälteste Temperatur mit -25C geschätzt und im Haus will man eine Temperatur von 20C haben. Damit beträgt die maximale Temperaturdifferenz 45C. Beim Keller ist die Temperaturdifferenz kleiner.

So beträgt der Wärmeverlust:

Außenwand 250 m² * 45C * 0.4 W/(m²*K)
4500 Watt
Dach 100 m² * 45C * 0.3 W/(m²*K)
1350 Watt
Keller 100 m² * 10C * 0.4 W/(m²*K)
400 Watt
Fenster 30 m² * 45C * 1.2 W/(m²*K)
1620 Watt

So beträgt der gesamte Wärmeverlust ca. 8000 Watt (8 kW).

Wärmespeichervermögen des Hauses

Das gesamte Wärmespeichervermögen des Hauses wird als nächstes berechnet. Normalerweise benötigt man dazu die Masse der Materialien, aus denen sich das Haus zusammensetzt und deren spezifische Wärmekapazität. Der Einfachheit wegen schätzen wir, dass sich das ganze Haus in 5 Stunden und bei einer Heizleistung von 8 kW um 10C erwärmt, was der Realität sehr nahe kommt.

Die benötigten Zahlen sind:

Heizleistung 8000 Watt
Schätzung
Wärmeverlust 3400 Watt
(Außentemperatur=0C)
Zeit 5 Stunden
(Muss in Sekunden umgerechnet werden(*3600))
Temperaturdifferenz 10 Kelvin
(Um wieviel das Haus erwärmt wird)

So beträgt der gesamte Wärmespeicher:

WSp = (8000 W- 3400 W)*(5*3600 s)/10 K = 8.280.000 J/K = 2.2( kW/h)/K

Energie zur Warmwasseraufbereitung

Als nächstes schätze ich die benötigte Energie zur Warmwasseraufbereitung. Die Vorgabe dafür ist, dass in 4 Stunden 300 Liter von 10C auf 60c erwärmt werden sollen.

Dafür benötige ich folgende Zahlen:

Boilerinhalt 300 Liter = 300 kg
Aufheizzeit 4 h = 4*3600 sec
Anfangstemperatur 10C
Endtemperatur 60C
spezifische Wärmekapazität des Wassers 4200 J/(kg*K)

So beträgt die erforderlich Heizleistung:

Heizleistung = 300 kg* (60C-10C)*4200 J/kg/K/(4*3600s) = 4375 Watt

Wärmeabgabe an den Heizkörpern

Zuletzt will nun auch noch die Wärmeabgabe an den Heizkörpern abschatzen. Dafür nehme ich an, dass wenn die Innentemperatur 20C und die Vorlauftemperatur (Temperatur in den Heizkörpern) 80C beträgt die Heizleistung von 7620 Watt vollständig übergeben wird.

Die Zahlen dafür sind:

Innentemperatur 20C
Vorlauftemperatur 80C
Heizleistung 7620 Watt

So ergibt sich folgender Wert für den Wärmeabgabefaktor:

WAF = 7620 W/(80C-20C) = 127 W/K

3. Ausführung in Java

  1. Grundwerte
  2. Berechnungen
  3. Der Programmaufbau

A) Grundwerte

Für die Ausführung in Java werden folgend Gründwerte benötigt:

Anfangszeit t =
0
Sekunden
Schrittweite dt =
60
Sekunden
Innentemperatur am Anfang temp_i =
10
C
Außentemperatur am Anfang temp_a =
-15
C
Wassertemperatur in der Leitung temp_w =
8
C
Wassermenge im Heizkreislauf wasserMenge =
20
Liter
Maximaler Heizleistungsbedarf maxHeizBedarf =
8000
W
Spezifische Wärmekapazität des Wassers c_Wasser =
4189
J/(kg*K)
Heizleistung der Energiequelle kesselLeistung =
12000
W
Solltemperatur des Raumes Soll_T =
20
C
Maximale Vorlauftemperatur temp_w_max =
80
C
Wärmeabgabefaktor an den Heizkörpern w_Ab =
maxHeizBedarf/55
J/K
Wärmeverlust nach außen w_Vl =
maxHeizBedarf/54
J/K

B) Berechnungen

Damit wird dann folgendes berechnet:

1. Die Energie, die benötigt wird um das Wasser im Heizkreislauf aufzuheizen:

kesselSpeicher
= wasserMenge * c_Wasser
Wassermenge im Heizkreislauf * spezifischer Wärmekapazität des Wasser

2. Die Energie, die benötigt wird um das Haus selbst aufzuheizen:

innenSpeicher
= MH * 5h / 10K
Maximaler Heizleistungsbedarf * 5 Stunden /10 Kelvin Temperaturdifferenz

3. Folgendes wird jedes Mal beim durchlaufen des Threads gerechnet:

  1. Wenn das Haus kälter als die Soll-Temperatur ist und die Vorlauftemperatur unter der maximalen Vorlauftemperatur ist wird das Wasser im Vorlaufkreislauf erhitzt. d_temp ist in diesem Fall eine Variable die für den Temperaturunterschied genommen wird.
    "  if ((temp_i<20)&(temp_w<=temp_w_max))
           dtemp_w=kesselleistung*dt/kesselspeicher;
       else
            dtemp_w=0;
    
       temp_w=temp_w + dtemp_w;
  2. Als nächstes berechnet man die Wärmeabgabe an den Heizkörpern. Dazu multipliziert man den Wärmeabgabefaktor mit der Zeitdauer und der Temperaturdifferenz von Vorlauf- und Innentemperatur.
    w_Abgabe=w_Ab*dt*(temp_w-temp_i);
  3. Danach berechnet man die Änderung der Innentemperatur. Dazu verwendet man die Variable dtemp_i für die Änderung, die erechnet wird, indem die Wärmeabgabe an den Heizkörpern durch den Wärmespeicher des Hauses dividiert.
     dtemp_i=w_Abgabe/innenSpeicher;
     temp_i=temp_i+dtemp_i;
  4. Darauf wird von der Vorlauftemperatur der Wärmeverlust an das Haus abgezogen:
    dtemp_w=-w_Abgabe/kesselSpeicher;
          temp_w=temp_w+dtemp_w;
  5. Auch von der Innentemperatur werden die Verluste nach außen abgezogen. w_Verlust ist eine Variable, die für den Energieverlust nach außen verwendet wird.
    w_Verlust=w_Vl*dt*(temp_a-temp_i);
          dtemp_i=w_Verlust/innenSpeicher;
          temp_i=temp_i+dtemp_i;

C) Der Programmaufbau

a) Der Thread:

Ein Thread ist ein Programmteil, dass man in Java einfügen kann. Dieses Programmteil ist dafür verantwortlich, dass nicht alles auf einmal gezeichnet wird, sondern das zwischendurch pausen sind. Der Thread für dieses Programm enthält die oben erwähnten Berechnungen und zudem noch folgende Dinge, die unbedingt notwendig sind:

public void run() {
    while (true) {
    repaint();
      System.out.println("Zeit:"+t/3600+"   Wasser: "+temp_w+" Innen: "+temp_i);
      try {Thread.sleep(100);}
      catch (Exception e) {System.err.println("Wasser!!!!");};
    }
  }

b) Die Zeichenfunktion (paint):

Mit der Zeichenfunktion erfolgt die Ausgabe in ein Fenster. Der Thread gibt mit der Anweisung repaint(); den Auftrag die Zeichenfunktion einmal zu durchlaufen. Die Zeichenfunktion enthält folgendes:

Programteil Erklärung
g.setColor(new Color(200,200,200));
Damit wird eine neue Farbe ausgewählt.
g.fillRect(0,0,800,600);
Damit wird ein gefülltes Rechteck gezeichnet
g.drawLine(0,400,800,400);
Damit wird eine Linie gezeichnet
g.fillOval(x,400-y,3,3);
Damit wird ein Kreis oder ein Punkt gezeichnet

Das gesamte Programm finden sie hier

4. Nun folgt verschiedene Fälle:

Startemperaturen:

Innentemperatur
10C
Außentemperatur
20C

Dies ergibt folgendes Bild:

Startemperaturen:

Innentemperatur
10C
Außentemperatur
-20C

Dies ergibt folgendes Bild:

Startemperaturen:

Innentemperatur
-10C
Außentemperatur
-2C

Dies ergibt folgendes Bild:

Weitere Applets finden sie hier