stm32对于串口数据流的处理，错过绝对后悔

串口编程问题：


   当来的数据是一个字符流的时候，截取需要的一串字符的处理 （stm32）：


#include "bsp_usart.h"


uint8_t RxBuffer1[COM1_Rx_length]={0};
uint8_t RxBuffer2[COM2_Rx_length]={0};
uint8_t TxBuffer1[COM1_Tx_length]={0};
uint8_t TxBuffer2[COM2_Tx_length]={0};

extern uint8_t flag;                                                                          
USART_TypeDef COM1,COM2;        //bsp_usart.c中的全局变量，在stm32f10x.h的结构体定义中增加了两个变量UsartRecvBufReadIndex UsartRecvBufWriteIndex;

/***************************************************************************************************
*Function      Usart_GPIO_config
*Description   配置函数
*Parameter     void
*Return        void
*Note         
*Log           2014.05.28    Ver 1.0   
*               创建函数。
***************************************************************************************************/
void Usart_GPIO_config()
{

        /*
        USART2
        TXD2----- PA2-US2-TX
        RXD2----- PA3-US2-RX
        USART1
        PA9   --tx
        PA10  --rx
        速率：9600,n,8,1
        */
        GPIO_InitTypeDef GPIO_Structure;
        GPIO_Structure.GPIO_Speed = GPIO_Speed_50MHz;
        //   GPIO_Structure.GPIO_Pin=GPIO_Pin_9;
        //         GPIO_Structure.GPIO_Mode=GPIO_Mode_AF_PP;
        //         GPIO_Init(GPIOA,&GPIO_Structure);

        //         GPIO_Structure.GPIO_Pin=GPIO_Pin_10;
        //         GPIO_Structure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
        //         GPIO_Init(GPIOA,&GPIO_Structure);

        GPIO_Structure.GPIO_Pin=GPIO_Pin_3;
        GPIO_Structure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
        GPIO_Init(GPIOA,&GPIO_Structure);

        GPIO_Structure.GPIO_Pin=GPIO_Pin_2;
        GPIO_Structure.GPIO_Mode=GPIO_Mode_AF_PP;;
        GPIO_Init(GPIOA,&GPIO_Structure);



}
/***************************************************************************************************
*Function      void Usart_Initlocal(int8_t port)
*Description   Usart 时钟使能
*Parameter     port 使能端口 (1或2)
*Return        void
*Note         
*Log                  2014年7月4日
*               创建函数。
***************************************************************************************************/
void Usart_RCC_Initlocal(int8_t port)
{
        if(port==1)                  
                RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);         
        if(port==2)
                RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART2,ENABLE);

}
/***************************************************************************************************
*Function      SetBaudRatelocal(USART_TypeDef* USARTx ,u32 BaudRate)
*Description   设置波特率
*Parameter     USART_TypeDef* USARTx
*Parameter     u32 BaudRate
*Return        void
*Note         
*Log                  2014年7月4日
*              
***************************************************************************************************/
void SetBaudRatelocal(USART_TypeDef* USARTx ,u32 BaudRate)
{

        USART_InitTypeDef USART_InitStructure;
        USART_InitStructure.USART_BaudRate = BaudRate;
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        USART_InitStructure.USART_StopBits = USART_StopBits_1;
        USART_InitStructure.USART_Parity = USART_Parity_No;
        USART_InitStructure.USART_HardwareFlowControl =USART_HardwareFlowControl_None;
        USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
        USART_Init(USARTx, &USART_InitStructure);  

}

/***************************************************************************************************
*Function     Usart_Enablelocal(USART_TypeDef* Usartx)
*Description   使能USAETx
*Parameter     USART_TypeDef* Usartx
*Return        void
*Note         
*Log                  2014年7月4日
*                      在时钟使能和设置完波特率之后，再使能Usart
***************************************************************************************************/
void Usart_Enablelocal(USART_TypeDef* Usartx)
{               
        USART_ITConfig(Usartx, USART_IT_TXE, ENABLE);
        USART_ITConfig(Usartx, USART_IT_RXNE, ENABLE);
        USART_Cmd(Usartx, ENABLE);          

}
/***************************************************************************************************
*Function     Usart_Enable(USART_TypeDef* Usartx)
*Description   使能USAETx
*Parameter     IRQn_Type IRQx( USART1_IRQn / USART2_IRQn)
*Return        void
*Note         
*Log                  2014年7月4日
*                      在时钟使能和设置完波特率之后，再使能Usart
***************************************************************************************************/
void Usart_NVIconfiglocal(IRQn_Type IRQx)
{
        NVIC_InitTypeDef NVICInitStructure;
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
        if(USART1_IRQn==IRQx)
                NVICInitStructure.NVIC_IRQChannel = USART1_IRQn;
        if(USART2_IRQn==IRQx)
                NVICInitStructure.NVIC_IRQChannel = USART2_IRQn;
        NVICInitStructure.NVIC_IRQChannelPreemptionPriority = 0;
        NVICInitStructure.NVIC_IRQChannelSubPriority = 0;
        NVICInitStructure.NVIC_IRQChannelCmd = ENABLE;       
        NVIC_Init(&NVICInitStructure);
}
/以上为硬件初始化/

/***************************************************************************************************
*Function      Usart_Sendchar(USART_TypeDef* USARTx,uint8_t ch_data)
*Description   发送单个字节
*Parameter     USART_TypeDef* USARTx
*Parameter     uint8_t ch_data
*Return        void
*Note         
*Log                  2014年7月5日
*                     
***************************************************************************************************/
void Usart_Sendchar(USART_TypeDef* USARTx,uint8_t ch_data)
{
        while(USART_GetFlagStatus(USARTx,USART_FLAG_TC)==RESET);
        USART_SendData(USARTx,(u8)ch_data);
}

/***************************************************************************************************
*Function      Usart_SendString(USART_TypeDef* USARTx,uint8_t *p_str)
*Description   发送字符串
*Parameter     USART_TypeDef* USARTx
*Parameter     uint8_t *p_str
*Return        void
*Note         
*Log                  2014年7月5日
*                      用于测试  需要以‘0’字符结尾
***************************************************************************************************/
void Usart_SendString(USART_TypeDef* USARTx,uint8_t *p_str)
{
        while(*p_str)
        {                    
                Usart_Sendchar(USARTx,*p_str++);         
        }       
}
/
/***************************************************************************************************
*Function       USARTSend(USART_TypeDef* USARTx,uint8_t *p_str,uint8_t len)
*Description   发送函数
*参数          USART_TypeDef* USARTx  端口号
*参数          uint8_t *buf  接收数组
*参数          uint8_t len          接收串的长度
*Return        uint8_t       返回实际可读取串的长度
*Note         
*Log                  2014年7月5日
*                     
***************************************************************************************************/
void USARTSend(uint8_t port,uint8_t *p_str,uint8_t len)
{
        uint8_t i;
        if(port==1)
        {
                for(i=0;i                 {                                             
                        Usart_Sendchar(USART1,p_str);             
                }

        }
        if(port==2)
        {
                for(i=0;i                 {                                             
                        Usart_Sendchar(USART2,p_str);             
                }
        }
}               
/***************************************************************************************************
*Function      USARTRecv(uint8_t port,uint8_t *buf,uint8_t len)
*Description   接收函数
*参数          uint8_t port  端口号
*参数          uint8_t *buf  接收数组
*参数          uint8_t len          接收串的长度
*Return        uint8_t       返回实际可读取串的长度
*Note         
*Log                  2014年7月5日
*                     
***************************************************************************************************/
uint8_t USARTRecv(uint8_t port,uint8_t *buf,uint8_t len)
{
        uint8_t data_count=0;
        uint8_t i;

        switch(port)
        {
        case 1:
                data_count=(COM1.UsartRecvBufWriteIndex+COM1_Rx_length-COM1.UsartRecvBufReadIndex)%COM1_Rx_length;
                if(data_count                 {                          
                        len=data_count;         // 当len<（UsartRecvBufWriteIndex-UsartRecvBufReadIndex）的时候，数据并不放在buf中，而是等待大于或等于的时候再放入！！！
                }
                else
                {
                        for(i=0;i                         {
                                buf=RxBuffer1[COM1.UsartRecvBufReadIndex++];
                                COM1.UsartRecvBufReadIndex=COM1.UsartRecvBufReadIndex%COM1_Rx_length;
                        }

                }
                break;
        case 2:
                data_count=(COM2.UsartRecvBufWriteIndex+COM2_Rx_length-COM2.UsartRecvBufReadIndex)%COM2_Rx_length;
                if(data_count                 {
                        len=data_count;                                               
                }
                else
                {
                        for(i=0;i                         {
                                buf=RxBuffer2[COM2.UsartRecvBufReadIndex++];
                                COM2.UsartRecvBufReadIndex=COM2.UsartRecvBufReadIndex%COM2_Rx_length;       

                        }
                }
                break;
        default:
                break;                                          
        }
        return len;

}







/***************************************************************************************************
*Function      Usart1_RxIntHandler(void)
*Description   Usart1接收处理函数
*Parameter     void
*Return        void
*Note         
*Log                  2014年7月5日
*                      放在中断里进行接收
***************************************************************************************************/
void Usart1_RxIntHandler(void)
{

        if(USART_GetFlagStatus(USART1,USART_IT_RXNE)!=RESET)
        {
                RxBuffer1[COM1.UsartRecvBufWriteIndex++]=USART_ReceiveData(USART1);
                COM1.UsartRecvBufWriteIndex=COM1.UsartRecvBufWriteIndex%COM1_Rx_length;

        }                                                                                                                  
        if(USART_GetITStatus(USART1,USART_IT_TXE)!=RESET)//        这段是为了避免STM32 USART 第一个字节发不出去的BUG // 发送中断还没有清零               
        {
                USART_ITConfig(USART1,USART_IT_TXE,DISABLE);         
        }        // 当再有需要发送的字符是，硬件会自动置位

}
//void Usart1_RxIntHandler(void)        //放在中断里进行接收
//{
//        uint8_t i;
//        if(USART_GetFlagStatus(USART1,USART_IT_RXNE)!=RESET)
//        {
//                RxBuffer1[RxCounter1++]=USART_ReceiveData(USART1);
//
//                if(RxBuffer1[RxCounter1-1]==0x16)
//                {
//                        for(i=0;i //                        {
//                                TxBuffer1=RxBuffer1;                                                  
//                        }
//                        TxBuffer1[RxCounter1]=0;
//                        flag=1;
//                        RxCounter1=0;                                 
//                }         
//        }
//        if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) //这段是为了避免STM32 USART 第一个字节发不出去的BUG // 发送中断还没有清零               
//        {
//                USART_ITConfig(USART1, USART_IT_TXE, DISABLE);                                             //禁止发缓冲器空中断，
//        }        // 当再有需要发送的字符是，硬件会自动置位
//
//}



/***************************************************************************************************
*Function      Usart2_RxIntHandler(void)
*Description   Usart2接收处理函数
*Parameter     void
*Return        void
*Note         
*Log                  2014年7月5日
*                      放在中断里进行接收   //结束符 0x16
***************************************************************************************************/
void Usart2_RxIntHandler(void)
{

        if(USART_GetFlagStatus(USART2,USART_IT_RXNE)!=RESET)
        {
                RxBuffer2[COM2.UsartRecvBufWriteIndex++]=USART_ReceiveData(USART2);
                COM2.UsartRecvBufWriteIndex=COM2.UsartRecvBufWriteIndex%COM2_Rx_length;

        }                                                                                                                  
        if(USART_GetITStatus(USART2,USART_IT_TXE)!=RESET)
        {
                USART_ITConfig(USART2,USART_IT_TXE,DISABLE);         
        }

}
//void Usart2_RxIntHandler(void)
//{
//        uint8_t i;
//        if(USART_GetFlagStatus(USART2,USART_IT_RXNE)!=RESET)
//        {
//                RxBuffer2[RxCounter2++]=USART_ReceiveData(USART2);
//                if(RxBuffer2[RxCounter2-1]==0x16)
//                {
//                        for(i=0;i //                        {
//                                TxBuffer2=RxBuffer2;
//
//                        }
//                        TxBuffer2[RxCounter2]=0;
//                        flag=1;
//                        RxCounter2=0;                                 
//                }  
//        }                
//        if(USART_GetITStatus(USART2,USART_IT_TXE)!=RESET)
//        {
//                USART_ITConfig(USART2,USART_IT_TXE,DISABLE);         
//        }
//
//}