工作经验总结：单片机中简易时间片轮询的结构设计

最新推荐文章于 2024-03-01 14:23:23 发布
最新推荐文章于 2024-03-01 14:23:23 发布
阅读量2.8k 收藏 64
点赞数 12
分类专栏： 工作经验 文章标签： 时间片轮询 单片机程序结构设计 单片机OS设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laifengyuan1/article/details/130748806
版权

目录

一、单片机中常见的几种模式介绍

二、简易时间片轮询结构设计

1、任务调度表的设计

（1）任务调度表的结构体设计

（2）时间片的处理与任务的启停

（3）任务调度表的实现

三、关于上述时间片轮询结构设计的一些补充

1、任务调度表的优先级调度设计

（1）任务调度表优先级与优先级计算的设计

（2）时间片轮询处理函数的修改

（3）任务调度函数的修改

一、单片机中常见的几种模式介绍

在MCU的设计与开发中有以下常见的程序结构设计：

  • 裸机：功能单一，简单的顺序执行
  • 时间片轮询：多任务、内存占用较少
  • RTOS：多任务、系统复杂性高，有较高的实时性要求和可靠性要求

其实一般情况下能上RTOS一般就上RTOS，根本不需要考虑时间片轮询的情况，斟酌使用时间片轮询的情况主要的考虑有以下几点：

  • MCU的RAM和ROM资源问题，引入RTOS会带来额外的内存开销
  • 业务功能的拆解与多任务的设计，有时候使用时间片轮询可以让整个结构更加简单易懂，方便设计
  • 调试更为简单方便

使用时间片轮询时要注意的点：

  • 功能任务划分的合理性，多任务的情况下，每个任务的执行都尽量设计成短小精悍。（例如：执行1个任务需要10ms，你不能只给它分配5ms的时间片）
  • 任务数量与MCU主频的简单关系估算：任务数量 = MCU主频 / (时间片大小 × 任务平均处理时间) ；例如：在一个系统中有10个任务，并且每个任务需要相同的时间片大小为10ms，那么每个任务将获得1/10的CPU时间，也就是10%的CPU时间。如果我们希望系统总体运行效率高达80%，那么MCU的主频应该是所有任务的最小执行时间的8倍，即主频应该为1/（10毫秒* 8） = 1250 Hz

二、简易时间片轮询结构设计

1、任务调度表的设计

（1）任务调度表的结构体设计

其中，任务调度表中包含了任务编号(或者可以设计成表中的索引)、回调的任务函数、任务类型（周期或者事件类型）、任务开关、任务状态（包括执行后的状态）、任务时间片计数、任务时间片初始值

/******************************************
 *          OS Task No
 ******************************************/
#define OS_TASK_NO1   0
#define OS_TASK_NO2   1
#define OS_TASK_NO3   2
#define OS_TASK_NO4   3
#define OS_TASK_NO5   4
#define OS_TASK_NO6   5
#define OS_TASK_NO7   6
#define OS_TASK_NO8   7

#define OS_TASK_MAX_NO 8

/******************************************
 *          OS Task switch
 ******************************************/
#define OS_TASK_OFF       0
#define OS_TASK_ON        1

/******************************************
 *          OS Task Type
 ******************************************/
#define OS_TASK_EVENT     0
#define OS_TASK_CYCLC     1

/******************************************
 *          OS Task Status
 ******************************************/
#define OS_TASK_OK             0
#define OS_TASK_READY          1
#define OS_TASK_ERROR          2

/******************************************
 *          Struct and Enum
 ******************************************/
typedef struct 
{
    uint8_t os_task_number;
    uint8_t (*taskFunc)(void);
    uint8_t os_task_type;
    uint8_t os_task_switch;
    uint8_t os_task_status;
    uint8_t os_task_tickCnt;
    uint8_t os_task_tickInit;

}OS_TASK_SCHEDULE_t;

（2）时间片的处理与任务的启停

  • 时间片的处理：放置在定时器或者Systick定时器的中断中，对所有任务的时间片计数进行处理，当计数值减少到0时，把对应任务的状态赋为Ready态，并对时间片赋初始计数值
void OS_TmrIsrTask(void)
{
    uint8_t indx = 0;

    OS_DISABLE_INTERRUPT();
    for(indx = 0; indx < osTaskScheduleCfgSize; indx++)
    {
        if(osTaskScheduleCfg[indx].os_task_switch == OS_TASK_ON &&\
           osTaskScheduleCfg[indx].os_task_status != OS_TASK_READY)
        {
            if(osTaskScheduleCfg[indx].os_task_tickCnt > 0)
            {
                osTaskScheduleCfg[indx].os_task_tickCnt--;
            }

            if(osTaskScheduleCfg[indx].os_task_tickCnt == 0)
            {
                osTaskScheduleCfg[indx].os_task_status = OS_TASK_READY;
                
                switch(osTaskScheduleCfg[indx].os_task_type)
                {
                    case OS_TASK_CYCLC:
                    {
                        osTaskScheduleCfg[indx].os_task_tickCnt = osTaskScheduleCfg[indx].os_task_tickInit;
                        break;
                    }
                    case OS_TASK_EVENT:
                    {
                        break;
                    }
                }

            }

        }
    }
    OS_ENABLE_INTERRUPT();
}

  • 任务的启停：

void OS_TaskTmrEventStart(uint8_t task_number)
{
    uint8_t indx = 0;

    OS_DISABLE_INTERRUPT();
    for(indx = 0; indx <= osTaskScheduleCfgSize; indx++)
    {
        if(task_number == osTaskScheduleCfg[indx].os_task_number)
        {
            osTaskScheduleCfg[indx].os_task_switch = OS_TASK_ON;
            osTaskScheduleCfg[indx].os_task_tickCnt = osTaskScheduleCfg[indx].os_task_tickInit;

            break;
        }
    }
    OS_ENABLE_INTERRUPT();
    
}

void OS_TaskTmrEventStop(uint8_t task_number)
{
    uint8_t indx = 0;

    OS_DISABLE_INTERRUPT();
    for(indx = 0; indx <= osTaskScheduleCfgSize; indx++)
    {
        if(task_number == osTaskScheduleCfg[indx].os_task_number)
        {
            osTaskScheduleCfg[indx].os_task_switch = OS_TASK_OFF;
            osTaskScheduleCfg[indx].os_task_tickCnt = 0;

            break;
        }
    }
    OS_ENABLE_INTERRUPT();
}

（3）任务调度表的实现

  • 任务调度表的实现：循环遍历任务调度表中每个任务的状态，当有处于Ready状态的任务时，则去执行。
void OS_StartSchedule(void)
{
    uint8_t indx;

    for(;;)
    {
        for(indx = 0; indx < osTaskScheduleCfgSize; indx++)
        {
            switch(osTaskScheduleCfg[indx].os_task_status)
            {
                case OS_TASK_OK:
                {
                    break;
                }
                case OS_TASK_ERROR:
                {
                    break;
                }
                case OS_TASK_READY:
                {
                    OS_DISABLE_INTERRUPT();
                    if(osTaskScheduleCfg[indx].taskFunc != NULL)
                    {
                        osTaskScheduleCfg[indx].os_task_status = osTaskScheduleCfg[indx].taskFunc();

                        if(osTaskScheduleCfg[indx].os_task_type == OS_TASK_EVENT)
                        {
                            osTaskScheduleCfg[indx].os_task_switch = OS_TASK_OFF;
                        }

                    }
                    OS_ENABLE_INTERRUPT();
                    break;
                }
            }
        }
    }   
}
  • 任务调度表与任务的配置：其中还可以根据对初始化tickCnt的值的差异，来控制先后执行任务的顺序
/*********************************************
 *          OS Task Schedule Config 
 *********************************************/
OS_TASK_SCHEDULE_t osTaskScheduleCfg[] = 
{   
    /* level            taskFunc     task_type           task_switch      os_task_status     task_tickCnt    task_tickInit */
    {OS_TASK_NO1,       os_task1,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        0,              100               },
    {OS_TASK_NO2,       os_task2,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        1,              100               },
    {OS_TASK_NO3,       os_task3,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        2,              100               },
    {OS_TASK_NO4,       os_task4,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        3,              100               },
    {OS_TASK_NO5,       os_task5,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        4,              100               },
    {OS_TASK_NO6,       os_task6,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        5,              100               },
    {OS_TASK_NO7,       os_task7,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        6,              100               },
    {OS_TASK_NO8,       os_task8,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        7,              100               },

};

uint8_t osTaskScheduleCfgSize = sizeof(osTaskScheduleCfg) / sizeof(OS_TASK_SCHEDULE_t);

/******************************************
 *          User Task Function
 ******************************************/
uint8_t os_task1(void)
{
    /* do something */

    return OS_TASK_OK
}

uint8_t os_task2(void)
{
    /* do something */

    return OS_TASK_OK
}

uint8_t os_task3(void)
{
    /* do something */

    return OS_TASK_OK
}

uint8_t os_task4(void)
{
    /* do something */

    return OS_TASK_OK
}

uint8_t os_task5(void)
{
    /* do something */

    return OS_TASK_OK
}

uint8_t os_task6(void)
{
    /* do something */

    return OS_TASK_OK
}

uint8_t os_task7(void)
{
    /* do something */

    return OS_TASK_OK
}

uint8_t os_task8(void)
{
    /* do something */

    return OS_TASK_OK
}

三、关于上述时间片轮询结构设计的一些补充

1、任务调度表的优先级调度设计

上述设计中，当两个任务同时Ready的时候，仅会按照顺序进行处理。当一些业务功能有优先级功能区分的时候，就无法满足这样的需求，这时候就要对上述设计进行改进。

（1）任务调度表优先级与优先级计算的设计

  • 任务调度表优先级的设计与就绪任务队列的设计

在原来任务调度表的基础上再新增一个优先级调度表结构体，设计如下：包含优先级（索引）、任务调度表、任务调度表长度、就绪任务的编号FIFO。

（注：就绪任务队列中存放着已经准备就绪的任务编号）

typedef struct
{
    uint8_t head;
    uint8_t tail;
    uint8_t buf[OS_READY_FIFO_MAX];

}OS_RdyNoFifo_t;

typedef struct 
{
    uint8_t os_task_number;
    uint8_t (*taskFunc)(void);
    uint8_t os_task_type;
    uint8_t os_task_switch;
    uint8_t os_task_status;
    uint8_t os_task_tickCnt;
    uint8_t os_task_tickInit;

}OS_TASK_SCHEDULE_t;

typedef struct
{
    uint8_t             prio_number;
    OS_TASK_SCHEDULE_t  *osTaskScheduleCfg;
    uint8_t             *osTaskScheduleCfgSize;
    OS_RdyNoFifo_t      *osRdyNofifoBuf;

}OS_PRIO_SCHEDULE_t;
  • 优先级计算的设计

假如我们需要8层的优先级，我们可以以1个字节中的每一位来充当1级优先级。数值越大，则优先级越高。设计如下：

/*******************************************************************
 *          OS Priority Schedule Number(Index)
 *******************************************************************/
#define OS_PRIO_LEVEL_1     0
#define OS_PRIO_LEVEL_2     1
#define OS_PRIO_LEVEL_3     2
#define OS_PRIO_LEVEL_4     3
#define OS_PRIO_LEVEL_5     4
#define OS_PRIO_LEVEL_6     5
#define OS_PRIO_LEVEL_7     6
#define OS_PRIO_LEVEL_8     7

#define OS_PRIO_LEVEL_MAX   8

#define OS_PRIO_VAL_LEVEL(x)            (1 << (7 - x))
#define OS_PRIO_VAL_LEVEL_1             (1 << (7 - OS_PRIO_LEVEL_1))
#define OS_PRIO_VAL_LEVEL_2             (1 << (7 - OS_PRIO_LEVEL_2))
#define OS_PRIO_VAL_LEVEL_3             (1 << (7 - OS_PRIO_LEVEL_3))
#define OS_PRIO_VAL_LEVEL_4             (1 << (7 - OS_PRIO_LEVEL_4))
#define OS_PRIO_VAL_LEVEL_5             (1 << (7 - OS_PRIO_LEVEL_5))
#define OS_PRIO_VAL_LEVEL_6             (1 << (7 - OS_PRIO_LEVEL_6))
#define OS_PRIO_VAL_LEVEL_7             (1 << (7 - OS_PRIO_LEVEL_7))
#define OS_PRIO_VAL_LEVEL_8             (1 << (7 - OS_PRIO_LEVEL_8))

以2层优先级为例，LEVEL_1与LEVEL_2，则有以下几种情况：

// 仅LEVEL1 任务产生
priority = 0x80;

// 仅LEVEL2 任务产生
priority = 0x40;

// LEVEL1和LEVEL2任务同时产生，此时要先执行LEVEL1的任务
priority = 0xC0;

 优先级计算函数：

static bool OS_isScheduleExistTask(OS_RdyNoFifo_t *osRdyNofifoBuf)
{
    bool ret = false;
    if(osRdyNofifoBuf->head != osRdyNofifoBuf->tail)
    {
        ret = true;
    }
    return ret;
}


static uint8_t OS_SchedulePrioCal(void)
{
    uint8_t indx = 0;
    uint8_t prio_number = 0;
    uint8_t priority = 0;
    OS_RdyNoFifo_t *osRdyNofifoBuf;

    for(indx = 0; indx < osTaskPrioScheduleCfgSize; indx++)
    {
        osRdyNofifoBuf = osTaskPrioScheduleCfg[indx].osRdyNofifoBuf;
        prio_number = osTaskPrioScheduleCfg[indx].prio_number;

        if(OS_isScheduleExistTask(osRdyNofifoBuf))
        {
            priority += OS_PRIO_VAL_LEVEL(prio_number);
        }
    }

    return priority;
}

  • 任务调度表与优先级调度表的配置

/*********************************************
 *          OS Task Ready FIFO Config 
 *********************************************/
OS_RdyNoFifo_t OsRdyFifoLv1 = {0};
OS_RdyNoFifo_t OsRdyFifoLv2 = {0};

/***********************************************************************
 *           OS Task Schedule Config (include priority level)
 ***********************************************************************/
OS_TASK_SCHEDULE_t osTaskScheduCfg_Lv1[] = 
{   
    /* number           taskFunc     task_type           task_switch      os_task_status     task_tickCnt    task_tickInit */
    {OS_TASK_NO1,       os_task1,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        0,              100               },
    {OS_TASK_NO2,       os_task2,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        1,              100               },
    {OS_TASK_NO3,       os_task3,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        2,              100               },
};

OS_TASK_SCHEDULE_t osTaskScheduCfg_Lv2[] = 
{   
    /* number           taskFunc     task_type           task_switch      os_task_status     task_tickCnt    task_tickInit */
    {OS_TASK_NO1,       os_task4,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        0,              100               },
    {OS_TASK_NO2,       os_task5,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        1,              100               },
    {OS_TASK_NO3,       os_task6,    OS_TASK_CYCLC,      OS_TASK_ON,      OS_TASK_OK,        2,              100               },
};

uint8_t osTaskScheduleCfgSize_Lv1 = sizeof(osTaskScheduCfg_Lv1) / sizeof(OS_TASK_SCHEDULE_t);
uint8_t osTaskScheduleCfgSize_Lv2 = sizeof(osTaskScheduCfg_Lv2) / sizeof(OS_TASK_SCHEDULE_t);

/***********************************************************************
 *           OS Task Priority Schedule
 ***********************************************************************/
OS_PRIO_SCHEDULE_t osTaskPrioScheduleCfg[] = 
{
    /* prio_number      osTaskScheduleCfg       osTaskScheduleCfgSize            osRdyNofifoBuf */
    {OS_PRIO_LEVEL_1,   &osTaskScheduCfg_Lv1,   &osTaskScheduleCfgSize_Lv1,      &OsRdyFifoLv1},
    {OS_PRIO_LEVEL_2,   &osTaskScheduCfg_Lv2,   &osTaskScheduleCfgSize_Lv2,      &OsRdyFifoLv2},
};

uint8_t osTaskPrioScheduleCfgSize = sizeof(osTaskPrioScheduleCfg) / sizeof(OS_PRIO_SCHEDULE_t);

（2）时间片轮询处理函数的修改

时间片轮询处理函仅做少数改动，遍历整张优先级表的同时，将Ready的任务Push到任务就绪队列中。

void OS_TmrIsrTask(void)
{
    uint8_t indx, taskCfgSize, task_i;
    OS_TASK_SCHEDULE_t * osTaskScheduleCfg;
    OS_RdyNoFifo_t * osRdyFifo;

    OS_DISABLE_INTERRUPT();
    for(indx = 0; indx < osTaskPrioScheduleCfgSize; indx++)
    {
        osTaskScheduleCfg = osTaskPrioScheduleCfg[indx].osTaskScheduleCfg;
        taskCfgSize = *osTaskPrioScheduleCfg[indx].osTaskScheduleCfgSize;
        osRdyFifo = osTaskPrioScheduleCfg[indx].osRdyNofifoBuf;

        for(task_i = 0; task_i < taskCfgSize; task_i++)
        {
            if(osTaskScheduleCfg[task_i].os_task_switch == OS_TASK_ON &&\
               osTaskScheduleCfg[task_i].os_task_status != OS_TASK_READY)
            {
                if(osTaskScheduleCfg[task_i].os_task_tickCnt > 0)
                {
                    osTaskScheduleCfg[task_i].os_task_tickCnt--;
                }

                if(osTaskScheduleCfg[task_i].os_task_tickCnt == 0)
                {
                    osTaskScheduleCfg[task_i].os_task_status = OS_TASK_READY;

                    if(OS_PushRdyTask(osRdyFifo, osTaskScheduleCfg[task_i].os_task_number) != OS_FIFO_OK)
                    {
                        /* push error dispose */
                    }

                    switch(osTaskScheduleCfg[task_i].os_task_type)
                    {
                        case OS_TASK_CYCLC:
                        {
                            osTaskScheduleCfg[task_i].os_task_tickCnt = osTaskScheduleCfg[task_i].os_task_tickInit;
                            break;
                        }
                        case OS_TASK_EVENT:
                        {
                            break;
                        }
                    }


                }
                    
            }

        }

    }
    OS_ENABLE_INTERRUPT();

}

（3）任务调度函数的修改

任务调度函数则需要先计算优先级，看优先处理哪一张任务调度表，再去从对应优先级的任务就绪队列中Pop出任务编号，然后执行对应任务。

static void OS_StartPrioSchedule(uint8_t prio_number)
{
    uint8_t prio_i, task_i;
    uint8_t task_number, osTaskScheduleCfgSize;
    OS_TASK_SCHEDULE_t * osTaskScheduleCfg;
    OS_RdyNoFifo_t * osRdyFifo;

    OS_DISABLE_INTERRUPT();

    osTaskScheduleCfg = osTaskPrioScheduleCfg[prio_number].osTaskScheduleCfg;
    osTaskScheduleCfgSize = *osTaskPrioScheduleCfg[prio_number].osTaskScheduleCfgSize;
    osRdyFifo = osTaskPrioScheduleCfg[prio_number].osRdyNofifoBuf;

    if(OS_PopRdyTask(osRdyFifo, &task_number) == OS_FIFO_OK)
    {
        switch(osTaskScheduleCfg[task_number].os_task_status)
        {
            case OS_TASK_OK:
            {
                break;
            }
            case OS_TASK_ERROR:
            {
                break;
            }
            case OS_TASK_READY:
            {
                osTaskScheduleCfg[task_number].os_task_status = osTaskScheduleCfg[task_number].taskFunc();
                if(osTaskScheduleCfg[task_number].os_task_type == OS_TASK_EVENT)
                {
                    osTaskScheduleCfg[task_number].os_task_switch = OS_TASK_OFF;
                }
                break;
            }
        }
    }
    OS_ENABLE_INTERRUPT();
}



void OS_StartSchedule(void)
{
    uint8_t indx;
    uint8_t priority;
    uint8_t task_number;

    for(;;)
    {
        /* Calculate the Schedule Priority */
        priority = OS_SchedulePrioCal();
        if(priority >= OS_PRIO_VAL_LEVEL_1)
        {
            OS_StartPrioSchedule(OS_PRIO_LEVEL_1);
        }
        else if(priority >= OS_PRIO_VAL_LEVEL_2)
        {
            OS_StartPrioSchedule(OS_PRIO_LEVEL_2);
        }
    }   
}
不吃鱼的猫丿
关注
  • 12
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
单片机 程序架构 时间片轮询. 时间片轮询..pdf
01-02
单片机 程序架构 时间片轮询.
单片机的程序架构——时间片轮询【学习笔记】
热门推荐
YU的博客
10-03 1万+
单片机的程序架构1.顺序执行2.时间片轮寻：==2.0 一个定时器的复用：====2.1 时间片轮询架构：====2.2 具体实现：==2.2.1定义 任务结构体2.2.2初始化 任务结构体2.2.3定义 任务清单&任务数目 枚举类型2.2.4编写 定时器中断函数&任务处理函数2.2.5编写main函数2.2.6编写你的任务函数==2.3 注意点&C语言补坑：==3.操作系统： 1.顺序执行 /*****************************************
单片机程序架构-时间片轮询架构
我的博客
03-01 576
Description : 任务结构体* attention : 它包含了一个任务所需要的所有信息;* 1:运行状态标志位:0-不运行;1-运行。* 2:计数器TimerCountdown--* 3:计数器数值填充器,预设的初值:TimerInitialValue(任务运行间隔时间)* 4:任务对应的函数指针// 程序运行的标记：0-不运行、1-运行// 计数器// 任务运行间隔时间// 要运行的任务函数// 任务定义// 任务清单。
时间片轮询法
weixin_34342992的博客
12-23 716
时间片轮询法 时间片轮询法是一种比较简单易用的系统架构之一，它对于系统中的任务调度算法是分时处理。核心思路是把 CPU 的时间分时给各个任务使用。我们常用的定时方法是定时器，把调度器放在定时中，可以简单的实现时间片轮询法。 需要注意的是，这种方法的前提是执行的 每个任务都是短小精悍的，要不然一个任务执行的时间过长，大于其它任务设置的时间片值，那其它任务就无法保证按它预设的时间片来执行。 尤其需要注...
一种裸机多任务实现方法--时间片轮询
Damon_Sandy的博客
03-20 1158
多任务，裸机
时间片轮询系统学习
qq_44711012的博客
03-13 3399
时间片轮询 所谓时间片轮询就是将时间分时，分别分配给不同的任务去执行任务，这个被任务分走的时间就叫做时间片。 时间片轮询系统中很重要的一点就是时间片的长度，当时间片的长度过小时，例如设置为20ms，因为在任务切换时，需要保存上下文，这个是需要花费时间的，假设花费为5ms，此时CPU20%（5/20+5）的时间花浪费在了管理开销上（网上查的，这里还不太明白为什么会说这是浪费？这个不是必须存在的吗？无论时间片的长度长还是短，这不是都得存在的？如果有知道的人可以指导一下，后续更新） 当时间片设置为500ms，这个
单片机程序架构之----时间片轮询法
120097046的博客
02-14 4091
我们在编写单片机代码时，常用的方法是根据各个模块的功能函数顺序执行，这种方法对于应用程序简单，实时性不高的场合比较实用。但对于一些对每个功能模块执行响应不同的系统来说，顺序执行就不能完成任务，例如一个系统中有液晶，按键，串口，液晶每500ms 执行一次，按键使用查询方式100ms查询一次，每秒响应一次秒事件执行,其余时间休眠。这个时候使用一个硬件定时器每隔50ms中断一次，中断唤醒后快速查询各个模块的执行标志，需要运行的，执行一次。没有则进入休眠。 如何构造这个代码： 1. 初始化一个硬件定时间，间隔5
嵌入式系统：时间片轮询框架
weixin_45366970的博客
08-18 887
嵌入式系统：时间片轮询框架
STM32裸机-时间片任务轮询
weixin_44843021的博客
06-03 5303
-待写-_-
单片机程序架构详解篇_时间片轮询.pdf
04-28
19年找到的这份资料，找到的过程异常艰辛，是一位老工程师总结的，我又加了一些注解，希望能帮助到大家~
单片机与DSP中的时间片轮转算法在单片机程序设计中的应用
12-10
摘要：提出一种采用时间片轮转算法改进单片机系统程序设计，实现多任务机制的软件设计方法，并给出了在MCS-51分级分布式系统中应用该算法进行程序设计的实例。  关键词：时间片 多任务机制 单片机系统 传统的单...
时间片轮转算法在单片机程序设计中的应用
08-02
提出一种采用时间片轮转算法改进单片机系统程序设计，实现多任务机制的软件设计方法，并给出了在MCS-51分级分布式系统中应用该算法进行程序设计的实例。
时间片轮调的单片机程序结构
08-10
我们使用单片机去做一些任务的时候，通常把程序写成顺序结构，基本可以解决大部分的设计要求了。而且这种结构便于理解，而且程序易构成模块化，在各个模块中调用实现更复杂的任务。
node-v9.6.0-x86.msi
04-29
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
Python基于机器学习的分布式系统故障诊断系统源代码，分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别
04-29
基于技术手段（包括但不限于机器学习、深度学习等技术）对分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别，实现分布式系统故障运维的智能化，快速恢复故障的同时大大降低分布式系统运维工作的难度，减少运维对人力资源的消耗。在分布式系统中某个节点发生故障时，故障会沿着分布式系统的拓扑结构进行传播，造成自身节点及其邻接节点相关的KPI指标和发生大量日志异常
JavaScript前端开发的核心语言前端开发的核心语言
最新发布
04-29
javascript 当今互联网时代，JavaScript已经成为了前端开发的核心语言它是一种高级程序设计语言，通常用于网页的交互和动态效果的实现。JavaScript的灵活性以及广泛的使用使得它变得异常重要，能够为用户带来更好的用户体验。 JavaScript的特点之一是它的轻量级，它可以在网页中运行无需单独的编译或下载。这意味着网页可以更快地加载并且用户无需安装额外的软件才能运行网页上的JavaScript代码。此外，与HTML和CSS紧密结合，可以直接在HTML文档中嵌入，使得网页的开发变得非常便捷。 JavaScript具有动态性，它可以在浏览器中实时修改页面内容和样。它可以通过操作DOM（文档对象模型来动态地修改网页的结构和布局，并且可以根据用户的行为实时地响应各种事件，如点击、标悬停、滚动等。这使得开发者可以轻松地为网页添加交互性和动态效果，提供更好的用户体验。 JavaScript也是一种面向对象的语言。它支持对象、类、继承、多态等面向对象编程的概念，使得代码结构更加清晰和可维护。开发者可以创建自定义的对象和方法，对功能进行封装和复用，提高代码的可读性和可维护性。
四则运算自动生成程序安装包
04-29
四则运算自动生成程序安装包
为我的单片机写一个时间片轮询代码
05-15
好的，以下是一个简单的时间片轮询代码，使用定时器中断来实现： ```c #include <avr/io.h> #include <avr/interrupt.h> #define TIME_SLICE_MS 10 volatile uint32_t ms_counter = 0; volatile uint8_t task_flag = 0; ISR(TIMER0_COMPA_vect) { ms_counter += TIME_SLICE_MS; task_flag = 1; } void init_timer() { TCCR0A |= (1 << WGM01); // CTC mode TCCR0B |= (1 << CS02) | (1 << CS00); // prescaler = 1024 OCR0A = (F_CPU / 1024 / 1000 * TIME_SLICE_MS) - 1; // compare value TIMSK0 |= (1 << OCIE0A); // enable interrupt } void main() { init_timer(); sei(); // enable global interrupt while (1) { if (task_flag) { task_flag = 0; // 执行任务代码 } } } ``` 该代码使用了 AVR 单片机的定时器0来实现时间片轮询，每隔 10ms 触发一次中断，并在中断服务函数中累加 `ms_counter` 变量，表示已经经过的毫秒数。在主循环中，检查 `task_flag` 是否为1，表示时间片已经到达，此时执行相应的任务代码，并清除 `task_flag` 标志。因为该代码使用了定时器中断，所以需要在 `main()` 函数中开启全局中断。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不吃鱼的猫丿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值