Dynamische Speicherverwaltung

[Peter L. (louben3010)]

Hallo,
ich arbeite mit einem ATmega644 und möchte gerne eine dynamische 
Speicherverealtung auf dem SRAM von 4Kb implementieren.
Die Frage jedoch ist, wie ich gezielt werde im Speicher schreiben kann?
Es soll einen Funktion geben, die auf eine gegebene Adresse einen 
bestimmten Wert schreiben soll.
Leider kann ich ja nicht einfach schreiben:

0x0012=4;

Außerdem möchte ich Werte an speziellen Adressen auslesen lassen.
Meine Idee bisher war, einen Pointer zu initialisieren, dem diese 
Adresse zu geben und dann einfach mit * zu dereferenzieren. Das scheint 
jedoch nicht zu funktionieren.

 //typedefs in der Header Datei:
//typedef uint16_t MemoryAdress
//typedef uint8_t MemoryVal

MemoryVal read (MemoryAdress addr) {
int *p;
p=addr;
return (*p);
}

Irgendwie stehe ich gerade auf dem Schlauch.
Bin über jeden Tipp und jede Hilfe dankbar.

Schönes Wochenende!

[Stefan M. (Gast)]

Sinn oder Unsinn hin oder her, sollte klappen.

p sollte aber kein int* sondern uint8_t* sein.
Die Zuweisung müsste eine Warnung erzeugen, hier evtl. casten.

Aber klappen müssts.

[ReadWrite? (Gast)]

L. schrieb:
> Es soll einen Funktion geben, die auf eine gegebene Adresse einen
> bestimmten Wert schreiben soll.

L. schrieb:
> MemoryVal read (MemoryAdress addr) {
> int *p;
> p=addr;
> return (*p);
> }

???

[Stefan M. (Gast)]

L. schrieb:
> Außerdem möchte ich Werte an speziellen Adressen auslesen lassen.

ReadWrite? schrieb:
> ???

[Hans (Gast)]

L. schrieb:
> Leider kann ich ja nicht einfach schreiben:
>0x0012=4;

Mit einem Cast geht es:

*((uint8_t*) 0x0012) = 4;

L. schrieb:
> Meine Idee bisher war, einen Pointer zu initialisieren, dem diese
> Adresse zu geben und dann einfach mit * zu dereferenzieren. Das scheint
> jedoch nicht zu funktionieren. //typedefs in der Header Datei:
> //typedef uint16_t MemoryAdress
> //typedef uint8_t MemoryVal
>
> MemoryVal read(MemoryAdress addr) {
> int *p;
> p=addr;
> return (*p);
> }

Auch da brauchst Du einen Cast, damit es ohne Warnung geht:

MemoryVal read(MemoryAdress addr) {
  MemoryVal* p;
  p = (MemoryVal*) addr;
  return *p;
}

Oder kürzer:

MemoryVal read(MemoryAdress addr) {
  return *((MemoryVal*) addr);
}

Allerdings würde ich Dir dringend davon abraten, direkt mit den 
physischen Addressen zu hantieren. Leg Dir lieber ein großes Array an, 
aus dem Du Speicher vergibst:

MemoryVal dynamicMemoryBuffer[4096];

MemoryVal read(MemoryAdress addr) {
  return dynamicMemoryBuffer[addr];
}

Oder nimm gleich malloc, dann kannst Du Dir die Arbeit sparen ...

[Wolfgang (Gast)]

L. schrieb:
> ich arbeite mit einem ATmega644 und möchte gerne eine dynamische
> Speicherverealtung auf dem SRAM von 4Kb implementieren.

Und welche Vorteile versprichst du dir gegenüber einer statischen 
Speicherplatzvergabe. Bei 4kB stehen die Chancen eher schlecht, dass du 
spontan vom Betriebssystem größere Speicherblöcke anfordern kannst. 
Entweder dein Kram paßt in die 4kB rein, oder nicht.