INGENIERIA EN TECNOLOGIAS DE MANUFACTURA

Materia: Mecatrónica.

Nombre del Maestro(a): Julio Alejandro Valdez González.

“BubbleRob en V-REP”

Nombre del alumno: Jesus Alberto Peñaloza Sánchez.

Grupo: 9AM

Mexicali, Baja california 21 de Agosto del 2019.

Índice
Introducción .................................................................................................................................. 3
Marco teórico ................................................................................................................................ 4
Materiales ..................................................................................................................................... 6
Desarrollo ...................................................................................................................................... 6
Conclusión ................................................................................................................................... 27
Referencias.................................................................................................................................. 28
Introducción
En este reporte de practica final de cuatrimestre se mostrara el procedimiento para la
creación o elaboración del robot BubbleRob en el software Vrep el cual funcionara para
detectar mediante un sensor de visión objetos, personas, o automóviles a una determinada
distancia o el rango que el sensor de visión puede alcanzar.
Además se mostrara generalmente información que ayudara a conocer un poco más acerca
del software Vrep.
Marco teórico
V-REP
Un simulador es esencial para la prueba de cualquier sistema robótico ya que se evita que
éste se dañe. También es muy útil para la enseñanza ya que no se precisa del robot
físicamente. La mayoría de software que se encuentran en el mercado está diseñados para
los robots de la propia empresa que desarrollaron este software y en raras ocasiones es
gratuito. Por este motivo recurrimos a V-REP®.
Este software de la empresa Coppelia Robotics es un simulador: libre, gratuito, que permite
diferentes modos de simulación y trae unos algoritmos a primera vista bastantes atractivos
para el cálculo de elementos esenciales en cualquier robot como son la cinemática inversa
y la detección de colisiones. El entorno gráfico te permite diseñar tu propio robot con los
elementos que te aporta o importar tu propio diseño desde cualquier entorno gráfico.

Sencillo de manejar
El desarrollador te proporciona un extensor manual en formato digital en el que vienen
detallados los temas necesarios para familiarizarse con el entorno. Hay ciertas temas que
no vienen explicados con la profundidad que se merece, pero que serán desarrollados en
este documento. Al ser una aplicación en alza, tiene una comunidad bastante grande detrás
en la que vienen resueltos la mayoría de problemas con los que te puedes encontrar.
Además, la propia empresa te responde en un periodo muy corto de respuesta. Desde mi
punto de vista cuesta hacerse con el entorno, principalmente a la hora de construir tu
propio robot.
Limitaciones
Es un simulador muy interesante, pero hay ciertos elementos que en primera instancia no
sabes muy bien qué estás modificando. El lenguaje de programación, LUA, es un lenguaje
de muy alto nivel con funciones prediseñadas con el que a veces te sientes atado de manos.
Otra limitación presente es que los algoritmos cálculo del jacobiano (Pseudoinversa y DLS)
están herméticamente cerrados y no puedes modificar nada.
Nuestro estudio en esta aplicación comenzará con un robot muy simple como es un robot
de dos grados de libertad que sólo se mueve en el plano XY para hacernos con el entorno.

Debido a la limitaciones que encontraremos y para entender mejor las estructuras de

control que esta aplicación implementa, buscaremos un conexión API con MATLAB® donde
V-REP® es el servidor y MATLAB® el cliente.
Materiales
Se utilizó el programa V-REP para la realización del robot BubbleRob así como la simulación.

Desarrollo
A continuación se mostrara el procedimiento para la creación del robot BubbleRob el cual
en este caso servirá para detectar objetos dentro del rango del sensor de visión.
Primero se debe agregar una forma primitiva desde el menú de un diámetro en X de 0.2:

Ahora se debe se debe habilitar las opciones habilitamos enable, collidable, measurable,
renderable y detectable en las propiedades comunes del objeto para esa forma, si aún no
está habilitada. Todo esto seleccionando la esfera y presionando la lupa de la parte superior
izquierda y seleccionando las opciones correspondientes dentro de common.
Ahora abrimos el diálogo de posición en la pestaña de traducción, seleccionamos la esfera
que representa el cuerpo de BubbleRob e ingresamos 0.02 para Along Z. Nos aseguramos
de que el elemento relativo esté configurado en World. Luego hacemos clic en Traducir
selección. Esto traduce todos los objetos seleccionados en 2 cm a lo largo del eje Z absoluto,
y efectivamente levantó un poco nuestra esfera. En la jerarquía de escenas, hacemos doble
clic en el nombre de la esfera, para poder editar su nombre. Entramos en bubbleRob y
presionamos enter.

A continuación, agregaremos un sensor de proximidad para que BubbleRob sepa cuándo se acerca
a los obstáculos: seleccionamos [Barra de menú -> Add --> Proximity sensor --> Cone type]. En el
diálogo de orientación en la pestaña de orientación, ingresamos 90 para Around de Y y Around de
Z, luego hacemos clic en Rotate selection.
En el diálogo de posición, en la pestaña de posición, ingresamos 0.1 para X-coord. Y 0.12
para Z-coord. El sensor de proximidad ahora está colocado correctamente en relación con
el cuerpo de BubbleRob.

Hacemos doble clic en el icono del sensor de proximidad en la jerarquía de la escena para
abrir su diálogo de propiedades. Hacemos clic en Show volumen parameters para abrir el
diálogo de volumen del sensor de proximidad. Ajustamos los elementos Offset a 0.005,
Angle a 30 y Range a 0.15.

Luego, en las propiedades del sensor de proximidad, hacemos clic en Mostrar parámetros
de detección. Esto abre el diálogo del parámetro de detección del sensor de proximidad.
Desmarcamos el elemento No permitir detecciones si la distancia es menor que la de cerrar
ese diálogo nuevamente. En la jerarquía de escenas, hacemos doble clic en el nombre del
sensor de proximidad, para poder editar su nombre. Ingresamos bubbleRob_sensor y
presionamos enter.

Seleccionamos bubbleRob_sensor, luego tecla Ctrl y seleccionamos bubbleRob, luego

hacemos clic en [Barra de menú -> Edit -> Make last selected object parent]. Esto une el
sensor al cuerpo del robot.
A continuación nos ocuparemos de las ruedas de BubbleRob. Creamos una nueva escena
con [Barra de menú -> File -> New Scene]. A menudo es muy conveniente trabajar en varias
escenas para visualizar y trabajar solo en elementos específicos. Agregamos un cilindro
primitivo puro con dimensiones (0.08, 0.08, 0.02).

En cuanto al cuerpo de BubbleRob, habilitamos Collidable, Measurable, Renderable y

Detectable en las propiedades comunes del objeto para ese cilindro, si aún no está
habilitado.
Luego establecemos la posición absoluta del cilindro en (0.05, 0.1, 0.04) y su orientación
absoluta en (-90, 0,0). Cambiamos el nombre a bubbleRob_leftWheel. Copiamos y pegamos
la rueda, y establecemos la coordenada Y absoluta de la copia en -0.1. Cambiamos el
nombre de la copia a bubbleRob_rightWheel.
Seleccionamos las dos ruedas, las copiamos, luego volvemos a la escena 1, luego pegamos
las ruedas.

Ahora necesitamos agregar juntas (o motores) para las ruedas. Hacemos clic en [Barra de
menú -> Add -> Joint -> Revolute] para agregar una junta giratoria a la escena. La mayoría
de las veces, al agregar un nuevo objeto a la escena, el objeto aparecerá en el origen del
mundo. Mantenemos la junta seleccionada, luego control-select bubbleRob_leftWheel.
En el cuadro de diálogo de posición, en la pestaña de posición, hacemos clic en el botón
Aplicate a selection: esto coloca la junta en el centro de la rueda izquierda.
Luego, en el diálogo de orientación, en la pestaña de orientación, hacemos lo mismo:
orientamos la unión de la misma manera que la rueda izquierda. Cambiamos el nombre de
la articulación a bubbleRob_leftMotor.
Ahora hacemos doble clic en el icono de la unión en la jerarquía de la escena para abrir el
diálogo de propiedades de la unión. Luego, hacemos clic en Mostrar parámetros dinámicos
para abrir el cuadro de diálogo de propiedades de dinámica conjunta. Activamos el motor
y verificamos el elemento Bloquear motor cuando la velocidad objetivo es cero.

Ahora repetimos el mismo procedimiento para el motor derecho y le cambiamos el nombre

a bubbleRob_rightMotor. Ahora conectamos la rueda izquierda al motor izquierdo, la rueda
derecha al motor derecho, luego conectamos los dos motores a bubbleRob.
Entonces se juntan los dos motores con el BubbleRob en la barra de menú,Edit, Make last
selected object parent para cuando se haga la simulación este no se desarme:

Ahora agregamos un pequeño control deslizante (o rueda). En una nueva escena,

agregamos una esfera primitiva pura con un diámetro de 0.05 y hacemos que la esfera sea
Colisionable, Medible, Renderable y Detectable (si aún no está habilitada), luego
renómbrela como bubbleRob_slider.

Establecemos el Material en noFrictionMaterial en las propiedades de dinámica de forma.

Para vincular rígidamente el control deslizante con el resto del robot, agregamos un objeto
sensor de fuerza con [Barra de menú -> Agregar -> Sensor de fuerza]. Le cambiamos el
nombre a bubbleRob_Sensor y lo cambiamos a 0.05.

Adjuntamos el control deslizante al sensor de fuerza, luego copiamos ambos objetos,

volvemos a la escena 1 y los pegamos en este caso le cambie el color a BubbleRob.
Luego cambiamos el sensor de fuerza en -0.07 a lo largo del eje X absoluto, luego lo
conectamos al cuerpo del robot.
Para evitar efectos extraños durante la simulación de dinámica, tenemos que informar a V-
REP que ambos objetos no chocan entre sí, y lo hacemos de la siguiente manera: en las
propiedades de dinámica de forma, para bubbleRob_slider establecemos la máscara local
responsable en 00001111, y para bubbleRob, establecemos la máscara local responsable en
11110000.
Seleccionamos las dos ruedas y el control deslizante, y en el cuadro de diálogo de dinámica
de forma hacemos clic tres veces M = M * 2 (para la selección). El efecto es que todas las
formas seleccionadas tendrán sus masas multiplicadas por 8. Hacemos lo mismo con las
inercias de las 3 formas seleccionadas.
Mientras tanto, se requiere definir una colección de objetos que representen BubbleRob.
Para eso definimos un objeto de colección. Hacemos clic en [Barra de menú -> tools ->
Colection] para abrir el cuadro de diálogo de la colección. En el cuadro de diálogo de la
colección, hacemos clic en Agregar nueva colección. Un nuevo objeto de colección aparece
en la lista justo debajo. Por ahora, la colección recién agregada aún está vacía (no definida).
Mientras el nuevo elemento de la colección está seleccionado en la lista, seleccione
bubbleRob en la jerarquía de la escena y luego haga clic en Agregar en el cuadro de diálogo
de la colección. Nuestra colección ahora se define como que contiene todos los objetos del
árbol de jerarquía comenzando en el objeto bubbleRob (la composición de la colección se
muestra en la sección Elementos y atributos de composición). Para editar el nombre de la
colección, hacemos doble clic en él y le cambiamos el nombre a bubbleRob_collection.

Ahora se requiere poder rastrear la distancia mínima entre BubbleRob y cualquier otro
objeto. Para eso, abrimos el diálogo de distancia con [Barra de menú -> Herramientas ->
Propiedades del módulo de cálculo]. En el diálogo de distancia, hacemos clic en Agregar
nuevo objeto de distancia y seleccionamos un par de distancia: [colección]
bubbleRob_collection - todos los demás objetos medibles en la escena. Esto acaba de
agregar un objeto de distancia que medirá la distancia más pequeña entre la colección
bubbleRob_collection (es decir, cualquier objeto medible en esa colección) y cualquier otro
objeto medible en la escena. Cambiamos el nombre del objeto de distancia a
bubbleRob_distance con un doble clic en su nombre. Cerramos el diálogo de distancia.
A continuación, agregaremos un sensor de visión, en la misma posición y orientación que el
sensor de proximidad de BubbleRob. Abrimos la jerarquía del modelo nuevamente, luego
hacemos clic en [Barra de menú -> Add -> Vision Sensor -> perspective type].

Luego conectamos el sensor de visión al sensor de proximidad:

Para personalizar el sensor de visión, abrimos su diálogo de propiedades. Establecemos el
elemento Plano de recorte lejano en 1 y 5, y los elementos Resolución xy Resolución y en
256 y 256.

Luego abrimos el cuadro de diálogo del filtro del sensor de visión haciendo clic en Mostrar
cuadro de diálogo de filtro. Seleccionamos el componente Edge detection on work image y
hacemos clic en Agregar filtro. Colocamos el filtro recién agregado en la segunda posición
(una posición hacia arriba, usando el botón hacia arriba).
Hacemos doble clic en el componente de filtro recién agregado y ajustamos su elemento
Umbral a 0.2, luego hacemos clic en Aceptar.

Agregamos una vista flotante a la escena, y sobre la vista flotante recién agregada (nos
aseguramos de que el sensor de visión esté seleccionado durante ese proceso).
A continuación agregamos velocidad de 50 al BobbleRob_LeftMotor seleccionando con dos
click el icono y seleccionando “Show dynamic properties dialog” y habilitamos Motor
enabled y lock motor when target velocity is zero. La velocidad es agregada en Target
velocity (deg/s).
Finalmente se colocaron objetos y personas en la simulación para que BubbleRob los
detectara con el sensor de visión todo esto dentro del rango del sensor (Distancia).
En la simulación se muestra que el sensor detecta los efectos mientras BubbleRob hace
movimientos circulares a 360 grados debido a la velocidad colocada en uno de los motores
de las llantas.
Conclusión
Esta práctica final fue muy interesante y complicada, ya que en lo personal no tenía mucho
conocimiento o habilidad acerca del programa, por lo que me di a la tarea de investigar del
software y cada uno de los comandos y controles para realizar una simulación. Para poder
realizar este robot tuve que observar ejemplos y videos de otras personas realizando
simulaciones donde además observe que se puede hacer una simulación más sencilla por
ejemplo un carrito moviéndose hasta algo más complejo como un robot detectando objetos
en una banda transportadora y acomodándolos en una mesa por color del objeto. Pero es
algo más sofisticado ya que se necesita interfaces con programas como Matlab para realizar
los códigos.
Es muy importante recalcar que la simulación hoy en día y en futuro será primordial para
poder correr algún proceso de producción o una máquina y observar cómo se comportaría,
si sería fiable o eficiente llevarlo a cabo en la vida real. He ahí la gran ventaja de este tipo
de programas que te permite observar cada comportamiento de cualquier maquina o
simulación que se quiere llevar a cabo.
Referencias

Fernandez, J. d. (2017). Exploración del software de simulación V-REP. Obtenido de Dep. de

Ingeniería de Sistemas y Automática, Escuela Tecnica Superior de ingenieria Universidad
de Sevilla:
http://bibing.us.es/proyectos/abreproy/91177/fichero/TFG_Resumen_JESUS_DE_MIGUEL
_FERNANDEZ.pdf