Umwandlung Wert in 4 Byte Gleitkommazahl (KNX)

[Matthias (Gast)]

Im KNX-Protokoll werden Leistungen als 4 Byte Gleitkommazahl übertragen. 
Mir ist allerdings nicht ganz klar, wie ich eine Zahl (z.B. Integer) in 
eine (KNX-)Gleitkommazahl mit 4 Byte umrechnen muß.

Ein Quellcode in C wäre super. Ich habe gegoogelt, aber nicht wirklich 
gute Treffer gelandet.

[Dieter H. (kyblord)]

Matthias schrieb:
> Im KNX-Protokoll werden Leistungen als 4 Byte Gleitkommazahl
> übertragen.
> Mir ist allerdings nicht ganz klar, wie ich eine Zahl (z.B. Integer) in
> eine (KNX-)Gleitkommazahl mit 4 Byte umrechnen muß.
>
> Ein Quellcode in C wäre super. Ich habe gegoogelt, aber nicht wirklich
> gute Treffer gelandet.

die frage ist, wie werden gleitkommazahlen in KNX repräsentiert?
Wenn es einfach nur das IEEE754 gleitkommaformat ist, dann solltest du 
einfach mal auf wikipedia nachlesen. Du musst einen Exponenten, Mantisse 
und Vorzeichenbit setzen. Wie lange diese Felder sind, regelt der 
Standard.

https://www.inf.hs-flensburg.de/lang/informatik/ieee-format.htm

Poste mal eine Beispielkommazahl und die zugehörigen Bits. Dann kann man 
vielleicht auf das Format schließen.

sonst gibt es doch 
http://www.knx-gebaeudesysteme.de/sto_g/_All/MANUALS/ABAS_121/FR/05_function_elements/ConverterElement/index.html 
?

[Ingo Less (Gast)]

Ich habe das so gelöst, habe aber keine Ahnung ob das bei dir 
funktioniert:

// Scale Values
  uint32_t CO2_Temp = (uint32_t)((((uint32_t)SensorRawData[0]) << 24) |
            (((uint32_t)SensorRawData[1]) << 16) |
            (((uint32_t)SensorRawData[3]) << 8) |
            ((uint32_t)SensorRawData[4]));
  memcpy(&SCD30_CO2_Concentration, &CO2_Temp, sizeof SCD30_CO2_Concentration);

Der Code setzt aus 4-Byte ein float zusammen.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Bei passender Bytereihenfolge/Endian reicht es auch, einen Pointer auf 
das erste Element zu setzen und den auf (float) zu casten:

char cval[4];
:
:
float fval = *(float*)cval;

[Matthias (Gast)]

1000 Watt entspricht bei der KNX-Übertragung dem Wert 0x447A0000.

Auf https://www.binaryconvert.com/convert_float.html kann man online die 
Zahl konvertieren. Da kommt auch genau das Ergebnis raus. Jetzt muß ich 
nur noch einen Quellcode in C dazu finden.

http://www.knx-gebaeudesysteme.de/sto_g/_All/MANUALS/ABAS_121/DE/05_function_elements/ConverterElement/index.html 
hatte ich auch gefunden, aber das scheint irgend ein Modul einer 
Steuerung zu sein.

Quellcode von Ingo Less habe ich nicht kapiert.
Quellcode von Lothar M geht nicht. Bringt als Ergebnis 0x3EB raus.

[Dergute W. (derguteweka)]

Moin,

Naechster Versuch:

#include <stdio.h>
#include <math.h>
int main() {
float f=1000.0;
printf("%02x" ,((unsigned char*)&f)[3]);
printf("%02x" ,((unsigned char*)&f)[2]);
printf("%02x" ,((unsigned char*)&f)[1]);
printf("%02x" ,((unsigned char*)&f)[0]);

#if 0
((unsigned char*)&f)[0] = 0xde;
((unsigned char*)&f)[1] = 0xad;
((unsigned char*)&f)[2] = 0xbe;
((unsigned char*)&f)[3] = 0xef;
#endif
printf("\n%f\n",f);
}

Aufm PC kommt raus:
$ ./a.exe
447a0000
1000.000000

Gruss
WK

[Martin (Gast)]

https://nwnlexicon.com/index.php/IntToFloat

[Matthias (Gast)]

Printf ist soweit ich weiß, ziemlich rechenintensiv für einen 
Mikrocontroller. Ich habe das Ganze bereits für 16 Bit und es 
funktioniert:

unsigned int int_to_float16(int iValue)
{
unsigned int uiExponent;  // 4 Bit
int iMantisse;        // 11 Bit
unsigned char ucVorzeichen;  // 1 Bit
unsigned int uiReturnvalue;  // 16 Bit

uiExponent = 0;        // Exponent löschen
iMantisse = iValue;      // übergebener Wert wurde bereits mit 100 Miltipliziert übergeben (da in KNX mit Faktor 0,01 übergeben wird)

// prüfen, wie oft Mantisse durch zwei geteilt werden muß, damit sie in der Bereich -2048 / +2047 paßt (=> Exponent berechnen)
while( (iMantisse <-2048) || (iMantisse > 2047) )
  {
  iMantisse = iMantisse / 2;  // Wert halbieren
  uiExponent++;        // Exponent erhöhen
  }


// bei negativer Zahl ist Umrechnung Mantisse in Zweierkomplement erforderlich
if(iMantisse < 0)  // negative Zahl?
  {
  iMantisse = -iMantisse;            // positive Zahl draus machen
  iMantisse = ~iMantisse;            // Bits invertieren (Einerkomplement)
  iMantisse++;                // 1 dazuaddieren (Zweierkomplement)
  iMantisse = iMantisse & 0b0000011111111111;  // die Bits oberhalb der Mantisse ausmaskieren
  ucVorzeichen = KNX_VORZEICHEN_MINUS;    // Merker setzen
    }
else
  ucVorzeichen = KNX_VORZEICHEN_PLUS;  // Merker setzen
    



if(ucVorzeichen == KNX_VORZEICHEN_MINUS)  // Vorzeichen negativ?
  uiReturnvalue = 0b1000000000000000;  // Negativ-Bit setzen
else
  uiReturnvalue = 0b0000000000000000;  // Negativ-Bit löschen
    
uiReturnvalue = uiReturnvalue | (uiExponent << 11);  // Exponent-Bits setzen
uiReturnvalue = uiReturnvalue +iMantisse;      // Mantisse dazu


return (uiReturnvalue);
}

Ich benötige es nun für 32 Bit.

[W.S. (Gast)]

Matthias schrieb:
> Jetzt muß ich
> nur noch einen Quellcode in C dazu finden.

Nö. Du solltest lieber das Prinzip verstehen lernen.

Also, zumeist besteht eine Gleitkommazahl aus dem Vorzeichen (1 Bit), 
dem Exponenten (8 Bit) und der Mantisse (23 Bit). Jetzt fragst du dich 
vielleicht, warum nicht 24 Bit Mantisse? Nun, das hängt an der 
Normierung der Mantisse, die solange linksverschoben wird, bis das MSB 
gesetzt ist. Der Exponent wird dabei angepaßt. Je nach Implementation 
kann die Mantisse damit
- von 0.5 bis 1 (- 1 LSB)
oder
- von 1.0 bis 2 (- 1 LSB)
gehen. Rein rechentechnisch ist das egal. Es hat nur mit dem Wert des 
Exponenten zu tun.

Da nun das MSB immer gesetzt ist, braucht man es nicht in der Zahl zu 
merken, sondern kann an dessen Stelle das Vorzeichen setzen.

W.S.

[Dergute W. (derguteweka)]

Moin,

W.S. schrieb:
> Du solltest lieber das Prinzip verstehen lernen.

Yupp. Und das Prinzip ist: Bloss nicht selber in 
Floatingpointverarbeitung rumruehren, wenns nicht unbedingt sein muss.
Das den Compiler machen lassen. Einfach aussenrum casten.
Die printfs in meinem Code sind nur dazu da, dass man "was sieht" in der 
console. Mit der eigentlichen Wandlung haben die nix zu tun.

Gruss
WK

[Matthias (Gast)]

Lothar M. schrieb:
> Bei passender Bytereihenfolge/Endian reicht es auch, einen Pointer auf
> das erste Element zu setzen und den auf (float) zu casten:

Habe nun eine Funktion für das Wandeln geschrieben. Geht sehr einfach.

float long_to_float32(long lValue)
  {
  float uiReturnvalue;

  uiReturnvalue = lValue;

  return (uiReturnvalue);
  }

[Matthias (Gast)]

So einfach geht es doch nicht. Meine Funktion zur KNX-Übertragung 
verwendet für die 4 Datenbyte grundsätzlich unsigned long. Daher wird 
das Format vom Compiler wieder zurück gewandelt. Anstelle der 0x447A0000 
(1000 als float32) werden 0x000003E8 (1000 als unsigned long) 
übertragen.

Wie kann ich 0x447A0000 float in 0x447A0000 unsigned long wandeln?
Habe schon versucht, den Float32 Wert in 4 einzelne Bytes zu zerlegen, 
um die dann wieder als unsigned long Wert wieder zusammen zu bauen. Aber 
der Compiler will das Zerlegen nicht machen:

float fTemp;
char element[4];
element[0] = (fTemp & 0x000000FF) >> 0;
element[1] = (fTemp & 0x0000FF00) >> 8;
element[2] = (fTemp & 0x0000FF00) >> 16;
element[3] = (fTemp & 0x0000FF00) >> 24;

Die Profi-Programmierer werden schon die Kriese bei der Frage 
bekommen...

[Uwe (Gast)]

Lothar M. schrieb:
> Bei passender Bytereihenfolge/Endian reicht es auch, einen Pointer auf
> das erste Element zu setzen und den auf (float) zu casten:char cval[4];
> :
> :
> float fval = *(float*)cval;

[Dergute W. (derguteweka)]

Moin,

Matthias schrieb:
> So einfach geht es doch nicht.
Ach.

memcpy(element, &float, 4);

 :-)

Gruss
WK

[Matthias (Gast)]

Danke. es geht nun!

unsigned long long_to_float32(long lValue)
{
char element[4];
float fTemp;
unsigned long ulReturnvalue;

fTemp = lValue;      // Wandlung in Float

memcpy(element, &fTemp, 4);  // die 4 Byte in Array kopieren

ulReturnvalue = 0x1000000*(unsigned long)element[3] + 0x10000*(unsigned long)element[2] + 0x100*(unsigned long)element[1] + (unsigned long)element[0];

return (ulReturnvalue);
}

[Jemand (Gast)]

Lothar M. schrieb:
> Bei passender Bytereihenfolge/Endian reicht es auch, einen Pointer
> auf
> das erste Element zu setzen und den auf (float) zu casten:char cval[4];
> :
> :
> float fval = *(float*)cval;

Äußerst unsportlich, dabei nicht auf den Haken mit strict aliasing 
hizuweisen.

[W.S. (Gast)]

Dergute W. schrieb:
> Yupp. Und das Prinzip ist: Bloss nicht selber in
> Floatingpointverarbeitung rumruehren, wenns nicht unbedingt sein muss.

Und das verstehst du als "Verstehen des Prinzips"?

Hmm..
Naja, wenn ich mir all die z.T. abstrusen Verrenkungen anschaue, die 
diverse C-Programmierer hier gepostet haben, um irgendwelche int oder 
long Zahlen nach float zu wandeln (ohne das anscheinend spezielle 
KNX-Gleitkommaformat zu kennen), dann graust es mich.

Ich hätte hier noch eine selbstgeschriebene kleine GK-Arithmetik incl. 
Ausgabekonverter für die PIC16 auf Lager - selbstverständlich in 
Assembler geschrieben, aber die habe ich bereits vor Zeiten hier mal in 
einem anderen Projekt gepostet.

W.S.

[Dergute W. (derguteweka)]

Moin,

W.S. schrieb:
> (ohne das anscheinend spezielle
> KNX-Gleitkommaformat zu kennen), dann graust es mich.

Was ist denn daran speziell? Wenn ich nach KNX und 32bit float google, 
dann springt mich von ueberall IEEE754 an...

Gruss
WK

[W.S. (Gast)]

Dergute W. schrieb:
> Was ist denn daran speziell?

Weiß ich nicht, hab mich dafür noch nicht interessiert.

Ansonsten ist das IEEE754 Format recht einfach zu verstehen, siehe Bild. 
Was mich damals bei den PIC16 daran gestört hatte, war die notwendige 
Schieberei mit dem Exponenten, die sich bei den PICs nicht besonders gut 
macht - und die für Konvertierungen auf dem PIC16 ungünstige 
Mantissengröße 1.0 bis 1.999usw. Von daher hatte ich das Vorzeichenbit 
direkt an die Stelle des MSB der Mantisse gesetzt und den Wertebereich 
der Mantisse auf 0.5 bis 0.999usw. gesetzt.

W.S.

[Dieter H. (kyblord)]

Dergute W. schrieb:
> Moin,
>
> Matthias schrieb:
>> So einfach geht es doch nicht.
> Ach.
> memcpy(element, &float, 4);
>  :-)
>
> Gruss
> WK

tja, wenn man nur von vorne rein wüsste was der TO machen will^^