stm32裸机开发下利用MultiTimer多任务时间片询

已于 2025-01-15 11:18:57 修改
阅读量2.4k 收藏 45
点赞数 1
CC 4.0 BY-SA版权
文章标签： stm32 嵌入式硬件 MultiTimer 多任务时间片询
于 2023-05-11 16:26:43 首次发布
本文为Perseverance52博主原创文章，未经博主允许，不得转载！
本文链接：https://blog.csdn.net/weixin_42880082/article/details/130623136

stm32裸机开发下利用MultiTimer多任务时间片询

  • 📌MultiTimerGithub地址：https://github.com/0x1abin/MultiTimer
  • ✨这是一个类似Arduino平台上的Ticker库，如需阅读懂源码，起码需要有链表知识的储备，如果仅仅只是拿来使用，那就忽略具体实现的方法。

📑MultiTimer简介

MultiTimer 是一个软件定时器扩展模块，可无限扩展你所需的定时器任务，取代传统的标志位判断方式， 更优雅更便捷地管理程序的时间触发时序。

⛳使用注意事项说明

  1. 定时器的时钟频率直接影响定时器的精确度，尽可能采用1ms/5ms/10ms这几个精度较高的tick;
  2. 定时器的回调函数内不应执行耗时操作，否则可能因占用过长的时间，导致其他定时器无法正常超时；
  3. 由于定时器的回调函数是在 MultiTimerYield() 内执行的，需要注意栈空间的使用不能过大，否则可能会导致栈溢出。

基于stm32f103,使用stm32cubemx配置的工程案例

  • 🔖为了省事，直接将其驱动文件分别拷贝到项目MultiTimer_Task\Core\Inc和MultiTimer_Task\Core\Src下。
  • 🌿在所创建好的工程中添加源文件（MultiTimer.c）,右键其文件属性-设置为c源文件。
    在这里插入图片描述

在这里插入图片描述

  • 📓将系统的滴答定时器作为MultiTimer多任务时间片询的时基。

  • 🌿main.c程序示例代码

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include "MultiTimer.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
MultiTimer timer1;//创建任务对象
MultiTimer timer2;
MultiTimer timer3;
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
uint64_t PlatformTicksGetFunc(void)
{
    return (uint64_t)HAL_GetTick();
}
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void exampleTimer1Callback(MultiTimer* timer, void* userData)
{
    //回调函数1
    printf("[TASK1] Timer:%p callback-> %s.\r\n",  timer, (char*)userData);
    MultiTimerStart(timer, 1000, exampleTimer1Callback, userData);
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_5);
}

void exampleTimer2Callback(MultiTimer* timer, void* userData)
{
    //回调函数2
    printf("[TASK2] Timer:%p callback-> %s.\r\n", timer, (char*)userData);
    HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_5);
}

void exampleTimer3Callback(MultiTimer* timer, void* userData)
{
    //回调函数3
    printf("[TASK3] Timer:%p callback-> %s.\r\n", timer, (char*)userData);
    MultiTimerStart(timer, 4567, exampleTimer3Callback, userData);//初始化并启动Timer
    HAL_GPIO_TogglePin(GPIOE, GPIO_PIN_6);
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
    /* USER CODE BEGIN 1 */

    /* USER CODE END 1 */

    /* MCU Configuration--------------------------------------------------------*/

    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    HAL_Init();

    /* USER CODE BEGIN Init */

    /* USER CODE END Init */

    /* Configure the system clock */
    SystemClock_Config();

    /* USER CODE BEGIN SysInit */

    /* USER CODE END SysInit */

    /* Initialize all configured peripherals */
    MX_GPIO_Init();
    MX_USART1_UART_Init();
    /* USER CODE BEGIN 2 */
    MultiTimerInstall(PlatformTicksGetFunc);
    MultiTimerStart(&timer1, 1000, exampleTimer1Callback, "1000ms CYCLE timer");
    MultiTimerStart(&timer2, 5000, exampleTimer2Callback, "5000ms ONCE timer");
    MultiTimerStart(&timer3, 3456, exampleTimer3Callback, "3456ms delay start, 4567ms CYCLE timer");
    /* USER CODE END 2 */

    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while(1)
    {
        /* USER CODE END WHILE */

        /* USER CODE BEGIN 3 */
        MultiTimerYield();
    }
    /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    /** Initializes the RCC Oscillators according to the specified parameters
    * in the RCC_OscInitTypeDef structure.
    */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
    if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    {
        Error_Handler();
    }

    /** Initializes the CPU, AHB and APB buses clocks
    */
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
                                  | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

    if(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
    {
        Error_Handler();
    }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
    /* USER CODE BEGIN Error_Handler_Debug */
    /* User can add his own implementation to report the HAL error return state */
    __disable_irq();
    while(1)
    {
    }
    /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{
    /* USER CODE BEGIN 6 */
    /* User can add his own implementation to report the file name and line number,
       ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
    /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
  • 📜串口调试信息输出：
    在这里插入图片描述
📚示例工程源码
  • 🏳‍🌈基于STM32CubeMX配置的stm32f103vc工程示例代码
链接: https://pan.baidu.com/s/1KbhfdzvpuUklwqboo3bAZQ
提取码: bfkb

基于定时器自定义多任务实现框架

简单多任务
  1. 定义任务结构体
    定义一个任务结构体，包含任务的状态、标志、执行函数指针、执行间隔和上次执行时间等信息。
typedef struct {
    void (*TaskFunction)(void); // 任务函数指针
    uint32_t Interval;          // 任务执行间隔（ms）
    uint32_t LastRun;           // 上次执行时间
    uint8_t State;              // 任务状态（例如：0-未运行，1-运行中）
    uint8_t Flag;               // 任务标志（例如：0-未就绪，1-就绪）
} Task_t;
  1. 创建任务数组
    创建一个任务数组，用于存储所有需要调度的任务。
#define MAX_TASKS 10

Task_t Tasks[MAX_TASKS]; // 任务数组
uint8_t TaskCount = 0;   // 当前任务数量
  1. 添加任务函数
    实现一个函数，用于向任务数组中添加任务。
void AddTask(void (*TaskFunction)(void), uint32_t Interval, uint8_t State, uint8_t Flag) {
    if (TaskCount < MAX_TASKS) {
        Tasks[TaskCount].TaskFunction = TaskFunction;
        Tasks[TaskCount].Interval = Interval;
        Tasks[TaskCount].LastRun = 0;
        Tasks[TaskCount].State = State;
        Tasks[TaskCount].Flag = Flag;
        TaskCount++;
    }
}
  1. 实现任务调度
    在定时器中断服务程序（ISR）中，遍历任务数组，检查每个任务是否需要执行。根据任务的状态和标志决定是否执行任务。
void TIM2_IRQHandler(void) {
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

        static uint32_t Tick = 0;
        Tick++;

        for (uint8_t i = 0; i < TaskCount; i++) {
            // 检查任务是否就绪且状态为运行中
            if (Tasks[i].Flag == 1 && Tasks[i].State == 1) {
                if (Tick - Tasks[i].LastRun >= Tasks[i].Interval) {
                    Tasks[i].TaskFunction(); // 执行任务
                    Tasks[i].LastRun = Tick; // 更新上次执行时间
                }
            }
        }
    }
}
  1. 添加任务
    在主函数中，添加需要调度的任务，并初始化任务的状态和标志。
void Task1(void) {
    // 任务1的代码
    printf("Task1 is running...\n");
}

void Task2(void) {
    // 任务2的代码
    printf("Task2 is running...\n");
}

int main(void) {
    TIM2_Init();

    // 添加任务
    AddTask(Task1, 100, 1, 1); // Task1，每100ms执行一次，状态为运行中，标志为就绪
    AddTask(Task2, 500, 1, 1); // Task2，每500ms执行一次，状态为运行中，标志为就绪

    while (1) {
        // 主循环
    }
}
  1. 动态修改任务状态和标志
    可以通过函数动态修改任务的状态和标志，以控制任务的执行。
void SetTaskState(uint8_t TaskID, uint8_t State) {
    if (TaskID < TaskCount) {
        Tasks[TaskID].State = State;
    }
}

void SetTaskFlag(uint8_t TaskID, uint8_t Flag) {
    if (TaskID < TaskCount) {
        Tasks[TaskID].Flag = Flag;
    }
}

例如，在主循环中动态控制任务的执行：

int main(void) {
    TIM2_Init();

    // 添加任务
    AddTask(Task1, 100, 1, 1); // Task1，每100ms执行一次，状态为运行中，标志为就绪
    AddTask(Task2, 500, 1, 1); // Task2，每500ms执行一次，状态为运行中，标志为就绪

    while (1) {
        // 动态控制任务
        if (some_condition) {
            SetTaskState(0, 0); // 暂停Task1
            SetTaskFlag(0, 0);  // 取消Task1的就绪标志
        } else {
            SetTaskState(0, 1); // 恢复Task1
            SetTaskFlag(0, 1);  // 设置Task1的就绪标志
        }
    }
}
  1. 扩展功能
    可以根据需要扩展任务结构体，例如：
  • 添加任务优先级字段。
    添加任务名称或ID字段。
    添加任务超时机制。
扩展任务结构体
  1. 在任务结构体中增加超时相关的字段，例如：
typedef struct {
    void (*TaskFunction)(void); // 任务函数指针
    uint32_t Interval;          // 任务执行间隔（ms）
    uint32_t LastRun;           // 上次执行时间
    uint8_t State;              // 任务状态（例如：0-未运行，1-运行中）
    uint8_t Flag;               // 任务标志（例如：0-未就绪，1-就绪）
    uint32_t Timeout;           // 任务超时时间（ms）
    uint32_t StartTime;         // 任务开始执行的时间戳
    uint8_t TimeoutFlag;        // 任务超时标志（例如：0-未超时，1-超时）
} Task_t;
  1. 在任务调度中检测超时
    在定时器中断服务程序（ISR）或主循环中，检查任务的执行时间是否超过设定的超时时间。
  • 方法 1：在定时器中断中检测
    在定时器中断中，遍历任务数组，检查任务的执行时间是否超时。
void TIM2_IRQHandler(void) {
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

        static uint32_t Tick = 0;
        Tick++;

        for (uint8_t i = 0; i < TaskCount; i++) {
            // 检查任务是否正在运行
            if (Tasks[i].State == 1 && Tasks[i].Flag == 1) {
                // 检查任务是否超时
                if (Tick - Tasks[i].StartTime > Tasks[i].Timeout) {
                    Tasks[i].TimeoutFlag = 1; // 标记任务超时
                    Tasks[i].State = 0;       // 停止任务
                    printf("Task %d timeout!\n", i);
                }
            }

            // 正常调度任务
            if (Tasks[i].Flag == 1 && Tasks[i].State == 1) {
                if (Tick - Tasks[i].LastRun >= Tasks[i].Interval) {
                    Tasks[i].StartTime = Tick; // 记录任务开始时间
                    Tasks[i].TaskFunction();   // 执行任务
                    Tasks[i].LastRun = Tick;   // 更新上次执行时间
                }
            }
        }
    }
}
  • 方法 2：在主循环中检测
    在主循环中，定期检查任务的执行时间是否超时.
int main(void) {
    TIM2_Init();

    // 添加任务
    AddTask(Task1, 100, 1, 1, 500); // Task1，每100ms执行一次，超时时间为500ms
    AddTask(Task2, 500, 1, 1, 1000); // Task2，每500ms执行一次，超时时间为1000ms

    while (1) {
        static uint32_t LastCheckTime = 0;
        uint32_t CurrentTime = GetSystemTick(); // 获取当前系统时间

        // 每隔一段时间检查任务超时
        if (CurrentTime - LastCheckTime >= 100) { // 每100ms检查一次
            LastCheckTime = CurrentTime;

            for (uint8_t i = 0; i < TaskCount; i++) {
                if (Tasks[i].State == 1 && Tasks[i].Flag == 1) {
                    if (CurrentTime - Tasks[i].StartTime > Tasks[i].Timeout) {
                        Tasks[i].TimeoutFlag = 1; // 标记任务超时
                        Tasks[i].State = 0;       // 停止任务
                        printf("Task %d timeout!\n", i);
                    }
                }
            }
        }
    }
}
  1. 添加任务时初始化超时时间
    在添加任务时，初始化任务的超时时间。
void AddTask(void (*TaskFunction)(void), uint32_t Interval, uint8_t State, uint8_t Flag, uint32_t Timeout) {
    if (TaskCount < MAX_TASKS) {
        Tasks[TaskCount].TaskFunction = TaskFunction;
        Tasks[TaskCount].Interval = Interval;
        Tasks[TaskCount].LastRun = 0;
        Tasks[TaskCount].State = State;
        Tasks[TaskCount].Flag = Flag;
        Tasks[TaskCount].Timeout = Timeout;
        Tasks[TaskCount].StartTime = 0;
        Tasks[TaskCount].TimeoutFlag = 0;
        TaskCount++;
    }
}
  1. 处理超时任务
    当检测到任务超时时，可以根据需求采取以下措施：
  • 停止任务并记录错误日志。
    重启任务。
    触发系统复位或报警。
void HandleTimeoutTasks(void) {
    for (uint8_t i = 0; i < TaskCount; i++) {
        if (Tasks[i].TimeoutFlag == 1) {
            printf("Task %d timeout! Taking corrective action...\n", i);
            Tasks[i].TimeoutFlag = 0; // 清除超时标志
            Tasks[i].State = 1;       // 重启任务
            Tasks[i].StartTime = GetSystemTick(); // 读取系统滴答定时器，重置任务开始时间
        }
    }
}

在主循环中调用该函数：

int main(void) {
    TIM2_Init();

    // 添加任务
    AddTask(Task1, 100, 1, 1, 500); // Task1，每100ms执行一次，超时时间为500ms
    AddTask(Task2, 500, 1, 1, 1000); // Task2，每500ms执行一次，超时时间为1000ms

    while (1) {
        HandleTimeoutTasks(); // 处理超时任务
    }
}
STM32全链路开发实战教程专栏总目录（2022.10.19更新）
Mculover666的博客（嵌入式）
09-19 5760
本教程专注于IoT领域开发，内容用五个字概括：**从裸机到云端**。
STM32 | 分享一个简单易用的单片机裸机程序模板，附代码实例分析！
嵌入式大杂烩
08-25 4856
前言 前不久，我有位做测试的朋友转去做开发的工作，面试遇到了一个问题，他没明白，打电话问了我。题目大概就是：在单片机裸机开发时，单片机要处理多个任务，此时你的程序框架是怎样的呢？这其实是...
MultiTimer 可无限扩展的定时器移植使用
m0_37202877的博客
02-21 409
MultiTimer 可无限扩展的定时器。记录下移植使用过程。
多任务定时器
01-09
多任务定时器
Timer多任务定时器
最新发布
weichaopst的专栏
05-25 258
参考 sample/usecase 目录中的示例代码实现定时任务。运行 sample/gtest 中的单元测试验证功能。部分代码如下，完整代码请参考。
使用STM32裸机实现时间轮片法进行多任务调度【单片机篇】
刘老刘的博客
11-15 2102
思路：在定时器中判断各个人物是否到执行时间，如果到了，该任务flag置1，然后主循环判断flag是否为1，为1执行。 END~~
STM32HAL 移植 MultiTimer 极简美开源软件定时器(裸机开发神器)
qq_36075612的博客
04-12 5567
概述 MultiTimer 是一个软件定时器扩展模块，可无限扩展你所需的定时器任务，取代传统的标志位判断方式， 更优雅更便捷地管理程序的时间触发时序。 GitHub：https://github.com/0x1abin/MultiTimer 硬件：STM32F103CBT6最小系统板 软件：Keil 5.29 + STM32CubeMX6.01 一、使用方法 1.先申请一个定时器管理handle struct Timer timer1; 2.初始化定时器对象，注册定时器回调...
推荐使用：MultiTimer - 灵活且强大的多任务定时器模块
gitblog_00030的博客
06-07 674
推荐使用：MultiTimer - 灵活且强大的多任务定时器模块 项目介绍 在嵌入式开发或者任何需要精确时间调度的任务中，MultiTimer 是一个值得您考虑的开源库。它提供了一个无限扩展的定时器框架，能够替代传统的基于标志位的计时方式，让您的代码更加整洁，时间触发逻辑更加优雅和高效。 项目技术分析 MultiTimer 基于面向对象的设计思想，允许开发者创建多个独立的定时器实例，并设置各自不同...
stm32如何用链表 中断实现裸机多任务调度
04-09
裸机多任务调度通常指的是在没有操作系统的情况下，通过时间片轮询或状态机等方式来模拟多任务环境。链表在这里可能用于管理多个任务的结构，而中断则用于定时触发任务切换。 根据用户提供的引用内容，特别是引用[2...
多任务定时器(MultiTaskTimerV2.0) V2.0绿色版
09-13
多任务定时器(MultiTaskTimerV2.0) V2.0绿色版 简单好用，例如用于公司整点报时、定时关机等
多任务定时器(1.1.2.3)版
09-03
关于本软件： 软件名: 多任务倒计时运行程序（包括关机重启注销） 版本 : 1.1.2.2 版 作者 : 王政东 本软件是本人第三个自主完成的windows编程 其间得到了陈烨的无私帮助 在此深表感谢 对程序有任何意见或建议 或者程序运行中有什么问题 欢迎联系我 QQ 290052851 功能说明： 1.0.0.1版 2007-4-28 支持指定日期计时 本软件支持10任务倒计时运行 1.1.1.0版 2007-4-29 支持指定具体倒数时间运行 支持关机前10秒提示以警示用户 1.1.1.2版 2007-4-30 支持切换用户 实现选择性屏幕保护功能 实现窗口的动画效果 实现列表的优化工作 1.1.2.1版 2007-05-09 修正一些 BUG 添加任务栏快捷操作 1.1.2.2版 2007-5-11 完善倒计时显示功能 加入非周末及非假期 预计断电时间前2分钟提示 加入 BEEP声音提示 加入右键菜单 修改按钮效果 郑重声明： 本软件系研究编写 使用中造成一切后果均自负，责任与软件作者无关 我的主页博客 http://www.wsmwzd.cn
多任务定时器 v2.1
11-03
“多任务定时器” 是一款面向任务的、多线程定时软件，可定时执行：播放影音、打开文件、提示信息、关闭进程、更换壁纸、屏保、关机、重启、休眠、注销、待机、关闭显示器、网络校时、语音报时...等任务。可按：整点、半点、经"XX"时间后、每隔"XX"时间、在"XX"日期、在"XX"时刻、 在每周第"XX"天、在每月第"XX"号、在每月倒数"XX"号、在每年"XX"日、 在每天"XX"时刻、在每周的"XX"时刻、在每月的"XX"时刻、在每月倒数"XX"时刻、在每年的"XX"时刻... 等方式进行定时， 并可直观地显示当前所有定时任务的状态和进度,可随时启动或停止指定的定时任务，使用方便,操作简单。由于专门针对定时任务而设计， 因此软件十分精悍，运行时占用内存资源极小(有多小您试用时和同类软件对比一下便知)...，还有，它是绿色软件。
多任务定时器2.1
10-28
超级实用的多任务定时器2.1 1、支持多个定时和倒计时设置 2、支持语音和文字框时间到提示 3、设置简单，操作方便 使你轻松解决各项工作，并行处理无遗漏，做一个高效达人！！！
多任务定时器 2.1_简体中文绿色免费版
01-17
多任务定时器 2.1_简体中文绿色免费版
STM32任务调度 - 时间片/Schedule
dxf1971738522的博客
03-06 1246
基于RT-Thread实现STM32的时间片实时调度
STM32单片机利用软件定时器实现分时多任务（使用HAL库编写）
热门推荐
qq_36075612的博客
04-10 2万+
概述 很多时候，应用场景，是需要分时处理各个事件。本文章就编写点亮LED与打印输出的示例来讲解使用方法。在这直接进入正题。（在此不做创建项目的步骤介绍） 1、STM32CubeIDE 配置 LED管脚配置 串口1配置（也就是debug串口） 2、代码 usart.c文件 /* USER CODE BEGIN 0 */ #include "stdio.h" /* USER...
【嵌入式开源库】MultiTimer 的使用，一款可无限扩展的软件定时器
凉开水白菜的博客
08-10 5390
MultiTimer 是一个软件定时器扩展模块，可无限扩展你所需的定时器任务，取代传统的标志位判断方式， 更优雅更便捷地管理程序的时间触发时序，MultiTimer 的作者和MultiButton 的作者都是0x1abin。本章使用环境：正点原子stm32F4探索者代码工程使用正点原子HAL库 实验8 定时器中断实验配置系统时间基准接口，安装定时器驱动；实例化一个定时器对象；设置定时时间，超时回调处理函数， 用户上下指针，启动定时器；在主循环调用定时器后台处理函数} }......
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值