HarmonyOS内核开发（任务、定时器、信号量）

最新推荐文章于 2024-05-18 23:30:41 发布

shi_zi_183

最新推荐文章于 2024-05-18 23:30:41 发布

阅读量987

点赞数 2

分类专栏： HarmonyOS IoT设备开发学习文章标签： harmonyos

原文链接：https://gitee.com/bearpi/bearpi-hm_nano

版权

HarmonyOS IoT设备开发学习专栏收录该内容

6 篇文章 5 订阅

订阅专栏

HarmonyOS内核开发

任务管理

基本概念

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

任务状态

任务状态通常分为以下四种

状态	解释
就绪(Ready)	该任务在就绪列表中，只等待CPU
运行(Running)	该任务正在执行
阻塞(Blocked)	该任务不在就绪列表中。包括任务被挂起、任务被延时、任务正在等待信号量、读写队列或者读写事件等。
退出态(Dead)	该任务运行结束，等待系统回收资源。

任务相关概念

相关概念	解释
任务ID	在任务创建时通过参数返回给用户，作为任务的一个非常重要的标识。
任务优先级	优先级标识任务执行的优先顺序
任务入口函数	每个新任务得到调度后将执行的函数
任务控制块TCB	每一个任务都含有一个任务控制块(TCB)。TCB包含了任务上下文栈指针(stack pointer)、任务状态、任务优先级、任务ID、任务名、任务栈大小等信息。TCB可以反映出每个任务运行情况。
任务栈	每个任务都拥有一个独立的栈空间，我们称为任务栈
任务上下文	任务在运行过程中使用到的一些资源，如寄存器等，我们称为任务上下文。LiteOS在任务挂起的时候会将本任务的任务上下文信息，保存在自己的任务栈里面，以便任务恢复后，从栈空间中恢复挂起时的上下文信息，从而继续执行被挂起时被打断的代码。
任务切换	任务切换包含获取就绪列表中最高优先级任务、切出任务上下文保存、切入任务上下文恢复等动作

任务的调度机制

任务状态	说明
就绪态->运行态	任务创建后进入就绪态，发送任务切换时，就绪列表中最高优先级的任务被执行，从而进入运行态，但此刻该任务仍旧在就绪列表中。
运行态->阻塞态	任务运行因挂起、读信号量等待等，在就绪列表中被删除进入阻塞。
阻塞态->就绪态(阻塞态->运行态)	阻塞的任务被恢复后(任务恢复、延时时间超时、读信号量量超时或读到信号量等)，此时被恢复的任务会被加入就绪列表，从而由阻塞态变成就绪态；此时如果被恢复任务的优先级高于正在运行任务的优先级，则会发生任务切换，将该任务由就绪态变成运行态。

就绪态->阻塞态：任务也有可能在就绪态时被阻塞(挂起)
运行态->就绪态：有更高优先级任务创建或者恢复后，发生任务切换而进入就绪列表
运行态->退出态：任务运行结束，内核自动将此任务删除，此时由运行态变为退出态。
阻塞态->退出态：阻塞的任务调用删除接口，任务状态由阻塞态变为退出态。

cmsis_os2的API任务接口简介

接口名	功能描述
osThreadNew(osTheaderFunc_t func,void* argument,const osThreadAttr_t* attr)	创建任务
osThreadTerminate(osThreadId_t thread_id)	删除某个任务(一般是对非自任务操作)
osThreadSuspend(osThreadId_t thread_id)	任务挂起
osThreadResume(osThreadId_t thread_id)	任务恢复

实现任务的创建

创建任务接口详解：osThreadNew(osTheaderFunc_t func,void* argument,const osThreadAttr_t* attr)

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

描述：

函数osThreadNew通过将线程添加到活动线程列表并将其设置为就绪状态来启动线程函数。线程函数的参数使用参数指针*argument传递。当创建的thread函数的优先级高于当前运行的线程时，创建的thread函数立即启动并成为新的运行线程。线程属性是用参数指针attr定义的。属性包括线程优先级、堆栈大小或内存分配的设置。可以在RTOS启动(调用 osKernelStart)之前安全地调用该函数，但不能在内核初始化 (调用 osKernelInitialize)之前调用该函数。

注意 :不能在中断服务调用该函数

任务案例

主要代码分析

在Thread_example函数中，通过osThreadNew()函数创建了thread1和thread2两个进程，thread1和thread2启动后会输出打印日志。

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

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

static void Thread_example(void)
{
    osThreadAttr_t attr;

    attr.name = "thread1";//函数名称
    attr.attr_bits = 0U;//属性位，表明osThreadJoin接口能否被使用，0可以被使用，1不可以
    attr.cb_mem = NULL;//控制块指针，没有操作控制块不用设置
    attr.cb_size = 0U;//控制块内存大小
    attr.stack_mem = NULL;//任务栈的指针，没有操作任务栈不用设置
    attr.stack_size = 1024*4;//任务栈大小
    attr.priority = 25;//任务优先级

    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");
    }
}

编译调试

修改 BUILD.gn 文件

修改 applications\BearPi\BearPi-HM_Nano\sample路径下 BUILD.gn 文件，指定 thread_example 参与编译。

"A1_kernal_thread:thread_example",
#"A2_kernel_timer:timer_example",
#"A3_kernel_event:event_example",
#"A4_kernel_mutex:mutex_example",
#"A5_kernel_semaphore:semaphore_example",
#"A6_kernel_message:message_example",

运行结果

示例代码编译烧录代码后，按下开发板的RESET按键，通过串口助手查看日志，Thread1和Thread2会交替打印信息

This is BearPi-HM_Nano Thread1----2
This is BearPi-HM_Nano Thread2----4
This is BearPi-HM_Nano Thread2----5
This is BearPi-HM_Nano Thread1----3
This is BearPi-HM_Nano Thread2----6
This is BearPi-HM_Nano Thread2----7

任务扩展实验

高优先级任务会抢占低优先级任务运行，当高优先级任务挂起之后低优先级的任务才能执行。
设计实验证明之。
复制A1项目文件
在这里插入图片描述
修改thread_example_expand.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>

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

/*新建两个全局变量用于保存任务id*/
osThreadId_t threadHIId;
osThreadId_t threadLoId;

/*****任务一*****/
void threadHi(void)
{
    printf("enter threadHi\r\n");
    osDelay(1);//进入阻塞状态1毫秒
    printf("threadHi delay done\r\n");//阻塞结束抢占threadLo
    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 suspend 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;//高优先级
    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函数指定入口*/
SYS_RUN(Thread_example);

为了避免模块初始化输出信息影响结果，我们在启动函数中禁用SAMGR_Bootstrap()
base\startup\services\bootstrap_lite\source\system_init.c

#include "core_main.h"
#include <ohos_init.h>
#include <samgr_lite.h>

void HOS_SystemInit(void)
{
    MODULE_INIT(bsp);
    MODULE_INIT(device);
    MODULE_INIT(core);
    SYS_INIT(service);
    SYS_INIT(feature);
    MODULE_INIT(run);
    //SAMGR_Bootstrap();//注释此函数禁止信息输出
}

void OHOS_SystemInit(void)
{
    MODULE_INIT(bsp);
    MODULE_INIT(device);
    MODULE_INIT(core);
    SYS_INIT(service);
    SYS_INIT(feature);
    MODULE_INIT(run);
    SAMGR_Bootstrap();
}

修改BUILD.gn
略
烧录查看输出
在这里插入图片描述
可以看到在threadLo循环输出时，threadHi抢占式的输出了enter threadHi delay done，导致第五句输出被截断。
可以看出抢占过程不会等待一句命令结束，而是直接中断执行。、
这两个任务没有像之前那样重复执行，是因为在任务最后删除了任务。

软件定时器

软件定时器基本概念

软件定时器，是基于系统Tick时钟中断且由软件来模拟的定时器，当经过设定的Tick时钟计数值后会触发用户定义的回调函数。定时精度与系统Tick时钟的周期有关。
硬件定时器受硬件的限制，数量上不足以满足用户的实际需求，因此为了满足用户需求，提供更多的定时器，LiteOS操作系统提供软件定时器功能。
软件定时器拓展了定时器的数量，允许创建更多的定时业务。
1）静态裁剪：能通过宏关闭软件定时器功能。
2）软件定时器创建
3）软件定时器启动
4）软件定时器停止
5）软件定时器删除
6）软件定时器剩余Tick数获取

运作机制

软件定时器使用了系统的一个队列和一个任务资源，软件定时器的触发遵循队列规则，先进先出。定时器时间短的定时器总是比定时时间长的靠近队列头，满足优先被触发的准则。
软件定时器以Tick为基本计时单位，当用户创建并启动一个软件定时器时，LiteOS会根据当前系统Tick时间及用户设置的定时间隔确定该定时器的到期Tick时间，并将定时器控制结构挂入计时全局链表。
当Tick中断到来时，在Tick中断处理函数中扫描软件定时器的计时全局链表，看是否有定时器超时，若有则将超时的定时器记录下来。
Tick中断处理函数结束后，软件定时器任务被唤醒，在该任务中调用之前记录下来的定时器的超时回调函数。

定时器的创建

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

接口名	功能描述
osTimeNew(osTimerFunc_t func,osTimerType_t type,void argument,const osTimerAttr_t attr)	创建定时器
osTimeStart(osTimerId_t timer_id,uint32_t ticks)	启动定时器
osTimeStop(osTimerId_t timer_id)	停止计时器
osTimerDelete(osTimerId_t timer_id)	删除定时器

创建定时器函数的参数

参数名	描述
osTimerFunc_t func	定时器回调函数，即定时器超时后调用的函数
osTimerType_t type	定时器的类型，单次或多次
void *argument	传递给定时器的参数
const osTimerAttr_t *attr	定时器属性参数

启动定时器函数的参数

参数名	描述
osTimerId_t timer_id	定时器id，创建函数返回值获取
uint32_t ticks	超时时间 1U=10ms

定时器案例

创建目录A2_kernel_timer
编写业务代码

#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);
    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);

改写BUILD.gn
略
将system_int.c的注释恢复
base\startup\services\bootstrap_lite\source\system_init.c

#include "core_main.h"
#include <ohos_init.h>
#include <samgr_lite.h>

void HOS_SystemInit(void)
{
    MODULE_INIT(bsp);
    MODULE_INIT(device);
    MODULE_INIT(core);
    SYS_INIT(service);
    SYS_INIT(feature);
    MODULE_INIT(run);
    SAMGR_Bootstrap();//注释此函数禁止信息输出
}

void OHOS_SystemInit(void)
{
    MODULE_INIT(bsp);
    MODULE_INIT(device);
    MODULE_INIT(core);
    SYS_INIT(service);
    SYS_INIT(feature);
    MODULE_INIT(run);
    SAMGR_Bootstrap();
}

烧录并查看输出
在这里插入图片描述
可以看到定时器1运行3次，定时器2运行1次。
这是因为定时器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;
    //将定时器1修改为单次定时器
    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
        }
    }
    //延时2秒后，停止计时器判断状态。
    osDelay(200U);
    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");
    }
    //延时2秒后，删除计时器判断状态。
    osDelay(200U);
    status=osTimerDelete(id1);
    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);

修改BUILD.gn
略
烧录并查看输出
在这里插入图片描述
可以看到定时器1停止失败了，这时因为定时器1是一个单次定时器，在延时两秒后，已经关闭了，所以自然不能再次关闭。
删除可以随时执行，无论定时器启动状态还是结束状态。

信号量

基本概念

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

运作原理

信号量初始化
为配置的N个信号量申请内存(N值可以由用户自行配置，受内存限制)，并把所有的信号量初始化成未使用，并加入到未使用链表中供系统使用。
信号量创建
从未使用的信号量链表中获取一个信号量资源，并设置初值。
信号量申请
若其计数器值大于0，则直接减1返回成功。否则任务阻塞，等待其他任务释放该信号量，等待的超时时间可设定。当任务被一个信号量阻塞时，将该任务挂到信号量等待任务队列的队尾。
信号量释放
若没有任务等待该信号量，则直接将计数器加1返回。否则唤醒该信号量等待任务队列上的第一个任务。
信号量删除
将正在使用的信号量置为未使用信号量，并挂回到未使用链表。
信号量允许多个任务在同一时刻访问同一资源
但会限制同一时刻访问此资源的最大任务数目。访问同一资源的任务数达到该资源的最大数量时，会阻塞其他试图获取该资源的任务，直到有任务释放该信号量。

实现信号量功能

接口名	功能描述
osSemaphoreId_t osSemaphoreNew(uint32_t max_count, uint32_t initial_count, const osSemaphoreAttr_t *attr)	创建信号量
osStatus_t osSemaphoreAcquire(osSemaphoreId_t semaphore_id, uint32_t timeout)	获取信号量
osStatus_t osSemaphoreRelease(osSemaphoreId_t semaphore_id)	释放信号量
osStatus_t osSemaphoreDelete(osSemaphoreId_t semaphore_id)	删除信号量

osSemaphoreAcquire()

osStatus_t osSemaphoreAcquire(osSemaphoreId_t semaphore_id,uint32_t timeout)

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

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

参数：

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

osSemaphoreNew()

osSemaphoreId_t osSemaphoreNew(uint32_t max_count,uint32_t initial_count,const osSemaphoreAttr_t *attr)

描述：

函数osMessageQueueNew创建并初始化一个消息队列对象。该函数返回消息队列对象标识符，如果出现错误则返回NULL，可以在RTOS启动(调用 osKernelStart)之前安全地调用该函数，也可以在内核初始化 (调用 osKernelInitialize)之前调用该函数。

注意 :不能在中断服务调用该函数

参数：

名字	描述
max_count	可用令牌的最大数量.
initial_count	可用令牌的初始数量.
attr	信号量的属性;空:默认值.

信号量案例

编写业务代码

#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);

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

        printf("Thread_Semaphore1 Release  Semap \n");
        osDelay(100);
    }
}
void Thread_Semaphore2(void)
{
    while (1)
    {
        //等待sem1信号量
        osSemaphoreAcquire(sem1, osWaitForever);

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

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);

改写BUILD.gn
略
烧录并查看输出
在这里插入图片描述
可以看到在延时1s后2、3进程分别进行了两句输出。
如果1进程每次只释放一个信号量那么，每隔1秒，2、3进程交替执行。

在这里插入图片描述

信号量扩展案例

修改业务代码
设置任务2的超时时间为50U

void Thread_Semaphore2(void)
{
    osStatus_t status;
    while (1)
    {
        //等待sem1信号量
        status=osSemaphoreAcquire(sem1, 50U);//设置超时时间50u
        //判断请求状态
        if(status != osOK){
            printf("Thread_Semaphore2 get semap failed\n");
        }else{
            printf("Thread_Semaphore2 get semap success\n")
        }
        osDelay(1);
    }
}

在这里插入图片描述

shi_zi_183

关注

2
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
HarmonyOS内核开发（任务、定时器、信号量）

HarmonyOS内核开发任务管理基本概念1、从系统的角度看，任务是竞争系统资源的最小运行单元。任务可以使用或等待CPU、使用内存空间等系统资源，并独立于其他任务运行。2、LiteOS的任务模块可以给用户提供多个任务，实现类之间的切换和信息，帮助用户管理业务程序流程。这样用户可以将更多的精力投入到业务功能的实现中。3、LiteOS中的任务是抢占式调度机制，高优先级的任务可打断低优先级任务，低优先级任务必须在高优先级任务阻塞或结束后才能得到调度，同时支持时间轮转调度方式。4、LiteOS的任务默认
复制链接

扫一扫