lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

存档

Browse Source
This commit is contained in:
lmx
2025-11-24 13:55:10 +08:00
parent f3710fbb4b
commit eb9de783ed
11 changed files with 3101 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

584
apps/earphone/RFID/reader/CPU_CARD.c Normal file
View File

@ -0,0 +1,584 @@
//2018<31><38>2<EFBFBD><32>2<EFBFBD>ձ༭<D5B1><E0BCAD>֧<EFBFBD><D6A7>CPU<50><55>Ƭָ<C6AC><EFBFBD><EEA3AC><EFBFBD>ӷ<EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD>
#include "../include/READER.h"
#include "../include/CPU_CARD.h"
#include <string.h>
#include "../include/READER_REG.h"
#include "../include/rfid_main.h"
#define CPU_DEBUG 0
struct CPU_CARD_STR CPU_CARD;
#if 0
unsigned char CPU_CARD_EVENT( void ){
return FAIL;
}
#else
unsigned char CPU_CARD_EVENT( void )
{
unsigned char result;
unsigned char SendBuffer[255];
unsigned char ReceiveBuffer[255];
unsigned char i;
transmission_struct APDU;
APDU.pSendBuffer = SendBuffer; /*<2A><><EFBFBD>÷<EFBFBD><C3B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
APDU.pReceiveBuffer = ReceiveBuffer; /*<2A><><EFBFBD>ý<EFBFBD><C3BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
result = CPU_Rats( &CPU_CARD.ATS.Length, CPU_CARD.ATS.Ats_Data );
if ( result != SUCCESS )
{
SetCW( DISABLE );
printf( "-> RATS ERROR!\r\n" );
return result;
}
printf( "-> ATS = " );
for(i = 0;i < CPU_CARD.ATS.Length;i++)
printf("%02X", CPU_CARD.ATS.Ats_Data[i]);
printf( "\r\n" );
result = Ats_Process( CPU_CARD.ATS.Length, CPU_CARD.ATS.Ats_Data );
if ( result != SUCCESS )
{
SetCW( DISABLE );
printf( "-> RATS ERROR!\r\n" );
return result;
}
memcpy( APDU.pSendBuffer, "\x00\xA4\x00\x00\x02\x3F\x00", 7 );
APDU.SendLength = 7;
result = CPU_APDU( &APDU );
if ( result != SUCCESS )
{
SetCW( DISABLE );
printf( "-> APDU ERROR!\r\n" );
return result;
}
printf( "->APDU = " );
for(i=0;i<APDU.ReceiveLength;i++)
printf("%02X", APDU.pReceiveBuffer[i] );
printf( "\r\n" );
memcpy(APDU.pSendBuffer,"\x00\xA4\x04\x00\x07\xD4\x10\x00\x00\x03\x00\x01",12);
APDU.SendLength = 12;
result = CPU_APDU(&APDU);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> APDU ERROR!\r\n");
return result;
}
printf("-> APDU = ");
for(i=0;i<APDU.ReceiveLength;i++)
printf("%02X",APDU.pReceiveBuffer[i]);
printf("\r\n");
memcpy(APDU.pSendBuffer,"\x00\xA4\x04\x00\x0E\x32\x50\x41\x59\x2E\x53\x59\x53\x2E\x44\x44\x46\x30\x31",19);
APDU.SendLength = 19;
result = CPU_APDU(&APDU);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> APDU ERROR!\r\n");
return result;
}
printf("-> Response = ");
for(i=0;i<APDU.ReceiveLength;i++)
printf("%02X",APDU.pReceiveBuffer[i]);
printf("\r\n");
memcpy(APDU.pSendBuffer,"\x00\xA4\x04\x00\x08\xA0\x00\x00\x03\x33\x01\x01\x01\x00",14);
APDU.SendLength = 14;
result = CPU_APDU(&APDU);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> APDU ERROR!\r\n");
return result;
}
printf("-> Response = ");
for(i=0;i<APDU.ReceiveLength;i++)
printf("%02X",APDU.pReceiveBuffer[i]);
printf("\r\n");
memcpy(APDU.pSendBuffer,"\x80\xA8\x00\x00\x24\x83\x22\x28\x00\x00\x80\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x01\x56\x00\x00\x00\x00\x00\x01\x56\x13\x08\x28\x82\x12\x34\x56\x78\x00\x00",42);
APDU.SendLength = 42;
result = CPU_APDU(&APDU);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> APDU ERROR!\r\n");
return result;
}
printf("-> Response = ");
for(i=0;i<APDU.ReceiveLength;i++)
printf("%02X",APDU.pReceiveBuffer[i]);
printf("\r\n");
memcpy( APDU.pSendBuffer, "\x00\x84\x00\x00\x08", 5 );
APDU.SendLength = 5;
result = CPU_APDU( &APDU );
if ( result != SUCCESS )
{
SetCW( DISABLE );
printf( "-> APDU ERROR!\r\n" );
return result;
}
printf( "-> Response = " );
for(i=0;i<APDU.ReceiveLength;i++)
printf("%02X",APDU.pReceiveBuffer[i]);
printf( "\r\n" );
return result;
}
#endif
#if 0
void Write_FIFO(unsigned char length,unsigned char* buff)
{
}
#else
void Write_FIFO(unsigned char length,unsigned char* buff)
{
unsigned char i;
for(i=0;i<length;i++)
{
SetReg(REG_FIFODATA,buff[i]);
}
}
#endif
#if 0
void Read_FIFO(unsigned char length,unsigned char* buff)
{
}
#else
void Read_FIFO(unsigned char length,unsigned char* buff)
{
unsigned char i;
for(i=0;i<length;i++)
{
GetReg(REG_FIFODATA,&buff[i]);
}
}
#endif
#if 0
unsigned char FM176XX_TPDU( transmission_struct *tpdu )
{
return FAIL;
}
#else
unsigned char FM176XX_TPDU( transmission_struct *tpdu )
{
unsigned char result,irq0,irq1,error;
unsigned int i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
SetReg(REG_IRQ0,0x7F);//Clear IRQ0
SetReg(REG_IRQ1,0x7F); //Clear IRQ1
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
Write_FIFO(tpdu->SendLength,tpdu->pSendBuffer);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
// SetTimer(tpdu->Timeout);
SetCommand(CMD_TRANSCEIVE);
for(i = 0;i < tpdu->Timeout; i++)
{
DelayMs(1);//<2F><><EFBFBD>յȴ<D5B5><C8B4><EFBFBD>ʱ
GetReg(REG_IRQ0,&irq0);
if(irq0 & BIT_RXIRQ)
{
GetReg( REG_ERROR, &error ); /*Get Error Status */
error = error & (BIT_NODATAERR | BIT_COLLDET | BIT_PROTERR | BIT_INTEGERR);
if(error != 0)
return FAIL;//<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD>
GetReg(REG_FIFOLENGTH,&tpdu->ReceiveLength);
if(tpdu->ReceiveLength > 0)
{
Read_FIFO(tpdu->ReceiveLength,tpdu->pReceiveBuffer);
result = SUCCESS;
return result;
}
}
GetReg(REG_IRQ1,&irq1);
// if(irq1 & BIT_TIMER1IRQ)
// {
// result = FAIL;//δ<><CEB4>timeoutʱ<74><CAB1><EFBFBD>ڽ<EFBFBD><DABD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD>
// }
}
result = FAIL;//δ<><CEB4>timeoutʱ<74><CAB1><EFBFBD>ڽ<EFBFBD><DABD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD>
return result;
}
#endif
/****************************************************************/
/*<2A><><EFBFBD><EFBFBD>: Rats */
/*<2A><><EFBFBD><EFBFBD>: Request for answer to select */
/*<2A><><EFBFBD><EFBFBD>: */
/* */
/*<2A><><EFBFBD>: */
/* ats_len<65><6E><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD>ATS<54><53><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> */
/* *ats<74><73><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><D5B5><EFBFBD>ATS<54><53><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8> */
/* OK: Ӧ<><D3A6><EFBFBD><EFBFBD>ȷ */
/* ERROR: Ӧ<><D3A6><EFBFBD><EFBFBD><EFBFBD> */
/****************************************************************/
#if 0
unsigned char CPU_Rats( unsigned char *ats_len, unsigned char *ats )
{
return FAIL;
}
#else
unsigned char CPU_Rats( unsigned char *ats_len, unsigned char *ats )
{
unsigned char result;
unsigned char outbuffer[2], inbuffer[64];
transmission_struct tpdu;
tpdu.pSendBuffer = outbuffer;
tpdu.pReceiveBuffer = inbuffer;
tpdu.pSendBuffer[0] = 0xE0; /*Start byte */
tpdu.pSendBuffer[1] = 0x50; /*default = 0x50 */
tpdu.SendLength = 2;
tpdu.Timeout = 160;
//CPU_CARD.FWT = 160;//Ĭ<><C4AC><EFBFBD><EFBFBD>ʱʱ<CAB1><CAB1>
result = FM176XX_TPDU( &tpdu );
if ( result == SUCCESS )
{
*ats_len = tpdu.ReceiveLength;
memcpy( ats, tpdu.pReceiveBuffer, *ats_len );
}
return (result);
}
#endif
#if 0
unsigned char Ats_Process( unsigned char ats_len, unsigned char *ats )/* ATS<54><53><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD> */
{
return FAIL;
}
#else
unsigned char Ats_Process( unsigned char ats_len, unsigned char *ats )/* ATS<54><53><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD> */
{
unsigned char result, offset;
if ( (ats_len == ats[0]) || (ats_len > 2) )/*TL */
{
CPU_CARD.FSCI = ats[1] & 0x0F;
if ( CPU_CARD.FSCI == 0 )
CPU_CARD.FSC = 13;
if ( CPU_CARD.FSCI == 1 )
CPU_CARD.FSC = 21;
if ( CPU_CARD.FSCI == 2 )
CPU_CARD.FSC = 29;
if ( CPU_CARD.FSCI == 3 )
CPU_CARD.FSC = 37;
if ( CPU_CARD.FSCI == 4 )
CPU_CARD.FSC = 45;
if ( CPU_CARD.FSCI == 5 )
CPU_CARD.FSC = 61;
if ( CPU_CARD.FSCI == 6 )
CPU_CARD.FSC = 93;
if ( CPU_CARD.FSCI == 7 )
CPU_CARD.FSC = 125;
if ( CPU_CARD.FSCI > 7 )
CPU_CARD.FSC = 253;
//CPU_CARD.FSC = 13;
printf( "-> CPU_CARD.FSC = %02X\r\n",CPU_CARD.FSC );
}
else
{
result = FAIL;
return (result);
}
offset = 0;
result = SUCCESS;
if ( ats[1] & BIT5 ) /*TA */
{
CPU_CARD.TA = ats[2];
offset++;
}
if ( ats[1] & BIT6 ) /*TB */
{
CPU_CARD.TB = ats[2 + offset];
CPU_CARD.SFGI = CPU_CARD.TB & 0x0F;
CPU_CARD.FWI = (CPU_CARD.TB >> 4) & 0x0F;
printf( "-> CPU_CARD.SFGI = %02X\r\n",CPU_CARD.SFGI );
printf( "-> CPU_CARD.FWI = %02X\r\n",CPU_CARD.FWI);
if ( CPU_CARD.FWI < 2 )
CPU_CARD.FWT = 1;
if ( CPU_CARD.FWI == 2 )
CPU_CARD.FWT = 2;
if ( CPU_CARD.FWI == 3 )
CPU_CARD.FWT = 3;
if ( CPU_CARD.FWI == 4 )
CPU_CARD.FWT = 5;
if ( CPU_CARD.FWI == 5 )
CPU_CARD.FWT = 10;
if ( CPU_CARD.FWI == 6 )
CPU_CARD.FWT = 20;
if ( CPU_CARD.FWI == 7 )
CPU_CARD.FWT = 40;
if ( CPU_CARD.FWI == 8 )
CPU_CARD.FWT = 80;
if ( CPU_CARD.FWI == 9 )
CPU_CARD.FWT = 160;
if ( CPU_CARD.FWI == 10 )
CPU_CARD.FWT = 310;
if ( CPU_CARD.FWI == 11 )
CPU_CARD.FWT = 620;
if ( CPU_CARD.FWI == 12 )
CPU_CARD.FWT = 1240;
if ( CPU_CARD.FWI == 13 )
CPU_CARD.FWT = 2480;
if ( CPU_CARD.FWI > 13 )
CPU_CARD.FWT = 4950;
offset++;
}
if ( ats[1] & BIT7 )/*TC */
{
CPU_CARD.TC = ats[2 + offset];
offset++;
}
CPU_CARD.PCB = 0x02;/*PCB<43><42>ʼֵΪ0x02 */
return (result);
}
#endif
#if 1
//xtell 同时把CPU_TPDU 和 CPU_NAk 用空函数替换 SPi正常
unsigned char CPU_NAK( transmission_struct *tpdu ) /* <20><>Ƭ<EFBFBD><C6AC><EFBFBD><EFBFBD>NAK */
{
return FAIL;
}
#else
unsigned char CPU_NAK( transmission_struct *tpdu ) /* <20><>Ƭ<EFBFBD><C6AC><EFBFBD><EFBFBD>NAK */
{
unsigned char result, tpdu_send_buffer[255],tpdu_receive_buffer[255];
tpdu->pSendBuffer = tpdu_send_buffer;
tpdu->pReceiveBuffer = tpdu_receive_buffer;
tpdu->pSendBuffer [0] = 0xB0 | CPU_CARD.PCB;
tpdu->SendLength = 1;
/*printf( "NAK\r\n" );*/
result = FM176XX_TPDU( tpdu );
return (result);
}
#endif
#if 0
unsigned char CPU_TPDU( transmission_struct *tpdu )
{
return FAIL;
}
#else
unsigned char CPU_TPDU( transmission_struct *tpdu )
{
unsigned char result, i, pcb_byte;
transmission_struct nak_tpdu;
result = FM176XX_TPDU( tpdu );
for ( i = 0; i < 3; i++ )
{
if ( result != SUCCESS )
{
result = CPU_NAK( &nak_tpdu );
if(result == SUCCESS)
{
if(nak_tpdu.ReceiveLength > 0)
{
memcpy( &pcb_byte, nak_tpdu.pReceiveBuffer, 1 );
if((pcb_byte & 0xF0) == 0xA0)//R(ACK)
{
#if CPU_DEBUG
printf("...pcb_byte = %02X\r\n",pcb_byte);
printf("...CPU_CARD.PCB = %02X\r\n",CPU_CARD.PCB);
#endif
if((pcb_byte & 0x03) != CPU_CARD.PCB)
{
result = FM176XX_TPDU( tpdu );
}
else
{
tpdu->pSendBuffer[0] = tpdu->pSendBuffer[0] ^ 0x01;//
CPU_CARD.PCB = tpdu->pSendBuffer[0] & 0x03;
result = FM176XX_TPDU( tpdu );
}
}
}
}
}
else
{
break;
}
}
return (result);
}
#endif
/****************************************************************/
/*<2A><><EFBFBD><EFBFBD>: CPU_APDU */
/*<2A><><EFBFBD><EFBFBD>: <20>ú<EFBFBD><C3BA><EFBFBD>ʵ<EFBFBD><CAB5>ת<EFBFBD><D7AA>APDU<44><55><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD> CPU card reset */
/*<2A><><EFBFBD><EFBFBD>: */
/* */
/*<2A><><EFBFBD>: */
/* ats_len<65><6E><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> */
/* ats<74><73><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8> */
/* OK: Ӧ<><D3A6><EFBFBD><EFBFBD>ȷ */
/* ERROR: Ӧ<><D3A6><EFBFBD><EFBFBD><EFBFBD> */
/****************************************************************/
#if 1
//xtell 同时把CPU_TPDU 和 CPU_NAk 用空函数替换 SPi正常
unsigned char CPU_APDU( transmission_struct *apdu )
{
return FAIL;
}
#else
unsigned char CPU_APDU( transmission_struct *apdu )
{
unsigned char result, pcb_byte, tpdu_send_buffer[255],tpdu_receive_buffer[255], i;
unsigned char unsent_length;
transmission_struct tpdu;
tpdu.pSendBuffer = tpdu_send_buffer;
tpdu.pReceiveBuffer = tpdu_receive_buffer;
tpdu.Timeout = CPU_CARD.FWT;
apdu->ReceiveLength = 0;
unsent_length = apdu->SendLength; /*<2A><><EFBFBD>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> */
for ( i = 0; i < 16; i++ ) /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̣<EFBFBD><CCA3><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1><EFBFBD>鳤<EFBFBD><E9B3A4>16<31><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>16<31><36><EFBFBD>鷢<EFBFBD><E9B7A2> */
{
#if CPU_DEBUG
printf("unsent_length = %02X\r\n",unsent_length);
#endif
if ( unsent_length < CPU_CARD.FSC )
{
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD><EFBFBD>֡<EFBFBD><D6A1><EFBFBD>ȣ<EFBFBD><C8A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
tpdu.pSendBuffer[0] = CPU_CARD.PCB; /*PCB<43>ֽ<EFBFBD>д<EFBFBD><D0B4>TPDU<44><55><EFBFBD><EFBFBD> */
memcpy( tpdu.pSendBuffer + 1, apdu->pSendBuffer + apdu->SendLength - unsent_length, unsent_length ); /*APDU<44><55><EFBFBD><EFBFBD>д<EFBFBD><D0B4>TPDU<44><55><EFBFBD><EFBFBD> */
tpdu.SendLength = unsent_length + 1; /*<2A><><EFBFBD>ͳ<EFBFBD><CDB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1 */
#if CPU_DEBUG
printf("--> ");
for(i=0;i<tpdu.SendLength;i++)
printf("%02X",tpdu.pSendBuffer[i]);
printf("\r\n");
#endif
result = CPU_TPDU( &tpdu );
if ( (result != SUCCESS) || (tpdu.ReceiveLength == 0) )
return (result);
#if CPU_DEBUG
printf("<-- ");
for(i=0;i<tpdu.ReceiveLength;i++)
printf("%02X",tpdu.pReceiveBuffer[i]);
printf("\r\n");
#endif
unsent_length = 0; /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD><EFBFBD><EFBFBD>0 */
break; /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݷ<EFBFBD><DDB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̺<EFBFBD><CCBA>˳<EFBFBD>ѭ<EFBFBD><D1AD> */
}
else
{
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3>ȴ<EFBFBD><C8B4>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֡<EFBFBD><D6A1><EFBFBD>ȣ<EFBFBD><C8A3><EFBFBD><EFBFBD>鷢<EFBFBD>ͣ<EFBFBD>ÿ<EFBFBD>鷢<EFBFBD>͵<EFBFBD><CDB5><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ<EFBFBD><CEAA>CPU_CARD.FSC - 1<><31> */
tpdu.pSendBuffer[0] = CPU_CARD.PCB | 0x10; /*PCB<43>ֽ<EFBFBD>д<EFBFBD><D0B4>TPDU<44><55><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӱ<EFBFBD>ʶ */
memcpy( tpdu.pSendBuffer + 1, apdu->pSendBuffer + apdu->SendLength - unsent_length, CPU_CARD.FSC - 1 ); /*APDU<44><55><EFBFBD><EFBFBD>д<EFBFBD><D0B4>TPDU<44><55><EFBFBD><EFBFBD> */
tpdu.SendLength = CPU_CARD.FSC; /*<2A><><EFBFBD>鷢<EFBFBD>ͳ<EFBFBD><CDB3><EFBFBD> */
#if CPU_DEBUG
printf("..--> ");
for(i=0;i<tpdu.SendLength;i++)
printf("%02X",tpdu.pSendBuffer[i]);
printf("\r\n");
#endif
result = CPU_TPDU( &tpdu );
#if CPU_DEBUG
printf("<-- ");
for(i=0;i<tpdu.ReceiveLength;i++)
printf("%02X",tpdu.pReceiveBuffer[i]);
printf("\r\n");
#endif
if ( (result != SUCCESS) && (tpdu.ReceiveLength == 1) )
return (result);
memcpy( &pcb_byte, tpdu.pReceiveBuffer, 1 ); /* */
if ( (pcb_byte == 0xA2) || (pcb_byte == 0xA3) )
{
unsent_length = unsent_length - (CPU_CARD.FSC - 1); /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> */
CPU_CARD.PCB = (pcb_byte & 0x0F) ^ 0x01; /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PCB<43>ֽ<EFBFBD> */
#if CPU_DEBUG
printf("unsent_length = %02X\r\n",unsent_length);
#endif
}
else
return (FAIL); /* */
}
}
for ( i = 0; i < 255; i++ ) /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̣<EFBFBD><CCA3><EFBFBD><EFBFBD>֧<EFBFBD><D6A7>255<35><35>ACK<43><4B><EFBFBD><EFBFBD>WTXӦ<58><D3A6> */
{
if ( (result != SUCCESS) || (tpdu.ReceiveLength == 0) )
return (FAIL);
memcpy( &pcb_byte, tpdu.pReceiveBuffer, 1 ); /*<2A><>ȡPCB<43>ֽ<EFBFBD> */
if ( (pcb_byte == 0x02) || (pcb_byte == 0x03) )
{
CPU_CARD.PCB = pcb_byte ^ 0x01; /*<2A><><EFBFBD><EFBFBD>PCB<43>ֽ<EFBFBD> */
#if CPU_DEBUG
printf("....CPU_CARD.PCB = %02X\r\n",CPU_CARD.PCB);
#endif
memcpy( apdu->pReceiveBuffer + apdu->ReceiveLength, tpdu.pReceiveBuffer + 1, tpdu.ReceiveLength - 1 );
apdu->ReceiveLength = apdu->ReceiveLength + tpdu.ReceiveLength - 1;
return (SUCCESS); /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><DDBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
}
if ( (pcb_byte == 0x12) || (pcb_byte == 0x13) )
{
memcpy( apdu->pReceiveBuffer + apdu->ReceiveLength, tpdu.pReceiveBuffer + 1, tpdu.ReceiveLength - 1 );
apdu->ReceiveLength = apdu->ReceiveLength + tpdu.ReceiveLength - 1;
tpdu.pSendBuffer[0] = ( (pcb_byte & 0x03) | 0xA0) ^ 0x01; /*<2A>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD>֡<EFBFBD><D6A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PCB<43>ֽ<EFBFBD> */
tpdu.SendLength = 1;
#if CPU_DEBUG
printf("...--> = ");
for(i=0;i<tpdu.SendLength;i++)
printf("%02X",tpdu.pSendBuffer[i]);
printf("\r\n");
#endif
result = CPU_TPDU( &tpdu ); /*<2A>ط<EFBFBD>ACK */
#if CPU_DEBUG
printf("<-- = ");
for(i=0;i<tpdu.ReceiveLength;i++)
printf("%02X",tpdu.pReceiveBuffer[i]);
printf("\r\n");
#endif
}
if ( (pcb_byte == 0xF2) || (pcb_byte == 0xF3) )
{
tpdu.SendLength = tpdu.ReceiveLength;
memcpy(tpdu.pSendBuffer ,tpdu.pReceiveBuffer ,tpdu.SendLength); /*<2A>յ<EFBFBD>WTX֡<58><D6A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>PCB<43>ֽ<EFBFBD> */
#if CPU_DEBUG
printf("....--> = ");
for(i=0;i<tpdu.SendLength;i++)
printf("%02X",tpdu.pSendBuffer[i]);
printf("\r\n");
#endif
result = CPU_TPDU( &tpdu ); /*<2A>ط<EFBFBD>WTX */
#if CPU_DEBUG
printf("<-- = ");
for(i=0;i<tpdu.ReceiveLength;i++)
printf("%02X",tpdu.pReceiveBuffer[i]);
printf("\r\n");
#endif
}
}
return (FAIL); /*<2A><><EFBFBD>մ<EFBFBD><D5B4><EFBFBD> */
}
#endif

491
apps/earphone/RFID/reader/MIFARE.c Normal file
View File

@ -0,0 +1,491 @@
#include "../include/MIFARE.h"
#include "../include/READER.h"
#include "string.h"
#include "../include/READER_REG.h"
#include "../include/rfid_main.h"
unsigned char SECTOR,BLOCK,BLOCK_NUM;
unsigned char BLOCK_DATA[16];
unsigned char KEY_A[16][6]=
{{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//0
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//1
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//2
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//3
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//4
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//5
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//6
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//7
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//8
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//9
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//10
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//11
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//12
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//13
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//14
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}};//15
unsigned char KEY_B[16][6]=
{{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//0
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//1
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//2
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//3
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//4
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//5
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//6
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//7
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//8
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//9
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//10
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//11
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//12
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//13
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},//14
{0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}};//15
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>Mifare_Clear_Crypto */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare_Clear_Crypto<74><6F><EFBFBD><EFBFBD><EFBFBD>֤<EFBFBD><D6A4>־ */
/*<2A><><EFBFBD>룺 */
/* */
/*<2A><><EFBFBD>: */
/* */
/* */
/*****************************************************************************************/
void Mifare_Clear_Crypto(void)
{
ModifyReg(REG_STATUS,BIT_CRYPTO1ON,RESET);
return;
}
unsigned char MIFARE_CARD_EVENTAAAAAAA(void)
{
unsigned char result;
Mifare_Clear_Crypto();
SECTOR = 1;
//for(SECTOR = 0;SECTOR < 16; SECTOR++)
{
BLOCK_NUM = (SECTOR * 4) + BLOCK;
result = Mifare_Auth(KEY_A_M1,SECTOR,KEY_A[SECTOR],PICC_A.UID);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> AUTH ERROR!\r\n");
return result;
}
printf("-> AUTH SUCCESS!\r\n");
for(BLOCK = 0;BLOCK < 3;BLOCK++)
{
BLOCK_NUM = (SECTOR * 4) + BLOCK;
if(BLOCK_NUM == 0)
BLOCK_NUM = 1;
printf("-> SECTOR = %02X\r\n",SECTOR);;
printf("-> BLOCK = %02X\r\n",BLOCK);
printf("-> BLOCK_NUM = %02X\r\n",BLOCK_NUM);
memcpy(BLOCK_DATA,"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",16);
result = Mifare_Blockwrite(BLOCK_NUM,BLOCK_DATA);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> WRITE BLOCK ERROR!\r\n");
return result;
}
printf("-> WRITE BLOCK SUCCESS!\r\n");
result = Mifare_Blockread(BLOCK_NUM,BLOCK_DATA);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> READ BLOCK ERROR!\r\n");
return result;
}
printf("-> READ BLOCK = %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\r\n",BLOCK_DATA[0],BLOCK_DATA[1],BLOCK_DATA[2],BLOCK_DATA[3],BLOCK_DATA[4],BLOCK_DATA[5],BLOCK_DATA[6],BLOCK_DATA[7],BLOCK_DATA[8],BLOCK_DATA[9],BLOCK_DATA[10],BLOCK_DATA[11],BLOCK_DATA[12],BLOCK_DATA[13],BLOCK_DATA[14],BLOCK_DATA[15]);
}
}
SetCW(DISABLE);
return result;
}
unsigned char MIFARE_CARD_EVENT(void)
{
unsigned char result;
Mifare_Clear_Crypto();
SECTOR = 1;
//for(SECTOR = 0;SECTOR < 16; SECTOR++)
{
BLOCK_NUM = (SECTOR * 4) + BLOCK;
result = Mifare_Auth(KEY_A_M1,SECTOR,KEY_A[SECTOR],PICC_A.UID);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> AUTH ERROR!\r\n");
return result;
}
printf("-> AUTH SUCCESS!\r\n");
for(BLOCK = 0;BLOCK < 3;BLOCK++)
{
BLOCK_NUM = (SECTOR * 4) + BLOCK;
if(BLOCK_NUM == 0)
BLOCK_NUM = 1;
printf("-> SECTOR = %02X\r\n",SECTOR);;
printf("-> BLOCK = %02X\r\n",BLOCK);
printf("-> BLOCK_NUM = %02X\r\n",BLOCK_NUM);
memcpy(BLOCK_DATA,"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",16);
result = Mifare_Blockwrite(BLOCK_NUM,BLOCK_DATA);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> WRITE BLOCK ERROR!\r\n");
return result;
}
printf("-> WRITE BLOCK SUCCESS!\r\n");
result = Mifare_Blockread(BLOCK_NUM,BLOCK_DATA);
if(result != SUCCESS)
{
SetCW(DISABLE);
printf("-> READ BLOCK ERROR!\r\n");
return result;
}
printf("-> READ BLOCK = %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\r\n",BLOCK_DATA[0],BLOCK_DATA[1],BLOCK_DATA[2],BLOCK_DATA[3],BLOCK_DATA[4],BLOCK_DATA[5],BLOCK_DATA[6],BLOCK_DATA[7],BLOCK_DATA[8],BLOCK_DATA[9],BLOCK_DATA[10],BLOCK_DATA[11],BLOCK_DATA[12],BLOCK_DATA[13],BLOCK_DATA[14],BLOCK_DATA[15]);
}
}
SetCW(DISABLE);
return result;
}
unsigned char Mifare_LoadKey(unsigned char *mifare_key)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,mifare_key[0]);
SetReg(REG_FIFODATA,mifare_key[1]);
SetReg(REG_FIFODATA,mifare_key[2]);
SetReg(REG_FIFODATA,mifare_key[3]);
SetReg(REG_FIFODATA,mifare_key[4]);
SetReg(REG_FIFODATA,mifare_key[5]);
SetCommand(CMD_LOADKEY);
DelayMs(1);
GetReg(REG_COMMAND,&reg_data);
if((reg_data & CMD_MASK) == CMD_IDLE)
return SUCCESS;
else
return FAIL;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>Mifare_Auth */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare_Auth<74><68>Ƭ<EFBFBD><C6AC>֤ */
/*<2A><><EFBFBD>룺mode<64><65><EFBFBD><EFBFBD>֤ģʽ<C4A3><CABD>0<EFBFBD><30>key A<><41>֤<EFBFBD><D6A4>1<EFBFBD><31>key B<><42>֤<EFBFBD><D6A4><EFBFBD><EFBFBD>sector<6F><72><EFBFBD><EFBFBD>֤<EFBFBD><D6A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ţ<EFBFBD>0~15<31><35> */
/* *mifare_key<65><79>6<EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>֤<EFBFBD><D6A4>Կ<EFBFBD><D4BF><EFBFBD>飻*card_uid<69><64>4<EFBFBD>ֽڿ<D6BD>ƬUID<49><44><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>: */
/* OK :<3A><>֤<EFBFBD>ɹ<EFBFBD> */
/* ERROR :<3A><>֤ʧ<D6A4><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Auth(unsigned char key_mode,unsigned char sector,unsigned char *mifare_key,unsigned char *card_uid)
{
unsigned char result,reg_data;
result = Mifare_LoadKey(mifare_key);
if (result != SUCCESS)
return result;
SetCommand(CMD_IDLE);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
if(key_mode == KEY_A_M1)
{
SetReg(REG_FIFODATA,0x60);//60 keyA M1<4D><31>ָ֤<D6A4><D6B8>
ModifyReg(REG_RXTXCON,BIT_SHMODE,DISABLE);
}
if(key_mode == KEY_B_M1)
{
SetReg(REG_FIFODATA,0x61);//61 keyB M1<4D><31>ָ֤<D6A4><D6B8>
ModifyReg(REG_RXTXCON,BIT_SHMODE,DISABLE);
}
SetReg(REG_FIFODATA,sector * 4);//<2F><>֤<EFBFBD><D6A4><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD>0<EFBFBD><30>ַ
SetReg(REG_FIFODATA,card_uid[0]);
SetReg(REG_FIFODATA,card_uid[1]);
SetReg(REG_FIFODATA,card_uid[2]);
SetReg(REG_FIFODATA,card_uid[3]);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_AUTHENT);
DelayMs(5);
GetReg(REG_COMMAND,&reg_data);
if((reg_data & CMD_MASK) == CMD_IDLE)
{
GetReg(REG_STATUS,&reg_data);
if(reg_data & BIT_CRYPTO1ON)//<2F>жϼ<D0B6><CFBC>ܱ<EFBFBD>־λ<D6BE><CEBB>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD>֤<EFBFBD><D6A4><EFBFBD>
return SUCCESS;
}
return FAIL;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>Mifare_Blockset */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare_Blockset<65><74>Ƭ<EFBFBD><C6AC>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>룺block<63><6B><EFBFBD><EFBFBD>ţ<EFBFBD>*buff<66><66><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD>õ<EFBFBD>4<EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD> */
/* */
/*<2A><><EFBFBD>: */
/* OK :<3A><><EFBFBD>óɹ<C3B3> */
/* ERROR :<3A><><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Blockset(unsigned char block,unsigned char *data_buff)
{
unsigned char block_data[16],result;
block_data[0] = data_buff[3];
block_data[1] = data_buff[2];
block_data[2] = data_buff[1];
block_data[3] = data_buff[0];
block_data[4] = ~data_buff[3];
block_data[5] = ~data_buff[2];
block_data[6] = ~data_buff[1];
block_data[7] = ~data_buff[0];
block_data[8] = data_buff[3];
block_data[9] = data_buff[2];
block_data[10] = data_buff[1];
block_data[11] = data_buff[0];
block_data[12] = block;
block_data[13] = ~block;
block_data[14] = block;
block_data[15] = ~block;
result = Mifare_Blockwrite(block,block_data);
return result;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>Mifare_Blockread */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare_Blockread<61><64>Ƭ<EFBFBD><C6AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>룺block<63><6B><EFBFBD><EFBFBD>ţ<EFBFBD>0x00~0x3F<33><46><EFBFBD><EFBFBD>buff<66><66>16<31>ֽڶ<D6BD><DAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>: */
/* OK :<3A>ɹ<EFBFBD> */
/* ERROR :ʧ<><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Blockread(unsigned char block,unsigned char *data_buff)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
SetReg(REG_FIFODATA,0x30);//30 <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
SetReg(REG_FIFODATA,block);//<2F><><EFBFBD>ַ
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(2);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 16) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ16
return FAIL;
GetReg(REG_ERROR,&reg_data);
if(reg_data & 0x07)
return FAIL;
for(i=0;i<16;i++)
{
GetReg (REG_FIFODATA,&data_buff[i]);
}
return SUCCESS;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>mifare_blockwrite */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare<72><65>Ƭд<C6AC><D0B4><EFBFBD><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>룺block<63><6B><EFBFBD><EFBFBD>ţ<EFBFBD>0x00~0x3F<33><46><EFBFBD><EFBFBD>buff<66><66>16<31>ֽ<EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>: */
/* OK :<3A>ɹ<EFBFBD> */
/* ERROR :ʧ<><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Blockwrite(unsigned char block,unsigned char *data_buff)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
SetReg(REG_FIFODATA,0xA0);//A0 д<><D0B4>ָ<EFBFBD><D6B8>
SetReg(REG_FIFODATA,block);//<2F><><EFBFBD>ַ
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
for(i=0;i<16;i++)
{
SetReg(REG_FIFODATA,data_buff[i]);
}
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
return SUCCESS;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD> */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare <20><>Ƭ<EFBFBD><C6AC>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>룺block<63><6B><EFBFBD><EFBFBD>ţ<EFBFBD>0x00~0x3F<33><46><EFBFBD><EFBFBD>buff<66><66>4<EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>: */
/* OK :<3A>ɹ<EFBFBD> */
/* ERROR :ʧ<><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Blockinc(unsigned char block,unsigned char *data_buff)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
SetReg(REG_FIFODATA,0xC1);//C1 <20><>ֵָ<D6B5><D6B8>
SetReg(REG_FIFODATA,block);//<2F><><EFBFBD>ַ
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
for(i=0;i<4;i++)
{
SetReg(REG_FIFODATA,data_buff[i]);
}
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
return SUCCESS;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>mifare_blockdec */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare <20><>Ƭ<EFBFBD><C6AC>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>룺block<63><6B><EFBFBD><EFBFBD>ţ<EFBFBD>0x00~0x3F<33><46><EFBFBD><EFBFBD>buff<66><66>4<EFBFBD>ֽڼ<D6BD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>: */
/* OK :<3A>ɹ<EFBFBD> */
/* ERROR :ʧ<><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Blockdec(unsigned char block,unsigned char *data_buff)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
SetReg(REG_FIFODATA,0xC0);//C0 <20><>ֵָ<D6B5><D6B8>
SetReg(REG_FIFODATA,block);//<2F><><EFBFBD>ַ
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
for(i=0;i<4;i++)
{
SetReg(REG_FIFODATA,data_buff[i]);
}
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
return SUCCESS;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>mifare_transfer */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare <20><>Ƭtransfer<65><72><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>룺block<63><6B><EFBFBD><EFBFBD>ţ<EFBFBD>0x00~0x3F<33><46> */
/*<2A><><EFBFBD>: */
/* OK :<3A>ɹ<EFBFBD> */
/* ERROR :ʧ<><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Transfer(unsigned char block)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
SetReg(REG_FIFODATA,0xC1);//C1 Transferָ<72><D6B8>
SetReg(REG_FIFODATA,block);//<2F><><EFBFBD>ַ
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
return SUCCESS;
}
/*****************************************************************************************/
/*<2A><><EFBFBD>ƣ<EFBFBD>mifare_restore */
/*<2A><><EFBFBD>ܣ<EFBFBD>Mifare <20><>Ƭrestore<72><65><EFBFBD><EFBFBD> */
/*<2A><><EFBFBD>룺block<63><6B><EFBFBD><EFBFBD>ţ<EFBFBD>0x00~0x3F<33><46> */
/*<2A><><EFBFBD>: */
/* OK :<3A>ɹ<EFBFBD> */
/* ERROR :ʧ<><CAA7> */
/*****************************************************************************************/
unsigned char Mifare_Restore(unsigned char block)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
SetReg(REG_FIFODATA,0xC2);//C1 Transferָ<72><D6B8>
SetReg(REG_FIFODATA,block);//<2F><><EFBFBD>ַ
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
for(i=0;i<4;i++)
{
SetReg(REG_FIFODATA,0);
}
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if (reg_data != 1) //<2F><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>Ϊ1
return FAIL;
GetReg (REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
return SUCCESS;
}

76
apps/earphone/RFID/reader/NTAG.c Normal file
View File

@ -0,0 +1,76 @@
#include "../include/READER.h"
#include "../include/NTAG.h"
#include <string.h>
#include "../include/READER_REG.h"
#include "../include/rfid_main.h"
unsigned char PAGE_DATA[16];
unsigned char NTAG_EVENT(void)
{
unsigned char result;
memcpy(PAGE_DATA,"\x01\x02\x03\x04",4);
result = Write_Page(8,PAGE_DATA);
if (result != SUCCESS)
return result;
printf("PAGE 8 Write OK\r\n");
result = Read_Page(8,PAGE_DATA);
printf("PAGE 8 = %02X%02X%02X%02X\r\n",PAGE_DATA[0],PAGE_DATA[1],PAGE_DATA[2],PAGE_DATA[3]);
return result;
}
unsigned char Read_Page(unsigned char page_num,unsigned char *page_data)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
Clear_FIFO();
SetReg(REG_FIFODATA,0x30);
SetReg(REG_FIFODATA,page_num);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_ERROR,&reg_data);
if(reg_data & 0x07)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 16)
return FAIL;
for(i=0;i<16;i++)
{
GetReg(REG_FIFODATA,&page_data[i]);
}
return SUCCESS;
}
unsigned char Write_Page(unsigned char page_num,unsigned char *page_data)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
Clear_FIFO();
SetReg(REG_FIFODATA,0xA2);
SetReg(REG_FIFODATA,page_num);
SetReg(REG_FIFODATA,page_data[0]);
SetReg(REG_FIFODATA,page_data[1]);
SetReg(REG_FIFODATA,page_data[2]);
SetReg(REG_FIFODATA,page_data[3]);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(5);
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 1)
return FAIL;
GetReg(REG_FIFODATA,&reg_data);
if(reg_data != 0x0A)
return FAIL;
return SUCCESS;
}

809
apps/earphone/RFID/reader/READER.c Normal file
View File

@ -0,0 +1,809 @@
//#include "fm15l0xx_ll_spi.h"
#include "../include/READER.h"
#include "../include/READER_REG.h"
#include <stdio.h>
#include "../include/rfid_main.h"
struct picc_a_struct PICC_A;
struct picc_b_struct PICC_B;
struct picc_v_struct PICC_V;
struct picc_f_struct PICC_F;
void DelayMs( uint32_t xms );
void DelayUs( uint32_t xus );
void DelayUs( uint32_t xus )
{
int t;
while ( xus-- )
{
t = 5;
while ( t-- )
;
}
}
void DelayMs( uint32_t xms )
{
DelayUs( xms * 1000 );
}
// void Reader_GPIO_Init( void )
// {
/******** 重做GPIO初始化 **********/
// // LL_GPIO_SetPinMode( PD_GPIO, PD_PIN, LL_GPIO_PINxMODE_OUTPUT );//PA7 PD
// //LL_GPIO_EnablePinPullUp( SPI_GPIO, SCK_PIN | MOSI_PIN ); // Enable Pullup
// //xtell注释
// // LL_GPIO_SetPinMode( SPI_GPIO, SCK_PIN, LL_GPIO_PINxMODE_OUTPUT ); // PB1 Digital function - SPI1 SCK
// // LL_GPIO_SetPinMode( SPI_GPIO, MISO_PIN, LL_GPIO_PINxMODE_INPUT ); // PB2 Digital function - SPI1 MISO1
// // LL_GPIO_SetPinMode( SPI_GPIO, MOSI_PIN, LL_GPIO_PINxMODE_OUTPUT ); // PB3 Digital function - SPI1 MOSI
// LL_GPIO_SetPinMode(); //xtell
// SCK_0;
// MOSI_0;
//
// LL_GPIO_SetPinMode(); //xtell
// //xtell注释
// // LL_GPIO_SetPinMode( SPI_GPIO, NSS_PIN, LL_GPIO_PINxMODE_OUTPUT ); // PB0 Digital function - SPI1 NSS1
// PD_0;
// NSS_1;
// }
// unsigned char FM176XX_HardReset(void)
// {
/*************NFC 硬件初始化 重做********************/
// unsigned char reg_data;
// NSS_1;//NSS = 1
// PD_1;//RST = 1
// DelayMs(1);
// PD_0;//RST = 0
// DelayMs(1);
// GetReg(REG_COMMAND,&reg_data);
// if (reg_data != 0x40)
// return FAIL;
// return SUCCESS;
// }
// unsigned char Reader_Set_HPD( unsigned char mode ) //mode = DISABLE <20>˳<EFBFBD>HPDģʽ <20><>mode = ENABLE <20><><EFBFBD><EFBFBD>HPDģʽ
// {
// if ( mode == ENABLE )
// {
// DelayMs( 1 ); //<2F><>ʱ1ms
// /******设置一个GPIO输出高*******xtell******/
// //PD_1; // PD = 1
// P34 = 1;
// }
// else
// {
// /******设置一个GPIO输出低*************/
// //PD_0; //PD = 0
// P34 =0;
// DelayMs( 1 ); //<2F><>ʱ1ms<6D><73><EFBFBD>ȴ<EFBFBD>Reader<65><72><EFBFBD><EFBFBD>
// }
// return (mode);
// }
//***********************************************
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƣ<EFBFBD>GetReg(unsigned char addr,unsigned char *regdata)
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD>ȡ<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>ֵ
//<2F><>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD>addr:Ŀ<><C4BF>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>ַ regdata:<3A><>ȡ<EFBFBD><C8A1>ֵ
//<2F><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD>unsigned char TRUE<55><45><EFBFBD><EFBFBD>ȡ<EFBFBD>ɹ<EFBFBD> FALSE:ʧ<><CAA7>
//***********************************************
// 从FM17660 读取数据时，BIT7 置 1
// unsigned char GetReg(unsigned char address,unsigned char *reg_data)
// {
// unsigned char spi_data,i;
// NSS_0; //NSS = 0;
// spi_data = (address << 1) | 0x01;
// for(i=0;i<8;i++)
// {
// if(spi_data & 0x80)
// MOSI_1;
// else
// MOSI_0;
// SCK_1;
// spi_data = spi_data<<1;
// SCK_0;
// }
// MOSI_0;
// *reg_data = 0;
// for(i=0;i<8;i++)
// {
// *reg_data = *reg_data<<1;
// SCK_1;
// if(LL_GPIO_ReadInputPort(SPI_GPIO)& MISO_PIN)
// *reg_data = *reg_data | 0x01;
// SCK_0;
// }
// NSS_1; //NSS = 1;
// return SUCCESS;
// }
//***********************************************
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƣ<EFBFBD>SetReg(unsigned char addr,unsigned char* regdata)
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܣ<EFBFBD>д<EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
//<2F><>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD>addr:Ŀ<><C4BF>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>ַ regdata:Ҫд<D2AA><D0B4><EFBFBD>ֵ
//<2F><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD>unsigned char TRUE<55><45>д<EFBFBD>ɹ<EFBFBD> FALSE:дʧ<D0B4><CAA7>
//***********************************************
// unsigned char SetReg(unsigned char address,unsigned char reg_data)
// {
// unsigned char spi_data,i;
// NSS_0; //NSS = 0;
// spi_data = (address << 1) & 0xFE;
// for(i=0;i<8;i++)
// {
// if(spi_data & 0x80)
// MOSI_1;
// else
// MOSI_0;
// SCK_1;
// spi_data = spi_data<<1;
// SCK_0;
// }
// MOSI_0;
// spi_data = reg_data;
// for(i=0;i<8;i++)
// {
// if(spi_data & 0x80)
// MOSI_1;
// else
// MOSI_0;
// SCK_1;
// spi_data = spi_data<<1;
// SCK_0;
// }
// SCK_0;
// MOSI_0;
// NSS_1; //NSS = 1;
// return SUCCESS;
// }
void ModifyReg( unsigned char reg_address, unsigned char mask, unsigned char set )
{
unsigned char reg_data;
// Uart1SendString(" ModifyReg begin ");
GetReg( reg_address, &reg_data );
if ( set )
{
reg_data |= mask;
}
else
{
reg_data &= ~mask;
}
SetReg( reg_address, reg_data );
return;
}
unsigned char SetCommand(unsigned char command)
{
unsigned char result;
result = SetReg(REG_COMMAND,CMD_MASK & command);
return result;
}
void SetTimer(unsigned int timeout) //
{
unsigned long prescale = 1;
unsigned long t,fc;
fc = timeout*13560;
t = fc;
while(fc > 65535)
{
prescale*=2;
fc = t/prescale;
if(fc*prescale != t)
fc++;
}
if(prescale>1)
{
SetReg(REG_T0CONTROL, BIT_TSTOP_RX | BIT_TSTART_TX | BIT_TAUTORESTARTED | VALUE_TCLK_1356_MHZ );
SetReg(REG_T0RELOADHI,(u8)(fc>>8));
SetReg(REG_T0RELOADLO,(u8)fc);
SetReg(REG_T1CONTROL, BIT_TSTOP_RX | BIT_TSTART_TX | VALUE_TCLK_T0 );
SetReg(REG_T1RELOADHI,(u8)(prescale>>8));
SetReg(REG_T1RELOADLO,(u8)prescale);
}
else
{
SetReg(REG_T1CONTROL, BIT_TSTOP_RX | BIT_TSTART_TX | VALUE_TCLK_1356_MHZ );
SetReg(REG_T1RELOADHI,(u8)(fc>>8));
SetReg(REG_T1RELOADLO,(u8)fc);
}
}
unsigned char SetCW(unsigned char mode)
{
unsigned char result;
if(mode == ENABLE)
{
ModifyReg(REG_COMMAND,BIT_MODEMOFF,DISABLE);
ModifyReg(REG_TXMODE,BIT0 | BIT1,ENABLE);
}
else
{
ModifyReg(REG_COMMAND,BIT_MODEMOFF,ENABLE);
ModifyReg(REG_TXMODE,BIT0 | BIT1,DISABLE);
}
DelayMs(5);
return result;
}
void Clear_FIFO(void)
{
unsigned char fifolength;
GetReg(REG_FIFOLENGTH,&fifolength);
if((fifolength) != 0) //FIFO<46><4F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>գ<EFBFBD><D5A3><EFBFBD>FLUSH FIFO
{
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE);
}
return ;
}
unsigned char LoadProtocol(unsigned char p_rx,unsigned char p_tx)
{
unsigned char reg_data = 0;
// Uart1SendString(" LoadProtocol begin ");
SetCommand(CMD_IDLE); //
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,p_rx);//Rx
SetReg(REG_FIFODATA,p_tx);//Tx
SetCommand(CMD_LOADPROTOCOL);
DelayMs(2);
GetReg(REG_COMMAND,&reg_data);
if(reg_data != CMD_IDLE)
return FAIL;
return SUCCESS;
}
void SetParity(unsigned char state)
{
// Uart1SendString(" SetParity begin");
ModifyReg(REG_FRAMECON,BIT_TXPARITYEN|BIT_RXPARITYEN,state);
}
unsigned char ReaderA_Initial(void)
{
// Uart1SendString(" ReaderA_Initial begin");
LoadProtocol(RX_TYPEA_106,TX_TYPEA_106);
ModifyReg(REG_TXMODE,BIT2,ENABLE);//FORCE 100ask ENABLE
SetReg(REG_TXAMP,AMPLITUDE_A);
SetReg(REG_TXCON,0x00);
SetReg(REG_RXANA,(HPCF_A<<3)|GAIN_A);
SetReg(0x5F,0x08);
SetReg(REG_THNSET,0xFF);
SetReg(REG_THNMIN,0xC0);
SetReg(REG_RXTXCON,0x80);//
SetParity(ENABLE);
SetReg(REG_STATUS,0);//<2F><><EFBFBD>Cry1Onλ
// Uart1SendString(" ReaderA_Initial end");
return SUCCESS;
}
unsigned char ReaderB_Initial(void)
{
LoadProtocol(RX_TYPEB_106,TX_TYPEB_106);
ModifyReg(REG_TXMODE,BIT2,DISABLE);//FORCE 100ask DISABLE
SetReg(REG_TXAMP,AMPLITUDE_B);
SetReg(REG_TXCON,MODULATION_B);
SetReg(REG_RXANA,(HPCF_B<<3)|GAIN_B);
SetReg(0x5F,0x08);
SetReg(REG_THNSET,0xFF);
SetReg(REG_THNMIN,0xC0);
SetReg(REG_RXTXCON,0x80);//
return SUCCESS;
}
unsigned char ReaderV_Initial(void)
{
LoadProtocol(RX_TYPEV_26,RX_TYPEV_26);
ModifyReg(REG_RXANA,BIT3|BIT2|BIT1|BIT0,DISABLE);
ModifyReg(REG_RXANA,(HPCF_V<<3)|GAIN_V,ENABLE);//39h
SetParity(DISABLE);
SetReg(REG_TXAMP,AMPLITUDE_V);
SetReg(REG_TXCON,MODULATION_V);
SetReg(REG_TXI,0x06);
SetReg(REG_THNSET,0xFF);
SetReg(REG_THNMIN,0x80);
SetReg(REG_THNADJ,0x08);
SetReg(REG_RXTXCON,0);
return SUCCESS;
}
unsigned char ReaderF_Initial(void)
{
ModifyReg(REG_MISC, 0x04,ENABLE);
LoadProtocol(RX_FELICA_212,TX_FELICA_212);
SetReg(REG_TXAMP,AMPLITUDE_F); //
SetReg(REG_TXCON,MODULATION_F);
ModifyReg(REG_RXANA,BIT3|BIT2|BIT1|BIT0,DISABLE);
ModifyReg(REG_RXANA,(HPCF_F<<3)|GAIN_F,ENABLE);//39h
SetParity(DISABLE);
SetReg(REG_THNSET,0xFF);
SetReg(REG_THNMIN,0x80);
SetReg(REG_THNADJ,0x08);
ModifyReg(REG_MISC, 0x04,DISABLE);
return SUCCESS;
}
unsigned char ReaderA_Wakeeup(struct picc_a_struct *picc_a)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x0F);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,RF_CMD_WUPA);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,DISABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(2);
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 2)
return FAIL;
GetReg(REG_FIFODATA,&picc_a->ATQA[0]);
GetReg(REG_FIFODATA,&picc_a->ATQA[1]);
return SUCCESS;
}
unsigned char ReaderA_Request(struct picc_a_struct *picc_a)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x0F);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,RF_CMD_REQA);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,DISABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
// DelayMs(2);
Delay1ms();
Delay1ms();
GetReg(REG_FIFOLENGTH,&reg_data);
// Uart1SendString("REG_FIFOLENGTH data=");
// printHex(reg_data);
if(reg_data != 2)
return FAIL;
GetReg(REG_FIFODATA,&picc_a->ATQA[0]);
GetReg(REG_FIFODATA,&picc_a->ATQA[1]);
return SUCCESS;
}
unsigned char ReaderA_Anticoll(struct picc_a_struct *picc_a)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,RF_CMD_ANTICOLL[picc_a->CASCADE_LEVEL]);
SetReg(REG_FIFODATA,0x20);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,DISABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,DISABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(2);
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 5)
return FAIL;
GetReg(REG_FIFODATA,&picc_a->UID[picc_a->CASCADE_LEVEL*4]);
GetReg(REG_FIFODATA,&picc_a->UID[picc_a->CASCADE_LEVEL*4+1]);
GetReg(REG_FIFODATA,&picc_a->UID[picc_a->CASCADE_LEVEL*4+2]);
GetReg(REG_FIFODATA,&picc_a->UID[picc_a->CASCADE_LEVEL*4+3]);
GetReg(REG_FIFODATA,&picc_a->BCC[picc_a->CASCADE_LEVEL]);
if( (picc_a->UID[picc_a->CASCADE_LEVEL*4] ^ picc_a->UID[picc_a->CASCADE_LEVEL*4+1] ^ picc_a->UID[picc_a->CASCADE_LEVEL*4+2] ^ picc_a->UID[picc_a->CASCADE_LEVEL*4+3]) == picc_a->BCC[picc_a->CASCADE_LEVEL])
return SUCCESS;
return FAIL;
}
unsigned char ReaderA_Select(struct picc_a_struct *picc_a)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,RF_CMD_ANTICOLL[picc_a->CASCADE_LEVEL]);
SetReg(REG_FIFODATA,0x70);
SetReg(REG_FIFODATA,picc_a->UID[picc_a->CASCADE_LEVEL*4]);
SetReg(REG_FIFODATA,picc_a->UID[picc_a->CASCADE_LEVEL*4+1]);
SetReg(REG_FIFODATA,picc_a->UID[picc_a->CASCADE_LEVEL*4+2]);
SetReg(REG_FIFODATA,picc_a->UID[picc_a->CASCADE_LEVEL*4+3]);
SetReg(REG_FIFODATA,picc_a->BCC[picc_a->CASCADE_LEVEL]);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(2);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 1)
return FAIL;
GetReg(REG_FIFODATA,&picc_a->SAK [picc_a->CASCADE_LEVEL]);
return SUCCESS;
}
unsigned char ReaderA_CardActivate(struct picc_a_struct *picc_a)
{
unsigned char result,cascade_level;
result = ReaderA_Request(picc_a);//
if (result != SUCCESS)
return result;
if ((picc_a->ATQA[0]&0xC0)==0x00) //1<><31>UID
{
cascade_level = 1;
picc_a->UID_Length = 4;
}
if ((picc_a->ATQA[0]&0xC0)==0x40) //2<><32>UID
{
cascade_level = 2;
picc_a->UID_Length = 8;
}
if ((picc_a->ATQA[0]&0xC0)==0x80) //3<><33>UID
{
cascade_level = 3;
picc_a->UID_Length = 12;
}
for (picc_a->CASCADE_LEVEL = 0; picc_a->CASCADE_LEVEL < cascade_level; picc_a->CASCADE_LEVEL++)
{
result = ReaderA_Anticoll(picc_a);//
if (result != SUCCESS)
return result;
result = ReaderA_Select(picc_a);//
if (result != SUCCESS)
return result;
}
picc_a->CASCADE_LEVEL--;
return result;
}
unsigned char ReaderB_Wakeup(struct picc_b_struct *picc_b)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x05); //APf
SetReg(REG_FIFODATA, 0x00); //AFI (00:for all cards)
SetReg(REG_FIFODATA, 0x08); //PARAM(REQB,Number of slots =0)
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)//<2F>жϴ<D0B6><CFB4><EFBFBD><EFBFBD>־
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 12)//<2F>жϽ<D0B6><CFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD>
return FAIL;
for(i=0;i<12;i++)
GetReg(REG_FIFODATA,&picc_b->ATQB [i]);
memcpy(picc_b->PUPI,picc_b->ATQB + 1,4);
memcpy(picc_b->APPLICATION_DATA,picc_b->ATQB + 6,4);
memcpy(picc_b->PROTOCOL_INF,picc_b->ATQB + 10,3);
return SUCCESS;
}
unsigned char ReaderB_Request(struct picc_b_struct *picc_b)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x05); //APf
SetReg(REG_FIFODATA, 0x00); //AFI (00:for all cards)
SetReg(REG_FIFODATA, 0x00); //PARAM(REQB,Number of slots =0)
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 12)
return FAIL;
for(i=0;i<12;i++)
GetReg(REG_FIFODATA,&picc_b->ATQB [i]);
memcpy(picc_b->PUPI,picc_b->ATQB + 1,4);
memcpy(picc_b->APPLICATION_DATA,picc_b->ATQB + 6,4);
memcpy(picc_b->PROTOCOL_INF,picc_b->ATQB + 10,3);
return SUCCESS;
}
unsigned char ReaderB_Attrib(struct picc_b_struct *picc_b)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x1D); //
SetReg(REG_FIFODATA, picc_b->PUPI[0]); //
SetReg(REG_FIFODATA, picc_b->PUPI[1]); //
SetReg(REG_FIFODATA, picc_b->PUPI[2]); //
SetReg(REG_FIFODATA, picc_b->PUPI[3]); //
SetReg(REG_FIFODATA, 0x00); //Param1
SetReg(REG_FIFODATA, 0x08); //Param2 BIT0~BIT3 Frame Size 0 = 16, 1 = 24, 2 = 32, 3 = 40, 4 = 48, 5 = 64, 6 = 96, 7 = 128, 8 = 256
//Param2 BIT4~BIT5 TX BaudRate BIT6~BIT7 RX BaudRate,00 = 106Kbps, 01 = 212Kbps, 10 = 424Kbps, 11 = 848Kbps
SetReg(REG_FIFODATA, 0x01); //COMPATIBLE WITH 14443-4
SetReg(REG_FIFODATA, 0x01); //CID:01
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 1)
return FAIL;
GetReg(REG_FIFODATA,&reg_data);
picc_b->CID = reg_data & 0x0F;
return SUCCESS;
}
unsigned char ReaderB_Halt(struct picc_b_struct *picc_b)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x50); //
SetReg(REG_FIFODATA, picc_b->PUPI[0]); //
SetReg(REG_FIFODATA, picc_b->PUPI[1]); //
SetReg(REG_FIFODATA, picc_b->PUPI[2]); //
SetReg(REG_FIFODATA, picc_b->PUPI[3]); //
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 1)
return FAIL;
GetReg(REG_FIFODATA,&reg_data);
*picc_b->Answer_to_HALT = reg_data & 0x0F;
return SUCCESS;
}
unsigned char ReaderB_Get_SN(struct picc_b_struct *picc_b)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x00); //
SetReg(REG_FIFODATA, 0x36); //
SetReg(REG_FIFODATA, 0x00); //
SetReg(REG_FIFODATA, 0x00); //
SetReg(REG_FIFODATA, 0x08); //
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 10)
return FAIL;
for(i=0;i<8;i++)
GetReg(REG_FIFODATA,&picc_b->SN[i]);
return SUCCESS;
}
unsigned char ReaderV_Inventory(struct picc_v_struct *picc_v)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x26); //
SetReg(REG_FIFODATA, 0x01);
SetReg(REG_FIFODATA, 0x00);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 10)
return FAIL;
GetReg(REG_FIFODATA,&picc_v->RESPONSE );
GetReg(REG_FIFODATA,&reg_data);
for(i = 0;i < 8; i++)
{
GetReg(REG_FIFODATA,&picc_v->UID[i]);
}
return SUCCESS;
}
unsigned char ReaderV_Select(struct picc_v_struct *picc_v)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x22);
SetReg(REG_FIFODATA, 0x25); //
SetReg(REG_FIFODATA, picc_v->UID[0]);
SetReg(REG_FIFODATA, picc_v->UID[1]);
SetReg(REG_FIFODATA, picc_v->UID[2]);
SetReg(REG_FIFODATA, picc_v->UID[3]);
SetReg(REG_FIFODATA, picc_v->UID[4]);
SetReg(REG_FIFODATA, picc_v->UID[5]);
SetReg(REG_FIFODATA, picc_v->UID[6]);
SetReg(REG_FIFODATA, picc_v->UID[7]);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 1)
return FAIL;
GetReg(REG_FIFODATA,&picc_v->RESPONSE );
return SUCCESS;
}
unsigned char ReaderV_ReadSingleBlock(unsigned char block_num,struct picc_v_struct *picc_v)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,0x12);
SetReg(REG_FIFODATA, 0x20); //
SetReg(REG_FIFODATA, block_num);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 5)
return FAIL;
GetReg(REG_FIFODATA,&picc_v->RESPONSE );
for(i = 0;i < 4; i++)
{
GetReg(REG_FIFODATA,&picc_v->BLOCK_DATA[i]);
}
return SUCCESS;
}
unsigned char ReaderV_WriteSingleBlock(unsigned char block_num,struct picc_v_struct *picc_v)
{
unsigned char reg_data;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA,0x02);
SetReg(REG_FIFODATA, 0x21); //
SetReg(REG_FIFODATA, block_num);
SetReg(REG_FIFODATA, picc_v->BLOCK_DATA[0]);
SetReg(REG_FIFODATA, picc_v->BLOCK_DATA[1]);
SetReg(REG_FIFODATA, picc_v->BLOCK_DATA[2]);
SetReg(REG_FIFODATA, picc_v->BLOCK_DATA[3]);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 1)
return FAIL;
GetReg(REG_FIFODATA,&picc_v->RESPONSE );
return SUCCESS;
}
unsigned char ReaderF_Inventory(struct picc_f_struct *picc_f)
{
unsigned char reg_data,i;
SetCommand(CMD_IDLE);
SetReg(REG_TXDATANUM,0x08);
ModifyReg(REG_FIFOCONTROL,BIT_FIFOFLUSH,ENABLE); //Clear FIFO
SetReg(REG_FIFODATA, 0x06);
SetReg(REG_FIFODATA, 0x00); //
SetReg(REG_FIFODATA, 0xFF);
SetReg(REG_FIFODATA, 0xFF);
SetReg(REG_FIFODATA, 0x10);
SetReg(REG_FIFODATA, 0x00);
ModifyReg(REG_TXCRCCON, BIT_CRCEN,ENABLE);
ModifyReg(REG_RXCRCCON, BIT_CRCEN,ENABLE);
SetCommand(CMD_TRANSCEIVE);
DelayMs(10);
GetReg(REG_ERROR,&reg_data);
if((reg_data & 0x0F)!=0)
return FAIL;
GetReg(REG_FIFOLENGTH,&reg_data);
if(reg_data != 18)
return FAIL;
GetReg(REG_FIFODATA,&reg_data);
GetReg(REG_FIFODATA,&reg_data);
for(i = 0;i < 8; i++)
{
GetReg(REG_FIFODATA,&picc_f->UID[i]);
}
return SUCCESS;
}

360
apps/earphone/RFID/reader/rfid_main.c Normal file
View File

@ -0,0 +1,360 @@
/********************************************************************************************************
* @file rfid_main.c
* @brief RFID 读卡器应用层主逻辑文件
* @details
* 本文件包含了RFID读卡器的主要应用逻辑，负责初始化RFID模块，并根据不同的卡片类型（Type A, B, V, F）
* 执行相应的寻卡、激活和数据交换流程。
* 原代码是为51单片机编写，现已进行重构，移除了所有硬件相关的代码（如GPIO、SPI、UART的直接操作），
* 并引入了硬件抽象层（HAL）的概念。所有底层硬件操作都通过 `rfid_hal.h` 中定义的接口函数完成，
* 以便于在STM32等不同平台上进行移植。
*
* @author Kilo Code
* @date 2025-11-24
* @version 1.0
*
* @note
* - 您需要在使用本模块前，在您的平台上实现 `rfid_hal.h` 中声明的所有硬件接口函数。
* - `rfid_task()` 函数是一个示例性的主任务循环，您可以根据您的实际应用需求进行修改或集成。
* - 文件中保留了对不同卡片类型事件的处理函数（`TYPE_A_EVENT`, `TYPE_B_EVENT`等），
* 这些是RFID协议的核心逻辑。
********************************************************************************************************/
#include "../include/rfid_main.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "../include/READER.h"
#include "../include/READER_REG.h"
#include "../include/MIFARE.h"
#include "../include/NTAG.h"
#include "rfid_hal.h" // 引入硬件抽象层头文件
// 宏定义，用于调试信息输出。您需要实现 rfid_hal.h 中的 rfid_log_debug 函数
#define rfid_printf rfid_log_debug
/**
* @brief 将一个字节的整数转换为两位十六进制字符串。
* @param buf [out] 存储转换后字符串的缓冲区，长度至少为3。
* @param num [in] 要转换的无符号字符。
* @return 无。
*/
static void IntToHex(unsigned char *buf, unsigned char num)
{
const unsigned char digits[] = "0123456789ABCDEF";
buf[0] = digits[(num >> 4) & 0x0F]; // 高4位
buf[1] = digits[num & 0x0F]; // 低4位
buf[2] = '\0';
}
/**
* @brief 通过调试接口打印一个字节的十六进制值。
* @param num [in] 要打印的无符号字符。
* @return 无。
*/
static void printHex(unsigned char num)
{
unsigned char buf[3];
IntToHex(buf, num);
rfid_printf((const char *)buf);
}
/**
* @brief 处理Type A卡片事件。
* @details
* 该函数执行ISO/IEC 14443 Type A卡片的完整激活流程，包括：
* 1. 初始化读卡器以支持Type A协议。
* 2. 打开RF场。
* 3. 请求（Request）和防冲突（Anticollision），最终激活卡片。
* 4. 根据卡片的SAK（Select Acknowledge）值，判断卡片具体类型（如Mifare, NTAG, CPU卡）并调用相应的处理函数。
* 5. 操作结束后关闭RF场。
* @return 无。
*/
void TYPE_A_EVENT(void)
{
unsigned char result;
rfid_printf("TYPE_A_EVENT begin\n");
// 初始化读卡器为Type A模式
result = ReaderA_Initial();
if (result != SUCCESS)
{
rfid_printf("INIT_ERROR\r\n");
SetCW(DISABLE);
return;
}
// 打开RF场（载波）
result = SetCW(ENABLE);
if (result != SUCCESS)
{
rfid_printf("CW_ERROR\r\n");
SetCW(DISABLE);
return;
}
// 激活Type A卡片
result = ReaderA_CardActivate(&PICC_A);
if (result != SUCCESS)
{
// rfid_printf("ReaderA_CardActivate_ERROR\r\n");
SetCW(DISABLE);
return;
}
rfid_printf("************* TYPE A CARD ************* \r\n");
rfid_printf("-> ATQA = %02X%02X\r\n", PICC_A.ATQA[0], PICC_A.ATQA[1]);
if (PICC_A.UID_Length == 4)
{
rfid_printf("-> UID = %02X%02X%02X%02X\r\n", PICC_A.UID[0], PICC_A.UID[1], PICC_A.UID[2], PICC_A.UID[3]);
}
else if (PICC_A.UID_Length > 4) // 支持更长的UID
{
rfid_printf("-> UID = ");
for (int i = 0; i < PICC_A.UID_Length; i++)
{
rfid_printf("%02X", PICC_A.UID[i]);
}
rfid_printf("\r\n");
}
rfid_printf("-> SAK = %02X\r\n", PICC_A.SAK[0]);
// 根据SAK值判断卡片类型
if (PICC_A.SAK[0] == 0x08)
{
rfid_printf("************* Mifare CARD ************* \r\n");
result = MIFARE_CARD_EVENT();
}
else if ((PICC_A.SAK[0] == 0x28) || (PICC_A.SAK[0] == 0x20))
{
rfid_printf("************* CPU CARD ************* \r\n");
// result = CPU_CARD_EVENT(); // CPU卡处理函数，暂未实现
}
else if (PICC_A.SAK[0] == 0x04)
{
rfid_printf("************* NTAG CARD ************* \r\n");
result = NTAG_EVENT();
}
SetCW(DISABLE); // 关闭RF场
}
/**
* @brief 处理Type B卡片事件。
* @details
* 该函数执行ISO/IEC 14443 Type B卡片的激活流程，包括：
* 1. 初始化读卡器以支持Type B协议。
* 2. 打开RF场。
* 3. 发送REQB/WUPB命令寻卡。
* 4. 发送ATTRIB命令选卡。
* 5. 获取卡片序列号（SN）。
* 6. 操作结束后关闭RF场。
* @return 无。
*/
void TYPE_B_EVENT(void)
{
unsigned char result;
rfid_printf("TYPE_B_EVENT begin\n");
ReaderB_Initial();
SetCW(ENABLE);
result = ReaderB_Request(&PICC_B);
if (result != SUCCESS)
{
SetCW(DISABLE);
return;
}
rfid_printf("************* TYPE B CARD ************* \r\n");
// 打印ATQB信息
rfid_printf("-> ATQB = ");
for(int i=0; i<12; i++) rfid_printf("%02X", PICC_B.ATQB[i]);
rfid_printf("\r\n");
result = ReaderB_Attrib(&PICC_B);
if (result != SUCCESS)
{
SetCW(DISABLE);
return;
}
rfid_printf("-> ATTRIB = %02X\r\n", PICC_B.CID);
result = ReaderB_Get_SN(&PICC_B);
if (result != SUCCESS)
{
SetCW(DISABLE);
return;
}
rfid_printf("-> SN = ");
for(int i=0; i<8; i++) rfid_printf("%02X", PICC_B.SN[i]);
rfid_printf("\r\n");
SetCW(DISABLE);
}
/**
* @brief 处理Type V (ISO/IEC 15693) 卡片事件。
* @details
* 该函数执行ISO/IEC 15693 Vicinity卡片的交互流程，包括：
* 1. 初始化读卡器以支持15693协议。
* 2. 打开RF场。
* 3. 发送Inventory命令寻卡并获取UID。
* 4. 发送Select命令选择卡片。
* 5. 示例性地对第4块进行写操作，然后再读回校验。
* 6. 操作结束后关闭RF场。
* @return 无。
*/
void TYPE_V_EVENT(void)
{
unsigned char result, i;
rfid_printf("TYPE_V_EVENT begin\n");
ReaderV_Initial();
SetCW(ENABLE);
result = ReaderV_Inventory(&PICC_V);
if (result != SUCCESS)
{
SetCW(DISABLE);
rfid_printf("-> ReaderV Inventory ERROR!\r\n");
return;
}
rfid_printf("************* TYPE V CARD ************* \r\n");
rfid_printf("UID=");
for (i = 0; i < 8; i++)
{
printHex(PICC_V.UID[i]);
}
rfid_printf("\r\n");
result = ReaderV_Select(&PICC_V);
if (result != SUCCESS)
{
SetCW(DISABLE);
rfid_printf("-> ReaderV Select ERROR!\r\n");
return;
}
// 示例：写单个块
memcpy(PICC_V.BLOCK_DATA, "\x11\x22\x33\x44", 4);
result = ReaderV_WriteSingleBlock(4, &PICC_V);
if (result != SUCCESS)
{
SetCW(DISABLE);
rfid_printf("-> ReaderV WriteSingleBlock ERROR!\r\n");
return;
}
rfid_printf("WriteSingleBlock SUCCESS\r\n");
// 示例：读单个块
result = ReaderV_ReadSingleBlock(4, &PICC_V);
if (result != SUCCESS)
{
SetCW(DISABLE);
rfid_printf("-> ReaderV ReadSingleBlock ERROR!\r\n");
return;
}
rfid_printf("BLOCK DATA = %02X%02X%02X%02X \r\n", PICC_V.BLOCK_DATA[0], PICC_V.BLOCK_DATA[1], PICC_V.BLOCK_DATA[2], PICC_V.BLOCK_DATA[3]);
SetCW(DISABLE);
}
/**
* @brief 处理Type F (FeliCa) 卡片事件。
* @details
* 该函数执行FeliCa卡片的交互流程，包括：
* 1. 初始化读卡器以支持FeliCa协议。
* 2. 打开RF场。
* 3. 发送Inventory命令寻卡并获取UID。
* 4. 后续可以添加与FeliCa卡的数据交换命令。
* 5. 操作结束后关闭RF场。
* @note 当前实现仅包含寻卡部分，具体的TPDU命令交换被注释掉了，因为它们依赖于一个未提供的 `CPU_TPDU` 函数。
* @return 无。
*/
void TYPE_F_EVENT(void)
{
unsigned char result, i;
// unsigned char SendBuffer[255];
// unsigned char ReceiveBuffer[255];
// transmission_struct TPDU;
// TPDU.pSendBuffer = SendBuffer;
// TPDU.pReceiveBuffer = ReceiveBuffer;
rfid_printf("TYPE_F_EVENT begin\n");
ReaderF_Initial();
SetCW(ENABLE);
result = ReaderF_Inventory(&PICC_F);
if (result != SUCCESS)
{
SetCW(DISABLE);
return;
}
rfid_printf("************* TYPE F CARD ************* \r\n");
rfid_printf("->TYPE F UID = ");
for(i=0; i<8; i++) rfid_printf("%02X", PICC_F.UID[i]);
rfid_printf("\r\n");
// 此处省略了原代码中复杂的TPDU数据交换部分，
// 因为它依赖于一个未定义的 CPU_TPDU 函数。
// 如果需要与CPU卡进行数据交换，您需要实现相关的APDU指令封装和解析。
SetCW(DISABLE);
}
/**
* @brief RFID模块的主任务函数。
* @details
* 这是一个示例性的任务函数，展示了如何初始化RFID芯片并进入一个无限循环来轮询不同类型的卡片。
* 您可以将此函数作为一个独立的任务运行，或者将其中的逻辑集成到您现有的任务调度中。
* 1. 调用 `rfid_hal_init()` 初始化底层硬件。
* 2. 调用 `FM176XX_HardReset()` 硬复位RFID芯片。
* 3. 检查芯片版本号，确认通信正常。
* 4. 在主循环中，依次调用不同卡片类型的事件处理函数。
* @return 无。
*/
void rfid_task(void)
{
unsigned char result, reg_data;
// 1. 初始化底层硬件 (SPI, GPIO, UART, Delay)
// 这个函数需要您在 rfid_hal.c 中实现
rfid_hal_init();
// 2. 硬复位 FM176XX 芯片
while (1)
{
result = FM176XX_HardReset();
if (result != SUCCESS)
{
rfid_printf("FM176XX HardReset FAIL\r\n");
rfid_delay_ms(1000); // 延时后重试
}
else
{
rfid_printf("FM176XX HardReset SUCCESS\r\n");
break;
}
}
// 3. 读取芯片版本号，确认通信是否正常
GetReg(REG_VERSION, &reg_data);
rfid_printf("REG_VERSION = %02X\r\n", reg_data);
// 4. 进入主循环，轮询不同类型的卡
while (1)
{
// 您可以根据需要取消注释来测试不同类型的卡
// TYPE_A_EVENT();
// TYPE_B_EVENT();
TYPE_V_EVENT(); // 当前默认只测试 Type V (15693) 卡
// TYPE_F_EVENT();
rfid_delay_ms(500); // 每次轮询后延时
}
}