m500auc.c

RFID的一些程序设计

	MSndBuffer[31] = 0x02; // RegIRqPinConfig    
	MSndBuffer[32] = 0x00; // RFU    
	MSndBuffer[33] = 0x00; // RFU
	MInfo.nBytesToSend   = 34;
	     
	status = M500PcdCmd(PCD_WRITEE2,
	                   MSndBuffer,
	                   MRcvBuffer,
	                   &MInfo); // write e2
	return status;
	}
	
	///////////////////////////////////////////////////////////////////////
	//          M I F A R E   R E M O T E   A N T E N N A
	//  Configuration of master module
	///////////////////////////////////////////////////////////////////////
	char M500PcdMfInOutMasterConfig(void)
	{
	WriteIO(RegRxControl2,0x42);
	WriteIO(RegTxControl,0x10);
	WriteIO(RegBitPhase,0x11);
	
	return MI_OK;
	}     
	
	///////////////////////////////////////////////////////////////////////
	//          M A S T E R   K E Y   L O A D 
	///////////////////////////////////////////////////////////////////////
	char M500PcdLoadMk(unsigned char  auth_mode,  // KEYA or KEYB
	               unsigned char  key_addr,   // 0 <= key_addr <= 15
	               unsigned char  *mk)        // 6 bytes uncoded master key
	{
	unsigned char idata offset = (auth_mode == PICC_AUTHENT1A) ? 0 : 6;
	
	memcpy(MKeys[key_addr] + offset,mk,6);
	return MI_OK;
	}
	              
	///////////////////////////////////////////////////////////////////////
	//          E E P R O M   M A S T E R   K E Y   L O A D 
	///////////////////////////////////////////////////////////////////////
	char M500PcdLoadKeyE2(unsigned char key_type,
	                      unsigned char sector,
	                      unsigned char *uncoded_keys)
	{
	char idata status = MI_OK;
	// eeprom address calculation
	// 0x80 ... offset
	// key_sector ... sector
	// 0x18 ... 2 * 12 = 24 = 0x18
	unsigned short idata e2addr = 0x80 + sector * 0x18;
	unsigned char idata *e2addrbuf = (unsigned char*)&e2addr;
	unsigned char idata keycoded[12];
	
	if (key_type == PICC_AUTHENT1B)
	  e2addr += 12; // key B offset   
	
	FlushFIFO();    // empty FIFO
	ResetInfo(MInfo);
	
	M500HostCodeKey(uncoded_keys,keycoded);
	memcpy(MSndBuffer,e2addrbuf,2); // write low and high byte of address
	MSndBuffer[2] = MSndBuffer[0];    // Move the LSB of the 2-bytes
	MSndBuffer[0] = MSndBuffer[1];    // address to the first byte
	MSndBuffer[1] = MSndBuffer[2];
	memcpy(&MSndBuffer[2],keycoded,12); // write 12 bytes of coded keys
	MInfo.nBytesToSend   = 14;
	
	// write load command
	status = M500PcdCmd(PCD_WRITEE2,
			MSndBuffer,
			MRcvBuffer,
			&MInfo);         
	
	return status;
	}
	
	///////////////////////////////////////////////////////////////////////
	//          E E P R O M   R E A D   
	///////////////////////////////////////////////////////////////////////
	char PcdReadE2(unsigned short startaddr,
	           unsigned char length,
	           unsigned char* _data)
	{
	char status = MI_OK;
	
	 // ************* Cmd Sequence ********************************** 
	 ResetInfo(MInfo);   
	 MSndBuffer[0] = startaddr & 0xFF;
	 MSndBuffer[1] = (startaddr >> 8) & 0xFF;
	 MSndBuffer[2] = length;
	 MInfo.nBytesToSend   = 3;
	 status = M500PcdCmd(PCD_READE2,
	                     MSndBuffer,
	                     MRcvBuffer,
	                     &MInfo);
	if (status == MI_OK)
	{
	   memcpy(_data,MRcvBuffer,length);
	}
	else   // Response Processing
	{
	   _data[0] = 0;
	}
	return status ;
	}
	
	///////////////////////////////////////////////////////////////////////
	//          E E P R O M   W R I T E 
	///////////////////////////////////////////////////////////////////////
	char PcdWriteE2(unsigned short startaddr,
	            unsigned char length,
	            unsigned char* _data)
	{
	char status = MI_OK;
	
	 // ************* Cmd Sequence ********************************** 
	ResetInfo(MInfo);   
	MSndBuffer[0] = startaddr & 0xFF;
	MSndBuffer[1] = (startaddr >> 8) & 0xFF;
	memcpy(MSndBuffer + 2,_data,length);
	
	MInfo.nBytesToSend   = length + 2;
	     
	status = M500PcdCmd(PCD_WRITEE2,
	                   MSndBuffer,
	                   MRcvBuffer,
	                   &MInfo); // write e2
	return status;
	}   
	
	///////////////////////////////////////////////////////////////////////
	//          C O N F I G   M F O U T   S E L E C T 
	///////////////////////////////////////////////////////////////////////
	char M500PcdMfOutSelect(unsigned char type)
	{
	WriteIO(RegMfOutSelect,type&0x7);
	return MI_OK;
	}
	
	///////////////////////////////////////////////////////////////////////
	//          W R I T E   R E G I S T E R 
	///////////////////////////////////////////////////////////////////////
	char M500PcdWriteRegister(unsigned char Reg, unsigned char value)
	{
	WriteIO(Reg,value);
	return MI_OK;
	}
	
	///////////////////////////////////////////////////////////////////////
	//          R E A D   R E G I S T E R 
	///////////////////////////////////////////////////////////////////////
	char M500PcdReadRegister(unsigned char Reg)
	{
	char value;
	
	value = ReadIO(Reg);
	return (value);
	}
	 
	///////////////////////////////////////////////////////////////////////
	//          M I F A R E    R E Q U E S T 
	///////////////////////////////////////////////////////////////////////
	char M500PiccRequest(unsigned char req_code, // request code ALL = 0x52 
	                                         // or IDLE = 0x26 
	               unsigned char *atq)     // answer to request
	{
	return M500PiccCommonRequest(req_code,atq);
	}
	
	///////////////////////////////////////////////////////////////////////
	//          M I F A R E   C O M M O N   R E Q U E S T 
	///////////////////////////////////////////////////////////////////////
	char M500PiccCommonRequest(unsigned char req_code, 
	                     unsigned char *atq)
	{
	char idata status = MI_OK;
	
	//************* initialize ******************************
	WriteIO(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
	ClearBitMask(RegControl,0x08);    // disable crypto 1 unit   
	WriteIO(RegBitFraming,0x07);        // set TxLastBits to 7 
	SetBitMask(RegTxControl,0x03);    // Tx2RF-En, Tx1RF-En enable
	
	ResetInfo(MInfo);   
	MSndBuffer[0] = req_code;
	MInfo.nBytesToSend   = 1;   
	status = M500PcdCmd(PCD_TRANSCEIVE,
	                  MSndBuffer,
	                  MRcvBuffer,
	                  &MInfo);
	
	if (status)      // error occured
	{
	  *atq = 0;
	} 
	else 
	{
	  if (MInfo.nBitsReceived != 16) // 2 bytes expected
	  {
	     *atq = 0;
	     status = MI_BITCOUNTERR;
	  } 
	  else 
	  {
	     status = MI_OK;
	     memcpy(atq,MRcvBuffer,2);
	  }
	}
	return status; 
	}
	
	///////////////////////////////////////////////////////////////////////
	//          M I F A R E    A N T I C O L L I S I O N
	// for standard select
	///////////////////////////////////////////////////////////////////////
	char M500PiccAnticoll (unsigned char bcnt,
	                 unsigned char *snr)
	{
	return M500PiccCascAnticoll(0x93,bcnt,snr); // first cascade level
	}
	
	///////////////////////////////////////////////////////////////////////
	//          M I F A R E    A N T I C O L L I S I O N
	// for extended serial numbers
	///////////////////////////////////////////////////////////////////////
	char M500PiccCascAnticoll (unsigned char select_code,
	                       unsigned char bcnt,       
	                       unsigned char *snr)       
	{
	char idata status = MI_OK;
	char idata snr_in[4];     // copy of the input parameter snr
	char idata nbytes = 0;
	char idata nbits = 0;
	char idata complete = 0;
	char idata i        = 0;
	char idata byteOffset = 0;
	unsigned char idata snr_crc;
	unsigned char idata snr_check;
	unsigned char dummyShift1;       // dummy byte for snr shift
	unsigned char dummyShift2;       // dummy byte for snr shift   
	
	//************* Initialisation ******************************
	M500PcdSetTmo(106);
	memcpy(snr_in,snr,4);   
	
	WriteIO(RegDecoderControl,0x28); // ZeroAfterColl aktivieren   
	ClearBitMask(RegControl,0x08);    // disable crypto 1 unit
	  
	//************** Anticollision Loop ***************************
	complete = 0;
	//   bcnt = 0;   // no part of the snr is known
	while (!complete && (status == MI_OK) )
	{
	  ResetInfo(MInfo);           
	  WriteIO(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
	  nbits = bcnt % 8;   // remaining number of bits
	  if (nbits)
	  {
	     WriteIO(RegBitFraming,nbits << 4 | nbits); // TxLastBits/RxAlign auf nb_bi
	     nbytes = bcnt / 8 + 1;   
	     // number of bytes known
	
	     // in order to solve an inconsistancy in the anticollision sequence
	     // (will be solved soon), the case of 7 bits has to be treated in a
	     // separate way - please note the errata sheet
	     if (nbits == 7)
	     {
	        MInfo.cmd = PICC_ANTICOLL1;   // pass command flag to ISR        
	        WriteIO(RegBitFraming,nbits); // reset RxAlign to zero
	     }
	  } 
	  else
	  {
	     nbytes = bcnt / 8;
	  }
	
	  MSndBuffer[0] = select_code;
	  MSndBuffer[1] = 0x20 + ((bcnt/8) << 4) + nbits; //number of bytes send
	           
	  for (i = 0; i < nbytes; i++)  // Sende Buffer beschreiben
	  {
	     MSndBuffer[i + 2] = snr_in[i];
	  }
	  MInfo.nBytesToSend   = 2 + nbytes;   
	
	  status = M500PcdCmd(PCD_TRANSCEIVE,
	                     MSndBuffer,
	                     MRcvBuffer,
	                     &MInfo);
	
	
	  // in order to solve an inconsistancy in the anticollision sequence
	  // (will be solved soon), the case of 7 bits has to be treated in a
	  // separate way 
	  if (nbits == 7)
	  {
	     // reorder received bits
	     dummyShift1 = 0x00;
	     for (i = 0; i < MInfo.nBytesReceived; i++)
	     {
	        dummyShift2 = MRcvBuffer[i];
	        MRcvBuffer[i] = (dummyShift1 >> (i+1)) | (MRcvBuffer[i] << (7-i));
	        dummyShift1 = dummyShift2;
	     }
	     MInfo.nBitsReceived -= MInfo.nBytesReceived; // subtract received parity bits
	     // recalculation of collision position
	     if ( MInfo.collPos ) MInfo.collPos += 7 - (MInfo.collPos + 6) / 9;
	  }
	     
	  if ( status == MI_OK || status == MI_COLLERR)    // no other occured
	  {
	     // R e s p o n s e   P r o c e s s i n g   
	     if ( MInfo.nBitsReceived != (40 - bcnt) ) // not 5 bytes answered
	     {
	        status = MI_BITCOUNTERR; // Exit with error
	     } 
	     else 
	     {
	        byteOffset = 0;
	        if( nbits != 0 ) // last byte was not complete
	        {
	            snr_in[nbytes - 1] = snr_in[nbytes - 1] | MRcvBuffer[0];
	            byteOffset = 1;
	        }
	
	        for ( i =0; i < (4 - nbytes); i++)     
	        {
	           snr_in[nbytes + i] = MRcvBuffer[i + byteOffset];
	        }
	
	        if (status != MI_COLLERR ) // no error and no collision
	        {
	           // SerCh check
	           snr_crc = snr_in[0] ^ snr_in[1] ^ snr_in[2] ^ snr_in[3];
	           snr_check = MRcvBuffer[MInfo.nBytesReceived - 1];
	           if (snr_crc != snr_check)
	           {
	              status = MI_SERNRERR;
	           } 
	           else   
	           {
	              complete = 1;
	           }
	        }
	        else                   // collision occured
	        {
	           bcnt = bcnt + MInfo.collPos - nbits;
	           status = MI_OK;
	        }
	     }
	  }
	}
	if (status == MI_OK)
	{
	  // transfer snr_in to snr
	  memcpy(snr,snr_in,4);
	}
	else
	{
	  memcpy(snr,"0000",4);
	}
	
	//----------------------Einstellungen aus Initialisierung ruecksetzen 
	ClearBitMask(RegDecoderControl,0x20); // ZeroAfterColl disable
	
	return status;  
	}
	
	///////////////////////////////////////////////////////////////////////
	//          M I F A R E    S E L E C T 
	// for std. select
	///////////////////////////////////////////////////////////////////////
	char M500PiccSelect(unsigned char *snr, 
	              unsigned char *sak)
	{
	return M500PiccCascSelect(0x93,snr,sak); // first cascade level
	}