The FreeRTOS Distribution（介绍、移植、类型定义）

p0inter

已于 2022-04-14 17:26:47 修改

阅读量287

点赞数

分类专栏： FreeRTOS 文章标签：单片机物联网 stm32

于 2021-12-02 20:57:00 首次发布

本文链接：https://blog.csdn.net/qq_41683305/article/details/121661768

版权

FreeRTOS 专栏收录该内容

16 篇文章 2 订阅

订阅专栏

1 Understand the FreeRTOS Distribution

1.1 Definition ：FreeRTOS Port

FreeRTOS目前可以在20种不同的编译器构建，并且可以在30多种不同的处理器架构上运行，每个受支持的编译器和处理器组合被认为是一个单独的FreeRTOS Port。

1.2 Building FreeRTOS

FreeRTOS可以被认为是一个库，为应用程序提供多任务处理能力。 FreeRTOS以一组C源文件的形式提供，一些文件对FreeRTOS Port是通用的。而另一些文件则是特定于某个FreeRTOS Port。

1.3 FreeRTOSCofig.h

FreeRTOSConfig.h是FreeRTOS的配置文件，用来定制FreeRTOS在特定应用程序中使用，用来裁剪和配置FreeRTOS使用那些功能和不使用那些功能，所以FreeRTOS必须配置在项目工程中

1.4 FreeRTOS的顶级目录

在这里插入图片描述
Source目录下式FreeRTOS的源文件，Demo文件下是FreeRTOS的例子

1.5 对所有FreeRTOS Port都通用的源文件

注：下面所说的文件都在FreeRTOS/Source目录中
在这里插入图片描述

tasks.c和list.c文件是FreeRTOS的核心文件，对所有FreeRTOS Port都通用，总是要求包含在项目中。
queue.c文件提供队列和信号量服务
timers.c提供软定时器功能，如果项目工程中需要软定时器，将其包含在内就可以了。
event_groups提供事件组功能
croutine.c实现了FreeRTOS的协程功能，协程旨在用于非常小的微控制器。现在很少使用

由于文件名可能会导致命名空间冲突，FreeRTOS禁止更改的FreeRTOS的源文件名，会导致项目出错以及自动化工具和IDE插件的兼容性，所以我们自己的文件不要与FreeRTOS的文件名同名

1.6 可移植性

这里的可移植性指的是有两种情况：

针对不同的编译器和架构，要选择不同的port.c和portmacro.h文件。特定于FreeRTOS Port的源文件包含在FreeRTOS/Source/portable目录中，如果使用的编译器(如Keil)在特定架构（ARM的CM0）的处理器上运行FreeRTOS，那么除了FreeRTOS源文件外，还必须构建位于FreeRTOS/Source/portable/[compiler]/[architecture]的文件
。
堆内存管理方案。使用早于V9.0.0的FreeRTOS版本的项目必须包含堆内存管理器，从FreeRTOS9.0.0开始，只要FreeRTOSConfig.h中的configSUPPORT_DYNAMIC_ALLOCATION设置为1或configSUPPORT_DYNAMIC_ALLOCATION没有定义时，才需要内存管理器。
FreeRTOS提供了五个方案来分配内存，分别有heap_1到heap_5实现，包含在FreeRTOS/Source/portable/MemMang目录下，如果项目中FreeRTOS使用动态内存分配，则必须在项目中使用这5个方案中的一个。

1.7 Include Paths

FreeRTOS要求编译器的包含路径中包含三个目录：

核心FreeRTOS头文件路径，在FreeRTOS/Source/include文件夹下
特定于正在使用的 FreeRTOS 端口的源文件的路径。如上所述，需要包含 FreeRTOS/Source/portable/[compiler]/[architecture]目录。
FreeRTOSConfig.h

1.8 头文件

使用 FreeRTOS API 的源文件必须包含“FreeRTOS.h”，后跟包含正在使用的 API 函数原型的头文件——“task.h”、“queue.h”、“semphr.h” 、“timers.h”或“event_groups.h”。

2 Creating a FreeRTOS Project

我们在Keil+STM32F4上面实现

Keil打开一个跑马灯实验，并可以下载到板子上正确运行。新建两个分组
在这里插入图片描述
FreeRTOS_Core存放的是核心文件，对每个FreeRTOS Port都一样，FreeRTOS_Protable是内存管理和特定于FreeRTOS Port的源文件，不同FreeRTOS Port可能会不同。

包含头文件：

在这里插入图片描述
第一个是核心FreeRTOS头文件路径，在FreeRTOS/Source/include文件夹下
第二个是FreeRTOSConfig.h文件以及特定于正在使用的 FreeRTOS 端口的源文件的路径FreeRTOS/Source/portable/[compiler]/[architecture]

到这里就配置好了，下面配置的是由于FreeRTOS和HAL库一些函数名重复或者与HAL库配置不符合

修改FreeRTOSConfig.h，第45行
在这里插入图片描述
port.c文件和stm32f4xx_it.c有重复定义的函数：PendSV_Handler、SVC_Handler、Systick_Handler，将stm32f4xx_it.c里面的这些函数屏蔽掉

在FreeRTOSConfig.h将configUSE_IDLE_HOOK、configUSE_TICK_HOOK、configUSE_MALLOC_FAILED_HOOK和configCHECK_FOR_STACK_OVERFLOW定义为0，这个宏定义为1的话，我们需要写一个函数，不然会报错，我们修改为0，就用定义这些函数了。

由于我用了正点原子的库文件，还需要修改sys.h文件和delay.c文件以及usart.c文件
sys.h

#ifndef _SYS_H
#define _SYS_H
#include "stm32f4xx.h"

//	 
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32F429开发板
//系统时钟初始化	
//包括时钟设置/中断管理/GPIO设置等
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//创建日期:2015/6/10
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2014-2024
//All rights reserved
//********************************************************************************
//修改说明
//无
//  

//0,不支持os
//1,支持os
#define SYSTEM_SUPPORT_OS		1		//定义系统文件夹是否支持OS
///
//定义一些常用的数据类型短关键字 
typedef int32_t  s32;
typedef int16_t s16;
typedef int8_t  s8;

typedef const int32_t sc32;  
typedef const int16_t sc16;  
typedef const int8_t sc8;  

typedef __IO int32_t  vs32;
typedef __IO int16_t  vs16;
typedef __IO int8_t   vs8;

typedef __I int32_t vsc32;  
typedef __I int16_t vsc16; 
typedef __I int8_t vsc8;   

typedef uint32_t  u32;
typedef uint16_t u16;
typedef uint8_t  u8;

typedef const uint32_t uc32;  
typedef const uint16_t uc16;  
typedef const uint8_t uc8; 

typedef __IO uint32_t  vu32;
typedef __IO uint16_t vu16;
typedef __IO uint8_t  vu8;

typedef __I uint32_t vuc32;  
typedef __I uint16_t vuc16; 
typedef __I uint8_t vuc8;  
	 
//位带操作,实现51类似的GPIO控制功能
//具体实现思想,参考<<CM3权威指南>>第五章(87页~92页).M4同M3类似,只是寄存器地址变了.
//IO口操作宏定义
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
//IO口地址映射
#define GPIOA_ODR_Addr    (GPIOA_BASE+20) //0x40020014
#define GPIOB_ODR_Addr    (GPIOB_BASE+20) //0x40020414 
#define GPIOC_ODR_Addr    (GPIOC_BASE+20) //0x40020814 
#define GPIOD_ODR_Addr    (GPIOD_BASE+20) //0x40020C14 
#define GPIOE_ODR_Addr    (GPIOE_BASE+20) //0x40021014 
#define GPIOF_ODR_Addr    (GPIOF_BASE+20) //0x40021414    
#define GPIOG_ODR_Addr    (GPIOG_BASE+20) //0x40021814   
#define GPIOH_ODR_Addr    (GPIOH_BASE+20) //0x40021C14    
#define GPIOI_ODR_Addr    (GPIOI_BASE+20) //0x40022014 
#define GPIOJ_ODR_ADDr    (GPIOJ_BASE+20) //0x40022414
#define GPIOK_ODR_ADDr    (GPIOK_BASE+20) //0x40022814

#define GPIOA_IDR_Addr    (GPIOA_BASE+16) //0x40020010 
#define GPIOB_IDR_Addr    (GPIOB_BASE+16) //0x40020410 
#define GPIOC_IDR_Addr    (GPIOC_BASE+16) //0x40020810 
#define GPIOD_IDR_Addr    (GPIOD_BASE+16) //0x40020C10 
#define GPIOE_IDR_Addr    (GPIOE_BASE+16) //0x40021010 
#define GPIOF_IDR_Addr    (GPIOF_BASE+16) //0x40021410 
#define GPIOG_IDR_Addr    (GPIOG_BASE+16) //0x40021810 
#define GPIOH_IDR_Addr    (GPIOH_BASE+16) //0x40021C10 
#define GPIOI_IDR_Addr    (GPIOI_BASE+16) //0x40022010 
#define GPIOJ_IDR_Addr    (GPIOJ_BASE+16) //0x40022410 
#define GPIOK_IDR_Addr    (GPIOK_BASE+16) //0x40022810 

//IO口操作,只对单一的IO口!
//确保n的值小于16!
#define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //输出 
#define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //输入 

#define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //输出 
#define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //输入 

#define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //输出 
#define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //输入 

#define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //输出 
#define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //输入 

#define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //输出 
#define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //输入

#define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //输出 
#define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //输入

#define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //输出 
#define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //输入

#define PHout(n)   BIT_ADDR(GPIOH_ODR_Addr,n)  //输出 
#define PHin(n)    BIT_ADDR(GPIOH_IDR_Addr,n)  //输入

#define PIout(n)   BIT_ADDR(GPIOI_ODR_Addr,n)  //输出 
#define PIin(n)    BIT_ADDR(GPIOI_IDR_Addr,n)  //输入

#define PJout(n)   BIT_ADDR(GPIOJ_ODR_Addr,n)  //输出 
#define PJin(n)    BIT_ADDR(GPIOJ_IDR_Addr,n)  //输入

#define PKout(n)   BIT_ADDR(GPIOK_ODR_Addr,n)  //输出 
#define PKin(n)    BIT_ADDR(GPIOK_IDR_Addr,n)  //输入

void Stm32_Clock_Init(u32 plln,u32 pllm,u32 pllp,u32 pllq);//时钟系统配置
//以下为汇编函数
void WFI_SET(void);		//执行WFI指令
void INTX_DISABLE(void);//关闭所有中断
void INTX_ENABLE(void);	//开启所有中断
void MSR_MSP(u32 addr);	//设置堆栈地址 
#endif

delay.c

#include "delay.h"
#include "sys.h"
// 	 
//如果使用OS,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "FreeRTOS.h"					//FreeRTOS使用	 
#include "task.h"
#endif


static u32 fac_us=0;							//us延时倍乘数

#if SYSTEM_SUPPORT_OS		
    static u16 fac_ms=0;				        //ms延时倍乘数,在os下,代表每个节拍的ms数
#endif

 
extern void xPortSysTickHandler(void);
//systick中断服务函数,使用OS时用到
void SysTick_Handler(void)
{  
    if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    {
        xPortSysTickHandler();	
    }
    HAL_IncTick();
}
			   
//初始化延迟函数
//当使用ucos的时候,此函数会初始化ucos的时钟节拍
//SYSTICK的时钟固定为AHB时钟
//SYSCLK:系统时钟频率
void delay_init(u8 SYSCLK)
{
	u32 reload;
    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);//SysTick频率为HCLK
	fac_us=SYSCLK;						    //不论是否使用OS,fac_us都需要使用
	reload=SYSCLK;					        //每秒钟的计数次数 单位为K	   
	reload*=1000000/configTICK_RATE_HZ;		//根据configTICK_RATE_HZ设定溢出时间
											//reload为24位寄存器,最大值:16777216,在180M下,约合0.745s左右	
	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
}								    

//延时nus
//nus:要延时的us数.	
//nus:0~190887435(最大值即2^32/fac_us@fac_us=22.5)	    								   
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);
}

usart.c

#include "usart.h"
#include "delay.h"
// 	 
//如果使用os,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "FreeRTOS.h"      //os 使用	  
#endif
 	  
//加入以下代码,支持printf函数,而不需要选择use MicroLIB	  
//#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)	
#if 1
#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;
}
#endif 

#if EN_USART1_RX   //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误   	
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记	

u8 aRxBuffer[RXBUFFERSIZE];//HAL库使用的串口接收缓冲
UART_HandleTypeDef UART1_Handler; //UART句柄

//初始化IO 串口1 
//bound:波特率
void uart_init(u32 bound)
{	
	//UART 初始化设置
	UART1_Handler.Instance=USART1;					    //USART1
	UART1_Handler.Init.BaudRate=bound;				    //波特率
	UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //字长为8位数据格式
	UART1_Handler.Init.StopBits=UART_STOPBITS_1;	    //一个停止位
	UART1_Handler.Init.Parity=UART_PARITY_NONE;		    //无奇偶校验位
	UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //无硬件流控
	UART1_Handler.Init.Mode=UART_MODE_TX_RX;		    //收发模式
	HAL_UART_Init(&UART1_Handler);					    //HAL_UART_Init()会使能UART1
	
	HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
  
}

//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
    //GPIO端口设置
	GPIO_InitTypeDef GPIO_Initure;
	
	if(huart->Instance==USART1)//如果是串口1，进行串口1 MSP初始化
	{
		__HAL_RCC_GPIOA_CLK_ENABLE();			//使能GPIOA时钟
		__HAL_RCC_USART1_CLK_ENABLE();			//使能USART1时钟
	
		GPIO_Initure.Pin=GPIO_PIN_9;			//PA9
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//复用推挽输出
		GPIO_Initure.Pull=GPIO_PULLUP;			//上拉
		GPIO_Initure.Speed=GPIO_SPEED_FAST;		//高速
		GPIO_Initure.Alternate=GPIO_AF7_USART1;	//复用为USART1
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//初始化PA9

		GPIO_Initure.Pin=GPIO_PIN_10;			//PA10
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//初始化PA10
		
#if EN_USART1_RX
		HAL_NVIC_EnableIRQ(USART1_IRQn);				//使能USART1中断通道
		HAL_NVIC_SetPriority(USART1_IRQn,3,3);			//抢占优先级3，子优先级3
#endif	
	}

}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance==USART1)//如果是串口1
	{
		if((USART_RX_STA&0x8000)==0)//接收未完成
		{
			if(USART_RX_STA&0x4000)//接收到了0x0d
			{
				if(aRxBuffer[0]!=0x0a)USART_RX_STA=0;//接收错误,重新开始
				else USART_RX_STA|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(aRxBuffer[0]==0x0d)USART_RX_STA|=0x4000;
				else
				{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=aRxBuffer[0] ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收	  
				}		 
			}
		}

	}
}
 
//串口1中断服务程序
void USART1_IRQHandler(void)                	
{ 
	u32 timeout=0;
	u32 maxDelay=0x1FFFF;

	HAL_UART_IRQHandler(&UART1_Handler);	//调用HAL库中断处理公用函数
	
	timeout=0;
    while (HAL_UART_GetState(&UART1_Handler) != HAL_UART_STATE_READY)//等待就绪
	{
	 timeout++;超时处理
     if(timeout>maxDelay) break;		
	
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
	{
	 timeout++; //超时处理
	 if(timeout>maxDelay) break;	
	}
} 
#endif	

/*下面代码我们直接把中断控制逻辑写在中断服务函数内部。*/
/*


//串口1中断服务程序
void USART1_IRQHandler(void)                	
{ 
	u8 Res;
	if((__HAL_UART_GET_FLAG(&UART1_Handler,UART_FLAG_RXNE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
	{
        HAL_UART_Receive(&UART1_Handler,&Res,1,1000); 
		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;//接收数据错误,重新开始接收	  
				}		 
			}
		}   		 
	}
	HAL_UART_IRQHandler(&UART1_Handler);	
} 
#endif	
*/

之后就可以运行了

3 Data Types and Coding Style Guide

3.1 Data Types

FreeRTOS的每个port都有一个唯一的portmacro.h头文件，其中包含TickType_t 和BaseType_t。
TickType_t 是用于保存滴答计数值和指定时间的数据类型。TickType_t 可以是无符号 16 位类型，也可以是无符号 32 位类型，具体取决于 FreeRTOSConfig.h 中 configUSE_16_BIT_TICKS 的设置。如果 configUSE_16_BIT_TICKS 设置为 1，则 TickType_t 定义为 uint16_t。如果 configUSE_16_BIT_TICKS 设置为 0，则 TickType_t 定义为 uint32_t。
使用 16 位类型可以大大提高 8 位和 16 位架构上的效率，但严重限制了可以指定的最大块周期。没有理由在 32 位架构上使用 16 位类型。
BaseType_t 通常用于只能取非常有限范围的值的返回类型，以及 pdTRUE/pdFALSE 类型的布尔值。这始终被定义为体系结构最有效的数据类型。通常，这是 32 位架构上的 32 位类型，16 位架构上的 16 位类型，以及 8 位架构上的 8 位类型。

3.2 Variable Names

变量以其类型为前缀：‘c’ for char，‘s’ for int16_t(short），‘l’ for int32_t(long)，and ‘x’ for BaseType_t和其他非标准类型。
如果一个变量是无符号的，以’u’为前缀，如果变量是指针，以’p’为前缀，比如’pc’代表字符指针类型

3.3 Function Names

函数以他们返回的类型和它们在其中定义的文件名为前缀，比如：
vTaskPrioritySet（）:返回类型为void，定义在task.c文件中
xQueueReceive()：返回值为BaseType_t类型，定义在queue.c文件中

3.4 Macro Names

大多数宏都是大写的，并以小写字母作为前缀，指示宏的定义位置。信号量API几乎完全是作为一组宏编写的，但遵循函数命名的约定。下面的四个宏用于整个FreeRTOS中
在这里插入图片描述

p0inter

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
The FreeRTOS Distribution（介绍、移植、类型定义）

1 Understand the FreeRTOS Distribution1.1 Definition ：FreeRTOS PortFreeRTOS目前可以在20种不同的编译器构建，并且可以在30多种不同的处理器架构上运行，每个受支持的编译器和处理器组合被认为是一个单独的FreeRTOS Port。1.2 Building FreeRTOSFreeRTOS可以被认为是一个库，为应用程序提供多任务处理能力。 FreeRTOS以一组C源文件的形式提供，一些文件对FreeRTOS Port是通用的。而另
复制链接

扫一扫