FreeRTOS是一个开源的实时操作系统。

使用的平台:秉火STM32 Cortex-M3内核开发板,Free RTOS v8.2.3。

多任务流水灯

.
├── Doc
│   └── readme.txt
├── FreeRTOS      //OS依赖目录
│   ├── inc
│   │   ├── croutine.h
│   │   ├── ...   //头文件
│   └── src
│       ├── croutine.c
│       ├── ...   //源码文件
├── Libraries     //库文件
├── Project       //工程文件
└── User
    ├── led
    │   ├── bsp_led.c
    │   └── bsp_led.h
    ├── main.c    //源码
    ├── stm32f10x_conf.h
    ├── stm32f10x_it.c
    └── stm32f10x_it.h

创建多任务:

int main ( void )
{	
	xTaskCreate( vTaskStart, "Task Start", 512, NULL, 1, NULL );
    vTaskStartScheduler();
}

void vTaskStart( void * pvParameters )
{
	LED_Init ();

	xTaskCreate( vTaskLed1, "Task Led1", 512, NULL, 1, NULL );
	xTaskCreate( vTaskLed2, "Task Led2", 512, NULL, 1, NULL );
	xTaskCreate( vTaskLed3, "Task Led3", 512, NULL, 1, NULL );

	vTaskDelete( NULL );	
}

void vTaskLed1( void * pvParameters )
{
	while(1)
	{
		macLED1_ON ();			 
		vTaskDelay( 1000 );
		macLED1_OFF ();	
		vTaskDelay( 1000 );
	}
}

上面依次对应主函数创建一个任务并开始调度,任务中又新建了三个任务,每个任务负责一个灯的开启和关闭。

任务管理-挂起与恢复

static void vTaskLed1( void * pvParameters ) //LED闪烁任务,循环执行
{
	TickType_t xLastWakeTime;	
	while(1)                                                    
	{
		macLED1_ON ();			                                     
		vTaskDelayUntil(&xLastWakeTime, 200 / portTICK_RATE_MS); 
		macLED1_OFF ();		                                       	
		vTaskDelayUntil(&xLastWakeTime, 200 / portTICK_RATE_MS);
	}
	
}


static void vTaskKey( void * pvParameters )   //按键控制挂起或恢复任务
{
	uint8_t ucKey1Press = 0, ucKey2Press = 0;	
	while(1)
	{
		if( Key_Scan ( macKEY1_GPIO_PORT, macKEY1_GPIO_PIN, 1, & ucKey1Press ) )      //KEY1按下,任务挂起
		{			
			vTaskSuspend( xHandleTaskLed1 );                                           
		}
		else if( Key_Scan ( macKEY2_GPIO_PORT, macKEY2_GPIO_PIN, 1, & ucKey2Press )) //KEY2按下,任务恢复
		{		
			vTaskResume( xHandleTaskLed1 );                                          
		}
		vTaskDelay( 20 / portTICK_RATE_MS );                                         
	}
}

现象:开机闪烁,按下按键1将停止,按下按键2恢复。

消息队列

/************************************ 创建队列 *********************************/
static xQueueHandle xQueue;

/********************************** 任务函数声明 *******************************/
static void vTaskStart  ( void * pvParameters );
static void vTaskSender ( void * pvParameters );
static void vTaskReceive( void * pvParameters );

/********************************** 任务函数定义 *******************************/
static void vTaskStart( void * pvParameters )                            //起始任务
{
	LED_Init ();	     //初始化LED
	USARTx_Config ();   //初始化串口
	printf("Test Queue");

	/* 创建消息队列 */
	xQueue = xQueueCreate(5, sizeof(uint32_t) );
	if(xQueue != NULL)                                                      //创建成功则创建另外两个任务
	{
		/* 创建发送1和发送2任务 */
		xTaskCreate( vTaskSender, "Task Sender1", 512, ( void *)100, 1, NULL);  //传递的参数为向队列中添加的参数
		xTaskCreate( vTaskSender, "Task Sender2", 512, ( void *)200, 1, NULL);
		
		/* 创建接收任务 */
		xTaskCreate( vTaskReceive, "Task Receiver", 512, NULL, 2, NULL );
	}	
	else                                                                      //创建失败
	{
		while(1);
	}
	vTaskDelete( NULL );                                                      //删除
}
static void vTaskSender( void * pvParameters )
{
	uint32_t lValueToSend;
	portBASE_TYPE xStatus;

	lValueToSend = ( uint32_t ) pvParameters;                  //获取参数(地址传递)
	while(1)
	{
		xStatus = xQueueSendToBack( xQueue, &lValueToSend, 0 );  //阻塞写入队列	
		if( xStatus != pdPASS )                                  
		{
		  printf("数据不能发送到数据队列\r\n");
		}	
		taskYIELD();                                             //放弃时间片,让出CPU
	}
}
static void vTaskReceive( void * pvParameters )
{
	uint32_t lReceivedValue;
	portBASE_TYPE xStatus;

	while(1)
	{
		xStatus = xQueueReceive( xQueue, &lReceivedValue, portMAX_DELAY );//阻塞读取
		if(xStatus==pdPASS)                                           
		{
			printf( "接收的数据是: %d\r\n", lReceivedValue );               
		}
		else                                                            
		{
			printf("没有接收的消息.\r\n");
		}
	}
}
/************************************* 主函数 **********************************/
int main ( void )
{	
	xTaskCreate( vTaskStart, "Task Start", 512, NULL, 1, NULL );       
	vTaskStartScheduler(); 
}

输出结果:

二值信号量–同步数据读写

static SemaphoreHandle_t  xSemaphore = NULL;
xSemaphore = xSemaphoreCreateBinary();
//发送信号量
xSemaphoreGive( xSemaphore );
//接收信号量
xSemaphoreTake( xSemaphore, portMAX_DELAY );

计数信号量

xSemaphore = xSemaphoreCreateCounting(5, 5);  //总共5个停车位,目前有5个可用(计数初值为5)

static void vTaskKey1( void * pvParameters ) 
{
	BaseType_t xResult;
	uint8_t ucKey1Press = 0;
	while(1)
	{
		if( Key_Scan ( macKEY1_GPIO_PORT, macKEY1_GPIO_PIN, 1, & ucKey1Press ) ) 
		{
            xResult = xSemaphoreTake( xSemaphore,0);    //接收信号量,信号值减1                  
            taskENTER_CRITICAL();
            if ( xResult == pdPASS )                      
                printf ( "\r\nKEY1被单击:成功申请到停车位。\r\n" );
            else
                printf ( "\r\nKEY1被单击:不好意思,现在停车场已满!\r\n" );
            taskEXIT_CRITICAL();
		}
		vTaskDelay( 20 / portTICK_RATE_MS );  
	}
	
}

static void vTaskKey2( void * pvParameters ) 
{
	BaseType_t xResult;
	uint8_t ucKey2Press = 0;
	while(1)
	{
		if( Key_Scan ( macKEY2_GPIO_PORT, macKEY2_GPIO_PIN, 1, & ucKey2Press ) ) 
		{
			xResult = xSemaphoreGive( xSemaphore );    //发送信号量,信号值加1
			taskENTER_CRITICAL();
			if ( xResult == pdPASS ) 
				printf ( "\r\nKEY2被单击:释放1个停车位。\r\n" );	
		    else
			    printf ( "\r\nKEY2被单击:但已无车位可以释放!\r\n" );
			taskEXIT_CRITICAL();
		}
		vTaskDelay( 20 / portTICK_RATE_MS );  	
	}
}

运行结果:

计数信号量模拟停车场管理测试
KEY1被单击:成功申请到停车位。
KEY1被单击:成功申请到停车位。
KEY1被单击:成功申请到停车位。
KEY1被单击:成功申请到停车位。
KEY1被单击:成功申请到停车位。
KEY1被单击:不好意思,现在停车场已满!
KEY2被单击:释放1个停车位。
KEY2被单击:释放1个停车位。
KEY2被单击:释放1个停车位。
KEY2被单击:释放1个停车位。
KEY2被单击:释放1个停车位。
KEY2被单击:但已无车位可以释放!

互斥量–同步数据读写

static SemaphoreHandle_t  xSemaphore = NULL;
xSemaphore = xSemaphoreCreateMutex();
//发送信号量
xSemaphoreGive( xSemaphore );
//接收信号量
xSemaphoreTake( xSemaphore, portMAX_DELAY );

事件标志组–按键组合

static EventGroupHandle_t xCreatedEventGroup = NULL;
xCreatedEventGroup = xEventGroupCreate();  //创建互斥信号量

//KEY1按下置位松开清零
xEventGroupSetBits(xCreatedEventGroup, 0x01);   //bit0置位
xEventGroupClearBits(xCreatedEventGroup, 0x01); //bit0清零

//KEY2按下置位松开清零
xEventGroupSetBits(xCreatedEventGroup, 0x02);   //bit1置位
xEventGroupClearBits(xCreatedEventGroup, 0x02); //bit1清零

xEventGroupWaitBits(xCreatedEventGroup,                              //事件标志组对象
				    0x03,                                            //等待bit0和bit1
					pdTRUE,                                          //事件发生后两位清零
					pdTRUE,                                          //等待两位均置位
					portMAX_DELAY); 	                             //无期限等待
//上面函数执行后,点亮LED3

运行现象:KEY1红灯,KEY2绿灯,KEY3蓝灯,按下KEY1或者KEY2红灯或者绿灯亮,同时按下后红灯、绿灯、蓝灯均亮起,松开后只剩下蓝灯。

软件定时器

/********************************** 内核对象句柄 *******************************/
static TimerHandle_t xTimers[3] = {NULL};

static void vTimerCallback( xTimerHandle pxTimer )
{
	uint32_t ulTimerID;	
	ulTimerID = (uint32_t) pvTimerGetTimerID( pxTimer );                   //获取软件定时器的ID
	switch ( ulTimerID )
	{
		case 0:
			macLED1_TOGGLE ();                                             //切换LED1的亮灭状态
			break;
		case 1:
			macLED2_TOGGLE ();                                             //切换LED1的亮灭状态
			break;
		case 2:
			macLED3_TOGGLE ();                                             //切换LED1的亮灭状态
			break;	
    default:
        break;			
	}	
}

static void vTaskTmr( void * pvParameters )                                //Led3任务
{
	uint8_t i;
	for( i=0; i<3; i++ )
	{
	/* 创建软件定时器 */
	xTimers[i] = xTimerCreate("Timer",                                      //命名定时器
                                (i+1)*1000/portTICK_RATE_MS,                //定时的滴答数
                                pdTRUE,                                     //周期性
                                (void * const)i,                            //定时器ID
                                vTimerCallback);                            //回调函数
	}
	for( i=0; i<3; i++ )
	{
        /* 启动软件定时器 */								 
        xTimerStart(xTimers[i],                                             //软件定时器的句柄
                    portMAX_DELAY);									        //如果无法立即启动的堵塞滴答数
	}  	
	vTaskDelete( NULL );                                                    //删除定时器任务自身	
}

多内核对象测试

使用内核对象集合进行统一处理,具体实现方式在创建队列、互斥等对象后,将对象放入集合并在一个任务中统一处理:

/********************************** 内核对象句柄 *******************************/
static SemaphoreHandle_t xSemaphore = NULL;
static xQueueHandle      xQueue1    = NULL;
static xQueueHandle      xQueue2    = NULL;
static xQueueSetHandle   xQueueSet  = NULL;
/********************************** 任务函数定义 *******************************/
static void vTaskStart( void * pvParameters )                       //起始任务
{
    ......
	/* 创建二值信号量 */
	xSemaphore = xSemaphoreCreateBinary();                                    //按键信号量

	/* 创建两个消息队列 */
	xQueue1 = xQueueCreate( 10, sizeof(uint32_t) );	                          //消息队列1
	xQueue2 = xQueueCreate( 10, sizeof(uint32_t) );                           //消息队列2

	/* 创建一个内核对象集合 */
	xQueueSet = xQueueCreateSet( 1 );                                       

	
	/* 添加内核对象到对象集合 xQueueSet */
    xQueueAddToSet(xSemaphore, xQueueSet);
	xQueueAddToSet(xQueue1,    xQueueSet);
	xQueueAddToSet(xQueue2,    xQueueSet);

    ......	
}

static void vTaskPend(void *pvParameters)
{
	QueueSetMemberHandle_t xActivatedMember;
	uint32_t ulQueueMsgValue;
	uint8_t  ucQueueMsgValue;

	while(1)
	{
	    /* 等待多个内核对象 */
		xActivatedMember = xQueueSelectFromSet(xQueueSet, portMAX_DELAY);

		/* 判断接收哪个内核对象 */
		if(xActivatedMember == xQueue1)                                    //如果接收到的对象是xQueue1
		{
		    /* 接收xQueue1的消息 */
			xQueueReceive(xActivatedMember, &ulQueueMsgValue, 0);
			printf("接收到消息队列1接收到消息内容为 %d\r\n", ulQueueMsgValue);
		}
		else if(xActivatedMember == xQueue2)                               //如果接收到的对象是xQueue2
		{
		    /* 接收xQueue2的消息 */
			xQueueReceive(xActivatedMember, &ucQueueMsgValue, 0);
			printf("接收到消息队列2接收到消息内容为 %d\r\n", ucQueueMsgValue);  
		}
		else if(xActivatedMember == xSemaphore)                             //如果接收到的对象是xSemaphore
		{
			/* 接收信号量 */	
			if( xSemaphoreTake(xActivatedMember, 0) == pdPASS )
			macLED1_TOGGLE();                                               //反转LED1的亮灭状态              
		}
	}
}

任务间通信–IPC


/************************************ 任务句柄 *********************************/
static TaskHandle_t xHandleTaskWait = NULL;

static void vTaskWait( void * pvParameters )     //定义接收任务消息任务
{
	BaseType_t xResult;
	uint32_t   ulNotifiedValue;
	while(1)                                                  
	{
		xResult = xTaskNotifyWait(0x00000000,         //函数执行前保留任务消息数据的所有位
                                    0xFFFFFFFF,       //函数执行后清除任务消息数据的所有位
                                    &ulNotifiedValue, //接收任务消息数据
                                    portMAX_DELAY);   //等到有任务消息到来为止	
		if(xResult == pdPASS)
		{
			printf("接收到的任务消息数据为: %d\r\n", ulNotifiedValue);
		}
		else
		{
			macLED1_TOGGLE();                         //反转LED1的亮灭状态
		}		
	}
}

static void vTaskPost( void * pvParameters )     //定义发送任务消息任务
{
	uint32_t ucCount = 0;
	while(1)
	{
		 /* 发送任务消息 */
		xTaskNotify(xHandleTaskWait,                 //目标任务的任务句柄
					ucCount++,                       //任务消息数据
      		        eSetValueWithOverwrite);         //如果目标任务没有及时接收,上次的数据会被覆盖
		vTaskDelay( 2000 / portTICK_RATE_MS );       //每2s发送一次任务消息
	}
}

运行现象:

任务消息测试
接收到的任务消息数据为: 0
接收到的任务消息数据为: 1
接收到的任务消息数据为: 2
接收到的任务消息数据为: 3
接收到的任务消息数据为: 4
接收到的任务消息数据为: 5
接收到的任务消息数据为: 6
......

任务间通信–中断

通过按键中断获取信息,主要将发送放入中断处理函数当中:

/**
  * @brief  EXTI 中断服务函数
  * @param  无
  * @retval 无
  */
void macEXTI_INT_FUNCTION (void)
{
	static portBASE_TYPE xHigherPriorityTaskWoken;
	static uint32_t ucCount = 0;

	if(EXTI_GetITStatus(macEXTI_LINE) != RESET)           //确保是否产生了EXTI Line中断
	{
		/* 发送任务消息 */
		xTaskNotifyFromISR(xHandleTaskWait,               //目标任务的任务句柄
							ucCount++,                    //任务消息数据
							eSetValueWithoutOverwrite,    //如果目标任务没有及时接收,上次的数据会被覆盖	
							&xHigherPriorityTaskWoken);   //返回目标任务的优先级是否高于当前运行任务	

		EXTI_ClearITPendingBit(macEXTI_LINE);             //清除中断标志位	
	}
	portYIELD_FROM_ISR( xHigherPriorityTaskWoken );       //切换到更高优先级的任务
}

内存管理

/********************************** 任务函数定义 *******************************/
static void vTaskStart( void * pvParameters )                       //定义起始任务函数
{
	char * pMallocMem;
	/* 初始化 */
	LED_Init ();	        //初始化 LED
	Key_Initial ();         //初始化按键
	USARTx_Config ();       //初始化 USART1
	printf ( "\r\n内存管理测试\r\n" );

	/* 测试动态申请和释放内存块 */
	pMallocMem = (char *)pvPortMalloc(50);                             //申请动态内存块
	printf( "%s\r\n", ( char * ) pvParameters );                       //打印任务函数参数	
	strcpy( pMallocMem, pvParameters );                                //拷贝任务函数参数到动态内存块
	printf( "%s\r\n", pMallocMem );                                    //打印动态内存块里的字符串
	vPortFree(pMallocMem);                                             //如果动态内存块不再使用,应该释放它
	
	vTaskDelete( NULL );                                               //删除起始任务自身
	
	
}
Logo

旨在为数千万中国开发者提供一个无缝且高效的云端环境,以支持学习、使用和贡献开源项目。

更多推荐