C-Funktion zum Konvertieren von Float in Byte-Array

Ich versuche, eine Funktion zu erstellen, die eine Float-Variable akzeptiert und in ein Byte-Array konvertiert. Ich habe ein funktionierendes Code-Snippet gefunden, möchte es aber nach Möglichkeit in einer Funktion wiederverwenden.

Ich arbeite auch mit der Arduino-Umgebung, aber ich verstehe, dass sie die meisten C-Sprachen akzeptiert.

Derzeit funktioniert:

float_variable = 1.11;
byte bytes_array[4];

*((float *)bytes_array) = float_variable;

Was kann ich hier ändern, damit diese Funktion funktioniert?

float float_test = 1.11;
byte bytes[4];

// Calling the function
float2Bytes(&bytes,float_test);

// Function
void float2Bytes(byte* bytes_temp[4],float float_variable){ 
     *(float*)bytes_temp = float_variable;  
}

Ich bin nicht so vertraut mit Zeigern und so, aber ich habe das gelesen (schweben) verwendet Casting oder so etwas?

Jede Hilfe wäre sehr willkommen!

Prost

*BEARBEITEN: GELÖST

Hier ist meine letzte Funktion, die in Arduino für jeden funktioniert, der dies findet. Es gibt effizientere Lösungen in den Antworten unten, aber ich denke, das ist in Ordnung zu verstehen.

Funktion: Konvertiert die Eingabe-Float-Variable in ein Byte-Array

void float2Bytes(float val,byte* bytes_array){
  // Create union of shared memory space
  union {
    float float_variable;
    byte temp_array[4];
  } u;
  // Overite bytes of union with float variable
  u.float_variable = val;
  // Assign bytes to input array
  memcpy(bytes_array, u.temp_array, 4);
}

Aufruf der Funktion

float float_example = 1.11;
byte bytes[4];

float2Bytes(float_example,&bytes[0]);

Danke für die Hilfe aller, ich habe in den letzten 20 Minuten so viel über Zeiger und Verweise gelernt, Cheers Stack Overflow!

Am einfachsten ist es, eine Vereinigung zu bilden:

#include <stdio.h>

int main(void) {
  int ii;
  union {
    float a;
    unsigned char bytes[4];
  } thing;

  thing.a = 1.234;
  for (ii=0; ii<4; ii++) 
    printf ("byte %d is %02x\n", ii, thing.bytes[ii]);
  return 0;
}

Ausgabe:

byte 0 is b6
byte 1 is f3
byte 2 is 9d
byte 3 is 3f

Hinweis – es gibt keine Garantie für die Byte-Reihenfolge … sie hängt von Ihrer Maschinenarchitektur ab.

Damit Ihre Funktion funktioniert, gehen Sie wie folgt vor:

void float2Bytes(byte bytes_temp[4],float float_variable){ 
  union {
    float a;
    unsigned char bytes[4];
  } thing;
  thing.a = float_variable;
  memcpy(bytes_temp, thing.bytes, 4);
}

Oder um es wirklich zu hacken:

void float2Bytes(byte bytes_temp[4],float float_variable){ 
  memcpy(bytes_temp, (unsigned char*) (&float_variable), 4);
}

Hinweis – in beiden Fällen stelle ich sicher, dass die Daten an den als Eingabeparameter angegebenen Ort kopiert werden. Dies ist entscheidend, da lokale Variablen nach Ihrer Rückkehr nicht mehr existieren (obwohl Sie sie deklarieren könnten static, aber lass uns dir keine schlechten Gewohnheiten beibringen. Was ist, wenn die Funktion erneut aufgerufen wird…)

Hier ist eine Möglichkeit, das zu tun, was Sie wollen, die nicht kaputt geht, wenn Sie sich auf einem System mit einem anderen befinden Endianität von dem, auf dem du gerade bist:

byte* floatToByteArray(float f) {
    byte* ret = malloc(4 * sizeof(byte));
    unsigned int asInt = *((int*)&f);

    int i;
    for (i = 0; i < 4; i++) {
        ret[i] = (asInt >> 8 * i) & 0xFF;
    }

    return ret;
}

Sie können es hier in Aktion sehen: http://ideone.com/umY1bB

Das Problem bei den obigen Antworten ist, dass sie sich auf die zugrunde liegende Darstellung von verlassen floats: C gibt keine Garantie dafür, dass das höchstwertige Byte “erstes” im Speicher ist. Der Standard ermöglicht die Implementierung des zugrunde liegenden Systems floatWie auch immer es sich anfühlt — wenn Sie also Ihren Code auf einem System mit einer bestimmten Art von Endianness (Byte-Reihenfolge für numerische Typen im Speicher) testen, funktioniert er nicht mehr abhängig von der Art des Prozessors, auf dem Sie es ausführen.

Das ist ein wirklich böser, schwer zu behebender Fehler, den Sie nach Möglichkeit vermeiden sollten.

Ich würde empfehlen, es mit einer “Union” zu versuchen.

Schau dir diesen Beitrag an:

http://forum.arduino.cc/index.php?topic=158911.0

typedef union I2C_Packet_t{
 sensorData_t sensor;
 byte I2CPacket[sizeof(sensorData_t)];
};

In Ihrem Fall so etwas wie:

union {
  float float_variable;
  char bytes_array[4];
} my_union;

my_union.float_variable = 1.11;

Noch ein anderer Weg, ohne Gewerkschaften: (Annahme byte = unsigned char)

void floatToByte(byte* bytes, float f){

  int length = sizeof(float);

  for(int i = 0; i < length; i++){
    bytes[i] = ((byte*)&f)[i];
  }

}

das scheint auch zu funktionieren

#include <stddef.h>
#include <stdint.h>
#include <string.h>

float fval = 1.11;
size_t siz;
siz = sizeof(float);

uint8_t ures[siz];

memcpy (&ures, &fval, siz);

dann

float utof;
memcpy (&utof, &ures, siz);

auch für Doppel

double dval = 1.11;
siz = sizeof(double);

uint8_t ures[siz];

memcpy (&ures, &dval, siz);

dann

double utod;
memcpy (&utod, &ures, siz);

Obwohl die anderen Antworten zeigen, wie dies mit einer Union erreicht wird, können Sie dies verwenden, um die gewünschte Funktion wie folgt zu implementieren:

byte[] float2Bytes(float val)
{
    my_union *u = malloc(sizeof(my_union));
    u->float_variable = val;
    return u->bytes_array;
}

oder

void float2Bytes(byte* bytes_array, float val)
{
    my_union u;
    u.float_variable = val;
    memcpy(bytes_array, u.bytes_array, 4);
}

**conversion without memory reference** \
#define FLOAT_U32(x) ((const union {float f; uint32_t u;}) {.f = (x)}.u) // float->u32
#define U32_FLOAT(x) ((const union {float f; uint32_t u;}) {.u = (x)}.f) // u32->float

**usage example:**
float_t sensorVal = U32_FLOAT(eeprom_read_dword(&sensor));