21ic电子技术开发论坛 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 【AT-START-F425测评】6、硬件SPI1驱动RC522
返回列表 发新帖我要提问

[活动专区] 【AT-START-F425测评】6、硬件SPI1驱动RC522

[复制链接]
 楼主| freeelectron 发表于 2022-3-8 15:42 | 显示全部楼层 |阅读模式
AT32F425, spi, RC522, AT-START-F425测评
本帖最后由 freeelectron 于 2022-3-8 15:49 编辑

1、关于AT32F425的SPI接口
36821622704450ef4f.png
可以看出包含3路SPI，分别是SPI1、SPI2、SPI3，本文使用SPI1。

2、开发板上SPI的引脚

98070622704d68b670.png

3、spi1引脚复用

445356227052c609ca.png


4、开发板与RC522模块连接

587766227089d72dd6.png

开发板                             rc522

PA4 <----------------------------->SDA(NSS)

PA5 <----------------------------->SCK

PA6 <----------------------------->MISO

PA7 <----------------------------->MOSI

PA3   <-----------------------------> RST

3.3V  <----------------------------->3V3

GND <----------------------------->GND


5、与SPI相关操作代码

复制
  1. #define SET_SPI_CS      gpio_bits_set(GPIOA, GPIO_PINS_4)
    

  2. #define CLR_SPI_CS      gpio_bits_reset(GPIOA, GPIO_PINS_4) 
    


  3. 

  4. #define SET_RC522RST    gpio_bits_set(GPIOA, GPIO_PINS_3) 
    

  5. #define CLR_RC522RST    gpio_bits_reset(GPIOA, GPIO_PINS_3)
    


  6. 

  7. #define SPIReadByte()        SPIWriteByte(0)
    


  8. 

  9. void SpiIoInit(void)
    

  10. {
    

  11.         /*SPI1 :  
    

  12.                 PA4/CS  
    

  13.                 PA5/SCK    
    

  14.                 PA6/MISO   
    

  15.                 PA7/MOSI    
    

  16.         */
    

  17.         crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
    


  18. 

  19.         gpio_init_type gpio_initstructure;
    

  20.         
    

  21.         gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;
    

  22.         gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  23.         gpio_initstructure.gpio_mode           = GPIO_MODE_OUTPUT;
    

  24.         gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  25.         gpio_initstructure.gpio_pins = GPIO_PINS_3;
    

  26.         gpio_init(GPIOA, &gpio_initstructure);
    

  27.         
    

  28.         gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;
    

  29.         gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  30.         gpio_initstructure.gpio_mode           = GPIO_MODE_OUTPUT;
    

  31.         gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  32.         gpio_initstructure.gpio_pins = GPIO_PINS_4;
    

  33.         gpio_init(GPIOA, &gpio_initstructure);
    

  34.   
    

  35.         gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE5, GPIO_MUX_0);
    

  36.         gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE6, GPIO_MUX_0);
    

  37.         gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE7, GPIO_MUX_0);
    


  38. 

  39.         gpio_default_para_init(&gpio_initstructure);
    


  40. 

  41.         gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;
    

  42.         gpio_initstructure.gpio_pull           = GPIO_PULL_DOWN;
    

  43.         gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    

  44.         gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  45.         gpio_initstructure.gpio_pins = GPIO_PINS_5;
    

  46.         gpio_init(GPIOA, &gpio_initstructure);
    


  47. 

  48.         gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;
    

  49.         gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  50.         gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    

  51.         gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  52.         gpio_initstructure.gpio_pins = GPIO_PINS_6;
    

  53.         gpio_init(GPIOA, &gpio_initstructure);
    


  54. 

  55.         gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;
    

  56.         gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  57.         gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    

  58.         gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  59.         gpio_initstructure.gpio_pins = GPIO_PINS_7;
    

  60.         gpio_init(GPIOA, &gpio_initstructure);
    

  61. }
    


  62. 


  63. 

  64. void SpiInit(void)
    

  65. {
    

  66.   spi_init_type spi_init_struct;
    


  67. 

  68.   crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
    

  69.   
    

  70.   spi_default_para_init(&spi_init_struct);
    

  71.   spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
    

  72.   spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
    

  73.   spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
    

  74.   spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
    

  75.   spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
    

  76.   spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW;
    

  77.   spi_init_struct.clock_phase = SPI_CLOCK_PHASE_1EDGE;
    

  78.   spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
    

  79.   spi_init(SPI1, &spi_init_struct);
    


  80. 


  81. 

  82.   spi_enable(SPI1, TRUE);
    

  83.   
    

  84. }
    


  85. 


  86. 


  87. 

  88. uint8_t  SPIWriteByte(uint8_t Byte)
    

  89. {
    

  90.         uint16_t ret=0;
    


  91. 

  92.         while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET) {};
    

  93.     spi_i2s_data_transmit(SPI1, Byte);
    

  94.                 
    

  95.     while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET) {};
    

  96.     ret=spi_i2s_data_receive(SPI1);
    

  97.         
    

  98.         return (ret&0x0ff);
    

  99. }


6、与RC522操作相关代码

复制
  1. void RC522Init(void)
    

  2. {
    

  3.         uint8_t ver=0;
    

  4.         
    

  5.         SpiIoInit();
    

  6.         SpiInit();
    

  7.         
    

  8.         PcdReset();
    

  9.         
    

  10.         ver=ReadRawRC(VersionReg);
    

  11.         
    

  12.         if(ver==0x91||ver==0x92)
    

  13.         {
    

  14.                 printf("rc522 exist\r\n");
    

  15.         }
    

  16.         else
    

  17.         {
    

  18.                 printf("rc522 not exist\r\n");
    

  19.         }
    

  20.         
    

  21.         PcdAntennaOff();
    

  22.         delay_ms(2);  
    

  23.         PcdAntennaOn();
    

  24.         M500PcdConfigISOType( 'A' );
    


  25. 

  26. }
    


  27. 


  28. 

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

  30. unsigned char SN[4]; //卡号
    


  31. 


  32. 

  33. char cStr [ 30 ];
    

  34. uint8_t  ucArray_ID [ 4 ];
    


  35. 


  36. 

  37. void RC522Polling(void)
    

  38. {
    

  39.         unsigned char status;        
    

  40.         uint8_t j; 
    

  41.         
    

  42.         status = PcdRequest(PICC_REQALL,CT);/*尋卡*/
    

  43.         if(status==MI_OK)//尋卡成功
    

  44.         {
    

  45.                 status=MI_ERR;
    

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

  47.         }
    


  48. 

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

  50.         {
    

  51.                 status=MI_ERR;                
    

  52.                 
    

  53.                 printf("\r\nThe Card ID is:");
    

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

  55.                 {
    

  56.                         printf("%02X",SN[j]);
    

  57.                 }
    

  58.                 printf("\r\n");
    

  59.                 status =PcdSelect(SN);
    

  60.         }                              
    

  61. }
    

  62.                         
    

  63. /////////////////////////////////////////////////////////////////////
    

  64. //功    能：寻卡
    

  65. //参数说明: req_code[IN]:寻卡方式
    

  66. //                0x52 = 寻感应区内所有符合14443A标准的卡
    

  67. //                0x26 = 寻未进入休眠状态的卡
    

  68. //          pTagType[OUT]：卡片类型代码
    

  69. //                0x4400 = Mifare_UltraLight
    

  70. //                0x0400 = Mifare_One(S50)
    

  71. //                0x0200 = Mifare_One(S70)
    

  72. //                0x0800 = Mifare_Pro(X)
    

  73. //                0x4403 = Mifare_DESFire
    

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

  75. /////////////////////////////////////////////////////////////////////
    

  76. char PcdRequest(uint8_t   req_code,uint8_t *pTagType)
    

  77. {
    

  78.         char   status;  
    

  79.         uint8_t   unLen;
    

  80.         uint8_t   ucComMF522Buf[MAXRLEN]; 
    


  81. 

  82.         ClearBitMask(Status2Reg,0x08);
    

  83.         WriteRawRC(BitFramingReg,0x07);
    

  84.         SetBitMask(TxControlReg,0x03);
    

  85.  
    

  86.         ucComMF522Buf[0] = req_code;
    


  87. 

  88.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
    


  89. 

  90.         if ((status == MI_OK) && (unLen == 0x10))
    

  91.         {    
    

  92.                 *pTagType     = ucComMF522Buf[0];
    

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

  94.         }
    

  95.         else
    

  96.         {   status = MI_ERR;   }
    

  97.    
    

  98.         return status;
    

  99. }
    


  100. 

  101. /////////////////////////////////////////////////////////////////////
    

  102. //功    能：防冲撞
    

  103. //参数说明: pSnr[OUT]:卡片序列号，4字节
    

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

  105. /////////////////////////////////////////////////////////////////////  
    

  106. char PcdAnticoll(uint8_t *pSnr)
    

  107. {
    

  108.     char   status;
    

  109.     uint8_t   i,snr_check=0;
    

  110.     uint8_t   unLen;
    

  111.     uint8_t   ucComMF522Buf[MAXRLEN]; 
    

  112.     
    


  113. 

  114.     ClearBitMask(Status2Reg,0x08);
    

  115.     WriteRawRC(BitFramingReg,0x00);
    

  116.     ClearBitMask(CollReg,0x80);
    

  117.  
    

  118.     ucComMF522Buf[0] = PICC_ANTICOLL1;
    

  119.     ucComMF522Buf[1] = 0x20;
    


  120. 

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


  122. 

  123.     if (status == MI_OK)
    

  124.     {
    

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

  126.          {   
    

  127.              *(pSnr+i)  = ucComMF522Buf[i];
    

  128.              snr_check ^= ucComMF522Buf[i];
    

  129.          }
    

  130.          if (snr_check != ucComMF522Buf[i])
    

  131.          {   status = MI_ERR;    }
    

  132.     }
    

  133.     
    

  134.     SetBitMask(CollReg,0x80);
    

  135.     return status;
    

  136. }
    


  137. 

  138. /////////////////////////////////////////////////////////////////////
    

  139. //功    能：选定卡片
    

  140. //参数说明: pSnr[IN]:卡片序列号，4字节
    

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

  142. /////////////////////////////////////////////////////////////////////
    

  143. char PcdSelect(uint8_t *pSnr)
    

  144. {
    

  145.     char   status;
    

  146.     uint8_t   i;
    

  147.     uint8_t   unLen;
    

  148.     uint8_t   ucComMF522Buf[MAXRLEN]; 
    

  149.     
    

  150.     ucComMF522Buf[0] = PICC_ANTICOLL1;
    

  151.     ucComMF522Buf[1] = 0x70;
    

  152.     ucComMF522Buf[6] = 0;
    

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

  154.     {
    

  155.             ucComMF522Buf[i+2] = *(pSnr+i);
    

  156.             ucComMF522Buf[6]  ^= *(pSnr+i);
    

  157.     }
    

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

  159.   
    

  160.     ClearBitMask(Status2Reg,0x08);
    


  161. 

  162.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
    

  163.     
    

  164.     if ((status == MI_OK) && (unLen == 0x18))
    

  165.     {   status = MI_OK;  }
    

  166.     else
    

  167.     {   status = MI_ERR;    }
    


  168. 

  169.     return status;
    

  170. }
    


  171. 

  172. /////////////////////////////////////////////////////////////////////
    

  173. //功    能：验证卡片密码
    

  174. //参数说明: auth_mode[IN]: 密码验证模式
    

  175. //                 0x60 = 验证A密钥
    

  176. //                 0x61 = 验证B密钥 
    

  177. //          addr[IN]：块地址
    

  178. //          pKey[IN]：密码
    

  179. //          pSnr[IN]：卡片序列号，4字节
    

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

  181. /////////////////////////////////////////////////////////////////////               
    

  182. char PcdAuthState(uint8_t   auth_mode,uint8_t   addr,uint8_t *pKey,uint8_t *pSnr)
    

  183. {
    

  184.     char   status;
    

  185.     uint8_t   unLen;
    

  186.     uint8_t   i,ucComMF522Buf[MAXRLEN]; 
    


  187. 

  188.     ucComMF522Buf[0] = auth_mode;
    

  189.     ucComMF522Buf[1] = addr;
    

  190. //    for (i=0; i<6; i++)
    

  191. //    {    ucComMF522Buf[i+2] = *(pKey+i);   }
    

  192. //    for (i=0; i<6; i++)
    

  193. //    {    ucComMF522Buf[i+8] = *(pSnr+i);   }
    

  194.     memcpy(&ucComMF522Buf[2], pKey, 6); 
    

  195.     memcpy(&ucComMF522Buf[8], pSnr, 4); 
    

  196.     
    

  197.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
    

  198.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
    

  199.     {   status = MI_ERR;   }
    

  200.     
    

  201.     return status;
    

  202. }
    


  203. 

  204. /////////////////////////////////////////////////////////////////////
    

  205. //功    能：读取M1卡一块数据
    

  206. //参数说明: addr[IN]：块地址
    

  207. //          p [OUT]：读出的数据，16字节
    

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

  209. ///////////////////////////////////////////////////////////////////// 
    

  210. char PcdRead(uint8_t   addr,uint8_t *p )
    

  211. {
    

  212.     char   status;
    

  213.     uint8_t   unLen;
    

  214.     uint8_t   i,ucComMF522Buf[MAXRLEN]; 
    


  215. 

  216.     ucComMF522Buf[0] = PICC_READ;
    

  217.     ucComMF522Buf[1] = addr;
    

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

  219.    
    

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

  221.     if ((status == MI_OK) && (unLen == 0x90))
    

  222.     {
    

  223.         for (i=0; i<16; i++)
    

  224.         {    
    

  225.                         *(p +i) = ucComMF522Buf[i];   
    

  226.                 }
    

  227.     }
    

  228.     else
    

  229.     {   
    

  230.                 status = MI_ERR;   
    

  231.         }
    

  232.     
    

  233.     return status;
    

  234. }
    


  235. 

  236. /////////////////////////////////////////////////////////////////////
    

  237. //功    能：写数据到M1卡一块
    

  238. //参数说明: addr[IN]：块地址
    

  239. //          p [IN]：写入的数据，16字节
    

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

  241. /////////////////////////////////////////////////////////////////////                  
    

  242. char PcdWrite(uint8_t   addr,uint8_t *p )
    

  243. {
    

  244.     char   status;
    

  245.     uint8_t   unLen;
    

  246.     uint8_t   i,ucComMF522Buf[MAXRLEN]; 
    

  247.     
    

  248.     ucComMF522Buf[0] = PICC_WRITE;
    

  249.     ucComMF522Buf[1] = addr;
    

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

  251.  
    

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


  253. 

  254.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    

  255.     {   status = MI_ERR;   }
    

  256.         
    

  257.     if (status == MI_OK)
    

  258.     {
    

  259.         //memcpy(ucComMF522Buf, p , 16);
    

  260.         for (i=0; i<16; i++)
    

  261.         {    
    

  262.                 ucComMF522Buf[i] = *(p +i);   
    

  263.         }
    

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


  265. 

  266.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
    

  267.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    

  268.         {   status = MI_ERR;   }
    

  269.     }
    

  270.     
    

  271.     return status;
    

  272. }
    


  273. 

  274. /////////////////////////////////////////////////////////////////////
    

  275. //功    能：命令卡片进入休眠状态
    

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

  277. /////////////////////////////////////////////////////////////////////
    

  278. char PcdHalt(void)
    

  279. {
    

  280.     uint8_t   status;
    

  281.     uint8_t   unLen;
    

  282.     uint8_t   ucComMF522Buf[MAXRLEN]; 
    


  283. 

  284.     ucComMF522Buf[0] = PICC_HALT;
    

  285.     ucComMF522Buf[1] = 0;
    

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

  287.  
    

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


  289. 

  290.     return MI_OK;
    

  291. }
    


  292. 

  293. /////////////////////////////////////////////////////////////////////
    

  294. //用MF522计算CRC16函数
    

  295. /////////////////////////////////////////////////////////////////////
    

  296. void CalulateCRC(uint8_t *pIn ,uint8_t   len,uint8_t *pOut )
    

  297. {
    

  298.     uint8_t   i,n;
    

  299.     ClearBitMask(DivIrqReg,0x04);
    

  300.     WriteRawRC(CommandReg,PCD_IDLE);
    

  301.     SetBitMask(FIFOLevelReg,0x80);
    

  302.     for (i=0; i<len; i++)
    

  303.     {   WriteRawRC(FIFODataReg, *(pIn +i));   }
    

  304.     WriteRawRC(CommandReg, PCD_CALCCRC);
    

  305.     i = 0xFF;
    

  306.     do 
    

  307.     {
    

  308.         n = ReadRawRC(DivIrqReg);
    

  309.         i--;
    

  310.     }
    

  311.     while ((i!=0) && !(n&0x04));
    

  312.     pOut [0] = ReadRawRC(CRCResultRegL);
    

  313.     pOut [1] = ReadRawRC(CRCResultRegM);
    

  314. }
    


  315. 

  316. /////////////////////////////////////////////////////////////////////
    

  317. //功    能：复位RC522
    

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

  319. /////////////////////////////////////////////////////////////////////
    

  320. char PcdReset(void)
    

  321. {
    

  322.         SET_RC522RST;
    

  323.         delay_ms(1);
    

  324.         CLR_RC522RST;
    

  325.         delay_ms(1);
    

  326.         SET_RC522RST;
    

  327.         delay_ms(1);
    


  328. 

  329.     WriteRawRC(CommandReg,PCD_RESETPHASE);
    

  330.         WriteRawRC(CommandReg,PCD_RESETPHASE);
    

  331.         delay_ms(1);
    


  332. 

  333.     WriteRawRC(ModeReg,0x3D);            //和Mifare卡通讯，CRC初始值0x6363
    

  334.     WriteRawRC(TReloadRegL,30);           
    

  335.     WriteRawRC(TReloadRegH,0);
    

  336.     WriteRawRC(TModeReg,0x8D);
    

  337.     WriteRawRC(TPrescalerReg,0x3E);
    

  338.         
    

  339.         WriteRawRC(TxAutoReg,0x40);//必须要
    

  340.    
    

  341.     return MI_OK;
    

  342. }
    

  343. //////////////////////////////////////////////////////////////////////
    

  344. //设置RC632的工作方式 
    

  345. //////////////////////////////////////////////////////////////////////
    

  346. char M500PcdConfigISOType(uint8_t   type)
    

  347. {
    

  348.    if (type == 'A')                     //ISO14443_A
    

  349.    { 
    

  350.        ClearBitMask(Status2Reg,0x08);
    

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

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

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

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

  355.            WriteRawRC(TReloadRegH,0);
    

  356.        WriteRawRC(TModeReg,0x8D);
    

  357.            WriteRawRC(TPrescalerReg,0x3E);
    

  358.            delay_ms(2);
    

  359.        PcdAntennaOn();
    

  360.    }
    

  361.    else{ return 1; }
    

  362.    
    

  363.    return MI_OK;
    

  364. }
    

  365. /////////////////////////////////////////////////////////////////////
    

  366. //功    能：读RC632寄存器
    

  367. //参数说明：Address[IN]:寄存器地址
    

  368. //返    回：读出的值
    

  369. /////////////////////////////////////////////////////////////////////
    

  370. uint8_t ReadRawRC(uint8_t   Address)
    

  371. {
    

  372.     uint8_t   ucAddr;
    

  373.     uint8_t   ucResult=0;
    

  374.         CLR_SPI_CS;
    

  375.     ucAddr = ((Address<<1)&0x7E)|0x80;
    

  376.         
    

  377.         SPIWriteByte(ucAddr);
    

  378.         ucResult=SPIReadByte();
    

  379.         SET_SPI_CS;
    

  380.    return ucResult;
    

  381. }
    


  382. 

  383. /////////////////////////////////////////////////////////////////////
    

  384. //功    能：写RC632寄存器
    

  385. //参数说明：Address[IN]:寄存器地址
    

  386. //          value[IN]:写入的值
    

  387. /////////////////////////////////////////////////////////////////////
    

  388. void WriteRawRC(uint8_t   Address, uint8_t   value)
    

  389. {  
    

  390.     uint8_t   ucAddr;
    

  391.         uint8_t tmp;
    


  392. 

  393.         CLR_SPI_CS;
    

  394.     ucAddr = ((Address<<1)&0x7E);
    


  395. 

  396.         SPIWriteByte(ucAddr);
    

  397.         SPIWriteByte(value);
    

  398.         SET_SPI_CS;
    

  399. }
    

  400. /////////////////////////////////////////////////////////////////////
    

  401. //功    能：置RC522寄存器位
    

  402. //参数说明：reg[IN]:寄存器地址
    

  403. //          mask[IN]:置位值
    

  404. /////////////////////////////////////////////////////////////////////
    

  405. void SetBitMask(uint8_t   reg,uint8_t   mask)  
    

  406. {
    

  407.     char   tmp = 0x0;
    

  408.     tmp = ReadRawRC(reg);
    

  409.     WriteRawRC(reg,tmp | mask);  // set bit mask
    

  410. }
    


  411. 

  412. /////////////////////////////////////////////////////////////////////
    

  413. //功    能：清RC522寄存器位
    

  414. //参数说明：reg[IN]:寄存器地址
    

  415. //          mask[IN]:清位值
    

  416. /////////////////////////////////////////////////////////////////////
    

  417. void ClearBitMask(uint8_t   reg,uint8_t   mask)  
    

  418. {
    

  419.     char   tmp = 0x0;
    

  420.     tmp = ReadRawRC(reg);
    

  421.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
    

  422. } 
    


  423. 

  424. /////////////////////////////////////////////////////////////////////
    

  425. //功    能：通过RC522和ISO14443卡通讯
    

  426. //参数说明：Command[IN]:RC522命令字
    

  427. //          pIn [IN]:通过RC522发送到卡片的数据
    

  428. //          InLenByte[IN]:发送数据的字节长度
    

  429. //          pOut [OUT]:接收到的卡片返回数据
    

  430. //          *pOutLenBit[OUT]:返回数据的位长度
    

  431. /////////////////////////////////////////////////////////////////////
    

  432. char PcdComMF522(uint8_t   Command, 
    

  433.                  uint8_t *pIn , 
    

  434.                  uint8_t   InLenByte,
    

  435.                  uint8_t *pOut , 
    

  436.                  uint8_t *pOutLenBit)
    

  437. {
    

  438.     char   status = MI_ERR;
    

  439.     uint8_t   irqEn   = 0x00;
    

  440.     uint8_t   waitFor = 0x00;
    

  441.     uint8_t   lastBits;
    

  442.     uint8_t   n;
    

  443.     uint16_t   i;
    

  444.     switch (Command)
    

  445.     {
    

  446.         case PCD_AUTHENT:
    

  447.                         irqEn   = 0x12;
    

  448.                         waitFor = 0x10;
    

  449.                         break;
    

  450.                 case PCD_TRANSCEIVE:
    

  451.                         irqEn   = 0x77;
    

  452.                         waitFor = 0x30;
    

  453.                         break;
    

  454.                 default:
    

  455.                         break;
    

  456.     }
    

  457.    
    

  458.     WriteRawRC(ComIEnReg,irqEn|0x80);
    

  459.     ClearBitMask(ComIrqReg,0x80);        //清所有中断位
    

  460.     WriteRawRC(CommandReg,PCD_IDLE);
    

  461.     SetBitMask(FIFOLevelReg,0x80);                 //清FIFO缓存
    

  462.     
    

  463.     for (i=0; i<InLenByte; i++)
    

  464.     {   WriteRawRC(FIFODataReg, pIn [i]);    }
    

  465.     WriteRawRC(CommandReg, Command);          
    

  466. //            n = ReadRawRC(CommandReg);
    

  467.     
    

  468.     if (Command == PCD_TRANSCEIVE)
    

  469.     {    SetBitMask(BitFramingReg,0x80);  }         //开始传送
    

  470.                                                                                      
    

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

  472.         i = 2000;
    

  473.     do 
    

  474.     {
    

  475.         n = ReadRawRC(ComIrqReg);
    

  476.         i--;
    

  477.     }
    

  478.     while ((i!=0) && !(n&0x01) && !(n&waitFor));
    

  479.     ClearBitMask(BitFramingReg,0x80);
    


  480. 

  481.     if (i!=0)
    

  482.     {    
    

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

  484.         {
    

  485.             status = MI_OK;
    

  486.             if (n & irqEn & 0x01)
    

  487.             {   status = MI_NOTAGERR;   }
    

  488.             if (Command == PCD_TRANSCEIVE)
    

  489.             {
    

  490.                        n = ReadRawRC(FIFOLevelReg);
    

  491.                       lastBits = ReadRawRC(ControlReg) & 0x07;
    

  492.                 if (lastBits)
    

  493.                 {   *pOutLenBit = (n-1)*8 + lastBits;   }
    

  494.                 else
    

  495.                 {   *pOutLenBit = n*8;   }
    

  496.                 if (n == 0)
    

  497.                 {   n = 1;    }
    

  498.                 if (n > MAXRLEN)
    

  499.                 {   n = MAXRLEN;   }
    

  500.                 for (i=0; i<n; i++)
    

  501.                 {   pOut [i] = ReadRawRC(FIFODataReg);    }
    

  502.             }
    

  503.         }
    

  504.         else
    

  505.         {   status = MI_ERR;   }
    

  506.         
    

  507.     }
    

  508.    
    


  509. 

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

  511.     WriteRawRC(CommandReg,PCD_IDLE); 
    

  512.     return status;
    

  513. }
    


  514. 

  515. /////////////////////////////////////////////////////////////////////
    

  516. //开启天线  
    

  517. //每次启动或关闭天险发射之间应至少有1ms的间隔
    

  518. /////////////////////////////////////////////////////////////////////
    

  519. void PcdAntennaOn(void)
    

  520. {
    

  521.     uint8_t   i;
    

  522.     i = ReadRawRC(TxControlReg);
    

  523.     if (!(i & 0x03))
    

  524.     {
    

  525.         SetBitMask(TxControlReg, 0x03);
    

  526.     }
    

  527. }
    


  528. 


  529. 

  530. /////////////////////////////////////////////////////////////////////
    

  531. //关闭天线
    

  532. /////////////////////////////////////////////////////////////////////
    

  533. void PcdAntennaOff(void)
    

  534. {
    

  535.         ClearBitMask(TxControlReg, 0x03);
    

  536. }
    


  537. 


  538. 

  539. void Reset_RC522(void)
    

  540. {
    

  541.   PcdReset();
    

  542.   PcdAntennaOff();
    

  543.   delay_ms(2);  
    

  544.   PcdAntennaOn();
    

  545. }


7、实验现象

单片机复位后，循环读卡，测试中使用了两张卡

610076227081e06420.gif





回复 赏

举报

相关帖子
huquanz711 发表于 2022-3-8 19:28 来自手机 | 显示全部楼层
可以加解密嘛？
回复 赏

举报

 楼主| freeelectron 发表于 2022-3-8 19:29 | 显示全部楼层
huquanz711 发表于 2022-3-8 19:28
可以加解密嘛？

本帖子，只移植了基础驱动
回复 赏

举报

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

本版积分规则

freeelectron
个人签名：stm32/LoRa物联网：304350312

65

主题

785

帖子

11

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