请教一个独立按键的问题

只看该作者 · 2012-12-5 14:40

按键端口的定义，如下所示：
sbit io_key_1 = P3^0 ;
sbit io_key_2 = P3^1 ;
sbit io_key_3 = P3^2 ;
sbit io_key_4 = P3^3 ;

根据按键硬件连接定义按键键值
#define KEY_VALUE_1 0x0e
#define KEY_VALUE_2 0x0d
#define KEY_VALUE_3 0x0b
#define KEY_VALUE_4 0x07
#define KEY_NULL 0x0f

按键的硬件驱动程序。
static uint8 KeyScan(void)
{
if(io_key_1 == 0)return KEY_VALUE_1 ;
if(io_key_2 == 0)return KEY_VALUE_2 ;
if(io_key_3 == 0)return KEY_VALUE_3 ;
if(io_key_4 == 0)return KEY_VALUE_4 ;
return KEY_NULL ;
}

这是之前看的一篇**中的按键检测程序，由于实际中这四个按键分别接在不同的IO端口上如P00、P11、P22、P33上，那么该如何根据按键硬件连接定义修改按键键值呐？

1万 · 2012-12-5 14:48

想什么值都可以的，使用时对应即可

只看该作者 · 2012-12-5 14:55

ayb_ice 发表于 2012-12-5 14:48
想什么值都可以的，使用时对应即可

那为什么只有一个按键有效呐？始终只有一个按键有用，其它的都没反应，但是如果像上面接在P30-P33上四个按键都有效！不解？求大侠赐教！

只看该作者 · 2012-12-5 15:04

static uint8 KeyScan(void)
函数中没有个条件不是return了吗，当然只有一个有效了，也就是最先按下的那个有效

只看该作者 · 2012-12-5 15:12

果断围观。。。

只看该作者 · 2012-12-5 15:14

zxb1717 发表于 2012-12-5 15:04
static uint8 KeyScan(void)
函数中没有个条件不是return了吗，当然只有一个有效了，也就是最先按下的那个 ...

您好！是这样的，如果像上面端口是连接在P30-P34上，而且程序也像上面那样写，完全没有任何问题，四个按键功能都可以实现，但是现在若是接两个按键到P00和P11端口上的话，只是修改了端口定义，然后屏蔽掉剩余两个按键定义，最后发现只有一个按键功能有效，很是不解，希望大侠赐教！

只看该作者 · 2012-12-5 15:16

xuxikfg 发表于 2012-12-5 15:12
果断围观。。。

求解啊:dizzy:

只看该作者 · 2012-12-5 15:20

zxb1717 发表于 2012-12-5 15:04
static uint8 KeyScan(void)
函数中没有个条件不是return了吗，当然只有一个有效了，也就是最先按下的那个 ...

换了端口连接后，是不是按键键值的宏定义也要一起修改呢？

只看该作者 · 2012-12-5 15:31

不解啊，各位大侠看哈到底是什么问题啊？

1万 · 2012-12-5 15:32

推荐使用以下方式

typedef U8 unsigned char;

#define BIT0 0x01
#define BIT1 0x02
#define BIT2 0x04
#define BIT3 0x08
#define BIT4 0x10
#define BIT5 0x20
#define BIT6 0x40
#define BIT7 0x80

static uint8 KeyScan(void)
{
U8 k = 0;

if(io_key_1 == 0){
k |= BIT0;
}
if(io_key_2 == 0){
k |= BIT1;
}
if(io_key_3 == 0){
k |= BIT2;
}
if(io_key_4 == 0){
k |= BIT3;
}

return k;
}

使用时如下
switch(key_number){
case BIT0:
case BIT1:
case BIT3:
case BIT4:
...
case BIT0+BIT1: // K1+K2
....
}

只看该作者 · 2012-12-5 16:00

本帖最后由 xppx1987 于 2012-12-5 16:43 编辑

ayb_ice 发表于 2012-12-5 15:32
推荐使用以下方式

换了您这种方法还是只有一个按键有效，现把自己按您说的方式修改的程序贴出来，看到底哪儿出错了？
//端口定义
#define io_key_1 RB0
#define io_key_2 RA1

#define BIT0       0x01
#define BIT1       0x02
//定义长按键的TICK 数,以及连发间隔的TICK 数
#define KEY_LONG_PERIOD 20
#define KEY_CONTINUE_PERIOD 5
//定义按键返回值状态(按下,长按,连发,释放)
#define KEY_DOWN 0x80
#define KEY_LONG 0x40
#define KEY_CONTINUE 0x20
#define KEY_UP 0x10
//定义按键状态
#define KEY_STATE_INIT 0
#define KEY_STATE_WOBBLE 1
#define KEY_STATE_PRESS 2
#define KEY_STATE_LONG 3
#define KEY_STATE_CONTINUE 4
#define KEY_STATE_RELEASE 5
//键值读取函数
static uchar KeyScan(void)
{
      uchar k=0;
      if(io_key_1 == 0)
      {
            k|=BIT0;
      }
      if(io_key_2 == 0)
      {
            k|=BIT1;
      }
      return k;
}
//按键操作函数
void GetKey(uchar *pKeyValue)
{
      static uchar s_u8KeyState=KEY_STATE_INIT;
      static uchar s_u8KeyTimeCount=0;
      static uchar s_u8LastKey=KEY_NULL; //保存按键释放时候的键值
      uchar KeyTemp=0;
      KeyTemp=KeyScan(); //获取键值
      switch(s_u8KeyState)
      {
            case KEY_STATE_INIT :
            {
                     if(KeyTemp!=0)
                     {
                              s_u8KeyState=KEY_STATE_WOBBLE ;
                     }
            }
            break ;
            case KEY_STATE_WOBBLE: //消抖
            {
                     s_u8KeyState=KEY_STATE_PRESS ;
            }
            break ;
            case KEY_STATE_PRESS :
            {
                     if(KeyTemp!=0)
                     {
                              s_u8LastKey=KeyTemp ; //保存键值,以便在释放按键状态返回键值
                              KeyTemp|=KEY_DOWN ; //按键按下
                              s_u8KeyState=KEY_STATE_LONG ;
                     }
                     else
                     {
                              s_u8KeyState=KEY_STATE_INIT ;
                     }
            }
            break ;
            case KEY_STATE_LONG :
            {
                     if(KeyTemp!=0)
                     {
                              if(++s_u8KeyTimeCount > KEY_LONG_PERIOD)
                              {
                                    s_u8KeyTimeCount = 0 ;
                                    KeyTemp |= KEY_LONG ; //长按键事件发生
                                    s_u8KeyState = KEY_STATE_CONTINUE ;
                              }
                     }
                     else
                     {
                              s_u8KeyState = KEY_STATE_RELEASE ;
                     }
            }
            break ;
            case KEY_STATE_CONTINUE :
            {
                     if(KeyTemp!=0)
                     {
                              if(++s_u8KeyTimeCount>KEY_CONTINUE_PERIOD)
                              {
                                    s_u8KeyTimeCount=0;
                                    KeyTemp |= KEY_CONTINUE;
                              }
                     }
                     else
                     {
                              s_u8KeyState = KEY_STATE_RELEASE;
                     }
            }
            break;
            case KEY_STATE_RELEASE:
            {
                     s_u8LastKey |= KEY_UP;
                     KeyTemp = s_u8LastKey;
                     s_u8KeyState = KEY_STATE_INIT;
            }
            break;
            default: break;
      }
      *pKeyValue=KeyTemp ; //返回键值
}
void main()///////////函数主程序
{
      float i,j;
      while(1)
   {
      if(time10ms_ok==1)
      {
               time10ms_ok=0;
               GetKey(&KeyValue);
               if(KeyValue==(BIT0|KEY_DOWN))
               {
                        j++;
               }
               if(KeyValue==(BIT1|KEY_DOWN))
               {
                        i++;
               }

      }
      }
}