学习笔记：在STM32上移植FreeRTOS_stm32移植freertos为什么要改system文件-CSDN博客

本文链接：https://blog.csdn.net/lee_goi/article/details/110452677

摘要：

本文主要介绍了FreeRTOS移植在STM32103上，并进行任务创建，创建了三个任务分别实现了：LED闪烁，串口通信，最后一个任务给出基本框架。

文章目录

✍️ 源码介绍

官网下载源码，解压

文件预览

FreeRTOS和FreeROS-Plus里就是其源码

点击进入，其提供了许多相关例程，但是我们需要的就是103

我们之后会参考这些例程

Source就是FreeRTOS了

打开后如图

下面是需要的文件

FreeRTOSv9.0.0\FreeRTOSv9.0.0\FreeRTOS\Source\portable\RVDS\ARM_CM3 这个目录下的文件也是我们需要的

✍️ 移植

🛠 创建文件夹，移入源码

其中portable文件夹下只保留Keil MemMang RVDS即可

🛠 把上次做的LED跑马灯作为基础程序，加入这些程序，并包含路径

创建FreeRTOS_CORE和FreeRTOS_PORTABLE两个文件夹，包含下面文件

包含头文件

🛠 编译报错，要包含头文件

解决：

打开路径FreeRTOSv9.0.0\FreeRTOS\Demo\CORTEX_STM32F103_Keil

找到下文件

这个文件就是FreeRTOS的系统配置文件

将其复制到前面建立的文件的头文件中

编译通过：

🛠 修改SYSTEM文件

SYSTEM是针对UCOS而编写的，用FreeRTOS的话就要重新修改

sys.h支持OS

usart.c文件，添加FreeRTOS.h头文件

#if SYSTEM_SUPPORT_OS
#include "FreeRTOS.h"					//FreeRTOS使用	 	  
#endif

USART1的中断服务函数
delay.c文件涉及到其时钟函数SysTIck_Handler()

extern void xPortSysTickHandler(void);

//systick中断服务函数,使用ucos时用到
void SysTick_Handler(void)
{	
    if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    {
        xPortSysTickHandler();	
    }
}

delay_init()初始化计时和延迟

oid delay_init()
{
	u32 reload;
	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
	fac_us=SystemCoreClock/1000000;				//不论是否使用OS,fac_us都需要使用
	reload=SystemCoreClock/1000000;				//每秒钟的计数次数 单位为M  
	reload*=1000000/configTICK_RATE_HZ;			//根据configTICK_RATE_HZ设定溢出时间
												//reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右	
	fac_ms=1000/configTICK_RATE_HZ;				//代表OS可以延时的最少单位	   

	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   	//开启SYSTICK中断
	SysTick->LOAD=reload; 						//每1/configTICK_RATE_HZ秒中断一次	
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;   	//开启SYSTICK    
}

根据 FreerRTOS的系统时钟节拍来初始化滴答定时器了。delay_init就是来完成这个功能的。 FREERTOS的系统时钟节拍由宏 configTICK_RATE_HZ来设置，这个值我们可以自由设置，但是一旦设置好以后我就要根据这个值来初始化滴答定时器，其实就是设置滴答定时器的中断周期FreerRTOS 为72MHz

延时函数

//延时nus
//nus:要延时的us数.	
//nus:0~204522252(最大值即2^32/fac_us@fac_us=168)	    								   
void delay_us(u32 nus)
{		
	u32 ticks;
	u32 told,tnow,tcnt=0;
	u32 reload=SysTick->LOAD;				//LOAD的值	    	 
	ticks=nus*fac_us; 						//需要的节拍数 
	told=SysTick->VAL;        				//刚进入时的计数器值
	while(1)
	{
		tnow=SysTick->VAL;	
		if(tnow!=told)
		{	    
			if(tnow<told)tcnt+=told-tnow;	//这里注意一下SYSTICK是一个递减的计数器就可以了.
			else tcnt+=reload-tnow+told;	    
			told=tnow;
			if(tcnt>=ticks)break;			//时间超过/等于要延迟的时间,则退出.
		}  
	};										    
}  
//延时nms
//nms:要延时的ms数
//nms:0~65535
void delay_ms(u32 nms)
{	
	if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
	{		
		if(nms>=fac_ms)						//延时的时间大于OS的最少时间周期 
		{ 
   			vTaskDelay(nms/fac_ms);	 		//FreeRTOS延时
		}
		nms%=fac_ms;						//OS已经无法提供这么小的延时了,采用普通方式延时    
	}
	delay_us((u32)(nms*1000));				//普通方式延时
}

//延时nms,不会引起任务调度
//nms:要延时的ms数
void delay_xms(u32 nms)
{
	u32 i;
	for(i=0;i<nms;i++) delay_us(1000);
}

屏蔽中断

这三个函数为定时器中断服务函数，需要屏蔽掉

再编译一下，移植就完成了。

✍️ 创建任务

接下来就是任务创建了，我将创建下面三个任务

每间隔500ms闪烁一次LED0
每间隔2000ms向串口发送一次指令 hellowindows
每500ms采集一次温度（因为暂时没有温度模块，这里用LED1翻转代替）

构建任务，需要注意，构建一个任务需要一下几步

设置任务优先级

设置任务堆栈大小

设置任务句柄

设置任务函数

我设置了4个任务第一个任务在主函数中创建，后三个任务在第一个任务中创建 创建任务框架如下

然后分别在任务框架上执行相应操作，对应代码如下

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "FreeRTOS.h"
#include "task.h"

//任务优先级
#define START_TASK_PRIO		1
//任务堆栈大小	
#define START_STK_SIZE 		128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);


//任务优先级
#define LED0_TASK_PRIO		2
//任务堆栈大小	
#define LED0_STK_SIZE 		50  
//任务句柄
TaskHandle_t LED0Task_Handler;
//任务函数
void led0_task(void *pvParameters);


//任务优先级
#define USART0_TASK_PRIO		3
//任务堆栈大小	
#define USART0_STK_SIZE 		50  
//任务句柄
TaskHandle_t USART0Task_Handler;
//任务函数
void usart0_task(void *pvParameters);


//任务优先级
#define TEMPER0_TASK_PRIO		4
//任务堆栈大小	
#define TEMPER0_STK_SIZE 		50  
//任务句柄
TaskHandle_t TEMPER0Task_Handler;
//任务函数
void temper0_task(void *pvParameters);
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();          //开启任务调度
}

//开始任务任务函数
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
    //创建LED0任务
    xTaskCreate((TaskFunction_t )led0_task,     	
                (const char*    )"led0_task",   	
                (uint16_t       )LED0_STK_SIZE, 
                (void*          )NULL,				
                (UBaseType_t    )LED0_TASK_PRIO,	
                (TaskHandle_t*  )&LED0Task_Handler);   
    //创建usart0任务
    xTaskCreate((TaskFunction_t )usart0_task,     
                (const char*    )"usart0_task",   
                (uint16_t       )USART0_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )USART0_TASK_PRIO,
                (TaskHandle_t*  )&USART0Task_Handler);
		//创建temper0任务
    xTaskCreate((TaskFunction_t )temper0_task,     
                (const char*    )"temper_task",   
                (uint16_t       )TEMPER0_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )TEMPER0_TASK_PRIO,
                (TaskHandle_t*  )&TEMPER0Task_Handler); 								
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}

//LED0任务函数 
void led0_task(void *pvParameters)
{
    while(1)
    {
        LED0=~LED0;
        vTaskDelay(500);
    }
}   

//usart0任务函数
void usart0_task(void *pvParameters)
{
	
			while(1)
			{	
				printf("hello windows");
				printf("\r\n");
				vTaskDelay(2000);
			}
}

//temper0任务函数(暂时为LED1翻转)
void temper0_task(void *pvParameters)
{
	
			while(1)
			{	
				LED1=~LED1;
        vTaskDelay(500);
			}
}