南昌大学FreeRTOS实验5-8知识点

干货FreeRTOS学习笔记——实验：串口后台打印EEWorld电子资讯犀利解读技术干货每日更新现在来探讨一下如何利用FreeRTOS 的服务来为单片机程序设计提供方便，也感受下引入FreeRTOS 后系统处理效率的变化。

我想了个简单的常用需求：串口的“后台”打印输出(单片机开发时常用于调试信息输出)，来进行实验。

串口（异步串行通讯口的简称, UART）相对于 CPU 是一个低速的设备，一般较高通信速率为115200bit/s，在此速率下输出一个8-bit 字符(假设用1个起始位，1个停止位，无校验)用的时间为87us. CPU 将字符写入串口的发送数据寄存器需要的时间可以忽略，但是由于串口硬件FIFO很小，务必要等待发送数据寄存器允许写入时才可以进行写操作。

于是，简单的程序设计中就不断查询标志位，等待寄存器可以写了就写一个字符，直到要发送的字符串写完。

要照顾执行效率的时候一定不能这么做，特别是在多任务环境下，因为这种循环重复查询标志位的做法让其它任务也只能等待，没有利用CPU处理能力。

于是我们需要一种“后台”输出的方法，让当前任务将要从串口输出的字符串提交到系统之后，程序往下执行，不用等待字符串从串口发送完；或者是当前任务等待字符串发送完，但是其它任务可以执行。

以下我的实验代码在ST Nucleo-L4R5ZI 板子上运行，也很容易改动一下以在其它 STM32 上运行（不过 STM32L4R5 的SRAM大，方便挥霍）。

在这块开发板上，USB串口连接到了STM32L4R5 的LPUART1, 我就编写一个 uart_puts(char *) 函数来从 LPUART1 输出字符串。

LPUART1 的TDR 寄存器时候用来写要发送的数据的，发送完成等状态可以从ISR 寄存器获取。

当然为了实现后台工作，中断是需要用到的了。

1简单直接的办法——字符队列不能反复查询，那么就让 LPUART1 的 TDR 寄存器可以写的时候，产生一个中断来告诉CPU，该写字符了。

STM32-FreeRTOS快速学习之总结11. 基础知识注意:在RTOS中是优先值越⾼则优先级越⾼(和ucos/linux的相反)在移植的时候,主要裁剪FreeRTOS/Source/portable⽂件夹,该⽂件夹⽤来针对不同MCU做的⼀些处理,如下图所⽰,我们只需要使⽤:1.1配置⼯程时,选择memMang时,⼀般使⽤heap_4.cheap_4: 优点在于可以有效的利⽤内存碎⽚来合并为⼀个⼤内存.缺点在于只能⽤来⼀个ram⾥.heap_5: ⼀般针对有外部RAM才⽤到,优点在于可以同时利⽤内部ram和外部ram来进⾏内存碎⽚合并.最终添加的库⽂件有:然后我们在分配释放内存的时候,就尽量使⽤RTOS带的函数来实现,分配/释放函数如下所⽰:void *pvPortMalloc( size_t xWantedSize );void vPortFree( void *pv );1.2 添加头⽂件路径添加FreeRTOS\include添加FreeRTOS\portable\RVDS\ARM_CM3并将原⼦中的FreeRTOSConfig.h也复制到我们项⽬的FreeRTOS\include中(⽤来配置RTOS系统)2. FreeRTOSConfig.h配置介绍⼀般会写configXXXXX或者INCLUDE_XXXX类似的宏,这两个宏区别在于:configXXXXX⽤来实现不同功能,⽐如定义configUSE_COUNTING_SEMAPHORES为1时,表⽰使⽤计数信号量INCLUDE_XXXX⽤来是否将某个API函数编译进程序中.⽐如定义INCLUDE_xTaskGetSchedulerState为1 时,则将会编译xTaskGetSchedulerState()函数,如下图所⽰:3. FreeRTOS任务状态3.1 运⾏态指当前任务正在运⾏.3.2 就绪态指当前任务正在等待调度,因为有个⾼优先级/同优先级的任务正在运⾏中3.3 阻塞态当前任务处于等待外部事件通知或通过vTaskDelay()函数进⼊休眠了,外部事件通知常见有信号量、等待队列、事件标志组、任务通知.3.4 挂起态类似于暂停,表⽰不会再参与任务调度了,通过vTaskSuspend()实现,重新恢复调度则使⽤xTaskResume()4. FreeRTOS中断配置4.1 回忆stm32 NVIC中断Stm32可以设置NVIC中断组数为0~4,其中0~4区别在于如下图所⽰:、⽐如我们设置为NVIC_PriorityGroup_4时:表⽰抢占优先级为4bit(即为2^4,为0~15个抢占优先级),副优先级为0bit(表⽰没有).4.2 抢占优先级和副优先级的区别:1. 抢占优先级和副优先级的值越低,则优先级越⾼2.⾼的抢占优先级的中断可以直接打断低的抢占优先级的中断3.⾼的副优先级的中断不可以打断低的副优先级的中断(只是两个相同抢占优先级的中断同时来的时候,只会优先选择⾼的副优先级)4.3 FreeRTOS中断配置宏configKERNEL_INTERRUPT_PRIORITY⽤来配置中断最低抢占优先级,也就是可以FreeRTOS可以管理的最⼩抢占优先级,所以使⽤FreeRTOS时,我们尽量设置stm32为NVIC_PriorityGroup_4,这样就可以管理16个优先级了.configMAX_SYSCALL_INTERRUPT_PRIORITY⽤来配置FreeRTOS能够安全管理的的最⾼优先级.⽐如原⼦的FreeRTOSConfig.h⾥就设置为5,⽽0~4的优先级中断就不会被FreeRTOS因为开关中断⽽禁⽌掉(⼀直都会有),并且不能调⽤RTOS中的”FromISR”结尾的API函数.⽐如喂看门狗中断函数就需要设置为0~4如下图所⽰(来⾃原⼦⼿册):4.3 FreeRTOS中断开关函数portENABLE_INTERRUPTS();//开中断,将configMAX_SYSCALL_INTERRUPT_PRIORITY⾄ configKERNEL_INTERRUPT_PRIORITY之间的优先级中断打开portDISABLE_INTERRUPTS();//关中断,将configMAX_SYSCALL_INTERRUPT_PRIORITY⾄ configKERNEL_INTERRUPT_PRIORITY之间的优先级中断禁⽌掉5.任务常⽤API函数5.1 xTaskCreate创建任务函数定义如下:xTaskCreate( TaskFunction_t pxTaskCode, //任务函数,⽤来供给函数指针调⽤的const char * const pcName, //任务的字符串别名const uint16_t usStackDepth, //任务堆栈深度,实际申请到的堆栈是该参数的4倍void * const pvParameters, //函数参数,⽤来供给指针调⽤的UBaseType_t uxPriority, //优先级,越⾼优先级⾼,范围为0~configMAX_PRIORITIES-1 //注意优先级0会创建为空闲任务, 优先级configMAX_PRIORITIES-1会创建⼀个软件定时器服务任务(管理定时器的) TaskHandle_t * const pxCreatedTask ); //任务句柄,该句柄可以⽤于挂起/恢复/删除对应的任务//返回值 errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY(-1):表⽰创建任务堆空间不⾜pdPASS(1):创建成功5.2 taskENTER_CRITICAL()和taskEXIT_CRITICAL()⽤于任务中进⼊/退出临界区,调⽤taskENTER_CRITICAL()主要会关闭其他任务调度.⽽taskEXIT_CRITICAL()则会恢复任务调度,⼀般⽤于初始化外设等.5.3 taskENTER_CRITICAL_FROM_ISR()和taskEXIT_CRITICAL_FROM_ISR()⽤于在中断函数中进⼊/退出临界区,作⽤和上⾯⼀样5.4 挂起/恢复/删除任务函数void vTaskSuspend( TaskHandle_t xTaskToSuspend ); //挂起⼀个任务,参数为挂起任务的句柄,如果为NULL则表⽰挂起⾃⾝任务void vTaskResume( TaskHandle_t xTaskToResume ); //恢复⼀个任务BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume);//从中断函数中恢复⼀个任务,返回1表⽰恢复成功void vTaskDelete( TaskHandle_t xTaskToDelete ); //删除⼀个任务,如果从任务函数中退出的话,则需要调⽤vTaskDelete(NULL)来删除⾃⾝任务5.5 vTaskDelay()延时函数void vTaskDelay( const TickType_t xTicksToDelay ); //参数表⽰延时的系统滴答数⽐如延时500ms可以写为: vTaskDelay( 500/portTICK_RATE_MS );portTICK_RATE_MS是个宏,表⽰当前系统的1个滴答需要多少ms,⽽500/portTICK_RATE_MS则表⽰当前500ms需要多少个系统滴答数.6. 队列6.1简介队列⽤于任务与任务或者任务与中断之间的通信.⽐如key任务检测到按键按下时,则可以通过队列向lcd显⽰任务发送信息,使得lcd切换界⾯.队列采⽤先进先出存储机制.队列发送数据可以有两种⽅式:浅拷贝、深拷贝.数据量不⼤的情况下,都使⽤深拷贝(会分配新的空间,并进⾏数据拷贝,缺点在于耗时)数据量⼤的情况下,都使⽤浅拷贝(通过指针⽅式,前提是要发送的数据必须不会被释放的)6.2队列的优点队列可以通过任何任务或者中断进⾏访问,可以随时存取数据消息.并且出⼊队的时候可以进⾏任务阻塞,⽐如某个任务进⾏读消息出队时,如果没有消息,则可以实现进⼊休眠状态,直到有消息才唤醒任务.6.3队列创建删除相关APIQueueHandle_t xQueueCreate( uxQueueLength, uxItemSize );//动态创建队列,内存会交给RTOS⾃动分配// uxQueueLength:队列长度(表⽰队列中最⼤多少条消息),uxItemSize:每个队列消息的长度(以字节为单位)//返回值: NULL(0, 表⽰分配失败),⾮0(表⽰返回该队列分配好的地址)//注意:使⽤⾃动分配时,需要配置configSUPPORT_DYNAMIC_ALLOCATION宏为1,否则只能由⽤户来分配.QueueHandle_t xQueueCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer );//静态创建队列,内存需要由⽤户事先分配好// uxQueueLength:队列长度(表⽰队列中最⼤多少条消息),uxItemSize:每个队列消息的长度(以字节为单位)// pucQueueStorage:指向⽤户事先分配好的存储区内存(必须为uint8_t型)// pxQueueBuffer:指向队列结构体,⽤来提供给RTOS初始化.然后给⽤户使⽤//返回值: NULL(0, 表⽰分配失败),⾮0(表⽰返回该队列分配好的地址)vQueueDelete( QueueHandle_t xQueue );//删除队列,并释放空间xQueueReset( xQueue );//将队列⾥的消息清空⼀次,也就是恢复初始状态6.4队列出⼊队相关APIxQueueSend( xQueue, pvItemToQueue, xTicksToWait );//插⼊队尾,和xQueueSendToBack函数效果⼀致// xQueue:队列句柄//PvItemToQueue:消息数据,会通过数据拷贝到队列中,如果想使⽤浅拷贝,则可以发送⼀个变量来存储要真正发送的缓冲区地址即可.// xTicksToWait:阻塞时间,单位为RTOS时钟滴答值,如果configTICK_RATE_HZ是1000,则填⼊的值表⽰阻塞的是多少ms,否则的话需要通过X/portTICK_RATE_MS来转换⼀下,才能实现阻塞Xms. //xTicksToWait==0:表⽰⼊队满了,则直接退出该函数// xTicksToWait==portMAX_DELAY:表⽰⼀直阻塞,直到队列有空位为⽌.//注意: INCLUDE_vTaskSuspend宏必须为1,否则任务⽆法进⼊休眠状态实现阻塞效果.//返回值: errQUEUE_FULL(队列已满) pdPASS(通过)xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait );//插⼊队头,参数和上⾯描述⼀致xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait );//插⼊队尾,参数和上⾯描述⼀致xQueueOverwrite( xQueue, pvItemToQueue );//将之前未出队的旧数据全部清空,然后再⼊队,该函数适⽤于长度为1的队列xQueueReceive( xQueue, pvBuffer, xTicksToWait );//从队列头部读出⼀个消息,并且这个消息会出队(删除掉)xQueuePeek( xQueue, pvBuffer, xTicksToWait );//从队列头部读出⼀个消息,但是这个消息不会出队(不会删除)PS:这些API函数只能⽤于任务⾥调⽤,如果要在中断服务函数中调⽤,则在函数名后添加FromQueue即可,⽐如xQueueSendFromQueue()函数6.5 中断发送/读取消息队列时,要注意的事情使⽤中断相关的读写队列相关的API时,第3个参数是不⼀样的,⽐如xQueueSendFromISR():PxHigherPriorityTaskWoken⽤来标记退出该函数后是否需要进⾏任务切换,因为我们发送队列时,有可能会将某个阻塞任务退出阻塞态,⽽此时⼜在中断中,所以当PxHigherPriorityTaskWoken为pdTRUE时,我们则必须进⾏⼀次任务切换.可以通过portYIELD_FROM_ISR()来进⾏任务切换,并且我们不需要去判断PxHigherPriorityTaskWoken是否为pdTRUE,因为该函数内部有判断的,如下图所⽰:来个中断函数发送队列⽰例:extern QueueHandle_t Message_Queue; //信息队列句柄void USART1_IRQHandler(void) //串⼝1中断服务程序{BaseType_t xHigherPriorityTaskWoken; //定义任务切换标志位if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET){//处理中断接收数据}if (Message_Queue!=NULL) //判断Message_Queue是否已创建{xQueueSendFromISR(Message_Queue, RX_BUF,&xHigherPriorityTaskWoken);//向队列Message_Queue中发送RX_BUFportYIELD_FROM_ISR(xHigherPriorityTaskWoken);//通过portYIELD_FROM_ISR()判断是否需要切换任务}}PS:尽量将portYIELD_FROM_ISR()写在中断函数末尾处6.6⽰例-任务之间的伪代码按键任务向打印任务发送按键消息队列,代码如下:QueueHandle_t Key_Queue; //按键值消息队列句柄int main(){//...省略N⾏代码Key_Queue=xQueueCreate(1,sizeof(u8)); //创建消息Key_Queue,长度为1//创建两个任务:key_task()、print_task()//...省略N⾏代码}key_task() //获取按键值{ while(1) { key=KEY_Scan(0); //扫描按键 if((Key_Queue!=NULL)&&(key)) //消息队列Key_Queue创建成功,并且按键被按下 { err=xQueueSend(Key_Queue,&key,10); if(err==errQUEUE_FULL) //发送按键值 { printf("队列Key_Queue已满，数据发送失败!\r\n"); } } vTaskDelay(10); //延时10个时钟节拍 }}print_task() //打印按键值{ u8 key; while(1) { if(Key_Queue!=NULL) { if(xQueueReceive(Key_Queue,&key,portMAX_DELAY))//请求消息Key_Queue { printf("key=%d\r\n",key); } } vTaskDelay(10); //延时10个时钟节拍 }}7. RTOS软件定时器7.1简介在之前的任务创建的时候有讲到过,RTOS会⾃动创建⼀个优先级configMAX_PRIORITIES-1的软件定时器服务任务(管理定时器的).所以我们写⼀个定时器回调函数时,则会被该定时器服务任务调⽤,所以在我们软件定时器函数中不能使⽤vTaskDelay()阻塞之类的API函数,否则会将系统中的定时器服务函数给阻塞掉.7.2 FreeRTOSConfig.h相关的定时器配置#define configUSE_TIMERS 1 //为1时启⽤软件定时器#define configTIMER_TASK_PRIORITY 31 //设置软件定时器优先级可设置的值范围为0~31#define configTIMER_QUEUE_LENGTH 5 //软件定时器队列长度#define configTIMER_TASK_STACK_DEPTH 200 //设置每个软件定时器任务堆栈⼤⼩7.3定时创建相关APITimerHandle_t xTimerCreateStatic(const char * const pcTimerName, //定时器字符串别名 const TickType_t xTimerPeriodInTicks, //需要定时的周期值,⽐如通过200/ portTICK_RATE_MS来转换实现定时200毫秒 const UBaseType_t uxAutoReload, //是否重载(周期性/单次性),若为pdTRUE(1)表⽰为周期性,为pdFALSE(0)表⽰为单次 void * const pvTimerID, //定时器ID号,⼀般⽤于多个定时器共⽤⼀个定时器回调函数,否则填0即可 TimerCallbackFunction_t pxCallbackFunction);//定时器回调函数xTimerDelete( xTimer, xTicksToWait );//删除定时器//xTicksToWait:指定该定时器在多少时钟节拍数之前删除掉,为0则⽴即删除,⼀般设为100(如果设为0,则如果在该操作之前还有其它设置定时器操作的话,则不会进⾏阻塞等待,从⽽返回false)7.4 定时器其它常⽤APIxTimerChangePeriod( xTimer, xNewPeriod, xTicksToWait );//修改定时器周期,在中断中则使⽤xTimerChangePeriodFromISR()// xNewPeriod:要修改的周期值//xTicksToWait:指定该定时器在多少时钟节拍数之前修改好,为0则⽴即删除//xTimerReset( xTimer, xTicksToWait );//复位定时器,让定时器重新计数,在中断中则使⽤xTimerResetFromISR()// xTicksToWait:和上⾯内容类似xTimerStart( xTimer, xTicksToWait );//启动定时器,如果定时器正在运⾏的话调⽤该函数的结果和xTimerReset()⼀样, 在中断中则使⽤xTimerResetFromISR ()xTimerStop( xTimer, xTicksToWait );//停⽌定时器, 在中断中则使⽤xTimerStopFromISR ()PS:在中断中使⽤定时器API时,同样和队列⼀样,也需要在函数末尾通过portYIELD_FROM_ISR()进⾏⼀次任务切换判断8. 信号量在项⽬中我们⼀般⽤⼆值信号量,⽤来同步数据的.⽐如任务A要向任务B发送⼀个很⼤的数据buf,⽽⽤队列的话会进⾏复制拷贝,从⽽占⽤⼤量时间.此时我们不妨定义⼀个全局数据buf,任务A修改这个buf,发送⼀个信号量给任务B,任务B就去读取这个全局数据buf即可.从⽽省去了队列复制拷贝的时间. 8.1定义信号量举例SemaphoreHandle_t BinarySemaphore; //⼆值信号量句柄BinarySemaphore=xSemaphoreCreateBinary(); //创建⼆值信号量8.2在中断中发送信号量过程BaseType_t xHigherPriorityTaskWoken;xSemaphoreGiveFromISR(BinarySemaphore,&xHigherPriorityTaskWoken);//发送⼆值信号量portYIELD_FROM_ISR(xHigherPriorityTaskWoken);//如果需要的话进⾏⼀次任务切换8.3在任务中发送信号量过程xSemaphoreGive(BinarySemaphore);//返回值: pdPASS(0, 表⽰发送成功,如果信号量⼀直未处理,则会返回值失败FULL)8.4 在任务中接收信号量过程err=xSemaphoreTake(BinarySemaphore,portMAX_DELAY); //获取信号量// portMAX_DELAY:进⼊阻塞态⼀直等待获取//返回值为pdTRUE(OK) pdFALSE(err)。

嵌入式操作系统FreeRTOS的原理与实现在嵌入式领域中，嵌入式实时操作系统正得到越来越广泛的应用。

采用嵌入式实时操作系统(RTOS)可以更合理、更有效地利用CPU的资源，简化应用软件的设计，缩短系统开发时间，更好地保证系统的实时性和可靠性。

由于RTOS需占用一定的系统资源(尤其是RAM资源)，只有μC／OS-II、embOS、Salvo、FreeRTOS等少数实时操作系统能在小RAM单片机上运行。

相对于μC／OS-II、embOS等商业操作系统，FreeRTOS操作系统是完全免费的操作系统，具有源码公开、可移植、可裁减、调度策略灵活的特点，可以方便地移植到各种单片机上运行。

1.FreeRTOS操作系统功能作为一个轻量级的操作系统，FreeRTOS提供的功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能等，可基本满足较小系统的需要。

FreeRTOS内核支持优先级调度算法，每个任务可根据重要程度的不同被赋予一定的优先级，CPU总是让处于就绪态的、优先级最高的任务先运行。

FreeRTOS内核同时支持轮换调度算法，系统允许不同的任务使用相同的优先级，在没有更高优先级任务就绪的情况下，同一优先级的任务共享CPU的使用时间。

FreeRTOS的内核可根据用户需要设置为可剥夺型内核或不可剥夺型内核。

当FreeRTOS被设置为可剥夺型内核时，处于就绪态的高优先级任务能剥夺低优先级任务的CPU使用权，这样可保证系统满足实时性的要求；当FreeRTOS被设置为不可剥夺型内核时，处于就绪态的高优先级任务只有等当前运行任务主动释放CPU的使用权后才能获得运行，这样可提高CPU的运行效率。

2.FreeRTOS操作系统的原理与实现2. 1任务调度机制的实现任务调度机制是嵌入式实时操作系统的一个重要概念，也是其核心技术。

对于可剥夺型内核，优先级高的任务一旦就绪就能剥夺优先级较低任务的CPU使用权，提高了系统的实时响应能力。

freertos的课程设计一、教学目标本课程旨在让学生了解和掌握FreeRTOS实时操作系统的基本原理和应用方法。

通过本课程的学习，学生将能够：1.理解实时操作系统的基本概念，包括任务、调度、同步等。

2.掌握FreeRTOS的关键特性，如多任务、抢占式调度、时间管理、内存管理等。

3.能够运用FreeRTOS进行嵌入式系统的开发，实现实时任务的管理和调度。

4.培养学生的动手实践能力和团队协作精神，提高他们解决实际问题的能力。

二、教学内容本课程的教学内容主要包括以下几个部分：1.实时操作系统基础：介绍实时操作系统的概念、特点和应用领域，让学生了解实时操作系统的基本原理。

2.FreeRTOS概述：讲解FreeRTOS的核心功能、架构和关键特性，使学生对FreeRTOS有一个整体的认识。

3.FreeRTOS编程：详细讲解FreeRTOS的编程接口，包括任务创建、任务调度、事件处理等，让学生能够熟练使用FreeRTOS进行编程。

4.嵌入式系统设计：介绍如何使用FreeRTOS设计嵌入式系统，包括硬件选择、系统架构设计、驱动开发等，帮助学生掌握嵌入式系统的设计方法。

5.实践项目：安排学生进行实践项目，让学生将所学知识应用到实际项目中，提高他们的动手实践能力。

三、教学方法为了提高教学效果，本课程将采用多种教学方法相结合的方式进行教学：1.讲授法：讲解实时操作系统和FreeRTOS的基本概念、原理和编程方法。

2.案例分析法：分析典型的嵌入式系统设计案例，让学生了解FreeRTOS在实际项目中的应用。

3.实验法：安排学生进行实验，让学生动手实践，加深对FreeRTOS的理解。

4.讨论法：学生进行课堂讨论，鼓励学生提问、发表见解，提高他们的思考和表达能力。

四、教学资源为了支持本课程的教学，我们将准备以下教学资源：1.教材：选用权威、实用的FreeRTOS教材，为学生提供系统的学习资料。

2.参考书：提供相关的嵌入式系统设计和实时操作系统方面的参考书，丰富学生的知识体系。

Selecting the API to Use∙Only those API functions specifically designated for use from within an ISR should be used from within an ISR.∙Tasks and co-routines use different API functions to access queues.A queue cannot be used to communicate between a task and a co-routineor visa versa.∙Intertask communication can be achieved using the full featured API functions, the alternative API functions, and the light weight API functions (those with "FromISR" in their name).∙Use of the light weight functions outside of an ISR requires special consideration, as described under the heading "Performance tips and tricks - using the light weight API".Task APIA task may call any API function listed in the menu frame on the left other than those under the co-routine specific section.Co-Routine APIIn addition to the API functions listed under the co-routine specific section, a co-routine may use the following API calls.∙taskYIELD() - will yield the task in which the co-routines are running.∙taskENTER_CRITICAL().∙taskEXIT_CRITICAL().∙vTaskStartScheduler() - this is still used to start the scheduler even if the application only includes co-routines and no tasks.∙vTaskSuspendAll() - can still be used to lock the scheduler.∙xTaskResumeAll()∙xTaskGetTickCount()∙uxTaskGetNumberOfTasks()Customisation[Configuration]A number of configurable parameters exist that allow the FreeRTOS kernel to be tailored to your particular application. These items are located in a file called FreeRTOSConfig.h. Each demo application included in the FreeRTOS source code download has its own FreeRTOSConfig.h file. Here is a typical example, followed by an explanation of each parameter:#ifndef FREERTOS_CONFIG_H#define FREERTOS_CONFIG_H/* Here is a good place to include header files that are required across your application. */#include "something.h"#define configUSE_PREEMPTION 1#define configUSE_IDLE_HOOK 0#define configUSE_TICK_HOOK 0#define configCPU_CLOCK_HZ 58982400#define configTICK_RATE_HZ 250#define configMAX_PRIORITIES 5#define configMINIMAL_STACK_SIZE 128#define configTOTAL_HEAP_SIZE 10240#define configMAX_TASK_NAME_LEN 16#define configUSE_TRACE_FACILITY 0#define configUSE_16_BIT_TICKS 0#define configIDLE_SHOULD_YIELD 1#define configUSE_MUTEXES 0#define INCLUDE_vTaskPrioritySet 1#define INCLUDE_uxTaskPriorityGet 1#define INCLUDE_vTaskDelete 1#define INCLUDE_vTaskCleanUpResources 0#define INCLUDE_vTaskSuspend 1#define INCLUDE_vResumeFromISR 1#define INCLUDE_vTaskDelayUntil 1#define INCLUDE_vTaskDelay 1#define INCLUDE_xTaskGetSchedulerState 1#define INCLUDE_xTaskGetCurrentTaskHandle 1#define configUSE_CO_ROUTINES 0#define configMAX_CO_ROUTINE_PRIORITIES 1#define configKERNEL_INTERRUPT_PRIORITY [dependent of processor] #endif /* FREERTOS_CONFIG_H */'config' ParametersconfigUSE_PREEMPTIONSet to 1 to use the preemptive kernel, or 0 to use the cooperative kernel.configUSE_IDLE_HOOKSet to 1 if you wish to use an idle hook, or 0 to omit an idle hook.configUSE_TICK_HOOKSet to 1 if you wish to use an tick hook, or 0 to omit an tick hook.configCPU_CLOCK_HZEnter the frequency in Hz at which the internal processor core will be executing. This value is required in order to correctly configure timer peripherals.configTICK_RATE_HZThe frequency of the RTOS tick interrupt.The tick interrupt is used to measure time. Therefore a higher tick frequency means time can be measured to a higher resolution. However, a high tick frequency also means that the kernel will use more CPU time so be less efficient. The RTOS demo applications all use a tick rate of 1000Hz. This is used to test the kernel and is higher than would normally be required.More than one task can share the same priority. The kernel will share processor time between tasks of the same priority by switching between the tasks during each RTOS tick. A high tick rate frequency will therefore also have the effect of reducing the 'time slice' given to each task.configMAX_PRIORITIESThe number of priorities available to the application tasks. Any number of tasks can share the same priority. Co-routines are prioritised separately - see configMAX_CO_ROUTINE_PRIORITIES.Each available priority consumes RAM within the kernel so this value should not be set any higher than actually required by your application. configMINIMAL_STACK_SIZEThe size of the stack used by the idle task. Generally this should not be reduced from the value set in the FreeRTOSConfig.h file provided with the demo application for the port you are using.configTOTAL_HEAP_SIZEThe total amount of RAM available to the kernel.This value will only be used if your application makes use of one of the sample memory allocation schemes provided in the FreeRTOS source code download. See the memory configuration section for further details.configMAX_TASK_NAME_LENThe maximum permissible length of the descriptive name given to a task when the task is created. The length is specified in the number of characters including the NULL termination byte.configUSE_TRACE_FACILITYSet to 1 if you wish the trace visualisation functionality to be available, or 0 if the trace functionality is not going to be used. If you use the trace functionality a trace buffer must also be provided.configUSE_16_BIT_TICKSTime is measured in 'ticks' - which is the number of times the tick interrupt has executed since the kernel was started. The tick count is held in a variable of type portTickType.Defining configUSE_16_BIT_TICKS as 1 causes portTickType to be defined (typedef'ed) as an unsigned 16bit type. Defining configUSE_16_BIT_TICKS as 0 causes portTickType to be defined (typedef'ed) as an unsigned 32bit type. Using a 16 bit type will greatly improve performance on 8 and 16 bit architectures, but limits the maximum specifiable time period to 65535 'ticks'. Therefore, assuming a tick frequency of 250Hz, the maximum time a task can delay or block when a 16bit counter is used is 262 seconds, compared to 17179869 seconds when using a 32bit counter.configIDLE_SHOULD_YIELDThis parameter controls the behaviour of tasks at the idle priority. It only has an effect if:1. The preemptive scheduler is being used.2. The users application creates tasks that run at the idle priority.T asks that share the same priority will time slice. Assuming none of the tasks get preempted, it might be assumed that each task of at a given priority will be allocated an equal amount of processing time - and if the shared priority is above the idle priority then this is indeed the case.When tasks share the idle priority the behaviour can be slightly different. When configIDLE_SHOULD_YIELD is set to 1 the idle task will yield immediately should any other task at the idle priority be ready to run. This ensures the minimum amount of time is spent in the idle task when application tasks are available for scheduling. This behaviour can however have undesirable effects (depending on the needs of your application) as depicted below:This diagram shows the execution pattern of four tasks at the idle priority. Tasks A, B and C are application tasks. Task I is the idle task. A context switch occurs with regular period at times T0, T1, ..., T6. When the idle task yields task A starts to execute - but the idle task has already taken up some of the current time slice. This results in task I and task A effectively sharing a time slice. The application tasks B and C therefore get more processing time than the application task A.This situation can be avoided by:∙If appropriate, using an idle hook in place of separate tasks at the idle priority.∙Creating all application tasks at a priority greater than the idle priority.∙Setting configIDLE_SHOULD_YIELD to 0.Setting configIDLE_SHOULD_YIELD prevents the idle task from yielding processing time until the end of its time slice. This ensure all tasks at the idle priority are allocated an equal amount of processing time - but at the cost of a greater proportion of the total processing time being allocated to the idle task.configUSE_USE_MUTEXESSet to 1 to include mutex functionality in the build, or 0 to omit mutex functionality from the build. Readers should familiarise themselves with the differences between mutexes and binary semaphores in relation to the functionality.configUSE_CO_ROUTINESSet to 1 to include co-routine functionality in the build, or 0 to omit co-routine functionality from the build. To include co-routines croutine.c must be included in the project.configMAX_CO_ROUTINE_PRIORITIESThe number of priorities available to the application co-routines. Any number of co-routines can share the same priority. T asks are prioritised separately - see configMAX_PRIORITIES.configKERNEL_INTERRUPT_PRIORITYCurrently only in Cortex-M3/IAR, PIC24 and dsPIC ports. Other ports will get upgraded shortly. This sets the interrupt priority used by the kernel. The kernel should use a low interrupt priority, allowing higher priority interrupts to be unaffected by the kernel entering critical sections. Instead of critical sections globally disabling interrupts, they only disable interrupts that are below the kernel interrupt priority.This permits very flexible interrupt handling:∙At the kernel priority level interrupt handling 'tasks' can be written and prioritised as per any other task in the system. These are tasks that are woken by aninterrupt. The interrupt service routine (ISR) itself should be written to be as short as it possibly can be - it just grabs the data then wakes the high priority handlertask. The ISR then returns directly into the woken handler task - so interruptprocessing is contiguous in time just as if it were all done in the ISR itself. Thebenefit of this is that all interrupts remain enabled while the handler task executes.∙ISR's running above the kernel priority are never masked out by the kernel itself, so their responsiveness is not effected by the kernel functionality. However, such ISR's cannot use the API functions.T o utilize this scheme your application design must adhere to the following rule: Any interrupt that uses the API must be set to the same priority as the kernel (as configured by the configKERNEL_INTERRUPT_PRIORITY macro).INCLUDE ParametersThe macros starting 'INCLUDE' allow those components of the real time kernel not utilized by your application to be excluded from your build. This ensures the RTOS does not use any more ROM or RAM than necessary for your particular embedded application.Each macro takes the form ...INCLUDE_FunctionName... where FunctionName indicates the API function (or set of functions) that can optionally be excluded. To include the API function set the macro to 1, to exclude the function set the macro to 0. For example, to include the vT askDelete() API function use:#define INCLUDE_vTaskDelete 1To exclude vTaskDelete() from your build use:#define INCLUDE_vTaskDelete 0Memory Management[Configuration]The RTOS kernel has to allocate RAM each time a task, queue or semaphore is created. The malloc() and free() functions can sometimes be used for this purpose, but ...1. they are not always available on embedded systems,2. take up valuable code space,3. are not thread safe, and4. are not deterministic (the amount of time taken to execute the function will differfrom call to call)... so more often than not an alternative scheme is required.One embedded / real time system can have very different RAM and timing requirements to another - so a single RAM allocation algorithm will only ever be appropriate for a subset of applications.To get around this problem the memory allocation API is included in the RTOS portable layer - where an application specific implementation appropriate for the real time system being developed can be provided. When the real time kernel requires RAM, instead of calling malloc() it makes a call to pvPortMalloc(). When RAM is being freed, instead of calling free() the real time kernel makes a call to vPortFree().Schemes included in the source code downloadThree sample RAM allocation schemes are included in the FreeRTOS source code download (V2.5.0 onwards). These are used by the various demo applications as appropriate. The following subsections describe the available schemes, when they should be used, and highlight the demo applications that demonstrate their use.Each scheme is contained in a separate source file (heap_1.c, heap_2.c and heap_3.c respectively) which can be located in the Source/Portable/MemMang directory. Other schemes can be added if required.Scheme 1 - heap_1.cThis is the simplest scheme of all. It does not permit memory to be freed once it has been allocated, but despite this is suitable for a surprisingly large number of applications.The algorithm simply subdivides a single array into smaller blocks as requests for RAM are made. The total size of the array is set by the definition configTOTAL_HEAP_SIZE - which is defined in FreeRTOSConfig.h.This scheme:∙Can be used if your application never deletes a task or queue (no calls to vT askDelete() or vQueueDelete() are ever made).∙Is always deterministic (always takes the same amount of time to return a block).∙Is used by the PIC, AVR and 8051 demo applications - as these do not dynamically create or delete tasks after vT askStartScheduler() has been called.heap_1.c is suitable for a lot of small real time systems provided that all tasks and queues are created before the kernel is started.Scheme 2 - heap_2.cThis scheme uses a best fit algorithm and, unlike scheme 1, allows previously allocated blocks to be freed. It does not however combine adjacent free blocks into a single large block.Again the total amount of available RAM is set by the definition configTOTAL_HEAP_SIZE - which is defined in FreeRTOSConfig.h.This scheme:∙Can be used even when the application repeatedly callsvT askCreate()/vT askDelete() or vQueueCreate()/vQueueDelete() (causingmultiple calls to pvPortMalloc() and vPortFree()).∙Should not be used if the memory being allocated and freed is of a random size - this would only be the case if tasks being deleted each had a different stack depth, or queues being deleted were of different lengths.∙Could possible result in memory fragmentation problems should your application create blocks of queues and tasks in an unpredictable order. This would beunlikely for nearly all applications but should be kept in mind.∙Is not deterministic - but is also not particularly inefficient.∙Is used by the ARM7, and Flashlite demo applications - as these dynamically create and delete tasks.heap_2.c is suitable for most small real time systems that have to dynamically create tasks.Scheme 3 - heap_3.cThis is just a wrapper for the standard malloc() and free() functions. It makes them thread safe.This scheme:∙Requires the linker to setup a heap, and the compiler library to provide malloc() and free() implementations.∙Is not deterministic.∙Will probably considerably increase the kernel code size.∙Is used by the PC (x86 single board computer) demo application.Task Creation[API] Modules∙xT askCreate∙vT askDeleteDetailed DescriptionxTaskHandletask. hType by which tasks are referenced. For example, a call to xTaskCreate returns (via a pointer parameter) an xTaskHandle variable that can then be used as a parameter to vTaskDelete to delete the taskxTaskCreate[Task Creation]task. hportBASE_TYPE xTaskCreate(pdTASK_CODE pvTaskCode,const portCHAR * const pcName,unsigned portSHORT usStackDepth,void *pvParameters,unsigned portBASE_TYPE uxPriority,xTaskHandle *pvCreatedTask);Create a new task and add it to the list of tasks that are ready to run.Parameters:pvTaskCode Pointer to the task entry function. Tasks must be implemented to never return (i.e. continuous loop).pcName A descriptive name for the task. This is mainly used to facilitate debugging. Max length defined by configMAX_TASK_NAME_LEN.usStackDepth The size of the task stack specified as the number of variables the stack can hold - not the number of bytes. For example, if the stack is 16 bitswide and usStackDepth is defined as 100, 200 bytes will be allocated forstack storage. The stack depth multiplied by the stack width must notexceed the maximum value that can be contained in a variable of typesize_t.pvParameters Pointer that will be used as the parameter for the task being created.uxPriority The priority at which the task should run.pvCreatedTask Used to pass back a handle by which the created task can be referenced. Returns:pdPASS if the task was successfully created and added to a ready list, otherwise an error code defined in the file projdefs. hExample usage:// Task to be created.void vTaskCode( void * pvParameters ){for( ;; ){// Task code goes here.}}// Function that creates a task.void vOtherFunction( void ){unsigned char ucParameterToPass;xTaskHandle xHandle;// Create the task, storing the handle.xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );// Use the handle to delete the task.vTaskDelete( xHandle );}vTaskDelete[Task Creation]task. hvoid vTaskDelete( xTaskHandle pxTask );INCLUDE_vTaskDelete must be defined as 1 for this function to be available. See the configuration section for more information.Remove a task from the RTOS real time kernels management. The task being deleted will be removed from all ready, blocked, suspended and event lists.NOTE: The idle task is responsible for freeing the kernel allocated memory from tasks that have been deleted. It is therefore important that the idle task is not starved of microcontroller processing time if your application makes any calls to vTaskDelete (). Memory allocated by the task code is not automatically freed, and should be freed before the task is deleted.See the demo application file death. c for sample code that utilises vTaskDelete ().Parameters:pxTask The handle of the task to be deleted. Passing NULL will cause the calling task to be deleted.Example usage:void vOtherFunction( void ){xTaskHandle xHandle;// Create the task, storing the handle.xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );// Use the handle to delete the task.vTaskDelete( xHandle );}vTaskDelay[Task Control]task. hvoid vTaskDelay( portTickType xTicksToDelay );INCLUDE_vTaskDelay must be defined as 1 for this function to be available. See the configuration section for more information.Delay a task for a given number of ticks. The actual time that the task remains blocked depends on the tick rate. The constant portTICK_RATE_MS can be used to calculate real time from the tick rate - with the resolution of one tick period.Parameters:xTicksToDelay The amount of time, in tick periods, that the calling task should block. Example usage:// Perform an action every 10 ticks.// NOTE:// This is for demonstration only and would be better achieved// using vTaskDelayUntil().void vTaskFunction( void * pvParameters ){portTickType xDelay, xNextTime;// Calc the time at which we want to perform the action// next.xNextTime = xTaskGetTickCount () + ( portTickType ) 10;for( ;; ){xDelay = xNextTime - xTaskGetTickCount ();xNextTime += ( portTickType ) 10;// Guard against overflowif( xDelay <= ( portTickType ) 10 ){vTaskDelay( xDelay );}// Perform action here.}}vTaskDelayUntil[Task Control]task. hvoid vTaskDelayUntil( portTickType *pxPreviousWakeTime, portTickType xTimeIncrement );INCLUDE_vTaskDelayUntil must be defined as 1 for this function to be available. See the configuration section for more information.Delay a task until a specified time. This function can be used by cyclical tasks to ensure a constant execution frequency.This function differs from vTaskDelay() in one important aspect: vTaskDelay() specifies a time at which the task wishes to unblock relative to the time at which vTaskDelay() is called, whereas vTaskDelayUntil() specifies an absolute time at which the task wishes to unblock.vTaskDelay() will cause a task to block for the specified number of ticks from the time vTaskDelay() is called. It is therefore difficult to use vTaskDelay() by itself to generate a fixed execution frequency as the time between a task unblocking following a call to vTaskDelay() and that task next calling vTaskDelay() may not be fixed [the task may take a different path though the code between calls, or may get interrupted or preempted a different number of times each time it executes].Whereas vTaskDelay() specifies a wake time relative to the time at which the function is called, vTaskDelayUntil() specifies the absolute (exact) time at which it wishes to unblock.It should be noted that vTaskDelayUntil() will return immediately (without blocking) if it is used to specify a wake time that is already in the past. Therefore a task using vTaskDelayUntil() to execute periodically will have to re-calculate its required wake time if the periodic execution is halted for any reason (for example, the task is temporarily placed into the Suspended state) causing the task to miss one or more periodic executions. This can be detected by checking the variable passed by reference as the pxPreviousWakeTime parameter against the current tick count. This is however not necessary under most usage scenarios.The constant portTICK_RATE_MS can be used to calculate real time from the tick rate - with the resolution of one tick period.Parameters:pxPreviousWakeTime Pointer to a variable that holds the time at which the task was lastunblocked. The variable must be initialised with the current timeprior to its first use (see the example below). Following this thevariable is automatically updated within vTaskDelayUntil().xTimeIncrement The cycle time period. The task will be unblocked at time(*pxPreviousWakeTime + xTimeIncrement). CallingvTaskDelayUntil with the same xTimeIncrement parameter valuewill cause the task to execute with a fixed interval period. Example usage:// Perform an action every 10 ticks.void vTaskFunction( void * pvParameters ){portTickType xLastWakeTime;const portTickType xFrequency = 10;// Initialise the xLastWakeTime variable with the current time. xLastWakeTime = xTaskGetTickCount();for( ;; ){// Wait for the next cycle.vTaskDelayUntil( &xLastWakeTime, xFrequency );// Perform action here.}}uxTaskPriorityGet[Task Control]task. hunsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask ); INCLUDE_vTaskPriorityGet must be defined as 1 for this function to be available. See the configuration section for more information.Obtain the priority of any task.Parameters:pxTask Handle of the task to be queried. Passing a NULL handle results in the priority of the calling task being returned.Returns:The priority of pxT ask.Example usage:void vAFunction( void ){xTaskHandle xHandle;// Create a task, storing the handle.xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );// ...// Use the handle to obtain the priority of the created task.// It was created with tskIDLE_PRIORITY, but may have changed// it itself.if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY ){// The task has changed it's priority.}// ...// Is our priority higher than the created task?if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) ){// Our priority (obtained using NULL handle) is higher.}}vTaskPrioritySet[Task Control]task. hvoid vTaskPrioritySet( xTaskHandle pxTask, unsigned portBASE_TYPE uxNewPriority );INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available. See the configuration section for more information.Set the priority of any task.A context switch will occur before the function returns if the priority being set is higher than the currently executing task.Parameters:pxTask Handle to the task for which the priority is being set. Passing a NULLhandle results in the priority of the calling task being set.uxNewPriority The priority to which the task will be set.Example usage:void vAFunction( void ){xTaskHandle xHandle;// Create a task, storing the handle.xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );// ...// Use the handle to raise the priority of the created task.vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );// ...// Use a NULL handle to raise our priority to the same value.vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );}vTaskSuspend[Task Control]task. hvoid vTaskSuspend( xTaskHandle pxTaskToSuspend );INCLUDE_vTaskSuspend must be defined as 1 for this function to be available. See the configuration section for more information.Suspend any task. When suspended a task will never get any microcontroller processing time, no matter what its priority.Calls to vTaskSuspend are not accumulative - i.e. calling vTaskSuspend () twice on the same task still only requires one call to vTaskResume () to ready the suspended task.Parameters:pxTaskToSuspend Handle to the task being suspended. Passing a NULL handle will causethe calling task to be suspended.Example usage:void vAFunction( void ){xTaskHandle xHandle;// Create a task, storing the handle.xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );// ...// Use the handle to suspend the created task.vTaskSuspend( xHandle );// ...// The created task will not run during this period, unless// another task calls vTaskResume( xHandle ).//...// Suspend ourselves.vTaskSuspend( NULL );// We cannot get here unless another task calls vTaskResume// with our handle as the parameter.}vTaskResume[Task Control]task. hvoid vTaskResume( xTaskHandle pxTaskToResume );INCLUDE_vTaskSuspend must be defined as 1 for this function to be available. See the configuration section for more information.Resumes a suspended task.A task that has been suspended by one of more calls to vTaskSuspend () will be made available for running again by a single call to vTaskResume ().Parameters:pxTaskToResume Handle to the task being readied.Example usage:void vAFunction( void ){xTaskHandle xHandle;// Create a task, storing the handle.xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );// ...// Use the handle to suspend the created task.vTaskSuspend( xHandle );// ...// The created task will not run during this period, unless// another task calls vTaskResume( xHandle ).//...// Resume the suspended task ourselves.vTaskResume( xHandle );// The created task will once again get microcontroller processing // time in accordance with it priority within the system.}vTaskResumeFromISR[Task Control]task. hportBASE_TYPE vTaskResumeFromISR( xTaskHandle pxTaskToResume ); INCLUDE_vTaskSuspend and INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be available. See the configuration section for more information.A function to resume a suspended task that can be called from within an ISR.A task that has been suspended by one of more calls to vTaskSuspend() willbe made available for running again by a single call to xTaskResumeFromISR().。

[FreeRTOS⼊门]1.CubeMX中FreeRTOS配置参数及理解1.有关优先级 1.1 Configuration --> FreeRTOSMAX_PRIORITIES 设置任务优先级的数量：配置应⽤程序有效的优先级数⽬。

任何数量的任务都可以共享⼀个优先级，使⽤协程可以单独的给与它们优先权。

见MAX_CO_ROUTINE_PRIORITIES。

在RTOS内核中，每个有效优先级都会消耗⼀定量的RAM，因此这个值不要超过你的应⽤实际需要的优先级数⽬。

每⼀个任务都会被分配⼀个优先级，优先级值从0~（MAX_PRIORITIES - 1）之间。

低优先级数表⽰低优先级任务。

空闲任务的优先级为0（PriorityIdle），因此它是最低优先级任务。

FreeRTOS调度器将确保处于就绪状态（Ready）或运⾏状态（Running）的⾼优先级任务⽐同样处于就绪状态的低优先级任务优先获取处理器时间。

换句话说，处于运⾏状态的任务永远是⾼优先级任务。

处于就绪状态的相同优先级任务使⽤时间⽚调度机制共享处理器时间。

Interrupt nesting behaviour configuration 断⾔配置LIBRARY_LOWEST_INTERRUPT_PRIORITY此宏定义是⽤来配置 FreeRTOS中⽤到的SysTick中断和PendSV中断的优先级reeRTOSreeRTOSreeRTOSreeRTOS ⽤到的 SysTSysT ick 中断和 PendSV中断的优先级。

在 NVIC分组设置为4的情况下，此宏定义的范围就是 0-15 ，即专门配置抢占优先级。

这⾥即专门配置抢占优先级。

这⾥配置为了 15，即 SysTick和 PendSV 都配配置为了最低优先级，实际项⽬中也建议配置为最低优先级。

LIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY定义了受FreeRTOS管理的最⾼优先级中断。

笔记：FreeRTOS要点总结⼀、基本配置1.1 数据类型FreeRTOS 使⽤的数据类型主要分为 stdint.h ⽂件中定义的和⾃⼰定义的两种FreeRTOS 主要⾃定义了以下四种数据类型：TickType_t----32 位⽆符号数（ 32位MCU,配置configUSE_16_BIT_TICKS = 0）BaseType_t----32 位有符号数(32位MCU)UBaseType_t---32 位⽆符号数(BaseType_t类型⽆符号版本)StackType_t----32 位变量(栈变量数据类型定义,32位MCU)1.2 代码风格变量uint32_t 定义的变量都加上前缀 ul。

u 代表 unsigned ⽆符号，l 代表 long 长整型。

uint16_t 定义的变量都加上前缀 us。

u 代表 unsigned ⽆符号，s 代表 short 短整型。

uint8_t 定义的变量都加上前缀 uc。

u 代表 unsigned ⽆符号，c 代表 char 字符型。

stdint.h ⽂件中未定义的变量类型，在定义变量时需要加上前缀 x，⽐如 BaseType_t 和TickType_t 定义的变量。

stdint.h ⽂件中未定义的⽆符号变量类型，在定义变量时要加上前缀 u，⽐如 UBaseType_t 定义的变量要加上前缀 ux。

size_t 定义的变量也要加上前缀 ux。

枚举变量会加上前缀 e。

指针变量会加上前缀 p，⽐如 uint16_t 定义的指针变量会加上前缀 pus。

根据 MISRA 代码规则，char 定义的变量只能⽤于 ASCII 字符，前缀使⽤ c。

根据 MISRA 代码规则，char *定义的指针变量只能⽤于 ASCII 字符串，前缀使⽤ pc。

函数加上了 static 声明的函数，定义时要加上前缀 prv，这个是单词 private 的缩写。

带有返回值的函数，根据返回值的数据类型，加上相应的前缀，如果没有返回值，即 void 类型，函数的前缀加上字母 v。

RTOS操作系统讲解--FreeRTOS一、操作系统背景讲解操作系统有实时操作系统和分时操作系统。

通常使用的实时操作系统（RTOS）有如MQXLite、MQX、FreeRTOS、uCOS-III、uCLinux、VxWorks、eCos实时操作系统：在一定时间限制内完成特定功能，并控制所有实时任务协调一致工作的操作系统，提供及时响应并具备高可靠性。

实时操作系统分为两种，硬实时（规定时间内完成操作），软实时（按照任务优先级完成操作）。

特征：多任务、有线程优先级、多种中断级别。

使用非实时嵌入式操作系统，例分时操作系统(Time-sharing Operating System)，如Android、Linxu、iOS、Windows CE分时操作系统：将系统处理机时间和内存空间按照一定的时间间隔，轮流地切换给各终端用户的程序使用。

特征：交互性、多路性、独立性、及时性。

那么实时操作系统和分时操作系统的主要区别的第一性是什么呢？本质就在于设计操作系统的时候，架构机制必须支持是否需要在特定的时间内完成某项任务。

if yes，real-time os，otherwise no.英文称Real Time Operating System，简称RTOS。

二、实时操作系统讲解1.实时操作系统定义实时操作系统（RTOS）是指当外界事件或数据产生时，能够接受并以足够快的速度予以处理，其处理的结果又能在规定的时间之内来控制生产过程或对处理系统作出快速响应，并控制所有实时任务协调一致运行的操作系统。

因而，提供及时响应和高可靠性是其主要特点。

实时操作系统有硬实时和软实时之分，硬实时要求在规定的时间内必须完成操作，这是在操作系统设计时保证的；软实时则只要按照任务的优先级，尽可能快地完成操作即可。

我们通常使用的操作系统在经过一定改变之后就可以变成实时操作系统。

实时操作系统是保证在一定时间限制内完成特定功能的操作系统。

例如，可以为确保生产线上的机器人能获取某个物体而设计一个操作系统。

FreeRTOS学习笔记5——InterruptFreeRTOS Interrupt ManagementFreeRTOS在任务和中断中使⽤两个版本API，以必免造成阻塞，中断使⽤的API以FromISR结尾xHigherPriorityTaskWoken如果在中断中应⽤上下⽂切换(xHigherPriorityTaskWoken=pdTRUE)，中断将中断⼀个进程，⽽退出中断后切换到另⼀个进程中去。

如果被唤醒的进程的优先级⼤于当前运⾏的进程时，将切换⾄优先级⾼的进程，抢占策略线程安全API（以FromISR结尾的API),有⼀个指针参数pxHigherPriorityTaskWoken,⽤以指⽰当前中断是否需要进⾏上下⽂切换当需要进⾏上下⽂切换时，API(FromISR)会将*pxHigherPriorityTaskWoken=pdTRUE, 在使⽤API(FromISR)之前，必需将pxHigherPriorityTaskWoken 初使化为pdFALSE若ISR中调⽤多个API(FromISR),时，必须在调⽤每个API之前将pxHigherPriorityTaskWoken初使化为pdFALSE pxHigherPriorityTaskWoken 是可选的，当不⽤时可以将pxHigherPriorityTaskWoken 设为NULL。

portYIELD_FROM_ISR() and portEND_SWITCHING_ISR()taskYIELD()是宏⽤于在task中请求context切换portYIELD_FROM_ISR(), portEND_SWITCHING_ISR()⽤法相同，都是taskYIELD()的 safe version.portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );portYIELD_FROM_ISR( xHigherPriorityTaskWoken );The xHigherPriorityTaskWoken parameter passed out of an interrupt safe API function can beused directly as the parameter in a call to portYIELD_FROM_ISR()⼤部分FreeRTOS ports允许在ISR中的任何位置调⽤portYIELD_FROM_ISR()有⼀⼩部分 ports 只允许在ISR尾部调⽤portYIELD_FROM_ISR()延迟中断处理Deferred Interrupt Processing中断处理要尽可能短An interrupt service routine must record the cause of the interrupt, and clear the interrupt. Any other processing necessitated by the interrupt can often be performed in a task, allowing the interrupt service routine to exit as quickly as is practical. This is called deferred interrupt processing, because the processing necessitated by the interrupt is deferred from the ISR to a taskBinary Semaphores Used for Synchronization⼆进制信号量⽤于同步Binary Semaphores 通常⽤于将中断处理程序延迟⾄task中处理的⽬的。

用了半天时间对FreeRTOS有了一个初步的认识，大概总结一下，其中混杂了系统实现和实际应用方面的问题。

现只是以应用为目的，实现方面待以后进一步研究。

1.FreeRTOS提供的功能包括：任务管理、时间管理、信号量、消息队列、内存管理。

与平台有关的文件包含在portable文件夹中，主要是port.c, portmacro.h 两个文件。

平台无关的文件主要是：list.c(基本链表结构), queue.c(包括消息队列，信号量的实现), croutine.c,tasks.c(任务管理，时间管理)。

命名协定RTOS内核与范例程序源代码使用下面的协定：变量char类型的变量以c 为前缀short类型的变量以s 为前缀long类型的变量以l 为前缀float类型的变量以f 为前缀double类型的变量以d 为前缀枚举变量以e 为前缀其他类型（如结构体）以x 为前缀指针有一个额外的前缀p , 例如short类型的指针前缀为ps无符号类型的变量有一个额外的前缀u , 例如无符号short类型的变量前缀为us函数文件内部函数以prv为前缀API函数以其返回值类型为前缀，按照前面对变量的定义函数的名字以其所在的文件名开头。

如vTaskDelete函数在Task.c文件中定义数据类型数据类型并不直接在RTOS内核内部引用。

相反，每个平台都有其自身的定义方式。

例如，char类型定义为portCHAR，short类型定义为portSHORT等。

范例程序源代码使用的就是这种符号，但这并不是必须的，你可以在你的程序中使用任何你喜欢的符号。

此外，有两种额外的类型要为每种平台定义。

分别是：portTickType可配置为16位的无符号类型或32位的无符号类型。

参考API文档中的定制部分获取详细信息。

portBASE_TYPE为特定体系定义的最有效率的数据类型。

如果portBASE_TYPE定义为char则必须要特别小心的保证用来作为函数返回值的signed char可以为负数，用于指示错误。

干货FreeRTOS学习笔记——中断与任务切换EEWorld电子资讯犀利解读技术干货每日更新在FreeRTOS具备了任务的内存资源——堆栈管理机制，能根据任务状态和优先级进行CPU执行的上下文切换，并提供了任务间通信渠道以实现必要的任务同步和互斥之后，多个任务可以协同起来工作了。

不过，既然名称叫做Real-Time (实时)的操作系统，还需要能对外部(硬件)事件作出快速的响应。

尤其是对于单片机上的应用，在一个硬件中断(IRQ)产生以后，立即唤醒某个任务来处理这个事件是操作系统必须要支持的。

从任务的角度来看，其实有很多任务是需要根据硬件上的事件（比如传输完成，设备就绪，接收到数据等）来被调度的，否则它将不停测试硬件设备状态寄存器标志位，浪费CPU时间。

FreeRTOS 的时间片管理，其实背后就是借用了定时器中断。

不然不可能一个任务执行时没有申请调度就被打断，去执行其它同一优先级的任务。

类似的，任何硬件中断发生时都会执行相应的中断服务程序(Interrupt Service Routine, ISR, 又叫IRQ Handler)，在ISR执行完之后是返回当前任务，还是调度执行其它任务？这完全由ISR来决定。

1. ISR 独立于所有任务尽管从效果上看，ISR,即中断服务程序是为了某个任务的功能在服务的，务必先强调一下：ISR 的代码不属于FreeRTOS 任何一个任务代码的部分。

每个ISR 都是一个C语言函数，但它不是一个任务，也不会被任何一个任务所调用。

ISR 对堆栈的使用与任务不同。

前面的连载中已经介绍过，FreeRTOS 对每个任务分配了独立的堆栈空间，用于保存函数的局部变量等等。

在发生中断时，CPU的某些寄存器会被保存到当前的堆栈里(而不是指定某任务的堆栈)，然后开始执行ISR程序。

如果当前是某个任务的代码正被执行，则会占用该任务的堆栈；如果当前是另外一个ISR 的代码正在执行即发生中断嵌套，那么可能继续用更早被中断的任务的堆栈（注：这与平台有关。

FreeRTOS学习笔记——系统配置FreeRTOS的系统配置⽂件是“FreeRTOSConfig.h”，通过此⽂件可以对系统进⾏裁剪和配置。

FreeRTOS的配置基本都是通过“FreeRTOSConfig.h”中的#define语句来定义宏定义实现的。

⼀、“INCLUDE_”开始的宏使⽤“INCLUDE_”开始的宏表⽰使能或除能对应的FreeRTOS的API函数，作⽤就是⽤来配置FreeRTOS的可选API函数。

⽐如当宏INCLUDE_vTaskPrioritySet配置为0的时候不能表⽰不能使⽤vTaskPrioritySet()函数。

如图所⽰：只有当宏INCLUDE_vTaskPrioritySet配置为1的时候，vTaskPrioritySet()函数才会被编译。

不⽌FreeRTOS这么⼲，其他的很多协议栈、GUI库和RTOS系统也都是使⽤条件编译来实现配置和剪裁的，条件编译的好处就是节省空间，不需要的功能就不⽤编译，根据实际需求减少系统占⽤的RAM和ROM⼤⼩，根据⾃⼰使⽤的MCU来调整系统消耗，降低成本。

其他的⼏个INCLUDE_开头的宏也是相同的道理：⼆、“config”开始的宏1.configAPPLICATION_ALLOCATED_HEAP“config”开始的宏也是⽤来完成FreeRTOS配置和裁剪的，例如，configAPPLICATION_ALLOCATED_HEAP定义为1的话，堆内存可以由⽤户⾃⾏配置，堆内存在heap1.c、heap2.c、heap3.c、heap4.c和heap5.c中有定义，具体在哪⼀个⽂件，取决于选择的内存管理⽅式。

例如我们使⽤了heap4.c，在heap4.c中就有如图所⽰的定义：当宏configAPPLICATION_ALLOCATED_HEAP配置为1的时候，需要⽤户⾃⾏配置堆内存ucHeap，否则由编译器分配。

2.configASSERT断⾔，类似C库中的assert()函数，调试代码的时候判断传⼊的参数是否合理。

正点原子freertos开发指南概述及解释说明1. 引言1.1 概述在嵌入式系统领域，实时操作系统（RTOS）成为了开发者必备的工具之一。

正点原子freertos是一种流行的RTOS，广泛应用于嵌入式设备的开发和设计中。

本文旨在提供一份详尽的指南，帮助读者理解和使用正点原子freertos。

1.2 文章结构本文将按照以下结构进行介绍和讲解。

首先，我们将在引言部分对文章进行概述，并阐明文章的目的。

然后，在正文部分，将深入讨论正点原子freertos的开发指南。

接着，在解释说明部分，我们将详细解析正点原子freertos中的核心概念，并展开讲解任务调度器以及任务通信与同步机制。

最后，在结论部分对整个开发指南进行总结。

1.3 目的本文的目的是提供读者全面而又易于理解的资料，来帮助初学者迅速上手并熟练使用正点原子freertos。

通过本文，读者将了解到这款RTOS的基本概念、特点与优势，并能够掌握它在嵌入式设备开发中所扮演的角色和功能。

同时，本文还旨在通过详细的解释说明部分，帮助读者深入理解正点原子freertos中的核心概念以及相关机制的运作原理。

最后，本文将通过总结部分，使读者对于整个开发指南有一个完整而清晰的认识。

这篇文章将成为初学者入门正点原子freertos开发所不可或缺的书籍，并且也非常适合已经有一定基础知识的开发人员参考和进一步提高。

我们相信，在阅读本文后，读者将能够充分了解并掌握正点原子freertos的开发过程和相关概念，从而在嵌入式系统领域取得更好的成果。

2. 正文：正文部分将详细介绍正点原子freertos的开发相关内容。

主要包括以下几个方面：2.1 什么是正点原子freertos正点原子freertos是一款基于实时操作系统（RTOS）的开发平台，专注于嵌入式系统开发。

它提供了一套完整且易于使用的工具和库，帮助开发者快速构建可靠、高效的嵌入式应用程序。

2.2 freertos的架构和特性我们将介绍freertos的整体架构和核心特性。