IRQ hängt ab und zu - Warum?

Hallo

Ich versuche einen ADUC7000 (ARM7) zu programmieren.
Im Moment hänge ich an den Uart-Funktionen.

Ich habe ein FIFO im SRam zum Senden und Empfangen angelegt.

Wenn Daten gesendet werden sollen, landen diese im FIFO.
So bald das Uart Senderegister leer ist, wird ein IRQ
ausgelöst. In der IRQ-Funktion wird ein Byte aus dem FIFO
ins Senderegister kopiert.

Wenn Daten in das FIFO schneller geschrieben werden, als die
Daten über die IRQ-Funktion gesendet werden können, wird eine
Statusvariable auf 2 gesetzt, damit im Programm erkannt werden
kann, dass gewartet werden muss, bis wieder Platz im Puffer ist.

Das funktioniert fast.
Dies ist meine Sendefunktion:

char UartWrite (char *ptr, char wait) { // Sende String ueber uart, Wenn 
wait==1, wird gewartet, bis der String vollstaendig
    // gesendet werden konnte. Soll nicht ewartet werden und der 
TX-Puffer laeuft ueber, wird die Position des Zeichen im
    // String zurueckgegeben, die nicht mehr gesendet werden konnte
  char *origptr = ptr;
  char CharSent;
  while (*ptr!='\0') {
    CharSent = UartPutChar (*ptr); // Uebergebe einzelnes Zeichen an 
Sendefunktion
    ptr++;
    if (CharSent==0) { // Puffer ist voll. Warte oder gebe Position des 
letzten gesendeten Zeichen zurueck
      if (wait){
        while (uarttxbufferstatus==2) {
          int bla1 = 7;
          int bla2 = 80;
        } // Warte bis Platz in TX-Puffer ist
      }
      else
        return *ptr; // Gebe Position des noch zu sendenden Zeichen aus
    }
  }
  return *origptr; // Gebe Pointer auf String zurueck, wenn alles 
gesendet wurde.
}



Was ich nicht ganz verstehe ist, dass der Code so funktioniert. Ich 
musste
in die inntere while-Schleife Variablen definieren. Eigentlich hätte 
folgender
Code gereicht:
        while (uarttxbufferstatus==2) {
        } // Warte bis Platz in TX-Puffer ist
Das Problem ist, dass dann der IRQ nicht mehr ausgelöst wird.
Hat einer von euch eine Idee wieso?


Beim Empfangen von Zeichen habe ich ebenfalls IRQ-Probleme. So bald 
Daten
im Empfangsregister liegen, wird ein IRQ ausgelöst. Die Daten werden 
dann
in einen FIFO kopiert. Einzelne Zeichen werden mit der Funktion 
UartRXGet()
empfangen:

char UartGetChar(void) { // Lese Zeichen aus Empfangspuffer
  char RETURN = 0;
  if (uartrxbufferstatus!=0) { // Zeichen in Empfangsringspeicher
    RETURN = uartrxbuffer[readuartrxbuffer];
    readuartrxbuffer++; // Aendere Position im Empfangsringspeicher
    readuartrxbuffer %= sizeof(uartrxbuffer);
    if (uartrxbufferstatus==2) uartrxbufferstatus = 1;
    if (writeuarttxbuffer == readuarttxbuffer) { // Empfangspuffer ist 
nun leer, setzte auf 0 zurueck
      uartrxbufferstatus = 0;
    }
  }
  return RETURN; // Gebe 0 zurueck, wenn kein Zeichen empfangen wurde
}

char UartRXGet(void) { // Warte bis Zeichen empfangen wurde und gebe 
dieses aus
  char ReturnChar = 0;
  while (!ReturnChar) {
    ReturnChar = UartGetChar();
    UartIrq(); // Warum muss hier diese Funktion aufgerufen werden?
  }
  return ReturnChar;
}

Hier habe ich ein ähnliches Problem. Der IRQ wird nicht immer ausgelöst.
Mein Programm hängt ewig in der while-Schleife fest. Desshalb habe ich 
in
die while-Schleife meine IRQ-Funktion für den Uart eingefügt. So 
funktioniert
der Code dann, aber ich weiß nicht wieso.

Dies ist meine IRQ-Funktion:

void UartIrq (void) {
  if (COMSTA0 & 0x01) { // Zeichen in RX Puffer
    if (uartrxbufferstatus!=2) { // Es ist noch Platz im Puffer
      uartrxbuffer[writeuartrxbuffer] = COMRX;
      writeuartrxbuffer++; // Aendere Position im Empfangsringspeicher
      writeuartrxbuffer %= sizeof(uartrxbuffer);;
      if (writeuartrxbuffer == readuartrxbuffer) { // Sendepuffer ist 
nun voll -> Gebe als Fehler 0 zurueck
        uartrxbufferstatus=2; // Puffer ist voll
      }
      else
        uartrxbufferstatus = 1; // Im Puffer liegen nun Daten
    }
    else { // Ueberschreibe aeltesten Wert in Puffer, damit das aelteste 
Zeichen verloren geht
      uartrxbuffer[writeuartrxbuffer] = COMRX;
      writeuartrxbuffer++; // Aendere Position im Empfangsringspeicher
      writeuartrxbuffer %= sizeof(uartrxbuffer);;
      readuartrxbuffer++; // Aendere Position im Empfangsringspeicher. 
Leseposition muss ebenfalls geaendert werden
      readuartrxbuffer %= sizeof(uartrxbuffer);;
    }
  }
  if (COMSTA0 & 0x40) { // TX Puffer leer.
    if (uarttxbufferstatus!=0) { // Zeichen in Senderingspeicher
      COMTX = uarttxbuffer[readuarttxbuffer]; // Sende Zeichen
      readuarttxbuffer++; // Aendere Position im Senderingspeicher
      readuarttxbuffer %= sizeof(uarttxbuffer);
      if (readuarttxbuffer==writeuarttxbuffer) { // Puffer ist nun leer
        COMIEN0 = 0x01; // Schalte TX-IRQ ab, Senderingspeicher leer.
        uarttxbufferstatus = 0; // Setzte Status = 0, also keine Daten 
mehr in Puffer
      }
      else
        uarttxbufferstatus = 1; // Puffer kann nicht mehr voll sein, da 
ein Element gesendet wurde
    }
    if (uarttxbufferstatus==0) { // Keine Zeichen in Puffer, Schalte IRQ 
ab.
      COMIEN0 = 0x01;
    }
  }

}

void IRQ_Function (void) {
  if (IRQSIG & UART_BIT) { // Uart
    UartIrq(); // Zeichen wurde empfangen
  }
}


Ich habe versucht herauszufinden, warum der IRQ nicht ausgelöst wird.
Für den Uart gibt es die Statusregister COMSTA0 und COMIEN0. In COMIEN0
wird eingestellt, ob ein volles RX oder ein leeres TX Register einen IRQ
auslöst. Mit COMSTA0 kann abgefragt werden, ob RX voll oder TX leer ist.

Ich habe in Eclipse das Programm an den entsprechenden Stellen 
angehalten
und die Register COMSTA0 und COMIEN0 angeschaut. Laut diesen Registern 
müsste
ein IRQ ausgelöst werden.

Ich kenne mich mit der Materie noch nicht so gut aus.

Hat einer von euch einen Tip für mich, wie ich weitermachen könnte?
Ich habe mir überlegt die Register abzufragen, in denen gespeichert 
wird,
ob sich die CPU gerade im Interrupt Mode befindet. DAs könnte ein Grund
sein, warum kein IRQ mehr ausgelöst wird. Ich habe nur leider keine 
Ahnung,
wie man so etwas machen könnte.

Bis dann, Tilo