RTOS内功修炼记(六)—— 任务间通信为什么不用全局变量?

内容导读:

第一篇文章讲述了任务的三大元素:任务控制块、任务栈、任务入口函数,并讲述了编写RTOS任务入口函数时三个重要的注意点。

第二篇文章从任务如何切换开始讲起,引出RTOS内核中的就绪列表、优先级表,一层一层为你揭开RTOS内核优先级抢占式调度方法的神秘面纱。

第三篇文章讲述了RTOS内核到底是如何管理中断的?用户该如何编写中断处理函数?以及用户如何设置临界段?

第四篇文章讲述了RTOS内核中所有与时间相关的内容,包括时钟管理、时间管理、任务延时机制、空闲任务、软件定时器、时间片调度:

第五篇文章讲述了RTOS内核中各种任务同步量的实现,虽然多种多样,但是万变不离其宗,一是全局变量,而是pend-post机制。

建议先阅读上文,对RTOS内核的抢占式调度机制和时间片调度机制、RTOS内核对中断的处理机制与裸机的不同之处、RTOS中任务延时的机制、pend-post机制理解之后,再阅读本文也不迟。


1. 知识点回顾

队列(queue)是一种只能在一端插入元素、在另一端删除元素的数据结构,遵循先入先出(FIFO)的规则。

环形队列(ring queue)可以方便的重复利用这段内存空间,同样遵循先入先出(FIFO)的规则。

优先级队列(prio queue)不遵循FIFO,而是根据元素的优先级进行出队,优先级最高的先出队。

本文的所有内容都是基于这两个数据结构,TencentOS-tiny中环形队列和优先级队列的实现和使用示例请阅读文章:

2. 消息队列

2.1. 什么是消息队列

消息队列,Message Queue,顾名思义包含两部分:消息+队列,或者可以理解为消息的队列。

① 消息是什么?

两个不同的任务之间传递数据时,这个数据就称之为消息,这个消息可以是一个整型值,浮点值,甚至一个结构体,一个指针……所以,在使用不同的RTOS的消息队列时,一定要注意传递的是值还是该值的地址

传递值的缺点是值的长度有大有小,导致整个消息队列的长度有大有小。

一个指针的长度是固定的4字节,传递值的时候,无论值是什么类型,只传递该值的地址。

传递地址当然也有缺陷,当动态任务task1中定义了一个局部变量,然后把该局部变量的地址传给了task2,随即task1因为某种原因被销毁,内存回收,导致指向该局部变量的指针变为野指针,非常危险,不过不用慌,小问题,在编程的时候注意避免即可。

在TencentOS-tiny中,消息队列中传递的消息指的是地址,邮箱队列传递的消息是值

② 队列是什么?

消息队列如果底层使用环形队列存储消息,则成为消息队列,遵循:先送入的消息先被取出。

消息队列如果底层使用优先级队列存储消息,则成为优先级消息队列,遵循:优先级最高的消息最先被取出。

在TencentOS-tiny中,这两种消息队列都有,下面一一讲述。

③ pend-post机制

无论是什么队列,都存在两种情况:当队列满了的时候,元素再入队会发生错误;当队列为空的时候,元素出队同样会发生错误。

这种问题可以巧妙的在队列基础之上用pend-post机制解决,即等待-释放机制。

当队列满了的时候,前来入队的task1可以选择pend一段时间或者永久等待,一旦有元素被task2出队,调用post释放一个信号,唤醒等待中的task1

同样,当队列空了的时候,前来出队的task1可以选择pend一段时间或者永久等待,一旦有元素被task2入队,调用post释放一个信号,唤醒等待中的task1

是不是很巧妙?

接下来上源码!上Demo!一看便知~

2.2. 消息队列的实现

TencentOS-tiny中消息队列的实现在 tos_message_queue.htos_message_queue.c中。

typedef struct k_message_queue_st {
    knl_obj_t   knl_obj;

    pend_obj_t  pend_obj;
    k_ring_q_t  ring_q;
} k_msg_q_t;

一个pend_obj对象用来实现pend-post机制,一个ring_q环形队列用来存储消息。

是不是和我讲述的没错?学透了之后,其实一切都没有那么神秘的~

再来看看从消息队列中获取消息的API实现:

__API__ k_err_t tos_msg_q_pend(k_msg_q_t *msg_q, void **msg_ptr, k_tick_t timeout)
{
	//省略了部分源码
    TOS_CPU_INT_DISABLE();

    if (tos_ring_q_dequeue(&msg_q->ring_q, msg_ptr, K_NULL) == K_ERR_NONE) {
        TOS_CPU_INT_ENABLE();
        return K_ERR_NONE;
    }
    
    pend_task_block(k_curr_task, &msg_q->pend_obj, timeout);

    TOS_CPU_INT_ENABLE();
    knl_sched();

    return err;
}

向消息队列中存放消息的API实现如下:

__STATIC__ k_err_t msg_q_do_post(k_msg_q_t *msg_q, void *msg_ptr, opt_post_t opt)
{
    //省略了部分源码
    TOS_CPU_INT_DISABLE();

    if (pend_is_nopending(&msg_q->pend_obj)) {
        err = tos_ring_q_enqueue(&msg_q->ring_q, &msg_ptr, sizeof(void*));
        if (err != K_ERR_NONE) {
            TOS_CPU_INT_ENABLE();
            return err;
        }
        TOS_CPU_INT_ENABLE();
        return K_ERR_NONE;
    }

    if (opt == OPT_POST_ONE) {
        msg_q_task_recv(TOS_LIST_FIRST_ENTRY(&msg_q->pend_obj.list, k_task_t, pend_list), msg_ptr);
    } else { // OPT_POST_ALL
        TOS_LIST_FOR_EACH_ENTRY_SAFE(task, tmp, k_task_t, pend_list, &msg_q->pend_obj.list) {
            msg_q_task_recv(task, msg_ptr);
        }
    }

    TOS_CPU_INT_ENABLE();
    knl_sched();

    return K_ERR_NONE;
}

从源码中可以看到,如果opt标志为 OPT_POST_ONE,表示唤醒一个,则唤醒该消息队列等待列表上任务优先级最高的那个;如果opt标志为 OPT_POST_ALL,则全部唤醒。

2.3. 消息队列的使用示例

#define MESSAGE_MAX     10

uint8_t msg_pool[MESSAGE_MAX * sizeof(void *)];

k_msg_q_t msg_q;

void entry_task_receiver(void *arg)
{
    k_err_t err;
    void *msg_received;

    while (K_TRUE) {
        err = tos_msg_q_pend(&msg_q, &msg_received, TOS_TIME_FOREVER);
        if (err == K_ERR_NONE) {
            printf("receiver: msg incoming[%s]\n", (char *)msg_received);
        }
    }
}

void entry_task_sender(void *arg)
{
    char *msg_prio_0 = "msg 0 without priority";
    char *msg_prio_1 = "msg 1 without priority";
    char *msg_prio_2 = "msg 2 without priority";

    printf("sender: post a message 2 without priority\n");
    tos_msg_q_post(&msg_q, msg_prio_2);

    printf("sender: post a message 1 without priority\n");
    tos_msg_q_post(&msg_q, msg_prio_1);

    printf("sender: post a message 0 without priority\n");
    tos_msg_q_post(&msg_q, msg_prio_0);
}

执行结果如下:

TencentOS-tiny Port on STM32L431RCT6 By Mculover666
sender: post a message 2 without priority
sender: post a message 1 without priority
sender: post a message 0 without priority
receiver: msg incoming[msg 2 without priority]
receiver: msg incoming[msg 1 without priority]
receiver: msg incoming[msg 0 without priority]

3. 优先级消息队列

3.1. 优先级消息队列的实现

实现和消息队列类似,通过在优先级队列的基础上加上pend-post机制来实现。

TencentOS-tiny中优先级消息队列的实现在tos_priority_message_queue.htos_priority_message_queue.c中。

typedef struct k_priority_message_queue_st {
    knl_obj_t   knl_obj;

    pend_obj_t  pend_obj;

    void       *prio_q_mgr_array;
    k_prio_q_t  prio_q;
} k_prio_msg_q_t;

其中pend_obj用于挂载等待该优先级消息队列的任务,prio_q和prio_q_mgr_array合起来实现优先级队列。

消息入队和消息出队的API实现与消息队列的实现思想一模一样,这里不再讲解。

3.2. 优先级消息队列的使用示例

#define MESSAGE_MAX     10

uint8_t msg_pool[MESSAGE_MAX * sizeof(void *)];

k_prio_msg_q_t prio_msg_q;

void entry_task_receiver(void *arg)
{
    k_err_t err;
    void *msg_received;

    while (K_TRUE) {
        err = tos_prio_msg_q_pend(&prio_msg_q, &msg_received, TOS_TIME_FOREVER);
        if (err == K_ERR_NONE) {
            printf("receiver: msg incoming[%s]\n", (char *)msg_received);
        }
    }
}

void entry_task_sender(void *arg)
{
    char *msg_prio_0 = "msg with priority 0";
    char *msg_prio_1 = "msg with priority 1";
    char *msg_prio_2 = "msg with priority 2";

    printf("sender: post a message with priority 2\n");
    tos_prio_msg_q_post(&prio_msg_q, msg_prio_2, 2);

    printf("sender: post a message with priority 1\n");
    tos_prio_msg_q_post(&prio_msg_q, msg_prio_1, 1);

    printf("sender: post a message with priority 0\n");
    tos_prio_msg_q_post(&prio_msg_q, msg_prio_0, 0);
}

运行结果如下:

TencentOS-tiny Port on STM32L431RCT6 By Mculover666
sender: post a message with priority 2
sender: post a message with priority 1
sender: post a message with priority 0
receiver: msg incoming[msg with priority 0]
receiver: msg incoming[msg with priority 1]
receiver: msg incoming[msg with priority 2]

将第2节的结果和第3节的结果对比,就会发现同样的消息发送顺序,因为使用不同的消息队列,任务获取到的消息顺序截然不同。

4. 邮箱队列

4.1. 不同之处

消息队列和邮箱队列的不同之处,在于底层队列每个元素类型不一样,看一眼源码便知。

消息队列传递的消息是地址,所以在初始化消息队列的时候,环形队列中每个元素都是空指针类型:

__API__ k_err_t tos_msg_q_create(k_msg_q_t *msg_q, void *pool, size_t msg_cnt)
{
	//部分源码省略

	//重点:队列中每个元素类型大小是sizeof(void*)
    err = tos_ring_q_create(&msg_q->ring_q, pool, msg_cnt, sizeof(void *));
    if (err != K_ERR_NONE) {
        return err;
    }

    return K_ERR_NONE;
}

而邮箱队列传递的是值,所以在初始化底层用到的环形队列时,每个元素的大小是由用户指定的:

__API__ k_err_t tos_mail_q_create(k_mail_q_t *mail_q, void *pool, size_t mail_cnt, size_t mail_size)
{
	//省略了部分源码
	
	//重点:每个元素的大小是mail_size,由用户传入参数指定
    err = tos_ring_q_create(&mail_q->ring_q, pool, mail_cnt, mail_size);
    if (err != K_ERR_NONE) {
        return err;
    }

    return K_ERR_NONE;
}

4.2. 邮箱队列的实现

这有什么好实现的~一个环形队列+pend-post对象即可。

TencentOS-tiny中邮箱队列的实现在tos_mail_queue.htos_mail_queue.c中。

typedef struct k_mail_queue_st {
    knl_obj_t   knl_obj;

    pend_obj_t  pend_obj;
    k_ring_q_t  ring_q;
} k_mail_q_t;

是不是没什么区别~至于操作的API,更没啥区别,不写了,划水划水。

4.3. 邮箱队列的使用示例

#define MAIL_MAX    10

typedef struct mail_st {
    char   *message;
    int     payload;
} mail_t;

uint8_t mail_pool[MAIL_MAX * sizeof(mail_t)];

k_mail_q_t mail_q;

void entry_task_receiver_higher_prio(void *arg)
{
    k_err_t err;
    mail_t mail;
    size_t mail_size;

    while (K_TRUE) {
        err = tos_mail_q_pend(&mail_q, &mail, &mail_size, TOS_TIME_FOREVER);
        if (err == K_ERR_NONE) {
            TOS_ASSERT(mail_size == sizeof(mail_t));
            printf("higher: msg incoming[%s], payload[%d]\n", mail.message, mail.payload);
        }
    }
}

void entry_task_receiver_lower_prio(void *arg)
{
    k_err_t err;
    mail_t mail;
    size_t mail_size;

    while (K_TRUE) {
        err = tos_mail_q_pend(&mail_q, &mail, &mail_size, TOS_TIME_FOREVER);
        if (err == K_ERR_NONE) {
            TOS_ASSERT(mail_size == sizeof(mail_t));
            printf("lower: msg incoming[%s], payload[%d]\n", mail.message, mail.payload);
        }
    }
}

void entry_task_sender(void *arg)
{
    int i = 1;
    mail_t mail;

    while (K_TRUE) {
        if (i == 2) {
            printf("sender: send a mail to one receiver, and shoud be the highest priority one\n");
            mail.message = "1st time post";
            mail.payload = 1;
            tos_mail_q_post(&mail_q, &mail, sizeof(mail_t));
        }
        if (i == 3) {
            printf("sender: send a message to all recevier\n");
            mail.message = "2nd time post";
            mail.payload = 2;
            tos_mail_q_post_all(&mail_q, &mail, sizeof(mail_t));
        }
        if (i == 4) {
            printf("sender: send a message to one receiver, and shoud be the highest priority one\n");
            mail.message = "3rd time post";
            mail.payload = 3;
            tos_mail_q_post(&mail_q, &mail, sizeof(mail_t));
        }
        if (i == 5) {
            printf("sender: send a message to all recevier\n");
            mail.message = "4th time post";
            mail.payload = 4;
            tos_mail_q_post_all(&mail_q, &mail, sizeof(mail_t));
        }
        tos_task_delay(1000);
        ++i;
    }
}

运行结果为:

TencentOS-tiny Port on STM32L431RCT6 By Mculover666

sender: send a mail to one receiver, and shoud be the highest priority one
higher: msg incoming[1st time post], payload[1]

sender: send a message to all recevier
higher: msg incoming[2nd time post], payload[2]
lower: msg incoming[2nd time post], payload[2]

sender: send a message to one receiver, and shoud be the highest priority one
higher: msg incoming[3rd time post], payload[3]

sender: send a message to all recevier
higher: msg incoming[4th time post], payload[4]
lower: msg incoming[4th time post], payload[4]

此示例主要演示了两点:1. 如何使用邮箱队列直接传递值;2. 唤醒一个等待任务和唤醒所有等待任务的区别。

5. 优先级邮箱队列

看到这里,这个不能再讲了吧~

TencentOS-tiny中实现在tos_priority_mail_queue.ctos_priority_mail_queue.h中。

可以自己尝试根据前面的demo,编写出一个使用优先级邮箱队列的demo,测试高优先级的邮件是否会被先收到,然后将结果与第4节的实验结果进行对比。

越到文末我越浪,划水已经不能满足了,博主要去摸鱼~

6. 总结

按照惯例,对本文所讲的内容进行一个总结。

本文主要讲述了用于任务间通信的一些内核对象,主要有四个:消息队列和优先级消息队列,邮箱队列和优先级邮箱队列。

接下来列出一些重要的点:

在使用RTOS中的一些用于任务间通信的量时,要注意传递的是值还是地址。TencentOS-tiny中消息队列传输的是地址,而邮箱队列传递的是值。

消息队列和邮箱队列基于环形队列实现,遵循FIFO规则;而优先级消息队列和优先级邮箱队列基于优先级队列实现,遵循按照元素优先级取出的规则。

最后来回答题目中的问题:任务间通信为什么不使用全局变量?

① 无论是消息队列还是邮箱队列,都是利用了全局变量可以被随意访问的特性,所以使用时都会被定义为全局变量。

② 普通全局变量可用于一些简单的任务间通信场合。

③ 相较于普通全局变量,加入队列机制可以存储多个消息,加入pend-post机制可以拥有任务等待和唤醒的机制,用于解决队列已满或队列为空的问题。

本文就讲到这里啦~我是喜欢玩板子的小码农Mculover666,下期文章再见!

Mculover666 CSDN认证博客专家 嵌入式软件开发 IoT全栈开发
CSDN博客专家,微信公众号mculover666,凭借与生俱来的热爱专注于嵌入式领域,在自己折腾的同时,以文字的方式分享所玩、所思、所想、所悟,作为一个技术人,我们一起前进~
©️2020 CSDN 皮肤主题: 成长之路 设计师:Amelia_0503 返回首页