RT-Thread-15天入门-第10天消息队列的使用RT-Thread问答社区

15天入门-第10天消息队列的使用

发布于 2018-05-28 00:19:46 浏览：1470 订阅该版

本次课程主要讲消息队列的使用，包含：
1、结合邮箱相关API 介绍消息队列相关API
邮箱大小容量固定4个字节;
创建/初始化 发送 接收 删除/分离detach 
struct rt_messagequeue
{
 struct rt_ipc_object parent; /**< inherit from ipc_object */

void *msg_pool; /**< start address of message queue */

rt_uint16_t msg_size; 消息大小 /**< message size of each message */
 rt_uint16_t max_msgs; 最大消息数量 /**< max number of messages */

rt_uint16_t entry; /**< index of messages in the queue */

void *msg_queue_head; /**< list head */
 void *msg_queue_tail; /**< list tail */
 void *msg_queue_free; /**< pointer indicated the free node of queue */
};
typedef struct rt_messagequeue *rt_mq_t;
 /* 从消息队列中接收消息 */

if (rt_mq_recv(&mq, &buf, sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)
    rt_mq_detach(&mq);

/* 发送紧急消息到消息队列中 */
 
result = rt_mq_urgent(&mq, &buf, 1);
 
/* 发送消息到消息队列中 */
 
   result = rt_mq_send(&mq, &buf, 1);     buf 就是直接发送的值.
  /* 初始化消息队列 */
    
result = rt_mq_init(&mq,

"mqt",
  
                    &msg_pool[0],               /* 内存池指向msg_pool */
 
                    1,                          /* 每个消息的大小是 1 字节 */
 
                    sizeof(msg_pool),           /* 内存池的大小是msg_pool的大小 */
                    
RT_IPC_FLAG_FIFO);          /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
     
2、例程源码解析
rt_thread 异常都是负的.
线程1 接收  间隔 100ms

线程 2 发送 间隔 10ms
3、邮箱和消息队列的几点区别
消息队列 会复制到 局部变量中.消息内容可以是局部变量也可以是全局变量
邮箱并没有进行内存复制,只是复制了内存地址.邮箱内容如果是局部变量的话,发送和接收 会有问题,一般内容
都是静态变量.不要放在局部变量中,因为局部变量放在栈中,退出后就回收了.

内容大小的不同:如果消息队列内容大小为4 就退化成邮箱.
4、消息队列的同步问题
异步的关系,任务2 发送消息给任务1,任务1 有没有收到,任务2不能立即就知道.
用消息的话,需要考虑消息同步的问题,主要解决的就是下面的问题:
接收方需要告诉 发送方自身已经接到消息了.
mailbox sem 
作业:
使用消息队列进行实际操作:
比如led 和key 的实际控制.
由于暂时没有增加同步的代码,会出现 key 已经恢复到原来的值,但还一直在receive,
造成的原因就是发送和接收间隔不一致.
 ```/*
 * 程序清单：消息队列例程
 *
 * 这个程序会创建2个动态线程，一个线程会从消息队列中收取消息；一个线程会定时给消
 * 息队列发送 普通消息和紧急消息。
 */
#include <rtthread.h>
#include "stm32f1xx.h"
#include "stm32f1xx_hal.h"
/* 消息队列控制块 */
static struct rt_messagequeue mq;
/* 消息队列中用到的放置消息的内存池 */
static rt_uint8_t msg_pool[2048];

ALIGN(RT_ALIGN_SIZE)
static char thread1_stack[1024];
static struct rt_thread thread1;
/* 线程1入口函数 */
static void thread1_entry(void *parameter)
{
    rt_uint8_t buf = 0;
     GPIO_InitTypeDef  GPIO_InitStruct;
	 	/* Enable the BUTTON Clock */
  __HAL_RCC_GPIOB_CLK_ENABLE();

/* Configure Button pin as input */
 GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 while (1)
 {
 /* 从消息队列中接收消息 */
 if (rt_mq_recv(&mq, &buf, sizeof(buf), RT_WAITING_FOREVER) == RT_EOK)
 {
 rt_kprintf("thread1: recv msg from msg queue, the content:%d ", buf);
 if (buf == 49)
 {
 break;
 }
						if(buf ==2)
						{
							 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET);
 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET);
							 rt_kprintf("LED OFF");
						}
						if(buf ==3)
						{
							HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_SET);
							rt_kprintf("LED_ON");
						}
						buf = 0;
 }
 /* 延时100ms */
 rt_thread_delay(rt_tick_from_millisecond(100));
 }
 rt_kprintf("thread1: detach mq ");
 rt_mq_detach(&mq);
}

ALIGN(RT_ALIGN_SIZE)
static char thread2_stack[1024];
static struct rt_thread thread2;
/* 线程2入口 */
static void thread2_entry(void *parameter)
{
    int result;
    rt_uint8_t buf = 0;
	GPIO_InitTypeDef GPIO_InitStruct;
	/* Enable the BUTTON Clock */
  __HAL_RCC_GPIOB_CLK_ENABLE();

/* Configure Button pin as input */
 GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3;
 GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
 GPIO_InitStruct.Pull = GPIO_PULLDOWN;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 while (1)
 {
 /* if (buf == 25)
 {
 // 发送紧急消息到消息队列中 
 result = rt_mq_urgent(&mq, &buf, 1);
 if (result != RT_EOK)
 {
 rt_kprintf("rt_mq_urgent ERR ");
 }
 rt_kprintf("thread2: send urgent message - %d ", buf);
 }
 else if (buf >= 50)// 发送50次消息之后退出 
 {
 rt_kprintf("message queue stop send, thread2 quit ");
 break;
 }
 else
 {
 //发送消息到消息队列中 
 result = rt_mq_send(&mq, &buf, 1);
 if (result != RT_EOK)
 {
 rt_kprintf("rt_mq_send ERR ");
 }

rt_kprintf("thread2: send message - %d ", buf);
 }
 buf++;
 //延时10ms 
				*/
				 if(1==HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2))
					{
						buf=2;
 /* 发送mb_str1地址到邮箱中 */
 rt_mq_send(&mq,&buf,1);
						 rt_kprintf("thread2: send message - %d ", buf);
 }
					if(1== HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_3))
					{
						buf = 3;
						 /* 发送mb_str2地址到邮箱中 */
 rt_mq_send(&mq,&buf,1);
						rt_kprintf("thread2: send message - %d ", buf);
					}
 rt_thread_delay(rt_tick_from_millisecond(10));
 }
}

/* 消息队列示例的初始化 */
int messagequeue_sample_init()
{
    rt_err_t result;

/* 初始化消息队列 */
    result = rt_mq_init(&mq,
                        "mqt",
                        &msg_pool[0],               /* 内存池指向msg_pool */
                        1,                          /* 每个消息的大小是 1 字节 */
                        sizeof(msg_pool),           /* 内存池的大小是msg_pool的大小 */
                        RT_IPC_FLAG_FIFO);          /* 如果有多个线程等待，按照先来先得到的方法分配消息 */

if (result != RT_EOK)
 {
 rt_kprintf("init message queue failed. ");
 return -1;
 }

rt_thread_init(&thread1,
                   "thread1",
                   thread1_entry,
                   RT_NULL,
                   &thread1_stack[0],
                   sizeof(thread1_stack), 25, 5);
    rt_thread_startup(&thread1);

rt_thread_init(&thread2,
                   "thread2",
                   thread2_entry,
                   RT_NULL,
                   &thread2_stack[0],
                   sizeof(thread2_stack), 25, 5);
    rt_thread_startup(&thread2);

return 0;
}
/* 如果设置了RT_SAMPLES_AUTORUN，则加入到初始化线程中自动运行 */
#if defined (RT_SAMPLES_AUTORUN) && defined(RT_USING_COMPONENTS_INIT)
    INIT_APP_EXPORT(messagequeue_sample_init);
#endif
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(messagequeue_sample_init, messagequeue sample);
```