Guia para usar Git com Unified Vitis IDE

Introdução ao Git no Vitis IDE

Usar o Git com o novo IDE "Unified Vitis", baseado em VSCode, apresenta desafios únicos em comparação com a versão mais antiga baseada em Eclipse. O assistente de importação/exportação do projeto está ausente na versão mais recente, causando dificuldades no gerenciamento eficaz do controle de versão.

Este guia tem como objetivo abordar os problemas encontrados ao usar o Git no Vitis, incluindo o tratamento de arquivos gerados com caminhos absolutos e a garantia de uma colaboração tranquila entre diferentes sistemas de desenvolvimento. Exploraremos um fluxo de trabalho prático para gerenciar seus projetos Vitis de forma eficiente com Git.

Comando	Descrição
import vitis	Importa a API Vitis para interagir com projetos Vitis programaticamente.
client.set_workspace()	Define o diretório do espaço de trabalho para o cliente Vitis gerenciar arquivos de projeto.
client.create_platform_component()	Cria um novo componente de plataforma no espaço de trabalho Vitis usando parâmetros de hardware e sistema operacional especificados.
platform.build()	Aciona o processo de construção para o componente de plataforma especificado no Vitis.
client.create_app_component()	Cria um novo componente de aplicativo vinculado ao componente de plataforma especificado no Vitis.
comp.import_files()	Importa os arquivos necessários do diretório de origem para o componente do aplicativo Vitis.
os.makedirs()	Cria a estrutura de diretórios especificada, incluindo quaisquer diretórios pai necessários.
vitis -s tools/build_app.py	Executa o script Python especificado usando a interface de linha de comando Vitis para configurar o projeto.
echo "build-vitis/" >>echo "build-vitis/" >> .gitignore	Adiciona o diretório de construção ao arquivo ignorado do Git para excluí-lo do controle de versão.
git commit -m	Confirma as alterações preparadas no repositório Git local com uma mensagem de confirmação especificada.

Explicando os scripts de automação Vitis

O primeiro script automatiza a configuração de um projeto Vitis usando Python. Começa importando os módulos necessários, especificamente e . Em seguida, ele define o caminho raiz e cria o diretório de construção se ele não existir usando . O script configura os caminhos esperados para o arquivo XSA e o diretório de origem principal. Em seguida, ele cria um cliente Vitis e define o espaço de trabalho para o diretório de construção recém-criado. O componente da plataforma é criado com client.create_platform_component(), especificando a configuração de hardware, sistema operacional e CPU. Depois que o componente de plataforma é construído, um componente de aplicativo é criado e vinculado ao componente de plataforma. Por fim, os arquivos necessários são importados para o projeto Vitis e o componente é construído.

O segundo script é um shell script que inicializa o projeto Vitis e configura a integração do Git. Ele define o caminho raiz e o diretório de construção, criando o diretório se ele não existir. O script então executa o script Python usando para automatizar a configuração do projeto. Após a execução do script Python, o script shell configura um repositório Git navegando até o diretório raiz, inicializando o Git com e adicionando diretórios de compilação ao arquivo. Ele organiza os arquivos relevantes com git add e os envia para o repositório com . Essa abordagem garante que os diretórios de construção sejam excluídos do controle de versão, ao mesmo tempo que mantém os arquivos de projeto necessários rastreados.

import vitis
import os

ROOT_PATH = os.path.abspath(os.path.dirname(__file__))
VITIS_BUILD_DIR_PATH = os.path.join(ROOT_PATH, "build-vitis")
os.makedirs(VITIS_BUILD_DIR_PATH, exist_ok=True)
EXPECTED_XSA_FILE_PATH = os.path.join(ROOT_PATH, "build-vivado", "mydesign.xsa")
COMPONENT_NAME = "MyComponent"
MAIN_SRC_PATH = os.path.join(ROOT_PATH, "src")

client = vitis.create_client()
client.set_workspace(path=VITIS_BUILD_DIR_PATH)

PLATFORM_NAME = "platform_baremetal"
platform = client.create_platform_component(
    name=PLATFORM_NAME,
    hw=EXPECTED_XSA_FILE_PATH,
    os="standalone",
    cpu="mycpu"
)

platform = client.get_platform_component(name=PLATFORM_NAME)
status = platform.build()

comp = client.create_app_component(
    name=COMPONENT_NAME,
    platform=os.path.join(VITIS_BUILD_DIR_PATH, PLATFORM_NAME, "export", PLATFORM_NAME, f"{PLATFORM_NAME}.xpfm"),
    domain="mydomainname"
)

comp = client.get_component(name=COMPONENT_NAME)
status = comp.import_files(
    from_loc=MAIN_SRC_PATH,
    files=["CMakeLists.txt", "UserConfig.cmake", "lscript.ld", "NOTUSED.cpp"],
    dest_dir_in_cmp="src"
)

comp.build()

#!/bin/bash

ROOT_PATH=$(pwd)
VITIS_BUILD_DIR_PATH="$ROOT_PATH/build-vitis"
mkdir -p "$VITIS_BUILD_DIR_PATH"
EXPECTED_XSA_FILE_PATH="$ROOT_PATH/build-vivado/mydesign.xsa"
COMPONENT_NAME="MyComponent"
MAIN_SRC_PATH="$ROOT_PATH/src"

vitis -s tools/build_app.py

# After running the Python script, set up Git repository
cd "$ROOT_PATH"
git init
echo "build-vitis/" >> .gitignore
echo "build-vivado/" >> .gitignore
git add src/ tools/ .gitignore
git commit -m "Initial commit with project structure and scripts"

# Script end

Compreendendo o Vitis IDE e o controle de versão

Um aspecto do uso do novo IDE “Unified Vitis” com Git envolve a compreensão da estrutura e dos componentes dos projetos Vitis. O Vitis IDE gera vários arquivos, muitos deles com caminhos absolutos, o que complica o controle de versão. Esses arquivos incluem configurações de plataforma, descrições de hardware e metadados específicos do IDE. Quando esses arquivos são controlados por versão sem o tratamento adequado, os desenvolvedores podem enfrentar problemas como erros de compilação devido a caminhos incompatíveis em diferentes sistemas.

Para mitigar esses problemas, uma prática comum é excluir as pastas gerenciadas pelo Vitis do controle de versão. Em vez disso, arquivos de configuração cruciais, como scripts de vinculador, arquivos CMake e outros arquivos essenciais do projeto, são copiados manualmente para os locais apropriados esperados pelo Vitis. Essa abordagem garante que apenas os arquivos necessários sejam controlados por versão, reduzindo o risco de conflitos e erros ao colaborar com outros desenvolvedores. Além disso, o uso de scripts de automação como Python ou shell scripts pode agilizar esse processo, garantindo que a configuração do projeto e o gerenciamento de arquivos sejam consistentes e reproduzíveis.

1. Como inicializo um repositório Git para um projeto Vitis?
2. Você pode inicializar um repositório Git navegando até a raiz do projeto e executando . Adicione os arquivos necessários ao para excluir arquivos indesejados.
3. Quais arquivos devem ser incluídos no para um projeto Vitis?
4. Inclui pastas específicas do IDE como e para evitar arquivos gerados automaticamente com controle de versão.
5. Como posso automatizar a configuração de um projeto Vitis?
6. Use um script Python para automatizar tarefas como criação de componentes de plataforma e importação de arquivos necessários. Execute o script usando .
7. Por que preciso copiar os arquivos de configuração manualmente?
8. Vitis espera que certos arquivos de configuração estejam em locais específicos. Copiar esses arquivos manualmente ou via script garante que o IDE os encontre corretamente.
9. Como lidar com pastas de plataforma e aplicativos no Vitis?
10. Exclua essas pastas do controle de versão e utilize scripts para gerenciar os arquivos necessários, garantindo consistência e evitando conflitos de caminho.
11. Posso editar arquivos de origem diretamente no Vitis enquanto uso o Git?
12. Sim, mas certifique-se de que a configuração do CMake aponte para os diretórios de origem corretos. Vitis pode não reconhecer inclusões e nomes corretamente para realce de sintaxe.
13. Quais são os benefícios de usar scripts para configuração do projeto?
14. Os scripts garantem uma configuração de projeto consistente e repetível, reduzindo erros manuais e simplificando a colaboração em diferentes ambientes.
15. Como posso atualizar a configuração do meu projeto se forem feitas alterações?
16. Modifique seus scripts de automação para refletir as alterações e execute-os novamente. Isso garante que todas as atualizações necessárias sejam aplicadas corretamente.
17. O que devo fazer se encontrar erros de compilação devido a problemas de caminho?
18. Verifique os scripts de configuração do seu projeto e certifique-se de que todos os caminhos estejam especificados corretamente. Use caminhos relativos sempre que possível para evitar conflitos.

Pontos-chave para controle de versão eficiente no Vitis IDE

A implementação do controle de versão com o novo IDE Unified Vitis envolve várias etapas críticas. Comece excluindo as pastas geradas pelo Vitis do controle de versão para evitar conflitos e erros. Em vez disso, concentre-se no rastreamento de arquivos de configuração essenciais, como scripts de vinculador, arquivos CMake e outros componentes vitais do projeto. Os scripts de automação, especialmente aqueles escritos em Python, podem agilizar significativamente esse processo, automatizando a configuração do projeto e garantindo que todos os arquivos necessários estejam nos locais corretos.

Ao automatizar a configuração, você pode garantir um ambiente de desenvolvimento consistente em diferentes sistemas, reduzindo a probabilidade de problemas relacionados ao caminho. Essa abordagem não apenas simplifica o gerenciamento de projetos, mas também facilita uma colaboração mais tranquila entre os desenvolvedores. Além disso, manter os arquivos de origem em seus diretórios originais e usar o CMake para apontar para esses diretórios permite uma edição e controle de versão mais fáceis, evitando as complexidades de lidar com as estruturas internas de arquivos do Vitis.

A integração do Git com o IDE Unified Vitis requer uma abordagem estratégica para gerenciar o controle de versão de maneira eficaz. Ao excluir as pastas gerenciadas pelo Vitis e focar nos arquivos de configuração essenciais, os desenvolvedores podem evitar armadilhas comuns associadas a caminhos absolutos e metadados específicos do IDE. Os scripts de automação aprimoram ainda mais esse processo, fornecendo uma configuração de projeto consistente e repetível. Estas estratégias garantem que os projetos Vitis permaneçam gerenciáveis ​​e colaborativos, mesmo em ambientes de desenvolvimento complexos.