Sabemos em escritórios, shoppings e em muitos outros locais onde apenas a pessoa com cartão de autorização pode entrar na sala. Esses sistemas usam sistema de comunicação RFID. RFID é usado em shoppings para impedir roubos, pois os produtos são etiquetados com chip RFID e quando uma pessoa sai do prédio com o chip RFID um alarme é acionado automaticamente. A etiqueta RFID é projetada tão pequena quanto parte da areia. Os sistemas de autenticação RFID são fáceis de projetar e baratos. Algumas escolas e faculdades hoje em dia usam sistemas de atendimento baseados em RFID.
Neste projeto, vamos projetar um sistema de cobrança de pedágio baseado em RFID para fins de segurança. Portanto, este sistema abre portões e permite pessoas apenas com as etiquetas RFID autorizadas. As identificações autorizadas de detentores de tags são programadas no microcontrolador ATMEGA e apenas esses detentores estão autorizados a sair ou entrar nas instalações.
Componentes necessários
Hardware: microcontrolador ATmega32, fonte de alimentação (5v), programador AVR-ISP, JHD_162ALCD (módulo LCD 16x2), capacitor 100uF (conectado à fonte de alimentação), botão, resistor de 10KΩ, capacitor 100nF, LED (duas peças), EM-18 (Módulo leitor RFID), driver de motor L293D IC, motor 5V DC.
Software: Atmel studio 6.1, progisp ou flash magic.
Diagrama de circuito e explicação de trabalho
No circuito do sistema de cobrança de pedágio RFID mostrado acima, PORTA de ATMEGA32 está conectado à porta de dados do LCD. Aqui devemos nos lembrar de desabilitar a comunicação JTAG em PORTC para ATMEGA, alterando os bytes do fusível, se quisermos usar o PORTC como uma porta de comunicação normal. No LCD 16x2, existem 16 pinos ao todo, se houver uma luz de fundo, se não houver luz de fundo, haverá 14 pinos. Podemos ligar ou deixar os pinos de luz de fundo. Agora nos 14 pinos existem 8 pinos de dados (7-14 ou D0-D7), 2 pinos de fonte de alimentação (1 e 2 ou VSS e VDD ou gnd e + 5v), 3º pino para controle de contraste (VEE-controla a espessura do caracteres devem ser mostrados), 3 pinos de controle (RS & RW & E).
No circuito, você pode observar que tirei apenas dois pinos de controle. Isso dá a flexibilidade de um melhor entendimento. O bit de contraste e READ / WRITE não são usados com frequência, portanto, podem entrar em curto com o aterramento. Isso coloca o LCD em maior contraste e modo de leitura. Precisamos apenas controlar os pinos ENABLE e RS para enviar caracteres e dados de acordo.
As conexões que são feitas para LCD, são fornecidas abaixo:
PIN1 ou VSS para aterrar
PIN2 ou VDD ou VCC para alimentação de + 5v
PIN3 ou VEE para aterrar (oferece contraste máximo, melhor para um iniciante)
PIN4 ou RS (Seleção de Registro) para PD6 de MCU
PIN5 ou RW (leitura / gravação) para aterrar (coloca o LCD no modo de leitura facilita a comunicação para o usuário)
PIN6 ou E (habilitar) para PD5 do microcontrolador
PIN7 ou D0 a PA0
PIN8 ou D1 a PA1
PIN9 ou D2 a PA2
PIN10 ou D3 a PA3
PIN11 ou D4 a PA4
PIN12 ou D5 a PA5
PIN13 ou D6 a PA6
PIN14 ou D7 a PA7
No circuito, você pode ver que usamos comunicação de 8 bits (D0-D7). No entanto, isto não é obrigatório e podemos usar comunicação de 4 bits (D4-D7) mas com o programa de comunicação de 4 bits torna-se um pouco complexo, por isso preferi comunicação de 8 bits.
Portanto, pela mera observação da tabela acima, estamos conectando 10 pinos do LCD ao controlador, em que 8 pinos são pinos de dados e 2 pinos para controle.
Antes de prosseguir, precisamos entender sobre a comunicação serial. O módulo RFID aqui envia dados para o controlador em série. Possui outro modo de comunicação, mas para facilitar a comunicação, optamos pelo RS232. O pino RS232 do módulo é conectado ao pino RXD do ATMEGA.
Os dados enviados pelo módulo RFID vão como:
Agora, para a interface do módulo RFID, os seguintes recursos são necessários:
1. O pino RXD (recurso de recebimento de dados) do controlador deve ser habilitado.
2. Como a comunicação é serial, precisamos saber quando o bye de dados é recebido, para que possamos interromper o programa até que o byte completo seja recebido. Isso é feito ativando uma interrupção completa de recebimento de dados.
3. RFID envia dados para o controlador no modo de 8 bits. Portanto, dois personagens serão enviados ao controlador por vez. Isso é mostrado na figura acima.
4. Da figura acima, não há bits de paridade, um bit de parada nos dados enviados pelo módulo.
Os recursos acima são configurados nos registros do controlador; vamos discuti-los brevemente,
VERMELHO (RXEN): Este bit representa o recurso de recebimento de dados. Este bit deve ser definido para que os dados do módulo sejam recebidos pelo controlador. Também habilita o pino RXD do controlador.
BROWN (RXCIE): Este bit deve ser definido para obter uma interrupção após a recepção de dados com sucesso. Ao habilitar este bit, ficamos sabendo, logo após o recebimento dos dados de 8 bits.
PINK (URSEL): Este bit deve ser definido antes de habilitar outros bits no UCSRC. Depois de definir, outros bits necessários no UCSRC, URSEL deve ser desabilitado ou colocado em zero.
AMARELO (UCSZ0, UCSZ1, UCSZ2): Esses três bits são usados para selecionar o número de bits de dados que estamos recebendo ou enviando de uma só vez.
Como os dados enviados pelo módulo RFID são do tipo 8 bits, temos que definir UCSZ0, UCSZ1 para um e UCSZ2 para zero.
LARANJA (UMSEL): Este bit é definido com base em se o sistema está se comunicando de forma assíncrona (ambos usam um relógio diferente) ou de forma síncrona (ambos usam o mesmo relógio).
Como o módulo e o controlador usam relógios diferentes, esse bit deve ser definido como zero ou deixado sozinho, pois todos eles são definidos como zero por padrão.
VERDE (UPM1, UPM0): Esses dois bits são ajustados com base na paridade de bit que estamos usando na comunicação.
Como o módulo RFID envia dados sem paridade, definimos UPM1 e UPM0 como zero ou eles podem ser deixados sozinhos, pois todos os bits em qualquer registro são definidos como zero por padrão.
AZUL (USBS): Este bit é usado para escolher o número de bits de parada que estamos usando durante a comunicação.
Como o módulo RFID envia dados com um bit de parada, só temos que deixar o bit USBS sozinho.
Agora, finalmente, precisamos definir a taxa de bauds, da figura acima fica claro que o módulo RFID envia dados para o controlador com uma taxa de bauds de 9600bps (bits por segundo).
A taxa de transmissão é definida no controlador escolhendo o UBRRH apropriado.
O valor UBRRH é escolhido pela taxa de transmissão de referência cruzada e frequência de cristal da CPU. Portanto, por referência cruzada o valor de UBRR é visto como '6' e a taxa de transmissão é definida.
Agora, conforme mostrado na figura, dois pinos do controlador vão para L293D, que é uma H-BRIDGE usada para controlar a velocidade e a direção de rotação para motores CC de baixa potência.
L293D é um H-BRIDGE IC projetado para acionar motores CC de baixa potência e é mostrado na figura, este IC consiste em duas pontes H e, portanto, pode acionar dois motores CC. Portanto, este IC pode ser usado para acionar motores de robôs a partir dos sinais do microcontrolador.
Agora, como discutido antes, este IC tem capacidade de alterar a direção de rotação do motor DC. Isso é obtido controlando os níveis de tensão em INPUT1 e INPUT2.
|
Habilitar PIN |
Pino de entrada 1 |
Pino de entrada 2 |
Direção do motor |
|
Alto |
Baixo |
Alto |
Vire à direita |
|
Alto |
Alto |
Baixo |
Vire a esquerda |
|
Alto |
Baixo |
Baixo |
Pare |
|
Alto |
Alto |
Alto |
Pare |
Como mostrado na tabela acima, para a rotação no sentido horário 2A deve ser alto e 1A deve ser baixo. Da mesma forma, para anti-horário, 1A deve ser alto e 2A deve ser baixo.
Sempre que um cartão autorizado é aproximado do módulo, o motor é programado para se mover no sentido horário por um segundo, para mostrar que o portão de pedágio está aberto depois de um segundo ele volta, informando que o portão de pedágio está fechado. O funcionamento da praça de pedágio é melhor explicado passo a passo do código C fornecido abaixo.
Explicação de programação
Abaixo está a explicação linha a linha para o código do Sistema de cobrança de pedágio RFID. Você pode entender o conceito e o funcionamento deste projeto lendo o código abaixo. Para baixar ou copiar, você pode encontrar o código completo na parte inferior da página.
#include // cabeçalho para habilitar o controle do fluxo de dados sobre os pinos
#define F_CPU 1000000 // dizendo a frequência de cristal do controlador conectado
#incluir
#define E 5 // dando o nome “enable” ao 5º pino do PORTD, visto que está conectado ao pino de habilitação do LCD
# define RS 6 // dando o nome de “ seleção de registros” ao 6º pino do PORTD, já que está conectado ao pino RS do LCD
void send_a_command (comando unsigned char);
void send_a_character (caractere sem sinal);
void send_a_string (char * string_of_characters);
int main (vazio)
{
DDRA = 0xFF; // colocando porta como pinos de saída
DDRD = 0b11111110;
_delay_ms (50); // dando atraso de 50ms
DDRB = 0b11110000; // Pegando alguns pinos portB como entrada.
UCSRB - = (1 <
UCSRC - = (1 <
UCSRC & = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // definindo a taxa de transmissão // O seguinte contém ID de tags, estes devem ser alterados para tags diferentes, estes devem ser atualizados para que o projeto funcione
/ * Após descarregar o programa no controlador, deve-se pegar os cartões que devem ser autorizados e obter o ID dos tags. Eles são obtidos colocando-se a tag perto do módulo RFID e o ID será mostrado na tela. Depois de obter os IDs, o programa deve ser atualizado substituindo os números de ID abaixo por novos números de ID.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Agora, acima, estamos autorizando apenas cinco cartões, eles podem ser alterados para qualquer número.
Por exemplo, considere que o programa padrão é descarregado no controlador, obtenha os cartões que devem ser autorizados. Coloque um após o outro próximo ao módulo, você obterá o ID de cada um como xxxxxxxx (907a4F87), Se tivermos 7 tags, teremos 7 ID de oito bits. * /
|
// agora para sete cartas vai como // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // alocação de memória para mostrar o ID enviado por módulo int i = 0; voto interno = 0; int k = 0; send_a_command (0x01); // Limpar tela 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // informando ao lcd que estamos usando o modo de comando / dados de 8 bits _delay_ms (50); send_a_command (0b00001111); // TELA LCD LIGADA e cursor piscando char MEM; // alocando memória para armazenar o ID completo da tag send_a_string ("NÚMERO RFID"); // enviando string send_a_command (0x80 + 0x40 + 0); // movendo o cursor para a segunda linha enquanto (1) { enquanto (! (UCSRA & (1 <
{ } COUNTA = UDR; // UDR armazena os dados de oito bits recebidos e é considerado um número inteiro. MEM = CONT.valores; // os primeiros dois caracteres são atualizados para a memória itoa (COUNTA, SHOWA, 16); // comando para colocar o número da variável no LCD (número da variável, em qual caractere substituir, qual base é variável (dez aqui, pois estamos contando o número na base 10)) send_a_string (SHOWA); // dizendo ao display para mostrar o caractere (substituído pelo número variável) da segunda pessoa após posicionar o cursor no LCD enquanto (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = CONT.valores; // terceiro e quarto caracteres são atualizados para a memória enquanto (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // quinto e sexto caracteres são atualizados para a memória enquanto (! (UCSRA & (1 <
{ } COUNTA = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // sétimo e oito caracteres são atualizados para a memória send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
para (i = 0; i <5; i ++) { if ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// verificar a compra de autorização comparando dois personagens por vez com os personagens na memória PORTB - = (1 <
PORTB & = ~ (1 <
_delay_ms (220); // atraso _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 unsigned char) { PORTA = comando; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (caractere sem sinal) { PORTA = personagem; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { enquanto (* string_de_caracteres> 0) { send_a_character (* string_of_characters ++); } } |