Anbindung an openHCAN

[CoolTux]

Vor allem klappt ja laut Deiner Aussage das syswrite auch nicht.

Nimm mal das hier und gib mir dann mal bitte nach 1min das log

[GU!DO]

Gerne, anbei das Log:

Code Auswählen Erweitern

!!!Initialize
!!!Define
2017.11.01 10:58:33 3: HCAN_Test (HCAN_Test) - defined with host localhost
!!!Set
!!!Set
!!!Set
!!!Set
!!!Open
2017.11.01 10:58:40 3: HCAN_Test (HCAN_Test) - Baue Socket Verbindung auf
!!!Set
2017.11.01 10:58:40 3: HCAN_Test (HCAN_Test) - Socket Connected
!!!Write
2017.11.01 10:58:40 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0xa757c38)';
2017.11.01 10:58:40 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
2017.11.01 10:58:40 1: PERL WARNING: Use of uninitialized value in addition (+) at ./FHEM/78_HCAN_Test.pm line 255.
!!!Write
2017.11.01 10:59:10 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0xa757c38)';
2017.11.01 10:59:10 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
!!!Write
2017.11.01 10:59:40 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0xa757c38)';
2017.11.01 10:59:40 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
2017.11.01 10:59:55 3: FHEMWEB WEB CSRF error: csrf_201500400611968 ne csrf_343132966347035 for client WEB_127.0.0.1_47219. For details see the csrfToken FHEMWEB attribute.
!!!Write
2017.11.01 11:00:10 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0xa757c38)';
2017.11.01 11:00:10 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
^C


[CoolTux]

Ich habe eine böse Ahnung.

Mal gaaanz vorsichtig gefragt, Du machst nach dem einspielen der neuen Moduldatei oder des neuen Inhaltes in die Moduldatei schon noch ein reload??

[GU!DO]

Ich mache es so wie hier:

Grundsätzlich gehe ich folgender Maßen vor, wenn ich Änderungen am Modul gemacht habe:
1. Ich lösche das Test-Device.
2. ich mache einen Reload des Moduls mit reload...
3. ich Erstelle ein neues Device mit define...
Ich denke das ist so ok?!

und hier:

Hier nochmal der Ablauf:

Code Auswählen Erweitern


########### MODUL RELOAD: reload 78_HCAN_Test
!!!Initialize
########### MODUL DEFINE: define HCAN_Test HCAN_Test localhost
!!!Define
2017.11.01 09:41:09 3: HCAN_Test (HCAN_Test) - defined with host localhost
!!!Set
!!!Set
!!!Set
################### KLICK AUF SET HCAN_Test CONNECT
!!!Set
!!!Open
2017.11.01 09:41:37 3: HCAN_Test (HCAN_Test) - Baue Socket Verbindung auf
!!!Set
2017.11.01 09:41:37 3: HCAN_Test (HCAN_Test) - Socket Connected
!!!Write
2017.11.01 09:41:37 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0xabd8fb8)';
2017.11.01 09:41:37 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
2017.11.01 09:41:37 1: PERL WARNING: Use of uninitialized value in addition (+) at ./FHEM/78_HCAN_Test.pm line 256.


beschrieben. Ist das Flasch?!?

[CoolTux]

Es fehlen Log Ausgaben und die Fehlermeldung undefined bla bla dürfte auch nicht mehr kommen.

Hier mal der komplette aktuelle Code

Code Auswählen Erweitern


package main;

use strict;
use warnings;
use IO::Socket::INET;

# zum Debuggen
use Data::Dumper;

#my $missingModul = "";

#eval "IO::Socket::INET" or $missingModul .= "IO::Socket::INET";



my $version = "0.0.1";


####################################
#  Wird zur Initialisierung beim ersten Laden des Moduls in FHEM
#  aufgerufen
#
sub HCAN_Test_Initialize($) {
    print("!!!Initialize\n");

    my ($hash) = @_;


    $hash->{ReadFn}     = "HCAN_Test_Read";
    $hash->{WriteFn}    = "HCAN_Test_Write";

    $hash->{SetFn}      = "HCAN_Test_Set";
    $hash->{DefFn}      = "HCAN_Test_Define";
    $hash->{UndefFn}    = "HCAN_Test_Undef";
    $hash->{AttrFn}     = "HCAN_Test_Attr";
    $hash->{AttrList}   = $readingFnAttributes;

    foreach my $d(sort keys %{$modules{HCAN_Test}{defptr}}) {
   
        my $hash = $modules{HCAN_Test}{defptr}{$d};
        $hash->{VERSION}    = $version;
    }
}


#####################################
# wird aufgerufen wenn der Define-Befehl für ein Geräte ausgeführt wird und das
# Modul bereits geladen und mit der Initialize-Funktion initialisiert ist
#
# übergebene Parameter prüfen und an geeigneter Stelle speichern-
# sowie einen Kommunikationsweg zum Gerät öffnen
#
sub HCAN_Test_Define($$) {
    print("!!!Define\n");

    my ( $hash, $def ) = @_;
    my @a = split( "[ \t][ \t]*", $def );

   
    return "too few parameters: define <name> HCAN_Test <HOST> " if( @a != 3 );
#    return "Cannot define a HCAN device. Perl modul $missingModul is missing." if ( $missingModul );
   
    my $name            = $a[0];
    my $host            = $a[2];

    $hash->{HOST}       = $host;
    $hash->{VERSION}    = $version;


    Log3 $name, 3, "HCAN_Test ($name) - defined with host $host";
    $attr{$name}{room} = "HCAN_Test" if( !defined( $attr{$name}{room} ) );
    $attr{$name}{verbose} = "5";



    readingsBeginUpdate($hash);
    readingsBulkUpdate($hash,'state','Initialized');
    readingsEndUpdate($hash,1);

   
   
    $modules{HCAN_Test}{defptr}{$host} = $hash;


    return undef;
}

#####################################
# Wird im Rahmen des delete-Befehls, sowie rereadcfg-Befehl aufgerufen.
# Dient zum Abbau von offenen Verbindungen, Timern, etc.-
#
sub HCAN_Test_Undef($$) {
    print("!!!Undef\n");

    my ( $hash, $arg ) = @_;
    my $host = $hash->{HOST};
    my $name = $hash->{NAME};

    RemoveInternalTimer($hash);
    HCAN_Test_Close($hash);
    delete $modules{HCAN_Test}{defptr}{$hash->{HOST}};
   
    Log3 $name, 3, "HCAN_Test ($name) - device $name deleted";
    return undef;
}

sub HCAN_Test_Attr(@) {

    my ( $cmd, $name, $attrName, $attrVal ) = @_;
    my $hash = $defs{$name};
    my $orig = $attrVal;

   
    return undef;
}

#####################################
# Wird im Rahmen des set-Befehls aufgerufen um Daten an das Gerät zu senden.
#
sub HCAN_Test_Set($@) {
    print("!!!Set\n");
   
     my ($hash, $name, $cmd, @args) = @_;
     my ($arg, @params)  = @args;

     if( $cmd eq 'connect' ) {

        return HCAN_Test_Open($hash);
           
      } else {
           
        my $list = 'connect:noArg';
                   
        return "Unknown argument $cmd, choose one of $list";
      }

# #    my $telnetCmd;
# #    $cmd = 'connect' if $cmd == '?';
#     print Dumper('Dumper: '.$cmd);
#
#
#     if($cmd eq 'reconnect') {
#         return "usage: $cmd" if( @args != 0 );
#
#         HCAN_Test_ReOpen($hash);
#         return undef;
#
#     } elsif($cmd eq 'connect') {
#         return "usage: $cmd" if( @args != 0 );
#
#         HCAN_Test_Open($hash);
#         return undef;
#
#     } elsif($cmd eq 'disconnect') {
#         return "usage: $cmd" if( @args != 0 );
#
#         HCAN_Test_Close($hash);
#         return undef;
#
#     } elsif($cmd eq 'sendCmd') {
#
# #        $telnetCmd = $arg;
#
#     } else {
#
#         my  $list = "";
#         $list .= "reconnect:noArg connect:noArg disconnect:noArg";
#         return "Unknown argument $cmd, choose one of $list";
#     }
#
#    HCAN_Test_Write($hash,$telnetCmd);
}

########################################
# Oeffnet den Socket
# Schreibt die Verbindungsdaten für %select in den hash
#
sub HCAN_Test_Open($) {
   
    print("!!!Open\n");
    my $hash        = shift;
    my $name        = $hash->{NAME};
    my $host        = $hash->{HOST};
    my $port        = 3600;
    my $timeout     = 0.1;


    Log3 $name, 3, "HCAN_Test ($name) - Baue Socket Verbindung auf";

    my $socket = new IO::Socket::INET   (   PeerHost    => $host,
                                            PeerPort    => $port,
                                            Proto       => 'udp',
                                            Timeout     => $timeout,
                                            Type        => SOCK_DGRAM
                                        )
        or return Log3 $name, 3, "HCAN_Test ($name) Couldn't connect to $host:$port";

    $hash->{FD}    = $socket->fileno();
    $hash->{CD}    = $socket;         # sysread / close won't work on fileno
    $selectlist{$name} = $hash;

    readingsSingleUpdate($hash, 'state', 'connected', 1 );
    Log3 $name, 3, "HCAN_Test ($name) - Socket Connected";

    # "Anmelde" Paket senden
    HCAN_Test_KeepAlive($hash);

}



########################################
# Schließt den Socket
# Loescht die Verbindungsdaten im hash
#
sub HCAN_Test_Close($) {
    print("!!!Close\n");
   
    my $hash    = shift;
    my $name    = $hash->{NAME};

   
    return if( !$hash->{CD} );
   
    close($hash->{CD}) if($hash->{CD});
    delete($hash->{FD});
    delete($hash->{CD});
    delete($selectlist{$name});
   
    readingsSingleUpdate($hash, 'state', 'not connected', 1 );
    RemoveInternalTimer($hash);
}

sub HCAN_Test_ReOpen($) {
   
    my $hash    = shift;
    my $name    = $hash->{NAME};

   
    HCAN_Test_Close($hash);
    HCAN_Test_Open($hash) if( !$hash->{CD} or !defined($hash->{CD}) );
}


########################################
# Keep Alive
#
sub HCAN_Test_KeepAlive($) {

    my $hash    = shift;
   
    my $data    = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00';
   
    HCAN_Test_Write($hash,$data);
   
    InternalTimer(gettimeofday()+30, "HCAN_Test_KeepAlive", $hash);
}



########################################
# wird durch die Funktion IOWrite() aufgerufen, sobald eine logische
# Geraetefinition Daten per IO-Gerät an die Hardware übertragen moechte
#
sub HCAN_Test_Write($@) {
    print("!!!Write\n");

     my ($hash,$data)  = @_;
     my $name          = $hash->{NAME};
             
             
     Log3 $name, 3, "HCAN_Test ($name) - WriteFn called";
                 
     print Dumper('Dumper: '.$hash->{CD});
     return Log3 $name, 3, "HCAN_Test ($name) - WriteFn socket not connected"
     unless($hash->{CD});
                           
     Log3 $name, 3, "HCAN_Test ($name) - $data";
     my $resp = syswrite($hash->{CD}, $data);
    Log3 $name, 3, "HCAN_Test ($name) - Write Response: $resp";
     return undef;

   
    # my ($hash,$string)  = @_;
    # my $name                    = $hash->{NAME};
    #
    #
    # $string    .= "\r\n";
    # Log3 $name, 4, "HCAN_Test ($name) - WriteFn called";
    #
    # return Log3 $name, 4, "HCAN_Test ($name) - socket not connected"
    # unless($hash->{CD});
    #
    # Log3 $name, 5, "HCAN_Test ($name) - $string";
    # syswrite($hash->{CD}, $string);
    #
    # return undef;
}


#####################################
# called from the global loop, when the select for hash->{FD} reports data
# Wird durch FHEM aufgerufen, wenn ein gelisteter Filedeskriptor in %selectlist
# Daten zum Lesen bereitstellt.
#
sub HCAN_Test_Read($) {
    print("!!!Read\n");
   
    my $hash = shift;
    my $name = $hash->{NAME};
    my $len;
    my $buf;

   
    Log3 $name, 4, "HCAN_Test ($name) - ReadFn gestartet";
    #$len = sysread($hash->{CD},$buf,1024);
    $len = sysread($hash->{CD},$buf,1500);
   
    Log3 $name, 3, "HCAN_Test ($name) - Daten Empfangen. Länge: $len - Daten: " . unpack('H*', $buf);
   
    if( !defined($len) || !$len ) {
   
        Log3 $name, 3, "HCAN_Test ($name) - connection closed by remote Host";
        HCAN_Test_Close($hash);
        return;
    }
   
    unless( defined $buf) {
   
        Log3 $name, 3, "HCAN_Test ($name) - no data received";
        return;
    }
   
   
    Log3 $name, 3, "HCAN_Test ($name) - received buffer data, Data: $buf";
    readingsSingleUpdate($hash,'response',$buf,1);
}








######################################
# FHEM zeigen, dass alles o.k. ist
1;


Der Weg an sich ist auf jefen Fall korrekt. Du kannst auch mal die version ändern, das sollte dann auch gleich im INTERNAL zu sehen sein.

[GU!DO]

Um ganz sicher zu gehen, habe ich den FHEM Prozess zwischen dem löschen des vorhanden Test-Devices und dem reload teilweise auch beendet und neu gestartet.

[CoolTux]

Nimm mal bitte die hier. Und dann gibst Du mir bitte eine Logausgabe und eine Ausgabe von

list DEVICENAME

[GU!DO]

Versuch ich sofort. Ich habe in der Zwischenzeit nochmal folgendes probiert:
(Ist quick an dirty, aus meinen bisherigen Versuchen kopiert.)

Wenn ich das ausführe, bekomme ich mittels TCP Dump das "keep_alive" Paket und den nachfolgenden Befehl auf dem Bus angezeigt.

1. Eingefügt:

Code Auswählen Erweitern


use Socket;


2. _Write habe ich geändert,

Code Auswählen Erweitern


  1 sub HCAN_Test_Write($@) {
  2     print("!!!Write\n");
  3      my ($hash,$data)  = @_;
  4      my $ret=HCAN_Test_Send($hash);
  5      return undef;
  6 }


und 3. dieses angefügt.

Code Auswählen Erweitern


  1 sub HCAN_Test_Send($$){
  2   my ($hash,$HEX)=@_;
  3   my $trans_serv  = getprotobyname( 'udp' );
  4   my $remote_host = gethostbyname( REMOTE_HOST );
  5   my $remote_port = SIMPLE_UDP_PORT; my $destination = sockaddr_in( $remote_port, $remote_host );
  6
  7
  8   socket( UDP_SOCK, PF_INET, SOCK_DGRAM, $trans_serv );
  9
10       # Keep-Alive-Paket senden
11       my $data = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
12       send( UDP_SOCK, $data, 0, $destination );
13       # Daten senden
14       my $data = "\x00\x8e\x10\x03\x03\x00\x00\x00\x05\x0b\x32\xb7\xec\x3a\x6f\xb7";
15       send( UDP_SOCK, $data, 0, $destination );
16       select(undef, undef, undef, 0.3); #pause 0.3 seconds
17       Log3 $hash->{NAME}, 5, 'Gesendet! ';
18   return undef;
19 }


Werde jetzt direkt Deins probieren...

[GU!DO]

AHHH SORRY, SORRY, SORRY... WO IST DAS SYMBOL, BEI DEM DER TYP DEN KOPF GEGEN DIE WAND HAUT!!!!!

Es tut mir wirklich leid. Ich weiß, warum Deine Änderungen nicht übernommen wurden.

Ich habe hier diese Downloads:
Nov  1 09:05 /root/Downloads/78_HCAN_Test(1).pm
Nov  1 10:54 /root/Downloads/78_HCAN_Test(2).pm
Nov  1 11:42 /root/Downloads/78_HCAN_Test(3).pm
Nov  1 08:06 /root/Downloads/78_HCAN_Test.pm

hab aber zum Kopieren immer:

Code Auswählen Erweitern


/../Downloads/78_HCAN_Test.pm guido@10.20.30.115:/home/guido

aus der Shell-History ausgeführt.

TUT MIR WIRKLICH LEID, DASS ICH DAMIT DEINE ZEIT VERGÄUDET HABE. SORRY!!!

Test das letzte Modul direkt.

[GU!DO]

Habs getestet, er sendet:

Code Auswählen Erweitern


11:52:15.250168 IP localhost.54675 > localhost.3600: UDP, length 64
0x0000:  4500 005c faf2 4000 4011 419c 7f00 0001
0x0010:  7f00 0001 d593 0e10 0048 fe5b 5c78 3030
0x0020:  5c78 3030 5c78 3030 5c78 3030 5c78 3030
0x0030:  5c78 3030 5c78 3030 5c78 3030 5c78 3030
0x0040:  5c78 3030 5c78 3030 5c78 3030 5c78 3030
0x0050:  5c78 3030 5c78 3030 5c78 3030


Ich hoffe Du spricht jetzt noch mit mir?!?

[CoolTux]

 

Dachte mir schon das da irgendwas nicht ganz sauber ist. Nicht wild. Ich bin manchmal nicht besser.

Aber jetzt müssen wir uns mal sortieren. Also er sendet das keepAlive nun auf den Bus. Nun geht es noch darum ob er auch empfängt.
Was sagt das fhem Log



Grüße

[GU!DO]

Danke für das Verständniss. Ich glaube ich hab mal was vom Berliner Stammtisch und `nem Bierchen gelesen. Wenn Berlin nur nicht so weit von Münster entfernt wäre...

Hab mir den Code noch nicht ansehen könne, da meine Frau mich zwischendurch immer Einspannt...

Also, das Paket ist noch zu Groß. 64 zu den geforderten 16. Das gibt Mecker vom hdan Daemon. Aber das sollte ja nicht das Problem sein.

Anbei das Log schaut vielversprechend aus:

Code Auswählen Erweitern


!!!Initialize
!!!Define
2017.11.01 11:51:51 3: HCAN_Test (HCAN_Test) - defined with host localhost
!!!Set
!!!Set
!!!Set
!!!Set
!!!Set
!!!Open
2017.11.01 11:52:02 3: HCAN_Test (HCAN_Test) - Baue Socket Verbindung auf
!!!Set
2017.11.01 11:52:02 3: HCAN_Test (HCAN_Test) - Socket Connected
!!!Write
2017.11.01 11:52:02 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0xa7da584)';
2017.11.01 11:52:02 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
2017.11.01 11:52:02 3: HCAN_Test (HCAN_Test) - Write Response: 64
!!!Set
!!!Set
!!!Set
!!!Set
!!!Open
2017.11.01 11:52:15 3: HCAN_Test (HCAN_Test) - Baue Socket Verbindung auf
!!!Set
!!!Set
2017.11.01 11:52:15 3: HCAN_Test (HCAN_Test) - Socket Connected
!!!Write
2017.11.01 11:52:15 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0x9be3664)';
2017.11.01 11:52:15 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
2017.11.01 11:52:15 3: HCAN_Test (HCAN_Test) - Write Response: 64
!!!Set
!!!Set
!!!Set
!!!Write
2017.11.01 11:52:32 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0x9be3664)';
2017.11.01 11:52:32 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
2017.11.01 11:52:32 3: HCAN_Test (HCAN_Test) - Write Response: 64
!!!Write
2017.11.01 11:52:45 3: HCAN_Test (HCAN_Test) - WriteFn called
$VAR1 = 'Dumper: IO::Socket::INET=GLOB(0x9be3664)';
2017.11.01 11:52:45 3: HCAN_Test (HCAN_Test) - \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
2017.11.01 11:52:45 3: HCAN_Test (HCAN_Test) - Write Response: 64
!!!Read
2017.11.01 11:53:00 4: HCAN_Test (HCAN_Test) - ReadFn gestartet
2017.11.01 11:53:00 3: HCAN_Test (HCAN_Test) - Daten Empfangen. Länge: 16 - Daten: 2490100307000000060100030b3500b7
2017.11.01 11:53:00 3: HCAN_Test (HCAN_Test) - received buffer data, Data: $�


Das Kauderwelsch aus der letzten Zeille (hier nur zum Teil zu sehen) müsste noch in HEX umgewandelt werden.

[CoolTux]

2017.11.01 11:53:00 4: HCAN_Test (HCAN_Test) - ReadFn gestartet
2017.11.01 11:53:00 3: HCAN_Test (HCAN_Test) - Daten Empfangen. Länge: 16 - Daten: 2490100307000000060100030b3500b7


So da haste Deine Daten  Er empfängt also. Ob das mit dem write Response 64 jetzt falsch ist kann ich nicht sagen. Aber er sendet und er empfängt nun schon mal. Schritt eins von 99 erledigt!

[CoolTux]

Mal davon ab,

\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00

Sind bei mir 64 Zeichen.

[GU!DO]

2017.11.01 11:53:00 4: HCAN_Test (HCAN_Test) - ReadFn gestartet
2017.11.01 11:53:00 3: HCAN_Test (HCAN_Test) - Daten Empfangen. Länge: 16 - Daten: 2490100307000000060100030b3500b7/

Ups, da hab ich doch das Wesentliche übersehen.

Schritt eins von 99 erledigt!

Na Du machst mir ja Mut!



Hmm, also er soll schon Pakete mit einer Größe von 16 Bytes bekommen... und die hat der mit meinem hcan2.pl und gleichem Code  auch so gesendet:

tcpdump Ausgabe vom hcan2.pl:

Code Auswählen Erweitern


12:22:17.085751 IP localhost.47240 > localhost.3600: UDP, length 16
0x0000:  4500 002c a5af 4000 4011 970f 7f00 0001
0x0010:  7f00 0001 b888 0e10 0018 fe2b 0000 0000
0x0020:  0000 0000 0000 0000 0000 0000



tcpdump Ausgabe vom fhem Paket:

Code Auswählen Erweitern


12:00:02.285332 IP localhost.54675 > localhost.3600: UDP, length 64
0x0000:  4500 005c 0a33 4000 4011 325c 7f00 0001
0x0010:  7f00 0001 d593 0e10 0048 fe5b 5c78 3030
0x0020:  5c78 3030 5c78 3030 5c78 3030 5c78 3030
0x0030:  5c78 3030 5c78 3030 5c78 3030 5c78 3030
0x0040:  5c78 3030 5c78 3030 5c78 3030 5c78 3030
0x0050:  5c78 3030 5c78 3030 5c78 3030


Er sagt ja auch, Length 16 zu Length 64.