Sistema di riscossione dei pedaggi basato su RFID

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 un sistema di riscossione del pedaggio basato su RFID per motivi di sicurezza. Quindi questo sistema apre i cancelli e consente alle persone solo con i tag RFID autorizzati. Gli ID dei titolari di tag autorizzati sono programmati nel microcontrollore ATMEGA e solo questi titolari possono uscire o entrare nei locali.

Componenti richiesti

Hardware: microcontrollore ATmega32, alimentatore (5v), programmatore AVR-ISP, JHD_162ALCD (modulo LCD 16x2), condensatore da 100uF (collegato all'alimentatore), pulsante, resistenza da 10KΩ, condensatore da 100nF, LED (due pezzi), EM-18 (Modulo lettore RFID), IC driver motore L293D, motore 5V DC.

Software: Atmel studio 6.1, progisp o flash magic.

Schema del circuito e spiegazione del funzionamento

Nel circuito del sistema di riscossione del pedaggio RFID mostrato sopra, PORTA di ATMEGA32 è collegato alla porta dati dell'LCD. Qui dovremmo ricordarci di disabilitare la comunicazione JTAG in PORTC ad ATMEGA cambiando i fuse bytes, se vogliamo usare il PORTC come una normale porta di comunicazione. In 16x2 LCD, ci sono 16 pin in tutto se c'è una retroilluminazione, se non c'è retroilluminazione ci saranno 14 pin. Possiamo 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 lo spessore del devono essere visualizzati i caratteri), 3 pin di controllo (RS & RW & E).

Nel circuito, puoi osservare che ho preso solo due pin di controllo. Ciò offre la flessibilità di una migliore comprensione. Il bit di contrasto e READ / WRITE non sono usati spesso, quindi possono 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 che vengono effettuati per 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 dell'MCU

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 del microcontrollore

PIN7 o D0 a PA0

PIN8 o D1 a PA1

PIN9 o D2 a PA2

PIN10 o D3 a PA3

PIN11 o D4 a PA4

PIN12 o D5 a PA5

PIN13 o D6 a PA6

PIN14 o D7 a PA7

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 nella figura sopra.

4. Dalla figura sopra, 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 vengano ricevuti dal controllore. 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, 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 i dati senza parità, abbiamo impostato sia UPM1 che UPM0 su 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, dobbiamo solo lasciare il bit USBS da solo.

Ora finalmente dobbiamo impostare il baud rate, dalla figura sopra è 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 facendo riferimento alla velocità di trasmissione in baud e alla frequenza di cristallo della CPU, quindi dal riferimento incrociato il valore UBRR è visto come "6", quindi viene impostata la velocità di trasmissione.

Ora, come mostrato in figura, due pin dal controller vanno a L293D, che è un H-BRIDGE utilizzato per controllare la velocità e la direzione di rotazione per i motori CC a bassa potenza.

L293D è un CI H-BRIDGE progettato per pilotare motori CC a bassa potenza ed è mostrato in figura, questo CI è costituito da due ponti H e può quindi pilotare due motori CC. Quindi questo IC può essere utilizzato per guidare i motori dei robot dai segnali del microcontrollore.

Ora, come discusso prima, questo IC ha la capacità di cambiare la direzione di rotazione del motore CC. Ciò si ottiene controllando i livelli di tensione su INPUT1 e INPUT2.

Abilita Pin	Pin di ingresso 1	Pin di ingresso 2	Direzione del motore
Alto	Basso	Alto	Girare a destra
Alto	Alto	Basso	Gira a sinistra
Alto	Basso	Basso	Fermare
Alto	Alto	Alto	Fermare

Quindi, come mostrato nella tabella sopra, per la rotazione in senso orario 2A dovrebbe essere alto e 1A dovrebbe essere basso. Allo stesso modo per il senso antiorario 1A dovrebbe essere alto e 2A dovrebbe essere basso.

Ogni volta che una tessera autorizzata viene avvicinata al modulo, il motore è programmato per muoversi in senso orario per un secondo, per mostrare che il casello è aperto dopo un secondo che ritorna, segnalando che il casello è chiuso. Il funzionamento di Toll Plaza è meglio spiegato passo dopo passo nel codice C fornito di seguito.

Spiegazione della programmazione

Di seguito è riportata la spiegazione riga per riga del codice del sistema di riscossione dei pedaggi RFID. Puoi capire il concetto e il funzionamento di questo progetto leggendo il codice sottostante. Per scaricare o copiare, puoi trovare il codice completo in fondo alla pagina.

#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 // intestazione per abilitare la funzione di ritardo nel programma

#define E 5 // dare il nome "abilita" 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 <

UCSRC - = (1 <

UCSRC & = ~ (1 <

UBRRH & = ~ (1 <

UBRRL = 6; // impostazione della velocità di trasmissione // Quanto segue contiene gli 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, si consideri che il programma predefinito è scaricato nel controller, ottenere le schede che dovrebbero essere autorizzate. Metti uno dopo l'altro vicino al modulo, otterrai l'ID per ciascuno 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); // SCHERMO LCD ACCESO e cursore lampeggiante char MEM; // assegnazione della memoria per memorizzare l'ID completo del tag send_a_string ("RFID NUMBER"); // invio di 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)) {// verifica l'autorizzazione acquista confrontando due caratteri alla volta con i caratteri in memoria PORTB - = (1 < PORTB & = ~ (1 < _delay_ms (220); // ritardo _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 < } } 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 ++); } } Incorporato Scelta dell'editore Semplice circuito di trasmissione di potenza wireless per illuminare un led 2024 Gioco con timer di reazione con ic 555 2024 Interruttore della luce telecomandato 2024 Progettare un circuito sorgente di corrente controllato in tensione utilizzando op 2024 Come progettare un circuito stampato (con esempio PCB di circuito modulatore vocale) 2024 Porta di Xor 2024