什么是信号量？

什么是二值信号量？

二值信号量相关 API 函数

1. 创建二值信号量

2. 释放二值信号量

3. 获取二值信号量

实操

实验需求

cubeMX配置编辑

代码实现

计数型信号量

什么是计数型信号量？

计数型信号量相关 API 函数

实操

实验需求

cubeMX配置

代码实现

什么是信号量？

信号量（ Semaphore ），是在多任务环境下使用的一种机制，是可以用来保证两个或多个关键代

码段不被并发调用。

信号量这个名字，我们可以把它拆分来看，信号可以起到通知信号的作用，然后我们的量还可以

用来表示资源的数量，当我们的量只有 0 和 1 的时候，它就可以被称作二值信号量，只有两个状

态，当我们的那个量没有限制的时候，它就可以被称作为计数型信号量。

信号量也是队列的一种

什么是二值信号量？

二值信号量其实就是一个长度为 1 ，大小为零的队列，只有 0 和 1 两种状态，通常情况下，我们用

它来进行互斥访问或任务同步。

互斥访问：比如门钥匙，只有获取到钥匙才可以开门

任务同步：比如我录完视频你才可以看视频

二值信号量相关 API 函数

函数	描述
xSemaphoreCreateBinary()	使用动态方式创建二值信号量
xSemaphoreCreateBinaryStatic()	使用静态方式创建二值信号量
xSemaphoreGive()	释放信号量
xSemaphoreGiveFromISR()	在中断中释放信号量
xSemaphoreTake()	获取信号量
xSemaphoreTakeFromISR()	在中断中获取信号量

1. 创建二值信号量

SemaphoreHandle_t xSemaphoreCreateBinary ( void )

参数：

无

返回值：

成功，返回对应二值信号量的句柄；

失败，返回 NULL 。

2. 释放二值信号量

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore )

参数：

xSemaphore ：要释放的信号量句柄

返回值：

成功，返回 pdPASS ；

失败，返回 errQUEUE_FULL 。

3. 获取二值信号量

BaseType_t xSemaphoreTake ( SemaphoreHandle_t xSemaphore , TickType_t xTicksToWait );

参数：

xSemaphore ：要获取的信号量句柄

xTicksToWait ：超时时间， 0 表示不超时， portMAX_DELAY 表示卡死等待；

返回值：

成功，返回 pdPASS ；失败，返回 errQUEUE_FULL 。

实操

实验需求

创建一个二值信号量，按下 KEY1 则释放信号量，按下 KEY2 获取信号量。

cubeMX配置

代码实现

void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* Create the semaphores(s) */
  /* definition and creation of myBinarySem */
  osSemaphoreDef(myBinarySem);
	//myBinarySemHandle = osSemaphoreCreate(osSemaphore(myBinarySem), 1);
	myBinarySemHandle = xSemaphoreCreateBinary();
  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* definition and creation of taskGive */
  osThreadDef(taskGive, StartTaskGive, osPriorityNormal, 0, 128);
  taskGiveHandle = osThreadCreate(osThread(taskGive), NULL);

  /* definition and creation of taskTake */
  osThreadDef(taskTake, StartTaskTake, osPriorityNormal, 0, 128);
  taskTakeHandle = osThreadCreate(osThread(taskTake), NULL);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

}

/* USER CODE BEGIN Header_StartTaskGive */
/**
  * @brief  Function implementing the taskGive thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartTaskGive */
void StartTaskGive(void const * argument)
{
  /* USER CODE BEGIN StartTaskGive */
  /* Infinite loop */
  for(;;)
  {
    if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				if (xSemaphoreGive(myBinarySemHandle) == pdTRUE)
					printf("二值信号量放入成功\r\n");
				else
					printf("二值信号量放入失败\r\n");
			}			
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}
		osDelay(10);
  }
  /* USER CODE END StartTaskGive */
}

/* USER CODE BEGIN Header_StartTaskTake */
/**
* @brief Function implementing the taskTake thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTaskTake */
void StartTaskTake(void const * argument)
{
  /* USER CODE BEGIN StartTaskTake */
  /* Infinite loop */
  for(;;)
  {
    if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				if (xSemaphoreTake(myBinarySemHandle, portMAX_DELAY ) == pdTRUE)
					printf("二值信号量取出成功\r\n");
				else
					printf("二值信号量取出失败\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
		osDelay(10);
  }
  /* USER CODE END StartTaskTake */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */

计数型信号量

什么是计数型信号量？

计数型信号量相当于队列长度大于 1 的队列，因此计数型信号量能够容纳多个资源，这在计数型

信号量被创建的时候确定的。

计数型信号量相关 API 函数

函数	描述
xSemaphoreCreateCounting()	使用动态方法创建计数型信号量。
xSemaphoreCreateCountingStatic()	使用静态方法创建计数型信号量
uxSemaphoreGetCount()	获取信号量的计数值

计数型信号量的释放和获取与二值信号量完全相同！

SemaphoreHandle_t xSemaphoreCreateCounting ( UBaseType_t uxMaxCount ,

UBaseType_t uxInitialCount );

参数：

uxMaxCount ：可以达到的最大计数值 uxInitialCount ：创建信号量时分配给信号量的计数值

返回值：

成功，返回对应计数型信号量的句柄；

失败，返回 NULL 。

实操

实验需求

创建一个计数型信号量，按下 KEY1 则释放信号量，按下 KEY2 获取信号量。

cubeMX配置

将 Config parameters 标签里的 USE_COUNTING_SEMAPHORES 设置为 Enabled 。

代码实现

void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* Create the semaphores(s) */
  /* definition and creation of myCountingSem */
  osSemaphoreDef(myCountingSem);
//  myCountingSemHandle = osSemaphoreCreate(osSemaphore(myCountingSem), 3);
	myCountingSemHandle = xSemaphoreCreateCounting(3, 0);
  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* definition and creation of taskGive */
  osThreadDef(taskGive, StartTaskGive, osPriorityNormal, 0, 128);
  taskGiveHandle = osThreadCreate(osThread(taskGive), NULL);

  /* definition and creation of taskTake */
  osThreadDef(taskTake, StartTaskTake, osPriorityNormal, 0, 128);
  taskTakeHandle = osThreadCreate(osThread(taskTake), NULL);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

}

/* USER CODE BEGIN Header_StartTaskGive */
/**
  * @brief  Function implementing the taskGive thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartTaskGive */
void StartTaskGive(void const * argument)
{
  /* USER CODE BEGIN StartTaskGive */
  /* Infinite loop */
  for(;;)
  {
    if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				if (xSemaphoreGive(myCountingSemHandle) == pdTRUE)
					printf("计数信号量放入成功\r\n");
				else
					printf("计数信号量放入失败\r\n");
		}
		while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}
		osDelay(10);
  /* USER CODE END StartTaskGive */
	}
}

/* USER CODE BEGIN Header_StartTaskTake */
/**
* @brief Function implementing the taskTake thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTaskTake */
void StartTaskTake(void const * argument)
{
  /* USER CODE BEGIN StartTaskTake */
  /* Infinite loop */
  for(;;)
  {
   if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
	 {
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				if (xSemaphoreTake(myCountingSemHandle, 0 ) == pdTRUE)
					printf("计数信号量获取成功\r\n");
				else
					printf("计数信号量获取失败\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
	 }
		osDelay(10);
  }
  /* USER CODE END StartTaskTake */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */