语音模块串口通信。

根据您的要求，我们将修改队列的名称以体现与语音模块的关系，并且不使用 `malloc` 和 `free` 函数。我们将使用静态数组来实现队列，这样就不需要动态分配内存。下面是修改后的代码：

```c
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义语音模块数据包结构
typedef struct {
    unsigned short hdr;         // 包头 (0xFFFF)
    unsigned short len;         // 数据包长度 (从命令到校验和)
    unsigned char cmd;          // 命令字节
    unsigned char sn;           // 序列号
    unsigned short flgs;        // 标记
    unsigned char pl[256];      // 有效负载 (最大256字节)
    unsigned char chk;          // 校验和
} __attribute__((packed)) vmpkt_t; // 使用 packed 属性确保结构体按原始方式存储

// 定义语音模块队列
#define VOICE_QUEUE_SIZE 10 // 队列大小
typedef struct {
    vmpkt_t queue[VOICE_QUEUE_SIZE]; // 队列数组
    int head;                        // 队头索引
    int tail;                        // 队尾索引
} voice_queue_t;

// 初始化队列
void init_voice_queue(voice_queue_t *q) {
    q->head = 0;
    q->tail = 0;
}

// 向队列尾部添加数据包
void enqueue_voice(voice_queue_t *q, vmpkt_t *pkt) {
    if ((q->tail + 1) % VOICE_QUEUE_SIZE == q->head) {
        // 队列满
        return;
    }

    q->queue[q->tail] = *pkt;
    q->tail = (q->tail + 1) % VOICE_QUEUE_SIZE;
}

// 从队列头部移除数据包
vmpkt_t *dequeue_voice(voice_queue_t *q) {
    if (q->head == q->tail) {
        // 队列为空
        return NULL;
    }

    vmpkt_t *pkt = &q->queue[q->head];
    q->head = (q->head + 1) % VOICE_QUEUE_SIZE;
    return pkt;
}

// 用于处理 0xFF 在有效负载中的转义函数
static inline unsigned char v_esc_ff(unsigned char b) {
    return b == 0xFF ? 0x55 : b;
}

// 计算校验和的函数
static inline unsigned char v_calc_chk(const unsigned char *data, size_t len) {
    unsigned short sum = 0;
    for (size_t i = 0; i < len; ++i) {
        sum += data[i];
    }
    return sum % 256;
}

// 构建语音模块数据包的函数
void v_build_pkt(vmpkt_t *pkt, unsigned char cmd, unsigned char sn, unsigned short flgs, const unsigned char *pl, size_t pl_len) {
    unsigned char i;

    pkt->hdr = 0xFFFF; // 设置包头为固定值 0xFFFF
    pkt->cmd = cmd; // 设置命令
    pkt->sn = sn; // 设置序列号
    pkt->flgs = flgs; // 设置标记
    
    // 计算数据包长度（不包括包头和校验和）
    pkt->len = 6 + pl_len; // 命令、序列号、标记、有效负载、校验和
    
    // 复制有效负载并进行转义处理
    for (i = 0; i < pl_len; ++i) {
        pkt->pl[i] = v_esc_ff(pl[i]); // 转义 0xFF
    }
    
    // 计算并设置校验和
    pkt->chk = v_calc_chk((const unsigned char*)pkt + 4, pkt->len);
}

// 处理接收到的语音模块数据包的函数
bool v_handle_rx_pkt(const unsigned char *data, size_t len, vmpkt_t *pkt) {
    unsigned char calc_chk;
    size_t pl_len, idx, i;

    if (len < 8 || data[0] != 0xFF || data[1] != 0xFF) {
        return false; // 如果数据包头部不是 0xFFFF，则返回无效
    }

    // 去除转义的 0xFF 和 0x55
    pl_len = data[2] + data[3] - 6;
    idx = 6;
    for (i = 0; i < pl_len; ++i) {
        if (data[idx] == 0x55 && data[idx - 1] == 0xFF) {
            pkt->pl[i] = 0xFF; // 还原 0xFF
            idx++; // 跳过 0x55
        } else {
            pkt->pl[i] = data[idx];
        }
        idx++;
    }
    
    // 解析数据包字段
    pkt->hdr = (data[0] << 8) | data[1]; // 包头
    pkt->len = (data[2] << 8) | data[3]; // 数据包长度
    pkt->cmd = data[4]; // 命令
    pkt->sn = data[5]; // 序列号
    pkt->flgs = (data[6] << 8) | data[7]; // 标记
    pkt->chk = data[idx]; // 校验和
    
    // 验证校验和
    calc_chk = v_calc_chk(data + 4, pkt->len);
    if (calc_chk != pkt->chk) {
        return false; // 如果校验和不匹配，则返回无效
    }
    
    return true; // 数据包有效
}

// 测试用例
void test_voice_module() {
    unsigned char cmd = 1;
    unsigned char sn = 0;
    unsigned short flgs = 0x0A0B;
    unsigned char pl[] = "Hello, World!";
    size_t pl_len = strlen((const char*)pl);

    vmpkt_t tx_pkt, rx_pkt;
    memset(&tx_pkt, 0, sizeof(tx_pkt));
    memset(&rx_pkt, 0, sizeof(rx_pkt));

    // 构建数据包
    v_build_pkt(&tx_pkt, cmd, sn, flgs, pl, pl_len);

    // 模拟接收的数据包
    unsigned char data[256];
    memcpy(data, &tx_pkt, sizeof(vmpkt_t));

    // 处理接收到的数据包
    bool is_valid = v_handle_rx_pkt(data, sizeof(vmpkt_t), &rx_pkt);

    printf("Data packet validation: %s\n", is_valid ? "Success" : "Failure");

    // 验证命令
    if (is_valid && rx_pkt.cmd == cmd) {
        printf("Command verification: Success\n");
    } else {
        printf("Command verification: Failure\n");
    }

    // 验证序列号
    if (is_valid && rx_pkt.sn == sn) {
        printf("Sequence number verification: Success\n");
    } else {
        printf("Sequence number verification: Failure\n");
    }

    // 验证标记
    if (is_valid && rx_pkt.flgs == flgs) {
        printf("Flags verification: Success\n");
    } else {
        printf("Flags verification: Failure\n");
    }

    // 验证有效负载
    if (is_valid && memcmp(rx_pkt.pl, pl, pl_len) == 0) {
        printf("Payload verification: Success\n");
    } else {
        printf("Payload verification: Failure\n");
    }
}

int main() {
    voice_queue_t voice_queue;
    init_voice_queue(&voice_queue);

    // 测试构建数据包
    vmpkt_t test_pkt;
    v_build_pkt(&test_pkt, 1, 0, 0x0A0B, (const unsigned char *)"Test payload", 12);
    enqueue_voice(&voice_queue, &test_pkt);

    // 测试处理数据包
    vmpkt_t rx_pkt;
    memcpy(&rx_pkt, &test_pkt, sizeof(vmpkt_t));
    v_handle_rx_pkt((const unsigned char*)&rx_pkt, sizeof(vmpkt_t), &rx_pkt);

    // 测试用例
    test_voice_module();

    return 0;
}

说明

1. 语音模块队列: 我们定义了一个使用静态数组实现的简单队列，名为 voice_queue_t。
2. 初始化队列: init_voice_queue 函数用于初始化队列。
3. 向队列添加数据包: enqueue_voice 函数用于向队列尾部添加数据包。
4. 从队列移除数据包: dequeue_voice 函数用于从队列头部移除数据包。
5. 测试用例: test_voice_module 函数用于验证构建和处理数据包的功能。

注意事项

• 队列的大小定义为 VOICE_QUEUE_SIZE，可以根据需要进行调整。
• 在实际应用中，您可能需要实现串口读写函数以与硬件进行交互，并且可能需要对队列操作进行同步处理，以保证多线程环境下的正确性。

请根据您的具体需求调整这些代码，例如添加错误处理逻辑或实现串口读写函数以与硬件进行交互。