Cortex-M0: FreeRTOS + UART-Interrupt = Problem.

[Michael B. (Gast)]

Hallo!

Auf einem NXP LPC11U35 (Cortex M0) versuche ich seit nunmehr geraumer 
Zeit FreeRTOS (v9.0.0) und den UART-Interrupt zusammen ans Laufen zu 
bekommen.

Folgendes funktioniert einwandfrei:
- FreeRTOS Tasks (LED, Statistikausgabe)
- IdleHook (u.A. USB-basiertes serielle Befehlskonsole (dafür braucht es 
ja auch einen Int-Handler, testweise auch __wfi();)
- Stacküberwachung (StackOverflowHook) und MallocFailedHook sind 
implementiert und funktionieren, wenn provoziert, wie erwartet
- Stacks sind alle ausreichend groß (Überwacht+sehr großzügig Headroom, 
auch für den IdleTask und den ersten Stack vor dem Starten des 
Schedulers

Nun füge ich ein UART-ISR hinzu, und das OS läuft nach Empfang des 
ersten Zeichens sofort bedeutend langsamer!? Später soll das ISR über 
TaskNotifications natürlich den Task aufwecken, aber dies ist momentan 
nicht implementiert und das ISR kümmert sich selbst drum. Alleine der 
konfigurierte UART + das eingeschaltete ISR bremsen das OS massiv ein.

Im Debugger geprüft: SysTick und PendSV haben Wert "192", also Prio "3", 
was korrekt der niedrigsten Cortex-Prio entspricht. Analog setze ich 
auch Prio 3, was entsprechend im Debugger auch stimmt. Der Cortex M0 hat 
lt. CMSIS auch nur 2 Prio-Bits.

Wie bereits geschrieben, Stack und Heap laufen auch (sehr sicher) nicht 
über.

Stoppt man die Ausführung im Debugger, sieht man subjektiv, dass obwohl 
nur selten Zeichen empfangen werden sehr häufig das UART-ISR 
angesprungen wird/aktiv ist.
Deaktiviert man per Debugger das UART-ISR im NVIC läuft das FreeRTOS 
sofort normal weiter!

These: Irgendwie verändert das FreeRTOS den NVIC so, dass ich nicht 
sauber das UART-ISR bediene/lösche, bzw. evtl. wird nach jeder 
CriticalSection durch (Re-)Aktivieren der ISRs das UART-ISR getriggert. 
Ein Nesting kann bei gleicher Prio da ja eigentlich nicht vorkommen.

Wenn ich wiederum alle StackCreate und StartScheduler auskommentiere 
(und in der nachfolgenden for (;;) Schleife arbeite) funktioniert das 
UART-ISR einwandfrei...

Über Vorschläge würde ich mich sehr freuen!

Grüße
Michi

#include "board.h"
#include "cli.h"

#include "FreeRTOS.h"
#include "task.h"

#include "stdio.h"
#include "cdc_vcom.h"

extern ErrorCode_t USB_Init(void);
extern USBD_API_INIT_PARAM_T usb_param;

long ledStackHighWaterMark;
long uartStackHighWaterMark;

static TaskHandle_t xUARTTaskHandle = NULL;

static short rx_byte;
static char rx_status;

void UART_IRQHandler(void)
{
  BaseType_t xHigherPriorityTaskWoken = pdFALSE;

  uint8_t iirvalue = Chip_UART_ReadIntIDReg(LPC_USART) & UART_IIR_INTID_MASK;
  if ((iirvalue == UART_IIR_INTID_RLS) || (iirvalue == UART_IIR_INTID_RDA))
  {
    rx_status = Chip_UART_ReadLineStatus(LPC_USART) & (UART_LSR_OE | UART_LSR_PE | UART_LSR_BI | UART_LSR_FE | UART_LSR_RXFE);
    rx_byte = Chip_UART_ReadByte(LPC_USART);
  }
  else if (iirvalue == UART_IIR_INTID_CTI)  /* Character timeout indicator */
  {
//    if (UART_Character_Timeout)
//      UART_Character_Timeout();
  }
  else if (iirvalue == UART_IIR_INTID_THRE)  /* THRE, transmit holding register empty */
  {
    /* all data transmitted on UART disable UART_IER_THREINT */
    Chip_UART_IntDisable(LPC_USART, UART_IER_THREINT);
  }
  
  NVIC_ClearPendingIRQ(UART0_IRQn);
  
  /* Notify the task that the transmission is complete. */
//  vTaskNotifyGiveFromISR( xUARTTaskHandle, &xHigherPriorityTaskWoken );

  /* If xHigherPriorityTaskWoken is now set to pdTRUE then a context switch
  should be performed to ensure the interrupt returns directly to the highest
  priority task.  The macro used for this purpose is dependent on the port in
  use and may be called portEND_SWITCHING_ISR(). */
//  portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

static void vUARTTask(void *pvParameters)
{
  uint32_t ulNotificationValue;
  const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 1000 );

  /* Store the handle of the calling task. */
  xUARTTaskHandle = xTaskGetCurrentTaskHandle();

  for (;;)
  {
    uartStackHighWaterMark = uxTaskGetStackHighWaterMark( NULL );

    /* Wait for the transmission to complete. */
    ulNotificationValue = ulTaskNotifyTake( pdFALSE, xMaxBlockTime );

    if( ulNotificationValue >= 1 )
    {
      /* The transmission ended as expected. */
      printf("ISR - ch = 0x%02x\r\n", rx_byte);      
    }
    else
    {
      /* The call to ulTaskNotifyTake() timed out. */
      printf("TO\r\n");
//      rx_byte = Chip_UART_ReadByte(LPC_USART);
//      printf("ch = %x\r\n", rx_byte);      
    }
  }
}

/* LED toggle thread */
static void vLEDTask(void *pvParameters)
{
  for (;;)
  {
    ACT_LED_TOGGLE();
    vTaskDelay(configTICK_RATE_HZ/2);
    ledStackHighWaterMark = uxTaskGetStackHighWaterMark( NULL );
  }
}

/* STATS thread */
static void vStatsTask(void *pvParameters)
{
  for (;;)
  {
    vTaskDelay(configTICK_RATE_HZ*10);
    printf("\r\n");
    printf("Heap: %d (act) / %d (min) byte free\r\n", xPortGetFreeHeapSize(), xPortGetMinimumEverFreeHeapSize());
    printf("this stack: %ld entries free\r\n", uxTaskGetStackHighWaterMark( NULL ));
    printf("UART stack: %ld entries free\r\n", uartStackHighWaterMark);
    printf("LED stack: %ld entries free\r\n", ledStackHighWaterMark);
    printf("\r\n");
  }
}

uint8_t lower_heap[5*1024];

HeapRegion_t xHeapRegions[] = {
  { (uint8_t*)lower_heap, sizeof(lower_heap) },
  { NULL, 0 },
  { NULL, 0 }
};

/* Main Program */
int main (void)
{
  Board_Init();
  USB_Init();
  CLI_Init();

  /* Setup UART for 38.4K8E1 */
  Chip_UART_Init(LPC_USART);
  Chip_UART_SetBaud(LPC_USART, 38400);
  Chip_UART_ConfigData(LPC_USART, (UART_LCR_WLEN8 | UART_LCR_SBS_1BIT | UART_LCR_PARITY_EN | UART_LCR_PARITY_EVEN));
  Chip_UART_SetupFIFOS(LPC_USART, (UART_FCR_FIFO_EN | UART_FCR_TRG_LEV2));
  Chip_UART_TXEnable(LPC_USART);

  /* Enable receive data and line status interrupt */
  Chip_UART_IntEnable(LPC_USART, (UART_IER_RBRINT | UART_IER_RLSINT));

  /* prio = 3 */
  NVIC_SetPriority(UART0_IRQn, (1UL<<__NVIC_PRIO_BITS)-1UL); // only 2 bits used, so prio can be 0,1,2,3 where 0 is highest priority
  NVIC_EnableIRQ(UART0_IRQn);

  // use remaining USB RAM for RTOS heap
  xHeapRegions[1].pucStartAddress = (uint8_t*)usb_param.mem_base;
  xHeapRegions[1].xSizeInBytes = usb_param.mem_size;

  vPortDefineHeapRegions(xHeapRegions);

  /* UART thread */
  xTaskCreate(vUARTTask, "UART", 80, NULL, configMAX_PRIORITIES - 1, (xTaskHandle *) NULL);

  /* STATS thread */
  xTaskCreate(vStatsTask, "Stats", 80, NULL, tskIDLE_PRIORITY, (xTaskHandle *) NULL);

  /* LED toggle thread */
  xTaskCreate(vLEDTask, "LED", 32, NULL, tskIDLE_PRIORITY + 1, (xTaskHandle *) NULL);

  /* Start the scheduler */
  vTaskStartScheduler();

  for (;;)
  {
    if (rx_byte != -1)
    {
      printf("ISR - ch = 0x%02x\r\n", rx_byte);      
      rx_byte = -1;
    }
    CLI_Task();
  }
}

void vApplicationIdleHook( void )
{
  // must never been delayed by FreeRTOS function...
  CLI_Task(); // consume all input
//  __wfi();
}
/*-----------------------------------------------------------*/

void vApplicationMallocFailedHook( void )
{
  ACT_LED_ON();
  taskDISABLE_INTERRUPTS();
  for (;;) {;}
}
/*-----------------------------------------------------------*/

void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
{
  ( void ) pcTaskName;
  ( void ) pxTask;

  ACT_LED_ON();
  taskDISABLE_INTERRUPTS();
  for (;;) {;}
}

[Daniel B. (dbuergin)]

Kleiner Tipp, häng den Code als File an, oder formatier ihn wenigstens 
richtig mit den Tags (c und \c) siehe auch Formatierung
Ansonsten vergraulst Du schon mal ein paar potenzielle Antwortgeber...


Beispiel:

void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
{
  ( void ) pcTaskName;
  ( void ) pxTask;

  ACT_LED_ON();
  taskDISABLE_INTERRUPTS();
  for (;;) {;}
}

[Pete K. (pete77)]

Ich kenne mich mit RTOS nicht wirklich aus, aber ist es erlaubt in der 
Main noch eine For-Schleife, die auf etwas wartet hinzuzufügen?

Ansonsten vielleicht mal die globalen Variablen als volatile generieren.

[temp (Gast)]

Das U0IIR Register sollte 0 sein wenn du den Interrupt verlässt, sonst 
läuft das Ding in einer Schleife. Versuch mal das in einer 
while-Schleife sicherzustellen. Bei den Cortexen kann auch mal eine 
gewisse Zeit vergehen bis die Interrupt-Flags so stehen wie gewünscht. 
Wird die Interrupt-Routine zu früh verlassen, löst das gleich den 
nächsten Interrupt aus. Hab ich bei den Timern schon erlebt.

so in etwa:

void UART_IRQHandler(void)
{
....

while (1) 
  {
  uint32_t iirvalue=Chip_UART_ReadIntIDReg(LPC_USART);
  if (iirvalue)
    {
    // Aktionen ausführen um die Flags zu löschen
    }
  else
    break;  
  } 
....

}

du hast in deinem Code iirvalue als uint8_t declariert, Sollte das nicht 
uint32_t sein?

[Michael B. (Gast)]

@Daniel: Hast recht, hatte [ c ] leider übersehen...

Pete K. schrieb:
> Ich kenne mich mit RTOS nicht wirklich aus, aber ist es erlaubt in
> der
> Main noch eine For-Schleife, die auf etwas wartet hinzuzufügen?
>
> Ansonsten vielleicht mal die globalen Variablen als volatile generieren.

Hallo Pete, die For-Schleife wird wenn vTaskStartScheduler aufgerufen 
wird nicht mehr erreicht, da ich nie (alle) Tasks beende. Ist in dem 
Fall "non-reachable".

temp schrieb:
> Das U0IIR Register sollte 0 sein wenn du den Interrupt verlässt,
> sonst
> läuft das Ding in einer Schleife. Versuch mal das in einer
> while-Schleife sicherzustellen. Bei den Cortexen kann auch mal eine
> gewisse Zeit vergehen bis die Interrupt-Flags so stehen wie gewünscht.
> Wird die Interrupt-Routine zu früh verlassen, löst das gleich den
> nächsten Interrupt aus. Hab ich bei den Timern schon erlebt.
>
> so in etwa:
> void UART_IRQHandler(void)
> {
> ....
>
> while (1)
>   {
>   uint32_t iirvalue=Chip_UART_ReadIntIDReg(LPC_USART);
>   if (iirvalue)
>     {
>     // Aktionen ausführen um die Flags zu löschen
>     }
>   else
>     break;
>   }
> ....
>
> }
>
> du hast in deinem Code iirvalue als uint8_t declariert, Sollte das nicht
> uint32_t sein?

Hallo temp, ich werde das mal versuchen. Die Idee defensiv IIR 
abzufragen ist sicher sinnvoll. Alle in IIR relvanten Ints sind in den 
unteren 8 bit, trotzdem ist es natürlich unschön. Wie gesagt: Ohne RTOS 
funktioniert das alles aber. Werde es aber trotzdem fixen.

Grüße
Michi

[Michael B. (Gast)]

Hallo!

Ich konnte dank Eurer Hinweise das Problem lokalisieren: Tatsächlich ist 
der Character Timeout (CTI) des UART gesetzt und wird auch von den 
Referenzimplementierungen nicht gelöscht.

Scheinbar bin ich nicht der Einzige: 
https://community.nxp.com/thread/419856

Als Lösungsmöglichkeit ergeben sich kurzfristig zwei Wege:
- bei CTI IMMER auch das RBR lesen (egal was RDA sagt)
- den FIFO nur 1 Byte tief machen

Ich werde mich nun noch mal genauer mit den Auswirkungen der einzelnen 
Lösungsansätze beschäftigen und das kleinere Übel auswählen.

Vielen Dank und Grüße
Michi