key.lst

扫描按键的程序

 117           ************************************************/
 118          unsigned char KEY2_JUDGE()
 119          {
 120   1       if(IsKEY2_ON)                                                                    //按键被按下时做如下判断
 121   1        {
 122   2          KEY2_Cnt++; 
 123   2              if(KEY2_Cnt>SHORT_BOUND)
 124   2           {
 125   3                KEY2_Now=KeyON;
 126   3                if(KEY2_Cnt>LONG_BOUND)                                                 //当KEY2_Cnt超过长按计数上界时判断为长按
 127   3                 {                                                                                      
 128   4                      KEY2_Cnt=LIMIT;                                                           //对KEY2_Cnt赋值作为下次计数的初值，LIMIT越大（上限为LONG_BOUND），下次LONG_
             -PRESS判断来的越快
 129   4                      KEY2_Fore=KEY2_Now;                                                       //记录上次按键为KeyON
 130   4                      return LONG_PRESS;
 131   4                 }
 132   3                if(KEY2_Fore==KeyOFF&&KEY2_Now==KeyON)                  //当上次按键为KeyOFF并且当前按键为KeyON时，判断为短按
 133   3                 {
 134   4                  KEY2_Fore=KEY2_Now;                                                   //记录上次按键为KeyON
 135   4                      return SHORT_PRESS;
 136   4                 }      
 137   3               }
 138   2               return NOP;                                                                      //当判断不明确时，返回NOP（分别在“去抖”和再次判断LONG_PRESS时）
 139   2        } 
 140   1       else  
 141   1        {                                                                                                       //按键没被按下，不做判断,返回NO_PRESS
 142   2         KEY2_Now=KeyOFF;                                                                       //则记录当前按键为KeyOFF
 143   2         KEY2_Cnt=0;                                                                            //计数清零
 144   2         KEY2_Fore=KEY2_Now;                                                            //记录上次按键为KeyOFF
 145   2         return NO_PRESS;
 146   2        }
 147   1      }
 148          /*************************************************
 149           *函数名：KEY3_JUDGE()
 150           *入口参数：无
 151           *出口参数：LONG_PRESS,SHORT_PRESS,NO_PRESS
 152           *说明: 当按键3被长时间按下时，返回LONG_PRESS;
 153           *              当按键3被短时间按下时，返回SHORT_PRESS;
 154           *      当按键3没有被按下时，返回NO_PRESS;
 155           *      在按键按下但尚未到明确状态时返回NOP;
 156           ************************************************/
 157          unsigned char KEY3_JUDGE()
 158          {
 159   1       if(IsKEY3_ON)                                                                    //按键被按下时做如下判断
 160   1        {
 161   2          KEY3_Cnt++; 
 162   2              if(KEY3_Cnt>SHORT_BOUND)
 163   2           {
 164   3                KEY3_Now=KeyON;
 165   3                if(KEY3_Cnt>LONG_BOUND)                                                 //当KEY3_Cnt超过长按计数上界时判断为长按
 166   3                 {                                                                                      
 167   4                      KEY3_Cnt=LIMIT;                                                           //对KEY3_Cnt赋值作为下次计数的初值，LIMIT越大（上限为LONG_BOUND），下次LONG_
             -PRESS判断来的越快
 168   4                      KEY3_Fore=KEY3_Now;                                                       //记录上次按键为KeyON
 169   4                      return LONG_PRESS;
 170   4                 }
 171   3                if(KEY3_Fore==KeyOFF&&KEY3_Now==KeyON)                  //当上次按键为KeyOFF并且当前按键为KeyON时，判断为短按
 172   3                 {
 173   4                  KEY3_Fore=KEY3_Now;                                                   //记录上次按键为KeyON
 174   4                      return SHORT_PRESS;
 175   4                 }      
C51 COMPILER V8.02   KEY                                                                   04/02/2008 13:21:35 PAGE 4   

 176   3               }
 177   2               return NOP;                                                                      //当判断不明确时，返回NOP（分别在“去抖”和再次判断LONG_PRESS时）
 178   2        } 
 179   1       else  
 180   1        {                                                                                                       //按键没被按下，不做判断,返回NO_PRESS
 181   2         KEY3_Now=KeyOFF;                                                                       //则记录当前按键为KeyOFF
 182   2         KEY3_Cnt=0;                                                                            //计数清零
 183   2         KEY3_Fore=KEY3_Now;                                                            //记录上次按键为KeyOFF
 184   2         return NO_PRESS;
 185   2        }
 186   1      }
 187          /*************************************************
 188           *函数名：KEY4_JUDGE()
 189           *入口参数：无
 190           *出口参数：LONG_PRESS,SHORT_PRESS,NO_PRESS
 191           *说明: 当按键4被长时间按下时，返回LONG_PRESS;
 192           *              当按键4被短时间按下时，返回SHORT_PRESS;
 193           *      当按键4没有被按下时，返回NO_PRESS;
 194           *      在按键按下但尚未到明确状态时返回NOP;
 195           ************************************************/
 196          unsigned char KEY4_JUDGE()
 197          {
 198   1       if(IsKEY4_ON)                                                                    //按键被按下时做如下判断
 199   1        {
 200   2          KEY4_Cnt++; 
 201   2              if(KEY4_Cnt>SHORT_BOUND)
 202   2           {
 203   3                KEY4_Now=KeyON;
 204   3                if(KEY4_Cnt>LONG_BOUND)                                                 //当KEY4_Cnt超过长按计数上界时判断为长按
 205   3                 {                                                                                      
 206   4                      KEY4_Cnt=LIMIT;                                                           //对KEY4_Cnt赋值作为下次计数的初值，LIMIT越大（上限为LONG_BOUND），下次LONG_
             -PRESS判断来的越快
 207   4                      KEY4_Fore=KEY1_Now;                                                       //记录上次按键为KeyON
 208   4                      return LONG_PRESS;
 209   4                 }
 210   3                if(KEY4_Fore==KeyOFF&&KEY4_Now==KeyON)                  //当上次按键为KeyOFF并且当前按键为KeyON时，判断为短按
 211   3                 {
 212   4                  KEY4_Fore=KEY4_Now;                                                   //记录上次按键为KeyON
 213   4                      return SHORT_PRESS;
 214   4                 }      
 215   3               }
 216   2               return NOP;                                                                      //当判断不明确时，返回NOP（分别在“去抖”和再次判断LONG_PRESS时）
 217   2        } 
 218   1       else  
 219   1        {                                                                                                       //按键没被按下，不做判断,返回NO_PRESS
 220   2         KEY4_Now=KeyOFF;                                                                       //则记录当前按键为KeyOFF
 221   2         KEY4_Cnt=0;                                                                            //计数清零
 222   2         KEY4_Fore=KEY1_Now;                                                            //记录上次按键为KeyOFF
 223   2         return NO_PRESS;
 224   2        }
 225   1      }


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =    268    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =      4    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =      8    ----
END OF MODULE INFORMATION.

C51 COMPILER V8.02   KEY                                                                   04/02/2008 13:21:35 PAGE 5   


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)