🍓 Raspberry Pi 5 e Linux

Uma imagem de câmera em 640 × 480 tem mais de 900 mil números (três cores por pixel), e chegam dezenas delas por segundo. O ESP32 tem memória para guardar só algumas dessas imagens e não roda as bibliotecas de visão que você vai usar. O Raspberry Pi 5 é um computador inteiro do tamanho de um cartão de crédito: processador de quatro núcleos, gigabytes de memória, sistema Linux, Python e OpenCV. Ele cuida de ver e decidir; o ESP32 continua cuidando dos motores.

Como ler: a seta ciano é larga em dados (a imagem inteira); a seta roxa leva só uma frase curta. Essa assimetria é o desenho de quase todo robô com visão: o computador digere a imagem e o microcontrolador recebe apenas a ordem. Você monta essa ligação no módulo 3.5.

Por que aprender

Saber o que cada placa faz bem evita os dois erros clássicos desta etapa: tentar fazer visão no microcontrolador (não cabe) e ligar motor direto no Pi (treme, atrasa e às vezes queima um pino). O Pi 4 ainda serve para o básico deste módulo; para câmera com detector de objetos, o Pi 5 é a escolha.

Conceitos-chave

Dentro do robô o Pi não terá tela nem teclado. Por isso você o prepara no modo "headless" (sem cabeça): grava o sistema no cartão pelo Raspberry Pi Imager, já deixando nome, usuário, Wi-Fi e SSH configurados, e depois acessa tudo pela rede, do seu computador. O sistema é o Raspberry Pi OS 64-bit, hoje baseado no Debian "Trixie". Para robô, a versão Lite (sem área de trabalho) é mais leve; se preferir ver uma área de trabalho no começo, use a versão completa.

Como ler: os três quadros roxos acontecem com o cartão e a placa; o ciano é o seu computador falando com o Pi. Se o passo 4 falhar, quase sempre o erro está no passo 1 (senha do Wi-Fi digitada errada ou SSH desligado).

Passo a passo

Objetivo: entrar no Pi pela rede e deixar o sistema atualizado. Troque <seu_usuario> pelo usuário criado no Imager.

# 1) No SEU computador: entrar no Pi (na primeira vez, responda "yes")
ssh <seu_usuario>@robo.local

# 2) Já dentro do Pi: atualizar a lista de pacotes e o sistema
sudo apt update
sudo apt full-upgrade -y

# 3) Conferir o que está rodando
cat /etc/os-release | grep PRETTY_NAME   # deve citar Debian e "trixie"
uname -m                                # aarch64 = sistema 64-bit
hostname -I                             # endereço IP do Pi na rede

# 4) Reiniciar para aplicar atualizações do núcleo
sudo reboot

Por que aprender

Um Pi preparado do jeito certo liga no robô e aparece na rede sozinho. Configurar tudo no Imager poupa o monitor, o teclado e as tentativas de editar arquivos de configuração à mão, que é onde muita gente trava no começo.

Conceitos-chave

No robô você vai conversar com o Pi quase só pelo terminal: uma linha de texto onde cada comando é uma palavra curta seguida de opções. Não precisa decorar dezenas deles. Com uns quinze você navega pelas pastas, edita o código, instala pacotes e descobre por que algo parou.

Como ler: à esquerda, a raiz e três pastas do sistema; à direita, o que você mesmo vai criar dentro da sua pasta pessoal. Mantenha seus arquivos sempre em ~: assim nada do sistema é tocado sem querer.

Objetivo: criar a pasta do curso, escrever um arquivo, conferir o espaço livre e desligar o Pi do jeito seguro.

mkdir -p ~/robo && cd ~/robo        # cria a pasta (se não existir) e entra nela
pwd                                 # mostra /home/<seu_usuario>/robo
echo "robo pronto" > notas.txt       # cria um arquivo com uma linha
cat notas.txt                       # mostra o conteúdo
ls -l                               # lista com tamanho e data
df -h /                             # espaço livre no cartão
free -h                             # memória total e em uso

# Desligar com segurança (espere o LED verde apagar antes de tirar a energia)
sudo shutdown -h now

Por que aprender

Todo o resto da trilha (câmera, YOLO26, comunicação com o ESP32) e a Trilha 4 inteira (ROS 2) acontecem no terminal. Quem domina esses comandos resolve sozinho "o cartão encheu", "o programa travou" e "onde salvei aquele arquivo".

Conceitos-chave

Se você tentar pip install direto no Raspberry Pi OS, vai ver o erro externally-managed-environment. Não é defeito: o sistema protege o Python que ele mesmo usa. A saída certa é criar um ambiente virtual (venv) para o robô. Um detalhe importante no Pi: crie o venv com --system-site-packages, para que ele enxergue as bibliotecas que vêm instaladas pelo sistema, como a picamera2 (câmera) e a gpiozero (pinos).

Como ler: o venv (roxo) fica em cima do Python do sistema (ciano). A seta mostra que, com a opção --system-site-packages, o venv "enxerga para baixo" e acha a câmera e os pinos; sem ela, import picamera2 falha dentro do venv.

Objetivo: criar o venv do curso, ativá-lo, instalar um pacote e provar que ele enxerga as bibliotecas do sistema.

# Criar o ambiente (uma vez só)
python3 -m venv --system-site-packages ~/robo-venv

# Ativar (toda vez que abrir um terminal novo)
source ~/robo-venv/bin/activate      # o prompt ganha "(robo-venv)" na frente

# Instalar pacotes DENTRO do venv (sem sudo)
pip install --upgrade pip
pip install numpy

# Testar: versão do Python e bibliotecas do sistema visíveis
python -c "import sys; print(sys.prefix)"
python -c "import gpiozero, picamera2; print('gpiozero e picamera2 OK')"

# Sair do venv quando quiser
deactivate

Por que aprender

OpenCV, Ultralytics e pyserial, que você usa nos próximos módulos, entram todos por esse venv. Fazer certo agora evita o problema mais comum de visão no Pi: "a câmera funciona no terminal, mas o meu script não acha a biblioteca".

Conceitos-chave

O Pi 5 tem uma fileira dupla de 40 pinos, como o ESP32 tem os dele. Alguns entregam energia (3,3 V, 5 V e GND); a maioria é GPIO, pinos que o seu programa liga, desliga ou lê. Em Python, a biblioteca gpiozero transforma isso em objetos simples: LED(17), Button(27). No robô, o GPIO do Pi serve para LEDs de status, um botão de parada e a serial com o ESP32; motores ficam com o ESP32.

Como ler: o retângulo é o começo do conector, visto de cima, com o pino 1 no canto (quadrado na placa). Vermelho é energia, cinza é GND, roxo é o GPIO que você vai usar. O botão vai no pino 13, logo abaixo do 11, e no GND do pino 14 ao lado.

Objetivo: piscar um LED de status e acender o LED fixo enquanto o botão estiver apertado. Ligue: GPIO17 (pino 11) → resistor 330 Ω → perna longa do LED; perna curta → GND (pino 9). Botão entre GPIO27 (pino 13) e GND (pino 14). Com o venv ativado, salve como ~/robo/led.py.

# LED de status e botão no Raspberry Pi 5 com gpiozero
# Rode com: python ~/robo/led.py   (Ctrl+C para sair)
from gpiozero import LED, Button
from signal import pause

led = LED(17)                       # número BCM: GPIO17 = pino físico 11
botao = Button(27, bounce_time=0.05) # GPIO27 = pino 13; pull-up interno ligado

def apertou():
    led.on()
    print("botão apertado: LED aceso")

def soltou():
    led.blink(on_time=0.2, off_time=0.8)  # volta a piscar em segundo plano
    print("botão solto: LED piscando")

botao.when_pressed = apertou
botao.when_released = soltou
soltou()                            # estado inicial: piscando
print("Pronto. Aperte o botão. Ctrl+C para sair.")
pause()                             # mantém o programa vivo esperando eventos

Por que aprender

O pino de 3,3 V é o mesmo cuidado do ESP32, mas o erro custa mais caro: um Pi 5 queimado sai bem mais caro que um ESP32. E a gpiozero, com eventos como when_pressed, é o jeito mais simples de colocar um botão físico de parada no robô, que você vai usar no projeto 3.6.

Conceitos-chave

Na bancada, o Pi 5 usa a fonte oficial de 27 W (5 V, 5 A, USB-C). Com fonte mais fraca ele funciona, mas limita a corrente das portas USB e pode reiniciar quando a câmera e a IA puxam carga ao mesmo tempo. No robô não há tomada: a bateria passa por um regulador buck que entrega 5 V estáveis com folga de corrente. E rodando visão, o processador esquenta: sem o cooler ativo, ele reduz a velocidade sozinho para se proteger, e o seu detector fica mais lento sem aviso.

Como ler: a energia (âmbar) sai da bateria e se divide antes de chegar a qualquer placa. O ramo de cima, com o buck em destaque, é o que mantém o Pi estável. O tracejado cinza lembra que os GND de todas as placas precisam estar ligados entre si.

Objetivo: acompanhar temperatura e alertas de energia enquanto o robô trabalha. Salve como ~/robo/saude.py e deixe rodando num segundo terminal durante os testes de visão.

# Monitor de saúde do Pi 5: temperatura e alertas de energia/calor
import subprocess, time

def temperatura():
    with open("/sys/class/thermal/thermal_zone0/temp") as f:
        return int(f.read()) / 1000          # vem em milésimos de grau

def alertas():
    saida = subprocess.run(["vcgencmd", "get_throttled"],
                           capture_output=True, text=True).stdout
    valor = int(saida.strip().split("=")[1], 16)
    msgs = []
    if valor & 0x1:     msgs.append("SUBTENSÃO AGORA")
    if valor & 0x4:     msgs.append("limitado AGORA")
    if valor & 0x10000: msgs.append("houve subtensão desde o boot")
    if valor & 0x40000: msgs.append("houve limitação desde o boot")
    return msgs or ["energia OK"]

while True:
    t = temperatura()
    aviso = "  QUENTE: confira o cooler" if t > 75 else ""
    print(f"{time.strftime('%H:%M:%S')}  {t:.1f} °C  {', '.join(alertas())}{aviso}")
    time.sleep(2)

Por que aprender

A maioria dos "bugs" de visão em robô começa aqui: o Pi reinicia quando o robô acelera, ou o detector cai pela metade de velocidade depois de alguns minutos. Medir temperatura e subtensão separa problema de energia de problema de código, e poupa você de procurar erro no lugar errado.

Conceitos-chave