forked from ROMEO/obsw
231 lines
6.8 KiB
C
231 lines
6.8 KiB
C
|
|
/************************************************************/
|
|
/* UART SETUP AND USAGE */
|
|
/************************************************************/
|
|
|
|
/******************************************************************************
|
|
* Copyright (C) 2002 - 2021 Xilinx, Inc. All rights reserved.
|
|
* Copyright (c) 2022 - 2023 Advanced Micro Devices, Inc. All Rights Reserved.
|
|
* SPDX-License-Identifier: MIT
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************/
|
|
/**
|
|
*
|
|
* @file xuartlite_polled_example.c
|
|
*
|
|
* This file contains a design example using the UartLite driver (XUartLite) and
|
|
* hardware device using the polled 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.00a sv 06/13/05 Minor changes to comply to Doxygen and coding guidelines
|
|
* 2.00a ktn 10/20/09 Updated this example to wait for valid data in receive
|
|
* fifo instead of Tx fifo empty to update receive buffer
|
|
* and minor changes as per coding guidelines.
|
|
* 3.2 ms 01/23/17 Added xil_printf statement in main function to
|
|
* ensure that "Successfully ran" and "Failed" strings
|
|
* are available in all examples. This is a fix for
|
|
* CR-965028.
|
|
* 3.9 gm 07/08/23 Added SDT support
|
|
* </pre>
|
|
******************************************************************************/
|
|
|
|
/***************************** Include Files *********************************/
|
|
|
|
#include "xparameters.h"
|
|
#include "xstatus.h"
|
|
#include "xuartlite.h"
|
|
#include "xil_printf.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.
|
|
*/
|
|
#ifndef SDT
|
|
#define UARTLITE_DEVICE_ID XPAR_UARTLITE_0_DEVICE_ID
|
|
#else
|
|
#define XUARTLITE_BASEADDRESS XPAR_XUARTLITE_0_BASEADDR
|
|
#endif
|
|
|
|
/*
|
|
* The following constant controls the length of the buffers to be sent
|
|
* and received with the UartLite, this constant must be 16 bytes or less since
|
|
* this is a single threaded non-interrupt driven example such that the
|
|
* entire buffer will fit into the transmit and receive FIFOs of the UartLite.
|
|
*/
|
|
#define TEST_BUFFER_SIZE 16
|
|
|
|
/**************************** Type Definitions *******************************/
|
|
|
|
|
|
/***************** Macros (Inline Functions) Definitions *********************/
|
|
|
|
|
|
/************************** Function Prototypes ******************************/
|
|
#ifndef SDT
|
|
int UartLitePolledExample(u16 DeviceId);
|
|
#else
|
|
int UartLitePolledExample(UINTPTR BaseAddress);
|
|
#endif
|
|
|
|
/************************** Variable Definitions *****************************/
|
|
|
|
XUartLite UartLite; /* Instance of the UartLite Device */
|
|
|
|
/*
|
|
* The following buffers are used in this example to send and receive data
|
|
* with the UartLite.
|
|
*/
|
|
u8 SendBuffer[TEST_BUFFER_SIZE]; /* Buffer for Transmitting Data */
|
|
u8 RecvBuffer[TEST_BUFFER_SIZE]; /* Buffer for Receiving Data */
|
|
|
|
/*****************************************************************************/
|
|
/**
|
|
*
|
|
* Main function to call the Uartlite polled example.
|
|
*
|
|
*
|
|
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
|
|
*
|
|
* @note None.
|
|
*
|
|
******************************************************************************/
|
|
int uart_polled_test(void)
|
|
{
|
|
int Status;
|
|
|
|
/*
|
|
* Run the UartLite polled example, specify the Device ID that is
|
|
* generated in xparameters.h
|
|
*/
|
|
#ifndef SDT
|
|
Status = UartLitePolledExample(UARTLITE_DEVICE_ID);
|
|
#else
|
|
Status = UartLitePolledExample(XUARTLITE_BASEADDRESS);
|
|
#endif
|
|
if (Status != XST_SUCCESS) {
|
|
xil_printf("Uartlite polled Example Failed\r\n");
|
|
return XST_FAILURE;
|
|
}
|
|
|
|
xil_printf("Successfully ran Uartlite polled Example\r\n");
|
|
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 data through the UartLite
|
|
* such that a physical loopback must be done with the transmit and receive
|
|
* signals of the UartLite.
|
|
*
|
|
* This function polls the UartLite and does not require the use of interrupts.
|
|
*
|
|
* @param DeviceId is the Device ID of the UartLite and is the
|
|
* XPAR_<uartlite_instance>_DEVICE_ID value from xparameters.h.
|
|
*
|
|
* @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful.
|
|
*
|
|
*
|
|
* @note
|
|
*
|
|
* This function calls the UartLite driver functions in a blocking mode such that
|
|
* if the transmit data does not loopback to the receive, this function may
|
|
* not return.
|
|
*
|
|
****************************************************************************/
|
|
#ifndef SDT
|
|
int UartLitePolledExample(u16 DeviceId)
|
|
#else
|
|
int UartLitePolledExample(UINTPTR BaseAddress)
|
|
#endif
|
|
{
|
|
int Status;
|
|
unsigned int SentCount;
|
|
unsigned int ReceivedCount = 0;
|
|
int Index;
|
|
|
|
/*
|
|
* Initialize the UartLite driver so that it is ready to use.
|
|
*/
|
|
#ifndef SDT
|
|
Status = XUartLite_Initialize(&UartLite, DeviceId);
|
|
#else
|
|
Status = XUartLite_Initialize(&UartLite, BaseAddress);
|
|
#endif
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Initialize the send buffer bytes with a pattern to send and the
|
|
* the receive buffer bytes to zero.
|
|
*/
|
|
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
|
|
SendBuffer[Index] = Index;
|
|
RecvBuffer[Index] = 0;
|
|
}
|
|
|
|
/*
|
|
* Send the buffer through the UartLite waiting til the data can be sent
|
|
* (block), if the specified number of bytes was not sent successfully,
|
|
* then an error occurred.
|
|
*/
|
|
SentCount = XUartLite_Send(&UartLite, SendBuffer, TEST_BUFFER_SIZE);
|
|
if (SentCount != TEST_BUFFER_SIZE) {
|
|
return XST_FAILURE;
|
|
}
|
|
|
|
/*
|
|
* Receive the number of bytes which is transferred.
|
|
* Data may be received in fifo with some delay hence we continuously
|
|
* check the receive fifo for valid data and update the receive buffer
|
|
* accordingly.
|
|
*/
|
|
while (1) {
|
|
ReceivedCount += XUartLite_Recv(&UartLite,
|
|
RecvBuffer + ReceivedCount,
|
|
TEST_BUFFER_SIZE - ReceivedCount);
|
|
if (ReceivedCount == TEST_BUFFER_SIZE) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Check the receive buffer data against the send buffer and verify the
|
|
* data was correctly received.
|
|
*/
|
|
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
|
|
if (SendBuffer[Index] != RecvBuffer[Index]) {
|
|
return XST_FAILURE;
|
|
}
|
|
}
|
|
|
|
return XST_SUCCESS;
|
|
}
|