🏁 Proyecto: robot que mapea y navega

El robot del proyecto es el de la Ruta 3 (chasis, motores con encoder, ESP32 y Raspberry Pi 5) con un LiDAR 2D en la parte superior. La división del trabajo sigue la regla del curso: la computadora piensa, el microcontrolador controla. El ESP32 lee los encoders y la IMU, hace girar los motores y corta todo si deja de recibir comandos. La Pi 5 ejecuta ROS 2: el driver del LiDAR, el agente micro-ROS, SLAM y Nav2. Tu PC solo se conecta para visualizar en RViz2, a través de la red.

Cómo leer: el recuadro ámbar es la Pi 5, donde reside toda la «inteligencia» de ROS 2. Las piezas cian de la izquierda son el hardware que se conecta por USB. El PC con línea discontinua es opcional: el robot funciona sin él; solo pierdes la pantalla de RViz2.

Objetivo: asignar nombres fijos a los puertos de la Pi 5 y configurar el canal ROS 2 junto con el PC. Los números <idVendor>, <idProduct> e <serial> los lees con el primer comando, un adaptador a la vez.

# 1) descubre los datos del adaptador conectado ahora
udevadm info -a -n /dev/ttyUSB0 | grep -m3 -E "idVendor|idProduct|serial"

# 2) crea la regla (una línea por dispositivo) y vuelve a cargarla
sudo nano /etc/udev/rules.d/99-robo.rules
#  SUBSYSTEM=="tty", ATTRS{idVendor}=="<idVendor>", ATTRS{idProduct}=="<idProduct>", ATTRS{serial}=="<serial>", SYMLINK+="lidar"
#  SUBSYSTEM=="tty", ATTRS{idVendor}=="<idVendor>", ATTRS{idProduct}=="<idProduct>", ATTRS{serial}=="<serial>", SYMLINK+="esp32"
sudo udevadm control --reload-rules && sudo udevadm trigger

# 3) mismo canal ROS 2 en la Pi y en el PC (elige un número del 0 al 101)
echo "export ROS_DOMAIN_ID=42" >> ~/.bashrc && source ~/.bashrc
ls -l /dev/lidar /dev/esp32

Cómo verificar: o ls muestra /dev/lidar e /dev/esp32 apuntando a algún ttyUSB; cambia los cables de puerto USB, reinicia y los nombres seguirán siendo correctos. En la PC, con el mismo ROS_DOMAIN_ID, ros2 topic list muestra los tópicos del robot.

Por qué aprender

Un robot que funciona en la mesa de trabajo y falla «a veces» casi siempre tiene una de estas causas: cambio de puerto, energía del motor que hace caer el Pi o una red que mezcla robots. Una arquitectura clara evita las tres antes de que aparezcan.

Conceptos clave

Abrir cinco terminales en cada prueba cansa y genera errores. Un launch file en Python describe todos los nodos, sus parámetros y las inclusiones de otros launch files, y lo pone todo en marcha con un comando. Este tiene un interruptor: slam:=True para mapear, slam:=False para navegar por el mapa guardado. Está en la carpeta launch/ del paquete meu_robo que creaste en el módulo 4.1 (el URDF viene de meu_robo_description, del 4.2).

Objetivo: un launch que pone en marcha la descripción del robot, el agente micro-ROS, el LiDAR y Nav2 (con SLAM o con un mapa). Ajusta el nombre del archivo xacro, la velocidad del puerto serial de tu LiDAR (el C1 y el A1 usan valores diferentes: compruébalo en el launch del driver) y la ruta del mapa.

# Pone en marcha todo el robot real: TF, ESP32 (micro-ROS), LiDAR y Nav2 con SLAM o mapa
import os
from ament_index_python.packages import get_package_share_directory
from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource
from launch.substitutions import Command, LaunchConfiguration
from launch_ros.actions import Node
from launch_ros.parameter_descriptions import ParameterValue


def generate_launch_description():
    pkg = get_package_share_directory('meu_robo')
    nav2 = get_package_share_directory('nav2_bringup')
    desc = get_package_share_directory('meu_robo_description')   # paquete del módulo 4.2
    xacro_arq = os.path.join(desc, 'urdf', 'robo.urdf.xacro')
    descricao = ParameterValue(Command(['xacro ', xacro_arq]), value_type=str)

    return LaunchDescription([
        DeclareLaunchArgument('slam', default_value='True',
                              description='True = mapear; False = navegar por el mapa guardado'),
        DeclareLaunchArgument('mapa', default_value=os.path.expanduser('~/mapas/casa.yaml')),
        DeclareLaunchArgument('params', default_value=os.path.join(pkg, 'config', 'nav2_robo.yaml')),

        # 1) URDF -> TF fijos (base_link -> laser, base_link -> imu)
        Node(package='robot_state_publisher', executable='robot_state_publisher',
             parameters=[{'robot_description': descricao}]),

        # 2) puente con el ESP32: /ticks y /cmd_vel pasan por aquí (módulo 4.3)
        Node(package='micro_ros_agent', executable='micro_ros_agent',
             arguments=['serial', '--dev', '/dev/esp32', '-b', '115200']),

        # 3) LiDAR (RPLIDAR; para el LD19 cambia el paquete, el ejecutable y los parámetros)
        Node(package='rplidar_ros', executable='rplidar_node',
             parameters=[{'serial_port': '/dev/lidar', 'serial_baudrate': 460800,
                          'frame_id': 'laser'}]),

        # 3b) nodo de odometría del módulo 4.3: /ticks -> /odom y TF odom -> base_link
        Node(package='meu_robo', executable='odometria'),

        # 4) Nav2: con slam:=True también pone en marcha slam_toolbox
        IncludeLaunchDescription(
            PythonLaunchDescriptionSource(os.path.join(nav2, 'launch', 'bringup_launch.py')),
            launch_arguments={'slam': LaunchConfiguration('slam'),
                              'map': LaunchConfiguration('mapa'),
                              'params_file': LaunchConfiguration('params'),
                              'use_sim_time': 'False'}.items()),
    ])

# en el setup.py de meu_robo (paquete ament_python), agrega esto dentro de data_files:
#   (os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')),
#   (os.path.join('share', package_name, 'config'), glob('config/*.yaml')),
# (y "import os" + "from glob import glob" al principio de setup.py)
mkdir -p ~/ros2_ws/src/meu_robo/config
cp ~/meu_nav2.yaml ~/ros2_ws/src/meu_robo/config/nav2_robo.yaml   # del módulo 4.5
cd ~/ros2_ws && colcon build --symlink-install && source install/setup.bash
ros2 launch meu_robo robo_completo.launch.py slam:=True

Por qué aprender

El launch file es la «receta» del robot: quien tome tu proyecto (un colega, un alumno o tú dentro de seis meses) lo pone todo en marcha con una línea, en vez de adivinar el orden de las terminales.

Conceptos clave

En Gazebo todo era perfecto: ruedas que no patinan, LiDAR sin ruido, reloj sincronizado. En el robot real, SLAM y Nav2 son los mismos; lo que cambia es quién publica los datos e a su calidad . La mayoría de los problemas al pasar al robot real están en la odometría y el árbol de frames, no en Nav2.

Cómo leer: cada flecha es una transformación y el texto a su lado indica quién la publica. Cada flecha necesita exactamente un publicador. El error clásico es que la odometría y otro nodo publiquen odom → base_link al mismo tiempo: el robot «salta» en RViz2.

Objetivo: verifica las tres fuentes del robot real antes de mapear. Ejecuta el launch del tema 2 y mantén el robot con las ruedas suspendidas para probar el comando.

# 1) frecuencias: /scan cerca de la frecuencia del LiDAR, /odom estable
ros2 topic hz /scan
ros2 topic hz /odom

# 2) ¿La odometría avanza junto con el robot? (empújalo 1 m con la mano y compara)
ros2 run tf2_ros tf2_echo odom base_link

# 3) ¿El comando llega a los motores? (ruedas en el aire; Ctrl+C para parar)
ros2 topic pub -r 10 /cmd_vel geometry_msgs/msg/Twist "{linear: {x: 0.1}}"

Por qué aprender

Sim-to-real es una habilidad que volverás a usar en la Trilha 5, con el brazo. La lección es la misma: mantén igual el «cerebro» y valida cada fuente de datos del mundo real, una por una.

Conceptos clave

Con las fuentes validadas, haz un mapa real. Sigue el procedimiento del módulo 4.4, ahora con el robot completo: launch con slam:=True, teleop desde la PC y mapa guardado con el nombre del lugar. Haz un mapa por entorno (casa, aula, laboratorio) y guárdalos todos en ~/mapas.

Paso a paso

Objetivo: los comandos de la sesión de mapeo, un terminal por bloque.

# Pi 5 (SSH): robot completo en modo de mapeo
ros2 launch meu_robo robo_completo.launch.py slam:=True

# PC: ver y conducir (mismo ROS_DOMAIN_ID)
rviz2 &
ros2 run teleop_twist_keyboard teleop_twist_keyboard

# Pi 5 (otro SSH), con el mapa correcto en pantalla: guardar
mkdir -p ~/mapas && ros2 run nav2_map_server map_saver_cli -f ~/mapas/casa

Cómo verificar: ~/mapas/casa.pgm muestra el plano sin paredes duplicadas; los pasillos rectos quedan rectos. Si una pared aparece «doblada», vuelve a recorrer ese tramo y cierra el circuito antes de guardar.

Por qué aprender

Es el mismo proceso que sigue un técnico al instalar un robot de limpieza o de reparto en un edificio: mapear, revisar el mapa y marcar dónde no puede ir el robot.

Conceptos clave

Las coordenadas como (3,0; 1,5) no significan nada para quien usa el robot. El paso final es asignar nombres a los lugares: un diccionario que vincula «cocina» con la pose del mapa. Así, «ve a la cocina» se convierte en un comando sencillo, que más adelante puede venir de un botón, un mensaje o tu voz (Ruta 5).

Cómo leer: el pedido (cian) solo se convierte en movimiento si el nombre está en la tabla ámbar. Esta «lista cerrada» es la misma idea de seguridad que la Ruta 5 usa con modelos de lenguaje: el pedido elige entre opciones permitidas, nunca inventa coordenadas.

Objetivo: un comando python3 vai_para.py cozinha que lleva al robot a la habitación usando su nombre. Antes, inicia el robot con slam:=False y establece la posición inicial en RViz2. Mide las poses de tu mapa pasando el mouse sobre RViz2.

#!/usr/bin/env python3
# Uso: python3 vai_para.py cozinha   (solo acepta nombres de la lista LUGARES)
import math
import sys
import rclpy
from geometry_msgs.msg import PoseStamped
from nav2_simple_commander.robot_navigator import BasicNavigator, TaskResult

LUGARES = {                       # nombre: (x, y, ángulo en grados) en el mapa casa.yaml
    'base': (0.0, 0.0, 0.0),
    'sala': (1.2, 0.8, 0.0),
    'cozinha': (3.0, 1.5, 90.0),
    'quarto': (0.5, -1.5, 180.0),
}


def main():
    nome = sys.argv[1].lower() if len(sys.argv) > 1 else ''
    if nome not in LUGARES:
        print('Lugar desconocido. Usa uno de estos:', ', '.join(LUGARES))
        return
    x, y, graus = LUGARES[nome]

    rclpy.init()
    nav = BasicNavigator()
    nav.waitUntilNav2Active()
    alvo = PoseStamped()
    alvo.header.frame_id = 'map'
    alvo.header.stamp = nav.get_clock().now().to_msg()
    alvo.pose.position.x, alvo.pose.position.y = x, y
    alvo.pose.orientation.z = math.sin(math.radians(graus) / 2)
    alvo.pose.orientation.w = math.cos(math.radians(graus) / 2)

    print(f'Yendo a {nome}...')
    nav.goToPose(alvo)
    while not nav.isTaskComplete():
        pass
    ok = nav.getResult() == TaskResult.SUCCEEDED
    print('Cheguei.' if ok else 'No pude llegar.')
    rclpy.shutdown()


if __name__ == '__main__':
    main()

Por qué aprender

Aquí es donde el robot deja de ser una demostración técnica y se vuelve útil: llevar un objeto a la cocina, recorrer la sala y volver a la base. Y la lista cerrada de lugares es el primer paso para conectar un «cerebro» de IA de forma segura.

Conceptos clave

Un robot que se mueve solo cerca de personas necesita barreras en varias capas, porque cada una falla de una manera diferente. El software puede bloquearse, la red puede caerse y el LiDAR no detecta escalones. La regla es: ninguna capa por sí sola garantiza tu seguridad, y la más fuerte siempre es la física.

Cómo leer: de afuera hacia adentro, cada capa es más sencilla y confiable. Si Nav2 se equivoca, el watchdog del ESP32 todavía detiene el robot cuando dejan de llegar los comandos; si el ESP32 se bloquea, el interruptor físico corta la energía. Tú eres el marco punteado: durante las primeras semanas, no te alejes.

Desafíos para avanzar

Por qué aprender

Un robot móvil es la primera máquina del curso que puede lastimar a alguien sin que la toques. Crear ahora el hábito de aplicar capas de seguridad es lo que te permitirá, en la Trilha 5, poner un brazo robótico y un modelo de IA al mando sin miedo.

Conceptos clave