• 一个51单片机键盘扫描程序,算法简单有效  发一个51单片机键盘扫描程序,算法简单有效   再给大家分享一个不错按键程序(来自ourdev) /****************************************  键盘_不采用...
    一个51单片机的键盘扫描程序,算法简单有效 


    发一个51单片机的键盘扫描程序,算法简单有效 
                                          再给大家分享一个不错按键程序(来自ourdev)
    /**************************************** 


    键盘_不采用定时器_不延时 


    特点: 
    按键在松手后有效,灵敏度高,消耗资源少,运行效率高 


    独立键盘为:K01=P2^4;K02=P2^5;K03=P2^6;K04=P2^7; 
    矩阵键盘为:行(上到下)_P2.3_P2.2_P2.1_P2.0 
               列(左到右)_P2.7_P2.6_P2.5_P2.4 


    提供的操作函数: 


    //独立键盘.无按键动作时其返回值num_key=0,否则返回按键号num_key 
    extern unsigned char keyboard_self(); 


    //矩阵键盘.无按键动作时其返回值num_key=0,否则返回按键号num_key****检测高四位 
    extern unsigned char keyboard_matrix(); 


    ****************************************/


    .
     


    先看独立键盘(和矩阵键盘的算法一样) 
    ----------------------------------------------------------------------- 
    #include<reg52.h> 
    #include<intrins.h> 


    //独立键盘.无按键动作时其返回值num_key=0,否则返回按键号num_key 
    extern unsigned char keyboard_self() 

            unsigned char num_key=0;//按键号 
            unsigned char temp=0;//用于读取P2线上按键值 
            static unsigned char temp_code=0;//保存按键值 
            static unsigned char num_check=0;//低电平有效次数 
            static unsigned char key_flag=0;//按键有效标识 


            temp=P2&0xF0;//读取P2线数据 


            if(temp!=0xF0)//低电平判断 
            { 
                    num_check++; 
                    if(num_check==10)//连续10次(10ms)低电平有效,则认为按键有效 
                    { 
                            key_flag=1;//使能按键有效标识 
                            temp_code=temp;//保存按键值 
                    } 
            } 
            else//松手时判断 
            { 
                    num_check=0; 


                    if(key_flag==1)//按键有效 
                    { 
                            key_flag=0; 


                            switch(temp_code)//读取按键号 
                            { 
                                    case 0xE0: num_key=1; 
                                               break; 
                                    case 0xD0: num_key=2; 
                                               break; 
                                    case 0xB0: num_key=3; 
                                               break; 
                                    case 0x70: num_key=4; 
                                               break; 
                            } 
                    } 
            } 


            return(num_key); 

     


    现在是矩阵键盘的 
    ----------------------------------------------------------------------- 
    #include<reg52.h> 
    #include<intrins.h>  


    //矩阵键盘.无按键动作时其返回值num_key=0,否则返回按键号num_key****检测高四位 
    extern unsigned char keyboard_matrix() 

            unsigned char num_key=0;//按键号 
            unsigned char temp=0;//读取P2口线数据 
            static unsigned char temp_code=0;//用于保存按键值 
            static unsigned char temp_circle=0xFE;//保存P2线上的循环扫描值 
            static unsigned char num_check=0;//低电平计数 
            static unsigned char key_flag=0;//按键有效标识 


            P2=temp_circle;//0xFX 
            temp=P2;//读取P2口线数据 
            if(temp!=temp_circle)//有按键动作 
            { 
                    num_check++;//低电平计数|逢低电平加1 
                    if(num_check==10)//连续10次(10ms)低电平有效 
                    { 
                            key_flag=1;//按键有效标识置1 
                            temp_code=temp;//保存按键值 
                    } 
            } 
            else//松手OR无按键动作,此时应该改变扫描线 
            { 
                    num_check=0; 
                    if(key_flag==1)//按键有效判断 
                    { 
                            key_flag=0; 
                            switch(temp_code)//读取按键号 
                            { 
                                    //P2^0线 
                                    case 0xEE: num_key=1; 
                                               break; 
                                    case 0xDE: num_key=2; 
                                               break; 
                                    case 0xBE: num_key=3; 
                                               break; 
                                    case 0x7E: num_key=4; 
                                               break; 
                                    //P2^1线 
                                    case 0xED: num_key=5; 
                                               break; 
                                    case 0xDD: num_key=6; 
                                               break; 
                                    case 0xBD: num_key=7; 
                                               break; 
                                    case 0x7D: num_key=8; 
                                               break; 
                                    //P2^2线 
                                    case 0xEB: num_key=9; 
                                               break; 
                                    case 0xDB: num_key=10; 
                                               break; 
                                    case 0xBB: num_key=11; 
                                               break; 
                                    case 0x7B: num_key=12; 
                                               break; 
                                    //P2^3线 
                                    case 0xE7: num_key=13; 
                                               break; 
                                    case 0xD7: num_key=14; 
                                               break; 
                                    case 0xB7: num_key=15; 
                                               break; 
                                    case 0x77: num_key=16; 
                                               break; 
                            } 
                    } 
                    temp_circle=_crol_(temp_circle,1);//改变扫描线 
                    if(temp_circle==0xEF) 
                    { 
                            temp_circle=0xFE; 
                    } 
            } 
            return(num_key);//返回按键号 



    /************************************************************************* 


    未按键时,扫描线一直变化。 
    长按键时,扫描线不变化,使得该行按键变成了独立按键,这样的扫描效率极高。 
    如当按下P2.0线上的某个键时,程序将扫描到这个键,而后扫描线不变化, 
    当键盘程序连续10次进入时检测到10次按键有效,直到松手后扫描线才变化 


    *************************************************************************/


    http://bbs.elecfans.com/jishu_184831_1_1.html


    展开全文
  • 51单片机矩阵键盘C程序主程序1:void main() { uchar i,j,k i=0; j=0; while(1) { i=key();//键盘循环扫描,其值赋给变量数组table if(i!=0)//键盘子程序返回值非0,即有按键按下 { table[j]=i;//将值存在...

    飞哥语录:别高估关系,别低估人心。

    主程序1:

    void main()
    {
       uchar i,j,k
       i=0;
       j=0;
       while(1)
       {
          i=key();//键盘循环扫描,其值赋给变量数组table
          if(i!=0)//键盘子程序返回值非0,即有按键按下
          {
              table[j]=i;//将值存在变量数组中
    
    j++;                                                          
          }
          if(j==6)
          {
             j=0;
             for(k=0;k<6;k++)//当数组存满6位时核对
             {
                 P3=table[k];//P3接有一排指示灯
                 delay (1000);//延时1S    
             }
          }
       }
    }
    

    主程序2:

    main(){
    int i,j,a[2][5]={10,15,25,15,75,15,45,65,85,95};
    for(i=0;i<2;i++)
    for(j=0;j<5;j++){
    printf("%d ",a[i][j]);
    }
    printf("\n");
    }
    

    主程序3:

    由键盘输入一个3×4矩阵a,选出各列最小的元素组成一个一维数组b并输出
    由键盘输入一个3×4矩阵a,选出各列最小的元素组成一个一维数组b并输出

    #include "stdio.h"
    #include "conio.h"
    
    void main()
    {
    int i,j,a[3][4],b[4],min;
    for(i=0;i<3;i++)
    for(j=0;j<4;j++)
    scanf("%d",&a[i][j]);
    for(i=0;i<4;i++)
    b[i]=a[0][i];
    for (i=0;i<4;i++)
    for(j=1;j<2;j++)
    if(a[i][j]<b[i]) b[i]=a[i][j];
    for(i=0;i<4;i++)
    printf("%d",b[i]);
        getch();
    }
    

    好了,今天的分享就到这里,分享一句话作为今天文章的结尾吧:梦里求她千百度,蓦然回首,那人却在灯火阑珊处。

    展开全文
  • 51单片机矩阵键盘响应程序 #include // P0端口接LED // P0端口接数码管 // P3端口接矩阵键盘 #define LED P0 #define KEY P3 #define DIG P0 unsigned char GetKey(void); void delay10ms(void); /...

    51单片机矩阵键盘响应程序

    #include <reg51.h>

    // P0端口接LED
    // P0端口接数码管
    // P3端口接矩阵键盘


    #define LED P0
    #define KEY P3
    #define DIG P0
    unsigned char GetKey(void);
    void delay10ms(void);
    // 独立数码管的段码表
    unsigned char val[16] = {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90, 0x88, 0x83, 0xc6, 0xa1, 0x86, 0x8e};
    void main(void)
    {
    unsigned char key = 0;
    while (1)
    {
    key = GetKey();
    if (key != 0)
    {
    DIG = val[key];
    }
    }
    }
    unsigned char GetKey(void)
    {
    unsigned char hang = 0, lie = 0;
    unsigned char keyvalue = 0;
    // 第1回合第1步
    KEY = 0x0f; // 从IO口输出,写IO口
    if (KEY != 0x0f)// 从IO口输入,读IO口
    {
    // 读出的不是0x0f说明有按键被按下
    // 第1回合第2步:读出端口从读出值来判断是哪一行
     delay10ms();
    // 第一回合中算出行号
    switch (KEY)
    {
    case 0x0e:hang = 1; break;
    case 0x0d: hang = 2; break;
    case 0x0b: hang = 3; break;
    case 0x07: hang = 4; break;
    default: break;
    }
    // 第2回合第1步
    KEY = 0xf0;
    if (KEY != 0xf0)
    {
     switch (KEY)
    {
    case 0xe0:lie = 1; break;
    case 0xd0: lie = 2; break;
    case 0xb0: lie = 3; break;
    case 0x70: lie = 4; break;
    default: break;
    }
    // 经过2个回合后hang和lie都知道了,然后根据hang和lie去计算键值即可
    keyvalue = (hang - 1) * 4 + lie;
    return keyvalue;
    }
    }
    return 0;
    }
    void delay10ms(void)   //误差 0us
    {
        unsigned char a,b,c;
        for(c=5;c>0;c--)
            for(b=4;b>0;b--)
                for(a=248;a>0;a--);
    }


    展开全文
  • 我这按键是机械弹性按键,所以具有弹性,按键在按下和松开的瞬间均伴随有一连串的抖动,键抖动会引起一次按键被误读多次,然后为了保证cpu对键的一次闭合仅作一次处理,所以我们必须去除抖动。去除抖动有2种,硬件消...

    我这按键是机械弹性按键,所以具有弹性,按键在按下和松开的瞬间均伴随有一连串的抖动,键抖动会引起一次按键被误

    读多次,然后为了保证cpu对键的一次闭合仅作一次处理,所以我们必须去除抖动。去除抖动有2种,硬件消抖和软件消抖。
    其中一软件消抖最方便。所以我就以软件消抖为例。



         独立按键的原理图和led的原理图如上,8个led的阳极都接了vcc(vcc认为是电源正极,gnd认为是电源负极),所以只需要led的阴极接的p2i(i取值0到7)口输入低电平(即0v)对应的led就可以发亮了.

    接下来看看独立按键的原理图,首先K1是和rxd管脚相连的,然后rxd管脚又是和P3^1口连接的,所以可以P3^1口是和k1开关连接的,可以知道当k1按键按下时电路就导通了,因为k1右边接了gnd,所以P3^1这个io口的输出电平就被拉低变0电平了。(p31io口电平能被拉低是因为P3口是准双向io口),所以我们可以通过判断P3^1io口的电平来获知按键的状态,P3^1==1,则按键k1没有按下,P3^1==0,则按键k1按下了。
    接下来展示一个通过独立键盘里的按键k1来控制led1的亮灭的程序

    #include<reg52.h>
    sbit led1=P2^0;//因为led1由p2^0口控制
    sbit k1=P3^1;//P31口的输出电平由按键k1控制
    void delay(int i)
    {
    	while(i--);
    }
    void keyproc()
    {
    	if(k1==0)
    	{
    		delay(1000);//延时消抖
    		if(k1==0)
    		{
    			led1=~led1;////led1状态反转,亮变灭,灭变亮
    		}
    		while(!k1) ;
    		
    	}
    }
    void main()
    {
    	while(1)
    	{
    		keyproc();
    	}
    }

    把这代码烧到单片机后,我们一按k1,led1就会亮,再按一次就会灭,一直这样下去


    展开全文
  • /*用矩阵键盘输入数字在数码管显示*/矩阵键盘代码的编写有点像VHDL 编码器的书写,很多那些数字都是根据唯一的扫描位置来定,也就是说这些数字可以任意设置,主要就是巧妙在“0xf0&0xfe” 通过这样确定出一定的位置...
    /*用矩阵键盘输入数字在数码管显示*/
    矩阵键盘代码的编写有点像VHDL 编码器的书写,很多那些数字都是根据唯一的扫描位置来定,也就是说这些数字可以任意设置,主要就是巧妙在“
    0xf0&0xfe” 通过这样确定出一定的位置,然后“编码”为你想要位置所代表的数字。矩阵键盘其实代码都很固定,很多东西其实也可以算是一沉不变的,
    作为初学者继续加油吧!
    
    
    
    
    #include<reg52.h>
    #define uint unsigned int
    #define uchar unsigned char
    sbit dula=P2^6;
    sbit wela=P2^7;
    sbit key1=P3^4;
    uchar code table[]={
    0x3f,0x06,0x5b,0x4f,
    0x66,0x6d,0x7d,0x07,
    0x7f,0x6f,0x77,0x7c,
    0x39,0x5e,0x79,0x71,0};
    uchar num,temp,num1;
    void delay(uint z)
    {
    	uint x,y;
    	for(x=z;x>0;x--)
    		for(y=110;y>0;y--);
    }
    uchar keyscan();
    void display(uchar aa);
    void main()
    {
    	num=17;
    	dula=1;
    	P0=0;
    	dula=0;
    	wela=1;
    	P0=0x00;
    	wela=0;
    	
    	while(1)
    		{
    			display(keyscan());
    		}
    }
    void display(uchar aa)
    {
    			dula=1;
    			P0=table[aa-1];
    			dula=0;		
    }
    uchar keyscan()
    {
    			P3=0xfe;
    			temp=P3;
    			temp=temp&0xf0;	  //0xf0&0xfe
    			while(temp!=0xf0)
    				{
    					delay(5);
    					temp=P3;
    					temp=temp&0xf0;	//延时消抖
    					while(temp!=0xf0)
    					{
    						temp=P3;
    					switch(temp)
    						{
    							case 0xee:num=1;
    								break;
    							case 0xde:num=2;
    								break;
    							case 0xbe:num=3;
    								break;
    							case 0x7e:num=4;
    								break;
    						}
    					while(temp!=0xf0)
    						{
    							temp=P3;
    							temp=temp&0xf0;
    						}
    					}
    				}
    
    			P3=0xfd;
    			temp=P3;
    			temp=temp&0xf0;
    			while(temp!=0xf0)
    				{
    					delay(5);
    					temp=P3;
    					temp=temp&0xf0;
    					while(temp!=0xf0)
    					{
    						temp=P3;
    					switch(temp)
    						{
    							case 0xed:num=5;
    								break;
    							case 0xdd:num=6;
    								break;
    							case 0xbd:num=7;
    								break;
    							case 0x7d:num=8;
    								break;
    						}
    					while(temp!=0xf0)
    						{
    							temp=P3;
    							temp=temp&0xf0;
    						}
    					}
    				}
    
    
    			P3=0xfb;
    			temp=P3;
    			temp=temp&0xf0;
    			while(temp!=0xf0)
    				{
    					delay(5);
    					temp=P3;
    					temp=temp&0xf0;
    					while(temp!=0xf0)
    					{
    						temp=P3;
    					switch(temp)
    						{
    							case 0xeb:num=9;
    								break;
    							case 0xdb:num=10;
    								break;
    							case 0xbb:num=11;
    								break;
    							case 0x7b:num=12;
    								break;
    						}
    					while(temp!=0xf0)
    						{
    							temp=P3;
    							temp=temp&0xf0;
    						}
    					}
    				}
    
    
    			P3=0xf7;
    			temp=P3;
    			temp=temp&0xf0;
    			while(temp!=0xf0)
    				{
    					delay(5);
    					temp=P3;
    					temp=temp&0xf0;
    					while(temp!=0xf0)
    					{
    						temp=P3;
    					switch(temp)
    						{
    							case 0xe7:num=13;
    								break;
    							case 0xd7:num=14;
    								break;
    							case 0xb7:num=15;
    								break;
    							case 0x77:num=16;
    								break;
    						}
    					while(temp!=0xf0)
    						{
    							temp=P3;
    							temp=temp&0xf0;
    						}
    					}
    				}
    return num;
    
    }

    展开全文
  • 目的:利用“模块化单片机教学实验平台”,加深对单片机与矩阵键盘的接口电路设计以及程序设计的理解。 任务:1、学习独立式按键的查询识别方法。 2、非编码矩阵键盘的行反转法识别方法。 3、掌握键盘接口的基本...
  • c51单片机矩阵键盘扫描实现代码
  • #include<reg52.h> typedef unsigned char uchar; typedef unsigned int uint; sbit a=P1^0;...uchar code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00}...
  • 矩阵键盘扫描原理详解根据原理图 键盘扫描方法是:行线P10~P13为输出线,列线P14~P17为输入线。一开始单片机将行线(P10~P13)全部输出低电平,此时读入列线数据,若列线全为高电平则没有键按下,当列线有出现低电...
  • 名称:矩阵键盘依次输入控制 使用行列逐级扫描 中断方式 内容:如计算器输入数据形式相同 从右至左 使用行列扫描方法 中断方式可以有效提供cpu工作效率,在有按键动作时才扫描,平时不进行扫描工作
  • 51单片机c语言4x4矩阵键盘实验详细操作
  • 1.认识按键 如上图所示为直插式按键,按下按键后松手按键立即弹起。有4个引脚,可以看出4各引脚每两个向内弯曲,弯曲的对立面两个引脚导通,其余不导通。即1和4之间是导通的,2和3之间是导通的,而1和2,3和4之间...
  • 键盘键值读取程序

    2020-06-04 23:30:35
    chw说明: 本程序将键盘发送到单片机的信息,以16进制方式送入电脑RS232口, 电脑串口接收软件为《串口调试助手V2.2》 串口发送波特率为9600 格式:N.8.1 这是本人编写的键盘数据读出程序,可以将键盘...
  • //地址:http://www.jdgcs.org/wiki/Downloads #include &lt;at89x51.h&gt; #include "KBCODE.H" #define LCM_RS P2_0 #define LCM_RW P2_1 //定义LCD引脚 #define LCM_E P2_2 ...#define Busy...
  • 关注【电子开发圈】微信公众号,一起学习吧!...电子DIY、Arduino、51单片机、STM32单片机、FPGA…… 电子百科、开发技术、职业经验、趣味知识、科技头条、设备拆机…… 点击链接,免费下载100G+电子设计学习资料! ...
  • 矩阵键盘单片机外部设备中所使用的排布类似于矩阵的键盘组,由于电路设计时需要更多的外部输入,单独的控制一个按键需要浪费很多的IO资源,所以就有了矩阵键盘,常用的矩阵键盘有4*4和8*8,其中用的最多的是4*4。...
  • 矩阵键盘单片机外部设备中所使用的排布类似于矩阵的键盘组。矩阵式结构的键盘显然比直接法要复杂一些,识别也要复杂一些,列线通过电阻接正电源,并将行线所接的单片机的I/O口作为输出端,而列线所接的I/O口则作为...
  • 在《51单片机(二十九)—— 矩阵键盘输入实验》中,我们对矩阵键盘的原理及使用方法进行了介绍。在本文中,我们采用矩阵键盘设计一个计算器,实现简单的计算器功能。 这个实验的代码的主函数如下所示。 main() ...
  • 单片机-键盘检测

    2020-02-06 21:18:39
    键盘检测原理及应用 独立键盘检测 通常用到的按键都是机械弹性开关,当开关闭合时,线路导通,开关断开时,线路断开 弹性按键:按下时闭合,松手后自动断开 自锁式按键:按下时闭合且会自动锁住,只有再次按下...
  • 单片机系统键盘的设计结 一、概述 键盘单片机应用系统中,实现输入数据、传送命令的功能,是人工干预的主要手段。键盘分两大类:编码键盘和非编码键盘。 编码键盘:由硬件逻辑电路完成必要的键识别...
1 2 3 4 5 ... 20
收藏数 3,263
精华内容 1,305