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

 

 

 

Ein Gedanke zu “3. Die Steuerung

  1. gibt es denn anhand der vielen möglichen daten auch fertige messungen während der funktion , sprich wirkungsgrad und funktion der gesamten apperatur ?

    Liken

Ich freue mich über Kommentare und Anregungen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden /  Ändern )

Google Foto

Du kommentierst mit Deinem Google-Konto. Abmelden /  Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden /  Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden /  Ändern )

Verbinde mit %s