FreeRTOS从入门到精通 第十七章（软件定时器）

原创 已于 2025-05-31 00:22:50 修改 · 1.2k 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#单片机 #嵌入式硬件 #FreeRTOS #操作系统 #stm32

于 2025-02-01 03:45:00 首次发布

参考教程：【正点原子】手把手教你学FreeRTOS实时系统_哔哩哔哩_bilibili

一、软件定时器简介

1、定时器的概念与种类

（1）定时器的概念：从指定的时刻开始，经过一个指定时间，然后触发一个超时事件，用户可自定义定时器的周期。

（2）定时器的种类：

①硬件定时器：芯片本身自带的定时器模块，硬件定时器的精度一般很高，每次在定时时间到达之后就会自动触发一个中断，用户在中断服务函数中处理信息。

②软件定时器：具有定时功能的软件，可设置定时周期，当指定时间到达后要调用回调函数（也称超时函数），用户在回调函数中处理信息。

2、软件定时器的优缺点

（1）优点：硬件定时器数量有限，而软件定时器理论上只需有足够内存，就可以创建多个，且使用简单、成本低。

（2）缺点：软件定时器相对硬件定时器来说，精度没有那么高（因为它以系统时钟为基准，系统时钟中断优先级又是最低，容易被打断），对于需要高精度要求的场合，不建议使用软件定时器。

3、FreeRTOS软件定时器

（1）FreeRTOS软件定时器的特点：

①软件定时器是可裁剪可配置的功能，如果要使能软件定时器，需将configUSE_TIMERS配置项配置成1。

②软件定时器支持设置成单次定时器或周期定时器。

（2）软件定时器的超时回调函数是由软件定时器服务任务调用的，软件定时器的超时回调函数本身不是任务，因此不能在该回调函数中使用可能会导致任务阻塞的API函数。

（3）在调用函数vTaskStartScheduler开启任务调度器的时候，会创建一个用于管理软件定时器的任务，这个任务就叫做软件定时器服务任务，其作用有：

①负责软件定时器超时的逻辑判断。

②调用超时软件定时器的超时回调函数。

③处理软件定时器命令队列。

（4）FreeRTOS提供了许多软件定时器相关的API函数，这些API函数大多都是往定时器的队列中写入消息（发送命令），这个队列叫做软件定时器命令队列，是提供给FreeRTOS中的软件定时器使用的，用户是不能直接访问的。

（5）软件定时器的相关配置：

①当FreeRTOS的配置项configUSE_TIMERS设置为1，在启动任务调度器时，会自动创建软件定时器的服务/守护任务prvTimerTask。

②软件定时器服务任务的优先级configTIMER_TASK_PRIORITY需配置为31（最高）。

③定时器的命令队列长度configTIMER_QUEUE_LENGTH需配置为5。

（6）软件定时器的超时回调函数是在软件定时器服务任务中被调用的，服务任务不是专为某个定时器服务的，它还要处理其它定时器，以下是回调函数的一些注意事项：

①回调函数要尽快实行，不能进入阻塞状态，即不能调用那些可能会阻塞任务的API函数。

②访问队列或者信号量的非零阻塞时间的API函数也不能调用。

（7）软件定时器共有两种状态：

①休眠态：软件定时器可以通过其句柄被引用，但因为没有运行，所以其定时超时回调函数不会被执行。（新创建的软件定时器处于休眠状态，也就是未运行的）

②运行态：运行态的定时器，当指定时间到达之后，它的超时回调函数会被调用。

（8）FreeRTOS提供了两种软件定时器：

①单次定时器：单次定时器一旦定时超时，只会执行一次其软件定时器超时回调函数，不会自动重新开启定时，不过可以被手动重新开启。

②周期定时器：周期定时器一旦启动以后就会在执行完回调函数以后自动地重新启动，从而周期地执行其软件定时器回调函数。

（9）软件定时器的状态转换图：

①单次定时器状态转换图：

②周期定时器状态转换图：

二、FreeRTOS软件定时器的结构体与相关API函数

1、软件定时器结构体成员介绍

typedef  struct
{
    const char * 				pcTimerName			//软件定时器名字
    ListItem_t 				xTimerListItem		//软件定时器列表项
    TickType_t 				xTimerPeriodInTicks;  //软件定时器的周期  
    void * 					pvTimerID			//软件定时器的ID
    TimerCallbackFunction_t	pxCallbackFunction; 	//软件定时器的回调函数
    #if ( configUSE_TRACE_FACILITY == 1 )
        UBaseType_t 			uxTimerNumber		//软件定时器的编号，调试用
    #endif
    uint8_t 					ucStatus;             //软件定时器的状态
}xTIMER;

2、软件定时器相关API函数

（1）软件定时器相关API函数概览：

函数

描述

xTimerCreate()

动态方式创建软件定时器

xTimerCreateStatic()

静态方式创建软件定时器

xTimerStart()

开启软件定时器定时

xTimerStartFromISR()

在中断中开启软件定时器定时

xTimerStop()

停止软件定时器定时

xTimerStopFromISR()

在中断中停止软件定时器定时

xTimerReset()

复位软件定时器定时

xTimerResetFromISR()

在中断中复位软件定时器定时

xTimerChangePeriod()

更改软件定时器的定时超时时间

xTimerChangePeriodFromISR()

在中断中更改定时超时时间

（2）xTimerCreate函数：

①函数定义：

TimerHandle_t xTimerCreate
(
    const char * const 		   		pcTimerName,
	const TickType_t 		    	xTimerPeriodInTicks,
	const UBaseType_t 	    	uxAutoReload,
	void * const 			    	pvTimerID,
	TimerCallbackFunction_t     	pxCallbackFunction
);

②函数参数：

形参 

描述

pcTimerName 

软件定时器名

xTimerPeriodInTicks 

定时超时时间，单位：系统时钟节拍

uxAutoReload 

定时器模式， pdTRUE：周期定时器， pdFALSE：单次定时器

pvTimerID 

软件定时器 ID，用于多个软件定时器公用一个超时回调函数

pxCallbackFunction 

软件定时器超时回调函数

③返回值：

形参 

描述

NULL 

软件定时器创建失败

其它值 

软件定时器创建成功，返回其句柄

（3）xTimerStart函数：

①函数定义：

BaseType_t xTimerStart
(
    TimerHandle_t 	xTimer,
	const TickType_t 	xTicksToWait
);

②函数参数：

形参 

描述

xTimer 

待开启的软件定时器的句柄

xTickToWait 

发送命令到软件定时器命令队列的最大等待时间

③返回值：

形参 

描述

pdPASS 

软件定时器开启成功

pdFAIL 

软件定时器开启失败

（4）xTimerStop函数：

①函数定义：

BaseType_t xTimerStop
(
    TimerHandle_t 	xTimer,
	const TickType_t 	xTicksToWait
);

②函数参数：

形参 

描述

xTimer 

待停止的软件定时器的句柄

xTickToWait 

发送命令到软件定时器命令队列的最大等待时间

③返回值：

形参 

描述

pdPASS 

软件定时器停止成功

pdFAIL 

软件定时器停止失败

（5）xTimerReset函数：

①函数定义：

BaseType_t  xTimerReset
(
    TimerHandle_t 	xTimer,
	const TickType_t 	xTicksToWait
);  //复位后的软件定时器以复位时的时刻作为开启时刻重新定时

②函数参数：

形参 

描述

xTimer 

待复位的软件定时器的句柄

xTickToWait 

发送命令到软件定时器命令队列的最大等待时间

③返回值：

形参 

描述

pdPASS 

软件定时器复位成功

pdFAIL 

软件定时器复位失败

（6）xTimerChangePeriod函数：

①函数定义：

BaseType_t  xTimerChangePeriod
(
    TimerHandle_t 		xTimer,
	const TickType_t 	xNewPeriod,
	const TickType_t 	xTicksToWait
);

②函数参数：

形参 

描述

xTimer 

待更新的软件定时器的句柄

xNewPeriod

新的定时超时时间，单位：系统时钟节拍

xTickToWait 

发送命令到软件定时器命令队列的最大等待时间

③返回值：

形参 

描述

pdPASS 

软件定时器定时超时时间更改成功

pdFAIL 

软件定时器定时超时时间更改失败

3、xTimerCreateTimerTask创建软件定时器任务函数内核代码剖析

（1）xTimerCreateTimerTask函数本身：

BaseType_t xTimerCreateTimerTask( void )
{
    BaseType_t xReturn = pdFAIL;

    traceENTER_xTimerCreateTimerTask();

    prvCheckForValidListAndQueue();  //创建当前软件定时器列表和溢出软件定时器列表及命令队列

    if( xTimerQueue != NULL )
    {
        #if ((configNUMBER_OF_CORES >1) && (configUSE_CORE_AFFINITY ==1))
        {
            #if ( configSUPPORT_STATIC_ALLOCATION ==1)
            {
                StaticTask_t * pxTimerTaskTCBBuffer = NULL;
                StackType_t * pxTimerTaskStackBuffer = NULL;
                configSTACK_DEPTH_TYPE uxTimerTaskStackSize;

                vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &uxTimerTaskStackSize );
                xTimerTaskHandle = xTaskCreateStaticAffinitySet( prvTimerTask,
                 configTIMER_SERVICE_TASK_NAME,
                 uxTimerTaskStackSize,
                 NULL,
                 ((UBaseType_t) configTIMER_TASK_PRIORITY)| portPRIVILEGE_BIT,
                 pxTimerTaskStackBuffer,
                 pxTimerTaskTCBBuffer,
                 configTIMER_SERVICE_TASK_CORE_AFFINITY );

                if( xTimerTaskHandle != NULL )
                {
                    xReturn = pdPASS;
                }
            }
            #else /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
            {
				//创建软件定时器服务任务
                xReturn = xTaskCreateAffinitySet( prvTimerTask,
                 configTIMER_SERVICE_TASK_NAME,
                 configTIMER_TASK_STACK_DEPTH,
                 NULL,
                 ((UBaseType_t)configTIMER_TASK_PRIORITY )| portPRIVILEGE_BIT,
                 configTIMER_SERVICE_TASK_CORE_AFFINITY,
                 &xTimerTaskHandle );
            }
            #endif /* configSUPPORT_STATIC_ALLOCATION */
        }
        #else /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */
        {
            #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
            {
                StaticTask_t * pxTimerTaskTCBBuffer = NULL;
                StackType_t * pxTimerTaskStackBuffer = NULL;
                configSTACK_DEPTH_TYPE uxTimerTaskStackSize;

                vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &uxTimerTaskStackSize );
                xTimerTaskHandle = xTaskCreateStatic( prvTimerTask,
                 configTIMER_SERVICE_TASK_NAME,
                 uxTimerTaskStackSize,
                 NULL,
                 ((UBaseType_t)configTIMER_TASK_PRIORITY )| portPRIVILEGE_BIT,
                 pxTimerTaskStackBuffer,
                 pxTimerTaskTCBBuffer );

                if( xTimerTaskHandle != NULL )
                {
                    xReturn = pdPASS;
                }
            }
            #else /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
            {
                xReturn = xTaskCreate( prvTimerTask,
                 configTIMER_SERVICE_TASK_NAME,
                 configTIMER_TASK_STACK_DEPTH,
                 NULL,
                 ((UBaseType_t)configTIMER_TASK_PRIORITY) | portPRIVILEGE_BIT,
                 &xTimerTaskHandle );
            }
            #endif /* configSUPPORT_STATIC_ALLOCATION */
        }
        #endif /* #if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) ) */
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }

    configASSERT( xReturn );

    traceRETURN_xTimerCreateTimerTask( xReturn );

    return xReturn;
}

（2）prvCheckForValidListAndQueue函数：负责创建当前软件定时器列表和溢出软件定时器列表及命令队列。

static void prvCheckForValidListAndQueue( void )
{
    taskENTER_CRITICAL();
    {
        if( xTimerQueue == NULL )
        {
            vListInitialise( &xActiveTimerList1 );    //初始化定时器列表1
            vListInitialise( &xActiveTimerList2 );    //初始化定时器列表2
            pxCurrentTimerList = &xActiveTimerList1;  //将定时器列表1赋给当前软件定时器列表
            pxOverflowTimerList = &xActiveTimerList2; //将定时器列表2赋给溢出软件定时器列表

            #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
            {
                PRIVILEGED_DATA static StaticQueue_t xStaticTimerQueue;
                PRIVILEGED_DATA static uint8_t ucStaticTimerQueueStorage[ ( size_t ) configTIMER_QUEUE_LENGTH * sizeof( DaemonTaskMessage_t ) ];

				//创建命令队列
                xTimerQueue = xQueueCreateStatic( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, ( UBaseType_t ) sizeof( DaemonTaskMessage_t ), &( ucStaticTimerQueueStorage[ 0 ] ), &xStaticTimerQueue );
            }
            #else
            {
				//创建命令队列
                xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, ( UBaseType_t ) sizeof( DaemonTaskMessage_t ) );
            }
            #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */

            #if ( configQUEUE_REGISTRY_SIZE > 0 )
            {
                if( xTimerQueue != NULL )
                {
                    vQueueAddToRegistry( xTimerQueue, "TmrQ" );
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            #endif /* configQUEUE_REGISTRY_SIZE */
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    taskEXIT_CRITICAL();
}

（3）prvTimerTask函数：软件定时器服务任务。

static portTASK_FUNCTION( prvTimerTask, pvParameters )
{
    TickType_t xNextExpireTime;
    BaseType_t xListWasEmpty;

    ( void ) pvParameters;

    #if ( configUSE_DAEMON_TASK_STARTUP_HOOK == 1 )
    {
        vApplicationDaemonTaskStartupHook();
    }
    #endif /* configUSE_DAEMON_TASK_STARTUP_HOOK */

    for( ; configCONTROL_INFINITE_LOOP(); )
    {
        //获取下一个超时的软件定时器
        xNextExpireTime = prvGetNextExpireTime( &xListWasEmpty );

        //判断所获得的定时器是否超时，如超时则调用超时回调函数
        prvProcessTimerOrBlockTask( xNextExpireTime, xListWasEmpty );

        //接收命令队列的一条命令并执行之
        prvProcessReceivedCommands();
    }
}

（4）prvProcessTimerOrBlockTask函数：判断定时器是否超时。

static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime,
                                        BaseType_t xListWasEmpty )
{
    TickType_t xTimeNow;
    BaseType_t xTimerListsWereSwitched;

    vTaskSuspendAll();
    {
        xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );

        if( xTimerListsWereSwitched == pdFALSE )
        {
            if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) ) //判断定时器是否超时
            {
                ( void ) xTaskResumeAll();
                prvProcessExpiredTimer( xNextExpireTime, xTimeNow );  //超时，调用回调函数
            }
            else
            {
                if( xListWasEmpty != pdFALSE )
                {
                    xListWasEmpty = listLIST_IS_EMPTY( pxOverflowTimerList );
                }

                vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ), xListWasEmpty );

                if( xTaskResumeAll() == pdFALSE )
                {
                    taskYIELD_WITHIN_API();
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
        }
        else
        {
            ( void ) xTaskResumeAll();
        }
    }
}

（5）prvProcessExpiredTimer函数：定时器超时后将调用一次该函数。

static void prvProcessExpiredTimer( const TickType_t xNextExpireTime,
                                    const TickType_t xTimeNow )
{
    Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );

    (void)uxListRemove(&(pxTimer->xTimerListItem));  //将定时器移出软件定时器列表

    if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0U )  //如果是周期定时器列表
    {
        prvReloadTimer( pxTimer, xNextExpireTime, xTimeNow ); //将定时器插回软件定时器列表
    }
    else
    {
        pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE ); //将对应位清零
    }

    traceTIMER_EXPIRED( pxTimer );
    pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );  //调用超时回调函数
}

（6）vQueueWaitForMessageRestricted函数：

void vQueueWaitForMessageRestricted( QueueHandle_t xQueue,
                                     TickType_t xTicksToWait,
                                     const BaseType_t xWaitIndefinitely )
{
    Queue_t * const pxQueue = xQueue;

    traceENTER_vQueueWaitForMessageRestricted( xQueue, xTicksToWait, xWaitIndefinitely );

    prvLockQueue( pxQueue );

    if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0U )   //判断命令队列的非空闲项数目是否为0
    {
        //将软件定时器服务任务挂到等待接收列表
        vTaskPlaceOnEventListRestricted( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait, xWaitIndefinitely );
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }

    prvUnlockQueue( pxQueue );

    traceRETURN_vQueueWaitForMessageRestricted();
}

三、FreeRTOS软件定时器实验

1、原理图与实验目标

（1）原理图：

（2）实验目标：

①设计2个任务——start_task、task1：

[1]start_task：用于创建task1任务，创建两个定时器并启动之（分别为单次和周期型，其回调函数中分别需要翻转LED1和LED2的状态）。

[2]task1：用于按键扫描，并对两个软件定时器进行开启、停止操作，按下按键1即开始两个软件定时器，按下按键2反之。

②预期实验现象：

[1]程序下载到板子上后，LED1灯状态仅变更一次，LED2灯持续闪烁。

[2]按下按键2，LED1和LED2状态冻结。

[3]按下按键1，LED1灯状态仅变更一次，LED2恢复持续闪烁。

2、实验步骤

（1）将“任务创建和删除的动态方法实验”的工程文件夹复制一份，在拷贝版中进行实验。

（2）在FreeRTOSConfig.h文件中将宏configUSE_TIMERS配置为1，将宏configTIMER_TASK_PRIORITY配置为31，将宏configTIMER_QUEUE_LENGTH配置为5，将宏configTIMER_TASK_STACK_DEPTH配置为256。

#define configUSE_TIMERS              1   //使能软件定时器
#define configTIMER_TASK_PRIORITY   31 //软件定时器服务任务的优先级配置为最高
#define configTIMER_QUEUE_LENGTH   5   //定时器的命令队列长度配置为5
#define configTIMER_TASK_STACK_DEPTH  256   //软件定时器服务任务的栈深度

（3）删除FreeRTOS_experiment.c文件中关于task2和task3的内容，在start_task中创建一个单次定时器和周期定时器，并为它们分别编写回调函数，同时更改task1函数的具体实现，然后添加头文件timers.h，如下所示。

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "timers.h"

//宏定义
#define START_TASK_STACK_SIZE 128   //start_task任务的堆栈大小
#define START_TASK_PRIO       1     //start_task任务的优先级
#define TASK1_STACK_SIZE      128   //task1任务的堆栈大小
#define TASK1_PRIO             2     //task1任务的优先级

//任务函数声明
void start_task(void);
void task1(void);

//任务句柄
TaskHandle_t start_task_handler;    //start_task任务的句柄
TaskHandle_t task1_handler;       //task1任务的句柄

//定时器回调函数
void timer1_callback(TimerHandle_t pxTimer);
void timer2_callback(TimerHandle_t pxTimer);

void FreeRTOS_Test(void)
{
	//创建任务start_task
	xTaskCreate((TaskFunction_t)start_task,           //指向任务函数的指针
				"start_task",                      //任务名字
				START_TASK_STACK_SIZE,       //任务堆栈大小，单位为字
				NULL,                           //传递给任务函数的参数
				START_TASK_PRIO,               //任务优先级
				(TaskHandle_t *) &start_task_handler  //任务句柄，就是任务的任务控制块
				);
	
	//开启任务调度器
	vTaskStartScheduler();
}

TimerHandle_t timer1_handle;    //单次定时器句柄
TimerHandle_t timer2_handle;    //周期定时器句柄
void start_task(void)
{
	taskENTER_CRITICAL();
	
	//创建任务task1
	xTaskCreate((TaskFunction_t)task1,             //指向任务函数的指针
				"task1",                        //任务名字
				TASK1_STACK_SIZE,           //任务堆栈大小，单位为字
				NULL,                        //传递给任务函数的参数
				TASK1_PRIO,                  //任务优先级
				(TaskHandle_t *) &task1_handler   //任务句柄，就是任务的任务控制块
				);
	//创建单次定时器timer1
    timer1_handle = xTimerCreate("timer1", 500, pdFALSE, (void *)1, timer1_callback );
                            
    //创建周期定时器timer2
    timer2_handle = xTimerCreate("timer2", 1000, pdTRUE, (void *)2, timer2_callback );
	
	//启动两个定时器
	xTimerStart(timer1_handle,portMAX_DELAY);
    xTimerStart(timer2_handle,portMAX_DELAY);
	
	vTaskDelete(NULL);
	
	taskEXIT_CRITICAL();
}

void task1(void)
{
	uint8_t key = 0;
    while(1) 
    {
        key = Key_GetNum();
        if(key == 1)
        {
            xTimerStart(timer1_handle,portMAX_DELAY);
            xTimerStart(timer2_handle,portMAX_DELAY);
        }
		else if(key == 2)
        {
            xTimerStop(timer1_handle,portMAX_DELAY);
            xTimerStop(timer2_handle,portMAX_DELAY);
        }
        vTaskDelay(10);
    }
}

/* timer1的超时回调函数 */
void timer1_callback( TimerHandle_t pxTimer )
{
    LED1_Turn();
}

/* timer2的超时回调函数 */
void timer2_callback( TimerHandle_t pxTimer )
{
    LED2_Turn();
}

（4）程序完善好后点击“编译”，然后将程序下载到开发板上。

FreeRTOS——定时器
bug_love的博客
01-09 1401
软件定时器的精度和准确性受到系统时钟的影响，通常适用于对时间要求不太严格的应用场景。硬件定时器常用于实时操作系统、嵌入式系统和实时应用中，能够提供可靠的定时功能和高精度的时间触发。在非自动重载模式下，定时器只会触发一次，在到期时停止计时，不会自动重新启动。定时器是计算机系统中的一种常用工具，用于在指定的时间间隔或延迟后执行特定的任务或操作。在自动重载模式下，定时器在每次到期后会自动重新启动，以便周期性地触发任务或回调函数的执行。回到定时器周期描述上来说，简单来说，操作系统数多少下，执行1次回调函数。
FreeRTOS（软件定时器）
m0_70987863的博客
07-25 1153
FreeRTOS（软件定时器）
FreeRTOS软件定时器
weixin_49038319的博客
04-29 1434
说明本文章基于百问网RTOS教程文档。
FreeRTOS笔记（九）定时器
m0_58575472的博客
06-08 672
软件定时器是基于系统时钟中断且由软件来模拟的定时器，当经过设定的Tick 时钟计数值后会触发用户定义的回调函数。软件定时器不占用单片机宝贵的硬件资源和CPU资源。FreeRTOS提供了完善的软件定时器的支持，为了启用软件定时器，需要在头文件中设置的值为1.软件定时器需要定时或者延时控制的函数称为函数的返回值是空类型，xTimer的参数是软件定时器的句柄。
软件定时器——FreeRTOS
最新发布
2401_83175899的博客
11-12 1126
软件定时器是由 FreeRTOS 内核通过硬件定时器中断作为时基，在软件层面实现的定时功能。
FreeRTOS学习篇八：软件定时器
weixin_45647341的博客
09-12 1605
FreeRTOS的软件定时器的基本概念、常用函数，以及使用示例。
100 篇文章精通 STM32F103（第 17 篇）：FreeRTOS 入门与多任务并发实战
CGlgq123的博客
10-29 280
CubeIDE 会在main.c// 温湿度数据（模拟）// 队列句柄（自动生成，在freertos.c中定义，需声明为外部变量）FreeRTOS 通过任务调度器实现多任务并发，高优先级任务可抢占低优先级任务，确保实时性；基于 STM32CubeIDE 的移植无需手动下载源码，通过图形化界面可快速创建任务、队列；实操中实现了 “传感器采样→数据通信→串口打印→LED 指示” 的三任务并发，验证了 FreeRTOS 的优势。
51单片机入门到精通——c语言篇
2401_83921466的博客
09-01 5453
在深入理解了AT89C51微控制器的编程之后，接下来要学习的是嵌入式系统的整体设计与架构。在掌握了AT89C51的基本设计与开发之后，可以进一步学习更高级的微控制器，如ARM系列，以及更复杂的嵌入式操作系统，如Linux、RTOS等。嵌入式系统是一个快速发展的领域，持续学习新技术、新工具、新理论是必要的。：设计一个基于AT89C51的温度监测系统，系统能够实时监测环境温度，并通过LED灯或蜂鸣器进行报警。：学习如何提高系统的可靠性，包括冗余设计、错误检测与恢复、故障隔离等。
freeRTOS从入门到进阶提升系列教程：入门文档+视频教程+进阶视频教程(全部免费的freeRTOS系列教程、freeRTOS学习路线)
挨踢民工的博客
12-21 3720
本教程是freeRTOS的系统教程，学完之后可达到中高级freeRTOS工程水平。教程分为三部分：学前知识普及->初级文档教程->进阶(高级)视频教程......
裸机嵌入式C编程：从入门到精通
从编写基础代码到掌握底层固件开发，这一过程虽具挑战性，但回报丰厚。嵌入式系统就像现代科技背后默默耕耘的引擎，无论是家用电器、工业控制系统还是复杂的物联网设备，都离不开它。 ## 2 裸机编程概述 裸机编程是...
【ESP32电机控制从入门到精通】：揭秘10大核心技巧与实战案例
[【ESP32电机控制从入门到精通】：揭秘10大核心技巧与实战案例](https://img-blog.csdnimg.cn/6ef6d8f8b2d842ac888f01f1ce163784.png) # 1. ESP32电机控制入门基础 ESP32作为一款集Wi-Fi与蓝牙于一体的高性能微控制...
FreeRTOS的定时器
2301_80899620的博客
07-04 2107
FreeRTOS定时器的创建，使用。
FreeRTOS定时器
caiji0169的博客
06-14 1880
讲解freertos的定时器，包括特性、运行环境（守护任务、回调函数、内部源码实现）、和linux的定时器进行比较，讲解内部是如何去标记定时器的，还有数据传输、相关的操作函数。讲解相关示例：一般使用和定时器防抖
FreeRTOS 定时器
cxtian55555的博客
04-24 1684
定时器的使用与定时器任务(Tmr Svc)服务的理解.freertos的定时器功能是用task实现的，但是其命令却是用队列queue实现的.一旦别的task中发送xMessage，可以导致prvTimerTask立刻从pxDelayedTaskList（等待列表）中加入pxReadyTasksLists（就绪列表）.由于Daemon优先级最高，因此可以立刻执行到prvTimerTask，通过接收xMessage的函数，根据xMessage.xMessageID，具体来处理命令。
FreeRTOS 软件定时器
longjingcha110的博客
04-13 501
系统节拍配置宏 configTICK_RATE_HZ, 即1S能跳动多少下, 软件定时器的运作机制. FreeRTOS 采用两个定时器列表维护软件定时器, pxCurrentTimerList 与 pxOverflowTimerList是列表指针, 在初始化的时候分别指向 xActiveTimerList1 与 xActiveTimerList2 pxCurrentTimerList: 系统将新创建的定时器以超时时间升序的方式插到 此链表中, 系统在定时任务中扫描 此链表的第一个定时器查看是否已经超时,
移植FreeRTOS软件定时器到单片机应用
标题“从FreeRTOS移植而来软件定时器，所有接口和FreeRTOS一致，可用于没有跑系统的单片机中”中涉及的知识点包括： 1. FreeRTOS移植：FreeRTOS是一个广泛应用于嵌入式系统中的实时操作系统（RTOS），提供时间管理...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Zevalin爱灰灰

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

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

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

打赏作者

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

抵扣说明：

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

余额充值