control de acceso para estacionamiento de la …

UNIVERSIDAD AUTÓNOMA DE SAN LUIS POTOSÍ

COORDINACIÓN ACADÉMICA REGIÓN ALTIPLANO

OESTE

CONTROL DE ACCESO PARA ESTACIONAMIENTO DE LA CARAO, UTILIZANDO SENSORES RFID Y ARDUINO

TRABAJO RECEPCIONAL PARA OBTENER EL TÍTULO DE:

INGENIERO/A EN SISTEMAS COMPUTACIONALES

PRESENTA: JOSE RICARDO PARGA OLVERA

DIRECTOR/ES DE TESIS: Dr. Marco Tulio Ramírez Torres. Dr. César Arturo Guerra García.

13 noviembre de 2019

Propuesta de Proyecto

Estudiante Nombre del Proyecto Fecha

Jose Ricardo Parga Olvera Control de acceso para estacionamiento de CARAO,

utilizando sensores RFID y arduino 13/11/2019

Director(a) del Proyecto “Dr. Marco Tulio Ramírez Torres.” “Dr. César Arturo Guerra García.”

Desarrollado por: José Ricardo Parga Olvera

Hoja 1

Tabla de contenido

Introducción 2

Planteamiento del Problema 2

1. 2 1.1 Administración de proyectos 2 1.2 Desarrollo del Producto o Servicio 2 1.2.1 Ciclo de Vida 2 1.3 Fundamento Normativo 3 1.3.1 Normatividad externa 3 1.3.2 Normatividad interna 3

2. 3 2.1 3 2.1.1 Descripción del Proyecto 3 2.1.2 Identificar a los Interesados 3 2.1.3 Descripción de Objetivos del Proyecto 3 2.2 4 2.2.1 Plan de Gestión de Requisitos 4 2.2.2 Establecer el Alcance de Entregables 4 2.2.3 Estructura de desglose de trabajo (EDT) 5 2.3 10 2.3.1 Planeación Diagrama de Gantt (Cronograma) 10 2.4 Cierre 10 2.4.1 Carta de Registro de Tema 10

3. 11

4. 11







Hoja 2

Introducción

El presente proyecto, servirá para el control de acceso al estacionamiento de la Coordinación Académica Región Altiplano Oeste de la Universidad Autónoma de San Luis Potosí. El proyecto consiste en permitir la entrada a personal que cuente con tarjetas RFID, las cuales serán leídas mediante sensores RFID522. Llevando un control de las personas que entren y salgan del campus.

Planteamiento del Problema

La Coordinación Académica Región Altiplano Oeste no cuenta con un control de acceso en su estacionamiento, por tal motivo entran a las instalaciones todas las personas que lo deseen, generando un riesgo de seguridad para la comunidad estudiantil, personal docente, administrativo y de intendencia.

1. Metodología

1.1 Administración de proyectos

Se considera como referente la Guía de los Fundamentos para la Dirección de Proyectos (PMBOK) [1]. Esto facilitará la aplicación de conocimiento, habilidades, herramientas y técnicas a las actividades inmersas en el desarrollo del proyecto “Control de acceso para estacionamiento de CARAO, utilizando sensores RFID y Arduino”, siempre con la idea de cumplir con los requerimientos del mismo.

1.2 Desarrollo del Producto o Servicio

1.2.1 Ciclo de Vida

El proyecto se inició investigando los sensores RFID, para saber si cumplían los requisitos mínimos para realizar el sistema de acceso. Una vez verificado su funcionamiento y capacidad, se definieron los demás componentes necesarios: motores, relevadores, resistencias, LEDs, circuito integrado 74LS04P, pilas, sensor óptico reflectivo TCRT5000 y el Arduino mega.







Hoja 3

Una vez con los datos necesarios, se adquirieron los componentes y se comenzó a hacer el circuito con los sensores RFID, agregando poco a poco los elementos, conforme los fuimos necesitando y haciendo pruebas hasta lograr el objetivo que es permitir el acceso al campus.

Una vez teniendo este circuito en la protoboard se podrá realizar un circuito impreso para poder implementarlo en el estacionamiento del campus y ponerlo en funcionamiento.

1.3 Fundamento Normativo

1.3.1 Normatividad interna

Por medio de la realización de este proyecto se pretende obtener el título como Ingeniero en Sistemas Computacionales mediante la modalidad de Trabajo Recepcional.

2. Desarrollo del Proyecto

2.1 Gestión de la Integración

2.1.1 Descripción del Proyecto

El proyecto es básicamente para tener control en el acceso al estacionamiento y por ende al campus, ya que por el momento no se tiene. El proyecto permitirá la entrada solo a personas que tengan el permiso necesario y que cuenten con una tarjeta registrada, de lo contrario no podrá ingresar.

Al leer una tarjeta que tenga permiso de acceso, la pluma se abrirá de forma automática y al pasar se detectará que ya ha entrado y la pluma se cerrará de igual manera, evitando que la pluma se cierre antes de tiempo y pueda causar algún daño al vehículo que esté pasando.

2.1.2 Identificar a los Interesados

Director de la universidad, profesores, estudiantes, administradores, visitantes, egresados y personal de intendencia.







Hoja 4

2.1.3 Descripción de Objetivos del Proyecto

1. Controlar el acceso sólo a personal autorizado.

2. No permitir acceso más de una vez con la misma tarjeta, sin haber salido.

3. Evitar que la pluma baje mientras esté pasando un vehículo.

2.2 Gestión del Alcance

Con el presente proyecto se puede tener un mayor control del acceso de todas las personas que tienen el permiso. De esta manera se puede evitar que personas ajenas a la institución tengan acceso y evitar riñas, robos, ventas de estupefacientes y hasta secuestros dentro del campus.

2.2.1 Plan de Gestión de Requisitos

No aplica.

2.2.2 Establecer el Alcance de Entregables

Se entregará la propuesta del proyecto en donde se explica las problemáticas y las soluciones de dichos problemas.

Se entregará una maqueta donde ya se están resolviendo los principales problemas y donde se podrá simular las entradas y salidas, así como el circuito en la cual se trabajó. Este entregable se podrá ver en el Anexo 1.

Para la realización del software se decidió usar la plataforma Arduino IDE 1.8.9, que es la última versión por el momento. Se agregó la librería para el módulo lector RFID-RC522 [4], con la cual estaremos trabajando ya que después de una ardua investigación no se lograba la conexión de dos módulos RFID y después de mucho investigar y realizar pruebas se tomó uno de los ejemplos como punto de partida esté código podrá ser observado en el Anexo 2.







Hoja 5

2.2.3 Estructura de desglose de trabajo (EDT)

1. Control de acceso para estacionamiento de CARAO, utilizando sensores RFID y Arduino.

1.1. Propuesta de proyecto.

1.1.1. Generación de la primera versión del documento.

1.1.2. Revisión del documento.

1.1.3. Generación de la segunda versión del documento propuesta.

1.1.4. Revisión de la segunda versión.

1.1.5. Generación de la tercera versión.

1.1.6. Revisión de la tercera versión.

1.1.7. Generación de la cuarta versión.

1.1.8. Revisión de la cuarta versión.

1.2. Maqueta.

1.2.1. Se buscaron los materiales más factibles y económicos para su realización, los cuales serán, madera, papel cascaron, plastilina y pintura verde negra, blanca y amarilla.

1.2.2. El circuito se armó inicialmente al descubierto, posteriormente se realizó una cabina con papel cascaron para ocultar el circuito, así como dos columnas para que dentro de ellas lleve los sensores RFID, sensores infrarrojos TCRT5000 y los motores, en los cuales estarán las plumas, quedando de una manera satisfactoria.

1.2.3. Ya armada la maqueta se montó el circuito, para ocultar los cables se pasaron por debajo ocultándolos con un doble fondo, quedando terminada y lista para ser mostrada, ver Anexo1.

1.3. Circuito.

1.3.1. Se buscaron componentes necesarios para la realización del circuito.

1.3.2. Se adquirieron los materiales: Arduino mega 2560, diodos LED (azul, rojo y verde), sensores RFID-RC522, tarjetas RFID, llaveros RFID,







Hoja 6

resistencias (470Ω, 10K, 330Ω), circuito integrado 74LS04P, cable telefónico, cable Dupont macho y hembra, modulo relevador de 4 canales, batería recargable, porta pilas AA, dos pilas AA, sensor infrarrojo TCRT5000, dos protoboards, cable USB AM/BM y dos motorreductores.

1.3.3. Se comenzó conectando un sensor RFID [4] para comprender su funcionamiento, ya que aún se desconocía como conectar dos sensores para que trabajaran de manera simultánea.

1.3.4. Después de investigar la forma de conexión para dos módulos [3] se realizó la conexión y las pruebas necesarias, para su correcto funcionamiento, cabe mencionar que para lograr esta conexión se comparten los pines de RST (Reset), MOSI (Master Output Slave input) [10], MISO (Master Input Slave Output) [9].

1.3.5. Ya que se tenía el circuito de los módulos RFID se agregaron los LEDs indicadores (Azul, Rojo y Verde).

1.3.6. Teniendo la conexión de los módulos y los LEDs fue el momento de agregar el módulo relevador de 4 canales y los motores, encargados de elevar las plumas de nuestro estacionamiento. En esta parte al realizar pruebas nos percatamos que al energizar nuestro circuito los motores giraban sin detenerse, para resolver esto se colocó un circuito integrado 74LS04P perteneciente a la compuerta NOT. Antes de poner el circuito integrado se realizó una prueba haciendo una compuerta negada con transistores 2n222A, de esta manera se determinó que con una compuerta negada podíamos resolver el problema.

1.3.6. Por último, se realizó una investigación para saber que sensor nos ayudaría para que estuviese detectando el paso de los vehículos y dejara caer la pluma. Así que se realizaron pruebas con el sensor CNY70, pero tenía muy poco alcance. También se realizaron pruebas con el sensor ultrasónico, pero no nos convenció ya que este solo lo pudimos hacer que detectara la proximidad y no que mandará una señal al pasar un obstáculo, llegando a la conclusión de usar el sensor TCRT5000 [6, 7] y obteniendo los resultados esperados con éxito.

1.3.7. Se anexan fotografías del circuito real en el Anexo 3.

1.4. Programación.







Hoja 7

1.4.1. Se instaló la librería MFRC522 [5] para nuestros módulos RFID, la cual nos ayudará para que reconozca nuestros módulos.

1.4.2. Se tomó como base el ejemplo de la librería titulado ReadUidMultiReader [5].

1.4.3. Al inicio se incluyeron las librerías que se utilizan las cuales son SPI y MFRC522. El SPI [2] es un protocolo que permite la comunicación con dispositivos de este tipo, utilizando Arduino como dispositivo maestro.

1.4.4. Se definieron los pines de los módulos RFID, RST y SDA, así como los LEDs indicadores verde, rojo y azul.

1.4.5. Se especificó un arreglo de tipo byte el cual ayuda a almacenar el SDA que es de cada módulo RFID.

1.4.6. Se establece la instancia MFRC522 para acceder a los módulos.

1.4.7. Se creó un arreglo de tipo byte el cual almacenará el identificador de usuario (UID por sus siglas en ingles de user ID).

1.4.8. Se estableció un arreglo bidimensional de tipo byte, en este arreglo se almacenan los UID de las tarjetas utilizadas por los usuarios.

1.4.9. Se declaró una variable [8] número entero con signo de 1 byte donde almacenará el número que se asignará a los módulos ya sea el 0 o el 1 dependiendo de cual haya leído la tarjeta.

1.4.10. Se declararon las variables [8] para los sensores TCRT5000, los pines donde estarán colocados, dos variables donde se almacenarán los valores analógicos, los estados actual y anterior de cada sensor, los tiempos de control y el tiempo de apagado del motor.

1.4.11. Se declaró la variable [9] de control para usuarios.

1.4.12. Se declararon las variables [8] para un bucle que controlará la comparación de los UID leídos con los almacenados.

1.4.13. void setup

1.4.13.1. Se establecen los LEDs indicadores como salidas, y con ello puedan encender al recibir los pulsos enviados por los módulos.

https://github.com/miguelbalboa/rfid/tree/master/examples/ReadUidMultiReader







Hoja 8

1.4.13.2. La variable sensor es declarada como entrada ya que esta nos mandará los datos analógicos directos del sensor TCRT5000.

1.4.13.3. Se comienza la comunicación serial para poder ver los datos en el monitor serie, así como SPI y una leyenda para iniciar el reconocimiento de las tarjetas.

1.4.13.4. Se declaró un ciclo for para determinar que módulo está leyendo las tarjetas y poder inicializar la estancia MFRC522, esté ciclo se declara en el setup por que sólo se ejecutará una vez.

1.4.13.5. Se utilizó un ciclo for en el que se asigna el valor a la variable de control.

1.4.13.5. Se establecen como salidas las variables de los motores que se llaman abrir, cerrar, abrir1 y cerrar1.

1.4.14. void loop

1.4.14.1. Se leen los valores de los sensores TCRT5000 y se almacenan en la variable val y val1.

1.4.14.2. Se entra a un ciclo for que determina el módulo en el que se realiza la lectura.

1.4.14.3. Con el condicionante if se determina si hay una nueva tarjeta o llavero, y si se detecta alguno tras leerlo se imprimirá en el monitor serial la lectura y su número de ID, perteneciente a la tarjeta que está leyendo. Para esto se ingresa a un ciclo for, que recorrerá byte por byte e imprimirá el byte leído y procederá a guardarlo en una variable para seguir con el siguiente proceso, que será la comparación del UID almacenado y el leído.

1.4.14.4. Se comprueba el UID leído, por los módulos con los almacenados, para saber si son válidos y pueden tener acceso. Esto se logra mandando llamar una variable X y asignarle un valor 0, para después entrar a un ciclo for en el que recorrerá, de 0 a 4 datos almacenados en una variable Y, dentro de este estará un condicional if que será el encargado de comparar nuestros UIDs, en caso de haber una coincidencia, nuestra variable Y aumentará, recorriendo byte por byte. La variable llamada VALIDO tendrá también un aumento, en caso de que no exista ninguna coincidencia entonces pasará a otro UID.







Hoja 9

1.4.14.5. Si la variable X es mayor o igual a la cantidad de UIDs almacenados, la variable cambiará el valor de 4 a 5, para que dé salida al siguiente proceso.

1.4.14.6. Comprobada la lectura de los módulos, si el módulo que está leyendo es el módulo 0, entrará al condicional if el cual comparará la variable valido y la variable de control, en caso de cumplir con la condición se imprimirá la leyenda de bienvenido y el número de usuario, dependiendo del usuario leído, se encenderá el LED indicador verde, así como el motor para elevar la pluma por un tiempo definido, y enseguida se apagará el LED y el motor permaneciendo la pluma arriba. En caso contrario que no cumpla con la condición entonces se encenderá el LED rojo y se mandará imprimir, “error salida no identificada o usuario no valido” y se apagará el LED rojo.

1.4.14.7. Se comprobará la lectura de los módulos, si el módulo que está leyendo el módulo 1, entrará al condicional if el cual comparará la variable valido y la variable de control en caso de cumplir, con la condición se imprimirá la leyenda de bienvenido y el número de usuario, dependiendo del usuario leído, encenderá el LED indicador verde, así como el motor para elevar la pluma por un tiempo definido, enseguida se apagará el LED y el motor permaneciendo la pluma arriba. En caso contrario, que no cumpla con la condición entonces se encenderá el LED rojo y mandará imprimir “usuario no valido”, se apagará el led rojo, se detendrá la comunicación con las tarjetas para finalizar la lectura de tarjetas.

1.4.14.8. Se verifica el estado actual del sensor TCRT5000, dependiendo su lectura, se le asigna el valor a la variable “EstadoActual”, esta variable nos ayudará para el condicional if, donde se verificará si el estado actual es diferente al estado anterior, si esto se cumple entonces se le dará un tiempo en milisegundos a la variable “T_Control”, una vez asignado el tiempo de control encenderá el led azul, se energizará el motor y bajará la pluma mostrando “cerrando” en el monitor serie, esto se realizará dependiendo del sensor que mande la información ya sea el sensor de entrada o el de salida.

1.4.14.9. Se asigna el estado actual al estado anterior, entrará a un condicional if, donde se comparará si el tiempo en milis es mayor al tiempo de control, y el tiempo de control mayor que cero,







Hoja 10

de cumplir esta condición, entonces se apagará el LED azul, se des energiza el motor y el tiempo de control se envía a cero, para continuar con todo el proceso de nueva cuenta, esto se realizará dependiendo del sensor que este mandando los datos.

2.3 Gestión del Tiempo

2.3.1 Planeación Diagrama de Gantt (Cronograma)

2.4 Cierre

2.4.1 Carta de Registro de Tema







Hoja 11

3. Referencias

• [1] Guía de los Fundamentos de la Dirección de Proyectos. Sexta Edición (Guía del PMBOK).

• [2] https://www.arduino.cc/en/reference/SPI

• [3] https://forum.arduino.cc/index.php?topic=562448.0

• [4] https://leantec.es/control-de-acceso-con-arduino-y-rfid/

• [5] https://github.com/miguelbalboa/rfid

• [6] https://www.mecatronicalatam.com/es/tarjeta/arduino/sensor-ir-tcrt5000

• [7] https://www.arduinoecia.com.br/sensor-optico-reflexivo-tcrt5000/

• [8] https://www.arduino.cc/reference/en/#variables

• [9] https://aprendiendoarduino.wordpress.com/tag/mosi/

https://www.arduino.cc/en/reference/SPI

https://forum.arduino.cc/index.php?topic=562448.0

https://leantec.es/control-de-acceso-con-arduino-y-rfid/

https://github.com/miguelbalboa/rfid

https://www.mecatronicalatam.com/es/tarjeta/arduino/sensor-ir-tcrt5000

https://www.arduinoecia.com.br/sensor-optico-reflexivo-tcrt5000/

https://www.arduino.cc/reference/en/#variables

https://aprendiendoarduino.wordpress.com/tag/mosi/







Hoja 12







Hoja 13

Anexo1. Podemos observar la maqueta de inicio con la que estuvimos trabajando y el resultado final de nuestra maqueta.







Hoja 14







Hoja 15







Hoja 16







Hoja 17







Hoja 18







Hoja 19







Hoja 20







Hoja 21







Hoja 22

Anexo 2. Se muestra el código de ejemplo tomado de la librería RFID, MFRC522 este ejemplo titulado “ReadUidMultiReader”.

/**

* -------------------------------------------------------------------------------------------------------------------- * Example sketch/program showing how to read data from more than one PICC to serial. * -------------------------------------------------------------------------------------------------------------------- * This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid

*

* Example sketch/program showing how to read data from more than one PICC (that is: a RFID Tag or Card) using a

* MFRC522 based RFID Reader on the Arduino SPI interface. *

* Warning: This may not work! Multiple devices at one SPI are difficult and cause many trouble!! Engineering skill * and knowledge are required! *

* @license Released into the public domain. *

* Typical pin layout used: * ----------------------------------------------------------------------------------------- * MFRC522 Arduino Arduino Arduino Arduino Arduino

* Reader/PCD Uno/101 Mega Nano v3 Leonardo/Micro Pro Micro

* Signal Pin Pin Pin Pin Pin Pin

* ----------------------------------------------------------------------------------------- * RST/Reset RST 9 5 D9 RESET/ICSP-5 RST

* SPI SS 1 SDA(SS) ** custom, take a unused pin, only HIGH/LOW required **

* SPI SS 2 SDA(SS) ** custom, take a unused pin, only HIGH/LOW required **

* SPI MOSI MOSI 11 / ICSP-4 51 D11 ICSP-4 16

* SPI MISO MISO 12 / ICSP-1 50 D12 ICSP-1 14

* SPI SCK SCK 13 / ICSP-3 52 D13 ICSP-3 15

*

*/ #include <SPI.h>

https://github.com/miguelbalboa/rfid







Hoja 23

#include <MFRC522.h>

#define RST_PIN 9 // Configurable, see typical pin layout above

#define SS_1_PIN 10 // Configurable, take a unused pin, only HIGH/LOW required, must be diffrent to SS 2

#define SS_2_PIN 8 // Configurable, take a unused pin, only HIGH/LOW required, must be diffrent to SS 1

#define NR_OF_READERS 2

byte ssPins[] = {SS_1_PIN, SS_2_PIN}; MFRC522 mfrc522[NR_OF_READERS]; // Create MFRC522 instance. /**

* Initialize. */ void setup() { Serial.begin(9600); // Initialize serial communications with the PC

while (!Serial); // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4) SPI.begin(); // Init SPI bus

for (uint8_t reader = 0; reader < NR_OF_READERS; reader++) { mfrc522[reader].PCD_Init(ssPins[reader], RST_PIN); // Init each MFRC522 card

Serial.print(F("Reader ")); Serial.print(reader); Serial.print(F(": ")); mfrc522[reader].PCD_DumpVersionToSerial(); } } /**

* Main loop. */ void loop() { for (uint8_t reader = 0; reader < NR_OF_READERS; reader++) {







Hoja 24

// Look for new cards

if (mfrc522[reader].PICC_IsNewCardPresent() && mfrc522[reader].PICC_ReadCardSerial()) { Serial.print(F("Reader ")); Serial.print(reader); // Show some details of the PICC (that is: the tag/card) Serial.print(F(": Card UID:")); dump_byte_array(mfrc522[reader].uid.uidByte, mfrc522[reader].uid.size); Serial.println(); Serial.print(F("PICC type: ")); MFRC522::PICC_Type piccType = mfrc522[reader].PICC_GetType(mfrc522[reader].uid.sak); Serial.println(mfrc522[reader].PICC_GetTypeName(piccType)); // Halt PICC

mfrc522[reader].PICC_HaltA(); // Stop encryption on PCD

mfrc522[reader].PCD_StopCrypto1(); } //if (mfrc522[reader].PICC_IsNewC

} //for(uint8_t reader } /**

* Helper routine to dump a byte array as hex values to Serial. */ void dump_byte_array(byte *buffer, byte bufferSize) { for (byte i = 0; i < bufferSize; i++) { Serial.print(buffer[i] < 0x10 ? " 0" : " "); Serial.print(buffer[i], HEX); }

}







Hoja 25

Anexo 3. Procesos de los circuitos realizados para lograr el objetivo final.







Hoja 26







Hoja 27







Hoja 28







Hoja 29

Anexo 4. Código del programa realizado para este proyecto.

/**

* ---------------------------------------- *

* | MFRC522 | Arduino *

* | Reader/PCD| Mega *

* Señal | Pin | Pin *

* -----------|-----------|---------------- *

* RST/Reset | RST | 5 *

* SPI SDA 1 | SDA | 6 *

* SPI SDA 2 | SDA | 7 *

* SPI MOSI | MOSI | 51 *

* SPI MISO | MISO | 50 *

* SPI SCK | SCK | 52 *

* | | *

* ---------------------------------------- *

*/ #define Abrir 8 //Abrir es definido al pin 8. #define Abrir1 11 //Abrir1 es definido al pin 11. #define Cerrar 9 //Cerrar es definido al pin 9. #define Cerrar1 12 //Cerrar1 es definido al pin 12. // Incluimos la libreria RFID y SPI para controlar la tarjeta lectora. #include <SPI.h> //Incluye librería bus SPI. #include <MFRC522.h> //Incluye librería específica para MFRC522. #define RST_PIN 5 // Se define el pin 5 para el reset del RC522. #define SDA_1_PIN 6 // Se define el pin 6 para el ss (SDA) del RC522. #define SDA_2_PIN 7 // Se define el pin 7 para el ss (SDA) del RC522. #define Verde 2 // Se define el pin 2 al led Verde. #define Azul 3 // Se define el pin 3 al led Azul. #define Rojo 4 // Se define el pin 4 al led Rojo. byte sdaPins[] = {SDA_1_PIN, SDA_2_PIN}; //Arreglo de pines SDA. MFRC522 mfrc522[2]; // Crea la instancia MFRC522.







Hoja 30

byte LecturaUID[4]; // Crea array para almacenar el UID leído. byte AltaUID[3][4]= {{0xF4, 0x50, 0xAC, 0x35}, // UID de tarjeta1

{0xF2, 0x72, 0x49, 0x19}, // UID de tarjeta2

{0x49, 0x64, 0xE2, 0x2A}}; // UID de llavero

uint8_t LecturaModulos; //Para saber si lo lee la tarjeta 0 o 1. int sensor = 10; //Pin donde será colocado el primer sensor TCRT5000. int sensor1 = 22; //Pin donde será colocado el segundo sensor TCRT5000. int val = 0; //Variable para almacenar el valor analógico del primer sensor TCRT5000. int val1 = 0; //Variable para almacenar el valor analógico del segudo sensor TCRT5000. int EstadoActual; // Estado actual del primer sensor TCRT500. int EstadoActual1; // Estado actual del segundo sensor TCRT500. int EstadoAnterior = 1; // Estado anterior del sensor primer TCRT500 iniciado con un pulso alto para que no encienda el motor desde un inicio. int EstadoAnterior1 = 1; // Estado anterior del sensor segundo TCRT500 iniciado con un pulso alto para que no encienda el motor desde un inicio. unsigned long T_Control=0; // Para controlar el tiempo consumido. unsigned long T_Control1=0; // Para controlar el tiempo consumido. unsigned long T_Apagar=1000; // Tiempo de funcionamiento. unsigned long T_Apagar1=1000; // Tiempo de funcionamiento. int Vcontrol[10]; // Variable de control para Usuarios. int x=0; //cambio guerra

int y; int valido; void setup() { pinMode(Verde, OUTPUT); // Determina el led verde como una salida. pinMode(Azul, OUTPUT); // Determina el led azul como una salida. pinMode(Rojo, OUTPUT); // Determina el led rojo como una salida. pinMode(sensor, INPUT); // Determina el led rojo como una Entrada. Serial.begin(9600); // Inicialización de la comunicación serial. SPI.begin(); // Iniciamos el bus SPI.







Hoja 31

Serial.println("IDENTIFIQUESE..."); // Muestra texto Listo. for (LecturaModulos = 0; LecturaModulos < 2; LecturaModulos++) { // Ciclo for que indica que lector esta inicializado. mfrc522[LecturaModulos].PCD_Init(sdaPins[LecturaModulos], RST_PIN); // Iniciamos el MFRC522 de los lectores. } for(int i=0; i<10; i++){ // ciclo for donde determina el valor a la variable de control. Vcontrol[i]=1; } pinMode(Abrir, OUTPUT); // Establecer Abrir como salida. pinMode(Cerrar, OUTPUT); // Establecer Cerrar como salida. pinMode(Abrir1, OUTPUT); // Establecer Abrir1 como salida. pinMode(Cerrar1, OUTPUT); // Establecer Cerrar1 como salida. } void loop() { val = digitalRead(sensor); // Lee el valor del sensor y lo almacena en la variable val. val1 = digitalRead(sensor1); // Lee el valor del sensor y lo almacena en la variable val1. for (LecturaModulos = 0; LecturaModulos < 2; LecturaModulos++) { //Para ver las nuevas tarjetas. Seleccionar una tarjeta. if (mfrc522[LecturaModulos].PICC_IsNewCardPresent() && mfrc522[LecturaModulos].PICC_ReadCardSerial()) { Serial.print(F("Lectura ")); Serial.print(LecturaModulos); Serial.print((": Card UID:")); for (byte i = 0; i < mfrc522[LecturaModulos].uid.size; i++) { // Ciclo for que recorre de a un byte a la vez del UID. Serial.print(mfrc522[LecturaModulos].uid.uidByte[i] < 0x10 ? " 0" : " ");







Hoja 32

Serial.print(mfrc522[LecturaModulos].uid.uidByte[i], HEX); // Imprime el byte del UID leído en hexadecimal. LecturaUID[i] = mfrc522[LecturaModulos].uid.uidByte[i]; // Almacena en array el byte del UID leído. valido=0; } Serial.println(); // Comparamos el número de serie leído con los 3 UID's válidos x=0; for(y=0; y<4;){// El UID tiene 4 valores

if((LecturaUID[y]) == (AltaUID[x][y])){ y++; valido++; }else{ x++; y=0; // modificado guerra

} if(x >= 3){ // UID's válidos, en este caso 3

y=5; } } if (LecturaModulos == 0){ // Si la lectura del UID es en el módulo 0 o primer modulo

if(valido == 4 && Vcontrol[x] == 1){ // Compara la variable valido y la variable de control. Serial.print("Bienvenido Usuario "); // Muestra texto de bienvenido al Usuario correspondiente. Serial.print(x); Serial.println(); digitalWrite(Verde, HIGH); // enciende el led Verde

delay(1000); digitalWrite(Abrir,HIGH); // Giro del motor a la derecha. Serial.println("Abriendo..."); delay(1000); // Se detiene mor un segundo.







Hoja 33

digitalWrite(Abrir, LOW); // Paro de motor. digitalWrite(Verde, LOW); // Apaga el led verde

delay(1000); Vcontrol[x]++; }else{ Serial.println("ERROR SALIDA NO IDENTIFICADA O USUARIO NO IDENTIFICADO ..."); // Muestra texto equivalente a acceso denegado. digitalWrite(Rojo, HIGH); // Enciende el led rojo

delay(1000); digitalWrite(Rojo, LOW); // Apaga el led rojo

} } if(LecturaModulos == 1){ // Si la lectura del UID es en el módulo 1 o segundo modulo

if(valido == 4 && Vcontrol[x] >= 1){ // Compara la variable valido y la variable de control. Serial.print("Adios Usuario"); // Muestra texto de adiós al Usuario correspondiente. Serial.print(x); Serial.println(); digitalWrite(Verde, HIGH); //Enciende el led Verde

delay(1000); digitalWrite(Abrir1,HIGH); // Giro del motor a la derecha. Serial.println("Abriendo..."); delay(1000); // Se detiene mor un segundo. digitalWrite(Abrir1, LOW); // Paro de motor. digitalWrite(Verde, LOW); //Apaga el led verde

delay(1000); Vcontrol[x]--; }else{ // Si retorna falso. Serial.println("USUARIO NO IDENTIFICADO"); // Muestra texto equivalente a acceso denegado. digitalWrite(Rojo, HIGH); // Enciende el led rojo

delay(1000); digitalWrite(Rojo, LOW); // Apaga el led rojo

} }







Hoja 34

mfrc522[LecturaModulos].PICC_HaltA(); // Detiene la comunicación con las tarjetas. } } EstadoActual=val; if (EstadoActual != EstadoAnterior){ // Si el estado ha variado. if(EstadoActual==1 && EstadoAnterior==0){ //si el estado actual es 1 y el estado anterior es 0

T_Control=millis()+T_Apagar; // Valor de milis para apagar. digitalWrite (Azul, HIGH); // Enciende el led azul. digitalWrite(Cerrar, HIGH); // Giro del motor a la izquierda. Serial.println("Cerrando..."); // Muestra el texto de cerrando

} } EstadoAnterior=EstadoActual; if (millis()>T_Control && T_Control>0){// Finalizo el tiempo y lo estamos controlando?. digitalWrite (Azul, LOW); // Apagar el led azul. digitalWrite(Cerrar, LOW); // Apagar el motor. T_Control=0; // Dejamos de controlar. } EstadoActual1=val1; if (EstadoActual1 != EstadoAnterior1){ // Estado ha variado?. if(EstadoActual1 == 1 && EstadoAnterior1 == 0){ T_Control1 = millis()+T_Apagar1; // Valor de milis para apagar. digitalWrite (Azul, HIGH); // Encendemos el led azul. digitalWrite(Cerrar1, HIGH); // Giro del motor a la izquierda. Serial.println("Cerrando..."); // Muestra el texto cerrando.







Hoja 35

} } EstadoAnterior1=EstadoActual1; if (millis()>T_Control1 && T_Control1>0){// Finalizo el tiempo y lo estamos controlando. digitalWrite (Azul, LOW); // Apagar el led azul. digitalWrite(Cerrar1, LOW); // Apagar el motor T_Control1=0; // Dejamos de controlar. }

}

Anexo 5. El presente proyecto aún puede tener más modificaciones y aplicaciones, por el momento el registro de usuarios se realiza por código, se intentó por medio de archivo txt, haciendo uso de un lector de memorias SD, pero al usar este módulo comparte pines (RST (reset), MOSI, MISO), en conjunto con los dos módulos RFID por consecuente se crean conflictos, pero se puede usar por medio de base de datos en el cual podemos tener mayor control de los usuarios, también podríamos saber la hora que entrada y salida de cada usuario, así como el nombre y fecha el que es usuario acceso, este proyecto fue pensado para la entrada del estacionamiento del campus, también se puede implementar para entrar a los distintos laboratorios de nuestro campus y con ello tener mayor control en ellos.







Hoja 36

Control de Versiones del Documento

Fecha Versión Descripción Autor

18/09/2019 1 En esta primera versión se aclararon dudas de la realización del documento como sus partes y la forma de redacción.

José Ricardo Parga Olvera

02/09/2019 2 Aclaramos la forma de realización de la estructura de desglose del proyecto ya que lo estaba realizando de forma incorrecta y los anexos que aún no contaba con ninguno.


30/10/2019 3 Correcciones ortográficas y agregar el título de anexos

en una hoja con letra grande, así como agregar fotografías de maqueta y corrección en

él diagrama de gantt.


13/11/2019 4 Se realizaron cambios de redacción en la descripción

del proyecto.


control de acceso para estacionamiento de la …

Documents