Pular para o conteúdo principal

🧠 Software e Inteligência Artificial

Tier 1 - Módulo 8⏱️ 22 minutos📊 Fundamentos

🎯 O que você vai aprender​

Neste módulo, você vai descobrir o cérebro digital dos humanoides: ROS2, visão computacional, aprendizado por reforço, modelos de linguagem e como IA está revolucionando robótica.

🏗️ Stack de Software​

Arquitetura em Camadas​

┌─────────────────────────────────────┐
│ CAMADA 5: Aplicação                 │
│ - Missões/Tarefas (pegar caixa)     │
│ - Interface com humano              │
└──────────────┬──────────────────────┘
               ↓
┌─────────────────────────────────────┐
│ CAMADA 4: Cognição/IA               │
│ - GPT-4 (linguagem natural)         │
│ - YOLO (detecção de objetos)        │
│ - Planejamento de trajetória        │
└──────────────┬──────────────────────┘
               ↓
┌─────────────────────────────────────┐
│ CAMADA 3: Middleware (ROS2)         │
│ - Pub/Sub de dados                  │
│ - SLAM, navegação                   │
│ - Controle de movimentos            │
└──────────────┬──────────────────────┘
               ↓
┌─────────────────────────────────────┐
│ CAMADA 2: Drivers                   │
│ - Interface com sensores/motores    │
│ - RealSense, LIDAR, CANbus          │
└──────────────┬──────────────────────┘
               ↓
┌─────────────────────────────────────┐
│ CAMADA 1: Sistema Operacional       │
│ - Ubuntu 22.04                      │
│ - Kernel Linux (drivers)            │
└─────────────────────────────────────┘

🤖 ROS2 (Robot Operating System 2)​

O que é ROS2?​

Definição: Framework open-source para desenvolvimento de software de robôs

NÃO é um sistema operacional, é uma camada de middleware sobre Linux.

📡

Comunicação

Publish/Subscribe entre processos

📦

Pacotes

Milhares de bibliotecas prontas (SLAM, navegação, etc)

🛠️

Ferramentas

Visualização (RViz), simulação (Gazebo), debug

🌐

Ecossistema

Comunidade gigantesca, suporte industrial

Conceitos Fundamentais​

Nodes - Processos Independentes​

O que é: Programa que executa uma tarefa específica

Exemplo de arquitetura:

┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ camera_node  │───▶│ vision_node  │───▶│ planner_node │
│ (publica     │    │ (detecta     │    │ (decide onde │
│  imagens)    │    │  objetos)    │    │  ir)         │
└──────────────┘    └──────────────┘    └──────────────┘
        │                                        │
        ▼                                        ▼
┌──────────────┐                        ┌──────────────┐
│  imu_node    │                        │ control_node │
│ (orientação) │───────────────────────▶│ (move robô)  │
└──────────────┘                        └──────────────┘

Vantagens:

  • ✅ Cada node pode crashar sem derrubar sistema todo
  • ✅ Desenvolvimento paralelo (times diferentes trabalham em nodes diferentes)
  • ✅ Reutilização (node de câmera funciona em qualquer robô)

ROS2 vs ROS1​

CaracterísticaROS1 (2007-2020)ROS2 (2017-hoje)
ComunicaçãoCustom TCPDDS (padrão industrial)
Tempo-real❌ Não✅ Sim (com RTOS)
Segurança❌ Nenhuma✅ Encriptação, autenticação
MultiplataformaSó LinuxLinux, Windows, macOS, RTOS
Python2.73.6+
StatusFim de vida 2025Ativo

Todos os humanoides novos usam ROS2 (Unitree, Figure, Apollo, etc.)

👁️ Visão Computacional​

Pipeline de Visão​

┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
│ Câmera   │──▶│ Pré-     │──▶│ Detecção │──▶│ Decisão  │
│ (1080p   │   │ processa-│   │ (IA)     │   │ (o que   │
│  30 FPS) │   │ mento    │   │          │   │  fazer)  │
└──────────┘   └──────────┘   └──────────┘   └──────────┘
                    │              │
                    ▼              ▼
              [Resize,       [YOLO, SAM,
               Denoise,       Depth Est]
               Calibração]

Tarefas Comuns​

Object Detection - YOLO​

O que faz: Identifica e localiza objetos em imagem

Modelo popular: YOLOv8

from ultralytics import YOLO

model = YOLO('yolov8n.pt')  # Nano (rápido)
results = model(image)

for detection in results[0].boxes:
    class_id = detection.cls
    confidence = detection.conf
    bbox = detection.xyxy  # [x1, y1, x2, y2]

    if class_id == 39:  # Classe "garrafa"
        print(f"Garrafa detectada em {bbox} com {confidence:.2f}")

Performance no Jetson Orin:

YOLOv8n (Nano): 120 FPS @ 640x480
YOLOv8s (Small): 80 FPS
YOLOv8m (Medium): 45 FPS
YOLOv8l (Large): 25 FPS

Uso em humanoide:

  • "Pegue a garrafa azul na mesa" → YOLO detecta garrafa

🧠 Inteligência Artificial​

Tipos de IA em Humanoides​

🎯

Supervised Learning

Treina com exemplos rotulados

Uso: Classificação de objetos

🎮

Reinforcement Learning

Aprende por tentativa/erro

Uso: Locomoção, manipulação

🤝

Imitation Learning

Copia demonstrações humanas

Uso: Tarefas complexas

💬

Large Language Models

Entende linguagem natural

Uso: Interface com humano

Reinforcement Learning (RL)​

Como Funciona​

Analogia: Ensinar cachorro com petiscos

Estado (State):
  - Posição de todas as juntas
  - Velocidades
  - Orientação do tronco (IMU)
  - Alvo a alcançar

Ação (Action):
  - Torque aplicado em cada junta
  - Exemplo: [10, -5, 20, ...] N·m

Recompensa (Reward):
  - +1: Se robô andou para frente
  - -10: Se robô caiu
  - +100: Se alcançou objetivo

Objetivo:
  Maximizar recompensa acumulada

Processo:

1. Robô tenta andar (ação aleatória)
2. Cai (recompensa -10)
3. IA ajusta: "Torque no tornozelo deve ser maior"
4. Tenta novamente...
5. Após milhões de tentativas: Aprende a andar

Foundation Models (LLMs + VLMs)​

GPT-4, Claude, etc. em Humanoides​

Como integram:

Humano: "Robô, pegue a garrafa azul que está na mesa e traga para mim"
         ↓
┌────────────────────────────┐
│ LLM (GPT-4)                │
│ Entende intenção:          │
│ 1. Localizar mesa          │
│ 2. Identificar garrafa azul│
│ 3. Planejar caminho        │
│ 4. Executar pick & place   │
│ 5. Navegar até humano      │
└────────┬───────────────────┘
         ↓
    ROS2 Actions
    (walk_to, pick_object, etc.)

Exemplo real - Figure 02 + OpenAI:

# Integração via API
import openai

def process_command(speech_text, image):
    prompt = f"""
    Você é um robô humanoide. O humano disse: "{speech_text}"
    Imagem atual: [imagem da câmera]

    Gere uma sequência de ações ROS2 para executar.
    """

    response = openai.ChatCompletion.create(
        model="gpt-4-vision",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": prompt},
                {"type": "image_url", "image_url": image}
            ]
        }]
    )

    actions = parse_actions(response['choices'][0]['message']['content'])
    execute_actions(actions)

Vantagens:

  • ✅ Interface natural (fala, não código)
  • ✅ Raciocínio complexo (LLM planeja passos)
  • ✅ Contexto (lembra conversas anteriores)

Desafios:

  • ❌ Latência (API call = 1-3s)
  • ❌ Alucinação (LLM pode gerar ação impossível)
  • ⚠️ Requer validação de segurança

🗺️ SLAM e Navegação​

SLAM (Simultaneous Localization and Mapping)​

Problema: Robô em ambiente desconhecido precisa:

  1. Saber onde está (localização)
  2. Construir mapa (mapeamento)

Paradoxo: Para mapear, precisa saber posição. Para saber posição, precisa ter mapa!

Solução: SLAM faz ambos simultaneamente

Tipos de SLAM​

Entrada: Scans de LIDAR 2D/3D

Algoritmos populares:

  • Cartographer (Google): Usado em robôs do Alphabet
  • SLAM Toolbox: ROS2 nativo
  • LIO-SAM: LIDAR + IMU fusion

Output:

  • Mapa 2D (occupancy grid)
  • Posição do robô (x, y, θ)

Precisão: 1-5 cm

🛠️ Ferramentas de Desenvolvimento​

Simuladores​

SimuladorFísicaGráficosROS2GPUIdeal para
Isaac Sim⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐✅NVIDIARL, visão
Gazebo⭐⭐⭐⭐⭐⭐⭐✅OpcionalROS dev
MuJoCo⭐⭐⭐⭐⭐⭐⭐⚠️SimRL research
PyBullet⭐⭐⭐⭐⭐⚠️SimPrototipagem
Webots⭐⭐⭐⭐⭐⭐⭐⭐✅NãoEducação

Visualização - RViz2​

O que é: Ferramenta ROS2 para visualizar dados do robô em 3D

Mostra:

  • Modelo 3D do robô (URDF)
  • Nuvem de pontos (LIDAR)
  • Câmeras
  • Trajetórias planejadas
  • Mapa (SLAM)

Screenshot típico:

┌─────────────────────────────────────┐
│ [Modelo 3D do H1]  [Nuvem LIDAR]   │
│                                     │
│ Juntas coloridas   Obstáculos em   │
│ por torque         vermelho         │
│                                     │
│ [Mapa 2D]          [Trajetória]    │
│ Grid ocupado       Caminho planejado│
└─────────────────────────────────────┘

💡 Tendências Futuras​

🌐

Modelos Foundation para Robótica

"ChatGPT para robôs" - Um modelo que controla qualquer humanoide

🔄

Fleet Learning

Milhares de robôs compartilham aprendizado (como Tesla FSD)

🧬

IA Neuromórfica

Chips que imitam cérebro (1000x mais eficiente)

🤖

End-to-End Learning

Câmera → IA → Controle de motor (sem programação manual)

🎓 Conceitos-Chave​

Lembre-se
  1. ROS2 é padrão da indústria - Aprenda se quiser trabalhar com humanoides
  2. RL domina locomoção - Milhões de tentativas em simulador
  3. LLMs são o futuro da interface - "Fale com o robô" ao invés de programar
  4. Sim-to-Real funciona - Domain randomization é chave
Você Sabia?

O Boston Dynamics Atlas aprendeu a fazer backflip com RL! Mas levou 100 milhões de iterações em simulação (equivalente a 278 anos de tentativas contínuas se fosse no robô real).

🔗 Próximo Módulo​

Agora vamos ver onde tudo isso é aplicado no mundo real:

🏭 Módulo 9: Aplicações Práticas →

🎯 Teste Seus Conhecimentos

Por que treinar RL em simulação ao invés do robô real?

Ver Resposta

3 razões: 1) Velocidade - simulador roda 100-1000x mais rápido que tempo real, 2) Segurança - robô não quebra/machuca ninguém, 3) Custo - não precisa de hardware físico.

📚 Recursos