基于单片机的多任务轮询系统

最新推荐文章于 2024-07-01 11:16:57 发布
最新推荐文章于 2024-07-01 11:16:57 发布
阅读量839 收藏 14
点赞数 1
分类专栏： 嵌入式 文章标签： 单片机 实时操作系统 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huazidianzi/article/details/113808138
版权
本文介绍了一个基于时间片轮询的时间片轮询系统，通过配置文件sch_chg.h、schedule.h和源码schedule.c实现。系统支持任务创建、任务初始化、任务调用，并提供了延时、信号量和邮箱等机制。应用示例展示了如何在STM32F103单片机上使用该调度器，通过定时器中断驱动任务轮询。
摘要由CSDN通过智能技术生成

Schedule

时间片轮询系统

通过时间片的划分，可以利用一个定时器或者系统滴答定时器，通过多任务轮询方法，实现一个多任务的基于时间轮询调度的系统——Schedule.

版权声明

本文展示的源码为网络上所获取的资源，如有侵权，请告知删除。
此处仅为交流学习使用。

文件结构

有三个文件构成，两个h文件一个c文件。
sch_chg.h 类型定义文件
schedule.c 源码实现
shcedule.h 宏定义和配置文件

源码

sch_chg.h

#ifndef __SCH_CFG_H_
#define __SCH_CFG_H_


//定义可裁剪部分
#define SCH_CFG_Q_EN            1u            /*       任务内建消息使能        */
#define SCH_MAX_TASKS           4             /*  最大任务数量可以增加最大255个*/


#define SCH_MBOX_EN             1    	     /* Enable (1) or Disable (0) 邮箱*/
#define SCH_TICKS_PER_SEC       1000         /* 1秒钟多少个系统时钟数         */
/*------------------------------------------------------------------------------
*                       与编译器相关数据类型定义 
*-----------------------------------------------------------------------------*/
typedef unsigned char   BOOLEAN;
typedef unsigned char   INT8U;                 /* Unsigned  8 bit quantity */
typedef signed   char   INT8S;                 /* Signed    8 bit quantity */
typedef unsigned short  INT16U;                /* Unsigned 16 bit quantity */
typedef signed   short  INT16S;                /* Signed   16 bit quantity */
typedef unsigned int    INT32U;                /* Unsigned 32 bit quantity */
typedef signed   int    INT32S;                /* Signed   32 bit quantity */
typedef float            FP32;           /* Single precision floating point */
typedef double           FP64;           /* Double precision floating point */
typedef unsigned int    SCH_TICKS;             //定义延时时钟数据类型

//定义数据类型
typedef unsigned char  SCH_UINT8;

typedef unsigned int   SCH_UINT16;
#endif

schedule.h

#ifndef __SCHEDULE_H
#define __SCHEDULE_H

#ifdef __cplusplus
extern "C" {
#endif

/*------------------------------------------------------------------------------
                             schedule 版本号
------------------------------------------------------------------------------*/

#define  SCH_VERSION                 02200u              

/*------------------------------------------------------------------------------
*                            包含头文件
------------------------------------------------------------------------------*/

#include "sch_cfg.h"
    
#ifndef  SCH_GLOBALS
#define  SCH_EXT  extern
#else
#define  SCH_EXT
#endif
/*------------------------------------------------------------------------------
*                         系统状态定义
------------------------------------------------------------------------------*/
#define SCH_DLY_TYPE 	            SCH_UINT16
#define SCH_ERR_NONE                     0u
#define SCH_ERR_TIMEOUT                 10u
#define SCH_TASK_RUN		             0
#define SCH_TASK_PEND		       (SCH_DLY_TYPE)0xffff

#if	SCH_MAX_TASKS <= 255
  #define SCH_MAX_TASK_TYPE	  SCH_UINT8	      //最大任务数<=255时定义为u8
#else
  #define SCH_MAX_TASK_TYPE	  SCH_UINT16	  //最大任务为>255则定义为u16
#endif
/*------------------------------------------------------------------------------
*                           数据结构定义
------------------------------------------------------------------------------*/
typedef struct 
{					
	SCH_TICKS		TaskDly;
    /*延时数据*/
	INT8U			SubExitFlag;
    /*这个是什么？*/
#if SCH_CFG_Q_EN > 0u
    void          *pData;      
    /*队列指针*/
    SCH_UINT8 	    Size;      
    /*消息的长度*/
#endif

}SCH_TCB;

/*----------------------------------------------------------------------------*/
/*----------------------------邮箱数据类型定义--------------------------------*/
typedef struct 
{					
  
	SCH_TICKS Dly;
    /*延时量*/
    
	void *pMbox;
    /*邮箱的指针*/
    
} MBOX;
typedef SCH_TICKS	SEM;			//信号量数据类型定义

/*------------------------------------------------------------------------------
*                                全局变量定义
------------------------------------------------------------------------------*/

SCH_EXT SCH_TCB 	TaskTcb[SCH_MAX_TASKS];			
//任务状态数据结构

SCH_EXT INT8U		CurRunTaskId;					
    //当前运行任务的ID号
/*----------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
                                 任务相关宏
【1】任务创建按实例创建：
void Task_xxx(void)
{
	SCH_TaskBegin();
	while(1) {
		//用户代码
		SCH_TimeDly(SCH_TICKS_PER_SEC/100);		//根据任务实际周期进行延时
	}
	SCH_TaskEnd();
}
【注意】
	1，任务必须是无限循环，不能返回；
	2，任务中必须有延时函数或等待信号量，便于任务出让CPU使用权；
	3，任务函数中使用的非静态局部变量会在任务出让CPU后，
       变量消失，因此要想某个变量不消失，则要使用静态变量

【2】任务调度，按以下实例
SCH_TaskRun(Task_xxx,0);
【注意】
	1，各任务的ID不能相同
------------------------------------------------------------------------------*/

//@任务开始宏在任务函数的变量声明后引用
#define SCH_TaskBegin()	static INT16U _lc=0u; switch(_lc){case 0: 
						
//@任务结束宏在任务尾引用
#define SCH_TaskEnd() }				

//@任务调用宏在主循环中调用
//@ TaskName:任务名
//@ TaskID：任务ID，最大值不能超过"SCH_MAX_TASKS"值,且每个任务的ID不能相同
#define SCH_TaskRun(TaskName,TaskID) \
    do { \
		CurRunTaskId = TaskID; \
        if(TaskTcb[CurRunTaskId].TaskDly==0u) { \
            TaskName(); \
        } \
    } while(0); 
/*----------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
                                  子任务相关宏
--------------------------------------------------------------------------------    
【1】子任务创建按实例创建：
void SubTask_xxx(void)
{
	SCH_SubTaskBegin();
	//用户代码
	SCH_TimeDly(SCH_TICKS_PER_SEC/100);		//根据任务实际周期进行延时
	SCH_SubTaskEnd();
}
【注意】
	1，子任务不可以是无限循环，否则子任务后面程序无法执行；
	2，子任务可以带参数,但是不能返回；
	3，子任务中必须有延时函数或等待信号量，便于任务出让CPU使用权；
	4，子任务函数中使用的非静态局部变量会在任务出让CPU后，变量消失，
       因此要想某个变量不消失，则要使用静态变量

【2】子任务调度，按以下实例
	SCH_CallSubTask(SubTask_xxx());
------------------------------------------------------------------------------*/

//@子任务开始宏，在子任务函数的变量声明后引用
#define SCH_SubTaskBegin() static INT16U _lc=0u;switch(_lc){case 0: 
	
//@子任务结束宏，在子任务函数尾引用
#define SCH_SubTaskEnd() }_lc=0u;TaskTcb[CurRunTaskId].SubExitFlag=0u;return

//@子任务调用宏，在任务中调用，允许多层嵌套
//@ SubTaskName:子任务名
//@ p_arg：子线程函数输入参数
#define SCH_CallSubTask(SubTaskFun)	\
	TaskTcb[CurRunTaskId].SubExitFlag=1u; \
	while(1) { \
		_lc=(__LINE__%65535);return;case(__LINE__%65535): { \
			SubTaskFun; \
		} \
		if(TaskTcb[CurRunTaskId].SubExitFlag==0u) { \
			break; \
		} \
	} 
	
/*------------------------------------------------------------------------------
*                                延时宏定义
------------------------------------------------------------------------------*/

//@延时宏，在任务开始宏和结束宏之间的任意位置引用;
//@【注】由于此调度器运用了C语言的行号的宏代码，
//@    因此此宏定义最好放在一行代码中，不能拆分此宏定义，防止行号返回出错
//@ ticks：延时时间
#define SCH_TimeDly(ticks) 	do{_lc=(__LINE__%65535);TaskTcb[CurRunTaskId].TaskDly=ticks;TaskTcb[CurRunTaskId].SubExitFlag=1u;return;}while(0);case (__LINE__%65535):

/*------------------------------------------------------------------------------
                             信号量相关调用宏定义
------------------------------------------------------------------------------*/
//@信号量创建
#define SCH_SemCreate(Sem) Sem = 1u

//@w信号量等待
//@	sem--等待信号量;
//@	timeout--等待超时时间,0--直到成功等待信号量;
//@	err--等待信号状态，SCH_ERR_NONE-等待成功，SCH_ERR_TIMEOUT-等待超时
#define SCH_SemPend(sem,timeout,err) \
    do { \
		if(sem==0u) { \
			sem = 1u; \
			err = SCH_ERR_NONE; \
		} else { \
			sem = timeout + 1u; \
			SCH_TimeDly(0u); \
			if(timeout==0u) { \
				if(sem>0u) { \
					TaskTcb[CurRunTaskId].TaskDly = 0u; \
					return; \
				} \
				sem = 1u; \
				err = SCH_ERR_NONE; \
			} else { \
				if(sem>1u) { \
					sem --; \
					TaskTcb[CurRunTaskId].TaskDly = 1u; \
					return; \
				} else if(sem==1u) { \
					err = SCH_ERR_TIMEOUT; \
				} else { \
					sem = 1u; \
					err = SCH_ERR_NONE; \
				} \
			} \
		} \
    } while(0) 

//@ 发出一个信号量
#define SCH_SemPost(Sem) \
    do { \
        Sem = 0u; \
    } while(0)
     
/*------------------------------------------------------------------------------
                              邮箱相关调用宏定义
------------------------------------------------------------------------------*/
#if SCH_MBOX_EN > 0u
	
//@创建邮箱
#define SCH_MboxCreate(mbox) \
	do { \
		mbox.Dly = 1u; \
		mbox.pMbox = (void*)0; \
	} while(0)

//@ 邮箱等待
//@	mbox--等待邮箱;
//@ pmsg--等待成功后接收邮箱数据指针;
//@	timeout--等待邮箱超时时间,0--直到成功等待邮箱;
//@	err--等待邮箱状态，SCH_ERR_NONE-等待成功，SCH_ERR_TIMEOUT-等待超时
#define SCH_MboxPend(mbox,pmsg,timeout,err) \
    do { \
		if(mbox.pMbox!=(void*)0) { \
			pmsg = mbox.pMbox; \
			mbox.pMbox = (void*)0; \
			err = SCH_ERR_NONE; \
		} else { \
			mbox.Dly = timeout + 1u; \
			SCH_TimeDly(0); \
			if(timeout==0u) { \
				if(mbox.pMbox==(void*)0) { \
					TaskTcb[CurRunTaskId].TaskDly = 0u; \
					return; \
				} \
				pmsg = mbox.pMbox; \
				mbox.pMbox = (void*)0; \
				err = SCH_ERR_NONE; \
			} else { \
				if(mbox.pMbox!=(void*)0) { \
					pmsg = mbox.pMbox; \
					mbox.pMbox = (void*)0; \
					err = SCH_ERR_NONE; \
				} else { \
					if(mbox.Dly>1u) { \
						mbox.Dly --; \
						TaskTcb[CurRunTaskId].TaskDly = 1u; \
						return; \
					} else if(mbox.Dly==1u) { \
						pmsg = (void*)0; \
						mbox.pMbox = (void*)0; \
						err = SCH_ERR_TIMEOUT; \
					} \
				} \
			} \
		} \
    } while(0) 

//@ 发出一个邮箱
#define SCH_MboxPost(mbox,pmsg) \
    do { \
        mbox.Dly = 0u; \
		mbox.pMbox = (void*)pmsg; \
    } while(0)
	
#endif 
/*------------------------------------------------------------------------------
                             操作指定任务,不常用      
------------------------------------------------------------------------------*/
//挂起（暂停）指定任务
#define SCHTaskPend(TaskPendTCB)      TaskPendTCB.TimeCounter = SCH_TASK_PEND

//恢复指定任务（运行）
#define SCHTaskResume(TaskResumeTCB)  TaskResumeTCB.TimeCounter = SCH_TASK_RUN

//指定任务延时X个时间节拍后恢复
#define SCHTaskDly(TaskDlyTCB, Ticks) TaskDlyTCB.TimeCounter = Ticks

/*------------------------------------------------------------------------------
                             消息队列功能实现 
------------------------------------------------------------------------------*/      
#if SCH_CFG_Q_EN > 0u

#define SCH_Q_FREE  1
#define SCH_Q_BUSY  0

//等待消息
#define SCHTaskQpend() {_lc=(__LINE__%65535);pCurTCB->TaskDly = SCH_TASK_PEND;pCurTCB->pData=(void *)0;pCurTCB->Size=0;}return;case (__LINE__%65535):

//释放消息
#define SCHTaskQpost(PostTCB, pDat, Len)  PostTCB.pData = pDat; PostTCB.Size = Len; PostTCB.TaskDly = SCH_TASK_RUN
                        
//查询消息列队状态,是否是自由(可用)或忙(不可用),
//调用SCHTaskQpend()时会将其设置为自由状态
#define SCHTaskGetQFree(TaskTCB, RetStatus)  RetStatus = SCH_Q_BUSY; if (TaskTCB.TaskDly == SCH_TASK_PEND){RetStatus = SCH_Q_FREE;}
#endif
//------------------------------------------------------------------------------


/*------------------------------------------------------------------------------
                                外部变量声明
------------------------------------------------------------------------------*/
extern SCH_TCB   *pCurTCB;	
/*------------------------------------------------------------------------------
                                  函数申明
------------------------------------------------------------------------------*/
void SCH_Init(void);
void SCH_TimeTick(void);

#ifdef __cplusplus
}
#endif

#endif

shcedule.c

#define  SCH_GLOBALS

#include  "schedule.h"

SCH_TCB  *pCurTCB;

/*------------------------------------------------------------------------------
** 函数名:	SCH_Init
** 输  入:	无
** 输  出:	无
** 功能说明：调度器初始化函数，任务运行前调用
**----------------------------------------------------------------------------*/
void SCH_Init(void)	
{ 
	INT8U i; 
	
	CurRunTaskId = 0;
    
	for(i=SCH_MAX_TASKS;i>0;i--) 
    { 
		TaskTcb[i-1].TaskDly = 0; 
		
        TaskTcb[i-1].SubExitFlag = 0;
	} 
}
/*------------------------------------------------------------------------------
** 函数名:	SCH_TimeTick
** 输  入:	无
** 输  出:	无
** 功能说明：调度器时钟节拍函数，在定时中断中调用
**----------------------------------------------------------------------------*/
void SCH_TimeTick(void)	
{ 
	INT8U i; 
	for(i=SCH_MAX_TASKS;i>0;i--) 
    {       
        if(TaskTcb[i-1].TaskDly>0) 
        {     
            //任务延时时间处理
            TaskTcb[i-1].TaskDly --; 
        } 
	} 
}
/*-----------------------------End Of File------------------------------------*/

具体代码就不再解释，可以结合源码注释自行研究理解。

应用

基于STM32F103系列单片机，展示实际应用。

包含头文件

schedule.h

定时器调用

定时器调用任务轮询函数

/*
定时器可设置为10ms周期，或其他
*/
void TIM2_IRQHandler(void)
{ 		    		  			    
	TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    SCH_TimeTick(); 
}

创建任务

/*******************************************************************************
 * 函数名称：Thread_InitMain
 * 函数功能：主线程
 * 入口参数：无
 * 返 回 值：无
 * 其他说明：无
*******************************************************************************/
void Thread_InitMain(void)
{
    SCH_TaskBegin(); //注意这里
    while(1) //注意这是死循环
    {
        SCH_TimeDly(150); //这是这个任务的演示函数，单位为定时器定时周期，如果
        					//如果定时器定时周期为10ms，则此处延时为150*10
    }
    SCH_TaskEnd(); //注意这里
}
/*******************************************************************************
 * 函数名称：Thread_Menu
 * 函数功能：菜单线程
 * 入口参数：无
 * 返 回 值：无
 * 其他说明：无
*******************************************************************************/
void Thread_Menu(void)
{
    SCH_TaskBegin();
    while(1)
    {
        KeyValue = Scan_key();
        if(KeyValue.key != 0)
        {
            QueuePushIn(&KeyValue.key, 1);
        } 
        Menu();
        SCH_TimeDly(100);
    }
    SCH_TaskEnd();
}
/*******************************************************************************

任务初始化

	SCH_Init(); //注意这里哦，先初始化
    Time2_Init(); //注意这里哦，再初始化
    
    //SEGGER_RTT_Init();
    
    Init_V9203();                 //初始化V9203
    UserData_Init();
    InitQueue(&stQueue);
    
    ClearScreen();
    DisplayFrequency = DISPLAY_FREQUENCY;
    while (1)
    {	
        SCH_TaskRun(Thread_InitMain, 0);
        SCH_TaskRun(Thread_Menu,    1);     
    }

任务调用

int main(void)
{

    SCH_Init();
    Time2_Init();
    while (1)
    {	
        SCH_TaskRun(Thread_InitMain, 0);  //这里入口参数的第二个参数为任务id，
        //id不能重复
        SCH_TaskRun(Thread_Menu,    1);     
    }
}

Schedule资源下载

别具匠心
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单片机中断方式与轮询方式 单片机中断方式与轮询方式
04-02
单片机中断方式与轮询方式 单片机中断方式与轮询方式
单片机裸机开发之“时间片轮询架构”去实现“多任务”
m0_52596850的博客
09-09 3106
单片机多任务，时间片轮询
单片机简单裸机任务调度
最新发布
m0_56306118的博客
07-01 582
时间片函数要在滴答定时器中断中运行，但这个函数是在应用层的，不能直接写在硬件层，所有需要一个回调函数，调用此函数运行。写一个每次1ms中断一次的定时器中断。在此中断函数里面调用。在mian中调用注册。
单片机中基于时间片的多任务的实现
HQ1356466973的博客
12-14 1万+
本博文基于STM32F103系列实现了类似时间片的多任务执行机制，可以在硬件资源（定时器）比较紧张的情况下，既可以实现多路应用，也可以提高应用的实时性（时间片够细，够短）。
单片机裸机程序框架之轮询方式
z717551460的博客
03-03 3920
单片机裸机程序框架之轮询方式轮询方式最基础的轮询方式带时间片的轮询方式带状态机的轮询方式时间片加状态机的轮询方式 轮询方式 最基础的轮询方式 程序例子： 这种是最基础的程序框架，优点是结构简单顺序执行，便于理解，开发成本低。缺点是程序顺序执行会造成对接收信息的处理不及时，造成实时性太差。适用场景在于，不需要处理外界信息的循环动作，或者接收信息后的一次性动作。 带时间片的轮询方式 #include "main.h" #include "driver_led.h" static int32_t time1_f
工作经验总结：单片机中简易时间片轮询的结构设计
不吃鱼的猫的博客
05-22 4843
裸机：功能单一，简单的顺序执行时间片轮询：多任务、内存占用较少RTOS：多任务、系统复杂性高，有较高的实时性要求和可靠性要求MCU的RAM和ROM资源问题，引入RTOS会带来额外的内存开销业务功能的拆解与多任务的设计，有时候使用时间片轮询可以让整个结构更加简单易懂，方便设计调试更为简单方便功能任务划分的合理性，多任务的情况下，每个任务的执行都尽量设计成短小精悍。（例如：执行1个任务需要10ms，你不能只给它分配5ms的时间片）
51单片机多任务程序例程
08-30
在本文中，我们将深入探讨"51单片机多任务程序例程"这一主题，它主要涉及51系列单片机、多任务处理、系统设计以及51定时器的使用。51单片机因其简单易用和成本效益高而广泛应用于各种嵌入式系统中。实现多任务在...
基于51单片机写的一个多任务切换的简易OS
07-22
在提供的"简易os"压缩包中，可能包含了源代码、头文件和其他相关文档，读者可以通过阅读和分析这些文件，进一步了解51单片机多任务切换的实现细节。这是一个极好的实践案例，对于提升单片机编程和操作系统设计的理解...
基于51单片机的多功能时钟
03-25
总结，基于51单片机的多功能时钟设计涉及了硬件接口、数据处理、定时控制等多个方面，通过合理地利用51单片机的资源，实现了数字显示、键盘交互、定时报警等多种功能，充分展示了51单片机在嵌入式系统中的强大应用...
基于PIC单片机串行轮询通信的相控阵雷达发射机监控设计.pdf
07-12
PIC单片机是一种广泛应用于嵌入式系统的微控制器，它具备良好的性能和较小的尺寸，非常适合于复杂系统的控制任务。PIC单片机可以通过串行通信与外部设备进行数据交换。在相控阵雷达发射机监控系统中，PIC单片机被...
基于实时操作系统的单片机多任务应用程序设计
06-26
在本文中，我们将深入探讨基于实时操作系统的单片机多任务应用程序设计，特别是关注μC/OS-Ⅱ和Small RTOS这两个实时操作系统。实时操作系统（RTOS）在嵌入式系统中扮演着至关重要的角色，因为它们能确保关键任务的...
单片机程序架构-时间片轮询架构
我的博客
03-01 1370
Description : 任务结构体* attention : 它包含了一个任务所需要的所有信息;* 1:运行状态标志位:0-不运行;1-运行。* 2:计数器TimerCountdown--* 3:计数器数值填充器,预设的初值:TimerInitialValue(任务运行间隔时间)* 4:任务对应的函数指针// 程序运行的标记：0-不运行、1-运行// 计数器// 任务运行间隔时间// 要运行的任务函数// 任务定义// 任务清单。
单片机的时间轮询
baidu_41787367的博客
02-23 791
单片机的时间片轮 概括：利用定时器，让单片机在需要延迟的等待的状态下（按键检测消抖），依然执行接下来的程序。 步骤：1.设置定时器中断->设置定时时间片（2ms，5ms，500ms）。
单片机轮询任务
Never say never
07-28 1714
【代码】单片机轮询任务。
浅谈单片机应用程序架构
dingjunwen2010的专栏
02-20 1560
前段时间在使用MSP430做项目时考虑说在单片机中如果有多个任务的话如何进行处理才能保证单片机的工作效率以及每个任务完成的及时性，在电子工程社区中看见下面一片文章，和大家一起分享！ 1. 顺序执行法：          这种方法，这应用程序比较简单，实时性，并行性要求不太高的情况下是不错的方法，程序设计简单，思路比较清晰。但是当应用程序比较复杂的时候，如果没有一个完整的流程图
实现简单的多任务轮询（C语言）
热门推荐
xuesong10210的博客
11-07 2万+
实现简单的多任务轮询（C语言）前言总体思路实现过程调用示例完整代码 前言 好久没有做MCU的项目了，最近因为工作需要接手一个STM32的项目，因为项目要求比较简单，也就没有用到操作系统，而是用了简单的状态机+任务轮询的方式。闲暇之余写下这篇简短的博客，记录一下自己的所知所想，也希望对那些刚进入MCU的新手们，能有些许的帮助。 总体思路 利用状态机的方式，在一个循环中不停的去判断每一个任务的执行标识，当判断标识为真时，则执行响应的任务，任务执行结束后及时的清除任务标识。 实现过程 先定义一个任
基于STC89C52RC 51单片机实现多任务处理
ahphong的博客
05-31 751
基于STC89C52RC 51单片机实现多任务处理
简易可移植的多任务轮询
qq_51183186的博客
07-29 334
TaskStruct时间片轮询系统文件结构源码polling.cpolling.h使用说明task_schedule（）task_process（）任务创建 时间片轮询系统 时间片轮询法是一种比较简单易用的系统架构之一，它对于系统中的任务调度算法是分时处理。核心思路是把 CPU 的时间分时给各个任务使用。我们常用的定时方法是定时器，把调度器放在定时中，可以简单的实现时间片轮询法。 需要注意的是，这种方法的前提是执行的 每个任务都是短小精悍的，要不然一个任务执行的时间过长，大于其它任务设置的时间片值，那其它任
单片机软件开发，实时系统和分时多任务，看完就懂
山上编程猿的博客
05-16 757
单片机软件开发，实时系统和分时多任务，看完你就懂了///插播一条：我自己在今年年初录制了一套还比较系统的入门单片机教程，想要的同学找我拿就行了免費的，私信我就可以哦~点我头像黑色字体加我地球呺也能领取哦。最近比较闲，带做毕设，带学生参加省级或以上比赛///说明：作者本人虽然岁数不小，但却是初入此行的新人，此篇文章只适合正在学习的准程序员，或初入行业的新人。当然如果有大牛路过，欢迎指点。单片机软件开发，如果不用实时系统的话，那么“基于时间片的分时多任务”一定是会用到的。“时间片的分时多任务”看似简单，其实还是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

别具匠心

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

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

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

打赏作者

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

抵扣说明：

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

余额充值