当前位置:   article > 正文

STM32FreeRTOS消息队列(STM32Cube高效开发)_stm32队列

stm32队列

在实际的项目开发中,经常会遇到在任务于任务之间或任务于中断之间需要进行“沟通交流”,即消息传递的过程。在不使用操作系统的情况下,函数与函数,或函数与中断之间的“沟通交流”一般使用一个或多多个全局变量来完成,但是在操作系统中,因为会涉及“资源管理”的问题,比方说读写冲突,因此使用全局变量在任务于任务或任务于中断之间进行消息传递,并不是很好的解决方案。队列读写队列做好了保护,防止多任务同时访问冲突;我们只需要直接调用API函数即可,简单易用。

一、队列

(一)简介

队列是任务到任务、任务到中断、中断到任务数据交流的一种机制(消息传递)。任务和ISR统称为进程,任务与任务之间,或任务与ISR之间有时需要进行通讯或同步,称为进程间通信

在这里插入图片描述

在这里插入图片描述
在创建队列时,就要指定队列长度以及队列项目的大小!

(二)FreeRTOS队列特点

在这里插入图片描述

1、入队阻塞:队列满了,此时无法继续写入数据

在这里插入图片描述

2、出队阻塞:队列为空,此时无法读出数据

在这里插入图片描述

3、入队阻塞解除,有多个任务等待时,哪一个会进入就绪态?

  • 优先级最高的任务
  • 如果优先级相同,那等待时间最久的任务会进入就绪态

4、队列操作

队列操作的过程:包括创建队列、往队列中写入消息、从队列中读取消息等操作
(1)创建队列
在这里插入图片描述
创建了一个用于任务 A 与任务 B 之间“沟通交流”的队列,这个队列最大可容纳 5 个队列项目,即队列的长度为 5。刚创建的队列是不包含内容的,因此这个队列为空。

(2)写入队列
在这里插入图片描述
任务 A 将一个私有变量写入队列的尾部。由于在写入队列之前,队列是空的,因此新写入的消息,既是是队列的头部,也是队列的尾部。
在这里插入图片描述
任务 A 改变了私有变量的值,并将新值写入队列。现在队列中包含了队列 A写入的两个值,其中第一个写入的值在队列的头部,而新写入的值在队列的尾部。 这时队列还有 3 个空闲的位置。

(3)读取队列
在这里插入图片描述
任务 B 从队列中读取消息,任务 B 读取的消息是处于队列头部的消息,这是任务 A 第一次往队列中写入的消息。在任务 B 从队列中读取消息后,队列中任务 A 第二次写入的消息,变成了队列的头部,因此下次任务 B 再次读取消息时,将读取到这个消息。此时队列中剩余 4 个空闲的位置。

二、队列函数

使用队列的主要流程:创建队列 ->写队列 -> 读队列。

(一)队列的创建和存储

队列创建时被分配固定个数的存储单元,每个存储单元存储
固定大小的数据,进程间传递的数据就保存在队列的存储单元里
1、xQueueCreate()创建队列
函数xQueueCreate()以动态分配内存的方式创建队列,队列需要用的存储空间由FreeRTOS从堆空间自动分配
在这里插入图片描述

#define xQueueCreate( uxQueueLength, uxItemSize ) 
xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), 
( queueQUEUE_TYPE_BASE ) )
//参数1:队列的长度
//参数2:每个存储单元的大小
//返回值:创建队列的句柄,若返回NULL表示创建失败
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

函数xQueueGenericCreate()是创建队列、信号量、互斥量等对象的通用函数。函数原型是:

QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, 
									const UBaseType_t uxItemSize, 
									const uint8_t ucQueueType )

//参数1:队列长度,也就是存储单元的个数
//参数2:每个存储单元的字节数
//参数3:表示创建对象的类型
//返回值:表示创建队列的句柄

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

ucQueueType表示创建对象的类型一般有以下几种:
在这里插入图片描述

通过参数3来决定是创建的类型:创建队列函数
在这里插入图片描述
创建队列官方代码示例:参数1是数据个数,参数2是每个数据的存储空间字节数
在这里插入图片描述

xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
  • 1

创建了一个具有10个存储单元的队列,每个单元占用sizeof(uint32_t)个字节,也就是4个字节。

 struct AMessage
 {
	char ucMessageID;
	char ucData[ 20 ];
 };
// Create a queue capable of containing 10 pointers to AMessage structures.
// These should be passed by pointer as they contain a lot of data.
xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

创建一个包含10个指向结构体AMessageID的队列,每个队列大小也就是sizeof( struct AMessage * ) 的大小
注意:
在这里插入图片描述

(二)向队列写入数据

一个任务或ISR向队列写入数据称为发送消息。队列是一个共享的存储区域,可以被多个进程写入,也可以被多个进程读取
在这里插入图片描述

1、任务中向队列中写入数据函数

在这里插入图片描述
在这里插入图片描述
可以发现几个写入函数调用的是同一个函数xQueueGenericSend( ),只是指定了不同的写入位置!

2、写入函数原型

BaseType_t xQueueGenericSend( QueueHandle_t xQueue, 
							const void * const pvItemToQueue, 
							TickType_t xTicksToWait, 
							const BaseType_t xCopyPosition )
参数1:队列句柄
参数2:待写入消息
参数3:阻塞超时时间
参数4:表示数据写入队列的位置,有3种常数定义
返回值:pdTRUE表示写入成功,反之失败
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

写入队列的位置:
在这里插入图片描述
注意:覆写方式写入队列,只有在队列的队列长度为 1 时,才能够使用

//向队列尾部写入数据
#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) 
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )

//向队列尾部写入数据
#define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) 
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )

//向队列头部写入数据
#define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) 
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

函数在队列未满时能正常向队列写入数据,函数返回值为pdTRUE;
如果队列已满,这两个函数不能再向队列写入数据,函数返回值为errQUEUE_FULL;

//以覆写的形式写入数据(队列长度为1的队列)
#define xQueueOverwrite( xQueue, pvItemToQueue ) 
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), 0, queueOVERWRITE )

  • 1
  • 2
  • 3
  • 4

xQueueOverwrite()也可以用于向队列写入数据,但是这个函数只用于队列长度为1的队列,在队列已满时,它会覆盖队列原来的数据。
在这里插入图片描述

3、ISR版本

在这里插入图片描述
只是比任务版本函数多一个是否需要进行上下文切换的申请
例如:

//任务版本
参数1:写入的队列
参数2:要写入的数据
参数3:阻塞超时时间
#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) 
xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
//ISR版本
//参数1:写入的队列
//参数2:要写入的数据
//参数3:是否进行上下文切换
#define xQueueSendFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) 
xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

(三)从队列读取数据

可以在任务或ISR里读取队列的数据,称为接收消息。总是从队列头读取数据,读出后删除这个单元的数据,后面的数据前移
在这里插入图片描述
在这里插入图片描述

1、从队列头部读取消息并删除消息

如果设置了等待节拍数,但是队列中没有数据,任务会进入阻塞状态等待指定的时间。如果在等待时间内,队列里有了数据就会退出阻塞状态进入就绪状态,随后调度进入运行状态后从队列里读取数据。反之超过了等待时间队列里还是没有数据函数就是返回pdfalse,任务退出阻塞状态,进入就绪状态。

BaseType_t xQueueReceive( QueueHandle_t xQueue, 
						void * const pvBuffer,
						 TickType_t xTicksToWait ) 

//参数1:读取的队列句柄
//参数2:数据缓冲区(存储的位置)
//参数3:阻塞超时时间
//返回值是pdTRUE或pdFALSE
//ISR版本:
BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue, 
								void * const pvBuffer,
								 BaseType_t * const pxHigherPriorityTaskWoken ) 
//参数1:读取的队列句柄
//参数2:数据缓冲区(存储的位置)
//参数3:是否进行上下文切换


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

官方demo

 // Task to receive from the queue.
 void vADifferentTask( void *pvParameters )
 {
 struct AMessage *pxRxedMessage;

	if( xQueue != 0 )
	{
		// Receive a message on the created queue.  Block for 10 ticks if a
		// message is not immediately available.
		if( xQueueReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
		{
			// pcRxedMessage now points to the struct AMessage variable posted
			// by vATask.
		}
	}

	// ... Rest of task code.
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

2、从队列头部读取消息

//任务版本
BaseType_t xQueuePeek( QueueHandle_t xQueue, 
						void * const pvBuffer, 
						TickType_t xTicksToWait ) 
//ISR版本
BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, 
							void * const pvBuffer ) 


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

(四)队列操作相关函数

1、xQueueReset()队列复位函数

将队列复位为空的状态,队列内的所有数据都被丢弃

#define xQueueReset( xQueue ) xQueueGenericReset( xQueue, pdFALSE )
  • 1

2、 vQueueDelete()删除队列函数

删除一个队列,也可以用于删除一个信号量

void vQueueDelete( QueueHandle_t xQueue ) 
  • 1

3、pcQueueGetName()获取队列的名称

获取队列的名称,也就是创建队列时设置的队列名称字符串

#if( configQUEUE_REGISTRY_SIZE > 0 )
	const char *pcQueueGetName( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
#endif
  • 1
  • 2
  • 3

4、vQueueSetQueueNumber()为队列设置一个编号

为队列设置一个编号,这个编号由用户设置并使用

void vQueueSetQueueNumber( QueueHandle_t xQueue, UBaseType_t uxQueueNumber )
  • 1

5、uxQueueGetQueueNumber()获取队列的编号

UBaseType_t uxQueueGetQueueNumber( QueueHandle_t xQueue ) 
  • 1

6、uxQueueSpacesAvailable()获取队列剩余空间个数

获取队列剩余空间个数,也就是还可以写入的消息个数

UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;

  • 1
  • 2

7、uxQueueMessagesWaiting()获取队列中等待读取的消息个数

UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue )

  • 1
  • 2

8、xQueueIsQueueEmptyFromISR()查询队列是否为空

查询队列是否为空,返回值为pdTRUE表示队列为空

BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) 
  • 1

9、xQueueIsQueueFullFromISR()查询队列是否已满

查询队列是否满了,返回值为pdTRUE表示队列满了

BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue )
  • 1

三、队列使用示例

(一)使用消息队列传输字符串和按键值

1、目标

(1)创建三个任务,创建两个队列

(2)任务1:负责按键扫描,根据按下的不同按键值执行不同的写入操作
按键1按下或按键2按下将按键值拷贝到队列Queue_keys中
唤醒按键按下将提前准备好的字符串拷贝到队列Queue_string中
(3)任务2:读取队列Queue_keys中的按键值,并在LCD上显示按下的键值
(4)任务3:队列队列Queue_string中传输的字符串,并在LCD上显示传输的字符串数据

2、STM32cubemx配置

(1)复制已经配置好LCD、和按键引脚的stm32cube工程修改名字
在这里插入图片描述
(2)RCC部分保持原来配置
在这里插入图片描述
(3)SYS选择TIM6作为FreeRTOS基础时钟源
在这里插入图片描述
(3)GPIO引脚是配置好的LCD背光和按键引脚
在这里插入图片描述
(4)启动FreeRTOS并选择V2版本,创建三个任务(动态形式创建)和两个队列
在这里插入图片描述
创建3个任务,设置不同的任务优先级(按键检测任务优先级可以设置最大),占空间大小都设置为128字,动态形式创建3个任务。
第一个任务:实现按键检测,将按键值或字符串写入到相关的队列中
第二个任务:读取队列数据获取按键按下的值,并在lcd上显示数据
第三个任务:读取队列数据获取字符串数据,并在LCD上显示数据
在这里插入图片描述
队列1用于传输按键按下的值,队列长度为10,项的大小是sizeof(uint8_t)个字节。
队列2用于传输字符串数据,队列长度为10,项的大小为sizeof(char*)个字节。
在这里插入图片描述

(5)clock保持原来配置不变
在这里插入图片描述
(6)工程名和存储地址无需配置(就是刚开始打开时的工程名和地址)-无法修改
如果是新建的工程可以随意填写(不要包含中文路径和汉字)
在这里插入图片描述
在这里插入图片描述
生成代码

3、代码编写

(1)复制BSP文件夹到工程目录下,并添加相对应路径,添加头文件实现LCD的数据显示
(2)main.h中添加头文件
在这里插入图片描述

/* USER CODE BEGIN Includes */
#include "cmsis_os.h"
#include "gpio.h"
#include "fsmc.h"
#include"tftlcd.h"
#include "keyled.h"
/* USER CODE END Includes */
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

(3)main.c文件主函数中LCD初始化和LCD显示测试
在这里插入图片描述
(4)FreeRTOS.c文件添加两个头文件
在这里插入图片描述

/* USER CODE BEGIN Includes */
#include"queue.h"
#include "stdio.h"
/* USER CODE END Includes */
  • 1
  • 2
  • 3
  • 4

(5)按键扫描任务

  • 主要根据不同的按键值写入不同的数据,并在LCD上进行按键按下提示和写入成功提示
    按键1按下写入数值1
    按键2按下写入数值2
    唤醒按键按下写入"abcdefgh"字符串
void AppTask_keyscan(void *argument)
{
  /* USER CODE BEGIN AppTask_keyscan */
	//按键扫描
	KEYS key_value=KEY_NONE; //无按键按下
	char *str="abcdefgh";   //要发送的字符串
//	str=&buf[0];
	BaseType_t result=pdFALSE; //函数返回值初始化
  /* Infinite loop */
  for(;;)
  {
	  key_value=key_scan(0);//按键扫描

	  if(key_value==KEY_1||key_value==KEY_2)//key1或者key2按下
	  {
		  //参数1:要写入的队列句柄,参数2:是按键值,参数3是一直等待
		  result=xQueueSend( Queue_keysHandle, &key_value, portMAX_DELAY );

		  uint8_t data[20];	  //缓冲数组
		  if(result==pdTRUE)//表明已经成功写入到队列中
		  {
			  sprintf(data,"key%d_write_ok  ",key_value);
			  LCD_ShowString(10, 10+2*20, tftlcd_data.width, tftlcd_data.height, 12, data);
		  }


		  //格式化字符串(key1_press或key2_press格式化存储到字符数组data中)
		  sprintf(data,"key%d_press   ",key_value);
		  //LCD显示哪个按键按下
		  LCD_ShowString(10, 10+1*20, tftlcd_data.width, tftlcd_data.height, 12, data);


	  }
	  else if(key_value==KEY_UP)//唤醒按键按下将字符串写入到Queue_stringHandle队列中
	  {
		  result=xQueueSend( Queue_stringHandle, &str , portMAX_DELAY );
		  LCD_ShowString(10, 10+1*20, tftlcd_data.width, tftlcd_data.height, 12, "key_up_press");
		  if(result==pdTRUE)
		  {
			  LCD_ShowString(10, 10+2*20, tftlcd_data.width, tftlcd_data.height, 12, "string_write_ok");

		  }

	  }
	  vTaskDelay(20);
  }
  /* USER CODE END AppTask_keyscan */
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

(6)读取按键队列,将接收到的按键值在lcd显示

void AppTask_keyshow(void *argument)
{
  /* USER CODE BEGIN AppTask_keyshow */
	uint8_t key;

  /* Infinite loop */
  for(;;)
  {		//参数1是读取的队列句柄,参数2:读取到的数值存放的变量,参数3:一直等到,返回值:是否读取成功
	  BaseType_t result= xQueueReceive( Queue_keysHandle, &key,portMAX_DELAY );
	  if(result=pdTRUE)
	  {
		  uint8_t str[20];
		  sprintf(str,"press key is %d     ",key);//显示接收到的按键值
		  LCD_ShowString(10, 10+4*20, tftlcd_data.width, tftlcd_data.height, 12, str);
	  }

  }
  /* USER CODE END AppTask_keyshow */
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

(7)读取字符串队列,将接收到的数据在lcd上显示

void AppTask_stringshow(void *argument)
{
  /* USER CODE BEGIN AppTask_stringshow */

	char* str;//存放接收的字符串数据
  /* Infinite loop */
  for(;;)
  {
	  BaseType_t result= xQueueReceive( Queue_stringHandle, &str,portMAX_DELAY );
	  if(result=pdTRUE)
	  {
		  uint8_t data[20];

		  sprintf(data,"RXstr is %s ",str);
		  LCD_ShowString(10, 10+4*20, tftlcd_data.width, tftlcd_data.height, 12, data);
	  }

  }
  /* USER CODE END AppTask_stringshow */
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

编译下载即可

4、队列的长度和项大小的确定

在这里插入图片描述
例如:要传输一个字符串长度为10的数据,设置不同的队列长度和不同的项大小有啥区别,要传输的数据和队列的创建上有啥关系?
在定义队列和项的大小时,不同的配置会对数据传输和处理产生不同的影响。
在这里插入图片描述
综上所述,选择哪种配置取决于具体的应用需求:
(1)如果需要逐字符或逐对字符处理,第一项和第二项配置可能更合适。
(2)如果需要并行处理或传输多个部分,第三项配置可能更好。
(3)如果整个字符串作为一个单元被处理或传输,并且不需要进一步分割,那么第四项配置可能最简单。
在实际应用中,还需要考虑网络带宽、延迟、内存使用和其他系统资源来做出最佳决策。

(二)根据不同的按键值LCD上画不同方向的线

1、目标

创建两个任务一个队列即可

2、代码

(1)按键扫描任务:向队列中写入数据

void AppTASK_Scankeys(void *argument)
{
  /* USER CODE BEGIN AppTASK_Scankeys */
	//扫描键�?�并写入到队列中
	GPIO_PinState keystate=GPIO_PIN_SET;//按键是低电平有效,初始化为高电平
	KEYS key=KEY_NONE;//按键值暂时初始化为按键按�?



  /* Infinite loop */
  for(;;)
  {
	  key=KEY_NONE;
	  keystate=HAL_GPIO_ReadPin(KEY0_GPIO_Port, KEY0_Pin);
	  if(keystate==GPIO_PIN_RESET)//表明按键0按下
	  {
		  key=KEY_0;//赋�?�为枚举型变�?
	  }

	  keystate=HAL_GPIO_ReadPin(KEY1_GPIO_Port, KEY1_Pin);
	  if(keystate==GPIO_PIN_RESET)//表明按键0按下
	  {
		  key=KEY_1;//赋�?�为枚举型变�?
	  }

	  keystate=HAL_GPIO_ReadPin(KEY2_GPIO_Port, KEY2_Pin);
	  if(keystate==GPIO_PIN_RESET)//表明按键0按下
	  {
		  key=KEY_2;//赋�?�为枚举型变�?
	  }

	  keystate=HAL_GPIO_ReadPin(KEY_UP_GPIO_Port, KEY_UP_Pin);
	  if(keystate==GPIO_PIN_SET)//表明按键0按下
	  {
		  key=KEY_UP;//赋�?�为枚举型变�?
	  }

	  //如果按键按下了,则向队列中写�?
	  if(key!=KEY_NONE)
	  {
		  //队列句柄,放进队列的项(把key的地�?放进去)�?50ms阻塞延时
		  BaseType_t err= xQueueSend(Queue_keysHandle,&key,50);//返回数据类型为BaseType_t
		  if(err==errQUEUE_FULL)//如果队列已经满了
		  {
			  //队列复位
			  xQueueReset(Queue_keysHandle);
		  }
		  vTaskDelay(300);//�?300ms只允许传入一个键值(起到�?个消抖的作用�?
	  }
	  else//没有扫描到按键的情况
	  {
		  //如果不写这一条其他任务无法进行调�?
		  vTaskDelay(5);//5ms的延迟(进入阻塞状�?�让其他任务得到调度�?
	  }

    osDelay(1);
  }
  /* USER CODE END AppTASK_Scankeys */
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

(2)画线任务:读取队列数据
四个按键分别代表上下左右方向,根据不同的按键值往不同的方向画线

void AppTASK_Draw(void *argument)
{
  /* USER CODE BEGIN AppTASK_Draw */
	//读取队列数据并在lcd操作
	//const char *pcQueueGetName( QueueHandle_t xQueue )
	//先测试获取任务名称函�?
	uint8_t queueName[30];
	sprintf(queueName,"queue name =%s",pcQueueGetName(Queue_keysHandle));
	LCD_ShowString(10, 10+1*20,tftlcd_data.width,tftlcd_data.height, 12, queueName);


	//打印队列的大�?
	uint8_t queue_size[30];
	sprintf(queue_size,"queue size =%d",uxQueueSpacesAvailable(Queue_keysHandle));
	LCD_ShowString(10, 10+2*20,tftlcd_data.width,tftlcd_data.height, 12, queue_size);

	KEYS keyvalue;


  /* Infinite loop */
  for(;;)
  {

	//等待读取的消息个�?
	uint8_t tempStr[30];
	sprintf(tempStr,"queue wait number:%d",uxQueueMessagesWaiting(Queue_keysHandle));
	LCD_ShowString(10, 10+3*20,tftlcd_data.width,tftlcd_data.height, 12, tempStr);

	//剩余的空间个�?(当前)
	sprintf(tempStr,"queue size =%d",uxQueueSpacesAvailable(Queue_keysHandle));
	LCD_ShowString(10, 10+4*20,tftlcd_data.width,tftlcd_data.height, 12, tempStr);

	//下面获取任务高水位�?�来判断是否会发生栈空间溢出(如果某个任务高位�?�接�?0,就有栈溢出的风险,�?要增加栈空间大小�?
	sprintf(tempStr,"TASK_Draw HighWaterMark =%d",uxTaskGetStackHighWaterMark( TASK_DrawHandle ));
	LCD_ShowString(10, 10+5*20,tftlcd_data.width,tftlcd_data.height, 12, tempStr);

	sprintf(tempStr," TASK_Scankeys HighWaterMark=%d",uxTaskGetStackHighWaterMark( TASK_ScankeysHandle ));
	LCD_ShowString(10, 10+6*20,tftlcd_data.width,tftlcd_data.height, 12, tempStr);

//	//读取消息队列
	if(xQueueReceive(Queue_keysHandle,&keyvalue,50)!=pdTRUE)
	{
		continue;//继续运行,跳�?
	}
	if(keyvalue==KEY_0)//�?
	{
		curScreenX+=10;
	}
	else if(keyvalue==KEY_2)
	{
		curScreenX-=10;
	}
	else if(keyvalue==KEY_1)
	{
		curScreenY+=10;
	}
	else if(keyvalue==KEY_UP)
	{
		curScreenY-=10;
	}



	//如果坐标大于屏幕尺寸320*480则进行处�?
	if(curScreenX>tftlcd_data.width)//限制x坐标
	{
		curScreenX=tftlcd_data.width;
	}
	if(curScreenY>tftlcd_data.height)//限制y坐标
	{
		curScreenY=tftlcd_data.height;
	}
	LCD_DrawLine(lastScreenX, lastScreenY, curScreenX, curScreenY);
//	LCD_DrawLine_Color(lastScreenX, lastScreenY, curScreenX, curScreenY,RED);
	//记录�?下当前的变量
	lastScreenX=curScreenX;
	lastScreenY=curScreenY;
	vTaskDelay(400);
  }
  /* USER CODE END AppTASK_Draw */
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
本文内容由网友自发贡献,转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号