Immer nur 3 bytes aus Empfangsdaten weiterreichen..

[Rul]

Hi zusammen...

..ich komme im Moment nicht weiter und benötige einen Rat.

Wie kannich 3 Bytes über seriell einlesen?

Danke!

Rul

PS
Ich hab D6

[Uwe Raabe]

Deklariere dir einen Buffer für die verbleibenden Zeichen. Dann könnte die Routine so aussehen:

Delphi-Quellcode:

var
  Buffer: string;

procedure DataAvailable(const Data: string);
begin
  Buffer := Buffer + Data;
  while length(Buffer) > 2 do begin
    UDPCLIENT.SEND(Copy(Data, 1, 3));
    Delete(Data, 1, 3);
  end;
end;

[Rul]

Zitat von Uwe Raabe:

Deklariere dir einen Buffer für die verbleibenden Zeichen. Dann könnte die Routine so aussehen:

Delphi-Quellcode:

var
  Buffer: string;

procedure DataAvailable(const Data: string);
begin
  Buffer := Buffer + Data;
  while length(Buffer) > 2 do begin
    UDPCLIENT.SEND(Copy(Data, 1, 3));
    Delete(Data, 1, 3);
  end;
end;

Hallo Uwe,

danke ersteinmal :

ich erhalte eine Fehlermeldung:

"Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden"

Irgendeine Idee?


Rul

Edit:
PS

eine zusätzliche Deklaration habe ich versucht aber da scheint die Application einzufrieren

Delphi-Quellcode:

var
  Buffer: string;
  neu : string;
procedure DataAvailable(const Data: string);
begin
neu := Data;
  Buffer := Buffer + neu;
  while length(Buffer) > 2 do begin
    UDPCLIENT.SEND(Copy(neu, 1, 3));
    Delete(neu, 1, 3);
  end;
end;

[Uwe Raabe]

Zitat von Rul:

ich erhalte eine Fehlermeldung:

"Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden"

Irgendeine Idee?

Sicher - war irgendwie Unsinn:

Delphi-Quellcode:

procedure DataAvailable(const Data: string);
begin
  Buffer := Buffer + Data;
  while length(Buffer) > 2 do begin
    UDPCLIENT.SEND(Copy(Buffer , 1, 3));
    Delete(Buffer , 1, 3);
  end;
end;

[Rul]

[QUOTE=Uwe Raabe;1251905]

Zitat von Rul:

Delphi-Quellcode:

procedure DataAvailable(const Data: string);
begin
  Buffer := Buffer + Data;
  while length(Buffer) > 2 do begin
    UDPCLIENT.SEND(Copy(Buffer , 1, 3));
    Delete(Buffer , 1, 3);
  end;
end;

Das sieht gut aus!


Prinzip erkannt - mein Trivales Grundgerüst ist im Vergleich aber irgendwie schneller...

Es stockt noch ein Wenig - denke dass die DataAvailable prozedure sich mit den Erreignisen des UDP Client überschneidet,
kann ich da einen Thread oder Application.ProcessMessages einbringen?

Danke!!

Rul

[Uwe Raabe]

Zitat von Rul:

Prinzip erkannt - mein Trivales Grundgerüst ist im Vergleich aber irgendwie schneller...

Es stockt noch ein Wenig - denke dass die DataAvailable prozedure sich mit den Erreignisen des UDP Client überschneidet,
kann ich da einen Thread oder Application.ProcessMessages einbringen?

Dazu kann ich ohne Kenntnis deines Codes nicht viel sagen.

Ich weiß auch nicht, ob du erfahren genug bist, einen Thread korrekt zu implementieren. Dein ursprünglicher Code läßt das eher zweifelhaft erscheinen. Von ProcessMessages rate ich in jedem Fall ab - das macht es definitiv nicht schneller sondern nur schwieriger die Fehler zu finden.

Als erstes müsste man wohl analysieren, wo die kritischen Stellen wirklich liegen.

[himitsu]

Wobei 3 Byte die Transportschicht doch etwas unterlasten.

Wenn der UDPCLIENT die Daten wirklich sofort versendet, wenn man sie an Send übergibt, dann vervielfacht der Overhead der Transportschichten die Daten doch um ein Vielfaches und das Übertragen dauert umso länger.

Ach ja, wenn die Daten unbedingt ankommen müssen, dann versende es besser via TCP.
Bei UDP kann es doch vorkommen, daß die Daten nicht ankommen und spurlos verschwinden.
Gut, dafür soll ja UDP schneller sein, da es eben keine Empfangskontrolle/Rückmeldung gibt.

Delphi-Quellcode:

procedure DataAvailable(const Data: string);
var
  i: Integer;
begin
  Buffer := Buffer + Data;
  i := (Length(Buffer) div 3) * 3;
  if i > 0 do begin
    UDPCLIENT.SEND(Copy(Buffer, 1, i));
    Delete(Buffer, 1, i);
  end;
end;

Da via UDP doch die Daten auch in anderen Reihenfolgen ankommen können, wenn überhaupt (wenn ich das richtig verstanden hab), dann kann man natürlich gern noch den Puffer aufteilen, so daß er maximal so groß ist, wie der kleineste Frame, in der Übertragung, so daß diese Bytes immer zusammen bleiben.

Delphi-Quellcode:

procedure DataAvailable(const Data: string);
var
  i: Integer;
begin
  Buffer := Buffer + Data;
  while Length(Buffer) > 2 do begin
    i := Min(Length(Buffer) div 3, 85) * 3;  // maximal 85 Pakete zusammen ... k.A. welche Größe Ideal wäre
    UDPCLIENT.SEND(Copy(Buffer, 1, i));
    // gibt es sowas wie ein UDPCLIENT.FLUSH?
    Delete(Buffer, 1, i);
  end;
end;

Man könnte natürlich auch auf den "Buffer" verzichten und die Daten direkt ans TCP weitergeben, ohne zusätzliches umkopieren und aufsplitten.

[Rul]

Zitat von himitsu:

Wobei 3 Byte die Transportschicht doch etwas unterlasten.

Wenn der UDPCLIENT die Daten wirklich sofort versendet, wenn man sie an Send übergibt, dann vervielfacht der Overhead der Transportschichten die Daten doch um ein Vielfaches und das Übertragen dauert umso länger.

Ach ja, wenn die Daten unbedingt ankommen müssen, dann versende es besser via TCP.
Bei UDP kann es doch vorkommen, daß die Daten nicht ankommen und spurlos verschwinden.
Gut, dafür soll ja UDP schneller sein, da es eben keine Empfangskontrolle/Rückmeldung gibt.

Delphi-Quellcode:

procedure DataAvailable(const Data: string);
var
  i: Integer;
begin
  Buffer := Buffer + Data;
  i := (Length(Buffer) div 3) * 3;
  if i > 0 do begin
    UDPCLIENT.SEND(Copy(Buffer, 1, i));
    Delete(Buffer, 1, i);
  end;
end;

Da via UDP doch die Daten auch in anderen Reihenfolgen ankommen können, wenn überhaupt (wenn ich das richtig verstanden hab), dann kann man natürlich gern noch den Puffer aufteilen, so daß er maximal so groß ist, wie der kleineste Frame, in der Übertragung, so daß diese Bytes immer zusammen bleiben.

Delphi-Quellcode:

procedure DataAvailable(const Data: string);
var
  i: Integer;
begin
  Buffer := Buffer + Data;
  while Length(Buffer) > 2 do begin
    i := Min(Length(Buffer) div 3, 85) * 3;  // maximal 85 Pakete zusammen ... k.A. welche Größe Ideal wäre
    UDPCLIENT.SEND(Copy(Buffer, 1, i));
    // gibt es sowas wie ein UDPCLIENT.FLUSH?
    Delete(Buffer, 1, i);
  end;
end;

Man könnte natürlich auch auf den "Buffer" verzichten und die Daten direkt ans TCP weitergeben, ohne zusätzliches umkopieren und aufsplitten.

Hallo Himitsu,

ich werde das im Anschluss gleich einmal versuchen.

.."Da via UDP doch die Daten auch in anderen Reihenfolgen ankommen können,.."

Das ist eine sehr interessantze Info -
Da muss ich meine Strecke nochmal überdenken... vieleicht habe ich einen Denkfehler in meinem Aufbau...

Ich muss leider UDP nehmen -

Frage:
Kann man die "Reihenfolge der UDP Daten" kontrollieren und richtig stellen im UDP Verfahren oder ist nur TCP ordentlich?

Das ganze passiert auf dem Endrechner.

Deine Beispiele werde ich versuchen und berichten, danke!!!!

LG

Rul

[Rul]

[QUOTE=Rul;1251917]

Zitat von himitsu:

Da via UDP doch die Daten auch in anderen Reihenfolgen ankommen können, wenn überhaupt (wenn ich das richtig verstanden hab), dann kann man natürlich gern noch den Puffer au
fteilen, so daß er maximal so groß ist, wie der kleineste Frame, in der Übertragung, so daß diese Bytes immer zusammen bleiben.

Delphi-Quellcode:

procedure DataAvailable(const Data: string);
var
  i: Integer;
begin
  Buffer := Buffer + Data;
  while Length(Buffer) > 2 do begin
    i := Min(Length(Buffer) div 3, 85) * 3;  // maximal 85 Pakete zusammen ... k.A. welche Größe Ideal wäre
    UDPCLIENT.SEND(Copy(Buffer, 1, i));
    // gibt es sowas wie ein UDPCLIENT.FLUSH?
    Delete(Buffer, 1, i);
  end;
end;

Hallo Himitsu,


Das ist supppper!!

Die Daten hängen jetzt nicht mehr -
..

LG

Rul

[Rul]

Hallo Himitsu,

Ich habe jetzt eine Zeile hinzugefügt weil ich sehen will was wie ankommt und verarbeitet wird,

Danke!.