TIdBytes, Variable deklariert als Word und versenden mit TCPIP

[Alex_ITA01]

Hallo zusammen,
ich habe eine Variable vom Typ Word und beschreibe diese mit dem Wert 999.
Anschließend wandle ich das in TIdBytes um und will es versenden über TIdTCPClient.
Das versenden klappt, es kommt auch im Server an.

Nur wenn ich mir den Inhalt von "aBytes" angucke vor dem versenden, steht da 231 und 3 drinne (in den beiden Bytes).

Wenn ich im Server etwas empfange, wandle ich die IdBytes wieder in ein Word um.

Versenden:

Delphi-Quellcode:

var
  myValue : Word;
  aBytes  : TIdBytes;
begin
  myValue := 999;
  aBytes  := ToBytes(myValue);
end;

Empfang:

Delphi-Quellcode:

var
  myValue : Word;
  aBytes  : TIdBytes;
//Empfang... -> tmpStr = Eingangsstring vom TIdTCPServer
aBytes  := ToBytes(tmpStr);

myValue := BytesToWord(aBytes);

Der Empfang (Server) wartet auf eine Nachricht und liest diese als String ein (mit Abschlusscharacter, da verschiedene Nachrichten empfangen werden können). Dieses String wandle ich wieder in IdBytes um, damit ich für die Auswertung komplett mit den IdBytes arbeiten kann.

Mein Problem ist jetzt, dass beim Empfang in den Bytes bereits etwas anderes steht wie beim absenden.
Absenden: 231 und 3
Empfang: 63 und 3

Könnt ihr mir da vielleicht weiterhelfen?

Den Empfang direkt als TIdBytes einlesen kann ich nicht, da ich da eine Bytesanzahl angeben muss, die ich einlesen will. Aber ich kann verschiedene Telegrammlängen empfangen, deswegen gehe ich über ein String mit Abschlusscharacter und kann darüber entscheiden, was ich mit der jeweiligen Nachricht mache.

Grüße

[jaevencooler]

Moin, Moin,

Ich versende unter anderem Daten vom Typ Word in einem TBytes Array (Maschinensteuerung)
und zwar wie folgt :

Delphi-Quellcode:

  
  In Bytes wandeln :

  ADataArr[0] := Lo(myWordValue);                   // low Byte
  ADataArr[1] := Hi(myWordValue);                   // high byte

 und wieder in ein Word wandeln :

  WordRec(myWordValue).Lo := ADataArr[0];
  WordRec(myWordValue).Hi := ADataArr[1];


wobei ADataArr vom Typ TBytes ist.

  auslesen vom Indy Server kannst Du wie folgt :

  if not AContext.Connection.IOHandler.InputBufferIsEmpty then
  begin
    AContext.Connection.IOHandler.InputBuffer.ExtractToBytes( LRxBuffer);
  end;  

  LRxBuffer ist auch vom Typ TBytes

Funktioniert in meinem fall perfekt !!

Beste Grüße
Michael

[Sir Rufo]

Du schickst also folgendes los

Code:

999 = 0x03E7 => 0xE7, 0x03

Diese beiden Bytes gehen in der Reihenfolge auf die Reise.

Beim Umwandeln der Nachricht von

Delphi-Quellcode:

string

nach Bytes kommt das heraus

Code:

0x3F, 0x03 => 0x033F = 831
  ?    #03

Und warum bekommst du ein ??

Ganz einfach, weil 0xE7 größer ist als 0x7F und das wird umgewandelt in

Delphi-Quellcode:

function TIdASCIIEncoding.GetBytes(const AChars: PIdWideChar; ACharCount: Integer;
  ABytes: PByte; AByteCount: Integer): Integer;
var
  P: PIdWideChar;
  i : Integer;
begin
  P := AChars;
  Result := IndyMin(ACharCount, AByteCount);
  for i := 1 to Result do begin
    // replace illegal characters > $7F
    if UInt16(P^) > $007F then begin
      ABytes^ := Byte(Ord('?'));
    end else begin
      ABytes^ := Byte(P^);
    end;
    //advance to next char
    Inc(P);
    Inc(ABytes);
  end;
end;

ah ja ...

[Alex_ITA01]

und wie müsste man es auf die Reise schicken, damit es richtig ankommt?
Dachte die TIdBytes Struktur (array) und die ganzen Umwandelfunktionen kann ich dafür nehmen?!

[Sir Rufo]

Im Prinzip kannst du das nehmen, aber du siehst ja selber, dass du nicht weisst, was du da wirklich annehmen sollst und wie.

Die Lösung lautet: Protokoll

Definiere ein Protokoll was jede Nachricht einhalten muss, damit der Server weiß, was da geschickt wird und wie er damit umgehen muss.

Beispiel:

Code:

Nachrichtentyp 00-FF (1 Byte)
Länge der Nachricht 0000-FFFF (2 Bytes)
Payload (x Bytes) // Hier sind die echten Daten drin
Prüfsumme 00-FF (1 Byte)

Der Server empfängt nun ein Byte, dann 2 Bytes, dann die Nachricht und das letzte Byte, prüft die Nachricht gegen die Prüfsumme und verteilt die Nachricht anhand des Nachrichtentyps.

[Alex_ITA01]

Ja ok, ich kann dann genau die Telegrammart identifizieren und dann entsprechend mit dem Lo() und Hi() arbeiten.
Trotzdem finde ich es ein wenig verwunderlich, dass ich in die Funktion "ToBytes" alle möglichen Datentypen reingeben kann und ich kann auch TIdBytes versenden über TIdTCPClient (IOHandler.Write) aber dann die Auswertung schief geht, weil etwas als "illegal characters" erkannt wird. Wofür gibt es dann die komplett fertigen Funktionen um sich die TIdBytes entsprechend eines Datentypes x erstellen zu lassen und anschließend kann ich es so nicht versenden bzw der Empfang interpretiert das als ungültig. Dann kann ich mir auch gleich selber das Format überlegen und schicke es z.B. als String und nehme den dann komplett auseinander...

[Sir Rufo]

Es ist halt immer die Badehose Schuld :roll:

[Alex_ITA01]

? Sorry, verstehe den Satz nicht :-D