ComfoAir Steuerung über RS232

[swiss]

Hallo Chris

Sorry für die späte Antwort. Ich war eine Weile nicht mehr hier weil ich komplet in Arbeit versunken bin...

Zu deiner Frage:

"Das Wiregate" ist ein Produkt von ElabNet: http://shop.wiregate.de/wiregate-1.html dabei handelt es sich um ein Multifunktionales Gateway... Das Plugin dass ich mal dafür geschrieben habe kann in der Web Oberfläche des Wiregate einfach eingefügt werden und übernimmt die Kommunikation zwischen der ComfoAir und KNX. Dazu sind auf der ComfoAir seinte ein RS232 Anschluss (direkt oder über USB-Seriell Wandler) und auf der KNX Seite entweder ein TP-UART oder eine KNX IP Schnitstelle/Router.

Je nach dem was du alles von der ComfoAir in KNX integrieren möchtest sit das Wiregate eine der Möglichkeiten. Ist aber nicht ganz günstig... Auch eine möglichkeit ist die neue ComfoAir/KNX Schnittstelle (ComfoWay) dazu ist zusätzlich eine KNXNet IP Schnittstelle nötig und preislich etwas teurer als die Wiregate Lösung. Wenn du nur die Stufen hoch/runter schalten möchtest und auf die Rückmeldungen verzichten kannst geht das natürlich viel günstiger ;-)

[Miki84]

Hallo,

ich stelle mal meine Frage auch mal hier rein...


könnte mir jmd ein Foto von dem Seriellen Anschluss machen.

Bzw. ein Foto oder ne Doku wir ihr das angeschlossen habt?

Wenn ich in meine Anlage reinschaue (kleiner Schlitz ca 1,5cm breit) kann ich nur einen RJ45 Port erkennen.

Muss ich mir da ein RJ45 zu RS232 Kabel basteln?

Danke und Gruß

[Northman]

Hallo Miki,

was für eine Anlage hast Du? Hier geht es primär um die Zehnder ComfoAir 350. Diese hat oben drauf einen Anschlußkasten. Wenn Du den aufschraubst, guckst Du direkt auf den D-SUB-Stecker von oben drauf. Die RJ45-Buchse zeigt nach hinten.
Siehe auch die schematische Darstellung in der Protokollbeschreibung.Seite 2, Konnektorplatine.
An den D-SUB-Stecker kannst Du direkt mit einem seriellen Kabel dran gehen (oder auch einem USB-RS232-Adapter).
Ich habe an ein 4x0,8 Kabel eine D-SUB-Buchsen gelötet und dort aufgesteckt (Kabel geht über Kabelkanäle in den Technikraum). Die andere Seite geht auf besagten Adapter.

[swiss]

Hallo Welche ComfoAir hast du denn genau? Und wo hast du genau geschaut? Bei den luxe Versionen hast du oben zwischen den Rohren einen Kunststoffdeckel den du abschrauben kannst. Darunter befindet sich eine Platine mit diversen Klemmen, einen RJ11 und eine SubD9 port... Hast du mal ein Foto von dem Gerät?

[Miki84]

Hi Danke für eure Antworten.

Es handelt sich um eine 350 L

Im Anhang mal 2 Fotos der ComfoAir.

Gruß

[swiss]

Hallo Miki

Hmmm... Irgendwie scheint das deine 350 L zu sein denn die Luxe Version die ich kenne verfügt über die so genannte Conectorplatione... Die scheint bei dir zu fehlen. Doch wenn es wirklich eine Zender ComfoAir 350 ist, kannst du auch den RJ11 Stecker zur Steuerung verwenden.

[mosjka1]

Tag Leute,

ich möchte endlich auch meine CA350 Luxe an die Wiregate anschließen, habe jedoch ein Verständnisproblem zum Anschluss. Da ich bereits ein CAT7 Kabel von der CA zur CC Ease Steuerung gezogen habe (ca. 15m Leitung), frage ich mich, ob ich parallel zur CC Ease Steuerung den RS232/USB Adapter dran hängen kann und diesen dann an die Wiregate anschließen?

Oder muss der RS232/USB Adapter separat an der RS232 Schnittstelle der CA350 unabhängen von der CC Ease Steuerung angeschlossen werden?

Danke euch!

Hier mein Anschlussbild:
image_44329.jpg

[swiss]

Hallo Du kannst die Leitung der CC EASE verwenden doch empfiekt es sich nicht die EASE paralell zur RS232 Ansteuerung zu betreiben.

[mosjka1]

Hallo Du kannst die Leitung der CC EASE verwenden doch empfiekt es sich nicht die EASE paralell zur RS232 Ansteuerung zu betreiben.

Danke Dir für die Info. Werde ich heute Abend ausprobieren.

Kannst du bitte dein letztes funktionierendes Plugin inkl. der config hier reinstellen? Hier sind mittlerweile soviele Versionen drin...

[Northman]

[...], frage ich mich, ob ich parallel zur CC Ease Steuerung den RS232/USB Adapter dran hängen kann und diesen dann an die Wiregate anschließen?

Du solltest den RS232-Adapter auf keinen Fall parallel anschließen (*). Ich habe mich mittels Arduino Due in die Leitung gehängt (je ein UART zur Anlage und zur CC-Ease) und dann die Daten auf die serielle Schnittstelle zum Computer geschickt. Die CC-Ease plappert... Sie fragt ununterbrochen die CA350 ab. Da fließen die Daten so schnell, daß die CC-Ease teilweise anfängt das nächste Paket zu schicken, während die CA350 noch antwortet. Das hat zur Folge, daß die CC-Ease ihr ACK mitten in ihrem eigenen Datenpaket schickt. Das macht die Auswertung der Pakete nicht einfacher...

(*) Auch elektrisch ist das sicher keine gute Idee.

Das sind die Daten, die ich bis jetzt rausbekomme, ohne selber auch nur ein Kommando zu senden.
NoData bedeutet, daß der entsprechende Buffer noch nicht gefüllt wurde, sprich ein entsprechendes Paket noch nicht empfangen wurde, oder ich das noch nicht dekodiere.

BootloaderVersion: NoData
FirmwareVersion: NoData
ConnectorBoardVersion: NoData
RS232Mode: Mode:CCEaseOnly
Inputs: NoData
VentilatorStatus: NoData
HatchStatus: NoData
TempStatus: NoData
KeyStatus: NoData
AnalogInputs: NoData
Sensordata:  EnthSensT:-20.0 EnthSensH:0 Analog1:0 Analog2:0 Analog3:0 Analog4:0 Analog1in:0 Analog1out:0 Analog2in:0 Analog2out:0 Analog3in:0 Analog3out:0 Analog4in:0 Analog4out:0 EnthCoef:0 EnthTimer:0
AnalogData: NoData
Delays: NoData
VentilatorLevels: Abl:15,35,61,100 Zul:15,35,75,100 Abl:66 Zul:75 Stufe:2 ZulVent:1
Temps: Komf:28.0 Aussen:2.5 Zul:6.5 Abl:18.0 Fol:7.0 EWT:0.0 SAussen:1 SZul:1 SAbl:1 SFol:1 SEWT:0 SNHzg:0 SKueche:0 Nachhzg:0.0 Kueche:0.0
Status: NoData
Errors: NoData
PowerOnHours: NoData
BypassStatus: F:5 L:0 C:5 S:0
PreHeatingStatus: Lid:undef=255 FrostProtectionActive:0 PreHeating:0 FrostMinutes:0 Frostmode:3
RFStatus: NoData
Last8PreHeatings: NoData
OtherHeatings: EWTlowT:-16.5 EWThighT:-8.5 EWTSpeedup:0 KitchenHoodSpeedUp:10 PostHeatingPower:0 PostHeatingPowerI:0 PostHeatingT:-11.0

Um diesen Status (also wirklich den Text da oben) auszugeben, benötigt der Arduino Due nur ca. 80-100msec (115.200 bit/s). Die Codewörter sollen noch kürzer werden und die Daten bekommen noch einen Loglevel. Die ersten vier Zeilen sind z.B. statische Werte und müssen nicht jedes Mail ausgegeben werden.
Das Schicken der Daten auf den KNX-Bus dauert wahrscheinlich länger, als die Abfrage des Arduinos :-)

Das ganze läuft stabil und für die ComfoAir & CC-Ease transparent. Ich kann auch ins Parametermenü der CC-Ease gehen und Einstellungen vornehmen.
Das Ziel ist, auch Kommandos schicken zu können (Stufe, Komforttemp,...). Das geht dann über die serielle Schnittstelle und erfordert nur noch einen Aufruf eines (noch zu erstellenden neuen) WG-Plugins. Das WG-Plugin werde ich erstellen, aber natürlich kann es mit jedem anderem System auch laufen, daß seriell kommunizieren kann.

PS: Bitte nicht fragen, warum die Abluft nur 18°C haben soll. Im Haus ist es definitiv wärmer.
PPS: Bitte keine Anfragen nach einem Termin :-)

[mfd]

PPS: Bitte keine Anfragen nach einem Termin :-)

Dann möchte ich an der Stelle zumindest meine Freude zum Ausdruck bringen, dass ich jemand in dieser Richtung mit der CA350 beschäftigt...
Eine transparente Kommunikation mit CC Ease und WG wäre sicher eine feine Sache.

[mosjka1]

Welches ist nun die neueste Version von dem Plugin? Kann die jemand bitte hier inkl. der config posten?

[Northman]

Das ist die Version, die bei mir läuft. Da sind kleine Änderungen im Vergleich zur 1.6.8 drin:

• Cycle in der Conf
• Etwas anderes Logging: einiges dazu, einiges weniger (leere "reciv-direkt:"-Zeilen, wenn keine Daten da sind)

# Plugin zur Ansteuerung einer Zender ComfoAir
# Version 1.6.8 28.05.2014 BETA
# Copyright: swiss (https://knx-user-forum.de/members/swiss.html)
# Aufbau moeglichst so, dass man unterhalb der Einstellungen nichts veraendern muss!
# - Neu mit der Moeglichkeit zur Anbindung über einen Moxa NPort von Fechter65 (https://knx-user-forum.de/members/fechter65.html)
# - Neustrukturierung des Codes von Fechter65 (https://knx-user-forum.de/members/fechter65.html)
# - Besseres Fehlerhandling bei der Verarbeitung der Reuckmeldungen von swiss (https://knx-user-forum.de/members/swiss.html)
# - Neu nun mit direktem abfragen der Stufe nach dem setzen und auswerten der Komforttemperatur von swiss (https://knx-user-forum.de/members/swiss.html)
# - Neu mit der Möglichkeit die Ventilationsstufe direkt zu setzen von swiss (https://knx-user-forum.de/members/swiss.html)
# - Neu mit der Möglichkeit die Ventilatorstufe für Zuluft und Abluft getrennt zu setzen (0% - 100%) von Netsrac80 (https://knx-user-forum.de/members/netsrac80.html)
# - Korrektur Stufe direkt setzen. Senden / empfangen hat nun das gleiche Mapping 1=Auto, 2=Sufe1, 3=Stufe2, 4=Stufe3
# - Neu mit Rückmeldung auf Lesetelegramme

 
####################
###Einstellungen:###
####################

#BITTE ab sofort die Einstellungen unter conf.d vornemen. Damit bleiben die Einstellungen auch bei einem Update erhalten.
 

######################
##ENDE Einstellungen##
######################


#Ab hier nichts mehr aendern.
#Hauptverarbeitung


#Erzeuge Variablen fuer die Zuordnung der Steuerfunktionen zu den Gruppenadressen:
my $ga_stufeabwesend = ''; #1bit Trigger fuer Stufe "Abwesend". 1=Aktivieren
my $ga_stufe1 = ''; #1bit Trigger fuer Stufe1. 1=Aktivieren
my $ga_stufe2 = ''; #1bit Trigger fuer Stufe2. 1=Aktivieren
my $ga_stufe3 = ''; #1bit Trigger fuer Stufe3. 1=Aktivieren
my $ga_stufe_setzen = ''; # GA DPT 5.005 zum direkten setzen der Stufe (1=Abwesend, 2=Stufe1, 3=Stufe2, 4=Stufe3)
my $ga_komforttemp = ''; #GA DPT 9.001 zum setzen der Komforttemperatur
my $ga_drehzahl_ventilator_zul = ''; #GA DPT 5.001 zum setzen der Zuluftdrehzahl
my $ga_drehzahl_ventilator_abl = ''; #GA DPT 5.001 zum setzen der Abluftdrehzahl
my $ga_reset_filter = ''; #1bit Trigger fuer das Zuruecksetzen des Betriebsstundenzaehlers des Filters. 1=Reset
my $ga_reset_error = ''; #1bit Trigger fuer das zuruecksetzen der KWL nach einem Fehler. 1=Reset
 

#Hier werden die Gruppenadressen fuer die Rueckmeldungen vergeben: (Nich vergeben = inaktiv)
my $ga_status_ventilator_zul = ''; #GA DPT 5.001 fuer Status Ventilator Zuluft %
my $ga_status_ventilator_abl = ''; #GA DPT 5.001 fuer Status Ventilator Abluft %
my $ga_status_bypass_prozent = ''; #GA DPT 5.001 fuer Status Bypassklappe %
my $ga_betriebsstunden_filter = ''; #GA DPT 16.000 fuer die Rueckmeldung der Betribsstunden des Filters
my $ga_zustand_badschalter = ''; #GA DPT 1.001 fuer die Rueckmeldung des Zustandes des Badezimmerschalters
my $ga_fehler_filter = ''; #GA DPT 1.001 fuer den Zustand des Filters. 0=OK, 1=Filter Voll
my $ga_fehlercode = ''; #GA DPT 16.000 fuer die Ausgabe des Fehlercodes als Text
my $ga_aktstufe = ''; #GA DPT 5.005 liefert den Wert für die aktuelle Stufe (1=A, 2=Stufe1, 3=Stufe2, 4=Stufe3)
 
#Hier werden die Gruppenadressen für die Rückmeldung der Temperaturen vergeben: (Nicht vergeben=inaktiv)
my $ga_aul_temp = ''; #GA DPT 9.001 für die Aussenlufttemperatur
my $ga_zul_temp = ''; #GA DPT 9.001 für die Zulufttemperatur
my $ga_abl_temp = ''; #GA DPT 9.001 für die Ablufttemperatur
my $ga_fol_temp = ''; #GA DPT 9.001 für die Fortlufttemperatur
my $ga_komfort_temp = ''; #GA DPT 9.001 für die Komforttemperatur
 
#Zuordnung der Namen fuer die RRD's:
my $Name_rrd_AUL = 'KWL_Aussenluft'; #Name RRD Aussenluft
my $Name_rrd_ZUL = 'KWL_Zuluft'; #Name RRD Zuluft
my $Name_rrd_ABL = 'KWL_Abluft'; #Name RRD Abluft
my $Name_rrd_FOL = 'KWL_Fortluft'; #Name RRD Fortluft
 
#Pfad zur seriellen Schnittstelle oder dem USB-Seriell-Wandler:
my $schnittstelle = '/dev/ttyUSB-2-4';
 

#Angaben für die Kommunikation über den UDP-Port einer MOXA [diese Einstellungen reichen aus, d.h. auf dem Wiregate muss unter "Seriell/LAN/Socketverbindungen" KEINE Socketverbindung erstellt werden
my $socknum = ""; # Eindeutige Nummer des Sockets
my $send_ip = ""; # SendeIP (UDP)
my $send_port = ""; # Sendeport (UDP)   
my $recv_ip = ""; # EmpfangsIP (UDP)
my $recv_port = ""; # Empfangsport (UDP)
 

# Kommunikationsart
my $Kom_Art = "S"; # "S" = seriell; "M" = Moxa
 

# Dauer einer Abfrage
my $Zaehler = "2500"; #Mit dieser Variable Zaehler wird beeinflusst, wie lange das Plugin auf den Abschluss einer Rückmeldung der KWL wartet; empfohlener Wert für seriell: 2500; für Moxa: 250
 
# Debug level 0 = nur die wichtigsten Infos, 1 = Alle Zustaende, 2 = Rohdaten (nur für Fehlersuche)
my $debug=0;

 
#Weitere Variablen die benoetigt werden -> NICHT veraendern!
my $seriel;
my $sin; #Serial Input = Empangener Datenstrom
my $cin; #Counter Input =  Länge des Datenpackets
my $laenge; #Länge des empfangenen Datenstrings nach dem kürzen
 
my $checksum = 0; #Checksumme
my @hex; #Hilfsarray für die Checksummenberechnung
my $x07warschon; #Hilfsvariable für die Checksummenberechnung
my $cycle = 150;

&readConf(); #conf.d einlesen
if($debug>=1){plugin_log($plugname,'Start')};
 
my $return_value2;
my $daten;
my $reciv;
my $reciv_all;
my $ack = pack("H*","07F3");
my $rcv_checksum;
 
# Zyklischer Aufruf nach restart, empfang GA oder 1/2 der einstellung rrd (typisch 150sek).
$plugin_info{$plugname.'_cycle'}  = $cycle;

use Device::SerialPort;
use Time::Local;

 
#Einrichten der Seriellen Schnittstelle fuer die Kommunikation mit der ComfoAir falls die Schnittstelle auf "S" steht
if ($Kom_Art eq "S"){
             $seriel = Device::SerialPort->new($schnittstelle) || die "Kann $schnittstelle nicht öffnen! ($!)\n";
             $seriel->baudrate(9600);
             $seriel->parity("none");
             $seriel->databits(8);
             $seriel->stopbits(1);
             if($debug>=1){plugin_log($plugname,'Schnittstelle: ' . $schnittstelle . ' erfolgreich geöffnet')};
}elsif ($Kom_Art eq "M"){
    if (!$socket[$socknum]) { # socket erstellen
            $socket[$socknum] = IO::Socket::INET->new(LocalPort => $recv_port,
                                      Proto => "udp",
                                      LocalAddr => $recv_ip,
                                      PeerPort  => $send_port,
                                      PeerAddr  => $send_ip,
                                      ReuseAddr => 1
                                       )
        or return ("open of $recv_ip : $recv_port failed: $!");
        $socksel->add($socket[$socknum]); # add socket to select
        $plugin_socket_subscribe{$socket[$socknum]} = $plugname; # Plugin an Socket "anmelden"
        if($debug>=1){plugin_log($plugname,'Socket: ' . $socknum . ' erfolgreich geöffnet')};
        return "opened Socket $socknum";
    }
}


###############################################################################################
###############################################################################################
## Ab hier werden die Befehle die vom KNX kommen für die ComfoAir uebersetzt und gesendet... ##
###############################################################################################
###############################################################################################
 
 if ($msg{'apci'} eq "A_GroupValue_Read"){
    if ($msg{'dst'} eq $ga_aktstufe){
            $daten = "00CD00";
            if($debug>=1){plugin_log($plugname,'Ventilationsstufe abrufen');}
            $return_value2 = command_senden($daten);        
    }elsif($msg{'dst'} eq $ga_status_bypass_prozent){
            $daten = "000D00";
            if($debug>=1){plugin_log($plugname,'Bypass Zustand abrufen');}
            $return_value2 = command_senden($daten);
    }elsif($msg{'dst'} eq $ga_status_ventilator_zul or $msg{'dst'} eq $ga_status_ventilator_abl){
            $daten = "000B00";
            if($debug>=1){plugin_log($plugname,'Ventilator Status abrufen');}
            $return_value2 = command_senden($daten);
    }elsif($msg{'dst'} eq $ga_aul_temp or $msg{'dst'} eq $ga_zul_temp or $msg{'dst'} eq $ga_abl_temp or $msg{'dst'} eq $ga_fol_temp or $msg{'dst'} eq $ga_komfort_temp){
            $daten = "00D100";
            plugin_log($plugname,'Temperatur abrufen');
            $return_value2 = command_senden($daten);
    }
}elsif ($msg{'apci'} eq "A_GroupValue_Write"){
    if ($msg{'dst'} eq $ga_stufeabwesend && knx_read($msg{'dst'},0,1) == 1) {
        $daten = "00990101";
        plugin_log($plugname,'Stufe abwesend setzen');
        $return_value2 = command_senden($daten);
            if($ga_aktstufe){ #Nur wenn die GA vergeben ist, die Ventilationsstufe abfragen
                $daten = "00CD00";
                if($debug>=1){plugin_log($plugname,'Ventilationsstufe abrufen');}
                $return_value2 = command_senden($daten);
            }
    }elsif ($msg{'dst'} eq $ga_stufe1 && knx_read($msg{'dst'},0,1) == 1) {
        $daten = "00990102";
        plugin_log($plugname,'Stufe 1 setzen');
        $return_value2 = command_senden($daten);
            if($ga_aktstufe){ #Nur wenn die GA vergeben ist, die Ventilationsstufe abfragen
                $daten = "00CD00";
                if($debug>=1){plugin_log($plugname,'Ventilationsstufe abrufen');}
                $return_value2 = command_senden($daten);
            }
    }elsif ($msg{'dst'} eq $ga_stufe2 && knx_read($msg{'dst'},0,1) == 1) {
        $daten = "00990103";
        plugin_log($plugname,'Stufe 2 setzen');
        $return_value2 = command_senden($daten);
            if($ga_aktstufe){ #Nur wenn die GA vergeben ist, die Ventilationsstufe abfragen
                $daten = "00CD00";
                if($debug>=1){plugin_log($plugname,'Ventilationsstufe abrufen');}
                $return_value2 = command_senden($daten);
            }
    }elsif ($msg{'dst'} eq $ga_stufe3 && knx_read($msg{'dst'},0,1) == 1) {
        $daten = "00990104";
        plugin_log($plugname,'Stufe 3 setzen');
        $return_value2 = command_senden($daten);
            if($ga_aktstufe){ #Nur wenn die GA vergeben ist, die Ventilationsstufe abfragen
                $daten = "00CD00";
                if($debug>=1){plugin_log($plugname,'Ventilationsstufe abrufen');}
                $return_value2 = command_senden($daten);
            }
    }elsif ($msg{'dst'} eq $ga_stufe_setzen) {
        my $stufenwert = knx_read($msg{'dst'},0,5.005);
        $daten = "0099010" . $stufenwert;
        plugin_log($plugname,'Stufe direkt setzen auf: ' . $stufenwert);
        $return_value2 = command_senden($daten);
            if($ga_aktstufe){ #Nur wenn die GA vergeben ist, die Ventilationsstufe abfragen
                $daten = "00CD00";
                if($debug>=1){plugin_log($plugname,'Ventilationsstufe abrufen');}
                $return_value2 = command_senden($daten);
            }
    }elsif ($msg{'dst'} eq $ga_komforttemp) {
        my $komforttemp = knx_read($msg{'dst'},0,9.001);
        plugin_log($plugname,'Komforttemp auf: ' . $komforttemp . '°C setzen');
        my $temphex = ($komforttemp + 20)*2; #Rechne die Temperatur fuer die ComfoAir um
        $temphex = sprintf "%x" , $temphex; # Mache aus Integer HEX
        $daten = "00D301" . $temphex;
        $return_value2 = command_senden($daten);
    }elsif ($msg{'dst'} eq $ga_reset_filter && knx_read($msg{'dst'},0,1) == 1) {
        $daten = "00DB0400000001";
        knx_write($ga_fehler_filter,0,1);
        plugin_log($plugname,'Filter zuruecksetzen');
        $return_value2 = command_senden($daten);
    }elsif ($msg{'dst'} eq $ga_reset_error && knx_read($msg{'dst'},0,1) == 1) {
        $daten = "00DB0401000000";
        plugin_log($plugname,'Fehler zuruecksetzen');
        $return_value2 = command_senden($daten);
    }elsif ($msg{'dst'} eq $ga_drehzahl_ventilator_zul) {
        my $drehzahl_zul = knx_read($msg{'dst'},0,5.001);
        plugin_log($plugname,'Drehzahl Zuluftluefter auf: ' . $drehzahl_zul . '% setzen');
        $plugin_info{$plugname."_zuluftdrehzahl_1"} = $drehzahl_zul;
       
        my $temp_abluftdrehzahl = sprintf "%x",$plugin_info{$plugname."_abluftdrehzahl_1"};
        my $hex_zuluftdrehzahl = sprintf "%x" , $drehzahl_zul; # Mache aus Integer HEX
        $daten = "00CF090F" . $temp_abluftdrehzahl.'0F0F'. $hex_zuluftdrehzahl.'0F0F0F0F';
        $return_value2 = command_senden($daten);
    }elsif ($msg{'dst'} eq $ga_drehzahl_ventilator_abl) {
        my $drehzahl_abl = knx_read($msg{'dst'},0,5.001);
        plugin_log($plugname,'Drehzahl Abluftluefter auf: ' . $drehzahl_abl . '% setzen');
        $plugin_info{$plugname."_abluftdrehzahl_1"} = $drehzahl_abl;
        
        my $temp_zuluftdrehzahl = sprintf "%x",$plugin_info{$plugname."_zuluftdrehzahl_1"};
        my $hex_abluftdrehzahl = sprintf "%x" , $drehzahl_abl; # Mache aus Integer HEX
        $daten = "00CF090F" . $hex_abluftdrehzahl.'0F0F'. $temp_zuluftdrehzahl.'0F0F0F0F';
        $return_value2 = command_senden($daten);
        if($debug>=2){plugin_log($plugname,'Drehzahl Abluftlüfter DATEN: ' . $daten . ' mit '. $drehzahl_abl. ' setzen! Antwort:'.$return_value2); }
    }
    if($debug>=1){plugin_log($plugname,'ENDE Aufruf durch GA');}
    return;
            
} else { # zyklischer Aufruf
    if(($plugin_info{$plugname.'_time'}+$plugin_info{$plugname.'_cycle'} ) > $plugin_info{$plugname.'_last'}){
        #plugin_log($plugname,'Time + Cycle >= Last');
        my $datestring = $plugin_info{$plugname.'_time'};
        #plugin_log($plugname,"DateString Time : $datestring");
        my $datestring = $plugin_info{$plugname.'_cycle'};
        #plugin_log($plugname,"DateString Cycle: $datestring");
        my $datestring = $plugin_info{$plugname.'_last'};
        #plugin_log($plugname,"DateString Last : $datestring");
        
        return;
        
    }
    $plugin_info{$plugname.'_time'} = time();
   
    # Plugin an Gruppenadresse "anmelden", hierdurch wird das Plugin im folgenden bei jedem eintreffen eines Telegramms auf die GA aufgerufen und der obere Teil dieser if-Schleife durchlaufen
    $plugin_subscribe{$ga_stufeabwesend}{$plugname} = 1;
    $plugin_subscribe{$ga_stufe1}{$plugname} = 1;
    $plugin_subscribe{$ga_stufe2}{$plugname} = 1;
    $plugin_subscribe{$ga_stufe3}{$plugname} = 1;
    $plugin_subscribe{$ga_stufe_setzen}{$plugname} = 1;
    $plugin_subscribe{$ga_komforttemp}{$plugname} = 1;
    $plugin_subscribe{$ga_reset_filter}{$plugname} = 1;
    $plugin_subscribe{$ga_reset_error}{$plugname} = 1;
    $plugin_subscribe{$ga_drehzahl_ventilator_zul}{$plugname} = 1;
    $plugin_subscribe{$ga_drehzahl_ventilator_abl}{$plugname} = 1;
    
    $plugin_subscribe{$ga_aktstufe}{$plugname} = 1;
    $plugin_subscribe{$ga_status_bypass_prozent}{$plugname} = 1;
    $plugin_subscribe{$ga_status_ventilator_zul}{$plugname} = 1;
    $plugin_subscribe{$ga_status_ventilator_abl}{$plugname} = 1;
    $plugin_subscribe{$ga_aul_temp}{$plugname} = 1;
    $plugin_subscribe{$ga_zul_temp}{$plugname} = 1;
    $plugin_subscribe{$ga_abl_temp}{$plugname} = 1;
    $plugin_subscribe{$ga_fol_temp}{$plugname} = 1;
    $plugin_subscribe{$ga_komfort_temp}{$plugname} = 1;
   

####################################################################################################
####################################################################################################
## Ab hier werden zyklisch diverse Werte von der ComfoAir abgefragt und an das KNX uebertragen... ##
####################################################################################################
####################################################################################################

 
    $daten = "00D100";
    plugin_log($plugname,'Temperatur abrufen');
    $return_value2 = command_senden($daten);
   
    if($ga_status_ventilator_zul && $ga_status_ventilator_abl){ #Nur wenn beide GA's vergeben sind, dann die Zustaende der Ventilatoren abfragen
        $daten = "000B00";
        if($debug>=1){plugin_log($plugname,'Ventilator Status abrufen');}
        $return_value2 = command_senden($daten);
    }
            
    if($ga_status_bypass_prozent){ #Nur wenn die GA vergeben ist, dann Zustand Bypassklappe abfragen
        $daten = "000D00";
        if($debug>=1){plugin_log($plugname,'Bypass Zustand abrufen');}
        $return_value2 = command_senden($daten);
    }
            
    if($ga_betriebsstunden_filter){ #Nur wenn die GA vergeben ist, die Betriebsstunden des Filters abfragen
        $daten = "00DD00";
        if($debug>=1){plugin_log($plugname,'Betriebsstunden Filter abrufen');}
        $return_value2 = command_senden($daten);
    }
            
    if($ga_zustand_badschalter){ #Nur wenn die GA vergeben ist, die Binaereingaenge abfragen
        $daten = "000300";
        if($debug>=1){plugin_log($plugname,'Binäreingänge abrufen');}
        $return_value2 = command_senden($daten);
    }
            
    if($ga_aktstufe){ #Nur wenn die GA vergeben ist, die Ventilationsstufe abfragen
        $daten = "00CD00";
        if($debug>=1){plugin_log($plugname,'Ventilationsstufe abrufen');}
        $return_value2 = command_senden($daten);
    }
            
    if($ga_fehlercode){ #Nur wenn die GA vergeben ist, werden hier die Stoermeldungen abgefragt
        $daten = "00D900";
        if($debug>=1){plugin_log($plugname,'Störungen abrufen');}
        $return_value2 = command_senden($daten);
    }

    if($debug>=2){plugin_log($plugname,'ENDE Zyklische Abfrage');}
    return;
}
 
 
# Ab hier wird das Datenpaket inklusive Checksumme zusammengestellt und an die ComfoAir uebertragen
sub command_senden{
    my $data = $_[0];
    if($debug>=2){plugin_log($plugname,'data: ' . $data);}
    $checksum = checksum_berechnen($data);
    if($debug>=2){plugin_log($plugname,'Checksumme aus der Subroutine: '.$checksum);}
    my $command = pack("H*","07F0" . $data . $checksum . "070F");
    my $commandhex = $command;
   
    $commandhex =~ s/(.)/sprintf("0x%x ",ord($1))/eg;
    if($debug>=2){plugin_log($plugname,'transmit: ' . $commandhex);} #Zeigt im Pluginlog das fertige Datenpaket, dass uebertragen wird
             if ($Kom_Art eq "S"){   
                             $seriel->write($command); #Befehl an die ComfoAir senden
             } elsif ($Kom_Art eq "M"){   
                             $plugin_info{$plugname.'_debug'} = $command;
                             syswrite($socket[$socknum], $command);
             }
    $reciv = '';
    $cin = '';
    $sin = '';
       
    $|=1;
    my $exit=0;
    while($exit < $Zaehler)
    {
        if ($Kom_Art eq "S"){
             ($cin, $sin) = $seriel->read(45);
        }elsif ($Kom_Art eq "M"){
                                 $sin ='';
                                 if ($fh) { # Antwort auslesen
                                                recv($fh,$sin,80,0);
                                 }
                                 $cin = length($sin);
        }
        if($cin > 0){
            $sin = unpack "H*", $sin;
            $reciv .= $sin;
            $exit=0;
        }else{
            $exit++
        }
       
        if($debug>=2  && $sin){plugin_log($plugname,'reciv-direkt:     ' . $sin);}
    
            if($reciv =~ /070f/i){
                if (substr($reciv,(length($reciv)-6),6) ne '07070f'){            
                    last;
                }
            }
    }#Ende While  

    if ($Kom_Art eq "S"){
        $seriel->write($ack); #ACK senden
        if($debug>=2){plugin_log($plugname,'ACK senden');}
    } elsif ($Kom_Art eq "M"){
        syswrite($socket[$socknum], $ack); #ACK senden
        if($debug>=2){plugin_log($plugname,'ACK senden');}
    }

    if($reciv eq ""){
        if($debug>=2){plugin_log($plugname,'FEHLER: Keine Daten empfangen!');}
        return;
    }
   
    while ((length($reciv) > 3) && (substr($reciv,(length($reciv)-4),4) ne '070f')) #solange das Ende nicht 070f lautet
    {
                    if($debug>=2){plugin_log($plugname,'String vor Kuerzung Ende: '.$reciv);}
                    $reciv = substr($reciv,0,-2); #String um die letzten zwei Zeichen kürzen
                    if($debug>=2){plugin_log($plugname,'String nach Kuerzung Ende: '.$reciv);}
    }  
   
 
        #Hier wird der empfangene String um Start- und Endbyte gekürzt
        $laenge = length($reciv); #Laenge des Antworttelegramms ermitteln
        $reciv = substr($reciv,0,($laenge-4)); #Entferne 07f0 vom Ende
       
        if(substr($reciv,(length($reciv)-4),4) eq '07f3'){
            $reciv = substr($reciv,0,($laenge-4));
            if($debug>=2){plugin_log($plugname,'String ohne 07f3: '.$reciv);}
        }

        if($debug>=2){plugin_log($plugname,'Erste 4 Byte des Datenpakets: '.(substr($reciv,0,4)));}

                                           
        while ((length($reciv) > 3) && (substr($reciv,0,4)) ne '07f0'){
            $reciv = substr($reciv,2); #falls noch falsche Zeichen am Anfang des Strings enthalten sind, werden diese hier entfernt.
            if($debug>=2){plugin_log($plugname,'reciv gekuerzt: '.$reciv);}
        }
       
        $reciv = substr($reciv,4);
        if($debug>=2){plugin_log($plugname,'String ohne 07f0 am Anfang: '.$reciv);}
       
        #Test einer Methode falls aussversehen mehrere Datenpakete auf einmal im Datenstring enthalten sind...
        if($reciv =~ /07f307f0/i){
            my @dataarray=split(/07f307f0/,$reciv);
            $reciv = $dataarray[0];
        }

                            
        #Nun wird die Checksumme gelesen und aus dem Datenstring entfernt
        $checksum = 0;
        $checksum = substr($reciv,-2,2);
        if($debug>=2){plugin_log($plugname,'Checksumme gelesen: '.$checksum);}
        $laenge = length($reciv); #Laenge des Antworttelegramms ermitteln
        $reciv = substr($reciv,0,($laenge-2));
        if($debug>=2){plugin_log($plugname,'Datenpaket ohne Checksumme: '.$reciv);}

        #Hier wird die Subroutine für die Berechnung der Checksumme aufgerufen und das Ergebnis in $rcv_checksum zurück gegeben
        $rcv_checksum = checksum_berechnen($reciv);

        
#######################################################################
#######################################################################
## Ab hier werden die Rueckmeldungen von der ComfoAir ausgewertet... ##
#######################################################################
#######################################################################


        if($rcv_checksum eq $checksum){ #Hier wird geprüft ob die Checksumme korrekt ist
            if($debug>=2){plugin_log($plugname,'Checksumme OK ');}
            
            #Hier werden die doppelten 07 aus dem Antwortstring entfernt.
            if($debug>=2){plugin_log($plugname,'String vor 07 bereinigung:  '.$reciv);}
            while ($reciv =~ s/0707/07/) {}
            if($debug>=2){plugin_log($plugname,'String nach 07 bereinigung: '.$reciv);}
            
            if($reciv =~ /00D209/i){ #Wenn die Temperaturen empfangen wurden
                my $t1 = substr($reciv,6,2);
                my $t2 = substr($reciv,8,2);
                my $t3 = substr($reciv,10,2);
                my $t4 = substr($reciv,12,2);
                my $t5 = substr($reciv,14,2);
                                                                          
                #Hier werden die Temperaturen "decodiert" damit sie einen Sinn ergeben
                $t1 =  (hex($t1)/2)-20;
                $t2 =  (hex($t2)/2)-20;
                $t3 =  (hex($t3)/2)-20;
                $t4 =  (hex($t4)/2)-20;
                $t5 =  (hex($t5)/2)-20;

                #Wenn die GA's vergeben wurde, die Temperaturen auf die GA's senden
                if($ga_komfort_temp ne ''){knx_write($ga_komfort_temp,$t1,9.001);}
                if($ga_aul_temp ne ''){knx_write($ga_aul_temp,$t2,9.001);}
                if($ga_zul_temp ne ''){knx_write($ga_zul_temp,$t3,9.001);}
                if($ga_abl_temp ne ''){knx_write($ga_abl_temp,$t4,9.001);}
                if($ga_fol_temp ne ''){knx_write($ga_fol_temp,$t5,9.001);}
               
                #Ab hier werden die RRD's mit den aktuellen Temperaturen aktualisiert:
                update_rrd($Name_rrd_AUL,"",$t2);
                update_rrd($Name_rrd_ZUL,"",$t3);
                update_rrd($Name_rrd_ABL,"",$t4);
                update_rrd($Name_rrd_FOL,"",$t5);
               
                plugin_log($plugname,'Temperaturen: AUL: ' . $t2 . '°C, ZUL:' . $t3 . '°C, ABL: ' . $t4 . '°C, FOL: ' . $t5 . '°C, Komforttemp: ' . $t1 . '°C');

            }elsif($reciv =~ /000C06/i){ #Wenn der Status fuer die Ventilatoren empfangen wurden
                my $vent_zul = substr($reciv,6,2);
                my $vent_abl = substr($reciv,8,2);
                plugin_log($plugname,'Ventilatoren: ZUL: ' . hex($vent_zul) . '% ABL: ' . hex($vent_abl) . '%');
                knx_write($ga_status_ventilator_zul,hex($vent_zul),5.001);
                knx_write($ga_status_ventilator_abl,hex($vent_abl),5.001);   
               
            }elsif($reciv =~ /00CE0E/i){ #Wenn der Status der Ventilatorenstufe empfangen wurden
                my $akt_stufe = substr($reciv,22,2);
                if(hex($akt_stufe) == 1){
                    plugin_log($plugname,'AKT_STUFE: A');
                }else{
                    plugin_log($plugname,'AKT_STUFE: ' . (hex($akt_stufe)-1));
                }
                knx_write($ga_aktstufe,hex($akt_stufe),5.005);                                                                               

            }elsif($reciv =~ /000E04/i){ #Wenn der Status fuer die Bypassklappe empfangen wurden
                my $bypass_prozent = substr($reciv,6,2);
                plugin_log($plugname,'Bypass: ' . hex($bypass_prozent) . '%');               
                knx_write($ga_status_bypass_prozent,hex($bypass_prozent),5.001);

            }elsif($reciv =~ /00DE14/i){ #Wenn die Rueckmeldung der Betriebsstunden des Filters empfangen wurden
                my $betriebsstunden_filter = substr($reciv,36,4);
                if($debug>=3){plugin_log($plugname,'Betriebsstunden Filter Roh: '.$betriebsstunden_filter);}
                plugin_log($plugname,'Betriebsstunden Filter: ' . hex($betriebsstunden_filter) . 'h');                
                knx_write($ga_betriebsstunden_filter,hex($betriebsstunden_filter) . 'h',16.000);
               
            }elsif($reciv =~ /000402/i){ #Wenn die Rueckmeldung der Binaereingaenge empfangen wurden
                my $zustand_badschalter = substr($reciv,8,1);
                plugin_log($plugname,'Zustand Badezimmerschalter: ' . $zustand_badschalter);                
                knx_write($ga_zustand_badschalter,$zustand_badschalter,1.001);
               
            }elsif($reciv =~ /00DA11/i){ #Wenn die Rueckmeldung der Stoermeldungen empfangen wurden
                my $fehlerAlo = substr($reciv,6,2);
                my $fehlerAhi = substr($reciv,30,2);
                my $fehlerE = substr($reciv,8,2);
                my $fehlerFilter = substr($reciv,22,2);
                my $fehlerEA = substr($reciv,24,2);
               
                my $numAlo = 'A';
                my $numAhi = 'A';
                my $numE = 'A';
                my $numEA = 'A';
               
                $numAlo .= unpack("B*",pack("H*",$fehlerAlo));
                $numAhi .= unpack("B*",pack("H*",$fehlerAhi));
                $numE .= unpack("B*",pack("H*",$fehlerE));
                $numEA .= unpack("B*",pack("H*",$fehlerEA));
               
               
                $fehlerAlo = reverse($numAlo); #Wandle den Wert in Binaer und drehe die Reihenfolge um. z.B 0x02 = 00000010 = 010000000
                $fehlerAlo = index($fehlerAlo,'1')+1; # Zaehle an welcher Stelle die 1 auftaucht (von links gelesen) z.B. 01000000 = INDEX 2 = Fehler2
               
                if($fehlerAhi ne '00'){
                    $fehlerAhi = index(reverse($numAhi),'1')+9;
                }else{
                    $fehlerAhi = '';
                }
               
                $fehlerE = index(reverse($numE),'1')+1;
                $fehlerEA = index(reverse($numEA),'1')+1;
                                                                           
                if($fehlerAhi == 16){$fehlerAhi = 0;}
                                                                           
                if($ga_fehlercode){ #Wenn die GA fuer das uebertragen den Fehlercodes eingertagen wurde, ab hier auswerten
                    if($fehlerAlo > 0){
                        plugin_log($plugname,'Aktueller Fehlercode: A' . $fehlerAlo);
                        knx_write($ga_fehlercode,'A' . $fehlerAlo,16.001);
                    }elsif($fehlerAhi ne ''){
                        plugin_log($plugname,'Aktueller Fehlercode: A' . $fehlerAhi);
                        knx_write($ga_fehlercode,'A' . $fehlerAhi,16.001);                       
                    }elsif($fehlerE > 0){
                        plugin_log($plugname,'Aktueller Fehlercode: E' . $fehlerE);
                        knx_write($ga_fehlercode,'E' . $fehlerE,16.001);
                    }elsif($fehlerEA > 0){
                        plugin_log($plugname,'Aktueller Fehlercode: EA' . $fehlerEA);
                        knx_write($ga_fehlercode,'EA' . $fehlerEA,16.001);
                    }else{
                        plugin_log($plugname,'Aktueller Fehlercode: keiner' );
                        knx_write($ga_fehlercode,'---',16.001);
                    }   
                }
               
                if(hex($fehlerFilter) > 0){
                    plugin_log($plugname,'Aktueller Fehler: Filter Voll');
                    knx_write($ga_fehler_filter,1,1);
                }else{
                    knx_write($ga_fehler_filter,0,1);
                }              
            }
        }else{
            if($debug>=2){plugin_log($plugname,'Checksumme fehlerhaft! Gelesen: '.$checksum.' Berechnet: '.$rcv_checksum);}
        }
} #ENDE Sub command_senden

sub checksum_berechnen {   
    my $chk_datasum = $_[0];
    $rcv_checksum = 0;
    my $i;
     $chk_datasum = $chk_datasum . "AD"; #+173 fuer die Checksummenberechnung
        if($debug>=2){plugin_log($plugname,'String für die Berechnung der Checksumme: '.$chk_datasum);}
    $x07warschon = 0;
    $laenge = length($chk_datasum);
        for($i = 0; $i< $laenge; $i++) {
            my $wertstring = substr($chk_datasum,$i,2);
            if($debug>=3){plugin_log($plugname,'Zahl: '.$wertstring);}
            my $wertbetrag = hex($wertstring);
            if ($wertbetrag == 7) {
                if ($x07warschon == 1) {
                    $x07warschon = 0;
                    $i++;
                    next;
                } else {
                    $x07warschon = 1;
                }
            }
        $rcv_checksum += $wertbetrag;
            if($debug>=3){plugin_log($plugname,'Summe: '.$rcv_checksum);}
        $i++;
    }
            if($debug>=3){plugin_log($plugname,'Summe def: '.$rcv_checksum);}

    if($debug>=2){plugin_log($plugname,'Checksumme vor der Umwandlung: '.$rcv_checksum);}
    $rcv_checksum = sprintf "%x\n" , $rcv_checksum; #Mache aus Integer wieder HEX
    if($debug>=2){plugin_log($plugname,'Checksumme vor der Kürzung: '.$rcv_checksum);}
    $rcv_checksum = substr($rcv_checksum,-3,2); #Verwende nur die letzten beiden Stellen
    if($debug>=2){plugin_log($plugname,'Checksumme nach der Kürzung: '.$rcv_checksum);}
    return $rcv_checksum;
} #Ende checksum_berechnen

 

sub readConf
{
    my $confFile = '/etc/wiregate/plugin/generic/conf.d/'.basename($plugname,'.pl').'.conf';
    if (! -f $confFile)
    {
        plugin_log($plugname, " no conf file [$confFile] found!");
    }
    else
    {
        if($debug>=1){plugin_log($plugname, " reading conf file [$confFile].");}
        open(CONF, $confFile);
        my @lines = <CONF>;
        close($confFile);
        my $result = eval("@lines");
#        ($result) and plugin_log($plugname, "conf file [$confFile] returned result[$result]");
        if ($@)
        {
            if($debug>=2){plugin_log($plugname, " conf file [$confFile] returned:");}
            my @parts = split(/\n/, $@);
            if($debug>=2){plugin_log($plugname, " --> $_") foreach (@parts);}
        }
    }
} # readConf

ComfoAir.conf

####################
###Einstellungen:###
####################

# Debug level 0 = nur die wichtigsten Infos, 1 = Alle Zustaende, 2 = Rohdaten (nur für Fehlersuche)
$debug=0;
$cycle = 60;


#Erzeuge Variablen fuer die Zuordnung der Steuerfunktionen zu den Gruppenadressen:
$ga_stufeabwesend             = '14/1/0' ; #1bit Trigger fuer Stufe "Abwesend". 1=Aktivieren
$ga_stufe1                     = '14/1/1' ; #1bit Trigger fuer Stufe1. 1=Aktivieren
$ga_stufe2                     = '14/1/2' ; #1bit Trigger fuer Stufe2. 1=Aktivieren
$ga_stufe3                     = '14/1/3' ; #1bit Trigger fuer Stufe3. 1=Aktivieren
$ga_stufe_setzen             = '14/1/19'; # GA DPT 5.005 zum direkten setzen der Stufe (1=Abwesend, 2=Stufe1, 3=Stufe2, 4=Stufe3)
$ga_komforttemp             = '14/1/5' ; #GA DPT 9.001 zum setzen der Komforttemperatur
$ga_drehzahl_ventilator_zul    = '14/1/20'; #GA DPT 5.001 zum setzen der Zuluftdrehzahl
$ga_drehzahl_ventilator_abl    = '14/1/21'; #GA DPT 5.001 zum setzen der Abluftdrehzahl
$ga_reset_filter             = '14/1/17'; #1bit Trigger fuer das Zuruecksetzen des Betriebsstundenzaehlers des Filters. 1=Reset
$ga_reset_error             = '14/1/18'; #1bit Trigger fuer das zuruecksetzen der KWL nach einem Fehler. 1=Reset
 

#Hier werden die Gruppenadressen fuer die Rueckmeldungen vergeben: (Nich vergeben = inaktiv)
$ga_status_ventilator_zul     = '14/1/10'; #GA DPT5.001 fuer Status Ventilator Zuluft %
$ga_status_ventilator_abl     = '14/1/11'; #GA DPT5.001 fuer Status Ventilator Abluft %
$ga_status_bypass_prozent     = '14/1/12'; #GA DPT5.001 fuer Status Bypassklappe %
$ga_betriebsstunden_filter     = '14/1/13'; #GA DPT16.000 fuer die Rueckmeldung der Betribsstunden des Filters
$ga_zustand_badschalter     = '14/1/14'; #GA DPT1.001 fuer die Rueckmeldung des Zustandes des Badezimmerschalters
$ga_fehler_filter             = '14/1/15'; #GA DPT 1.001 fuer den Zustand des Filters. 0=OK, 1=Filter Voll
$ga_fehlercode                 = '14/1/16'; #GA DPT 16.000 fuer die Ausgabe des Fehlercodes als Text
$ga_aktstufe                 = '14/1/4' ; #GA DPT 5.005 Wert für aktuelle Stufe
 
#Hier werden die Gruppenadressen für die Rückmeldung der Temperaturen vergeben: (Nicht vergeben=inaktiv)
$ga_aul_temp                 = '14/1/6' ; #GA DPT 9.001 für die Aussenlufttemperatur
$ga_zul_temp                 = '14/1/7' ; #GA DPT 9.001 für die Zulufttemperatur
$ga_abl_temp                 = '14/1/8' ; #GA DPT 9.001 für die Ablufttemperatur
$ga_fol_temp                 = '14/1/9' ; #GA DPT 9.001 für die Fortlufttemperatur
$ga_komfort_temp             = '14/1/22'; #GA DPT 9.001 für die Komforttemperatur

#Zuordnung der Namen fuer die RRD's:
$Name_rrd_AUL                 = 'KWL_Aussenluft'; #Name RRD Aussenluft
$Name_rrd_ZUL                 = 'KWL_Zuluft'    ; #Name RRD Zuluft
$Name_rrd_ABL                 = 'KWL_Abluft'    ; #Name RRD Abluft
$Name_rrd_FOL                 = 'KWL_Fortluft'  ; #Name RRD Fortluft
 
#Pfad zur seriellen Schnittstelle oder dem USB-Seriell-Wandler:
$schnittstelle                 = '/dev/usbserial-1-4.4';
 
### Neu in Version 1.6###

#Angaben für die Kommunikation über den UDP-Port einer MOXA [diese Einstellungen reichen aus, d.h. auf dem Wiregate muss unter "Seriell/LAN/Socketverbindungen" KEINE Socketverbindung erstellt werden
$socknum     = ""; # Eindeutige Nummer des Sockets
$send_ip     = ""; # SendeIP (UDP)
$send_port     = ""; # Sendeport (UDP)    
$recv_ip     = ""; # EmpfangsIP (UDP)
$recv_port     = ""; # Empfangsport (UDP)
 

# Kommunikationsart
$Kom_Art = "S"; # "S" = seriell; "M" = Moxa
 

# Dauer einer Abfrage
$Zaehler = "2500"; #Mit dieser Variable Zaehler wird beeinflusst, wie lange das Plugin auf den Abschluss einer Rückmeldung der KWL wartet; empfohlener Wert für seriell: 2'500; für Moxa: 250
 
 
 
######################
##ENDE Einstellungen##
######################

[mosjka1]

Hallo Northmann,

vielen Dank!

EDIT: Kann jemand bestätigen, dass sich die unterschiedliche Drehzahlen des Zu-/Abluftventilators für die verschiedene Stufen nicht setzen lassen? Es bleibt nur jeweils ein Wert Bsp. Stufe1 (ZUL:35 ABL: 31) erhalten. Die restlichen Stufen 2-3 sind mit jetweils 15% definiert. Einfacher gesagt: man kann der jeweiligen Stufe keine bestimmte Zu-/Abluftdrehzahl festlegen?

[mosjka1]

Hallo Leute, wie kann man über das Plugin die Comfoair direkt auf Kaminmodus(zuluft 50%, Abluft 15%) schalten ohne dabei die einzelnen drehzahlwerte der Zuluft und Abluft per GA eingeben zu müssen? Ist das überhaubt mit diesem Plugin möglich?