Como programar a Raspberry Pi Pico no Linux

No artigo "Como programar a Raspberry Pi Pico" vimos o ambiente de compilação montado no Raspberry Pi 4. Sem dúvidas é a maneira mais prática, já que tudo está sendo feito pelo script de automação do processo, criado pela própria organização. Mas não é tão mais trabalhoso assim configurar outros ambientes, como o desktop. Nesse artigo veremos como preparar o ambiente para programar a Raspberry Pi Pico no Linux.

Instalando os pacotes

Vamos começar pelo óbvio: instalando os pacotes necessários. Praticamente já tenho tudo, pois desenvolvo para diversas plataformas diferentes, mas vou repetir o processo para escrever o artigo.

Baixe o SDK e os exemplos

Tem 2 repositório extras que não são fundamentais, nem 100% funcionais, mas que contêm recursos que podem ser interessantes. São os últimos dois clones da lista abaixo, e são opcionais.

No home do usuário, crie o diretório pico e faça os respectivos clones dentro dele:

cd
mkdir pico
cd pico
git clone -b master https://github.com/raspberrypi/pico-sdk.git
cd pico-sdk
git submodule update --init
cd ..
git clone -b master https://github.com/raspberrypi/pico-examples.git 
git clone https://github.com/raspberrypi/pico-extras.git
git clone https://github.com/raspberrypi/pico-playground.git

Para adicionar o pico-extras ao projeto, podemos adicionar o caminho via variável de ambiente com PICO_EXTRAS_PATH ou através do cmake:

cmake_minimum_required(VERSION 3.12)

# Pull in PICO SDK (must be before project) include(pico_sdk_import.cmake)

# We also need PICO EXTRAS 
include(pico_extras_import.cmake) 

project(pico_playground C CXX)
set(CMAKE_C_STANDARD 11) 
set(CMAKE_CXX_STANDARD 17)

Outra opção é fazer a compilação passando o parâmetro:

-DPICO_SDK_POST_LIST_DIRS=/path/to/pico_extras ao cmake.

Instalar a toolchain

Hora de preparar o ambiente de compilação. Os binários geradores em uma máquina para outro tipo de máquina são chamados de "cross-compiling". No caso, vamos compilar binários para ARM Cortex-M0, por isso precisamos do conjunto necessário de ferramentas.

sudo apt-get update
sudo apt install cmake gcc-arm-none-eabi libnewlib-arm-none-eabi build-essential libstdc++-arm-none-eabi-newlib

Compilando o blink

O teste inicial sempre é necessário para comprovar que está tudo ok. Por mais que pareça bobo, não deixe de testar.

Entre no diretório pico-examples e faça essa sequência:

cd pico-examples
mkdir build
cd build
export PICO_SDK_PATH=../../pico-sdk

Agora prepare o cmake assim:

cmake ..

Que deve resultar em uma saída semelhante a essa:

Para habilitar o debug, use o cmake assim:

cmake .. -DCMAKE_BUILD_TYPE=Debug

Depois compile o programa blink:

cd blink
make

Se tiver múltiplos processadores, por exemplo, 8 núcleos, você pode executar a compilação com make -j8 ou com o número de processadores que desejar dedicar à tarefa de compilação.

O resultado da compilação criará o arquivo blink.elf que utilizaremos para depuração com GDB, de forma semelhante ao mostrado nesse artigo e também mostrado em detalhes nesse vídeo.

O outro arquivo importante gerado é o blink.uf2, que é o programa a ser arrastado para o Raspberry Pi Pico, quando em modo de dispositivo de massa. Se não fez nada ainda com Raspberry Pi Pico, permita-me explicar brevemente:

Conecte a Raspberry Pi Pico ao computador enquanto mantém pressionado o botão BOOTSEL da placa. Após conectado, o Raspberry Pi Pico deve aparecer no sistema como se fosse um pendrive. Arrastando o arquivo blink.ef2 para dentro desse dispositivo fará com que a RP Pico reinicie já no modo normal, com seu novo programa. Ainda assim, ejete o dispositivo do sistema, apesar de nesse momento não estar mais acessível como dispositivo de massa.

Se pretende montar o ambiente em uma Raspberry Pi 4, ou se pretende fazer o processo por linha de comando, recomendo, além do artigo supracitado, o vídeo "Configurando o SDK da Raspberry Pi Pico".

Botão para reset

Já citei no artigo e no vídeo, mas sempre é bom enfatizar que, como descrito no documento oficial, podemos adicionar um botão do pino RUN ao GND.

No artigo recém-publicado, mostrei como configurar GPIO e serial na RP Pico. É uma leitura fundamental para quem está iniciando com essa placa.

Interface SWD para flashing

Serial Wire Debug (SWD) é um padrão de interface do Cortex-M, que dá ao computador de desenvolvimento o poder de resetar, carregar código para a flash e fazer o código rodar na placa externa como se fosse um programa local - o que nos permite fazer a depuração, como no vídeo que exemplifico usando um Cortex-M3 (a BluePill, no caso).

Usando essa interface, temos algumas vantagens:

• Não precisamos desconectar, reconectar, subir o firmware toda a vez que fizermos uma compilação
• Podemos testar o código e vê-lo funcionando, invés de fazer N compilações até chegar no código funcional.
• Podemos depurar o código sem inserir uma enormidade de prints no nosso código.

Compilando o OpenOCD

Dentro do diretório ~/pico, proceda com a sequência de comandos:

sudo apt-get install automake autoconf build-essential texinfo libtool libftdi-dev libus
b-1.0-0-dev
git clone https://github.com/raspberrypi/openocd.git --recursive --branch rp2040 --depth
=1
cd openocd
./bootstrap
./configure --enable-ftdi --enable-sysfsgpio --enable-bcm2835gpio
make -j8
sudo make install

Ao fim do configure podemos ver uma série de dispositivos suportados para debug com o openOCD. Entre eles, o link desse artigo.

Após o comando make install, o programa openocd deverá estar disponível a partir do terminal.

SWD Wiring

Se fez o setup para Raspberry Pi 4 descrito nesse artigo, pode querer utilizar os GPIO da própria Raspberry para debug. A documentação descreve o SWDIO na GPIO24 e o SWCLK no GPIO25. Simples assim.

A alimentação por USB pode ser feita sem problemas, só não faça pelo pino e pela USB.

Flashing com OpenOCD

Esse é o exemplo básico do carregamento de um programa com OpenOCD:

openocd -f interface/raspberrypi-swd.cfg -f target/rp2040.cfg -c "program blink/blink.elf
 verify reset exit"

Debug com GDB

As interfaces do OpenOCD estão dentro do diretório openocd/tcl/interface. Nesse diretório você poderá ver todas as possibilidades de interface disponíveis.

Para outras placas que não a rp2040, olhe dentro do diretório openocd/tcl/target.

O exemplo da documentação mostra a conexão ao RP Pico a partir da Raspberry fazendo o papel de SWD:

openocd -f interface/raspberrypi-swd.cfg -f target/rp2040.cfg

A saída desse comando deve retornar mensagens de info:

…
 Info : rp2040.core0: hardware has 4 breakpoints, 2 watchpoints
 Info : rp2040.core1: hardware has 4 breakpoints, 2 watchpoints
 Info : starting gdb server for rp2040.core0 on 3333
 Info : Listening on port 3333 for gdb connections

Agora já podemos iniciar o GDB de uma das diversas maneiras:

#carrega o arquivo elf
gdb-multiarch hello_serial.elf
#conecta ao OpenOCD
target remote localhost:3333
#iniciar o debug
monitor reset init
continue
#adicionar breakpoint
b funcao
continue
#avançar 1 step
n

Assista o vídeo mostrando o debug, caso não conheça ainda o recurso.

Vimos como programar a Raspberry Pi Pico no Linux. No próximo artigo relacionado veremos como configurar o VS Code para programar o Raspberry Pi Pico usando Linux x86. Se Pretende programar a Raspberry Pi Pico a partir de uma Raspberry Pi 4, leia esse artigo.

Onde comprar Raspberry Pi Pico?

Claro, na Robocore! Aproveite o preço tentador e já compre logo duas. Tem coisa pra fazer com duas, ainda escreverei a respeito, se ninguém kibar a ideia!

Revisão: Ricardo Amaral de Andrade

Inscreva-se no nosso canal Manual do Maker no YouTube.

Também estamos no Instagram.