Pular para o conteĂșdo principal

đŸ’» Computação Embarcada

Tier 1 - MĂłdulo 6⏱ 16 minutos📊 Fundamentos

🎯 O que vocĂȘ vai aprender​

Neste mĂłdulo, vocĂȘ vai entender os computadores dentro dos robĂŽs humanoides: desde microcontroladores que controlam motores atĂ© GPUs que processam visĂŁo computacional e IA.

🧠 A Arquitetura Computacional de um Humanoide​

Analogia com o CĂ©rebro Humano​

🧠

CĂłrtex (GPU/CPU Principal)

RaciocĂ­nio, visĂŁo, planejamento

Exemplo: NVIDIA Jetson Orin

🏃

Cerebelo (MCU de Controle)

Coordenação motora, equilíbrio

Exemplo: STM32, Cortex-M7

🩮

Nervos Periféricos (Drivers)

Controle direto de motores

Exemplo: ODrive, SimpleFOC

đŸ—ïž Arquitetura HierĂĄrquica​

Modelo de 3 Camadas​

┌─────────────────────────────────────┐
│ CAMADA 1: Computação de Alto Nível  │
│ (High-Level Computer)               │
│ ‱ Visão computacional (IA)          │
│ ‱ Planejamento de trajetória        │
│ ‱ Tomada de decisão                 │
│ ‱ Interface com usuário             │
│                                     │
│ Hardware: Jetson Orin, PC embarcado │
│ OS: Ubuntu + ROS2                   │
│ FrequĂȘncia: 10-60 Hz                │
└──────────────┬──────────────────────┘
               │ Ethernet/USB
┌──────────────▌──────────────────────┐
│ CAMADA 2: Controle de Baixo Nível   │
│ (Real-Time Controller)              │
│ ‱ Controle de equilíbrio            │
│ ‱ Geração de torque                 │
│ ‱ Leitura de sensores (IMU, encoders)│
│ ‱ Segurança (emergency stop)        │
│                                     │
│ Hardware: MCU ARM Cortex-M7         │
│ OS: FreeRTOS ou bare-metal          │
│ FrequĂȘncia: 1000 Hz (1 kHz)         │
└──────────────┬──────────────────────┘
               │ CANbus/UART
┌──────────────▌──────────────────────┐
│ CAMADA 3: Drivers de Motor          │
│ (Motor Controllers)                 │
│ ‱ PWM para motores                  │
│ ‱ Leitura de encoder local          │
│ ‱ FOC (Field-Oriented Control)      │
│                                     │
│ Hardware: ESC, ODrive, driver integrado│
│ FrequĂȘncia: 20-50 kHz               │
└─────────────────────────────────────┘

đŸ’Ș Camada 1: Computação de Alto NĂ­vel​

OpçÔes de Hardware​

NVIDIA Jetson - O PadrĂŁo da IndĂșstria​

Por que Jetson domina em robĂłtica:

  • ✅ GPU integrada (aceleração de IA)
  • ✅ Baixo consumo (10-30W)
  • ✅ Compacto (cartĂŁo de crĂ©dito)
  • ✅ Ecossistema maduro (JetPack SDK)

Modelos DisponĂ­veis (2024):

ModeloGPURAMPreçoUso
Nano128 CUDA4 GB$99Hobby, protĂłtipos
Xavier NX384 CUDA8 GB$399Projetos médios
Orin Nano1024 CUDA8 GB$499Entry profissional
Orin NX1024 CUDA16 GB$799Profissional
Orin AGX2048 CUDA64 GB$1,999Top de linha

Unitree H1 usa: Jetson Orin (NX ou AGX, dependendo da configuração)

Capacidades:

# Performance em tarefas tĂ­picas (Orin AGX)
YOLOv8 (detecção de objetos): 120 FPS @ 1080p
Depth estimation: 60 FPS
SLAM (mapeamento): 30 FPS simultĂąneo

Consumo: 15-25W (modo performance)

⚡ Camada 2: Controlador Tempo-Real​

Por que MCU Separado?​

Problema do Linux:

Linux nĂŁo Ă© tempo-real:
  - Pode ter latĂȘncia de 1-10ms imprevisĂ­vel
  - Garbage collector pode pausar programa
  - Multitasking nĂŁo garante prioridade

Controle de equilĂ­brio precisa:
  - Loop de 1 kHz (1ms exato)
  - Zero jitter (variação)
  - Prioridade absoluta

Solução: Microcontrolador dedicado (MCU)

OpçÔes de MCU​

STM32 - O Mais Popular​

FamĂ­lia: ARM Cortex-M (ST Microelectronics)

Modelos Comuns:

STM32F4 (Entry):
  CPU: Cortex-M4 @ 168 MHz
  RAM: 192 KB
  Flash: 1 MB
  FPU: Sim (single precision)
  Preço: $5-10

STM32H7 (High-performance):
  CPU: Cortex-M7 @ 480 MHz
  RAM: 1 MB
  Flash: 2 MB
  FPU: Sim (double precision)
  Preço: $15-25

Por que Ă© popular:

  • ✅ FPU (cĂĄlculos de ponto flutuante rĂĄpidos)
  • ✅ Muitos timers (PWM)
  • ✅ CANbus integrado
  • ✅ DMA (transferĂȘncia sem CPU)

Exemplo de uso:

// Loop de controle a 1 kHz
void TIM2_IRQHandler() {  // Interrupção do timer
    // Ler IMU (via SPI)
    imu_data_t imu = read_imu();

    // Ler encoders (via GPIO)
    for (int i = 0; i < 21; i++) {
        joint_pos[i] = read_encoder(i);
    }

    // Calcular torque (controle de equilĂ­brio)
    compute_balance_control(imu, joint_pos, torque_output);

    // Enviar comandos via CANbus
    for (int i = 0; i < 21; i++) {
        can_send_torque(i, torque_output[i]);
    }
}

🚗 Camada 3: Drivers de Motor​

Controladores de Motor​

ODrive - O Favorito Open-Source​

O que Ă©: Driver de motor brushless (BLDC) com FOC

Modelos:

ODrive v3.6 (Original):
  Canais: 2 motores
  Corrente: 60A contĂ­nuo por canal
  TensĂŁo: 12-56V
  Interface: USB, UART, CANbus
  Encoder: Incremental, absoluto, Hall
  Preço: $120

ODrive Pro:
  Canais: 1 motor (mais compacto)
  Corrente: 90A contĂ­nuo
  TensĂŁo: 12-56V
  CANbus isolado
  Preço: $200

Por que Ă© Ăłtimo:

  • ✅ Open-source (firmware e hardware)
  • ✅ FOC (controle suave e eficiente)
  • ✅ Controle de posição/velocidade/torque
  • ✅ Documentação excelente

Exemplo de comando:

import odrive
odrv = odrive.find_any()

# Configurar modo torque
odrv.axis0.controller.config.control_mode = 1  # Torque

# Aplicar 2 N·m
odrv.axis0.controller.input_torque = 2.0

🔌 Comunicação Entre Camadas​

Protocolos​

ProtocoloVelocidadeDistĂąnciaUsoRobustez
CANbus1 Mbps40mMotores ↔ MCU⭐⭐⭐⭐⭐
Ethernet1 Gbps100mJetson ↔ MCU⭐⭐⭐⭐
USB480 Mbps5mCùmeras, geral⭐⭐⭐
UART/Serial115 kbps15mDebug, sensores simples⭐⭐
SPI10+ Mbps0.3mIMU, encoder local⭐⭐⭐
I2C400 kbps1mSensores auxiliares⭐⭐

CANbus em Detalhes​

Por que CANbus domina em robĂłtica:

CaracterĂ­sticas:
✅ Diferencial (imune a ruĂ­do elĂ©trico)
✅ Multi-master (qualquer nó pode iniciar)
✅ Arbitração (sem colisĂ”es)
✅ CRC integrado (detecção de erro)
✅ Cabos longos (atĂ© 40m)

Topologia:
  MCU ←→ Motor1 ←→ Motor2 ←→ ... ←→ Motor21
  (Daisy-chain, nĂŁo estrela)

Velocidades tĂ­picas:
  250 kbps: AplicaçÔes automotivas
  500 kbps: RobĂłtica moderada
  1 Mbps: RobĂłtica de alta performance (Unitree)

Exemplo de mensagem CAN:

# Enviar comando de torque para motor ID=5
can_message = {
    'id': 0x05,  # Motor ID
    'data': [
        0x01,  # Comando: Set torque
        0x00, 0x64,  # Torque: 100 (0x0064) em escala
        0x00, 0x00, 0x00, 0x00, 0x00  # Padding
    ],
    'dlc': 8  # Data length
}
can.send(can_message)

📊 Arquiteturas Reais​

Unitree H1 (Estimado)​

┌─────────────────────────────────┐
│ Jetson Orin NX (16GB)           │ ← Visão, IA, ROS2
│ - RealSense D435i (USB)         │   30-60 Hz
│ - LIDAR (Ethernet)              │
└──────────┬──────────────────────┘
           │ Ethernet (UDP)
┌──────────▌──────────────────────┐
│ MCU Cortex-M7 (STM32H7 likely) │ ← Controle de equilíbrio
│ - IMU (SPI)                     │   1000 Hz
│ - Foot sensors (GPIO/ADC)       │
└──────────┬──────────────────────┘
           │ CANbus @ 1 Mbps
     ┌─────┮─────┬─────┬───── ... ─┬─────┐
     ▌           ▌     ▌            ▌     ▌
  [Motor1]   [Motor2] ...      [Motor21]
  Drivers integrados (QDD)

Tesla Optimus (Especulado)​

┌─────────────────────────────────┐
│ Tesla FSD Chip (Custom SoC)     │ ← IA, visão, tudo
│ - 8x Cñmeras                    │   Processamento
│ - Áudio                         │   integrado
└──────────┬──────────────────────┘   30-120 Hz
           │ Ethernet/Custom bus
┌──────────▌──────────────────────┐
│ MCU Secundário (backup/safety)  │ ← Emergency stop
└──────────┬──────────────────────┘   Watchdog
           │ CANbus
     ┌─────┮─────┬───── ... ─┐
     ▌           ▌            ▌
  [Motor1]   [Motor28]   [Torque sensors]
  Drivers custom Tesla

Diferencial: Chip Ășnico faz tudo (reduz latĂȘncia Jetson↔MCU)

🔋 Consumo de Energia​

Budget de PotĂȘncia​

ComponentePotĂȘncia (W)% do Total
Motores (movimento)200-100060-80%
Jetson Orin15-255-10%
MCU + Periféricos5-102-5%
Sensores (cĂąmeras, LIDAR)10-203-8%
Perdas (conversĂŁo DC/DC)20-505-10%
Total250-1105100%

Exemplo - H1 caminhando:

Bateria: 48V × 15Ah = 720 Wh
Consumo médio: 350W
Autonomia: 720 Wh / 350W = 2 horas

OtimizaçÔes:

  • ✅ Desligar Jetson quando parado (sĂł MCU ativo)
  • ✅ Undervolt GPU se IA nĂŁo estĂĄ rodando
  • ✅ Power gating de sensores nĂŁo usados

đŸ› ïž Montando Stack Computacional DIY​

Opção Econîmica ($200)​

Raspberry Pi 4 (8GB): $75
STM32F4 Discovery: $25
CĂąmera USB: $30
IMU MPU-6050: $5
CANbus transceiver MCP2515: $10
Fonte de alimentação 12V: $30
Cabos e proto-board: $25

Total: ~$200

O que dĂĄ para fazer:
  ✅ Controle de 6-10 servos
  ✅ Visão básica (OpenCV)
  ✅ ROS2 no Pi
  ❌ IA pesada

Opção Profissional ($1,500)​

Jetson Orin Nano (8GB): $500
STM32H7 Nucleo: $50
RealSense D435i: $300
RpLidar A1: $100
ODrive v3.6 (x2): $240
Bateria 48V 10Ah: $200
Cabos, conectores, case: $110

Total: ~$1,500

O que dĂĄ para fazer:
  ✅ SLAM em tempo real
  ✅ Detecção de objetos (YOLO)
  ✅ Controle de 4 motores BLDC
  ✅ Publicar papers!

💡 TendĂȘncias Futuras​

🧠

SoCs Integrados

Chips Ășnicos com CPU+GPU+NPU eliminando Jetson separado

⚡

Edge AI

Modelos de IA otimizados rodando em MCUs (TinyML)

📡

TSN (Time-Sensitive Networking)

Ethernet determinĂ­stico substituindo CANbus

🔋

Neuromorphic Chips

Intel Loihi, IBM TrueNorth - 1000x mais eficiente

🎓 Conceitos-Chave​

Lembre-se
  1. Hierarquia Ă© essencial: Linux para IA, MCU para controle, driver para PWM
  2. Tempo-real importa: 1ms de atraso = robĂŽ cai
  3. CANbus reina: Protocolo padrĂŁo para motores
  4. Jetson domina: NVIDIA tem ecossistema imbatĂ­vel em robĂłtica
VocĂȘ Sabia?

O Tesla Optimus nĂŁo usa ROS! Eles usam stack prĂłprio (mesma do carro). Mas 90% dos humanoides usam ROS2 por ser open-source e maduro.

🔗 Próximo Módulo​

Computadores precisam de energia. Vamos aprender sobre baterias e sistemas de potĂȘncia:

🔋 Módulo 7: Energia e Bateria →

🎯 Teste Seus Conhecimentos

Por que humanoides usam MCU separado ao invés de fazer tudo no Jetson?

Ver Resposta

Tempo-real! Linux no Jetson tem latĂȘncia imprevisĂ­vel (1-10ms). Controle de equilĂ­brio precisa de loop exato a 1kHz (1ms). MCU dedicado garante isso.

📚 Recursos