梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记原创精华

zzuliGjq

发布于 2022-8-3 13:33

浏览

1收藏

@toc

HarmonyOS内核开发

内核指的是LiteOS-m内核

任务管理

参考：

任务管理简介

从系统的角度看，任务是竞争系统资源的最小运行单元。任务可以使用或等待CPU、使用内存空间等系统资源，并独立于其它任务运行。
LiteOS的任务模块可以给用户提供多个任务，实现了任务之间的切换和通信，帮助用户管理业务程序流程。这样用户可以将更多的精力投入到业务功能的实现中。
LiteOS中的任务是抢占式调度机制，高优先级的任务可打断低优先级任务，低优先级任务必须在高优先级任务阻塞或结束后才能得到调度，同时支持时间片轮转调度方式。
LiteOS的任务默认有32个优先级(0-31)，最高优先级为0，最低优先级为31。（具体有多少个优先级，可以让用户自己去配置）

任务的相关概念

任务即是线程

任务状态
- 任务状态通常分为以下四种：
  - 就绪（Ready）：该任务在就绪列表中，只等待CPU。
  - 运行（Running）：该任务正在执行。
  - 阻塞（Blocked）：该任务不在就绪列表中。包含任务被挂起、任务被延时、任务正在等待信号量、读写队列或者等待读写事件等。
  - 退出态（Dead）：该任务运行结束，等待系统回收资源。
任务ID： 在任务创建时通过参数返回给用户，作为任务的一个非常重要的标识。
任务优先级： 优先级表示任务执行的优先顺序。任务入口函数：每个新任务得到调度后将执行的函数。
任务控制块TCB： 每一个任务都含有一个任务控制块(TCB)。TCB包含了任务上下文栈指针（stack pointer）、任务状态、任务优先级、任务ID、任务名、任务栈大小等信息。TCB可以反映出每个任务运行情况。
任务栈： 每一个任务都拥有一个独立的栈空间，我们称为任务栈。
任务上下文： 任务在运行过程中使用到的一些资源，如寄存器等，我们称为任务上下文。LiteOS在任务挂起的时候会将本任务的任务上下文信息，保存在自己的任务栈里面，以便任务恢复后，从栈空间中恢复挂起时的上下文信息，从而继续执行被挂起时被打断的代码。
任务切换： 任务切换包含获取就绪列表中最高优先级任务、切出任务上下文保存、切入任务上下文恢复等动作。

任务的调度机制

任务状态迁移说明

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

就绪态→运行态： 任务创建后进入就绪态，发生任务切换时，就绪列表中最高优先级的任务被执行，从而进入运行态，但此刻该任务依旧在就绪列表中。

运行态→阻塞态： 任务运行因挂起、延时、获取互斥锁、读消息、读信号量等待等，在就绪列表中被删除进入阻塞。

阻塞态→就绪态（阻塞态→运行态）： 阻塞的任务被恢复后（任务恢复、延时时间超时、读信号量超时或读到信号量等），此时被恢复的任务会被加入就绪列表，从而由阻塞态变成就绪态；此时如果被恢复任务的优先级高于正在运行任务的优先级，则会发生任务切换，将该任务由就绪态变成运行态。

就绪态→阻塞态： 任务也有可能在就绪态时被阻塞（挂起）。

运行态→就绪态： 有更高优先级任务创建或者恢复后，发生任务切换而进入就绪列表。

运行态→退出态： 任务运行结束，内核自动将此任务删除，此时由运行态变为退出态。

阻塞态→退出态： 阻塞的任务调用删除接口，任务状态由阻塞态变为退出态。

实现任务的管理

cmsis_os2的API任务接口简介

接口名	功能描述
osThreadNew	创建任务
osThreadTerminate	删除某个任务（一般是对非自任务操作)
osThreadSuspend	任务挂起
osThreadResume	任务恢复

创建任务： osThreadNew(osThreadFunc_t func,void * argument,const osThreadAttr_t * attr)
删除某个任务： osThreadTerminate(osThreadId_t thread_id);
任务挂起： osThreadSuspend(osThreadId_t thread_id)
任务恢复： osThreadResume (osThreadId_t thread_id)

创建任务接口详解

osThreadNew(osThreadFunc_t func, void * argument, const osThreadAttr_t * attr)

名称	描述
func	任务函数
argument	作为启动参数传递给任务函数的指针
attr	任务入口函数的参数列表
返回值	任务ID

源码：在applications\BearPi\BearPi-HM_Nano\sample\A1_kernal_thread\thread_example.c路径下，以下添加了部分注释

/*实现任务一和任务二交替运行，任务一执行1次、任务二执行2次*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

/*****任务一*****/
void thread1(void)
{
    int sum = 0;
    while (1)
    {
        printf("This is BearPi Harmony Thread1----%d\r\n", sum++);
        usleep(1000000);
    }
}

/*****任务二*****/
void thread2(void)
{
    int sum = 0;
    while (1)
    {
        printf("This is BearPi Harmony Thread2----%d\r\n", sum++);
        usleep(500000);
    }
}

/*****任务创建*****/
static void Thread_example(void)
{
    osThreadAttr_t attr;

    attr.name = "thread1";  // 函数名称
    attr.attr_bits = 0U;  // 属性位
    attr.cb_mem = NULL;  // 控制块指针
    attr.cb_size = 0U;  // 控制块内存大小
    attr.stack_mem = NULL;  // 任务栈的指针
    attr.stack_size = 1024 * 4;  // 任务栈的大小
    attr.priority = 25;  // 优先级，在cmsis_os2.0接口里面，数字越大，优先级越高

    if (osThreadNew((osThreadFunc_t)thread1, NULL, &attr) == NULL)  // 设置任务函数，并将参数传递进去，创建任务一
    {
        printf("Falied to create thread1!\n");
    }

    attr.name = "thread2";  // 重新赋值任务名

    if (osThreadNew((osThreadFunc_t)thread2, NULL, &attr) == NULL)
    {
        printf("Falied to create thread2!\n");
    }
    // 当两个任务优先级相同的时候，先创建的任务先运行
}

APP_FEATURE_INIT(Thread_example);

当两个任务优先级相同的时候，先创建的任务先运行

前面讲的是LiteOS中的任务优先级，现在讲的是cmsis-rtos接口封装后的任务优先级，这两个的规则是相反的

修改applications\BearPi\BearPi-HM_Nano\sample路径下BUILD.gn，指定 thread_example，编译、烧录、打印日志（不再描述，可参考前两篇博客）

结果如下

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

实验结果与扩展实验

实验现象：高优先级任务抢占低优先级任务进行运行，高优先级任务被挂起后，低优先级任务才能继续运行，最后两个任务都删除退出

源码

/*优先级任务抢占低优先级任务进行运行，高优先级任务被挂起后，低优先级任务才能继续运行，最后两个任务都删除退出*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

osThreadId_t threadHiID;  // 定义变量，任务id，用于进行任务挂起、恢复及删除
osThreadId_t threadLoID;  // 定义变量，任务id，用于进行任务挂起、恢复及删除

/*****任务一*****/
void threadHi(void)
{
    printf("enter threadHi\r\n");  // 任务一执行
    osDelay(1);  // 延时，任务进入阻塞态
    printf("threadHi delay done\r\n");  // 阻塞态结束
    osThreadSuspend(threadHiID);  // 将任务一挂起，进入阻塞态
    printf("threadHi osThreadResume success\r\n");  // 高优先级任务恢复成功
    osThreadTerminate(threadHiID);  // 删除任务一
}

/*****任务二*****/
void threadLo(void)
{
    // 任务一为阻塞状态时，任务二才能运行，为了看到抢占的现象，这里多打印几次
    for (int i = 0; i < 10; i++)
    {
        printf("enter threadLo----%d\r\n", i);  // 在还未打印10次的时候，延时结束，任务一由阻塞态转为就绪态，因任务一优先级比任务二高，可看到抢占现象，任务一转为运行态，任务二转为就绪态，等任务一挂起后任务二继续执行for循环
    }
    printf("threadHi osThreadSuspend success\r\n");  // 高优先级任务挂起成功
    osThreadResume(threadHiID);  // 通过低优先级任务恢复高优先级任务
    osThreadTerminate(threadLoID);  // 删除任务二
}

/*****任务创建*****/
static void Thread_example(void)
{
    osThreadAttr_t attr;

    attr.name = "threadHi";  // 函数名称
    attr.attr_bits = 0U;  // 属性位
    attr.cb_mem = NULL;  // 控制块指针
    attr.cb_size = 0U;  // 控制块内存大小
    attr.stack_mem = NULL;  // 任务栈的指针
    attr.stack_size = 1024 * 4;  // 任务栈的大小
    attr.priority = 25;  // 优先级，在cmsis_os2.0接口里面，数字越大，优先级越高
    threadHiID = osThreadNew((osThreadFunc_t)threadHi, NULL, &attr);  // 创建任务的时候获取任务id

    if (threadHiID == NULL)
    {
        printf("Falied to create threadHi!\n");
    }

    attr.name = "threadLo";  // 重新赋值任务名
    attr.priority = 24;  // 优先级，在cmsis_os2.0接口里面，数字越大，优先级越高
    threadLoID = osThreadNew((osThreadFunc_t)threadLo, NULL, &attr);  // 创建任务的时候获取任务id

    if (threadLoID == NULL)
    {
        printf("Falied to create threadLo!\n");
    }
    // 当两个任务优先级相同的时候，先创建的任务先运行
}

// APP_FEATURE_INIT(Thread_example);
// 将base\startup\services\bootstrap_lite\source\system_init.c路径下的HOS_SystemInit中的SAMGR_Bootstrap()注释掉，此时不能通过APP_FEATURE_INIT来启动Thread_example，应通过SYS_RUN来启动Thread_example，简化打印日志，更容易看懂
SYS_RUN(Thread_example);  // 通过SYS_RUN来启动Thread_example

编译、烧录、打印日志

日志如下：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

定时器管理

参考：

HarmonyOS内核开发—软件定时器_哔哩哔哩_bilibili

软件定时器基本概念

软件定时器，是基于系统Tick时钟中断且由软件来模拟的定时器，当经过设定的Tick时钟计数值后会触发用户定义的回调函数。定时精度与系统Tick时钟的周期有关。

硬件定时器受硬件的限制，数量上不足以满足用户的实际需求，因此为了满足用户需求，提供更多的定时器，LiteOS操作系统提供软件定时器功能。

软件定时器扩展了定时器的数量，允许创建更多的定时业务。

软件定时器功能上支持：

静态裁剪：能通过宏关闭软件定时器功能。
软件定时器创建。
软件定时器启动。
软件定时器停止。
软件定时器删除。
软件定时器剩余Tick数获取。

软件定时器运作机制

软件定时器使用了系统的一个队列和一个任务资源，软件定时器的触发遵循队列规则，先进先出。定时时间短的定时器总是比定时时间长的靠近队列头，满足优先被触发的准则。

软件定时器以Tick为基本计时单位，当用户创建并启动一个软件定时器时，Huawei LiteOS会根据当前系统Tick时间及用户设置的定时间隔确定该定时器的到期Tick时间，并将该定时器控制结构挂入计时全局链表。

当Tick中断到来时，在Tick中断处理函数中扫描软件定时器的计时全局链表，看是否有定时器超时，若有则将超时的定时器记录下来。

Tick中断处理函数结束后，软件定时器任务（优先级为最高）被唤醒，在该任务中调用之前记录下来的定时器的超时回调函数。

实现软件定时器创建

cmsis_os2的API软件定时器接口简介

接口名	功能描述
osTimerNew	创建定时器
osTimerStart	启动定时器
osTimerStop	停止定时器
osTimerDelete	删除定时器

创建定时器：osTimerNew (osTimerFunc_t func, osTimerType_t type, void *argument, const osTimerAttr_t *attr);
启动定时器：osTimerStart (osTimerId_t timer_id, uint32_t ticks);
停止定时器：osTimerStop (osTimerId_t timer_id);
删除定时器：osTimerDelete (osTimerId_t timer_id);

接口源码在kernel\liteos_m\components\cmsis\2.0\cmsis_os2.h中

官方案例：applications\BearPi\BearPi-HM_Nano\sample\A2_kernel_timer\Timer_example.c路径下，以下添加了部分注释

/*定时器1每隔1秒钟执行一次，定时器2每隔3秒钟执行一次*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

uint32_t exec1, exec2;

/***** 定时器1 回调函数 *****/
void Timer1_Callback(void *arg)
{
    (void)arg;
    printf("This is BearPi Harmony Timer1_Callback!\r\n");
}

/***** 定时器2 回调函数 *****/
void Timer2_Callback(void *arg)
{
    (void)arg;
    printf("This is BearPi Harmony Timer2_Callback!\r\n");
}

/***** 定时器创建 *****/
static void Timer_example(void)
{
    osTimerId_t id1, id2;
    uint32_t timerDelay;
    osStatus_t status;

    exec1 = 1U;
    id1 = osTimerNew(Timer1_Callback, osTimerPeriodic, &exec1, NULL);  // 定时器创建，返回一个id，参数分别是定时器回调函数、定时器类型（单次或周期性，osTimerOnce为单次，osTimerPeriodic为周期性）、给回调函数传递的参数、定时器的属性参数
    if (id1 != NULL)
    {

        // Hi3861 1U=10ms,100U=1S
        timerDelay = 100U;

        status = osTimerStart(id1, timerDelay);  // 启动定时器
        if (status != osOK)
        {
            // Timer could not be started
        }
    }

    exec2 = 1U;
    id2 = osTimerNew(Timer2_Callback, osTimerPeriodic, &exec2, NULL);
    if (id2 != NULL)
    {

        // Hi3861 1U=10ms,300U=3S
        timerDelay = 300U;

        status = osTimerStart(id2, timerDelay);
        if (status != osOK)
        {
            // Timer could not be started
        }
    }
}

APP_FEATURE_INIT(Timer_example);

修改applications\BearPi\BearPi-HM_Nano\sample路径下BUILD.gn，指定 timer_example，编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

软件定时器扩展实验

定时器的停止与删除

源码：

/*定时器1执行一次后先停止后删除，定时器2每隔3秒钟执行一次*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

uint32_t exec1, exec2;

/***** 定时器1 回调函数 *****/
void Timer1_Callback(void *arg)
{
    (void)arg;
    printf("This is BearPi Harmony Timer1_Callback!\r\n");
}

/***** 定时器2 回调函数 *****/
void Timer2_Callback(void *arg)
{
    (void)arg;
    printf("This is BearPi Harmony Timer2_Callback!\r\n");
}

/***** 定时器创建 *****/
static void Timer_example(void)
{
    osTimerId_t id1, id2;
    uint32_t timerDelay;
    osStatus_t status;

    exec1 = 1U;
    id1 = osTimerNew(Timer1_Callback, osTimerOnce, &exec1, NULL);  // 定时器创建，返回一个id，参数分别是定时器回调函数、定时器类型（单次或周期性，osTimerOnce为单次，osTimerPeriodic为周期性）、给回调函数传递的参数、定时器的属性参数
    if (id1 != NULL)
    {

        // Hi3861 1U=10ms,100U=1S
        timerDelay = 100U;

        status = osTimerStart(id1, timerDelay);  // 启动定时器
        if (status != osOK)
        {
            // Timer could not be started
        }
    }

    osDelay(50U);  // 延时0.5秒
    status = osTimerStop(id1);  // 停止定时器1，只有在定时器还在运行的时候才能停止成功
    if (status != osOK)
    {
        printf("stop Timer1 failed\r\n");  // 若停止失败则打印
    }
    else
    {
        printf("stop Timer1 success\r\n");  // 若停止成功则打印
    }

    status = osTimerStart(id1, timerDelay);  // 重新启动定时器
    if (status != osOK)
    {
        printf("start Timer1 failed\r\n");  // 若启动失败则打印
    }

    osDelay(200U);  // 延时2秒
    status = osTimerDelete(id1);  // 删除定时器1，无论定时器是否在运行都能删除成功
    if (status != osOK)
    {
        printf("delete Timer1 failed\r\n");  // 若删除失败则打印
    }
    else
    {
        printf("delete Timer1 success\r\n");  // 若删除成功则打印
    }

    exec2 = 1U;
    id2 = osTimerNew(Timer2_Callback, osTimerPeriodic, &exec2, NULL);
    if (id2 != NULL)
    {

        // Hi3861 1U=10ms,300U=3S
        timerDelay = 300U;

        status = osTimerStart(id2, timerDelay);
        if (status != osOK)
        {
            // Timer could not be started
        }
    }
}

APP_FEATURE_INIT(Timer_example);

编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

对于单次定时器，只有在定时器运行期间才能停止定时器，而删除定时器可以是任何时候

信号量

参考：

HarmonyOS内核开发—信号量_哔哩哔哩_bilibili

信号量基本概念

1、信号量（Semaphore）是一种实现任务间通信的机制，实现任务之间同步或临界资源的互斥访问。常用于协助一组相互竞争的任务来访问临界资源。

2、在多任务系统中，各任务之间需要同步或互斥实现临界资源的保护，信号量功能可以为用户提供这方面的支持。

3、通常一个信号量的计数值用于对应有效的资源数，表示剩下的可被占用的互斥资源数。其值的含义分两种情况：

1）0，表示没有积累下来的Post信号量操作，且有可能有在此信号量上阻塞的任务。

2）正值，表示有一个或多个Post信号量操作。

4、以同步为目的的信号量和以互斥为目的的信号量在使用有如下不同：

1）用作互斥时，信号量创建后记数是满的，在需要使用临界资源时，先取信号量，使其变空，这样其他任务需要使用临界资源时就会因为无法取到信号量而阻塞，从而保证了临界资源的安全。

2）用作同步时，信号量在创建后被置为空，任务1取信号量而阻塞，任务2在某种条件发生后，释放信号量，于是任务1得以进入READY或RUNNING态，从而达到了两个任务间的同步。

信号量运作机制

信号量运作原理

1、信号量初始化，为配置的N个信号量申请内存（N值可以由用户自行配置，受内存限制），并把所有的信号量初始化成未使用，并加入到未使用链表中供系统使用。

2、信号量创建，从未使用的信号量链表中获取一个信号量资源，并设定初值。

3、信号量申请，若其计数器值大于0，则直接减1返回成功。否则任务阻塞，等待其它任务释放该信号量，等待的超时时间可设定。当任务被一个信号量阻塞时，将该任务挂到信号量等待任务队列的队尾。

4、信号量释放，若没有任务等待该信号量，则直接将计数器加1返回。否则唤醒该信号量等待任务队列上的第一个任务。

5、信号量删除，将正在使用的信号量置为未使用信号量，并挂回到未使用链表

6、信号量允许多个任务在同一时刻访问同一资源，但会限制同一时刻访问此资源的最大任务数目。访问同一资源的任务数达到该资源的最大数量时，会阻塞其他试图获取该资源的任务，直到有任务释放该信号量。

信号量运作示意图

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

公共资源有四个任务数，信号量都分别被线程1、2、3、4获取后，此时此资源就会锁定而不让线程5进入，线程5及后面的线程都进入阻塞模式，当线程1工作完成而释放出信号量，线程5立即获得信号而得到执行。如此往复。

实现信号量功能

cmsis_os2的API信号量接口简介

接口名	功能描述
osSemaphoreNew	创建信号量
osSemaphoreAcquire	获取信号量
osSemaphoreRelease	释放信号量
osSemaphoreDelete	删除信号量

创建信号量：osSemaphoreNew (uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr);
获取信号量：osSemaphoreAcquire (osSemaphoreId_t semaphore_id, uint32_t timeout);
释放信号量：osSemaphoreRelease (osSemaphoreId_t semaphore_id);
删除信号量：osMutexDelete (osMutexId_t mutex_id);

osStatus_t osSemaphoreRelease(osSemaphoreId_t semaphore_id)

描述：
函数osSemaphoreRelease释放由参数semaphore_id指定的信号量对象的标记

注意 :该函数可以在中断服务例程调用

参数：

名字	描述
semaphore_id	由osSemaphoreNew获得的信号量ID

案例代码在applications\BearPi\BearPi-HM_Nano\sample\A5_kernel_semaphore\Semaphore_example.c路径下，以下添加了部分注释：

/*每隔一秒钟，Thread_Semaphore2 get Semap和Thread_Semaphore3 get Semap同时打印*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

osSemaphoreId_t sem1;

void Thread_Semaphore1(void)
{
    while (1)
    {
        //申请两次sem1信号量，使得Thread_Semaphore2和Thread_Semaphore3能同步执行
        osSemaphoreRelease(sem1);  // 每释放一次信号量计数值加1

        //此处若只申请一次信号量，则Thread_Semaphore2和Thread_Semaphore3会交替运行。
        osSemaphoreRelease(sem1);

        printf("Thread_Semaphore1 Release  Semap \n");
        osDelay(100);  // 延时1s
    }
}
void Thread_Semaphore2(void)
{
    while (1)
    {
        //等待sem1信号量
        osSemaphoreAcquire(sem1, osWaitForever);  // 每申请一次信号量计数器减1，能不能申请到取决于信号量计数值是否大于0，超时时间是永久等待

        printf("Thread_Semaphore2 get Semap \n");
        osDelay(1);  // 延时10ms
    }
}

void Thread_Semaphore3(void)
{
    while (1)
    {
        //等待sem1信号量
        osSemaphoreAcquire(sem1, osWaitForever);

        printf("Thread_Semaphore3 get Semap \n");
        osDelay(1);
    }
}

void Semaphore_example(void)
{
    // 创建三个任务，三个任务优先级相同
    osThreadAttr_t attr;

    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = 1024 * 4;
    attr.priority = 24;

    attr.name = "Thread_Semaphore1";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore1, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore1!\n");
    }
    attr.name = "Thread_Semaphore2";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore2, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore2!\n");
    }
    attr.name = "Thread_Semaphore3";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore3, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore3!\n");
    }

    sem1 = osSemaphoreNew(4, 0, NULL);  // 创建信号量，参数分别是信号量最大计数值、信号量计数器初始值、信号量的属性
    if (sem1 == NULL)
    {
        printf("Falied to create Semaphore1!\n");
    }
}
APP_FEATURE_INIT(Semaphore_example);

每释放一次信号量计数值加1，每申请一次信号量计数器减1，能不能申请到取决于信号量计数值是否大于0，计数值是否大于0的时候才能申请成功，否则申请失败

修改applications\BearPi\BearPi-HM_Nano\sample路径下BUILD.gn，指定 semaphore_example，编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

信号量扩展实验

osSemaphoreAcquire超时时间的使用

osStatus_t osSemaphoreAcquire(osSemaphoreId_t semaphore_id,uint32_t timeout)

描述：
阻塞函数osSemaphoreAcquire一直等待，直到由参数semaphore_id指定的信号量对象的标记可用为止。如果一个令牌可用，该函数立即返回并递减令牌计数。

注意：如果参数timeout设置为0，可以从中断服务例程调用。

参数：

名字	描述
semaphore_id	由osSemaphoreNew获得的信号量ID
timeout	超时值

/*osSemaphoreAcquire超时时间的使用。首先是任务一释放两次信号量，信号量计数值变为2，延时1s，延时期间任务二连续申请两次信号量之后，信号量计数值变为0，再次申请申请失败挂起0.5s（超时时间），接着任务三申请同样被挂起，然后任务二挂起0.5s时间结束，继续申请，还是会被挂起0.5s，此时任务一延时结束（因为任务一抢占任务二执行，所以Thread_Semaphore1 Release  Semap在第二次Thread_Semaphore2 get Semap failed之前打印），释放两次信号量，信号量计数值变为2，延时1s，之后任务二申请信号量申请成功，因为任务三一直在挂起，所以也能申请成功，延时1s。此时信号量计数值又变为0，循环往复*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

osSemaphoreId_t sem1;

void Thread_Semaphore1(void)
{
    while (1)
    {
        //申请两次sem1信号量
        osSemaphoreRelease(sem1);  // 每释放一次信号量计数值加1

        osSemaphoreRelease(sem1);

        printf("Thread_Semaphore1 Release  Semap \n");
        osDelay(100);  // 延时1s
    }
}
void Thread_Semaphore2(void)
{
    osStatus_t status;  // 定义变量，接收osSemaphoreAcquire的返回值
    while (1)
    {
        //等待sem1信号量
        status = osSemaphoreAcquire(sem1, 50U);  // 每申请一次信号量计数器减1，能不能申请到取决于信号量计数值是否大于0，超时时间是0.5s（申请不到的时候挂起0.5s）
        if(status != osOK)
        {
            printf("Thread_Semaphore2 get Semap failed\n");
        }
        else
        {
            printf("Thread_Semaphore2 get Semap success\n");
        }
    }
}

void Thread_Semaphore3(void)
{
    while (1)
    {
        //等待sem1信号量
        osSemaphoreAcquire(sem1, osWaitForever);

        printf("Thread_Semaphore3 get Semap \n");
        osDelay(1);
    }
}

void Semaphore_example(void)
{
    // 创建三个任务，三个任务优先级相同
    osThreadAttr_t attr;

    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = 1024 * 4;
    attr.priority = 24;

    attr.name = "Thread_Semaphore1";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore1, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore1!\n");
    }
    attr.name = "Thread_Semaphore2";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore2, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore2!\n");
    }
    attr.name = "Thread_Semaphore3";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore3, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore3!\n");
    }

    sem1 = osSemaphoreNew(4, 0, NULL);  // 创建信号量，参数分别是信号量最大计数值、信号量计数器初始值、信号量的属性
    if (sem1 == NULL)
    {
        printf("Falied to create Semaphore1!\n");
    }
}
APP_FEATURE_INIT(Semaphore_example);

编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

osSemaphoreDelete的使用

osSemaphoreDelete(osSemaphoreId_t semaphore_id)

删除指定的信号量，删除之后再执行获取信号量、释放信号量等操作都会失败

/*osSemaphoreDelete的使用，删除信号量后，获取。释放等操作都会失败*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

osSemaphoreId_t sem1;

void Thread_Semaphore1(void)
{
    osStatus_t status;  // 定义变量，接收osSemaphoreRelease的返回值

    while (1)
    {
        //申请信号量
        status = osSemaphoreRelease(sem1);  // 每释放一次信号量计数值加1
        if(status != osOK)
        {
            printf("Thread_Semaphore1 Release Semap failed\n");
        }
        else
        {
            printf("Thread_Semaphore1 Release Semap success\n");
        }

        osDelay(100);  // 延时1s
    }
}
void Thread_Semaphore2(void)
{
    osStatus_t status;  // 定义变量，接收osSemaphoreAcquire的返回值
    while (1)
    {
        //等待sem1信号量
        status = osSemaphoreAcquire(sem1, 50U);  // 每申请一次信号量计数器减1，能不能申请到取决于信号量计数值是否大于0，超时时间是0.5s
        if(status != osOK)
        {
            printf("Thread_Semaphore2 get Semap failed\n");
        }
        else
        {
            printf("Thread_Semaphore2 get Semap success\n");
            osSemaphoreDelete(sem1);  // 申请信号量能获取成功则将信号量删除
        }
    }
}

void Thread_Semaphore3(void)
{
    osStatus_t status;  // 定义变量，接收osSemaphoreAcquire的返回值
    while (1)
    {
        //等待sem1信号量
        status = osSemaphoreAcquire(sem1, osWaitForever);
        if(status != osOK)
        {
            printf("Thread_Semaphore3 get Semap failed\n");
        }
        else
        {
            printf("Thread_Semaphore3 get Semap success\n");
        }

        osDelay(1);
    }
}

void Semaphore_example(void)
{
    // 创建三个任务，三个任务优先级相同
    osThreadAttr_t attr;

    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = 1024 * 4;
    attr.priority = 24;

    attr.name = "Thread_Semaphore1";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore1, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore1!\n");
    }
    attr.name = "Thread_Semaphore2";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore2, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore2!\n");
    }
    attr.name = "Thread_Semaphore3";
    if (osThreadNew((osThreadFunc_t)Thread_Semaphore3, NULL, &attr) == NULL)
    {
        printf("Falied to create Thread_Semaphore3!\n");
    }

    sem1 = osSemaphoreNew(4, 0, NULL);  // 创建信号量，参数分别是信号量最大计数值、信号量计数器初始值、信号量的属性
    if (sem1 == NULL)
    {
        printf("Falied to create Semaphore1!\n");
    }
}
APP_FEATURE_INIT(Semaphore_example);

编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

事件管理

参考：

HarmonyOS内核开发—事件管理_哔哩哔哩_bilibili

事件基本概念

事件是一种实现任务间通信的机制，可用于实现任务间的同步，但事件通信只能是事件类型的通信，无数据传输。一个任务可以等待多个事件的发生：可以是任意一个事件发生时唤醒任务进行事件处理；也可以是几个事件都发生后才唤醒任务进行事件处理。事件集合用32位无符号整型变量来表示，每一位代表一个事件。

多任务环境下，任务之间往往需要同步操作。事件可以提供一对多、多对多的同步操作。一对多同步模型：一个任务等待多个事件的触发；多对多同步模型：多个任务等待多个事件的触发。

任务可以通过创建事件控制块来实现对事件的触发和等待操作。LiteOS的事件仅用于任务间的同步。

事件运作机制

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

读事件时，可以根据入参事件掩码类型uwEventMask读取事件的单个或者多个事件类型。事件读取成功后，如果设置LOS_WAITMODE_CLR会清除已读取到的事件类型，反之不会清除已读到的事件类型，需显式清除。可以通过入参选择读取模式，读取事件掩码类型中所有事件还是读取事件掩码类型中任意事件。

写事件时，对指定事件写入指定的事件类型，可以一次同时写多个事件类型。写事件会触发任务调度。

清除事件时，根据入参事件和待清除的事件类型，对事件对应位进行清0操作。

实现事件功能

cmsis_os2的API事件接口简介

接口名	功能描述
osEventFlagsNew	创建事件标记对象
osEventFlagsSet	设置事件标记
osEventFlagsWait	等待事件标记触发
osEventFlagsDelete	删除事件标记对象

创建事件标记对象： osEventFlagsNew (const osEventFlagsAttr_t *attr);

设置事件标记： osEventFlagsSet (osEventFlagsId_t ef_id, uint32_t flags);

等待事件标记触发： osEventFlagsWait (osEventFlagsId_t ef_id, uint32_t flags, uint32_t options, uint32_t timeout);

删除事件标记对象： osEventFlagsDelete (osEventFlagsId_t ef_id);

案例代码在applications\BearPi\BearPi-HM_Nano\sample\A3_kernel_event\Event_example.c路径下，以下添加了部分注释：

/*一个事件来同步一个任务*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

#define FLAGS_MSK1 0x00000001U

osEventFlagsId_t evt_id; // event flags id

/***** 发送事件 *****/
void Thread_EventSender(void *argument)
{
  (void)argument;
  while (1)
  {
    osEventFlagsSet(evt_id, FLAGS_MSK1);  // 设置事件标记

    //suspend thread
    osThreadYield();

    osDelay(100);  // 延时1s
  }
}

/***** 接收事件 *****/
void Thread_EventReceiver(void *argument)
{
  (void)argument;
  uint32_t flags;

  while (1)
  {
    flags = osEventFlagsWait(evt_id, FLAGS_MSK1, osFlagsWaitAny, osWaitForever);  // 永久阻塞，等待事件标记的到来
    printf("Receive Flags is %d\n", flags);
  }
}

/***** 创建事件 *****/
static void Event_example(void)
{
  evt_id = osEventFlagsNew(NULL);  // 创建事件标记对象，并将事件标记id赋值给evt_id
  if (evt_id == NULL)
  {
    printf("Falied to create EventFlags!\n");
  }

  // 创建两个任务Thread_EventSender和Thread_EventReceiver
  osThreadAttr_t attr;

  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 1024 * 4;
  attr.priority = 25;

  attr.name = "Thread_EventSender";
  if (osThreadNew(Thread_EventSender, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_EventSender!\n");
  }
  attr.name = "Thread_EventReceiver";
  if (osThreadNew(Thread_EventReceiver, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_EventReceiver!\n");
  }
}

APP_FEATURE_INIT(Event_example);

修改applications\BearPi\BearPi-HM_Nano\sample路径下BUILD.gn，指定 event_example，编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

事件扩展实验

/*多个事件来同步多个任务。只有当3个事件同时触发才能触发任务，否则永久阻塞*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

#define FLAGS_MSK1 0x00000001U
#define FLAGS_MSK2 0x00000002U
#define FLAGS_MSK3 0x00000003U

osEventFlagsId_t evt_id; // event flags id

/***** 发送事件 *****/
void Thread_EventSender(void *argument)
{
  (void)argument;
  while (1)
  {
    osEventFlagsSet(evt_id, FLAGS_MSK1);  // 设置事件标记
    osEventFlagsSet(evt_id, FLAGS_MSK2);  // 设置事件标记
    osEventFlagsSet(evt_id, FLAGS_MSK3);  // 设置事件标记

    //suspend thread
    osThreadYield();

    osDelay(100);  // 延时1s
  }
}

/***** 接收事件 *****/
void Thread_EventReceiver(void *argument)
{
  (void)argument;
  uint32_t flags;

  while (1)
  {
    flags = osEventFlagsWait(evt_id, FLAGS_MSK1|FLAGS_MSK2|FLAGS_MSK3, osFlagsWaitAll, osWaitForever);  // 永久阻塞，等待三个事件标记全部到来（osFlagsWaitAll是逻辑与，osFlagsWaitAny是逻辑或）
    printf("Receive Flags is %d\n", flags);
  }
}

/***** 创建事件 *****/
static void Event_example(void)
{
  evt_id = osEventFlagsNew(NULL);  // 创建事件标记对象，并将事件标记id赋值给evt_id
  if (evt_id == NULL)
  {
    printf("Falied to create EventFlags!\n");
  }

  // 创建两个任务Thread_EventSender和Thread_EventReceiver
  osThreadAttr_t attr;

  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 1024 * 4;
  attr.priority = 25;

  attr.name = "Thread_EventSender";
  if (osThreadNew(Thread_EventSender, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_EventSender!\n");
  }
  attr.name = "Thread_EventReceiver";
  if (osThreadNew(Thread_EventReceiver, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_EventReceiver!\n");
  }
}

APP_FEATURE_INIT(Event_example);

编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

互斥锁

参考：

HarmonyOS内核开发—互斥锁_哔哩哔哩_bilibili

互斥锁基本概念

互斥锁又称互斥型信号量，是一种特殊的二值性信号量，用于实现对共享资源的独占式处理。
任意时刻互斥锁的状态只有两种：开锁或闭锁。
当有任务持有时，互斥锁处于闭锁状态，这个任务获得该互斥锁的所有权。
当该任务释放时，该互斥锁被开锁，任务失去该互斥锁的所有权。
当一个任务持有互斥锁时，其他任务将不能再对该互斥锁进行开锁或持有。
多任务环境下往往存在多个任务竞争同一共享资源的应用场景，互斥锁可被用于对共享资源的保护从而实现独占式访问。另外，互斥锁可以解决信号量存在的优先级翻转问题。
LiteOS提供的互斥锁具有如下特点： 通过优先级继承算法，解决优先级翻转问题。

互斥锁运作机制

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

多任务环境下会存在多个任务访问同一公共资源的场景，而有些公共资源是非共享的，需要任务进行独占式处理。互斥锁怎样来避免这种冲突呢？用互斥锁处理非共享资源的同步访问时，如果有任务访问该资源，则互斥锁为加锁状态。此时其他任务如果想访问这个公共资源则会被阻塞，直到互斥锁被持有该锁的任务释放后，其他任务才能重新访问该公共资源，此时互斥锁再次上锁，如此确保同一时刻只有一个任务正在访问这个公共资源，保证了公共资源操作的完整性。

实现互斥锁功能

cmsis_os2的API互斥锁接口简介

接口名	功能描述
osMutexNew	创建互斥锁
osMutexAcquire	获取互斥锁
osMutexRelease	释放互斥锁
osMutexDelete	删除互斥锁

创建互斥锁： osMutexNew (const osMutexAttr_t *attr);

获取互斥锁： osMutexAcquire (osMutexId_t mutex_id, uint32_t timeout);

释放互斥锁： osMutexRelease (osMutexId_t mutex_id);

删除互斥锁： osMutexDelete (osMutexId_t mutex_id);

案例代码在applications\BearPi\BearPi-HM_Nano\sample\A4_kernel_mutex\Mutex_example.c目录下，以下添加了部分注释：

/*资源独占式处理。HighPrioThread任务和MidPrioThread任务延时挂起1s，LowPrioThread任务最先执行，获取互斥锁，延时期间，HighPrioThread任务与MidPrioThread任务执行，HighPrioThread任务获取不到互斥锁被挂起，MidPrioThread任务执行println函数，MidPrioThread is runing.打印3次，LowPrioThread延时结束，HighPrioThread任务获取到互斥锁，并延时挂起3s，此时MidPrioThread任务再次执行，打印3次MidPrioThread is runing.，之后HighPrioThread任务释放互斥锁，LowPrioThread任务又获取到互斥锁，循环往复*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

osMutexId_t mutex_id;

void HighPrioThread(void)
{
  // wait 1s until start actual work
  osDelay(100U);

  while (1)
  {
    // try to acquire mutex
    osMutexAcquire(mutex_id, osWaitForever);

    printf("HighPrioThread is runing.\r\n");
    osDelay(300U);
    osMutexRelease(mutex_id);
  }
}

void MidPrioThread(void)
{
  // wait 1s until start actual work
  osDelay(100U);

  while (1)
  {
    printf("MidPrioThread is runing.\r\n");
    osDelay(100);
  }
}

void LowPrioThread(void)
{
  while (1)
  {
    osMutexAcquire(mutex_id, osWaitForever);  // 获取互斥锁
    printf("LowPrioThread is runing.\r\n");

    // block mutex for 3s
    osDelay(300U);  // 延时3s，此时独自持有互斥锁3s
    osMutexRelease(mutex_id);  // 释放互斥锁
  }
}

void Mutex_example(void)
{
  osThreadAttr_t attr;

  // 创建3个优先级不同的任务
  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 1024 * 4;

  attr.name = "HighPrioThread";
  attr.priority = 24;
  if (osThreadNew((osThreadFunc_t)HighPrioThread, NULL, &attr) == NULL)
  {
    printf("Falied to create HighPrioThread!\n");
  }
  attr.name = "MidPrioThread";
  attr.priority = 25;
  if (osThreadNew((osThreadFunc_t)MidPrioThread, NULL, &attr) == NULL)
  {
    printf("Falied to create MidPrioThread!\n");
  }
  attr.name = "LowPrioThread";
  attr.priority = 26;
  if (osThreadNew((osThreadFunc_t)LowPrioThread, NULL, &attr) == NULL)
  {
    printf("Falied to create LowPrioThread!\n");
  }
  mutex_id = osMutexNew(NULL);  // 新建互斥锁
  if (mutex_id == NULL)
  {
    printf("Falied to create Mutex!\n");
  }
}
APP_FEATURE_INIT(Mutex_example);

修改applications\BearPi\BearPi-HM_Nano\sample路径下BUILD.gn，指定 mutex_example，编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

互斥锁扩展实验

/*当使用osMutexDelete删除互斥锁时，在执行osMutexDelete、osMutexAcquire、osMutexRelease操作都会失败*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"

osMutexId_t mutex_id;

void HighPrioThread(void)
{
  // wait 1s until start actual work
  osDelay(100U);

  osStatus_t status;  // 定义变量，接收osMutexAcquire或者osMutexRelease的返回值
  while (1)
  {
    // try to acquire mutex
    status = osMutexAcquire(mutex_id, osWaitForever);
    if (status != osOK)
    {
      printf("acquire mutex failed\r\n");
    }
    else
    {
      printf("acquire mutex success\r\n");
    }

    printf("HighPrioThread is runing.\r\n");
    osDelay(300U);

    status = osMutexRelease(mutex_id);
    if (status != osOK)
    {
      printf("release mutex failed\r\n");
    }
    else
    {
      printf("release mutex success\r\n");
    }
  }
}

void MidPrioThread(void)
{
  // wait 1s until start actual work
  osDelay(100U);

  while (1)
  {
    printf("MidPrioThread is runing.\r\n");
    osDelay(100);
  }
}

void LowPrioThread(void)
{
  osStatus_t status;  // 定义变量，接收osMutexAcquire或者osMutexRelease的返回值

  while (1)
  {
    status = osMutexAcquire(mutex_id, osWaitForever);  // 获取互斥锁
    printf("LowPrioThread is runing.\r\n");
    if (status != osOK)
    {
      printf("acquire mutex failed\r\n");
    }
    else
    {
      printf("acquire mutex success\r\n");
    }

    // block mutex for 3s
    osDelay(300U);  // 延时3s，此时独自持有互斥锁3s

    status = osMutexRelease(mutex_id);  // 释放互斥锁
    if (status != osOK)
    {
      printf("release mutex failed\r\n");
    }
    else
    {
      printf("release mutex success\r\n");
    }
  }
}

void Mutex_example(void)
{
  osThreadAttr_t attr;
  osStatus_t status;  // 定义变量，接收osMutexDelete的返回值

  // 创建3个优先级不同的任务
  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 1024 * 4;

  attr.name = "HighPrioThread";
  attr.priority = 24;
  if (osThreadNew((osThreadFunc_t)HighPrioThread, NULL, &attr) == NULL)
  {
    printf("Falied to create HighPrioThread!\n");
  }
  attr.name = "MidPrioThread";
  attr.priority = 25;
  if (osThreadNew((osThreadFunc_t)MidPrioThread, NULL, &attr) == NULL)
  {
    printf("Falied to create MidPrioThread!\n");
  }
  attr.name = "LowPrioThread";
  attr.priority = 26;
  if (osThreadNew((osThreadFunc_t)LowPrioThread, NULL, &attr) == NULL)
  {
    printf("Falied to create LowPrioThread!\n");
  }
  mutex_id = osMutexNew(NULL);  // 新建互斥锁
  if (mutex_id == NULL)
  {
    printf("Falied to create Mutex!\n");
  }
  
  status = osMutexDelete(mutex_id);  // 删除互斥锁
  if (status != osOK)
  {
    printf("delete mutex failed\r\n");
  }
  else
  {
    printf("delete mutex success\r\n");
  }

  status = osMutexDelete(mutex_id);  // 再次删除
  if (status != osOK)
  {
    printf("delete mutex failed\r\n");
  }
  else
  {
    printf("delete mutex success\r\n");
  }
}
APP_FEATURE_INIT(Mutex_example);

编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

消息队列

参考：

HarmonyOS内核开发—消息队列_哔哩哔哩_bilibili

消息队列基本概念

消息队列，是一种常用于任务间通信的数据结构，实现了接收来自任务或中断的不固定长度的消息，并根据不同的接口选择传递消息是否存放在自己空间。任务能够从队列里面读取消息，当队列中的消息是空时，挂起读取任务；当队列中有新消息时，挂起的读取任务被唤醒并处理新消息。

用户在处理业务时，消息队列提供了异步处理机制，允许将一个消息放入队列，但并不立即处理它，同时队列还能起到缓冲消息作用。

LiteOS中使用队列数据结构实现任务异步通信工作，具有如下特性：

消息以先进先出方式排队，支持异步读写工作方式。
读队列和写队列都支持超时机制。
发送消息类型由通信双方约定，可以允许不同长度（不超过队列节点最大值）消息。
一个任务能够从任意一个消息队列接收和发送消息。
多个任务能够从同一个消息队列接收和发送消息。
当队列使用结束后，如果是动态申请的内存，需要通过释放内存函数回收。

消息队列运作机制

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

创建队列时，根据用户传入队列长度和消息节点大小来开辟相应的内存空间以供该队列使用，返回队列ID。

在队列控制块中维护一个消息头节点位置Head和一个消息尾节点位置Tail来表示当前队列中消息存储情况。Head表示队列中被占用消息的起始位置。Tail表示队列中被空闲消息的起始位置。刚创建时Head和Tail均指向队列起始位置。

写队列时，根据Tail找到被占用消息节点末尾的空闲节点作为数据写入对象。

读队列时，根据Head找到最先写入队列中的消息节点进行读取。

删除队列时，根据传入的队列ID寻找到对应的队列，把队列状态置为未使用，释放原队列所占的空间，对应的队列控制头置为初始状态。

实现消息队列功能

cmsis_os2的API消息队列接口简介

接口名	功能描述
osMessageQueueNew	创建消息队列
osMessageQueuePut	发送消息
osMessageQueueGet	获取消息
osMessageQueueDelete	删除消息队列

创建消息队列： osMessageQueueNew(uint32_t msg_count, uint32_t msg_size, const osMessageQueueAttr_t *attr)

发送消息： osMessageQueuePut(osMessageQueueId_t mq_id, const void *msg_ptr, uint8_t msg_prio, uint32_t timeout);

获取消息： osMessageQueueGet(osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout);

删除消息队列： osMessageQueueDelete(osMessageQueueId_t mq_id);

案例代码在applications\BearPi\BearPi-HM_Nano\sample\A6_kernel_message\Message_example.c目录下，以下添加了部分注释：

/*每隔1s，消息打印一次*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"


//number of Message Queue Objects
#define MSGQUEUE_OBJECTS 16

typedef struct
{
  //object data type
  char *Buf;
  
  uint8_t Idx;
} MSGQUEUE_OBJ_t;

MSGQUEUE_OBJ_t msg;

//message queue id
osMessageQueueId_t mid_MsgQueue;   

void Thread_MsgQueue1(void *argument)
{
  (void)argument;

  //do some work...
  msg.Buf = "Hello BearPi-HM_Nano!";
  msg.Idx = 0U;
  while (1)
  {
    osMessageQueuePut(mid_MsgQueue, &msg, 0U, 0U);  // 向消息队列中发送信息，参数分别表示消息队列id、发送的消息、消息队列的优先级、超时时间

    //suspend thread
    osThreadYield();
    osDelay(100);  // 延时1s，以1s的频率来发送消息
  }
}

void Thread_MsgQueue2(void *argument)
{
  (void)argument;
  osStatus_t status;

  while (1)
  {
    //Insert thread code here...

    //wait for message
    status = osMessageQueueGet(mid_MsgQueue, &msg, NULL, 0U);  // 获取消息，参数分别表示消息队列id、要获取消息的缓冲区指针、消息队列的优先级、超时时间
    if (status == osOK)
    {
      printf("Message Queue Get msg:%s\n", msg.Buf);
    }
  }
}

static void Message_example(void)
{

  mid_MsgQueue = osMessageQueueNew(MSGQUEUE_OBJECTS, 100, NULL);  // 创建消息队列，参数分别表示消息队列中的最大消息数、消息队列中消息大小，消息队列的属性
  if (mid_MsgQueue == NULL)
  {
    printf("Falied to create Message Queue!\n");
  }

  // 创建两个优先级相同的任务
  osThreadAttr_t attr;

  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 1024 * 10;
  attr.priority = 25;

  attr.name = "Thread_MsgQueue1";
  if (osThreadNew(Thread_MsgQueue1, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_MsgQueue1!\n");
  }
  attr.name = "Thread_MsgQueue2";
  if (osThreadNew(Thread_MsgQueue2, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_MsgQueue2!\n");
  }
}

APP_FEATURE_INIT(Message_example);

修改applications\BearPi\BearPi-HM_Nano\sample路径下BUILD.gn，指定 message_example，编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

消息队列扩展实验

/*删除消息队列。开始时，两任务按照顺序执行，Thread_MsgQueue1任务发送消息后，延时1s，延时期间，Thread_MsgQueue2任务获取消息队列中的消息数为1，之后获取消息，消息队列中的消息数会减1，变为0，延时3s，1s后，Thread_MsgQueue1延时结束，又发送了2条消息后Thread_MsgQueue2延时结束，获取消息队列中的消息数为2，之后获取消息，消息队列中的消息数减1，变为1，再延时3s，Thread_MsgQueue1发送了3条消息后，Thread_MsgQueue2延时结束，获取消息队列中的消息数为4，之后获取消息，消息队列中的消息数会减1，变为3，之后循环往复，逐次加2，直到消息队列中的消息数为16，删除消息队列。读队列时，根据最先写入队列中的消息节点进行读取，所以打印出的idx从0逐次加1*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ohos_init.h"
#include "cmsis_os2.h"


//number of Message Queue Objects
#define MSGQUEUE_OBJECTS 16

typedef struct
{
  //object data type
  char *Buf;
  
  uint8_t Idx;
} MSGQUEUE_OBJ_t;

MSGQUEUE_OBJ_t msg;

//message queue id
osMessageQueueId_t mid_MsgQueue;   

void Thread_MsgQueue1(void *argument)  // 延时1s，以1s的频率来发送消息
{
  (void)argument;
  uint8_t num = 0;

  //do some work...
  msg.Buf = "Hello BearPi-HM_Nano!";
  while (1)
  {
    msg.Idx = num;
    osMessageQueuePut(mid_MsgQueue, &msg, 0U, 0U);  // 向消息队列中发送信息，参数分别表示消息队列id、发送的消息、消息队列的优先级、超时时间

    num++;
    //suspend thread
    osThreadYield();
    osDelay(100);  // 延时1s，以1s的频率来发送消息
  }
}

void Thread_MsgQueue2(void *argument)
{
  (void)argument;
  osStatus_t status;
  uint32_t count;

  while (1)
  {
    //Insert thread code here...
    count = osMessageQueueGetCount(mid_MsgQueue);  // 获取消息队列中的消息数
    printf("message queue get count: %d\r\n", count);
    if (count == MSGQUEUE_OBJECTS)
    {
      osMessageQueueDelete(mid_MsgQueue);  // 删除消息队列
    }

    //wait for message
    status = osMessageQueueGet(mid_MsgQueue, &msg, NULL, 0U);  // 获取消息，参数分别表示消息队列id、要获取消息的缓冲区指针、消息队列的优先级、超时时间
    if (status == osOK)
    {
      printf("Message Queue Get msg idx:%d buf:%s\n", msg.Idx, msg.Buf);
    }
    osDelay(300);  // 延时3s，每隔3s获取一次消息
  }
}

static void Message_example(void)
{

  mid_MsgQueue = osMessageQueueNew(MSGQUEUE_OBJECTS, 100, NULL);  // 创建消息队列，参数分别表示消息队列中的最大消息数、消息队列中消息大小，消息队列的属性
  if (mid_MsgQueue == NULL)
  {
    printf("Falied to create Message Queue!\n");
  }

  // 创建两个优先级相同的任务
  osThreadAttr_t attr;

  attr.attr_bits = 0U;
  attr.cb_mem = NULL;
  attr.cb_size = 0U;
  attr.stack_mem = NULL;
  attr.stack_size = 1024 * 10;
  attr.priority = 25;

  attr.name = "Thread_MsgQueue1";
  if (osThreadNew(Thread_MsgQueue1, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_MsgQueue1!\n");
  }
  attr.name = "Thread_MsgQueue2";
  if (osThreadNew(Thread_MsgQueue2, NULL, &attr) == NULL)
  {
    printf("Falied to create Thread_MsgQueue2!\n");
  }
}

APP_FEATURE_INIT(Message_example);

编译、烧录、打印日志

日志结果：

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记-鸿蒙开发者社区

疑问： 为什么删除消息队列后，消息队列中的消息数一直为16（看了看osMessageQueueGetCount实现源码，难道最后返回的是消息队列中可写的资源数？还望大佬指点）

osMessageQueueGetCount源码附上：

uint32_t osMessageQueueGetCount(osMessageQueueId_t mq_id)
{
    uint32_t count;
    UINTPTR uwIntSave;
    LosQueueCB *pstQueue = (LosQueueCB *)mq_id;

    if (pstQueue == NULL) {
        count = 0U;
    } else {
        uwIntSave = LOS_IntLock();
        count = (uint32_t)(pstQueue->readWriteableCnt[OS_QUEUE_READ]);
        LOS_IntRestore(uwIntSave);
    }
    return count;
}

6个官方案例及修改后的扩展实验源码见附件

感悟

从后面几节的学习来看，任务管理是最基础也是必须要掌握的一部分，后面的定时器、信号量、事件管理、互斥锁、消息队列都要用到任务的相关内容。官方给出的案例较为容易理解，但是扩展实验部分有些难度，尤其是在信号量部分，用了很多精力才能勉强理解，上面也写出了自己的思路（讲述不周之处还请多多包涵）。通过比较这6块内容，可以发现这6块的常用接口之间还是有一些相同之处的，都会有创建…、删除…，另外就是启动、恢复或者停止、挂起，其中的参数也很相似。官方给的源码中每一个案例附带的README.md文档，里面给出了一些常用接口的介绍，很有必要看一下，虽然有些抽象，但根据实例去理解收获还是蛮大的。内核开发部分学习耗费的时间有些多，后面四章内容需要加快进度，继续努力！！！

分类

标签

案例代码.zip 27.49K 28次下载

已于2022-8-3 13:39:23修改

3条回复

按时间正序

按时间倒序

红叶亦知秋

大佬讲解已经非常详细了，社区之前也有大佬写过类似的文章，也可以做个参考。

鸿蒙内核源码分析主页：https://ost.51cto.com/user/posts/14930441

zhushangyuan_主页：https://ost.51cto.com/user/posts/14238748

已于2022-8-3 14:59:34修改

2022-8-3 14:59:17

zzuliGjq 回复了红叶亦知秋

大佬讲解已经非常详细了，社区之前也有大佬写过类似的文章，也可以做个参考。鸿蒙内核源码分析主页：https://ost.51cto.com/user/posts/14930441 zhushangyuan_主页：https://ost.51cto.com/user/posts/14238748

感谢感谢

已于2022-8-3 17:39:57修改

2022-8-3 17:39:04

HUAWEI_Engineer

学习中

2022-8-5 23:15:59

51CTO

51CTO博客

51CTO学堂

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记 原创 精华

HarmonyOS内核开发

任务管理

任务管理简介

任务的相关概念

任务的调度机制

任务状态迁移说明

实现任务的管理

cmsis_os2的API任务接口简介

创建任务接口详解

实验结果与扩展实验

定时器管理

软件定时器基本概念

软件定时器运作机制

实现软件定时器创建

cmsis_os2的API软件定时器接口简介

软件定时器扩展实验

信号量

信号量基本概念

信号量运作机制

信号量运作原理

信号量运作示意图

实现信号量功能

cmsis_os2的API信号量接口简介

信号量扩展实验

osSemaphoreAcquire超时时间的使用

osSemaphoreDelete的使用

事件管理

事件基本概念

事件运作机制

实现事件功能

cmsis_os2的API事件接口简介

事件扩展实验

互斥锁

互斥锁基本概念

互斥锁运作机制

实现互斥锁功能

cmsis_os2的API互斥锁接口简介

互斥锁扩展实验

消息队列

消息队列基本概念

消息队列运作机制

实现消息队列功能

cmsis_os2的API消息队列接口简介

消息队列扩展实验

感悟

目录

订阅鸿蒙技术特刊，精选内容抢先看

梅科尔工作室-#14天鸿蒙设备开发实战#内核开发笔记原创精华