小熊派学习(四)-内核开发

Sherry辛巳

发布于 2022-7-23 21:40

962浏览

0收藏

梅科尔工作室-欢

1.任务管理

任务相关概念：

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

/*****任务一*****/
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\r\n");
}
printf("threadHi osThreadSuspend success\r\n");
osThreadResume(threadHiID);
osThreadTerminate(threadLoID);
}
osThreadId_t threadHiID ;
osThreadId_t 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;
threadHiID = osThreadNew((osThreadFunc_t)threadHi, NULL, 
&attr);
if ( threadHiID == NULL)
{
printf("Falied to create threadHi!\n");
}
attr.name = "threadLo";
attr.priority = 24;
threadLoID = osThreadNew((osThreadFunc_t)threadLo, NULL, 
&attr); 
if (threadLoID == NULL)
{
printf("Falied to create threadLo!\n");
}
}
SYS_RUN(Thread_example);
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.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.

2.软件定时器

软件定时器，是基于系统Tick时钟中断且由软件来模拟的定时器，当经过设定的Tick时钟计数值后会触发用户定义的回调函数。定时精度与系统Tick时钟的周期有关。
硬件定时器受硬件的限制，数量上不足以满足用户的实际需求，因此为了满足用户需求，提供更
多的定时器，LiteOS操作系统提供软件定时器功能。
软件定时器扩展了定时器的数量，允许创建更多的定时业务。
小熊派学习(四)-内核开发-鸿蒙开发者社区

exec1 = 1U;
id1 = osTimerNew(Timer1_Callback, osTimerOnce, &exec1, NULL);
if (id1 != NULL)
{
// Hi3861 1U=10ms,100U=1S
timerDelay = 100U;
status = osTimerStart(id1, timerDelay);
if (status != osOK)
{
// Timer could not be started
}
}

osDelay(50U);
status = osTimerStop(id1);
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);
status = osTimerDelete(id1);
if(status != osOK)
{
printf("delete Timer1 failed\r\n");
}
else
{
printf("delete Timer1 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.
31.
32.
33.
34.
35.
36.
37.
38.

3.信号量

1、信号量（Semaphore）是一种实现任务间通信的机制，实现任务之间同步或临界资源的互斥访问。常用于协助一组相
互竞争的任务来访问临界资源。
2、在多任务系统中，各任务之间需要同步或互斥实现临界资源的保护，信号量功能可以为用户提供这方面的支持。
3、通常一个信号量的计数值用于对应有效的资源数，表示剩下的可被占用的互斥资源数。其值的含义分两种情况：
1）0，表示没有积累下来的Post信号量操作，且有可能有在此信号量上阻塞的任务。
2）正值，表示有一个或多个Post信号量操作。
4、以同步为目的的信号量和以互斥为目的的信号量在使用有如下不同：
1）用作互斥时，信号量创建后记数是满的，在需要使用临界资源时，先取信号量，使其变空，这样其他任务需要使用
临界资源时就会因为无法取到信号量而阻塞，从而保证了临界资源的安全。
2）用作同步时，信号量在创建后被置为空，任务1取信号量而阻塞，任务2在某种条件发生后，释放信号量，于是任务1得以进入READY或RUNNING态，从而达到了两个任务间的同步。
小熊派学习(四)-内核开发-鸿蒙开发者社区

void Thread_Semaphore1(void)
{
osStatus_t status;
while (1)
{
//释放两次sem1信号量，使得Thread_Semaphore2和Thread_Semaphore3能同步执行
status = osSemaphoreRelease(sem1);
if(status != osOK)
{
printf("Thread_Semaphore1 Release Semap failed\n");
}
else
{
printf("Thread_Semaphore1 Release Semap success\n");
}
// //此处若只释放一次信号量，则Thread_Semaphore2和Thread_Semaphore3会交替运行
。
// osSemaphoreRelease(sem1);
osDelay(100);
}
}

void Thread_Semaphore2(void)
{
osStatus_t status;
while (1)
{
//申请sem1信号量
status= osSemaphoreAcquire(sem1, 50U);
if(status != osOK)
{
printf("Thread_Semaphore2 get Semap failed\n");
}
else
{
printf("Thread_Semaphore2 get Semap success\n");
}
}
}

void Thread_Semaphore3(void)
{
osStatus_t status;
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);
}
}
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.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.

4.事件管理

小熊派学习(四)-内核开发-鸿蒙开发者社区

/***** 发送事件 *****/
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.

5.互斥锁

互斥锁的概念：

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

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.

6.消息队列

消息队列，是一种常用于任务间通信的数据结构，实现了接收来自任务或中断的不固定长度的消息，并根据不同的接口选择传递消息是否存放在自己空间。任务能够从队列里面读取消息，当队列中的消息是空时，挂起读取任务；当队列中有新消息时，挂起的读取任务被唤醒并处理新消息。用户在处理业务时，消息队列提供了异步处理机制，允许将一个消息放入队列，但并不立即处理它，同时队列还能起到缓冲消息作用。
LiteOS中使用队列数据结构实现任务异步通信工作，具有如下特性：
⚫ 消息以先进先出方式排队，支持异步读写工作方式。
⚫ 读队列和写队列都支持超时机制。
⚫ 发送消息类型由通信双方约定，可以允许不同长度（不超过队列节点最大值）消息。
⚫ 一个任务能够从任意一个消息队列接收和发送消息。
⚫ 多个任务能够从同一个消息队列接收和发送消息。
⚫ 当队列使用结束后，如果是动态申请的内存，需要通过释放内存函数回收。
小熊派学习(四)-内核开发-鸿蒙开发者社区

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.

分类

卡片开发

其他

标签

小熊派

已于2022-7-23 21:46:36修改

51CTO

51CTO博客

51CTO学堂