btl143/QD4C-firmware
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

更新帧解析方式(待测试)

Browse Source
This commit is contained in:
bmy
2024-03-20 00:59:33 +08:00
parent 3bb5383c06
commit d5646d43ef
2 changed files with 118 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
app/by_fan_control.c
View File

@@ -18,15 +18,15 @@ void by_pwm_init(void)
pwm_init(Fan_pwm_up1, 50, 500); // 浮力风扇左
pwm_init(Fan_pwm_up2, 50, 500); // 浮力风扇右
pwm_init(Fan_pwm_power1, 50, 500); // 动力风扇左1
pwm_init(Fan_pwm_power2, 50, 500); // 动力风扇右1
pwm_init(Fan_pwm_power3, 50, 500); // 动力风扇左2
pwm_init(Fan_pwm_power4, 50, 500); // 动力风扇右2
pwm_init(Fan_pwm_power1, 50, 500); // 动力风扇左 1
pwm_init(Fan_pwm_power2, 50, 500); // 动力风扇右 1
pwm_init(Fan_pwm_power3, 50, 500); // 动力风扇左 2
pwm_init(Fan_pwm_power4, 50, 500); // 动力风扇右 2
// system_delay_ms(3000);
// // pwm_init(Fan_pwm_power1, 50, 1000); // 动力风扇左1
// // pwm_init(Fan_pwm_power2, 50, 1000); // 动力风扇右1
// // pwm_init(Fan_pwm_power3, 50, 1000); // 动力风扇左2
// // pwm_init(Fan_pwm_power4, 50, 1000); // 动力风扇右2
// // pwm_init(Fan_pwm_power1, 50, 1000); // 动力风扇左 1
// // pwm_init(Fan_pwm_power2, 50, 1000); // 动力风扇右 1
// // pwm_init(Fan_pwm_power3, 50, 1000); // 动力风扇左 2
// // pwm_init(Fan_pwm_power4, 50, 1000); // 动力风扇右 2
// // system_delay_ms(5000);
// pwm_set_duty(Fan_pwm_power1, 600);
// pwm_set_duty(Fan_pwm_power2, 600);

188
app/by_frame.c
View File

@@ -7,110 +7,129 @@
#include "lwrb.h"
#include "crc16.h"
// lwrb_t lwrb_struct;
// uint8_t lwrb_buffer[50];
uint8_t frame_buffer[50];
uint8_t frame_buffer_parse[50];
uint8_t frame_buffer_recv[(2 * (4 + 8))];
uint8_t frame_buffer_send[4 + 8];
uint8_t frame_parse_busy;
fifo_struct frame_fifo;
void by_frame_init(void)
{
fifo_init(&frame_fifo, FIFO_DATA_8BIT, frame_buffer, 30);
fifo_init(&frame_fifo, FIFO_DATA_8BIT, frame_buffer_recv, (2 * (4 + 8)));
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);
frame_parse_busy = 0;
// lwrb_init(&lwrb_struct, lwrb_buffer, 50);
}
void by_frame_send(uint8_t data_num, uint32_t *data_array)
{
uint16_t crc_cal = 0;
frame_buffer[0] = BY_FRAME_HEAD_1;
frame_buffer[1] = BY_FRAME_HEAD_2;
uint16_t crc_cal = 0;
frame_buffer_send[0] = BY_FRAME_HEAD_1;
frame_buffer_send[1] = BY_FRAME_HEAD_2;
memcpy(frame_buffer + 2, data_array, data_num * sizeof(uint32_t));
crc_cal = crc16_check(frame_buffer, 2 + data_num * sizeof(uint32_t));
memcpy(frame_buffer_send + 2, data_array, data_num * sizeof(uint32_t));
crc_cal = crc16_check(frame_buffer_send, 2 + data_num * sizeof(uint32_t));
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);
frame_buffer_send[2 + data_num * sizeof(uint32_t)] = (uint8_t)(crc_cal >> 8);
frame_buffer_send[3 + data_num * sizeof(uint32_t)] = (uint8_t)(crc_cal);
uart_write_buffer(BY_FRAME_UART_INDEX, frame_buffer, 4 + data_num * sizeof(uint32_t));
uart_write_buffer(BY_FRAME_UART_INDEX, frame_buffer_send, 4 + data_num * sizeof(uint32_t));
}
void by_frame_parse(uint8_t data_num, uint32_t *data_array)
{
uint8_t cnt = 0;
uint8_t cnt_crc = 2;
uint8_t cnt_ptr = 0;
uint8_t data = 0;
uint8_t data_array_temp[100] = {0};
uint16_t crc_cal = 0;
uint32_t read_length = 50;
if (fifo_used(&frame_fifo) >= 4 + 4 * data_num) {
fifo_read_buffer(&frame_fifo, frame_buffer_parse, &read_length, FIFO_READ_AND_CLEAN);
while (1) {
if (cnt_ptr < 50) {
data = frame_buffer_parse[cnt_ptr];
cnt_ptr++;
uint16_t len = (uint16_t)fifo_used(&frame_fifo);
uint16_t len_cnt = len;
uint8_t status = 0;
uint16_t frame_start = 0;
uint8_t frame_buffer[4 + 8] = {0};
uint8_t buf[sizeof(frame_buffer)] = {0};
if (len < 4 + 4 * data_num) {
// 缓冲区内长度小于帧长度，直接返回
// 要是每次读的时候缓冲区内就只有前一帧的尾部和后一帧的头部，岂不是很尴尬
// 是不是应该正确解析之后再把过的部分清空？但是是异步操作，实际上缓冲区内已经是新数据了
// 可是直接读取 fifo 的话也是异步操作
// 发的慢的话就很有可能有同步问题，导致一直解析不出来
// 喵的，为啥不直接丢中断里解析算了
// 目前的解决办法大概是缓冲区开两帧长的大小，然后一次性读完
// 读取的时候不清除，等待新帧覆盖
return;
}
fifo_read_buffer(&frame_fifo, buf, &len, FIFO_READ_ONLY);
while (len_cnt--) {
if (0 == status) // 没找到帧头
{
printf("finding frame head, now frame_start %d\r\n", frame_start);
uint16_t temp = *((uint16_t *)(buf + (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");
}
// printf("char : %0.2X\r\n", data);
continue;
}
if ((0 == cnt) && (BY_FRAME_HEAD_1 == data)) {
cnt = 1;
data_array_temp[0] = data;
continue;
}
if ((1 == cnt) && (BY_FRAME_HEAD_2 == data)) {
cnt = 2;
data_array_temp[1] = data;
continue;
}
if ((2 <= cnt) && (cnt < 2 + data_num * sizeof(uint32_t))) {
data_array_temp[cnt] = data;
cnt++;
continue;
}
if (cnt_crc) {
crc_cal |= ((uint16_t)data << (--cnt_crc * 8));
cnt++;
continue;
}
// printf("GET CRC %0.4X\r\n", crc_cal);
// 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(data_array_temp, 2 + data_num * sizeof(uint32_t))) {
memcpy(data_array, data_array_temp + 2, data_num * sizeof(uint32_t));
fifo_clear(&frame_fifo); // TODO 确认是否有必要清除
// lwrb_reset(&lwrb_struct); // 处理完直接清空缓冲区，避免堆积产生处理阻塞
memset(data_array_temp, 0, sizeof(data_array_temp));
// for (uint8_t i = 0; i < data_num; i++) {
// for (uint8_t j = 0; j < 4; j++) {
// uart_write_byte(DEBUG_UART_INDEX, data_array[i] >> (j * 8));
// }
// }
// uart_write_byte(DEBUG_UART_INDEX, 0x00);
// uart_write_byte(DEBUG_UART_INDEX, 0x00);
// uart_write_byte(DEBUG_UART_INDEX, 0x80);
// uart_write_byte(DEBUG_UART_INDEX, 0x7F);
if (1 == status) // 开始读数据
{
if ((frame_start + 4 + 8) >= len) // 剩下的数据不够组成一帧
{
printf("failed! length not enough \r\n");
return; // 解析出错，缓冲区中没有有效帧
} else {
memcpy(frame_buffer, buf + frame_start - 1, 4 + 8); // 复制到帧缓冲区，减一是因为之前多加了一次
for (uint8_t i = 0; i < 12; i++) {
printf("%02X", frame_buffer[i]);
}
break;
printf("\r\n");
status = 2;
}
continue;
}
if (2 == status) // 校验 CRC
{
// TODO 确认一下高低位
if (*((uint16_t *)(frame_buffer + 2 + 8)) == crc16_check(frame_buffer, 2 + 4 * data_num)) // 暂时用 0xFF 替代 注意比较的时候字节序！！！
{
printf("parsed done!!!!!!!!\r\n"); // 解析成功了✌
memcpy(data_array, frame_buffer + 2, 4 * data_num); // 复制数据
return;
} else {
status = 0;
// frame_start += (8 - 1); // 这样无法应对连续帧之间缺字节的的问题，但是减少了重新遍历寻找帧头的时间
frame_start += (2 - 1); // 从上一个帧头之后开始解析
continue;
}
}
}
// if (lwrb_get_full(&lwrb_struct) >= (4 + data_num * sizeof(uint32_t))) {
// while (lwrb_read(&lwrb_struct, &data, 1)) {
return;
// uint8_t cnt = 0;
// uint8_t cnt_crc = 2;
// uint8_t cnt_ptr = 0;
// uint8_t data = 0;
// uint8_t data_array_temp[100] = {0};
// uint16_t crc_cal = 0;
// uint32_t read_length = 50;
// if (fifo_used(&frame_fifo) >= 4 + 4 * data_num) {
// fifo_read_buffer(&frame_fifo, frame_buffer_parse, &read_length, FIFO_READ_AND_CLEAN);
// while (1) {
// if (cnt_ptr < 50) {
// data = frame_buffer_parse[cnt_ptr];
// cnt_ptr++;
// }
// // printf("char : %0.2X\r\n", data);
// if ((0 == cnt) && (BY_FRAME_HEAD_1 == data)) {
// frame_parse_busy = 1; // 开始解析
// cnt = 1;
// data_array_temp[0] = data;
// continue;
@@ -130,6 +149,7 @@ void by_frame_parse(uint8_t data_num, uint32_t *data_array)
// if (cnt_crc) {
// crc_cal |= ((uint16_t)data << (--cnt_crc * 8));
// cnt++;
// continue;
// }
@@ -139,9 +159,9 @@ void by_frame_parse(uint8_t data_num, uint32_t *data_array)
// if (!cnt_crc) {
// if (crc_cal == crc16_check(data_array_temp, 2 + data_num * sizeof(uint32_t))) {
// memcpy(data_array, data_array_temp + 2, data_num * sizeof(uint32_t));
// lwrb_reset(&lwrb_struct); // 处理完直接清空缓冲区，避免堆积产生处理阻塞
// fifo_clear(&frame_fifo); // TODO 确认是否有必要清除
// // lwrb_reset(&lwrb_struct); // 处理完直接清空缓冲区，避免堆积产生处理阻塞
// memset(data_array_temp, 0, sizeof(data_array_temp));
// // printf("parsed done!\r\n");
// }
// break;
@@ -155,3 +175,15 @@ void by_frame_parse_uart_handle(uint8_t data)
fifo_write_element(&frame_fifo, data);
// lwrb_write(&lwrb_struct, &data, 1);
}
/**
* @brief 定时器回调，用于接收超时判断 1ms 调用一次
*
*/
void by_frame_parse_timer_handle(void)
{
static uint8_t time_out = 0;
if (frame_parse_busy) {
time_out--;
}
}