rc531.c.txt

C语言的 RC531

case 7: 
rc531_register_write(Bit_Frame,0x77); 
buffer[1]=(buffer[1] | 0x07); 
break; 
default: 
break; 
} 
} 

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~// 
//名称: Request // 
//功能: 该函数实现对放入RC531操作范围之内的卡片的Request操作 // 
// // 
//输入: // 
// mode: WUPA(监测所以RC531操作范围之内的卡片) // 
// REQA(监测在RC531操作范围之内不处于HALT状态的空闲卡片) // 
// // 
//输出: // 
// RC531_NOTAGERR: 无卡 // 
// RC531_OK: 应答正确 // 
// RC531_REQERR: 应答错误 // 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~// 
char Request(char mode) 
{ 
char temp; 
buffer[0]=mode; //Request模式选择 
rc531_register_write(Bit_Frame,0x07); //发送7bit 
rc531_register_write(ChannelRedundancy,0x03); //关闭CRC校验 
rc531_register_write(Control,0x00); //屏蔽CRYPTO1位 
temp=Command_Send(1,buffer,Transceive); 
if(temp == FALSE) 
{ 
return(RC531_NOTAGERR); 
} 
Read_FIFO(buffer); //从FIFO中读取应答信息 
temp=Judge_Req(buffer); //判断应答信号是否正确 
if (temp==TRUE) 
{ 
tagtype[0]=buffer[0]; 
tagtype[1]=buffer[1]; 
return(RC531_OK); 
} 
else 
return(RC531_REQERR); 
} 


/********************************************************************************************************/ 
/*名称: AntiColl */ 
/*功能: 该函数实现对放入RC531操作范围之内的卡片的防冲突检测 */ 
/* */ 
/*输入: */ 
/* N/A */ 
/* */ 
/*输出: */ 
/* RC531_NOTAGERR: 无卡 */ 
/* RC531_BYTECOUNTERR: 接收字节错误 */ 
/* RC531_SERNRERR: 卡片序列号应答错误 */ 
/* RC531_OK: 卡片应答正确 */ 
/********************************************************************************************************/ 
char AntiColl(void) 
{ 
char temp; 
char i; 
char row,col; 
char pre_row; 

row=0; 
col=0; 
pre_row=0; 

buffer[0]=RF_CMD_ANTICOL; 
buffer[1]=0x20; 
rc531_register_write(Bit_Frame,0x00); 
rc531_register_write(ChannelRedundancy,0x03); //关闭CRC,打开奇偶校验 
temp=Command_Send(2,buffer,Transceive); 

while(1) 
{ 
if(temp==FALSE) 
return(RC531_NOTAGERR); 
temp=rc531_register_read(FIFO_Length); 
if (temp==0) 
return(RC531_BYTECOUNTERR); 
Read_FIFO(buffer); 
Save_UID(row,col,temp); //将收到的UID放入UID数组中 
temp=rc531_register_read(ErrorFlag); //判断接収数据是否出错 
if((temp &amt; 0x02)==0x02) 
return(RC531_PARITYERR); 
if((temp &amt; 0x04)==0x04) 
return(RC531_FRAMINGERR); 
if((temp &amt; 0x01)==0x00) 
{ 
temp=Check_UID(); //校验收到的UID 
if(temp==FALSE) 
return(RC531_SERNRERR); 
return(RC531_OK); 
} 
else 
{ 
temp=rc531_register_read(CollPos); //读取冲突检测寄存器 
row=temp/8; 
col=temp>8; 
buffer[0]=RF_CMD_ANTICOL; 
Set_BitFraming(row+pre_row,col); //设置待发送数据的字节数 
pre_row=pre_row+row; 
for(i=0;i<pre_row+1;i++) 
buffer[i+2]=UID[i]; 
if(col!=0x00) 
row=pre_row+1; 
else 
row=pre_row; 
temp=Command_Send(row+2,buffer,Transceive); 
} 
} 
} 


/********************************************************************************************************/ 
/*名称: Select_Card */ 
/*功能: 该函数实现对放入RC531操作范围之内的某张卡片进行选择 */ 
/* */ 
/*输入: */ 
/* N/A */ 
/* */ 
/*输出: */ 
/* RC531_NOTAGERR: 无卡 */ 
/* RC531_PARITYERR: 奇偶校验错 */ 
/* RC531_CRCERR: CRC校验错 */ 
/* RC531_BYTECOUNTERR: 接收字节错误 */ 
/* RC531_OK: 应答正确 */ 
/* RC531_SELERR: 选卡出错 */ 
/********************************************************************************************************/ 
char Select_Card(void) 
{ 
char temp,i; 

buffer[0]=RF_CMD_SELECT; 
buffer[1]=0x70; 
for(i=0;i<5;i++) 
buffer[i+2]=UID[i]; 
rc531_register_write(ChannelRedundancy,0x0f); //开启CRC,奇偶校验校验 
temp=Command_Send(7,buffer,Transceive); 

if(temp==FALSE) 
return(RC531_NOTAGERR); 
else 
{ 
temp=rc531_register_read(ErrorFlag); 
if ((temp &amt; 0x01)==0x01) 
return(RC531_COLLERR); 
if ((temp &amt; 0x02)==0x02) 
return(RC531_PARITYERR); 
if((temp &amt; 0x04)==0x04) 
return(RC531_FRAMINGERR); 
if ((temp &amt; 0x08)==0x08) 
return(RC531_CRCERR); 

temp=rc531_register_read(FIFO_Length); 
if (temp!=1) 
return(RC531_BYTECOUNTERR); 
Read_FIFO(buffer); //从FIFO中读取应答信息 
if (*buffer==SAK_BYTE0 || *buffer==SAK_BYTE1) //判断应答信号是否正确 
return(RC531_OK); 
else 
return(RC531_SELERR); 
} 
} 


/********************************************************************************************************/ 
/*名称: Read_E2 */ 
/*功能: 该函数实现从RC531的EE中读出数据 */ 
/* */ 
/*输入: */ 
/* lsb, EE地址(低字节) */ 
/* msb, EE地址(高字节) */ 
/* count, 待读出数据EE的字节个数 */ 
/* buff, 指向待读出数据的指针 */ 
/* */ 
/*输出: */ 
/* TRUE, EE数据正确读出 */ 
/* FALSE, EE数据读出有误 */ 
/********************************************************************************************************/ 
char Read_E2(char lsb,char msb,char count,char *buff) 
{ 
char temp; 

*buff=lsb; 
*(buff+1)=msb; 
*(buff+2)=count; 
temp=Command_Send(3,buff,ReadE2); 
Read_FIFO(buff); 
return(temp); 
} 

/********************************************************************************************************/ 
/*名称: Write_E2 */ 
/*功能: 该函数实现向RC531的EE中写入数据 */ 
/* */ 
/*输入: */ 
/* lsb, EE地址(低字节) */ 
/* msb, EE地址(高字节) */ 
/* count, 待写入数据EE的字节个数 */ 
/* buff, 指向待写入数据的指针 */ 
/* */ 
/*输出: */ 
/* TRUE, EE数据正确写入 */ 
/* FALSE, EE数据写入有误 */ 
/********************************************************************************************************/ 
char Write_E2(char lsb,char msb,char count,char *buff) 
{ 

char temp,i; 

for(i=0;i<count;i++) 
*(buff+count-i+2)=*(buff-i+count); 
*buff=lsb; 
*(buff+1)=msb; 
temp=Command_Send(count+2,buff,WriteE2); 
temp=rc531_register_read(SecondaryStatus); 
temp=temp &amt; 0x40; 
if (temp==0x40) 
return(TRUE); 
else 
return(FALSE); 
} 

/********************************************************************************************************/ 
/*名称: Load_key_CPY */ 
/*功能: 该函数实现把FIFO中的密码存入rc531的keybuffer中 */ 
/* */ 
/*输入: */ 
/* keybuff: 密码首地址 */ 
/* */ 
/*输出: */ 
/* TRUE: 密钥装载成功 */ 
/* FALSE: 密钥装载失败 */ 
/********************************************************************************************************/ 
char Load_key_CPY(char *keybuff) 
{ 
char temp; 

temp=Command_Send(12,keybuff,LoadKey); 
temp=(rc531_register_read(ErrorFlag)) &amt; 0x40; 
if (temp==0x40) 
return(FALSE); 
return(TRUE); 
} 

/********************************************************************************************************/ 
/*名称: Load_keyE2 */ 
/*功能: 该函数实现把E2中密码存入rc531的keybuffer中 */ 
/* */ 
/*输入: */ 
/* Secnr: EE起始地址 */ 
/* */ 
/*输出: */ 
/* True: 密钥装载成功 */ 
/* False: 密钥装载失败 */ 
/********************************************************************************************************/ 
char Load_keyE2_CPY(char Secnr,char Mode) 
{ 
char temp; 
char msb=0; 
char lsb=0; 

temp = Secnr * 12; 
if (Mode==0) 
{ 
if (temp>=0x80) //计算密码存放地址 
{ 
lsb=temp-0x80; 
msb=0x01; 
} 
else 
{ 
msb=0x00; 
lsb=temp+0x80; 
} 
} 
else 
{ 
msb=0x01; 
lsb=temp+0x40; 
} 
buffer[0]=lsb; 
buffer[1]=msb; 
temp=Command_Send(2,buffer,LoadKeyE2); 
temp=(rc531_register_read(ErrorFlag)) &amt; 0x40; 
if (temp==0x40) 
return(FALSE); 
return(TRUE); 
} 

/********************************************************************************************************/ 
/*名称: Authentication */ 
/*功能: 该函数实现密码认证的过程 */ 
/* */ 
/*输入: */ 
/* UID: 卡片序列号地址 */ 
/* SecNR: 扇区号 */ 
/* mode: 模式 */ 
/* 0 : KeyA */ 
/* 1 : KeyB */ 
/*输出: */ 
/* RC531_NOTAGERR: 无卡 */ 
/* RC531_PARITYERR: 奇偶校验错 */ 
/* RC531_CRCERR: CRC校验错 */ 
/* RC531_OK: 应答正确 */ 
/* RC531_AUTHERR: 权威认证有错 */ 
/********************************************************************************************************/ 
char Authentication(char *UID,char SecNR,char mode) 
{ 
char i; 
char temp,temp1; 

temp1=rc531_register_read(Control); 
temp1=temp1 &amt; 0xf7; 
rc531_register_write(Control,temp1); 

if (mode==1) //AUTHENT1 
buffer[0]=RF_CMD_AUTH_LB; 
else 
buffer[0]=RF_CMD_AUTH_LA; 
buffer[1]=SecNR*4+3; 
for (i=0;i<4;i++) 
buffer[2+i]=UID[i]; 
rc531_register_write(ChannelRedundancy,0x0f); //开启CRC,奇偶校验校验 
temp=Command_Send(6,buffer,Authent1); 
if (temp==FALSE) 
return(RC531_NOTAGERR); 
temp=rc531_register_read(ErrorFlag); 
if ((temp &amt; 0x01)==0x01) 
return(RC531_COLLERR); 
if ((temp &amt; 0x02)==0x02) 
return(RC531_PARITYERR); 
if ((temp &amt; 0x04)==0x04) 
return(RC531_FRAMINGERR); 
if ((temp &amt; 0x08)==0x08) 
return(RC531_CRCERR); 

temp=Command_Send(0,buffer,Authent2); //AUTHENT2 
if(temp==FALSE) 
return(RC531_NOTAGERR); 
temp=rc531_register_read(ErrorFlag); 
if ((temp &amt; 0x01)==0x01) 
return(RC531_COLLERR); 
if ((temp &amt; 0x02)==0x02) 
return(RC531_PARITYERR); 
if ((temp &amt; 0x04)==0x04) 
return(RC531_FRAMINGERR); 
if ((temp &amt; 0x08)==0x08) 
return(RC531_CRCERR); 
temp1=rc531_register_read(Control); 
temp1=temp1 &amt; 0x08; //Crypto1on=1，验证通过 
if (temp1==0x08) 
return(RC531_OK); 
else 
return(RC531_AUTHERR); 
} 

/********************************************************************************************************/ 
/*名称: MIF_Read */ 
/*功能: 该函数实现读MIFARE卡块的数值 */ 
/* */ 
/*输入: */ 
/* buff: 缓冲区首地址 */ 
/* Block_Adr: 块地址 */ 
/*输出: */ 
/* RC531_NOTAGERR: 无卡 */ 
/* RC531_PARITYERR: 奇偶校验错 */ 
/* RC531_CRCERR: CRC校验错 */ 
/* RC531_BYTECOUNTERR: 接收字节错误 */ 
/* RC531_OK: 应答正确 */ 
/********************************************************************************************************/ 
char MIF_READ(char *buff,char Block_Adr) 
{ 
char temp; 

rc531_register_write(ChannelRedundancy,0x0f); 
//Int_Req=0x7f; 
buff[0]=RF_CMD_READ; 
buff[1]=Block_Adr; 
temp=Command_Send(2,buff,Transceive); 
if (temp==0) 
return(RC531_NOTAGERR); 

temp=rc531_register_read(ErrorFlag); 
if ((temp &amt; 0x01)==0x01) 
return(RC531_COLLERR); 
if ((temp &amt; 0x02)==0x02) 
return(RC531_PARITYERR); 
if ((temp &amt; 0x04)==0x04) 
return(RC531_FRAMINGERR); 
if ((temp &amt; 0x08)==0x08) 
return(RC531_CRCERR); 

temp=rc531_register_read(FIFO_Length); 
if (temp!=0x10) 
return(RC531_BYTECOUNTERR); 
Read_FIFO(buff); 
return(RC531_OK); 
} 

/********************************************************************************************************/ 
/*名称: MIF_Write */ 
/*功能: 该函数实现写MIFARE卡块的数值 */ 
/* */ 
/*输入: */ 
/* buff: 缓冲区首地址 */ 
/* Block_Adr: 块地址 */ 
/*输出: */ 
/* RC531_NOTAGERR: 无卡 */ 
/* RC531_BYTECOUNTERR: 接收字节错误 */ 
/* RC531_NOTAUTHERR: 未经权威认证 */ 
/* RC531_EMPTY: 数据溢出错误 */ 
/* RC531_CRCERR: CRC校验错 */ 
/* RC531_PARITYERR: 奇偶校验错 */ 
/* RC531_WRITEERR: 写卡块数据出错 */ 
/* RC531_OK: 应答正确 */ 
/********************************************************************************************************/ 
char MIF_Write(char *buff,char Block_Adr) 
{ 
char temp; 
char *F_buff; 

F_buff=buff+0x10; 
rc531_register_write(ChannelRedundancy,0x0f); 
*F_buff=RF_CMD_WRITE; 
*(F_buff+1)=Block_Adr; 
temp=Command_Send(2,F_buff,Transceive); 
if (temp==FALSE) 
return(RC531_NOTAGERR); 
temp=rc531_register_read(FIFO_Length); 
if (temp==0) 
return(RC531_BYTECOUNTERR); 
Read_FIFO(F_buff); 
temp=*F_buff; 
switch(temp) 
{ 
case 0x00 : 
return(RC531_NOTAUTHERR); 
case 0x04: 
return(RC531_EMPTY); 
case 0x0a: 
break; 
case 0x01: 
return(RC531_CRCERR); 
case 0x05: 
return(RC531_PARITYERR); 
default: 
return(RC531_WRITEERR); 
} 

temp=Command_Send(16,buff,Transceive); 
if (temp==TRUE) 
return(RC531_OK); 
else 
{ 
temp=rc531_register_read(ErrorFlag); 
if ((temp &amt; 0x02)==0x02) 
return(RC531_PARITYERR); 
else if((temp &amt; 0x04)==0x04) 
return(RC531_FRAMINGERR); 
else if ((temp &amt; 0x08)==0x08) 
return(RC531_CRCERR); 
else 
return(RC531_WRITEERR); 
} 
} 

/********************************************************************************************************/ 
/*名称: MIF_Halt */ 
/*功能: 该函数实现暂停MIFARE卡 */ 
/* */ 
/*输入: */ 
/* N/A */ 
/* */ 
/*输出: */ 
/* RC531_OK: 应答正确 */ 
/* RC531_PARITYERR: 奇偶校验错 */ 
/* RC531_CRCERR: CRC校验错 */ 
/* RC531_NOTAGERR: 无卡 */ 
/********************************************************************************************************/ 
char MIF_Halt(void) 
{ 
char temp; 

rc531_register_write(ChannelRedundancy,0x03); 
*buffer=RF_CMD_HALT; 
*(buffer+1)=0x00; 
temp=Command_Send(2,buffer,Transmit); 
if (temp==TRUE) 
return(RC531_OK); 
else 
{ 
temp=rc531_register_read(ErrorFlag); 
if ((temp &amt; 0x02)==0x02) 
return(RC531_PARITYERR); 
if ((temp &amt; 0x04)==0x04) 
return(RC531_FRAMINGERR); 
return(RC531_NOTAGERR); 
} 
} 

/********************************************************************************************************/ 
/*名称: MIF_Initival */ 
/*功能: 该函数实现MIFARE卡初始化值操作 */ 
/* */ 
/*输入: */ 
/* buff: 四个字节初始化数值起始地址 */ 
/* Block_Adr: 块地址 */ 
/* */ 
/*输出: */ 
/* RC531_NOTAGERR: 无卡 */ 
/* RC531_BYTECOUNTERR: 接收字节错误 */ 
/* RC531_NOTAUTHERR: 未经权威认证 */ 
/* RC531_EMPTY: 数据溢出错误 */ 
/* RC531_CRCERR: CRC校验错 */ 
/* RC531_PARITYERR: 奇偶校验错 */ 
/* RC531_WRITEERR: 写卡块数据出错 */ 
/* RC531_OK: 应答正确 */ 
/********************************************************************************************************/