STM32F429 Dev Board Sdram benutzen mit System Workbench

[Uli S. (uli_stone)]

Hallo,

ich benutze das STM32F429 Disco Dev Board und habe jetzt Probleme mit 
einem RAM Overflow. Das Problem liegt daran, das ich große Arrays in 
meinem Source-Code benutze um Bilder zu speichern. Leider habe ich mit 
zusätzlichen Speicher noch nicht gearbeitet und bin mir nicht sicher wo 
ich anfangen soll und was nötig ist.

Könnt ihr mir erklären was alles nötig ist den Sdram zu nutzen? Ist es 
richtig das der Speicher initialisiert werden muss 
(http://en.radzio.dxp.pl/stm32f429idiscovery/sdram.html) und der Linker 
angepasst.

Danke

[Jim M. (turboj)]

Uli S. schrieb:
> Könnt ihr mir erklären was alles nötig ist den Sdram zu nutzen? I

Man saugt sich den Beispielcode aus der entsprechenden Appnote des 
Herstellers.

[Uli S. (uli_stone)]

Mhh... das war nicht was ich lese wollte.

ich habe hier auch noch was gefunden 
(http://www.openstm32.org/forumthread2017), leider weiß ich nicht recht 
ob das für mich ist und wie oben geschrieben ob ich den Sdram 
initilaizieren muss. und wie wird in den speicher geschrieben...?

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Wenn du für die AppNotes zu faul bist, kannst du dir mal die Libraries 
von Uwe anschauen:
http://mikrocontroller.bplaced.net/wordpress/?page_id=160

Uli S. schrieb:
> ob ich den Sdram
> initilaizieren muss

Ja, musst du initialisieren, nämlich den FMC Controller.

Uli S. schrieb:
> und wie wird in den speicher geschrieben...?

Z.B. mit den Routinen in der o. a. Library.
Deine lustige Workbench kenne ich nicht, klingt aber toll :-P

[Uli S. (uli_stone)]

Danke Matthias für deine Antwort. AppNotes habe ich nicht gefunden...

Ich hätte mir gewünscht dass Varaibelen in den Sdram abgelegt werden und 
ich nicht direkt in den Speicher schreiben muss... ISt das möglich?

[Harry L. (mysth)]

Die FMC-Configuration kannst du dir von CubeMX generieren lassen,
Am einfachsten geht das, wenn du direkt über den Board-Selector dein 
Board auswählst.

[Dumm User (Gast)]

Matthias S. schrieb:
> Z.B. mit den Routinen in der o. a. Library.

... und ich dachte immer man mapped mit einem Linker Description
Eintrag den SD-RAM Speicher in den "normalen" Arbeitssspeicher-Bereich.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Dumm User schrieb:
> Linker Description
> Eintrag den SD-RAM Speicher in den "normalen" Arbeitssspeicher-Bereich.

Sollte auch klappen. Mit dem SDRAM habe ich das noch nicht probiert, 
aber mit dem CoreCoupled RAM geht das auf jeden Fall - der liegt ja 
meistens auch brach und ist zwar nicht groß, aber schnell.

[Dr. Sommer (Gast)]

Uli S. schrieb:
> Ich hätte mir gewünscht dass Varaibelen in den Sdram abgelegt werden und
> ich nicht direkt in den Speicher schreiben muss... ISt das möglich?

Ja, schließlich wird der RAM in den Adressraum eingeblendet. Bevor man 
den RAM aber nutzen kann, muss man dem via FMC eine Reihe an Befehlen 
zur Initialisierung schicken. Wenn man die nicht selbst austüfteln 
möchte, kopiert man die aus dem Beispielcode von ST.

[Uli S. (uli_stone)]

Danke für die Antworten.

Verstehe ich es richtig, das die auf folgender Seite die Initializierung 
vorgenommen wird: http://en.radzio.dxp.pl/stm32f429idiscovery/sdram.html 
?

Wie kann ich den Linker Datei so konfigurieren das der Sdram aufgenommen 
wird?

[Dumm User (Gast)]

Matthias S. schrieb:
> Mit dem SDRAM habe ich das noch nicht probiert,

Dafür ist ein xy-RAM Controller in einem uC unter anderem
da: Dass er unabhängig von irgendwelchen überkünstelten
Pointer-Zugriffen das Schreiben und Lesen auf diesen er-
weiterten Speicherbereich ermöglicht.

Uli S. schrieb:
> Wie kann ich den Linker Datei so konfigurieren das der Sdram aufgenommen
> wird?

Schau dir ein Linker-Description File an und lerne daraus. Es
gibt auch genügend Beispiele im Internet dazu.

[Uli S. (uli_stone)]

Hi,

ich habe eine Funktion generiert, bei der der SDRAM initializiert wird, 
welche am Anfang der main-Funktion ausgeführt wird. (Nach folgender 
Anleitung http://en.radzio.dxp.pl/stm32f429idiscovery/sdram.html und 
sollte funktinieren, da ich in den SDRAM schreiben kann.

Ich bin mir nicht sicher wo das Problem liegt, im Linker Skript oder in 
der Syscall.c Datei.

Die syscall.c wurde von:

    caddr_t _sbrk(int incr)
    {
            extern char end asm("end"); 
      static char *heap_end;
      char *prev_heap_end;
     
      if (heap_end == 0)
        heap_end = &end;
     
      prev_heap_end = heap_end;
      if (heap_end + incr > stack_ptr)
      {
    //    write(1, "Heap and stack collision\n", 25);
    //    abort();
        errno = ENOMEM;
        return (caddr_t) -1;
      }
     
      heap_end += incr;
     
      return (caddr_t) prev_heap_end;
    }

zu nachfolgender geändert:

    caddr_t _sbrk(int incr)
    {
    //  extern char end asm("end"); // June 2019 - US
     
      extern char __heap_start asm ("__heap_start");
      extern char __heap_limit asm ("__heap_limit");
     
      static char *heap_end;
        static char *heap_limit = &__heap_limit;
      char *prev_heap_end;
     
      if (heap_end == 0)
        heap_end = &__heap_start;
     
      prev_heap_end = heap_end;
      if (heap_end + incr > heap_limit)
      {
    //    write(1, "Heap and stack collision\n", 25);
    //    abort();
        errno = ENOMEM;
        return (caddr_t) -1;
      }
     
      heap_end += incr;
     
      return (caddr_t) prev_heap_end;
    }

Und das Linker-Skript habe ich zu an folgenden Stellen geändert:
      - heap wurde auskommentiert
      - heap_start and heap_limit hinzugefügt
      - SDRAM wurde zu den memory areas hinzugefügt
      - user_stack wurde verändert

    /*_Min_Heap_Size = 0x200;      /* required amount of heap   commented out*/
     
    __heap_start = 0xD0000000; /*Was added*/
    __heap_limit = 0xD0800000; /*Was added*/
     
    /* Specify the memory areas - SDRAM was added */
    MEMORY
    {
    FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 2048K
    RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 192K
    CCMRAM (rw)      : ORIGIN = 0x10000000, LENGTH = 64K
    SDRAM (xrw)     : ORIGIN = 0xD000000, LENGTH = 8M
    }
     
    /* User_stack section, used to check that there is enough RAM left was altered */
      ._user_stack :
      {
        . = ALIGN(8);
        PROVIDE ( end = . );
        PROVIDE ( _end = . );
        . = . + _Min_Stack_Size;
        . = ALIGN(8);
      } >RAM

Aber wenn ich versuche ein großes Array zu deklarieren bekomme ich 
(immernoch) ein RAM overflow (global deklariert):

    volatile uint16_t test[76800];

Wie kann ich mein Problem beheben, so das der SDRAM als RAm Erweiterung 
genutzt wird?

Danke

[Dr. Sommer (Gast)]

Füge zwei Sections für den SDRAM hinzu:

.SdRamData : {
  . = ALIGN(4);
  _SdRamDataBegin = .;
  *(.SdRamData);
  *(.SdRamData*);
  . = ALIGN(4);
  _SdRamDataEnd = .;
} >SDRAM AT> FLASH

_SdRamLoadData = LOADADDR(.SdRamData);

.SdRamBss (NOLOAD) : {
  . = ALIGN(4);
  _SdRamBssBegin = .;
  *(.SdRamBss);
  *(.SdRamBss*);
  . = ALIGN(4);
  _SdRamBssEnd = .;
} >SDRAM

Dann im Startup-Code nach Initialisierung des SDRAM den Bereich 
_SdRamBssBegin-_SdRamBssEnd auf 0 setzen, und den Bereich ab 
_SdRamLoadData nach _SdRamDataBegin - _SdRamDataEnd kopieren.

Dann im C-Code Variablen welche initialisiert werden müssen so 
definieren:

volatile uint16_t test[76800] __attribute__ ((section (".SdRamData"))) = { 1, 2, 3 };

Und Variablen welche 0 sind so:

volatile uint16_t test[76800] __attribute__ ((section (".SdRamBss")));

Wenn du kein malloc verwendest, kannst du die ganze Angelegenheit mit 
Heap und sbrk weglassen. Für globale / statische Variablen ist das 
unnötig.