Wie können Sie Ihre Garagentür mit RFID öffnen

() translation by (you can also view the original English article)

Radio Frequency Identification oder RFID ist eine aufregende Technologie, die in den letzten Jahren an Popularität gewonnen hat. Es schafft die Fähigkeit, etwas mit einem sehr kleinen passiven Chip zu markieren, der dann das Fernlesen der Informationen auf diesem Chip ermöglicht. RFID-Tags werden häufig für Sicherheitstürkarten, zur Identifizierung verlorener Haustiere und in letzter Zeit für die Nahfeldkommunikation in Smartphones verwendet.

In diesem Tutorial werde ich ein paar Grundlagen über die Funktionsweise von RFID erklären, verschiedene Arten von RFID beschreiben und zeigen, wie man einen RFID-Garagentor-Öffner bauen kann.

Die Grundlagen von RFID

RFID ist eine wirklich coole Technologie, die die Energie des RFID-Lesersignals nutzt, um das Tag oder den Transponder mit Strom zu versorgen. Das liefert dann ein Signal, das den Inhalt des Speicherchips des Tags enthält.

rfidvisual — Das Abfragesignal versorgt den RFID-Chip

Es gibt eine Reihe von RFID-Typen. Einige Tags können eine kleine Menge an Daten enthalten, die später gelesen werden können. Andere sind so ausgefeilt, dass der Leser einen Verschlüsselungsschlüssel signalisieren muss, bevor das Tag seinen Inhalt dekodieren und zurückgeben kann. Die meisten Tags enthalten jedoch einfach eindeutige eindeutige ID-Nummern. Weitere Informationen zu RFID finden Sie auf Wikipedia.

RFID-Chip-Formate und -Frequenzen variieren erheblich. Es gibt eine ganze Buchstabensuppe von Typen. Viele Smartphones lesen NFC- und MIFARE-Formate.

Für dieses Projekt werde ich jedoch den Chipchip EM4100 125K Wiegand verwenden. Diese Art von RFID verwendet kostengünstige Leser und Tags, was der Hauptgrund für diesen Chip in meinem Kit ist. Solange Sie jedoch kompatible Lesegeräte und Tags haben, ist die Art von RFID für dieses Projekt nicht von Bedeutung.

Das RFID-Projekt

In diesem Projekt werde ich ein RFID-Tag und ein Arduino verwenden, um ein Garagentor zu öffnen, wenn ein autorisiertes Tag erfasst wird. Die Verwendung einer Low-Level-RFID-Komponente ist eine ziemlich komplizierte Aufgabe, daher verwenden wir eine Breakout-Platine, die den Low-Level-Lesevorgang durchführt und den Tag-Code über serielle Pins überträgt. So arbeiten die meisten RFID Breakout Boards. Dieses Tutorial verwendet eine solche Breakout-Karte.

Für dieses Tutorial werde ich das Design für den Garagentoröffner zusammenstellen und einen funktionalen Proof of Concept erstellen.

Projektkomponenten

Arduino (So ungefähr jedes 5V Modell sollte funktionieren, ich habe ein Uno benutzt)
RFID Reader Board mit Antenne
RFID-Tags (Ich fand, dass EM4100 125K Wiegand Schlüsselanhänger sind günstig und leicht zu finden auf ebay)
Steckbrett
Eine Standard-LED
220 Ohm Widerstand (Rot Rot Braun)
Relais (Aleph SD1A05AWJ)
Diode (1N4148)
Jumper Drähte

Wie es funktioniert

Der Prozess ist ziemlich einfach.

Zuerst liest das RFID-Lesegerät das Tag und überträgt den Code an den Arduino. Der Arduino liest dann den Code von der seriellen Verbindung und vergleicht ihn mit einer Liste autorisierter RFID-Codes. Wenn sich das Tag in der autorisierten Liste befindet, zieht der Arduino einen Pin hoch, um 5V zum Schließen eines Relais bereitzustellen. Wenn das Relais schließt, verbindet es die Klemmen der Garagentür-Signalkontakte. Das Garagentor öffnet sich dann.

Der Aufbau

Schritt 1. Die RFID Lesereinstellung

Verwenden Sie das Datenblatt oder die Anweisungen auf dem RFID-Lesegerät, und verdrahten Sie die Strom-, Masse-, seriellen und Antennenstifte. Unten ist das Pin-Out-Diagramm des Lesers, den ich habe. Wir verwenden die Arduino-Pins 2 und 3 für die serielle Kommunikation mit der RFID-Karte, sodass wir die Pins 0 und 1 für die Konsolenausgabe belassen können.rfid_specsheet

rfid_specsheet — Das Datenblatt zeigt die Pinbelegung

Befolgen Sie diese Schritte, um die RFID-Leserkarte anzuschließen.

Kabelmasse zum Erdungsstift des Lesers
Verbinden Sie den Strom mit dem Stromanschluss des Lesers
Verdrahten Sie Arduino Pin 2 mit dem TX Pin der RFID Karte
Verdrahten Sie Arduino Pin 3 mit dem RX Pin
Schließen Sie die Antenne an den Leser an
Verbinden Sie die LED-Anode mit dem pwr out-Pin der Boards-Anzeige.
Verbinden Sie den Kathodenstift der LED über den Widerstand mit der Masse

Meine Steckbrett-Einstellung wird unten angezeigt.

rfidhookedup — Der Arduino ist mit der RFID-Leserplatine verbunden

Schritt 2. Relais-Einstellung

Fügen Sie das Relais dem Steckbrett hinzu. Die zwei internen Pins führen den Elektromagneten, der das Relais schließt. Im folgenden Diagramm sehen Sie, wie sich der laufende Strom über die Pins 3 bis 7 auf das Relais auswirkt.

Führen Sie Pin 4 vom Arduino zu Pin 3 auf dem Relais. Wenn er hoch gezogen wird, liefert dieser Pin genug Strom, um das Relais zu schließen.
Führen Sie Pin 7 am Relais zur Masse.
Fügen Sie die Diode zwischen den Stiften 3 und 7 mit dem Farbstreifen in Richtung Pin 3 des Relais.

Tipp: Wenn Sie ein Relais oder wirklich alles verwenden, das ein elektromagnetisches Feld verwendet, verwenden Sie immer eine "Rücklauf" -Diode, um das System vor der Leistungsspitze zu schützen, wenn das Magnetfeld zusammenbricht.

Das ist mein Steckbrett mit dem Relais verdrahtet.

Breadboard with RFID and relay setup — Steckbrett mit RFID- und Relais-Einstellung

Schritt 3. Programmieren Sie Arduino

Kopieren Sie den Code am Ende dieses Tutorials. Der Code ist ausführlich kommentiert, damit Sie verstehen, was bei jedem Schritt passiert. Oben im Code können Sie sehen, wo die Liste der RFID-Tag-Werte geändert werden kann. Wir werden den Code einmal ausführen und Ihren RFID-Tag winken, damit Sie die ID aus Ihren autorisierten Tags kopieren und in den endgültigen Code einfügen können.
Klicken Sie in der Arduino IDE auf Hochladen
Öffnen Sie den seriellen Monitor der Arduino IDE, indem Sie CTRL SHIFT M drücken oder Menü Werkzeuge > Serieller Monitor (Tools > Serial Monitor) wählen.

Tipp: Stellen Sie sicher, dass die Baudrate des seriellen Monitors mit der Einstellung in der Funktion setup() übereinstimmt. In diesem Beispiel: 38400.

Sie sollten so etwas sehen:

RFID GDO V0.1 Tag read: 3D00CFBB80 Checksum: C9 — passed. 3D00CFBB80

Schlechtes Tag. Gehen Sie weg.

Kopieren Sie Ihre ID (3D00CFBB80 in diesem Beispiel) und fügen Sie sie in den Code der GoodTags-Liste ein. Beachten Sie, dass ein anderer Code in einer neuen Zeile stehen kann, solange er von Anführungszeichen umgeben ist und ein Komma hinter ihm steht. Eine einzelne Codeliste könnte etwa so aussehen:

char* goodTags[] = { "3D00CFBB80", };

Klicken Sie in der Arduino IDE auf Laden, und öffnen Sie dann den seriellen Monitor der Arduino IDE, indem Sie CTRL SHIFT M drücken oder das Menü Werkzeuge > Serieller Monitor auswählen.

Wenn Sie nun den Code ausführen, sehen Sie Folgendes:

RFID GDO V0.1 Tag read: 3D00CFBB80 Checksum: C9 -- passed. 3D00CFBB80

Öffnung der Tür!

Unten ist ein Foto von mir, das den RFID-Tag mit dem Relais testet. Das Multimeter wird an die Pins 1 und 9 des Relais angeschlossen, damit es beim Schließen des Relais Kontinuität erkennen kann.

Testing the RFID loop — Testen der RFID-Schleife

Wenn ein Multimeter angeschlossen ist, können Sie den Piepton des Multimeters hören, um Kontinuität anzuzeigen, und dann einen sehr schwachen Knick, und das Relais springt wieder auf.

Schritt 4. Öffnung des Garagentors

Die meisten Garagentoröffner funktionieren sehr einfach durch Öffnen, wenn sie einen Kontakt geschlossen haben. Wenn Sie den Knopf an der Wand drücken, schließen Sie den Kontakt. An meinem Garagentoröffner habe ich Terminals, an denen die Drähte des Tasters angeschlossen sind. Sie können die hier markierten Terminals sehen:

garagedoorterminals — Garagendosterminals

Pin 1 und 9 vom Relais auf dem Steckbrett an die Klemmen am Garagentoröffner anschließen
Bewegen Sie Ihr RFID-Tag in die Nähe der Antenne
Sehen Sie die Tür offen

Sie haben jetzt den grundlegenden Beweis des Konzepts, um die Tür mit einer Handbewegung zu öffnen.

Schritt 5. Machen Sie es dauerhaft

Montieren Sie die Antenne irgendwo, wo sie das Tag durch die Tür oder die Wand lesen kann. RFID kann feste Objekte passieren, so dass je nach Material eine Antenne hinter der Garagenwand versteckt werden kann. Es kann einige Versuche und Fehler erfordern, einen Ort zu finden, an dem es das Tag lesen kann.
Übertragen Sie die Schaltung auf ein Surfbrett und löten Sie eine dauerhafte Lösung
Legen Sie das Projekt in eine Kiste und montieren Sie es in Ihrer Garage.

Quellcode für dieses Projekt

/*
  RFID Garage door opener sample code by Ben Miller @VMfoo
  ReadKey function inspired and borrowed in part from the arduino playground
  example: http://playground.arduino.cc/Code/ID12

*/

// include the SoftwareSerial library so you can use its functions:
#include   //leaving the hardware serial ports for debugging

#define rxPin 2    //pin to receive data from RFID reader
#define txPin 3    //transmit pin for softserial initialization
#define doorPin 4  //pin to trigger relay

// set up a new serial port
NewSoftSerial RFIDPort =  NewSoftSerial(rxPin, txPin);
byte pinState = 0;

// for incoming serial data
int incomingByte = 0;
// character array for the value of the RFID tag
char tagValue[10];

//What tag values are authorized
char* goodTags[] = {
  "3D00CFBB80",
  //"######",  //add another tag by replacing the #'s with your code and uncommenting this line
};
// Calculate the number of tags in the array above
int tagCount = sizeof(goodTags)/sizeof(goodTags[0]);

void setup()  {
  // define pin modes for the opener relay
  pinMode(doorPin, OUTPUT);

  // set the data rate for the SoftwareSerial port
  RFIDPort.begin(9600);
  Serial.begin(38400);  //serial monitor rate
  Serial.println("RFID GDO V0.1");  //hello world
}

void loop() {
  //loop and read
  if ( RFIDPort.available() ) {
      if ( readKey() ) {
       //check tag value
        if(goodTag()){  //if this is allowed
          openDoor();
        } else {
          Serial.println("Bad tag.  Go away.");
        }
      }
  }
}

int goodTag() {
  for(int i=0; i < tagCount; i++) {  //walk through the tag list
    if(strcmp(tagValue, goodTags[i]) == 0) {
      return 1;
    }
  }
   return 0;
}

void openDoor(){
  Serial.println("Opening Door!");
  digitalWrite(doorPin, HIGH);
  delay(500); // half a second is plenty of time to let trigger the contact
  digitalWrite(doorPin, LOW);
  //to prevent "bounce" or secondary reads if the tag is still close to the reader
  //we delay 3 seconds
  delay(3000);
}

int readKey(){
  byte i         = 0;
  byte val       = 0;
  byte checksum  = 0;
  byte bytesRead = 0;
  byte tempByte  = 0;
  byte tagBytes[6];    // "Unique" tags are only 5 bytes but we need an extra byte for the checksum
//  char tagValue[10]; this is defined globaly to simplify code

  if((val = RFIDPort.read()) == 2) {        // Check for header
    bytesRead = 0;
    while (bytesRead < 12) {            // Read 10 digit code + 2 digit checksum
    if (RFIDPort.available()) {
      val = RFIDPort.read();

      // Append the first 10 bytes (0 to 9) to the raw tag value
      // Check if this is a header or stop byte before the 10 digit reading is complete
      if (bytesRead < 10)       { tagValue[bytesRead] = val; }       if((val == 0x0D)||(val == 0x0A)||(val == 0x03)||(val == 0x02)) {  break; // Stop reading }       // Ascii/Hex conversion:       if ((val >= '0') && (val <= '9')) {  val = val - '0';  }       else if ((val >= 'A') && (val <= 'F')) { val = 10 + val - 'A'; }       // Every two hex-digits, add a byte to the code:       if (bytesRead & 1 == 1) {          // Make space for this hex-digit by shifting the previous digit 4 bits to the left          tagBytes[bytesRead >> 1] = (val | (tempByte << 4));         if (bytesRead >> 1 != 5) {     // If we're at the checksum byte,
           checksum ^= tagBytes[bytesRead >> 1];   // Calculate the checksum... (XOR)
          };
      } else {
        tempByte = val; // Store the first hex digit first
      };

      bytesRead++; // Ready to read next digit
      }
    }
    // Send the result to the host connected via USB
    if (bytesRead == 12) {                        // 12 digit read is complete
      tagValue[10] = '\0';                        // Null-terminate the string

      Serial.print("Tag read: ");
      for (i=0; i<5; i++) {
        // Add a leading 0 to pad out values below 16
        if (tagBytes[i] < 16) {
          Serial.print("0");
        }
        Serial.print(tagBytes[i], HEX);
      }
      Serial.println();

      Serial.print("Checksum: ");
      Serial.print(tagBytes[5], HEX);
      Serial.println(tagBytes[5] == checksum ? " -- passed." : " -- error.");
      Serial.println(tagValue);
      Serial.println();
      return 1; //return value to indicate that we read something
    }
  }
  bytesRead=0;
  return 0;
}

Zusammenfassung

In diesem Tutorial habe ich die Grundlagen der RFID-Technologie erläutert und sie für Ihre eigenen Projekte nutzbar gemacht. Während die Low-Level-Komponenten, die RFID lesen, für Bastler schwierig zu bedienen sind, ermöglichen RFID-Breakout-Boards die einfache Verwendung von RFID in Projekten mit Arduino oder sogar einem Raspberry Pi über eine serielle Schnittstelle. Sobald eine ID von einem Tag gelesen wurde, ist es einfach, auf die Information zu reagieren. In diesem Beispiel haben wir ein Relais betätigt, um ein Garagentor zu öffnen.

In Ergänzung:

Ich untersuchte die Unterschiede in den Arten der RFID-Technologie
Ich habe das Konzept der Funktionsweise von RFID untersucht
Sie folgten einem Beispiel für das Anschließen einer RFID-Leserplatine an einen Arduino
Lesen und drucken Sie die RFID-Kennung aus einem ID-Tag
Dem Schaltkreis wurde ein Relais hinzugefügt, um einen Kontakt zu schließen, wenn das richtige Tag gelesen wurde
Verbinden Sie das Relais mit einem Garagentoröffner, um RFID-basierte Zugangskontrolle hinzuzufügen