freertos学习

freertos的基本框架如下

　　

注意有三点很重要：

　　1.任务的资源

　　　　（1）任务优先级：freertos 能够调度的任务优先级在freertosConfig.h中的configMAX_PRIORITIES中定义，每一个任务的优先级都在0~configMAX_PRIORITIES -1 中取值 优先级是数值越小，优先级越小，空闲任务的优先级为0.高优先级的任务必须有延时，低优先级的任务才能获得人物使用权。

　　　　　　任务优先级在定义时，可参考以下的规则：

　　　　　    ① IRQ 任务：IRQ 任务是指通过中断服务程序进行触发的任务，此类任务应该设置为所有任务里面优先级最高的。

　　　　　　② 高优先级后台任务：比如按键检测，触摸检测，USB 消息处理，串口消息处理等，都可以归为这一类任务。

　　　　　　③ 低优先级的时间片调度任务：比如 emWin 的界面显示，LED 数码管的显示等不需要实时执行的都可以归为这一类任务。 实际应用中用户不必拘泥于将这些任务都设置为优先级 1 的同优先级任务，可以设置多个优先级，只需注意这类任务不需要高实时性。

（2）任务栈的大小：在freertosConfig.h中定义了一个总的堆栈的大小configTOTAL_HEAP_SIZE。如何这个值不够使用的话可以增大这个值。每个任务的栈都是特别要注意的。如果任务出现不运行，很大可能是任务栈不够用了。在freertos中有一个API可以获取在程序运行到现在，栈的接近历史最高水平线的值。我们需要在配置头文件将宏configCHECK_FOR_STACK_OVERFLOW 打开，这宏可定义为两个值1或者2，这两个值有着不同的检测方法，这两个方法不在赘叙。我们还需要调用任务栈溢出的时候，将溢出的任务的名字打印出来，或者进行其他处理。

　　　　2.线程间的通讯

　　（1）信号量 ：二值信号量、计数信号量、互斥信号量。在多个任务等待同一个信号量来进行同步时，当这些任务优先级相等时，他们依次交叉获取 ，当这些任务优先级不同时，就会只有高优先级的任务会获取。

　　（2）队列：注意取队列的速度和发送队列的速度，与他们的等待时长。注意判断返回值

　　（3）事件组：事件组相当于一个软件寄存器，每一位都有一个标志。常用于当一个任务同时满足多个条件（与的关系）或者满足多个条件的某一个条件（或的关系）时使用。

　　　3.所有的API都要注意是不是在中断中调用。

其他：软件定时器：本质上就是队列，需要自己注册定时到后的回调函数。

 #include "mytask.h"
 #include "task.h"
 #include "timers.h"

 /* TASK HANDLERS */
 TaskHandle_t startHandle;
 TaskHandle_t ledHandle;
 TaskHandle_t printfHandle;
 TaskHandle_t writeQueueHandle;
 TaskHandle_t SemaphoreBinaryHandle;
 TaskHandle_t eventgrupHandle;
 TimerHandle_t timer;
 /* TASK INPUT VARIABLES */
 u32 led_params = ;
 char *databuf = "hello world";
 u8 queue_buff[];
 u8 TIMER_ID = ;
 /* thread commutication variables */
 xQueueHandle myqueue;
 xSemaphoreHandle semphorebinary;
 EventGroupHandle_t eventgroup;
 /* task status */
 portBASE_TYPE status;

 void start_task(void *param)
 {
     printf("start task\r\n");

     myqueue = xQueueCreate(,*sizeof(char));

   vSemaphoreCreateBinary(semphorebinary);
     timer = xTimerCreate("timer test",/portTICK_PERIOD_MS,pdTRUE,(void*)&TIMER_ID,AutoReloadTimer_Handle_callback);
     eventgroup  = xEventGroupCreate(); 

     taskENTER_CRITICAL();
     xTaskCreate(led_task,"led task",START_STA_SIZE,(void*)&led_params,LED_TASK_PRTO,ledHandle);
     xTaskCreate(printf_task,"printf task",PRINTF_STA_SIZE,(void *)databuf,PRTINF_TASK_PRIO,printfHandle);
     xTaskCreate(writeQueue_task,"write queue task",WRITEQUEUE_STA_SIZE,NULL,WRITEQUEUE_TASK_PRIO,writeQueueHandle);
     xTaskCreate(SemaphoreBinary_task,"xsemphorebinary task",BINARY_STA_SIZE,NULL,PRTINF_TASK_PRIO,SemaphoreBinaryHandle);
     xTaskCreate(eventgrup_task,"eventgrup task",EVENT_STA_SIZE,NULL,EVENT_TASK_PRIO,eventgroup);
     taskEXIT_CRITICAL();
     //xTimerStart(timer,0);
     vTaskDelete(NULL);
 }

 void led_task(void*param)
 {

     while()
     {

             HAL_GPIO_WritePin(GPIOJ,GPIO_PIN_13,GPIO_PIN_SET);    //PB1置1
           HAL_GPIO_WritePin(GPIOJ,GPIO_PIN_5, GPIO_PIN_RESET);    //PB1置1
             vTaskDelay(*(u32*)param);
           HAL_GPIO_WritePin(GPIOJ,GPIO_PIN_13,GPIO_PIN_RESET);    //PB1置1
           HAL_GPIO_WritePin(GPIOJ,GPIO_PIN_5, GPIO_PIN_SET);    //PB1置1
           vTaskDelay(*(u32*)param);
             xEventGroupSetBits(eventgroup,0x1);
     }

 }

 void printf_task(void*param)
 {
     while()
     {
       status =  xQueueReceive(myqueue,queue_buff,portMAX_DELAY);
         if(status == pdPASS)
         {
             taskENTER_CRITICAL();
             printf("%s\r\n",queue_buff);

             taskEXIT_CRITICAL();
         }
         else printf("queue null \r\n");
         vTaskDelay();
     }
 }

 void writeQueue_task(void *param)
 {
     u8 i =;
     while()
     {
         status = xQueueSend(myqueue,queue_buff,);
         if(status!= pdPASS) printf("queue full\r\n");
         i++;
         if(!(i%))
         {
 //            xSemaphoreTake(semphorebinary,portMAX_DELAY);
 //                printf("get once baniry\r\n");
                 xEventGroupSetBits(eventgroup,0x4);
         }
         vTaskDelay();
     }
 }

 void SemaphoreBinary_task(void*param)
 {
      u8 i =;
         while()
         {
             i++;
             if(!(i%))
             {
                 xSemaphoreGive(semphorebinary);

             }
             vTaskDelay();
             xEventGroupSetBits(eventgroup,0x2);
         }

 }

 void eventgrup_task(void*param)
 {
     while()
     {
             xEventGroupWaitBits(eventgroup,0x7,pdTRUE,pdFALSE,portMAX_DELAY);
             printf(" event groups test!!! \r\n");
   }

 }

 void vApplicationStackOverflowHook( TaskHandle_t xTask, char *pcTaskName )
 {
     printf("task overflow name :%s\r\n",pcTaskName);

 }
 void AutoReloadTimer_Handle_callback(TimerHandle_t xTimer)
 {
     static u32 count  = ;
     count++;
     if(count>)
     {
     //    xTimerReset(timer,0);
         xTimerStop(timer,);
     }
     printf("timer count: %d\r\n",count);
 }

 void print_high_stack_mark_value(void)
 {
     if(STACK_DEBUG)
     {
         u8 num =;
         num = uxTaskGetStackHighWaterMark(ledHandle);
         printf("%s  : %d\r\n",pcTaskGetTaskName(ledHandle),num);
         num = uxTaskGetStackHighWaterMark(ledHandle);
         printf("%s  : %d\r\n",pcTaskGetTaskName(ledHandle),num);
         num = uxTaskGetStackHighWaterMark(ledHandle);
         printf("%s  : %d\r\n",pcTaskGetTaskName(ledHandle),num);    

     }

 }

freertos test code