本文主要介绍在嵌入式开发中用来输出log的方法。

最常用的是通过串口输出uart log，这种方法实现简单，大部分嵌入式芯片都有串口功能。但是这样简单的功能有时候却不是那么好用，比如：

• 一款新拿到的芯片，没有串口驱动时如何打印log

• 某些应用下对时序要求比较高，串口输出log占用时间太长怎么办？比如USB枚举。

•  某些bug正常运行时会出现，当打开串口log时又不再复现怎么办

• 一些封装中没有串口，或者串口已经被用作其他用途，要如何输出log 

下文来讨论这些问题。

1、输出log信息到SRAM

准确来说这里并不是输出log，而是以一种方式不使用串口就可以看到log。在芯片开发阶段都可以连接仿真器调试，可以使用打断点的方法调试，但是有些操作如果不能被打断就没法使用断点调试了。

这时候可以考虑将log打印到SRAM中，整个操作结束后再通过仿真器查看SRAM中的log buffer，这样就实现了间接的log输出。

本文使用的测试平台是STM32F407 discovery，基于usb host实验代码，对于其他嵌入式平台原理也是通用的。首先定义一个结构体用于打印log，如下:

定义一段SRAM空间作为log buffer:

static u8 log_buffer[LOG_MAX_LEN];

log buffer是环形缓冲区，在小的buffer就可以无限打印log，缺点也很明显，如果log没有及时输出就会被新的覆盖。Buffer大小根据SRAM大小分配，这里使用1kB。为了方便输出参数，使用printf函数来格式化输出，需要做如下配置（Keil）：

并包含头文件#include <stdio.h>, 在代码中实现函数fputc()：

写入数据到SRAM：

为了方便控制log打印格式，在头文件中再添加自定义的打印函数。

在需要打印log的地方直接调用DEBUG()即可，最终效果如下，从Memory窗口可以看到打印的log：

2、通过SWO输出log

通过打印log到SRAM的方式可以看到log，但是数据量多的时候可能来不及查看就被覆盖了。为了解决这个问题，可以使用St-link的SWO输出log，这样就不用担心log被覆盖。查看原理图f407 discovery的SWO已经连接了，否则需要自己飞线连接：

在log结构体中添加SWO的操作函数集：

typedef struct
{
    u8 (*init)(void* arg);
    u8 (*print)(u8 ch);
    u8 (*print_dma)(u8* buffer, u32 len);
}log_func;

typedef struct 
{
    volatile u8     type;
    u8*             buffer;
    volatile u32    write_idx;
    volatile u32    read_idx;
    //SWO
    log_func*       swo_log_func;
}log_dev;

SWO只需要print操作函数，实现如下：

u8 swo_print_ch(u8 ch)
{
    ITM_SendChar(ch);
    return 0;
}

使用SWO输出log同样先输出到log buffer，然后在系统空闲时再输出，当然也可以直接输出。log延迟输出会影响log的实时性，而直接输出会影响到对时间敏感的代码运行，所以如何取舍取决于需要输出log的情形。

在while循环中调用output_ch()函数，就可以实现在系统空闲时输出log。

/*output log buffer to I/O*/
void output_ch(void)
{   
    u8 ch;
    volatile u32 tmp_write,tmp_read;
    tmp_write = log_dev_ptr->write_idx;
    tmp_read = log_dev_ptr->read_idx;

    if(tmp_write != tmp_read)
    {
        ch = log_dev_ptr->buffer[tmp_read++];
        //swo
        if(log_dev_ptr->swo_log_func)
            log_dev_ptr->swo_log_func->print(ch);
        if(tmp_read >= LOG_MAX_LEN)
        {
            log_dev_ptr->read_idx = 0;
        }
        else
        {
            log_dev_ptr->read_idx = tmp_read;
        }
    }
}

2.1 通过IDE输出

使用IDE中SWO输出功能需要做如下配置（Keil）：

在窗口可以看到输出的log：

2.2 通过STM32 ST-LINK Utility输出

使用STM32 ST-LINK Utility不需要做特别的设置，直接打开ST-LINK菜单下的Printf via SWO viewer，然后按start：

3、通过串口输出log

以上都是在串口log暂时无法使用，或者只是临时用一下的方法，而适合长期使用的还是需要通过串口输出log，毕竟大部分时候没法连接仿真器。添加串口输出log只需要添加串口的操作函数集即可：

typedef struct 
{
    volatile u8     type;
    u8*             buffer;
    volatile u32    write_idx;
    volatile u32    read_idx;
    volatile u32    dma_read_idx;
    //uart
    log_func*       uart_log_func;
    //SWO
    log_func*       swo_log_func;
}log_dev;

实现串口驱动函数：

添加串口输出log与通过SWO过程类似，不再多叙述。而下面要讨论的问题是，串口的速率较低，输出数据需要较长时间，严重影响系统运行。

虽然可以通过先打印到SRAM再延时输出的办法来减轻影响，但是如果系统中断频繁，或者需要做耗时运算，则可能会丢失log。要解决这个问题，就是要解决CPU与输出数据到串口同时进行的问题，嵌入式工程师立马可以想到DMA正是好的解决途径。

使用DMA搬运log数据到串口输出，同时又不影响CPU运行，这样就可以解决输出串口log耗时影响系统的问题。串口及DMA初始化函数如下：

u8 uart_log_init(void* arg)
{
    DMA_InitTypeDef DMA_InitStructure;
    u32* bound = (u32*)arg;
    //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//使能USART2时钟
    //串口2对应引脚复用映射
    GPIO_PinAFConfig(GPIOA,GPIO_PinSource2,GPIO_AF_USART2);
    //USART2端口配置
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    GPIO_Init(GPIOA,&GPIO_InitStructure);
    //USART2初始化设置
    USART_InitStructure.USART_BaudRate = *bound;//波特率设置
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    USART_InitStructure.USART_Mode = USART_Mode_Tx; //收发模式
    USART_Init(USART2, &USART_InitStructure); //初始化串口1
    #ifdef LOG_UART_DMA_EN  
    USART_DMACmd(USART2,USART_DMAReq_Tx,ENABLE);
    #endif  
    USART_Cmd(USART2, ENABLE);  //使能串口1 
    USART_ClearFlag(USART2, USART_FLAG_TC);
    while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
    #ifdef LOG_UART_DMA_EN
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    //Config DMA channel, uart2 TX usb DMA1 Stream6 Channel
    DMA_DeInit(DMA1_Stream6);
    DMA_InitStructure.DMA_Channel = DMA_Channel_4;
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART2->DR);
    DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_High;
    DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable; 
    DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
    DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
    DMA_Init(DMA1_Stream6, &DMA_InitStructure);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
    #endif
    return 0;
}

DMA输出到串口的函数如下：

这里为了方便直接使用了查询DMA状态寄存器，有需要可以修改为DMA中断方式，查Datasheet可以找到串口2使用DMA1 channel4的stream6：

最后在PC端串口助手可以看到log输出：

使用DMA搬运log buffer中数据到串口，同时CPU可以处理其他事情，这种方式对系统影响最小，并且输出log及时，是实际使用中用的最多的方式。并且不仅可以用串口，其他可以用DMA操作的接口（如SPI、USB）都可以使用这种方法来打印log。

4、使用IO口模拟串口输出log

最后要讨论的是在一些封装中没有串口，或者串口已经被用作其他用途时如何输出log，这时可以找一个空闲的普通IO，模拟UART协议输出log到上位机的串口工具。常用的UART协议如下：

只要在确定的时间在IO上输出高低电平就可以模拟出波形，这个确定的时间就是串口波特率。为了得到精确延时，这里使用TIM4定时器产生1us的延时。注意：定时器不能重复用，在测试工程中TIM2、3都被用了，如果重复用就错乱了。初始化函数如下：

u8 simu_log_init(void* arg)
{
    TIM_TimeBaseInitTypeDef TIM_InitStructure;  
    u32* bound = (u32*)arg;
    //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //速度50MHz
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    GPIO_Init(GPIOA,&GPIO_InitStructure);
    GPIO_SetBits(GPIOA, GPIO_Pin_2);
    //Config TIM
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4,ENABLE); //使能TIM4时钟
    TIM_DeInit(TIM4);
    TIM_InitStructure.TIM_Prescaler = 1;        //2分频
    TIM_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_InitStructure.TIM_Period = 41;          //1us timer
    TIM_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_TimeBaseInit(TIM4, &TIM_InitStructure);
    TIM_ClearFlag(TIM4, TIM_FLAG_Update);
    baud_delay = 1000000/(*bound);          //根据波特率计算每个bit延时
    return 0;
}

使用定时器的delay函数为：

最后是模拟输出函数，注意：输出前必须要关闭中断，一个byte输出完再打开，否则会出现乱码：

u8 simu_print_ch(u8 ch)
{
    volatile u8 i=8;
    __asm("cpsid i");
    //start bit
    GPIO_ResetBits(GPIOA, GPIO_Pin_2);
    simu_delay(baud_delay);
    while(i--)
    {
        if(ch & 0x01)
        GPIO_SetBits(GPIOA, GPIO_Pin_2);
        else
        GPIO_ResetBits(GPIOA, GPIO_Pin_2);
        ch >>= 1;
        simu_delay(baud_delay);
    }
    //stop bit
    GPIO_SetBits(GPIOA, GPIO_Pin_2);
    simu_delay(baud_delay);
    simu_delay(baud_delay);
    __asm("cpsie i");
    return 0;
}

使用IO模拟可以达到与真实串口类似的效果，并且只需要一个普通IO，在小封装芯片上比较使用。

NorthFrame是基于非UML极简理念的状态机框架

配合NF_FsmDesigner图形化开发工具，可无负担替代传统switch-case状态机开发。

1、NorthFrame的组件

• NF_FSM :

  极简非UML状态机框架

• NF_FsmDesigner :

  基于C# Winform开发的状态机图形化开发工具，可直接生成C代码

• NF_Signal :

  用于代替全局变量的动态信号机制

NF_Signal ：代替全局变量，使用方便：

NF_Signal_Set("flag_connect", 1);
NF_Signal_Set("blink_cnt", 3);
NF_SignalValue flag_connect = NF_Signal_Get("flag_connect");

2、NorthFrame图形化状态机开发

以下例程在VS2012环境中运行一个判断QE组合键的状态机：

Step1 : 使用NF_FsmDesigner工具设计绘制状态转换图，并保存为XML文件

Step2 : 点击生成代码，生成如下C语言代码

#include <n_frame.h>
#include <fsm_qande.h>

/* 转换执行的外部函数声明 */
extern void IDLE_TO_Q(void);
extern void Q_TO_QE(void);
extern void QE_TO_IDLE(void);
extern void QE_TO_Q(void);
extern void Q_TO_IDLE(void);

/* 状态处理函数声明 */
void FSM_QandE_IDLE(NF_FSM* me, NF_Event event);
void FSM_QandE_Q_DOWN(NF_FSM* me, NF_Event event);
void FSM_QandE_QE_DOWN(NF_FSM* me, NF_Event event);

/* 状态机对象 */
NF_FSM FSM_QandE = {
    FSM_QandE_IDLE
};

/* IDLE状态处理函数 */
void FSM_QandE_IDLE(NF_FSM* me, NF_Event event)
{

    if (NF_FSM_NameIs(event.Name, "Q_DOWN"))
    {
        IDLE_TO_Q();
        NF_FSM_TRAN(FSM_QandE_Q_DOWN);
        return ;
    }

    if (NF_FSM_NameIs(event.Name, "test"))
    {
        NF_FSM_TRAN(FSM_QandE_IDLE);
        return ;
    }
}

/* Q_DOWN状态处理函数 */
void FSM_QandE_Q_DOWN(NF_FSM* me, NF_Event event)
{

    if (NF_FSM_NameIs(event.Name, "E_DOWN"))
    {
        Q_TO_QE();
        NF_FSM_TRAN(FSM_QandE_QE_DOWN);
        return ;
    }

    if (NF_FSM_NameIs(event.Name, "Q_UP"))
    {
        Q_TO_IDLE();
        NF_FSM_TRAN(FSM_QandE_IDLE);
        return ;
    }
}

/* QE_DOWN状态处理函数 */
void FSM_QandE_QE_DOWN(NF_FSM* me, NF_Event event)
{

    if (NF_FSM_NameIs(event.Name, "Q_UP"))
    {
        QE_TO_IDLE();
        NF_FSM_TRAN(FSM_QandE_IDLE);
        return ;
    }

    if (NF_FSM_NameIs(event.Name, "E_UP"))
    {
        QE_TO_Q();
        NF_FSM_TRAN(FSM_QandE_Q_DOWN);
        return ;
    }
}

Step3 : 在main.c文件中实现按键处理，并发送事件给状态机

备注 : 后续版本会加入发布-订阅机制，目前仅支持直接派发

#include "n_frame.h"

#include "windows.h"
#include "stdio.h"

#include "fsm_qande.h"

#define KEY_VALUE(_key) ((GetKeyState(_key) >= 0) ? NF_Bool_False : NF_Bool_True )

/* 信号产生者 */
void Test_Key_Process(void)
{
 static NF_Bool last_q_val = NF_Bool_False;
 static NF_Bool last_e_val = NF_Bool_False;

 NF_Bool then_q_val;
 NF_Bool then_e_val;

 then_q_val = KEY_VALUE('Q');
 then_e_val = KEY_VALUE('E');

 /* Q键事件处理 */
 if ((last_q_val == NF_Bool_False) && (KEY_VALUE('Q') == NF_Bool_True))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("Q_DOWN"));
 } 
 else if ((last_q_val == NF_Bool_True) && (KEY_VALUE('Q') == NF_Bool_False))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("Q_UP"));
 }

 /* E键事件处理 */
 if ((last_e_val == NF_Bool_False) && (KEY_VALUE('E') == NF_Bool_True))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("E_DOWN"));
 } 
 else if ((last_e_val == NF_Bool_True) && (KEY_VALUE('E') == NF_Bool_False))
 {
  NF_FSM_Dispatch(&FSM_QandE, NF_FSM_Event("E_UP"));
 }

 last_q_val = then_q_val;
 last_e_val = then_e_val;
}

void IDLE_TO_Q(void)
{
 printf("state translate : IDLE -> Q_DOWN\n");
}

void Q_TO_QE(void)
{
 printf("state translate : Q_DOWN -> QE_DOWN\n");
}

void QE_TO_IDLE(void)
{
 printf("state translate : QE_DOWN -> IDLE\n");
}

void QE_TO_Q(void)
{
 printf("state translate : QE_DOWN -> Q_DOWN\n");
}

void Q_TO_IDLE(void)
{
 printf("state translate : Q_DOWN -> IDLE\n");
}

int main(void)
{
 for (;;)
 {
  Test_Key_Process();
 }
}

克隆链接：

git clone https://gitee.com/PISCES_X/NorthFrame.git

在编写单片机程序的时候，由于中断服务程序写的不好，导致单片机程序总是跑飞，最后费了好长时间，花了很大功夫才找到问题原因，由此总结了单片机程序跑飞的三种现象、原因及解决方法。

1、数组越界/溢出

现象：

单片机程序在函数中运行时，总是在运行到函数末尾，要跳出函数时，程序跑飞。

原因：

数组越界（数组溢出），函数中定义的数组元素的个数小于程序中实际使用的数组元素的个数，例如在函数中定义了一个数组ucDataBuff[10]，这个数组只有10个元素，但是在函数中却有这样的语句ucDataBuff[10]=0x1a,这个语句是给数组的第11个元素赋值，：由于定义的数组只有10个元素，从而导致赋值语句中不知道把0x1a放到什么地方，从而导致程序跑飞。

解决方法：

如果在调试程序时，发现程序总是在函数执行完毕时跑飞，多数情况是发生了数组越界（数组溢出）的错误，仔细检查函数中调用的数组是否存在越界（溢出）的情况。

2、中断服务程序缺失

现象：

程序运行过程中总是跑飞。

原因：

程序中打开了某个中断，但是却没有相应的中断服务程序，从而导致在中断发生后，找不到中断服务程序入口，从而导致程序跑飞。

解决方法：

检查程序中是否存在打开了某个中断，但是没有相对应的中断服务程序。

3、看门狗复位

现象：

在执行一段较为耗费时间的程序时，程序跑飞，并且总是跳到复位位置处。

原因：

程序中使用了看门狗，但是没有及时“喂狗”，从而导致看门狗复位，使程序直接跳到复位位置。

解决方法：

根据程序运行时间，尤其是一定要计算清楚最耗时的那段程序的运行时间，然后准确设置看门狗的复位时长，定时“喂狗”，尤其是如果有死循环的情况，一定要在死循环中记得“喂狗”。

今天分享一篇单片机程序框架的文章。

程序架构重要性

很多人尤其是初学者在写代码的时候往往都是想一点写一点，最开始没有一个整体的规划，导致后面代码越写越乱，bug不断。

最终代码跑起来看似没有问题(有可能也真的没有问题)，但是要加一个功能的时候会浪费大量的时间，甚至导致整个代码的崩溃。

所以，在一个项目开始的时候多花一些时间在代码的架构设计上是十分有必要的。代码架构确定好了之后你会发现敲代码的时候会特别快，并且在后期调试的时候也不会像无头苍蝇一样胡乱找问题。当然，调试也是一门技术。

在学习实时操作系统的过程中，发现实时操作系统框架与个人的业务代码之间的耦合性就非常低，都是只需要将业务代码通过一定的接口函数注册好后就交给操作系统托管了，十分方便。

但是操作系统的调度过于复杂，这里就使用操作系统的思维方式来重构这个时间片轮询框架。实现该框架的完全解耦，用户只需要包含头文件，并且在使用过程中不需要改动已经写好的库文件。

Demo

首先来个demo，该demo是使用电脑开两个线程：一个线程模拟单片机的定时器中断产生时间片轮询个时钟，另一个线程则模拟主函数中一直运行的时间片轮询调度程序。

#include <thread>
#include <stdio.h>
#include <windows.h>
#include "timeslice.h"

// 创建5个任务对象
TimesilceTaskObj task_1, task_2, task_3, task_4, task_5;

// 具体的任务函数
void task1_hdl()
{
    printf(">> task 1 is running ...\n");
}

void task2_hdl()
{
    printf(">> task 2 is running ...\n");
}

void task3_hdl()
{
    printf(">> task 3 is running ...\n");
}

void task4_hdl()
{
    printf(">> task 4 is running ...\n");
}

void task5_hdl()
{
    printf(">> task 5 is running ...\n");
}

// 初始化任务对象，并且将任务添加到时间片轮询调度中
void task_init()
{
    timeslice_task_init(&task_1, task1_hdl, 1, 10);
    timeslice_task_init(&task_2, task2_hdl, 2, 20);
    timeslice_task_init(&task_3, task3_hdl, 3, 30);
    timeslice_task_init(&task_4, task4_hdl, 4, 40);
    timeslice_task_init(&task_5, task5_hdl, 5, 50);
    timeslice_task_add(&task_1);
    timeslice_task_add(&task_2);
    timeslice_task_add(&task_3);
    timeslice_task_add(&task_4);
    timeslice_task_add(&task_5);
}


// 开两个线程模拟在单片机上的运行过程
void timeslice_exec_thread()
{
    while (true)
    {
        timeslice_exec();
    }
}

void timeslice_tick_thread()
{
    while (true)
    {
        timeslice_tick();
        Sleep(10);
    }
}

int main()
{
    task_init();

    printf(">> task num: %d\n", timeslice_get_task_num());
    printf(">> task len: %d\n", timeslice_get_task_timeslice_len(&task_3));

    timeslice_task_del(&task_2);
    printf(">> delet task 2\n");
    printf(">> task 2 is exist: %d\n", timeslice_task_isexist(&task_2));

    printf(">> task num: %d\n", timeslice_get_task_num());

    timeslice_task_del(&task_5);
    printf(">> delet task 5\n");

    printf(">> task num: %d\n", timeslice_get_task_num());

    printf(">> task 3 is exist: %d\n", timeslice_task_isexist(&task_3));
    timeslice_task_add(&task_2);
    printf(">> add task 2\n");
    printf(">> task 2 is exist: %d\n", timeslice_task_isexist(&task_2));

    timeslice_task_add(&task_5);
    printf(">> add task 5\n");

    printf(">> task num: %d\n", timeslice_get_task_num());

    printf("\n\n========timeslice running===========\n");

    std::thread thread_1(timeslice_exec_thread);
    std::thread thread_2(timeslice_tick_thread);

    thread_1.join();
    thread_2.join();


    return 0;
}

运行结果如下：

由以上例子可见，这个框架使用十分方便，甚至可以完全不知道其原理，仅仅通过几个简单的接口就可以迅速创建任务并加入到时间片轮询的框架中，十分好用。

时间片轮询架构

其实该部分主要使用了面向对象的思维，使用结构体作为对象，并使用结构体指针作为参数传递，这样作可以节省资源，并且有着极高的运行效率。

其中最难的部分是侵入式链表的使用，这种链表在一些操作系统内核中使用十分广泛，这里是参考RT-Thread实时操作系统中的侵入式链表实现。

h文件：

#ifndef _TIMESLICE_H
#define _TIMESLICE_H

#include "./list.h"

typedef enum {
    TASK_STOP,
    TASK_RUN
} IsTaskRun;

typedef struct timesilce
{
    unsigned int id;
    void (*task_hdl)(void);
    IsTaskRun is_run;
    unsigned int timer;
    unsigned int timeslice_len;
    ListObj timeslice_task_list;
} TimesilceTaskObj;

void timeslice_exec(void);
void timeslice_tick(void);
void timeslice_task_init(TimesilceTaskObj* obj, void (*task_hdl)(void), unsigned int id, unsigned int timeslice_len);
void timeslice_task_add(TimesilceTaskObj* obj);
void timeslice_task_del(TimesilceTaskObj* obj);
unsigned int timeslice_get_task_timeslice_len(TimesilceTaskObj* obj);
unsigned int timeslice_get_task_num(void);
unsigned char timeslice_task_isexist(TimesilceTaskObj* obj);

#endif

c文件：

#include "./timeslice.h"

static LIST_HEAD(timeslice_task_list);

void timeslice_exec()
{
    ListObj* node;
    TimesilceTaskObj* task;

    list_for_each(node, &timeslice_task_list)
    {
           
        task = list_entry(node, TimesilceTaskObj, timeslice_task_list);
        if (task->is_run == TASK_RUN)
        {
            task->task_hdl();
            task->is_run = TASK_STOP;
        }
    }
}

void timeslice_tick()
{
    ListObj* node;
    TimesilceTaskObj* task;

    list_for_each(node, &timeslice_task_list)
    {
        task = list_entry(node, TimesilceTaskObj, timeslice_task_list);
        if (task->timer != 0)
        {
            task->timer--;
            if (task->timer == 0)
            {
                task->is_run = TASK_RUN;
                task->timer = task->timeslice_len;
            }
        }
    }
}

unsigned int timeslice_get_task_num()
{
    return list_len(&timeslice_task_list);
}

void timeslice_task_init(TimesilceTaskObj* obj, void (*task_hdl)(void), unsigned int id, unsigned int timeslice_len)
{
    obj->id = id;
    obj->is_run = TASK_STOP;
    obj->task_hdl = task_hdl;
    obj->timer = timeslice_len;
    obj->timeslice_len = timeslice_len;
}

void timeslice_task_add(TimesilceTaskObj* obj)
{
    list_insert_before(&timeslice_task_list, &obj->timeslice_task_list);
}

void timeslice_task_del(TimesilceTaskObj* obj)
{
    if (timeslice_task_isexist(obj))
        list_remove(&obj->timeslice_task_list);
    else
        return;
}


unsigned char timeslice_task_isexist(TimesilceTaskObj* obj)
{
    unsigned char isexist = 0;
    ListObj* node;
    TimesilceTaskObj* task;

    list_for_each(node, &timeslice_task_list)
    {
        task = list_entry(node, TimesilceTaskObj, timeslice_task_list);
        if (obj->id == task->id)
            isexist = 1;
    }

    return isexist;
}

unsigned int timeslice_get_task_timeslice_len(TimesilceTaskObj* obj)
{
    return obj->timeslice_len;
}

底层侵入式双向链表