🛠️ 1.

Introducción
Este documento detalla el proceso completo para transformar una Raspberry Pi 4 con
Ubuntu Server 22.04 en un entorno de simulación educativa con ROS2 y Stage,
incluyendo configuración de entorno gráfico, automatización con scripts, overclocking,
y programación básica de un robot simulado.

Está pensado para facilitar el aprendizaje práctico, incluso sin conexión a Internet ni

📥
necesidad de acceder a cuentas privadas como GitHub.

🖥️
●​ Descarga de Ubuntu Server 22.04.

⚙️
●​ Instalación del entorno gráfico (Xfce).

🤖
●​ Instalación de ROS2 Humble.

🛠️
●​ Instalación y compilación de Stage para ROS2 (con y sin Git).
●​ Scripts automatizados (instalar_stage.sh, lanzar_todo.sh,

🧠
etc.).
●​ Opcional: tu primer script mover_robot.py y el
esquiva_robot.py comentado.
🚀 Overclocking paso a paso.
🔐 Inicio de sesión automático y carga del entorno gráfico sin
●​
●​
credenciales ni comandos.

✍️ 2. Requisitos
2.1. Hardware mínimo recomendado
- Raspberry Pi 4 con 4 GB de RAM
- Tarjeta microSD clase 10 (solo para el primer booteo, se usará SSD)
- SSD SATA (120 GB o más) conectado vía USB 3.0
- Fuente de alimentación de 5V – 3A
- Disipador + ventilador para la Pi
2.2. Software necesario
- Imagen de Ubuntu Server 22.04 para Raspberry Pi:
[Link]
- Balena Etcher (para grabar la imagen)
- Otro equipo para preparar la imagen inicial si es necesario
​ 2.3. Hardware mínimo para el montaje del Robot Móvil Diferencial (PonchoBot)
​ ​ - Placa Esp32 montada sobre una mini protoboard
​ ​ - Dos microservos sg90 de giro continuo con sus ruedas
​ ​ - Un chasis con una rueda loca para el montaje del robot
​ ​ - Una power bank de 5v - 3A para energizar el sistema

🧭 3. Instalación de Ubuntu Server 22.04 en

Raspberry Pi 4
1.​ Descargar imagen oficial Ir a [Link] y
seleccionar Ubuntu Server 22.04 LTS (64-bit) para Raspberry Pi 4.
 2.​ Grabar la imagen en una microSD
○​ Usar Balena Etcher para grabar el archivo .[Link] en una tarjeta
microSD clase 10.
○​ Seleccionar la imagen descargada, la microSD, y luego hacer clic en
“Flash!”.
3.​ Primer arranque y migración a SSD
○​ Insertar la microSD en la Raspberry Pi y conectar el SSD por USB 3.0.
○​ En el primer inicio, iniciar sesión:
■​ Usuario: ubuntu
■​ Contraseña: ubuntu
○​ Ubuntu pedirá cambiar la contraseña.
4.​ Opcional: Migrar el sistema al SSD Hay varias formas (como usando rsync
o instaladores tipo PiClone), pero si estás trabajando directo en SSD o usando
imágenes que ya se cargan en ese medio, podés omitir este paso.

🖥️ 4. Instalación de entorno gráfico (Xfce)

Ubuntu Server no tiene GUI por defecto. Para instalar un entorno ligero:

1.​ Actualizar paquetes

sudo apt update && sudo apt upgrade -y

2.​ Instalar Xfce y utilidades mínimas

sudo apt install -y xfce4 lightdm xserver-xorg mousepad xterm

3.​ Establecer LightDM como gestor de inicio

Cuando se te pregunte cuál display manager usar, seleccioná: lightdm

4.​ Probar entorno gráfico

Podés reiniciar con:

sudo reboot

O iniciar manualmente con: startx

🤖 5. Instalación de ROS2 Humble en Raspberry Pi 4

con Ubuntu Server 22.04
ROS2 Humble es la versión recomendada para Ubuntu 22.04 y tiene soporte activo. A
continuación te explico cómo instalarlo correctamente.

📌 5.1. Configurar locales

sudo apt update && sudo apt install -y locales
 sudo locale-gen en_US en_US.UTF-8
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
export LANG=en_US.UTF-8

Esto asegura que los paquetes de ROS2 usen el sistema de codificación

correcto.

🔐 5.2. Agregar claves GPG y repositorios

sudo apt install -y curl gnupg lsb-release
sudo curl -sSL [Link] |
sudo gpg --dearmor -o /usr/share/keyrings/[Link]

Agregar el repositorio:

echo "deb [signed-by=/usr/share/keyrings/[Link]] \

[Link] $(lsb_release -cs) main" | \
sudo tee /etc/apt/[Link].d/[Link] > /dev/null

📦 5.3. Instalar ROS2 Humble

sudo apt update
sudo apt install -y ros-humble-desktop

Esto incluye rviz, simuladores básicos y muchas herramientas útiles.

🧠 5.4. Configurar el entorno automáticamente

Agregá la línea al final de tu ~/.bashrc:

echo "source /opt/ros/humble/[Link]" >> ~/.bashrc

source ~/.bashrc

🧰 5.5. Instalar herramientas adicionales

sudo apt install -y python3-colcon-common-extensions \
python3-pip python3-rosdep python3-argcomplete

Inicializar rosdep (una sola vez):

sudo rosdep init

rosdep update

📍Hasta acá ya tenemos ROS2 Humble operativo. En la siguiente sección entramos

de lleno con Stage para ROS2, incluyendo la opción de instalación con y sin GitHub.

🧩 6. Instalación de Stage para ROS2 (con

alternativa sin GitHub)
6.1. Crear el workspace de ROS2 si aún no existe
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

6.2. Clonar Stage y stage_ros2

✅ Opción 1: usando Git (requiere conexión a GitHub)

git clone [Link]
git clone [Link]

📦 Opción 2: sin GitHub, descargando archivos .zip

Ideal para entornos educativos sin autenticación.

cd ~/ros2_ws/src
# Descargar Stage
wget [Link] -O [Link]
unzip [Link]
mv Stage-master Stage
rm [Link]

# Descargar stage_ros2 alternativo

wget [Link]
-O stage_ros2.zip
unzip stage_ros2.zip
mv stage_ros2-master stage_ros2
rm stage_ros2.zip

6.3. Instalar dependencias del sistema

sudo apt install -y cmake g++ libpng-dev libjpeg-dev libfltk1.3-dev \
libx11-dev libxt-dev libxft-dev libxinerama-dev \
libltdl-dev libtool libboost-dev

6.4. Compilar Stage (motor gráfico)

cd ~/ros2_ws/src/Stage
mkdir build && cd build
cmake ..
make -j4
sudo make install

6.5. Compilar stage_ros2

cd ~/ros2_ws
source /opt/ros/humble/[Link]
colcon build --packages-select stage_ros2

6.6. Activar el entorno cada vez que abras una terminal

 Agregá al final de ~/.bashrc:

source ~/ros2_ws/install/[Link]

Y aplicalo con:

source ~/.bashrc

🛠️ Script automatizado: instalar_stage.sh

Podés usar este instalador todo en uno:

cd ~/ros2_ws
nano instalar_stage.sh

Contenido:

📦
#!/bin/bash
echo " Instalando dependencias..."
sudo apt update && sudo apt install -y \
cmake g++ libpng-dev libjpeg-dev libfltk1.3-dev \
libx11-dev libxt-dev libxft-dev libxinerama-dev \
libltdl-dev libtool libboost-dev python3-colcon-common-extensions

echo "📁 Preparando directorios..."

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

echo "⬇️ Clonando Stage y stage_ros2..."

git clone [Link]
git clone [Link]

echo "🔧 Compilando Stage..."

cd Stage && mkdir build && cd build
cmake .. && make -j4 && sudo make install

echo "⚙️ Compilando stage_ros2..."

cd ~/ros2_ws
source /opt/ros/humble/[Link]
colcon build --packages-select stage_ros2

echo "✅ Instalación completada. Agregá esto a tu ~/.bashrc:"

echo "source ~/ros2_ws/install/[Link]"

Luego:

chmod +x instalar_stage.sh
./instalar_stage.sh
Con esto, Stage y su paquete ROS2 estarán instalados y listos para usarse en
simulaciones 2D y 3D. En la próxima parte vamos a incluir los scripts de
automatización (lanzar_todo.sh) y ejemplos comentados como mover_robot.py
y esquiva_robot.py.

🔁 7. Automatización con scripts

7.1 Script para lanzar simulador y controlador: lanzar_todo.sh

Este script abre dos terminales: una lanza el simulador Stage, la otra ejecuta tu
programa en Python.

Para usuarios con entorno Xfce:

cd ~/ros2_ws
nano lanzar_todo.sh

Contenido:

#!/bin/bash
ROS_SETUP="/opt/ros/humble/[Link]"
WORKSPACE_SETUP="$HOME/ros2_ws/install/[Link]"

# Lanzar Stage en una terminal

xfce4-terminal --hold --title="Simulador Stage" --command="bash -c 'source
$ROS_SETUP && source $WORKSPACE_SETUP && ros2 launch stage_ros2
[Link]'"

# Ejecutar script del robot en otra terminal

xfce4-terminal --hold --title="Controlador del robot" --command="bash -c 'source
$ROS_SETUP && source $WORKSPACE_SETUP && cd
~/ros2_ws/simple_mover && python3 mover_robot.py'"

Guardar con Ctrl+O, salir con Ctrl+X, luego:

chmod +x lanzar_todo.sh

Podés ejecutarlo cada vez así:

./lanzar_todo.sh

🧠 8. Programas de ejemplo para controlar el robot

8.1 mover_robot.py: movimiento recto continuo

Ubicación sugerida: ~/ros2_ws/simple_mover/mover_robot.py

 import rclpy
from [Link] import Node
from geometry_msgs.msg import Twist

class SimpleMover(Node):
def __init__(self):
super().__init__('simple_mover')
[Link] = self.create_publisher(Twist, '/cmd_vel', 10)
[Link] = self.create_timer(0.5, [Link])

def move(self):
msg = Twist()
[Link].x = 0.2 # Avanza recto
[Link](msg)

def main():
[Link]()
nodo = SimpleMover()
[Link](nodo)
nodo.destroy_node()
[Link]()

if __name__ == '__main__':
main()

8.2 esquiva_robot.py: evita obstáculos con láser

Ubicación sugerida: ~/ros2_ws/esquiva_robot/esquiva_robot.py

Este programa:

1.​ Publica comandos en /cmd_vel

2.​ Lee el láser /scan
3.​ Si detecta algo a < 0.5 m en frente, gira por 2 segundos

import rclpy
from [Link] import Node
from geometry_msgs.msg import Twist
from sensor_msgs.msg import LaserScan

class EsquivaRobot(Node):
def __init__(self):
super().__init__('esquiva_robot')
[Link] = self.create_publisher(Twist, '/cmd_vel', 10)
[Link] = self.create_subscription(LaserScan, '/scan', self.leer_laser, 10)
[Link] = 'AVANZANDO'
self.tiempo_giro = 0
[Link] = self.create_timer(0.1, [Link])
 def leer_laser(self, msg):
centro = [Link][len([Link])//2 - 10 : len([Link])//2 + 10]
if min(centro) < 0.5 and [Link] != 'GIRANDO':
[Link] = 'GIRANDO'
self.tiempo_giro = 20

def controlar(self):
cmd = Twist()
if [Link] == 'AVANZANDO':
[Link].x = 0.2
elif [Link] == 'GIRANDO':
[Link].z = 0.7
self.tiempo_giro -= 1
if self.tiempo_giro <= 0:
[Link] = 'AVANZANDO'
[Link](cmd)

def main():
[Link]()
nodo = EsquivaRobot()
[Link](nodo)
nodo.destroy_node()
[Link]()

if __name__ == '__main__':
main()

⚡ 9. Overclocking seguro de Raspberry Pi 4 en

Ubuntu Server 22.04
> Advertencia: realizá esto solo si tenés buena refrigeración (disipador + ventilador).

1.​ Editar configuración del firmware:

sudo nano /boot/firmware/[Link]

2.​ Agregar al final del archivo:

# Overclock seguro
over_voltage=6
arm_freq=2100
gpu_freq=750

3.​ Asegurarse de usar el modo gráfico compatible:

dtoverlay=vc4-fkms-v3d
 4.​ Guardar y reiniciar:

sudo reboot

5.​ Verificar frecuencia y temperatura:

watch -n1 vcgencmd measure_clock arm

watch -n2 vcgencmd measure_temp

> Si la temperatura supera 80 °C bajo carga, considerá bajar a arm_freq=2000.

🔐 10. Inicio automático sin login ni startx

10.1 Activar autologin en consola
sudo mkdir -p /etc/systemd/system/getty@[Link].d
sudo nano /etc/systemd/system/getty@[Link].d/[Link]

Agregar:

[Service]
ExecStart=
ExecStart=-/sbin/agetty --noissue --autologin sergio %I $TERM
Type=idle

> Cambiá “sergio” por tu usuario si es distinto.

10.2 Lanzar el entorno gráfico automáticamente

nano ~/.bash_profile

Agregar al final:

if [ -z "$DISPLAY" ] && [ "$(tty)" = "/dev/tty1" ]; then

startx
fi

> Esto asegura que el entorno gráfico se cargue automáticamente al iniciar sesión.

🧾 11. Anexos: resumen de scripts

🔧 lanzar_todo.sh (con Xfce)
#!/bin/bash
ROS_SETUP="/opt/ros/humble/[Link]"
WORKSPACE_SETUP="$HOME/ros2_ws/install/[Link]"
 xfce4-terminal --hold --title="Simulador Stage" --command="bash -c 'source
$ROS_SETUP && source $WORKSPACE_SETUP && ros2 launch stage_ros2
[Link]'"

xfce4-terminal --hold --title="Controlador del robot" --command="bash -c 'source

$ROS_SETUP && source $WORKSPACE_SETUP && cd
~/ros2_ws/simple_mover && python3 mover_robot.py'"

📜 esquiva_robot.py (comportamiento autónomo con sensores)

> Ver sección 8.2 del documento para el código completo y explicado.

🎉 ¡Felicitaciones! Completaste una instalación robusta de un entorno gráfico,

simulador de robótica, controladores personalizados y optimización del sistema en tu
Raspberry Pi 4. Todo con capacidad para enseñar, replicar y seguir creciendo.

📁 Estructura sugerida de carpetas y archivos

ros2_ws/

├── lanzar_todo.sh

├── instalar_stage.sh

├── simple_mover/

│ └── mover_robot.py

├── esquiva_robot/

│ └── esquiva_robot.py

🛠️ Cómo crearla y empaquetarla como .zip

1.​ Crear las carpetas y copiar los scripts

cd ~/ros2_ws

# Crear carpetas

mkdir -p simple_mover esquiva_robot

# Crear y copiar los archivos

nano lanzar_todo.sh # Pegar contenido de lanzar_todo.sh

nano instalar_stage.sh # Pegar contenido del instalador

 cd simple_mover

nano mover_robot.py # Pegar código del robot que avanza

cd ../esquiva_robot

nano esquiva_robot.py # Pegar código del robot que esquiva

2.​ Dar permisos de ejecución a los scripts

cd ~/ros2_ws

chmod +x lanzar_todo.sh instalar_stage.sh

3.​ Empaquetar todo en un archivo ZIP

cd ~

zip -r proyecto_ros2_stage.zip ros2_ws

Esto creará el proyecto_ros2_stage.zip en tu carpeta personal (~/), listo para

copiar o compartir.

Gemelo digital o control simulado-real en paralelo

Es una de las experiencias más potentes para enseñar robótica, el robot diferencial
físico —con ESP32 y microservos de giro continuo— se mueve al mismo tiempo que
su versión simulada en Stage, recibiendo las mismas órdenes desde un nodo ROS2.

El esquema general sería:

+------------------------------+
| ROS2 en la Pi |
+------------------------------+
| |
| +--> Stage (robot simulado)
|
+--> ESP32 (robot real)
↳ recibe comandos vía UART / WiFi

El nodo en ROS2 publica un Twist en /cmd_vel. Ese mensaje:

●​ Es consumido por stage_ros2, que mueve el robot simulado.

●​ Es reenviado al ESP32, que lo interpreta y mueve a los servos.

🧩 Paso 1: comunicación Pi ↔ ESP32

Primero, decidimos cómo conectar tu ESP32:

●​ Opción A: Serial (UART) por USB Más simple, confiable y sin necesidad de
WiFi.
●​ Opción B: WiFi (ROS2 Micro-ROS o protocolo propio) Requiere más
configuración, ideal si querés usar microros_client.

Para empezar, se recomienda UART por simplicidad.

🔁 Paso 2: nodo ROS2 que reenvía /cmd_vel al

ESP32
Creamos un nodo ROS2 en Python que:

1.​ Se suscribe a /cmd_vel

2.​ Toma los valores linear.x y angular.z
3.​ Los traduce a una cadena compacta (ej: "0.2,0.0\n")
4.​ Los envía por puerto serie al ESP32

🔌 Paso 3: ESP32 que recibe y ejecuta

Tu ESP32:

●​ Escucha por [Link]('\n')

●​ Extrae los dos valores
●​ Aplica estos valores a los SG90 (uno para cada rueda)
○​ Calcula velocidad relativa para cada servo según giro diferencial

Esto permite que el ESP32 y el robot simulado reciban los mismos comandos al
mismo tiempo.

🛠️ Vamos a preparamos primero el nodo ROS2 que reenvía por serial /cmd_vel, y
luego el sketch Arduino para interpretar eso en el ESP32 y mover los SG90

📡 Parte 1: Conectar ROS2 con el ESP32 vía Serial

🎯 Objetivo
El nodo se suscribe a /cmd_vel, y cada vez que recibe un mensaje, lo traduce a texto
(por ejemplo: "0.2,0.0\n") y lo envía al ESP32 vía /dev/ttyUSB0.

🔧 Paso a paso para el nodo reenvia_cmdvel.py

1.​ 📂 Creamos una carpeta nueva:
 cd ~/ros2_ws

mkdir -p enviar_serial

cd enviar_serial

2.​ ✍️ Creamos el script:

nano reenvia_cmdvel.py

3.​ 🔠 Pegar este código en python:

#!/usr/bin/env python3

import rclpy

from [Link] import Node

from geometry_msgs.msg import Twist

import serial

class CmdVelSerialBridge(Node):

def __init__(self):

super().__init__('cmdvel_serial_bridge')

self.serial_port = [Link]('/dev/ttyUSB0', 115200, timeout=1)

[Link] = self.create_subscription(

Twist,

'/cmd_vel',

self.cmd_vel_callback,

10

self.get_logger().info(' 🌐 Nodo puente ROS2 → ESP32 iniciado')

def cmd_vel_callback(self, msg):

lin = [Link].x

ang = [Link].z

texto = f"{lin:.2f},{ang:.2f}\n"
 self.serial_port.write([Link]('utf-8'))

self.get_logger().info(f'↪ Enviado: {[Link]()}')

def main():

[Link]()

nodo = CmdVelSerialBridge()

[Link](nodo)

nodo.destroy_node()

[Link]()

if __name__ == '__main__':

main()

4.​ 💾 Guardá el archivo y salí. Luego asegurate de tener pyserial:

pip3 install pyserial

5.​ 🧪 Probá el nodo (con el ESP32 conectado):

source ~/ros2_ws/install/[Link]

cd ~/ros2_ws/enviar_serial

python3 reenvia_cmdvel.py

> Deberías ver en consola cada línea enviada al ESP32. Esos valores llegarán como
cadenas de texto al otro lado, listos para interpretar.

🔜 Próximo paso: el código del ESP32

Vamos a armar ahora el sketch Arduino para que:

●​ Lea del puerto serie la línea "0.2,0.0\n"

●​ Separe linear y angular
●​ Calcule la velocidad de cada SG90 (rueda izquierda y derecha)
●​ Controle los servos como robot diferencial

🤖 Parte 2: Sketch del ESP32 que interpreta

/cmd_vel y mueve los servos

🎯 Objetivo
 ●​ Leer datos del puerto serie en forma "lineal,angular\n"
●​ Convertir esos valores en velocidad para las ruedas izquierda y derecha
●​ Controlar los servos SG90 (uno por cada rueda)

🔧 Wiring sugerido
Componente Pin ESP32 Notas

SG90 Izquierdo GPIO 5 PWM, con ledc

SG90 Derecho GPIO 18 PWM, con ledc

GND Servo GND Mismo GND entre servos y ESP

VCC Servo 5V Ideal usar fuente externa si hay

ruido

💡 Calibración rápida de servos SG90 de giro continuo

●​ Tienen un rango de control en microsegundos: ~1300–1700 µs
●​ Velocidad 0 (parado) suele estar en 1500 µs
●​ Más bajo → gira a izquierda; más alto → a derecha

Vamos a traducir velocidades diferenciales a este lenguaje.

✍️ Código de ejemplo completo (Arduino para ESP32)

cpp

#include <Arduino.h>

#define SERVO_LEFT_CHANNEL 0

#define SERVO_RIGHT_CHANNEL 1

#define SERVO_LEFT_PIN 5

#define SERVO_RIGHT_PIN 18
// Rango PWM para SG90 (en microsegundos)

const int PWM_MIN = 1300;

const int PWM_NEUTRO = 1500;

const int PWM_MAX = 1700;

// Parámetro de velocidad máxima esperada (m/s)

const float MAX_SPEED = 0.3;

void setup() {

[Link](115200);

// Configurar PWM (ledc)

ledcSetup(SERVO_LEFT_CHANNEL, 50, 16); // 50 Hz, 16 bits

ledcAttachPin(SERVO_LEFT_PIN, SERVO_LEFT_CHANNEL);

ledcSetup(SERVO_RIGHT_CHANNEL, 50, 16);

ledcAttachPin(SERVO_RIGHT_PIN, SERVO_RIGHT_CHANNEL);

detener();

[Link](" 🤖 Esperando comandos desde ROS2...");

}

void loop() {

if ([Link]()) {

String linea = [Link]('\n');

[Link]();
 float linear = 0.0, angular = 0.0;

int sep = [Link](',');

if (sep > 0) {

linear = [Link](0, sep).toFloat();

angular = [Link](sep + 1).toFloat();

float vL = linear - angular; // rueda izquierda

float vR = linear + angular; // rueda derecha

aplicarPWM(vL, vR);

void aplicarPWM(float vIzq, float vDer) {

int pwmL = PWM_NEUTRO + (int)(constrain(vIzq, -MAX_SPEED, MAX_SPEED) /

MAX_SPEED * (PWM_MAX - PWM_NEUTRO));

int pwmR = PWM_NEUTRO + (int)(constrain(vDer, -MAX_SPEED, MAX_SPEED) /

MAX_SPEED * (PWM_MAX - PWM_NEUTRO));

// Invertimos uno si el servo está montado al revés

pwmR = 2 * PWM_NEUTRO - pwmR;

ledcWrite(SERVO_LEFT_CHANNEL, map(pwmL, 1000, 2000, 3276, 6553));

ledcWrite(SERVO_RIGHT_CHANNEL, map(pwmR, 1000, 2000, 3276, 6553));

}

void detener() {

aplicarPWM(0.0, 0.0);

🧪 Pruebas y ajustes
●​ Si tus servos giran al revés, podés invertir pwmL o pwmR.
●​ Si avanzan aunque linear = 0.0, ajustá el PWM_NEUTRO.
●​ Si querés que el robot real y el simulado estén súper sincronizados, asegurate
de que los valores de MAX_SPEED coincidan con los del simulador.

🎬 Objetivo final: lanzamiento completo coordinado

Vamos a crear un script lanzar_real_y_virtual.sh que:

1.​ Lanza Stage con el mundo simulado.

2.​ Lanza tu script mover_robot.py o esquiva_robot.py.
3.​ Lanza el puente reenvia_cmdvel.py que manda los mismos comandos al
ESP32.
4.​ Opcional: ejecuta un comportamiento definido (por ejemplo, avanzar 1 s, girar
90°, avanzar 1 s más…).

🛠️ Paso 1: Script de control sincronizado

(giro_90.py)
Este programa manda comandos secuenciales por /cmd_vel durante tiempos
determinados.

python

import rclpy

from [Link] import Node

from geometry_msgs.msg import Twist

import time

class ScriptGiro(Node):
def __init__(self):

super().__init__('giro_90')

[Link] = self.create_publisher(Twist, '/cmd_vel', 10)

[Link](1.0) # Esperar conexiones

[Link]()

def secuencia(self):

cmd = Twist()

# Avanzar 1 segundo

[Link].x = 0.2

[Link](cmd)

[Link](1)

# Girar 90° durante 1.4 s aprox (ajustable)

[Link].x = 0.0

[Link].z = 1.0

[Link](cmd)

[Link](1.4)

# Avanzar nuevamente

[Link].z = 0.0

[Link].x = 0.2

[Link](cmd)

[Link](1)
 # Detener

[Link].x = 0.0

[Link].z = 0.0

[Link](cmd)

self.get_logger().info('✅ Secuencia finalizada')

def main():

[Link]()

nodo = ScriptGiro()

nodo.destroy_node()

[Link]()

if __name__ == '__main__':

main()

📂 Guardalo en ~/ros2_ws/giro_90/giro_90.py
🧨 Paso 2: nuevo lanzador automatizado
bash

cd ~/ros2_ws

nano lanzar_real_y_virtual.sh

Pegá esto:

#!/bin/bash

ROS_SETUP="/opt/ros/humble/[Link]"

WORKSPACE_SETUP="$HOME/ros2_ws/install/[Link]"
xfce4-terminal --hold --title="Simulador Stage" --command="bash -c 'source
$ROS_SETUP && source $WORKSPACE_SETUP && ros2 launch stage_ros2
[Link]'"

sleep 3

xfce4-terminal --hold --title="Serial → ESP32" --command="bash -c 'source

$ROS_SETUP && source $WORKSPACE_SETUP && cd ~/ros2_ws/enviar_serial &&
python3 reenvia_cmdvel.py'"

sleep 2

xfce4-terminal --hold --title="Comando coordinado" --command="bash -c 'source

$ROS_SETUP && source $WORKSPACE_SETUP && cd ~/ros2_ws/giro_90 &&
python3 giro_90.py'"

Luego:

chmod +x lanzar_real_y_virtual.sh

🚀 Para usarlo:
1.​ Conectá el ESP32.

Asegurate de que tu usuario tenga acceso a /dev/ttyUSB0:​

bash​
sudo usermod -a -G dialout $USER

2.​ (y reiniciá)

Ejecutá:​
./lanzar_real_y_virtual.sh

3.​

🕺🤖📺
Y ahí los verás: robot rojo en pantalla y tu autito físico girando al mismo tiempo, con
precisión casi coreográfica

Continuará …