We weten in kantoren, winkelcentra en op veel andere plaatsen waar alleen de persoon met autorisatiekaart de kamer mag betreden. Deze systemen maken gebruik van een RFID-communicatiesysteem. RFID wordt in winkelcentra gebruikt om diefstal te stoppen, aangezien de producten zijn voorzien van een RFID-chip en wanneer een persoon het gebouw verlaat met de RFID-chip, gaat er automatisch een alarm af. De RFID-tag is zo klein ontworpen als een deel van zand. De RFID-authenticatiesystemen zijn eenvoudig te ontwerpen en goedkoop in prijs. Sommige scholen en hogescholen gebruiken tegenwoordig op RFID gebaseerde aanwezigheidssystemen.
In dit project gaan we voor veiligheidsdoeleinden een op RFID gebaseerd tolheffingssysteem ontwerpen. Dus dit systeem opent poorten en laat alleen mensen toe met de geautoriseerde RFID-tags. De ID's van de geautoriseerde taghouder zijn in de ATMEGA Microcontroller geprogrammeerd en alleen die houders mogen het pand verlaten of betreden.
Componenten vereist
Hardware: ATmega32 microcontroller, voeding (5v), AVR-ISP Programmer, JHD_162ALCD (16x2 LCD-module), 100uF condensator (aangesloten over voeding), knop, 10KΩ weerstand, 100nF condensator, LED (twee stuks), EM-18 (RFID-leesmodule), L293D-motorstuurprogramma-IC, 5V DC-motor.
Software: Atmel studio 6.1, progisp of flash magie.
Schakelschema en werkuitleg
In het hierboven getoonde circuit van het RFID-tolheffingssysteem is PORTA van ATMEGA32 verbonden met datapoort van LCD. Hier moeten we onthouden om de JTAG-communicatie in PORTC naar ATMEGA uit te schakelen door de zekeringbytes te wijzigen, als we de PORTC als een normale communicatiepoort willen gebruiken. In een 16x2 LCD-scherm zijn er in totaal 16 pinnen als er een achtergrondverlichting is, als er geen achtergrondverlichting is, zijn er 14 pinnen. We kunnen de achterlichtpinnen van stroom voorzien of laten. Nu zijn er in de 14 pinnen 8 datapinnen (7-14 of D0-D7), 2 voedingspinnen (1 & 2 of VSS & VDD of gnd & + 5v), 3 e pin voor contrastregeling (VEE-regelt hoe dik de tekens moeten worden weergegeven), 3 controlepennen (RS & RW & E).
In het circuit kun je zien dat ik maar twee controlepennen heb genomen. Dit geeft de flexibiliteit van een beter begrip. Het contrastbit en READ / WRITE worden niet vaak gebruikt, zodat ze kunnen worden kortgesloten naar aarde. Dit plaatst LCD in het hoogste contrast en leesmodus. We hoeven alleen de ENABLE- en RS-pinnen te bedienen om tekens en gegevens dienovereenkomstig te verzenden.
De aansluitingen die zijn gemaakt voor LCD, worden hieronder weergegeven:
PIN1 of VSS naar aarde
PIN2 of VDD of VCC tot + 5v vermogen
PIN3 of VEE naar aarde (geeft maximaal contrast het beste voor een beginner)
PIN4 of RS (registerselectie) naar PD6 van MCU
PIN5 of RW (lezen / schrijven) naar aarde (zet LCD in leesmodus vereenvoudigt de communicatie voor de gebruiker)
PIN6 of E (inschakelen) naar PD5 van Microcontroller
PIN7 of D0 tot PA0
PIN8 of D1 naar PA1
PIN9 of D2 naar PA2
PIN10 of D3 naar PA3
PIN11 of D4 naar PA4
PIN12 of D5 naar PA5
PIN13 of D6 naar PA6
PIN14 of D7 naar PA7
In het circuit kun je zien dat we 8bit-communicatie hebben gebruikt (D0-D7). Dit is echter niet verplicht en we kunnen 4-bits communicatie gebruiken (D4-D7) maar met 4-bits communicatie wordt het programma een beetje ingewikkeld, dus ik gaf de voorkeur aan 8-bits communicatie.
Dus door alleen de bovenstaande tabel te observeren, verbinden we 10 pinnen van het LCD-scherm met de controller waarin 8 pinnen datapinnen zijn en 2 pinnen voor controle.
Voordat we verder gaan, moeten we de seriële communicatie begrijpen. De RFID-module stuurt hier gegevens in serie naar de controller. Het heeft een andere communicatiemodus, maar voor gemakkelijke communicatie kiezen we RS232. De RS232-pin van de module is verbonden met de RXD-pin van ATMEGA.
De gegevens die door de RFID-module worden verzonden, zijn:
Nu zijn voor de RFID-module-interface de volgende functies vereist:
1. De RXD-pin (gegevensontvangstfunctie) van de controller moet ingeschakeld zijn.
2. Aangezien de communicatie serieel is, moeten we weten wanneer de data bye is ontvangen, zodat we het programma kunnen stoppen totdat de volledige byte is ontvangen. Dit wordt gedaan door een volledige onderbreking van de gegevensontvangst mogelijk te maken.
3. RFID stuurt gegevens naar de controller in 8-bits modus. Er worden dus twee karakters tegelijk naar de controller gestuurd. Dit wordt getoond in bovenstaande figuur.
4. In bovenstaande figuur zijn er geen pariteitsbits, één stopbit in de gegevens die door de module worden verzonden.
De bovenstaande functies zijn ingesteld in de registers van de controller; we gaan ze kort bespreken,
ROOD (RXEN): Deze bit vertegenwoordigt de functie voor het ontvangen van gegevens. Dit bit moet worden ingesteld om de gegevens van de module te ontvangen door de controller. Het maakt ook de RXD-pin van de controller mogelijk.
BRUIN (RXCIE): Deze bit moet worden ingesteld om een interrupt te krijgen na succesvolle gegevensontvangst. Door dit bit in te schakelen, leren we het kennen, direct nadat 8 bit data is ontvangen.
PINK (URSEL): deze bit moet worden ingesteld voordat andere bits in UCSRC worden ingeschakeld. Na het instellen van andere benodigde bits in UCSRC, moet URSEL worden uitgeschakeld of op nul worden gezet.
GEEL (UCSZ0, UCSZ1, UCSZ2): deze drie bits worden gebruikt voor het selecteren van het aantal databits dat we in één keer ontvangen of verzenden.
Aangezien de gegevens die door de RFID-module worden verzonden, een 8-bits gegevenstype zijn, moeten we UCSZ0, UCSZ1 op één en UCSZ2 op nul zetten.
ORANJE (UMSEL): Deze bit wordt ingesteld op basis van of het systeem asynchroon communiceert (beide gebruiken een andere klok) of synchroon (beide gebruiken dezelfde klok).
Aangezien de module en de controller verschillende klokken gebruiken, moet deze bit op nul worden gezet of alleen gelaten worden, aangezien ze allemaal standaard op nul zijn ingesteld.
GROEN (UPM1, UPM0): deze twee bits worden aangepast op basis van bitpariteit die we in communicatie gebruiken.
Omdat de RFID-module gegevens zonder pariteit verzendt, hebben we zowel UPM1 als UPM0 op nul gezet of ze kunnen met rust worden gelaten, aangezien alle bits in alle registers standaard op nul zijn ingesteld.
BLAUW (USBS): Deze bit wordt gebruikt om het aantal stopbits te kiezen dat we gebruiken tijdens communicatie.
Omdat de RFID-module gegevens met één stopbit verzendt, hoeven we de USBS-bit alleen te laten.
Nu moeten we eindelijk de baudrate instellen, uit bovenstaande figuur is duidelijk dat de RFID-module gegevens naar de controller stuurt met een baudrate van 9600bps (bits per seconde).
De baudrate wordt in de controller ingesteld door de juiste UBRRH te kiezen.
De UBRRH-waarde wordt gekozen door de baudrate en de CPU-kristalfrequentie te kruisverwijzen, dus door de kruisverwijzing wordt de UBRR-waarde gezien als '6', en dus wordt de baudrate ingesteld.
Zoals weergegeven in de afbeelding, gaan twee pinnen van de controller naar L293D, een H-BRIDGE die wordt gebruikt om de snelheid en draairichting van DC-motoren met laag vermogen te regelen.
L293D is een H-BRIDGE-IC ontworpen voor het aandrijven van DC-motoren met laag vermogen en wordt weergegeven in de afbeelding, dit IC bestaat uit twee H-bruggen en kan dus twee DC-motoren aandrijven. Dit IC kan dus worden gebruikt om robotmotoren aan te sturen op basis van de signalen van een microcontroller.
Zoals eerder besproken, heeft dit IC de mogelijkheid om de draairichting van de DC-motor te veranderen. Dit wordt bereikt door de spanningsniveaus op INPUT1 en INPUT2 te regelen.
|
Pin inschakelen |
Invoerpen 1 |
Invoerpin 2 |
Motor richting |
|
Hoog |
Laag |
Hoog |
Rechts afslaan |
|
Hoog |
Hoog |
Laag |
Sla linksaf |
|
Hoog |
Laag |
Laag |
Hou op |
|
Hoog |
Hoog |
Hoog |
Hou op |
Zoals weergegeven in bovenstaande tabel, moet voor rotatie met de klok mee 2A hoog zijn en 1A laag. Evenzo moet voor linksom 1A hoog zijn en 2A laag.
Elke keer dat een geautoriseerde kaart in de buurt van de module wordt gebracht, wordt de motor geprogrammeerd om een seconde met de klok mee te bewegen, om aan te geven dat het tolpoortje na een seconde wordt geopend en terugkomt om aan te geven dat het tolpoortje gesloten is. De werking van tolplein kan het beste worden uitgelegd in de onderstaande C-code.
Uitleg over programmeren
Hieronder vindt u de regel voor regel uitleg voor de code van het RFID-tolheffingssysteem. U kunt het concept en de werking van dit project begrijpen door de onderstaande code te lezen. Om te downloaden of te kopiëren, vindt u de volledige code onderaan de pagina.
#include // header om gegevensstroomcontrole over pinnen in te schakelen
#define F_CPU 1000000 // vertellen kristalfrequentie van controller aangesloten
# omvatten
#define E 5 // het geven van de naam “enable” om 5 th pin van PORTD, want het is aangesloten op LCD in te schakelen pin
#define RS 6 // het geven van de naam “registerselection” tot 6 th pin van PORTD, want het is verbonden met LCD RS pin
void send_a_command (niet-ondertekende tekenopdracht);
void send_a_character (teken zonder teken);
ongeldig send_a_string (char * string_of_characters);
int main (ongeldig)
{
DDRA = 0xFF; // porta als output pinnen zetten
DDRD = 0b11111110;
_delay_ms (50); // geeft een vertraging van 50 ms
DDRB = 0b11110000; // Enkele portB-pinnen als invoer gebruiken.
UCSRB - = (1 <
UCSRC - = (1 <
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // instellen van de baudrate // Het volgende bevat ID van tags, deze moeten worden gewijzigd voor verschillende tags, Deze moeten worden bijgewerkt om het project te laten werken
/ * Na het dumpen van het programma in de controller moet men de kaarten nemen die geautoriseerd moeten zijn en de tag-ID krijgen. Deze worden verkregen door de tag naast de RFID-module te plaatsen en de ID wordt op het scherm getoond. Nadat u de ID's hebt ontvangen, moet het programma worden bijgewerkt door de onderstaande ID-nummers te vervangen door nieuwe ID-nummers.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Nu hierboven autoriseren we slechts vijf kaarten, deze kunnen in elk nummer worden gewijzigd.
Overweeg bijvoorbeeld dat het standaardprogramma in de controller wordt gedumpt, haal de kaarten op die moeten worden geautoriseerd. Plaats de een na de ander in de buurt van de module, u krijgt de ID voor elk als xxxxxxxx (907a4F87), Als we 7 tags hebben, hebben we 7 8 bit ID's. * /
|
// nu voor zeven kaarten gaat het als // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // geheugen toewijzen voor het tonen van de ID die per module is verzonden int i = 0; int stem = 0; int k = 0; send_a_command (0x01); // Scherm wissen 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // LCD vertellen dat we de 8-bits commando / gegevensmodus gebruiken _delay_ms (50); send_a_command (0b00001111); // LCD-SCHERM AAN en knipperend char MEM; // geheugen toewijzen om de volledige ID van de tag op te slaan send_a_string ("RFID NUMBER"); // verzendende string send_a_command (0x80 + 0x40 + 0); // verhuizen naar tweede lijn terwijl (1) { terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR slaat de ontvangen acht bits gegevens op en wordt omgezet in een geheel getal. MEM = COUNTA; // De eerste twee tekens worden in het geheugen bijgewerkt itoa (COUNTA, SHOWA, 16); // commando voor het plaatsen van variabel nummer in LCD (variabel nummer, in welk teken te vervangen, welke basis is variabel (tien hier omdat we het aantal tellen in basis10)) send_a_string (SHOWA); // het display vertellen om het karakter (vervangen door variabel nummer) van de tweede persoon weer te geven na het positioneren van de courser op het LCD-scherm terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // derde en vierde tekens worden in het geheugen bijgewerkt terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // vijfde en zesde lettertekens worden in het geheugen bijgewerkt terwijl (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // zevende en acht tekens worden in het geheugen bijgewerkt send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
voor (i = 0; i <5; i ++) { if ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// controleren op autorisatie kopen door twee karakters tegelijk te vergelijken met de karakters in het geheugen PORTB - = (1 <
PORTB & = ~ (1 <
_delay_ms (220); // vertraging _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); PORTB - = (1 <
PORTB & = ~ (1 <
_delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); _delay_ms (220); PORTB & = ~ (1 <
PORTB - = (1 <
} } UCSRB - = (1 <
} } ongeldig send_a_command (niet-ondertekende tekenopdracht) { PORTA = commando; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (teken zonder teken) { PORTA = teken; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { while (* tekenreeks_tekens> 0) { send_a_character (* string_of_characters ++); } } |