RTT Nano学习笔记 9 - 事件

目录

1. 创建

2. 删除

3. 发送

4. 接收

5. 实例

---

事件也是线程同步的一种方式，与信号量或互斥量不同的是，它可以实现一对多、多对多的线程同步。另外，线程还可以通过多个事件间的逻辑关系来确定是否唤醒，比如需要多个事件都发生才唤醒，或者多个事件中有一个发生就可以唤醒。

RTT的事件集合用 32 位无符号整型变量来表示，每一位代表一个事件，线程通过“逻辑与”或“逻辑或”与一个或多个事件建立关联，形成一个事件集。

1. 创建

#define rtosEventCreate(                               \
    handle,                                            \
    name,                                              \
    flag                                               \
    )                                                  \
    {                                                  \
        handle = rt_event_create(name, flag);          \
    }

参数含义与信号量类似，flag也是支持FIFO和PRIO两种方式。 

handle的宏定义如下：

#define rtosEvent_t                                     rt_event_t

2. 删除

#define rtosEventDelete(                               \
    handle                                             \
    )                                                  \
    {                                                  \
        rt_event_delete(handle);                       \
    }

3. 发送

#define rtosEventSend(                                 \
    handle,                                            \
    set                                                \
    )                                                  \
    {                                                  \
        rt_event_send(handle, set);                    \
    }

参数set是发送的一个或多个事件的32位标志值，即每一位代表一个事件

4. 接收

#define rtosEventReceive(                               \
    handle,                                             \
    set,                                                \
    option,                                             \
    timeout,                                            \
    recved,                                             \
    ret                                                 \
    )                                                   \
    {                                                   \
        ret = rt_event_recv(handle, set, option,        \
            timeout, recved);                           \
    }

参数：

handle - 事件的句柄，由create获取

set - 含义与发送一样，与option组合来判断它要接收的事件是否发生。

option - 接收选项，3个选项：AND或者OR或者CLEAR，CLEAR是和AND或者OR组合使用，表示接收结束后清除事件标志。

#define RTOS_EVENT_AND                                  RT_EVENT_FLAG_AND
#define RTOS_EVENT_OR                                   RT_EVENT_FLAG_OR
#define RTOS_EVENT_CLEAR                                RT_EVENT_FLAG_CLEAR

timeout - 接收超时时间

recved - 指向收到的事件，可以设置为NULL

ret - 返回值，如果返回0表示成功，否则就是失败。

5. 实例

2个进程，一个进程发送事件，一个进程接收事件。假设有2个事件：初始化Flash和初始LCD。

static rtosEvent_t event = NULL;
#define EVENT_FLAG_INIT_FLASH       ((uint32_t)1 << 0)
#define EVENT_FLAG_INIT_LCD         ((uint32_t)1 << 1)

发送进程中初始化FLASH和LCD，各自完成后发送事件。

static void threadEvevtSend(void *parameter)
{
    Printf("Init Flash\n");
    rtosEventSend(event, EVENT_FLAG_INIT_FLASH);
    rtosThreadSleep(1000);
    
    Printf("Init LCD\n");
    rtosEventSend(event, EVENT_FLAG_INIT_LCD);
    rtosThreadSleep(1000);
}

接收进程分别接收Flash和LCD的事件，当事件参数set为一个事件时，option参数是OR或者AND都是一样的，但是不能为0。

static void threadEvevtReceive(void *parameter)
{
    uint32_t ret;
    rtosEventReceive(event, EVENT_FLAG_INIT_FLASH, RTOS_EVENT_OR, RTOS_WAIT_FOREVER, NULL, ret);
    if(ret == 0)
    {
        Printf("Init Flash Done 1!\n");
    }
    else
        return;
    
    rtosEventReceive(event, EVENT_FLAG_INIT_FLASH | EVENT_FLAG_INIT_LCD, RTOS_EVENT_OR, RTOS_WAIT_FOREVER, NULL, ret);
    if(ret == 0)
    {
        Printf("Init Flash Done 2!\n");
    }
    else
        return;
    
    rtosEventReceive(event, EVENT_FLAG_INIT_LCD, RTOS_EVENT_OR, RTOS_WAIT_FOREVER, NULL, ret);
    if(ret == 0)
    {
        Printf("Init LCD Done 1!\n");
    }
    else
        return;
    
    rtosEventReceive(event, EVENT_FLAG_INIT_FLASH | EVENT_FLAG_INIT_LCD, RTOS_EVENT_AND | RTOS_EVENT_CLEAR, RTOS_WAIT_FOREVER, NULL, ret);
    if(ret == 0)
    {
        Printf("Init All Done!\n");
    }
    else
        return;
}

初始化这2个进程

    rtosEventCreate(event, "event", RTOS_IPC_FLAG_FIFO);

    rtosCreateThread(
        handle1,
        "Event R",
        threadEvevtReceive,
        (void *)0,
        NULL,
        256,
        RTOS_PRIORITY_MAX - 2, 
        100);
    rtosCreateThread(
        handle2,
        "Event S",
        threadEvevtSend,
        (void *)0,
        NULL,
        256,
        RTOS_PRIORITY_MAX - 1, 
        100);
    rtosStartThread(handle1);
    rtosStartThread(handle2);

打印结果：

Init Flash
Init Flash Done 1!
Init Flash Done 2!
Init LCD
Init LCD Done 1!
Init All Done!

这里在发送进程中每个事件中间加入了sleep，去掉这2个sleep测试一下会发现打印结果是一样的，这是因为接收进程的优先级比发送进程高，所以当发送Flash事件后接收进程就开始执行了。

如果去掉sleep的同时把2个进程的优先级反一下，可以看到打印结果如下：

Init Flash
Init LCD
Init Flash Done 1!
Init Flash Done 2!
Init LCD Done 1!
Init All Done!