嵌入式开发之通信协议解析器减少出错率的方法

最新推荐文章于 2025-10-14 11:35:16 发布

原创最新推荐文章于 2025-10-14 11:35:16 发布 · 601 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#嵌入式软件 #通信协议 #解释器

嵌入式开发之路专栏收录该内容

54 篇文章

订阅专栏

在嵌入式系统里，要实现通信协议的可靠解析，可按以下步骤操作：

1. 数据帧定界与同步

要准确识别完整的协议帧，避免帧边界出现错误。

方法：
- 固定长度帧：不管实际数据量多少，帧的总长度是固定的。
- 特殊起始 / 结束标记：像 ASCII 协议里常用STX/ETX，Modbus 协议采用0x55 AA。
- 长度字段：在帧头标明整个帧的长度，比如 CANopen 协议。
示例代码：

// 基于结束标记的帧同步（以'\n'为例）
#define MAX_FRAME_SIZE 256
char frame_buffer[MAX_FRAME_SIZE];
int buffer_index = 0;

void process_byte(uint8_t byte) {
    if (buffer_index < MAX_FRAME_SIZE - 1) {
        frame_buffer[buffer_index++] = byte;
        if (byte == '\n') {  // 检测到结束标记
            frame_buffer[buffer_index] = '\0';  // 添加字符串结束符
            parse_frame(frame_buffer, buffer_index);
            buffer_index = 0;  // 重置缓冲区
        }
    } else {
        // 缓冲区溢出处理
        buffer_index = 0;
    }
}

2. 错误检测机制

为保证数据的完整性，需加入校验措施。

常用算法：
- CRC 校验：像 Modbus、CAN 协议都使用这种校验方式，它的检错能力较强。
- 校验和：例如 ASCII 协议会用到简单的累加和校验。
- LRC 校验：在一些旧协议中较为常见。
示例代码：

// CRC16-Modbus计算
uint16_t crc16_modbus(const uint8_t *data, uint16_t length) {
    uint16_t crc = 0xFFFF;
    for (uint16_t i = 0; i < length; i++) {
        crc ^= (uint16_t)data[i];
        for (uint8_t j = 0; j < 8; j++) {
            if ((crc & 0x0001) != 0) {
                crc >>= 1;
                crc ^= 0xA001;
            } else {
                crc >>= 1;
            }
        }
    }
    return crc;
}

// 帧校验示例
bool verify_frame(const uint8_t *frame, uint16_t length) {
    if (length < 3) return false;  // 至少包含数据和2字节CRC
    
    uint16_t received_crc = (frame[length-2] << 8) | frame[length-1];
    uint16_t calculated_crc = crc16_modbus(frame, length - 2);
    
    return (received_crc == calculated_crc);
}

3. 状态机解析

针对复杂协议，建议使用分层解析的方式。

实现方式：

有限状态机（FSM）：能够处理协议的各个阶段，如帧头检测、长度解析、数据校验等。
事件驱动：当接收到特定字节或完成特定操作时触发相应事件。

示例代码：

// 协议解析状态机
typedef enum {
    STATE_IDLE,
    STATE_HEADER,
    STATE_LENGTH,
    STATE_DATA,
    STATE_CRC
} ParseState;

ParseState current_state = STATE_IDLE;
uint16_t frame_length = 0;
uint16_t data_received = 0;

void parse_byte(uint8_t byte) {
    switch (current_state) {
        case STATE_IDLE:
            if (byte == 0xAA) {  // 起始标记
                current_state = STATE_HEADER;
            }
            break;
            
        case STATE_HEADER:
            if (byte == 0x55) {  // 第二个起始标记
                current_state = STATE_LENGTH;
            } else {
                current_state = STATE_IDLE;  // 同步失败
            }
            break;
            
        case STATE_LENGTH:
            frame_length = byte;
            data_received = 0;
            current_state = STATE_DATA;
            break;
            
        case STATE_DATA:
            // 存储数据
            frame_buffer[data_received++] = byte;
            if (data_received >= frame_length) {
                current_state = STATE_CRC;
            }
            break;
            
        case STATE_CRC:
            // 校验并处理完整帧
            if (verify_frame(frame_buffer, data_received + 2)) {
                process_frame(frame_buffer, data_received);
            }
            current_state = STATE_IDLE;
            break;
    }
}

4. 错误处理策略

为增强系统的健壮性，需要有完善的错误处理机制。

常见错误：
- 帧同步失败：可以设置超时机制来处理这种情况。
- 校验错误：记录错误日志，并可以请求重新发送数据。
- 缓冲区溢出：进行边界检查，防止内存损坏。
示例代码：

// 超时处理
#define FRAME_TIMEOUT_MS 100
uint32_t last_byte_time = 0;

void handle_timeout(void) {
    if ((get_current_time() - last_byte_time) > FRAME_TIMEOUT_MS) {
        current_state = STATE_IDLE;  // 超时，重置状态机
        buffer_index = 0;
    }
}

// 主循环
void main_loop(void) {
    while (1) {
        if (data_available()) {
            uint8_t byte = read_byte();
            last_byte_time = get_current_time();
            process_byte(byte);
        }
        handle_timeout();
        // 其他任务
    }
}