Mecatronica Sistema Automatico de Parqueo
Mecatronica Sistema Automatico de Parqueo
Mecatronica Sistema Automatico de Parqueo
2
CONTENIDO
Pág.
1. INTRODUCCION .............................................................................................. 8
3. OBJETIVOS .................................................................................................... 10
6. METODOLOGÍA .............................................................................................. 22
8. CONCLUSIONES ............................................................................................ 53
9. BIBLIOGRAFÍA ............................................................................................... 56
4
LISTA DE FIGURAS
Pág.
Ilustración 1. Sistema de gestión plazas de parqueadero. ................................... 11
Ilustración 2. Trayectorias simuladas para estacionar un automóvil. ................... 12
Ilustración 3. Trayectorias simuladas para estacionar paralelo de un automóvil.. 13
Ilustración 4. Funcionamiento de un sensor ultrasónico de distancia. ................. 14
Ilustración 5. Sensor de ultrasonido EZ4. ............................................................ 15
Ilustración 6. Sensor de ultrasonido SRF04. ........................................................ 15
Ilustración 7. Sensor de ultrasonido SRF05. ........................................................ 16
Ilustración 8. Proceso lógico servidor de almacenamiento. ................................. 17
Ilustración 9. Tarjeta de adquisición de datos NodeMCU ESP32MOD. ............... 19
Ilustración 10. Generación de mapas con LiDAR-SLAM. ..................................... 20
Ilustración 11. Visualización entorno virtual Unity 3D. .......................................... 21
Ilustración 12. Metodología por implementar. ...................................................... 22
Ilustración 13. Sensor de ultrasonido HC-sr04. .................................................... 23
Ilustración 14. Circuito acondicionamiento de los sensores de ultrasonido HC-sr04.
............................................................................................................................... 25
Ilustración 15. Conexiones protocolo maestro - esclavo modulo lector RFID ...... 26
Ilustración 16. Circuito acondicionamiento lectores RFID .................................... 27
Ilustración 17. Tarjeta de adquisición de datos NodeMCU ESP32. ..................... 28
Ilustración 18. Proceso lógico servidor de almacenamiento. ............................... 28
Ilustración 19. Parámetros de comunicación NodeMCU - ThingSpeak................ 29
Ilustración 20. Comunicación ThingSpeak - Matlab. ............................................ 30
Ilustración 21. Funciones de lectura canales de ThingSpeak en Matlab. ............. 30
Ilustración 22. Transmisión datos del módulo de sensado. .................................. 30
Ilustración 23. Información Servidor almacenamiento FireBase. ......................... 31
Ilustración 24. Función de envío datos al servidor. .............................................. 32
Ilustración 25. Identificación de las variables en el servidor. ................................ 32
Ilustración 26. Levantamiento de mapa en Matlab. .............................................. 33
Ilustración 27. Diagrama de flujo del proceso. ..................................................... 34
5
Ilustración 28. Diseño inicial interfaz. ................................................................... 35
Ilustración 29. Sistema de sensado plazas de parqueo. ...................................... 36
Ilustración 30. Sistema de sensado ubicación del vehículo. ................................ 37
Ilustración 31. Falla de memoria NodeMCU ESP32 ............................................ 38
Ilustración 32. Prueba de sensado tarjetas RFID. ................................................ 38
Ilustración 33. Prueba de envío de datos al servidor en FireBase. ...................... 38
Ilustración 34. Vista previa del desarrollo de la aplicación. .................................. 39
Ilustración 35. Pantalla de inicio - Registro de usuario......................................... 40
Ilustración 36. Registro número de identificación. ................................................ 41
Ilustración 37. Selección modo de trayectoria. ..................................................... 42
Ilustración 38. Interfaz Matlab “Prueba Manual”................................................... 44
Ilustración 39. Interfaz Matlab – ThingSpeak “Prueba Servidor”. ......................... 46
Ilustración 40. Interfaz Android Studio – FireBase “Prueba emulador Android
Studio”. .................................................................................................................. 48
Ilustración 41. Prueba Aplicación IMK Parking en un entorno controlado – inicio.
............................................................................................................................... 50
Ilustración 42. Prueba Aplicación IMK Parking en un entorno controlado –
desarrollo. .............................................................................................................. 51
Ilustración 43. Prueba Aplicación IMK Parking en un entorno controlado – datos
servidor. ................................................................................................................. 52
6
LISTA DE TABLAS
Pág.
7
1. INTRODUCCION
8
2. DESCRIPCIÓN Y JUSTIFICACIÓN DEL PROBLEMA
9
3. OBJETIVOS
10
4. ESTADO DEL ARTE
11
Bernhard Muller; Joachim Deutscher y Stefan Grodde; en la conferencia
internacional sobre aplicaciones de control en Múnich, Alemania 2006. Postulan su
proyecto de generación de trayectoria y control de avance para estacionar un auto
[2]. En la cual su problemática la centran en las colisiones entre automóviles en el
proceso de parqueo entre dos posiciones al no guardar la distancia y maniobra en
retroceso. Cuya solución la centran en un algoritmo de planificación de trayectoria
de dos pasos para generar trayectorias adecuadas para una maniobra de
estacionamiento autónomo de un automóvil.
12
Parisa Masoumi Moghri; Mohammad Reza Karami y Reza Ghaderi presentaron en
el 16to Simposio internacional CSI sobre inteligencia artificial y procesamiento de
señales (AISP 2012) su sistema de estacionamiento paralelo inteligente en tiempo
real para un automóvil como un robot móvil [4], en el que consideraron el
estacionamiento paralelo una acción difícil tanto para los conductores nuevos como
para los experimentados. Por lo tanto, este problema se ha convertido en un asunto
serio en el curso de las últimas décadas. Donde presentaron un método en línea
para la planificación del movimiento del estacionamiento paralelo autónomo hacia
atrás de un automóvil de cuatro ruedas como un robot móvil (CLMR) y aplicaron
sensores de distancia para reconocer un espacio factible para realizar maniobras
de estacionamiento sin colisiones según el tamaño del lote de estacionamiento y
CLMR.
13
5. MARCO TEÓRICO
• ULTRASONIDO
El ultrasonido es una forma de energía, la cual es transmitida por ondas vibratorias
a frecuencias por encima del rango de audición humano normal, con frecuencias
superiores a 16 [KHz]. El ultrasonido es una rama específica de la acústica, la cual
trata con ondas vibratorias en sólidos, líquidos y gases. Este tipo de ondas es
ampliamente utilizado debido a su seguridad, sensibilidad y precisión,
independencia del material, superficie, color y tamaño del objeto, además de ser
una técnica no invasiva la cual permite observar los órganos internos de un paciente
sin la necesidad de exámenes como biopsias, radiografías, etc. en aplicaciones
clínicas, hasta la caracterización de materiales y pruebas no destructivas en estos,
entre otras aplicaciones.
La utilización del ultrasonido como medidor de distancia, tiene como principio de
funcionamiento la reflexión de las ondas por parte de los objetos. Como se muestra
en la figura 1 los componentes básicos de un sensor ultrasónico es un transmisor el
cual emite la señal de ultrasonido, la cual rebota contra el objeto que se encuentra
a una distancia cercana de este, y un receptor el cual recibe la reflexión de la onda.
14
Donde:
d; es la distancia a la que se encuentra el objeto.
V; es la velocidad del sonido en el aire.
t; es el tiempo transcurrido entre la emisión y recepción del pulso.
✓ EZ4 [6]
Voltaje: 2.5 a 5 [Vdc]
Tipo de Salida: PWM, analógica o serial.
Frecuencia 42 [kHz].
Distancia de medición 0 [cm] a 6 metros.
✓ SRF04 [7]
Rango - 3 [cm] a 3 [m]
Voltaje - 5 [V], 30 [mA] Typ.
Frecuencia - 40 [KHz].
Tamaño - 43 [mm] x 20 [mm] x 17 [mm]
Salida: Ancho de pulso proporcional a la distancia en que se encuentra el objeto.
15
✓ SRF05 [8]
Rango - 1,7 [cm] a 4 [m].
Voltaje - 5 [V], 4 [mA] Typ.
Frecuencia - 40 [KHz].
Tamaño 43 [mm] x 20 [mm] x 17 [mm].
16
• THINGSPEAK
Es una plataforma de IOT que permite almacenar y recolectar datos utilizando el
protocolo HTTP a través de Internet o a través de una red de área local. También
permite la creación de aplicaciones de registro de sensores, aplicaciones de
localización de posicionamiento, y una red social con notificaciones de las
actualizaciones de estado. [11]
• SISTEMAS EMBEBIDOS
Son sistemas diseñados para ejecutar tareas específicas programadas por los
usuarios, la ventaja de estos es su precio y tamaño reducido [12]. Los componentes
principales de un sistema embebido son: Procesador, memorias y periféricos.
Algunos sistemas embebidos como BeagleBoard, Raspberry Pi o PandaBoard su
arquitectura es ARM, usan memorias SD/MicroSD15 de almacenamiento y
memorias de trabajo RAM16. [13]
17
✓ BLUETOOTH®
Es una tecnología de enlace inalámbrica que se utiliza para transmitir sonido, datos
e información entre dispositivos. Bluetooth utiliza una topología de red punto a punto
(P2P) con la cual establece comunicación entre dispositivos uno a uno (1:1). [14]
• ANDROID
Android es un sistema operativo móvil desarrollado por Google; es uno de los más
conocidos junto con iOS de Apple. Está basado en Linux, que junto con aplicaciones
middleware está enfocado para ser utilizado en dispositivos móviles como teléfonos
inteligentes, tablets, Google TV y otros dispositivos. [16]
Existe un entorno para desarrollo de aplicaciones Android llamado Android Studio
creado por Google, el cual está escrito en el lenguaje de programación Java. [17]
• NODEMCU ESP32MOD
Es una pequeña placa Wifi, disponible para usar en cualquier proyecto IoT (internet
of things). Está montada alrededor del ya conocido ESP32 y expone todos sus pines
en los laterales. Además, ofrece más ventajas como la incorporación de un
regulador de tensión integrado, así como un puerto USB de programación. Se puede
programar mediante el IDE de Arduino. [18]
18
Ilustración 9. Tarjeta de adquisición de datos NodeMCU ESP32MOD.
• COMUNICACIÓN ANDROID-ARDUINO
La comunicación entre Arduino y Android se realiza por las siguientes formas:
✓ Bluetooth
✓ Wireless Fidelity
✓ USB (Universal Serial Bus)
• MATLAB
Matlab cuenta con la librería Computer Vision System Toolbox la cual nos provee
algoritmos de, funciones y aplicaciones para el procesamiento digital de imágenes,
estas funciones nos permiten realizar la detección y seguimiento de objetos en
movimiento, estimación de movimientos y análisis en tiempo real de videos. Las
funciones están disponibles como funciones de MATLAB, objetos System y bloques
Simulink. [19]
19
• BASES DE DATOS
Las bases de datos como su nombre lo indica almacenan datos de manera
estructurada. Las bases de datos permiten utilizaciones variadas y simultáneas. [20]
Un SGBD (Sistema gestor de base de datos) es un sistema que permite acceder a
la información contenida en una base de datos, por medio de programas que
facilitan su recuperación, manipulación y almacenaje. Estos sistemas son diseñados
para gestionar gran cantidad de información, además de garantizar su seguridad.
Las bases de datos SGBD son generalmente utilizadas por empresas o entidades
que necesitan alto grado de seguridad y fiabilidad de la información que almacenan
en estas. [21]
20
• UNITY 3D
Es un motor de desarrollo para la creación de juegos y contenidos 3D interactivos,
con las características que es completamente integrado y que ofrece innumerables
funcionalidades para facilitar el desarrollo de videojuegos. Una de las mayores
ventajas de Unity 3D es que permite desarrollar juegos para muchas plataformas
con realmente muy poco trabajo extra. A diferencia de otras tecnologías, con Unity
3D prácticamente no hay que hacer casi ajustes para adaptar compilar un juego
para iOS teniéndolo ya para Android. [23]
21
6. METODOLOGÍA
22
6.1. MALLA DE SENSORES
23
Tabla 1. Unidades vendidas de automóviles en Colombia.
24
Ilustración 14. Circuito acondicionamiento de los sensores de ultrasonido HC-
sr04.
25
La malla de sensores consta de dos partes, la primera es el sensado de las plazas
de parqueo en la cual se obtiene los estados de ocupación en tiempo real y la
segunda parte de la malla de sensado consta en el diseño de una red para saber la
ubicación del vehículo dentro del área “mapa” de parqueo, para esto se decidió
cambiar los sensores de presencia que se pensó utilizar en primer lugar y se
utilizaron lectores RFID con tal de evitar falsos positivos de activación y conseguir
un registro para los usuarios con tarjetas RFID identificados con un ID que se
guardan en una base de datos con el fin de globalizar el sistema para una futura
ampliación de mapas y zonas de parqueo a optimizar.
En este diseño se debe tener en cuenta que un módulo de sensado no consta de
un (1) solo lector RFID, va a estar compuesto de cuatro (4) lectores RFID, formando
una regleta “ilustración 16”, para no limitar su zona de funcionamiento y lectura del
vehículo por la vía, su programación comprende de la información obtenida de los
pines de comunicación SPI para múltiples lectores ya que deben compartir los pines
“miso, mosi, sck y reset” mediante el protocolo de comunicación maestro esclavo
“ilustración 15”, se les asignan diferentes pines de selección de esclavo “ss” en el
código para la lectura de los ID y la comparación en el código interno dela base de
datos y el envío a la plataforma de almacenamiento web.
26
Ilustración 16. Circuito acondicionamiento lectores RFID
27
6.2. SERVIDORES DE ALMACENAMIENTO
28
Este sistema se comunica con el servidor de ThingSpeak a través de su modulo wifi
y se realiza la programación en el IDE Arduino, en este script se declara dos librerías
que definen habilitan la comunicación entre placa y web definiendo los parámetros
de comunicación con la plataforma ThingSpeak después se pasó a la etapa de
verificación de la información recibida a través de la IP de ThingSpeak, se llenó la
información recibida en un vector de 11 posiciones los cuales se almacenan en unas
nuevas variables los estados de los sensores.
29
Ilustración 20. Comunicación ThingSpeak - Matlab.
30
Como segundo método para dar solución debido a un limitante de envió de datos
en el servidor ThingSpeak, se implementa el uso de un servidor libre para el
almacenamiento de datos dinámicos y una visualización del cambio de estado de
estos sensores mediante FireBase, que es una plataforma de libre acceso diseñado
para el desarrollo de aplicaciones móviles o web y que consta de varias
herramientas de la mano de Google, la principal razón del uso es la implementación
del Realtime Database, que permite crear una base de datos y actualizar los datos
de la aplicación móvil final en tiempo real, manteniendo actualizado los datos sin la
manipulación del desarrollador del código de la aplicación.
31
Ilustración 24. Función de envío datos al servidor.
32
6.3. ELABORACIÓN DE MAPAS DIGITALES
33
Ilustración 27. Diagrama de flujo del proceso.
34
Con los parámetros del diagrama del proceso, el siguiente paso es diseñar una
interfaz inicial como validación virtual utilizando herramientas de Matlab, en la que
se evalúa la transmisión de los datos y lectura mediante líneas de código ya vistas
y para la ilustración de los estados de los sensores y la asignación de una
trayectoria.
Como se planteó en la sección de diseño de la malla de sensores, se representan
en el mapa 11 sensores para las plazas de parqueo y 11 sensores para el sensado
de la posición del vehículo en el mapa.
35
7. RESULTADOS Y EVIDENCIAS
36
Ilustración 30. Sistema de sensado ubicación del vehículo.
37
Ilustración 31. Falla de memoria NodeMCU ESP32
38
Una vez comprobado el funcionamiento de la malla de sensado, el sistema de envío
y almacenamiento de datos en los servidores utilizados, se diseña la aplicación
móvil en base a React Native, que permite diseñar aplicaciones móviles para
Android, iOS, macOS, entre otras plataformas, donde se relaciona e implementa el
algoritmo para la asignación de trayectorias dinámicas A*, según el modo de uso de
la aplicación, y se añaden objetos estáticos y basados en clases mediante
TypeScript con el fin de darle un ambiente agradable a la aplicación en busca de
una forma fácil de usar.
39
Ilustración 35. Pantalla de inicio - Registro de usuario.
40
Ilustración 36. Registro número de identificación.
41
Ilustración 37. Selección modo de trayectoria.
42
7.1 FASE DE PRUEBAS
43
Simulación de la
prueba
44
• Como segunda prueba, vamos a comprobar el funcionamiento de la interfaz
creada en matlab cargando los datos desde el servidor en ThingSpeak,
utilizando el modo automático para la creacion de trayectorias y ver la
visualización de los estados de los sensores es correcta.
45
Ilustración 39. Interfaz Matlab – ThingSpeak “Prueba
Servidor”.
46
• En la tercera prueba, se busca ver el funcionamiento de la interfaz de la
aplicación en Android Studio, sobrescribiendo los datos desde el emulador
ejecutando una secuencia utilizando el modo manual.
47
Ilustración 40. Interfaz Android Studio – FireBase “Prueba
emulador Android Studio”.
48
• Para la cuarta prueba, se busca comprobar el funcionamiento de la aplicación
en un entorno real controlado, al igual que los módulos de sensado y la
transmisión de datos al servidor y la generación de trayectoria optima en los
modos manual o automático.
49
Simulación
de la prueba
50
Ilustración 42. Prueba Aplicación IMK Parking en un entorno
controlado – desarrollo.
51
Ilustración 43. Prueba Aplicación IMK Parking en un entorno
controlado – datos servidor.
52
8. CONCLUSIONES
53
va actualizando con la nueva posición del vehículo, y en la migración a código C, se
implementa el algoritmo a estrella “A*”, que se basa en la medida heurística entre el
punto de entrada “ubicación en tiempo real del vehículo” con el punto de llegada
“plaza de parqueo” seleccionada en el modo manual o asignada en el modo
automático.
54
Con respecto al proyecto, se recomienda una modificación o mejora futura en busca
de entregar un servicio más amplio, ya que, al ser la versión inicial de un proyecto
de movilidad inteligente, carece de algunas funcionalidades como la
estandarización de una tarjeta de identificación para el usuario que funcione de la
mano con la visualización de mapas en diferentes puntos de la ciudad, así como el
modelado y visualización de estos mapas además de la implementación de los
sensores de planta.
55
9. BIBLIOGRAFÍA
1. García Velandia Camilo Sneider, Huertas Acevedo Jairo Alberto. Prototipo
de sistema para la gestión de ocupación de parqueaderos en un centro
comercial. Universidad Distrital Francisco José de Caldas, Facultad
tecnológica, Ingeniería en control. Bogotá, Colombia 2018
2. Bernhard Muller; Joachim Deutscher; Stefan Grodde. Generación de
trayectoria y control de avance para estacionar un auto. Proceedings of the
2006 IEEE. International Conference on Control Applications. Munich,
Germany, October 4-6, 2006.
3. Cárdenas Correa, Edwin Francis. Una aplicación computacional de
generación de trayectorias y evasión de obstáculos para distintos robots
manipuladores con análisis en un sistema real. Universidad Nacional de
Colombia. Bogotá 2009.
4. Parisa Masoumi Moghri; Mohammad Reza Karami; Reza Ghaderi. Sistema
de estacionamiento paralelo inteligente en tiempo real para un automóvil
como un robot móvil. The 16th CSI International Symposium on Artificial
Intelligence and Signal Processing (AISP 2012).
5. PEREZ DE DIEGO, Diego. Sensores de distancia por ultrasonidos. Cuarto
semestre ingeniería de Telecomunicaciones. [en línea].
<http://www.alcabot.com/alcabot/seminario2006/Trabajos/DiegoPerezDeDie
go.pdf > [citado el 16 de febrero de 2019]
6. DYNAMO ELECTRONICS. Sensor ultrasónico EZ4 [en línea].
<https://www.dynamoelectronics.com/medir-distancias/270-sensor-
ultrasonico-ez4.html?search_query=ultrasonico&results=13 > [citado el 16
de febrero de 2019]
7. DYNAMO ELECTRONICS. Sensor ultrasónico SRF04 [en línea].
<https://www.dynamoelectronics.com/medir-distancias/275-sensor-
ultrasonico-srf04.html?search_query=ultrasonico&results=13 > [citado el 16
de febrero de 2019]
56
8. DYNAMO ELECTRONICS. Sensor ultrasónico SRF05 [en línea].
<https://www.dynamoelectronics.com/medir-distancias/277-sensor-
ultrasonico-srf05.html?search_query=ultrasonico&results=13 > [citado el 16
de febrero de 2019]
9. Leuze electronic. Sensor ultrasónico HRTU 418, pág. 25 [en línea]. <
https://www.leuze.com/media/assets/archive/DS_BR_USDS_es.pdf >
[citado el 16 de febrero de 2019]
10. DYNAMO ELECTRONICS. Sensor ultrasónico MB7367 [en línea].
<https://www.dynamoelectronics.com/industria/490-mb7367-sensor-
ultrasonido-industrial-alta-resolucion-
1mm.html?search_query=ultrasonico&results=13 > [citado el 16 de febrero
de 2019]
11. ThingSpeak [en línea]. <https://en.wikipedia.org/wiki/ThingSpeak > [citado el
20 de febrero de 2019]
12. Sistemas embebidos innovando hacia los sistemas inteligentes [en línea].
<http://www.semanticwebbuilder.org.mx/es_mx/swb/Sistemas_Embebidos_I
nnovando_hacia_los_Sistemas_Inteligentes_ > [citado el 16 de febrero de
2019]
13. Parámetros sistemas embebidos [en línea].
<https://www.cdtdegas.com/images/Descargas/Nuestra_revista/MetFlu10/4
AutomatizacionTunel.pdf > [citado el 16 de febrero de 2019]
14. BLUETOOTH. How it Works [en línea]. <https://www.bluetooth.com/what-is-
bluetooth-technology/how-it-works > [citado el 17 de febrero de 2019]
15. Wireless Fidelity (Wi-Fi) [en línea].
<https://www.techopedia.com/definition/10035/wireless-fidelity-wi-fi > [citado
el 17 de febrero de 2019]
16. ANDROID OS. Introducción [en línea].
<https://androidos.readthedocs.io/en/latest/data/introduccion/> [citado el 17
de febrero de 2019]
57
17. ANDROID STUDIO. Android Studio IDE OFICIAL PARA ANDROID [en
línea]. <https://developer.android.com/studio/index.html> [citado el 17 de
febrero de 2019]
18. NodeMCU tutorial paso a paso desde cero. Programarfacil.com. [en línea] <
https://programarfacil.com/podcast/nodemcu-tutorial-paso-a-paso/ > [citado
el 22 de febrero de 2019]
19. MathWorks Design and simulate computer vision and video processing
systems [en línea]. <https://es.mathworks.com/products/computer-
vision.html > [Citado el 15 de febrero de 2019]
20. CMPS PARE, RAFAEL. BASE DE DATOS [en línea].
<http://www.uoc.edu/masters/oficiales/img/913.pdf > [citado el 18 de febrero de
2019]
21. SILBERSCHATZ, Abraham. Fundamentos de bases de datos. Cuarta
Edición, Mc Graw Hill.
22. MathWorks Navigation toolbox. [en línea] <
https://de.mathworks.com/products/navigation.html > [citado el 24 de agosto
de 2020]
23. Unity 3D toolbox de mapas [en línea] < https://www.mapbox.com/unity/> [citado el
12 de marzo del 2019].
24. Moreno, Juan Guillermo. Estos son los carros más vendidos en el país. El
colombiano. [en línea] <https://www.elcolombiano.com/entretenimiento/motores/los-
carros-mas-vendidos-son-hechos-en-colombia-CL8085260> publicado el 27 de
enero del 2018
25. Restrepo, Oscar Julián. Top 50: los carros más vendidos de Colombia en
marzo del 2019. El carro colombiano revista virtual. [ en línea]
<[https://www.elcarrocolombiano.com/industria/top-50-los-carros-mas-
vendidos-de-colombia-en-marzo-de-2019/> Publicado el 23 de abril del 2019
26. Norma técnico colombiana NTC 5385 centros de diagnóstico automotor. 15
de diciembre del 2016
27. Celis Morales, Omar Alfredo. Estudiante de ingeniería mecatrónica.
Universidad autónoma de Bucaramanga. 2019
58
10. ANEXOS
• Código interfaz en Matlab con la herramienta GUIDE para la simulación de
una interfaz virtual “interfaz_1.m”.
Segmento de código que inicia la interfaz y las imágenes, tablas, gráficos de inicio.
Nos permite escoger entre los modos de trayectoria manual o automático.
% --- Executes on button press in SALIR.
function SALIR_Callback(hObject, eventdata, handles)
BOTÖN SALIR
59
function MANUAL_Callback(hObject, eventdata, handles)
% hObject handle to MANUAL (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
set(handles.INICIO,'visible','off')
set(handles.panel_manual,'visible','on')
set(handles.panel_automatico,'visible','off')
set(handles.axes2,'visible','off');
set(handles.text3,'visible','off');
set(handles.text9,'visible','off');
BOTÖN MANUAL
set(handles.text5,'visible','off');
set(handles.text10,'visible','off');
set(handles.text6,'visible','off');
set(handles.text11,'visible','off');
set(handles.text7,'visible','off');
set(handles.text12,'visible','off');
set(handles.text8,'visible','off');
set(handles.text13,'visible','off');
set(handles.text14,'visible','off');
set(handles.text15,'visible','off');
set(handles.S1,'visible','off'); set(handles.S6,'visible','off');
set(handles.S11,'visible','off');
set(handles.S2,'visible','off'); set(handles.S7,'visible','off');
set(handles.S3,'visible','off'); set(handles.S8,'visible','off');
set(handles.S4,'visible','off'); set(handles.S9,'visible','off');
set(handles.S5,'visible','off'); set(handles.S10,'visible','off');
60
function CARGAR_MAN_Callback(hObject, eventdata, handles)
% hObject handle to CARGAR_MAN (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
set(handles.text3,'visible','off');
set(handles.text9,'visible','on');
set(handles.text5,'visible','on');
set(handles.text10,'visible','on');
set(handles.text6,'visible','on');
set(handles.text11,'visible','on');
set(handles.text7,'visible','on');
set(handles.text12,'visible','on');
set(handles.text8,'visible','on');
set(handles.text13,'visible','on');
set(handles.text14,'visible','on');
set(handles.text15,'visible','on');
set(handles.S1,'visible','on'); set(handles.S6,'visible','on');
set(handles.S11,'visible','on');
set(handles.S2,'visible','on'); set(handles.S7,'visible','on');
set(handles.S3,'visible','on'); set(handles.S8,'visible','on');
set(handles.S4,'visible','on'); set(handles.S9,'visible','on');
CARGAR DATOS MANUAL
set(handles.S5,'visible','on'); set(handles.S10,'visible','on');
data = thingSpeakRead(1277825,'Fields',[1,2,3],'Timeout',15)
data_2 =
thingSpeakRead(1283305,'Fields',[1,2,3,4,5,6,7,8],'Timeout',15)
data = [data data_2]
map = binaryOccupancyMap(220, 260, 1);
occ = zeros(260, 220);
%construccion mapa 2D
%La referencia de la toolbox la toma en la esquina izquierda
superior
occ(1,:) = 1; % limite superior "PARED"
occ(1:end,1) = 1; % limite pared izquierda
occ(end,50:end) = 1; % limite inferior "PARED"
occ(1:260,end) = 1; %limite pared derecha
% creacion plazas de parqueo
%plazas de parqueo superior
occ(1:50,[50 90 130 170:end]) = 1;
occ(1:100,[170:end])=1;
% plazas de parqueo derecha
occ([end-40 end-80 end-120 end-160 end-200], 170:end) = 1;
%plazas de parqueo central mirando hacia abajo
% occ(14,5:13) = 1;
% occ(9:14,[5 9 13])=1;
%plazas de parqueo central mirando hacia izquierda
occ([end-40 end-80 end-120 end-160], 50:100) = 1;
occ(100:220,50)=1;
%---------------------------------------------------------
% cerrando via para que busque la direccion correcta
occ(end-40,[1:50])=1;
%------- ó -----------------------------------------------
% obstacleWidth = 49;
% obstacleHeight = 5;
% obstacleBottomLeftLocation = [1 40];
61
% values = ones(obstacleHeight, obstacleWidth);
% setOccupancy(map, obstacleBottomLeftLocation, values)
setOccupancy(map, occ)
axes(handles.axes2);
show(map)
title('DISTRIBUCION PLAZAS PARQUEO')
axis off
if data(1) == 0;
ES1 = set(handles.text5,'Foregroundcolor','red');
else
ES1 = set(handles.text5,'Foregroundcolor','green');
end
if data(2) == 0;
ES2 = set(handles.text6,'Foregroundcolor','red');
else
ES2 = set(handles.text6,'Foregroundcolor','green');
end
if data(3) == 0;
ES3 = set(handles.text7,'Foregroundcolor','red');
else
ES3 = set(handles.text7,'Foregroundcolor','green');
end
if data(4) == 0;
ES4 = set(handles.text8,'Foregroundcolor','red');
else
ES4 = set(handles.text8,'Foregroundcolor','green');
end
if data(5) == 0;
ES5 = set(handles.text9,'Foregroundcolor','red');
else
ES5 = set(handles.text9,'Foregroundcolor','green');
end
if data(6) == 0;
ES6 = set(handles.text10,'Foregroundcolor','red');
else
ES6 = set(handles.text10,'Foregroundcolor','green');
end
if data(7) == 0;
ES7 = set(handles.text11,'Foregroundcolor','red');
else
ES7 = set(handles.text11,'Foregroundcolor','green');
end
if data(8) == 0;
ES8 = set(handles.text12,'Foregroundcolor','red');
else
ES8 = set(handles.text12,'Foregroundcolor','green');
end
if data(9) == 0;
ES9 = set(handles.text13,'Foregroundcolor','red');
else
ES9 = set(handles.text13,'Foregroundcolor','green');
end
if data(10) == 0;
ES10 = set(handles.text14,'Foregroundcolor','red');
62
else
ES10 = set(handles.text14,'Foregroundcolor','green');
end
if data(11) == 0;
ES11 = set(handles.text15,'Foregroundcolor','red');
else
ES11 = set(handles.text15,'Foregroundcolor','green');
end
set(handles.text3,'visible','off');
63
function Trayectoria_Manual_Callback(hObject, eventdata, handles)
% hObject handle to Trayectoria_Manual (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
s1 = get(handles.S1,'Value'); s6 = get(handles.S6,'Value'); s11
= get(handles.S11,'Value');
s2 = get(handles.S2,'Value'); s7 = get(handles.S7,'Value');
s3 = get(handles.S3,'Value'); s8 = get(handles.S8,'Value');
s4 = get(handles.S4,'Value'); s9 = get(handles.S9,'Value');
s5 = get(handles.S5,'Value'); s10 = get(handles.S10,'Value');
S = [s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11];
Posiciones_libres = find(S==1);
Trayectoria_a_sensor = Posiciones_libres(1);
if (Trayectoria_a_sensor == 1)
pos_sensor1 = [200 25 -pi/2];
Coordenadas = pos_sensor1;
end
if (Trayectoria_a_sensor == 2)
pos_sensor2 = [200 55 -pi/2];
GENERAR TRAYECTORIA MANUAL
Coordenadas = pos_sensor2;
end
if (Trayectoria_a_sensor == 3)
pos_sensor3 = [200 95 -pi/2];
Coordenadas = pos_sensor3;
end
if (Trayectoria_a_sensor == 4)
pos_sensor4 = [200 135 -pi/2];
Coordenadas = pos_sensor4;
end
if (Trayectoria_a_sensor == 5)
pos_sensor5 = [145 230 -pi/2];
Coordenadas = pos_sensor5;
end
if (Trayectoria_a_sensor == 6)
pos_sensor6 = [115 230 -pi/2];
Coordenadas = pos_sensor6;
end
if (Trayectoria_a_sensor == 7)
pos_sensor7 = [75 230 -pi/2];
Coordenadas = pos_sensor7;
end
if (Trayectoria_a_sensor == 8)
pos_sensor8 = [25 230 -pi/2];
Coordenadas = pos_sensor8;
end
if (Trayectoria_a_sensor == 9)
pos_sensor9 = [60 75 -pi/2];
Coordenadas = pos_sensor9;
end
if (Trayectoria_a_sensor == 10)
pos_sensor10 = [60 95 -pi/2];
Coordenadas = pos_sensor10;
end
if (Trayectoria_a_sensor == 11)
64
pos_sensor11 = [60 125 -pi/2];
Coordenadas = pos_sensor11;
end
map = binaryOccupancyMap(220, 260, 1);
occ = zeros(260, 220);
%construccion mapa 2D
%La referencia de la toolbox la toma en la esquina izquierda
superior
occ(1,:) = 1; % limite superior "PARED"
occ(1:end,1) = 1; % limite pared izquierda
occ(end,50:end) = 1; % limite inferior "PARED"
occ(1:260,end) = 1; %limite pared derecha
% creacion plazas de parqueo
%plazas de parqueo superior
occ(1:50,[50 90 130 170:end]) = 1;
occ(1:100,[170:end])=1;
% plazas de parqueo derecha
occ([end-40 end-80 end-120 end-160 end-200], 170:end) = 1;
%plazas de parqueo central mirando hacia abajo
% occ(14,5:13) = 1;
% occ(9:14,[5 9 13])=1;
%plazas de parqueo central mirando hacia izquierda
occ([end-40 end-80 end-120 end-160], 50:100) = 1;
occ(100:220,50)=1;
%---------------------------------------------------------
% cerrando via para que busque la direccion correcta
occ(end-40,[1:50])=1;
%------- ó -----------------------------------------------
% obstacleWidth = 49;
% obstacleHeight = 5;
% obstacleBottomLeftLocation = [1 40];
% values = ones(obstacleHeight, obstacleWidth);
% setOccupancy(map, obstacleBottomLeftLocation, values)
setOccupancy(map, occ)
% ----------------------------------------------------------------
-------
% GENERACION DE LA TRAYECTORIA SEGUN LA SALIDA
estMap = occupancyMap(occupancyMatrix(map));
vMap = validatorOccupancyMap;
vMap.Map = estMap;
planner = plannerHybridAStar(vMap, 'MinTurningRadius', 2);
entrance = [15 1 0]; %entrada
packagePickupLocation = Coordenadas; %punto de llegada
route = plan(planner, entrance, packagePickupLocation);
route = route.States;
% Get poses from the route.
rsConn = reedsSheppConnection('MinTurningRadius',
planner.MinTurningRadius);
startPoses = route(1:end-1,:);
endPoses = route(2:end,:);
rsPathSegs = connect(rsConn, startPoses, endPoses);
poses = [];
for i = 1:numel(rsPathSegs)
lengths = 0:0.1:rsPathSegs{i}.Length;
65
[pose, ~] = interpolate(rsPathSegs{i}, lengths);
poses = [poses; pose];
end
axes(handles.axes2);
show(planner)
title('TRAYECTORIA GENERADA A PLAZA DE PARQUEO')
axis off
set(handles.panel_manual,'visible','off')
set(handles.panel_automatico,'visible','on')
set(handles.axes3,'visible','off');
set(handles.text16,'visible','off');
set(handles.text22,'visible','off');
set(handles.text17,'visible','off');
set(handles.text23,'visible','off');
set(handles.text18,'visible','off');
set(handles.text24,'visible','off');
set(handles.text19,'visible','off');
set(handles.text25,'visible','off');
set(handles.text20,'visible','off');
set(handles.text26,'visible','off');
set(handles.text21,'visible','off');
Botón que permite ingresar en el panel de la interfaz del modo automático, donde
se encuentra un botón llamado generar automático y otro llamado atrás.
66
function trayectoria_Callback(hObject, eventdata, handles)
% hObject handle to trayectoria (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
set(handles.text16,'visible','on');
set(handles.text22,'visible','on');
set(handles.text17,'visible','on');
set(handles.text23,'visible','on');
set(handles.text18,'visible','on');
set(handles.text24,'visible','on');
set(handles.text19,'visible','on');
set(handles.text25,'visible','on');
set(handles.text20,'visible','on');
set(handles.text26,'visible','on');
set(handles.text21,'visible','on');
data = thingSpeakRead(1277825,'Fields',[1,2,3],'Timeout',15)
data_2 =
thingSpeakRead(1283305,'Fields',[1,2,3,4,5,6,7,8],'Timeout',15)
data = [data data_2]
Posiciones_libres = find(data==1);
Trayectoria_a_sensor = Posiciones_libres(1);
GENERAR AUTOMÁTICO
if (Trayectoria_a_sensor == 1)
pos_sensor1 = [200 25 -pi/2];
Coordenadas = pos_sensor1;
end
if (Trayectoria_a_sensor == 2)
pos_sensor2 = [200 55 -pi/2];
Coordenadas = pos_sensor2;
end
if (Trayectoria_a_sensor == 3)
pos_sensor3 = [200 95 -pi/2];
Coordenadas = pos_sensor3;
end
if (Trayectoria_a_sensor == 4)
pos_sensor4 = [200 135 -pi/2];
Coordenadas = pos_sensor4;
end
if (Trayectoria_a_sensor == 5)
pos_sensor5 = [145 230 -pi/2];
Coordenadas = pos_sensor5;
end
if (Trayectoria_a_sensor == 6)
pos_sensor6 = [115 230 -pi/2];
Coordenadas = pos_sensor6;
end
if (Trayectoria_a_sensor == 7)
pos_sensor7 = [75 230 -pi/2];
Coordenadas = pos_sensor7;
end
if (Trayectoria_a_sensor == 8)
pos_sensor8 = [25 230 -pi/2];
Coordenadas = pos_sensor8;
end
if (Trayectoria_a_sensor == 9)
67
pos_sensor9 = [60 75 -pi/2];
Coordenadas = pos_sensor9;
end
if (Trayectoria_a_sensor == 10)
pos_sensor10 = [60 95 -pi/2];
Coordenadas = pos_sensor10;
end
if (Trayectoria_a_sensor == 11)
pos_sensor11 = [60 125 -pi/2];
Coordenadas = pos_sensor11;
end
map = binaryOccupancyMap(220, 260, 1);
occ = zeros(260, 220);
%construccion mapa 2D
%La referencia de la toolbox la toma en la esquina izquierda
superior
occ(1,:) = 1; % limite superior "PARED"
occ(1:end,1) = 1; % limite pared izquierda
occ(end,50:end) = 1; % limite inferior "PARED"
occ(1:260,end) = 1; %limite pared derecha
% creacion plazas de parqueo
%plazas de parqueo superior
occ(1:50,[50 90 130 170:end]) = 1;
occ(1:100,[170:end])=1;
% plazas de parqueo derecha
occ([end-40 end-80 end-120 end-160 end-200], 170:end) = 1;
%plazas de parqueo central mirando hacia abajo
% occ(14,5:13) = 1;
% occ(9:14,[5 9 13])=1;
%plazas de parqueo central mirando hacia izquierda
occ([end-40 end-80 end-120 end-160], 50:100) = 1;
occ(100:220,50)=1;
%---------------------------------------------------------
% cerrando via para que busque la direccion correcta
occ(end-40,[1:50])=1;
%------- ó -----------------------------------------------
% obstacleWidth = 49;
% obstacleHeight = 5;
% obstacleBottomLeftLocation = [1 40];
% values = ones(obstacleHeight, obstacleWidth);
% setOccupancy(map, obstacleBottomLeftLocation, values)
setOccupancy(map, occ)
% ----------------------------------------------------------------
--------
% GENERACION DE LA TRAYECTORIA SEGUN LA SALIDA
estMap = occupancyMap(occupancyMatrix(map));
vMap = validatorOccupancyMap;
vMap.Map = estMap;
planner = plannerHybridAStar(vMap, 'MinTurningRadius', 2);
entrance = [15 1 0]; %entrada
packagePickupLocation = Coordenadas; %punto de llegada
route = plan(planner, entrance, packagePickupLocation);
route = route.States;
% Get poses from the route.
68
rsConn = reedsSheppConnection('MinTurningRadius',
planner.MinTurningRadius);
startPoses = route(1:end-1,:);
endPoses = route(2:end,:);
rsPathSegs = connect(rsConn, startPoses, endPoses);
poses = [];
for i = 1:numel(rsPathSegs)
lengths = 0:0.1:rsPathSegs{i}.Length;
[pose, ~] = interpolate(rsPathSegs{i}, lengths);
poses = [poses; pose];
end
axes(handles.axes3);
show(planner)
title('TRAYECTORIA GENERADA A PLAZA DE PARQUEO')
axis off
if data(1) == 0;
ES1 = set(handles.text16,'Foregroundcolor','red');
else
ES1 = set(handles.text16,'Foregroundcolor','green');
end
if data(2) == 0;
ES2 = set(handles.text17,'Foregroundcolor','red');
else
ES2 = set(handles.text17,'Foregroundcolor','green');
end
if data(3) == 0;
ES3 = set(handles.text18,'Foregroundcolor','red');
else
ES3 = set(handles.text18,'Foregroundcolor','green');
end
if data(4) == 0;
ES4 = set(handles.text19,'Foregroundcolor','red');
else
ES4 = set(handles.text19,'Foregroundcolor','green');
end
if data(5) == 0;
ES5 = set(handles.text20,'Foregroundcolor','red');
else
ES5 = set(handles.text20,'Foregroundcolor','green');
end
if data(6) == 0;
ES6 = set(handles.text21,'Foregroundcolor','red');
else
ES6 = set(handles.text21,'Foregroundcolor','green');
end
if data(7) == 0;
ES7 = set(handles.text22,'Foregroundcolor','red');
else
ES7 = set(handles.text22,'Foregroundcolor','green');
end
if data(8) == 0;
ES8 = set(handles.text23,'Foregroundcolor','red');
else
ES8 = set(handles.text23,'Foregroundcolor','green');
69
end
if data(9) == 0;
ES9 = set(handles.text24,'Foregroundcolor','red');
else
ES9 = set(handles.text24,'Foregroundcolor','green');
end
if data(10) == 0;
ES10 = set(handles.text25,'Foregroundcolor','red');
else
ES10 = set(handles.text25,'Foregroundcolor','green');
end
if data(11) == 0;
ES11 = set(handles.text26,'Foregroundcolor','red');
else
ES11 = set(handles.text26,'Foregroundcolor','green');
end
Como es el modo automático no es necesario cargar los datos del servidor para
ver sus estados, como su nombre lo dice de forma automática el sistema lle los
datos del servidor y genera la trayectoria hasta el sensor cercano que se
encuentre libre.
% --- Executes on button press in ATRAS_2.
function ATRAS_2_Callback(hObject, eventdata, handles)
BOTÓN ATRÁS 2
70
11. CRONOGRAMA
Semanas
No. Actividades
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 Revisión estado del arte. X X X X
Investigación del estado
actual de la malla de
sensores utilizadas en
2 X X X X
los parqueaderos en la
ciudad de
Bucaramanga.
Investigar acerca de los
diferentes softwares
3 X X X X
para el levantamiento de
mapas virtuales.
Primera Sustentación
4 X
(50%)
Revisar arquitectura
algoritmos de
5 X X X
generación de
trayectorias 3D.
Seleccionar sensores y
6 módulos de transmisión X X
de datos.
Diseñar sistema de
transmisión y
7 X X
almacenamiento de
datos.
71
Validación sistema de
8 transmisión y X X X
almacenamiento.
Selección del software
a implementar para la
9 X X
realización del entorno
virtual.
Levantamiento de mapa
10 X X X
virtual.
Elaborar documento
11 representativo a la tesis X X X X X X X X X X X X X X X
de grado.
Sustentación Final X
12
(50%)
72
Tabla 8. Descripción de las actividades del plan de trabajo correspondiente al primer
semestre del año 2019.
73
Diseñar sistema de Diseñar el sistema de adquisición de datos, en
transmisión y el que se evalúan las alternativas encontradas
6
almacenamiento de para la transmisión de datos y el
datos. almacenamiento de estos.
Validar el envío y almacenamiento de datos
Validación sistema de
mediante un plan de pruebas que evalúe la
7 transmisión y
implementación de los sensores y la toma de
almacenamiento.
datos en tiempo real.
Cumpliendo con los requisitos de costos bajos
Selección del software a
y el tiempo de elaboración de un mapa sea
implementar para la
8 bajo, se selecciona un software que sea
realización del entorno
compatible con los sensores y elementos a
virtual.
utilizar.
Simular mediante el software seleccionado, un
mapa digital en representación de un espacio,
Levantamiento de mapa
9 que cuente con especificaciones como
virtual.
direcciones y distancias reales o escaladas
entre objetos.
Realizar avances y correcciones en un
Elaborar documento
cuaderno consignando la información obtenida,
10 representativo a la tesis
pruebas de montajes y alternativas de solución
de grado.
para el sistema.
74
Tabla 9. Plan de trabajo correspondiente al primer semestre del año 2021.
Semanas
No. Actividades
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Desarrollar algoritmo de
1 X X X X
trayectorias.
Simular en un entorno
2 virtual las trayectorias X X X X
asignadas.
Primera Sustentación
3 X
(50%)
Diseñar aplicación
4 X X X
móvil.
Validar sistema final en
5 X X X X
un entorno real.
Elaborar un manual de
6 X X X X X X
usuario.
Elaborar documento
7 representativo a la tesis X X X X X X X X X X X X X X X
de grado
Sustentación Final
8 X
(50%)
75
Tabla 10. Descripción de las actividades del plan de trabajo correspondiente al
primer semestre del año 2021.
76
12. RECURSOS
77