Știm în birouri, centre comerciale și în multe alte locuri unde numai persoana cu card de autorizare are voie să intre în cameră. Aceste sisteme utilizează un sistem de comunicații RFID. RFID este utilizat în centrele comerciale pentru a opri furtul, deoarece produsele sunt etichetate cu cip RFID și atunci când o persoană părăsește clădirea cu cipul RFID, se declanșează automat o alarmă. Eticheta RFID este concepută la fel de mică ca o parte a nisipului. Sistemele de autentificare RFID sunt ușor de proiectat și sunt ieftine. Unele școli și colegii folosesc în prezent sisteme de prezență bazate pe RFID.
În acest proiect vom proiecta o mașină de votare care să numere doar voturile autentificate. Acest lucru se face utilizând etichete RFID (Radio Frequency Identification). Aici vom scrie un program pentru ATMEGA pentru a permite doar deținătorilor autorizați de etichete RFID să voteze. (Verificați și acest proiect simplu de mașină de vot)
Componente necesare
Hardware: ATMEGA32, sursă de alimentare (5v), PROGRAMATOR AVR-ISP, JHD_162ALCD (16x2LCD), condensator 100uF (conectat la sursa de alimentare), buton (cinci bucăți), rezistor 10KΩ (cinci bucăți), condensator 100nF (cinci bucăți), LED (două bucăți), EM-18 (modul de citire RFID).
Software: Atmel studio 6.1, progisp sau flash magic.
Diagrama și explicația circuitului
În circuitul PORTA al ATMEGA32 este conectat la portul de date al LCD-ului. Aici ar trebui să vă amintiți să dezactivați comunicarea JTAG în PORTC în ATMEGA prin schimbarea octeților siguranței, dacă doriți să utilizați PORTC ca un port de comunicație normal. În ecranul LCD 16x2 există 16 pini în general dacă există o lumină neagră, dacă nu există lumină de fundal, vor exista 14 pini. Se poate alimenta sau lăsa pinii luminii din spate. Acum, în cele 14 pinii există 8 pini de date (7-14 sau D0-D7), 2 pini de alimentare (1 & 2 sau VSS & VDD sau gnd & + 5v), 3 rd pini pentru controlul contrastului (VEE-control cât de gros personajele ar trebui să fie afișat), 3 pini de control (RS & RW & E)
În circuit, puteți observa că am luat doar doi pini de control, ceea ce oferă flexibilitatea unei mai bune înțelegeri, bitul de contrast și CITIREA / SCRIEREA nu sunt utilizate adesea, astfel încât acestea pot fi scurtcircuitate la masă. Acest lucru pune LCD în cel mai mare contrast și modul de citire. Trebuie doar să controlăm ENABLE și pinii RS pentru a trimite caractere și date în consecință.
Conexiunile care se fac pentru LCD sunt date mai jos:
PIN1 sau VSS la masă
PIN2 sau VDD sau VCC la + 5v putere
PIN3 sau VEE la sol (oferă un contrast maxim optim pentru un începător)
PIN4 sau RS (Selectare înregistrare) la PD6 de uC
PIN5 sau RW (citire / scriere) la masă (pune LCD în modul de citire facilitează comunicarea pentru utilizator)
PIN6 sau E (Activare) la PD5 de uC
PIN7 sau D0 la PA0 de uC
PIN8 sau D1 la PA1 de uC
PIN9 sau D2 la PA2 de uC
PIN10 sau D3 până la PA3 de uC
PIN11 sau D4 la PA4 de uC
PIN12 sau D5 până la PA5 de uC
PIN13 sau D6 la PA6 de uC
PIN14 sau D7 la PA7 de uC
În circuit, puteți vedea că am folosit comunicația pe 8 biți (D0-D7). Cu toate acestea, acest lucru nu este obligatoriu și putem folosi comunicația pe 4 biți (D4-D7), dar programul de comunicare pe 4 biți devine puțin complex, așa că am preferat comunicarea pe 8 biți.
Deci, din simpla observare a tabelului de mai sus, conectăm 10 pini de LCD la controler în care 8 pini sunt pini de date și 2 pini pentru control.
Înainte de a merge mai departe, trebuie să înțelegem despre comunicarea în serie. Modulul RFID de aici trimite datele către controler în serie. Are un alt mod de comunicare, dar pentru o comunicare ușoară alegem RS232. Pinul RS232 al modulului este conectat la pinul RXD al ATMEGA.
Datele trimise de modulul RFID sunt:
Acum, pentru interfața modulului RFID, sunt necesare următoarele caracteristici:
1. Pinul RXD (caracteristică de primire a datelor) al controlerului trebuie activat.
2. Întrucât comunicarea este serială, trebuie să știm ori de câte ori sunt primite datele bye, astfel încât să putem opri programul până când este primit octetul complet. Acest lucru se realizează prin activarea unei întreruperi complete a datelor.
3. RFID trimite date către controler în modul 8 biți. Deci, două caractere vor fi trimise controlerului odată. Acest lucru este prezentat în blocul din figura 3
4. Din figura 3, nu există biți de paritate, un bit de oprire în datele trimise de modul.
Funcțiile de mai sus sunt setate în registrele controlerului; le vom discuta pe scurt,
ROȘU (RXEN): Acest bit reprezintă caracteristica de primire a datelor, acest bit trebuie setat pentru ca datele din modul să fie primite de către controler, de asemenea, activează pinul RXD al controlerului.
MARO (RXCIE): Acest bit trebuie setat pentru a obține o întrerupere după recepționarea cu succes a datelor. Activând acest bit, vom afla, imediat după primirea datelor pe 8 biți.
PINK (URSEL): Acest bit trebuie setat înainte de activarea altor biți în UCSRC, după setarea altor biți necesari în UCSRC; URSEL trebuie dezactivat sau pus la zero.
GALBEN (UCSZ0, UCSZ1, UCSZ2): Acești trei biți sunt utilizați pentru selectarea numărului de biți de date pe care îi primim sau îi trimitem într-o singură trecere.
Deoarece datele transmise de modulul RFID sunt de tip 8bit (FIGURA3), trebuie să setăm UCSZ0, UCSZ1 la unu și UCSZ2 la zero.
ORANGE (UMSEL): acest bit este setat pe baza faptului că sistemul comunică asincron (ambele folosesc ceas diferit) sau sincron (ambele utilizează același ceas),
Deoarece modulul și controlerul utilizează ceas diferit, acest bit trebuie setat la zero sau lăsat singur, deoarece toate sunt setate la zero în mod implicit.
VERZ (UPM1, UPM0): Acești doi biți sunt reglați pe baza parității de biți pe care o folosim în comunicare.
Deoarece modulul RFID trimite date fără paritate (FIGURA3), am setat ambele UPM1, UPM0 la zero sau pot fi lăsate singure, deoarece toți biții din orice registre sunt setați la zero în mod implicit.
ALBASTRU (USBS): Acest bit este utilizat pentru alegerea numărului de biți de oprire pe care îi folosim în timpul comunicării.
Deoarece modulul RFID trimite date cu un bit de oprire (figura 3), trebuie doar să lăsăm bitul USBS singur.
Acum, în sfârșit, trebuie să setăm rata de transmisie, din figura 3 este clar că modulul RFID trimite date către controler cu o viteză de transmisie de 9600bps (biți pe secundă).
Rata de transmisie este setată în controler prin alegerea UBRRH corespunzătoare,
Valoarea UBRRH este aleasă prin rata de transmisie încrucișată și frecvența cristalului CPU,
Deci, prin referință încrucișată, valoarea UBRR este văzută ca „6”, astfel încât rata baud este setată.
Există cinci butoane prezente aici, patru pentru creșterea voturilor candidaților și al cincilea este pentru restabilirea voturilor candidaților la zero. Condensatorii prezenți aici sunt pentru a anula efectul de săritură al butoanelor. Dacă sunt eliminate, controlerul poate conta mai mult de unul de fiecare dată când este apăsat butonul.
Rezistențele conectate pentru pini sunt pentru limitarea curentului, atunci când butonul este apăsat pentru a trage în jos pinul la pământ. Ori de câte ori este apăsat un buton, știftul corespunzător al controlerului este tras în jos și astfel controlerul recunoaște că este apăsat un anumit buton și acțiunea corespunzătoare care trebuie întreprinsă, poate crește voturile candidatului sau resetarea voturilor în funcție de butonul apăsat.
Când este apăsat butonul care reprezintă o persoană corespunzătoare, controlerul îl alege și mărește numărul de persoană corespunzător în memoria sa după incrementare afișează scorul persoanelor corespunzătoare pe afișajul LCD 16x2.
Funcționarea mașinii de vot este cel mai bine explicată pas cu pas din codul C dat mai jos:
Explicarea codului
#include // header pentru a permite controlul fluxului de date peste pini
#define F_CPU 1000000 // indicând frecvența cristalului controlerului atașată
#include
#define E 5 // da numele „permite“ 5 - lea PIN al PORTD, deoarece acesta este conectat la LCD permite PIN -
#define RS 6 // dând numele „registerselection” la al șaselea pin al PORTD, deoarece este conectat la pinul RS LCD
void send_a_command (comandă char nesemnată);
void send_a_character (caracter de caractere nesemnat);
void send_a_string (char * șir_de_caractere);
int main (nul)
{
DDRA = 0xFF; // punerea porta ca pini de ieșire
DDRD = 0b11111110;
_delay_ms (50); // oferind o întârziere de 50ms
DDRB = 0b11110000; // Luând niște pini portB ca intrare.
UCSRB - = (1 <
// activarea datelor primește întrerupere completă, activarea pinului pentru primirea datelor
UCSRC - = (1 <
// schimbarea altor biți prin prima setare URSEL, setare pentru comunicare pe 8 biți
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // setarea ratei de transmisie
int16_t VOTEA = 0; // persoana1 voturi stocând memoria
char A; // persoana1 voturi afișând caracterul pe LCD
int16_t VOTEB = 0;; // persoana2 voturi stocând memoria
char B; // person2 voturi afișând caracterul pe LCD
int16_t VOTEC = 0;; // persoană3 voturi stocând memoria
char C; // person3 voturi afișând caracterul pe LCD
int16_t VOTAT = 0;; // persoană4 voturi stocând memoria
char D; / / person 4 voturi afișând caracterul pe LCD
// Următorul conține ID-ul etichetelor, acestea trebuie modificate pentru diferite etichete, acestea trebuie actualizate pentru ca proiectul să funcționeze
// După ce ați aruncat programul în controler, trebuie să luați cardurile care trebuie autorizate și să obțineți ID-ul etichetelor, acestea sunt obținute prin plasarea etichetei lângă modulul RFID și ID-ul va fi afișat pe ecran. După obținerea ID-urilor, programul trebuie actualizat prin înlocuirea numerelor de identificare de mai jos cu numere de identificare noi.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Acum, mai sus, autorizăm doar cinci cărți, acestea pot fi schimbate cu orice număr, De exemplu, luați în considerare faptul că programul implicit este aruncat în controler, obțineți cardurile care ar trebui să fie autorizate așezați unul după altul lângă modul, veți primi ID-ul pentru fiecare dintre acestea ca xxxxxxxx (907a4F87)
Dacă avem 7 etichete pe care le avem, atunci vom avea 7 ID de 8 biți.
|
// acum pentru șapte cărți merge ca. // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // alocarea memoriei pentru afișarea ID-ului trimis prin modul int i = 0; vot int = 0; int k = 0; send_a_command (0x01); // Ștergeți ecranul 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // spunând lcd că folosim modul de comandă / date pe 8 biți _delay_ms (50); send_a_command (0b00001111); // LCD SCREEN ON și cursorul clipește char MEM; // alocarea memoriei pentru a stoca ID-ul complet al etichetei send_a_string ("NUMĂR RFID"); // string de trimitere send_a_command (0x80 + 0x40 + 0); // mutarea cursorului pe linia a doua în timp ce (1) { while (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR stochează datele primite pe opt biți și sunt luate într-un număr întreg. MEM = COUNTA; // primele două caractere sunt actualizate în memorie itoa (COUNTA, SHOWA, 16); // comanda pentru introducerea numărului variabil în LCD (număr variabil, în ce caracter trebuie înlocuit, care bază este variabilă (zece aici, deoarece numărăm numărul în baza10)) send_a_string (SHOWA); // spunând afișajului să afișeze caracterul (înlocuit cu numărul variabil) al persoanei a doua după poziționarea cursorului pe LCD while (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // al treilea și al patrulea caracter sunt actualizate în memorie while (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // al cincilea și al șaselea caracter sunt actualizate în memorie while (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // șaptea și opt caractere sunt actualizate în memorie send_a_string (""); send_a_comand (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
pentru (i = 0; i <5; i ++) { if ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// verificarea autorizației cumpără compararea a două caractere odată cu caracterele din memorie PORTB - = (1 <
vot = 1; // dacă este autorizat setați VOTĂ } } if (vot == 0) // autorizarea nu a reușit dacă votul nu este setat { UCSRB - = (1 <
} while (vot == 1) // faceți această buclă până la vot, dacă este autorizat { send_a_command (0x80 + 0); // mergeți la poziția zero pe linia1 send_a_string ("VOTĂ ACUM"); // afișarea șirului if (bit_is_clear (PINB, 0)) // când se apasă butonul unu { VOTEA ++; // creșteți memoria votului primei persoane cu una vot = 0; // lăsând în timp ce bucla să meargă după vot } if (bit_is_clear (PINB, 1)) // când este apăsat butonul 2 { VOTEB ++; // crește memoria votului celei de-a doua persoane cu una vot = 0; } if (bit_is_clear (PINB, 2)) // când este apăsat butonul 3 { VOTEC ++; // incrementa memoria vot de 3 rd persoana de unul vot = 0; } if (bit_is_clear (PINB, 3)) // când butonul 4 este apăsat { VOTAT ++; // incrementa memoria vot de 4 mii persoane de unul vot = 0; } if (vot == 0) // șters după votul primit { send_a_command (0x80 + 0); // mutați în poziția zero a liniei1 send_a_string ("MULTUMESC PENTRU VOT"); // afișează șirul pentru (k = 0; k <10; k ++) { _delay_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // afișarea voturilor tuturor celor patru persoane send_a_string ("A ="); send_a_comand (0x80 + 2); itoa (VOTEA, A, 10); send_a_string (A); send_a_comand (0x80 + 8); send_a_string ("B ="); send_a_comand (0x80 + 10); itoa (VOTEB, B, 10); send_a_string (B); send_a_comand (0x80 + 0x40 + 0); send_a_string ("C ="); send_a_comand (0x80 + 0x40 + 2); itoa (VOTEC, C, 10); send_a_string (C); send_a_comand (0x80 + 0x40 + 8); send_a_string ("D ="); send_a_comand (0x80 + 0x40 + 10); itoa (VOTAT, D, 10); send_a_string (D); send_a_comand (0x80 + 0x40 + 16); pentru (k = 0; k <25; k ++) { _delay_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // trecerea la poziția zero send_a_string ("NUMĂR RFID"); // trimite un șir send_a_comand (0x80 + 0x40 + 0); } } void send_a_command (comandă char nesemnată) { PORTA = comanda; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (caracter de caractere nesemnat) { PORTA = personaj; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { while (* șir_de_caractere> 0) { send_a_character (* șir_de_caractere ++); } } |