使用STM32F407 HAL库串口2通讯，如果同时收发频繁导致不能接受数据。不知道在这种情况是什么原因，需要注意哪》？
/* 私有类型定义 --------------------------------------------------------------*/
/* 私有宏定义 ----------------------------------------------------------------*/
/* 私有变量 ------------------------------------------------------------------*/
//UART_HandleTypeDef husartx;
__IO uint8_t g_arrUart2RecvBuf[USART2_RECV_SIZE];
__IO uint8_t g_arrUart2SendBuf[USART2_SEND_SIZE];
volatile uint8_t g_nSendStatus_SP2 = 0;
#if 1
#pragma import(__use_no_semihosting)            
//标准库需要的支持函数                 
struct __FILE
{
int handle;
};
FILE __stdout;      
//定义_sys_exit()以避免使用半主机模式   
void _sys_exit(int x)
{
x = x;
}
//重定义fputc函数
int fputc(int ch, FILE *f)
{  
while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
USART2->DR = (u8) ch;      
return ch;
}
#endif

u8 aRxBuffer[RXBUFFERSIZE];//HAL库使用的串口接收缓冲
UART_HandleTypeDef UART2_Handler; //UART句柄
//初始化IO 串口1
//bound:波特率
void uart2_init(u32 bound)
{
//UART 初始化设置
UART2_Handler.Instance=USART2;         //USART1
UART2_Handler.Init.BaudRate=bound;        //波特率
UART2_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //字长为8位数据格式
UART2_Handler.Init.StopBits=UART_STOPBITS_1;     //一个停止位
UART2_Handler.Init.Parity=UART_PARITY_NONE;      //无奇偶校验位
UART2_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //无硬件流控
UART2_Handler.Init.Mode=UART_MODE_TX_RX;      //收发模式
HAL_UART_Init(&UART2_Handler);         //HAL_UART_Init()会使能UART1


// husartx2.Instance = USARTx2;
// husartx2.Init.BaudRate = USARTx2_BAUDRATE;
// husartx2.Init.WordLength = UART_WORDLENGTH_8B;
// husartx2.Init.StopBits = UART_STOPBITS_1;
// husartx2.Init.Parity = UART_PARITY_NONE;
// husartx2.Init.Mode = UART_MODE_TX_RX;
// husartx2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
// husartx2.Init.OverSampling = UART_OVERSAMPLING_16;
// HAL_UART_Init(&husartx2);

HAL_UART_Receive_IT(&UART2_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
  
}
//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄
void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
    //GPIO端口设置
GPIO_InitTypeDef GPIO_Initure;

if(huart->Instance==USART2)//如果是串口1，进行串口1 MSP初始化
{
  __HAL_RCC_GPIOD_CLK_ENABLE();   //使能GPIOA时钟
  __HAL_RCC_USART2_CLK_ENABLE();   //使能USART1时钟
  
    GPIO_Initure.Pin =  USARTx_Tx_GPIO_PIN;
    GPIO_Initure.Mode = GPIO_MODE_AF_PP;
    GPIO_Initure.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_Initure.Alternate = USARTx_AFx;
    HAL_GPIO_Init(GPIOD, &GPIO_Initure);
    GPIO_Initure.Pin =  USARTx_Rx_GPIO_PIN;
    GPIO_Initure.Mode = GPIO_MODE_AF_PP;
    GPIO_Initure.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_Initure.Alternate = USARTx_AFx;
    HAL_GPIO_Init( GPIOD, &GPIO_Initure);
  
  HAL_NVIC_EnableIRQ(USART2_IRQn);    //使能USART1中断通道
  HAL_NVIC_SetPriority(USART2_IRQn,3,3);   //抢占优先级3，子优先级3
}
}
static uint16_t m_nUsart2RecvCount=0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance==USART2)//如果是串口1
{
  if(m_nUsart2RecvCount>= USART2_RECV_SIZE)
  {
   m_nUsart2RecvCount=0;
  }
  g_arrUart2RecvBuf[m_nUsart2RecvCount] = aRxBuffer[0] ;
  m_nUsart2RecvCount++;
  
  //do  
  //{  
   //   ret = HAL_UART_Receive_IT(&husartx,&aRxBuffer,1);;            
  //}while(ret != HAL_OK);
  // HAL_UART_Receive_IT(&husartx,aRxBuffer,1);

}
}

//串口1中断服务程序
void USART2_IRQHandler(void)                 
{
u32 timeout=0;

HAL_UART_IRQHandler(&UART2_Handler); //调用HAL库中断处理公用函数

timeout=0;
    while (HAL_UART_GetState(&UART2_Handler) != HAL_UART_STATE_READY)//等待就绪
{
  timeout++;////超时处理
     if(timeout>HAL_MAX_DELAY) break;  

}
     
timeout=0;
while(HAL_UART_Receive_IT(&UART2_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
{
  timeout++; //超时处理
  if(timeout>HAL_MAX_DELAY) break;
}
}

void UART2_PushRecvDataLen(uint16_t n)
{
  m_nUsart2RecvCount=n;
}
uint16_t UART2_GetRecvDataLen(void)
{
return m_nUsart2RecvCount;
}
void UART2_ClcRecvDataLen(void)
{
m_nUsart2RecvCount=0;
}
//发送单字节
void SP2_SendByteInfoProc(u8 nSendInfo)
{
volatile BYTE* pBuf = NULL;
g_nSendStatus_SP2 = 0;
//指向发送缓冲区
pBuf = g_arrUart2SendBuf;
//
*pBuf++ = nSendInfo;
//
HAL_UART_Transmit(&UART2_Handler,&nSendInfo,1,100);
}
void SP2_SendBytesInfoProc(uint8_t* pSendInfo, u16 nSendCount)
{
u16 i = 0;
volatile BYTE* pBuf = NULL;
g_nSendStatus_SP2 = 0;

//指向发送缓冲区
pBuf = g_arrUart2SendBuf;
//
for (i=0; i<nSendCount; i++)
{
  //
  *pBuf++ = pSendInfo[i];
  //HAL_UART_Transmit(&husartx,&pSendInfo[i],1,100);
}

//
HAL_UART_Transmit(&UART2_Handler,pSendInfo,nSendCount,100);
}