UNIVERSIDAD NACIONAL SAN CRISTÓBAL DE

HUAMANGA
FALCULTAD DE INGENIERÍA DE MINAS GEOLOGÍA Y
CIVIL
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
SISTEMAS DIGITALES Y ARQUITECTURA DE COMPUTADORAS IS - 341

TRABAJO DE APLICACIÓN DE FIN DE SEMESTRE

ESTACIONAMIENTO AUTOMATIZADO
DOCENTE : Mg. Manuel A. Lagos Barzola
INTEGRANTES : APAICO HUAMANÍ, Ray Henry
BALABARCA ARONES, Arnold Martin
CAMASCA ATMI, Joseph Giovani
GARCÍA CÁCERES, Christian Kevin
GÓMEZ CUCHO, Joseph Junior

FECHA : 26 de julio

AYACUCHO – PERÚ
2018
ÍNDICE

I. RESUMEN............................................................................................................... 3
II. FUNDAMENTACIÓN TEÓRICA..............................................................................4
III. INGENIERÍA DEL PROYECTO................................................................................6
IV. PRUEBAS Y EVALUACIÓN DE FUNCIONAMIENTO............................................15
V. IMPACTO AMBIENTAL.........................................................................................15
VI. COSTOS Y PRESUPUESTOS..................................................................................16
VII. OBSERVACIONES.................................................................................................16
VIII. CONCLUSIONES Y RECOMENDACIONES........................................................16
IX. BIBLIOGRAFÍA.....................................................................................................17
X. ANEXOS...............................................................................................................17
LINEAS DE CÓDIGO...................................................................................................22

2
I. RESUMEN
El estacionamiento automatizado es un proyecto de sistemas digitales que
pretende solventar la necesidad de información acerca de la disponibilidad de
espacios para el aparcamiento de vehículos. La problemática actual de las
instituciones públicas y privadas en relación a la administración de sus garajes,
nos sitúa en el contexto de usuarios quienes tienen la necesidad de parquear sus
vehículos, con el desconocimiento de la cantidad disponible de espacios para
este fin. El objetivo propuesto para este proyecto es el de brindar la información
necesaria de los espacios disponibles de aparcamiento en los garajes, para evitar
solicitudes denegadas de los mismos a través de la simulación del mismo
mediante una maqueta ilustrativa.

La solución al problema propuesto encuentra su cauce en el estudio y diseño de

un sistema digital, que nos permita obtener la información requerida en tiempo
real. Para la implementación de la misma se usará la plataforma de hardware
libre “Arduino” sumado a componentes electrónicos que nos permitan completar
los requerimientos del sistema.

La composición del trabajo tuvo resultados favorables en materia de ensamblado

e ilustración de la situación problema, además de brindar el enfoque de la
elaboración de una zona de parqueo inteligente, ello en consecuencia nos lleva a
la conclusión de que el trabajo que será expuesto en el transcurso del trabajo,
logro con éxito la implementación y despliegue del modelo de estacionamiento
automatizado.

3
II. FUNDAMENTACIÓN TEÓRICA
Para el diseño de un sistema digital que nos permita la administración de
información de los espacios de aparcamiento, se requiere el conocimiento de los
siguientes conceptos:
Computación física
Significa la construcción de sistemas interactivos físicos mediante el uso de
software y hardware que pueden sentir y responder al mundo analógico. Si bien
esta definición es suficientemente amplia para abarcar aspectos como los
sistemas inteligentes de control de tráfico de automóviles o los procesos de
automatización de fábricas, en un sentido más amplio, la computación física es
un marco creativo para la comprensión de la relación de los seres humanos en el
mundo digital. En la práctica, se utilizan sensores y microcontroladores para
traducir entradas analógicas a sistemas basados en software, y/o controlar
dispositivos electromecánicos como motores, servos, iluminación u otro
hardware.
Para el desarrollo de este proyecto nos basaremos en este concepto, llevar las
señales físicas digitalizarlas, procesar y que generen una acción que modifique el
entorno para un estacionamiento.
Arduino
Es una plataforma de electrónica abierta para la creación de prototipos basa-da
en software y hardware libre, flexibles y fáciles de usar. Se creó para artistas,
diseñadores, aficionados y cualquier interesado en crear entornos u objetos
interactivos.
Arduino puede tomar información del entorno a través de sus pines de entrada,
para esto toda una gama de sensores puede ser usada y puede afectar aquello que
le rodea controlando luces, motores y otros actuadores. El microcontrolador en
la placa Arduino se programa mediante el lenguaje de programación Arduino
(basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing).
Arduino se programa en el lenguaje de alto nivel C/C++ y generalmente tiene los
siguientes componentes para elaborar el algoritmo:
• Estructuras
• Variables
• Operadores matemáticos, lógicos y booleanos
• Estructuras de control (Condicionales y ciclos)
• Funciones
SISTEMA REACTIVO
Un sistema reactivo se compone de las siguientes partes:

4
 Entradas: Toman las señales del mundo físico y las convierte en corriente o
voltaje
Procesadores: Manipulan, interpretan y transforman las señales.
Salidas: Convierten la corriente o voltaje en señales físicamente útiles.
COMPONENTES ELECTRÓNICOS
Servomotor SG90.
Un servomotor es un tipo especial de motor que permite controlar la posición del
eje en un momento dado. Está diseñado para moverse determinada cantidad de
grados y luego mantenerse fijo en una posición.
Display de 7 segmentos
El display de 7 segmentos, es un componente que se utiliza para la
representación de números en muchos dispositivos electrónicos.
Pulsadores:
Un pulsador es un operador eléctrico que, cuando se oprime, permite el paso de
la corriente eléctrica y, cuando se deja de oprimir, lo interrumpe.
Resistencias
Encargadas de la regulación de voltaje para el correcto funcionamiento del
sistema digital
Batería 9V
Para la realización del proyecto se utilizará una batería de 9V que será la
encargada del suministro de energía para el sistema.
Multiplexor; Los multiplexores son circuitos combinacionales con varias
entradas y una única salida de datos. Están dotados de entradas de control
capaces de seleccionar una, y solo una, de las entradas de datos para permitir su
transmisión desde la entrada seleccionada hacia dicha salida.
En el campo de la electrónica el multiplexor se utiliza como dispositivo que
puede recibir varias entradas y transmitirlas por un medio de transmisión
compartido. Para ello lo que hace es dividir el medio de transmisión en múltiples
canales, para que varios nodos puedan comunicarse al mismo tiempo.

III. INGENIERÍA DEL PROYECTO

En el presente trabajo se pretende realizar el ensamblaje de un prototipo para
efectos de demostración de un estacionamiento, este contara con la capacidad
para ocho vehículos; dicho establecimiento funcionara de la siguiente manera:

Hardware:

5
 DIAGRAMA DE BLOQUES

SISTEMA DE SISTEMA RECEPTOR

CAPTURA DE DATOS DE DATOS

BASE DE DATOS EN
LA NUBE

APLICACIÓN MÓVIL
DE CONSULTA

DIAGRAMA DE BLOQUES DEL SISTEMA DE CAPTURA DE DATOS

MICROSERVOS

DEMULTIPLEXOR

SENSORES DE
PUERTO SERIAL ARDUINO UNO PROXIMIDAD

MULTIPLEXOR

DISPLAY 7
SEGMENTOS

6
 DIAGRAMA DE BLOQUES DEL SISTEMA RECEPTOR DE DATOS

COMPUTADORA

APLICACIÓN
PUERTO SERIAL MONGO DRIVER
RECEPTORA INTERNET

DIAGRAMA DE LA BASE DE DATOS EN LA NUBE

ENTORNO DE MLAB

INTERNET

PEERING CONECCIÓN
BASE DE DATOS
NO SQL

INTERNET

PEERING CONECCIÓN

7
 DIAGRAMA DE LA APLICACIÓN DE CONSULTA

INTERNET

PEERING CONECCIÓN

ENTORNO ANDROID

APLICACIÓN DE CONSULTA

MARCO DE TRABAJO DE LA APLICACIÓN

LIBRERIAS Y JVM

KERNEL LINUX

Software:

El trabajo antes descrito basa su funcionamiento en la identificación de señales

provenientes de un conjunto de sensores que se encargaran de reportar la
presencia y no presencia de automóviles.

La información recabada por el Arduino, se mostrará en un display de 7

segmentos que permitirá la visualización de la disponibilidad de espacios de
aparcamiento. Las clases definidas para el funcionamiento del dispositivo son las
siguientes.

Clase Principal: Main

#include "Estacionamiento.h"

#define NUM_MAX_CARROS 8

Estacionamiento est(NUM_MAX_CARROS, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12);

void setup() {

8
 pinMode(LED_BUILTIN, OUTPUT);

digitalWrite(LED_BUILTIN, LOW);

void loop() {}

Clase Funcionamiento

#ifndef Estacionamiento_h
#define Estacionamiento_h

#include "Arduino.h"
#include "TransmisorDeDatos.h"
#include "SensorProximidad.h"
#include "SelectorPosicion.h"
#include "Display7Seg.h"
#include <Servo.h>

/*
Representa una puerta del estacionamiento (salida
o entrada).
*/
struct puerta {
Servo motor; //Servomotor de la puerta.
SensorProximidad prx; //Sensor de proximidad de
las puertas.
int id; //identificador de la
puerta.

/*
Inicializa el sensor de proximidad.
*/
void initPrx(int trig, int echo) {
SensorProximidad pr(trig, echo);
prx = pr;
}

/*
Inicializa el servomotor.
*/
void initServo(int pinServo) {
motor.attach(pinServo);
}
};

/*
Representa al conjunto de sensores de proximidad y
brinda información de
las plazas del estacionamiento.
*/
struct controladorSensores {

9
 SensorProximidad prx; //Sensor de proximidad de las
plazas.
SelectorPos3Bits pos; //Selector de 3 bits.

/*
Estructura definida en TransmisorDeDatos.h,
representa los datos
que se enviaran a la base de datos mediante el
puerto Serial.
*/
datos _estadoActual;

/*
Inicializa el selector de posición, el sensor de
proximidad y el estado actual
del estacionamiento.
*/
void init(int trig, int echo, int C, int B, int A,
int numMaxCarros) {

pos.C = C; //MSB (Bit más significativo)

pos.B = B;
pos.A = A; //LSB (Bit menos significativo)

pos._pos = 0; //Posición inicial del selector

pinMode(pos.C, OUTPUT);
pinMode(pos.B, OUTPUT);
pinMode(pos.A, OUTPUT);

SensorProximidad p(trig, echo);

prx = p;

//Contar los carros presentes al iniciar.

for (int i = 0; i < numMaxCarros; i++) {
int d = prx.obtenerDistancia();

if (d <= 30) {
_estadoActual.numActualCarros++;

_estadoActual.plazasDisponibles.insertarNodo(byte(i))
;//Indica la plaza en la que se ubica el carro
estacionado.
}
nextPos();
}
}

/*
Avanza una posición en el rango [0, 8], si la
posición esta fuera de este
rango se reinicia en 0;
*/
int nextPos() {

pos._pos++;

10
 pos.setPos(pos._pos);
return pos._pos;
}
};

/*
La clase Estacionamiento representa el
estacionamiento que se desea implementar.
*/
class Estacionamiento {
private:
Transmisor _tx; //Transmisor de los
datos del estacionamiento,
//ya está inicializado.

puerta _pEntrada, //Puertas de entrada

y salida
_pSalida;

int _numMaxCarros; //representa el

número máximo de plazas para estacionarse.

controladorSensores ctr; //Representa a las 8

plazas disponibles para estacionarse.

public:

Estacionamiento() {}
/*
Inicializa las puertas, el estado actual del
estacionamiento y el transmisor de datos.
*/
Estacionamiento (int numMaxCarros, int
pinTrigEnt, int pinEchoEnt, int pinServoEntrada,
int idPuertaEntrada, int
pinTrigSld, int pinEchoSld, int pinServoSalida,
int idPuertaSalida, int trigCtr,
int echoCtr, int C, int B, int A) {

_numMaxCarros = numMaxCarros;

_pEntrada.initPrx(pinTrigEnt, pinEchoEnt);
_pEntrada.initServo(pinServoEntrada);
_pEntrada.id = idPuertaEntrada;

_pSalida.initPrx(pinTrigSld, pinEchoSld);
_pSalida.initServo(pinServoSalida);
_pSalida.id = idPuertaSalida;

ctr.init(trigCtr, echoCtr, C, B, A,
numMaxCarros);
ctr._estadoActual.sitiosRestantes =
numMaxCarros - ctr._estadoActual.numActualCarros;
}

int getNumCarrosActual() {

11
 return ctr._estadoActual.numActualCarros;
}

int getPlazasDisponibles() {

return ctr._estadoActual.sitiosRestantes;
}

void abrirPuerta(int idPuerta) {

puerta selec = _pSalida;

if (idPuerta == _pEntrada.id) {
selec = _pEntrada;

}
selec.motor.write(0);
}

void cerrarPuerta(int idPuerta) {

puerta selec = _pSalida;

if (idPuerta == _pEntrada.id) {
selec = _pEntrada;

}
selec.motor.write(90);
}

/*
Se enviará y actualizara los datos cada vez
el numActualCarros sea diferente a un valor anterior.
*/
void updateNumActualCarros(int numActualCarros) {

int numAnteriorCarros =
ctr._estadoActual.numActualCarros;

if (numAnteriorCarros != numActualCarros) {

ctr._estadoActual.numActualCarros =
numActualCarros;
ctr._estadoActual.sitiosRestantes =
_numMaxCarros - numActualCarros;
_tx.enviarDatos(ctr._estadoActual);
}
}

};

#endif

12
13
IV. PRUEBAS Y EVALUACIÓN DE FUNCIONAMIENTO
Realizamos las pruebas del proyecto haciendo una simulación, e implementando
algunos materiales ya adquiridos.
Prueba N° 1

En el despliegue de la
primera prueba se
observaron los
siguientes detalles:
- Los sensores no
reportaron la
presencia de los
autos
- El suministro de energía aparentemente no es suficiente.

Prueba N° 2
Para el despliegue se integró un transistor LM 7508 para la regulación del
voltaje para el sistema, con los siguientes detalles:
- El sistema dispone del voltaje suficiente, pero los sensores siguen sin
reportar la presencia de los autos.

V. IMPACTO AMBIENTAL
El objetivo el proyecto responde a la demanda de espacios de aparcamiento, lo
que en consecuencia evitará la congestión vial.
El prototipo antes descrito cumple su rol ambiental, en la reutilización de
algunos materiales reciclados, que servirán para la implementación de sus
estructuras.

14
 VI. COSTOS Y PRESUPUESTOS
A continuación, se presenta el cuadro de costos de los materiales para la
implementación del estacionamiento automatizado:

PRECIO
MATERIAL CANTIDAD TOTAL
UNITARIO
Arduino UNO 1 29.00 29.00
Cables 10 0.50 5.00
Display 7 Segmentos 1 2.00 2.00
Servomotor SG90 2 9.50 19.00
Pulsador 2 pines 1 2.00 2.00
Sensor de Proximidad 9 7.20 64.80
Multiplexor (74LS151) 1 1.50 1.50
Decoder (74LS138) 1 3.50 3.50
Not Gate (74LS04) 2 2.50 5.00
Bin to 7 Seg (74LS47) 1 4.50 4.50
Autos de Juguete 8 1.00 8.00
Cartones 3 2.00 6.00
Total 150.30

VII. OBSERVACIONES
- El sensor de proximidad usado no tuvo la respuesta deseada debido a una
precisión baja en la medición de distancias, razón por la cual las medidas
obtenidas no estaban de acuerdo al modelo de programación sugerido.

VIII. CONCLUSIONES Y RECOMENDACIONES

- Se recomienda para un próximo trabajo el uso de algún tipo de sensor
diferente que pueda refinar el problema de precisión en la medición o
percepción de objetos.
- Para la elaboración de siguientes proyectos es recomendable el uso de una
placa de Arduino con mayor cantidad de pines, que para este caso sería un
Arduino de tipo MEGA.

15
IX. BIBLIOGRAFÍA
- https://www.xataka.com/especiales/guia-del-arduinomaniaco-todo-lo-que-
necesitas-saber-sobre-arduino
- https://aprendiendoarduino.wordpress.com/tag/computacion-fisica/
- https://www.arrow.com/es-mx/categories/sensors/proximity-sensors
- https://techlandia.com/mux-demux-info_250607/

X. ANEXOS
Arduino Atmega328

Servomotor SG90

Sensor de proximidad HC-SR04

16
 Dimensiones y Especificaciones
Voltaje de trabajo: DC 5V
Corriente de trabajo: 15mA
Frecuencia de trabajo: 40Hz
Alcance máximo: 4 m
Rango mínimo: 2 cm
Ángulo de medición: 15 grados
Señal de entrada del disparador: pulso TTL
10μS
Señal de salida de eco Señal de palanca TTL
y el rango en proporción
Dimensión 45 * 20 * 15 mm

Proceso de construcción de la maqueta

17
18
19
20
 LINEAS DE CÓDIGO
ArduinoPortListener
import time, serial, pymongo, threading
from pymongo import MongoClient
puerto = serial.Serial()
puerto.port = 'COM3'

def listenPort():
while True:
try:
puerto.open()
print(puerto.readline())
puerto.close()
break
except serial.serialutil.SerialException:
print('Puerto %s no disponible' % puerto.port)
serial.time.sleep(2)

#qLEArn8cYC3swG4k3eGgMTaa pass for usuario

def enviarDatos(numCars, plazasDisponibles):

21
 cliente =
MongoClient('mongodb://arduinoUNO:4w5dczd7JYqDFbaEa2fFVHDQ@ds2592
50.mlab.com:59250/estacionmiento')
db = cliente['estacionmiento']
test = db['test']
datos = {"_id":"update", "numCar":numCars,
"plazasDisponibles":plazasDisponibles}
test.replace_one({"_id":"update"}, datos, upsert=True)
cliente.close()
del datos, test, db, cliente
#hilo1 = threading.Thread(target = listenPort, daemon = True)
#hilo1.start()

Display7Seg

#ifndef Display7Seg_h
#define Display7Seg_h
#include "Arduino.h"
#include "SelectorPosicion.h"
/*
La clase Display7Seg representa a un display de 7 segmentos
de colector común.
Para la reducción del uso de pines se debe usar un IC 74LS47.
*/
class Display7Seg {
private:
SelectorPos4Bits _pos;
public:
Display7Seg() {}

/*
Inicializa los pines de entrada del IC 74LS47.
Siempre se debe llamar a esta función antes de usar
los demás métodos de esta clase.
*/
Display7Seg(int A, int B, int C, int D) {

22
 _pos.A = A;
_pos.B = B;
_pos.C = C;
_pos.D = D;
pinMode(_pos.A, OUTPUT);
pinMode(_pos.B, OUTPUT);
pinMode(_pos.C, OUTPUT);
pinMode(_pos.D, OUTPUT);
}
/*
Establece el digito mostrado por el display de 7 segmentos.
*/
void setDigito(int digito) {
_pos.setPos(digito);
}
/*
Cambia los digitos del display de 7 segmentos de acuerdo al
tiempo de retraso seleccionado.
*/
void test(int delayTime) {
for (int i = 0; i < 10; i++) {
setDigito(i);
delay(delayTime);
}
}
/*
Cambia los digitos del display de 7 segmentos cada 1s.
*/
void test() {
for (int i = 0; i < 10; i++) {
setDigito(i);
delay(1000);
}
}

23
 };
#endif
SensorProximidad

#ifndef SensorProximidad_h
#define SensorProximidad_h

#include "Arduino.h"

/*
La clase SensorProximidad representa a un sensor de
proximidad
HC-SR04 de 4 pines: Vcc, Trig, Echo, Gnd.

Para calcular la proximidad de un objeto se usan dos

fórmulas que
se obtuvieron del datasheet del producto:

1) d = t/58 cm

rango = t*(velocidadDelSonido/2)/10000
2)rango = t*0.01716 cm
Donde:
t: representa el tiempo en us que tarda en
llegar la señal
emitida por el Trigger hacia el Echo.
d: distancia hacia el objeto en cm.
rango: distancia hacia el objeto en cm.

La diferencia entre distancia y rango es que distancia

es de tipo int,
en cambio rango es de tipo float

Los rangos del sensor varian entre 2cm y 4m.

*/
class SensorProximidad {
private:
//pines del sensor:
int _TRIGGER, //pin del Trig
_ECHO; //pin del Echo

public:
/*
Constructor que se invoca al declarar una variable
de la clase SensorProximidad:

SensorProximidad prx;
*/
SensorProximidad() {}

/*

24
 Constructor que inicializa los pines Trig y Eco del
sensor de proximidad.

Siempre se debe llamar a esta función antes de usar

los demás métodos
de esta clase.

Para llamar a este constructor declarar:

SensorProximidad prx(t, e);

*/
SensorProximidad (int pinTrigger, int pinEcho) {

_TRIGGER = pinTrigger;
_ECHO = pinEcho;
}

/*
Obtiene la proximidad de un objeto de acuerdo a la
fórmula:
1) d = t/58 cm
Donde:
t: representa el tiempo en us que tarda en
llegar
la señal emitida por el Trigger hacia el
Echo.
d: distancia hacia el objeto en cm.

Retorna la proximidad de un objeto (int).

*/
int obtenerDistancia() {

digitalWrite(_TRIGGER, HIGH);
delayMicroseconds(10);
digitalWrite(_TRIGGER, LOW);

int d = pulseIn(_ECHO, HIGH) / 58; //pulseIn(ECHO,

HIGH) retorna el tiempo de respuesta
return d;
}

/*
Obtiene la proximida de un objeto de acuerdo a la
fórmula:
2) rango = t*(velocidadDelSonido/2)/10000 =
t*0.01716 cm
Donde:
t: representa el tiempo en us que tarda en
llegar la señal emitida por el Trigger hacia el Echo.
rango: distancia hacia el objeto en cm.
Retorna la proximidad de un objeto (int).
*/
float obtenerRango() {

25
 digitalWrite(_TRIGGER, HIGH);
delayMicroseconds(10);
digitalWrite(_TRIGGER, LOW);

float distancia = pulseIn(_ECHO, HIGH) * 0.01716;

//VelocidadSonido/2 = 171.6 m/s
return distancia;
}
};
#endif

26