¶ Bitacora de proyecto electrico I-2025
¶ Sesión lunes 17 de marzo [1pm-3:30pm]
-
Objetivo a trabajar: Confirmar funcionamiento del brazo robotico Panda.
-
Actividades realizadas:
- Intento de compilación de programa para visualizar el brazo robotico en tiempo real a la hora de intentar iniciar el launch file se obtiene la advertencia de que la liberia Franka instalada en ese momento es incompatible.
Aun asi se logra iniciar el programa Rviz para visualizar el robot en tiempo real, donde se observa el siguiente resultado:
Por el momento se plantea la posible solución de desinstalar la versión que se tenga de la libreria Franka en la máquina e instalar otra.
-
Resultados obtenidos:
- Confirmación de la no funcionalidad de comunicación entre computadora y el robot real para el usuario en el cual se desea manipular este.
- Obtención de posible falla del porque este no funcione.
¶ Sesión martes 18 de marzo [1pm-3:30pm]
-
Objetivo a trabajar: Confirmar funcionamiento del brazo robotico Panda.
-
Actividades realizadas:
- Se probó otro intento de solucionar el problema observado con el programa Rviz para visualizar el robot a tiempo real y el porque no se observan los meshes del robot en este, en el launch file de este programa se agregó un nodo el cual llama a los meshes en este de la siguiente forma:
Lamentablemente este intento de solución no logro corregir el error que se presenta como se observa en la siguiente figura:
- Por otra parte se intentó instalar la libreria más actual de Franka la cual es 0.15.0, en la instalación de esta se encontraron problemas por la dependencia "pinoccio", esto se logró solucionar por medio de los siguientes comandos obtenidos del repositorio oficial de la libreria Franka:
A pesar de instalar esta versión igualmente se obtuvó el mismo problema de compatibilidad con la libreria franka que se presentó en la sesión pasada. Por lo cual para la siguiente se va a optar por instalar una versión más antigua de este.
-
Resultados obtenidos:
- Se confirmó que el error presentado por el programa Rviz para observar los cambios del robot en tiempo real viene de la incompatibilidad de la libreria Franka.
- Se obtuvó que las versiones nuevas de esta libreria no funcionan para comunicarse con el robot real.
¶ Sesión lunes 24 de marzo [1pm-3:30pm]
-
Objetivo a trabajar: Confirmar funcionamiento del brazo robotico Panda.
-
Actividades realizadas:
- Compilacion e instalacion de la libreria Franka para comunicacion con el brazo robotico en su version 0.8.0, ya que esta ha demostrado que funciona correctamente con este
- A la hora de iniciar el launch file para abrir el Rviz que nos permite observar los cambios en el robot en tiempo real, se encontro un error, ya que este no encontro las librerias
Afortunadamente al eliminar las carpetas, install, build y log se logró resolver este error y permitió abrir el programa requerido, como se puede observar el la siguiente figura:
El brazo robotico se observo de esta forma debido a que aun no sea ha inicializado correctamente este, para inicializarlo se tuvo que agregar el usuario en el que actualmente se estaba trabajando, al grupo de usuarios que pueden usar el kernel de tiempo real, esto se realizó por medio de los siguientes comandos:
- Compilacion e instalacion de la libreria Franka para comunicacion con el brazo robotico en su version 0.8.0, ya que esta ha demostrado que funciona correctamente con este
sudo addgroup realtime
sudo usermod -a -G realtime $(whoami)
-
Ya con esto, y al utilizar el comando que activa cada uno de los joints, inicializamos correctamente el braoz robotico, donde el rviz que utilizamos para visualizarlo se presenta de la siguiente forma:
-
Resultados obtenidos:
- Compilacion e instalacion correcta de libreria Franka.
- Correcta apertura del programa Rviz para visualizar los cambios en tiempo real del brazo robotico Panda.
- Inicializacion correcta del brazo robotico panda para visualizar cambios en tiempo real por medio de Rviz.
¶ Sesión martes 25 de marzo [1pm-3:30pm]
-
Objetivo a trabajar: Confirmar funcionamiento de brazo robotico Panda.
-
Actividades realizadas:
- Correcion de launch files en iniciar programa de prueba en el brazo robotico Panda.
Se observó que a la hora de utilizar el comando que activa el programa de prueba abre una ventana de Rviz que no deberia aparecer
Esto se debió a que se realizo un cambio en el launch file, que permitía ejecutarse el el nodo de Rviz que anteriormente se encontraba deshabilitado.
Cuando se revirtio este launch file, se volvió a ejecutar este mismo y se logro corregir este error:
- Al iniciar el launch file del programa de prueba se observa que este no reconoce el servicio del gripper, esto debe a que este es llamado por el servicio llamado Panda_driver_topics y no por Impedance_control_msgs, este ultimo servicio es llamado cuando se utiliza el emulador del brazo robotico panda, se descubrio este fallo al utilizar el programa de debuggeo rqt, donde se observa que el servicio es diferente al que viene en el launch file del programa de prueba
Al restaurar este archivo a una version anterior donde es llamado por el servicio correspondiente se logró ejecutar el programa, pero no como se esperaria, ya que el robot se mueve muy erraticamente.
- Correcion de launch files en iniciar programa de prueba en el brazo robotico Panda.
-
Resultados obtenidos:
- Solucion a apertura de un segundo Rviz que no deberia aparecer.
- Correcto llamado al gripper del brazo robotico Panda por medio de asignar su correcto servicio.
¶ Sesión miércoles 26 de marzo [9am-11:30am]
-
Objetivos a trabajar: Depuracion de simulador de brazo robótico.
-
Actividades realizadas:
- Al analizar el driver por el cual se comunica el brazo robotico y comparando con el simulador, y el programa a ejecutar en este, se encontró que el driver cuando se abre el gripper asume los valores de epsilon_inner y epsilon_outer, y el simulador al no ser ingresados, este asume un valor de 0, lo cual generaba el error de overshoot visto anteriormente, para ello se agregaron los valores de estas variables al simulador, cuando se esta abriendo el gripper.
Ya a la hora de abrir el simulador no se observa en el log de este que ya se presente el error de overshoot
Pero a la hora de ejecutar el programa de prueba en el simulador se observa que el brazo tiene un movimiento inusual, parecido al que se observo en el robot real, el cual es de la siguiente forma:
Esto puede apuntar a un error en el programa de prueba que se esta utilizando para asegurar el correcto funcionamiento del simulador y del robot real.
- Al analizar el driver por el cual se comunica el brazo robotico y comparando con el simulador, y el programa a ejecutar en este, se encontró que el driver cuando se abre el gripper asume los valores de epsilon_inner y epsilon_outer, y el simulador al no ser ingresados, este asume un valor de 0, lo cual generaba el error de overshoot visto anteriormente, para ello se agregaron los valores de estas variables al simulador, cuando se esta abriendo el gripper.
-
Resultados obtenidos:
- Implementación de solucion para el problema de overshoot en el simulador del brazo robótico.
¶ Sesión lunes 31 de marzo [1pm-3:30pm]
-
Objetivo a trabajar: Confirmar funcionamiento de brazo robotico Panda.
-
Actividades realizadas:
- Pruebas de funcionamiento en el robot real para observar de donde proviene el movimiento erratico observado en sesiones pasadas, como en el simulador, donde se encontró el siguiente error en el paquete RBC del robot:
Se obtiene un error en el Vector Field del programa "ct_experience_asimilar", donde lamentablente en esta sesión no se logró obtener una solución a como resolverlo apropiadamente, por lo cual se propone investigar aún más en la siguiente sesión sobre este error.
-
Resultados obtenidos:
-Obtención de posible fallo que generé el movimiento erratico tanto para el simulador como para el robot real.
¶ Sesión martes 1 de abril [1pm-3:30pm]
-
Objetivos a trabajar: Confirmar funcionamiento de brazo robotico Panda, depuracion de simulador de brazo robotico.
-
Actividades realizadas:
- Se hizo un git pull al repositorio del Robot Body Coupler, ya que anteriormente se habia hecho uno al branch en el cual no se encontraba la actualizacion que resolvia el problema
- Al realizar el cambio con este paquete actualizado se logra ejecutar el programa
- En cierta parte del programa simulado se genero otro problema de overshoot por lo cual se aumento la tolerancia del simulador cuando se realiza el movimiento de "ungrasp" de 0.005 a 0.02
- Ya con este aumento en la tolerancia del gripper del robot simulado se logra ejecutar el programa completo sin ningun problema
- Para resolver el problema de incompatibildad de servicios entre el gripper y el robot real se opto por manipular el driver del robot real para que este llamara al mismo servicio que se usa en el simulador:
- Junto con la actualizacion del repositorio del Robot Body Coupler y la manipulacion del driver del robot real se ejecuta el programa sin problemas en este ultimo
- Se observo que al utilizar un bloque con otra etiqueta si lo detecta, pero no convierte su transformada a la de un bloque, por lo cual el programa no funciona con otras etiquetas
Una posible solucion planteada a este problema es modificar el programa para que detecte otros tipos de marcadores.
- Se hizo un git pull al repositorio del Robot Body Coupler, ya que anteriormente se habia hecho uno al branch en el cual no se encontraba la actualizacion que resolvia el problema
-
Resultados obtenidos:
- Depuracion parcialmente completa del simulador en C++, ya que logra ejecutar el programa de prueba sin ningun problema encontrado
- En el simulador se observa que el gripper se encuentra oscilando apenas este abre por primera vez y lo sigue haciendo cuando agarra un objeto, pero esto no supone un problema mas alla de lo estetico ya que el programa de prueba como se menciona anteriormente funciona correctamente.
- Ejecucion parcialmente correcta del programa con el robot real, ya que dependiendo de la posicion o la etiqueta que se utiliza puede que no funcione el programa.
¶ Sesión lunes 7 de abril [1pm-3:30pm]
-
Objetivos a trabajar: Confirmar funcionamiento de brazo robotico Panda
-
Actividades realizadas:
- En algunas situaciones el brazo robotico tiende a no agarrar el bloque, para buscar la razón del porque se tiene este problema se implementó un nuevo comando al programa el cual en vez de ir a la posición del bloque directamente, ira antes a una posición por encima de este.
Como se puede observar se agrega a la transformada z del bloque 20cm por encima de este, donde al simularlo se tiene el siguiente resultado:
Se tiene que el nuevo comando fue implementado de forma exitosa en la simulación, al implementarlo en el robot real se produce el siguiente resultado:
Al implementar este comando se obtuvo como resultado que el problema por el cual en ocasiones el robot no lográ en ocasiones agarrar el bloque es por su posición, después de ciertas pruebas se tiene el siguiente diagrama por el cual dependiendo de la posición del "marker" del bloque este puede ser obtenido exitosamente por el bloque o no:
Si se tiene el "marker" del bloque dentro de la zona verde el robot muy posiblemente logre obtener el bloque, mientras tanto en la zona roja no, debido a que el robot tratara de rotar 270° para obtenerlo y este no tiene la suficiente velocidad para lograr este movimiento antes de realizar el siguiente comando.- Ya con lo anterior realizado se realizaron pruebas con el robot real y se obtuvó una obtención correcta del bloque por parte del robot
-
Resultados obtenidos:
- Implementación de un nuevo comando para que el robot se encuentre encima del bloque que se desea obtener.
- Se encontró la razón del porque dependiendo de la posición del bloque este no es obtenido por el robot, ya que este en ocaciones no logra rotar la garra lo suficientemente rápido para conseguir estar alineado con el "marker".
¶ Sesión martes 8 de abril [1pm-3:30pm]
-
Objetivos a trabajar: Confirmar funcionamiento de brazo robotico Panda
-
Actividades realizadas:
- El programa que se tiene actualmente en el robot solo obtiene el bloque, lo lleva a una posición y lo deja caer, se desea agregar un comando para mover a cierta coordenada y soltar el bloque en vez de dejarlo caer cierta altura, para ello se obtuvó una coordenada en la cual la cámara del robot no detecte el "marker" del bloque que ya colocó para evitar que vuelva a obtener este mismo en vez de otro nuevo.
- Primero se investigó como funciona el movimiento del brazó robotico dentro del programa ya hecho, donde se realiza por medio del comando "v" dentro de este vienen las coordenadas cartesianas a las cuales se desea mover el robot con respecto al odometrico del robot (esto no necesariamente indica el centro del robot o que el Z=0.0 sea la altura de la mesa) y su cuaternión de rotación, por lo cual se implementarón las siguientes coordenadas:
Al ingresar estas coordenadas se tiene que el brazo robotico se movio a la siguiente posición observada:
Al realizar este movimento se pudo observar como esta definido el sistema de coordenadas del robot, donde si se observa a este de frente, se tiene que:
1. Para moverlo para adelante y atras se debe manipular la coordenada Y
2. Para moverlo de izquierda y derecha se debe manipular la coordenada X
3. Para moverlo arriba y abajo se debe manipular la coordenada Z - Ya con el sistema de coordenadas definido se toma una posición donde la camara del robot no logre detectar el "marker" del bloque que ya colocó anteriormente cuando este regrese a su posición natural, para ello se eligió la siguiente posición:
La posición mostrada anteriormente no detecta el bloque cuando el robot se encuentra en su posición natural, por lo cual se procede a programar esas coordenadas en el simulador de la siguiente forma:
Al simular estas coordenadas se tiene el siguiente resultado:
Como se puede apreciar estas coordenadas son bastante similares a las que se eligieron para colocar el robot real, donde al ingresarlas se obtuvó el siguiente resultado:
El robot logra de forma exitosa moverse a esa posición y cuando este vuelve a su posición natural se tiene que este no observa al bloque colocado anteriormente:
Ya con esto se tienen ls siguientes comandos para el programa de prueba:
Este programa tiene los siguientes comandos:
- Abre la garra del robot.
- Se dirige a su posición natural.
- Se posiciona encima del bloque.
- Se dirige a la posición exacta del bloque.
- Toma el bloque.
- Se dirige a la posición natural.
- Se posiciona en las coordenadas anteriormente determinadas.
- Suelta el bloque.
Durante las pruebas de este programa, se pudó observar que en ciertas ocaciones la garra del robot obtiene dos bloques en vez de solo uno, por lo cual se ajusto las coordenadas del comando que va a la posición exacta del bloque por unos cuantos milimetros:
Ya con este ajuste la garra del robot, solo logra obtener un bloque en vez de dos, por otra parte las coordenadas anteriores dejan caer el bloque desde una altura considerable, por lo cual se ajusto la coordenada Z de la posición determinada anteriormente:
-
Resultados obtenidos:
- Correcta manipulación del brazo robotico al igual que un mejor entendimiento de como funcionan los comandos dentro de este.
- Se logró entender de mejor manera el sistema de coordenadas que se tiene en el brazo robotico.
¶ Sesión miercoles 9 de abril [9am-11:30am]
-
Objetivos a trabajar: Confirmar funcionamiento de brazo robotico panda.
-
Actividades realizadas:
- Para esta sesión se buscó un mejor entendimiento del sistema de rotación que posee el brazo robotico Panda, ya que este lo realiza por medio de cuaterniones, se propusó como practica rotar el brazo 180° en el eje Z, para ello se simularon algunos comandos de prueba como el que se presenta en la siguiente figura:
En la anterior figura, el comando marcado se incremento la coordenada k del cuaternion en 1, donde al simularlo se obtuvó el siguiente resultado:
La anterior simulación indica que al modificar esta coordenada, el brazo robotico rota en el eje Y en sentido horario, lo cual no es un resultado esperado. Por otra parte se opto por modificar la coordenada J en -1 como se puede observar en la siguiente figura:
Esta modificación genero la siguiente respuesta en la simulación:
Se obtuvó que al realizar esta modificación el brazo rota en el eje X, con sentido antihorario, esto deja entender que para rotar en el eje Z, se debe hacer por medio de modificar la coordenada I del cuaternion, para ello se realizó la respectiva simulación modificando el eje I como se muestra en la siguiente figura:
Al simular este comando se obtiene la siguiente respuesta:
Al realizar esta modificación se logró exitosamente rotar el bloque en el eje Z como se esperaba, aunque esto genera que al robot no le tiempo de rotar completamente los 180° que se desean, por eso se implemento un comando antes de este para asegurar la rotación deseada.
Ya con este comando se obtiene la rotación requerida en el brazo robotico.- Con las pruebas de rotación realizadas anteriormente ahora se implementa en el robot real un nuevo comando que en conjunto con el realizado en la sesión pasada coloca un nuevo bloque encima del anterior, solo que rotado 180° en el eje Z. Para ello se tiene la siguiente implementación del comando en el robot real:
Al implementar estos comando se obtiene que el robot realiza la rotación en el eje Z de manera adecuada, pero se obtuvó el mismo problema que en la sesión pasada de que la altura en la cual se suelta el bloque es demasiado alta:
Para solucionar este error se modifica la altura a la cual se deja soltar el bloque para evitar que este caiga desde una altura considerable:
Ya con esta altura el robot suelta el bloque a una altura cercana al del primer bloque, como se muestra en la siguiente figura:
- Para esta sesión se buscó un mejor entendimiento del sistema de rotación que posee el brazo robotico Panda, ya que este lo realiza por medio de cuaterniones, se propusó como practica rotar el brazo 180° en el eje Z, para ello se simularon algunos comandos de prueba como el que se presenta en la siguiente figura:
-
Resultados obtenidos:
- Mejor entendimiento del funcionamiento de la rotación del brazo robotico.
- Implementación de un programa simple en el robot que apila un bloque encima de otro.
¶ Sesión lunes 21 de abril [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Se descargó el programa que indica las posiciones al brazo robotico sobre donde debe colocar las piezas de jenga para construir una estructura cuadrada, una vez se descargo el programa este fue compilado de manera exitosa como se muestra en la siguiente figura:
- Una vez compilado exitosamente el programa, se comprueba el funcionamiento que este tiene hasta el momento. La ultima actualización que tiene el programa es generar un archivo csv que indica donde se deben colocar los bloques, la generación de este archivo se observa de la siguiente forma:
Como se puede observar se genera el archivo csv con las coordenadas en las cuales se deben colocar los bloques jenga para construir la estructura cuadrada.
- Se descargó el programa que indica las posiciones al brazo robotico sobre donde debe colocar las piezas de jenga para construir una estructura cuadrada, una vez se descargo el programa este fue compilado de manera exitosa como se muestra en la siguiente figura:
-
Resultados obtenidos:
- Comprobación de generación de coordenadas para construir la estructura cuadrada con bloques jenga.
- Se descubrió que este programa aun no es capaz de enviar estas coordenadas al robot, ya sea el simulado o el real, por lo cual para la siguiente sesión se abordará más en implementar esta caracteristica tan necesaria.
¶ Sesión miércoles 23 de abril [9:00am-11:30am]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Se tiene que el programa para construir la estructura con bloques Jenga esta conformado de la siguiente manera:
De la anterior figura se tiene que los archivos con terminación .py "task_sender_service", "task_client" y "jenga_house_builder" son los más importantes por el momento, ya que el primero es el que envía las posiciones del bloque del archivo csv, el segundo los recibe y el tercer archivo se encarga de indicar cuantos bloques faltan para terminar la estructura, que tantos por cual bloque el programa esta construyendo.
Estos programas fueron agregados como ejecutables en el archivo "setup.py" que se muestra en la figura anterior de la siguiente forma:
Al intentar ejecutar estos programas para el caso del archivo "task_client"
Este es un resultado esperado ya que el programa esta esperando al servicio que debería entregar las coordenadas de los bloques.Por otra parte al intentar ejecutar el programa "task_sender_service" se tiene el siguiente resultado:
Este resultado es fuera de lo comun ya que previamente se había agregado el ejecutable "jenga_house_builder" al archivo "setup.py" para que este fuera reconocido por los demás programas. - Se tiene que el programa para construir la estructura con bloques Jenga esta conformado de la siguiente manera:
-
Resultados obtenidos:
-Se obtuvó una parcial instalación de los programas dan el funcionamiento para construir la estructura con bloques jenga.
-No se pudó encontrar que generá el error a la hora de ejecutar el programa "task_sender_service", esto se abordará en la proxima sesión con más detenimiento.
¶ Sesión lunes 28 de abril [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
-Se descubrió que el error presentado en la sesión anterior de no encontrar los paquetes se puede resolver con el siguiente cambio que se presenta en la siguiente imagen
Donde se tiene el siguiente resultado:
Se lográ generar las posiciones de los bloques, pero no logra crear el archivo csv donde almaceran estos, como se puede apreciar en el error que se encuentra abajo de este para, intentar solucionar este problema se intentó agregar la carpeta donde se puede almacenar el archivo csv generado en el archivo setup.py el cual administra como el paquete es instalado en el espacio de trabajo:
Al realizar este cambio, se tiene el siguiente resultado:
Lamentablemente no se logró obtener un resultado positivo de este intento de solucionar el error para generar el csv con los comandos. -
Resultados obtenidos:
-Se obtuvó una parcial instalación de los programas que dan el funcionamiento para construir la estructura con bloques jenga.
-Se logró obtener una ejecución parcial del ejecutable "task_sender_service", pero no se logró generar el csv debido a que este programa no encuentra el directorio destino para hacerlo, esto se abordará en la proxima sesión con más detenimiento.
¶ Sesión martes 29 de abril [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Como originalmente estaba escrito el programa este utilizaba una dirección relativa para almacenar el archivo csv que genera, si este se ejecuta como un archivo de python no hay problema, pero al ser ejecutado utilizando los comandos de ros2, no encuentra la dirección para almacenar el csv, para ello se determino una dirección absoluta para indicarle al programa que cree el archivo csv en esa dirección:
Al intentar este procedimiento se obtiene el siguiente resultado:
Lamentablemente esta solución no funciono adecuadamente para generar el csv.
Se investigó otra solución utilizando el paquete de python "get_package_share_directory" este metodo busca la carpeta "share" dentro de la carpeta instalación del paquete, este metodo es bastante efectivo debido a portabilidad si se desea ejecutar en otros equipos, lo cual es el caso para cuando eventualmente se desee ejecutar el programa en el robot real, este metodo se implemento de la siguiente forma:
Este intento no se pudó concretar, debido a que a la hora de intentar ejecutar el programa este no logra encontrar el paquete necesario para realizar este metodo para crear el csv.
- Como originalmente estaba escrito el programa este utilizaba una dirección relativa para almacenar el archivo csv que genera, si este se ejecuta como un archivo de python no hay problema, pero al ser ejecutado utilizando los comandos de ros2, no encuentra la dirección para almacenar el csv, para ello se determino una dirección absoluta para indicarle al programa que cree el archivo csv en esa dirección:
-
Resultados obtenidos:
-Aun no se logró generar el csv debido a que este programa no encuentra el directorio destino para hacerlo, esto se abordará en la proxima sesión con más detenimiento.
¶ Sesión miércoles 23 de abril [9:00am-11:30am]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
-Se intento de nuevo el intento con el paquete de la sesión pasada en otra computadora, donde se observa de la siguiente forma:
El resultado obtenido fue el siguiente:
Como se puede apreciar se tiene una ejecución correcta del programa, ya que se generaron tanto el csv que contiene las posiciones para crear la estructura de jenga y los comandos a mandar al robot para realizarlos.
-Despues se intentó una comunicación entre este archivo y el "task_client", el cual se observa de la siguiente forma:
Como se puede apreciar se tiene una correcta comunicación entre el el servidor y cliente del nodo, ya que cuando el cliente le solicita al nodo el siguiente comando este lo envia. -
Resultados obtenidos:
-Se obtuvó una correcta ejecución de "task_sender_service" utilizando los comandos de ros2, al igual que la creación correcta de los archivos csv que indican las posiciones de los bloques jenga para la construcción de la estructura al igual que los comandos que se enviarán al robot en un futuro.
¶ Sesión lunes 5 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Se probaron los cambios realizados en la computadora conectada al brazo robotico Panda, para comprobar el funcionamiento del nodo reparado, donde se obtuvieron los siguientes resultados:
Se puede comprobar el funcionamiento del nodo en la computadora deseada, donde se el resultado de las pruebas fallidas que se realizaron con este nodo hayan sido debido a un posible error tipografico en el código. - Por otra parte uno de los objetivos del proyecto es que el usuario ingrese las variables de altura, largo y anchura que la casa de bloques jenga vaya a tener, para ello se implementa un nodo que obtenga estos datos del usuario, donde se tiene el siguiente código para el servidor:
Los nodos en ros2 requieren un archivo con terminación srv, estos sirven para almacenar los datos que se requieran en el nodo, para este caso se tiene la siguiente estructura:
Este debe ingresarse al archivo CMakeLists como una variable, sino el nodo no podra obtener datos, este se ingresa de la siguiente forma:
- Se probaron los cambios realizados en la computadora conectada al brazo robotico Panda, para comprobar el funcionamiento del nodo reparado, donde se obtuvieron los siguientes resultados:
-
Resultados obtenidos:
-Realización del servidor del nodo que permite la obtención del alto, largo y ancho de la esctructura de jenga por parte del usuario, para la siguiente sesión se realizará la escritura del cliente del nodo.
¶ Sesión martes 6 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Se escribió el cliente del nodo, este es el que se encarga de obtener las variables de altura, largo y ancho de la estructura de jenga a realizar por parte del usuario, este fue escritó de la siguiente forma:
A la hora de querer comprobar la comunicación entre el servidor y el cliente se generaron diversos problemas tales como:- Errores tipograficos.
- Mal manejo de errores.
- Variables no declaradas.
Estos errores fueron resueltos con la siguientes versiones del código ya arreglado, donde el de la siguiente figura pertenece al del cliente del servidor:
Y la siguiente figura representa al del servidor:
Con estos arreglos ya se realizó una prueba de comunicación entre el cliente y el servidor, donde se obtuvó el siguiente resultado:
- Se escribió el cliente del nodo, este es el que se encarga de obtener las variables de altura, largo y ancho de la estructura de jenga a realizar por parte del usuario, este fue escritó de la siguiente forma:
-
Resultados obtenidos:
-Realización del cliente del nodo que solicita altura, largo y ancho al usuario.
-Comprobación exitosa de comunicación entre el cliente y el servidor del nodo, para la proxima sesión se espera implementar completamente los datos obtenidos por este nodo al nodo task_sender_service.
¶ Sesión miércoles 7 de mayo [9:00am-11:30am]
-
Objetivos a trabajar: Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Para que el nodo task_sender_service obtenga los nuevos parametros de altura, largo y ancho de la estructura a construir, se debe crear otro servicio con la siguiente estructura:
Ya con este servicio nuevo, se agregan los siguientes cambios al nodo
Se ingresa al nodo de task_sender_service los cambios para poder procesar los nuevos datos obtenidos por el usuario:
A la hora de querer implementar estos cambios al nodo task_sender_service se encontro con un problema que impide aplicar esta estructura por el momento, esto es que a la hora de ejecutarlo, crea el csv con las posiciones para los bloques jenga con las dimensiones originales, sin esperar a que se el servicio anteriormente creado se ejecute para obtener las dimensiones del usuario.
- Para que el nodo task_sender_service obtenga los nuevos parametros de altura, largo y ancho de la estructura a construir, se debe crear otro servicio con la siguiente estructura:
-
Resultados obtenidos:
- Se completo la creación de un nodo que pida al usuario las dimensiones que se desean de la estructura jenga.
- Se descubrió que por el momento no se puede implementar este nodo, ya que esto equivaldría cambiar toda la lógica del programa que se tiene hasta el momento, así que por el momento este nodo no se implementará.
¶ Sesión Lunes 12 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar:Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Ya que se descubrió que no se puede implementar el nodo que pide al usuario los datos sobre la altura, largo y ancho de la estructura a construir, ahora se enfocó en realizar un nodo de ros2 que reciba un request de un cliente para leer el archivo csv.
Para ello se escribió el siguiente código de prueba tanto para el servidor:
Como para el cliente:
Este el cliente le manda una solicitud al servidor de leer el csv que contiene todas las posiciones que el robot debe ejecutar para construir la estructura con bloques jenga, al leerlo lo convierte en la siguiente estructura: ("comando",(valores)), ya que esta es la estructura con la cual el simulador y el robot real leen los comandos.Donde al compilar se obtuvó una lectura exitosa de los datos al igual que su conversión.
-
Resultados obtenidos:
- Se completó la creación de un nodo que lea el csv de las instrucciones que se deben mandar al robot y convertirlas en un formato en el cual este ultimo pueda leerlos.
- En el proceso de intentar compilar el programa se encontrarón diversos problemas con la compilación que normalmente se tratarón de errores tipograficos, por lo cual solucionarlos no represento mucho problema.
- Para la siguiente sesión se espera lograr implementar el cliente del nodo csv en el programa que ejecuta las instrucciones.
¶ Sesión Martes 13 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar:Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Este proceso fue en extremo complejo ya que el programa que ejecuta los comandos en el robot cuenta con una gran cantidad de otros clientes que ejecutan funciones vitales para que se puedan realizar las diversas acciones dentro del robot.
Primero se ingresó la definición del nuevo cliente, junto con una condición de verificar si el servidor de este nodo se encuentra activo:
Después se ingresarón dos nuevas definiciones a la clase del nodo, una donde se envié el request al servidor para leer el csv con el nombre fetch_csv_goals y otro que se encargue de leer el csv y procesar los datos llamado process_csv, los cuales fuerón escritos de la siguiente forma:
Seguido a esto colocó la siguiente condicional donde si el servicio del nodo csv se encuentra activo las nuevas intrucciones a leer serán las del csv y no las que vienen en el programa originalmente.
- Este proceso fue en extremo complejo ya que el programa que ejecuta los comandos en el robot cuenta con una gran cantidad de otros clientes que ejecutan funciones vitales para que se puedan realizar las diversas acciones dentro del robot.
-
Resultados obtenidos:
- Se implementó parcialmente el cliente del nodo csv en el programa que lee comandos y los envía al robot real, esto debido a que por cuestiones de tiempo no se logró probar si como mínimo el simulador del robot lograba leer los comandos.
- Para la proxima sesión se espera lograr realizar pruebas a estos cambios para comprobar si el simulador y por consiguiente el robot real logran leer estos datos.
¶ Sesión miércoles 14 de mayo [9:00am-11:30am]
-
Objetivos a trabajar:Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Se agrego una igualdad al programa debido a que las instrucciones en el csv tienen el movimiento cartesiano como el comando "cartesian_movement" en vez de "v" que es como lo lee el programa, por lo cual se realizó el siguiente cambio:
Ya con esto se determinarón los siguientes pasos para que el simulador se ejecute con los datos del csv:
- Se agrego una igualdad al programa debido a que las instrucciones en el csv tienen el movimiento cartesiano como el comando "cartesian_movement" en vez de "v" que es como lo lee el programa, por lo cual se realizó el siguiente cambio:
- Escribir el siguiente comando en la consola:
ros2 run rbc_house_builder task_sender_service
Este genera el csv con las instrucciones a enviar al robot
2. Ya una vez ejecutado ese comando se procede a hacer crtl+C y se escribe el siguiente comando:
ros2 run rbc_house_builder goals_service
Este activa el nodo de lectura csv.
3. Ejecutar los pasos para el simulador indicados en la página rbc_Asimilar
Al ejecutar los pasos anteriormente descritos se tiene que ya sea el programa para el robot real o el simulador debe indicar el siguiente aviso en la consola:
En caso de no aparecer el programa leerá los comandos que originalmente vienen en el, si esto sucede cerrar el programa que ejecuta los comandos y volverlo a iniciar, si es que se tiene el servidor del nodo csv activo.
Al ejecutarlo se observá que el simulador logra leer los nuevos comandos que son dados por el csv, como se puede apreciar en la siguiente imagen:
- Resultados obtenidos:
- Se implementó completamente el cliente del nodo csv para que el programa logré leer los nuevos comandos que se generan por el csv, donde se tiene hasta el momento que la simulación del robot solo lee los movimientos cartesianos.
- Por el momento no lee el comando de detección del bloque, al igual que los comandos para el gripper esto se espera implementar en la proxima sesión.
¶ Sesión Lunes 19 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar:Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- El programa que genera los comandos para ser leidos por el csv es llamado task_expander, este se encarga de leer las coordenadas de cada bloque y convertirlas en comandos.
Los comandos que este antes generaba no eran compatibles con lo que debería leer el programa real, para esto se realizaron algunos cambios.
Primero se cambio el como se mandan las coordenadas para realizar un movimiento cartesiano, donde las coordenadas de rotación estan en x,y,z en vez de cuaternion que esto es lo que lee el programa, por lo cual se realizó el siguiente cambio para pasar de angulo de rotación a coordenadas de cuaternion:
Esto toma el ángulo en radianes y lo transforma a coordenadas de cuaternion, donde como solo por el momento se rota en Z, las ecuaciones de transformación no fueron complicadas de obtener. - Por otra parte se tiene que el comando para posicionarse en la pila de bloques no esta del modo en el cual lo lee el programa final, por lo cual se le realizó el siguiente cambio:
Se colocarón las coordenadas en 0 debido a que esto no es necesario que lo genere este programa, ya que el programa final ya hace la detección de la pila de bloques, por otra parte la variable goal_type se igualo a 4, cuando se tiene este valor el robot va hacia la pila de bloques. - Se agregó una posición natural para el robot, esta posición ayuda al robot a detectar mejor los markers de los bloques, esto se realizó de la siguiente forma:
Donde las coordenadas cartesianas para el homing son las siguientes:
- El programa que genera los comandos para ser leidos por el csv es llamado task_expander, este se encarga de leer las coordenadas de cada bloque y convertirlas en comandos.
-
Resultados obtenidos:
- Resolución parcial de transformación de comandos antiguos a nuevos para que el robot los logre leer completamente, para la siguiente sesión se espera implementar todos los cambios para que el simulador logre leer todos los comandos.
¶ Sesión Martes 20 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar:Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Este programa anteriormente tenía sus valores de distancia en metros en ordenes mayores a 100, por lo cual la mayoría de estos datos fueron divididos en 1000 para pasarlos a milimetros, que es lo que normalmente lee el programa final.
Por otra parte también se agregarón los comandos para controlar el gripper, ya sea para abrirlo o cerrarlo.
Para abrir el gripper se tiene la siguiente función:
Donde las primeras dos variables indican que tanto deseo abrir el gripper y el segundo a que velocidad deseo hacerlo, donde el goal_type que es 3, indica que deseo abrir el gripper, esto en el csv de los comandos se verá reflejado por el comando "ungrasp".
Para cerrar el gripper y con esto tomar un bloque se tiene la siguiente función:
Las dos primeras variables cumplen la misma función que en la función anterior, solo que ahora para cerrar el gripper, donde también se añade la fuerza a la cual se quiere hacer y que tanto error desde el centro del gripper tanto dentro de este como fuera de este es aceptable para el gripper. - Ya con estos nuevos comandos ahora se comprueban en la simulación del programa final, donde se tiene que no solo lee exitosamente los comandos sino que también ya logra ejecutar estos, como se muestra en la siguiente figura:
- Este programa anteriormente tenía sus valores de distancia en metros en ordenes mayores a 100, por lo cual la mayoría de estos datos fueron divididos en 1000 para pasarlos a milimetros, que es lo que normalmente lee el programa final.
-
Resultados obtenidos:
- Se logró realizar la primera simulación del programa ya con los nuevos comandos generados por el csv, para la siguiente sesión se va a retocar los comandos generados en el csv para que tengan más coherencia para cuando se desee realizar esto en el robot real.
¶ Sesión miércoles 21 de mayo [9:00am-11:30am]
-
Objetivos a trabajar:Implementar en simulación el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Realizando pruebas a la simulación del programa se observó que el robot aunque entiende todas las instrucciones del csv, no ejecuta todas y en cierto punto este solo repite las mismas 5 instrucciones, esto fue debido a que anteriormente no se definió que el programa final leyera toda la longitud del csv con las nuevas coordenadas, sino que solo leyera la longitud de las instrucciones originales.
Para solucionar este error se realizó el siguiente cambio en el programa final:
Donde si el nodo que lee el csv se encuentra activo este leerá todo el longitud de instrucciones que contenga el csv, en caso contrario solo leerá la longitud de instrucciones que contenga el programa original.
Ya con esto se logró obtener que la simulación leyera todas las instrucciones. - Después se ingresó que el primer comando del csv siempre fuera que abriera el gripper, ya que cuando este vaya a probarse en el robot real, el gripper debe estar abierto antes de ir a recolectar el bloque, esto generaba en que cada iteración de la simulación sucediera un bug donde se tiene un error en el gripper y el programa se cierra, para evitar esto se ingresó la siguiente condición donde se abre el gripper antes de llegar a la pila, solo para el primer bloque.
Con estos cambios se realizó una simulación completa del programa.
- Realizando pruebas a la simulación del programa se observó que el robot aunque entiende todas las instrucciones del csv, no ejecuta todas y en cierto punto este solo repite las mismas 5 instrucciones, esto fue debido a que anteriormente no se definió que el programa final leyera toda la longitud del csv con las nuevas coordenadas, sino que solo leyera la longitud de las instrucciones originales.
-
Resultados obtenidos:
- Se logró completar una simulación del programa con los nuevos comandos que son obtenidos del csv, donde para la siguiente sesión se espera iteración exitosa del programa en el robot real.
¶ Sesión Lunes 26 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en el robot real el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Para lograr ejecutar el programa en el robot real, se deben realizar los siguientes pasos:
- Escribir el siguiente comando en la consola:
ros2 run rbc_house_builder task_sender_service
Este genera el csv con las instrucciones a enviar al robot
2. Ya una vez ejecutado ese comando se procede a hacer crtl+C y se escribe el siguiente comando:
ros2 run rbc_house_builder goals_service --ros-args -r __ns:=/asimilar
El anterior comando activa el servicio del nodo para leer el csv, la diferencia es que se le realizó un remaping para que en vez de estar en el namespace del simulador, ahora sea el del robot real.
3. Seguir los pasos indicados por la página rbc_Asimilar para el funcionamiento del robot real.
Al realizar esto se obtuvó que el robot real si ejecutaba los comandos del csv, pero no se tuvo en cuenta que a la hora de colocar el primer bloque y querer detectar el segundo el robot real en ocasiones detectaba el segundo, para ello se colocarón algunos offset a las posiciones finales de los bloques, para que la camara de este no los detectara, esto fue realizado de la siguiente forma:
Al realizar este offset se logró que el robot tuviera el suficiente espacio para construir lo que pudiera de la superficie.
Se obtuvó que el robot real si ejecuta los comandos que lee del csv y la imagen anterior representa como este coloca el primer bloque.
- Resultados obtenidos:
- Se logró realizar una prueba del funcionamiento de los comandos generados por el csv en el robot real, para la siguiente sesión se esperan realizar más pruebas del funcionamiento de este.
¶ Sesión Martes 27 de mayo [1:00pm-3:30pm]
-
Objetivos a trabajar:Implementar en el robot real el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- De la prueba anterior se observó que el robot real deja caer el bloque desde cierta altura, lo que evita que este se logre colocar de la manera esperada, para ello se modificaron los offset al generador de las instrucciones del csv con los siguientes:
Ya con el nuevo offset en el eje Z se obtuvó que el brazo no suelta el bloque en una altura considerable, sino que ahora logra dejarlo aproximadamente cerca de la superficie de la mesa.
Al realizar la nueva prueba se logró realizar la primera pared del cuadrado, pero al llegar a colocar en la primera esquina el robot no tiene el suficiente tiempo para lograr colocar el bloque en la rotación deseada y se obtuvó la siguiente respuesta:
Para ello en el programa real se agregó que para los bloques con rotación se repitiera el comando de colocarse encima de la posición dos veces, para evitar que sucediera estos inconvenientes.
Donde al realizar este cambio se obtuvo la siguiente respuesta del robot:
Este resultado es bastante cercano a lo esperado, donde las inconsistencias entre los bloques por la posición donde se colocan en su posición final es debido a que aun no se toma en cuenta que tan separados se desean los bloques unos de otros.
- De la prueba anterior se observó que el robot real deja caer el bloque desde cierta altura, lo que evita que este se logre colocar de la manera esperada, para ello se modificaron los offset al generador de las instrucciones del csv con los siguientes:
-
Resultados obtenidos:
- Se logró realizar una prueba del funcionamiento de los comandos generados por el csv en el robot real donde se obtuvó la primera pared y la primera diagonal.
¶ Sesión Lunes 2 de junio [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en el robot real el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Para esta sesión se realizarón diversos cambios respecto a la posición donde se obtienen los bloques para construir la estructura, al igual que se ajusta un espacio para evitar que los bloques choquen entre si cuando se esta armando la estructura.
En la imagen anterior se agregaron otras dos posiciones de homing, esto debido a que la velocidad del robot no es suficiente para completar la instrucción de volver a la posición de homing cuando regresa de colocar un bloque rotado.
Por otra parte se cambio la variable "block_gap a 10mm, este valor lo que hace es dejar un espacio entre cada bloque de 10mm, esto es vital ya que el robot en ocasiones no logra obtener correctamente la posición del bloque y como este valor anteriormente era 0, en ocasiones sucedia que los bloques se colocaban encima de otros."
Donde al agregar este valor se obtuvó la siguiente respuesta en la construcción de la estructura:
Como se puede apreciar, hay una distancia aproximada de 10mm entre cada bloque colocado, esto evitará que coloquen bloques encima de otros de mejor manera.
- Para esta sesión se realizarón diversos cambios respecto a la posición donde se obtienen los bloques para construir la estructura, al igual que se ajusta un espacio para evitar que los bloques choquen entre si cuando se esta armando la estructura.
-
Resultados obtenidos:
- Se logró realizar una prueba del funcionamiento evitando que bloques se coloquen encima de otros generando una estructura erronea.
¶ Sesión Lunes 9 de junio [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en el robot real el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Para esta sesión se intentó construir la estructura cuadrada completa, ya que obtuvó una correcta colocación de la primera pared y el primer bloque rotado, con ello se tiene unos grandes cambios al código del programa:
Esta nueva posición de homing no solo permite leer el "marker" de los bloques de mejor manera, sino que permite más espacio para construir la estructura deseada.
Después de diversas pruebas se definió que por cada pila se tuvieran 6 bloques jenga, donde la nueva posición de homing logra que se tengan dos bloques a la par de otro, donde se tiene lo siguiente:
El código marcado hará que cuando se acabe la primera pila de bloques, ahora el robot se mueva a la posición donde se encuentran los bloques restantes para completar la estructura de jenga.
Se agregaron desplazamientos en el eje X y Y para aprovechar el nuevo espacio para construir la estructura, donde se obtiene la siguiente respuesta del robot:
Se puede observar de mejor manera la contrucción de esta estructura en el siguiente Vídeo de construcción
- Para esta sesión se intentó construir la estructura cuadrada completa, ya que obtuvó una correcta colocación de la primera pared y el primer bloque rotado, con ello se tiene unos grandes cambios al código del programa:
-
Resultados obtenidos:
- Se logró construir la estructura completa de forma parcial.
- En la prueba se observó que la ultima pared, los bloques no rotaban, esto se planea solucionar en la siguiente prueba.
¶ Sesión Miercoles 11 de junio [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en el robot real el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- Se descubrió la razón por la cual la ultima pared no estaba siendo rotada, esto es debido a que no se actualizaba el ángulo de rotación para esta pared en especifico, esto se logró solucionar de la siguiente forma:
El código marcado logra actualizar de mejor forma el ángulo de rotación de esta pared de la estructura.
Después se realizaron unos nuevos cambios a los comandos que genera el programa para ser enviados al robot.
El primer código señalado mueve el robot un poco más en el eje X para capturar los bloques de la segunda pila de bloques de mejor manera.
El segundo cambio mostrado es debido a la misma razón que el ajuste anterior.
El ultimo cambio realizado es debido para asegurar la rotación del bloque adecuadamente.
Una vez realizados estos cambios se obtuvó la siguiente respuesta:
Donde el proceso de como se obtuvo este resultado se puede observar en este Vídeo
- Se descubrió la razón por la cual la ultima pared no estaba siendo rotada, esto es debido a que no se actualizaba el ángulo de rotación para esta pared en especifico, esto se logró solucionar de la siguiente forma:
-
Resultados obtenidos:
- Se logró construir la estructura completa de forma exitosa, por el momento solo se debe ajustar los diferentes desfases entre los bloques para que la estructura se observe de forma más uniforme.
¶ Sesión Miercoles 18 de junio [1:00pm-3:30pm]
-
Objetivos a trabajar: Implementar en el robot real el programa existente que calcula la disposición de los bloques Jenga para construir una estructura.
-
Actividades realizadas:
- El nuevo código realiza un ajuste para reducir la altura del robot para lograr de mejor manera la lectura de los markers de los bloques.
- Por otra parte también se ajustaron las distancias de las paredes rotadas para que tuvieran una estructura más uniforme, donde se tiene la siguiente respuesta en forma de Vídeo
- El nuevo código realiza un ajuste para reducir la altura del robot para lograr de mejor manera la lectura de los markers de los bloques.
-
Resultados obtenidos:
- Los ajustes realizados a la construcción de la estructura se observa que no siguen la forma que se desea, la cual se observa en la siguiente figura:
Por lo cual para la proxima sesión se espera resolver este problema.
- Los ajustes realizados a la construcción de la estructura se observa que no siguen la forma que se desea, la cual se observa en la siguiente figura: