# 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%"
/>

Le EarthRover Mini Plus est un robot mobile entièrement open source qui se connecte via le cloud à l'aide du Frodobots SDK. Cela vous permet de contrôler le robot et d'enregistrer des jeux de données pour l'entraînement de modèles d'IA.

## De quoi vous avez besoin

### Matériel

- Robot EarthRover Mini
- Ordinateur avec Python 3.12 ou plus récent
- Connexion Internet

### Configuration du SDK Frodobots

Le robot a besoin que le [Frodobots SDK](https://github.com/frodobots-org/earth-rovers-sdk) soit installé sur votre ordinateur. Voici comment faire :

1. Télécharger et installer le SDK :

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

2. Enregistrer les identifiants :

Écrivez vos variables .env avec la clé API du SDK et le nom du bot fournis par l'équipe 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. Démarrer le SDK :

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

4. Ouvrez votre navigateur web et accédez à `http://localhost:8000`, puis cliquez sur « Rejoindre »

Le SDK vous offre :

- Vidéo en direct des caméras avant et arrière

> [!IMPORTANT]
> Le SDK doit être en cours d'exécution avant que vous puissiez utiliser le robot.

## Installer LeRobot

Suivez notre [Guide d'installation](./installation) pour installer LeRobot.

En plus de l'installation de base, installez EarthRover Mini avec les dépendances matérielles :

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

## Fonctionnement

Le robot utilise Internet pour communiquer :

- **Commandes de déplacement** : envoyées via le SDK
- **Vidéo de la caméra** : Reçue depuis le SDK
- **Informations sur le robot** : batterie, position, vitesse issues du SDK

Vous n'avez besoin de brancher quoi que ce soit - tout fonctionne via le SDK.

## Calibration

Aucune calibration nécessaire ! Le robot est prêt à l'emploi dès que le SDK est en cours d'exécution.

## Contrôler le robot

Vous contrôlez le robot à l'aide de votre clavier - tout comme lors d'une partie de jeu vidéo avec les touches WASD.

### Contrôles du clavier

| Clé | Action                           |
| --- | -------------------------------- |
| W   | Avancer                     |
| S   | Reculer                    |
| A   | Tourner à gauche (avec un mouvement vers l'avant)  |
| D   | Tourner à droite (avec un mouvement vers l'avant) |
| Q   | Rotation à gauche sur place             |
| E   | Rotation à droite sur place            |
| X   | Arrêter tout mouvement                |
| +/= | Augmenter la vitesse                   |
| -   | Réduire la vitesse                   |
| ESC | Déconnecter                       |

### Paramètres de vitesse

Vous pouvez ajuster la vitesse de déplacement du robot :

- **Vitesse avant/arrière** : La valeur par défaut est la vitesse maximale (1.0)
- **Vitesse de rotation** : la valeur par défaut est la vitesse maximale (1.0)
- **Modifications de la vitesse** : utilisez les touches +/- pour ajuster de 0,1 à chaque fois

### Essayer

Essai du robot avant l'enregistrement des données :

```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 vous utilisez un Mac, vous devrez peut-être accorder à Terminal l'autorisation d'accéder à votre clavier pour la téléopération. Allez dans Préférences Système > Sécurité et confidentialité > Surveillance des entrées et cochez la case Terminal.

## Enregistrement des données

Une fois que vous savez bien piloter le robot, vous pouvez commencer à enregistrer des données pour entraîner des modèles d'IA. Le système enregistre :

- **Ce que vous faites** : La manière dont vous déplacez le robot (avancer, reculer, tourner)
- **Ce que le robot voit** :
  - Vidéos des deux caméras
  - Vitesse et direction du robot
  - Niveau de batterie et localisation
  - Position GPS et signal
  - Autres données de capteurs
- **Quand c'est arrivé** : Horodatage de tout

### Mise en place de Hugging Face

Nous utilisons Hugging Face pour stocker vos données en ligne. Connectez-vous d'abord avec votre jeton depuis [les paramètres Hugging Face](https://huggingface.co/settings/tokens) :

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

Enregistrez votre nom d'utilisateur Hugging Face :

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

### Démarrer l'enregistrement

Utilisez la commande d'enregistrement standard :

```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
```

Remplacez `your_username/dataset_name` par votre nom d'utilisateur Hugging Face et un nom pour votre jeu de données.

### Ce qui est enregistré

Votre jeu de données comprend :

**Vos actions (2 fonctionnalités)** :

- `linear_velocity` : La distance parcourue en avant/en arrière
- `angular_velocity` : L'ampleur de la rotation vers la gauche/droite

**Observations du robot (24 caractéristiques)** :

- Vidéo de la caméra avant
- Vidéo de la caméra arrière
- Vitesse actuelle
- Niveau de la batterie
- Orientation
- GPS (latitude, longitude, intensité du signal)
- Intensité du signal réseau
- Niveau de vibration
- État de la lampe (allumée/éteinte)
- Accelerometer (x, y, z)
- Gyroscope (x, y, z)
- Magnetometer (x, y, z)
- Tours par minute des roues (4 roues)

### Où vont vos données

Sur votre ordinateur : `~/.cache/huggingface/lerobot/{repo-id}`

Après l'enregistrement, vos données sont automatiquement téléversées sur votre page Hugging Face :

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

Votre jeu de données sera étiqueté avec `LeRobot` pour faciliter sa découverte par la communauté.

