1. 首页
  2. 文章中心
  3. Other

单片机模块学习之键盘

77 阅读 0 评论
我是靠谱客的博主 飞快月饼，最近开发中收集的这篇文章主要介绍单片机模块学习之键盘，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

转载一位大神的，很全

一篇理解按键扫描的思想的博文。

理论

按键涉及到的重要知识点就是扫描和消抖了！

关于扫描，主要三种循环查询，定时查询，中断响应，当然各有优缺点，这里来总结下先。

1、循环查询

在一个循环函数里不断地扫描按键值，获取按下的按键。

优点：实现简单。
缺点：消抖需要浪费宝贵的CPU时间，且实时性不足(等待)。

2、定时查询

在中断服务函数里扫描按键活的按键值，根据按键按下的值然后存入缓冲区，等主函数有需要再来处理按键消息。（关于消息机制其实是一个很有意思的东西，这里这样称不知道准不准确。。。）

优点：避免消抖浪费时间，不会丢失捕捉按键按下，容易实现按键按下，长按，以及弹起等动作的识别。
缺点：需要使用定时器中断。

3、中断响应

按键按下触发中断，获取相应的按键值，需要进行消抖处理。
优点：实时性好。
缺点：需要微控制器支持中断，并且消抖浪费CPU资源。

通过上面的分析我们也不难猜出，其实应用比较好的还是定时查询的方式，既可以识别多种按键状态，还不必消抖浪费CPU资源。

实验

①、独立按键

这里写图片描述

1-2短接实现矩阵按键。
2-3短接实现独立按键。

1个独立按键是每2ms扫描一次(进一次中断保存一下当前值)，获取连续8个当前值，也就是耗费 2*8 = 16ms。

独立按键，同时使用一个数码管实现按一下+1的操作。（注意J5插针在右边）

/*
*******************************************************************************
* 文件名：
* 描
述：
* 作
者：CLAY
* 版本号：v1.0.0
* 日
期:
* 备
注：S4每次加1，S5每次加2，S6每次加3，S7每次加4
*
*******************************************************************************
*/
#include <stc15.h>
sbit KEY_IN_1 = P3^3;
sbit KEY_IN_2 = P3^2;
sbit KEY_IN_3 = P3^1;
sbit KEY_IN_4 = P3^0;
typedef unsigned char u8;
typedef unsigned int
u16;
typedef unsigned long u32;
u8 code LedChar[] = {
0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};
u8 LedBuff[] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
u8 KeySta[4] = {1, 1, 1, 1};
u8 KeyCodeMap[4] = {'1', '2', '3', '4'};
u8 T0RH;
u8 T0RL;
u16 cnt = 0;
void CloseFucker();
void ConfigTimer0(u16 ms);
void ShowNumber(u16 dat);
void KeyDriver();
void main()
{
CloseFucker();
ConfigTimer0(2);//2ms一扫。
EA = 1;
ShowNumber(0);
while(1)
{
KeyDriver();
}
}
void KeyAction(u8 keycode)
{
if(keycode == '1')
{
cnt += 1;
ShowNumber(cnt);
}
else if(keycode == '2')
{
cnt += 2;
ShowNumber(cnt);
}
else if(keycode == '3')
{
cnt += 3;
ShowNumber(cnt);
}
else if(keycode == '4')
{
cnt += 4;
ShowNumber(cnt);
}
}
void KeyDriver()
{
u8 i;
static u8 backup[4] = {1, 1, 1, 1};
for(i=0; i<4; i++)
{
if(KeySta[i] != backup[i])
{
if(backup[i] != 0)
{
KeyAction(KeyCodeMap[i]);
}
backup[i] = KeySta[i];
}
}
}
void CloseFucker()
{
P2 = (P2 & 0x1F) | 0x80;
P0 = 0xFF;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xA0;
P0 = 0xAF;
P2 = P2 & 0x1F;
}
void ConfigTimer0(u16 ms)
{
u32 tmp;
tmp = 11059200 / 12;
tmp = (tmp * ms) / 1000;
tmp = 65536 - tmp;
T0RH = (u8)(tmp >> 8);
T0RL = (u8)tmp;
TMOD &= 0xF0;
TMOD |= 0x01;
TH0 = T0RH;
TL0 = T0RL;
ET0 = 1;
TR0 = 1;
}
void ShowNumber(u16 dat)
{
char i;
u8 buf[8];
for(i=0; i<8; i++)
{
buf[i] = dat % 10;
dat /= 10;
}
for(i=7; i>0; i--)
{
if(buf[i] == 0)
LedBuff[i] = 0xFF;
else
break;
}
for( ; i>=0; i--)
{
LedBuff[i] = LedChar[buf[i]];
}
}
void LedScan()
{
static u8 index = 0;
P2 = (P2 & 0x1F) | 0xE0;
P0 = 0xFF;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xC0;
P0 = 0x80 >> index;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xE0;
P0 = LedBuff[index];
P2 = P2 & 0x1F;
if(index < 7)
index++;
else
index = 0;
}
void KeyScan()
{
u8 i;
static u8 keybuff[4] = {0xFF, 0xFF, 0xFF, 0xFF};
keybuff[0] = (keybuff[0] << 1) | KEY_IN_1;
keybuff[1] = (keybuff[1] << 1) | KEY_IN_2;
keybuff[2] = (keybuff[2] << 1) | KEY_IN_3;
keybuff[3] = (keybuff[3] << 1) | KEY_IN_4;
for(i=0; i<4; i++)
{
if(keybuff[i] == 0xFF)
{
KeySta[i] = 1;
}
else if(keybuff[i] == 0x00)
{
KeySta[i] = 0;
}
else
{}
}
}
void interruptTimer0() interrupt 1
{
TH0 = T0RH;
TL0 = T0RL;
LedScan();
KeyScan();
}




②、矩阵键盘


1个独立按键的时候，一端是接地的。 

这里写图片描述


同理，矩阵按键无非就是软件设置分别接地而已。




关于扫描时间，这里如果还是2ms, 8个扫描值的话。那么4行按键，每个按键扫8次，也就是2*4*8 = 64ms……有点长了。我们改成，1ms一扫，每个按键扫4次。1*4*4 = 16ms 和 1个独立按键的时间一样！


矩阵按键映射关系


这里写图片描述


/*
*******************************************************************************
* 文件名：
* 描
述：
* 作
者：CLAY
* 版本号：v1.0.0
* 日
期:
* 备
注：显示对应的0-9
*
*******************************************************************************
*/
#include <stc15.h>
typedef unsigned char u8;
typedef unsigned int
u16;
typedef unsigned long u32;
sbit KEY_OUT_1 = P3^0;
sbit KEY_OUT_2 = P3^1;
sbit KEY_OUT_3 = P3^2;
sbit KEY_OUT_4 = P3^3;
sbit KEY_IN_4 = P3^4;
sbit KEY_IN_3 = P3^5;
sbit KEY_IN_2 = P4^2;
sbit KEY_IN_1 = P4^4;
u8 code LedChar[] = {
0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};
u8 LedBuff[] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
u8 KeySta[4][4] = {
{1, 1, 1, 1}, {1, 1, 1, 1,}, {1, 1, 1, 1}, {1, 1, 1, 1}
};
u8 KeyCodeMap[4][4] = {
{'1', '2',
'3',
0x26},
{'4', '5',
'6',
0x25},
{'7', '8',
'9',
0x28},
{'0', 0x1B, 0x0D, 0x27}
};
u8 T0RH;
u8 T0RL;
void CloseFucker();
void ConfigTimer0(u16 ms);
void KeyDriver();
void main()
{
CloseFucker();
ConfigTimer0(1);
EA = 1;
while(1)
{
KeyDriver();
}
}
void ShowNumber(u8 dat)
{
char i;
u8 buf[8];
for(i=0; i<8; i++)
{
buf[i] = dat % 10;
dat /= 10;
}
for(i=7; i>0; i--)
{
if(buf[i] == 0)
LedBuff[i] = 0xFF;
else
break;
}
for( ; i>=0; i--)
{
LedBuff[i] = LedChar[buf[i]];
}
}
void KeyAction(u8 keycode)
{
if((keycode >= '0') && (keycode <= '9'))
{
ShowNumber(keycode - '0');
}
}
void KeyDriver()
{
u8 i, j;
static u8 backup[4][4] = {
{1, 1, 1, 1}, {1, 1, 1, 1,}, {1, 1, 1, 1}, {1, 1, 1, 1}
};
for(i=0; i<4; i++)
{
for(j=0; j<4; j++)
{
if(KeySta[i][j] != backup[i][j])
{
if(backup[i][j] != 0)
{
KeyAction(KeyCodeMap[i][j]);
}
backup[i][j] = KeySta[i][j];
}
}
}
}
void CloseFucker()
{
P2 = (P2 & 0x1F) | 0x80;
P0 = 0xFF;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xA0;
P0 = 0xAF;
P2 = P2 & 0x1F;
}
void ConfigTimer0(u16 ms)
{
u32 tmp;
tmp = 11059200 / 12;
tmp = (tmp * ms) / 1000;
tmp = 65536 - tmp;
T0RH = (u8)(tmp >> 8);
T0RL = (u8)tmp;
TMOD &= 0xF0;
TMOD |= 0x01;
TH0 = T0RH;
TL0 = T0RL;
ET0 = 1;
TR0 = 1;
}
void LedScan()
{
static u8 index = 0;
P2 = (P2 & 0x1F) | 0xE0;
P0 = 0xFF;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xC0;
P0 = 0x80 >> index;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xE0;
P0 = LedBuff[index];
P2 = P2 & 0x1F;
if(index < 7)
index++;
else
index = 0;
}
void KeyScan()
{
u8 i;
static u8 keyout = 0;
static u8 keybuff[4][4] = {
{0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}
};
switch(keyout)
{
case 0: KEY_OUT_1 = 0; KEY_OUT_4 = 1; break;
case 1: KEY_OUT_2 = 0; KEY_OUT_1 = 1; break;
case 2: KEY_OUT_3 = 0; KEY_OUT_2 = 1; break;
case 3: KEY_OUT_4 = 0; KEY_OUT_3 = 1; break;
default : break;
}
keybuff[keyout][0] = (keybuff[keyout][0] << 1) | KEY_IN_1;
keybuff[keyout][1] = (keybuff[keyout][1] << 1) | KEY_IN_2;
keybuff[keyout][2] = (keybuff[keyout][2] << 1) | KEY_IN_3;
keybuff[keyout][3] = (keybuff[keyout][3] << 1) | KEY_IN_4;
for(i=0; i<4; i++)
{
if((keybuff[keyout][i] & 0x0F) == 0x0F)
KeySta[keyout][i] = 1;
else if((keybuff[keyout][i] & 0x0F) == 0x00)
KeySta[keyout][i] = 0;
else
{}
}
keyout++;
keyout &= 0x03;
}
void interruptTimer0() interrupt 1
{
TH0 = T0RH;
TL0 = T0RL;
LedScan();
KeyScan();
}




③、长按键


如果上面所介绍的都没有问题了的话，就可以在其上的基础上再来了解一下长按键的实现了！ 拿独立按键来说，短按下只加一回，长按一直加，思路也很简单，用到了阈值的思路，这个要特别注意长按的加入不能影响到短按！


设置一个像KeySta的全局变量KeyDownTime，用来保存每个按键按下的时间累加，只要弹起就清零，这个是在KeyScan()里面进行操作的，也是和KeySta状态再一起进行判断的！ 

然后还需要个TimeThr这个在KeyDriver()里面，初始值为1000。如果检测到按下，执行按键动作函数，继续往下执行，如果检测到某个按键的KeyDownTime不为0，再判断是否大于阈值，大于阈值也要执行按键动作函数，然后让阈值增大，调节阈值增量可以控制增长速度。一旦KeyDownTime等于0，就是按键弹起来了，让阈值回归1000。


看下怎么实现吧!


以独立按键的实验为例，矩阵按键同理


/*
*******************************************************************************
* 文件名：
* 描
述：
* 作
者：CLAY
* 版本号：v1.0.0
* 日
期:
* 备
注：S4每次加1，S5每次加2，S6每次加3，S7每次加4
*
*******************************************************************************
*/
#include <stc15.h>
sbit KEY_IN_1 = P3^3;
sbit KEY_IN_2 = P3^2;
sbit KEY_IN_3 = P3^1;
sbit KEY_IN_4 = P3^0;
typedef unsigned char u8;
typedef unsigned int
u16;
typedef unsigned long u32;
u8 code LedChar[] = {
0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};
u8 LedBuff[] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
u8 KeySta[4] = {1, 1, 1, 1};
u16 KeyDownTime[4] = {0, 0, 0, 0};
u8 KeyCodeMap[4] = {'1', '2', '3', '4'};
u8 T0RH;
u8 T0RL;
u16 cnt = 0;
void CloseFucker();
void ConfigTimer0(u16 ms);
void ShowNumber(u16 dat);
void KeyDriver();
void main()
{
CloseFucker();
ConfigTimer0(2);//2ms一扫。
EA = 1;
ShowNumber(0);
while(1)
{
KeyDriver();
}
}
void KeyAction(u8 keycode)
{
if(keycode == '1')
{
cnt += 1;
ShowNumber(cnt);
}
else if(keycode == '2')
{
cnt += 2;
ShowNumber(cnt);
}
else if(keycode == '3')
{
cnt += 3;
ShowNumber(cnt);
}
else if(keycode == '4')
{
cnt += 4;
ShowNumber(cnt);
}
}
void KeyDriver()
{
u8 i;
static u8 backup[4] = {1, 1, 1, 1};
static u16 TimeThr[4] = {1000, 1000, 1000, 1000};
for(i=0; i<4; i++)
{
if(KeySta[i] != backup[i])
{
if(backup[i] != 0)
{
KeyAction(KeyCodeMap[i]);
}
backup[i] = KeySta[i];
}
if(KeyDownTime[i] > 0)
{
if(KeyDownTime[i] > TimeThr[i])
{
KeyAction(KeyCodeMap[i]);
TimeThr[i] += 200;
}
}
else
{
TimeThr[i] = 1000;
}
}
}
void CloseFucker()
{
P2 = (P2 & 0x1F) | 0x80;
P0 = 0xFF;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xA0;
P0 = 0xAF;
P2 = P2 & 0x1F;
}
void ConfigTimer0(u16 ms)
{
u32 tmp;
tmp = 11059200 / 12;
tmp = (tmp * ms) / 1000;
tmp = 65536 - tmp;
T0RH = (u8)(tmp >> 8);
T0RL = (u8)tmp;
TMOD &= 0xF0;
TMOD |= 0x01;
TH0 = T0RH;
TL0 = T0RL;
ET0 = 1;
TR0 = 1;
}
void ShowNumber(u16 dat)
{
char i;
u8 buf[8];
for(i=0; i<8; i++)
{
buf[i] = dat % 10;
dat /= 10;
}
for(i=7; i>0; i--)
{
if(buf[i] == 0)
LedBuff[i] = 0xFF;
else
break;
}
for( ; i>=0; i--)
{
LedBuff[i] = LedChar[buf[i]];
}
}
void LedScan()
{
static u8 index = 0;
P2 = (P2 & 0x1F) | 0xE0;
P0 = 0xFF;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xC0;
P0 = 0x80 >> index;
P2 = P2 & 0x1F;
P2 = (P2 & 0x1F) | 0xE0;
P0 = LedBuff[index];
P2 = P2 & 0x1F;
if(index < 7)
index++;
else
index = 0;
}
void KeyScan()
{
u8 i;
static u8 keybuff[4] = {0xFF, 0xFF, 0xFF, 0xFF};
keybuff[0] = (keybuff[0] << 1) | KEY_IN_1;
keybuff[1] = (keybuff[1] << 1) | KEY_IN_2;
keybuff[2] = (keybuff[2] << 1) | KEY_IN_3;
keybuff[3] = (keybuff[3] << 1) | KEY_IN_4;
for(i=0; i<4; i++)
{
if(keybuff[i] == 0xFF)
{
KeySta[i] = 1;
KeyDownTime[i] = 0;
}
else if(keybuff[i] == 0x00)
{
KeySta[i] = 0;
KeyDownTime[i] += 4;
}
else
{}
}
}
void interruptTimer0() interrupt 1
{
TH0 = T0RH;
TL0 = T0RL;
LedScan();
KeyScan();
}




小结


1、充分利用独立按键和矩阵按键再次感受模块化编程的便利，应用层和底层分离，维护修改记忆都方便，一石好几鸟。


2、注意程序中KEY_IN和KEY_OUT引脚定义以及KeyCodeMap的定义。

最后

以上就是飞快月饼为你收集整理的单片机模块学习之键盘的全部内容，希望文章能够帮你解决单片机模块学习之键盘所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(51)

相关文章

赵承熙获美国人宽恕，马加爵呢
赵承熙获美国人宽恕，马加爵呢
成功　自信　快乐, ――给中国青年学生的一封信
成功　自信　快乐, ――给中国青年学生的一封信
从ffmpeg中抓取mv/mb_type/dct_coeff/qp和MBSize等数据（H.264）1. mv——运动矢量2. QP——量化参数3. MB_Type——宏块类型4. DCT_Coeff——DCT系数5. MBSize——宏块编码长度6. 几个暗坑6.2 mb_xy与实际的宏块的索引值不同
从ffmpeg中抓取mv/mb_type/dct_coeff/qp和MBSize等数据（H.264）1. mv——运动矢量2. QP——量化参数3. MB_Type——宏块类型4. DCT_Coeff——DCT系数5. MBSize——宏块编码长度6. 几个暗坑6.2 mb_xy与实际的宏块的索引值不同
Task2：数理统计与描述性分析（第二次打卡）
Task2：数理统计与描述性分析（第二次打卡）
单片机模块学习之键盘
单片机模块学习之键盘
LCD1602液晶显示模块的单片机驱动深入详解之硬件篇
LCD1602液晶显示模块的单片机驱动深入详解之硬件篇
Dojo学习笔记（四）：NodeList扩展
Dojo学习笔记（四）：NodeList扩展
最优配餐
最优配餐

评论列表共有 0 条评论

立即
投稿
返回
顶部