Ram Test mit komischem Ergebnis

[Paule_ (Gast)]

Hallo,

vor kurzem hatte ich Probleme mit meinem ext. RAM (32kx8). Daher wollte 
ich ein kleines Testprogramm schreiben, welches mir mal mitteilt, wann 
ein Schreib-/Lesefehler auftritt.
Dazu reserviere ich Speicherblöcke der Größe sizeof(char)*x mittels 
malloc(). Danach schreibe ich Werte hinein, lese diese wieder und schaue 
ob da was im Argen lag. Der Block wird wieder frei gegeben, x wird 
inkrementiert und das ganze beginnt wieder von vorn. Ist nicht besonders 
schön, aber einfach :)
Nun kam bei der Sache herraus, dass nach 10238 reserveirten Bytes ein 
Fehler auftrat. Komisch finde ich bei dieser Zahl nur, dass das ziemlich 
die Hälfte meines reservierten Heaps darstellt:
--defsym=__heap_start=0x804000,--defsym=__heap_end=0x808fff
Außerdem war es ein Schreib-/Lesefehler und kein Fehler bei der 
Reservierung des Speicherblocks.

Mein Verdacht viel auf eine weiter kalte Lötstelle bei einem Adresspin. 
Falls ich also zu heap_start die 10238 Byte hinzurechne komme ich auf 
die Adresse 0x806801, welche keinen signifikaten Sprung in der binären 
Adresse aufweißt. Ich bin mir aber auch nicht sicher, ob man das so 
rechnen darf. Ich lasse mir von meinem Testprog auch die Adresse des 
reservierten Speicherblockes zurückgeben, welche beim Abbruch dez 10238 
ist. Aber was zeigt mir diese Adresse? Einen Ort nach heap_start, also 
10238 + 0x804000?

Generell frage ich mich, ob dieses Verhalten noch normal ist, oder ob da 
wirklich noch wo der Wurm drin ist?


PS: mein anderer Beitrag 
Beitrag "SRAM liefert flasche Werte zurück"

[Paule_ (Gast)]

sry

die ausgegebene Adresse ist 26625 und nicht 10238!

[Knut B. (Firma: TravelRec.) (travelrec)]

Ist es nicht einfacher, alle Lötstellen zu überprüfen? Neue SRAMs sind 
in aller Regel zu 100% in Ordnung. Bei ausgelöteten oder sehr alten 
SRAMs kann es schon mal zu Merkwürdigkeiten kommen. Wichtig ist 
außerdem, daß die Betriebsspannung des SRAMs innerhalb der 
Spezifikationen liegt und das Schnittstellen-Timing genau eingehalten 
wird.

[oszi40 (Gast)]

Auch wenn alle RAMs vom Werk aus "in Ordung" sind, könnte z.B. noch eine 
Zinnperle auf der Schaltung liegen.

Speicherfehler sind zwar selten geworden, aber gerade in den ersten 
Tagen nach der Montage kann man Frühausfälle häufiger beobachten. 
Deshalb ist ein kleiner Test nach der Bestückung immer lobenswert.

[Sepp (Gast)]

Also diesen blöden Riegel hab ich jetzt schon 2 oder drei mal 
nachgelötet und des öfteren dessen Anschlüsse geprüft. Aber der Fehler 
bleibt.

Also nach mehreren Testläufen ist immer der Fehler bei 10238 Byts 
Blöckgröße aufgetreten. Da ich sonst keinen malloc Befehl ausführe, gehe 
ich davon aus, dass der Heap soweit leer ist. Also geht irgendwas bei 
der Speicheradresse von 0x8038FE schief.
Rein binär sollte bei der Adresse kein Bit gesetzt worden sein, welches 
vorher nicht auch schon mal gesetzt war und zu keinem Fehler geführt 
hat. Daher würde ich schon mal die Adressleitungen ausschließen. Die 
Datenleitungen könnens aber auch nicht sein, da ja bis dahin immer alles 
passte.
-> bin ratlos

Jetzt löte ich nochmal alles nach....

[Sepp (Gast)]

Ach ja: Sepp = Paule_ ;)

[Paule_ (Gast)]

Alles nachgelötet, aber keine Verbesserung/Änderung.

[Paule_ (Gast)]

Hier mal mein Testprogramm. Evtl ist ja da der Wurm drin:

int main(void)
{
  init_hardware();
  uart1_init();
  char *pHeap;
  char *zeichen = "X";
  unsigned int size = 1;
  unsigned int isize = 0;
  rs232_puts("Initialisierung des Boards erfolgreich.");
  LED_RT(0);
  LED_GE(0);
  LED_GN(1);

  rs232_puts("Schreibe Werte in Heap. Bitte warten...");

  while(1)
  {
    //gelbe und rote LEDs blinken
    static uint16_t ledcnt,t;
    ledcnt++;
    if(ledcnt%100 == 0)
    {
      t=!t;
      LED_GE(t);
      LED_RT(t);
      
    }
    
                //Speicher reservieren
    pHeap = malloc(size);
    if(pHeap == 0){
      rs232_puts("malloc = 0");
      goto end;
    }
    
                //Beschreiben
    while(size!=isize){
      memcpy(pHeap+isize,zeichen,1);
      isize++;
    }
    isize=0;
    
                //Lesen
    while(size!=isize){
      if(memcmp(pHeap+isize,zeichen,1)!= 0){
        rs232_puts("ungleich");
        rs232_puts("Inhalt:");
        rs232_putcn(pHeap,isize+10); //evtl gibts ja noch was zu sehen
        goto end;
      }
      isize++;
    }
    isize=0;
      
    size++;
    free(pHeap);
  }
  end:
  rs232_puts("Abgebrochen bei einer Blockgroesse von:");
  rs232_puti((int)size);
  rs232_puts("Adresse:");
  rs232_puti((int)pHeap);

  return 0;
}