根据正点原子FreeRTOS视频整理
单片机：STM32F207VC
FreeRTOS源码版本：v10.0.1
任务相关API函数：
1. main.c
/*
*
*/
#include "main.h"
#include "delay.h"
#include "sys.h"
#include "usart.h" #include "stm32f2xx_gpio.h" #include "FreeRTOS.h"
#include "task.h" #define START_TASK_PRIO 1 /*任务优先级*/
#define START_STK_SIZE 128 /*任务堆栈大小*/
TaskHandle_t StartTask_Handle; /*任务句柄*/
void StartTask(void *pvParameters); /*任务函数*/ #define LED_TASK_PRIO 2
#define LED_STK_SIZE 128
TaskHandle_t LedTask_Handle;
void LedTask(void *pvParameters); #define QUERY_TASK_PRIO 3
#define QUERY_STK_SIZE 256
TaskHandle_t QueryTask_Handle;
void QueryTask(void *pvParameters); char InfoBuffer[]; /*保存信息的数组*/ /***** 声明 *****/
static void SystemInitial(void);
static void GPIO_LED_Configuration(void); static void GPIO_LED_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE); GPIO_InitStructure.GPIO_Pin = LED_POWER | LED_RUN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOE, &GPIO_InitStructure); LED_Power_On();
GPIO_SetBits(GPIOE, LED_RUN);
} void StartTask(void *pvParameters)
{
taskENTER_CRITICAL(); /*进入临界区*/ xTaskCreate((TaskFunction_t )LedTask, /*任务函数*/
(const char * )"LedTask", /*任务名称*/
(uint16_t )LED_STK_SIZE, /*任务堆栈大小*/
(void * )NULL, /*传递给任务函数的参数*/
(UBaseType_t )LED_TASK_PRIO, /*任务优先级*/
(TaskHandle_t )&LedTask_Handle); /*任务句柄*/ xTaskCreate((TaskFunction_t )QueryTask, /*任务函数*/
(const char * )"QueryTask", /*任务名称*/
(uint16_t )QUERY_STK_SIZE, /*任务堆栈大小*/
(void * )NULL, /*传递给任务函数的参数*/
(UBaseType_t )QUERY_TASK_PRIO, /*任务优先级*/
(TaskHandle_t )&QueryTask_Handle); /*任务句柄*/ vTaskDelete(StartTask_Handle); /*删除开始任务*/
taskEXIT_CRITICAL(); /*退出临界区*/
} void LedTask(void *pvParameters)
{
while ()
{
GPIOE->ODR ^= LED_RUN;
vTaskDelay();
}
} void QueryTask(void * pvParameters)
{
UBaseType_t x;
/*1. 函数uxTaskPriorityGet()的使用*/
printf("/*********** 1. 函数uxTaskPriorityGet()的使用 ***********/\r\n");
x = uxTaskPriorityGet(LedTask_Handle);
printf("函数LedTask的优先级是%ld\r\n", x);
x = uxTaskPriorityGet(QueryTask_Handle);
printf("函数QueryTask的优先级是%ld\r\n", x);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*2. 函数vTaskPrioritySet()的使用*/
printf("/*********** 2. 函数vTaskPrioritySet()的使用 ***********/\r\n");
x = uxTaskPriorityGet(LedTask_Handle);
printf("函数LedTask的优先级是%ld\r\n", x);
printf("设置LedTask函数优先级为5\r\n");
vTaskPrioritySet(LedTask_Handle, (UBaseType_t));
x = uxTaskPriorityGet(LedTask_Handle);
printf("更改后，函数LedTask的优先级是%ld\r\n", x);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*3. 函数uxTaskGetSystemState()的使用*/
uint32_t TotalRunTime;
UBaseType_t ArraySize;
TaskStatus_t *StatusArray; printf("/*********** 3. 函数uxTaskGetSystemState()的使用 ***********/\r\n");
ArraySize = uxTaskGetNumberOfTasks(); /*获取系统任务数量*/
StatusArray = pvPortMalloc(ArraySize * sizeof(TaskStatus_t)); /*申请内存*/
if (StatusArray != NULL)
{
ArraySize = uxTaskGetSystemState( (TaskStatus_t * )StatusArray,
(UBaseType_t )ArraySize,
(uint32_t * )&TotalRunTime );
printf("TaskName\t\tPriority\t\tTaskNumber\t\t\r\n");
for (x=;x<ArraySize;++x)
{
printf("%s\t\t%d\t\t\t%d\t\t\t\r\n",
StatusArray[x].pcTaskName,
(int)StatusArray[x].uxCurrentPriority,
(int)StatusArray[x].xTaskNumber );
}
}
vPortFree(StatusArray); /*释放内存*/
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*4. 函数vTaskGetInfo()的使用*/
TaskHandle_t LedTaskHandle;
TaskStatus_t LedTaskStatus; printf("/*********** 4. 函数vTaskGetInfo()的使用 ***********/\r\n");
LedTaskHandle = xTaskGetHandle("LedTask"); /*函数xTaskGetHandle()的使用*/
vTaskGetInfo(LedTaskHandle,
(TaskStatus_t *)&LedTaskStatus,
pdTRUE,
eInvalid);
printf("任务名 %s\r\n", LedTaskStatus.pcTaskName);
printf("任务编号 %ld\r\n", LedTaskStatus.xTaskNumber);
printf("任务状态 %d\r\n", LedTaskStatus.eCurrentState);
printf("任务优先级 %ld\r\n", LedTaskStatus.uxCurrentPriority);
printf("任务基础优先级 %ld\r\n", LedTaskStatus.uxBasePriority);
printf("任务栈基地址 %#x\r\n", (int)LedTaskStatus.pxStackBase);
printf("任务栈历史剩余最小值 %d\r\n", LedTaskStatus.usStackHighWaterMark);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*
* 栈历史剩余最小值是针对定义的“QUERY_STK_SIZE 256”来说的，
* 假如QueryTask函数用了62字节，那么查询到的最小值就应该是256-62=194了。
*/
/*5. 函数uxTaskGetStackHighWaterMark()的使用*/
printf("/*********** 5. 函数uxTaskGetStackHighWaterMark()的使用 ***********/\r\n");
x = uxTaskGetStackHighWaterMark(LedTask_Handle);
printf("LedTask任务，栈历史剩余最小值：%ld\r\n", x);
x = uxTaskGetStackHighWaterMark(QueryTask_Handle);
printf("QueryTask任务，栈历史剩余最小值：%ld\r\n", x);
x = uxTaskGetStackHighWaterMark(LedTask_Handle);
printf("LedTask任务，栈历史剩余最小值：%ld\r\n", x);
x = uxTaskGetStackHighWaterMark(QueryTask_Handle);
printf("QueryTask任务，栈历史剩余最小值：%ld\r\n", x);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*6. 函数eTaskGetState()的使用*/
eTaskState LedTaskState;
eTaskState QueryTaskState; printf("/*********** 6. 函数eTaskGetState()的使用 ***********/\r\n");
LedTaskState = eTaskGetState(LedTask_Handle);
printf("LedTask任务状态：%d\r\n", LedTaskState);
QueryTaskState = eTaskGetState(QueryTask_Handle);
printf("QueryTask任务状态：%d\r\n", QueryTaskState);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*7. 函数pcTaskGetName()的使用，根据任务句柄查询任务名*/
char *TaskName; printf("/*********** 7. 函数pcTaskGetName()的使用 ***********/\r\n");
TaskName = pcTaskGetName(LedTask_Handle);
printf("LedTask任务名：%s\r\n", TaskName);
TaskName = pcTaskGetName(QueryTask_Handle);
printf("QueryTask任务名：%s\r\n", TaskName);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*8. 函数uxTaskGetNumberOfTasks()的使用，查询系统当前存在的任务数量*/
printf("/*********** 8. 函数uxTaskGetNumberOfTasks()的使用 ***********/\r\n");
x = uxTaskGetNumberOfTasks();
printf("任务总数是：%ld\r\n", x);
printf("ArraySize值是：%ld\r\n", ArraySize);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); /*
* Name: 创建任务的时候给任务分配的名字
* State: 任务的状态信息。B阻塞态，R就绪态，S挂起态，D删除态
* Priority: 任务优先级
* Stack: 栈历史最小剩余大小
* Num: 任务编号
*/
/*9. 函数vTaskList()的使用*/
printf("/*********** 9. 函数vTaskList()的使用 ***********/\r\n");
vTaskList(InfoBuffer);
printf("Name State Priority\tStack\tNum\t\r\n");
printf("*******************************************\r\n");
printf("%s\r\n", InfoBuffer);
printf("/*************************** end ***************************/\r\n");
printf("\r\n"); while ()
{
vTaskDelay();
}
} static void SystemInitial(void)
{
/*组4，16级抢占优先级，无响应优先级*/
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); DelayInitial();
USART1_Initialization();
GPIO_LED_Configuration();
} int main(void)
{
SystemInitial(); /*创建开始任务*/
xTaskCreate((TaskFunction_t )StartTask, /*任务函数*/
(const char * )"StartTask", /*任务名称*/
(uint16_t )START_STK_SIZE, /*任务堆栈大小*/
(void * )NULL, /*传递给任务函数的参数*/
(UBaseType_t )START_TASK_PRIO, /*任务优先级*/
(TaskHandle_t * )&StartTask_Handle); /*任务句柄*/ /*开启任务调度*/
vTaskStartScheduler();
} /***************************END OF FILE***************************/
2. main.h
/**/
#ifndef __MAIN_H__
#define __MAIN_H__ #define LED_POWER GPIO_Pin_2 /*PE2*/
#define LED_RUN GPIO_Pin_3 /*PE3*/ #define LED_Power_On() GPIO_ResetBits(GPIOE, LED_POWER) #endif /*__MAIN_H__*/ /***************************END OF FILE***************************/
3. sys.c
/**/
#include "sys.h"
#include "stdio.h" #pragma import(__use_no_semihosting)
//标准库需要的支持函数
struct __FILE
{
int handle; }; FILE __stdout;
//定义_sys_exit()以避免使用半主机模式
void _sys_exit(int x)
{
x = x;
}
/* //重定义fputc函数
int fputc(int ch, FILE *f)
{
while((USART1->SR&0X40)==0) //循环发送,直到发送完毕
USART1->DR = (u8) ch;
return ch;
} */ /***************************END OF FILE***************************/
4. sys.h
/**/
#ifndef __SYS_H__
#define __SYS_H__ /*0不支持OS，1支持OS*/
#define SYSTEM_SUPPORT_OS 1 /*定义系统文件夹是否支持OS*/ #endif /*__SYS_H__*/ /***************************END OF FILE***************************/
5. delay.c
/**/
#include "delay.h"
#include "sys.h"
/*如果需要使用OS,则包括下面的头文件即可*/
#if SYSTEM_SUPPORT_OS
#include "FreeRTOS.h"
#include "task.h"
#endif __IO uint32_t TimingDelay; //////////////////////////
//static uint8_t fac_us = 0;
////////////////////////// /***** 声明 *****/
extern void xPortSysTickHandler(void); /*systick中断服务函数,使用FreeRTOS时用到*/
void SysTick_Handler(void)
{
TimingDelayDecrement(); if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED) /*系统已运行*/
{
xPortSysTickHandler();
}
} void DelayInitial(void)
{
/*
* SystemCoreClock / 1000 1ms中断一次
* SystemCoreClock / 100000 10us中断一次
* SystemCoreClock / 1000000 1us中断一次
*/
if (SysTick_Config(SystemCoreClock / ))
{
while ();
}
/*关闭systick timer定时器*/
/* SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;*/ /*使能滴答定时器*/
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
} //void DelayNus(uint32_t nus)
//{
// uint32_t ticks;
// uint32_t told, tnow, tcnt = 0;
// uint32_t reload = SysTick->LOAD;
//
// fac_us = SystemCoreClock / 1000000;
// ticks = nus * fac_us;
// told = SysTick->VAL;
//
// while (1)
// {
// tnow = SysTick->VAL;
// if (tnow != told)
// {
// if (tnow < told)
// {
// tcnt += told - tnow;
// }
// else
// {
// tcnt += reload - tnow + told;
// }
// told = tnow;
// if (tcnt >= ticks) break;
// }
// }
//} ///*不会引起调度*/
//void DelayXms(uint32_t nms)
//{
// uint32_t i;
//
// for (i=0;i<nms;++i)
// {
// DelayNus(1000);
// }
//} /*
* 本函数在中断函数中调用，滴答定时器中断一次调用一次。
*/
void TimingDelayDecrement(void)
{
if (TimingDelay != 0x00)
{
TimingDelay--;
}
} /*
* TimingDelay值在TimingDelayDecrement函数中递减
*/
void DelayNms(uint32_t nTimes)
{
TimingDelay = nTimes; while (TimingDelay!=); //等待计数停止
} /***************************END OF FILE***************************/
6. delay.h
/**/
#ifndef __DELAY_H__
#define __DELAY_H__ #include "stm32f2xx.h" #include <stdint.h> extern void DelayInitial(void);
extern void TimingDelayDecrement(void);
extern void DelayNms(uint32_t nTimes); /////////////////////////
extern void DelayXms(uint32_t nms);
///////////////////////// #endif /*__DELAY_H__*/
/***************************END OF FILE***************************/
7. usart.c
/*
* USART1: 中断优先级选择第4组, 3级抢占优先级 无响应优先级
*/
#include "usart.h"
#include "stdio.h" /*printf*/
#include "stm32f2xx.h"
#include "stm32f2xx_gpio.h"
#include "stm32f2xx_rcc.h"
#include "stm32f2xx_usart.h" uint8_t USART1_RxBuffer[USART1_RECEIVE_SIZE];
uint8_t Flag_USART1Receive = ;
uint8_t USART1_ReceiveCount = ;
uint8_t USART1_ReceiveIndex = ; void USART1_Initialization(void)
{
USART1_GPIO_Configuration();
USART1_NVIC_Configuration();
/*USART1使能接收中断*/
// USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
/*USART1使能发送中断*/
/* USART_ITConfig(USART1, USART_IT_TXE, ENABLE); */
}
/*
*/
void USART1_GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
GPIO_PinAFConfig(GPIOA, , GPIO_AF_USART1); /*GPIO连接到串口1上，PA9-TXD*/
GPIO_PinAFConfig(GPIOA, , GPIO_AF_USART1); /*GPIO连接到串口1上，PA10-RXD*/ /*tx, PA9*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitStructure); /*rx, PA10*/
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitStructure); /*配置波特率9600*/
USART_InitStructure.USART_BaudRate = ;
/*配置串口的模式。为了配置双线全双工通讯，需要把Rx和Tx模式都开启. Tx发送使能和Rx接收使能*/
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
/*无奇偶校验*/
USART_InitStructure.USART_Parity = USART_Parity_No;
/*1停止位*/
USART_InitStructure.USART_StopBits = USART_StopBits_1;
/*配置串口传输字长8位*/
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
/*不采用硬件流控制*/
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
/*向寄存器写入配置参数*/
USART_Init(USART1, &USART_InitStructure);
/*使能USART1外设。在使用外设时，不仅要使能其时钟，还要调用此函数使能外设才可以正常使用*/
USART_Cmd(USART1, ENABLE);
} //void USART1_SendNChar(uint8_t *str, uint8_t n)
//{
// /*发送区是否为空*/
// while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
//
// while (n--)
// {
// USART_SendData(USART1, (uint8_t)(*str++));
// /*是否发送完成*/
// while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
// }
//} /*
* 如果一次发送多个字节数据，可能会多次进入此函数
* 调用时，应先延时几十毫秒，确保把数据都接收完
*/
//void USART1_ReceiveIRQ(void)
//{
// /*如果寄存器中有数据*/
// while (USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET)
// {
// USART1_RxBuffer[USART1_ReceiveIndex++] = USART_ReceiveData(USART1);
// USART1_ReceiveCount++;
// }
//
// Flag_USART1Receive = 1;
//} void USART1_NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure; /*中断优先级选择第1组*/
// NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); /*3级抢占优先级 0级响应优先级*/
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = ;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = ;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
} /*重定义fputc函数 2种方法都可以*/
/*
int fputc(int ch,FILE *f)
{
while(USART_GetFlagStatus(USART1,USART_FLAG_TC) != SET);
USART_SendData(USART1,(uint8_t)ch);
while(USART_GetFlagStatus(USART1,USART_FLAG_TC) != SET); return (ch);
}
*/ int fputc(int ch, FILE *f)
{
while((USART1->SR&0X40)==) /*循环发送,直到发送完毕*/
{} USART1->DR = (uint8_t)ch;
return ch;
}
/***************************END OF FILE***************************/
8. usart.h
/*
*
*/
#ifndef __USART_H__
#define __USART_H__ #include <stdint.h> /* uint8_t */ #define USART1_RECEIVE_SIZE 20 void USART1_Initialization(void);
void USART1_GPIO_Configuration(void);
void USART1_SendNChar(uint8_t *str, uint8_t n);
void USART1_ReceiveIRQ(void);
void USART1_NVIC_Configuration(void); #endif /*__USART_H__*/ /***************************END OF FILE***************************/
打印结果：