Float Variable wortweise swappen

[C-Anfänger (Gast)]

Hallo zusammen,

ich hoffe, dass ich im richtigen Forum bin.
Ich bin noch nicht so die Leuchte in C. Eventuell stellt euch mein 
Problem vor keine großen Herausforderungen, aber ich stehe noch am 
Anfang.

Ich möchte eine Float Variable wortweise swappen und ich weiß nicht wie.
Also so:

Von von (Byte1,Byte2,Byte3,Byte4) nach (Byte3,Byte4,Byte1,Byte2).

Wie bekomme ich das bei Float hin. Bei einem 32 Bit unsigned integer 
kann ich es mir noch vorstellen. Aber wie geht es bei Float-Variablen?

Danke für eure Hilfe

[Peter II (Gast)]

memcopy in ein Byte Array und dann zurück.

Aber die große Frage: Warum sollte man das tun?

Float ist üblicherweise auf jeder Plattform gleich.

[C-Anfänger (Gast)]

Danke.
Ich kenne memcopy noch nicht, muss mich damit beschäftigen.
Ich dachte schon an eine union, geht das auch?

Manche Modbus Geräte wollen es anders herum.
Es ist mir auch nicht so klar warum!

[Peter II (Gast)]

C-Anfänger schrieb:
> Ich dachte schon an eine union, geht das auch?

geht oft auch, aber ist dafür nicht gedacht und kann Nebenwirkungen 
haben.

[Peter II (Gast)]

C-Anfänger schrieb:
> Manche Modbus Geräte wollen es anders herum.
> Es ist mir auch nicht so klar warum!

dort sendest du es doch auch byteweise oder nicht? Dann kannst du doch 
dort einfach die Bytes tauschen.

[C-Anfänger (Gast)]

Eigentlich ist Modbus Wort-orientiert. Man sendet eigentlich nur 16 
Bit-Werte.
Es ist meines Wissens nicht genau definiert wie float übertragen werden 
(also 2 Wörter).
Daher macht es auch nicht jeder Hersteller gleich.
Die Anzeige die ich ansteuern will macht es halt anders herum.

[Peter II (Gast)]

C-Anfänger schrieb:
> Eigentlich ist Modbus Wort-orientiert. Man sendet eigentlich nur 16
> Bit-Werte.

dann tausche doch einfach die beiden Words beim senden und empfangen. 
Dafür musst du doch nicht die Float umdrehen.

[C-Anfänger (Gast)]

Jetzt weiß ich was du meinst.

Mein Problem ist:
Ich habe eine Float Varibale:
z.B.
float x;
Wie zerpflücke ich die Variable in zwei einzelne 16 Bit Werte.

[Peter D. (peda)]

Ich hab sowas auch für den CAN-Bus gebraucht.
Hier die nötigen Funktionen:

uint32_t swap_order( uint32_t val )             // LSB first -> MSB first
{
  union{
    uint32_t u32;
    uint8_t u8[4];
  } in, out;
  in.u32 = val;
  out.u8[0] = in.u8[3]; 
  out.u8[1] = in.u8[2]; 
  out.u8[2] = in.u8[1]; 
  out.u8[3] = in.u8[0]; 
  return out.u32;
}

static inline uint32_t mkp_u32( float val )    // make pointer from float to uint32_t
{
  union{
    uint32_t u32;
    float f;
  } out;
  out.f = val;
  return out.u32;
}

static inline float mkp_fl( uint32_t val )      // make pointer from uint32_t to float
{
  union{
    uint32_t u32;
    float f;
  } out;
  out.u32 = val;
  return out.f;
}

[Michael B. (laberkopp)]

C-Anfänger schrieb:
> Ich möchte eine Float Variable wortweise swappen

Warum solltest du ?

Der Wert geht dabei kaputt.

Du tauscht einige Mantissenbits mit Exponentenbits,
aus 3.14526e+4 wird vielleicht -9.887e-25 oder was anderes.

[Gerhard (Gast)]

Hallo,

hier ein Beispiel, wie es funktionieren könnte:

union convert_t // union to access the same memory location as float or byte array
{
  float   fValue;        // float ist auf meinem System 4 Byte lang 
  int32_t    lValue;
  uint32_t    ulValue;
  uint8_t bValue[sizeof(float)];
};

und später im Programm:

  uint8_t c;
  float f;
  union convert_t Conv_value;
  f = 1.2345;
  Conv_value.fValue = f;
  c = Conv_value.bValue[3];
  Conv_value.bValue[3] = Conv_value.bValue[4];
  Conv_value.bValue[4] = c;
  f = Conv_value.fValue;

ich schließe mich aber meinem Vorredner an: Erklär lieber, warum du es 
machen willst. Little <==> Big Endian Konvertierung für floats?

Gerhard

PS: statt uint8_t kannst du sicher auch char nehmen.

[Peter II (Gast)]

C-Anfänger schrieb:
> Wie zerpflücke ich die Variable in zwei einzelne 16 Bit Werte.

float f = 3.14f;
word[2] tmp;

memcpy( &tmp, %f, sizeof( float ) );
send( tmp[1] );
send( tmp[0] );

Union finde ich unsauber

[Gerhard (Gast)]

Gerhard schrieb:
> hier ein Beispiel, wie es funktionieren könnte:

uff, viel zu langsam ;-)

[C-Anfänger (Gast)]

Michael B. schrieb:
> Du tauscht einige Mantissenbits mit Exponentenbits,
> aus 3.14526e+4 wird vielleicht -9.887e-25 oder was anderes.

Genau das will ich machen!
Natürlich geht der Wert kaputt, aber wenn der Busteilnehmer es eben so 
will. Das Display interpretiert es eben falsch herum.

[C-Anfänger (Gast)]

Also zumindest habe ich es mir irgendwie einfacher vorgestellt.
Danke mal an alle.
Ich muss jetzt den Code ganz in Ruhe durchgehen und verstehen.

[C-Anfänger (Gast)]

Hallo.
Ich hab mir jetzt nochmal ein paar Gedanken gemacht.
Geht es auch so?

float u1, u1_swap;

union{
 char c[4];
 float f;
} in, out;

in.f = u1;

out.c[0] = in.c[3]; 
out.c[1] = in.c[2]; 
out.c[2] = in.c[1]; 
out.c[3] = in.c[0]; 

u1_swap = out.f;

[helfer (Gast)]

Wenn, dann so:

float u1, u1_swap;

union{
 char c[4];
 float f;
} in, out;

in.f = u1;

out.c[0] = in.c[2]; 
out.c[1] = in.c[3]; 
out.c[2] = in.c[0]; 
out.c[3] = in.c[1]; 

u1_swap = out.f;

[Peter II (Gast)]

C-Anfänger schrieb:
> Geht es auch so?

Standardkonform geht es mit Union nicht, sie ist nicht dafür gedacht.

Warum willst du immer noch die float umdrehen, sende die beiden words 
einfach in andere Reihenfolge.

Dafür braucht man keine Union, das sind 3 Zeilen fürs senden und noch 
mal 3 Zeilen fürs empfangen. Portabel und allgemein gültig.


Senden:

float f = 3.14f;

word[2] tmp;
memcpy( &tmp, &f, sizeof( float ) );
send( tmp[1] );
send( tmp[0] );

empfangen:

float f;
word[2] tmp;
read( tmp[1] );
read( tmp[0] );
memcpy(&f, &tmp sizeof( float ) );

[C-Anfänger (Gast)]

helfer schrieb:
> Wenn, dann so:

Du hast recht. Sorry!

Peter II schrieb:
> Dafür braucht man keine Union, das sind 3 Zeilen fürs senden und noch
> mal 3 Zeilen fürs empfangen. Portabel und allgemein gültig.

Du hast ja auch recht. Aber ich kannte die Union vorher nicht wirklich. 
Jetz möchte ich sie einfach verstehen.

Peter II schrieb:
> Standardkonform geht es mit Union nicht, sie ist nicht dafür gedacht.

Für was ist sie dann gedacht?

[Peter II (Gast)]

C-Anfänger schrieb:
> Für was ist sie dann gedacht?

um Speicher zu sparen.

Man sollte/darf nur die variabel auslesen die man vorher auch 
geschrieben hat.

Dann kann es noch Probleme bei Alignment gehen, auf einigen System muss 
float an gewissen Speicheradressen ausgerichtet sein, das geht dann bei 
einer Union nicht mehr.

[Peter D. (peda)]

Peter II schrieb:
> Warum willst du immer noch die float umdrehen, sende die beiden words
> einfach in andere Reihenfolge.

Üblicher Weise bastelt man erst ein komplettes Paket und übergibt der 
Sendefunktion nur den Pointer darauf. Es können ja mehrere Tasks 
gleichzeitg senden wollen.

[Peter II (Gast)]

Peter D. schrieb:
> Üblicher Weise bastelt man erst ein komplettes Paket und übergibt der
> Sendefunktion nur den Pointer darauf. Es können ja mehrere Tasks
> gleichzeitg senden wollen.

wenn man genug speicher hat ja, wenn man mehre stellen hat die Senden 
können muss mit sperren arbeiten.

Aber auch dann kann man es genau machen, statt Send() füllt man man sein 
puffer-byte-Array ab.