speicherzellen verschieden interpretieren

[franz (Gast)]

Hallo,

ich habe ein kleines Organisationsproblem bzw fehlt mir Verständnis um 
folgende Idee umzusetzen:

In meinem C-Programm habe ich ein Array angelegt mit 80 Zellen á 16 Bit:

uint16_t speicher[80]; angenommen im controller heisst die startadresse 
0x00.

die Adresse des 1. arrayelementes ist dann 0x00. (es erstreckt sich aber 
auf 2 8-bit-register, deshalb ist
die Adresse des 2. arrayelementes dann 0x02.

nun will ich in dem array sowohl 16-bit als auch 32-bit zahlen ablegen.
das koennte ich machen, indem ich einem 16bit-arrayelement das high-byte 
und dann dem nächsten das low-byte zuweise.

würde ich danach noch eine 16bitzahl ablegen wollen, würde ich das 3. 
arrayelement beschreiben.

die zuordnung meiner datentypen ist fest: die ersten 10 werte sind 
32bit, die nächsten 20 16bit.

nun ist meine frage, ob es möglich wäre, vielleicht mit pointern 
folgendes zu veranstalten:

uint32_t messwert0 soll auf arrayelement speicher[0] und speicher[1] 
zeigen.

uint32_t messwert1 soll auf arrayelement speicher[2] und speicher[3] 
zeigen.

...
uint16_t messwert11 soll auf arrayelement speicher[22] zeigen
uint16_t messwert11 soll auf arrayelement speicher[23] zeigen
...

also im prinzip will ich auf verschiedene weisen auf die speicherzellen 
zugreifen. ich koennte mir vorstellen, dass das irgendwie mit pointern 
geht, aber dann muss ich ja in jedem die adresse speichern, was ja auch 
wieder speicherplatz verbraucht, oder?
mhm, irgendwie komme ich nicht ganz klar damit, ich hoffe, ihr versteht, 
was ich meine ... und koennt mir helfen.
vielen Dank schonmal
Franz

[ich (Gast)]

mach dir ein struct, in dem 2 Arrays sind. Ein Array mit den 16-Bittern, 
eins mit den 32 Bittern

[Daniel V. (danvet)]

warum legst du dir keine Struktur an (struct), auf die du ganz bequem 
zugreifst? Zeigerarithmetik wird schnell unübersichtlich und 
fehleranfällig.

struct{
uint32 erste_32;
uint32 zweite_32;
...
uint32 letzte_32;

uint16 erste_16;
...
uint16 letzte_16;
}

edit: uups, war zu langsam

[Karl H. (kbuchegg)]

franz schrieb:

> die zuordnung meiner datentypen ist fest: die ersten 10 werte sind
> 32bit, die nächsten 20 16bit.

Wenn du das sowieso hast, warum dann der ganze Aufwand?
Mach dir 2 Arrays und all deine Probleme sind gelöst

> nun ist meine frage, ob es möglich wäre, vielleicht mit pointern
> folgendes zu veranstalten:

Möglich ist das schon. Aber extrem umständlich

> zugreifen. ich koennte mir vorstellen, dass das irgendwie mit pointern
> geht, aber dann muss ich ja in jedem die adresse speichern, was ja auch
> wieder speicherplatz verbraucht, oder?

Im Prinzip ja.
Aber du musst dir den Pointer ja nur dann erzeugen, wenn du ihn 
tatsächlich brauchst.

Aber wie gesagt: Das einfachste wäre es, ganz einfach 2 Arrays zu 
benutzen. Solange es keinen guten Grund gibt, das nicht zu tun, ist das 
der Weg den du gehen solltest.

[na (Gast)]

struct und union könnten Dir helfen.

[franz (Gast)]

wow,
danke fuer die schnellen Antworten, ich werd mir gleich mal struct und 
union ansehen.

Wie ich dahin kam ist eigentlich schnell erklärt:
Zur Erstellung eines Modbus-Slaves habe ich mir in meinem Controller ein 
16-bit Speicherarray erstellt, der aus Master fragt ja auch immer 
16-bit-Worte ab (und wenn er 32bit braucht, fragt er halt 2 16-bit-Worte 
ab).

Soweit geht das alles prima, vom Controller kann gelesen und auf ihn 
auch geschrieben werden. Also die seite steht.

Nun wollte ich mich daran machen, vom Controller aus die register zu 
beschreiben und bin auf das Problem gestossen. Ich wollte die 
Schreiberei mit low- und highbyte (fuer die als 32-bit interpretierten 
Zellen) sparen und versuchen von der einen Seite die 
16-bit-array-struktur zu erhalten und vom vom Controller aus auf die 
selben speicher-Register als Variablen zugreifen, die entweder 16 oder 
32 bit breit sind.

Na ich schau mal und melde mich bei Problemen nochmal.

:) schönen Tag noch

[Karl H. (kbuchegg)]

Da du weißt, dass die ersten 20 deiner 'Zellen' für 10 Stück uint32_t 
reserviert sind und die 16 Bit Werte erst dahinter anfangen, kannst du 
ja auch Zugriffsfunktionen schreiben.

uint32_t Get32BitValue( uint8_t Index )
{
  return *(uint32_t*)&speicher[ sizeof(uint32_t) * Index];
}

uint16_t Get16BitValue( uint8_t Index )
{
  return speicher[ Index + 10 * sizeof( uint32_t ) ];
}