Sabemos en oficinas, centros comerciales y en muchos otros lugares donde solo la persona con tarjeta de autorización puede ingresar a la habitación. Estos sistemas utilizan un sistema de comunicación RFID. La RFID se utiliza en los centros comerciales para detener el robo, ya que los productos están etiquetados con un chip RFID y cuando una persona sale del edificio con el chip RFID, se activa una alarma automáticamente. La etiqueta RFID está diseñada tan pequeña como parte de la arena. Los sistemas de autenticación RFID son fáciles de diseñar y económicos. Actualmente, algunas escuelas y universidades utilizan sistemas de asistencia basados en RFID.
En este proyecto vamos a diseñar un sistema de cobro de peaje basado en RFID por motivos de seguridad. Entonces, este sistema abre puertas y permite a las personas solo con las etiquetas RFID autorizadas. Las identificaciones de los titulares de etiquetas autorizados se programan en el microcontrolador ATMEGA y solo esos titulares pueden salir o entrar en las instalaciones.
Componentes requeridos
Hardware: microcontrolador ATmega32, fuente de alimentación (5v), programador AVR-ISP, JHD_162ALCD (módulo LCD de 16x2), condensador de 100uF (conectado a través de la fuente de alimentación), botón, resistencia de 10KΩ, condensador de 100nF, LED (dos piezas), EM-18 (Módulo lector RFID), controlador de motor L293D IC, motor de 5 V CC.
Software: Atmel studio 6.1, progisp o flash magic.
Diagrama de circuito y explicación de trabajo
En el circuito del sistema de cobro de peaje RFID que se muestra arriba, el PORTA de ATMEGA32 está conectado al puerto de datos de la pantalla LCD. Aquí debemos recordar deshabilitar la comunicación JTAG en PORTC a ATMEGA cambiando los bytes del fusible, si queremos usar el PORTC como puerto de comunicación normal. En LCD de 16x2, hay 16 pines en total si hay luz de fondo, si no hay luz de fondo, habrá 14 pines. Podemos encender o dejar los pines de luz de fondo. Ahora en los 14 pines hay 8 pines de datos (7-14 o D0-D7), 2 clavijas de alimentación de alimentación (1 y 2 o VSS y VDD o GND y + 5V), 3 rd PIN para el control de contraste (VEE-controla el grosor de la deben mostrarse los caracteres), 3 pines de control (RS & RW & E).
En el circuito, se puede observar que solo he sacado dos pines de control. Esto da la flexibilidad de una mejor comprensión. El bit de contraste y READ / WRITE no se utilizan con frecuencia, por lo que pueden cortocircuitarse a tierra. Esto coloca a la pantalla LCD en el modo de mayor contraste y lectura. Solo necesitamos controlar los pines ENABLE y RS para enviar caracteres y datos en consecuencia.
Las conexiones que se realizan para LCD, se dan a continuación:
PIN1 o VSS a tierra
PIN2 o VDD o VCC a + 5v de potencia
PIN3 o VEE a tierra (ofrece el mejor contraste máximo para un principiante)
PIN4 o RS (Selección de registro) a PD6 de MCU
PIN5 o RW (lectura / escritura) a tierra (pone la pantalla LCD en modo lectura facilita la comunicación para el usuario)
PIN6 o E (habilitado) a PD5 del microcontrolador
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
En el circuito, puede ver que hemos utilizado comunicación de 8 bits (D0-D7). Sin embargo, esto no es obligatorio y podemos usar la comunicación de 4 bits (D4-D7), pero con la comunicación de 4 bits el programa se vuelve un poco complejo, así que preferí la comunicación de 8 bits.
Por lo tanto, a partir de la mera observación de la tabla anterior, estamos conectando 10 pines de LCD al controlador en el que 8 pines son pines de datos y 2 pines para control.
Antes de seguir adelante, debemos comprender la comunicación en serie. El módulo RFID aquí envía datos al controlador en serie. Tiene otro modo de comunicación pero para facilitar la comunicación elegimos RS232. El pin RS232 del módulo está conectado al pin RXD de ATMEGA.
Los datos enviados por el módulo RFID son:
Ahora, para la interfaz del módulo RFID, se requieren las siguientes características:
1. El pin RXD (función de recepción de datos) del controlador debe estar habilitado.
2. Dado que la comunicación es serial, necesitamos saber cuándo se recibe el bye de datos, para poder detener el programa hasta que se reciba el byte completo. Esto se hace habilitando una interrupción completa de la recepción de datos.
3. RFID envía datos al controlador en modo de 8 bits. Por lo tanto, se enviarán dos caracteres al controlador a la vez. Esto se muestra en la figura anterior.
4. De la figura anterior, no hay bits de paridad, un bit de parada en los datos enviados por el módulo.
Las características anteriores se establecen en los registros del controlador; vamos a discutirlos brevemente,
ROJO (RXEN): este bit representa la función de recepción de datos. Este bit debe establecerse para que el controlador reciba los datos del módulo. También habilita el pin RXD del controlador.
MARRÓN (RXCIE): Este bit debe establecerse para obtener una interrupción después de una recepción de datos exitosa. Al habilitar este bit, nos damos cuenta, justo después de recibir los datos de 8 bits.
ROSA (URSEL): este bit debe establecerse antes de habilitar otros bits en UCSRC. Después de configurar, otros bits necesarios en UCSRC, URSEL deben desactivarse o ponerse a cero.
AMARILLO (UCSZ0, UCSZ1, UCSZ2): estos tres bits se utilizan para seleccionar la cantidad de bits de datos que estamos recibiendo o enviando de una sola vez.
Dado que los datos enviados por el módulo RFID son del tipo de datos de 8 bits, tenemos que configurar UCSZ0, UCSZ1 en uno y UCSZ2 en cero.
NARANJA (UMSEL): este bit se establece en función de si el sistema se comunica de forma asíncrona (ambos usan un reloj diferente) o de forma síncrona (ambos usan el mismo reloj).
Dado que el módulo y el controlador usan un reloj diferente, este bit debe establecerse en cero o dejarse solo, ya que todos están establecidos en cero de forma predeterminada.
VERDE (UPM1, UPM0): estos dos bits se ajustan en función de la paridad de bits que estamos usando en la comunicación.
Dado que el módulo RFID envía datos sin paridad, hemos establecido tanto UPM1 como UPM0 en cero o se pueden dejar solos, ya que todos los bits de cualquier registro se establecen en cero de forma predeterminada.
AZUL (USBS): Este bit se usa para elegir el número de bits de parada que usamos durante la comunicación.
Dado que el módulo RFID envía datos con un bit de parada, solo tenemos que dejar solo el bit USBS.
Ahora, por fin, necesitamos configurar la velocidad en baudios, de la figura anterior está claro que el módulo RFID envía datos al controlador con una velocidad en baudios de 9600bps (bits por segundo).
La velocidad en baudios se establece en el controlador eligiendo el UBRRH apropiado.
El valor de UBRRH se elige mediante la tasa de baudios de referencia cruzada y la frecuencia del cristal de la CPU, por lo que el valor de UBRR de referencia cruzada se ve como '6', por lo que se establece la tasa de baudios.
Ahora, como se muestra en la figura, dos pines del controlador van a L293D, que es un H-BRIDGE que se usa para controlar la velocidad y la dirección de rotación para motores de CC de baja potencia.
L293D es un H-BRIDGE IC diseñado para impulsar motores de CC de baja potencia y se muestra en la figura, este IC consta de dos puentes en H y, por lo tanto, puede impulsar dos motores de CC. Entonces, este IC se puede usar para impulsar motores de robot a partir de las señales del microcontrolador.
Ahora, como se discutió antes, este IC tiene la capacidad de cambiar la dirección de rotación del motor de CC. Esto se logra controlando los niveles de voltaje en INPUT1 e INPUT2.
|
Habilitar Pin |
Pin de entrada 1 |
Pin de entrada 2 |
Dirección del motor |
|
Alto |
Bajo |
Alto |
Girar a la derecha |
|
Alto |
Alto |
Bajo |
Girar a la izquierda |
|
Alto |
Bajo |
Bajo |
Detener |
|
Alto |
Alto |
Alto |
Detener |
Entonces, como se muestra en la tabla anterior, para la rotación en el sentido de las agujas del reloj, 2A debe ser alta y 1A debe ser baja. De manera similar, en el sentido contrario a las agujas del reloj, 1A debe ser alto y 2A debe ser bajo.
Siempre que una tarjeta autorizada se acerca al módulo, el motor está programado para moverse en el sentido de las agujas del reloj por un segundo, para mostrar que la puerta de peaje se abre después de un segundo y vuelve, indicando que la puerta de peaje está cerrada. El funcionamiento de la plaza de peaje se explica mejor en el paso a paso del código C que se proporciona a continuación.
Explicación de programación
A continuación se muestra la explicación línea a línea del código del sistema de cobro de peaje RFID. Puede comprender el concepto y el funcionamiento de este proyecto leyendo el código a continuación. Para descargar o copiar, puede encontrar el código completo en la parte inferior de la página.
#include // encabezado para permitir el control del flujo de datos sobre los pines
#define F_CPU 1000000 // indicando la frecuencia del cristal del controlador adjunta
#incluir
#define E 5 // dando el nombre “activar” a 5 º pin de PORTD, ya que está conectado a la pantalla LCD permite pin
#define RS 6 // dando el nombre “registerselection” a 6 º pin de PORTD, ya que está conectado al pin LCD RS
void send_a_command (comando de caracteres sin firmar);
void send_a_character (carácter sin signo);
void send_a_string (char * string_of_characters);
int main (vacío)
{
DDRA = 0xFF; // poner porta como pines de salida
DDRD = 0b11111110;
_delay_ms (50); // dando un retraso de 50ms
DDRB = 0b11110000; // Tomando algunos pines del puerto B como entrada.
UCSRB - = (1 <
UCSRC - = (1 <
UCSRC y = ~ (1 <
UBRRH & = ~ (1 <
UBRRL = 6; // configuración de la velocidad en baudios // Lo siguiente contiene ID de etiquetas, estos deben cambiarse para diferentes etiquetas, estos deben actualizarse para que el proyecto funcione
/ * Después de descargar el programa en el controlador, se deben tomar las tarjetas que deben estar autorizadas y obtener el ID de las etiquetas. Estos se obtienen colocando la etiqueta cerca del módulo RFID y la identificación se mostrará en la pantalla. Después de obtener las identificaciones, el programa debe actualizarse reemplazando los siguientes números de identificación con nuevos números de identificación.
|
char ADMIT = {{(0x97), (0xa1), (0x90), (0x92)}, {(0x97), (0xa1), (0x90), (0x93)}, {(0x97), (0xa1), (0x90), (0x94)}, {(0x97), (0xa1), (0x90), (0x95)}, {(0x97), (0xa1), (0x90), (0x96)}}; |
Ahora, en lo anterior, estamos autorizando solo cinco tarjetas, estas se pueden cambiar a cualquier número.
Por ejemplo, considere que el programa predeterminado se descarga en el controlador, obtenga las tarjetas que deben autorizarse. Coloque uno tras otro cerca del módulo, obtendrá la ID de cada uno como xxxxxxxx (907a4F87), Si hay 7 etiquetas que tenemos, entonces tendremos 7 ID de ocho bits. * /
|
// ahora para siete cartas va como // char ADMIT = {{(0x90), (0x7a), (0x4F), (0x87)},; // asignación de memoria para mostrar el ID enviado por módulo int i = 0; int voto = 0; int k = 0; send_a_command (0x01); // Limpiar pantalla 0x01 = 00000001 _delay_ms (50); send_a_command (0x38); // decirle a lcd que estamos usando el modo de comando / datos de 8 bits _delay_ms (50); send_a_command (0b00001111); // PANTALLA LCD ENCENDIDA y el cursor parpadeando char MEM; // asignación de memoria para almacenar la identificación completa de la etiqueta send_a_string ("NÚMERO RFID"); // enviando cadena send_a_command (0x80 + 0x40 + 0); // moviendo el corcel a la segunda línea mientras (1) { mientras que (! (UCSRA & (1 <
{ } CONTAR = UDR; // UDR almacena los datos de ocho bits recibidos y se convierte en un número entero. MEM = COUNTA; // los primeros dos caracteres se actualizan en la memoria itoa (COUNTA, SHOWA, 16); // comando para poner el número de variable en LCD (número de variable, en qué carácter reemplazar, qué base es variable (diez aquí ya que estamos contando el número en base10)) send_a_string (SHOWA); // decirle a la pantalla que muestre el carácter (reemplazado por un número variable) de la segunda persona después de colocar el cursor en la pantalla LCD mientras que (! (UCSRA & (1 <
{ } CONTAR = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // el tercer y cuarto caracteres se actualizan en la memoria mientras que (! (UCSRA & (1 <
{ } CONTAR = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // el quinto y sexto caracteres se actualizan en la memoria mientras que (! (UCSRA & (1 <
{ } CONTAR = UDR; itoa (COUNTA, SHOWA, 16); send_a_string (SHOWA); MEM = COUNTA; // el séptimo y el ocho caracteres se actualizan en la memoria send_a_string (""); send_a_command (0x80 + 0x40 + 0); UCSRB & = ~ (1 <
para (i = 0; i <5; i ++) { si ((MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT) & (MEM == ADMIT)) {// verificar la compra de autorización comparando dos caracteres a la vez con los caracteres en la memoria PORTB - = (1 <
PORTB & = ~ (1 <
_delay_ms (220); // retraso _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 de caracteres sin firmar) { PORTA = comando; PORTD & = ~ (1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_character (carácter de carácter sin firmar) { PORTA = personaje; PORTD - = 1 <
PORTD - = 1 <
_delay_ms (50); PORTD & = ~ 1 <
PORTA = 0; } void send_a_string (char * string_of_characters) { while (* cadena_de_caracteres> 0) { send_a_character (* cadena_de_caracteres ++); } } |