GPIO 按键及矩阵键盘程序——/* 自己实验确认并总结 */

GPIO 按键及矩阵键盘程序——/* 自己实验确认并总结 */新型的按键扫描程序不过入式处理器上面我在网上游逛了很久,也看过不少源程序了,没有发现这种按键处理办法的踪迹,所以,我将他共享出来,和广大同僚们共勉。我非常坚信这种按键处理办法的便捷和高效,你可以移植到任何一种嵌,因为C语言强大的可移植性。同时,这里面用到了一些分层的思想,在单片机当中也是相当有用的,也是本文的另外一个重点。对于老鸟,我建议直接看那两个表达式,然后自己想想就会懂的了,

新型的按键扫描程序

不过入式处理器上面我在网上游逛了很久,也看过不少源程序了,没有发现这种按键处理办法的踪迹,所以,我将他共享出来,和广大同僚们共勉。我非常坚信这种按键处理办法的便捷和高效,你可以移植到任何一种嵌,因为C语言强大的可移植性。
同时,这里面用到了一些分层的思想,在单片机当中也是相当有用的,也是本文的另外一个重点。
对于老鸟,我建议直接看那两个表达式,然后自己想想就会懂的了,也不需要听我后面的自吹自擂了,我可没有班门弄斧的意思,hoho~~但是对于新手,我建议将全文看完。因为这是实际项目中总结出来的经验,学校里面学不到的东西。
以下假设你懂C语言,因为纯粹的C语言描述,所以和处理器平台无关,你可以在MCS-51,AVR,PIC,甚至是ARM平台上面测试这个程序性能。当然,我自己也是在多个项目用过,效果非常好的。
好了,工程人员的习惯,废话就应该少说,开始吧。以下我以AVR的MEGA8作为平台讲解,没有其它原因,因为我手头上只有AVR的板子而已没有51的。用51也可以,只是芯片初始化部分不同,还有寄存器名字不同而已。
核心算法:
unsigned char Trg;
unsigned char Cont;
void KeyRead( void )
{

unsigned char ReadData = PINB^0xff; // 1
Trg = ReadData & (ReadData ^ Cont); // 2
Cont = ReadData; // 3
}
完了。有没有一种不可思议的感觉?当然,没有想懂之前会那样,想懂之后就会惊叹于这算法的精妙!!
下面是程序解释:
Trg(triger) 代表的是触发,Cont(continue)代表的是连续按下。
1:读PORTB的端口数据,取反,然后送到ReadData 临时变量里面保存起来。
2:算法1,用来计算触发变量的。一个位与操作,一个异或操作,我想学过C语言都应该懂吧?Trg为全局变量,其它程序可以直接引用。
3:算法2,用来计算连续变量。
看到这里,有种“知其然,不知其所以然”的感觉吧?代码很简单,但是它到底是怎么样实现我们的目的的呢?好,下面就让我们绕开云雾看青天吧。
我们最常用的按键接法如下:AVR是有内部上拉功能的,但是为了说明问题,我是特意用外部上拉电阻。那么,按键没有按下的时候,读端口数据为1,如果按键按下,那么端口读到0。下面就看看具体几种情况之下,这算法是怎么一回事。
(1) 没有按键的时候
端口为0xff,ReadData读端口并且取反,很显然,就是 0x00 了。
Trg = ReadData & (ReadData ^ Cont); (初始状态下,Cont也是为0的)很简单的数学计算,因为ReadData为0,则它和任何数“相与”,结果也是为0的。
Cont = ReadData; 保存Cont 其实就是等于ReadData,为0;
结果就是:
ReadData = 0;
Trg = 0;
Cont = 0;
(2) 第一次PB0按下的情况
端口数据为0xfe,ReadData读端口并且取反,很显然,就是 0x01 了。
Trg = ReadData & (ReadData ^ Cont); 因为这是第一次按下,所以Cont是上次的值,应为为0。那么这个式子的值也不难算,也就是 Trg = 0x01 & (0x01^0x00) = 0x01
Cont = ReadData = 0x01;
结果就是:
ReadData = 0x01;
Trg = 0x01;Trg只会在这个时候对应位的值为1,其它时候都为0

Cont = 0x01;

自己实验总结:在main() 的while(1)内调用KeyRead()后,即可判断Trg的状态,然后按其状态对应处理。如:

KeyRead();

if(Trg = 0x80)

{

// 处理程序

}

此时,Trg保持当前值,只有当while内后续操作完成后,重新循环回KeyRead()函数后,Trg会更新。

(3) PB0按着不松(长按键)的情况
端口数据为0xfe,ReadData读端口并且取反是 0x01 了。
Trg = ReadData & (ReadData ^ Cont); 因为这是连续按下,所以Cont是上次的值,应为为0x01。那么这个式子就变成了 Trg = 0x01 & (0x01^0x01) = 0x00
Cont = ReadData = 0x01;
结果就是:
ReadData = 0x01;
Trg = 0x00;
Cont = 0x01;
因为现在按键是长按着,所以MCU会每个一定时间(20ms左右)不断的执行这个函数,那么下次执行的时候情况会是怎么样的呢?
ReadData = 0x01;这个不会变,因为按键没有松开
Trg = ReadData & (ReadData ^ Cont) = 0x01 & (0x01 ^ 0x01) = 0 ,只要按键没有松开,这个Trg值永远为 0 !!!
Cont = 0x01;只要按键没有松开,这个值永远是0x01!!
(4) 按键松开的情况
端口数据为0xff,ReadData读端口并且取反是 0x00 了。
Trg = ReadData & (ReadData ^ Cont) = 0x00 & (0x00^0x01) = 0x00
Cont = ReadData = 0x00;
结果就是:
ReadData = 0x00;
Trg = 0x00;
Cont = 0x00;
很显然,这个回到了初始状态,也就是没有按键按下的状态。
总结一下,不知道想懂了没有?其实很简单,答案如下:
Trg 表示的就是触发的意思,也就是跳变,只要有按键按下(电平从1到0的跳变),那么Trg在对应按键的位上面会置一,我们用了PB0则Trg的值为0x01,类似,如果我们PB7按下的话,Trg 的值就应该为 0x80 ,这个很好理解,还有,最关键的地方,Trg 的值每次按下只会出现一次,然后立刻被清除,完全不需要人工去干预。所以按键功能处理程序不会重复执行,省下了一大堆的条件判断,这个可是精粹哦!!Cont代表的是长按键,如果PB0按着不放,那么Cont的值就为 0x01,相对应,PB7按着不放,那么Cont的值应该为0x80,同样很好理解。
如果还是想不懂的话,可以自己演算一下那两个表达式,应该不难理解的。
因为有了这个支持,那么按键处理就变得很爽了,下面看应用:
应用一:一次触发的按键处理
假设PB0为蜂鸣器按键,按一下,蜂鸣器beep的响一声。这个很简单,但是大家以前是怎么做的呢?对比一下看谁的方便?
#define KEY_BEEP 0x01
void KeyProc(void)
{

if (Trg & KEY_BEEP) // 如果按下的是KEY_BEEP
{

Beep(); // 执行蜂鸣器处理函数
}
}
怎么样?够和谐不?记得前面解释说Trg的精粹是什么?精粹就是只会出现一次。所以你按下按键的话,Trg & KEY_BEEP 为“真”的情况只会出现一次,所以处理起来非常的方便,蜂鸣器也不会没事乱叫,hoho~~~
或者你会认为这个处理简单,没有问题,我们继续。
应用2:长按键的处理
项目中经常会遇到一些要求,例如:一个按键如果短按一下执行功能A,如果长按2秒不放的话会执行功能B,又或者是要求3秒按着不放,计数连加什么什么的功能,很实际。不知道大家以前是怎么做的呢?我承认以前做的很郁闷。
但是看我们这里怎么处理吧,或许你会大吃一惊,原来程序可以这么简单
这里具个简单例子,为了只是说明原理,PB0是模式按键,短按则切换模式,PB1就是加,如果长按的话则连加(玩过电子表吧?没错,就是那个!)
#define KEY_MODE 0x01 // 模式按键
#define KEY_PLUS 0x02 // 加
void KeyProc(void)
{

if (Trg & KEY_MODE) // 如果按下的是KEY_MODE,而且你常按这按键也没有用,
{ //它是不会执行第二次的哦 , 必须先松开再按下
Mode++; // 模式寄存器加1,当然,这里只是演示,你可以执行你想
// 执行的任何代码
}

if (Cont & KEY_PLUS) // 如果“加”按键被按着不放
{

cnt_plus++; // 计时
if (cnt_plus > 100) // 20ms*100 = 2S 如果时间到
{

Func(); // 你需要的执行的程序

}
}
不知道各位感觉如何?我觉得还是挺简单的完成了任务,当然,作为演示用代码。
应用3:点触型按键和开关型按键的混合使用
点触形按键估计用的最多,特别是单片机。开关型其实也很常见,例如家里的电灯,那些按下就不松开,除非关。这是两种按键形式的处理原理也没啥特别,但是你有没有想过,如果一个系统里面这两种按键是怎么处理的?我想起了我以前的处理,分开两个非常类似的处理程序,现在看起来真的是笨的不行了,但是也没有办法啊,结构决定了程序。不过现在好了,用上面介绍的办法,很轻松就可以搞定。
原理么?可能你也会想到,对于点触开关,按照上面的办法处理一次按下和长按,对于开关型,我们只需要处理Cont就OK了,为什么?很简单嘛,把它当成是一个长按键,这样就找到了共同点,屏蔽了所有的细节。程序就不给了,完全就是应用2的内容,在这里提为了就是说明原理~~
好了,这个好用的按键处理算是说完了。可能会有朋友会问,为什么不说延时消抖问题?哈哈,被看穿了。果然不能偷懒。下面谈谈这个问题,顺便也就非常简单的谈谈我自己用时间片轮办法,以及是如何消抖的。
延时消抖的办法是非常传统,也就是 第一次判断有按键,延时一定的时间(一般习惯是20ms)再读端口,如果两次读到的数据一样,说明了是真正的按键,而不是抖动,则进入按键处理程序。
当然,不要跟我说你delay(20)那样去死循环去,真是那样的话,我衷心的建议你先放下手上所有的东西,好好的去了解一下操作系统的分时工作原理,大概知道思想就可以,不需要详细看原理,否则你永远逃不出“菜鸟”这个圈子。当然我也是菜鸟。我的意思是,真正的单片机入门,是从学会处理多任务开始的,这个也是学校程序跟公司程序的最大差别。当然,本文不是专门说这个的,所以也不献丑了。
我的主程序架构是这样的:
volatile unsigned char Intrcnt;
void InterruptHandle() // 中断服务程序
{

Intrcnt++; // 1ms 中断1次,可变
}
void main(void)
{

SysInit();
while(1) // 每20ms 执行一次大循环
{

KeyRead(); // 将每个子程序都扫描一遍
KeyProc();
Func1();
Funt2();


while(1)
{

if (Intrcnt>20) // 一直在等,直到20ms时间到
{

Intrcnt=”0″;
break; // 返回主循环
}
}
}
}
貌似扯远了,回到我们刚才的问题,也就是怎么做按键消抖处理。我们将读按键的程序放在了主循环,也就是说,每20ms我们会执行一次KeyRead()函数来得到新的Trg 和 Cont 值。好了,下面是我的消抖部分:很简单
基本架构如上,我自己比较喜欢的,一直在用。当然,和这个配合,每个子程序必须执行时间不长,更加不能死循环,一般采用有限状态机的办法来实现,具体参考其它资料咯。
懂得基本原理之后,至于怎么用就大家慢慢思考了,我想也难不到聪明的工程师们。例如还有一些处理,

怎么判断按键释放?很简单,Trg 和Cont都为0 则肯定已经释放了。

这个是4*4矩阵,是从吧里转来的,感觉也是这种算法。顺便也贴到这里

把文本格式奉上 直接复制到你的程序里
volatile unsigned char CF[4]; //按键触发标志(表示4列,每一列同一行的
//值是一样的但列标不一样来区分不同列的键)
volatile unsigned char KeyVal;//键值
code unsigned char KeyOut[4] = {0xef,0xdf,0xbf,0x7f}; //4X4按输出端控制
#define KEY P2 //P2口作为4*4矩阵键盘输入
/*
**描述:新型4X4按键扫描程序 放在1ms-10ms中断内使用(十分稳定不需要再写消抖程序)
**备注:按键弹起时 keyVal = 0 单键按下 keyVal 有16个值,你自己程序可以针对不同值
**进行不同程序操作 keyVal单键值分别为 
**0x11,0x12,0x14,0x18,
**0x21,0x22,0x24,0x28,
**0x31,0x32,0x34,0x38,
**0x41,0x42,0x44,0x48,
*/ 
void Key_Head() 
{

unsigned char ReadData[4];
static unsigned char i;
if(++i>=4)i=0;

KEY = KeyOut[i]|0x0f; //忽略低4位
ReadData[i] = (KEY|0xf0)^0xff; //忽略高4位 取反 
CF[i] = ReadData[i] & (ReadData[i] ^ Cont[i]); 
Cont[i] = ReadData[i]; 
//输出键值
switch(CF[i])//第i列
{

case 0x08: KeyVal = (i<<4+8);break;
case 0x04: KeyVal = (i<<4+4);break;
case 0x02: KeyVal = (i<<4+2);break;
case 0x01: KeyVal = (i<<4+1);break;
default:KeyVal = 0;break;

}

GPIO 按键及矩阵键盘程序------/* 自己实验确认并总结 */

原贴“给大家分享一个超级好用 不占CPU的4*4矩阵键盘扫描程序”:http://tieba.baidu.com/p/2730390494

自己使用总结:

上述程序实例使用需注意一下几点:

1. i定义为static型变量,每执行if(++i>=4)后i会自增;

2. Cont[]忘记定义:unsigned char Cont[4];

3. KeyVal值错误,因为if(++i>=4) i=0; 所以KeyVal单键值应为:

0x11,0x12,0x14,0x18,
0x21,0x22,0x24,0x28,
0x31,0x32,0x34,0x38,
0x01,0x02,0x04,0x08,

4. 在使用中端口要注意,程序中P2端口的高4位为输出端口,低4位为输入端口,且4个输入端口要默认上拉

KeyOut[4] = {0xef,0xdf,0xbf,0x7f};的定义决定高四位为输出端口,低4位为输入端口。

扫描原理可参考:http://blog.csdn.net/phenixyf/article/details/76173409 

KEY = KeyOut[i]|0x0f; //忽略低4位

这一步是在配置输出

ReadData[i] = (KEY|0xf0)^0xff; //忽略高4位 取反 

这一步是在读取矩阵按键

这两句要根据具体使用自己修改,如使用STM8S003,将两个端口拼成一个8位扫描端口,程序如下:

volatile unsigned char Cont[4];
//unsigned char KeyOut[4] = {0xef,0xdf,0xbf,0x7f}; //4X4按输出端控制
unsigned char KeyOut[4] = {0x3f,0x5f,0x6f,0x77};    //两个端口组合组成4x4端口
unsigned char KeyVal;     //键值
unsigned char cIn0,cIn1,cIn2,cIn3;
void Key_Head() 
{
  unsigned char ReadData[4];
  static unsigned char i;
  /*
    PortCom BIT7 BIT6 BIT5 BIT4 BIT3 BIT2 BIT1 BIT0
            PD6  PD5  PD4  PD3  PD2  PA3  PA2  PA1
  */
  cIn0 = 0;
  cIn1 = 0;
  cIn2 = 0;
  cIn3 = 0;
  if(++i>=4)i=0;


//  PortCom = KeyOut[i]|0x0f;                     //忽略低4位
  //输出扫描
  PD_ODR = KeyOut[i];
  //输入侦测
  cIn0 = PA_IDR_bit.IDR1;
  cIn1 = PA_IDR_bit.IDR2;
  cIn2 = PA_IDR_bit.IDR3;
  cIn3 = PD_IDR_bit.IDR2;
  PortCom = (cIn3<<3) | (cIn2<<2) | (cIn1<<1) | cIn0; 
  
  ReadData[i] = (PortCom|0xf0)^0xff;            //忽略高4位 取反 
  CF[i] = ReadData[i] & (ReadData[i] ^ Cont[i]); 
  Cont[i] = ReadData[i]; 
  //输出键值
  switch(CF[i])//第i列
  {
    case 0x08: KeyVal = ((i<<4)+8);break;
    case 0x04: KeyVal = ((i<<4)+4);break;
    case 0x02: KeyVal = ((i<<4)+2);break;
    case 0x01: KeyVal = ((i<<4)+1);break;
    default:KeyVal = 0;break;
    delay(50);
  } 

5. 特别注意一点:在原Key_Head()函数中,键值KeyVal只会保持按键侦测到当时一下,在下次扫描中马上会被清零(下次扫描i增加,CF[i]也随之变化,此时switch语句进入default分支,将KeyVal清零)。

这个是算法的精髓,当按键按下后,键值只出现一次,在Key_Head()后紧跟对应键值处理程序,完成对应操作,然后下次循环Key_Head()会自动将KeyVal清零,保证不会重复执行键值对应处理程序。

对于消抖,可以在KeyVal后加入适当延迟,如上程序最后一行

int main(void)
{
  CLK_CKDIVR = 0x00;              //内部时钟为1分频
  ALL_LED_Init();                 //调用LED1初始化函数
  ALLKeyInit();                   //调用按钮初始化函数


  while(1)
  {  
    Key_Head();
    
    switch(KeyVal)
    {
    case 0x11:
      {
        PC_ODR ^= 0x80;                //异或取反LED2使其亮灭
        break;
      }
    case 0x12:
      {
        PC_ODR ^= 0x40;                //异或取反LED3使其亮灭
        break;
      }
    case 0x14:
      {
        PC_ODR ^= 0x08;                //异或取反LED4使其亮灭
        break;
      }
    case 0x18:
      {
        PC_ODR ^= 0x80;                //异或取反LED2使其亮灭
        break;
      }
 
    default:
      {
        break;
      }
    }
    
  }
}

转自:http://tieba.baidu.com/p/2751359634

因可能会用不同端口的pin脚,拼接成扫描的端口,这时要注意以下两点:

1. 输出扫描的值KeyOut[4] = {
0xbf,0xef,0xdf,0x7f}; 要做对应的修改;

2. 获取输入pin数据时,输入pin的端口拼接方法要根据使用具体情况来定。

简单举例:获取pin数据是按bit获取,获取后拼接输入端口

//输入侦测
  cIn0 = PA_IDR_bit.IDR1;
  cIn1 = PA_IDR_bit.IDR2;
  cIn2 = PA_IDR_bit.IDR3;
  cIn3 = PD_IDR_bit.IDR2;
  PortCom = (cIn3<<3) | (cIn2<<2) | (cIn1<<1) | cIn0; 

当获取pin数据是按byte获取,获取后拼接输入端口

cIn[0] = GPIOE->IDR & 0x20;
  cIn[1] = GPIOC->IDR & 0x02;
  cIn[2] = GPIOC->IDR & 0x04;
  cIn[3] = GPIOC->IDR & 0x08;
  
  PortCom = cIn[3] | cIn[2] | cIn[1] | (cIn[0]>>5); 

前提是拼接的端口高4为做输出,低4位做输入。

在上述前提下,swith(CF[i])中的case值不用变,KeyValue值也是在

{0x11,0x12,0x14,0x18,
0x21,0x22,0x24,0x28,
0x31,0x32,0x34,0x38,
0x01,0x02,0x04,0x08,}范围内。

4X4 KeyScan() debug方法

如下图所示设置断点:

GPIO 按键及矩阵键盘程序------/* 自己实验确认并总结 */

进入第一个断点后,按下某个按键,向下执行,因要扫描4列,所以KeyScan函数要进出4次,其中必有一次可以扫到按键;

扫到按键后PortCom不为0x0F,CF[i]和kevalue也有对应值出现,如下图:

GPIO 按键及矩阵键盘程序------/* 自己实验确认并总结 */

扫到某个键后,如果按住不放,等再次扫到时,CF和keyvalue会清零,但Cont会有值,表示长按

KeyScan()侦测同时按下的多个值的方法:

GPIO 按键及矩阵键盘程序------/* 自己实验确认并总结 */

switch(CF[i])//第i列
  {
    case 0x08: KeyVal = ((i<<4)+8);break;
    case 0x04: KeyVal = ((i<<4)+4);break;
    case 0x02: KeyVal = ((i<<4)+2);break;
    case 0x01: KeyVal = ((i<<4)+1);break;
    default:KeyVal = 0;break;
    delay(50);
  } 

在状态判断中,如上判断只是判断一个按键是否被按下,如0x08代表SW1被按下,0x12代表SW11被按下;

如果要判断多个按键是否同时被按下,可以更改case后的值,如0x09代表SW1和SW2同时被按下,0x0B代表SW1/SW2/SW3同时被按下;

但如果要判断不同输出下的两个或多个键同时被按下,需定义一个变量,让keyScan循环4次后,将所得值或起来判断

for(int i=0; i<4; i++)

{

    keyScan();

    KeyMul |= KeyVal;

}然后判断KeyMul值。

但这个会有误判,即不同按键组合可能会得到相同的KeyMul值。如SW1/SW10同时按下和SW3/SW5同时按下,得到的值都是0x2A。这需要另外区分判断。

另外,对应同一输入下的多个按键同时按下,如SW1/SW5,可能无法得到正确值,这需要根据硬件看上拉或下拉的能力哪个强,要量测实际值来判断。如SW1/SW5同时按下,当PC6输出0时,keyValue值是否为0xA7或0xE7或0xEF,要根据实际量测为准。

KeyScan()独立表示各按键状态,让按键状态与键值呈组合逻辑状态:

在车窗镜控制板项目中,各按键值要根据按键状态实时反应,所以要对KeyScan做修改,如上图按键组合:

bool 	KeyPos[20];

void KeyScan(void)	
{
  unsigned char ReadData[4];
  static unsigned char i;

  cIn[0] = 0;
  cIn[1] = 0;
  cIn[2] = 0;
  cIn[3] = 0;
  if(++i>=4)i=0;
  T1 = KeyOut[i];
  GPIOC->ODR = KeyOut[i];      
  cIn[0] = GPIOE->IDR & 0x20;
  cIn[1] = GPIOC->IDR & 0x02;
  cIn[2] = GPIOC->IDR & 0x04;
  cIn[3] = GPIOC->IDR & 0x08;  
  PortCom = cIn[3] | cIn[2] | cIn[1] | (cIn[0]>>5); 
  
  ReadData[i] = (PortCom|0xf0)^0xff;           
  CF[i] = ReadData[i] & (ReadData[i] ^ Cont[i]); 
  Cont[i] = ReadData[i]; 
  
	KeyPos[i*4] = (((CF[i] |Cont[i]) & 0x08)==0x08)?true:false;
	KeyPos[i*4+1] = (((CF[i] |Cont[i]) & 0x04)==0x04)?true:false;
	KeyPos[i*4+2] = (((CF[i] |Cont[i]) & 0x02)==0x02)?true:false;
	KeyPos[i*4+3] = (((CF[i] |Cont[i]) & 0x01)==0x01)?true:false;
    
  Delay(3);
}

KeyPos[0]对应SW1; KeyPos[1]对应SW4; KeyPos[2]对应SW3; KeyPos[3]对应SW2; 

KeyPos[4]对应SW7; KeyPos[5]对应SW16; KeyPos[6]对应SW11; KeyPos[7]对应SW20; 

KeyPos[8]对应SW6; KeyPos[9]对应SW13; KeyPos[10]对应SW10; KeyPos[11]对应SW17; 

KeyPos[12]对应SW22; KeyPos[13]对应SW23; KeyPos[14]对应SW21; KeyPos[15]对应SWX; 

按此方式修改,即KeyPos[i]实时反应对应的按键是按下还是松开,不会因KeyScan循环下次后,键值发生改变。

如SW1被按下后,当KeyOut输出0xEF时,KeyPos[0]=1,当KeyOut分别输出0xBF,0xDF,0x7F时,KeyPos[0]也维持为1,不会如之前的KeyValue被清零或变成其它状态。

此方法就是将每个按键与一个键值状态,独立联系起来。之前是用一个状态KeyValue将16个按键统一表示起来。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/38468.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注