Está en la página 1de 28

UNIVERSIDAD NACIONAL DE INGENIERÍA

FACULTAD DE INGENIERÍA GEOLÓGICA, MINERA Y


METALÚRGICA

Arduino - PLC

Curso:
• Ingeniería Eléctrica
Docente:
• Ing. Juan Carlos Guerrero
Villalba
Integrantes:

• Carolina Colquichagua
Palacin
20160560I
• Leandro Ayala Ramirez
20160581F
• Roger Noel Cubas Ramón
20160779K

2018 - 2
Introducción
La cerradura inteligente es uno de los desarrollos más útiles de las viviendas que hacen de la
tecnología su mayor aliado. Esta innovación evitará que, por ejemplo, tengas que llamar a un
cerrajero y pagar sus elevados honorarios.

La domótica ya no es tan desconocida como antes. Aunque los proyectos integrales siguen
teniendo una cuantía muy elevada, hay pequeños automatismos cuya implantación resulta
sencilla o poco costosa. Además, el hecho de apoyarse en la tecnología para tener una vida
más cómoda de puertas adentro es una tendencia cada vez más extendida, por lo que la oferta
sube y los precios se democratizan.
Objetivos

1. Utilizar la tarjeta RFID para abrir una cerradura.


2. Realizar un sistema de comunicación al Arduino, para que permanezca abierto y
cerrado(de manera natural) un sistema.
3. Crear un sistema de usuarios que nos permita tener en registro en el programa del
Arduino Software.
Fundamento Teórico
¿Qué es arduino?

Arduino es una plataforma de prototipos electrónica de código abierto (open-source) basada


en una sencilla placa con entradas y salidas, en un entorno de desarrollo que está basado en el
lenguaje de programación Processing. Es un dispositivo que conecta el mundo físico con el
mundo virtual, o el mundo analógico con el digital.

Partes de un arduino

El arduino como todo componente esta conformado distintas partes como son entradas,
salidas, alimentación, comunicación y shields.

• Entradas

Son los pines de nuestra placa que podemos utilizar para hacer lecturas. En la placa Uno son
los pines digitales (del 0 al 13) y los analógicos (del A0 al A5).

• Salidas

Los pines de salidas se utilizan para el envío de señales. En este caso los pines de salida son
sólo los digitales (0 a 13).

• Otros pines

También tenemos otros pines como los GND (tierra), 5V que proporciona 5 Voltios, 3.3V que
proporciona 3.3 Voltios, los pines REF de referencia de voltaje, TX (transmisión) y RX (lectura)
también usados para comunicación serial, RESET para resetear, Vin para alimentar la placa y
los pines ICSP para comunicación SPI.

• Alimentación

Como hemos visto el pin Vin sirve para alimentar la placa pero lo más normal es alimentarlo
por el jack de alimentación usando una tensión de 7 a 12 Voltios. También podemos
alimentarlo por el puerto USB pero en la mayoría de aplicaciones no lo tendremos conectado a
un ordenador.

• Comunicación

En nuestros tutoriales nos comunicaremos con Arduino mediante USB para cargar los
programas o enviar/recibir datos. Sin embargo no es la única forma que tiene Arduino de
comunicarse. Cuando insertamos una shield ésta se comunica con nuestra placa utilizando los
pines ICSP (comunicación ISP), los pines 10 a 13 (también usados para comunicación ISP), los
pines TX/RX o cualquiera de los digitales ya que son capaces de configurarse como pines de
entrada o salida y recibir o enviar pulsos digitales.

• Shields

Se llama así a las placas que se insertan sobre Arduino a modo de escudo ampliando sus
posibilidades de uso. En el mercado existen infinidad de shields para cada tipo de Arduino.
Algunas de las más comunes son las de Ethernet, Wi-Fi, Ultrasonidos, Pantallas LCD, relés,
matrices LED’s, GPS.

Arduino está constituido en el hardware por un micro controlador principal llamado Atmel AVR
de 8 bits (que es programable con un lenguaje de alto nivel), presente en la mayoría de los
modelos de Arduino.

Las características generales de todas las placas Arduino son las siguientes:

▪ El microprocesador ATmega328
▪ 32 kbytes de memoria Flash
▪ 1 kbyte de memoria RAM
▪ 16 MHz
▪ 13 pins para entradas/salidas digitales (programables)
▪ 5 pins para entradas analógicas
▪ 6 pins para salidas analógicas (salidas PWM)
▪ Completamente autónomo: Una vez programado no necesita estar
▪ conectado al PC
▪ Microcontrolador ATmega328
▪ Voltaje de operación 5V
▪ Voltaje de entrada (recomendado) 7-12 V
▪ Voltaje de entrada (limite) 6-20 V
▪ Digital I/O Pins 14 (con 6 salidas PWM)
▪ Entradas analógicas Pins 6
▪ DC corriente I/O Pin 40 mA
▪ DC corriente 3.3V Pin 50 mA
▪ Memoria Flash 32 KB (2 KB para el bootloader)
▪ SRAM 1 KB
▪ EEPROM 512 byte
▪ Velocidad de reloj 16 MHz

¿Cómo funciona arduino?

▪ El Arduino es una placa basada en un microcontrolador, específicamente un ATMEL. Un


microcontrolador es un circuito integrado (podríamos hablar de un microhip) en el cual se
pueden grabar instrucciones. Estas instrucciones se escriben utilizando un lenguaje de
programación que permite al usuario crear programas que interactúan con circuitos
electrónicos.

▪ Normalmente un microcontrolador posee entradas y salidas digitales, entradas y salidas


analógicas y entradas y salidas para protocolos de comunicación. Un Arduino es una placa que
cuenta con todos los elementos necesarios para conectar periféricos a las entradas y salidas
del microcontrolador. Se trata de una placa impresa con todos los componentes necesarios
para el funcionamiento del micro y su comunicación con una computadora a través de
comunicación serial.

▪ La comunicación serial es un protocolo de comunicación que alguna vez fue muy utilizado a
través de los puertos serie que traían las computadoras de antaño.
Existen diferentes modelos de Arduino, con múltiples características en cuanto a tamaño,
formas, funciones y precios.
Lectores RFID:
Es el que usaremos en este experimento, este módulo funciona como Lector y
Grabador de Tags RFID.

Módulo RFID RC522

Este módulo utiliza un sistema de modulación y demodulación de 13.56MHz,


frecuencia que en la actualidad utiliza la tecnología RFID.
¿Qué es un Protoboard?
La Protoboard, llamada en inglés breadboard, es una
placa de pruebas en los que se pueden insertar elementos
electrónicos y cables con los que se arman circuitos sin la
necesidad de soldar ninguno de los componentes. Las
Protoboards tienen orificios conectados entre si por
medio de pequeñas laminas metálicas. Usualmente, estas
placas siguen un arreglo en el que los orificios de una
misma fila están conectados entre sí y los orificios en filas
diferentes no. Los orificios de las placas normalmente
están tienen una separación de 2.54 milímetros (0.1
pulgadas).
Una Protoboard es un instrumento que permite probar el diseño de un circuito sin la
necesidad de soldar o desoldar componentes. Las conexiones en una Protoboard se hacen con
solo insertar los componentes lo que permite armar y modificar circuitos con mayor velocidad.
Normalmente estas placas son usadas para realizar pruebas experimentales. Si la prueba
resulta satisfactoria el circuito se construye de una forma más permanente para evitar el
riesgo de que algún componente pueda desconectarse. En caso de que la prueba no sea
satisfactoria, puede modificarse el circuito fácilmente.
Las Protoboards tienen tres partes: el canal central, las pistas, y los buses. En el canal central,
ubicado en la parte media, se conectan los circuitos integrados para mantener aislados los
pines de ambos lados del circuito integrado. Los buses se encuentran en los lados de la
Protoboard, y generalmente se emplean para conectar la tierra del circuito y su voltajes de
alimentación. La mayoría de las veces los buses están indicados con franjas color negro o azul
para indicar el bus de tierra, y con franjas color rojo para indicar el bus de voltaje positivo. El
resto de los orificios de la Protoboard pertenecen a las pistas. Como se mencionó
anteriormente, las pistas están separadas por filas. Las filas están indicadas con números y las
columnas están indicadas con letras
Las Protoboards presentan algunas ventajas y desventajas. Entre sus principales ventajas esta
que pueden utilizarse tantas veces como se requiera y que son de fácil manejo. Por otra parte,
entre sus desventajas está el inconveniente de que en ocasiones puede haber falsos contactos,
los cables empleados pueden tener mala conductividad o estar rotos, lo que hace que las
conexiones no sean tan seguras como las de las pistas de un circuito impreso. Otra
característica que hay que tomar en cuenta es que las Protoboards no están diseñadas para
trabajar con componentes de gran potencia.
La corriente con la que puede operar una Protoboard varía entre 3 y 5 A, y esto depende del
fabricante. Suelen operar a bajas frecuencias, entre 10 – 20 MHz.
Es importante mencionar que en inglés, se entiende por Protoboard, una placa prefabricada
para soldar componentes, en México se suele llamar a este tipo de componentes por el
nombre de placas fenólicas perforadas.
PROGRAMACIÓN
La programación desarrollada en el IDE de Arduino utiliza la librería MFRC522 para el uso de
lectores RFID RC522 y la librería SPI permite realizar la comunicación con el lector RFID.
Materiales
a) Arduino UNO
b) Lector RFID-RC522A con su respectiva llave y tarjeta
c) Una cerradura electrónica de alimentación de 12 o 24Voltios
d) Un Rele 10V-30V
e) Una resistencia de 470 Ω
f) Tres diodos LED (Rojo, Verde y Amarillo)
g) Protoboard
h) Bombilla
i) Fuente de corriente alterna (el enchufe)
j) Cables

Desarrollo
TARJETAS RFID (TAGS)

Los Tags tienen internamente una antena y un microchip, encargado de realizar todo el
proceso de comunicación, la energía lo obtiene de la señal de radiofrecuencia, que si bien la
energía en la señal es pequeña, es suficiente para hacer trabajar el microchip, esto es la razón
por la que es necesario acercarlos a una pequeña distancia generalmente menor a 10 cm. Pero
existen Tags activos, que incorporan baterías, estos tiene alcance de varios metros de
distancia.
Estos lectores realizan un sistema de modulación y demodulación de 13.56MHz, frecuencia
que en la actualidad utiliza la tecnología RFID.
EL módulo se comunica por SPI, por lo que se puede implementar con cualquier
microcontrolador con interfaz SPI, como un Arduino.

LECTURA DE TAGS

El lector RFID RC522A realiza la lectura de las tarjetas y llaves magnética (tags) mediante sus
códigos hexadecimales, es decir cada tag posee su propio código hexadecimal del siguiente
tamaño: 0xC3, 0xF7, 0xDB, 0x00, 0xFF, 0xFF.

Cada lector viene con un par de tags, pero en este proyecto se incorpora una sentencia de
código para la lectura de múltiples tarjetas, es decir el usuario tiene la opción de acceder al
sistema mediante diferentes tags. Pero para el caso de la lectura de tarjetas incorrectas
ejecuta una sentencia de bloqueo, esta no permite realizar ninguna acción por parte del
usuario durante un cierto tiempo definido.

La lectura de cada código lo realiza mediante comunicación SPI (Serial peripheral interface).

Durante la lectura de una tarjeta, Arduino permite realizar la acción de bloquear o acceder a
un usuario al sistema. En el caso de permitir acceder al sistema, Arduino activa una cerradura
electrónica de 12 o 24 Voltios a través de un RELE durante unos segundos y encenderá un Led
verde como indicador de tarjeta correcta. En el caso de bloqueo, dos led (verde y rojo)
parpadearán alternadamente como señal de sistema bloqueado, esta acción ocurre cuando un
usuario intento acceder por tres veces seguidas al sistema con una tarjeta incorrecta. Antes del
bloqueo del sistema, cuando el lector lea un tag incorrecto, el Led rojo parpadeará como señal
de advertencia (tag incorrecto el sistema se bloqueará si sigue intentando con el mismo tag).

Esquemático del Proyecto o Control de accesos

Programación mediante arduino

#include <EEPROM.h> // We are going to read and write PICC's UIDs from/to EEPROM
#include <SPI.h> // RC522 Module uses SPI protocol
#include <MFRC522.h> // Library for Mifare RC522 Devices
#define COMMON_ANODE

#ifdef COMMON_ANODE
#define LED_ON LOW
#define LED_OFF HIGH
#else
#define LED_ON HIGH
#define LED_OFF LOW
#endif
#define redLed 7 // Set Led Pins
#define greenLed 6
#define blueLed 5

#define relay 4 // Set Relay Pin


#define wipeB 3 // Button pin for WipeMode

bool programMode = false; // initialize programming mode to false

uint8_t successRead; // Variable integer to keep if we have Successful Read from Reader

byte storedCard[4]; // Stores an ID read from EEPROM


byte readCard[4]; // Stores scanned ID read from RFID Module
byte masterCard[4]; // Stores master card's ID read from EEPROM

// Create MFRC522 instance.


#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN);

///////////////////////////////////////// Setup ///////////////////////////////////


void setup() {
//Arduino Pin Configuration
pinMode(redLed, OUTPUT);
pinMode(greenLed, OUTPUT);
pinMode(blueLed, OUTPUT);
pinMode(wipeB, INPUT_PULLUP); // Enable pin's pull up resistor
pinMode(relay, OUTPUT);
//Be careful how relay circuit behave on while resetting or power-cycling your Arduino
digitalWrite(relay, HIGH); // Make sure door is locked
digitalWrite(redLed, LED_OFF); // Make sure led is off
digitalWrite(greenLed, LED_OFF); // Make sure led is off
digitalWrite(blueLed, LED_OFF); // Make sure led is off
//Protocol Configuration
Serial.begin(9600); // Initialize serial communications with PC
SPI.begin(); // MFRC522 Hardware uses SPI protocol
mfrc522.PCD_Init(); // Initialize MFRC522 Hardware

//If you set Antenna Gain to Max it will increase reading distance
//mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max);

Serial.println(F("Acceso de Control v0.1")); // For debugging purposes


ShowReaderDetails(); // Show details of PCD - MFRC522 Card Reader details

//Wipe Code - If the Button (wipeB) Pressed while setup run (powered on) it wipes EEPROM
if (digitalRead(wipeB) == LOW) { // when button pressed pin should get low, button
connected to ground
digitalWrite(redLed, LED_ON); // Red Led stays on to inform user we are going to wipe
Serial.println(F("Boton de Limpieza Presionado"));
Serial.println(F("Tienes 10 Segundos para Cancelar"));
Serial.println(F("Esto eliminará todos los registros y no se podrá deshacer."));
bool buttonState = monitorWipeButton(10000); // Give user enough time to cancel
operation
if (buttonState == true && digitalRead(wipeB) == LOW) { // If button still be pressed, wipe
EEPROM
Serial.println(F("Empezando a Limpiar EEPROM"));
for (uint16_t x = 0; x < EEPROM.length(); x = x + 1) { //Loop end of EEPROM address
if (EEPROM.read(x) == 0) { //If EEPROM address 0
// do nothing, already clear, go to the next address in order to save time and reduce
writes to EEPROM
}
else {
EEPROM.write(x, 0); // if not write 0 to clear, it takes 3.3mS
}
}
Serial.println(F("EEPROM Eliminado con Exito"));
digitalWrite(redLed, LED_OFF); // visualize a successful wipe
delay(200);
digitalWrite(redLed, LED_ON);
delay(200);
digitalWrite(redLed, LED_OFF);
delay(200);
digitalWrite(redLed, LED_ON);
delay(200);
digitalWrite(redLed, LED_OFF);
}
else {
Serial.println(F("Limpieza Cancelada")); // Show some feedback that the wipe button did
not pressed for 15 seconds
digitalWrite(redLed, LED_OFF);
}
}
// Check if master card defined, if not let user choose a master card
// This also useful to just redefine the Master Card
// You can keep other EEPROM records just write other than 143 to EEPROM address 1
// EEPROM address 1 should hold magical number which is '143'
if (EEPROM.read(1) != 143) {
Serial.println(F("Sin Tarjeta Definida"));
Serial.println(F("Escanee un PICC para definir como Tarjeta"));
do {
successRead = getID(); // sets successRead to 1 when we get read from reader
otherwise 0
digitalWrite(blueLed, LED_ON); // Visualize Master Card need to be defined
delay(200);
digitalWrite(blueLed, LED_OFF);
delay(200);
}
while (!successRead); // Program will not go further while you not get a successful
read
for ( uint8_t j = 0; j < 4; j++ ) { // Loop 4 times
EEPROM.write( 2 + j, readCard[j] ); // Write scanned PICC's UID to EEPROM, start from
address 3
}
EEPROM.write(1, 143); // Write to EEPROM we defined Master Card.
Serial.println(F("Tarjeta Definida"));
}
Serial.println(F("-------------------"));
Serial.println(F("Tarjeta UID"));
for ( uint8_t i = 0; i < 4; i++ ) { // Read Master Card's UID from EEPROM
masterCard[i] = EEPROM.read(2 + i); // Write it to masterCard
Serial.print(masterCard[i], HEX);
}
Serial.println("");
Serial.println(F("-------------------"));
Serial.println(F("Todo está Listo"));
Serial.println(F("PICs en espera para ser escaneados"));
cycleLeds(); // Everything ready lets give user some feedback by cycling leds
}

///////////////////////////////////////// Main Loop ///////////////////////////////////


void loop () {
do {
successRead = getID(); // sets successRead to 1 when we get read from reader otherwise 0
// When device is in use if wipe button pressed for 10 seconds initialize Master Card wiping
if (digitalRead(wipeB) == LOW) { // Check if button is pressed
// Visualize normal operation is iterrupted by pressing wipe button Red is like more
Warning to user
digitalWrite(redLed, LED_ON); // Make sure led is off
digitalWrite(greenLed, LED_OFF); // Make sure led is off
digitalWrite(blueLed, LED_OFF); // Make sure led is off
// Give some feedback
Serial.println(F("oton de Limpieza Presionado"));
Serial.println(F("¡La Tarjeta será borrada! en 10 segundos"));
bool buttonState = monitorWipeButton(10000); // Give user enough time to cancel
operation
if (buttonState == true && digitalRead(wipeB) == LOW) { // If button still be pressed, wipe
EEPROM
EEPROM.write(1, 0); // Reset Magic Number.
Serial.println(F("Tarjeta borrada del dispositivo"));
Serial.println(F("Por favor, reinicie para reprogramar la tarjeta"));
while (1);
}
Serial.println(F("Borrado de Tarjeta Cancelado"));
}
if (programMode) {
cycleLeds(); // Program Mode cycles through Red Green Blue waiting to read a new
card
}
else {
normalModeOn(); // Normal mode, blue Power LED is on, all others are off
}
}
while (!successRead); //the program will not go further while you are not getting a
successful read
if (programMode) {
if ( isMaster(readCard) ) { //When in program mode check First If master card scanned again
to exit program mode
Serial.println(F("Tarjeta Escaneada"));
Serial.println(F("Saliendo del modo de programa"));
Serial.println(F("-----------------------------"));
programMode = false;
return;
}
else {
if ( findID(readCard) ) { // If scanned card is known delete it
Serial.println(F("Conozco este PICC, eliminando ..."));
deleteID(readCard);
Serial.println("-----------------------------");
Serial.println(F("Escanee un PICC para AGREGAR o QUITARSE a EEPROM"));
}
else { // If scanned card is not known add it
Serial.println(F("No conozco este PICC, agregando ..."));
writeID(readCard);
Serial.println(F("-----------------------------"));
Serial.println(F("Escanee un PICC para AGREGAR o QUITARSE a EEPROM"));
}
}
}
else {
if ( isMaster(readCard)) { // If scanned card's ID matches Master Card's ID - enter program
mode
programMode = true;
Serial.println(F("Hola Usuario - Modo de programa ingresado"));
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that
Serial.print(F("Yo tengo ")); // stores the number of ID's in EEPROM
Serial.print(count);
Serial.print(F(" registro(s) en EEPROM"));
Serial.println("");
Serial.println(F("Escanee un PICC para AGREGAR o QUITARSE a EEPROM"));
Serial.println(F("Escanear Tarjeta de nuevo para salir del modo de programa"));
Serial.println(F("-----------------------------"));
}
else {
if ( findID(readCard) ) { // If not, see if the card is in the EEPROM
Serial.println(F("Bienvenido puedes Pasar"));
granted(300); // Open the door lock for 300 ms
}
else { // If not, show that the ID was not valid
Serial.println(F("No puedes pasar"));
denied();
}
}
}
}

///////////////////////////////////////// Access Granted ///////////////////////////////////


void granted ( uint16_t setDelay) {
digitalWrite(blueLed, LED_OFF); // Turn off blue LED
digitalWrite(redLed, LED_OFF); // Turn off red LED
digitalWrite(greenLed, LED_ON); // Turn on green LED
digitalWrite(relay, LOW); // Unlock door!
delay(5000); // Hold door lock open for given seconds
digitalWrite(relay, HIGH); // Relock door
delay(1000); // Hold green LED on for a second
}

///////////////////////////////////////// Access Denied ///////////////////////////////////


void denied() {
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
digitalWrite(redLed, LED_ON); // Turn on red LED
delay(1000);
}

///////////////////////////////////////// Get PICC's UID ///////////////////////////////////


uint8_t getID() {
// Getting ready for Reading PICCs
if ( ! mfrc522.PICC_IsNewCardPresent()) { //If a new PICC placed to RFID reader continue
return 0;
}
if ( ! mfrc522.PICC_ReadCardSerial()) { //Since a PICC placed get Serial and continue
return 0;
}
// There are Mifare PICCs which have 4 byte or 7 byte UID care if you use 7 byte PICC
// I think we should assume every PICC as they have 4 byte UID
// Until we support 7 byte PICCs
Serial.println(F("UID del PICC escaneado:"));
for ( uint8_t i = 0; i < 4; i++) { //
readCard[i] = mfrc522.uid.uidByte[i];
Serial.print(readCard[i], HEX);
}
Serial.println("");
mfrc522.PICC_HaltA(); // Stop reading
return 1;
}

void ShowReaderDetails() {
// Get the MFRC522 software version
byte v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg);
Serial.print(F("MFRC522 Software Version: 0x"));
Serial.print(v, HEX);
if (v == 0x91)
Serial.print(F(" = v1.0"));
else if (v == 0x92)
Serial.print(F(" = v2.0"));
else
Serial.print(F(" (desconocido), probablemente un clon chino?"));
Serial.println("");
// When 0x00 or 0xFF is returned, communication probably failed
if ((v == 0x00) || (v == 0xFF)) {
Serial.println(F("ADVERTENCIA: Fallo de comunicación, ¿el MFRC522 está correctamente
conectado?"));
Serial.println(F("SISTEMA HALTADO: Revise las conexiones."));
// Visualize system is halted
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
digitalWrite(redLed, LED_ON); // Turn on red LED
while (true); // do not go further
}
}

///////////////////////////////////////// Cycle Leds (Program Mode)


///////////////////////////////////
void cycleLeds() {
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
delay(200);
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
delay(200);
digitalWrite(redLed, LED_ON); // Make sure red LED is on
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
delay(200);
}

//////////////////////////////////////// Normal Mode Led ///////////////////////////////////


void normalModeOn () {
digitalWrite(blueLed, LED_ON); // Blue LED ON and ready to read card
digitalWrite(redLed, LED_OFF); // Make sure Red LED is off
digitalWrite(greenLed, LED_OFF); // Make sure Green LED is off
digitalWrite(relay, HIGH); // Make sure Door is Locked
}

//////////////////////////////////////// Read an ID from EEPROM //////////////////////////////


void readID( uint8_t number ) {
uint8_t start = (number * 4 ) + 2; // Figure out starting position
for ( uint8_t i = 0; i < 4; i++ ) { // Loop 4 times to get the 4 Bytes
storedCard[i] = EEPROM.read(start + i); // Assign values read from EEPROM to array
}
}

///////////////////////////////////////// Add ID to EEPROM ///////////////////////////////////


void writeID( byte a[] ) {
if ( !findID( a ) ) { // Before we write to the EEPROM, check to see if we have seen this card
before!
uint8_t num = EEPROM.read(0); // Get the numer of used spaces, position 0 stores the
number of ID cards
uint8_t start = ( num * 4 ) + 6; // Figure out where the next slot starts
num++; // Increment the counter by one
EEPROM.write( 0, num ); // Write the new count to the counter
for ( uint8_t j = 0; j < 4; j++ ) { // Loop 4 times
EEPROM.write( start + j, a[j] ); // Write the array values to EEPROM in the right position
}
successWrite();
Serial.println(F("Registro de ID agregado exitosamente a la EEPROM"));
}
else {
failedWrite();
Serial.println(F("¡Ha fallado! Hay algo mal con ID o EEPROM mal"));
}
}

///////////////////////////////////////// Remove ID from EEPROM


///////////////////////////////////
void deleteID( byte a[] ) {
if ( !findID( a ) ) { // Before we delete from the EEPROM, check to see if we have this card!
failedWrite(); // If not
Serial.println(F("¡Ha fallado! Hay algo mal con ID o EEPROM mal"));
}
else {
uint8_t num = EEPROM.read(0); // Get the numer of used spaces, position 0 stores the
number of ID cards
uint8_t slot; // Figure out the slot number of the card
uint8_t start; // = ( num * 4 ) + 6; // Figure out where the next slot starts
uint8_t looping; // The number of times the loop repeats
uint8_t j;
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that stores number of
cards
slot = findIDSLOT( a ); // Figure out the slot number of the card to delete
start = (slot * 4) + 2;
looping = ((num - slot) * 4);
num--; // Decrement the counter by one
EEPROM.write( 0, num ); // Write the new count to the counter
for ( j = 0; j < looping; j++ ) { // Loop the card shift times
EEPROM.write( start + j, EEPROM.read(start + 4 + j)); // Shift the array values to 4 places
earlier in the EEPROM
}
for ( uint8_t k = 0; k < 4; k++ ) { // Shifting loop
EEPROM.write( start + j + k, 0);
}
successDelete();
Serial.println(F("Registro de ID eliminado exitosamente de la EEPROM"));
}
}

///////////////////////////////////////// Check Bytes ///////////////////////////////////


bool checkTwo ( byte a[], byte b[] ) {
for ( uint8_t k = 0; k < 4; k++ ) { // Loop 4 times
if ( a[k] != b[k] ) { // IF a != b then false, because: one fails, all fail
return false;
}
}
return true;
}

///////////////////////////////////////// Find Slot ///////////////////////////////////


uint8_t findIDSLOT( byte find[] ) {
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that
for ( uint8_t i = 1; i <= count; i++ ) { // Loop once for each EEPROM entry
readID(i); // Read an ID from EEPROM, it is stored in storedCard[4]
if ( checkTwo( find, storedCard ) ) { // Check to see if the storedCard read from EEPROM
// is the same as the find[] ID card passed
return i; // The slot number of the card
}
}
}

///////////////////////////////////////// Find ID From EEPROM


///////////////////////////////////
bool findID( byte find[] ) {
uint8_t count = EEPROM.read(0); // Read the first Byte of EEPROM that
for ( uint8_t i = 1; i < count; i++ ) { // Loop once for each EEPROM entry
readID(i); // Read an ID from EEPROM, it is stored in storedCard[4]
if ( checkTwo( find, storedCard ) ) { // Check to see if the storedCard read from EEPROM
return true;
}
else { // If not, return false
}
}
return false;
}

///////////////////////////////////////// Write Success to EEPROM


///////////////////////////////////
// Flashes the green LED 3 times to indicate a successful write to EEPROM
void successWrite() {
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
digitalWrite(greenLed, LED_OFF); // Make sure green LED is on
delay(200);
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
delay(200);
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
delay(200);
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
delay(200);
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
delay(200);
digitalWrite(greenLed, LED_ON); // Make sure green LED is on
delay(200);
}

///////////////////////////////////////// Write Failed to EEPROM


///////////////////////////////////
// Flashes the red LED 3 times to indicate a failed write to EEPROM
void failedWrite() {
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
delay(200);
digitalWrite(redLed, LED_ON); // Make sure red LED is on
delay(200);
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
delay(200);
digitalWrite(redLed, LED_ON); // Make sure red LED is on
delay(200);
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
delay(200);
digitalWrite(redLed, LED_ON); // Make sure red LED is on
delay(200);
}

///////////////////////////////////////// Success Remove UID From EEPROM


///////////////////////////////////
// Flashes the blue LED 3 times to indicate a success delete to EEPROM
void successDelete() {
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
digitalWrite(redLed, LED_OFF); // Make sure red LED is off
digitalWrite(greenLed, LED_OFF); // Make sure green LED is off
delay(200);
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
delay(200);
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
delay(200);
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
delay(200);
digitalWrite(blueLed, LED_OFF); // Make sure blue LED is off
delay(200);
digitalWrite(blueLed, LED_ON); // Make sure blue LED is on
delay(200);
}

////////////////////// Check readCard IF is masterCard ///////////////////////////////////


// Check to see if the ID passed is the master programing card
bool isMaster( byte test[] ) {
return checkTwo(test, masterCard);
}

bool monitorWipeButton(uint32_t interval) {


uint32_t now = (uint32_t)millis();
while ((uint32_t)millis() - now < interval) {
// check on every half a second
if (((uint32_t)millis() % 500) == 0) {
if (digitalRead(wipeB) != LOW)
return false;
}
}
return true;
}
Conclusiones
• En la actualidad se emplea esta experiencia en puertas hasta en servicio de
metropolitano.
• Para mejorar la experiencia se le puede añadir más llaves.
• Una de las ventajas de este proyecto es que mediante este sistema se puede bloquear
el paso de la llave con la tarjeta en caso que se utilice como usuario y este se haya
extraviado.
• Se verifica que para la operación diseñada del Arduino puede ensamblarse
directamente sin necesidad del Protoboard.
• La duración de apertura para el paso de entrada o salida es de aproximadamente de 4
segundos.
Bibliografía
http://www.ingmecafenix.com/electronica/arduino/
https://blog.330ohms.com/2016/03/02/protoboards/
https://naylampmechatronics.com/blog/22_Tutorial-Lector-RFID-RC522.html
https://ecuduino.wordpress.com/cerradura-electronica-rfid/