[OT] Welchen Atmelprozessor für "Von Neumann Architektur" ?

[Realizer]

Keine Angst, ich will dem Arduino nicht untreu werden. Aber es ist ein wenig OT, nachdem einige Herrschaften in dem Thread "Erklärung zum Forum" Deutsch - Arduino Forum verpetzt haben, daß hier auch einige "uralte" Exoten mitmischen.

Folgendes. Ich hatte früher ein 8051 Devirat im Einsatz. (80535) Dieser war auf externen Speicher konfiguriert. Dazu benutzte ich einen 32k Flash und einen 32K SRAM. Schön und gut, aber dieses ewige hin und her des Flashes ging mir auf die Nerven. Ich weiß, dass es heute Microcontroller gibt, die bereits Flash enthalten.

Ich will 64kB batteriegepufferten Ram extern haben und diesen mit serieller Schnittstelle beschreiben und lesen können. Wenn das Programm überspielt ist, dann dieses starten.

Ich weiß nicht ob man einen moderneren 8051 im Flashrom starten kann um dann den externen Ram über UART zu befüllen und dann komplett auf Extern umzuschalten. Programm und Daten befinden sich dann im SRAM.

[Serenifly]

Wegen dem Titel: AVRs verwenden, genauso wie 8051/52, eine modifizierte Havard-Architektur.

[Realizer]

Ok, AVR.

Wenn ich den EA Pin auf low ziehe, dann ist der externe Speicher angesprochen. Bei EA high wird der interne Speicher verwendet.

Ist es möglich, über eine Art Bootloader den externen Ram schreibend anzusprechen? Dafür muss EA jedoch high sein und ich befürchte, daß der Controller dann eben nicht mehr das externe Ram bedienen kann.

Ich kann mir natürlich auch mit einem Atmega8 und zwei Schieberegistern eine Logik bauen um einen 16 Bit Adressbus und einen bidirektionalen 8 Bit Datenbus zu generieren. Damit könnte ich dann mit dem Arduino mittels serial das Ram beschreiben und lesen. Noch ein paar weitere Pins am ´51 ansteuern. (Reset, EA usw.)

Es wäre halt von dem Hardwareaufwand schon geschickt, wenn ich nur den AVR(´51) über das interne Programm extern beschreiben könnte. Ohne Adress und Datenbushardware und EA Gefrickel...

[jurs]

Realizer:
Es wäre halt von dem Hardwareaufwand schon geschickt, wenn ich nur den AVR(´51) über das interne Programm extern beschreiben könnte. Ohne Adress und Datenbushardware und EA Gefrickel...

Soweit es mir bekannt ist, gibt es zwei Arten, den Speicher eines Atmega-Controllers zu erweitern:

1. Möglichkeit: RAM-Erweiterung
   Dafür benötigst Du einen Atmega Controller, der eine RAM-Erweiterung unterstützt und mußt 19 Datenleitungen bereitstellen: 2 komplette Ports a 8 Leitungen für die 16-bittige Speicheradressierung, Latch-Leitung, Read-Strobe und Write-Strobe. Dann kannst Du - nicht mit der Arduino-Software - sondern mit der Atmel-Studio Software den Compiler so einrichten, dass er den externen Speicher genau so anspricht als wenn es eingebauter Speicher mit mehr RAM wäre. Ein solcher Controller wäre der Atmega64, Datenblatt siehe:
   http://www.atmel.com/images/atmel-2490-8-bit-avr-microcontroller-atmega64-l_datasheet.pdf
   Dort zu beachten die Hinweise unter

• "Table 27. Port A Pins Alternate Functions" ==> Address Lowbyte
• "Alternate Functions of Port C" ==> Address Hibyte
• "Alternate Functions of Port G" ==> Latch, Read-Strobe, Write-Strobe für external RAM
  Der Atmega64 wird nicht von der Arduino-Software unterstützt und die Arduino-Software unterstützt auch keinen anderen Controller, bei dem external RAM aktiviert werden könnte.

2. Möglichkeit: External Memory
   Das ist das wovon Du schreibst "diesen mit serieller Schnittstelle beschreiben und lesen können". Dann ist der Speicher wie jede andere externe Hardware zu betrachten, und eine Kommunikation mit den Speicherstellen kann nur durch Ausführen spezieller Lese- und Schreibbefehle durchgeführt werden. D.h. Du kannst Befehle aufrufen, um Daten vom external Memory in den RAM zu veranlassen und umgekehrt. Sowas geht auch mit der Arduino-Software.

3. Möglichkeit: Controller mit mehr eingebautem RAM verwenden
   Der für die Arduino-Software vorgesehene Upgrade-Pfad zu mehr RAM-Speicher ist der Umstieg auf ein 32-Bit Controller-Board, den Arduino DUE mit 96 kB RAM:
   http://arduino.cc/en/Main/ArduinoBoardDue

[system]

Realizer:
Keine Angst, ich will dem Arduino nicht untreu werden. Aber es ist ein wenig OT, nachdem einige Herrschaften in dem Thread "Erklärung zum Forum" Deutsch - Arduino Forum verpetzt haben, daß hier auch einige "uralte" Exoten mitmischen.

Dein Link soll wohl hierhin zeigen: Erklärung zum Forum - Deutsch - Arduino Forum
Ich muss mich leider fragen, ob das einem "Jungen" auch passiert wäre 8)

Realizer:
Ich weiß nicht ob man einen moderneren 8051 im Flashrom starten kann um dann den externen Ram über UART zu befüllen und dann komplett auf Extern umzuschalten. Programm und Daten befinden sich dann im SRAM.

Also, ich habe an meinem Arduino Mega2560 64kB externen SRAM angeschlossen. Mit der Arduino-IDE gelingt mir der Zugriff nur durch

int8_t *adr;
    .
    .
    .
  adr = (int8_t *) 0x2200U;
  
  adr[0x1000] = 12;                   // auf Adr. 0x1000 schreiben bzw.

  Serial.println(adr[0x1000]);      // bzw. Adr. 0x1000 auslesen

Aktiviert habe ich den externen SRAM mit

void setup() {
  XMCRA = 0x80;
  XMCRB = 0x80;
}

Die Erklärung zu XMCR A und B (also External Memory Configuration Register A und B) findest Du im Datenblatt des ATMega2560. Kurz: Externes SRAM wird eingeschaltet, keine Waitstates, kompletter 64kB-Adressraum wird benutzt.

Um nun den RAM auch für Daten und Variablen benutzen zu können, muss man dem Linker mitteilen, das externes RAM vorhanden ist. Nach vielem Rumprobieren habe ich keinen Weg gefunden um über die Arduino-Oberfläche dem Linker Optionen übergeben zu können. Deswegen habe ich hier Linker Optionen beim Mega2560 setzen, zwecks ext. SRAM - Deutsch - Arduino Forum nach Hilfe gejammert, hat sich aber leider bis jetzt niemand zu Wort gemeldet.

Ich benutze jetzt zum Testen mal Code-Blocks, hier kann man zumindest Linker-Optionen einstellen. Leider habe ich aber mit

-Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff

noch nicht das gewünschte Ergebnis erzielt.

Für mich wäre es eigentlich auch wünschenswert, ein Programm in den SRAM zu laden und dann auf irgendeine Weise den Program Counter in den externen RAM zu setzen, damit dort das Programm abgearbeitet wird, aber wie das gehen könnte oder ob es überhaupt möglich ist, weiß ich noch nicht. Falls Du dazu etwas rausbekommst, lasse es mich bitte unbedingt wissen! Falls Du noch was zum Lesen brauchst, hätte ich hier noch einen Link über die Speicheraufteilung der AVRs: avr-libc: Memory Areas and Using malloc().

Soweit also mein momentaner Kenntnisstand. Vielleicht hilfts ja ein wenig...

Gruß,
Ralf

[Realizer]

Danke ihr Lieben,
damit habe ich wieder Lektüre bis zum Abwinken. Und Sorry für den ersten falschen Link. @Schachmann, ich weiß auch nicht ob das einem Jüngeren auch passiert wäre. Ich habe ja Euch, aufmerksame Leser. Vielen Dank!

Bin echt nur noch am Grübeln. Für mich als "Hardwarer" stellt sich die Lösung mit dem externen Ram und einer externen Hardware für Adress und Datenbus am einfachsten dar. Über Eure Vorschläge werde ich einige Nächte verbringen und lesen, lesen, lesen.

Es hat halt einfach etwas "entspannendes", wenn man beliebig oft das Programm nach Trial und Error in das Gebilde spielen kann, ohne immer darüber nachdenken zu müssen, daß der Flash irgendwann stirbt. Daher externes Ram (SRAM). Bei der relativ schnellen RISC Technologie muss ich schon wieder auf die Zugriffszeiten des Static-Rams achten. Aber das ist ja konfigurierbar. In erster Linie suchte ich die logische Vorgehensweise zur Verwirklichung meiner Idee.

Und @Jurs, auch Dir vielen Dank. Ob ich nun die Arduinosoftware oder Atmelstudio verwende, sei mal noch nicht als so wichtig. Mir gehts hauptsächlich erstmal um das realisieren von 64 kB SRAM, den ich adressieren und lesend, schreibend zugreifen kann. Letztenendes ist es ja fast egal, welcher Prozessor daran werkelt. Natürlich sind dabei die Timings wichtig.

Wie gesagt, erstmal Danke. So viel Lesestoff...

Ich lasse Euch dann an meinen Basteleien teilhaben. Versprochen.

[jurs]

Realizer:
Und @Jurs, auch Dir vielen Dank. Ob ich nun die Arduinosoftware oder Atmelstudio verwende, sei mal noch nicht als so wichtig. Mir gehts hauptsächlich erstmal um das realisieren von 64 kB SRAM, den ich adressieren und lesend, schreibend zugreifen kann. Letztenendes ist es ja fast egal, welcher Prozessor daran werkelt. Natürlich sind dabei die Timings wichtig.

OK, ich sehe gerade, es gibt mit dem Arduino MEGA doch ein Board, das "external RAM" unterstützt und von der Arduino-Software unterstützt wird.

In http://www.atmel.com/Images/doc2549.pdf sind in Kapitel 13.3.1 "Alternate Functions of Port A" genau dieselben Ports mit Sonderfunktionen zum Zugriff auf externes RAM aufgeführt wie beim (von der Arduino-Software nicht unterstützten) Atmega64.

Und wie ich so weiter googele, gibt es für den MEGA sogar fertige Speichererweiterungen zu kaufen:
a) mit 128 KB: http://ruggedcircuits.com/html/megaram.html
b) mit 256 KB: http://ruggedcircuits.com/html/quadram.html

In beiden Fällen läßt sich auf den vollen Speicher nur mit Sonderbefehlen zum Schreiben und lesen zugreifen.

Aber wenn man nur 56 KB RAM Speicher benötigt (das ist wohl 64 KB abzgl. des internal RAM im Atmega2560), soll es wohl tatsächlich mit einem MEGA2560 möglich sein, diese Speichergröße als echten RAM-Speicher zu verwenden, mit "external RAM", 19 belegten I/O-Leitungen am Arduino MEGA und etwas Adressenverbiegerei. Kann man sich ja mal informieren, wenn man es braucht.

[Realizer]

Superinteressante Sachen krieg ich hier zu lesen.

Danke Euch allen. Bin dann mal erstversorgt mit Informationen.

Wenn ich meinen Cmos-Container öffne, dann sehe ich nur Oldtimer. Da steht beispielsweise: Intel P8031AH oder Phillips 80C31BH-3. Der SAB 80C535-N war der damalige Controller, den ich für meine ersten Tests und einen Zeichenkonverter an der PC-Druckerschnittstelle. Liegt hier übrigens auch noch rum.

Wenn ich das heutige Angebot an Controllern so anschaue, dann wird man ja förmlich erschlagen, wenn man als Bastler und Tüftler unterwegs ist. Wenn ich einen modernen RISC mit Neumann Architektur benutzen will, dann muss ich darauf achen daß SRAM auch schnell genug ist.

[system]

jurs:
soll es wohl tatsächlich mit einem MEGA2560 möglich sein, diese Speichergröße als echten RAM-Speicher zu verwenden, mit "external RAM", 19 belegten I/O-Leitungen am Arduino MEGA und etwas Adressenverbiegerei.

Es ist möglich, aber scheinbar nicht mit der Arduino-IDE =(

jurs:
Kann man sich ja mal informieren, wenn man es braucht.

Wenn Du Infos hast, lass es mich bitte unbedingt wissen!

Gruß,
Ralf

[jurs]

Schachmann:
Es ist möglich, aber scheinbar nicht mit der Arduino-IDE =(
...
Wenn Du Infos hast, lass es mich bitte unbedingt wissen!

Es müssen auf jeden Fall die Linker-Optionen beim Linken der Programmdatei geändert werden, diese Info fand ich hier:

Adding external memory to Atmega128 - Do It Easy With ScienceProg

Aus der Arduino-IDE heraus ist das mit Sicherheit nicht möglich.
Ob es irgendwie durch manuelle Umkonfiguration einiger Dateien machbar ist, keine Ahnung. Das kann ich nicht beurteilen, weil ich vom Compile- und Linkprozess in der Arduino-Software nur eine grobe Vorstellung, aber keine Ahnung von Details habe.

Jedenfalls ist auf der Seite dann auch das Speicher-Mapping erklärt, wie es mit aktiviertem external RAM aussieht:
Der Speicherbereich für Register, freien und belegten Stackspeicher bleiben im internen RAM
Der Speicherbereich für Daten und Heapbereich wandern ins externe RAM.

Irgendwelche ganz ausgefuchsten Hard- und Softwarefreak bekommen das wohl hin.

Aber ich überlege mir: Wenn ich für einen Arduino MEGA plus eine fertige RAM-Karte mit 128 KB, von denen ich "vielleicht und mit viel Basteln" 56 KB als external RAM nutzen könnte, denselben Preis bezahlen muss, für den ich auch einen Arduino DUE kaufen könnte, der direkt von der Arduino-Software unterstützt wird, dann würde ich lieber den Arduino DUE nehmen. Das dürfte stressfreier sein, wenn man wirklich mehr RAM benötigt.

[system]

@jurs: Bei mir funktionieren die angegebenen Linkeroptionen in Deinem Link nicht. Er zeigt mir zwar rd. 63kB freien Speicher an, stürzt aber ab, wenn ich versuche mehr als den eingebauten RAM für Variablen zu benutzen.

Vielleicht sollte man wirklich über den Due nachdenken...

Ach so, Du kannst die vollen 64kB benutzen, wie steht im Datenblatt des ATMega2560.

Gruß,
Ralf

[Realizer]

Ich wollte einfach die alten Schaltungen wieder so aufbauen wie sie damals waren. Da kann ich alle möglichen 5V TTL Bausteine einfach dranhängen. Dann habe ich den AT89C51RB2 bei Atmel MCU Selector gefunden. Schade daß ich da nirgens gefunden habe wo man "von Neumann / Havard-Architektur" an oder abwählen kann. Da müsste ich mir ja tausende von Handbüchern durchlesen.

Wenn ich einen Prozessor finde, der so wie Schachmann sagt, aus dem Bootloader hinaus auf jede externe Ram Adresse schreiben kann und 44 Pins hat, mit 5 Volt arbeitet, RISC hat (1 Zyklus, 1Befehl), dann werde ich genau diesen kaufen.

Das Umschalten auf externes Ram werde ich dann auch über eine externe Logik machen. Dieses Umschalten ist mit einem Reset verbunden und die Software wird später erkennen ob es ein gültiges Programm ist und dann starten. Falls kein gültiges Programm im externen Ram gefunden wird, dann wartet der Bootloader solange bis ein Hexfile von der seriellen Schnittstelle kommt.

Und wenn alle Stricke reißen, dann mach ich mir drei Schieberegister und mache mir einen einfachen Adress und Datenbus mit dem Mega168. Also Quasi einen barebone Arduino nur zum Programmieren des 8051er. Auslesen kann ich den Ram ja wieder aus der UART des 8051. Dann hätte ich eine serielle Programmierschnittstelle und zusätzlich eine serielle Datenschnittstelle sobald der 51er läuft. Ram batteriepuffern. (Accu oder Goldcap).

Es ist mir nicht nur wegen der Programmierung des Controllers wichtig ein externes Ram zu haben, sondern auch um größere Datenmengen oft hin und herschieben zu können. Beispiel digitale Türglocke mit ladbaren Klingeltönen. Im nächsten Moment könnte das Ding nämlich eine Wetterstation oder eine Heizungssteuerung oder, oder, oder...

Mein 80535er damals konnte über ein R2R Netzwerk an einem kleinen Verstärker einen ganzen Satz abspielen. Dazu habe ich ein Zitat mit dem Amiga augenommen. 8 Bit Mono. Und im Raw Format in den SRAM gespeichert. Das hörte sich noch nicht einmal so schlecht an. Aber mein Wellensittich hatte dann auch nicht das Sprechen gelernt, obwohl ich das Zitat immer wieder zufällig abgespielt habe. (Mit längeren Pausen dazwischen).

[jurs]

Schachmann:
@jurs: Bei mir funktionieren die angegebenen Linkeroptionen in Deinem Link nicht. Er zeigt mir zwar rd. 63kB freien Speicher an, stürzt aber ab, wenn ich versuche mehr als den eingebauten RAM für Variablen zu benutzen.

Die im Link angegebenen Linker-Optionen können natürlich nicht funktionieren: Diese Linker-Optionen gelten ja für einen Atmega128 mit nur 4 kB internem RAM.

Für einen MEGA2560 müssen die Optionen natürlich angepaßt werden, denn der hat ja 8 kB internes RAM.
Also muß das Datensegment nicht auf 0x1100 geschoben werden, sondern bis auf 0x2100.
Und wenn genug RAM installiert ist, dann ist das Ende des Heap erst bei (64 KB -1) und nicht bei (12 KB -1).
Wenn ich jetzt mal die beiden Zahlen in der angegebenen Linker-Option umrechne, dann komme ich für einen MEGA2560 auf die Linker-Option:
-Wl,--section-start,.data=0x802100,--defsym=__heap_end=0x80ffff

Keine Ahnung, ob das dann zu besseren Ergebnissen führt, aber so würde ich das anpassen für einen MEGA2560 mit einer 56 KB RAM-Erweiterung.

Darf ich mal fragen, wo Du diese Linker-Optionen in der Arduino-Software einstellen kannst, wenn Du sagst, Du hast es ausprobiert?

Realizer:
Es ist mir nicht nur wegen der Programmierung des Controllers wichtig ein externes Ram zu haben, sondern auch um größere Datenmengen oft hin und herschieben zu können. Beispiel digitale Türglocke mit ladbaren Klingeltönen. Im nächsten Moment könnte das Ding nämlich eine Wetterstation oder eine Heizungssteuerung oder, oder, oder...

Mein 80535er damals konnte über ein R2R Netzwerk an einem kleinen Verstärker einen ganzen Satz abspielen. Dazu habe ich ein Zitat mit dem Amiga augenommen. 8 Bit Mono. Und im Raw Format in den SRAM gespeichert. Das hörte sich noch nicht einmal so schlecht an. Aber mein Wellensittich hatte dann auch nicht das Sprechen gelernt, obwohl ich das Zitat immer wieder zufällig abgespielt habe. (Mit längeren Pausen dazwischen).

Zum Speichern großer Datenmengen kann man eine SD-Karte verwenden.

Digitale Klingeltöne oder 8-Bit WAV-Dateien kannst Du mit dem Arduino von einer SD-Karte abspielen, die Geschwindigkeit reicht dafür.

[system]

jurs:
... dann komme ich für einen MEGA2560 auf die Linker-Option:
-Wl,--section-start,.data=0x802100,--defsym=__heap_end=0x80ffff

Du hast natürlich (fast ?) Recht. Ich kam, auch lt. Datenblatt des ATMega2560, auf:

-Wl,--section-start,.data=0x802200,--defsym=__heap_end=0x80ffff

und so habe ich das auch probiert. Wie geschrieben, es wird knapp 63k Speicher ermittelt, aber beim Zugriff hängt der Arduino sich auf

Zu Deiner Frage: In der Arduino-IDE habe ich nach langem Suchen keinen Weg gefunden, um dem Linker Optionen zu übergeben. Deshalb benutze ich für dieses Projekt im Moment Code:Blocks Arduino-Edition. Damit kann man wunderbar Projektverwaltung betreiben und für einzelne Projekte auch Compiler-, Linker- und alle möglichen anderen Optionen einstellen. Außerdem bietet es - zwar noch als Beta-Version, aber immerhin - auch einen Arduino-Emulator, auf dem man seine Programme debuggen kann. Wenn Du es noch nicht kennst, es ist Open-Source und mal ansehen lohnt sich sicherlich. Als weitere IDE habe ich MariaMole ausgemacht, die auch Projektverwaltung unterstützt aber, wie die Arduino-IDE, keine Linker- und dgl. Optionen.

Gruß,
Ralf

[jurs]

Schachmann:
und so habe ich das auch probiert. Wie geschrieben, es wird knapp 63k Speicher ermittelt, aber beim Zugriff hängt der Arduino sich auf

Zu Deiner Frage: In der Arduino-IDE habe ich nach langem Suchen keinen Weg gefunden, um dem Linker Optionen zu übergeben. Deshalb benutze ich für dieses Projekt im Moment Code:Blocks Arduino-Edition.

OK, also so kommst Du an die Linker-Optionen ran und kanst das Programm so linken, dass es mit externem RAM verwendet werden kann.

Jetzt fehlt wahrscheinlich nur noch die hardwaremäßige Initialisierung des externen RAM im Controller.

Irgendwo im Programm ganz weit vor "setup()" und auch ganz weit vor "main()".
Wobei Arduino-Programmierer schon "main()" gar nicht zu Gesicht bekommen, weil es versteckt wird.
Wahrscheinlich muß der Code zum Aktivieren des external RAM irgendwo in ein ".init" Segment des Programms. Die verschiedenen Segmente und die Reihenfolge der Ausführung bei AVR-GCC Programmen ist hier zu finden:
http://www.nongnu.org/avr-libc/user-manual/mem_sections.html
So wie es aussieht, müßte das externe RAM vor dem Segment .init4 im Programm aktiviert werden, denn in .init4 erfolgt bereits das Umkopieren der Datenbereiche aus dem Flash in das Datensegment, und der Datenbereich soll ja im externen RAM liegen.

Die Frage ist: Kannst Du mit Deiner IDE nicht nur eigene Linker-Optionen setzen, sondern auch eigenen Initialisierungs-Code im Program schreiben, der bereits in der Initialisierungsphase ausgeführt wird, weit vor den Starten von setup() oder main()?

[system]

@jurs: Danke für Deine Antwort. Ich kann Dir leider aber noch nicht ganz folgen. Meinst Du sowas:

void my_init (void) __attribute__ ((naked)) __attribute__ ((section (".init4")));

void my_init(void)
{
    // Das hier landet in .init4
}

Wenn ja, was soll denn dann in .init4 drin stehen? So wie ich das sehe werden an der Stelle lediglich Daten aus dem Flash ins RAM kopiert. Wo das RAM aber physikalisch angesiedelt ist, muss vorher schon der Linker festlegen (der bestimmt ja von welcher Adresse an welche Adresse kopiert wird).

Ich denke, ich muss irgendwo noch das Linker-Control-File ändern, da steht z.B.:

MEMORY
{
  text      (rx)   : ORIGIN = 0, LENGTH = 1024K
  data      (rw!x) : ORIGIN = 0x802000, LENGTH = 0xffa0
  eeprom    (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
  fuse      (rw!x) : ORIGIN = 0x820000, LENGTH = 1K
  lock      (rw!x) : ORIGIN = 0x830000, LENGTH = 1K
  signature (rw!x) : ORIGIN = 0x840000, LENGTH = 1K
}

Ich finde aber im Moment noch nicht das richtige Control-File für den ATMega2560. Da gibt es jede Menge verschiedene für die verschiedenen Atmel-Controller. Leider heißen die aber nicht so wie die Controller, sondern sind mehr oder weniger einfach durchnummeriert.

Trotzdem, wenn Du weitere Tipps hast, bin ich Dir dankbar!

Gruß,
Ralf

[jurs]

Schachmann:
@jurs: Danke für Deine Antwort. Ich kann Dir leider aber noch nicht ganz folgen. Meinst Du sowas:

void my_init (void) __attribute__ ((naked)) __attribute__ ((section (".init4")));

void my_init(void)
{
    // Das hier landet in .init4
}

Wenn ja, was soll denn dann in .init4 drin stehen?

Ich weiß nur, dass in einer .init Sektion VOR .init4 Code drinstehen muß, der im Port MCUCR mindestens ein Bit anders setzt. Schau mal hier:
http://www.avr-asm-tutorial.net/avr_de/beginner/pdetail.html
Und da auf der Seite mal bei MCUCR, Bit 7, Name "Ext.SRAM Enable".
Dieses Bit muß auf "1" gesetzt werden, und zwar während der Initialisierungsphase BEVOR das Programm anfängt zu laufen.

Nur dann betrachtet der Controller die Leitungen, wo das externe RAM angeschlossen ist, auch als externes RAM und nicht als allgemeine I/O Pins.

Wie das technisch gemacht wird, bin ich völlig überfragt. Ich habe wie gesagt nur sehr rudimentäre Vorstellungen vom Compile- und Linkvorgang und weiß nicht, wie man Initialisierungscode in ein Programm einfügt, der ganz am Anfang ausgeführt wird, noch weit vor dem Start der main() oder gar der setup() Funktion, die ja erst starten, wenn alles andere Initialisiert ist: Stackpointer, Heappointer, alle globalen Variablen im RAM-Speicher angelegt etc. Und bei diesen Initialisierungsvorgängen muß dann auch irgendwo das Bit "External RAM enable" gesetzt werden.

Die Codezeile sollte dann ungefähr so gehen, um das externe RAM zu aktivieren:
MCUCR |= (1 << SRE); // Enable external RAM

Aber wie und wo das unter Arduino und/oder der von Dir installierten alternativen IDE gemacht werden kann: Ich bin da völlig überfragt.

[system]

Ah ja, jetzt weiß ich, was Du meinst. Du meinst SRE im External Memory Control Register A. Das kann quasi nach Belieben an- und ausschalten, siehe Kapitel 9.4 im Datenblatt des ATMega2560.

In meinem Programm passiert das einfach durch

XMCRA = 0x80;

Das kann man im Programm einfach so setzen, dann greift er auf das XRAM zu oder rücksetzen (XMCRA = 0x00;) dann greift er eben nicht mehr zu. Die Adressierung des externen RAMs lässt sich auf dem Oszilloskop gut ansehen. Es ist sogar möglich das nach Bedarf an- und auszuschalten. Beispiel ich brauche Daten aus dem XRAM, also XMCRA = 0x80; Später im Programm brauche ich kein XRAM mehr, möchte aber Port C als normales I/O-Port benutzen, dann XMCRA 0x00; (Das RAM muss dabei natürlich gegen Zugriffe vom außerhalb geschützt werden, also entweder abschalten oder in einen Tri-State-Zustand bringen.)

Gruß,
Ralf

[jurs]

Schachmann:
Das kann man im Programm einfach so setzen, dann greift er auf das XRAM zu oder rücksetzen (XMCRA = 0x00;) dann greift er eben nicht mehr zu. Die Adressierung des externen RAMs lässt sich auf dem Oszilloskop gut ansehen. Es ist sogar möglich das nach Bedarf an- und auszuschalten. Beispiel ich brauche Daten aus dem XRAM, also XMCRA = 0x80; Später im Programm brauche ich kein XRAM mehr, möchte aber Port C als normales I/O-Port benutzen, dann XMCRA 0x00; (Das RAM muss dabei natürlich gegen Zugriffe vom außerhalb geschützt werden, also entweder abschalten oder in einen Tri-State-Zustand bringen.)

Genau das.

Wenn Du nur "irgendwann im Programm" auf irgendwelche Speicherstellen in einer Speichererweiterung zugreifen möchtest, dann kannst Du das enable-Bit auch "irgendwann im Programm" setzen.

Wenn aber die Speichererweiterung als "externes RAM" dienen soll, das genau so genutzt werden kann wie internes RAM, und in dem sich der Datenbereich befindet und der Heap, dann muß das enable-Bit gesetzt worden sein, bevor die erste Datenvariable im Datensegment angelegt wird und bevor das erste Byte im Heap alloziert wird.

Und das Bit darf im laufenden Programm auch nicht mehr gelöscht werden, sonst entziehst Du dem Programm sowohl den Datenbereich als auch den Heap.

[system]

Tja, ich hatte das bisher nicht so verstanden. Ich muss aber sagen, dass Deine Argumentation einiges für sich hat, u.a. wäre es eine wirklich treffende Erklärung dafür, das der ATMega sich so verhält, wie er sich im Moment verhält.

Trotzdem, wenn ich das Bit setze und dann später im Programm dynamisch Speicher alloziere, hat der Controller eigentlich keinen Grund, nicht auf das externe RAM zuzugreifen. Für statische Variablen udgl. die alloziert werden, ehe der eigentliche Programmlauf beginnt, gebe ich Dir aber völlig Recht, das kann so nicht gehen.

Im Moment bin ich nicht mehr an meinem Entwicklungsrechner, aber morgen werde ich auf jeden Fall mal versuchen, das Bit so früh wie möglich zu setzen, mal sehen ob das und was das bringt. Ich weiß jetzt auch nicht aus dem Stegreif wie und was man da mit Code:Blocks tun kann. Mal sehen... Wenn ich ein Ergebnis habe, poste ich es auf jeden Fall hier.

Mein nächster Versuch wäre gewesen, ich habe ja die Speicher-Hardware hier. Meinen Arduino wollte ich eigentlich ganz lassen (also nicht den Bootloader rausfeuern). Ich habe aber noch ein paar ATMega8515 in der Schublade, die haben das gleiche XRAM-Interface. Ich hätte dann mal einen davon auf dem Breadboard aufgebaut und es mal in Assembler probiert - einfach um die Umwägbarkeiten der Arduino-Software und des Bootloaders loszuwerden.

Besten Dank auf jeden Fall für Deine Denkanstöße!

Gruß,
Ralf