PREVENT - Robotics Practial Session (Halmstad) - ES

Robótica - Proyecto PREVENT

Sesión práctica

Iniciar

Índice

Objetivos

Ejercicio 1

Ejercicio 2

Ejercicio 3

fuente: https://emanual.robotis.com/

Objetivos

• El objetivo de esta sesión práctica de robótica es adquirir experiencia práctica con la operación de robots, comprender conceptos clave en control de robótica y aplicar habilidades de resolución de problemas en aplicaciones del mundo real.
• La sesión consta de dos escenarios principales: 
  • detección y reconocimiento visual de un incendio
  • localizar la salida más cercana evitando un incendio
• La sesión práctica se basa en simulaciones ROS2 y Gazebo, que se pueden implementar fácilmente en modelos físicos.

La tecnología robótica está transformando la respuesta a desastres, haciendo que las operaciones de búsqueda, rescate y recuperación sean más rápidas, seguras y eficaces.

Repositorio de GitHub

Objetivos

Esta es una simulación de robótica inteligente que combina visión por computador y navegación autónoma para detectar incendios y navegar por entornos peligrosos hacia la salida más segura.

Características principales

• Detección de flechas basada en color para guía de navegación

• Detección de fuego/llama usando visión por computador

• Navegación autónoma de robots en entornos simulados

• Control en tiempo real mediante entrada de teclado

• Transmisión en vivo desde la cámara del robot

source: https://emanual.robotis.com/

¿Qué experimentarás

• Detección de visión: Observa cómo tus algoritmos identifican flechas de colores y llamas

• Simulación en 3D: Mira cómo tu robot navega por un entorno escolar realista

• Cámara en vivo: Observa el mundo a través de los ojos de tu robot

• Control interactivo: Conduce tu robot usando las teclas WASD

• Navegación autónoma: Permite que el robot tome decisiones basadas en las señales visuales

Requisitos previos

• Conocimientos básicos de Python

• Fundamentos de visión por computador

• Biblioteca OpenCV

Ejercicio 1

Ejercicio 1- Detección de visión

El objetivo de este ejercicio de detección de visión es desarrollar habilidades básicas en visión por computador comenzando con el ejercicio práctico de detección de color. Los estudiantes aprenderán y practicarán específicamente la detección del color de flechas para los tres colores primarios (rojo, verde, azul) y la detección de llamas usando varias imágenes de muestra. Esta práctica práctica proporciona la base necesaria para entender cómo funcionan los algoritmos de procesamiento de imágenes en aplicaciones del mundo real.

Ejercicio 1- Detección de visión

Comenzar con el ejercicio

# Instalar OpenCV para los ejerciciospip install opencv-contrib-python# Probar los algoritmos de deteccióncd Exercise/python detect.py

Ejercicio 1- Detección de visión

El código de detección de color (detect.py) y las imágenes de ejemplo se pueden descargar desde aquí

Detección de visión

import cv2import numpy as npimport sysdef detect_arrow_and_show(image_path: str): image = cv2.imread(image_path) if image is None: print(f"Error: No se pudo leer {image_path}") return image_bgr = image.copy() hsv_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2HSV) red_lower = np.array([0, 50, 50]) red_upper = np.array([10, 255, 255]) green_lower = np.array([35, 50, 50]) green_upper = np.array([85, 255, 255]) blue_lower = np.array([100, 50, 50]) blue_upper = np.array([130, 255, 255]) orange_lower = np.array([ 8,100,140]) orange_upper = np.array([20,255,255]) yellow_lower = np.array([20, 60,160]) yellow_upper = np.array([45,255,255]) red_mask = cv2.inRange(hsv_image, red_lower, red_upper) green_mask = cv2.inRange(hsv_image, green_lower, green_upper) blue_mask = cv2.inRange(hsv_image, blue_lower, blue_upper) orange_mask = cv2.inRange(hsv_image, orange_lower, orange_upper) yellow_mask = cv2.inRange(hsv_image, yellow_lower, yellow_upper)

pixeles_rojos = cv2.countNonZero(red_mask) pixeles_verdes = cv2.countNonZero(green_mask) pixeles_azules = cv2.countNonZero(blue_mask) pixeles_llama = cv2.countNonZero(red_mask) + cv2.countNonZero(orange_mask) + cv2.countNonZero(yellow_mask) conteo_colores = { 'Rojo': pixeles_rojos, 'Verde': pixeles_verdes, 'Azul': pixeles_azules, 'Llama': pixeles_llama } color_mas_alto = max(conteo_colores, key=conteo_colores.get) cantidad_maxima = conteo_colores[color_mas_alto] color_detectado = color_mas_alto si cantidad_maxima > 100 else "Desconocido" # return color_detectado cv2.putText(imagen, f'Detectado: {color_detectado}', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) cv2.imshow(f'{image_path} - {color_detectado}', imagen) print(f"{image_path}: {color_detectado} detectado") cv2.waitKey(0) cv2.destroyAllWindows() if __name__ == "__main__": if len(sys.argv) < 2: print("Uso: python detect.py <nombre de archivo>") else: detect_arrow_and_show(sys.argv[1])

Ejercicio 1- Detección de visión

Detección de visión

Y el código de detección de llamas (liveFlameDetection.py):

import cv2import numpy as npdef flamedetector(): cap = cv2.VideoCapture(0) if not cap.isOpened(): print("Error: No se pudo abrir la cámara.") return # Opcional: hacer la imagen un poco más nítida / coherente cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) # Parámetros que puedes ajustar MIN_AREA_RATIO = 0.001 # 0.1% del área del marco SAT_MIN = 140 # saturación mínima (para reducir detecciones de piel) VAL_MIN = 190 # brillo mínimo (las llamas son brillantes) COOLDOWN_FRAMES = 8 # mantener el texto unos cuadros para evitar parpadeo cooldown = 0 print("Presione 'q' para salir.") while True: ret, frame = cap.read() frame = cv2.flip(frame, 1) if not ret: print("Error: No se pudo leer el cuadro.") break hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) h, s, v = cv2.split(hsv) # Rangos de tono para llamas rojas/naranjas/amarillas # rojo (0-10) mask_r1 = cv2.inRange(hsv, np.array([0, SAT_MIN, VAL_MIN]), np.array([10, 255, 255])) # naranja/amarillo (15-45) – ajusta el límite superior si tu llama parece más amarilla mask_r2 = cv2.inRange(hsv, np.array([15, SAT_MIN, VAL_MIN]), np.array([45, 255, 255]))

mask = cv2.bitwise_or(mask_r1, mask_r2) # Limpieza del ruido mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3,3), np.uint8), iterations=1) mask = cv2.morphologyEx(mask, cv2.MORPH_DILATE, np.ones((3,3), np.uint8), iterations=2) # Encontrar regiones lo suficientemente grandes contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) frame_area = frame.shape[0] * frame.shape[1] min_area = max(200, int(MIN_AREA_RATIO * frame_area)) # nunca por debajo de 200 px detectado = any(cv2.contourArea(c) > min_area for c in contours) # Anti parpadeo if detectado: cooldown = COOLDOWN_FRAMES elif cooldown > 0: cooldown -= 1 if cooldown > 0: cv2.putText(frame, '¡Llama Detectada!', (12, 34), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 3, cv2.LINE_AA) cv2.imshow('Detección de llamas (color)', frame) si cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows() if __name__ == "__main__": flamedetector()

Ejercicio 2

Ejercicio 2 - Simulación de Robot

El objetivo de este ejercicio es integrar conceptos fundamentales mediante la aplicación de habilidades de visión por computador y control en un entorno de simulación realista. Específicamente, los estudiantes practicarán usando un sistema de visión simulado para detectar señales de navegación e implementar lógica de toma de decisiones para navegar con éxito un TurtleBot3 a través de un modelo de una escuela. Este ejercicio está diseñado para imitar peligros del mundo real que pueden seguir a terremotos e incendios forestales. En un terremoto, se crean múltiples fuentes de ignición, como tuberías de gas rotas y cortocircuitos eléctricos. Durante un incendio forestal, los edificios se encienden principalmente por chispas arrastradas por el viento, o por calor radiante intenso de estructuras cercanas en llamas.

Ejercicio 2 - Simulación de Robot

Requisitos previos

• Sistema operativo Windows/Linux

• GPU: Tarjeta gráfica NVIDIA o AMD - Muy recomendable

• RAM: Se recomienda 8GB+

• Software Docker Desktop: Si eres usuario de Windows

Los Mac de Apple no se pueden usar debido a las GPUs basadas en modelos de silicio.

Ejercicio 2 - Simulación de Robot

Configurar entorno ROS2

Paso 4 Accede a tu escritorio virtual

Paso 3 Iniciar el contenedor

Paso 1 Clonar el repositorio

Paso 2 Construir el contenedor Docker

Ejercicio 2 - Simulación de Robot

Instalación rápida Abre una terminal en tu escritorio virtual y ejecuta:

Paso 4 Configuración del entorno (¡IMPORTANTE!)

Paso 3 Construir el proyecto

Paso 1 Instalar dependencias

Paso 2 Corregir compatibilidad de Python

Ejercicio 2 - Simulación de Robot

Iniciar la Simulación Una vez que todo esté instalado, abre 3 terminales y sigue estos pasos:

Terminal 3: Conduce el Robot

Terminal 1: Iniciar el Mundo

Terminal 2: Visión del Robot

Ejercicio 3

Ejercicio 3 - Implementación en el mundo real

Si tienes acceso a robots físicos reales, puedes realizar estos ejercicios, donde probarás las simulaciones previas en un entorno del mundo real.

origen: https://www.ros.org/robots/turtlebot3/

Ejercicio 3 - Implementación en el mundo real

Necesitarás:

• construir un modelo de una escuela para el entorno de simulación

• ejecutar el mismo código que en el Ejercicio 1 (detect.py)

• ejecutar el mismo código que en el Ejercicio 2 (vision_detector.py)

Ejercicio 1

Ejercicio 2

fuente: https://forum.robotis.com/t/awesome-turtlebot3-projects/4206

¡Curso completado!

1. Abre tu navegador
2. Navega a: http://localhost:6080/
3. Inicia sesión con:

• Nombre de usuario: ubuntu
• Contraseña: ubuntu

¡Boom! ¡Ahora tienes un escritorio Linux en tu navegador!

# Configurar el entorno primerosource /opt/ros/humble/setup.bashsource /code/ros2_ws/install/setup.bashexport TURTLEBOT3_MODEL=waffle_pi# Lanzar la simulaciónros2 launch prevent sim_tb3.launch.py

¡Verás el robot desplegado en un mundo 3D de Gazebo!

cd ~/code/ros2_ws/concolg build --symlink-install

¡Compilación en marcha...

docker run -p 6080:80 --gpus all --shm-size=32gb -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix -v $(pwd)/:/code/ --privileged -it --name humble tiryoh/ros2-desktop-vnc:humble bash

Ejecute estos comandos en CADA nueva terminal:

source /opt/ros/humble/setup.bashsource /code/ros2_ws/install/setup.bashexport TURTLEBOT3_MODEL=waffle_pi

clonar git https://github.com/SivadineshPonrajan/PREVENT.gitcd PREVENT

sudo apt update && sudo apt install -y \ ros-humble-turtlebot3* \ ros-humble-turtlebot3-gazebo \ ros-humble-gazebo-ros-pkgs \ ros-humble-gazebo-ros \ ros-humble-image-view \ python3-numpy \ python3-opencv \ ros-humble-vision-opencvsudo apt install python3-colcon-common-extensions

# Configura el entorno primerosource /opt/ros/humble/setup.bashsource /code/ros2_ws/install/setup.bashexport TURTLEBOT3_MODEL=waffle_pi# Controla el robot con el tecladoros2 run turtlebot3_teleop teleop_keyboard

¡Usa las teclas WASD para conducir tu robot!

docker build -t tiryoh/ros2-desktop-vnc:humble .

Esto puede tardar unos minutos...

sudo python3 -m pip desinstalar -y numpy || truesudo apt-get updatesudo apt-get install -y --reinstalar python3-numpypython3 -m pip instalar "numpy<2" --no-cache-dir

🐍

# Configurar el entorno primerosource /opt/ros/humble/setup.bashsource /code/ros2_ws/install/setup.bashexport TURTLEBOT3_MODEL=waffle_pi# Ver lo que ve el robotros2 run image_view image_view --ros-args --remap /image:=/camera/image_raw

¡Mira el mundo a través de la cámara del robot!