21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › STM32F407——RC522（模拟SPI）
返回列表 发新帖我要提问

[STM32F4] STM32F407——RC522（模拟SPI）

[复制链接]
 楼主| 无法去污粉 发表于 2022-12-25 13:40 | 显示全部楼层 |阅读模式
RC522, ST, STM, STM32, STM32F

1.引脚连接

MISO——PA6

MOSI——PA7

SCK——PA5

NSS——PA4

RST——PA8

IRQ悬空不接引脚

2.GPIO配置

MISO配置成浮空输入，其余的配置出推挽输出

  • 复制
    1. #include "bsp_spi.h"
      

    2.  
      

    3.  
      

    4. static void RC522_SPI_Config(void);
      

    5.  
      

    6.  
      

    7.  
      

    8. void RC522_Init ( void )
      

    9. {
      

    10.         
      

    11.         RC522_SPI_Config ();        
      

    12.         RC522_Reset_Disable();        
      

    13.         RC522_CS_Disable();
      

    14.         
      

    15. }
      

    16.  
      

    17.  
      

    18.  /**
      

    19.   * [url=home.php?mod=space&uid=247401]@brief[/url]  模拟软件SPI初始化
      

    20.   * @param  无
      

    21.   * @retval 无
      

    22.   */
      

    23.         
      

    24. static void RC522_SPI_Config(void)
      

    25. {
      

    26.   GPIO_InitTypeDef GPIO_InitStructure;
      

    27.   
      

    28.   //使能GPIO时钟
      

    29.         RCC_AHB1PeriphClockCmd (RCC_AHB1Periph_GPIOA, ENABLE);
      

    30.         
      

    31.  
      

    32.         //MISO
      

    33.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
      

    34.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; //输入
      

    35.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;  //浮空：无上拉和下拉
      

    36.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      

    37.         GPIO_Init(GPIOA, &GPIO_InitStructure);
      

    38.                 
      

    39.         //MOSI
      

    40.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
      

    41.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
      

    42.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      

    43.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      

    44.         GPIO_Init(GPIOA, &GPIO_InitStructure);
      

    45.         
      

    46.         //SCK
      

    47.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
      

    48.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
      

    49.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      

    50.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      

    51.   GPIO_Init(GPIOA, &GPIO_InitStructure);
      

    52.  
      

    53.  
      

    54.         //NSS
      

    55.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
      

    56.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
      

    57.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      

    58.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      

    59.   GPIO_Init(GPIOA, &GPIO_InitStructure);
      

    60.         
      

    61.         //RST
      

    62.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
      

    63.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
      

    64.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      

    65.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      

    66.   GPIO_Init(GPIOA, &GPIO_InitStructure);
      

    67.  
      

    68.  
      

    69. }





回复 赏

举报

评论

无法去污粉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/weixin_47316662/article/details/124555292 ———————————————— 版权声明：本文为CSDN博主「半透明的橙子i」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/weixin_47316662/arti  发表于 2022-12-25 13:43

相关帖子
 楼主| 无法去污粉 发表于 2022-12-25 13:44 | 显示全部楼层
接发数据

数据由  MISO端口——>RC522寄存器,MOSI端口<——RC522寄存器

软件SPI通过控制MISO引脚和MOSI端口引脚的高低电平来控制数据的进出，下面读取和写入寄存器的函数都是靠这两个函数来接收和发送数据与外界
6736563a7e347b7f8f.png
回复 赏

举报

 楼主| 无法去污粉 发表于 2022-12-25 13:45 | 显示全部楼层
查数据手册得RC552采用模式3，上图为模式3的时序图，根据时序图写发送数据，共有8个时钟周期，所以循环8次， 按位查询需要发送的数据的高低电平，0将MOSI引输出低电平，1将MOSI输出高电平，然后调SCK时钟引脚，使时钟引脚输出低电平（默认状态高电平），延时一会，输出高电平，
回复 赏

举报

 楼主| 无法去污粉 发表于 2022-12-25 13:46 | 显示全部楼层
复制
  1. void SPI_RC522_SendByte ( uint8_t byte )
    

  2. {
    

  3.   uint8_t counter;
    

  4.  
    

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

  6.   {     
    

  7.     if ( byte & 0x80 )
    

  8.       RC522_MOSI_1 ();
    

  9.     else 
    

  10.       RC522_MOSI_0 ();
    

  11.     
    

  12.     RC522_DELAY();
    

  13.     RC522_SCK_0 ();
    

  14.     
    

  15.     RC522_DELAY();
    

  16.     RC522_SCK_1();
    

  17.     
    

  18.     RC522_DELAY();
    

  19.     byte <<= 1; 
    

  20.   }         
    

  21. }
    

  22.  
    

  23.  
    

  24. /**
    

  25.   * @brief  从RC522发送1 Byte 数据
    

  26.   * @param  无
    

  27.   * @retval RC522返回的数据
    

  28.   */
    

  29. uint8_t SPI_RC522_ReadByte ( void )
    

  30. {
    

  31.   uint8_t counter;
    

  32.   uint8_t SPI_Data;
    

  33.  
    

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

  35.   {
    

  36.     SPI_Data <<= 1;
    

  37.     RC522_SCK_0 ();
    

  38.    
    

  39.     RC522_DELAY();
    

  40.     if ( RC522_MISO_GET() == 1)
    

  41.      SPI_Data |= 0x01;
    

  42.     
    

  43.     RC522_DELAY();
    

  44.     RC522_SCK_1 ();
    

  45.     
    

  46.     RC522_DELAY();
    

  47.   }
    

  48.   return SPI_Data;
    

  49.         
    

  50. }
回复 赏

举报

 楼主| 无法去污粉 发表于 2022-12-25 13:46 | 显示全部楼层
RC522官方函数

RC522.c

复制
  1. **
    

  2.   * @brief  读RC522寄存器
    

  3.   * @param  ucAddress，寄存器地址
    

  4.   * @retval 寄存器的当前值
    

  5.   */
    

  6. uint8_t ReadRawRC ( uint8_t ucAddress )
    

  7. {
    

  8.         uint8_t ucAddr, ucReturn;
    

  9.         
    

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

  11.         RC522_CS_Enable();
    

  12.   
    

  13.         SPI_RC522_SendByte ( ucAddr );
    

  14.         ucReturn = SPI_RC522_ReadByte ();
    

  15.   
    

  16.         RC522_CS_Disable();
    

  17.         
    

  18.         return ucReturn;        
    

  19. }
    

  20.  
    

  21. /**
    

  22.   * @brief  写RC522寄存器
    

  23.   * @param  ucAddress，寄存器地址
    

  24.   * @param  ucValue，写入寄存器的值
    

  25.   * @retval 无
    

  26.   */
    

  27. void WriteRawRC ( uint8_t ucAddress, uint8_t ucValue )
    

  28. {  
    

  29.         uint8_t ucAddr;
    

  30.         
    

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

  32.         RC522_CS_Enable();
    

  33.         
    

  34.         SPI_RC522_SendByte ( ucAddr );        
    

  35.         SPI_RC522_SendByte ( ucValue );
    

  36.   
    

  37.         RC522_CS_Disable();                
    

  38. }
    

  39.  
    

  40.  
    

  41. /**
    

  42.   * @brief  对RC522寄存器置位
    

  43.   * @param  ucReg，寄存器地址
    

  44.   * @param   ucMask，置位值
    

  45.   * @retval 无
    

  46.   */
    

  47. void SetBitMask ( uint8_t ucReg, uint8_t ucMask )  
    

  48. {
    

  49.   uint8_t ucTemp;
    

  50.  
    

  51.   ucTemp = ReadRawRC ( ucReg );
    

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

  53. }
    

  54.  
    

  55.  
    

  56. /**
    

  57.   * @brief  对RC522寄存器清位
    

  58.   * @param  ucReg，寄存器地址
    

  59.   * @param  ucMask，清位值
    

  60.   * @retval 无
    

  61.   */
    

  62. void ClearBitMask ( uint8_t ucReg, uint8_t ucMask )  
    

  63. {
    

  64.   uint8_t ucTemp;
    

  65.  
    

  66.   ucTemp = ReadRawRC ( ucReg );
    

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

  68. }
    

  69.  
    

  70.  
    

  71. /**
    

  72.   * @brief  开启天线 
    

  73.   * @param  无
    

  74.   * @retval 无
    

  75.   */
    

  76. void PcdAntennaOn ( void )
    

  77. {
    

  78.   uint8_t uc;
    

  79.  
    

  80.   uc = ReadRawRC ( TxControlReg );
    

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

  82.    SetBitMask(TxControlReg, 0x03);                
    

  83. }
    

  84.  
    

  85.  
    

  86. /**
    

  87.   * @brief  关闭天线
    

  88.   * @param  无
    

  89.   * @retval 无
    

  90.   */
    

  91. void PcdAntennaOff ( void )
    

  92. {
    

  93.   ClearBitMask ( TxControlReg, 0x03 );        
    

  94. }
    

  95.  
    

  96.  
    

  97. /**
    

  98.   * @brief  复位RC522 
    

  99.   * @param  无
    

  100.   * @retval 无
    

  101.   */
    

  102. void PcdReset ( void )
    

  103. {
    

  104.         RC522_Reset_Disable();
    

  105.         
    

  106.         Delay_us ( 1 );
    

  107.         
    

  108.         RC522_Reset_Enable();
    

  109.         Delay_us ( 1 );
    

  110.         
    

  111.         RC522_Reset_Disable();
    

  112.         Delay_us ( 1 );
    

  113.         
    

  114.         
    

  115.         WriteRawRC ( CommandReg, 0x0f );
    

  116.         
    

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

  118.         
    

  119.         Delay_us ( 1 );
    

  120.   
    

  121.         //定义发送和接收常用模式 和Mifare卡通讯，CRC初始值0x6363
    

  122.   WriteRawRC ( ModeReg, 0x3D );        
    

  123.         
    

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

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

  126.         
    

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

  128.         
    

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

  130.         
    

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

  132.         
    

  133. }
    

  134.  
    

  135.  
    

  136.  
    

  137. /**
    

  138.   * @brief  设置RC522的工作方式
    

  139.   * @param  ucType，工作方式
    

  140.   * @retval 无
    

  141.   */
    

  142. void M500PcdConfigISOType ( uint8_t ucType )
    

  143. {
    

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

  145.   {
    

  146.                 ClearBitMask ( Status2Reg, 0x08 );
    

  147.                 
    

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

  149.                 
    

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

  151.                 
    

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

  153.                 
    

  154.                 WriteRawRC( TReloadRegL, 30 );        
    

  155.                 
    

  156.                 WriteRawRC ( TReloadRegH, 0 );
    

  157.                 
    

  158.                 WriteRawRC ( TModeReg, 0x8D );
    

  159.                 
    

  160.                 WriteRawRC ( TPrescalerReg, 0x3E );
    

  161.                 
    

  162.                 Delay_us ( 2 );
    

  163.                 
    

  164.                 PcdAntennaOn ();//开天线
    

  165.                 
    

  166.    }         
    

  167. }
    

  168.  
    

  169.  
    

  170.  
    

  171. /**
    

  172.   * @brief  通过RC522和ISO14443卡通讯
    

  173.   * @param  ucCommand，RC522命令字
    

  174.   * @param  pInData，通过RC522发送到卡片的数据
    

  175.   * @param  ucInLenByte，发送数据的字节长度
    

  176.   * @param  pOutData，接收到的卡片返回数据
    

  177.   * @param  pOutLenBit，返回数据的位长度
    

  178.   * @retval 状态值= MI_OK，成功
    

  179.   */
    

  180. char PcdComMF522 ( uint8_t ucCommand,
    

  181.                    uint8_t * pInData, 
    

  182.                    uint8_t ucInLenByte, 
    

  183.                    uint8_t * pOutData,
    

  184.                    uint32_t * pOutLenBit )                
    

  185. {
    

  186.   char cStatus = MI_ERR;
    

  187.   uint8_t ucIrqEn   = 0x00;
    

  188.   uint8_t ucWaitFor = 0x00;
    

  189.   uint8_t ucLastBits;
    

  190.   uint8_t ucN;
    

  191.   uint32_t ul;
    

  192.  
    

  193.   switch ( ucCommand )
    

  194.   {
    

  195.      case PCD_AUTHENT:                  //Mifare认证
    

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

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

  198.         break;
    

  199.      
    

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

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

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

  203.         break;
    

  204.      
    

  205.      default:
    

  206.        break;     
    

  207.   }
    

  208.   //IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反 
    

  209.   WriteRawRC ( ComIEnReg, ucIrqEn | 0x80 );
    

  210.   //Set1该位清零时，CommIRqReg的屏蔽位清零
    

  211.   ClearBitMask ( ComIrqReg, 0x80 );         
    

  212.   //写空闲命令
    

  213.   WriteRawRC ( CommandReg, PCD_IDLE );                 
    

  214.   
    

  215.   //置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
    

  216.   SetBitMask ( FIFOLevelReg, 0x80 );                        
    

  217.  
    

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

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

  220.     
    

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

  222.  
    

  223.  
    

  224.   if ( ucCommand == PCD_TRANSCEIVE )
    

  225.     
    

  226.     //StartSend置位启动数据发送 该位与收发命令使用时才有效
    

  227.     SetBitMask(BitFramingReg,0x80);                                    
    

  228.  
    

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

  230.  
    

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

  232.   {
    

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

  234.        ul --;
    

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

  236.  
    

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

  238.  
    

  239.   if ( ul != 0 )
    

  240.   {
    

  241.     //读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
    

  242.     if ( ! ( ReadRawRC ( ErrorReg ) & 0x1B ) )        
    

  243.     {
    

  244.       cStatus = MI_OK;
    

  245.       
    

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

  247.         cStatus = MI_NOTAGERR;   
    

  248.         
    

  249.       if ( ucCommand == PCD_TRANSCEIVE )
    

  250.       {
    

  251.         //读FIFO中保存的字节数
    

  252.         ucN = ReadRawRC ( FIFOLevelReg );                          
    

  253.         
    

  254.         //最后接收到得字节的有效位数
    

  255.         ucLastBits = ReadRawRC ( ControlReg ) & 0x07;        
    

  256.         
    

  257.         if ( ucLastBits )
    

  258.           
    

  259.           //N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
    

  260.           * pOutLenBit = ( ucN - 1 ) * 8 + ucLastBits;           
    

  261.         else
    

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

  263.         
    

  264.         if ( ucN == 0 )                
    

  265.           ucN = 1;    
    

  266.         
    

  267.         if ( ucN > MAXRLEN )
    

  268.           ucN = MAXRLEN;   
    

  269.         
    

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

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

  272.         
    

  273.         }        
    

  274.     }   
    

  275.     else
    

  276.       cStatus = MI_ERR;       
    

  277.   }
    

  278.  
    

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

  280.   WriteRawRC ( CommandReg, PCD_IDLE ); 
    

  281.    
    

  282.   return cStatus;
    

  283. }
    

  284.  
    

  285. /**
    

  286.   * @brief 寻卡
    

  287.   * @param  ucReq_code，寻卡方式 = 0x52，寻感应区内所有符合14443A标准的卡；
    

  288.             寻卡方式= 0x26，寻未进入休眠状态的卡
    

  289.   * @param  pTagType，卡片类型代码
    

  290.              = 0x4400，Mifare_UltraLight
    

  291.              = 0x0400，Mifare_One(S50)
    

  292.              = 0x0200，Mifare_One(S70)
    

  293.              = 0x0800，Mifare_Pro(X))
    

  294.              = 0x4403，Mifare_DESFire
    

  295.   * @retval 状态值= MI_OK，成功
    

  296.   */
    

  297. char PcdRequest ( uint8_t ucReq_code, uint8_t * pTagType )
    

  298. {
    

  299.   char cStatus;  
    

  300.   uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  301.   uint32_t ulLen;
    

  302.  
    

  303.   //清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
    

  304.   ClearBitMask ( Status2Reg, 0x08 );
    

  305.         //发送的最后一个字节的 七位
    

  306.   WriteRawRC ( BitFramingReg, 0x07 );
    

  307.   //TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
    

  308.   SetBitMask ( TxControlReg, 0x03 );        
    

  309.  
    

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

  311.  
    

  312.   cStatus = PcdComMF522 ( PCD_TRANSCEIVE,        
    

  313.                           ucComMF522Buf,
    

  314.                           1, 
    

  315.                           ucComMF522Buf,
    

  316.                           & ulLen );        //寻卡  
    

  317.  
    

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

  319.   {    
    

  320.      * pTagType = ucComMF522Buf [ 0 ];
    

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

  322.   }
    

  323.  
    

  324.   else
    

  325.    cStatus = MI_ERR;
    

  326.  
    

  327.   return cStatus;         
    

  328. }
    

  329.  
    

  330. /**
    

  331.   * @brief  防冲撞
    

  332.   * @param  pSnr，卡片序列号，4字节
    

  333.   * @retval 状态值= MI_OK，成功
    

  334.   */
    

  335. char PcdAnticoll ( uint8_t * pSnr )
    

  336. {
    

  337.   char cStatus;
    

  338.   uint8_t uc, ucSnr_check = 0;
    

  339.   uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  340.   uint32_t ulLen;
    

  341.   
    

  342.   //清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
    

  343.   ClearBitMask ( Status2Reg, 0x08 );
    

  344.   //清理寄存器 停止收发
    

  345.   WriteRawRC ( BitFramingReg, 0x00);        
    

  346.         //清ValuesAfterColl所有接收的位在冲突后被清除
    

  347.   ClearBitMask ( CollReg, 0x80 );                          
    

  348.  
    

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

  350.   ucComMF522Buf [ 1 ] = 0x20;
    

  351.  
    

  352.   cStatus = PcdComMF522 ( PCD_TRANSCEIVE, 
    

  353.                           ucComMF522Buf,
    

  354.                           2, 
    

  355.                           ucComMF522Buf,
    

  356.                           & ulLen);      //与卡片通信
    

  357.  
    

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

  359.   {
    

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

  361.     {
    

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

  363.        ucSnr_check ^= ucComMF522Buf [ uc ];
    

  364.     }
    

  365.     
    

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

  367.       cStatus = MI_ERR;                                     
    

  368.   }
    

  369.   
    

  370.   SetBitMask ( CollReg, 0x80 );
    

  371.       
    

  372.   return cStatus;                
    

  373. }
    

  374.  
    

  375.  
    

  376. /**
    

  377.   * @brief  用RC522计算CRC16
    

  378.   * @param  pIndata，计算CRC16的数组
    

  379.   * @param  ucLen，计算CRC16的数组字节长度
    

  380.   * @param  pOutData，存放计算结果存放的首地址
    

  381.   * @retval 无
    

  382.   */
    

  383. void CalulateCRC ( uint8_t * pIndata, 
    

  384.                  uint8_t ucLen, 
    

  385.                  uint8_t * pOutData )
    

  386. {
    

  387.   uint8_t uc, ucN;
    

  388.  
    

  389.   ClearBitMask(DivIrqReg,0x04);
    

  390.  
    

  391.   WriteRawRC(CommandReg,PCD_IDLE);
    

  392.  
    

  393.   SetBitMask(FIFOLevelReg,0x80);
    

  394.  
    

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

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

  397.  
    

  398.   WriteRawRC ( CommandReg, PCD_CALCCRC );
    

  399.  
    

  400.   uc = 0xFF;
    

  401.  
    

  402.   do 
    

  403.   {
    

  404.       ucN = ReadRawRC ( DivIrqReg );
    

  405.       uc --;
    

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

  407.   
    

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

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

  410. }
    

  411.  
    

  412.  
    

  413. /**
    

  414.   * @brief  选定卡片
    

  415.   * @param  pSnr，卡片序列号，4字节
    

  416.   * @retval 状态值= MI_OK，成功
    

  417.   */
    

  418. char PcdSelect ( uint8_t * pSnr )
    

  419. {
    

  420.   char ucN;
    

  421.   uint8_t uc;
    

  422.   uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  423.   uint32_t  ulLen;
    

  424.   
    

  425.   
    

  426.   ucComMF522Buf [ 0 ] = PICC_ANTICOLL1;
    

  427.   ucComMF522Buf [ 1 ] = 0x70;
    

  428.   ucComMF522Buf [ 6 ] = 0;
    

  429.  
    

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

  431.   {
    

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

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

  434.   }
    

  435.   
    

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

  437.  
    

  438.   ClearBitMask ( Status2Reg, 0x08 );
    

  439.  
    

  440.   ucN = PcdComMF522 ( PCD_TRANSCEIVE,
    

  441.                      ucComMF522Buf,
    

  442.                      9,
    

  443.                      ucComMF522Buf, 
    

  444.                      & ulLen );
    

  445.   
    

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

  447.     ucN = MI_OK;  
    

  448.   else
    

  449.     ucN = MI_ERR;    
    

  450.   
    

  451.   return ucN;                
    

  452. }
    

  453.  
    

  454.  
    

  455.  
    

  456. /**
    

  457.   * @brief  验证卡片密码
    

  458.   * @param  ucAuth_mode，密码验证模式= 0x60，验证A密钥，
    

  459.             密码验证模式= 0x61，验证B密钥
    

  460.   * @param  uint8_t ucAddr，块地址
    

  461.   * @param  pKey，密码 
    

  462.   * @param  pSnr，卡片序列号，4字节
    

  463.   * @retval 状态值= MI_OK，成功
    

  464.   */
    

  465. char PcdAuthState ( uint8_t ucAuth_mode, 
    

  466.                     uint8_t ucAddr, 
    

  467.                     uint8_t * pKey,
    

  468.                     uint8_t * pSnr )
    

  469. {
    

  470.   char cStatus;
    

  471.   uint8_t uc, ucComMF522Buf [ MAXRLEN ];
    

  472.   uint32_t ulLen;
    

  473.   
    

  474.  
    

  475.   ucComMF522Buf [ 0 ] = ucAuth_mode;
    

  476.   ucComMF522Buf [ 1 ] = ucAddr;
    

  477.  
    

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

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

  480.  
    

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

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

  483.  
    

  484.   cStatus = PcdComMF522 ( PCD_AUTHENT,
    

  485.                           ucComMF522Buf, 
    

  486.                           12,
    

  487.                           ucComMF522Buf,
    

  488.                           & ulLen );
    

  489.  
    

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

  491.     cStatus = MI_ERR;   
    

  492.     
    

  493.   return cStatus;
    

  494. }
    

  495.  
    

  496.  
    

  497. /**
    

  498.   * @brief  写数据到M1卡一块
    

  499.   * @param  ucAddr，块地址（0-63）。M1卡总共有16个扇区(每个扇区有：3个数据块+1个控制块),共64个块
    

  500.   * @param  pData，写入的数据，16字节
    

  501.   * @retval 状态值= MI_OK，成功
    

  502.   */
    

  503. char PcdWrite ( uint8_t ucAddr, uint8_t * pData )
    

  504. {
    

  505.   char cStatus;
    

  506.   uint8_t uc, ucComMF522Buf [ MAXRLEN ];
    

  507.   uint32_t ulLen;
    

  508.    
    

  509.   
    

  510.   ucComMF522Buf [ 0 ] = PICC_WRITE;
    

  511.   ucComMF522Buf [ 1 ] = ucAddr;
    

  512.  
    

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

  514.  
    

  515.   cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
    

  516.                           ucComMF522Buf,
    

  517.                           4, 
    

  518.                           ucComMF522Buf,
    

  519.                           & ulLen );
    

  520.  
    

  521.   if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || 
    

  522.          ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
    

  523.     cStatus = MI_ERR;   
    

  524.       
    

  525.   if ( cStatus == MI_OK )
    

  526.   {
    

  527.     //memcpy(ucComMF522Buf, pData, 16);
    

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

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

  530.     
    

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

  532.  
    

  533.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
    

  534.                            ucComMF522Buf, 
    

  535.                            18, 
    

  536.                            ucComMF522Buf,
    

  537.                            & ulLen );
    

  538.     
    

  539.     if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || 
    

  540.          ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
    

  541.       cStatus = MI_ERR;   
    

  542.     
    

  543.   }         
    

  544.   return cStatus;                
    

  545. }
    

  546.  
    

  547.  
    

  548. /**
    

  549.   * @brief  读取M1卡一块数据
    

  550.   * @param  ucAddr，块地址（0-63）。M1卡总共有16个扇区(每个扇区有：3个数据块+1个控制块),共64个块
    

  551.   * @param  pData，读出的数据，16字节
    

  552.   * @retval 状态值= MI_OK，成功
    

  553.   */
    

  554. char PcdRead ( uint8_t ucAddr, uint8_t * pData )
    

  555. {
    

  556.   char cStatus;
    

  557.   uint8_t uc, ucComMF522Buf [ MAXRLEN ]; 
    

  558.   uint32_t ulLen;
    

  559.   
    

  560.   ucComMF522Buf [ 0 ] = PICC_READ;
    

  561.   ucComMF522Buf [ 1 ] = ucAddr;
    

  562.  
    

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

  564.  
    

  565.   cStatus = PcdComMF522 ( PCD_TRANSCEIVE,
    

  566.                           ucComMF522Buf,
    

  567.                           4, 
    

  568.                           ucComMF522Buf,
    

  569.                           & ulLen );
    

  570.  
    

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

  572.   {
    

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

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

  575.   }
    

  576.   
    

  577.   else
    

  578.     cStatus = MI_ERR;   
    

  579.    
    

  580.   return cStatus;                
    

  581. }
    

  582.  
    

  583.  
    

  584.  
    

  585. /**
    

  586.   * @brief  判断 ucAddr 是否数据块
    

  587.   * @param  ucAddr，块绝对地址（0-63）
    

  588.   * @retval 返回值 1:是数据块；0:不是数据块
    

  589.   */
    

  590. char IsDataBlock( uint8_t ucAddr )
    

  591. {
    

  592.   if(ucAddr == 0)
    

  593.   {
    

  594.     printf("第0扇区的块0不可更改,不应对其进行操作\r\n");
    

  595.     return 0;
    

  596.   }
    

  597.   /* 如果是数据块(不包含数据块0) */
    

  598.   if( (ucAddr<64) && (((ucAddr+1)%4) != 0) )
    

  599.   {
    

  600.     return 1;
    

  601.   }
    

  602.   
    

  603.   printf("块地址不是指向数据块\r\n");
    

  604.   return 0;
    

  605. }
    

  606.  
    

  607. /**
    

  608.   * @brief  写 pData 字符串到M1卡中的数据块
    

  609.   * @param  ucAddr，数据块地址（不能写入控制块）
    

  610.   * @param  pData，写入的数据，16字节
    

  611.   * @retval 状态值= MI_OK，成功
    

  612.   */
    

  613. char PcdWriteString ( uint8_t ucAddr, uint8_t * pData )
    

  614. {
    

  615.   /* 如果是数据块(不包含数据块0)，则写入 */
    

  616.   if( IsDataBlock(ucAddr) )
    

  617.   {
    

  618.     return PcdWrite(ucAddr, pData);
    

  619.   }
    

  620.  
    

  621.   return MI_ERR;
    

  622. }
    

  623.  
    

  624. /**
    

  625.   * @brief  读取M1卡中的一块数据到 pData
    

  626.   * @param  ucAddr，数据块地址（不读取控制块）
    

  627.   * @param  pData，读出的数据，16字节
    

  628.   * @retval 状态值= MI_OK，成功
    

  629.   */
    

  630. char PcdReadString ( uint8_t ucAddr, uint8_t * pData )
    

  631. {
    

  632.   /* 如果是数据块(不包含数据块0)，则读取 */
    

  633.   if( IsDataBlock(ucAddr) )
    

  634.   {
    

  635.     return PcdRead(ucAddr, pData);
    

  636.   }
    

  637.  
    

  638.   return MI_ERR;
    

  639. }
    

  640.  
    

  641.  
    

  642.  
    

  643. /**
    

  644.   * @brief  命令卡片进入休眠状态
    

  645.   * @param  无
    

  646.   * @retval 状态值= MI_OK，成功
    

  647.   */
    

  648. char PcdHalt( void )
    

  649. {
    

  650.         uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  651.         uint32_t  ulLen;
    

  652.   
    

  653.  
    

  654.   ucComMF522Buf [ 0 ] = PICC_HALT;
    

  655.   ucComMF522Buf [ 1 ] = 0;
    

  656.         
    

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

  658.          PcdComMF522 ( PCD_TRANSCEIVE,
    

  659.                 ucComMF522Buf,
    

  660.                 4, 
    

  661.                 ucComMF522Buf, 
    

  662.                 & ulLen );
    

  663.  
    

  664.   return MI_OK;        
    

  665. }
    

  666.  
    

  667. /
    

  668. //功    能：写入钱包金额
    

  669. //参数说明: ucAddr[IN]：块地址
    

  670. //          pData：写入的金额
    

  671. //返    回: 成功返回MI_OK
    

  672. /
    

  673. char WriteAmount( uint8_t ucAddr, uint32_t pData )
    

  674. {
    

  675.         char status;
    

  676.         uint8_t ucComMF522Buf[16];
    

  677.         ucComMF522Buf[0] = (pData&((uint32_t)0x000000ff));
    

  678.         ucComMF522Buf[1] = (pData&((uint32_t)0x0000ff00))>>8;
    

  679.         ucComMF522Buf[2] = (pData&((uint32_t)0x00ff0000))>>16;
    

  680.         ucComMF522Buf[3] = (pData&((uint32_t)0xff000000))>>24;        
    

  681.         
    

  682.         ucComMF522Buf[4] = ~(pData&((uint32_t)0x000000ff));
    

  683.         ucComMF522Buf[5] = ~(pData&((uint32_t)0x0000ff00))>>8;
    

  684.         ucComMF522Buf[6] = ~(pData&((uint32_t)0x00ff0000))>>16;
    

  685.         ucComMF522Buf[7] = ~(pData&((uint32_t)0xff000000))>>24;        
    

  686.         
    

  687.         ucComMF522Buf[8] = (pData&((uint32_t)0x000000ff));
    

  688.         ucComMF522Buf[9] = (pData&((uint32_t)0x0000ff00))>>8;
    

  689.         ucComMF522Buf[10] = (pData&((uint32_t)0x00ff0000))>>16;
    

  690.         ucComMF522Buf[11] = (pData&((uint32_t)0xff000000))>>24;        
    

  691.         
    

  692.         ucComMF522Buf[12] = ucAddr;
    

  693.         ucComMF522Buf[13] = ~ucAddr;
    

  694.         ucComMF522Buf[14] = ucAddr;
    

  695.         ucComMF522Buf[15] = ~ucAddr;
    

  696.   status = PcdWrite(ucAddr,ucComMF522Buf);
    

  697.         return status;
    

  698. }
    

  699.  
    

  700. /
    

  701. //功    能：读取钱包金额
    

  702. //参数说明: ucAddr[IN]：块地址
    

  703. //          *pData：读出的金额
    

  704. //返    回: 成功返回MI_OK
    

  705. /
    

  706. char ReadAmount( uint8_t ucAddr, uint32_t *pData )
    

  707. {
    

  708.         
    

  709.         char status = MI_ERR;
    

  710.         uint8_t j;
    

  711.         uint8_t ucComMF522Buf[16];
    

  712.   status = PcdRead(ucAddr,ucComMF522Buf);
    

  713.         if(status != MI_OK)
    

  714.                 return status;
    

  715.         for(j=0;j<4;j++)
    

  716.         {
    

  717.                 if((ucComMF522Buf[j] != ucComMF522Buf[j+8]) && (ucComMF522Buf[j] != ~ucComMF522Buf[j+4]))//验证一下是不是钱包的数据
    

  718.                 break;
    

  719.         }
    

  720.         if(j == 4)
    

  721.         {
    

  722.                   status = MI_OK;
    

  723.                         *pData = ucComMF522Buf[0] + (ucComMF522Buf[1]<<8) + (ucComMF522Buf[2]<<16) + (ucComMF522Buf[3]<<24);
    

  724.         }
    

  725.         else
    

  726.         {
    

  727.                 status = MI_ERR;
    

  728.                 *pData = 0;
    

  729.         }
    

  730.   return status;        
    

  731. }
    

  732.  
    

  733.  
    

  734.  
    

  735.  
    

  736.  
    

  737. /**
    

  738.  * @brief 修改控制块 ucAddr 的密码A。注意 ucAddr 指的是控制块的地址。
    

  739.  *        必须要校验密码B，密码B默认为6个0xFF，如果密码B也忘记了，那就改不了密码A了
    

  740.  * [url=home.php?mod=space&uid=536309]@NOTE[/url]  注意：该函数仅适用于默认的存储控制模式，若是其他的话可能出现问题
    

  741.  * @param ucAddr：[控制块]所在的地址。M1卡总共有16个扇区(每个扇区有：3个数据块+1个控制块),共64个块
    

  742.  * @param pKeyA：指向新的密码A字符串，六个字符，比如 "123456"
    

  743.  * @retval 成功返回 MI_OK
    

  744.  */
    

  745. char ChangeKeyA( uint8_t ucAddr, uint8_t *pKeyA )
    

  746. {
    

  747.         uint8_t KeyBValue[]={0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // B密钥
    

  748.   uint8_t ucArray_ID [ 4 ];    /*先后存放IC卡的类型和UID(IC卡序列号)*/                                                                                         
    

  749.   uint8_t ucComMF522Buf[16];
    

  750.   uint8_t j;
    

  751.   
    

  752.   /*寻卡*/
    

  753.   while ( PcdRequest ( PICC_REQALL, ucArray_ID ) != MI_OK )
    

  754.   {    
    

  755.     printf( "寻卡失败\r\n" );
    

  756.     Delay_us(1000000);
    

  757.   }
    

  758.   
    

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

  760.   
    

  761.   /* 防冲突（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
    

  762.   if ( PcdAnticoll ( ucArray_ID ) == MI_OK )                                                                   
    

  763.   {
    

  764.     /* 选中卡 */
    

  765.     PcdSelect(ucArray_ID);                        
    

  766.  
    

  767.     /* 校验 B 密码 */
    

  768.     if( PcdAuthState( PICC_AUTHENT1B, ucAddr, KeyBValue, ucArray_ID ) != MI_OK )
    

  769.     {
    

  770.       printf( "检验密码B失败\r\n" );
    

  771.     }
    

  772.     
    

  773.     // 读取控制块里原本的数据（只要修改密码A，其他数据不改）
    

  774.     if( PcdRead(ucAddr,ucComMF522Buf) != MI_OK)
    

  775.     {
    

  776.       printf( "读取控制块数据失败\r\n" );
    

  777.       return MI_ERR;
    

  778.     }
    

  779.     
    

  780.     /* 修改密码A */
    

  781.     for(j=0; j<6; j++)
    

  782.       ucComMF522Buf[j] = pKeyA[j];
    

  783.     
    

  784.     if( PcdWrite(ucAddr,ucComMF522Buf) != MI_OK)
    

  785.     {
    

  786.       printf( "写入数据到控制块失败\r\n" );
    

  787.       return MI_ERR;
    

  788.     }
    

  789.     
    

  790.     printf( "密码A修改成功！\r\n" );
    

  791.     PcdHalt();
    

  792.     
    

  793.     return MI_OK;
    

  794.   }
    

  795.   
    

  796.   return MI_ERR;
    

  797. }
    

  798.  
    

  799.  
    

  800. /**
    

  801.  * @brief 按照RC522操作流程写入16字节数据到块 ucAddr
    

  802.  *        函数里校验的是密码B，密码B默认为6个0xFF，也可以校验密码A
    

  803.  *        用法：WriteDataBlock( 1, "123456789\n", 10); //字符串不够16个字节的后面补零写入
    

  804.  * @note  注意：该函数仅适用于默认的存储控制模式，若是其他的话可能出现问题
    

  805.  *        注意：使用该函数要注意 ucAddr 是块0、数据块还是控制块，该函数内部不对此做判断
    

  806.  * @param ucAddr：任意块地址。M1卡总共有16个扇区(每个扇区有：3个数据块+1个控制块),共64个块
    

  807.  * @param pData：指向要写入的数据，最大16个字符
    

  808.  * @param Len：要写入数据的字节数
    

  809.  * @retval 成功返回 MI_OK
    

  810.  */
    

  811. char WriteDataBlock( uint8_t ucAddr, uint8_t *pData, uint8_t Len)
    

  812. {
    

  813.         uint8_t KeyBValue[]={0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // B密钥
    

  814.   uint8_t ucArray_ID [ 4 ];    /*先后存放IC卡的类型和UID(IC卡序列号)*/                                                                                         
    

  815.   uint8_t ucComMF522Buf[16];
    

  816.   uint8_t j;
    

  817.   
    

  818.   /*寻卡*/
    

  819.   while ( PcdRequest ( PICC_REQALL, ucArray_ID ) != MI_OK )
    

  820.   {    
    

  821.     printf( "寻卡失败\r\n" );
    

  822.     Delay_us(1000000);
    

  823.   }
    

  824.   
    

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

  826.   
    

  827.   /* 防冲突（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
    

  828.   if ( PcdAnticoll ( ucArray_ID ) == MI_OK )                                                                   
    

  829.   {
    

  830.     /* 选中卡 */
    

  831.     PcdSelect(ucArray_ID);                        
    

  832.  
    

  833.     /* 校验 B 密码 */
    

  834.     if( PcdAuthState( PICC_AUTHENT1B, ucAddr, KeyBValue, ucArray_ID ) != MI_OK )
    

  835.     {
    

  836.       printf( "检验密码B失败\r\n" );
    

  837.     }
    

  838.     
    

  839.     /* 拷贝 pData 里的 Len 个字符到 ucComMF522Buf */
    

  840.     for(j=0; j<16; j++)
    

  841.     {
    

  842.       if( j < Len ) ucComMF522Buf[j] = pData[j];
    

  843.       else ucComMF522Buf[j] = 0; //16个字节若是未填满的字节置0
    

  844.     }
    

  845.     
    

  846.     /* 写入字符串 */
    

  847.     if( PcdWrite(ucAddr,ucComMF522Buf) != MI_OK)
    

  848.     {
    

  849.       printf( "写入数据到数据块失败\r\n" );
    

  850.       return MI_ERR;
    

  851.     }
    

  852.     
    

  853.     printf( "写入数据成功！\r\n" );
    

  854.     PcdHalt();
    

  855.     
    

  856.     return MI_OK;
    

  857.   }
    

  858.   
    

  859.   return MI_ERR;
    

  860. }
    

  861.  
    

  862.  
    

  863. /**
    

  864.  * @brief 按照RC522操作流程读取块 ucAddr
    

  865.  *        函数里校验的是密码B，密码B默认为6个0xFF，也可以校验密码A
    

  866.  *        用法：ReadDataBlock( 1, databuf);  // databuf 至少为16字节：uint8_t databuf[16];
    

  867.  * @note  注意：该函数仅适用于默认的存储控制模式，若是其他的话可能出现问题
    

  868.  *        注意：使用该函数要注意 ucAddr 是块0、数据块还是控制块，该函数内部不对此做判断
    

  869.  * @param ucAddr：任意块地址。M1卡总共有16个扇区(每个扇区有：3个数据块+1个控制块),共64个块
    

  870.  * @param pData：指向读取到的数据，包含16个字符
    

  871.  * @retval 成功返回 MI_OK
    

  872.  */
    

  873. char ReadDataBlock( uint8_t ucAddr, uint8_t *pData)
    

  874. {
    

  875.         uint8_t KeyBValue[]={0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // B密钥
    

  876.   uint8_t ucArray_ID [ 4 ];    /*先后存放IC卡的类型和UID(IC卡序列号)*/                                                                                         
    

  877.   
    

  878.   /*寻卡*/
    

  879.   while ( PcdRequest ( PICC_REQALL, ucArray_ID ) != MI_OK )
    

  880.   {    
    

  881.     printf( "寻卡失败\r\n" );
    

  882.     Delay_us(1000000);
    

  883.   }
    

  884.   
    

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

  886.   
    

  887.   /* 防冲突（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
    

  888.   if ( PcdAnticoll ( ucArray_ID ) == MI_OK )                                                                   
    

  889.   {
    

  890.     /* 选中卡 */
    

  891.     PcdSelect(ucArray_ID);                        
    

  892.  
    

  893.     /* 校验 B 密码 */
    

  894.     if( PcdAuthState( PICC_AUTHENT1B, ucAddr, KeyBValue, ucArray_ID ) != MI_OK )
    

  895.     {
    

  896.       printf( "检验密码B失败\r\n" );
    

  897.     }
    

  898.     
    

  899.     // 读取数据块里的数据到 pData
    

  900.     if( PcdRead(ucAddr, pData) != MI_OK)
    

  901.     {
    

  902.       printf( "读取数据块失败\r\n" );
    

  903.       return MI_ERR;
    

  904.     }
    

  905.     
    

  906.     printf( "读取数据成功！\r\n" );
    

  907.     PcdHalt();
    

  908.     
    

  909.     return MI_OK;
    

  910.   }
    

  911.   
    

  912.   return MI_ERR;
    

  913. }

回复 赏

举报

 楼主| 无法去污粉 发表于 2022-12-25 13:48 | 显示全部楼层
RC522.H
复制
  1. #ifndef BSP_SPI_H
    

  2. #define BSP_SPI_H
    

  3.  
    

  4. #include  "stm32f4xx.h"
    

  5.  
    

  6.  
    

  7. /
    

  8. //MF522命令字
    

  9. /
    

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

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

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

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

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

  15. #define PCD_RESETPHASE        0x0F               //复位
    

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

  17.  
    

  18. /
    

  19. //Mifare_One卡片命令字
    

  20. /
    

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

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

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

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

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

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

  27. #define PICC_READ             0x30               //读块
    

  28. #define PICC_WRITE            0xA0               //写块
    

  29. #define PICC_DECREMENT        0xC0               //扣款
    

  30. #define PICC_INCREMENT        0xC1               //充值
    

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

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

  33. #define PICC_HALT             0x50               //休眠
    

  34.  
    

  35. /
    

  36. //MF522 FIFO长度定义
    

  37. /
    

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

  39. #define MAXRLEN  18
    

  40.  
    

  41. /
    

  42. //MF522寄存器定义
    

  43. /
    

  44. // PAGE 0
    

  45. #define     RFU00                 0x00    
    

  46. #define     CommandReg            0x01    
    

  47. #define     ComIEnReg             0x02    
    

  48. #define     DivlEnReg             0x03    
    

  49. #define     ComIrqReg             0x04    
    

  50. #define     DivIrqReg             0x05
    

  51. #define     ErrorReg              0x06    
    

  52. #define     Status1Reg            0x07    
    

  53. #define     Status2Reg            0x08    
    

  54. #define     FIFODataReg           0x09
    

  55. #define     FIFOLevelReg          0x0A
    

  56. #define     WaterLevelReg         0x0B
    

  57. #define     ControlReg            0x0C
    

  58. #define     BitFramingReg         0x0D
    

  59. #define     CollReg               0x0E
    

  60. #define     RFU0F                 0x0F
    

  61. // PAGE 1     
    

  62. #define     RFU10                 0x10
    

  63. #define     ModeReg               0x11
    

  64. #define     TxModeReg             0x12
    

  65. #define     RxModeReg             0x13
    

  66. #define     TxControlReg          0x14
    

  67. #define     TxAutoReg             0x15
    

  68. #define     TxSelReg              0x16
    

  69. #define     RxSelReg              0x17
    

  70. #define     RxThresholdReg        0x18
    

  71. #define     DemodReg              0x19
    

  72. #define     RFU1A                 0x1A
    

  73. #define     RFU1B                 0x1B
    

  74. #define     MifareReg             0x1C
    

  75. #define     RFU1D                 0x1D
    

  76. #define     RFU1E                 0x1E
    

  77. #define     SerialSpeedReg        0x1F
    

  78. // PAGE 2    
    

  79. #define     RFU20                 0x20  
    

  80. #define     CRCResultRegM         0x21
    

  81. #define     CRCResultRegL         0x22
    

  82. #define     RFU23                 0x23
    

  83. #define     ModWidthReg           0x24
    

  84. #define     RFU25                 0x25
    

  85. #define     RFCfgReg              0x26
    

  86. #define     GsNReg                0x27
    

  87. #define     CWGsCfgReg            0x28
    

  88. #define     ModGsCfgReg           0x29
    

  89. #define     TModeReg              0x2A
    

  90. #define     TPrescalerReg         0x2B
    

  91. #define     TReloadRegH           0x2C
    

  92. #define     TReloadRegL           0x2D
    

  93. #define     TCounterValueRegH     0x2E
    

  94. #define     TCounterValueRegL     0x2F
    

  95. // PAGE 3      
    

  96. #define     RFU30                 0x30
    

  97. #define     TestSel1Reg           0x31
    

  98. #define     TestSel2Reg           0x32
    

  99. #define     TestPinEnReg          0x33
    

  100. #define     TestPinValueReg       0x34
    

  101. #define     TestBusReg            0x35
    

  102. #define     AutoTestReg           0x36
    

  103. #define     VersionReg            0x37
    

  104. #define     AnalogTestReg         0x38
    

  105. #define     TestDAC1Reg           0x39  
    

  106. #define     TestDAC2Reg           0x3A   
    

  107. #define     TestADCReg            0x3B   
    

  108. #define     RFU3C                 0x3C   
    

  109. #define     RFU3D                 0x3D   
    

  110. #define     RFU3E                 0x3E   
    

  111. #define     RFU3F                                          0x3F
    

  112.  
    

  113. /
    

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

  115. /
    

  116. #define         MI_OK                 0x26
    

  117. #define         MI_NOTAGERR           0xcc
    

  118. #define         MI_ERR                0xbb
    

  119.  
    

  120.  
    

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

  122. #define          RC522_CS_Enable()         GPIO_ResetBits (GPIOA,GPIO_Pin_4)
    

  123. #define          RC522_CS_Disable()        GPIO_SetBits (GPIOA,GPIO_Pin_4)
    

  124.  
    

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

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

  127.  
    

  128. #define          RC522_SCK_0()             GPIO_ResetBits(GPIOA,GPIO_Pin_5)
    

  129. #define          RC522_SCK_1()             GPIO_SetBits (GPIOA,GPIO_Pin_5)
    

  130.  
    

  131. #define          RC522_MOSI_0()            GPIO_ResetBits(GPIOA,GPIO_Pin_7)
    

  132. #define          RC522_MOSI_1()            GPIO_SetBits (GPIOA,GPIO_Pin_7)
    

  133.  
    

  134. #define          RC522_MISO_GET()          GPIO_ReadInputDataBit (GPIOA,GPIO_Pin_6)
    

  135.  
    

  136.  
    

  137.  
    

  138. /*********************************** 函数 *********************************************/
    

  139. void             RC522_Init                   ( void );
    

  140.  
    

  141.  
    

  142.  
    

  143. #endif /*BSP_SPI_H */
回复 赏

举报

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

  2. #include "bsp_led.h"
    

  3. #include "bsp_spi.h"
    

  4. #include "bsp_usart.h"
    

  5. #include "bsp_SysTick.h"
    

  6.  
    

  7.  
    

  8.  
    

  9. uint8_t KeyValue[]={0xFF ,0xFF, 0xFF, 0xFF, 0xFF, 0xFF};   // 卡A密钥
    

  10.  
    

  11.  
    

  12.  
    

  13. void IC_test ( void )
    

  14. {
    

  15.         uint32_t writeValue = 100;
    

  16.         uint32_t readValue;
    

  17.         char cStr [ 30 ];
    

  18.   uint8_t ucArray_ID [ 4 ];    /*先后存放IC卡的类型和UID(IC卡序列号)*/                                                                                         
    

  19.         uint8_t ucStatusReturn;      /*返回状态*/                                                                                           
    

  20.   while ( 1 )
    

  21.   {    
    

  22.     /*寻卡*/
    

  23.                 if ( ( ucStatusReturn = PcdRequest ( PICC_REQALL, ucArray_ID ) ) != MI_OK )
    

  24.     {
    

  25.                 
    

  26.       /*若失败再次寻卡*/
    

  27.       printf ( "寻卡失败\n" );
    

  28.                         ucStatusReturn = PcdRequest ( PICC_REQALL, ucArray_ID ); //PICC_REQALL   PICC_REQIDL
    

  29.     }
    

  30.  
    

  31.                 if ( ucStatusReturn == MI_OK  )
    

  32.                 {
    

  33.       //printf ( "寻卡成功\n" );
    

  34.       /*防冲撞（当有多张卡进入读写器操作范围时，防冲突机制会从其中选择一张进行操作）*/
    

  35.                         if ( PcdAnticoll ( ucArray_ID ) == MI_OK )                                                                   
    

  36.                         {
    

  37.                                 PcdSelect(ucArray_ID);                        
    

  38.                 
    

  39.                                 PcdAuthState( PICC_AUTHENT1A, 0x11, KeyValue, ucArray_ID );//校验密码                         
    

  40.         WriteAmount(0x11,writeValue); //写入金额
    

  41.         if(ReadAmount(0x11,&readValue) == MI_OK)        //读取金额
    

  42.                                 {                
    

  43.                                         //writeValue +=100;
    

  44.                                   sprintf ( cStr, "The Card ID is: %02X%02X%02X%02X",ucArray_ID [0], ucArray_ID [1], ucArray_ID [2],ucArray_ID [3] );
    

  45.                                         printf ( "%s\r\n",cStr );  //打印卡片ID
    

  46.                                         
    

  47.                                         printf ("余额为：%d\r\n",readValue);
    

  48.                                         sprintf ( cStr, "TThe residual amount: %d", readValue);                                                                                                                                  
    

  49.           PcdHalt();
    

  50.                                 }
    

  51.         
    

  52.     
    

  53.         
    

  54.                         }                                
    

  55.                 }                
    

  56.                     
    

  57.   }        
    

  58. }
    

  59.  
    

  60.  
    

  61.  
    

  62.  
    

  63.  
    

  64. int main(void)
    

  65. {
    

  66.         
    

  67.         LED_GPIO_Config();
    

  68.  
    

  69.         SysTick_Init();       //滴答时钟初始化
    

  70.         USART_Config(); //USART1 配置模式为 115200 8-N-1，中断接收 
    

  71.         RC522_Init ();        //RC522模块所需外设的初始化配置
    

  72.         printf("reallly");
    

  73.         
    

  74.         PcdReset ();
    

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

  76.  
    

  77.         printf("ok");
    

  78.         
    

  79.   while ( 1 )
    

  80.   {
    

  81.     IC_test ();//IC卡检测        
    

  82.   }        
    

  83.  
    

  84.         
    

  85.
回复 赏

举报

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

本版积分规则

无法去污粉

56

主题

807

帖子

1

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