main.LST
上传用户:njxy551199
上传日期:2022-04-06
资源大小:1990k
文件大小:13k
源码类别:

RFID编程

开发平台:

C/C++

  1. C51 COMPILER V8.08   MAIN                                                                  03/14/2010 21:16:39 PAGE 1   
  2. C51 COMPILER V8.08, COMPILATION OF MODULE MAIN
  3. OBJECT MODULE PLACED IN main.OBJ
  4. COMPILER INVOKED BY: C:KeilC51BINC51.EXE main.c BROWSE DEBUG OBJECTEXTEND
  5. line level    source
  6.    1          #include "main.h"        
  7.    2          #include "hy502.h"
  8.    3          #include "lcd.h"
  9.    4          #include <stdio.h>
  10.    5          
  11.    6          
  12.    7          // SPI 总线状态定义
  13.    8          #define SPI_RDY  0xF0;            // 准备
  14.    9          #define spibusy  0xaa             // 忙
  15.   10          #define spiread  0xbb             // 读
  16.   11          #define spiwrite 0xcc             // 写
  17.   12          
  18.   13          
  19.   14          
  20.   15          /////////////////////////////////////////////////////////////////////////////////////////////////////
  21.   16          // 延时函数
  22.   17          void delay(unsigned int x)
  23.   18          {
  24.   19   1              while(x)
  25.   20   1              {
  26.   21   2                      x--;
  27.   22   2              }
  28.   23   1      }
  29.   24          
  30.   25           
  31.   26          
  32.   27          ///////////////////////////////////////////////////////////////////////
  33.   28          // Delay 1ms
  34.   29          ///////////////////////////////////////////////////////////////////////
  35.   30          void delay_1ms (uint _1ms)
  36.   31          {
  37.   32   1      
  38.   33   1        RCAP2LH = RCAP2_1ms;
  39.   34   1        T2LH    = RCAP2_1ms;
  40.   35   1        ET2 = 0;      // Disable timer2 interrupt
  41.   36   1        T2CON = 0x04; // 16-bit auto-reload, clear TF2, start timer
  42.   37   1      
  43.   38   1        while (_1ms--)
  44.   39   1        {
  45.   40   2              while (!TF2);
  46.   41   2              TF2 = FALSE;
  47.   42   2        }
  48.   43   1        TR2 = FALSE;
  49.   44   1      
  50.   45   1      }
  51.   46          
  52.   47          ///////////////////////////////////////////////////////////////////////
  53.   48          // Delay 10ms
  54.   49          ///////////////////////////////////////////////////////////////////////
  55.   50          void delay_10ms(unsigned int _10ms)
  56.   51          {
  57.   52   1        RCAP2LH = RCAP2_10ms;
  58.   53   1        T2LH    = RCAP2_10ms;
  59.   54   1        ET2 = 0;      // Disable timer2 interrupt
  60.   55   1        T2CON = 0x04; // 16-bit auto-reload, clear TF2, start timer
  61. C51 COMPILER V8.08   MAIN                                                                  03/14/2010 21:16:39 PAGE 2   
  62.   56   1      
  63.   57   1        while (_10ms--)
  64.   58   1        {
  65.   59   2              while (!TF2)
  66.   60   2              {
  67.   61   3               if(g_bReceCommandOk)            // change by lin 2006-08-21
  68.   62   3                {
  69.   63   4                      TR2 = FALSE;
  70.   64   4                      TF2 = FALSE;
  71.   65   4                      return;
  72.   66   4                 }
  73.   67   3              }
  74.   68   2              TF2 = FALSE;
  75.   69   2        }
  76.   70   1        TR2 = FALSE;
  77.   71   1      
  78.   72   1      }
  79.   73          
  80.   74           
  81.   75          /******************* SPI FUNCTION DEFINE ************************************/
  82.   76          /*****************************************************************************
  83.   77          *function: send a byte over SPI bus
  84.   78           发送一个字节
  85.   79          *****************************************************************************/
  86.   80          unsigned char SPIRWByte(unsigned char cSendByte)
  87.   81          {
  88.   82   1              unsigned char data i = 8;
  89.   83   1              unsigned char cRecByte;
  90.   84   1              while (i--)
  91.   85   1              {
  92.   86   2                      cRecByte += cRecByte;
  93.   87   2                      SCL = 0;
  94.   88   2                      MOSI = (bit)(cSendByte & 0x80);
  95.   89   2                      cSendByte += cSendByte;
  96.   90   2                      cRecByte |= (unsigned char) MISO ;
  97.   91   2                      SCL = 1;
  98.   92   2              }
  99.   93   1              SCL = 1;
  100.   94   1              return cRecByte;
  101.   95   1      }
  102.   96          
  103.   97          
  104.   98          /***** 查询SPI总线状态 *********/
  105.   99          unsigned char spi_cStatus(void)
  106.  100          {
  107.  101   1              unsigned char cStatus;
  108.  102   1              NSS=0;
  109.  103   1              cStatus=SPIRWByte(spibusy);
  110.  104   1      
  111.  105   1              cStatus=SPIRWByte(0xFF);
  112.  106   1              NSS=1;
  113.  107   1      
  114.  108   1              return cStatus;
  115.  109   1      }
  116.  110          
  117.  111          /***** 读SPI总线数据********/
  118.  112          unsigned char SPI_Read(unsigned char *cP)
  119.  113          {
  120.  114   1              unsigned char cCnt,cStatus;
  121.  115   1              unsigned char cCheckSum = 0;
  122.  116   1      
  123.  117   1              for (cCnt=0; cCnt<100; cCnt++)
  124. C51 COMPILER V8.08   MAIN                                                                  03/14/2010 21:16:39 PAGE 3   
  125.  118   1              {
  126.  119   2                      cStatus=spi_cStatus(); //查询SPI总线状态
  127.  120   2                      if(cStatus==0xF0)
  128.  121   2                      {
  129.  122   3                              cCnt=253;
  130.  123   3                      }
  131.  124   2                      delay(10);        
  132.  125   2              }
  133.  126   1      
  134.  127   1              if(cCnt==254)  //卡操作结束,可以回传数据
  135.  128   1              {  
  136.  129   2                      NSS=0;
  137.  130   2              cCnt=SPIRWByte(spiread);
  138.  131   2              
  139.  132   2      
  140.  133   2                  cP[0]=0x01;                            
  141.  134   2                 for (cCnt=0; cCnt<cP[0]; cCnt++)
  142.  135   2                 {
  143.  136   3                      cP[cCnt] = SPIRWByte(0xFF);
  144.  137   3                      cCheckSum ^= cP[cCnt];
  145.  138   3                    if(cP[0]>32)
  146.  139   3                      {
  147.  140   4                         NSS=1;
  148.  141   4                         return  FAILURE;
  149.  142   4                      }       
  150.  143   3                 }
  151.  144   2      
  152.  145   2                 cP[cCnt] = SPIRWByte(0xFF);
  153.  146   2      
  154.  147   2                 NSS=1;
  155.  148   2                 if (cCheckSum == cP[cCnt])
  156.  149   2                 {
  157.  150   3                    return SUCCESS;
  158.  151   3      
  159.  152   3                 }
  160.  153   2             }
  161.  154   1              return FAILURE;
  162.  155   1      }
  163.  156          
  164.  157          /***** 写SPI总线数据 *********/
  165.  158          unsigned char SPI_Write(unsigned char *cP)
  166.  159          {
  167.  160   1              unsigned char i,cStatus;
  168.  161   1              unsigned char cCheckSum = 0;
  169.  162   1      
  170.  163   1                      NSS=0;
  171.  164   1                      cStatus=SPIRWByte(spiwrite);
  172.  165   1      
  173.  166   1                      for(i=0; i<cP[0]; i++)  // cP[0] 表示数据包的长度
  174.  167   1                      {
  175.  168   2                              cCheckSum ^= cP[i];
  176.  169   2                              cStatus=SPIRWByte(cP[i]);
  177.  170   2                      }
  178.  171   1                      cStatus=SPIRWByte(cCheckSum);
  179.  172   1                      NSS=1;
  180.  173   1              return cStatus;
  181.  174   1      }
  182.  175          
  183.  176          
  184.  177          //-----Reset rf module -------//
  185.  178          void Reset_HY502(void)
  186.  179          {
  187. C51 COMPILER V8.08   MAIN                                                                  03/14/2010 21:16:39 PAGE 4   
  188.  180   1              RST_HY=0;                         //Reset HY502 复位模块 
  189.  181   1          delay_10ms(50);          
  190.  182   1              RST_HY=1;     
  191.  183   1      }
  192.  184             
  193.  185          /************************** main function start here *******************************/
  194.  186          void main()
  195.  187          {                       
  196.  188   1              
  197.  189   1              uchar str0[]={"money ="}         ;
  198.  190   1              uchar idata str3[]={"error"};
  199.  191   1              uchar str1[4];
  200.  192   1              uchar idata cStatus;                   
  201.  193   1              uchar *cPa;
  202.  194   1              int flag=0;
  203.  195   1              int money=120;
  204.  196   1      
  205.  197   1              InitializeSystem();                // 初始化系统        
  206.  198   1              Reset_HY502();       
  207.  199   1              delay_1ms(500); 
  208.  200   1              lcd_init() ;
  209.  201   1      
  210.  202   1        
  211.  203   1         while(sig) ; 
  212.  204   1                
  213.  205   1         cPa = ComIntiPurse5 ;  
  214.  206   1         SPI_Write(cPa);               
  215.  207   1         delay_1ms(100) ;
  216.  208   1         cStatus = SPI_Read(g_cReceBuf);
  217.  209   1         while ((g_cReceBuf[1] != cPa[1]) || cStatus != SUCCESS)
  218.  210   1                       {
  219.  211   2                              cPa = ComIntiPurse5 ;  
  220.  212   2                  SPI_Write(cPa);              
  221.  213   2                  delay_1ms(100) ;
  222.  214   2                  cStatus = SPI_Read(g_cReceBuf);
  223.  215   2                        }
  224.  216   1      ////////////
  225.  217   1      
  226.  218   1              while (1)
  227.  219   1              {
  228.  220   2                         if (flag == 1)         break;
  229.  221   2      
  230.  222   2                         
  231.  223   2                         while(sig) ;
  232.  224   2                      
  233.  225   2                      
  234.  226   2                        delay_1ms(70);           //预留卡靠近的时间     
  235.  227   2                        while ( !sig)
  236.  228   2                        {
  237.  229   3             if (money -10<0)               //余额不够,重新初始化赋值
  238.  230   3                   {
  239.  231   4                         display(str3);
  240.  232   4                                         flag = 1;
  241.  233   4                          break;
  242.  234   4      
  243.  235   4                   }
  244.  236   3      
  245.  237   3            cPa =ComDecrPurse5;
  246.  238   3                SPI_Write(cPa);
  247.  239   3                delay_1ms(100);                                                 
  248.  240   3              cStatus = SPI_Read(g_cReceBuf);
  249.  241   3               while ((g_cReceBuf[1] != cPa[1]) || cStatus != SUCCESS)
  250. C51 COMPILER V8.08   MAIN                                                                  03/14/2010 21:16:39 PAGE 5   
  251.  242   3                       {
  252.  243   4                cPa =ComDecrPurse5;
  253.  244   4                SPI_Write(cPa);
  254.  245   4                delay_1ms(100);                                                 
  255.  246   4                cStatus = SPI_Read(g_cReceBuf);               
  256.  247   4                                
  257.  248   4                        }
  258.  249   3                                              
  259.  250   3                delay_1ms(200);
  260.  251   3                cPa =ComReadPurse5;                           // 读取钱包         
  261.  252   3              SPI_Write(cPa);
  262.  253   3              delay_1ms(100);                                           
  263.  254   3              cStatus = SPI_Read(g_cReceBuf);
  264.  255   3          if ((g_cReceBuf[1] != cPa[1]) || cStatus != SUCCESS)
  265.  256   3                       {
  266.  257   4                           cStatus  =  SPI_Write(ComHaltCard);
  267.  258   4                           display(str3); 
  268.  259   4                              delay_1ms(500);         
  269.  260   4                                continue;
  270.  261   4                        }
  271.  262   3              ///////////////////////
  272.  263   3              
  273.  264   3                      money  =  g_cReceBuf[2];
  274.  265   3              
  275.  266   3                      
  276.  267   3           sprintf(str1,  "%d", money); 
  277.  268   3                                      
  278.  269   3              SPI_Write(ComHaltCard);    //设置为休眠状态
  279.  270   3              delay_1ms(100);            
  280.  271   3              lcd_display(str0,str1);
  281.  272   3              
  282.  273   3              delay_1ms(2000);
  283.  274   3              lcd_init() ;                      
  284.  275   3                                              
  285.  276   3                 }
  286.  277   2                }
  287.  278   1      
  288.  279   1               
  289.  280   1      
  290.  281   1       
  291.  282   1      
  292.  283   1      }                                                   
  293.  284          /*****************************************************************************
  294.  285          *system initialize
  295.  286          *UART baudrate = 19200bps, baud generator is T1
  296.  287          *****************************************************************************/
  297.  288          void InitializeSystem()
  298.  289          {
  299.  290   1        
  300.  291   1              ET2 = 0;
  301.  292   1              T2CON = 0x04;
  302.  293   1          PCON = 0x80;
  303.  294   1          SCON = 0x70;
  304.  295   1          TMOD = 0x21;        //TMOD = 0x22;
  305.  296   1      
  306.  297   1              TH1   = BAUD_19200;  //默认波特率
  307.  298   1              TL1   = TH1;
  308.  299   1              TR1   = TRUE;             // 波特率发生器
  309.  300   1      
  310.  301   1              ET1=0;
  311.  302   1              EA=1;
  312.  303   1              EX0=0;;
  313. C51 COMPILER V8.08   MAIN                                                                  03/14/2010 21:16:39 PAGE 6   
  314.  304   1              IT0 = 1;
  315.  305   1              TR2=0;
  316.  306   1              ES = TRUE;
  317.  307   1              g_bReceCommandOk=0;                                                             
  318.  308   1      
  319.  309   1      }
  320. MODULE INFORMATION:   STATIC OVERLAYABLE
  321.    CODE SIZE        =    954    ----
  322.    CONSTANT SIZE    =     94    ----
  323.    XDATA SIZE       =   ----    ----
  324.    PDATA SIZE       =   ----    ----
  325.    DATA SIZE        =     47      38
  326.    IDATA SIZE       =     60       7
  327.    BIT SIZE         =      3    ----
  328. END OF MODULE INFORMATION.
  329. C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)