speicherzellen verschieden interpretieren

franz Gast #1708565
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Daniel V. #1708574
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #1708578
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
franz Gast #1708595
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #1708610
Lesenswert?
• ▲
▼ 
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.

1
uint32_t Get32BitValue( uint8_t Index )

2
{

3
  return *(uint32_t*)&speicher[ sizeof(uint32_t) * Index];

4
}

5


6
uint16_t Get16BitValue( uint8_t Index )

7
{

8
  return speicher[ Index + 10 * sizeof( uint32_t ) ];

9
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren