Interrupt gesteuertes UART transmit

[Alex V. (bastel_alex)]

Hallo zusammen,
ich arbeite auf einem ATSAM4S gerade an der Optimierung der bandbreite 
und des timings meiner über UART an ein Bluetooth Modul zu übertragenden 
daten:

Ich habe zwei Ringbuffer, über die zu sendende und empfangene daten 
abgearbeitet werden.

Der Receive-Zweig klappt wunderbar: Über den UART0_Handler mit 
aktiviertem RXRDY Interrupt hole ich immer bei Eingang eines Bytes 
dieses aus dem Empfangsregister und schiebe es in den 
Empfangs-Ringbuffer für die weitere Verarbeitung.

Der Transmit-Zweig macht mir Probleme: Bislang hatte ich an einer Stelle 
der main-routine einfach den Transmit-Ringbuffer schritt für schritt 
abgearbeitet - also ganz ohne Interrupts.

Jetzt kann ich aber nur mit 115.2kBaud übertragen (und nutze diese 
Bandbreite ziemlich aus) - und das Erzeugt bei mir Timing Problemee, 
wenn ich jedes mal warten muss, bis die Übertragung beendet ist.

Am besten soll also regelmäßig der Transmit-Ringbuffer überprüft - und 
was darin ist stückweise übertragen werden.
Ich wollte das ganze in der selben UART0_Handler Interrupt routine wie 
oben abarbeiten, indem ich den TXRDY Interrupt (oder ENDTX) aktiviere 
und dann in der routine wenn einer Übertragung beendet wurde nur noch 
prüfe ob der Transmit-Ringbuffer leer ist - und wenn nicht ein Element 
herausnehme und versende - etc. etc.

Das funktioniert so nun nicht: Obwohl ständig daten in den ringbuffer 
geschickt werden, bekomme ich in der Konsole nur kurz daten - und dann 
ein stop. Auch, wenn ich am ende der mainroutine jedes mal noch einen 
transmit initiiere, um bei zwischenzeitlich leerem ringbuffer (und damit 
gestoppter übertragung) wieder neu zu beginnen.

Wie würdet ihr eine interrupt gesteuerte UART-Transmit-Übertragung 
lösen, die immer, wenn etwas im Ringbuffer ist, im "hintergrund" daten 
sendet, während in der mainroutine eben diese daten erzeugt werden?

[Alex V. (bastel_alex)]

Hier die grobe Übersicht der routinen unter Verwendung des Atmel 
Software Framework

/**
 *  Handler for UART interrupts - pushes received data in the RX fifobuffer/ pulls data to transmit from TX fifobuffer.
 */
void UART0_Handler (void){
  uint8_t temprx;
  // If data has been received, load into rxbuffer
  if (uart_is_rx_ready(CONSOLE_UART))  {
    uart_read(CONSOLE_UART, &temprx);
    fifo_push_uint8(&rxbuf_desc, temprx);  
  }
  
  // Send Data from TX Buffer
  if (!fifo_is_empty(&txbuf_desc) && (uart_is_tx_empty(CONSOLE_UART))) {
    fifo_pull_uint8(&txbuf_desc, &txchar);
    usart_serial_putchar(CONSOLE_UART, txchar);
  }
}


main(void{

// Initialize UART module
const usart_serial_options_t uart_serial_options = {
    .baudrate = CONF_UART_BAUDRATE,
    #ifdef CONF_UART_CHAR_LENGTH
    .charlength = CONF_UART_CHAR_LENGTH,
    #endif
    .paritytype = CONF_UART_PARITY,
    #ifdef CONF_UART_STOP_BITS
    .stopbits = CONF_UART_STOP_BITS,
    #endif
  };

  /* Configure console UART. */
  sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
  stdio_serial_init((Usart *)CONF_UART, &uart_serial_options);
  // Enable UART End of Receive Transfer and End of Transmit interrupts
  NVIC_EnableIRQ(UART0_IRQn);
  NVIC_SetPriority(UART0_IRQn, IRQ_PRIOR_UART);
  uart_enable_interrupt(CONSOLE_UART, (UART_IER_RXRDY || UART_IER_TXRDY));
  // Reset console - initialize flags/counter
  console_reset(cstat);
  cstat->feedback=false;

while(1){

// Much data is generated here

// At the end: Start new transmission
  if (!fifo_is_empty(&txbuf_desc) && (uart_is_tx_empty(CONSOLE_UART))) {
    fifo_pull_uint8(&txbuf_desc, &txchar);
    usart_serial_putchar(CONSOLE_UART, txchar);
  }

}
}