RFID

Mit diesem Projekt wird ein RFID-Kartenleser (RFID=radio frequency identification) für eine Zugangskontrolle eingesetzt. Zunächst muss der RFID-Transponder oder die RFID-Karte ausgelesen werden. Der ausgelesene "Code" wird im Hauptprogramm für den Zugang verwendet und z.B. ein Türschloss geöffnet.
Die Grüne LED zeigt blinkend die Verwendung des korrekten Transponder an, die rote LED zeigt blinkend einen ungültigen Transponder an. Ein Ausgang ist für einen Relais-Anschluss für ein Türschloss vorgesehen und ein Ausgang optional für einen Servo-Motor.

Hardware

Die Stückliste für die RFID-Zugangskontrolle:

• 1 x Arduino NANO
• 1 x RFID-RC522 Modul
• 1 x Transponder mit Schlüsselring
• 1 x Transponder im Kartenformat
• 1 x Relais für den Türöffner (optional)
• 1 x rote LED mit 100R Vorwiderstand
• 1 x grüne LED mit 100R Vorwiderstand
• 1 x Buzzer (optional)
• 1 x Relais für den Türöffner (optional)
• 1 x Servo-Motor (optional)
• Kleinmaterial, Schaltdraht

Verdrahtung

• NANO 2 -> grüne LED
• NANO 3 -> rote LED
• NANO 4 -> Buzzer
• NANO 5 -> Relais
• NANO 7 -> ServoMotor

Software

Die Software wird mit der Arduino IDE in den NANO geladen.

• Mit dem Programm 1 wird die RFID-ID aus dem Transponder oder Karte ausgelesen.
• Das Programm 2 ist das Hauptprogramm für die Zugangskontrolle.

Programm

C++ Code: Transponder auslesen

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: RFID Auslesen
**************************************************************************************************
Version: 21.06.2022
**************************************************************************************************
Board: NANO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/

#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN  10  // ESP32 pin GIOP5
#define RST_PIN 9 // ESP32 pin GIOP27


MFRC522 rfid(SS_PIN, RST_PIN);

void setup() {
  Serial.begin(115200);
  SPI.begin(); // init SPI bus
  rfid.PCD_Init(); // init MFRC522

  Serial.println("Lege den Chip oder die Karte auf den RFID-RC522 Reader");
}

void loop() {
  if (rfid.PICC_IsNewCardPresent()) {
    if (rfid.PICC_ReadCardSerial()) {
      MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
      Serial.print("RFID/NFC Typ: ");
      Serial.println(rfid.PICC_GetTypeName(piccType));


      Serial.print("UID:");
      for (int i = 0; i < rfid.uid.size; i++) {
        Serial.print(rfid.uid.uidByte[i] < 0x10 ? " 0" : " ");
        Serial.print(rfid.uid.uidByte[i], HEX);
      }
      Serial.println();

      rfid.PICC_HaltA();
      rfid.PCD_StopCrypto1();
    }
  }
}

RAW code

RFID-Code mit dem Seriellen Monitor auslesen

C++ Code: Hauptprogramm RFID-Zugangskontrolle

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: RFID LED ansteuern, Relais, Servo, 2 Chips

**************************************************************************************************
Version: 05.11.2022
**************************************************************************************************
Board: NANO
**************************************************************************************************
Libraries:
https://github.com/miguelbalboa/rfid
https://github.com/espressif/arduino-esp32/tree/master/libraries
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/
//einbinden der Bibliotheken für das
//ansteuern des MFRC522 Moduls
#include <SPI.h>
#include <MFRC522.h>

//definieren der Pins  RST & SDA für den NANO
#define RST_PIN     9
#define SS_PIN      10

#define ledRot 3
#define ledGruen 2
#define oc_PIN 5 //Open Close PIN

//erzeugen einer Objektinstanz
MFRC522 mfrc522(SS_PIN, RST_PIN);

//Variable zum speichern der bereits gelesenen RFID-ID
String lastRfid = "";

//Anzahl der zulässigen RFID-IDs im Array ************************************************
const int NUM_RFIDS = 2;
//zulaessige  RFID-ID
String rfids[NUM_RFIDS] = {" 43 7D 3F 92", " 73 05 B4 94"};
//****************************************************************************************

#include "Servo.h"                          // Servomotor-Bibliothek
#define SERVOPIN 7
Servo Servomotor;


void setup() {
  //beginn der seriellen Kommunikation mit 115200 Baud
  Serial.begin(115200);
  //eine kleine Pause von 50ms.
  Serial.println("Das Tuerschloss ist aktiv");
  delay(50);

  pinMode(ledRot, OUTPUT);
  pinMode(ledGruen, OUTPUT);
  pinMode(oc_PIN, OUTPUT);
  digitalWrite(oc_PIN, LOW);

    Servomotor.attach(SERVOPIN);
    Servomotor.write(0);                    // Servomotor auf Schließposition 0 Grad fahren


  //begin der SPI Kommunikation
  SPI.begin();
  //initialisieren der Kommunikation mit dem RFID Modul
  mfrc522.PCD_Init();
}

void loop() {

  //Wenn keine neue Karte vorgehalten wurde oder die serielle Kommunikation
  //nicht gegeben ist, dann...
  if ( !mfrc522.PICC_IsNewCardPresent()) {
    //Serial.println("!PICC_IsNewCardPresent");
    return;
  }

  if (!mfrc522.PICC_ReadCardSerial()) {
    //Serial.println("!PICC_ReadCardSerial");
    return;
  }


  String newRfidId = "";
  for (byte i = 0; i < mfrc522.uid.size; i++) {
    newRfidId.concat(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
    newRfidId.concat(String(mfrc522.uid.uidByte[i], HEX));
  }

  //alle Buchstaben in Großbuchstaben umwandeln
  newRfidId.toUpperCase();

  //Wenn die neue gelesene RFID-ID ungleich der bereits zuvor gelesenen ist,
  //dann soll diese auf der seriellen Schnittstelle ausgegeben werden.
  if (!newRfidId.equals(lastRfid)) {
    //überschreiben der alten ID mit der neuen
    lastRfid = newRfidId;
  }


  bool zugangOk = false;
  //prüfen ob die gelesene RFID-ID im Array mit bereits gespeicherten IDs vorhanden ist
  for (int i = 0; i < NUM_RFIDS; i++) {
    //wenn die ID an der Stelle "i" im Array "rfids" mit dem gelesenen übereinstimmt, dann
    if (rfids[i].equals(newRfidId)) {
      zugangOk = true;
      //Schleife verlassen
      break;
    }
  }

  //Wenn die Variable "zugangOk" auf True ist, dann...
  if (zugangOk) {
    digitalWrite(oc_PIN, HIGH); //Türschloss öffnen
    Serial.println("Tuerschloss oeffnen");
    Servomotor.write(90);        // Servo in Öffnungsposition 90 Grad fahren

    blinkLed(ledGruen);
    Serial.println("RFID-ID [" + newRfidId + "] OK!, Zugang wird gewährt");
    delay(1000);
    digitalWrite(oc_PIN, LOW);
    Serial.println("Tuerschloss schliessen");
    Servomotor.write(0);        // Servo in Öffnungsposition 90 Grad fahren

  } else {
    //Wenn nicht dann...
    blinkLed(ledRot);
    Serial.println("RFID-ID [" + newRfidId + "] nicht OK!, Zugang wird nicht gewährt");
  }

  Serial.println();
}

//Blinken einer LED am Pin "pin"
void blinkLed(int pin) {
  //Schleife von 0 bis 5
  for (int a = 0; a < 5; a++) {
    //LED aktivieren
    digitalWrite(pin, HIGH);
    //eine Pause von 125 ms.
    delay(125);
    //LED deaktivieren
    digitalWrite(pin, LOW);
    //eine Pause von 125 ms.
    delay(125);
  }
}

RAW code

RFID-Zugangsinformationen mit dem Seriellen Monitor auslesen

RFID-Zugangsinformationen für zwei RFID-Transponder mit dem Seriellen Monitor auslesen

Aufbau der RFID-Zugangskontrolle

RFID-Zugangskontrolle mit Servo-Motor Verschlusseinheit

C++ Code: Testprogramm für ein UNO-RFID-Shield

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: RFID-Shield Test

**************************************************************************************************
Version: 16.11.2022
**************************************************************************************************
Board: UNO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19

**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json

It uses SPI communication. Connect SCK, MI, MO and NSS on the shield with jumper cap. Then slide SET0 to L, SET1 to H.
There are two slide switches on the shield for you to select the interface mode:
      SET0  SET1
UART  L     L
SPI   L     H
IIC   H     L
**************************************************************************************************/

#include <PN532.h>
#include <SPI.h>

/*Chip select pin can be connected to D10 or D9 which is hareware optional*/
/*if you the version of NFC Shield from SeeedStudio is v2.0.*/
#define PN532_CS 10

PN532 nfc(PN532_CS);
#define  NFC_DEMO_DEBUG 1

void setup(void) {
#ifdef NFC_DEMO_DEBUG
  Serial.begin(115200);
  Serial.println("Hello!");
#endif
  nfc.begin();

  uint32_t versiondata = nfc.getFirmwareVersion();
  if (! versiondata) {
#ifdef NFC_DEMO_DEBUG
    Serial.print("Didn't find PN53x board");
#endif
    while (1); // halt
  }
#ifdef NFC_DEMO_DEBUG
  // Got ok data, print it out!
  Serial.print("Found chip PN5");
  Serial.println((versiondata>>24) & 0xFF, HEX);
  Serial.print("Firmware ver. ");
  Serial.print((versiondata>>16) & 0xFF, DEC);
  Serial.print('.');
  Serial.println((versiondata>>8) & 0xFF, DEC);
  Serial.print("Supports ");
  Serial.println(versiondata & 0xFF, HEX);
#endif
  // configure board to read RFID tags and cards
  nfc.SAMConfig();
}

void loop(void) {
  uint32_t id;
  // look for MiFare type cards
  id = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A);

  if (id != 0)

  {
#ifdef NFC_DEMO_DEBUG
    Serial.println(" ");
    Serial.println("Read card #");
    Serial.println(id);
#endif
    uint8_t keys[]= { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF };
    if(nfc.authenticateBlock(1, id ,0x08,KEY_A,keys)) //authenticate block 0x08
    {
      //if authentication successful
      uint8_t block[16];
      //read memory block 0x08
      if(nfc.readMemoryBlock(1,0x08,block))
      {
#ifdef NFC_DEMO_DEBUG
        //if read operation is successful
        for(uint8_t i=0;i<16;i++)
        {
          //print memory block
          Serial.print(block[i],HEX);
          Serial.print(" ");
        }
        Serial.println();
#endif
      }
    }
  }
 delay(500);
}

RAW code

RFID-Shield:Zugangsinformationen mit dem Seriellen Monitor auslesen

PIN-OUT RFID-Shield

Zurück