STM32F103xx毫秒级任务管理器、调度器(动态任务创建的方式实现)

最新推荐文章于 2024-07-24 14:53:58 发布
最新推荐文章于 2024-07-24 14:53:58 发布
阅读量634 收藏 9
点赞数
分类专栏： STM32 文章标签： stm32 链表 arm 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ceosat/article/details/126237366
版权

STM32F103xx毫秒级任务管理器、调度器(动态任务创建的方式实现

一、 任务数据类型结构体


/* 任务回调函数类型 */
typedef void(* TaskFunction)(void);

/* 字节对齐 */
#pragma pack(1)

typedef struct MsecTask
{
    TaskFunction TaskCallback;      //任务回调函数
    uint8_t  State;                 //任务状态
    uint32_t PeriodTimes;           //任务运行周期时间
    uint32_t PrevTimes;             //上次运行时间
    uint32_t CostTimes;             //花费时间
    uint32_t ErrorTimes;            //误差时间
    struct MsecTask * pNextTask;    //下一个任务
}MsecTask_Typedef, * MsecTask_Typedef_t;

二、 任务管理器数据类型结构体


typedef struct MsecTaskManager
{
    MsecTask_Typedef * pTaskHead;//任务链表头
    MsecTask_Typedef * pTaskTail;//任务链表尾


    /* 注册任务 */
    MsecTask_Typedef * (* Register)(struct MsecTaskManager * taskManager, TaskFunction taskCallback, uint32_t tims_ms, uint8_t state);

    /* 运行任务管理器 */
    void (* Running)(struct MsecTaskManager * taskManager, uint32_t tick);

    /* 设置任务运行时间 */
    uint8_t (* SetTaskPeriodTime)(struct MsecTaskManager * taskManager, TaskFunction taskCallback, uint32_t tims_ms);

    /* 获取任务状态 */
    uint8_t (* GetTaskState)(struct MsecTaskManager * taskManager, TaskFunction taskCallback);

    /* 设置任务状态 */
    uint8_t (* SetTaskState)(struct MsecTaskManager * taskManager, TaskFunction taskCallback, uint8_t state);

    /* 获取误差时间 */
    uint32_t (* GetTaskErrorTimes)(struct MsecTaskManager * taskManager, TaskFunction taskCallback);

    /* 查找任务 */
    MsecTask_Typedef * (* FindTask)(struct MsecTaskManager * taskManager, TaskFunction taskCallback);

    /* 获取上一个任务 */
    MsecTask_Typedef * (* GetPrevTask)(struct MsecTaskManager * taskManager, MsecTask_Typedef * task);

    /* 删除一个任务 */
    uint8_t (* DeleteTask)(struct MsecTaskManager * taskManager, TaskFunction taskCallback);


#if ( MTM_MCU_USE_RATIO_ENABLE > 0 )
    /* 获取处理器利用率 */
    uint8_t (* GetMicroProcessorUseRatio)(struct MsecTaskManager * taskManager);

    /* 获取任务运行的时间 */
    uint32_t (* GetTaskRunningTimes)(struct MsecTaskManager * taskManager, TaskFunction taskCallback);

    /* 所有任务运行的总时间 */
    uint32_t TaskRunTotalTimes;
#endif


}MsecTaskManager_Typedef, * MsecTaskManager_Typedef_t;

三、获取系统运行的Tick、获取时差

  1. 系统时钟72MHZ，SysTick_Handler()嘀嗒定时器1ms中断

#define SYSTICK_LOADVALUE       72000//(SystemCoreClock/1000U)
#define CYCLES_PER_MICROSECOND  72//(SystemCoreClock/1000000U)

/* 获取系统运行的Tick */
static uint32_t ulGetSystemTick(void)
{
    extern __IO uint32_t uwTick;
    return (uwTick * 1000 + (SYSTICK_LOADVALUE-SysTick->VAL)/CYCLES_PER_MICROSECOND); 
}


/* 获取时差 */
static uint32_t ulGetTickDifference(uint32_t curTick, uint32_t preTick)
{
    uint32_t diffTick = 0;

    if (curTick >= preTick)
    {
        diffTick = curTick - preTick;
    }
    else
    {
        diffTick = 0xFFFFFFFF - preTick + 1;
        diffTick += curTick;
    }

    return diffTick;
}

四、查找任务

在这里插入图片描述


/* 查找任务 */
static MsecTask_Typedef * pStuTaskManager_FindTask(struct MsecTaskManager * taskManager, TaskFunction taskCallback)
{
    MsecTask_Typedef * nowTask = NULL;
    MsecTask_Typedef * resTask = NULL;


	/* 从任务链表头部开始查找 */
    nowTask = taskManager->pTaskHead;

    while(nowTask != NULL)
    {
        /* 任务函数相同 */
        if (nowTask->TaskCallback == taskCallback)
        {
            resTask = nowTask;
            break;
        }

        /* 移动到下一个任务链表节点 */
        nowTask = nowTask->pNextTask;
    }

    return resTask;
}

五、注册任务

在这里插入图片描述

/* 注册任务 */
static MsecTask_Typedef * pStuTaskManager_Register(struct MsecTaskManager * taskManager, TaskFunction taskCallback, uint32_t tims_ms, uint8_t state)
{
    MsecTask_Typedef * task = NULL;


    /* 任务是否存在 */
    task = taskManager->FindTask(taskManager, taskCallback);

    /* 任务已存在 更新周期和状态 上次运行的时刻 */
    if (task != NULL)
    {
        task->State       = state; /* 任务状态 */
        task->PrevTimes   = ulGetSystemTick(); //上次运行的时刻
        task->PeriodTimes = tims_ms; /* 任务运行周期时间 */
		return task;
    }

    /* 任务不存在 为新任务申请内存 */
    task = (MsecTask_Typedef *)malloc(sizeof(MsecTask_Typedef));

    /* 内存申请失败 */
    if (task == NULL)
    {
        return NULL;
    }
	

    /* 初始化任务参数 */
    task->CostTimes    = 0;             //任务运行花费时间
    task->ErrorTimes   = 0;             //任务运行误差时间
    task->pNextTask    = NULL;          //从任务链表尾部插入任务
    task->State        = state;         //任务状态
    task->PeriodTimes  = tims_ms;       //任务运行周期时间
    task->TaskCallback = taskCallback;  //任务回调
    task->PrevTimes    = ulGetSystemTick(); //上次运行的时刻


    /* 任务链表为空 第一个任务为头部 */
    if (taskManager->pTaskHead == NULL)
    {
        /* 链表头部任务 */
        taskManager->pTaskHead = task;
    }
    else
    {
        /* 从任务链表尾部插入新任务 */
        taskManager->pTaskTail->pNextTask = task;
    }

    /* 更新链表尾部任务 新插入的任务作为链表尾部 */
    taskManager->pTaskTail = task;

	return task;
}

六、设置、获取任务状态


/* 设置任务状态 */
static uint8_t ubTaskManager_SetTaskState(struct MsecTaskManager * taskManager, TaskFunction taskCallback, uint8_t state)
{
    MsecTask_Typedef * memTask = NULL;

    /* 从任务链表中查找任务是否存在 */
    memTask = taskManager->FindTask(taskManager, taskCallback);
	
    /* 任务不存在*/
    if (memTask == NULL)
    {
        return 1;
    }

    /* 设置任务状态 */
	memTask->State = state;
	
	return 0;
}


/* 获取任务状态 */
static uint8_t ubTaskManager_GetTaskState(struct MsecTaskManager * taskManager, TaskFunction taskCallback)
{
    MsecTask_Typedef * memTask = NULL;
    uint8_t taskState = 0xFF;


    /* 从任务链表中查找任务是否存在 */
    memTask = taskManager->FindTask(taskManager, taskCallback);

    /* 任务不存在*/
    if (memTask == NULL)
    {
        return 1;
    }

    /* 获取任务状态 */
    taskState = memTask->State;

    return taskState;
}

七、设置任务运行周期时间


/* 设置任务运行周期时间 */
uint8_t ubTaskManager_SetTaskPeriodTime(struct MsecTaskManager * taskManager, TaskFunction taskCallback, uint32_t tims_ms)
{
    MsecTask_Typedef * memTask = NULL;

    /* 从任务链表中查找任务是否存在 */
    memTask = taskManager->FindTask(taskManager, taskCallback);

    /* 任务不存在*/
    if (memTask == NULL)
    {
        return 1;
    }

    /* 设置任务运行周期时间 */
	memTask->PeriodTimes = tims_ms;
	
	return 0;
}

八、获取任务误差时间

/* 获取任务误差时间 */
static uint32_t ulTaskManager_GetTaskErrorTimes(struct MsecTaskManager * taskManager, TaskFunction taskCallback)
{
    MsecTask_Typedef * memTask = NULL;
	uint32_t errorTimes = 0;


    /* 从任务链表中查找任务是否存在 */
    memTask = taskManager->FindTask(taskManager, taskCallback);

    /* 任务不存在*/
    if (memTask == NULL)
    {
        return 0xFFFFFFFFUL;
    }

    /* 获取任务误差时间 */
	errorTimes = memTask->ErrorTimes;
	
	return errorTimes;
}

九、获取上一个任务

/* 获取上一个任务 */
static MsecTask_Typedef * pStuTaskManager_GetPrevTask(struct MsecTaskManager * taskManager, MsecTask_Typedef * task)
{
    MsecTask_Typedef * nowTask = NULL;
    MsecTask_Typedef * resTask = NULL;

    /* 从任务链表头开始处理 */
    nowTask = taskManager->pTaskHead;

    while (1)
    {
        /* 空任务节点 */
        if (nowTask == NULL)
        {
            break;
        }

        /* 下个任务与查找的任务相同 */
        if (nowTask->pNextTask == task)
        {
            /* 当前任务为上一个任务 */
            resTask = nowTask;
            break;
        }

        /* 下一个任务节点 */
        nowTask = nowTask->pNextTask;
    }

    return resTask;
}

十、查找任务


/* 删除一个任务 */
uint8_t ubTaskManager_DeleteTask(struct MsecTaskManager * taskManager, TaskFunction taskCallback)
{
    MsecTask_Typedef * memTask  = NULL;
    MsecTask_Typedef * prevTask = NULL;
    MsecTask_Typedef * nextTask = NULL;

    /* 从任务链表中查找任务是否存在 */
    memTask = taskManager->FindTask(taskManager, taskCallback);

    /* 任务不存在*/
    if (memTask == NULL)
    {
        return 1;
    }

    /* 查找当前任务的上一个任务是否存在 */
    prevTask = taskManager->GetPrevTask(taskManager, memTask);

    /* 获取当前任务的下一个任务 */
    nextTask = memTask->pNextTask;

    if((prevTask == NULL) && (nextTask == NULL))
    {
        /* 当前任务列表只有一个任务 */
        taskManager->pTaskHead = taskManager->pTaskTail = NULL;
    }
    else if((prevTask == NULL) && (nextTask != NULL))
    {
        /* 当前任务为任务链表的头部任务 */
        taskManager->pTaskHead = nextTask;
    }
    else if((prevTask != NULL) && (nextTask == NULL))
    {
        /* 当前任务为任务链表的尾部任务 */
        taskManager->pTaskTail = prevTask;
        prevTask->pNextTask = NULL;
    }
    else if((prevTask != NULL) && (nextTask != NULL))
    {
        /*当前任务为中间任务 上一个和下一个任务都存在 */
        prevTask->pNextTask = nextTask;
    }
    else
    {
        return 2;
    }

    /* 释放任务内存 */
    free(memTask);

    memTask = NULL;

    return 0; 
}

十一、获取处理器利用率 、任务运行时间


#if ( MTM_MCU_USE_RATIO_ENABLE > 0 )

/* 获取处理器利用率 */
static uint8_t usTaskManager_GetMicroProcUseRatio(struct MsecTaskManager * taskManager)
{
    static uint32_t startTick = 0;
    uint8_t useRatio = 0;

    useRatio = taskManager->TaskRunTotalTimes / (ulGetSystemTick() - startTick);

    if (useRatio > 100)
    {
        useRatio = 100;
    }

    taskManager->TaskRunTotalTimes = 0;
    startTick = ulGetSystemTick();

    return useRatio;
}



/* 获取任务运行花费时间 */
static uint32_t ulTaskManager_GetTaskRunTimes(struct MsecTaskManager * taskManager, TaskFunction taskCallback)
{
    MsecTask_Typedef * memTask = NULL;
	uint32_t takeTimes = 0;


    /* 从任务链表中查找任务是否存在 */
    memTask = taskManager->FindTask(taskManager, taskCallback);

    /* 任务不存在*/
    if (memTask == NULL)
    {
        return 0;
    }

    /* 获取任务运行时间 */
	takeTimes = memTask->CostTimes;
	
	return takeTimes;

}
#endif

十二、运行任务管理


/* 运行任务管理 */
static void vTaskManager_Running(struct MsecTaskManager * taskManager, uint32_t tick)
{
    MsecTask_Typedef * nowTask = NULL;
    uint32_t diffTick = 0;


    /* 从任务链表头开始处理 */
    nowTask = taskManager->pTaskHead;

    while (1)
    {
        /* 任务不存在 */
        if (nowTask == NULL)
        {
            break;
        }

        /* 任务状态和任务回调有效 */
        if ((nowTask->State) && (nowTask->TaskCallback != NULL))
		{
            /* 获取时间差 */
            diffTick = ulGetTickDifference(tick, nowTask->PrevTimes);

            /* 时间差大于任务运行周期时间 */
            if (diffTick >= nowTask->PeriodTimes)
            {
                /* 保存误差时间 */
				nowTask->ErrorTimes = diffTick - nowTask->PeriodTimes;
				
                /* 记录任务运行时刻 */
                nowTask->PrevTimes = tick;

                #if ( MTM_MCU_USE_RATIO_ENABLE > 0 )

                /* 获取当前时刻 */
                uint32_t startTick = ulGetSystemTick();

                /* 运行任务回调 */
				nowTask->TaskCallback();

                /* 记录任务回调运行花费的时间 */
                nowTask->CostTimes = ulGetTickDifference(ulGetSystemTick(), startTick);
				
				/* 所有任务运行花费总时间 */
                taskManager->TaskRunTotalTimes += nowTask->CostTimes;

                #else

                /* 运行任务回调 */
				nowTask->TaskCallback();

                #endif

            }
		}

        /* 下一个任务 */
        nowTask = nowTask->pNextTask;
    }
}

十三、初始化毫秒级任务管理器


/* 初始化毫秒级任务管理器 */
void vInit_MsecTaskManager(MsecTaskManager_Typedef * taskManager)
{
    taskManager->pTaskHead = NULL;  /* 任务链表头 */
    taskManager->pTaskTail = NULL;  /* 任务链表尾 */


    taskManager->Running             = vTaskManager_Running;                /* 运行任务管理 */
    taskManager->FindTask            = pStuTaskManager_FindTask;            /* 查找任务 */
    taskManager->Register            = pStuTaskManager_Register;            /* 注册任务 */
    taskManager->DeleteTask          = ubTaskManager_DeleteTask;            /* 删除一个任务 */
    taskManager->SetTaskState        = ubTaskManager_SetTaskState;          /* 设置任务状态 */
    taskManager->GetTaskState        = ubTaskManager_GetTaskState;          /* 获取任务状态 */
    taskManager->GetPrevTask         = pStuTaskManager_GetPrevTask;         /* 获取上一个任务 */
    taskManager->GetTaskErrorTimes   = ulTaskManager_GetTaskErrorTimes;     /* 获取误差时间 */
    taskManager->SetTaskPeriodTime   = ubTaskManager_SetTaskPeriodTime;     /* 设置任务运行周期时间 */
    
	
#if ( MTM_MCU_USE_RATIO_ENABLE > 0 )
    taskManager->GetTaskRunningTimes       = ulTaskManager_GetTaskRunTimes;      /* 获取任务运行时间 */
    taskManager->GetMicroProcessorUseRatio = usTaskManager_GetMicroProcUseRatio; /* 获取处理器利用率 */
#endif
	
}

十四、验证例程

static void vTask1_Demo(void)
{
	HAL_GPIO_TogglePin(USER_LED0_GPIO_Port, USER_LED0_Pin);
}

static void vTask2_Demo(void)
{
	HAL_GPIO_TogglePin(USER_LED0_GPIO_Port, USER_LED6_Pin);
}

static void vTask3_Demo(void)
{
	HAL_GPIO_TogglePin(USER_LED0_GPIO_Port, USER_LED2_Pin);
}

static void vDebug_Demo(void)
{
	uint32_t takeTimer[3]  = {0};
	uint32_t errorTimer[3] = {0};
	
	takeTimer[0] = AppMsecTaskManager.GetTaskRunningTimes(&AppMsecTaskManager, vTask1_Demo);
	takeTimer[1] = AppMsecTaskManager.GetTaskRunningTimes(&AppMsecTaskManager, vTask2_Demo);
	takeTimer[2] = AppMsecTaskManager.GetTaskRunningTimes(&AppMsecTaskManager, vTask3_Demo);
	
	errorTimer[0] = AppMsecTaskManager.GetTaskErrorTimes(&AppMsecTaskManager, vTask1_Demo);
	errorTimer[1] = AppMsecTaskManager.GetTaskErrorTimes(&AppMsecTaskManager, vTask2_Demo);
	errorTimer[2] = AppMsecTaskManager.GetTaskErrorTimes(&AppMsecTaskManager, vTask3_Demo);
	
	printf("Name    Period    Take    Error\r\n");
	printf("Task1   %-8d  %-8d  %d\r\n", 1000, takeTimer[0] , errorTimer[0]);
	printf("Task2   %-8d  %-8d  %d\r\n", 500,  takeTimer[1] , errorTimer[1]);
	printf("Task3   %-8d  %-8d  %d\r\n", 200,  takeTimer[2] , errorTimer[2]);
}


void vRegister_Task(void)
{
    AppMsecTaskManager.Register(&AppMsecTaskManager, vTask1_Demo, 1000, 1);
    AppMsecTaskManager.Register(&AppMsecTaskManager, vTask2_Demo, 500,  1);
    AppMsecTaskManager.Register(&AppMsecTaskManager, vTask3_Demo, 2000, 1);
	
	AppMsecTaskManager.Register(&AppMsecTaskManager, vDebug_Demo, 5000, 1);
}

十五、主函数


int main(void)
{
	HAL_Init();
    SystemClock_Config();
	SystemCoreClockUpdate();

    MX_GPIO_Init();
    MX_USART1_UART_Init();
	printf("Init USART OK...\r\n");
	
	vInit_MsecTaskManager(&AppMsecTaskManager);
	printf("Msec Task Manager OK...\r\n");
	vRegister_Task();
	
    while (1)
    {
		AppMsecTaskManager.Running(&AppMsecTaskManager, HAL_GetTick());
    }
}
凌盛羽
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
STM32F103实现UCOSII 任务调度【支持STM32F10X系列单片机】
11-22
STM32F103驱动程序，资源内包含三种驱动实现方式：寄存器驱动、库函数驱动和HAL库驱动。 项目支持STM32F10X系列单片机调测和移植。 项目可直接编译、运行。
自编STM32轻量级操作系统(二)------任务调度
风筝
07-24 1万+
你好，这里是风筝的博客， 欢迎和我一起交流。 上一章自编STM32轻量级操作系统(一)------操作系统实现 讲了那么多，终于到了实战环节。现在来开始动手码程序。 根据之前分析的，我们先写下分析流程： 上帝(操作系统)正在开心的玩耍着，看了看时间，一天结束了，夜晚来了(系统定时器中断)，哦，要搞事情了，人间将要掀起一场腥风血雨！！！ 此时人间（用户进程）
STM32 裸机程序的任务调度（学习）
最新发布
qq_62081970的博客
07-24 1092
在开发单片机时如果不使用操作系统，任务调度是有点让人头疼的，尤其是业务功能模块比较多的情况，比如说有些功能需要几毫米就要执行一次，而有些只需要几百毫秒才用执行一次就可以，这种情况如果做不到及时的任务调度，那么使用起来的感受是非常不好的。
毫秒级精度计划任务管理、系统运维管理、定时执行任务、定时任务执行、任务定时执行软件 —— 定时执行专家
热门推荐
boom's works
06-25 32万+
《定时执行专家》—— 官方安装教程。《定时执行专家》是一款制作精良、功能强大、毫秒精度、专业级的定时任务执行软件。软件具有 23 种【任务类型】、12 种【触发器】触发方式，并且全面支持界面化【Cron表达式】设置。软件采用多线程并发方式检测任务触发和任务执行，能够达到毫秒级的执行精度，可以同时支持50个以上任务的毫秒级触发。
【基于FreeRTOS的STM32F103系统】内存管理及任务调度
qq_52785580的博客
09-12 1641
虽然现在的单片机系统，CPU的资源并不是那么紧缺了，也有丰富的内存空间，但是我们还是要积极地实现内存管理，这可以帮我们减少内存资源的占用，优化程序，提高效率。 而任务调度算法，则是帮助我们合理安排实时系统中各个任务的逻辑顺序，保证各个任务按照某种规则协调有效的进行。
STM32 实现简单定时任务调度器，动态创建任务，两种思路实现流水灯
刻[苦] 的 blog
06-06 4256
代码实现和硬件没关系，所以并不限于STM32，Arduino 之类的其他地方也能用，只要有一个能获取时间的函数就行，或者说，只要有一个会随着时间自动增加的变量就行，时间单位无所谓，所以确实想的话，拿到电脑上也能用。
STM32F103C8T6标准库的FreeRTOS版本
02-01
9. **示例代码分析**：压缩包中的代码可能是已测试成功的STM32F103C8T6与FreeRTOS的集成实例，包括初始化设置、任务创建、中断处理等。通过分析这些代码，可以学习如何在实际项目中应用FreeRTOS。 10. **移植与优化...
stm32f103c8的延迟函数
03-16
在STM32F103C8的项目中，我们可能会遇到以下几种延时函数的实现方式： 1. **基于循环计数的延时**： 这是最简单的延时方法，通过设置一个循环计数器，在循环体内执行无实际意义的操作，如空循环，直到达到预设的...
SysTick（系统滴答定时器）操作_STM32F103_
10-01
STM32F103系列微控制器是基于ARM Cortex-M3内核的高性能微处理器，广泛应用于嵌入式系统设计。在这些应用中，时序控制和任务调度至关重要，SysTick（系统滴答定时器）就是这样的一个核心组件。SysTick是一个内置的...
基于STM32f103单片机 printf重定向实验软件例程源代码.rar
05-23
在STM32中，可以通过配置SysTick来设置周期性中断，实现毫秒级的延时或心跳信号。 总的来说，这个实验涵盖了STM32F103的多个关键功能，包括printf重定向、UART通信、RTC时钟、红外遥控以及系统定时器的使用。通过这...
使用C语言在STM32F103VCT6上实现uC/OS-II控制系统：SPI、CAN、S型加减速及UART通信
qq_38334677的博客
06-23 602
高性能：72 MHz的工作频率，支持1.25 DMIPS/MHz的运算能力。丰富的外设接口：内置多个USART、SPI、I2C和CAN接口，适合多种通信需求。低功耗：支持多种低功耗模式，适合电池供电的应用场景。丰富的开发资源：ST官方提供了丰富的开发工具和库函数，方便开发者快速上手。小巧高效：代码小巧，占用资源少，适合资源有限的嵌入式系统。可移植性强：支持多种处理器架构，易于移植到不同平台。任务管理灵活：支持多任务调度、信号量、消息队列等多种实时操作系统特性。稳定可靠。
FreeRTOS（基于STM32）——任务管理
vizio.blog.csdn.net
11-03 371
FreeRTOS（基于STM32）——任务管理
STM32 简单多任务调度
a651588的专栏
05-07 1万+
STM32的开发目前大多数还开处于“裸奔”的阶段，处于开发成本的考虑，可能还未嵌入任何的RTOS系统，由于没有操作系统的支持，因而不能方便的对多任务进行调度和管理，在main函数中你可能会写成如下方式： int main(void) {         while (1)         {                 Task1(); // 调用任务
STM32使用定时器输出比较实现任务调度
tiange1996的博客
03-24 2008
实现任务调度——使用定时器输出比较 唔，今天被问了一下，如何去做代码的一个响应框架，下班了就想写一下然后就算是作为随笔吧。 1.手册解读 在这里使用的是通用定时器TIMER3,从手册中我们可以看到，在输出比较模式下有四个比较寄存器： 通过手册我们可以知道： 而我们就是利用的是输出比较功能中的相应中断使能位（TIMx_DIER 寄存器中的 CCXIE 位）置 1，将生成中断。并且在当前的比较中断中获取比较寄存器的值动态修改，让不同的时基中断一直进行下去。 2.定时器比模式实现任务调度示意图 这样我们便可
stm32——freeRTOS任务调度、任务4种状态
2302_76515999的博客
05-10 1369
调度器就是使用相关的调度算法来决定当前需要执行哪个任务。freeRTOS中开启任务调度的函数是vTaskStartScheduler(),但是在cubeMX中被封装为osKernelStart()。
【STM32---任务调度】裸系统下的时间片轮询机制
泡泡吐泡泡啊的博客
05-17 2837
一、任务调度 二、实现方法
STM32 操作系统内核调度原理与实现（3）：两个任务之间的切换
白杨木屋
05-31 2037
在实现多个任务之间的切换之前，可以先通过实现两个固定任务切换，作为一个过度，本文将介绍在STM32中，如何通过操作内核，来实现两个固定任务之间的切换。 一、嵌入汇编 1. 嵌入汇编的方法 正如前文所提及，实现任务切换中操作内核寄存器需要使用汇编程序，所以我们需要掌握如何在自己使用的IDE中嵌入汇编语句，本文使用的编译器为MDK5默认编译器v5版本： 嵌入汇编的方式十分简单，只需要使用_asm来声明一个函数即可，如： //程序清单3.1 __asm void BUD_ContextSwitch(stack_
STM32 操作系统内核调度原理与实现（2）：任务调度的基础
白杨木屋
04-19 1804
一、STM32F103ze 简介 本文中，采用的 MCU 具体型号为 STM32F103ZET6，其拥有丰富的外设资源（USB，IIC，USART，TIMER）等，大容量的RAM和ROM，以及上百个IO口，可满足普通嵌入式设备的大部分需求： STM32F103ZE 参数 STM32F103ZE 存储器 程序存储器类型 Flash ROM(B...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值