T536_DTU/app_public/bluetooth/bluetooth.c

#include "head.h"
#include "bluetooth.h"

// #define BL_DEBUG                                // 调试打印
#define FREAM_SPLIT_LEN             (240)       // 分帧长度
#define FREAM_INTERVAL_TIME_MS      (65)        // 帧间隔ms，手册建议帧间隔60ms以上
#define BL_DISC_REBOOT_TIME_MS      (100)       // 连接断开复位蓝牙延时ms
#define BL_IDLE_REBOOT_TIME_MS      (120000)    // 蓝牙空闲状态自动复位延时ms

#define BL_ENABLE_RESEND_MODE       (1)         // 重发机制
#define BL_RESEND_TIMES             (3)         // 重发次数
#define BL_RECV_TIMEOUT_MS          (500)       // 接收超时时间
#define BL_TIMEOUT_RESEND_MS        (500)       // 超时重发时间

#define BLUETOOTH_DEFAULT_NAME      "OLE-DTUv5" // 蓝牙默认名称，获取ID失败时设置此蓝牙名称

/* 各指令详细描述请参考蓝牙手册,路径:Z:\研发中心\研发二部\共享\88_DTU5.0\02蓝牙模块 */
/* AT指令匹配列表 */
const struct at_cmd_index_match at_cmd_index_match[AT_CMD_MAX] = 
{
    //指令字符串  追加字符串 指令结束字符串  数据段结束字符串 指令结果结束字符串    指令匹配的枚举类型
    {"SCAN"		,	"="	,   "{\r\n"	,       "}\r\n" ,       NULL	    ,       AT_CMD_SACN     },
	{"CONN"		,	"="	,   "="	    ,       NULL	,       NULL	    ,       AT_CMD_CONN     },
	{"CHINFO"	,	""  ,   "{\r\n"	,       "}\r\n"	,       "OK\r\n"    ,       AT_CMD_CHINFO   },
	{"LESEND"	,	"=" ,   "\r\n"	,       NULL	,       "OK\r\n"	,       AT_CMD_LESEND   },	
	{"LEDISC"	,	"="	,   "="	    ,       "\r\n"  ,       NULL	    ,       AT_CMD_LEDISC   },	
	{"NAME"		,	"="	,   "="	    ,       "\r\n"  ,       "OK\r\n"	,       AT_CMD_NAME     },	
	{"MAC"		,	""	,   "="	    ,       "\r\n"	,       "OK\r\n"	,       AT_CMD_MAC      },
	{"REBOOT"	,	""	,   "\r\n"	,       NULL	,       "OK\r\n"	,       AT_CMD_REBOOT   },
    {"DATA"	    ,	""	,   "="	    ,       "\r\n"	,       NULL	    ,       AT_CMD_DATA     },
    {"GATTSTAT"	,	""	,   "="	    ,       "\r\n"	,       NULL	    ,       AT_CMD_STAT     },
};

/**
 * @brief   获取一个buf
 * @details 从缓存队列中返回一个buf
 * @param   _pt 结构体指针
 * @return  buf索引
 * @author  EWen
 * @date    2025-10-11
 * @remarks 增加发送队列缓存是考虑到多帧分帧放进缓存后自动发送，但目前报文组帧处理了可以一帧发完，暂时用不上
 */
static u8 _get_one_buf(bl_tbuf_t *pt)
{
    u8 head;

    head = pt->tb_head;
    pt->tb_head++;
    if (pt->tb_head >= BL_TBUF_NUM)
    {
        pt->tb_head = 0;
    }

    // 系统设计时，保证缓冲不会满，以下情况不应出现
    if (pt->tb_head == pt->tb_tail_ack || pt->tb_head == pt->tb_tail_send)
    {
        rt_printf_time("bluetooth: _get_one_buf error:head=%d,send=%d,ack=%d.\r\n", pt->tb_head, pt->tb_tail_send, pt->tb_tail_ack);
    }

    return head;
}

/**
 * @brief   确认一条发送的报文
 * @details none
 * @param   _pt 结构体指针
 * @param   _cmd_type 接收到的报文类型
 * @return  none
 * @author  EWen
 * @date    2025-10-11
 * @remarks Tnone
 */
static void _ack_one_buf(bl_tbuf_t *pt, s8 _cmd_type)
{
    if (_cmd_type == AT_CMD_DATA)
    {
        // 蓝牙模块主动发送的数据不需进行发送确认
        return;
    }

    if (_cmd_type == AT_CMD_STAT)
    {
        u8 send_cmd_index;
        send_cmd_index = (pt->tb_tail_ack + 1) >= BL_TBUF_NUM ? 0 : (pt->tb_tail_ack + 1);
        // 不是因终端主动发起的命令而收到AT_CMD_STAT类型数据不需确认
        if (pt->tb_cmd[send_cmd_index] != AT_CMD_CONN || pt->tb_cmd[send_cmd_index] != AT_CMD_LEDISC)
            return;
    }

    pt->tb_tail_ack++;
    if (pt->tb_tail_ack >= BL_TBUF_NUM)
        pt->tb_tail_ack = 0;

#ifdef BL_DEBUG
    rt_printf("ack tb_head=%d,tb_tail_send=%d,tb_tail_ack=%d\r\n", pt->tb_head, pt->tb_tail_send, pt->tb_tail_ack);
#endif
}

/**
 * @brief   组帧
 * @details none
 * @param   _pt 结构体指针
 * @param   _pdat 数据指针
 * @param   _cmd 组帧类型
 * @param   _len 数据长度
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks 目前格式字符填充部分最长长度为数据发送格式填充18字节
 */
static int _frame_packing(BLUETOOTH_DEF *_pt, const u8 *_pdat, AT_CMD _cmd, u8 _len)
{
    u8 i = 0;
    u8 head = 0;
    u8 *pd = NULL;
    u8 ext_len = 0;
    u8 str_len = 0;

    // 目前格式字符填充部分最长长度为数据发送格式填充18字节
    // 组帧buf首字节为发送长度因此再 -1
    if (_len >= BL_TBUF_LEN - 18 - 1)
    {
        rt_printf("蓝牙->%s 组帧数据长度越限,in len=%d,max=%d\r\n", __func__, _len, BL_TBUF_LEN - 19);
        return -1;
    }

    // 匹配at命令
    for (i = 0; i < AT_CMD_MAX; i++)
    {
        if (at_cmd_index_match[i].cmd == _cmd)
            break;
    }

    if (i == AT_CMD_MAX)
    {
        rt_printf("bluetooth: %s error! can't find cmd %d\r\n", __func__, _cmd);
        return -2;
    }

    head = _get_one_buf(&_pt->tx_buf[0]);

    _pt->tx_buf[0].tb_cmd[head] = _cmd;

    pd = &_pt->tx_buf[0].tb_data[head][1];

    // 固定头
    strcpy(pd, "AT+");
    pd += 3;
    ext_len += 3;

    // 根据_cmd 填充命令
    str_len = strlen(at_cmd_index_match[i].cmd_str);
    strncpy(pd, at_cmd_index_match[i].cmd_str, str_len);
    pd += str_len;
    ext_len += str_len;

    // 根据可选字符填充
    if (at_cmd_index_match[i].send_op_str)
    {
        str_len = strlen(at_cmd_index_match[i].send_op_str);
        strncpy(pd, at_cmd_index_match[i].send_op_str, str_len);
        pd += str_len;
        ext_len += str_len;
    }

    // 填充长度数据
    if (_cmd == AT_CMD_LESEND)
    {
        u8 tmp_len[6] = {0};

        *pd++ = '0';
        *pd++ = ',';
        ext_len += 2;

        sprintf(tmp_len, "%d", _len);
        str_len = strlen(tmp_len);
        strncpy(pd, tmp_len, str_len);
        pd += str_len;
        ext_len += str_len;

        *pd++ = ',';
        ext_len += 1;
    }

    // 填充发送数据
    if (_pdat)
    {
        memcpy(pd, _pdat, _len);
        pd += _len;
    }

    // 固定尾
    strcpy(pd, "\r\n");
    ext_len += 2;

    // 首字节为需发送报文长度
    _pt->tx_buf[0].tb_data[head][0] = _len + ext_len;

#ifdef BL_DEBUG
    rt_printf_time("%s data:%d,ext:%d\r\n", __func__, _len, ext_len);
    for (i = 0; i < _len + ext_len; i++)
    {
        if (i != 0 && i % 16 == 0)
            rt_printf("\r\n");
        rt_printf("%02x ", _pt->tx_buf[0].tb_data[head][i + 1]);
    }
    rt_printf("\r\n");
#endif

    return 0;
}

/**
 * @brief   设置蓝牙名称
 * @details none
 * @param   _pt 结构体指针
 * @param   _pdat 名称字符串指针
 * @param   _len 名称长度
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
static int _name_set(BLUETOOTH_DEF *pt, const u8 *_pdat, u8 _len)
{
    return _frame_packing(pt, _pdat, AT_CMD_NAME, _len);
}

/**
 * @brief   蓝牙模块软重启
 * @details none
 * @param   _pt 结构体指针
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
static int _reboot(BLUETOOTH_DEF *pt)
{
    return _frame_packing(pt, NULL, AT_CMD_REBOOT, 0);
}

/**
 * @brief   断开蓝牙连接
 * @details none
 * @param   _pt 结构体指针
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks 已连接状态才起作用，否则蓝牙模块不回复
 */
static int _ledisc(BLUETOOTH_DEF *pt)
{
    const u8 para = '0'; // 固定为 "0"

    if (!pt->lnk_sta)
    {
        // 非连接状态下发送断开连接命令，蓝牙模块不会回复报文
        rt_printf("非连接状态下不能进行断开连接操作!\r\n");
        return -1;
    }

    return _frame_packing(pt, &para, AT_CMD_LEDISC, 1);
}

/**
 * @brief   接收数据复位
 * @details none
 * @param   _pt 结构体指针
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
static void _recv_rst(BLUETOOTH_DEF *pt, u8 num)
{
    if (num == 10)
    {
        rt_printf_time("接收帧错误,超时未能接收到帧结束符号!!!\r\n");
    }
    if (pt->cTypeCounter)
    {
        rt_printf_time("bluetooth_recv_rst:state=%d,counter=%d,num=%d\r\n", pt->cTypeCounter, pt->cRecvCnt, num);
    }

    pt->cTypeCounter = 0;
    pt->cRecvLenth = 0;
    pt->cRecvCnt = 0;

    pt->us0_recv = 0;
}

/**
 * @brief   蓝牙接收数据解析
 * @details 判断是否接收到完整一帧
 * @param   _pt 结构体指针
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
static int _recv_parse(BLUETOOTH_DEF *pt, u8 c)
{
    u8 i = 0;
    u8 match_count = 0;

    switch (pt->cTypeCounter)
    {
    case 0:
        if (c == '+') // 固定起始符号
        {
            pt->cmd_type = -1;
            pt->cTypeCounter++;
            pt->us0_recv = bsp_ustimer_get_origin();
            memset(pt->cmd_recvbuf, '\0', sizeof(pt->cmd_recvbuf));
        }
        else
        {
            _recv_rst(pt, 1);
        }
        break;
    case 1:
        pt->cmd_recvbuf[pt->cRecvCnt++] = c;

        if (pt->cRecvCnt >= CMD_RECVBUF_LEN)
        {
            _recv_rst(pt, 2);
            rt_printf_time("接收指令错误，指令长度溢出!!!\r\n");
            break;
        }

        // 最短命令匹配字符MAC
        if (pt->cRecvCnt < 3)
        {
            break;
        }

        // 命令未匹配
        if (pt->cmd_type == -1)
        {
            for (i = 0; i < AT_CMD_MAX; i++)
            {
                // 匹配命令
                if (strstr(at_cmd_index_match[i].cmd_str, pt->cmd_recvbuf) != NULL)
                {
                    match_count++;
                    pt->cmd_type = at_cmd_index_match[i].cmd;
                    break;
                }
            }

            // 3个字符都未能匹配一条，不支持命令，重新接收
            if (match_count == 0)
            {
                rt_printf("蓝牙接收->不支持的指令:%s\r\n", pt->cmd_recvbuf);
                pt->cmd_type = -1;
                _recv_rst(pt, 3);
                break;
            }
            else if (match_count > 1)
            {
                // 多条匹配继续接收匹配
                pt->cmd_type = -1;
            }
        }
        else
        {
            if (strstr(pt->cmd_recvbuf, at_cmd_index_match[pt->cmd_type].cmd_end_str) != NULL)
            {
#ifdef BL_DEBUG
                pt->cmd_recvbuf[pt->cRecvCnt - 1] = '\0';
                rt_printf("recv cmd:%s\r\n", pt->cmd_recvbuf);
#endif
                // 命令结束,转入下一流程
                pt->cRecvCnt = 0;
                pt->cTypeCounter++;
                memset(pt->recvbuf, 0, sizeof(pt->recvbuf));

                _ack_one_buf(&pt->tx_buf[0], pt->cmd_type);
            }
        }
        break;
    case 2:
        if (at_cmd_index_match[pt->cmd_type].data_end_str)
        {
            // 此帧包含数据
            pt->recvbuf[pt->cRecvCnt++] = c;
            if (pt->cRecvCnt >= BLUETOOTH_BUF_LEN)
            {
                _recv_rst(pt, 4);
                rt_printf("蓝牙接收->数据长度溢出!!!\r\n");
                break;
            }

            if (c == '\n')
            {
                if (strstr(&pt->recvbuf[pt->cRecvCnt - strlen(at_cmd_index_match[pt->cmd_type].data_end_str)], at_cmd_index_match[pt->cmd_type].data_end_str) != NULL)
                {
#ifdef BL_DEBUG
                    int i = 0;
                    rt_printf("recv data:\r\n");
                    for (i = 0; i <= pt->cRecvCnt - 1; i++)
                    {
                        if (i % 16 == 0 && i != 0)
                            rt_printf("\r\n");
                        rt_printf("%02x ", pt->recvbuf[i]);
                    }
                    rt_printf("\r\n");
#endif

                    if (at_cmd_index_match[pt->cmd_type].sta_end_str)
                    {
                        pt->cRecvCnt = 0;
                        pt->cTypeCounter++;
                    }
                    else
                    {
                        pt->bData = true;
                        pt->cTypeCounter = 0;
                        _recv_rst(pt, 5);
                    }
                }
            }
        }
        else if (at_cmd_index_match[pt->cmd_type].sta_end_str)
        {
            // 结果判断
            pt->cTypeCounter++;
            pt->cmd_recvbuf[pt->cRecvCnt++] = c;
        }
        else
        {
            _recv_rst(pt, 6);
            rt_printf("%s %d unknowd operation!\r\n", __func__, __LINE__);
        }
        break;
    case 3:
        // 结果
        pt->cmd_recvbuf[pt->cRecvCnt++] = c;
        if (c == '\n')
        {
#ifdef BL_DEBUG
            rt_printf("recv statue:%s", pt->cmd_recvbuf);
#endif

            if (strstr(pt->cmd_recvbuf, "OK\r\n") != NULL)
            {
                pt->cmd_sta = true;
                if (at_cmd_index_match[pt->cmd_type].data_end_str)
                {
                    pt->bData = true;
                }
            }
            else
            {
                rt_printf("蓝牙->执行%s->%s失败!!\r\n", at_cmd_index_match[pt->cmd_type].cmd_str, pt->cmd_recvbuf);
            }

            pt->cTypeCounter = 0;
            _recv_rst(pt, 7);
        }
        break;

    default:
        _recv_rst(pt, 8);
        break;
    }

    return 0;
}

/**
 * @brief   接收应用
 * @details 从fifo提取数据去解析
 * @param   _pt 结构体指针
 * @return  none
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
static void _recv_app(BLUETOOTH_DEF *pt)
{
    u8 c;
    // 接收数据
    while (pt->bData == false)
    {
        if (rt_fifo_get(&pt->recv_fifo, &c, 1) == 0)
        {
            if (pt->b_recv_reset)
            {
                _recv_rst(pt, 10);
                pt->b_recv_reset = 0;
            }

            break;
        }

        _recv_parse(pt, c);
    }
}

/**
 * @brief   蓝牙接收数据解析
 * @details 数据接收判断时已将"+DATA="去除
 * @param   _pt 结构体指针
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks 数据内容格式：+DATA=para1,para2,para3; para1：固定值0，para2：接收的数据长度，para3：接收的数据内容
 */
static int _data_parse(BLUETOOTH_DEF *pt)
{
    u16 i = 0;
    u8 *pd = NULL;
    char *endptr;
    u16 data_len = 0;
    u8 len_str[5] = {0};

    // 固定开头为 "0,"
    if (pt->recvbuf[0] != '0' || pt->recvbuf[1] != ',')
    {
        rt_printf("%s data format error!\r\n", __func__);
        return -1;
    }

    // 解析长度字符串
    pd = &pt->recvbuf[2];
    for (i = 0; i < 5; i++)
    {
        len_str[i] = *pd++;
        // 长度字符串以","结束，跳过","
        if (*pd == ',')
        {
            pd++;
            break;
        }
    }

    if (i == 5)
    {
        rt_printf("%s lenth error!\r\n", __func__);
        return -2;
    }
    else
    {
        data_len = strtol(len_str, &endptr, 10);
        if (*endptr != '\0')
        {
            rt_printf("%s lenth strtol failed!\r\n", __func__);
            return -3;
        }
#ifdef BL_DEBUG
        rt_printf("%s data_len:%d\r\n", __func__, data_len);
#endif
    }

    for (i = 0; i < data_len; i++)
    {
        u8 j;
        int ret;

        ret = sec_recv(&pt->rx_buf, *pd++, pt->arrSendBuf, false);
        if (ret == SEC_FRAME_OK_APP) // 带规约的报文
        {
            rt_printf("未实现的蓝牙通讯帧处理->SEC_FRAME_OK_APP\r\n");
        }
        else if (ret == SEC_FRAME_OK_EXT) // 纯安全扩展报文 发送
        {
            u16 remaining_length = 0;

            // 前两个字节为加密返回报文的长度
            remaining_length = ((pt->arrSendBuf[0] << 8) + (pt->arrSendBuf[1]));
#ifdef BL_DEBUG
            rt_printf("esam data len->%d\r\n", remaining_length);
#endif
            // 分帧
            // TODO 直接将报文分帧有较大几率证书管理工具会报错，此处已在加密报文处理中将每帧证书长度修改为220处理
            // 可以在一帧报文中将加密安全扩展报文发送，如确实需分帧的话要按照加密报文分帧处理再分帧，此处没有处理。。。
            if (remaining_length > FREAM_SPLIT_LEN)
            {
                for (j = 0;; j++)
                {
                    if (remaining_length <= FREAM_SPLIT_LEN)
                    {
                        _frame_packing(pt, pt->arrSendBuf + 2 + j * FREAM_SPLIT_LEN, AT_CMD_LESEND, (u8)remaining_length);
                        break;
                    }
                    _frame_packing(pt, pt->arrSendBuf + 2 + j * FREAM_SPLIT_LEN, AT_CMD_LESEND, FREAM_SPLIT_LEN);
                    remaining_length -= FREAM_SPLIT_LEN;
                }
            }
            else
            {
                _frame_packing(pt, pt->arrSendBuf + 2, AT_CMD_LESEND, (u8)remaining_length);
            }
        }
    }

    return 0;
}

/**
 * @brief   蓝牙连接状态解析
 * @details none
 * @param   _pt 结构体指针
 * @return  0：成功 其它：失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks 数据格式0,0 1 2
 */
static int _status_parse(BLUETOOTH_DEF *pt)
{
    // 固定开头为 "0,"
    if (pt->recvbuf[0] != '0' || pt->recvbuf[1] != ',')
    {
        rt_printf("%s data format error!\r\n", __func__);
        return -1;
    }

    if (pt->recvbuf[2] == '1')
    {
        // 连接断开
        pt->lnk_sta = false;
        rt_printf("蓝牙连接断开!\r\n");
        pt->us0_disc_reboot = bsp_ustimer_get_origin();
    }
    else if (pt->recvbuf[2] == '2')
    {
        // 正在连接
        rt_printf("蓝牙连接中...\r\n");
    }
    else if (pt->recvbuf[2] == '3')
    {
        // 已连接
        pt->lnk_sta = true;
        rt_printf("蓝牙已连接!\r\n");
    }
    else
    {
        // 未知的连接状态
        rt_printf_time("蓝牙连接状态解析错误,未知的状态%d%d%d!\r\n", pt->recvbuf[0], pt->recvbuf[1], pt->recvbuf[2]);
        return -2;
    }

    return 0;
}

/**
 * @brief   蓝牙名称设置解析
 * @details 解析名称设置结果
 * @param   _pt 结构体指针
 * @return  none
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
static void _name_set_parse(BLUETOOTH_DEF *pt)
{
    rt_printf("设置蓝牙名称:%s%s\r\n", pt->recvbuf, pt->cmd_sta ? "成功!" : "失败!");
}

/**
 * @brief   蓝牙数据初始化
 * @details none
 * @param   _pt 结构体指针
 * @param   chnl 通道
 * @return  0: 成功 其它: 失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
int bluetooth_init(BLUETOOTH_DEF *pt, u8 chnl)
{
    u8 name_buf[30] = {0};
    RMT_FIXED_TABLE tfixedset;

    memset(pt, 0, sizeof(BLUETOOTH_DEF));
    memset(&tfixedset, 0, sizeof(tfixedset));
    tfixedset.num = RMT_FIXED_SET_NUM;
    tfixedset.set[0].type = FIXED_SET_ID;
    iec_get_fixedset_csv(&tfixedset);

    // 初始化接收buf结构
    pt->chnl = chnl;
    pt->rx_buf.chn = pt->chnl;
    pt->rx_buf.buf = pt->esambuf;
    rt_fifo_init(&pt->recv_fifo, pt->recv_fifo_buf, BLUETOOTH_BUF_LEN);

    if (tfixedset.set[0].len == 24)
    {
        /* ID 标准定义24位 */
        rt_printf("设置蓝牙名称:%s\r\n", tfixedset.set[0].str);
        memcpy(name_buf, tfixedset.set[0].str, tfixedset.set[0].len);
    }
    else
    {
        strcpy(name_buf, BLUETOOTH_DEFAULT_NAME);
        rt_printf("蓝牙: 未能从fixset.csv中获取到正确ID,使用默认名称:%s.\r\n", BLUETOOTH_DEFAULT_NAME);
    }

    _name_set(pt, name_buf, strlen(name_buf));
    _reboot(pt);

    return 0;
}

/**
 * @brief   蓝牙数据接收
 * @details 将数据存入fifo中
 * @param   _pt 结构体指针
 * @param   _byte 数据
 * @return  none
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
void bluetooth_recv(BLUETOOTH_DEF *pt, u8 _byte)
{
    rt_fifo_put(&pt->recv_fifo, &_byte, 1);
}

/**
 * @brief   发送检查
 * @details none
 * @param   _pt 结构体指针
 * @return  none
 * @author  EWen
 * @date    2025-10-11
 * @remarks 帧间隔延时精度受扫描间隔影响，实际测试到1000ms间隔发送也没什么问题
 */
static void _send_polling(BLUETOOTH_DEF *_pt)
{
    u8 *buf;
    u16 i = 0;
    u16 len = 0;
    u8 *pd, tb_send;
    bl_tbuf_t *pbuf;

    pbuf = &_pt->tx_buf[0];
#if BL_ENABLE_RESEND_MODE
    // 上一帧未收到回复
    if (pbuf->tb_tail_send != pbuf->tb_tail_ack)
    {
        // 未超时不发下一帧
        if (bsp_ustimer_get_duration(_pt->us0_cfmtimeout) < USTIMER_MS * BL_TIMEOUT_RESEND_MS)
        {
            // tb_tail_send != tb_tail_ack,说明已进行过报文发送即更新过_pt->us0_cfmtimeout
            // 所以此处直接判断延时是否超时也没有问题
            return;
        }
        else
        {
            // 重发次数到达不再重发
            if (_pt->resend_cnt >= BL_RESEND_TIMES)
            {
                _pt->resend_cnt = 0;
                memset(_pt->tx_buf, 0, sizeof(_pt->tx_buf));
                return;
            }

            // 超时重发
            pbuf->tb_tail_send--; // 发送尾索引回上一帧的位置进行重发
            _pt->resend_cnt++;
            rt_printf_time("超时重发上一帧,重发次数=%d,tb_head=%d,tb_tail_send=%d,len=%d\r\n", _pt->resend_cnt, pbuf->tb_head, pbuf->tb_tail_send, pbuf->tb_data[pbuf->tb_tail_send][0]);
            for (i = 0; i < pbuf->tb_data[pbuf->tb_tail_send][0]; i++)
            {
                if (i != 0 && i % 16 == 0)
                    rt_printf("\r\n");
                rt_printf("%02x ", pbuf->tb_data[pbuf->tb_tail_send][i + 1]);
            }
            rt_printf("\r\n");
        }
    }
#endif
    // 如果串口忙或者帧间隔时间未到，不能发送数据
    if (g_tRsComm[_pt->chnl].bextsend || bsp_ustimer_get_duration(_pt->us0_sendpiece) < USTIMER_MS * FREAM_INTERVAL_TIME_MS)
    {
        return;
    }

    if (pbuf->tb_head == pbuf->tb_tail_send)
    {
        return;
    }

    // 更新发送尾指针,保留老指针备用。
    tb_send = pbuf->tb_tail_send;
    pbuf->tb_tail_send++;
    if (pbuf->tb_tail_send >= BL_TBUF_NUM)
    {
        pbuf->tb_tail_send = 0;
    }
#ifdef BL_DEBUG
    rt_printf("send tb_head=%dtb_tail_send=%dtb_tail_ack=%d\r\n", pbuf->tb_head, pbuf->tb_tail_send, pbuf->tb_tail_ack);
#endif
    // 将数据复制到真正发送的buf
    len = pbuf->tb_data[tb_send][0];
    pd = g_tRsComm[_pt->chnl].extsendbuf;
    memcpy(pd, &pbuf->tb_data[tb_send][1], len);
    g_tRsComm[_pt->chnl].extsendcnt = 0;
    g_tRsComm[_pt->chnl].extsendlen = len;
    g_tRsComm[_pt->chnl].bextsend = true;
#ifdef BL_DEBUG
    {
        rt_printf_time("bluetooth send data:%d\r\n", len);
        for (i = 0; i < len; i++)
        {
            if (i != 0 && i % 16 == 0)
                rt_printf("\r\n");
            rt_printf("%02x ", g_tRsComm[_pt->chnl].extsendbuf[i]);
        }
        rt_printf("\r\n");
    }
#endif

    _pt->us0_cfmtimeout = _pt->us0_sendpiece = bsp_ustimer_get_origin();
}

/**
 * @brief   蓝牙应用巡检
 * @details none
 * @param   _pt 结构体指针
 * @return  0：成功 其它：失败
 * @author  EWen
 * @date    2025-10-11
 * @remarks none
 */
int bluetooth_app(BLUETOOTH_DEF *pt)
{
    _recv_app(pt);

    if (pt->bData)
    {
        switch (pt->cmd_type)
        {
        case AT_CMD_DATA:
            _data_parse(pt);
            break;
        case AT_CMD_STAT:
            _status_parse(pt);
            break;
        case AT_CMD_NAME:
            _name_set_parse(pt);
            break;
        default:
            rt_printf("%s 未支持的指令类型->%d\r\n", __func__, pt->cmd_type);
            break;
        }
        pt->bData = false;
    }

    _send_polling(pt);

    return 0;
}

/**
 * @brief   蓝牙定时器
 * @details 处理一些定时任务
 * @param   _pt 结构体指针
 * @return  none
 * @author  EWen
 * @date    2025-10-11
 * @remarks 延时精度受扫描间隔影响，但实际在此处理的操作实时性要求不高，因此没有关系
 */
void bluetooth_timer(BLUETOOTH_DEF *pt)
{
    if (pt->us0_disc_reboot)
    {
        if (bsp_ustimer_get_duration(pt->us0_disc_reboot) >= BL_DISC_REBOOT_TIME_MS * USTIMER_MS)
        {
            _reboot(pt);
            pt->us0_disc_reboot = 0;
        }
    }

    if (pt->lnk_sta)
    {
        pt->us0_idle_reboot = 0;
    }
    else
    {
        if (pt->us0_idle_reboot == 0)
        {
            pt->us0_idle_reboot = bsp_ustimer_get_origin();
        }
        else
        {
            if (bsp_ustimer_get_duration(pt->us0_idle_reboot) >= BL_IDLE_REBOOT_TIME_MS * USTIMER_MS)
            {
                _reboot(pt);
                pt->us0_idle_reboot = 0;
            }
        }
    }

    if (pt->us0_recv)
    {
        if (bsp_ustimer_get_duration(pt->us0_recv) >= BL_RECV_TIMEOUT_MS * USTIMER_MS)
        {
            pt->us0_recv = 0;
            pt->b_recv_reset = true;
        }
    }
}