Título do Projeto: Robótica Resiliente: Superando Desafios para a Teleoperação de um Braço Manipulador em Simulação

Integração de outros modelos de hardware com o framework LeRobot.
Em nosso exemplo, integramos o projeto MeArm, composto de quatro servo motores SG90 e uma controladora Arduino.
Os Obstáculos que Enfrentei (e Superei!):
Guerras de Dependência e ModuleNotFoundError: Mesmo com "Factory Resets" e um novo notebook, enfrentei um inferno de dependências e erros como ModuleNotFoundError: No module named 'pyvirtualdisplay' ou cannot import name 'load_from_hub'. Isso me obrigou a entender profundamente como o Colab gerencia ambientes e a garantir que todas as bibliotecas fossem instaladas e importadas na ordem correta, dentro da mesma célula.
Modelos "Perdidos" no Hugging Face (404 Client Error): Meu maior inimigo foram os erros 404 Not Found ao tentar baixar qualquer modelo pré-treinado do Hugging Face Hub (ppo, tqc, a2c, her). Era como se os arquivos tivessem sumido do servidor, mesmo com meu HF_TOKEN configurado e o login bem-sucedido. Cada tentativa (via load_from_hub ou wget com validação de ZIP) resultava em arquivos corrompidos ou downloads de 0 bytes (páginas HTML de erro). Isso nos impediu de usar qualquer inteligência pré-existente.
Renderização Teimosa (DISPLAY e gladLoadGL): Para o MuJoCo funcionar no Colab e gerar um vídeo, o ambiente precisa de um "display virtual". Lutei contra erros como 'X11: The DISPLAY environment variable is missing' e gladLoadGL error, que me forçaram a integrar e depurar o pyvirtualdisplay de forma robusta.
Atingimos um ponto onde, o máximo que conseguíamos, era um robô que se movia aleatoriamente (parecia até 'bugado' no vídeo!). Mas mesmo isso já era uma vitória, pois provava que o ambiente MuJoCo e a física estavam rodando, apesar de todas as falhas.
Nossa Conquista Final: Teleoperação e Controle Humano-em-Loop
Não aceitei parar no robô aleatório. Com o tempo estendido, decidimos focar em um entregável que realmente mostrasse nosso controle e a funcionalidade do ambiente: a teleoperação. Implementei um sistema para que o robô pudesse ser controlado diretamente pelo teclado no próprio notebook do Colab.
No vídeo abaixo, vocês verão a prova de tudo isso. Vocês verão o braço robótico no ambiente FetchPickAndPlace-v3 sendo controlado em tempo real por mim (ou pelo meu colega!). Usando as teclas do teclado, somos capazes de mover o braço e controlar a garra, tentando a tarefa de pegar e mover o bloco.
O que este vídeo demonstra:
Ambiente de Simulação Funcional: O robô e seu ambiente MuJoCo estão perfeitamente carregados e operacionais.
Controle Direto e Interativo: O robô responde aos comandos humanos em tempo real, validando o conceito de "Human-In-the-Loop".
Física Realista: O bloco (ponto vermelho) reage realisticamente às interações com a garra, provando a simulação de física.
Resiliência Técnica: Este projeto é um testemunho da nossa capacidade de depurar problemas complexos, adaptar estratégias (do gym-hil para o Colab, de modelos pré-treinados para teleoperação) e persistir até conseguir um entregável funcional, mesmo diante de falhas críticas de infraestrutura e recursos externos.
Próximos Passos (se houvesse mais tempo):
Com uma base funcional de teleoperação, o próximo passo seria usar essa capacidade para coletar demonstrações de sucesso (e falha) e treinar um agente de Reinforcement Learning de forma autônoma. Gostaríamos de ter explorado tarefas mais complexas, como a separação de lixo por cores em ambientes customizados, utilizando visão computacional.

===================================================================

CÉLULA ÚNICA FINAL: INSTALAÇÃO, SETUP E TELEOPERAÇÃO DO ROBÔ

(VERSÃO AJUSTADA PARA ERROS DE DEPENDÊNCIA E RENDERIZAÇÃO)

===================================================================

Este código foi o resultado de uma longa jornada de depuração e resiliência.

Ele instala todas as dependências, configura um display virtual para renderização,

e permite controlar um robô FetchPickAndPlace-v3 em tempo real via teclado,

gravando a sessão em um vídeo MP4.

===================================================================

print("🚀 INICIANDO O PLANO FINAL: Instalação e execução em uma única célula para o hackathon...")

--- 1. Instalação de Bibliotecas Python e Dependências do Sistema ---

print(" Instalando bibliotecas Python e dependências do sistema... (Isso pode levar ~2-3 minutos)")

Desinstalação explícita para garantir instalação limpa de huggingface_hub

!pip uninstall -y huggingface_hub

Instalação das dependências principais, garantindo huggingface_hub em versão compatível

!pip install -q gymnasium[mujoco] gymnasium-robotics moviepy pyvirtualdisplay ipywidgets stable_baselines3 huggingface_hub>=0.15.0 huggingface_sb3

Instalação de dependências do sistema para renderização (Xvfb e FFmpeg)

!apt-get update -qq && !apt-get install -y -q xvfb ffmpeg > /dev/null
print(" ✅ Instalações concluídas.")

--- 2. Importações Necessárias ---

from pyvirtualdisplay import Display
import numpy as np
import gymnasium as gym
import gymnasium_robotics
from stable_baselines3.common.env_util import make_vec_env
from stable_baselines3.common.vec_env import VecVideoRecorder
import os

Para interação via teclado no Colab

import ipywidgets as widgets
from IPython.display import display as ipy_display, HTML
from threading import Thread, Lock
import time

--- 3. Configuração do Display Virtual (ESSENCIAL para MuJoCo no Colab) ---

print("\n🖥️ Configurando display virtual para renderização do robô...")
display = None
try:
display = Display(visible=0, size=(1400, 900))
display.start()
print(" ✅ Display virtual configurado e iniciado.")
except Exception as e:
print(f" ❌ ERRO GRAVE: Falha ao configurar o display virtual: {e}")
print(" Não será possível renderizar o vídeo do robô. A execução será interrompida.")
raise Exception("Falha crítica na configuração do display virtual.")

--- 4. Parâmetros do Ambiente e Vídeo ---

ENV_ID = "FetchPickAndPlace-v3"
VIDEO_FILENAME_PREFIX = "teleoperacao_robo_garra"
video_folder = "videos/"
video_length = 1000 # Duração do vídeo em passos (aprox. 40-50 segundos)

--- 5. Configurando o Ambiente de Simulação ---

print(f"\n🤖 Carregando o ambiente de simulação '{ENV_ID}'...")
env = make_vec_env(ENV_ID, n_envs=1, env_kwargs=dict(render_mode="rgb_array"))

--- 6. Configurando o Gravador de Vídeo ---

print(f" Configurando gravador de vídeo na pasta '{video_folder}'...")
env = VecVideoRecorder(env, video_folder,
record_video_trigger=lambda x: x == 0,
video_length=video_length,
name_prefix=VIDEO_FILENAME_PREFIX)

--- 7. Lógica de Teleoperação por Teclado ---

print("\n⌨️ Configurando teleoperação por teclado...")

Define os valores de controle para o vetor de ação [delta_x, delta_y, delta_z, delta_gripper]

action_value = np.zeros(env.action_space.shape[0])
action_lock = Lock() # Para proteger o acesso à action_value de múltiplos threads

speed = 0.05 # Velocidade de movimento do braço
gripper_speed = 0.05 # Velocidade da garra

Função para manipular a ação baseada na tecla pressionada

def on_key_event(event):
global action_value
with action_lock:
# Reseta a ação para não continuar movendo indefinidamente após soltar a tecla
action_value[:] = 0.0

    # Movimento XY
    if event['key'] == 'w': action_value[0] = speed
    elif event['key'] == 's': action_value[0] = -speed
    elif event['key'] == 'a': action_value[1] = speed
    elif event['key'] == 'd': action_value[1] = -speed
    
    # Movimento Z (para cima/baixo)
    elif event['key'] == 'q': action_value[2] = speed
    elif event['key'] == 'e': action_value[2] = -speed

    # Controle da garra (abrir/fechar)
    elif event['key'] == 'z': action_value[3] = gripper_speed  # Abrir garra
    elif event['key'] == 'x': action_value[3] = -gripper_speed # Fechar garra

Cria um widget de texto para capturar eventos de teclado

text_area = widgets.Textarea(
value='',
placeholder='Clique aqui e use as teclas W,A,S,D (XY), Q,E (Z), Z,X (Garra)',
description='Controle:',
disabled=False,
layout=widgets.Layout(width='auto', height='auto')
)

Renderiza o widget para o notebook

ipy_display(text_area)

Conecta o evento de teclado

text_area.on_msg(lambda widget, content, buffers: on_key_event(content))

--- 8. Loop Principal de Simulação e Gravação ---

print("\n🎬 INICIANDO SIMULAÇÃO. Clique na caixa de texto acima para ativar o controle do teclado!")
print(" Pressione W,A,S,D para mover o braço (XY). Q,E para cima/baixo. Z para abrir a garra, X para fechar.")
print(" Você terá cerca de 40-50 segundos de gravação. Tente pegar o bloco e movê-lo!")

obs = env.reset()
task_succeeded = False

try:
for step in range(video_length + 1):
with action_lock:
current_action = action_value.copy() # Pega a ação atual do teclado

    obs, _, _, info = env.step(np.array([current_action])) # Envia a ação para o ambiente

    if info[0].get('is_success'):
        print(f"   🏆 TAREFA CONCLUÍDA! O robô completou a tarefa em {step} passos.")
        task_succeeded = True
        break
    
    time.sleep(0.02) # Pequeno delay para controlar a velocidade da simulação

except Exception as e:
print(f"\n❌ ERRO DURANTE A SIMULAÇÃO: {e}")
print(" A simulação pode ter falhado inesperadamente.")
finally:
env.close()

print("\n🎉 Simulação finalizada!")
if task_succeeded:
    print("   ✅ O robô demonstrou a capacidade de pegar e colocar o objeto com sucesso, via teleoperação!")
else:
    print("   ⚠️ O robô pode não ter concluído a tarefa nesta tentativa, mas a teleoperação demonstrou controle.")

print(f"\n📹 O vídeo da simulação foi salvo na pasta '{video_folder}' no ambiente do Colab.")
print("   👉 PARA BAIXAR O VÍDEO: Clique no ícone de pasta (arquivos) na barra lateral esquerda do Colab.")
print(f"      Navegue até a pasta '{video_folder}'.")
print(f"      Você verá um arquivo .mp4 (ex: '{VIDEO_FILENAME_PREFIX}-step-0-to-{video_length}.mp4').")
print("      Clique nos três pontinhos (...) ao lado do nome do arquivo e selecione 'Fazer o download'.")

# --- Finaliza o display virtual ---
if display:
    try:
        if display.is_started:
            display.stop()
            print("   ✅ Display virtual parado.")
    except Exception as e:
        print(f"   ⚠️ Aviso: Erro ao parar o display virtual: {e}")

print("\nParabéns! Você tem seu entregável. Use a narrativa que discutimos para a apresentação!")

-------------- sketch.ino --------------------------
#include <Servo.h>

Servo servoBase, servoShoulder, servoElbow, servoGripper;

void setup() {
Serial.begin(9600);
servoBase.attach(9); // base
servoShoulder.attach(6); // ombro
servoElbow.attach(5); // cotovelo
servoGripper.attach(3); // garra

// Posição inicial (ajuste conforme necessário)
servoBase.write(90);
servoShoulder.write(90);
servoElbow.write(90);
servoGripper.write(90);
}

void loop() {
if (Serial.available()) {
String cmd = Serial.readStringUntil('\n');
// Comando no formato "servo_index:angulo" (ex: "0:120")
int sep = cmd.indexOf(':');
if (sep > 0) {
int idx = cmd.substring(0, sep).toInt();
int ang = cmd.substring(sep+1).toInt();
ang = constrain(ang, 0, 180);
switch(idx) {
case 0: servoBase.write(ang); break;
case 1: servoShoulder.write(ang); break;
case 2: servoElbow.write(ang); break;
case 3: servoGripper.write(ang); break;
default: break;
}
Serial.print("OK:"); Serial.print(idx); Serial.print(":"); Serial.println(ang);
} else {
Serial.println("ERR");
}
}
}
----------------------- EOF -----------------------------------------

------------------ me_arm.py ------------------------
import time
from lerobot.common.motors.motors_bus import MotorsBus, Motor, MotorNormMode
import serial

class ArduinoMotorsBus(MotorsBus):
def init(self, port, baud=9600):
self.model_number_table = {"sg90": 0}
self.model_ctrl_table = {"sg90": {}}
motors = {
0: Motor(id=0, model="sg90", norm_mode=MotorNormMode.DEGREES), # base
1: Motor(id=1, model="sg90", norm_mode=MotorNormMode.DEGREES), # shoulder
2: Motor(id=2, model="sg90", norm_mode=MotorNormMode.DEGREES), # elbow
3: Motor(id=3, model="sg90", norm_mode=MotorNormMode.DEGREES), # gripper
}
super().init(port=port, motors=motors)
self.ser = serial.Serial(port, baud, timeout=1)
time.sleep(2)

# Métodos abstratos como stubs...
def _assert_protocol_is_compatible(self, *a, **k): pass
def _decode_sign(self, *a, **k): pass
def _disable_torque(self, *a, **k): pass
def _encode_sign(self, *a, **k): pass
def _find_single_motor(self, *a, **k): pass
def _get_half_turn_homings(self, *a, **k): pass
def _handshake(self, *a, **k): pass
def _split_into_byte_chunks(self, *a, **k): pass
def broadcast_ping(self, *a, **k): pass
def configure_motors(self, *a, **k): pass
def disable_torque(self, *a, **k): pass
def enable_torque(self, *a, **k): pass
def is_calibrated(self, *a, **k): return True
def read_calibration(self, *a, **k): pass
def write_calibration(self, *a, **k): pass

def set_motor_position(self, motor_index, position):
    angle = int(max(0, min(180, position)))
    cmd = f"{motor_index}:{angle}\n"
    self.ser.write(cmd.encode())
    resp = self.ser.readline().decode().strip()
    print(f"Enviado: {cmd.strip()} | Arduino: {resp}")

def close(self):
    self.ser.close()

====== Movimentos coordenados ======

if name == "main":
bus = ArduinoMotorsBus("/dev/ttyUSB0") # ou "/dev/ttyACM0"

def espera(segundos=0.8):
    time.sleep(segundos)

print("Início - posição neutra")
# Posição inicial (ajuste conforme seu braço)
bus.set_motor_position(0, 90)  # base
bus.set_motor_position(1, 90)  # ombro
bus.set_motor_position(2, 90)  # cotovelo
bus.set_motor_position(3, 80)  # gripper meio-fechado
espera()

print("Girando base para a esquerda")
bus.set_motor_position(0, 40)
espera()

print("Girando base para a direita")
bus.set_motor_position(0, 140)
espera()

print("Abrindo garra")
bus.set_motor_position(3, 160)
espera()

print("Descendo o braço (ombro e cotovelo)")
bus.set_motor_position(1, 140)   # ombro para baixo
bus.set_motor_position(2, 100)   # cotovelo
espera()

print("Fechando a garra (pegar objeto)")
bus.set_motor_position(3, 60)
espera()

print("Levantando o braço")
bus.set_motor_position(1, 80)    # ombro para cima
bus.set_motor_position(2, 60)
espera()

print("Girando base para o centro")
bus.set_motor_position(0, 90)
espera()

print("Soltando objeto (abrindo garra)")
bus.set_motor_position(3, 160)
espera()

print("Voltando à posição inicial")
bus.set_motor_position(1, 90)
bus.set_motor_position(2, 90)
espera()

print("Fim da sequência!")
bus.close()

----------------------- EOF -----------------------------------------