Sappiamo in uffici, centri commerciali e in molti altri luoghi dove solo la persona con carta di autorizzazione può entrare nella stanza. Questi sistemi utilizzano il sistema di comunicazione RFID. L'RFID viene utilizzato nei centri commerciali per fermare i furti poiché i prodotti sono contrassegnati con chip RFID e quando una persona lascia l'edificio con il chip RFID viene attivato automaticamente un allarme. Il tag RFID è progettato come piccolo come parte della sabbia. I sistemi di autenticazione RFID sono facili da progettare e hanno un costo contenuto. Alcune scuole e college oggigiorno utilizzano sistemi di frequenza basati su RFID.
In questo progetto progetteremo una macchina per il voto che conta solo voti autenticati. Questo viene fatto utilizzando tag RFID (Radio Frequency Identification). Qui scriveremo un programma per ATMEGA per consentire solo ai titolari di tag RFID autorizzati di votare. (Controlla anche questo semplice progetto di macchina per il voto)
Componenti richiesti
Hardware: ATMEGA32, alimentatore (5v), AVR-ISP PROGRAMMER, JHD_162ALCD (16x2LCD), condensatore 100uF (collegato all'alimentatore), pulsante (cinque pezzi), resistore 10KΩ (cinque pezzi), condensatore 100nF (cinque pezzi), LED (due pezzi), EM-18 (modulo lettore RFID).
Software: Atmel studio 6.1, progisp o flash magic.
Schema del circuito e spiegazione
Nel circuito PORTA di ATMEGA32 è collegato alla porta dati dell'LCD. Qui bisogna ricordarsi di disabilitare la comunicazione JTAG in PORTC ad ATMEGA cambiando i fuse bytes, se si vuole usare il PORTC come una normale porta di comunicazione. Nell'LCD 16x2 ci sono complessivamente 16 pin se c'è una luce nera, se non c'è retroilluminazione ci saranno 14 pin. Si può alimentare o lasciare i perni della retroilluminazione. Ora nei 14 pin ci sono 8 pin dati (7-14 o D0-D7), 2 pin di alimentazione (1 & 2 o VSS & VDD o gnd & + 5v), 3 ° pin per il controllo del contrasto (VEE-controlla quanto dovrebbero essere spessi i caratteri mostrato), 3 pin di controllo (RS & RW & E)
Nel circuito, puoi osservare che ho preso solo due pin di controllo, questo dà la flessibilità di una migliore comprensione, il bit di contrasto e READ / WRITE non sono usati spesso in modo che possano essere cortocircuitati a massa. Questo mette l'LCD nel più alto contrasto e modalità di lettura. Abbiamo solo bisogno di controllare i pin ENABLE e RS per inviare caratteri e dati di conseguenza.
Di seguito sono riportati i collegamenti effettuati per l'LCD:
PIN1 o VSS a terra
Alimentazione da PIN2 o VDD o VCC a + 5v
PIN3 o VEE a massa (offre il massimo contrasto migliore per un principiante)
PIN4 o RS (selezione registro) a PD6 di uC
PIN5 o RW (lettura / scrittura) a massa (mette l'LCD in modalità di lettura facilita la comunicazione per l'utente)
PIN6 o E (Abilita) a PD5 di uC
PIN7 o D0 a PA0 di uC
PIN8 o D1 a PA1 di uC
PIN9 o D2 a PA2 di uC
PIN10 o D3 a PA3 di uC
PIN11 o D4 a PA4 di uC
PIN12 o D5 a PA5 di uC
PIN13 o D6 a PA6 di uC
PIN14 o D7 a PA7 di uC
Nel circuito, puoi vedere che abbiamo usato la comunicazione a 8 bit (D0-D7). Tuttavia questo non è obbligatorio e possiamo usare la comunicazione a 4 bit (D4-D7) ma con il programma di comunicazione a 4 bit diventa un po 'complesso, quindi ho preferito la comunicazione a 8 bit.
Quindi dalla semplice osservazione della tabella sopra stiamo collegando 10 pin dell'LCD al controller in cui 8 pin sono pin dati e 2 pin per il controllo.
Prima di andare avanti, dobbiamo capire la comunicazione seriale. Il modulo RFID qui invia i dati al controller in seriale. Ha altre modalità di comunicazione ma per una facile comunicazione scegliamo RS232. Il pin RS232 del modulo è collegato al pin RXD di ATMEGA.
I dati inviati dal modulo RFID sono:
Ora per l'interfaccia del modulo RFID, sono necessarie le seguenti funzionalità:
1. Il pin RXD (funzione di ricezione dati) del controller deve essere abilitato.
2. Poiché la comunicazione è seriale, dobbiamo sapere ogni volta che viene ricevuto il bye dei dati, in modo da poter interrompere il programma fino alla ricezione del byte completo. Questo viene fatto abilitando un interrupt completo di ricezione dati.
3. RFID invia i dati al controller in modalità 8 bit. Quindi due caratteri verranno inviati al controller alla volta. Questo è mostrato nel blocco di figura 3
4. Dalla figura3 non ci sono bit di parità, un bit di stop nei dati inviati dal modulo.
Le funzionalità di cui sopra sono impostate nei registri del controller; li discuteremo brevemente,
ROSSO (RXEN): questo bit rappresenta la funzione di ricezione dei dati, questo bit deve essere impostato affinché i dati dal modulo siano ricevuti dal controller, abilita anche il pin RXD del controller.
MARRONE (RXCIE): questo bit deve essere impostato per ottenere un interrupt dopo la corretta ricezione dei dati. Abilitando questo bit si viene a sapere subito dopo la ricezione dei dati a 8 bit.
ROSA (URSEL): questo bit deve essere impostato prima di abilitare altri bit in UCSRC, dopo aver impostato altri bit necessari in UCSRC; URSEL deve essere disabilitato o messo a zero.
GIALLO (UCSZ0, UCSZ1, UCSZ2): questi tre bit vengono utilizzati per selezionare il numero di bit di dati che stiamo ricevendo o inviando in una sola volta.
Poiché i dati inviati dal modulo RFID sono di tipo a 8 bit (FIGURA3), dobbiamo impostare UCSZ0, UCSZ1 su uno e UCSZ2 su zero.
ARANCIONE (UMSEL): questo bit viene impostato in base al fatto che il sistema comunichi in modo asincrono (entrambi utilizzano un clock diverso) o in modo sincrono (entrambi utilizzano lo stesso clock),
Poiché il modulo e il controllore utilizzano un clock diverso, questo bit deve essere impostato su zero o lasciato solo poiché sono tutti impostati su zero per impostazione predefinita.
VERDE (UPM1, UPM0): questi due bit vengono regolati in base alla parità di bit che stiamo utilizzando nella comunicazione.
Poiché il modulo RFID invia dati senza parità (FIGURA3), abbiamo impostato sia UPM1 che UPM0 a zero oppure possono essere lasciati soli poiché tutti i bit in qualsiasi registro sono impostati su zero per impostazione predefinita.
BLU (USBS): questo bit viene utilizzato per scegliere il numero di bit di stop che stiamo utilizzando durante la comunicazione.
Poiché il modulo RFID invia i dati con un bit di stop (figura3), dobbiamo solo lasciare il bit USBS da solo.
Ora finalmente dobbiamo impostare il baud rate, dalla figura 3 è chiaro che il modulo RFID invia i dati al controller con un baud rate di 9600bps (bit per secondo).
La velocità di trasmissione viene impostata nel controller scegliendo l'UBRRH appropriato,
Il valore UBRRH viene scelto incrociato la velocità di trasmissione e la frequenza di cristallo della CPU,
Quindi, per riferimento incrociato, il valore UBRR viene visto come "6", quindi viene impostata la velocità di trasmissione.
Ci sono cinque pulsanti qui presenti, quattro per aumentare i voti dei candidati e il quinto per azzerare i voti dei candidati. I condensatori qui presenti servono ad annullare l'effetto di rimbalzo dei pulsanti. Se vengono rimossi, il controller potrebbe contare più di uno ogni volta che viene premuto il pulsante.
Le resistenze collegate per i pin servono per limitare la corrente, quando il pulsante viene premuto per abbassare il pin a terra. Ogni volta che si preme un pulsante, il pin corrispondente del controller viene abbassato a terra e quindi il controller riconosce che un determinato pulsante è stato premuto e l'azione corrispondente da intraprendere, potrebbe aumentare i voti candidati o reimpostare i voti a seconda del pulsante premuto.
Quando viene premuto il pulsante che rappresenta una persona corrispondente, il controller lo seleziona e incrementa il numero della persona corrispondente all'interno della sua memoria dopo l'incremento mostra il punteggio della persona corrispondente sul display LCD 16x2.
Il funzionamento della macchina per il voto è meglio spiegato passo dopo passo del codice C riportato di seguito:
Spiegazione del codice
#include // intestazione per abilitare il controllo del flusso di dati sui pin
#define F_CPU 1000000 // indica la frequenza di cristallo del controller collegata
#includere
#define E 5 // dando il nome "enable" al 5 ° pin di PORTD, poiché è collegato al pin di abilitazione LCD
#define RS 6 // dando il nome "selezione di registro" al 6 ° pin di PORTD, poiché è collegato al pin LCD RS
void send_a_command (comando char non firmato);
void send_a_character (carattere char non firmato);
void send_a_string (char * string_of_characters);
int main (void)
{
DDRA = 0xFF; // mettendo porta come pin di output
DDRD = 0b11111110;
_delay_ms (50); // fornisce un ritardo di 50 ms
DDRB = 0b11110000; // Prendendo alcuni pin della portaB come input.
UCSRB - = (1 <
// abilitazione dell'interruzione completa ricezione dati, abilitazione pin ricezione dati
UCSRC - = (1 <
// modifica di altri bit impostando prima URSEL, impostazione per la comunicazione a 8 bit
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // impostazione del baud rate
int16_t VOTEA = 0; // person1 voti che immagazzinano memoria
char A; // voti person1 che visualizzano il carattere sul display LCD
int16_t VOTEB = 0;; // voti person2 che immagazzinano memoria
char B; // voti person2 che visualizzano il carattere sul display LCD
int16_t VOTEC = 0;; // person3 voti che immagazzinano memoria
char C; // person3 voti che visualizzano il carattere sul display LCD
int16_t VOTED = 0;; // person4 voti che immagazzinano memoria
char D; / / person4 voti che visualizzano il carattere sul display LCD
// Quanto segue contiene l'ID dei tag, questi devono essere modificati per tag diversi, Questi devono essere aggiornati affinché il progetto funzioni
// Dopo aver scaricato il programma nel controller è necessario prendere le carte che devono essere autorizzate e ottenere l'ID dei tag, questi si ottengono posizionando il tag vicino al modulo RFID e l'ID verrà mostrato sullo schermo. Dopo aver ottenuto gli ID, il programma deve essere aggiornato sostituendo i seguenti numeri ID con nuovi numeri ID.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Ora sopra stiamo autorizzando solo cinque carte, queste possono essere modificate in qualsiasi numero, Ad esempio, considera che il programma predefinito è scaricato nel controller, prendi le schede che dovrebbero essere autorizzate posizionate una dopo l'altra vicino al modulo, otterrai l'ID per ciascuna come xxxxxxxx (907a4F87), Se ci sono 7 tag che abbiamo, avremo 7 ID a otto bit.
|
// ora per sette carte va come // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // assegnazione della memoria per mostrare l'ID inviato dal modulo int i = 0; voto int = 0; int k = 0; send_a_command (0x01); // Cancella schermo 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // dice a lcd che stiamo usando la modalità comando / dati a 8 bit _delay_ms (50); send_a_command (0b00001111); // LCD SCREEN ON e il cursore lampeggia char MEM; // assegnazione della memoria per memorizzare l'ID completo del tag send_a_string ("RFID NUMBER"); // invio stringa send_a_command (0x80 + 0x40 + 0); // sposta il cursore sulla seconda riga mentre (1) { mentre (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR memorizza i dati a otto bit ricevuti e viene considerato un numero intero. MEM = COUNTA; // i primi due caratteri vengono aggiornati in memoria itoa (COUNTA, SHOWA, 16); // comando per inserire un numero variabile in LCD (numero variabile, in quale carattere sostituire, quale base è variabile (dieci qui perché stiamo contando il numero in base10)) send_a_string (SHOWA); // dice al display di mostrare il carattere (sostituito da un numero variabile) della seconda persona dopo aver posizionato il cursore sull'LCD mentre (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // il terzo e il quarto carattere vengono aggiornati in memoria mentre (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // il quinto e il sesto carattere vengono aggiornati in memoria mentre (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // il settimo e gli otto caratteri vengono aggiornati in memoria send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
per (i = 0; i <5; i ++) { se ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// controllo dell'autorizzazione acquisto confrontando due caratteri alla volta con i caratteri in memoria PORTB - = (1 <
voto = 1; // se autorizzato imposta VOTE } } if (vote == 0) // autorizzazione fallita se il voto non è impostato { UCSRB - = (1 <
} while (vote == 1) // esegue questo ciclo finché non viene votato, se autorizzato { send_a_command (0x80 + 0); // va alla posizione zero sulla riga1 send_a_string ("VOTE NOW"); // visualizzazione della stringa if (bit_is_clear (PINB, 0)) // quando viene premuto il pulsante uno { VOTEA ++; // incrementa di uno la memoria dei voti della prima persona voto = 0; // lasciando andare il ciclo while dopo la votazione } if (bit_is_clear (PINB, 1)) // quando viene premuto il pulsante 2 { VOTEB ++; // incrementa la memoria voto del 2 ° persona da uno voto = 0; } if (bit_is_clear (PINB, 2)) // quando si preme il pulsante 3 { VOTEC ++; // incrementa di uno la memoria dei voti della terza persona voto = 0; } if (bit_is_clear (PINB, 3)) // quando si preme il pulsante 4 { VOTATO ++; // incrementa la memoria voto del 4 ° persona da uno voto = 0; } if (vote == 0) // cancellato dopo il voto ricevuto { send_a_command (0x80 + 0); // sposta alla posizione zero della riga1 send_a_string ("THANK U FOR VOTE"); // visualizza la stringa per (k = 0; k <10; k ++) { _delay_ms (220); } PORTB & = ~ (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // visualizzazione dei voti di tutte e quattro le persone 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 (VOTATO, D, 10); send_a_string (D); send_a_command (0x80 + 0x40 + 16); per (k = 0; k <25; k ++) { _delay_ms (220); } UCSRB - = (1 <
send_a_command (0x01); send_a_command (0x80 + 0); // spostarsi alla posizione zero send_a_string ("RFID NUMBER"); // invia una stringa send_a_command (0x80 + 0x40 + 0); } } void send_a_command (comando char non firmato) { PORTA = comando; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (carattere char non firmato) { PORTA = carattere; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { while (* string_of_characters> 0) { send_a_character (* string_of_characters ++); } } |