Pași pentru configurare

Permisiuni sistem

Înainte de orice build trebuie setat parametrul kernel.apparmor_restrict_unprivileged_userns pentru a permite utilizarea namespace-urilor utilizator (nu sudo):

# Allow the user namespaces required by BitBake during the build.
sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0

# Retry the image build; completed tasks will be reused where possible.
petalinux-build

După terminarea build-ului/ activităților, permisiunile trebuie readuse la valorile implicite:

# Restore the host restriction after the build command finishes.
sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=1

Creearea unui proiect

Nici un build de imagine petalinux nu poate avea loc în afara unui proiect. Trebuie mai întâi creat un proiect:

Construirea și instalarea PetaLinux pe placa Arty Z7

Tutorial complet: de la o instalare Ubuntu goală până la un sistem Linux funcțional pe procesorul ARM al plăcii Arty Z7, pregatit pentru experimente de rețelistică.

Acest tutorial acoperă întregul proces: pregătirea gazdei, crearea design-ului hardware în Vivado, construirea imaginii Linux cu PetaLinux, scrierea pe cardul SD, pornirea plăcii și configurarea rețelei. Pașii și comenzile corespund versiunii 2025.2 a uneltelor AMD și unei gazde Ubuntu 24.04 LTS.

De citit mai întâi — decizii care economisesc timp

Alegeți o singură versiune și folosiți-o peste tot. Vivado, Vitis și PetaLinux trebuie să fie toate aceeași versiune (de exemplu, toate 2025.2). Fișierul hardware .xsa produs de Vivado versiunea X poate fi importat doar de PetaLinux versiunea X. Aceasta este cea mai frecventă cauză a construcțiilor eșuate pentru începători.

Ce placă aveți?

Arty Z7-20 → Zynq XC7Z020-1CLG400C
Arty Z7-10 → Zynq XC7Z010-1CLG400C
Fluxul de lucru este identic; schimbați doar componenta/preset-ul plăcii în Vivado.

Sistemul de operare gazdă: PetaLinux rulează doar pe Linux — nu există versiune de Windows. Folosiți Ubuntu 24.04 LTS (sau 22.04 / 20.04). Pe Windows, Mac sau altă distribuție Linux, rulați Ubuntu într-o mașină virtuală sau container.

Vivado poate rămâne pe Windows. Singurul lucru de care are nevoie PetaLinux de la Vivado este fișierul .xsa exportat, iar acel fișier este portabil între sisteme de operare. Astfel, o configurație frecventă (și mai ușoară) este: Vivado pe Windows pentru a construi hardware-ul și a exporta .xsa, apoi doar PetaLinux pe Ubuntu pentru a construi imaginea Linux.

Notă: Dacă aveți deja Vivado pe Windows, acea instalare fixează versiunea: instalați versiunea corespunzătoare de PetaLinux pe Ubuntu (de exemplu, Vivado 2025.2 pe Windows → PetaLinux 2025.2 pe Ubuntu).

Spațiu și timp: Dacă instalați Vivado pe Ubuntu, rezervați peste 100 GB liberi. Dacă Vivado rămâne pe Windows, partea de Ubuntu este mult mai ușoară. Prima construcție durează între 30 și 90 de minute, în funcție de mașină și de conexiune.

Ce construiți de fapt

Cipul Zynq-7000 de pe Arty Z7 este două lucruri într-unul singur:

PS (Processing System): procesor dual-core ARM Cortex-A9 plus periferice integrate (controler DDR3, MAC Gigabit Ethernet, UART, SD/MMC, USB). Aici rulează Linux.
PL (Programmable Logic): structura FPGA.

Chiar și un Linux „doar software” are nevoie de un design FPGA minimal, deoarece Vivado este cel care configurează PS-ul (care DDR, care pini pentru PHY-ul Ethernet, care UART etc.) și generează descrierea hardware .xsa pe care o consumă PetaLinux.

Lanțul de pornire pe care îl veți produce:

BootROM → FSBL → (bitstream) → U-Boot → kernel Linux (image.ub) → rootfs (EXT4 pe SD)
             \________________ totul împachetat în BOOT.BIN ________________/

Pentru rețelistică, blocul hardware esențial este MAC-ul Gigabit Ethernet din PS (GEM), conectat la PHY-ul Ethernet de pe placă. Odată activat în preset-ul PS, Linux obține automat o interfață eth0 cu DHCP.

Cerințe preliminare

Hardware:

Placa Arty Z7
Cablu microUSB (la conectorul PROG UART — acesta asigură JTAG, serial și alimentare)
Card microSD, clasa 10, 8–16 GB (recomandat SanDisk)
Cititor de card microSD pentru gazdă
Cablu Ethernet plus o rețea/switch cu DHCP (pentru experimentele voastre)

Software — pe mașina Ubuntu (gazda de construcție PetaLinux):

Ubuntu 24.04 (sau 22.04)
PetaLinux Tools (versiunea corespunzătoare cu Vivado)
Un terminal serial (PuTTY, minicom, screen, CoolTerm sau TeraTerm)
balenaEtcher (sau dd) pentru scrierea cardului SD
Un cont AMD/Xilinx (gratuit) pentru descărcarea uneltelor

Software — pentru design-ul hardware (oricare mașină):

Vivado — instalarea existentă pe Windows funcționează, sau instalați-l pe Ubuntu. Necesar doar pentru a construi și a exporta fișierul .xsa.

Instalarea uneltelor pe gazdă

Flux de lucru cu două mașini (recomandat dacă aveți deja Vivado pe Windows): Nu aveți nevoie de Vivado pe Ubuntu. Faceți Partea B (design hardware + export XSA) pe Vivado de pe Windows, apoi copiați un singur fișier .xsa pe mașina Ubuntu. Pe Ubuntu instalați doar PetaLinux — săriți peste pasul A.3. Singura regulă: versiunea de PetaLinux de pe Ubuntu trebuie să corespundă versiunii de Vivado de pe Windows.

Descărcarea fișierelor de instalare

De pe pagina de descărcări AMD, pentru versiunea aleasă:

PetaLinux Tools installer (petalinux-vX.X.X-*-installer.run) — întotdeauna necesar pe mașina Ubuntu.
AMD Unified Installer for FPGAs & Adaptive SoCs (conține Vivado + Vitis) — doar dacă veți rula Vivado pe această mașină Ubuntu. Săriți peste el dacă Vivado rămâne pe Windows.

Pregătirea gazdei Ubuntu

Instalați dependențele pentru build:

sudo apt update
sudo apt install -y \
  tofrodos iproute2 gawk xxd gcc git make net-tools libncurses5-dev \
  tftpd zlib1g-dev libssl-dev flex bison libselinux1 gnupg wget diffstat \
  chrpath socat xterm autoconf libtool tar unzip texinfo zlib1g-dev \
  gcc-multilib build-essential libsdl1.2-dev libglib2.0-dev screen pax \
  gzip cpio python3 python3-pip python3-pexpect python3-git python3-jinja2 \
  xz-utils debianutils rsync

Esențial: PetaLinux necesită ca /bin/sh să fie bash, dar Ubuntu îl setează implicit pe dash. Pe Ubuntu 24.04, metoda cu debconf poate să nu funcționeze; cea mai sigură cale este crearea directă a legăturii simbolice:

sudo ln -sf bash /bin/sh
ls -l /bin/sh    # trebuie să afișeze: /bin/sh -> bash

Configurați directorul TFTP pe care îl așteaptă PetaLinux (inofensiv chiar dacă nu folosiți TFTP):

sudo mkdir -p /tftpboot
sudo chmod -R 777 /tftpboot
sudo chown -R $USER:$USER /tftpboot

Pregătiri specifice pentru Ubuntu 24.04

Aceste două probleme blochează construcția pe Ubuntu 24.04 și trebuie rezolvate înainte de prima construcție.

Biblioteca libtinfo.so.5 lipsă. Unealta xsct din PetaLinux este legată de vechea bibliotecă ncurses5, pe care Ubuntu 24.04 nu o include. Instalați-o din arhiva Ubuntu:

cd /tmp
wget http://security.ubuntu.com/ubuntu/pool/universe/n/ncurses/libtinfo5_6.3-2ubuntu0.1_amd64.deb
sudo apt install ./libtinfo5_6.3-2ubuntu0.1_amd64.deb

Notă: Dacă acel nume de fișier dă eroarea 404, versiunea a fost actualizată — încercați libtinfo5_6.3-2ubuntu0.2_amd64.deb. Ambele oferă aceeași bibliotecă libtinfo.so.5.

Namespace-urile de utilizator restricționate de AppArmor. Ubuntu 24.04 restricționează namespace-urile de utilizator neprivilegiate, de care BitBake (motorul de construcție Yocto) are nevoie. Reactivați capabilitatea:

# Test imediat (se revine la restart):
sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0

# Pentru a face permanent:
echo "kernel.apparmor_restrict_unprivileged_userns=0" | sudo tee /etc/sysctl.d/60-apparmor-namespace.conf
sudo sysctl --system

Instalarea Vivado + Vitis (se omite dacă Vivado rămâne pe Windows)

chmod +x FPGAs_AdaptiveSoCs_Unified_2025.2_*.bin
./FPGAs_AdaptiveSoCs_Unified_2025.2_*.bin

În interfața grafică: autentificați-vă cu contul AMD, alegeți Vitis (instalează și Vivado), instalați în locația implicită /tools/Xilinx și permiteți instalarea driverelor pentru cablu.

Instalarea PetaLinux

Instalați ca utilizator obișnuit, niciodată cu sudo, într-un director propriu:

mkdir -p ~/petalinux
chmod +x petalinux-v2025.2-*-installer.run
./petalinux-v2025.2-*-installer.run --dir ~/petalinux
# Acceptați licențele când vi se cere

Nu încărcați PetaLinux permanent. Încărcați mediul în fiecare terminal, atunci când îl folosiți:

source ~/petalinux/settings.sh

Notă: Avertismentul „not a supported OS” pe Ubuntu 24.04 este inofensiv — este doar o nepotrivire a sub-versiunii. Ubuntu 24.04 LTS este oficial suportat.

Partea B — Crearea design-ului hardware (fișierul XSA)

Unde se rulează această parte: oriunde aveți Vivado — instalarea existentă de pe Windows este potrivită. Pașii sunt identici pe Windows și Linux; diferă doar calea fișierelor de placă. La final, veți copia un singur fișier .xsa pe mașina Ubuntu.

Instalarea fișierelor Digilent (o singură dată)

Acestea oferă lui Vivado un preset „Arty Z7” care conectează corect DDR, Ethernet, UART, SD și USB.

Descărcați depozitul Digilent vivado-boards de pe GitHub.
Copiați folderele new/board_files/* în directorul de fișiere de placă al lui Vivado:
- Linux: /tools/Xilinx/Vivado/2025.2/data/boards/board_files/
- Windows: C:\Xilinx\Vivado\2025.2\data\boards\board_files\
Reporniți Vivado pentru a le prelua.

Construirea unui design PS minimal

Deschideți Vivado — pe Windows, din meniul Start; pe Linux, încărcați mediul și rulați-l:

source /tools/Xilinx/Vivado/2025.2/settings64.sh
vivado &

Apoi, în interfața grafică Vivado:

Create Project → numiți-l artyz7_prj → proiect RTL, fără a specifica surse.
În Boards, selectați placa Arty Z7-20 (sau Z7-10).
Create Block Design (nume implicit design_1).
Apăsați + și adăugați ZYNQ7 Processing System.
Apăsați Run Block Automation → Apply Board Preset (acesta activează DDR3, Ethernet-ul Gigabit pe GEM, UART1, SD0, USB0 cu pinii corecți).
(Opțional, dar util) Adăugați un AXI GPIO conectat la LED-uri/butoane. Rulați Run Connection Automation: bifați atât S_AXI (controlul de la CPU), cât și GPIO, iar pentru GPIO alegeți interfața de placă (de exemplu leds_4bits) ca să se aplice automat constrângerile de pini.
În panoul Sources, clic dreapta pe design_1 → Create HDL Wrapper → Let Vivado manage wrapper.
Generate Bitstream (rulează automat sinteza și implementarea; necesar dacă ați adăugat logică PL precum AXI GPIO).

Exportul fișierului XSA

File → Export → Export Hardware
Alegeți Include bitstream (selectați dacă ați adăugat logică PL).
Notați unde scrie artyz7_prj.xsa.

Copierea fișierului XSA pe mașina Ubuntu

Dacă ați construit design-ul pe Windows, transferați doar fișierul .xsa pe Ubuntu — acel fișier este tot ce îi trebuie lui PetaLinux. Orice metodă funcționează: stick USB, folder partajat sau scp:

mkdir -p ~/artyz7_prj
scp utilizator@gazda-windows:/cale/catre/artyz7_prj.xsa ~/artyz7_prj/

Verificare versiune: confirmați că versiunea de Vivado de pe Windows care a produs acest .xsa corespunde versiunii de PetaLinux de pe Ubuntu. O nepotrivire este cea mai frecventă cauză a eșecului importului în Partea C.

Construirea (build) imaginii PetaLinux

Deschideți un terminal nou și încărcați mediul PetaLinux (nu Vivado) aici.

Crearea proiectului

source ~/petalinux/settings.sh
cd ~/artyz7_prj
petalinux-create -t project --template zynq -n linux_ws
cd linux_ws

Importarea descrierii hardware

Indicați directorul care conține fișierul .xsa (nu fișierul în sine):

petalinux-config --get-hw-description=../

Se va deschide un meniu de configurare (ncurses) populat automat din hardware-ul vostru.

Configurarea pornirii și a sistemului de fișiere

În meniu:

Image Packaging Configuration → Root filesystem type → schimbați din INITRD în EXT4 (SD/eMMC/SATA/USB). Astfel se obține un rootfs persistent pe cardul SD.
Confirmați că dispozitivul SD este /dev/mmcblk0p2, așa cum este detectat.
Salvați și ieșiți.

Adăugarea uneltelor de rețea în sistemul de fișiere

Deschideți configurația rootfs:

petalinux-config -c rootfs

În Petalinux Package Groups, activați packagegroup-networking-stack. Acesta include: ethtool, phytool, netcat, dnsmasq, iproute2, net-tools, iptables și rpcbind. Lăsați variantele -dbg și -dev dezactivate.

Pachetele de diagnostic tcpdump și iperf3 nu sunt în acel grup. Pentru a le adăuga (împreună cu un server SSH), editați fișierul de înregistrare a pachetelor utilizator:

nano project-spec/meta-user/conf/user-rootfsconfig

Adăugați aceste linii (prefixul CONFIG_ este obligatoriu aici):

CONFIG_tcpdump
CONFIG_iperf3
CONFIG_iputils

Salvați, apoi redeschideți petalinux-config -c rootfs, intrați în user packages și bifați pachetele noi (apăsați Y pe fiecare).

Serverul SSH (important): pentru acces de la distanță aveți nevoie de un server SSH. Dacă intenționați să folosiți VS Code Remote-SSH, alegeți OpenSSH (Dropbear nu este compatibil). Activați doar unul dintre ele.

⚠ Avertisment: Nu activați simultan dropbear și openssh — ele intră în conflict (ambele oferă un server SSH), iar construcția va eșua la pasul de asamblare a rootfs-ului cu un mesaj de tipul „package dropbear conflicts with openssh-sshd”. Alegeți unul singur.

Configurarea numelui interfeței de rețea (recomandat)

În mod implicit, udev redenumește interfața Ethernet din eth0 într-un nume bazat pe adresa MAC (de exemplu enx000a35001e53), iar scriptul de pornire eșuează să obțină o adresă IP automat. Pentru a păstra numele eth0, adăugați un argument de kernel:

petalinux-config

Navigați la DTG Settings → Kernel Bootargs. Lăsați „generate boot args automatically” activat și introduceți în câmpul „Add extra boot args”:

net.ifnames=0

Astfel, argumentul se adaugă la cele generate automat, fără a le rescrie. Salvați și ieșiți.

Construirea

petalinux-build

Prima construcție este cea mai lentă (30–90 de minute). Țineți conexiunea la internet activă — BitBake descarcă surse pe tot parcursul. Căutați mesajul final [INFO] Successfully built project. Dacă se oprește cu o eroare roșie ERROR:, notați calea log.do_* pe care o indică.

Împachetarea și scrierea cardului SD

Întâi, confirmați artefactele de construcție:

ls images/linux/

Ar trebui să vedeți zynq_fsbl.elf, system.bit, u-boot.elf, image.ub, boot.scr, system.dtb și rootfs.tar.gz.

Generarea binarului de pornire (BOOT.BIN)

petalinux-package --boot \
  --fsbl images/linux/zynq_fsbl.elf \
  --fpga images/linux/system.bit \
  --u-boot images/linux/u-boot.elf \
  --force

Notă: Pe versiunea 2025.2, dacă vreun parametru este respins, rulați petalinux-package --boot --help pentru sintaxa exactă a versiunii voastre.

Crearea imaginii SD (WIC)

petalinux-package --wic \
  --bootfiles "BOOT.BIN image.ub boot.scr system.dtb" \
  --rootfs-file images/linux/rootfs.tar.gz

Aceasta creează petalinux-sdimage.wic în images/linux/ — o imagine SD completă, cu două partiții (boot FAT + rootfs EXT4).

D.3 Scrierea pe card

Cu balenaEtcher (cea mai simplă metodă, recomandat pe Mac/Windows): deschideți balenaEtcher → Flash from file → selectați petalinux-sdimage.wic → selectați cardul SD → Flash. Aveți nevoie doar de acest singur fișier .wic; toate celelalte fișiere sunt deja incluse în el.

Notă (macOS): Dacă apare „The disk you inserted was not readable”, apăsați Ignore (nu Initialize sau Eject) — macOS nu poate citi partițiile ext4.

Cu dd (pe Linux), înlocuind /dev/sdX cu dispozitivul real (verificați cu lsblk):

sudo dd if=images/linux/petalinux-sdimage.wic \
  of=/dev/sdX bs=4M conv=fsync status=progress
sync

⚠ Avertisment: Verificați de două ori ținta of= înainte de a apăsa Enter — dd scrie fără avertizare pe orice dispozitiv indicați.

Pornirea plăcii

Poziționarea jumperelor

JP4 → SD: pornire de pe cardul SD.
JP5 → USB dacă alimentați prin portul PROG UART, sau REG dacă folosiți alimentatorul extern.

Conectarea și deschiderea unui terminal serial

Introduceți cardul SD, conectați cablul microUSB la portul PROG UART (acesta alimentează placa). Placa apare ca un port serial USB. Deschideți-l la 115200 8N1, fără control al fluxului.

Exemplu pe Linux:

sudo screen /dev/ttyUSB1 115200

Pe macOS (de exemplu cu CoolTerm sau screen), găsiți portul cu ls /dev/tty.usbserial*, apoi folosiți parametrii: Baudrate 115200, 8 biți de date, fără paritate, 1 bit de stop, fără control al fluxului (RTS/CTS și XON/XOFF dezactivate).

Sfat: Conectați-vă în terminalul serial înainte de a porni placa, ca să vedeți întreaga secvență de pornire de la primele mesaje FSBL.

Prima autentificare

Veți vedea bannerul FSBL, apoi U-Boot, apoi mesajele kernelului și, în final, un prompt de autentificare. Autentificați-vă ca utilizator petalinux — la prima pornire vi se va cere să setați o parolă.

Configurarea și verificarea rețelei

Conectați cablul Ethernet la un router sau switch cu DHCP, apoi:

ip link                 # vedeți interfața (eth0, dacă ați aplicat net.ifnames=0)
ethtool eth0            # confirmă starea legăturii, viteza/duplexul
ip addr show eth0       # verifică adresa IP
ping -c 3 8.8.8.8

Notă: Dacă nu ați aplicat net.ifnames=0, interfața va avea un nume de tipul enx000a35001e53, iar DHCP-ul automat la pornire va eșua. Puteți obține manual o adresă cu sudo udhcpc -i enx000a35001e53, dar soluția curată este argumentul net.ifnames=0 din pasul C.5.

IP static (util pentru experimente repetabile):

ip addr add 192.168.1.50/24 dev eth0
ip link set eth0 up
ip route add default via 192.168.1.1
echo "nameserver 8.8.8.8" > /etc/resolv.conf

Acces de la distanță prin SSH (dacă ați activat openssh/dropbear): de pe gazdă, după ce eth0 are o adresă:

ssh petalinux@<ip-placă>

Test de debit cu iperf3:

# pe placă:
iperf3 -s
# pe gazdă:
iperf3 -c <ip-placă>

Captură de pachete cu tcpdump:

tcpdump -i eth0 -n

Crearea unui utilizator propriu

Deoarece rootfs-ul este EXT4 pe cardul SD, un utilizator creat la rulare supraviețuiește repornirilor (dar nu și unei rescrieri a cardului). Mai întâi aflați care grup acordă drepturi sudo, verificând /etc/sudoers — pe aceste imagini este de obicei grupul sudo.

sudo useradd -m -s /bin/bash tom
sudo passwd tom
sudo usermod -aG sudo tom

Verificați:

groups tom       # trebuie să includă 'sudo'
su - tom
sudo whoami      # trebuie să afișeze 'root'

Notă: Nu este nevoie să vă adăugați în grupurile input, audio, video sau aie — acelea sunt pentru dispozitive pe care o placă fără ecran/sunet nu le folosește. Grupul sudo este suficient.

Opțional, pentru a dezactiva contul implicit (după ce confirmați că tom funcționează cu sudo):

sudo passwd -l petalinux    # blochează parola contului implicit

Oprirea corectă

Întreruperea alimentării fără oprire corectă poate corupe rootfs-ul EXT4 de pe card. Opriți întotdeauna astfel:

sync
sudo halt

Notă: Pe Zynq/PetaLinux, un mesaj final „System halted” poate să nu apară. Când ieșirea pe consolă s-a oprit complet și rămâne oprită câteva secunde după mesajele de demontare, este sigur să întrerupeți alimentarea. Comanda sync dinainte asigură golirea scrierilor în așteptare.

Depanare (debugging)

Simptom	Cauză și soluție
`libtinfo.so.5 ... is required by meta-xilinx-tools`	Bibliotecă gazdă lipsă pe Ubuntu 24.04. Instalați `libtinfo5` (vezi pasul A.2).
`User namespaces are not usable by BitBake`	Restricția AppArmor din Ubuntu 24.04. Setați `kernel.apparmor_restrict_unprivileged_userns=0` (vezi pasul A.2).
`package dropbear conflicts with openssh-sshd`	Două servere SSH selectate. Dezactivați unul dintre ele (vezi pasul C.4).
`ifup: failed to bring up eth0` / `SIOCGIFINDEX: No such device`	Interfața a fost redenumită de udev. Aplicați `net.ifnames=0` (pasul C.5) sau folosiți numele `enx...` real.
Erori la import despre nepotrivirea XSA	Versiunile Vivado și PetaLinux diferă. Trebuie să fie identice.
Eroare `/bin/sh` / scripturi care eșuează criptic	Nu ați schimbat dash în bash (pasul A.2).
`hwclock: Cannot access the Hardware Clock` și data greșită la pornire	Zynq-7000 nu are ceas de timp real cu baterie. Normal; setați ora cu NTP sau manual cu `date` după conectarea la rețea.
Nu apare `eth0` deloc	Ethernet-ul PS nu a fost activat în preset-ul plăcii din Vivado. Reaplicați Board Preset (pasul B.2), re-exportați XSA și re-importați.
Construcție oprită la descărcarea surselor	Conexiune la internet pierdută. Reluați `petalinux-build`; Yocto continuă de unde a rămas.

Pentru o reconstrucție curată:

petalinux-build -x mrproper    # șterge artefactele, păstrează configurația
petalinux-build

Note privind dezvoltarea și planurile de viitor

Dezvoltare cu VS Code: VS Code Remote-SSH nu rulează pe Arty Z7, deoarece Zynq-7000 este ARM pe 32 de biți (armhf), iar Microsoft nu oferă un server VS Code pentru această arhitectură. Abordarea recomandată este compilarea încrucișată pe mașina Ubuntu, folosind SDK-ul generat de PetaLinux (petalinux-build --sdk), și copierea binarelor pe placă prin scp. VS Code rulează nativ pe Ubuntu.

Pachete la rulare: Imaginile PetaLinux/Yocto nu folosesc apt. Setul de software este fixat la construcție. Pentru a adăuga un pachet (de exemplu nano), adăugați-l în configurația rootfs și reconstruiți imaginea. Majoritatea utilitarelor de bază sunt furnizate de BusyBox (de exemplu vi în loc de nano).

Viitorul PetaLinux: AMD retrage treptat PetaLinux în favoarea cadrului EDF (Embedded Development Framework), bazat pe Yocto, introdus în versiunea 2025.1. PetaLinux rămâne funcțional și bine documentat pentru acest scop, dar ajunge la sfârșitul ciclului de viață în jurul anului 2026. Pentru o soluție orientată spre viitor, luați în considerare construirea directă a unei imagini Yocto/OpenEmbedded cu straturile meta-xilinx.

Crearea unei imagini petalinux