读卡芯片RC531驱动程序

最新推荐文章于 2021-05-23 05:50:25 发布
最新推荐文章于 2021-05-23 05:50:25 发布
阅读量3k 收藏 4
点赞数 1
分类专栏： 嵌入式

原文地址：读卡芯片RC531驱动程序 作者：嵌入宝贝

 

RC.h头文件，主要是RC531命令及结构体内如如下：

 

#ifndef _RC_H
#define _RC_H

#ifndef uchar
#define uchar unsigned char
#endif

#ifndef uint
#define uint unsigned int
#endif

 


//常量定义
#define FALSE 0
#define TRUE 1

 

//spi通信端口宏
#define RC531_IRQ  0
#define RC531_PD   1
#define RC531_CS  2
#define RC531_MOSI  3
#define RC531_MISO  4
#define RC531_CLK  5


#define RC531_CS_LOW()    {PORTB&=~(1<<RC531_CS);}
#define RC531_CS_HIGN()   {PORTB|=(1<<RC531_CS);}

#define RC531_CLK_LOW()  {PORTB&=~(1<<RC531_CLK);}
#define RC531_CLK_HIGN() {PORTB|=(1<<RC531_CLK);}

#define RC531_data()  {PINB&(1<<RC531_MISO);}

#define RC531_UP()  {PORTB|=(1<<RC531_PD);}
#define RC531_DOWN()  {PORTB&=~(1<<RC531_PD);}

 


//卡的命令
#define PICC_REQSTD      0x26

#define PICC_REQALL     0x52

#define PICC_HALT     0x50
 
#define PICC_ANTICOLL1  0x93

#define PICC_ANTICOLL2   0x95

#define PICC_ANTICOLL3 0x97

#define  PICC_AUTHENT1B   0x61

#define PICC_AUTHENT1A 0x60

#define PICC_READ    0x30

#define PICC_WRITE      0xA0


//RF531 set of commands
#define StartUp  0x3f
#define CmdIdle     0x00
#define Transmit  0x1a
#define Receive     0x16
#define CmdTransceive  0x1e
#define WritE2      0x01
#define ReadE2      0x03
#define CmdLoadKeyE2 0x0b
#define CmdLoadKey  0x19
#define CmdAuthent1 0x0c
#define CmdAuthent2 0x14
#define LoadConfig 0x07
#define CalcCRC  0x12


#define RF_TimeOut 0xfff  //发送命令延时时间
#define Req       0x01  
#define Sel       0x02


//RF531状态宏
#define FIFO_FULL ((PrimaryStatus&0x02)==1?,1：0）
#define FIFO_EMPTY ((PrimaryStatus&0x01)==1?,1:0)
#define PICC_DECREMENT  0xC0    //;decrement value
#define PICC_INCREMENT  0xC1    //;increment value
#define PICC_RESTORE    0xC2    //;restore command code
#define  PICC_TRANSFER   0xB0   // ;transfer command code
#define  PICC_HALT       0x50   // ;halt


//RF531  set of Registers addresses

#define RegPage  0x00
#define RegCommand   0x01
#define RegFIFOData   0x02
#define RegPrimaryStatus 0x03

#define SecondaryStatus 0x05

#define Int_Req      0x07
#define SPILevel  0x08
#define RegFIFOLevel  0x29
#define RegFIFOLength  0x04

 
#define RegControl      0x09
#define RegErrorFlag    0x0a

#define CollPos   0x0b
#define TimeValue  0x0c
#define RegCRCResuletLSB 0x0d
#define CRCResuletMSB 0x0e
#define RegBitFraming  0x0f
#define RegCRCPresetLSB 0x23 
#define RegCwConductance   0x12
#define RegModConductance 0x13
#define RegRxWait   0x21
#define MFOUTSelect     0x26
#define RegChannelRedundancy 0x22
#define RegTimerClock  0x2a
#define RegTimerControl 0x2b
#define RegTimerReload  0x2c
#define RegInterruptEn  0x06
#define RegTxControl  0x11
#define TypeSH   0x31
#define RegCoderControl   0x14
#define TypeBFraming 0x17
#define RegDecoderControl 0x1a
#define RegClockQControl 0x1f
#define RegBitPhase 0x1B
#define RegRxThreshhold 0x1c
#define RegRxControl1  0x19    
#define RegModWidth  0x15
#define RegBPSKDemControl  0x1d
#define RegIRqPinConfig 0x2D
#define RegCWConductance 0x12
#define RegRxControl2  0x1e
#define RegCRCPresetMSB     0x24
//卡片类型定义
#define TYPEA_MODE 0      //TYPEA模式
#define TYPEB_MODE 1      //TYPEB模式
#define SHANGHAI_MODE 2   //上海模式

//射频卡通信命令码定义
#define RF_CMD_REQUEST_STD 0x26
#define RF_CMD_REQUEST_ALL 0x52
#define RF_CMD_ANTICOL    0x93
#define RF_CMD_SELECT    0x93
#define RF_CMD_AUTH_LA    0x60
#define RF_CMD_AUTH_LB    0x61
#define RF_CMD_READ     0x30
#define RF_CMD_WRITE    0xa0
#define RF_CMD_INC     0xc1
#define RF_CMD_DEC     0xc0
#define RF_CMD_RESTORE    0xc2
#define RF_CMD_TRANSFER    0xb0
#define RF_CMD_HALT     0x50

//Status Value
#define  ALL   0x01
#define  KEYA  0x04
#define  KEYB  0x00
#define  _AB   0x40
#define  CRC_A 1
#define  CRC_B 2

#define  CEC_OK  0
#define  CRC_ERR 1

#define  BCC_OK   0
#define  BCC_ERR  1

 

//
#define MIFARE_8K  0 //MIFARE系列8K卡片
#define MIFARE_TOKEN 1 //MIFARE系列1KTOKEN卡片
#define SHANGHAI_8K  2 //上海标准系列8K卡片
#define SHANGHAI_TOKEN 3 // 上海标准系列1KTOKEN卡片

 

//
#define RC_531_OK     0     //正确
#define RC_531_NOTAGERR   1     //无卡
#define RC_531_CRCERR   2     //卡片CRC校验错误
#define RC_531_EMPTY   3      //数值溢出错误
#define RC_531_AUTHERR   4     //验证不成功
#define RC_531_PARITYERR   5     //卡片奇偶校验错误
#define RC_531_CODEERR   6     //通信错误（BCC）校验错误
#define RC_531_SERNRERR   8     //卡片序列号错误（anti-collison错误）
#define RC_531_SELECTERR  9     //卡片数据长度字节错（SELECT错误）
#define RC_531_NOTAUTHERR  10     //卡片没有通过验证
#define RC_531_BITCOUNTERR   11    //从卡片接受到的位数错误
#define RC_531_BYTECOUNTERR    12    //从卡片接受到的字节错误（仅读函数有效）
#define RC_531_RESTERR   13   //调用restore函数错误
#define RC_531_TRANSERR   14   //调用transfer函数错误
#define RC_531_WRITEERR   15   //调用write函数错误
#define RC_531_INCRERR   16   //调用increment函数错误
#define RC_531_DECRERR   17   //调用decrement函数错误
#define RC_531_READERR   18   //调用resad函数错误
#define RC_531_LOADKEYERR  19   //调用LOADKEY函数错误
#define RC_531_FRAMINGERR  20     //RC_531桢错误
#define RC_531_REQERR   21   //调用req函数错误
#define RC_531_SELERR   22   //调用sel函数错误
#define RC_531_ANTICOLLERR  23   //调用anticoll函数错误
#define RC_531_INTIVALERR  24   //调用初始化函数错误
#define RC_531_READVALERR  25   //调用高级读块值函数错误
#define RC_531_DESELECTERR  26   
#define RC_531_CMD_ERR   42   //命令错误

 

//RF531 set of hanshu
extern void init_port(void);
extern uchar init_RF531(uchar);
extern void  SPI_send(uchar temp);
extern uchar SPI_receive();
extern void SPI_write_byte(uchar address,uchar content);
extern uchar SPI_read_byte(uchar address);
extern void rf_reset();
extern void rf_reg_init();
extern void typeA_init(void);
extern void uart_proc();
extern void RequestA();  //;TYPE A卡卡请求RequestA命令
extern void  Anticollision();  //;TYPE A卡防冲突Anticollision命令
extern void Select();     //;TYPE A卡选择卡Select命令
extern void CheckEEPROM();   //;TYPE A卡验证EEPROM密码命令
extern void  CheckUser();    //;TYPE A卡验证User密码命令
extern void  ReadTypeA();  //;TYPE A卡读卡命令
extern void  WriteTypeA();   //;TYPE A卡写卡命令
extern void  DecTypeA(); //;TYPE A卡钱包减命令
extern void  IncTypeA();   //;TYPE A卡钱包加命令
extern void  TranTypeA();   //;TYPE A卡Transfer命令
extern void  HaltTypeA(); //;TYPE A卡Halt命令
extern void  RestroeTypeA();  //;TYPE A卡Restore命令
extern void  ReadRC531();   // ;读读卡芯片寄存器
extern void  WriteRC531();   // ;写读卡芯片寄存器
extern void  ToTypeA();  // ;打开射频信号并设成TYPE A方式
  //case 0x0f: ToTypeB();break;   //;打开射频信号并设成TYPE B方式
extern void  Close();   //;关掉射频信号


#endif

 

RC531.C源文件，TypeA，TypeB读卡驱动代码如下：

内部包含SPI协议驱动代码。

 

#include "includes.h"

#include "uart.h"

#include "RC.h"

extern void SetTimerOut(uchar);

void init_port()
{  
   
    SFIOR=0x00;

    PORTB=0x17;
    
    DDRB=0x2e;

    SPCR=0x50;//SPI中断不允许,msb先移出,主机模式,sck闲置时为低,sck时钟下降沿采样,spi的f=fosc/4

    SPSR=0x00;

}


//spi 发送一个字节函数
void  SPI_send(uchar temp)
{
  
 SPDR=temp;

 while(!(SPSR&(1<<7)));

 return;

}

uchar SPI_receive()
{
 
 SPDR=0x00;

 while(!(SPSR&(1<<7))); 

 return SPDR;
}


uchar SPI_read_byte(uchar address)
{

 uchar temp;
 
 RC531_CS_LOW();

 address<<=1;

 address|=0x80;

 address&=0xfe;
  

 SPI_send(address);

 temp=SPI_receive();
 
 RC531_CS_HIGN();

 return temp;
 
}
void SPI_write_byte(uchar address,uchar content)
{

 //地址必须满足要求

 address<<=1;

 address&=0x7f;

 RC531_CS_LOW();

         __delay_cycles(40680);

 SPI_send(address);

 SPI_send(content);

 RC531_CS_HIGN();

 return;

 
}

void rf_reset()
{
 
        uchar temp;

 RC531_UP();
       
        __delay_cycles(40680);
 
 RC531_DOWN();

 //_delay_ms(3.0);      
        //保证ＲＣ５３１正确复位
      
       
         __delay_cycles(40680);

 SPI_write_byte(RegPage,0x00);
  
 nPubTime=40;

 TIMSK=0x01;  //定时器0中断允许
       
        temp=5;

 while(nPubTime>=5)

 {
  temp=SPI_read_byte(RegCommand);


  if(temp==0x00)
   
  {
                       
   TIMSK=0x00;   //再次禁止定时器0中断
 
   return;
  }

 }


 return; 

}



void FlushFIFO()
{
 
        uchar temp;

 temp=SPI_read_byte(RegControl);

 temp|=0x01;
 
 SPI_write_byte(RegControl,temp);

 //_delay_us(100.0);
       
        __delay_cycles(1356);

 
}



void rf_reg_init()
{  
 

       uchar temp;
      
 SPI_write_byte(RegPage,0x00); 
       
 SPI_write_byte(RegClockQControl,0x47);
  

 //_delay_us(100.0);//wait approximately 100 us - calibration in progress
        __delay_cycles(1356);

 // RCALL ClearBitMask // clear bit ClkQCalib for further calibration
 temp=SPI_read_byte(RegClockQControl);

 temp&=0xbf;

 SPI_write_byte(RegClockQControl,temp);

 //ADD：1B      initialize bit phase，定义接收和发送的相位关系 
 SPI_write_byte(RegBitPhase,0xad);
      

 //ADD：1C      initialize minlevel，定义能分辨的最小信号强度 
 SPI_write_byte(RegRxThreshhold,0x24);
 
 
 //ADD：1E      ，用q时钟，接收总是aciivate（disable auto power down），内部解调
 SPI_write_byte(RegRxControl2,0x01);
 
    //;21
 SPI_write_byte(RegRxWait,0x06);


     //Depending on the processing speed of the operation environment, the waterlevel
     //can be adapted. (not very critical for mifare applications) initialize waterlevel to value 4
 //ADD:  29       ,定义使hi（lo）alert置位的FIFO数据数
 SPI_write_byte(RegFIFOLevel,0x08);

    //ADD： 2B   ；定义为当数据传输结束时，定时器开始计时;timer must be stopped manually
 SPI_write_byte(RegTimerControl,0x02); //TStopRxEnd=0,TStopRxBeg=0, TStartTxEnd=1,TStartTxBeg=0
  
 //定义timeclock，timerload
       
 
       
 SetTimerOut(0x01);    //short timeout
 
 //ADD:   2D   当irq置位时，输出引脚irq上点平反转
 SPI_write_byte(RegIRqPinConfig,0x03); //interrupt active low enable

  return;
}



void typeA_init(void)
{
   // GLED_ON             ;开指示灯

 //ADD: $11
 SPI_write_byte(RegTxControl,0x5b);

 //ADD   12    ;与调制指数有关
 SPI_write_byte(RegCwConductance,0x18);
  
 //ADD   13     ;与调制指数有关
    SPI_write_byte(RegModConductance,0x08); 

    //ADD: $14   
 SPI_write_byte(RegCoderControl,0x19);
  _WDR();  
    //ADD: $15
 SPI_write_byte(RegModWidth,0x13);
  
 //ADD  $19
 SPI_write_byte(RegRxControl1,0x73);
   
 //ADD  $23
    SPI_write_byte(RegCRCPresetLSB,0x63);
 
 //ADD  24
 SPI_write_byte(RegCRCPresetMSB,0x63); 
    
 //ADD   1D    
 SPI_write_byte(RegBPSKDemControl,0x1e);
   
 //ADD   1A     
 SPI_write_byte(RegDecoderControl,0x48); 
  
    //ADD   1C
 SPI_write_byte(RegRxThreshhold,0x44); 
   
 //Next if Format of Framing
 //ADD   13    
 SPI_write_byte(RegModConductance,0x3f); 

 //_delay_ms(10.0);  //延时1ms
        __delay_cycles(135600);

    main_flag&=0xfd;
//putc(0x48);
}



void uart_transmit(uchar length)
{

 uchar checksum=0,*p;

 putc(0xaa);//;发送数据头

 UCSRA|=0x40;//清除串口数据
 
 putc(0xaa);

 putc(0xaa);

 putc(0x96);

 putc(0x0a);
 
 p=pub_buff_content;

 while(length--)

 { putc(*p);

  checksum=checksum^(*p);

  p++;

 }
 putc(checksum);


}

uchar check()
{
 uchar *p1,temp,count;

 p1=p.pBuffer+5;

 temp=*p1++;

 count=*p1++;

 temp^=count;

 while(count--)

 temp=temp^(*p1++);
  
 if(temp==0) return 1;

 else  return 0;

}



uchar tx_OK()
{
 
 pub_buff_content[0]=0x00;
 
 pub_buff_content[1]=0x04;

 pub_buff_content[2]=0x00;

 pub_buff_content[3]=0x00;

 pub_buff_content[4]=0x90;

 return 5;
}
 
  
  

uchar tx_false()
{
 
        uchar temp;
       
 pub_buff_content[0]=0x00;
 
 pub_buff_content[1]=0x04;

 pub_buff_content[2]=0x00;

 pub_buff_content[3]=0x00;

 pub_buff_content[4]=0x41;

 temp=5;

 return temp;
}



uchar CDRequest(void)
{
 
      uchar temp;
     
 SPI_write_byte(RegChannelRedundancy,0x0f);

 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_HALT);


 SPI_write_byte(RegFIFOData,0x00);

 temp=SPI_read_byte(RegFIFOLength);
       
 if(temp!=2)
 
 {

  temp=tx_false();

  return temp; 
 }

 SPI_write_byte(RegCommand,CmdTransceive);

        __delay_cycles(13560);

 SPI_write_byte(RegCommand,0x00);

    //---------initialize------------ 
 SPI_write_byte(RegChannelRedundancy,0x03);        //;ADD: 0x22// ;RxCRC,TxCRC disable   ;Parity enble
      

 temp=SPI_read_byte(RegControl);                 //;ADD: 0x09

 temp&=0xf7;

 SPI_write_byte(RegControl,temp);


 FlushFIFO();

 SPI_write_byte(RegBitFraming,0x07);             //  ;ADD:0x1B
                          // ;set TxLastBits to 7
 temp=SPI_read_byte(RegTxControl);             //  ;ADD: 0x11

 temp|=0x03;                     

 SPI_write_byte(RegTxControl,temp);  // 确保TX1，TX2引脚输出的信号


 SPI_write_byte(RegFIFOData,PICC_REQALL); 


 temp=SPI_read_byte(RegFIFOLength);

 if(temp!=1)
 {
 
  temp=tx_false();

  return temp; 
 
 }
 
 SPI_write_byte(RegCommand,CmdTransceive);

           __delay_cycles(27120);


 temp=SPI_read_byte(RegFIFOLength);

//此时，缓冲区中存放的是卡返回的内容，如果有卡，缓冲区长度应该是2，没有卡应该是0

 if(temp!=2)

 {
  temp=tx_false();

  return temp;
 }

    pub_buff_content[0]=0x00;

 pub_buff_content[1]=0x06;
   
 pub_buff_content[2]=0x00;

    pub_buff_content[3]=0x00;

    pub_buff_content[4]=0x90;

    temp=SPI_read_byte(RegFIFOData);

 pub_buff_content[5]=temp;

 temp=SPI_read_byte(RegFIFOData);

 pub_buff_content[6]=temp;
  
   return 7;
}

 

 

 


uchar CDAnticollision()
{

 uchar temp,temp1,checksum=0,i;

 temp=SPI_read_byte(RegControl);

 temp&=0xf7;

 SPI_write_byte(RegControl,temp);

 FlushFIFO();

 SPI_write_byte(RegChannelRedundancy,0x03);

 SPI_write_byte(RegInterruptEn,0x7f);

 SPI_write_byte(RegFIFOData,PICC_ANTICOLL1); 
 
 SPI_write_byte(RegFIFOData,0x20);
 
 temp=SPI_read_byte(RegFIFOLength); 
     
 if(temp!=0x02)
 {
  temp=tx_false();

  return temp;
 }
 
 
 SPI_write_byte(RegCommand,CmdTransceive);

        __delay_cycles(27120);

 temp=SPI_read_byte(RegFIFOLength);


 if(temp!=0x05)
 {
  temp=tx_false();

  return temp;
 }

    temp1=temp;

 pub_buff_content[0]=0x00;

 pub_buff_content[1]=0x09;

 pub_buff_content[2]=0x00;

 pub_buff_content[3]=0x00;

 pub_buff_content[4]=0x90;

  
 i=temp1;


 while(temp1--)
 {
  temp=SPI_read_byte(RegFIFOData);

  pub_buff_content[i++]=temp;

  checksum^=temp;
 }

 if(checksum!=0)
 {
  temp=tx_false();

  return temp;
 }

 return 10;

}

 

void After_op()
{

  p.nCount=0;
 
  p.nHead=0;

  p.nTail=0;

         rsrecv_num=0;
   
         rsrxdat_num=0;

   rsrecv_endp=p.pBuffer;

         rsrxdat_p=p.pBuffer;

     main_flag&=0xe7;

  return;

}

uchar CDSelect()
{

 uchar i=0,temp;
       
 
 
 temp=SPI_read_byte(RegControl);

 temp&=0xf7;

 SPI_write_byte(RegControl,temp);
       
 FlushFIFO();

       
       
 SPI_write_byte(RegChannelRedundancy,0x0f);

 SPI_write_byte(RegInterruptEn,0x7f);

 SPI_write_byte(RegFIFOData,PICC_ANTICOLL1); 
 
 SPI_write_byte(RegFIFOData,0x70);

 while(i<5)
 {
  SPI_write_byte(RegFIFOData,*(p.pBuffer+9+i));

  i++;
 }

 temp=SPI_read_byte(RegFIFOLength);
       


 if(temp!=0x07)
 {
  temp=tx_false();

  return temp;
 }
  
 SPI_write_byte(RegCommand,CmdTransceive);


 for(i=0;i<20;i++)
 {
              __delay_cycles(135600);
 }

 temp=SPI_read_byte(RegFIFOLength);
       
   
       
 if(temp!=0x01)
 {

  temp=tx_false();

  return temp;
 }

 pub_buff_content[0]=0x00;

 pub_buff_content[1]=0x05;

 pub_buff_content[2]=0x00;

 pub_buff_content[3]=0x00;

 pub_buff_content[4]=0x90;

 temp=SPI_read_byte(RegFIFOData);

 pub_buff_content[5]=temp;

 return 6;


}


//;TYPE A卡卡请求RequestA命令
void RequestA()
{
 
 
        uchar temp;
       
 if((main_flag&0x10)==0) 
        {
          //  After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }

 temp=CDRequest();

 uart_transmit(temp);

 After_op();

 return;
}   

//;TYPE A卡防冲突Anticollision命令
void Anticollision()
{

 
        uchar temp;
       
 if((main_flag&0x10)==0) 
        {
          //  After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }

 temp=CDAnticollision();
 
 uart_transmit(temp);

 After_op();

 return;

}
// ;TYPE A卡选择卡Select命令
void  Select()
{
 
        uchar temp; 
       
 if((main_flag&0x10)==0) 
        {
           // After_op();
           
            return;
        }
       
 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }

 temp=CDSelect();

 uart_transmit(temp);

 After_op();

 return;

}


uchar CDAuthenticationE2()
{

        uchar temp;
       
 int i,mul,temp1,temp2;

 FlushFIFO();
 
 SPI_write_byte(RegCommand,CmdIdle);
 
 temp=*(p.pBuffer+9);    //取出扇区号

 temp2=temp;             //把扇区号 ——存于temp2中

 mul=temp*44+128;       //根据扇区号计算出E2PROM中该Sector的密码地址

 temp=*(p.pBuffer+10);   //取出密码类型

 temp1=temp;    //save密码类型，A或者B

 if(temp&0x01)

 mul+=12;
 
 SPI_write_byte(RegFIFOData,mul-256*(mul/256)); //低地址

 SPI_write_byte(RegFIFOData,mul/256);  //高地址

 temp=SPI_read_byte(RegFIFOLength);


 if(temp!=0x02)
 {

  temp=tx_false();

  return temp;
 }

 SPI_write_byte(RegCommand,CmdLoadKeyE2);

 temp=SPI_read_byte(RegErrorFlag);
       


 if(!(temp&0x40))
 {

  temp=tx_false();

  return temp;
 }
 
 __delay_cycles(40680);//3 ms
       
       
   //把需要的密码放入keybuffer里
 
 if(temp1&0x01)

  *(p.pBuffer+9)=PICC_AUTHENT1B;
 else
  
  *(p.pBuffer+9)=PICC_AUTHENT1A;

 temp2=temp2*4;  //r19

  *(p.pBuffer+10)=temp2;   //保存块号

 temp=6;

 i=9;

 while(temp--)

 SPI_write_byte(RegFIFOData,*(p.pBuffer+(i++)));

 temp=SPI_read_byte(RegFIFOLength);
       


 if(temp!=0x06)
 {

  temp=tx_false();

  return temp;
 }
 
 SPI_write_byte(RegCommand,CmdAuthent1);

 temp=SPI_read_byte(RegErrorFlag);
       


 if(temp&0x07)
 {

  temp=tx_false();

  return temp;
 }

 

 SPI_write_byte(RegCommand,CmdAuthent2);

   __delay_cycles(27120);

 temp=SPI_read_byte(RegControl);

 if(!(temp&0x08))

 {
  temp=tx_false();

  return temp;
 }
  temp=tx_OK();

  return temp;
}

uchar CDAuthenticationUser()
{
 
  uchar i=11,tim=6,temp1,temp;

  int mul;

  FlushFIFO();
  
  //转换密码格式
  while(tim--)
  {
  
  temp=*(p.pBuffer+i);

  temp1=temp;

  temp&=0xf0;

  temp=(temp<<4)|(temp>>4);

  temp1=(~temp1)&0xf0;

  temp1|=temp;

  SPI_write_byte(RegFIFOData,temp1);
               
 

  temp=temp1=*(p.pBuffer+i);

  temp=(temp<<4)|(temp>>4);

  temp=(~temp)&0xf0;

  temp1&=0x0f;

  temp|=temp1;

  SPI_write_byte(RegFIFOData,temp);

  i++;

 }
 
 SPI_write_byte(RegCommand,CmdLoadKey);

 temp=SPI_read_byte(RegErrorFlag);
       
        putc(temp);

 if(temp&0x40)            //;KeyErr is Set?
 {

  temp=tx_false();

  return temp;
 }

 __delay_cycles(40680);

 mul=(*(p.pBuffer+9))*4;   //;计算块号

 temp=*(p.pBuffer+10);

 if(temp&0x01)

  SPI_write_byte(RegFIFOData,PICC_AUTHENT1B); //B;第0位为1,B密码

 else
  
  SPI_write_byte(RegFIFOData,PICC_AUTHENT1A);//A/;第0位为0,A密码

  
  SPI_write_byte(RegFIFOData,mul);// ;块号

  i=17;tim=4;

  while(tim--)
  {
   SPI_write_byte(RegFIFOData,*(p.pBuffer+i));

   i++;
  }

 temp=SPI_read_byte(RegFIFOLength);

 if(temp!=0x06)          
 {

  temp=tx_false();

  return temp;
 }

 SPI_write_byte(RegCommand,CmdAuthent1);

   __delay_cycles(27120);

 temp=SPI_read_byte(RegErrorFlag);
       
        putc(temp);

 if(temp&0x07)            //;KeyErr is Set?
 {

  temp=tx_false();

  return temp;
 }

 SPI_write_byte(RegCommand,CmdAuthent2);

   __delay_cycles(27120);

 temp=SPI_read_byte(RegControl);
       
        putc(temp);

 if(!(temp&0x08))
 {

  temp=tx_false();

  return temp;
 }

 temp=tx_OK();

 return temp;

}

uchar CDRead()
{

 uchar i,tim,temp;

 SPI_write_byte(RegChannelRedundancy,0x0f);
 
 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_READ);

 SPI_write_byte(RegFIFOData,*(p.pBuffer+9));

 temp=SPI_read_byte(RegFIFOLength);
       
        putc(temp);

 if(temp!=0x02)
 {

  temp=tx_false();

  return temp;
 }

 SPI_write_byte(RegCommand,CmdTransceive);

 __delay_cycles(27120);//;延时>2ms

 temp=SPI_read_byte(RegFIFOLength);
       
        putc(temp);

 if(temp!=0x10)
 {

  temp=tx_false();

  return temp;
 }
 pub_buff_content[0]=0x00;

 pub_buff_content[1]=0x14;

 pub_buff_content[2]=0x00;

 pub_buff_content[3]=0x00;

 pub_buff_content[4]=0x90;

 i=16;tim=5;

 while(i--)
 {
  temp=SPI_read_byte(RegFIFOData);

  pub_buff_content[tim++]=temp;

 }

 return 21;

}



uchar CDWrite()
{

 uchar i,tim,temp;

 SPI_write_byte(RegChannelRedundancy,0x0f);

 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_WRITE);
            
 SPI_write_byte(RegFIFOData,*(p.pBuffer+9)); //;nBlock

 temp=SPI_read_byte(RegFIFOLength);
       
        putc(temp);

 if(temp!=0x02)
 {

  temp=tx_false();

  return temp;
 }

 SPI_write_byte(RegCommand,CmdTransceive);

 __delay_cycles(27120);//;延时>2ms

 temp=SPI_read_byte(RegFIFOLength);
       
        putc(temp);

 if(temp!=0x01)
 {

  temp=tx_false();

  return temp;
 }

 temp=SPI_read_byte(RegFIFOData);  //随机数，所以不用判断是多少
       
        putc(temp);

 i=16;tim=10;

 while(i--)
 {

  SPI_write_byte(RegFIFOData,*(p.pBuffer+tim));

  tim++;

 }

 SPI_write_byte(RegCommand,CmdTransceive);
       
        i=5;

 while(i--)
 {
    __delay_cycles(5452);
  
  temp=SPI_read_byte(RegFIFOLength); //等待数据发送完毕

  if(temp==0) break;

 }
       
        putc(i);
       
 if(i==0)
 {
  temp=tx_false();

  return temp;
 }
 
 i=16;   //16次循环每次延时0.5ms

 while(i--)// ;数据发送完毕，等待返回信息或者超时
 {
    __delay_cycles(6780);

  temp=SPI_read_byte(RegFIFOLength);

  if(temp==1) break;
 }

 temp=SPI_read_byte(RegFIFOData);
       
        putc(temp);

 if(temp!=0x0a)
 {
  temp=tx_false();

  return temp;
 }
 temp=tx_OK();

 return temp;

}

uchar CDDecrement()
{

 uchar i,tim,temp;

 SPI_write_byte(RegChannelRedundancy,0x0f);

 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_DECREMENT);

 SPI_write_byte(RegFIFOData,*(p.pBuffer+9));

 temp=SPI_read_byte(RegFIFOLength);
       
        putc(temp);

 if(temp!=0x02)
 {
  temp=tx_false();

  return temp;
 }
 SPI_write_byte(RegCommand,CmdTransceive);

 __delay_cycles(27120);//;延时>2ms

 temp=SPI_read_byte(RegFIFOLength);
       
        putc(temp);

 if(temp!=0x01)
 {
  temp=tx_false();

  return temp;
 }

 temp=SPI_read_byte(RegFIFOData);

 FlushFIFO();

 tim=4;i=10;

 while(tim--)
 {
  SPI_write_byte(RegFIFOData,*(p.pBuffer+i));
               
  i++;
 }
 SPI_write_byte(RegCommand,CmdTransceive);

   __delay_cycles(27120);//;延时>2ms

 temp=SPI_read_byte(RegPrimaryStatus);
       
        putc(temp);

 if(temp&0x04)
 {
  temp=tx_false();

  return temp;
 }

 temp=tx_OK();

 return temp;

}

uchar CDIncrement()
{
 uchar i,tim,temp;

 SPI_write_byte(RegChannelRedundancy,0x0f);

 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_INCREMENT);
 

 SPI_write_byte(RegFIFOData,*(p.pBuffer+9));

 temp=SPI_read_byte(RegFIFOLength);
      
      putc(temp);
 if(temp!=0x02)
 {
  temp=tx_false();

  return temp;
 }
 SPI_write_byte(RegCommand,CmdTransceive);

 __delay_cycles(27120);//;延时>2ms

 temp=SPI_read_byte(RegFIFOLength);
       
        putc(temp);

 if(temp!=0x01)
 {
  temp=tx_false();

  return temp;
 }

 temp=SPI_read_byte(RegFIFOData);

 FlushFIFO();

 tim=4;i=10;

 while(tim--)
 {
  SPI_write_byte(RegFIFOData,*(p.pBuffer+i));

  i++;
 }
 SPI_write_byte(RegCommand,CmdTransceive);

   __delay_cycles(27120);//;延时>2ms

 temp=SPI_read_byte(RegPrimaryStatus);
       
        putc(temp);

 if(temp&0x04)
 {
  temp=tx_false();

  return temp;
 }

 temp=tx_OK();

 return temp;
}

uchar CDTransfer()
{
 uchar i,temp;

 SPI_write_byte(RegChannelRedundancy,0x0f);

 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_TRANSFER);

 SPI_write_byte(RegFIFOData,*(p.pBuffer+9));//;nBlock

 temp=SPI_read_byte(RegFIFOLength);

 if(temp!=2)
 {
  temp=tx_false();

  return temp;
 }

 SPI_write_byte(RegCommand,CmdTransceive);

 i=4;

 while(i--)
 {
    __delay_cycles(27120);//;延时>2ms
                 
                    __delay_cycles(27120);

  temp=SPI_read_byte(RegFIFOLength);

  if(temp==1)  break;
 
 }
 if(i==0)
 {
  temp=tx_false();

  return temp;
 }
 temp=SPI_read_byte(RegFIFOData);


 temp=tx_OK();

 return temp;


}


uchar CDHalt()
{
        uchar temp;
       
 SPI_write_byte(RegChannelRedundancy,0x0f);

 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_HALT);

 SPI_write_byte(RegFIFOData,0x00);

 temp=SPI_read_byte(RegFIFOLength);

 if(temp!=2)
 {
  temp=tx_false();

  return temp;
 }
 SPI_write_byte(RegCommand,CmdTransceive);

 temp=SPI_read_byte(RegPrimaryStatus);

 if(temp&0x04)
 {
  temp=tx_false();

  return temp;
 }
 temp=tx_OK();

 return temp;

}


uchar CDRestore()
{
 uchar i,tim,temp;

 SPI_write_byte(RegChannelRedundancy,0x0f);

 FlushFIFO();

 SPI_write_byte(RegFIFOData,PICC_RESTORE);

 SPI_write_byte(RegFIFOData,*(p.pBuffer+9));// ;nBlock

 temp=SPI_read_byte(RegFIFOLength);
       


 if(temp!=2)
 {
  temp=tx_false();

  return temp;
 }
 SPI_write_byte(RegCommand,CmdTransceive);

   __delay_cycles(27120);//;延时>2ms

 temp=SPI_read_byte(RegFIFOLength);


 if(temp!=0x01)
 {
  temp=tx_false();

  return temp;
 }
 temp=SPI_read_byte(RegFIFOData);//;不用判断,值不确定

 tim=4;i=10;

 while(tim--)
 {
  SPI_write_byte(RegFIFOData,*(p.pBuffer+i));

  i++;
 }
 SPI_write_byte(RegCommand,CmdTransceive);

   __delay_cycles(27120);//;延时2ms

 temp=SPI_read_byte(RegPrimaryStatus);


 if(temp&0x04)
 {
  temp=tx_false();

  return temp;
 }
 temp=tx_OK();

 return temp;

}

 

 //  ;TYPE A卡验证EEPROM密码命令
void CheckEEPROM()
{
 
        uchar temp;
       
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
         
 
  temp=CDAuthenticationE2();
 
  uart_transmit(temp);

 After_op();

 return;


}


//;TYPE A卡验证User密码命令
void CheckUser()
{
        uchar temp;
        
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
  temp=CDAuthenticationUser();

    uart_transmit(temp);

    After_op();

   return;
 
}
 

 // ;TYPE A卡读卡命令
void ReadTypeA()
{
 
         uchar temp;
        
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 temp=CDRead();

        uart_transmit(temp);
 
         After_op();

 return;
} 
 
 // ;TYPE A卡写卡命令   
void WriteTypeA()
{
         uchar temp;
        
 if((main_flag&0x10)==0) 
        {
            //After_op();
            return;
        }
       
 temp=check();
 
 if(temp==0)
        {
          
           After_op();
          
           return;
        }
 temp=CDWrite();

    uart_transmit(temp);
   
    After_op();

 return;
}
    
//;TYPE A卡钱包减命令   
void  DecTypeA()
{
 
         uchar temp;
        
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 temp=CDDecrement();

    uart_transmit(temp);

  After_op();


 return;
}
 
 // ;TYPE A卡钱包加命令  
void IncTypeA()
{
 
       uchar temp;
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 
 temp=CDIncrement();

    uart_transmit(temp);

  After_op();

 return; 
}

//  ;TYPE A卡Transfer命令
void TranTypeA()
{
 
       uchar temp;
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 
 temp=CDTransfer();

    uart_transmit(temp);

  After_op();

 return; 
}

// ;TYPE A卡Halt命令
void HaltTypeA()
{
 
       uchar temp;
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 
 temp=CDHalt();

    uart_transmit(temp);
   
    After_op();

 return; 
}


//;TYPE A卡Restore命令
void RestroeTypeA()
{
 
         uchar temp;
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 
 temp=CDRestore();

    uart_transmit(temp);

  After_op();

 return; 
}


// ;读读卡芯片寄存器
void ReadRC531()
{
 
         uchar temp;
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 
 temp=SPI_read_byte(*(p.pBuffer+9));

 pub_buff_content[0]=0x00;

 pub_buff_content[1]=0x05;

 pub_buff_content[2]=0x00;

 pub_buff_content[3]=0x00;

 pub_buff_content[4]=0x90;

 pub_buff_content[5]=temp;


 uart_transmit(6);

  After_op();

 return; 
}


//    ;写读卡芯片寄存器
void WriteRC531()    
{
       uchar temp;
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }

 SPI_write_byte(*(p.pBuffer+9),*(p.pBuffer+10));
 
 temp=tx_OK();

 uart_transmit(temp);

  After_op();

 return;

}

 //;打开射频信号并设成TYPE A方式

void ToTypeA()
{
 
         uchar temp;
        
  if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 
 typeA_init();

 temp=tx_OK();
 
 uart_transmit(temp);
 
 return; 

}

//;关掉射频信号
void Close()
{
       uchar temp;
 if((main_flag&0x10)==0) 
        {
            //After_op();
           
            return;
        }
         

 temp=check();
 
 if(temp==0)
        {
         
           After_op();
          
           return;
        }
 
 SPI_write_byte(RegTxControl,0x00);

 temp=tx_OK();
 
 uart_transmit(temp);

 After_op();
 
 return; 
}

蓝色天空001
关注
专栏目录
RK3568笔记五十三：RC522驱动开发测试（SPI1)
08-05 399
RC522 是一种非接触式读写卡芯片，底层采用SPI模拟时序，可以应用于校园一卡通、水卡充值消费、公交卡充值消费设计、门禁卡等。非接触性IC卡与读卡器之间通过无线电波来完成读写操作。二者之间的通讯频率为13.56MHZ。非接触性IC卡本身是无源卡，当读写器对卡进行读写操作时，读写器发出的信号由两部分叠加组成:一部分是电源信号，该信号由卡接收后，与本身的L/C产生一个瞬间能量来供给芯片工作。另一部分则是指令和数据信号，指挥芯片完成数据的读取、修改、储存等，并返回信号给读写器,完成一次读写操作。
frid 开发_RFID 开发板 RC531
weixin_39799307的博客
12-20 582
RFID DEMO是一款RFID功能演示、学习的开发套件。主要针对13.56MHz的RFID频段，可以同时支持多款读卡器芯片，包括：1.MFRC5002.MFRC5313.CLRC6324.FM1702NL5.MFRC5226.PN532可以支持多种格式的射频卡，包括：1.S502.S703.标签卡(15693)RFID DEMO采用常用的STC51单片机作为主控芯片，设计简单，...
RC531 匹配电路和天线设计
02-06
RC531射频模块开发，完整50欧姆匹配电路和天线设计方面的资料，对开发非接触读卡器射频部分很有帮助
rcreg amp 0x01 c语言,发一个读写RC531的STM32F2XX的DEMO
weixin_29343153的博客
05-20 272
#ifndef _RC531_H#define _RC531_H//-------------------------------------------------------------------------------------------------------#define RC531_CS1 ...
RC531详细规格书
05-23
NXP的非接触读卡芯片，用于读写M1卡和CPU卡，支持SPI和并口两种接口，支持ISO14443协议，
基于RC531的非接触卡PBOC的完整驱动代码
08-12
基于RC531的芯片，实现了基于PBOC规范的完整的驱动操作控制流程，包括开关频场、寻卡、握手、发送APDU指令等，支持A类和B类卡驱动。
STM32 RC522驱动程序
07-21
STM32 RC522驱动程序是针对基于STM32微控制器的RFID读卡器模块的软件实现。RC522是NXP公司生产的一款高频（13.56MHz）非接触式IC卡阅读器芯片，常用于门禁系统、电子支付、物联网设备等场景。在STM32上实现RC522的...
LPC1114 读卡器RC522驱动程序
01-05
《LPC1114与RC522读卡器驱动程序详解》 在嵌入式系统设计中，实现RFID（无线频率识别）功能是一个常见的需求，这通常涉及到微控制器与特定的读卡器模块之间的通信。在这个场景中，LPC1114是一款基于ARM Cortex-M0...
复旦微ISO14443TypeA卡读卡芯片FM17522驱动程序(含LPCD低功耗寻卡功能).rar
03-31
复旦微电子的FM17522是一款专为ISO14443 Type A卡片设计的读卡芯片，常用于非接触式智能卡系统，如门禁、交通卡、电子支付等领域。这款驱动程序包含了FM17522芯片在实际应用中的核心功能，特别是LPCD（Low Power ...
RC522读卡NFC芯片C51 MSP430单片机驱动源代码+RFID 设计指南等文档资料.zip
最新发布
06-18
RC522读卡NFC芯片C51 MSP430单片机驱动源代码+RFID 设计指南等文档资料 MSP430F149读写卡参考例程 TIDZ-RC522读卡模块使用说明.pdf 相关数据手册和参考文献 IC-S50数据手册.PDF M1卡破解 MFRC522数据手册.pdf Mifare...
基于STM32 RC522射频模块驱动程序(HAL库)
03-18
该驱动程序主要针对Philips（现为NXP）的MFRC522射频芯片设计，与STM32微控制器的HAL库进行接口集成，实现RFID系统的功能。 首先，了解STM32。STM32是意法半导体（STMicroelectronics）推出的一系列高性能、低功耗...
RC531数据手册及官方基本功能库源码
11-04
RC513芯片2014年的数据手册，以及RC500的官方基本功能库源码，RC500与RC531在操作上基本相同。
SPI RC531 RAM
07-31
ARM单片机的SPI接口操作RC531,完全可以使用,本人从51移植成功的!
MFRC531完整版带寄存器
03-07
This data sheet describes the functionality of the MFRC531 Integrated Circuit (IC). It includes the functional and electrical specifications and from a system and hardware viewpoint gives detailed information on how to design-in the device.
RF-RC531无线读写门禁完整源代码
03-13
RF-RC531无线读写门禁完整源代码 此程序代码实现RF方式读写卡，用于门禁产品的完整程序，
基于STM32的RC663编程
09-11
基于STM32单片机开发的对射频芯片RC663的编程控制。 CLRC663是高度集成的收发器芯片，用于13.56兆赫兹的非接触式通讯。CLRC663收发器芯片支持下列操作模式。 • 读写模式支持ISO/IEC 14443A/MIFARE • 读写模式支持SO/IEC 14443IB • JIS X 6319-4读写模式支持（等效于FeliCa1方案，请参阅章节21.5） • 相应于ISO/IEC 18092的被动发起方模式 • 读写模式支持ISO/IEC 15693 • 读写模式支持ICODE EPC UID/EPC OTP • 读写模式支持ISO/IEC 18000-3 mode 3/ EPC Class-1 HF
STM32 SPI初始化和使用
weixin_34405925的博客
03-20 1960
串行外设接口(SPI)。初始化步骤：1、连接SPI外设时钟，通过RCC-&gt;APB2ENR设置。2、连接被复用的GPIO的外设时钟，也是通过RCC-&gt;APB2ENR设置为什么还要连接GPIO时钟，参见STM32参考手册8.1.4节。手册上这么说的：对于复用输出功能，端口必须配置成复用功能输出模式(推挽或开漏)。3、设置被复用的GPIO为推挽输出，并设置时钟。不能设置为开漏输出。设置成开漏...
实验一. RFID自动读卡实验
热门推荐
lululumiao的博客
05-23 1万+
实验一. RFID自动读卡实验实验目的实验环境实验内容实验步骤实验代码1) 初始化MFRC531如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 实验目的 了解RFID相关知识。 掌握RFID模块自动识别IC卡工作原理。 实验环境 软件：IAR SWSTM8 1.30
FM1701调试手记
SuGuolin的博客
12-14 4549
做完刷卡版充电插座这个项目遇到的问题做一些笔记 首先是硬件电路如下: 从 TX 发射出去的是调制过的 13.56MHz 载波信号，软件发送命令，6脚产生13.56MHZ的正弦波的载波信号，然后天线刷卡得到信号跟载波信号叠加传输到RX脚。 在使用SPI的时候配要根据FM1701的时序图，由下图可以判断出用的SPI模式（参考博客） 批量生产的时候测试的时候可以输出卡，后来...
MF_RC531读卡器芯片详细资料：广州周立功单片机应用与服务
MF_RC531_scn 读卡器芯片口文资料是一份详细介绍了MF RC531芯片的文档，该芯片是一款高集成度的ISO14443A标准的读写卡芯片，由广州周立功单片机发展有限公司开发。MF RC531是用于实现卡片数据读取和写入功能的关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值