amoBBS 阿莫电子论坛

 找回密码
 注册
搜索
bottom↓
查看: 7755|回复: 71

分享一下我的通用按键驱动代码

  [复制链接]
发表于 2013-9-28 21:22:38 | 显示全部楼层 |阅读模式
本帖最后由 Jach_cc 于 2013-9-28 22:22 编辑

  按键在单片机系统开发中是一个很常用到的器件。一般情况下按键检测程序显得太长,最糟糕的是缺乏可移植性。这样一来,与按键相关的代码就显得凌乱不堪。苦于这个原因,我写了一个比较通用的按键驱动程序,可以在任何单片机系统中方便移植。有做的不好的地方希望大家指正,谢谢啦。
  与一般代码的比较:
  一、一般的按键扫描代码特点:
      1. 消抖延时浪费CPU资源。
      2. 松手检测极度浪费单片机CPU资源。
      3. 缺乏封装性:这也是代码凌乱的根源所在。
      4. 多个按键不能同时操作。(因为一般我们的代码是单线程的,等待松手会占用100% CPU资源)
  二、本键盘扫描代码的特点:
      这个程序就是为了解决上面问题而写的,所以特点是针对上面一般按键扫描代码的改进。
      1. 不用消抖延时浪费CPU资源,当然也可以用消抖延时,具体视你的调用频率而定。如果你配置为一定频率刷新按键状态就不会因为消抖延时而暂时完全占用CPU资源。
      2. 松手检测不占用CPU资源。(这一特色很重要吧?因为你可以去处理别的东西,不用等到松手后)
      3. 每一颗按键被完全封装到一个结构体(包括扫描按键状态的函数,这用函数指针实现),不分矩阵键盘和独立按键(它们的不同点仅仅在你的接口函数中有而已,初始化后任何形式的键盘都一样了)。
      4. 支持多个按键同时互不影响操作(可以同时按多个按键,支持组合键)。
      5. 欢迎大家继续发现它的优异性,或者提出宝贵的意见。


  写得很幸苦,有问题谢谢大家一起交流。

  这个代码分key.c和key.h,移植时只用将它们复制到你的目录下。稍作配置即可使用。
    key.c的移植:
        如果你固定频率调用按键刷新函数就完全不用修改这个文件;如果你的调用频率不固定,那么仅仅需要修改void key_delay1ms(uint8_t xms);用来产生一毫的延时。
    key.h的移植:key.h只用配置4个宏定义即可:
      #define USER_DATA_EN                (0)    //使能用户数据,每一个按键有一个变量可以供用户任意使用,如果不用这个变量把括号内改成0即可;如果要用就改成1,但是这会浪费一个字节的内存
      #define KEY_USE_SEM                        (0)        //1使用按键信号量,0不使用互斥信号量。使用互斥信号量的时候多个地方不能同时访问按键的按下次数变量,这样数据最安全,一般很少人用。
      #define KEY_WOBBLE_TIME                (10)  //按键抖动时间,单位ms。具体大小不同由硬件决定,一般情况下是10ms
      //#define KEY_FIXED_PERIOD         (10)//固定频率调用按键状态更新函数,括号内为调用周期,周期单位为ms

types.h文件
#ifndef __TYPES_H__
#define __TYPES_H__


typedef unsigned char uint8_t;
typedef unsigned int uint16_t;
typedef unsigned long uint32_t;

typedef struct{
        uint8_t x;
        uint8_t y;
}point_2d;

#endif
本文件讲解:定义类型,定义了8位,16位,32位长度的数据类型,具体视你的编译器修改。还有一个2d图形中的坐标点,这个不用,是我在其它的程序里面用得。

key.h文件
#ifndef __KEY_H__
#define __KEY_H__

#include "types.h"

#define USER_DATA_EN                (0)
#define KEY_USE_SEM                (0)        //1使用按键互斥信号量,0不使用按键互斥信号量
#define KEY_WOBBLE_TIME                (10)  //按键抖动时间。也就是消抖时间,单位ms

//#define KEY_FIXED_PERIOD        (10)//固定频率调用按键状态更新函数,括号内为调用周期,周期单位为ms

#define KEY_TIMES_MAX (0XFF)
typedef enum{
        KEY_ACCESS_READ         = 0x08,
        KEY_ACCESS_WRITE        = 0x80,
        KEY_ACCESS_CLEAR        = 0X40,
        KEY_ACCESS_DECREASE= 0X20,
        KEY_ACCESS_INCREASE= 0X10       
}access_type;

/************以下内容均不需要更改,直接使用即可*******************************/
typedef enum
{
        KEY_DOWN                                 = 1,
        KEY_UP                                         = 2,
        KEY_UP_WOBBLE         = 3,//确认弹起消抖状态
        KEY_DOWN_WOBBLE = 4 //确认按下消抖状态
}key_state_type;


/************按键信号量,互斥访问时使用*****************/
typedef enum
{
        KEY_SEM_USING = 0,
        KEY_SEM_FREE  = 1
}key_sem_type;

typedef struct
{
        uint8_t (*get_state)(void);        //用于获取按键状态的函数

        #if KEY_USE_SEM==1
        key_sem_type                sem;                                //信号量,
        #endif

        #ifdef  KEY_FIXED_PERIOD
        uint8_t                                time_ms;                        //用于固定周期调用状态更新函数的计时,不能超过类型所能表示的最大值
        #endif

        key_state_type                state;
        uint8_t                                times;                                //按下并弹出后加一,使用后由应用程序减1

        #if (USER_DATA_EN==1)
        uint8_t                                value;                                //用户变量,可由用户任意使用
        #endif
}key_inf_type;

/*                        函数声明:                                                                                                                                                                                        */
void Key_Init(key_inf_type* key_this, uint8_t(*getState)(void));
void Key_RefreshState(key_inf_type* theKey);
uint8_t Key_AccessTimes(key_inf_type* theKey, access_type option );

#endif
本文件讲解:access_type这个枚举类型在使用互斥信号量时,对按键状态访问的选择。
                  key_state_type这个枚举类型用来不由用户使用,是状态机的,正是因为有了这个,才免去的一般按键驱动代码对CPU的100%占用。
                  key_sem_type这个枚举类型用来记录信号量状态
                  key_inf_type这个结构体是核心类型了,按键的所有信息都记录在里面。包括按键被按下的次数,和现在按键的状态,以及它的信号量。


key.c文件
#include "key.h"

/****************************************************************
函数说明:        按键专用延时函数,大概一毫秒
移植说明:        需要更改
*****************************************************************/
#ifndef  KEY_FIXED_PERIOD
void key_delay1ms(uint8_t xms)
{
        unsigned int _1ms;
        for( ; xms>0; xms-- )
                for( _1ms=400; _1ms>0; _1ms-- );
}
#endif


/*                                        以下内容不需要更改,直接使用即可                                                                */
/*
        函数说明:        初始化一个按键对象
        参数说明:        key_this:指向按键对象的指针
                                getState:状态检测函数指针
*/

void Key_Init(key_inf_type* key_this, uint8_t(*getState)(void))
{
        key_this->get_state = getState;
        key_this->state = KEY_UP;
        key_this->times        = 0;
        #if (USER_DATA_EN==1)
        key_this->value        = 0;
        #endif
        #if KEY_USE_SEM==1
        key_this->sem        = KEY_SEM_FREE;
        #endif
        #ifdef  KEY_FIXED_PERIOD
        key_this->time_ms = 0;        //用于固定周期调用状态更新函数的计时
        #endif
}


/****************************************************************
函数说明:        更新按键状态
要求        :
                        1、调用频率:满足按键更新最快频率,一般要求调用频率在20HZ以上
*****************************************************************/
void Key_RefreshState(key_inf_type* theKey)
{
        #if KEY_USE_SEM==1
        if( KEY_SEM_FREE == theKey->sem )
        {
                theKey->sem = KEY_SEM_USING;
        #endif
                switch( theKey->state )
                {
                        case KEY_UP:
                        {
                                if( (*(theKey->get_state))() )
                                {
                                        #ifdef  KEY_FIXED_PERIOD
                                        theKey->time_ms = 0;
                                        theKey->state = KEY_DOWN_WOBBLE;//进行消抖延时
                                        #else
                                        theKey->state = KEY_DOWN_WOBBLE;
                                        key_delay1ms(KEY_WOBBLE_TIME);                               
                                        if( (*(theKey->get_state))() )
                                        {
                                                theKey->state = KEY_DOWN;
                                        }
                                        #endif
                                }
                        }break;
                       
                        #ifdef  KEY_FIXED_PERIOD
                        case KEY_DOWN_WOBBLE:
                        {
                                theKey->time_ms += KEY_FIXED_PERIOD;
                                if( theKey->time_ms >=KEY_WOBBLE_TIME )
                                {
                                        if( (*(theKey->get_state))() )
                                        {
                                                theKey->state = KEY_DOWN;
                                        }else
                                        {
                                                theKey->state = KEY_UP;
                                        }
                                }
                        }break;
                        #endif

                        case KEY_DOWN:
                        {
                                if( (*(theKey->get_state))() == 0 )
                                {
                                        #ifdef  KEY_FIXED_PERIOD
                                        theKey->time_ms = 0;
                                        theKey->state = KEY_UP_WOBBLE;//进行消抖延时
                                        #else
                                        key_delay1ms(KEY_WOBBLE_TIME);
                                        if( (*(theKey->get_state))() == 0 )
                                        {
                                                theKey->state = KEY_UP;
                                                theKey->times++;
                                                if( theKey->times > 250)
                                                        theKey->times = 250;//最多允许按下250次没处理
                                        }
                                        #endif
                                }
                        }break;

                        #ifdef  KEY_FIXED_PERIOD
                        case KEY_UP_WOBBLE:
                        {
                                theKey->time_ms += KEY_FIXED_PERIOD;
                                if( theKey->time_ms >= KEY_WOBBLE_TIME )
                                {
                                        if( 0 == (*(theKey->get_state))() )
                                        {
                                                theKey->state = KEY_UP;
                                                theKey->times++;
                                                if( theKey->times > 250)
                                                        theKey->times = 250;//最多允许按下250次没处理
                                        }else
                                        {
                                                theKey->state = KEY_DOWN;
                                        }
                                }
                        }break;
                        #endif
                }

        #if KEY_USE_SEM==1
                theKey->sem = KEY_SEM_FREE;
        }
        #endif
}

/****************************************************************
函数说明        :        对按键值的访问,主要是封装对信号量的访问
参数                :        option        --------        选项
                                        详见access_type定义。主要分read和write两类不可按位或;write有3种情况,不可按位或。
                                        如果只是读取则不用对option进行配置
                                        如果是write类型的访问,则要KEY_ACCESS_WRITE位或上“KEY_ACCESS_CLEAR或者其它两个中的一个”
返回值        :        ->times的值。
                               
*****************************************************************/
uint8_t Key_AccessTimes(key_inf_type* theKey, access_type option )
{
        uint8_t times_temp;
       
        #if KEY_USE_SEM==1
        if( KEY_SEM_FREE == theKey->sem )
        {
                theKey->sem = KEY_SEM_USING;
        #endif
       
        if( (option&KEY_ACCESS_WRITE) == KEY_ACCESS_WRITE )
        {
                if( (option&KEY_ACCESS_CLEAR) == KEY_ACCESS_CLEAR )
                {
                        theKey->times = 0;                                       
                }
                if( (option&KEY_ACCESS_DECREASE) == KEY_ACCESS_DECREASE )
                {
                        if( 0 == theKey->times )
                        {
                                theKey->times = theKey->times;
                        }else
                        {
                                (theKey->times)--;
                        }
                }
                if( (option&KEY_ACCESS_INCREASE) == KEY_ACCESS_INCREASE )
                {
                        if( KEY_TIMES_MAX == theKey->times )
                        {
                                theKey->times = theKey->times;
                        }else
                        {
                                (theKey->times)++;
                        }
                }
               
        }
               
        times_temp = theKey->times;
       
        #if KEY_USE_SEM==1
                theKey->sem = KEY_SEM_FREE;
        }
        else
        {
                return 0xff;//times_temp = 0xff;//表示正在被占用,不能访问times
        }
        #endif
       
        return times_temp;
}
本文件讲解:void key_delay1ms(uint8_t xms);延时1ms为单位的函数,用来消抖。如果你的程序固定周期调用按键状态刷新函数就不用这个了。
                  void Key_Init(key_inf_type* key_this, uint8_t(*getState)(void));初始化一颗按键。第一个参数是这一颗按键的结构体,第二个参数是它的状态检测函数,由用户提供。
                  void Key_RefreshState(key_inf_type* theKey);刷新一颗按键状态。初始化完成后调用它就可以了。
                  uint8_t Key_AccessTimes(key_inf_type* theKey, access_type option );访问一颗按键的按下次数。
看起来很复杂,新手看起来可能有困难,由于篇幅较多就不一一分析。但是比较容易理解,最重要的是它的通用性,这也是我最喜欢的程序特点。
 楼主| 发表于 2013-9-28 22:24:57 | 显示全部楼层
忘了上次代码。补上

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x
发表于 2013-9-28 22:31:04 | 显示全部楼层
太强了,顶下,学习
发表于 2013-9-28 22:34:33 | 显示全部楼层
学长,怎么使用这个啊?
发表于 2013-9-28 22:36:44 | 显示全部楼层
学习一下
 楼主| 发表于 2013-9-28 22:45:36 | 显示全部楼层
高灿健 发表于 2013-9-28 22:34
学长,怎么使用这个啊?

对了啊,这个忘了说,使用如下(avr例,矩阵键盘):

key_inf_type key_up; //定义上键

uint8_t KeyUp_state(void)
{
        PORTD |= ( (1u<<PORTD4)|(1u<<PORTD5) );
        PORTD &= ( ~(1u<<PORTD3) );
        asm("nop");//等待电平稳定
        if( (PINB&0x02)!=0x02 )
        {
                return 1;
        }else
        {
                return 0;
        }
}
void main(void)
{
  Key_Init( &key_up, KeyUp_state );//初始化按键,将上键和它的检测函数联系起来。
  while(1)
  {
        Key_RefreshState( &key_up );//刷新按键状态
        if( Key_AccessTimes(&key_up, KEY_ACCESS_READ ) != 0 )//按键被按下过
        {
                Key_AccessTimes(&key_up, KEY_ACCESS_WRITE|KEY_ACCESS_CLEAR ) ;//清除按键状态
                state = 6;
        }

        display( state );
}

简单吧?独立按键一样,只是它们的状态检测函数不一样而已。
这里只是简单的使用,还没有涉及综合应用和组合键。
发表于 2013-9-28 23:04:09 | 显示全部楼层
不错,值得学习,,,
发表于 2013-9-28 23:04:57 | 显示全部楼层
学长,写的比我的好多了。
发表于 2013-9-28 23:06:35 | 显示全部楼层
按键应该用 状态机               
 楼主| 发表于 2013-9-28 23:09:33 | 显示全部楼层
二进制 发表于 2013-9-28 23:06
按键应该用 状态机

就是用的状态机
typedef struct
{
        uint8_t (*get_state)(void);        //用于获取按键状态的函数

        #if KEY_USE_SEM==1
        key_sem_type                sem;                                //信号量,
        #endif

        #ifdef  KEY_FIXED_PERIOD
        uint8_t                                time_ms;                        //用于固定周期调用状态更新函数的计时
        #endif

        key_state_type                state;
        uint8_t                                times;                                //按下并弹出后加一,使用后由应用程序减1

        #if (USER_DATA_EN==1)
        uint8_t                                value;                                //用户变量,可由用户任意使用
        #endif
}key_inf_type;
这个里面的state就是。。状态有下面这些东西:
typedef enum
{
        KEY_DOWN                                 = 1,
        KEY_UP                                         = 2,
        KEY_UP_WOBBLE         = 3,//确认弹起消抖状态
        KEY_DOWN_WOBBLE = 4 //确认按下消抖状态
}key_state_type;
发表于 2013-9-28 23:12:44 | 显示全部楼层
值得学习
发表于 2013-9-28 23:17:26 | 显示全部楼层
确实比较高深,对我等新手来说比较难懂,顶一顶!
发表于 2013-9-28 23:47:40 | 显示全部楼层
mark 按键 学习了
发表于 2013-9-28 23:51:15 来自手机 | 显示全部楼层
按键一所般都是使用一个通用模块,方便移植,每次只需要编写读键值部分即可。
发表于 2013-9-29 00:26:51 | 显示全部楼层
做个额记号,好学习。
发表于 2013-9-29 07:12:06 | 显示全部楼层
先学习   
发表于 2013-9-29 08:45:35 来自手机 | 显示全部楼层
收藏了细看
发表于 2013-9-29 09:24:18 | 显示全部楼层
写的不错,遇到键盘就可以不用再慢慢扣了,只是对于没怎么接触过状态机的初学者可能需要花点时间研究一下
发表于 2013-9-29 09:42:17 | 显示全部楼层
不错,很好的思路。
发表于 2013-9-29 10:40:59 | 显示全部楼层
楼主,我想问下,既然你说了延时消抖会浪费CPU时间,但是在你的程序中还是有key_delay1ms这个函数的调用,这函数,不同样也会是程序停在这个地方,一样也是会浪费CPU时间啊???
 楼主| 发表于 2013-9-29 14:13:42 | 显示全部楼层
qufuta 发表于 2013-9-29 10:40
楼主,我想问下,既然你说了延时消抖会浪费CPU时间,但是在你的程序中还是有key_delay1ms这个函数的调用, ...

这个函数不一定用得着,你如果固定频率调用刷新函数这个就完全不用。如果你自己也不知道多长时间调用一次刷新,那就需要用这个来消抖。
发表于 2013-9-29 14:14:50 | 显示全部楼层
这个要顶。。。。。。。。。
发表于 2013-9-29 14:22:33 | 显示全部楼层
顶一下,不错
发表于 2013-9-29 15:16:33 | 显示全部楼层
还没仔细看,不过将三个文件打包一下方便大家下载

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x
发表于 2013-9-29 15:35:31 | 显示全部楼层
好像没法处理两个按钮同时按下的情况。(例如,两个按键,需要处理,每个按键短按,长按,以及两个按键同时按下的情况),代码是自己写的,特繁琐,测试了好用。
  1. /*---------define key's STATE-------------*/
  2. #define KEY_NORMAL                        0
  3. #define KEYA_PRESS                        1
  4. #define        KEYA_RELEASE                2
  5. #define KEYB_PRESS                        3
  6. #define KEYB_RELEASE                4
  7. #define KEYAB_PRESS                        5
  8. #define KEYA_SHORTPRESS                6
  9. #define KEYA_LONGPRESS                7
  10. #define KEYB_SHORTPRESS                8
  11. #define KEYB_LONGPRESS                9


  12. /*-----------define IO input state----*/
  13. #define KeyARelease                (P1IN & 0x01) == 0x01
  14. #define KeyBRelease                (P1IN & 0x04) == 0x04
  15. #define KeyAPress                (P1IN & 0x01) == 0
  16. #define KeyBPress                (P1IN & 0x04) == 0

  17. unsigned char KeyAction;        //
  18. unsigned char KeyState;

  19. /*===================键盘状态机函数=======================================*/
  20. void ScanKeyState(void)
  21. {
  22.         static unsigned char DelayKeyAShortPress = 0;
  23.         static unsigned char DelayKeyALongPress = 0;
  24.         static unsigned char DelayKeyBShortPress = 0;
  25.         static unsigned char DelayKeyBLongPress = 0;

  26.         switch(KeyState)
  27.         {
  28.         case KEY_NORMAL:                //there are three state to go
  29.                 if(KeyAPress && KeyBRelease)
  30.                 {
  31.                         DelayKeyAShortPress++;
  32.                         if(DelayKeyAShortPress>1)
  33.                         {
  34.                                 DelayKeyAShortPress = 0;
  35.                                 KeyState = KEYA_PRESS;
  36.                                 break;
  37.                         }
  38.                 }
  39.                 else
  40.                 {
  41.                         DelayKeyAShortPress = 0;
  42.                 }

  43.                 if(KeyBPress && KeyARelease)
  44.                 {
  45.                         DelayKeyBShortPress++;
  46.                         if(DelayKeyBShortPress>1)
  47.                         {
  48.                                 DelayKeyBShortPress = 0;
  49.                                 KeyState = KEYB_PRESS;
  50.                                 break;
  51.                         }
  52.                 }
  53.                 else
  54.                 {
  55.                         DelayKeyBShortPress = 0;
  56.                 }

  57.                 if(KeyAPress && KeyBPress)
  58.                 {
  59.                         DelayKeyAShortPress++;
  60.                         DelayKeyBShortPress++;
  61.                         if(DelayKeyAShortPress>1 && DelayKeyBShortPress>1)
  62.                         {
  63.                                 DelayKeyAShortPress = 0;
  64.                                 DelayKeyBShortPress = 0;
  65.                                 KeyState = KEYAB_PRESS;
  66.                                 break;
  67.                         }
  68.                 }
  69.                 break;

  70.         case KEYA_PRESS:                                //need to check three condition:KeyA release;KeyA Press for T1;KeyB press for t2
  71.                 if(KeyARelease)                                //if the condition is false, then goes to next "if"
  72.                 {
  73.                         //DelayKeyALongPress = 0;
  74.                         DelayKeyAShortPress++;
  75.                         if(DelayKeyAShortPress>1)
  76.                         {
  77.                                 DelayKeyAShortPress = 0;
  78.                                 KeyState = KEYA_SHORTPRESS;
  79.                                 KeyAction=1;                //KeyA short press
  80.                                 break;
  81.                         }
  82.                 }
  83.                 else if(KeyAPress && KeyBRelease)        //if the condition is false, then
  84.                 {
  85.                         DelayKeyALongPress++;
  86.                         if(DelayKeyALongPress>100)
  87.                         {
  88.                                 DelayKeyALongPress = 0;
  89.                                 DelayKeyAShortPress = 0;
  90.                                 KeyState = KEYA_LONGPRESS;
  91.                                 KeyAction=2;                        //KeyA Long Press
  92.                                 break;
  93.                         }
  94.                         //if(DelayKeyALongPress>)
  95.                 }
  96.                 else if(KeyAPress && KeyBPress)
  97.                 {
  98.                         DelayKeyALongPress++;
  99.                         DelayKeyBShortPress++;
  100.                         if(DelayKeyALongPress > 1 && DelayKeyBShortPress > 1)
  101.                         {
  102.                                 DelayKeyALongPress  = 0;
  103.                                 DelayKeyBShortPress = 0;
  104.                                 DelayKeyAShortPress = 0;
  105.                                 KeyState = KEYAB_PRESS;
  106.                                 KeyAction=5;                        //KeyA and KeyB are all Press in the same time
  107.                         }
  108.                 }
  109.                 break;
  110.         case KEYB_PRESS:
  111.                 if(KeyBRelease)
  112.                 {
  113.                         DelayKeyBShortPress++;
  114.                         if(DelayKeyBShortPress>1)
  115.                         {
  116.                                 DelayKeyBShortPress = 0;
  117.                                 KeyState = KEYB_SHORTPRESS;
  118.                                 KeyAction=3;                        //KeyB short press
  119.                                 break;
  120.                         }
  121.                 }
  122.                 else if(KeyBPress && KeyARelease)
  123.                 {
  124.                         DelayKeyBLongPress++;
  125.                         if(DelayKeyBLongPress>100)
  126.                         {
  127.                                 DelayKeyBLongPress = 0;
  128.                                 DelayKeyBShortPress = 0;
  129.                                 KeyState = KEYB_LONGPRESS;
  130.                                 KeyAction=4;                        //KeyB long press
  131.                                 break;
  132.                         }

  133.                 }
  134.                 else if(KeyBPress && KeyAPress)
  135.                 {
  136.                         DelayKeyBLongPress++;
  137.                         DelayKeyAShortPress++;
  138.                         if(DelayKeyBLongPress > 1 && DelayKeyAShortPress > 1)
  139.                         {
  140.                                 DelayKeyBLongPress  = 0;
  141.                                 DelayKeyAShortPress = 0;
  142.                                 DelayKeyBShortPress = 0;
  143.                                 KeyState = KEYAB_PRESS;
  144.                                 KeyAction=5;                        //KeyA and KeyB are all press in the same time

  145.                         }
  146.                 }
  147.                 break;
  148.         case KEYA_SHORTPRESS:
  149.                 if(KeyARelease)
  150.                 {
  151.                         DelayKeyAShortPress++;
  152.                         if(DelayKeyAShortPress>1)
  153.                         {
  154.                                 KeyState = KEY_NORMAL;
  155.                                 DelayKeyAShortPress = 0;
  156.                                 DelayKeyALongPress = 0;
  157.                         }
  158.                 }
  159.                 break;
  160.         case KEYA_LONGPRESS:
  161.                 if(KeyARelease)
  162.                 {
  163.                         DelayKeyAShortPress++;
  164.                         if(DelayKeyAShortPress>1)
  165.                         {
  166.                                 KeyState = KEY_NORMAL;
  167.                                 DelayKeyAShortPress = 0;
  168.                                 DelayKeyALongPress = 0;
  169.                         }
  170.                 }
  171.                 break;
  172.         case KEYB_SHORTPRESS:
  173.                 if(KeyBRelease)
  174.                 {
  175.                         DelayKeyBShortPress++;
  176.                         if(DelayKeyBShortPress>1)
  177.                         {
  178.                                 KeyState = KEY_NORMAL;
  179.                                 DelayKeyBShortPress = 0;
  180.                                 DelayKeyBLongPress = 0;
  181.                         }
  182.                 }
  183.                 break;
  184.         case KEYB_LONGPRESS:
  185.                 if(KeyBRelease)
  186.                 {
  187.                         DelayKeyBShortPress++;
  188.                         if(DelayKeyBShortPress>1)
  189.                         {
  190.                                 KeyState = KEY_NORMAL;
  191.                                 DelayKeyBShortPress = 0;
  192.                                 DelayKeyBLongPress = 0;
  193.                         }
  194.                 }
  195.                 break;

  196.         case KEYAB_PRESS:
  197.                 if(KeyARelease && KeyBRelease)
  198.                 {
  199.                         DelayKeyAShortPress++;
  200.                         DelayKeyBShortPress++;
  201.                         if(DelayKeyAShortPress>1 && DelayKeyBShortPress>1)
  202.                         {
  203.                                 KeyState = KEY_NORMAL;
  204.                                 DelayKeyBShortPress = 0;
  205.                                 DelayKeyBLongPress = 0;
  206.                         }
  207.                 }
  208.                 break;
  209.         }
  210. }
复制代码
 楼主| 发表于 2013-9-29 15:41:59 | 显示全部楼层
皮爱了西 发表于 2013-9-29 15:35
好像没法处理两个按钮同时按下的情况。(例如,两个按键,需要处理,每个按键短按,长按,以及两个按键同时 ...

可以处理多个按键同时操作(同时按下),在底层都一样,直接调用就可以了。主要是在你的应用中进行判断,比如多个键同时按下时,相关按键的->times都不为零。那就知道是组合键了。
发表于 2013-9-29 18:52:18 | 显示全部楼层
建议你看看这个帖子,他写的非常号,整体结构非常完整,当然你写的也不错,http://www.amobbs.com/thread-5542774-1-1.html
发表于 2013-9-29 20:29:53 | 显示全部楼层
先顶一个  哈哈
发表于 2013-9-29 20:31:35 | 显示全部楼层
吾好东西顶一下以后再看
发表于 2013-9-29 20:37:06 | 显示全部楼层
不错  顶一下
发表于 2013-9-29 20:55:34 | 显示全部楼层
不错,学习
发表于 2013-9-30 08:39:47 | 显示全部楼层
标记了,留待以后使用!
发表于 2013-9-30 09:14:28 | 显示全部楼层
可以有按键连击吗?
许多情况下按键需要有按住一个键不松手,一定时间后按键会自动按一个固定时间连续输出。这个键一般用在数据的加减设置中。希望楼主能增加这个功能。
发表于 2013-9-30 09:15:49 | 显示全部楼层
MARK,谢谢分享
发表于 2013-9-30 14:43:09 | 显示全部楼层
好贴 ,Mark
 楼主| 发表于 2013-9-30 16:12:05 | 显示全部楼层
wtliu 发表于 2013-9-30 09:14
可以有按键连击吗?
许多情况下按键需要有按住一个键不松手,一定时间后按键会自动按一个固定时间连续输出 ...

谢谢你的建议。其实这个功能只要用户定时判断->state = KEY_DOWN就能实现了。当然封装到void Key_RefreshState(key_inf_type* theKey)这个函数,作为它的返回值就方便多了。
 楼主| 发表于 2013-9-30 16:16:39 | 显示全部楼层
wtliu 发表于 2013-9-30 09:14
可以有按键连击吗?
许多情况下按键需要有按住一个键不松手,一定时间后按键会自动按一个固定时间连续输出 ...

关于连击,我想在用户定时调用更新函数时实现,因为连击和时间相关。不想因为判断连击而占用CPU大量资源。
发表于 2013-10-14 16:30:13 | 显示全部楼层
不错。谢谢楼主,功能比较强大
发表于 2013-10-14 16:40:49 | 显示全部楼层
mark
发表于 2013-10-15 20:49:09 | 显示全部楼层
似乎有点复杂啊
发表于 2014-2-19 08:54:19 | 显示全部楼层
需要不停地扫描按键吧...
发表于 2014-2-19 11:27:02 | 显示全部楼层
MARK,谢谢分享
发表于 2014-2-19 12:35:43 | 显示全部楼层
学习一下!
发表于 2014-5-8 13:30:05 | 显示全部楼层
厉害 学习了
发表于 2014-5-17 15:40:46 | 显示全部楼层
Jach_cc 发表于 2013-9-28 22:45
对了啊,这个忘了说,使用如下(avr例,矩阵键盘):

key_inf_type key_up; //定义上键

不懂avr不知道你检测状态是什么意思!!!
发表于 2014-5-17 18:13:41 | 显示全部楼层

STM32移植成功,有工程文件

本帖最后由 10xjzheng 于 2014-5-17 18:23 编辑

移植成功,一下午的时间总算没有白费,分享一下。测试正常,你按住一个按键,随便都可以同时控制另一个按键。有空楼主留个QQ交流下你写程序的思路。而且我只是用了最简单的按键获取,没有什么复杂的长按短按的,求楼主教下。
有个问题楼主需要解决。
根据楼主介绍的使用办法,是要用到下面这行代码的,
  1. Key_AccessTimes(&key_up, KEY_ACCESS_WRITE|KEY_ACCESS_CLEAR ) ;//清除按键状态
复制代码
这是不对的,首先看函数uint8_t Key_AccessTimes(key_inf_type* theKey, access_type option ),后面这个参数是枚举变量,但是这个枚举变量没有KEY_ACCESS_WRITE|KEY_ACCESS_CLEAR里面没有这个吧,所以呢?我就给枚举类型access_type增加了一种写入按键消除状态的枚举变量KEY_ACCESS_WRITE_CLEAR=KEY_ACCESS_WRITE|KEY_ACCESS_CLEAR,在枚举类型定义那里。应该还可以将函数的形参option类型改成其他的形式,编译的时候就不会出错了。
我用的板子是野火的ISO,芯片STM32,原理图如下:


把上面的问题解决之后,在Key.c里面增加多下面的函数,只列举了一个按键!一个按键2个定义的函数,而且内容都差不多!!这个就爽爆了,移植很容易。首先是状态获取,如果IO口是你按键按下对应的电平,那么返回1,否则返回0,可以看到我这是不是组合按键,简单到爆有木有!!第二个函数是GPIO的初始化,STM32必须的,51的就可以省了。
  1. /****************************************************用户自定义函数***********************************/
  2. uint8_t Key1_State(void)
  3. {
  4.         if(GPIO_ReadInputDataBit(KEY1_PORT,KEY1_PIN)==KEY_ON)
  5.         {
  6.                         return 1;
  7.         }
  8.         else
  9.         {
  10.                         return 0;
  11.         }
  12. }
  13. //按键接A0
  14. void Key1_GPIO_Config(void)
  15. {
  16.         GPIO_InitTypeDef GPIO_InitStructure;
  17.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  18.         GPIO_InitStructure.GPIO_Pin=KEY1_PIN;
  19.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
  20.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
  21.         GPIO_Init(KEY1_PORT,&GPIO_InitStructure);
  22. }
  23. /***************************************用户自定义函数结束***********************************/
复制代码
在key.h里面主要是管脚的宏定义,方便修改和移植,不用也是可以的,后面是声明上面两个函数的部分
  1. /*****************************************用户定义声明部分************************************************/
  2. //用户定义变量
  3. #define KEY_ON  0
  4. #define KEY_OFF 1
  5. #define KEY1_PIN  GPIO_Pin_0
  6. #define KEY1_PORT GPIOA
  7. //用户定义变量结束

  8. //用户函数声明
  9. uint8_t Key1_State(void);
  10. void Key1_GPIO_Config(void);
  11. //用户函数声明结束
  12. /*****************************************用户定义声明部分************************************************/
复制代码
真的是感谢作者。工程文件:,如果是想移植到其他的STM32板子,就把端口在宏定义那里改成对应的就可以啦。
我刷新是用systick做后台的一个任务调度,在刷新那里可以看到,
  1. Task_Delay[0]=50;
复制代码
这个每1ms会自动减一,50个就是50ms进入一次任务,只有=0的时候才能进入刷新任务,所以这个是20Hz的。


本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x
发表于 2014-6-12 13:52:14 | 显示全部楼层
学习了,谢谢
发表于 2014-6-17 14:13:25 | 显示全部楼层

mark 按键 学习了
发表于 2014-7-20 00:16:30 | 显示全部楼层
10xjzheng 发表于 2014-5-17 15:40
不懂avr不知道你检测状态是什么意思!!!


同问,这个有点悬虚。 对没有用过AVR的人,真是。。。
发表于 2014-7-20 00:55:51 来自手机 | 显示全部楼层
这个要好好学习并消化一下,正准备做按键,
发表于 2014-7-20 01:20:50 | 显示全部楼层
难道矩阵只用了PortD3:5和 portB ???

uint8_t KeyUp_state(void)
{
        PORTD |= ( (1u<<PORTD4)|(1u<<PORTD5) );    // PORTD[4:5] 输出1
        PORTD &= ( ~(1u<<PORTD3) );    // PORTD[3] 输出0
        asm("nop");//等待电平稳定
        if( (PINB&0x02)!=0x02 )  //检测 PortB 输入状态。 难道矩阵只用了PortD3:5和 portB
        {
                return 1;
        }else
        {
                return 0;
        }
}
发表于 2014-7-20 15:52:25 | 显示全部楼层
ppdd 发表于 2014-7-20 01:20
难道矩阵只用了PortD3:5和 portB ???

uint8_t KeyUp_state(void)

这个其实很简单,意思是说,如果现在检测出来IO口的电平跟你按键按下时候IO口的电平是一样的,那么返回1,否则返回0.
发表于 2014-7-20 16:22:07 | 显示全部楼层
这个真心,没看明白,用来做什么???
typedef enum
{
        KEY_ACCESS_READ         = 0x08,
        KEY_ACCESS_WRITE        = 0x80,
        KEY_ACCESS_CLEAR        = 0X40,
        KEY_ACCESS_DECREASE = 0X20,
        KEY_ACCESS_INCREASE = 0X10, ///??????? ÓÐûÓжººÅÄØ       
}access_type;
发表于 2014-8-19 21:04:16 | 显示全部楼层
没有看到松手检测,不会连发吗?
发表于 2014-9-1 11:34:16 | 显示全部楼层
按键还是比较复杂的~
发表于 2014-9-1 13:12:06 来自手机 | 显示全部楼层
顶!家常便饭做得好吃并非易事!
发表于 2014-9-1 20:26:20 | 显示全部楼层
本帖最后由 superplaim 于 2014-9-1 20:29 编辑

请教楼主这个uint8_t (*get_state)(void);是个什么意思 语法上表示什么
这是定义了个指针变量吗 加void是什么意思
发表于 2014-11-10 16:44:26 | 显示全部楼层
发表于 2015-5-27 09:31:34 | 显示全部楼层
10xjzheng 发表于 2014-5-17 18:13
移植成功,一下午的时间总算没有白费,分享一下。测试正常,你按住一个按键,随便都可以同时控制另一个按键 ...

你好,请问 一下*(theKey->get_state))()到底是什么意思啊看不懂
发表于 2015-7-13 23:13:50 | 显示全部楼层
请问楼主,这些与编译器有关的东西能不能直接去掉啊!!!在keil下始终编译不过啊!!!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x
发表于 2015-7-14 07:47:36 | 显示全部楼层
很详细的按键
发表于 2015-7-14 08:07:38 | 显示全部楼层
互斥量。。研究一下。。以前没有这么使用过。
发表于 2015-7-14 08:37:13 | 显示全部楼层
很好 学习一下
发表于 2015-8-21 13:00:25 | 显示全部楼层
非常感谢楼主资料,我使用飞思卡尔M0移植成功了。现在有个疑问想请教楼主:
我在10ms伺服周期刷新按键状态,看了下函数,总感觉无论如何都要执行
key_delay1ms(KEY_WOBBLE_TIME);          // 去抖动函数
请指教,谢谢。


                        case KEY_UP:
                        {
                                if((*(theKey->get_state))())                // »ñÈ¡µçƽ״̬
                                {
                                        #ifdef  KEY_FIXED_PERIOD
                        theKey->time_ms = 0;
                        theKey->state = KEY_DOWN_WOBBLE;    // ½øÐÐÏû¶¶ÑÓʱ
                                        #else
                                        theKey->state = KEY_DOWN_WOBBLE;
                    
                                        key_delay1ms(KEY_WOBBLE_TIME);          // È¥¶¶¶¯
                    
                                        if((*(theKey->get_state))())
                                        {
                                                theKey->state = KEY_DOWN;
                                        }
                                        #endif
                                }
                        }

                        case KEY_DOWN:
                        {
                                if((*(theKey->get_state))() == 0)
                                {
                                        #ifdef  KEY_FIXED_PERIOD
                        theKey->time_ms = 0;
                        theKey->state = KEY_UP_WOBBLE;      // ½øÐÐÏû¶¶ÑÓʱ
                                        #else
                                        key_delay1ms(KEY_WOBBLE_TIME);
                    
                                        if((*(theKey->get_state))() == 0)
                                        {
                                                theKey->state = KEY_UP;
                                                theKey->times++;
                                                if( theKey->times > 250)
                                                        theKey->times = 250;            // ×î¶àÔÊÐí°´ÏÂ250´Îû´¦Àí
                                        }
                                        #endif
                                }
                        }

发表于 2015-10-9 17:04:29 | 显示全部楼层
好东西,统统MARK...
发表于 2016-3-8 16:49:41 | 显示全部楼层
强  学习了!!!
发表于 2016-6-19 11:39:40 | 显示全部楼层
试了,效果不错
发表于 2017-3-24 02:29:50 | 显示全部楼层
mark
发表于 2017-3-30 23:07:22 | 显示全部楼层
有创意,有风格。
发表于 2018-9-20 10:54:55 | 显示全部楼层
个人觉得应该从一个软件的整体上来考虑按键程序。
1 可以将按键底层驱动与应用层分开,应用层与按键底层通过一个循环队列来交互。
2 底层驱动只负责向队列里放按键消息,应用层只需要从队列里取消息即可。
3 按照这个思想,整个软件结构就非常的清晰了。
发表于 2018-9-20 11:08:12 | 显示全部楼层
用了很好用,谢谢。
发表于 2018-9-20 13:43:03 | 显示全部楼层
学习学习,谢谢分享
友情提示:标题不合格、重复发帖,将会被封锁ID。详情请参考:论坛通告:封锁ID、获得注册邀请码、恢复被封ID、投诉必读
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|阿莫电子论坛(原ourAVR/ourDEV) ( 公安备案:44190002001997(交互式论坛) 工信部备案:粤ICP备09047143号 )

GMT+8, 2019-9-18 18:22

阿莫电子论坛, 原"中国电子开发网"

© 2004-2018 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表