Pular para o conteúdo principal

⚙️ Modos de Operação

Objetivo

Compreender os três modos operacionais do G1 e transições entre eles: Damping, Preparation e Movement.

📊 Estados do Sistema​

Diagrama de Estados​

                    ┌─────────────────┐
        Power ON →  │   BOOT (20s)    │
                    └────────┬────────┘
                             │
                             ↓
                    ┌────────────────┐
                    │  0: DAMPING    │ ← Modo seguro
                    │  (Zero torque)  │
                    └───────┬────────┘
                         ↕  │ L1+UP
        Manual move      │  ↓
                    ┌────────────────┐
                    │ 1: PREPARATION │ ← Pronto para operar
                    │   (Standing)    │
                    └───────┬────────┘
                         ↕  │ START
      AUTO/Commands      │  ↓
                    ┌────────────────┐
                    │  2: MOVEMENT   │ ← Operação ativa
                    │   (Walking)     │
                    └───────┬────────┘
                            │
                L2+R2 →     ↓
                    ┌────────────────┐
                    │ EMERGENCY STOP │
                    └────────────────┘
                            │
                            ↓ (sit down)
                      [DAMPING]

🔵 Mode 0: DAMPING (Safe Mode)​

Características​

Quando o G1 Entra neste Modo:

  • ✅ Ao ligar (boot completo)
  • ✅ Após emergency stop
  • ✅ Bateria <5%
  • ✅ Erro crítico detectado
  • ✅ Botão DAMPING pressionado

Comportamento:

Motors: Zero torque (gravity compensation OFF)
├─ Você pode mover membros manualmente
├─ Robô NÃO se sustenta sozinho
└─ Cai se não apoiado

Sensores: Ativos (LIDAR, câmeras, IMU)
├─ ROS2 nodes rodando
└─ Pode ler telemetria

Computador: Jetson ligado
└─ SSH/API acessíveis

Uso Prático​

Quando Usar:

  • Posicionar robô manualmente
  • Calibração de poses
  • Ensino por demonstração (kinesthetic teaching)
  • Manutenção segura

Exemplo:

from unitree_sdk import Robot

robot = Robot()

# Entrar em modo damping
robot.set_mode(0)  # DAMPING

print("Você pode mover os braços manualmente agora")
print("Gravando trajetória...")

trajectory = []
for i in range(100):  # 10 segundos @ 10Hz
    # Ler posições atuais das juntas
    joint_positions = robot.get_joint_positions()
    trajectory.append(joint_positions)
    time.sleep(0.1)

print("Trajetória gravada com", len(trajectory), "pontos")
# Pode reproduzir depois em modo Movement

🟡 Mode 1: PREPARATION (Ready)​

Características​

Estado:

Motors: Torque ativo, holding position
├─ Robô sustenta próprio peso
├─ Pode ficar em pé indefinidamente
└─ Consome ~80W

Posição: Standing (padrão)
├─ Pernas estendidas
├─ Torso vertical
└─ Braços relaxados ao lado

Pronto para: Receber comandos
├─ Executar poses
├─ Mover braços
└─ Iniciar caminhada (→ Movement)

Transição Damping → Preparation​

Usando Controle:

Sequência:
1. L1 + UP (press simultâneo)
   └─ G1 inicia stand up sequence

2. Aguardar 3-5 segundos
   └─ Pernas estendem gradualmente

3. LED status muda: Azul → Verde
   └─ Modo Preparation ativo

4. Pronto para operar!

Animação de Stand-Up:

Frame 1 (0s):   Sentado
     _O_
    / | \     Damping mode
    ‾ ‾ ‾

Frame 2 (1.5s): Apoiando mãos
     _O_
    /|||\ ←   Mãos no chão
    / | \

Frame 3 (3s):   Levantando
     _O_
    / | \  ←  Pernas estendendo
    /   \

Frame 4 (5s):   Em pé
      O
     /|\   ←  Preparation mode
     / \

Operações em Preparation Mode​

O que você pode fazer:

# 1. Executar poses pré-programadas
robot.pose('wave')         # Acenar
robot.pose('point_front')  # Apontar para frente
robot.pose('arms_up')      # Braços para cima

# 2. Controle de braços
robot.arm_left.move_to_xyz(x=0.3, y=0.2, z=1.0)

# 3. Virar cabeça
robot.head.pan(angle=45)   # Olhar 45° direita
robot.head.tilt(angle=-20) # Olhar 20° para baixo

# 4. Pequenos ajustes de posição (sem caminhar)
robot.lean_forward(angle=5)   # Inclinar 5° frente
robot.shift_weight_left()     # Peso perna esquerda

# 5. Preparar para movimento
robot.prepare_walk()  # Pré-calcula gait
robot.set_mode(2)     # → Movement mode

🟢 Mode 2: MOVEMENT (Active)​

Características​

Estado:

Motors: Controle dinâmico ativo
├─ Caminhada, corrida, saltos
├─ Estabilização ativa (100Hz)
└─ Consome 150-500W (depende velocidade)

Controladores: Todos ativos
├─ Locomotion controller (pernas)
├─ Balance controller (IMU feedback)
├─ Arm controllers (braços independentes)
└─ Navigation (se autônomo)

Sensores: Loop fechado
├─ LIDAR → obstacle avoidance
├─ Cameras → vision-based control
├─ IMU → dynamic balance
└─ Foot sensors → terrain adaptation

Transição Preparation → Movement​

Via Controle RC:

1. Certifique-se que está em Preparation (verde)

2. Mover LEFT STICK:
   ├─ UP/DOWN: Frente/trás
   ├─ LEFT/RIGHT: Girar
   └─ Magnitude: Velocidade

3. G1 transiciona automaticamente para Movement
   └─ LED: Verde → Verde piscando

4. Soltar stick: Para e volta para Preparation

Via Código:

# Método 1: Velocity command (manual)
robot.set_velocity(linear_x=0.5, angular_z=0.0)
# G1 entra em Movement mode automaticamente

# Método 2: Explicit mode change
robot.set_mode(2)  # Movement
robot.walk_forward(speed=0.8)

# Para
robot.stop()  # Volta para Preparation

Limitações em Movement Mode​

Restrições de Segurança:

# Velocidade máxima por gait
LIMITS = {
    'walk':   2.0,  # m/s
    'run':    3.0,  # m/s
    'trot':   1.5,  # m/s (mais estável)
}

# Aceleração máxima
MAX_ACCEL = 1.0  # m/s²

# Inclinação máxima do terreno
MAX_SLOPE = 15  # graus

# Altura de degrau
MAX_STEP_HEIGHT = 0.20  # metros

# Verificação antes de comando
def safe_walk(speed):
    if speed > LIMITS['walk']:
        print(f"⚠️ Velocidade limitada a {LIMITS['walk']} m/s")
        speed = LIMITS['walk']

    if robot.get_slope() > MAX_SLOPE:
        print("❌ Terreno muito inclinado!")
        return False

    robot.walk_forward(speed)
    return True

🔴 Emergency Stop​

Ativação​

Causas de E-Stop:

  1. Manual (L2+R2 no controle)
  2. Queda detectada (IMU) 
    if abs(imu.pitch) > 45 or abs(imu.roll) > 45:
        emergency_stop()
  3. Colisão (força súbita nos pés/braços)
  4. Bateria crítica (<3%)
  5. Motor superaquecido (>90°C)
  6. Perda de comunicação (timeout 2s)

Comportamento​

Emergency Stop Sequence:
━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. [0ms] Parar todos comandos de movimento
2. [10ms] Ativar controle de estabilização MAX
3. [50ms] Tentar sit down controlado
4. [2000ms] Se não conseguiu sentar → Damping mode
5. [2100ms] Enviar log de erro

LED: Vermelho piscando rápido
Som: Beep contínuo (se alto-falante habilitado)

Recovery:

# Após emergency stop
if robot.get_mode() == 0:  # Damping
    print("Robot em emergency stop")

    # 1. Verificar causa
    errors = robot.get_errors()
    print(f"Erros: {errors}")

    # 2. Resolver problema (ex: bateria)

    # 3. Clear errors
    robot.clear_errors()

    # 4. Stand up novamente
    robot.stand_up()  # → Preparation mode

📊 Monitoramento de Estado​

Dashboard em Tempo Real​

# monitor.py
import time
import os

def monitor_robot_state():
    while True:
        os.system('clear')

        mode = robot.get_mode()
        mode_names = ['DAMPING', 'PREPARATION', 'MOVEMENT', 'ERROR']

        print("═" * 50)
        print(f"  UNITREE G1 STATUS MONITOR")
        print("═" * 50)
        print(f"Mode:    [{mode}] {mode_names[mode]}")
        print(f"Battery:  {robot.battery.soc}% ({robot.battery.voltage:.1f}V)")
        print(f"Speed:    {robot.get_speed():.2f} m/s")
        print(f"Position: ({robot.x:.2f}, {robot.y:.2f})")
        print(f"IMU:      Pitch={robot.imu.pitch:.1f}° Roll={robot.imu.roll:.1f}°")
        print("═" * 50)

        # Estado dos motores (resumido)
        temps = robot.get_motor_temperatures()
        max_temp = max(temps.values())
        avg_temp = sum(temps.values()) / len(temps)

        print(f"Motors:   Avg={avg_temp:.0f}°C Max={max_temp:.0f}°C")

        # Warnings
        if mode == 0 and robot.is_moving():
            print("⚠️  WARNING: Moving in DAMPING mode!")

        if max_temp > 80:
            print("⚠️  WARNING: Motor overheating!")

        if robot.battery.soc < 20:
            print("⚠️  WARNING: Low battery!")

        time.sleep(0.5)  # Update 2Hz

# Rodar
monitor_robot_state()

✅ Checklist de Conhecimento​

Após este módulo, você deve saber:

  • 3 modos: Damping (0), Preparation (1), Movement (2)
  • Damping = zero torque, movimentação manual segura
  • Preparation = em pé, pronto para comandos
  • Movement = caminhada/navegação ativa
  • Emergency stop → sempre retorna para Damping
  • Transições: L1+UP (stand up), START (walk), L2+R2 (e-stop)

🔗 Próximos Passos​

Próximo Módulo

🎯 Especificações vs Concorrentes →

G1 vs Tesla Optimus, Figure 01, Atlas - comparação técnica completa.

⏱️ Tempo de estudo: 40-50 minutos 📊 Nível: Intermediário 🎮 Hands-on: Testar transições de modos com RC ou API