NFC Modul RC522 mit Midas Tags / Blockzeilen beschreiben und unterscheiden

Hallo habe mich ein paar Tage mit Arduino beschäftigt und versucht einen Arduino UNO mit RC522 (NFC) auszurüsten.

nach einigem Hin und her habe ich es hinbekommen das je nach dem welche ID vorliegt das jeweilige Relay geschalten wird oder einen Schaltung abgewiesen wird

Ähnlich wie die Zugangskontrolle vom GitHub nur mit 2 Relay.

nun möchte ich aber nicht mehr per UID der NFC Tags unterscheiden sonder mit einem Code den ich mit einem 2ten Arduino vorher auf den NFC Tag schreibe

also z.b Code1 = Relay 1 Code 2 = Relay 2

so das er dann im ersten Arduino beschriftet wird Taste 1 = Code 1 Taste 2 = Code 2

und im 2ten Arduino erkannt wird Code 1 = Relay 1 Code 2 = Relay 2

der momentante Sketch sieht bislang nur eine Schaltung je nach UID für das jeweilige Relay vor

Sketch:

//////////////////////////////////////////////////
//
// RFID/NFC  Erkennung / Sharkfire
//
//////////////////////////////////////////////////

#include <SPI.h>     // Import SPI-Bibiothek 
#include <MFRC522.h> // Import RFID-Bibiothek


///////// Variablen MFRC522 //////////////////////
const int SDAPIN   = 10; // Uno => Pin 10 
const int RSTPIN   =  9; // Uno => Pin 9
MFRC522 rfidReader(SDAPIN, RSTPIN); // RFID-Empfänger


///////// Aktoren: 2er Relai Karte ///////////////////
const int K1   = 5;  // Uno -> Pin 8
const int K2   = 6;  // Uno -> Pin 7

//////// ID des richtigen RFID-Tags //////////////
byte sesam[] = {0x22, 0x7E, 0x83, 0xCB};
byte sesam1[] = {0x22, 0x90, 0xE5, 0x10};
byte sesam2[] = {0x04, 0x84, 0x2F, 0xF2};
byte sesam3[] = {0x04, 0xC5, 0x2F, 0xF2};
byte sesam4[] = {0x04, 0xE8, 0x2F, 0xF2};
byte sesam5[] = {0x04, 0x29, 0x2F, 0xF2};
byte sesam6[] = {0x04, 0x4B, 0x2F, 0xF2};
byte sesam7[] = {0x04, 0xC5, 0x2F, 0xF2};


//////////////////////////////////////////////////
//
// setup()
//   Initialisieren von SPI,
//   seriellem Monitor,
//   20x4 LCD
//   RFID-Leser
//
//////////////////////////////////////////////////
void setup() 
{


 pinMode(K1, OUTPUT);
 pinMode(K2, OUTPUT);

 Serial.begin(9600); // Serielle Verbindung 

 SPI.begin(); // SPI-Verbindung aufbauen

 rfidReader.PCD_Init(); // Initial. RFID-Leser
 Serial.println("Material-Kontrolle aktiv");
 
 digitalWrite(K1, HIGH);
 digitalWrite(K2, HIGH);
}



//////////////////////////////////////////////////
//
// acceptedRFID()
//   Stimmt gelesene RFID
//   mit der voreingestellten ID überein?
//
//////////////////////////////////////////////////
bool acceptedRFID(byte uid[4]) {
 return
     (rfidReader.uid.uidByte[0] == sesam[0]) &&
     (rfidReader.uid.uidByte[1] == sesam[1]) &&
     (rfidReader.uid.uidByte[2] == sesam[2]) &&
     (rfidReader.uid.uidByte[3] == sesam[3]) or
     (rfidReader.uid.uidByte[0] == sesam1[0]) &&
     (rfidReader.uid.uidByte[1] == sesam1[1]) &&
     (rfidReader.uid.uidByte[2] == sesam1[2]) &&
     (rfidReader.uid.uidByte[3] == sesam1[3]) or
     (rfidReader.uid.uidByte[0] == sesam2[0]) &&
     (rfidReader.uid.uidByte[1] == sesam2[1]) &&
     (rfidReader.uid.uidByte[2] == sesam2[2]) &&
     (rfidReader.uid.uidByte[3] == sesam2[3]) or
     (rfidReader.uid.uidByte[0] == sesam4[0]) &&
     (rfidReader.uid.uidByte[1] == sesam4[1]) &&
     (rfidReader.uid.uidByte[2] == sesam4[2]) &&
     (rfidReader.uid.uidByte[3] == sesam4[3]) or
     (rfidReader.uid.uidByte[0] == sesam5[0]) &&
     (rfidReader.uid.uidByte[1] == sesam5[1]) &&
     (rfidReader.uid.uidByte[2] == sesam5[2]) &&
     (rfidReader.uid.uidByte[3] == sesam5[3]);
}
bool acceptedRFID2(byte uid[4]) {
 return
     (rfidReader.uid.uidByte[0] == sesam3[0]) &&
     (rfidReader.uid.uidByte[1] == sesam3[1]) &&
     (rfidReader.uid.uidByte[2] == sesam3[2]) &&
     (rfidReader.uid.uidByte[3] == sesam3[3]) or
     (rfidReader.uid.uidByte[0] == sesam6[0]) &&
     (rfidReader.uid.uidByte[1] == sesam6[1]) &&
     (rfidReader.uid.uidByte[2] == sesam6[2]) &&
     (rfidReader.uid.uidByte[3] == sesam6[3]) or
     (rfidReader.uid.uidByte[0] == sesam7[0]) &&
     (rfidReader.uid.uidByte[1] == sesam7[1]) &&
     (rfidReader.uid.uidByte[2] == sesam7[2]) &&
     (rfidReader.uid.uidByte[3] == sesam7[3]);
}

//////////////////////////////////////////////////
//
// 
//  Kunststoff erkannt
//  
//
//////////////////////////////////////////////////
void signalAccessGranted() {
 digitalWrite(K1, LOW);
 digitalWrite(K2, HIGH);

 delay(2000);
 digitalWrite(K1, HIGH);
 digitalWrite(K2, HIGH);
}

//////////////////////////////////////////////////
//
// 
//   Holz
// 
//
//////////////////////////////////////////////////
void signalAccessGranted2() {
 digitalWrite(K1, HIGH);
 digitalWrite(K2, LOW);

 delay(2000);
 digitalWrite(K1, HIGH);
 digitalWrite(K2, HIGH);
}



//////////////////////////////////////////////////
//
// loop()
//   Warten auf RFID-Erkennung
//   Reaktion abhaengig vom ID-Vergleich
//
//////////////////////////////////////////////////
void loop() 
{
 // 





 // Karte erkannt und gelesen
 if (rfidReader.PICC_IsNewCardPresent() && rfidReader.PICC_ReadCardSerial()) {
 

       

     Serial.print("RFID-TAG =>  "); 
     

     // Bytes der ID lesen und ausgeben
     Serial.print("/");
    
     for (byte i = 0; i < rfidReader.uid.size; i++) {
       Serial.print(rfidReader.uid.uidByte[i], HEX); 
      
       Serial.print("/");
      
 

     }

     Serial.println();
    
   
     // Check ob Karte mit Variable sesam übereinstimmt
     if (acceptedRFID(rfidReader.uid.uidByte)) { // ja =>
        // 
        signalAccessGranted();
   
        Serial.println("Weisses-Rohteil erkannt");
    
         delay(1000);
         
     }
    
         else
  
           
           if (acceptedRFID2(rfidReader.uid.uidByte)) { // ja =>
      
        signalAccessGranted2();
    
      
        Serial.println("Schwarzes-Rohteil erkannt");
       
         delay(1000);
        
    
      
      
     
       }
       else // nein =>
       {
         
      delay (1000);


         Serial.println("kein Rohteil erkannt");
         
         delay(1000);
          
       }
     }
 }

Vielleicht jemand eine Idee? Dachte das ich ggf. mit der Personal Daten Read/Write vom GitHub was anfangen oder zusammen schneiden könnte. 8) :slightly_smiling_face:

Dein Sketch ist fast nicht zu lesen. In einem Mobilgerät überhaupt nicht.
Setze den bitte in Code-Tags.

Verwende dazu die Schaltfläche </> oben links im Editorfenster.
Das kannst du auch nachträglich machen.
Dazu den Sketch markieren und die Schaltfläche klicken.

Damit wird dieser für alle besser lesbar.

Was mir auffällt .....

Das durchnummerieren von Variablen ist unangenehm.
Schwer zu warten. Schlecht zu lesen.

Tipp:
Es gibt auch mehrdimensionale Arrays.
Diese wurden extra dafür erfunden, um sowas abzuhandeln.

Und einen Zauberlehrling welcher dir das (hässliche) Vergleichen abnimmt: memcmp()

Sind die TAG programmierbar? kann der RFID Leser den TAG programmieren?
Grüße Uwe

man kann auf die Tags innerhalb von CodeZeilen(Blocks)
Informationen hinterlegen/schreiben und auslesen ja

Der aktuelle Sketch arbeitet wie gesagt nur mit Bekannten UID und weisst unbekannte ab das ist auch soweit gewollt.

Allerdings wäre es einefach sinniger für mein Projekt wenn ich mit einem Gerät eine Codezeile in einem Block hinter lege und mit einem Anderen Gerät diese auslesen und der Funktion zu weisen könnte

//////////////////////////////////////////////////
//
// RFID/NFC  Erkennung / Sharkfire
//
//////////////////////////////////////////////////

#include <SPI.h>     // Import SPI-Bibiothek
#include <MFRC522.h> // Import RFID-Bibiothek


///////// Variablen MFRC522 //////////////////////
const int SDAPIN   = 10; // Uno => Pin 10
const int RSTPIN   =  9; // Uno => Pin 9
MFRC522 rfidReader(SDAPIN, RSTPIN); // RFID-Empfänger


///////// Aktoren: 2er Relai Karte ///////////////////
const int K1   = 5;  // Uno -> Pin 8
const int K2   = 6;  // Uno -> Pin 7

//////// ID des richtigen RFID-Tags //////////////
byte sesam[] = {0x22, 0x7E, 0x83, 0xCB};
byte sesam1[] = {0x22, 0x90, 0xE5, 0x10};
byte sesam2[] = {0x04, 0x84, 0x2F, 0xF2};
byte sesam3[] = {0x04, 0xC5, 0x2F, 0xF2};
byte sesam4[] = {0x04, 0xE8, 0x2F, 0xF2};
byte sesam5[] = {0x04, 0x29, 0x2F, 0xF2};
byte sesam6[] = {0x04, 0x4B, 0x2F, 0xF2};
byte sesam7[] = {0x04, 0xC5, 0x2F, 0xF2};


//////////////////////////////////////////////////
//
// setup()
//   Initialisieren von SPI,
//   seriellem Monitor,
//   20x4 LCD
//   RFID-Leser
//
//////////////////////////////////////////////////
void setup()
{


pinMode(K1, OUTPUT);
pinMode(K2, OUTPUT);

Serial.begin(9600); // Serielle Verbindung

SPI.begin(); // SPI-Verbindung aufbauen

rfidReader.PCD_Init(); // Initial. RFID-Leser
Serial.println("Material-Kontrolle aktiv");

digitalWrite(K1, HIGH);
digitalWrite(K2, HIGH);
}



//////////////////////////////////////////////////
//
// acceptedRFID()
//   Stimmt gelesene RFID
//   mit der voreingestellten ID überein?
//
//////////////////////////////////////////////////
bool acceptedRFID(byte uid[4]) {
return
    (rfidReader.uid.uidByte[0] == sesam[0]) &&
    (rfidReader.uid.uidByte[1] == sesam[1]) &&
    (rfidReader.uid.uidByte[2] == sesam[2]) &&
    (rfidReader.uid.uidByte[3] == sesam[3]) or
    (rfidReader.uid.uidByte[0] == sesam1[0]) &&
    (rfidReader.uid.uidByte[1] == sesam1[1]) &&
    (rfidReader.uid.uidByte[2] == sesam1[2]) &&
    (rfidReader.uid.uidByte[3] == sesam1[3]) or
    (rfidReader.uid.uidByte[0] == sesam2[0]) &&
    (rfidReader.uid.uidByte[1] == sesam2[1]) &&
    (rfidReader.uid.uidByte[2] == sesam2[2]) &&
    (rfidReader.uid.uidByte[3] == sesam2[3]) or
    (rfidReader.uid.uidByte[0] == sesam4[0]) &&
    (rfidReader.uid.uidByte[1] == sesam4[1]) &&
    (rfidReader.uid.uidByte[2] == sesam4[2]) &&
    (rfidReader.uid.uidByte[3] == sesam4[3]) or
    (rfidReader.uid.uidByte[0] == sesam5[0]) &&
    (rfidReader.uid.uidByte[1] == sesam5[1]) &&
    (rfidReader.uid.uidByte[2] == sesam5[2]) &&
    (rfidReader.uid.uidByte[3] == sesam5[3]);
}
bool acceptedRFID2(byte uid[4]) {
return
    (rfidReader.uid.uidByte[0] == sesam3[0]) &&
    (rfidReader.uid.uidByte[1] == sesam3[1]) &&
    (rfidReader.uid.uidByte[2] == sesam3[2]) &&
    (rfidReader.uid.uidByte[3] == sesam3[3]) or
    (rfidReader.uid.uidByte[0] == sesam6[0]) &&
    (rfidReader.uid.uidByte[1] == sesam6[1]) &&
    (rfidReader.uid.uidByte[2] == sesam6[2]) &&
    (rfidReader.uid.uidByte[3] == sesam6[3]) or
    (rfidReader.uid.uidByte[0] == sesam7[0]) &&
    (rfidReader.uid.uidByte[1] == sesam7[1]) &&
    (rfidReader.uid.uidByte[2] == sesam7[2]) &&
    (rfidReader.uid.uidByte[3] == sesam7[3]);
}

//////////////////////////////////////////////////
//
//
//  Kunststoff erkannt
//  
//
//////////////////////////////////////////////////
void signalAccessGranted() {
digitalWrite(K1, LOW);
digitalWrite(K2, HIGH);

delay(2000);
digitalWrite(K1, HIGH);
digitalWrite(K2, HIGH);
}

//////////////////////////////////////////////////
//
//
//   Holz
//
//
//////////////////////////////////////////////////
void signalAccessGranted2() {
digitalWrite(K1, HIGH);
digitalWrite(K2, LOW);

delay(2000);
digitalWrite(K1, HIGH);
digitalWrite(K2, HIGH);
}



//////////////////////////////////////////////////
//
// loop()
//   Warten auf RFID-Erkennung
//   Reaktion abhaengig vom ID-Vergleich
//
//////////////////////////////////////////////////
void loop()
{
//





// Karte erkannt und gelesen
if (rfidReader.PICC_IsNewCardPresent() && rfidReader.PICC_ReadCardSerial()) {


      

    Serial.print("RFID-TAG =>  ");
    

    // Bytes der ID lesen und ausgeben
    Serial.print("/");
  
    for (byte i = 0; i < rfidReader.uid.size; i++) {
      Serial.print(rfidReader.uid.uidByte[i], HEX);
    
      Serial.print("/");
    


    }

    Serial.println();
  
  
    // Check ob Karte mit Variable sesam übereinstimmt
    if (acceptedRFID(rfidReader.uid.uidByte)) { // ja =>
       //
       signalAccessGranted();
  
       Serial.println("Weisses-Rohteil erkannt");
  
        delay(1000);
        
    }
  
        else

          
          if (acceptedRFID2(rfidReader.uid.uidByte)) { // ja =>
    
       signalAccessGranted2();
  
    
       Serial.println("Schwarzes-Rohteil erkannt");
      
        delay(1000);
      
  
    
      }
      else // nein =>
      {
        
     delay (1000);


        Serial.println("kein Rohteil erkannt");
        
        delay(1000);
        
      }
    }
}

Habe dazu ein paar einzel Bausteine gefunden nur werde noch nicht ganz schlau daraus

//EINGABE

uint8_t blockzahl =0xf;

//In welchem Block soll geschrieben werden?


uint8_t keys[]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};// Key-B zum Login

uint8_t access[]={0x7f,0x07,0x88,0x40};// Access-Bits


//Abgleich

uint8_t blockzahl =0xe;//Block des Sicherheitsschlüssels

uint8_t code[]={0xD0,0xE8,0x76,0xA6,0x46,0xDE,0x94,0xC5,0x35,0x83
,0x25,0x50,0xA6,0x6E,0x27,0xB4};

uint8_t keys[]={0xB0,0xD,0xAE,0xF4,0x97,0xE5};//KeyA

Damit schonmal jemand was gemacht?

Also eher nicht? :slight_smile:

So habe da mal Das Beschriftungsprogramm fertig allerdings noch das Problem das es nur auf MiFare 1KB NFC läuft

jemand eine Idee wie ich es kompatible zu MiFare Ultralight oder Ultralight C bekomme?
Also für die kleinen Midas NFC-Tags.

#include <SPI.h>     // Import SPI-Bibiothek 
#include <MFRC522.h> // Import RFID-Bibiothek
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>



LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

int TasterW = 6;
int TasterS = 7;
constexpr uint8_t RST_PIN = 9;     //
constexpr uint8_t SS_PIN = 53;     //

MFRC522 mfrc522(SS_PIN, RST_PIN);   //


void setup() {
  Serial.begin(9600);        // serial PC
  SPI.begin();               //  SPI bus
  mfrc522.PCD_Init();        // MFRC522
  lcd.begin(20, 4); // LCD 20x4

  pinMode(TasterW, INPUT);
  pinMode(TasterS, INPUT);

}

void loop() {

  lcd.setCursor(1, 1);
  lcd.print(F("  NFC-Codezeile "));
  Serial.print(F("  NFC-Codezeile "));
  delay(4000);

  // Prüfung des NFC Tags
  MFRC522::MIFARE_Key key;
  for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF;

  // Neue Karte?
  if ( ! mfrc522.PICC_IsNewCardPresent()) {
    return;
  }


  if ( ! mfrc522.PICC_ReadCardSerial()) {
    return;
  }

  Serial.println(F("**Card Detected:**"));


  lcd.clear();
  lcd.setCursor(1, 1);
  Serial.print("    NFC-TAG =>  ");
  lcd.print("    NFC-TAG =>  ");
  lcd.setCursor(0, 2);

  // Bytes der ID lesen und ausgeben
  Serial.print("/");
  lcd.print("/");
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i], HEX);
    lcd.print(mfrc522.uid.uidByte[i], HEX);
    Serial.print("/");
    lcd.print("/");
    Serial.println();
    delay(500);
  }
  delay(2000);


  Serial.print(F("NFC-Typ: "));   // Tag Typ
  MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
  Serial.println(mfrc522.PICC_GetTypeName(piccType));
  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print(F("     NFC-Typ: "));   //
  delay(1000);
  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print(mfrc522.PICC_GetTypeName(piccType));
  delay(2000);
  lcd.clear();
  byte buffer[8];
  byte block;
  MFRC522::StatusCode status;
  byte len;


  //!!!ab hier Eingabe erforderlich!!!//


  // Farbe?

  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print(F("Halbzeug Farbe/Code"));
  lcd.setCursor(0, 2);
  lcd.print(F("Eingabe 5sek halten"));
  delay(5000);


  // Taster Weiss gedrückt

  if (digitalRead(TasterW) == HIGH) {

    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print("  Weisses Halbzeug");
    delay(2000);
    lcd.clear();

    for (byte i = len; i < 1; i++) buffer[i] = 'W';     //Code
    block = 1;



    //Verbindung zu NFC Tag fehlerhaft

    status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid));
    if (status != MFRC522::STATUS_OK) {
      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print(F(" PCD_Authenticate()       failed: "));
      lcd.print(mfrc522.GetStatusCodeName(status));
      Serial.print(F(" PCD_Authenticate()       failed: "));
      Serial.println(mfrc522.GetStatusCodeName(status));
      delay(1000);
      lcd.clear();
      return;
    }

    // Verbindung OK

    else Serial.println(F(" PCD_Authenticate()       success: "));
    delay(1000);
    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print(F(" PCD_Authenticate()       success: "));


    // Schreibe Code
    status = mfrc522.MIFARE_Write(block, buffer, 16);
    if (status != MFRC522::STATUS_OK) {
      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print(F("   MIFARE_Write()            failed: "));
      lcd.print(mfrc522.GetStatusCodeName(status));
      Serial.print(F("   MIFARE_Write()            failed: "));
      Serial.println(mfrc522.GetStatusCodeName(status));
      delay(1000);
      lcd.clear();
      return;
    }
    else Serial.println(F("   MIFARE_Write()         success: "));
    delay(1000);
    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print(F("   MIFARE_Write()         success: "));


    delay(1000);
    lcd.clear();
    lcd.setCursor(0, 1);

    lcd.print("       Fertig");

    delay(2000);
    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print(" NFC-Tag entfernen");

    delay(6000);
    lcd.clear();
    mfrc522.PICC_HaltA();
    mfrc522.PCD_StopCrypto1();
    return;
  }



  else

    if (digitalRead(TasterS) == HIGH) {

      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print(" Schwarzes Halbzeug");
      delay(2000);
      lcd.clear();

      for (byte i = len; i < 1; i++) buffer[i] = 'S';     //Code
      block = 1;



      //Verbindung zu NFC Tag fehlerhaft

      status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid));
      if (status != MFRC522::STATUS_OK) {
        delay(1000);
        lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print(F(" PCD_Authenticate()       failed: "));
        lcd.print(mfrc522.GetStatusCodeName(status));
        Serial.print(F(" PCD_Authenticate()       failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
        delay(1000);
        lcd.clear();
        return;
      }

      // Verbindung OK

      else Serial.println(F(" PCD_Authenticate()       success: "));
      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print(F(" PCD_Authenticate()       success: "));

      // Schreibe Code
      status = mfrc522.MIFARE_Write(block, buffer, 16);
      if (status != MFRC522::STATUS_OK) {
        delay(1000);
        lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print(F("   MIFARE_Write()           failed: "));
        lcd.print(mfrc522.GetStatusCodeName(status));
        Serial.print(F("   MIFARE_Write()           failed: "));
        Serial.println(mfrc522.GetStatusCodeName(status));
        delay(1000);
        lcd.clear();
        return;
      }
      else Serial.println(F("   MIFARE_Write()         success: "));
      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print(F("   MIFARE_Write()         success: "));

      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 1);

      lcd.print("       Fertig");

      delay(2000);
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print(" NFC-Tag entfernen");

      delay(6000);
      lcd.clear();
      mfrc522.PICC_HaltA();
      mfrc522.PCD_StopCrypto1();
      return;

      // Keine Farbauswahl getroffen?

    }     else
      delay(2000);
  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print("       Fehler ");
  lcd.setCursor(0, 2);
  lcd.print(" NFC-Tag entfernen ");
  delay(6000);
  lcd.clear();
  mfrc522.PICC_HaltA();
  mfrc522.PCD_StopCrypto1();
  return;


}

Deine Terminologie ist verwirrend. Codezeile. Block. Funktion. Diese Wörter haben in der Programmierung eine genau definierte Bedeutungen. Du meinst aber scheinbar etwas anderes damit. Dadurch ist nicht ganz klar was du eigentlich tun willst.

Normal hinterlegt man eben den Vergleichswert in einem Array. Dann liest man den Tag in ein anderes Array ein. Und vergleicht die zwei Arrays mit memcmp() (memory compare)

Im Prinzip:

byte einlesen[] = { 0x01, 0x02, 0x03, 0x04 };   //als Test fest vorgegeben

byte vergleich1[] = { 0x01, 0x02, 0x03, 0x04 };
byte vergleich2[] = { 0x01, 0x02, 0x03, 0xFF };

if (memcmp(einlesen, vergleich1, sizeof(einlesen)) == 0)
{
    // ist gleich
}

if (memcmp(einlesen, vergleich2, sizeof(einlesen)) == 0)
{
   //ist nicht gleich. Dieser Block wird nicht ausgeführt
}

Wie schon gesagt kann man mehrere Vergleichswerte in einem zwei-dimensionalen Array speichern. Dann kann man schön und kurz in einer for-Schleife darüber iterieren

ok das mag das Problem sein.

Also in dem letzten Sketch den ich gepostet habe sieht man das ich einen wert in einem Block hinterlege.
Mit MiFare 1KB Tags geht dies auch nur nicht mit MiFare Ultralight.

Das ist zur Zeit mein Problem

der 2te Arduino kommt dannach der ist dann zum Auslesen und Vergleichen.

Was ist für dich ein Block? Ein Block ist normal das:

{
}

ist ein Array

Das mag kleinlich klingen, aber korrekte Bezeichnungen zu verwenden ist gerade im Internet wichtig, wenn man nicht sofort fragen kann was gemeint war

ok das ist dumm gelaufen :wink:

es geht darum das Jedes NFC Medium Blockzeilen hat die beschriftet werden können.

Mit den Classic 1KB ist das mittlerweile kein Problem mehr aber ich habe extra kleine NFC genommen die heissen Midas und die bekomme ich leider nicht beschrieben bzw. keinen Zugang auf sie.

Sagt immer nur das er keine Verbindung dazu bekommt.
Dachte ggf liegt das an einer Sketch Zeile im Bereich der Beschreibsketchzeile.

z.B in der Status Zeile

status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, block, &key, &(mfrc522.uid));
if (status != MFRC522::STATUS_OK) {

kann sich hier der Fehler befinden?

PCD_Authenticate() failed: Timeout in communication.

Ah, es geht darum Daten auf die Tags zu schreiben. Jetzt macht das Sinn :slight_smile:

Das kann man allgemein schwer bis gar nicht beantworten. Dazu müsste jemand genau das schon mal gemacht haben

Naja darauf hatte ich eigendlich gehofft :wink: Aber ok muss selber gucken.

Suche zur Zeit eine Passende LIB für den Tag Typen für mein RC522 mal sehen ob ich damit weiter komme.

Für Ideen bin ich immer Dankbar ^^