Rodando em um Raspberry Pi 5

O Raspberry Pi 5 é a placa de referência do NoWayOS: de baixo custo, fácil de encontrar, e a placa em que rodam os seus primeiros testes de hardware. Um sistema que passa no QEMU é verificado no Pi com o mesmo arquivo expect, a partir do log serial da placa.

Duas regras para a placa. Nunca conecte um adaptador serial de 5 V à UART do Pi: ela é uma porta de 3,3 V. E nunca programe a memória OTP (programável uma única vez) do Pi nem ative a inicialização segura numa placa de desenvolvimento: as duas coisas são irreversíveis. make sdcard recusa um config.txt que faça qualquer uma delas, ou que altere a tensão da placa.

Do que você precisa

Monte o cartão SD

make sdcard BOARD=rpi5b_2gb SYSTEM=hello

Isso grava a partição de boot do cartão em build/rpi5b_2gb/hello/sdcard/: o U-Boot, a device tree e os overlays, o config.txt, a imagem seL4 loader.img, os arquivos de licença e um SHA256SUMS para verificar o cartão depois. O U-Boot é compilado a partir do código-fonte no contêiner, de forma reproduzível.

Grave o cartão

No macOS

1. Encontre o cartão com diskutil list: ele aparece como external, physical, com o tamanho do cartão. O próximo passo apaga esse disco inteiro, então confira o número duas vezes.
2. Formate-o com o rótulo PIBOOT:

diskutil eraseDisk FAT32 PIBOOT MBRFormat /dev/diskN

3. Copie os arquivos e verifique se cada um chegou intacto (isto não imprime nada quando todos conferem):

cp -RX build/rpi5b_2gb/hello/sdcard/ /Volumes/PIBOOT/
dot_clean -m /Volumes/PIBOOT
(cd /Volumes/PIBOOT && shasum -a 256 -c SHA256SUMS | grep -v ': OK$')

4. Ejete-o com diskutil eject /dev/diskN e coloque-o no Pi.

No Linux

Os mesmos passos, com as ferramentas do Linux (os cartões do próprio projeto são feitos no macOS):

1. Encontre o cartão com lsblk -p: um disco do tamanho do cartão, como /dev/sdX ou /dev/mmcblk0. O próximo passo apaga esse disco inteiro, então confira o nome duas vezes e desmonte qualquer partição dele.
2. Crie nele uma única partição FAT32, com o rótulo PIBOOT (com dosfstools e parted instalados):

sudo parted --script /dev/sdX mklabel msdos mkpart primary fat32 1MiB 100% set 1 lba on
sudo mkfs.vfat -F 32 -n PIBOOT /dev/sdX1

3. Copie os arquivos e verifique se cada um chegou intacto (isto não imprime nada quando todos conferem):

sudo mount /dev/sdX1 /mnt
sudo cp -r build/rpi5b_2gb/hello/sdcard/. /mnt/
(cd /mnt && sha256sum -c SHA256SUMS | grep -v ': OK$')
sudo umount /mnt

4. Coloque-o no Pi.

Conecte o console serial

Conecte o Debug Probe ao conector de depuração dedicado de 3 pinos do Pi 5, entre as portas HDMI, e não aos pinos GPIO. Ele opera a 115200 baud, 8N1. O probe aparece num Mac como /dev/cu.usbmodem… e no Linux como /dev/ttyACM0 ou algo parecido (o seu usuário precisa estar no grupo dialout).

Comece a capturar antes de ligar o Pi, um boot por log:

mkdir -p build/rpi5b_2gb/hello
(stty 115200 raw -echo; cat) < /dev/cu.usbmodemXXXX | tee build/rpi5b_2gb/hello/serial.log

Mantenha a configuração e a leitura num único comando, como aqui: no macOS, uma segunda abertura da porta volta para 9600 baud. No Linux, configure a porta com stty -F /dev/ttyACM0 115200 raw -echo e leia-a com cat /dev/ttyACM0. Pare com Ctrl-C depois da última linha esperada.

Ao ligar, o U-Boot faz uma contagem regressiva de três segundos e depois inicializa o loader.img do cartão. Para parar no prompt dele, digite stopboot durante a contagem. (Só essa palavra o interrompe, então o ruído que uma linha serial desconectada capta nunca consegue prender um dispositivo no U-Boot.)

Verifique o log

Verifique o log da placa com o arquivo expect do sistema, pelas mesmas regras com que a saída do QEMU é verificada:

make check-serial SYSTEM=hello LOG=build/rpi5b_2gb/hello/serial.log

Acrescente BOARD=rpi5b_2gb para um sistema que tenha um arquivo expect próprio para o Pi.

Rode sistemas sem ninguém por perto

Com o probe conectado, make pi-run roda uma série de sistemas na placa sem precisar trocar o cartão e sem ninguém junto à placa. Rode-o na sua própria máquina, não no contêiner (num Mac, a máquina virtual do Podman não enxerga dispositivos seriais USB). Ele precisa de Python 3.11 ou posterior ali, só com a biblioteca padrão:

make pi-run PI_DEVICE=/dev/cu.usbmodemXXXX PI_SYSTEMS="hello ipc-demo isolation-test"

Para cada sistema, ele compila a imagem no contêiner, reinicia a placa, envia a imagem pela linha serial e verifica se ela chegou intacta, arma o watchdog da placa e a inicia. Cada log é verificado à medida que chega, e o watchdog reinicia a placa para o próximo. Cada comando que ele digita é ecoado de volta e conferido antes de ser enviado. Os logs ficam em build/rpi5b_2gb/pi-run/.

Acompanhe a interface de usuário

Com o monitor conectado antes de ligar:

make pi-run PI_DEVICE=/dev/cu.usbmodemXXXX PI_SYSTEMS=ui-demo PI_WATCHDOG=15

executa a sessão roteirizada da interface de usuário na tela HDMI e verifica um hash de cada quadro. Para deixar um sistema rodando para uma pessoa acompanhar, sem watchdog, use make pi-show PI_DEVICE=… SYSTEM=ui-demo; ele roda até a placa ser desligada e religada.

Quando algo falha

Volte para a última imagem que funcionou e verifique de novo a linha serial e a cadeia de boot antes de mudar mais de uma coisa por vez. Se nada aparecer antes do U-Boot, confira a configuração BOOT_UART do bootloader e enable_uart=1 no config.txt do cartão antes de suspeitar do probe ou da fiação.