Helios KWL (easycontrols) über modbus tcp einbinden

**uli** · 31.08.2015, 13:59

Ich wollte nun auch mal Feedback geben. Das Programm läuft auf Anhieb einwandfrei und macht genau was es soll!!

Vielen Dank für Deine Mühe, damit spart man sich die KNX-Schnittstelle. Ich nehme mal an, das ist auch ein Grund, warum es Helios dem Anwender schwer macht, anstatt die Standards so einfach wie möglich umzusetzen.

Das einzige, was das Programm bei mir nicht macht, ist die aktuelle Lüfterstufe bei den Radiotasten nach einem Miniserver-Neustart anzuzeigen. Kann man das irgendwie bewerkstelligen?

**Gast** · 20.10.2015, 11:34

Hallo Jan,

ich bin auch gerade dabei meine KWL500 per Modbus auszulesen bzw. zu steuern.
Aktuell noch mit nem Linux Rechner, aber ich habe auch angedacht, dies dann in die Loxone zu integrieren.
Leider habe ich bis jetzt noch keine Aktivitäten in Richtung Loxone unternommen....
Jetzt wurde ich auf deinen Beitrag hingewiesen....
...gute Arbeit! :-)

Besteht die Möglichkeit, dass du mir das Programm einmal zukommen lässt?

Vielen Dank.

Gruß
Christian

**Fuxi** · 20.10.2015, 20:54

JAN:

Danke für dieses tolle Programm !!
So etwas habe ich immer gesucht !
Funktioniert auf Anhieb einwandfrei !!

**Jan W.** · 21.10.2015, 00:25

Danke. Hab jetzt das Skript in die Loxwiki portiert: http://www.loxwiki.eu/pages/viewpage...pageId=1639038
Der Inhalt (Stand Okt. 2015) ist der gleiche wie oben.

**Gast** · 21.10.2015, 07:28

Topp!
Vielen Dank.

**Jan W.** · 03.01.2016, 17:38

Ich habe das Programm verbessert (Version 3):

- auslesen der aktuellen Lüfterstufe bei Start des Skriptes
- schreiben der Lüfterstufe nur, wenn in Loxone geändert wurde, sonst auslesen
(erlaubt paralleles Ändern der Lüfterstufe im easycontrols webinterface)

Link ist unten.

Gruß Jan

**uli** · 03.01.2016, 18:35

Hallo Jan,

gleich mal ausprobiert und läuft einwandfrei. Super Arbeit!

Ich hatte mir mit der alten Version eine Stoßlüften-Funktion gebastelt (siehe unten). Das geht nun mit der Version 3 nicht mehr, da ja die Lüftungsstufe wieder über den Merker mit einfliest und somit auch geändert wird. Hat jemand eine Idee wie man das umsetzen könnte?

VG

**Frank71** · 03.01.2016, 22:14

Hallo Jan,

ich hab mir auch eine Helios geleistet und gleich mal dein Programm verwendet. Danke nochmal.

Hier ist meine Version mit Automatikbetrieb und manueller Lüftereinstellung. Hiermit ist auch eine Stoßlüftung möglich.

Vieleicht kannst du aus beiden eine neue Version 4 machen ;-)

// Helios KWL mit easyControls über Modbus TCP steuern v2.0
// by jan punkt wachsmuth at web.de, Feedback gerne erwünscht.
//
//INPUTS
//AI1 .... Betriebsart
//AI2 .... Lüfterstufe
//
//OUTPUTS
//AQ1 .... Temperatur Aussenluft
//AQ2 .... Temperatur Zuluft
//AQ3 .... Temperatur Fortluft
//AQ4 .... Temperatur Abluft
//AQ5 .... Ventilator Zuluft (rpm)
//AQ6 .... Ventilator Abluft (rpm)
//AQ7 .... Bypass aktiv
//AQ8 .... Anzahl Fehler
//AQ9 .... Anzahl Warnungen
//A10 .... Anzahl Infos
//A11 .... Luefertestufe
//A12 .... Betriebsart
//TQ1 .... Artikelbezeichnung

//CONSTANTS
// Disable/enable debug mode (writes log messages)
#define DEBUG_MODE 1

//VARIABLES
char* answer;
float tempAussenluft = 0.0;
float tempZuluft = 0.0;
float tempFortluft = 0.0;
float tempAbluft = 0.0;
float rpmZuluft = 0.0;
float rpmAbluft = 0.0;
float bypass = 0.0;
float anzahlFehler = 0.0;
float anzahlWarnungen = 0.0;
float anzahlInfo = 0.0;
char artikelBez[32];
int betriebsart = 0;
int luefterStufe = 0;

// Modbus TCP header
char modbusTCP[30];

char tIDl,tIDh;
char szBuffer[100];
int nLen;
int err;
int zaehler;

printf("Helios KWL Modbus TCP start");

// modbusTCP Header vorbereiten und konstante Werte eintragen
tIDl=0;
tIDh=0;
// Protocol Identifier - 2 Byte Zahl, immer 0
modbusTCP[2]=0;
modbusTCP[3]=0;
// Length - 2 Byte Zahl - Länge des nachfolgenden Datenpaketes insgesamt
modbusTCP[4]=0;
modbusTCP[5]=0;
// Unit Identifier - immer 180 für Helios KWL
modbusTCP[6]=180;
// reference number - Zweck unklar
modbusTCP[8]=0;
modbusTCP[9]=1;
// Word count - Anzahl der zu schreibenden Worte (16 Bit)
modbusTCP[10]=0;

int modbusTCPwriteVar(char* heliosVar)
{
int wordLen;
int nLen;

// Anfrage mit modbusTCP Header erstellen (variabler Anteil)

// Transaction Identifier - 2 Byte Zahl, die mit jeder Anfrage hochzählt
modbusTCP[0] = tIDh;
modbusTCP[1] = tIDl;
tIDl++;
if (tIDl == 256) {
tIDl = 0;
tIDh++;
if (tIDh == 256)
tIDh = 0;
}
// Function Code
modbusTCP[7] = 16; // Write Multiple Registers (16)
// Word count - Anzahl der zu schreibenden Worte (16 Bit)
// inkl. 0-Byte am Ende (+1), aufrunden (+1)
nLen = strlen(heliosVar);
wordLen = (nLen + 2) >> 1;
nLen = wordLen << 1;
// Length - 2 Byte Zahl - Länge des nachfolgenden Datenpaketes insgesamt
modbusTCP[5] = 7 + nLen;
// Anzahl der zu schreibenden Register (a 16 Bit)
modbusTCP[11] = wordLen;
// Byte count - Anzahl der nachfolgenden Bytes
modbusTCP[12] = nLen;
strncpy(&modbusTCP[13], heliosVar, nLen);

// Header und Daten an Helios senden
stream_write(stream, modbusTCP, 13 + nLen);
stream_flush(stream);

// TCP Datenpaket empfangen, max. 500 msec auf Antwort warten
nLen = stream_read(stream, szBuffer, sizeof(szBuffer) - 1, 500);
if (nLen == 0) {
printf("modbusTCP request for %s failed (0 bytes read) !", heliosVar);
return 1;
} else {
// weitere Überprüfung der Antwort fehlt - Werte ähnlich wie in der Anfrage
// es wird angenommen, dass die Antwort passt
return 0;
}
}

char* modbusTCPreadVar(char* heliosVar, int len)
{
// "countWords" Worte (a 16-Bit) aus Holding Register auslesen
// TCP Anfrage mit modbusTCP Header erstellen

// Transaction Identifier - 2 Byte Zahl, die mit jeder Anfrage hochzählt
modbusTCP[0] = tIDh;
modbusTCP[1] = tIDl;
tIDl++;
if (tIDl == 256) {
tIDl = 0;
tIDh++;
if (tIDh == 256)
tIDh = 0;
}
// Length - 2 Byte Zahl - Länge des nachfolgenden Datenpaketes insgesamt
modbusTCP[5] = 6;
// Function Code
modbusTCP[7] = 3; // Read Holding Registers (3)
// Word count - Anzahl der zu lesenden Worte (16 Bit), muss < 256 sein!
// Variable=6 Byte, "="=1 Byte, Wert=len Byte, 0-Byte am Ende (+1), aufrunden (+1)
modbusTCP[11] = (9 + len) >> 1;
// TCP Datenpaket mit modbus Header senden
stream_write(stream, modbusTCP, 12);
stream_flush(stream);

// TCP Datenpaket empfangen, max. 500 msec auf Antwort warten
nLen = stream_read(stream, szBuffer, sizeof(szBuffer) - 1, 500);

// Länge der Antwort prüfen (mind v0XXXX=y\0)
if (nLen>16) {
// Variable auslesen und überprüfen, immer 6 Bytes lang "v0XXXX"
if (strncmp(heliosVar, &szBuffer[9], 6) == 0) {
return &szBuffer[16];
} else {
szBuffer[15]=0;
printf("modbusTCP variable %s is not %s !", heliosVar, &szBuffer[9]);
return NULL;
}
} else {
printf("modbusTCP answer too short, only %i Bytes, <%s>", nLen, &szBuffer[9]);
return NULL;
}
}

float heliosReadFloat(char* heliosVar, int len)
{
int err;
char* answer;
float floatValue;
// 1. Teil: String für Variable schreiben
err = modbusTCPwriteVar(heliosVar);
if (err)
return -999;

// 2. Teil: Antwort aus Holding Register auslesen
answer = modbusTCPreadVar(heliosVar, len);
if (answer != NULL) {
floatValue = atof(answer);
if (DEBUG_MODE)
printf("modbusTCP READ %s = %f", heliosVar, floatValue);
return floatValue;
}
return -999;
}

void heliosReadString(char* heliosVar, char* heliosString, int len)
{
int err;
char* answer;
// 1. Teil: String für Variable schreiben
err = modbusTCPwriteVar(heliosVar);
if (err) {
strcpy(heliosString, "Error!");
return;
}

// 2. Teil: Antwort aus Holding Register auslesen
answer = modbusTCPreadVar(heliosVar, len);
if (answer != NULL) {
strcpy(heliosString, answer);
if (DEBUG_MODE)
printf("modbusTCP READ %s = %s", heliosVar, heliosString);
} else {
strcpy(heliosString, "Error!");
}
}

void heliosWriteInt(char* heliosVar, int value)
{
char heliosString[20];

sprintf(heliosString,"%s=%d", heliosVar, value);
if (DEBUG_MODE)
printf("modbusTCP WRITE %s = %d", heliosVar, value);

modbusTCPwriteVar(heliosString);
}

while(TRUE)
{
// Stream zur IP-Adresse der Helios KWL (Modbus TCP Gegenstelle)
STREAM* stream = stream_create("/dev/tcp/192.168.0.120/502", 1, 0);

if (stream != NULL)
{

// Betriebsart w�hlen 0 = Automat. 1 = Handbetrieb
// Betriebsart schreiben
betriebsart=(int)getinput(0);

if(betriebsart<0)
betriebsart=0;
if(betriebsart>1)
betriebsart=1;

heliosWriteInt("v00101", betriebsart);
sleep(100);

if(betriebsart==1)
{
// Luefterstufe setzen
luefterStufe = (int)getinput(1);
if(luefterStufe<0) luefterStufe=0;
heliosWriteInt("v00102", luefterStufe);
printf("Lüfterstufe manuell schreiben %f",luefterStufe);
sleep(100);
}
else {
printf("Lüfterstufe in Automatik ");
}

// Betriebsart auslesen, char[1]
anzahlInfo = heliosReadFloat("v00101", 1);
setoutput(11, anzahlInfo);
sleep(100);

// Luefterstufe auslesen, char[1]
anzahlInfo = heliosReadFloat("v00102", 1);
setoutput(10, anzahlInfo);
sleep(100);

// Temperatur Aussenluft auslesen, char[7]
tempAussenluft = heliosReadFloat("v00104", 7);
setoutput(0, tempAussenluft);
sleep(100);

// Temperatur Zuluft auslesen, char[7]
tempZuluft = heliosReadFloat("v00105", 7);
setoutput(1, tempZuluft);
sleep(100);

// Temperatur Fortluft auslesen, char[7]
tempFortluft = heliosReadFloat("v00106", 7);
setoutput(2, tempFortluft);
sleep(100);

// Temperatur Abluft auslesen, char[7]
tempAbluft = heliosReadFloat("v00107", 7);
setoutput(3, tempAbluft);
sleep(100);

// Drehzahl Zuluft (rpm) auslesen, char[4]
rpmZuluft = heliosReadFloat("v00348", 4);
setoutput(4, rpmZuluft);
sleep(100);

// Drehzahl Abluft (rpm) auslesen, char[4]
rpmAbluft = heliosReadFloat("v00349", 4);
setoutput(5, rpmAbluft);
sleep(100);

// Bypass auslesen, char[1], undokumentiert!
bypass = heliosReadFloat("v02119", 1);
setoutput(6, bypass);
sleep(100);

// AnzahlFehler auslesen, char[2]
anzahlFehler = heliosReadFloat("v01300", 2);
setoutput(7, anzahlFehler);
sleep(100);

// AnzahlWarnungen auslesen, char[1]
anzahlWarnungen = heliosReadFloat("v01301", 1);
setoutput(8, anzahlWarnungen);
sleep(100);

// AnzahlInfo auslesen, char[1]
anzahlInfo = heliosReadFloat("v01302", 1);
setoutput(9, anzahlInfo);
sleep(100);

// Artikelbezeichnung auslesen, char[31]
heliosReadString("v00000", artikelBez, 31);
setoutputtext(0, artikelBez);
sleep(100);

} else {
printf("Unable to create TCP stream");
sleeps(9);
}
stream_close(stream);
sleeps(1);
}

**Jan W.** · 03.01.2016, 23:55

Hallo Uli,

da Du wahrscheinlich nicht der Einzige bist, der eine Funktion Stoßlüften (vergleichbar mit Partybetrieb) haben möchtest, habe ich die Funktion noch eingebaut und in Loxwiki als Version 4 hochgeladen. Im Beispiel nur mit einem einfachen Taster zum An- bzw. Abschalten, aber der kann ja je nach Geschmack durch einen Treppenlichtschalter bzw. einem Baustein Ausschaltverzögerung angepasst werden. Mit einem virtuellem analogen Eingang (Eingabetyp Schieber) kann man leicht die "original" Partyfunktion für x Stunden / Minuten nachbilden.

Während der Funktion Stoßlüften/Partybetrieb können die Werte nicht über ein externes Interface z.B. easycontrols geändert werden, sondern es wird fest die Stufe 4 (Maximalwert) geschrieben. Im Normalbetrieb ist ein paralleler Betrieb möglich, allerdings sollte die Automatik in easycontrols abgeschaltet werden.

Gruß Jan

**uli** · 05.01.2016, 14:42

Getestet und für gut befunden

Dankeschön euch beiden...

**LoxFFB** · 21.05.2016, 13:07

Super Programm

wie macht ihr die ansteuerung von der bypass klappe?

**Jan W.** · 21.05.2016, 14:42

Bisher noch gar nicht, d.h. es läuft bei mir noch die automatische Aktivierung durch die Anlage selbst. Ist aber für den Sommer noch geplant, wenn ich zeitlich dazu komme.

Die Steuerung des Bypass solle möglich sein, allerdings weiß ich nicht, ob das direkt über ein Register geht oder nur indirekt über Bypass Tag/Monat und Außenluft / Ablufttemperatur. Wenn es direkt geht, dann müsste man ja das interne "Berechnungsverfahren" über die genannte Parameter irgendwie abschalten können. Dazu habe ich nichts gefunden.

Indirekte Konfiguration: Man könnte z.B. für Abluft mind. 22 Grad, Außenluft nicht kälter als 5 Grad einstellen, was den Bypass aktivieren sollte. Tagsüber, wenn es draußen ganz heiß ist, dann könnte man die Abluft auf mind. 30 Grad einstellen, was den Bypass schließen dürfte. Damit würde die wärmere Außenluft sogar durch die kühlere Abluft etwas heruntergekühlt werden. Man soll wohl dann noch einen Stopfen entfernen (siehe Anleitung für die Anlage). Alternativ kann man ja auch die Stufe tagsüber deutlich heruntersetzen oder ausschalten.

Alternativ könnte man noch die "Funktion 6" für den externen Kontakt wählen und diesen über Loxone steuern. Das soll wohl die eingebaute Bypass-Steuerung abschalten und durch den externen Kontakt ersetzen.

Habe alles noch nicht ausprobiert, aber der Sommer kommt ja noch. Im letzten Sommer habe ich an einigen Tagen/Nächten manuell die Stufe verstellt, um die Innentemperatur etwas herunterzukühlen, allerdings ein Problem mit der Lautstärke gehabt. Dann habe ich die passive Kühlung unserer Wärmepumpe aktiviert und auf diese Weise die Innentemperatur reduziert.

Nach meiner Ansicht gibt es ein "Konstruktionsproblem" mit der Helios Anlage: Mit installiertem Pollenfilter im Bypass (nur dann!) und einer Anlage mit konstanter Luftstrommenge, z.B. dem Modell KWL 370 erhöht sich die Drehzahl der Lüfter deutlich. Bei uns hat man dann im Schlafzimmer die Anlage dann deutlich gehört. Hatte letztes Jahr deswegen beim Support von Helios angerufen, aber die haben mich nur auf die Firma verwiesen, die die Installation gemacht hat. Die meine, dass ich die Stufe dann reduzieren sollte. Na toll. Dummerweise war bei uns der Weg von der Anlage zum Schlafzimmer recht kurz, so dass es nur da zu hören war.

Letztendlich habe ich das Problem dadurch gelöst, dass ich sowohl vor als auch hinter die Anlage eine Box für Industriefilter eingebaut habe und dadurch einen wesentlich höheren Querschnitt im Filter habe. Einen weiteren Schalldämpfer habe ich auch noch mit eingebaut. Nun ist es deutlich leiser durch reduzierte Drehzahlen bei gleicher Lüftungsleistung. Hier habe ich die Teile bestellt:
- G4 Filter vor der Anlage, G7 Filter danach, Ersatzfilter 287x287mm kosten z.B. bei filter-mueller.de weniger als 15 Euro
- Filterboxen gibt es z.B. bei gastroplus24.de für gut 100 Euro

Der Einbau war auch nicht so schwierig. Falls jemand ebenfalls das gleiche Problem hat: die Lösung mit den Filterboxen ist super und man spart dadurch auch noch Geld bei den Filtern ein. Das hätte die Firma mal gleich so bauen sollen! Ich kann jedem nur empfehlen, solche Filter gleich von Anfang an einzubauen bzw. einbauen zu lassen.

Gruß Jan

**Frank71** · 21.05.2016, 14:55

Zitat von Jan W.

Indirekte Konfiguration: Man könnte z.B. für Abluft mind. 22 Grad, Außenluft nicht kälter als 5 Grad einstellen, was den Bypass aktivieren sollte.
Gruß Jan

Hallo Jan,

könntest du mir bitte die Einstellung erklären wie Helios die Berechnung bzw. Status
mit "Raum-/Ablufttemperatur in °C:" und "Min. Außenlufttemperatur in °C:" durchführt?
Ich bin daraus noch nicht schlau geworden und finde nirgends eine Erklärung.

Danke und Gruß Frank

**Jan W.** · 21.05.2016, 15:20

Hier https://www.heliosventilatoren.de/mb...82208_0514.pdf ist die Berechnung auf Seite 9 erläutert.

Kurz gesagt geht der Bypass auf, wenn
- die Außentemperatur niedriger als die Abluft ist (wenn die Außentemperatur höher ist, dann kühlt der Wärmetauscher die Aussenluft etwas herunter - der Bypass ist dann zu)
- die Außentemperatur nicht zu kalt ist - hierfür ist die "min. Außenlufttemperatur" konfigurierbar. Das macht Sinn, denn Nachts bei 5 Grad möchte man keine eiskalte Zugluft haben.
- die Ablufttemperatur einen bestimmten Wert überschreitet - Es soll natürlich nur gekühlt werden, wenn es drinnen "zu warm" ist. Der Wert ist ebenfalls konfigurierbar.

Zusätzlich gibt es noch den Beginn und das Ende (nach Kalender), so dass der Bypass nur "im Sommer" aktiviert wird. Die Tage kann man ebenfalls einstellen.

Wenn Du den Bypass auf jeden Fall aktivieren möchtest, dann könntest Du "Abluft mind. -10 Grad", "Außenluft mind. -20" einstellen. Die von mir im Post #13 genannten Werte sind nicht ganz so krass und waren nur als Beispiel gedacht - i.d.R. sollten sie den Bypass aktivieren. Auch bei Ausfall der Steuerung durch Loxone würde die Lüftungsanlage dann noch sinnvolle Werte haben.

Hoffe, dass war verständlich.

Gruß Jan

Helios KWL (easycontrols) über modbus tcp einbinden

Helios KWL (easycontrols) über modbus tcp einbinden

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar

Kommentar