Vi vet det på kontorer, kjøpesentre og mange andre steder hvor bare personen med autorisasjonskort får komme inn i rommet. Disse systemene bruker RFID-kommunikasjonssystem. RFID brukes i kjøpesentre for å stoppe tyveri ettersom produktene er merket med RFID-brikke, og når en person forlater bygningen med RFID-brikken, slås en alarm automatisk. RFID-koden er designet så liten som en del av sand. RFID-autentiseringssystemene er enkle å designe og koster billig. Noen skoler og høyskoler bruker i dag RFID-baserte fremmøtesystemer.
I dette prosjektet skal vi designe en stemmeautomat som bare teller godkjente stemmer. Dette gjøres ved å bruke RFID-koder (Radio Frequency Identification). Her skal vi skrive et program for ATMEGA for å la bare autoriserte RFID-tagginnehavere stemme. (Sjekk også dette enkle valgmaskinprosjektet)
Komponenter kreves
Maskinvare: ATMEGA32, strømforsyning (5v), AVR-ISP PROGRAMMER, JHD_162ALCD (16x2LCD), 100uF kondensator (koblet over strømforsyning), knapp (fem stykker), 10KΩ motstand (fem deler), 100nF kondensator (fem deler), LED (to deler), EM-18 (RFID-lesermodul).
Programvare: Atmel studio 6.1, progisp eller flash magi.
Kretsdiagram og forklaring
I kretsen er PORTA på ATMEGA32 koblet til dataporten på LCD-skjermen. Her bør man huske å deaktivere JTAG-kommunikasjonen i PORTC til ATMEGA ved å endre sikringsbyte, hvis man ønsker å bruke PORTC som en vanlig kommunikasjonsport. I 16x2 LCD er det totalt 16 pinner hvis det er svart lys, hvis det ikke er noe bakgrunnslys, vil det være 14 pinner. Man kan drive eller la baklysetappene ligge. Nå i de 14 pinnene er det 8 datapinner (7-14 eller D0-D7), 2 strømforsyningspinner (1 & 2 eller VSS & VDD eller GND & + 5V), 3. pinne for kontrastkontroll (VEE-styrer hvor tykke tegnene skal være vist), 3 kontrollpinner (RS & RW & E)
I kretsen kan du observere at jeg bare har tatt to kontrollpinner, dette gir fleksibiliteten til bedre forståelse, kontrastbiten og LES / SKRIV brukes ikke ofte slik at de kan kortsluttes til bakken. Dette setter LCD i høyest kontrast og lesemodus. Vi trenger bare å kontrollere ENABLE- og RS-pinner for å sende tegn og data tilsvarende.
Tilkoblingene som gjøres for LCD er gitt nedenfor:
PIN1 eller VSS til bakken
PIN2 eller VDD eller VCC til + 5v strøm
PIN3 eller VEE til jord (gir maksimal kontrast best for en nybegynner)
PIN4 eller RS (Register Selection) til PD6 i uC
PIN5 eller RW (lese / skrive) til bakken (setter LCD i lesemodus letter kommunikasjonen for brukeren)
PIN6 eller E (Aktiver) til PD5 på uC
PIN7 eller D0 til PA0 av uC
PIN8 eller D1 til PA1 av uC
PIN9 eller D2 til PA2 av uC
PIN10 eller D3 til PA3 av uC
PIN11 eller D4 til PA4 av uC
PIN12 eller D5 til PA5 av uC
PIN13 eller D6 til PA6 av uC
PIN14 eller D7 til PA7 av uC
I kretsen kan du se at vi har brukt 8bit kommunikasjon (D0-D7). Dette er imidlertid ikke obligatorisk, og vi kan bruke 4-biters kommunikasjon (D4-D7), men med 4-bits kommunikasjonsprogram blir det litt komplisert, så jeg foretrakk 8-bits kommunikasjon.
Så fra bare observasjon av tabellen ovenfor kobler vi 10 pins LCD til kontrolleren der 8 pins er datapinner og 2 pins for kontroll.
Før vi går videre, må vi forstå seriekommunikasjonen. RFID-modulen sender her data til kontrolleren i serie. Den har annen kommunikasjonsmåte, men for enkel kommunikasjon velger vi RS232. RS232-pinnen på modulen er koblet til RXD-pinnen på ATMEGA.
Dataene som sendes av RFID-modulen går som:
Nå for RFID-modulgrensesnittet kreves følgende funksjoner:
1. RXD-pinnen (datamottaksfunksjonen) til kontrolleren må være aktivert.
2. Siden kommunikasjonen er seriell, må vi vite når data-bye mottas, slik at vi kan stoppe programmet til fullstendig byte er mottatt. Dette gjøres ved å aktivere datamottak fullstendig avbrudd.
3. RFID sender data til kontrolleren i 8bit-modus. Så to tegn vil bli sendt til kontrolleren om gangen. Dette er vist i figur 3
4. Fra figur 3 er det ingen paritetsbiter, en stoppbit i dataene som sendes av modulen.
Ovennevnte funksjoner er angitt i kontrollerregistrene; vi skal diskutere dem kort,
RØD (RXEN): Denne biten representerer mottaksdata-funksjonen, denne biten må være satt for at dataene fra modulen skal mottas av kontrolleren, det muliggjør også RXD-pin på kontrolleren.
BRUN (RXCIE): Denne biten må settes for å få et avbrudd etter vellykket datamottak. Ved å aktivere denne biten blir vi kjent med det, rett etter at 8 bit data mottas.
PINK (URSEL): Denne biten må settes før du aktiverer andre bits i UCSRC, etter at du har satt andre nødvendige bits i UCSRC; URSEL må deaktiveres eller settes til null.
GUL (UCSZ0, UCSZ1, UCSZ2): Disse tre bitene brukes til å velge antall databiter vi mottar eller sender på en gang.
Siden dataene som sendes av RFID-modulen er 8-bits datatype (FIGUR3), må vi sette UCSZ0, UCSZ1 til en og UCSZ2 til null.
ORANGE (UMSEL): Denne biten er satt ut fra om systemet kommuniserer asynkront (begge bruker annen klokke) eller synkront (begge bruker samme klokke),
Siden modul og kontroller bruker forskjellig klokke, må denne biten settes til null eller være alene, siden de alle er satt til null som standard.
GRØNN (UPM1, UPM0): Disse to bitene justeres basert på bitparitet vi bruker i kommunikasjon.
Siden RFID-modulen sender data uten paritet (FIGUR 3), har vi satt både UPM1, UPM0 til null, eller de kan være alene da alle biter i alle registre er satt til null som standard.
BLÅ (USBS): Denne biten brukes til å velge antall stoppbiter vi bruker under kommunikasjonen.
Siden RFID-modulen sender data med en stoppbit (figur 3), må vi bare la USBS-biten være alene.
Nå til slutt må vi sette overføringshastigheten, fra figur 3 er det klart at RFID-modulen sender data til kontrolleren med en overføringshastighet på 9600 bps (bits per sekund).
Baudhastigheten stilles inn i kontrolleren ved å velge riktig UBRRH,
UBRRH-verdien velges ved krysshenvisende baudrate og CPU-krystallfrekvens,
Så ved kryssreferanse blir UBRR-verdi sett på som '6', og så blir overføringshastigheten satt.
Det er fem knapper til stede her, fire for å øke kandidatenes stemmer og den femte for å tilbakestille kandidatenes stemmer til null. Kondensatorene som er tilstede her, er for å oppheve den hoppende effekten av knapper. Hvis de fjernes, kan kontrolleren telle mer enn én hver gang du trykker på knappen.
Motstandene som er koblet til pinner, er for å begrense strømmen når du trykker på knappen for å trekke ned pinnen til bakken. Hver gang du trykker på en knapp, blir den korresponderende kontrollpinnen trukket ned til bakken, og dermed gjenkjenner kontrolleren at det trykkes på en bestemt knapp og tilsvarende tiltak som skal utføres, det kan være å øke kandidatstemmene eller tilbakestille stemmer avhengig av hvilken knapp du trykker på.
Når du trykker på knappen som representerer en tilsvarende person, velger kontrolleren den og øker det tilsvarende personnummeret i minnet etter trinn, det viser de tilsvarende personene på 16x2 LCD-skjermen.
Arbeidet med stemmemaskin forklares best trinn for trinn av C-koden gitt nedenfor:
Kode Forklaring
#include // header for å aktivere datastrømskontroll over pins
#define F_CPU 1000000 // forteller kontrollerens krystallfrekvens festet
#inkludere
#define E 5 // gi navn “aktiver” til 5 th pin av PORTD, siden den er koblet til LCD aktivere pin
#define RS 6 // gi navnet “registerselection” til 6 th pin av PORTD, ettersom er forbundet med LCD-RS tapp
ugyldig send_a_command (usignert char-kommando);
ugyldig send_a_character (usignert char Character);
ugyldig send_a_string (char * string_of_characters);
int main (ugyldig)
{
DDRA = 0xFF; // sette porta som utgangspinner
DDRD = 0b11111110;
_forsink_ms (50); // gir forsinkelse på 50 ms
DDRB = 0b11110000; // Tar noen portB-pinner som inngang.
UCSRB - = (1 <
// aktivere data motta fullstendig avbryt, aktivere data motta pin
UCSRC - = (1 <
// endre andre biter ved først å sette URSEL, innstilling for 8-bits kommunikasjon
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // innstilling av overføringshastighet
int16_t VOTEA = 0; // person1 stemmer som lagrer minne
tegn A; // person1 stemmer som viser tegn på LCD
int16_t VOTEB = 0;; // person2 stemmer som lagrer minne
tegn B; // person2 stemmer som viser tegn på LCD
int16_t VOTEC = 0;; // person3 stemmer som lagrer minne
char C; // person3 stemmer som viser tegn på LCD
int16_t STEMMET = 0;; // person4 stemmer som lagrer minne
char D; / / person 4 stemmer som viser tegn på LCD
// Følgende inneholder ID for koder, disse må endres for forskjellige koder, Disse må oppdateres for at prosjektet skal fungere
// Etter å ha dumpet programmet i kontrolleren, må man ta kortene som må godkjennes og få tag-ID, disse oppnås ved å plassere koden nær RFID-modulen, og ID-en vil vises på skjermen. Etter å ha fått ID-ene, må programmet oppdateres ved å erstatte ID-numrene nedenfor med nye ID-nummer.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Nå ovenfor godkjenner vi bare fem kort, disse kan endres til hvilket som helst nummer, Tenk for eksempel på at standardprogrammet er dumpet i kontrolleren, få kortene som skal autoriseres plassere hverandre i nærheten av modulen, du vil få ID for hver som xxxxxxxx (907a4F87), Hvis det er 7 koder vi har, vil vi ha 7 åtte biters ID.
|
// nå for sju kort går det som // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)}; // tildeler minne for å vise ID sendt etter modul int i = 0; int stemme = 0; int k = 0; send_a_command (0x01); // Fjern skjerm 0x01 = 00000001 _forsink_ms (50); send_a_command (0x38); // forteller lcd at vi bruker 8bit kommando / datamodus _forsink_ms (50); send_a_command (0b00001111); // LCD SKJERM PÅ og courser blinker char MEM; // tildeler minne for å lagre fullstendig ID for taggen send_a_string ("RFID NUMBER"); // sendingstreng send_a_command (0x80 + 0x40 + 0); // flytter courser til andre linje mens (1) { mens (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR lagrer de mottatte åttebitsdataene og blir tatt med i et helt tall. MEM = COUNTA; // de to første tegnene oppdateres til minnet itoa (COUNTA, SHOWA, 16); // kommando for å sette variabeltall i LCD (variabelt tall, i hvilket tegn som skal erstattes, hvilken base er variabel (ti her som vi teller nummer i base10)) send_a_string (SHOWA); // ber skjermen om å vise tegn (erstattet av variabelt nummer) til andre person etter å ha plassert kurset på LCD mens (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // tredje og fjerde tegn oppdateres til minnet mens (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // femte og sjette tegn oppdateres til minnet mens (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // syvende og åtte tegn oppdateres til minnet send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
for (i = 0; i <5; i ++) { hvis ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// sjekke autorisasjonskjøp som sammenligner to tegn om gangen med tegnene i minnet PORTB - = (1 <
vote = 1; // hvis autorisert sett VOTE } } hvis (stemme == 0) // autorisasjon mislyktes hvis stemme ikke er satt { UCSRB - = (1 <
} mens (stemme == 1) // gjør denne sløyfen til den er stemt, hvis den er autorisert { send_a_command (0x80 + 0); // gå til posisjon null på linje 1 send_a_string ("STEM NÅ"); // viser streng hvis (bit_is_clear (PINB, 0)) // når du trykker på knapp en { VOTEA ++; // øke stemmeminnet til første person med en stemme = 0; // la mens løkken går etter avstemming } hvis (bit_is_clear (PINB, 1)) // når du trykker på knapp 2 { VOTEB ++; // øke stemmene minne på 2 nd person etter en stemme = 0; } hvis (bit_is_clear (PINB, 2)) // når du trykker på knapp 3 { VOTEC ++; // øk stemmeminnet til 3. person med en stemme = 0; } hvis (bit_is_clear (PINB, 3)) // når knapp 4 trykkes { KÅRET ++; // øke stemmene minne på 4 th person etter en stemme = 0; } hvis (stemme == 0) // fjernet etter mottatt stemme { send_a_command (0x80 + 0); // flytt til posisjon null på linje 1 send_a_string ("TAKK FOR VOTE"); // visningsstreng for (k = 0; k <10; k ++) { _forsink_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // viser stemmer for alle fire personer send_a_string ("A ="); send_a_command (0x80 + 2); itoa (VOTEA, A, 10); send_a_string (A); send_a_command (0x80 + 8); send_a_string ("B ="); send_a_command (0x80 + 10); itoa (VOTEB, B, 10); send_a_string (B); send_a_command (0x80 + 0x40 + 0); send_a_string ("C ="); send_a_command (0x80 + 0x40 + 2); itoa (VOTEC, C, 10); send_a_string (C); send_a_command (0x80 + 0x40 + 8); send_a_string ("D ="); send_a_command (0x80 + 0x40 + 10); itoa (STEMMET, D, 10); send_a_string (D); send_a_command (0x80 + 0x40 + 16); for (k = 0; k <25; k ++) { _forsink_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // flytter til nullposisjon send_a_string ("RFID NUMBER"); // send en streng send_a_command (0x80 + 0x40 + 0); } } ugyldig send_a_command (usignert char-kommando) { PORTA = kommando; PORTD & = ~ (1 <
PORTD - = 1 <
_forsink_ms (50); PORTD & = ~ 1 <
PORTA = 0; } ugyldig send_a_character (usignert tegn) { PORTA = karakter; PORTD - = 1 <
PORTD - = 1 <
_forsink_ms (50); PORTD & = ~ 1 <
PORTA = 0; } ugyldig send_a_string (char * string_of_characters) { mens (* string_of_characters> 0) { send_a_character (* string_of_characters ++); } } |