SISTEMA ROBÓTICO MÓVIL PARA EL TRANSPORTE DE …
94
INSTITUTO POLITÉCNICO NACIONAL ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA UNIDAD PROFESIONAL "ADOLFO LÓPEZ MATEOS" ZACATENCO "SISTEMA ROBÓTICO MÓVIL PARA EL TRANSPORTE DE MATERIALES LIGEROS " TESIS PARA OBTENER EL TÍTULO DE INGENIERO EN COMUNICACIONES Y ELECTRÓNICA PRESENTAN EDGAR IVAN CAMACHO FRANCO EVELIA ESCOBEDO RAMÍREZ ASESOR ING. ALEJANDRO VICENTE LUGO SILVA CIUDAD DE MÉXICO, ENERO 2019
Transcript of SISTEMA ROBÓTICO MÓVIL PARA EL TRANSPORTE DE …
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICAUNIDAD PROFESIONAL "ADOLFO LÓPEZ MATEOS" ZACATENCO
"SISTEMA ROBÓTICO MÓVIL PARA EL TRANSPORTE DE
MATERIALES LIGEROS "
TESIS
PARA OBTENER EL TÍTULO DE
INGENIERO EN COMUNICACIONES Y ELECTRÓNICA
PRESENTAN
EDGAR IVAN CAMACHO FRANCO
EVELIA ESCOBEDO RAMÍREZ
ASESOR
ING. ALEJANDRO VICENTE LUGO SILVA
CIUDAD DE MÉXICO, ENERO 2019
i
ÍNDICE
Planteamiento del problema .......................................................................................................... 2
Justificación ..................................................................................................................................... 2
Hipótesis .......................................................................................................................................... 3
Objetivos ......................................................................................................................................... 3
Alcance del proyecto ....................................................................................................................... 4
1 CAPÍTULO 1. ESTADO DEL ARTE ........................................... 5
1.1 Robots de servicio ............................................................................................................... 5
1.1.1 MIR .............................................................................................................................. 6
1.1.2 Xiaowa Robotic Cleaner .............................................................................................. 7
1.1.3 Aura ............................................................................................................................. 8
2 CAPÍTULO 2. MARCO TEÓRICO ............................................9
2.1 Componentes y arquitectura de un robot móvil ................................................................. 9
2.1.1 Locomoción ............................................................................................................... 10
2.1.2 Transductores ............................................................................................................ 11
2.1.3 Tipos de comunicación .............................................................................................. 11
2.1.4 Procesadores ............................................................................................................. 12
2.1.5 Entornos de desarrollo .............................................................................................. 13
2.1.6 Normas ISO ................................................................................................................ 14
2.2 Características de los robots móviles ................................................................................ 15
2.3 Base de datos .................................................................................................................... 16
3 CAPÍTULO 3. DESARROLLO Del Prototipo ................ 18
3.1 Desarrollo de hardware..................................................................................................... 18
3.1.1 Motores ..................................................................................................................... 19
3.1.2 Llantas ....................................................................................................................... 19
3.1.3 Placa L298N ............................................................................................................... 20
3.1.4 Sensores .................................................................................................................... 22
3.1.5 Alimentación ............................................................................................................. 23
3.1.6 Raspberry Pi............................................................................................................... 24
3.1.7 Arduino ...................................................................................................................... 25
3.1.8 Herramientas para la comunicación ......................................................................... 26
ii
3.1.9 Lectura del codificador .............................................................................................. 27
3.2 Desarrollo de software ...................................................................................................... 27
3.2.1 Control de motores ................................................................................................... 28
3.2.2 Lectura de sensores ................................................................................................... 29
3.2.3 Interfaz de usuario .................................................................................................... 32
3.2.4 Comunicación ............................................................................................................ 49
4 Capítulo 4. Pruebas y resultados ......................... 57
4.1 Percepción ......................................................................................................................... 57
4.2 Accesibilidad ...................................................................................................................... 58
4.3 Capacidad de carga ........................................................................................................... 58
4.4 Tiempo de respuesta ......................................................................................................... 59
4.5 Resolución ......................................................................................................................... 60
4.6 Precisión ............................................................................................................................ 62
4.7 Autonomía ......................................................................................................................... 63
4.8 Salida de la trayectoria ...................................................................................................... 63
4.9 Control del mecanismo ..................................................................................................... 64
4.10 Alcance de la comunicación .............................................................................................. 64
4.11 Transmisión de video ........................................................................................................ 65
5 CONCLUSIONES ........................................................................ 66
6 REFERENCIAS ............................................................................ 67
7 ANEXO A .................................................................................... 69
8 ANEXO b ..................................................................................... 86
iii
ÍNDICE DE FIGURAS
Figura 1.1 MIR100 en hospitales ............................................................................................ 6
Figura 1.2 Robot aspiradora ..................................................................................................... 7
Figura 1.3 Robot Aura ................................................................................................................ 8
Figura 2.1 Diagrama general de un sistema robótico .................................................... 9
Figura 3.1 Diagrama general del robot móvil .................................................................. 18
Figura 3.2 Motor DC utilizado ................................................................................................ 19
Figura 3.3 Llantas con coples ................................................................................................ 20
Figura 3.4 Placa L298N ............................................................................................................. 20
Figura 3.5 Codificador óptico FC-03 .................................................................................... 22
Figura 3.6 Sensor ultrasónico HC-SR04 ............................................................................. 23
Figura 3.7 a)Batería recargable, b)Batería portátil para Raspberry ....................... 23
Figura 3.8 Elementos de una Raspberry ............................................................................ 24
Figura 3.9 Codificador óptico leyendo disco ..................................................................... 27
Figura 3.10 Disco con orificios ............................................................................................... 27
Figura 3.11 Ventana de acceso ............................................................................................. 32
Figura 3.12 Elementos de la base de datos en Access ................................................ 33
Figura 3.13 Registro de nuevo usuario .............................................................................. 34
Figura 3.14 Ventana de acceso denegado………………………………………………………….40
Figura 3.15 Ventana de acceso permitido ........................................................................ 35
Figura 3.16 Archivo .txt para guardar el registro y salida del sistema ................. 36
Figura 3.17 Ventana principal ............................................................................................... 37
Figura 3.18 Ventana para programar recorridos ........................................................... 39
Figura 3.19 Primer paso para la programación de recorridos de recorridos ....... 39
Figura 3.20 Segundo paso para la programación de recorridos .............................. 40
Figura 3.21 Tercer paso para la programación de recorridos ................................... 40
Figura 3.22 Cuarto paso para la programación de recorridos .................................. 40
Figura 3.23 Guardado de recorridos ................................................................................... 41
Figura 3.24 Calibración de vueltas ...................................................................................... 41
Figura 3.25 Ventana para obtener mapa de los recorridos establecidos ............. 42
Figura 3.26 Ejemplo de generación de mapa .................................................................. 43
Figura 3.27 Guardado del mapa ........................................................................................... 44
Figura 3.28 Abrir mapa ............................................................................................................ 44
Figura 3.29 Ventana de control para la ejecución de recorridos ............................. 47
Figura 3.30 Salida del sistema .............................................................................................. 49
Figura 3.31 Diagrama de comunicación ............................................................................ 50
Figura 4.1 Posiciones iniciales para pruebas de percepción ...................................... 57
Figura 4.2 Distancia obtenida de la prueba 3 de percepción .................................... 58
Figura 4.3 Grados de libertad ................................................................................................ 58
Figura 4.4 Delimitación de áreas para pruebas de resolución .................................. 60
Figura 4.5 Prueba 2 de resolución con peso vista superior ....................................... 62
iv
Figura 4.6 Prueba 4 de resolución sin peso ..................................................................... 62
Figura 4.7 Prueba 2 de resolución con peso vista frontal........................................... 62
Figura 4.8 Cámara puesta en prototipo ............................................................................. 65
Figura 4.9 Interfaz gráfica junto con video en vivo en PC ......................................... 65
ÍNDICE DE DIAGRAMAS
Diagrama 2.1 Diagrama de una base de datos .......................................... 17
Diagrama 3.1 Diagrama de flujo del control de motores ............................. 28
Diagrama 3.2 Diagrama de flujo de sensores ............................................ 30
Diagrama 3.3 Diagrama de flujo de funciones Arduino ................................ 31
Diagrama 3.4 Diagrama de flujo de acceso al sistema ................................ 33
Diagrama 3.5 Diagrama de flujo de registro de nuevo usuario ..................... 35
Diagrama 3.6 Diagrama de flujo para verificar estado ................................ 38
Diagrama 3.7 Diagrama de flujo para la programación de recorridos ............ 42
Diagrama 3.8 Diagrama de flujo para la creación de mapa .......................... 45
Diagrama 3.9 Diagramas de flujo del control del sistema ........................... 48
Diagrama 3.10 Diagrama de flujo del control mediante una ruta .................. 55
Diagrama 3.11 Diagrama de conexiones ................................................... 56
Diagrama 3.12 Diagrama eléctrico del sistema .......................................... 56
ÍNDICE DE TABLAS
Tabla 3.1 Características de Raspberry Pi 3 .................................................................... 25
Tabla 3.2 Descripción de elementos en ventana de acceso ....................................... 33
Tabla 3.3 Descripción de elementos de ventana de registro de nuevo usuario . 34
Tabla 3.4 Descripción de los elementos en ventana principal................................... 37
Tabla 3.5 Descripción de elementos de la ventana para programar recorridos . 39
Tabla 3.6 Descripción de los elementos en ventana para obtener mapa de los
recorridos ....................................................................................................................................... 43
Tabla 3.7 Descripción de los elementos en ventana de control ............................... 47
Tabla 4.1 Pruebas de precepción .......................................................................................... 57
Tabla 4.2 Pruebas de capacidad de carga ......................................................................... 59
Tabla 4.3 Pruebas de tiempo de respuesta ...................................................................... 60
Tabla 4.4 Pruebas de resolución sin peso ......................................................................... 61
Tabla 4.5 Pruebas de resolución con peso ........................................................................ 61
Tabla 4.6 Pruebas de precisión sin peso ............................................................................ 63
Tabla 4.7 Pruebas de precisión con peso .......................................................................... 63
Tabla 4.8 Pruebas de alcance de la comunicación ........................................................ 64
1
Introducción
El presente trabajo de tesis tiene como principal objetivo dar a conocer una alternativa
al manejo y transporte de materiales, principalmente dentro de áreas domésticas o de
trabajo enfocadas al servicio, con el desarrollo y la implementación del software de
control para un robot móvil aplicando una serie de algoritmos e interfaces, empleando
como elemento principal una API de tipo Rest desarrollada en Python embebida en un
servidor local dentro de una microcomputadora, así como un cliente web desarrollado
en C# el cual tiene como función dotar al sistema de una serie de interfaces gráficas
para su interacción con el usuario.
A partir del desarrollo previamente mencionado se propone la elaboración de un
mecanismo simple y funcional compuesto por un chasis con 4 motores y, adaptado a él,
una serie de componentes electrónicos para obtener un prototipo robusto el cual permite
la evaluación de nuestro sistema a través de pruebas de laboratorio.
Para el desarrollo de este proyecto se establece una metodología compuesta por el
planteamiento del problema, las razones que nos llevaron a trabajar sobre este
proyecto, una propuesta de solución, los objetivos y el alcance que delimita
explícitamente lo que comprende el trabajo.
En el capítulo 1 se aborda una investigación del tema en cuestión a lo largo de la historia,
y cómo fue que la tecnología ha ido permitiendo la aplicación de la robótica en las
distintas áreas de servicio, así también se hace mención a los proyectos similares
realizados en los últimos años.
El capítulo 2 contiene cuestiones teóricas que sustentan la parte del desarrollo del
prototipo propuesto, se describen una serie de elementos que resuelven de distintas
formas el problema planteado.
En el capítulo 3 se hace hincapié en aquellos elementos que fueron seleccionados para
este proyecto en particular, así como los pasos en el diseño y construcción del sistema
en sus aspectos de hardware y software.
Finalmente, en el capítulo 4 se dan a conocer los resultados obtenidos así como las
conclusiones del trabajo en función a las pruebas de desempeño a las que se sometió el
prototipo.
2
Planteamiento del problema
En la actualidad, la productividad de los trabajadores dentro de espacios como lo son:
hospitales, escuelas, hoteles, oficinas e incluso dentro del hogar se ve afectada por la
sobrecarga de trabajo a la que están sometidos, por lo que es de vital importancia el
adecuado manejo del tiempo para cumplir exitosamente las tareas diarias. Asimismo, el
surgimiento de errores humanos, como olvidar llevar de un lugar a otro cierto papeleo
dentro de una oficina o una escuela, tropezar y tirar una bandeja de comida en un
hospital o en un hotel, o simplemente tareas que quitan mucho tiempo y que son
repetitivas, impactan en la productividad de este tipo de ambientes laborales.
Por otra parte, existe cierta población vulnerable que no puede realizar actividades que
impliquen mucho movimiento como caminar un largo trayecto o desplazarse entre
distintos espacios. Para su bienestar, necesitan la ayuda de otra persona que pueda
facilitarles sus actividades diarias y muchas veces no se cuenta con esa ayuda.
También existen ambientes hostiles para los seres humanos, tareas que son peligrosas
como la exploración de ciertos espacios, la vigilancia por las noches, trabajos en áreas
con temperaturas inadecuadas para un ser humano, entre otras.
Se propone el desarrollo de un dispositivo de ayuda para minimizar las afectaciones que
las situaciones descritas anteriormente puedan causar.
Justificación
Con el fin de obtener datos más precisos y saber el grado de aceptación primeramente,
de un cambio en la forma de trabajo y después, de la integración de un sistema robótico
dentro de las labores diarias dentro de área de servicio (hospital, escuela, oficina u
hotel), se aplicaron 25 encuestas en 4 hospitales públicos de la Ciudad de México en el
mes de mayo a médicos, enfermeras y anestesiólogos preguntando qué funciones les
gustaría que realizará un robot dentro del espacio de trabajo; un 37% de ellos
contestaron que sería útil que colabore en labores de limpieza, mientras que un 42%
encontraron conveniente que ayude al transporte de medicamentos y materiales.
3
En las estadísticas obtenidas de los cuatro hospitales se ve reflejada una necesidad en
común entre distintas especialidades que existen dentro de un hospital (enfermería,
anestesiología, ginecología y medicina general), la cual demanda una mayor eficiencia
en la labor del transporte y la administración de material médico.
Finalmente se concluye gracias a las opiniones conjuntas de los trabajadores, que el
transporte de materiales mediante un dispositivo robótico apoyaría en la disminución de
tiempos perdidos, así también lograría la disminución de errores o accidentes al
momento del traslado de materiales delicados, como lo son muestras o algunos
medicamentos, estableciendo con esto un mejor sistema de gestión y administración de
los distintos materiales que se encuentran dentro del hospital, y dando como resultado
la optimización de la calidad del servicio brindado por cualquiera de estas instituciones.
Hipótesis
Es posible obtener un mayor control sobre la eficiencia y seguridad de las actividades
diarias de las distintas áreas de servicio, a través de la construcción de un sistema
robótico móvil que se encargue del transporte y entrega de materiales, dando como
resultado la optimización de estas.
Objetivos
General
Diseñar e implementar el sistema de control de un robot móvil para el transporte de
materiales en general utilizando una interfaz gráfica, una base de datos y comunicación
Wi-Fi.
Específicos
• Diseñar y construir el software para controlar el seguimiento del robot desde una
interfaz gráfica instalada en PC, así como el sistema de comunicación inalámbrica
entre la PC y el robot.
• Diseñar y programar la base de datos del sistema.
• Diseñar y construir el hardware de comunicaciones y control del robot.
• Adaptar una estructura mecánica móvil para construir el robot.
4
• Evaluar el funcionamiento del sistema a través de pruebas de laboratorio.
Alcance del proyecto
El presente proyecto se centra en el control de un sistema robótico móvil por medio de
una interfaz gráfica y comunicación inalámbrica. Debido a esto no se elaborará un diseño
mecánico profesional del robot y solo se realizarán adaptaciones necesarias a una
estructura simple y funcional. Finalmente, el funcionamiento del sistema se evaluará
realizando pruebas de laboratorio.
5
1 CAPÍTULO 1. ESTADO DEL ARTE
En los años ochenta, con la aceleración computacional y el desarrollo de nuevos
sensores, mecanismos y sistemas de control, permitieron aumentar la autonomía de los
robots. Como consecuencia de esto, en 1990 John Engelberger empieza a desarrollar
los primeros robots móviles para el campo industrial. A partir de ese momento este tipo
de robots empieza a cobrar una fuerza en distintas áreas. En 1994 se crea “Dante I” y
“Dante II” por la Universidad Carnegie Mellon de Pittsburgh, usados para la investigación
de volcanes activos. En 1994 la NASA lanza al espacio “Mars Pathfinder”, un rover
(también conocido como astromóvil, es un vehículo de exploración espacial diseñado
para moverse sobre la superficie de un planeta) encargado de estudiar la superficie de
Marte, controlado desde la tierra. Este aparato tenía un sistema para evitar obstáculos
y así permitir la libre exploración de la superficie marciana. A partir del año 2000 en
adelante, los robots móviles extendieron su campo de aplicación y ya no sólo limitaron
su uso para la investigación, misiones espaciales, exploraciones en volcanes o en el
fondo del mar, durante la guerra, o en fábricas. En la actualidad el uso doméstico se ha
divulgado gracias a la creación de nuevos y robots móviles avanzados como “Aibo”,
“PackBot”, “Roomba” e “IntelliRobots”, entre otros [1].
Los avances tecnológicos han permitido que cada vez los robots sean más livianos y
pequeños con nuevos dispositivos electrónicos y, como consecuencia, la construcción de
sistemas cada vez más complejos y de mejor adaptación a cualquier medio.
1.1 Robots de servicio
El nombre surge por la inquietud de la comunidad científica de realizar desarrollos
destinados a estar al servicio de la sociedad, tratando de que ésta reconozca y apoye
sus resultados. Desde el punto de vista social hay aún muy pocos desarrollos en esta
área que hayan impactado en nuestra forma de vivir, pero en los centros de
investigación especializada en robótica hay una gran actividad en investigación con este
objetivo y, posiblemente en un plazo relativamente inmediato se podrán ver robots de
servicio operando de forma masiva.
6
El término “robots de servicio” apareció a finales de los años 80 con una definición
propuesta por el comité ISO TC 184/SC2 refiriéndose a todo tipo de robot que no es
industrial, asimismo la IFR (International Federation of Robotics) se refiere como “robot
que opera de forma parcial o totalmente autónoma al servicio del bienestar de los seres
humanos y de equipamiento, excluyendo operaciones manufactureras”. Los robots de
servicio tenían que poder operar en entornos no estructurados, en condiciones
ambientales cambiantes y con una estrecha interacción con los humanos. En 1995 fue
creado por la IEEE Robotics and Automation Society, el Technical Committee on Service
Robots. Este comité definió en el año 2000 las áreas de aplicación de los robots de
servicios [2].
Así bien, podemos ver esta área como la parte de la robótica que se centra en el diseño
y construcción de robots capaces de proporcionar servicios directamente a los miembros
que forman la sociedad. Algunos de los robots móviles que a la vez son robots de servicio
más famosos dentro del mercado son los siguientes:
1.1.1 MIR
En la figura 1.1 se observa un sistema robótico móvil llamado “MIR100”, desarrollado
por la empresa Mobile Industrial Robots, especializado para el transporte en el campo
industrial. Brindan una mayor flexibilidad en el trabajo y un ahorro de tiempo y dinero
en el proceso productivo. El personal puede programarlo y adecuarlo a las necesidades
para que el robot realice las entregas sin descanso [3].
Figura 1.1 MIR100 en hospitales [3]
7
El Hospital de Southern Jutland en Dinamarca usa una variante de este modelo para
transportar y entregar muestras de sangre, medicinas, artículos de cama, comida,
documentación y desechos de cada cuarto. Las enfermeras y demás personal médico
pueden llamar al robot por teléfono y este los asistirá.
Este sistema puede tomar el elevador para realizar tareas en los diferentes pisos del
hospital. Si surge algún inconveniente manda un mensaje a la estación de control y una
persona encargada puede retransmitir la ruta o controlarlo remotamente a través de un
Smartphone. Para poder acceder a los cajones que contienen el material se debe teclear
un código de acceso [4].
1.1.2 Xiaowa Robotic Cleaner
Desarrollado por la empresa china Xiaomi, es un robot aspirador doméstico autónomo
que cuenta con escobillas debajo de su estructura y a su vez, tiene un sistema de
aspiración que en conjunto operan para realizar la limpieza del hogar (Figura 1.2).
Cuenta con 9 modos de limpieza los cuales es posible administrar desde cualquier
dispositivo móvil con la aplicación Mi Home. También puede limpiar esquinas, zonas
específicas que le indiquemos y alrededor de objetos, como por ejemplo las patas de los
muebles.
Figura 1.2 Robot aspiradora [5]
La aspiradora de Xiaomi tiene todo lo necesario para desplazarse y realizar su labor
correctamente como sensores de colisión e infrarrojos para evitar caer por las escaleras.
8
Una gran diferencia entre el aspirador Xiaomi y otros en el mercado son el uso de voces
humanas reales y el habla para sus mensajes de estado. El resto de aspiradores o bien
sólo hacen ruidos, o sólo usan luces LED como indicador de que puede haber un
problema.
Una de sus principales ventajas es su costo, el cual es menor en comparación a otros
robots aspiradores de este tipo y posee casi las mismas especificaciones [5].
1.1.3 Aura
Aura es un equipo entrenado para moverse de manera autónoma entre los pisos y
habitaciones de un hotel, realiza tareas sencillas como llevar toallas y agua a los
huéspedes, como se muestra en la figura 1.3. Está siendo implementado por la cadena
de hoteles Millennium Hotels and Resorts que, con ayuda de Aura cuenta con un
avanzado servicio a cuarto.
Este hotel fue diseñado para las personas que se dedican a viajar por el mundo. El robot
se emplea para disminuir la carga de trabajo del personal, ya que mientras Aura se
dedica a realizar sencillas tareas de llevar los insumos que requiere una habitación, los
trabajadores pueden enfocarse en realizar otras tareas. Aura recibe la solicitud de
servicio en alguna habitación, se dirige hasta la puerta de la habitación correcta,
manipula el elevador y con esto, resuelve las solicitudes de los huéspedes a tiempo.
Este robot fue desarrollado por la empresa tecnológica Savioke, quien ya trabaja en otro
modelo que se prevé estará destinado a los servicios de cocina [6].
Figura 1.3 Robot Aura [6]
9
2 CAPÍTULO 2. MARCO TEÓRICO
A lo largo de este capítulo, se describen los elementos generales que componen a un
robot móvil (Figura 2.1), las características que deben cumplir, así como algunas normas
y reglas que se solicitan en ciertos concursos de robótica.
Figura 2.1 Diagrama general de un sistema robótico [7]
2.1 Componentes y arquitectura de un robot móvil
Es posible organizar las tareas del sistema de control de una estructura robótica en
niveles jerárquicos (Figura 2.1). En el nivel inferior se realiza la supervisión del control
de físico del mismo por medio de los actuadores utilizados. El segundo nivel es el
encargado de la generación de trayectorias, es decir, el control del desplazamiento del
robot de un punto a otro. El nivel superior se ocupa de la interacción con el usuario, de
la correcta interpretación de la programación del robot, de la percepción hecha por los
sensores y de la toma de decisiones hechas por el robot de forma autónoma (detección
y evasión de obstáculos) [7].
Visión
Tacto
Audición Proximidad
Otros.
Percepción
del entorno
Sistema
de
Control
Sensores Internos
Actuadores
10
2.1.1 Locomoción
Para que el robot pueda desplazarse necesita al menos dos ruedas y un motor. Según
el objetivo deseado deberán incluirse más elementos. Los diferentes tipos de motor que
se pueden emplear son:
• Motores CD: Ofrecen un movimiento lineal y rotatorio dependiendo de la
diferencia de tensión aplicada a sus entradas.
• Motores paso a paso: Ofrecen un movimiento mediante grados (pasos) lo cual
permite una mayor precisión, pero con mayor dificultad de uso y menor velocidad.
• Servomotores: Pueden ubicarse en cualquier posición dentro de un rango.
La movilidad del robot está caracterizada por dos factores: el tipo de llantas y el sistema
de locomoción empleado. Las llantas para un robot móvil pueden ser de diferentes tipos,
como:
• Ruedas convencionales: Realiza una rotación sobre el eje de la rueda. Estas a su
vez se dividen en 3:
o rueda fija: El eje de la rueda esta fijo a la estructura del robot.
o rueda orientable centrada: Permite una rotación sobre el eje de contacto.
o rueda orientable no centrada o loca: Su rotación es sobre el eje de la rueda
y sobre un eje de dirección desplazado del punto de contacto.
• Ruedas suecas: Es similar a la rueda convencional con la diferencia de que posee
rodillos que permiten su desplazamiento lateral sin cambiar la dirección de la
rueda, estos pueden situarse a distintos ángulos [8].
Los sistemas de locomoción más comunes en robots móviles son:
• Ackerman: Se utiliza en vehículos con 4 ruedas. Su sistema de movimiento es
una adaptación del movimiento de los automóviles.
• Triciclo clásico: La rueda delantera se utiliza para la tracción y el movimiento. Su
maniobrabilidad es mayor que en Ackerman pero puede no ser lo suficientemente
estable para algunos tipos de terrenos.
• Diferencial: El direccionamiento se obtiene gracias a la diferencia de velocidades
de las ruedas laterales.
• Skid steer: Incluye más de dos llantas en los laterales y el movimiento se produce
por las distintas velocidades de las llantas de cada lado.
11
• Pista de deslizamiento: Utilizan ruedas tipo oruga para su movimiento.
• Síncrona: Todas las ruedas deben actuar simultáneamente y girar de forma
síncrona [7].
2.1.2 Transductores
Proporcionan al robot información acerca del entorno para que pueda ser procesada e
interpretada y usada para un objetivo en específico. Podemos clasificarlos en dos
grandes grupos:
• Sensores internos: Como su nombre lo dice, se encargan de medir el estado
interno del sistema. Estos pueden ser de posición, como los codificadores ópticos
o los potenciómetros, de velocidad como el tacómetro, de aceleración y de fuerza.
• Sensores externos: Su interés se centra en el conocimiento del entorno que rodea
al robot. Estos a su vez se dividen en dos tipos, de contacto o sin contacto. Dentro
de los primeros encontramos los piezoeléctricos o de presión y en los segundos
se encuentran los sensores de proximidad, de efecto Hall, ultrasónicos y sensores
laser [9].
2.1.3 Tipos de comunicación
El sistema robótico debe estar comunicado con la computadora o el dispositivo que le
enviará las instrucciones a realizar y que recibirá información acerca de su entorno. Esta
comunicación puede ser de dos tipos:
• Alámbrica:
o Ethernet: Se trata de cables y conectores físicos, dependiendo del tipo de
cable se determina su velocidad máxima de transmisión y el alcance que
tiene.
o Serial: La comunicación serial se utiliza para la transmisión de datos
digitales entre un procesador y una computadora u otros dispositivos. La
información es transmitida bit a bit enviando un solo bit a la vez.
12
• Inalámbrica:
o Bluetooth: Se utiliza para la transmisión de voz y datos entre dispositivos
sobre la banda de 2.4 GHz. Puede ofrecer un alcance de 100 metros a una
velocidad de 24 Mbps
o Radiofrecuencia: La velocidad y el alcance está limitado al tipo de emisor y
receptor empleados.
o Infrarroja: La transmisión de datos se realiza bidireccionalmente mediante
un haz de luz infrarroja por lo que se necesita que los dispositivos estén
alineados. La velocidad máxima que alcanza es de 16 Mbps a una distancia
máxima de 1 metro.
o Wi-Fi: Trabaja en la banda 2.4 GHz. Puede llegar a transmitir con una
velocidad de hasta 54 Mbps y alcanzar hasta 50 km [10].
2.1.4 Procesadores
Los elementos que forman parte de un robot móvil deben ser controlados y los datos
extraídos del medio deben ser recibidos, procesados y enviados a un dispositivo final
para su uso. Para esta etapa se utilizan diversas opciones encargadas de realizar las
operaciones e instrucciones encargadas al robot móvil. Algunos microcontroladores
populares en el área de la robótica son:
• Arduino: Es una plataforma electrónica de código abierto, basado en los
microcontroladores ATmega.
• Mbed: Es una plataforma de experimentación para realizar prototipos con
microcontroladores ARM Cortex-M3 y ARM Cortex-M0 de 32 bits.
Otra opción es una mini- computadora, que permiten a cualquier persona disponer de
un completo servidor Linux casero de bajo consumo y por un precio muy bajo. Algunos
ejemplos son:
• Raspberry Pi: Microcomputadora de placa reducida o SBC (Single Board
Computer) de bajo costo, cuyo objetivo es el de estimular la enseñanza de las
ciencias de la computación y poder realizar múltiples aplicaciones, los sistemas
operativos más comunes para esta son: Raspbian, Windows IoT y Noobs.
13
• Jaguar One: Nació de un proyecto de Kickstarter, tiene compatibilidad con X86 y
la posibilidad de instalar Windows 8 o 10 en su versión completa.
• Orange Pi: Es una placa muy parecida a Raspberry Pi, admite Linux y Android, así
como versiones de distribuciones como Ubuntu, Raspbian o Android.
• PcDuino4: Esta placa cuenta con un enfoque multimedia, compatible con vídeo
4K. Viene preparada para instalar Android y diferentes reproductores, así como
servicios de streaming de vídeo.
• ODroid-C2: Es una gran competidora de la Raspberri Pi 3 por su precio y
prestaciones. Sus ventajas son su mayor memoria RAM, sus puertos infrarrojos y
su salida HDMI que permite sacar video 4K, su desventaja es la ausencia de
conectividad Wi-Fi [11].
2.1.5 Entornos de desarrollo
2.1.5.1 Interfaz gráfica
Algunas opciones disponibles para el desarrollo de una interfaz gráfica además de
Microsoft Visual Studio como IDE y C# son:
• NetBeans: Inicialmente desarrollado por Sun y ahora en manos de Oracle. Es uno
de los IDE para desarrollo Java, C, C++ e incluso PHP.
• CodeLite: de código abierto y libre bajo la licencia GNU (General Public License)
soporta los lenguajes C/C++, PHP y Node.js.
También existen editores de código los cuales incorporan un gran número de
herramientas y con ellos es posible realizar aplicaciones en la web:
• Sublimetext: Es multiplataforma y multilenguaje, sus colores ayudan a dar una
mejor vista y organización al código. Soporta un gran número de lenguajes entre
los cuales tenemos: C, C++, C#, CSS, D, Erlang, HTML, Groovy, Haskell, HTML,
Java, JavaScript, LaTeX, Lisp, Matlab, PHP, Python.
• Visual Studio Code: Desarrollado por Microsoft para Windows, Linux y MacOS.
Incluye soporte para la depuración, control integrado de Git, resaltado de sintaxis,
finalización inteligente de código, fragmentos y refactorización de código [12].
14
2.1.5.2 Servidor
Para la microcomputadora Raspberry se pueden encontrar gran variedad de sistemas
operativos entre los que destacan:
• Raspbian: Es el S.O. por defecto ya que es el más completo y optimizado, está
basado en Debian 7.0 [14].
• Ubuntu Mate: Se trata de una distribución basada en UBUNTU, y en GNOME 2,
visualizador ampliamente conocido y extendido entre los usuarios de Linux.
• Windows 10 IOT Core: Su interfaz sólo permite crear proyectos de IoT (Internet
de las cosas), robótica o domótica.
Así mismo se tienen un gran repertorio de lenguajes para desarrollar aplicaciones en
Raspbian como Javascript, Python, C/C++, entre otros. Aunque los más usados son
Python y C, debido a que están implícitos dentro de raspbian, son lenguajes universales
y básicos en programación.
2.1.6 Normas ISO
Han sido desarrolladas ciertas normas que controlan el uso de robots y dispositivos
robóticos en la vida diaria, la mayoría de ellas se centran en robots industriales y en
seguridad. Algunas normas relacionadas con este proyecto son:
• ISO 13482:2014 Requerimientos de seguridad para robots de cuidado personal:
Se especifican las características para un diseño seguro, medidas de protección e
información para el uso de robots móviles de servicio y asistentes físicos.
• ISO 19649:2017 Vocabulario de robots móviles: Términos relacionados a robots
móviles industriales y de servicio.
• ISO 18646-1:2016 Criterios de desempeño y métodos de prueba relacionados
para robots de servicio - Parte 1: Locomoción para robots con ruedas.
• ISO/DIS 18646-2 Criterios de desempeño y métodos de prueba relacionados para
robots de servicio - Parte 2: Navegación.
• ISO/AWI 18646-3 Criterios de desempeño y métodos de prueba relacionados para
robots de servicio - Parte 3: Manipulación [13].
15
2.2 Características de los robots móviles
Las características que debe cumplir cualquier robot móvil son:
• Percepción: La capacidad de recibir datos del medio mediante los diferentes
sensores que posee el robot. Procesar, almacenar y usar esta información recibida
para el cumplimiento de los objetivos del sistema.
• Accesibilidad: Está relacionada con los grados de libertad que posee el sistema.
• Capacidad de carga: Es el límite permisible de peso soportado por el robot para
realizar sus tareas de manera correcta.
• Rapidez de respuesta
• Resolución: Es la menor variación posible en la posición final del robot.
• Precisión: Es la diferencia entre la trayectoria realizada y la realmente ordenada.
• Repetibilidad: Es la capacidad de realizar un gran número de veces las tareas
ordenadas en las mismas condiciones [14].
En algunas competencias de robótica se especifican ciertas características que debe
cumplir cualquier robot móvil, por ejemplo:
• Autonomía: Una vez que se inicie la instrucción encomendada no se podrá tener
acceso a él. No se permite la intervención para controlarlo en el trayecto, solo en
el inicio y si en algún momento tuviera que detenerse de emergencia por la
existencia de una colisión o alguna situación que ponga en riesgo a las personas
y ambiente cercano o por petición de los jueces.
Asimismo dentro del mundo de la robótica s consideran 5 reglas para considerar
a un robot completamente autónomo, las cuales son:
1. Obtener información sobre el medio ambiente.
2. El trabajo durante un período prolongado sin intervención humana.
3. Moverse todo o parte de sí mismo a través de su entorno operativo, sin ayuda
humana.
4. Evitar situaciones que son perjudiciales para las personas, los bienes o para el
robot mismo, a menos que sean parte de las especificaciones de diseño.
16
5. Poder aprender o adquirir nuevos conocimientos, como el ajuste de nuevos
métodos para el cumplimiento de su tarea(s) o la adaptación a los cambios de
entorno.
• Salida de trayectoria: Si en algún momento el robot no cumple con la trayectoria
y se desvía, tendrá que regresar desde el punto donde se perdió o algún punto
anterior para reanudar la trayectoria, no podrá tomar atajos para llegar al punto
final.
• Clasificación: Para poder clasificar a una siguiente ronda, se tienen 3
oportunidades. Si no se logra completar el recorrido, se registra la distancia
máxima avanzada.
• Tiempo límite: Es asignado un tiempo para completar las tareas, el robot que lo
haga en menor tiempo suma puntos. El que lo haga después de ese tiempo es
descalificado.
• Total control del mecanismo: Se solicita que exista una función de paro de
emergencia para evitar cualquier accidente dentro de las pistas de prueba
• Mapeo del entorno: En competencias avanzadas se añade la evaluación de la
capacidad del robot de mapear el recorrido realizado [15] [16].
2.3 Base de datos
En un dispositivo robótico se deben almacenar los datos que se reciben del exterior,
para llevar un control y ejecutar tareas repetitivas. Una base de datos es un sistema
computarizado para guardar registros; es decir, es un sistema cuya finalidad general es
almacenar información y permitir a los usuarios recuperar y actualizar esa información
con base en peticiones. La información en cuestión puede ser cualquier cosa que sea de
importancia para el individuo u organización.
17
Diagrama 2.1 Diagrama de una base de datos
Base de datos: conjunto de datos persistentes que es utilizado por los sistemas de
aplicación de alguna empresa dada.
Programas de aplicación: estos programas pueden ser aplicaciones convencionales por
lotes o pueden ser aplicaciones en línea, cuyo propósito es permitir al usuario final el
acceso a la base de datos desde una estación de trabajo o terminal en línea.
Usuarios finales: son quienes interactúan con el sistema desde estaciones de trabajo o
terminales en línea. Pueden acceder a la base de datos a través de aplicaciones en línea
(también existen otros dos tipos de usuarios que son los programadores de aplicaciones
y los administradores de base de datos o DBA)
La mayoría de los sistemas de base de datos incluyen un procesador de lenguaje de
consulta, mediante el cual el usuario puede emitir solicitudes a la base de datos (también
conocidas como instrucciones o comandos), como SELECT e INSERT, en forma
interactiva con el DBA. El lenguaje SQL es un ejemplo típico de un lenguaje de consulta
de base de datos [17].
Programas
de aplicación
Base de
datos
Sistema de administración
de bases de datos (DBMS)
Usuarios finales
18
3 CAPÍTULO 3. DESARROLLO Del Prototipo
En el presente capítulo se muestra el desarrollo del proyecto, tanto en hardware como
software, en la figura 3.1 se muestra el diagrama general del sistema.
Figura 3.1 Diagrama general del robot móvil
3.1 Desarrollo de hardware
El sistema completo consta de:
• 4 motores de CD de 12 v
• 4 llantas acopladas a cada motor
• 1 placa L298N
• 1 codificador óptico FC-03
• 1 sensor ultrasónico HC-SR04
• Batería de litio de 11.1 v
Servicios WEB
-Movimiento de motores
Raspberry Pi
SENSORES
PC
GUI (Microsoft
Visual Studio
2015)
-Establecimiento
de rutas
-Generación de
USUARIO
VISUALIZACIÓN
Y PROCESAMIENTO
R
E
S
T
A
P
I
WI-FI
INTERFAZ DE
COMUNICACIÓN
HTTP HTTP
HARDWARE
- Control de
Motores
GPIO
ARDUINO
(ADC) INTERACCIÓN
CON EL MEDIO
19
• 1 placa Raspberry Pi 3
• 1 placa Arduino Uno
3.1.1 Motores
Los motores CD utilizados en este proyecto son los mostrados en la figura 3.2 y algunas
de sus características son:
• Voltaje nominal: 12V DC
• Voltaje de operación: 6 - 12 VDC
• Velocidad sin carga a 12 V DC: 500 RPM
• Corriente estimada: 650 mA
• Dimensiones: 10 cm longitud x 5 cm diámetro
• Peso: 167 g
Figura 3.2 Motor DC utilizado
3.1.2 Llantas
Las llantas elegidas son convencionales para motorreductor con rin deportivo y medidas
de 65 mm x 25 mm con agarre y adherencia a la superficie (Figura 3.3). El rin es de
acoplamiento hexagonal, incluye un cople de la misma forma de 12 mm de diámetro
para empotrarlo con la flecha de 5 mm del motorreductor.
20
Figura 3.3 Llantas con coples
3.1.3 Placa L298N
Para el control de sentido de giro de los motores, así como su velocidad se empleó la
placa L298N. Debido a la alimentación de los 4 motores se utilizó la configuración sin el
jumper regulador, la parte lógica funciona gracias a Raspberry con una batería portátil.
El módulo L298N (Figura 3.4) consiste básicamente de dos puentes H que nos permiten
controlar la velocidad y sentido de giro de dos motores de corriente continua o un motor
paso a paso bipolar. Un puente H es un arreglo formado por 4 transistores cuya función
es invertir el sentido de la corriente, y de esta forma poder invertir el sentido de giro
del motor.
Figura 3.4 Placa L298N
21
La placa también cuenta con diodos de protección y un regulador de voltaje LM7805 que
suministra 5V a la parte lógica del integrado y trabaja desde los 3V hasta los 35V, y una
intensidad de hasta 2A. La electrónica del módulo consume alrededor de 3V, por lo que
los motores recibirán 3V menos que la tensión con la que se alimenta el módulo.
Las ventajas que ofrece son facilidad de uso y un precio económico.
El módulo contiene dos salidas para los motores, La salida para el motor A está
conformada por OUT1 y OUT2 y la salida para el motor B por OUT3 y OUT4. Los
pines IN1 e IN2 sirven para controlar el sentido de giro del motor A, y los
pines IN3 e IN4 el del motor B. si IN1 está a HIGH e IN2 a LOW, el motor A gira en un
sentido, y si IN1 está a LOW e IN2 a HIGH lo hace en el otro sentido. Lo mismo sucede
con los pines IN3 e IN4 para el motor B.
Para controlar la velocidad de giro de los motores se tiene que quitar los jumpers y usar
los pines ENA y ENB para ingresar una señal PWM por ellos. Si los jumpers permanecen
colocados, los motores girarán siempre a la misma velocidad.
La entrada de tensión Vin admite tensiones entre 3V y 35V. EL pin V lógico puede
funcionar de dos maneras gracias al regulador LM7805.
Si el jumper regulador está colocado, el módulo permite una alimentación de entre 6V
a 12V, se activa el regulador y en V lógico obtendremos una salida de 5V, que puede
ser usada para alimentar la parte de control del módulo, como un microcontrolador,
Arduino o Raspberry, pero se recomienda que el consumo no sea mayor a 500 mA.
Si se quita el jumper el módulo permite una alimentación de entre 12V a 35V, el
regulador quedara desactivado, así que necesitaremos alimentar la parte lógica del
módulo con una tensión de 5V por la conexión V lógico. Usualmente esta tensión es la
misma de la parte de control.
Es importante señalar que si se introduce tensión por V lógico con el jumper de
regulación puesto podríamos dañar el módulo y que el regulador sólo funciona con
tensiones de hasta 12V en Vin, con tensiones superiores tendremos que quitar el jumper
y alimentar la parte lógica del módulo desde otra fuente [18].
22
3.1.4 Sensores
Codificador óptico FC-03
El módulo FC-03 (Figura 3.5) contiene un optointerruptor MOCH22A que consiste en un
LED infrarrojo, y un fototransistor encapsulados en un pequeño contenedor y separados
por una distancia de 5 mm para colocar un disco ranurado entre ellos.
Figura 3.5 Codificador óptico FC-03
Los optointerruptores emiten un haz de luz directo entre el emisor y el receptor. Si un
objeto se interpone entre ellos, se activa la detección. Al interrumpirse el rayo de luz el
voltaje de salida lógico cambia a 0 lógico, y cuando el rayo pasa con normalidad el
módulo arroja una salida de 1 lógico. Estos pulsos son comparados en un amplificador
operacional LM393, entregando pulsos TTL que pueden ser interpretados por un
microcontrolador como Arduino [19].
Sensor ultrasónico
Un sensor ultrasónico permite medir la distancia entre un objeto y éste mediante el
tiempo entre la emisión y recepción de ondas ultrasónicas.
El sensor HC-SR04 (Figura 3.6) es un módulo que utiliza un par de transductores de
ultrasonido para determinar la distancia del sensor con un objeto colocado enfrente de
este. Su funcionamiento consiste en emitir un sonido ultrasónico por uno de sus
transductores, y esperar que el sonido rebote de algún objeto frente a él, para que el
eco sea captador por el segundo transductor.
23
Figura 3.6 Sensor ultrasónico HC-SR04
La distancia entre el objeto y el sensor se puede calcular con la ecuación 1:
𝐿 =1
2∗ 𝑇 ∗ 𝐶 (𝑐𝑚) …………………….…………………………………….(1)
Donde L es la distancia, T es el tiempo entre la emisión y la recepción, y C es la velocidad
del sonido. El valor se multiplica por 1/2 porque T es el tiempo de recorrido de ida y
vuelta.
Una de las ventajas de este sensor es que incluso los objetos transparentes pueden ser
detectados gracias a que las ondas ultrasónicas pueden reflejarse en superficies de
vidrio o líquido, y retornar al sensor [20].
3.1.5 Alimentación
La batería utilizada en el proyecto es una batería de lithium-ion recargable modelo hw-
li2ah-c (Figura 3.7 a), nos ofrece un voltaje de 11.1v y 2 Ah(22wh) y sus medidas son
15 cm x 10 cm x 5 cm, la cual sirve para alimentar a los motores CD. A su vez, se utilizó
una más para la alimentación de Raspberry Pi 3 con salida de 5v a 2.4A con una
capacidad de 8000mAh (Figura 3.7 b).
Figura 3.7 a) Batería recargable b) Batería portátil para Raspberry
24
3.1.6 Raspberry Pi
Dentro de ella podemos encontrar un chip Broadcom BCM2835 con procesador ARM
hasta a 1 GHz de velocidad, GPU VideoCore IV y hasta 512 Mbytes de memoria RAM
En general la mayoría de las tarjetas Raspberry Pi se componen de (Figura 3.8):
• Puertos USB 2.0 (de 2 a 4 dependiendo el modelo)
• Puerto GPIO (40 pines)
• Puerto Ethernet RJ45 (10/100Mb)
• Entrada para HDMI
• Entrada para tarjeta SD
• Entrada para la alimentación
• Entradas A/V
• Leds indicadores
• Su precio ronda entre los $700.00 a $1,000.00 MXN.
Hoy en día existe una gran variedad de modelos los cuales varían de acuerdo al precio,
especificaciones, capacidades o diseño. Sin embargo, la Raspberry que cumple con todos
los requerimientos para este proyecto es la Pi 3.
En la tabla 3.1 se muestran sus características.
Figura 3.8 Elementos de una Raspberry
25
Tabla 3.1 Características de Raspberry Pi 3
Característica 3 Modelo B
CPU 1.2GHz QUAD ARM Cortex-A53
RAM 1Gb
USB 4
Video Jack, HDMI
Audio Jack, HDMI
Boot MicroSD
Red Ethernet 10/100, Wifi, BT
Consumo 2.5A/12.5w/5v
Alimentación MicroUSB/GPIO
Tamaño 85x56 mm
Precio $1,200.00
3.1.7 Arduino
Es una plataforma electrónica de código abierto, flexible y fácil de aprender y usar. Su
objetivo es ayudar a estudiantes, profesionistas y aficionados a desarrollar proyectos
embebidos usando sus herramientas con el mínimo costo y esfuerzo. Acepta otros
componentes como todo tipo de sensores, lo que lo convierte en una plataforma perfecta
para la interacción con cualquier entorno. El lenguaje para programar Arduino es una
versión simplificada de C/C++.
Existen diferentes tipos de tarjetas Arduino para cada necesidad como son: Arduino
Uno, Leonardo, LilyPad, Mega, Nano, Mini, Mini Pro, BT.
El Arduino Uno está basado en el microcontrolador ATmega328. Consta de 14 puertos
de entrada salida digitales y 6 puertos de entrada análogos y reloj de 16Mhz.
Arduino ofrece algunas ventajas frente a otras plataformas como Parallax Basic Stamp,
Netmedia’s BX-24, Phidgets, MIT’s Handyboard, como son:
• Costo: La versión del chip ATMEGA8 para ensamblar a mano cuesta $35.00, y los
módulos de Arduino pre ensamblados van desde $100.00 a $300.00 MXN.
• Multiplataforma: El software de Arduino está disponible para sistemas operativos
Windows, Macintosh OSX y GNU/Linux.
26
• Entorno de programación simple y claro: El entorno de programación de Arduino
es fácil de utilizar para usuarios de todos los niveles, y flexible para que usuarios
avanzados también puedan aprovecharlo.
• Código abierto y software extensible: El software es una herramienta de código
abierto, disponible para expansión mediante librerías C++ por programadores
avanzados.
• Hardware extensible: Los circuitos para los módulos están publicados bajo licencia
Creative Commons, esto permite a diseñadores y aficionados realizar su propia
versión del módulo [21].
3.1.8 Herramientas para la comunicación
Wi-Fi
Una comunicación inalámbrica es aquella que se lleva a cabo sin la necesidad de ocupar
cables de interconexión. Brinda grandes ventajas sobre la comunicación por un medio
guiado, la más sobresaliente es la movilidad que ofrece a los usuarios.
Wi-Fi es el nombre corto de Wireless Fidelity. Se basa en el estándar IEEE 802.11
(normalmente con una velocidad de transmisión de los 11 Mbps hasta 54Mbps). Es una
tecnología ampliamente aceptada y actualmente está disponible casi en cualquier lugar
debido a su oferta y bajo precio. Permite crear una red entre distintos dispositivos para
poder compartir recursos [22].
Enrutador
Un enrutador se encarga de ofrecer una conexión de red a uno o varios dispositivos
dentro de cierto rango, y de dirigir los datos que van y vienen de ellos. Admite
conexiones cableadas e inalámbricas y la comunicación entre todos los dispositivos que
estén dentro de la red sin importar la forma en que estos se conecten. El enrutador se
conecta a un modem para compartir un servicio de internet. La mayoría de los
enrutadores incorporan un firewall para controlar el acceso seguro a la red.
Los enrutadores inalámbricos se encargan de establecer qué ruta se destinará a cada
paquete de datos dentro de una red. Verifican el correcto envío y recepción de estos.
Una de las funciones de un enrutador es el uso del protocolo DHCP (Dynamic Host
27
Configuration Protocol) que realiza la asignación de direcciones IP locales para cada
dispositivo de la red.
Las direcciones IP locales son conjuntos de 4 números, un ejemplo sería: 192.168.1.X.
o 10.0.1.X. La "X" representa el cambio que hace DCHP para cada dispositivo. El DCHP
de cada enrutador puede emitir un número limitado de direcciones IP y estas direcciones
son dinámicas, pueden cambiar en cualquier momento.
Para algunas aplicaciones resulta un poco inconveniente tener una dirección IP que
puede cambiar en cualquier momento y se opta por configurar una IP estática [23].
3.1.9 Lectura del codificador
Para poder obtener el dato de la distancia avanzada por el robot fuer usado un
codificador el cual se compone de un optointerruptor contenido en una placa y un circulo
hecho de plástico con un diámetro de 5 cm y 4 orificios (Figuras 3.9 y 3.10) acoplado a
una llanta trasera del mecanismo.
Figura 3.10 Disco con orificios
3.2 Desarrollo de software
La estructura del software puede dividirse en:
• Control de motores (Raspberry Pi)
• Lectura de sensores (Arduino)
• Interfaz de usuario (VisualStudio)
• Comunicación
Figura 3.9 Codificador óptico leyendo disco
28
3.2.1 Control de motores
Python
Python es un lenguaje de programación interpretado y multiparadigma, esto quiere decir
que adopta la forma y el estilo de los programadores ya que soporta diferentes formas
de programar como orientación a objetos, programación imperativa y programación
funcional, otros paradigmas son soportados mediante el uso de extensiones.
Es un lenguaje sencillo que se puede entender con facilidad, por ejemplo, se pueden
usar palabras en vez de símbolos. Un ejemplo sencillo es en los operadores lógicos and,
not y or, los cuales en python se escriben como se han mencionado antes, en cambio
en otros lenguajes de programación deben escribirse con &&, ! y —— respectivamente.
Otra ventaja de este código es que no necesita usarse llaves para los bloques de código
como bucles, funciones y clases, en Python sólo basta con usar espacios o tabulaciones
que se conocen como identación. También, a diferencia de otros lenguajes, Python no
necesita un punto y coma al final de una línea para indicar que esta ha terminado, aquí
solo es necesario dar un “enter” para cambiar de línea.
El programa para el control de motores se realizó mediante Python dentro de Raspberry,
mandando instrucciones directas a la placa L298N. A continuación (Diagrama 3.1), se
muestran los diagramas de flujo de la inicialización de los puertos de entrada y salida,
y las funciones de avance hacia adelante, giro derecha y giro izquierda.
Diagrama 3.1 Diagrama de flujo del control de motores
29
3.2.2 Lectura de sensores
Para poder realizar la lectura y procesamiento de los datos recabados por los sensores
se utilizó la placa Arduino Uno, comunicándola de manera serial con Raspberry. Las
principales funciones de Arduino para el puerto serie son:
• Serial.begin(rate)
Esta instrucción nos permite abrir el puerto serie de Arduino para que inicie
comunicación con cualquier dispositivo conectado vía serial. Asigna una tasa de baudios
para la transmisión de datos serie, la típica es de 9600 bits por segundo, aunque también
otras velocidades están soportadas. Cuando se usa la comunicación serie, los pines
digitales 0 (Rx) y 1 (Tx) no pueden ser usados al mismo tiempo.
• Serial.available()
Da el número de bytes (caracteres) disponibles para leer en el puerto serie, son datos
que han llegado y se almacenan en el buffer serie que tiene un tamaño de 64 bytes.
• Serial.read();
Lee los datos provenientes del puerto serial.
• Serial.println(data)
Imprime datos al puerto serie seguidos de un enter y un avance de línea automáticos,
también permite imprimir en otros formatos especificándolo dentro del paréntesis
después del dato.
• Serial.write()
Escribe datos en binario sobre el puerto serie. El dato es enviado como un byte o serie
de bytes.
Buffer Serial: los puertos serie de los microcontroladores tienen un buffer que se va
llenando hasta que nosotros lo vamos leyendo con la función read() que lo va vaciando,
es una pila FIFO. El tamaño del buffer serie en el Arduino Uno es de 64 bytes, cuando
se llena ese buffer el resto de elementos recibidos se pierden.
Los diagramas de flujo del programa del codificador óptico y el sensor ultrasónico
(Diagrama 3.2) se muestran a continuación.
30
Diagrama 3.2 Diagrama de flujo de sensores
Para el programa del sensor ultrasónico, una vez obtenido el ancho del pulso que es el
tiempo que dura en llegar el eco del ultrasonido, la distancia entre el objeto y el sensor
se puede calcular gracias a la ecuación 2:
𝑣𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑 = 𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 𝑟𝑒𝑐𝑜𝑟𝑟𝑖𝑑𝑎
𝑡𝑖𝑒𝑚𝑝𝑜 (
𝑐𝑚
𝑢𝑠)……………………………….(2)
Donde velocidad es la velocidad del sonido, 0.0343 cm/us y distancia recorrida es dos
veces la distancia hacia al objeto. Planteando nuevamente la ecuación 2 se tiene que la
distancia recorrida es:
𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 (𝑐𝑚) = 𝑡𝑖𝑒𝑚𝑝𝑜 (𝑢𝑠) ∗ 0.017………………………………(3)
Mientras que, en el codificador óptico, se programa el pin de interrupción y la forma en
que se requiera que se haga, en este caso mediante el modo RISING lo que quiere decir
que el contador incrementará en uno cuando el pin cambie de estado bajo a alto. La
distancia recorrida será igual a multiplicar el contador (número de orificios) por la
distancia entre un orificio y otro. Para obtener esta distancia basta con realizar la
siguiente ecuación 4:
𝐷𝑜 =𝐷∗ 𝜋
𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑜𝑟𝑖𝑓𝑖𝑐𝑖𝑜𝑠 (𝑐𝑚)……….…………………………….(4)
31
Donde Do es la distancia entre orificios y D el diámetro del círculo, para nuestro caso:
𝐷𝑜 =5 𝑐𝑚∗ 𝜋
4 (𝑐𝑚)……………………………………………….(5)
𝐷𝑜 = 3.927 𝑐𝑚………………………………………………….(6)
Los diagramas de las funciones de declaración de variables y loop (Diagrama 3.3) se
muestran a continuación:
Diagrama 3.3 Diagrama de flujo de funciones Arduino
32
3.2.3 Interfaz de usuario
Visual Studio
Visual Studio es un entorno de desarrollo integrado (IDE) para Windows. Soporta
distintos lenguajes de programación como C++, C#, Visual Basic, Java, Python, Ruby y
PHP y lenguajes para el desarrollo web. Por su parte, C# es un lenguaje de programación
orientado a objetos basado en C y C++.
El desarrollo de la interfaz gráfica se realizó en este entorno de desarrollo y consta de 3
ventanas. La primera es la ventana de acceso, la segunda el registro de un nuevo
usuario y la ultima es el programa principal donde se muestra el control, programación
de recorridos y la generación del mapa con base a estos.
3.2.3.1 Acceso al sistema y registro
Para la realización de la ventana de acceso (Figura 3.11) se requirió de una conexión a
base de datos la cual se realizó con el programa Microsoft Office Access, el cual permite
almacenar la BD en un archivo .accdb y así, llevar un registro de los usuarios que pueden
acceder al sistema como también dar cabida a nuevos usuarios. Se muestra a
continuacion la ventana y el funcionamiento de cada elemento en la tabla 3.2.
Figura 3.11 Ventana de acceso
4
1
2
3
5
33
Tabla 3.2 Descripción de elementos en ventana de acceso
Con ayuda de la lógica mostrada en el diagrama 3.4 se permite o denega el acceso a la
aplicación, al momento de presionar el botón “Iniciar sesión”.
Diagrama 3.4 Diagrama de flujo de acceso al sistema
La base da datos de Usuarios se compone de los elementos mostrados en la figura
3.12.
Figura 3.12 Elementos de la base de datos en Access
Control Descripción
1 Campo
de texto Introduce el nombre de usuario
2 Campo de texto
Introduce la contraseña
3 Botón Manda la información para intentar acceder al sistema
4 Botón Abre la ventana del formulario para registrar un nuevo usuario
5 Botón Permite salir de la aplicación
34
Donde la llave primaria es el ID del usuaro debido a que es un único número que se
incrementará automáticamente. Aunado a esto se tienen los datos para el registro: el
nombre completo del usuario, el nombre para acceder a la plataforma y la contraseña
propia de cada usuario. También, gracias al botón “Nuevo Usuario” se puede tener
acceso a la ventana de Registro de nuevo usuario, la cual se muestra a continuación en
la figura 3.13 junto con la descripción de sus elementos en la tabla 3.3.
Figura 3.13 Registro de nuevo usuario
Tabla 3.3 Descripción de elementos de ventana de registro de nuevo usuario
Control Descripción
1 Campo de texto Introduce el nombre completo del nuevo usuario
2 Campo de texto Introduce el nombre del nuevo usuario
3 Campo de texto Introduce la contraseña del nuevo usuario
4 Campo de texto Confirmación de la contraseña para el nuevo usuario
5 Campo de texto Introduce la clave proporcionada por el administrador
para poder crear el nuevo usuario
6 Botón Guarda un registro con los datos ingresados
7 Botón Permite volver a la ventana de acceso
La lógica para guardar un nuevo usuario (Diagrama 3.5) se compone de una etapa de
validación del formulario en la cual se determina si existe algún campo sin llenar o
llenado incorrectamente. Después, para completar el registro, se tiene una clave única
proporcionada por el administrador para hacer que no cualquiera pueda registrarse sino
únicamente usuarios destinados para el control de la interfaz y a su vez del robot.
1
2
3
4
5 6
7
7
35
Diagrama 3.5 Diagrama de flujo de registro de nuevo usuario
Finalmente, al regresar a la ventana de “Acceso” aparecerán dos ventanas emergentes
(Figura 3.14 y 3.15) dependiendo de si el usuario y contraseña con correctos o no.
Figura 3.14 Ventana de acceso denegado Figura 3.15 Ventana de acceso permitido
36
3.2.3.2 Registro del acceso y cierre de sesión
Para tener un control y llevar registro de los usuarios que acceden y salen del sistema,
se creó un Log que lleva a cabo la tarea de almacenar dentro de un bloc de notas (.txt)
el nombre del usuario y la hora a la que accedió, así como también se imprime la hora
a la que dio cierre a la sesión.
Esto se logra a través de la clase StreamWriter, donde, con ayuda de un constructor se
inicializa una nueva instancia de la clase para el archivo especificado usando la
codificación y tamaño de búfer especificados. Si el archivo ya existe, es posible
sobrescribirlo o anexarle datos. Si el archivo no existe, este constructor crea uno nuevo.
Finalmente para poder escribir en este archivo una cadena de texto, se hace mediante
el método WriteLine() el cual escribe un terminador de línea en la cadena o secuencia.
Figura 3.16 Archivo .txt para guardar el registro y salida del sistema
37
3.2.3.3 Descripción y estado general
Dentro de la sección de la descripción unicamente se expone un breve resúmen del
robot, dando a conocer su labor, su objetivo y colocando una pequeña ilustración para
hacer más amigable la interfaz.
Posterior a esto se tiene una columna que siempre será mostrada al usuario, la cual
contiene los datos más relevantes del robot como: su estatus, el nivel de batería, la
tarea que está desempeñando en el momento, y una ventana que sirve como ventana
de diálogo entre el cliente (PC) y el servidor (Raspberry Pi). La figura 3.17 nos muestra
los elementos mencionados y en la tabla 3.4 la descripción de sus elementos.
Figura 3.17 Ventana principal
Tabla 3.4 Descripción de los elementos en ventana principal
Elementos Descripción
A Texto e imagen Sección de bienvenida al usuario
B Indicadores Contiene indicadores del estado del robot
C Control de
pestañas
Contiene todas las diferentes ventanas de la aplicación
C
A B
38
El funcionamiento del botón para el estado del robot, funciona gracias a la siguiente
lógica del diagrama 3.6:
Diagrama 3.6 Diagrama de flujo para verificar estado
3.2.3.4 Programación de recorridos
Para la creación de los recorridos (Figura 3.18) y del mapa se creó un sistema basado
en un formulario, el cual el usuario deberá llenar siguiendo un orden establecido y podrá
ver reflejado código por código que se estará guardando en la base de datos y,
finalmente se mostrará dentro de un DataGridView todos los códigos almacenados para
formar así el mapa completo del lugar donde trabajará el robot.
39
Figura 3.18 Ventana para programar recorridos
Tabla 3.5 Descripción de elementos de la ventana para programar recorridos
Elementos Descripción
A Campo de
texto y
botón
Agrega un nuevo recorrido colocando el nombre o de dónde a
dónde irá el robot
B Formulario Define el comportamiento del recorrido especificando la distancia
y dirección del tramo
C Botones Guarda, edita o elimina un recorrido ya ingresado
D Campo de
texto
Espacio para introducir valores de calibración previamente
probados en la parte de “Control Manual”
E Tabla Muestra todos los recorridos guardados
Para poder llenar el formulario que se muestra en la figura 3.19, se deberá llenar en el
siguiente orden:
1) Llenar el nombre del recorrido (Figura 3.19).
Figura 3.19 Primer paso para la programación de recorridos de recorridos
A
B
C
D
E
40
2) Elegir si va a ir hacia adelante o va a girar para dar una vuelta.
En caso de que vaya hacia adelante, colocar la distancia en centímetros y, en caso
de que vaya a dar vuelta, colocar el sentido y el ángulo al que va a ser la vuelta
(Figura 3.20).
Figura 3.20 Segundo paso para la programación de recorridos
3) Una vez que se haya llenado el formulario dar click al botón de “Agregar”, el cual
va a permitir fijar el tramo y lo irá agregando a una cadena. Si aún faltan tramos
por agregar, se repite el proceso anterior hasta que hayamos terminado con el
recorrido (Figura 3.21).
Figura 3.21 Tercer paso para la programación de recorridos
4) Una vez terminado el recorrido, se procede a dar click en el botón “Guardar”
(Figura 3.22) y se almacenará todo el recorrido dentro de una celda del
DataGridView (Figura 3.23).
Figura 3.22 Cuarto paso para la programación de recorridos
41
Figura 3.23 Guardado de recorridos
5) Para agregar más recorridos y que el mapa quede completo se tendrá que repetir
el proceso anterior.
Además de estas funciones se agregaron algunos otros botones para interactuar con la
base de datos como lo es el botón de “Cancelar”, el cual interrumpe la escritura de datos
y reestablece el formulario, el botón “Editar” el cual permite realizar algún cambio en
algún recorrido y el botón “Eliminar” que permite borrar un registro de un recorrido
(Figura 3.22).
Finalmente, la interfaz cuenta con un campo de inserción para valores que ayudan a
ajustar la trayectoria al momento de dar las vueltas, estableciendo una calibración. En
el caso de que estos campos no sean llenados se tomarán los valores ya establecidos
en el programa (Figura 3.24).
Figura 3.24 Calibración de vueltas
42
El diagrama 3.7 muestra la lógica para la parte de la programación de recorridos.
Diagrama 3.7 Diagrama de flujo para la programación de recorridos
3.2.3.5 Generación de mapa
Este apartado, mostrado en la figura 3.25, funciona mediante tres botones descritos en
la tabla 3.6.
Figura 3.25 Ventana para obtener mapa de los recorridos establecidos
1
2
3
4
43
Tabla 3.6 Descripción de los elementos en ventana para obtener mapa de los recorridos
Control Descripción
1 Botón Genera el mapa desde BD de recorridos
2 Botón Abre un mapa guardado en la PC
3 Botón Guarda un mapa en la PC
4 Cuadro de
Imagen
Despliega el mapa creado o abre un mapa guardado
Generar Mapa: Dibuja un mapa con base en el DataGridView de la base de datos,
llenado previamente y tomando como base cada uno de los tramos. En la figura 3.26 se
muestra un ejemplo de un mapa generado.
Figura 3.26 Ejemplo de generación de mapa
Punto de inicio
Recorrido “uno” Recorrido “dos”
Recorrido “tres”
44
Guardar Mapa: Abre una ventana de Guardado en la cual se puede introducir el nombre
y tipo de la imagen (Figura 3.27).
Figura 3.27 Guardado del mapa
Abrir Mapa: Abre una ventana de Archivos donde se puede seleccionar la imagen
(mapa) que se desea que se cargue y se muestre (Figura 3.28).
Figura 3.28 Abrir mapa
45
El algoritmo para la generación del mapa se muestra en el diagrama 3.8:
Diagrama 3.8 Diagrama de flujo para la creación de mapa
46
3.2.3.6 Ejecución de recorridos
Para la ejecución de los recorridos (Figura 3.29) previamente almacenados en la base
de datos, se tiene un pequeño sistema dividido en dos partes: control programado y
control manual.
Control programado
Dentro de este apartado, se debe ingresar únicamente dos datos, el nombre del
recorrido que se desea ejecutar y la hora a la que se desea ejecutar; Posterior a esto,
se presiona el botón “Agregar” el cual permite anexar los dos datos previamente
insertados en una cola, la cual se verá dentro del ListBox. Finalmente se debe encender
este control programado con ayuda de los Radio Buttons.
Esta parte de la interfaz también cuenta con un botón “Borrar”, el cual permite vaciar la
cola en el momento que se requiera. También podemos ver en un pequeño Label la hora
actual de nuestro sistema.
Además, la programación cuenta con una opción de ajuste, cada vez que el robot da
una vuelta ya sea de 90° o 180°, esta opera con ayuda de los campos mencionados en
la Figura 3.24 podemos acceder al control manual, insertar el valor que nosotros
consideremos para el ajuste (se debe tener en cuenta los valores por defecto que ya
tienen la aplicación) y después se procede a presionar el botón “Continuar recorrido”
para que el robot continúe su avance después de haber realizado dicho ajuste.
Control manual
Este control es el más sencillo ya que solo cuenta con cuatro botones los cuales, al darles
click el robot comenzará su avance automáticamente. También este tipo de control
cuenta con su botón de activado a través de los Radio Buttons como en el control
programado.
47
Figura 3.29 Ventana de control para la ejecución de recorridos
Tabla 3.7 Descripción de los elementos en ventana de control
Elemento(s) Descripción
A Formulario Sección del control programado
B Formulario y botones
Sección del control manual
C Formulario Inserción de la hora y el recorrido deseados
D TextBox Selección de los valores de calibración dependiendo el tipo de terreno
E Botones Mover el robot automáticamente al presionar los botones arriba, izquierda , derecha y vuelta de 180°
1 Label Muestra la hora del sistema
2 RadioButtons Opciónes para encender/apagar el tipo de control
3 Botón Elimina la cola de recorridos a ejecutarse
4 Botón Indica que la vuelta se realizó correctamente y que salte al siguiente movimiento del robot
La lógica para el control programado se muestra en el diagrama 3.9.
A
B
2
3
4
D E
C
1
48
Diagrama 3.9 Diagramas de flujo del control del sistema
49
Como se mencionó anteriormente, la ejecución de recorridos comprende un algoritmo
el cual permite realizar un ajuste o calibración al momento de realizar una vuelta; esta
función sirve a primera instancia sólo si el operador está en el mismo lugar que el robot.
Por esta razón se le agregó una cámara IP (que para este prototipo se utilizó la de un
smartphone Android) la cual, con ayuda de la aplicación IP Webcam permite visualizar
en la PC a manera de transmisión en vivo la trayectoria por la que el robot se está
moviendo y de esta forma poder realizar cualquier ajuste en su trayectoria.
3.2.3.7 Salida del sistema
Finalmente en la parte superior derecha de la interfáz, se colocó un pequeño botón (el
cual está siempre visible) que permite salir de la aplicación en el momento en que se
requiera.
Figura 3.30 Salida del sistema
3.2.4 Comunicación
La forma de comunicación entre el robot y la computadora donde estará la interfaz
gráfica para controlarlo, se logra mediante una API REST. Raspberry funciona como
servidor y la computadora como cliente, la conexión se logra cuando los dos están en la
misma red, en este caso conectados al mismo enrutador vía WiFi.
En la figura 3.31 muestra los elementos necesarios para realizar la comunicación entre
un entorno gráfico y la parte mecánica del proyecto:
50
Figura 3.31 Diagrama de comunicación
3.2.4.1 API REST
Una API, por sus siglas en inglés Application Programming Interface (Interfaz de
programación de aplicaciones) permite el acceso a datos y servicios para desarrollar
aplicaciones. Contiene funciones que facilitan el intercambio de información entre
aplicaciones de una computadora sobre una red y usando un lenguaje en común [24].
Una API REST provee características y funciones que permiten el uso de un servicio web
dentro de cualquier aplicación propia.
Las diferencias entre un sitio web y una API es que el primero provee una información
solicitada por cualquier usuario, no tiene estructuras alrededor del uso de contenido y
cualquier cambio es percibido inmediatamente por el usuario [25].
Por su parte, REST (REpresentational State Transfer), es una forma de desarrollo de
servicios web que está construido sobre sistemas y características existentes propias de
internet y sus protocolos. Se basa en una comunicación cliente-servidor. Una API REST
hace a un servicio web RESTful.
Sus objetivos son crear nuevos estándares entre sistemas de computadoras en la web,
desarrollar nuevas tecnologías y simplificar la comunicación entre ordenadores.
Características
Cliente y servidor independientes: el código del cliente o servidor puede ser modificado
en cualquier momento sin afectar la operación del otro.
51
Stateless (Sin estado): Cada solicitud realizada contiene toda la información requerida,
ni el cliente ni el servidor necesitan datos previos para satisfacerla. Por lo tanto, se
puede entender cualquier mensaje.
Interfaz uniforme (UI): El uso de una interfaz uniforme sirve como identificador para
cada recurso del sistema facilitando así, el acceso y la manipulación de la información,
separando los asuntos de interface de usuario de los asuntos de almacenamiento de
datos mejoramos la flexibilidad de la interfaz y la escalabilidad simplificando los
componentes del servidor.
Cliente
Envía solicitudes para recuperar, modificar, crear o remover recursos en el servidor.
Generalmente, una solicitud consiste de las siguientes partes:
Métodos HTTP: Los métodos HTTP indican la operación a realizar y son usados en las
solicitudes para interactuar con los recursos.
• GET: obtener datos del servidor
• DELETE: remover datos del servidor
• PUT: guardar o actualizar los datos del servidor
• POST: crear un nuevo recurso
Cabecera (header): Aquí se especifica el tipo de contenido que es capaz de recibir del
servidor y se asegura que el servidor no envié datos erróneos. Las opciones para los
tipos de contenido son llamados tipos MIME (Multipurpose Internet Mail Extensions), se
dividen en tipos y subtipos y son separados por un /. Por ejemplo, para una imagen:
imagen/png
Camino al recurso: Ayuda al cliente a saber a dónde ir. Debe contener toda la
información necesaria para localizar el recurso. Un ejemplo sería,
café.com/día/223/orden/12 se observa que se está accediendo a la orden 12 del día
223.
Servidor
Realiza la operación especificada por el cliente y avisa sobre el resultado de ésta. Todas
las interacciones comunican su estado usando códigos de estado del estándar HTTP, por
ejemplo:
52
• 200 (OK): Indica una solicitud HTTP correcta.
• 400 (BAD REQUEST): Indica que la solicitud no puede ser procesada por algún
error en el cliente.
• 403 (FORBIDDEN): Indica que el cliente no tiene permitido accede a ese recurso.
• 404 (NOT FOUND): Indica que la fuente solicitada no fue encontrada.
• 500 (INTERNAL SERVER ERROR): Indica un error de aplicación en el servidor.
Para los métodos HTTP existen códigos específicos que el servidor envía como
respuesta:
• GET-200 (OK)
• POST-201 (Creado)
• PUT-200 (OK)
• DELETE-204 (No hay contenido)
Ventajas
• Uso de términos familiares para todo aquel que haya usado los protocolos de
comunicación de internet (HTTP)
• Las aplicaciones REST pueden ser escritas en cualquier lenguaje de programación
como Java, Phyton, .NET o JavaScript [26] [27] [28].
3.2.4.2 IP estática
Un dispositivo con una IP estática, permite utilizar esta dirección todo el tiempo. La
mejor forma de configurar una IP estática es elegir una que quede fuera del rango que
DHCP asigna. Por ejemplo, si un servicio DHCP tiene un rango de 192.168.1.10 a
192.168.1.49, una dirección IP conveniente sería 192.168.1.100 [26].
Para configurar una IP estática en Raspbian se logra mediante el archivo “dhcpd.conf” y
logramos acceder a él con el comando “sudo nano /etc/dhcpcd.conf”.
Agregando únicamente las siguientes líneas de código:
interface eth0
static ip_address=192.168.2.102/24
53
static routers=192.168.2.1
static domain_name_servers=192.168.2.1
interface wlan0
static ip_address=192.168.2.102/24
static routers=192.168.2.1
static domain_name_servers=192.168.2.1
3.2.4.3 Flask
Flask es un micro framework para el desarrollo de aplicaciones web en Python que está
basado en Werkzeug y Jinja 2. La palabra micro se refiere al hecho de flask contiene los
servicios básicos, pero se apoya en extensiones para la adición de funciones avanzadas
a la aplicación tales como bases de datos y formas de autenticación. Gracias a esto,
flask brinda soluciones rápidas y simples al mismo tiempo que tiene las ventajas de ser
escalable y flexible.
• Framework: Un framework es una librería o un conjunto de estas que permiten
la solución de una parte de un problema en vez de uno completo.
• WSGI (Web Server Gateway Interface): Es una interfaz basada en un estándar
para el desarrollo de aplicaciones web en Python. Describe la comunicación entre
un servidor web y las aplicaciones web.
• Werkzeug: Se trata de una librería de WGSI que incluye un depurador, objetos
de solicitud y respuesta, utilidades HTTP, encabezados de control caché, manejo
de cookies, carga de archivos, sistema de enrutamiento URL y módulos de
complementos dados por la comunidad.
• Jinja 2: Son plantillas para Python que permiten la creación de páginas web
dinámicas [29] [30].
Dentro del programa general de Python se especificó la ruta a seguir para poder acceder
a las diferentes opciones de control. El primer paso fue importar las librerías flask y una
vez definidas las funciones de control de motores, se creó una instancia app con el
argumento __name__. Después se especificó la ruta con la cual se puede acceder a las
opciones de control:
54
@app.route('/gpio/enable/<int:direccion>/<float:distancia>/<int:vuelta>',
methods=['GET'])
Esta ruta se coloca después de la dirección IP de la Raspberry y de su puerto, a partir
de tercera diagonal encontramos variables que hacen referencia a cada opción,
mostradas a continuación, para el control del robot móvil.
• <int:direccion> : Especifica que dirección tomará el robot. Tomará el valor de 0
si la instrucción es avanzar hacia delante o 1 si la instrucción es una vuelta.
• <float:distancia> : Tomará el valor especificado por el usuario para un avance
hacia adelante. En el caso de los giros tanto derecha como a la izquierda a 90° y
180°, los valores ya están establecidos ya que siempre serán los mismos, aunque
dentro de la interfaz gráfica hay una opción de calibración debido a la variación
de velocidad y comportamiento de las llantas en distintos tipos de suelo.
• <int:vuelta> : Si se requiere una vuelta hacia la derecha tomará el valor de 1 y
hacia la izquierda un valor de 2.
Un ejemplo de una ruta completa es:
192.168.2.101:8080/gpio/enable/1/29.2/2
Se ve especificada la dirección IP de la Raspberry, su puerto y con esta combinación el
robot girará hacia la izquierda 90°.
El diagrama de este control mediante una ruta es el mostrado en el diagrama 3.10:
55
Para comprobar la conexión existe otra ruta definida de la siguiente forma:
@app.route('/status', methods=['GET'])
De la misma forma se accede escribiendo la dirección IP y el puerto. Esta función retorna
un ‘ALIVE’ cuando el servidor está disponible.
El diagrama general de conexiones del sistema es el siguiente:
Diagrama 3.10 Diagrama de flujo del control mediante una ruta
56
Diagrama 3.12 Diagrama eléctrico del sistema
Diagrama 3.11 Diagrama de conexiones
L298N
FC-03 HC-SR04
Arduino Raspberry Pi
Bate
ría
Motor A Motor B
Batería
5v
57
4 Capítulo 4. Pruebas y resultados
Durante este capítulo se presentan las pruebas realizadas al prototipo con base en las
características que debe cumplir un robot móvil, redactadas en el capítulo 2 y también
algunas pruebas que son solicitadas en los concursos de robótica del país.
4.1 Percepción
Esta característica se ve reflejada en el sensor ultrasónico. Se realizaron pruebas
programando que el robot se detuviera cuando encontrara un obstáculo a menos de 15
cm. Los resultados (Tabla 4.1) son los siguientes:
Tabla 4.1 Pruebas de precepción
Percepción (ultrasónico)
No de prueba
Distancia robot-objeto inicial
Distancia robot-objeto medida
Distancia robot-objeto esperada
1 30cm 10cm 15cm
2 1m 7cm 15cm
3 1.30cm 11cm 15cm
4 2m 7.5cm 15cm
5 3m 9cm 15cm
La distancia medida cuando se colocó un objeto frente al robot en movimiento (Figura
4.1 y 4.2), en todos los casos, entra dentro del rango permisible. En ninguna prueba el
robot colisionó, con lo que podemos concluir que la percepción del sistema es adecuada.
Figura 4.1 Posiciones iniciales para pruebas de percepción
58
4.2 Accesibilidad
Al ser un robot móvil posee únicamente 2 grados de libertad, hacia delante y atrás y
giro izquierda o derecha (flechas roja y naranja respectivamente de la figura 4.3).
Figura 4.3 Grados de libertad
4.3 Capacidad de carga
El prototipo, al ser un robot móvil de transporte, se le adaptó un pequeño cajón para
poder guardar materiales. Las pruebas realizadas para conocer el límite de peso que
podía transportar el sistema de manera satisfactoria se encuentran registradas en la
tabla 4.2.
Figura 4.2 Distancia obtenida de la prueba 3 de percepción
59
Tabla 4.2 Pruebas de capacidad de carga
Capacidad de Carga
Peso adicional (kg) Realizado correctamente Observaciones
0 SI Trabaja correctamente
1 SI Trabaja correctamente
1.2 SI Trabaja correctamente
1.4 SI Trabaja correctamente
1.6 SI Trabaja correctamente
1.8 SI No recomendable (presenta ciertas dificultades)
2 NO Peso excedido
3 NO Peso excedido
5 NO Puede dañar el mecanismo
Como podemos observar, el prototipo solo responde correctamente con pesos menores
a 2 kg puestos en el cajón. Esto se debe principalmente a que el prototipo se realizó con
la ayuda de una base de metal de un robot de competencia que pesa por si sola 5 kg,
además de que las llantas acondicionadas no soportan mucho peso. Sin embargo, para
el transporte de materiales ligeros trabaja de manera adecuada.
4.4 Tiempo de respuesta
Está dado por lo que requiera la aplicación, en este caso, si el robot móvil se requiere a
una hora específica para que esté posicionado en cualquiera de los puntos programados,
será el tiempo que tarda (con cierta tolerancia) en llegar a este lugar.
Para estas pruebas se tomaron dos tiempos, el t1 se refiere al tiempo transcurrido entre
el inicio del recorrido en la interfaz gráfica y el arranque mecánico del sistema y el t2 es
el tiempo que tarda desde el arranque hasta que completa el recorrido. Los resultados
se muestran en la tabla 4.3.
60
Tabla 4.3 Pruebas de tiempo de respuesta
Los tiempos de respuesta varían mínimamente entre las pruebas realizadas. La primera
con un recorrido de avanzar 2 metros hacia adelante y la segunda con un recorrido más
elaborado: avanzar 1 metro hacia adelante, dar una vuelta a la derecha, 1.3 metros
hacia adelante, vuelta a la derecha y finalmente 1 metro hacia adelante. Debido a que
los tiempos son muy parecidos, podemos asegurar un adecuado tiempo de respuesta
del sistema.
4.5 Resolución
Para medir esta característica, se colocaron en el suelo distintas marcas para observar
la llegada final del robot. Se delimitaron tres áreas (Figura 4.4), la primera es el espacio
esperado donde el robot llegará y las áreas 2 y 3 son permisibles para obtener un error
pequeño.
Figura 4.4 Delimitación de áreas para pruebas de resolución
Tiempo de respuesta
No prueba
Recorrido 1 (2m adelante) Recorrido 2 (1m-A, vueltaD, 1.3m-A, vueltaD, 1m-A )
t1 (s) t2 (s) t1 (s) t2 (s)
1 1.55 12.86 2.11 30.21
2 2.12 12.48 2.15 29.83
3 2.7 12.49 1.58 31.11
4 2.1 12.53 2.12 31.77
61
La tabla 4.4 muestra los resultados de las pruebas realizadas para la característica de
resolución sin peso extra y la tabla 4.5 con un peso extra de 2 kg. Todas las pruebas
fueron con un recorrido en forma de ‘L’ con avance de 1.5 metros hacia adelante, giro
izquierda y avance 1.5 metros.
Tabla 4.4 Pruebas de resolución sin peso
Resolución (sin peso)
No. Prueba Dentro de área 1
1 SI
2 SI
3 SI
4 SI
5 SI
6 SI
Tabla 4.5 Pruebas de resolución con peso
Resolución (con peso)
No. Prueba Dentro de área 1 Dentro de área 2 y 3 Fuera de áreas
1 SI
2 SI
3 SI
4 SI
5 SI
6 SI
Los resultados obtenidos casi siempre cayeron dentro de las áreas delimitadas, excepto
en una ocasión. El comportamiento es mejor sin un peso extra de 2 kg, pero aun con
éste solo una vez cayó fuera del rango, con lo que se puede concluir que el sistema tiene
buena resolución. En las figuras 4.5, 4.6, y 4.7 se muestran algunas fotos
correspondientes a estas pruebas.
62
Figura 4.7 Prueba 2 de resolución con peso vista frontal
4.6 Precisión
Se programaron recorridos rectilíneos de diferentes distancias para medir este
parámetro, se colocaron marcas en el suelo para saber la distancia exacta que debería
avanzar el prototipo. Se realizaron pruebas sin peso y con un peso extra de 2 kg. Los
resultados se muestran en la tabla 4.6 y 4.7, respectivamente.
Figura 4.5 Prueba 2 de resolución con peso
vista superior Figura 4.6 Prueba 4 de resolución sin peso
63
Tabla 4.6 Pruebas de precisión sin peso
Precisión (sin peso)
No. Prueba Hacia adelante 1 m 2 m 3 m 4 m 5 m
1 +4 cm 0 cm -7.5 cm -1.5 cm +10 cm
2 -0.5 cm -4 cm +2 cm +5 cm +23 cm
3 +5.5 cm -4.5 cm +3 cm +17 cm +17 cm
4 +1.5 cm +1 cm +1 cm +11 cm +13 cm
5 -3 cm -0.5 cm -0.5 cm +23 cm +25 cm
6 +2.5 cm +1 cm +1 cm +35 cm +33 cm
¿Están dentro del límite permisible de ±10? SI SI SI NO NO
Tabla 4.7 Pruebas de precisión con peso
Precisión (con peso)
No. Prueba Hacia adelante 1 m 2 m 3 m 4 m
1 +4 cm +3.5 cm -3.5 cm +13.5 cm
2 +9 cm -1.5 cm -1.5 cm -4.5 cm
3 -4 cm +6 cm +9.5 cm +16 cm
4 +3 cm +3 cm +5.5 cm +11 cm
¿Están dentro del límite permisible de ±10? SI SI SI NO
Las pruebas reflejan un buen comportamiento en distancias cortas, a distancias mayores
de 3 metros se empiezan a ver errores de precisión mayores a 10 centímetros.
4.7 Autonomía
El sistema es parcialmente autónomo o semiautónomo, ya que solo cumple con las
características 1, 2, 3 para ser un robot completamente autónomo
4.8 Salida de la trayectoria
Para este rubro se determinó que el robot móvil no cumple con la inteligencia suficiente
para volver a la trayectoria de forma autónoma cuando se salga de esta y retomar su
camino. Sin embargo, se propone una alternativa de solución a este requerimiento con
64
el cual permite pasar de un control programado a un control manual en caso de que el
dispositivo salga de la trayectoria.
4.9 Control del mecanismo
El prototipo cuenta con dos opciones de paro de emergencia. La primera consiste en un
switch integrado en la carcasa del robot el cual permite realizar un completo apagado
del sistema. La segunda se compone de un botón dentro de la interfaz gráfica con el
cual se inicia una interrupción y aborta cualquier tarea haciendo que el sistema se
detenga completamente sin interrumpir la comunicación.
4.10 Alcance de la comunicación
El enrutador que se utilizó para poder realzar la comunicación vía WiFi entre el robot y
la interfaz gráfica en una PC, brinda un alcance de 100 m. Para comprobar esto se
hicieron pruebas en el pasillo del primer piso del edificio 5 de la escuela, todos los
recorridos fueron rectilíneos variando la distancia. Los resultados se encentran en la
tabla 4.8.
Tabla 4.8 Pruebas de alcance de la comunicación
Alcance de la comunicación
No. Prueba Distancia (m) Realizado correctamente
1 9 SI
2 15 SI
3 20 SI
4 30 SI
5 50 SI
6 85 SI
Al observar los resultados se puede concluir que el alcance de conexión es el adecuado
para las aplicaciones del proyecto.
65
4.11 Transmisión de video
Se colocó un Smartphone, con una aplicación integrada llamada IP Webcam que simula
este tipo de cámara utilizando la del Smartphone, en la parte de enfrente del prototipo
para que grabe los recorridos programados (Figura 4.8). Además, se colocó una flecha
para poder visualizar si era necesario realizar una calibración en el momento de los giros
del robot. Al momento de abrir la aplicación, esta brinda una dirección IP para ingresar
desde cualquier navegador y poder observar el video en vivo.
En la figura 4.9 se muestra la interfaz gráfica en PC junto con la dirección IP dada por
la aplicación desde un navegador web donde se observa la grabación de la cámara.
Figura 4.8 Cámara puesta en prototipo
Figura 4.9 Interfaz gráfica junto con video en vivo en PC
66
5 CONCLUSIONES
El prototipo construido para el transporte demostró con base en las pruebas realizadas
ser un sistema semiautónomo funcional. Sin embargo, se observó un error producido
por el sistema de locomoción, específicamente las ruedas debido a distintos aspectos
como la desalineación de estas, la cantidad de peso con la que trabajan, pero sobre todo
la interacción con suelos desiguales o que presenten alguna deformación.
Además, gracias a las pruebas realizadas de percepción, precisión, resolución
rendimiento de la batería, capacidad de carga y alcance de la comunicación es posible
decir que el robot demostró ser un sistema robusto y bastante completo para su
aplicación, tomando en cuenta las distancias que recorrerá y el tiempo de labor diaria
que tendría que realizar. Cabe destacar que la mejor prueba realizada fue la de la
comunicación, dotando al sistema de un muy alto alcance para su operación en grandes
espacios y desde grandes distancias sin perder comunicación.
La interfaz gráfica contiene elementos visuales que facilitan el control del sistema,
además de que no se requiere ninguna instalación de algun software externo para su
funcionamiento. Respecto a la función de programación de horarios este responde al
tiempo que requiere el usuario con una óptima respuesta para inicializar su recorrido.
La aplicación de transmisión resultó ser funcional debido a que resultó ser en tiempo
real, con un ligero desfase pero que finalmente permite realizar ajustes sin la necesidad
de ver directamente el prototipo.
Finalmente, se demostró que los resultados cumplieron con los objetivos del proyecto.
Esto se logró en gran parte al algoritmo implementado que permite realizar un ajuste a
la función de giro y a la cámara que permite ver la posición del robot.
67
6 REFERENCIAS
[1] VINSSA (2017). La historia y evolución de los robots móviles. 24 de febrero.
[2] Aracil, R., Balaguer, C. and Armada, M. (2008). “Robots de servicio”. Revista
Iberoamericana de Automática e Informática Industrial RIAI, 5(2), pp.6-13.
[3] http://www.mobile-industrial-robots.com/en/resources/case-studies/mobile-
robots-deliver-chemotherapy/ [Consultado junio 2017]. Derechos de autor [2016-2017]
por Mobile Industrial Robots ApS. Reimpresión autorizada
[4] http://www.mobile-industrial-robots.com/case-study/2ccc2f4b-12c6-11e7-9f6e-
0292f2941023 [Consultado junio 2017].
[5] https://www.lasaspiradoras.com/test-robot-aspiradora-xiaomi-mi/ [Consultado
Agosto 2017].
[6] https://www.notisistema.com/noticias/crean-a-aura-el-robot-de-servicio-a-
cuartos/ [Consultado Agosto 2017]. Derechos de autor [2014] por Notisistema.
Reimpresión autorizada
[7] Aníbal Ollero Baturone, A. (2001). Robotica. Manipuladores y robots móviles.
Barcelona, España: Marcombo Boixareu, pp.4-6, 28-32, 147-148.
[8] Vázquez Fernández-Pacheco, A. (2016). Robótica educativa. Madrid: Ra-Ma, pp.67,
68.
[9] Saha, S. (2011). Introducción a la Robotica. España: McGraw-Hill, p.54.
[10] García, J. (2012). Mapeo con robot móvil: Construcción y seguimiento. Universidad
Autónoma de Barcelona.
[11]https://www.xataka.com/especiales/alternativas-a-la-raspberri-pi-7-modelos-de-
miniordenadores-baratos-en-los-que-deberias-pensar [Consultado Julio 2018]
[12]https://www.vix.com/es/btg/tech/13220/los-mejores-ides-y-editores-para-
programadores [Consultado Julio 2018]
[13]https://therobotacademy.com/ros/4-principales-sistemas-operativos-para-
raspberry-pi [Consultado Julio 2018]
[14] https://www.iso.org [Consultado Agosto 2018]
[15] https://www.robomatrix.org [Consultado Agosto 2018]
68
[16] https://www.femexrobotica.org [Consultado Agosto 2018]
[17] Date, C. (1987). Introducción a los sistemas de bases de datos. Wilmington
(Delaware): Addison-Wesley Iberoamericana.
[18] https://www.prometec.net/l298n/ [Consultado Julio 2018]
[19]https://www.amgkits.com/home/112-sensor-de-velocidad-infrarrojo-fc-03.html
[Consultado Julio 2018]
[20]https://www.keyence.com.mx/ss/products/sensor/sensorbasics/ultrasonic/info/
[Consultado Julio 2018]
[21] http://arduino.cl/que-es-arduino/ [Consultado Julio 2018]
[22] Carballar Falcon, J. (2010). Wi-fi. Madrid: RC Libros, pp.1, 2.
[23]http://www8.hp.com/ve/es/campaigns/wireless-printing-center/wireless-network-
help4.html?jumpid=re_r11400_wireless_easy_cs_redirect [Consultado Mayo 2018]
[24] Masse, M. (2012). REST API Design Rulebook. 1st ed. Sebastopol, CA: O'Reilly,
pp.5, 6.
[25] Jacobson, D., Brail, G. and Woods, D. (2012). APIs: A strategy guide. Sebastopol,
CA: O'Reilly, pp.4-6.
[26]https://bbvaopen4u.com/es/actualidad/api-rest-que-es-y-cuales-son-sus-
ventajas-en-el-desarrollo-de-proyectos [Consultado Abril 2018]
[27] https://www.codecademy.com/articles/what-is-rest [Consultado Abril 2018]
[28]https://searchmicroservices.techtarget.com/definition/REST-representational-
state-transfer [Consultado Abril 2018]
[29] http://flask.pocoo.org/ [Consultado Mayo 2018]
[30]https://www.tutorialspoint.com/flask/flask_overview.htm [Consultado Mayo 2018]
69
7 ANEXO A
CÓDIGO DE LA INTERFAZ GRÁFICA
FORM1 (Ventana de acceso)
Bibliotecas utilizadas
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; using System.Data.OleDb; using Microsoft.Win32; using System.Collections; using System.IO;
Declaración de variables/objetos
OleDbConnection conexion = new OleDbConnection("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\Users\\Edgar\\Desktop\\9CM11\\Tesis\\Prueba interfaz 1\\Prueba interfaz 1\\bin\\Debug\\dbUsuarios.accdb"); OleDbCommand comando = new OleDbCommand();
internal static StreamWriter file = new StreamWriter("log.txt", true);
Botones
private void btnIniciar_Click(object sender, EventArgs e) { conexion.Open();
string consulta = "select Usuario, Contraseña from Usuarios where Usuario='" + tbUsuario.Text + "' and Contraseña='" + tbContraseña.Text + "';";
OleDbCommand comando = new OleDbCommand(consulta, conexion); OleDbDataReader leer_datos; leer_datos = comando.ExecuteReader(); Boolean existencia = leer_datos.HasRows; if (existencia) { MessageBox.Show("Bienvenido"); Form3 frmprincipal = new Form3(); frmprincipal.Show();
file.WriteLine("El usuario " + tbUsuario.Text.ToString() + " accedió al sistema a las: " + DateTime.Now.ToString());
} else { MessageBox.Show("Acceso denegado, verifica usuario o contraseña"); conexion.Close(); return; } conexion.Close();
70
this.Hide(); }
private void btnNuevo_Click(object sender, EventArgs e) { this.Hide(); Form2 frmRegistro = new Form2(); frmRegistro.Show(); } private void btnSalir_Click(object sender, EventArgs e) { this.Close(); }
FORM2 (Registro de nuevo usuario)
Bibliotecas utilizadas
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; using System.Data.OleDb;
Declaración de variables/objetos
OleDbConnection conexion = new OleDbConnection("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\Users\\Edgar\\Desktop\\9CM11\\Tesis\\Prueba interfaz 1\\Prueba interfaz 1\\bin\\Debug\\dbUsuarios.accdb"); OleDbCommand comando = new OleDbCommand();
string PassAdmin = "1234";
Botones
private void btnRegresar_Click(object sender, EventArgs e) { this.Close(); Form1 frminicio = new Form1(); frminicio.Show(); } private void btnGuardar_Click_1(object sender, EventArgs e) { if(tBadmin.Text == PassAdmin) {
if (tbNombreR.Text == "") { MessageBox.Show("Hay campos sin llenar."); } else if (tbUsuarioR.Text == "") { MessageBox.Show("Hay campos sin llenar."); } else if (tbContraseñaR.Text == "") { MessageBox.Show("Hay campos sin llenar."); } else if (tbContraseñaR2.Text == "") { MessageBox.Show("Hay campos sin llenar."); }
else
71
{ conexion.Open(); int i = 0; comando.Connection = conexion;
comando.CommandText = "INSERT INTO [Usuarios]([Nombre Completo], [Usuario], [Contraseña]) VALUES('" + tbNombreR.Text + "','" + tbUsuarioR.Text + "','" + tbContraseñaR.Text + "')";
i = comando.ExecuteNonQuery(); {
comando.Parameters.AddWithValue("@Nombre Completo", tbNombreR); comando.Parameters.AddWithValue("@Usuario", tbUsuarioR); comando.Parameters.AddWithValue("@Contraseña", tbContraseñaR); MessageBox.Show("Guardado"); } } } else {
MessageBox.Show("Necesitas introducir la contraseña que te proporcionará el administrador del sistema");
} }
FORM3 (Ventana principal)
Bibliotecas utilizadas
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; using System.Drawing.Imaging; using System.IO; using System.Threading;
Declaración de variables/objetos globales
Image File;
float[] tramo = new float[4]; Queue<string> tiempos = new Queue<string>(); Queue<string> codigos = new Queue<string>(); Queue<string> codigosRestantes = new Queue<string>(); float avanza = 100.1F; float daVueltanoventa = 29.3F; float daVueltacientochenta = 53.1F; string direccion = "http://192.168.2.102:8080/gpio/enable/"; bool flagAjuste = false;
72
Programación de recorridos
Botones
private void btNew_Click(object sender, EventArgs e) { lblDistancia.Visible = false; tbDistancia.Visible = false; rbtnDerecha.Visible = false; rbtnIzquierda.Visible = false; rbtn90.Visible = false; rbtn180.Visible = false; lblmet.Visible = false; recorridoBindingSource.AddNew(); panel5.Enabled = true; btCancel.Visible = true; btSave.Enabled = true; btCancel.Visible = true; btSave.Enabled = true; tbNombreRec.Focus(); }
private void btnAgregarPaso_Click_1(object sender, EventArgs e) { if (tbNombreRec.Text == "") { MessageBox.Show("Hay campos sin llenar."); } else { string nombreRec; float z = 0; bool bandera2 = float.TryParse(tbDistancia.Text, out z); nombreRec = tbNombreRec.Text; if (rbtnAdelante.Checked == true) { if (bandera2 == true) { tramo[1] = 0; tramo[2] = (float.Parse(tbDistancia.Text)); tramo[3] = 0; string codigo = tramo[1] + "/" + tramo[2] + "/" + tramo[3]; tbArreglo.AppendText(codigo + ","); lBrecorrido.Items.Add(codigo); } else {
MessageBox.Show("Valor no válido (coloca un número entero o flotante).");
} } else if (rbtnVuelta.Checked == true) { tramo[1] = 1; if (rbtnDerecha.Checked == true) {
73
tramo[3] = 1; if (rbtn90.Checked == true) { if (tBv90.Text == ""){daVueltanoventa = 29.3F;} else {daVueltanoventa = float.Parse(tBv90.Text);} tramo[2] = daVueltanoventa; } else { if (tBv180.Text == "") { daVueltacientochenta = 53.1F; }
else { daVueltacientochenta = float.Parse(tBv180.Text); } tramo[2] = daVueltacientochenta; } } else { tramo[3] = 2; if (rbtn90.Checked == true) { if (tBv90.Text == "") { daVueltanoventa = 29.3F; } else { daVueltanoventa = float.Parse(tBv90.Text); } tramo[2] = daVueltanoventa; } else { if (tBv180.Text == "") { daVueltacientochenta = 53.1F; }
else { daVueltacientochenta = float.Parse(tBv180.Text); } tramo[2] = daVueltacientochenta; } } string codigo = tramo[1] + "/" + tramo[2] + "/" + tramo[3]; tbArreglo.AppendText(codigo + ","); } } }
private void btSave_Click(object sender, EventArgs e) { if (!(tbArreglo.Text == "") || (tbArreglo.Text== null) ) { string codigo_final = tbArreglo.Text; tbArreglo.Text = codigo_final.Substring(0, codigo_final.Length - 1); try { this.recorridoBindingSource.EndEdit();
this.recorridoTableAdapter.Update(bdRecorridos1DataSet.Recorrido);
this.recorridoDataGridView.Refresh(); } catch (Exception exc) {
MessageBox.Show(exc.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
recorridoBindingSource.ResetBindings(false); } } }
private void btEdit_Click(object sender, EventArgs e) {
74
panel5.Enabled = true; btCancel.Visible = true; btSave.Enabled = true; tbNombreRec.Focus(); }
private void btDrop_Click(object sender, EventArgs e) {
if (MessageBox.Show("¿Desea borrar el registro?", "Borra registro", MessageBoxButtons.YesNo) == DialogResult.Yes)
{ this.recorridoTableAdapter.Delete(Convert.ToInt32(nombreTextBox.Text)); this.bdRecorridos1DataSet.Recorrido.Rows.RemoveAt(this.recorridoDataGridView.CurrentCell.RowIndex);
this.recorridoTableAdapter.Update(bdRecorridos1DataSet.Recorrido); } }
Generación del Mapa
Botones
private void button1_Click(object sender, EventArgs e) {
pB1.Image = new Bitmap(pB1.Width, pB1.Height); Graphics g = Graphics.FromImage(pB1.Image); g.Clear(System.Drawing.Color.White); g.DrawLine(Pens.Blue, 272 - 5, 216, 272, 216 - 5); g.DrawLine(Pens.Blue, 272 - 5, 216, 272 + 5, 216); g.DrawLine(Pens.Blue, 272 + 5, 216, 272, 216 - 5); for (int h = 0; h < int.Parse(recorridoDataGridView.RowCount.ToString()); h++) { int x = 272; int y = 216; int dx = 272; int dy = 216; string codigo; int[] direcciones = new int[4] { 1, 2, -1, -2 }; int[] aux = new int[4]; int auxiliar = 0; codigo = (string)recorridoDataGridView.Rows[h].Cells[2].Value; string[] codigo_leido = codigo.Split(','); for (int i = 0; i <= codigo_leido.Length - 1; i++) { string[] valores = codigo_leido[i].Split('/'); if (i == 0) { logicaMapa(aux,direcciones,valores,auxiliar,x,y,dx,dy); } else {
75
x = dx; y = dy; logicaMapa(aux, direcciones, valores, auxiliar, x, y, dx, dy); } } } g.Dispose(); } private void Save_map_Click(object sender, EventArgs e) { SaveFileDialog sfd = new SaveFileDialog(); sfd.Filter = "Images|*.png;*.bmp;*.jpg"; ImageFormat format = ImageFormat.Png; if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK) { string ext = System.IO.Path.GetExtension(sfd.FileName); switch (ext) { case ".jpg": format = ImageFormat.Jpeg; break; case ".bmp": format = ImageFormat.Bmp; break; } pB1.Image.Save(sfd.FileName, format); } } private void button2_Click(object sender, EventArgs e) { OpenFileDialog f = new OpenFileDialog(); f.Filter = "PNG(*.PNG)|*.ppg"; if (f.ShowDialog() == DialogResult.OK) { File = Image.FromFile(f.FileName); pB1.Image = File; } }
Funciones
public void logicaMapa(int[] aux, int[] direcciones, string[] valores,int auxiliar, int x, int y, int dx, int dy) { Graphics g = Graphics.FromImage(pB1.Image);
if (valores[0] == "0") { if (direcciones[auxiliar] == 1) { dy = dy - 20; g.DrawLine(Pens.Red, x, y, dx, dy);
g.DrawLine(Pens.Blue, dx - 5, dy, dx, dy - 5); g.DrawLine(Pens.Blue, dx - 5, dy, dx + 5, dy); g.DrawLine(Pens.Blue, dx + 5, dy, dx, dy - 5); } else if (direcciones[auxiliar] == 2) {
76
dx = dx + 20; g.DrawLine(Pens.Red, x, y, dx, dy);
g.DrawLine(Pens.Blue, dx, dy - 5, dx, dy + 5); g.DrawLine(Pens.Blue, dx, dy + 5, dx + 5, dy); g.DrawLine(Pens.Blue, dx + 5, dy, dx, dy - 5); } else if (direcciones[auxiliar] == -1) { dy = dy + 20; g.DrawLine(Pens.Red, x, y, dx, dy);
g.DrawLine(Pens.Blue, dx - 5, dy, dx + 5, dy); g.DrawLine(Pens.Blue, dx - 5, dy, dx, dy + 5); g.DrawLine(Pens.Blue, dx, dy + 5, dx + 5, dy); } else if (direcciones[auxiliar] == -2) { dx = dx - 20; g.DrawLine(Pens.Red, x, y, dx, dy);
g.DrawLine(Pens.Blue, dx, dy - 5, dx - 5, dy); g.DrawLine(Pens.Blue, dx - 5, dy, dx, dy + 5); g.DrawLine(Pens.Blue, dx, dy + 5, dx, dy - 5); } } else { if (valores[2] == "2") {
if (valores[1] == Convert.ToString(daVueltanoventa)) { auxiliar += auxiliar - 1; if (auxiliar == -1) { auxiliar = 3; } for (int j = 0; j <= 3; j++) { aux[j] = direcciones[j]; } } else { auxiliar += auxiliar + 2; if (auxiliar == 4) { auxiliar = 0; } for (int j = 0; j <= 3; j++) { aux[j] = direcciones[j]; } } } else {
if (valores[1] == Convert.ToString(daVueltanoventa)) { auxiliar += 1; if (auxiliar == 4) { auxiliar = 0; } for (int j = 0; j <= 3; j++) { aux[j] = direcciones[j]; } } else { auxiliar += 2; if (auxiliar == 4) { auxiliar = 0; } for (int j = 0; j <= 3; j++)
77
{ aux[j] = direcciones[j]; } } } } }
Control/Ejecución de recorridos
Botones
private void timer1_Tick(object sender, EventArgs e) { lblHoraAct.Text = DateTime.Now.ToString("HH:mm:ss:f"); if (radioButton1.Checked) { if (!(tiempos == null || tiempos.Count == 0) ) { string paquete_leido; paquete_leido = tiempos.Peek(); string[] paquete_split = paquete_leido.Split(','); tBhoraDeseada.Text = Convert.ToString(paquete_split[0]); tBsearch.Text = Convert.ToString(paquete_split[1]); if (lblHoraAct.Text == tBhoraDeseada.Text + ":1") { string[] arreglo = null; arreglo = ConsultaRecorrido(tBsearch.Text);
for (int i = 0; i < arreglo.Length; i++) { codigos.Enqueue(direccion + arreglo[i]); lBrecorrido.Items.Add(arreglo[i] + "\n\r"); } if (!(codigos == null || codigos.Count == 0)) { ThreadStart delegado = new ThreadStart(Control); Thread hilo = new Thread(delegado); hilo.Start(); } tiempos.Dequeue();
recorridoDataGridView.DataSource = recorridoBindingSource; } } } }
private void btAgregar_Click(object sender, EventArgs e) { if ((tiempos == null || tiempos.Count == 0)) { string paquete = tBhoraDeseada.Text + "," + tBsearch.Text; tiempos.Enqueue(paquete); lBtiempos.Items.Clear(); foreach (string item in tiempos)
78
{ lBtiempos.Items.Add(item); } } else { string paquete = tBhoraDeseada.Text + "," + tBsearch.Text; string hora = tBhoraDeseada.Text; string hora_des = hora.Substring(0, 5); string[] hora_des_split = hora_des.Split(':'); string paquete_pico = tiempos.Peek(); string hora_pico = paquete_pico.Substring(0, 5); string[] hora_pico_split = hora_pico.Split(':'); string tdeseado = hora_des_split[0] + hora_des_split[1]; string tpico = hora_pico_split[0] + hora_pico_split[1]; if ((Convert.ToInt32(tdeseado)) - (Convert.ToInt32(tpico)) <= 20) {
MessageBox.Show("Debes de dejar una tolerancia de 20 min como mínimo para el siguente recorrido");
} else { tiempos.Enqueue(paquete); lBtiempos.Items.Clear(); foreach (string item in tiempos) { lBtiempos.Items.Add(item); } } } }
private void btBorralista_Click(object sender, EventArgs e) { lBtiempos.Items.Clear(); tiempos.Clear(); }
private void button3_Click(object sender, EventArgs e) { try { peticionServidor(direccion + "0/" + avanza + "/0"); } catch (ApplicationException err) {
debugOutput("Ocurrió un error al contactar con el dispositivo remoto:" + err); } finally{} } private void derecha_Click(object sender, EventArgs e) { if (tBvuelta90.Text == "") { daVueltanoventa = 29.3F; } else
79
{ daVueltanoventa = float.Parse(tBvuelta90.Text); } try { peticionServidor(direccion + "1/" + daVueltanoventa + "/1"); } catch (ApplicationException err) {
debugOutput("Ocurrió un error al contactar con el dispositivo remoto:" + err); } finally { } } private void izquierda_Click(object sender, EventArgs e) { if (tBvuelta90.Text == "") { daVueltanoventa = 29.3F; } else { daVueltanoventa = float.Parse(tBvuelta90.Text); } try { peticionServidor(direccion + "1/" + daVueltanoventa + "/2"); } catch (ApplicationException err) {
debugOutput("Ocurrió un error al contactar con el dispositivo remoto:" + err); } finally { } } private void button3_Click_1(object sender, EventArgs e) { if (tBvuelta90.Text == "") { daVueltacientochenta = 53.1F; } else { daVueltacientochenta = float.Parse(tBvuelta180.Text); } try { peticionServidor(direccion + "1/" + daVueltacientochenta + "/1"); } catch (ApplicationException err) {
debugOutput("Ocurrió un error al contactar con el dispositivo remoto:" + err); } finally { } } private void ajusteYA_Click(object sender, EventArgs e) { flagAjuste = true; }
80
Funciones
public string[] ConsultaRecorrido(string recBusqueda) { string[] recSolicitado = null; if (string.IsNullOrEmpty(tBsearch.Text)) { recorridoDataGridView.DataSource = recorridoBindingSource; } { var query = from o in this.bdRecorridos1DataSet.Recorrido where o.Nombre == tBsearch.Text select o; recorridoDataGridView.DataSource = query.ToList(); } string valor_leido; valor_leido = (string)recorridoDataGridView.Rows[0].Cells[2].Value; recSolicitado = valor_leido.Split(','); return recSolicitado; } public string peticionServidor(string url) { RestClient rClient = new RestClient(); rClient.endPoint = url; debugOutput("Rest Client Created"); string strResponse = rClient.makeRequest(); debugOutput(strResponse); return strResponse; } public void Control() { try { foreach (var item in codigos) { if (item.StartsWith(direccion + "1")) { peticionServidor(item);
const string message = "¿Deseas continuar con el recorrido?"; const string caption = "Form Closing"; var result = MessageBox.Show(message, caption, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (result == DialogResult.No) { flagAjuste = false; do { } while (flagAjuste == false); } }
81
else { peticionServidor(item); } } } catch (ApplicationException err) {
debugOutput("Ocurrió un error al contactar con el dispositivo remoto:" + err); } finally { codigos.Clear(); } }
CÓDIGO PYTHON
Bibliotecas utilizadas
#!flask/bin/python from flask import Flask, jsonify from flask import abort from flask import make_response import RPi.GPIO as GPIO from flask import request import time import serial from array import array from time import sleep import socket import subprocess import sys import re import os
Funciones
def Giro_Favor_Reloj(): GPIO.output(13,True) GPIO.output(15,False) GPIO.output(16,True) GPIO.output(18,False) def Giro_Contra_Reloj(): GPIO.output(13,False) GPIO.output(15,True) GPIO.output(16,False) GPIO.output(18,True) def Giro_Favor_Reloj_Vuelta(): GPIO.output(13,False) GPIO.output(15,True) GPIO.output(16,True) GPIO.output(18,False)
82
def Giro_Contra_Reloj_Vuelta(): GPIO.output(13,True) GPIO.output(15,False) GPIO.output(16,False) GPIO.output(18,True) def Wait_For_Stop(): while True: read_serial= ser.readline() print "Waiting for zero condition:" + read_serial dist_recorrida = read_serial trama = dist_recorrida.split(",") if len(trama) == 3: vueltas1 = float(trama[0]) if vueltas1 == 0.0: break ser.write("2") def get_pids(port): command="sudo lsof -i :%s | awk '{print $2}'" % port pids=subprocess.check_output(command, shell=True) pids= pids.strip() if pids: pids=re.sub(' +',' ',pids) for pid in pids.split('\n'): try: yield int(pid) except: pass
Rutas de la aplicación web
app = Flask(__name__) @app.route('/gpio/enable/<int:direccion>/<float:distancia>/<int:vuelta>', methods=['GET']) def setPin(direccion, distancia, vuelta): print "Comienza a leer datos" time.sleep(3) while True: read_serial= ser.readline() print "Info: " + read_serial dist_recorrida = read_serial trama = dist_recorrida.split(",") if len(trama) == 3: vueltas1 = float(trama[0]) ultrasonico = float(trama[1]) print str(vueltas1) + coma + str(ultrasonico) print distancia if ultrasonico > 15: if direccion==(0): if vueltas1 < distancia: Giro_Favor_Reloj() pwm_a.start(0) pwm_b.start(0) pwm_a.ChangeDutyCycle(70)
83
pwm_b.ChangeDutyCycle(39) else: ser.write("2") print "parar" pwm_a.stop() pwm_b.stop() Wait_For_Stop() break elif direccion==(1): if vuelta==(1): if vueltas1 < distancia: Giro_Favor_Reloj_Vuelta() pwm_a.start(0) pwm_b.start(0) pwm_a.ChangeDutyCycle(100) pwm_b.ChangeDutyCycle(100) #print("Vuelta derecha") else: ser.write("2") print "parar" pwm_a.stop() pwm_b.stop() Wait_For_Stop() break elif vuelta==(2): if vueltas1 < distancia: Giro_Contra_Reloj_Vuelta() pwm_a.start(0) pwm_b.start(0) pwm_a.ChangeDutyCycle(100) pwm_b.ChangeDutyCycle(100) else: ser.write("2") print "parar" pwm_a.stop() pwm_b.stop() Wait_For_Stop() break else: print "Objeto detectado" pwm_a.stop() pwm_b.stop() ser.write("1") return "OK" @app.errorhandler(404) def not_found(error): return make_response(jsonify({'error': 'not found'}),404) @app.route('/status', methods=['GET']) def getStatus(): return "ALIVE"
Programa principal if __name__ == '__main__':
84
inicializacion_gpio() pwm_a = GPIO.PWM(12,500) pwm_b = GPIO.PWM(35,500) ser=serial.Serial('/dev/ttyACM0',9600) trama = "" coma= "," while True: try: app.run(host='0.0.0.0', port=8080, debug=True) except: port = 8080 pids=set(get_pids(port)) command='kill -9 {}'.format(' '.join([str(pid) for pid in pids])) print(command) os.system(command) time.sleep(5)
CÓDIGO ARDUINO
Declaración de variables
int contador=1; float distancia_rec=0; long distancia1; long tiempo1; String str1 = ","; int secuencia = 0;
Funciones
void setup() {
Serial.begin(9600);
attachInterrupt(digitalPinToInterrupt(2), interrupcion, RISING);
mensj_inicial();
pinMode(9, OUTPUT);
pinMode(8, INPUT);
}
void loop() {
ultrasonico();
char opcion=Serial.read();
if (opcion == '1')
{
while(distancia1 < 15)
{
ultrasonico();
}
continuarMarcha();
//Serial.flush();
}
if(opcion == '2'){
Serial.flush();
mensj_inicial();
}
85
}
void ultrasonico()
{
digitalWrite(9, HIGH);
delayMicroseconds(10);
digitalWrite(9, LOW);
tiempo1 = pulseIn(8, HIGH);
distancia1 = int(0.017 * tiempo1);
}
void mensj_inicial()
{
secuencia++;
//Serial.flush();
contador=0.00;
delay(500);
Serial.println("0.00" + str1 + "20.00" + str1 + secuencia);
}
void interrupcion()
{
contador++;
//delay(1000);
distancia_rec=contador*3.927;
Serial.println(distancia_rec + str1 + distancia1 + str1 + secuencia);
}
void continuarMarcha()
{
delay(500);
Serial.println("0.00" + str1 + "20.00" + str1 + secuencia);
}
COMANDOS PARA LA COMUNICACIÓN (RASPBERRY)
sudo nano /home/pi/bashrc //Archivo que contiene la configuración de la consola. Dentro de
él se introdujo el nombre de nuestro programa para que se ejecute al momento de abrir la
consola.
/home/pi/.config/lxsession/LXDE-pi/autostart //Se utiliza para ejecutar automáticamente un
programa (que requiera elementos gráficos) una vez que se inicia LXDE (entorno de escritorio
gráfico utilizado por Raspbian). Dentro de él se introdujo el comando “@lxterminal” para
arrancar la terminal al momento de encender la Raspberry Pi.
86
8 ANEXO b
COSTO DEL PROTOTIPO
MECANISMO
Material Cantidad Precio unitario Total
Carcasa 1 $ 1,500.00 $ 1,500.00
Bases de madera 2 $ 200.00 $ 400.00
Motores CD 4 $100.00 $ 400.00
Llantas 4 $ 78.00 $ 312.00
Coples para llanta 4 $ 45.00 $ 180.00
Mueble 1 $ 459.00 $ 459.00
Subtotal $ 3,251.00
CONTROL
Material Cantidad Precio unitario Total
Raspberry pi 3 modelo B 1 $ 1200.00 $ 1,200.00
Micro SD 8 GB 1 $ 150.00 $ 150.00
Arduino Uno 1 $ 150.00 $ 150.00
Sensor ultrasónico 1 $ 30.00 $ 30.00
Sensor óptico FC-03 1 $ 20.00 $ 20.00
Placa L298N 1 $ 130.00 $ 130.00
Switch ON/OFF 1 $ 10.00 $ 10.00
Subtotal $ 1,690.00
ALIMENTACIÓN
Material Cantidad Precio unitario Total
Batería recargable 1 $ 499.00 $ 499.00
Batería de litio 1 $ 550.00 $ 550.00
Conector para batería 1 $ 10.00 $ 10.00
Subtotal $ 1,059.00
PERSONAL
Personal Días Sueldo por día Total
Trabajo técnico 21 $ 280.00 $ 5,880.00
Desarrollo de software 60 $ 480.00 $ 28,800.00
Subtotal $ 34,680.00
87
TOTALES
Concepto Subtotal
Mecanismo $ 3,251.00
Control $ 1,690.00
Alimentación $ 1,059.00
Personal $ 34,680.00
TOTAL $ 40,680.00
