梅科尔工作室-14.5

燃新梨。

发布于 2022-7-25 11:55

浏览

0收藏

HarmonyOS内核开发—事件管理

事件基本概念

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

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

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

事件运作机制

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

写事件时，对指定事件写入指定的事件类型，可以一次同时写多个事件类型。写事件会触发任务调度。
清除事件时，根据入参事件和待清除的事件类型，对事件对应位进行清0操作。

实现事件功能

梅科尔工作室-14.5-鸿蒙开发者社区

软件定时器扩展实验

/***** 发送事件 *****/
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);
}
}
/***** 接收事件 *****/
void Thread_EventReceiver(void *argument)
{
(void)argument;
uint32_t flags;
while (1)
{
flags = osEventFlagsWait(evt_id, FLAGS_MSK1|FLAGS_MSK2|FLAGS_MSK3, osFlagsWaitAll, osWaitForever);
printf("Receive Flags is %d\n", flags);
}
}

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

HarmonyOS内核开发—互斥锁

互斥锁基本概念

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

LiteOS提供的互斥锁具有如下特点：
通过优先级继承算法，解决优先级翻转问题

实现互斥锁功能

梅科尔工作室-14.5-鸿蒙开发者社区

互斥锁拓展实验

void HighPrioThread(void)
{
// wait 1s until start actual work
osDelay(100U);
osStatus_t status;
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");
}
}
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

void LowPrioThread(void)
{
osStatus_t status;
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);
status = osMutexRelease(mutex_id);
if(status != osOK)
{
printf("release mutex failed\r\n");
}
else
{
printf("release mutex success\r\n");
}
}
}

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

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");
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

HarmonyOS内核开发—消息队列

消息队列基本概念

消息队列，是一种常用于任务间通信的数据结构，实现了接收来自任务或中断的不固定长度的消息，并根据不同的接口选择传递消息是否存放在自己空间。任务能够从队列里面读取消息，当队列中的消息是空时，挂起读取任务；当队列中有新
消息时，挂起的读取任务被唤醒并处理新消息。
用户在处理业务时，消息队列提供了异步处理机制，允许将一个消息放入队列，但并不立即处理它，同时队列还能起到缓冲消息作用。
LiteOS中使用队列数据结构实现任务异步通信工作，具有如下特性：

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

实现消息队列功能

梅科尔工作室-14.5-鸿蒙开发者社区

扩展实验代码

void Thread_MsgQueue1(void *argument)
{
(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);
num++;
//suspend thread
osThreadYield();
osDelay(100);
}
}

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

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);
if (status == osOK)
{
printf("Message Queue Get msg idx:%d buf:%s\n", msg.Idx,msg.Buf);
}
osDelay(300);
}
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.