zuviele RX Interrupts

[Lugge (Gast)]

Hallo,

ich brüte hier seit einiger Zeit über einem mir unverständlichen 
Problem.

Ich versuche gerade in einem bereits bestehenden, größeren Projekt, die 
serielle Schnittstelle (USART) zum laufen zu bekommen.
Um Strings, bzw längere Commandos empfangen zu können würde ich gerne in 
der RX-ISR einen FIFO Buffer befüllen. Leider scheint es, dass pro 
empfangenem Byte der Interrupt gleich mehrmals ausgelöst wird.

Habe die ISR mal zum Testen aufs wesentliche reduziert:


void INTUC2R(void)
{

    Sci_PutChar(UC2RXL.byte);  //Senden des gerade empfangenen Zeichens

    return;
}

Wobei Sci_PutChar die Funktion zum senden eines Bytes und UC2RXL.byte 
das Lowerbyte des Empfangsregister (RX) ist.

Mehr kann ich leider nicht posten da es sich wie gesagt um ein 
bestehendes, umfangreiches Projekt handelt. Allerdings ist der Rest für 
den USART nicht relevant.

Mein Problem: Sende ich in HTerm das Zeichen 'a' so empfange ich die 
Zeichen oxFF (Wert des RX Registers nach Reset) und 'a'. Sende ich 
danach das Zeichen 'b' so empfange ich 'a' und 'b'. Sende ich danach das 
Zeichen 'c' so empfange ich 'b' und 'c'. Usw.
Also werden mir 2 Zeichen zurückgeschickt obwohl der IR nur einmal 
auftritt. Einmal das alte und einmal das neue Zeichen.

Das der Fehler in der Sci-PutChar ist kann ich (sogutwie) ausschließen. 
Denn lasse ich in der ISR einen Integer hochzählen und debugge das 
Programm so erhöht sich der Wert des Integers um 2 pro gesendetem 
Zeichen.

USART-spezifische Register werden vom Rest des Projekts nicht verwendet, 
habe mit Eclipse das gesamte Projekt danach durchsucht.
Baudrate (115200 bps) und Modus (8N1) stimmen, da hab ich des öfteren 
drübergeschaut.
Prozessor ist ein V850E Phoenix (32-Bitter) von Renesas.
Datenblatt gibt keinen Hinweiß.

Zuhause an meinem AVR gings ohne Probleme :)

Kann mir jemand vielleicht nen Denkanstoß geben? Hat jemand sowas 
schonmal erlebt?

Achja, bevor ichs vergess: Ich sende über HTerm natürlich KEIN CR und 
KEIN LF. Ich sende wirklich nur 1 Byte.

Viele Grüße,
Lugge

[Purzel H. (hacky)]

In der ISR darf man natuerlich nicht auch grad senden. Ohne code plus 
sonstigen Beschrieb wird s schwierig...

[Frank M. (ukw) (Moderator)]

Lugge schrieb:
>     Sci_PutChar(UC2RXL.byte);  //Senden des gerade empfangenen Zeichens

Ich kenne den µC nicht, den Du verwendest. Aber mal eine Frage: wird mit 
der Verwendung von UC2RXL.byte das Zeichen auch automatisch "abgeholt", 
d.h. im Prozessor aus dem Empfangsregister genommen?

Ich glaube eher, der µC hat ein Eingangsfifo der Länge 2 und Du liest da 
munter im Fifo rum.

Ich weiss: Beim AVR reicht es, auf UDR zuzugreifen, damit das Zeichen 
auch aus dem Empfangsregister gelöscht wird. Ist es bei Deinem µC 
tatsächlich auch so?

Gruß,

Frank

[Lugge (Gast)]

Poly Oschi schrieb:
> In der ISR darf man natuerlich nicht auch grad senden. Ohne code plus
> sonstigen Beschrieb wird s schwierig...


Wieso nicht? Gibts da einen Grund? Zumindest Rechenzeit sollte meine ISR 
nichtviel beanspruchen, sonst kann ich da drin doch (fast) machen was 
ich will.
Aber ja, hab ja auch scho probiert das empfangene Zeichen einfach nur in 
nen Puffer zu schreiben, ohne was zu Senden. Das Zeichen lag dann öfter 
im Puffer. Deshalb eben nun diese Reduzierung aufs wesentliche.

@ Frank M.:

Nach mehrmaliger Lektüre des Datenblattes hab ich nichts gefunden was 
darauf hindeutet. Aber ich werd nochmal nen Blick reinwerfen (komm eh 
ned weiter :))

Danke euch trotzdem bisher!

Grüße,
Lugge

[Mat (Gast)]

ev. beide Bytes aus dem FiFo auslesen?
gruß

[Lugge (Gast)]

Welcher FIFO?
Der uC zumindest besitzt keinen. Hab grad extra nochmal nachgeschaut.
Es wird definitiv die ISR zu oft ausgelöst, das sehe ich ja wenn ich 
einen Integer in der ISR hochzählen lasse... :/

Langsam raucht mir der Schädel hier :)

[Lugge (Gast)]

Habs nun gefunden...

Liegt an einer Funktion namens Shared Interrupt. Irgendwas andres im 
System hat dadurch die selbe ISR aufgerufen. Was genau das war muss ich 
jetzt herausfinden.
Mit deaktiviertem Shared Interrupt gehts.

Muss mich mal einlesen was das genau sein soll, darüber bin ich jetzt 
eher zufällig gestolpert...

Lugge