基于STM32F103移植华为LiteOS_任务挂起与恢复_面向对象编程思想之按键状态机

已于 2022-04-06 01:20:12 修改
阅读量3.3k 收藏
点赞数 3
分类专栏： 华为LiteOS 文章标签： 物联网 嵌入式 华为
于 2022-04-06 00:23:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/morecrazylove/article/details/123978066
版权

华为LiteOS_任务挂起与恢复_面向对象编程思想之按键状态机

       因为在做华为LiteOS任务挂起和恢复需要使用到按键去触发任务挂起和恢复动作，因为我就萌发出使用状态机这种架构做一个按键检测触发。回想已经也做过按键状态机，不过因为那时候是在裸机上做的按键状态机，比较简单，只有按下和释放功能，而且是单个按键检测的。
       这里我借此实验机会使用面向对象的编程思想设计一个可按用户按键个数的按键状态机。面向对象思想可以是驱动程序适合在多种平台快速移植开发，可读性高。
       状态机是一个抽象概念，表示把一个过程抽象为若干个状态之间的切换，这些状态之间存在一定的联系。状态机的设计主要包括4个要素：
①现态：是指当前所处的状态。
②条件：当一个条件满足，将会触发一个动作，或者执行一次状态的迁移。
③动作：表示条件满足后执行动作。动作执行完毕后，可以迁移到新的状态，也可以仍旧保持原状态。动作要素不是必需的，当条件满足后，也可以不执行任何动作，直接迁移到新状态。
④次态：表示条件满足后要迁往的新状态。
       从上面解释可以清晰地知道，保存当前状态，判断条件是否满足，设置相应的动作标志（这是用于实际的事件触发的），然后将当前状态通过上面的条件判断设置到相应的下一个状态。
在这里插入图片描述
       这里我还提供了程序框图让大家参考，应该能解决大家对“有按键状态了，为什么还需要按键事件”这个问题，其实就是按键状态状态机循环扫描按键状态的根本，而按键事件时在按键状态中触发的动作。（按键实际状态只有：初始未按下态、按下态、长按态、释放态）
在这里插入图片描述

       LiteOS 系统中的每一个任务都有多种运行状态，它们之间的转换称为任务状态迁移。如下图所示。
在这里插入图片描述
这里亮代码让大家理解了。
key.h

#ifndef __KEY_H
#define __KEY_H

#include "stm32f10x.h"
#include "usart1.h"

#define	KEY_UP_GPIO_CLK   RCC_APB2Periph_GPIOA
#define KEY_UP_GPIO_PORT  GPIOA			   
#define KEY_UP_GPIO_PIN		GPIO_Pin_0

#define KEY0_GPIO_CLK			RCC_APB2Periph_GPIOE
#define KEY0_GPIO_PORT		GPIOE
#define KEY0_GPIO_PIN			GPIO_Pin_4

#define KEY1_GPIO_CLK			RCC_APB2Periph_GPIOE
#define KEY1_GPIO_PORT		GPIOE
#define KEY1_GPIO_PIN			GPIO_Pin_3

#define KEY2_GPIO_CLK			RCC_APB2Periph_GPIOE
#define KEY2_GPIO_PORT		GPIOE
#define KEY2_GPIO_PIN			GPIO_Pin_2

/* 按键状态 */
typedef enum {
	KEY_NULL = 0,						//初始空状态
	KEY_WAIT_CONFIRM_DOWN,	//等待确认按下状态
	KEY_CONFIRN_DOWN,				//确认按下状态
	KEY_LONG_DOWN,					//长按状态
	KEY_UP,									//抬起状态
}Key_State_List;

/* 按键类，此处添加按键 */
typedef enum {
	KEYUP = 0,		//key_up按键
	KEY0,					//Key0按键
	KEY1,					//Key1按键
	KEY2,					//Key2按键
	KEY_CLASS_NUM,//按键类个数，即多少个按键
}Key_Class;

/* 按键外设初始化结构体,移植可修改，不同单片机配置外设参数不一样 */
typedef struct {
	uint32_t RCC_APB2Periph_GPIOx;	//时钟
	GPIO_TypeDef* GPIOx;						//端口
	uint16_t GPIO_Pin_x;						//引脚
	GPIOMode_TypeDef GPIO_Mode;			//模式
}Key_Init;

/* 状态机初始化结构体，移植可修改函数指针，不同单片机读取函数不一样 */
typedef struct {
	FunctionalState Key_Use_State;			//按键使用状态，使能还是失能
	BitAction Key_Press_Level;					//表示按键按下,与实际的按下电平对应的
	BitAction	Key_Current_Level;				//表示按键标志，1表示按下，0表示松开
	uint8_t Key_Count;									//按键长按的时间
	Key_State_List Key_State;						//用于状态机按键状态切换的
	Key_State_List Key_Event;						//按键触发事件，用于外部按键判断是否按下，是长按还是短按
	BitAction (* Read_Pin_Level)(Key_Init KeyInit);	//函数指针，用于读取对应按键IO的输入电平
}Key_State_Machine;

/* 按键结构体，类 */
typedef struct {
	Key_Init Key_Init;										//按键外设初始化
	Key_State_Machine Key_State_Machine;	//按键状态机初始化
}Key_Config;


/* 定义长按时间 (47+3)T=按下的时间,T=20ms,Time=1S，移植可修改，根据个数要求定义长按的时间长度*/
#define Key_Long_Pree_Time 47

extern Key_Config	KEY_CLASS[KEY_CLASS_NUM];

void Key_Config_parameter(void);
void Read_Key_State(void);

#endif

key.c

#include "key.h"

/* 定义按键,便于添加按键 */
Key_Config	KEY_CLASS[KEY_CLASS_NUM];

/* 读按键对应IO电平函数，移植可修改读取电平函数 */
static BitAction Key_Read_Pin_Level(Key_Init KeyInit) {
	return (BitAction)GPIO_ReadInputDataBit(KeyInit.GPIOx,KeyInit.GPIO_Pin_x);
}

/* 创建按键，即初始化外设和状态机,Key_State_Machine* Key_State_Machine */
void Creat_Key(Key_Init* KeyInit) {
	uint8_t i;								//用于逐个对按键状态机结构体赋值
	GPIO_InitTypeDef GPIO_InitStructure;
	
	for(i=0;i<KEY_CLASS_NUM;i++) {
		/*将配置好的Key_Init结构体参数赋予Key_Config结构体定义好的按键类对应的Key_Init结构体参数*/
		KEY_CLASS[i].Key_Init = *(KeyInit+i);	
		
		/* 按键初始化结构体复制初始化，移植可修改 */
		RCC_APB2PeriphClockCmd(KEY_CLASS[i].Key_Init.RCC_APB2Periph_GPIOx,ENABLE);		//时钟使能
		GPIO_InitStructure.GPIO_Pin = KEY_CLASS[i].Key_Init.GPIO_Pin_x;								//IO引脚
		GPIO_InitStructure.GPIO_Mode = KEY_CLASS[i].Key_Init.GPIO_Mode;								//IO模式
		GPIO_Init(KEY_CLASS[i].Key_Init.GPIOx,&GPIO_InitStructure);										//初始化IO

		/* KEYUP按键结构体中Key_State_Machine结构体赋值 */
		KEY_CLASS[i].Key_State_Machine.Key_Use_State = ENABLE;	//使能改按键
		KEY_CLASS[i].Key_State_Machine.Key_Count = 0;					//长按次数初始化为0
		KEY_CLASS[i].Key_State_Machine.Key_Current_Level = Bit_RESET; 		//初始化按键，为松开状态
		KEY_CLASS[i].Key_State_Machine.Key_State = KEY_NULL;	//当前按键状态为未按下状态，也就是初始状态
		KEY_CLASS[i].Key_State_Machine.Read_Pin_Level = Key_Read_Pin_Level;		//将函数指针实例化，指向定义的读IO电平函数
		/* 判断输入模式，移植可修改，不同的单片机库的输入模式不一样，这里是下拉输入和上拉输入 */
		if(KEY_CLASS[i].Key_Init.GPIO_Mode == GPIO_Mode_IPD) {	
			KEY_CLASS[i].Key_State_Machine.Key_Press_Level = Bit_SET;				//设置按键按下的实际电平为高电平
		} else {
			KEY_CLASS[i].Key_State_Machine.Key_Press_Level = Bit_RESET;	
		}		
	}
}

/* 按键配置并初始化 */
void Key_Config_parameter(void) {
	/* 配置按键外设参数，移植可修改 */
	Key_Init KeyInit[KEY_CLASS_NUM] = {
		{KEY_UP_GPIO_CLK,KEY_UP_GPIO_PORT,KEY_UP_GPIO_PIN,GPIO_Mode_IPD},
		{KEY0_GPIO_CLK,KEY0_GPIO_PORT,KEY0_GPIO_PIN,GPIO_Mode_IPU},
		{KEY1_GPIO_CLK,KEY1_GPIO_PORT,KEY1_GPIO_PIN,GPIO_Mode_IPU},
		{KEY2_GPIO_CLK,KEY2_GPIO_PORT,KEY2_GPIO_PIN,GPIO_Mode_IPU},
	};
	
	/* 创建并实例化按键类 */
	Creat_Key(KeyInit);
}

/* 获取按键值 */
static void Get_Key_Level(void)
{
	uint8_t i;
	for(i=0;i<KEY_CLASS_NUM;i++) {
		/* 判断按键是否使能，如果失能就判断下一个按键 */
		if(KEY_CLASS[i].Key_State_Machine.Key_Use_State==DISABLE) {
			continue;		//下一次循环
		}
		/* 读取当前按键IO的输入电平是否与该按键按下状态的电平一样 */
		if(KEY_CLASS[i].Key_State_Machine.Read_Pin_Level(KEY_CLASS[i].Key_Init)==KEY_CLASS[i].Key_State_Machine.Key_Press_Level) {
			KEY_CLASS[i].Key_State_Machine.Key_Current_Level = Bit_SET;		//设置当前为按下状态
		} else {
			KEY_CLASS[i].Key_State_Machine.Key_Current_Level = Bit_RESET;
		}
	}
}

/* 读取按键的状态，状态机的4个要素：现态、条件、动作、次态 */
void Read_Key_State(void) {
	uint8_t i;
	Get_Key_Level();	//获取当前按键值
	for(i=0;i<KEY_CLASS_NUM;i++) {
		switch(KEY_CLASS[i].Key_State_Machine.Key_State) {
		/* 状态0：KEY_NULL按键初始状态，空状态，未按下状态 */
			case KEY_NULL:
				if(KEY_CLASS[i].Key_State_Machine.Key_Current_Level==Bit_SET) {	//有按键按下
					/* 将按键状态进入下一个按键等待确认按下状态 */
					KEY_CLASS[i].Key_State_Machine.Key_State = KEY_WAIT_CONFIRM_DOWN;
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_NULL;	//空事件触发
				} else {
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_NULL;	//空事件触发
				}
				break;
			/* 第二次扫描，判断按键进入按键等待确认按下状态 */
			case KEY_WAIT_CONFIRM_DOWN:
				/* 再次判断按键是否按下，起到消抖作用 */
				if(KEY_CLASS[i].Key_State_Machine.Key_Current_Level==Bit_SET) {
					/* 按键进入按键确认按键状态 */
					KEY_CLASS[i].Key_State_Machine.Key_State = KEY_CONFIRN_DOWN;
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_CONFIRN_DOWN;	//按键按下触发
					KEY_CLASS[i].Key_State_Machine.Key_Count = 0;	//按键计数清零，为下面判断是否为长按做准备
				} else {
					/* 假按下，所有按键没有按下 */
					KEY_CLASS[i].Key_State_Machine.Key_State = KEY_NULL;
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_NULL;
				}
				break;
			/* 第三次扫描，按键按下，是否是长按还是短按 */
			case KEY_CONFIRN_DOWN:
				/* 如果按键在第三次扫描中判断出按键没有按下，说明是短按，按键已经释放 */
				if(KEY_CLASS[i].Key_State_Machine.Key_Current_Level!=Bit_SET) {
					KEY_CLASS[i].Key_State_Machine.Key_State = KEY_NULL;	//按键释放了，进入最开始状态
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_UP;		//按键释放状态
					/* 判断按键仍然按下，并且按下是时间达到长按时间要求 */
				} else if((KEY_CLASS[i].Key_State_Machine.Key_Current_Level==Bit_SET) && (++KEY_CLASS[i].Key_State_Machine.Key_Count>=Key_Long_Pree_Time)){
					KEY_CLASS[i].Key_State_Machine.Key_State = KEY_LONG_DOWN;	//按键为长按状态
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_LONG_DOWN;	//触发按键长按事件
					KEY_CLASS[i].Key_State_Machine.Key_Count = 0;	//按键计数清零，记录长按的了多少个扫描周期，即为按键触发了多少次按下事件
				} else {
					/* 按下状态但未达到长按状态 */
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_NULL;	//按键不触发事件
				}
				break;
			/* 第四次扫描，进入长按状态，需要计算按下长按的周期个数 */
			case KEY_LONG_DOWN:
				/* 如果按键进入长按状态，但是进入后此状态很快就释放了 */
				if(KEY_CLASS[i].Key_State_Machine.Key_Current_Level!=Bit_SET) {
					KEY_CLASS[i].Key_State_Machine.Key_State = KEY_NULL;	//按键为达成长按计算目的，重新回对初始状态
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_UP;		//按键按下后触发按键释放事件
					/* 如果按键仍然在按下，那么就记录长按了多少个扫描周期，即连续按了多少下 */
				} else if(KEY_CLASS[i].Key_State_Machine.Key_Current_Level==Bit_SET) {
					KEY_CLASS[i].Key_State_Machine.Key_Event = KEY_LONG_DOWN;	//仍然处于长按触发事件
					++KEY_CLASS[i].Key_State_Machine.Key_Count;		//累加按键按下扫描周期个数
				}
				break;
			default:
				break;
		}
	}
}

main.c

#include "stm32f10x.h"
#include "los_sys.h "
#include "los_typedef.h"
#include "los_task.ph"

#include "led.h"
#include "usart1.h"
#include "key.h"

/* 定义任务 ID 变量 */
UINT32 Test1_Task_Handle;
UINT32 Test2_Task_Handle;
UINT32 Key_Task_Handle;


/* 函数声明 */
static UINT32 AppTaskCreate(void);		//用于创建任务管理
static UINT32 Creat_Test1_Task(void);	//创建任务1函数
static UINT32 Creat_Test2_Task(void);	//创建任务2函数
static UINT32 Creat_Key_Task(void);		//创建任务3函数

static void Test1_Task(void);					//任务1函数
static void Test2_Task(void);					//任务2函数
static void Key_Task(void);						//任务3函数

int main(void)
{	
	UINT32 uwRet = LOS_OK; //定义一个任务创建的返回值，默认为创建成功
	
	/*中断优先级分组为 4*/
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
	/* 板载相关初始化 */
	Usart1_Config();
	LED_GPIO_Config();
	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){	//上面任务失败会进入此
		GPIO_SetBits(GPIOB, GPIO_Pin_5);
		GPIO_SetBits(GPIOE,GPIO_Pin_5);
	}
}



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

	uwRet = Creat_Test1_Task();
	if (uwRet != LOS_OK) {
		printf("Test1_Task任务创建失败！失败代码0X%X\r\n",uwRet);
		return uwRet;
	}
	
	uwRet = Creat_Test2_Task();
	if (uwRet != LOS_OK) {
		printf("Test2_Task任务创建失败！失败代码0X%X\r\n",uwRet);
		return uwRet;
	}
	
	uwRet = Creat_Key_Task();
	if (uwRet != LOS_OK) {
		printf("Key_Task 任务创建失败！失败代码0X%X\r\n",uwRet);
		return uwRet;
	}
	return LOS_OK;
}

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

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

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

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

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

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

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

	task_init_param.usTaskPrio = 3; /* 任务优先级，数值越小，优先级越高 */
	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;	
}

/******************************************************************
 * @ 函数名 ： Test1_Task
 * @ 功能说明： Test1_Task 任务实现
 * @ 参数 ： NULL
 * @ 返回值 ： NULL
 *****************************************************************/
static void Test1_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);
	}
}

/******************************************************************
 * @ 函数名 ： Test2_Task
 * @ 功能说明： Test2_Task 任务实现
 * @ 参数 ： NULL
 * @ 返回值 ： NULL
 *****************************************************************/
static void Test2_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_Test2_Task 任务！\r\n");
				uwRet = LOS_TaskSuspend(Test2_Task_Handle);
				if (uwRet == LOS_OK) {
					printf("挂起LED_Test2_Task 任务成功！\r\n");
				}
			}
			
			if((trigger_state==KEY_CONFIRN_DOWN) && (i==KEY0)) {
				printf("恢复 LED_Test2_Task 任务！\r\n");
				uwRet = LOS_TaskResume(Test2_Task_Handle);
				if (uwRet == LOS_OK) {
						printf("恢复 LED_Test2_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;
			}
		}
		LOS_TaskDelay(20);	
	}
}

实验现象如下图所示。
在这里插入图片描述
小编能力有限，希望大家多多体谅，大家一起相互学习探讨。
工程文件包：华为LiteOS任务挂起和恢复及按键状态机

邓家文007
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LiteOS移植示例程序ＳＴＭ３２Ｆ１０３.rar
06-08
华为LiteOS操作系统，移植到STM３２F１０３的示例程序（基于MDK环境）。liteOS的移植测试成功了。
状态机-面向对象编程
Paper_Love的博客
01-14 276
状态机-面向对象编程 #include "stdio.h" //状态 typedef struct State { const struct State *(* const state_press)(const struct State *pThis); const struct State *(* const state_release)(const struct State *pThis); } State; //事件--改变状态 void initialize(void); voi
[007] [STM32] 以面向对象的思想编写按键程序
柯西的彷徨的博客
02-19 2401
CubeMX配置 RCC：配置HSE为晶体/陶瓷谐振器 SYS：Debug选择SW模式 时钟：选择HSE作为PLL时钟源，将其改为8MHz（默认），然后选择PLLCLK作为系统时钟源，设为系统时钟为72MHz 按键引脚：PA0（wk_up）下拉输入，PA15（key1）和PC5（key0）上拉输入 LED引脚：PA8（红灯）和PD2（黄灯）设为推挽输出，默认输出高电平 TIM6：向上计数模式（TIM6&7只支持向上计数），psc = 72 - 1，arr = 1000 - 1，即1ms更新中断，
软件编程思想 ：状态机 面向对象的编程思想 模块化编程思想
dianqicyuyan的博客
09-23 222
浪里个浪
华为LiteOS移植到STM32F103ZET6
11-23
在野火的标准库基础例程上，移植了 华为LiteOS。用的是野火STM32F103ZET6 核心板。已完成了移植，并启动了第一个 LED的任务。可以作为模版使用。
stm32f103min移植liteos_重定向printf.zip
05-17
STM32F103MIN移植LiteOS及串口重定向详解 STM32F103系列是意法半导体（STMicroelectronics）推出的基于ARM Cortex-M3内核的微控制器，广泛应用于嵌入式系统设计。STM32F103MIN型号是该系列的一种，通常具有低功耗、...
基于STM32F103单片机的liteos移植项目keil5
10-19
在本文中，我们将深入探讨如何将LiteOS操作系统移植到基于STM32F103的硬件平台上，并使用Keil uVision5作为开发环境。LiteOS是华为推出的一款轻量级实时操作系统，它专为物联网(IoT)设备设计，具有低功耗、高性能和...
基于STM32F103移植的华为LiteOS物联网系统
04-02
本项目是将华为LiteOS操作系统移植到STM32F103平台，以实现物联网系统的构建。移植过程中涉及的关键知识点包括： 1. **STM32F103硬件接口**：理解STM32F103的GPIO、UART、SPI、I2C等外设接口，这是驱动设备和与外部...
STM32F103VEx_LiteOS_Demo.zip
03-03
STM32F103VEx_LiteOS_Demo.zip是一个包含STM32微控制器上LiteOS操作系统移植示例的压缩文件。这个项目的核心目标是将LiteOS操作系统成功移植到STM32F103VET6这款高性能的Cortex-M3内核微控制器上，并在移植完成后...
移植LiteOS到STM32
12-15
华为LiteOS移植程序，LiteOS移植到STM32F103R8T6，已成功
基于鸿蒙LiteOS实现 按键驱动 ，中断和循环读取两种实现方式
11-06
网文教程参考 ： https://mp.weixin.qq.com/s/Ddb4h6EnlYI5yn45_qIQSA ，微信搜索：嵌入式从0到1，更多干货等着你
Huawei_LiteOS_STM32移植教程
11-23
Huawei_LiteOS_STM32移植教程Huawei_LiteOS_STM32移植教程Huawei_LiteOS_STM32移植教程
Huawei LiteOS_STM32_DEMO
01-30
基于STM32F103移植的Huawei LiteOS系统，删除了不用的部分，修改了配置，该Demo可实现最简单的两任务，效果为2个LED灯交替闪烁。
STM32F103移植LiteOS保姆级教程（基于Ubuntu平台）
weixin_43930521的博客
04-30 1134
嵌入式软件常用linux系统进行开发，LiteOS于linux平台上的移植相比win的移植简单许多，本文基于Ubuntu平台对STM32F103的LiteOS移植教程进行详细讲解。
STM32F103移植LiteOS保姆级教程（基于Huawei-LiteOS-studio）
weixin_43930521的博客
04-30 5424
开始按照官方教程进行安装和配置发现会有一些问题，经过不断尝试终于可以在huawei-liteos-studio下编译移植成功。以下为STM32f103ZE移植LiteOS详细的完整教程。
基于STM32F103移植华为LiteOS物联网系统
morecrazylove的博客
04-02 5158
基于STM32F103移植华为LieOS物联网系统
【LiteOS】13-移植-按键
qq_44772822的博客
06-02 332
此笔记由个人整理 华为IOT LiteOS开发实战营 第七天 一、控制移植 定义变量（在数据上报时使用） uint8_t Light_state; uint8_t Motor_state; 按键一 代码 //按键1任务 void Key1_task_entry() { if (Light_state == 0) { //此处灯控制开 HAL_GPIO_WritePin(IA1_Light_GPIO_Port, IA1_Light_Pin, GPIO_.
STM32F103移植LiteOS之跑马灯实验
weixin_43930521的博客
05-07 2959
相关文章： STM32F103移植LiteOS保姆级教程（基于Huawei-LiteOS-studio） STM32F103移植LiteOS保姆级教程（基于Ubuntu平台） 在编译通过且能成功烧录的工程基础上，对工程目录进行查看。 无任何修改移植时可以发现灯会闪烁，而其中相关的控制代码则在targets->STM32F103_FIRE_Arbitrary的src当中。 启用studio创建的工程项目里面的stm32函数是采用HAL库进行编程，其中gpio.c文件对led的gpio进行初始化，use
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、付费专栏及课程。

余额充值