[ARM] Tiva C Launchpad UART Interrupt Probleme

[Tobias S. (ucfreak)]

Ich habe mir mal einiges zurecht programmiert um die UART interrupt 
gesteuert zu nutzen.

Das funktionierte auch schon alles. Nur heute will es nur noch halb 
funktionieren.

Jedes Mal wenn ich ein Zeichen über die UART bekomme, sende ich die 
Temperatur des Temperatursensor per UART wieder zurück.

Der Receive-Interrupt kommt auch wunderbar, nur der Sendeinterrupt kommt 
mal gar nicht :(

Mein gesamter UART-Code sieht so aus:

void
Uart_Init(void)
{
  // enable UART and GPIO port A
  SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
  SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
  // init FIFOs
  FifoQueue_Init(&g_sUartRxFifo,UART_RX_FIFO_SIZE);
  FifoQueue_Init(&g_sUartTxFifo,UART_TX_FIFO_SIZE);
  // set GPIO ports
  GPIOPinConfigure(GPIO_PA0_U0RX);
  GPIOPinConfigure(GPIO_PA1_U0TX);
  GPIOPinTypeUART(GPIO_PORTA_BASE,GPIO_PIN_0 | GPIO_PIN_1);
  // disable UART
//  UARTDisable(UART0_BASE);
  // set UART clock
  UARTConfigSetExpClk(UART0_BASE,SysCtlClockGet(),115200,(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
  // disable FIFOs
  UARTFIFODisable(UART0_BASE);
  // enable RX and disable TX interrupt
  IntEnable(INT_UART0);
  UARTIntEnable(UART0_BASE,UART_INT_RX);
  UARTIntDisable(UART0_BASE,UART_INT_TX);
  // enable UART
//  UARTEnable(UART0_BASE);
}

void
Uart0_Isr(void)
{
  uint32_t status;
  // get status
  status = UARTIntStatus(UART0_BASE,true);
  // clear status
  UARTIntClear(UART0_BASE,status);
  // RX interrupt?
  if(status & UART_INT_RX)
  {
    while(UARTCharsAvail(UART0_BASE)) //loop while there are chars
    {
      char chr = UARTCharGetNonBlocking(UART0_BASE);
      // push character into fifo queue
      FifoQueue_Push(&g_sUartRxFifo,chr);
    }
  }
  // TX interrupt?
  if(status & UART_INT_TX)
  {
    while(FifoQueue_ItemAvailable(&g_sUartTxFifo) && UARTSpaceAvail(UART0_BASE))
    {
      char chr;
      // pop character from fifo and put it into the UART fifo
      FifoQueue_Pop(&g_sUartTxFifo,(uint8_t*)&chr);
      UARTCharPutNonBlocking(UART0_BASE,chr);
    }
    // check if we need another interrupt
    if(!FifoQueue_ItemAvailable(&g_sUartTxFifo))
    {
      // disable UART TX interrupt
      UARTIntDisable(UART0_BASE,UART_INT_TX);
    }

    g_sUartTxIntOccured = true;
  }
}

void
Uart0_SendBuffer(char*    buffer,
         uint16_t size)
{
  uint16_t pos = 0;
  // go through the buffer
  while(pos < size)
  {
    // disable TX interrupt
    UARTIntDisable(UART0_BASE,UART_INT_TX);
    // if the FIFO is full, we need to wait
    if(FifoQueue_IsFull(&g_sUartTxFifo))
    {
      g_sUartTxIntOccured = false;
      // enable interrupts
      UARTIntEnable(UART0_BASE,UART_INT_TX);
      // wait for interrupt
      while(!g_sUartTxIntOccured)
      {
        ;
      }
      // disable interrupts
      UARTIntDisable(UART0_BASE,UART_INT_TX);
    }
    // push characters into the FIFO
    while(pos < size && !FifoQueue_IsFull(&g_sUartTxFifo))
    {
      FifoQueue_Push(&g_sUartTxFifo,buffer[pos++]);
    }
    // enable interrupts
    UARTIntEnable(UART0_BASE,UART_INT_TX);
  }
}

bool
Uart0_CharAvailable(void)
{
  return (g_sUartRxFifo.header.numItems > 0);
}

char
Uart0_GetChar(void)
{
  char chr = 0;
  // disable interrupts
  UARTIntDisable(UART0_BASE,UART_INT_RX);
  // get character
  if(g_sUartRxFifo.header.numItems > 0)
  {
    FifoQueue_Pop(&g_sUartRxFifo,(uint8_t*)&chr);
  }
  // enable interrupts
  UARTIntEnable(UART0_BASE,UART_INT_RX);

  return chr;
}

Wie gesagt, ich bekomme im Moment nicht den TX Interrupt (RX kommt) 
obwohl ich diesen bei jedem Senden anmache.

Hat einer eine Idee was schief läuft oder wo ich noch einen Denkfehler 
habe?

[Tobias S. (ucfreak)]

Ich habe das Problem jetzt gelöst indem ich die FIFOs vollständig nutze 
und mir nach deren Stand einen Interrupt geben lasse.

Keine Ahnung warum es ohne die Benutzung der FIFOs nicht funktioniert.

[Bernd N (Gast)]

TIVA C oder LM4F120 sollten da ziemlich gleich funktionieren. Ich denke 
dein Code ist aus den TI Beispielen zusammen kopiert ? Das es 
funktioniert ist ja gut aber verstehst du auch warum ?

Du kannst das Ganze zu folgendem Code zusammendampfen:

#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/rom.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"


// System Clock initialisieren
void SysClockInit (void)
{
    ROM_SysCtlClockSet (SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);   // 16 MHz Quarz
}

// UART initialisieren
void UartInit (void)
{
    ROM_SysCtlPeripheralEnable (SYSCTL_PERIPH_UART0);
    ROM_SysCtlPeripheralEnable (SYSCTL_PERIPH_GPIOA);

    ROM_GPIOPinConfigure (GPIO_PA0_U0RX);                                                          // GPIO A0, A1 as UART pins
    ROM_GPIOPinConfigure (GPIO_PA1_U0TX);
    ROM_GPIOPinTypeUART (GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    ROM_UARTConfigSetExpClk (UART0_BASE, ROM_SysCtlClockGet(), 115200,                             // 115200 Baud, 8-N-1
                             (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));

    ROM_IntEnable (INT_UART0);                                                                     // Enable UART interrupt
    ROM_UARTIntEnable (UART0_BASE, UART_INT_RX | UART_INT_RT);
}

// UART ISR
void UARTIntHandler (void)
{
    unsigned long ulStatus;

    ulStatus = ROM_UARTIntStatus (UART0_BASE, true);                                               // check if ISR is triggered
    ROM_UARTIntClear (UART0_BASE, ulStatus);                                                       // clear interrupt

    while (ROM_UARTCharsAvail (UART0_BASE)) {                                                      // read FIFO receive Buffer
        ROM_UARTCharPut (UART0_BASE, ROM_UARTCharGet (UART0_BASE));                                // echo received char.
    }
}

// simple printf
void printfEasy (const char *s)
{
    while (*s) UARTCharPut (UART0_BASE, (*s++));
}

void main (void)
{
    SysClockInit ();
    UartInit ();
    ROM_IntMasterEnable ();                                                                        // enable Interrupts

    printfEasy ("Hello World, Enter a text:\n\r");

    while (1) {
    }
}

[Tobias S. (ucfreak)]

Jap, mein Code ist ein Mix aus Beispielen und eigenem. Ich weiß warum er 
funktioniert, was ich nicht weiß, wieso der ursprüngliche Code nicht 
funktioniert ;)

Allerdings ist mir das jetzt auch egal. Hauptsache es läuft und ich weiß 
warum.

Ich weiß aber nicht was du mir mit deinem Code sagen willst!?

[Bernd N (Gast)]

Ich will dir sagen das es auch ohne Fifo geht.

[Tobias S. (ucfreak)]

Ich weiß das es auch ohne FIFO geht, aber ich bekomme dann nicht den 
TX-Interrupt!