RTOS中软件定时器的简单应用

? ? ? 我们在stm32f103c8t6单片机上验证RTOS中软件定时器的简单应用，利用stm32cube进行RTOS的配置。裸机的时钟源默认是 SysTick，但是开启 FreeRTOS 后，FreeRTOS会占用 SysTick （用来生成1ms 定时，用于任务调度），所以我们开启TIM2当做裸机的时钟源，为其他总线提供另外的时钟源。

验证的功能比较简单，选择V1 版本的内核完全够用。

一、验证的思路以及需要使用的函数及简单介绍

1.验证思路

创建 1 个任务：Task。

任务要求如下：

在任务里可以要开启循和单次定时器，单次定时器开启1秒后发送” 栋哥帅吗?”循环定时器每隔两秒发送”帅”。

2.需要用到的函数

创建软件定时器

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

pcTimerName：软件定时器名称

xTimerPeriodInTicks：定时超时时间，单位：系统时钟节拍。宏 pdMS_TO_TICKS() 可用于将以毫秒为单位指定的时间转换为以 tick 为单位指定的时间。

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

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

pxCallbackFunction：软件定时器超时回调函数

返回值：成功：定时器句柄，失败：NULL

开启软件定时器

BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xBlockTime );

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

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

返回值： pdPASS：开启成功 pdFAIL：开启失败

更改软件定时器定时时间

BaseType_t xTimerChangePeriod( TimerHandle_t xTimer, TickType_t xNewPeriod, TickType_t xBlockTime );

xTimer：定时器句柄

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

xBlockTime：阻塞时间

3. 简单介绍

定时器是一个可选的、不属于 FreeRTOS 内核的功能，它是由定时器服务任务来提供的。 在调用函数 vTaskStartScheduler() 开启任务调度器的时候，会创建一个用于管理软件定时器的任务，这个任务就叫做软件定时器服务任务。

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

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

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

FreeRTOS提供了很多定时器有关的API函数，这些API函数大多都使用FreeRTOS的队列发送命令给定时器服务任务。这个队列叫做定时器命令队列。定时器命令队列是提供给FreeRTOS的软件定时器使用的，用户不能直接访问！

也就是说我们的API函数是不能直接控制定时器的，他需要一步一步的转化。

软件定时器有一个定时器服务任务和定时器命令队列，这两个东西肯定是要配置的，相关的配置 也是放到文件FreeRTOSConfig.h中的，涉及到的配置如下：

①configUSE_TIMERS 如果要使用软件定时器的话宏configUSE_TIMERS一定要设置为1，当设置为1的话定时器服务任务就会在启动FreeRTOS调度器的时候自动创建。

②configTIMER_TASK_PRIORITY 设置软件定时器服务任务的任务优先级，可以为0~(configMAX_PRIORITIES-1)。优先级一定要根据实际的应用要求来设置。如果定时器服务任务的优先级设置的高的话，定时器命令队列中的命 令和定时器回调函数就会及时的得到处理。

③configTIMER_QUEUE_LENGTH 此宏用来设置定时器命令队列的队列长度。

④configTIMER_TASK_STACK_DEPTH 此宏用来设置定时器服务任务的任务堆栈大小。

定时器服务任务和定时器命令队列我们会在stm32cube里直接配置并生成代码。

二、stm32cube的配置

SYS

RCC

RTOS

在Software timer definitions里选择USE_TIMERS,使能Enable。这样才可以在Timers and Semaphores中开启Timers。软件定时器服务任务的任务优先级(configTIMER_TASK_PRIORITY)，队列长度(configTIMER_QUEUE_LENGTH)，定时器服务任务的任务堆栈大小(configTIMER_TASK_STACK_DEPTH),保持默认。

这里我们开启了两个定时器，在Type里分别选择循环模式和单次模式。

开启任务，配置如下所示

三、代码部分

usart.c

#include "stdio.h"

int fputc(int ch, FILE *f)

{?????

?????? unsigned char temp[1]={ch};

?????? HAL_UART_Transmit(&huart1,temp,1,0xffff);?

?????? return ch;

}

同时打开“魔术棒”，勾选Use MicroLIB,点击OK。这样就可以进行串口打印了。

freertos.c

#include "FreeRTOS.h"

#include "task.h"

#include "main.h"

#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/

/* USER CODE BEGIN Includes */

#include "stdio.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/

/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/

/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/

/* USER CODE BEGIN PM */

/* USER CODE END PM */

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

/* USER CODE BEGIN Variables */

/* USER CODE END Variables */

osThreadId TaskHandle;

osTimerId xunhuanTimerHandle;

osTimerId danciTimerHandle;

/* Private function prototypes -----------------------------------------------*/

/* USER CODE BEGIN FunctionPrototypes */

/* USER CODE END FunctionPrototypes */

void StartTask(void const * argument);

void Callback01(void const * argument);

void Callback02(void const * argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* GetIdleTaskMemory prototype (linked to static allocation support) */

void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );

/* GetTimerTaskMemory prototype (linked to static allocation support) */

void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize );

/* USER CODE BEGIN GET_IDLE_TASK_MEMORY */

static StaticTask_t xIdleTaskTCBBuffer;

static StackType_t xIdleStack[configMINIMAL_STACK_SIZE];

void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )

{

? *ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer;

? *ppxIdleTaskStackBuffer = &xIdleStack[0];

? *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;

? /* place for user code */

}

/* USER CODE END GET_IDLE_TASK_MEMORY */

/* USER CODE BEGIN GET_TIMER_TASK_MEMORY */

static StaticTask_t xTimerTaskTCBBuffer;

static StackType_t xTimerStack[configTIMER_TASK_STACK_DEPTH];

void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize )

{

? *ppxTimerTaskTCBBuffer = &xTimerTaskTCBBuffer;

? *ppxTimerTaskStackBuffer = &xTimerStack[0];

? *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;

? /* place for user code */

}

/* USER CODE END GET_TIMER_TASK_MEMORY */

/**

? * @brief? FreeRTOS initialization

? * @param? None

? * @retval None

? */

void MX_FREERTOS_Init(void) {

? /* USER CODE BEGIN Init */

? /* USER CODE END Init */

? /* USER CODE BEGIN RTOS_MUTEX */

? /* add mutexes, ... */

? /* USER CODE END RTOS_MUTEX */

? /* USER CODE BEGIN RTOS_SEMAPHORES */

? /* add semaphores, ... */

? /* USER CODE END RTOS_SEMAPHORES */

? /* Create the timer(s) */

? /* definition and creation of xunhuanTimer */

? osTimerDef(xunhuanTimer, Callback01);

? xunhuanTimerHandle = osTimerCreate(osTimer(xunhuanTimer), osTimerPeriodic, NULL);

? /* definition and creation of danciTimer */

? osTimerDef(danciTimer, Callback02);

? danciTimerHandle = osTimerCreate(osTimer(danciTimer), osTimerOnce, NULL);

? /* USER CODE BEGIN RTOS_TIMERS */

? /* start timers, add new ones, ... */

? /* USER CODE END RTOS_TIMERS */

? /* USER CODE BEGIN RTOS_QUEUES */

? /* add queues, ... */

? /* USER CODE END RTOS_QUEUES */

? /* Create the thread(s) */

? /* definition and creation of Task */

? osThreadDef(Task, StartTask, osPriorityNormal, 0, 128);

? TaskHandle = osThreadCreate(osThread(Task), NULL);

? /* USER CODE BEGIN RTOS_THREADS */

? /* add threads, ... */

? /* USER CODE END RTOS_THREADS */

}

/* USER CODE BEGIN Header_StartTask */

/**

? * @brief? Function implementing the Task thread.

? * @param? argument: Not used

? * @retval None

? */

/* USER CODE END Header_StartTask */

void StartTask(void const * argument)

{

? /* USER CODE BEGIN StartTask */

?????? osTimerStart(xunhuanTimerHandle, 2000);

osTimerStart(danciTimerHandle, 1000);

? /* Infinite loop */

? for(;;)

? {

??? osDelay(1);

? }

? /* USER CODE END StartTask */

}

/* Callback01 function */

void Callback01(void const * argument)

{

? /* USER CODE BEGIN Callback01 */

printf("帅\r\n");

? /* USER CODE END Callback01 */

}

/* Callback02 function */

void Callback02(void const * argument)

{

? /* USER CODE BEGIN Callback02 */

printf("栋哥帅吗?\r\n");

? /* USER CODE END Callback02 */

}

但是因为我们使用的是STM32cube，所以无论是创建，还是开启，这些函数都被封装过了，这样的话，我们使用就比较简单了，当然你也可以替换成我们文章开始的函数。

创建

osTimerDef(xunhuanTimer, Callback01);

xunhuanTimerHandle = osTimerCreate(osTimer(xunhuanTimer), osTimerPeriodic, NULL);

开启

osTimerStart(xunhuanTimerHandle, 2000);如果你觉得stm32自己生成的看着不爽，你也可以用文章开头写的函数，比如修改成xTimerStart(xunhuanTimerHandle, 2000);效果一样。

如果你想要更改软件定时器定时时间

可以再StartTask（）函数里开启定时器之后使用

xTimerChangePeriod(xunhuanTimerHandle, pdMS_TO_TICKS(1000), 0);来完成时间的修改。

xunhuanTimerHandle是定时器的句柄；pdMS_TO_TICKS(1000) 可用于将以毫秒为单位指定的时间转换为以 tick 为单位指定的时间；0代表阻塞时间为0.

连接串口助手，如下图所示