21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 驱动RFID-RC522模块
12
返回列表 发新帖我要提问

[其他ST产品] 驱动RFID-RC522模块

[复制链接]
 楼主| 慢醇 发表于 2022-12-24 15:25 | 显示全部楼层
RC522与M1通信前必须开启天线，进行复位，然后设置RC522的工作方式！下面介绍一下相关代码：

/**
  * @brief  ：开启天线
  * @param  ：无
  * @retval ：无
*/
void RC522_Antenna_On( void )
{
        uint8_t k;
        k = RC522_Read_Register( TxControlReg );
        /* 判断天线是否开启 */
        if( !( k&0x03 ) )
                RC522_SetBit_Register( TxControlReg, 0x03 );
}

/**
  * @brief  ：关闭天线
  * @param  ：无
  * @retval ：无
*/
void RC522_Antenna_Off( void )
{
        /* 直接对相应位清零 */
        RC522_ClearBit_Register( TxControlReg, 0x03 );
}


/**
  * @brief  ：复位RC522
  * @param  ：无
  * @retval ：无
*/
void RC522_Rese( void )
{
        RC522_Reset_Disable();
        Delay_us ( 1 );
        RC522_Reset_Enable();
        Delay_us ( 1 );
        RC522_Reset_Disable();
        Delay_us ( 1 );
        RC522_Write_Register( CommandReg, 0x0F );
        while( RC522_Read_Register( CommandReg )&0x10 )
                ;

        /* 缓冲一下 */
        Delay_us ( 1 );
        RC522_Write_Register( ModeReg, 0x3D );       //定义发送和接收常用模式
        RC522_Write_Register( TReloadRegL, 30 );     //16位定时器低位
        RC522_Write_Register( TReloadRegH, 0 );      //16位定时器高位
        RC522_Write_Register( TModeReg, 0x8D );      //内部定时器的设置
        RC522_Write_Register( TPrescalerReg, 0x3E ); //设置定时器分频系数
        RC522_Write_Register( TxAutoReg, 0x40 );     //调制发送信号为100%ASK
}


/**
  * @brief  ：设置RC522的工作方式
  * @param  ：Type：工作方式
  * @retval ：无
  M500PcdConfigISOType
*/
void RC522_Config_Type( char Type )
{
        if( Type=='A' )
        {
                RC522_ClearBit_Register( Status2Reg, 0x08 );
                RC522_Write_Register( ModeReg, 0x3D );
                RC522_Write_Register( RxSelReg, 0x86 );
                RC522_Write_Register( RFCfgReg, 0x7F );
                RC522_Write_Register( TReloadRegL, 30 );
                RC522_Write_Register( TReloadRegH, 0 );
                RC522_Write_Register( TModeReg, 0x8D );
                RC522_Write_Register( TPrescalerReg, 0x3E );
                Delay_us(2);
                /* 开天线 */
                RC522_Antenna_On();
        }
}
回复 赏

举报

 楼主| 慢醇 发表于 2022-12-24 15:26 | 显示全部楼层
对于这些寄存器和指令的宏定义，查一下前面的说明即可。
回复 赏

举报

 楼主| 慢醇 发表于 2022-12-24 15:28 | 显示全部楼层
STM32控制RC522与M1的通信
这部分是最重要的步骤，RC522与M1的通信是工程要实现的目的，而且要遵守前面提到的M1卡与RC522通信的步骤以及M1卡的内部构造，包括以下操作：

通过RC522和M1卡通讯（数据的双向传输）
寻卡
防冲突
用RC522计算CRC16（循环冗余校验）
选定卡片
校验卡片密码
在M1卡的指定块地址写入指定数据
读取M1卡的指定块地址的数据
让卡片进入休眠模式
回复 赏

举报

 楼主| 慢醇 发表于 2022-12-24 15:31 | 显示全部楼层
话不多说，上代码，代码中都有按照我理解的一些注释：
复制
  1. /**
    

  2.   * @brief  ：通过RC522和ISO14443卡通讯
    

  3. * @param  ：ucCommand：RC522命令字
    

  4.  *          pInData：通过RC522发送到卡片的数据
    

  5.  *          ucInLenByte：发送数据的字节长度
    

  6.  *          pOutData：接收到的卡片返回数据
    

  7.  *          pOutLenBit：返回数据的位长度
    

  8.   * @retval ：状态值MI_OK，成功
    

  9. */
    

  10. char PcdComMF522 ( uint8_t ucCommand, uint8_t * pInData, uint8_t ucInLenByte, uint8_t * pOutData, uint32_t * pOutLenBit )                
    

  11. {
    

  12.     char cStatus = MI_ERR;
    

  13.     uint8_t ucIrqEn   = 0x00;
    

  14.     uint8_t ucWaitFor = 0x00;
    

  15.     uint8_t ucLastBits;
    

  16.     uint8_t ucN;
    

  17.     uint32_t ul;
    

  18.         
    

  19.         
    

  20.     switch ( ucCommand )
    

  21.     {
    

  22.        case PCD_AUTHENT:                //Mifare认证
    

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

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

  25.           break;
    

  26.                          
    

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

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

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

  30.           break;
    

  31.                          
    

  32.        default:
    

  33.          break;
    

  34.                          
    

  35.     }
    

  36.    
    

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

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

  39.     RC522_Write_Register ( CommandReg, PCD_IDLE );                //写空闲命令
    

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

  41.     
    

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

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

  44.                         
    

  45.     RC522_Write_Register ( CommandReg, ucCommand );                                        //写命令
    

  46.    
    

  47.     
    

  48.     if ( ucCommand == PCD_TRANSCEIVE )
    

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

  50.     
    

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

  52.                 
    

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

  54.     {
    

  55.          ucN = RC522_Read_Register ( ComIrqReg );                                                        //查询事件中断
    

  56.          ul --;
    

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

  58.                 
    

  59.     RC522_ClearBit_Register ( BitFramingReg, 0x80 );                                        //清理允许StartSend位
    

  60.                 
    

  61.     if ( ul != 0 )
    

  62.     {
    

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

  64.                         {
    

  65.                                 cStatus = MI_OK;
    

  66.                                 
    

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

  68.                                   cStatus = MI_NOTAGERR;   
    

  69.                                         
    

  70.                                 if ( ucCommand == PCD_TRANSCEIVE )
    

  71.                                 {
    

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

  73.                                         
    

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

  75.                                         
    

  76.                                         if ( ucLastBits )
    

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

  78.                                         else
    

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

  80.                                         
    

  81.                                         if ( ucN == 0 )                
    

  82.             ucN = 1;    
    

  83.                                         
    

  84.                                         if ( ucN > MAXRLEN )
    

  85.                                                 ucN = MAXRLEN;   
    

  86.                                         
    

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

  88.                                           pOutData [ ul ] = RC522_Read_Register ( FIFODataReg );                                           
    

  89.                                         }                                        
    

  90.       }                        
    

  91.                         else
    

  92.                                 cStatus = MI_ERR;                           
    

  93.     }
    

  94.    
    

  95.    RC522_SetBit_Register ( ControlReg, 0x80 );           // stop timer now
    

  96.    RC522_Write_Register ( CommandReg, PCD_IDLE ); 
    

  97.                  
    

  98.    return cStatus;                
    

  99. }
    


  100. 


  101. 


  102. 

  103. /**
    

  104.   * @brief  ：寻卡
    

  105. * @param  ucReq_code，寻卡方式
    

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

  107.  *                     = 0x26：寻未进入休眠状态的卡
    

  108.  *         pTagType，卡片类型代码
    

  109.  *                   = 0x4400：Mifare_UltraLight
    

  110.  *                   = 0x0400：Mifare_One(S50)
    

  111.  *                   = 0x0200：Mifare_One(S70)
    

  112.  *                   = 0x0800：Mifare_Pro(X))
    

  113.  *                   = 0x4403：Mifare_DESFire
    

  114.   * @retval ：状态值MI_OK，成功
    

  115. */
    

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

  117. {
    

  118.    char cStatus;  
    

  119.          uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  120.    uint32_t ulLen;
    

  121.         
    

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

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

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


  125. 

  126.    ucComMF522Buf [ 0 ] = ucReq_code;                //存入寻卡方式
    

  127.         /* PCD_TRANSCEIVE：发送并接收数据的命令，RC522向卡片发送寻卡命令，卡片返回卡的型号代码到ucComMF522Buf中 */
    

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

  129.   
    

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

  131.    {    
    

  132.                  /* 接收卡片的型号代码 */
    

  133.        * pTagType = ucComMF522Buf [ 0 ];
    

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

  135.    }
    

  136.    else
    

  137.      cStatus = MI_ERR;   
    

  138.    return cStatus;         
    

  139. }
    


  140. 


  141. 


  142. 

  143. /**
    

  144.   * @brief  ：防冲突
    

  145.         * @param  ：Snr：卡片序列，4字节，会返回选中卡片的序列
    

  146.   * @retval ：状态值MI_OK，成功
    

  147. */
    

  148. char PcdAnticoll ( uint8_t * pSnr )
    

  149. {
    

  150.     char cStatus;
    

  151.     uint8_t uc, ucSnr_check = 0;
    

  152.     uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  153.           uint32_t ulLen;
    

  154.    
    

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

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

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

  158.    
    

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

  160.     ucComMF522Buf [ 1 ] = 0x20;
    

  161.    
    

  162.           /* 将卡片防冲突命令通过RC522传到卡片中，返回的是被选中卡片的序列 */
    

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

  164.         
    

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

  166.     {
    

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

  168.                         {
    

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

  170.          ucSnr_check ^= ucComMF522Buf [ uc ];
    

  171.       }
    

  172.                         
    

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

  174.                                 cStatus = MI_ERR;             
    

  175.     }    
    

  176.     RC522_SetBit_Register ( CollReg, 0x80 );                
    

  177.     return cStatus;                
    

  178. }
    


  179. 


  180. 


  181. 

  182. /**
    

  183.  * @brief   :用RC522计算CRC16（循环冗余校验）
    

  184.         * @param  ：pIndata：计算CRC16的数组
    

  185.  *            ucLen：计算CRC16的数组字节长度
    

  186.  *            pOutData：存放计算结果存放的首地址
    

  187.   * @retval ：状态值MI_OK，成功
    

  188. */
    

  189. void CalulateCRC ( uint8_t * pIndata, u8 ucLen, uint8_t * pOutData )
    

  190. {
    

  191.     uint8_t uc, ucN;
    

  192.         
    

  193.         
    

  194.     RC522_ClearBit_Register(DivIrqReg,0x04);        
    

  195.     RC522_Write_Register(CommandReg,PCD_IDLE);        
    

  196.     RC522_SetBit_Register(FIFOLevelReg,0x80);
    

  197.         
    

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

  199.             RC522_Write_Register ( FIFODataReg, * ( pIndata + uc ) );   
    


  200. 

  201.     RC522_Write_Register ( CommandReg, PCD_CALCCRC );
    

  202.         
    

  203.     uc = 0xFF;
    

  204.         
    

  205.     do 
    

  206.     {
    

  207.         ucN = RC522_Read_Register ( DivIrqReg );
    

  208.         uc --;
    

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

  210.                 
    

  211.     pOutData [ 0 ] = RC522_Read_Register ( CRCResultRegL );
    

  212.     pOutData [ 1 ] = RC522_Read_Register ( CRCResultRegM );
    

  213.                 
    

  214. }
    


  215. 


  216. 


  217. 

  218. /**
    

  219.   * @brief   :选定卡片
    

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

  221.   * @retval ：状态值MI_OK，成功
    

  222. */
    

  223. char PcdSelect ( uint8_t * pSnr )
    

  224. {
    

  225.     char ucN;
    

  226.     uint8_t uc;
    

  227.           uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  228.     uint32_t  ulLen;
    

  229.     /* PICC_ANTICOLL1：防冲突命令 */
    

  230.     ucComMF522Buf [ 0 ] = PICC_ANTICOLL1;
    

  231.     ucComMF522Buf [ 1 ] = 0x70;
    

  232.     ucComMF522Buf [ 6 ] = 0;
    

  233.         
    

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

  235.     {
    

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

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

  238.     }
    

  239.                 
    

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

  241.   
    

  242.     RC522_ClearBit_Register ( Status2Reg, 0x08 );
    


  243. 

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

  245.     
    

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

  247.       ucN = MI_OK;  
    

  248.     else
    

  249.       ucN = MI_ERR;    
    


  250. 

  251.     return ucN;
    

  252.                 
    

  253. }
    


  254. 


  255. 


  256. 

  257. /**
    

  258.   * @brief   :校验卡片密码
    

  259.   * @param  ：ucAuth_mode：密码验证模式
    

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

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

  262.   *           ucAddr：块地址
    

  263.   *           pKey：密码
    

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

  265.   * @retval ：状态值MI_OK，成功
    

  266. */
    

  267. char PcdAuthState ( uint8_t ucAuth_mode, uint8_t ucAddr, uint8_t * pKey, uint8_t * pSnr )
    

  268. {
    

  269.     char cStatus;
    

  270.           uint8_t uc, ucComMF522Buf [ MAXRLEN ];
    

  271.     uint32_t ulLen; 
    

  272.         
    

  273.     ucComMF522Buf [ 0 ] = ucAuth_mode;
    

  274.     ucComMF522Buf [ 1 ] = ucAddr;
    

  275.           /* 前俩字节存储验证模式和块地址，2~8字节存储密码（6个字节），8~14字节存储序列号 */
    

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

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

  278.         
    

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

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

  281.     /* 进行冗余校验，14~16俩个字节存储校验结果 */
    

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

  283.           /* 判断验证是否成功 */
    

  284.     if ( ( cStatus != MI_OK ) || ( ! ( RC522_Read_Register ( Status2Reg ) & 0x08 ) ) )
    

  285.       cStatus = MI_ERR;   
    

  286.                 
    

  287.     return cStatus;
    

  288.                 
    

  289. }
    


  290. 


  291. 

  292. /**
    

  293.   * @brief   :在M1卡的指定块地址写入指定数据
    

  294.   * @param  ：ucAddr：块地址
    

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

  296.   * @retval ：状态值MI_OK，成功
    

  297. */
    

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

  299. {
    

  300.     char cStatus;
    

  301.           uint8_t uc, ucComMF522Buf [ MAXRLEN ];
    

  302.     uint32_t ulLen;
    

  303.    
    

  304.     ucComMF522Buf [ 0 ] = PICC_WRITE;//写块命令
    

  305.     ucComMF522Buf [ 1 ] = ucAddr;//写块地址
    

  306.         
    

  307.           /* 进行循环冗余校验，将结果存储在& ucComMF522Buf [ 2 ] */
    

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

  309.     
    

  310.         /* PCD_TRANSCEIVE:发送并接收数据命令，通过RC522向卡片发送写块命令 */
    

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


  312. 

  313.                 /* 通过卡片返回的信息判断，RC522是否与卡片正常通信 */
    

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

  315.       cStatus = MI_ERR;   
    

  316.         
    

  317.     if ( cStatus == MI_OK )
    

  318.     {
    

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

  320.                         /* 将要写入的16字节的数据，传入ucComMF522Buf数组中 */
    

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

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

  323.                         /* 冗余校验 */
    

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

  325.       /* 通过RC522，将16字节数据包括2字节校验结果写入卡片中 */
    

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

  327.                         /* 判断写地址是否成功 */
    

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

  329.         cStatus = MI_ERR;                           
    

  330.     } 
    

  331.     return cStatus;        
    

  332. }
    


  333. 


  334. 

  335. /**
    

  336.   * @brief   :读取M1卡的指定块地址的数据
    

  337.   * @param  ：ucAddr：块地址
    

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

  339.   * @retval ：状态值MI_OK，成功
    

  340. */
    

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

  342. {
    

  343.     char cStatus;
    

  344.           uint8_t uc, ucComMF522Buf [ MAXRLEN ]; 
    

  345.     uint32_t ulLen;
    


  346. 

  347.     ucComMF522Buf [ 0 ] = PICC_READ;
    

  348.     ucComMF522Buf [ 1 ] = ucAddr;
    

  349.           /* 冗余校验 */
    

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

  351.     /* 通过RC522将命令传给卡片 */
    

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

  353.         
    

  354.           /* 如果传输正常，将读取到的数据传入pData中 */
    

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

  356.     {
    

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

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

  359.     }
    

  360.                 
    

  361.     else
    

  362.       cStatus = MI_ERR;   
    

  363.         
    

  364.     return cStatus;
    


  365. 

  366. }
    


  367. 


  368. 

  369. /**
    

  370.   * @brief   :让卡片进入休眠模式
    

  371.   * @param  ：无
    

  372.   * @retval ：状态值MI_OK，成功
    

  373. */
    

  374. char PcdHalt( void )
    

  375. {
    

  376.         uint8_t ucComMF522Buf [ MAXRLEN ]; 
    

  377.         uint32_t  ulLen;
    


  378. 

  379.   ucComMF522Buf [ 0 ] = PICC_HALT;
    

  380.   ucComMF522Buf [ 1 ] = 0;
    

  381.         
    

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

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


  384. 

  385.   return MI_OK;
    

  386.         
    

  387. }
回复 赏

举报

 楼主| 慢醇 发表于 2022-12-24 15:33 | 显示全部楼层
测试函数
通过测试函数来试一下对M1卡的识别，读取数据等。
复制
  1. 在这里插入代码片char cStr [ 30 ];
    

  2. /* 卡的ID存储，32位,4字节 */
    

  3. u8 ucArray_ID [ 4 ];
    

  4. /**
    

  5.   * @brief  : 测试代码，读取卡片ID
    

  6.   * @param  ：无
    

  7.   * @retval ：无
    

  8. */
    

  9. void IC_test ( void )
    

  10. {                                                                                       
    

  11.         uint8_t ucStatusReturn;    //返回状态                                       
    

  12.         
    

  13.   while ( 1 )
    

  14.   { 
    

  15.                 /* 寻卡（方式：范围内全部），第一次寻卡失败后再进行一次，寻卡成功时卡片序列传入数组ucArray_ID中 */
    

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

  17.                         ucStatusReturn = PcdRequest ( PICC_REQALL, ucArray_ID );                   
    


  18. 

  19.                 if ( ucStatusReturn == MI_OK  )
    

  20.                 {
    

  21.                         /* 防冲突操作，被选中的卡片序列传入数组ucArray_ID中 */
    

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

  23.                         {
    

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

  25.                                 printf ("%s\r\n",cStr ); 
    

  26.                         }
    

  27.                 }
    


  28. 

  29.   }
    

  30. }
回复 赏

举报

huangcunxiake 发表于 2022-12-25 17:11 | 显示全部楼层
这是什么对象。
回复 赏

举报

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

本版积分规则

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