/*****动态创建递归互斥信号量*****/
SemaphoreHandle_t xSemaphoreCreateRecursiveMutex(void)
/*****静态创建递归互斥信号量*****/
SemaphoreHandle_t xSemaphoreCreateRecursiveMutexStatic(StaticSemaphore_t * pxSemaphoreBuffer)
//参数：pxSemaphoreBuffer 指向一个StaticSemaphore_t类型的变量，用来保存信号量结构体
返回值：创建成功返回互斥信号量句柄；失败返回NULL

#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
#define xSemaphoreCreateRecursiveMutex()  	
eueCreateMutex(queueQUEUE_TYPE_RECURSIVE_MUTEX)		
#endif

/*****递归互斥信号量释放*****/
BaseType_t xSemaphoreGiveRecursive(SemaphoreHandle_t  xMutex)
返回值：释放成功返回pdPASS;释放失败返回pdFAIL                   

#define xSemaphoreGiveRecursive(xMutex)	
XQueueGiveMutexRecursive((xMutex))

/**xQueueGiveMutexRecursive()函数**/
BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex ){
  BaseType_t xReturn;
  Queue_t * const pxMutex = ( Queue_t * ) xMutex;
  /* 检查递归互斥信号量是不是被当前任务获取 */
  if(pxMutex->pxMutexHolder == (void *)xTaskGetCurrentTaskHandle()){
	( pxMutex->u.uxRecursiveCallCount )--;//用来记录递归信号量被释放的次数
	/* uxRecursiveCallCount为0时，说明是最后一次释放 */
	if(pxMutex->u.uxRecursiveCallCount == (UBaseType_t) 0){
	  /* 此时调用xQueueGenericSend完成真正的释放  */
	  (void)xQueueGenericSend(pxMutex,NULL,q
     ueueMUTEX_GIVE_BLOCK_TIME,queueSEND_TO_BACK);
	}
	else{
	  mtCOVERAGE_TEST_MARKER();
	}
	xReturn = pdPASS;//释放成功
  }
  else{
	xReturn = pdFAIL;//不是被当前任务获取，释放失败
  }
  return xReturn;
}

/****递归互斥信号量获取*****/
BaseType_t xSemaphoreTakeRecursive(SemaphoreHandle_t  xMutex//要获取的信号量句柄
ickType_t xBlockTime)//阻塞时间
返回值：获取成功返回pdPASS;释放失败返回pdFALSE                      

#if( configUSE_RECURSIVE_MUTEXES == 1 )
#define xSemaphoreTakeRecursive( xMutex, xBlockTime ) 
xQueueTakeMutexRecursive(( xMutex ), ( xBlockTime ))
#endif

/****xQueueTakeMutexRecursive()函数****/
BaseType_t xQueueTakeMutexRecursive(QueueHandle_t xMutex,TickType_t xTicksToWait){
  BaseType_t xReturn;
  Queue_t * const pxMutex = ( Queue_t * ) xMutex;
  /* 检查当前任务是不是递归互斥信号量的拥有者 */
  if(pxMutex->pxMutexHolder == (void *) xTaskGetCurrentTaskHandle()){
	( pxMutex->u.uxRecursiveCallCount )++;//若是，表示本次是重复获取信号量
	xReturn = pdPASS;
  }
  else{//如果任务是第一次获取信号量，就需要调用以下函数完成真正的信号量获取
	xReturn = xQueueGenericReceive( pxMutex, NULL, xTicksToWait, pdFALSE );
	/* 第一次获取信号量成功后，将uxRecursiveCallCount加1 */
	if( xReturn != pdFAIL ){
	  ( pxMutex->u.uxRecursiveCallCount )++;
	}
	else{
	  traceTAKE_MUTEX_RECURSIVE_FAILED( pxMutex );
	}
  }
  return xReturn;
}

/*****HighTask****/
void HighTask(void const * argument){
  for(;;){
    vTaskDelay(500);
	printf("High task take RecursiveMutex1\r\n");
	xSemaphoreTakeRecursive(RecursiveMutexHandle,portMAX_DELAY);
	printf("High task running...!\r\n");
	printf("High task take RecursiveMutex2\r\n");
	xSemaphoreTakeRecursive(RecursiveMutexHandle,portMAX_DELAY);
	printf("High task running...!\r\n");
	HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_1);	
	printf("High task give RecursiveMutex1\r\n");
	xSemaphoreGiveRecursive(RecursiveMutexHandle);
	printf("High task give RecursiveMutex2\r\n");
	xSemaphoreGiveRecursive(RecursiveMutexHandle);
	vTaskDelay(500);
  }
}
/******************MiddleTask***********************/
void MiddleTask(void const * argument){
  for(;;){
    printf("Middle task running!\r\n");
	HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_0);
	vTaskDelay(1000);
  }
}
/******************LowTask**************************/
void LowTask(void const * argument){
  for(;;){
  	printf("Low task take RecursiveMutex\r\n");
    xSemaphoreTakeRecursive(RecursiveMutexHandle,portMAX_DELAY);
	printf("Low task running...!\r\n");
	for(int i=0;i<20000000;i++){
	  taskYIELD();			
	}
	printf("Low task give RecursiveMutex\r\n");		
	xSemaphoreGive(RecursiveMutexHandle);
	vTaskDelay(1000);
  }
}