5 为什么消息队列接不到消息呢？

发布于 2024-11-11 21:02:03 浏览：291 订阅该版

当串口接收到固定数据帧时，通过消息队列发送一个结构体，为什么另一边接不到呢
```c
#include <rtthread.h>
#include <zhukong.h>

#if defined(RT_VERSION_CHECK) && (RTTHREAD_VERSION >= RT_VERSION_CHECK(5, 0, 1))
    rt_align(RT_ALIGN_SIZE)
#else
    ALIGN(RT_ALIGN_SIZE)
#endif

static rt_device_t serial3;
static rt_device_t serial2;

static char thread_uart3_stack[1024];
static struct rt_thread thread_uart3;

static char thread_send_mq_stack[1024];
static struct rt_thread thread_send_mq;

static struct rt_semaphore uart3_rx_sem;
static rt_bool_t should_continue_parsing = RT_TRUE;

static struct rt_messagequeue mq_uart2;  // 消息队列句柄
static rt_uint8_t mq_uart2_pool[1024];

static rt_err_t uart3_rx_ind(rt_device_t dev, rt_size_t size)
{
	if (size > 0)
    {
        rt_sem_release(&uart3_rx_sem);
    }
    return RT_EOK;

}

static rt_uint8_t uart3_get_data(void)
{
	rt_uint8_t ch;
	
	while(rt_device_read(serial3, 0, &ch, 1) == 0)
	{
		rt_sem_control(&uart3_rx_sem, RT_IPC_CMD_RESET, RT_NULL);
        rt_sem_take(&uart3_rx_sem, RT_WAITING_FOREVER);
	}
	
	return ch;
}

static void data_parsing(rt_uint8_t *data, rt_size_t length )  
{  
    rt_uint8_t ch;  
 
    static int index = 0;  
  
    while (should_continue_parsing)  
    {  
        ch = uart3_get_data();  
            
        if (index == 0 && ch == MFRAME)  // 检查是否是帧头
        {  
            data[index++] = ch;  
        }  
		
        else if (index > 0 && index < length)  
        {  
              
            data[index++] = ch;  
  
             
            if (index == length)  // 检查是否接收完整个数据帧 
            {    
                rt_kprintf("Received data frame: ");  
                for (int i = 0; i < length; i++)  
                {  
                    rt_kprintf("%02X ", data[i]);  
                }  
                rt_kprintf("\n");  
    
                index = 0; 
				
				should_continue_parsing = RT_FALSE;
            }  
        }  
        else if (index == length && ch != MFRAME)  
        {   
            index = 0;  
        }  
    }

should_continue_parsing = RT_TRUE;
}

static void data_get(void *parameter)
{
	rt_uint8_t value;
	data_frame data;
	while(1)
	{
		data_parsing(data.RX_DATA_BUFF,8);
		
		if(data.RX_DATA_BUFF[1] == 0x01)
		{
			value = (rt_uint8_t)data.RX_DATA_BUFF[4];
		
			rt_kprintf("thread2:%x \n", value);
				
			rt_mb_send(&pwm_mb, (rt_uint32_t)&value);

}
		
		if(data.RX_DATA_BUFF[1] == 0x02)
		{
			rt_sem_release(&adc_sem);			
		}
		
		if(data.RX_DATA_BUFF[1] == 0x03)
		{
			rt_err_t result;
			struct msg_t msg; 
			
            msg.data[0] = 0x10;
			msg.data[1] = 0x20;
			msg.data[2] = 0x30;
			msg.data[3] = 0x40;
			msg.data[4] = 0x50;
			msg.data[5] = 0x50;
			msg.data[6] = 0x50;
			msg.data[7] = 0x50;
			
			
			result = rt_mq_send(&mq_uart2, &msg, sizeof(struct msg_t));
			
			if (result != RT_EOK)
			{
				rt_kprintf("adc sample run failed! can't find %s device!\n");
			}
			else
			{
				rt_kprintf("send successs\n");
			}
			
		}
		
	}

}

static void uart3_init(void)
{	
	rt_err_t result;
	
	serial3 = rt_device_find(ZK_UART_NAME);
	if(!serial3)
	{
		rt_kprintf("find %s failed!\n", ZK_UART_NAME);
        
	}
	
	rt_sem_init(&uart3_rx_sem, "uart3_rx_sem", 0, RT_IPC_FLAG_FIFO);
	
	rt_device_open(serial3, RT_DEVICE_FLAG_INT_RX);
	
	rt_device_set_rx_indicate(serial3, uart3_rx_ind);
	
	result = rt_mb_init(&pwm_mb,
						"pwm_mb",
						mt_pool,
						sizeof(mt_pool)/4,
						RT_IPC_FLAG_FIFO);
	if (result != RT_EOK)
    {
        rt_kprintf("init mailbox failed.\n");
    }
	
}

static void uart2_init(void)
{	
	rt_err_t result;
	
	serial2 = rt_device_find(CJ_UART_NAME);
	if(!serial2)
	{
		rt_kprintf("find %s failed!\n", CJ_UART_NAME);
        
	}

rt_device_open(serial2, RT_DEVICE_FLAG_INT_RX);
	
	
	
	// 创建消息队列
    result = rt_mq_init(&mq_uart2,
                        "mq_uart2",
                        &mq_uart2_pool[0],             /* 内存池指向 msg_pool */
                        sizeof(struct msg_t),                          /* 每个消息的大小是 1 字节 */
                        sizeof(mq_uart2_pool),        /* 内存池的大小是 msg_pool 的大小 */
                        RT_IPC_FLAG_FIFO);       /* 如果有多个线程等待，优先级大小的方法分配消息 */
    if (result != RT_EOK)
    {
        rt_kprintf("Create MQ failed!\n");
    }
	
}

static void send_mq_data(void)
{
	struct msg_t recv_msg;
    rt_size_t recv_size;
	rt_err_t result;
	
    while (1)
    {
        
		result = rt_mq_recv(&mq_uart2, &recv_msg, sizeof(struct msg_t), RT_WAITING_FOREVER);
        if (result = RT_ERROR)
		{
			rt_kprintf("Received: FAILED");
		}
		else
		{			
			for (int i = 0; i < 10; i++)
            {
                rt_kprintf("Received: %02x\n", recv_msg.data[i]);
            }
			
		}
		
    }
}

int test_sample(void)
{

uart3_init();

uart2_init();
	
				   
	rt_thread_init(&thread_uart3,
                   "thread_uart3",
                   data_get,
                   RT_NULL,
                   &thread_uart3_stack[0],
                   sizeof(thread_uart3_stack),
                   THREAD_PRIORITY, THREAD_TIMESLICE);
    rt_thread_startup(&thread_uart3);
				   
	rt_thread_init(&thread_send_mq,
                   "thread_send_mq",
                   send_mq_data,
                   RT_NULL,
                   &thread_send_mq_stack[0],
                   sizeof(thread_send_mq_stack),
                   THREAD_PRIORITY, THREAD_TIMESLICE);
    rt_thread_startup(&thread_send_mq);
				   
	return 0;
}

MSH_CMD_EXPORT(test_sample , uart device sample);
```