UART problem

Carlos Gonzalez2

Well I didnt wanted to make a post about this but i'm tired of this, im using the uart_echo example for UART0 and works perfectly but when I try to use the UART1 or 2 it doesnt work, I try to see the result in RealTerm but I dont get any response from the UART1 (or 2), I also check the physical pins of the stellaris U2TX with an RS232 to USB but again i dont see any response from the UART i dont know whats wrong with my code if someone has the time and the kwnoledge to tell me whats wrong i would appreciate.

#include "inc/hw_ints.h"

#include "inc/hw_memmap.h"

#include "inc/hw_types.h"

#include "driverlib/debug.h"

#include "driverlib/fpu.h"

#include "driverlib/gpio.h"

#include "driverlib/interrupt.h"

#include "driverlib/pin_map.h"

#include "driverlib/rom.h"

#include "driverlib/sysctl.h"

#include "driverlib/uart.h"

//*****************************************************************************

// The error routine that is called if the driver library encounters an error.

//*****************************************************************************

#ifdef DEBUG

void

__error__(char *pcFilename, unsigned long ulLine)

{

}

#endif

//*****************************************************************************

// The UART interrupt handler.

//*****************************************************************************

void

UARTIntHandler(void)

{

unsigned long ulStatus;

// Get the interrrupt status.

//UART0

ulStatus = ROM_UARTIntStatus(UART0_BASE, true);

//UART1

//ulStatus = ROM_UARTIntStatus(UART2_BASE, true);

// Clear the asserted interrupts.

//UART0

ROM_UARTIntClear(UART0_BASE, ulStatus);

//UART1

//ROM_UARTIntClear(UART2_BASE, ulStatus);

// Loop while there are characters in the receive FIFO.

//UART0

while(ROM_UARTCharsAvail(UART0_BASE))

//UART1

//while(ROM_UARTCharsAvail(UART2_BASE))

{

// Read the next character from the UART and write it back to the UART.

//UART0

ROM_UARTCharPutNonBlocking(UART0_BASE, ROM_UARTCharGetNonBlocking(UART0_BASE));

//UART1

//ROM_UARTCharPutNonBlocking(UART2_BASE, ROM_UARTCharGetNonBlocking(UART2_BASE));

// Blink the LED to show a character transfer is occuring.

//GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);

// Delay for 1 millisecond. Each SysCtlDelay is about 3 clocks.

SysCtlDelay(SysCtlClockGet() / (1000 * 3));

// Turn off the LED

//GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);

}

//*****************************************************************************

// Send a string to the UART.

//*****************************************************************************

void

UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)

{

// Loop while there are more characters to send.

while(ulCount--)

{

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);

SysCtlDelay(SysCtlClockGet() / (10 * 3));

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);

SysCtlDelay(SysCtlClockGet() / (10 * 3));

// Write the next character to the UART.

//UART0

ROM_UARTCharPutNonBlocking(UART0_BASE, *pucBuffer++);

//UART1

//ROM_UARTCharPutNonBlocking(UART2_BASE, *pucBuffer++);

}

//*****************************************************************************

// This example demonstrates how to send a string of data to the UART.

//*****************************************************************************

int

main(void)

{

// Enable lazy stacking for interrupt handlers. This allows floating-point

// instructions to be used within interrupt handlers, but at the expense of

// extra stack usage.

ROM_FPUEnable();

ROM_FPULazyStackingEnable();

// Set the clocking to run directly from the crystal.

ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |

SYSCTL_XTAL_16MHZ);

// Enable the GPIO port that is used for the on-board LED.

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

// Enable the GPIO pins for the LED (PF2).

ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);

// Enable the peripherals used by this example.

//UART0

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

//UART1

//ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);

//ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);

// Enable processor interrupts.

ROM_IntMasterEnable();

// Set GPIO A0 and A1 as UART pins.

//UART0

GPIOPinConfigure(GPIO_PA0_U0RX);

GPIOPinConfigure(GPIO_PA1_U0TX);

ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

//UART1

//GPIOPinConfigure(GPIO_PD6_U2RX);

//GPIOPinConfigure(GPIO_PD7_U2TX);

//ROM_GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);

// Configure the UART for 115,200, 8-N-1 operation.

//UART0

ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,

(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |

UART_CONFIG_PAR_NONE));

//UART1

//ROM_UARTConfigSetExpClk(UART2_BASE, ROM_SysCtlClockGet(), 115200,

// (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |

// UART_CONFIG_PAR_NONE));

// Enable the UART interrupt.

//UART0

ROM_IntEnable(INT_UART0);

ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);

//UART1

//ROM_IntEnable(INT_UART2);

//ROM_UARTIntEnable(UART2_BASE, UART_INT_RX | UART_INT_RT);

// Prompt for text to be entered.

UARTSend((unsigned char *)"\033[2JEnter text: ", 16);

UARTCharPut(UART0_BASE,'1');

// Loop forever echoing data through the UART.

while(1)

{

}

and the startup_ccs

//*****************************************************************************

// startup_ccs.c - Startup code for use with TI's Code Composer Studio.

// 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 9453 of the EK-LM4F120XL Firmware Package.

//*****************************************************************************

// Forward declaration of the default fault handlers.

//*****************************************************************************

void ResetISR(void);

static void NmiSR(void);

static void FaultISR(void);

static void IntDefaultHandler(void);

//*****************************************************************************

// External declaration for the reset handler that is to be called when the

// processor is started

//*****************************************************************************

extern void _c_int00(void);

//*****************************************************************************

// Linker variable that marks the top of the stack.

//*****************************************************************************

extern unsigned long __STACK_TOP;

//*****************************************************************************

// External declaration for the interrupt handler used by the application.

//*****************************************************************************

extern void UARTIntHandler(void);

//*****************************************************************************

// The vector table. Note that the proper constructs must be placed on this to

// ensure that it ends up at physical address 0x0000.0000 or at the start of

// the program if located at a start address other than 0.

//*****************************************************************************

#pragma DATA_SECTION(g_pfnVectors, ".intvecs")

void (* const g_pfnVectors[])(void) =

{

(void (*)(void))((unsigned long)&__STACK_TOP),

// 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

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

UARTIntHandler, // 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

UARTIntHandler, // 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

IntDefaultHandler, // CAN2

IntDefaultHandler, // Ethernet

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

IntDefaultHandler, // I2S0

IntDefaultHandler, // External Bus Interface 0

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

IntDefaultHandler, // I2C2 Master and Slave

IntDefaultHandler, // I2C3 Master and Slave

IntDefaultHandler, // Timer 4 subtimer A

IntDefaultHandler, // Timer 4 subtimer B

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

IntDefaultHandler, // PECI 0

IntDefaultHandler, // LPC 0

IntDefaultHandler, // I2C4 Master and Slave

IntDefaultHandler, // I2C5 Master and Slave

IntDefaultHandler, // GPIO Port M

IntDefaultHandler, // GPIO Port N

IntDefaultHandler, // Quadrature Encoder 2

IntDefaultHandler, // Fan 0

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)

{

// Jump to the CCS C initialization routine. This will enable the

// floating-point unit as well, so that does not need to be done here.

__asm(" .global _c_int00\n"

" b.w _c_int00");

}

//*****************************************************************************

// 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 12 years ago

0 slandrum over 12 years ago

Mastermind 9890 points

The first thing to note is that the TX and RX pins on the UART ports on the processor are NOT RS232 pins. If you want RS232, then you need to connect the pins to something that generates RS232 levels. If you connect them directly to RS232 lines, you will likely damage your processor.

0 cb1 over 12 years ago in reply to slandrum

Guru 47900 points

@ slandrum: Of course yours is good advice - however may not fully apply in this poster's case. He states that he is able to transact via UART_0 - and does make mention of an RS232-USB converter, ("see the result in RealTerm"). (which may really be a USB to Cmos-Level converter) To my knowledge - his is launchpad - which has no RS232 level shifters on any port - but again he is able to transact via Uart_0...

@ Carlos: Don't let this ARM stuff get you down - it is highly complex - demands constant attention to detail. Arduino is better choice for those "less patient" - who demand instant,easy results. Don't suffer - suggest that you find interested others near you (university, trade-school, small firms) amazing how several minds can combine to far exceed the individual "pieces." When you report - as you have done - w/sufficient detail & effort - many talented individuals will attempt to help.

Appears that you are setting up and configuring each Uart correctly (although you seem to have transposed Uart1 and Uart2 labels).

Here's my "hunch" - you employ a "multi-port" Uart Interrupt Service - and you likely have not fully/properly "disabled" the "inactive" Uart - meaning that the Uart_RX pin is left floating. Likely then - this "flotating RX pin" will generate an interrupt - and will not be properly serviced - and will thus prevent your "enabled" new Uart from being properly recognized/processed by the "single - multi-Uart - Interrupt Service you've designed.

To prove this theory - employ a physical pull-up R to "hold-up" Uart0_RX and create separate interrupt service routines for each Uart. (remember to properly match their new labels w/in your start-up file.

Uart_1 on launchpad has been reported as problemmatic - Uart_4 is available on these same pins (PC6/7 from my memory) and shows no such issue. You may search for - review this post where I identified this Uart_4 issue (happened w/in past 7 days) Was verified as correct by original poster.

0 Anand Baskaran1 over 12 years ago

Intellectual 345 points

The code you typed looks fine. The program you wrote is used to handle the UART2RX and UART2TX. You may be trying with UART1. I guess that could be a problem for not getting the output.

0 Carlos Gonzalez2 over 12 years ago in reply to cb1

Prodigy 70 points

slandrum said:

The first thing to note is that the TX and RX pins on the UART ports on the processor are NOT RS232 pins. If you want RS232, then you need to connect the pins to something that generates RS232 levels. If you connect them directly to RS232 lines, you will likely damage your processor.

Maybe thats why im not getting response from other UART's. When I said that I saw the result in RealTerm I meant the result from UART_0 (because of the virtual com) so, no USB-RS232 converter was involved (I use FT232RL).

cb1- said:

...

Appears that you are setting up and configuring each Uart correctly (although you seem to have transposed Uart1 and Uart2 labels).

Here's my "hunch" - you employ a "multi-port" Uart Interrupt Service - and you likely have not fully/properly "disabled" the "inactive" Uart - meaning that the Uart_RX pin is left floating. Likely then - this "flotating RX pin" will generate an interrupt - and will not be properly serviced - and will thus prevent your "enabled" new Uart from being properly recognized/processed by the "single - multi-Uart - Interrupt Service you've designed.

To prove this theory - employ a physical pull-up R to "hold-up" Uart0_RX and create separate interrupt service routines for each Uart. (remember to properly match their new labels w/in your start-up file.

Uart_1 on launchpad has been reported as problemmatic - Uart_4 is available on these same pins (PC6/7 from my memory) and shows no such issue. You may search for - review this post where I identified this Uart_4 issue (happened w/in past 7 days) Was verified as correct by original poster.

Thanks for the response, Yes I forgot to change the labels on the comments, I was testing it first with the UART1 but then looked on this forum about the problems with UART_1, I enabled the Pull-Up resistor in GPIOA like this:

HWREG(GPIO_PORTA_BASE + GPIO_O_PUR) = 0xFF;

The datasheet tells me that needs 1 in the bits 0-7. I created the separate IntHandlers for UART0 and UART2 .

But now comes another question, and maybe I had to start with this one, The rest of the UARTs (UART1 and up) are NOT virtual so I cant see any "print" in RealTerm connecting the LaunchPad with the micro usb cable as with the UART0. Right? Then I thought "well lets just use the FT232RL like I did with another microprocessor" (one developed by a professor in my university) but you guys tell me that this LM4F120 doesn't transmit RS232 levels, so what I have done was in a wrong way? if I want to see what im transmitting from the rest of the UART's, what do I need?

Again, thanks for your responses.

UPDATE:

I read some more posts and find out that the UART doesnt transmit RS232 levels so ill put that away.

I checked the PD7 (Tx of UART_2) with an oscilloscope while transmitting:

UART2Send("UART2", 5);

in a loop, but I didn't got any consistence response, just noise

0 cb1_mobile over 12 years ago in reply to Carlos Gonzalez2

Guru 117855 points

Your long code listing - and the mislabeled Uart references - complicate analysis.

You likely have missed the fact that PD7 is a "restricted" pin - defaults to NMI - and must be specially handled. (i.e. unlocked) Thus your (and our) torment.

Hint - always wise to "test" pin for such restriction by ordering it into simple, GPIO Output mode. (PD7 would have "failed" there too - thus alerting you to "something's up" w/that pin...) Devil very much at home w/in these complex MCUs - less frequent visitor to Arduino, dreaded PICs...

PC4, PC5 serve as Uart_4 - have been reported to work - can you instead use them?

(and - would be nice if you can "escape me" from "suggested" into Verified Answer land...)

0 Carlos Gonzalez2 over 12 years ago in reply to cb1_mobile

Prodigy 70 points

Well, I used the UART_4 with the same configuration and worked like a charm with my RS232 adapter (I asked a professor and told me that that adapter is not "entirely" RS232 levels). Added the IntHandlers for the desired UARTs in the startupCSS, no response from UART_2, I implemented the pull up resistor on UART_1. Sorry for the long and not very clear posts.

//*****************************************************************************

// The UART2 interrupt handler.

//*****************************************************************************

void

UART2IntHandler(void)

{

unsigned long ulStatus;

ulStatus = ROM_UARTIntStatus(UART2_BASE, true);

ROM_UARTIntClear(UART2_BASE, ulStatus);

while(ROM_UARTCharsAvail(UART2_BASE))

{

ROM_UARTCharPutNonBlocking(UART2_BASE, ROM_UARTCharGetNonBlocking(UART2_BASE));

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);

SysCtlDelay(SysCtlClockGet() / (100 * 3));

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);

}

//*****************************************************************************

// The UART4 interrupt handler.

//*****************************************************************************

void

UART4IntHandler(void)

{

unsigned long ulStatus;

ulStatus = ROM_UARTIntStatus(UART4_BASE, true);

ROM_UARTIntClear(UART4_BASE, ulStatus);

while(ROM_UARTCharsAvail(UART4_BASE))

{

ROM_UARTCharPutNonBlocking(UART4_BASE, ROM_UARTCharGetNonBlocking(UART4_BASE));

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);

SysCtlDelay(SysCtlClockGet() / (100 * 3));

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);

}

void

UART2Send(const unsigned char *pucBuffer, unsigned long ulCount)

{

// Loop while there are more characters to send.

while(ulCount--)

{

//Turn ON and OFF red LED when transferring

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1);

SysCtlDelay(SysCtlClockGet() / (10 * 3));

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);

SysCtlDelay(SysCtlClockGet() / (10 * 3));

// Write the next character to the UART.

ROM_UARTCharPutNonBlocking(UART2_BASE, *pucBuffer++);

}

//*****************************************************************************

// Send a string to the UART2.

//*****************************************************************************

void

UART4Send(const unsigned char *pucBuffer, unsigned long ulCount)

{

// Loop while there are more characters to send.

while(ulCount--)

{

//Turn ON and OFF red LED when transferring

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);

SysCtlDelay(SysCtlClockGet() / (10 * 3));

GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);

SysCtlDelay(SysCtlClockGet() / (10 * 3));

// Write the next character to the UART.

ROM_UARTCharPutNonBlocking(UART4_BASE, *pucBuffer++);

}

int

main(void)

{

// Enable lazy stacking para interrupciones. Permite usar instrucciones flotantes

// dentro de los IntHandler pero ocupa mas stack

ROM_FPUEnable();

ROM_FPULazyStackingEnable();

// Set the clocking to run directly from the crystal.

ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);

// Enable the GPIO port that is used for the on-board LED.

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

// Enable the GPIO pins for the LED (PF2).

ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);

//ROM_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);

// Enable the peripherals used by this example.

//UART0

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

//UART2

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);

//UART4

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);

ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);

// Enable processor interrupts.

ROM_IntMasterEnable();

//UART0

GPIOPinConfigure(GPIO_PA0_U0RX);

GPIOPinConfigure(GPIO_PA1_U0TX);

ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

//Enable the Pull-Up resistor

HWREG(GPIO_PORTA_BASE + GPIO_O_PUR) = 0xFF;

//UART2

GPIOPinConfigure(GPIO_PD6_U2RX);

GPIOPinConfigure(GPIO_PD7_U2TX);

ROM_GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);

//HWREG(GPIO_PORTD_BASE + GPIO_O_PUR) = 0xFF;

//UART4

GPIOPinConfigure(GPIO_PC4_U4RX);

GPIOPinConfigure(GPIO_PC5_U4TX);

ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);

//UART0

ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,

(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |

UART_CONFIG_PAR_NONE));

//UART2

ROM_UARTConfigSetExpClk(UART2_BASE, ROM_SysCtlClockGet(), 115200,

(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |

UART_CONFIG_PAR_NONE));

//UART4

ROM_UARTConfigSetExpClk(UART4_BASE, ROM_SysCtlClockGet(), 19200,

(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |

UART_CONFIG_PAR_NONE));

// Enable the UART interrupt.

//UART0

ROM_IntEnable(INT_UART0);

ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);

//UART2

ROM_IntEnable(INT_UART2);

ROM_UARTIntEnable(UART2_BASE, UART_INT_RX | UART_INT_RT);

//UART4

ROM_IntEnable(INT_UART4);

ROM_UARTIntEnable(UART4_BASE, UART_INT_RX | UART_INT_RT);

// Prompt for text to be entered.

UART0Send("Enter", 5);

// Loop forever echoing data through the UART.

while(1)

{

UART4Send("UART4", 5);

UART2Send("UART2", 5);

}

0 cb1_mobile over 12 years ago in reply to Carlos Gonzalez2

Guru 117855 points

Carlos Gonzalez2 said:
UART_4 with the same configuration and worked like a charm

Promotion from suggested to Verified Answer - also charming - thanks.

Keep this moment - this victory - long in mind ... future challenges await. (bet you're not "so tired of this" - as 1st post reported...)

Remember you did the work - small steps - systematic - attention to detail - good luck...

Arm-based microcontrollers

Arm-based microcontrollers forum

UART problem