• 【51单片机】8-按键

    1.按键相关知识

    在按键未被按下之前，电路中默认为高电平【1】；

    按键被按下后，电路中默认为低电平【0】

    1.按键工作原理

    1.内部机械结构

    内部是没有电路的，电路在引脚上，看着4个引脚，实际上里面两个引脚相互连接，只有按下的时候，1，2才会连接起来

    2.电路连接与原理图中图标

    按下按键，内部引脚连接再一起；

    松开按键，内部引脚断开

    3.按键电路接法

    4.上拉电阻

    在与VCC相连接的位置有一个上拉电阻，所以，使得我们在与VCC和mcu和按键相连接的电路中是保持高电平【如果未按下按钮】-->上拉电阻是为了让引脚变为高电平

    上拉是为了让引脚默认为高电平【因为如果为低电平，则会与VCC形成电压差，就会造成电流】，但是上拉的力量扛不住接地，所以按键没有按下时上拉的力量保证了IO引脚输入为1，而按下后绝对为0【接地是默认无穷大】

    5.按下和弹起的区别

    区别就是接不接地的问题，也就是引脚输入为1还是为0的问题。

    6.按键存在的意义

    按键这个设备对CPU来说是一共输入设备，输入的是人的工作。CPU提高监控按键连接的IO引脚的电平输入是1还是0就知道外部有没有人按下这个按键。相当于人通过按按键给CPU输入一个信号。这个信号可以被CPU监测到从而指导CPU去做一定的工作。

    2.CPU如何处理按键

    1.轮询式

    所谓的轮询式就是CPU不断的隔很小时间去查看有没有按键被按下，如果按下就处理按键，如果没有按下就过一会再来查看（按键什么时候被按下CPU是无法预知的）

    2.中断式

    3.按键分类

    1.独立按键

    2.矩阵键盘

    2.独立按键编程

    1.原理图和接线分析

    （1）8个独立按键接法一样：都是一端接GND，另外一端接插座上

    （2）接线：插座接到P1端口，接完之后P1端口8个IO分别对应8个按键（P1.0对应K1，p1.1对应K2，....P1.7对应K8）

    （3）为了应用LED点亮或者熄灭来指示按键是否按下，还要给LED接线。P0端口接LED,P1端口接按键。

    2.先监测1个按键（用LED作为指示）

    （1）使用轮询法，来处理独立按键K1，单片机再循环中每隔很短的时间就监测K1对应的P1.0引脚的输入电平是1还是0，如果是1则表示按键没有按下，延时等待下一次检验；如果是0表示按键引脚按下，点亮一颗LED作为指示。

    （2）为了用LED点亮或者熄灭来指示按键是否按下，还要给LED接线，P0端接LED。

    1. #include
    2.  
    3. //当前我们要处理的是K1，对应的P1.0这个IO口
    4. //操控的LED是LED1，对应的是P0.0
    5.  
    6. sbit Key1=P1^0;
    7. sbit LED1=P0^0;
    8.  
    9.  
    10.  
    11. void delay(){
    12. 	unsigned char i,j;
    13. 	for(i=0;i<100;i++){
    14. 		for(j=0;j<200;j++);
    15. 	}
    16. 	
    17. }
    18.  
    19. int main(){
    20. 	
    21. 	while(1){
    22. 		
    23. 		//再C语言中把一个引脚定义未一个变量key1
    24. 		//然后给key1变量赋值就相当于向这个IO引脚输出
    25. 		//直接使用（读）这个key1变量，就相当于从这个IO引脚输入
    26. 		if(Key1==1){
    27. 			//表示此时为高电平，此时未按下按键
    28. 			//这里我们要对应原理图和你所插的单片机进行分析，应该是【0灭还是0亮】
    29. 			LED1=0;//led此时熄灭
    30. 		}else{
    31. 			//已经按下按键，Key1==0
    32. 			LED1=1;
    33. 		}
    34. 		
    35. 	}
    36. 	
    37. 	
    38. }

    3.监测8个独立按键

    （1）如果要监测的按键数量少，可以用位监测。如果多可以直接用端口字节变量来监测。

    （2）独立按键之间多个按键之间是彼此独立的，所以允许多个按键同时按下，而且不会互相影响（矩阵按键只能一次按下一个按键，不能同时按下多个）

    （3）按键去抖

    3.键值检测和显示

    1.何为键值

    （1）一般产品按键很多，对于整个程序来说一般都是把按键进行编码，给每一个按键一个对应的编码值，就叫做按键的键值

    （2）再正式的比较庞大的程序中，按键的检测部分和处理部分都是隔开的。这两部分隔开有利于各自部分的程序编写，两部分之间用键值来连接。按键监测部分赋值监测按键，一旦发送一个按键事件就产生一个键值，然后将键值传递给按键处理部分。

    2.加入数码管显示键值

    （1）整个程序分为2部分：第一步部分做按键检测，另一部分负责将接收到

    （2）将muc中的P0与数码管连接，mcu中的P1与独立按键连接

    注意点：

    注意点1：显示问题

    1. //当前我们要处理的是K1，对应的P1.0这个IO口
    2. //操控的LED是LED1，对应的是P0.0
    3.  
    4. sbit Key1=P1^0;
    5. sbit LED1=P0^0;
    6.  
    7. sbit Key2=P1^1;
    8. sbit LED2=P0^1;
    9.  
    10. sbit Key3=P1^2;
    11. sbit LED3=P0^2;
    12.  
    13.  
    14. 		if(Key1==1){
    15. 			//表示此时为高电平，此时未按下按键
    16. 			//LED1=0;//led此时熄灭
    17. 		}else{
    18. 			//已经按下按键，Key1==0
    19. 			LED1=1;
    20. 			keynum=1;
    21. 		}

    （1）我们将P0.0作为数码管的端口，此时我们按下【按键】，则数码管上显示“1”，当我们松开，则按键处于断电状态，此时进入if语句中，将LED1=0，因为LED1对应的是P0.0端口，此时我们就意味着修改了P0.0这个端口的数值。

    所以我们应该将if语句中的LED1=0注释掉。

    简单写法
    1. 		/**
    2. 			简单写法
    3. 		*/
    4. 		
    5. 		if(Key1==0){//此时“按键”已经被按下
    6. 			keynum=1;
    7. 		}
    8. 		if(Key2==0){
    9. 			keynum=2;
    10. 		}
    11. 		if(Key3==0){
    12. 			keynum=3;
    13. 		}
    读取整个端口的数值

    此时只能读取其中一个端口的值，无法同时检查两个按键

    1. 		/**
    2. 			读取整个端口
    3. 			如果使用端口读取，则直接使用P1【因为P1是连接着独立按键】
    4. 		*/
    5. 		//高电平【1】表示未按下按键，【0】表示被按下按键
    6. 		//1111 1110
    7. 		if(P1==0xfe){//此时“按键”已经被按下
    8. 			keynum=1;
    9. 		}
    10. 		//1111 1101
    11. 		if(P1==0xfd){
    12. 			keynum=2;
    13. 		}
    14. 		//1111 1011
    15. 		if(P1==0xfb){
    16. 			keynum=3;
    17. 		}

    注意点2：多个按钮按下问题

    1. 		使用整个IO端口读入--漏洞：此时无法同时按下多个按钮
    2. 		
    3. 		if(P1==0xfe){//1111 1110
    4. 			//表示最右边的按键被按下
    5. 			keynum=1;
    6. 		}
    7. 		
    8. 		if(P1==0xbf){//1011 1111
    9. 			//表示最右边的按键被按下
    10. 			keynum=7;
    11. 		}
    12. 		
    13. 		if(P1==0x7f){//0111 1111
    14. 			//表示最右边的按键被按下
    15. 			keynum=81;
    16. 		}

    如果我们按照上面这样写，则无法同时按下多个按钮。

    1. //独立数码管的段码表
    2. unsigned char val[16]={0xc0,0xf9,0xA4,0xb0,0x99,0x92,0x82,0xf8,
    3. 0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e};
    4.  
    5.  
    6. //*****************************************
    7. //函数声明
    8. void display(unsigned char num);
    9. void delay();
    10.  
    11. //***********************************************************
    12. //该函数将num送到独立数码管中进行显示
    13. void display(unsigned char num){
    14. 	
    15. 	//原来P0端口我们接着LED（因为我们原来在测试按钮，此时将起接到独立数码管中）
    16. 	P0=val[num];
    17. }
    18.  
    19.  
    20. void delay(){
    21. 	unsigned char i,j;
    22. 	for(i=0;i<100;i++){
    23. 		for(j=0;j<200;j++);
    24. 	}
    25. 	
    26. }
    27. //*********************************************************
    28. int main(){
    29. 	
    30. 	//默认为0
    31. 	//如果按键未被按下，则数码管默认输入“0”
    32. 	unsigned char keynum=0;
    33. 		
    34. 	unsigned char i=0;
    35. 		for(i=0;i<8;i++){//因为我们P1IO端口有8个IO口，所以需要循环8次
    36. 			//P1 &(0x1<
    37. 			//我们通过P1与0x1位移的每一位进行比较，&【同1则1，其余为0】
    38. 			//如果我们p1中有一位刚好与【0x1《《i】&出结果为0，则表示p1中的数值为0，则表示为低电平
    39. 			//则表示此按键已经被按下
    40. 			if( (P1 &(0x1<0  ){
    41. 					keynum=i+1;//i是从0开始
    42. 			}
    43. 		}
    44. 		
    45. 		
    46. 		
    47. 		//在这里去处理按键
    48. 		//处理方法就是把整个按键发出到独立数码管去显示
    49. 		display(keynum);
    50. 		
    51. 	}
    52. 	
    53. 	
    54. }

    4.按键的消抖

    1.案例：按键按一次数码管显示数字+1

    我们设计代码后，如果一直按着加键，则数值会一直加。如果我们一个一个的按，则显示结果不是我们想要的，因为CPU判断的速度和我们手动去按的速度不一样。

    2.什么是抖动

    （1）按键按下和弹起时的电平变化图

    （2）抖动如何产生【物理产生的，无法消除的】

    （3）抖动的危害：在抖动时间范围内引脚的电平变化是不定的，如果程序在这一段时间范围内去判断引脚的电平从而来判断有无按键，则有很大可能性会误判。

    3.如何消抖

    1.硬件消抖

    在硬件设计上想办法降低抖动，这是一种主动消抖。【使用电容器--》滤波，电容器可以阻碍电容变化-----》吸走高频】

    2.软件消抖

    既然在硬件上不能完全消除抖动，软件设计上想办法绕开抖动造成的影响，这是一种被动的（逃避式）的消抖。---》通过延时，来判断是真低电平还是高电平。

    1. while(1){
    2. 		
    3. 		if(key1==0){
    4. 			//发现一次低电平，有可能是按键按下，也可能是抖动，软件消除
    5. 			delay10ms();
    6. 			if(key1==0){
    7. 				//10ms后还是低电平，则说明是真的按下，不是抖动
    8. 				AddDisplay();
    9. 			}
    10.             delay10ms();
    11. 		}

    5.完整的按键检测

    1.一次完整的按键事件

    （1）按键事件就是按键操作过程中不同状态的切换

    （2）一个完整的事件包括：按下事件（电平由高变低），弹起事件（由低到高）

    （3）一般都认为发生了一次完整的按键事件才算的用户操作了一次按键，程序才会去处理按键，所以在一次完整的按键事件中程序只能去处理一次按键。

    2.改良版按键增加数码管显示

    1.按下按钮数值不变，当松开按键时，数值+1

    因为一次完整的按键事件=按下+弹起【所以我们不只是要检查是否按下，还要检查是否弹起】

            unsigned char flag=0;//默认为0

            while(1){
                if(Key1==0){//此时表示按下了
                //发现一次低电平，有可能是按键按下，也可能是抖动
                    delay10ms();
                    if(Key1==0){
                        //10ms后还是低电平，说明是真的按键按下，不是抖动
                        //这里说明发现了一个按下事件
                            flag=1;
                    }
                }else{//Key1==1【表示未按下按键，或者正在弹起】
                    //弹起也要消抖
                    delay10ms();
                    if(Key1==1){
                        //说明弹起
                        if(flag==1){//判断此时是不是按下产生的弹起，因为上面我们设置了按下flag=1
                            AddDisplay();//等按下后才弹起的数值+1
                            //记得将flag置为0，才可能进入下一次循环
                            flag=0;
                        }
                    }
                }
            }

    1. /******************************全局变量定义*************************/
    2. unsigned char dnum = 0;//默认从0开始加
    3. /**************************************************************/
    4. int main(){
    5. 	//这里默认为0,用来表示此时按键的状态
    6. 	unsigned char flag=0;
    7. 		
    8. 		while(1){
    9. 			
    10. 			if(Key1==0){
    11. 			//发现一次低电平，有可能是按键按下，也可能是抖动
    12. 				delay10ms();
    13. 				if(Key1==0){
    14. 					//10ms后还是低电平，说明是真的按键按下，不是抖动
    15. 					//这里说明发现了一个按下事件
    16. 					if(flag<2){
    17. 						flag=1;
    18. 					}
    19. 				}
    20. 			}else{//Key1==1【表示未按下按键，或者正在弹起】
    21. 				//弹起也要消抖
    22. 				delay10ms();
    23. 				if(Key1==1){
    24. 					//说明弹起
    25. 					if(flag==1){//判断此时是不是按下产生的弹起，因为上面我们设置了按下flag=1
    26. 						AddDisplay();//等按下后才弹起的数值+1
    27. 						//记得将flag置为0，才可能进入下一次循环
    28. 						flag=0;
    29. 					}
    30. 				}
    31. 			}
    32. 		}
    33. 			
    34. 		delay();
    35. }
    36. // 该函数将num数字送到独立数码管去显示
    37. void AddDisplay(void)
    38. {
    39.  
    40. 	dnum = dnum + 1;
    41. 	if (dnum > 15)
    42. 	{
    43. 		dnum = 0;
    44. 	}
    45.  
    46. 	P0 = val[dnum];
    47. }
    48.  
    49. // 延时函数
    50. void delay(void)
    51. {
    52. 	unsigned char i, j;
    53.  
    54. 	for (i=0; i<100; i++)
    55. 		for (j=0; j<200; j++);
    56. }

    2.按下按键时数值+1，松开按钮数值不变

    //这里默认为0,用来表示此时按键的状态
        unsigned char flag=0;
            
            while(1){
                if(Key1==0){
                //发现一次低电平，有可能是按键按下，也可能是抖动
                    delay10ms();
                    if(Key1==0){
                        //10ms后还是低电平，说明是真的按键按下，不是抖动
                        //这里说明发现了一个按下事件
                            if(flag==0){
                                AddDisplay();
                                flag=1;
                            }
                    }
                }else{//Key1==1【表示未按下按键，或者正在弹起】
                    //弹起也要消抖
                    delay10ms();
                    if(Key1==1){
                        //说明弹起
                        if(flag==1){//判断此时是不是按下产生的弹起，因为上面我们设置了按下flag=1
                            //记得将flag置为0，才可能进入下一次循环
                            flag=0;
                        }
                    }
                }
            }

    1. int main(){
    2. 	//这里默认为0,用来表示此时按键的状态
    3. 	unsigned char flag=0;
    4. 		
    5. 		while(1){
    6. 			
    7. 			if(Key1==0){
    8. 			//发现一次低电平，有可能是按键按下，也可能是抖动
    9. 				delay10ms();
    10. 				if(Key1==0){
    11. 					//10ms后还是低电平，说明是真的按键按下，不是抖动
    12. 					//这里说明发现了一个按下事件
    13. 						if(flag==0){
    14. 							AddDisplay();
    15. 							flag=1;
    16. 						}
    17. 				}
    18. 			}else{//Key1==1【表示未按下按键，或者正在弹起】
    19. 				//弹起也要消抖
    20. 				delay10ms();
    21. 				if(Key1==1){
    22. 					//说明弹起
    23. 					if(flag==1){//判断此时是不是按下产生的弹起，因为上面我们设置了按下flag=1
    24. 						//记得将flag置为0，才可能进入下一次循环
    25. 						flag=0;
    26. 					}
    27. 				}
    28. 			}
    29. 		}
    30. 			
    31. 		delay();
    32. }
    33. // 该函数将num数字送到独立数码管去显示
    34. void AddDisplay(void)
    35. {
    36.  
    37. 	dnum = dnum + 1;
    38. 	if (dnum > 15)
    39. 	{
    40. 		dnum = 0;
    41. 	}
    42.  
    43. 	P0 = val[dnum];
    44. }

    6.中断

    1.案例引入

    独立数码管循环显示0-F，同时按键控制LED亮灭

    1. #include
    2.  
    3.  
    4. /**
    6. 	中断测试：
    7. 		
    8. */
    9.  
    10. // 当前要处理的是K1，对应P1.0IO口，操控的LED是LED1，对应P0.0
    11.  
    12. /*********************变量定义************************************/
    13. sbit key1 = P1^0;
    14. sbit key2 = P1^1;
    15. sbit key8 = P1^7;
    16.  
    17. //因为P0端口被数码管占用，所以我们LED只能使用P2端口
    18. //这里为什么从7开始？？因为P2端口的7在上面
    19. sbit led1 = P2^7;
    20. sbit led2 = P2^6;
    21.  
    22.  
    23.  
    24.  
    25. // 独立数码管的段码表
    26. unsigned char val[16] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e};
    27.  
    28.  
    29.  
    30. /*********************************** 函数声明 ***********************/
    31. void delay(void);
    32. void delay10ms(void);
    33.  
    34. // 延时函数
    35. void delay(void)
    36. {
    37. 	unsigned char i, j;
    38.  
    39. 	for (i=0; i<200; i++)
    40. 		for (j=0; j<250; j++);
    41. }
    42.  
    43. void delay10ms(void)   //误差 0us
    44. {
    45.     unsigned char a,b,c;
    46.     for(c=5;c>0;c--)
    47.         for(b=4;b>0;b--)
    48.             for(a=248;a>0;a--);
    49. }
    50.  
    51. int main(){
    52. 	
    53. 	unsigned char i=0;
    54. 	while(1){
    55. 		//【任务1】：在数码管上1循环显示0-F
    56. 		for(i=0;i<16;i++){
    57. 			//这里P0端口被数码管使用
    58. 			P0=val[i];
    59. 			//时间变化太快看不到数值
    60. 			delay();
    61. 		}
    62. 		
    63. 		//【任务2】：按键监测和led控制
    64. 		if(Key1==0){
    65. 			led1=1;
    66. 		}else{
    67. 			led1=0;
    68. 		}
    69. 		
    70. 		if(Key2==0){
    71. 			led2=1;
    72. 		}else{
    73. 			led2=0;
    74. 		}
    75. 	}
    76. 	
    77. }

    （1）分析是否实现，实践证明可以实现功能，但是按键监测控制LED这边非常不灵敏-->因为for循环等待

    （2）逐步认识到单片机只有一个”主线任务“的特点

    （3）多任务时如何及时响应？

    2.中断的思路

    （1）”主线任务“为常规任务，默认运行

    （2）中断发生后CPU暂替主线任务转去处理中断任务，完成后再回来接着执行主线任务。

    3.中断的意义

    （1）中断处理内容让CPU可以全力处理主线任务而不用担心会错过中断任务（看电影和收快递）

    （2）中断式比轮询式更加合适处理异步事件，效率更高。

    （3）中断任务的特点：处理时间短，响应要求急，无法事先预料

    7.使用单片机外部中断处理按键

    1.外部中断INTO和INT1

    int0【表示”外部中断0】

    int1【表示“外部中断1”】

    1.何为外部中断

    中断源来自于单片机外部就叫外部中断，51支持4个外部中断。分别对应4个引脚。每一个外部中断都对应一个特定的单片机IO引脚（比如INT0对应P3.2，这个是单片机再设计时就设定好的，是无法改变的）。

    我们软件只需要对P3.2做一些相关配置，P3.2 就可以响应外部的中断事件。当硬件产生了一个外部中断时CPU就会收到一个中断信号。从而转去执行外部中断对应的处理程序（这个处理程序也是我们软件需要去编写提供的）。

    2.外部中断对应

    外部中断对应哪一个引脚？？数据手册上有。

    2.参考数据手册中“中断处理程序”示例代码写程序

    1.编程使用INT0处理按键

    【IT0=1-->下降沿触发】：这一位用来设置中断触发模式：下降沿触发【1】（Falling）或者低电平【0】触发（Low level)【我们一般初始化为1，因为按键事件只有一个下降沿】

    【EX0=1-->打开外部中断】：外部中断0的开关。如果EX0=0则外部中断再单片机内部被关闭，此时CPU无法收到INT0的中断信息所以不会处理INT0；如果需要使用INT0就一定要设置为1.

    【EA=1-->打开全局中断】：全局的中断开关。EA如果关掉，则整个CPU不能响应中断，如果EA打开也不一定可以响应中断，还得具体的中断开关打开才行。

    2.程序解释

    1. #include
    2.  
    3.  
    4. /**
    6. 	中断测试：
    7. 		
    8. */
    9.  
    10. // 当前要处理的是K1，对应P1.0IO口，操控的LED是LED1，对应P0.0
    11.  
    12. /*********************变量定义************************************/
    13. sbit Key1= P1^0;
    14. sbit Key2 = P1^1;
    15. sbit Key8 = P1^7;
    16.  
    17. //因为P0端口被数码管占用，所以我们LED只能使用P2端口
    18. //这里为什么从7开始？？因为P2端口的7在上面
    19. sbit led1 = P2^7;
    20. sbit led2 = P2^6;
    21.  
    22.  
    23.  
    24.  
    25. // 独立数码管的段码表
    26. unsigned char val[16] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e};
    27.  
    28.  
    29.  
    30. /*********************************** 函数声明 ***********************/
    31. void delay(void);
    32. void delay10ms(void);
    33.  
    34. // 延时函数
    35. void delay(void)
    36. {
    37. 	unsigned char i, j;
    38.  
    39. 	for (i=0; i<200; i++)
    40. 		for (j=0; j<250; j++);
    41. }
    42.  
    43. void delay10ms(void)   //误差 0us
    44. {
    45.     unsigned char a,b,c;
    46.     for(c=5;c>0;c--)
    47.         for(b=4;b>0;b--)
    48.             for(a=248;a>0;a--);
    49. }
    50.  
    51. //【2.中断处理程序】
    52. //interrupt:关键字
    53. //Isr：中断处理程序
    54. void Eitn0Isr() interrupt 0//按键检测
    55. {
    56. 	//进入中断后LED状态转换，原来亮则灭，原来灭则亮
    57. 	if(led1==1){
    58. 		led1=0;
    59. 	}else{
    60. 		led1=1;
    61. 	}
    62. }
    63.  
    64.  
    65. int main(){
    66. 	
    67. 	unsigned char i=0;
    68. 	
    69. 	
    70. 	//【1.中断处理的初始化】
    71. 	IT0=1;//设置为下降沿触发
    72. 	EX0=1;//外部中断0的开关
    73. 	EA=1;//全局的中断开关
    74. 	
    75. 	
    76. 	//2.主线任务
    77. 	while(1){
    78. 		//在数码管上1循环显示0-F
    79. 		for(i=0;i<16;i++){
    80. 			//这里P0端口被数码管使用
    81. 			P0=val[i];
    82. 			//时间变化太快看不到数值
    83. 			delay();
    84. 		}
    85. 		
    86. 		
    87. 	}
    88. 	
    89. }

    3.总结

    （1）中断能力的CPU本身设计时支持的，并不是编程制造出来的

    （2）程序员只要负责2件事情即可：主程序中初始化中断，定义中断处理程序

    （3）当中断条件发生时，硬件会自动检测到并且通知CPI，CPU会自动去执行中断处理程序，这一切都是CPU设计时定下来的，不需要编程干预。

    8.矩阵键盘的原理

    1.原理分析

    （1）横向和纵向分组（因为有一端是连接再一起的）

    （2）按键两端分别接不同的IO引脚

    （3）按键的物理作用不变：接下接通电路，弹起断开电路

    2.工作原理

    主要步骤：分别给0x0f和0xf0

    （1）先送（IO引脚输出）0x0f--》判断哪一行按下了

    （2）如果有按键接收到的不是0x0f，从收到的数据（IO引脚输入）判断哪一行按下了

    （3）再送（IO引脚输出）0xf0---》判断哪一列按下了

    （4）从收到的数据（IO引脚出入）判断哪一列按下了

    （5）综合2次得到的行和列的位置，计算出键值

    3.特点

    （1）优点：节省单片机的IO口

    （2）缺点：不能同时按下多个按键【可能会产生多个焦点，无法确定按下是哪一个按键】

    9.矩阵键盘编程实战

    1.实验研究按键按下的规律（LED显示辅助）

    1. #include
    2.  
    3. //P0：接LED
    4. #define LED P0
    5.  
    6.  
    7.  
    8. //P3：矩阵键盘
    9. #define KEY P3
    10.  
    11.  
    12. void main(){
    13. 	
    14. 	//【第一回合第一步】输出
    15. 	KEY=0x0f;		//从IO口输出，写IO口
    16. 	//因为KEY是接IO空，所以中间KEY可能会变
    17. 	if(KEY!=0x0f){		//从IO口输入，读IO口
    18. 		//读出的不是0x0f说明有按键被按下
    19. 		//【第一回合第2步】：读出端口从读出值来判断是哪一行
    20. 		LED=KEY;//直接读出到LED中
    21. 	 }
    22. 		//【第二回合第1步】
    23. 		KEY=0xf0;
    24. 		if(KEY!=0xf0){
    25. 			LED=KEY;
    26. 		}
    27. }

    2.编写键值检验函数

    1. unsigned char GetKey(void){
    2. 	
    3. 	//定义行列
    4. 	unsigned char hang=0,lie=0;
    5. 	//显示当前按下的按键的键值
    6. 	unsigned char keyvalue=0;
    7. 	
    8. 	
    9. 	//【第一回合第一步】输出
    10. 	KEY=0x0f;		//从IO口输出，写IO口
    11. 	
    12. 	//因为KEY是接IO空，所以中间KEY可能会变
    13. 	if(KEY!=0x0f){		//从IO口输入，读IO口
    14. 		//读出的不是0x0f说明有按键被按下
    15. 		//【第一回合第2步】：读出端口从读出值来判断是哪一行
    16. 		
    17. 		//1.算出行号
    18. 		switch(KEY){
    19. 			case 0xfe:hang=1;	break;
    20. 			case 0xfd:hang=2;	break;
    21. 			case 0xfb:hang=3;	break;
    22. 			case 0xf7:hang=4;	break;
    23. 			default:break;
    24. 		}
    25. 		
    26. 	
    27. 	 }
    28. 		//【第二回合第1步】
    29. 		KEY=0xf0;
    30. 		if(KEY!=0xf0){
    31. 			
    32. 			//1.算出列号
    33. 			switch(KEY){
    34. 				case 0xef:lie=1;	break;
    35. 				case 0xdf:lie=2;	break;
    36. 				case 0xbf:lie=3;	break;
    37. 				case 0x7f:lie=4;	break;
    38. 				default:break;
    39. 			}
    40. 		
    41. 				//经过2个回合后hang和lie都知道了，然后根据hang和lie计算出键值
    42. 				//（行-1）*4+列=键值
    43. 				keyvalue=(hang-1)*4+lie;
    44. 				return keyvalue;
    45. 			
    46. 			}
    47. }

    3.独立数码管显示键值

    1. // 独立数码管的段码表
    2. unsigned char val[16] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82,
    3. 0xf8, 0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e};
    4. //************************************************
    5. //函数声明
    6. unsigned char GetKey(void);
    7.  
    8. void main(){
    9. 	
    10. 	unsigned char key=0;
    11. 	while(1){
    12. 		key=3;
    13. 		//key=GetKey();
    14. 		if(key!=0){
    15. 			DIG=val[key];
    16. 		}
    17. 	}	
    18. }

    4.总结

    1. #include
    2.  
    3.  
    4. //P0：接数码管
    5. #define DIG P0
    6.  
    7.  
    8. //P3：矩阵键盘
    9. #define KEY P3
    10.  
    11.  
    12. // 独立数码管的段码表
    13. unsigned char val[16] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82,
    14. 0xf8, 0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e};
    15. //************************************************
    16. //函数声明
    17. unsigned char GetKey(void);
    18. void delay10ms(void);
    19.  
    20. void delay10ms(void)   //误差 0us
    21. {
    22.     unsigned char a,b,c;
    23.     for(c=5;c>0;c--)
    24.         for(b=4;b>0;b--)
    25.             for(a=248;a>0;a--);
    26. }
    27.  
    28. void main(){
    29. 	
    30. 	unsigned char key=0;
    31. 	while(1){
    32. 		key=3;
    33. 		//key=GetKey();
    34. 		if(key!=0){
    35. 			DIG=val[key];
    36. 		}
    37. 	}	
    38. }
    39.  
    40. unsigned char GetKey(void){
    41. 	
    42. 	//定义行列
    43. 	unsigned char hang=0,lie=0;
    44. 	//显示当前按下的按键的键值
    45. 	unsigned char keyvalue=0;
    46. 	
    47. 	
    48. 	//【第一回合第一步】输出
    49. 	KEY=0x0f;		//从IO口输出，写IO口
    50. 	
    51. 	//因为KEY是接IO空，所以中间KEY可能会变
    52. 	if(KEY!=0x0f){		//从IO口输入，读IO口
    53. 		//读出的不是0x0f说明有按键被按下
    54. 		//【第一回合第2步】：读出端口从读出值来判断是哪一行
    55. 		
    56. 		//因为按键会出现显示效果不太符合，所以这里需要消抖
    57. 		delay10ms();
    58. 		
    59. 		//1.算出行号
    60. 		switch(KEY){
    61. 			case 0x0e:hang=1;	break;
    62. 			case 0x0d:hang=2;	break;
    63. 			case 0x0b:hang=3;	break;
    64. 			case 0x07:hang=4;	break;
    65. 			default:break;
    66. 		}
    67. 		
    68. 	
    69. 	 }
    70. 		//【第二回合第1步】
    71. 		KEY=0xf0;
    72. 		if(KEY!=0xf0){
    73. 			
    74. 			delay10ms();
    75. 			
    76. 			//1.算出列号
    77. 			switch(KEY){
    78. 				case 0xe0:lie=1;	break;
    79. 				case 0xd0:lie=2;	break;
    80. 				case 0xb0:lie=3;	break;
    81. 				case 0x70:lie=4;	break;
    82. 				default:break;
    83. 			}
    84. 		
    85. 				//经过2个回合后hang和lie都知道了，然后根据hang和lie计算出键值
    86. 				//（行-1）*4+列=键值
    87. 				keyvalue=(hang-1)*4+lie;
    88. 				return keyvalue;
    89. 			
    90. 			}
    91. }

    10.为什么未按下按键是高电平

     在MCU内部有一个约100K欧姆的电阻，上拉电阻约为1K欧姆

    串联分压

    并联分流

    11.为什么要初始化0x0f和0xf0

    但是上拉电阻位于MCU内部

    初始化0xf0：

    可以判断哪一个行被按下

    初始化0x0f

  • 相关阅读:
    使用hashicorp Raft开发分布式服务
    Maven入门
    【蓝桥杯2025备赛】集合求和
    css中flex和flex-grow的区别
    Spring中拦截器重复注册的问题排查
    【.NET项目分享】免费开源的静态博客生成工具EasyBlog,5分钟拥有自己的博客
    5-网络架构和Netty系列-Bootstrap和Channel源码分析
    文件上传学习笔记
    面向对象编程原则(06)——依赖倒转原则
    大语言模型LLM微调技术深度解析：Fine-tuning、Adapter-Tuning与Prompt Tuning的作用机制、流程及实践应用（LLM系列08）
  • 原文地址：https://blog.csdn.net/m0_63077733/article/details/133241785