Convert a 32 bits to float value
c, embedded, linux
Solution
You need to copy the bit pattern verbatim without invoking any implicit conversions. The simplest way to do that is to take the address of the data and reinterpret it as a pointer to the intermediate "carrier" type before dereferencing it.
Consider this:
float source_float = 1234.5678f ;
uint32_t transport_bits = *((uint32_t*)&source_float);
float destination_float = *((float*)&transport_bits);
The intermediate result in `transport_bits` is target dependent, in my test on x86, it is 0x449a522b, this being the bit representation of single precision float on that platform (floating point representation and endianness dependent).
Either way the result in `destination_float` is identical to `source_float` having been transported via the `uint32_t` `transport_bits`.
However this does require that the floating point representation of the originator is identical to that of the receiver which may not be a given. It is all a bit non-portable, The fact that your code does not work suggests perhaps that the representation does indeed differ between sender and receiver. Not only must the FP representation be identical but also the endianness. If they differ your code may have to do one or both of reorder the bits and calculate the floating point equivalent by extraction of exponent and mantissa. All so you nee to be sure that the transmission order of the bits is is the same order in which you are reassembling them. There are a number of opportunities to get this wrong.
Problem
I am working on a DSP processor to implement a BFSK frequency hopping mechanism using C on a Linux system. On the receiver part of the program, I am getting an input of a set of samples which I de-modulate using Goertzel algorithm to determine whether the received bit was a 0 or 1. Right now, I am able to detect the bits individually. But I have to return the data for processing in the form of a float array. So, I need to pack every set of 32 bits received to form a float value. Right I am doing something like : ``` uint32_t i,j,curBit,curBlk; unint32_t *outData; //this is intiallized to address of some pre-defined location in DSP memory float *output; for(i=0; i<num_os_bits; i++) //Loop for number of data bits { //Demodulate the data and set curBit=0x0000 or 0x8000 curBlk=curBlk>>1; curBlk=curBlk|curBit; bitsCounter+=1; if(i!=0 && (bitsCounter%32)==0) //32-bits processed, save the data in array { *(outData+j)=curBlk; j+=1; curBlk=0; } } output=(float *)outData; ``` Now, the values of the `output` array are just the values of `outData` array with 0s after the decimal point. example: if `output[i]=12345` the `outData[i]=12345.0000'. But while testing the program I am generating the sample test data of bits using an array of float `float data[] ={123.12456,45.789,297.0956};` So after the demodulation I am expecting the float array `output` to have a same values as `data` array. Is there some other method to convert 32-bits of data to a float. Should I store the received bits to a `char` array and then convert it to float.