Atmega16 USART_UDRE_vect interrupt

[Markus W. (kornbanane)]

Hallo Leute,

ich hab die Kommunikation über UART mit meinem Atmega16 über einen 
Ringbbuffer gelöst. Dabei wird mithilfe des Interruptvektors 
USART_UDRE_vect jedesmal ein neues Zeichen ins Senderegister geschoben, 
wenn das Senderegister leer ist. Im Datenblatt steht zu diesem Interruot 
folgendes:

 • Bit 5 – UDRE: USART Data Register Empty
The UDRE Flag indicates if the transmit buffer (UDR) is ready to receive new data. If UDRE is
one, the buffer is empty, and therefore ready to be written. The UDRE Flag can generate a Data
Register empty Interrupt (see description of the UDRIE bit).
UDRE is set after a reset to indicate that the transmitter is ready.



Bit 5 – UDRIE: USART Data Register Empty Interrupt Enable
Writing this bit to one enables interrupt on the UDRE Flag. A Data Register Empty Interrupt will
be generated only if the UDRIE bit is written to one, the Global Interrupt Flag in SREG is written
to one and the UDRE bit in UCSRA is set.

So weit so gut, es funktioniert auch, aber ich habe ein 
Verständnissproblem. Und zwar steht im Datenblatt, das der Interrupt 
aufgerufen wird, sobalt das Senderegister leer ist. Wenn nun aber sagen 
wir das Senderegister jetzt die nächsten 10 minuten leer bleibt, wird 
dann zig 1000 mal die Interruptroutine aufgerufen ? Weil das ginge am 
eigendlichen sinn der Sache vorbei (is ja auch wieder polling). Oder 
wird sie nur einmal aufgerufen, nachdem das Senderegister leer ist und 
dann ist Ruhe ?

Gruß Markus

[Manuel S. (steinerhippo)]

Markus Wi*** schrieb:
> Wenn nun aber sagen
> wir das Senderegister jetzt die nächsten 10 minuten leer bleibt, wird
> dann zig 1000 mal die Interruptroutine aufgerufen ?

Ja, der Interrupt muss nach dem Sendevorgang deaktiviert werden. Siehe 
dazu auch:

http://www.mikrocontroller.net/articles/Interrupt#UART_mit_Interrupts

In

ISR(USART_UDRE_vect)

 steht foldendes:

char data;

// Ende des nullterminierten Strings erreicht?
if (data==0 ) {        
    UCSRB &= ~(1<<UDRIE);       // ja, dann UDRE Interrupt ausschalten
    ...
    ...
}

[Markus W. (kornbanane)]

Danke erst mal soweit, das hat mir schon weiter geholfen.

Habe es nun so umgesetzt:

/// Für die Kommunikation über die UART0 Schnittstelle
unsigned char uart0_tx_buffer[255];      // Sendebuffer
unsigned char uart0_tx_buffer_pointer=0;  // Zeigt auf den nächsten freien Speicherbereich im Sendebuffer
unsigned char uart0_txd_pointer=0;      // Zeige auf das nächste zu sendende Zeichen im Sendebuffer
unsigned char uart0_tdx_complete=0;      // Zeigt an, ob alle Zeichen gesendet wurden (=1)


//---------------------------------------------------------------------------
// ISR(USART_TXC_vect)
//
// functiondescription:  Interrupt für USART0 Data Register Empty. Prüft, ob weitere Zeichen im Sendebuffer stehen und sendet diese
//
// hand over:
//  - input parameters: nothing
// returns:
//  - return parameter: nothing
//---------------------------------------------------------------------------
ISR(USART_UDRE_vect)
{
  if(uart0_txd_pointer!=uart0_tx_buffer_pointer)    // Es stehen noch ungesendete Zeichen im Sendebuffer
  {  
    //while(UDRE!=1);
    UDR=uart0_tx_buffer[uart0_txd_pointer];
    //PORTC = uart0_tx_buffer[uart0_txd_pointer];
    uart0_txd_pointer++;
    if(uart0_txd_pointer>255) uart0_txd_pointer=0;  // Zur Sicherheit, kann hier aber nicht passieren, da unsigned char sowieso überläuft 
  }
  else
  {
    UCSRB &= ~(1<<UDRIE);                 // den UDRE Interrupt ausschalten
    uart0_tdx_complete=1;              // Alle Zeichen gesendet
    PORTC = 0x0A;
  }  
}




//---------------------------------------------------------------------------
// InitUART
//
// functiondescription:  Initialisiert die UART Schnittstelle
//
// hand over:
//  - input parameters: nothing
// returns:
//  - return parameter: nothing
//---------------------------------------------------------------------------
void Inituart0(void)
{
  UCSRB=0x4C;          // 8N1, RX und TX Enable, RX Interrupt
  UCSRC=0x86;          // 8N1; Asynchron; kein Paritätsbit  
  UBRRH = 0;          // Für 9600Baud@16Khz
  UBRRL = 103;        // Für 9600Baud@16Khz
}




//---------------------------------------------------------------------------
// putch
//
// functiondescription:  Schreibt das zu sendende Zeichen in den Sendebuffer der jeweiligen Schnittstelle
//
// hand over:
//  - input parameters: Zu sendendes Zeichen; Schnittstelle über die gesendet werden soll
// returns:
//  - return parameter: nothing
//---------------------------------------------------------------------------
void putch(unsigned char character, unsigned char channel)
{
  switch (channel)
  {
    case 0:
    {
      
      uart0_tdx_complete=0;                    // Uart0 ist aktiv
      uart0_tx_buffer[uart0_tx_buffer_pointer]=character;      // Zeichen in den Sendebuffer kopieren
      uart0_tx_buffer_pointer++;                  // Sendepuffer erhöhen
      if(uart0_tx_buffer_pointer>255) uart0_tx_buffer_pointer=0;  // Zur Sicherheit, kann hier aber nicht passieren, da unsigned char sowieso überläuft 
      break;
    
    }
    
    default: break;
  }

}



//---------------------------------------------------------------------------
// puts
//
// functiondescription:  Sendet den übergebenen String in den Sendebuffer der jeweiligen Schnittstelle mithilfe der Funktion putch
//
// hand over:
//  - input parameters: Zu sendenden String; Schnittstelle über die gesendet werden soll
// returns:
//  - return parameter: nothing
//---------------------------------------------------------------------------
void puts(unsigned char *string, unsigned char channel)
{
  
  while (*string != '\0')
  { 
    if(*string == '\n')           // CR senden ?  
    {
      putch('\r',channel);
      string++;
    }
    else
    {
      putch(*string++,channel);       // Jedes Zeichen einzeln in den Sendebuffer schreiben
    }
  }
  
  UCSRB |= (1<<UDRIE);
  
}

In meiner main funktion rufe ich jetzt ein mal auf

puts("\n\nHallo Welt !! !!\n\n",0);

Die Funktion puts übergibt jedes Zeichen einzeln an die Funktion putch. 
Diese läd dann den Sendebuffer. Am Ende der Funktion puts aktiviere ich 
dann noch den Interrupt. Im Interrupt wird überprüft, ob es noch 
ungesendete Zeichen gibt (uart0_txd_pointer!=uart0_tx_buffer_pointe) und 
diese gesendet, falls das der Fall ist. Wenn nicht, wird der Interupt 
wieder deaktiviert. Sollte doch so funktionieren.

Aber ich bekomme meine Textausgabe in einer Dauerschleife !! Wieso ?! 
Resettet sich der µC etwa ständig ? Hab sonst nix drinn im Programm, 
kein Watchdog kein garnix :( :(

Vom Aufbau her ist es doch das selbe wie bei dem verlinktem Artikel

[Stefan E. (sternst)]

Markus Wi*** schrieb:
> Resettet sich der µC etwa ständig ?

Ja, und der Grund liegt hier:

  UCSRB=0x4C;          // 8N1, RX und TX Enable, RX Interrupt

Gutes Beispiel, warum diese Schreibweise nicht sehr sinnvoll ist.