非常实用的裸机多任务实现方法

已于 2023-11-21 10:13:30 修改
阅读量485 收藏 9
点赞数 2
分类专栏： 嵌入式 文章标签： 数据结构 算法 单片机 stm32 嵌入式硬件 1024程序员节
于 2023-08-25 16:44:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53828053/article/details/132497784
版权

1.相对于上一个版本增加中间接口，全部代码都粘贴到了文章中，无任何收费，大家动动小手点个收藏关注。

2.你是否有这种烦恼？

        1）控制不同灯的不同闪烁频率，每个灯的闪烁速率不同，于是乎，定义了一大堆的标志位去控制不同的周期闪烁？想要控制它停止你又得有其他的标志位，逻辑复杂，标志位特别多，if else特别长？而且几乎不能维护！不是吧，不是吧，还有人这么写的吗?

        2) 我想要一个低速率的PWM方波，1k以下，不想用定时器实现，想用软件实现，于是乎，又是一大堆标志位变量和复杂的逻辑！！！！同样维护成本及高，看得让人头皮发麻，不会有人是这么做的吧？不会吧？

        3）我想要设置一个重复间隔执行动作，比如说开门关门，开门后延时一段时间在关门，再间隔一段时间在开门，这个又需要更加庞大的标志位和变量，维护？不存在的

3.这篇文章呢，就是为了解决这种烦恼，这个适配了大多数场景，如果发现不能适配的可以联系作者，后续更新哦。

        4) 又或者单片机rom装不下市面上的操作系统，又或者ram不够？，用起来麻烦，不会？学习成本高？怕不稳定？

怎么办呢？不会吧，还有人在跑裸机加函数指针数组的形式吧，太落后了，功能太单一了！！！

没事的，我这个能满足你！

4.接下来就是正文了！

5.当然这个也是有不足之处的，比如说，没有优先级，只能顺序执行，这个和操作系统的区别还是很大的，适合用在实时性不是那么强的场景。

6.好处有哪些呢？减少了一大堆的逻辑判断和变量标志，简化了程序设计时间，更加易于维护！

直接上图不罗嗦（图很丑别吐槽）

 这个图够清楚了吧，就不扒拉太多了

typedef struct
{
	char name[12];
	int count; 		//需要执行的次数
	int current; 	//当前计数值
	int timer; 		//一次的时长
	int interval;
	void (* enter_applocation)(const char * name, int  count);//时间到达需要执行的动作
	void (*mid_applocation)(const char * name, int  count);
	void (* exti_applocation)(const char * name, int  count);//时间到达需要执行的动作
	void (*cancel_handle)(const char * name, int  count);
}reckon_by_time;

name：每个任务都有一个固定的任务名，通过这个任务名去添加与删除任务，不会存在相同的任务名，如有相同的自带机制会顶替原有任务。

count：这个任务需要执行多少次，也就是上面说的，闪烁灯，闪多少次，开关门多少次，如果设置为-1为无限次数，不会终止

current：这个你不需要设置，内部用的

其他的图上面有说明了，就不哔哔赖赖了。

程序接口主要用于执行重复性的事情，以及用作裸机任务栈，如果添加任务不成功，可以修改BYTIMESIZE  宏大小，增加任务池大小。

直接上干货，不罗嗦！

chrono.h

#ifndef __CHRONOSCOPE_H__
#define __CHRONOSCOPE_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <string.h>
//#define CHRONO_RTTHREAD 
#define TASKNAMELEN 20
#define BYTIMESIZE  20



typedef struct
{
	char name[TASKNAMELEN];
	int count; 		//需要执行的次数
	int current; 	//当前计数值
	int timer; 		//一次的时长
	int interval;
	void (* enter_applocation)(const char * name, int  count);//时间到达需要执行的动作
	void (*mid_applocation)(const char * name, int  count);
	void (* exti_applocation)(const char * name, int  count);//时间到达需要执行的动作
	void (*cancel_handle)(const char * name, int  count);
}reckon_by_time;


typedef struct
{
	reckon_by_time rbt[BYTIMESIZE];
	int size;
	#ifdef CHRONO_RTTHREAD
	struct rt_mutex rt_mutex_t;
	#endif
}BytimePool;
	
	
void chrono_scope_task(void);

void init_by_time_pool(void);	

int add_by_time_task(const char * name, int count, int timer,int interval, 
	void (* enter_applocation)(), 
		void (* exti_applocation)(),
			void (*cancel_handle)());
		
int add_bt_mid_task(const char * name, int count, int timer,int interval, 
	void (* enter_applocation)(const char * name, int  count), 
		void (* mid_applocation)(const char * name, int  count), 
		void (* exti_applocation)(const char * name, int  count),
			void (*cancel_handle)(const char * name, int  count));
				
int add_bt_simp_task(const char * name, int count, int timer,
	void (* enter_applocation)(const char * name, int  count));		

void delete_by_time_task(const char * name);



#ifdef __cplusplus
}
#endif

#endif

chrono.c

/*********************************************************************************
  *Copyright(C) -
  *FileName: chrono.c
  *Author: 我不是阿沸
  *Version: 3.6
  *Date: 2023.09.15
  *Description:  程序接口主要用于执行重复性的事情，以及用作裸机任务栈  
  *Others:  使用接口前一定调用初始化接口，这里只适配了rt_thread数据安全接口，如需要使用可以打开相关
  			宏定义，其他操作系统数据安全需自行实现  
  *History:  
     1.Date:2023/08/24
       Author:我不是阿沸 
       Modification:修改原来的任务id为任务名 ，修改原来与id相关的接口，增加简化版初始化接口。
     2.Date:2023/09/15
       Author:我不是阿沸 
       Modification：增加中间接口，用于直行到一半时产生中间异步回调，解决死锁问题。
	 3.其他修改 
**********************************************************************************/

#include "chrono.h"



static BytimePool bytimePool;


/**
  * @brief  初始化任务池
  * @retval None
  */
void init_by_time_pool(void)
{
    bytimePool.size = 0;
#ifdef CHRONO_RTTHREAD
    if(RT_EOK != rt_mutex_init( &(bytimePool.rt_mutex_t), "bytime_pool", RT_IPC_FLAG_FIFO))
    {

        return;
    }
    rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
}


/**
  * @brief  添加任务
  * @param  count为任务执行次数,如果为-1为永久执行.
  * @param  进入任务与退出任务的执行时间，注意这个时间只与任务监测线程的时间片有关
  * @param  每次任务的间隔时间
  * @param  进入任务事件
  * @param  退出任务事件
  * @param  任务到期完成回调
  * @retval 任务索引
  */
int add_by_time_task(const char * name, int count, int timer,int interval,
                     void (* enter_applocation)(const char * name, int  count),
                     void (* exti_applocation)(const char * name, int  count),
                     void (*cancel_handle)(const char * name, int  count))
{
#ifdef CHRONO_RTTHREAD
    rt_mutex_take(&(bytimePool.rt_mutex_t), RT_WAITING_FOREVER);
#endif
    if(bytimePool.size >= BYTIMESIZE)
    {
#ifdef CHRONO_RTTHREAD
        rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
        return -1;
    }
    int id = -1;
    for(int i = 0; i < bytimePool.size; i++)
    {
        if(strncmp(bytimePool.rbt[i].name, name, TASKNAMELEN) == 0)
        {
            //不允许存在相同名字任务
            id = i;
            break;
        }
    }

    if(id < 0 || id >= bytimePool.size)
    {
        id =  bytimePool.size;
    }

    reckon_by_time * rbt = bytimePool.rbt + id;

    bytimePool.size++;

    if(strlen(name) > TASKNAMELEN-1)
    {
#ifdef CHRONO_RTTHREAD
        rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
        return -1;
    }
    strcpy(rbt->name, name);
    rbt->count = count;
    rbt->timer = timer;
    rbt->interval = timer+interval;
    rbt->current = 0;
    rbt->enter_applocation = enter_applocation;
    rbt->exti_applocation = exti_applocation;
    rbt->cancel_handle = cancel_handle;
#ifdef CHRONO_RTTHREAD
    rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
    return bytimePool.size - 1;
}


/**
  * @brief  添加任务
  * @param  count为任务执行次数,如果为-1为永久执行.
  * @param  进入任务与退出任务的执行时间，注意这个时间只与任务监测线程的时间片有关
  * @param  每次任务的间隔时间
  * @param  进入任务事件
  * @param  中间任务事件
  * @param  退出任务事件
  * @param  任务到期完成回调
  * @retval 任务索引
  */
int add_bt_mid_task(const char * name, int count, int timer,int interval,
                    void (* enter_applocation)(const char * name, int  count),
                    void (* mid_applocation)(const char * name, int  count),
                    void (* exti_applocation)(const char * name, int  count),
                    void (*cancel_handle)(const char * name, int  count))
{
#ifdef CHRONO_RTTHREAD
    rt_mutex_take(&(bytimePool.rt_mutex_t), RT_WAITING_FOREVER);
#endif
    if(bytimePool.size >= BYTIMESIZE)
    {
#ifdef CHRONO_RTTHREAD
        rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
        return -1;
    }
    int id = -1;
    for(int i = 0; i < bytimePool.size; i++)
    {
        if(strncmp(bytimePool.rbt[i].name, name, TASKNAMELEN) == 0)
        {
            //不允许存在相同名字任务
            id = i;
            break;
        }
    }

    if(id < 0 || id >= bytimePool.size)
    {
        id =  bytimePool.size;
    }

    reckon_by_time * rbt = bytimePool.rbt + id;

    bytimePool.size++;

    if(strlen(name) > TASKNAMELEN-1)
    {
#ifdef CHRONO_RTTHREAD
        rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
        return -1;
    }
    strcpy(rbt->name, name);
    rbt->count = count;
    rbt->timer = timer;
    rbt->interval = timer+interval;
    rbt->current = 0;
    rbt->enter_applocation = enter_applocation;
    rbt->mid_applocation = mid_applocation;
    rbt->exti_applocation = exti_applocation;
    rbt->cancel_handle = cancel_handle;
#ifdef CHRONO_RTTHREAD
    rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
    return bytimePool.size - 1;
}

/**
  * @brief  添加任务
  * @param  count为任务执行次数,如果为-1为永久执行.
  * @param  进入任务与退出任务的执行时间，注意这个时间只与任务监测线程的时间片有关
  * @param  进入任务事件
  * @retval 任务索引
  */
int add_bt_simp_task(const char * name, int count, int timer,
                     void (* enter_applocation)(const char * name, int  count))
{
#ifdef CHRONO_RTTHREAD
    rt_mutex_take(&(bytimePool.rt_mutex_t), RT_WAITING_FOREVER);
#endif
    if(bytimePool.size >= BYTIMESIZE)
    {
#ifdef CHRONO_RTTHREAD
        rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
        return -1;
    }
    int id = -1;
    for(int i = 0; i < bytimePool.size; i++)
    {
        if(strncmp(name, bytimePool.rbt[i].name, TASKNAMELEN) == 0)
        {
            //不允许存在相同名字任务
            id = i;
            break;
        }
    }

    if(id < 0 || id >= bytimePool.size)
    {
        id =  bytimePool.size;
    }

    reckon_by_time * rbt = bytimePool.rbt + id;

    bytimePool.size++;

    if(strlen(name) > TASKNAMELEN-1)
    {
#ifdef CHRONO_RTTHREAD
        rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
        return -1;
    }
    strcpy(rbt->name, name);
    rbt->count = count;
    rbt->timer = timer;
    rbt->interval = timer+0;
    rbt->current = 0;
    rbt->enter_applocation = enter_applocation;
    rbt->mid_applocation = NULL;
    rbt->exti_applocation = NULL;
    rbt->cancel_handle = NULL;
#ifdef CHRONO_RTTHREAD
    rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
    return bytimePool.size - 1;
}


/**
  * @brief  删除任务
  * @param  任务ID
  * @retval None
  */
void delete_by_time_task(const char * name)
{
#ifdef CHRONO_RTTHREAD
    rt_mutex_take(&(bytimePool.rt_mutex_t), RT_WAITING_FOREVER);
#endif
    int id = -1;
    for(int i = 0; i < bytimePool.size; i++)
    {
        if(strcmp(bytimePool.rbt[i].name, name) == 0)
        {
            //不允许存在相同名字任务
            id = i;
            break;
        }
    }
    if(id < 0 || id >= bytimePool.size)
    {
#ifdef CHRONO_RTTHREAD
        rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
        return;
    }
    else	if(bytimePool.rbt[id].cancel_handle != NULL)
    {
        bytimePool.rbt[id].cancel_handle(bytimePool.rbt[id].name, bytimePool.rbt[id].count);
    }

    bytimePool.rbt[id] = bytimePool.rbt[bytimePool.size - 1];
    bytimePool.size--;
#ifdef CHRONO_RTTHREAD
    rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
}

/**
  * @brief  任务池监测线程，时基会影响任务定时的执行，一般为1ms为时基
  * @retval None
  */
void chrono_scope_task(void)
{
#ifdef CHRONO_RTTHREAD
    rt_mutex_take(&(bytimePool.rt_mutex_t), RT_WAITING_FOREVER);
#endif
    for(int i = 0; i < bytimePool.size; i++)
    {
        reckon_by_time * rbt = bytimePool.rbt + i;
        if(rbt->count > 0 || rbt->count < 0)
        {
            if(rbt->current == 0)
            {
                if(rbt->enter_applocation != NULL)
                {
                    rbt->enter_applocation(rbt->name, rbt->count);
                }

            }
            //第二阶段
            if(rbt->current == rbt->timer)
            {
                if(rbt->exti_applocation != NULL)
                {
                    rbt->exti_applocation(rbt->name, rbt->count);
                }
            }

            if(rbt->current == rbt->timer/2)
            {
                if(rbt->mid_applocation != NULL)
                {
                    rbt->mid_applocation(rbt->name, rbt->count);
                }

            }
            rbt->current++;

            //第三阶段 重置
            if(rbt->current == rbt->interval)
            {
                rbt->current = 0;
                if(rbt->count > 0) rbt->count--;
            }
        }
        else
        {
            if(bytimePool.rbt[i].cancel_handle != NULL)
            {
                bytimePool.rbt[i].cancel_handle(rbt->name, rbt->count);
            }

            //直接拿最后一个替换
            bytimePool.rbt[i] = bytimePool.rbt[bytimePool.size - 1];

            bytimePool.size--;
        }
    }
#ifdef CHRONO_RTTHREAD
    rt_mutex_release(&(bytimePool.rt_mutex_t));
#endif
}

示例：

void expand_enter(const char * name, int count)
{
	static int __time_ex = 0;
	if(__time_ex >= 20) __time_ex = 0;
	__time_ex++;
	pwm_para pwm;
	
	//if(__time_ex == NULL) return;
	
	pwm_ctr.freq = __freq_bf[__time_ex];
	cmp_by_angle(&pwm_ctr, &pwm);
	set_pwm_value(&pwm);
}

AF_DATA_TYPE switch_convert(AF_DATA_TYPE data, AF_DATA_TYPE src){
	if(preset.expand > 0 && data % 2 == 1)
	{
		__freq_bf = rand_freq(preset.freq, preset.expand);
		//开启拓频
		add_by_time_task("expand", -1, 1, 1, expand_enter, NULL, NULL);
	}
	else
	{
		delete_by_time_task("expand");
	}
}

我不是阿沸
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RTOS是如何进行任务划分的
02-24
从宏观的角度看是多个任务同时在占据着CPU的执行，就像是多CPU一样，在真正的多CPU系统中，每个CPU都有一套自己的寄存器，而为了实现这样一种多CPU运行的机制，那么操作系统就为每个任务用一块专用的存储空间构建了...
单片机资源较少时的多任务处理方法
TheCity2333的博客
09-13 187
每个任务都有空闲的时间，如小车灯的亮灭时间，只需要改变灯的电平，中间不需要一直等待，需要实现灯的定时闪烁功能时，程序可以写成。也就是讲，唤醒该任务的条件是T=T0+t。休眠的任务池中，可通过延时唤醒加入待唤醒任务池，待唤醒任务池中的任务需要在特定时间苏醒。但是，依旧有些需要考虑的问题，如何实现在特定时间唤醒对应任务，当两个任务需要在同一时间节点唤醒，该如何处理？该实现的缺点是使用了一个定时器的业务逻辑来实现，定时器的个数是有限的，实现业务逻辑在定时器中，也增加了业务的耦合性，不利于后续程序的维护。
关于STM32的裸机多任务多线程心得
热门推荐
qq_37272520的博客
03-30 2万+
多任务多线程 多任务"并行处理" 首先我们来理解一下并行处理，初学者写程序通常是顺序执行，当我们逐渐想成为“专业”人士的时候顺序执行 的程序已经不能满足我们了，所以就需要多任务多线程系统，市面上标准的一些操作系统比如ucos，freeRTOS这些操作系统需要的学习周期长，范围广。在网上看到了一本书"单片机编程魔法师之高级裸编思想"在没学会ucos的阶段学习用这种思想过度感觉非常nice！ 单片机是...
单片机开发之裸机也能 “多任务”？
Tang的博客
04-21 5069
单片机开发之裸机也能 “多任务”？ 1. 背景 ​ 对于一些简单的单片机项目，没必要非得跑RTOS，因此，多项目都是“裸奔”(指纯循环加上中断的机制)。所以，开发出一套好用的裸机框架是非常有必要的，本文章带你手把手实现裸机中的“多任务”调度。 2. 基本知识 ​ 需要掌握的基本知识并不多，也都是最基本的知识，总结如下 Systick 定时器 函数指针 结构体数组 3. 代码实现 ​ 整个系统的代码由 Systick 中断发动，Systick 就像是一个发动机，每隔一定的周期发动一次中断，利用这一个中断的
一种轻便的裸机多任务实现方法
诗筱涵的博客
07-23 830
转载自：https://mp.weixin.qq.com/s/uf89w_qFBoVFLez45dlrDQ 一种轻便的裸机多任务实现方法 嵌入式大杂烩 今天 以下文章来源于嵌入式实验基地 ，作者Embedded小飞哥 关注「嵌入式大杂烩」，选择「星标公众号」一起进步！ 来源：嵌入式实验基地 前言 你是否还在为一大堆任务放在while中，通过一个个标志，做一大堆if...else...switch...case...烦恼，想跑个freertos或者ucos，发现芯片空间有限，添加不进去了.
裸机环境实现多任务调度(例程及源码)
qq_37830757的博客
03-09 3588
无RTOS(裸机环境)下实现分时调度法，非常适用于单片机环境下的一般应用场景。 RTOS优点不用多说了，但对于一些简单的业务需求，移植一个操作系统又显得非常麻烦，且非常占用系统资源。 通常的做法是在一个大while下执行各个业务函数，通过多个定时器去控制各个函数的执行周期，利用几个全局变量关联各个模块功能。 但这样的做法在多轮开发下，会造成 代码非常臃肿，模块关系混乱，不利于阅读。 为了解决这个问题，手动码了一个简单的多任务调度，封装成接口供大家使用！ 实现方式：创建任务时，设定好任务的调度周期和
一种裸机多任务实现方法--时间片轮询
Damon_Sandy的博客
03-20 1235
多任务，裸机
裸机系统与操作系统
业精于勤荒于嬉
08-30 3452
目录 前言 一、裸机系统通常分成轮询系统和前后台系统（中断） 1.轮询系统 2.前后台系统 二、多线程系统 总结 前言 裸机系统与操作系统存在什么区别，两者都适合在什么场景下使用，我们今天我们一起来探讨一下这个问题， 一、裸机系统通常分成轮询系统和前后台系统（中断） 1.轮询系统 轮询系统中是最简单的一种软件结构，就像一条流水线一样是顺序循环执行的，可以看下下边的范例，嵌入式开发过程中一般都是先将硬件结构初始化，之后再加上一个循环控制来执行业务，这就是最简单的流程 int ma
【单片机】单片机裸机实现多任务调度
最新发布
冲沖衝的博客
12-01 845
实时操作系统RTOS的优点不必多说了，但是对于一些简单的业务需求，移植一个操作系统显得非常麻烦，并且占用系统资源，此时就可以考虑利用SysTick裸机实现多任务调度。单片机裸机实现多任务调度的优点有。3、程序架构清晰、模块化。
raspi3-tutorial:裸机Raspberry Pi 3教程
05-25
我将不讨论诸如内存管理和虚拟文件系统之类的主题，也不介绍如何实现多任务处理。 如果您打算为Raspberry Pi编写自己的操作系统，建议您在继续之前进行一些研究。 本教程非常注重与硬件的接口，而不是关于OS的理论...
STM32时分法多任务处理例程
02-15
STM32时分法多任务处理例程
NASM 汇编编译器（可写跨平台任务和操作系统！）
09-26
如编译附带的操作系统（这个文件有两种模式，1完全脱离系统，2运行于WINDOW虚拟机，这里我就不多说了）的方法是： NASM boot.asm -o boot.com 3.注释方法，行注释：在行注释前增加符号 ; （英文分号）这样这行这...
stm8
03-13
尽管从头开始编写外围设备驱动程序似乎在重蹈覆辙，但在许多情况下，实现特定任务所需的功能更容易，更快捷，而不是依赖于供应商提供的库来尝试一次完成所有工作（并失败）。 有关更多详细信息，请查看： : 主要...
agola：Agola：重新定义了CICD
02-02
具有实现扇入，扇出，矩阵等功能的任务工作流（我们称为Runs ），将所有内容打包在一起以实现最大的可重复性。 基于Git的工作流程：运行定义被提交到git存储库中（因此所有内容都可以被跟踪和再现）。 运行执行是...
裸机条件下写一个基于时间片轮转的多任务并发程序
silent_dusbin的博客
03-24 1097
在学习各种MCU的时候，都是用在main函数里写一个while(1){/* 执行代码 */}，这种方式只能一个函数运行完以后再运行另一个函数。假设需求控制多个模块，如显示屏幕信息的同时控制电机，还要一边接收按键输入。如果用上面的方式每个模块要排队等待CPU运行，就会显的很卡。那有没有办法每个模块运行固定的时间，时间到了运行下一个模块，这样单个模块即使特别耗时，也不影响其他模块的运行，这个方法叫时间片轮转。想到这个办法很容易，但要怎么编写代码呢？
使用STM32裸机实现时间轮片法进行多任务调度【单片机篇】
刘老刘的博客
11-15 1000
思路：在定时器中判断各个人物是否到执行时间，如果到了，该任务flag置1，然后主循环判断flag是否为1，为1执行。 END~~
单片机STM32有什么推荐的裸机编程架构
qq_41854911的博客
11-07 3235
基于循环时间的跨平台任务管理系统（可用于MCS51，STM32等单片机）
STM32/51单片机进阶技一 裸机编程(多任务处理编程思想与代码风格)
m0_56194543的博客
07-17 4633
在单片机编程当中，我们难免会用单片机处理1个，2个简单的任务，但是当任务数量超过了十几，二十的时候，或者任务之间会有相互影响，我们又不想使用稍微更为复杂的操作系统的话，这里提供一种任务处理思想例如以上就是今天要讲的内容，本文仅仅简单运用定时器服务函数的使用，方便在单片机中进行多任务的处理。...
RTT简介及其简单应用
A1394155851的博客
10-21 6688
一、 裸机系统和多任务系统 裸机系统通常分为轮询系统和前后台系统。 int main() { Init(); while(1) { /*事件1*/ event1(); /*事件2*/ event2(); /*事件3*/ event3(); } }
stm32不用freerots怎么实现多功能运行
05-22
STM32 是一款强大的微控制器，它可以实现多种功能的运行，不一定需要使用 FreeRTOS。下面是一些实现多功能运行的方法： 1. 使用中断：STM32 可以使用中断来处理多个任务，可以通过配置不同的中断优先级来实现任务的优先级控制。 2. 使用定时器：STM32 的定时器功能可以用来实现定时任务，比如定时采集传感器数据、定时发送数据等。 3. 使用 DMA：STM32 的 DMA 功能可以实现数据的快速传输，可以用来实现高速数据采集、数据存储等任务。 4. 使用多线程编程：使用多线程编程技术可以在不使用操作系统的情况下实现多任务并发执行。 5. 使用裸机编程：在不使用操作系统和多线程编程技术的情况下，可以使用裸机编程技术实现多个任务的轮流执行。 以上是一些常见的实现多功能运行的方法，具体方法需要根据具体的应用场景和需求来选择。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值