1

DOCUMENTACIÓN DE APLICACIONES ROBOTICAS EN ROS

CÓDIGO DE PROYECTO: PG-18-2-01

CRISTIAN CAMILO CÁRDENAS RODRÍGUEZ

CÓDIGO: 1511396

IDENTIFICACIÓN: C.C. 1032498464

ANDERSON STEVEN MENDEZ CHIPATECUA

CÓDIGO: 1510200

IDENTIFICACIÓN: C.C. 1012441482

UNIVERSIDAD PILOTO DE COLOMBIA

FACULTAD DE INGENIERÍA

PROGRAMA DE INGENIERÍA MECATRÓNICA

BOGOTÁ, D.C.

2019

2

DOCUMENTACIÓN DE APLICACIONES ROBOTICAS EN ROS

CRISTIAN CAMILO CÁRDENAS RODRÍGUEZ

CÓDIGO: 1511396

IDENTIFICACIÓN: C.C. 1032498464

ANDERSON STEVEN MENDEZ CHIPATECUA

CÓDIGO: 1510200

IDENTIFICACIÓN: C.C. 1012441482

PROYECTO DE GRADO PARA OPTAR POR EL TÍTULO DE INGENIERO MECATRÓNICO DE LA UNIVERSIDAD PILOTO DE COLOMBIA

DIRECTOR:

ING. RUBEN DARIO HERNANDEZ BELEÑO PhD

UNIVERSIDAD PILOTO DE COLOMBIA

FACULTAD DE INGENIERÍA

PROGRAMA DE INGENIERÍA MECATRÓNICA

BOGOTÁ, D.C.

2019

3

NOTA DE ACEPTACIÓN

Una vez realizada la revisión metodológica y técnica del documento final de proyecto de grado, doy constancia de que el (los) estudiante (s) ha cumplido a cabalidad con los objetivos propuestos, cumple a cabalidad con los Lineamientos de Opción de Grado vigentes del programa de Ingeniería Mecatrónica y con las leyes de derechos de autor de la República de Colombia, por tanto, se encuentra(n) preparado(s) para la defensa del mismo ante un jurado evaluador que considere idóneo el Comité de Investigaciones del Programa de Ingeniería Mecatrónica de la Universidad Piloto de Colombia.

Ruben Darío Hernández Beleño

Director del Proyecto

4

DEDICATORIA

A mis padres, mis abuelos, Juliana, mi hermana, jamás existirá una forma de agradecer en esta vida todo lo que han hecho por mí, todos mis esfuerzos y logros también son suyos.

Con amor y una profunda admiración.

Cristian Camilo Cárdenas Rodríguez.

A mis padres, los cuales han estado apoyándome a lo largo de la carrera y acompañado en este camino y a todas las personas que se esfuerzan día a día por mejorar este mundo mediante la

investigación.

De corazón y una profunda admiración.

Anderson Steven Méndez Chipatecua

5

AGRADECIMIENTOS

A Dios, por regalarme tan grandes bendiciones y acompañarme a cada paso que doy.

A Eduardo, mi papá, por todo el esfuerzo que hizo para que yo llegara a este momento tan importante en mi vida.

A Doris, mi mamá, por su apoyo, por sus esfuerzos, por haberme mostrado el camino de la mecatrónica.

A Juliana, mi compañera de vida, por el apoyo incondicional, motivación y todo lo que estuvo a su alcance para que yo estuviera bien.

A mis abuelos, por ser mi ejemplo de vida, por el cariño y buenas lecciones que me dieron para mi vida.

Al Ingeniero Ruben Hernández, quien siempre creyó en mí, me motivo, me guio, me brindo su conocimiento. Un ejemplo de vida.

A mis familiares y amigos, quienes fueron participes de este camino de constante aprendizaje y crecimiento, gracias por contribuir en cada momento.

Cristian Camilo Cárdenas Rodríguez

6

AGRADECIMIENTOS

A Yorly, mi mamá, por su apoyo, paciencia y por su constante motivación brindada a lo largo de la carrera en los momentos de dificulta, gracias por ser el punto de apoyo en esta etapa de mi vida, la cual hasta el momento ha sido una de las más alegres, emocionantes y gratificantes de mi vida.

A Eduardo, mi papá, por ser la persona que me apoyo, me dio confianza para estudiar ingeniera y me motivo siempre a desarrollar proyectos relacionados con la ingeniera, y por brindarme la pasión por el conocimiento y las ganas de continuar aprendiendo.

A Edward, mi hermano, por apoyarme y siempre motivarme en seguir aprendiendo cada vez mas día a día y nunca dejar de aprender.

Al Ingeniero Rubén Hernández, por ser la persona que nos guio en este proceso, por haber confiado en nosotros y siempre motivarnos a seguir aprendiendo a lo largo de nuestra vida universitaria.

Anderson Steven Méndez Chipatecua

7

TABLA DE CONTENIDO

Pág.

NOTA DE ACEPTACIÓN ....................................................................................................................3

DEDICATORIA ....................................................................................................................................4

AGRADECIMIENTOS ..........................................................................................................................5

AGRADECIMIENTOS ..........................................................................................................................6

LISTA DE FIGURAS ......................................................................................................................... 10

INTRODUCCIÓN .............................................................................................................................. 13

RESUMEN ........................................................................................................................................ 14

ABSTRACT....................................................................................................................................... 14

1. GENERALIDADES ............................................................................................................... 15

1.1.1. Antecedentes del Problema .................................................................................................... 15 1.1.2. Descripción del problema ....................................................................................................... 17 1.1.3. Línea de investigación del programa ...................................................................................... 17 1.1.4. Formulación del problema ...................................................................................................... 17

1.3.1. Objetivo General ..................................................................................................................... 18 1.3.2. Objetivos específicos .............................................................................................................. 18

1.4.1. Alcances y Limitaciones.......................................................................................................... 18

1.5.1. Marco teórico .......................................................................................................................... 19 1.5.2. Clasificación de robots ............................................................................................................ 27 1.5.3. Antecedentes .......................................................................................................................... 27

1.6.1. Metodología ............................................................................................................................ 31

2. ROS EN PROFUNDIDAD ..................................................................................................... 32

2.1.1. Paquetes en ROS ................................................................................................................... 32 2.1.2. Meta Packeges ....................................................................................................................... 32 2.1.3. Manifiestos de paquetes ......................................................................................................... 32 2.1.4. Repositorios ............................................................................................................................ 32 2.1.5. Tipos de mensajes .................................................................................................................. 33 2.1.6. Tipos de servicio ..................................................................................................................... 33

8

2.2.1. Nodos en ROS ........................................................................................................................ 33 2.2.2. Maestro ................................................................................................................................... 33 2.2.3. Servidor de parámetros .......................................................................................................... 33 2.2.4. Mensajes ................................................................................................................................. 33 2.2.5. Temas ..................................................................................................................................... 33 2.2.6. Servicios ................................................................................................................................. 34 2.2.7. Bolsas ..................................................................................................................................... 34 2.2.8. Máster ..................................................................................................................................... 34

2.3.1. Distribuciones ......................................................................................................................... 34 2.3.2. Repositorios ............................................................................................................................ 35 2.3.3. El wiki de ROS ........................................................................................................................ 35 2.3.4. Listas de correo ...................................................................................................................... 35 2.3.5. Repuestas de ROS ................................................................................................................. 35

3. IMPLEMENTACIÓN DE ROS EN UBUNTU ........................................................................ 36

3.3.1. Instalación Eclipse .................................................................................................................. 37 3.3.2. Blender .................................................................................................................................... 37 3.3.3. SDF ......................................................................................................................................... 37 3.3.4. Catkin ...................................................................................................................................... 37 3.3.5. Implementación de una caja 2x2 en Gazebo mediante ROS ................................................ 39

3.4.1. Instalación de SketchUp ......................................................................................................... 44 3.4.2. Descarga de PlayOnLinux ...................................................................................................... 44 3.4.3. Importación de SketchUp a Blender. ...................................................................................... 45 3.4.4. Exportación de Blender. ......................................................................................................... 46

4. IMPLEMENTACIÓN DE ROS EN RASPBERRY PI ............................................................ 49

5. MODELAMIENTO MATEMATICO DE ROBOTS POR MEDIO DE MATLAB .................... 59

5.1.1. Instalación de complementos en SolidWorks. ........................................................................ 59 5.1.2. Configuración del modelo en SolidWorks. .............................................................................. 60 5.1.3. Exportación del modelo a Matlab. .......................................................................................... 61

5.2.1. Brazo robótico. ........................................................................................................................ 62 5.2.2. Robot UAV (Dron). .................................................................................................................. 67 5.2.3. Robot Diferencial. ................................................................................................................... 71

6. SIMULACIÓN DE ROBOTS EN ROS .................................................................................. 75

9

7. RESULTADOS Y PRUEBAS DE FUNCIONAMIENTO ....................................................... 89

8. CONCLUSIONES ................................................................................................................. 90

9. REFERENCIAS..................................................................................................................... 91

10

LISTA DE FIGURAS

Pág.

Figura 1. PR2 Robot / Willow Garage ....................................................................................... 16

Figura 2. RB-2. ........................................................................................................................ 16

Figura 3. Summit XL. ............................................................................................................... 17

Figura 4. Simulador Gazebo. .................................................................................................... 20

Figura 5. Simulador Morse. ...................................................................................................... 20

Figura 6. Simulador Webots..................................................................................................... 21

Figura 7. Simulador V-REP. ...................................................................................................... 22

Figura 8. Blender Simulador..................................................................................................... 22

Figura 10 Icub. ........................................................................................................................ 29

Figura 11. Robots tipo colmena. .............................................................................................. 29

Figura 12. Rover. ..................................................................................................................... 30

Figura 13. Instrucciones de Catkin. ........................................................................................... 37

Figura 14. Compilación espacio de trabajo. .............................................................................. 38

Figura 15. Creación de nuevo proyecto en eclipse. .................................................................... 39

Figura 16. Selección de Carpeta. .............................................................................................. 40

Figura 17. Distribución de Archivos. ......................................................................................... 40

Figura 18. Creación de carpetas (world) y sub-carpeta(Launcher). ............................................ 41

Figura 19. Creacion de archivo lanzador (.launcher) y mundo (.world) ...................................... 41

Figura 20. Creación del mundo. (.world) ................................................................................... 42

Figura 21. Entorno Gazebo. ..................................................................................................... 42

Figura 22. Creación del mundo................................................................................................. 43

Figura 23. Modelo de una caja 2x2 en Gazebo. ......................................................................... 43

Figura 24. Página Web, PlayOnLinux........................................................................................ 44

Figura 25. Página Web SketchUp. ............................................................................................ 44

Figura 26. Programa SketchUp 2016. ....................................................................................... 45

Figura 27. Obtención del Robot en Blender. ............................................................................. 45

Figura 28. Creación del modelo para Gazebo. ........................................................................... 46

Figura 29. Carpetas creadas para el modelo. ............................................................................ 46

Figura 30. Configuración del modelo. ....................................................................................... 47

Figura 31. Configuración de Inercia del modelo. ....................................................................... 47

Figura 32. Lanzamiento de robot en Gazebo. ............................................................................ 48

Figura 33. Obtención del robot en Gazebo. ............................................................................... 48

Figura 34. Página Web, Raspberry. .......................................................................................... 49

Figura 35. Descarga de Raspian Stretch. .................................................................................. 50

Figura 36. Ejecución de programa Win32DiskImager. ............................................................... 50

Figura 37. Licencia Win32DiskImager. ...................................................................................... 51

Figura 38. GUI, Win32DiskImager. ........................................................................................... 51

Figura 39. Preparación para instalar la imagen de SD. .............................................................. 52

Figura 40. Selección de Imagen. ............................................................................................... 52

Figura 41. Instalación de imagen en la SD. ............................................................................... 53

Figura 42. Implementación de SD en Raspberry. ....................................................................... 53

11

Figura 43. Conexión de Periféricos. .......................................................................................... 54

Figura 44. Gui, Raspian. ........................................................................................................... 54

Figura 45. Descarga de actualización de sistema operativo. ..................................................... 55

Figura 46. Instalación de paquetes por actualizar en el sistema operativo. ............................... 55

Figura 47. Configuración sistema operativo. ............................................................................ 56

Figura 48. Gui, Configuración. .................................................................................................. 56

Figura 49. Configuración de idioma. ......................................................................................... 57

Figura 50. Selección de Idioma. ................................................................................................ 57

Figura 51. Configuración de Zona horaria................................................................................. 58

Figura 52. Página web, Matlab. ............................................................................................... 59

Figura 53. Configuración de Simscape Multibody Link en SolidWorks. ....................................... 60

Figura 54. Exportación de SolidWorks a Matlab. ...................................................................... 60

Figura 55. Diagrama de Bloques en Simulink. ........................................................................... 61

Figura 56. Modelo en Simulink, Matlab. ................................................................................... 61

Figura 57. Plano de Referencias. .............................................................................................. 62

Figura 58. Simulación de Brazo Robótico y su respectiva trayectoria. ........................................ 65

Figura 59.. Velocidades o Acciones de Control. ......................................................................... 66

Figura 60. Errores de Posición. ................................................................................................. 66

Figura 61. Plano de referencias Robot Omnidireccional. ........................................................... 67

Figura 62. Simulación del Robot UAV. (Dron) ........................................................................... 69

Figura 63. Grafica de las velocidades del Robot UAV. ............................................................... 70

Figura 64. Errores de Posición para cada eje............................................................................. 70

Figura 65. Plano de Referencias Robot Diferencial. ................................................................... 71

Figura 66. Simulación de Trayectoria Robot Diferencial. ........................................................... 73

Figura 67. Errores en cada termino. ......................................................................................... 74

Figura 68. Respuesta de acción de control. ............................................................................... 74

Figura 69. Línea de código del paquete. ................................................................................... 75

Figura 70. Construcción del Workspace. ................................................................................... 75

Figura 71. Ingreso al Workspace. ............................................................................................. 76

Figura 72. Compilando el Programa. ........................................................................................ 76

Figura 73. Robot en ROS. ......................................................................................................... 77

Figura 74. Comandos. .............................................................................................................. 77

Figura 75. Pestaña adicional en consola. .................................................................................. 77

Figura 76. Lanzar el programa Teleoperado. ............................................................................ 78

Figura 77. Comando del programa. .......................................................................................... 79

Figura 78. Laser Hokuyo. ......................................................................................................... 80

Figura 79. Ubicación modelo URDF. ......................................................................................... 80

Figura 80. Ubicación archivo del sensor URDF. ......................................................................... 80

Figura 81. Código Sensor URDF. ............................................................................................... 81

Figura 82. Proyección del Laser. ............................................................................................... 82

Figura 83. Proyección del laser implementado en el Robot. ...................................................... 82

Figura 84. Selección de opción LaserScan. ................................................................................ 83

Figura 85. Visualización de objetos con LaserScan. ................................................................... 83

Figura 86. Visualización de objetos en RVIZ. ............................................................................. 84

Figura 87. Creacion de archivos en la carpeta navegación. ....................................................... 85

Figura 88. Visualización de archivos dentro de la carpeta navegación creada. .......................... 85

12

Figura 89. Configuración del mapa y localización del robot. ...................................................... 85

Figura 90. Inicialización de RViz, analizando los objetos. .......................................................... 86

Figura 91. Inicialización de Gazebo, analizando los objetos....................................................... 86

Figura 92. 2D Nav Goal. ........................................................................................................... 87

Figura 93. Trayectoria curva del robot. .................................................................................... 87

Figura 94. Trayectoria semicurva del robot. ............................................................................. 88

Figura 95. Simulación de Trayectoria Robot Diferencial. .......................................................... 89

13

INTRODUCCIÓN

Debido a que el mundo de la robótica ha evolucionado considerablemente en el transcurso de los años, es necesario incluirlo en la educación, en este proyecto se quiere dar a conocer una idea general del funcionamiento del Robotic Operative Systems (ROS), para su utilización en el aprendizaje y el desarrollo de las personas que quieran adquirir interés en el tema. De esta manera, este proyecto podrá ser utilizado tanto de una forma teórico - práctico en el entorno de la robótica, dicho entorno que obtiene herramientas que permiten optimizar el tiempo de desarrollo y prueba de los robots. Esto es posible puesto que después de tener un modelo simulado o la abstracción del sistema se puede evaluar frente a diversas circunstancias en un tiempo menor al que se gastaría en la vida real. Adicionalmente es importante tener en cuenta que dicha simulación entiende los algoritmos como el modelo estructural sobre el cual se planteó el diseño del robot. Uno de los programas de simulación es Gazebo, el cual cuenta con una interfaz de usuario, obteniendo un ambiente de programación basado en C++, esto permite evaluar y modelar cada uno de los comportamientos del sistema.

14

RESUMEN

Este trabajo tiene como objetivo principal, la instalación de paquetes del framework ROS, para probar los diferentes algoritmos y modelos de robots móviles, tanto terrestres como aéreos, con el fin de disminuir el tiempo y los costos de prueba de dichos robots, de igual manera enlazar los entornos para entender la estructura y funcionamiento de los simuladores y frameworks usados.

Se realizó una guía que permite a los usuarios tener una pauta para la modificación, creación y desarrollo de diferentes algoritmos y ambientes utilizando los simuladores Gazebo, y el framework ROS con el fin de facilitar el desarrollo de proyecto futuros e ideas enfocadas hacia el desarrollo de software y hardware para robots. Los ambientes y la descripción de los robots fueron incluidas en un solo paquete con el fin de disminuir el número de fuentes necesarias para observar su funcionamiento. Se resalta que dichos scripts fueron realizados basándose en las normas y parámetros que tiene ROS para el desarrollo de software. El lenguaje usado en el desarrollo del proyecto fue XML para la descripción de los robots y el ambiente en Gazebo y ROS.

Palabras Clave: Robots, Móviles, Gazebo.

ABSTRACT

This work has as main objective, the installation of packages of the ROS framework, to test the different algorithms and models of mobile robots, both terrestrial and aerial, in order to reduce the time and test costs of these robots, in the same way link the environments to understand the structure and operation of the simulators and frameworks used.

A guide was made that allows users to have a guideline for the modification, creation and development of different algorithms and environments using Gazebo simulators, and the ROS framework in order to facilitate the development of future projects and ideas focused on the development of software and hardware for robots

The environments and the description of the robots were included in a single package in order to reduce the number of sources needed to observe their operation. It is highlighted that these scripts were made based on the norms and parameters that ROS has for software development. The language used in the development of the project was XML for the description of the robots and the environment in Gazebo and ROS.

Keywords: Robots, Gazebo, Mobile.

15

1. GENERALIDADES

PLANTEAMIENTO DEL PROBLEMA

Los elevados costos de la robótica, generan que varios proyectos que inician no terminen, ya que en el transcurso de su proceso surgen algunos inconvenientes que no se tienen en cuenta en el diseño y en la implementación, adicionalmente muchos prototipos en las fases de pruebas empiezan a presentar fallas que no se pudieron tomar en cuenta en la parte del diseño, como por ejemplo, problemas como, falta de torque en los motores de alguna articulación, por otra parte fallas geométricas en el diseño que impiden la movilidad del robot o problemas que surgen en la implementación del robot con su entorno, ya que en la etapa de diseño no se tuvo en cuenta el entorno donde el robot funcionaría.

Las simulaciones proveen características que permiten conocer el funcionamiento de un robot y como este se comporta en un ambiente especifico, lo cual ayuda al investigador a tener una idea amplia de como el robot funcionaría y las necesidades que requiere al ser implementado de forma tangible. Esta monografía se enfoca en la línea de la robótica donde se documentan aplicaciones de la robótica utilizado ROS y Gazebo para que funcionen como fuente de consulta y desarrollo en las asignaturas de sistemas dinámicos, control, robótica e inteligencia artificial.

1.1.1. Antecedentes del Problema

Las principales habilidades que se esperan de los robots es la capacidad de interactuar con el medio, problema que está prácticamente resuelto en ambientes específicos y controlados, como se puede apreciar en las líneas de producción de automóviles o similares. Si vemos más allá aparecen muchos vacíos en la robótica que impiden la implementación en gran masa de forma comercial en áreas menos controladas. Por consiguiente, el gran paso de la robótica es obtener el control de robots autónomos robustos, funcionales y que puedan responder en tiempo real a los requerimientos que se les hace.

La existencia de robots autónomos robustos en ambientes no controlados tiene muchas aplicaciones, desde asistentes y traslado de objetos en industrias y oficinas hasta robots de cuidado de salud para enfermos o ancianos, lo que significa una reducción de costos en el cuidado y una mejor calidad de vida para estas personas. En estos escenarios es fundamental poder tomar objetos de variadas formas para transporte o uso, por lo que esta habilidad es indispensable para estas aplicaciones.

A continuación, se presentan diferentes empresas que implementan el frameworks ROS en sus robots para evaluar y suplir estas necesidades:

PR2 (Willow Garage): Es un robot con una proyección para realizar diversas aplicaciones según su entorno, podemos encontrar aplicaciones en el entorno laboral en tareas como servicios hasta la fabricación de objetos, esto debido a que las personas pasan mucho tiempo haciendo tareas repetitivas. Con este robot al suplir estas labores pueden llegar a ser más productivos y tener un trabajo mejor o más agradable.

16

Figura 1. PR2 Robot / Willow Garage

Recuperado de: http://ellingson.cc/willow.

En el entorno personal realiza diferentes tareas, desde lavar los platos hasta lavar la ropa. Por último, se encuentra el entorno independiente, esto se refiere a las personas que quieran o necesiten vivir en un lugar asistido, este robot podría llevar cosas, entre otras actividades. [1]

RB-2 BASE (Robotnik): Es un robot móvil compacto con alta capacidad de carga útil para aplicaciones industriales de alto rendimiento en logística. RB-2 BASE se utiliza para el transporte interior de carga útil o carros de hasta 200 kg.

La plataforma utiliza una configuración cinemática diferencial con ruedas omnidireccionales que distribuyen la carga útil en las esquinas, lo que proporciona la máxima estabilidad en el espacio mínimo. Monta dos buscadores de alcance láser para localización, navegación y seguridad, así como dispositivos RGBD para la detección de obstáculos fuera del plano del buscador de alcance. Todos los robots de Robotnik utilizan el software ROS. Se puede aplicar en logística, almacenes y otras aplicaciones intra logísticas. Robótica para la construcción y aplicaciones en ambientes hostiles. [2] Figura 2. RB-2.

Recuperado de: https://www.robotnik.eu/mobile-robots/rb-2-base/

SUMMIT-XL STEEL(Robotnik): Es una plataforma robótica para el desarrollo de aplicaciones (logística, transporte interior, etc.). Tiene un diseño robusto y puede transportar hasta 250 kg de carga útil. La plataforma móvil tiene cinemática de dirección de deslizamiento / omnidireccional basada en 4 ruedas de motor de alta potencia. Cada rueda integra un motor sin escobillas con caja

17

de cambios y codificador. La odometría se calcula con el uso de una unidad de medición inercial de alta precisión montada dentro del chasis y la velocidad de la rueda.

La base del robot puede navegar de forma autónoma o teleoperada mediante una cámara PTZ que transmite video en tiempo real.

Se puede configurar con una amplia gama de sensores. También tiene conectividad interna (USB, RS232, GPIO y RJ45) y externa (USB, RJ45, fuentes de alimentación 5, 12 VDC y batería), para agregar componentes personalizados fácilmente. utiliza la arquitectura abierta ROS. Se encuentra en diversas aplicaciones como, logística, transporte interior, investigación y educación, vigilancia y seguimiento. [3] Figura 3. Summit XL.

Recuperado de: https://www.robotnik.es/robots-moviles/summit-xl-steel/

1.1.2. Descripción del problema

En el transcurso de los años se han evidenciado problemáticas a la hora de implementar un sistema de control para un robot en las aulas de clase, en esta guía se quiere minimizar esta problemática llevando el robot a un entorno de simulación, para evitar perdida de material, tiempo y dinero. Obteniendo así, una respuesta aproximada del movimiento del robot y una mayor facilidad a la hora de implementarlo físicamente.

1.1.3. Línea de investigación del programa

El proyecto se estructura bajo los lineamientos del área de Robótica y Biomecatrónica del programa de ingeniería mecatrónica de la Universidad Piloto de Colombia.

1.1.4. Formulación del problema

¿Existen guías, tutoriales o libros que permitan desarrollar simulaciones de robots en las aulas de clase?

18

JUSTIFICACIÓN

Actualmente, se generan costos y perdidas a la hora de la implementación de un robot, ya sea en errores de diseño o errores del entorno de implementación del robot, esto es debido a que usualmente en proyectos robóticos se omite la fase de simulación de robots; sin embargo, en la actualidad se están implementado frameworks que permiten la simulación de robots para que así el investigador analice y experimente el entorno donde va a trabajar el robot. Por esta razón, se desarrolla la documentación para el desarrollo de aplicaciones robóticas con el fin de que estas sean utilizadas y así mitigar el vacío que existe entre las fases de diseño e implementación en las aplicaciones robóticas.

OBJETIVOS

1.3.1. Objetivo General

Desarrollar e implementar una guía teórico-práctica para la implementación y validación de sistemas robóticos, usando la plataforma de ros y sus componentes como uso aplicado de la robótica.

1.3.2. Objetivos específicos

• Establecer el estado de arte en profundidad sobre las herramientas computacionales usadas para la simulación de sistemas robótico para determinar las ventajas y desventajas de los softwares existentes.

• Desarrollar e implementar tres aplicaciones robóticas para documentar su uso y aplicaciones a diferentes ramas de la mecatrónica.

• Desarrollo de guías técnicas o laboratorio para implementarlas en las asignaturas de sistemas dinámicos, control y robótica.

DELIMITACIÓN DEL PROYECTO

Este proyecto tiene como delimitación la simulación de tres robots, uno de ellos es tipo móvil catalogado como diferencial, el segundo de ellos es un robot aéreo tipo UAV civil o comúnmente llamado dron no tripulado de uso civil. Por último, vamos a encontrar el robot industrial tipo antropomórfico. Esto con el fin de tener una guía para el desarrollo de diversos tipos de robots en las diferentes aulas académicas.

1.4.1. Alcances y Limitaciones

a. Alcances

Se espera crear tres diferentes escenarios que satisfagan las variables necesarias para evaluar el correcto desempeño de tres clases de robots, acuático, aéreo y terrestre, creando un conjunto de plugin o scripts que faciliten el manejo de los escenarios y que a su vez permitan cargar la

19

representación del robot y algoritmos diseñados, teniendo en cuenta que estos tienen que ser formados en base a ROS y los formatos aceptados en Gazebo. Adicionalmente, crear una sucesión de pasos que facilite el entendimiento de ROS, así como su incorporación con Gazebo.

b. Limitaciones

Se tiene como limitación la simulación completa de las variables que afectan el sistema robótico, en el mundo real ya que Gazebo no ofrece un paquete completo de estas. Los scripts o plugin creados no tendrán una interfaz si no serán ejecutados en la terminal. Los sensores no presentarán valores idénticos al mundo real debido que en un entorno virtual no se obtiene ruido, de igual manera deberán ser valores aproximados

MARCO REFERENCIAL

1.5.1. Marco teórico

En esta guía se tuvo en cuenta diversidad de simuladores, definiciones, además de la clasificación de robots, el cual tuvo como fin determinar la herramienta con mayor capacidad para la simulación de los robots y entendimiento de estas.

1.5.1.1. Simuladores.

La simulación es una forma que permite representar el comportamiento de un sistema real o imaginario frente a especificaciones. Esta ayuda a comprender la realidad y toda la complejidad de un sistema, ya que se determina por medio de una descripción matemática del mismo para posteriormente aplicar condiciones con el fin de observar el comportamiento de este.

Analizando la finalidad de la simulación, se determina el comportamiento del sistema frente a determinados acontecimientos en un tiempo establecido. A continuación, se verán algunos de los simuladores con mayor reconocimiento y características para la simulación de robots.

a. Gazebo.

Es una herramienta de simulación para múltiples robots (terrestres, acuáticos y aéreos), se puede encontrar el desarrollo de ambientes al aire libre, desarrollado por Open-Source Robotics Foundation. Esto hace posible realizar pruebas de regresión y entrenar el sistema de inteligencia artificial utilizando escenarios realistas. De esta manera Gazebo ofrece la capacidad de simular de manera precisa y eficiente las poblaciones de robots en entornos complejos interiores y exteriores. A demás encontramos un lenguaje de programación amigable con el usuario ya que usa directamente las clases de C++.

20

Figura 4. Simulador Gazebo.

Recuperado de: https://dev.px4.io/v1.9.0/en/simulation/gazebo.html.

La licencia de este simulador es de fuente abierta y permite su integración con diversos frameworks como lo son ROS, YARP, entre otros, esto beneficia debido a una simulación con comportamientos más complejos en cada uno de los sistemas que usan estos tipos de integración.

Contiene diversos plugins que nos brindan la oportunidad de añadir sensores al modelo del robot y simularlos, como pueden ser sensores de odometría (Sistema de posicionamiento global (GPS) y Unidad de Medición Inercial (IMU)), de fuerza, de contacto, láseres y cámaras.

Gazebo permite directamente, crear mundos y objetos idóneos para colocar el modelo robótico que se esté desarrollando, con el fin de visibilizar la manera en la que el mismo interactúa en un ambiente determinado, De esta forma verificar el funcionamiento de sensores, aptitudes de movilidad e incluso de superación de obstáculos. También resulta posible observar cómo la gravedad afecta la estructura, caídas desde alturas determinadas, fricción, entre otras. [4]

b. Morse.

Es un simulador genérico para la robótica. Igual que Gazebo se centra en la simulación realista en 3D de entornos pequeños a grandes, interiores o exteriores.

Figura 5. Simulador Morse.

Recuperado de: https://www.eu-robotics.net/robotics_forum/press/going-hands-on-with-the-morse-simulator.html?changelang=3

21

Morse se controla por medio del lenguaje de Python, desde la línea de comandos, las escenas de simulación se generan a partir de simples scripts que describen los robots y el entorno.

Cuenta con un conjunto de sensores, actuadores y bases robóticas, además la representación se basa en el motor de juego de Blender el motor de juego basado en OpenGL ofrece opciones de iluminación, admite múltiples texturas y utiliza biblioteca Bullet de última generación para la simulación física de los robots. También admite dos formas de manejo del tiempo: el mejor esfuerzo, que trata de mantener un ritmo en tiempo real, al costo de eliminar cuadros si es necesario, o un paso fijo que asegure que la simulación sea precisa. Este simulador exporta su propio reloj que puede usarse para ajustar otros módulos dependientes del tiempo en su sistema.

En cuanto a la arquitectura Morse soporta actualmente 6 middlewares de código abierto entre ellos ROS y YARP. Por otra parte, Morse beneficial las capacidades de importación/exportación de Blender, los modelos existentes en muchos formatos 3D como VRML, COLLADA, DFX, entre otros pueden usarse para construir robots y entornos. [5]

c. Webots

Es un simulador de código abierto que proporciona un entorno de desarrollo completo para modelar, programar y simular robots. Muchas personas en el mundo utilizan esta herramienta como método educativo.

Figura 6. Simulador Webots

Recuperado de: http://doc.aldebaran.com/2-5/software/webots/webots_index.html

Este simulador tiene la opción de escoger la forma, el color, el tamaño, la fricción de los objetos que conforman el robot. Se puede trabajar en Windows, Linux y Mac, como es un software propietario necesita licencia al igual que Matlab, por lo tanto, en cuanto a costos esto representa una desventaja. [6]

22

d. V-REP

Es un simulador de la empresa Coppelia Robotics la cual permite diferentes modos de simulación y ciertas herramientas en robótica como por ejemplo el cálculo de la cinemática inversa, una de las grandes características de este software es que es gratuito a diferencia de otros simuladores que tienen un costo y están diseñados por la propia empresa del robot. Adicionalmente este software permite crear un robot con ciertas piezas que él tiene por defecto o exportar nuestro modelo 3D.

Figura 7. Simulador V-REP.

Recuperado de: http://hades.mech.northwestern.edu/index.php/V-REP_Introduction

Este programa posee ciertas limitaciones a comparación de otros en la programación, ya que es una programación de alto nivel y hay ciertos aspectos los cuales no se pueden modificar, como es el caso del cálculo del jacobiano a pesar de tener la opción de realizar este cálculo hay ciertos parámetros que no se pueden modificar. [7]

e. Blender

Es un programa el cual posee diferentes aspectos sin embargo su principal característica es el modelado 3D, ya que posee herramientas como agregar mallas, superficies, curvas, brillo y texto, sin embargo, tiene aspectos para la edición de video, animaciones, un motor de juegos para desarrollarlos, simulaciones físicas y programación en Python. [8]

Figura 8. Blender Simulador.

Recuperado de: https://machinekoder.com/animating-industrial-robots-with-blender/

23

En las simulaciones tiene diferentes aspectos como simular cuerpos blandos y simular colisiones entre objetos adicionándole la elasticidad que se provoca entre los cuerpos, aspectos como la gravedad, fricción del objeto y su velocidad [9]

1.5.1.2. Modelo del sistema

Un modelo es una representación ideal de un sistema real, esto se realiza con el fin de describir el sistema, plantear suposiciones sobre el comportamiento que puede adaptar. La representación ideal es un modelo matemático que permite comprender de una manera lógica el comportamiento del sistema, por ende, es importante analizar de una manera estricta los valores obtenidos del modelo ya que de ellos se parte para controlar y reestructurar al sistema. [10]

1.5.1.3. Medio Ambiente.

Es considerado como la suma de las relaciones culturales y sociales, en un entorno, en momento histórico y un lugar en particular.

Viéndolo desde un punto de vista general, el medio ambiente es un compendio de factores que actúan directamente sobre un sistema y ocasionan el comportamiento y evolución de este.

1.5.1.4. Entorno virtual.

A partir de la definición de simulación y medio ambiente podríamos decir que un entorno virtual es la representación por computadora de un lugar real o imaginario que afecta el desenvolvimiento y evolución de un sistema en específico. Dicho modelo representa las variables a los cuales va a ser expuestos el sistema y sobre los cuales se evaluar su esquema mecánico como el software que establece su comportamiento. De esta forma antes de determinar un entorno virtual es necesario analizar y establecer los parámetros y circunstancias a los cuales va a ser expuesto el sistema en el mundo real. Así estos ambientes permiten minimizar el tiempo de prueba asi como los costos de estas.

1.5.1.5. Frameworks.

Es un conjunto estandarizado de conceptos, prácticas y criterios para enfocar un tipo de problemática que sirve como referencia, para enfrentar y desarrollar nuevos problemas similares, vale resaltar que un framework puede contener diversos lenguajes, así como librerías y herramientas que permiten el desarrollo de nuevos programas, Este tipo de herramientas facilitan la relación entre diferentes entidades y dominios con el fin de facilitar la integración de diferentes sistemas informáticos y de hardware. Gracias a las diversas características que contiene este tipo de herramientas, se puede implementar un mismo programa en diferentes procesos o con otros fines.

Un framework generalmente este compuesto por un grupo de librerías, herramientas, APIs y compiladores con el fin de minimizar el esfuerzo necesario para el desarrollo de programas más complejos. Este tipo de herramientas han sido desarrolladas para la creación de software de robots, esto con el fin de minimizar el esfuerzo y estandarizar las normas necesarias para cumplir un conjunto de tareas especializadas. Este tipo de herramientas han permitido el desarrollo de sistemas complejos como el PR2 y Atlas, dos robots que cuentas con programas independientes que se

24

integran entre sí para permitir el desarrollo de una variedad de tareas como la manipulación, identificación y manejo de elementos determinados. [11]

Frameworks usados en la robótica:

a. Robot Operating System (ROS)

Ros es un sistema de código abierto meta-operativo para su robot. Donde se proporcionan los servicios que se esperaría de un sistema operativo, incluyendo la abstracción de hardware, el control de dispositivos de bajo nivel, la implementación de la funcionalidad de uso común, el recorrido de mensajes entre procesos y la administración de paquete. De igual manera proporciona herramientas y bibliotecas para obtener, crear, escribir y ejecutar código en diferentes computadores. Ros es similar en algunos aspectos a frameworks de robots como Player, Yarp, Orocos, Carmen, Orca, Moos y Microsoft Robotics Studio.

El grafico de tiempo de ejecución de ROS es una red de procesos potencialmente distribuidos entre maquinas que se articula de manera flexible mediante la infraestructura de comunicación de ROS. ROS implementa varios estilos de comunicación, incluyendo la comunicación a través de servicios sincrónica de RPC, la transmisión asincrónica de datos sobre temas y el almacenamiento de datos en un servidor de parámetros.

ROS no es un marco en tiempo real, aunque se puede integrar ROS con código en tiempo real. El robot Willow Garage PR2 utiliza un sistema llamado pr2_etherCAT, que transporta mensajes de ROS dentro y fuera de un proceso en tiempo real. ROS tiene una integración perfecta con Orocos Real-time Toolkit.

ROS actualmente solo se ejecuta en plataformas basadas en Unix. El software para ROS se prueba principalmente en sistemas Ubuntu y Mac OS X, aunque la comunidad ROS ha estado contribuyendo con el soporte para Fedora, Gentoo, Arch Linux y otras plataformas Linux. Si bien es posible un puerto a Microsoft Windows para ROS, aún no se ha explorado completamente. [12]

b. Player

Player es un software libre que permite la investigación en sistemas de robots y sensores. Es la interfaz de robots probablemente más utilizada en el mundo.

Lanzado bajo la licencia pública general de GNU, todo Player es desarrollado por un equipo internacional de investigadores en robótica y se utiliza en laboratorios de todo el mundo.

Player proporciona una interfaz de red para una variedad de hardware de sensores y robots. El modelo cliente - servidor permite que los programas del robot se escriban en cualquier lenguaje de programación y se ejecuten en cualquier computadora con una conexión de red al robot, además admite múltiples conexiones de clientes simultaneas a dispositivos, creando nuevas posibilidades para la detección y el control distribuidos y colaborativos. El software Player se ejecuta en Linux, Solaris, *BSD y Mac OSX. [13]

25

c. Yet Another Robot Platform (YARP)

YARP admite la creación de un sistema de control de robot como una colección de programas que se comunican de manera par a par, con una familia extensible de tipos de conexión como (tcp, udp, multicast, local, MPI, mjpg-over-http, XML/RPC, tcpros, …) que pueden intercambiarse para ajustarse a sus necesidades. También apoyan la interconexión similar flexible con dispositivos de hardware. El objetivo estratégico es aumentar la longevidad de los proyectos de software de robots.

YARP está escrito en C++. La biblioteca ACE se utiliza para las compilaciones de Windows y para admitir protocolos adicionales. En Linux y macOS, se puede omitir ACE opcionalmente, dando una huella muy ligera. YARP es gratis y abierto, bajo la licencia BSD-3-Clause.

YARP proporciona características que permiten a los desarrolladores asignar prioridades a conexiones individuales. [14]

d. Orocos

Es una herramienta para crear aplicaciones de robótica en tiempo real utilizando componentes de software configurables modulares en tiempo de ejecución.

Orocos nos proporciona un soporte multiplataforma como Linux, Windows (Visual Studio) y Mac OS-X, además nos proporciona extensiones con otros frameworks como ROS, Rock, YARP. Orocos es un generador de código para transferir datos definidos por el usuario entre componentes distribuidos, componentes configurables, en tiempo de ejecución y en tiempo real. También se obtiene un registro y reporte de eventos del sistema y datos comunicados.

Orocos consiste en: - Autoproj, es una herramienta para descargar y compilar las bibliotecas necesarias. - Real – Time Toolkit, un marco de componentes que nos permite escribir componentes en

tiempo real en c++ - Biblioteca de componentes, se obtienen los componentes necesarios para iniciar una

aplicación e interactuar con ella en tiempo de ejecución. - OroGen y TypeGen, son herramientas para generar código listo para compilar y ejecutar a

partir de encabezados existentes o archivos de descripción de componentes.

Los componentes de Orocos están construidos por los mismos usuarios que se encuentran alojados en sus propios repositorios. [15]

e. Carmen

Es una colección de software de código abierto para el control de robots móviles. Carmen es un software modular diseñado para proporcionar elementos básicos de navegación que incluyen, control de base y sensor, registro, evitación de obstáculos, localización, planificación de ruta y mapeo.

Carmen es un software de control de robots modulares, utiliza una comunicación entre procesos IPC, realiza un monitoreo de procesos, obtiene un soporte de hardware de robot para diferentes plataformas, obtiene módulos de planificación de rutas, módulos de localización, funcionalidad de

26

reproducción y registro de mensajes, Carmen utiliza un lenguaje de programación en C y proporciona un soporte para java, corre bajo Linux y está disponible bajo GPL. [16]

f. Orca

Orca es un marco de código abierto para desarrollar sistemas robóticos basados en componentes. Proporciona los medios para definir y desarrollar los componentes básicos que se pueden enlazar para formar sistemas robóticos arbitrariamente complejos, desde vehículos individuales hasta redes de sensores distribuidos.

El objetivo principal de este framework es el progreso continuo en la investigación y la industria robóticas. El principal desafío que vemos en la actualidad es el software específico de los robots, por su complejidad y diversidad en la industria, se basan reutilización del software promete una solución a estos dos problemas. [17]

g. Moos

Moos es un software multiplataforma con lenguaje de programación c++ para la investigación robótica. Cuenta con una capa de comunicaciones llamada Core Moos basada en una red llamada MOOSDB que permite crear aplicaciones que se comunican entre sí. A demás existe Essential MOOS que conforma una capa de aplicaciones que cubren tareas comunes, como el control de procesos y el registro.

Este software permite conectar una sesión en matlab a un conjunto de procesos habilitados para MOOS, además permite depurar visualmente un conjunto de procesos de comunicación. Encontramos aplicaciones para controlar el GPS NMEA, la orientación y los sensores de profundidad.

De igual forma permite el control estatal de vehículos (pHelm), un sostificado marco de estimación de pose para vehículos submarinos y de superficie (pNav). [18]

h. Microsoft Robotics Studio

Es un entorno de programación basado en .NET disponible gratuitamente para crear aplicaciones de robótica. Puede ser utilizado tanto por desarrolladores profesionales o no profesionales, asi como por aficionados.

Admite un amplio conjunto de plataformas robóticas ejecutando directamente en la plataforma PC integrada que ejecute Windows o controlando el robot desde una PC con Windows a través de un canal de comunicación como WI-FI o Bluetooth.

Además, proporciona un VPL (Visual Programming Language) que permite los desarrolladores crear aplicaciones simplemente arrastrando y soltando componentes en un lienzo y conectándolos entre sí.

Gracias al potente entorno de visualización (VSE) proporciona un entorno de alta fidelidad impulsada por el motor NVIDIA para ejecutar simulaciones 3D con calidad de juego con interacciones del mundo real. [19]

27

1.5.2. Clasificación de robots

a. Robot Móvil

Los robots móviles son plataformas mecánicas en un sistema de locomoción capaz de recorrer a través de un determinado ambiente de trabajo, portando cargas con cierto nivel de autonomía. Sus aplicaciones se diversifican y por lo general se relacionan con tareas que el ser humano le es riesgosa o nociva, se pueden aplicar en áreas como en el transporte de cargas peligrosas, agricultura, exploración junto a otros vehículos.

También se puede definir un robot móvil como un vehículo de propulsión autónoma y movimiento programado por medio de control automático para realizar una tarea en específico.

Se clasifican en guiados y no guiados. El vehículo guiado está restringido a un conjunto de trayectorias predefinidas en su área de trabajo. Mientras el no guiado no está restringido a una trayectoria predefinida. [20]

b. Robots Terrestres

Son aquellos que están en funcion del medio, existen diferentes tipos de robots terrestres como robots con ruedas, aquellos que se utilizan en superficies lisas, otro de ellos son tipo oruga, son aquellos que se utilizan para superficies irregulares y por último se encuentran los robots con patas, que son utilizados para superficies muy irregulares o complejas. [21]

c. Robots Aéreos

Son vehículos aéreos no tripulados controlados por radio control o por un programa previamente instalado, mientras que los robots y los helicópteros tripulados tienen serios convenientes, principalmente a las limitaciones de los pilotos y a la restricción de no poner en peligro la vida de ellos. Los UAV (Unmanned Aerial Vehicle) pueden ser enviados a todo tipo de operaciones.

Su principal desarrollo fue impulsado para aplicaciones militares, donde los UAV destacan en campos como el reconocimiento aéreo, vigilancia aérea, adquisición de objetivos, evaluación de daños, búsqueda y rescate en zonas de combate, etc. Sin embargo, se han ideado aplicaciones como el reconocimiento del campo aéreo e incluso en la exploración espacial. [22]

1.5.3. Antecedentes

En la actualidad, la robótica es utilizada en diferentes áreas como la medicina, construcción, manufactura, agricultura y exploración espacial siendo así los robots una de las prioridades en estos campos, sin embargo la construcción e implementación de estos robots presenta dificultades ya que en varios casos no cumplen adecuadamente su función debido a fallas en el diseño, por esta razón se es necesario realizar simulaciones de los robots antes de ser construidos para disminuir el margen de error a la hora de su funcionamiento.

Las simulaciones han brindado grandes ventajas en la robótica como, por ejemplo, en la competición realizada por DARPA, donde el objetivo es la realización de diferentes tareas por parte de robots

28

humanoides, estos robots fueron simulados e implementados con ROS ya que se podía simular el entorno en el cuales estos robots iban a estar y así cumplir de una mejor forma su actividad. [23]

Recuperado de: https://ieeexplore.ieee.org/abstract/document/7140073/figures#figures

Algunos simuladores implementados en la robótica son diseñados por las propias empresas que lo requieren como es en el caso del robot humanoide icub, este simulador está diseñado con el fin de dar ejemplos de escenarios reales, que se puedan simular para que luego de realizar la programación pueda ser implementado más fácilmente, a diferentes de otros programas este es de código abierto para que la comunidad pueda aportar a mejorar dicho simulador y puedan utilizarlo gratuitamente.

Figura 9. Implementación robot humanoide Darpa.

29

Figura 10 Icub.

Recuperado de: http://www.commonsenserobotics.org/platforms/

Los simuladores en robótica requieren de ciertos requisitos dependiendo la aplicación, como es en el caso de simular grandes cantidades de robots en un mismo escenario al mismo tiempo, simuladores como ROS y Webots tienen esta limitación; sin embargo, ARGoS tiene la capacidad de simular varios robots al mismo tiempo como, por ejemplo, en aplicaciones de robots tipo colmena donde su funcionalidad depende de varios robots ya que estos trabajan al mismo tiempo para cumplir una tarea.

Figura 11. Robots tipo colmena.

Recuperado de: https://images.app.goo.gl/PbksCVJzyTo8Cd198

En el área de la medicina las simulaciones también están presentes ya que estas tecnologías permiten interactuar a los estudiantes con un entorno muy similar a la realidad, permitiendo así que puedan practicar, cometer errores, y lograr un mejor aprendizaje con el fin de no cometer errores cuando se esté realizando una operación con un paciente, como es en el caso de la práctica de los procedimientos endoscópicos e intervenciones quirúrgicas. Las simulaciones en esta área han ido aumentado debido a un reporte dado por el Instituto Nacional de Medicina de los Estados Unidos

30

de América en el cual exponían que sucederían aproximadamente 98.000 muertes cada año debido a una equivocación medica por esta razón se han intensificado las practicas con simuladores ya que estos dan confianza a los estudiantes.

En el ámbito aeroespacial las simulaciones también están presentes ya que el espacio es un sistema poco explorado y por ende las simulaciones son un primer paso para conocer con antelación dichos terrenos, como es el caso de los viajes planeados a Marte, una de las necesidades principales es conocer donde se establecerá la primera colonia que viaje a marte por esta razón la Nasa usa un simulador el cual posea un entorno donde pueda visualizar las superficies del planeta, algunos elementos como el Rover, invernaderos inflames y equipos a utilizar de los astronautas.

Recuperado de: Bruce Irving [7]

Algunos de los simuladores desarrollados han sido diseñados por la Nasa entre estos están: [8]

• General Mission Analysis Tool (GMAT)

• Eyes on the Solar System

• RocketModeler

• Rocket Thrust

• Atmos Modeler

Entre los diferentes simuladores utilizados en robótica hay uno el cual es bastante importante y es el Microsoft Robotics Developer Studio (MSRDS) esto es debido a que está en desarrollo y los usuarios pueden diseñar sus propios algoritmos y utilizar otros que ya han sido implementados por medio de repositorios, esto fue diseñado para que la comunidad en el área de la robótica avanzará ya que este área no estaba muy desarrollada debido a que los programas de simulación eran diseñados por las empresas privadas y el conocimiento que realizaban en estas plataformas no se compartían, hasta el lanzamiento del simulador de Microsoft el cual permite al usuario interactuar y controlar los robots con diferentes lenguajes de programación, y adicionalmente este permite la transferencia de códigos mediante aplicaciones externas. [9]

Figura 12. Rover.

31

MARCO METODOLÓGICO

1.6.1. Metodología

Para alcanzar los objetivos propuestos se plantea una metodología preliminar la cual consta de 6 fases de trabajo que son:

FASE 2

IMPLEMENTACIÓN DE ROS EN S.O

UBUNTU

FASE 1

ESTUDIO DE ROBOTS

SIMULADOS CON ROS

FASE 3

IMPLEMENTACIÓN DE ROS EN

RASPBERRY PI

FASE 4

SIMULACION DE ROBOTS EN ROS

FASE 5

SIMULACION DE ROBOTS EN

MATLAB

FASE 6

ANALISIS DE RESULTADOS.

32

2. ROS EN PROFUNDIDAD

En este capítulo, encontramos que ROS cuenta con tres niveles de conceptos: el nivel de sistema de archivos, nivel grafico de cálculo ROS y el nivel de comunidad.

Los cuales sirven para determinar los recursos necesarios para la simulación, como debe estar conformado el robot y los mensajes que se definen para el lanzamiento del robot, de esta manera llegar al movimiento del robot y el comportamiento con las características dinámicas y estáticas del entorno

NIVEL DE SISTEMA DE ARCHIVOS ROS

Los conceptos a nivel del sistema de archivos cubren principalmente los recursos ROS que se pueden encontrar en el disco. [24]

2.1.1. Paquetes en ROS

Los paquetes son la unidad principal para organizar software en ROS, un paquete puede contener procesos de tiempo de ejecución de ROS, una biblioteca dependiente de ROS, archivos de configuración, conjunto de datos u otro tipo de cosas que sea útil organizar juntos; Los elementos de lanzamiento de ROS son llamados paquetes, el elemento de creación más atómico, lo más detallado que puedes construir y lanzar o ejecutar es un paquete. [24]

2.1.2. Meta Packeges

Son paquetes especializados que sirven para representar un grupo de paquetes relacionados, comúnmente, los meta paquetes se utilizan como un marcador de posición compatible con versiones anteriores para las pilas de rosbuild convertidas. [24]

2.1.3. Manifiestos de paquetes

Los manifiestos son paquetes tipo (package.xml) nos proporcionan metadatos sobre un paquete, incluidos su nombre, versión, descripción, información de licencia, dependencias y otra información como paquetes exportados.

package.xml especifico un nuevo formato de manifestó de paquete, solo es relevante para los paquetes que utilizan el nuevo sistema de compilación Catkin. [24]

2.1.4. Repositorios

Son una colección de paquetes que comparten un sistema VCS común, los paquetes que comparten un VCS comparten la misma versión y se pueden lanzar juntos usando la herramienta de automatización de lanzamiento de Catkin; Estos repositorios comúnmente son asignados a las pilas de rosbuild convertidas, además puede que solo contengan un solo paquete. [24]

33

2.1.5. Tipos de mensajes

Los mensajes definen las estructuras de datos de solicitud y respuesta para los servicios en ROS, estos son almacenados en my_package / msg / MyMessageType.msg [24]

2.1.6. Tipos de servicio

Las descripciones del servicio definen las estructuras de datos de solicitud y respuesta para los servicios en ROS, estos son almacenados en my_package / srv / MyServiceType.srv [24]

NIVEL DE GRAFICO DE CÁLCULO ROS

Es la red de igual a igual de los procesos de ROS que procesan datos juntos, los conceptos básicos de gráficos de computación de ROS son nodos, maestro, servidor de parámetros, mensajes, temas, servicios, bolsas, máster; Estos conceptos se implementan en el repositorio ros_comm. [24]

2.2.1. Nodos en ROS

Son procesos que realizan computación, Ros está diseñado para ser modular en una escala muy detallada; Un sistema de control de robot usualmente obtiene gran cantidad de nodos, por ejemplo, un nodo controla un buscador laser de rangos, un nodo controla los motores de las ruedas, un nodo realiza la localización, un nodo realiza la planificación de la ruta, un nodo proporciona una vista grafica del sistema, se describe con el uso de una biblioteca de cliente ROS, como roscpp o rospy. [24]

2.2.2. Maestro

Proporciona el registro de nombres y la búsqueda del resto del nivel de gráfico; Sin el maestro, los nodos no podrían encontrarse, intercambiar mensajes o llamar servicios. [24]

2.2.3. Servidor de parámetros

Nos permite almacenar los datos por clave en una ubicación central, forma parte del Máster. [24]

2.2.4. Mensajes

Los nodos se comunican por medio de los mensajes, es una estructura de datos, que corresponde a espacios o campos escritos, se admiten los tipos primitivos estándar (Int, Float, Boolean, Chart, etc), de igual forma para las matrices de tipos primitivos, los mensajes pueden incluir estructuras y matrices arbitrariamente anidadas. [24]

2.2.5. Temas

Los mensajes se enrutan a través de un sistema de transporte con semántica de publicación o suscripción; Un nodo envía un mensaje publicándolo en un tema determinado.

34

Tema es el nombre que se proporciona para identificar el contenido del mensaje, puede haber múltiples editores y suscriptores para un solo tema, y un solo nodo puede publicar y/o suscribirse a diversos temas.

Como idea principal se quiere desacoplar la producción de información de consumo, lógicamente, cada bus tiene un nombre y cualquiera puede conectarse al bus para enviar o recibir mensajes siempre que sean del tipo correcto. [24]

2.2.6. Servicios

El modelo de publicación o suscripción es un paradigma de comunicación muy flexible, la solicitud o la respuesta se realiza por medio de servicios, que se definen mediante un par de estructuras de mensajes, una para solicitud y otra para respuesta.

Un nodo proveedor ofrece un servicio con un nombre y un cliente usa el servicio enviando el mensaje de solicitud y esperando la respuesta; las bibliotecas cliente de ROS generalmente presentan esta interacción al programador como si fuera una llamada a un procedimiento remoto. [24]

2.2.7. Bolsas

Las bolsas son un formato para guardar datos de mensajes ROS, las bolsas son un mecanismo importante para almacenar datos, como los datos de sensores, que pueden ser difíciles de recopilar, pero son necesarios para desarrollar y probar algoritmos. [24]

2.2.8. Máster

Actúa como un servicio de nombres en el nivel grafico de ROS, este almacena temas y servicios de información de registro para nodos ROS, se comunican con el maestro para brindar la información de registro, de igual manera se puede recibir información sobre otros nodos registrados y realizar conexiones según corresponda.

El maestro retorna el llamado cuando estos nodos cambien la información de registro.

El máster solo proporciona información de búsqueda, como un servidos DNS; Establecen una conexión a través de un protocolo de conexión acordado, el protocolo más común usado en un ROS se llama TCPROS, que usa sockets TCP/ IP estándar. [24]

NIVEL DE LA COMUNIDAD ROS

Los conceptos de nivel de la comunidad de ROS son recursos que permiten a comunidades separadas intercambiar software y conocimiento. [24]

2.3.1. Distribuciones

Son conexiones de pilas versionadas que puede instalar las distribuciones que desempeñan un papel similar a las distribuciones de Linux, facilitan la instalación de una colección de software y también mantienen versiones coherentes en un conjunto de software. [24]

35

2.3.2. Repositorios

Se basan en una red federada de repositorios de código, donde diferentes instituciones pueden desarrollar y lanzar sus propios componentes de software de robots. [24]

2.3.3. El wiki de ROS

Es un foro principal para documentar información sobre ROS, cualquier persona puede obtener una cuenta y contribuir con su propia documentación, proporcionar correcciones o actualizaciones. [24]

2.3.4. Listas de correo

La lista de correo de ros-users es un canal de comunicación principal sobre las nuevas actualizaciones de ROS, así como un foro para hacer preguntas sobre el software de ROS. [24]

2.3.5. Repuestas de ROS

Es un sitio de preguntas y respuestas para responder sus preguntas relacionadas con ROS. [24]

36

3. IMPLEMENTACIÓN DE ROS EN UBUNTU

En este capítulo se puede evidenciar la guía de instalación e implementación de un robot en ROS enlazado con Gazebo y algunos entornos de desarrollo como Blender y eclipse.

A la hora de iniciar el proceso de instalación de ROS, se deben tener algunos aspectos en cuenta:

Uno de ellos es que la plataforma Gazebo solo funciona de forma adecuada en sistemas operativos Linux, además se debe saber que se puede instalar Gazebo en su última versión o instalar los paquetes de ROS que contienen Gazebo 7. Al instalar la última versión de Gazebo, pueden ocurrir errores debido a que al instalar los paquetes de ROS se sobrescriben los paquetes de Gazebo ya instalados y quedan rutas rotas. Se recomienda instalar solo los paquetes de ROS con el gazebo ya predeterminado (Gazebo 7) o instalar los paquetes de ROS y luego la última versión de Gazebo. Antes de instalar los paquetes de ROS se debe tener en cuenta la versión de Ubuntu. Para el caso de este proyecto se desarrolló en Ubuntu Xenial, por ende, se instalará ROS KINETIC KAME que es la versión más estable compatible con el software que se está utilizando.

INSTALACIÓN DE GAZEBO.

En Ubuntu se debe abrir la terminal y colocar la siguiente línea de código “ curl -sSL http://get.gazebosim.org | sh ” donde se carga la dirección, este trae un script y se lanza.

A continuación, se coloca la contraseña de usuario si es requerida y se da enter, una vez realizado el proceso se comienza la descarga. Cuando termine la instalación se puede escribir en la terminal Gazebo y se observa que arranca el simulador donde es posible configurar el robot que se desea utilizar, el mundo o ambiente en el cual se desea trabajar, entre otras cosas.

INSTALAR PAQUETES DE ROS

En Ubuntu se abre la terminal y se coloca esta línea de código “sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $ (lsb_release -sc) main"> /etc/apt/sources.list.d/ros-latest.list' ”. Debido a que este software no es propio de Ubuntu, se debe agregar este repositorio para que acepte cualquier paquete de ROS.

A continuación, se coloca la contraseña de usuario si es requerida, se da enter, ya se tiene añadido el repositorio, ahora se debe firmar para que sea válida la descarga con este comando: “sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116”

Luego se actualiza la librería de paquetes con el siguiente comando “sudo apt-get update” se da enter, en este momento se puede instalar completamente ROS con el siguiente comando: “sudo apt-get install ros-kinetic-desktop-full”.

Ya instalados los paquetes de ROS, se inicializan las dependencias para ROS con el siguiente comando: “sudo rosdep init”, una vez inicializado se actualizan las dependencias con el siguiente

37

comando, “rosdep update”, con esto ya se tienen algunos ejemplos de este sistema, complementos entre otros.

Ahora se instala el catkin que debe ser la misma versión que la de ROS con el siguiente comando: “sudo apt-get install ros-kinetic-catkin”.

Con esto ya se pueden correr los códigos para el robot, para comodidad instalar un sistema de desarrollo de código.

CONFIGURACIÓN DE ENTORNO

3.3.1. Instalación Eclipse

Para el desarrollo y codificación de los robots, se instala eclipse para mayor comodidad de programación con el siguiente comando “sudo apt-get install eclipse”. Se recomienda instalar la última versión.

3.3.2. Blender

Se puede usar esta herramienta como sistema de modelado en 3D, además pasar diseños ya sean en SolidWorks o Inventor a un lenguaje SDF.

3.3.3. SDF

Es un lenguaje que utiliza Gazebo para la construcción del robot en términos físicos donde se usa lenguaje XML, esto permite construir robots mucho más potentes.

3.3.4. Catkin

Antes de empezar a desarrollar el robot se debe preparar el entorno, para ello se abre la terminal y se inicia catkin. Si ejecuta catkin se evidenciará que no existe un comando de inicialización, primero se configura ROS para que la terminal conozca las opciones de ROS, se ejecuta:

source /opt/ros/kinetic/setup.bash

Para cada terminal ejecutar el comando, ahora ya se tiene configurado ROS, se coloca cat enseguida de la tecla tab y se evidencian las instrucciones.

Fuentes: Autores.

Figura 13. Instrucciones de Catkin.

38

Ahora se decide donde tener el proyecto, para esta guía se colocará en la carpeta raíz en la de usuario, ahora se construye la carpeta con el siguiente comando.

mkdir -/robot

Donde “ -/ “ sirve para ir a la carpeta raíz o poner cosas allí. Con el comando cd se dirige a la carpeta: cd robot.

Ahora dentro de la carpeta robot se crea una nueva carpeta llamada src, se ingresa a la carpeta src, donde se generan los códigos para el robot.

Se introduce en la terminal:

catkin_init_workspace

Este realiza un enlace simbólico dentro de la carpeta sobre el sistema de compilación de catkin. Ahora se compila el espacio de trabajo desde la carpeta robot y se ejecuta el siguiente código:

catkin_make

Fuentes: Autores. Ya compilado el espacio de trabajo, ahora se obtuvo una carpeta build una devel y la src, con el comando “ ls ” se observa esto. Para compilar el robot con Gazebo es necesario que en cada terminal se introduzca el siguiente comando:

source ~/robot/devel/setup.bash En este caso robot es el nombre de la carpeta. Ahora se define la morfología del robot, en este caso se realiza una caja de ejemplo con el cual se pueden desarrollar diferentes aplicaciones.

Figura 14. Compilación espacio de trabajo.

39

3.3.5. Implementación de una caja 2x2 en Gazebo mediante ROS

Se inicia por estar en la carpeta que se ha definido para el proyecto y se crean los paquetes de desarrollo, en la carpeta de src usamos:

catkin_create_pkg -D “Mi primer Robot” -a Cristian --rosdistro KINETIC miRobot Donde:

- catkin_create_pkg Crea los paquetes vacíos de catkin - -D “Mi primer Robot” Añade una descripción del robot - - -rosdistro KINETIC Añade la distribución que manejamos - miRobot Añade un paquete llamado miRobot

ingresan al paquete que se denomina miRobot con el comando ls se puede observar:

- CmakeLists.txt - package.xml

Inicializan eclipse para crear un proyecto y así modificar los códigos desde esta plataforma, se lanza eclipse, seleccionan nuevo proyecto como se puede observar.

Fuente: Autores. Se da clic en siguiente y se denomina un nombre al proyecto, se desmarca la opción de ruta por defecto y se da clic en buscar ruta o buscar.

Figura 15. Creación de nuevo proyecto en eclipse.

40

Fuentes: Autores.

Seleccionan la carpeta de usuario o donde se tenga la carpeta creada anteriormente en este caso robot luego clic en la carpeta src o source y luego miRobot, aquí aparecen dos archivos un Cmakelist y un package, se da clic en aceptar y luego en finalizar.

Fuentes: Autores.

Ahora se crea una carpeta llamada mundo o world dentro del paquete del robot creado anteriormente, ahora se crea otra con el nombre de launcher.

Figura 16. Selección de Carpeta.

Figura 17. Distribución de Archivos.

41

Fuentes: Autores. Ahora se crea un archivo o un file o fichero que permite lanzar el robot y activara la comunicación con ROS y Gazebo, se define un nombre que termine con “ .launcher ”, como se aprecia a continuación en la figura 7.

Fuente: Autores. Como se observa, se tiene un archivo, le colocan un nombre con la extensión “.launcher “, ahora según el formato SDF se usan estas líneas que pueden observar, están en lenguaje XML y significan: <arg name="paused" default="true"/> “lanza el robot pausado” <arg name="use_sim_time" default="true"/> “que use el tiempo por defecto” <arg name="gui" default="true"/> “que muestre el entorno”

Figura 18. Creación de carpetas (world) y sub-carpeta(Launcher).

Figura 19. Creacion de archivo lanzador (.launcher) y mundo (.world)

42

<arg name="headless" default="false"/> <arg name="debug" default="false"/> “que no muestre todo lo que hay detrás o una depuración del robot” Se crea un archivo “.world“ con cualquier nombre en este caso se colocó robot_acuatico2.world e ingresan la ruta para incluirlo en el launcher o lanzador como se puede observar. <arg name="world_name"value="(find miRobot)/worlds/robot_acuatico2.world"/> En el archivo de mundo se comienza a crear el entorno donde estará el robot, condiciones de gravedad, luz entre otras cosas que se puede observar directamente en la página de SDF FORMAT; en este caso se crea un mundo para la caja que fue propuesto hacer para el tutorial. Figura 20. Creación del mundo. (.world)

Fuentes: Autores. Se colocan estas líneas de código y se lanzan en la terminal para verificar que esté conectado ros y Gazebo con el siguiente comando: “ roslaunch miRobot robot_acuatico1.launcher ” se da enter y este abre directamente Gazebo con el mundo creado.

Fuentes: Autores. La línea verde que se observa es el eje (Y), la línea roja el eje (x), y la de azul el eje (z) respectivamente.

Figura 21. Entorno Gazebo.

43

Fuentes: Autores. En la anterior imagen se ve creado el mundo con la caja ya creada y para que funciona cada línea de código es importante mantener una estructura organizada. Al lanzarlo en la terminal queda la caja 2x2 como observan a continuación en la figura 23.

Fuentes: Autores.

EXPORTACIÓN DE UN MODELO CREADO EN SOLIDWORKS A GAZEBO.

Usualmente los robots están diseñados en programas como lo son SolidWorks, AutoDesk Inventor entre otros, estos programas facilitan el diseño y modelado del robot sin embargo existen otros programas como en este caso ROS el cual tiene más alternativas para simular un robot. Para realizar las simulaciones respectivas en ROS es necesario tener el robot modelado en el archivo .DAE para eso es necesario adquirir Blender y SketchUp.

Figura 22. Creación del mundo.

Figura 23. Modelo de una caja 2x2 en Gazebo.

44

3.4.1. Instalación de SketchUp

Para la instalación de SketchUp es necesario el programa PlayOnLinux ya que dicho programa tiene licencias de Microsoft y por esta razón no se puede instalar convencionalmente. Este programa permite instalar cualquier programa de Microsoft en Linux para este caso SketchUp.

3.4.2. Descarga de PlayOnLinux

La descarga de este programa se puede realizar mediante la página oficial que se encuentra a continuación: (https://www.playonlinux.com/en/download.html). Figura 24. Página Web, PlayOnLinux.

Fuentes: Autores. Se descargan los paquetes de Debian, el cual es el sistema operativo que se tiene, en el caso que no tenga este sistema operativo instalar el que este instalado. Después de tener instalado PlayOnLinux se procede a instalar SketchUp. El archivo de SketchUp puede ser descargado desde la página oficial. (https://help.sketchup.com/en/downloading-older-versions)

Fuentes: Autores.

Figura 25. Página Web SketchUp.

45

Se descarga la versión SketchUp Make 2017 o 2016 ya que, si se descarga una versión anterior, SketchUp no podrá importar archivos de tipo IFC (Industry Foundation Classes) y este tipo de formato será el de nuestro modelo 3D. Cuando el programa este instalado, aparecerá una imagen como la siguiente, para eso se requiere abrir antes PlayOnLinux y seleccionar la opción en lanzar y finalmente se tendrá el programa instalado.

Fuentes: Autores.

3.4.3. Importación de SketchUp a Blender.

Con el archivo .3DS exportado mediante SketchUp, se puede abrir este archivo en Blender como se muestra en la siguiente imagen el modelo 3D del robot.

Fuentes: Autores.

Figura 26. Programa SketchUp 2016.

Figura 27. Obtención del Robot en Blender.

46

En esta imagen se encuentra el robot, la visualización en Gazebo será igual a como se ve en Blender, se puede afirmar que la exportación de SketchUp a Blender mediante el archivo. 3DS fue exitosa ya que no perdió ningún detalle en el diseño y por ende su renderizado se realizó de la mejor manera.

3.4.4. Exportación de Blender.

Luego de tener el modelo 3D en Blender es necesario exportar este archivo a .DAE ya que es el archivo requerido por Gazebo, a continuación, se muestra como es la exportación en la siguiente imagen.

Fuentes: Autores. Para abrir el archivo en gazebo es necesario tener el robot tipo .DAE y su configuración principal, como lo es su momento de inercia y definir ciertos parámetros que se explicaran a continuación.

Fuentes: Autores. Se crean estas tres capetas para el modelo en la ubicación de gazebo, estas carpetas se pueden crear mediante el comando mkdir (Nombre del archivo), en la carpeta meshes se encontrará el modelo

Figura 28. Creación del modelo para Gazebo.

Figura 29. Carpetas creadas para el modelo.

47

3D con el formato .DAE, en la carpeta “model.config” estará la configuración general del modelo, para poder editar esta carpeta se requiere del comando vim (Nombre del archivo).

Fuentes: Autores. Como se puede observar se encuentra el nombre de los autores y el nombre del archivo y su respectiva versión. La siguiente carpeta es model.sdf la cual contiene toda la información del modelo sin embargo para este caso solo se utiliza el momento de inercia.

Fuentes: Autores En esta imagen se encuentra el momento de inercia del robot y la ubicación del archivo que se está modificando el cual es blender.dae.

Figura 30. Configuración del modelo.

Figura 31. Configuración de Inercia del modelo.

48

Ahora, ya se procede a abrir nuestro modelo en gazebo, solo falta agregar la ubicación donde se encuentra el archivo del robot, para esto se agrega el Path.

Fuentes: Autores. Finalmente, el robot se exporto exitosamente a gazebo como se observa en la siguiente imagen, hay que tener en cuenta de siempre agregar el path correctamente ya que si la ubicación es errónea el archivo no será abierto por gazebo y el espacio de trabajo se encontrará vacío.

Fuentes: Autores.

Figura 32. Lanzamiento de robot en Gazebo.

Figura 33. Obtención del robot en Gazebo.

49

4. IMPLEMENTACIÓN DE ROS EN RASPBERRY PI

En este capítulo se quiere guiar para la preparación e instalación de ROS en un sistema embebido,

con el fin de que en el aula de clase se promueva el uso de estos dispositivos y se ilustren nuevas

formas de programación.

Para la instalación de ROS en un embebido, en este caso la Raspberry pi se tienen unos requisitos,

los cuales se conforman de una Memoria microSD (Se recomienda clase 10), Raspbian OS / Ubuntu

Mate 16.04 OS, un cable HDMI, un cargador, monitor, teclado, ratón.

INSTALACIÓN RASPIAN

Se descarga la imagen de Raspbian desde la página oficial de Raspberry pi, la cual se ilustra a continuación.

https://www.raspberrypi.org/downloads/

Figura 34. Página Web, Raspberry.

Fuentes: Autores.

El siguiente paso por seguir es descargar Raspbian Stretch with desktop, seleccionan la opción descargar ZIP como se muestra en la imagen.

50

Figura 35. Descarga de Raspian Stretch.

Fuentes: Autores.

El siguiente paso se descarga Win32 Disk Imager el cual es un programa diseñado para escribir una imagen de disco sin formato en un dispositivo en el siguiente enlace se puede descargar dicho programa.

https://sourceforge.net/projects/win32diskimager/

Se ejecuta el programa.

Figura 36. Ejecución de programa Win32DiskImager.

Fuentes: Autores.

Se acepta la licencia del software para poder instalarlo

51

Fuentes: Autores.

Finalmente, después de instalarlo aparecerá la siguiente ventana lo cual significa que ya se podrá usar el programa.

Figura 38. GUI, Win32DiskImager.

Fuentes: Autores.

Figura 37. Licencia Win32DiskImager.

52

Ahora se busca el archivo que se descargo de raspbian, en este caso se descarga en el escritorio y se le da en write, es importante seleccionar la ubicación donde se encuentra la memoria microSD en este caso se encuentra en la unidad G como se ve en el recuadro negro de la siguiente imagen.

Figura 39. Preparación para instalar la imagen de SD.

Fuentes: Autores.

Figura 40. Selección de Imagen.

Fuentes: Autores.

53

Figura 42. Implementación de SD en Raspberry.

Al finalizar la instalacion aparecera una ventana con el mensaje “Write Successfull” lo cual significa que la instalacion se ha realizado correctamente.

Figura 41. Instalación de imagen en la SD.

Fuentes: Autores.

PREPARACION DEL HARDWARE

Se inserta la microSD en la ranura posterior de la RaspberryPi.

Fuentes: Autores.

54

Se conectan los periféricos necesarios.

- Ratón

- Teclado

- Cable HDMI

- Cargador

Fuentes: Autores.

Luego de conectar los periféricos aparece la pantalla de carga que se muestra a continuación y se tiene instalado Raspbian en la Rasberry Pi ya que la instalación se hizo por medio del programa Win32 Disk Imager el cual permite guardar la imagen en la memoria microSD con el archivo de Raspbian previamente descargado en el paso 2.

Figura 44. Gui, Raspian.

Fuentes: Autores.

Figura 43. Conexión de Periféricos.

55

Ahora se realizan las actualizaciones respectivas del sistema, esto puede tardar varios minutos mientras descarga y aplica las actualizaciones requeridas, para realizar este procedimiento es necesario tener la Raspberry Pi conectada a internet ya sea por cable o por wifi.

sudo apt-get update

Figura 45. Descarga de actualización de sistema operativo.

Fuentes: Autores.

sudo apt-get upgrade

Figura 46. Instalación de paquetes por actualizar en el sistema operativo.

Fuentes: Autores.

56

Finalmente se configura el idioma y la hora. Para cambiar el idioma seleccionan la opción Raspberry Pi Configuration.

Figura 47. Configuración sistema operativo.

Fuentes: Autores.

Saldrá una ventana como la que se muestra a continuación y seleccionan la opción Localisation.

Figura 48. Gui, Configuración.

Fuentes: Autores.

Se selecciona la opción Set Locale con el fin de modificar el idioma de la RaspberryPi.

57

Figura 49. Configuración de idioma.

Fuentes: Autores.

En la opción de Language seleccionan la opción es (Spanish) y pulsan en OK.

Figura 50. Selección de Idioma.

Fuentes: Autores.

Para configurar la hora seleccionan en Timezone, si su ubicación es de Colombia selecciona América y Bogotá respectivamente como se puede observar en la siguiente imagen.

58

Figura 51. Configuración de Zona horaria.

Fuentes: Autores.

Finalmente, la Raspberry Pi está en el idioma deseado, con la hora respectiva del país y lista para funcionar e instalar ROS y Gazebo.

Esta instalación se realiza de la misma forma en que fue realizado en Ubuntu.

59

5. MODELAMIENTO MATEMATICO DE ROBOTS POR MEDIO DE MATLAB

En este capítulo se encontrará como exportar un modelo diseñado en SolidWorks a Matlab, además se encontrarán los modelos matemáticos de los robots a simular tanto en Matlab como en ROS.

EXPORTACIÓN DE UN MODELO CREADO EN SOLIDWORKS A MATLAB.

Inicialmente se debe descargar un complemento para lograr la exportación, este complemento se llama Simmechanics o Simscape Multibody y se puede encontrar en la página oficial de Matlab.

(https://la.mathworks.com/campaigns/offers/download_smlink_confirmation.html?elqsid=1562619479406&potential_use=Student)

En el caso de este proyecto se descarga la versión 5.2 ya que se tiene matlab 2018a, descargamos tanto el ZIP como el archivo instalador “.m”; Esto se debe a que las versiones deben ser semejantes para que se puedan leer archivos de forma bidireccional.

Figura 52. Página web, Matlab.

Fuentes: Autores.

5.1.1. Instalación de complementos en SolidWorks.

Luego de descargar estos dos elementos, se procede con la instalación, los dos elementos deben estar en una misma carpeta. Se inicializa matlab y se coloca la siguiente línea de código:

install_addon('smlink.r2018a.win64.zip')

una vez este completa la instalación se coloca este comando “ doc_smlink ” tecla enter y luego el siguiente comando “smlink_linksw”. Hecho esto se puede ver en SolidWorks el complemento instalado. Como se puede ver a continuación.

60

Figura 53. Configuración de Simscape Multibody Link en SolidWorks.

Fuentes: Autores.

5.1.2. Configuración del modelo en SolidWorks.

Hecho esto se abre el modelo diseñado y se continua con la exportación. En SolidWorks, una vez abierto el ensamble en SolidWorks, se da clic en herramientas Simscape Multibody link seguido se elige la opción exportar y por último clic en Simscape Multibody, se recomienda mantener abierto matlab debido a que se comunican y esto facilita el proceso.

Figura 54. Exportación de SolidWorks a Matlab.

Fuentes: Autores.

61

5.1.3. Exportación del modelo a Matlab.

Una vez terminado el proceso, en matlab se coloca el siguiente código:

smimport('Dron_1.xml')

debe estar abierta la ruta donde se encuentra el archivo, para que abra el archivo en simulink, se verá un diagrama de bloques de la siguiente forma: Figura 55. Diagrama de Bloques en Simulink.

Fuentes: Autores.

Ahora se da en run y cuando termine de correr se verá el modelo en esta ventana:

Figura 56. Modelo en Simulink, Matlab.

Fuentes: Autores.

De esta forma se concluye la exportación de SolidWorks a Matlab.

62

SIMULACIÓN E IMPLEMENTACIÓN DE CONTROLADORES POR MEDIO DE LOS MODELOS MATEMÁTICOS.

En esta sección se encontrará el modelo matemático de los robots implementados, como se controlaron y sus resultados, para esta guía se implementaron el robot denominado tipo industrial y nombrado brazo robótico antropomórfico, además se encontrará los robots tipo UAV “Dron no tripulado de uso civil” y por último el tipo móvil nombrado “Robot Diferencial”.

5.2.1. Brazo robótico.

5.2.1.1. Modelo Matemático.

En esta ocasión se realiza la geometría, basado en el plano de referencias, se tiene el plano (x), (y) y (z). se inicia con el ángulo de rotación del eje z que se denomina q1, el que se mueve en el eje (Y) q2 y en el eje (x) q3.

Como se observa, se forma un triángulo rectángulo con q1 de esta forma se pueden obtener los valores por medio de ley de cosenos.

Figura 57. Plano de Referencias.

Fuentes: Autores.

se halla la hipotenusa que en este caso se denomina L1 y L2, se desarrolla y se obtiene:

𝑥 = 𝐿1 cos(𝑞2) cos(𝑞1) + 𝐿2 cos(𝑞2 + 𝑞3) cos(𝑞1) (1)

se realiza el mismo proceso para el eje (Y) y se obtiene:

63

𝑦 = 𝐿1 cos(𝑞2) sin(𝑞1) + 𝐿2 cos(𝑞2 + 𝑞3) sin(𝑞1) (2)

Para el eje z se tiene en cuenta la altura de la base del brazo robótico y se obtiene de la misma forma:

𝑧 = h + 𝐿1 sin(𝑞2) + 𝐿2 sin(𝑞2 + 𝑞3)

(3)

A partir del modelo geométrico, se obtiene el modelo cinemático directo, se deriva y se obtiene en forma matricial como se muestra a continuación:

[

−𝐿1 cos(𝑞2) sin(𝑞1) − 𝐿2 cos(𝑞2 + 𝑞3) sin(𝑞1) −𝐿1 cos(𝑞1) sin(𝑞2) − 𝐿2 cos(𝑞1) sin(𝑞2 + 𝑞3) −𝐿2 cos(𝑞1) sin(𝑞2 + 𝑞3)

𝐿1 cos(𝑞2) cos(𝑞1) + 𝐿2 cos(𝑞2 + 𝑞3) cos(𝑞1) −𝐿1sin(𝑞1)sin(𝑞2) − 𝐿2sin(𝑞1)sin(𝑞2 + 𝑞3) −𝐿2sin(𝑞1)sin(𝑞2 + 𝑞3)

0 𝐿1 cos(𝑞2) + 𝐿2𝑐𝑜𝑠(𝑞2 + 𝑞3) 𝐿2cos(𝑞2 + 𝑞3)

] (4)

Aquí se puede observar la derivada del eje (x) con respecto a (q1) luego se deriva con respecto a (q2) y finalmente con respecto a (q3).

En la siguiente fila se realizan las derivadas del eje (Y) con respecto a (q1), (q2) y (q3), respectivamente.

Por último, se deriva el eje (Z) de la misma manera con respecto a (q1), (q2) y (q3), como se puede encontrar en la fila 3 de la matriz.

5.2.1.2. Implementación de controlador.

En la actualidad existen diversas técnicas para controlar un robot, por mencionar algunas se determina el diseño de controladores proporcionales (P), proporcionales-derivativos(PD), proporcionales-integrales(PI),proporcional-integral-derivativo(PID), de igual manera podrían ser ideales o reales, para esta guía, no se usó ningún controlador de los mencionados; sino, se efectúa la estabilidad a través de la ecuación de Lyapunov [25] junto a una matriz de ganancia K, que permite converger el error a 0.

Por otra parte, se debe tener en cuenta que se tomó el modelo matemático para que el punto de interés a controlar sea el gripper; para encontrar la posición del gripper o punto de interés, se deben dar unas condiciones iniciales en el robot, estas condiciones iniciales están dadas por (q1, q2,q3) que corresponden a la ubicación de las articulaciones. También se deben indicar los valores de L1(longitud de la articulación 1), L2 (longitud de la articulación 2) y h (altura de la base a la primera articulación), como se puede observar a continuación:

𝐿1 = 0.5

𝐿2 = 0.65

ℎ = 0.25

𝑞1 = 0(𝜋/180)

64

𝑞2 = 30(𝜋/180)

𝑞3 = 30(𝜋/180)

Con esto ya se puede encontrar la posición del gripper, teniendo en cuenta que el modelo siempre se realizó con respecto al punto de interés en este caso el gripper. Para hallar la posición inicial del robot, se determina las condiciones iniciales en las ecuaciones, de esta forma se obtiene el primer punto de posición del gripper.

En este caso se realizó una trayectoria, por ende, se deben indicar las coordenadas, para realizar un control de puntos y determinar un vector que sea dependiente del tiempo, por ello se obtuvieron las siguientes ecuaciones:

𝑥𝑟 = 0.6 cos(0.2𝑡) (5)

𝑦𝑟 = 0.6sin(0.2𝑡) (6)

𝑧𝑟 = 0.7 + 0.01𝑡 (7)

A estas ecuaciones se les realiza la derivada de cada una, para realizar el cálculo de control. Se realiza un bucle de simulación calculando los errores de cada una de las posiciones del gripper, se almacenan en un vector y se multiplica por la matriz o cinemática, además se realiza una matriz de ganancia que permite converger el desempeño del controlador.

A continuación, se realiza la ley de control para el seguimiento de trayectorias que se denomina de la siguiente manera:

Se determina un vector inicialmente:

ℎ𝑑𝑝 = [𝑥𝑟(𝑘)𝑦𝑟(𝑘)𝑧𝑟(𝑘)]′ (8)

y se determina la ley de control “ecuación de Lyapunov”:

𝑣 = (𝐽)−1(ℎ𝑑𝑝 + 𝐾tanh(𝑒)) (9)

Esta, se obtiene de la derivada de las ecuaciones de las posiciones deseadas, se usa la tangente hiperbólica (tanh) para saturar las velocidades que se aplican a los eslabones del brazo robótico.

Para la simulación se debe realizar la integración numérica de las velocidades obtenidas por la ecuación (9), una vez halladas las posiciones que debe alcanzar para lograr la trayectoria, se aplican al modelo geométrico obtenido anteriormente.

La ecuación de Lyapunov ayuda a determinar la trayectoria del robot con las condiciones iniciales, al cumplir las condiciones y con las ecuaciones de velocidad aplicadas, se genera el movimiento del robot.

65

5.2.1.3. Obtención de resultados.

En esta sección se grafican los errores para ver el desempeño del controlador y adicionalmente se muestran las acciones de control, de esta forma analizar si se satura por medio de la tangente hiperbólica las velocidades aplicadas en el robot.

A continuación, se puede observar el resultado de la simulación, las gráficas de los errores y las velocidades o acciones de control:

Figura 58. Simulación de Brazo Robótico y su respectiva trayectoria.

Fuentes: Autores.

66

Fuentes: Autores. Figura 60. Errores de Posición.

Fuentes: Autores.

Figura 59.. Velocidades o Acciones de Control.

67

5.2.2. Robot UAV (Dron).

En este ítem se va a simular el robot aéreo tipo UAV civil o comúnmente llamado dron no tripulado de uso civil. Para ello se va a tener en cuenta el modelamiento del robot omnidireccional que se asemeja al funcionamiento del robot aéreo UAV, claramente adicionando su altura que en esta sección se denomina eje (z). A continuación, se realiza el modelamiento matemático y sus respectivas simulaciones.

5.2.2.1. Modelo Matemático.

Un robot UAV, tiene características de un robot omnidireccional por lo tanto se puede mover en cualquier dirección y además posee tres grados de inclinación que son el Pitch (P), el Yaw (Y) y el Roll (R).

Esta simulación se va a centrar en el ángulo (Y) y se basa en el modelo matemático de un robot omnidireccional para la obtención del modelo matemático del robot UAV.

- Modelo Matemático UAV

Figura 61. Plano de referencias Robot UAV.

Fuentes: Autores.

Se analiza el plano de referencias y geométricamente se obtiene:

𝑥𝑟 = 𝑥𝑐 (10)

𝑦𝑟 = 𝑦𝑐 (11)

xr: es la coordenada donde se encuentra el punto xc o punto de interés, donde xc es el centro de nuestro robot en el eje x.

68

yr: es la coordenada donde se encuentra el punto yc o punto de interés, donde yc es el centro de nuestro robot en el eje y.

La idea principal del modelo es relacionar las velocidades 𝑥�̇� y 𝑦�̇� con las velocidades que se deben aplicar al robot, para que se desplace, en este caso se tiene una velocidad frontal que llamaremos (uf) o velocidad lineal frontal y una velocidad perpendicular, que se denominó (ul) o velocidad lineal lateral.

El modelo se debe realizar en función a estas velocidades, se deriva y se obtiene:

𝑥�̇� = 𝑥�̇� (12)

𝑦�̇� = 𝑦�̇� (13)

Ahora si se desplaza el sistema de referencias, se puede obtener los ángulos formados como se observa, son Phi(Φ) y Alpha(α), con estos ángulos se podrá descomponer estas dos velocidades en sus respectivos ejes (X) y (Y) y se obtiene:

𝑥�̇� = 𝑢𝑓 cos(𝜑) − 𝑢𝑙sin(𝛼) (14)

𝑦�̇� = 𝑢𝑓 sin(𝜑) + 𝑢𝑙 cos(𝛼) (15)

Ahora se considera la velocidad angular y queda:

�̇� = 𝜔 (16)

Ya considerado ω se analiza respectivamente el plano de referencias del robot y se concluye que:

𝛼 = 𝜑 (17)

Ahora se realiza el reemplazo en las respectivas ecuaciones y el modelo matemático queda de la siguiente manera:

𝑥�̇� = 𝑢𝑓 cos(𝜑) − 𝑢𝑙sin(𝜑) (18)

𝑦�̇� = 𝑢𝑓 sin(𝜑) + 𝑢𝑙 cos(𝜑) (19)

�̇� = 𝜔 (20)

Retomando el modelo para el robot UAV se agrega la velocidad en el eje Z.

69

Para este modelo se desea trabajar el punto de control a una distancia “a” lo cual cambia el modelo matemático de la siguiente manera, se representa en forma matricial debido a que es una forma más sencilla de trabajar en Matlab:

[

cos(𝜑) −sin(𝜑) 0 −𝑎sin(𝜑)

sin(𝜑) −cos(𝜑) 0 𝑎cos(𝜑)

00

00

1 00 1

]

(21)

5.2.2.2. Implementación de controlador.

En esta sección con la matriz del modelo matemático se puede implementar el control del robot UAV de la siguiente manera:

Se determinan las variables deseadas:

𝑎 = 0.1;

𝑥𝑟𝑑 = 2;

𝑦𝑟𝑑 = 2;

𝑧𝑟𝑑 = 5;

𝑝ℎ𝑖𝑑 = 90(𝑝𝑖/180);

Se realiza el mismo procedimiento que se realizó en el brazo robótico de calcular las posiciones, el error de posición, las velocidades, una matriz de ganancia para el control del robot, determinar un bucle para el modelo matemático y graficar.

5.2.2.3. Obtención de resultados.

Como resultado se quiso llegar a simular el “Dron” a un punto con una altura y una distancia de su punto de origen, en la siguiente grafica se puede observar la trayectoria y las gráficas correspondientes.

Figura 62. Simulación del Robot UAV. (Dron)

Fuentes: Autores.

70

Figura 63. Grafica de las velocidades del Robot UAV.

Fuentes: Autores.

Figura 64. Errores de Posición para cada eje.

Fuentes: Autores.

71

5.2.3. Robot Diferencial.

En este apartado se va a encontrar un robot tipo móvil, para ser más exactos un robot diferencial, que de igual manera se le realiza, el modelo matemático y su respectiva simulación.

5.2.3.1. Modelo Matemático.

Fuentes: Autores.

En este segmento se realiza la representación del robot en coordenadas polares.

𝐿 = √(𝑥𝑟𝑑 − 𝑥𝑟)2 + (𝑦𝑟𝑑 − 𝑦𝑟)2 (22)

ζ = ψ − Φ (23)

𝜓 = 𝑎𝑡𝑎𝑛2((𝑦𝑟𝑑 − 𝑦𝑟), (𝑥𝑟𝑑 − 𝑥𝑟)) (24)

Aquí se puede observar que (L) es la distancia del punto de control hacia el punto de meta. Que viene dada por la distancia euclidiana.

A demás, el ángulo (ψ) es el ángulo de orientación que se puede obtener en el punto de meta y el ángulo (ζ) que viene dado por la diferencia de (ψ) y (Φ) de orientación del robot.

También se observa que entre el punto actual y el de meta, forma un triángulo rectángulo. Por lo tanto, se utiliza la tangente para hallar dicho ángulo, donde dice que la tangente es igual al cateto

Figura 65. Plano de Referencias Robot Diferencial.

72

opuesto (𝑦𝑟𝑑 − 𝑦𝑟) sobre el adyacente (𝑥𝑟𝑑 − 𝑥𝑟). Denominado esto se deriva el conjunto de ecuaciones y se obtiene el modelo diferencial.

Finalmente se tiene el siguiente modelo.

�̇� = −𝑣cos(ζ) (25)

𝜁̇ = −𝜔 + (𝑣

𝑙) sin(ζ) (26)

�̇� = (𝑣

𝑙) sin(𝜁) (27)

Con estas ecuaciones definida se puede iniciar la implementación de control para el robot diferencial.

5.2.3.2. Implementación de controlador.

Para el diseño del controlador se debe garantizar que la distancia (L) del punto de control hacia la meta tienda a cero, la zeta (𝜁) tienda a cero y el Psi (ψ) tienda a cero.

Para ello según el método de Lyapunov existen algunos pasos, en primer lugar, es definir la función candidata de Lyapunov, en este caso se debe tener todos los estados que estamos analizando.

La idea de este método es definir los términos de la función candidata negativa. Esto debido a la cuarta condición de Lyapunov.

Para el primer término se propone que la acción de control de la velocidad lineal sea:

𝑣 = 𝐾1(cos(𝜁))𝐿,𝐾1 > 0 (28)

Y para la velocidad angular con el siguiente termino:

𝜔 = (𝐾2(cos(𝜁))(sin(𝜁))(𝜁 + 𝑞2𝜓))/𝜁, 𝐾2 > 0 (29)

Definido esto se establecen los parámetros de simulación como se observa a continuación.

5.2.3.3. Obtención de resultados.

En este tramo se establecen los requerimientos de simulación y se obtiene las gráficas de simulación obtenidas.

Se definen las posiciones deseadas xr: Posición del centro de eje de las ruedas en X[m]; yr: Posición del centro de eje de las ruedas en Y[m]; Phi: Orientación inicial con respecto al eje x [rad]. Luego se

73

obtiene la posición final o meta que se quiere cumplir con el robot, en este caso: (xrd) Posición del centro de eje de las ruedas en X[m] final y (yrd) Posición del centro de eje de las ruedas en Y[m] final.

Se aplican las acciones de control de la misma forma que se evidencio anteriormente, se hallan las posiciones con la integral numérica y se obtiene.

Figura 66. Simulación de Trayectoria Robot Diferencial.

Fuentes: Autores.

74

Figura 67. Errores en cada termino.

Fuentes: Autores.

Como se puede observar el algoritmo de control funciona debido a que los errores de cada termino tienden a cero como se había diagnosticado.

Figura 68. Respuesta de acción de control.

Fuentes: Autores.

75

6. SIMULACIÓN DE ROBOTS EN ROS

En este capítulo se observa la simulación de los robots en ROS. En primer lugar, se necesita implementar un robot, en este caso se usa un repositorio de un robot diferencial con el siguiente código se puede descargar en:

git clone -b base https://github.com/richardw05/mybot_ws.git

Fuentes: Autores. En este repositorio se encuentran los archivos respectivos para poder controlar el robot diferencial, es necesario acceder al workspace para este caso es mybot_ws, el cual fue descargado anteriormente, como se muestra en la siguiente imagen.

Fuentes: Autores.

Figura 69. Línea de código del paquete.

Figura 70. Construcción del Workspace.

76

Fuentes: Autores. Ahora se incluye el workspace, para buscar el path con el siguiente código que se encuentra a continuación.

echo "source ~/mybot_ws/devel/setup.bash" >> ~/.bashrc Luego se inicia el programa con roslaunch.

Fuentes: Autores. A continuación, se abrirá la ventana de Gazebo con el robot diferencial como se muestra en la siguiente imagen.

Figura 71. Ingreso al Workspace.

Figura 72. Compilando el Programa.

77

Fuentes: Autores. Implementado ya el robot en gazebo ahora se controla el movimiento de forma teleoperada, en este caso por el teclado del computador para hacer más fácil su manejo, ya que también se podría implementar su control por medio de código, para esto se requiere de unos paquetes diseñados por la comunidad. En primer lugar, se abre otra ventana, sin cerrar la actual, ya que en esta está corriendo actualmente el programa, para esto se utilizan las teclas.

Fuentes: Autores. Ahora se descargan los paquetes para poder controlar el robot de forma teleoperada con el teclado del computador, estos paquetes llevan el nombre de teleop twist keyboard. Figura 75. Pestaña adicional en consola.

Fuentes: Autores.

sudo apt-get install ros-kinetic-teleop-twist-keyboard

Figura 73. Robot en ROS.

Figura 74. Comandos.

78

En la anterior imagen, se observa la ventana adicional que se inicia con las teclas mencionadas, hay que tener en cuenta la línea de código que se utiliza, para este caso se descarga el paquete para la versión Kinetic, en su caso se debe descargar su respectiva versión, por ejemplo:

• Para la versión Indigo

sudo apt-get install ros-indigo-teleop-twist-keyboard

• Para la versión Lunar

sudo apt-get install ros-lunar-teleop-twist-keyboard

• Para la version Melodic

sudo apt-get install ros-melodic-teleop-twist-keyboard Adicionalmente puede visitar la página oficial de ROS.org donde se encuentra toda la documentación sobre estas versiones; Después de instalar este paquete solo faltara correr el paquete respectivo, esto se realiza con el siguiente código.

Fuentes: Autores:

rosrun teleop_twist_keyboard teleop_twist_keyboard.py A continuación, se observa cómo controlar el robot de por medio del teclado.

Figura 76. Lanzar el programa Teleoperado.

79

Fuentes: Autores. Con los comandos que se encuentran a continuación usted podrá manejar el robot.

i = Mover hacia adelante , = Mover hacia atrás k = Parar el robot j = girar a la izquierda l = girar a la derecha

Hay que tener en cuenta que el robot tiene unas velocidades angulares y lineales las cuales se pueden modificar ya que al principio el robot tiene una velocidad por defecto que puede ser elevada y por ende su control no sea adecuado; por este motivo se recomienda bajar estas velocidades, oprimiendo las teclas correspondientes:

q/z : Incrementar / Decrementar la velocidad del robot.

Figura 77. Comando del programa.

80

IMPLEMENTACIÓN DE SENSORES AL ROBOT.

En esta sección se encuentra como se puede agregar sensores a su robot, para este caso se agregará

el láser Hokuyo que se muestra en la siguiente imagen.

Recuperado de: https://www.roscomponents.com/en/visible-price/85-ust-10lx.html

Para que el robot tenga el sensor es necesario agregar el modelo del sensor laser Hokuyo, en el

modelo urdf, este modelo está ubicado en el workspace y en la carpeta mybot_description, como

se muestra en la siguiente imagen.

Figura 79. Ubicación modelo URDF.

Fuente: Autores.

En la siguiente imagen se muestra el modelo del sensor urdf, que se encuentra en los archivos

mybot.xacro.

Figura 80. Ubicación archivo del sensor URDF.

Fuente: Autores.

Figura 78. Laser Hokuyo.

81

Figura 81. Código Sensor URDF.

Fuente: Autores.

Ahora se debe agregar el modelo del sensor .dae, este modelo debe estar ubicado en la carpeta

meshes de la descripción del robot.

El modelo hokuyo.dae es el archivo 3D del láser, en capítulos anteriores se encuentra información

de cómo convertir estos archivos a .dae, también es necesario modificar los archivos del robot que

van enlazados a Gazebo, para este caso se muestra el archivo mybot.gazebo.

82

Figura 82. Proyección del Laser.

Fuente: Autores.

Adicionalmente se puede observar el láser que proyecta el sensor, esto es debido al anterior código. Figura 83. Proyección del laser implementado en el Robot.

Fuente: Autores.

Para evidenciar en RViz que el robot tiene un sensor laser, es necesario agregar en la opción

laserScan.

83

Figura 84. Selección de opción LaserScan.

Fuentes: Autores.

Figura 85. Visualización de objetos con LaserScan.

Fuente: Autores.

84

Figura 86. Visualización de objetos en RVIZ.

Fuente: Autores.

En la imagen se observan los objetos que ve el robot desde RViz, y así es como realmente ve el

robot, esta simulación facilita la navegación de robot a la hora de programar.

NAVEGACIÓN DE ROBOTS AUTONOMOS

En el mundo actual es necesario que los robots sean autónomos y adicionalmente puedan navegar

en ambientes complicados, en este capítulo se muestra cómo hacer que el robot siga una trayectoria

de forma autónoma esto se realiza mediante la odometría el cual es el estudio de la estimación de

la posición de vehículos con ruedas durante la navegación.

Para que el robot siga una trayectoria de forma autónoma es necesario adicionar al robot anterior,

la creación del mapa que el robot reconoce por medio de los sensores, en este caso el sensor laser

y es necesario agregar el plugin necesario para que el robot siga la trayectoria que se le asigne.

En primer lugar, es necesario crear la carpeta de navegación con los siguientes archivos que se

explicarán en los siguientes pasos.

Con el comando que se observa, se crea la carpeta y algunos archivos necesarios en la carpeta de

navegación.

85

Figura 87. Creacion de archivos en la carpeta navegación.

Fuente: Autores.

Figura 88. Visualización de archivos dentro de la carpeta navegación creada.

Fuente: Autores.

Para que el robot detecte la trayectoria que se le asigne es necesario que el detecte el mapa, la

localización y de las órdenes para que el robot se mueve, esto se muestra en la siguiente imagen.

Figura 89. Configuración del mapa y localización del robot.

Fuente: Autores.

86

Es necesario iniciar primero el robot en gazebo como se muestra en los anteriores capítulos.

1. Iniciar el robot en gazebo

roslaunch mybot_gazebo mybot_world.launch

2. Iniciar el mapa del robot

roslaunch mybot_navigation amcl_demo.launch

3. Iniciar RVIz

roslaunch mybot_description mybot_rviz_amcl.launch

Figura 90. Inicialización de RViz, analizando los objetos.

Fuente: Autores.

Figura 91. Inicialización de Gazebo, analizando los objetos.

Fuente Autores.

87

Luego de iniciar RViz y Gazebo podemos asignar la trayectoria del robot, en el botón 2D Nav Goal, el

robot asignara la mejor ruta, esto es mediante la odometría y luego seguirá la trayectoria establecida,

esa trayectoria se puede ver en las figuras 93 y 94 la cual es la línea de color azul. Figura 92. 2D Nav Goal.

Fuente: Autores.

La flecha que se muestra anteriormente en la figura 92 es la trayectoria que se establece al robot, y

el robot calcula la mejor trayectoria, adicionalmente hay un objeto frente al robot el cual lo detecta

por las líneas rosadas, lo cual verifica que el mapeo se realiza correctamente. Figura 93. Trayectoria curva del robot.

Fuente: Autores.

88

En las figuras 93 y 94, el robot esta siguiente diferentes trayectorias una curva y otra semicurva, lo cual corrobora que el robot es capaz de establecer de forma autónoma trayectorias diferentes a trayectorias lineales de acuerdo con el entorno el cual este ubicado. Figura 94. Trayectoria semicurva del robot.

Fuente: Autores.

89

7. RESULTADOS Y PRUEBAS DE FUNCIONAMIENTO

En este capítulo se evidencia el funcionamiento del robot diferencial en Matlab y ROS, donde no se compara debido a que se realizan métodos o formas diferentes a la hora de implementar una trayectoria con el robot. Sin embargo, se logra realizar la trayectoria de forma autónoma como se había propuesto.

Para lograr la trayectoria es necesario ingresar los parámetros de entrada como lo son velocidad, este parámetro se encuentra alrededor de 0.5 en Matlab y exactamente 0.5 para ROS, esto debido a la forma de simulación Matlab simula con un parámetro de tiempo que se debe incluir en las condiciones deseadas, en ROS no sucede este inconveniente. Por consiguiente, con los algoritmos realizados respectivamente de forma autónoma calcula una ruta y se obtiene una respuesta, como se puede evidenciar en las siguientes imágenes.

Figura 95. Simulación de Trayectoria Robot Diferencial.

Fuentes: Autores.

Aquí se puede evidenciar como en Matlab la imagen izquierda, grafica una trayectoria similar a la que grafica ROS en la imagen derecha. Lo que indica que se logró lo propuesto y se obtuvieron los resultados esperados en dos herramientas de simulación diferentes.

90

8. CONCLUSIONES

Se determino la viabilidad y ventajas que permiten las simulaciones en las aplicaciones en robótica como se muestra en la sección 6, la cual muestra las simulaciones del robot diferencial y el cual permite ser utilizado en entornos de exploración, esto se logra debido a que el robot posee un sensor laser el cual permite escanear el área, la longitud máxima del sensor laser Hokuyo es de 10 m, adicionalmente mediante se implementó la navegación autónoma del robot, lo cual facilita la exploración el mapeo del entorno ya que no es necesario de que alguien opere el robot. La exploración es uno de los objetivos de la robótica y gracias a los simuladores como Gazebo y los frameworks como ROS, los cuales permiten realizar mapeos, facilitan la exploración de entornos desconocidos.

Se analizó cada herramienta computacional de simulación más usadas en la industria de sistemas robóticos, donde se determinó a Gazebo por medio de ROS y Matlab como las herramientas más completas a nivel gráfico, permite su integración con diferentes frameworks como lo es ROS, con mayor facilidad de programación, con mayor documentación para el desarrollo de los mismos por encima de Webots, V-Rep, Morse por mencionar algunos que no brindan la calidad de las herramientas mencionadas anteriormente. Adicionalmente estos simuladores permiten agregar diferentes plugins como lo son sensores, lo que nos permitió integrar un sensor laser al robot y que pudiera realizar la trayectoria de forma autónoma.

Se desarrollo una guía teórico-práctica de aplicaciones robóticas, en este proyecto se exponen los robots denominado tipo industrial y nombrado brazo robótico antropomórfico, además se encontrará los robots tipo UAV “Dron no tripulado de uso civil” y por último el tipo móvil nombrado “Robot Diferencial”. Donde se determina una base para el desarrollo de diversos robots en las aulas de clase, llegando a el objetivo establecido inicialmente.

En este proyecto se expuso y se encontraron los parámetros y modelos matemáticos necesarios para implementar la guía teórico-practica de simulación de robots, donde para cada modelo se definió una trayectoria. Dicha trayectoria se cumple por medio de algoritmos, se propone el método de Lyapunov para controlar el movimiento del robot como un método diferente a los expuestos en las aulas de clase, métodos convencionales como lo son los controladores PID y sus derivados, sin embargo, la respuesta de este método da una respuesta similar a la de un controlador PID. Además, se desarrollan los modelos matemáticos por métodos geométricos así obteniendo su cinemática y logrando llegar a la matriz jacobiana. Esta es otra forma de llegar a simular los robots debido a que usualmente se simulan con métodos matriciales.

91

9. REFERENCIAS

[1] Willow Garage, «Willow Garage,» [En línea]. Available: http://www.willowgarage.com/pages/pr2/overview. [Último acceso: 12 10 2019].

[2] Robotnik, «Robotnik,» [En línea]. Available: https://www.robotnik.eu/mobile-robots/rb-2-base/. [Último acceso: 12 10 2019].

[3] Robotnik, «Robotnik,» [En línea]. Available: https://www.robotnik.es/robots-moviles/summit-xl-steel/. [Último acceso: 12 10 2019].

[4] Open Source Robotics Foundation, «Gazebo,» [En línea]. Available: http://gazebosim.org/. [Último acceso: 23 5 2019].

[5] Morse, «Morse,» [En línea]. Available: https://www.openrobots.org/morse/doc/stable/morse.html. [Último acceso: 23 5 2019].

[6] Cyberbotics Ltd, «Webots,» [En línea]. Available: https://cyberbotics.com/#webots. [Último acceso: 23 5 2019].

[7] J. d. M. Fernández, «Exploración del software de simulación V-REP,» 2017. [En línea]. Available: https://fama.us.es/discovery/fulldisplay?docid=alma991012655739704987&context=L&vid=34CBUA_US:VU1&search_scope=all_data_not_idus&tab=all_data_not_idus&lang=es. [Último acceso: 23 5 2019].

[8] Ministerio de Educación, Cultura y Deporte, «Intef,» [En línea]. Available: http://www.ite.educacion.es/formacion/materiales/181/cd/m1/qu_hace_blender.html. [Último acceso: 13 Febrero 2019].

[9] Centro de excelencia del software libre, «Centro de excelencia del software libre,» [En línea]. Available: http://www.esi.uclm.es/www/cglez/fundamentos3D/04.06.Simulaciones.html. [Último acceso: 12 Febrero 2019].

[10] M. A. H. A. P. &. B. Perez. [En línea]. Available: http://dea.unsj.edu.ar/control1b/teoria/unidad1y2.pdf. [Último acceso: 23 5 2019].

[11] J. M. Galindo Haro, «Diseño e implementación de un marco de trabajo (framework) de presentación para aplicaciones JEE.,» 2010. [En línea]. Available: http://openaccess.uoc.edu/webapps/o2/handle/10609/876. [Último acceso: 23 5 2019].

[12] ROS wiki, «ROS.org,» [En línea]. Available: http://wiki.ros.org/. [Último acceso: 23 5 2019].

92

[13] sourceforge, «PlayerStage,» [En línea]. Available: playerstage.sourceforge.net. [Último acceso: 2 6 2019].

[14] Yarp, «Yarp,» [En línea]. Available: https://www.yarp.it/. [Último acceso: 2 6 2019].

[15] Orocos, « Orocos,» [En línea]. Available: https://orocos.org/. [Último acceso: 2 6 2019].

[16] CARMEN- Team, «Carmen Robot Navigation Toolkit,» [En línea]. Available: http://carmen.sourceforge.net/. [Último acceso: 2 6 2019].

[17] Orca Robotics, «Orca,» [En línea]. Available: http://orca-robotics.sourceforge.net/. [Último acceso: 2 6 2019].

[18] Modular Robotics Incorporated, «Modular Robotics,» [En línea]. Available: https://www.modrobotics.com/moss/. [Último acceso: 2 6 2019].

[19] Microsoft Corporation, [En línea]. Available: https://social.technet.microsoft.com/wiki/contents/articles/12955.microsoft-robotics-developer-studio-tutorial-en-espanol.aspx. [Último acceso: 2 6 2019].

[20] Bambino, «Una Introducción a los Robots Móviles,» 2008. [En línea]. Available: http://www.aadeca.org/pdf/CP_monografias/monografia_robot_movil.pdf. [Último acceso: 2 6 2019].

[21] G. Bermudez, «Modelamiento cinemático y odómetrico de robots Móviles,» 2003. [En línea]. Available: http://revistas.udistrital.edu.co/ojs/index.php/Tecnura/article/view/6131. [Último acceso: 2 6 2019].

[22] B. &. A. J. Carrasco, «ntegración de un UAV (vehículo aéreo no tripulado) en la plataforma robótica ARGOS,» 2015. [En línea]. Available: https://repositorio.uam.es/handle/10486/665076. [Último acceso: 2 6 2019].

[23] S. D. P. &. H. K. Hart, «The affordance template ROS package for robot task programming,» 5 2015. [En línea]. Available: https://ieeexplore.ieee.org/abstract/document/7140073/. [Último acceso: 2 6 2019].

[24] ROS wiki, «ROS.org,» [En línea]. Available: http://wiki.ros.org/ROS/Concepts. [Último acceso: 2 6 2019].

[25] S. G. Tzafestas, «Introduction to Mobile Robot Control,» de Introduction to Mobile Robot Control, Athens, Elsevier Inc., 2014, pp. 145-191.