rt-thread多线程消息队列通信

yunteng521

673人浏览 · 2025-07-21 13:48:26

yunteng521 · 2025-07-21 13:48:26 发布

前言：
这章学习使用消息队列通信

1：环境
WIN11
STM32CubeMX 6.15.0
keil5.38
STM32F103C8T6
STLINKV2
USB转TTL(CH340)

2：代码
创建工程参考 rt-thread点亮LED(详细步骤)

rt-thread 使能消息队列或到 rtconfig.h line113 去掉注释
使能堆栈也一样
在这里插入图片描述

增加出串口输出
在这里插入图片描述
这章代码主要在
rt-thread多线程及按键处理
上修改而来，没有STM32CubeMX重新创建工程，只是用增加宏定义及代码
main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <rtthread.h>  // RT-Thread核心头文件 rtthread.h //自行增加
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
//自行增加
static rt_thread_t led_thread = RT_NULL;
static void led_thread_entry(void* parameter);

static rt_thread_t send_thread_1 = RT_NULL;
static void send_thread_entry_1(void* parameter);

static rt_thread_t send_thread_2 = RT_NULL;
static void send_thread_entry_2(void* parameter);

static rt_thread_t recv_thread = RT_NULL;
static void recv_thread_entry(void* parameter);

#define  LED_GPIO_Port  GPIOC
#define  LED_Pin     GPIO_PIN_13

#define  KEY_GPIO_Port  GPIOA  //pa1-pa4
#define  KEY1_Pin     GPIO_PIN_1
#define  KEY2_Pin     GPIO_PIN_2
#define  KEY3_Pin     GPIO_PIN_3
#define  KEY4_Pin     GPIO_PIN_4

#ifdef RT_USING_MESSAGEQUEUE   //在 rtconfig.h  line113  定义
static rt_mq_t system_mq = RT_NULL;

#define MSG_MAX_SIZE    64
#define MSG_MAX_NUM     10

typedef struct {
    rt_uint32_t msgtype;
    rt_uint32_t timestamp;
	  rt_uint32_t  msgcount;
} msg_t;

typedef struct {
    char       t1;
    rt_uint32_t timestamp;
} msg_tt;

#define  RT_SETUP_MSG_QUEUE
#endif

//#define  USE_KEY_PRESS_THREAD   //按键检测线程开启

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
////自行增加
int my_rt_thread_init(void){
	led_thread = /* 线程控制块指针 */
	rt_thread_create( "led", /* 线程名字 */
					led_thread_entry, /* 线程入口函数 */
					RT_NULL, /* 线程入口函数参数 */
					512, /* 线程栈大小 */
					3, /* 线程的优先级 */
					20); /* 线程时间片 */
	/* 启动线程，开启调度 */
	if (led_thread != RT_NULL)
		rt_thread_startup(led_thread);
	else
		return -1;

}

static void led_thread_entry(void* parameter)
{
	static uint32_t unum =0;
	while (1)
	{
		//rtconfig.h 有定义  
	// <o>OS tick per second
//  <i>Default: 1000   (1ms)
//#define RT_TICK_PER_SECOND 1000    //1000 == 1S  500= 0.5秒
		HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_SET);
		rt_thread_delay(500); /* 延时 500 个 tick */
		rt_kprintf("led_thread running on[%d]==>\r\n",unum);
		HAL_GPIO_WritePin(LED_GPIO_Port,LED_Pin,GPIO_PIN_RESET);
		rt_thread_delay(500); /* 延时 500 个 tick */
		rt_kprintf("led_thread running off[%d]<==\r\n",unum++);
		rt_thread_delay(3000); //延长时间
	}
}

static void send_thread_entry_1(void* parameter){
	uint32_t  send_count =0;
	while(1){
		#ifdef RT_SETUP_MSG_QUEUE
		msg_t  msg;
		while(1){
			msg.msgtype = 1;
			msg.timestamp = rt_tick_get();
			msg.msgcount  = send_count;
			rt_err_t t =rt_mq_send(system_mq, &msg, sizeof(msg_t));
			if(t != RT_EOK){
				rt_kprintf("sensor_thread rt_err_t: %d [%d]\n", (int)t,send_count);
			}else{
				rt_kprintf("send_thread msgdata:1- %d [%d]\n",msg.timestamp,send_count);
			}
			++send_count;
			rt_thread_mdelay(5000); // 每2秒采集一次
		}
		#else
		rt_kprintf("log_thread_entry on[%d]==>\r\n",send_count++);
		rt_thread_delay(5000); //延长时间
		#endif
	}
	
}

static void send_thread_entry_2(void* parameter){
	uint32_t  send_count =0;
	while(1){
		#ifdef RT_SETUP_MSG_QUEUE
		msg_t  msg;
		while(1){
			msg.msgtype = 2;
			msg.timestamp = rt_tick_get();
			msg.msgcount  = send_count;
			rt_err_t t =rt_mq_send(system_mq, &msg, sizeof(msg_t));
			if(t != RT_EOK){
				rt_kprintf("sensor_thread rt_err_t: %d [%d]\n", (int)t,send_count);
			}else{
				rt_kprintf("send_thread msgdata:2- %d [%d]\n",msg.timestamp,send_count);
			}
			++send_count;
			rt_thread_mdelay(5277); // 每2秒采集一次
		}
		#else
		rt_kprintf("log_thread_entry on[%d]==>\r\n",send_count++);
		rt_thread_delay(5000); //延长时间
		#endif
	}
	
}

static void recv_thread_entry(void* parameter){
	uint32_t  tcount =0;
	while(1){
		#ifdef RT_USING_MESSAGEQUEUE
		uint8_t buffer[MSG_MAX_SIZE];
    while (1) {
        // 接收消息（永久等待）
       rt_err_t t = rt_mq_recv(system_mq, buffer, MSG_MAX_SIZE, RT_WAITING_FOREVER);
       if(t == RT_EOK){
				 msg_t* pmsg = (msg_t*)buffer;
				 rt_kprintf("recv_thread msgdata:%d- %d [%d]\n",pmsg->msgtype,pmsg->timestamp,pmsg->msgcount);
			}else{
				rt_kprintf("recv_thread rt_err_t: %d\n", (int)t);
			}
			//rt_thread_mdelay(10); // 
    }
	#else
		rt_kprintf("recv_thread_entry on[%d]==>\r\n",tcount++);
		rt_thread_delay(5000); //延长时间
	#endif	
	}
}

uint8_t Key_Scan(uint8_t key)
{
    static uint8_t key_up = 1;  // 按键松开标志（1=松开）
    
    if (key_up && (key == 0))  // 按键按下（低电平）且之前处于松开状态
    {
        rt_thread_delay(20);  // 延时消抖（需自行实现延时函数）
        if (key == 0)  // 再次检测确认按下
        {
            key_up = 0;  // 标记按键按下
            return 1;    // 返回按下状态
        }
    }
    else if (key == 1)  // 按键松开（高电平）
    {
        key_up = 1;      // 标记按键松开
    }
    return 0;  // 未按下或消抖中
}

static void my_key_thread(void* parameter){
	while(1){
		// 检测各按键状态
			//	HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin); //Key_Scan(HAL_GPIO_GET(KEY1_PORT, KEY1_PIN))
        if (Key_Scan(HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY1_Pin)) == 1)
        {
            // K1按下，执行操作（例如点亮LED）
						rt_kprintf("key_thread KEY1 DOWN=>UP\r\n ");
        }
				 if (Key_Scan(HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY2_Pin)) == 1)
        {
            // K1按下，执行操作（例如点亮LED）
						rt_kprintf("key_thread KEY2 DOWN=>UP\r\n ");
        }
				
				 if (Key_Scan(HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY3_Pin)) == 1)
        {
            // K1按下，执行操作（例如点亮LED）
						rt_kprintf("key_thread KEY3 DOWN=>UP\r\n ");
        }
				
				 if (Key_Scan(HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY4_Pin)) == 1)
        {
            // K1按下，执行操作（例如点亮LED）
						rt_kprintf("key_thread KEY4 DOWN=>UP \r\n");
        }
				
				rt_thread_delay(200);
      
	}
	
}

static rt_thread_t key_thread = RT_NULL;

int key_rt_thread_init(void){
#ifdef USE_KEY_PRESS_THREAD	
	key_thread = /* 线程控制块指针 */
	rt_thread_create( "key", /* 线程名字 */
					my_key_thread, /* 线程入口函数 */
					RT_NULL, /* 线程入口函数参数 */
					512, /* 线程栈大小 */
					2, /* 线程的优先级 */
					20); /* 线程时间片 */
	/* 启动线程，开启调度 */
	if (key_thread != RT_NULL)
		rt_thread_startup(key_thread);
	else
		return -1;
#endif	
	
	#ifdef RT_USING_MESSAGEQUEUE
	rt_kprintf("sizeof(msg_tt)=%d\n",sizeof(msg_tt));//sizeof(msg_tt)=8  位4字节对齐  =16位8字节对齐  =5 为1字节对齐
	system_mq = rt_mq_create("sys_mq", MSG_MAX_SIZE, MSG_MAX_NUM, RT_IPC_FLAG_FIFO);
	if (system_mq == RT_NULL) {
			rt_kprintf("Failed to create message queue!\n");
			return -1;
	}else{
		rt_kprintf("success to create message queue!\n");
	}
#endif
	
	send_thread_1 = /* 线程控制块指针 */
	rt_thread_create( "send1", /* 线程名字 */
					send_thread_entry_2, /* 线程入口函数 */
					RT_NULL, /* 线程入口函数参数 */
					512, /* 线程栈大小 */
					2, /* 线程的优先级 */
					20); /* 线程时间片 */
	/* 启动线程，开启调度 */
	if (send_thread_1 != RT_NULL)
		rt_thread_startup(send_thread_1);
	else
		return -1;
	
	send_thread_2 = /* 线程控制块指针 */
	rt_thread_create( "send2", /* 线程名字 */
					send_thread_entry_1, /* 线程入口函数 */
					RT_NULL, /* 线程入口函数参数 */
					512, /* 线程栈大小 */
					2, /* 线程的优先级 */
					20); /* 线程时间片 */
	/* 启动线程，开启调度 */
	if (send_thread_2 != RT_NULL)
		rt_thread_startup(send_thread_2);
	else
		return -1;
	
	recv_thread = /* 线程控制块指针 */
	rt_thread_create( "recv1", /* 线程名字 */
					recv_thread_entry, /* 线程入口函数 */
					RT_NULL, /* 线程入口函数参数 */
					512, /* 线程栈大小 */
					1, /* 线程的优先级 */
					40); /* 线程时间片 */
	/* 启动线程，开启调度 */
	if (recv_thread != RT_NULL)
		rt_thread_startup(recv_thread);
	else
		return -1;
	rt_kprintf("key_rt_thread_init  ok!\n");
	return 0;
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */
	//自行增加
	//my_rt_thread_init();
	key_rt_thread_init();
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
		//自行增加
		rt_thread_delay(500); 
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

3：结果如果对你又帮助，麻烦点个赞，加个关注
demo地址
demo md5:e376bfff8b277e6dbf6958d0277f3531
学会了MESSAGEQUEUE 那么 MAILBOX 更简单了
却别在于 MESSAGEQUEUE 消息可以变长，不超过最大长度就行
MAILBOX 定长
MESSAGEQUEUE MAILBOX 都支持 mpmc
一般用mpsc就可以了，
在这里插入图片描述

天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

deck.gl TripsLayer 出租车轨迹动画示例实战：从示例运行到着色器原理

TripsLayer 是 deck.gl 中用于渲染**随时间流动的轨迹动画**（如出租车行程、物流路径、迁徙路线）的核心图层。本文以仓库中的最小独立示例 [examples/website/trips](https://link.gitcode.com/i/1442af8f442f4cff39ff546e050fceb5) 为骨架，带你完成从安装依赖、启动应用、理解曼哈顿出租车数据格式，到深入

天工造物局

Foundry Anvil 中 eth_simulateV1 的 Blob 交易与 Blob Gas 字段规范化：原理、实现与测试验证

本篇技术指南以 [anvil-simulate-blob-transactions.md](https://link.gitcode.com/i/3d2ebe227262de169335eb290af80da8) 这条 changelog 条目为起点，深入剖析 Foundry Anvil 对 `eth_simulateV1` RPC 返回结果中 blob（EIP-4844）交易与 blob gas

天工造物局

LMCache CLI 实战：用 `lmcache kvcache clear` 管理运行中服务的 KV Cache 状态

本文是一份针对 LMCache 官方 CLI 命令 `lmcache kvcache` 的完整技术指南。该命令用于在**运行中的 LMCache 服务（MP HTTP server）**上管理 KV cache 状态，当前提供 `clear` 子命令，用于清空 L1（CPU 内存）层中缓存的全部 KV 数据。读完本文，你将掌握该命令的完整参数体系、退出码语义、终端/JSON/静默三种输出模式，并能