main.c

  1. #include "sys.h"
  2. #include "delay.h"
  3. #include "usart.h"
  4. #include "led.h"
  5. #include "timer.h"
  6. #include "lcd.h"
  7. #include "FreeRTOS.h"
  8. #include "task.h"
  9. /************************************************
  10.  ALIENTEK Mini STM32F103开发板 FreeRTOS实验6-2
  11.  FreeRTOS任务创建和删除(静态方法)-库函数版本
  12.  技术支持：www.openedv.com
  13.  淘宝店铺：http://eboard.taobao.com 
  14.  关注微信公众平台微信号："正点原子"，免费获取STM32资料。
  15.  广州市星翼电子科技有限公司  
  16.  作者：正点原子 @ALIENTEK
  17. ************************************************/
  19. //空闲任务任务堆栈
  20. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
  21. //空闲任务控制块
  22. static StaticTask_t IdleTaskTCB;
  24. //定时器服务任务堆栈
  25. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
  26. //定时器服务任务控制块
  27. static StaticTask_t TimerTaskTCB;
  29. //任务优先级
  30. #define START_TASK_PRIO        1
  31. //任务堆栈大小    
  32. #define START_STK_SIZE         128  
  33. //任务堆栈
  34. StackType_t StartTaskStack[START_STK_SIZE];
  35. //任务控制块
  36. StaticTask_t StartTaskTCB;
  37. //任务句柄
  38. TaskHandle_t StartTask_Handler;
  39. //任务函数
  40. void start_task(void *pvParameters);
  42. //任务优先级
  43. #define TASK1_TASK_PRIO        2
  44. //任务堆栈大小    
  45. #define TASK1_STK_SIZE         128  
  46. //任务堆栈
  47. StackType_t Task1TaskStack[TASK1_STK_SIZE];
  48. //任务控制块
  49. StaticTask_t Task1TaskTCB;
  50. //任务句柄
  51. TaskHandle_t Task1Task_Handler;
  52. //任务函数
  53. void task1_task(void *pvParameters);
  55. //任务优先级
  56. #define TASK2_TASK_PRIO        3
  57. //任务堆栈大小    
  58. #define TASK2_STK_SIZE         128 
  59. //任务堆栈
  60. StackType_t Task2TaskStack[TASK2_STK_SIZE];
  61. //任务控制块
  62. StaticTask_t Task2TaskTCB;
  63. //任务句柄
  64. TaskHandle_t Task2Task_Handler;
  65. //任务函数
  66. void task2_task(void *pvParameters);
  68. //LCD刷屏时使用的颜色
  69. int lcd_discolor[14]={    WHITE, BLACK, BLUE,  BRED,      
  70.                       GRED,  GBLUE, RED,   MAGENTA,            
  71.                       GREEN, CYAN,  YELLOW,BROWN,             
  72.                       BRRED, GRAY };
  74. //获取空闲任务地任务堆栈和任务控制块内存，因为本例程使用的
  75. //静态内存，因此空闲任务的任务堆栈和任务控制块的内存就应该
  76. //有用户来提供，FreeRTOS提供了接口函数vApplicationGetIdleTaskMemory()
  77. //实现此函数即可。
  78. //ppxIdleTaskTCBBuffer:任务控制块内存
  79. //ppxIdleTaskStackBuffer:任务堆栈内存
  80. //pulIdleTaskStackSize:任务堆栈大小
  81. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, 
  82.                                    StackType_t **ppxIdleTaskStackBuffer, 
  83.                                    uint32_t *pulIdleTaskStackSize)
  84. {
  85.     *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
  86.     *ppxIdleTaskStackBuffer=IdleTaskStack;
  87.     *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
  88. }
  90. //获取定时器服务任务的任务堆栈和任务控制块内存
  91. //ppxTimerTaskTCBBuffer:任务控制块内存
  92. //ppxTimerTaskStackBuffer:任务堆栈内存
  93. //pulTimerTaskStackSize:任务堆栈大小
  94. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, 
  95.                                     StackType_t **ppxTimerTaskStackBuffer, 
  96.                                     uint32_t *pulTimerTaskStackSize)
  97. {
  98.     *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
  99.     *ppxTimerTaskStackBuffer=TimerTaskStack;
  100.     *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
  101. }
  103. int main(void)
  104. {
  105.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4     
  106.     delay_init();                        //延时函数初始化     
  107.     uart_init(115200);                    //初始化串口
  108.     LED_Init();                              //初始化LED
  109.     LCD_Init();                            //初始化LCD
  111.     POINT_COLOR = RED;
  112.     LCD_ShowString(30,10,200,16,16,"ATK STM32F103/407");    
  113.     LCD_ShowString(30,30,200,16,16,"FreeRTOS Examp 6-2");
  114.     LCD_ShowString(30,50,200,16,16,"Task Creat and Del");
  115.     LCD_ShowString(30,70,200,16,16,"ATOM@ALIENTEK");
  116.     LCD_ShowString(30,90,200,16,16,"2016/11/25");
  118.     //创建开始任务
  119.     StartTask_Handler=xTaskCreateStatic((TaskFunction_t    )start_task,        //任务函数
  120.                                         (const char*     )"start_task",        //任务名称
  121.                                         (uint32_t         )START_STK_SIZE,    //任务堆栈大小
  122.                                         (void*               )NULL,                //传递给任务函数的参数
  123.                                         (UBaseType_t     )START_TASK_PRIO,     //任务优先级
  124.                                         (StackType_t*   )StartTaskStack,    //任务堆栈
  125.                                         (StaticTask_t*  )&StartTaskTCB);    //任务控制块              
  126.     vTaskStartScheduler();          //开启任务调度
  127. }
  129. //开始任务任务函数
  130. void start_task(void *pvParameters)
  131. {
  132.     taskENTER_CRITICAL();           //进入临界区
  133.     //创建TASK1任务
  134.     Task1Task_Handler=xTaskCreateStatic((TaskFunction_t    )task1_task,        
  135.                                         (const char*     )"task1_task",        
  136.                                         (uint32_t         )TASK1_STK_SIZE,    
  137.                                         (void*               )NULL,                
  138.                                         (UBaseType_t     )TASK1_TASK_PRIO,     
  139.                                         (StackType_t*   )Task1TaskStack,    
  140.                                         (StaticTask_t*  )&Task1TaskTCB);    
  141.     //创建TASK2任务
  142.     Task2Task_Handler=xTaskCreateStatic((TaskFunction_t    )task2_task,        
  143.                                         (const char*     )"task2_task",        
  144.                                         (uint32_t         )TASK2_STK_SIZE,    
  145.                                         (void*               )NULL,                
  146.                                         (UBaseType_t     )TASK2_TASK_PRIO,     
  147.                                         (StackType_t*   )Task2TaskStack,    
  148.                                         (StaticTask_t*  )&Task2TaskTCB);
  149.     vTaskDelete(StartTask_Handler); //删除开始任务
  150.     taskEXIT_CRITICAL();            //退出临界区
  151. }
  153. //task1任务函数
  154. void task1_task(void *pvParameters)
  155. {
  156.     u8 task1_num=0;
  158.     POINT_COLOR = BLACK;
  160.     LCD_DrawRectangle(5,110,115,314);     //画一个矩形    
  161.     LCD_DrawLine(5,130,115,130);        //画线
  162.     POINT_COLOR = BLUE;
  163.     LCD_ShowString(6,111,110,16,16,"Task1 Run:000");
  164.     while(1)
  165.     {
  166.         task1_num++;    //任务执1行次数加1 注意task1_num1加到255的时候会清零！！
  167.         LED0=!LED0;
  168.         printf("任务1已经执行：%d次\r\n",task1_num);
  169.         if(task1_num==5) 
  170.         {
  171.             vTaskDelete(Task2Task_Handler);//任务1执行5次删除任务2
  172.             printf("任务1删除了任务2!\r\n");
  173.         }
  174.         LCD_Fill(6,131,114,313,lcd_discolor[task1_num%14]); //填充区域
  175.         LCD_ShowxNum(86,111,task1_num,3,16,0x80);    //显示任务执行次数
  176.         vTaskDelay(1000);                           //延时1s，也就是1000个时钟节拍    
  177.     }
  178. }
  180. //task2任务函数
  181. void task2_task(void *pvParameters)
  182. {
  183.     u8 task2_num=0;
  185.     POINT_COLOR = BLACK;
  187.     LCD_DrawRectangle(125,110,234,314); //画一个矩形    
  188.     LCD_DrawLine(125,130,234,130);        //画线
  189.     POINT_COLOR = BLUE;
  190.     LCD_ShowString(126,111,110,16,16,"Task2 Run:000");
  191.     while(1)
  192.     {
  193.         task2_num++;    //任务2执行次数加1 注意task1_num2加到255的时候会清零！！
  194.         LED1=!LED1;
  195.         printf("任务2已经执行：%d次\r\n",task2_num);
  196.         LCD_ShowxNum(206,111,task2_num,3,16,0x80);  //显示任务执行次数
  197.         LCD_Fill(126,131,233,313,lcd_discolor[13-task2_num%14]); //填充区域
  198.         vTaskDelay(1000);                           //延时1s，也就是1000个时钟节拍    
  199.     }
  200. }

程序下载：

FreeRTOS实验6-1 FreeRTOS任务创建和删除实验(动态方法).zip