Repository navigation
Pliego de condiciones
La maqueta consiste en la simulación de un parking real a escala, necesitando simular solo una pequeña cantidad de plazas, en este caso 3 plazas. El parking posee una entrada con una barrera, que controlara el acceso y además, contará con una pantalla LCD 16x2 que arrojara datos al usuario que desee entrar, entre los datos que se muestran en ella se encuentra:
- Temperatura y humedad del parking
- Plazas libres y ocupadas
- Acceso permitido o negación del acceso al parking (controlado por el sensor RFID)
Los datos que se obtendrán para comprobar la efectividad de la maqueta y del servicio que se propone complementar son los siguientes:
- Cuando un usuario accede al parking y cuando lo deja
- Que usuario accede al parking y quien lo deja ( Nombre, Apellido, datos bancarios)
- Tiempo de ocupación de las plazas
- El estado de las plazas
- Temperatura del parking
- Humedad del parking
- Sistema de seguridad en caso de incendios
- Sistema de seguridad de control de parking
El material usado para la construcción de la madera es mayormente madera.
El suelo estará construido con un tablón de aglomerado con una dimensión de 60 x 40 x 1 cm, el techo de la maqueta y la superficie en la que se apoyara toda la circuitería también será un tablón de aglomerado con una dimensión de 40 x 40 x 1 cm.
Las paredes estarán construidas con 3 tableros de contrachapado con unas dimensiones de 40 x 30 x 0,5 cm.
Como se mencionaba en el primer párrafo, no toda la maqueta estará construida con madera, se usara por tanto en el techo superior de la maqueta y el lateral derecho unas láminas de metacrilato para poder visualizar la circuitería y el interior, respectivamente, de la maqueta, estas laminas tienen una dimensiones de 40 x 40 x 0,4 cm y 40 x 30 x 0,4 cm respectivamente.
En el exterior de la maqueta ira situada la barrera, que controlara el acceso al parking. Esta barrera estará formada por un servomotor, led’s de indicación, un zumbador y un módulo RFID. Para la construcción del bloque de la barrera y el bloque de la pantalla LCD, se usará madera contrachapada de un grosor de 0,5 cm.
Las dimensiones del bloque de la barrera son: 6,8 x 6 x 3,8 cm Las dimensiones del bloque de la pantalla LCD son: 8 x 4,5 x 2 cm
En el interior del parking, podremos encontrar 3 columnas, a modo de soportes para él entre-techo. En estas columnas irán situados los sensores IR TCRT5000/5000L.
En el entretecho encontraremos toda la circuitería del parking, donde se ubicara los siguientes componentes.
- Placa Arduino
- Sensores ultrasonido
- Relé
- Fichas de contacto de 6 mm
- Potenciómetro
- Resistencias
- Batería
El módulo HC – SR04 se trata de un transmisor y receptor de ondas ultrasónicas, con un rango de entre 2 cm y 400 cm.
El funcionamiento básico consiste en:
- Usando un disparador, lanzará una señal de 10us de nivel alto
- El modulo automáticamente lanzara 8 ondas de 40 KHz y detectara cualquier onda de retorno.
- La onda de retorno será detectada y con ella, se calculara el tiempo desde que salió hasta que se volvió a detectar. La fórmula usada para la obtención de la distancia será:
Distancia= (Tiempo de Nivel Alto x Velocidad del sonido) / 2
Tabla de parámetros HC-SR04
Rango y dimensiones de HC-SR04
Diagrama de tiempo
Lo que se observa en el diagrama de tiempo es como funciona exactamente el módulo HC-SR04
Al recibir un pulso de 10uS mediante la tecnología TTL, el modulo iniciara una secuencia de disparo de 8 ciclos de una señal de 40 KHz. Estos pulsos se tratan de una señal inaudible para el ser humano, que según avanzara se ira degradando. Al rebotar con una superficie y volver al módulo, esta señal es recibida y leída. La señal eco, tendrá un nivel dependiendo de la distancia que haya sido capaz de recorrer, y gracias a esto, es como podemos obtener la distancia con la formula ya mencionada.
Habrá 3 módulos HC-SR04 en la maqueta que cada uno de ellos ira encima de cada plaza del parking. Estos detectara si hay un cambio en la distancia que normalmente detecta y con ello, se podrá saber si hay algo debajo de ellos.
El sensor TCRT5000 y 5000L, se trata de un módulo compuesto por un emisor de infrarrojos y un fototransistor.
El funcionamiento básico consiste en:
-
El emisor de infrarrojos emite una señal en el rango de 950 nm, por lo tanto se trata de una señal invisible al ojo humano.
-
El fototransistor capta la señal provocando una tensión contraria a la de alimentación, la tensión contraria variara dependiendo de la cantidad de luz recibida del emisor lo que nos indicara la distancia.
Tabla de parámetros TCRT 5000/5000L
Diagrama y esquema de TCRT 5000/5000L
Arduino Mega 2560 es una placa microcontroladora basada en ATmega2560.
Características:
- Posee 54 pines digitales de entrada/salida ( 14 de ellos puede ser usados como salidas PWM)
- 16 pines analógicos de entrada
- 4 UART’s
- Un oscilador de cristal de cuarzo de 16 MHz
- Puerto USB
- Entrada de alimentación tipo Jack
- Botón de reinicio
- Dispositivo ICSP
Arduino cuenta con su propia IDE para desarrollar sus programas y cargarlos a una placa Arduino. La sintaxis del lenguaje de programación Arduino es una versión simplificada de C/C++. Para este proyecto se usara esta IDE aunque es posible programar una placa Arduino con otras IDE’s.
El módulo, modelo MFRC522, es una placa integrada con un lector y escritor IC de comunicación sin contacto de una frecuencia de 13,56 MHz. El módulo RC 522 usa un sistema avanzado de modulación y demodulación para todo tipo de dispositivos pasivos.
El funcionamiento básico consiste en:
- El módulo RFID posee un campo electromagnético. El modulo siempre está activo a la espera de datos.
- Al pasar un dispositivo compatible con la tecnológica RFID o NFC, el modulo reacciona y obtiene los datos del dispositivos.
- Los datos son enviados a la placa Arduino, donde se usaran del modo deseado por el programador.
Los TAGs viene en diferentes modelos, los más comunes son en tarjetas y en llaveros, pero también vienen como etiquetas adhesivas e incluso ya viene incrustados en algunos productos.
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.
El relé es un dispositivo electromagnético. Funciona como un interruptor controlado por un circuito eléctrico en el que, por medio de una bobina y un electroimán, se acciona un juego de uno o varios contactos que permiten abrir o cerrar otros circuitos eléctricos independientes. Es la definición básica de un relé común.
El modulo relé que usaremos tendrá 4 relé controlados por Arduino, mediante valores de tensión Altos y Bajos. Cada relé puede tener posiciones tanto NA como NC. Al recibir un valor de tensión, el relé se abrirá o cerrara.
La definición más extendida sobre las resistencias es que una resistencia es un elemento pasivo que disipa energía en forma de calor según la ley de Joule.
Para este proyecto, se necesitara una determinada cantidad de resistencias fijas de un valor determinado, para que ciertos componentes como los sensores de IR o los led’s funcionen correctamente y evitando que se deterioren.
La cantidad de resistencias y su capacidad vienen listadas a continuación:
- Resistencias de 220 Ω 10
- Resistencias de 4700 Ω 1
- Resistencias de 10 kΩ 3
Además se necesita de un potenciómetro, que consiste en una resistencia que puede variar su capacidad, con una capacidad de hasta 100 kΩ
Un led es un componente opto electrónico pasivo y, más concretamente, un diodo qué emite luz.
En este proyecto, los led’s serán usados con varios fines:
- Iluminación
- Estado de las plazas (libres u ocupadas)
- Indicador de acceso o negación de acceso
- Indicador de funcionamiento de la barrera
Para llevar a cabo cada misión, se ha decidido usar 2 tipos de led’s distintos.
- Para el caso de la iluminación de usaran led’s de color blanco de 5mm que operan con 3,6 v.
- Para los led de indicación, se usan unos led’s de 3mm y de colores verde y rojo.
Un servomotor (también llamado servo) es un dispositivo similar a un motor de corriente continua que tiene la capacidad de ubicarse en cualquier posición dentro de su rango de operación, y mantenerse estable en dicha posición.
El servomotor en este proyecto jugará el papel de hacer de barrera. El servomotor usado en la maqueta consta de 3 cables, siendo Positivo (Rojo), Negativo (Negro) y Control (Amarillo).
El control de un servomotor se realiza mediante PWM.
Para la ventilación se usara un ventilador común de 80mm de tamaño, este será alimentado con una batería de 7,8v independiente al sistema de alimentación del resto del circuito.
Placa-Servomotor
Placa-LCD
Placa-Led de ocupación
Placa-Sensor humedad
Placa-Módulo RFID
Placa-TCRT 5000/5000L
Placa-HC-SR04
Placa-Zumbadores
Placa-Ventilador + Relé
La placa Arduino Mega 2560 que será instalada en la maqueta, será el cerebro del parking. Será la encargada de manejar, controlar y dar energía a los diferentes componentes del sistema.
Sus funciones serán las siguientes:
- Control de plazas, mediante los sensores de ultrasonido (HC-SR04) e IR (TCRT 5000/5000L). Al usar 2 sensores por plazas, se disminuye la probabilidad de una mala lectura.
- Control de temperatura y humedad del parking con el sensor DHT-11. Gracias al sensor DHT-11 el código que ejecutara Arduino se podrá usar para identificar posibles incendios en caso de que la temperatura se eleve por encima de la temperatura máxima estándar de la época.
- Control del acceso al parking, mediante un servomotor, que hará de barrera y un módulo RFID que controlara esta barrera. Gracias al modo RFID, se puede tener una base de datos de usuarios que tenga permitido el acceso al parking, conociendo así, quienes han accedido al parking y durante cuanto han estado en él.
- Control de pantalla LCD. Esta pantalla indicara a los usuarios el estado del parking, sabiendo así, antes de entrar en él, si hay plazas ocupadas. También se mostrara información de la temperatura y la humedad y si se ha concedido o no, el acceso al parking.
- Control de ventilación e iluminación, que mediante un relé se conmutara dada ciertas circunstancias
/**********************************/
/* Librerias */
/**********************************/
#include <DHT.h>
#include <LiquidCrystal.h>
#include <SPI.h>
#include <MFRC522.h>
#include <Servo.h>
/**********************************/
/* Estructura para las plazas */
/**********************************/
typedef struct
{
/*********Datos del programa*******************/
/*Sensor Ultrasonido*/
int trigger;
int echo;
int IR;
/*Variable para la funcion temporizador*/
unsigned long temporizador;
/*LED de ocupacion
* Rojo: Ocupado
* Verde: Libre
*/
int LED_ROJO;
int LED_VERDE;
/*Variables para la funcion control_plaza
* Ocupada --> Indicara si los sensores han marcado una plaza como ocupada o libre.
* Ciclo --> Variable para controlar cuando empieza la ocupacion de una plaza y cuando termina.
* Activador --> Sin uso.
*/
bool ocupada;
bool ciclo;
bool activador;
/* Mediciones realizadas por los sensores de temparatura
* Temp = Temperatura
* Hum = Humedad
*/
int temp1;
int temp2;
int hum1;
int hum2;
/*********Datos para el usuario****************/
int temp_media;
int hum_media;
/*********Datos de usuarios****************/
unsigned long int tiempo_inicio;
unsigned long int tiempo_final;
unsigned long int tiempo_ocupacion;
bool dentro;
} datos;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*************************************************************************************************************/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**********************************/
/* Variables globales */
/**********************************/
#define CANT_PLAZAS 3
#define DHTTYPE 11
#define RST_PIN 5 //Pin 5 para el reset del RC522
#define SS_PIN 53 //Pin 53 para el SS (SDA) del RC522
#define LED_ACCESO 48
#define LED_NEGACION 49
MFRC522 mfrc522(SS_PIN, RST_PIN); ///Creamos el objeto para el RC522
/*********Variables para RFID****************/
/*
* Crear una estructura para manejar ilimitados usuarios.
*/
byte ActualUID[4]; //Almacenará el código del Tag leído
byte Usuario1[4] = {0x73, 0x20, 0x7B, 0x25} ; //Código Tarjeta Blanca
byte Usuario2[4] = {0xE6, 0x2B, 0xEE, 0x30} ; //Código Llavero Azul
byte Usuario3[4] = {}; // Espacio libre para un usuario mas
/*********Variables de la estructura de datos****************/
datos plaza[CANT_PLAZAS];
datos usuario[CANT_PLAZAS];
unsigned long tiempo = millis();
unsigned long TIEMPO_SENSOR = 0;
/*********Variables Zumbadores****************/
int alarma1;
int alarma2;
unsigned long encender = 0;
unsigned long apagar = 0;
unsigned long valor_encender = 200;
unsigned long valor_apagar = 400;
/*********Variables de temporizador LCD****************/
unsigned long lcd0 = 0;
unsigned long lcd1 = 3000;
unsigned long lcd2 = 6000;
unsigned long lcd3 = 9000;
/*********Pines RELE****************/
int rele1=36; // Iluminacion
int rele2=37; // Ventilacion
int rele3=38; // Luz de emergencias
int rele4=39; // Sin uso
/*********************************/
/* Variables de control */
/* mediante interfaz */
/*********************************/
bool iluminacion=false; // Variable de activacion
bool ventilacion=false; // Variable de activacion
bool alert=false; // Variable de activacion de alarma por interfaz
bool gate=false; // Variable de activacon barrera
bool aux=false; // Variable de activacion luces de emergencia
/*********************************/
/* Variables de control */
/* internas */
/*********************************/
bool temp=false; // Variable que controla la manera que funciona la funcion alarma
bool nuevo_plaza=false; // Variable de activacion. Para repintar LCD cuando se detecten nuevos datos.
bool alarm=false; // Variable de activacion para los sensores de temperatura
bool acceso=false; // Variable de acceso positivo
bool no_acceso=false; // Variable de acceso negativo
unsigned long t_acceso=0;
unsigned long ti_acceso=0;
unsigned long t_noacceso=0;
unsigned long ti_noacceso=0;
bool pause=false;
int c = 0;
DHT dht1(34, DHTTYPE);
DHT dht2(35, DHTTYPE);
LiquidCrystal lcd(42, 43, 44, 45, 46, 47);
Servo SERVO;
La función Setup(), es la primera arrancar, usada para inicializar variables, el modo de los pin, arrancar las librerías y algunas funciones más. Esta parte del código solo se ejecutara 1 vez.
Lo primero que se hará en el Setup, será iniciar la comunicación serie con la función Serial.begin() , con un valor de 9600 baudio.
La siguiente función se verá repetida de ahora en adelante, con el objetivo de mostrar información o saber dónde se encuentra en el código Arduino, esto se realiza mediante la función Serial.print(), esta información se mostrara a través de la consola del IDE.
Como se menciona al principio de este mismo apartado, el objetivo de Setup(), es inicializar y adjudicar valores a las distintas variables y pines de Arduino.
Para los pines se usaran 3 funciones distintas:
-
pinMode(PIN,INPUT/OUTPUT), esta función configurara el modo en el que un determinado pin funcionara, si como salida o entrada. -
digitalWrite()yanalogWrite(), estas 2 funciones , dependiendo de valor (HIGH o LOW), alimentaran los diferentes pins.
Para el resto de variables se iniciaran a mano, dando los valores de pin al que irán conectado de la placa. En el Main, además, se realizan varias operaciones de comprobación, para asegurar el buen funcionamiento de cada elemento del sistema.
/**********************************/
/* Main */
/**********************************/
void setup()
{
int iniciador;
Serial.begin(9600);
Serial.print("Inicializando programa...\n");
Serial.print("Adjudicando valor a variables\n");
plaza[0].ocupada = false;
plaza[0].ciclo = false;
plaza[0].activador = false;
plaza[1].ocupada = false;
plaza[1].ciclo = false;
plaza[1].activador = false;
plaza[2].ocupada = false;
plaza[2].ciclo = false;
plaza[2].activador = false;
for (iniciador = 0; iniciador < CANT_PLAZAS; iniciador++)
{
TIEMPO_SENSOR = TIEMPO_SENSOR + 2000;
plaza[iniciador].temporizador = TIEMPO_SENSOR;
TIEMPO_SENSOR = TIEMPO_SENSOR - 1000;
usuario[iniciador].temporizador = TIEMPO_SENSOR;
TIEMPO_SENSOR = TIEMPO_SENSOR + 1000;
usuario[iniciador].dentro=false;
}
Serial.print("Adjudicando PIN a las variables de los sensores HC-SR04 \n");
/*********Pin HC-SR04***************/
plaza[0].activador = true;
plaza[0].trigger = 22;
plaza[0].echo = 23;
plaza[1].trigger = 24;
plaza[1].echo = 25;
plaza[2].trigger = 26;
plaza[2].echo = 27;
Serial.print("Adjudicando PIN a las variables de los LED de ocupación \n");
/*********Pin de LED's**************/
plaza[0].LED_ROJO = 28;
plaza[0].LED_VERDE = 29;
plaza[1].LED_ROJO = 30;
plaza[1].LED_VERDE = 31;
plaza[2].LED_ROJO = 32;
plaza[2].LED_VERDE = 33;
Serial.print("Adjudicando PIN a las variables de los sensores TCRT5000 \n");
/*********Pin IR********************/
plaza[0].IR = A0;
plaza[1].IR = A1;
plaza[2].IR = A2;
Serial.print("Adjudicando PIN a las variables de los zumbadores \n");
/*********Pin Zumbador**************/
alarma1 = 12;
alarma2 = 13;
Serial.print("Configurando el funcionamiento de los pin's digitales \n");
/*****************Pines digitales***************/
/*********************************/
/* Sensores ultrasonido */
/* y */
/* LED's de ocupación */
/*********************************/
pinMode(plaza[0].trigger, OUTPUT);
pinMode(plaza[0].echo, INPUT);
pinMode(plaza[0].LED_ROJO, OUTPUT);
pinMode(plaza[0].LED_VERDE, OUTPUT);
pinMode(plaza[0].LED_ROJO, HIGH);
pinMode(plaza[0].LED_VERDE, HIGH);
pinMode(plaza[1].trigger, OUTPUT);
pinMode(plaza[1].echo, INPUT);
pinMode(plaza[1].LED_ROJO, OUTPUT);
pinMode(plaza[1].LED_VERDE, OUTPUT);
pinMode(plaza[1].LED_ROJO, HIGH);
pinMode(plaza[1].LED_VERDE, HIGH);
pinMode(plaza[2].trigger, OUTPUT);
pinMode(plaza[2].echo, INPUT);
pinMode(plaza[2].LED_ROJO, OUTPUT);
pinMode(plaza[2].LED_VERDE, OUTPUT);
pinMode(plaza[2].LED_ROJO, HIGH);
pinMode(plaza[2].LED_VERDE, HIGH);
digitalWrite(plaza[0].LED_ROJO, LOW);
digitalWrite(plaza[0].LED_VERDE, HIGH);
digitalWrite(plaza[1].LED_ROJO, LOW);
digitalWrite(plaza[1].LED_VERDE, HIGH);
digitalWrite(plaza[2].LED_ROJO, LOW);
digitalWrite(plaza[2].LED_VERDE, HIGH);
delay(500);
digitalWrite(plaza[0].LED_ROJO, HIGH);
digitalWrite(plaza[0].LED_VERDE, LOW);
digitalWrite(plaza[1].LED_ROJO, HIGH);
digitalWrite(plaza[1].LED_VERDE, LOW);
digitalWrite(plaza[2].LED_ROJO, HIGH);
digitalWrite(plaza[2].LED_VERDE, LOW);
delay(500);
digitalWrite(plaza[0].LED_ROJO, LOW);
digitalWrite(plaza[0].LED_VERDE, HIGH);
digitalWrite(plaza[1].LED_ROJO, LOW);
digitalWrite(plaza[1].LED_VERDE, HIGH);
digitalWrite(plaza[2].LED_ROJO, LOW);
digitalWrite(plaza[2].LED_VERDE, HIGH);
Serial.print("Encendido de Leds\n");
/*********************************/
/* Inicialización y testeo */
/* de los zumbadores */
/*********************************/
pinMode(alarma1, OUTPUT);
pinMode(alarma2, OUTPUT);
////////// LINEAS DE TEST //////////
////////////////////////////////////
Serial.print("Probando zumbadores...\n");
analogWrite(alarma1, 20);
analogWrite(alarma2, 20);
delay(50);
analogWrite(alarma1, 0);
analogWrite(alarma2, 0);
delay(50);
analogWrite(alarma1, 20);
analogWrite(alarma2, 20);
delay(50);
analogWrite(alarma1, 0);
analogWrite(alarma2, 0);
/*********************************/
/* Relé */
/*********************************/
pinMode(rele1,OUTPUT);
pinMode(rele2,OUTPUT);
pinMode(rele3,OUTPUT);
pinMode(rele4,OUTPUT);
/* Los Reles, 1 y 2, estan configurados como NA:
* valor HIGH = CIRCUITO ABIERTO
* valor LOW = CIRCUITO CERRADO
*
* Los Reles, 3 y 4, estan sin usar.
*/
////////// LINEAS DE TEST //////////
////////////////////////////////////
Serial.print("Probando dispositivos controlados por rele\n");
digitalWrite(rele1,HIGH);
digitalWrite(rele2,HIGH);
digitalWrite(rele3,HIGH);
digitalWrite(rele4,HIGH);
delay(500);
digitalWrite(rele1,LOW);
digitalWrite(rele2,LOW);
digitalWrite(rele3,LOW);
digitalWrite(rele4,LOW);
delay(500);
digitalWrite(rele1,HIGH);
digitalWrite(rele2,HIGH);
digitalWrite(rele3,HIGH);
digitalWrite(rele4,HIGH);
delay(500);
digitalWrite(rele1,LOW);
digitalWrite(rele2,LOW);
digitalWrite(rele3,LOW);
digitalWrite(rele4,LOW);
delay(500);
digitalWrite(rele1,HIGH);
digitalWrite(rele2,HIGH);
digitalWrite(rele3,HIGH);
digitalWrite(rele4,HIGH);
////////////////////////////////////
Serial.print("Configurando el funcionamiento de los pin's analógicos \n");
/*****************Pines analogicas*****************/
/*********************************/
/* Sensores IR */
/*********************************/
pinMode(plaza[0].IR, INPUT);
pinMode(plaza[1].IR, INPUT);
pinMode(plaza[2].IR, INPUT);
/*********************************/
/* Inicializacion y testeo */
/* de LCD */
/*********************************/
lcd.begin(16, 2);
lcd.display();
lcd.setCursor(0, 0);
lcd.print("Iniciando LCD");
lcd.setCursor(0, 1);
lcd.print("Pantalla de info");
delay(2000);
lcd.clear();
lcd.setCursor(0, 0);
/*********************************/
/* Inicializacion y testeo */
/* de RFID */
/*********************************/
Serial.print("Configurando el funcionamiento del modulo RFID \n");
SPI.begin(); //Iniciamos el Bus SPI
pinMode(LED_ACCESO,OUTPUT);
pinMode(LED_NEGACION,OUTPUT);
digitalWrite(LED_ACCESO,HIGH);
digitalWrite(LED_NEGACION,HIGH);
delay(500);
digitalWrite(LED_ACCESO,LOW);
digitalWrite(LED_NEGACION,LOW);
delay(500);
digitalWrite(LED_ACCESO,HIGH);
digitalWrite(LED_NEGACION,HIGH);
delay(500);
digitalWrite(LED_ACCESO,LOW);
digitalWrite(LED_NEGACION,HIGH);
mfrc522.PCD_Init(); // Iniciamos el MFRC522
Serial.println("Control de acceso:");
/*********************************/
/* Inicializacion y testeo */
/* de servo */
/*********************************/
//Minimo del servo 1º. Maximo del servo 180º.//
//GRADO 1: BARRERA ABIERTA. //
//GRADO 110: BARRERA CERRADA. //
SERVO.attach(9);
SERVO.write(100);
acceso=false;
no_acceso=false;
Serial.println("Programa cargado correctamente.\n");
Serial.println("Iniciando Loop.\n");
Serial.flush();
}
Después de ejecutarse la función Setup(), se ejecutara la función loop(), que a diferencia de la función Setup(), se ejecutara una y otra vez, de manera infinita, por tanto, aquí es donde ira todo nuestro programa.
Podemos encontrar las siguientes funciones en el loop:
-
Control_plazas(), el código que controlara los sensores de las plazas, tanto el de ultrasonido como el IR. -
Control_temperatura(), controlara la humedad y la temperatura de parking, y además, puede activarse la ventilación y la alarma de incendios de manera automática. -
Control_lcd(), manejara la pantalla LCD. -
Control_iluminación(), función para encender o apagar la iluminación. -
Control_ventilación(), función para encender o apagar la ventilación. -
Control_acceso(), función que maneja el modulo RFID -
Control_barrera(), función que controlara el servomotor
/**********************************/
/* Loop */
/**********************************/
void loop()
{
nuevo_plaza=false; //Variable para actualizar LCD al actualizar datos
control_interfaz();
control_plazas(nuevo_plaza);
control_temperatura();
control_lcd();
control_iluminacion();
control_aux();
alarma();
control_ventilacion();
control_acceso();
control_barrera();
t_acceso=millis();
t_noacceso=millis();
Serial.flush();
}
El codigo arduino contará con 14 funciones, que se listaran a continuacion:
- void initempo(unsigned long *crono, unsigned long Time)
- unsigned long chktempo(unsigned long *crono)
- void control_plazas(bool &nuevo_plaza)
- bool sensor_plaza(int i)
- void control_temperatura()
- void alarma()
- void control_lcd()
- void control_iluminacion()
- void control_ventilacion()
- void control_aux()
- void control_acceso()
- boolean compareArray(byte array1[], byte array2[])
- void control_barrera()
- void control_interfaz()
A. initempo() y chktempo()
Las funciones void initempo() y unsigned long chktempo() van juntas, initempo() inicializara nuestros temporizadores pasado X tiempo, un tiempo determinado por nosotros. Chktempo() se encarga de comprobar la variable y ver si se cumple el límite de tiempo impuesto por nosotros.
/*****************Funcion Temporizador*****************/
void initempo(unsigned long *crono, unsigned long Time)
{
*crono = millis() + Time;
}
unsigned long chktempo(unsigned long *crono)
{
if (*crono > millis())
{
return (*crono - millis());
}
else
{
return 0;
}
}
B. control_plazas(bool nuevo_plaza)
La función void control_plazas(bool &nuevo_plaza) será la encargada del control de las plazas. Dentro de ella nos podemos encontrar con la función bool sensor_plaza(int i) que será la encargada de gobernar los sensores de ultrasonido HC-SR04 y los sensores de IR TCRT 5000/5000L
/*****************Funcion Plazas*****************/
void control_plazas(bool &nuevo_plaza)
{
// La variable i, indica la plaza correspondiente en cada momento.
int i;
if (chktempo(&plaza[0].temporizador) <= 0)
{
for (i = 0; i < CANT_PLAZAS; i++)
{
// Serial.print("Plaza: ");
// Serial.print(i);
// Serial.print("\n");
plaza[i].ocupada = sensor_plaza(i);
if ((plaza[i].ocupada == false) && (plaza[i].ciclo == false))
{
digitalWrite(plaza[i].LED_ROJO, LOW);
digitalWrite(plaza[i].LED_VERDE, HIGH);
}
if ((plaza[i].ocupada == true) && (plaza[i].ciclo == false))
{
// Se inicia el contador de tiempo para la plaza correspondiente
plaza[i].tiempo_inicio = millis();
// Se enciende el LED ROJO para señalizar plaza ocupada
digitalWrite(plaza[i].LED_ROJO, HIGH);
digitalWrite(plaza[i].LED_VERDE, LOW);
// Se activa la variable de identificacion para el contador
plaza[i].ciclo = true;
nuevo_plaza=true;
}
if ((plaza[i].ocupada == true) && (plaza[i].ciclo == true))
{
// Se idica el tiempo de ocupacion de la plaza en ms.
plaza[i].tiempo_final = millis() - plaza[i].tiempo_inicio;
}
if ((plaza[i].ocupada == false) && (plaza[i].ciclo == true))
{
plaza[i].ciclo = false;
plaza[i].tiempo_final = millis() - plaza[i].tiempo_inicio;
//segundos
// Se enciende el LED VERDE para señalizar plaza libre
digitalWrite(plaza[i].LED_ROJO, HIGH);
digitalWrite(plaza[i].LED_VERDE, LOW);
}
}
initempo(&plaza[0].temporizador, 2000);
}
}
/*****************Funcion Sensores*****************/
bool sensor_plaza(int i)
{
float tiempo = 0, distancia = 0, estado = 0;
/***********************************************************************************************/
// - Falta definir los parametros de "distancia" y "estado" para la entrega de datos de la funcion
// mediante "true" o "false".
/***********************************************************************************************/
do {
digitalWrite(plaza[i].trigger, LOW); // Por cuestion de estabilizacion del sensor
delayMicroseconds(5);
digitalWrite(plaza[i].trigger, HIGH); // Se realiza un pulso
delayMicroseconds(10);
tiempo = pulseIn(plaza[i].echo, HIGH);
/* Función para medir la longitud del pulso entrante. Mide el tiempo que transcurrido entre el envÃÂo
del pulso ultrasónico y cuando el sensor recibe el rebote, es decir: desde que el pin "plaza[i].trigger"
empieza a recibir el rebote, HIGH, hasta que deja de hacerlo, LOW, la longitud del pulso entrante*/
distancia = int(0.017 * tiempo);
/*fórmula para calcular la distancia obteniendo un valor entero*/
} while (distancia <= 0);
estado = analogRead(plaza[i].IR);
//////// LINEAS TEST , MONITOR SERIE ////////
/*
if (distancia != 0)
{
Serial.print("tiempo: ");
Serial.print(tiempo);
Serial.print("\n");
Serial.print("cm: ");
Serial.print(distancia);
Serial.print("\n");
Serial.print("IR: ");
Serial.print(estado);
Serial.print("\n");
}
/* Aqui finaliza la funcion, devolviendo "true" o "false".
*
* Para que se cumpla la condicion de "true", los 2 sensores deben estar de acuerdo,segun nuestro criterio
*
*/
if (((distancia < 14)||(distancia > 18)) && (estado < 800))
{
return true;
}
else
{
return false;
}
}
C. control_temperatura()
La función void control_temperatura() será la encargada del control y gestion de los datos obtenidos por los sensores DHT-11, obteniendo asi la temperatura y humedad del parking.
/*****************Funcion Temperatura*****************/
void control_temperatura()
{
if (chktempo(&usuario[0].temporizador) <= 0)
{
usuario[0].hum1 = dht1.readHumidity();
usuario[0].temp1 = dht1.readTemperature();
usuario[0].hum2 = dht2.readHumidity();
usuario[0].temp2 = dht2.readTemperature();
usuario[0].temp_media = ((usuario[0].temp1 + usuario[0].temp2) / 2);
usuario[0].hum_media = ((usuario[0].hum1 + usuario[0].hum2) / 2);
initempo(&usuario[0].temporizador, 3000);
//////// LINEAS TEST , MONITOR SERIE ////////
/* Serial.print("humedad: ");
Serial.print(usuario[0].hum_media);
Serial.print("\n");
Serial.print("temperatura: ");
Serial.print(usuario[0].temp_media);
Serial.print("\n");
*/
}
if ((usuario[0].temp_media >= 40)&&(alarm==false))
{
//ALARMA DE INCENDIOS Y VENTILACION
temp=true;
alarma();
ventilacion=true;
control_ventilacion();
}
if ((usuario[0].temp_media <= 40)&&(alarm==true))
{
temp=false;
alarma();
ventilacion=false;
control_ventilacion();
}
temp=false;
}
D. alarma()
La función void alarma() se encargará del control de la alarma del parking.
void alarma()
{
/*
* Alarma1 , sera el zumbador encargado de simular una alarma
* Alarma2 , sera el zumbador encargado de simular un pitido de negacion de acceso
* para el modulo RFID
*/
////////// Valores iniciales ///////////
////////// ENCENDER=200 |-| APAGAR=400 /////////
if((temp==true)||(alert==true))
{
if ((chktempo(&encender)) <= 0)
{
analogWrite(alarma1, 20);
//analogWrite(alarma2, 20);
initempo(&encender, valor_encender);
}
if (chktempo(&apagar) <= 0)
{
analogWrite(alarma1, 0);
//analogWrite(alarma2, 0);
initempo(&apagar, valor_apagar);
}
}
if(alert==false) analogWrite(alarma1, 0);
/*
Serial.print("\n");
Serial.print("\n");
Serial.print(no_acceso);
Serial.print("\n");
Serial.print("\n");
*/
}
E. control_lcd()
La función void control_lcd() será la encargada del control de la información mostrada a través de la pantalla LCD.
/*****************Funcion LCD*****************/
void control_lcd()
{
int i;
// Informacion sobre plazas //
if(pause==false)
{
if (((chktempo(&lcd1)) <= 0)||(nuevo_plaza==true)) // variable con or para actualizar
{
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Plazas");
lcd.setCursor(0, 1);
for (i = 0; i < CANT_PLAZAS; i++)
{
if (plaza[i].ocupada == false)
{
lcd.print("P");
lcd.print(i + 1);
lcd.print(":L ");
}
if (plaza[i].ocupada == true)
{
lcd.print("P");
lcd.print(i + 1);
lcd.print(":O ");
}
}
initempo(&lcd1, 3000);
nuevo_plaza==false;
}
// Informacion sobre temperatura y humedad //
if ((chktempo(&lcd2)) <= 0)
{
// Datos de temperatura y humedad
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Temperatura Parking");
lcd.setCursor(0, 1);
lcd.print("Temp:");
lcd.print(usuario[0].temp_media);
lcd.print("C");
lcd.print(" Hum:");
lcd.print(usuario[0].hum_media);
lcd.print("%");
initempo(&lcd2, 6000);
}
}
}
F. control_iluminacion(),control_ventilacion(),control_aux()
Las funciones void control_iluminacion(), void control_ventilacion(),void control_aux() serán las encargadas de gobernar el módulo relé que estará instalado en el parking, que a su vez gobierna los diferentes sistemas del parking.
/*****************Funcion Iluminacion*****************/
void control_iluminacion()
{
if(iluminacion==false)
{
digitalWrite(rele1,HIGH);
}
if(iluminacion==true)
{
digitalWrite(rele1,LOW); // Cierra circuito, NORMALMENTE ABIERTO
}
}
/*****************Funcion Ventilacion*****************/
void control_ventilacion()
{
if(ventilacion==false)
{
digitalWrite(rele2,HIGH);
}
if(ventilacion==true)
{
digitalWrite(rele2,LOW); // Cierra circuito, NORMALMENTE ABIERTO
}
}
/*****************Funcion Luz de Emergencia*****************/
void control_aux()
{
if(aux==false)
{
digitalWrite(rele3,HIGH);
}
if(aux==true)
{
digitalWrite(rele3,LOW); // Cierra circuito, NORMALMENTE ABIERTO
}
}
G. control_acceso()
La función void control_acceso() será la encargada de gobernar el módulo RFID, por lo tanto, nos aportara los datos de que usuario entra o sale del parking, esto se hace mediante la función boolean compareArray(byte array1[], byte array2[]), que compara los datos ID del TAG leído con los datos de ID conocidos. Por último, la función void control_acceso() controlara la barrera con sus variables en la función La función void control_barrera()
/*****************Funcion Acceso al parking*****************/
void control_acceso()
{
bool i=1;
// Revisamos si hay nuevas tarjetas presentes
if ( mfrc522.PICC_IsNewCardPresent())
{
//Seleccionamos una tarjeta
if ( mfrc522.PICC_ReadCardSerial())
{
// Enviamos serialemente su UID
// Serial.print(F("Card UID:"));
for (byte i = 0; i < mfrc522.uid.size; i++)
{
//Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
//Serial.print(mfrc522.uid.uidByte[i], HEX);
ActualUID[i] = mfrc522.uid.uidByte[i];
}
//Serial.print(" ");
// LED_ACCESO 48
// LED_NEGACION 49
//comparamos los UID para determinar si es uno de nuestros usuarios
if ((compareArray(ActualUID, Usuario1))||(compareArray(ActualUID, Usuario2)))
{
//INTRODUCIR TEMPORIZADOR PARA APAGAR LA LUZ
//LED DE CONFIRMACION DE ACCESO.
digitalWrite(LED_ACCESO,HIGH);
digitalWrite(LED_NEGACION,LOW);
acceso=true;
pause=true;
t_acceso=millis();
ti_acceso=t_acceso+10000;
// Serial.println("Acceso concedido...");
// Usuario entra en el parking //
if(((compareArray(ActualUID, Usuario1))&&(usuario[0].dentro==false))&&(i==true))
{
usuario[0].dentro=true;
i=0;
}
if(((compareArray(ActualUID, Usuario2))&&(usuario[1].dentro==false))&&(i==1))
{
usuario[1].dentro=true;
i=0;
}
if(((compareArray(ActualUID, Usuario3))&&(usuario[2].dentro==false))&&(i==1))
{
usuario[2].dentro=true;
i=0;
}
// Usuario entra en el parking //
if(((compareArray(ActualUID, Usuario1))&&(usuario[0].dentro==true))&&(i==1))
{
usuario[0].dentro=false;
i=0;
}
if(((compareArray(ActualUID, Usuario2))&&(usuario[1].dentro==true))&&(i==1))
{
usuario[1].dentro=false;
i=0;
}
if(((compareArray(ActualUID, Usuario3))&&(usuario[2].dentro==true))&&(i==1))
{
usuario[2].dentro=false;
i=0;
}
}
else
{
no_acceso=true;
t_noacceso=millis();
ti_noacceso=t_noacceso+2000;
// Serial.println("Acceso denegado...");
}
// Terminamos la lectura de la tarjeta tarjeta actual
////////// LINEAS DE TEST //////////
////////////////////////////////////
/* Serial.println("He llegado aqui, Valor=");
Serial.println(no_acceso);*/
////////////////////////////////////
mfrc522.PICC_HaltA();
}
}
}
H. control_interfaz()
La función void control_interfaz() será la encargada de la gestión de los datos, enviando los datos a la interfaz para que el usuario final tenga toda la información de lo que está ocurriendo en el parking. Para el funcionamiento de la comunicación serie entre Arduino y la Interfaz se ha creado un lenguaje de comunicación para el entendimiento de ambos lenguajes. El código usado es el siguiente:
- ‘0’ y ‘1’ Iluminación
- ‘2’ y ‘3’ Ventilación
- ‘4’ y ‘5’ Alarma
- ‘6’ y ‘7’ Iluminación auxiliar
- ‘t’ Temperatura
- ‘h’ Humedad
- ‘b’ Barrera
- ‘u’ Usuarios
- ‘p’ Plazas
- ‘m’ , ‘n’ y ‘g’ Ocupación de plazas
- ‘s’ Sincronización
La información enviada desde Arduino como cadenas de caracteres, en ocasiones, la información ira codificada usando solo caracteres de ‘0’ y ‘1’ y será la interfaz la encargada de decodificar y actuar en consecuencia.
void control_interfaz()
{
int x;
if(Serial.available())
{
char c=Serial.read();
// Iluminación //
if(c=='0'){iluminacion=false;}
if(c=='1'){iluminacion=true; }
// Ventilación //
if(c=='2'){ventilacion=false;}
if(c=='3'){ventilacion=true;}
// Alarma //
if(c=='4'){alert=false;}
if(c=='5'){ alert=true;}
// Iluminacion de emergencia //
if(c=='6'){aux=false;}
if(c=='7'){aux=true;}
// Temperatura //
if(c=='t')
{
Serial.write("t=");
Serial.print(usuario[0].temp_media);
}
// Humedad //
if(c=='h')
{
Serial.write("h=");
Serial.print(usuario[0].hum_media);
}
// Barrera //
if(c=='b')
{
Serial.write("b=");
if(acceso==true)
{
Serial.write("Abierta");
if((gate==true)&&(usuario[0].dentro==true))Serial.write("11");
if((gate==true)&&(usuario[0].dentro==false))Serial.write("10");
if((gate==true)&&(usuario[1].dentro==true))Serial.write("21");
if((gate==true)&&(usuario[1].dentro==false))Serial.write("20");
if((gate==true)&&(usuario[2].dentro==true))Serial.write("31");
if((gate==true)&&(usuario[2].dentro==false))Serial.write("30");
}
if(acceso==false)
{
Serial.write("Cerrada");
}
}
// Usuario //
if(c=='u')
{
Serial.write("u=");
for(x=0;x<CANT_PLAZAS;x++)
{
if(usuario[x].dentro==false)Serial.print("0");
if(usuario[x].dentro==true)Serial.print("1");
}
}
// Plaza //
if(c=='p')
{
Serial.write("p=");
for(x=0;x<CANT_PLAZAS;x++ )
{
if(plaza[x].ocupada==false)Serial.print("0");
if(plaza[x].ocupada==true)Serial.print("1");
}
}
// Ocupacion Plaza
if(c=='m')
{
if(plaza[0].ocupada==true)
{
Serial.print("p1=");
Serial.print((plaza[0].tiempo_final/1000)/60);
}
else
{
Serial.print("Li1");
}
}
if(c=='n')
{
if(plaza[1].ocupada==true)
{
Serial.print("p2=");
Serial.print((plaza[1].tiempo_final/1000)/60);
}
else
{
Serial.print("Li2");
}
}
if(c=='g')
{
if(plaza[2].ocupada==true)
{
Serial.print("p3=");
Serial.print((plaza[2].tiempo_final/1000)/60);
}
else
{
Serial.print("Li3");
}
}
// Sincronizacion //
if(c=='s')
{
if(iluminacion==false)Serial.print(0);
if(iluminacion==true)Serial.print(1);
if(ventilacion==false)Serial.print(0);
if(ventilacion==true)Serial.print(1);
if(alert==false)Serial.print(0);
if(alert==true)Serial.print(1);
if(aux==false)Serial.print(0);
if(aux==true)Serial.print(1);
}
}//Serial.available()
}
La interfaz buscara un manejo simple, rápido y eficaz para gestionar nuestro parking. Aunque la programación que llevara la placa arduino estará pensada para funcionar de manera autónoma, se decidió añadir al proyecto una interfaz para tener un control puntual de ciertas facetas del parking. Además, de obtener datos del parking.
La interfaz será creada con la aplicación C++ Builder 6.
A simple vista se puede diferenciar 4 áreas bien definidas.
- Conectividad
- Plazas del Parking
- Control del Parking
- Datos de Parking
La 1º área por la que deberá pasar cualquier usuario que use la interfaz será la de conectividad. Desde esta área, se eligiera el puerto de conexión usado para comunicación serial, la velocidad de comunicación en baudios, la paridad y el tamaño de las tramas en bits.
Esta área tiene como objeto dar una visión rápida del estado de las plazas, su numeración, la ubicación de la plaza y el estado de los usuarios.
Desde el área de control, podremos manejar manualmente el sistema de ventilación, la iluminación y la alarma.
En esta área nos encontraremos con diferentes datos a modo de información para el usuario que maneja la interfaz. Como la temperatura y humedad del parking, los usuarios registrados en el parking, el estado de la barrera y el tiempo de ocupación de cada plaza.
La comunicación entre la interfaz y arduino se realiza mediante comunicación serie. Arduino cuenta con sus propias librerías para hacer esto posible, pero en el caso de C++ Builder 6 será necesario instalar la librería CPortLib para la gestión de la comunicación serie.
El componente TComPort (desarrollado por Dejan Crnila de Eslovenia) es un componente gratuito para comunicaciones serie para Delphi y C++ Builder. Permite el acceso al puerto serie del PC en Windows XP, Vista y Windows 7. TComPort se basa en la API de Windows por lo que es totalmente compatible con los controladores o drivers pasarela tipo USB - RS232. Es fácil de utilizar para propósitos de comunicación serie básicos. En tcomport.rar está disponible la versión 4.11 y en la página oficial http://sourceforge.net/projects/comport/ estará disponible la última versión. TComPort encapsula en un componente no visible el acceso al puerto serie del PC. Tiene métodos que permiten abrir y cerrar el puerto, así como escribir y recibir datos a través de él.