feat: 增加通信参数

app/by_frame.c

@@ -7,83 +7,147 @@
 #include "lwrb.h"
 #include "crc16.h"
 
-lwrb_t lwrb_struct;
+uint8_t frame_buffer_recv[(2 * (4 + BY_FRAME_DATA_NUM * sizeof(uint32_t))) + 1];
-uint8_t lwrb_buffer[50];
+uint8_t frame_buffer_send[4 + BY_FRAME_DATA_NUM * sizeof(uint32_t)];
-uint8_t frame_buffer[100];
+uint8_t frame_parse_busy;
+lwrb_t lwrb_ctx;
 
 void by_frame_init(void)
 {
+    lwrb_init(&lwrb_ctx, frame_buffer_recv, sizeof(frame_buffer_recv)); // lwrb 最大元素数量为 buff 大小减一
     uart_init(BY_FRAME_UART_INDEX, BY_FRAME_UART_BAUDRATE, BY_FRAME_UART_TX_PIN, BY_FRAME_UART_RX_PIN);
-    // uart_rx_interrupt(BY_FRAME_UART_INDEX, ENABLE);
+    uart_rx_interrupt(BY_FRAME_UART_INDEX, ENABLE);
-
-    lwrb_init(&lwrb_struct, lwrb_buffer, 50);
 }
 
-void by_frame_send(uint8_t data_num, uint32_t *data_array)
+void by_frame_send(uint32_t *data_array)
 {
     uint16_t crc_cal            = 0;
-    frame_buffer[0]  = BY_FRAME_HEAD_1;
+    const uint8_t data_byte_num = BY_FRAME_DATA_NUM * sizeof(uint32_t);
-    frame_buffer[1]  = BY_FRAME_HEAD_2;
 
-    memcpy(&frame_buffer[2], data_array, data_num * sizeof(uint32_t));
+    frame_buffer_send[0] = BY_FRAME_HEAD_1;
-    crc_cal = crc16_check(frame_buffer, 2 + data_num * sizeof(uint32_t));
+    frame_buffer_send[1] = BY_FRAME_HEAD_2;
 
-    frame_buffer[2 + data_num * sizeof(uint32_t)] = (uint8_t)(crc_cal >> 8);
+    // 当传入数组不足时，会发生越界情况
-    frame_buffer[3 + data_num * sizeof(uint32_t)] = (uint8_t)(crc_cal);
+    memcpy(frame_buffer_send + 2, data_array, data_byte_num);
+    crc_cal = crc16_check(frame_buffer_send, 2 + data_byte_num);
 
-    uart_write_buffer(BY_FRAME_UART_INDEX, frame_buffer, 4 + data_num * sizeof(uint32_t));
+    frame_buffer_send[2 + data_byte_num] = (uint8_t)(crc_cal >> 8);
-    system_delay_us(BY_FRAME_UART_IDLE_TIME_US);
+    frame_buffer_send[3 + data_byte_num] = (uint8_t)(crc_cal);
+
+    uart_write_buffer(BY_FRAME_UART_INDEX, frame_buffer_send, 4 + data_byte_num);
 }
 
-void by_frame_parse(uint8_t data_num, uint32_t *data_array)
+/**
+ * @brief
+ *
+ * @param data_num
+ * @param data_array
+ * @todo 将其中写死的数据长度按照宏定义给出
+ */
+void by_frame_parse(uint32_t *data_array)
 {
-    uint8_t cnt     = 0;
+    uint32_t len                = lwrb_get_full(&lwrb_ctx); // 缓冲区大小
-    uint8_t cnt_crc = 2;
+    uint8_t status              = 0;                        // 状态 0-未找到帧头 1-找到帧头 2-校验
-    uint8_t data    = 0;
+    uint16_t frame_start        = 0;                        // 帧起始位置
-    uint8_t data_array_temp[100];
+    uint8_t frame_buf[4 + BY_FRAME_DATA_NUM * sizeof(uint32_t)]    = {0};                      // 帧
-    uint16_t crc_cal = 0;
+    uint8_t buf[(4 + BY_FRAME_DATA_NUM * sizeof(uint32_t)) * 2]    = {0};                      // 用于解析的数据块
+    const uint8_t data_byte_num = BY_FRAME_DATA_NUM * sizeof(uint32_t);
 
-    if (lwrb_get_full(&lwrb_struct) >= (4 + data_num * sizeof(uint32_t))) {
+    if (len < 2 * (4 + data_byte_num)) {
-        while (lwrb_read(&lwrb_struct, &data, 1)) {
+        // 当前要求缓冲区满
-            printf("char : %0.2X\r\n", data);
+        // (x) 缓冲区内长度小于帧长度，直接返回
-            if ((0 == cnt) && (BY_FRAME_HEAD_1 == data)) {
+        // 要是每次读的时候缓冲区内就只有前一帧的尾部和后一帧的头部，岂不是很尴尬
-                cnt                = 1;
+        // 是不是应该正确解析之后再把过的部分清空？但是是异步操作，实际上缓冲区内已经是新数据了
-                data_array_temp[0] = data;
+        // 可是直接读取 fifo 的话也是异步操作
+        // 发的慢的话就很有可能有同步问题，导致一直解析不出来
+        // 喵的，为啥不直接丢中断里解析算了
+
+        // 目前的解决办法大概是缓冲区开两帧长的大小，然后一次性读完
+        // 读取的时候不清除，等待新帧覆盖
+        // 用 lwrb 的话就只能清除了
+        return;
+    }
+
+    // 从环形缓冲区里读取数据
+    lwrb_read(&lwrb_ctx, buf, len);
+
+    // 递归解析有效帧
+    while (1) {
+        if (0 == status) // 没找到帧头
+        {
+            // 读到最后一个元素还没找到帧头
+            if (frame_start >= len - 2) {
+                return;
+            }
+            // printf("finding frame head, now frame_start %d\r\n", frame_start);
+            uint16_t temp = (buf[frame_start] | (buf[frame_start + 1] << 8));
+            frame_start++;
+            // printf("now find %02X\r\n", temp);
+
+            // 递归寻找帧头，直接俩拼起来找 注意比较的时候低位在前
+            if ((BY_FRAME_HEAD_2 << 8 | BY_FRAME_HEAD_1) == temp) {
+                status = 1; // 找到了好耶
+                // printf("frame head found!!!!!!!!!\r\n");
+            }
             continue;
         }
 
-            if ((1 == cnt) && (BY_FRAME_HEAD_2 == data)) {
+        // 开始读数据
-                cnt                = 2;
+        if (1 == status) {
-                data_array_temp[1] = data;
+            // 剩下的数据不够组成一帧
+            if ((frame_start + 4 + data_byte_num - 1) > len) {
+                // printf("failed! length not enough \r\n");
+                // 解析出错，缓冲区中没有有效帧
+                return;
+            } else {
+                // 复制到帧缓冲区，减一是因为之前多加了一次
+                memcpy(frame_buf, buf + frame_start - 1, 4 + data_byte_num);
+
+                // for (uint8_t i = 0; i < 12; i++) {
+                //     printf("%02X", frame_buf[i]);
+                // }
+                // printf("\r\n");
+
+                status = 2;
+            }
             continue;
         }
 
-            if ((2 <= cnt) && (cnt < 2 + data_num * sizeof(uint32_t))) {
+        if (2 == status) // 校验 CRC
-                data_array_temp[cnt] = data;
+        {
-                cnt++;
+            if ((frame_buf[2 + data_byte_num] << 8 | frame_buf[2 + data_byte_num + 1]) == crc16_check(frame_buf, 2 + data_byte_num)) {
+                // 解析成功了✌
+                // printf("parsed done!!!!!!!!\r\n");
+
+                // 复制数据
+                if (NULL != (frame_buf + 2)) {
+                    memcpy(data_array, frame_buf + 2, data_byte_num);
+                }
+                return;
+            } else {
+                status = 0;
+                // 这样无法应对连续帧之间缺字节的的问题，但是减少了重新遍历寻找帧头的时间
+                // frame_start += (8 - 1);
+                // 从上一个帧头之后开始解析
+                frame_start += (2 - 1);
                 continue;
             }
-
+        }
-            if (cnt_crc) {
-                crc_cal |= ((uint16_t)data << (--cnt_crc * 8));
-                continue;
     }
 
-            printf("GET CRC %0.4X\r\n", crc_cal);
+    return;
-            printf("CAL CRC %0.4X\r\n", crc16_check((uint8_t *)data_array_temp, 2 + data_num * sizeof(uint32_t)));
-
-            if (!cnt_crc) {
-                if (crc_cal == crc16_check((uint8_t *)data_array_temp, 2 + data_num * sizeof(uint32_t))) {
-                    memcpy(data_array, data_array_temp + 2, data_num * sizeof(uint32_t));
-                    printf("parsed done!\r\n");
-                    break;
-                }
-            }
-        }
-    }
 }
 
 void by_frame_parse_uart_handle(uint8_t data)
 {
-    lwrb_write(&lwrb_struct, &data, 1);
+    // fifo_write_element(&frame_fifo, data);
+    lwrb_write(&lwrb_ctx, &data, 1);
+}
+
+/**
+ * @brief 定时器回调，用于接收超时判断 1ms 调用一次
+ *
+ */
+void by_frame_parse_timer_handle(void)
+{
 }

app/by_frame.h

@@ -16,11 +16,14 @@
 #define BY_FRAME_UART_INDEX        (UART_2)
 #define BY_FRAME_UART_BAUDRATE     (115200)
 
-#define BY_FRAME_UART_IDLE_TIME_US ((1000000 / BY_FRAME_UART_BAUDRATE * 8) * 4)
+#define BY_FRAME_DATA_NUM      (3)
+
+extern uint8_t frame_buffer[50];
 
 extern void by_frame_init(void);
-extern void by_frame_send(uint8_t data_num, uint32_t *data_array);
+void by_frame_send(uint32_t *data_array);
-extern void by_frame_parse(uint8_t data_num, uint32_t *data_array);
+void by_frame_parse(uint32_t *data_array);
 extern void by_frame_parse_uart_handle(uint8_t data);
 
+
 #endif

app/isr.c

@@ -279,7 +279,7 @@ void EXTI15_10_IRQHandler(void)
 void TIM1_UP_IRQHandler(void)
 {
     if (TIM_GetITStatus(TIM1, TIM_IT_Update) != RESET) {
-        by_frame_send(2, &tiny_frame_param[0].u32);
+        by_frame_send(&tiny_frame_param[0].u32);
         TIM_ClearITPendingBit(TIM1, TIM_IT_Update);
         by_led_warn_blink();
     }

app/jj_param.h

@@ -47,7 +47,7 @@ typedef union {
     uint32_t u32;
     int32_t s32;
     float f32;
-    uint8_t u8;
+    uint8_t u8[4];
 } TYPE_UNION;
 
 typedef struct {

app/main.c

@@ -58,6 +58,7 @@ int main(void)
         by_buzzer_run();
         tiny_frame_param[0].f32 = pure_angle;
         tiny_frame_param[1].f32 = dx_near;
+        tiny_frame_param[2].u32 = 0x19260817;
         system_delay_ms(10);
         if (mt9v03x_finish_flag) {
             // 该操作消耗大概 1970 个 tick，折合约 110us