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

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"
#endifstatic u32 fac_us=0;                         //us延时倍乘数#if SYSTEM_SUPPORT_OS      static u16 fac_ms=0;                       //ms延时倍乘数,在os下,代表每个节拍的ms数
#endifextern 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频率为HCLKfac_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;                     //USART1UART1_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()会使能UART1HAL_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;           //PA9GPIO_Initure.Mode=GPIO_MODE_AF_PP;        //复用推挽输出GPIO_Initure.Pull=GPIO_PULLUP;         //上拉GPIO_Initure.Speed=GPIO_SPEED_FAST;        //高速GPIO_Initure.Alternate=GPIO_AF7_USART1;    //复用为USART1HAL_GPIO_Init(GPIOA,&GPIO_Initure);      //初始化PA9GPIO_Initure.Pin=GPIO_PIN_10;          //PA10HAL_GPIO_Init(GPIOA,&GPIO_Initure);       //初始化PA10#if EN_USART1_RXHAL_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中