Zeiger Strings ausgeben?!

[Jan H. (janiiix3)]

Moin Moin.

Wieso hängt sich der µC auf, wenn ich die Strings ausgeben will?

typedef struct  
{
  const char *ProjectName;
  const char *HardwareVersion;
  const char *SoftwareVersion;
  const char *HardwareDate;
  const char *SoftwareDate;
}DevBoard_t;

DevBoard_t  Message={
  
  .ProjectName    = "DevBoard\r\n",
  .HardwareVersion  = "Hardware Version 1.0\r\n",
  .SoftwareVersion  = "Software Version 1.0\r\n",
  .HardwareDate    = "Hardware from 18.04.17\r\n",
  .SoftwareDate    = "Software from 30.05.17\r\n",
};

uart_puts(Message.ProjectName);

[Frank M. (ukw) (Moderator)]

Jan H. schrieb:
> Wieso hängt sich der µC auf, wenn ich die Strings ausgeben will?

Vielleicht, weil die Funktion uart_puts() fehlerhaft implementiert 
wurde? Sonst gibt es auf kleinen µCs noch tausend andere Gründe, wie 
z.B. Größe des RAMs usw.

Ein

int main ()
{
    fputs (Message.ProjectName, stdout);
    return 0;
}

funktioniert unter Linux jedenfalls einwandfrei.

Um welchen µC handelt es sich denn? Und wie sieht der Rest des Programms 
aus?

Hängt sich der µC wirklich auf, wenn Du nur so eine kleine 
main()-Funktion hast, oder hast Du noch 30000 weitere Zeilen an Code?

Bitte ein compilierbares, reproduzierbares Beispiel angeben.

[Jan H. (janiiix3)]

Die Uart Routinen sind hier von der Seite..
Andere Strings kann ich an dieser Stelle, wo ich eigentlich diese 
Strings ausgeben will, ohne Probleme ausgeben.

Verwenden tue ich einen ATMEGA32.

[Rufus Τ. F. (rufus)]

Jan H. schrieb:
> Die Uart Routinen sind hier von der Seite..

Ach so. Auf µc.net gibt es auch nur genau einen Satz UART-Routinen ...

[Jan H. (janiiix3)]

/*************************************************************************
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 */

/*************************************************************************
Function: uart_puts()
Purpose:  transmit string to UART
Input:    string to be transmitted
Returns:  none          
**************************************************************************/
void uart_puts(const char *s )
{
    while (*s) 
      uart_putc(*s++);

}/* uart_puts */

Diese werden verwendet..

[Stefan E. (sternst)]

Kann es sein, dass du versuchst, die Strings innerhalb einer ISR 
auszugeben?

[Jan H. (janiiix3)]

Stefan E. schrieb:
> Kann es sein, dass du versuchst, die Strings innerhalb einer ISR
> auszugeben?

Nein. Das passiert alles bevor sei() aufgerufen wird.

[Marius (Gast)]

Wahrscheinlich läuft der UART-Software-Puffer voll, wenn du den String 
ohne aktivierte Interrupts ausgibst. Dann wartet die Ausgabe bei

;/* wait for free space in buffer */

, weil kein Interrupt passiert, der den Puffer leert.

Gruß
Marius

[Frank M. (ukw) (Moderator)]

Jan H. schrieb:
> UART0_CONTROL    |= _BV(UART0_UDRIE);

Das Zeichen soll also in einer ISR ausgegeben werden. Wo ist die ISR 
dazu?

> Das passiert alles bevor sei() aufgerufen wird.

Wie soll das gehen? Ohne sei() kein Interrupt, ohne Interrupt kein 
ISR-Auffruf! Ohne ISR-Aufruf keine Ausgabe von Zeichen! Das kann so 
nicht gehen.

Pardon, aber mit so einer Salamitaktik kann man den Fehler nicht finden.

Ich wiederhole nochmal:

Bitte zeige ein compilierbares Programm mit reproduzierbarem Fehler. 
Sonst ist das ein Stochern im Dunkeln. Der Fehler kann überall sein, nur 
nicht in Deinem bisher gezeigten Code.

[Jan H. (janiiix3)]

Ah okay.
Habs verstanden.

Jetzt funktioniert es aber. Scheint wirklich der Puffer voll zu laufen.

Besten Dank!

[Frank M. (ukw) (Moderator)]

Jan H. schrieb:
> Was hat denn die Ausgabe mit einem Interrupt zu tun?

Dein oben zitiertes uart_puts() gibt das Zeichen gar nicht aus. Es 
kopiert das Zeichen nur in einen Ringbuffer und aktiviert dann den 
UART-Empty-Interrupt. Dieser wird ausgelöst, wenn der UART leerläuft. 
Die ISR kopiert dann das nächste auszugebende Zeichen ins UART-Register. 
Die eigentliche Ausgabe läuft also nicht in uart_puts(), sondern in der 
ISR.

> Das habe ich noch
> nicht ganz verstanden. Wenn ein Zeichen rein kommt, weiß ich das es ein
> Interrupt gibt.

Siehe oben. Wenn der UART kein Zeichen auszugeben hat, dann löst er 
einen UDRIE-Interrupt aus. Genau diesen aktiviert Dein uart_puts():

> UART0_CONTROL |= _BV(UART0_UDRIE);

> Jetzt funktioniert es aber. Scheint wirklich der Puffer voll zu laufen.

Lass mich raten: Du hast den sei()-Aufruf nach vorne gezogen.

Achja, bitteschön. ;)