# Ejecuta un ejemplo completo con Turtlesim


## Resumen

Turtlesim es una herramienta de simulación sencilla que demuestra los conceptos fundamentales de ROS 2, tales como nodos, temas (topics) y servicios. En esta sección, ejecutarás un ejemplo completo con Turtlesim, controlarás la tortuga, monitorearás los temas y visualizarás el sistema con rqt.

---

## Configura la redirección de pantalla

### Linux

Permite que Docker acceda a tu servidor X:

```console
$ xhost +local:docker
```

### macOS

En macOS, utiliza XQuartz para proporcionar soporte X11. Instala XQuartz usando Homebrew:

1. Instala XQuartz usando Homebrew:

   ```console
   $ brew install --cask xquartz
   ```

2. Abre XQuartz desde Aplicaciones, luego navega a `Preferences > Security` y habilita `Allow connections from network clients`. Reinicia tu computadora para asegurarte de que los cambios surtan efecto.

3. Después de reiniciar, abre una terminal y permite las conexiones locales:

   ```console
   $ defaults write org.xquartz.X11 nolisten_tcp -bool false
   $ xhost +localhost
   $ xhost + 127.0.0.1
   ```

## Inicia el contenedor

Inicia el contenedor utilizando la misma configuración de Docker Compose de la sección del espacio de trabajo.

Para Linux:

```console
$ cd ws_linux
$ docker compose up -d
$ docker compose exec ros2 /bin/bash
```

Para macOS:

```console
$ cd ws_mac
$ docker compose up -d
$ docker compose exec ros2 /bin/bash
```

## Instala y ejecuta Turtlesim

Dentro del contenedor, instala el paquete Turtlesim:

1. Actualiza el gestor de paquetes:

   ```console
   $ sudo apt update
   ```

2. Instala el paquete Turtlesim:

   ```console
   $ sudo apt install -y ros-humble-turtlesim
   ```

3. Ejecuta el nodo de Turtlesim:

   ```console
   $ ros2 run turtlesim turtlesim_node
   ```

Debería aparecer una ventana en tu escritorio que muestra una tortuga en una cuadrícula.

## Controla la tortuga

1. Abre una nueva terminal y conéctate al mismo contenedor, luego inicia el nodo teleop de teclado:

   ```console
   $ ros2 run turtlesim turtle_teleop_key
   ```

   Este nodo te permite controlar la tortuga usando tu teclado. Utiliza las teclas de flecha para mover la tortuga hacia adelante, atrás, izquierda y derecha. Presiona `Ctrl+C` para detener el nodo teleop.

2. Mueve la tortuga por la ventana. Deberías ver cómo dibuja una línea a su paso.

## Monitorea los temas (topics)

1. Abre otra terminal y conéctate al mismo contenedor, luego lista todos los temas activos:

   ```console
   $ ros2 topic list
   ```

   Deberías ver una salida similar a la siguiente:

   ```text
   /parameter_events
   /rosout
   /turtle1/cmd_vel
   /turtle1/color_sensor
   /turtle1/pose
   ```

2. Obtén información sobre un tema específico:

   ```console
   $ ros2 topic info /turtle1/pose
   ```

   Verás el tipo de tema y qué nodos publican y se suscriben a él.

## Visualiza el sistema con rqt

1. Abre otra terminal y conéctate al mismo contenedor, luego actualiza el gestor de paquetes:

   ```console
   $ sudo apt update
   ```

2. Instala rqt:

   ```console
   $ sudo apt install -y 'ros-humble-rqt*'
   ```

3. Inicia rqt:

   ```console
   $ ros2 run rqt_gui rqt_gui
   ```

Debería aparecer una ventana de rqt. rqt proporciona varios complementos (plugins) útiles para visualizar y monitorear sistemas ROS 2.

### Gráfico de nodos (Node Graph)

Puedes explorar el gráfico de nodos navegando a **Plugins > Introspection > Node Graph**. Se abrirá una nueva pestaña que muestra nodos y temas con sus conexiones ilustradas como líneas. Esta visualización demuestra cómo el nodo teleop envía comandos de velocidad al nodo Turtlesim, y cómo el nodo Turtlesim publica los datos de posición a través de los temas correspondientes.

### Monitor de temas (Topic Monitor)

Puedes monitorear los temas activos navegando a **Plugins > Topics > Topic Monitor**. Se abrirá una nueva pestaña que muestra todos los temas activos y sus valores actuales. Selecciona el icono del ojo junto a `/turtle1/pose` para monitorearlo. A medida que mueves la tortuga, observa cómo se actualizan los valores de pose en tiempo real, mostrando el cambio de posición y orientación de la tortuga según tus comandos.

### Llamador de servicios (Service Caller)

Puedes llamar a servicios desde rqt usando **Plugins > Services > Service Caller**. Selecciona un servicio como `/turtle1/teleport_absolute`, ingresa valores para los campos de la solicitud y selecciona **Call** para enviar la solicitud.

### Gráficos (Plots)

Para graficar los datos de un tema a lo largo del tiempo, navega a **Plugins > Visualization > Plot**. Por ejemplo, en la ventana de Plot, escribe `/turtle1/pose/x` en el campo Topic y presiona Enter. Mueve la tortuga y observa cómo se muestra la posición en el eje X en una gráfica a lo largo del tiempo.

## Llama a servicios de ROS 2

Turtlesim proporciona servicios para realizar acciones como reposicionar la tortuga y limpiar el trayecto.

1. Lista los servicios disponibles:

   ```console
   $ ros2 service list
   ```

   Deberías ver servicios como `/turtle1/set_pen` (para cambiar el color y grosor de la pluma), `/turtle1/teleport_absolute` (para mover la tortuga a una posición específica) y `/turtle1/teleport_relative` (para mover la tortuga con respecto a su posición actual).

2. Teletransporta la tortuga a una nueva posición:

   ```console
   $ ros2 service call /turtle1/teleport_absolute turtlesim/srv/TeleportAbsolute "
   x: 1.0
   y: 3.0
   theta: 0.0
   "
   ```

   La tortuga debería moverse instantáneamente a la posición especificada (1.0, 3.0).

## Crea un publicador sencillo

1. Crea un script de Python que publique comandos de velocidad para controlar la tortuga de forma programática. En una nueva terminal, crea un archivo llamado `move_turtle.py`:

   ```python
   import rclpy
   from geometry_msgs.msg import Twist
   import time

   def main():
       rclpy.init()
       node = rclpy.create_node('turtle_mover')
       publisher = node.create_publisher(Twist, 'turtle1/cmd_vel', 10)

       # Crear un mensaje de tipo twist
       msg = Twist()
       msg.linear.x = 2.0  # Moverse hacia adelante a 2 m/s
       msg.angular.z = 1.0  # Rotar a 1 rad/s

       # Publicar el mensaje
       for i in range(50):
           publisher.publish(msg)
           time.sleep(0.1)

       # Detener la tortuga
       msg.linear.x = 0.0
       msg.angular.z = 0.0
       publisher.publish(msg)

       node.destroy_node()
       rclpy.shutdown()

   if __name__ == '__main__':
       main()
   ```

2. Ejecuta el script:

   ```console
   $ python3 move_turtle.py
   ```

   La tortuga debería moverse en forma circular durante 5 segundos y luego detenerse.

---

## Resumen

En esta sección, configuraste la redirección de pantalla, utilizaste los nodos de Turtlesim, inspeccionaste nodos y temas, y visualizaste el sistema usando rqt. Por último, interactuaste con servicios de ROS 2 y creaste un publicador sencillo para mover la tortuga de forma programática.

Estos conceptos fundamentales se aplican directamente a las aplicaciones de robótica del mundo real con sensores y actuadores reales.

---

## Recursos relacionados

- [Tutoriales de ROS 2 Turtlesim](https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Topics/Understanding-ROS2-Topics.html)
- [Conceptos de ROS 2](https://docs.ros.org/en/humble/Concepts.html)
- [Mensajes de geometría](https://github.com/ros2/geometry2/tree/humble/geometry_msgs)