C51 按键

最新推荐文章于 2023-10-29 08:45:02 发布

带刀木头

最新推荐文章于 2023-10-29 08:45:02 发布

阅读量1.1k

点赞数 1

分类专栏：本科学习文章标签：单片机编程语言

本文链接：https://blog.csdn.net/weixin_43482693/article/details/106401123

版权

本科学习专栏收录该内容

31 篇文章 3 订阅

订阅专栏

按键

C51 按键

C51 按键

1.独立按键

在这里插入图片描述
利用电流，我们就可以通过 KeyIn1 这个 IO 口的高低电平来判断是否有按键按下。

方框内的电路都是指单片机内部部分，方框外的就是我们外接的上拉电阻和按键。当我们要读取外部按键信号的时候，单片机必须先给该引脚写“1”，这样我们才能正确读取到外部按键信号。

2.矩阵按键

在这里插入图片描述
如果 KeyOut1 输出一个低电平，KeyOut1 就相当于是 GND，相当于 4 个独立按键。当然这时候 KeyOut2、KeyOut3、KeyOut4 都必须输出高电平，它们都输出高电平才能保证与它们相连的三路按键不会对这一路产生干扰。

//以下为简单示例
#include <reg52.h>
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED9 = P0^7;
sbit LED8 = P0^6;
sbit LED7 = P0^5;
sbit LED6 = P0^4
sbit KEY1 = P2^4;
sbit KEY2 = P2^5;
sbit KEY3 = P2^6;
sbit KEY4 = P2^7;
void main()
{
 
 ENLED = 0; //选择独立 LED 进行显示
 ADDR3 = 1;
 ADDR2 = 1;
 ADDR1 = 1;
 ADDR0 = 0;
 P2 = 0xF7; //P2.3 置 0，即 KeyOut1 输出低电平
while (1)
 {
 //将按键扫描引脚的值传递到 LED 上
 LED9 = KEY1; //按下时为 0，对应的 LED 点亮
 LED8 = KEY2;
 LED7 = KEY3;
 LED6 = KEY4;
 } }

我们把每次扫描到的按键状态保存，当一次按键状态扫描进来，与前一次状态做比较，如果发现这两次按键状态不一致，就说明按键产生动作了。

#include <reg52.h>
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit KEY1 = P2^4;
sbit KEY2 = P2^5;
sbit KEY3 = P2^6;
sbit KEY4 = P2^7;
unsigned char code LedChar[] = { //数码管显示字符转换表
 0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
 0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};
void main()
{
 bit backup = 1; //定义一个位变量，保存前一次扫描的按键值
 unsigned char cnt = 0; //定义一个计数变量，记录按键按下的次数
 
 ENLED = 0; //选择数码管 DS1 进行显示
 ADDR3 = 1;
 ADDR2 = 0;
 ADDR1 = 0;
 ADDR0 = 0;
 P2 = 0xF7; //P2.3 置 0，即 KeyOut1 输出低电平
 P0 = LedChar[cnt]; //显示按键次数初值
while (1)
 {
 if (KEY4 != backup) //当前值与前次值不相等说明此时按键有动作
 {
 if (backup == 0) //如果前次值为 0，则说明当前是由 0 变 1，即按键弹起
 {
 cnt++; //按键次数+1
 if (cnt >= 10)
 { //只用 1 个数码管显示，所以加到 10 就清零重新开始
 cnt = 0;
 }
 P0 = LedChar[cnt]; //计数值显示到数码管上
 }
 backup = KEY4; //更新备份为当前值，以备进行下次比较
 }
 } }

3.按键消抖

当检测到按键状态变化时，不是立即去响应动作，而是先等待闭合或断开稳定后再进行处理。

最简单的办法是延迟一定时间。

更好的办法是启用中断：我们启用一个定时中断，每 2ms 进一次中断，扫描一次按键状态并且存储起来，连续扫描 8 次后，看看这连续 8 次的按键状态是否是一致的。8 次按键的时间大概是 16ms，这 16ms 内如果按键状态一直保持一致，那就可以确定现在按键处于稳定的阶段，而非处于抖动的阶段。
在这里插入图片描述

#include <reg52.h>
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit KEY1 = P2^4;
sbit KEY2 = P2^5;
sbit KEY3 = P2^6;
sbit KEY4 = P2^7;
unsigned char code LedChar[] = { //数码管显示字符转换表
 0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
 0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};
bit KeySta = 1; //当前按键状态
void main()
{
 bit backup = 1; //按键值备份，保存前一次的扫描值
 unsigned char cnt = 0; //按键计数，记录按键按下的次数
 
 EA = 1; //使能总中断
 ENLED = 0; //选择数码管 DS1 进行显示
 ADDR3 = 1;
 ADDR2 = 0;
 ADDR1 = 0;
 ADDR0 = 0;
 TMOD = 0x01; //设置 T0 为模式 1
 TH0 = 0xF8; //为 T0 赋初值 0xF8CD，定时 2ms
 TL0 = 0xCD;
 ET0 = 1; //使能 T0 中断
 TR0 = 1; //启动 T0
 P2 = 0xF7; //P2.3 置 0，即 KeyOut1 输出低电平
 P0 = LedChar[cnt]; //显示按键次数初值
  while (1)
 {
 if (KeySta != backup) //当前值与前次值不相等说明此时按键有动作
 {
 if (backup == 0) //如果前次值为 0，则说明当前是弹起动作
 {
 cnt++; //按键次数+1
 if (cnt >= 10)
 { //只用 1 个数码管显示，所以加到 10 就清零重新开始
 cnt = 0;
 }
 P0 = LedChar[cnt]; //计数值显示到数码管上
 }
 backup = KeySta; //更新备份为当前值，以备进行下次比较
 }
 } }
/* T0 中断服务函数，用于按键状态的扫描并消抖 */
void InterruptTimer0() interrupt 1
{
 static unsigned char keybuf = 0xFF; //扫描缓冲区，保存一段时间内的扫描值
 
 TH0 = 0xF8; //重新加载初值
 TL0 = 0xCD;
 keybuf = (keybuf<<1) | KEY4; //缓冲区左移一位，并将当前扫描值移入最低位
 if (keybuf == 0x00)
 { //连续 8 次扫描值都为 0，即 16ms 内都只检测到按下状态时，可认为按键已按下
 KeySta = 0;
 }
 else if (keybuf == 0xFF)
 { //连续 8 次扫描值都为 1，即 16ms 内都只检测到弹起状态时，可认为按键已弹起
 KeySta = 1;
 }
 else
 {} //其它情况则说明按键状态尚未稳定，则不对 KeySta 变量值进行更新
}

4.矩阵按键扫描

我们每次让矩阵按键的一个 KeyOut 输出低电平，其它三个输出高电平，判断当前所有 KeyIn 的状态，下次中断时再让下一个 KeyOut 输出低电平，其它三个输出高电平，再次判断所有 KeyIn，通过快速的中断不停的循环进行判断，就可以最终确定哪个按键按下了

总结程序

#include <reg52.h>
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit KEY_IN_1 = P2^4;
sbit KEY_IN_2 = P2^5;
sbit KEY_IN_3 = P2^6;
sbit KEY_IN_4 = P2^7;
sbit KEY_OUT_1 = P2^3;
sbit KEY_OUT_2 = P2^2;
sbit KEY_OUT_3 = P2^1;
sbit KEY_OUT_4 = P2^0;
unsigned char code LedChar[] = { //数码管显示字符转换表
 0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
 0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};
unsigned char KeySta[4][4] = { //全部矩阵按键的当前状态
 {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
};
void main()
{
 unsigned char i, j;
 unsigned char backup[4][4] = { //按键值备份，保存前一次的值
 {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
 };
  EA = 1; //使能总中断
 ENLED = 0; //选择数码管 DS1 进行显示
 ADDR3 = 1;
 ADDR2 = 0;
 ADDR1 = 0;
 ADDR0 = 0;
 TMOD = 0x01; //设置 T0 为模式 1
 TH0 = 0xFC; //为 T0 赋初值 0xFC67，定时 1ms
 TL0 = 0x67;
 ET0 = 1; //使能 T0 中断
 TR0 = 1; //启动 T0
 P0 = LedChar[0]; //默认显示 0
 while (1)
 {
 for (i=0; i<4; i++) //循环检测 4*4 的矩阵按键
 {
 for (j=0; j<4; j++)
 {
 if (backup[i][j] != KeySta[i][j]) //检测按键动作
 {
 if (backup[i][j] != 0) //按键按下时执行动作
 {
 P0 = LedChar[i*4+j]; //将编号显示到数码管
 }
 backup[i][j] = KeySta[i][j]; //更新前一次的备份值
 }
 }
 }
 } }
/* T0 中断服务函数，扫描矩阵按键状态并消抖 */
void InterruptTimer0() interrupt 1
{
 unsigned char i;
 static unsigned char keyout = 0; //矩阵按键扫描输出索引
 static unsigned char keybuf[4][4] = { //矩阵按键扫描缓冲区
 {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF},
 {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}
 };
 
 TH0 = 0xFC; //重新加载初值
 TL0 = 0x67;
  //将一行的 4 个按键值移入缓冲区
 keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
 keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
 keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
 keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
 //消抖后更新按键状态
 for (i=0; i<4; i++) //每行 4 个按键，所以循环 4 次
 {
 if ((keybuf[keyout][i] & 0x0F) == 0x00)
 { //连续 4 次扫描值为 0，即 4*4ms 内都是按下状态时，可认为按键已稳定的按下
 KeySta[keyout][i] = 0;
 }
 else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
 { //连续 4 次扫描值为 1，即 4*4ms 内都是弹起状态时，可认为按键已稳定的弹起
 KeySta[keyout][i] = 1;
 }
 }
 //执行下一次的扫描输出
 keyout++; //输出索引递增
 keyout = keyout & 0x03; //索引值加到 4 即归零
 switch (keyout) //根据索引，释放当前输出引脚，拉低下次的输出引脚
 {
 case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
 case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
 case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
 case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
 default: break;
 } }