ZYNQ裸板：串口篇

#ifndef SRC_USER_UART_H_
#define SRC_USER_UART_H_
#include "xparameters.h"
#include "xuartps.h"
#include "xil_printf.h"
#include "sleep.h"
#define UART_DEVICE_ID                  XPAR_XUARTPS_0_DEVICE_ID
int Uart_Send(XUartPs* Uart_Ps, u8 *sendbuf, int length);
int Uart_Init(XUartPs* Uart_Ps, u16 DeviceId);
#endif /* SRC_USER_UART_H_ */

#include "user_uart.h"
// UART格式
XUartPsFormat uart_format =
{
  9600,
  //XUARTPS_DFT_BAUDRATE,   //默认波特率 115200
  XUARTPS_FORMAT_8_BITS,
  XUARTPS_FORMAT_NO_PARITY,
  XUARTPS_FORMAT_1_STOP_BIT,
};
//--------------------------------------------------------------
//                     UART初始化函数
//--------------------------------------------------------------
int Uart_Init(XUartPs* Uart_Ps, u16 DeviceId)
{
  int Status;
  XUartPs_Config *Config;
  /*  初始化UART设备    */
  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;
  }
  /*  UART设备自检  */
  Status = XUartPs_SelfTest(Uart_Ps);
  if (Status != XST_SUCCESS) {
  return XST_FAILURE;
  }
  /*  设置UART模式与参数   */
  XUartPs_SetOperMode(Uart_Ps, XUARTPS_OPER_MODE_NORMAL); //正常模式
  XUartPs_SetDataFormat(Uart_Ps, &uart_format);    //设置UART格式
  return XST_SUCCESS;
}
//--------------------------------------------------------------
//                     UART数据发送函数
//--------------------------------------------------------------
int Uart_Send(XUartPs* Uart_Ps, u8 *sendbuf, int length)
{
  int SentCount = 0;
  while (SentCount < length) {
  SentCount += XUartPs_Send(Uart_Ps, &sendbuf[SentCount], 1);
  }
  return SentCount;
}

#include "user_uart.h"
XUartPs Uart_Ps;  /* The instance of the UART Driver */
int main(void)
{
  int Status;
  u8 sendbuf[] = "Hello World!\r\n";
  /* 串口初始化 */
  Status = Uart_Init(&Uart_Ps, UART_DEVICE_ID);
  if (Status == XST_FAILURE) {
  xil_printf("Uartps Failed\r\n");
  return XST_FAILURE;
  }
  while (1)
  {
  sleep(1);
  Uart_Send(&Uart_Ps, sendbuf, 14);
  }
  return Status;
}

s32 XUartPs_SelfTest(XUartPs *InstancePtr)
这个函数执行一次本地回环，验证可以正常发送和接受数据。返回XST_UART_TEST_FAIL表示测试失败；XST_SUCCESS表示测试成功。我们可以用这个函数检查硬件工作是否正常。

void XUartPs_SetOperMode(XUartPs *InstancePtr, u8 OperationMode)

s32 XUartPs_SetDataFormat(XUartPs *InstancePtr, XUartPsFormat * FormatPtr)

s32 XUartPs_SetBaudRate(XUartPs *InstancePtr, u32 BaudRate)

#define XUARTPS_MAX_BAUD_ERROR_RATE   3U  /* max % error allowed */

typedef struct {
  u32 BaudRate; /**< In bps, ie 1200 */
  u32 DataBits; /**< Number of data bits */
  u32 Parity;  /**< Parity */
  u8 StopBits;  /**< Number of stop bits */
} XUartPsFormat;

u32 XUartPs_Send(XUartPs *InstancePtr, u8 *BufferPtr, u32 NumBytes)

#ifndef SRC_USER_UART_H_
#define SRC_USER_UART_H_
#include "xparameters.h"
#include "xuartps.h"
#include "xil_printf.h"
#include "sleep.h"
#include "xscugic.h"
#define UART_DEVICE_ID     XPAR_PS7_UART_1_DEVICE_ID //设备ID
#define UART_INT_IRQ_ID    XPAR_XUARTPS_1_INTR  //中断号
#define BUFFER_SIZE 8
int Uart_Send(XUartPs* Uart_Ps, u8 *RecvBuffer, int length);
int Uart_Init(XUartPs* Uart_Ps, u16 DeviceId);
void Uart_Intr_System(XScuGic *Intc, XUartPs *Uart_Ps, u16 UartIntrId);
void Handler(void *CallBackRef);
#endif /* SRC_USER_UART_H_ */

#include "user_uart.h"
static u8 RecvBuffer[BUFFER_SIZE];
u8 *RecvBufferPtr;
volatile u32 TotalRecvCnt;
XUartPsFormat uart_format =
{
  //9600,
  XUARTPS_DFT_BAUDRATE,   //默认波特率 115200
  XUARTPS_FORMAT_8_BITS,
  XUARTPS_FORMAT_NO_PARITY,
  XUARTPS_FORMAT_1_STOP_BIT,
};
//--------------------------------------------------------------
//                     UART初始化函数
//--------------------------------------------------------------
int Uart_Init(XUartPs* Uart_Ps, u16 DeviceId)
{
  int Status;
  XUartPs_Config *Config;
  /*  数据初始化  */
  RecvBufferPtr = RecvBuffer;
  TotalRecvCnt = 0;
  /*  初始化UART设备    */
  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;
  }
  /*  UART设备自检  */
  Status = XUartPs_SelfTest(Uart_Ps);
  if (Status != XST_SUCCESS) {
  return XST_FAILURE;
  }
  /*  设置UART模式与参数   */
  XUartPs_SetOperMode(Uart_Ps, XUARTPS_OPER_MODE_NORMAL); //正常模式
  XUartPs_SetDataFormat(Uart_Ps, &uart_format);    //设置UART格式
  XUartPs_SetFifoThreshold(Uart_Ps, 8);  //设置RxFIFO的中断触发等级
  return XST_SUCCESS;
}
//--------------------------------------------------------------
//                  UART中断系统初始化函数
//--------------------------------------------------------------
void Uart_Intr_System(XScuGic *Intc, XUartPs *Uart_Ps, u16 UartIntrId)
{
  XScuGic_Connect(Intc, UartIntrId,
    (Xil_ExceptionHandler) Handler,
    (void *) Uart_Ps);
  XScuGic_Enable(Intc, UartIntrId);
  // 设置UART的中断触发方式
  XUartPs_SetInterruptMask(Uart_Ps, XUARTPS_IXR_RXOVR);
}
//--------------------------------------------------------------
//                     UART中断处理函数
//--------------------------------------------------------------
void Handler(void *CallBackRef)
{
  XUartPs *UartInstancePtr = (XUartPs *) CallBackRef ;
  u32 ReceivedCount = 0 ;
  u32 IsrStatus ;
  //读取中断ID寄存器，判断触发的是哪种中断
  IsrStatus = XUartPs_ReadReg(UartInstancePtr->Config.BaseAddress,
       XUARTPS_IMR_OFFSET);
  IsrStatus &= XUartPs_ReadReg(UartInstancePtr->Config.BaseAddress,
       XUARTPS_ISR_OFFSET);
  if (IsrStatus & (u32)XUARTPS_IXR_RXOVR)   /* 检查RxFIFO是否触发 */
  {
  ReceivedCount = XUartPs_Recv(UartInstancePtr, RecvBufferPtr, (BUFFER_SIZE-TotalRecvCnt)) ;
  TotalRecvCnt += ReceivedCount ;
  RecvBufferPtr += ReceivedCount ;
  /* 清除中断标志 */
  XUartPs_WriteReg(UartInstancePtr->Config.BaseAddress, XUARTPS_ISR_OFFSET, XUARTPS_IXR_RXOVR) ;
  }
  xil_printf("Enter INTR\r\n");
  /* 数据处理 */
  if (TotalRecvCnt >= BUFFER_SIZE) {
  xil_printf("%s", RecvBuffer);
  xil_printf("\r\nI have received %d bytes.\r\n", TotalRecvCnt);
  RecvBufferPtr = RecvBuffer;
  TotalRecvCnt = 0;
  }
}

#include "sys_intr.h"
#include "user_uart.h"
XScuGic Intc;       //GIC
XUartPs Uart_Ps;  //UART
void System_Init(void)
{
  Init_Intr_System(&Intc);
  Setup_Intr_Exception(&Intc);
  Uart_Intr_System(&Intc, &Uart_Ps, UART_INT_IRQ_ID);
}
int main(void)
{
  int Status;
  /* 串口初始化 */
  Status = Uart_Init(&Uart_Ps, UART_DEVICE_ID);
  if (Status == XST_FAILURE) {
  xil_printf("Uartps Failed\r\n");
  return XST_FAILURE;
  }
  System_Init();   //中断初始化
  while (1){
  sleep(1);
  xil_printf("Hello World!\r\n");
  }
  return Status;
}

#ifndef SRC_UART_DRIVER_H_
#define SRC_UART_DRIVER_H_
#include "xparameters.h"
#include "xuartns550.h"
#include "xil_exception.h"
#ifdef XPAR_INTC_0_DEVICE_ID
#include "xintc.h"
#include <stdio.h>
#else
#include "xscugic.h"
#include "xil_printf.h"
#include "xbasic_types.h"
#include "lib_fifo.h"
#include "Uart_driver.h"
#endif
XUartNs550 UartNs550;
#define FIFO_SIZE 512
FIFO Uart0FIFO; /* **参考万能的FIFO篇**，非常方便的帮助处理收到的大量数据；但是相应的也会牺牲部分效率在数据不是特别大串口不是特别多的时候建议使用，过多可能完全一样的复制10个串口就有一个莫名奇妙出bug */
u8 RecvBuffer[12][FIFO_SIZE]; /* Buffer for Receiving Data */
#ifndef TESTAPP_GEN
#ifdef XPAR_INTC_0_DEVICE_ID
#define INTC_DEVICE_ID  XPAR_INTC_0_DEVICE_ID
#else
#define INTC_DEVICE_ID  XPAR_SCUGIC_SINGLE_DEVICE_ID
#endif /* XPAR_INTC_0_DEVICE_ID */
#endif /* TESTAPP_GEN */
/***************** Type Definitions *********************/
#ifdef XPAR_INTC_0_DEVICE_ID
#define INTC  XIntc
#define INTC_HANDLER  XIntc_InterruptHandler
#else
#define INTC  XScuGic
#define INTC_HANDLER  XScuGic_InterruptHandler
#endif /* XPAR_INTC_0_DEVICE_ID */
#ifndef TESTAPP_GEN
INTC IntcInstance0;  /* Instance of the Interrupt Controller */
XUartNs550 Uart0Ns550Instance;  /* Instance of the UART Device */
//先例化一个吧
#endif
/*
 * The following buffers are used in this example to send and receive data
 * with the UART.
 */
u8 SendBuffer[FIFO_SIZE]; /* Buffer for Transmitting Data */
/*
 * The following counters are used to determine when the entire buffer has
 * been sent and received.
 */
#ifndef TESTAPP_GEN
#endif
/************************************/
/***** Function Prototypes ************/
int UartNs550Init(INTC *IntcInstancePtr,
    XUartNs550 *UartInstancePtr,
    u16 UartDeviceId,
    u16 UartIntrId);
void Uart0Ns550IntrHandler(void *CallBackRef, u32 Event, unsigned int EventData);
static int UartNs550SetupIntrSystem(INTC *IntcInstancePtr,
    XUartNs550 *UartInstancePtr,
    u16 UartIntrId);
static void UartNs550DisableIntrSystem(INTC *IntcInstancePtr, u16 UartIntrId);
/* 还需要多少复制粘贴吧 */
#endif /* SRC_UART_DRIVER_H_ */

#include "Uart_driver.h"
u8 SendBuffer[FIFO_SIZE]; /* Buffer for Transmitting Data */
/*
 * The following counters are used to determine when the entire buffer has
 * been sent and received.
 */
//static volatile int TotalReceivedCount;
 int TotalReceivedCount;
static volatile int TotalSentCount;
static volatile int TotalErrorCount;
#ifndef TESTAPP_GEN
#endif
/*****************************************************************************/
/**
*
* This function does a minimal test on the UartNs550 device and driver as a
* design example. The purpose of this function is to illustrate how to use the
* XUartNs550 component.
*
* This function transmits data and expects to receive the same data through the
* UART using the local loopback of the hardware.
*
* This function uses interrupt driver mode of the UART.
*
* @param  IntcInstancePtr is a pointer to the instance of the
*  Interrupt Controller.
* @param  UartInstancePtr is a pointer to the instance of the UART .
* @param  UartDeviceId is the device Id and is typically
*  XPAR_<UARTNS550_instance>_DEVICE_ID value from  xparameters.h.
* @param  UartIntrId is the interrupt Id and is typically
*  XPAR_<INTC_instance>_<UARTNS550_instance>_IP2INTC_IRPT_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 UartNs550Init(INTC *IntcInstancePtr,
    XUartNs550 *UartInstancePtr,
    u16 UartDeviceId,
    u16 UartIntrId)
{
  int Status;
  u32 Index;
  u16 Options;
  u32 BadByteCount = 0;
  XUartNs550_Handler CB;
  /*
  * Initialize the UART driver so that it's ready to use.
  */
  Status = XUartNs550_Initialize(UartInstancePtr, UartDeviceId);
  if (Status != XST_SUCCESS) {
  return XST_FAILURE;
  }
  /*
  * Perform a self-test to ensure that the hardware was built correctly.
  */
  /*Status = XUartNs550_SelfTest(UartInstancePtr);
  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 = UartNs550SetupIntrSystem(IntcInstancePtr,
      UartInstancePtr,
      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.
  */
  switch(UartDeviceId)
  {
  case XPAR_UARTNS550_0_DEVICE_ID:
  CB = Uart0Ns550IntrHandler;
  break;
  default:
  break;
  }
  XUartNs550_SetHandler(UartInstancePtr, CB,
      UartInstancePtr);
  /*
  * Enable the interrupt of the UART so interrupts will occur, setup
  * a local loopback so data that is sent will be received, and keep the
  * FIFOs enabled.
  */
  Options = XUN_OPTION_DATA_INTR | //得把例程的回环屏蔽XUN_OPTION_LOOPBACK |
    XUN_OPTION_FIFOS_ENABLE;
  XUartNs550_SetOptions(UartInstancePtr, Options);
  /*
  * 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 + '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 and we are using interrupt mode.
  */
  // XUartNs550_Recv(UartInstancePtr, 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.
  */
  // XUartNs550_Send(UartInstancePtr, 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 (RecvBuffer[Index] != SendBuffer[Index]) {
//    BadByteCount++;
//  }
//  }
  /*
  * Disable the UartNs550 interrupt.
  */
  //UartNs550DisableIntrSystem(IntcInstancePtr, UartIntrId);
  /*
  * If any bytes were not correct, return an error.
  */
//  if (BadByteCount != 0) {
//  return XST_FAILURE;
//  }
//
//  /* Clear the counters */
//  TotalErrorCount = 0;
//  TotalReceivedCount = 0;
//  TotalSentCount = 0;
//
return XST_SUCCESS;
}
/*****************************************************************************/
/**
*
* This function is the handler which performs processing to handle data events
* from the UartNs550.  It is called from an interrupt context such that the
* amount of processing performed should be minimized.
*
* This handler provides an example of how to handle data for the UART and
* is application specific.
*
* @param  CallBackRef contains a callback reference from the driver,
*  in thiscase it is the instance pointer for the UART 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 Uart0Ns550IntrHandler(void *CallBackRef, u32 Event, unsigned int EventData)
{
  u8 Errors;
  XUartNs550 *UartNs550Ptr = (XUartNs550 *)CallBackRef;
    u8 recData[256];
  /*
  * All of the data has been sent.
  */
  if (Event == XUN_EVENT_SENT_DATA) {
  TotalSentCount = EventData;
  }
  /*
  * All of the data has been received.
  */
  if (Event == XUN_EVENT_RECV_DATA)
  {
  TotalReceivedCount = EventData;
  //xil_printf("d-\r\n");
  ///XUartNs550_Recv(&Uart0Ns550Instance, recData, 10);
  //FifoWrite(&Uart0FIFO,recData,10);
  }
  /*
  * Data was received, but not the expected number of bytes, a
  * timeout just indicates the data stopped for 4 character times.
  */
  if (Event == XUN_EVENT_RECV_TIMEOUT) {
  TotalReceivedCount = EventData;
  //xil_printf("c-\r\n");
  }
  /*
  * Data was received with an error, keep the data but determine
  * what kind of errors occurred.
  */
  if (Event == XUN_EVENT_RECV_ERROR) {
  TotalReceivedCount = EventData;
  TotalErrorCount++;
  Errors = XUartNs550_GetLastErrors(UartNs550Ptr);
  //xil_printf("c1-\r\n");
  }
  //xil_printf("TotalReceivedCount=%d\r\n",TotalReceivedCount);
  //xil_printf("TotalErrorCount=%d\r\n",TotalErrorCount);
}
/*****************************************************************************/
/**
*
* This function is the handler which performs processing to handle data events
* from the UartNs550.  It is called from an interrupt context such that the
* amount of processing performed should be minimized.
*
* This handler provides an example of how to handle data for the UART and
* is application specific.
*
* @param  CallBackRef contains a callback reference from the driver,
*  in thiscase it is the instance pointer for the UART 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.
*
*******************************************************************************/
/******************************************************************************/
/**
*
* This function setups the interrupt system such that interrupts can occur
* for the UART.  This function is application specific since the actual
* system may or may not have an interrupt controller.  The UART could be
* directly connected to a processor without an interrupt controller.  The
* user should modify this function to fit the application.
*
* @param  IntcInstancePtr is a pointer to the instance of the Interrupt
*  Controller.
* @param  UartInstancePtr is a pointer to the instance of the UART.
* @param  UartIntrId is the interrupt Id and is typically
*  XPAR_<INTC_instance>_<UARTNS550_instance>_VEC_ID value from
*  xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note  None.
*
*******************************************************************************/
static int UartNs550SetupIntrSystem(INTC *IntcInstancePtr,
      XUartNs550 *UartInstancePtr,
      u16 UartIntrId)
{
  int Status;
#else
#ifndef TESTAPP_GEN
  XScuGic_Config *IntcConfig;
  /*
  * Initialize the interrupt controller driver so that it is ready to
  * use.
  */
  IntcConfig = XScuGic_LookupConfig(INTC_DEVICE_ID);
  if (NULL == IntcConfig) {
  return XST_FAILURE;
  }
  Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
      IntcConfig->CpuBaseAddress);
  if (Status != XST_SUCCESS) {
  return XST_FAILURE;
  }
#endif /* TESTAPP_GEN */
  XScuGic_SetPriorityTriggerType(IntcInstancePtr, UartIntrId,
      0xA0, 0x3);
  /*
  * Connect the interrupt handler that will be called when an
  * interrupt occurs for the device.
  */
  Status = XScuGic_Connect(IntcInstancePtr, UartIntrId,
     (Xil_ExceptionHandler)XUartNs550_InterruptHandler,
     UartInstancePtr);
  if (Status != XST_SUCCESS) {
  return Status;
  }
  /*
  * Enable the interrupt for the Timer device.
  */
  XScuGic_Enable(IntcInstancePtr, UartIntrId);
#endif /* XPAR_INTC_0_DEVICE_ID */
#ifndef TESTAPP_GEN
  /*
  * Initialize the exception table.
  */
  Xil_ExceptionInit();
  /*
  * Register the interrupt controller handler with the exception table.
  */
  Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
    (Xil_ExceptionHandler)INTC_HANDLER,
    IntcInstancePtr);
  /*
  * Enable exceptions.
  */
  Xil_ExceptionEnable();
#endif /* TESTAPP_GEN */
  return XST_SUCCESS;
}
static void UartNs550DisableIntrSystem(INTC *IntcInstancePtr, u16 UartIntrId)
{
  /*
  * Disconnect and disable the interrupt for the UartNs550 device.
  */
#ifdef XPAR_INTC_0_DEVICE_ID
  XIntc_Disconnect(IntcInstancePtr, UartIntrId);
#else
  XScuGic_Disable(IntcInstancePtr, UartIntrId);
  XScuGic_Disconnect(IntcInstancePtr, UartIntrId);
#endif
}

void Uart_demo()
{
  int i,Status;
  u8 sendbuf[] = "HelloWorld";
  u8 recvbuf[FIFO_SIZE] = {};
//多余的自己复制粘贴吧  
  FifoInit(&Uart0FIFO,&RecvBuffer[0],FIFO_SIZE);
//多余的自己复制粘贴吧  /*
  * Run the UartNs550 Interrupt example.
  */
  Status = UartNs550Init(&IntcInstance0,
      &Uart0Ns550Instance,
      XPAR_UARTNS550_0_DEVICE_ID,
      XPAR_FABRIC_AXI_UART16550_0_IP2INTC_IRPT_INTR);
  XUartNs550_SetBaudRate(&Uart0Ns550Instance,115200); //多余的自己复制粘贴吧，这可是个好东西，可以单独设置波特率，不然就是默认的了，默认的也可以直接填
  if (Status != XST_SUCCESS)
  {
  xil_printf("Uartns550 0 interrupt Example Failed\r\n");
  return XST_FAILURE;
  }
  //多余的自己复制粘贴吧  
  //XUartNs550_Send(&UartNs550Instance, sendbuf, 14);
  //XUartNs550_Recv(&UartNs550Instance, recvbuf, TEST_BUFFER_SIZE);
  //XUartNs550_Recv(&UartNs550Instance, recvbuf, 8);
  //XUartNs550_Recv(&Uart0Ns550Instance, recvbuf, 1);
  XUartNs550_Recv(&Uart0Ns550Instance, recvbuf, 256);
  //多余的自己复制粘贴吧  
  while(1)
  {
  sleep(1);
  //FifoRead(&Uart0FIFO,recvbuf,40);
//因为不知名bug原因暂时屏蔽掉，多余的自己复制粘贴吧    //XUartNs550_ReadReg(XPAR_UARTNS550_0_BASEADDR,0x1000);
     XUartNs550_Send(&Uart0Ns550Instance, sendbuf, 10);
    //多余的自己复制粘贴吧  
  if(TotalReceivedCount > 0)
  {
    XUartNs550_Recv(&Uart0Ns550Instance, recvbuf, 256);
    //多余的自己复制粘贴吧    //FifoWrite(&Uart0FIFO,recvbuf,256);
    TotalReceivedCount = 0;
  }
  for(int i=0; i < 20; i++)
    {xil_printf("%c ",recvbuf[i]);}
     xil_printf("\r\n");
  //多余的自己复制粘贴吧  
        xil_printf("\n\r");
  for(int i=0; i < 20; i++)
//    {xil_printf("%c ",recvbuf11[i]);}
//    xil_printf("\n\r");
  memset(recvbuf,0,256);
//多余的自己复制粘贴吧  
  }
}