OpenHarmony设备开发 轻量系统内核（LiteOS-M）基础内核时间管理

VOID ExampleTransformTime(VOID)
{
    UINT32 ms;
    UINT32 tick;

    /* 10000ms转换为tick */
    tick = LOS_MS2Tick(10000);
    printf("tick = %d \n", tick);

    /* 100tick转换为ms */
    ms = LOS_Tick2MS(100);
    printf("ms = %d \n", ms);
}

VOID ExampleGetTime(VOID)
{
    UINT32 cyclePerTick;
    UINT64 tickCountBefore;
    UINT64 tickCountAfter;

    cyclePerTick  = LOS_CyclePerTickGet();
    if (0 != cyclePerTick) {
        printf("LOS_CyclePerTickGet = %d \n", cyclePerTick);
    }

    tickCountBefore = LOS_TickCountGet();
    LOS_TaskDelay(200);
    tickCountAfter = LOS_TickCountGet();
    printf("LOS_TickCountGet after delay rising = %d \n", (UINT32)(tickCountAfter - tickCountBefore));
}

tick = 1000
ms = 1000

LOS_CyclePerTickGet = 250000 (根据实际运行环境，数据会有差异)
LOS_TickCountGet after delay rising = 200

#include "los_swtmr.h"

/* 定时器间隔时间 */
#define SWTMR_INTERVAL_LONG      1000
#define SWTMR_INTERVAL_SHORT     100

/* 定时器触发次数计数 */
UINT32 g_timerCount1 = 0;
UINT32 g_timerCount2 = 0;

/* 回调函数1，单次触发定时器的回调函数 */
void Timer1Callback(UINT32 arg)
{
    g_timerCount1++;
    printf("g_timerCount1=%d\n", g_timerCount1);
}

/* 回调函数2，多次触发定时器的回调函数 */
void Timer2Callback(UINT32 arg)
{
    g_timerCount2++;
    printf("g_timerCount2=%d\n", g_timerCount2);
}

void SwtmrTest(void)
{
    UINT32 ret;
    UINT32 id1; // 定时器id1，单次触发定时器
    UINT32 id2; // 定时器id2，周期触发定时器
    UINT32 tickCount;

#if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
    /* 创建单次软件定时器，Tick数为1000，启动到1000Tick数时执行回调函数1 */
    LOS_SwtmrCreate(SWTMR_INTERVAL_LONG, LOS_SWTMR_MODE_ONCE, Timer1Callback, &id1, 0,
                    OS_SWTMR_ROUSES_IGNORE, OS_SWTMR_ALIGN_SENSITIVE);

    /* 创建周期性软件定时器，每100Tick数执行回调函数2 */
    LOS_SwtmrCreate(SWTMR_INTERVAL_SHORT, LOS_SWTMR_MODE_PERIOD, Timer2Callback, &id2, 0,
                    OS_SWTMR_ROUSES_IGNORE, OS_SWTMR_ALIGN_SENSITIVE);
#else
    /* 创建单次软件定时器，Tick数为1000，启动到1000Tick数时执行回调函数1 */
    LOS_SwtmrCreate(SWTMR_INTERVAL_LONG, LOS_SWTMR_MODE_ONCE, Timer1Callback, &id1, 0);

    /* 创建周期性软件定时器，每100Tick数执行回调函数2 */
    LOS_SwtmrCreate(SWTMR_INTERVAL_SHORT, LOS_SWTMR_MODE_PERIOD, Timer2Callback, &id2, 0);
#endif

    /* 启动单次软件定时器 */
    ret = LOS_SwtmrStart(id1);
    printf("start Timer1 %s\n", (ret == LOS_OK) ? "success" : "failed");

    /* 短时间延时，定时器还未触发 */
    LOS_TaskDelay(SWTMR_INTERVAL_SHORT);

    /* 单次定时器还未到时间触发，此时停止应该成功 */
    ret = LOS_SwtmrStop(id1);
    printf("stop timer1 %s\n", (ret == LOS_OK) ? "success" : "failed");

    LOS_SwtmrStart(id1);
    
    /* 长时间延时，定时器触发 */
    LOS_TaskDelay(SWTMR_INTERVAL_LONG);

    /* 单次定时器触发后自删除，此时停止失败才是正常 */
    ret = LOS_SwtmrStop(id1);
    printf("timer1 self delete test %s\n", (ret != LOS_OK) ? "success" : "failed");

    /* 启动周期性软件定时器 */
    ret = LOS_SwtmrStart(id2);
    printf("start Timer2 %s\n", (ret == LOS_OK) ? "success" : "failed");

    /* 长时间延时，定时器周期触发 */
    LOS_TaskDelay(SWTMR_INTERVAL_LONG);

    LOS_SwtmrStop(id2);

    ret = LOS_SwtmrDelete(id2);
    if (ret == LOS_OK) {
        printf("delete Timer2 success\n");
    }
}

UINT32 ExampleSwtmr(VOID)
{
    UINT32 ret;
    TSK_INIT_PARAM_S taskParam = { 0 };
    UINT32 taskId;

    /* 锁任务调度 */
    LOS_TaskLock();

    /* 创建任务 */
    taskParam.pfnTaskEntry = (TSK_ENTRY_FUNC)SwtmrTest;
    taskParam.pcName       = "TimerTsk";
    taskParam.uwStackSize  = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
    taskParam.usTaskPrio   = 5;
    ret = LOS_TaskCreate(&taskId, &taskParam);
    if (ret != LOS_OK) {
        printf("TimerTsk create failed.\n");
        return LOS_NOK;
    }

    /* 解锁任务调度 */
    LOS_TaskUnlock();
    return LOS_OK;
}

start Timer1 success
stop timer1 success
g_timerCount1=1
timer1 self delete test success
start Timer2 success
g_timerCount2=1
g_timerCount2=2
g_timerCount2=3
g_timerCount2=4
g_timerCount2=5
g_timerCount2=6
g_timerCount2=7
g_timerCount2=8
g_timerCount2=9
g_timerCount2=10
delete Timer2 success

#include "stdio.h"
#include "los_list.h"

STATIC UINT32 ExampleList(VOID)
{
    LOS_DL_LIST listHead = {NULL,NULL};
    LOS_DL_LIST listNode1 = {NULL,NULL};
    LOS_DL_LIST listNode2 = {NULL,NULL};

    /* 初始化链表 */
    printf("Initial head\n");
    LOS_ListInit(&listHead);

    /* 添加节点1和节点2，并校验他们的相互关系 */
    LOS_ListAdd(&listHead, &listNode1);
    if (listNode1.pstNext == &listHead && listNode1.pstPrev == &listHead) {
        printf("Add listNode1 success\n");
    }

    LOS_ListTailInsert(&listHead, &listNode2);
    if (listNode2.pstNext == &listHead && listNode2.pstPrev == &listNode1) {
        printf("Tail insert listNode2 success\n");
    }

    /* 删除两个节点 */
    LOS_ListDelete(&listNode1);
    LOS_ListDelete(&listNode2);

    /* 确认链表为空 */
    if (LOS_ListEmpty(&listHead)) {
        printf("Delete success\n");
    }

    return LOS_OK;
}

Initial head 
Add listNode1 success 
Tail insert listNode2 success
Delete success