topic Re: Layering of Structs... in LPCXpresso IDE

Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:29 GMT

Content originally posted in LPCWare by Wenzu on Sat Jun 18 14:45:33 MST 2011
Trying to figure out why layering of two structs on top of the same memory space do not result in what I'm expecting....

struct AAA
{
[COLOR=Red]int16_t[/COLOR] aaa;
[COLOR=Red]int16_t[/COLOR] bbb;
[COLOR=Red]int16_t[/COLOR] ccc;
} PACKED ; 

struct AAA   mylistA  __attribute__((at(0x10007000)));

struct BBB
{
[COLOR=Lime]int8_t[/COLOR] aaa_L;
[COLOR=Lime]int8_t[/COLOR] aaa_H;
[COLOR=Lime]int8_t[/COLOR] bbb_L;
[COLOR=Lime]int8_t[/COLOR] bbb_H;
[COLOR=Lime]int8_t[/COLOR] ccc_L;
[COLOR=Lime]int8_t[/COLOR] ccc_H;
} PACKED ; 

struct BBB mylistB  __attribute__((at(0x10007000)));

mylistA.aaa = 100
mylistA.bbb = 101
mylistA.ccc = 102

sprintf(mybuffer, "%i,%i,%i, mylistA.aaa, mylistA.bbb, mylistA.ccc);
// this prints out the correct values = 100,101,102 //

// However //

sprintf(mybuffer, "%i,%i,%i,%i,%i,%i, mylistB.aaa_L, mylistB.aaa_H, mylistB.bbb_L, mylistB.bbb_H, 
mylistB.ccc_L, mylistB.ccc_H);
                                 
// this prints out  = 0,0,0,0,0,0 //

Any insight what I may be doing wrong ??

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:30 GMT

Content originally posted in LPCWare by Ex-Zero on Sat Jun 18 15:07:17 MST 2011
Isn't the compiler complaining :confused::confused:

Quote:

../src/main.c:48:8: warning: 'at' attribute directive ignored

And why don't you just use good old 'union' ?

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:30 GMT

Content originally posted in LPCWare by Wenzu on Sat Jun 18 15:28:00 MST 2011
I used struct because ( AFAIK) struct packs byte after byte ( I also enforce Packed ), while Union allocates memory space, but does not guarantee contiguous ???

Need to look up the use of Unions.... any LPCexpresso example comes to mind ??

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:31 GMT

Content originally posted in LPCWare by Ex-Zero on Sat Jun 18 15:39:54 MST 2011
LPC17xx.h :eek::eek:

/*------------- General Purpose Input/Output (GPIO) --------------------------*/
typedef struct
{
  union {
    __IO uint32_t FIODIR;
    struct {
      __IO uint16_t FIODIRL;
      __IO uint16_t FIODIRH;
    };
    struct {
      __IO uint8_t  FIODIR0;
      __IO uint8_t  FIODIR1;
      __IO uint8_t  FIODIR2;
      __IO uint8_t  FIODIR3;
    };
  };
  uint32_t RESERVED0[3];
  union {
    __IO uint32_t FIOMASK;
    struct {
      __IO uint16_t FIOMASKL;
      __IO uint16_t FIOMASKH;
    };
    struct {
      __IO uint8_t  FIOMASK0;
      __IO uint8_t  FIOMASK1;
      __IO uint8_t  FIOMASK2;
      __IO uint8_t  FIOMASK3;
    };
  };
  union {
    __IO uint32_t FIOPIN;
    struct {
      __IO uint16_t FIOPINL;
      __IO uint16_t FIOPINH;
    };
    struct {
      __IO uint8_t  FIOPIN0;
      __IO uint8_t  FIOPIN1;
      __IO uint8_t  FIOPIN2;
      __IO uint8_t  FIOPIN3;
    };
  };
  union {
    __IO uint32_t FIOSET;
    struct {
      __IO uint16_t FIOSETL;
      __IO uint16_t FIOSETH;
    };
    struct {
      __IO uint8_t  FIOSET0;
      __IO uint8_t  FIOSET1;
      __IO uint8_t  FIOSET2;
      __IO uint8_t  FIOSET3;
    };
  };
  union {
    __O  uint32_t FIOCLR;
    struct {
      __O  uint16_t FIOCLRL;
      __O  uint16_t FIOCLRH;
    };
    struct {
      __O  uint8_t  FIOCLR0;
      __O  uint8_t  FIOCLR1;
      __O  uint8_t  FIOCLR2;
      __O  uint8_t  FIOCLR3;
    };
  };
} LPC_GPIO_TypeDef;

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:32 GMT

Content originally posted in LPCWare by Wenzu on Sat Jun 18 15:46:16 MST 2011
Oh Crap :eek::eek: !!! Thanks Zero !!

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:33 GMT

Content originally posted in LPCWare by Wenzu on Sun Jun 19 04:50:02 MST 2011
Oh No!!... after many attempts at searching, reading and trying, I cannot configure well the union with structs. ( a first time for everything)

I know I may be abusing :o:o... but can you just outline the proper syntax of laying down the struct and union?

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:33 GMT

Content originally posted in LPCWare by Ex-Zero on Sun Jun 19 05:18:49 MST 2011

Quote:

...after many attempts...

Come on, that's a 5 minutes copy and paste job :confused::confused:

Define structure:

typedef struct
{
 union                                     //start union
 {
  volatile int16_t my_integer;
  struct                                //start byte struct
  {
   volatile uint8_t my_byte_Lo;
   volatile uint8_t my_byte_Hi;
  };                                    //end byte struct
 };                                      //end union
} my_funny_struct_TypeDef;

and use it:

 my_funny_struct_TypeDef my_funny_struct;
 my_funny_struct.my_integer = 0xABCD;

That's a simple structure, should be described in your (online) C Book like:

http://publications.gbdirect.co.uk/c_book/chapter6/structures.html

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:34 GMT

Content originally posted in LPCWare by Wenzu on Sun Jun 19 06:04:17 MST 2011
Hi Zero,

Many thanks for pointing me to gbdirect. Its very resourceful.

Quote:
...after many attempts...

Unfortunately its very true.... not just a copy paste in 5 minutes... but literally many hours of trying to find a solution... wiki, retrying, searching, heartbreak, pulling hair.....

Ok.. finally I have the union working....
When I was trying to address the bytes of the union, I was not using the full address call with all the dots in between the fields.

Once again, thanks Zero.
Now I've learnt something new and very useful.
Your posts, have also helped me lose less hair :D
One more beer for you !!!

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:35 GMT

Content originally posted in LPCWare by Wenzu on Sun Jun 19 16:42:36 MST 2011
Turns out that with unions, it will be really inconvenient to code.

Is there any way that what I wanted to do in the first post, can be done in an efficient manner ??
By efficient, I mean 'sanity wise while coding' :eek::eek:,
without having to remember, or look for each different field for each variable I want to map directly with the n.bytes that make up each variable.

In the meantime, I found out that the attribute __at does not work, the compiler merrily passing to the next available location.... in the first example posted... the bytes were starting at location
0x10007006
and that is why they were appearing as having value zero.

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:35 GMT

Content originally posted in LPCWare by CodeRedSupport on Sun Jun 19 23:58:54 MST 2011

The sane way to do this is to use unions. You appear to be trying to do exactly what unions are designed to do, so I can't see why you think that this is inefficient.

Quote:

In the meantime, I found out that the attribute __at does not work, the compiler merrily passing to the next available location.... in the first example posted... the bytes were starting at location
0x10007006
and that is why they were appearing as having value zero.

The[I] at[/I] attribute is not supported within LPCXpresso IDE. If you want to force a variable to be at a specific address, you typically need to place it in its own section, then place that section manually within your linker script. For more details see:

http://support.code-red-tech.com/CodeRedWiki/PlacingData
http://support.code-red-tech.com/CodeRedWiki/OwnLinkScripts
http://support.code-red-tech.com/CodeRedWiki/EnhancedManagedLinkScripts

Note that if you do decide to make life really difficult for yourself and use "overlapping structs", then you are also probably going to have to look at using the OVERLAY attribute in your linker scripts.

Regards,
CodeRedSupport

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:36 GMT

Content originally posted in LPCWare by TheFallGuy on Mon Jun 20 02:53:25 MST 2011

Quote: Wenzu
Turns out that with unions, it will be really inconvenient to code.

Is there any way that what I wanted to do in the first post, can be done in an efficient manner ??
By efficient, I mean 'sanity wise while coding' :eek::eek:,
without having to remember, or look for each different field for each variable I want to map directly with the n.bytes that make up each variable.

In the meantime, I found out that the attribute __at does not work, the compiler merrily passing to the next available location.... in the first example posted... the bytes were starting at location
0x10007006
and that is why they were appearing as having value zero.

Can you explain what it is that you think is inefficient? Give us some examples so we can see what you are trying to do and why you think it is inefficient.

the __at attribute is an compiler vendor specific extension and is not supported by GCC.

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:36 GMT

Content originally posted in LPCWare by Wenzu on Mon Jun 20 03:49:54 MST 2011
@FallGuy - Exactly, the __at is not supported by gcc.
@CodeRed - Thanks a mill' for your reply.

Quote:
Give us some examples so we can see what you are trying to do and why you think it is inefficient.

I regret..my statement was bombastic, and reflects on my inexperience ( hobbyist with no formal training in programming ). To explain better, my 'inefficient' tag pertains only to a specific need that I have, which probably, the way to achieve it out of the struct is not evident to me at the moment.

Here's what I done before, on other compilers, on much less powerful processors.

[LIST]
[*]Create an array of bytes that covers( plus some extra) all my variable types packed together
[*]use friendly names for my working variables, and map them manually over the byte array
[*]Create a byte array that starts and ends where my working variables are located .. (intended to be transmitted fast and frequently to my GUI)
[/LIST]
The code example is already given in the first post of this thread. The hi-Byte and lo-Byte are my final requirement.
The cherry on the cake, is to be able to use friendly names for variables, instead of structure.X.Y.Z

What method can I use to be able to have access to this single byte copy to the main data structure, that can scan incrementally through all the struct ??
If I know the starting address, is there a function ( perhaps ASM ??) to be able to increment memory location ?

Hope it is a tad clearer now! THANKS !!

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:37 GMT

Content originally posted in LPCWare by TheFallGuy on Mon Jun 20 06:08:08 MST 2011
I don't really understand what your problem is, but how about (something like this)

ttypedef struct {
    int word1 ;
    int word2 ;
} __PACKED struct1 ;

typedef struct {
    unsigned char array[8];
} __PACKED struct2 ;

union {
    struct1 s1;
    struct2 s2;
    struct {
        int word3 ;
        int word4 ;
    }__PACKED;
} * union1;

#define word1 union1->s1.word1
#define array union1->s2.array
...
   word1 = 0 ; // use macro to access word1
    array[0] = 1 ; //use macro to access array elements
    union1->word3 = 2 ; // anonymous structure within union works like this

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:38 GMT

Content originally posted in LPCWare by Ex-Zero on Mon Jun 20 06:45:00 MST 2011
Is there someone out there, who is reading manuals or Wikis?

http://support.code-red-tech.com/CodeRedWiki/PackedStructs

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:38 GMT

Content originally posted in LPCWare by Wenzu on Mon Jun 20 07:45:53 MST 2011

Quote:
Is there someone out there, who is reading manuals or Wikis?

Of Course Zero.

Packed... was listed in my first example in the begging of this thread.

From the PackedStructs - CodeRed

Quote:
there are some circumstances where you may need to make use of it - for example for accessing data coming in from peripherals.

Exactly my point..

....but I do not understand why the performance overhead...

Earlier links from Code Red - Thanks.. V.interesting... ( but scripts are beyond my understanding.. for now )

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:39 GMT

Content originally posted in LPCWare by Wenzu on Mon Jun 20 10:50:50 MST 2011
@TheFallGuy - Thanks for your contribution.

Logically, it seems to do exactly what I was initially asking for... layer two structs over each other.

So.. hard as I am to understand my_funny_struct_logic, ( :) ) , it's almost[I] exactly[/I] what I'm after...

One thing left to solve.. the code is now throwing a Hardfault_Handler.
When I check the registers, I can only see the address of pointer union1. ( 0x10000202 )
All variables that are being used in the struct and union disappear ( perhaps because they are being #define[I]d[/I] ) ??

Hmmm....
If I remove the union, everything works fine ( of course not addressing the bytes ).

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:40 GMT

Content originally posted in LPCWare by Ex-Zero on Mon Jun 20 11:14:13 MST 2011
1. The sample above is using a pointer. Do you know what that is ?

2. The sample above is no C-P sample. As mentioned above syntax '__packed' is not working and therefore destroys your anonymous union :eek:

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:40 GMT

Content originally posted in LPCWare by Wenzu on Mon Jun 20 11:34:09 MST 2011
Hi Zero, Thanks for popping by.
I love your replies ...:o

Yes.. So.. a Pointer is the number on the lottery ticket you have just purchased.
The contents of the pigeon hole that has the bounty have nothing to do with your ticket.
But when the draw comes up, if your pointer matches that on the winning drawn number you see on the screen, then you have access to the contents of the pigeon hole. How 'bout that ??

Now... what is C-P ??

I've also tried without __Packed.. still the same hardfault error.

Isn't __packed, supposed to guarantee that there will be no empty pigeon holes ,
...so that if your ticket has that unlucky number that is'skipped' in the 'non-packed' stack, then you wouldn't be fighting with the lottery organizer that he tricked you into buying a false ticket ??

:D:D

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:41 GMT

Content originally posted in LPCWare by Ex-Zero on Mon Jun 20 11:45:27 MST 2011

Quote:

I love your replies...

OK, then I'll repeat them:

Quote:

Is there someone out there, who is reading manuals or Wikis?

http://support.code-red-tech.com/Cod.../PackedStructs

There's described the correct syntax: __attribute__((packed)) :eek::eek:

Are you using this syntax?

C-P is what you are doing: Copy and paste programming:

http://en.wikipedia.org/wiki/Copy_and_paste_programming

Re: Layering of Structs...

lpcware — Thu, 16 Jun 2016 02:35:42 GMT

Content originally posted in LPCWare by Wenzu on Mon Jun 20 12:10:30 MST 2011
C-P ( thanks for the wiki link -> interesting reading ). The pejorative connotation is not what I'm doing.

Of course, in [I][B]my_funny_struct_logic.h[/B][/I] file

, I am using

#define __PACKED __attribute__((__packed__))

since the code example on Page 1.

Zero...what beer r u drinking ?? Must be more bitter than usual today .. is it ??