[WireGate-Plugin] Anbindung Mastervolt Wechselrichter - Plugin

[mfd]

Voraussetzung um aus den Mastervolt-Wechselrichtern verwertbare Daten zu bekommen ist ein (simpler, passiver) RS485 -> RS232 Konverter. Diesen gibt es entweder vom Hersteller direkt oder auch im Netz zu finden z.B. hier.

Das Protokoll der Geräte scheint im Wesentlichen diesem hier zu entsprechen.
Die kleineren WR bis ~1500W sollten genau nach diesem Schema ansprechbar sein.
Bei den größeren Geräten (QS/XS) verhält es sich so, dass diese intern aus mehreren identischen Wechselrichtern aufgebaut sind.
In meinem Fall (QS6400) besteht dieser intern aus 2x QS3200 und diese jeweils aus den Eingängen "A" und "B" (also theoretisch 4x1600W).

So können (die großen WR haben jeweils 2 RS485/RJ45 Buchsen) auch einfach mehrere Geräte kaskadiert und gleichzeitig ausgelesen werden. Diese müssen lediglich eindeutige IDs haben.

Eine typische Abfrage der aktuellen WR-Daten mit der Original-Software sieht dann z.B. so aus:

2013-08-22 19:22:34.705 T 01 01 FF FF B6 00 00 00 B6 
2013-08-22 19:22:34.908 R 01 01 FF FF B6 00 00 00 B6 FF FF 01 01 B6 EE 00 80 AC 00 1F 00 87 13 EC 00 14 00 2F 00 FD EC 12 2C BF B1 21 00 00 24 94
2013-08-22 19:22:34.908 T 02 01 FF FF B6 00 00 00 B7 
2013-08-22 19:22:35.111 R 02 01 FF FF B6 00 00 00 B7 FF FF 02 01 B6 EE 00 80 AC 00 21 00 87 13 E9 00 15 00 31 00 24 66 12 34 92 B2 21 00 00 24 14 
2013-08-22 19:22:35.111 T 11 01 FF FF B6 00 00 00 C6 
2013-08-22 19:22:35.314 R 11 01 FF FF B6 00 00 00 C6 FF FF 11 01 B6 EF 00 80 AA 00 22 00 87 13 EB 00 15 00 31 00 FB 53 11 2C E9 B8 1F 00 00 1F 36
2013-08-22 19:22:35.314 T 12 01 FF FF B6 00 00 00 C7 
2013-08-22 19:22:35.517 R 12 01 FF FF B6 00 00 00 C7 FF FF 12 01 B6 EF 00 80 A7 00 23 00 87 13 ED 00 16 00 34 00 DA E6 13 35 61 93 21 00 00 1F 95

dabei entspricht
01 01 WR 1A
02 01 WR 1B
11 01 WR 2A
12 01 WR 2B

Fortsetzung folgt...

[mfd]

Die Anfragen an den Wechselrichter sind dabei wie folgt aufgebaut:

12 01 FF FF B6 00 00 00 C7
ID WR Befehl Checksumme (alle addiert, letzten beiden Stellen)

Folgende Befehle sind dabei (anscheinend) möglich:

xB6 ruft die aktuellen Werte vom WR ab
xB4 ruft die Firmware des jeweiligen WRs ab, existiert bei mir nur einmal pro "QS3200 Hälfte" also nur "01 01" und "11 01" hat eine eigene Firmware

xA9 ruft die Tageserträge (bis letzte 10 Tage) ab

dabei stellt
xA9 x00 "heute" dar
xA9 x01 "gestern"
...
xA9 x09 "vor 9 Tagen"

Um die Abfragen zu veranschaulichen habe ich die entsprechenden Screenshots der Original-Software beigefügt.
Ein Dump der kompletten seriellen Kommunikation befindet sich in seriallog.zip (SerialMon Dump). Dort ist auch schön zu sehen wie nach dem Neu Verbinden die WR "Gesucht" werden.

Die einzelnen Ertragsdaten habe ich versucht in der protocol_info.odt aufzuschlüsseln. Als Grundlage habe ich die oben erwähnte Protokollbeschreibung genommen und die Abweichungen von meinem Gerät entsprechend kommentiert.

Für das in der Protokollbeschreibung genannte Gerät Soladin 600 habe ich bereits verschiedene Scripte gefunden.
Allerdings läßt sich keiner davon aufgrund der anderen Wechselrichter-Erkennung (meiner unterstützt keinen "xC1" Befehl und hat 4 separate IDs!) einsetzen. Auch Modifikationsversuche schlugen bisher fehl.
Falls es zur Entwicklung dennoch weiterhilft hier die entsprechenden Links:

Solget (für Soladin 600 geschrieben, kontaktiert, hat mich auf mbsolget verwiesen)

mbsolget (Modifikation für XS3200, klappt leider bei mir auch nicht, Seite NL, kontaktiert, entwickelt nicht weiter)

mastervolt-php (PHP-Script XS3200, XS2000, vielversprechend, hatte ich auch schon Kontakt, meldet sich momentan leider nicht zurück)

[mfd]

Für den Anfang würde mir ein Auslesen der täglichen Erträge eigentlich schon ausreichen.
Sofern man seine Wechselrichter IDs händisch einträgt (wären bei mir ja 4 einzelne) müsste man daraufhin IMHO 4x mit dem "xA9"-Befehl abfragen um die entsprechenden Werte zu bekommen und diese ggf. zu einem Gesamtwert addieren.
Das Ganze wäre dann ausbaubar (aktuelle Daten, WR-IDs erkennen usw. ggf Unterstützung für andere Modelle sofern Bedarf besteht) ist aber für mich erstmal "Luxus" da ich im Moment noch gar keine Daten bekomme.

Edit: Falls sich jemand fragt was das Thema eigentlich soll, und wo jetzt das Plugin ist...
...swiss war so freundlich und wollte sich das von Programmierer-Seite einmal ansehen, ob ein Plugin mit vertretbarem Aufwand möglich ist.

Zudem sollen alle etwas von den bisher zusammengetragenen Informationen haben und vielleicht finden sich ja noch andere Interessenten - sowohl auf Programmierer- als auch auf Anwenderseite.

[swiss]

Das sieht eigentlich ziemlich handlich aus. Mal sehen ob die Messwerte auch nur Additionen sind oder ob die umgerechnet werden müssen.

Wenn das funktioniert könnte man ja einfach mal einen Befehl von Hand (ohne laufendes Serviceprogramm) an den WR senden und sehen ob er korrekt antwortet. Sollte das funktionieren, wäre eine Umsetzung als Plugin wahrscheinlich nicht so kompliziert. Man müsste nur wissen wie die Kommunikation endet. Hat die ein Timeout oder wird das Ende eines Datenpakets anders erkannt?

EDIT: OK. Nach durchsicht des Protokolls sollte das ja eigentlich problemlos machbar sein. Ich kann ja mal ein Demo zusammen tippen und dan sehen wir ob es tut. Wenn ja, kann man darauf aufbauen. So habe ich das damals beim CA Plugin auch gemacht Nur das erkennen des Ende eines Datenpaketes ist mir noch nicht ganz klar. Das müsste erst noch geklärt werden

[mfd]

Das sieht eigentlich ziemlich handlich aus. Mal sehen ob die Messwerte auch nur Additionen sind oder ob die umgerechnet werden müssen.

Die Messwerte ergeben sich wie in der modifizierten Protokollbeschreibung (protocol_info.zip) angegeben.

Wie kann ich herausfinden wie die Kommunikation endet?
In meinem SerialMon Mitschnitt ist das denke ich leider nicht ersichtlich. Der WR spuckt soweit ich sehe seine 31 Byte als Antwort aus (bzw. 18 bei den Tageserträgen) und dann kann (muss aber nicht) die nächste Anfrage starten?

[swiss]

Hmm... Wie es aussieht wird tatsächlich mit einem Timeout gearbeitet... Um so besser. Dan kann man einfach auf das Ende warten und dann auswerden. Ausser am Ende befindet sich ein aus dem Log nicht ersichtliches CR oder LF.

Aber das kannst du ja mal manuell testen in dem du von Hand einen Befehl sendest du die Antwort abwartest...

[swiss]

Hast du den WR schon mit dem WG verbunden?

[mfd]

Ja, der WR hängt bei mir als ttyUSB1 am WG.

Wegen der Timeout-Geschichte könnten vielleicht die vorhandenen Scripte etwas hergeben.
Z.B. hier:
https://github.com/langemeijer/maste...MasterVolt.php

Leider für mich nicht allzu aussagekräftig.

Wenn ich also etwas testen soll ist das kein Problem, allerdings nur tagsüber möglich, weil der WR sich nachts komplett abschaltet und dann IMHO einfach nicht auf Anfragen antwortet...

[swiss]

Wie sind den die Schnittstellenparameter?

Aus dem PHP (ich habe es nicht so mit PHP) sehe ich eine Bitrate von 9600 und 8 Datenbit.

Was ich nicht verstehe...

- Hast du 0, 1 oder 2 Stopbit?
- handshake?
- Paritätbit?

Hast du eine Definition der Schnittstellenparameter? Normal für RS232 ist z.B. 9600 8N1

Ich habe da mal was auf die schnelle zusammen geklöppelt. Brauchst nur die Schnittstelle anpassen und das Plugin (wenn es keine Feler ausspuckt) mal so ca. 2-3 Minuten laufenlassen. Im Pluginlog sollte (wenn alles klapt) der Antwortsting auftauchen. Wenn das Passt, ist der Rest noch reine Fleissarbeit

#Pfad zur seriellen Schnittstelle oder dem USB-Seriell-Wandler:
my $schnittstelle = '/dev/ttyUSB-2-4';

#Weitere Variablen die benoetigt werden -> NICHT veraendern!
my $seriel;
my $sin; #Serial Input = Empangener Datenstrom
my $cin; #Counter Input =  Länge des Datenpackets
my $exit;
my $reciv;
my $daten;

my $debug=2;
my $Zaehler = 1000;


$plugin_info{$plugname.'_cycle'}  = 10;

use Device::SerialPort;

       $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')};

        $daten = "0101ffffb6000000b6";
        plugin_log($plugname,'Daten Abrufen: '.$daten);
        $return_value2 = command_senden($daten);
        
sub command_senden{
    my $data = $_[0];
    my $command = pack("H*",$data);
    
    $seriel->write($command);
    
    $reciv = '';
    $cin = '';
    $sin = '';
       
    $|=1;
    my $exit=0;
    while($exit < $Zaehler)
    {
        ($cin, $sin) = $seriel->read(45);

        if($cin > 0){
            $sin = unpack "H*", $sin;
            $reciv .= $sin;
            $exit=0;
        }else{
            $exit++
        }
       
        if($debug>=2){plugin_log($plugname,'reciv-direkt:     ' . $sin);}

    }#Ende While 
if($debug>=2){plugin_log($plugname,'reciv-komplet:     ' . $reciv);}
}

[mfd]

9600 8N1 müsste passen.

Ich werde es morgen bei Tageslicht gleich testen und Rückmeldung geben.

Danke für die Unterstützung.

[mfd]

Erster Test

Zunächst ergab sich beim Testen folgender Fehler:

Global symbol "$return_value2" requires explicit package name at (eval 19802) line 29

Tante Google hat mir dann als Nicht-Programmierer verraten, dass offenbar

my $return_value2;

fehlte.

Danach funktionierte es dann auch...
(...mein erstes Perl Erfolgserlebnis )

Die ausschlaggebenden Zeilen im Log sind vermutlich

2013-09-04 09:06:46.258,Mastervolt_Solar,reciv-komplet:     [COLOR=YellowGreen]0101ffffb6000000b6[/COLOR][COLOR=RoyalBlue]ffff0101b6ee0080bf00a8008513ee007f002e01ca01132d9cd72100001b79[/COLOR]
2013-09-04 09:06:46.260,Mastervolt_Solar,1,0.6s,

Der Vollständigkeit halber hänge ich das komplette Logfile mal mit ran. Da sind nämlich jede Menge "Leere" Zeilen und auch einige unvollständige Kommunikationsversuche dabei - sofern ich das richtig interpretiere. Oder ist der WR einfach nur sehr lahm und das Plugin so fix?

Am Anfang der Logdatei habe ich gesehen, dass wohl auch Antworten vom Wechselrichterteil "1 B" also "11 01"... dabei sind. Wie das allerdings Zustande kommt???

[swiss]

Hallo Marco

Das sieht ja schon mal sehr gut aus. Das mit der fehlenden Variablendeklaration tut mir leid. Das ist mir beim zusammen klöppeln durchgerutscht.

Die Fragemente sind übrigens normal. Ist nur für mich um zu sehen, ob tatsächlich mit einem Timeout gearbeitet wird und wie hoch der ist.

Also kommt der nächste Schritt... (Bugfix ist drin also sollte das erweiterte Plugin hoffentlich gleich funktionieren)

Bitte mal 2-3 Minuten laufen lassen und dann das Pluginlog posten...

#Pfad zur seriellen Schnittstelle oder dem USB-Seriell-Wandler:
my $schnittstelle = '/dev/ttyUSB-2-1.2';

#Weitere Variablen die benoetigt werden -> NICHT veraendern!
my $seriel;
my $sin; #Serial Input = Empangener Datenstrom
my $cin; #Counter Input =  Länge des Datenpackets
my $exit;
my $reciv;
my $daten;
my $return_value2;

my $debug=2;
my $Zaehler = 100;


$plugin_info{$plugname.'_cycle'}  = 10;

use Device::SerialPort;

       $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')};

        $daten = "0101ffffb6000000b6";
        plugin_log($plugname,'Daten Abrufen: '.$daten);
        $return_value2 = command_senden($daten);
        
sub command_senden{
    my $data = $_[0];
    my $command = pack("H*",$data);
    
    $seriel->write($command);
    
    $reciv = '';
    $cin = '';
    $sin = '';
       
    $|=1;
    my $exit=0;
    while($exit < $Zaehler)
    {
        ($cin, $sin) = $seriel->read(45);

        if($cin > 0){
            $sin = unpack "H*", $sin;
            $reciv .= $sin;
            $exit=0;
        }else{
            $exit++
        }
       
        if($debug>=3){plugin_log($plugname,'reciv-direkt:     ' . $sin);}

    }#Ende While 
    if($debug>=2){plugin_log($plugname,'reciv-komplet:     ' . $reciv);}

    if($reciv ne ""){
        
        $reciv =~ s/$data//;

        my $pv_voltage = reverse(substr($reciv,16,4));
        $pv_voltage =  hex($pv_voltage)*10;
        if($debug>=1){plugin_log($plugname,'PV Spannung: ' . $pv_voltage);}
    }
}

[swiss]

Also hier nochmal mit ein paar Zusätzen. Wenn das klappt haben wir die gröste Hürde geschafft

#Pfad zur seriellen Schnittstelle oder dem USB-Seriell-Wandler:
my $schnittstelle = '/dev/ttyUSB-2-1.2';

#Weitere Variablen die benoetigt werden -> NICHT veraendern!
my $seriel;
my $sin; #Serial Input = Empangener Datenstrom
my $cin; #Counter Input =  Länge des Datenpackets
my $exit;
my $reciv;
my $daten;
my $return_value2;

my $debug=2;
my $Zaehler = 100;


$plugin_info{$plugname.'_cycle'}  = 10;

use Device::SerialPort;

       $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')};

        $daten = "0101ffffb6000000b6";
        plugin_log($plugname,'Daten Abrufen: '.$daten);
        $return_value2 = command_senden($daten);
        
sub command_senden{
    my $data = $_[0];
    my $command = pack("H*",$data);
    
    $seriel->write($command);
    
    $reciv = '';
    $cin = '';
    $sin = '';
       
    $|=1;
    my $exit=0;
    while($exit < $Zaehler)
    {
        ($cin, $sin) = $seriel->read(45);

        if($cin > 0){
            $sin = unpack "H*", $sin;
            $reciv .= $sin;
            $exit=0;
        }else{
            $exit++
        }
       
        if($debug>=3){plugin_log($plugname,'reciv-direkt:     ' . $sin);}

    }#Ende While 
    if($debug>=2){plugin_log($plugname,'reciv-komplet:     ' . $reciv);}

    if($reciv =~ m/$data/){
        
        $reciv =~ s/$data//;
        if($debug>=2){plugin_log($plugname,'reciv gekürzt: ' . $reciv);}
        my $pv_voltage = reverse(substr($reciv,16,4));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_voltage);}
        $pv_voltage =  hex($pv_voltage)*10;
        if($debug>=1){plugin_log($plugname,'PV Spannung: ' . $pv_voltage);}
    }
}

[mfd]

So sieht das aktuelle PluginLog jetzt aus:

2013-09-05 08:57:06.338,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:57:06.339,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:57:06.422,Mastervolt_Solar,reciv-komplet:     0101ffffb6000000b6ffff0101b6ee0080c0008a008713ec006a00fa008804132cabda2100001ae3
2013-09-05 08:57:06.422,Mastervolt_Solar,reciv gekürzt: ffff0101b6ee0080c0008a008713ec006a00fa008804132cabda2100001ae3
2013-09-05 08:57:06.422,Mastervolt_Solar,substr: 000c
2013-09-05 08:57:06.422,Mastervolt_Solar,PV Spannung: 120
2013-09-05 08:57:06.425,Mastervolt_Solar,1,0s,
2013-09-05 08:57:17.298,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:57:17.298,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:57:17.320,Mastervolt_Solar,reciv-komplet:     0101ffffb6000000
2013-09-05 08:57:24.761,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:57:24.761,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:57:24.773,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:57:35.688,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:57:35.688,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:57:35.699,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:57:46.687,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:57:46.688,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:57:46.706,Mastervolt_Solar,reciv-komplet:     0101ffffb600
2013-09-05 08:57:57.734,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:57:57.734,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:57:57.745,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:58:08.636,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:58:08.636,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:58:08.655,Mastervolt_Solar,reciv-komplet:     0101ffffb6
2013-09-05 08:58:18.739,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:58:18.740,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:58:18.750,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:58:29.714,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:58:29.714,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:58:29.725,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:58:40.703,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:58:40.703,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:58:40.714,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:58:51.681,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:58:51.681,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:58:51.703,Mastervolt_Solar,reciv-komplet:     0101ffffb6000000
2013-09-05 08:59:02.707,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:59:02.707,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:59:02.724,Mastervolt_Solar,reciv-komplet:     0101ffffb6
2013-09-05 08:59:13.704,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:59:13.704,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:59:13.715,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:59:24.749,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:59:24.749,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:59:24.769,Mastervolt_Solar,reciv-komplet:     0101ffffb60000
2013-09-05 08:59:35.709,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:59:35.710,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:59:35.727,Mastervolt_Solar,reciv-komplet:     0101ffff
2013-09-05 08:59:46.273,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:59:46.274,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:59:46.284,Mastervolt_Solar,reciv-komplet:     
2013-09-05 08:59:56.951,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 08:59:56.951,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 08:59:57.018,Mastervolt_Solar,reciv-komplet:     0101ffffb6000000b6ffff0101b6ee0080c00093008913ed00700009018904132daeda2100001e0e
2013-09-05 08:59:57.019,Mastervolt_Solar,reciv gekürzt: ffff0101b6ee0080c00093008913ed00700009018904132daeda2100001e0e
2013-09-05 08:59:57.020,Mastervolt_Solar,substr: 000c
2013-09-05 08:59:57.020,Mastervolt_Solar,PV Spannung: 120
2013-09-05 08:59:57.022,Mastervolt_Solar,1,0.3s,
2013-09-05 09:00:08.195,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 09:00:08.195,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 09:00:08.215,Mastervolt_Solar,reciv-komplet:     0101ffffb60000
2013-09-05 09:00:18.745,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 09:00:18.745,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 09:00:18.757,Mastervolt_Solar,reciv-komplet:     
2013-09-05 09:00:29.709,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 09:00:29.709,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 09:00:29.721,Mastervolt_Solar,reciv-komplet:     
2013-09-05 09:00:40.727,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 09:00:40.727,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 09:00:40.738,Mastervolt_Solar,reciv-komplet:     
2013-09-05 09:00:52.725,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 09:00:52.726,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 09:00:52.736,Mastervolt_Solar,reciv-komplet:     
2013-09-05 09:01:03.749,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 09:01:03.750,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 09:01:03.761,Mastervolt_Solar,reciv-komplet:     
2013-09-05 09:01:14.802,Mastervolt_Solar,Schnittstelle: /dev/ttyUSB-2-1.2 erfolgreich geöffnet
2013-09-05 09:01:14.802,Mastervolt_Solar,Daten Abrufen: 0101ffffb6000000b6
2013-09-05 09:01:14.814,Mastervolt_Solar,reciv-komplet:

[swiss]

Das sieht eigentlich schon mal nicht soo schlecht aus. Ausser dass ich das Plugin ausbremsen muss weil es wildläuft...

Teste doch bitte mal dass für 2-3 Minuten und häng mir wieder das Pluginlog an:

#Pfad zur seriellen Schnittstelle oder dem USB-Seriell-Wandler:
my $schnittstelle = '/dev/ttyUSB-2-1.2';

#Weitere Variablen die benoetigt werden -> NICHT veraendern!
my $seriel;
my $sin; #Serial Input = Empangener Datenstrom
my $cin; #Counter Input =  Länge des Datenpackets
my $exit;
my $reciv;
my $daten;
my $return_value2;

my $debug=2;
my $Zaehler = 100;


$plugin_info{$plugname.'_cycle'}  = 20;

    if(($plugin_info{$plugname.'_time'}+$plugin_info{$plugname.'_cycle'}) >= $plugin_info{$plugname.'_last'}){
        return;
    }
    $plugin_info{$plugname.'_time'} = time();

use Device::SerialPort;

       $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')};

        $daten = "0101ffffb6000000b6";
        plugin_log($plugname,'Daten Abrufen: '.$daten);
        $return_value2 = command_senden($daten);
        
sub command_senden{
    my $data = $_[0];
    my $command = pack("H*",$data);
    
    $seriel->write($command);
    
    $reciv = '';
    $cin = '';
    $sin = '';
       
    $|=1;
    my $exit=0;
    while($exit < $Zaehler)
    {
        ($cin, $sin) = $seriel->read(45);

        if($cin > 0){
            $sin = unpack "H*", $sin;
            $reciv .= $sin;
            $exit=0;
        }else{
            $exit++
        }
       
        if($debug>=3){plugin_log($plugname,'reciv-direkt:     ' . $sin);}

    }#Ende While 
    if($debug>=2){plugin_log($plugname,'reciv-komplet:     ' . $reciv);}

    if($reciv =~ m/$data/){
        
        $reciv =~ s/$data//;
        if($debug>=2){plugin_log($plugname,'reciv gekürzt: ' . $reciv);}
        
        
        my $pv_voltage = reverse(substr($reciv,16,4));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_voltage);}
        $pv_voltage =  hex($pv_voltage)*10;
        if($debug>=1){plugin_log($plugname,'PV Spannung: ' . $pv_voltage . 'V');}
        

        my $pv_ampere = reverse(substr($reciv,20,4));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_ampere);}
        $pv_ampere =  hex($pv_ampere)*100;
        if($debug>=1){plugin_log($plugname,'PV Strom: ' . $pv_ampere . 'A');}
        
        my $pv_frequecy = reverse(substr($reciv,24,4));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_frequecy);}
        $pv_frequecy =  hex($pv_frequecy)*100;
        if($debug>=1){plugin_log($plugname,'PV Frequenz: ' . $pv_frequecy . 'Hz');}

        my $pv_grid_voltage = reverse(substr($reciv,28,4));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_grid_voltage);}
        $pv_grid_voltage =  hex($pv_grid_voltage);
        if($debug>=1){plugin_log($plugname,'PV Ausgangsspannung: ' . $pv_grid_voltage . 'V');}
        
        my $pv_grid_power = reverse(substr($reciv,36,4));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_grid_power);}
        $pv_grid_power =  hex($pv_grid_power)*10;
        if($debug>=1){plugin_log($plugname,'PV Ausgangsleistung: ' . $pv_grid_power . 'W');}
        
        my $pv_total_grid_power = reverse(substr($reciv,40,6));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_total_grid_power);}
        $pv_total_grid_power =  hex($pv_total_grid_power)*10;
        if($debug>=1){plugin_log($plugname,'PV total Ausgangsleistung: ' . $pv_total_grid_power . 'kWh');}
        
        my $pv_temp = reverse(substr($reciv,46,2));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_temp);}
        $pv_temp =  hex($pv_temp);
        if($debug>=1){plugin_log($plugname,'PV Temperatur: ' . $pv_temp . '°C');}
        
        my $pv_working_time = reverse(substr($reciv,48,8));
        if($debug>=2){plugin_log($plugname,'substr: ' . $pv_working_time);}
        $pv_working_time =  hex($pv_working_time);
        if($debug>=1){plugin_log($plugname,'PV Betriebsstunden: ' . $pv_working_time . 'h');}
    }
}