设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › 基于stm32F103xxx与RFID-RC522的门禁程序
返回列表 发新帖
查看: 5152|回复: 6
收起左侧

基于stm32F103xxx与RFID-RC522的门禁程序

  [复制链接]
ID:618513 发表于 2021-1-4 20:37 | 显示全部楼层 |阅读模式
最近用到了RFID-RC522，找了很多资料，总结了一下 顺便和大家分享分享。  再本人的项目中RFID只是用来起到刷卡开门的效果，顺带用串口打印显示ID号。 需要的朋友自行下载。
RD
连线如下：
//SPI2_SCK                         PB13
//SPI2_MISO                        PB14
//SPI2_MOSI                         PB15
//RCC522_RST                   PC4
//RCC522_SDA                   PB0
//RCC522_IRQ                         悬空（不管）


直接移植久好  驱动是全的      
  1. #include "rc522.h"

  3. //SPI2_SCK                                 PB13
  4. //SPI2_MISO                                PB14
  5. //SPI2_MOSI                         PB15
  6. //RCC522_RST(CE)  PC4
  7. //RCC522_NSS(SDA）PB0
  8. //RCC522_IRQ                         悬空

  10. void SPI2_Init(void)
  11. {
  12.         GPIO_InitTypeDef GPIO_InitStructure;
  13.         SPI_InitTypeDef  SPI_InitStructure;

  15.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE );        //PORTB时钟使能
  16.         RCC_APB1PeriphClockCmd(        RCC_APB1Periph_SPI2,  ENABLE );                                                                                                //SPI2时钟使能         

  18.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
  19.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                                                                                                                          //PB13/14/15复用推挽输出
  20.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  21.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                                                                                                                                                //初始化GPIOB
  22.         GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);                                                                                  //PB13/14/15上拉
  23.         
  24.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;                                                                                                                                                        //PB0 RC522_CS
  25.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                                                                                                  //PB0推挽输出
  26.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                                                                                                                                                //初始化GPIOB
  27.         GPIO_SetBits(GPIOB,GPIO_Pin_0);                                                                                                                                                                                          //PB0上拉        

  29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;                                                                                                                                                        //PC4 RC522_RST
  30.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                                                                                                                  //推挽输出
  31.         GPIO_Init(GPIOC, &GPIO_InitStructure);                                                                                                                                                                //初始化GPIOC
  32.         GPIO_SetBits(GPIOC,GPIO_Pin_4);                                                                                                                                                                                          //PC4

  34.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;                                          //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
  35.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                                                                                                                                        //设置SPI工作模式:设置为主SPI
  36.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                                                                                                                        //设置SPI的数据大小:SPI发送接收8位帧结构
  37.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                                                                                                                                                //串行同步时钟的空闲状态为高电平
  38. //                 SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;        
  39. //                SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;                                                                                                                                        //串行同步时钟的第一个跳变沿（下降）数据被采样
  40.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                                                                                                                                                //串行同步时钟的第二个跳变沿（上升）数据被采样
  41.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                                                                                                                                                        //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
  42. //RC522 SPI通讯时钟周期最小为100ns        即频率最大为10MHZ
  43. //RC522 数据在下降沿变化
  44.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                                        //定义波特率预分频的值:波特率预分频值为256、传输速率36M/256=140.625KHz
  45.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                                                                                                                //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
  46.         SPI_InitStructure.SPI_CRCPolynomial = 7;                                                                                                                                                        //CRC值计算的多项式
  47.         SPI_Init(SPI2, &SPI_InitStructure);                                                                                                                                                                          //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器

  49.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
  50.         RC522_CS=0;
  51.         SPI2_ReadWriteByte(0xaa);//启动传输        
  52.         RC522_CS=1;
  53.                
  54.   delay_ms(50);
  55.         PcdReset();//复位RC522读卡器
  56.         delay_ms(10);
  57.         PcdReset();//复位RC522读卡器
  58.         delay_ms(10);
  59.         PcdAntennaOff();//关闭天线发射                                                         
  60.         delay_ms(10);         
  61.   PcdAntennaOn();//开启天线发射
  62.         printf("RFID-MFRC522 TEST\r\nFindCard Starting ...\r\n");  //测试引脚初始化完成
  63. }


  66. void delay_ns(u32 ns)
  67. {
  68.   u32 i;
  69.   for(i=0;i<ns;i++)
  70.   {
  71.     __nop();
  72.     __nop();
  73.     __nop();
  74.   }
  75. }

  77. /***************************************************************************
  78.     - 功能描述：STM32f103 SPI读写字节函数
  79.     - 隶属模块：STM32 SPI操作
  80.   - 函数属性：外部，使用户使用
  81.   - 参数说明：TxData:要写入的字节
  82.   - 返回说明：读取到的字节
  83. - 函数说明：由于主机SPI通信时，在发送和接受时是同时进行的,即发送完了一个字节的数据后，也应当接受到一个字节的数据
  84.    （1）stm32先等待已发送的数据是否发送完成，如果没有发送完成，并且进入循环200次，则表示发送错误，返回收到的值为0;
  85.    （2）如果发送完成，stm32从SPI1总线发送TxData
  86.    （3）stm32再等待接收的数据是否接收完成，如果没有接收完成，并且进入循环200次，则表示接收错误，则返回值0
  87.    （4）如果接收完成了，则返回STm32读取的最新的数据  
  88.    
  89.    stm32
  90.    ------->等待已发送的数据是否完成
  91.    OK
  92.    ------->  
  93.    stm32发送数据
  94.    ------->等待待接收的数据是否完成
  95.    OK
  96.    ------->
  97.    stm32读取数据

  99. //SPIx 读写一个字节
  100. //TxData:要写入的字节
  101. //返回值:读取到的字节
  102. ***************************************************************************/

  104. char SPI2_ReadWriteByte(u8 TxData)
  105. {                                                
  106.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
  107.                 {
  108.                         ;
  109.                 }                          
  110.         SPI_I2S_SendData(SPI2, TxData);                                                                                                                                 //通过外设SPIx发送一个数据
  111.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
  112.                 {
  113. //                 retry++;
  114. //                 if(retry>200)return 0;
  115.                         ;
  116.                 }                                                              
  117.         return SPI_I2S_ReceiveData(SPI2);                                                                                                                         //返回通过SPIx最近接收的数据                                            
  118. }
  119. // u8 SPI2_ReadWriteByte(u8 Byte)
  120. // {
  121. //         while((SPI2->SR&0X02)==0);                //等待发送区空         
  122. //         SPI2->DR=Byte;                             //发送一个byte   
  123. //         while((SPI2->SR&0X01)==0);      //等待接收完一个byte  
  124. //         return SPI2->DR;                      //返回收到的数据                        
  125. // }


  128. //******************************************************************/
  129. //功    能：读RC522寄存器
  130. //参数说明：Address[IN]:寄存器地址
  131. //返    回：读出的值
  132. //******************************************************************/
  133. unsigned char ReadRawRC(unsigned char Address)
  134. {
  135.         u8 ucAddr;
  136.   u8 ucResult=0;
  137.         RC522_CS=0;
  138.         delay_us(10);
  139.    ucAddr = ((Address<<1)&0x7E)|0x80;
  140.         SPI2_ReadWriteByte(ucAddr);
  141.         delay_us(10);
  142.         ucResult=SPI2_ReadWriteByte(0);
  143.         delay_us(10);
  144.         RC522_CS=1;
  145.   return ucResult;
  146. }

  148. //******************************************************************/
  149. //功    能：写RC522寄存器
  150. //参数说明：Address[IN]:寄存器地址
  151. //          value[IN]:写入的值
  152. //******************************************************************/
  153. void WriteRawRC(unsigned char Address, unsigned char value)
  154. {
  155.         u8 ucAddr;
  156.         RC522_CS=0;
  157.         delay_us(10);
  158.         ucAddr = ((Address<<1)&0x7E) ;
  159.         SPI2_ReadWriteByte(ucAddr);
  160.         delay_us(10);
  161.         SPI2_ReadWriteByte(value);
  162.         delay_us(10);
  163.         RC522_CS=1;
  164. }

  166. //******************************************************************/
  167. //功    能：置RC522寄存器位
  168. //参数说明：reg[IN]:寄存器地址
  169. //          mask[IN]:置位值
  170. //******************************************************************/
  171. void SetBitMask(unsigned char reg,unsigned char mask)  
  172. {
  173.   char tmp = 0x0            ;
  174.   tmp = ReadRawRC(reg)| mask;
  175.   WriteRawRC(reg,tmp | mask);  // set bit mask
  176. }

  178. //******************************************************************/
  179. //功    能：清RC522寄存器位
  180. //参数说明：reg[IN]:寄存器地址
  181. //          mask[IN]:清位值
  182. //******************************************************************/
  183. void ClearBitMask(unsigned char reg,unsigned char mask)  
  184. {
  185.   char tmp = 0x0              ;
  186.   tmp = ReadRawRC(reg)&(~mask);
  187.   WriteRawRC(reg, tmp)        ;  // clear bit mask
  188. }

  190. //******************************************************************/
  191. //功    能：复位RC522
  192. //返    回: 成功返回MI_OK
  193. //******************************************************************/
  194. char PcdReset()
  195. {
  196.   RC522_RST=1;                             ;
  197.   delay_ns(10)                             ;
  198.   RC522_RST=0;                             ;
  199.   delay_ns(100)                             ;
  200.   RC522_RST=1;                             ;
  201.   delay_ns(10)                           ;
  202.   WriteRawRC(CommandReg,PCD_RESETPHASE);
  203.   delay_ns(100)                             ;
  204.   WriteRawRC(ModeReg,0x3D)             ;//定义发送和接收常用模式 和Mifare卡通讯，CRC初始值0x6363
  205.   WriteRawRC(TReloadRegL,30)           ;//16位定时器低位 30
  206.   WriteRawRC(TReloadRegH,0)            ;//16位定时器高位
  207.   WriteRawRC(TModeReg,0x8D)            ;//定义内部定时器的设置
  208.   WriteRawRC(TPrescalerReg,0x3E)       ;//设置定时器分频系数  
  209.   WriteRawRC(TxASKReg,0x40)            ;//调制发送信号为100%ASK
  210.   return MI_OK                         ;
  211. }
  212. //////////////////////////////////////////////////////////////////////
  213. //设置RC522的工作方式   
  214. //////////////////////////////////////////////////////////////////////
  215. char MF522PcdConfigISOType(unsigned char  type)
  216. {
  217.         if (type == 'A')        //ISO14443_A
  218.                 {
  219.                         ClearBitMask(Status2Reg,0x08);        //状态2寄存器         
  220.                         WriteRawRC(ModeReg,0x3D);        //3F  //和Mifare卡通讯，CRC初始值0x6363         
  221.                         WriteRawRC(RxSelReg,0x86);        //84   选择内部接收器设置，内部模拟部分调制信号，发送数据后，延迟6个位时钟，接收         
  222.                         WriteRawRC(RFCfgReg,0x7F);        //4F  配置接收器  48dB最大增益         
  223.                         WriteRawRC(TReloadRegL,30);        //tmoLength);TReloadVal = 'h6a =tmoLength(dec)      
  224.                         WriteRawRC(TReloadRegH,0);        //实际值是OXD3E 这部分主要是设置定时器寄存器      
  225.                         WriteRawRC(TModeReg,0x8D);
  226.                         WriteRawRC(TPrescalerReg,0x3E);
  227.                         delay_ns(1000);
  228.                         PcdAntennaOn();
  229.                 }     
  230.         else {return 0xFE;}  
  231.         return MI_OK;
  232. }  

  234. //******************************************************************/
  235. //开启天线发射  
  236. //每次启动或关闭天险发射之间应至少有1ms的间隔
  237. //******************************************************************/
  238. void PcdAntennaOn()
  239. {
  240.   unsigned char i;
  241.   WriteRawRC(TxASKReg,0x40)       ;
  242.   delay_us(10)                       ;
  243.   i = ReadRawRC(TxControlReg)     ;
  244.   if(!(i&0x03))
  245.     SetBitMask(TxControlReg, 0x03);
  246.   i=ReadRawRC(TxASKReg)       ;
  247. }


  250. //******************************************************************/
  251. //关闭天线发射
  252. //******************************************************************/
  253. void PcdAntennaOff()
  254. {
  255.   ClearBitMask(TxControlReg, 0x03);
  256. }

  258. //******************************************************************/
  259. //功    能：通过RC522和ISO14443卡通讯
  260. //参数说明：Command[IN]:RC522命令字
  261. //          pInData[IN]:通过RC522发送到卡片的数据
  262. //          InLenByte[IN]:发送数据的字节长度
  263. //          pOutData[OUT]:接收到的卡片返回数据
  264. //          *pOutLenBit[OUT]:返回数据的位长度
  265. //******************************************************************/
  266. char PcdComMF522(unsigned char Command  ,unsigned char *pInData ,
  267.                  unsigned char InLenByte,unsigned char *pOutData,
  268.                  unsigned int  *pOutLenBit                       )
  269. {
  270.   char status = MI_ERR                          ;
  271.   unsigned char irqEn   = 0x00                  ;
  272.   unsigned char waitFor = 0x00                  ;
  273.   unsigned char lastBits                        ;
  274.   unsigned char n                               ;
  275.   unsigned int  i                               ;
  276.   switch (Command)
  277.   {
  278.     case PCD_AUTHENT:
  279.       irqEn   = 0x12                            ;
  280.       waitFor = 0x10                            ;
  281.       break                                     ;
  282.     case PCD_TRANSCEIVE:
  283.       irqEn   = 0x77                            ;
  284.       waitFor = 0x30                            ;
  285.       break                                     ;
  286.     default:
  287.       break                                     ;
  288.   }
  289.   WriteRawRC(ComIEnReg,irqEn|0x80)              ; //
  290.   ClearBitMask(ComIrqReg,0x80)                  ;
  291.   WriteRawRC(CommandReg,PCD_IDLE)               ;
  292.   SetBitMask(FIFOLevelReg,0x80)                 ; // 清空FIFO
  293.   for(i=0; i<InLenByte; i++)
  294.     WriteRawRC(FIFODataReg,pInData[i])          ; // 数据写入FIFO
  295.   WriteRawRC(CommandReg, Command)               ; // 命令写入命令寄存器
  296.   if(Command == PCD_TRANSCEIVE)
  297.     SetBitMask(BitFramingReg,0x80)              ; // 开始发送     
  298.   i = 6000                                      ; //根据时钟频率调整，操作M1卡最大等待时间25ms
  299.   do
  300.   {
  301.     n = ReadRawRC(ComIrqReg)                    ;
  302.     i--                                         ;
  303.   }
  304.   while((i!=0)&&!(n&0x01)&&!(n&waitFor))        ;
  305.   ClearBitMask(BitFramingReg,0x80)              ;
  306.   if(i!=0)
  307.   {
  308.     if(!(ReadRawRC(ErrorReg)&0x1B))
  309.     {
  310.       status = MI_OK                            ;
  311.       if (n&irqEn&0x01)
  312.         status = MI_NOTAGERR                    ;
  313.       if(Command==PCD_TRANSCEIVE)
  314.       {
  315.         n = ReadRawRC(FIFOLevelReg)             ;
  316.         lastBits = ReadRawRC(ControlReg)&0x07   ;
  317.         if(lastBits)
  318.           *pOutLenBit = (n-1)*8 + lastBits      ;
  319.         else
  320.           *pOutLenBit = n*8                     ;
  321.         if(n==0)
  322.           n = 1                                 ;
  323.         if(n>MAXRLEN)
  324.           n = MAXRLEN                           ;
  325.         for (i=0; i<n; i++)
  326.           pOutData[i] = ReadRawRC(FIFODataReg)  ;
  327.       }
  328.     }
  329.     else
  330.       status = MI_ERR                           ;        
  331.   }
  332.   SetBitMask(ControlReg,0x80)                   ;// stop timer now
  333.   WriteRawRC(CommandReg,PCD_IDLE)               ;
  334.   return status;
  335. }

  337. //******************************************************************/
  338. //功    能：寻卡                                                    /
  339. //参数说明: req_code[IN]:寻卡方式                                   /
  340. //                0x52 = 寻感应区内所有符合14443A标准的卡           /
  341. //                0x26 = 寻未进入休眠状态的卡                       /
  342. //                pTagType[OUT]：卡片类型代码                       /
  343. //                0x4400 = Mifare_UltraLight                        /
  344. //                0x0400 = Mifare_One(S50)                          /
  345. //                0x0200 = Mifare_One(S70)                          /
  346. //                0x0800 = Mifare_Pro(X)                            /
  347. //                0x4403 = Mifare_DESFire                           /
  348. //返    回: 成功返回MI_OK                                           /
  349. //******************************************************************/
  350. char PcdRequest(unsigned char req_code,unsigned char *pTagType)
  351. {
  352.   char status                                        ;  
  353.   unsigned int  unLen                                ;
  354.   unsigned char ucComMF522Buf[MAXRLEN]               ;

  356.   ClearBitMask(Status2Reg,0x08)                      ;//清除MRCrypto1on，要用软件清零
  357.   WriteRawRC(BitFramingReg,0x07)                     ;//startsend=0,rxalign=0,在FIFO中存放的位置，TXlastbit=7
  358.   SetBitMask(TxControlReg,0x03)                      ;//TX2rfen=1,TX1RFen=1,传递调制的13.56MHZ的载波信号

  360.   ucComMF522Buf[0] = req_code                        ;

  362.   status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen       );
  363.   if ((status == MI_OK) && (unLen == 0x10))
  364.   {   
  365.     *pTagType     = ucComMF522Buf[0]                 ;
  366.     *(pTagType+1) = ucComMF522Buf[1]                 ;
  367.   }
  368.   else
  369.     status = MI_ERR                                  ;
  370.   return status                                      ;
  371. }

  373. //******************************************************************/
  374. //功    能：防冲撞                                                  /
  375. //参数说明: pSnr[OUT]:卡片序列号，4字节                             /
  376. //返    回: 成功返回MI_OK                                           /
  377. //******************************************************************/
  378. char PcdAnticoll(unsigned char *pSnr)
  379. {
  380.     char status;
  381.     unsigned char i,snr_check=0;
  382.     unsigned int  unLen;
  383.     unsigned char ucComMF522Buf[MAXRLEN];
  384.    
  385.     ClearBitMask(Status2Reg,0x08);//清除MRCrypto1on，要用软件清零
  386.     WriteRawRC(BitFramingReg,0x00);//表示最后一个字节所有位都发送
  387.     ClearBitMask(CollReg,0x80);//CollRegCollReg0冲突结束后冲突位被置零

  389.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  390.     ucComMF522Buf[1] = 0x20;

  392.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);

  394.     if (status == MI_OK)
  395.     {
  396.              for (i=0; i<4; i++)
  397.          {   
  398.              *(pSnr+i)  = ucComMF522Buf[i];
  399.              snr_check ^= ucComMF522Buf[i];
  400.          }
  401.          if (snr_check != ucComMF522Buf[i])
  402.          {   status = MI_ERR;    }
  403.     }
  404.    
  405.     SetBitMask(CollReg,0x80);//CollRegCollReg 在106kbps良好的防冲突情况下该位置1
  406.     return status;
  407. }

  409. /////////////////////////////////////////////////////////////////////
  410. //功    能：选定卡片
  411. //参数说明: pSnr[IN]:卡片序列号，4字节
  412. //返    回: 成功返回MI_OK
  413. /////////////////////////////////////////////////////////////////////
  414. char PcdSelect(unsigned char *pSnr)
  415. {
  416.     char status;
  417.     unsigned char i;
  418.     unsigned int  unLen;
  419.     unsigned char ucComMF522Buf[MAXRLEN];
  420.    
  421.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  422.     ucComMF522Buf[1] = 0x70;
  423.     ucComMF522Buf[6] = 0;
  424.     for (i=0; i<4; i++)
  425.     {
  426.             ucComMF522Buf[i+2] = *(pSnr+i);
  427.             ucComMF522Buf[6]  ^= *(pSnr+i);
  428.     }
  429.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
  430.   
  431.     ClearBitMask(Status2Reg,0x08);//清零MFcryon

  433.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
  434.    
  435.     if ((status == MI_OK) && (unLen == 0x18))
  436.     {   status = MI_OK;  }
  437.     else
  438.     {   status = MI_ERR;    }

  440.     return status;
  441. }

  443. //******************************************************************/
  444. //功    能：验证卡片密码
  445. //参数说明: auth_mode[IN]: 密码验证模式
  446. //                 0x60 = 验证A密钥
  447. //                 0x61 = 验证B密钥
  448. //          addr[IN]：块地址
  449. //          pKey[IN]：密码
  450. //          pSnr[IN]：卡片序列号，4字节
  451. //返    回: 成功返回MI_OK
  452. //******************************************************************/
  453. char PcdAuthState(unsigned char auth_mode,unsigned char addr,
  454.                   unsigned char *pKey,unsigned char *pSnr    )
  455. {
  456.     char status;
  457.     unsigned int  unLen;
  458.     unsigned char i,ucComMF522Buf[MAXRLEN];

  460.     ucComMF522Buf[0] = auth_mode;//验证A密钥
  461.     ucComMF522Buf[1] = addr;//addr[IN]：块地址
  462.     for (i=0; i<6; i++)
  463.     {    ucComMF522Buf[i+2] = *(pKey+i);   }
  464.     for (i=0; i<6; i++)
  465.     {    ucComMF522Buf[i+8] = *(pSnr+i);   }
  466.    
  467.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
  468.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
  469.     {   status = MI_ERR;   }
  470.    
  471.     return status;
  472. }

  474. //******************************************************************/
  475. //功    能：读取M1卡一块数据
  476. //参数说明: addr[IN]：块地址
  477. //          pData[OUT]：读出的数据，16字节
  478. //返    回: 成功返回MI_OK
  479. //******************************************************************/
  480. char PcdRead(unsigned char addr,unsigned char *pData)
  481. {
  482.     char status                                          ;
  483.     unsigned int  unLen                                  ;
  484.     unsigned char i,ucComMF522Buf[MAXRLEN]               ;

  486.     ucComMF522Buf[0] = PICC_READ                         ;
  487.     ucComMF522Buf[1] = addr                              ;
  488.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2])       ;   
  489.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,
  490.                          ucComMF522Buf,&unLen           );
  491.     if ((status == MI_OK) && (unLen == 0x90))
  492.     {
  493.         for (i=0; i<16; i++)
  494.             *(pData+i) = ucComMF522Buf[i];   
  495.     }
  496.     else
  497.       status = MI_ERR;      
  498.     return status;
  499. }

  501. //******************************************************************/
  502. //功    能：读取M1卡一块数据
  503. //参数说明: addr[IN]：块地址
  504. //          pData[OUT]：读出的数据，16字节
  505. //返    回: 成功返回MI_OK
  506. //******************************************************************/
  507. char Read_Block(unsigned char Block,unsigned char *Buf)
  508. {
  509.   char result                                             ;
  510.   result = PcdAuthState(0x60,Block,Password_Buffer,UID)   ;
  511.   if(result!=MI_OK)
  512.     return result                                         ;
  513.   result = PcdRead(Block,Buf)                             ;
  514. //  return result; // 2011.01.03
  515.   
  516.   if(result!=MI_OK)     return   result                   ;
  517.   if(Block!=0x00&&des_on)
  518.   {
  519. //     Des_Decrypt((char *)Buf    ,KK,(char *)Buf    )       ;
  520. //     Des_Decrypt((char *)&Buf[8],KK,(char *)&Buf[8])       ;  
  521.   }
  522.   return SUCCESS                                          ;
  523. }

  525. //******************************************************************/
  526. //功    能：写数据到M1卡一块
  527. //参数说明: addr[IN]：块地址
  528. //          pData[IN]：写入的数据，16字节
  529. //返    回: 成功返回MI_OK
  530. //******************************************************************/
  531. char PcdWrite(unsigned char addr,unsigned char *pData)
  532. {
  533.   char status                                             ;
  534.   unsigned int  unLen                                     ;
  535.   unsigned char i,ucComMF522Buf[MAXRLEN]                  ;
  536.    
  537.   ucComMF522Buf[0] = PICC_WRITE                           ;
  538.   ucComMF522Buf[1] = addr                                 ;
  539.   CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2])          ;
  540.   status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,
  541.                        ucComMF522Buf,&unLen          )    ;
  542.   if(  ( status != MI_OK)||(unLen != 4)
  543.      ||((ucComMF522Buf[0]&0x0F)!= 0x0A))
  544.     status = MI_ERR                                       ;           
  545.   if (status == MI_OK)
  546.   {
  547.     for (i=0; i<16; i++)
  548.       ucComMF522Buf[i] = *(pData+i)                       ;  
  549.     CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16])      ;
  550.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,
  551.                          18,ucComMF522Buf,&unLen     )    ;
  552.     if(  (status != MI_OK)||(unLen != 4 )
  553.        ||((ucComMF522Buf[0]&0x0F)!= 0x0A))
  554.       status = MI_ERR                                     ;   
  555.   }   
  556.   return status                                           ;
  557. }
  558. //******************************************************************/
  559. //功    能：写数据到M1卡一块
  560. //参数说明: addr[IN]：块地址
  561. //          pData[IN]：写入的数据，16字节
  562. //返    回: 成功返回MI_OK
  563. //******************************************************************/

  565. //******************************************************************/
  566. //用MF522计算CRC16函数
  567. //******************************************************************/
  568. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
  569. {
  570.     unsigned char i,n;
  571.     ClearBitMask(DivIrqReg,0x04);
  572.     WriteRawRC(CommandReg,PCD_IDLE);//取消当前命令
  573.     SetBitMask(FIFOLevelReg,0x80);//FlushBuffer 清除ErrReg 的标志位
  574.     for (i=0; i<len; i++)
  575.     {   WriteRawRC(FIFODataReg, *(pIndata+i));   }
  576.     WriteRawRC(CommandReg, PCD_CALCCRC);
  577.     i = 0xFF;
  578.     do
  579.     {
  580.         n = ReadRawRC(DivIrqReg);
  581.         i--;
  582.     }
  583.     while ((i!=0) && !(n&0x04));//当CRCIRq所有数据被处理完毕该位置位
  584.     pOutData[0] = ReadRawRC(CRCResultRegL);//显示计算出来的CRC值
  585.     pOutData[1] = ReadRawRC(CRCResultRegM);
  586. }


  589. //==============================================================================
  590. //读取卡的类型
  591. //读取卡的ID号
  592. // 卡片：12AAD52D
  593. // 卡环：EC838322
  594. //==============================================================================
  595. void ReaderCard(void)
  596. {
  597.         char temp_value;
  598.         if(PcdRequest(PICC_REQALL,Temp)==MI_OK)        //选卡
  599.         {
  600.                 if(Temp[0]==0x04&&Temp[1]==0x00)  
  601.                                 printf("MFOne-S50");
  602.                 else if(Temp[0]==0x02&&Temp[1]==0x00)
  603.                         printf("MFOne-S70");
  604.                 else if(Temp[0]==0x44&&Temp[1]==0x00)
  605.                         printf("MF-UltraLight");
  606.                 else if(Temp[0]==0x08&&Temp[1]==0x00)
  607.                         printf("MF-Pro");
  608.                 else if(Temp[0]==0x44&&Temp[1]==0x03)
  609.                         printf("MF Desire");
  610.                 else
  611.                         printf("Unknown");
  612.                 if(PcdAnticoll(UID)==MI_OK)                        //防冲撞
  613.                 {
  614.                         printf("Card Id is:");
  615.                         /* 获取卡值  */
  616.                         Uart1_SendHexDisplay(UID[0]);
  617.                         Uart1_SendHexDisplay(UID[1]);
  618.                         Uart1_SendHexDisplay(UID[2]);
  619.                         Uart1_SendHexDisplay(UID[3]);
  620.                         printf("\r\n");                //发送换行指令
  621.                         temp_value = ((UID[0]>>4)*10+(UID[0]&0x0f));
  622.                         printf("管理员:%d\r\n",temp_value);
  623. //                        switch(temp_value)
  624. //                        {
  625. //                                case 12 : printf("管理员:%d\r\n",temp_value);    break;
  626. //                                case 152: printf("学生  :%d\r\n",temp_value);    break;
  627. //                                default : printf("无效卡:%d\r\n",temp_value);    break;
  628. //                        }                                    
  629.                 }
  630.   }
  631. }
复制代码
全部程序51hei下载地址：
RFID_RC522.7z (195.99 KB, 下载次数: 394)

评分

参与人数 2黑币 +65 收起 理由
杀死比亚 + 15 很给力！
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:218113 发表于 2021-1-27 14:54 | 显示全部楼层
感谢老铁，资料非常好。谢谢了
回复

使用道具 举报

ID:210139 发表于 2021-2-7 10:59 | 显示全部楼层
很不错，在网上很少有直接移植，就能成功程序，楼主的很不错，烧录好以后就能直接用
回复

使用道具 举报

ID:884825 发表于 2021-2-19 10:10 | 显示全部楼层
太感谢了，驱动移植很方便
回复

使用道具 举报

ID:890184 发表于 2021-4-27 01:22 | 显示全部楼层
楼主您好，我怎么找不到Uart1_SendHexDisplay这个函数的定义。您能告诉我吗？
回复

使用道具 举报

ID:933937 发表于 2022-3-24 15:09 | 显示全部楼层
我想知道实物实现需要买什么硬件，或者说识别模块
回复

使用道具 举报

ID:528966 发表于 2022-10-18 13:49 | 显示全部楼层
楼主的很不错，烧录好以后就能直接用
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表