# EarthRover Mini Plus

<img
  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/Earth_Rover_Mini_5_240c9adc-4f9e-44b7-982f-5d1dc24af1d8.png.webp"
  alt="EarthRover Mini Plus"
  width="70%"
/>

El EarthRover Mini Plus es un robot móvil totalmente de código abierto que se conecta a través de la nube mediante el Frodobots SDK. Esto te permite controlar el robot y grabar conjuntos de datos para entrenar modelos de IA.

## Lo que necesitas

### Hardware

- Robot EarthRover Mini
- Computadora con Python 3.12 o más reciente
- Conexión a Internet

### Configuración del SDK de Frodobots

El robot necesita que el [Frodobots SDK](https://github.com/frodobots-org/earth-rovers-sdk) esté en ejecución en tu computadora. Así es como:

1. Descarga e instala el SDK:

```bash
git clone https://github.com/frodobots-org/earth-rovers-sdk.git
cd earth-rovers-sdk
pip install -r requirements.txt
```

2. Guardar credenciales:

Escribe tus variables de .env con la clave de API del SDK y el nombre del bot proporcionados por el equipo de Frodobots.

```bash
SDK_API_TOKEN=your_sdk_api_token_here
BOT_SLUG=your_bot_slug_here
CHROME_EXECUTABLE_PATH=/path/to/chrome_or_chromium
# Default value is MAP_ZOOM_LEVEL=18 https://wiki.openstreetmap.org/wiki/Zoom_levels
MAP_ZOOM_LEVEL=18
MISSION_SLUG=your_mission_slug_here
# Image quality between 0.1 and 1.0 (default: 0.8)
# Recommended: 0.8 for better performance
IMAGE_QUALITY=0.8
# Image format: jpeg, png or webp (default: png)
# Recommended: jpeg for better performance and lower bandwidth usage
IMAGE_FORMAT=jpeg
```

3. Inicie el SDK:

```bash
hypercorn main:app --reload
```

4. Abre tu navegador web y ve a `http://localhost:8000`, luego haz clic en "Join"

El SDK te ofrece:

- Vídeo en vivo de las cámaras frontal y trasera

> [!IMPORTANT]
> El SDK debe estar en ejecución antes de poder usar el robot.

## Instalar LeRobot

Siga nuestra [Guía de instalación](./installation) para instalar LeRobot.

Además de la instalación base, instale EarthRover Mini con las dependencias de hardware:

```bash
pip install -e ".[hardware]"
```

## Cómo funciona

El robot usa internet para comunicarse:

- **Comandos de movimiento**: enviados a través del SDK
- **Video de cámara**: Recibido del SDK
- **Información del robot**: batería, ubicación y velocidad desde el SDK

No necesitas conectar nada: todo funciona a través del SDK.

## Calibración

¡No se necesita calibración! El robot está listo para usar en cuanto el SDK esté en ejecución.

## Controlando el robot

Controlas el robot con tu teclado, igual que al jugar un videojuego con las teclas WASD.

### Controles de teclado

| Clave | Acción                           |
| --- | -------------------------------- |
| W   | Avanzar                     |
| S   | Mover hacia atrás                    |
| A   | Girar a la izquierda (con movimiento hacia adelante)  |
| D   | Girar a la derecha (con movimiento hacia adelante) |
| Q   | Rotar a la izquierda en el sitio             |
| E   | Rotar a la derecha in situ            |
| X   | Detener todo movimiento                |
| +/= | Aumentar la velocidad                   |
| -   | Reducir la velocidad                   |
| ESC | Desconectar                       |

### Ajustes de velocidad

Puede ajustar la velocidad a la que se mueve el robot:

- **Velocidad de propagación hacia adelante/hacia atrás**: El valor predeterminado es la velocidad completa (1.0)
- **Velocidad de giro**: El valor predeterminado es la velocidad completa (1.0)
- **Cambios de velocidad**: Use las teclas +/- para ajustar en 0,1 cada vez

### Pruébalo

Probando el robot antes de grabar datos:

```python
from lerobot.robots.earthrover_mini_plus import EarthRoverMiniPlus, EarthRoverMiniPlusConfig
from lerobot.teleoperators.keyboard import KeyboardRoverTeleop, KeyboardRoverTeleopConfig

# Initialize robot
robot_config = EarthRoverMiniPlusConfig()
robot = EarthRoverMiniPlus(robot_config)

# Initialize teleoperator
teleop_config = KeyboardRoverTeleopConfig(
    linear_speed=1.0,
    angular_speed=1.0,
    speed_increment=0.1
)
teleop = KeyboardRoverTeleop(teleop_config)

# Connect
robot.connect()
teleop.connect()

# Teleoperate (use keyboard controls)
try:
    while True:
        action = teleop.get_action()
        robot.send_action(action)
except KeyboardInterrupt:
    pass
finally:
    robot.disconnect()
    teleop.disconnect()
```

> [!TIP]
> Si usas un Mac, es posible que tengas que dar permiso a Terminal para acceder a tu teclado para la teleoperación. Ve a Preferencias del sistema > Seguridad y privacidad > Monitoreo de entrada y marca la casilla de Terminal.

## Registro de datos

Una vez que puedas controlar bien el robot, puedes comenzar a grabar datos para entrenar modelos de IA. El sistema graba:

- **Lo que haces**: Cómo mueves el robot (hacia adelante, hacia atrás, girando)
- **Lo que ve el robot**:
  - Vídeos de ambas cámaras
  - Velocidad y dirección del robot
  - Nivel de batería y ubicación
  - Posición y señal GPS
  - Otros datos de sensores
- **Cuándo ocurrió**: Marcas de tiempo para todo

### Configuración de Hugging Face

Usamos Hugging Face para almacenar tus datos en línea. Primero, inicia sesión con tu token de [configuración de Hugging Face](https://huggingface.co/settings/tokens):

```bash
hf auth login --token ${HUGGINGFACE_TOKEN} --add-to-git-credential
```

Guarda tu nombre de usuario de Hugging Face:

```bash
HF_USER=$(hf auth whoami | awk -F': *' 'NR==1 {print $2}')
echo $HF_USER
```

### Iniciar grabación

Use el comando de grabación estándar:

```bash
lerobot-record \
    --robot.type=earthrover_mini_plus \
    --teleop.type=keyboard_rover \
    --dataset.repo_id=your_username/dataset_name \
    --dataset.num_episodes=2 \
    --dataset.fps=10 \
    --dataset.single_task="Navigate around obstacles" \
    --dataset.streaming_encoding=true \
    --dataset.encoder_threads=2 \
    --display_data=true
# Optional: --dataset.rgb_encoder.vcodec=auto
```

Reemplaza `your_username/dataset_name` con tu nombre de usuario de Hugging Face y un nombre para tu conjunto de datos.

### Lo que se guarda

Tu conjunto de datos incluye:

**Tus acciones (2 características)**:

- `linear_velocity`: Cuánto te desplazaste hacia adelante/atrás
- `angular_velocity`: Cuánto giraste a la izquierda/derecha

**Observaciones del robot (24 características)**:

- Vídeo de la cámara frontal
- Vídeo de la cámara trasera
- Velocidad actual
- Nivel de batería
- Orientación
- GPS (latitud, longitud, intensidad de la señal)
- Intensidad de la señal de red
- Nivel de vibración
- Estado de la lámpara (encendida/apagada)
- Accelerometer (x, y, z)
- Gyroscope (x, y, z)
- Magnetometer (x, y, z)
- RPM de las ruedas (4 ruedas)

### Dónde va tus datos

En tu computadora: `~/.cache/huggingface/lerobot/{repo-id}`

Después de grabar, tus datos se suben automáticamente a tu página de Hugging Face:

```bash
echo https://huggingface.co/datasets/${HF_USER}/earthrover-navigation
```

Tu conjunto de datos se etiquetará con `LeRobot` para facilitar su descubrimiento por parte de la comunidad.

