key.lst

前两天一个朋友要我写一个51例程

C51 COMPILER V8.01   KEY                                                                   10/14/2008 09:55:55 PAGE 1   


C51 COMPILER V8.01, COMPILATION OF MODULE KEY
OBJECT MODULE PLACED IN key.OBJ
COMPILER INVOKED BY: d:\Keil\C51\BIN\C51.EXE key.c ROM(SMALL) BROWSE MODP2 DEBUG OBJECTEXTEND

line level    source

   1          /********************************************************/      
   2          /*文件名:                                                                               */
   3          /*功能:                                                 */
   4          /*编写:                                                                                 */
   5          /*建立时间: 
   6          /*修改纪录：                                                                                    */
   7          /********************************************************/
   8          #include "key.h"
   9          
  10          
  11          
  12          INT8U   KeyCt[KeyNumber+1];     //定义检测按键的计数器
  13          /**/
  14          
  15          /*读取按键键值，注意，按键如果同时按下，也只能返回一个键值，但是有优先级*/
  16          INT8U   GetKeyValue()
  17          {
  18   1              uchar   KeyValueReg=0;
  19   1              if                      (Key1)
  20   1              {
  21   2                      if((KeyCt[1]>=KeyMaxTest))      
  22   2                      {
  23   3                              KeyValueReg=    1;
  24   3                      } 
  25   2                      KeyCt[1]=0; 
  26   2              }
  27   1              if (Key2)
  28   1              {
  29   2                      if((KeyCt[2]>=KeyMaxTest))      
  30   2                      {
  31   3                              KeyValueReg=    2;
  32   3                      } 
  33   2                      KeyCt[2]=0; 
  34   2              }
  35   1              if (Key3)
  36   1              {
  37   2                      if((KeyCt[3]>=KeyMaxTest))      
  38   2                      {
  39   3                              KeyValueReg=    3;
  40   3                      } 
  41   2                      KeyCt[3]=0; 
  42   2              }
  43   1              if (Key4)
  44   1              {
  45   2                      if((KeyCt[4]>=KeyMaxTest))      
  46   2                      {
  47   3                              KeyValueReg=    4;
  48   3                      } 
  49   2                      KeyCt[4]=0; 
  50   2              }
  51   1              if (Key5)
  52   1              {
  53   2                      if((KeyCt[5]>=KeyMaxTest))      
  54   2                      {
  55   3                              KeyValueReg=    5;
C51 COMPILER V8.01   KEY                                                                   10/14/2008 09:55:55 PAGE 2   

  56   3                      } 
  57   2                      KeyCt[5]=0; 
  58   2              }
  59   1              if (Key6)
  60   1              {
  61   2                      if((KeyCt[6]>=KeyMaxTest))      
  62   2                      {
  63   3                              KeyValueReg=    6;
  64   3                      } 
  65   2                      KeyCt[6]=0; 
  66   2              }
  67   1              if (Key7)
  68   1              {
  69   2                      if((KeyCt[7]>=KeyMaxTest))      
  70   2                      {
  71   3                              KeyValueReg=    7;
  72   3                      } 
  73   2                      KeyCt[7]=0; 
  74   2              }
  75   1              if (Key8)
  76   1              {
  77   2                      if((KeyCt[8]>=KeyMaxTest))      
  78   2                      {
  79   3                              KeyValueReg=    8;
  80   3                      } 
  81   2                      KeyCt[8]=0; 
  82   2              } 
  83   1              return  (KeyValueReg);  
  84   1      }
  85          #ifdef  KEYSUBEN
              void KeyScan()  {
                                              /*SetKeyOn*/
                                              if      ((!Key1)&&(KeyCt[1]<KeyMaxTest))                                   
                                              {                                                                                                                          
                                                      KeyCt[1]++;                                                                                                
                                              }                                                                                                                          
                                              if      ((!Key2)&&(KeyCt[2]<KeyMaxTest))                                   
                                              {                                                                                                                          
                                                      KeyCt[2]++;                                                                                                
                                              }                                                                                                                          
                                              if      ((!Key3)&&(KeyCt[3]<KeyMaxTest))                                   
                                              {                                                                                                                          
                                                      KeyCt[3]++;                                                                                                
                                              }                                                                                                                          
                                              if      ((!Key4)&&(KeyCt[4]<KeyMaxTest))                                   
                                              {                                                                                                                          
                                                      KeyCt[4]++;                                                                                                
                                              }                                                                                                                          
                                              if      ((!Key5)&&(KeyCt[5]<KeyMaxTest))                                   
                                              {                                                                                                                          
                                                      KeyCt[5]++;                                                                                                
                                              }                                                                                                                          
                                              if      ((!Key6)&&(KeyCt[6]<KeyMaxTest))                                   
                                              {                                                                                                                          
                                                      KeyCt[6]++;                                                                                                
                                              }                                                                                                                          
                                              if      ((!Key7)&&(KeyCt[7]<KeyMaxTest))                                   
                                              {                                                                                                                          
                                                      KeyCt[7]++;                                                                                                
                                              }                                                                                                                          
                                              if      ((!Key8)&&(KeyCt[8]<KeyMaxTest))                                   
                                              {                                                                                                                          
C51 COMPILER V8.01   KEY                                                                   10/14/2008 09:55:55 PAGE 3   

                                                      KeyCt[8]++;                                                                                                
                                              }                                                                                                                          
                                      }  
              #endif


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =    122    ----
   CONSTANT SIZE    =   ----    ----
   XDATA SIZE       =   ----    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =      9    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


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