基于STM32F103移植华为LiteOS_消息队列之任务间通信

最新推荐文章于 2023-06-09 19:02:38 发布
最新推荐文章于 2023-06-09 19:02:38 发布
阅读量862 收藏
点赞数 2
分类专栏： 华为LiteOS 文章标签： 嵌入式 华为 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/morecrazylove/article/details/124079027
版权

基于STM32F103移植华为LiteOS_消息队列之任务间通信

一、消息队列的一些专业描述

消息队列基本概念：
队列又称消息队列，是一种常用于任务间通信的数据结构，实现了接收来自任务或中断的不固定长度的消息，并根据不同的接口选择传递消息是否存放在自己空间。任务能够从队列里面读取消息，当队列中的消息是空时，挂起读取任务；当队列中有新消息时，挂起的读取任务被唤醒并处理新消息。
用户在处理业务时，消息队列提供了异步处理机制，允许将一个消息放入队列，但并不立即处理它，同时队列还能起到缓冲消息作用。
Huawei LiteOS中使用队列数据结构实现任务异步通信工作，具有如下特性：
• 消息以先进先出方式排队，支持异步读写工作方式。
• 读队列和写队列都支持超时机制。
• 发送消息类型由通信双方约定，可以允许不同长度（不超过队列节点最大值）消息。
• 一个任务能够从任意一个消息队列接收和发送消息。
• 多个任务能够从同一个消息队列接收和发送消息。
• 当队列使用结束后，如果是动态申请的内存，需要通过释放内存函数回收。

消息队列运作原理
创建队列时，根据用户传入队列长度和消息节点大小来开辟相应的内存空间以供该队列使用，返回队列ID。

在队列控制块中维护一个消息头节点位置Head和一个消息尾节点位置Tail来表示当前队列中消息存储情况。Head表示队列中被占用消息的起始位置。Tail表示队列中被空闲消息的起始位置。刚创建时Head和Tail均指向队列起始位置。

写队列时，根据Tail找到被占用消息节点末尾的空闲节点作为数据写入对象。如果Tail已经指向队列尾则采用回卷方式。根据usWritableCnt判断队列是否可以写入，不能对已满（usWritableCnt为0）队列进行写队列操作。

读队列时，根据Head找到最先写入队列中的消息节点进行读取。如果Head已经指向队列尾则采用回卷方式。根据usReadableCnt判断队列是否有消息读取，对全部空闲（usReadableCnt为0）队列进行读队列操作会引起任务挂起。

删除队列时，根据传入的队列ID寻找到对应的队列，把队列状态置为未使用，释放原队列所占的空间，对应的队列控制头置为初始状态。
图1 队列读写数据操作示意图
图1 队列读写数据操作示意图
在这里插入图片描述

二、我的描述

消息队列就是一个双向链表，它就像工厂的流水线。正常的情况下，从尾部进行添加各种加工材料，然后从头部产出成品。但在不正常的情况下，老板之间将材料扔进头部的加工材料直接产出成品。这两种情况也就分别对应先出原则（First In First Out ，FIFO） 和后进先出原则（Last In First Out，LIFO）。
这里我是怎么知道还有LIFO机制的呢？通过野火的LiteOS指南可以知道，但是这个指南没有告诉这个机制怎么用，哪里引出来的这个机制？这个我是通过华为官方提供的开发指南文档知道的，如下图是我在该指南文档中截取的关键信息。
在这里插入图片描述
一般来说，消息队列在队列头部写数据是在特殊的紧急情况才会去使用的，正常情况都会遵守FIFO原则。
从上图还可以知道，LiteOS 提供了两种消息的传输方式，一种是复制方式，另一种是引用方式，通过上文的类比，读者可以选择自己需要的消息传输方式。读者可以根据消息的大小与重要性来选择消息的传递方式，假如消息是很重要的话，选择复制的方式会更加安全，假如消息的数据量很小的话，也是可以选择复制的方式。假如消息只是一些不重要的内容或者消息数据量很大， 可以选择引用方式。
相关开发指南资料链接：Huawei LiteOS开发全家桶

三、野火的LiteOS开发指南的消息队列实验错误地方

大家要是使用的是野火的《物联网操作系统 LiteOS开发实战指南—基于STM32》这个学习的，想必也会遇到读写消息队列的消息是出错的。
大家是否记得，写入消息队列的消息不能大于定义的消息队列的消息节点大小，而读取消息队列的消息不能小于定义的消息队列的消息节点大小。
如下图是野火教程文档中的实验程序。
在这里插入图片描述
在这里插入图片描述
在此，大家想必已经明白原因了。

四、我的基于STM32F103的LiteOS之消息队列读写实验

这里我说一下，我的实验是基于之前编写的按键状态机进行的实验。后续会写更多相关的面向对象编程的架构实验。

/* LiteOS头文件 */
#include "los_sys.h "
#include "los_task.ph"
#include "los_queue.h"

/* 外设驱动头文件 */
#include "led.h"
#include "usart1.h"
#include "key.h"

/* 定义任务 ID 变量,也叫任务句柄 */
UINT32 LED1_Task_Handle;					//RED LED
UINT32 LED2_Task_Handle;					//GREEN LED
UINT32 Key_Task_Handle;						//KEY
UINT32 Queue_Receive_Task_Handle;	//消息队列接收

/* 定义消息队列的ID变量,消息队列句柄 */
UINT32 Test_Queue_Handle;

/* 定义消息队列长度 */
#define TEST_QUEUE_LEN			20	//队列中消息个数
#define TEST_QUEUE_SIZE			20	//消息节点大小

/* 定义全局变量 */
static CHAR send_data1[] = "djw";
static CHAR send_data2[] = "hyt";

/* 函数声明 */
static UINT32 AppTaskCreate();							//用于创建任务管理
static UINT32 Create_LED1_Task();						//创建任务1函数
static UINT32 Create_LED2_Task();						//创建任务2函数
static UINT32 Create_Key_Task();						//创建任务3函数
static UINT32 Create_Queue_Receive_Task();	//创建任务4函数

static void LED1_Task(void);					//任务1函数
static void LED2_Task(void);					//任务2函数
static void Key_Task(void);						//任务3函数
static void Queue_Receive_Task(void);	//任务4函数

int main(void)
{	
	UINT32 uwRet = LOS_OK; //定义一个任务创建的返回值，默认为创建成功
	
	/*中断优先级分组为 4*/
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
	/* 板载相关初始化 */
	Usart1_Config();		//串口1
	LED_GPIO_Config();	//LED
	Key_Config_parameter();	//按键
	
	printf("KEYUP = %d\r\n",KEY_CLASS[KEYUP].Key_Init.GPIO_Pin_x);
	printf("KEY0 = %d\r\n",KEY_CLASS[KEY0].Key_Init.GPIO_Pin_x);
	printf("KEY1 = %d\r\n",KEY_CLASS[KEY1].Key_Init.GPIO_Pin_x);
	printf("KEY2 = %d\r\n",KEY_CLASS[KEY2].Key_Init.GPIO_Pin_x);

	printf("正点原子战舰开发板-LiteOS-SRAM 动态创建多任务！\r\n\r\n");
	
	/* LiteOS 内核初始化 */
	uwRet = LOS_KernelInit();
	if (uwRet != LOS_OK) {
		printf("LiteOS核心初始化失败！任务代码0X%X\r\n",uwRet);
		return LOS_NOK;
	}
	
	uwRet = AppTaskCreate();
	if (uwRet != LOS_OK) {
		printf("AppTaskCreate任务创建失败！任务代码0X%X\r\n",uwRet);
		return LOS_NOK;
	}
	
	/* 开启 LiteOS 任务调度 */
	LOS_Start();
	
	while(1){	//上面任务失败会进入此,LED关闭
		GPIO_SetBits(GPIOB, GPIO_Pin_5);
		GPIO_SetBits(GPIOE,GPIO_Pin_5);
	}
}

/**************************************************************************/
/******************************** 任务函数 ********************************/
/**************************************************************************/

/*******************************************************************
 * @ 函数名 ： AppTaskCreate
 * @ 功能说明： 任务创建，为了方便管理，所有的任务创建函数都可以放在这个函数里面
 * @ 参数 ： NULL
 * @ 返回值 ： NULL
 *************************************************************/
static UINT32 AppTaskCreate(void)
{
	/* 定义一个返回类型变量，初始化为 LOS_OK */
	UINT32 uwRet = LOS_OK;

	/* 创建消息队列 */
	uwRet = LOS_QueueCreate("Test_Queue", 		/* 消息队列的名称 */
													TEST_QUEUE_LEN,			/* 消息队列的长度 */
													&Test_Queue_Handle,	/* 消息队列的 ID(句柄) */
													0,							/* 消息队列模式，官方暂时未使用 */
													TEST_QUEUE_SIZE);		/* 节点大小，单位为字节 */
	if (uwRet != LOS_OK) {
		printf("Test_Queue消息队列创建失败！失败代码 0X%X\r\n",uwRet);
		return uwRet;
	}	
	
	uwRet = Create_Queue_Receive_Task();
	if (uwRet != LOS_OK) {
		printf("Queue_Receive_Task 任务创建失败！失败代码0X%X\r\n",uwRet);
		return uwRet;
	}
	
	uwRet = Create_LED1_Task();
	if (uwRet != LOS_OK) {
		printf("LED1_Task任务创建失败！失败代码0X%X\r\n",uwRet);
		return uwRet;
	}
	
	uwRet = Create_LED2_Task();
	if (uwRet != LOS_OK) {
		printf("LED2_Task任务创建失败！失败代码0X%X\r\n",uwRet);
		return uwRet;
	}
	
	uwRet = Create_Key_Task();
	if (uwRet != LOS_OK) {
		printf("Key_Task 任务创建失败！失败代码0X%X\r\n",uwRet);
		return uwRet;
	}

	return LOS_OK;
}

/******************************************************************
 * @ 函数名 ： Create_LED1_Task
 * @ 功能说明： 创建 LED1_Task 任务
 * @ 参数 ：	NULL
 * @ 返回值 ： NULL
 ******************************************************************/
static UINT32 Create_LED1_Task()
{
	//定义一个创建任务的返回类型，初始化为创建成功的返回值
	UINT32 uwRet = LOS_OK;
	
	//定义一个用于创建任务的参数结构体
	TSK_INIT_PARAM_S task_init_param;

	task_init_param.usTaskPrio = 6; /* 任务优先级，数值越小，优先级越高 */
	task_init_param.pcName = "LED1_Task";/* 任务名 */
	task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)LED1_Task;		//任务入口函数
	task_init_param.uwStackSize = 1024; /* 栈大小 */

	uwRet = LOS_TaskCreate(&LED1_Task_Handle, &task_init_param);	//LED1_Task_Handle任务ID
	return uwRet;
}

/******************************************************************
 * @ 函数名 ： Create_LED1_Task
 * @ 功能说明： 创建 LED1_Task 任务
 * @ 参数 ：	NULL
 * @ 返回值 ： NULL
 ******************************************************************/
static UINT32 Create_LED2_Task()
{
	//定义一个创建任务的返回类型，初始化为创建成功的返回值
	UINT32 uwRet = LOS_OK;
	
	//定义一个用于创建任务的参数结构体
	TSK_INIT_PARAM_S task_init_param;

	task_init_param.usTaskPrio = 7; /* 任务优先级，数值越小，优先级越高 */
	task_init_param.pcName = "LED2_Task";/* 任务名 */
	task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)LED2_Task;		//任务入口函数
	task_init_param.uwStackSize = 1024; /* 栈大小 */

	uwRet = LOS_TaskCreate(&LED2_Task_Handle, &task_init_param);	//LED1_Task_Handle任务ID
	return uwRet;
}

/*******************************************************************
 * @ 函数名 ： Create_Key_Task
 * @ 功能说明： 创建 Key_Task 任务
 * @ 参数 ：	NULL
 * @ 返回值 ： NULL
 ******************************************************************/
static UINT32 Create_Key_Task() {
	// 定义一个创建任务的返回类型，初始化为创建成功的返回值
	UINT32 uwRet = LOS_OK;
	TSK_INIT_PARAM_S task_init_param;

	task_init_param.usTaskPrio = 4; /* 任务优先级，数值越小，优先级越高 */
	task_init_param.pcName = "Key_Task"; /* 任务名*/
	task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)Key_Task; //任务入口函数
	task_init_param.uwStackSize = 1024; /* 栈大小 */

	uwRet = LOS_TaskCreate(&Key_Task_Handle,&task_init_param);/*创建任务 */

 return uwRet;	
}

/*******************************************************************
 * @ 函数名 ： Create_Queue_Receive_Task
 * @ 功能说明： 创建 Key_Task 任务
 * @ 参数 ：	NULL
 * @ 返回值 ： NULL
 ******************************************************************/
static UINT32 Create_Queue_Receive_Task() {
	//定义一个返回类型变量，初始化为 LOS_OK
	UINT32 uwRet = LOS_OK;	
	//定义一个用于创建任务的参数结构体
	TSK_INIT_PARAM_S task_init_param;
	
	task_init_param.usTaskPrio = 5; /* 任务优先级，数值越小，优先级越高 */
	task_init_param.pcName = "Queue_Receive_Task"; /* 任务名*/
	task_init_param.pfnTaskEntry = (TSK_ENTRY_FUNC)Queue_Receive_Task; //任务入口函数
	task_init_param.uwStackSize = 1024; /* 栈大小 */
	
	uwRet = LOS_TaskCreate(&Queue_Receive_Task_Handle,&task_init_param);/*创建任务 */

 return uwRet;	
}


/**************************************************************************/
/******************************** 任务函数 ********************************/
/**************************************************************************/

/******************************************************************
 * @ 函数名 ： LED1_Task
 * @ 功能说明： LED1_Task 任务实现
 * @ 参数 ： NULL
 * @ 返回值 ： NULL
 *****************************************************************/
static void LED1_Task(void) {
	int i = 0;
	/* 任务都是一个无限循环，不能返回 */
	while(1) {
		if(i%2==0) {
			GPIO_ResetBits(GPIOB, GPIO_Pin_5);
		} else {
			GPIO_SetBits(GPIOB, GPIO_Pin_5);
		}
//		printf("任务1---1000ms\r\n");
		i++;
		if(i>100) i=0;
		LOS_TaskDelay(1000);
	}
}

/******************************************************************
 * @ 函数名 ： LED2_Task
 * @ 功能说明： LED2_Task 任务实现
 * @ 参数 ： NULL
 * @ 返回值 ： NULL
 *****************************************************************/
static void LED2_Task(void) {
	int i = 0;
	/* 任务都是一个无限循环，不能返回 */
	while(1) {
		if(i%2==0) {
			GPIO_SetBits(GPIOE,GPIO_Pin_5);
		} else {
			GPIO_ResetBits(GPIOE,GPIO_Pin_5);
		}
//		printf("任务2---500ms\r\n");
		i++;
		if(i>100) i=0;
		LOS_TaskDelay(500);
	}
}

/******************************************************************
 * @ 函数名 ： Key_Task
 * @ 功能说明： Key_Task 任务实现
 * @ 参数 ： NULL
 * @ 返回值 ： NULL
 *****************************************************************/
static void Key_Task(void) {
	UINT32 uwRet = LOS_OK;
	UINT8 i,trigger_state;		
	UINT32 j=0;	//是用来检测长按按下的扫描周期数的
	while(1) {
		Read_Key_State();	//启动状态机检测按键状态
		for(i=0;i<KEY_CLASS_NUM;i++) {
			trigger_state = KEY_CLASS[i].Key_State_Machine.Key_Event;	//获取按键触发状态
			
			if((trigger_state==KEY_CONFIRN_DOWN) && (i==KEYUP)) {
				printf("挂起LED_LED2_Task 任务！\r\n");
				uwRet = LOS_TaskSuspend(LED2_Task_Handle);
				if (uwRet == LOS_OK) {
					printf("挂起LED_LED2_Task 任务成功！\r\n");
				}
			}
			
			if((trigger_state==KEY_CONFIRN_DOWN) && (i==KEY0)) {
				printf("恢复 LED_LED2_Task 任务！\r\n");
				uwRet = LOS_TaskResume(LED2_Task_Handle);
				if (uwRet == LOS_OK) {
						printf("恢复 LED_LED2_Task 任务成功！\r\n");
				}
			}
			
			/* 如果为KEY1和长按事件和长按的周期不为0次，那么我就自减按下的周期数 */
			if((trigger_state==KEY_LONG_DOWN) && (i==KEY1) && (KEY_CLASS[i].Key_State_Machine.Key_Count>=0)) {
				KEY_CLASS[i].Key_State_Machine.Key_Count--;
				++j;
				printf("count = %d\r\n",j);
			} else if((trigger_state==KEY_UP) && (i==KEY1)) {
				j = 0;
			}
			
			/***************** 发送消息到消息队列 *****************/
			if((trigger_state==KEY_CONFIRN_DOWN) && (i==KEY1)) {
				/* 将消息写入消息队列中，等待时间为0 */
				uwRet = LOS_QueueWrite(Test_Queue_Handle,	/* 消息队列的ID（句柄） */
															send_data1,				/* 写入消息队列的消息 */	
															sizeof(send_data1),	/* 写入消息队列的消息长度 */
															0);
				if (uwRet != LOS_OK) {
					printf("消息不能写入到消息队列！错误代码 0X%X\r\n",uwRet);
				}
			}
			
			if((trigger_state==KEY_CONFIRN_DOWN) && (i==KEY2)) {
				/* 将消息写入消息队列中，等待时间为0 */
				uwRet = LOS_QueueWrite(Test_Queue_Handle,	/* 消息队列的ID（句柄） */
															send_data2,				/* 写入消息队列的消息 */	
															sizeof(send_data1),	/* 写入消息队列的消息长度 */
															0);
			if (uwRet != LOS_OK) {
				printf("消息不能写入到消息队列！错误代码 0X%X\r\n",uwRet);
			}
		}
			
		LOS_TaskDelay(20);	
		}
	}
}

/******************************************************************
 * @ 函数名 ： Queue_Receive_Task
 * @ 功能说明： 创建 Queue_Rec25ve_Task 任务
 * @ 参数 ：	NULL
 * @ 返回值 ： NULL
 ******************************************************************/
static void Queue_Receive_Task(void) {
	/* 定义一个返回类型变量，初始化为 LOS_OK */
	UINT32 uwRet = LOS_OK;
	UINT32 r_queue;	//接收消息队列数据缓存区
	UINT32 buffsize = 20;	//接收消息队列节点大小
	while(1) {
		/* 消息队列读取，等待时间为一直等待模式 */
		uwRet = LOS_QueueRead(Test_Queue_Handle,		/* 消息队列的ID（句柄） */
													&r_queue,							/* 接收消息队列信息的保存缓存位置 */
													buffsize,							/* 接收消息队列节点大小 */
													LOS_WAIT_FOREVER);		/* 等待时间，一直等待 */
		if(LOS_OK == uwRet) {
			printf("接收到的消息队列消息是%s\r\n",(char *)r_queue);
		} else {
			printf("接收消息队列消息出错，错误代码%d\r\n",uwRet);
		}
	}
}

实验现象

在这里插入图片描述

邓家文007
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LiteOS消息队列
qq_52674444的博客
03-16 952
LiteOS消息队列介绍与使用
利用LiteOS-develop源码在野火STM32指南者移植LiteOS系统及NB组件.pdf
05-28
利用STM32指南者开发板以及STM32CubeMX（移植采用STM32HAL库）移植华为物联网操作系统LiteOS源码（华为官网LiteOS_develop源码）以及NB相关组件，之前移植走了很多坑，所以做了一个详细的笔记，从源码下载到移植测试均有详细步骤。
STM32队列
最新发布
weixin_49001476的博客
06-09 2106
队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、中断和任务间传递信息。为什么不使用全局变量？如果使用全局变量，兔子（任务1）修改了变量a，等待树獭（任务3）处理，但树獭处理速度很慢，在处理数据的过程中，狐狸（任务2）有可能又修改了变量a，导致树獭有可能得到的不是正确的数据。在这种情况下，就可以使用队列。兔子和狐狸产生的数据放在流水线上，树獭可以慢慢一个个依次处理。关于队列的几个名词：
基于STM32F103移植华为LiteOS物联网系统
xqhrs232的专栏
01-28 628
8、【LiteOS】LiteOS移植教程（STM32F103C8+MDK）----6、LiteOS 配置文件target_config.h文件详解----5、【LiteOS】HUAWEI LiteOS 详解----2、华为LiteOS操作系统基础知识入门与内核移植----3、STM32F401CCU6移植华为LiteOS----7、STM32在MDK中移植 LiteOS的问题----4、STM32 移植 LiteOS 过程----1、移植华为LiteOS----
stm32cubemx hal学习记录：FreeRTOS消息队列
ohhjack的博客
11-21 2979
stm32
STM32CubeMX——FREERTOS学习：消息队列Queue
m0_49968063的博客
03-28 2192
队列，也叫消息队列，就是把消息一条一条的排个队。 比如创建了一个消息队列，这个消息队列可以存10条消息。任务A可以往里存消息，任务B也可以往里存。这个存的消息是要讲先来后到的，存满了10条消息就不能存了。假设任务C从里面去消息，也是一条一条的取，按照先后顺序取，先存的先取，后存的后取。信息取一个，队列里面就少一个，取10个之后，消息队列就空了。 往队列里面存消息，如果队列已经满了，可以一直等着，直到队列里面有空位置，也可以等一会，没空位离开。 从队列里面取消息，如果队列已经空了，可以一直等着，直到队列
基于STM32F103移植华为LiteOS_任务挂起与恢复_面向对象编程思想之按键状态机
04-06
在本文中，我们将深入探讨如何基于STM32F103微控制器移植华为的轻量级操作系统LiteOS，并实现任务的挂起与恢复，以及利用面向对象编程思想设计按键状态机。华为LiteOS是一个专为物联网（IoT）设计的开源实时操作系统...
基于STM32F103单片机的liteos移植项目keil5
10-19
在本文中，我们将深入探讨如何将LiteOS操作系统移植到基于STM32F103的硬件平台上，并使用Keil uVision5作为开发环境。LiteOS是华为推出的一款轻量级实时操作系统，它专为物联网(IoT)设备设计，具有低功耗、高性能和...
stm32f103min移植liteos_重定向printf.zip
05-17
STM32F103MIN移植LiteOS及串口重定向详解 STM32F103系列是意法半导体（STMicroelectronics）推出的基于ARM Cortex-M3内核的微控制器，广泛应用于嵌入式系统设计。STM32F103MIN型号是该系列的一种，通常具有低功耗、...
基于STM32F103移植的华为LiteOS物联网系统
04-02
本项目是将华为LiteOS操作系统移植到STM32F103平台，以实现物联网系统的构建。移植过程中涉及的关键知识点包括： 1. **STM32F103硬件接口**：理解STM32F103的GPIO、UART、SPI、I2C等外设接口，这是驱动设备和与外部...
消息队列方式实现串口数据不定长接收 —- RT-thread&STM32
01-06
Life moves pretty fast. If you don’t stop and look around once in a while, you could miss it. 人生匆匆，若不偶尔停下来看看周围，便会错过许多风景。 一、串口数据不定长接收的实现 通常在裸机中，我们使用一个定时器来辅助串口实现串口数据不定长接收，也就是当串口接收数据时，定时器一直处于定时值（比如100ms）,接收不断的把数据放入缓冲区（通常可使用数组），当串口空闲时，定时器开始计时，当计时时间到，读取缓冲区的数据即可，这样就实现了数据的不定长接收。 而使用RTOS，可以使用消息队列来作为缓冲区，串口每次
华为LiteOS移植到STM32F103ZET6
11-23
在野火的标准库基础例程上，移植了 华为LiteOS。用的是野火STM32F103ZET6 核心板。已完成了移植，并启动了第一个 LED的任务。可以作为模版使用。
LiteOS移植示例程序ＳＴＭ３２Ｆ１０３.rar
06-08
华为LiteOS操作系统，移植到STM３２F１０３的示例程序（基于MDK环境）。liteOS的移植测试成功了。
STM32F103VEx_LiteOS_Demo.zip
03-03
STM32F103VEx_LiteOS_Demo.zip是一个包含STM32微控制器上LiteOS操作系统移植示例的压缩文件。这个项目的核心目标是将LiteOS操作系统成功移植到STM32F103VET6这款高性能的Cortex-M3内核微控制器上，并在移植完成后...
STM32移植工程教程 包括解决Keil 一些常见的错误等等
m0_66506772的博客
04-07 4045
然后打开Keil 在左边的能看到即说明添加成功 出现如图则说明添加成功编译一下，把多余的头文件删去 有6个错误 我们一般从第一个错误开始看 这里的错误 是TIM定时器的结构体没定义，但其实这些在工程里面的库函数这些都已经包含了这时候，找到stm32f10x_conf.h打开，可以看到stm32f10x_tim.h被注释掉了，这就是导致编译错误的原因，只需要删掉注释 重新编译一下即可 重新编译一下 错误就没有了有时候 会遇到引脚冲突，解决方法一修改文件里面的宏定义 更换为别的引脚解决方法二使用重定义功能
LiteOS移植到STM32F1系列芯片的keil工程
SHADOWPIGGG的博客
09-18 781
LiteOS移植到STM32F1系列芯片的keil工程 STM32F103ZE： https://liteos.github.io/porting/stm32-keil.html#%E7%BC%96%E8%AF%91%E5%B9%B6%E9%AA%8C%E8%AF%81%E8%A3%B8%E6%9C%BA%E5%B7%A5%E7%A8%8B STM32F103C8： https://blog.csdn.net/llb19900510/article/details/101642957 特别注意源码下载一定要
STM32使用大彩串口屏程序框架使用总结
Bruce.yang的嵌入式之旅
04-29 8827
大彩科技是专注做串口屏的厂家，网址如下： http://www.gz-dc.com/ 指令格式如下： 一般情况下，采用的是CRC格式校验的指令。 处理指令方面，大彩提供了一个例程，主要用一个队列来维护。 数据结构: #define QUEUE_MAX_SIZE 128 /*!< 指令接收缓冲区大小，根据需要调整，尽量设置大一些*/ typedefstruct_...
STM32移植Huawei LiteOS详细教程
本教程专注于将华为LiteOS操作系统移植到STM32微控制器上，STM32是一款基于ARM Cortex-M系列处理器的广泛应用的微控制器。 1. 开源协议说明 华为LiteOS可能遵循特定的开源协议，例如Apache License 2.0或者GPLv2，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

邓家文007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值