TX UART Problem Peter Fleury

[Thomas (Gast)]

Hallo,

ich habe ein Problem mit der UART Lib von Peter Fleury:

void uart_putc(unsigned char data)
{
    unsigned char tmphead;

    
    tmphead  = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;
    
    while ( tmphead == UART_TxTail ){
        ;/* wait for free space in buffer */
    }
    
    UART_TxBuf[tmphead] = data;
    UART_TxHead = tmphead;

    /* enable UDRE interrupt */
    UART0_CONTROL    |= _BV(UART0_UDRIE);

}/* uart_putc */

Wenn ich mittels uart_puts("dsadkljK") etwas verschicken will bleibt der 
Controller auf der Zeile

while ( tmphead == UART_TxTail ){

stehen. In beiden Variablen steht dann eine 0x12...

Wieso ist das so? Wieso while() ohne darin was zu tun?

Vielleicht kann mir jemand weiterhelfen, in jedem Fall vielen Dank!
Thomas

[Stefan B. (Gast)]

Das Programm wartet - wie dokumentiert - an dieser Stelle, weil im 
Sendepuffer momentan kein weiterer Platz ist. Weiterer Platz wird erst 
geschaffen, wenn Zeichen von der UDRE Interruptroutine gesendet werden.

In deinem unbekannten Programm werden anscheinend von der UDRE 
Interruptroutine keine Zeichen gesendet. Das kann an einem Fehler im 
selbst geschriebenen Programmteil liegen, den wir nicht sehen. 
Möglicherweise die Fleury Library ist von dir nicht richtig 
initialisiert und/oder Interrupts sind noch nicht global aktiviert.

[Stefan E. (sternst)]

Das wahrscheinlichste ist, dass an der Stelle die Interrupts nicht 
aktiviert sind, entweder weil sie explizit deaktiviert sind, oder 
implizit. Du versuchst nicht etwa innerhalb einer ISR was zu senden, 
oder?

[Thomas (Gast)]

Hm gute Frage mit in einer ISR. Ich rufe aus einem Timer eine Funktion 
auf die dann was ausgeben will... das zählt dann wohl als aus einer ISR.

[Karl H. (kbuchegg)]

In einer ISR werden grundsätzlich keine länger andauernden Operationen 
durchgeführt. Weder wird auf irgendetwas gewartet, noch macht man 
Ausgaben. Das ist eine einfache Regel, die nur dann zu Problemen führt, 
wenn man sie nicht beachtet.

[Thomas (Gast)]

Naja drum hätte ich ja auch gerne ein paar Zeichen in den Ausgangspuffer 
geschrieben und fertig.

[Stefan E. (sternst)]

Thomas schrieb:
> Naja drum hätte ich ja auch gerne ein paar Zeichen in den Ausgangspuffer
> geschrieben und fertig.

Das funktioniert aber nur, wenn auch entsprechend Platz im Puffer ist. 
Wenn kein Platz mehr ist, hast du den von dir beobachteten Deadlock.

[Thomas (Gast)]

Ja danke euch beiden... Da muss ich wohl was umbauen.

[daniel (Gast)]

mach doch so ...

uINT8 flags;
#define SHOULD_SEND    0
#define SHOULD_DO_XYZ  1
...


ISR(..._vect) {
    flags |= 1UL << SHOULD_SEND;
}

int main(void) {
    while(1) {
        if(flags & (1UL << SHOULD_SEND)) {
            flags &= ~(1UL << SHOULD_SEND);
            call_send_routine();
        }
        // ...
    }
}

[Simon K. (simon)]

Beim Löschen des Flags muss/müssen der/die Interrupt/s gesperrt werden. 
Man kann auch statt den Flags + Interrupts nur das Interruptflag 
abfragen in der main-loop (Aber dann die Interrupts deaktivieren).

[Thomas (Gast)]

Ja ich habe in etwa die Lösung von Daniel umgesetzt.
Ich setzt nur noch Flags in der ISR für 10/100ms Tasks die dann in der 
Main abgearbeitet werden...