21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › RFID无线射频技术（RC522刷卡模块）
123下一页
返回列表 发新帖我要提问

[其他ST产品] RFID无线射频技术（RC522刷卡模块）

[复制链接]
3489|57
 楼主| 无法去污粉 发表于 2022-12-25 15:05 | 显示全部楼层
TRANSCEIVE命令，该循环命令重复发送FIFO的数据，并不断接收RF场的数据。第一个动作是发送，发送结束后命令变为接收数据流。
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:06 | 显示全部楼层
MFAUTENT命令(P69，17)，该命令用来处理Mifare认证以使能到任何Mifare普通卡的安全通信。在命令激活前以下数据必须被写入FIFO:认证命令码， 块地址，秘钥，序列号。该命令在Mifare卡被认证且Status2Reg寄存器的MFCrypto1On位置位时自动终止。
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:14 | 显示全部楼层
SOFTRESET命令，所有寄存器都设置成复位值。命令完成后自动终止。
614763a7f841c9fdb.png
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:15 | 显示全部楼层
RCC52与STM32接线图
490963a7f88c81bff.png
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:21 | 显示全部楼层
RCC52代码
rc522.h
复制
  1. #ifndef __RC522_H
    

  2. #define __RC522_H        
    

  3. #include "stm32f10x.h"
    

  4.  
    


  5. 

  6. //MF522命令字
    


  7. 

  8. #define PCD_IDLE              0x00               //取消当前命令
    

  9. #define PCD_AUTHENT           0x0E               //验证密钥
    

  10. #define PCD_RECEIVE           0x08               //接收数据
    

  11. #define PCD_TRANSMIT          0x04               //发送数据
    

  12. #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
    

  13. #define PCD_RESETPHASE        0x0F               //复位
    

  14. #define PCD_CALCCRC           0x03               //CRC计算
    

  15.  
    


  16. 

  17. //Mifare_One卡片命令字
    


  18. 

  19. #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
    

  20. #define PICC_REQALL           0x52               //寻天线区内全部卡
    

  21. #define PICC_ANTICOLL1        0x93               //防冲撞
    

  22. #define PICC_ANTICOLL2        0x95               //防冲撞
    

  23. #define PICC_AUTHENT1A        0x60               //验证A密钥
    

  24. #define PICC_AUTHENT1B        0x61               //验证B密钥
    

  25. #define PICC_READ             0x30               //读块
    

  26. #define PICC_WRITE            0xA0               //写块
    

  27. #define PICC_DECREMENT        0xC0               //扣款
    

  28. #define PICC_INCREMENT        0xC1               //充值
    

  29. #define PICC_RESTORE          0xC2               //调块数据到缓冲区
    

  30. #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
    

  31. #define PICC_HALT             0x50               //休眠
    

  32.  
    


  33. 

  34. //MF522 FIFO长度定义
    


  35. 

  36. #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
    

  37. #define MAXRLEN  18
    

  38.  
    


  39. 

  40. //MF522寄存器定义
    


  41. 

  42. // PAGE 0
    

  43. #define     RFU00                 0x00    
    

  44. #define     CommandReg            0x01    
    

  45. #define     ComIEnReg             0x02    
    

  46. #define     DivlEnReg             0x03    
    

  47. #define     ComIrqReg             0x04    
    

  48. #define     DivIrqReg             0x05
    

  49. #define     ErrorReg              0x06    
    

  50. #define     Status1Reg            0x07    
    

  51. #define     Status2Reg            0x08    
    

  52. #define     FIFODataReg           0x09
    

  53. #define     FIFOLevelReg          0x0A
    

  54. #define     WaterLevelReg         0x0B
    

  55. #define     ControlReg            0x0C
    

  56. #define     BitFramingReg         0x0D
    

  57. #define     CollReg               0x0E
    

  58. #define     RFU0F                 0x0F
    

  59. // PAGE 1     
    

  60. #define     RFU10                 0x10
    

  61. #define     ModeReg               0x11
    

  62. #define     TxModeReg             0x12
    

  63. #define     RxModeReg             0x13
    

  64. #define     TxControlReg          0x14
    

  65. #define     TxAutoReg             0x15
    

  66. #define     TxSelReg              0x16
    

  67. #define     RxSelReg              0x17
    

  68. #define     RxThresholdReg        0x18
    

  69. #define     DemodReg              0x19
    

  70. #define     RFU1A                 0x1A
    

  71. #define     RFU1B                 0x1B
    

  72. #define     MifareReg             0x1C
    

  73. #define     RFU1D                 0x1D
    

  74. #define     RFU1E                 0x1E
    

  75. #define     SerialSpeedReg        0x1F
    

  76. // PAGE 2    
    

  77. #define     RFU20                 0x20  
    

  78. #define     CRCResultRegM         0x21
    

  79. #define     CRCResultRegL         0x22
    

  80. #define     RFU23                 0x23
    

  81. #define     ModWidthReg           0x24
    

  82. #define     RFU25                 0x25
    

  83. #define     RFCfgReg              0x26
    

  84. #define     GsNReg                0x27
    

  85. #define     CWGsCfgReg            0x28
    

  86. #define     ModGsCfgReg           0x29
    

  87. #define     TModeReg              0x2A
    

  88. #define     TPrescalerReg         0x2B
    

  89. #define     TReloadRegH           0x2C
    

  90. #define     TReloadRegL           0x2D
    

  91. #define     TCounterValueRegH     0x2E
    

  92. #define     TCounterValueRegL     0x2F
    

  93. // PAGE 3      
    

  94. #define     RFU30                 0x30
    

  95. #define     TestSel1Reg           0x31
    

  96. #define     TestSel2Reg           0x32
    

  97. #define     TestPinEnReg          0x33
    

  98. #define     TestPinValueReg       0x34
    

  99. #define     TestBusReg            0x35
    

  100. #define     AutoTestReg           0x36
    

  101. #define     VersionReg            0x37
    

  102. #define     AnalogTestReg         0x38
    

  103. #define     TestDAC1Reg           0x39  
    

  104. #define     TestDAC2Reg           0x3A   
    

  105. #define     TestADCReg            0x3B   
    

  106. #define     RFU3C                 0x3C   
    

  107. #define     RFU3D                 0x3D   
    

  108. #define     RFU3E                 0x3E   
    

  109. #define     RFU3F                                          0x3F
    

  110.  
    


  111. 

  112. //和MF522通讯时返回的错误代码
    


  113. 

  114. #define         MI_OK                 0
    

  115. #define         MI_NOTAGERR           (1)
    

  116. #define         MI_ERR                (2)
    

  117.  
    

  118. #define        SHAQU1        0X01
    

  119. #define        KUAI4        0X04
    

  120. #define        KUAI7        0X07
    

  121. #define        REGCARD        0xa1
    

  122. #define        CONSUME        0xa2
    

  123. #define READCARD        0xa3
    

  124. #define ADDMONEY        0xa4
    

  125.  
    

  126. //
    

  127. //#define  spi_cs 1;
    

  128. //sbit  spi_ck=P0^6;
    

  129. //sbit  spi_mosi=P0^7;
    

  130. //sbit  spi_miso=P4^1;
    

  131. //sbit  spi_rst=P2^7;
    

  132. #define SPIReadByte()        SPIWriteByte(0)
    

  133. u8 SPIWriteByte(u8 byte);
    

  134. void SPI1_Init(void);
    

  135.  
    

  136. #define SET_SPI_CS  (GPIOF->BSRR=0X01)
    

  137. #define CLR_SPI_CS  (GPIOF->BRR=0X01)
    

  138.  
    

  139.  
    

  140.  
    

  141. #define SET_RC522RST  GPIOF->BSRR=0X02
    

  142. #define CLR_RC522RST  GPIOF->BRR=0X02
    

  143.  
    

  144.  
    

  145. /***********************RC522 函数宏定义**********************/
    

  146. #define          RC522_CS_Enable()         GPIO_ResetBits ( GPIOB, GPIO_Pin_12 )
    

  147. #define          RC522_CS_Disable()        GPIO_SetBits ( GPIOB, GPIO_Pin_12 )
    

  148.  
    

  149. #define          RC522_Reset_Enable()      GPIO_ResetBits( GPIOA, GPIO_Pin_8 )
    

  150. #define          RC522_Reset_Disable()     GPIO_SetBits ( GPIOA, GPIO_Pin_8 )
    

  151.  
    

  152. #define          RC522_SCK_0()             GPIO_ResetBits( GPIOB, GPIO_Pin_13 )
    

  153. #define          RC522_SCK_1()             GPIO_SetBits ( GPIOB, GPIO_Pin_13 )
    

  154.  
    

  155. #define          RC522_MOSI_0()            GPIO_ResetBits( GPIOB, GPIO_Pin_15 )
    

  156. #define          RC522_MOSI_1()            GPIO_SetBits ( GPIOB, GPIO_Pin_15 )
    

  157.  
    

  158. #define          RC522_MISO_GET()          GPIO_ReadInputDataBit ( GPIOB, GPIO_Pin_14 )
    

  159.  
    

  160. void             RC522_Handel               (void);
    

  161. void             RC522_Init                 ( void );                       //初始化
    

  162. void             PcdReset                   ( void );                       //复位
    

  163. void             M500PcdConfigISOType       ( u8 type );                    //工作方式
    

  164. char             PcdRequest                 ( u8 req_code, u8 * pTagType ); //寻卡
    

  165. char             PcdAnticoll                ( u8 * pSnr);                   //读卡号
    

  166.  
    

  167. char             PcdSelect                  ( u8 * pSnr );
    

  168. char             PcdAuthState               ( u8 ucAuth_mode, u8 ucAddr, u8 * pKey, u8 * pSnr );
    

  169. char             PcdWrite                   ( u8 ucAddr, u8 * pData );
    

  170. char             PcdRead                    ( u8 ucAddr, u8 * pData );
    

  171. //void ShowID(u16 x,u16 y, u8 *p, u16 charColor, u16 bkColor);         //显示卡的卡号，以十六进制显示
    

  172. void ShowID(u8 *p);         //显示卡的卡号，以十六进制显示
    


  173. 

  174. extern unsigned char buf1[16];
    

  175. extern unsigned char buf2[16]; 
    

  176.  
    

  177. #endif
    


  178.
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:22 | 显示全部楼层
rc522.c
复制
  1. #include "rc522.h"
    

  2. #include "delay.h"
    

  3. #include "usart.h"
    

  4. #include <string.h>
    

  5. #include "oled.h" 
    

  6. #include "led.h"
    

  7. // M1卡分为16个扇区，每个扇区由四个块（块0、块1、块2、块3）组成
    

  8. // 将16个扇区的64个块按绝对地址编号为：0~63
    

  9. // 第0个扇区的块0（即绝对地址0块），用于存放厂商代码，已经固化不可更改 
    

  10. // 每个扇区的块0、块1、块2为数据块，可用于存放数据
    

  11. // 每个扇区的块3为控制块（绝对地址为:块3、块7、块11.....）包括密码A，存取控制、密码B等
    

  12.  
    

  13. /*******************************
    

  14. *连线说明：
    

  15. *1--SDA  <----->PB12
    

  16. *2--SCK  <----->PB13
    

  17. *3--MOSI <----->PB15
    

  18. *4--MISO <----->PB14
    

  19. *5--悬空
    

  20. *6--GND <----->GND
    

  21. *7--RST <----->PA8
    

  22. *8--VCC <----->VCC
    

  23. ************************************/
    

  24.  
    

  25. /*全局变量*/
    

  26. unsigned char CT[2];//卡类型
    

  27. unsigned char SN[4]; //卡号（低字节在前，高字节在后）
    

  28. unsigned char RFID[16];                        //存放RFID 
    

  29. unsigned char lxl_bit=0;
    

  30. unsigned char card1_bit=0;
    

  31. unsigned char card2_bit=0;
    

  32. unsigned char card3_bit=0;
    

  33. unsigned char card4_bit=0;
    

  34. unsigned char total=0;
    

  35. unsigned char lxl[4]={196,58,104,217};
    

  36. unsigned char card_1[4]={83,106,11,1};
    

  37. unsigned char card_2[4]={208,121,31,57};
    

  38. unsigned char card_3[4]={176,177,143,165};
    

  39. unsigned char card_4[4]={5,158,10,136};
    

  40. u8 KEY[6]={0xff,0xff,0xff,0xff,0xff,0xff};
    

  41. u8 AUDIO_OPEN[6] = {0xAA, 0x07, 0x02, 0x00, 0x09, 0xBC};
    

  42. unsigned char RFID1[16]={0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x07,0x80,0x29,0xff,0xff,0xff,0xff,0xff,0xff};
    

  43. /*函数声明*/
    

  44. unsigned char status;
    

  45. unsigned char s=0x08;
    

  46.  unsigned char ShowON; 
    

  47.  
    

  48. #define   RC522_DELAY()  delay_us( 20 )
    


  49. 

  50. //ID
    

  51. char ss[255];
    

  52. //char data[16];
    


  53. 

  54. unsigned char snr, buf[16], TagType[2], SelectedSnr[4], DefaultKey[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; 
    

  55. unsigned char buf1[16];
    

  56. unsigned char buf2[16];
    

  57. int a = 1200;
    

  58. char OK_status;
    


  59. 

  60. void RC522_Handel(void)
    

  61. {
    

  62. //
    

  63.         
    

  64.     status = PcdRequest(PICC_REQALL,CT);//寻卡
    

  65.     
    

  66. //    printf("\r\nstatus>>>>>>%d\r\n", status);
    

  67.     
    

  68.     if(status==MI_OK)//寻卡成功
    

  69.     {
    

  70.                                  printf("\r\n寻卡成功\r\n");
    

  71.          status=MI_ERR;
    

  72.          status = PcdAnticoll(SN);//防冲撞               
    

  73.     }
    

  74.  
    

  75.     if (status==MI_OK)//防衝撞成功
    

  76.     {
    

  77. //                int d;
    

  78. //                char cStr [ 30 ];
    

  79.         status=MI_ERR;                
    

  80. //                                printf("\r\n card_0>>>>>>%d\r\n", SN[0]);
    

  81. //                                printf("\r\n card_1>>>>>>%d\r\n", SN[1]);
    

  82. //                                printf("\r\n card_2>>>>>>%d\r\n", SN[2]);
    

  83. //                                printf("\r\n card_3>>>>>>%d\r\n", SN[3]);
    

  84. //                                card_number_D=(SN[2]<<16)+(SN[1]<<8)+(SN[0]);        //获取印刷卡号
    

  85. //                                printf("\r\n卡号：[%d]\r\n",card_number_D);
    

  86.                 
    

  87. //                        sprintf ( cStr, "%d%d%d%d", SN [ 0 ], SN [ 1 ], SN [ 2 ], SN[ 3 ] );
    

  88.                         printf ( "%s\n",cStr );   //在这里打印出来卡号
    

  89. //                                OLED_Clear();
    

  90. //                                for(d=0;d<10;d++)
    

  91. //                                {
    

  92. //                                OLED_ShowNum(d*8,0,cStr[d]-0x30,1,16);
    

  93. //                                }
    

  94. //      ShowID(0,200,SN,BLUE,WHITE); //在液晶屏上显示卡的ID号
    

  95.                                   ShowID(SN); // 串口打印卡的ID号
    

  96.         
    

  97. //        if((SN[0]==lxl[0])&&(SN[1]==lxl[1])&&(SN[2]==lxl[2])&&(SN[3]==lxl[3]))
    

  98. //        {
    

  99. //            lxl_bit=1;
    

  100. //            printf("\r\nThe User is:card_0\r\n");
    

  101. //                        OLED_ShowString(0,3,"\r\nThe User is:card_0\r\n",16);
    

  102. //            
    

  103. //        }
    

  104. //        if((SN[0]==card_1[0])&&(SN[1]==card_1[1])&&(SN[2]==card_1[2])&&(SN[3]==card_1[3]))
    

  105. //        {
    

  106. //            card1_bit=1;
    

  107. //            printf("\r\nThe User is:card_1\r\n");
    

  108. //            
    

  109. //        }
    

  110. //        if((SN[0]==card_2[0])&&(SN[1]==card_2[1])&&(SN[2]==card_2[2])&&(SN[3]==card_2[3]))
    

  111. //        {
    

  112. //            card2_bit=1;
    

  113. //            printf("\r\nThe User is:card_2\r\n");
    

  114. //            
    

  115. //        }
    

  116. //        
    

  117. //        if((SN[0]==card_3[0])&&(SN[1]==card_3[1])&&(SN[2]==card_3[2])&&(SN[3]==card_3[3]))
    

  118. //        {
    

  119. //            card3_bit=1;
    

  120. //            printf("\r\nThe User is:card_3\r\n");
    

  121. //            
    

  122. //        }
    

  123. //        if((SN[0]==card_4[0])&&(SN[1]==card_4[1])&&(SN[2]==card_4[2])&&(SN[3]==card_4[3]))
    

  124. //        {
    

  125. //            card4_bit=1;
    

  126. //            printf("\r\nThe User is:card_4\r\n");
    

  127. //            
    

  128. //        }
    

  129.         //total=card1_bit+card2_bit+card3_bit+card4_bit+lxl_bit;
    

  130.         status =PcdSelect(SN);
    

  131.  
    

  132.     }
    

  133.     else
    

  134.     {
    

  135.         
    

  136.        // TODO 
    

  137.     }
    

  138.     if(status==MI_OK)//選卡成功
    

  139.     {
    

  140.  
    

  141.         status=MI_ERR;
    

  142.         status =PcdAuthState(0x60,0x09,KEY,SN);
    

  143.      }
    

  144.     if(status==MI_OK)//驗證成功
    

  145.     {
    

  146.         status=MI_ERR;
    

  147.         status=PcdRead(s,RFID);
    

  148.     }
    

  149.  
    

  150.     if(status==MI_OK)//讀卡成功
    

  151.     {
    

  152.         status=MI_ERR;
    

  153.         delay_ms(100);
    

  154.     }        
    

  155.  
    

  156. }
    


  157. 


  158. 

  159. void RC522_Init ( void )
    

  160. {
    

  161.         SPI1_Init();
    

  162.         
    

  163.         RC522_Reset_Disable();
    

  164.         
    

  165.         RC522_CS_Disable();
    

  166.     
    

  167.   PcdReset ();
    

  168.     
    

  169.         M500PcdConfigISOType ( 'A' );//设置工作方式
    

  170.  
    

  171. }
    

  172.  
    

  173. void SPI1_Init(void)        
    

  174. {
    

  175.                 GPIO_InitTypeDef GPIO_InitStructure;
    

  176.                 RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能 
    

  177.                 
    

  178.                 // CS
    

  179.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;         
    

  180.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    

  181.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  182.     GPIO_Init(GPIOB, &GPIO_InitStructure);                                         //根据设定参数初始化PB12
    

  183.     
    

  184.     // SCK
    

  185.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;         
    

  186.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    

  187.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  188.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  189.     
    

  190.     // MISO
    

  191.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;         
    

  192.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                  //推挽输出
    

  193.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  194.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  195.     
    

  196.     // MOSI
    

  197.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;         
    

  198.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    

  199.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  200.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    

  201.     
    

  202.     // RST
    

  203.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;         
    

  204.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    

  205.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  206.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    

  207.     
    

  208. }
    

  209.  
    

  210.  
    

  211. /*
    

  212.  * 函数名：SPI_RC522_SendByte
    

  213.  * 描述  ：向RC522发送1 Byte 数据
    

  214.  * 输入  ：byte，要发送的数据
    

  215.  * 返回  : RC522返回的数据
    

  216.  * 调用  ：内部调用
    

  217.  */
    

  218. void SPI_RC522_SendByte ( u8 byte )
    

  219. {
    

  220.     u8 counter;
    

  221.         
    

  222.     for(counter=0;counter<8;counter++)
    

  223.     {     
    

  224.                         if ( byte & 0x80 )
    

  225.                                         RC522_MOSI_1 ();
    

  226.                         else 
    

  227.                                         RC522_MOSI_0 ();
    

  228.  
    

  229. //                        delay_us ( 3 );
    

  230.                         RC522_DELAY();
    

  231.                 
    

  232.                         RC522_SCK_0 ();
    

  233.  
    

  234. //                        delay_us ( 1 );
    

  235. //                        delay_us ( 3 );
    

  236.                         RC522_DELAY();
    

  237.                          
    

  238.                         RC522_SCK_1();
    

  239.  
    

  240. //                        delay_us ( 3 );
    

  241.                         RC522_DELAY();
    

  242.                          
    

  243.                         byte <<= 1; 
    

  244.                         
    

  245.     } 
    

  246.         
    

  247. }
    

  248.  
    

  249.  
    

  250. /*
    

  251.  * 函数名：SPI_RC522_ReadByte
    

  252.  * 描述  ：从RC522发送1 Byte 数据
    

  253.  * 输入  ：无
    

  254.  * 返回  : RC522返回的数据
    

  255.  * 调用  ：内部调用
    

  256.  */
    

  257. u8 SPI_RC522_ReadByte ( void )
    

  258. {
    

  259.         u8 counter;
    

  260.         u8 SPI_Data;
    

  261.  
    

  262.  
    

  263.         for(counter=0;counter<8;counter++)
    

  264.         {
    

  265.                         SPI_Data <<= 1;
    

  266.          
    

  267.                         RC522_SCK_0 ();
    

  268.  
    

  269. //                        delay_us ( 3 );
    

  270.                     RC522_DELAY();
    

  271.                 
    

  272.                         if ( RC522_MISO_GET() == 1)
    

  273.                                         SPI_Data |= 0x01;
    

  274.  
    

  275. //                        delay_us ( 2 );
    

  276. //                        delay_us ( 3 );
    

  277.                         RC522_DELAY();
    

  278.  
    

  279.                         RC522_SCK_1 ();
    

  280.         
    

  281. //                        delay_us ( 3 );
    

  282.                         RC522_DELAY();
    

  283.                         
    

  284.         }
    

  285.         
    

  286.  
    

  287. //        printf("****%c****",SPI_Data);
    

  288.         return SPI_Data;
    

  289. }
    

  290.  
    

  291.  
    

  292. /*
    

  293.  * 函数名：ReadRawRC
    

  294.  * 描述  ：读RC522寄存器
    

  295.  * 输入  ：ucAddress，寄存器地址
    

  296.  * 返回  : 寄存器的当前值
    

  297.  * 调用  ：内部调用
    

  298.  */
    

  299. u8 ReadRawRC ( u8 ucAddress )
    

  300. {
    

  301.         u8 ucAddr, ucReturn;
    

  302.         
    

  303.         
    

  304.         ucAddr = ( ( ucAddress << 1 ) & 0x7E ) | 0x80;
    

  305.         
    

  306.         RC522_CS_Enable();
    

  307.         
    

  308.         SPI_RC522_SendByte ( ucAddr );
    

  309.         
    

  310.         ucReturn = SPI_RC522_ReadByte ();
    

  311.         
    

  312.         RC522_CS_Disable();
    

  313.  
    

  314.         return ucReturn;
    

  315. }
    

  316.  
    

  317.  
    

  318. /*
    

  319.  * 函数名：WriteRawRC
    

  320.  * 描述  ：写RC522寄存器
    

  321.  * 输入  ：ucAddress，寄存器地址
    

  322.  *         ucValue，写入寄存器的值
    

  323.  * 返回  : 无
    

  324.  * 调用  ：内部调用
    

  325.  */
    

  326. void WriteRawRC ( u8 ucAddress, u8 ucValue )
    

  327. {  
    

  328.         u8 ucAddr;
    

  329.  
    

  330.         ucAddr = ( ucAddress << 1 ) & 0x7E;
    

  331.         
    

  332.         RC522_CS_Enable();
    

  333.         
    

  334.         SPI_RC522_SendByte ( ucAddr );
    

  335.         
    

  336.         SPI_RC522_SendByte ( ucValue );
    

  337.         
    

  338.         RC522_CS_Disable();        
    

  339. }
    

  340.  
    

  341.  
    

  342. /*
    

  343.  * 函数名：SetBitMask
    

  344.  * 描述  ：对RC522寄存器置位
    

  345.  * 输入  ：ucReg，寄存器地址
    

  346.  *         ucMask，置位值
    

  347.  * 返回  : 无
    

  348.  * 调用  ：内部调用
    

  349.  */
    

  350. void SetBitMask ( u8 ucReg, u8 ucMask )  
    

  351. {
    

  352.     u8 ucTemp;
    

  353.  
    

  354.     ucTemp = ReadRawRC ( ucReg );
    

  355.         
    

  356.     WriteRawRC ( ucReg, ucTemp | ucMask );         // set bit mask
    

  357.  
    

  358. }
    

  359.  
    

  360.  
    

  361. /*
    

  362.  * 函数名：ClearBitMask
    

  363.  * 描述  ：对RC522寄存器清位
    

  364.  * 输入  ：ucReg，寄存器地址
    

  365.  *         ucMask，清位值
    

  366.  * 返回  : 无
    

  367.  * 调用  ：内部调用
    

  368.  */
    

  369. void ClearBitMask ( u8 ucReg, u8 ucMask )  
    

  370. {
    

  371.     u8 ucTemp;
    

  372.  
    

  373.     ucTemp = ReadRawRC ( ucReg );
    

  374.         
    

  375.     WriteRawRC ( ucReg, ucTemp & ( ~ ucMask) );  // clear bit mask
    

  376.         
    

  377.         
    

  378. }
    

  379.  
    

  380.  
    

  381. /*
    

  382.  * 函数名：PcdAntennaOn
    

  383.  * 描述  ：开启天线 
    

  384.  * 输入  ：无
    

  385.  * 返回  : 无
    

  386.  * 调用  ：内部调用
    

  387.  */
    

  388. void PcdAntennaOn ( void )
    

  389. {
    

  390.     u8 uc;
    

  391.  
    

  392.     uc = ReadRawRC ( TxControlReg );
    

  393.         
    

  394.     if ( ! ( uc & 0x03 ) )
    

  395.                         SetBitMask(TxControlReg, 0x03);
    

  396.         
    

  397. }
    

  398.  
    

  399.  
    

  400. /*
    

  401.  * 函数名：PcdAntennaOff
    

  402.  * 描述  ：开启天线 
    

  403.  * 输入  ：无
    

  404.  * 返回  : 无
    

  405.  * 调用  ：内部调用
    

  406.  */
    

  407. void PcdAntennaOff ( void )
    

  408. {
    

  409.  
    

  410.     ClearBitMask ( TxControlReg, 0x03 );
    

  411.  
    

  412. }
    

  413.  
    

  414.  
    

  415. /*
    

  416.  * 函数名：PcdRese
    

  417.  * 描述  ：复位RC522 
    

  418.  * 输入  ：无
    

  419.  * 返回  : 无
    

  420.  * 调用  ：外部调用
    

  421.  */
    

  422. void PcdReset ( void )
    

  423. {
    

  424.     RC522_Reset_Disable();
    

  425.  
    

  426.     delay_us ( 1 );
    

  427.  
    

  428.     RC522_Reset_Enable();
    

  429.  
    

  430.     delay_us ( 1 );
    

  431.  
    

  432.     RC522_Reset_Disable();
    

  433.  
    

  434.     delay_us ( 1 );
    

  435.  
    

  436.     WriteRawRC ( CommandReg, 0x0f );
    

  437.  
    

  438.     while ( ReadRawRC ( CommandReg ) & 0x10 );
    

  439.  
    

  440.     delay_us ( 1 );
    

  441.  
    

  442.     WriteRawRC ( ModeReg, 0x3D );            //定义发送和接收常用模式 和Mifare卡通讯，CRC初始值0x6363
    

  443.  
    

  444.     WriteRawRC ( TReloadRegL, 30 );          //16位定时器低位    
    

  445.     WriteRawRC ( TReloadRegH, 0 );                             //16位定时器高位
    

  446.  
    

  447.     WriteRawRC ( TModeReg, 0x8D );                                   //定义内部定时器的设置
    

  448.  
    

  449.     WriteRawRC ( TPrescalerReg, 0x3E );                         //设置定时器分频系数
    

  450.  
    

  451.     WriteRawRC ( TxAutoReg, 0x40 );                                   //调制发送信号为100%ASK        
    

  452.         
    

  453.  
    

  454. }
    

  455.  
    

  456.  
    

  457. /*
    

  458.  * 函数名：M500PcdConfigISOType
    

  459.  * 描述  ：设置RC522的工作方式
    

  460.  * 输入  ：ucType，工作方式
    

  461.  * 返回  : 无
    

  462.  * 调用  ：外部调用
    

  463.  */
    

  464. void M500PcdConfigISOType ( u8 ucType )
    

  465. {
    

  466.         if ( ucType == 'A')                     //ISO14443_A
    

  467.   {
    

  468.                 ClearBitMask ( Status2Reg, 0x08 );
    

  469.                 
    

  470.     WriteRawRC ( ModeReg, 0x3D );//3F
    

  471.                 
    

  472.                 WriteRawRC ( RxSelReg, 0x86 );//84
    

  473.                 
    

  474.                 WriteRawRC( RFCfgReg, 0x7F );   //4F
    

  475.                 
    

  476.                 WriteRawRC( TReloadRegL, 30 );//tmoLength);// TReloadVal = 'h6a =tmoLength(dec) 
    

  477.                 
    

  478.                 WriteRawRC ( TReloadRegH, 0 );
    

  479.                 
    

  480.                 WriteRawRC ( TModeReg, 0x8D );
    

  481.                 
    

  482.                 WriteRawRC ( TPrescalerReg, 0x3E );
    

  483.                 
    

  484.                 delay_us ( 2 );
    

  485.                 
    

  486.                 PcdAntennaOn ();//开天线
    

  487.                 
    

  488.    }
    

  489.  
    

  490. }
    

  491.  
    

  492.  
    

  493. /*
    

  494.  * 函数名：PcdComMF522
    

  495.  * 描述  ：通过RC522和ISO14443卡通讯
    

  496.  * 输入  ：ucCommand，RC522命令字
    

  497.  *         pInData，通过RC522发送到卡片的数据
    

  498.  *         ucInLenByte，发送数据的字节长度
    

  499.  *         pOutData，接收到的卡片返回数据
    

  500.  *         pOutLenBit，返回数据的位长度
    

  501.  * 返回  : 状态值
    

  502.  *         = MI_OK，成功
    

  503.  * 调用  ：内部调用
    

  504.  */
    

  505. char PcdComMF522 ( u8 ucCommand, u8 * pInData, u8 ucInLenByte, u8 * pOutData, u32 * pOutLenBit )                
    

  506. {
    

  507.     char cStatus = MI_ERR;
    

  508.     u8 ucIrqEn   = 0x00;
    

  509.     u8 ucWaitFor = 0x00;
    

  510.     u8 ucLastBits;
    

  511.     u8 ucN;
    

  512.     u32 ul;
    

  513.  
    

  514.     switch ( ucCommand )
    

  515.     {
    

  516.        case PCD_AUTHENT:                //Mifare认证
    

  517.           ucIrqEn   = 0x12;                //允许错误中断请求ErrIEn  允许空闲中断IdleIEn
    

  518.           ucWaitFor = 0x10;                //认证寻卡等待时候 查询空闲中断标志位
    

  519.           break;
    

  520.                          
    

  521.        case PCD_TRANSCEIVE:                //接收发送 发送接收
    

  522.           ucIrqEn   = 0x77;                //允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
    

  523.           ucWaitFor = 0x30;                //寻卡等待时候 查询接收中断标志位与 空闲中断标志位
    

  524.           break;
    

  525.                          
    

  526.        default:
    

  527.          break;
    

  528.                          
    

  529.     }
    

  530.    
    

  531.     WriteRawRC ( ComIEnReg, ucIrqEn | 0x80 );                //IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反 
    

  532.     ClearBitMask ( ComIrqReg, 0x80 );                        //Set1该位清零时，CommIRqReg的屏蔽位清零
    

  533.     WriteRawRC ( CommandReg, PCD_IDLE );                //写空闲命令
    

  534.     SetBitMask ( FIFOLevelReg, 0x80 );                        //置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
    

  535.     
    

  536.     for ( ul = 0; ul < ucInLenByte; ul ++ )
    

  537.                   WriteRawRC ( FIFODataReg, pInData [ ul ] );                    //写数据进FIFOdata
    

  538.                         
    

  539.     WriteRawRC ( CommandReg, ucCommand );                                        //写命令
    

  540.    
    

  541.     
    

  542.     if ( ucCommand == PCD_TRANSCEIVE )
    

  543.                         SetBitMask(BitFramingReg,0x80);                                  //StartSend置位启动数据发送 该位与收发命令使用时才有效
    

  544.     
    

  545.     ul = 1000;//根据时钟频率调整，操作M1卡最大等待时间25ms
    

  546.                 
    

  547.     do                                                                                                                 //认证 与寻卡等待时间        
    

  548.     {
    

  549.          ucN = ReadRawRC ( ComIrqReg );                                                        //查询事件中断
    

  550.          ul --;
    

  551.     } while ( ( ul != 0 ) && ( ! ( ucN & 0x01 ) ) && ( ! ( ucN & ucWaitFor ) ) );                //退出条件i=0,定时器中断，与写空闲命令
    

  552.                 
    

  553.     ClearBitMask ( BitFramingReg, 0x80 );                                        //清理允许StartSend位
    

  554.                 
    

  555.     if ( ul != 0 )
    

  556.     {
    

  557.                 if ( ! (( ReadRawRC ( ErrorReg ) & 0x1B )) )                        //读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
    

  558.                 {
    

  559.                         cStatus = MI_OK;
    

  560.                         
    

  561.                         if ( ucN & ucIrqEn & 0x01 )                                        //是否发生定时器中断
    

  562.                           cStatus = MI_NOTAGERR;   
    

  563.                                 
    

  564.                         if ( ucCommand == PCD_TRANSCEIVE )
    

  565.                         {
    

  566.                                 ucN = ReadRawRC ( FIFOLevelReg );                        //读FIFO中保存的字节数
    

  567.                                 
    

  568.                                 ucLastBits = ReadRawRC ( ControlReg ) & 0x07;        //最后接收到得字节的有效位数
    

  569.                                 
    

  570.                                 if ( ucLastBits )
    

  571.                                         * pOutLenBit = ( ucN - 1 ) * 8 + ucLastBits;           //N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
    

  572.                                 else
    

  573.                                         * pOutLenBit = ucN * 8;                                           //最后接收到的字节整个字节有效
    

  574.                                 
    

  575.                                 if ( ucN == 0 )        
    

  576.                     ucN = 1;    
    

  577.                                 
    

  578.                                 if ( ucN > MAXRLEN )
    

  579.                                         ucN = MAXRLEN;   
    

  580.                                 
    

  581.                                 for ( ul = 0; ul < ucN; ul ++ )
    

  582.                                   pOutData [ ul ] = ReadRawRC ( FIFODataReg );   
    

  583.                         }                
    

  584.         }
    

  585.                         else
    

  586.                                 cStatus = MI_ERR;   
    

  587. //                        printf(ErrorReg);
    

  588.     }
    

  589.    
    

  590.    SetBitMask ( ControlReg, 0x80 );           // stop timer now
    

  591.    WriteRawRC ( CommandReg, PCD_IDLE ); 
    

  592.         
    

  593.    return cStatus;
    

  594.  
    

  595. }
    

  596.  
    

  597.  
    

  598. /*
    

  599.  * 函数名：PcdRequest
    

  600.  * 描述  ：寻卡
    

  601.  * 输入  ：ucReq_code，寻卡方式
    

  602.  *                     = 0x52，寻感应区内所有符合14443A标准的卡
    

  603.  *                     = 0x26，寻未进入休眠状态的卡
    

  604.  *         pTagType，卡片类型代码
    

  605.  *                   = 0x4400，Mifare_UltraLight
    

  606.  *                   = 0x0400，Mifare_One(S50)
    

  607.  *                   = 0x0200，Mifare_One(S70)
    

  608.  *                   = 0x0800，Mifare_Pro(X))
    

  609.  *                   = 0x4403，Mifare_DESFire
    

  610.  * 返回  : 状态值
    

  611.  *         = MI_OK，成功
    

  612.  * 调用  ：外部调用
    

  613.  */
    

  614. char PcdRequest ( u8 ucReq_code, u8 * pTagType )
    

  615. {
    

  616.     char cStatus;  
    

  617.     u8 ucComMF522Buf [ MAXRLEN ]; 
    

  618.     u32 ulLen;
    

  619.  
    

  620.     ClearBitMask ( Status2Reg, 0x08 );        //清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
    

  621.     WriteRawRC ( BitFramingReg, 0x07 );        //        发送的最后一个字节的 七位
    

  622.     SetBitMask ( TxControlReg, 0x03 );        //TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
    

  623.  
    

  624.     ucComMF522Buf [ 0 ] = ucReq_code;                //存入 卡片命令字
    

  625.  
    

  626.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE,        ucComMF522Buf, 1, ucComMF522Buf, & ulLen );        //寻卡  
    

  627.  
    

  628.     if ( ( cStatus == MI_OK ) && ( ulLen == 0x10 ) )        //寻卡成功返回卡类型 
    

  629.     {    
    

  630.        * pTagType = ucComMF522Buf [ 0 ];
    

  631.        * ( pTagType + 1 ) = ucComMF522Buf [ 1 ];
    

  632.     }
    

  633.      
    

  634.     else
    

  635.      cStatus = MI_ERR;
    

  636.  
    

  637.     return cStatus;
    

  638.  
    

  639. }
    

  640.  
    

  641.  
    

  642. /*
    

  643.  * 函数名：PcdAnticoll
    

  644.  * 描述  ：防冲撞
    

  645.  * 输入  ：pSnr，卡片序列号，4字节
    

  646.  * 返回  : 状态值
    

  647.  *         = MI_OK，成功
    

  648.  * 调用  ：外部调用
    

  649.  */
    

  650. char PcdAnticoll ( u8 * pSnr )
    

  651. {
    

  652.     char cStatus;
    

  653.     u8 uc, ucSnr_check = 0;
    

  654.     u8 ucComMF522Buf [ MAXRLEN ]; 
    

  655.         u32 ulLen;
    

  656.  
    

  657.     ClearBitMask ( Status2Reg, 0x08 );                //清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
    

  658.     WriteRawRC ( BitFramingReg, 0x00);                //清理寄存器 停止收发
    

  659.     ClearBitMask ( CollReg, 0x80 );                        //清ValuesAfterColl所有接收的位在冲突后被清除
    

  660.    
    

  661.     ucComMF522Buf [ 0 ] = 0x93;        //卡片防冲突命令
    

  662.     ucComMF522Buf [ 1 ] = 0x20;
    

  663.    
    

  664.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 2, ucComMF522Buf, & ulLen);//与卡片通信
    

  665.         
    

  666.     if ( cStatus == MI_OK)                //通信成功
    

  667.     {
    

  668.                 for ( uc = 0; uc < 4; uc ++ )
    

  669.         {
    

  670.             * ( pSnr + uc )  = ucComMF522Buf [ uc ];                        //读出UID
    

  671.             ucSnr_check ^= ucComMF522Buf [ uc ];
    

  672.         }
    

  673.                         
    

  674.         if ( ucSnr_check != ucComMF522Buf [ uc ] )
    

  675.                         cStatus = MI_ERR;    
    

  676.                                  
    

  677.     }
    

  678.     
    

  679.     SetBitMask ( CollReg, 0x80 );
    

  680.  
    

  681.     return cStatus;
    

  682.         
    

  683. }
    

  684.  
    

  685.  
    

  686. /*
    

  687.  * 函数名：CalulateCRC
    

  688.  * 描述  ：用RC522计算CRC16
    

  689.  * 输入  ：pIndata，计算CRC16的数组
    

  690.  *         ucLen，计算CRC16的数组字节长度
    

  691.  *         pOutData，存放计算结果存放的首地址
    

  692.  * 返回  : 无
    

  693.  * 调用  ：内部调用
    

  694.  */
    

  695. void CalulateCRC ( u8 * pIndata, u8 ucLen, u8 * pOutData )
    

  696. {
    

  697.     u8 uc, ucN;
    

  698.  
    

  699.     ClearBitMask(DivIrqReg,0x04);
    

  700.         
    

  701.     WriteRawRC(CommandReg,PCD_IDLE);
    

  702.         
    

  703.     SetBitMask(FIFOLevelReg,0x80);
    

  704.         
    

  705.     for ( uc = 0; uc < ucLen; uc ++)
    

  706.             WriteRawRC ( FIFODataReg, * ( pIndata + uc ) );   
    

  707.  
    

  708.     WriteRawRC ( CommandReg, PCD_CALCCRC );
    

  709.         
    

  710.     uc = 0xFF;
    

  711.         
    

  712.     do 
    

  713.     {
    

  714.         ucN = ReadRawRC ( DivIrqReg );
    

  715.         uc --;
    

  716.     } while ( ( uc != 0 ) && ! ( ucN & 0x04 ) );
    

  717.                 
    

  718.     pOutData [ 0 ] = ReadRawRC ( CRCResultRegL );
    

  719.     pOutData [ 1 ] = ReadRawRC ( CRCResultRegM );
    

  720.         
    

  721. }
    

  722.  
    

  723.  
    

  724. /*
    

  725.  * 函数名：PcdSelect
    

  726.  * 描述  ：选定卡片
    

  727.  * 输入  ：pSnr，卡片序列号，4字节
    

  728.  * 返回  : 状态值
    

  729.  *         = MI_OK，成功
    

  730.  * 调用  ：外部调用
    

  731.  */
    

  732. char PcdSelect ( u8 * pSnr )
    

  733. {
    

  734.     char ucN;
    

  735.     u8 uc;
    

  736.           u8 ucComMF522Buf [ MAXRLEN ]; 
    

  737.     u32  ulLen;
    

  738.  
    

  739.     ucComMF522Buf [ 0 ] = PICC_ANTICOLL1;
    

  740.     ucComMF522Buf [ 1 ] = 0x70;
    

  741.     ucComMF522Buf [ 6 ] = 0;
    

  742.         
    

  743.     for ( uc = 0; uc < 4; uc ++ )
    

  744.     {
    

  745.             ucComMF522Buf [ uc + 2 ] = * ( pSnr + uc );
    

  746.             ucComMF522Buf [ 6 ] ^= * ( pSnr + uc );
    

  747.     }
    

  748.                 
    

  749.     CalulateCRC ( ucComMF522Buf, 7, & ucComMF522Buf [ 7 ] );
    

  750.   
    

  751.     ClearBitMask ( Status2Reg, 0x08 );
    

  752.  
    

  753.     ucN = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 9, ucComMF522Buf, & ulLen );
    

  754.     
    

  755.     if ( ( ucN == MI_OK ) && ( ulLen == 0x18 ) )
    

  756.       ucN = MI_OK;  
    

  757.     else
    

  758.       ucN = MI_ERR;    
    

  759.  
    

  760.     return ucN;
    

  761.         
    

  762. }
    

  763.  
    

  764.  
    

  765. /*
    

  766.  * 函数名：PcdAuthState
    

  767.  * 描述  ：验证卡片密码
    

  768.  * 输入  ：ucAuth_mode，密码验证模式
    

  769.  *                     = 0x60，验证A密钥
    

  770.  *                     = 0x61，验证B密钥
    

  771.  *         u8 ucAddr，块地址
    

  772.  *         pKey，密码
    

  773.  *         pSnr，卡片序列号，4字节
    

  774.  * 返回  : 状态值
    

  775.  *         = MI_OK，成功
    

  776.  * 调用  ：外部调用
    

  777.  */
    

  778. char PcdAuthState ( u8 ucAuth_mode, u8 ucAddr, u8 * pKey, u8 * pSnr )
    

  779. {
    

  780.     char cStatus;
    

  781.           u8 uc, ucComMF522Buf [ MAXRLEN ];
    

  782.     u32 ulLen;
    

  783.  
    

  784.     ucComMF522Buf [ 0 ] = ucAuth_mode;
    

  785.     ucComMF522Buf [ 1 ] = ucAddr;
    

  786.         
    

  787.     for ( uc = 0; uc < 6; uc ++ )
    

  788.             ucComMF522Buf [ uc + 2 ] = * ( pKey + uc );   
    

  789.         
    

  790.     for ( uc = 0; uc < 6; uc ++ )
    

  791.             ucComMF522Buf [ uc + 8 ] = * ( pSnr + uc );   
    

  792.  
    

  793.     cStatus = PcdComMF522 ( PCD_AUTHENT, ucComMF522Buf, 12, ucComMF522Buf, & ulLen );
    

  794.         
    

  795.     if ( ( cStatus != MI_OK ) || ( ! ( ReadRawRC ( Status2Reg ) & 0x08 ) ) )
    

  796.                         
    

  797.                 {
    

  798. //                        if(cStatus != MI_OK)
    

  799. //                                        printf("666")        ;                
    

  800. //                        else
    

  801. //                                printf("888");
    

  802.                         cStatus = MI_ERR; 
    

  803.     }
    

  804.                 
    

  805.     return cStatus;
    

  806.                 
    

  807. }
    

  808.  
    

  809.  
    

  810. /*
    

  811.  * 函数名：PcdWrite
    

  812.  * 描述  ：写数据到M1卡一块
    

  813.  * 输入  ：u8 ucAddr，块地址
    

  814.  *         pData，写入的数据，16字节
    

  815.  * 返回  : 状态值
    

  816.  *         = MI_OK，成功
    

  817.  * 调用  ：外部调用
    

  818.  */
    

  819. char PcdWrite ( u8 ucAddr, u8 * pData )
    

  820. {
    

  821.     char cStatus;
    

  822.           u8 uc, ucComMF522Buf [ MAXRLEN ];
    

  823.     u32 ulLen;
    

  824.  
    

  825.     ucComMF522Buf [ 0 ] = PICC_WRITE;
    

  826.     ucComMF522Buf [ 1 ] = ucAddr;
    

  827.         
    

  828.     CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
    

  829.  
    

  830.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen );
    

  831.  
    

  832.     if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
    

  833.       cStatus = MI_ERR;   
    

  834.         
    

  835.     if ( cStatus == MI_OK )
    

  836.     {
    

  837.                         memcpy(ucComMF522Buf, pData, 16);
    

  838.       for ( uc = 0; uc < 16; uc ++ )
    

  839.                           ucComMF522Buf [ uc ] = * ( pData + uc );  
    

  840.                         
    

  841.       CalulateCRC ( ucComMF522Buf, 16, & ucComMF522Buf [ 16 ] );
    

  842.  
    

  843.       cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 18, ucComMF522Buf, & ulLen );
    

  844.                         
    

  845.                         if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
    

  846.         cStatus = MI_ERR;   
    

  847.                         
    

  848.     } 
    

  849.  
    

  850.     return cStatus;
    

  851.         
    

  852. }
    

  853.  
    

  854.  
    

  855. /*
    

  856.  * 函数名：PcdRead
    

  857.  * 描述  ：读取M1卡一块数据
    

  858.  * 输入  ：u8 ucAddr，块地址
    

  859.  *         pData，读出的数据，16字节
    

  860.  * 返回  : 状态值
    

  861.  *         = MI_OK，成功
    

  862.  * 调用  ：外部调用
    

  863.  */
    

  864. char PcdRead ( u8 ucAddr, u8 * pData )
    

  865. {
    

  866.     char cStatus;
    

  867.           u8 uc, ucComMF522Buf [ MAXRLEN ]; 
    

  868.     u32 ulLen;
    

  869.  
    

  870.     ucComMF522Buf [ 0 ] = PICC_READ;
    

  871.     ucComMF522Buf [ 1 ] = ucAddr;
    

  872.         
    

  873.     CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
    

  874.    
    

  875.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen );
    

  876.         
    

  877.     if ( ( cStatus == MI_OK ) && ( ulLen == 0x90 ) )
    

  878.     {
    

  879.                         for ( uc = 0; uc < 16; uc ++ )
    

  880.         * ( pData + uc ) = ucComMF522Buf [ uc ];   
    

  881.     }
    

  882.                 
    

  883.     else
    

  884.       cStatus = MI_ERR;   
    

  885.         
    

  886.     return cStatus;
    

  887.  
    

  888. }
    

  889.  
    

  890.  
    

  891. /*
    

  892.  * 函数名：PcdHalt
    

  893.  * 描述  ：命令卡片进入休眠状态
    

  894.  * 输入  ：无
    

  895.  * 返回  : 状态值
    

  896.  *         = MI_OK，成功
    

  897.  * 调用  ：外部调用
    

  898.  */
    

  899. char PcdHalt( void )
    

  900. {
    

  901.     u8 ucComMF522Buf [ MAXRLEN ]; 
    

  902.     u32  ulLen;
    

  903.  
    

  904.     ucComMF522Buf [ 0 ] = PICC_HALT;
    

  905.     ucComMF522Buf [ 1 ] = 0;
    

  906.  
    

  907.     CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
    

  908.             PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen );
    

  909.  
    

  910.     return MI_OK;
    

  911.         
    

  912. }
    

  913.  
    

  914.  
    

  915. void IC_CMT ( u8 * UID, u8 * KEY, u8 RW, u8 * Dat )
    

  916. {
    

  917.     u8 ucArray_ID [ 4 ] = { 0 };//先后存放IC卡的类型和UID(IC卡序列号)
    

  918.  
    

  919.     PcdRequest ( 0x52, ucArray_ID );//寻卡
    

  920.  
    

  921.     PcdAnticoll ( ucArray_ID );//防冲撞
    

  922.  
    

  923.     PcdSelect ( UID );//选定卡
    

  924.  
    

  925.     PcdAuthState ( 0x60, 0x10, KEY, UID );//校验
    

  926.  
    

  927.     if ( RW )//读写选择，1是读，0是写
    

  928.         PcdRead ( 0x10, Dat );
    

  929.  
    

  930.     else 
    

  931.         PcdWrite ( 0x10, Dat );
    

  932.      
    

  933.     PcdHalt ();         
    

  934.          
    

  935. }
    

  936.  
    

  937. void ShowID(u8 *p)         //显示卡的卡号，以十六进制显示
    

  938. {
    

  939.         u8 num[9];
    

  940.         u8 i;
    

  941.  
    

  942.          for(i=0;i<4;i++)
    

  943.         {
    

  944.                 num[i*2]=p[i]/16;
    

  945.                 num[i*2]>9?(num[i*2]+='7'):(num[i*2]+='0');
    

  946.                 num[i*2+1]=p[i]%16;
    

  947.                 num[i*2+1]>9?(num[i*2+1]+='7'):(num[i*2+1]+='0');
    

  948.         }
    

  949.         num[8]=0;
    

  950.         for(i =0;i<10;i++)
    

  951.                 {
    

  952.                     SN[i] = num[i];
    

  953.                 }
    

  954.                 sprintf(ss,"%s",SN);
    

  955.                  OLED_ShowString(0,0,"ID:",16); //oled显示
    

  956.                 OLED_ShowString(25,0,(u8*)ss,16); //oled显示 
    

  957.                 if(strcmp(SN,"F3355E0D") == 0)
    

  958.                 {
    

  959.                     LED0 = 0;
    

  960.                         delay_ms(500);
    

  961.                         LED0=1;
    

  962.                 }
    

  963.                 else 
    

  964.                 {
    

  965.                 //        OLED_ShowString(0,5,"error",16); //oled显示
    

  966.                 }
    

  967.         
    


  968. 

  969.     printf("ID>>>%s\r\n", num);
    

  970.  
    

  971. }
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:23 | 显示全部楼层
main.c
复制
  1. #include "led.h"
    

  2. #include "delay.h"
    

  3. #include "key.h"
    

  4. #include "sys.h"
    

  5. #include "usart.h"
    

  6. #include "rc522.h" 
    

  7. #include "beep.h"
    

  8. #include "oled.h"
    


  9. 


  10. 

  11. u8 RC522_lock(void);//刷卡解锁
    

  12. u8 cardid[6]={0,0,0,0,0,0};  //卡号1
    

  13. //MFRC522数据区
    

  14. u8  mfrc552pidbuf[18];
    

  15. u8  card_pydebuf[2];
    

  16. u8  card_numberbuf[5];
    

  17. u8  card_key0Abuf[6]={0xff,0xff,0xff,0xff,0xff,0xff};
    

  18. u8  card_writebuf[16]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    

  19. u8  card_readbuf[18];
    

  20.  int main(void)
    

  21.  {                
    

  22.         delay_init();                     //延时函数初始化          
    

  23.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    

  24.         uart_init(115200);         //串口初始化为115200
    

  25.          LED_Init();                             //LED端口初始化
    

  26.         KEY_Init();          //初始化与按键连接的硬件接口
    

  27.         RC522_Init();                                //初始化射频卡模块
    

  28. //        BEEP_Init();                                //初始化蜂鸣器
    

  29.         OLED_Init();                //初始化OLED
    

  30.         OLED_Clear();                 //清屏
    

  31.         
    

  32.         OLED_ShowCHinese(0,5,9); //刷
    

  33.         OLED_ShowCHinese(15,5,2); //卡
    

  34.         OLED_ShowCHinese(30,5,12); //显
    

  35.         OLED_ShowCHinese(45,5,13); //示
    

  36.          while(1)
    

  37.         {
    


  38. 

  39.                 RC522_Handel();
    

  40.         }         
    

  41.  }
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:26 | 显示全部楼层
https://live.csdn.net/v/embed/197467  刷卡能够显示卡的ID号，如果ID号正确能够亮灯，请看具体的代码，下面是视频演示
回复

收藏 举报

 楼主| 无法去污粉 发表于 2022-12-25 15:27 | 显示全部楼层
7、备注：
本文章是个人总结，如有错误请指正；
部分资料来源于网络和开发手册，如有侵权请联系我删除；
回复

收藏 举报

华力电子 发表于 2023-3-29 09:42 | 显示全部楼层
有可以兼容读写IC与ID卡频段的没
回复

收藏 举报

午夜粪车 发表于 2023-3-30 19:11 | 显示全部楼层
电子标签与阅读器之间通过耦合元件实现射频信号的空间(无接触)耦合、在耦合通道内，根据时序关系，实现能量的传递、数据的交换
回复

收藏 举报

songqian17 发表于 2023-3-30 19:29 | 显示全部楼层
信息可以以异步 (Asynchronous)的方式传送，所以传送者不必等待回应
回复

收藏 举报

huwr 发表于 2023-3-30 19:31 | 显示全部楼层
面向消息的中间件包含些什么功能
回复

收藏 举报

huwr 发表于 2023-3-30 19:43 | 显示全部楼层
低频、高频和超高频(甚高频)、微波等
回复

收藏 举报

童雨竹 发表于 2024-2-5 08:10 | 显示全部楼层

只要内存占用量不超过 256.0 就可以用 small 模式编译
回复

收藏 举报

Clyde011 发表于 2024-2-5 10:16 | 显示全部楼层

电流型变换器电流检测电阻的公共接点和输出端电阻分压器的下端
回复

收藏 举报

公羊子丹 发表于 2024-2-5 11:09 | 显示全部楼层

超过变量128后必须使用compact模式编译
回复

收藏 举报

公羊子丹 发表于 2024-2-5 11:09 | 显示全部楼层

超过变量128后必须使用compact模式编译
回复

收藏 举报

Uriah 发表于 2024-2-5 13:15 | 显示全部楼层

数字电压表(DVM)或仪器来测量效率
回复

收藏 举报

帛灿灿 发表于 2024-2-5 15:11 | 显示全部楼层

任何一条PCB引线都可能成为天线
回复

收藏 举报

下一页 »
123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部