FreeRTOS_软件定时器

FreeRTOS_软件定时器
FreeRTOS 软件定时器
实验
创建2个任务，start_task、timercontrol_task。

start_stask：创建timercontrol_task任务；创建周期定时器AutoReloadTimer 和单次定时器OneShotTimer；创建⼆值信号量BinarySemaphore。

BinarySemaphore：接收串⼝命名，在中断中释放信号，在timercontrol_task中等待信号量，解析命名，通过不同的命令控制周期定时器AutoReloadTimer和单次定时器OneShotTimer的开启和关闭。

AutoReloadTimer 的回调函数会输出运⾏的次数
OneShotTimer的回电函数会输出运⾏的次数
任务分配：
//任务优先级
#define START_TASK_PRIO 1
//任务堆栈⼤⼩
#define START_STK_SIZE 128
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);
//任务优先级
#define TIMERCONTROL_TASK_PRIO 2
//任务堆栈⼤⼩
#define TIMERCONTROL_STK_SIZE 50
//任务句柄
TaskHandle_t TimerControlTask_Handler;
//任务函数
void timercontrol_task(void *pvParameters);
SemaphoreHandle_t BinarySemaphore_Handle; // ⼆值信号量句柄
TimerHandle_t AutoReloadTimer_Handle ; // 周期定时器句柄
TimerHandle_t OneShotTimer_Handle; // 单次定时器句柄
void AutoReloadTimerCallback(void); // 周期定时器回调函数
void OneShotTimerCallback(void); // 周期定时器回调函数
main() 函数
int main(void)
{
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
delay_init(); //延时函数初始化
uart_init(115200); //初始化串⼝
LED_Init(); //初始化LED
//创建开始任务
xTaskCreate((TaskFunction_t )start_task, //任务函数
(const char* )"start_task", //任务名称
(uint16_t )START_STK_SIZE, //任务堆栈⼤⼩
(void* )NULL, //传递给任务函数的参数
(UBaseType_t )START_TASK_PRIO, //任务优先级
(TaskHandle_t* )&StartTask_Handler); //任务句柄
vTaskStartScheduler(); //开启任务调度
}
命令解析相关函数：
// 将字符串中的⼩写字母转换为⼤写
// str：要转换的字符串
// len：字符串长度
void LowerToCap(u8 *str,u8 len)
{
u8 i;
for(i=0;i<len;i++)
{
if((96<str[i])&&(str[i]<123)) // ⼩写字母
str[i] = str[i]-32; // 转换为⼤写
}
}
// 命令处理函数，将字符串命令转换成命令值
// str：命令
// 返回值：0xFF-命令错误其他值-命令值
u8 CommandProcess(u8 *str)
{
u8 CommandValue = 0xFF;
if(strcmp((char*)str,"KEY1")==0) CommandValue = 1;
else if(strcmp((char*)str,"KEY2")==0) CommandValue = 2;
else if(strcmp((char*)str,"KEY3")==0) CommandValue = 3;
else if(strcmp((char*)str,"KEY4")==0) CommandValue = 4;
return CommandValue;
}
任务函数：
//开始任务任务函数
void start_task(void *pvParameters)
{
taskENTER_CRITICAL(); //进⼊临界区
// 创建⼆值信号量
BinarySemaphore_Handle = xSemaphoreCreateBinary(); // 创建⼆值信号量if(BinarySemaphore_Handle ==NULL)
{
printf("BinarySemaphore Create Failed!\r\n");
}else{
xSemaphoreGive(BinarySemaphore_Handle); // 释放信号量
}
// 创建周期定时器
AutoReloadTimer_Handle = xTimerCreate( (const char *)"AutoReloadTimer", (TickType_t) 1000,
(UBaseType_t) pdTRUE,
(void *) 1,
(TimerCallbackFunction_t)AutoReloadTimerCallback );
if(AutoReloadTimer_Handle == NULL)
{
printf("AutoReloadTimer Created Failed \r\n");
}else{
printf("AutoReloadTimer Created Success \r\n");
}
// 创建单次定时器
OneShotTimer_Handle = xTimerCreate( (const char *)"OneShotTimer",
(TickType_t) 2000,
(UBaseType_t) pdFALSE,
(void *) 2,
(TimerCallbackFunction_t)OneShotTimerCallback );
if(OneShotTimer_Handle == NULL)
{
printf("OneShotTimer Created Failed \r\n");
}else{
printf("OneShotTimer Created Success \r\n");
}
//创建TIMECONTRFOL任务
xTaskCreate((TaskFunction_t )timercontrol_task,
(const char* )"timercontrol_task",
(uint16_t )TIMERCONTROL_STK_SIZE,
(void* )NULL,
(UBaseType_t )TIMERCONTROL_TASK_PRIO,
(TaskHandle_t* )&TimerControlTask_Handler);
vTaskDelete(StartTask_Handler); //删除开始任务
taskEXIT_CRITICAL(); //退出临界区
}
//TIMERCONTROL任务函数
void timercontrol_task(void *pvParameters)
{
u8 len = 0;
u8 CommandValue = 0xFF;
u8 CommandStr[USART_REC_LEN];
BaseType_t err;
while(1)
{
xSemaphoreTake( BinarySemaphore_Handle, portMAX_DELAY ); // 死等
len = USART_RX_STA&0x3fff; // 得到此次接收到的数据长度 sprintf((char *)CommandStr,"%s",USART_RX_BUF); // 装载数据
CommandStr[len] = '\0'; // 加上字符串结尾符号
LowerToCap(CommandStr,len); // 将字符串转换为⼤写
CommandValue = CommandProcess(CommandStr); // 命令解析if(CommandValue != 0xFF) // 接收到正确的命令
{
switch(CommandValue)
{
case1: // 开启周期定时器
err = xTimerStart( AutoReloadTimer_Handle, 0 );
if(err == pdFAIL)
{
printf("AutoReloadTimer Start Failed! \r\n");
}else{
printf("AutoReloadTimer Start Succeed! \r\n");
}
break;
case2: // 关闭周期定时器
err = xTimerStop( AutoReloadTimer_Handle, 0 );
if(err == pdFAIL)
{
printf("AutoReloadTimer Stop Failed! \r\n");
}else{
printf("AutoReloadTimer Stop Succeed! \r\n");
}
break;
case3: // 开启单次定时器
err = xTimerStart( OneShotTimer_Handle, 0 );
if(err == pdFAIL)
{
printf("OneShotTimer Start Failed! \r\n");
}else{
printf("OneShotTimer Start Succeed! \r\n");
}
break;
case4: // 关闭周期定时器
err = xTimerStop( OneShotTimer_Handle, 0 );
if(err == pdFAIL)
{
printf("OneShotTimer Stop Failed! \r\n");
}else{
printf("OneShotTimer Stop Succeed! \r\n");
}
break;
}
}else{
printf("Cmd error!\r\n");
}
USART_RX_STA = 0;
}
}
定时器回调函数：
// 周期定时器回调函数
void AutoReloadTimerCallback(void)
{
static u8 count = 0;
count ++;
printf("AutoReloadTimerCallback running %d timers\r\n",count);
}
// 周期定时器回调函数
void OneShotTimerCallback(void)
{
static u8 count = 0;
count ++;
printf("OneShotTimerCallback running %d timers\r\n",count);
}
串⼝中断初始化和中断处理函数
u8 USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最⼤USART_REC_LEN个字节.
//接收状态
//bit15，接收完成标志
//bit14，接收到0x0d
//bit13~0，接收到的有效字节数⽬
u16 USART_RX_STA=0; //接收状态标记
void uart_init(u32 bound){
//GPIO端⼝设置
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE); //使能USART1，GPIOA时钟 //USART1_TX GPIOA.9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复⽤推挽输出
GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
//USART1_RX GPIOA.10初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输⼊
GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10
//Usart1 NVIC 配置
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=8 ;//抢占优先级3
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //⼦优先级3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器
//USART 初始化设置
USART_ART_BaudRate = bound;//串⼝波特率
USART_ART_WordLength = USART_WordLength_8b;//字长为8位数据格式
USART_ART_StopBits = USART_StopBits_1;//⼀个停⽌位
USART_ART_Parity = USART_Parity_No;//⽆奇偶校验位
USART_ART_HardwareFlowControl = USART_HardwareFlowControl_None;//⽆硬件数据流控制
USART_ART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
USART_Init(USART1, &USART_InitStructure); //初始化串⼝1
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串⼝接受中断
USART_Cmd(USART1, ENABLE); //使能串⼝1
}
extern SemaphoreHandle_t BinarySemaphore_Handle; // ⼆值信号量句柄
void USART1_IRQHandler(void) //串⼝1中断服务程序
{
u8 Res;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾) {
Res =USART_ReceiveData(USART1); //读取接收到的数据
if((USART_RX_STA&0x8000)==0)//接收未完成
{
if(USART_RX_STA&0x4000)//接收到了0x0d
{
if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
else USART_RX_STA|=0x8000; //接收完成了
}
else//还没收到0X0D
{
if(Res==0x0d)USART_RX_STA|=0x4000;
else
{
USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
USART_RX_STA++;
if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收
}
}
}
}
if((BinarySemaphore_Handle != NULL) && (USART_RX_STA&0x8000))
{
xSemaphoreGiveFromISR( BinarySemaphore_Handle, &xHigherPriorityTaskWoken ); // 释放互斥信号量 portYIELD_FROM_ISR(xHigherPriorityTaskWoken); // 如果需要进⾏⼀次任务切换
}
}
#define USART_REC_LEN 20 //定义最⼤接收字节数 200
#define EN_USART1_RX 1 //使能（1）/禁⽌（0）串⼝1接收
extern u8 USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最⼤USART_REC_LEN个字节.末字节为换⾏符
注意：串⼝中断的优先级在FreeRTOS的优先级管理范围内。

运⾏结果：
输⼊KEY1命令，周期定时器开始运⾏，周期性调⽤其回调函数，直到输⼊KEY2命令，停⽌周期定时器，其回调函数不再被调⽤。

输⼊KYE3命令，单次定时器开始运⾏，调⽤其回调函数，只调⽤⼀次，就不再调⽤。

再次输⼊KEY3命令，还是只调其回调函数⼀次。

可以看出，停⽌单次定时器命令KEY4，可以不存在。