LPC1857 ARM Cortex M3 Problem mit EMC und SDRAM

[Martin (Gast)]

Hallo alle zusammen,

ich versuche gerade die Kommunikation zwischen einem NXP LPC1857 und 
einem SDRAM MT48LC4M32B2P-6 hinzubekommen. Dazu verwende ich das KEIL 
MCB1857 Entwicklungsboard. Als Entwicklungsumgebung nutze ich LPCXpresso 
IDE mit dem LPC-Link.

Ich habe ein einfaches Projekt angelegt. Der EMC wird in der emc.c 
initialisiert und in der main.c wird dann ein Testprogramm ausgeführt, 
welches mir bei erfolgreichem Schreiben auf den SDRAM sowie bei 
fehlgeschlagenem Schreiben je eine LED ansteuert.

Mein Problem ist jetzt, dass es nicht funktioniert.

Als EMC Takt verwende ich 120MHz, die ich einfach nur in der 
CGU_Init()-Funktion mit SetPLL1(10) eingestellt hab.
Den CLK0 (rot) und den CKE0 (gelb) habe ich gemessen (siehe Bild im 
Anhang). Ich habe beide Signale mit einem anderen Board und einem 
funktionierenden Beispielcode verglichen. Also der Clock scheint schon 
mal in Ordnung zu sein.

Das Linker-Script habe ich manuell im MEMORY-Bereich erweitert (siehe 
Anhang SDRAM16).

Könnte sich bitte jemand meine Dateien mal ansehen, ob er eventuell den 
Fehler findet, warum ich keine erfolgreiche Kommunikation hinbekomme?

Vielen Dank! :-)

Beste Grüße,

Martin

[Martin (Gast)]

Guten morgen :-)

hat jemand Erfahrungen mit den LPC18xx Controllern und Linker-Skripten 
in LPCXpresso IDE oder der Code Red IDE?

Reicht es folgende Einstellungen vorzunehmen:

In der ..._mem.ld Datei:

MEMORY 
{
   ...
   ...
   SDRAM (rwx) : ORIGIN = 0x28000000, LENGTH = 0x1000000
}

   ...
   ...
   __top_SDRAM = 0x28000000 + 0x10000000;

In der ... .ld Datei:

Erstellen einer section (Beispiel):

.VRAM (NOLOAD) : ALIGN(4)
{
    *(.VRAM)
} > SDRAM

Ist es ausreichend, nur die Einstellungen in der ...mem.ld vorzunehmen, 
um nur einen Wert in den Speicherbereich des SDRAM zu schreiben?

Die section benötige ich doch nur, wenn ich eine Variable oder eine 
Funktion in diesen Bereich ablegen will, oder?

Danke.

Mfg Martin

[Arne (Gast)]

Martin schrieb:

> Mein Problem ist jetzt, dass es nicht funktioniert.
>
> Als EMC Takt verwende ich 120MHz

Der EMC in den LPC178x (!) verträgt nur 80MHz:
http://www.lpcware.com/content/forum/dk-57vts-lpc1788-configuring-emc-sdram

Würde mich wundern, wenn es beim LPC18xx anders wäre, es sei denn, es 
steht explizit im Usermanual.

bye, Arne

PS: SDRAM am LPC1788 steht mir auch noch bevor...

[Martin (Gast)]

Hallo Arne,

danke für den Hinweis, ich werd gleich nochmal schauen, wie hoch die 
Frequenz sein darf.

Ein funktionierendes Beispiel für den EMC des 1788 findest du im BSP von 
emWin.

[Martin (Gast)]

Also die typische maximale EMC Frequenz ist 120MHz. Das heißt ich 
betreib den gerade am Maximum. Naja ich werd mal mit 60 oder 72MHz 
versuchen.

[Martin (Gast)]

72MHz bringt auch keinen Erfolg..

[Arne (Gast)]

Unterscheidet sich der EMC vom 178x zum 1857? Sonst könntest Du doch auf 
das emWin Bsp. zurückgreifen.
Ich meine der EMC ist sogar in LPC2xxx ARM7 drin.

[Arne (Gast)]

BTW: hast Du da nicht ein Henne-Ei Problem?
Der StartUp Code "kennt" anhand des Linkerskripts das externe SDRAM und 
versucht u.U. da das BSS zu nullen, bzw. das DATA Segment aus dem
int. Flash dahin zu kopieren. Und das alles bevor der EMC samt SDRAM 
korrekt konfiguriert ist?

Ich werde bei mir einen Bootloader programmieren, der das ext.RAM vom 
Linkerskript nicht kennt, aber den EMC und das SDRAM bereits korrekt 
initialisiert. Dann erfolgt der Sprung in die Applikation, die vom 
Linkerskript das ext.RAM bereits kennt. Dann kann vom BSS/DATA kopieren 
nichts schief gehen.

[Martin (Gast)]

Im Wesentlichen habe ich die EMC Configuration vom 1788 genommen. Es 
mussten nur die Pinkonfigurationsregister für den 1857 angepasst werden 
und halt die Daten vom neuen SDRAM.

Trotzdem gehts nicht.

Zum Linker-Script:

Ich kann ja zum einen den SDRAM unter MCU Settings per Edit im Memory 
Configuration Editor hinzufügen. Danach "Manage Linker script" auswählen 
und das Linker script wird automatisch erstellt. Dabei entstehen neben 
der Memory-Region "SDRAM" auch noch .DATA- und .BSS-Sektionen für 
"SDRAM".
Zum anderen kann man "Manage Linker Script" auch abwählen und das 
existierende (ohne SDRAM) manuell bearbeiten. Im emWin-Beispiel vom 1788 
wurden lediglich die Einträge für die Memory-Region in der _mem.ld Datei 
vorgenommen und die Sektionen .GUI_RAM und .VRAM in der .ld erstellt. Da 
gibt es keine .DATA oder .BSS-Sektionen für den SDRAM.
Also habe ich mich an das Beispiel gehalten und nur eine neue 
Memory-Region für den SDRAM erstellt, da ich im Moment für den Test die 
.VRAM und .GUI_RAM Sektionen nicht benötige. Ich habe nichts bei .DATA 
und .BSS programmiert.

Wie sollte denn das Linker-Skript richtig programmiert werden? Benötige 
ich die .DATA- und .BSS-Sektionen?

Anbei habe ich die Linker-skript Dateien vom emWin BSP anghängt.

[Martin (Gast)]

Ich habe jetzt noch einmal meine Testroutine geändert. Jetzt sieht es so 
aus, als ob das Schreiben auf den SDRAM funktioniert.

Testroutine vorher:

unsigned int SDRAM_Test (void)             
                            // Test-Routine aus der NXP AppNote 10771
{
  unsigned int i;
  // 32 bits access
  for (i = 0; i < 0x2000000; i+=sizeof(unsigned int))
  {
    *(unsigned int *)((unsigned int )SDRAM_BASE_ADDR+i) = i;
  }
  for (i = 0; i < 0x2000000; i+=sizeof(unsigned int ))
  {
     if (*(unsigned int *)((unsigned int )SDRAM_BASE_ADDR+i) != i)
     {
         return(0);
     }
  }
  
  return(1);
}

Aktuelle Testroutine:

unsigned int SDRAM_Test (void)             
                            // Test-Routine aus der NXP AppNote 10771
{
  unsigned int i;
  // 32 bits access
  for (i = 0; i < 0x2000000; i+=sizeof(unsigned int))
  {
     *(unsigned int *)((unsigned int )SDRAM_BASE_ADDR+i) = i;
          
     if (*(unsigned int *)((unsigned int )SDRAM_BASE_ADDR+i) != i)
     {
         return(0);
     }
  }
  
  return(1);
}

Jetzt müsste es doch so sein, dass der aktuelle Wert von i an die Stelle 
SDRAM_BASE_ADDR+i geschrieben und gleich im Anschluss überprüft wird.

Vorher wurden alle Werte i nacheinander in den SDRAM geschrieben. Danach 
wurden wieder alle Werte i hochgezählt und überprüft. Dabei werden sich 
ja bestimmte Werte überschrieben haben und es kam zum Fehlschlagen der 
Überprüfung.

Passt meine Überlegung oder hab ich da einen Denkfehler drin? Das 
Programm funktioniert jedenfalls erst einmal.

[Martin (Gast)]

Ich habe jetzt noch einmal die Test_SDRAM - Routine vom emWin LPC1788 
Board support package ausprobiert und festgestellt, dass meine 
Kommunikation mit dem SDRAM nicht funktioniert.

Warum klappt es aber mit der Test-Routine aus dem letzten Post? Kann es 
sein, dass ich dort gar nicht wirklich auf den SDRAM schreibe??

[Lothar (Gast)]

Habe nichts mit dem LPC1857 gemacht, aber der soll doch kompatibel zum 
LPC4357 sein bzw. umgekehrt, und damit vielleicht auch der EMC:

http://www.lpc4350.com/lpc43xx/Examples/SDRAM_Test/

[Martin (Gast)]

Habs immer noch nicht hinbekommen :-(

Hab jetzt folgende EMC_Init-Routine:

void emc_WaitUS(volatile uint32_t us)
{
  us *= ((SystemCoreClock / 1000000)/3);
  while(us--);
}

void emc_WaitMS(volatile uint32_t ms)
{
  ms *= ((SystemCoreClock / 1000)/3);
  while(ms--);
}

/*********************************************************************
*
*       _EMC_Init()
*
*  Purpose:
*    Initializes external memory controller for SDRAM
*/

void _EMC_Init(void) {

  volatile U32 CmdDly;
  volatile U32 Dummy;
  volatile U32 i;

  LPC_SCU->EMCDELAYCLK  = 0x7777;
  //LPC_CREG->CREG6 |= (1 << 16);

  LPC_EMC->CONTROL   = 0x1;           // EMC enable
  LPC_EMC->CONFIG    = 0x0;        //Little Endian Mode
  //
  // Port init
  //
  LPC_SCU->SFSP1_7 = (MD_PLN_FAST | FUNC3);  //D0
  LPC_SCU->SFSP1_8 = (MD_PLN_FAST | FUNC3);  //D1
  LPC_SCU->SFSP1_9 = (MD_PLN_FAST | FUNC3);  //D2
  LPC_SCU->SFSP1_10 = (MD_PLN_FAST | FUNC3); //D3
  LPC_SCU->SFSP1_11 = (MD_PLN_FAST | FUNC3); //D4
  LPC_SCU->SFSP1_12 = (MD_PLN_FAST | FUNC3); //D5
  LPC_SCU->SFSP1_13 = (MD_PLN_FAST | FUNC3); //D6
  LPC_SCU->SFSP1_14 = (MD_PLN_FAST | FUNC3); //D7
  LPC_SCU->SFSP5_4 = (MD_PLN_FAST | FUNC2);  //D8
  LPC_SCU->SFSP5_5 = (MD_PLN_FAST | FUNC2);  //D9
  LPC_SCU->SFSP5_6 = (MD_PLN_FAST | FUNC2);  //D10
  LPC_SCU->SFSP5_7 = (MD_PLN_FAST | FUNC2);  //D11
  LPC_SCU->SFSP5_0 = (MD_PLN_FAST | FUNC2);  //D12
  LPC_SCU->SFSP5_1 = (MD_PLN_FAST | FUNC2);  //D13
  LPC_SCU->SFSP5_2 = (MD_PLN_FAST | FUNC2);  //D14
  LPC_SCU->SFSP5_3 = (MD_PLN_FAST | FUNC2);  //D15
  LPC_SCU->SFSPD_2 = (MD_PLN_FAST | FUNC2);  //D16
  LPC_SCU->SFSPD_3 = (MD_PLN_FAST | FUNC2);  //D17
  LPC_SCU->SFSPD_4 = (MD_PLN_FAST | FUNC2);  //D18
  LPC_SCU->SFSPD_5 = (MD_PLN_FAST | FUNC2);  //D19
  LPC_SCU->SFSPD_6 = (MD_PLN_FAST | FUNC2);  //D20
  LPC_SCU->SFSPD_7 = (MD_PLN_FAST | FUNC2);  //D21
  LPC_SCU->SFSPD_8 = (MD_PLN_FAST | FUNC2);  //D22
  LPC_SCU->SFSPD_9 = (MD_PLN_FAST | FUNC2);  //D23
  LPC_SCU->SFSPE_5 = (MD_PLN_FAST | FUNC3);  //D24
  LPC_SCU->SFSPE_6 = (MD_PLN_FAST | FUNC3);  //D25
  LPC_SCU->SFSPE_7 = (MD_PLN_FAST | FUNC3);  //D26
  LPC_SCU->SFSPE_8 = (MD_PLN_FAST | FUNC3);  //D27
  LPC_SCU->SFSPE_9 = (MD_PLN_FAST | FUNC3);  //D28
  LPC_SCU->SFSPE_10 = (MD_PLN_FAST | FUNC3); //D29
  LPC_SCU->SFSPE_11 = (MD_PLN_FAST | FUNC3); //D30
  LPC_SCU->SFSPE_12 = (MD_PLN_FAST | FUNC3); //D31

  LPC_SCU->SFSP2_9 = (MD_PLN_FAST | FUNC3);  //A0
  LPC_SCU->SFSP2_10 = (MD_PLN_FAST | FUNC3); //A1
  LPC_SCU->SFSP2_11 = (MD_PLN_FAST | FUNC3); //A2
  LPC_SCU->SFSP2_12 = (MD_PLN_FAST | FUNC3); //A3
  LPC_SCU->SFSP2_13 = (MD_PLN_FAST | FUNC3); //A4
  LPC_SCU->SFSP1_0 = (MD_PLN_FAST | FUNC2);  //A5
  LPC_SCU->SFSP1_1 = (MD_PLN_FAST | FUNC2);  //A6
  LPC_SCU->SFSP1_2 = (MD_PLN_FAST | FUNC2);  //A7
  LPC_SCU->SFSP2_8 = (MD_PLN_FAST | FUNC3);  //A8
  LPC_SCU->SFSP2_7 = (MD_PLN_FAST | FUNC3);  //A9
  LPC_SCU->SFSP2_6 = (MD_PLN_FAST | FUNC2);  //A10
  LPC_SCU->SFSP2_2 = (MD_PLN_FAST | FUNC2);  //A11
  LPC_SCU->SFSP2_1 = (MD_PLN_FAST | FUNC2);  // A12
  LPC_SCU->SFSP2_0 = (MD_PLN_FAST | FUNC2);  //A13
  LPC_SCU->SFSP6_8 = (MD_PLN_FAST | FUNC1);  //A14
  LPC_SCU->SFSP6_7 = (MD_PLN_FAST | FUNC1);  // A15
  LPC_SCU->SFSPD_16= (MD_PLN_FAST | FUNC2);  // A16
  LPC_SCU->SFSPD_15= (MD_PLN_FAST | FUNC2);  // A17
  LPC_SCU->SFSPE_0 = (MD_PLN_FAST | FUNC3);  // A18
  LPC_SCU->SFSPE_1 = (MD_PLN_FAST | FUNC3);  // A19
  LPC_SCU->SFSPE_2 = (MD_PLN_FAST | FUNC3);  // A20
  LPC_SCU->SFSPE_3 = (MD_PLN_FAST | FUNC3);  // A21
  LPC_SCU->SFSPE_4 = (MD_PLN_FAST | FUNC3);  // A22
  LPC_SCU->SFSPA_4 = (MD_PLN_FAST | FUNC3);  // A23*/

  LPC_SCU->SFSP1_3 = (MD_PLN_FAST | FUNC3);  // OE
  LPC_SCU->SFSP1_6 = (MD_PLN_FAST | FUNC3);  //WE
  LPC_SCU->SFSP1_4 = (MD_PLN_FAST | FUNC3);  // BLS0
  LPC_SCU->SFSP6_6 = (MD_PLN_FAST | FUNC1);  // BLS1
  LPC_SCU->SFSPD_13 = (MD_PLN_FAST | FUNC2);  // BLS2
  LPC_SCU->SFSPD_10 = (MD_PLN_FAST | FUNC2);  // BLS3
  LPC_SCU->SFSP1_5 = (MD_PLN_FAST | FUNC3);  // CS0
  LPC_SCU->SFSP6_3 = (MD_PLN_FAST | FUNC3);  // CS1
  LPC_SCU->SFSPD_12 = (MD_PLN_FAST | FUNC2);  // CS2
  LPC_SCU->SFSPD_11 = (MD_PLN_FAST | FUNC2);  // CS3
  LPC_SCU->SFSP6_4 = (MD_PLN_FAST | FUNC3);  //CAS
  LPC_SCU->SFSP6_5 = (MD_PLN_FAST | FUNC3);  //RAS
  LPC_SCU->SFSCLK_0 = (MD_PLN_FAST | FUNC0);  //CLK0
  LPC_SCU->SFSCLK_1 = (MD_PLN_FAST | FUNC0);  //CLK1
  LPC_SCU->SFSCLK_2 = (MD_PLN_FAST | FUNC0);  //CLK2
  LPC_SCU->SFSCLK_3 = (MD_PLN_FAST | FUNC0);  //CLK3
  LPC_SCU->SFSP6_9 = (MD_PLN_FAST | FUNC3);  //DYCS0
  LPC_SCU->SFSP6_1 = (MD_PLN_FAST | FUNC1);  // DYCS1
  LPC_SCU->SFSPD_14 = (MD_PLN_FAST | FUNC2);  // DYCS2
  LPC_SCU->SFSPE_14 = (MD_PLN_FAST | FUNC3);   // DYCS3
  LPC_SCU->SFSP6_11 = (MD_PLN_FAST | FUNC3); //CKE0
  LPC_SCU->SFSP6_2 = (MD_PLN_FAST | FUNC1);   // CKEOUT1
  LPC_SCU->SFSPD_1 = (MD_PLN_FAST | FUNC2);   // CKEOUT2
  LPC_SCU->SFSPE_15 = (MD_PLN_FAST | FUNC3);   // CKEOUT3
  LPC_SCU->SFSP6_12 = (MD_PLN_FAST | FUNC3);  //DQMOUT0
  LPC_SCU->SFSP6_10 = (MD_PLN_FAST | FUNC3);  //DQMOUT1
  LPC_SCU->SFSPD_0 = (MD_PLN_FAST | FUNC2);   //DQMOUT2
  LPC_SCU->SFSPE_13 = (MD_PLN_FAST | FUNC3);  //DQMOUT3
  //
  // Setup EMC config for SDRAM, timings for 72MHz bus => 13,9ns
  // SDRAM: MT48LC4M32B2 on Keil MCB1857 Board
  //
  LPC_EMC->DYNAMICCONFIG0    = 0x00004500; //128Mb, 4Mx32, 4 banks, 12 rows, 8 columns
  
  LPC_EMC->DYNAMICRP         = 0x1;    // tRP = n + 1 clock cycles # min. 18ns
  LPC_EMC->DYNAMICRAS        = 0x3;    // tRAS = n + 1 clock cycles # min. 42ns
  LPC_EMC->DYNAMICSREX       = 0x5;    // tSREX = tXSR = n + 1 clock cycles # min. 70ns
  LPC_EMC->DYNAMICAPR        = 0x1;    // no tAPR => using tRCD = n + 1 clock cycles # min. 18ns
  LPC_EMC->DYNAMICDAL        = 0x5;    // tDAL = n clock cycles  # 5Cks = min. 30ns
  LPC_EMC->DYNAMICWR         = 0x1;    // tWR = n + 1 clock cycles  # min. 12ns
  LPC_EMC->DYNAMICRC         = 0x4;    // tRC = n + 1 clock cycles # min. 60ns
  LPC_EMC->DYNAMICRFC        = 0x4;    // tRFC = n + 1 clock cycles # min. 60ns
  LPC_EMC->DYNAMICXSR        = 0x4;   // tXSR = n + 1 clock cycles # min. 60ns
  LPC_EMC->DYNAMICRRD        = 0x1;    // tRRD = n + 1 clock cycles # min. 12ns
  LPC_EMC->DYNAMICMRD        = 0x1;    // tMRD = n + 1 clock cycles # 2CKs = min. 12ns
  //emc_WaitMS(200);
  LPC_EMC->DYNAMICCONTROL    = 0x00000183;
  emc_WaitMS(100);
  LPC_EMC->DYNAMICCONTROL    = 0x00000103;
  LPC_EMC->DYNAMICREFRESH    = 0x00000002;  // n * 16 clock cycles
  //for (i = 0; i < 0x80; i++);               // Wait 128 AHB clock cycles
  emc_WaitMS(100);
  LPC_EMC->DYNAMICREFRESH    = 50;  // n * 16 clock cycles (~ 1 pro MHz)
  LPC_EMC->DYNAMICRASCAS0    = 0x00000202;
  LPC_EMC->DYNAMICCONFIG0    = 0x00004500;
  //emc_WaitUS(200);
  //
  // Init SDRAM
  //
  LPC_EMC->DYNAMICCONTROL    = 0x00000083;// CLock Enable = driven HIGH, CLKOUT runs continously, Issue MODE command
  Dummy = *((volatile U32*)(SDRAM_BASE_ADDR | (0x22 << (2+8+2))));  // 4 burst, 2 CAS latency
  Dummy = Dummy;
  //for (i = 0; i < 0x80; i++);
  LPC_EMC->DYNAMICCONTROL = 0x00000000;//NORMAL;                             // Issue NORMAL command
  LPC_EMC->DYNAMICCONFIG0 = 0x00084500;//128Mb, 4Mx32, 4 banks, 12 rows, 8 columns, buffer enable
  }

Ich will den SDRAM mit emWin nutzen. Rufe _EMC_Init() in der HWConf.c 
unter _low_level_init() auf.

Wenn ich die .GUI_RAM section im RamLoc32 lasse, dann läuft es und ich 
bekomme etwas auf dem Display angezeigt. Will ich aber nun die section 
in den SDRAM verlinken, dann funktioniert es nicht mehr.


Reicht es im Linker script aus, wenn ich den Eintrag wie folgt mache?
(Ich nutze LPCXpresso IDE)

in der ...mem.ld-Datei

MEMORY
{
  /* Define each memory region */
  MFlashA512 (rx) : ORIGIN = 0x1a000000, LENGTH = 0x80000 /* 512k */
  MFlashB512 (rx) : ORIGIN = 0x1b000000, LENGTH = 0x80000 /* 512k */
  RamLoc32 (rwx) : ORIGIN = 0x10000000, LENGTH = 0x8000 /* 32k */
  RamLoc40 (rwx) : ORIGIN = 0x10080000, LENGTH = 0xa000 /* 40k */
  RamAHB32 (rwx) : ORIGIN = 0x20000000, LENGTH = 0x8000 /* 32k */
  RamAHB16 (rwx) : ORIGIN = 0x20008000, LENGTH = 0x4000 /* 16k */
  RamAHB_ETB16 (rwx) : ORIGIN = 0x2000c000, LENGTH = 0x4000 /* 16k */
  SDRAM (rwx) : ORIGIN = 0x28000000, LENGTH = 0x01000000 /* 16M */

}
  /* Define a symbol for the top of each memory region */
  __top_MFlashA512 = 0x1a000000 + 0x80000;
  __top_MFlashB512 = 0x1b000000 + 0x80000;
  __top_RamLoc32 = 0x10000000 + 0x8000;
  __top_RamLoc40 = 0x10080000 + 0xa000;
  __top_RamAHB32 = 0x20000000 + 0x8000;
  __top_RamAHB16 = 0x20008000 + 0x4000;
  __top_RamAHB_ETB16 = 0x2000c000 + 0x4000;
  __top_SDRAM = 0x28000000 + 0x1000000;

und in der .ld-Datei

          ...
/* MAIN BSS SECTION */
    .bss : ALIGN(4)
    {
        _bss = .;
        *(.bss*)
        *(COMMON)
        . = ALIGN(4) ;
        _ebss = .;
        PROVIDE(end = .);
    } > RamLoc32
    
    .GUI_RAM (NOLOAD): ALIGN(4)        /* hier ist mein Eintrag */
    {
      *(.GUI_RAM)
    } > SDRAM 
        
    /* NOINIT section for RamLoc40 */
    .noinit_RAM2 (NOLOAD) : ALIGN(4)
    {
      *(.noinit.$RAM2*)
      *(.noinit.$RamLoc40*)
       . = ALIGN(4) ;
    } > RamLoc40 
    /* NOINIT section for RamAHB32 */
    .noinit_RAM3 (NOLOAD) : ALIGN(4)
    {
      *(.noinit.$RAM3*)

            ...

Habe ich irgendeine Einstellung oder Anpassung beim Portieren vergessen 
bzw. übersehen?

Kann mir vielleicht jemand helfen oder bestätigen, dass die 
Initialisierungsfunktion bzw. der Aufruf im Linker-script in Ordnung 
sind?

Gruß Martin

[Arne (Gast)]

Zum Code kann ich nix sagen, aber Warteroutinen wie oben durchzuführen 
ist m.E. nach "bäääähhh".
Warum nimmst Du nicht den M3 internen Cyclecounter?

[Martin (Gast)]

Guten Morgen Arne,

der Cyclecounter sagt mir noch gar nichts oder meinst du damit den 
Systick? Ich wollte die Warteroutine sowieso noch auf Systick 
umstricken. Das werd ich wahrscheinlich gleich mal machen. An irgendwas 
muss es ja liegen..

[Arne (Gast)]

Nein.. nicht den Systick (wobei Du beim LPC18xx ja auch noch den RIT 
hättest). Ich meine den Cyclecounter, den jeder M3 im Kern haben sollte 
und der mit jedem ALU Clock inkrementiert wird (wie z.B. m.W. auch ab 
Pentium P5). Ist im M3 ein 32bit Counter.
Ich schalte an 0xE000EDFC Bit 24 ein und an 0xE0001000 Bit 0 und Bit 12.
Der Counterwert liegt an 0xE0001004.
Zieh dir mal 
http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337i/DDI0337I_cortexm3_r2p1_trm.pdf
Dort Kap.8.2. Ich hab mir da ein kleines API herum gebastelt.

[Martin (Gast)]

Hab mir jetzt mal den Cycle Counter angeschaut. Das klingt ja schon mal 
nicht schlecht. Wie gehe ich dann mit dem Counterwert um?
Ich verwende einen 72MHz Systemtakt. Also muss der Counter bis 72 
zählen, damit ich 1 µs erhalte. Jetzt kann ich ja ein Tap bei Bit 6 oder 
10 festlegen. So wie ich das verstanden habe, zählt, sobald CYCCNT 
dieses Tap-Bit erreicht hat, der POSTCNT ein Bit runter.
Der Anfangswert von POSTCNT wird mit POSTPRESET festgelegt. Wenn der 
Countdown (POSTCNT) == 0 ist, dann wird ein PC Sample Event ausgelöst.

Damit kann ich aber meinen Zählwert von 72 nicht realisieren (nur mit 
einem gewissen Fehler)(da Tap-Bit 6 = 64 und Tap-Bit 10 = 1024 ist).
Also kann ich mir doch das ganze so vorstellen, als ob das Tap-Bit für 
den Prescaler steht - Prescaler 64 oder 1024 !?

Will ich 1 ms haben, dann muss der Counter bis 72000 zählen. Jetzt kann 
ich das Bit 6 als Tap-Bit wählen und den POSTPRESET mit 1125 vorladen. 
Das PC Sample Event gibt mir dann die Millisekunde an.

Arne, wie hast du das gelöst?

[Arne (Gast)]

Sicher, dass Du da nicht was verkomplizierst?
1. setze das TCRA Bit: Schreibe (1 << 12) in 0xE000EDFC
2. lass den Counter loslaufen: schreibe ((1u << 12u) | (1u << 0)) an 
0xE0001000
3. lese für Zeitmessungen 0xE0001004 als uint32_t aus.

Jetzt kannst Du Dir eine Wait Funktion basteln oder eine 
wieviele-Ticks-sind-seit-Zeitstempel-x-vergangen Funktion. Umrechnen von 
Ticks in µs und zurück kannst Du ja generisch machen, so dass das immer 
funktioniert, egal welcher Takt an der ALU anliegt.

[Arne (Gast)]

Fehler vom Amt.
Es muss heißen:
1. setze das TCRA Bit: Schreibe (1 << 24) in 0xE000EDFC

Bau mal so eine Warteschleife von 1s Blinktakt:

while(1) {
    LED_ON();
    Wait(72000000); /* warte 72Mio clocks = 1s */
    LED_OFF();
    Wait(72000000); /* warte 72Mio clocks = 1s */
}

Häng ein Oszi an die LED und schaue, ob die Flanken schön mit 1s kommen.
Sollte klappen.

[Martin (Gast)]

Hi Arne,

ja das klappt auch super!! Danke für deine Tips. Den Timer zu 
realisieren ist ja wirklich nicht ganz so kompliziert, wenn man es mal 
gemacht hat. Für Werte im Millisekundenbereich bekomme ich auch relativ 
genaue Zeiten hin, aber im 100µs-Bereich und darunter macht sich der 
Fehler bemerkbar.

Hier mal mein Code:

#define CoreClock 72000000

/* ========== Debug Watchpoint Timer - DWT ============ */
#define DWT_CTRL   *((volatile unsigned long *) (0xE0001000))  
#define DWT_CYCCNT   *((volatile unsigned long *) (0xE0001004))  
#define DWT_ENABLE   *((volatile unsigned long *) (0xE000EDFC))  

void emc_WaitUS(volatile uint32_t us)
{
  DWT_ENABLE |= (1 << 24);          //enable DWT
  DWT_CTRL = (1 << 12) | (1 << 0);      //Bit 0:  Enable CYCCNT
                       
  DWT_CYCCNT = 0;
  while (DWT_CYCCNT < ((CoreClock/1000000)*us));
}

void emc_WaitMS(volatile uint32_t ms)
{
  DWT_ENABLE |= (1 << 24);          //enable DWT
  DWT_CTRL = (1 << 12) | (1 << 0);      //Bit 0:  Enable CYCCNT
                          
  DWT_CYCCNT = 0;
  while (DWT_CYCCNT < ((CoreClock/1000)*ms));
}

Liegt der Fehler im µs-Bereich am DWT Timer oder eher an meinem Code 
(der WHILE-Schleife)?

Ich werde morgen gleich mal den EMC mit dem Timer testen.

Glaube aber, dass das nicht das eigentliche Problem ist. Muss ich 
eigentlich beim Einbinden des externen Speichers im Startup-Code etwas 
ändern oder reicht die Änderung im Linker-Script?

[Arne (Gast)]

Bei den Warteschleifen kommt es ja i.d.R. nur darauf an eine Mindestzeit 
nicht zu unterschreiten. Dafür ist das Ding ganz nützlich.

[Martin (Gast)]

Hi Arne,

hab es jetzt hinbekommen, die _EMC_Init() wurde an der falschen Stelle 
aufgerufen. Hab jetzt die _low_level_init() in die startup-Datei 
integriert (wie im emWin_EA1788_BSP), sodass der EMC vor der main() 
initialisiert wird.

Dann habe ich die Initialisierung noch mal fein abgestimmt und für die 
Wartezeiten den Cycle Counter verwendet. Jetzt gehts... :-)

VIELEN DANK!!! :-)

[Heiner (Gast)]

Na dann kannst Du Dich ja jetzt an den RAM-Test wagen:
http://www.barrgroup.com/Embedded-Systems/How-To/Memory-Test-Suite-C

Dass EMC_Init() vor dem Kopieren des DATA Segmentes in das SDRAM und 
auch vor dem Ausnullen des BSS geschehen muss war schon klar, oder?

Ansonsten hast Du das von mir eingangs erwähnte "Henne-Ei" Problem.