TMS320F280049C: Data alignment issues for breaking float value into byte chunks and for joining byte chunks into float value

Hi Arpan,

I just closed your previous post to avoid multiple posts of similar issue.  Please continue posting here.  After your fix from the other thread, can you share the MISRA C violation?

Thanks,

Joseph

As an update to the thread, the following code solved the alignment issues and is working as expected:

float fvar;
char * chunkdata;
chunkdata = (char *)&fvar;

uint16_t array_read[20] = {...};//initialized with some values
float32_t var;

chunkdata[0] = array_read[OFFSET] + (array_read[OFFSET+1] << 8);
chunkdata[1] = array_read[OFFSET+2] + (array_read[OFFSET+3] << 8);
var = *(float_t *)(&chunkdata[0]);

But it is violating MISRA guidelines. To test for MISRA, I created a separate CCS project with just main.c, which is as follows

/*
*/
/**
 * main.c
 */

#include <stdint.h>

void main(void);

void main(void)
{
    float fvar;
    char * chunkdata;
    chunkdata = (char *)&fvar;

    uint16_t array_read[4] = {1,2,3,4};
    float var;

    chunkdata[0] = array_read[0] + (array_read[1] << 8);
    chunkdata[1] = array_read[2] + (array_read[3] << 8);
    var = *(float *)(&chunkdata[0]);
}

The MISRA issues are as follows. The line numbering is verified:

Hi Arpan,

Using memcpy is a better solution for allocating space for the new float variable compared to the pointer assignment example that I provided as it violates MISRA C guidelines.  I have a concern though that you are still using 16-bit variable 'intermediate' to copy it back as a 'float_new' in the last memcpy statement as the 16-bit variable may not be properly aligned.

Here's a different version that uses just one float variable and copies the contents of that float variable into 32-bit int data which is the ieee754 equivalent using memcpy.  A 16-bit array holds the byte data, which can be used to hold the de constructed data from the 32-bit location or vise versa. 

    float floatdata;
    Uint32 intdata;
    Uint16 canbyte[4];

    floatdata = 3.1415926;

    memcpy(&intdata,&floatdata,sizeof(float));

    // de-construct 32-bit data into bytes
    canbyte[0]=intdata&0xff;
    canbyte[1]=(intdata>>8)&0xff;
    canbyte[2]=(intdata>>16)&0xff;
    canbyte[3]=(intdata>>24)&0xff;


    // group byte chunks into 32-bit number
    intdata=0;
    intdata=canbyte[0]+(canbyte[1]<<8)+(((canbyte[2])+(canbyte[3]<<8))*65536);

    floatdata=0;
    memcpy(&floatdata,&intdata,sizeof(float));

Regards,

Joseph

Hi Joseph,

According to me, in 
memcpy(&float_new, intermediate, sizeof(float32_t));
intermediate is a 16-bit variable. So read to it  by memcpy does not require aligned address. What do you think?

Hi Joseph,

So I will stick with the solution I have highlighted as resolved. Thanks a lot for your continuous help over the last 2 days.

Regards,
Arpan