RFID read MINI vs. UL

Guten Abend zusammen. Ich stöber gerade durch den Code zum Lesen der RFID Tags. Kann mir einer folgendes Erklären:

Bei einem MIFARE MINI sieht der Readbefehl wie folgt aus. Der komplette Buffer wird über einen Read gefüllt. buffer hat 18 byte. Super einfach. Fertig.

rfid::status = (MFRC522::StatusCode)mfrc522.MIFARE_Read(rfid::blockAddr, buffer, &size);

Beim MIFARE UL hingegen iteriert der Code über diverse blockAddressen beginnend bei 8 bis 11, liest dabei immer einen kompletten buffer2 (18 Byte), übernimmt dann aber immer nur die ersten 4 Byte in den Buffer.

else if (piccType == MFRC522::PICC_TYPE_MIFARE_UL )
{
byte buffer2[18];
byte size2 = sizeof(buffer2);

rfid::status = (MFRC522::StatusCode)mfrc522.MIFARE_Read(8, buffer2, &size2);
if (rfid::status != MFRC522::STATUS_OK) {
  Serial.print(F("MIFARE_Read_1() failed: "));
  Serial.println(mfrc522.GetStatusCodeName(rfid::status));
  return false;
}
memcpy(buffer, buffer2, 4);

rfid::status = (MFRC522::StatusCode)mfrc522.MIFARE_Read(9, buffer2, &size2);
if (rfid::status != MFRC522::STATUS_OK) {
  Serial.print(F("MIFARE_Read_2() failed: "));
  Serial.println(mfrc522.GetStatusCodeName(rfid::status));
  return false;
}
memcpy(buffer + 4, buffer2, 4);

usw. bis 11.

Das wirkt auf den ersten Blick super umständlich. Ich bin mir sicher, es hat einen Grund. Würde es gerne verstehen.

MfG, Nick

Das liegt einfach daran wie die Daten auf der Karte liegen. Im ersten Fall kannst du halt die kompletten 16 Byte in einem Rutsch lesen (Sektor 1 Block 4). Bei UL und NTAG sind die Daten halt über 4 Pages a 4 Byte verteilt weil die interne Organisation bei diesen Karten eine andere ist. Bei NXP findest du Datasheets falls dich das näher interessieren sollte.

Hi Stephan,

danke für die schnelle Antwort. Ich hatte eigentlich eine Blitzantwort von @Gute_Laune vermutet ;oP. Der Mann postet schneller als sein Schatten. Vielleicht ist er im Urlaub?

Aber zum Thema: Sowas hatte ich fast vermutet. Was mich halt irritiert ist, dass bei der UL trotzdem jeder Read über size2, also 18 byte geht.
Wenn ich 4 Pages a 4 Byte lese, hätte ich erwartet, das buffer2 auch nur 4 Byte hat und der Read über 4 Byte geht, und nicht über 18. Der Code liest aber je 18 Byte über 4 Pages, und wirft von den 18 Byte halt alles jenseits der 4 Byte weg.
Liest der read dann trotzdem nur 4 Byte, obwohl man ihm ein array mit 18 Byte anbietet und ihm eine size von 18 übergibt? Oder liest der ins Nirvana und im Rest steht halt irgendein Schrott?

Und auch beim Write werden 16 Byte pro Write in die Page übergeben.
Man beachte: 16 Byte Write Buffer, aber 18 Byte Read Buffer. Auch das ist mir nicht schlüssig.

Warum nimmst du an @Gute_Laune wäre ein Mann?

Die Buffergrößen sind (wahrscheinlich) aus den Examples der library entnommen. Beim read kommt da noch eine Checksumme mit, ich erinnere das nicht mehr so genau. In meinem Fork ist das aber auch so weil ich für beides den gleichen buffer nutze. Bei Classic MUSS dieser 18 byte sein. Bei UL und NTAG mindestens 4 byte (darf aber größer sein). Das kannst du alles in der Library finden:

Stimmt, du hast recht. Warum eigentlich? Hab ehrlich gesagt gar nicht drüber nachgedacht. Aber Jana scheint eindeutig. War eher so in Analogie zu Luck Luke formuliert. Jana, bitte entschuldige den Fauxpas.

Ansonsten denke ich ist meine Frage dann auch beantwortet.

Danke

2 Like

Kein Problem.

Das hatte ich schon verstanden. :wink: