[버튼][독립 버튼] - 2: 더블 클릭

14857 단어 더블 클릭버튼
2. [더블 클릭] 프로그램
1. 소개를 더블 클릭
4
  • 더블 클릭의 판정은 첫 번째 [클릭]을 완성한 후 일정한 시간 간격(본 프로그램은 300ms를 사용), 이어서 두 번째 [클릭]을 완성하고 [더블 클릭]으로 판정한다

  • 4
  • 두 번 클릭한 응답 1) 미리 설정한 시간 간격으로 두 번째 [클릭]을 완성하고 키를 눌렀을 때 응답은 유효한 키 값[두 번 클릭]으로 돌아간다.2) 두 번째 키를 계속 누르면 설정된 간격(300ms)을 초과하면 첫 번째 [클릭]에 응답하고 유효한 키 값[클릭]을 반환합니다.주:[클릭]은 버튼을 누르고 놓는 과정을 포함하고 판정 방식은 위에서 말한 바와 같이 잊어버리면 윗글을 참고할 수 있습니다

  • 4
  • 더블 클릭 응답 시퀀스 그림
  • 주: T1: 클릭 판정 시간, 범위: 30ms 2. 키보드 구조
    버튼 프로그램은 네 가지 부분으로 나눌 수 있는데 첫 번째 부분은 버튼이 있는지 없는지를 판단하는 것이다.두 번째 부분: 두 번 클릭하는 것이 미리 설정한 시간 간격 내에 두 번째 [클릭]이 있는지 판단한다.세 번째 부분: 버튼이 풀리기를 기다린다.
    3. 프로그램의 원본 코드와 주석을 더블 클릭
    프로그램의 주석은 매우 상세하게 쓰여 있어서 읽을 수 있을 것이며, 의문이 있으면 댓글로 토론할 수 있다.위의 [클릭] 함수는 이번 [더블 클릭] 프로그램의 하위 함수 이하로 키입니다.c의 소스 코드:
    // =========================== key.c ======================
    #include"reg51.h"
    
    #define KEY_INPUT P1.0 //   IO
    
    #define KEY_STATE_0 0 //     
    #define KEY_STATE_1 1
    #define KEY_STATE_2 2
    #define KEY_STATE_3 3
    
    #define SINGLE_KEY_TIME 3 // SINGLE_KEY_TIME*10MS = 30MS          ,    
    #define KEY_INTERVAL 30 // KEY_INTERVAL*10MS = 300MS          
    #define LONG_KEY_TIME 300 // LONG_KEY_TIME*10MS = 3S          
    
    
    #define N_KEY 0 // no click
    #define S_KEY 1 // single click
    #define D_KEY 2 // double click
    #define L_KEY 10 // long press
    
    // ----------------------------------- key_driver --------------------------
    unsigned char key_driver(void) 
    {     
        static unsigned char key_state = 0;
        static unsigned int  key_time = 0;
        unsigned char key_press, key_return; 
    
        key_return = N_KEY;                         //         
    
        key_press = key_input;                      //       
    
        switch (key_state)     
        {       
            case KEY_STATE_0:                       //     0:        
                if (!key_press)                     //      
                {
                    key_time = 0;                   //         
                    key_state = KEY_STATE_1;        //          1
                }        
                break;
    
            case KEY_STATE_1:                       //     1:    (        ,     )。       :               。
                if (!key_press)                     
                {
                    key_time++;                     //   10ms
                    if(key_time>=SINGLE_KEY_TIME)   //      :SINGLE_KEY_TIME*10ms = 30ms;
                    {
                        key_state = KEY_STATE_2;    //              ,           。        :      ,       2,              
                    }
                }         
                else key_state = KEY_STATE_0;       //           ,     ,    ,       0,      
                break; 
    
            case KEY_STATE_2:                       //     2:         :   ,    
                if(key_press)                       //                  ,      
                { 
                     key_return = S_key;            //         :  
                     key_state = KEY_STATE_0;       //        0,      
                } 
                else
                {
                    key_time++;                     
    
                    if(key_time >= LONG_KEY_TIME)   //                 (LONG_KEY_TIME*10ms=300*10ms=3000ms),        
                    {
                        key_return = L_KEY;         //         :  
                        key_state = KEY_STATE_3;    //    3,      
                    }
                }
                break;
    
          case KEY_STATE_3:                         //       
              if (key_press) 
              {
                  key_state = KEY_STATE_0;          //      ,       0 ,          
              }        
              break; 
    
            default:                                //     :key_state       ,  key_state。               key_state,            
                key_state = KEY_STATE_0;
                break;
        }
    
        return  key_return;                         //       
    } 
    
    // ----------------------------------- key_read --------------------------------
    void key_read(void)                             
    { 
        static unsigned char key_state1=0, key_time1=0;
        unsigned char key_return,key_temp;
    
        key_return = N_KEY;                         //         
    
        key_temp = key_driver();                    //     
    
        switch(key_state1) 
        {         
            case KEY_STATE_0:                       //     0:      (   key_driver         )
                if (key_temp == S_key )             //    [  ],          ,        1,     [  ]   
                { 
                     key_time1 = 0;                 //     
                     key_state1 = KEY_STATE_1; 
                }             
                else                                //     [  ],       。         :[  ],[    ]
                {
                     key_return = key_temp;         //       
                }
                break;
    
            case KEY_STATE_1:                       //     1:     [  ]
                if (key_temp == S_key)              //  [  ] ,           (KEY_INTERVAL*10ms=30*10ms=300ms)  ,   [  ],  [  ],              [  ],        2,     [  ]
                {              
                     key_return = D_key;            //        :[  ]
                     key_state1 = KEY_STATE_0;      //        0,        
                } 
                else                                //  [  ] ,           (KEY_INTERVAL*10ms=30*10ms=300ms) ,  [  ]  ,     [  ]
                {
                    key_time1++;                    //        
                    if(key_time1 >= KEY_INTERVAL)   //        
                     { 
                          key_return = S_key;       //        :[  ]
                          key_state1 = KEY_STATE_0; //        0,        
                     }              
                 }              
                 break; 
    
            default:                                //     :key_state       ,  key_state。               key_state,            
                key_state1 = KEY_STATE_0;
                break;
        }
    
        return = key_return;                        //       
    }     
    

    참고: 1) 하드웨어: 키의 한쪽 끝 접지(GND), 다른 한쪽 끝 입출력 포트를 사용합니다.입출력을 입력하려면 반드시 위로 당기는 저항이 있어야 한다.2) 타이머: 여기는 정확한 타이머를 위해 타이머를 사용했습니다. 타이머의 시간은 10ms입니다.3) 검색 주기: 이 함수를 호출할 때반드시 검사 주기"10ms 미만이어야 합니다. 그렇지 않으면 버튼 안에 관련된 시간이 정확하지 않고 커질 수 있습니다. 관련된 시간은 떨림 해소 시간이 길고 버튼 길이가 시간 등을 포함합니다. 스캔 주기 정의: 첫 번째 버튼 스캔 프로그램에 들어갔을 때부터 두 번째 버튼 스캔 프로그램에 들어갔을 때 끝날 때까지 소요되는 시간입니다. 스캔 주기 측정 방법: 버튼 스캔 프로그램의 첫 문장에 IO 인출 함수를 추가하고 표시를 사용할 수 있습니다.파기는 입출력을 바꾸는 것을 보았는데, 입출력의 주기는 일반적으로 스캐닝 주기이다.4) 상기 프로그램의 시간에 관한 세 가지 매크로에 특히 주의하는 것이 상당히 중요하다.버튼의 클릭 민감도를 변경하려면, 두 번 클릭의 속도, 또는 오래 누르려면 매크로의 값을 수정하면 됩니다.예를 들어 노인을 위한 버튼은 더블 클릭의 속도를 천천히 조절해야 KEYINTERVAL 값이 증가합니다.
  • SINGLE_KEY_TIME: 클릭의 민감도, 값이 작을수록 민감합니다
  • KEY_INTERVAL: 더블 클릭 속도, 이 값을 수정하면 작을수록 속도가 빨라집니다.동시에 이 값은 클릭의 응답 시간을 결정한다. 클릭한 후에 이 시간 간격에 두 번째 클릭이 없다는 것을 판단해야 하기 때문에 클릭이 진정한 클릭이 아니라면 클릭의 응답 시간은 다음과 같다. SINGLEKEY_TIME+KEY_INTERVAL;
  • LONG_KEY_TIME: 오래 누를수록 이것을 수정하면 됩니다. 값이 클수록 시간이 길어집니다

  • 4. 버튼 프로그램의 사용 실례
    다음은 C51비트 하드웨어 플랫폼의 인스턴스 설명 1) 인스턴스 프로그램의 기능입니다.
    4
  • 클릭: LED1 강조 표시
  • 더블 클릭: LED1 끄기
  • 4
  • 길게 누르기: LED1 끄기 4
  • 2) 하드웨어:
    4
  • 키 IO: P1.0
  • LED1 :P2.0

  • 아래는main.c 소스 코드:
    // =========================== key.c ======================
    
    #include "reg51.h"
    #include "key.c"
    
    sbit LED1 = P2.0;                   //   LEDIO 
    
    unsigned char g_u8_KeyValue;        //    
    unsigned char g_flag_10ms_key;      // 10ms     
    
    
    void key_read();                    //         
    
    
    void T0_Init_10ms(void)             // timer0,      ,      10ms
    {
        TMOD |= 0x01;
        TH0 = (65535 - 10000)/256;
        TL0 = (65535 - 10000)%256;
    
        ET0 = 1;
        TR0 = 1;
        EA = 1;
    }
    
    //    
    void main(void)
    {
        P1.0 = 1;                                   // P1.0   
        T0_Init_10ms();                             //    0,   ,  10ms
    
        while(1)
        {
            if(g_flag_10ms_key)                     //   10ms,    
            {
                g_flag_10ms_key = 0;                //   10ms    
    
                g_u8_KeyValue = key_read();         //      
    
                switch(g_u8_KeyValue)
                {
                    case S_Key: LED1 = 1; break;    //      LED1
                    case D_Key: LED1 = 0; break;    //      LED1
                    case L_Key: LED1 = 0; break;    //      LED1
                }
            }
        }
    }
    
    // timer0       
    void IRQ_T0(void) interrupt 1
    {
        g_flag_10ms_key = 1;                        //    10ms     
    }

    Pillar Peng 2016.3.29 10:25
    ———-
    나머지 공유 링크:
    첫 부분:[버튼][독립 버튼] - 1: 클릭
    3부:[버튼][독립 버튼] - 3:3타격 및 N타격

    좋은 웹페이지 즐겨찾기