# LeKiwi

<img
  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/1740517739083.jpeg"
  alt="LeKiwi"
  width="70%"
/>

Nas etapas abaixo, explicamos como montar o robô móvel LeKiwi.

## Obter as peças

Siga este [README](https://github.com/SIGRobotics-UIUC/LeKiwi). Ele contém a lista de materiais, com um link para adquirir as peças, bem como as instruções para imprimir as peças em 3D. Ele também inclui orientações caso seja sua primeira vez imprimindo ou se você não possui uma impressora 3D.

### Versão com fio

Se você tiver a versão **wired** do LeKiwi, pode pular a instalação do Raspberry Pi e a configuração do SSH. Você também pode executar todos os comandos diretamente no seu PC, tanto para os scripts do LeKiwi quanto para os scripts do braço líder para teleoperação.

## Instalar software no Pi

Agora, precisamos configurar o PC remoto que será executado no Robô LeKiwi. Normalmente, trata-se de um Raspberry Pi, mas pode ser qualquer PC que funcione com 5V e possua portas usb suficientes (2 ou mais) para as câmeras e a placa de controle do motor.

### Instalar o SO

Para configurar o Raspberry Pi e seu cartão SD, consulte: [Setup PI](https://www.raspberrypi.com/documentation/computers/getting-started.html). Aqui é explicado como baixar o [Imager](https://www.raspberrypi.com/software/) para instalar o Raspberry Pi OS ou o Ubuntu.

### Configurar SSH

Após configurar seu Pi, você deve habilitar e configurar o [SSH](https://www.raspberrypi.com/news/coding-on-raspberry-pi-remotely-with-visual-studio-code/) (Secure Shell Protocol) para que possa fazer login no Pi a partir do seu laptop sem precisar de uma tela, teclado e mouse no Pi. Um ótimo tutorial sobre como fazer isso pode ser encontrado [aqui](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh). O login no seu Pi pode ser feito no seu Prompt de Comando (cmd) ou, se você usa VSCode, pode usar a extensão [esta](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-ssh).

### Instale o LeRobot no Pi 🤗

No seu Raspberry Pi, instale o LeRobot usando nosso [Guia de Instalação](./installation)

Além dessas instruções, você precisa instalar o suporte para motores Feetech & ZeroMQ no seu Pi:

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

## Instale o LeRobot localmente

Se você já instalou o LeRobot no seu laptop/pc, pode pular esta etapa; caso contrário, siga as mesmas etapas que realizamos no Pi.

Siga nosso [Guia de Instalação](./installation)

Além dessas instruções, você precisa instalar o suporte para motores Feetech & ZeroMQ no seu laptop/pc:

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

Ótimo 🤗! Você já terminou de instalar o LeRobot e podemos começar a montar os braços SO100/SO101 e a base móvel 🤖. Sempre que quiser usar o LeRobot, basta ir para a pasta `~/lerobot`, onde instalamos o LeRobot, e executar um dos comandos.

# Instruções de Montagem Passo a Passo

Primeiro, montaremos os dois braços SO100/SO101. Um para acoplar à base móvel e outro para teleoperação. Em seguida, montaremos a base móvel. As instruções de montagem podem ser encontradas nestas duas páginas:

- [Monte o SO101](./so101#step-by-step-assembly-instructions)
- [Monte o LeKiwi](https://github.com/SIGRobotics-UIUC/LeKiwi/blob/main/Assembly.md)

### Encontre as portas USB associadas à placa do motor

Para encontrar a porta de cada adaptador de servo de barramento, execute este script:

```bash
lerobot-find-port
```

Exemplo de saída:

```
Finding all available ports for the MotorBus.
['/dev/tty.usbmodem575E0032081']
Remove the USB cable from your MotorsBus and press Enter when done.

[...Disconnect corresponding leader or follower arm and press Enter...]

The port of this MotorsBus is /dev/tty.usbmodem575E0032081
Reconnect the USB cable.
```

Onde a porta encontrada é: `/dev/tty.usbmodem575E0032081`, correspondente ao seu board.

No Linux, você pode precisar conceder acesso às portas USB executando:

```bash
sudo chmod 666 /dev/ttyACM0
sudo chmod 666 /dev/ttyACM1
```

Exemplo de saída:

```
Finding all available ports for the MotorBus.
['/dev/ttyACM0']
Remove the usb cable from your MotorsBus and press Enter when done.

[...Disconnect corresponding leader or follower arm and press Enter...]

The port of this MotorsBus is /dev/ttyACM0
Reconnect the USB cable.
```

Onde a porta encontrada é: `/dev/ttyACM0`, correspondente ao seu board.

### Configure os motores

As instruções para configurar os motores podem ser encontradas nos [docs](./so101#configure-the-motors) do SO101. Além dos ids dos motores do braço, também precisamos definir os ids dos motores da base móvel. Eles precisam estar em uma ordem específica para funcionar. Abaixo, uma imagem dos ids dos motores e das posições de montagem dos motores da base móvel. Observe que usamos apenas uma placa de Controle de Motor no LeKiwi. Isso significa que os ids dos motores das rodas são 7, 8 e 9.

Você pode executar este comando para configurar os motores do LeKiwi. Ele primeiro configurará os motores do braço (id 6..1) e, em seguida, os motores das rodas (9,8,7).

```bash
lerobot-setup-motors \
    --robot.type=lekiwi \
    --robot.port=/dev/tty.usbmodem58760431551 # <- paste here the port found at previous step
```

### Solução de problemas de comunicação

Se você está tendo problemas para se conectar ao LeKiwi, siga estas etapas para diagnosticar e resolver o problema.

#### 1. Verifique a configuração do endereço IP

Certifique-se de que o IP correto do Pi seja usado nos comandos ou no seu código. Para verificar o endereço IP do Raspberry Pi, execute (na linha de comando do Pi):

```bash
hostname -I
```

#### 2. Verifique se o Pi é acessível a partir do notebook/PC

Tente fazer um ping no Raspberry Pi a partir do seu laptop:

```bash
ping <your_pi_ip_address>
```

Se o ping falhar:

- Verifique se o Pi está ligado e conectado à mesma rede.
- Verifique se o SSH está habilitado no Pi.

#### 3. Tente a conexão SSH

Se você não consegue fazer SSH no Pi, ele pode não estar conectado corretamente. Use:

```bash
ssh <your_pi_user_name>@<your_pi_ip_address>
```

Se você receber um erro de conexão:

- Verifique se o SSH está habilitado no Pi executando:
  ```bash
  sudo raspi-config
  ```
  Em seguida, navegue até: **Interfacing Options -> SSH** e habilite-o.

### Calibração

Agora, precisamos calibrar o braço líder e o braço seguidor. Os motores das rodas não precisam ser calibrados. O processo de calibração é muito importante, pois permite que uma rede neural treinada em um robô funcione em outro.

### Calibrar o braço seguidor (na base móvel)

Verifique se o braço está conectado ao Raspberry Pi e execute este script ou exemplo de API (no Raspberry Pi via SSH) para iniciar a calibração do braço seguidor:

```bash
lerobot-calibrate \
    --robot.type=lekiwi \
    --robot.id=my_awesome_kiwi # <- Give the robot a unique name
```

Unificamos o método de calibração para a maioria dos robôs; portanto, as etapas de calibração para o braço LeKiwi são as mesmas das etapas para o Koch e o SO101. Primeiro, precisamos mover o robô para a posição em que cada junta está no meio de sua faixa de movimento e, em seguida, pressionar `Enter`. Em segundo lugar, movemos todas as juntas por toda a sua faixa de movimento. Um vídeo desse mesmo processo para o SO101, como referência, pode ser encontrado [aqui](https://huggingface.co/docs/lerobot/en/so101#calibration-video).

### Versão com fio

Se você tiver a versão **wired** do LeKiwi, execute todos os comandos no seu laptop.

### Calibrar o braço líder

Em seguida, para calibrar o braço líder (que está acoplado ao laptop/pc). Execute o seguinte comando do exemplo de API no seu laptop:

```bash
# Use the port of your leader arm, and give the arm a unique name with --teleop.id
lerobot-calibrate \
    --teleop.type=so100_leader \
    --teleop.port=/dev/tty.usbmodem58760431551 \
    --teleop.id=my_awesome_leader_arm
```

```python
from lerobot.teleoperators.so_leader import SO100LeaderConfig, SO100Leader

config = SO100LeaderConfig(
    port="/dev/tty.usbmodem58760431551",
    id="my_awesome_leader_arm",
)

leader = SO100Leader(config)
leader.connect(calibrate=False)
leader.calibrate()
leader.disconnect()
```

## Teleopere o LeKiwi

> [!TIP]
> Se você está usando um Mac, talvez precise dar permissão ao Terminal para acessar seu teclado para teleoperação. Vá em System Preferences > Security & Privacy > Input Monitoring e marque a caixa para Terminal.

Para teleoperar, faça SSH no seu Raspberry Pi e execute `conda activate lerobot` e este comando:

```bash
python -m lerobot.robots.lekiwi.lekiwi_host --robot.id=my_awesome_kiwi
```

O host para após `--host.connection_time_s` segundos (30 por padrão). Para sessões mais longas, como a gravação de um conjunto de dados, aumente esse valor, por exemplo, `--host.connection_time_s=600`.

Em seguida, no seu laptop, execute também `conda activate lerobot` e rode o exemplo da API, certificando-se de definir o `remote_ip` e a `port` corretos em `examples/lekiwi/teleoperate.py`.

```bash
python examples/lekiwi/teleoperate.py
```

Agora você pode mover o braço líder e usar o teclado (w,a,s,d) para avançar, ir para a esquerda, recuar e ir para a direita. E use (z,x) para virar à esquerda ou à direita. Você pode usar (r,f) para aumentar e diminuir a velocidade do robô móvel. Há três modos de velocidade, veja a tabela abaixo:

| Modo de Velocidade | Velocidade Linear (m/s) | Velocidade de Rotação (graus/s) |
| ---------- | ------------------ | ---------------------- |
| Rápido       | 0.3                | 90                     |
| Médio     | 0.2                | 60                     |
| Lento       | 0.1                | 30                     |

| Chave | Ação         |
| --- | -------------- |
| W   | Avançar   |
| A   | Mover para a esquerda      |
| S   | Mover para trás  |
| D   | Mover para a direita     |
| Z   | Vire à esquerda      |
| X   | Vire à direita     |
| R   | Aumentar a velocidade |
| F   | Diminuir a velocidade |

> [!TIP]
> Se você usa um teclado diferente, pode alterar as teclas de cada comando no [`LeKiwiClientConfig`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/robots/lekiwi/config_lekiwi.py).

### Versão com fio

Se você tiver a versão **wired** do LeKiwi, execute todos os comandos no seu laptop.

## Registrar um conjunto de dados

Depois que você estiver familiarizado com a teleoperação, poderá gravar seu primeiro conjunto de dados.

Usamos os recursos do hub do Hugging Face para enviar seu dataset. Se você ainda não usou o Hub, verifique se consegue fazer login via cli usando um token de acesso de escrita; esse token pode ser gerado nas [configurações do Hugging Face](https://huggingface.co/settings/tokens).

Adicione seu token ao CLI executando este comando:

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

Em seguida, armazene o nome do seu repositório do Hugging Face em uma variável:

```bash
HF_USER=$(hf auth whoami --quiet)
echo $HF_USER
```

Agora você pode gravar um dataset. Para gravar episódios e enviar seu dataset para o hub, execute este exemplo de API adaptado para o LeKiwi. Certifique-se de primeiro adaptar o `remote_ip`, `HF_REPO_ID`, a `port` do braço líder e a `TASK_DESCRIPTION` no script. Para gravar mais episódios ou episódios mais longos, altere `NUM_EPISODES`, `EPISODE_TIME_SEC` e `RESET_TIME_SEC`, e inicie o host com um `--host.connection_time_s` que cubra toda a sessão.

```bash
python examples/lekiwi/record.py
```

#### Upload de dataset

Localmente, seu conjunto de dados é armazenado nesta pasta: `~/.cache/huggingface/lerobot/{repo-id}`. Ao final da gravação dos dados, seu conjunto de dados será enviado para sua página do Hugging Face sob o `HF_REPO_ID` definido no script (por exemplo, `https://huggingface.co/datasets/${HF_USER}/lekiwi_test`), que você pode obter executando:

```bash
echo https://huggingface.co/datasets/${HF_USER}/lekiwi_test
```

Seu conjunto de dados será automaticamente marcado com `LeRobot` para que a comunidade o encontre facilmente, e você também pode adicionar tags personalizadas (neste caso, `tutorial`, por exemplo).

Você pode procurar por outros conjuntos de dados do LeRobot no hub pesquisando pelas [tags](https://huggingface.co/datasets?other=LeRobot) `LeRobot`.

#### Dicas para coletar dados

Quando você estiver confortável com a gravação de dados, pode criar um conjunto de dados maior para o treinamento. Uma boa tarefa inicial é pegar um objeto em diferentes localizações e colocá-lo em uma caixa. Sugerimos gravar pelo menos 50 episódios, com 10 episódios por localização. Mantenha as câmeras fixas e mantenha um comportamento de pegada consistente ao longo das gravações. Certifique-se também de que o objeto que você está manipulando esteja visível nas câmeras. Uma boa regra geral é que você deve ser capaz de executar a tarefa sozinho olhando apenas para as imagens das câmeras.

Nas seções a seguir, você treinará sua rede neural. Após alcançar um desempenho confiável de preensão, você pode começar a introduzir mais variações durante a coleta de dados, como locais adicionais de preensão, diferentes técnicas de preensão e alterações nas posições da câmera.

Evite adicionar muita variação muito rapidamente, pois isso pode prejudicar seus resultados.

Se você deseja se aprofundar neste tópico importante, pode conferir o [post no blog](https://huggingface.co/blog/lerobot-datasets#what-makes-a-good-dataset) que escrevemos sobre o que torna um bom dataset.

#### Solução de problemas:

- No Linux, as teclas de controle de fluxo de gravação (teclas de seta, Escape) funcionam em X11, Wayland e sessões headless/SSH, desde que você execute a gravação a partir de um terminal interativo (mantendo-o em foco) — não é necessário configurar o `$DISPLAY`; os equivalentes em letras `n` / `r` / `q` também funcionam. Observe que a **teleoperação por teclado da base LeKiwi** é diferente: ela depende de um backend global de teclas e, portanto, funciona apenas em uma sessão X11, em um desktop Windows ou no macOS com permissões de Acessibilidade/Monitoramento de Entrada concedidas — não funciona em Wayland ou em máquinas headless. Consulte [limitações do pynput](https://pynput.readthedocs.io/en/latest/limitations.html#linux).

## Reproduzir um episódio

Para reproduzir um episódio, execute o exemplo de API abaixo, certifique-se de alterar `remote_ip`, `port`, LeRobotDatasetId e o índice do episódio.

```bash
python examples/lekiwi/replay.py
```

Parabéns 🎉, seu robô está pronto para aprender uma tarefa por conta própria. Comece a treiná-lo pela parte de treinamento deste tutorial: [Primeiros passos com robôs do mundo real](./il_robots)

## Avalie sua política

Para avaliar sua política, execute o exemplo de API `evaluate.py`, certifique-se de alterar `remote_ip`, `port`, model..

```bash
python examples/lekiwi/evaluate.py
```

> [!TIP]
> Se você tiver alguma dúvida ou precisar de ajuda, entre em contato no [Discord](https://discord.com/invite/s3KuuzsPFb).

