Poolwasser mit der Sonne aufheizen.

[Admin]

Ich habe ein neues Projekt begonnen.
Unser Pool ist immer seeeehr kalt. Auch im höchsten Sommer können wir froh sein, wenn der an die 22 Grad geht. In der Regel eigentlich eher 19-21 Grad. Er kühlt leider in der Nacht immer so 1-2 Grad ab, und am Tag wird er auch nicht wesentlich wärmer. 42000 Ltr. Wasser sind nun mal eine große Badewanne und somit eine Ansage zum Heizen. Und das ist mir eindeutig zu kalt. Ich war in den zwei Jahren, die wir den Pool jetzt haben, genau 3x im Pool. Und das auch nur, um zu testen ob ich es aushalte. Spass sieht def. anders aus.


Jetzt wollen wir mit zwei Solar-Absorber, je 1,2 x 4,50 Meter das Wasser am Dach dess Poolhauses aufwärmen.

Um das Wasser vom Pool aufs Dach zu bringen habe ich mir eine Tauchpumpe bestellt, die mit 18 Volt DC betrieben wird.
Gerät: BARICUS Akku Tauchpumpe 18V
Spannung: 18 V /80 W
Max. Flüssigkeitstemperatur: 35°C
Pumpenschlauchlänge: 2,5 m
Qmax /Hmax (Pumpleistung/max. Förderhöhe): 1750 l/h / 17,5 m
Max. Eintauchtiefe: 2 m
Schutzklassen: II / IPX4 / IPX8

Die Versorgungsspannung kommt aus zwei Akkus 12 Volt / 7,2 AH, also 24 Volt. Diese werden wiederrum über zwei Solarpanels geladen.

Die Daten der beiden SolarPanels sind:
65 Watt 12V Solarmodul Polykristallin
Nennleistung Pmax 65 Watt
Spannung bei Nennleistung Vpmax 17,6 Volt
Leerlauf Spannung Voc 21,65 Volt
Kurzschluss Strom Isc 4,057 Ampere
Strom bei Nennleistung Ipmax 3,694 Ampere
Modul Type P65W-12V
Temperaturbereich -40°C / + 85°C
Toleranz +/-5 %
Solarzellen Polykristallin
By-Pass Diode
Abmessungen 720 x 670 x 35mm
Gewicht ca. 6,2 kg
Ohne Anschlusskabel!

Ich stelle mir vor, an zwei Stellen die Temperaturen zu messen. Einmal das Poolwasser, wie es von der Tauchpumpe hochgepummt wird und zweites in der Verbindungs-Leitung zwischen den beiden Absorbern. Wenn das Poolwasser nicht warm genug ist, und das Wasser am Dach schon schön warm ist, dann wird die Pumpe hochgeregelt. Ich habe vor, die Pumpe nicht zu schnell laufen zu lassen, so dass das Wasser wärend der Pumpzeit wieder oben aufgewärmt wird. Ich möchte dadurch Wartezeiten zum Aufheizen verhindern, oder wenigstens seltener machen. So wird der Absorber auch nicht dauernd schockgekühlt udn wieder erhitzt, wieder schockgekühlt und wieder erhitzt. Sondern eben so langsamm durchpumpen, dass das Wasser wärend ihrem Weg durch die Absorber, immer gleich aufgewämt wird. Also wenn es geht, möchte ich gar nicht stoppen. OK, wenn kaum Sonne ist, wird es sich nicht verhindern lassen.

Zwischen den beiden Absorbern will ich uach noch einen StrömungsSensor zusätzlich zum Temp.Sensor. Dass ich die Pumpe so steuern kann, dass das Wasser nicht steht, sondern eben langsam läuft. Der Sensor sagt mir die Strömungsgeschwindigkeit, und der Temp. Sensor die Themperatur. Sollte das Poolwasser mal die Wunsch-Themperatur deutlich überschreiten, dann Pumpt die Anlage eben nicht.

Wenn das alles läuft, könnte ich mir noch vorstellen des PH Mittel, das Chlor, und das Algenmittel automatisch beizumischen. Also mit Sensoren den Stand messen, und entsprechend nur was wirklcih nötig ist, beizumischen.

Das Laden der Batterien kontrolliere ich nicht, dafür gibt es sehr billige fertige Geräte, die gerade mal 10 - 40 Euronen kosten. Dafür ist mir die Freizeit zu schade.

[Admin]

Hier ist mal der erste Schaltplan nach meiner aktuelle Vorstellung. Da wird bestimmt noch was dazu kommen. Ich habe bis jetzt noch keine Bedienelemente ausser das Poti, mit dem ich die Pumpengeschwindigkeit regeln kann.
.

Solar_Pool_Heizung_V01.JPG (547.68 KiB) 623 mal betrachtet

[Admin]

Ich habe keine große Dachhöhe, muss daher diese Absorber die wohl 4,5 Meter x 1,2 Meter sind, nicht aufrecht, sondern liegend aufs Dach packen. Aber das sollte auch gehen. Das sieht dann so aus.
.

absorber-alternativ.jpg (53.32 KiB) 681 mal betrachtet

Das Bild habe ich mir von Poolsana geliehen und für mich passend 90 Grad gedreht. Ich werde bei Poolsana auch kommende Woche mal anrufen, ob was dagegen spricht, sie so zu montieren. Ich habe ja dann trotzdem ein Gefälle, also die Luft geht trotzdem nach oben raus. Ich weiß nur nicht, wie die Dinger innen konstruiert sind, deshalb habe ich keine Ahnung ob da was dagegen spricht.

Das würde dann ungefähr so aussehen. Das Brett, das da seitlich links raus geht, geht zum Pool. Das Kabel ist das für den PoolRobby, das direkt zum Rand des Pools zielt.
.

Poolhaus V2.jpg (422.83 KiB) 680 mal betrachtet

[Admin]

Mir hat inzwischen ein Vögelen gezwitschert, wo ich diese Messtüllen-Adapter an 38mm Rohre und 6mm Sensoren bekomme. Habe mir auch gleich 2 bestellt. Der Tag ist gerettet Die Absorber werden ja mit 38mm Rohren angefahren, deshalb sind diese fetten Dinger nötig.

Also ist eigentlich erst mal alles klar.


Achtung !!. Diese Messtüllenadapter werden in einzelteilen geliefert. Das wird in der Anzeige offenbar gerne verschleiert, dass man das erst mal kauft, und dann feststellt, dass man auch noch einen Kleber dazu braucht, umd die 4 Teile selber zusammenzukleben. Also entweder gleich einen Kleber mitbestellen, oder wo anders kaufen, wo man komplette Teile bekommt und keinen Baukasten.

[Admin]

Übrigens gleich mal nochwas zur Technik.
Es gibt die MPPT Regler und die PWM Regler. Der den ich hier zur Zeit noch verwende ist ein PWM Regler. Der MPPT Regler scheint aus den Batterien ein bischen mehr rauszukitzeln. Und der große Unterschied. Die PWM Regler können nur Bleibatterien. Bleisäure, Bleigel. Die MPPT Regler können auch mit den LiFePo4 Batterien umgehen. Ich habe hier mal ein Youtube Video zu dem Thema gesehen. Er sagt selbst dass er nicht die große Ahnung hat, aber er scheit einige Videos gemacht zu haben zu dem Thema Solarlader und Batterien.

[Admin]

Die Steuerung macht Fortschritte. Hier mal ein Bild von der Kiste. Mit den beiden Reglern kann ich die Pool-Solltemperatur (Zeile 2) einstellen, und die Soll-Differenz (Zeile 3) zwischen Pool und Wasser am Dach.
daraus macht dann das Programm die Pumpendrehzahl (Zeile 4).

Die Ist-Temperaturen gibt es noch nicht, weil ich da erst die Fühler anschließen muss. Dafür brauche ich 3pol. geschirmte Kabel, die ich noch nicht habe. Die CPU sieht man am Bild nicht, die befindet sich hinter dem Display.
.

Pool_Solarheizung_V01.jpg (768.48 KiB) 638 mal betrachtet

[Admin]

So bin wieder ein Stück weiter. Die Werte die ich brauche sind damit schon mal alle erhoben.
Zeile 2: Ich habe Poolwasser Temperatur Soll und Ist.
Zeile 3: Differenz zwíschen Pollwasser und Solarwasser am Dach, Soll und Ist.
Die wird am Bild nicht nicht gezeigt, weil ich noch einen Sensor mit langen, geschirmten Kabel bestücken muss.
Zeile 4: Pumpen Schubeinstellung bis 255.
Da muss ich noch Testen welchen Schub man minnimal braucht, dass es das Wasser aufs Dach vom Poolhaus schafft.

Ja, jetzt muss ich erst mal ein paar Tests machen und dann kommt noch die Verarbeitung der bereitgestellten Daten.

Servus
Franz
.

Pool_Solarheizung_V02.jpg (326 KiB) 627 mal betrachtet

[Admin]

So der zweite Temp. Fühler ist drann und die Differez zwischen Solar-Wassertaschen und dem Poolwasser ausgerechnet. Und so sieht das dann aus. Die nächste Etappe ist daraus die Stärke der Pumpenansteuerung zu generieren. Das mache ich jetzt dann gleich. Und dann muß ich wohl das ganze Ding aus dem Büro ins Poolhaus verlegen, weil ich ja den Pool nicht in den ersten Stock bringen kann Da kommen dann erst mal Tests mit der Pumpe, um zu sehen welche Drehzahl Pumpe mindestens fahren muss, dass sie das Wasser übers Dach und wieder zurück in den Pool fördern kann. Das ist jetzt erst mal ein kleiner Ausflug an den Pool.
.

Pool_Solarheizung_V03.jpg (352.86 KiB) 615 mal betrachtet

Noch was zu den Temperatur-Sensoren DS18B20. Ich habe dafür die im Bild sichtbaren 4 Poligen Stecker verwendet. Die sind an der Buchse wie auch am Stecker von 1 - 4 durchnummeriert.
Auf 1 = Plus = Rot vom Sensor wie auch vom Telefonkabel
Auf 2 = Minus = Schwarz vom Sensor wie auch vom Telefonkabel
Auf 3 = Daten = Gelb vom Sensor wie auch vom Telefonkabel
Auf 4 = Kupfer = Erddraht vom Telefonkabel

Den Sensor und das Telefonkabel, Rot mit Rot, Schwarz mit Schwarz, Gelb mit Gelb verbinden. Den Erddraht und den Weißen Draht vom Telefonkabel zum Sensor hin wegzwicken!

Von der Buchse zum Arduino hin:
1 ist VCC 5 Volt
2+4 ist GND
3 ist DatenPin

[Admin]

So ich habe jetzt die Pumpen-Abhängigkeit von der Temperatur-Defferenz zwischen Pooltemperatur und Solarwasser eingebaut, das läuft schon mal wunderbar. Aber jetzt brauche ich erst mal die Geschwindigkeit, die meine Pumpe minnimal laufen muss dass sie das Wasser Dach bringt austesten. Aber hier ist schon mal das Programm, das ich jetzt fürs erste geschrieben habe. Jetzt komemn eben die Anpassungen.

Code: Alles auswählen

// Arduino Pool_Solarheizung_Pumpensteuerung Beta 1.0
#include <OneWire.h>
#include <DallasTemperature.h>
#include "Wire.h"
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);
//-----Motortreiber----
const byte RPWM = 10;
const byte LPWM = 11;
const byte Poti1 = A0;
const byte Poti2 = A1;
byte Pumpe = 0;
int P1 = 0;
int P2 = 0;
int Drehzahl = 0;
int Drehzahlmin = 50;
int Drehzahlmax = 200;
unsigned long millisekunden = 0;
unsigned long Sekundenablauf01 = 0; // Messung Potis und Ausgabe Display
const unsigned long Pausezeit01 = 1000;
const unsigned char One_Wire_Bus = 2; // Sensoren auf Pin 2
OneWire oneWire(One_Wire_Bus);
DallasTemperature sensoren (&oneWire);
int Anzahl_Sensoren = 0;
int is = 0; // Zähler für die Sensoren
int ia = 0; // Zähler für die Adressstellen 0-7
int Sensor = 0;
float temppool = 0;
float tempsolar = 0;
DeviceAddress tempDeviceAddress; // Für die Adressausgabe
int numberOfDevices; // Für die Adressausgabe
//==========================================================================
void setup() {
  Wire.begin();
  sensoren.begin();
  Serial.begin(9600);
  lcd.begin();
  lcd.backlight();
  lcd.setCursor (0, 0);
  lcd.print (F("Solarheizung - Pool"));
  lcd.setCursor (0, 1);
  lcd.print (F("Soll"));
  lcd.setCursor (10, 1);
  lcd.print (F("Ist"));
  lcd.setCursor (0, 2);
  lcd.print (F("Soll"));
  lcd.setCursor (10, 2);
  lcd.print (F("Ist"));
  lcd.setCursor (0, 3);
  lcd.print (F("Die Pumpe Ist "));
  // Anzahl der Sesoren ermitteln-------------------------------------
  Anzahl_Sensoren = sensoren.getDeviceCount();
  // Ermitteln der Sensor-Adressen------------------------------------
  for (is = 0; is < Anzahl_Sensoren; is++)
  {
    if (sensoren.getAddress(tempDeviceAddress, is))
    {
      Serial.println ();
      printAddress(tempDeviceAddress);
    }
  }

  //-----------Aus-/Eingänge einrichten-------------------------------------
  pinMode(RPWM, OUTPUT);              // PWM Pumpensteuerung
  pinMode(LPWM, OUTPUT);              // PWM Pumpensteuerung
  pinMode(Poti1, INPUT);
  pinMode(Poti2, INPUT);
}
// Ausgabe der Sensor-Adressen
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t ia = 0; ia < 8; ia++)
  {
    if (deviceAddress[ia] < 16)
    {
      Serial.print("0"); //ist die Hex Adresse kleiner 16 dann erste Stelle eine "0"
    }
    Serial.print(deviceAddress[ia], HEX);
  }
}
//==========================================================================
void loop()
{
  millisekunden = millis();
  if (millisekunden - Sekundenablauf01 >= Pausezeit01) // Eine Sekunde abgelaufen?
  {
    P1 = analogRead (Poti1);
    P1 = map(P1, 0, 1023, 0, 40);
    P2 = analogRead (Poti2);
    P2 = map(P2, 0, 1023, 0, 20);
    lcd.setCursor (5, 1);
    lcd.print (P1);
    lcd.print ("  ");
    lcd.setCursor (5, 2);
    lcd.print (P2);
    lcd.print ("  ");
    lcd.setCursor (14, 3);
    lcd.print (Drehzahl);
    lcd.print (F(" "));
    Sekundenablauf01 = millisekunden;
    // -------------------------Temperatur Auswertung---------------------------
    //Temperaturen Aulesen
    sensoren.requestTemperatures();

    // Hier werden die Sensoren ausgelesen und aufs Display gebracht
    if (Sensor < 2) {
      Sensor ++;
      float temperatur = sensoren.getTempCByIndex(Sensor - 1);

      if (Sensor == 1) {
        temppool = temperatur;
        lcd.setCursor (14, 1);
        lcd.print (temppool);
        lcd.print (F(" "));
      }

      if (Sensor == 2) {
        tempsolar = temperatur;
        lcd.setCursor (14, 2);
        lcd.print (tempsolar - temppool);
        lcd.print (F(" "));
        Drehzahl= map(tempsolar - temppool,0,6,0,200);
        if (Drehzahl >Drehzahlmax)
        {
          Drehzahl = Drehzahlmax;
        }
        else
        {
          if (Drehzahl < Drehzahlmin)
          {
            Drehzahl = 0;
          }
        }
      }
      if (Sensor == Anzahl_Sensoren) Sensor = 0;
    }
  }
Pumpe = 1;
//------------------Pumpen Ansteuerung------------------------------------
if (Pumpe == 1)
{
  analogWrite(RPWM, Drehzahl);
  analogWrite(LPWM, 0);
}
else
{
  analogWrite(RPWM, 0);
  analogWrite(LPWM, 0);
  lcd.setCursor (0, 3);
  lcd.print (F(" Pumpe aus "));
}
}

[Admin]

So, jetzt bin ich mal draussen im Poolhaus in Betrieb gegangen. Morgen besorge ich mir noch ein Flexibles Stromkabel nach draussen am Pool zur Pumpe. Dann gegen die Testläufe los. Aber das wird ein Kurzes Intermezzo. Ist ja alles schon vorbereitet. Wenn ich sehe dass die Pumpe passt, dann kommt der nexte Teil. Die Absorber bestelle und aufs dach schnallen. Die Sensortüllen fehlen noch, aber die werden schon in den nächsten Tagen kommen. Ja, dann kommt der echte Betrieb. Wenigstens erst mal im Testlauf. Aber wenn alles gut läuft, bin ich in 2 Wochen mit dem Thema durch.

Der Kabel - Durcheinader hier im Bild ist nur deshalb, weil ich nur alles provisorisch angeschossen habe. Wenn das ganze dann endgültig in Betrieb geht, ist der Kabelverhau natürlich weg. Im Moment muss ich das Gerät ja auch schnell mal abstöpseln können, um es in die Werkstatt mitnehmen zu können und dort noch mögliche Hardware Änderungen vornehmen zu können. Ich möchte dass meine Geräte optimal arbeiten, und ob sie das tun, weiß ich erst nach den ersten Testläufen. Die Kabel kann man auch erst auf die richtige Länge kürzen, wenn die Geräte endgültig am Richtigen Ort hängen.
.

Pool_Solarheizung_V04.jpg (662.31 KiB) 610 mal betrachtet

Hier am Bild sieht man jetzt oben die Solarpanel-Ladesteuerung für die 24 Volt Batterien und unten die Pumpensteuerung. Im Diplay wird die derzeitge Mehrspannung von den Solarpanels gegenüber der Batterie angezeigt. Unten Links, das kleine 6mm Durchmesser Röhrchen, ist einer der beiden DS18B20 Temp. Sensoren. Der misst gerade mal die Temp im Innenraum, und ist im Echtbetrieb dann der Sensor für das Solarwasser. Den zweiten Sensor habe ich schon mal raus gehängt, da ist es nicht soooo warm. Ich hatte ihn mal zum Spass in den Pool hängen lassen, da hatte ich 18,3 Grad. Da sieht man am Bild gerade diese Aussentemperatur in der zweiten Zeile (22 Grad). In der dritten Zeile sieht man den Differenzwert 7,13 Grad. Also der zweite Sensor, der für das Solarwasser zuständig ist. Das heißt, der mist 22 + 7,13 = 29,13 Grad. Das ist die Temperatur im Poolhaus, der zur Zeit links neben meiner Steuerung liegt. Die Solldifferenz heist es im Display, soll 4 Grad nicht überschreiten, deshalb hat die Pumpe hier in Zeile 4 eine Vollgas-Ansteuerung mit dem Wert 200.

Am Programm waren ein paar Änderungen:

Code: Alles auswählen

// Arduino Pool_Solarheizung_Pumpensteuerung
#include <OneWire.h>
#include <DallasTemperature.h>
#include "Wire.h"
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);
//-----Motortreiber----
const byte RPWM = 10;
const byte LPWM = 11;
const byte Poti1 = A0;
const byte Poti2 = A1;
byte Pumpe = 0;
int P1 = 0;
int P2 = 0;
int Drehzahl = 0;
int Drehzahlmin = 50;
int Drehzahlmax = 200;
unsigned long millisekunden = 0;
unsigned long Sekundenablauf01 = 0; // Messung Potis und Ausgabe Display
const unsigned long Pausezeit01 = 1000;
const unsigned char One_Wire_Bus = 2; // Sensoren auf Pin 2
OneWire oneWire(One_Wire_Bus);
DallasTemperature sensoren (&oneWire);
int Anzahl_Sensoren = 0;
int is = 0; // Zähler für die Sensoren
int ia = 0; // Zähler für die Adressstellen 0-7
int Sensor = 0;
float temppool = 0;
float tempsolar = 0;
float tempdif = 0;
DeviceAddress tempDeviceAddress; // Für die Adressausgabe
int numberOfDevices; // Für die Adressausgabe
//##########################################################################
void setup() {
  Wire.begin();
  sensoren.begin();
  Serial.begin(9600);
  lcd.begin();
  lcd.backlight();
  lcd.setCursor (0, 0);
  lcd.print (F("Solarheizung - Pool"));
  lcd.setCursor (0, 1);
  lcd.print (F("Soll"));
  lcd.setCursor (10, 1);
  lcd.print (F("Ist"));
  lcd.setCursor (0, 2);
  lcd.print (F("Soll"));
  lcd.setCursor (10, 2);
  lcd.print (F("Ist"));
  lcd.setCursor (0, 3);
  lcd.print (F("Die Pumpe Ist "));
  // Anzahl der Sesoren ermitteln-------------------------------------
  Anzahl_Sensoren = sensoren.getDeviceCount();
  // Ermitteln der Sensor-Adressen------------------------------------
  for (is = 0; is < Anzahl_Sensoren; is++)
  {
    if (sensoren.getAddress(tempDeviceAddress, is))
    {
      Serial.println ();
      printAddress(tempDeviceAddress);
    }
  }

  //-----------Aus-/Eingänge einrichten-------------------------------------
  pinMode(RPWM, OUTPUT);              // PWM Pumpensteuerung
  pinMode(LPWM, OUTPUT);              // PWM Pumpensteuerung
  pinMode(Poti1, INPUT);
  pinMode(Poti2, INPUT);
}
// Ausgabe der Sensor-Adressen
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t ia = 0; ia < 8; ia++)
  {
    if (deviceAddress[ia] < 16)
    {
      Serial.print("0"); //ist die Hex Adresse kleiner 16 dann erste Stelle eine "0"
    }
    Serial.print(deviceAddress[ia], HEX);
  }
}
//###########################################################################
void loop()
{
  millisekunden = millis();
  if (millisekunden - Sekundenablauf01 >= Pausezeit01) // Eine Sekunde abgelaufen?
  {
    P1 = analogRead (Poti1);
    P1 = map(P1, 0, 1023, 0, 40);
    P2 = analogRead (Poti2);
    P2 = map(P2, 0, 1023, 0, 10);
    lcd.setCursor (5, 1);
    lcd.print (P1);
    lcd.print ("  ");
    lcd.setCursor (5, 2);
    lcd.print (P2);
    lcd.print ("  ");
    lcd.setCursor (14, 3);
    lcd.print (Drehzahl);
    lcd.print (F(" "));
    Sekundenablauf01 = millisekunden;
    // -------------------------Temperatur Auswertung---------------------------
    //Temperaturen Aulesen
    sensoren.requestTemperatures();

    // Hier werden die Temp-Sensoren ausgelesen und aufs Display gebracht
    if (Sensor < 2) {
      Sensor ++;
      float temperatur = sensoren.getTempCByIndex(Sensor - 1);

      if (Sensor == 1) {
        temppool = temperatur;
        lcd.setCursor (14, 1);
        lcd.print (temppool);
        lcd.print (F(" "));
      }

      if (Sensor == 2) {
        tempsolar = temperatur;
        tempdif = tempsolar - temppool;
        lcd.setCursor (14, 2);
        lcd.print (tempdif);
        lcd.print (F(" "));
        Drehzahl = map(tempdif, 0, 6, 0, 200);
        if (Drehzahl > Drehzahlmax)
        {
          Drehzahl = Drehzahlmax;
        }
        else
        {
          if (Drehzahl < Drehzahlmin)
          {
            Drehzahl = 0;
          }
        }
      }
      if (Sensor == Anzahl_Sensoren) Sensor = 0;
    }
    //------------------Pumpen Ansteuerung------------------------------------
    // Wenn Temperaturdifferenz gleich/größer eingestellte Differenz dann Pumpe Maximal
    if (tempdif >= P2)
    {
      Drehzahl = Drehzahlmax;
    }
    // Ist aber die Wunsch-Temperatur erreicht, dann keine Solar Unterstützung mehr
    if (temppool > P1)
    {
      Drehzahl = 0;
    }
    analogWrite(RPWM, Drehzahl);
    analogWrite(LPWM, 0);
  }
}

Im Programm werden jetzt auch die Einstellungen der Potis berücksichtigt.
Maximale Wunsch Differenz erreicht, Pumpe Vollgas.
Aber wenn Maximale Wunsch Pooltemperatur überschritten, trotzdem Pumpe aus.