Pular para o conteúdo principal

🖥️ Sistema Computacional

Objetivo

Entender o computador embarcado do G1: Jetson Orin NX, arquitetura, ROS2, processamento de IA e otimizações.

🧠 NVIDIA Jetson Orin NX 16GB​

Arquitetura do SoM (System on Module)​

┌────────────────────────────────────────────────┐
│       NVIDIA Jetson Orin NX 16GB SOM           │
├────────────────────────────────────────────────┤
│  CPU: 8-core ARM Cortex-A78AE @ 2.0 GHz       │
│  ├─ 4x Big cores (high performance)            │
│  └─ 4x Little cores (energy efficient)         │
├────────────────────────────────────────────────┤
│  GPU: 1024-core NVIDIA Ampere                  │
│  ├─ 32 Tensor Cores (IA acelerada)             │
│  ├─ 8 RT Cores (raytracing - não usado)        │
│  └─ 100 TOPS (INT8) / 50 TFLOPS (FP16)         │
├────────────────────────────────────────────────┤
│  Memory: 16GB LPDDR5                            │
│  ├─ Bandwidth: 102 GB/s                        │
│  └─ Shared entre CPU/GPU (unified memory)      │
├────────────────────────────────────────────────┤
│  Storage: 64GB eMMC (sistema)                  │
│  └─ Slot NVMe M.2 para expansão (até 2TB)      │
├────────────────────────────────────────────────┤
│  Conectividade:                                 │
│  ├─ 2x GbE (Gigabit Ethernet)                  │
│  ├─ 4x USB 3.2                                 │
│  ├─ HDMI 2.1 (debug/desenvolvimento)           │
│  ├─ 3x MIPI CSI-2 (câmeras)                    │
│  ├─ 2x CAN Bus                                 │
│  └─ GPIO, I2C, SPI, UART                       │
├────────────────────────────────────────────────┤
│  Power: 10-25W (configurável)                  │
│  OS: Ubuntu 20.04 (JetPack 5.1.2)              │
└────────────────────────────────────────────────┘

Por Que Jetson Orin NX?​

100 TOPS de Performance

TOPS = Tera Operations Per Second (trilhões ops/seg)

# Exemplo: YOLO detection com GPU
import tensorrt as trt

# Modelo YOLO otimizado para Jetson
model = trt.load_engine('yolov8n_fp16.trt')

# Inference em uma imagem 1920x1080
frame = camera.read()
detections = model.infer(frame)  # ~3ms (333 FPS!)

# Mesmo modelo sem GPU: ~150ms (6 FPS)
# Aceleração: 50x mais rápido

Aplicações que Usam 100 TOPS:

  1. Visão Computacional (40 TOPS)

    • YOLO object detection
    • Pose estimation (detectar pessoas)
    • Depth estimation

  2. Navegação (30 TOPS)

    • SLAM (mapeamento simultâneo)
    • Path planning
    • Obstacle avoidance

  3. Controle (20 TOPS)

    • Modelo preditivo de estabilidade
    • Otimização de marcha em tempo real

  4. Reserva (10 TOPS)

    • Tarefas customizadas do usuário

🐧 Sistema Operacional​

Ubuntu 20.04 + JetPack 5.1.2​

O que vem instalado:

┌─ Base System ─────────────────────┐
│ Ubuntu 20.04.6 LTS (Focal Fossa)  │
│ Kernel: 5.10.104-tegra            │
│ Python: 3.8.10                    │
└───────────────────────────────────┘

┌─ NVIDIA JetPack 5.1.2 ────────────┐
│ CUDA 11.4                          │
│ cuDNN 8.6                          │
│ TensorRT 8.5.2                     │
│ VPI (Vision Programming Interface) │
│ DeepStream SDK 6.2                 │
└───────────────────────────────────┘

┌─ ROS & Robotics ──────────────────┐
│ ROS2 Humble (LTS)                  │
│ Gazebo 11                          │
│ MoveIt 2                           │
└───────────────────────────────────┘

┌─ AI Frameworks ───────────────────┐
│ PyTorch 1.13 (ARM + CUDA)          │
│ TensorFlow 2.11                    │
│ ONNX Runtime 1.14                  │
└───────────────────────────────────┘

Acesso ao Sistema​

Conectar via WiFi/Ethernet:

# G1 cria hotspot WiFi quando ligado
SSID: Unitree-G1-XXXX
Password: (fornecida com robô)

# IP padrão: 192.168.123.1

# SSH
ssh unitree@192.168.123.1
# Senha padrão: 123

# Trocar senha
passwd

Desenvolvimento Remoto:

# VS Code Remote SSH
# Instalar extensão: Remote - SSH

# .ssh/config
Host unitree-g1
    HostName 192.168.123.1
    User unitree
    ForwardX11 yes  # Para GUIs

# Conectar
code --remote ssh-remote+unitree-g1 /home/unitree/workspace

🤖 ROS2 Humble​

Arquitetura ROS2 no G1​

┌────────────────── ROS2 Nodes ──────────────────┐
│                                                 │
│  /camera_node → /camera/image_raw (topic)       │
│       ↓                                         │
│  /yolo_detector → /detections (topic)           │
│       ↓                                         │
│  /navigation → /cmd_vel (topic) → Motores       │
│                                                 │
└─────────────────────────────────────────────────┘

Nodes Principais do G1​

# Listar nodes ativos
ros2 node list

/lidar_node          # Publica point clouds
/camera_front_node   # Câmera principal
/camera_left_node    # Stereo esquerda
/camera_right_node   # Stereo direita
/imu_node            # IMU (acelerômetro + gyro)
/joint_state_node    # Posições de todos motores

Exemplo - Ler Câmera:

# Ver imagem (requer X11 forwarding)
ros2 run image_tools showimage --ros-args \
  -r image:=/camera/front/image_raw

# Salvar frame
ros2 run image_view image_saver --ros-args \
  -r image:=/camera/front/image_raw

⚡ Otimizações de Performance​

TensorRT - Otimização de Modelos IA​

Converter PyTorch → TensorRT:

import torch
import torch_tensorrt

# Modelo PyTorch original
model = torch.hub.load('ultralytics/yolov8', 'yolov8n')
model.eval().cuda()

# Converter para TensorRT
trt_model = torch_tensorrt.compile(
    model,
    inputs=[torch_tensorrt.Input(shape=[1, 3, 640, 640])],
    enabled_precisions={torch.float16},  # FP16 (2x mais rápido)
)

# Salvar
torch.jit.save(trt_model, 'yolov8n_fp16.ts')

Ganhos de Performance:

ModeloFrameworkPrecisionFPSLatência
YOLOv8nPyTorchFP321566ms
YOLOv8nPyTorchFP162835ms
YOLOv8nTensorRTFP161208ms
YOLOv8sTensorRTFP166016ms

Unified Memory - Zero-Copy​

Jetson usa memória compartilhada CPU↔GPU:

import cupy as cp  # NumPy-like para CUDA
import numpy as np

# ❌ Método tradicional (com cópia)
data_cpu = np.random.rand(1920, 1080, 3).astype(np.uint8)
data_gpu = cp.array(data_cpu)  # Copia CPU→GPU (lento!)

# ✅ Método Jetson (zero-copy)
import pycuda.driver as cuda

# Alocar em unified memory
data_unified = cuda.managed_empty(
    shape=(1920, 1080, 3),
    dtype=np.uint8,
    mem_flags=cuda.mem_attach_flags.GLOBAL
)

# CPU e GPU acessam MESMA memória
# Sem cópia, 10x mais rápido para grandes dados

Cooling e Throttling​

Monitorar Temperatura:

# Ver temperaturas
tegrastats

# Output:
# CPU@38.5°C GPU@42°C ...

Cooling Ativo:

G1 possui:
├─ 2x Ventiladores 40mm (torso)
├─ PWM controlado (0-100%)
└─ Trigger: <60°C = 100% fan

Configuração:
/etc/nvidia/nvfancontrol.conf

Evitar Thermal Throttling:

# Monitorar clock real vs max
import subprocess

def get_gpu_clock():
    result = subprocess.run(
        ['nvidia-smi', '--query-gpu=clocks.gr', '--format=csv,noheader,nounits'],
        capture_output=True,
        text=True
    )
    return int(result.stdout.strip())

clock = get_gpu_clock()
if clock < 900:  # Max: 918 MHz em mode MAXN
    print(f"⚠️ Throttling detectado! Clock: {clock} MHz")
    print("GPU muito quente, reduzir carga de trabalho")

📦 Expansão de Armazenamento​

Adicionar SSD NVMe​

Slot M.2 2280 disponível:

# Recomendado: Samsung 980 PRO 512GB
# Custo: ~$80

# 1. Instalar fisicamente (parafuso M2)
# 2. Formatar
sudo mkfs.ext4 /dev/nvme0n1

# 3. Montar automaticamente
sudo mkdir /mnt/nvme
echo "/dev/nvme0n1 /mnt/nvme ext4 defaults 0 2" | sudo tee -a /etc/fstab

# 4. Mover datasets/models para SSD
mv ~/datasets /mnt/nvme/
ln -s /mnt/nvme/datasets ~/datasets

Benefícios:

  • 📦 500GB+ espaço (vs 64GB eMMC)
  • ⚡ 3000 MB/s leitura (vs 300 MB/s eMMC)
  • 🎥 Gravar vídeos das câmeras
  • 💾 Armazenar logs/telemetria

✅ Checklist de Conhecimento​

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

  • Specs do Jetson Orin NX (8-core CPU, 1024 GPU cores, 16GB RAM)
  • O que são 100 TOPS e para que servem
  • Como conectar via SSH ao G1
  • ROS2 Humble é o middleware padrão
  • TensorRT otimiza modelos IA (8x speedup)
  • Como expandir armazenamento com NVMe

🔗 Próximos Passos​

Próximo Módulo

📡 Comunicação e Conectividade →

Redes, WiFi, 4G, API remota e multi-robô.

⏱️ Tempo de estudo: 50-60 minutos 📊 Nível: Intermediário-Avançado 💻 Hands-on: SSH ao G1, explorar ROS2 topics