Schwer einschätzbarer Fehler(Interrupts?)

[Mirkolski (Gast)]

Hallo zusammen,

ich sitze schon seit Stunden an folgendem Code:

int istTemp = 113;//convert2degree(adc_get(6));

uart_putc(STX);
uart_putc('c');
uart_puts(itoa(istTemp, NULL, 10));
uart_putc('t');
uart_puts(itoa((UART_SEND_RATE * counter)/100, NULL, 10));
uart_putc(ETX);

sreg_local = SREG;
cli();
N3310_ClearLcd();
N3310_goto(0, 0); N3310_PutStr(PSTR("Temp1"));
N3310_goto(42, 0); N3310_PutInt(adc_get(6));
//N3310_goto(42, 12); N3310_PutInt(istTemp);
SREG = sreg_local;

N3310 ist ein LCD Display. Der Code Ausschnitt wird alle 250ms 
durchgeführt.
Auf dem Display erscheint der Text nicht sauber. Wenn ich die vorletzte 
Zeile auskommentier, dann erscheint der Text auf dem LCD für 9sekunden 
sauber und danach nicht mehr. Wenn ich cli() und sei() weg lasse erhalte 
ich keinen Unterschied. nur wenn ich kein Zeichen über den UART sende 
läuft der Code ohne Probleme. Die Uart Ausgabe läuft über einen 
Interrupt. Für mich ist diese Phänomen absolut unverständlich. Ich hoffe 
jemand von euch kann mir das erklären. Die Interrupt Routine sieht so 
aus:

ISR (UART0_TRANSMIT_INTERRUPT)
/*************************************************************************
Function: UART Data Register Empty interrupt
Purpose:  called when the UART is ready to transmit the next byte
**************************************************************************/
{
    unsigned char tmptail;

    
    if ( UART_TxHead != UART_TxTail) {
        // calculate and store new buffer index
        tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;
        UART_TxTail = tmptail;
        // get one byte from buffer and write it to UART
        UART0_DATA = UART_TxBuf[tmptail];  // start transmission
    }else{
        // tx buffer empty, disable UDRE interrupt
        UART0_CONTROL &= ~_BV(UART0_UDRIE);
    }
}

[Oliver S. (oliverso)]

Na ja, wenn das der ganze Code ist, wirst du da noch länger dran sitzen. 
Wenn nicht, zeig den Rest. Glaskugeln sind aus.

Ganz prinzipiell ist C-Code, der am sreg rumfummelt, immer suspekt.

Oliver

[Johann L. (gjlayde)]

Mirkolski schrieb:

> uart_puts(itoa(istTemp, NULL, 10));

Lies nochmals aufmerksam die Doku zu itoa!

Du mußt genügend Platz für das Ergebnis der Umwandlung zur Verfügung 
stellen.  NULL tut dies keinesfalls, die schreibst irgendwo in der SFR- 
oder GPR-Bereich.

[Jörg W. (dl8dtl) (Moderator)]

Oliver S. schrieb:
> Ganz prinzipiell ist C-Code, der am sreg rumfummelt, immer suspekt.

Er rettet und restauriert das SREG ja nur.

Sowas kann seine Berechtigung haben (wenn Code sowohl aus einem
Interrupt- als auch regulären Kontext gerufen wird), aber in 99 % der
Fälle weiß man eigentlich vorher, ob man aus einem Interruptkontext
gerufen wird oder nicht, und kann dann hart cli()/sei() rufen.

[Oliver (Gast)]

Jörg Wunsch schrieb:
> in 99 % der Fälle

ist das vor allem ein Zeichen dafür, daß der Code unverstanden aus 
irgendwelchen veralteten oder fragwürdigen Quellen übernommen wurde.

Das muß jetzt hier nicht der Fall sein, aus dem gezeigten Codeschnipsel 
lässt sich ja nichts erkennen.

> Mirkolski schrieb:
>> uart_puts(itoa(istTemp, NULL, 10));

Kommt drauf an, wie NULL definiert ist ;)
Wenn NULL aber tatsächlich 0 ist, schreibt er in die Register ab R0. Das 
hat schon was ;)

Oliver

[Mirkolski (Gast)]

Die uart_putc Methode sieht so aus:

/*************************************************************************
Function: uart_putc()
Purpose:  write byte to ringbuffer for transmitting via UART
Input:    byte to be transmitted
Returns:  none          
**************************************************************************/
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 */

könnte es sein, das diese Schleife

while ( tmphead == UART_TxTail ){
        ;/* wait for free space in buffer */
}

ununterbrochen ausgeführt wird wenn die Interrupts ausgeschaltet werden, 
denn der Buffer wird ja nur in der Interrupt Methode geleert?
Aber eigentlich ist das bei mir nicht der Fall, denn die Zeichen auf dem 
Display werden plötzlich falsch dargestellt. Das Display kommuniziert 
über SPI, aber ohne Interrupts. Das ganze ist mir sehr schleierhaft.

[Karl H. (kbuchegg)]

Mirkolski schrieb:

> Könnte es sein ...
> denn der Buffer wird ja nur in der Interrupt Methode geleert?

Nein.
Welchen Teil von:

   itoa(istTemp, NULL, 10))

"du kannst hier keinen NULL Pointer nehmen"
verstehst du nicht.

Du bügelst hier über die Register drüber. Ab diesem Zeitpunkt werden 
keine Wetten mehr angenommen, was danach alles im Detail passiert bzw. 
nicht mehr funktioniert.

itoa braucht eine Speicherfläche, in der es die Textrepräsentierung 
aufbaut. Es ist DEIN Job, einen entsprechenden Speicher dafür bereit zu 
stellen.

PS: Das heißt nicht, dass es nicht noch mglw. weitere Probleme gibt. 
Aber das ist mit Sicherheit dein erstes Problem. Und wenn ich hinzufügen 
darf, ist es ein Hinweis darauf, dass in deinem C-Verständnis sich eine 
ganz große Lücke auftut. Konkret: wie funktioniert Speicherverwaltung im 
allgmeinenen bzw. Stringverarbeitung im besonderen.

[Mirkolski (Gast)]

Manchmal ist das Ziel so nah und der Weg dort hin... auch ;)
Vielen Dank

[Mark B. (markbrandis)]

Harter Zugriff auf den NULL pointer... sieht man auch nicht alle Tage 
;-)