//////////////////////////// PrintData ////////////////////////////////
int PrintData( ){
u32 data;
int dram_addr;
//Read all data from DRAM
// int dram_base = 0xa000000;
// int dram_cieling = 0xa00ffff; //read out data from all integration channels
// Read only Adj Average data from DRAM
int dram_base = 0xa000000;
int dram_cieling = 0xA004000; //read out just adjacent average (0xA004000 - 0xa000000 = 16384)
Xil_DCacheInvalidateRange(0x00000000, 65536);
for (dram_addr = dram_base; dram_addr <= dram_cieling; dram_addr+=4){
if (!sw) { sw = XGpioPs_ReadPin(&Gpio, SW_BREAK_GPIO); } //read pin
data = Xil_In32(dram_addr);
xil_printf("%d\r\n",data);
XUartPs_Recv(&Uart_PS, &RecvBuffer, 32);
if ( RecvBuffer[0] == 'q' ) { sw = 1; }
if(sw) { return sw; }
}
return sw;
}
//function to receive from UART port
void uart_receive(float* in,int RecvCount){
u8 buff[RecvCount];
int counter = 0;
while(counter < RecvCount){
while (!XUartPs_IsReceiveData(Config->BaseAddress));
;//waiting for input
XUartPs_Recv(&uart,&buff[counter],1);
counter++;
}
in =(float*) buff;
}
//////////////////////////// ReadCommandPoll////////////////////////////////
// Function used to clear the read buffer
// Read In new command, expecting a <return>
// Returns buffer size read
int ReadCommandPoll() {
u32 rbuff = 0; // read buffer size returned
int i = 0; // index
XUartPs_SetOptions(&Uart_PS,XUARTPS_OPTION_RESET_RX); // Clear UART Read Buffer
for (i=0; i<32; i++ ) { RecvBuffer[i] = '_'; } // Clear RecvBuffer Variable
while (!(RecvBuffer[rbuff-1] == '\n' || RecvBuffer[rbuff-1] == '\r' || RecvBuffer[rbuff-1] == 'd')) {
rbuff += XUartPs_Recv(&Uart_PS, &RecvBuffer[rbuff],(32 - rbuff));
sleep(0.1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 0.1 s
}
return rbuff;
}
/**
*
* This function is the handler which performs processing to handle data events
* from the device. It is called from an interrupt context. so the amount of
* processing should be minimal.
*
* This handler provides an example of how to handle data for the device and
* is application specific.
*
* @param CallBackRef contains a callback reference from the driver,
* in this case it is the instance pointer for the XUartPs driver.
* @param Event contains the specific kind of event that has occurred.
* @param EventData contains the number of bytes sent or received for sent
* and receive events.
*
* @return None.
*
* @note None.
*
***************************************************************************/
void Handler(void *CallBackRef, u32 Event, unsigned int EventData)
{
/* All of the data has been sent */
if (Event == XUARTPS_EVENT_SENT_DATA) {
TotalSentCount = EventData;
}
/* All of the data has been received */
if (Event == XUARTPS_EVENT_RECV_DATA) {
TotalReceivedCount = EventData;
if (EventData > 0){
XUartPs_Recv(&uart, ch, TEST_BUFFER_SIZE);
//ch[0] = (char) XUartPs_RecvByte(XPAR_PS7_UART_1_BASEADDR); //doesn't work
send = 1;
}
}
/*
* Data was received, but not the expected number of bytes, a
* timeout just indicates the data stopped for 8 character times
*/
if (Event == XUARTPS_EVENT_RECV_TOUT) {
TotalReceivedCount = EventData;
}
/*
* Data was received with an error, keep the data but determine
* what kind of errors occurred
*/
if (Event == XUARTPS_EVENT_RECV_ERROR) {
TotalReceivedCount = EventData;
TotalErrorCount++;
}
/*
* Data was received with an parity or frame or break error, keep the data
* but determine what kind of errors occurred. Specific to Zynq Ultrascale+
* MP.
*/
if (Event == XUARTPS_EVENT_PARE_FRAME_BRKE) {
TotalReceivedCount = EventData;
TotalErrorCount++;
}
/*
* Data was received with an overrun error, keep the data but determine
* what kind of errors occurred. Specific to Zynq Ultrascale+ MP.
*/
if (Event == XUARTPS_EVENT_RECV_ORERR) {
TotalReceivedCount = EventData;
TotalErrorCount++;
}
}
//////////////////////////// DAQ ////////////////////////////////
int DAQ(){
int buffsize; //BRAM buffer size
int dram_addr; // DRAM Address
XUartPs_SetOptions(&Uart_PS,XUARTPS_OPTION_RESET_RX);
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x48, 0xa000000); // DMA Transfer Step 1
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x58 , 65536); // DMA Transfer Step 2
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
ClearBuffers(); // Clear Buffers.
// Capture garbage in DRAM
for (dram_addr = 0xa000000; dram_addr <= 0xA004000; dram_addr+=4){Xil_In32(dram_addr);}
while(1){
buffsize = Xil_In32 (XPAR_AXI_GPIO_11_BASEADDR);
if (!sw) { sw = XGpioPs_ReadPin(&Gpio, SW_BREAK_GPIO); } //read pin
XUartPs_Recv(&Uart_PS, &RecvBuffer, 32);
if ( RecvBuffer[0] == 'q' ) { sw = 1; }
if(sw) { return sw; }
if(buffsize >= 4095){
//Xil_Out32 (XPAR_AXI_GPIO_18_BASEADDR, 0); // Disable Capture Module in FPGA
Xil_Out32 (XPAR_AXI_GPIO_15_BASEADDR, 1);
//sleep(10); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 10 s
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x48, 0xa000000);
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x58 , 65536);
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
Xil_Out32 (XPAR_AXI_GPIO_15_BASEADDR, 0);
//Xil_Out32(XPAR_AXI_GPIO_18_BASEADDR, 1);
ClearBuffers();
PrintData();
}
}
return sw;
}
/**
*
* This function does a minimal test on the UartPS device and driver as a
* design example. The purpose of this function is to illustrate
* how to use the XUartPs driver.
*
* This function sends data and expects to receive the same data through the
* device using the local loopback mode.
*
* This function uses interrupt mode of the device.
*
* @param IntcInstPtr is a pointer to the instance of the Scu Gic driver.
* @param UartInstPtr is a pointer to the instance of the UART driver
* which is going to be connected to the interrupt controller.
* @param DeviceId is the device Id of the UART device and is typically
* XPAR_<UARTPS_instance>_DEVICE_ID value from xparameters.h.
* @param UartIntrId is the interrupt Id and is typically
* XPAR_<UARTPS_instance>_INTR 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 UartPsIntrExample(XScuGic *IntcInstPtr, XUartPs *UartInstPtr,
u16 DeviceId, u16 UartIntrId)
{
int Status;
XUartPs_Config *Config;
int Index;
u32 IntrMask;
int BadByteCount = 0;
/*
* Initialize the UART driver so that it's ready to use
* Look up the configuration in the config table, then initialize it.
*/
Config = XUartPs_LookupConfig(DeviceId);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XUartPs_CfgInitialize(UartInstPtr, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Check hardware build
*/
Status = XUartPs_SelfTest(UartInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the UART to the interrupt subsystem such that interrupts
* can occur. This function is application specific.
*/
Status = SetupInterruptSystem(IntcInstPtr, UartInstPtr, UartIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handlers for the UART that will be called from the
* interrupt context when data has been sent and received, specify
* a pointer to the UART driver instance as the callback reference
* so the handlers are able to access the instance data
*/
XUartPs_SetHandler(UartInstPtr, (XUartPs_Handler)Handler, UartInstPtr);
/*
* Enable the interrupt of the UART so interrupts will occur, setup
* a local loopback so data that is sent will be received.
*/
IntrMask =
XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | XUARTPS_IXR_FRAMING |
XUARTPS_IXR_OVER | XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXFULL |
XUARTPS_IXR_RXOVR;
XUartPs_SetInterruptMask(UartInstPtr, IntrMask);
XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_LOCAL_LOOP);
/*
* Set the receiver timeout. If it is not set, and the last few bytes
* of data do not trigger the over-water or full interrupt, the bytes
* will not be received. By default it is disabled.
*
* The setting of 8 will timeout after 8 x 4 = 32 character times.
* Increase the time out value if baud rate is high, decrease it if
* baud rate is low.
*/
XUartPs_SetRecvTimeout(UartInstPtr, 8);
/*
* Initialize the send buffer bytes with a pattern 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 % 26) + 'A';
RecvBuffer[Index] = 0;
}
/*
* Start receiving data before sending it since there is a loopback,
* ignoring the number of bytes received as the return value since we
* know it will be zero
*/
XUartPs_Recv(UartInstPtr, RecvBuffer, TEST_BUFFER_SIZE);
/*
* Send the buffer using the UART and ignore the number of bytes sent
* as the return value since we are using it in interrupt mode.
*/
XUartPs_Send(UartInstPtr, 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 (1) {
if ((TotalSentCount == TEST_BUFFER_SIZE) &&
(TotalReceivedCount == TEST_BUFFER_SIZE)) {
break;
}
}
/*
* Verify the entire receive buffer was successfully received
*/
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
if (RecvBuffer[Index] != SendBuffer[Index]) {
BadByteCount++;
}
}
/*
* Set the UART in Normal Mode
*/
XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_NORMAL);
/*
* If any bytes were not correct, return an error
*/
if (BadByteCount != 0) {
return XST_FAILURE;
}
return XST_SUCCESS;
}
void Handler(void *CallBackRef, u32 Event, unsigned int EventData)
{
/*
* All of the data has been sent
*/
if (Event == XUARTPS_EVENT_SENT_DATA);
/*
* All of the data has been received
*/
if (Event == XUARTPS_EVENT_RECV_DATA) {
XUartPs_Recv(&Uart_Ps, uartBuffer, UART_BUFFER_SIZE);
//XUartPs_Send(&Uart_Ps, RecvBuffer, TEST_BUFFER_SIZE);
if(uartBuffer[2] == 0x41){//Up Arrow: 1B 5B 41
if(contrast != 8)
contrast++;
}
if(uartBuffer[2] == 0x42){//Down Arrow: 1B 5B 42
if(contrast != 0)
contrast--;
}
if(uartBuffer[2] == 0x43){//Right Arrow: 1B 5B 43
roadPosition++;
}
if(uartBuffer[2] == 0x44){//Left Arrow: 1B 5B 44
roadPosition--;
}
setContrast();
}
/*
* Data was received, but not the expected number of bytes, a
* timeout just indicates the data stopped for 8 character times
*/
if (Event == XUARTPS_EVENT_RECV_TOUT){
XUartPs_Recv(&Uart_Ps, uartBuffer, UART_BUFFER_SIZE);
//Letter characters received are ascii
//w and s used to increase and shrink the size of the road
XUartPs_Send(&Uart_Ps, uartBuffer, 1);
switch(uartBuffer[0]){
case 0x77://w: 0x77
roadSizeRight++;
break;
case 0x73://s: 0x73
roadSizeRight--;
break;
case 0x71://q: 0x71
roadSizeLeft++;
break;
case 0x61://a: 0x61
roadSizeLeft--;
break;
case 0x63://c: 0x63
calibrate = !calibrate;
break;
case 0x74://t: 0x74
if( blanking_position < 15)
blanking_position++;
setThreshold();
break;
case 0x67://g: 0x67
if(blanking_position > 0)
blanking_position--;
setThreshold();
break;
case 0x31://1: 0x31
cross_row = 0;
break;
case 0x32://2: 0x32
start_blink = 1;
break;
case 0x33://3: 0x33
schl_xing_row = 0;
break;
case 0x72://r: 0x72
start_recording = 1;
break;
case 0x70://p 0x70
playback_idx = 0;
break;
case 0x65://e 0x65
if(frameRateSelect < 3)
frameRateSelect++;
framerate = FRAME_RATE_VALS[frameRateSelect];
printf("Framerate: %f", framerate);
break;
case 0x64://d
if(frameRateSelect > 0)
frameRateSelect--;
framerate = FRAME_RATE_VALS[frameRateSelect];
printf("Framerate: %f", framerate);
break;
case 0x79://y
road_vert_pos--;
break;
case 0x68://h
road_vert_pos++;
break;
}
}
/*
* Data was received with an error, keep the data but determine
* what kind of errors occurred
*/
if (Event == XUARTPS_EVENT_RECV_ERROR);
}
/**
*
* This function does a minimal test on the XUartPs device in polled mode.
*
* This function sends data and expects to receive the data thru the UART
* using the local loopback mode.
*
*
* @param DeviceId is the unique device id from hardware build.
*
* @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful
*
* @note
* This function polls the UART, it may hang if the hardware is not
* working correctly.
*
****************************************************************************/
int UartPsPolledExample(u16 DeviceId)
{
int Status;
XUartPs_Config *Config;
unsigned int SentCount;
unsigned int ReceivedCount;
u16 Index;
u32 LoopCount = 0;
/*
* Initialize the UART driver so that it's ready to use.
* Look up the configuration in the config table, then initialize it.
*/
Config = XUartPs_LookupConfig(DeviceId);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XUartPs_CfgInitialize(&Uart_PS, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Check hardware build.
*/
Status = XUartPs_SelfTest(&Uart_PS);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Use local loopback mode.
*/
XUartPs_SetOperMode(&Uart_PS, XUARTPS_OPER_MODE_LOCAL_LOOP);
/*
* Initialize the send buffer bytes with a pattern and zero out
* the receive buffer.
*/
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
SendBuffer[Index] = '0' + Index;
RecvBuffer[Index] = 0;
}
/*
* Block sending the buffer.
*/
SentCount = XUartPs_Send(&Uart_PS, SendBuffer, TEST_BUFFER_SIZE);
if (SentCount != TEST_BUFFER_SIZE) {
return XST_FAILURE;
}
/*
* Wait while the UART is sending the data so that we are guaranteed
* to get the data the 1st time we call receive, otherwise this function
* may enter receive before the data has arrived
*/
while (XUartPs_IsSending(&Uart_PS)) {
LoopCount++;
}
/*
* Block receiving the buffer.
*/
ReceivedCount = 0;
while (ReceivedCount < TEST_BUFFER_SIZE) {
ReceivedCount +=
XUartPs_Recv(&Uart_PS, &RecvBuffer[ReceivedCount],
(TEST_BUFFER_SIZE - ReceivedCount));
}
/*
* Check the receive buffer 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;
}
}
/*
* Restore to normal mode.
*/
XUartPs_SetOperMode(&Uart_PS, XUARTPS_OPER_MODE_NORMAL);
return XST_SUCCESS;
}
int main()
{
int sentCount;
int aliveLed = 0;
int numBytes;
int currentGain;
unsigned char id, prevId;
int sw, i1;
int success;
int pa, prevPa;
static int testBlinkCount;
int txCount = 0, txTryCount = 0, txSuccess;
unsigned char numUartRead, curValue;
unsigned char rxBuf[256], txBuf[256];
init_platform();
if(SetupPeripherals() != XST_SUCCESS)
return -1;
if ( Chilipepper_Initialize() != 0 )
return -1;
// by default we are in receive
Chilipepper_SetPA( 1 );
Chilipepper_SetTxRxSw( 1 ); // 0- transmit, 1-receive
// enable the Chilipepper LED to indicate we are operational
Chilipepper_SetLed( 1 );
xil_printf("\r\n\r\nWelcome to Toyon's Chilipepper QPSK demo. This demo was written in MATLAB using Mathworks HDL Coder.\r\n\r\n");
//Chilipepper_SetRxGain( 20 );
prevPa = 0;
prevId = 0;
//Chilipepper_Reset();
while (1)
{
currentGain = Chilipepper_ControlAgc();
WriteLedGain( currentGain );
pa = XGpio_DiscreteRead(&gpio_sw_tx_pa, 1);
if (pa != prevPa)
Chilipepper_SetTxGain( pa );
prevPa = pa;
sw = XGpio_DiscreteRead(&gpio_sw_test, 1);
switch (sw)
{
case 0: // normal operation
// during normal operation adjust the AGC
// main priority is to parse OTA packets
numBytes = Chilipepper_ReadPacket( rxBuf, &id );
if (numBytes > 0)
XGpio_DiscreteWrite(&gpio_blinky, 1, 1);
// if ID is zero then this is an ACK - should never see this here
// if ID is not zero we need to send a packet back with the payload being the ID
// Here we've received the same packet as last time. This means the sender must not
// have gotten the ACK we sent. So, let's just send the ACK again, but don't write to UART.
if (id != 0 && numBytes > 0 && id == prevId)
{
// received the same packet again so transmitter must not have gotten ACK
Chilipepper_WriteAckPacket( txBuf, id );
XGpio_DiscreteWrite(&gpio_blinky, 1, 0);
}
// This is a normal receive situation. We get a packet, write it to UART, and send ACK
else if ( id != 0 && numBytes > 0)
{
// first thing we need to do if ID is not zero is send back ACK with payload
// being id
Chilipepper_WriteAckPacket( txBuf, id );
sentCount = 0;
while (sentCount < numBytes)
{
curValue = rxBuf[sentCount+4];
sentCount += XUartPs_Send(&uartPs, &curValue, 1);
}
prevId = id;
XGpio_DiscreteWrite(&gpio_blinky, 1, 0);
}
// now that we've gotten the radio stuff out of the way, let's parse things coming over the UART
do
{
numUartRead = XUartPs_Recv(&uartPs, &txBuf[txCount+4], 1);
if (numUartRead == 1)
txCount++;
} while(numUartRead == 1);
// only attempt to send something if we have something to send
if (txCount > 0)
{
XGpio_DiscreteWrite(&gpio_blinky, 1, 1);
if (txCount >= 10 || txTryCount > 100000)
{
txSuccess = Chilipepper_WritePacketWithAck( txBuf, txCount, rxBuf );
if (txSuccess == 1)
{
XGpio_DiscreteWrite(&gpio_blinky, 1, 0);
}
txCount = 0;
txTryCount = 0;
}
}
txTryCount++;
// flip the LED1 so the user knows the processor is alive
testBlinkCount += 1;
if (testBlinkCount > 100000)
{
if (aliveLed == 0)
aliveLed = 1;
else
aliveLed = 0;
testBlinkCount = 1;
XGpio_DiscreteWrite(&gpio_blinky, 2, aliveLed);
}
break;
case 1: // continuously send out packets
// do it once and then stall for a bit
for (i1=0; i1<5000; i1++)
{
if (i1 == 0)
{
XGpio_DiscreteWrite(&gpio_blinky, 1, 1);
Chilipepper_WriteTestPacket( 1 );
XGpio_DiscreteWrite(&gpio_blinky, 1, 0);
}
}
// flip the LED1 so the user knows the processor is alive
testBlinkCount += 1;
if (testBlinkCount > 2000)
{
if (aliveLed == 0)
aliveLed = 1;
else
aliveLed = 0;
testBlinkCount = 1;
XGpio_DiscreteWrite(&gpio_blinky, 2, aliveLed);
}
break;
case 2: // initiate packet transmission with a button press
// flip the LED1 so the user knows the processor is alive
testBlinkCount += 1;
if (testBlinkCount > 200000)
{
if (aliveLed == 0)
aliveLed = 1;
else
aliveLed = 0;
testBlinkCount = 1;
XGpio_DiscreteWrite(&gpio_blinky, 2, aliveLed);
}
if (DebouncButton() == 0)
break;
XGpio_DiscreteWrite(&gpio_blinky, 1, 1);
success = Chilipepper_WriteTestPacketWithAck( rxBuf );
if (success == 1)
XGpio_DiscreteWrite(&gpio_blinky, 1, 0);
else
{
Chilipepper_Reset();
}
break;
default:
break;
}
}
cleanup_platform();
return 0;
}
/**
*
* This function runs a self-test on the driver and hardware device. This self
* test performs a local loopback and verifies data can be sent and received.
*
* The time for this test is proportional to the baud rate that has been set
* prior to calling this function.
*
* The mode and control registers are restored before return.
*
* @param InstancePtr is a pointer to the XUartPs instance
*
* @return
* - XST_SUCCESS if the test was successful
* - XST_UART_TEST_FAIL if the test failed looping back the data
*
* @note
*
* This function can hang if the hardware is not functioning properly.
*
******************************************************************************/
s32 XUartPs_SelfTest(XUartPs *InstancePtr)
{
s32 Status = XST_SUCCESS;
u32 IntrRegister;
u32 ModeRegister;
u8 Index;
u32 ReceiveDataResult;
/*
* Assert validates the input arguments
*/
Xil_AssertNonvoid(InstancePtr != NULL);
Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
/*
* Disable all interrupts in the interrupt disable register
*/
IntrRegister = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
XUARTPS_IMR_OFFSET);
XUartPs_WriteReg(InstancePtr->Config.BaseAddress, XUARTPS_IDR_OFFSET,
XUARTPS_IXR_MASK);
/*
* Setup for local loopback
*/
ModeRegister = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
XUARTPS_MR_OFFSET);
XUartPs_WriteReg(InstancePtr->Config.BaseAddress, XUARTPS_MR_OFFSET,
((ModeRegister & (u32)(~XUARTPS_MR_CHMODE_MASK)) |
(u32)XUARTPS_MR_CHMODE_L_LOOP));
/*
* Send a number of bytes and receive them, one at a time.
*/
for (Index = 0U; Index < XUARTPS_TOTAL_BYTES; Index++) {
/*
* Send out the byte and if it was not sent then the failure
* will be caught in the comparison at the end
*/
(void)XUartPs_Send(InstancePtr, &TestString[Index], 1U);
/*
* Wait until the byte is received. This can hang if the HW
* is broken. Watch for the FIFO empty flag to be false.
*/
ReceiveDataResult = Xil_In32((InstancePtr->Config.BaseAddress) + XUARTPS_SR_OFFSET) &
XUARTPS_SR_RXEMPTY;
while (ReceiveDataResult == XUARTPS_SR_RXEMPTY ) {
ReceiveDataResult = Xil_In32((InstancePtr->Config.BaseAddress) + XUARTPS_SR_OFFSET) &
XUARTPS_SR_RXEMPTY;
}
/*
* Receive the byte
*/
(void)XUartPs_Recv(InstancePtr, &ReturnString[Index], 1U);
}
/*
* Compare the bytes received to the bytes sent to verify the exact data
* was received
*/
for (Index = 0U; Index < XUARTPS_TOTAL_BYTES; Index++) {
if (TestString[Index] != ReturnString[Index]) {
Status = XST_UART_TEST_FAIL;
}
}
/*
* Restore the registers which were altered to put into polling and
* loopback modes so that this test is not destructive
*/
XUartPs_WriteReg(InstancePtr->Config.BaseAddress, XUARTPS_IER_OFFSET,
IntrRegister);
XUartPs_WriteReg(InstancePtr->Config.BaseAddress, XUARTPS_MR_OFFSET,
ModeRegister);
return Status;
}
