Free RTOS的计数型信号量

上篇讲解了二值信号量，二值信号量只能判断有无，而不能确定事件发生的次数，因此我们为了确定事件的次数引入了计数型信号量！
 

 

使用计数型信号量时，需要在FreeRTOSConfig.h中加入一行配置代码
 

•  
•  

//为1时使用计数信号量
#define configUSE_COUNTING_SEMAPHORES    1

 

仔细阅读源码的同学就会发现有很多类似的代码(如下图)，这些代码让FreeRTO可以实现不同需要的裁剪，以减少系统开销
 

 

创建计数型信号量

•  

xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount )

参数：
 

    uxMaxCount：计数信号量最大计数值，但信号量值等于此值的时候，释放信号量就会失败
 

    uxInitialCount ：计数信号量初始值
 

返回值：
 

    NULL：计数信号量创建失败
 

    其他值：计数信号量创建成功，返回计数信号量句柄
 

 

释放信号量
 

 

非中断释放
 

•  

xSemaphoreGive( SemaphoreHandle_t xSemaphore )

参数：
 

    xSemaphore : 要释放的信号量句柄
 

返回值：
 

    pdPASS:           释放信号量成功
 

    errQUEU_FULL:释放信号量失败
 

 

中断释放

•  
•  
•  

BaseType_t xSemaphoreGiveFromISR( SemaphoreHandle_t xSemaphore,
                                 BaseType_t* pxHigherPriorityTaskWoken)

参数：
 

    xSemaphore：要释放的信号量句柄

    pxHigherPriorityTaskWoken：标记退出此函数后是否需要进行任务切换，pxHigherPriorityTaskWoken是可选参数，可以设置为NULL。当该值为pdTRUE的时候在退出中断服务函数之前一定要进行一次任务切换。

返回值：
 

    释放成功返回pdPASS，失败返回errQUEUE_FULL

 

获取信号量
 

 

非中断获取
 

•  
•  

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore,
        TickType_t xBlockTime)

参数：

        xSemaphore：要释放的信号量句柄

        xBlockTime：阻塞时间

返回值：

        获取成功返回pdTRUE，失败返回pdFALSE

 

中断获取

•  
•  

BaseType_t xSemaphoreTakeFromISR( SemaphoreHandle_t xSemaphore,
BaseType_t* pxHigherPriorityTaskWoken)

参数：

    xSemaphore：要释放的信号量句柄

    pxHigherPriorityTaskWoken：标记退出此函数后是否需要进行任务切换

返回值：

    获取成功返回pdTRUE，失败返回pdFALSE

 

注意：不管是二值信号量、计数型信号量还是互斥信号量，它们都使用上面的释放信号量和获取信号量API函数
 

 

源码例程

#include "stm32f10x.h"
#include 
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"

void LED_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;        //定义结构体变量
  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);  //开启时钟
  
  GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;            //选择你要设置的IO口
  GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;      //设置推挽输出模式
  GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;     //设置传输速率
  GPIO_Init(GPIOC,&GPIO_InitStructure);                //初始化GPIO
  
  GPIO_SetBits(GPIOC,GPIO_Pin_0);             //将LED端口拉高，熄灭LED
}

void KEY_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure; //定义结构体变量  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOE,ENABLE);
  
  GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;     //选择你要设置的IO口
  GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPD;//下拉输入  
  GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;     //设置传输速率
  GPIO_Init(GPIOA,&GPIO_InitStructure);      /* 初始化GPIO */
  
  GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3|GPIO_Pin_2|GPIO_Pin_4;
  GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;  //上拉输入
  GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
  GPIO_Init(GPIOE,&GPIO_InitStructure);
}


void USART_init(uint32_t bound)
{
  GPIO_InitTypeDef GPIO_InitStruct;   //定义GPIO结构体变量
  USART_InitTypeDef USART_InitStruct;   //定义串口结构体变量
  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);   //使能GPIOC的时钟
  
  GPIO_InitStruct.GPIO_Pin=GPIO_Pin_9;   //配置TX引脚
  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_AF_PP;   //配置PA9为复用推挽输出
  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;   //配置PA9速率
  GPIO_Init(GPIOA,&GPIO_InitStruct);   //GPIO初始化函数
  
  GPIO_InitStruct.GPIO_Pin=GPIO_Pin_10;   //配置RX引脚
  GPIO_InitStruct.GPIO_Mode=GPIO_Mode_IN_FLOATING;   //配置PA10为浮空输入
  GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz;   //配置PA10速率
  GPIO_Init(GPIOA,&GPIO_InitStruct);   //GPIO初始化函数
  
  
  USART_InitStruct.USART_Mode=USART_Mode_Tx|USART_Mode_Rx;   //发送接收模式
  USART_InitStruct.USART_Parity=USART_Parity_No;   //无奇偶校验
  USART_InitStruct.USART_BaudRate=bound;   //波特率
  USART_InitStruct.USART_StopBits=USART_StopBits_1;   //停止位1位
  USART_InitStruct.USART_WordLength=USART_WordLength_8b;   //字长8位
  USART_InitStruct.USART_HardwareFlowControl=USART_HardwareFlowControl_None;   //无硬件数据流控制
  USART_Init(USART1,&USART_InitStruct);   //串口初始化函数
  
  USART_Cmd(USART1,ENABLE);   //使能USART1
}

int fputc(int ch,FILE *f)   //printf重定向函数
{
  USART_SendData(USART1,(uint8_t)ch);   //发送一字节数据
  while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);   //等待发送完成
  return ch;
}


#define START_TASK_PRIO 1      //任务优先级
#define START_STK_SIZE 128      //任务堆栈大小
TaskHandle_t StartTask_Handler;   //任务句柄
void Start_Task(void *pvParameters);//任务函数

#define Send_TASK_PRIO 2       //任务优先级
#define Send_STK_SIZE 50       //任务堆栈大小
TaskHandle_t SendTask_Handler;     //任务句柄
void Send_Task(void *p_arg);     //任务函数

#define Receive_TASK_PRIO 2     //任务优先级
#define Receive_STK_SIZE 50     //任务堆栈大小
TaskHandle_t ReceiveTask_Handler;     //任务句柄
void Receive_Task(void *p_arg);   //任务函数

SemaphoreHandle_t CountSem_Handle =NULL;  //计数型信号量句柄

int main( void ) 
{
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组 4
  
  LED_Init(); //初始化 LED
  KEY_Init();
  USART_init(9600);
  
  //创建开始任务
  xTaskCreate(
    (TaskFunction_t )Start_Task,     //任务函数
    (const char* )"Start_Task",     //任务名称
    (uint16_t )START_STK_SIZE,       //任务堆栈大小
    (void* )NULL,             //传递给任务函数的参数
    (UBaseType_t )START_TASK_PRIO,     //任务优先级
    (TaskHandle_t* )&StartTask_Handler  //任务句柄 
  );
  vTaskStartScheduler();  //开启调度
}

//开始任务函数
void Start_Task(void *pvParameters)
{
  taskENTER_CRITICAL();   //进入临界区
   /* 创建Test_Queue */
  CountSem_Handle = xSemaphoreCreateCounting(5,0);
  //创建 发送 任务
  xTaskCreate(
    (TaskFunction_t )Send_Task, 
    (const char* )"Send_Task", 
    (uint16_t )Send_STK_SIZE, 
    (void* )NULL,
    (UBaseType_t )Send_TASK_PRIO,
    (TaskHandle_t* )&SendTask_Handler
  );
  //创建 接收 任务
  xTaskCreate(
    (TaskFunction_t )Receive_Task, 
    (const char* )"Receive_Task", 
    (uint16_t )Receive_STK_SIZE, 
    (void* )NULL,
    (UBaseType_t )Receive_TASK_PRIO,
    (TaskHandle_t* )&ReceiveTask_Handler
  );
  vTaskDelete(StartTask_Handler); //删除开始任务
  taskEXIT_CRITICAL();   //退出临界区
}

//发送 任务函数
void Send_Task(void *pvParameters)
{
  BaseType_t xReturn = NULL;
  while(1)
  {
    if (CountSem_Handle != NULL)
    {
      xReturn = xSemaphoreGive(CountSem_Handle);
      if (xReturn == pdTRUE){
        printf("信号量释放成功n");
      }
      else{
        printf("信号量释放失败n");
      }
    }
    vTaskDelay(1000);
  }
}

//接收 任务函数
void Receive_Task(void *pvParameters)
{
  BaseType_t xReturn = NULL;
  uint16_t count = 0;
  while(1)
  {
     // 等待获取信号量
        xReturn = xSemaphoreTake(CountSem_Handle, portMAX_DELAY);
        if (xReturn == pdTRUE)
        {
      count = uxSemaphoreGetCount(CountSem_Handle);
      printf("%dn",count);
        }
        else
        {
      printf("获取信号量失败n");
        }
    vTaskDelay(2000);
  }
}

 

实验现象
 

 

 

--END--