4 Bytes als Float betrachten

[DelphiManiac]

Hallo,
ich habe folgendes Problem:
ich habe 4 Bytes

Delphi-Quellcode:

Byte1,Byte2,Byte3,Byte4:Byte

diese Bytes will ich also Floatzahl bewerten nach IEEE 754.
Denke der Datentyp Single ist schon IEEE 754 konform.
Habe es bisher (aber natürlich nicht sonderlich gut oder elegant) so
gelöst

Delphi-Quellcode:

data1:=IntToHex(device1.FT_In_Buffer[3],2);
data2:=IntToHex(device1.FT_In_Buffer[4],2);
data3:=IntToHex(device1.FT_In_Buffer[5],2);
data4:=IntToHex(device1.FT_In_Buffer[6],2);
ReadValueString:='$'+data1+data2+data3+data4;
data:=StrToInt(ReadValueString);
ReadValueString:= HexStringToStr(ReadValueString);
PointerSingle:=@data;
FLOATWERT:=PointerSingle^;

Desweiteren muss ich ja die Floatzahl auch wieder rückrechnen können.. bzw genau die 4 Bytes, die eine Floatzahl darstellen

Danke, ich hoffe es antworten mir ein paar Spezis :-)

[Klaus01]

Es sollte damit gehen.

Delphi-Quellcode:

function HexToSingle(Value: String): Single;
 var
   IntValue: Integer;
   FloatValue: Single absolute IntValue;
 begin
   IntValue:=StrToInt('$'+Value);
   Result:=FloatValue;
 end;

[edit] mal wieder zu schnell gepostes und nicht alles gelesen, der Weg zurück geht damit auch nicht [/edit]

Grüße
Klaus

[DelphiManiac]

Hi Kalus01,

danke für deine Antwort,
was macht denn das absolute?

Delphi-Quellcode:

FloatValue: Single absolute IntValue;

THX

[Klaus01]

Noch auf einer japanischen WebSeite gefunde,

Delphi-Quellcode:

function SingleToHex(d: single) : String;
var i: Cardinal absolute d;
begin
  Result := IntToHex(i,8);
end;

function HexToSingle(h: String): Single;
var
i: Cardinal;
s: Single absolute i;
begin
  i := StrToIntDef(h, 0);
  Result := s;
end;

zu absolute:

Zitat:

You can create a new variable that resides at the same address as another variable. To do so, put the directive absolute after the type name in the declaration of the new variable, followed by the name of an existing (previously declared) variable. For example,

var

Str: string[32];
StrLen: Byte absolute Str;

specifies that the variable StrLen should start at the same address as Str. Since the first byte of a short string contains the string’s length, the value of StrLen is the length of Str.
You cannot initialize a variable in an absolute declaration or combine absolute with any other directives.

Grüße
Klaus

[Amateurprofi]

Zitat:

Zitat von DelphiManiac

Hallo,
ich habe folgendes Problem:
ich habe 4 Bytes
[delphi]
Byte1,Byte2,Byte3,Byte4:Byte

diese Bytes will ich also Floatzahl bewerten nach IEEE 754.
Denke der Datentyp Single ist schon IEEE 754 konform.
Habe es bisher (aber natürlich nicht sonderlich gut oder elegant) so
gelöst

so müßte es funktionieren:

Code:

Type
   TSingle= packed Record
               case integer of
                  1  :  (byte1,byte2,byte3,byte4:byte);
                  2  :  (word1,word2:word);
                  3  :  (int:integer);
                  4  :  (lword:cardinal);
                  5  :  (bytes:array[0..3] of byte);
                  6  :  (words:array[0..1] of word);
                  7  :  (value:single);
               end;
var
   data:TSingle;

Du kannst die Daten als Bytes, Words, Integer oder Cardinal in data schreiben und dann mit data.value den Wert als single auslesen, ohne irgenwelche weiteren Operationen.

[DelphiManiac]

Danke euch beiden,

@Amateurpofi:

Ok ich versuche mich mal dran.
Also wir haben einen neuen Datentypen
TSingle, dieser bildet ein gepackten (also alles hintereinander) Record.
was macht jetzt genau die Case Struktur mit

Delphi-Quellcode:

case integer

?

@Klaus01:
muss das mal ausprobieren (was hast du denn auf japanischen Websites zusuchen?? :-)

[Klaus01]

Zitat:

Zitat von DelphiManiac

was macht jetzt genau die Case Struktur mit

Delphi-Quellcode:

case integer

?

Das case ist dazu da damit man im Record verschiedene Typen auf
ein und demselben Adressraum abbilden kann.
Kannst ja mal in der Delphi Hilfe nach variant Records schauen.

Grüße
Klaus

[Amateurprofi]

Zitat:

Zitat von DelphiManiac

Danke euch beiden,

@Amateurpofi:

was macht jetzt genau die Case Struktur mit

Delphi-Quellcode:

case integer

?

Die case Struktur bewirkt, daß du unterschiedliche Datentypen ansprechen kannst
z.B.
data.byte1:=5; // byte1 wird = 5 gesetzt, andere Bytes bleiben unberührt
data.int:=5; // alle 4 Bytes werden verändert, in diesem Fall byte1 = 5 alle anderen = 0
data.value:=37.5 // 37.5 wird als Single-Wert gespeichert

[DelphiManiac]

@Amateurprofi:

Das heißt ich kann eine 32 Bit Speicherstelle über den Datentyp des records ansprechen?
Das wäre dann ja genau das was ich suche, so kann ich meine Speicherstelle füllen und
den Datentyp (der die Speicherstelle ja interpretiert) auswählen.

SUPER DANKE!!!
Danke auch nocheinmal allen, die sich mit mir den Kopf zerbrochen haben :o
Problem gelöst :-)

[alzaimar]

Äh...

Delphi-Quellcode:

  Move (@IntegerVariable, @SingleVariable, SizeOf (Integer));

Und zurück:

Delphi-Quellcode:

  Move (@SingleVariable, @IntegerVariable, SizeOf (Integer));

[SnuffMaster23]

@alzaimar: so brauchst du aber immer zwei Variablen die zwischendurch auch mal möglicherweise verschiedene "Werte" haben können.
Außerdem müssen die vier Bytes direkt hintereinander im Speicher liegen, sonst geht das schief.

[alzaimar]

@SnuffMaster23: Das ist schon klar, aber anstatt sich einen mit irgenwelchen Funktionen von japanischen Foren abzubrechen, dachte ich mir, ich poste mal die knappe Variante. Dessenungeachtet soll damit klar werden, das man einfach die 4 Bytes direkt in ein Single reinblastern kann.

Was allerdings dein Einwand mit den Variablen, die verschiedene Werte annehmen können, meinst, ist mir schleierhaft. Der Sinn von Variablen ist doch der, das sie... verschiedene Werte annehmen können.

Nun egal. Ist eh trivial.

[SnuffMaster23]

Also ich fänds schon praktischer wenn ich die Single-Variable schreiben und dann direkt die Bytes entnehmen kann und umgekehrt.
Das geht eben bei der record-Variante weils ein und derselbe Speicher ist.

Verschiedene Variablen muss man immer vorher syncronisieren ;)

Und nebenbei, ich wär auch ohne japanische Foren drauf gekommen, aber da stands schon da^^

[DelphiManiac]

@alle

Hallo also die Recordvariante von Amateurprofi ist genau das was ich gesucht habe,
einfach anzuwenden und man muss keine Typkonvertierung durchführen, da sie ja schon im Record liegen.

Also danke nochmal!!

[SirThornberry]

die Variante mit dem varianten Record ist (meiner Meinung nach) die beste. Eine weitere Variante wäre mit Pointern:

Delphi-Quellcode:

var
  lDeinSingle: Single;
begin
  PByte(Cardinal(@lDeinSingle) + 0)^ := Byte4;
  PByte(Cardinal(@lDeinSingle) + 1)^ := Byte3;
  PByte(Cardinal(@lDeinSingle) + 3)^ := Byte2;
  PByte(Cardinal(@lDeinSingle) + 4)^ := Byte1;

[uligerhardt]

Man könnte auch einfach ein array of Byte und nen simplen Cast nehmen:

Delphi-Quellcode:

procedure Test;
var
  bytes: array[0..3] of Byte;
  i: Integer;

  procedure WriteIt;
  var
    i: Integer;
  begin
    Write(Single(bytes): 5: 5, '= (');
    for i := 0 to 2 do
      Write(bytes[i], ', ');
    Writeln(bytes[3], ')');
  end;

begin
  Single(bytes) := Pi;
  WriteIt;

  for i := 0 to 3 do
    bytes[i] := 0;
  WriteIt;

  bytes[0] := 219;
  bytes[1] := 15;
  bytes[2] := 73;
  bytes[3] := 64;
  WriteIt;
end;

Uli.