TM4C123GH6PM: TM4C123GH6PM

RONIT SHARMA

Part Number: TM4C123GH6PM
Other Parts Discussed in Thread: EK-TM4C123GXL

I connected my Tiva board with nodemcu in uart1. I'm trying to receive a string from a nodemcu in the Tiva board and print it. but it's not even going to interrupt handler I've initialized interrupt handler function in startup file also.

I've attached my main file and startup file. Please check once I'm unable to locate the problem.

I'm using IAR 8.32.4 IDE and Arduino IDE for coding.

Fullscreen 3362.startup_ewarm.c Download

//*****************************************************************************
//
// startup_ewarm.c - Startup code for use with IAR's Embedded Workbench,
//                   version 5.
//
// Copyright (c) 2011-2017 Texas Instruments Incorporated.  All rights reserved.
// Software License Agreement
// 
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
// 
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
// 
// This is part of revision 2.1.4.178 of the DK-TM4C123G Firmware Package.
//
//*****************************************************************************

#include <stdint.h>
#include "inc/hw_nvic.h"
#include "inc/hw_types.h"

//*****************************************************************************
//
// Enable the IAR extensions for this source file.
//
//*****************************************************************************
#pragma language=extended

//*****************************************************************************
//
// Forward declaration of the default fault handlers.
//
//*****************************************************************************
void ResetISR(void);
static void NmiSR(void);
static void FaultISR(void);
static void IntDefaultHandler(void);

//*****************************************************************************
//
// External declarations for the interrupt handlers used by the application.
//
//*****************************************************************************
extern void UARTIntHandler(void);


//*****************************************************************************
//
// The entry point for the application startup code.
//
//*****************************************************************************
extern void __iar_program_start(void);

//*****************************************************************************
//
// Reserve space for the system stack.
//
//*****************************************************************************
static uint32_t pui32Stack[256] @ ".noinit";

//*****************************************************************************
//
// A union that describes the entries of the vector table.  The union is needed
// since the first entry is the stack pointer and the remainder are function
// pointers.
//
//*****************************************************************************
typedef union
{
    void (*pfnHandler)(void);
    uint32_t ui32Ptr;
}
uVectorEntry;

//*****************************************************************************
//
// The vector table.  Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x0000.0000.
//
//*****************************************************************************
__root const uVectorEntry __vector_table[] @ ".intvec" =
{
    { .ui32Ptr = (uint32_t)pui32Stack + sizeof(pui32Stack) },
                                            // The initial stack pointer
    ResetISR,                               // The reset handler
    NmiSR,                                  // The NMI handler
    FaultISR,                               // The hard fault handler
    IntDefaultHandler,                      // The MPU fault handler
    IntDefaultHandler,                      // The bus fault handler
    IntDefaultHandler,                      // The usage fault handler
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // SVCall handler
    IntDefaultHandler,                      // Debug monitor handler
    0,                                      // Reserved
    IntDefaultHandler,                      // The PendSV handler
    IntDefaultHandler,                      // The SysTick handler
    IntDefaultHandler,                               // GPIO Port A
    IntDefaultHandler,                               // GPIO Port B
    IntDefaultHandler,                               // GPIO Port C
    IntDefaultHandler,                      // GPIO Port D
    IntDefaultHandler,                      // GPIO Port E
    IntDefaultHandler,                            // UART0 Rx and Tx
    UARTIntHandler,                           // UART1 Rx and Tx
    IntDefaultHandler,                      // SSI0 Rx and Tx
    IntDefaultHandler,                      // I2C0 Master and Slave
    IntDefaultHandler,                      // PWM Fault
    IntDefaultHandler,                      // PWM Generator 0
    IntDefaultHandler,                      // PWM Generator 1
    IntDefaultHandler,                      // PWM Generator 2
    IntDefaultHandler,                      // Quadrature Encoder 0
    IntDefaultHandler,                      // ADC Sequence 0
    IntDefaultHandler,                      // ADC Sequence 1
    IntDefaultHandler,                      // ADC Sequence 2
    IntDefaultHandler,                      // ADC Sequence 3
    IntDefaultHandler,                      // Watchdog timer
    IntDefaultHandler,                      // Timer 0 subtimer A
    IntDefaultHandler,                      // Timer 0 subtimer B
    IntDefaultHandler,                      // Timer 1 subtimer A
    IntDefaultHandler,                      // Timer 1 subtimer B
    IntDefaultHandler,                      // Timer 2 subtimer A
    IntDefaultHandler,                      // Timer 2 subtimer B
    IntDefaultHandler,                      // Analog Comparator 0
    IntDefaultHandler,                      // Analog Comparator 1
    IntDefaultHandler,                      // Analog Comparator 2
    IntDefaultHandler,                      // System Control (PLL, OSC, BO)
    IntDefaultHandler,                      // FLASH Control
    IntDefaultHandler,                      // GPIO Port F
    IntDefaultHandler,                      // GPIO Port G
    IntDefaultHandler,                      // GPIO Port H
    IntDefaultHandler,                      // UART2 Rx and Tx
    IntDefaultHandler,                      // SSI1 Rx and Tx
    IntDefaultHandler,                      // Timer 3 subtimer A
    IntDefaultHandler,                      // Timer 3 subtimer B
    IntDefaultHandler,                      // I2C1 Master and Slave
    IntDefaultHandler,                      // Quadrature Encoder 1
    IntDefaultHandler,                      // CAN0
    IntDefaultHandler,                      // CAN1
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // Hibernate
    IntDefaultHandler,                      // USB0
    IntDefaultHandler,                      // PWM Generator 3
    IntDefaultHandler,                      // uDMA Software Transfer
    IntDefaultHandler,                      // uDMA Error
    IntDefaultHandler,                      // ADC1 Sequence 0
    IntDefaultHandler,                      // ADC1 Sequence 1
    IntDefaultHandler,                      // ADC1 Sequence 2
    IntDefaultHandler,                      // ADC1 Sequence 3
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // GPIO Port J
    IntDefaultHandler,                      // GPIO Port K
    IntDefaultHandler,                      // GPIO Port L
    IntDefaultHandler,                      // SSI2 Rx and Tx
    IntDefaultHandler,                      // SSI3 Rx and Tx
    IntDefaultHandler,                      // UART3 Rx and Tx
    IntDefaultHandler,                      // UART4 Rx and Tx
    IntDefaultHandler,                      // UART5 Rx and Tx
    IntDefaultHandler,                      // UART6 Rx and Tx
    IntDefaultHandler,                      // UART7 Rx and Tx
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // I2C2 Master and Slave
    IntDefaultHandler,                      // I2C3 Master and Slave
    IntDefaultHandler,                      // Timer 4 subtimer A
    IntDefaultHandler,                      // Timer 4 subtimer B
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // Timer 5 subtimer A
    IntDefaultHandler,                      // Timer 5 subtimer B
    IntDefaultHandler,                      // Wide Timer 0 subtimer A
    IntDefaultHandler,                      // Wide Timer 0 subtimer B
    IntDefaultHandler,                      // Wide Timer 1 subtimer A
    IntDefaultHandler,                      // Wide Timer 1 subtimer B
    IntDefaultHandler,                      // Wide Timer 2 subtimer A
    IntDefaultHandler,                      // Wide Timer 2 subtimer B
    IntDefaultHandler,                      // Wide Timer 3 subtimer A
    IntDefaultHandler,                      // Wide Timer 3 subtimer B
    IntDefaultHandler,                      // Wide Timer 4 subtimer A
    IntDefaultHandler,                      // Wide Timer 4 subtimer B
    IntDefaultHandler,                      // Wide Timer 5 subtimer A
    IntDefaultHandler,                      // Wide Timer 5 subtimer B
    IntDefaultHandler,                      // FPU
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // I2C4 Master and Slave
    IntDefaultHandler,                      // I2C5 Master and Slave
    IntDefaultHandler,                      // GPIO Port M
    IntDefaultHandler,                      // GPIO Port N
    IntDefaultHandler,                      // Quadrature Encoder 2
    0,                                      // Reserved
    0,                                      // Reserved
    IntDefaultHandler,                      // GPIO Port P (Summary or P0)
    IntDefaultHandler,                      // GPIO Port P1
    IntDefaultHandler,                      // GPIO Port P2
    IntDefaultHandler,                      // GPIO Port P3
    IntDefaultHandler,                      // GPIO Port P4
    IntDefaultHandler,                      // GPIO Port P5
    IntDefaultHandler,                      // GPIO Port P6
    IntDefaultHandler,                      // GPIO Port P7
    IntDefaultHandler,                      // GPIO Port Q (Summary or Q0)
    IntDefaultHandler,                      // GPIO Port Q1
    IntDefaultHandler,                      // GPIO Port Q2
    IntDefaultHandler,                      // GPIO Port Q3
    IntDefaultHandler,                      // GPIO Port Q4
    IntDefaultHandler,                      // GPIO Port Q5
    IntDefaultHandler,                      // GPIO Port Q6
    IntDefaultHandler,                      // GPIO Port Q7
    IntDefaultHandler,                      // GPIO Port R
    IntDefaultHandler,                      // GPIO Port S
    IntDefaultHandler,                      // PWM 1 Generator 0
    IntDefaultHandler,                      // PWM 1 Generator 1
    IntDefaultHandler,                      // PWM 1 Generator 2
    IntDefaultHandler,                      // PWM 1 Generator 3
    IntDefaultHandler                       // PWM 1 Fault
};

//*****************************************************************************
//
// This is the code that gets called when the processor first starts execution
// following a reset event.  Only the absolutely necessary set is performed,
// after which the application supplied entry() routine is called.  Any fancy
// actions (such as making decisions based on the reset cause register, and
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//*****************************************************************************
void
ResetISR(void)
{
    //
    // Enable the floating-point unit.  This must be done here to handle the
    // case where main() uses floating-point and the function prologue saves
    // floating-point registers (which will fault if floating-point is not
    // enabled).  Any configuration of the floating-point unit using DriverLib
    // APIs must be done here prior to the floating-point unit being enabled.
    //
    // Note that this does not use DriverLib since it might not be included in
    // this project.
    //
    HWREG(NVIC_CPAC) = ((HWREG(NVIC_CPAC) &
                         ~(NVIC_CPAC_CP10_M | NVIC_CPAC_CP11_M)) |
                        NVIC_CPAC_CP10_FULL | NVIC_CPAC_CP11_FULL);

    //
    // Call the application's entry point.
    //
    __iar_program_start();
}

//*****************************************************************************
//
// This is the code that gets called when the processor receives a NMI.  This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
static void
NmiSR(void)
{
    //
    // Enter an infinite loop.
    //
    while(1)
    {
    }
}

//*****************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt.  This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
FaultISR(void)
{
    //
    // Enter an infinite loop.
    //
    while(1)
    {
    }
}

//*****************************************************************************
//
// This is the code that gets called when the processor receives an unexpected
// interrupt.  This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
IntDefaultHandler(void)
{
    //
    // Go into an infinite loop.
    //
    while(1)
    {
    }
}

over 5 years ago

0 Charles Tsai over 5 years ago

TI__Guru**** 191846 points

Hi,

RONIT SHARMA said:
I connected my Tiva board with nodemcu in uart1. I'm trying to receive a string from a nodemcu in the Tiva board and print it.

What do you mean by print it? Do you mean to print to the terminal window? Please note only UART0 is used as a virtual COM port on the EK-TM4C123GXL launchPad. Not UART1 unless you have a USB to UART adapter that sits between the UART1 and your PC.

RONIT SHARMA said:
it's not even going to interrupt handler I've initialized interrupt handler function in startup file also.

I don't see your main file. You only attach the startup file. In any case, I will suggest you start with the TivaWare example. You can find <TivaWare_Installation>/examples/boards/ek-tm4c123gxl/uart_echo and examples under <TivaWare_Installation>/examples/peripherals/uart. These are examples using polling method. If you can get them to work then it is easy to change to interrupt mode. I will suggest to aid you debugging, you should have the scope or logic analyzer to watch the bus traffic. How do you know if your nodemcu is or isn't transmitting data to the Tiva. Do you have scope cap to prove it is transmitting the correct data and a matching data format (baud rate, stop bits, parity) to the Tiva device?

0 RONIT SHARMA over 5 years ago in reply to Charles Tsai

Prodigy 140 points

I used UART1 of tiva board to connect nodemcu and UART 0 to print data that I have received in uart1.

main code:-

#include<stdint.h>
#include<stdbool.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"
#include "inc/hw_ints.h"
#include "driverlib/interrupt.h"
#include "utils/uartstdio.h"

//void UARTprintf(int,char);
uint32_t recv_buf[20];
uint8_t flag = 0;
uint8_t i=0;

void UARTIntHandler(void)
{
uint32_t ulStatus;
ulStatus = UARTIntStatus(UART0_BASE, true); //get interrupt status
UARTIntClear(UART1_BASE, ulStatus); //clear the asserted interrupts
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); //blink LED
while(UARTCharsAvail(UART1_BASE)) //loop while there are chars
{
recv_buf[i++] = (UARTCharGetNonBlocking(UART1_BASE)&0xFF);
}
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); //blink LED
flag = 1;
i = 0;
}

void printf(uint8_t *value)
{
while(*value)
{
UARTCharPut(UART0_BASE,*value++);
}
}

void init_uart_0()
{
// Enable uart peripheral
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// Set Tx and Rx
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
// Configure Baud rate
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200, UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE);
UARTFIFOEnable(UART0_BASE);

}

void init_uart_1()
{
// Enable uart peripheral
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
// Set Tx and Rx
GPIOPinConfigure(GPIO_PB0_U1RX);
GPIOPinConfigure(GPIO_PB1_U1TX);
GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
// Configure Baud rate
UARTConfigSetExpClk(UART1_BASE, SysCtlClockGet(), 115200, UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE);
// FIFO SET
UARTFIFOLevelSet(UART1_BASE,UART_FIFO_TX4_8, UART_FIFO_RX1_8);
UARTFIFOEnable(UART1_BASE);
UARTLoopbackEnable(UART1_BASE);
// Configure Interuupt
IntMasterEnable();
IntEnable(INT_UART1);
UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT);
}

void init_led()
{
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1 | GPIO_PIN_3 );
}

int main()
{
init_uart_0();
init_uart_1();
init_led();
printf("UART0 initilized");
printf("UART1 initilized");
// UARTprintf("Initilized");
while(1)
{
if(flag)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1); //blink LED
printf((uint8_t *)(&recv_buf));
flag = 0;
}
}

}

0 Charles Tsai over 5 years ago in reply to RONIT SHARMA

TI__Guru**** 191846 points

You wrote below for the UARTIntHandler().

uint32_t ulStatus;
ulStatus = UARTIntStatus(UART0_BASE, true); //get interrupt status
UARTIntClear(UART1_BASE, ulStatus); //clear the asserted interrupts
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); //blink LED
while(UARTCharsAvail(UART1_BASE)) //loop while there are chars

You are generating interrupt on UART1, not UART0. So this is the first mistake to fix.

You wrote:

UARTLoopbackEnable(UART1_BASE);

Why are you putting UART1 in loopback mode? When you are in loopback mode then the TX are RX are internally connected. It will not talk to your external device.

0 cb1_mobile over 5 years ago in reply to Charles Tsai

Guru 117855 points

Hi Charles,

Might you know - or be able to test to determine if UART_n's TX output appears at the pin - as well as internally (via the loopback?) (where n != 0)

(a client notes "difficulty" w/the loopback - thus our desire to monitor the TX Output while loopback is "in process." We are able to monitor client's MCU remotely (i.e. at the MCU's pins.)

Thanks Charles - your time & attention.

0 Charles Tsai over 5 years ago in reply to cb1_mobile

TI__Guru**** 191846 points

Hi cb1,

I can check the TX pin in loopback mode when I get a chance on Monday. Whether or not the TX can be monitored in loopback mode is moot in this case. The poster wants to receive data from the external nodemcu. Therefore, the UART1 RX pin cannot be connect to its own TX pin in loopback mode. The shift register needs to connect to the RX pin.

0 cb1_mobile over 5 years ago in reply to Charles Tsai

Guru 117855 points

Hi Charles,

Thank you - appreciated. While moot to this forum poster - our concern was/is directed towards (our) client - who has not posted.

Having worked in the semi industry it is believed that, "Breaking the wire-bond connection to the TX pin (during loopback) would add cost as opposed to simply gatingTX to the (nearby) RX." Again we have the ability to monitor our client's GPIO remotely - thus our request.

0 RONIT SHARMA over 5 years ago in reply to Charles Tsai

Prodigy 140 points

Hii Charles,

Thanks for a reply. I made a very silly mistake. But one thing I realized as per the example code if I used while loop -

ulStatus = UARTIntStatus(UART0_BASE, true); //get interrupt status
UARTIntClear(UART1_BASE, ulStatus); //clear the asserted interrupts
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); //blink LED
while(UARTCharsAvail(UART1_BASE)) //loop while there are chars
{
recv_buf[i++] = (UARTCharGetNonBlocking(UART1_BASE)&0xFF);
}

I'm getting only half of the strings but if I used if condition instead of while loop I'm able to receive the whole string.

Can you please check this?

0 RONIT SHARMA over 5 years ago in reply to RONIT SHARMA

Prodigy 140 points

Hey Charles, I'm waiting for your reply.

0 Charles Tsai over 5 years ago in reply to RONIT SHARMA

TI__Guru**** 191846 points

Can you show your code using the if statement?

You wrote:

UARTFIFOLevelSet(UART1_BASE,UART_FIFO_TX4_8, UART_FIFO_RX1_8);

With UART_FIFO_RX1_8, this means you will generate an RX interrupt when 1/8 of the FIFO is full. What if you change to UART_FIFO_RX4_8? Does it make a difference?

0 RONIT SHARMA over 5 years ago in reply to Charles Tsai

Prodigy 140 points

There is a "while" loop.

while(UARTCharsAvail(UART1_BASE)) //loop while there are chars

{

recv_buf[i++] = (UARTCharGetNonBlocking(UART1_BASE)&0xFF);

}

when I'm writing while loop, I'm getting half characters randomly of the whole string length but when I'm using if instead of while I'm getting the exact string what I've received through UART.

0 Charles Tsai over 5 years ago in reply to RONIT SHARMA

TI__Guru**** 191846 points

I asked if you try UART_FIFO_RX4_8, did it make a difference?

Arm-based microcontrollers

Arm-based microcontrollers forum

TM4C123GH6PM: TM4C123GH6PM