Академический Документы
Профессиональный Документы
Культура Документы
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
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
▪ 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.
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).
#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
uint8_t successRead; // Variable integer to keep if we have Successful Read from Reader
//If you set Antenna Gain to Max it will increase reading distance
//mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max);
//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
}
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
}
}