257 Star 870 Fork 330

GVPHuawei LiteOS / LiteOS

Create your Gitee Account
Explore and code with more than 6 million developers,Free private repositories !:)
Sign up
Clone or download
README_CN.md 20.99 KB
Copy Edit Web IDE Raw Blame History
tinyfrog authored 2020-12-26 19:18 . update doc info

KERNEL DEMOS使用指南

目 录

须知: 如果想更详细了解LiteOS各内核模块,可以访问LiteOS开发指南

1.前言

使用方法

用户可以直接参考3.运行实例来运行demos/kernel下各个实例。

具体的实例介绍在2.实例介绍中,下面是对各个实例的概述:

任务

los_api_task.c/.h实现了任务实例。

  • 实现了任务的创建、删除、延迟、挂起、恢复等功能,以及锁定和解锁任务调度。

内存管理

los_api_dynamic_mem.c/.h实现了动态内存实例

  • 实现了动态内存的初始化、申请、使用、释放功能。

los_api_static_mem.c/.h实现了静态内存实例

  • 实现了静态内存的初始化、申请、使用、清除和释放功能。

中断

los_api_interrupt.c/.h实现了中断实例。

  • 实现了中断的创建、删除、使能、禁止、请求位的清除等功能。

IPC通信

los_api_msgqueue.c/.h实现了消息队列实例。

  • 实现了消息队列的创建、删除、发送和接收功能。

los_api_event.c/.h实现了事件实例。

  • 实现了事件的创建、删除、读事件和写事件功能。

los_api_mutex.c/.h实现了互斥锁实例。

  • 实现了互斥锁的创建、删除、申请和释放等功能。

los_api_sem.c/.h实现了信号量实例。

  • 实现了信号量的创建、删除、申请和释放等功能。

时间管理

los_api_systick.c/.h实现了tick时间实例。

  • 实现了获取系统Tick数和每个Tick的Cycle数的功能。

los_api_timer.c/.h实现了软件定时器实例。

  • 实现了软件定时器的创建、开始、停止、删除等功能。

双向链表

los_api_list.c/.h实现了双向链表实例

  • 实现了双向链表的初始化,链表的非空检测,节点的增加、删除等功能。

2.实例介绍

2.1 任务

任务实例:los_api_task.c/los_api_task.h

任务是竞争系统资源的最小运行单元。任务可以使用或等待CPU、使用内存空间等系统资源,并独立于其它任务运行。

本实例执行以下步骤:

  1. 锁任务LOS_TaskLock,防止创建任务时发生任务调度。
  2. 通过LOS_TaskCreate创建了2个任务,高优先级任务Example_TaskHi和低优先级任务Example_TaskLo,解锁任务LOS_TaskUnlock。
  3. Example_TaskHi任务被调度,通过LOS_TaskSuspend挂起任务。
  4. Example_TaskLo任务被调度,通过LOS_TaskResume恢复挂起的Example_TaskHi任务。
  5. Example_TaskHi任务被唤醒,执行完成,Example_TaskLo任务被调度,执行完成。

实例结果

Kernel task demo begin.
LOS_TaskLock() ok.
Create Example_TaskHi ok.
Create Example_TaskLo ok.
Enter TaskHi Handler.
Enter TaskLo Handler.
TaskHi LOS_TaskDelay Done.
TaskHi LOS_TaskSuspend ok.
TaskHi LOS_TaskResume ok.
Kernel task demo ok.

2.2 内存管理

Huawei LiteOS的内存管理分为静态内存管理和动态内存管理,提供内存初始化、分配、释放等功能。

动态内存管理实例:los_api_dynamic_mem.c/los_api_dynamic_mem.h

当用户需要使用内存时,可以通过操作系统的动态内存申请函数申请指定大小的内存,动态内存管理模块会从系统配置的一块连续内存(内存池)中为用户分配指定大小的内存块。一旦使用完毕,用户再通过动态内存释放函数归还所占用内存,使之可以重复使用。

本实例执行以下步骤:

  1. 通过LOS_MemInit初始化一个动态内存池。
  2. 使用LOS_MemAlloc从动态内存池中申请一块内存。
  3. 在这个内存块中存放一个数据。
  4. 打印出这个内存块中的数据。
  5. 通过LOS_MemFree释放这块内存。

实例结果

Kernel dynamic memory demo begin.
Mempool init ok.
Mem alloc ok.
*mem = 828.
Mem free ok.
Kernel dynamic memory demo ok.

静态内存管理实例:los_api_static_mem.c/los_api_static_mem.h

静态内存池由一个控制块和若干相同大小的内存块构成。控制块位于内存池头部,用于内存块管理。内存块大小在内存池初始化时设定,初始化后内存块的大小不可变更。所以静态内存池是由若干大小相同的内存块构成的。内存块的申请和释放以块大小为粒度。

本实例执行以下步骤:

  1. 通过LOS_MemboxInit初始化一个静态内存池。
  2. 使用LOS_MemboxAlloc从静态内存池中申请一块内存。
  3. 在这个内存块中存放一个数据。
  4. 打印出内存块中的数据。
  5. 通过LOS_MemboxClr清除内存块中的数据。
  6. 通过LOS_MemboxFree释放这块内存。

实例结果

Kernel static memory demo begin.
Mem box init ok.
Mem box alloc ok.
*mem = 828.
Clear data ok, *mem = 0.
Mem box free ok.
Kernel static memory demo ok.

2.3 中断

中断实例:los_api_interrupt.c/los_api_interrupt.h

中断是指出现需要时,CPU暂停执行当前程序,转而执行新程序的过程。即在程序运行过程中,出现了一个必须由CPU立即处理的事务。此时,CPU暂时中止当前程序的执行转而处理这个事务,这个过程就叫做中断。

本实例以软件中断为例来说明中断使用的一般步骤:

  1. 通过LOS_IntLock关中断。
  2. 通过LOS_HwiCreate创建中断。
  3. 通过LOS_HwiEnable使能中断。
  4. 通过LOS_IntRestore开中断。
  5. 通过LOS_HwiTrigger触发中断。

实例结果

Kernel interrupt demo begin.
User IRQ test ok.
Kernel interrupt demo ok.

说明: 目前的中断测试代码提供了基本框架,中断硬件初始化代码请用户根据开发板硬件情况在Example_Exti0_Init()函数中自行实现。

以下以野火挑战者F429开发板为例来说明硬件中断使用的一般步骤:

  1. 通过LOS_IntLock关中断。
  2. 通过Example_Exti0_Init初始化按键PA0。
  3. 通过LOS_HwiCreate创建中断。
  4. 通过LOS_HwiEnable使能中断。
  5. 通过LOS_IntRestore开中断。
  6. 通过硬件按键PA0触发中断。
  7. 在中断处理程序中通过__HAL_GPIO_EXTI_CLEAR_IT清除硬件中断。

实例结果

按下PA0引脚对应的按键(即野火挑战者F429开发板上的对应的KEY1按键)串口输出如下:

Button IRQ test ok.

**注意事项:**当前LiteOS系统对于Cortex-M系列芯片,前16个中断号为系统预留,不开放给用户使用。

2.4 IPC通信

IPC通信提供消息队列、事件、互斥锁和信号量功能。

消息队列实例:los_api_msgqueue.c/los_api_msgqueue.h

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

本实例执行以下步骤:

  1. 在Example_MsgQueue中锁任务调度,通过LOS_TaskCreate创建两个任务 send_Entry和recv_Entry。
  2. 在Example_MsgQueue中通过LOS_QueueCreate创建一个消息队列。
  3. 解锁任务调度,任务send_Entry被调度,该任务循环通过LOS_QueueWrite以非阻塞模式向队列写入消息,写入一条消息后休眠50Tick,循环写API_MSG_NUM条消息。
  4. 任务recv_Entry被唤醒,该任务循环通过LOS_QueueRead以非阻塞模式从队列中读取消息,读完一条消息后就休眠50Tick,一旦任务无法从队列中读取消息,就退出循环,并通过LOS_QueueDelete删除队列。
  5. 通过LOS_TaskDelete删除send_Entry和recv_Entry两个任务。

实例结果

Kernel message queue demo begin.
Create the queue ok.
Recv message : test is message 0.
Recv message : test is message 1.
Recv message : test is message 2.
Recv message : test is message 3.
Recv message : test is message 4.
Recv message failed, error: 200061d.
Delete the queue ok.
Kernel message queue demo ok.

事件实例:los_api_event.c/los_api_event.h

事件是一种实现任务间通信的机制,可用于实现任务间的同步。一个任务可以等待多个事件的发生:可以是任意一个事件发生时唤醒任务进行事件处理,也可以是几个事件都发生后才唤醒任务进行事件处理。

本实例执行以下步骤:

  1. 在Example_SndRcvEvent中初始化事件控制块,并创建任务Example_Event。任务Example_Event的优先级高于Example_SndRcvEvent函数所在任务。
  2. Example_Event被调度,通过LOS_EventRead读事件0x00000001,超时时间为100 Ticks,此时无法读取到该事件,Example_Event阻塞挂起。
  3. Example_SndRcvEvent被调度,通过LOS_EventWrite写事件0x00000001。
  4. Example_Event读取到事件0x00000001,被唤醒,任务结束执行。
  5. Example_SndRcvEvent被调度,通过LOS_EventClear清除事件类型,任务结束执行。

实例结果

Kernel event demo begin.
Example_Event wait event 0x1.
Example_SndRcvEvent write event.
Example_Event, read event : 0x1.
EventMask : 1
EventMask : 0
Kernel event demo ok.

互斥锁实例:los_api_mutex.c/los_api_mutex.h

互斥锁又称互斥型信号量,是一种特殊的二值性信号量,用于实现对共享资源的独占式处理。

本实例执行以下步骤:

  1. 在Example_MutexLock中创建一个互斥锁,锁任务调度,创建两个任务:低优先级任务Example_MutexTask1和高优先级任务Example_MutexTask2,解锁任务调度。
  2. Example_MutexTask2被调度,通过LOS_MuxPend以永久阻塞模式申请互斥锁,此时互斥锁没有被其他任务持有,它成功申请到锁后,开始休眠100Tick,Example_MutexTask2挂起。
  3. Example_MutexTask1被调度,申请互斥锁,其申请等待时间为10Tick,因互斥锁仍被Example_MutexTask2持有,Example_MutexTask1挂起10Tick后再次被唤醒,因仍未拿到互斥锁,Example_MutexTask1以永久阻塞模式申请互斥锁,因无法拿到锁,Example_MutexTask1挂起。
  4. 100Tick后Example_MutexTask2休眠时间结束,其被唤醒后释放互斥锁,Example_MutexTask2结束执行。
  5. 因Example_MutexTask2已经释放互斥锁,Example_MutexTask1被唤醒后拿到锁,接着释放锁,Example_MutexTask1结束执行。
  6. 300Tick后Example_MutexLock被调度运行并删除互斥锁。

实例结果

Kernel mutex demo begin.
Task2 try to get mutex, wait forever.
Task2 get mutex g_demoMux01 and suspend 100 ticks.
Task1 try to get mutex, wait 10 ticks.
Task1 timeout and try to get mutex, wait forever.
Task2 resumed and post the g_demoMux01.
Task1 wait forever, got mutex g_demoMux01 ok.
Kernel mutex demo ok.

信号量实例:los_api_sem.c/los_api_sem.h

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

本实例执行以下步骤:

  1. 在Example_Semphore中创建一个计数值为0的信号量,锁任务调度,创建两个任务:低优先级任务Example_SemTask1和高优先级任务Example_SemTask2,解锁任务调度。
  2. Example_SemTask2被调度,通过LOS_SemPend以永久阻塞模式申请信号量后阻塞挂起。
  3. Example_SemTask1被调度,通过LOS_SemPend以定时等待10Tick的方式申请信号量后阻塞挂起。
  4. Example_Semphore被调度,执行LOS_SemPost释放信号量。
  5. Example_SemTask2得到信号量,被唤醒,然后休眠20Tick,Example_MutexTask2挂起。
  6. Example_SemTask1被调度,等待10Tick后仍未得到信号量,尝试以永久阻塞模式申请信号量,Example_SemTask1挂起。
  7. Example_Semphore被唤醒,开始休眠40Tick,Example_Semphore挂起。
  8. 20Tick的休眠结束后,Example_SemTask2唤醒,释放信号量,Example_SemTask2结束执行。
  9. Example_SemTask1得到信号量,被唤醒后释放信号量,Example_SemTask1结束执行。
  10. 40Tick的休眠结束后,Example_Semphore被唤醒,并通过LOS_SemDelete删除信号量。

实例结果

Kernel semaphore demo begin.
Example_SemTask2 try get sem g_demoSemId wait forever.
Example_SemTask1 try get sem g_demoSemId, timeout 10 ticks.
Example_SemTask2 get sem g_demoSemId and then delay 20ticks.
Example_SemTask1 timeout and try get sem g_demoSemId wait forever.
Example_SemTask2 post sem g_demoSemId.
Example_SemTask1 wait_forever and got sem g_demoSemId ok.
Kernel semaphore demo ok.

2.5 时间管理

时间管理以系统时钟为基础。时间管理提供给应用程序所有和时间有关的服务。下面包括时钟管理和软件定时器两个实例。

时钟管理实例:los_api_systick.c/los_api_systick.h

本实例执行以下步骤:

  1. 通过LOS_CyclePerTickGet统计一个Tick的Cycle数。
  2. 通过LOS_TickCountGet获取自系统启动以来的Tick数,然后休眠200Tick后,再次调用LOS_TickCountGet。将这两次获取的Tick数相减,其差应该大于等于休眠的200Tick。

实例结果

Kernel systick demo begin.
LOS_CyclePerTickGet = 180000.
LOS_TickCountGet = 8987.
LOS_TickCountGet after delay = 9189.
Kernel systick demo ok.

软件定时器实例:los_api_timer.c/los_api_timer.h

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

本实例执行以下步骤:

  1. 通过LOS_SwtmrCreate创建两个定时器,定时1000Ticks的单次软件定时器Timer1和定时100Tick的周期软件定时器Timer2。
  2. 通过LOS_SwtmrStart启动Timer1。
  3. 200Tick后通过LOS_SwtmrStop停止Timer1,再通过LOS_SwtmrStart启动Timer1。
  4. 再经过1000Ticks后通过LOS_SwtmrDelete删除Timer1(显示删除失败,此时Timer1定时器已经完成1000Ticks的定时,对于单次定时器,定时时间到达后系统会自动删除该定时器)。
  5. 通过LOS_SwtmrStart启动Timer2。
  6. 休眠1000Ticks,在此期间,Timer2会触发10次回调函数。1000Ticks后停止并删除Timer2,任务结束执行。

实例结果

Kernel swtimer demo begin.
Create Timer1 ok.
Create Timer2 ok.
Start Timer1 ok.
Stop Timer1 ok.
LOS_TickCountGet g_demoTimerCount1 = 1.
LOS_TickCountGet tickLast1 = 11402.
Delete Timer1 failed.
Start Timer2 ok.
LOS_TickCountGet g_demoTimerCount2 = 1.
LOS_TickCountGet tickLast2 = 11510.
LOS_TickCountGet g_demoTimerCount2 = 2.
LOS_TickCountGet tickLast2 = 11610.
LOS_TickCountGet g_demoTimerCount2 = 3.
LOS_TickCountGet tickLast2 = 11710.
LOS_TickCountGet g_demoTimerCount2 = 4.
LOS_TickCountGet tickLast2 = 11810.
LOS_TickCountGet g_demoTimerCount2 = 5.
LOS_TickCountGet tickLast2 = 11910.
LOS_TickCountGet g_demoTimerCount2 = 6.
LOS_TickCountGet tickLast2 = 12010.
LOS_TickCountGet g_demoTimerCount2 = 7.
LOS_TickCountGet tickLast2 = 12110.
LOS_TickCountGet g_demoTimerCount2 = 8.
LOS_TickCountGet tickLast2 = 12210.
LOS_TickCountGet g_demoTimerCount2 = 9.
LOS_TickCountGet tickLast2 = 12310.
LOS_TickCountGet g_demoTimerCount2 = 10.
LOS_TickCountGet tickLast2 = 12410.
Kernel timer demo ok.

2.6 双向链表

双向链表实例:los_api_list.c/los_api_list.h

双向链表是指含有往前和往后两个方向的链表,即每个结点中除存放下一个节点指针外,还增加一个指向其前一个节点的指针。其头指针head是唯一确定的。

本实例执行以下步骤:

  1. 调用LOS_MemAlloc生成链表的头指针。
  2. 调用LOS_ListInit初始化双向链表。
  3. 调用LOS_ListEmpty判断链表初始化是否成功。
  4. 调用LOS_MemAlloc生成两个中间节点和一个尾节点。
  5. 调用LOS_ListAdd在头指针之后插入上面的两个中间节点。
  6. 调用LOS_ListTailInsert插入尾节点。
  7. 调用LOS_ListDelete删除其中一个节点。

实例结果

Kernel list demo begin.
Init list......
Node add and tail add......
Add node ok.
Add tail ok.
Delete node......
Delete node ok.
Kernel list demo ok.

3.运行实例

在target文件夹下的main.c或者user_task.c中找到app_init函数。LiteOS系统完成初始化后,会创建用户任务,其任务处理函数就是app_init(), 用户可以直接在该函数中运行demos/kernel下的各个实例。

这里提供两种方式来运行2.实例介绍中的各个实例。

实例1:los_inspect_entry.c/los_inspect_entry.h

开发流程

1.使用make menuconfig打开宏开关:

Demos --> Kernel Demo --> Enable Kernel Demo --> Kernel Demo Entry --> InspectEntry

2.在实现app_init()的源文件中添加头文件引用:

#include "los_inspect_entry.h"  // 调用测试函数头文件

3.在app_init()中调用KernelDemoInspectEntry()函数,该函数会执行所有内核实例:

KernelDemoInspectEntry();    // 调用测试任务测试所有实例

实例2:los_demo_entry.c/los_demo_entry.h

通过宏开关来判断是否调用各内核实例,以实现对2.实例介绍中某个或多个实例的执行。

开发流程

1.使用make menuconfig打开需要测试功能的宏开关,例如要测试task实例,则选择“DemoEntry”, 并选择实例:

Demos --> Kernel Demo --> Enable Kernel Demo --> Kernel Demo Entry --> DemoEntry --> Run Kernel Task Demo

2.在实现app_init()的源文件中添加头文件引用:

#include "los_demo_entry.h" // 调用测试函数头文件

3.在app_init()中调用KernelDemoEntry()函数,该函数通过宏开关来判断是否调用某内核实例:

KernelDemoEntry();   // 调用测试任务

测试流程

用户可以按照LiteOS Studio STM32工程示例对代码进行编译烧写测试。

C
1
https://gitee.com/LiteOS/LiteOS.git
git@gitee.com:LiteOS/LiteOS.git
LiteOS
LiteOS
LiteOS
master

Search

103611 48b8ff67 1899542 103622 4d02230c 1899542