Sorry, you need to enable JavaScript to visit this website.

UART application

Unsolved
11 posts / 0 new
sebastianuskh's picture
sebastianuskh
Junior(0)
UART application

Dear all,
I'm new to Microzed and I need to use UART communication for my project. I need to get data using the UART and I cannot found any tutorial that helps me to set the UART. I already found example from Xilinx but it is not working. Any idea where I can get the tutorial to setting the UART?

TroutChaser's picture
TroutChaser
Moderator(18)
Please be more specific

Which UART are you trying to use, UART1 which is connected by default to the USB-UART device, or UART0 which is not connected by default? Exactly what are you attempting to do? And which Xilinx example is not working.
 
-Gary

sebastianuskh's picture
sebastianuskh
Junior(0)
I have already connected the

I have already connected the UART0 and UART1 to the Pmod port and didn't have any problem with it. Also I have already test hello world for both of them. The problem occurs when I tried get data from other device with UART and use them as an interrupt. thx alot.

* @file xuartlite_intr_example.c
*
* This file contains a design example using the UartLite driver (XUartLite) and
* hardware device using the interrupt mode.
*
* @note
*
* The user must provide a physical loopback such that data which is
* transmitted will be received.
*
* MODIFICATION HISTORY:
* <pre>
* Ver Who Date Changes
* ----- ---- -------- -----------------------------------------------
* 1.00a jhl 02/13/02 First release
* 1.00b rpm 10/01/03 Made XIntc declaration global
* 1.00b sv 06/09/05 Minor changes to comply to Doxygen and coding guidelines
* 2.00a ktn 10/20/09 Updated to use HAL Processor APIs and minor changes
* for coding guidelnes.
* </pre>
******************************************************************************/

/***************************** Include Files *********************************/

#include "xparameters.h"
#include "xuartlite.h"
#include "xintc.h"
#include "xil_exception.h"

/************************** Constant Definitions *****************************/

/*
* The following constants map to the XPAR parameters created in the
* xparameters.h file. They are defined here such that a user can easily
* change all the needed parameters in one place.
*/
#define UARTLITE_DEVICE_ID XPAR_UARTLITE_0_DEVICE_ID
#define INTC_DEVICE_ID XPAR_INTC_0_DEVICE_ID
#define UARTLITE_INT_IRQ_ID XPAR_INTC_0_UARTLITE_1_VEC_ID

/*
* The following constant controls the length of the buffers to be sent
* and received with the UartLite device.
*/
#define TEST_BUFFER_SIZE 1

/**************************** Type Definitions *******************************/

/***************** Macros (Inline Functions) Definitions *********************/

/************************** Function Prototypes ******************************/

int UartLiteIntrExample(u16 DeviceId);

int SetupInterruptSystem(XUartLite *UartLitePtr);

void SendHandler(void *CallBackRef, unsigned int EventData);

void RecvHandler(void *CallBackRef, unsigned int EventData);

/************************** Variable Definitions *****************************/

XUartLite UartLite; /* The instance of the UartLite Device */

XIntc InterruptController; /* The instance of the Interrupt Controller */

/*
* The following variables are shared between non-interrupt processing and
* interrupt processing such that they must be global.
*/

/*
* The following buffers are used in this example to send and receive data
* with the UartLite.
*/
u8 SendBuffer[TEST_BUFFER_SIZE];
u8 ReceiveBuffer[TEST_BUFFER_SIZE];

/*
* The following counters are used to determine when the entire buffer has
* been sent and received.
*/
static volatile int TotalReceivedCount;
static volatile int TotalSentCount;

/******************************************************************************/
/**
*
* Main function to call the UartLite interrupt example.
*
* @param None
*
* @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful
*
* @note None
*
*******************************************************************************/
int main(void)
{
int Status;

/*
* Run the UartLite Interrupt example, specify the Device ID that is
* generated in xparameters.h.
*/
Status = UartLiteIntrExample(UARTLITE_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

return XST_SUCCESS;
}

/****************************************************************************/
/**
*
* This function does a minimal test on the UartLite device and driver as a
* design example. The purpose of this function is to illustrate
* how to use the XUartLite component.
*
* This function sends data and expects to receive the same data through the
* UartLite. The user must provide a physical loopback such that data which is
* transmitted will be received.
*
* This function uses interrupt driver mode of the UartLite device. The calls
* to the UartLite driver in the handlers should only use the non-blocking
* calls.
*
* @param DeviceId is the Device ID of the UartLite Device and is the
* XPAR_<uartlite_instance>_DEVICE_ID value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note
*
* This function contains an infinite loop such that if interrupts are not
* working it may never return.
*
****************************************************************************/
int UartLiteIntrExample(u16 DeviceId)
{
int Status;
int Index;

/*
* Initialize the UartLite driver so that it's ready to use.
*/
Status = XUartLite_Initialize(&UartLite, DeviceId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XUartLite_SelfTest(&UartLite);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
* Connect the UartLite to the interrupt subsystem such that interrupts can
* occur. This function is application specific.
*/
Status = SetupInterruptSystem(&UartLite);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
* Setup the handlers for the UartLite that will be called from the
* interrupt context when data has been sent and received, specify a
* pointer to the UartLite driver instance as the callback reference so
* that the handlers are able to access the instance data.
*/
XUartLite_SetSendHandler(&UartLite, SendHandler, &UartLite);
XUartLite_SetRecvHandler(&UartLite, RecvHandler, &UartLite);

/*
* Enable the interrupt of the UartLite so that interrupts will occur.
*/
XUartLite_EnableInterrupt(&UartLite);
xil_printf("run");
/*
* Initialize the send buffer bytes with a pattern to send and the
* the receive buffer bytes to zero to allow the receive data to be
* verified.
*/
// for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
// SendBuffer[Index] = Index;
// ReceiveBuffer[Index] = 0;
// }
//
// /*
// * Start receiving data before sending it since there is a loopback.
// */
// XUartLite_Recv(&UartLite, ReceiveBuffer, TEST_BUFFER_SIZE);
//
// /*
// * Send the buffer using the UartLite.
// */
// XUartLite_Send(&UartLite, SendBuffer, TEST_BUFFER_SIZE);
//
// /*
// * Wait for the entire buffer to be received, letting the interrupt
// * processing work in the background, this function may get locked
// * up in this loop if the interrupts are not working correctly.
// */
// while ((TotalReceivedCount != TEST_BUFFER_SIZE) ||
// (TotalSentCount != TEST_BUFFER_SIZE)) {
// }
//
// /*
// * Verify the entire receive buffer was successfully received.
// */
// for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
// if (ReceiveBuffer[Index] != SendBuffer[Index]) {
// return XST_FAILURE;
// }
// }
while(1);

return XST_SUCCESS;
}

/*****************************************************************************/
/**
*
* This function is the handler which performs processing to send data to the
* UartLite. It is called from an interrupt context such that the amount of
* processing performed should be minimized. It is called when the transmit
* FIFO of the UartLite is empty and more data can be sent through the UartLite.
*
* This handler provides an example of how to handle data for the UartLite,
* but is application specific.
*
* @param CallBackRef contains a callback reference from the driver.
* In this case it is the instance pointer for the UartLite driver.
* @param EventData contains the number of bytes sent or received for sent
* and receive events.
*
* @return None.
*
* @note None.
*
****************************************************************************/
void SendHandler(void *CallBackRef, unsigned int EventData)
{
TotalSentCount = EventData;
print("send");
}

/****************************************************************************/
/**
*
* This function is the handler which performs processing to receive data from
* the UartLite. It is called from an interrupt context such that the amount of
* processing performed should be minimized. It is called data is present in
* the receive FIFO of the UartLite such that the data can be retrieved from
* the UartLite. The size of the data present in the FIFO is not known when
* this function is called.
*
* This handler provides an example of how to handle data for the UartLite,
* but is application specific.
*
* @param CallBackRef contains a callback reference from the driver, in
* this case it is the instance pointer for the UartLite driver.
* @param EventData contains the number of bytes sent or received for sent
* and receive events.
*
* @return None.
*
* @note None.
*
****************************************************************************/
void RecvHandler(void *CallBackRef, unsigned int EventData)
{
TotalReceivedCount = EventData;
xil_printf("recv");
}

/****************************************************************************/
/**
*
* This function setups the interrupt system such that interrupts can occur
* for the UartLite device. This function is application specific since the
* actual system may or may not have an interrupt controller. The UartLite
* could be directly connected to a processor without an interrupt controller.
* The user should modify this function to fit the application.
*
* @param UartLitePtr contains a pointer to the instance of the UartLite
* component which is going to be connected to the interrupt
* controller.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
****************************************************************************/
int SetupInterruptSystem(XUartLite *UartLitePtr)
{

int Status;

/*
* Initialize the interrupt controller driver so that it is ready to
* use.
*/
Status = XIntc_Initialize(&InterruptController, INTC_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
* Connect a device driver handler that will be called when an interrupt
* for the device occurs, the device driver handler performs the
* specific interrupt processing for the device.
*/
Status = XIntc_Connect(&InterruptController, UARTLITE_INT_IRQ_ID,
(XInterruptHandler)XUartLite_InterruptHandler,
(void *)UartLitePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
* Start the interrupt controller such that interrupts are enabled for
* all devices that cause interrupts, specific real mode so that
* the UartLite can cause interrupts through the interrupt controller.
*/
Status = XIntc_Start(&InterruptController, XIN_REAL_MODE);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}

/*
* Enable the interrupt for the UartLite device.
*/
XIntc_Enable(&InterruptController, UARTLITE_INT_IRQ_ID);

/*
* Initialize the exception table.
*/
Xil_ExceptionInit();

/*
* Register the interrupt controller handler with the exception table.
*/
Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
(Xil_ExceptionHandler)XIntc_InterruptHandler,
&InterruptController);

/*
* Enable exceptions.
*/
Xil_ExceptionEnable();

return XST_SUCCESS;
}

TroutChaser's picture
TroutChaser
Moderator(18)
The code you show is for the axi_uartlite

So if I understand correctly you are using a MicroZed board and have added an axi_uartlite core to your Zynq Programmable Logic (PL) section and connected it via an axi_interconnect core to the Zynq processor, and connected the interrupt from the axi_uartlite core to a Zynq PS interrupt that you have enabled. How have you connected the uartlite rx and tx signals to your external device? The Pmod port on the MicroZed is only connected to Zynq MIO pins and so cannot provide a connection from PL based peripherals. Are you using a carrier card?
 
If you have built this hardware and exported to SDK I would first verify that it works in non-interrupt mode.
 
Once these steps verify your hardware design we can start to debug interrupt based operation.
 
-Gary

sebastianuskh's picture
sebastianuskh
Junior(0)
solved, thx anyway

solved, thx anyway

lozuwa's picture
lozuwa
Junior(0)
I am facing the same problem

Greetings,
I am facing the same problem. I cannot see whether the buffer sends information or not. Would you please share the way you solved it? Please, a lot of people would thank you.

sebastianuskh's picture
sebastianuskh
Junior(0)
solved

the problem is the UART interrupt is setting into UART1 not UART0. The example program need to be edited.

TroutChaser's picture
TroutChaser
Moderator(18)
Glad you found the issue

Glad you found the issue, thanks for sharing the details.
 
Which Xilinx tools version did you find the errant code in? I pulled up the example code from the latest version (2013.4) and it is correct, without the error you show, even though it is labeled with the same 2.00a Version with a 10/20/09 update date.
 
-Gary

sebastianuskh's picture
sebastianuskh
Junior(0)
well I'm also using xilinx

well I'm also using xilinx tools version 2013.4. don't know why it's different. anyway thx.

anacode's picture
anacode
Junior(0)
Xilinx's UART0 example file in SDK

In Vivado 2014.4, if you open the UART_0 interrupt example file (xuartps_intr_example.c), there is wrong ID for the UART_INT_IRQ_ID definition. The example has the ID of XPAR_XUARTPS_1_INTR and it should be XPAR_XUARTPS_0_INTR.

FDVB's picture
FDVB
Junior(0)
Xilinx's UART0

Can you tell how do you resolved the problem? A do not understand how I do the hardware's configurations. Can you help me? Do you have a tutorial?

Thanks