libs/RFID.MFRC522
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

style space to tab

Browse Source 
no code change, just style
This commit is contained in:
Rotzbua
2015-03-15 20:07:39 +01:00
parent 56d2777eb3
commit 2dc9124ffc
2 changed files with 294 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
MFRC522.cpp
View File

@@ -279,71 +279,69 @@ void MFRC522::PCD_SetAntennaGain(byte mask) {
* @return Whether or not the test passed. * @return Whether or not the test passed.
*/ */
bool MFRC522::PCD_PerformSelfTest() { bool MFRC522::PCD_PerformSelfTest() {
// This follows directly the steps outlined in 16.1.1 // This follows directly the steps outlined in 16.1.1
// 1. Perform a soft reset.
PCD_Reset();
// 1. Perform a soft reset. // 2. Clear the internal buffer by writing 25 bytes of 00h
PCD_Reset(); byte ZEROES[25] = {0x00};
PCD_SetRegisterBitMask(FIFOLevelReg, 0x80); // flush the FIFO buffer
PCD_WriteRegister(FIFODataReg, 25, ZEROES); // write 25 bytes of 00h to FIFO
PCD_WriteRegister(CommandReg, PCD_Mem); // transfer to internal buffer
// 2. Clear the internal buffer by writing 25 bytes of 00h // 3. Enable self-test
byte ZEROES[25] = {0x00}; PCD_WriteRegister(AutoTestReg, 0x09);
PCD_SetRegisterBitMask(FIFOLevelReg, 0x80); // flush the FIFO buffer
PCD_WriteRegister(FIFODataReg, 25, ZEROES); // write 25 bytes of 00h to FIFO
PCD_WriteRegister(CommandReg, PCD_Mem); // transfer to internal buffer
// 3. Enable self-test // 4. Write 00h to FIFO buffer
PCD_WriteRegister(AutoTestReg, 0x09); PCD_WriteRegister(FIFODataReg, 0x00);
// 4. Write 00h to FIFO buffer // 5. Start self-test by issuing the CalcCRC command
PCD_WriteRegister(FIFODataReg, 0x00); PCD_WriteRegister(CommandReg, PCD_CalcCRC);
// 5. Start self-test by issuing the CalcCRC command // 6. Wait for self-test to complete
PCD_WriteRegister(CommandReg, PCD_CalcCRC); word i;
byte n;
for (i = 0; i < 0xFF; i++) {
n = PCD_ReadRegister(DivIrqReg); // DivIrqReg[7..0] bits are: Set2 reserved reserved MfinActIRq reserved CRCIRq reserved reserved
if (n & 0x04) { // CRCIRq bit set - calculation done
break;
}
}
PCD_WriteRegister(CommandReg, PCD_Idle); // Stop calculating CRC for new content in the FIFO.
// 6. Wait for self-test to complete // 7. Read out resulting 64 bytes from the FIFO buffer.
word i; byte result[64];
byte n; PCD_ReadRegister(FIFODataReg, 64, result, 0);
for (i = 0; i < 0xFF; i++) {
n = PCD_ReadRegister(DivIrqReg); // DivIrqReg[7..0] bits are: Set2 reserved reserved MfinActIRq reserved CRCIRq reserved reserved
if (n & 0x04) { // CRCIRq bit set - calculation done
break;
}
}
PCD_WriteRegister(CommandReg, PCD_Idle); // Stop calculating CRC for new content in the FIFO.
// 7. Read out resulting 64 bytes from the FIFO buffer. // Auto self-test done
byte result[64]; // Reset AutoTestReg register to be 0 again. Required for normal operation.
PCD_ReadRegister(FIFODataReg, 64, result, 0); PCD_WriteRegister(AutoTestReg, 0x00);
// Auto self-test done // Determine firmware version (see section 9.3.4.8 in spec)
byte version = PCD_ReadRegister(VersionReg);
// Reset AutoTestReg register to be 0 again. Required for normal operation. // Pick the appropriate reference values
PCD_WriteRegister(AutoTestReg, 0x00); const byte *reference;
switch (version) {
case 0x91: // Version 1.0
reference = MFRC522_firmware_referenceV1_0;
break;
case 0x92: // Version 2.0
reference = MFRC522_firmware_referenceV2_0;
break;
default: // Unknown version
return false;
}
// Determine firmware version (see section 9.3.4.8 in spec) // Verify that the results match up to our expectations
byte version = PCD_ReadRegister(VersionReg); for (i = 0; i < 64; i++) {
if (result[i] != pgm_read_byte(&(reference[i]))) {
return false;
}
}
// Pick the appropriate reference values // Test passed; all is good.
const byte *reference; return true;
switch (version) {
case 0x91: // Version 1.0
reference = MFRC522_firmware_referenceV1_0;
break;
case 0x92: // Version 2.0
reference = MFRC522_firmware_referenceV2_0;
break;
default: // Unknown version
return false;
}
// Verify that the results match up to our expectations
for (i = 0; i < 64; i++) {
if (result[i] != pgm_read_byte(&(reference[i]))) {
return false;
}
}
// Test passed; all is good.
return true;
} // End PCD_PerformSelfTest() } // End PCD_PerformSelfTest()
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
@@ -1044,17 +1042,17 @@ byte MFRC522::MIFARE_Transfer( byte blockAddr ///< The block (0-0xff) number.
* @return STATUS_OK on success, STATUS_??? otherwise. * @return STATUS_OK on success, STATUS_??? otherwise.
*/ */
byte MFRC522::MIFARE_GetValue(byte blockAddr, long *value) { byte MFRC522::MIFARE_GetValue(byte blockAddr, long *value) {
byte status; byte status;
byte buffer[18]; byte buffer[18];
byte size = sizeof(buffer); byte size = sizeof(buffer);
// Read the block // Read the block
status = MIFARE_Read(blockAddr, buffer, &size); status = MIFARE_Read(blockAddr, buffer, &size);
if (status == STATUS_OK) { if (status == STATUS_OK) {
// Extract the value // Extract the value
*value = (long(buffer[3])<<24) | (long(buffer[2])<<16) | (long(buffer[1])<<8) | long(buffer[0]); *value = (long(buffer[3])<<24) | (long(buffer[2])<<16) | (long(buffer[1])<<8) | long(buffer[0]);
} }
return status; return status;
} // End MIFARE_GetValue() } // End MIFARE_GetValue()
/** /**
@@ -1069,24 +1067,24 @@ byte MFRC522::MIFARE_GetValue(byte blockAddr, long *value) {
* @return STATUS_OK on success, STATUS_??? otherwise. * @return STATUS_OK on success, STATUS_??? otherwise.
*/ */
byte MFRC522::MIFARE_SetValue(byte blockAddr, long value) { byte MFRC522::MIFARE_SetValue(byte blockAddr, long value) {
byte buffer[18]; byte buffer[18];
// Translate the long into 4 bytes; repeated 2x in value block // Translate the long into 4 bytes; repeated 2x in value block
buffer[0] = buffer[ 8] = (value & 0xFF); buffer[0] = buffer[ 8] = (value & 0xFF);
buffer[1] = buffer[ 9] = (value & 0xFF00) >> 8; buffer[1] = buffer[ 9] = (value & 0xFF00) >> 8;
buffer[2] = buffer[10] = (value & 0xFF0000) >> 16; buffer[2] = buffer[10] = (value & 0xFF0000) >> 16;
buffer[3] = buffer[11] = (value & 0xFF000000) >> 24; buffer[3] = buffer[11] = (value & 0xFF000000) >> 24;
// Inverse 4 bytes also found in value block // Inverse 4 bytes also found in value block
buffer[4] = ~buffer[0]; buffer[4] = ~buffer[0];
buffer[5] = ~buffer[1]; buffer[5] = ~buffer[1];
buffer[6] = ~buffer[2]; buffer[6] = ~buffer[2];
buffer[7] = ~buffer[3]; buffer[7] = ~buffer[3];
// Address 2x with inverse address 2x // Address 2x with inverse address 2x
buffer[12] = buffer[14] = blockAddr; buffer[12] = buffer[14] = blockAddr;
buffer[13] = buffer[15] = ~blockAddr; buffer[13] = buffer[15] = ~blockAddr;
// Write the whole data block // Write the whole data block
return MIFARE_Write(blockAddr, buffer, 16); return MIFARE_Write(blockAddr, buffer, 16);
} // End MIFARE_SetValue() } // End MIFARE_SetValue()
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
@@ -1512,65 +1510,65 @@ void MFRC522::MIFARE_SetAccessBits( byte *accessBitBuffer, ///< Pointer to byte
* Of course with non-bricked devices, you're free to select them before calling this function. * Of course with non-bricked devices, you're free to select them before calling this function.
*/ */
bool MFRC522::MIFARE_OpenUidBackdoor(bool logErrors) { bool MFRC522::MIFARE_OpenUidBackdoor(bool logErrors) {
// Magic sequence: // Magic sequence:
// > 50 00 57 CD (HALT + CRC) // > 50 00 57 CD (HALT + CRC)
// > 40 (7 bits only) // > 40 (7 bits only)
// < A (4 bits only) // < A (4 bits only)
// > 43 // > 43
// < A (4 bits only) // < A (4 bits only)
// Then you can write to sector 0 without authenticating // Then you can write to sector 0 without authenticating
PICC_HaltA(); // 50 00 57 CD PICC_HaltA(); // 50 00 57 CD
byte cmd = 0x40; byte cmd = 0x40;
byte validBits = 7; /* Our command is only 7 bits. After receiving card response, byte validBits = 7; /* Our command is only 7 bits. After receiving card response,
this will contain amount of valid response bits. */ this will contain amount of valid response bits. */
byte response[32]; // Card's response is written here byte response[32]; // Card's response is written here
byte received; byte received;
byte status = PCD_TransceiveData(&cmd, (byte)1, response, &received, &validBits, (byte)0, false); // 40 byte status = PCD_TransceiveData(&cmd, (byte)1, response, &received, &validBits, (byte)0, false); // 40
if( status != STATUS_OK ) { if( status != STATUS_OK ) {
if( logErrors ) { if( logErrors ) {
Serial.println(F("Card did not respond to 0x40 after HALT command. Are you sure it is a UID changeable one?")); Serial.println(F("Card did not respond to 0x40 after HALT command. Are you sure it is a UID changeable one?"));
Serial.print(F("Error name: ")); Serial.print(F("Error name: "));
Serial.println(GetStatusCodeName(status)); Serial.println(GetStatusCodeName(status));
} }
return false; return false;
} }
if ( received != 1 || response[0] != 0x0A ) { if ( received != 1 || response[0] != 0x0A ) {
if ( logErrors ) { if ( logErrors ) {
Serial.print(F("Got bad response on backdoor 0x40 command: ")); Serial.print(F("Got bad response on backdoor 0x40 command: "));
Serial.print(response[0], HEX); Serial.print(response[0], HEX);
Serial.print(F(" (")); Serial.print(F(" ("));
Serial.print(validBits); Serial.print(validBits);
Serial.print(F(" valid bits)\r\n")); Serial.print(F(" valid bits)\r\n"));
} }
return false; return false;
} }
cmd = 0x43; cmd = 0x43;
validBits = 8; validBits = 8;
status = PCD_TransceiveData(&cmd, (byte)1, response, &received, &validBits, (byte)0, false); // 43 status = PCD_TransceiveData(&cmd, (byte)1, response, &received, &validBits, (byte)0, false); // 43
if( status != STATUS_OK ) { if( status != STATUS_OK ) {
if( logErrors ) { if( logErrors ) {
Serial.println(F("Error in communication at command 0x43, after successfully executing 0x40")); Serial.println(F("Error in communication at command 0x43, after successfully executing 0x40"));
Serial.print(F("Error name: ")); Serial.print(F("Error name: "));
Serial.println(GetStatusCodeName(status)); Serial.println(GetStatusCodeName(status));
} }
return false; return false;
} }
if ( received != 1 || response[0] != 0x0A ) { if ( received != 1 || response[0] != 0x0A ) {
if ( logErrors ) { if ( logErrors ) {
Serial.print(F("Got bad response on backdoor 0x43 command: ")); Serial.print(F("Got bad response on backdoor 0x43 command: "));
Serial.print(response[0], HEX); Serial.print(response[0], HEX);
Serial.print(F(" (")); Serial.print(F(" ("));
Serial.print(validBits); Serial.print(validBits);
Serial.print(F(" valid bits)\r\n")); Serial.print(F(" valid bits)\r\n"));
} }
return false; return false;
} }
// You can now write to sector 0 without authenticating! // You can now write to sector 0 without authenticating!
return true; return true;
} // End MIFARE_OpenUidBackdoor() } // End MIFARE_OpenUidBackdoor()
/** /**
@@ -1583,120 +1581,120 @@ bool MFRC522::MIFARE_OpenUidBackdoor(bool logErrors) {
*/ */
bool MFRC522::MIFARE_SetUid(byte* newUid, byte uidSize, bool logErrors) { bool MFRC522::MIFARE_SetUid(byte* newUid, byte uidSize, bool logErrors) {
// UID + BCC byte can not be larger than 16 together // UID + BCC byte can not be larger than 16 together
if ( !newUid || !uidSize || uidSize > 15) { if ( !newUid || !uidSize || uidSize > 15) {
if ( logErrors ) { if ( logErrors ) {
Serial.println(F("New UID buffer empty, size 0, or size > 15 given")); Serial.println(F("New UID buffer empty, size 0, or size > 15 given"));
} }
return false; return false;
} }
// Authenticate for reading // Authenticate for reading
MIFARE_Key key = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; MIFARE_Key key = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
byte status = PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, (byte)1, &key, &uid); byte status = PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, (byte)1, &key, &uid);
if ( status != STATUS_OK ) { if ( status != STATUS_OK ) {
if ( status == STATUS_TIMEOUT ) { if ( status == STATUS_TIMEOUT ) {
// We get a read timeout if no card is selected yet, so let's select one // We get a read timeout if no card is selected yet, so let's select one
// Wake the card up again if sleeping // Wake the card up again if sleeping
// byte atqa_answer[2]; // byte atqa_answer[2];
// byte atqa_size = 2; // byte atqa_size = 2;
// PICC_WakeupA(atqa_answer, &atqa_size); // PICC_WakeupA(atqa_answer, &atqa_size);
if ( !PICC_IsNewCardPresent() || !PICC_ReadCardSerial() ) { if ( !PICC_IsNewCardPresent() || !PICC_ReadCardSerial() ) {
Serial.println(F("No card was previously selected, and none are available. Failed to set UID.")); Serial.println(F("No card was previously selected, and none are available. Failed to set UID."));
return false; return false;
} }
status = PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, (byte)1, &key, &uid); status = PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, (byte)1, &key, &uid);
if ( status != STATUS_OK ) { if ( status != STATUS_OK ) {
// We tried, time to give up // We tried, time to give up
if ( logErrors ) { if ( logErrors ) {
Serial.println(F("Failed to authenticate to card for reading, could not set UID: ")); Serial.println(F("Failed to authenticate to card for reading, could not set UID: "));
Serial.println(GetStatusCodeName(status)); Serial.println(GetStatusCodeName(status));
} }
return false; return false;
} }
} }
else { else {
if ( logErrors ) { if ( logErrors ) {
Serial.print(F("PCD_Authenticate() failed: ")); Serial.print(F("PCD_Authenticate() failed: "));
Serial.println(GetStatusCodeName(status)); Serial.println(GetStatusCodeName(status));
} }
return false; return false;
} }
} }
// Read block 0 // Read block 0
byte block0_buffer[18]; byte block0_buffer[18];
byte byteCount = sizeof(block0_buffer); byte byteCount = sizeof(block0_buffer);
status = MIFARE_Read((byte)0, block0_buffer, &byteCount); status = MIFARE_Read((byte)0, block0_buffer, &byteCount);
if ( status != STATUS_OK ) { if ( status != STATUS_OK ) {
if ( logErrors ) { if ( logErrors ) {
Serial.print(F("MIFARE_Read() failed: ")); Serial.print(F("MIFARE_Read() failed: "));
Serial.println(GetStatusCodeName(status)); Serial.println(GetStatusCodeName(status));
Serial.println(F("Are you sure your KEY A for sector 0 is 0xFFFFFFFFFFFF?")); Serial.println(F("Are you sure your KEY A for sector 0 is 0xFFFFFFFFFFFF?"));
} }
return false; return false;
} }
// Write new UID to the data we just read, and calculate BCC byte // Write new UID to the data we just read, and calculate BCC byte
byte bcc = 0; byte bcc = 0;
for ( int i = 0; i < uidSize; i++ ) { for ( int i = 0; i < uidSize; i++ ) {
block0_buffer[i] = newUid[i]; block0_buffer[i] = newUid[i];
bcc ^= newUid[i]; bcc ^= newUid[i];
} }
// Write BCC byte to buffer // Write BCC byte to buffer
block0_buffer[uidSize] = bcc; block0_buffer[uidSize] = bcc;
// Stop encrypted traffic so we can send raw bytes // Stop encrypted traffic so we can send raw bytes
PCD_StopCrypto1(); PCD_StopCrypto1();
// Activate UID backdoor // Activate UID backdoor
if ( !MIFARE_OpenUidBackdoor(logErrors) ) { if ( !MIFARE_OpenUidBackdoor(logErrors) ) {
if ( logErrors ) { if ( logErrors ) {
Serial.println(F("Activating the UID backdoor failed.")); Serial.println(F("Activating the UID backdoor failed."));
} }
return false; return false;
} }
// Write modified block 0 back to card // Write modified block 0 back to card
status = MIFARE_Write((byte)0, block0_buffer, (byte)16); status = MIFARE_Write((byte)0, block0_buffer, (byte)16);
if (status != STATUS_OK) { if (status != STATUS_OK) {
if ( logErrors ) { if ( logErrors ) {
Serial.print(F("MIFARE_Write() failed: ")); Serial.print(F("MIFARE_Write() failed: "));
Serial.println(GetStatusCodeName(status)); Serial.println(GetStatusCodeName(status));
} }
return false; return false;
} }
// Wake the card up again // Wake the card up again
byte atqa_answer[2]; byte atqa_answer[2];
byte atqa_size = 2; byte atqa_size = 2;
PICC_WakeupA(atqa_answer, &atqa_size); PICC_WakeupA(atqa_answer, &atqa_size);
return true; return true;
} }
/** /**
* Resets entire sector 0 to zeroes, so the card can be read again by readers. * Resets entire sector 0 to zeroes, so the card can be read again by readers.
*/ */
bool MFRC522::MIFARE_UnbrickUidSector(bool logErrors) { bool MFRC522::MIFARE_UnbrickUidSector(bool logErrors) {
MIFARE_OpenUidBackdoor( logErrors ); MIFARE_OpenUidBackdoor( logErrors );
byte block0_buffer[] = {0x01, 0x02, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; byte block0_buffer[] = {0x01, 0x02, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
// Write modified block 0 back to card // Write modified block 0 back to card
byte status = MIFARE_Write((byte)0, block0_buffer, (byte)16); byte status = MIFARE_Write((byte)0, block0_buffer, (byte)16);
if (status != STATUS_OK) { if (status != STATUS_OK) {
if ( logErrors ) { if ( logErrors ) {
Serial.print(F("MIFARE_Write() failed: ")); Serial.print(F("MIFARE_Write() failed: "));
Serial.println(GetStatusCodeName(status)); Serial.println(GetStatusCodeName(status));
} }
return false; return false;
} }
} }
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////

19
MFRC522.h
View File

@@ -315,14 +315,13 @@ public:
void PCD_AntennaOff(); void PCD_AntennaOff();
byte PCD_GetAntennaGain(); byte PCD_GetAntennaGain();
void PCD_SetAntennaGain(byte mask); void PCD_SetAntennaGain(byte mask);
bool PCD_PerformSelfTest(); bool PCD_PerformSelfTest();
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
// Functions for communicating with PICCs // Functions for communicating with PICCs
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
byte PCD_TransceiveData(byte *sendData, byte sendLen, byte *backData, byte *backLen, byte *validBits = NULL, byte rxAlign = 0, bool checkCRC = false); byte PCD_TransceiveData(byte *sendData, byte sendLen, byte *backData, byte *backLen, byte *validBits = NULL, byte rxAlign = 0, bool checkCRC = false);
byte PCD_CommunicateWithPICC(byte command, byte waitIRq, byte *sendData, byte sendLen, byte *backData = NULL, byte *backLen = NULL, byte *validBits = NULL, byte rxAlign = 0, bool checkCRC = false); byte PCD_CommunicateWithPICC(byte command, byte waitIRq, byte *sendData, byte sendLen, byte *backData = NULL, byte *backLen = NULL, byte *validBits = NULL, byte rxAlign = 0, bool checkCRC = false);
byte PICC_RequestA(byte *bufferATQA, byte *bufferSize); byte PICC_RequestA(byte *bufferATQA, byte *bufferSize);
byte PICC_WakeupA(byte *bufferATQA, byte *bufferSize); byte PICC_WakeupA(byte *bufferATQA, byte *bufferSize);
byte PICC_REQA_or_WUPA(byte command, byte *bufferATQA, byte *bufferSize); byte PICC_REQA_or_WUPA(byte command, byte *bufferATQA, byte *bufferSize);
@@ -336,13 +335,13 @@ public:
void PCD_StopCrypto1(); void PCD_StopCrypto1();
byte MIFARE_Read(byte blockAddr, byte *buffer, byte *bufferSize); byte MIFARE_Read(byte blockAddr, byte *buffer, byte *bufferSize);
byte MIFARE_Write(byte blockAddr, byte *buffer, byte bufferSize); byte MIFARE_Write(byte blockAddr, byte *buffer, byte bufferSize);
byte MIFARE_Decrement(byte blockAddr, long delta); byte MIFARE_Decrement(byte blockAddr, long delta);
byte MIFARE_Increment(byte blockAddr, long delta); byte MIFARE_Increment(byte blockAddr, long delta);
byte MIFARE_Restore(byte blockAddr); byte MIFARE_Restore(byte blockAddr);
byte MIFARE_Transfer(byte blockAddr); byte MIFARE_Transfer(byte blockAddr);
byte MIFARE_Ultralight_Write(byte page, byte *buffer, byte bufferSize); byte MIFARE_Ultralight_Write(byte page, byte *buffer, byte bufferSize);
byte MIFARE_GetValue(byte blockAddr, long *value); byte MIFARE_GetValue(byte blockAddr, long *value);
byte MIFARE_SetValue(byte blockAddr, long value); byte MIFARE_SetValue(byte blockAddr, long value);
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
// Support functions // Support functions
@@ -360,9 +359,9 @@ public:
void PICC_DumpMifareClassicSectorToSerial(Uid *uid, MIFARE_Key *key, byte sector); void PICC_DumpMifareClassicSectorToSerial(Uid *uid, MIFARE_Key *key, byte sector);
void PICC_DumpMifareUltralightToSerial(); void PICC_DumpMifareUltralightToSerial();
void MIFARE_SetAccessBits(byte *accessBitBuffer, byte g0, byte g1, byte g2, byte g3); void MIFARE_SetAccessBits(byte *accessBitBuffer, byte g0, byte g1, byte g2, byte g3);
bool MIFARE_OpenUidBackdoor(bool logErrors); bool MIFARE_OpenUidBackdoor(bool logErrors);
bool MIFARE_SetUid(byte* newUid, byte uidSize, bool logErrors); bool MIFARE_SetUid(byte* newUid, byte uidSize, bool logErrors);
bool MIFARE_UnbrickUidSector(bool logErrors); bool MIFARE_UnbrickUidSector(bool logErrors);
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
// Convenience functions - does not add extra functionality // Convenience functions - does not add extra functionality