Manchmal kommt es leider vor, dass ein Tag nicht 100%ig richtig eingelesen werden konnte --- dann kommt es zu merkwüridgen Ergebnissen. Daher ist meine Frage, ob/wie man einen Check einbauen könnte, der prüft, ob die UID des Tags richtig erfasst werden konnte.
Meine Idee dazu ist: im loop eine Bedingung, die überprüft, ob die UID des Tags tatsächlich in dieser Form: 04 7B CD B2 75 71 81 gelesen werden konnte oder nicht ... wie seht ihr das? Ist das sinnvoll? Wie könnte man das realisieren? Vielleicht irgendwie in Form von "14 mal beliebige Zahl erfolgreich gelesen"?
Ach ja -- wenn die Tags zu schnell gescannt werden, erhalte ich ab und auf der seriellen Konsole auch die Warnung "WARNING: Too many records. Increase MAX_NDEF_RECORDS." oder manchmal auch "Error. Failed read page 4" - kann mir da auch einer einen guten Tipp geben, wie ich das erhöhen kann?
In Zeile 60 wird die gescannte UID mit einer anderen verglichen ... so ähnlich stelle ich mir das auch vor ... nur dass nicht überprüft werden soll, ob der String genau mit einem anderen übereinstimmt sondern so, dass überprüft wird, ob der String "als vollständige UID übergekommen ist" ...
Ok, jetzt bin ich wieder vor Ort und kann genauer nachsehen ... hier kommt mein Sketch, mit dem ich das versuche umzusetzen. Vielleicht hat ja jemand eine gute Idee?
#include <SPI.h>
#include "PN532_SPI.h"
#include "PN532.h"
#include "NfcAdapter.h"
PN532_SPI interface(SPI, 10); // create a SPI interface for the shield with the SPI CS terminal at digital pin 10
NfcAdapter nfc = NfcAdapter(interface); // create an NFC adapter object
// Vergleich von Vorgänger und Nachfolger RFID-Tag, damit keiner doppelt gezählt wird!
// globale Variable zunächst leer definiert!
String uidVorgaenger = "";
void setup(void) {
Serial.begin(115200);
nfc.begin();
}
void loop(void) {
//Ausgabe auf serieller Konsole ...
Serial.println(" RFID-Tag scannen:");
if (nfc.tagPresent())
{
NfcTag tag = nfc.read();
// Serial.println(tag.getTagType());
// Serial.print("UID: ");Serial.println(tag.getUidString());
if (tag.hasNdefMessage()) // every tag won't have a message
{
NdefMessage message = tag.getNdefMessage();
// cycle through the records, printing some info from each
int recordCount = message.getRecordCount();
for (int i = 0; i < recordCount; i++)
{
// Serial.print("\nNDEF Record ");Serial.println(i+1);
NdefRecord record = message.getRecord(i);
// NdefRecord record = message[i]; // alternate syntax
// The TNF and Type should be used to determine how your application processes the payload
// There's no generic processing for the payload, it's returned as a byte[]
int payloadLength = record.getPayloadLength();
byte payload[payloadLength];
record.getPayload(payload);
// Print the Hex and Printable Characters
// Serial.print(" Payload (HEX): ");
// PrintHexChar(payload, payloadLength);
// Force the data into a String (might work depending on the content)
// Real code should use smarter processing
String payloadAsString = "";
for (int c = 1; c < payloadLength; c++) {
payloadAsString += (char)payload[c];
}
// UID als String definieren:
String uidNachfolger = tag.getUidString();
// Hier folgt der Abschnitt, der den o.g. Test durchführen soll:
// Es sollte ein Check durchgeführt werden, ob die UID des RFID-Tags richtig gescannt werden konnte, bevor mit unsinnigen Daten
// weitergemacht wird. Wie kann man das am besten umsetzen?
// Kann man evtl prüfen, ob die UID aus 14 hexadezimalen Zahlen besteht?
// Oben gibt es bereits den Befehl "PrintHexChar(" ... ist der vielleicht kombinierbar mit
// https://www.arduino.cc/reference/en/language/functions/characters/ishexadecimaldigit/ ??
//if(uidNachfolger.compareTo("04 7B CD B2 75 71 81") == 0)
// compare the NFC tag's UID with the correct tag's UID (a match exists when compareTo returns 0)
// { // the scanned NFC tag matches the saved myUID value
// Serial.println("UID richtig erkannt");
// put your here to trigger the unlocking mechanism (e.g. motor, transducer)
//}
Serial.print(" UID: ");
Serial.println(uidNachfolger);
// Prüfen, ob aktuelle UID dem Vorgänger entspricht.
if (uidVorgaenger != uidNachfolger)
{Serial.println("Tags sind verschieden!");
uidVorgaenger = uidNachfolger;
}
else {
Serial.println("Tags sind identisch!");
break; }
}
}
}
delay(500);
}
kannst du das bitte näher ausführen, damit wir wissen was du überhaupt suchst
Manchmal kommt es leider vor, dass ein Tag nicht 100%ig richtig eingelesen werden konnte --- dann kommt es zu merkwüridgen Ergebnissen. Daher ist meine Frage, ob/wie man einen Check einbauen könnte, der prüft, ob die UID des Tags richtig erfasst werden konnte.
Wie stellst du das fest dass der UID nicht richtig ist?
Wie sehen solche UID aus?
Wie können wir das auf unserer Hardware nachvollziehen?
Was sind die Schritte um in diese Situation zu kommen?
Eine UID hat immer diese Form: 14 hexadezimale Ziffern wie z.B. 04 7B CD B2 75 71 81
Ich bin nicht ganz sicher, warum / wann der Scan-Vorgang nicht richtig gelaufen ist, aber ich vermute, dass das dann geschieht, wenn man das Tag zu schnell wieder von der Antenne weg zieht oder es nur zu kurz oder nicht richtig davor hält. Jedenfalls funktioniert dann die simple Prüfung in meinem Sketch "vorgänger = nachfolger" nicht. Was genau dann als nachfolger im Speicher steht, kann ich nicht genau sagen -- ich vermute aber, dass die UID dann einfach leer geblieben ist??
Ach ja: Ich habe als Tags Aufkleber verwendet, auf denen "Mifare" steht -- scheint ein Standard zu sein? Dieses Format kann ich auch auf dem Smartphone mit der App "NFC Tools" problemlos lesen. Aber zumindest mit meinem Smartphone ist es so, dass der Abstand viel kleiner sein muss als das mit dem Shield der Fall ist. Zum Testen, was auf dem Tag steht, geht es aber auch per App ...
whiterabbit07:
Das meiste davon steht bereits oben:
Ja, aber eben nicht alles.
Das ist in allen vorherigen Threads bisher von Dir Gebetsmühlenartig betont worden, das Du nur das Gerüst aus dem Example verwendest.
Das ist aber nicht so - denn mittlwereile dürfte da schon das Eine oder Andere drumrum sein.
Bisher ist nicht ein Code von Dir gekommen; und irgendwie raten alle nur, was Du hast und machst.
Findest Du das cool?
Nein.
Von meinen Fragen ist KEINE in deinem Eröffnungspost oder in einem deiner Folgeposts beantwortet.
Daher stelle ich diese Fragen.
Eine UID hat immer diese Form: 14 hexadezimale Ziffern wie z.B. 04 7B CD B2 75 71 81
Gehe davon aus, ich weis wie eine UID aussieht.
Daher ist mir auch geläufig dass eine 7 Byte UID ein gültiger Wert für eine double size UID sein kann.
04 7B CD B2 75 71 81 - deutet auf 7 Bytes.
Ich wollte wissen wie deine "Tag nicht 100%ig richtig eingelesen" aussehen.
noiasca:
Ich wollte wissen wie deine "Tag nicht 100%ig richtig eingelesen" aussehen.
Das weiß ich leider nicht -- ich vermute es nur und kann es leider nicht genauer sagen. Ich würde es ja gerne genauer sagen -- weiß aber nicht wie ich das nachsehen kann?!
Es wäre doch auch denkbar, dass In meinem Beispiel der Nachfolger im Fehlerfall einfach die UID=" " (also leer, weil nicht richtig gescannt werden konnte) erhält, und deshalb "Tags sind verschieden!" ausgegeben wird? (Sorry, wenn sich hier einige vor den Kopf gestoßen fühlen ... das war sicher nicht meine Absicht.)