Wir wissen in Büros, Einkaufszentren und an vielen anderen Orten, wo nur die Person mit Autorisierungskarte den Raum betreten darf. Diese Systeme verwenden ein RFID-Kommunikationssystem. RFID wird in Einkaufszentren verwendet, um Diebstahl zu verhindern, da die Produkte mit einem RFID-Chip gekennzeichnet sind. Wenn eine Person das Gebäude mit dem RFID-Chip verlässt, wird automatisch ein Alarm ausgelöst. Das RFID-Tag ist so klein wie ein Teil des Sandes. Die RFID-Authentifizierungssysteme sind einfach zu entwerfen und kostengünstig. Einige Schulen und Hochschulen verwenden heutzutage RFID-basierte Anwesenheitssysteme.
In diesem Projekt werden wir aus Sicherheitsgründen ein RFID-basiertes Mauterhebungssystem entwickeln. Dieses System öffnet also Tore und erlaubt nur Personen mit den autorisierten RFID-Tags. Die Inhaber-IDs der autorisierten Tags sind im ATMEGA Microcontroller programmiert, und nur diese Inhaber dürfen die Räumlichkeiten verlassen oder betreten.
Erforderliche Komponenten
Hardware: ATmega32-Mikrocontroller, Netzteil (5 V), AVR-ISP-Programmierer, JHD_162ALCD (16 x 2 LCD-Modul), 100 uF-Kondensator (über das Netzteil angeschlossen), Taste, 10 kΩ-Widerstand, 100 nF-Kondensator, LED (zweiteilig), EM-18 (RFID-Lesemodul), L293D-Motortreiber-IC, 5-V-Gleichstrommotor.
Software: Atmel Studio 6.1, Progisp oder Flash Magic.
Schaltplan und Arbeitserklärung
In der oben gezeigten Schaltung des RFID-Mauterhebungssystems ist PORTA von ATMEGA32 mit dem Datenport des LCD verbunden. Hier sollten wir daran denken, die JTAG-Kommunikation in PORTC zu ATMEGA durch Ändern der Sicherungsbytes zu deaktivieren, wenn wir PORTC als normalen Kommunikationsport verwenden möchten. Bei 16x2-LCD-Bildschirmen gibt es insgesamt 16 Pins, wenn eine Hintergrundbeleuchtung vorhanden ist. Wenn keine Hintergrundbeleuchtung vorhanden ist, sind 14 Pins vorhanden. Wir können die Stifte für die Hintergrundbeleuchtung mit Strom versorgen oder belassen. Nun in den 14 Stiften sind 8 Datenstifte (7-14 oder D0-D7), 2 Stromversorgungsstifte (1, 2 oder VSS & VDD oder GND & + 5 V), 3 rd Stift für die Kontraststeuerung (VEE-Kontrollen, wie dick die Zeichen sollten angezeigt werden), 3 Steuerstifte (RS & RW & E).
In der Schaltung können Sie beobachten, dass ich nur zwei Steuerstifte genommen habe. Dies gibt die Flexibilität eines besseren Verständnisses. Das Kontrastbit und READ / WRITE werden nicht oft verwendet, so dass sie gegen Masse kurzgeschlossen werden können. Dies versetzt das LCD in den höchsten Kontrast- und Lesemodus. Wir müssen nur die ENABLE- und RS-Pins steuern, um Zeichen und Daten entsprechend zu senden.
Die Anschlüsse, die für LCD hergestellt werden, sind unten angegeben:
PIN1 oder VSS gegen Masse
PIN2 oder VDD oder VCC auf +5V
PIN3 oder VEE gegen Masse (bietet maximalen Kontrast am besten für Anfänger)
PIN4 oder RS (Registerauswahl) an PD6 der MCU
PIN5 oder RW (Lesen / Schreiben) nach Masse (versetzt das LCD in den Lesemodus, erleichtert die Kommunikation für den Benutzer)
PIN6 oder E (Aktivieren) an PD5 des Mikrocontrollers
PIN7 oder D0 bis PA0
PIN8 oder D1 bis PA1
PIN9 oder D2 bis PA2
PIN10 oder D3 bis PA3
PIN11 oder D4 bis PA4
PIN12 oder D5 bis PA5
PIN13 oder D6 bis PA6
PIN14 oder D7 bis PA7
In der Schaltung sehen Sie, dass wir 8-Bit-Kommunikation (D0-D7) verwendet haben. Dies ist jedoch nicht obligatorisch und wir können 4-Bit-Kommunikation (D4-D7) verwenden, aber mit 4-Bit-Kommunikation wird das Programm etwas komplex, daher habe ich 8-Bit-Kommunikation bevorzugt.
Aus der bloßen Beobachtung der obigen Tabelle schließen wir also 10 Pins des LCD an den Controller an, wobei 8 Pins Datenpins und 2 Pins zur Steuerung sind.
Bevor wir fortfahren, müssen wir uns mit der seriellen Kommunikation vertraut machen. Das RFID-Modul sendet hier seriell Daten an die Steuerung. Es hat eine andere Art der Kommunikation, aber für eine einfache Kommunikation wählen wir RS232. Der RS232-Pin des Moduls ist mit dem RXD-Pin von ATMEGA verbunden.
Die vom RFID-Modul gesendeten Daten lauten wie folgt:
Für die RFID-Modulschnittstelle sind nun die folgenden Funktionen erforderlich:
1. Der RXD-Pin (Datenempfangsfunktion) des Controllers muss aktiviert sein.
2. Da die Kommunikation seriell ist, müssen wir wissen, wann das Datenbye empfangen wird, damit wir das Programm stoppen können, bis das vollständige Byte empfangen wird. Dies erfolgt durch Aktivieren eines vollständigen Datenempfangsinterrupts.
3. RFID sendet Daten im 8-Bit-Modus an die Steuerung. Es werden also zwei Zeichen gleichzeitig an den Controller gesendet. Dies ist in der obigen Abbildung dargestellt.
4. In der obigen Abbildung gibt es keine Paritätsbits, ein Stoppbit in den vom Modul gesendeten Daten.
Die oben genannten Funktionen sind in den Controller-Registern festgelegt. wir werden sie kurz besprechen,
ROT (RXEN): Dieses Bit repräsentiert die Empfangsdatenfunktion. Dieses Bit muss gesetzt sein, damit die Daten vom Modul von der Steuerung empfangen werden. Es aktiviert auch den RXD-Pin des Controllers.
BROWN (RXCIE): Dieses Bit muss gesetzt sein, um nach erfolgreichem Datenempfang einen Interrupt zu erhalten. Durch Aktivieren dieses Bits lernen wir gleich nach dem 8-Bit-Datenempfang kennen.
PINK (URSEL): Dieses Bit muss gesetzt werden, bevor andere Bits in UCSRC aktiviert werden. Nach dem Setzen anderer erforderlicher Bits in UCSRC muss URSEL deaktiviert oder auf Null gesetzt werden.
GELB (UCSZ0, UCSZ1, UCSZ2): Diese drei Bits werden verwendet, um die Anzahl der Datenbits auszuwählen, die wir in einem Durchgang empfangen oder senden.
Da die vom RFID-Modul gesendeten Daten vom 8-Bit-Datentyp sind, müssen wir UCSZ0, UCSZ1 auf Eins und UCSZ2 auf Null setzen.
ORANGE (UMSEL): Dieses Bit wird basierend darauf gesetzt, ob das System asynchron (beide verwenden unterschiedliche Uhr) oder synchron (beide verwenden dieselbe Uhr) kommuniziert.
Da Modul und Controller unterschiedliche Takte verwenden, muss dieses Bit auf Null gesetzt oder in Ruhe gelassen werden, da alle standardmäßig auf Null gesetzt sind.
GRÜN (UPM1, UPM0): Diese beiden Bits werden basierend auf der Bitparität angepasst, die wir in der Kommunikation verwenden.
Da das RFID-Modul Daten ohne Parität sendet, haben wir sowohl UPM1 als auch UPM0 auf Null gesetzt, oder sie können in Ruhe gelassen werden, da alle Bits in beliebigen Registern standardmäßig auf Null gesetzt sind.
BLAU (USBS): Dieses Bit wird zur Auswahl der Anzahl der Stoppbits verwendet, die wir während der Kommunikation verwenden.
Da das RFID-Modul Daten mit einem Stoppbit sendet, müssen wir nur das USBS-Bit in Ruhe lassen.
Jetzt müssen wir endlich die Baudrate einstellen. Aus der obigen Abbildung geht hervor, dass das RFID-Modul Daten mit einer Baudrate von 9600 Bit / s (Bit pro Sekunde) an die Steuerung sendet.
Die Baudrate wird im Controller durch Auswahl des entsprechenden UBRRH eingestellt.
Der UBRRH-Wert wird durch Querverweisen auf die Baudrate und die CPU-Kristallfrequenz ausgewählt. Durch Querverweisen wird der UBRR-Wert als '6' angesehen, und daher wird die Baudrate eingestellt.
Wie in der Abbildung gezeigt, gehen nun zwei Pins vom Controller zu L293D, einer H-BRÜCKE, mit der Drehzahl und Drehrichtung für Gleichstrommotoren mit geringer Leistung gesteuert werden.
L293D ist ein H-BRIDGE-IC, der für den Antrieb von Gleichstrommotoren mit geringer Leistung ausgelegt ist. In der Abbildung ist dieser IC aus zwei H-Brücken dargestellt und kann daher zwei Gleichstrommotoren antreiben. Dieser IC kann also verwendet werden, um Robotermotoren aus den Signalen des Mikrocontrollers anzutreiben.
Wie bereits erwähnt, kann dieser IC die Drehrichtung des Gleichstrommotors ändern. Dies wird erreicht, indem die Spannungspegel an INPUT1 und INPUT2 gesteuert werden.
|
Pin aktivieren |
Eingangspin 1 |
Eingangspin 2 |
Motorrichtung |
|
Hoch |
Niedrig |
Hoch |
Biegen Sie rechts ab |
|
Hoch |
Hoch |
Niedrig |
Biegen Sie links ab |
|
Hoch |
Niedrig |
Niedrig |
Halt |
|
Hoch |
Hoch |
Hoch |
Halt |
Wie in der obigen Tabelle gezeigt, sollte für die Drehung im Uhrzeigersinn 2A hoch und 1A niedrig sein. In ähnlicher Weise sollte 1A gegen den Uhrzeigersinn hoch und 2A niedrig sein.
Wenn eine autorisierte Karte in die Nähe des Moduls gebracht wird, ist der Motor so programmiert, dass er sich eine Sekunde lang im Uhrzeigersinn bewegt, um anzuzeigen, dass die Mautstelle nach einer Sekunde geöffnet ist, wenn sie zurückkommt, und dass die Mautstelle geschlossen ist. Die Funktionsweise des Mautplatzes wird am besten Schritt für Schritt anhand des unten angegebenen C-Codes erläutert.
Programmiererklärung
Nachfolgend finden Sie eine Erklärung von Zeile zu Zeile für den Code des RFID-Mauterhebungssystems. Sie können das Konzept und die Arbeitsweise dieses Projekts verstehen, indem Sie den folgenden Code lesen. Zum Herunterladen oder Kopieren finden Sie den vollständigen Code am Ende der Seite.
#include // Header, um die Datenflusssteuerung über Pins zu aktivieren
#define F_CPU 1000000 // Angabe der angeschlossenen Controller-Kristallfrequenz
#einschließen
#define E 5 // Namen geben „Freigabe“ bis 5 th Stift von PORTD, da es zu LCD angeschlossen ist Enable - Pin
#define RS 6 // geben Namen „registerselection“ bis 6 th Stift PORTD, da es zu LCD RS Stift verbunden ist, void send_a_command (vorzeichenloser char-Befehl);
void send_a_character (vorzeichenloses Zeichen);
void send_a_string (char * string_of_characters);
int main (nichtig)
{
DDRA = 0xFF; // Porta als Ausgangspins setzen
DDRD = 0b11111110;
_delay_ms (50); // mit einer Verzögerung von 50ms
DDRB = 0b11110000; // Einige PortB-Pins als Eingabe nehmen.
UCSRB - = (1 <
UCSRC - = (1 <
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // Festlegen der Baudrate // Das Folgende enthält die ID von Tags. Diese müssen für verschiedene Tags geändert werden. Diese müssen aktualisiert werden, damit das Projekt funktioniert
/ * Nach dem Ablegen des Programms in der Steuerung muss man die Karten nehmen, die autorisiert werden müssen, und die Tags-ID erhalten. Diese erhalten Sie, indem Sie das Etikett in der Nähe des RFID-Moduls platzieren. Die ID wird auf dem Bildschirm angezeigt. Nach dem Abrufen der IDs muss das Programm aktualisiert werden, indem die folgenden ID-Nummern durch neue ID-Nummern ersetzt werden.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Jetzt oben autorisieren wir nur fünf Karten, diese können in eine beliebige Anzahl geändert werden.
Angenommen, das Standardprogramm wird im Controller gespeichert, und holen Sie sich die Karten, die autorisiert werden sollen. Platzieren Sie eines nach dem anderen in der Nähe des Moduls. Sie erhalten die ID für jedes Modul als xxxxxxxx (907a4F87).
Wenn wir 7 Tags haben, haben wir 7 8-Bit-IDs. * /
|
// jetzt für sieben Karten geht es als // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // Speicher für die Anzeige der vom Modul gesendeten ID zuweisen int i = 0; int vote = 0; int k = 0; send_a_command (0x01); // Bildschirm löschen 0x01 = 00000001 Verzögerung (50); send_a_command (0x38); // lcd mitteilen, dass wir den 8-Bit-Befehls- / Datenmodus verwenden Verzögerung (50); send_a_command (0b00001111); // LCD-BILDSCHIRM EIN und Courser blinkt char MEM; // Speicher zuweisen, um die vollständige ID des Tags zu speichern send_a_string ("RFID NUMBER"); // String senden send_a_command (0x80 + 0x40 + 0); // Courser in die zweite Zeile verschieben während (1) { während (! (UCSRA & (1 <)
{ }} COUNTA = UDR; // UDR speichert die empfangenen 8-Bit-Daten und wird in eine Ganzzahl umgewandelt. MEM = COUNTA; // Die ersten beiden Zeichen werden in den Speicher aktualisiert itoa (COUNTA, SHOWA, 16); // Befehl zum Einfügen der Variablennummer in das LCD (Variablennummer, welches Zeichen ersetzt werden soll, welche Basis variabel ist (zehn hier, da wir die Nummer in base10 zählen)) send_a_string (SHOWA); // Aufforderung an das Display, das Zeichen (ersetzt durch die variable Nummer) der zweiten Person anzuzeigen, nachdem der Courser auf dem LCD positioniert wurde während (! (UCSRA & (1 <)
{ }} COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // Das dritte und vierte Zeichen werden in den Speicher aktualisiert während (! (UCSRA & (1 <)
{ }} COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // fünftes und sechstes Zeichen werden in den Speicher aktualisiert während (! (UCSRA & (1 <)
{ }} COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // Siebtes und acht Zeichen werden in den Speicher aktualisiert send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
für (i = 0; i <5; i ++) { if ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// Überprüfung auf Autorisierung kaufen, indem zwei Zeichen gleichzeitig mit den Zeichen im Speicher verglichen werden PORTB - = (1 <
PORTB & = ~ (1 <
_delay_ms (220); // Verzögerung Verzögerung (220); Verzögerung (220); Verzögerung (220); Verzögerung (220); Verzögerung (220); PORTB - = (1 <
PORTB & = ~ (1 <
Verzögerung (220); Verzögerung (220); Verzögerung (220); Verzögerung (220); Verzögerung (220); Verzögerung (220); PORTB & = ~ (1 <
PORTB - = (1 <
}} }} UCSRB - = (1 <
}} }} void send_a_command (vorzeichenloser char-Befehl) { PORTA = Befehl; PORTD & = ~ (1 <
PORTD - = 1 <
Verzögerung (50); PORTD & = ~ 1 <
PORTA = 0; }} void send_a_character (vorzeichenloses Zeichen) { PORTA = Zeichen; PORTD - = 1 <
PORTD - = 1 <
Verzögerung (50); PORTD & = ~ 1 <
PORTA = 0; }} void send_a_string (char * string_of_characters) { while (* string_of_characters> 0) { send_a_character (* string_of_characters ++); }} }} |