串口V2使用消息队列接收，线程假死问题

发布于 2022-09-01 13:59:47 浏览：1067 订阅该版

硬件：STM32F429IGT6核心板
操作系统：RTT V4.1.5
串口框架：使用串口V2。配置如下
![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20220901/4c133bd63007bb102fbb8b331cb6e0ee.png)
/* 以 DMA 接收及轮询发送方式打开串口设备 */
rt_device_open(serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
使用场景：使用MODBUSRTU通信协议。上位机1ms时间间隔发送数据，串口线程读取后处理并返回。
问题点：1.串口线程来不及接收消息队列内容，导致线程阻塞，假死。
复现情况：PWM中断开启，优先级为1.
串口中断优先级为2.DMA优先级为0.
发送100Khz以下频率，通信正常感受不到延时。
发送100KhZ以上频率，发送一小会，串口通信正常。持续发送，串口通信掉线。
调整PWM中断优先级为3.发送100khz频率以上，通信不掉线。

问题点：2.DEBUG的时候，触发断点不继续运行。上位机串口发送数据没有关闭，持续一会在继续运行程序。这时也会导致线程假死。甚至系统崩溃，触发看门狗。

问题点：3.下载代码的时候。上位机串口发送数据没有关闭，这时也会导致线程假死。甚至系统崩溃，触发看门狗。

使用DEBUG断点查看，线程假死后，上位机发送数据，可以进入接收回调函数。
但是断点在线程中，始终无法进入线程。
怀疑是消息队列满了，无法处理导致假死。尝试过对消息队列清空，失败了。
另一个是怀疑串口V2的缓存满了没有清空，尝试过清空对应的ringbuffer缓存，也失败了。

请不要说是串口线程太卡了，接收太慢处理不过来。
我想知道的是，线程假死后怎么恢复。
或者说是消息队列没处理过来的话怎么保证线程不会异常，可以抛弃消息队列内的所有内容。

代码如下。其中的信号量与互斥量取消过。没有改善。
```c
/**
  * @brief  MODBUS线程
  * @param  p:无用，不定义创建线程有警告
  * @retval None.
  * @note   None.
*/
static void modbus_thread(void* p)
{
  //初始化modbusRTU，从站地址为0x01,波特率为115200，无校验。
  eMBRTUInit(&ucRTU_DCB,&ucMB_RTU_PORT,SLAVE_ADDRESS,BAUD_RATE,MB_PAR_NONE); 
  eMBRTUStart(&ucRTU_DCB);
  //F4使能空闲中断不会立马进入中断函数进行状态转换，手动切换
  ucRTU_DCB.eRcvState = STATE_RX_IDLE;
  while(1)
  {
    struct rx_msg msg;
    rt_memset(&msg, 0, sizeof(msg));
    /* 从消息队列中读取消息 */
    rt_err_t result = rt_mq_recv(rx_mq, &msg, sizeof(msg), RT_WAITING_FOREVER);
    if (result == RT_EOK)
    {
        /* 从串口读取数据 */
        rt_uint32_t rx_length = rt_device_read(msg.dev, 0,(CHAR *)ucRTU_DCB.ucBuffer, msg.size);
        if(rx_length != msg.size)
        {
          LOG_W("Incorrect receive length");
          break;
        }
        else
        {
          ucRTU_DCB.ucBufferCount = msg.size;               //写入读取大小
          xMBPortEventPost(&ucRTU_DCB,EV_FRAME_RECEIVED);   //改变事件状态为接收事件
          rt_mutex_take(mb_slave_mutex, RT_WAITING_FOREVER);//保存内存
          eMBRTUPoll(&ucRTU_DCB);                           //读写内存
          rt_mutex_release(mb_slave_mutex);                 //允许操作内存
          rt_sem_release(mb_buff_sem);                      //释放MB处理线程信号量
        }
    }
  }
}
/*******************************************串口收发处理函数*********************************************************************/
/**
 * @brief This function will set the reception indication callback function. This callback function
 *        is invoked when this device receives data.
 *
 * @param dev is the pointer of device driver structure.
 *
 * @param rx_ind is the indication callback function.
 *
 * @return RT_EOK
 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    struct rx_msg msg;
    rt_err_t result;
    msg.dev = dev;
    msg.size = size;

result = rt_mq_send(rx_mq, &msg, sizeof(msg));
    if (result == -RT_EFULL)
    {
        /* 消息队列满 */
        LOG_E("message queue full!");
    }
    return 1;
}
/**
  * @brief  串口接收函数.
  * @param  buf:接收缓存
  * @param  bufsz:接收缓存大小
  * @retval 接收长度。-1表示接受失败
  * @note   消息队列阻塞接收，一直等待消息到来
*/
static int serial_receive(uint8_t *buf, int bufsz)
{
    struct rx_msg msg;
    rt_err_t result;
    rt_uint32_t rx_length;

while (1)
    {
        rt_memset(&msg, 0, sizeof(msg));
        /* 从消息队列中读取消息 */
        result = rt_mq_recv(rx_mq, &msg, sizeof(msg), RT_WAITING_FOREVER);
        if (result == RT_EOK)
        {
            /* 从串口读取数据 */
            rx_length = rt_device_read(msg.dev, 0, buf, msg.size);
            /* 打印数据 */
//            LOG_HEX(UART_NAME,8,buf,rx_length);
            return rx_length;
        }
    }
}
/**
  * @brief  串口发送函数..
  * @param  buf:发送缓存
  * @param  bufsz:发送缓存大小
  * @retval 成功：1，失败：0
  * @note   None.
*/
static int serial_send(uint8_t *buf, int len)
{
  rt_size_t send_len = 0; 
  /* 通过串口设备 serial 输出读取到的消息 */
  send_len = rt_device_write(serial, 0, buf, len);
  if(send_len == len)
  {
    return 1;
  }
  else
  {
    LOG_E("send failed");
    return 0;
  }
}
/**
  * @brief  modbus 从机1 初始化
  * @param  None.
  * @retval None.
  * @note   None.
*/
static int Modbus_Slave1_Init(void)
{
    rt_err_t ret = RT_EOK;
    struct rx_msg msg;
    /* 初始化消息队列 */
    rx_mq = rt_mq_create("mbs1ave1",
                         sizeof(struct rx_msg),    /* 一条消息的最大长度 */
                         BSP_UART1_RX_BUFSIZE,     /* 存放消息的缓冲区大小 */
                         RT_IPC_FLAG_FIFO);

/* 查找串口设备 */
    serial = rt_device_find(UART_NAME);
    if (!serial)
    {
        rt_mq_detach(rx_mq);
        LOG_E("find %s failed!", UART_NAME);
        return RT_ERROR;
    }
               
    /* 创建一个动态互斥量 */
    mb_slave_mutex = rt_mutex_create("mb slave", RT_IPC_FLAG_PRIO);
    if (mb_slave_mutex == RT_NULL)
    {
        LOG_E("create mb_slave_mutex failed.");
        return -1;
    }
    
    /* 创建 MODBUS从机线程*/
    rt_thread_t thread = rt_thread_create( UART_NAME,         /* 线程名字 */
                                           modbus_thread,     /* 线程入口函数 */
                                           RT_NULL,           /* 线程入口函数参数 */
                                           THREAD_STACK_SIZE, /* 线程栈大小 */
                                           THREAD_PRIORITY,   /* 线程的优先级 */
                                           THREAD_TIMESLICE); /* 线程时间片 */
    /* 创建成功则启动线程 */
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }
    else
    {
        ret = RT_ERROR;
        LOG_E("modbus slave created failed.");
    }

return ret;
}
/* 导出到 msh 命令列表中 */
INIT_APP_EXPORT(Modbus_Slave1_Init);
```