【TencentOS】事件

最新推荐文章于 2022-03-13 22:59:00 发布

与光同程

最新推荐文章于 2022-03-13 22:59:00 发布

阅读量438

点赞数

分类专栏：嵌入式实时操作系统文章标签： TencentOS 事件

本文链接：https://blog.csdn.net/yy197696/article/details/101073147

版权

嵌入式实时操作系统专栏收录该内容

13 篇文章 6 订阅

订阅专栏

3）事件
概述
事件提供了一种任务间实现同步和信息传递的机制。一般来说，一个事件中包含了一个旗标，这个旗标的每一位表示一个“事件”。
一个任务可以等待一个或者多个“事件”的发生，其他任务在一定的业务条件下可以通过写入特定“事件”唤醒等待此“事件”的任务，实现一种类似信号的编程范式

事件event
tos_event_create
k_err_t tos_event_create(k_event_t *event, k_event_flag_t init_flag);
• 功能描述
创建一个事件。
• 参数解释
IN/OUT 参数名描述
[in] event 事件句柄
[in] init_flag 事件初始旗标
• 返回值
K_ERR_NONE 事件创建成功。
K_ERR_OBJ_PTR_NULL event指针为空。
tos_event_destroy
k_err_t tos_event_destroy(k_event_t *event);
• 功能描述
销毁一个事件。
• 参数解释
IN/OUT 参数名描述
[in] event 事件句柄
• 返回值
K_ERR_NONE 事件销毁成功。
K_ERR_OBJ_PTR_NULL event指针为空。
K_ERR_OBJ_INVALID event指向的不是一个合法的事件。
tos_event_pend
k_err_t tos_event_pend(k_event_t *event, k_event_flag_t flag_expect, k_event_flag_t *flag_match, k_tick_t timeout, k_opt_t opt);
• 功能描述
尝试获取一个特定的事件。
• 参数解释
IN/OUT 参数名描述
[in] event 事件句柄
[in] flag_expect 期望获取到的事件旗标
[out] flag_match 实际获取到的事件旗标
[in] timeout 等待超时参数
[in] opt 选项
• 注意
opt选项说明：
1、TOS_OPT_EVENT_PEND_ANY
尝试从事件中获取一组旗标，并且这一组旗标包含flag_expect中标识的任意一个旗标，如果在此场景下视作event获取成功，则opt传递此参数。
举例来说，如果传入的flag_expect为0x9（0x8 | 0x1），且opt为TOS_OPT_EVENT_PEND_ANY，则event包含的旗标包含0x8或者0x1即视为事件获取成功，也就是说，event包含的旗标为(0x8 | X, X为整数，且X∈(0, 0xFFFFFFFF])，或者(0x1 | X, X为整数，且X∈(0, 0xFFFFFFFF])。
2、TOS_OPT_EVENT_PEND_ALL
尝试从事件中获取一组旗标，并且这一组旗标必须至少包含flag_expect中标识的所有旗标，如果只在此种场景下视作event获取成功，则opt传递此参数。
举例来说，如果传入的flag_expect为0x9（0x8 | 0x1），且opt为TOS_OPT_EVENT_PEND_ALL，则event包含的旗标至少为0x9的最小全集才视为事件获取成功，也就是说，event包含的旗标应为(0x9 | X, X为整数，且X∈(0, 0xFFFFFFFF])。
3、TOS_OPT_EVENT_PEND_CLR
如果希望读取完事件后，直接复位清空event的所有旗标，则opt传递此参数。
举例来说，原event包含旗标为0x9，在传递TOS_OPT_EVENT_PEND_CLR参数并成功获取event中的旗标后，event包含的旗标会复位为0x0。
如果希望一次传入多个选项，可以用逻辑“或”将多个参数连接传入，譬如同时希望采用TOS_OPT_EVENT_PEND_ANY 语义及TOS_OPT_EVENT_PEND_CLR，可以传入（TOS_OPT_EVENT_PEND_ANY | TOS_OPT_EVENT_PEND_CLR）。
需要注意的是，不可以同时传入TOS_OPT_EVENT_PEND_ANY与TOS_OPT_EVENT_PEND_ALL。
• 返回值
K_ERR_NONE 读取特定的事件成功。
K_ERR_EVENT_PEND_OPT_INVALID opt参数非法。
K_ERR_PEND_NOWAIT 未能从event中获取到期望的旗标，并且timeout参数为TOS_TIME_NOWAIT（表示未获取到期望旗标时立即返回）。
K_ERR_PEND_SCHED_LOCKED 未能从event中获取到期望的旗标，并且系统调度处于锁定的状态。
K_ERR_PEND_TIMEOUT 在超时范围内未能从event中获取到期望的旗标。
K_ERR_PEND_DESTROY 尝试获取旗标的事件被销毁了（tos_event_destroy）。
tos_event_post
k_err_t tos_event_post(k_event_t *event, k_event_flag_t flag);
• 功能描述
向事件中放置一组旗标
• 参数解释
IN/OUT 参数名描述
[in] event 事件句柄
[in] flag 要放置的旗标
• 注意
调用此接口放置一组旗标时，原event中包含的旗标将被覆盖。
举例来说，如果原事件的旗标为0x1，并且要放置的旗标为0x8，此接口调用结束后，事件的旗标将被覆写为0x8。
• 返回值
K_ERR_NONE 旗标放置成功。
K_ERR_OBJ_PTR_NULL event为空指针。
K_ERR_OBJ_INVALID event指向的并不是一个合法的事件。
tos_event_post_keep
k_err_t tos_event_post_keep(k_event_t *event, k_event_flag_t flag);
• 功能描述
向事件中放置一组旗标，原event中包含的旗标将被保留。
举例来说，如果原事件的旗标为0x1，并且要放置的旗标为0x8，此接口调用结束后，事件的旗标将被修改为0x9(0x8 | 0x1)，也就是说，原事件的包含的旗标被保留。
• 参数解释
IN/OUT 参数名描述
[in] event 事件句柄
[in] flag 要放置的旗标
• 返回值
K_ERR_NONE 旗标放置成功。
K_ERR_OBJ_PTR_NULL event为空指针。
K_ERR_OBJ_INVALID event指向的并不是一个合法的事件。
程序实例：

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "key.h"
#include "lcd.h"
#include "string.h"
#include "cmsis_os.h"
#include "tos.h"		

#define STK_SIZE_TASK_LISTENER      512
#define STK_SIZE_TASK_TRIGGER       512

k_stack_t stack_task_listener1[STK_SIZE_TASK_LISTENER];
k_stack_t stack_task_listener2[STK_SIZE_TASK_LISTENER];
k_stack_t stack_task_trigger[STK_SIZE_TASK_TRIGGER];

k_task_t task_listener1;
k_task_t task_listener2;
k_task_t task_trigger;

extern void entry_task_listener1(void *arg);
extern void entry_task_listener2(void *arg);
extern void entry_task_trigger(void *arg);

const k_event_flag_t event_eeny     = (k_event_flag_t)(1 << 0);
const k_event_flag_t event_meeny    = (k_event_flag_t)(1 << 1);
const k_event_flag_t event_miny     = (k_event_flag_t)(1 << 2);
const k_event_flag_t event_moe      = (k_event_flag_t)(1 << 3);

k_event_t event;

void entry_task_listener1(void *arg)
{
    k_event_flag_t flag_match;
    k_err_t err;

    while (K_TRUE) {
        // ´ËÈÎÎñ¼àÌýËÄ¸öÊÂ¼þ£¬ÒòÎªÊ¹ÓÃÁËTOS_OPT_EVENT_PEND_ALLÑ¡Ïî£¬Òò´Ë±ØÐëÊÇËÄ¸öÊÂ¼þÍ¬Ê±µ½´ï´ËÈÎÎñ²Å»á±»»½ÐÑ
        err = tos_event_pend(&event,          //ÊÂ¼þ¾ä±ú
                         			event_eeny | event_meeny | event_miny | event_moe,
                              &flag_match,    //»ñµÃµ½µÄÊÂ¼þÆì±ê
                         			TOS_TIME_FOREVER,//³¬Ê±²ÎÊý
                         			TOS_OPT_EVENT_PEND_ALL | TOS_OPT_EVENT_PEND_CLR); //ÓÐ¹ØÑ¡Ïî
        if (err == K_ERR_NONE) {
            printf("entry_task_listener1:\n");
            printf("eeny, meeny, miny, moe, they all come\n");
        }
    }
}

void entry_task_listener2(void *arg)
{
    k_event_flag_t flag_match;
    k_err_t err;

    while (K_TRUE)
		{
        err = tos_event_pend(&event, 
			               event_eeny | event_meeny | event_miny | event_moe,
                           &flag_match,
                        TOS_TIME_FOREVER|TOS_OPT_EVENT_PEND_ANY|TOS_OPT_EVENT_PEND_CLR);
        if (err == K_ERR_NONE) 
				{
            printf("entry_task_listener2:\n");
            // ÓÐÊÂ¼þµ½´ï£¬ÅÐ¶Ï¾ßÌåÊÇÄÄ¸öÊÂ¼þ
            if (flag_match == event_eeny) {
                printf("eeny comes\n");
            }
            if (flag_match == event_meeny) {
                printf("meeny comes\n");    
            }
            if (flag_match == event_miny) {
                printf("miny comes\n");
            }
            if (flag_match == event_moe) {
                printf("moe comes\n");
            }
            if (flag_match == (event_eeny | event_meeny | event_miny | event_moe))
						{
                printf("all come\n");
            }
        }
    }
}

void entry_task_trigger(void *arg)
{
    int i = 1;

    while (K_TRUE)
			{
        if (i == 2) {
            printf("entry_task_trigger:\n");
            printf("eeny will come\n");
            // ·¢ËÍeenyÊÂ¼þ£¬task_listener2»á±»»½ÐÑ
            tos_event_post(&event, event_eeny);
        }
        if (i == 3) {
            printf("entry_task_trigger:\n");
            printf("meeny will come\n");
            // ·¢ËÍeenyÊÂ¼þ£¬task_listener2»á±»»½ÐÑ
            tos_event_post(&event, event_meeny);
        }
        if (i == 4) {
            printf("entry_task_trigger:\n");
            printf("miny will come\n");
            // ·¢ËÍeenyÊÂ¼þ£¬task_listener2»á±»»½ÐÑ
            tos_event_post(&event, event_miny);
        }
        if (i == 5) {
            printf("entry_task_trigger:\n");
            printf("moe will come\n");
            // ·¢ËÍeenyÊÂ¼þ£¬task_listener2»á±»»½ÐÑ
            tos_event_post(&event, event_moe);
        }
        if (i == 6) {
            printf("entry_task_trigger:\n");
            printf("all will come\n");
            tos_event_post(&event, event_eeny | event_meeny | event_miny | event_moe);
        }
        tos_task_delay(1000);
        ++i;
    }
}


int main(void)
{
    HAL_Init();                     //³õÊ¼»¯HAL¿â   
    Stm32_Clock_Init(360,25,2,8);   //ÉèÖÃÊ±ÖÓ,180Mhz
    delay_init(180);                //³õÊ¼»¯ÑÓÊ±º¯Êý
    uart_init(115200);              //³õÊ¼»¯USART
    LED_Init();                     //³õÊ¼»¯LED 
    KEY_Init();                     //³õÊ¼»¯°´¼ü
	  LCD_Init();  
    tos_knl_init();
	  tos_event_create(&event, (k_event_flag_t)0u);
   
    
    (void)tos_task_create(&task_listener1, "listener1", entry_task_listener1, NULL,
                            3, stack_task_listener1, STK_SIZE_TASK_LISTENER, 0);
    (void)tos_task_create(&task_listener2, "listener2", entry_task_listener2, NULL,
                            4, stack_task_listener2, STK_SIZE_TASK_LISTENER, 0);
    (void)tos_task_create(&task_trigger, "trigger", entry_task_trigger, NULL,
                            4, stack_task_trigger, STK_SIZE_TASK_TRIGGER, 0);
     tos_knl_start();
	while(1)
	{}

实验现象：
在这里插入图片描述

与光同程

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【TencentOS】事件

3）事件概述事件提供了一种任务间实现同步和信息传递的机制。一般来说，一个事件中包含了一个旗标，这个旗标的每一位表示一个“事件”。一个任务可以等待一个或者多个“事件”的发生，其他任务在一定的业务条件下可以通过写入特定“事件”唤醒等待此“事件”的任务，实现一种类似信号的编程范式事件eventtos_event_createk_err_t tos_event_create(k_event_t...
复制链接

扫一扫