Part Number: EK-TM4C1294XL
Other Parts Discussed in Thread: SYSBIOS
Tool/software: TI-RTOS
Hi,
I came acoross multiple threads about this issue but couldn't really solve it. I have a small application that print the input from the UART in the console using a hardware interrupt for UART, and a Task interrupt to print the message using event and queue API. When I keep pressing on a button, I get the error in the figure. and when I just press one or two buttons, the Task interrupt would be invoked, but crash after initializing the event. Please have a look at the attached main.c and the main.cfg.
Thank you.
Error1:
Error2:
/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/Error.h>
/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/hal/Timer.h>
#include <ti/sysbios/knl/Event.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/knl/Swi.h>
#include <ti/sysbios/knl/Queue.h>
#include <ti/sysbios/hal/Hwi.h>
/* TI-RTOS Header files */
#include <ti/drivers/GPIO.h>
#include <ti/drivers/UART.h>
#include <ti/drivers/uart/UARTTiva.h>
/* Board Header file */
#include "Board.h"
#include <string.h>
#include "driverlib/fpu.h"
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "driverlib/sysctl.h"
#include "driverlib/interrupt.h"
#include "driverlib/uart.h"
#include "driverlib/gpio.h"
#include "utils/ustdlib.h"
#include "grlib/grlib.h"
#include "grlib/widget.h"
#include "grlib/canvas.h"
#include "drivers/Kentec320x240x16_ssd2119_spi.h"
#define TASKSTACKSIZE 512
typedef struct MsgObj {
Queue_Elem elem; /* first field for Queue */
Char data; /* message value */
} MsgObj;
Task_Struct task0Struct;
Char task0Stack[TASKSTACKSIZE];
Semaphore_Struct sem0Struct;
Semaphore_Handle semHandle;
Event_Struct evtStruct;
Event_Handle evtHandle;
Queue_Handle QueueHandle;
Hwi_Handle HwiUART;
uint32_t g_ui32SysClock;
tContext sContext;
void UARTSend(const uint8_t *pui8Buffer, uint32_t ui32Count) {
// Loop while there are more characters to send.
while (ui32Count--) {
// Write the next character to the UART.
if (!UARTCharPutNonBlocking(UART0_BASE, *pui8Buffer++)) {
SysCtlDelay((0.002 * g_ui32SysClock) / 3);
UARTCharPutNonBlocking(UART0_BASE, *pui8Buffer++);
}
}
}
void uart0FuncTask() {
MsgObj *msg;
UInt events;
msg = Queue_get(QueueHandle);
System_printf("RET msg rec: %c\n", msg->data);
System_printf("\nmsg uart0FuncTask: %c\n");
while (1) {
System_printf("\nmsg while 1\n");
events = Event_pend(evtHandle, Event_Id_05, Event_Id_NONE, BIOS_WAIT_FOREVER);
Semaphore_pend(semHandle, BIOS_NO_WAIT);
if (events & Event_Id_05) {
Semaphore_pend(semHandle, BIOS_NO_WAIT);
while (!Queue_empty(QueueHandle)) {
msg = Queue_get(QueueHandle);
System_printf("RET msg rec: %c\n", msg->data);
}
}
}
}
void uart0FuncHwi(UArg arg) {
System_printf("\nHwi: uart0FuncHwi called\n");
uint32_t ui32Status;
// Get the interrrupt status.
ui32Status = UARTIntStatus(UART0_BASE, true);
// Clear the asserted interrupts.
UARTIntClear(UART0_BASE, ui32Status);
char ch;
// Loop while there are characters in the receive FIFO.
while (UARTCharsAvail(UART0_BASE)) {
MsgObj msg;
ch = UARTCharGetNonBlocking(UART0_BASE); //HWI
// Read the next character from the UART and write it back to the UART.
// Blink the LED to show a character transfer is occuring.
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, GPIO_PIN_0);
// Delay for 1 millisecond. Each SysCtlDelay is about 3 clocks.
SysCtlDelay(g_ui32SysClock / (1000 * 3));
// Turn off the LED
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);
if (ch != '\r' && ch != ' ') {
// Read the next character from the UART and write it back to the UART.
System_printf("\n msg : %c\n", ch);
msg.data = ch;
Queue_put(QueueHandle, &(msg.elem));
Semaphore_post(semHandle);
}
else if (ch == '\r') {
System_printf("\nmsg with return\n");
Event_post(evtHandle, Event_Id_05);
}
}
}
void initUARTHwiInt() {
/* Turn on user LED */
GPIO_write(Board_LED0, Board_LED_ON);
Hwi_Params hwiParams;
Error_Block hwi_eb;
Error_init(&hwi_eb);
Hwi_Params_init(&hwiParams);
hwiParams.arg = (UArg)QueueHandle;
HwiUART = Hwi_create(21, (Hwi_FuncPtr)uart0FuncHwi, &hwiParams, &hwi_eb);
if (HwiUART == NULL) System_printf("Hwi create failed\n");
}
void initUARTEvent() {
Event_construct(&evtStruct, NULL);
evtHandle = Event_handle(&evtStruct);
}
void initUARTSemaphore() {
Semaphore_Params semParams;
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&sem0Struct, 0, &semParams);
semHandle = Semaphore_handle(&sem0Struct);
}
void initUARTQueue() {
QueueHandle = Queue_create(NULL, NULL);
}
void initUARTTaskInt() {
Task_Params taskParams;
Task_Params_init(&taskParams);
taskParams.stackSize = TASKSTACKSIZE;
Task_create((Task_FuncPtr)uart0FuncTask, &taskParams, NULL);
}
void configureUART(void) {
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
IntMasterEnable();
// Configure the UART for 115,200, 8-N-1 operation.
UARTConfigSetExpClk(UART0_BASE, g_ui32SysClock, 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
// Enable the UART interrupt.
IntEnable(INT_UART0);
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
System_printf("UART is set\n");
}
void configureGUI(uint32_t g_ui32SysClock) {
FPUEnable();
FPULazyStackingEnable();
Kentec320x240x16_SSD2119Init(g_ui32SysClock);
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
GrContextForegroundSet(&sContext, ClrWhite);
GrContextFontSet(&sContext, &g_sFontCm20);
}
/* main */
int main(void) {
// Set the clocking to run directly from the crystal at 120MHz.
g_ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000);
/* Call board init functions */
Board_initGeneral();
Board_initGPIO();
Board_initUART();
configureGUI(g_ui32SysClock);
initUARTQueue();
configureUART();
initUARTTaskInt();
initUARTHwiInt();
initUARTEvent();
initUARTSemaphore();
/* SysMin will only print to the console when you call flush or exit */
System_flush();
/* Start BIOS */
BIOS_start();
return (0);
}
