20 rt_thread_resume failed

发布于 2021-08-14 15:22:01 浏览：1125 订阅该版

[tocm]

### **最终目的：**
- 通过无线接收数据（中断中接收），然后将数据通过mqtt发送出去，并将数据更新至显示屏

### **实现方法**
- 参照rtthread系统中 **rt_slist_t**结构创建一个单向链表，每个要显示的数据都会放置在这个链表的末端，称为显示缓冲区。
- 创建显示屏刷新任务**thread_screen_refresh**：显示屏使用迪文串口屏，每屏最多显示 9 条数据，要显示的这9条数据定义为结构体数组，称为显存，显示屏固定 7s 间隔将当前显存更新与显示屏。
- 创建显示缓存链表数据检查任务**thread_screen_datacheck**：数据通过中断接收时会产生一个 rt_tick_get(); 并将这个数据放置在链表的末端，这个线程的功能是，如果这个 tick 和当前 tick 相比大于10s；就是说这条数据的第一条收到了，超过10s第二条还没有收到，我会把这个数据从链表中删除。
- 创建显示屏缓存链表数据写入任务**thread_screen_datawrite**:中断接收通过消息队里将要添加到链表末端的数据结构传输给此线程，通过这个线程写入到链表末端。

### **流程图**
- 说的比较乱，我画个图说明一下。
![0.png](https://oss-club.rt-thread.org/uploads/20210814/e9bc4ff993eec2afbfd3a02f45af3a49.png.webp)

### **线程代码**
- **数据写入**
``` C
static void thread_screen_datawrite(void* param)
{   
    DisList_Type_Def temp_datawrite;
    
    while(1)
    {
        if(rt_mq_recv(p_mq_details_write, &temp_datawrite, sizeof(DisList_Type_Def), RT_WAITING_FOREVER) == RT_EOK)
        {
            /* write data */
            if(write_listdata_dis(p_displaylist_ctrl, &temp_datawrite) == RT_ERROR)
            {
                LOG_E("Write dis data error");
            }
        }
        else
        {
            rt_thread_delay(RT_TICK_PER_SECOND);
        }
    }
}
```

- **数据检查**
``` C
static void thread_screen_datacheck(void* param)
{
    while (1)
    {
        if(p_displaylist_ctrl->dislist_store != RT_NULL)
        {
            delete_listdata_dis(p_displaylist_ctrl);
            rt_thread_delay(RT_TICK_PER_SECOND * 3);
        }
        else
        {
            rt_thread_delay(RT_TICK_PER_SECOND * 3);
        }
    }
}
```
- **显示刷新**
``` C
// 定时器发送 sem 刷新
void callbakfunc_timer_refreshdetails(void* param)
{
    rt_sem_t p_sem_refreshdetails = param;

rt_sem_release(p_sem_refreshdetails);
}

static void thread_screen_refresh(void* param)
{
    while (1)
    {
        if(rt_sem_take(&sem_display_refresh, RT_WAITING_FOREVER) != RT_EOK)
        {
            LOG_E("sem_display_refresh take failed !");
            rt_thread_delay(RT_TICK_PER_SECOND);
        }

display_clear();
        refresh_details_mem();
        refresh_details();
        refresh_basicinfo(p_displaylist_ctrl->dislist_pagenum, p_system_time, netdev_default, p_mqttsend_devicestatus->client_param->mqtt_client_state);
    }
}
```
### **显示结构体**
``` C
/* display state union */
typedef union 
{
    rt_uint8_t uc;

struct 
    {
        rt_uint8_t b_chiptypeexist : 1;
        rt_uint8_t b_nameexist : 1;
        rt_uint8_t b_distanceexist : 1;
        rt_uint8_t b_voltageexist : 1;
        rt_uint8_t b_chiptype : 1;
        rt_uint8_t b_flagsos : 1;
        rt_uint8_t b_flagcall : 1;
        rt_uint8_t b_rev0:1;
    }param;
}DisplayState_Type_Def;

/* display content struct */
typedef struct 
{
    rt_slist_t dis_list;

DisplayState_Type_Def dis_state;
    rt_uint8_t dis_tagvol;
    rt_uint16_t dis_tagid;
    rt_uint32_t dis_tagdistance;
    rt_tick_t generate_tick;
    char dis_tagname[DISPLAY_NAME_MAX];
    rt_uint8_t tagname_len;
}DisList_Type_Def;

/* display ctrl struct */
typedef struct 
{
    DisList_Type_Def* dislist_store;
    DisList_Type_Def* dislist_read;
    rt_mp_t p_mempool_display;
    rt_uint8_t dislist_pagenum;
    rt_mutex_t muctexlock_dislist;
}DisCtrl_Type_Def;
```

### **应用接口代码**
- **初始化**
``` C
rt_err_t ini_listdata_dis(DisCtrl_Type_Def* param_displayctrl, rt_mp_t param_displaymempoll)
{
    /* check param is rt_null */
    RT_ASSERT(param_displayctrl);
    RT_ASSERT(param_displaymempoll);

return ini_var_list(param_displayctrl, param_displaymempoll);
}
```
- **写入**
``` C
rt_err_t write_listdata_dis(DisCtrl_Type_Def* param_displayctrl, DisList_Type_Def* param_listdata_w)
{
    DisList_Type_Def* cur_finddata = RT_NULL;

/* check param is rt_null */
    RT_ASSERT(param_displayctrl);
    RT_ASSERT(param_listdata_w);

/* 1. find --------------------------------------------------------------*/
    if(param_displayctrl->dislist_store != RT_NULL)
    {
        cur_finddata = find_data_list(param_displayctrl, param_listdata_w);        
    }

/* 2. change ----------------------------------------------------------- */
    if(cur_finddata)
    {
        return change_data_list(param_displayctrl, cur_finddata, param_listdata_w);
    }

/* 3. add -------------------------------------------------------------- */
    return write_data_list(param_displayctrl, param_listdata_w);
}
```
- **读取**
``` C
DisList_Type_Def* read_listdata_dis(DisCtrl_Type_Def* param_displayctrl)
{
    /* check param is rt_null */
    RT_ASSERT(param_displayctrl);
        
    return read_data_list(param_displayctrl);
}
```
- **删除**
``` C
rt_err_t delete_listdata_dis(DisCtrl_Type_Def* param_displayctrl)
{
    /* check param is rt_null */
    RT_ASSERT(param_displayctrl);

return delete_data_list(param_displayctrl);
}
```

### **链表操作代码**
- **初始化**
``` C
rt_err_t ini_var_list(DisCtrl_Type_Def* param_displayctrl, rt_mp_t param_displaymempoll)
{
    param_displayctrl->dislist_store = RT_NULL;

param_displayctrl->dislist_read = RT_NULL;

param_displayctrl->p_mempool_display = param_displaymempoll;

param_displayctrl->dislist_pagenum = 0x01;

param_displayctrl->muctexlock_dislist = rt_mutex_create("muctexlock_dislist", RT_IPC_FLAG_FIFO);
    if(param_displayctrl->muctexlock_dislist == RT_NULL)
    {
        LOG_E("muctexlock_dislist init failed");

return RT_ERROR;
    }
    else
    {
        return RT_EOK;
    }
}

void ini_var_listdetails(DisList_Type_Def* param_listdata_w)
{
    rt_slist_init(&(param_listdata_w->dis_list));

param_listdata_w->dis_state.uc = 0x00;
    param_listdata_w->dis_tagdistance = 0x00;
    param_listdata_w->dis_tagid = 0x00;
    rt_memset(param_listdata_w->dis_tagname, 0x20, DISPLAY_NAME_MAX);
    param_listdata_w->dis_tagvol = 0x00;
    param_listdata_w->generate_tick = 0x00;
    param_listdata_w->tagname_len = 0x00;
}
```
- **查找**
``` C
DisList_Type_Def* find_data_list(DisCtrl_Type_Def* param_displayctrl, DisList_Type_Def* param_listdata_w)
{
    rt_base_t level;
    rt_slist_t *node = RT_NULL;
    DisList_Type_Def* temp_finddata = RT_NULL;

// rt_mutex_take(param_displayctrl->muctexlock_dislist, RT_WAITING_FOREVER);
    level = rt_hw_interrupt_disable();

for (node = &(param_displayctrl->dislist_store->dis_list); node; node = rt_slist_next(node))
    {
        temp_finddata = rt_slist_entry(node, DisList_Type_Def, dis_list);
        if(temp_finddata && tagid_cmp(temp_finddata, param_listdata_w))
        {
			// rt_mutex_release(param_displayctrl->muctexlock_dislist);
            rt_hw_interrupt_enable(level);
            return temp_finddata;
        }
    }
    
    // rt_mutex_release(param_displayctrl->muctexlock_dislist);
    rt_hw_interrupt_enable(level);
    return RT_NULL;
}
```
- **更新**
``` C
rt_err_t change_data_list(DisCtrl_Type_Def* param_displayctrl, DisList_Type_Def* param_listdata_cur, DisList_Type_Def* param_listdata_w)
{
    rt_base_t level;

// rt_mutex_take(param_displayctrl->muctexlock_dislist, RT_WAITING_FOREVER);
    level = rt_hw_interrupt_disable();

/* chiptype */
    if(param_listdata_w->dis_state.param.b_chiptypeexist)
    {
        param_listdata_cur->dis_state.param.b_chiptype = param_listdata_w->dis_state.param.b_chiptype;
        param_listdata_cur->dis_state.param.b_chiptypeexist = param_listdata_w->dis_state.param.b_chiptypeexist;
    }

/* voltage */
    if((param_listdata_cur->dis_tagvol != param_listdata_w->dis_tagvol) && (param_listdata_w->dis_state.param.b_voltageexist))
    {
        param_listdata_cur->dis_tagvol = param_listdata_w->dis_tagvol;
        param_listdata_cur->dis_state.param.b_voltageexist = param_listdata_w->dis_state.param.b_voltageexist;
    }

/* name */
    if((!param_listdata_cur->dis_state.param.b_nameexist) && (param_listdata_w->dis_state.param.b_nameexist))
    {
        rt_memcpy(param_listdata_cur->dis_tagname, param_listdata_w->dis_tagname, param_listdata_w->tagname_len);
        param_listdata_cur->dis_state.param.b_nameexist = param_listdata_w->dis_state.param.b_nameexist;
        param_listdata_cur->tagname_len = param_listdata_w->tagname_len;
    }

/* distance */
    if((param_listdata_cur->dis_tagdistance != param_listdata_w->dis_tagdistance) && (param_listdata_w->dis_state.param.b_distanceexist))
    {
        param_listdata_cur->dis_tagdistance = param_listdata_w->dis_tagdistance;
        param_listdata_cur->dis_state.param.b_distanceexist = param_listdata_w->dis_state.param.b_distanceexist;
    }

/* sos and call */
    param_listdata_cur->dis_state.param.b_flagsos = param_listdata_w->dis_state.param.b_flagsos;
    param_listdata_cur->dis_state.param.b_flagcall = param_listdata_w->dis_state.param.b_flagcall;

/* tick */
    param_listdata_cur->generate_tick = param_listdata_w->generate_tick;

// rt_mutex_release(param_displayctrl->muctexlock_dislist);
    rt_hw_interrupt_enable(level);

return RT_EOK;
}
```
- **写入**
``` C
rt_err_t write_data_list(DisCtrl_Type_Def* param_displayctrl, DisList_Type_Def* param_listdata_w)
{
    rt_base_t level;
    DisList_Type_Def* temp_writedata = RT_NULL;

/* malloc mempool */
    temp_writedata = (DisList_Type_Def*)rt_mp_alloc(param_displayctrl->p_mempool_display, RT_WAITING_NO);
    if(temp_writedata == RT_NULL)
    {
        return RT_ERROR;
    }

/* init store detail */
    ini_var_listdetails(temp_writedata);

/* copy memory details */
    rt_memcpy(temp_writedata, param_listdata_w, sizeof(DisList_Type_Def));

// rt_mutex_take(param_displayctrl->muctexlock_dislist, RT_WAITING_FOREVER);
    level = rt_hw_interrupt_disable();

if(param_displayctrl->dislist_store == RT_NULL)
    {
        param_displayctrl->dislist_store = temp_writedata;
        param_displayctrl->dislist_read = temp_writedata;
    }
    else
    {
        /* tail insertion */
        rt_slist_append(&(param_displayctrl->dislist_store->dis_list), &(temp_writedata->dis_list));
    }

// rt_mutex_release(param_displayctrl->muctexlock_dislist);
    rt_hw_interrupt_enable(level);
    return RT_EOK;
}
```
- **读取**
``` C
DisList_Type_Def* read_data_list(DisCtrl_Type_Def* param_displayctrl)
{
    rt_base_t level;
    rt_slist_t *node = RT_NULL;
    DisList_Type_Def* temp_readdata = RT_NULL;

/* check store and read */
    if((param_displayctrl->dislist_store == RT_NULL) || (param_displayctrl->dislist_read == RT_NULL))
    {
        return RT_NULL;
    }

// rt_mutex_take(param_displayctrl->muctexlock_dislist, RT_WAITING_FOREVER);
    level = rt_hw_interrupt_disable();
    
    /* read one struct disdata */
	node = &(param_displayctrl->dislist_read->dis_list);
    if(node)
    {
        temp_readdata = rt_slist_entry(node, DisList_Type_Def, dis_list);
        if(temp_readdata)
        {
			// rt_mutex_release(param_displayctrl->muctexlock_dislist);
            rt_hw_interrupt_enable(level);
            return temp_readdata;
        }
    }

// rt_mutex_release(param_displayctrl->muctexlock_dislist);
    rt_hw_interrupt_enable(level);
    return RT_NULL;
}
```
- **删除**
``` C
rt_err_t delete_data_list(DisCtrl_Type_Def* param_displayctrl)
{
    rt_base_t level;
    rt_slist_t *node = RT_NULL;
    DisList_Type_Def* temp_deletedata = RT_NULL;

// rt_mutex_take(param_displayctrl->muctexlock_dislist, RT_WAITING_FOREVER);
    level = rt_hw_interrupt_disable();

/* delete disdata */
    for(node = &(param_displayctrl->dislist_store->dis_list); node; node = rt_slist_next(node))
    {
        temp_deletedata = rt_slist_entry(node, DisList_Type_Def, dis_list);
        if((temp_deletedata) && tick_cmp(rt_tick_get(), temp_deletedata))
        {
            /* check store */
            if(param_displayctrl->dislist_store == temp_deletedata && rt_slist_next(¶m_displayctrl->dislist_store->dis_list) == RT_NULL)
            {
                param_displayctrl->dislist_store = RT_NULL;
            }
            
            /* delete */
            else
            {
                rt_slist_remove(&(param_displayctrl->dislist_store->dis_list), &(temp_deletedata->dis_list));
            }

/* check read */
            if(param_displayctrl->dislist_read == temp_deletedata)
            {
                param_displayctrl->dislist_read = param_displayctrl->dislist_store;
            }

/* free memory */
            rt_mp_free(temp_deletedata); 
        }
    }

// rt_mutex_release(param_displayctrl->muctexlock_dislist);
    rt_hw_interrupt_enable(level);
    
    return RT_EOK;
}
```
### **详细信息**
![2.png](https://oss-club.rt-thread.org/uploads/20210814/d0a5aa943e292cb4939e3a820bee9e9e.png)

## **问题阐述**

- **说明：**中断产生的数据会很快

- 说不定什么时候就报错，错误内容如下
```C
(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread) assertion failed at function:rt_thread_resume, line number:770 
```
- 未添加显示相关的三个线程时，程序可稳定运行，昨晚添加后今天来了一看就有这个问题了，试着修改了 开关中断还是不行。

- 各位路过的大神，停下脚步帮帮我吧，疫情如此别出去七夕了，为国家减轻点负担，写代码最安全。