www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik speicherzellen verschieden interpretieren


Autor: franz (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: ich (Gast)
Datum:

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

Autor: Daniel V. (danvet)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: na (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
struct und union könnten Dir helfen.

Autor: franz (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht 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.
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 ) ];
}

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.