Este blog explora cómo realizar la detección de objetos en un entorno virtual con NVIDIA Isaac Sim y ROS2. La configuración implica controlar una carretilla elevadora dentro de un almacén virtual mediante las entradas del teclado. Una cámara frontal montada en la carretilla elevadora captura imágenes del entorno. Estas imágenes se transmiten a través de Action Graph a un nodo ROS2. Un paquete ROS2 personalizado procesa las imágenes y utiliza el modelo YoloV8 para detectar objetos. Luego, los resultados de la detección se visualizan en tiempo real con RViz2, lo que permite una integración y un monitoreo perfectos del proceso de detección de objetos en el entorno simulado.

Configuración de la instancia EC2

Para empezar, lance una instancia EC2 y configúrela según las instrucciones detalladas que se proporcionan en el blog «Implementación de NVIDIA Omniverse con Isaac Sim en AWS: guía paso a paso». Siga los pasos que se indican en las secciones Lanzamiento de la instancia de AWS y Configuración principal de la instancia. Estos pasos garantizan que la instancia EC2 esté correctamente configurada para ejecutar Isaac Sim.

• Usa una instancia compatible con GPU de NVIDIA (p. ej., g5.2xlarge) para dar soporte a Isaac Sim.
• Instala los controladores y el software necesarios para ejecutar Isaac Sim.

Creación de una imagen de Docker con ROS2 e Isaac Sim

Cuando la instancia EC2 esté lista, cree una carpeta denominada Isaac-ROS2-Object-Detection para organizar los archivos del proyecto. Dentro de esta carpeta, cree un Dockerfile con el siguiente contenido:

DESDE nvcr.io/nvidia/isaac-sim:4.2.0

#1) Configuración básica del entorno

ENV DEBIAN_FRONTEND=No interactivo

ENV TZ=América/Nueva_York

# 2) Instalar las dependencias del sistema

EJECUTE apt-get update && apt-get install -y\

curl gnupg2 lsb-release tzdata software-propiedades-common

# 3) Agregue las claves y el repositorio de ROS 2

EJECUTE curl -Ssl https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | apt-key add -\

&& echo «deb http://packages.ros.org/ros2/ubuntu $ (lsb_release -cs) main»\

> /etc/apt/sources.list.d/ros2-latest.list

# 4) Instale ROS 2 Humble + teleop + editor

EJECUTE apt-get update && apt-get install -y\

ros-humble-desktop\

teclado ros-humble-teleop-twist-\

nano

# 4.1) Instalar colcon

EJECUTE apt-get update && apt-get install -y python3-colcon-common-extensions

# 5) Instale pip3 y actualice pip

EJECUTE apt-get update && apt-get install -y python3-pip

EJECUTE python3 -m pip install --upgrade pip

# 6) Instale PyTorch (CUDA 11.7) antes de Ultralytics

EJECUTE python3 -m pip install torch torchvision torchaudio\

--index-url https://download.pytorch.org/whl/cu117

# 7) Force NumPy <2 y luego instale Ultralytics

EJECUTE python3 -m pip install --upgrade --force-reinstall «numpy<2"

EJECUTE python3 -m pip install ultralytics

# 8) Configure el entorno ROS en el .bashrc de root

SHELL [» /bin/bash», «-c"]

EJECUTE echo «source /opt/ros/humble/setup.bash" >> /root/.bashrc

# 9) Variables de entorno ROS 2

ENTORNO ROS_VERSION=2

ENTORNO ROS_PYTHON_VERSION=3

ENV ROS_DISTRO=humilde

# 10) Reiniciar DEBIAN_FRONTEND

ENV DEBIAN_FRONTEND=Diálogo

# 11) Punto de entrada predeterminado

PUNTO DE ENTRADA [» /bin/bash "]

Creación de la imagen de Docker:

1. Navega hasta la carpeta en la que se encuentra el Dockerfile.
2. Cree la imagen de Docker ejecutando docker build -t isaac-sim-ros 2:4.2 .0.

Cómo ejecutar el contenedor Isaac Sim

Inicie el contenedor Docker con el siguiente comando:

docker run --name isaac-sim --entrypoint bash -it --gpus all\

-e «ACCEPT_EULA=Y» --rm --network=host\

-e «PRIVACY_CONSENT=Y»\

-v ~/docker/isaac-sim/cache/kit: /isaac-sim/kit/cache:rw\

-v ~/docker/isaac-sim/cache/ov: /root/.cache/ov:rw\

-v ~/docker/isaac-sim/cache/pip: /root/.cache/pip:rw\

-v ~/docker/isaac-sim/cache/glcache: /root/.cache/nvidia/glcache:rw\

-v ~/docker/isaac-sim/cache/computecache: /root/.nv/computecache:rw\

-v ~/docker/isaac-sim/logs: /root/.nvidia-omniverse/logs:rw\

-v ~/docker/isaac-sim/data: /root/.local/share/ov/data:rw\

-v ~/docker/isaac-sim/documentos: /root/documents:rw\

-v /home/ubuntu/documents/isaac_files:/root/documents/isaac_files\

-v /tmp/x11-unix:/tmp/x11-unix\

-e PANTALL=$PANTALLA \

-v /dev/dri:/dev/dri\

isaac-sim-ros 2:4.2.0

• Reenvío X11: Esto permite que se muestren las interfaces gráficas.
• Variable de visualización: Garantiza que ROS2 e Isaac Sim GUI funcionen correctamente.

Cargando la escena del almacén

1. Lanza Isaac Sim dentro del contenedor ejecutando: . /runheadless.webrtc.sh (puedes correr. /runheadless.native.sh si desea cargar la interfaz con Omniverse Streaming Client).
2. En la interfaz de Isaac Sim, navega hasta la Activos pestaña.
3. Carga la escena Warehouse_with_Forklifts. Esto configurará el entorno virtual con una carretilla elevadora.
4. Agregue una nueva carretilla elevadora, en este caso el activo «forklift_c»

Colocación de una cámara en la carretilla elevadora

1. Añada una cámara a la escena arrastrando un objeto de cámara desde crear entra en escena.
2. Coloque la cámara debajo de la jerarquía de la carretilla elevadora, específicamente dentro del prisma del «elevador». Esto asegura que la cámara se mueva junto con el mecanismo de elevación de la carretilla elevadora.
3. Configure la posición y la orientación de la cámara para que mire hacia adelante y capture la vista directamente delante de la carretilla elevadora.
4. Guarde la configuración para garantizar que la ubicación de la cámara se conserve para su uso futuro.

Creación del gráfico de acciones

Gráfico de acción para mover la carretilla elevadora mediante el teclado

Para poder controlar la carretilla elevadora desde el teclado de Isaac Sim, tendrás que configurar un gráfico de acción. Este gráfico vincula las entradas del usuario (teclado) con los mecanismos de movimiento y dirección de la carretilla elevadora, simulando la dirección de Ackermann para lograr un control realista del vehículo.

Para obtener instrucciones detalladas sobre la creación de este gráfico, consulte nuestra entrada de blog Integración de Isaac Sim con ROS 2, específicamente la sección Control de una carretilla elevadora de cuatro ruedas con dirección Ackermann. (https://lnkd.in/dEnJZqbz)

Creación del gráfico de acciones para publicar imágenes

Para permitir que la cámara montada en la carretilla elevadora capture imágenes y las publique en un tema de ROS2 (/rgb), debe configurar un gráfico de acción en Isaac Sim. Este gráfico vincula la cámara con los nodos de comunicación ROS2.

Pasos para crear el gráfico de acciones

1. Abre el editor Action Graph:
   • En Isaac Sim, navega hasta el menú y abre Gráfico de acción editor.
   • Crea un nuevo gráfico de acción para este propósito.
2. Añada los nodos necesarios: Cree y conecte los siguientes nodos como se muestra en el diseño proporcionado:
   • Marque al reproducir: Activa el gráfico de cada marca de simulación.
   • Marco de simulación Isaac Run One: Garantiza que la simulación avance en un fotograma para obtener actualizaciones en tiempo real.
   • Contexto ROS2: Inicializa el entorno ROS2 y establece la comunicación.
   • Isaac Create Render Product: Captura imágenes de la cámara montada en la carretilla elevadora.
   • Ayudante de cámara ROS2: Configura las propiedades de la cámara y establece el espacio de nombres del tema ROS2.
   • Imagen de publicación de ROS2: Publica las imágenes capturadas en el tema /rgb en ROS2.

Explicación detallada de los nodos

• Marque al reproducir:
  • Este nodo activa el gráfico de forma continua durante la reproducción de la simulación, lo que garantiza que la publicación de la imagen sea en tiempo real.
• Marco de simulación Isaac Run One:
  • Avanza la simulación en un fotograma para cada tic, manteniendo el flujo de datos sincronizado.
• Contexto ROS2:
  • Establece un entorno ROS2 que permite que otros nodos del gráfico interactúen con ROS2.
• Isaac Create Render Product:
  • Captura imágenes de la cámara que ha montado en la carretilla elevadora.
  • Establezca la ruta y la resolución de la cámara.

• Ayudante de cámara ROS2:
  • Configura los atributos de la cámara, como la velocidad de fotogramas y el campo de visión, para la integración de ROS2.
  • Defina el espacio de nombres y asegúrese de que el nombre del tema sea /rgb.
• Imagen de publicación de ROS2:
  • Toma la imagen capturada de la cámara y la publica en el tema /rgb, dejándola disponible para que la procesen los nodos ROS2.

1. Verificar y guardar:
   • Una vez que los nodos estén conectados y configurados, guarde el gráfico de acciones.
   • Ejecute la simulación y supervise el tema /rgb en ROS2 para comprobar que las imágenes se publican correctamente.

Para obtener una vista más detallada, consulte Apéndice 1: Gráfico de acción.

Crear un paquete ROS2

Navegue hasta el directorio raíz del contenedor con el comando: cd..

Una vez en el directorio raíz, cree una nueva carpeta llamada ros2_ws para que sirva como espacio de trabajo de ROS2. Dentro de esta carpeta, cree otra carpeta llamada src. Estos directorios organizarán los archivos de su paquete ROS2.

A continuación, vaya al directorio src y ejecute el siguiente comando para crear un nuevo paquete ROS2 llamado yolov8_detector. Este paquete se encargará de las tareas de detección de objetos:

mkdir ros2_ws

cd ros2_ws

mkdir src

cd src

ros2 pkg create --build-type ament_python yolov8_detector

• --tipo de compilación ament_python: especifica que el paquete utilizará Python como idioma principal.
• detector yolov8: el nombre del paquete, que se utilizará durante todo el proyecto.

El paso anterior creó un nuevo directorio denominado yolov8_detector con la siguiente estructura:

detector yolov8/

├── package.xml

├── setup.py

├── recurso

│ ── detector yolov8_

── detector yolov8_

├── __init__.py

Agregar el nodo ROS2 para el procesamiento de imágenes

Dentro del directorio yolov8_detector/yolov8_detector, debes crear el archivo Python que se encargará de capturar las imágenes publicadas por Isaac Sim. Este archivo también realizará la detección de objetos utilizando el modelo YoloV8.

Crear el archivo de nodo

En el directorio src, ejecuta el siguiente comando para crear un nuevo archivo de Python:

nano yolov8_detector/yolov8_detector/yolov8_node.py

Añadir el código de nodo

Dentro del archivo yolov8_node.py, pega el siguiente código. Este script escucha el tema /rgb de Isaac Sim, procesa los fotogramas de la cámara con YoloV8 y publica los resultados de la detección en un tema nuevo denominado /camera/detections:

importar rclpy

de rclpy.node importar Nodo

de sensor_msgs.msg importar Imagen

de cv_bridge importar puente V

importar cv2

de ultralítica importar YOLO

clase Detector Yolov8 (nodo):

def __init__ (uno mismo):

súper (). __init__ ('detector yolov8')

self.subscription = self.create_subscription (

Imagen,

'/rgb', # El tema en el que Isaac Sim publica marcos de cámara

self.listener_callback,

10)

self.publisher = self.create_publisher (Imagen, '/camera/detections', 10)

self.bridge = CVBridge ()

self.model = YOLO ('~/your_path/yolov8n.pt') # Ruta a tu modelo de YoloV8

def listener_callback (self, msg):

# Convierte el mensaje de imagen ROS a formato OpenCV

cv_image = self.bridge.imgmsg_to_cv2 (msg, desired_encoding='bgr8')

# Realizar la detección de objetos

resultados = self.model (cv_image)

# Dibuja cuadros delimitadores en la imagen

annotated_frame = resultados [0] .plot ()

# Volver a convertir a mensaje de imagen ROS

detection_msg = self.bridge.cv2_to_imgmsg (marco anotado, codificación = «bgr8»)

detection_msg.header = msg.header # Conservar el encabezado original del mensaje

self.publisher.publish (detection_msg)

def principal (args=Ninguna):

rclpy.init (args=args)

yolov8_detector = Yolov8Detector ()

rclpy.spin (detector yolov8)

yolov8_detector.destroy_node ()

rclpy.shutdown ()

si __nombre__ == '__principal__':

principal ()

1. Temas: El tema /rgb es donde Isaac Sim publica los marcos de la cámara. Asegúrese de que coincide con el nombre del tema configurado en Isaac Sim.
2. Modelo YOLO: Actualice la ruta ~/your_path/yolov8n.pt con la ubicación de su archivo de modelo de YoloV8. (Puedes descargar los pesos del modelo en el siguiente enlace: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n.pt)
3. Tema de salida: Los fotogramas procesados con cuadros delimitadores se publican en /camera/detections, lo que los hace accesibles para su visualización en RViZ2 u otras herramientas.

Guarde el archivo y salga del editor. Este paso completa la configuración para capturar y procesar imágenes de Isaac Sim.

Configuración del archivo setup.py

El archivo setup.py es un componente crucial de su paquete ROS2. Sirve como script de compilación y especifica los metadatos sobre el paquete, sus dependencias y sus puntos de entrada ejecutables. Este archivo permite que las herramientas de ROS2, como colcon, compilen, instalen y administren correctamente su paquete.

Pasos para editar el archivo setup.py

• Navegue hasta el directorio ros2_wc/src Ejecute el siguiente comando para abrir el archivo setup.py y editarlo:nano yolov8_detector/setup.py
• Pegue la configuración Sustituya el contenido del archivo por el siguiente código:de herramientas de configuración importar find_packages, setuppackage_name = 'yolov8_detector setup (name=package_name, version='0.0.0', packages= ['yolov8_detector'], data_files= [('share/ament_index/resource_index/packages', ['resource/' + package_name]), ('share/' + package_name]), ('share/' + package_name, ['package.xml']),], install_requires= ['setuptools', 'rclpy', 'cv_bridge', 'ultralytics'], zip_safe=Cierto, maintainer='root', maintainer_email=' [email protected] ', description='Todo: descripción del paquete', license='Todo: Declaración de licencia', tests_require= [' pytest '], entry_points= {' console_scripts ': ['yolov8_node = yolov8_detector.yolov8_node:main'],},)
  • nombre: especifica el nombre del paquete (yolov8_detector).
  • versión: Define la versión actual del paquete (0.0.0).
  • paquetes: Incluye los módulos o paquetes de Python que se van a instalar (yolov8_detector).
  • archivos_datos: Muestra archivos como package.xml y los archivos de recursos necesarios para la integración de ROS2.
  • instalar_requiere: declara las dependencias de Python necesarias para el paquete, incluidas rclpy, cv_bridge y ultralytics.
  • puntos de entrada: asigna los scripts de la consola a sus puntos de entrada, haciendo que yolov8_node sea ejecutable mediante comandos ROS2.

Creación del paquete ROS2 y verificación de la instalación

Uso de colcon

¿Qué es el colcón?

colcon (abreviatura de «construcción colectiva») es una herramienta de línea de comandos que se utiliza para crear, probar y administrar espacios de trabajo ROS2. Automatiza el proceso de compilación de paquetes, resolución de dependencias y generación de los archivos necesarios para ejecutar los nodos ROS2.

Construya el paquete

Navegue hasta la raíz del espacio de trabajo de ROS2 (/ros2_ws) y ejecute el siguiente comando:

colcon build --packages-select yolov8_detector

—packages-select yolov8_detector: Esta opción le dice a colcon que cree solo el paquete yolov8_detector en lugar de todos los paquetes del espacio de trabajo.

¿Qué ocurre durante la construcción?

1. colcon lee el archivo setup.py para entender la configuración del paquete.
2. Las dependencias enumeradas en setup.py se comprueban y resuelven.
3. Los archivos compilados y los directorios de instalación se generan en la carpeta de instalación de su espacio de trabajo.

Suministro del espacio de trabajo

Una vez finalizado el proceso de creación, debe obtener el espacio de trabajo:

fuente install/setup.bash

¿Qué hace este comando?

• Configura el entorno para que ROS2 pueda localizar el paquete creado.
• Actualiza ROS_PACKAGE_PATH, garantizando que herramientas como ros2 run y ros2 launch puedan encontrar tu paquete y sus nodos.

Verificación del paquete

Ejecute el siguiente comando para enumerar todos los paquetes del espacio de trabajo y filtrar por yolov8_detector:

lista de paquetes de ros2 | grep yolov8_detector

lista de paquetes de ros2: muestra todos los paquetes ROS2 disponibles en el entorno actual.

detector de grep yolov8: filtra la salida para mostrar solo la línea que contiene el nombre del paquete yolov8_detector.

Salida esperada:

Si todo está configurado correctamente, deberías ver: detector yolov8

Lanzamiento del sistema completo de detección y visualización de objetos

Para utilizar al máximo el sistema que has configurado, necesitarás tres pestañas terminales, cada una conectada al contenedor Isaac Sim. A continuación te explicamos cómo proceder:

Acceda al contenedor en cada terminal

En cada terminal, ejecuta el siguiente comando para acceder al contenedor Docker en ejecución:

docker exec -it isaac-sim bash

Este comando abre una sesión interactiva dentro del contenedor en la que puede ejecutar los comandos ROS2.

Primera terminal: lanzamiento del nodo de detección de objetos

Ejecute el siguiente comando desde. /ros2_ws para ejecutar el nodo de detección de objetos:

ros2 ejecuta yolov8_detector yolov8_node

Si lo anterior no funciona, ejecute source instalar/setup.bash de nuevo y repite el comando anterior

¿Qué pasa aquí?

• El yolov8_node comienza a escuchar el tema /rgb, donde se publican las imágenes de la cámara de la carretilla elevadora.
• YoloV8 procesa las imágenes, detecta objetos y publica fotogramas anotados en el tema /camera/detections.
• Los registros de las detecciones (por ejemplo, los objetos detectados y sus puntuaciones de confianza) se mostrarán en este terminal.

Segunda terminal: control de la carretilla elevadora

En la segunda terminal, ejecute este comando para permitir el control de la carretilla elevadora desde el teclado:

ros2 ejecuta teleop_twist_keyboard teleop_twist_keyboard

Consulta esta configuración en nuestra entrada de blog anterior: Integración de Isaac Sim con ROS 2.

¿Qué pasa aquí?

• Esto lanza un nodo ROS2 para la teleoperación del teclado.
• Con el teclado, puede enviar comandos de velocidad y dirección para mover la carretilla elevadora en el almacén virtual.
• Asegúrese de que el tema ROS2 para la teleoperación coincida con el configurado en el gráfico de acción de Isaac Sim para el control de montacargas.

Lanzamiento del sistema completo de detección y visualización de objetos

Para utilizar al máximo el sistema que has configurado, necesitarás tres pestañas terminales, cada una conectada al contenedor Isaac Sim. A continuación te explicamos cómo proceder:

Acceda al contenedor en cada terminal

En cada terminal, ejecuta el siguiente comando para acceder al contenedor Docker en ejecución:

docker exec -it isaac-sim bash

Este comando abre una sesión interactiva dentro del contenedor en la que puede ejecutar los comandos ROS2.

Primera terminal: lanzamiento del nodo de detección de objetos

Ejecute el siguiente comando para ejecutar el nodo de detección de objetos:

ros2 ejecuta yolov8_detector yolov8_node

¿Qué pasa aquí?

• El yolov8_node comienza a escuchar el tema /rgb, donde se publican las imágenes de la cámara de la carretilla elevadora.
• YoloV8 procesa las imágenes, detecta objetos y publica fotogramas anotados en el tema /camera/detections.
• Los registros de las detecciones (por ejemplo, los objetos detectados y sus puntuaciones de confianza) se mostrarán en este terminal.

Segunda terminal: control de la carretilla elevadora

En la segunda terminal, ejecute este comando para permitir el control de la carretilla elevadora desde el teclado:

ros2 ejecuta teleop_twist_keyboard teleop_twist_keyboard

¿Qué pasa aquí?

• Esto lanza un nodo ROS2 para la teleoperación del teclado.
• Con el teclado, puede enviar comandos de velocidad y dirección para mover la carretilla elevadora en el almacén virtual.
• Asegúrese de que el tema ROS2 para la teleoperación coincida con el configurado en el gráfico de acción de Isaac Sim para el control de montacargas.

Métodos abreviados de teclado:

• Usa W, A, S, D para los movimientos hacia adelante, hacia la izquierda, hacia atrás y hacia la derecha.
• Sigue las instrucciones que aparecen en pantalla para ver más controles.

Tercer terminal: visualización en RViZ2

Ejecute el siguiente comando para iniciar RViz2:

ros2 ejecuta rviz2 rviz2

¿Qué es rViz2?

rViZ2 es una herramienta de visualización 3D para ROS2 que permite el monitoreo en tiempo real de los datos de los sensores, los estados de los robots y más. Proporciona una interfaz gráfica para visualizar temas, lo que la hace ideal para la depuración y la supervisión.

¿Qué pasa aquí?

• RViZ2 mostrará la transmisión de la cámara en vivo desde la carretilla elevadora.
• Verás cuadros delimitadores superpuestos en las imágenes de la cámara, que representan los objetos detectados por YoloV8.

Agregar temas para visualización

1. Accede al menú «Añadir»:
   • Busque y haga clic en Añadir botón, que normalmente se encuentra en el panel izquierdo o en la barra de herramientas de la interfaz RViZ2.
2. Selecciona «Por tema»:
   • En el menú emergente, haga clic en Por tema para explorar los temas de ROS2 disponibles.
3. Añadir el tema /rgb:
   • Navegue hasta el tema /rgb de la lista.
   • En este tema, seleccione Imagen.
   • Haga clic BIEN para añadir el tema a RViz2.
   • Muestra la imagen original en tiempo real capturada por la cámara frontal de la carretilla elevadora en RViZ2.
4. Agregue el tema /camera/detections:
   • Repita el proceso, pero esta vez vaya al tema /camera/detections.
   • De nuevo, selecciona Imagen y haga clic BIEN.
   • Esto muestra los fotogramas anotados de YoloV8, mostrando los cuadros delimitadores y los resultados de detección en tiempo real.

Ahora que todo está configurado, es hora de dar vida al sistema controlando la carretilla elevadora y observando las detecciones en tiempo real en rViZ2.

Apéndice 1: Gráfico de acción

Imagen original:

Primeros planos:

‍