串口汲取，环形缓冲区+剖析

串口汲取，环形缓冲区+剖析

环形缓冲区存储布局体

1. #define RX_RING_SIZE 256
3. typedef struct {
4.     uint8_t buf[RX_RING_SIZE];  // 实际存数据
5.     volatile uint16_t head;     // 写指针（中断在改），（volatile）防止编译器优化导致 中断/主循环不同步
6.     volatile uint16_t tail;     // 读指针（主循环在改）
7. } ring_buf_t;

复制代码

初始化串口

1. void USART3_IRQHandler(void);//提前声明串口接收中断
2. void uart3_Init(u32 baud)
3. {         
4.   GPIO_InitTypeDef GPIO_InitStructure;
5.   USART_InitTypeDef USART_InitStructure;
6.   NVIC_InitTypeDef NVIC_InitStruct;
7.   
8.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);                        
9.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);                       
10.   
11.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;                        
12.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                               
13.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                               
14.   GPIO_Init(GPIOB,&GPIO_InitStructure);                                
15.    
16.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                        
17.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                               
18.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                               
19.   GPIO_Init(GPIOB,&GPIO_InitStructure);
20.   
21.   USART_InitStructure.USART_BaudRate = baud;                               
22.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;               
23.   USART_InitStructure.USART_StopBits = USART_StopBits_1;                       
24.   USART_InitStructure.USART_Parity = USART_Parity_No;                       
25.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
26.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;               
27.   USART_Init(USART3, &USART_InitStructure);        
28.   
29.   NVIC_InitStruct.NVIC_IRQChannel = USART3_IRQn;
30.   NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
31.   NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
32.   NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
33.   NVIC_Init(&NVIC_InitStruct);//配置NVIC
34.   
35.   USART_Cmd(USART3, ENABLE);                                         
36.   
37.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);       
38.   USART_ITConfig(USART3, USART_IT_ERR, ENABLE);
39.   
40.   BSP_IntVectSet(BSP_INT_ID_USART3,USART3_IRQHandler);
41.   BSP_IntEn(BSP_INT_ID_USART3);
43. }

复制代码

设置布局体

1. ring_buf_t rx_ring3 = {0, 0, 0};

复制代码

串口汲取制止(底子)

1. void USART3_IRQHandler(void)
2. {
3.    if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) {
4.        uint8_t ch = (uint8_t)USART_ReceiveData(USART3);
5.        uint16_t next = (rx_ring3.head + 1) % RX_RING_SIZE;
7.        // 如果缓冲区没满，存入 数据
8.        if (next != rx_ring3.tail) {
9.            rx_ring3.buf[rx_ring3.head] = ch;
10.            rx_ring3.head = next;
11.        }
12.        USART_ClearITPendingBit(USART3, USART_IT_RXNE);
13.    }
14. }

复制代码

剖析函数（放循环，壅闭期待）

1. void Extract_select_Data(void)//判断数据包
2. {
3.     static uint8_t state_r4 = 0;
4.     static uint8_t data_len_r4 = 0;
5.     static uint8_t count_r4 = 0;
7.     static uint8_t frame_buf[32];
9.     // 只要缓冲区里有数据，就一直处理
10.     while (rx_ring3.head != rx_ring3.tail)
11.     {
12.         // 1. 从环形缓冲区读取一个字节  
13.         uint8_t ch = rx_ring3.buf[rx_ring3.tail];
14.         rx_ring3.tail = (rx_ring3.tail + 1) % RX_RING_SIZE;
16.         switch (state_r4)
17.         {
18.             case 0: // 等待帧头
19.                 if (ch == 0x2A)
20.                 {
21.                     frame_buf[0] = ch;
22.                     count_r4 = 1;
23.                     state_r4 = 1;
24.                 }
25.                 break;
27.             case 1: // 校验 CMD
28.                 if (ch == 0x11)
29.                 {
30.                     frame_buf[count_r4++] = ch;
31.                     state_r4 = 2;
32.                 }
33.                 else
34.                 {
35.                     state_r4 = 0;   // CMD 不匹配，丢弃
36.                 }
37.                 break;
39.             case 2: // 校验 LEN
40.                 if (ch == 0x04)
41.                 {
42.                     data_len_r4 = ch;
43.                     frame_buf[count_r4++] = ch;
44.                     state_r4 = 3;
45.                 }
46.                 else
47.                 {
48.                     state_r4 = 0;   // LEN 不匹配，丢弃
49.                 }
50.                 break;
52.             case 3: // 接收 DATA(4字节) + CRC
53.                 frame_buf[count_r4++] = ch;
55.                 // 1(2E) + 1(CMD) + 1(LEN) + 4(DATA) + 1(CRC) = 8
56.                 if (count_r4 >= 8)
57.                 {
58.                     /* ========= 业务判断 ========= */
60.                     uint8_t byte6 = frame_buf[5]; // DATA2
62.                     if (byte6 & 0x04)   // bit2 = 1
63.                     {
64.                         select_bit2_flag = 1;//解析结果
65.                         BLE_TO_MCU_OK_FLAG=1;
66.                     }
67.                     else
68.                     {
69.                         BLE_TO_MCU_OK_FLAG=0;
70.                         select_bit2_flag = 0;
71.                     }
73.                     /* ============================ */
75.                     state_r4 = 0;   // 准备下一帧
76.                 }
77.                 break;
79.             default:
80.                 state_r4 = 0;
81.                 break;
82.         }
83.     }
84. }

复制代码

打扫缓存区

1. void RingBuf3_ClearAndResetParser(void)
2. {
3. //    __disable_irq();  // 关中断，保证原子性
5.     // 1. 清空环形缓冲区数据
6.     memset(rx_ring3.buf, 0, RX_RING_SIZE);
8.     // 2. 重置 head/tail
9.     rx_ring3.head = 0;
10.     rx_ring3.tail = 0;
12.     // 3. 重置解析器状态
13.     state_r3 = 0;
14.     count_r3 = 0;
15.     data_len_r3 = 0;
16.     pkg_ready = 0;
18. //    __enable_irq();  // 重新使能中断
19. }

复制代码