Impressum

Impressum:
Angaben gemäß § 5 TMG:

Martin Schneider
Wildroßstraße 8
45897 Gelsenkirchen

Kontakt:

Telefon: 01772914672
E-Mail: ascotthortersqu@gmail.com

Verantwortlich für den Inhalt nach § 55 Abs. 2 RStV:

Martin Schneider
Wildroßstraße 8
45897 Gelsenkirchen

Quelle: https://www.e-recht24.de

 

Haftungsausschluss (Disclaimer)

 

Haftung für Inhalte

Als Diensteanbieter sind wir gemäß § 7 Abs.1 TMG für eigene Inhalte auf diesen Seiten nach den allgemeinen Gesetzen verantwortlich. Nach §§ 8 bis 10 TMG sind wir als Diensteanbieter jedoch nicht verpflichtet, übermittelte oder gespeicherte fremde Informationen zu überwachen oder nach Umständen zu forschen, die auf eine rechtswidrige Tätigkeit hinweisen. Verpflichtungen zur Entfernung oder Sperrung der Nutzung von Informationen nach den allgemeinen Gesetzen bleiben hiervon unberührt. Eine diesbezügliche Haftung ist jedoch erst ab dem Zeitpunkt der Kenntnis einer konkreten Rechtsverletzung möglich. Bei Bekanntwerden von entsprechenden Rechtsverletzungen werden wir diese Inhalte umgehend entfernen.

Haftung für Links

Unser Angebot enthält Links zu externen Webseiten Dritter, auf deren Inhalte wir keinen Einfluss haben. Deshalb können wir für diese fremden Inhalte auch keine Gewähr übernehmen. Für die Inhalte der verlinkten Seiten ist stets der jeweilige Anbieter oder Betreiber der Seiten verantwortlich. Die verlinkten Seiten wurden zum Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft. Rechtswidrige Inhalte waren zum Zeitpunkt der Verlinkung nicht erkennbar. Eine permanente inhaltliche Kontrolle der verlinkten Seiten ist jedoch ohne konkrete Anhaltspunkte einer Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Links umgehend entfernen.

Urheberrecht

Die durch die Seitenbetreiber erstellten Inhalte und Werke auf diesen Seiten unterliegen dem deutschen Urheberrecht. Die Vervielfältigung, Bearbeitung, Verbreitung und jede Art der Verwertung außerhalb der Grenzen des Urheberrechtes bedürfen der schriftlichen Zustimmung des jeweiligen Autors bzw. Erstellers. Downloads und Kopien dieser Seite sind nur für den privaten, nicht kommerziellen Gebrauch gestattet. Soweit die Inhalte auf dieser Seite nicht vom Betreiber erstellt wurden, werden die Urheberrechte Dritter beachtet. Insbesondere werden Inhalte Dritter als solche gekennzeichnet. Sollten Sie trotzdem auf eine Urheberrechtsverletzung aufmerksam werden, bitten wir um einen entsprechenden Hinweis. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Inhalte umgehend entfernen.
Datenschutzerklärung:
Datenschutz

Die Betreiber dieser Seiten nehmen den Schutz Ihrer persönlichen Daten sehr ernst. Wir behandeln Ihre personenbezogenen Daten vertraulich und entsprechend der gesetzlichen Datenschutzvorschriften sowie dieser Datenschutzerklärung.

Die Nutzung unserer Webseite ist in der Regel ohne Angabe personenbezogener Daten möglich. Soweit auf unseren Seiten personenbezogene Daten (beispielsweise Name, Anschrift oder E-Mail-Adressen) erhoben werden, erfolgt dies, soweit möglich, stets auf freiwilliger Basis. Diese Daten werden ohne Ihre ausdrückliche Zustimmung nicht an Dritte weitergegeben.

Wir weisen darauf hin, dass die Datenübertragung im Internet (z.B. bei der Kommunikation per E-Mail) Sicherheitslücken aufweisen kann. Ein lückenloser Schutz der Daten vor dem Zugriff durch Dritte ist nicht möglich.

Datenschutzerklärung für die Nutzung von Facebook-Plugins (Like-Button)

Auf unseren Seiten sind Plugins des sozialen Netzwerks Facebook, Anbieter Facebook Inc., 1 Hacker Way, Menlo Park, California 94025, USA, integriert. Die Facebook-Plugins erkennen Sie an dem Facebook-Logo oder dem „Like-Button“ („Gefällt mir“) auf unserer Seite. Eine Übersicht über die Facebook-Plugins finden Sie hier: http://developers.facebook.com/docs/plugins/.

Wenn Sie unsere Seiten besuchen, wird über das Plugin eine direkte Verbindung zwischen Ihrem Browser und dem Facebook-Server hergestellt. Facebook erhält dadurch die Information, dass Sie mit Ihrer IP-Adresse unsere Seite besucht haben. Wenn Sie den Facebook „Like-Button“ anklicken während Sie in Ihrem Facebook-Account eingeloggt sind, können Sie die Inhalte unserer Seiten auf Ihrem Facebook-Profil verlinken. Dadurch kann Facebook den Besuch unserer Seiten Ihrem Benutzerkonto zuordnen. Wir weisen darauf hin, dass wir als Anbieter der Seiten keine Kenntnis vom Inhalt der übermittelten Daten sowie deren Nutzung durch Facebook erhalten. Weitere Informationen hierzu finden Sie in der Datenschutzerklärung von Facebook unter http://de-de.facebook.com/policy.php.

Wenn Sie nicht wünschen, dass Facebook den Besuch unserer Seiten Ihrem Facebook- Nutzerkonto zuordnen kann, loggen Sie sich bitte aus Ihrem Facebook-Benutzerkonto aus.

Datenschutzerklärung für die Nutzung von Twitter

Auf unseren Seiten sind Funktionen des Dienstes Twitter eingebunden. Diese Funktionen werden angeboten durch die Twitter Inc., 1355 Market Street, Suite 900, San Francisco, CA 94103, USA. Durch das Benutzen von Twitter und der Funktion „Re-Tweet“ werden die von Ihnen besuchten Webseiten mit Ihrem Twitter-Account verknüpft und anderen Nutzern bekannt gegeben. Dabei werden auch Daten an Twitter übertragen. Wir weisen darauf hin, dass wir als Anbieter der Seiten keine Kenntnis vom Inhalt der übermittelten Daten sowie deren Nutzung durch Twitter erhalten. Weitere Informationen hierzu finden Sie in der Datenschutzerklärung von Twitter unter http://twitter.com/privacy.

Ihre Datenschutzeinstellungen bei Twitter können Sie in den Konto-Einstellungen unter http://twitter.com/account/settings ändern.

Datenschutzerklärung für die Nutzung von YouTube

Unsere Webseite nutzt Plugins der von Google betriebenen Seite YouTube. Betreiber der Seiten ist die YouTube, LLC, 901 Cherry Ave., San Bruno, CA 94066, USA. Wenn Sie eine unserer mit einem YouTube-Plugin ausgestatteten Seiten besuchen, wird eine Verbindung zu den Servern von YouTube hergestellt. Dabei wird dem Youtube-Server mitgeteilt, welche unserer Seiten Sie besucht haben.
Wenn Sie in Ihrem YouTube-Account eingeloggt sind ermöglichen Sie YouTube, Ihr Surfverhalten direkt Ihrem persönlichen Profil zuzuordnen. Dies können Sie verhindern, indem Sie sich aus Ihrem YouTube-Account ausloggen.

Weitere Informationen zum Umgang von Nutzerdaten finden Sie in der Datenschutzerklärung von YouTube unter https://www.google.de/intl/de/policies/privacy

6. Die Kosten der Bauteile

Einer der Gründe für den Selbstbau sind natürlich die Kosten, die gegenüber vergleichbar leistungfähigen Geräten deutlich geringer sein können. Es kommt natürlich auch darauf an, ob man sich ein wenig auf die Suche macht, wirklich preiswert an die Einzelteile zu kommen, oder ob man einige Zutaten schon im Bastelkeller finden kann. Viele Bauteile findet man – je nach Anspruch auch gebraucht – bei Ebay, da konnte ich z.B. die beiden Papst-Diagonlaventilatoren zu einem Spottpreis von 15 Euro kaufen.

Die unten angegebenen Preise (bis auf die oben erwähnten Ventilatoren) habe ich incl. Versandkosten bezahlt. So kam ich auf insgesamt rund
320.- Euro Materialkosten.

KG-Rohre DN160 und DN200, Abzweige, Stopfen und Reduzierungen für den Wämetauscher: ca. 50,- (Stabilo Werkzeugfachmarkt)
KG-Rohre DN110 und Winkel für die Luftwege 30,- (Hornbach)
Trinkhalme 25,- (Spielwaren Erding)
Edelstahl Volierendraht 25,- (Ebay)
Netzteil Meanwell RS-100-24 15,- (Ebay)
2 Papst-DC-Diagonalventilatoren neu ca. 200,- (ebm-papst)
Sekundenkleber, Primer 30,- (2Construct)
Filterbox mit 2 Deckeln 15,- (Hornbach)
F7-Filter, G4 Filtermatte 25,- (Swirl)
Raspberry mit Netzteil und WLAN-Adapter 45,-
4 DHT Feuchtesensoren 10,- (Ebay China)
Platine, Bauteile, Relais (EXP GmbH), Kabel, LCD-Display 30,- (Ebay)

5. Auswahl der Ventilatoren

Zur Auswahl der beiden benötigten Lüfter für Fort- und Zuluft habe ich zunächst versucht, die Druckverluste in der geplanten Rohrstrecke, im Wärmetauscher und in dem Luftfilter zu berechnen. Leider waren die entsprechenden Infos entweder für den zwar interessierten, aber nicht ausgebildeten Laien teils komplizierte Berechnungen, oder die Druckverluste werden einfach nicht genau angegeben, z.B. bei den Filtereinsätzen. So habe ich die jetzigen F7-Filtereinsätze mit ähnlichen Einsätzen verglichen, bei denen es Angaben dazu gab.
Lediglich beim Ventilator gab es präzise Angaben zu den Kenndaten, sodass ich bei der Wahl des Ventilators von ebm-papst auf ein ausführliches Firmendatenblatt zugreifen konnte.

Für eine etwas genauere Auslegung, aber auch zur Überprüfung der Leistung habe ich mir dann einen Versuchsaufbau aufgebaut, mit dessen Hilfe ich die Strömungsverhältnisse durch einfaches Ausprobieren und Auswerten in den Griff bekommen wollte.

Für diese Tests hatte ich nach einiger Internet-Recherche eine grobe Vorstellung von der Volumenleistung, die ich mir ausgedacht hatte. Das Problem ist ja eventuell, dass es im Sommer in der Nacht nur eine relativ kurze Zeitspanne geben könnte, in der die Luftfeuchtigkeit außen geringer ist als im Keller. Daher musste der Volumenstrom schon relativ hoch liegen.
Um die 150 Kubikmeter pro Stunde sollten es daher schon sein.

Der benutzte Lüfter von ebm-papst ist vom Typ her ein sogenannter DC-Diagonallüfter, der einen brauchbaren Volumenstrom in einem relativ hohen Druckbereich liefern kann. Also hoffentlich genau richtig, wenn man Druckverluste zu erwarten hat. Außerdem habe ich so Reserven, wenn sich der Luftfilter zusetzt, und dort der Druckverlust zunimmt.

Der Versuchsaufbau

Er besteht aus einem in das vorgesehene Rohrstück eingebautem Lüfter, daran angeschlossen ein langer Luftschlauch mit einem definierten Füllvolumen von ungefähr 333,33 Litern und einem Handy zum Stoppen der Füllzeit. Beim Vergleich mit dem frei in den Luftschlauch blasenden Ventilator, und den Füllzeiten mit angeschlossenem Wärmetauscher und/oder davorgesetzter Filterbox lassen sich durch einfaches Stoppen die Druckverluste abschätzen, bzw. das Luftfördervolumen der Lüftungsanlage bestimmen.

Versuchsaufbau1
Hier der Wärmetauscher mit angeflanschter Lüfterbox

 

Versuchsaufbau3
Hier füllt sich der Luftsack frei einblasend
Versuchsaufbau2
Ich habe das Füllvolumen mit 333,33 Litern grob geschätzt. 🙂 Weiß jemand das Füllvolumen eines Schlauchsacks von 86 x 213 cm exakt?

Ergebnis der kleinen Versuchsreihe:

Füllzeit frei einbasend:
4 Sekunden – entspricht 300 Kubikmeter/h Volumenstrom

Füllzeit nur mit Wärmetauscher:
5 Sekunde – entspricht 240 Kubikmeter/h Volumenstrom

Füllzeit mit Wärmetauscher und Filterbox:
6 Sekunden – entspricht 200 Kubikmeter/h

Füllzeit mit Wärmetauscher, Filterbox plus 10 Meter Rohrleitung mit 10 Krümmungen:
7 Sekunden – entspricht 170 Kubikmeter/h

 

Die beiden Lüfter

Lüfternenndaten
Das Datenblatt spricht von 320 Kubikmeter/h freiblasend, bei meinem Versuchsaufbau brauchte er für 333,33 Liter 4 Sekunden, also dementsprechend 12 Sekunden pro Kubikmeter. 3600 Sekunden (= 1 Stunde) geteilt durch 12 ergibt 300 Kubikmeter pro Stunde, also ein Wert, der ziemlich genau den Daten entspricht.

Kennlinie
Jetzt kann ich anhand des Lüfterdiagramms und der verschiedenen Fördervolumina abschätzen, ob der gewählte Lüfter in seinem optimalen Arbeitspunkt arbeitet. Wie man sieht, bewege ich mich bei einem Volumenstrom (V) von 170 Kubikmetern/h bei einem Druck von ca. 180 Pa, was für mich bedeutet, dass der Lüfter ausreichend dimensioniert ist.

Der Raum zum Wäschetrocknen sowie die daran angrenzenden Räume haben ein Luftvolumen von ca. 120 Kubikmetern. Das bedeutet, dass innerhalb einer Laufzeit von rund 42 Minuten das gesamte Luftvolumen einmal ausgetauscht wäre. Damit sollte auch im Sommer selbst bei einem knappen Zeitfenster noch eine gute Lüftung klappen können.

 

Hier sind noch ein paar Bilder des Lüftereinbaus in die KG-Reduzierung DN200 auf DN160 mittels einer Scheibe, Innendurchmesser 125 mm, Außendurchmesser 189 mm. Die Scheibe wurde aus einem KG200-Rohrstopfen ausgesägt.

 

4. Die Luftfilterung

Die Luft wird in lufttechnischen Anlagen üblicherweise gefiltert, damit einerseits die Anlage selbst nicht verdreckt, oder sich die Rohre schneller als einem lieb ist, zusetzen. Dementsprechend wird die Luft, die nach draußen befördert wird, ebenfalls mit einem Grobfilter gereinigt. Die einströmende Luft wird noch etwas stärker gefiltert, ich habe mich dabei an der sehr verbreiteten Filterklasse für Lüftungsgeräte orientiert, und einen F7-Filtereinsatz mit vorgelegter F4-Grobfiltermatte vorgesehen. Für die Abluft ist eine G4-Grobfiltermatte eingebaut.

Damit der Wirkungsgrad der Anlage nicht durch zu kleine Filter gemindert wird, habe ich für die anzusaugende Luft eine relativ üppige Filterbox gebaut, die aus einer ausgesprochen stabilen Mehrzweckkiste aus grauem Polypropylen besteht.
Es gibt sie in vielen unterschiedlichen Größen in einem TV-bekannten Baumarkt, in dessen Werbung die Menschen immer ganz besonders dreckig werden.

Filterbox
Das Innenmaß der grauen Stapelkiste ist ungefähr 36 x 26 cm, die nutzbare Innen-Höhe beträgt ca. 20 cm. Der Boden ist mit einem Wabenmuster verstärkt. Genau in die Mitte der Waben habe ich in liebevoller Handarbeit sechseckige Öffnungen gesägt, durch die dann später die Außenluft angesaugt werden wird, und gleichzeitig die Filtermedien gut geschützt sind. (Scherz, das war in Wirklichkeit wieder meine Fräse, aber ich denke, runde Löcher hätten den gleichen Zweck erfüllt). Auf der Raum-Seite ist der Kistendeckel mit einem Loch versehen, Durchmesser 125 mm, damit ein KG-Rohr-Stutzen genau passend eingesetzt werden kann.
Für diese Box-Abmessungen habe ich einen gut passenden Filtereinsatz gefunden, der selbst die Maße 25 x 35 x 9,4 cm hat. Er wird bestimmungsgemäß für die Lüftungsanlage von der Fa. Paul, Atmos 175 benutzt. Der Filtereinsatz ist mit einem Preis von unter 20 Euro nicht sehr kostspielig.
In meinem Fall wird diese Kisten-Filtereinheit direkt in eine Fensteröffnung im Keller eingebaut, die dann in einem Lichschacht endet. Der durchlöcherte Boden weist nach außen, dann kommen als nächstes eine Lage G4-Grobfilter, danach der F7 Filtereinsatz, dahinter eine Halterung/Klemmung für die Filtereinsätze. Diese Klemmung besteht wieder aus dem Kisten-Deckel, der passend zu dieser Kiste angeboten wird, und der passend zurechtgesägt wird. Dann folgt eine Luftkammer, die über die Deckelbohrung schließlich im KG-Rohr DN110-Stutzen den Anschluss des Wärmetauschers ermöglicht.
Der Deckel wird mit einigen Edelstahl-Blechschrauben befestigt, die natürlich nicht zu fest angezogen werden sollten, da sie nur in ca. 2 mm PP-Material der Kiste halten. Der Deckel und die Seiten erhalten zur Wärmedämmung noch einen Einsatz aus Styrodur-Platten.

Da Bilder wieder einmal mehr als 1000 Worte sagen, hier ein paar Fotos von der Filterbox.

Bildschirmfoto 2016-05-03 um 19.37.12

So sieht die Box unbearbeitet aus.
Der Boden ist durch die Wabenstruktur sehr stabil.

 

Bildschirmfoto 2016-05-03 um 19.36.39

Hier wird das Loch für den Stutzen hergestellt.

 

Bildschirmfoto 2016-05-03 um 19.38.26
Die Box mit den fertig ausgefrästen Waben.

1. Einleitung

In diesem Blog geht es um ein Selbstbauprojekt einer automatischen Lüftung mit Wärmerückgewinnung für einen Kellerraum, in dem Wäsche getrocknet wird.
Insbesondere um die Vorstellung einer Selbstbau-Version, die im wesentlichen aus leicht beschaffbaren Komponenten besteht, und auf besondere Designvorgaben nicht angewiesen ist. Schließlich ist die Technik in einem Kellerraum untergebracht, und daher besonderen ästhetischen Anforderungen nicht unterworfen.

Also, kurz skizziert, geht es um Folgendes:

Der Keller – insbesondere der Wäschetrocknerraum – soll belüftet werden, damit ein gutes Trocknen der Leinen-Wäsche gewährleistet wird.
Nebenbei soll natürlich auch wirksam verhindert werden, dass feuchte Luft an den kühleren Kellerwänden auskondensiert, sprich Wasser sich niederschlagen kann, und der Nährboden für Schimmelbildung entsteht.
Damit die Feuchtigkeit herausgelüftet werden kann, muss also ein Ventilator die feuchte Luft nach außen befördern.
Die feuchte Luft muss aber ersetzt werden, am besten durch relativ trockene Luft. Und die zweite Anforderung ist, dass die frische hereingebrachte Luft eine ähnliche Temperatur hat, wie die weggelüftete. Das ist das Prinzip der Wärmerückgewinnung.
Nur nach außen weglüften, hätte zur Folge, dass warme Luft aus den höher liegenden Stockwerken in den Keller geführt wird, und der höhere Wassergehalt der wärmeren Luft sich nun erst recht an den Wänden niederschlägt. In diesem Fall würde also Lüften nur das Gegenteil bewirken. Ebenso ist es häufig so, dass die Außenluft sogar noch mehr Feuchtigkeit enthält, als die Kellerluft, die wir eigentlich loswerden wollen. Insbesondere im Sommer wird man wahrscheinlich nur nachts bei tieferen Temperaturen auch die gewünschte geringere Luftfeuchtigkeit vorfinden. Kurzum, eine Steuerung, die über Sensoren die Feuchte messen und auswerten kann, und so die Lüfter schalten kann, ist zwingend erforderlich.

Mein Ansatz zur Lösung ist auch nicht neu. Wer sich schon einmal mit der Thematik befasst hat, findet unter dem Stichwort „dezentrale Lüftung“ im Netz ja auch etliche Infos zum Thema „richtiges Lüften“, „Wärmetauscher“, „Lüftersteuerung“ etc.

Hier geht es um die möglichst genaue, und für diejenigen, die sich mit ähnlichen Projekten beschäftigen wollen, zusammenfassenden Darstellung einer bereits realisierten Ausführung. So kann jeder, der selbst in ein ähnliches Projekt einsteigen möchte, vielleicht besser abschätzen, wie die Dimensionierung der Komponenten für ihn günstig wäre. Denn es gibt einige Stellschrauben, die man irgendwann einmal festlegen muss. Zum Beispiel die Größe der Wärmetauschereinheit, die Auswahl des richtigen Lüftermotors mit den Verhältnissen aus Wattzahl, Fördermenge und Förderdruck, aus der Länge der Rohrführung von Frischluft und Abluft, der Art der Luftfilterung mit der Festlegung der Filterklasse und der Größe des Filtermediums etc.

Die Erfahrungen aus dem laufenden Betrieb liegen demnächst vor, und die Auswertung wird bestimmt einige Tuningmöglichkeiten aufzeigen, die ich in diesem Blog ebenfalls demnächst kurz anreißen möchte.

2. Der Wärmetauscher

Der Wärmetauscher ist das Herzstück der Anlage und die wichtigste Komponente. Im Laufe der Entwicklung habe ich viele Möglichkeiten durchgespielt, wie man dieses Teil am einfachsten im Selbstbau anfertigen kann. Dabei ging es mir besonders darum, den Wärmetauscher mit »relativ« einfachen Mitteln herstellen zu können, die leicht zu beschaffen sind, und sich auch leicht verarbeiten lassen.

Er besteht im wesentlichen aus KG-Rohren bzw. den entsprechenden Bogenstücken, Muffen, Abzweigen und Reduzierungen, sowie aus dem Rohrbündeleinschub.Der Grund für die Auswahl lag daran, dass man durch einfaches Stecken der Bauteile bereits schon das fertige Gehäuse erhält, und dass alle Anschlüsse sofort mit KG-Rohr weitergeführt werden können. Bis zu einem Maß von DN160 ist alles meistens im Baumarkt meines Vertrauen vorrätig, lediglich die DN200 Stücke habe ich im Internet bestellt. Da der Wärmetauscher in einem Werkraum untergebracht wird, musste ich auf formvollendetes Design keine Rücksicht nehmen, ebenso konnte ich den Wärmetauscher relativ groß auslegen, was sich bei dem besseren Luftdurchsatz durch weniger Strömungsverluste dann positiv bemerkbar macht.

 

_SAM2746
Da guckt man ganz schön in die Röhre!

Der Rohrbündeleinschub besteht aus vielen dünnen Polypropylen-Röhrchen, 1 Meter lang, und ca. 6,5 mm Durchmesser, Wandstärke ca. 0,13 mm, besser bekannt unter dem Begriff »Trinkhalm« in der Ausführung XXL, dann heißt die Sorte »Ballermann-Trinkhalm« oder »Sangria-Trinkhalm«. Diese werden zu einem Rohrbündel zusammengefasst. Das Innenvolumen der Rohre entspricht dabei in etwa dem Volumen der um die Rohre strömenden Luft. Der Abstand der Rohre zueinander, die Matrix, wird durch zwei Scheiben geschaffen, die die Rohre auf Abstand hält, in meinem Fall 8 mm.

_SAM2738
Die ausgeschnittene Edelstahlmatte.

 

Da die Rohre bei einem Meter Länge zwischen den beiden Endscheiben eingespannt sind, müssen die Abstände im Verlauf der Länge zusätzlich stabilisiert werden. Das geschieht durch einen Maschendraht aus Edelstahl. In meinem Fall hat die einzelne Masche aber einen Abstand von 8,5 mm. Durch das Schrägstellen dieser Matrix ergibt sich dann aber wieder der gewünschte Abstand von 8 mm. Außerdem stabilisiert sich das Rohrbündel etwas besser.

 

_SAM2743
Das Einfädeln der Röhrchen ist etwas fummelig.

 

Meine größte Sorge war zunächst, dass die Trinkhalme nicht stabil genug wären, oder leicht knicken könnten und dann undicht werden.
Daraufhin habe ich versucht, einen Trinkhalm zu zerstören, also habe ich ihn mit aller Gewalt zerknubbelt, und versucht, ihn zu zerreißen. Der Erfolg war, dass er natürlich ziemlich geknittert war. Aber nach dem glattstreichen ließ er sich problemlos wieder in seine ursprüngliche Form bringen und war absolut dicht. Kein Loch an den Knickstellen. Nach diesem Experiment war ich davon überzeugt, dass der normale Gebrauch überhaupt keine negativen Einflüsse haben kann, und das Prinzip sehr dauerhaft ist. Ein weitere Knackpunkt war zunächst die Verklebung von Polypropylen, das ist nämlich das Grundmaterial der Trinkhalme. Polypropylen ist eigentlich ein unipolarer Kunststoff, der sich fast gar nicht verkleben lässt. Ich habe auch nur zwei Arten von Klebstoff gefunden, die eine Verklebung ermöglichen könnten. Zum einen ein Zweikomponenten-Klebstoff, der aus einer Doppelkartusche im Verhältnis 1 : 10 mittels einer speziellen Auspresspistole über eine Mischkanüle appliziert werden kann.
Dieser Klebstoff kann die mit Alkohol gereinigte Oberfläche direkt verkleben, ohne einen Primer als Haftvermittler zu benötigen. Bei meinen Testverklebungen hatte ich eigentlich schon ganz gute Ergebnisse erzielt.
Letzten Endes habe ich mich aber dann für die Kombination Primer und Sekundenkleber entschieden. Die Handhabung war wesentlich einfacher und die Klebeeigenschaften waren noch einen „Tacken“ besser.

 

Die Montage des Rohbündels.
Zunächst habe ich die beiden Scheiben aus zwei KG-Rohr-Stopfen angefertigt. Die eine Seite besteht aus einer Scheibe mit nahezu dem Innendurchmesser eines KG-Rohres der Dimension DN200. Das sind nominell 190 mm, für ein leichteres Durchgleiten in den Rohrteilen habe ich den Durchmesser mit 189 mm festgelegt. Der Stopfen wird dazu zunächst mit den 362 Stück 6,5 mm Bohrungen versehen. Ich habe das große Glück, diese Arbeiten auf einer CNC-Fräse herstellen zu können, die das Bohrprogramm in knapp 70 Minuten erledigt. Was aber nicht heißt, dass man mit einer normalen Bohrmaschine nicht auch die entsprechenden Löcher gebohrt bekäme. Die Scheibe wird dann anschließend aus dem Stopfen herausgefräst (oder gesägt), sodass der erwähnte Durchmesser von 189 mm erreicht wird. Die andere Scheibenseite wird genau gleich gebohrt, allerdings wird dann nur der Rand des Stopfens abgefräst und die Seitenhöhe auf ca. 3 cm abgesägt und mit der Fräse begradigt. Dadurch kommen wir auf den DN200 Außendurchmesser von 200 mm. Diese Scheibe soll also nicht komplett im Rohr verschiebbar sein, sondern nur bis zum Anschlag des Abzweigrohres eingeschoben werden können und so Halt finden können.

 

_SAM2770
Die Fräse in Aktion. Man sieht den eingespannten KG-Rohr-Stopfen als »Rohling«.

 

_SAM2772
Das Bohrprogramm für MACH3 der CNC-Fräse.

 

_SAM2822
Hier sieht man die schon fertiggebohrte Scheibe, Durchmesser 189 mm, Stärke 5 mm, 362 Löcher von 6,5 mm Durchmesser im Abstand von 8 mm.

 

_SAM2832
Aus den vorher in die Edelstahldrahtmaschen und der Scheibe auf der anderen Seite eingefädelten Rohren wird von unten nach oben verklebt, hier bin ich schon mittendrin.

 

_SAM2831
Die Röhrchen schauen noch ca. 2 mm auf der Rückseite heraus, damit der Sekundenkleber auch hinten und vorne einen Wulst bilden kann, und die Rohre fest sitzen.

 

Die Zusammenstellung der Bauteile des Wärmetauschers

In der Abbildung sind alle Bauteile des Wärmetauschers so angeordnet, wie sie dann zusammengesteckt werden. Zunächst wird das Rohrbündel in die KG-Abzweige eingesteckt, damit man die benötigte Länge des Verbindungsstückes (KG-Rohr DN200, 50 cm) anzeichnen und später kürzen kann. In meinem Fall waren es genau 68 mm, die abgeschnitten wurden.

Explosionszeichnung
Explosionszeichnung

3. Die Steuerung

Ich habe die Steuerung über den kleinen Einplatinencomputer Raspberry Pi realisiert. Die Gründe dafür waren, dass der Betrieb gleichzeitig mitgeloggt werden soll, und dass eine WLAN-Unterstützung relativ einfach zu realisieren ist, sodass der Betrieb über den Fernzugriff einfach zu überwachen ist. Die Ansteuerung der Lüfter erfolgt über ein bistabiles Relais, dass nur während des Schaltvorgangs Strom verbraucht. Überhaupt ist die Stromaufnahme des kleinen Raspberry Pis mit 4 Watt noch erfreulich moderat.
Das eigentliche Programm ist in Python ausgeführt und wahrscheinlich in den Augen gelernter Programmierer durchaus verbesserungsfähig.

Daneben ist der kleine Computerzwerg auch noch relativ preiswert zu bekommen, insbesondere die etwas ältere Ausführung, die ich hier benutze, ist für weniger als 30 Euros inkl. Netzteil zu bekommen. Für alle, die nicht so firm sind im Umgang mit dem Lötkolben und der Programmierung, dafür aber etwas mehr Geld ausgeben können, wäre eine Möglichkeit gewesen, auf den Möglichkeiten einer homematic Haussteuerung zurückzugreifen. Dort gibt es fertige Feuchtesensoren, die man über ein grafisches Interface relativ eifach einbinden kann. Ich hatte mich damit ebenfalls beschäftigt, bin aber aufgrund des doch relativ hohen Preises der Komponenten eben zu der Raspberry-Pi-Version gekommen. Aber wie gesagt, die homematic-Steuerung ließe sich mit ca. 300 Euro ebenfalls realisieren. Letzten Endes geht es ja auch um eine einfache „Wenn-dann“ Steuerung, also einfach den absoluten Feuchtegrad der Luft im Wäschetrocknerraum mit der Außenfeuchtigkeit vergleichen. Falls die Außenluft also weniger Wasser enthält, als die Innenluft, soll der Lüfter starten, sprich feuchte Luft wird dem Wärmetauscher über die Außenseiten der Röhrchen vorbeigeführt und nach draußen abgeleitet, während der zweite Lüfter umgekehrt dieselbe Menge an Luft von außen jetzt durch die Röhrchen in den Wäschetrocknerraum befördert, und dabei durch den Gegenstrom nahezu die Temperatur der Innenluft annehmen wird.

Ein Vorteil der Raspberry-Version: Die Feuchte- und Temperaturwerte werden aufgezeichnet in einer CV-Datei gespeichert, und stehen zu Auswertezwecken zur Verfügung. Es werden 4 Feuchtesensoren vom Typ DHT 22 eingesetzt, jeweils also an den 4 Ausgängen des Wärmetauschers, sodass man die Betriebszustände und die Steuerung der Lüfter in Abhängigkeit von den Sensorwerten vornehmen kann.
Das Relais sowie die Anschlüsse der 4 Sensoren und der LEDs sowie noch eine kleine zweizeilige LCD-Anzeige sind auf einer kleinen Platine zusammengefasst, die über ein Flachkabel mit den GPIO-Ports des Raspberry verbunden ist. Den Versuchsaufbau habe ich auf einem Breadboard mit fliegender Steckverdrahtung aufgebaut, um während der Programmierung flexibel zu sein. Die Umsetzung der Platine ist sehr schlicht ausgeführt, in Ermangelung der Möglichkeit einer zweiseitigen Platinenherstellung, habe ich mit Drahtbrücken und einer Streifenrasterplatine mit Dreiergruppen gearbeitet, was aber aufgrund der Einfachheit der Platine auch nicht weiter tragisch ist.

_SAM2589
Die Tests auf dem Breadboard. Vorne eine bistabile Relaisstufe und im Hintergrund zwei DHT22 als Humidity-Sensoren.
SAMSUNG CAMERA PICTURES
Die fertige Platine der Lüftersteuerung

 

Das Layout der Bestückungsseite
Und hier das Layout der Bestückungsseite mit den eleganten Drahtbrücken

 

Das Programm

Das Python-Programm besteht aus mehreren Funktionsteilen, die mir gestatten sollen, über das Terminal-Programm auf meinem Mac den Ablauf der Messung genau zu verfolgen. Dasselbe kann man natürlich auch über das Terminal-Programm auf dem Raspberry erledigen, aber dann hätte ich nicht so bequem vom Arbeitsrechner aus zugreifen können. Die Raspberry-Oberfläche kann man sich auch über Remote Desktop auf den Mac holen. Für die Programmausführung reicht aber auch das Mac-eigene Programm „Terminal“.

Der Raspberry ist über einen kleinen WLAN-Stick in das Netzwerk eingebunden, und der Pi kann (in meinem Fall) über den Aufruf „ssh 192.168.178.43 -l pi“ und seinem Passwort direkt angesprochen werden. Dann kann das Python-Programm gestartet werden mit dem Programmnamen „sudo ./lueftersteuerung.py“.

Damit der Betrieb auch automatisch läuft, habe ich einen entsprechenden CRON-Job definiert, der z.B. bei Stromausfall oder einem Reset das Programm wieder neu startet und im Abstand von einer Viertelstunde immer wieder ausführt. Also natürlich auch unabhängig vom Mac-Termial.

Das folgende Programmlisting kann leider nicht einfach kopiert werden, da die Syntax von Python die genaue Stellung von Tabulatoren und Zeichen erfordert, die hier verloren gegangen sind, daher also mit Vorsicht zu genießen. Wer Interesse hat, sich tiefer damit zu befassen, kann sich ja mal bei mir melden.

 

#!/usr/bin/python
# coding=utf-8

print „Start der Messung!“

# Test code für eine feuchteabhängige Lüftersteuerung

import RPi.GPIO as GPIO
import time

# rote LED für 3 Sekunden einschalten zum Beginn des Programms
# PIN-Nummern verwenden (nicht GPIO-Nummern)
GPIO.setmode(GPIO.BOARD)
# PIN 26 (=GPIO 7) (CE1) zur Datenausgabe verwenden
GPIO.setup(26, GPIO.OUT)
# PIN 26 einschalten
GPIO.output(26, GPIO.HIGH)
# nach 3 Sekunden wieder ausschalten
time.sleep(3)
GPIO.output(26, GPIO.LOW)
# alle vom Script benutzen GPIOs wieder freigeben
GPIO.cleanup()
import dhtreader
import time
type = 22
# dhta4 ist pin 7, brauchte ich für lcd, daher jetzt pin 5 = dht 24
DHTA = 24
DHTI = 25

DHTA1 = 22
DHTI1 = 23

def getDHTData():
global TemperaturAussen
global LuftfeuchtigkeitAussen
global TemperaturInnen
global LuftfeuchtigkeitInnen

global TemperaturAusgang
global FeuchteAusgang
global TemperaturEingang
global FeuchteEingang

print „Abfrage des Außensensors“

dhtreader.init()
MesswerteAussen = dhtreader.read(type, DHTA)

i = 0
while True:
if (MesswerteAussen !=None):
TemperaturAussen = „%.0f“ % MesswerteAussen[0]
LuftfeuchtigkeitAussen = „%.0f“ % MesswerteAussen[1]
break
else:
i += 1

if (i == 5):
TemperaturAussen = 0
LuftfeuchtigkeitAussen = 0
break
time.sleep(2)

print „Abfrage des Innensensors“

dhtreader.init()
MesswerteInnen = dhtreader.read(type, DHTI)

i = 0
while True:
if (MesswerteInnen !=None):
TemperaturInnen = „%.0f“ % MesswerteInnen[0]
LuftfeuchtigkeitInnen = „%.0f“ % MesswerteInnen[1]
break
else:
i += 1

if (i == 5):
TemperaturInnen = 0
LuftfeuchtigkeitInnen = 0
break
time.sleep(2)

print „Abfrage des Sensors am Ausgang“

dhtreader.init()
MesswerteAusgang = dhtreader.read(type, DHTA1)

i = 0
while True:
if (MesswerteAusgang !=None):
TemperaturAusgang = „%.0f“ % MesswerteAusgang[0]
FeuchteAusgang = „%.0f“ % MesswerteAusgang[1]
break
else:
i += 1

if (i == 5):
TemperaturAusgang = 0
FeuchteAusgang = 0
break
time.sleep(2)

print „Abfrage des Sensors am Eingang“

dhtreader.init()
MesswerteEingang = dhtreader.read(type, DHTI1)

i = 0
while True:
if (MesswerteEingang !=None):
TemperaturEingang = „%.0f“ % MesswerteEingang[0]
FeuchteEingang = „%.0f“ % MesswerteEingang[1]
break
else:
i += 1

if (i == 5):
TemperaturEingang = 0
FeuchteEingang = 0
break
time.sleep(2)

getDHTData()

print „Temperatur Aussen: “ + str(TemperaturAussen) + „C“
print „Relative Luftfeuchtigkeit Aussen: “ + str(LuftfeuchtigkeitAussen) + „%“
print „Temperatur Innen: “ + str(TemperaturInnen) + „C“
print „Relative Luftfeuchtigkeit Innen: “ + str(LuftfeuchtigkeitInnen) + „%“
print „Temperatur Ausgang: “ + str(TemperaturAusgang) + „C“
print „Relative Luftfeuchtigkeit Ausgang: “ + str(FeuchteAusgang) + „%“
print „Temperatur Eingang: “ + str(TemperaturEingang) + „C“
print „Relative Luftfeuchtigkeit Eingang: “ + str(FeuchteEingang) + „%“
# Berechnung der Absolutfeuchtewerte
AfA=round(13.233*(float(LuftfeuchtigkeitAussen))*((10**((7.5*(float(TemperaturAussen)))/(237+(float(TemperaturAussen)))))/(273.16+(float(TemperaturAussen)))),2)
AfI=round(13.233*(float(LuftfeuchtigkeitInnen))*((10**((7.5*(float(TemperaturInnen)))/(237+(float(TemperaturInnen)))))/(273.16+(float(TemperaturInnen)))),2)

print „Aussen: Absolute Feuchte in g Wasserdampf pro m3 Luft:“ + str(AfA)

print „Innen: Absolute Feuchte in g Wasserdampf pro m3 Luft:“ + str(AfI)
test=1
if (AfA<=AfI)and AfA!=0 and AfI!=0:
# PIN-Nummern verwenden (nicht GPIO-Nummern)
GPIO.setmode(GPIO.BOARD)
# PIN 24 (=GPIO 8) (CE0) zur Datenausgabe verwenden
# grüne LED leuchtet 4 Sekunden wenn Messung okay
GPIO.setup(24, GPIO.OUT)
# PIN 24 einschalten
GPIO.output(24, GPIO.HIGH)
# nach 4 Sekunden wieder ausschalten
time.sleep(4)
GPIO.output(24, GPIO.LOW)
# alle vom Script benutzen GPIOs wieder freigeben
GPIO.cleanup()

# Relais einschalten mit einem 0.3 Sekunden-Impuls
if (AfA<=AfI)and AfA!=0 and AfI!=0:
# PIN-Nummern verwenden (nicht GPIO-Nummern)
GPIO.setmode(GPIO.BOARD)
# alt:PIN 11 (=BCM-GPIO17, P0) zur Datenausgabe verwenden weisses Kabel Relais zieht an
# neu wg lcd:PIN 13 (=BCM-GPIO22, P02) zur Datenausgabe verwenden weisses Kabel Relais zieht an
GPIO.setup(13, GPIO.OUT)
# PIN 11 einschalten
print „Relais zieht jetzt an“
time.sleep(1)
GPIO.output(13, GPIO.HIGH)
# nach 0.3 Sekunden wieder ausschalten
time.sleep(0.3)
GPIO.output(13, GPIO.LOW)
# alle vom Script benutzen GPIOs wieder freigeben
GPIO.cleanup()

if (AfA>=AfI)and AfA!=0 and AfI!=0:
# falls es außen feuchter ist als innen und die Messung gültig ist:
# PIN-Nummern verwenden (nicht GPIO-Nummern)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)
print „Es ist außen zu feucht, das Relais wird den Lüfter jetzt ausschalten“
time.sleep(2)
# PIN 12 (=BCM-GPIO18, P1) einschalten gelbes Kabel Relais fällt ab
GPIO.output(12, GPIO.HIGH)
# nach 0.3 Sekunden wieder ausschalten
time.sleep(0.3)
GPIO.output(12, GPIO.LOW)
time.sleep(0.5)
# alle vom Script benutzen GPIOs wieder freigeben
GPIO.cleanup()

if AfA==0 or AfI==0:
# falls die Messung fehlschlug:
# PIN-Nummern verwenden (nicht GPIO-Nummern)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)
print „Messung fehlgeschlagen, das Relais wird den Lüfter jetzt ausschalten“
time.sleep(1)
# PIN 12 (=P1) einschalten gelbes Kabel Relais fällt ab
GPIO.output(12, GPIO.HIGH)
# nach 0,3 Sekunden wieder ausschalten
time.sleep(0.3)
GPIO.output(12, GPIO.LOW)
time.sleep(1)
# alle vom Script benutzen GPIOs wieder freigeben
GPIO.cleanup()

time.sleep(4)
print „Der Abfragedurchlauf ist beendet“

# Wenn Messung ungültig blinkt die rote LED 3 mal
if AfA==0 or AfI==0:
# PIN-Nummern verwenden (nicht GPIO-Nummern)
GPIO.setmode(GPIO.BOARD)
# PIN 26 (=BCM GPIO 7, CE1) zur Datenausgabe verwenden
print „Eine ungültige Messung, rote LED blinkt gleich 3 mal“
time.sleep(1)
GPIO.setup(26, GPIO.OUT)
GPIO.output(26, GPIO.HIGH)
time.sleep(0.2)
GPIO.output(26, GPIO.LOW)
time.sleep(0.2)
GPIO.output(26, GPIO.HIGH)
time.sleep(0.2)
GPIO.output(26, GPIO.LOW)
time.sleep(0.2)
GPIO.output(26, GPIO.HIGH)
time.sleep(0.2)
GPIO.output(26, GPIO.LOW)
time.sleep(0.2)
# alle vom Script benutzen GPIOs wieder freigeben
GPIO.cleanup()

LCDAFA=AfA
LCDAFI=AfI

# Umweg, um eine Integer-Zahl zu erhalten, die nach Teilen durch 100 in Excel wieder eine Dezimalzahl mit zwei Nachkommastellen werden kann
AfA=(int(AfA*100))
AfI=(int(AfI*100))
# Ausgabe semikolonsepariert in Datei falls beide Sensoren gemessen haben:
if AfA!=0 and AfI!=0:
import csv
csv.register_dialect(„logluft“, delimiter=“;“)

Datum = time.strftime(„%d.%m.%Y__%H.%M“)
writer = csv.writer(open(„Logdatei_Lueftersteuerung.csv“, „ab“), dialect=“logluft“)
# writer.writerow([])
daten = (
[Datum, TemperaturAussen, LuftfeuchtigkeitAussen, AfA, TemperaturInnen, LuftfeuchtigkeitInnen, AfI, TemperaturEingang, FeuchteEingang, TemperaturAusgang, FeuchteAusgang],
)
writer.writerows(daten)

# „Datum“, „Aussentemperatur“, „Aussen rel. Luftfeuchtigkeit“, „Aussen absolute Feuchte“, „Innen Temperatur“, „Innen Luftfeuchtigkeit“, „Innen absolute Feuchte“
# Programm ausführbar machen mit: chmod a+x lueftersteuerung.py
# Programmaufruf mit root-Rechten wegen GPIO: sudo ./lueftersteuerung.py

# LCD aktivieren

import time
import RPi.GPIO as GPIO

# GPIO <-> HD44780 LCD ZUORDNUNG
DISPLAY_RS = 2
DISPLAY_E = 3
DISPLAY_DATA4 = 4
DISPLAY_DATA5 = 14
DISPLAY_DATA6 = 15
DISPLAY_DATA7 = 17
DISPLAY_LIGHT = 10

# HD44780 HARDWARE-FACTS
DISPLAY_WIDTH = 16
DISPLAY_LINE_1 = 0x80
DISPLAY_LINE_2 = 0xC0
DISPLAY_CHR = True
DISPLAY_CMD = False
E_PULSE = 0.00005
E_DELAY = 0.00005

# GPIO INIT
GPIO.setmode(GPIO.BCM) # Verwenden der BCM GPIO Zahlen
GPIO.setwarnings(False)
GPIO.setup(DISPLAY_E, GPIO.OUT)
GPIO.setup(DISPLAY_RS, GPIO.OUT)
GPIO.setup(DISPLAY_DATA4, GPIO.OUT)
GPIO.setup(DISPLAY_DATA5, GPIO.OUT)
GPIO.setup(DISPLAY_DATA6, GPIO.OUT)
GPIO.setup(DISPLAY_DATA7, GPIO.OUT)
GPIO.setup(DISPLAY_LIGHT, GPIO.OUT)

# HD44780 senden
def lcd_byte(bits, mode):
GPIO.output(DISPLAY_RS, mode)
GPIO.output(DISPLAY_DATA4, False)
GPIO.output(DISPLAY_DATA5, False)
GPIO.output(DISPLAY_DATA6, False)
GPIO.output(DISPLAY_DATA7, False)
if bits&0x10==0x10:
GPIO.output(DISPLAY_DATA4, True)
if bits&0x20==0x20:
GPIO.output(DISPLAY_DATA5, True)
if bits&0x40==0x40:
GPIO.output(DISPLAY_DATA6, True)
if bits&0x80==0x80:
GPIO.output(DISPLAY_DATA7, True)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_E, True)
time.sleep(E_PULSE)
GPIO.output(DISPLAY_E, False)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_DATA4, False)
GPIO.output(DISPLAY_DATA5, False)
GPIO.output(DISPLAY_DATA6, False)
GPIO.output(DISPLAY_DATA7, False)
if bits&0x01==0x01:
GPIO.output(DISPLAY_DATA4, True)
if bits&0x02==0x02:
GPIO.output(DISPLAY_DATA5, True)
if bits&0x04==0x04:
GPIO.output(DISPLAY_DATA6, True)
if bits&0x08==0x08:
GPIO.output(DISPLAY_DATA7, True)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_E, True)
time.sleep(E_PULSE)
GPIO.output(DISPLAY_E, False)
time.sleep(E_DELAY)

# HD44780 Zeile schreiben
def lcd(zeile,text):
if zeile == 1:
lcd_byte(DISPLAY_LINE_1, DISPLAY_CMD)
if zeile == 2:
lcd_byte(DISPLAY_LINE_2, DISPLAY_CMD)

message = text.ljust(DISPLAY_WIDTH,“ „)
for i in range(DISPLAY_WIDTH):
lcd_byte(ord(message[i]),DISPLAY_CHR)

# HD44780 initialisiserung und loeschen
def lcd_init():
lcd_byte(0x33,DISPLAY_CMD)
lcd_byte(0x32,DISPLAY_CMD)
lcd_byte(0x28,DISPLAY_CMD)

lcd_byte(0x0C,DISPLAY_CMD)
lcd_byte(0x06,DISPLAY_CMD)
lcd_byte(0x01,DISPLAY_CMD)

# HD44780 Hintergrundbeleuchtung ein oder aus
def lcd_backlight(what):
GPIO.output(DISPLAY_LIGHT, what)

GRAD=“T“
PROZ=“% “
GR=“g “

lcd_init()

lcd(1,“A “ + (str(LCDAFA)) + str(GR)+ (str(LuftfeuchtigkeitAussen)) + str(PROZ)+ (str(TemperaturAussen))+ str(GRAD) )
lcd(2,“I “ + (str(LCDAFI))+ str(GR) + (str(LuftfeuchtigkeitInnen))+ str(PROZ) + (str(TemperaturInnen))+ str(GRAD) )
lcd_backlight(True)

time.sleep(10)

#test ob Displaymeldung für aussen feuchter als innen funzt
#AfA=AfA + 500

if (AfA>=AfI)and AfA!=0 and AfI!=0:
# falls es außen feuchter ist als innen und die Messung gültig ist:

# GPIO INIT
GPIO.setmode(GPIO.BCM) # Verwenden der BCM GPIO Zahlen
GPIO.setwarnings(False)
GPIO.setup(DISPLAY_E, GPIO.OUT)
GPIO.setup(DISPLAY_RS, GPIO.OUT)
GPIO.setup(DISPLAY_DATA4, GPIO.OUT)
GPIO.setup(DISPLAY_DATA5, GPIO.OUT)
GPIO.setup(DISPLAY_DATA6, GPIO.OUT)
GPIO.setup(DISPLAY_DATA7, GPIO.OUT)
GPIO.setup(DISPLAY_LIGHT, GPIO.OUT)
# HD44780 senden
def lcd_byte(bits, mode):
GPIO.output(DISPLAY_RS, mode)
GPIO.output(DISPLAY_DATA4, False)
GPIO.output(DISPLAY_DATA5, False)
GPIO.output(DISPLAY_DATA6, False)
GPIO.output(DISPLAY_DATA7, False)
if bits&0x10==0x10:
GPIO.output(DISPLAY_DATA4, True)
if bits&0x20==0x20:
GPIO.output(DISPLAY_DATA5, True)
if bits&0x40==0x40:
GPIO.output(DISPLAY_DATA6, True)
if bits&0x80==0x80:
GPIO.output(DISPLAY_DATA7, True)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_E, True)
time.sleep(E_PULSE)
GPIO.output(DISPLAY_E, False)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_DATA4, False)
GPIO.output(DISPLAY_DATA5, False)
GPIO.output(DISPLAY_DATA6, False)
GPIO.output(DISPLAY_DATA7, False)
if bits&0x01==0x01:
GPIO.output(DISPLAY_DATA4, True)
if bits&0x02==0x02:
GPIO.output(DISPLAY_DATA5, True)
if bits&0x04==0x04:
GPIO.output(DISPLAY_DATA6, True)
if bits&0x08==0x08:
GPIO.output(DISPLAY_DATA7, True)
time.sleep(E_DELAY)
GPIO.output(DISPLAY_E, True)
time.sleep(E_PULSE)
GPIO.output(DISPLAY_E, False)
time.sleep(E_DELAY)

# HD44780 Zeile schreiben
def lcd(zeile,text):
if zeile == 1:
lcd_byte(DISPLAY_LINE_1, DISPLAY_CMD)
if zeile == 2:
lcd_byte(DISPLAY_LINE_2, DISPLAY_CMD)

message = text.ljust(DISPLAY_WIDTH,“ „)
for i in range(DISPLAY_WIDTH):
lcd_byte(ord(message[i]),DISPLAY_CHR)

# HD44780 initialisiserung und loeschen
def lcd_init():
lcd_byte(0x33,DISPLAY_CMD)
lcd_byte(0x32,DISPLAY_CMD)
lcd_byte(0x28,DISPLAY_CMD)
lcd_byte(0x0C,DISPLAY_CMD)
lcd_byte(0x06,DISPLAY_CMD)
lcd_byte(0x01,DISPLAY_CMD)

# HD44780 Hintergrundbeleuchtung ein oder aus
def lcd_backlight(what):
GPIO.output(DISPLAY_LIGHT, what)
Zeile1=“s ist aussen“
Zeile2=“u feucht!“

lcd_init()
lcd(1,“E“ + str(Zeile1))
lcd(2,“z“ + str(Zeile2))
lcd_backlight(True)

 

 

Im Terminal stellt sich der Programmablauf dann so dar:

Start der Messung!
Abfrage des Außensensors
Abfrage des Innensensors
Abfrage des Sensors am Ausgang
Abfrage des Sensors am Eingang
Temperatur Aussen: 23C
Relative Luftfeuchtigkeit Aussen: 61%
Temperatur Innen: 23C
Relative Luftfeuchtigkeit Innen: 61%
Temperatur Ausgang: 23C
Relative Luftfeuchtigkeit Ausgang: 62%
Temperatur Eingang: 0C
Relative Luftfeuchtigkeit Eingang: 0%
Aussen: Absolute Feuchte in g Wasserdampf pro m3 Luft:12.56
Innen: Absolute Feuchte in g Wasserdampf pro m3 Luft:12.56
Relais zieht jetzt an
Es ist außen zu feucht, das Relais wird den Lüfter jetzt ausschalten
Der Abfragedurchlauf ist beendet