⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 keypad.lst

📁 MSTARXX.rar
💻 LST
字号:
C51 COMPILER V8.18   KEYPAD                                                                09/29/2009 23:58:03 PAGE 1   


C51 COMPILER V8.18, COMPILATION OF MODULE KEYPAD
OBJECT MODULE PLACED IN ..\..\1out\Keypad.obj
COMPILER INVOKED BY: d:\Keil\C51\BIN\C51.EXE ..\..\msFunc\Keypad.c BROWSE INCDIR(..\..\inc) DEBUG OBJECTEXTEND PRINT(..\
                    -..\1out\Keypad.lst) OBJECT(..\..\1out\Keypad.obj)

line level    source

   1          #define _KEYPAD_C_
   2          
   3          #include <math.h>
   4          #include "types.h"
   5          #include "board.h"
   6          #include "ms_reg.h"
   7          #include "global.h"
   8          #include "keypaddef.h"
   9          #include "DEBUG.h"
  10          #include "misc.h"
  11          #include "ms_rwreg.h"
  12          #include "Reg52.h"
  13          #include "ir.h"
  14          #include "menu.h"
  15          #include "keypad.h"
  16          
  17          //===============================================================
  18          #define MAX_KEYVALUE        0x3F
  19          #define HIGHLEVEL           0x3A
  20          #define KeyJitterCounter        15
  21          #define KeyStableCounter        1
  22          #define KEY_Idle            0xFF
  23          
  24          BYTE Key_ScanValue(BYTE KeyAdcPort)
  25          {
  26   1          if(KeyAdcPort==ADCKEY1)
  27   1              g_ucCurrentKeyADC[KeyAdcPort]=PKEYADC1;
  28   1          else
  29   1              g_ucCurrentKeyADC[KeyAdcPort]=PKEYADC2;
  30   1      
  31   1              return g_ucCurrentKeyADC[KeyAdcPort];
  32   1      }
  33          
  34          
  35          BYTE Key_GetKeypadStatus(void)
  36          {
  37   1                  //BYTE KeyData = KEY_NOTHING;
  38   1                  BYTE ADCValue;
  39   1      
  40   1      #if(KEY_TYPE==Single_ADCKey)
              //------------------------------------------------
                              ADCValue=Key_ScanValue(ADCKEY1);
              
                              if (ADCValue < (KEY_AD_L0 + KEY_AD_DELTA)&&ADCValue > (KEY_AD_L0 - KEY_AD_DELTA))
                                  {
                                  if(g_ucKeyStableCountBuff[KEY_POWER]++>KeyStableCounter)
                                      {
                                          return KEY_POWER;
                                      }
                                  }
                      else if (ADCValue < (KEY_AD_L1+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L1 - KEY_AD_DELTA))
                          {
                                  if(g_ucKeyStableCountBuff[KEY_MENU]++>KeyStableCounter)
                                      {
C51 COMPILER V8.18   KEYPAD                                                                09/29/2009 23:58:03 PAGE 2   

                                          return KEY_MENU;
                                      }
                          }
                      else if (ADCValue < (KEY_AD_L2+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L2 - KEY_AD_DELTA))
                          {
                                  if(g_ucKeyStableCountBuff[KEY_LEFT]++>KeyStableCounter)
                                      {
                                          return KEY_LEFT;
                                      }
                          }
                      else if (ADCValue < (KEY_AD_L3+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L3 - KEY_AD_DELTA))
                          {
                                  if(g_ucKeyStableCountBuff[KEY_RIGHT]++>KeyStableCounter)
                                      {
                                          return KEY_RIGHT;
                                      }
                          }
                      else if (ADCValue < (KEY_AD_L4+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L4 - KEY_AD_DELTA))
                          {
                                  if(g_ucKeyStableCountBuff[KEY_DOWN]++>KeyStableCounter)
                                      {
                                          return KEY_DOWN;
                                      }
                          }
                      else if (ADCValue < (KEY_AD_L5+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L5 - KEY_AD_DELTA))
                          {
                                  if(g_ucKeyStableCountBuff[KEY_UP]++>KeyStableCounter)
                                      {
                                          return KEY_UP;
                                      }
                          }
              
              #elif(KEY_TYPE==Dual_ADCKey)
  88   1      //------------------------------------------------
  89   1                      ADCValue=Key_ScanValue(ADCKEY1);
  90   1                      if (ADCValue < (KEY_AD_L0 + KEY_AD_DELTA)&&ADCValue > (KEY_AD_L0 - KEY_AD_DELTA))
  91   1                          {
  92   2                          if(g_ucKeyStableCountBuff[KEY_RIGHT]++>KeyStableCounter)
  93   2                              {
  94   3                                  return KEY_RIGHT;
  95   3                              }
  96   2                          }
  97   1              else if (ADCValue < (KEY_AD_L1+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L1 - KEY_AD_DELTA))
  98   1                  {
  99   2                          if(g_ucKeyStableCountBuff[KEY_LEFT]++>KeyStableCounter)
 100   2                              {
 101   3                                  return KEY_LEFT;
 102   3                              }
 103   2                  }
 104   1              else if (ADCValue < (KEY_AD_L2+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L2 - KEY_AD_DELTA))
 105   1                  {
 106   2                          if(g_ucKeyStableCountBuff[KEY_UP]++>KeyStableCounter)
 107   2                              {
 108   3                                  return KEY_UP;
 109   3                              }
 110   2                  }
 111   1              else if (ADCValue < (KEY_AD_L3+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L3 - KEY_AD_DELTA))
 112   1                  {
 113   2                          if(g_ucKeyStableCountBuff[KEY_DOWN]++>KeyStableCounter)
 114   2                              {
 115   3                                  return KEY_DOWN;
 116   3                              }
C51 COMPILER V8.18   KEYPAD                                                                09/29/2009 23:58:03 PAGE 3   

 117   2                  }
 118   1      
 119   1                      ADCValue=Key_ScanValue(ADCKEY2);
 120   1                      if (ADCValue < (KEY_AD_L0 + KEY_AD_DELTA)&&ADCValue > (KEY_AD_L0 - KEY_AD_DELTA))
 121   1                          {
 122   2                          if(g_ucKeyStableCountBuff[KEY_POWER]++>KeyStableCounter)
 123   2                              {
 124   3                                  return KEY_POWER;
 125   3                              }
 126   2                          }
 127   1              else if (ADCValue < (KEY_AD_L1+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L1 - KEY_AD_DELTA))
 128   1                  {
 129   2                          if(g_ucKeyStableCountBuff[KEY_MENU]++>KeyStableCounter)
 130   2                              {
 131   3                                  return KEY_MENU;
 132   3                              }
 133   2                  }
 134   1              else if (ADCValue < (KEY_AD_L2+KEY_AD_DELTA)&&ADCValue > (KEY_AD_L2 - KEY_AD_DELTA))
 135   1                  { //printf("\r\nADCValue===<%x>", ADCValue);
 136   2                          if(g_ucKeyStableCountBuff[KEY_SOURCE]++>KeyStableCounter)
 137   2                              {
 138   3                                  return KEY_SOURCE;
 139   3                              }
 140   2                  }
 141   1      #endif
 142   1      
 143   1                      if(!g_ucKeyCounter)
 144   1                  return KEY_NOTHING;
 145   1      
 146   1              g_ucKeyCounter--;
 147   1      
 148   1              return KEY_Idle;
 149   1      }
 150          
 151          void Key_ScanKeypad(void)
 152          {
 153   1              BYTE keypadStatus;
 154   1      
 155   1          keypadStatus=Key_GetKeypadStatus();
 156   1      
 157   1          if (keypadStatus!=KEY_Idle)
 158   1              {
 159   2              if(keypadStatus!=KEY_NOTHING)
 160   2                  {
 161   3                      printf("\r\nKEY<%x>", keypadStatus);
 162   3      
 163   3                              if (keypadStatus == g_ucLastKeypad)
 164   3                          {
 165   4                              //printMsg("repeat key pad");
 166   4                              EventRepeatProcess(keypadStatus, 2);
 167   4                          }
 168   3                          else
 169   3                          {
 170   4                              //printMsg("Single key pad");
 171   4                              EventProcess(keypadStatus);
 172   4                          }
 173   3                  }
 174   2              g_ucLastKeypad = keypadStatus;
 175   2              Key_KeyInit();
 176   2              }
 177   1      }
 178          
C51 COMPILER V8.18   KEYPAD                                                                09/29/2009 23:58:03 PAGE 4   

 179          void Key_KeyInit(void)
 180          {
 181   1          g_ucKeyCounter=KeyJitterCounter;
 182   1      
 183   1          g_ucKeyStableCountBuff[0]=0;
 184   1          g_ucKeyStableCountBuff[1]=0;
 185   1          g_ucKeyStableCountBuff[2]=0;
 186   1          g_ucKeyStableCountBuff[3]=0;
 187   1          g_ucKeyStableCountBuff[4]=0;
 188   1          g_ucKeyStableCountBuff[5]=0;
 189   1          g_ucKeyStableCountBuff[6]=0;
 190   1          g_ucKeyStableCountBuff[7]=0;
 191   1      }
 192          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =    299    ----
   CONSTANT SIZE    =     10    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =     19       1
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


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

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -