SW-EK-TM4C129EXL: EK-TM4C129EXL

imtiaj hossain

Part Number: SW-EK-TM4C129EXL
Other Parts Discussed in Thread: EK-TM4C129EXL, TM4C129ENCPDT

Dear all,

I use UART2 (PA6 as Tx and PA7 as Rx). I send a data stream like 17, 03, 04, 34, 45, 65 to another board(Arduino Mega). It was successfully work. But when I send same data and then this data is received my ek-tm4c129exl , there is a problem. Because I want to show this receive data in console. I use UART0 as console. But I didn't show the anything in console. My code is--

#include <stdint.h>
#include <stdbool.h>

#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/tm4c129encpdt.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/rom.h"
#include "driverlib/rom_map.h"
#include "driverlib/uart.h"
#include "driverlib/interrupt.h"
#include "utils/uartstdio.h"

/*
* ---------------SYSTEM Clock Rate--------------
*/

uint32_t g_ui32SysClock;

void MB_Port(void)
{
// Run from the PLL at 120 MHz.
// Note: SYSCTL_CFG_VCO_240 is a new setting provided in TivaWare 2.2.x and
// later to better reflect the actual VCO speed due to SYSCTL#22.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_240), 120000000);

MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

MAP_GPIOPinConfigure(GPIO_PA6_U2RX);
MAP_GPIOPinConfigure(GPIO_PA7_U2TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_6 | GPIO_PIN_7);

//----------------Baud Rate setup 9600bps---------------
MAP_UARTConfigSetExpClk(UART2_BASE, g_ui32SysClock, 9600,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));

}

/*
* --------------------Console function-----------------
*/
void
InitConsole(void)
{
//
// Enable GPIO port A which is used for UART0 pins.
// TODO: change this to whichever GPIO port you are using.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

//
// Configure the pin muxing for UART0 functions on port A0 and A1.
// This step is not necessary if your part does not support pin muxing.
// TODO: change this to select the port/pin you are using.
//
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);

//
// Enable UART0 so that we can configure the clock.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

//
// Use the internal 16MHz oscillator as the UART clock source.
//
MAP_UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);

//
// Select the alternate (UART) function for these pins.
// TODO: change this to select the port/pin you are using.
//
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 9600, g_ui32SysClock);
}

/**
* main.c
*/
int main(void)
{

unsigned int j=0;
unsigned int data_in[j],a[6]={17,03,34,25,65,45};

MB_Port();
InitConsole();

for(i=0;i<6;i++)
{
MAP_UARTCharPut(UART2_BASE,a[i]);
}
while(1)
{
while(MAP_UARTCharsAvail(UART0_BASE))
{
data_in[j] = (unsigned int)MAP_UARTCharGetNonBlocking(UART0_BASE);
UARTprintf("Ack data is %d", data_in[j]);
j++;
}
}

over 3 years ago

0 imtiaj hossain over 3 years ago

Intellectual 270 points

Following error are given in ccs10.

0 Charles Tsai over 3 years ago in reply to imtiaj hossain

TI__Guru**** 176036 points

Hi,

I suppose you want to receive the data on the UART2, correct? The reason is that you are sending the data out using UART2TX and since UART is full-duplex, you will receive the data on UART2RX. If that is the case, why are calling MAP_UARTCharGetNonBlocking(UART0_BASE)?

You should have code as follows.

for(i=0;i<6;i++)
{
MAP_UARTCharPut(UART2_BASE,a[i]);
}
while(1)
{
while(MAP_UARTCharsAvail(UART2_BASE))
{
data_in[j] = (unsigned int)MAP_UARTCharGetNonBlocking(UART2_BASE);
UARTprintf("Ack data is %d", data_in[j]);
j++;
}
}

Once you receive the data, you can use the UARTprintf that print out the data using UART0. UART0 is connected to the virtual terminal of the PC.

0 imtiaj hossain over 3 years ago in reply to Charles Tsai

Intellectual 270 points

Hi Charles,

Yes It's my big mistake. Thank you. I was replace the code. But compiler terminate the process like that.

0 Charles Tsai over 3 years ago

TI__Guru**** 176036 points

Hi,

The behavior is normal. The main() function is just like any other function. When there is no more code to execute, where does it go? It goes to the abort(). If you don't it to go to abort, then add a while(1) at the end of your main() function. That ways the MCU is always running the main() function.

See this post too.

https://e2e.ti.com/support/microcontrollers/other-microcontrollers-group/other/f/other-microcontrollers-forum/820957/tm4c123gh6pm-code-goes-into-exit-c/3037167?tisearch=e2e-sitesearch&keymatch=abort%252525252525252528%252525252525252529#3037167

0 Chester Gillon over 3 years ago in reply to imtiaj hossain

Guru 92251 points

imtiaj hossain said:
But compiler terminate the process like that.

The backtrace in the debugger shows that __vla_alloc has called exit, which is a function called by the compiler to support a variable-length-array (VLA). The TI compiler uses the heap to allocate a VLA, and can call exit if insufficient space on the heap. See CCS/EK-TM4C123GXL: "exit.c" accessed when code is run for more information on how to increase the size of the heap if your code needs to use a VLA.

Looking at your code in main() in the first post there is:

unsigned int j=0;
unsigned int data_in[j],a[6]={17,03,34,25,65,45};

In which data_in is a VLA since it's size is set by the value of j.

The code creates data_in as a zero length array and then stores elements in the array with:

while(1)
{
    while(MAP_UARTCharsAvail(UART0_BASE))
    {
        data_in[j] = (unsigned int)MAP_UARTCharGetNonBlocking(UART0_BASE);
        UARTprintf("Ack data is %d", data_in[j]);
        j++;
    }
}

I.e. the code is attempting to dynamically grow the length of array which isn't supported in C and will overwrite other items in memory.

If you used C++ and a std::vector you would have a vector whose length would be grown, with allocations made from the heap.

Do you need to dynamically grow the length of the data_in array, or could you instead get a constant maximum array length at compile time?

0 Charles Tsai over 3 years ago in reply to Chester Gillon

TI__Guru**** 176036 points

Hi Chester,

Thanks for your analysis. I missed that there was already a while(1) in the main() and the abort was entered for a different reason.

Arm-based microcontrollers

Arm-based microcontrollers forum

SW-EK-TM4C129EXL: EK-TM4C129EXL