Pierwsze kroki z Git w Vitis IDE
Używanie Gita z nowym IDE „Unified Vitis”, opartym na VSCode, stwarza wyjątkowe wyzwania w porównaniu ze starszą wersją opartą na Eclipse. W najnowszej wersji brakuje kreatora projektów importu/eksportu, co powoduje trudności w skutecznym zarządzaniu kontrolą wersji.
Celem tego przewodnika jest omówienie problemów napotykanych podczas używania Git w Vitis, w tym obsługa wygenerowanych plików ze ścieżkami bezwzględnymi i zapewnienie płynnej współpracy pomiędzy różnymi systemami programistycznymi. Przyjrzymy się praktycznemu przepływowi pracy umożliwiającemu efektywne zarządzanie projektami Vitis za pomocą Git.
Komenda | Opis |
---|---|
import vitis | Importuje interfejs API Vitis w celu programowej interakcji z projektami Vitis. |
client.set_workspace() | Ustawia katalog obszaru roboczego dla klienta Vitis w celu zarządzania plikami projektu. |
client.create_platform_component() | Tworzy nowy komponent platformy w obszarze roboczym Vitis przy użyciu określonych parametrów sprzętu i systemu operacyjnego. |
platform.build() | Uruchamia proces kompilacji dla określonego komponentu platformy w Vitis. |
client.create_app_component() | Tworzy nowy komponent aplikacji powiązany z określonym komponentem platformy w Vitis. |
comp.import_files() | Importuje niezbędne pliki z katalogu źródłowego do komponentu aplikacji Vitis. |
os.makedirs() | Tworzy określoną strukturę katalogów, łącznie ze wszystkimi niezbędnymi katalogami nadrzędnymi. |
vitis -s tools/build_app.py | Uruchamia określony skrypt Pythona przy użyciu interfejsu wiersza poleceń Vitis w celu skonfigurowania projektu. |
echo "build-vitis/" >>echo "build-vitis/" >> .gitignore | Dodaje katalog kompilacji do pliku ignorowania Git, aby wykluczyć go z kontroli wersji. |
git commit -m | Zatwierdza etapowe zmiany w lokalnym repozytorium Git za pomocą określonego komunikatu zatwierdzenia. |
Wyjaśnienie skryptów automatyzacji Vitis
Pierwszy skrypt automatyzuje konfigurację projektu Vitis przy użyciu języka Python. Rozpoczyna się od zaimportowania niezbędnych modułów vitis I os. Następnie definiuje ścieżkę główną i tworzy katalog kompilacji, jeśli nie istnieje, używając os.makedirs(). Skrypt ustawia oczekiwane ścieżki dla pliku XSA i głównego katalogu źródłowego. Następnie tworzy klienta Vitis i ustawia obszar roboczy na nowo utworzony katalog kompilacji. Komponent platformy jest tworzony za pomocą client.create_platform_component(), określając konfigurację sprzętu, systemu operacyjnego i procesora. Po zbudowaniu komponentu platformy tworzony jest komponent aplikacji, który jest łączony z komponentem platformy. Na koniec niezbędne pliki są importowane do projektu Vitis i budowany jest komponent.
Drugi skrypt to skrypt powłoki, który inicjuje projekt Vitis i konfiguruje integrację z Git. Definiuje ścieżkę główną i katalog kompilacji, tworząc katalog, jeśli nie istnieje. Następnie skrypt uruchamia skrypt Pythona za pomocą vitis -s tools/build_app.py aby zautomatyzować konfigurację projektu. Po uruchomieniu skryptu Pythona skrypt powłoki konfiguruje repozytorium Git, przechodząc do katalogu głównego, inicjując Git za pomocą git initi dodanie katalogów kompilacji do pliku .gitignore plik. Tworzy odpowiednie pliki za pomocą git add i zatwierdza je w repozytorium za pomocą git commit -m. Takie podejście gwarantuje, że katalogi kompilacji zostaną wykluczone z kontroli wersji, jednocześnie śledząc niezbędne pliki projektu.
Automatyzacja konfiguracji projektu Vitis za pomocą języka Python
Skrypt Pythona do obsługi konfiguracji projektu Vitis i integracji z Git
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()
Zarządzanie kontrolą źródła w projektach Vitis
Skrypt powłoki usprawniający inicjalizację projektu Vitis i kontrolę źródła
#!/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
Zrozumienie Vitis IDE i kontroli wersji
Jednym z aspektów używania nowego IDE „Unified Vitis” z Git jest zrozumienie struktury i komponentów projektów Vitis. Vitis IDE generuje wiele plików, wiele ze ścieżkami bezwzględnymi, co komplikuje kontrolę wersji. Pliki te obejmują konfiguracje platformy, opisy sprzętu i metadane specyficzne dla IDE. Gdy te pliki są kontrolowane pod kątem wersji i nie są odpowiednio obsługiwane, programiści mogą napotkać problemy, takie jak błędy kompilacji spowodowane niedopasowanymi ścieżkami w różnych systemach.
Aby złagodzić te problemy, powszechną praktyką jest wykluczanie folderów zarządzanych przez Vitis z kontroli wersji. Zamiast tego kluczowe pliki konfiguracyjne, takie jak skrypty linkera, pliki CMake i inne istotne pliki projektu, są ręcznie kopiowane do odpowiednich lokalizacji oczekiwanych przez Vitis. Takie podejście zapewnia kontrolę wersji tylko niezbędnych plików, co zmniejsza ryzyko konfliktów i błędów podczas współpracy z innymi programistami. Dodatkowo użycie skryptów automatyzujących, takich jak Python lub skrypty powłoki, może usprawnić ten proces, zapewniając spójność i powtarzalność konfiguracji projektu i zarządzania plikami.
Często zadawane pytania i rozwiązania dotyczące używania Git z Vitis IDE
- Jak zainicjować repozytorium Git dla projektu Vitis?
- Możesz zainicjować repozytorium Git, przechodząc do katalogu głównego projektu i uruchamiając go git init. Dodaj niezbędne pliki do .gitignore aby wykluczyć niechciane pliki.
- Jakie pliki powinny znaleźć się w .gitignore dla projektu Vitis?
- Dołącz foldery specyficzne dla IDE, takie jak build-vitis/ I build-vivado/ aby uniknąć kontroli wersji automatycznie generowanych plików.
- Jak mogę zautomatyzować konfigurację projektu Vitis?
- Użyj skryptu Python, aby zautomatyzować zadania, takie jak tworzenie komponentów platformy i importowanie niezbędnych plików. Uruchom skrypt za pomocą vitis -s tools/build_app.py.
- Dlaczego muszę ręcznie kopiować pliki konfiguracyjne?
- Vitis oczekuje, że określone pliki konfiguracyjne będą znajdować się w określonych lokalizacjach. Kopiowanie tych plików ręcznie lub za pomocą skryptu gwarantuje, że IDE odnajdzie je poprawnie.
- Jak obsługiwać foldery platformy i aplikacji w Vitis?
- Wyklucz te foldery z kontroli wersji i użyj skryptów do zarządzania niezbędnymi plikami, zapewniając spójność i unikając konfliktów ścieżek.
- Czy mogę edytować pliki źródłowe bezpośrednio w Vitis podczas korzystania z Git?
- Tak, ale upewnij się, że konfiguracja CMake wskazuje prawidłowe katalogi źródłowe. Vitis może nie rozpoznać poprawnie dołączeń i nazw przy podświetlaniu składni.
- Jakie są zalety używania skryptów do konfiguracji projektu?
- Skrypty zapewniają spójną i powtarzalną konfigurację projektu, redukując błędy ręczne i upraszczając współpracę w różnych środowiskach.
- Jak mogę zaktualizować konfigurację projektu, jeśli zostaną wprowadzone zmiany?
- Zmodyfikuj skrypty automatyzacji, aby odzwierciedlić zmiany i uruchom je ponownie. Dzięki temu wszystkie niezbędne aktualizacje zostaną poprawnie zastosowane.
- Co powinienem zrobić, jeśli napotkam błędy kompilacji spowodowane problemami ze ścieżką?
- Sprawdź skrypty konfiguracyjne projektu i upewnij się, że wszystkie ścieżki zostały poprawnie określone. Jeśli to możliwe, używaj ścieżek względnych, aby uniknąć konfliktów.
Kluczowe punkty skutecznej kontroli wersji w Vitis IDE
Wdrożenie kontroli wersji za pomocą nowego Unified Vitis IDE obejmuje kilka kluczowych kroków. Zacznij od wykluczenia folderów wygenerowanych przez Vitis z kontroli wersji, aby uniknąć konfliktów i błędów. Zamiast tego skup się na śledzeniu niezbędnych plików konfiguracyjnych, takich jak skrypty linkera, pliki CMake i inne istotne komponenty projektu. Skrypty automatyzujące, szczególnie te napisane w języku Python, mogą znacznie usprawnić ten proces, automatyzując konfigurację projektu i zapewniając, że wszystkie niezbędne pliki znajdują się we właściwych lokalizacjach.
Automatyzując konfigurację, możesz zapewnić spójne środowisko programistyczne w różnych systemach, zmniejszając prawdopodobieństwo problemów związanych ze ścieżką. Takie podejście nie tylko upraszcza zarządzanie projektami, ale także ułatwia płynniejszą współpracę między programistami. Dodatkowo przechowywanie plików źródłowych w ich oryginalnych katalogach i używanie CMake do wskazywania tych katalogów pozwala na łatwiejszą edycję i kontrolę wersji, unikając jednocześnie zawiłości związanych z wewnętrznymi strukturami plików Vitis.
Podsumowanie przepływu pracy dla Vitis i Git
Integracja Gita z Unified Vitis IDE wymaga strategicznego podejścia do skutecznego zarządzania kontrolą wersji. Wykluczając foldery zarządzane przez Vitis i skupiając się na niezbędnych plikach konfiguracyjnych, programiści mogą uniknąć typowych pułapek związanych ze ścieżkami bezwzględnymi i metadanymi specyficznymi dla IDE. Skrypty automatyzacji dodatkowo usprawniają ten proces, zapewniając powtarzalną i spójną konfigurację projektu. Strategie te zapewniają, że projekty Vitis będą łatwe w zarządzaniu i oparte na współpracy, nawet w złożonych środowiskach programistycznych.