如果我的数据不是定长的，我该如何来接收这些数据呢？

1、需求
1、收到数据，放入缓存
2、取出数据进行协议解析


2、问题
HAL库的接收函数，指定接收固定数长的数据。


//中断方式接收
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
//非中断方式接收
HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);


按照常规思维，我们会有以下几个问题。
1、是不是一直要在主循环里面去调用这个函数，以免漏掉数据。
2、如果我的数据不是定长的，我该如何来接收这些数据呢？


3、解决
3.1、以前的解决方法
放在以前呢，我们是重写了HAL库的中断接收函数，直接在里面对DR寄存器进行操作，然后放在自己的缓冲区，相当于回到了以前非HAL库的那种操作方式。这种解决方式并没有什么不好，甚至会提升代码运行效率。但是这种方式，HAL库的优势并没有发挥出来，程序的一致性也没有得到体现。甚至在每一次cubeMX重新生成代码后，还需要手动去修改中断函数。
下面是以前我们团队大牛重写的中断接收函数。


/**
  * @brief         void Uart_Fifo_IRQHandler(UART_HandleTypeDef *huart)
        * @auther MSA
        * @param         UART_HandleTypeDef *huart
       
        * @note                 使用Uart_Fifo时的中断处理函数
        * @note                注意参考hal库HAL_UART_IRQHandler函数中关于错误标志的处理
  */
uint8_t uc_ore_cnt = 0;  //test
void Uart_Fifo_IRQHandler(UART_FIFO_Typedef *st_uart_fifo_tx_p, UART_FIFO_Typedef *st_uart_fifo_rx_p)
{
        //错误处理,
        //errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE));
        //以上错误标志中ORE和FE在EIE使能的时候会产生中断,不清楚会一直进入中断
        //错误中断标志使能位是EIE,不知道hal库的初始化是否会使能该中断,应该不会
  
  //RXNE中断或者EIE中断使能后,ORE中断自动使能
  if( (__HAL_UART_GET_IT(st_uart_fifo_tx_p->st_uart_handle_p, UART_IT_ORE) != RESET)&&
      ((__HAL_UART_GET_IT_SOURCE(st_uart_fifo_tx_p->st_uart_handle_p, UART_IT_RXNE) != RESET)||(__HAL_UART_GET_IT_SOURCE(st_uart_fifo_tx_p->st_uart_handle_p, UART_IT_ERR) != RESET))
    )
  {
    uc_ore_cnt++;
    __HAL_UART_CLEAR_IT(st_uart_fifo_tx_p->st_uart_handle_p, UART_CLEAR_OREF);
  }
       
        //发送中断的处理
        if((__HAL_UART_GET_IT(st_uart_fifo_tx_p->st_uart_handle_p, UART_IT_TXE) != RESET) && (__HAL_UART_GET_IT_SOURCE(st_uart_fifo_tx_p->st_uart_handle_p, UART_IT_TXE) != RESET))
   {     
                  if(st_uart_fifo_tx_p->uw_fifo_cnt)
                  {
                                 --(st_uart_fifo_tx_p->uw_fifo_cnt);
                                st_uart_fifo_tx_p->st_uart_handle_p->Instance->TDR = *(st_uart_fifo_tx_p->uc_fifo_addr_p + st_uart_fifo_tx_p->uw_fifo_read_index);               
                                 if(++(st_uart_fifo_tx_p->uw_fifo_read_index) >= st_uart_fifo_tx_p->uw_fifo_size)
                                {
                                     st_uart_fifo_tx_p->uw_fifo_read_index = 0;
                                }
                  }
                       
                        if(st_uart_fifo_tx_p->uw_fifo_cnt == 0)
                        {
                                /* Disable the UART Transmit Data Register Empty Interrupt */
                                __HAL_UART_DISABLE_IT(st_uart_fifo_tx_p->st_uart_handle_p, UART_IT_TXE);
                        }
   }
         
         
        //接收中断处理
        uint8_t ucData;
        if((__HAL_UART_GET_IT(st_uart_fifo_rx_p->st_uart_handle_p, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(st_uart_fifo_rx_p->st_uart_handle_p, UART_IT_RXNE) != RESET))
  {
                ucData = (uint8_t)(st_uart_fifo_rx_p->st_uart_handle_p->Instance->RDR&0x01FF);
                       
          if(((st_uart_fifo_rx_p->st_uart_handle_p->Instance->ISR) & 0x0000) == 0)//无错误
          {
            /*buf满了则清除缓冲区*/
                        if(++(st_uart_fifo_rx_p->uw_fifo_cnt) > st_uart_fifo_rx_p->uw_fifo_size)  
                        {
//                                           st_uart_fifo_rx_p->uw_fifo_cnt = st_uart_fifo_rx_p->uw_fifo_size;   //test
                                st_uart_fifo_rx_p->uw_fifo_cnt = 0;  //test
                                st_uart_fifo_rx_p->uw_fifo_write_index = st_uart_fifo_rx_p->uw_fifo_read_index;
                           st_uart_fifo_rx_p->uc_fifo_overflow = 1;
                        }
                        else
                        {
                //增加一个接受回调函数      
                                *(st_uart_fifo_rx_p->uc_fifo_addr_p + st_uart_fifo_rx_p->uw_fifo_write_index) = ucData;     


               
                                if(++(st_uart_fifo_rx_p->uw_fifo_write_index) >= st_uart_fifo_rx_p->uw_fifo_size)
                                {
                                        st_uart_fifo_rx_p->uw_fifo_write_index = 0;
                                }       
                        }       
               
          }//接收到数据
      MSA_UART_RxCpltCallback(ucData, st_uart_fifo_rx_p);
  }
}


3.2、新的解决方法
一次项目机会，重新审视了以前的操作方式，觉得应该是有比较好的解决方案的。于是出现了下面这种方法。好处有以下几点。
1、不需要修改HAL库的基础函数
2、系统可移植性提高
3、不需要去研究寄存器，去判断串口接收错误


这种方式，是利用hal库的接收完成回调函数，当串口数据接收完成后会进入回调函数，我们只需要完善回调函数，就可以了。回调函数是个弱函数，类似于C++里面的虚函数。主要方法如下
1、利用HAL库中断接收方法接收一个数据。当这个数据接收完成后，会进入回调函数。


HAL_UART_Receive_IT(&huart1, &aRxBuffer, 1);
1
2、在回调函数里面，处理完数据后，重新调用上面这条语句。这样，只要有数据进来，中断就不停的接收数据，并放入自己定义的缓冲区。


//测试版本，没有判断是哪个串口收到的数据
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
                        if(++(st_uart1_rx_fifo.uw_fifo_cnt) > st_uart1_rx_fifo.uw_fifo_size)  
                        {
                                           st_uart1_rx_fifo.uw_fifo_cnt = st_uart1_rx_fifo.uw_fifo_size;   //test
                                st_uart1_rx_fifo.uw_fifo_cnt = 0;  //test
                                st_uart1_rx_fifo.uw_fifo_write_index = st_uart1_rx_fifo.uw_fifo_read_index;
                           st_uart1_rx_fifo.uc_fifo_overflow = 1;
                        }
                        else
                        {
                //增加一个接受回调函数      
                                *(st_uart1_rx_fifo.uc_fifo_addr_p + st_uart1_rx_fifo.uw_fifo_write_index) = aRxBuffer;     
     
                                if(++(st_uart1_rx_fifo.uw_fifo_write_index) >= st_uart1_rx_fifo.uw_fifo_size)
                                {
                                        st_uart1_rx_fifo.uw_fifo_write_index = 0;
                                }       
                        }       
        HAL_UART_Receive_IT(&huart1, &aRxBuffer, 1);
}


4、总结
接收一个字节，然后利用接收完成回调函数，在回调函数里面处理完对应的数据后，继续接收一个字节。如此往复。