Vi vet i kontor, köpcentra och på många andra platser där endast den som har behörighetskort får komma in i rummet. Dessa system använder RFID-kommunikationssystem. RFID används i köpcentra för att stoppa stöld då produkterna är märkta med RFID-chip och när en person lämnar byggnaden med RFID-chipet larmas automatiskt. RFID-taggen är utformad så liten som en del av sand. RFID-autentiseringssystemen är enkla att utforma och kostar billigt. Vissa skolor och högskolor använder numera RFID-baserade närvarosystem.
I detta projekt kommer vi att utforma ett RFID-baserat vägtullsystem för säkerhetsändamål. Så detta system öppnar grindar och tillåter endast personer med auktoriserade RFID-taggar. De auktoriserade ID-taggarna är programmerade i ATMEGA Microcontroller och endast de innehavarna får lämna eller komma in i lokalerna.
Komponenter krävs
Hårdvara: ATmega32 mikrokontroller, strömförsörjning (5v), AVR-ISP Programmerare, JHD_162ALCD (16x2 LCD-modul), 100uF kondensator (ansluten över strömförsörjning), knapp, 10KΩ motstånd, 100nF kondensator, LED (två delar), EM-18 (RFID-läsarmodul), L293D-motorförare IC, 5V DC-motor.
Programvara: Atmel studio 6.1, progisp eller flash magi.
Kretsschema och arbetsförklaring
I RFID-vägtullsystemskretsen som visas ovan är PORTA på ATMEGA32 ansluten till dataporten på LCD-skärmen. Här bör vi komma ihåg att inaktivera JTAG-kommunikationen i PORTC till ATMEGA genom att ändra säkringsbyten, om vi vill använda PORTC som en vanlig kommunikationsport. I 16x2 LCD finns det 16 stift överallt om det finns en bakgrundsbelysning, om det inte finns något bakgrundsbelysning kommer det att finnas 14 stift. Vi kan driva eller lämna bakljusstiften. Nu i de 14 stiften finns 8 datastift (7-14 eller D0-D7), 2 effektmatningsstiften (1 & 2 eller VSS & VDD eller GND & + 5v), 3 : e stift för kontrastkontroll (VEE-kontroller hur tjock tecken ska visas), 3 kontrollstift (RS & RW & E).
I kretsen kan du se att jag bara har tagit två kontrollstift. Detta ger flexibiliteten för bättre förståelse. Kontrastbiten och LÄS / SKRIV inte ofta så att de kan kortslutas till marken. Detta sätter LCD i högsta kontrast och läsläge. Vi behöver bara kontrollera ENABLE- och RS-stift för att skicka tecken och data i enlighet därmed.
Anslutningarna som är gjorda för LCD ges nedan:
PIN1 eller VSS till jord
PIN2 eller VDD eller VCC till + 5v ström
PIN3 eller VEE till marken (ger maximal kontrast bäst för en nybörjare)
PIN4 eller RS (Registrera val) till PD6 i MCU
PIN5 eller RW (läs / skriv) till marken (sätter LCD i läsläge underlättar kommunikationen för användaren)
PIN6 eller E (Enable) till PD5 i Microcontroller
PIN7 eller D0 till PA0
PIN8 eller D1 till PA1
PIN9 eller D2 till PA2
PIN10 eller D3 till PA3
PIN11 eller D4 till PA4
PIN12 eller D5 till PA5
PIN13 eller D6 till PA6
PIN14 eller D7 till PA7
I kretsen kan du se att vi har använt 8-bitars kommunikation (D0-D7). Detta är dock inte obligatoriskt och vi kan använda 4-bitars kommunikation (D4-D7) men med 4-bitars kommunikation blir programmet lite komplext, så jag föredrog 8-bitars kommunikation.
Så från enbart observationen av ovanstående tabell ansluter vi 10 stift LCD till styrenheten där 8 stift är datapinnar och 2 stift för kontroll.
Innan vi går vidare måste vi förstå seriekommunikationen. RFID-modulen skickar här data till styrenheten i serie. Den har ett annat kommunikationssätt men för enkel kommunikation väljer vi RS232. RS232-stiftet på modulen är ansluten till RXD-stiftet i ATMEGA.
Data som skickas av RFID-modulen går som:
För RFID-modulgränssnittet krävs nu följande funktioner:
1. Styrenhetens RXD-stift (datamottagningsfunktion) måste vara aktiverad.
2. Eftersom kommunikationen är seriell måste vi veta när data bye tas emot, så att vi kan stoppa programmet tills fullständig byte tas emot. Detta görs genom att möjliggöra en fullständig avbrott för datamottagning.
3. RFID skickar data till styrenheten i 8bit-läge. Så två tecken kommer att skickas till styrenheten åt gången. Detta visas i figuren ovan.
4. Från figuren ovan finns inga paritetsbitar, en stoppbit i data som skickas av modulen.
Ovanstående funktioner ställs in i registerregistret; vi ska diskutera dem kort,
RÖD (RXEN): Denna bit representerar funktionen för mottagningsdata. Denna bit måste ställas in för att data från modulen ska tas emot av styrenheten. Det möjliggör också RXD-stift av styrenhet.
BRUN (RXCIE): Denna bit måste ställas in för att få ett avbrott efter lyckad datamottagning. Genom att aktivera den här biten lär vi oss, direkt efter att 8-bitars data har mottagits.
PINK (URSEL): Denna bit måste ställas in innan du aktiverar andra bitar i UCSRC. Efter inställningen måste andra bitar som behövs i UCSRC, URSEL inaktiveras eller sättas till noll.
GUL (UCSZ0, UCSZ1, UCSZ2): Dessa tre bitar används för att välja antalet databitar vi tar emot eller skickar på en gång.
Eftersom data som skickas av RFID-modulen är 8bit-datatyp, måste vi ställa UCSZ0, UCSZ1 till en och UCSZ2 till noll.
ORANGE (UMSEL): Denna bit ställs in baserat på om systemet kommunicerar asynkront (båda använder olika klockor) eller synkront (båda använder samma klocka).
Eftersom modul och styrenhet använder olika klockor måste denna bit ställas till noll eller lämnas ensam eftersom de alla är inställda på noll som standard.
GRÖN (UPM1, UPM0): Dessa två bitar justeras baserat på bitparitet som vi använder i kommunikationen.
Eftersom RFID-modulen skickar data utan paritet har vi satt både UPM1, UPM0 till noll eller så kan de lämnas ensamma eftersom alla bitar i alla register är som standard noll.
BLÅ (USBS): Denna bit används för att välja antalet stoppbitar vi använder under kommunikationen.
Eftersom RFID-modulen skickar data med en stoppbit måste vi bara lämna USBS-biten i fred.
Nu måste vi äntligen ställa in överföringshastigheten, från figuren ovan är det tydligt att RFID-modulen skickar data till styrenheten med en överföringshastighet på 9600 bps (bitar per sekund).
Överföringshastigheten ställs in i styrenheten genom att välja lämplig UBRRH.
UBRRH-värdet väljs genom korshänvisande baudhastighet och CPU-kristallfrekvens, så genom korsreferens ses UBRR-värdet som '6', och så ställs baudhastigheten in.
Som visas i figuren går två stift från styrenheten till L293D, som är en H-BRIDGE som används för att styra hastighet och rotationsriktning för DC-motorer med låg effekt.
L293D är en H-BRIDGE IC konstruerad för att driva likströmsmotorer med låg effekt och visas i figur, denna IC består av två h-broar och så att den kan driva två likströmsmotorer. Så denna IC kan användas för att driva robotmotorer från signalerna från mikrokontroller.
Nu som diskuterats tidigare har denna IC förmåga att ändra DC-motorns rotationsriktning. Detta uppnås genom att kontrollera spänningsnivåerna vid INPUT1 och INPUT2.
|
Aktivera stift |
Ingångsstift 1 |
Ingångsstift 2 |
Motorriktning |
|
Hög |
Låg |
Hög |
Sväng höger |
|
Hög |
Hög |
Låg |
Sväng vänster |
|
Hög |
Låg |
Låg |
Sluta |
|
Hög |
Hög |
Hög |
Sluta |
Så som visas i tabellen ovan borde rotation med 2A vara hög och 1A vara låg. På samma sätt för moturs bör 1A vara hög och 2A vara låg.
Varje gång ett auktoriserat kort kommer nära modulen är motorn programmerad att röra sig medurs i en sekund för att visa att avgiftsgrinden öppnas efter en sekund den kommer tillbaka och säger att avgiftsgrinden är stängd. Arbetet med vägtullar förklaras bäst steg för steg av C-koden nedan.
Programmeringsförklaring
Nedan följer en rad till rad-förklaring för koden för RFID Toll Collection System. Du kan förstå konceptet och arbetet med detta projekt genom att läsa koden nedan. För att ladda ner eller kopiera hittar du hela koden längst ner på sidan.
#include // header för att aktivera dataflödeskontroll över stift
#define F_CPU 1000000 // berättar styrenhetens kristallfrekvens
#omfatta
#define E 5 // ger namnet "aktivera" till 5: e stift PORTD, eftersom den är ansluten till LCD-aktiveringsstift
#define RS 6 // ger namnet "registerval" till 6: e stift PORTD, eftersom den är ansluten till LCD RS-stift
ogiltig send_a_command (osignerad char kommando);
ogiltig send_a_character (osignerad char karaktär);
ogiltig send_a_string (char * string_of_characters);
int main (void)
{
DDRA = 0xFF; // sätta porta som utgångsstift
DDRD = 0b11111110;
_delay_ms (50); // ger fördröjning på 50 ms
DDRB = 0b11110000; // Ta några portB-stift som ingång.
UCSRB - = (1 <
UCSRC - = (1 <
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // ställa in överföringshastighet // Följande innehåller ID för taggar, dessa måste ändras för olika taggar, Dessa måste uppdateras för att projektet ska fungera
/ * Efter att ha dumpat programmet i styrenheten måste man ta korten som måste vara auktoriserade och få taggar-ID. Dessa erhålls genom att placera taggen nära RFID-modulen och ID kommer att visas på skärmen. Efter att ha fått ID: n måste programmet uppdateras genom att ersätta nedanstående ID-nummer med nya ID-nummer.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Nu ovan ovan godkänner vi bara fem kort, dessa kan ändras till valfritt nummer.
Tänk till exempel att standardprogrammet dumpas i styrenheten, få de kort som ska godkännas. Placera efter varandra nära modul så får du ID för var och en som xxxxxxxx (907a4F87), Om det finns 7 taggar vi har, kommer vi att ha 7 åtta bitars ID. * /
|
// nu för sju kort går det som // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // tilldela minne för att visa ID skickat per modul int i = 0; int-omröstning = 0; int k = 0; send_a_command (0x01); // Rensa skärm 0x01 = 00000001 _fördröjning_ms (50); send_a_command (0x38); // berättar för lcd att vi använder 8bit kommando / dataläge _fördröjning_ms (50); send_a_command (0b00001111); // LCD-SKÄRM PÅ och courser blinkar char MEM; // tilldela minne för att lagra komplett ID för taggen send_a_string ("RFID NUMBER"); // skickar sträng send_a_command (0x80 + 0x40 + 0); // flytta courser till andra raden medan (1) { medan (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR lagrar de mottagna åtta bitars data och tas in i ett heltal. MEM = COUNTA; // de första två tecknen uppdateras till minnet itoa (COUNTA, SHOWA, 16); // kommando för att sätta variabelt nummer i LCD (variabelt nummer, i vilket tecken som ska ersättas, vilken bas är variabel (tio här när vi räknar nummer i base10)) send_a_string (SHOWA); // ber displayen att visa karaktär (ersatt med variabelt nummer) för den andra personen efter att ha placerat kursledaren på LCD-skärmen medan (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // tredje och fjärde tecknet uppdateras till minnet medan (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // femte och sjätte tecken uppdateras till minnet medan (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // sjunde och åtta tecken uppdateras till minnet send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
för (i = 0; i <5; i ++) { om ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// kontroll av auktoriseringsköp som jämför två tecken i taget med tecknen i minnet PORTB - = (1 <
PORTB & = ~ (1 <
_fördröjning_ms (220); // fördröjning _fördröja_ms (220); _fördröja_ms (220); _fördröja_ms (220); _fördröja_ms (220); _fördröja_ms (220); PORTB - = (1 <
PORTB & = ~ (1 <
_fördröja_ms (220); _fördröja_ms (220); _fördröja_ms (220); _fördröja_ms (220); _fördröja_ms (220); _fördröja_ms (220); PORTB & = ~ (1 <
PORTB - = (1 <
} } UCSRB - = (1 <
} } ogiltigt send_a_command (osignerat char-kommando) { PORTA = kommando; PORTD & = ~ (1 <
PORTD - = 1 <
_fördröjning_ms (50); PORTD & = ~ 1 <
PORTA = 0; } ogiltig send_a_character (osignerad karaktär) { PORTA = karaktär; PORTD - = 1 <
PORTD - = 1 <
_fördröjning_ms (50); PORTD & = ~ 1 <
PORTA = 0; } ogiltig send_a_string (char * string_of_characters) { medan (* string_of_characters> 0) { send_a_character (* string_of_characters ++); } } |