String umwandeln

[Masteric]

Hi Experten Team,
ich habe ein Problem, was auf einen alten Thread von mir aufbaut, wo ich Daten von einer USB Messkarte auslese, die einen virtuellen seriellen port hat. Ich lese die Daten mit dem Comport aus und erhalte auch einen String zurück, wenn ich einen bestimmten Befehl an die Karte sende. Jedoch bekomm ich z. B. sowas zurück "ú'aÿè±™ç" bin mir nicht sicher, was das für eine Textformatierung ist, aber hoffe ihr wisst, was ich damit tun muss, um da irgendwie leserliche Zahlen zu bekommen....



Gruß Masteric

[mkinzler]

Sieht eher binär aus.

[sirius]

Viel kann man nicht sagen. Ich würde (wenn du zahlen erwartest) sie mal in einen Integer einlesen. Oder wenn du schon nen string hats dann setze mal eine Variable vom Typ PInteger oder PByte oder PWord,... auf @s[1] und schu mal was in PInteger(@s[1])^ so drin steht.

[Masteric]

Hab nochmal was ähnliches in der Anelitung gesehen, vielleicht hilft das witer, da steht ,das sei ASCII Code, sollte der aber nicht lesbar sein, da waren aber auch solche Zeichen :gruebel: ... also in der Anleitung, wo bei die leider nicht viel hergibt

[Masteric]

Hab es rausbekommen :corky:

ich musste den string den ich bekomme, der besteht bei wenn ich nur einen kanal abfrage genau aus drei bytes, die diese merkwürdigen strings ergaben, aus dem musste ich die beiden ersten chars aus dem string nehmen, und in ordinal zahlen umwandeln, wobei das erste ein Heighbyte ist, was ich erstnoch mit 256 multipliziere und zum zweiten, dem Lowbyte addiere, dann bekomm ich den erhofften Wert..., der dritte ist nur eine Prüfsumme.

Das hätten die in der Anleitung ein bisschen besser erklären können :warn: ....


Gruß Masteric

PS: Trotzdem Danke für euer Hilfe...

[sirius]

also wäre es PWord(@s[1])^ gewesen ;)

[himitsu]

nein ist es nicht:

bei (P)Word steht zuerst das Low-Byte (halt BigEndian)

Delphi-Quellcode:

W := (Word(S[1])) shl 8) or Byte(S[2]);

// oder 

W := ByteSwap(PWord(@S[1]))

Delphi-Quellcode:

Function ByteSwap(i: Word): Word;
  ASM
    XCHG AH, AL;
  End;

// oder (Ersteres läuft auch auf alter CPUs)

Function ByteSwap(i: Word): Word;
  ASM
    BSWAP AX
  End;

[turboPASCAL]

Wenn ich die Variante BSWAP AX verwenden möchte kömmt von meinem Delphi6 die Antwort: "Ungültige Kombination von Opcode und Operanden"
Wieso denn das bitte ?

[himitsu]

ups, grad nochmal nachgeguckt ... bei Word hab ich des auch nicht verwendet (vermutlich scheint es dann doch nicht zu gehn) :oops:

für LongWord (BSWAP EAX) ginge aber :angel2:

nja gut, XCHG AH, AL sollte auch gut genug funktionieren :angel:

[turboPASCAL]

Zitat:

nja gut, XCHG AH, AL sollte auch gut genug funktionieren

jo, das tut das tun.

[GPRSNerd]

<OT>

@Masteric
Bei deiner Signatur sollte es doch bestimmt "weiser Professor" und nicht "weißer" heißen, oder? Oder spielt die Hautfarbe für den Spruch irgendeine Rolle? :warn:

</OT>

[himitsu]

:angel:

Delphi-Quellcode:

Procedure ChangeEndian(Var S: WideString); Overload;
  ASM
    TEST   EAX, EAX
    JZ     @exit
    MOV    EAX, [EAX]
    MOV    ECX, [EAX - 4]
    SHR    ECX, 1
    @Loop:
    MOV    DL, BYTE PTR [EAX]
    XCHG   DL, BYTE PTR [EAX + 1]
    MOV    BYTE PTR [EAX], DL
    ADD    EAX, 2
    LOOP   @Loop
    @exit:
  End;

Procedure ChangeEndian(Var S: UnicodeString); Overload;
  ASM
    TEST   EAX, EAX
    JZ     @exit
    CALL   System.@UniqueStringU
    MOV    ECX, [EAX - 4]
    @Loop:
    MOV    DL, BYTE PTR [EAX]
    XCHG   DL, BYTE PTR [EAX + 1]
    MOV    BYTE PTR [EAX], DL
    ADD    EAX, 2
    LOOP   @Loop
    @exit:
  End;

Procedure ChangeEndian(P: PWideChar; Len: Integer); Overload;
  ASM
    TEST   EAX, EAX
    JZ     @exit
    CMP    EDX, 0
    JLE    @exit
    MOV    ECX, EDX
    @Loop:
    MOV    DL, BYTE PTR [EAX]
    XCHG   DL, BYTE PTR [EAX + 1]
    MOV    BYTE PTR [EAX], DL
    ADD    EAX, 2
    LOOP   @Loop
    @exit:
  End;

falls jemand rausbekommt, wie man UniqueStringU, @UniqueStringU, bzw InternalUniqueStringU für einen UnicodeString per ASM aufruft, dann könnte man das Ganze komplett in Assembler lösen, aber irgendwie konnt ich da grad keinen Zugang finden :?


[add]
noch schnell was für Alle, welche lieber auf 'ne einfache und reine Pascalversion stehen:

Delphi-Quellcode:

Procedure ChangeEndian(Var S: WideString); Overload;
  Var i: Integer;

  Begin
    For i := 1 to Length(S) do
      S[i] := WideChar((Word(S[i]) shl 8) or (Word(S[i]) shr 8));
  End;

Procedure ChangeEndian(Var S: UnicodeString); Overload;
  Var i: Integer;

  Begin
    For i := 1 to Length(S) do
      S[i] := WideChar((Word(S[i]) shl 8) or (Word(S[i]) shr 8));
  End;

Procedure ChangeEndian(P: PWideChar; Len: Integer);
  Var i: Integer;

  Begin
    While Len > 0 do Begin
      P^ := WideChar((Word(P^) shl 8) or (Word(P^) shr 8));
      Inc(P);
      Dec(Len);
    End;
  End;

[sirius]

Zitat:

falls jemand rausbekommt, wie man UniqueStringU, @UniqueStringU, bzw InternalUniqueStringU für einen UnicodeString per ASM aufruft, dann könnte man das Ganze komplett in Assembler lösen, aber irgendwie konnt ich da grad keinen Zugang finden

Du musst mindestens die Unit mit in den Call-Befehl schmeißen. Assembler denkt halt nicht so mit....

[himitsu]

:wall: stümmt, so geht's :stupid: ,
dann noch ein paar kleine Fehler bei UniqueStringU-Parametern berichtigt
und schon sieht's schön aus :angel:

(neuer Code siehe oben)

[add]
jo, und für alle, welche auf PWideChar oder Array's stehen, hab ich noch je eine Version mit 'nem Pointer drangehängt :angel2:

[Hawkeye219]

Hallo,

ich wollte nur schnell etwas Material in die Runde werfen: klick

Gruß Hawkeye

[himitsu]

Gt, dann halt extra für sich noch 'ne Variante und für Dax einen schönen Funktionsnamen :angel2:

Delphi-Quellcode:

Procedure ChangeByteorder(Var S: WideString); Overload;
  Var i: Integer;

  Begin
    For i := 1 to Length(S) do
      S[i] := WideChar(Swap(Word(S[i])));
  End;

Procedure ChangeByteorder(Var S: UnicodeString); Overload;
  Var i: Integer;

  Begin
    For i := 1 to Length(S) do
      S[i] := WideChar(Swap(Word(S[i])));
  End;

Procedure ChangeByteorder(P: PWideChar; Len: Integer); Overload;
  Var i: Integer;

  Begin
    For i := 0 to Len - 1 do
      P[i] := WideChar(Swap(Word(P[i])));
  End;

[himitsu]

Gut, dann halt extra für dich noch 'ne Swap-Variante und für Dax einen schönen Funktionsnamen :angel2:

Delphi-Quellcode:

Procedure ChangeByteorder(Var S: WideString); Overload;
  Var i: Integer;

  Begin
    For i := 1 to Length(S) do
      S[i] := WideChar(Swap(Word(S[i])));
  End;

Procedure ChangeByteorder(Var S: UnicodeString); Overload;
  Var i: Integer;

  Begin
    For i := 1 to Length(S) do
      S[i] := WideChar(Swap(Word(S[i])));
  End;

Procedure ChangeByteorder(P: PWideChar; Len: Integer); Overload;
  Var i: Integer;

  Begin
    For i := 0 to Len - 1 do
      P[i] := WideChar(Swap(Word(P[i])));
  End;

Die Funktionen machen jetzt zwar alle immernoch das Selbe, aber so ist zumindestens für jeden was dabei :mrgreen: