UART application

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

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;
}

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

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

solved, thx anyway

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

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

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.

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

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.