18.7.1 二值信号量同步实验

信号量同步实验是在 FreeRTOS 中创建了两个任务，一个是获取信号量任务，一个是释放互斥量任务，两个任务独立运行，获取信号量任务是一直在等待信号量，其等待时间是 portMAX_DELAY，等到获取到信号量之后， 任务开始执行任务代码，如此反复等待另外任务释放的信号。
释放信号量任务在检测按键是否按下，如果按下则释放信号量，此时释放信号量会唤醒获取任务，获取任务开始运行，然后形成两个任务间的同步，因为如果没按下按键，那么信号量就不会释放，只有当信号量释放的时候，获取信号量的任务才会被唤醒，如此一来就达到任务与任务的同步， 同时程序的运行会在串口打印出相关信息。

  2. /* FreeRTOS头文件 */
  3. #include "FreeRTOS.h"
  4. #include "task.h"
  5. #include "queue.h"
  6. #include "semphr.h"
  7. /* 开发板硬件bsp头文件 */
  8. #include "bsp_led.h"
  9. #include "bsp_usart.h"
  10. #include "bsp_key.h"
  11. /**************************** 任务句柄 ********************************/
  12. /* 
  13.  * 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
  14.  * 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
  15.  * 这个句柄可以为NULL。
  16.  */
  17. static TaskHandle_t AppTaskCreate_Handle = NULL;/* 创建任务句柄 */
  18. static TaskHandle_t Receive_Task_Handle = NULL;/* LED任务句柄 */
  19. static TaskHandle_t Send_Task_Handle = NULL;/* KEY任务句柄 */
  21. /********************************** 内核对象句柄 *********************************/
  22. /*
  23.  * 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
  24.  * 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
  25.  * 们就可以通过这个句柄操作这些内核对象。
  26.  *
  27.  * 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
  28.  * 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
  29.  * 来完成的
  30.  * 
  31.  */
  32. SemaphoreHandle_t BinarySem_Handle =NULL;
  34. /******************************* 全局变量声明 ************************************/
  35. /*
  36.  * 当我们在写应用程序的时候，可能需要用到一些全局变量。
  37.  */
  40. /******************************* 宏定义 ************************************/
  41. /*
  42.  * 当我们在写应用程序的时候，可能需要用到一些宏定义。
  43.  */
  46. /*
  47. *************************************************************************
  48. *                             函数声明
  49. *************************************************************************
  50. */
  51. static void AppTaskCreate(void);/* 用于创建任务 */
  53. static void Receive_Task(void* pvParameters);/* Receive_Task任务实现 */
  54. static void Send_Task(void* pvParameters);/* Send_Task任务实现 */
  56. static void BSP_Init(void);/* 用于初始化板载相关资源 */
  58. /*****************************************************************
  59.   * @brief  主函数
  60.   * @param  无
  61.   * @retval 无
  62.   * @note   第一步：开发板硬件初始化 
  63.             第二步：创建APP应用任务
  64.             第三步：启动FreeRTOS，开始多任务调度
  65.   ****************************************************************/
  66. int main(void)
  67. {    
  68.   BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  70.   /* 开发板硬件初始化 */
  71.   BSP_Init();
  72.     printf("这是一个[野火]-STM32全系列开发板-FreeRTOS二值信号量同步实验！\n");
  74.   printf("按下KEY1或者KEY2进行任务与任务间的同步\n");
  75.    /* 创建AppTaskCreate任务 */
  76.   xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,  /* 任务入口函数 */
  77.                         (const char*    )"AppTaskCreate",/* 任务名字 */
  78.                         (uint16_t       )512,  /* 任务栈大小 */
  79.                         (void*          )NULL,/* 任务入口函数参数 */
  80.                         (UBaseType_t    )1, /* 任务的优先级 */
  81.                         (TaskHandle_t*  )&AppTaskCreate_Handle);/* 任务控制块指针 */ 
  82.   /* 启动任务调度 */           
  83.   if(pdPASS == xReturn)
  84.     vTaskStartScheduler();   /* 启动任务，开启调度 */
  85.   else
  86.     return -1;  
  88.   while(1);   /* 正常不会执行到这里 */    
  89. }
  92. /***********************************************************************
  93.   * @ 函数名  ： AppTaskCreate
  94.   * @ 功能说明： 为了方便管理，所有的任务创建函数都放在这个函数里面
  95.   * @ 参数    ： 无  
  96.   * @ 返回值  ： 无
  97.   **********************************************************************/
  98. static void AppTaskCreate(void)
  99. {
  100.   BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  102.   taskENTER_CRITICAL();           //进入临界区
  104.   /* 创建 BinarySem */
  105.   BinarySem_Handle = xSemaphoreCreateBinary();     
  106.   if(NULL != BinarySem_Handle)
  107.     printf("BinarySem_Handle二值信号量创建成功!\r\n");
  109.   /* 创建Receive_Task任务 */
  110.   xReturn = xTaskCreate((TaskFunction_t )Receive_Task, /* 任务入口函数 */
  111.                         (const char*    )"Receive_Task",/* 任务名字 */
  112.                         (uint16_t       )512,   /* 任务栈大小 */
  113.                         (void*          )NULL,    /* 任务入口函数参数 */
  114.                         (UBaseType_t    )2,        /* 任务的优先级 */
  115.                         (TaskHandle_t*  )&Receive_Task_Handle);/* 任务控制块指针 */
  116.   if(pdPASS == xReturn)
  117.     printf("创建Receive_Task任务成功!\r\n");
  119.   /* 创建Send_Task任务 */
  120.   xReturn = xTaskCreate((TaskFunction_t )Send_Task,  /* 任务入口函数 */
  121.                         (const char*    )"Send_Task",/* 任务名字 */
  122.                         (uint16_t       )512,  /* 任务栈大小 */
  123.                         (void*          )NULL,/* 任务入口函数参数 */
  124.                         (UBaseType_t    )3, /* 任务的优先级 */
  125.                         (TaskHandle_t*  )&Send_Task_Handle);/* 任务控制块指针 */ 
  126.   if(pdPASS == xReturn)
  127.     printf("创建Send_Task任务成功!\n\n");
  129.   vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
  131.   taskEXIT_CRITICAL();            //退出临界区
  132. }
  136. /**********************************************************************
  137.   * @ 函数名  ： Receive_Task
  138.   * @ 功能说明： Receive_Task任务主体
  139.   * @ 参数    ：   
  140.   * @ 返回值  ： 无
  141.   ********************************************************************/
  142. static void Receive_Task(void* parameter)
  143. {    
  144.   BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  145.   while (1)
  146.   {
  147.     //获取二值信号量 xSemaphore,没获取到则一直等待
  148.         xReturn = xSemaphoreTake(BinarySem_Handle,/* 二值信号量句柄 */
  149.                               portMAX_DELAY); /* 等待时间 */
  150.     if(pdTRUE == xReturn)
  151.       printf("BinarySem_Handle二值信号量获取成功!\n\n");
  152.         LED1_TOGGLE;
  153.   }
  154. }
  156. /**********************************************************************
  157.   * @ 函数名  ： Send_Task
  158.   * @ 功能说明： Send_Task任务主体
  159.   * @ 参数    ：   
  160.   * @ 返回值  ： 无
  161.   ********************************************************************/
  162. static void Send_Task(void* parameter)
  163. {     
  164.   BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  165.   while (1)
  166.   {
  167.     /* K1 被按下 */
  168.     if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON )
  169.     {
  170.       xReturn = xSemaphoreGive( BinarySem_Handle );//给出二值信号量
  171.       if( xReturn == pdTRUE )
  172.         printf("BinarySem_Handle二值信号量释放成功!\r\n");
  173.       else
  174.         printf("BinarySem_Handle二值信号量释放失败!\r\n");
  175.     } 
  176.     /* K2 被按下 */
  177.     if( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON )
  178.     {
  179.       xReturn = xSemaphoreGive( BinarySem_Handle );//给出二值信号量
  180.       if( xReturn == pdTRUE )
  181.         printf("BinarySem_Handle二值信号量释放成功!\r\n");
  182.       else
  183.         printf("BinarySem_Handle二值信号量释放失败!\r\n");
  184.     }
  185.     vTaskDelay(20);
  186.   }
  187. }
  188. /***********************************************************************
  189.   * @ 函数名  ： BSP_Init
  190.   * @ 功能说明： 板级外设初始化，所有板子上的初始化均可放在这个函数里面
  191.   * @ 参数    ：   
  192.   * @ 返回值  ： 无
  193.   *********************************************************************/
  194. static void BSP_Init(void)
  195. {
  196.     /*
  197.      * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
  198.      * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
  199.      * 都统一用这个优先级分组，千万不要再分组，切忌。
  200.      */
  201.     NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
  203.     /* LED 初始化 */
  204.     LED_GPIO_Config();
  206.     /* 串口初始化    */
  207.     USART_Config();
  209.      /* 按键初始化    */
  210.      Key_GPIO_Config();
  212. }
  214. /********************************END OF FILE****************************/

18.7.2 计数信号量实验

  1.  计数型信号量实验是模拟停车场工作运行。在创建信号量的时候初始化 5 个可用的信号量，并且创建了两个任务：一个是获取信号量任务，一个是释放信号量任务，两个任务独立运行，获取信号量任务是通过按下 KEY1 按键进行信号量的获取，模拟停车场停车操作，其等待时间是 0，在串口调试助手输出相应信息 <br />     释放信号量任务则是信号量的释放，释放信号量任务也是通过按下 KEY2 按键进行信号量的释放，模拟停车场取车操作，在串口调试助手输出相应信息。
  1. /*
  2. *************************************************************************
  3. *                             包含的头文件
  4. *************************************************************************
  5. */ 
  6. /* FreeRTOS头文件 */
  7. #include "FreeRTOS.h"
  8. #include "task.h"
  9. #include "queue.h"
  10. #include "semphr.h"
  11. /* 开发板硬件bsp头文件 */
  12. #include "bsp_led.h"
  13. #include "bsp_usart.h"
  14. #include "bsp_key.h"
  15. /**************************** 任务句柄 ********************************/
  16. /* 
  17.  * 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
  18.  * 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
  19.  * 这个句柄可以为NULL。
  20.  */
  21. static TaskHandle_t AppTaskCreate_Handle = NULL;/* 创建任务句柄 */
  22. static TaskHandle_t Take_Task_Handle = NULL;/* Take_Task任务句柄 */
  23. static TaskHandle_t Give_Task_Handle = NULL;/* Give_Task任务句柄 */
  25. /********************************** 内核对象句柄 *********************************/
  26. /*
  27.  * 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
  28.  * 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
  29.  * 们就可以通过这个句柄操作这些内核对象。
  30.  *
  31.  * 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
  32.  * 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
  33.  * 来完成的
  34.  * 
  35.  */
  36. SemaphoreHandle_t CountSem_Handle =NULL;
  38. /******************************* 全局变量声明 ************************************/
  39. /*
  40.  * 当我们在写应用程序的时候，可能需要用到一些全局变量。
  41.  */
  44. /******************************* 宏定义 ************************************/
  45. /*
  46.  * 当我们在写应用程序的时候，可能需要用到一些宏定义。
  47.  */
  50. /*
  51. *************************************************************************
  52. *                             函数声明
  53. *************************************************************************
  54. */
  55. static void AppTaskCreate(void);/* 用于创建任务 */
  57. static void Take_Task(void* pvParameters);/* Take_Task任务实现 */
  58. static void Give_Task(void* pvParameters);/* Give_Task任务实现 */
  60. static void BSP_Init(void);/* 用于初始化板载相关资源 */
  62. /*****************************************************************
  63.   * @brief  主函数
  64.   * @param  无
  65.   * @retval 无
  66.   * @note   第一步：开发板硬件初始化 
  67.             第二步：创建APP应用任务
  68.             第三步：启动FreeRTOS，开始多任务调度
  69.   ****************************************************************/
  70. int main(void)
  71. {    
  72.   BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  74.   /* 开发板硬件初始化 */
  75.   BSP_Init();
  77.   printf("这是一个[野火]-STM32全系列开发板-FreeRTOS计数信号量实验！\n");
  78.   printf("车位默认值为5个，按下KEY1申请车位，按下KEY2释放车位！\n\n");
  80.   /* 创建AppTaskCreate任务 */
  81.   xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,  /* 任务入口函数 */
  82.                         (const char*    )"AppTaskCreate",/* 任务名字 */
  83.                         (uint16_t       )512,  /* 任务栈大小 */
  84.                         (void*          )NULL,/* 任务入口函数参数 */
  85.                         (UBaseType_t    )1, /* 任务的优先级 */
  86.                         (TaskHandle_t*  )&AppTaskCreate_Handle);/* 任务控制块指针 */ 
  87.   /* 启动任务调度 */           
  88.   if(pdPASS == xReturn)
  89.     vTaskStartScheduler();   /* 启动任务，开启调度 */
  90.   else
  91.     return -1;  
  93.   while(1);   /* 正常不会执行到这里 */    
  94. }
  97. /***********************************************************************
  98.   * @ 函数名  ： AppTaskCreate
  99.   * @ 功能说明： 为了方便管理，所有的任务创建函数都放在这个函数里面
  100.   * @ 参数    ： 无  
  101.   * @ 返回值  ： 无
  102.   **********************************************************************/
  103. static void AppTaskCreate(void)
  104. {
  105.   BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
  107.   taskENTER_CRITICAL();           //进入临界区
  109.   /* 创建Test_Queue */
  110.   CountSem_Handle = xSemaphoreCreateCounting(5,5);     
  111.   if(NULL != CountSem_Handle)
  112.     printf("CountSem_Handle计数信号量创建成功!\r\n");
  114.   /* 创建Take_Task任务 */
  115.   xReturn = xTaskCreate((TaskFunction_t )Take_Task, /* 任务入口函数 */
  116.                         (const char*    )"Take_Task",/* 任务名字 */
  117.                         (uint16_t       )512,   /* 任务栈大小 */
  118.                         (void*          )NULL,    /* 任务入口函数参数 */
  119.                         (UBaseType_t    )2,        /* 任务的优先级 */
  120.                         (TaskHandle_t*  )&Take_Task_Handle);/* 任务控制块指针 */
  121.   if(pdPASS == xReturn)
  122.     printf("创建Take_Task任务成功!\r\n");
  124.   /* 创建Give_Task任务 */
  125.   xReturn = xTaskCreate((TaskFunction_t )Give_Task,  /* 任务入口函数 */
  126.                         (const char*    )"Give_Task",/* 任务名字 */
  127.                         (uint16_t       )512,  /* 任务栈大小 */
  128.                         (void*          )NULL,/* 任务入口函数参数 */
  129.                         (UBaseType_t    )3, /* 任务的优先级 */
  130.                         (TaskHandle_t*  )&Give_Task_Handle);/* 任务控制块指针 */ 
  131.   if(pdPASS == xReturn)
  132.     printf("创建Give_Task任务成功!\n\n");
  134.   vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
  136.   taskEXIT_CRITICAL();            //退出临界区
  137. }
  141. /**********************************************************************
  142.   * @ 函数名  ： Take_Task
  143.   * @ 功能说明： Take_Task任务主体
  144.   * @ 参数    ：   
  145.   * @ 返回值  ： 无
  146.   ********************************************************************/
  147. static void Take_Task(void* parameter)
  148. {    
  149.   BaseType_t xReturn = pdTRUE;/* 定义一个创建信息返回值，默认为pdPASS */
  150.   /* 任务都是一个无限循环，不能返回 */
  151.   while (1)
  152.   {
  153.         //如果KEY1被单击
  154.         if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON )       
  155.         {
  156.             /* 获取一个计数信号量 */
  157.           xReturn = xSemaphoreTake(CountSem_Handle,    /* 计数信号量句柄 */
  158.                              0);     /* 等待时间：0 */
  159.             if ( pdTRUE == xReturn ) 
  160.                 printf( "KEY1被按下，成功申请到停车位。\n" );
  161.             else
  162.                 printf( "KEY1被按下，不好意思，现在停车场已满！\n" );                            
  163.         }
  164.         vTaskDelay(20);     //每20ms扫描一次        
  165.   }
  166. }
  168. /**********************************************************************
  169.   * @ 函数名  ： Give_Task
  170.   * @ 功能说明： Give_Task任务主体
  171.   * @ 参数    ：   
  172.   * @ 返回值  ： 无
  173.   ********************************************************************/
  174. static void Give_Task(void* parameter)
  175. {     
  176.   BaseType_t xReturn = pdTRUE;/* 定义一个创建信息返回值，默认为pdPASS */
  177.   /* 任务都是一个无限循环，不能返回 */
  178.   while (1)
  179.   {
  180.     //如果KEY2被单击
  181.         if( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON )       
  182.         {
  183.             /* 获取一个计数信号量 */
  184.             xReturn = xSemaphoreGive(CountSem_Handle);//给出计数信号量                  
  185.             if ( pdTRUE == xReturn ) 
  186.                 printf( "KEY2被按下，释放1个停车位。\n" );
  187.             else
  188.                 printf( "KEY2被按下，但已无车位可以释放！\n" );                            
  189.         }
  190.         vTaskDelay(20);     //每20ms扫描一次    
  191.   }
  192. }
  193. /***********************************************************************
  194.   * @ 函数名  ： BSP_Init
  195.   * @ 功能说明： 板级外设初始化，所有板子上的初始化均可放在这个函数里面
  196.   * @ 参数    ：   
  197.   * @ 返回值  ： 无
  198.   *********************************************************************/
  199. static void BSP_Init(void)
  200. {
  201.     /*
  202.      * STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
  203.      * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
  204.      * 都统一用这个优先级分组，千万不要再分组，切忌。
  205.      */
  206.     NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
  208.     /* LED 初始化 */
  209.     LED_GPIO_Config();
  211.     /* 按键初始化    */
  212.     Key_GPIO_Config();
  214.     /* 串口初始化    */
  215.     USART_Config();
  216. }
  218. /********************************END OF FILE****************************/