Visão AI com o Kit Inicial de Visão AI Kria KV260

Ari Mahpour
|  Criada: Novembro 18, 2024
Visão AI com o Kit Inicial de Visão AI Kria KV260

Em Introdução ao Kit Inicial de Visão AI Kria KV260, desembalamos e exploramos o Kit Inicial de Visão AI Kria KV260 da AMD Xilinx. Esta placa nos oferece um FPGA e processador ARM poderosos o suficiente para rodar uma distribuição completa do Ubuntu. Neste artigo, vamos construir e executar a aplicação SmartCam usando uma câmera Raspberry Pi. Esta aplicação será capaz de detectar rostos em tempo real e demonstrar isso no monitor do seu computador.

Por Que Escrevi Este Tutorial

Este tutorial segue o tutorial original montado pela equipe da AMD Xilinx. Você notará que grande parte deste tutorial é muito semelhante (se não igual) ao deles. Minha reação inicial a este tutorial foi me sentir sobrecarregado. Tenho um conhecimento razoavelmente bom em design de FPGA, mas seguir seus tutoriais, passo a passo, às vezes pode ser desafiador e um pouco assustador. Eu estava procurando algo um pouco mais direto e simples de seguir. Depois de analisar outros tutoriais reescritos, não fiquei muito satisfeito com o que encontrei; por isso, decidi escrever o meu próprio.

Se você está procurando todos os detalhes sórdidos, eu recomendo fortemente que você revise o tutorial original. Existem alguns passos que não são super claros, mas eu tento passar por eles (ou até mesmo contorná-los) neste tutorial. Mais importante, no momento em que este artigo foi escrito, a aplicação SmartCam de exemplo não parecia funcionar com o firmware mais recente. No meu repositório bifurcado, eu criei scripts automatizados (e até mesmo os arquivos finais de flash necessários) para fazer sua demonstração funcionar sem problemas. Com este tutorial em mãos, espero que você consiga mergulhar em IA em alvos de hardware o mais rápido possível e experimentar aquele momento de "uau" que eu tive após conseguir iniciar a demonstração com sucesso.

Pré-requisitos de Hardware

Você precisará, é claro, do Kria KV260 Vision Starter Kit da AMD Xilinx. Você precisará configurar sua placa, e isso pode ser feito seguindo meu tutorial anterior, Getting Started with the Kria KV260 Vision AI Starter Kit. Você também precisará de um Raspberry Pi Camera Module V2. A parte V2 é super importante. Eu tentei sem sucesso rodar a demonstração com a versão mais barata V1 da câmera e outras câmeras genéricas (e posso atestar que elas não funcionam com esta demonstração). Você precisará conectar o cabo flat da câmera à porta J9 na placa. Por último, você precisará de um monitor (ou TV) compatível com HDMI para conectar ao seu kit KV260 (e cabo HDMI, é claro).

Pré-requisitos de Software

Antes de começar com a demonstração, você precisa ter tanto o Docker quanto o exemplo SmartCam instalados no seu dispositivo Kria KV260 (mesmo que não vamos usar a aplicação SmartCam). Você também precisará do Xilinx Vitis (a instalação completa) versão 2022.1. Note que o número da versão do Xilinx Vitis é muito importante, pois este tutorial foi construído especificamente para essa versão.

Você pode instalar o Docker usando o método Convenience Script. Para fazer isso, abra um terminal e execute as seguintes linhas:

curl -fsSL https://get.docker.com -o get-docker.sh

sudo sh ./get-docker.sh --dry-run

sudo usermod -aG docker $USER

Para instalar o pacote da aplicação SmartCam, execute o seguinte comando no terminal:

sudo apt install -y xlnx-firmware-kv260-smartcam

Você também precisará clonar meu fork do repositório original:

git clone --recursive --branch rpi-camera-demo-clean

https://github.com/amahpour/kria-vitis-platforms.git

Executando a Construção

Para tornar as coisas o mais simples possível, escrevi um script automatizado que executa o processo de construção automaticamente. Você não precisará seguir as capturas de tela no tutorial original para atualizar os designs de bloco ou alterar qualquer código. Este tutorial tenta executar a construção sem ter que entrar na interface do usuário do Vitis. Para executar o script de construção, entre no seu repositório clonado e execute os seguintes comandos:

cd kv260

./build_demo.sh

Note que este script foi escrito pensando no Linux. Se você estiver usando o Windows, eu recomendo fortemente que configure o WSL 2 com Ubuntu e instale o Xilinx Vitis lá (em vez de no Windows).

Se você receber um erro dizendo que o Vivado não pode ser encontrado, provavelmente esqueceu de carregar as configurações da Xilinx. Basta executar este comando:

source /tools/Xilinx/Vivado/2022.1/settings64.sh

Executar o script build_demo.sh vai completamente contornar todo o tutorial porque incluí o design de bloco atualizado, o arquivo de restrição de pinos e as configurações do projeto na pasta kv260/extras/ do repositório. Se você quiser seguir o tutorial passo a passo, recomendo fortemente dar uma olhada no original.

Se tudo ocorreu corretamente, você deve acabar com um arquivo bitstream localizado em

kv260/overlays/examples/smartcam/binary_container_1/link/int/kv260-raspi-dpu.bit.bin.

O processo de construção pode levar entre 1-2 horas. Nem todos têm tempo para isso, então eu incluí o arquivo bitstream na pasta kv260/extras/ como um backup.

Executando a Demonstração

Neste ponto, estamos prontos para copiar nossos arquivos para a placa KV260 e executar a demonstração. Você pode transferir arquivos via um pen drive USB ou através do comando SCP (cópia segura). Você precisará transferir os seguintes arquivos:

  • kv260/extras/kv260-raspi-dpu.bit.bin (ou o gerado mencionado acima)
  • kv260/extras/kv260-raspi-dpu.dtbo
  • kv260/extras/kv260-raspi-dpu.xclbin

Uma vez de volta ao seu dispositivo KV260, precisamos mover esses arquivos para a seção da biblioteca onde o firmware é tipicamente carregado:

sudo mkdir /lib/firmware/xilinx/kv260-raspi-dpu

sudo mv kv260-raspi-dpu.bit.bin /lib/firmware/xilinx/kv260-raspi-dpu/

sudo mv kv260-raspi-dpu.dtbo /lib/firmware/xilinx/kv260-raspi-dpu/

sudo mv kv260-raspi-dpu.xclbin /lib/firmware/xilinx/kv260-raspi-dpu/kv260-raspi-dpu.xclbin

sudo cp /lib/firmware/xilinx/kv260-smartcam/shell.json /lib/firmware/xilinx/kv260-raspi-dpu/

Agora, estamos prontos para iniciar a aplicação. Note que isso desligará o seu monitor, então você deve executar isso via SSH ou pela interface serial USB (ou seja, porta USB e usando PuTTY ou TeraTerm):

sudo xmutil listapps

sudo xmutil unloadapp

sudo xmutil loadapp kv260-raspi-dpu

sudo xmutil desktop_disable

docker run \

--env="DISPLAY" \

-h "xlnx-docker" \

--env="XDG_SESSION_TYPE" \

--net=host \

--privileged \

--volume="$HOME/.Xauthority:/root/.Xauthority:rw" \

-v /tmp:/tmp \

-v /dev:/dev \

-v /sys:/sys \

-v /etc/vart.conf:/etc/vart.conf \

-v /lib/firmware/xilinx:/lib/firmware/xilinx \

-v /run:/run \

-it xilinx/smartcam:latest bash

No contêiner Docker, precisaremos fazer uma pequena modificação em um arquivo. Isso exigirá que instalemos o vim primeiro:

apt-get update -y && apt-get install -y vim

vim /opt/xilinx/kv260-smartcam/share/vvas/facedetect/preprocess.json

Uma vez no vim, pressione "i" (para "inserir") para começar a editar o arquivo. Procure pela linha que aponta para um arquivo "xclbin" e atualize-a com este caminho:

/lib/firmware/xilinx/kv260-raspi-dpu/kv260-raspi-dpu.xclbin

Pressione a tecla escape. Digite ":wq" (para salvar e sair), depois pressione enter. Após isso, podemos executar a aplicação com o seguinte comando (muito longo):

gst-launch-1.0 mediasrcbin name=videosrc media-device=/dev/media0  v4l2src0::io-mode=mmap v4l2src0::stride-align=256 !  video/x-raw, largura=1920, altura=1080, formato=NV12, framerate=30/1  ! tee name=t ! queue ! vvas_xmultisrc kconfig="/opt/xilinx/kv260-smartcam/share/vvas/facedetect/preprocess.json" ! queue ! vvas_xfilter kernels-config="/opt/xilinx/kv260-smartcam/share/vvas/facedetect/aiinference.json" ! ima.sink_master                     vvas_xmetaaffixer name=ima ima.src_master ! fakesink t. ! queue max-size-buffers=1 leaky=2 ! ima.sink_slave_0 ima.src_slave_0 ! queue ! vvas_xfilter kernels-config="/opt/xilinx/kv260-smartcam/share/vvas/facedetect/drawresult.json"          ! queue ! kmssink driver-name=xlnx plane-id=39 sync=false fullscreen-overlay=true

Se tudo funcionou corretamente, seu monitor (ou TV) deve ligar novamente com o feed da sua câmera Raspberry Pi. Ele colocará uma caixa azul ao redor de qualquer rosto que detectar no feed de vídeo em tempo real.

Conclusão

Neste artigo, revisamos o tutorial do SmartCam com a Câmera Raspberry Pi e observamos os atalhos necessários para "simplesmente fazer funcionar". Neste ponto, você deve agora ter seu próprio SmartCam em funcionamento no Kria KV260, detectando rostos em tempo real. Meu objetivo era simplificar o processo para que você possa focar mais na diversão de ver a IA em ação, em vez de se atrapalhar com o tutorial original. Espero que este guia tenha tornado as coisas mais claras e rápidas para você, a fim de obter aquele momento de "isso funciona". Agora, é a sua vez de ser criativo e explorar o que mais você pode fazer com este poderoso kit inicial.

Nota: Todo o código para este projeto pode ser encontrado em este repositório.

Sobre o autor

Sobre o autor

Ari is an engineer with broad experience in designing, manufacturing, testing, and integrating electrical, mechanical, and software systems. He is passionate about bringing design, verification, and test engineers together to work as a cohesive unit.

Recursos relacionados

Documentação técnica relacionada

Retornar a página inicial
Thank you, you are now subscribed to updates.