Structure Pointer is not pointing correctly to raw byte array.

On the C2000 char and Uint16 are both 16-bit types, so char vh1 is going to be 16 bits (sizeof 1) and len[2] is going to give you 32 bits (sizeof 2).

Have you read what the compiler user guide has to say on the subject? It might help clear up some confusion. Chapter 6.4 covers data types and has a note that explains why sizeof behaves the way it does.

Compiler Users's Guide: http://www.ti.com/general/docs/lit/getliterature.tsp?baseLiteratureNumber=spru514&fileType=pdf

You can use bit fields to get the items in the struct to be truly 8-bits. Maybe something like this:

struct ethip_hdr {
    struct uip_eth_hdr ethhdr;
    Uint16 vhl:8,
    tos:8,
    len,
    ipid,
    ipoffset,
    ttl:8,
    proto:8;
    Uint16 ipchksum;
    Uint16 srcipaddr[2],
    destipaddr;
};

Whitney

Hi Whitney,

See attachment for memory information of "uip_buf" in detail.

From memory looks like, Address 0x0000C08C and 0x0000C08D are in sequence without any extra field with data 0x00.

Thanks,

Kalpesh.

Kalpesh,

That's what I was expecting it to look like. You have to remember that chars are 16 bits on the C2000, so what you have here is:

00FF 00FF 00FF 00FF 00FF 00FF 00B0 0083 00FE 006B 00BA 00E3 0008 0006

But the structure we've created is expecting:

FFFF FFFF FFFF B083 FE6B BAE3 0806

When you're filling the uip_buf, you could pack it as shown above by shifting every other byte received into the upper 8 bits of the char. Or you could take advantage of the __byte() intrinsic that's described in the compiler user guide. The consequence of this is that you'll have to make modifications to the stack almost anywhere pointer arithmetic or indexing into this buffer is being performed since in this scenario, two bytes have the same address.

Unfortunately, given that the architecture can't do 8-bit byte addressability, I don't think there's going to be a good way to get around having to make these changes to the stack.

Whitney

Whitney,

Great explanation, Thanks.

Let me clarify bit more,

Whitney Dewey said:

shifting every other byte received into the upper 8 bits of the char

That is good idea but for stack it is bad idea. Because when i try to access any field of "unsigned char" then it will not return what i expect.

E.g. :- If i fill major byte by every 2nd element of uip_buf, it will looks like : FFFF FFFF FFFF B083 FE6B BAE3 0806

When i try to access 1st six byte mac address then it will consume 12 byte of my payload.

CONCLUSION : By this method i can access 2 byte value perfectly but it will create problem with 1 byte value.

Whitney Dewey said:

Or you could take advantage of the __byte() intrinsic that's described in the compiler user guide.

Since two byte has the same address. That is the real problem.

So my concern is,

Can't we do something special which can resolve problem of "two byte has same address" at top level and it will behave as normal standard controller for whole other code?

And one more doubt, Is there any special reason behind this logic(two byte has same address)?

Thanks,

Kalpesh.

Hi Whitney,

Whitney Dewey said:

With #1,

Yes exactly, Right now i had change code almost at every place where data type is Uint16 in structure.

And after broke type it look like,

        typeH = 0x08, typeL = 0x00, typeH1 = 0x06; typeL1 = 0x00

And then i am integrate them with,

type = BUF->typeH << 8 | BUF->typeH1; // type = 0x0806

Whitney Dewey said:

With #2

You are telling to fill array's every most byte with next consecutive byte.

No doubt i don't need to use extra Shift and OR of bytes. But the problem is We can't use address of bit field(Compiler is not allowed and that is obvious) so we need to use __byte and again for this i need to change code where i had user pointer to point data(Almost everywhere!).

And again thanks for this everything.

Thanks,

Kalpesh