stm32_RFID_RCC522无线通信

最新推荐文章于 2023-07-25 22:18:27 发布
最新推荐文章于 2023-07-25 22:18:27 发布
阅读量2.7k 收藏 7
点赞数 1
分类专栏： stm32 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhy421955124/article/details/77868274
版权

#include "spi.h"

#include "sys.h" //ϵͳ×Óº¯Êý        
#include "delay.h" //ÑÓʱ×Óº¯Êý
#include "MFRC522.h"

unsigned char CT[2];//¿¨ÀàÐÍ
unsigned char SN[4]; //¿¨ºÅ
unsigned char RFID[16];            //´æ·ÅRFID
u8 KEY[6]={0xff,0xff,0xff,0xff,0xff,0xff};

void test_rf552(void);
int main(void)
{
         SystemInit();
         delay_init(72);         //ÑÓʱ³õʼ»¯
         NVIC_Configuration();    
      InitRc522();
      delay_ms(100);
      
        while(1)
        {    
               //status = PcdRequest(PICC_REQALL,CT);
            test_rf552();
            
        }
}
void test_rf552(void)
{
    u8 status = 0;
    unsigned char s=0x11;
    status = PcdRequest(PICC_REQALL,CT);//寻卡
    if(0 == status)
    {
        status=MI_ERR;
        status = PcdAnticoll(SN);    /防冲撞
    }
    if (status==MI_OK)  /防冲撞成功
    {
        status=MI_ERR;  
        status =PcdSelect(SN);//选卡
    }
    if(status==MI_OK)//选卡成功
    {
        status=MI_ERR;
        status=PcdAuthState(0x60,0x09,KEY,SN);//验证
    }
    if(status==MI_OK)//
    {
        status=MI_ERR;
        status=PcdRead(s,RFID);//读卡
        //status=PcdWrite(s,RFID1);//写卡
    }
    if(status==MI_OK)//读写成功
    {
        status=MI_ERR;
        delay_ms(100);
    }
        
}

RCC522配置函数及其头文件

#include "sys.h"
#include "rc522.h"
#include "delay.h"
#include "string.h"

void delay_ns(u32 ns)
{
  u32 i;
  for(i=0;i<ns;i++)
  {
    __nop();
    __nop();
    __nop();
  }
}

u8 SPIWriteByte(u8 Byte)
{
    while((SPI2->SR&0X02)==0);        //   
    SPI2->DR=Byte;                     //
    while((SPI2->SR&0X01)==0);     
    return SPI2->DR;                  //           
}


u8 SPI2_ReadWriteByte(u8 TxData)
{        
    u8 retry=0;                     
    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位
        {
        retry++;
        if(retry>200)return 0;
        }              
    SPI_I2S_SendData(SPI2, TxData); //发数据
    retry=0;

    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位
        {
        retry++;
        if(retry>200)return 0;
        }                                  
    return SPI_I2S_ReceiveData(SPI2); //返回的数据                     
}



void SPI2_SetSpeed(u8 SPI_BaudRatePrescaler)
{
      assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    SPI2->CR1&=0XFFC7;
    SPI2->CR1|=SPI_BaudRatePrescaler;    //速度设置
    SPI_Cmd(SPI2,ENABLE);

}

void SPI2_Init(void)    
{
    GPIO_InitTypeDef GPIO_InitStructure;
  SPI_InitTypeDef  SPI_InitStructure;
     RCC_APB2PeriphClockCmd(    RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOA, ENABLE );//PORTBʱÖÓʹÄÜ
    RCC_APB1PeriphClockCmd(    RCC_APB1Periph_SPI2,  ENABLE );//SPI2ʱÖÓʹÄÜ

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;     //
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;               //
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;             //
    GPIO_Init(GPIOA, &GPIO_InitStructure);                                 
    GPIO_SetBits(GPIOA,GPIO_Pin_6|GPIO_Pin_7);                           


    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15¸´ÓÃÍÆÍìÊä³ö
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);//³õʼ»¯GPIOB

     GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15ÉÏÀ­

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;       
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;       
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;      
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;   
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;       
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;       
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;   
    SPI_InitStructure.SPI_CRCPolynomial = 7;   
    SPI_Init(SPI2, &SPI_InitStructure);
  MFRC522_CS(1);
    SPI_Cmd(SPI2, ENABLE);
    
    //SPI2_ReadWriteByte(0xff);
}

void InitRc522(void)
{
  SPI2_Init();
  PcdReset();
  PcdAntennaOff();
  delay_ms(2);  
  PcdAntennaOn();
  M500PcdConfigISOType( 'A' );
}
void Reset_RC522(void)
{
  PcdReset();
  PcdAntennaOff();
  delay_ms(2);  
  PcdAntennaOn();
}                         
/

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

//                    0x4400 = Mifare_UltraLight
//                    0x0400 = Mifare_One(S50)
//                    0x0200 = Mifare_One(S70)
//                    0x0800 = Mifare_Pro(X)
//                    0x4403 = Mifare_DESFire

/
char PcdRequest(u8   req_code,u8 *pTagType)
{
    char   status;  
    u8   unLen;
    u8   ucComMF522Buf[MAXRLEN];

    ClearBitMask(Status2Reg,0x08);
    WriteRawRC(BitFramingReg,0x07);
    SetBitMask(TxControlReg,0x03);
 
    ucComMF522Buf[0] = req_code;

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

    if ((status == MI_OK) && (unLen == 0x10))
    {    
        *pTagType     = ucComMF522Buf[0];
        *(pTagType+1) = ucComMF522Buf[1];
    }
    else
    {   status = MI_ERR;   }
   
    return status;
}

/
//防撞卡

/  
char PcdAnticoll(u8 *pSnr)
{
    char   status;
    u8   i,snr_check=0;
    u8   unLen;
    u8   ucComMF522Buf[MAXRLEN];

      ClearBitMask(Status2Reg,0x08);
    WriteRawRC(BitFramingReg,0x00);
    ClearBitMask(CollReg,0x80);
    ucComMF522Buf[0] = PICC_ANTICOLL1;
    ucComMF522Buf[1] = 0x20;
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);
    if (status == MI_OK)
    {
         for (i=0; i<4; i++)
         {   
             *(pSnr+i)  = ucComMF522Buf[i];
             snr_check ^= ucComMF522Buf[i];
         }
         if (snr_check != ucComMF522Buf[i])
         {   status = MI_ERR;    }
    }   
    SetBitMask(CollReg,0x80);
    return status;
}

/
//选卡

/
char PcdSelect(u8 *pSnr)
{
    char   status;
    u8   i;
    u8   unLen;
    u8   ucComMF522Buf[MAXRLEN];
    
    ucComMF522Buf[0] = PICC_ANTICOLL1;
    ucComMF522Buf[1] = 0x70;
    ucComMF522Buf[6] = 0;
    for (i=0; i<4; i++)
    {
        ucComMF522Buf[i+2] = *(pSnr+i);
        ucComMF522Buf[6]  ^= *(pSnr+i);
    }
    CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
 
    ClearBitMask(Status2Reg,0x08);

    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
    
    if ((status == MI_OK) && (unLen == 0x18))
    {   status = MI_OK;  }
    else
    {   status = MI_ERR;    }

    return status;
}

/
//验证卡
// auth_mode[IN]: 密码验证模式
//                 0x60 = 验证A
//                 0x61 =验证B
//          addr[IN]块地址
//          pKey[IN]密码
//          pSnr[IN]卡序列号4字节
/               
char PcdAuthState(u8   auth_mode,u8   addr,u8 *pKey,u8 *pSnr)
{
    char   status;
    u8   unLen;
    u8   i,ucComMF522Buf[MAXRLEN];

    ucComMF522Buf[0] = auth_mode;
    ucComMF522Buf[1] = addr;
//    for (i=0; i<6; i++)
//    {    ucComMF522Buf[i+2] = *(pKey+i);   }
//    for (i=0; i<6; i++)
//    {    ucComMF522Buf[i+8] = *(pSnr+i);   }
    memcpy(&ucComMF522Buf[2], pKey, 6);
    memcpy(&ucComMF522Buf[8], pSnr, 4);
    
    status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
    if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
    {   status = MI_ERR;   }
    
    return status;
}

/
//读卡
/
char PcdRead(u8   addr,u8 *p )
{
    char   status;
    u8   unLen;
    u8   i,ucComMF522Buf[MAXRLEN];

    ucComMF522Buf[0] = PICC_READ;
    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
   
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
    if ((status == MI_OK) && (unLen == 0x90))
 //   {   memcpy(p , ucComMF522Buf, 16);   }
    {
        for (i=0; i<16; i++)
        {    *(p +i) = ucComMF522Buf[i];   }
    }
    else
    {   status = MI_ERR;   }
    
    return status;
}

/

//写卡addr[IN]：地址

//p [IN]：数据
/                  
char PcdWrite(u8   addr,u8 *p )
{
    char   status;
    u8   unLen;
    u8   i,ucComMF522Buf[MAXRLEN];
    
    ucComMF522Buf[0] = PICC_WRITE;
    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
 
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    {   status = MI_ERR;   }
        
    if (status == MI_OK)
    {
        //memcpy(ucComMF522Buf, p , 16);
        for (i=0; i<16; i++)
        {    
            ucComMF522Buf[i] = *(p +i);   
        }
        CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);

        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
        if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
        {   status = MI_ERR;   }
    }
    
    return status;
}

/
//休眠

/
char PcdHalt(void)
{
    u8   status;
    u8   unLen;
    u8   ucComMF522Buf[MAXRLEN];

    ucComMF522Buf[0] = PICC_HALT;
    ucComMF522Buf[1] = 0;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
 
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

    return MI_OK;
}

/
//计算函数
/
void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut )
{
    u8   i,n;
    ClearBitMask(DivIrqReg,0x04);
    WriteRawRC(CommandReg,PCD_IDLE);
    SetBitMask(FIFOLevelReg,0x80);
    for (i=0; i<len; i++)
    {   WriteRawRC(FIFODataReg, *(pIn +i));   }
    WriteRawRC(CommandReg, PCD_CALCCRC);
    i = 0xFF;
    do
    {
        n = ReadRawRC(DivIrqReg);
        i--;
    }
    while ((i!=0) && !(n&0x04));
    pOut [0] = ReadRawRC(CRCResultRegL);
    pOut [1] = ReadRawRC(CRCResultRegM);
}

/
//复位
/
char PcdReset(void)
{
    //PORTD|=(1<<RC522RST);

  MFRC522_Rst(1);
    
    delay_ns(10);
    //PORTD&=~(1<<RC522RST);
    MFRC522_Rst(0);
    
    delay_ns(10);
    //PORTD|=(1<<RC522RST);
    MFRC522_Rst(1);
    delay_ns(10);
    WriteRawRC(CommandReg,PCD_RESETPHASE);
    WriteRawRC(CommandReg,PCD_RESETPHASE);
    delay_ns(10);
    
    WriteRawRC(ModeReg,0x3D);            //ºÍMifare¿¨Í¨Ñ¶£¬CRC³õʼֵ0x6363
    WriteRawRC(TReloadRegL,30);           
    WriteRawRC(TReloadRegH,0);
    WriteRawRC(TModeReg,0x8D);
    WriteRawRC(TPrescalerReg,0x3E);
    
    WriteRawRC(TxAutoReg,0x40);//±ØÐëÒª
   
    return MI_OK;
}
//
//工作方式
//
char M500PcdConfigISOType(u8   type)
{
   if (type == 'A')                     //ISO14443_A
   {
       ClearBitMask(Status2Reg,0x08);
       WriteRawRC(ModeReg,0x3D);//3F
       WriteRawRC(RxSelReg,0x86);//84
       WriteRawRC(RFCfgReg,0x7F);   //4F
          WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
             WriteRawRC(TReloadRegH,0);
       WriteRawRC(TModeReg,0x8D);
         WriteRawRC(TPrescalerReg,0x3E);
         delay_ns(1000);
       PcdAntennaOn();
   }
   else{ return 1; }
   
   return MI_OK;
}
/
//读寄存器地址 Address[IN]

//返回读出的值
/
u8 ReadRawRC(u8   Address)
{
    u8   ucAddr;
    u8   ucResult=0;
    
    MFRC522_CS(0);
    ucAddr = ((Address<<1)&0x7E)|0x80;
    
    SPIWriteByte(ucAddr);
    ucResult=SPIReadByte();
    MFRC522_CS(1);
   return ucResult;
}

/
//写寄存器地址 Address[IN]//返回写的值
/
void WriteRawRC(u8   Address, u8   value)
{  
    u8   ucAddr;
//    u8 tmp;

    MFRC522_CS(0);
    ucAddr = ((Address<<1)&0x7E);

    SPIWriteByte(ucAddr);
    SPIWriteByte(value);
    MFRC522_CS(1);

//    tmp=ReadRawRC(Address);
//
//    if(value!=tmp)
//        printf("wrong\n");
}
/
//置寄存器位
/
void SetBitMask(u8   reg,u8   mask)  
{
    char   tmp = 0x0;
    tmp = ReadRawRC(reg);
    WriteRawRC(reg,tmp | mask);  // set bit mask
}

/
//¹¦    ÄÜ£ºÇåRC522¼Ä´æÆ÷λ
//²ÎÊý˵Ã÷£ºreg[IN]:¼Ä´æÆ÷µØÖ·
//          mask[IN]:Çåλֵ
/
void ClearBitMask(u8   reg,u8   mask)  
{
    char   tmp = 0x0;
    tmp = ReadRawRC(reg);
    WriteRawRC(reg, tmp & ~mask);  // clear bit mask
}

/
//RCC和卡通信

//Command[IN]命令

// pIn [IN]数据

//InLenByte[IN]长度

//pOut [OUT]接收到卡返回的数据

//*pOutLenBit[OUT]返回的长度

/
char PcdComMF522(u8   Command,
                 u8 *pIn ,
                 u8   InLenByte,
                 u8 *pOut ,
                 u8 *pOutLenBit)
{
    char   status = MI_ERR;
    u8   irqEn   = 0x00;
    u8   waitFor = 0x00;
    u8   lastBits;
    u8   n;
    u16   i;
    switch (Command)
    {
        case PCD_AUTHENT:
            irqEn   = 0x12;
            waitFor = 0x10;
            break;
        case PCD_TRANSCEIVE:
            irqEn   = 0x77;
            waitFor = 0x30;
            break;
        default:
            break;
    }
   
    WriteRawRC(ComIEnReg,irqEn|0x80);
    ClearBitMask(ComIrqReg,0x80);    //ÇåËùÓÐÖжÏλ
    WriteRawRC(CommandReg,PCD_IDLE);
    SetBitMask(FIFOLevelReg,0x80);         //ÇåFIFO»º´æ
    
    for (i=0; i<InLenByte; i++)
    {   WriteRawRC(FIFODataReg, pIn [i]);    }
    WriteRawRC(CommandReg, Command);      
//        n = ReadRawRC(CommandReg);
    
    if (Command == PCD_TRANSCEIVE)
    {    SetBitMask(BitFramingReg,0x80);  }     //¿ªÊ¼´«ËÍ
                                            
    //i = 600;//¸ù¾ÝʱÖÓƵÂʵ÷Õû£¬²Ù×÷M1¿¨×î´óµÈ´ýʱ¼ä25ms
    i = 2000;
    do
    {
        n = ReadRawRC(ComIrqReg);
        i--;
    }
    while ((i!=0) && !(n&0x01) && !(n&waitFor));
    ClearBitMask(BitFramingReg,0x80);

    if (i!=0)
    {    
        if(!(ReadRawRC(ErrorReg)&0x1B))
        {
            status = MI_OK;
            if (n & irqEn & 0x01)
            {   status = MI_NOTAGERR;   }
            if (Command == PCD_TRANSCEIVE)
            {
                   n = ReadRawRC(FIFOLevelReg);
                  lastBits = ReadRawRC(ControlReg) & 0x07;
                if (lastBits)
                {   *pOutLenBit = (n-1)*8 + lastBits;   }
                else
                {   *pOutLenBit = n*8;   }
                if (n == 0)
                {   n = 1;    }
                if (n > MAXRLEN)
                {   n = MAXRLEN;   }
                for (i=0; i<n; i++)
                {   pOut [i] = ReadRawRC(FIFODataReg);    }
            }
        }
        else
        {   status = MI_ERR;   }
        
    }
   

    SetBitMask(ControlReg,0x80);           // stop timer now
    WriteRawRC(CommandReg,PCD_IDLE);
    return status;
}

/
//启动天线

//1m的间隔

/
void PcdAntennaOn(void)
{
    u8   i;
    i = ReadRawRC(TxControlReg);
    if (!(i & 0x03))
    {
        SetBitMask(TxControlReg, 0x03);
    }
}


/
//关闭天线
/
void PcdAntennaOff(void)
{
    ClearBitMask(TxControlReg, 0x03);
}


头文件:


/
//MF522ÃüÁî×Ö
/
#define PCD_IDLE              0x00               //È¡Ïûµ±Ç°ÃüÁî
#define PCD_AUTHENT           0x0E               //ÑéÖ¤ÃÜÔ¿
#define PCD_RECEIVE           0x08               //½ÓÊÕÊý¾Ý
#define PCD_TRANSMIT          0x04               //·¢ËÍÊý¾Ý
#define PCD_TRANSCEIVE        0x0C               //·¢ËͲ¢½ÓÊÕÊý¾Ý
#define PCD_RESETPHASE        0x0F               //¸´Î»
#define PCD_CALCCRC           0x03               //CRC¼ÆËã

/
//Mifare_One¿¨Æ¬ÃüÁî×Ö
/
#define PICC_REQIDL           0x26               //Ñ°ÌìÏßÇøÄÚδ½øÈëÐÝÃß״̬
#define PICC_REQALL           0x52               //Ñ°ÌìÏßÇøÄÚÈ«²¿¿¨
#define PICC_ANTICOLL1        0x93               //·À³åײ
#define PICC_ANTICOLL2        0x95               //·À³åײ
#define PICC_AUTHENT1A        0x60               //ÑéÖ¤AÃÜÔ¿
#define PICC_AUTHENT1B        0x61               //ÑéÖ¤BÃÜÔ¿
#define PICC_READ             0x30               //¶Á¿é
#define PICC_WRITE            0xA0               //д¿é
#define PICC_DECREMENT        0xC0               //¿Û¿î
#define PICC_INCREMENT        0xC1               //³äÖµ
#define PICC_RESTORE          0xC2               //µ÷¿éÊý¾Ýµ½»º³åÇø
#define PICC_TRANSFER         0xB0               //±£´æ»º³åÇøÖÐÊý¾Ý
#define PICC_HALT             0x50               //ÐÝÃß

/
//MF522 FIFO³¤¶È¶¨Òå
/
#define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
#define MAXRLEN  18

/
//MF522¼Ä´æÆ÷¶¨Òå
/
// PAGE 0
#define     RFU00                 0x00    
#define     CommandReg            0x01    
#define     ComIEnReg             0x02    
#define     DivlEnReg             0x03    
#define     ComIrqReg             0x04    
#define     DivIrqReg             0x05
#define     ErrorReg              0x06    
#define     Status1Reg            0x07    
#define     Status2Reg            0x08    
#define     FIFODataReg           0x09
#define     FIFOLevelReg          0x0A
#define     WaterLevelReg         0x0B
#define     ControlReg            0x0C
#define     BitFramingReg         0x0D
#define     CollReg               0x0E
#define     RFU0F                 0x0F
// PAGE 1     
#define     RFU10                 0x10
#define     ModeReg               0x11
#define     TxModeReg             0x12
#define     RxModeReg             0x13
#define     TxControlReg          0x14
#define     TxAutoReg             0x15
#define     TxSelReg              0x16
#define     RxSelReg              0x17
#define     RxThresholdReg        0x18
#define     DemodReg              0x19
#define     RFU1A                 0x1A
#define     RFU1B                 0x1B
#define     MifareReg             0x1C
#define     RFU1D                 0x1D
#define     RFU1E                 0x1E
#define     SerialSpeedReg        0x1F
// PAGE 2    
#define     RFU20                 0x20  
#define     CRCResultRegM         0x21
#define     CRCResultRegL         0x22
#define     RFU23                 0x23
#define     ModWidthReg           0x24
#define     RFU25                 0x25
#define     RFCfgReg              0x26
#define     GsNReg                0x27
#define     CWGsCfgReg            0x28
#define     ModGsCfgReg           0x29
#define     TModeReg              0x2A
#define     TPrescalerReg         0x2B
#define     TReloadRegH           0x2C
#define     TReloadRegL           0x2D
#define     TCounterValueRegH     0x2E
#define     TCounterValueRegL     0x2F
// PAGE 3      
#define     RFU30                 0x30
#define     TestSel1Reg           0x31
#define     TestSel2Reg           0x32
#define     TestPinEnReg          0x33
#define     TestPinValueReg       0x34
#define     TestBusReg            0x35
#define     AutoTestReg           0x36
#define     VersionReg            0x37
#define     AnalogTestReg         0x38
#define     TestDAC1Reg           0x39  
#define     TestDAC2Reg           0x3A   
#define     TestADCReg            0x3B   
#define     RFU3C                 0x3C   
#define     RFU3D                 0x3D   
#define     RFU3E                 0x3E   
#define     RFU3F                    0x3F

/
//ºÍMF522ͨѶʱ·µ»ØµÄ´íÎó´úÂë
/
#define     MI_OK                 0
#define     MI_NOTAGERR           (1)
#define     MI_ERR                (2)

#define    SHAQU1    0X01
#define    KUAI4    0X04
#define    KUAI7    0X07
#define    REGCARD    0xa1
#define    CONSUME    0xa2
#define READCARD    0xa3
#define ADDMONEY    0xa4

//
//#define  spi_cs 1;
//sbit  spi_ck=P0^6;
//sbit  spi_mosi=P0^7;
//sbit  spi_miso=P4^1;
//sbit  spi_rst=P2^7;
#define SPIReadByte()    SPIWriteByte(0)
u8 SPIWriteByte(u8 byte);
void SPI2_Init(void);


#define MFRC522_CS(x) x ? GPIO_SetBits(GPIOA,GPIO_Pin_6):GPIO_ResetBits(GPIOA,GPIO_Pin_6)
#define MFRC522_Rst(x) x ? GPIO_SetBits(GPIOA,GPIO_Pin_7):GPIO_ResetBits(GPIOA,GPIO_Pin_7)

void InitRc522(void);
void ClearBitMask(u8   reg,u8   mask);
void WriteRawRC(u8   Address, u8   value);
void SetBitMask(u8   reg,u8   mask);
char PcdComMF522(u8   Command,
                 u8 *pIn ,
                 u8   InLenByte,
                 u8 *pOut ,
                 u8  *pOutLenBit);
void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut );
u8 ReadRawRC(u8   Address);
void PcdAntennaOn(void);

char PcdReset(void);
char PcdRequest(unsigned char req_code,unsigned char *pTagType);
void PcdAntennaOn(void);
void PcdAntennaOff(void);
char M500PcdConfigISOType(unsigned char type);
char PcdAnticoll(unsigned char *pSnr);
char PcdSelect(unsigned char *pSnr);
char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr);
char PcdWrite(unsigned char addr,unsigned char *pData);
char PcdRead(unsigned char addr,unsigned char *pData);
char PcdHalt(void);
void Reset_RC522(void);









fluffy_floppy
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RCC.zip_stm32 rcc
09-20
STM32实时时钟的应用改进，设置。变编译通过
STM32-RCC.rar_RCC_stm32 rcc
09-21
STM32x系统时钟的详细介绍，对新人理解STM32的时钟系统有着很大帮助。
RC522-RFID读卡器.rar_51 keil4_rcc522读s50 扇区_rfid_rfid-rc522_rfid-rc
09-23
rfid-rc522测试程序，可识别唯一的s50钥匙扣，使用者可以在上面进行修改
RCC.rar_RCC_STM32F103 rcc
09-24
基于CORTEX-M3内核STM32F103平台的RCC模块控制程序
RC522和51通信的资料
07-27
51和RC522通信代码
RCC522中英文参考手册及例程
01-28
RCC522中英文参考手册及例程，应该是最全的手册了
RT thread studio ---RCC522门禁卡使用
qq_41121877的博客
05-11 2264
1、前言 编译工具：RT thread studio 2.1.0 控制芯片：STM32F103RCT6 IC卡：RC522 RT thread studio上的软件包貌似有问题，导入之后没办法使用，因此在网上参考了一些例程，在此总结一下该模块的调试过程，参考博客：https://blog.csdn.net/junzia/article/details/102224285 a、该卡分为16个扇区，每个扇区有4块（块0、块1、块2、块3）组成； b、将所有的块按绝对位置编号为0~63，其中编号0
RCC522模块的读写方法
weixin_44077714的博客
03-30 1376
关于RCC522对复旦卡进行读写的操作步骤 首先了解复旦卡的存储结构。复旦卡有16个扇区，每一个扇区又被分为4个数据块。 扇区0是固化的，用来存储复旦卡的编码，这是不可改写的，只可读。 其他15个扇区都是可读写。 对于每一个扇区来说，前三个的块都是数据块，最后一块是控制块，存储密码A、存取控制和密码B。如果想要读写复旦卡，需要验证控制块的密码。 其中第0扇区的块0是用于存放厂商代码的，已经固化，不可更改，为32位（4Bytes）； 每个扇区的块0、块1和块2位数据块，可用于存储数据，每块16
基础篇010.2 STM32驱动RC522 RFID模块之二：STM32硬件SPI驱动RC522
qcmyqcmy的专栏
05-28 7149
STM32驱动RC522 RFID模块之二：STM32硬件SPI驱动RC522。 驱动程序设计时，必须的顺序是：寻卡--->防冲撞--->选卡--->开天线--->读/写卡。主函数的编写必须要按照这样的顺序，否者设备不会工作。 本实验是由门禁项目修改而来，为方便分析RC522读取到的数据，利用串口通信助手来检查是否读取到正确的数据。
【MFRC522】STM32 MFRC522 IC读卡 程序及原理图
热门推荐
cxw312864660的博客
04-18 3万+
【RC522芯片简介】 MF RC522是应用于13.56MHz非接触式通信中高集成度的读写卡芯片，是NXP公司针对“三表”应用推出的一款低电压、低成本、体积小的非接触式读写卡芯片，是智能仪表和便携式手持设备研发的较好选择。 MF RC522利用了先进的调制和解调概念，完全集成了在13.56MHz下所有类型的被动非接触式通信方式和协议。支持14443A兼容应答器信号。数字部分处理...
RCC系统时钟_RCC系统时钟_RCC_stm32_
10-02
stm32f10x，RCC系统时钟配置，完成工程范例
005_STM32程序移植之_RC522读卡模块
08-24
视频演示地址：https://v.youku.com/v_show/id_XMzc3MTcyNjE4MA==.html?spm=a2h1n.8251843.playList.5!6~5~A&f=51844923&o=1
基于RFID-RC522的智能门锁设计
最新发布
LuChengjie_的博客
07-25 1040
RFID工程主要是两个硬件， 一个是读卡器（带引脚的芯片），另一个是卡片，没有引脚。通信过程一般为MCU---------->读卡器--------->卡片，卡片可以回传数据给读卡器，由于读卡器本身没有对我们需要的数据进行处理的能力，此时需要给他外接一个大脑，即MCU，用来处理和加工我们需要的信息。上图片：
STM32--RFID无线射频技术（RC522刷卡模块）
y黎好好
04-11 2万+
STM32+RC522刷卡模块，亲测可用！！！
RFID射频识别
飘飘仙儿__的博客
04-13 2157
MFRC522是高度集成的非接触式（13.56MHz）读写卡芯片。此芯片利用调制和解调的原理，并将它们完全集成到各种非接触式通信方法和协议中。MFRC522的内部发送器部分可驱动读写器天线与ISO14443A/MIFARE卡和应答机的通信，无需其它的电路。接收器部分提供一个功能强大和高效的解调和译码电路，用来处理兼容ISO14443A/MIFARE卡和应答机的信号。 RC522支持SPI、I2C...
STM32—驱动RFID-RC522模块
肥宅快乐博客
02-10 2万+
文章目录一.S50（M1）卡介绍1.S50（M1）卡基础知识2.内部信息3.存取控制4.数据块的存取控制5.控制块的存取控6.工作原理7.M1与读卡器的通信 一.S50（M1）卡介绍 1.S50（M1）卡基础知识 1.每张卡有唯一的序列号，32位 2.卡的容量是8Kbit的EEPROM 3.分为16个扇区，每个扇区分为4块，每块16个字节，以块为存取单位 4.每个扇区都有独立的一组密码和访问控制 ...
STM32F407使用MFRC522射频卡调试及程序移植成功
Kevin_8_Lee的博客
03-28 8655
基于STM32的MFRC522射频卡模块使用 移植MFRC522程序到STM32 本学期感测技术选修课需要做一个作品出来，用到了MFRC522射频卡模块，经历一个星期的调试，终于可以正常使用了。 成功的把C51的程序移植到了STM32上面。 现在分享一下调试过程 1、操作环境 我所使用的是STM32F407的开发板，使用STM32CubeMX配置初始代码。 MFRC522使用软件模拟SPI通信 2、 关于引脚的配置 淘...
STM32CubeMX(13)——SPI时序读写RFID-RC522
lzzzzzzm的博客
09-18 1万+
STM32 Cubemax(十三) ——SPI时序读写RFID-RC522 目录 STM32 Cubemax(十三) ——SPI时序读写RFID-RC522 前言 一、SPI时序通信 二、模块接线 三.Cubemax配置 四.核心代码 延时函数 写RC522寄存器 读RC522寄存器 复位RC522 使用代码 1.复位 2.寻卡并得到其序列号 总结 前言 用RFID来学习一下SPI，本次实验使用的是如下这款，在某宝随便搜索RC522即可。 整篇文章较长，手把手从说明.
SPI通信(SPI1主机与SPI2从机)
我爱你Max
09-06 1万+
芯片型号stm32f103 主机采用spi1，从机spi2，中断接收测试 主机配置函数： #include "spi.h" void SPI1_Init(void) {         NVIC_InitTypeDef NVIC_InitStructure;     GPIO_InitTypeDef  GPIO_InitStructure;     SPI_InitTypeDe
stm32f103c8t6与rcc522接线
06-10
以下是stm32f103c8t6与rcc522的接线方式： RCC522模块 STM32F103C8T6开发板 SDA PB7 SCK PB6 MOSI PB5 MISO PB4 IRQ 不接 GND GND RST PB8 3.3V 3.3V 需要注意的是，接线时要注意引脚的对应关系，以及共地连接。同时，需要在代码中配置相应的引脚为SPI模式，并配置对应的SPI参数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值