单片机按键FIFO

最新推荐文章于 2024-05-23 20:19:01 发布
最新推荐文章于 2024-05-23 20:19:01 发布
阅读量6.9k 收藏 42
点赞数 9
分类专栏： 嵌入式 文章标签： 单片机 嵌入式 按键事件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42378319/article/details/106411256
版权

本文代码参考安富莱按键FIFO

FIFO数据结构如果不清楚可以参考博文简单的FIFO

一般的单片机系统，按键作为人机交互工具是必不可少的，但是普通的按键需要消抖处理，极大的增加了程序开销，降低系统实时性。

安富莱的FIFO按键，无需延时处理消抖，可以记录按键按下、弹起、长按、组合按，并且移植起来也十分方便。之前在做一个项目时，用到一个矩阵键盘，移植了这个按键FIFO程序，用起来效果很不错。

主要流程就是开启一个10ms的定时器中断，在中断中扫描按键状态，并对按键状态进行分析消抖处理，如果按键动作，将按键动作压入FIFO中，在主循环中读取FIFO，获取按键状态。
在这里插入图片描述

使用时首先要调用初始化函数，此函数有两个子函数，分别完成变量初始化和板子硬件初始化。

/*
*********************************************************************************************************
*	函 数 名: bsp_InitKey
*	功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
void bsp_InitKey(void)
{
	bsp_InitKeyVar();		/* 初始化按键变量 */
	bsp_InitKeyHard();		/* 初始化按键硬件 */
}

移植时需要注意对应IO硬件初始化修改成自己的，这里使用的STC8A单片机，3*4矩阵键盘，使用的IO通过宏定义封装起来。
在这里插入图片描述


/* 矩阵键盘 */
#define C1_PIN             1
#define C1_GPIO_PORT       2

#define C2_PIN             2
#define C2_GPIO_PORT       2

#define C3_PIN             3
#define C3_GPIO_PORT       2

#define C4_PIN             4
#define C4_GPIO_PORT       2

 
// Row1, Row2, Row3, Row4
#define R1_PIN             1
#define R1_GPIO_PORT       4

#define R2_PIN             0
#define R2_GPIO_PORT       2

#define R3_PIN             2
#define R3_GPIO_PORT       4


/*
*********************************************************************************************************
*	函 数 名: bsp_InitKeyHard
*	功能说明: 配置按键对应的GPIO
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
static void bsp_InitKeyHard(void)
{
	//KEY 初始化
    PIN_InitPushPull(C1_GPIO_PORT, C1_PIN);
	PIN_InitPushPull(C2_GPIO_PORT, C2_PIN);
	PIN_InitPushPull(C3_GPIO_PORT, C3_PIN);
	PIN_InitPushPull(C4_GPIO_PORT, C4_PIN);
	PIN_InitOpenDrain(R1_GPIO_PORT, R1_PIN);
	PIN_InitOpenDrain(R2_GPIO_PORT, R2_PIN);
	PIN_InitOpenDrain(R3_GPIO_PORT, R3_PIN);
	
}

按键参数初始化需要注意设置连发速度来确定对应按键是否支持连按。还要自行修改判断按键按下函数和按键个数

/*
	按键滤波时间50ms, 单位10ms。
	只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
	即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
*/
#define KEY_FILTER_TIME   5
#define KEY_LONG_TIME     100		     	/* 单位10ms， 持续1秒，认为长按事件 */
#define KEY_COUNT    13	   					/* 按键个数, 12个独立建 + 1 个组合键 */
static KEY_T xdata s_tBtn[KEY_COUNT];
static KEY_FIFO_T xdata s_tKey;		/* 按键FIFO变量,结构体 */

/* 检测按键按下函数 */
static uint8_t IsKeyDown0(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 0; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown1(void)  {P(C1_GPIO_PORT, C1_PIN) = 0;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; NOP(50); if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown2(void)  {P(C1_GPIO_PORT, C1_PIN) = 0;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown3(void)  {P(C1_GPIO_PORT, C1_PIN) = 0;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown4(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 0;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown5(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 0;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown6(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 0;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown7(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 0; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown8(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 0; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown9(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 0; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown10(void) {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 0; NOP(50); if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown11(void) {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 0; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}

/* 组合按键 key1 && key2 */
static uint8_t IsKeyDown12(void)  { return IsKeyDown1() && IsKeyDown2();}
/*
*********************************************************************************************************
*	函 数 名: bsp_InitKeyVar
*	功能说明: 初始化按键变量
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
static void bsp_InitKeyVar(void)
{
	uint8_t xdata i;

	/* 对按键FIFO读写指针清零 */
	fifo_init(&s_tKey);
	
	/* 给每个按键结构体成员变量赋一组缺省值 */
	for (i = 0; i < KEY_COUNT; i++)
	{
		s_tBtn[i].LongTime = KEY_LONG_TIME;			/* 长按时间 0 表示不检测长按键事件 */
		s_tBtn[i].Count = KEY_FILTER_TIME / 2;		/* 计数器设置为滤波时间的一半 */
		s_tBtn[i].State = 0;							/* 按键缺省状态，0为未按下 */
		//s_tBtn[i].KeyCodeDown = 3 * i + 1;				/* 按键按下的键值代码 */
		//s_tBtn[i].KeyCodeUp   = 3 * i + 2;				/* 按键弹起的键值代码 */
		//s_tBtn[i].KeyCodeLong = 3 * i + 3;				/* 按键被持续按下的键值代码 */
		s_tBtn[i].RepeatSpeed = 0;						/* 按键连发的速度，0表示不支持连发 */
		s_tBtn[i].RepeatCount = 0;						/* 连发计数器 */
	}


	/* 判断按键按下的函数 */
	s_tBtn[0].IsKeyDownFunc = IsKeyDown0;
	s_tBtn[1].IsKeyDownFunc = IsKeyDown1;
	s_tBtn[2].IsKeyDownFunc = IsKeyDown2;
	s_tBtn[3].IsKeyDownFunc = IsKeyDown3;
	s_tBtn[4].IsKeyDownFunc = IsKeyDown4;
	s_tBtn[5].IsKeyDownFunc = IsKeyDown5;
	s_tBtn[6].IsKeyDownFunc = IsKeyDown6;
	s_tBtn[7].IsKeyDownFunc = IsKeyDown7;
	s_tBtn[8].IsKeyDownFunc = IsKeyDown8;
	s_tBtn[9].IsKeyDownFunc = IsKeyDown9;
	s_tBtn[10].IsKeyDownFunc = IsKeyDown10;
	s_tBtn[11].IsKeyDownFunc = IsKeyDown11;
	
	/* 组合按键 */
	s_tBtn[12].IsKeyDownFunc = IsKeyDown12;
}

按键扫描函数，需要开启一个10ms的定时器中断，在中断中对按键状态进行扫描。


/*
*********************************************************************************************************
*	函 数 名: bsp_DetectKey
*	功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*	形    参:  按键结构变量指针
*	返 回 值: 无
*********************************************************************************************************
*/
static void bsp_DetectKey(uint8_t i)
{
	KEY_T xdata *pBtn;

	/*
		如果没有初始化按键函数，则报错
		if (s_tBtn[i].IsKeyDownFunc == 0)
		{
			printf("Fault : DetectButton(), s_tBtn[i].IsKeyDownFunc undefine");
		}
	*/

	pBtn = &s_tBtn[i];
	if (pBtn->IsKeyDownFunc())
	{
		if (pBtn->Count < KEY_FILTER_TIME)
		{
			pBtn->Count = KEY_FILTER_TIME;
		}
		else if(pBtn->Count < 2 * KEY_FILTER_TIME)
		{
			pBtn->Count++;
		}
		else
		{
			if (pBtn->State == 0)
			{
				pBtn->State = 1;

				/* 发送按钮按下的消息 */
				bsp_PutKey((uint8_t)(3 * i + 1));
			}

			if (pBtn->LongTime > 0)
			{
				if (pBtn->LongCount < pBtn->LongTime)
				{
					/* 发送按钮持续按下的消息 */
					if (++pBtn->LongCount == pBtn->LongTime)
					{
						/* 键值放入按键FIFO */
						bsp_PutKey((uint8_t)(3 * i + 3));
					}
				}
				else
				{
					if (pBtn->RepeatSpeed > 0)
					{
						if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
						{
							pBtn->RepeatCount = 0;
							/* 常按键后，每隔10ms发送1个按键 */
							bsp_PutKey((uint8_t)(3 * i + 1));
						}
					}
				}
			}
		}
	}
	else
	{
		if(pBtn->Count > KEY_FILTER_TIME)
		{
			pBtn->Count = KEY_FILTER_TIME;
		}
		else if(pBtn->Count != 0)
		{
			pBtn->Count--;
		}
		else
		{
			if (pBtn->State == 1)
			{
				pBtn->State = 0;

				/* 发送按钮弹起的消息 */
				bsp_PutKey((uint8_t)(3 * i + 2));
			}
		}

		pBtn->LongCount = 0;
		pBtn->RepeatCount = 0;
	}
}
/*
*********************************************************************************************************
*	函 数 名: bsp_KeyScan
*	功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
void bsp_KeyScan(void)
{
	uint8_t xdata i;

	for (i = 0; i < KEY_COUNT; i++)
	{
		bsp_DetectKey(i);
	}
}

在主函数中，非堵塞方式获取按键键值

/*
*********************************************************************************************************
*	函 数 名: bsp_GetKey
*	功能说明: 从按键FIFO缓冲区读取一个键值。
*	形    参:  无
*	返 回 值: 按键代码
*********************************************************************************************************
*/
uint8_t bsp_GetKey(void)
{
	uint8_t xdata ret;

	if (fifo_pop(&s_tKey, &ret) == 1)
	{
		return KEY_NONE;
	}
	else
	{
		return ret;
	}
}

完整代码如下
bsp_key.h

/*!
  * @file     BSP_KEY.h
  *
  * @brief    按键驱动文件
  *
  * @company  
  *
  * @author   不咸不要钱
  *
  * @note     无
  *
  * @version  
  *
  * @date     2019/10/18 星期五
  */ 
#ifndef __LQ_KEY_H
#define __LQ_KEY_H

#include "LQ_GPIO.h"



/* 矩阵键盘 */
#define C1_PIN             1
#define C1_GPIO_PORT       2

#define C2_PIN             2
#define C2_GPIO_PORT       2

#define C3_PIN             3
#define C3_GPIO_PORT       2

#define C4_PIN             4
#define C4_GPIO_PORT       2

 
// Row1, Row2, Row3, Row4
#define R1_PIN             1
#define R1_GPIO_PORT       4

#define R2_PIN             0
#define R2_GPIO_PORT       2

#define R3_PIN             2
#define R3_GPIO_PORT       4




#define KEY_COUNT    13	   					/* 按键个数, 12个独立建 + 1 个组合键 */



/* 按键ID, 主要用于bsp_KeyState()函数的入口参数 */
typedef enum
{
	KID_K0,
	KID_K1, 
	KID_K2,
	KID_K3,
	KID_K4,
	KID_K5,
	KID_K6,
	KID_K7,
	KID_K8,
	KID_K9,
	KID_K10,
	KID_K11,
	KID_K12,
	
}KEY_ID_E;

/*
	按键滤波时间50ms, 单位10ms。
	只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
	即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
*/
#define KEY_FILTER_TIME   5
#define KEY_LONG_TIME     100			/* 单位10ms， 持续1秒，认为长按事件 */

/*
	每个按键对应1个全局的结构体变量。
*/
typedef struct
{
	/* 下面是一个函数指针，指向判断按键手否按下的函数 */
	uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */

	uint8_t  Count;			/* 滤波器计数器 */
	uint16_t LongCount;		/* 长按计数器 */
	uint16_t LongTime;		/* 按键按下持续时间, 0表示不检测长按 */
	uint8_t  State;			/* 按键当前状态（按下还是弹起） */
	uint8_t  RepeatSpeed;	/* 连续按键周期 */
	uint8_t  RepeatCount;	/* 连续按键计数器 */
}KEY_T;

/*
	定义键值代码, 必须按如下次序定时每个键的按下、弹起和长按事件

	推荐使用enum, 不用#define，原因：
	(1) 便于新增键值,方便调整顺序，使代码看起来舒服点
	(2) 编译器可帮我们避免键值重复。
*/
typedef enum
{
	KEY_NONE = 0,			/* 0 表示按键事件 */

	KEY_0_DOWN,			    /* 0键按下 */
	KEY_0_UP,				/* 0键弹起 */
	KEY_0_LONG,			    /* 0键长按 */
	
	KEY_1_DOWN,				/* 1键按下 */
	KEY_1_UP,				/* 1键弹起 */
	KEY_1_LONG,				/* 1键长按 */

	KEY_2_DOWN,				/* 2键按下 */
	KEY_2_UP,				/* 2键弹起 */
	KEY_2_LONG,				/* 2键长按 */

	KEY_3_DOWN,				/* 3键按下 */
	KEY_3_UP,				/* 3键弹起 */
	KEY_3_LONG,				/* 3键长按 */

	KEY_4_DOWN,				/* 4键按下 */
	KEY_4_UP,				/* 4键弹起 */
	KEY_4_LONG,				/* 4键长按 */

	KEY_5_DOWN,				/* 5键按下 */
	KEY_5_UP,				/* 5键弹起 */
	KEY_5_LONG,				/* 5键长按 */

	KEY_6_DOWN,				/* 6键按下 */
	KEY_6_UP,				/* 6键弹起 */
	KEY_6_LONG,				/* 6键长按 */

	KEY_7_DOWN,				/* 7键按下 */
	KEY_7_UP,				/* 7键弹起 */
	KEY_7_LONG,				/* 7键长按 */

	KEY_8_DOWN,				/* 8键按下 */
	KEY_8_UP,				/* 8键弹起 */
	KEY_8_LONG,				/* 8键长按 */

	KEY_9_DOWN,				/* 9键按下 */
	KEY_9_UP,				/* 9键弹起 */
	KEY_9_LONG,				/* 9键长按 */

	KEY_10_DOWN,			/* 10键按下 */
	KEY_10_UP,				/* 10键弹起 */
	KEY_10_LONG,			/* 10键长按 */
	
	KEY_11_DOWN,			/* 11键按下 */
	KEY_11_UP,				/* 11键弹起 */
	KEY_11_LONG,			/* 11键长按 */
	
	KEY_12_DOWN,			/* 12键按下 */
	KEY_12_UP,				/* 12键弹起 */
	KEY_12_LONG,			/* 12键长按 */
}KEY_ENUM;

/* 按键FIFO用到变量 */
#define FIFO_SIZE	15

/*! fifo缓冲区类型 */
#define FIFO_TYPE    uint8_t

/*! fifo缓冲区满后 是否覆盖旧数据 0进行覆盖  1报错入栈失败*/
#define FIFO_COVER   0
typedef struct
{
    FIFO_TYPE  buff[FIFO_SIZE];       /* FIFO 缓冲区 */

    uint32_t   fifoLen;               /* FIFO 缓冲区有效数据长度 */

    uint32_t   fifoWrite;             /* 缓冲区写指针 */
    uint32_t   fifoRead;              /* 缓冲区读指针 */

}fifo_t;

typedef fifo_t KEY_FIFO_T;

/* 供外部调用的函数声明 */
void bsp_InitKey(void);
void bsp_KeyScan(void);
void bsp_PutKey(uint8_t _KeyCode);
uint8_t bsp_GetKey(void);
uint8_t bsp_GetKey2(void);
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID);
void bsp_SetKeyParam(uint8_t _ucKeyID, uint16_t _LongTime, uint8_t  _RepeatSpeed);
void bsp_ClearKey(void);




#endif

bsp_key.c

/*!
  * @file     BSP_KEY.c
  *
  * @brief    按键驱动文件
  *
  * @company  
  *
  * @author   不咸不要钱
  *
  * @note     无
  *
  * @version  
  *
  * @date     2019/10/18 星期五
  */ 
#include "bsp_key.h"
#include "lq_gpio.h"
#include "stdio.h"



static KEY_T xdata s_tBtn[KEY_COUNT];
static KEY_FIFO_T xdata s_tKey;		/* 按键FIFO变量,结构体 */

static void bsp_InitKeyVar(void);
static void bsp_InitKeyHard(void);
static void bsp_DetectKey(uint8_t i);

static uint8_t IsKeyDown0(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 0; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown1(void)  {P(C1_GPIO_PORT, C1_PIN) = 0;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; NOP(50); if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown2(void)  {P(C1_GPIO_PORT, C1_PIN) = 0;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown3(void)  {P(C1_GPIO_PORT, C1_PIN) = 0;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown4(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 0;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown5(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 0;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown6(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 0;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown7(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 0; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown8(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 0; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R2_GPIO_PORT, R2_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown9(void)  {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 0; P(C4_GPIO_PORT, C4_PIN) = 1; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown10(void) {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 0; NOP(50); if (P(R1_GPIO_PORT, R1_PIN) == 0) return 1;else return 0;}
static uint8_t IsKeyDown11(void) {P(C1_GPIO_PORT, C1_PIN) = 1;  P(C2_GPIO_PORT, C2_PIN) = 1;  P(C3_GPIO_PORT, C3_PIN) = 1; P(C4_GPIO_PORT, C4_PIN) = 0; if (P(R3_GPIO_PORT, R3_PIN) == 0) return 1;else return 0;}

/* 组合按键 key1 && key2 */
static uint8_t IsKeyDown12(void)  { return IsKeyDown1() && IsKeyDown2();}

/*!
 * @brief    fifo初始化
 *
 * @param    fifo_t    ：  FIFO
 *
 * @return   无
 *
 * @note     无
 *
 * @see      fifo_t  tempFifo;
 *           fifo_init(tempFifo);  //fifo初始化
 *
 * @date     2020/5/21
 */
void fifo_init(fifo_t *fifo)
{
    fifo->fifoLen   = 0;
    fifo->fifoRead  = 0;
    fifo->fifoWrite = 0;
}


/*!
 * @brief    fifo压入数据
 *
 * @param    fifo_t    ：  FIFO
 * @param    data      ：  入栈数据
 *
 * @return   0 ：成功   1 ：失败
 *
 * @note     FIFO_COVER 宏定义进行判断缓冲区满后的操作
 *
 * @see      fifo_t  tempFifo;
 *           fifo_push(tempFifo, 120);  //fifo中压入一个数据
 *
 * @date     2020/5/21
 */
uint8_t fifo_push(fifo_t *fifo, FIFO_TYPE dat)
{
    fifo->fifoLen++;

    /* 判断缓冲区是否已满 */
    if(fifo->fifoLen > FIFO_SIZE)
    {
        fifo->fifoLen = FIFO_SIZE;

#if FIFO_COVER
        return 1;
#else
        if(++fifo->fifoRead >= FIFO_SIZE)
        {
            fifo->fifoRead = 0;
        }
#endif
    }

    fifo->buff[fifo->fifoWrite] = dat;

    if(++fifo->fifoWrite >= FIFO_SIZE)
    {
        fifo->fifoWrite = 0;
    }

    return 0;

}

/*!
 * @brief    fifo弹出数据
 *
 * @param    fifo_t    ：  FIFO
 * @param    data      ：  出栈数据
 *
 * @return   0 ：成功   1 ：失败
 *
 * @note     无
 *
 * @see      fifo_t  tempFifo;
 *           FIFO_TYPE tempData;
 *           fifo_push(tempFifo, 120);       //fifo中压入一个数据
 *           fifo_pop(tempFifo, &tempData);  //fifo中弹出一个数据
 *
 * @date     2020/5/21
 */
uint8_t fifo_pop(fifo_t *fifo, FIFO_TYPE *dat)
{
    /* 缓冲区为空 */
    if(fifo->fifoLen == 0)
    {
        return 1;
    }

    fifo->fifoLen--;

    *dat = fifo->buff[fifo->fifoRead];

    if(++fifo->fifoRead >= FIFO_SIZE)
    {
        fifo->fifoRead = 0;
    }

    return 0;
}

/*
*********************************************************************************************************
*	函 数 名: bsp_InitKey
*	功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
void bsp_InitKey(void)
{
	bsp_InitKeyVar();		/* 初始化按键变量 */
	bsp_InitKeyHard();		/* 初始化按键硬件 */
}


/*
*********************************************************************************************************
*	函 数 名: bsp_PutKey
*	功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
*	形    参:  _KeyCode : 按键代码
*	返 回 值: 无
*********************************************************************************************************
*/
void bsp_PutKey(uint8_t _KeyCode)
{
	fifo_push(&s_tKey, _KeyCode);
}


/*
*********************************************************************************************************
*	函 数 名: bsp_GetKey
*	功能说明: 从按键FIFO缓冲区读取一个键值。
*	形    参:  无
*	返 回 值: 按键代码
*********************************************************************************************************
*/
uint8_t bsp_GetKey(void)
{
	uint8_t xdata ret;

	if (fifo_pop(&s_tKey, &ret) == 1)
	{
		return KEY_NONE;
	}
	else
	{
		return ret;
	}
}


/*
*********************************************************************************************************
*	函 数 名: bsp_GetKeyState
*	功能说明: 读取按键的状态
*	形    参:  _ucKeyID : 按键ID，从0开始
*	返 回 值: 1 表示按下， 0 表示未按下
*********************************************************************************************************
*/
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID)
{
	return s_tBtn[_ucKeyID].State;
}


/*
*********************************************************************************************************
*	函 数 名: bsp_SetKeyParam
*	功能说明: 设置按键参数
*	形    参：_ucKeyID : 按键ID，从0开始
*			_LongTime : 长按事件时间
*			 _RepeatSpeed : 连发速度
*	返 回 值: 无
*********************************************************************************************************
*/
void bsp_SetKeyParam(uint8_t _ucKeyID, uint16_t _LongTime, uint8_t  _RepeatSpeed)
{
	s_tBtn[_ucKeyID].LongTime = _LongTime;			/* 长按时间 0 表示不检测长按键事件 */
	s_tBtn[_ucKeyID].RepeatSpeed = _RepeatSpeed;			/* 按键连发的速度，0表示不支持连发 */
	s_tBtn[_ucKeyID].RepeatCount = 0;						/* 连发计数器 */
}

/*
*********************************************************************************************************
*	函 数 名: bsp_ClearKey
*	功能说明: 清空按键FIFO缓冲区
*	形    参：无
*	返 回 值: 按键代码
*********************************************************************************************************
*/
void bsp_ClearKey(void)
{
	s_tKey.fifoRead = s_tKey.fifoWrite;
}


/*
*********************************************************************************************************
*	函 数 名: bsp_InitKeyHard
*	功能说明: 配置按键对应的GPIO
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
static void bsp_InitKeyHard(void)
{
	//KEY 初始化
    PIN_InitPushPull(C1_GPIO_PORT, C1_PIN);
	PIN_InitPushPull(C2_GPIO_PORT, C2_PIN);
	PIN_InitPushPull(C3_GPIO_PORT, C3_PIN);
	PIN_InitPushPull(C4_GPIO_PORT, C4_PIN);
	PIN_InitOpenDrain(R1_GPIO_PORT, R1_PIN);
	PIN_InitOpenDrain(R2_GPIO_PORT, R2_PIN);
	PIN_InitOpenDrain(R3_GPIO_PORT, R3_PIN);
	
}


/*
*********************************************************************************************************
*	函 数 名: bsp_InitKeyVar
*	功能说明: 初始化按键变量
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
static void bsp_InitKeyVar(void)
{
	uint8_t xdata i;

	/* 对按键FIFO读写指针清零 */
	fifo_init(&s_tKey);
	
	/* 给每个按键结构体成员变量赋一组缺省值 */
	for (i = 0; i < KEY_COUNT; i++)
	{
		s_tBtn[i].LongTime = KEY_LONG_TIME;			/* 长按时间 0 表示不检测长按键事件 */
		s_tBtn[i].Count = KEY_FILTER_TIME / 2;		/* 计数器设置为滤波时间的一半 */
		s_tBtn[i].State = 0;							/* 按键缺省状态，0为未按下 */
		//s_tBtn[i].KeyCodeDown = 3 * i + 1;				/* 按键按下的键值代码 */
		//s_tBtn[i].KeyCodeUp   = 3 * i + 2;				/* 按键弹起的键值代码 */
		//s_tBtn[i].KeyCodeLong = 3 * i + 3;				/* 按键被持续按下的键值代码 */
		s_tBtn[i].RepeatSpeed = 0;						/* 按键连发的速度，0表示不支持连发 */
		s_tBtn[i].RepeatCount = 0;						/* 连发计数器 */
	}


	/* 判断按键按下的函数 */
	s_tBtn[0].IsKeyDownFunc = IsKeyDown0;
	s_tBtn[1].IsKeyDownFunc = IsKeyDown1;
	s_tBtn[2].IsKeyDownFunc = IsKeyDown2;
	s_tBtn[3].IsKeyDownFunc = IsKeyDown3;
	s_tBtn[4].IsKeyDownFunc = IsKeyDown4;
	s_tBtn[5].IsKeyDownFunc = IsKeyDown5;
	s_tBtn[6].IsKeyDownFunc = IsKeyDown6;
	s_tBtn[7].IsKeyDownFunc = IsKeyDown7;
	s_tBtn[8].IsKeyDownFunc = IsKeyDown8;
	s_tBtn[9].IsKeyDownFunc = IsKeyDown9;
	s_tBtn[10].IsKeyDownFunc = IsKeyDown10;
	s_tBtn[11].IsKeyDownFunc = IsKeyDown11;
	
	/* 组合按键 */
	s_tBtn[12].IsKeyDownFunc = IsKeyDown12;
}

/*
*********************************************************************************************************
*	函 数 名: bsp_DetectKey
*	功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
*	形    参:  按键结构变量指针
*	返 回 值: 无
*********************************************************************************************************
*/
static void bsp_DetectKey(uint8_t i)
{
	KEY_T xdata *pBtn;

	/*
		如果没有初始化按键函数，则报错
		if (s_tBtn[i].IsKeyDownFunc == 0)
		{
			printf("Fault : DetectButton(), s_tBtn[i].IsKeyDownFunc undefine");
		}
	*/

	pBtn = &s_tBtn[i];
	if (pBtn->IsKeyDownFunc())
	{
		if (pBtn->Count < KEY_FILTER_TIME)
		{
			pBtn->Count = KEY_FILTER_TIME;
		}
		else if(pBtn->Count < 2 * KEY_FILTER_TIME)
		{
			pBtn->Count++;
		}
		else
		{
			if (pBtn->State == 0)
			{
				pBtn->State = 1;

				/* 发送按钮按下的消息 */
				bsp_PutKey((uint8_t)(3 * i + 1));
				P27 = 1;                   //开启蜂鸣器
			}

			if (pBtn->LongTime > 0)
			{
				if (pBtn->LongCount < pBtn->LongTime)
				{
					/* 发送按钮持续按下的消息 */
					if (++pBtn->LongCount == pBtn->LongTime)
					{
						/* 键值放入按键FIFO */
						bsp_PutKey((uint8_t)(3 * i + 3));
					}
				}
				else
				{
					if (pBtn->RepeatSpeed > 0)
					{
						if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
						{
							pBtn->RepeatCount = 0;
							/* 常按键后，每隔10ms发送1个按键 */
							bsp_PutKey((uint8_t)(3 * i + 1));
						}
					}
				}
			}
		}
	}
	else
	{
		if(pBtn->Count > KEY_FILTER_TIME)
		{
			pBtn->Count = KEY_FILTER_TIME;
		}
		else if(pBtn->Count != 0)
		{
			pBtn->Count--;
		}
		else
		{
			if (pBtn->State == 1)
			{
				pBtn->State = 0;

				/* 发送按钮弹起的消息 */
				bsp_PutKey((uint8_t)(3 * i + 2));
				P27 = 0;                   //关闭蜂鸣器
			}
		}

		pBtn->LongCount = 0;
		pBtn->RepeatCount = 0;
	}
}

/*
*********************************************************************************************************
*	函 数 名: bsp_KeyScan
*	功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用
*	形    参:  无
*	返 回 值: 无
*********************************************************************************************************
*/
void bsp_KeyScan(void)
{
	uint8_t xdata i;

	for (i = 0; i < KEY_COUNT; i++)
	{
		bsp_DetectKey(i);
	}
}

思考

这个按键底层驱动可以检测到底层按下弹起，是否支持双击？
双击实现可以基于此底层驱动，不需要修改代码，只需要在修改应用层，比如检测到某按键按下，开启一个软件定时器，在定时器定时结束前，再次检测到按下，则为双击。

不咸不要钱
关注
  • 9
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
STM32高级篇—按键FIFO
2301_81355360的博客
06-11 694
FIFO的基本思想，就是先进先出，还是比较好理解的，我们以几张图为代表，就可以轻松的搞定。2）系统是非阻塞的，这样系统在检测到按键按下的情况下，由于机械按键抖动的原因不需要再这里等待一段事件，然后再确定按键是否按下。1）可以有效地记录按键事件的发生，尤其使对按键的按下，长按，弹起等事件的发生，使用FIFO的方式实现是一种非常好的思路。分别按下按键，K1,K2,K3按键被按下的事件将进入FIFO当中。这个时候写指针会根据写入的事件从而发生改变。通过读指针，实现对按键事件的读写操作。
51单片机FIFO实现
09-17
51单片机FIFO实现,做串口通信用，非常简洁，可靠！
GPIO应用之按键FIFO驱动
qq_62425900的博客
03-02 1150
eg:FIFO机制和状态机一样，都是在裸机编程中非常重要的编程思想。FIFO是先入先出的意思，即谁先进入队列，谁先出去。比如我们需要串口打印数据，当使用缓存将该数据保存的时候，在输出数据时必然是先进入的数据先出去，那么该如何实现这种机制呢？首先就是建立一个缓存空间，这里假设为10个字节空间进行说明。从上图可知，使用FIFO就先要定义一个结构体，来储存他的三个成员。缓存区Buf[]数组，缓存区写指针Write，缓存区读指针Read。初始状态下，Read=Write=0;//缓存区//缓存区写指针。
按键FIFO
最新发布
huihuafu_001的博客
05-23 227
看了很多网上按键FIFO的资料，很多都只有代码，注释不全面，也看不太懂，借鉴了大部分自己搞明白了，写了比较多注释。然后是按键的一些结构体和枚举，使用枚举是因为给每一个不同的时间都赋予一个不同的键值，方便使用。按键结构体的一些操作，接下来就是检测按键短按，双击，长按的主要函数。注释已经解释的比较清楚，需要注意的是这个函数需要在中断里不断调用。我的是自己做了6个按键的，如果需要更多或者更少都能很简单移植。另外调用FIFO的函数也有点复杂，我还没搞出来。所需函数只有初始化和读取FIFO的函数。
stm32按键FIFO的实现
weixin_30932215的博客
11-24 1313
学习目标： 　　1、理解FIFO的基本概念和设计按键FIFO的意义 　　 2、写出实现按键FIFO的代码 1、设计按键FIFO的优点 　　要介绍实现按键FIFO的优点，首先要了解FIFO的一些基本概念。FIFO即First In First Out，是一种先进先出的数据缓存方式，例如在超市购物之后我们会提着满满的购物车来到收银台排在结账队伍的最后等待付款，先排队的客户先付款离开，后...
基于FIFO的按键检测（1）—FIFO实现
weixin_58670090的博客
01-31 761
FIFO的C语言实现，抓稳自己的钱袋子
按键FIFO实现以及单片机时间片轮循法实现
Flin
07-09 721
本文主要介绍一套按键驱动代码以及使用SYSTICK定时器实现延时和嵌入式单片机时间片轮循法实现。
基于FIFO的按键检测（2）--按键扫描
weixin_58670090的博客
02-02 638
基于FIFO的按键扫描，按键检测部分
stm32F407按键例程安富莱
lzw508170827的博客
02-27 2171
/* ********************************************************************************************************* * * 模块名称 : 独立按键驱动模块 (外部输入IO) * 文件名称 : bsp_key.c * 版 本 : V1.3 * 说 明 : 扫描独立按键，具有软件滤波机制，...
STM32F429BI单片机按键检测和LED控制软件例程工程源码.zip
01-13
STM32F429BI单片机按键检测和LED控制软件例程工程源码，可做为你的学习设计参考。 该例使用systick定时器作为系统滴答定时器, 每隔1ms执行依次systick定时中断服务程序。 此后所有的例程都会和这个滴答定时器相关。...
Ex004-按键检测例程(软件滤波+FIFO)
06-08
Ex004-按键检测例程(软件滤波+FIFO)Ex004-按键检测例程(软件滤波+FIFO)Ex004-按键检测例程(软件滤波+FIFO)
V4-002_按键检测（抖动滤波、FIFO机制）（V1.0）
12-20
在标题提到的“V4-002_按键检测（抖动滤波、FIFO机制）（V1.0）”项目中，我们看到了一个高级的解决方案，结合了去抖动技术和FIFO（先进先出）数据结构，这对于单片机编程尤其重要。 1. **去抖动**： - 抖动产生的...
stm32f103_LL_key_FIFO.rar
07-19
在给定的“stm32f103_LL_key_FIFO.rar”压缩包中，我们关注的是如何在该芯片上实现按键队列（KEY_FIFO）的移植，利用GPIO（通用输入/输出）和滴答定时器（Tick Timer）来优化按键处理。 首先，理解GPIO在STM32F103...
51单片机教程实例59-独立按键依次输入数据
07-07
这个“51单片机教程实例59-独立按键依次输入数据”显然是一个教学资源，旨在帮助学习者掌握如何通过单片机处理来自独立按键的输入，并将这些数据依次存储或显示。 51单片机是由Intel开发的8051系列微控制器，具有...
STM32按键扫描代码
10-25
本篇将详细讲解如何编写STM32的按键扫描代码，以及其中涉及到的软件滤波、按键FIFO、事件检测等功能。 首先，我们要理解按键扫描的基本原理。在STM32中，通常使用GPIO（General-Purpose Input/Output）口来连接独立...
电子设计教程3：按键滤波电路
geekYatao
02-02 7673
  这是RC低通滤波器的应用。电路板上常见的机械接触式按键，在按下或者松开的过程中，常常会产生不稳定的信号，如下图所示，杂波过程一般持续10ms-20ms，毛刺的频率一般超过10KHz。下图是一款机械自锁按键开关瞬间产生的杂波   为了过滤掉杂波，可以通过单片机程序滤波或者通过硬件滤波电路进行滤波。单片机程序滤波的基本原理是：单片机检测到低电平后，延时若干毫秒，再检测一次，如果还是低电平，则确定...
单片机常见滤波算法
a919964703的博客
04-21 3062
这里写目录标题一、滑动滤波1、定义2、公式3、代码4、优缺点二、算术平均滤波1、原理2、公式3、代码三、加权平均滤波算法1、原理2、公式3、代码四、限幅滤波1、原理2、代码3、适用场合 一、滑动滤波 1、定义 滑动平均滤波就是把连续取得的N个采样值看成一个队列，队列的长度固定为N，每次采样得到一个新数据放到队尾，并丢掉原来队首的一次数据，把队列中的N个数据进行平均运算，就可以获得新的滤波结果。 经过滑动滤波之后，波形整体变得平滑。 2、公式 y(n)=12m+1∑n−mn+mx(n−k) y(n)=\fra
单片机 c51 串口 fifo
09-04
单片机C51的串口FIFO是指使用FIFO（First In First Out）缓冲区来处理串口数据的一种方式。C51单片机的串口通信需要通过UART（Universal Asynchronous Receiver Transmitter）模块来实现，而FIFO缓冲区则是更高效地处理串口数据的一种方法。 当C51单片机收到串口数据时，数据首先会被存储在串口接收缓冲区中。如果没有使用FIFO缓冲区，每次读取接收缓冲区中的数据时都需要进行一次读取操作，这样会导致效率低下。而使用FIFO缓冲区后，接收缓冲区中的数据可以被以先进先出的方式进行读取，提高了串口数据的处理效率。 在C51单片机中，串口FIFO缓冲区可以配置为不同的大小，一般可以设置为2字节、4字节或8字节等。当收到新的串口数据时，数据会被存储在FIFO缓冲区的末尾，而读取数据时则从FIFO缓冲区的头部开始，一次读取一个字节，直到FIFO缓冲区被完全读取。 使用FIFO缓冲区可以避免数据的丢失和冲突，特别是在高速和中断环境下的串口通信中。通过使用FIFO缓冲区，C51单片机可以更高效地处理串口数据，提高了系统的实时性和性能。 总之，单片机C51的串口FIFO是一种用于处理串口数据的缓冲区方式，通过先进先出的原则进行数据的读取和存储，提高了串口通信的效率和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值