rt_event_recv无故返回(RT-Thread 4.1.1)

发布于 2024-02-02 15:17:43 浏览：507 订阅该版

2 个回答

lchnu 2024-02-02

Witness, Understand, Skill

我这边按照你的流程写了个简单demo，运行4.1.1，没有发现有什么问题。

按照你的说明，我理解的EVT2是对Running的ACK；EVT6是对Stop的ACK。

下方的代码中：

1. worker线程等待EVT_RUN；然后发送EVT2，修改状态为TRUE；然后等待EVT3，EVT4和EVT Stop，其中，等到EVT Stop后发送EVT6。

2. controller线程发出EVT Run，等待EVT2，等待EVT6；

3. int_sim用于模拟你的中断，发出EVT3，EVT4和EVT Stop。

在你的代码中，为什么控制线程等待EVT2需要将timeout设置为0？我的模拟代码中设置为FOREVER。

```c
#include <rtthread.h>

#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

#define EVT_RUN  (1<<0)
#define EVT_STOP (1<<1)
#define EVT_2   (1<<2)
#define EVT_3   (1<<3)
#define EVT_4   (1<<4)
#define EVT_6   (1<<6)

void worker_entry(void *arg);
void controller_entry(void *arg);
void int_sim_entry(void *arg);

static struct rt_event evt;
int main(void)
{
    rt_thread_t tid;
    rt_event_init(&evt, "event", RT_IPC_FLAG_FIFO);

tid = rt_thread_create("worker", worker_entry, RT_NULL, 2048, 15, 0);
    if(tid) {
        LOG_D("worker startup");
        rt_thread_startup(tid);
    }

tid = rt_thread_create("controller", controller_entry, RT_NULL, 2048, 14, 0);
    if(tid) {
        LOG_D("controller startup");
        rt_thread_startup(tid);
    }

tid = rt_thread_create("int_sim", int_sim_entry, RT_NULL, 2048, 11, 0);
    if(tid) {
        LOG_D("demo_int startup");
        rt_thread_startup(tid);
    }
	
    return RT_EOK;
}

void worker_entry(void *arg)
{
    rt_err_t err;
    rt_uint32_t flags;
    rt_bool_t state_run = RT_FALSE;

while(1) {
        err = rt_event_recv(&evt,EVT_RUN,
                            RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,
                            RT_WAITING_FOREVER,&flags);
        LOG_I("State - RUNNING       , flags = %d", flags);
        state_run = RT_TRUE;

rt_event_send(&evt, EVT_2);

while(RT_TRUE == state_run) {
            err = rt_event_recv(&evt,EVT_3|EVT_4|EVT_STOP,
                                RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,
                                1000,&flags);
            if (err == RT_EOK) {
                switch(flags) {
                case EVT_3:
                    LOG_D("State - RUNNING EVT_3 , flags = %d",flags);
                    break;
                case EVT_4:
                    LOG_D("State - RUNNING EVT_4 , flags = %d",flags);
                    break;
                case EVT_STOP:
                    LOG_I("State - STOP Received , flags = %d",flags);
                    rt_event_send(&evt,EVT_6);
                    state_run = RT_FALSE;
                    break;
                default:
                    LOG_D("State - Unknown       , flags = %d", flags);
                }
            } else{
                LOG_D("Timeout");
            }
        }
    }
}

void controller_entry(void *arg)
{
    rt_uint32_t flags;

while(1)
    {
        rt_event_send(&evt,EVT_RUN);

rt_event_recv(&evt,EVT_2,
                            RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,
                            RT_WAITING_FOREVER,&flags);
        LOG_I("State - Run Ack       , flags = %d",flags);
        rt_event_recv(&evt,EVT_6,
                            RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,
                            RT_WAITING_FOREVER,&flags);
        LOG_I("State - Stop Ack      , flags = %d",flags);
    }
}

void int_sim_entry(void *arg)
{
    rt_uint32_t count = 0;
    while(++count)
    {
        if(0 == (count %2) )
        {
            rt_event_send(&evt, EVT_3);
        }
        else
        {
            rt_event_send(&evt, EVT_4);
        }

if(count == 20)
        {
            rt_event_send(&evt, EVT_STOP);
            count = 0;
        }
        rt_thread_delay(1000);
    }

}
```

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240202/433cce0fffd92fcac1ca7c3a1f79c961.png.webp)

Alf76 2024-02-03

这家伙很懒，什么也没写！

不好意思，没有说清楚。
```c
rt_event_recv(_evt,EVT_2,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,RT_NULL);
rt_event_send(_evt,EVT_6);
```
首先，这段的 rt_event_recv 是在工作线程用来单独清除 EVT_2 的，所以 timeout 是 0，实际上是 EVT_2 当成可以用来挂起的旗号来用。工作线程的流程类似这样：
```
    while(1)
    {
        if(_state < PRELOAD)
        {
            err = rt_event_recv(_evt,EVT_RUN,
                            RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,
                            STOP_TIMEOUT,&flags);	//FOREVER by default
            if(err != RT_EOK) continue;
            _state = PRELOAD;
            flags = 0;
        }
        else
        {
            err = rt_event_recv(_evt,EVT_3|EVT_4|EVT_STOP,
                                RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,
                                timeout,&flags);

if(err == RT_EOK)
            {
                if(flags & EVT_3)
                {
                    task3();
                }
                if(flags & ABRD_EVT_STOP)
                {
                    stop();
					rt_event_recv(_evt,EVT_2,	//clear EVT_2
								RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,RT_NULL);
					rt_event_send(_evt,EVT_6);
                    _state = STOP;
                    continue;
                }
                if(flags & EVT_4)
                {
                    task4();
                }
            }
        }
        timeout = common_op();	//0 or forever
		if(_state == PRELOAD)
		{
			rt_event_send(_evt,EVT_2);
			_state = RUN;
		}
    }
```
跟你写的差别不算大。在common_op()中另外有个rt_data_queue_pop(), 不知有没有影响。也有点怀疑是否有其他因素影响调度器了。现在正尝试用邮件代替部分功能....