[gelöst] BlockingCall forkt mit PPID1/Anzahl der BlockingCalls begrenzen

[CoolTux]

Hallo Stephan,

Genau das ist es. Jedes Device hat in FHEM einen Device Hash. In diesem Hash stehen diverse Sachen drin. Readings Values von den Readings, Timestamps und und und. Und unter helper stehen eben auch Sachen drin wie Infos zum BlockingCall.
Und ein zweiter BlockingCall dürfte gar nicht erst anlaufen da wir ja eine Abfrage machen.

[abc2006]

Möglicherweise hab ich einen Fehler im Code ... 

Code Auswählen Erweitern

2017.10.14 15:37:42.708 1: Timeout for ardsendHV reached, terminated process 20594
Can't use string ("did not receive acknowledge from"...) as a HASH ref while "strict refs" in use at ./FHEM/99_myUtilsHZG.pm line 111.


Allerdings dürfte dann ja kein neuer BlockingCall gestartet werden ... [/s]

erst denken ... Ich hab die alte funktionierende sub aufgerufen, die natürlich nicht mit den Wünschen der neuen AbortFn klarkommt...
Weitersuchen

[CoolTux]

Zum besseren Verständnis Bau dir doch Mal etwas ganz einfaches. Ein Dummy, ein notify welches auf ein set on vom Dummy triggert, das notify startet eine Routine und stellt gleichzeitig den Dummy wieder auf off. Dir Routine startet ein BlockingCall mit timeout 60s und im BlockingCall machst du ein sleep von 20s und gibst irgendwas nach durchlaufen zurück. Bei den Aufruf des BlockingCall ganz einfach auf, wie im Wiki.

Nun machst du ein set on der BlockingCall startet. Paar Sekunden später machst du noch mal Set on, ein weiterer BlockingCall dürfte nun nicht starten.

[abc2006]

Klingt nach nem Plan, danke.

Wird aber erst heute Nacht was, ich melde mich.

Grüße,
Stephan

[CoolTux]

Dein Projekt, ich unterstütze nur. Also ganz entspannt. In erster Linie geht es darum das Du verstehst was passiert. Und vielleicht solltest Du versuchen Deinen Code wenn denn möglich einfacher zu halten, es sei denn Du hast da den Durchblick, dann habe ich nichts gesagt 

Rudi schlägt bestimmt schon bisschen die Hände über den Kopf (nett gemeint). Er hat mal gesagt Tray and Error kostet beim Programmieren nur Nerven. Er hat Recht, aber wenn das Teil dann mal rennt und Du verstanden hast wieso und wie genau reparieren sich die Nerven auf Grund von Glückmomenthormonen 



Grüße
Leon

[abc2006]

Hi Leon,

ich unterstütze nur

Ich weiss. Aber ich weiss das sehr zu schätzen. Ich bastel hier irgendwelchen verquirlten Kram, und du wendest deine Zeit auf, um mir zu helfen, das bedeutet mir viel!
Und ich versuche deine Erklärungen zu verstehen und nachzuvollziehen, auch wenn es bedeutet, dass ich anders arbeiten muss als bisher.
Ich versteh diese Sache mit dem Hash und dem -> halt (noch) nicht wirklich.

Zum Thema:

es gibt einen dummy D_dummy
es gibt ein notify N_notify:
   

Code Auswählen Erweitern

D_dummy:on {nb_test("N_notify")}


Es gibt eine Routine test (die mit dem sleep) und eine Routine nb_test

Code Auswählen Erweitern

sub nb_test($){
my ($name) = @_;
my $hash = $defs{NAME};
$hash->{helper}{RUNNING_PID} = BlockingCall("test","$hash") unless(exists($hash->{helper}{RUNNING_PID}));
}


sub test($){
Log3 "test", 1, "gestartet";
sleep 30;
Log3 "test", 1, "beendet";
}



der sleep funktioniert, und wird auch im Log dargestellt, aber ich kann so viele Blocking starten, wie ich will:

Code Auswählen Erweitern

2017.10.15 02:00:14.569 3: N_notify return value: HASH(0x30488f8)
2017.10.15 02:00:14.572 1: gestartet
2017.10.15 02:00:18.664 3: N_notify return value: HASH(0x30492a0)
2017.10.15 02:00:18.667 1: gestartet
2017.10.15 02:00:44.574 1: beendet
2017.10.15 02:00:48.669 1: beendet


"list D_dummy" gibt (erwartungsgemäß) nichts von RUNNING_PID aus, "list N_notify" aber auch nicht.

Ich habe den Eindruck, dass das mit dem "an den Hash binden" nicht so ganz funktioniert. Kann es sein, dass für jeden Aufruf ein neuer $hash gebildet wird?  Jetzt am Minimal-Beispiel: Was muss ich tun?

Danke und Grüße,
Stephan

[CoolTux]

Hallo Stephan,

Nur kurz. Du hast einen Fehler drin.

my $hash = $defs{$name};

Schau mal was Du geschrieben hast.



Grüße

[abc2006]

my $hash = $defs{$name};

werde ich gleich angehen.
Ich habe auch schon ein bisschen weitergebaut:

Code Auswählen Erweitern

sub nb_test($){
my $blockingFn = "test";
my $finishFn = "finish";
my $timeout = 40;
my $abortFn = "abort";
my $abortArg = "test";
my $arg = "test";
my $runningpid = ReadingsVal("D_dummy","blockingpid",1);
if($runningpid < 1){
my $BChash = BlockingCall($blockingFn,$arg,$finishFn,$timeout,$abortFn,$abortArg);
fhem("setreading D_dummy blockingpid $BChash->{pid}");
} else {
Log3 "test", 1, "es läuft noch ein BlockingCall";
}
}


sub test($){
Log3 "test", 1, "gestartet";
sleep 30;
Log3 "test", 1, "beendet";
}

sub finish(){
Log3 "test", 1, "finish";
fhem("setreading D_dummy blockingpid 0");
}
sub abort($){
Log3 "test", 1, "abort";
fhem("setreading D_dummy blockingpid -1");
}



Läuft einwandfrei (habs halt jetzt über ein Reading realisiert, schaue mir den $hash trotzdem gleich nochmal an)

Aber: Damit habe ich noch zwei Punkte:

1.)  Rudi schlug das Attribut blockingCallMax vor. Das soll die BlockingCall Aufrufe ja beschränken und in eine queue stellen. Hab ich probiert, tut es. Ist auch genau das (ein Teil davon) was ich mir vorstellen würde. Ich müsste also nicht selbst eine queue implementieren, sondern könnte die globale nutzen.

2.) die BlockingCalls, die ich mit dem o.g. Code erzeuge, haben alle die PPID des originalen FHEM-Prozesses. Ich hab es nicht geschafft, einen weiteren FHEM-Prozess mit der PPID 1 zu erzeugen. Hier hänge ich noch fest...

[abc2006]

Hallo Stephan,

Nur kurz. Du hast einen Fehler drin.

my $hash = $defs{$name};

Schau mal was Du geschrieben hast.



Grüße

Jaaaaa geil, kaum macht mans richtig, schon gehts. Klasse!
dann bau ich jetzt mal an den großen funktionen rum.

Hast du noch irgendwo ein Beispiel (oder nen Tipp), durch was ich das

die() am besten ersetze?
Vielleicht löst sich ja dadurch auch schon mein Problem...

Grüße,
Stephan

edit: und jetzt ist mir das Ding mit den Hashes auf einmal viel klarer geworden... glaub ich!

[abc2006]

So,
hab die BlockingFn wie folgt abgeändert. Das Problem war anscheinend wirklich das die() (falls du die Lösung so als *gut* erachtest

Grüße,
Stephan

Code Auswählen Erweitern

sub udpsend($) {

my ($parameters) = @_;
my ($name,$order,$ip,$port) = split("\\|",$parameters);
my $answer="";
my $now = strftime "%Y-%m-%d %T",localtime();
my $sock = IO::Socket::INET->new(
        Proto   => 'udp',
        PeerPort => $port,
        PeerAddr => $ip,
) or die "could not create Socket: $!\n";
$sock->send($order) or die "Send error $!\n";
$sock->setsockopt(SOL_SOCKET, SO_RCVTIMEO, pack('l!l!', 2, 0))
    or die "setsockopt: $!";
$sock->recv($answer,1024)
or die "Could not receive an answer: $!";
$sock->close();
##
$answer =~ s/(.*)\n.*/$1/g;
my $return = "$name|$answer|$order|$ip|$port";
my $return = encode_base64($return,"");
return $return;
}


[CoolTux]

Sieht gut aus was ich so sehen kann. Läuft denn Dein Code nun wie gewünscht?

[abc2006]

So, nachdem ich mir heute durch das speichern einer gecachten Seite alles wieder zerschossen habe, läufts jetzt wieder 

Ja, mein Code macht (im moment) das was er soll. Zur Vollständigkeit nochmal unten anbei.
Um in der Abortfunction feststellen zu können, was der Fehler war, bin ich auf die Internen Variablen umgestiegen.
Oder habe ich eine Möglichkeit, der abortFn ein dynamisches Argument mitzugeben, übersehen?

Womit ich extra gewartet habe, bis das erste Problem im Griff ist: Die Sub ist ja nur deswegen Blocking, weil sie auf eine Antwort wartet. Dazu hatte ich folgendes gefunden:

wenn es nur darum geht beim lesen nicht zu blockieren kannst du das aber viel einfacher in dem du deinen filedescriptor per selectlist in die fhem event loop einhängst. du wirst dann automatisch aufgerufen wenn daten für dich da sind. ein beispiel dafür ist das telnet modul in fhem.

Zugegebenermaßen, in das Telnet-Modul habe ich bisher nicht reingeschaut. Würde ich heute Abend machen. Denkst du, es macht Sinn, meine Sub auf *selectlist* umzubauen?
Dazu bräuchte ich vermutlich nochmal hilfe.

Danke,
Stephan

Code Auswählen Erweitern

sub nb_udpsend($$$$) {
my $log_name = "nb_udpsend()";
my $subloglevel = 5;
my $previous_loglevel = AttrVal("global","verboseTelegram",0);
if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $subloglevel");
}
log_telegram("5",$log_name,"debug aktiviert","remotebot");
 
    my ($name,$order,$ip,$port) = @_;
my $hash = $defs{$name};
my $blockingFn = "udpsend";
my $finishFn = "finishFn";
my $timeout = 2;
my $abortFn = "abortFn";
my $abortArg = $name;
##     $order        $ip           $port
my $args = "$name|$order|$ip|$port";
##delete($hash->{helper}{RUNNING_PID});

##log_telegram("4",$log_name,"_BlockingCall FN: $blockingFn ARG: $args FIN: $finishFn TO:$timeout AFN:$abortFn AARG: $abortArg _","remotebot");

##BlockingKill($hash->{helper}{RUNNING_PID}) if(defined($hash->{helper}{RUNNING_PID}));
if(!exists($hash->{helper}{RUNNING_PID})){
$hash->{helper}{RUNNING_PID} = BlockingCall($blockingFn,$args,$finishFn,$timeout,$abortFn,$abortArg);
log_telegram("4",$log_name,"_starte BlockingCall FN: $blockingFn ARG: $args FIN: $finishFn TO:$timeout AFN:$abortFn AARG: $abortArg _","remotebot");
} else {
log_telegram("2",$log_name,"BlockingCall $hash->{helper}{RUNNING_PID}{pid} is already running","remotebot");
if ($hash->{helper}{RUNNING_PID}{pid} =~ "DEAD"){
log_telegram("2",$log_name,"töte BlockingCall","remotebot");
BlockingKill($hash->{helper}{RUNNING_PID});
delete($hash->{helper}{RUNNING_PID});
}
}
$hash->{helper}{RUNNING_PID}{OWN_PORT} = $port;
$hash->{helper}{RUNNING_PID}{OWN_IP} = $ip;
$hash->{helper}{RUNNING_PID}{OWN_ORDER} = $order;

if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $previous_loglevel");
}
return;
}

sub udpsend($) {

my ($parameters) = @_;
my ($name,$order,$ip,$port) = split("\\|",$parameters);
my $hash = $defs{$name};
my $answer="";
my $now = strftime "%Y-%m-%d %T",localtime();
my $sock = IO::Socket::INET->new(
        Proto   => 'udp',
        PeerPort => $port,
        PeerAddr => $ip,
);
my $status .=$!;
##if(defined($!)){return "could not create Socket: $!"};
$sock->send($order);
my $status .=$!;
##if(defined($!)){return "Send error $!"};
$sock->setsockopt(SOL_SOCKET, SO_RCVTIMEO, pack('l!l!', 2, 0));
my $status .=$!;
##if(defined($!)){return "setsockopt: $!"};
$sock->recv($answer,1024);
my $status .=$!;
##if(defined($!)){return "Could not receive an answer: $!"};
$sock->close();
##
$answer =~ s/(.*)\n.*/$1/g;
my $return = "$name|$answer|$order|$ip|$port|$status";
my $ret = encode_base64($return,"");
$hash->{helper}{RUNNING_PID}{OWN_ANSWER} = $answer;
$hash->{helper}{RUNNING_PID}{OWN_STATUS} = $status;

return $ret;
##return $order;


}


sub abortFn($) {
my $log_name = "abortFn(S)";
my ($name) = @_;
my $hash= $defs{$name};
my $subloglevel = 5;
my $previous_loglevel = AttrVal("global","verboseTelegram",0);
if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $subloglevel");
}

my $answer = $hash->{helper}{RUNNING_PID}{OWN_ANSWER};
my $port = $hash->{helper}{RUNNING_PID}{OWN_PORT};
my $ip = $hash->{helper}{RUNNING_PID}{OWN_IP};
my $order = $hash->{helper}{RUNNING_PID}{OWN_ORDER};
my $status = $hash->{helper}{RUNNING_PID}{OWN_STATUS};


delete($hash->{helper}{RUNNING_PID});

log_telegram("3",$log_name,"function aborted: $name","remotebot");
log_telegram("5",$log_name,"OUTPUT BEGIN","remotebot");
log_telegram("5",$log_name,"ANSWER: $answer","remotebot");
log_telegram("5",$log_name,"ORDER: $order","remotebot");
log_telegram("5",$log_name,"IP: $ip","remotebot");
log_telegram("5",$log_name,"PORT: $port","remotebot");
log_telegram("5",$log_name,"STATUS: $status","remotebot");
log_telegram("5",$log_name,"OUTPUT END","remotebot");

if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $previous_loglevel");
}

}
sub finishFn($) {
my $log_name = "finishFn(S)";

my ($input) = @_;
my $parameters = decode_base64($input);
my ($name,$answer,$order,$ip,$port,$status) = split("\\|",$parameters);
my $hash = $defs{$name};

delete($hash->{helper}{RUNNING_PID});


my $subloglevel = 5;
my $previous_loglevel = AttrVal("global","verboseTelegram",0);
if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $subloglevel");
}
log_telegram("5",$log_name,"OUTPUT BEGIN","remotebot");
log_telegram("5",$log_name,"ANSWER: $answer","remotebot");
log_telegram("5",$log_name,"ORDER: $order","remotebot");
log_telegram("5",$log_name,"IP: $ip","remotebot");
log_telegram("5",$log_name,"PORT: $port","remotebot");
log_telegram("5",$log_name,"STATUS: $status","remotebot");
log_telegram("5",$log_name,"OUTPUT END","remotebot");

if($answer == $order){
log_telegram("3",$log_name,"function finished: $parameters","remotebot");
} else {
log_telegram("1",$log_name,"function finished: $parameters but:\n$answer is not equal to $order","remotebot");
}

if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $previous_loglevel");
}


}

####################################################################################
sub controlVL_ARD($) {
my $log_name = "controlVL_ARD";
my $subloglevel = 3;
my $previous_loglevel = AttrVal("global","verboseTelegram",0);
if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $subloglevel");
}
log_telegram("5",$log_name,"debug aktiviert","remotebot");

my ($name) = @_;
my $hash = $defs{$name};
my $warmRelais = 1;
my $kaltRelais = 2;
my $tuwas = ReadingsVal("PID.FUBO","actuation","-5");;
my $VL = ReadingsVal("RE_TEMP_VorlaufHK","temperature","100");
my $VLSoll = ReadingsVal("PID.FUBO","desired","0");
my $SpeicherOben = ReadingsVal("RE_TEMP_Speicher_09","temperature","0");
my $KesselVL = ReadingsVal("RE_TEMP_Vorlauf_Kessel","temperature","0");
my $KesselRL = ReadingsVal("RE_TEMP_Ruecklauf_Kessel","temperature","0");
my $literpromin = ReadingsNum("KNX10.I06_Heizungszaehler_main","literpromin",1);
my $pidstate = ReadingsVal("DF_Heizschleifenfunktion","status","error");
my $order = 0;
my $ip = "192.168.0.98";
my $port = "8887";


my $readingsAge = ReadingsAge("KNX10.I06_Heizungszaehler_main","literpromin",0);
if ($readingsAge > 90 && $literpromin !=0) {
log_telegram("5",$log_name,"_literpromin $literpromin ist bereits $readingsAge Sekunden alt, setze Reading auf 0_","remotebot");
log_telegram("3",$log_name,"_literpromin $literpromin ist bereits $readingsAge Sekunden alt, setze Reading auf 0_","alarmbot");
fhem("setreading KNX10.I06_Heizungszaehler_main literpromin 0");
}elsif($literpromin == 0) {
log_telegram("5",$log_name,"_literpromin $literpromin ==0_","remotebot");
}else {
log_telegram("5",$log_name,"_literpromin $literpromin ist erst $readingsAge Sekunden alt_","remotebot");
}

## muss nach reparatur des Durchflussmessers entfernt werden
##my $literpromin = 1;
## muss nach reparatur des Durchflussmessers entfernt werden

my $message = "VL-ist:$VL VL-soll:$VLSoll";
log_telegram("4",$log_name,"N_changeVL: wurde aufgerufen","remotebot");

if ($VL > 40){
$tuwas = -50;
log_telegram("5",$log_name,"N_changeVL: RE_TEMP_VorlaufHK: [RE_TEMP_VorlaufHK:temperature]°C, fahre $tuwas Sek!","remotebot");
} elsif($literpromin == 0 && $tuwas < 0) { # und $VL < 45 {
log_telegram("5",$log_name,"tue nichts, weil literpromin = $literpromin und tuwas = $tuwas","remotebot");
$tuwas = 0;
}
if ( $pidstate eq "uebergang" && ($tuwas > 0.2 || $tuwas < -0.5) )
{

log_telegram("4",$log_name,"_tuwas : $tuwas ; pidstate: $pidstate _","remotebot");
if($tuwas > 0){
$order = $warmRelais . "R" . abs($tuwas)*1000;
} else {
$order = $kaltRelais . "R" . abs($tuwas)*1000;
}
nb_udpsend($name,$order,$ip,$port);
##fhem("setreading ardsend sent $order");
$message .= " :=> $order";
} elsif (($tuwas >= 0.7 && $SpeicherOben > $VLSoll) || $tuwas <= -0.7 )
{   
log_telegram("4",$log_name,"_tuwas : $tuwas _","remotebot");
if($tuwas > 0){
$order = $warmRelais . "R" . abs($tuwas)*1000;
} else {
$order = $kaltRelais . "R" . abs($tuwas)*1000;
}
nb_udpsend($name,$order,$ip,$port);
##fhem("setreading ardsend sent $order");
$message .= " :=> $order";
} else {
$message .= " :=> $tuwas < 0.7\n keine Änderung";
}## end if
log_telegram("3",$log_name,$message,"remotebot");
if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $previous_loglevel");
}
}## end sub



#########################################################################################################################
sub controlRLA_ARD($) {
my $log_name = "controlRLA_ARD";
my $subloglevel = 3;
my $previous_loglevel = AttrVal("global","verboseTelegram",0);
if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $subloglevel");
}
log_telegram("5",$log_name,"debug aktiviert","remotebot");

my ($name) = @_;
my $hash = $defs{$name};
my $warmRelais = 2;
my $kaltRelais = 1;
my $tuwas = ReadingsVal("PID.HV_RLA","actuation","-5");
my $RLA_Soll = ReadingsVal("PID.HV_RLA","desired","0");
my $RLA = ReadingsVal("RE_TEMP_HV_RLA","temperature","0");
my $order;
my $ip = "192.168.0.95";
my $port = "8888";



my $message = "RLA ist: $RLA, soll: $RLA_Soll","remotebot";

if ($tuwas >= 500 || $tuwas <= -500 )
{   
log_telegram("4",$log_name,"_tuwas : $tuwas _","remotebot");
if($tuwas > 0){
$order = $warmRelais . "R" . abs($tuwas);
} else {
$order = $kaltRelais . "R" . abs($tuwas);
}

nb_udpsend($name,$order,$ip,$port);
##nb_ardsendHV($order);
$message .= " :=> $order";
} else {
$message .= " :=> $tuwas < 500\n keine Änderung";
}## end if
log_telegram("3",$log_name,$message,"remotebot");
if ($previous_loglevel != $subloglevel){
fhem("attr global verboseTelegram $previous_loglevel");
}
my $return = "dies ist die veraltete funktion|dies ist die veraltete funktion|dies ist die veraltete funktion|dies ist die veraltete funktion|dies ist die veraltete funktion";
my $return = encode_base64($return,"");
return $return;
}## end sub


[CoolTux]

Code Auswählen Erweitern


sub myUtils_BlaBla_open($hash) {

     my $hash    = shift;
.......
my $sock = IO::Socket::INET->new(
        Proto   => 'udp',
        PeerPort => $port,
        PeerAddr => $ip,
)
or return Log3 $name, 3, "Couldn't connect to $host:$port";


$hash->{FD}    = $socket->fileno();
$hash->{CD}    = $socket;
$selectlist{$name} = $hash;


.....


Sicherlich war es so gemeint. Du brauchst nun noch die passende Read Sub dazu

Code Auswählen Erweitern


sub 99myUtils_BlaBla_Read($) {

    my $hash = shift;
    my $name = $hash->{NAME};
   
    my $len;
    my $buf;
   
   
    Log3 $name, 4, "ReadFn started";

    $len = sysread($hash->{CD},$buf,10240);


........


In $buf stecken dann Deine Daten.

Allerdings empfehle ich Dir das alles in eine eigene 99_myUtils_BlaBla.pm zu stecken mit einer passenden Initialize ganz oben

Code Auswählen Erweitern


sub myUtils_BlaBla_Initialize($) {

    my ($hash) = @_;

    $hash->{ReadFn}     = "myUtils_BlaBla_Read";
    $hash->{WriteFn}    = "myUtils_BlaBla_Write";

........

Die Write falls Du auch mal Daten schreiben willst.

Und dann eben noch eine Sub zum verarbeiten der erhaltenen Daten.


Zum Thema abortFn

Code Auswählen Erweitern


sub AbortedFn($) {

    my ($hash)  = @_;
    my $name    = $hash->{NAME};

    delete($hash->{helper}{RUNNING_PID});


    Log3 $name, 4, " ($name) - ExecGatttool_Aborted: The BlockingCall Process terminated unexpectedly. Timedout";
}


Das ist schon alles. Seit neustem gibt es noch einen zweiten Parameter der an die AbortFn übergeben wird, den kann man mit auswerten wenn man will. Schau Dir am besten mal den Code von Blocking.pm an

[CoolTux]

Huch fast vergessen

Code Auswählen Erweitern


sub 99myUtils_BlaBla_Write($@) {

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


   syswrite($hash->{CD}, $string);



}


Nun hast Du aber immer noch das Problem das Du das ganze an ein Device binden musst damit Du immer zugriff auf den Hash hast. Mein persönliches vorgehen wäre innerhalb dieser myUtils irgendwie ein Device anlegen zu lassen. Aber ganz ehrlich, wenn Du das alles so machst, dann kannst auch gleich ein eigenes Modul schreiben. Nur so für Dich.

[abc2006]

Ja, war auch schon meine Überlegung.
Ich hab auch ein (eigenes) Modul (schon in Betrieb), was Daten von einem "volkszähler-USB-Modul" liest.
Das würde ich dann auch mit in Angriff nehmen.


Danke für die Tipps, bin ab morgen erstmal ne Woche im Urlaub. Melde mich dann, falls ich noch Fragen hab.

Grüße,
Stephan