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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › MFRC522单片机驱动源码 IO模拟spi接口 调试通过能正常读 ...
返回列表 发新帖
查看: 5694|回复: 2
收起左侧

MFRC522单片机驱动源码 IO模拟spi接口 调试通过能正常读到M1卡

[复制链接]
ID:198609 发表于 2017-5-9 14:18 | 显示全部楼层 |阅读模式
调试通过的RC522驱动源码，使用IO模拟spi接口。测试后能正常读到M1卡
0.png

单片机源程序：
  1. #include "MFRC522.h"
  2. #include "nrf_delay.h"
  3. #include "nrf_gpio.h"
  4. #include <stdint.h>
  5. #include <string.h>
  6. #include <stdio.h>
  7. //#include "simple_uart.h"
  8. extern uint32_t *p_spi_base_address;
  9. typedef  uint8_t u8;
  10. typedef  uint16_t u16;
  11. #define _MFRC_SOFT_SPI
  12. #define Set_MFRC_CS(x)                x ? nrf_gpio_pin_set(SPI_PSELSS0):nrf_gpio_pin_clear(SPI_PSELSS0)
  13. #define Set_MFRC_SCK(x)        x ? nrf_gpio_pin_set(SPI_PSELSCK0):nrf_gpio_pin_clear(SPI_PSELSCK0)
  14. #define Set_MFRC_MOSI(x)        x ? nrf_gpio_pin_set(SPI_PSELMOSI0):nrf_gpio_pin_clear(SPI_PSELMOSI0)
  15. #define MFRC_MISO_STATUS()        nrf_gpio_pin_read(SPI_PSELMISO0)
  16. //#define Set_MFRC_RST(x)                x ? HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_SET):HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_RESET);

  18. void MFRC_Delay(u16 Delay_Time)
  19. {
  20.   u16 i, j;
  21.   for (i = 40; i > 0; i--)
  22.   {
  23.     for (j = Delay_Time; j > 0; j--);
  24.   }
  25. }
  26. #ifndef _MFRC_SOFT_SPI  
  27. void SPI_TxByte(u8 Dat)
  28. {
  29.         uint8_t state;
  30.         state = spi_master_tx(p_spi_base_address, Dat);          
  31.         if(state != true)
  32.                 state = true;
  33. }

  35. u8 SPI_RxByte(void)
  36. {
  37.         uint8_t state;
  38.   state = spi_master_rx(p_spi_base_address) ;
  39.   return state;                             
  40. }
  41. #endif
  42. /*
  43. /////////////////////////////////////////////////////////////////////
  44. //?    ?:?RC632???
  45. //????:Address[IN]:?????
  46. //?    ?:????
  47. /////////////////////////////////////////////////////////////////////
  48. unsigned char ReadRawRC(unsigned char Address)
  49. {
  50.     unsigned char ucResult=0;
  51.                 uint8_t ucAddr;
  52.                 uint8_t tx_data[2]={0x00,0x00};
  53.                 uint8_t rx_data[2]={0x00,0x00};
  54.                 ucAddr = ((Address << 1) & 0x7E) | 0x80;
  55.                 tx_data[0] = ucAddr;
  56.                 spi_master_tx_rx(p_spi_base_address, 1, tx_data, rx_data);
  57.                 ucResult = rx_data[0];
  58.     return ucResult;
  59. }

  61. /////////////////////////////////////////////////////////////////////
  62. //?    ?:?RC632???
  63. //????:Address[IN]:?????
  64. //          value[IN]:????
  65. /////////////////////////////////////////////////////////////////////
  66. void WriteRawRC(unsigned char Address, unsigned char value)
  67. {  
  68.                 uint8_t tx_data[2]={0x00,0x00};
  69.                 uint8_t rx_data[2]={0x00,0x00};
  70.                 uint8_t ucAddr;
  71.                 ucAddr = ((Address << 1) & 0x7E);
  72.                 tx_data[0] = ucAddr;
  73.                 tx_data[1] = value;
  74.                 spi_master_tx_rx(p_spi_base_address, 2, tx_data, rx_data);
  75. }*/

  77. /////////////////////////////////////////////////////////////////////
  78. //功    能：读RC632寄存器
  79. //参数说明：Address[IN]:寄存器地址
  80. //返    回：读出的值
  81. /////////////////////////////////////////////////////////////////////
  82. static u8 ReadRawRC(u8 Address)
  83. {
  84.   u8 ucAddr;
  85.   u8 ret = 0;
  86. #ifdef _MFRC_SOFT_SPI
  87.   u8 i;
  88.   Set_MFRC_SCK(0);
  89. #endif  
  90.   
  91.   Set_MFRC_CS(0);

  93.   ucAddr = ((Address << 1) & 0x7E) | 0x80;
  94. #ifdef _MFRC_SOFT_SPI  
  95.   for(i=8; i>0; i--)
  96.   {
  97.     Set_MFRC_MOSI((ucAddr & 0x80) == 0x80);
  98.     Set_MFRC_SCK(1);
  99.     ucAddr <<= 1;
  100.     Set_MFRC_SCK(0);
  101.   }

  103.   for(i=8; i>0; i--)
  104.   {
  105.     Set_MFRC_SCK(1);
  106.     ret <<= 1;
  107.     ret |= MFRC_MISO_STATUS();
  108.     Set_MFRC_SCK(0);
  109.   }
  110. #else
  111.   SPI_TxByte(ucAddr);
  112.   ret = SPI_RxByte();
  113.        
  114. #endif
  115.   Set_MFRC_CS(1);
  116. #ifdef _MFRC_SOFT_SPI
  117.   Set_MFRC_SCK(1);
  118. #endif
  119.         printf("REG ADDR:0x%x  Val: 0x%02x\r\n",Address,ret);
  120.   return ret;
  121. }

  123. /////////////////////////////////////////////////////////////////////
  124. //功    能：写RC632寄存器
  125. //参数说明：Address[IN]:寄存器地址
  126. //          value[IN]:写入的值
  127. /////////////////////////////////////////////////////////////////////
  128. void WriteRawRC(u8 Address, u8 value)
  129. {
  130.   u8 ucAddr;
  131. #ifdef _MFRC_SOFT_SPI
  132.   u8 i;
  133.   Set_MFRC_SCK(0);
  134. #endif
  135.   Set_MFRC_CS(0);

  137.   ucAddr = ((Address << 1) & 0x7E);
  138. #ifdef _MFRC_SOFT_SPI
  139.         printf("---write---REG ADDR:0x%x  Val: 0x%02x\r\n",Address,value);
  140.   for(i=8; i>0; i--)
  141.   {
  142.     Set_MFRC_MOSI((ucAddr & 0x80) == 0x80);
  143.     Set_MFRC_SCK(1);
  144.     ucAddr <<= 1;
  145.     Set_MFRC_SCK(0);
  146.   }

  148.   for(i=8; i>0; i--)
  149.   {
  150.     Set_MFRC_MOSI((value & 0x80) == 0x80);
  151.     Set_MFRC_SCK(1);
  152.     value <<= 1;
  153.     Set_MFRC_SCK(0);
  154.   }
  155. #else
  156.   SPI_TxByte(ucAddr);
  157.   SPI_TxByte(value);
  158.         printf("---write---REG ADDR:0x%x  Val: 0x%x\r\n",Address,value);
  159. #endif
  160.   Set_MFRC_CS(1);
  161. #ifdef _MFRC_SOFT_SPI
  162.   Set_MFRC_SCK(1);
  163. #endif
  164.        
  165. }

  167. /////////////////////////////////////////////////////////////////////
  168. //功    能：清RC522寄存器位
  169. //参数说明：reg[IN]:寄存器地址
  170. //          mask[IN]:清位值
  171. /////////////////////////////////////////////////////////////////////
  172. static void ClearBitMask(u8 reg, u8 mask)
  173. {
  174.         u8 tmp = 0x0;
  175.         tmp = ReadRawRC(reg);
  176.         WriteRawRC(reg, tmp & ~mask);  // clear bit mask
  177. }

  179. /////////////////////////////////////////////////////////////////////
  180. //功    能：置RC522寄存器位
  181. //参数说明：reg[IN]:寄存器地址
  182. //          mask[IN]:置位值
  183. /////////////////////////////////////////////////////////////////////
  184. static void SetBitMask(u8 reg, u8 mask)
  185. {
  186.         u8 tmp = 0x0;
  187.         tmp = ReadRawRC(reg);
  188.         WriteRawRC(reg, tmp | mask);  // set bit mask
  189. }


  192. //开启天线  
  193. //每次启动或关闭天险发射之间应至少有1ms的间隔
  194. void PcdAntennaOn(void)
  195. {
  196.         u8 i;
  197.         i = ReadRawRC(TxControlReg);
  198.         if (!(i & 0x03))
  199.         {
  200.                 SetBitMask(TxControlReg, 0x03);
  201.         }
  202. }

  204. //关闭天线
  205. void PcdAntennaOff(void)
  206. {
  207.         ClearBitMask(TxControlReg, 0x03);
  208. }

  210. /////////////////////////////////////////////////////////////////////
  211. //功    能：通过RC522和ISO14443卡通讯
  212. //参数说明：Command[IN]:RC522命令字
  213. //          pIn [IN]:通过RC522发送到卡片的数据
  214. //          InLenByte[IN]:发送数据的字节长度
  215. //          pOut [OUT]:接收到的卡片返回数据
  216. //          *pOutLenBit[OUT]:返回数据的位长度
  217. /////////////////////////////////////////////////////////////////////
  218. #define MAXRLEN                       18
  219. static char PcdComMF522(unsigned char Command,
  220.                  unsigned char *pInData,
  221.                  unsigned char InLenByte,
  222.                  unsigned char *pOutData,
  223.                  unsigned int  *pOutLenBit)
  224. {
  225.         char status = MI_ERR;
  226.         unsigned char irqEn   = 0x00;
  227.         unsigned char waitFor = 0x00;
  228.         unsigned char lastBits;
  229.         unsigned char n;
  230.         unsigned int i;

  232.         switch (Command)
  233.         {
  234.         case PCD_AUTHENT:
  235.                 irqEn = 0x12;
  236.                 waitFor = 0x10;
  237.                 break;
  238.         case PCD_TRANSCEIVE:
  239.                 irqEn = 0x77;
  240.                 waitFor = 0x30;
  241.                 break;
  242.         default:
  243.                 break;
  244.         }

  246.         WriteRawRC(ComIEnReg, irqEn | 0x80);
  247.         ClearBitMask(ComIrqReg, 0x80);
  248.         WriteRawRC(CommandReg, PCD_IDLE);
  249.         SetBitMask(FIFOLevelReg, 0x80);

  251.         for (i = 0; i < InLenByte; i++)
  252.         {
  253.                 WriteRawRC(FIFODataReg, pInData[i]);
  254.         }
  255.         WriteRawRC(CommandReg, Command);

  257.         if (Command == PCD_TRANSCEIVE)
  258.         {
  259.                 SetBitMask(BitFramingReg, 0x80);
  260.         }

  262.         i = 3000;//800;
  263.         do
  264.         {
  265.                 n = ReadRawRC(ComIrqReg);
  266.                 i--;
  267.         } while ((i != 0) && !(n & 0x01) && !(n & waitFor));
  268.         ClearBitMask(BitFramingReg, 0x80);

  270.         if (i != 0)
  271.         {
  272.                 if (!(ReadRawRC(ErrorReg) & 0x1B))
  273.                 {
  274.                         status = MI_OK;
  275.                         if (n & irqEn & 0x01)
  276.                         {
  277.                                 status = MI_NOTAGERR;
  278.                         }
  279.                         if (Command == PCD_TRANSCEIVE)
  280.                         {
  281.                                 n = ReadRawRC(FIFOLevelReg);
  282.                                 lastBits = ReadRawRC(ControlReg) & 0x07;
  283.                                 if (lastBits)
  284.                                 {
  285.                                         *pOutLenBit = (n - 1) * 8 + lastBits;
  286.                                 }
  287.                                 else
  288.                                 {
  289.                                         *pOutLenBit = n * 8;
  290.                                 }
  291.                                 if (n == 0)
  292.                                 {
  293.                                         n = 1;
  294.                                 }
  295.                                 if (n > MAXRLEN)
  296.                                 {
  297.                                         n = MAXRLEN;
  298.                                 }
  299.                                 for (i = 0; i < n; i++)
  300.                                 {
  301.                                         pOutData[i] = ReadRawRC(FIFODataReg);
  302.                                 }
  303.                         }
  304.                 }
  305.                 else
  306.                 {
  307.                         status = MI_ERR;
  308.                 }
  309.         }
  310.         SetBitMask(ControlReg, 0x80);           // stop timer now
  311.         WriteRawRC(CommandReg, PCD_IDLE);
  312.         return status;
  313. }


  316. /////////////////////////////////////////////////////////////////////
  317. //功    能：复位RC522
  318. //返    回: 成功返回MI_OK
  319. /////////////////////////////////////////////////////////////////////
  320. char PcdReset(void)
  321. {
  322.         nrf_gpio_pin_set(SPI_RST);
  323.         MFRC_Delay(10);  
  324.         nrf_gpio_pin_clear(SPI_RST);
  325.         MFRC_Delay(60000);  
  326.         nrf_gpio_pin_set(SPI_RST);
  327.         MFRC_Delay(500);  
  328.         WriteRawRC(CommandReg, PCD_RESETPHASE);
  329.         MFRC_Delay(2000);  

  331.         WriteRawRC(ModeReg, 0x3D);            
  332.         WriteRawRC(TReloadRegL, 30);            
  333.         WriteRawRC(TReloadRegH, 0);
  334.         WriteRawRC(TModeReg, 0x8D);
  335.         WriteRawRC(TPrescalerReg, 0x3E);
  336.         WriteRawRC(TxAutoReg, 0x40);
  337.        
  338.         ClearBitMask(TestPinEnReg, 0x80);         //off MX and DTRQ out
  339.         WriteRawRC(TxAutoReg, 0x40);

  341.         return MI_OK;
  342. }       

  344. /////////////////////////////////////////////////////////////////////
  345. //用MF522计算CRC16函数
  346. /////////////////////////////////////////////////////////////////////
  347. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
  348. {
  349.     unsigned char i,n;
  350.        
  351.     ClearBitMask(DivIrqReg,0x04);
  352.     WriteRawRC(CommandReg,PCD_IDLE);
  353.     SetBitMask(FIFOLevelReg,0x80);
  354.     for (i=0; i<len; i++)
  355.     {   
  356.         WriteRawRC(FIFODataReg, *(pIndata+i));  
  357.     }
  358.     WriteRawRC(CommandReg, PCD_CALCCRC);
  359.     i = 0xFF;
  360.     do
  361.     {
  362.         n = ReadRawRC(DivIrqReg);
  363.         i--;
  364.     }
  365.     while ((i!=0) && !(n&0x04));
  366.     pOutData[0] = ReadRawRC(CRCResultRegL);
  367.     pOutData[1] = ReadRawRC(CRCResultRegM);
  368. }


  371. //////////////////////////////////////////////////////////////////////
  372. //设置RC522的工作方式
  373. //////////////////////////////////////////////////////////////////////
  374. signed char M500PcdConfigISOType(unsigned char type)
  375. {
  376.   if('A' == type)
  377.   {
  378.     ClearBitMask(Status2Reg,0x08);
  379.     WriteRawRC(ModeReg,0x3D);
  380.     WriteRawRC(RxSelReg,0x86);
  381.     WriteRawRC(RFCfgReg,0x7F);   
  382.     WriteRawRC(TReloadRegL,30);
  383.     WriteRawRC(TReloadRegH,0);
  384.     WriteRawRC(TModeReg,0x8D);
  385.     WriteRawRC(TPrescalerReg,0x3E);
  386.     MFRC_Delay(10000);
  387.     PcdAntennaOn();
  388.   }
  389.   else
  390.   {
  391.     return -1;
  392.   }
  393.        
  394.   return MI_OK;
  395. }

  397. /***
  398. 初始化RC522
  399. */

  401. void MFRC522_Init(void)
  402. {
  403. //  MFRC_GPIOConfigure();
  404.        
  405.   PcdReset();
  406.   PcdAntennaOff();
  407.   MFRC_Delay(2000);
  408.   PcdAntennaOn();
  409.   M500PcdConfigISOType('A');
  410. }

  412. /////////////////////////////////////////////////////////////////////
  413. //功    能：寻卡
  414. //参数说明: req_code[IN]:寻卡方式
  415. //                0x52 = 寻感应区内所有符合14443A标准的卡
  416. //                0x26 = 寻未进入休眠状态的卡
  417. //          pTagType[OUT]：卡片类型代码
  418. //                0x4400 = Mifare_UltraLight
  419. //                0x0400 = Mifare_One(S50)
  420. //                0x0200 = Mifare_One(S70)
  421. //                0x0800 = Mifare_Pro(X)
  422. //                0x4403 = Mifare_DESFire
  423. //返    回: 成功返回MI_OK
  424. /////////////////////////////////////////////////////////////////////
  425. char PcdRequest(u8 req_code, u8 *pTagType)
  426. {
  427.   char status;  
  428.         unsigned int  unLen;
  429.         unsigned char ucComMF522Buf[MAXRLEN];

  431.         ClearBitMask(Status2Reg, 0x08);
  432.         WriteRawRC(BitFramingReg, 0x07);
  433.         SetBitMask(TxControlReg, 0x03);
  434. //   
  435.         ucComMF522Buf[0] = req_code;

  437.         status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 1, ucComMF522Buf,
  438.                         &unLen);
  439. //   UART_send_byte(status);
  440.         if ((status == MI_OK) && (unLen == 0x10))
  441.         {
  442.                 *pTagType = ucComMF522Buf[0];
  443.                 *(pTagType + 1) = ucComMF522Buf[1];
  444.         }
  445.         else
  446.         {
  447.           status = MI_ERR;
  448.         }

  450.         return status;
  451. }


  454. /////////////////////////////////////////////////////////////////////
  455. //功    能：防冲撞
  456. //参数说明: pSnr[OUT]:卡片序列号，4字节
  457. //返    回: 成功返回MI_OK
  458. /////////////////////////////////////////////////////////////////////  
  459. char PcdAnticoll(unsigned char *pSnr)
  460. {
  461.     char status;
  462.     unsigned char i,snr_check=0;
  463.     unsigned int  unLen;
  464.     unsigned char ucComMF522Buf[MAXRLEN];
  465.    

  467.     ClearBitMask(Status2Reg,0x08);
  468.     WriteRawRC(BitFramingReg,0x00);
  469.     ClearBitMask(CollReg,0x80);

  471.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  472.     ucComMF522Buf[1] = 0x20;

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

  476.     if (status == MI_OK)
  477.     {
  478.              for (i=0; i<4; i++)
  479.          {   
  480.              *(pSnr+i)  = ucComMF522Buf[i];
  481.              snr_check ^= ucComMF522Buf[i];
  482.          }
  483.          if (snr_check != ucComMF522Buf[i])
  484.          {   status = MI_ERR;    }
  485.     }
  486.    
  487.     SetBitMask(CollReg,0x80);
  488.     return status;
  489. }

  491. /////////////////////////////////////////////////////////////////////
  492. //功    能：选定卡片
  493. //参数说明: pSnr[IN]:卡片序列号，4字节
  494. //返    回: 成功返回MI_OK
  495. /////////////////////////////////////////////////////////////////////
  496. char PcdSelect(unsigned char *pSnr)
  497. {
  498.     char status;
  499.     unsigned char i;
  500.     unsigned int  unLen;
  501.     unsigned char ucComMF522Buf[MAXRLEN];
  502.    
  503.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  504.     ucComMF522Buf[1] = 0x70;
  505.     ucComMF522Buf[6] = 0;
  506.     for (i=0; i<4; i++)
  507.     {
  508.             ucComMF522Buf[i+2] = *(pSnr+i);
  509.             ucComMF522Buf[6]  ^= *(pSnr+i);
  510.     }
  511.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
  512.   
  513.     ClearBitMask(Status2Reg,0x08);

  515.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
  516.    
  517.     if ((status == MI_OK) && (unLen == 0x18))
  518.     {   status = MI_OK;  }
  519.     else
  520.     {   status = MI_ERR;    }

  522.     return status;
  523. }

  525. /////////////////////////////////////////////////////////////////////
  526. //功    能：命令卡片进入休眠状态
  527. //返    回: 成功返回MI_OK
  528. /////////////////////////////////////////////////////////////////////
  529. char PcdHalt(void)
  530. {
  531. //    int status;
  532.     unsigned int  unLen;
  533.     unsigned char ucComMF522Buf[MAXRLEN];

  535.     ucComMF522Buf[0] = PICC_HALT;
  536.     ucComMF522Buf[1] = 0;
  537.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  539.     //status =
  540.     PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  542.     return MI_OK;
  543. }

  545. /////////////////////////////////////////////////////////////////////
  546. //功    能：验证卡片密码
  547. //参数说明: auth_mode[IN]: 密码验证模式
  548. //                 0x60 = 验证A密钥
  549. //                 0x61 = 验证B密钥
  550. //          addr[IN]：块地址
  551. //          pKey[IN]：密码
  552. //          pSnr[IN]：卡片序列号，4字节
  553. //返    回: 成功返回MI_OK
  554. /////////////////////////////////////////////////////////////////////               
  555. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
  556. {
  557.     char status;
  558.     unsigned int  unLen;
  559.     unsigned char i,ucComMF522Buf[MAXRLEN];

  561.     ucComMF522Buf[0] = auth_mode;
  562.     ucComMF522Buf[1] = addr;
  563.     for (i=0; i<6; i++)
  564.     {    ucComMF522Buf[i+2] = *(pKey+i);   }
  565.     for (i=0; i<6; i++)
  566.     {    ucComMF522Buf[i+8] = *(pSnr+i);   }
  567. //   memcpy(&ucComMF522Buf[2], pKey, 6);
  568. //   memcpy(&ucComMF522Buf[8], pSnr, 4);
  569.    
  570.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
  571.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
  572.     {   status = MI_ERR;   }
  573.    
  574.     return status;
  575. }

  577. /////////////////////////////////////////////////////////////////////
  578. //功    能：读取M1卡一块数据
  579. //参数说明: addr[IN]：块地址
  580. //          pData[OUT]：读出的数据，16字节
  581. //返    回: 成功返回MI_OK
  582. /////////////////////////////////////////////////////////////////////
  583. char PcdRead(unsigned char addr,unsigned char *pData)
  584. {
  585.     char status;
  586.     unsigned int  unLen;
  587.     unsigned char i,ucComMF522Buf[MAXRLEN];

  589.     ucComMF522Buf[0] = PICC_READ;
  590.     ucComMF522Buf[1] = addr;
  591.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  592.    
  593.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
  594.     if ((status == MI_OK) && (unLen == 0x90))
  595. //   {   memcpy(pData, ucComMF522Buf, 16);   }
  596.     {
  597.         for (i=0; i<16; i++)
  598.         {    *(pData+i) = ucComMF522Buf[i];   }
  599.     }
  600.     else
  601.     {   status = MI_ERR;   }
  602.    
  603.     return status;
  604. }

  606. /////////////////////////////////////////////////////////////////////
  607. //功    能：写数据到M1卡一块
  608. //参数说明: addr[IN]：块地址
  609. //          pData[IN]：写入的数据，16字节
  610. //返    回: 成功返回MI_OK
  611. /////////////////////////////////////////////////////////////////////                  
  612. char PcdWrite(unsigned char addr,unsigned char *pData)
  613. {
  614.     char status;
  615.     unsigned int  unLen;
  616.     unsigned char i,ucComMF522Buf[MAXRLEN];
  617.    
  618.     ucComMF522Buf[0] = PICC_WRITE;
  619.     ucComMF522Buf[1] = addr;
  620.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  622.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  624.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  625.     {   status = MI_ERR;   }
  626.         
  627.     if (status == MI_OK)
  628.     {
  629.         //memcpy(ucComMF522Buf, pData, 16);
  630.         for (i=0; i<16; i++)
  631.         {    ucComMF522Buf[i] = *(pData+i);   }
  632.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);

  634.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
  635.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  636.         {   status = MI_ERR;   }
  637.     }
  638.    
  639.     return status;
  640. }

  642. /////////////////////////////////////////////////////////////////////
  643. //功    能：扣款和充值
  644. //参数说明: dd_mode[IN]：命令字
  645. //               0xC0 = 扣款
  646. //               0xC1 = 充值
  647. //          addr[IN]：钱包地址
  648. //          pValue[IN]：4字节增(减)值，低位在前
  649. //返    回: 成功返回MI_OK
  650. /////////////////////////////////////////////////////////////////////                 
  651. char PcdValue(unsigned char dd_mode,unsigned char addr,unsigned char *pValue)
  652. {
  653.     char status;
  654.     unsigned int  unLen;
  655.     unsigned char ucComMF522Buf[MAXRLEN];
  656.    
  657.     ucComMF522Buf[0] = dd_mode;
  658.     ucComMF522Buf[1] = addr;
  659.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  661.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  663.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  664.     {   status = MI_ERR;   }
  665.         
  666.     if (status == MI_OK)
  667.     {
  668.         memcpy(ucComMF522Buf, pValue, 4);
  669. //       for (i=0; i<16; i++)
  670. //       {    ucComMF522Buf[i] = *(pValue+i);   }
  671.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
  672.         unLen = 0;
  673.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
  674.         if (status != MI_ERR)
  675.         {    status = MI_OK;    }
  676.     }
  677.    
  678.     if (status == MI_OK)
  679.     {
  680.         ucComMF522Buf[0] = PICC_TRANSFER;
  681.         ucComMF522Buf[1] = addr;
  682.         CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  683.    
  684.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  686.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  687.         {   status = MI_ERR;   }
  688.     }
  689.     return status;
  690. }

  692. /////////////////////////////////////////////////////////////////////
  693. //功    能：备份钱包
  694. //参数说明: sourceaddr[IN]：源地址
  695. //          goaladdr[IN]：目标地址
  696. //返    回: 成功返回MI_OK
  697. /////////////////////////////////////////////////////////////////////
  698. char PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr)
  699. {
  700.     char status;
  701.     unsigned int  unLen;
  702.     unsigned char ucComMF522Buf[MAXRLEN];

  704.     ucComMF522Buf[0] = PICC_RESTORE;
  705.     ucComMF522Buf[1] = sourceaddr;
  706.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  708.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  710.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  711.     {   status = MI_ERR;   }
  712.    
  713.     if (status == MI_OK)
  714.     {
  715.         ucComMF522Buf[0] = 0;
  716.         ucComMF522Buf[1] = 0;
  717.         ucComMF522Buf[2] = 0;
  718.         ucComMF522Buf[3] = 0;
  719.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);

  721.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
  722.         if (status != MI_ERR)
  723.         {    status = MI_OK;    }
  724.     }


  727. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

完整代码下载：
MFRC522.zip (5.95 KB, 下载次数: 81)
回复

使用道具 举报

ID:272419 发表于 2018-4-23 19:28 | 显示全部楼层
谢谢分享！
回复

使用道具 举报

ID:336475 发表于 2020-4-26 17:37 | 显示全部楼层
谢谢分享！
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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