矩阵键盘_矩阵键盘扫描 - CSDN
矩阵键盘 订阅
矩阵键盘是单片机外部设备中所使用的排布类似于矩阵的键盘组。矩阵式结构的键盘显然比直接法要复杂一些,识别也要复杂一些,列线通过电阻接正电源,并将行线所接的单片机的I/O口作为输出端,而列线所接的I/O口则作为输入。 展开全文
矩阵键盘是单片机外部设备中所使用的排布类似于矩阵的键盘组。矩阵式结构的键盘显然比直接法要复杂一些,识别也要复杂一些,列线通过电阻接正电源,并将行线所接的单片机的I/O口作为输出端,而列线所接的I/O口则作为输入。
信息
适    用
单片机外部设备中所使用
识别方法
矩阵的键盘比直接法要复杂一些
作    用
切换中控式HDMI矩阵信号源
中文名
矩阵键盘
外文名
Matrix keyboard
本    质
类似于矩阵的键盘组
矩阵键盘组成结构
在键盘中按键数量较多时,为了减少I/O口的占用,通常将按键排列成矩阵形式。在矩阵式键盘中,每条水平线和垂直线在交叉处不直接连通,而是通过一个按键加以连接。这样,一个端口(如P1口)就可以构成4*4=16个按键,比之直接将端口线用于键盘多出了一倍,而且线数越多,区别越明显,比如再多加一条线就可以构成20键的键盘,而直接用端口线则只能多出一键(9键)。由此可见,在需要的键数比较多时,采用矩阵法来做键盘是合理的。
收起全文
精华内容
参与话题
  • 矩阵键盘扫描原理详解——单片机

    万次阅读 多人点赞 2016-04-07 20:12:00
    矩阵键盘扫描原理详解根据原理图 键盘扫描方法是:行线P10~P13为输出线,列线P14~P17为输入线。一开始单片机将行线(P10~P13)全部输出低电平,此时读入列线数据,若列线全为高电平则没有键按下,当列线有出现低电...

    矩阵键盘扫描原理详解


    这里写图片描述


    根据原理图
    键盘扫描方法是:行线P10~P13为输出线,列线P14~P17为输入线。一开始单片机将行线(P10~P13)全部输出低电平,此时读入列线数据,若列线全为高电平则没有键按下,当列线有出现低电平时调用延时程序以此来去除按键抖动。延时完成后再判断是否有低电平,如果此时读入列线数据还是有低电平,则说明确实有键按下。最后一步确定键值。现在我们以第二行的S5键为例,若按下S5后我们应该怎么得到这个键值呢?当判断确实有键按下之后,行线轮流输出低电平,根据读入列线的数据可以确定键值。首先,单片机将P10输出为低电平,其它P11~P13输出高电平,此时读取列线的数据全为高电平,说明没有在第一行有键按下;其次,单片机将P11输出低电平,其它P10、P12、P13仍为高电平,此时再来读取列线数据,发现列线读到的数据有低电平,数值为1011(0x0B),如果我们的键盘布局已经确定,那么0x0B就代表S5的值了。转到S5键功能处理子程序就可以达到目的。


    /*  
        功能:矩阵键盘扫面,按键显示键值程序 
        作者:siriuszxn
                                      */
    #include "reg51.h"                                                                                                                
    #define KEYPORT = P1                                                                                                   
    
    unsigned char i;                                                                                                                                         
    unsigned char Keynum;                                                                                                        
    unsigned char Line;                                       //行                                                                 
    unsigned char Mask;                                                                                                         
    unsigned char Col;                                        //列                                                                      
    unsigned char ScanCode;                                                                                              
    
    unsigned char code psegs_table[] =                                                                                            {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x88,0x83,0xc6,0xa1,0x86,0x8e};                                                                //共阳极数码管0-F                                                                                                                                            
    
    void delay_ms(unsigned int t)                      //ms延时程序                                                                      
    {                                                                                                                                       
        unsigned char i;                                                                                                                 
         unsigned int x;                                                                                                                  
         x=t;                                                                                                                              
         while(x--)                                                                                                                        
         {                                                                                                                                          
                 for(i=0;i<113;i++);                                                                                                              
         }                                                                                                                                           
    }                                                                                                                                        
    /* 键盘扫描程序 */                                                                                                                                        
    void keyscan()                                                                                                           
    {                                                                                                                                   
        while (1)              //循环扫描键盘       
        {                                                                                                                            
           P1 = 0xff;          //开始                                                         
            Line = 1;                                                                                         
            Mask = 0x01;                                                                                         
    
            for(i = 0; i < 4; i++)                                                                                   
            {                                                                                                                                                                                    
                P1 = ~Mask;                                                                                    
    
                ScanCode = P1 & 0xf0;                                                                                          
    
                if (ScanCode != 0xf0)                                                                                         
                {                                                                                                                                                                                    
                    delay_ms(5);                                                                               
                }                                                                                                                                                                                    
    
                ScanCode = P1 & 0xf0;                                                                                          
    
                switch(ScanCode)                                                
                {                                                                                                                                                                                    
                    case 0xe0:Col=1;break;                                                                                          
                    case 0xd0:Col=2;break;                                                                   
                    case 0xb0:Col=3;break;                                                                          
                    case 0x70:Col=4;break;                                                                  
                    default  :Col=0;break;                                                                                          
                }                                                                                                                                                                                    
    
                if (Col > 0)                                                                                                                                           
                {   
                    //根据行列计算键值                                                                                                                                                         
                    Keynum = (Line - 1) * 4 + Col;                                                                  
                    //通过P0口接数码管显示                                                                                                          
                    P0 = psegs_table[Keynum-1];                                                                                          
    
                    while(1)                                                                                           
                    {                                                                                
                        ScanCode = P1 & 0xf0;                                                                                
                        if(ScanCode == 0xf0)                                                               
                        {                                                                                                                                              
                            break;                                                    
                        }                                                                                                                       
                    }                                                                                
                    Mask <<= 1;                                                                                                      
                    Line++;                                                                                                 
                }                                                                                                                        
            }                                                                                                                                      
        }  
    }                                                                                                                                   
    
    void main()                                                                                         
    {                                                                                                                                     
        while(1)                                                                                                                      
        {                                                                                                                                 
            keyscan();                                                                                         
        }                                                                                                                                 
    }                                                                      
    展开全文
  • 单片机读入4*4矩阵键盘

    万次阅读 多人点赞 2015-12-03 11:55:17
    矩阵键盘是单片机外部设备中所使用的排布类似于矩阵的键盘组,由于电路设计时需要更多的外部输入,单独的控制一个按键需要浪费很多的IO资源,所以就有了矩阵键盘,常用的矩阵键盘有4*4和8*8,其中用的最多的是4*4。...
    一、什么是矩阵键盘
    矩阵键盘是单片机外部设备中所使用的排布类似于矩阵的键盘组,由于电路设计时需要更多的外部输入,单独的控制一个按键需要浪费很多的IO资源,所以就有了矩阵键盘,常用的矩阵键盘有4*4和8*8,其中用的最多的是4*4。
    网上搜了两张实物图,大家可以看看



    看上图就知道,4*4键盘还是很多地方用到的吧^_^

    二、矩阵键盘的原理
    矩阵键盘又称为行列式键盘,它是用4条I/O线作为行线,4条I/O线作为列线组成的键盘。
    在行线和列线的每一个交叉点上,设置一个按键。这样键盘中按键的个数是4×4个。
    这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率。由于单片机IO端口具
    有线与的功能,因此当任意一个按键按下时,行和列都有一根线被线与,通过运算就可以
    得出按键的坐标从而判断按键键值。

    原理如同矩阵数列的行列式



    三、驱动电路图

    按4*4矩阵搭建的按键矩阵还是比较简单的,也有的人为了保证电路的稳定性,加上二极管保护和上拉电阻,但是一般要求不太高的电路就不需要加了,向下面设置的电路那样就可以


    四、软件程序设计

    根据4*4键盘的原理软件设计程序如下:


    //***************************************************
    //函数功能:
    //单片机驱动4*4键盘,读入键盘值并使用数码管静态
    //显示按键键值,若没有数码管用8421码显示LED灯也可以的
    //读入原理:先令单片机端口输出11110000读一次,然后
    //再令单片机输出00001111读一次把两次的值相加,最后
    //获取一个高位和低位分别有0的值即可判断键值,
    //如11101110
    //***************************************************
    #include<reg52.h>
    #define uchar unsigned char 
    #define uint unsigned int 
    
    unsigned char code smg_d[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
    
    //************************************************
    //延时函数,在12MHz的晶振频率下
    //大约50us的延时
    //************************************************
    void delay_50us(uint t)
    {
     uchar j;
     for(;t>0;t--)
            for(j=19;j>0;j--);
    }
    
    void main()
    {
     uchar key_l,key_h;
     uchar key;
     while(1)
     {
     P1=0xf0;
     key_l=P1;			//读P1端口的值
     key_l=key_l&0xf0;  //令低4位置位为0
     if(key_l!=0xf0)    //判断是否有按键按下
     {
      delay_50us(100);
      if(key_l!=0xf0)
      {					//若有按键按下,则切换高低4位判断键值
       key_l=P1&0xf0;   //11100000	获取第一次键值
       key_l=key_l|0x0f;//11101111   
       P1=key_l;        //反过来再读一次,由于人手按下按键的时间虽然短暂,但是
       key_h=P1;        //对于单片机来说,已经足够长,因此可以正反读取两次值
       key_h=key_h&0x0f;//00001110
       key_l=key_l&0xf0;//11100000
       key=key_h+key_l; //11101110
      }
     }
     switch (key)
     {
      case 0xee:P2=smg_d[0];break;
      case 0xde:P2=smg_d[1];break;
      case 0xbe:P2=smg_d[2];break;
      case 0x7e:P2=smg_d[3];break;
      case 0xed:P2=smg_d[4];break;
      case 0xdd:P2=smg_d[5];break;
      case 0xbd:P2=smg_d[6];break;
      case 0x7d:P2=smg_d[7];break;
      case 0xeb:P2=smg_d[8];break;
      case 0xdb:P2=smg_d[9];break;
      case 0xbb:P2=smg_d[10];break;
      case 0x7b:P2=smg_d[11];break;
      case 0xe7:P2=smg_d[12];break;
      case 0xd7:P2=smg_d[13];break;
      case 0xb7:P2=smg_d[14];break;
      case 0x77:P2=smg_d[15];break;
     }
     }
    }


    展开全文
  • 矩阵键盘的原理及应用

    万次阅读 多人点赞 2018-05-16 12:07:01
    矩阵键盘原理图:第一行的行控制线接到p17,第二行的行控制线接到p16,第三行的行控制线接到p15,第4行的行控制线接到p14第一列的列控制线接到p13,第二列的列控制线接到p12,第三列的列控制线接到p11,第四列的列...

    矩阵键盘原理图:
    第一行的行控制线接到p17,第二行的行控制线接到p16,第三行的行控制线接到p15,第4行的行控制线接到p14
    第一列的列控制线接到p13,第二列的列控制线接到p12,第三列的列控制线接到p11,第四列的列控制线接到p10

    矩阵键盘的原理和独立按键类似,另外我们可以把矩阵键盘的任意一行或一列作为一个独立键盘使用,假如我们把第一行作为独立键盘,那么我们只需要让P17输出高电平,其余7个io口输出低电平即可,假如我们按下了s1,那么p13的电平就会被拉低,变为低电平,所以我们可以通过查找低4位里哪一位为低电平就可以知道哪个按键按下了。

    下面来说说矩阵按键扫描原理(即当我们按下一个矩阵键盘的按键时,如何获取按键的位置)

    方法有2种,一种是逐行扫描,一种是行列扫描.接下来就主要讲讲行列扫描.

    行列扫描的话,就是一开始让p1口高4位输出高电平,低4位输出低电平,若这4行按键里,有按键按下了,那么那一行按键对应的io的电平就会被拉低,我们就可以知道按键的行坐标.获取按键列坐标的方法也是类似的,就是一开始让p1口高4位输出低电平,低4位输出高电平,若这4列按键里,有按键按下了,那么那一列按键对应的io的电平就会被拉低,我们就可以知道按键的列坐标,获得了行坐标x,列坐标y后,4*(x-1)+y就是按键的编号.
    接下来贴份应用的代码,目的就是赋予16个按键键值,分别对应的键值是从0~F。按下一个键,第一个数码管就显示对应的键值

    #include<reg52.h>
    sbit lsa=P2^2;
    sbit lsb=P2^3;
    sbit lsc=P2^4;
    #define duanxuan P0
    #define keyboard P1
    int zxm[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
    int x,y;
    void delay(int i)
    {
    	while(i--);
    }
    void keyproc()
    {
        int a=0;
    	P1=0x0f;//检测是哪一列有按键按下;
    	if(P1!=0x0f)
    	{
    		delay(1000);
    		if(P1!=0x0f)
    		{
    			P1=0x0f;
    			switch(P1)
    			{
    				case(0x07):y=1;break;
    				case(0x0b):y=2;break;
    				case(0x0d):y=3;break;
    				case(0x0e):y=4;break;
    			}
    		}
    		P1=0xf0;//检测是哪一行有按键按下
    		switch(P1)
    		{
    			case(0x70):x=1;break;
    			case(0xb0):x=2;break;
    			case(0xd0):x=3;break;
    			case(0xe0):x=4;break;
    		}
    		while(a<50&&P1!=0xf0)//当按键按下的时间超过了500ms或者按键松开了就退出while循环
    		{
    			delay(1000);
    			a++;
    		}
    		
    
    	}
    }
    int main()
    {
    	lsa=0;
    	lsb=0;
    	lsc=0;//位选选中第一个数码管
    	P0=0x00;//第一个数码管先什么都不显示
    	while(1)
    	{
    		keyproc();
    		P0=zxm[(x-1)*4+y-1];//送入段选信息
    		
    		
    	}
    	return 0;
    	
    }

    数码管和138译码器原理图:
    通过138译码器控制位选,例如p22输出电平为1,p23输出电平为0,p24输出电平为0,由p24,p23,p22构成了一个三位二进制数001,转换成10进制就是1,那么138译码器的输出端里y1就输出低电平到第二个数码管的com端,相当于位选选中了第二个数码管。
    每一个数码管的8段led都是共阴极的,只要给对应数码管的com端输入低电平,数码管就能亮,至于哪些段亮哪些不亮就通过p0口控制,

    展开全文
  • 4*4矩阵键盘

    千次阅读 2018-12-06 21:30:39
    在33基础上做的改进 33和44的基本思想相同,...所以就会想到用ASCII码实现,键盘大致字符位置如下: 由于上次已经附了基本的代码,所以这次只是写点基本算法 u8 KEY_Scan(u8 mode) { u8 l=0,h=0; static u8 key...

    在33基础上做的改进
    3
    3和44的基本思想相同,均是通过两次扫描分别判定按键所在行和列,然后通过计算显示出自己想显示的内容即可,因为本次44上除数字外会输出A B C D,# * .所以就会想到用ASCII码实现,键盘大致字符位置如下:
    在这里插入图片描述
    由于上次已经附了基本的代码,所以这次只是写点基本算法

    u8 KEY_Scan(u8 mode)
    {   
    	u8 l=0,h=0;
    	static u8 key_con=1;    //按键按松开标志
    	if(mode) key_con=1;     //支持连按
    	KEY_ROW_out1=0;         //行输出置低
    	KEY_ROW_out2=0;
    	KEY_ROW_out3=0;
    	KEY_ROW_out4=0;
    	
    	KEY_Init1();
    	
        KEY_ROL_out1=1;          //列输出置高
    	KEY_ROL_out2=1;
    	KEY_ROL_out3=1;
    	KEY_ROL_out4=1;
    	
        
    	if(key_con&&(KEY_ROW_in1==1||KEY_ROW_in2==1||KEY_ROW_in3==1||KEY_ROW_in4==1)) //检测按下的按键所在行
    	{
    	  delay_ms(10);
    	  key_con=0;
    	  if(KEY_ROW_in1==1)   h=1;                                   //返回行值
    	   else if(KEY_ROW_in2==1)  h=2;
             else if(KEY_ROW_in3==1)   h=3;
    		   else if(KEY_ROW_in4==1)    h=4;
    	}
    	else if(KEY_ROW_in1==0&&KEY_ROW_in2==0&&KEY_ROW_in3==0&&KEY_ROW_in4==0)       //无按键按下
    	{
    	  key_con=1;                                                   
    	  return 0;
    	}
    	KEY_ROL_out1=0;                                               //二次扫描 列输出置低
    	KEY_ROL_out2=0;
    	KEY_ROL_out3=0;
    	KEY_ROL_out4=0;
    	
    	KEY_Init2();
    	
    	KEY_ROW_out1=1;                                               //行输出置高
    	KEY_ROW_out2=1;
    	KEY_ROW_out3=1;
    	KEY_ROW_out4=1;
    	
        if(KEY_ROL_in1==1||KEY_ROL_in2==1||KEY_ROL_in3==1||KEY_ROL_in4==1)            //检测按下的按键所在列
    	{
    	  if(KEY_ROL_in1==1) 
    	   { if(h==4) l='*';
    		   else l=(h-1)*3+49;
    	   }
    	    else if(KEY_ROL_in2==1) 
    		     {
    				
    		       if(h==4) l=48;
    			      else l=(h-1)*3+50;
    	      	 }		
    	      else if(KEY_ROL_in3==1)    
    		       { 
    				  if(h==4) l='#';
    				    else l=(h-1)*3+51;
    			   }
    		    else if(KEY_ROL_in4==1)   
    			      {
    				    l=64+h;
    				  }		
    	}
    	return l;
    }
    
    

    这个为主要函数 最终输出%c即可实现按键的一致输出

    展开全文
  • 矩阵键盘及其基本原理

    千次阅读 2019-06-02 18:41:40
    原理:矩阵键盘的原理就是分行和列扫描,来获知按下按键的行数和列数,然后得到按下按键的键值。 矩阵键盘的原理图及接线图如下: 因为四脚的微动按键的同一排引脚是相连的,相当于是一个同一个引脚,所以...
  • 矩阵键盘

    千次阅读 2019-05-27 12:02:56
    矩阵键盘原理图: 第一行的行控制线接到p17,第二行的行控制线接到p16,第三行的行控制线接到p15,第4行的行控制线接到p14 第一列的列控制线接到p13,第二列的列控制线接到p12,第三列的列控制线接到p11,...
  • 一、基本知识  1.按键分类与输入原理 按键按照结构原理科分为两类,一类是触点式开关按键,如机械式开关、导电橡胶式开关灯;另一类是无触点式开关按键,如电气式按键,磁感应按键等。前者造价低,后者寿命长。...
  • Arduino开发板使用矩阵键盘的方法

    千次阅读 2018-09-02 20:47:56
    键盘允许用户在程序运行时输入数据。本篇文章主要介绍如何将一个带有十二个按键的键盘连接到Arduino开发板以及如何使用库Keypad.h。 通常需要键盘来为Arduino开发板提供输入信号,而薄膜键盘是许多应用的经济型解决...
  • 键盘中按键数量较多时,为了减少对 I/O 口的占用,通常将按键排列成矩阵形式,也称为行列键盘,这是一种常见的连接方式。矩阵键盘接口见图 9-7 所示,它由行线和列线组成,按键位于行、列的交叉点上。当键被按下...
  • 矩阵键盘及去抖动

    万次阅读 2010-04-22 17:42:00
    键盘中按键数量较多时,为了减少I/O口的占用,通常将按键排列成矩阵形式,在矩阵键盘中,每条水平线和垂直线在交叉处不直接连通,而是通过一个按键加以连接。这样,一个端口(如P1口)就可以构成4*4=16个按键,比...
  • 矩阵键盘的中断模式

    千次阅读 2017-03-29 22:53:23
    矩阵键盘扫描会占用MCU大量的时间,为了节约时间使程序运行更加流畅,一般实用中断方式进行矩阵键盘的扫描工作。 上图中从上往下前8个管脚连接单片机的8个I/O,最后一个连接单片机的外部中断管脚,用来触发中断。
  • STM32F103的4*4矩阵按键,调试通过

    千次阅读 2016-04-09 01:26:08
    STM32F103的4*4矩阵按键,调试通过。多个按键同时触发的时候,以最后一个释放的按键值为准。 4*4表盘的显示数据可以由大家自己修订。 矩阵按键的扫描原理不再详述了。 下面附上代码,大家一同进步。
  • 11、C++键盘输入矩阵并打印结果

    千次阅读 2017-02-21 18:52:42
    C++ 键盘输入矩阵并打印结果
  • 矩阵键盘+数码管动态显示

    千次阅读 2018-05-16 21:45:42
    我把矩阵键盘和数码管动态显示综合起来写了个程序。这个代码的意思是在一开始8个数码管什么也不显示,因为p0的初始值是0x00,当我们按下矩阵按键里的按键时,8个数码管动态显示该按键的键值,直到按下了下一个按键,8...
  • 51单片机矩阵键盘响应程序

    万次阅读 2018-01-27 18:39:22
    51单片机矩阵键盘响应程序 #include // P0端口接LED // P0端口接数码管 // P3端口接矩阵键盘 #define LED P0 #define KEY P3 #define DIG P0 unsigned char GetKey(void); void delay10ms(void); /...
  • 矩阵键盘线反转法实现

    千次阅读 2019-03-03 22:23:46
    project: 线反转法扫描键盘,一位数码显示 ;version: 20130611 ;problems: 1.有时出现数码管显示相应数字后变暗闪烁,键盘失灵 ; a.尝试加全部键盘检测完,没有找到则返回主程序,没用 ; b.加...
  • #include int main() { int a[3][3],sum=0; int i,j; for(i=0;i;i++) for(j=0;j;j++) scanf("%d",&a[i][j]); for(i=0;i;i++) for(j=0;j;j++) if(i==j||(i+j==2)) sum=sum+a[i][j];
  • 4*4矩阵按键控制数码管显示0-F

    千次阅读 2017-01-23 09:17:14
    4*4矩阵按键原理图如下: 根据原理图,汇编程序代码如下: 4*4矩阵按键控制数码管显示0-F。刚学单片机汇编,是根据单片机C语言思路来写的,写的不好,如果发现有错误或会导致程序跑飞的,麻烦帮我指出,谢谢!
  • 薄膜4×4矩阵键盘内部电路

    万次阅读 2012-07-17 16:12:22
    薄膜4×4矩阵键盘内部电路 早就从朋友那里得到了一个薄膜4×4矩阵键盘,不会用,或者说是不敢用,因为不知道内部电路,一直也懒得上网查,因为这种键盘的类型很多,我怕查到不能用,浪费了时间。 今天晚上闲来无...
  • 矩阵键盘的连接方法和工作原理

    万次阅读 2009-10-16 14:34:00
    矩阵键盘的连接方法和工作原理什么是矩阵键盘?当键盘中按键数量较多时,为了减少I/O 口线的占用,通常将按键排列成矩阵形式。在矩阵键盘中,每条水平线和垂直线在交叉处不直接连通,而是通过一个按键加以连接...
1 2 3 4 5 ... 20
收藏数 22,761
精华内容 9,104
关键字:

矩阵键盘