Interfața Tcl în Vivado

De la YO3ITI
Sari la navigare Sari la căutare

Interfața Tcl în AMD Vivado: obiecte, proprietăți și automatizarea proiectelor FPGA

Introducere

AMD Vivado Design Suite este mediul de dezvoltare utilizat pentru proiectarea, sinteza, implementarea și configurarea circuitelor FPGA și a dispozitivelor adaptive SoC din familiile acceptate de Vivado.

Deși Vivado oferă o interfață grafică (GUI), o mare parte a funcționalității sale este accesibilă prin intermediul interpretorului Tcl (Tool Command Language).

Interfața Tcl permite:

  • crearea și configurarea proiectelor FPGA;
  • identificarea dispozitivelor și a plăcilor de dezvoltare;
  • interogarea obiectelor interne ale proiectului;
  • citirea și modificarea proprietăților obiectelor;
  • administrarea surselor HDL și a constrângerilor;
  • executarea sintezei și implementării;
  • generarea rapoartelor de utilizare și temporizare;
  • automatizarea fluxului de proiectare;
  • reproducerea procesului de construire a unui proiect pe alte calculatoare.

Un avantaj important al Tcl este posibilitatea de a transforma o succesiune de operații efectuate manual în interfața grafică într-un script care poate fi executat repetat.

De exemplu, în loc să creăm manual un proiect, să adăugăm fișierele Verilog și să lansăm sinteza, putem executa un script Tcl care realizează toate aceste operații.

În continuare vom utiliza exemple generale, precum și exemple adaptate plăcii Digilent Arty Z7-20, echipată cu un dispozitiv AMD/Xilinx Zynq-7000.

Tcl și arhitectura de control Vivado

Ce este Tcl?

Tcl este un limbaj de scripting interpretat, utilizat frecvent în aplicațiile de automatizare a proiectării electronice (EDA).

În Vivado, comenzile Tcl pot controla atât configurarea proiectului, cât și instrumentele de sinteză, implementare, analiză temporală și programare a dispozitivului.

Trebuie făcută distincția între două categorii de comenzi:

  • Comenzi Tcl standard, precum set, puts, foreach, if și proc.
  • Comenzi specifice Vivado, precum get_cells, get_property, create_project, synth_design și report_timing_summary.

Exemplu de Tcl standard: 

set frequency_mhz 100
set period_ns [expr {1000.0 / $frequency_mhz}]

puts "Frequency = $frequency_mhz MHz"
puts "Period = $period_ns ns"

Rezultatul este: 

Frequency = 100 MHz
Period = 10.0 ns

Aceste comenzi nu necesită un proiect Vivado deschis.

Interpretorul Tcl din Vivado

Vivado poate executa comenzile Tcl în mai multe moduri.

Mod de operare Descriere Utilizare
Vivado IDE Interfața grafică include consola Tcl. Dezvoltare interactivă și depanare.
Tcl Shell Interpretor Tcl Vivado fără interfață grafică. Administrarea proiectelor din linia de comandă.
Batch Mode Executarea unui script Tcl fără interacțiune cu utilizatorul. Automatizare și fluxuri reproductibile.

Pornirea interpretorului Tcl: 

vivado -mode tcl

Executarea unui script în modul batch: 

vivado -mode batch -source build.tcl

Pornirea unui script în modul Tcl interactiv: 

vivado -mode tcl -source build.tcl

În Windows, comenzile se execută dintr-un terminal în care executabilul Vivado este disponibil, de exemplu din terminalul instalat împreună cu Vivado sau după configurarea variabilei PATH.

Observație: Opțiunea -mode batch este potrivită pentru automatizări, deoarece procesul se încheie după executarea scriptului.

Consola Tcl din Vivado IDE

În interfața grafică, consola Tcl poate fi accesată din meniul: 

Window → Tcl Console

În această consolă pot fi executate direct comenzile prezentate în tutorial.

De exemplu: 

puts [version]

Comanda afișează informații despre versiunea Vivado utilizată.

O comandă utilă pentru identificarea directorului curent este: 

pwd

Pentru schimbarea directorului: 

cd C:/FPGA/Projects

În scripturile Tcl pentru Windows este convenabil să folosim caracterul / în căile fișierelor, evitând interpretarea caracterului backslash ca secvență de escape.

Sistemul de ajutor Tcl în Vivado

Vivado dispune de un sistem integrat de documentare a comenzilor.

Pentru a obține informații despre o comandă: 

help get_property

Pentru afișarea informațiilor detaliate: 

get_property -help

Pentru identificarea comenzilor corespunzătoare unei categorii: 

help get_*

Alte exemple: 

help report_*
help create_project
help set_property
help get_cells

Comenzile disponibile pot varia în funcție de versiunea Vivado.

Recomandare: Înainte de utilizarea unei comenzi într-un script complex, este util să verificăm sintaxa acesteia cu help.

Modelul de obiecte Vivado

Noțiunea de obiect

Vivado utilizează un model intern bazat pe obiecte.

Un obiect poate reprezenta:

  • un proiect;
  • un dispozitiv FPGA;
  • o definiție de placă;
  • un fișier sursă;
  • un set de fișiere;
  • o execuție de sinteză sau implementare;
  • o instanță logică;
  • un registru;
  • o rețea electrică sau logică;
  • un port;
  • un pin;
  • un semnal de ceas;
  • o resursă fizică a dispozitivului.

Obiectele sunt accesibile prin comenzi Tcl care returnează colecții de obiecte.

Exemple: 

get_projects
get_parts
get_board_parts
get_files
get_runs
get_cells
get_nets
get_ports
get_clocks

Nu toate aceste comenzi sunt relevante în orice moment.

De exemplu, pentru identificarea celulelor rezultate după sinteză este necesar să avem un design elaborat, sintetizat sau implementat deschis.

Comenzi pentru identificarea obiectelor

Comandă Funcționalitate
get_projects Identificarea proiectelor deschise.
get_parts Enumerarea dispozitivelor FPGA și SoC cunoscute de instalarea Vivado.
get_board_parts Enumerarea definițiilor de plăci de dezvoltare instalate.
get_files Identificarea fișierelor asociate proiectului.
get_filesets Identificarea seturilor de fișiere.
get_runs Identificarea execuțiilor de sinteză și implementare.
get_cells Identificarea instanțelor logice din design.
get_nets Identificarea rețelelor care conectează celulele.
get_ports Identificarea porturilor de nivel superior.
get_pins Identificarea pinilor instanțelor logice.
get_clocks Identificarea obiectelor de tip clock.
get_sites Identificarea amplasamentelor fizice din dispozitiv.
get_package_pins Identificarea pinilor capsulei dispozitivului.

Obiectul curent

Vivado utilizează frecvent conceptul de obiect curent.

Exemple: 

current_project
current_design
current_fileset
current_run

Aceste comenzi returnează sau gestionează obiectul curent din categoria respectivă.

Exemplu: 

set proj [current_project]

puts "Current project: $proj"

Comanda presupune existența unui proiect deschis.

Pentru a verifica dacă avem un proiect curent: 

if {[catch {current_project} proj]} {
    puts "No project is currently open."
} else {
    puts "Current project: $proj"
}

Instrucțiunea catch permite tratarea unei erori Tcl fără întreruperea executării scriptului.

Proprietățile obiectelor Vivado

Ce reprezintă o proprietate?

Fiecare obiect Vivado poate avea un set de proprietăți.

Proprietățile descriu caracteristicile, configurația sau starea obiectului.

De exemplu, un proiect poate avea proprietăți asociate cu:

  • numele proiectului;
  • dispozitivul țintă;
  • placa de dezvoltare;
  • limbajul HDL;
  • directorul proiectului;
  • configurațiile de sinteză și implementare.

Un port poate avea proprietăți precum:

  • standardul electric I/O;
  • pinul fizic al capsulei;
  • direcția;
  • constrângeri asociate.

O instanță logică poate avea proprietăți precum:

  • numele ierarhic;
  • tipul primitivei;
  • amplasarea fizică, atunci când este disponibilă;
  • proprietăți de optimizare și implementare.

Comenzi pentru administrarea proprietăților

Comandă Funcționalitate
get_property Citirea valorii unei proprietăți.
set_property Modificarea valorii unei proprietăți.
list_property Enumerarea numelor proprietăților disponibile.
report_property Afișarea unui raport cu proprietățile unui obiect.
list_property_value Identificarea valorilor permise, pentru proprietățile care acceptă enumerări.
reset_property Resetarea unei proprietăți.

Citirea unei proprietăți

Sintaxa generală: 

get_property PROPERTY_NAME OBJECT

Exemplu: 

get_property PART [current_project]

Comanda returnează dispozitivul selectat în proiect.

Pentru un proiect Arty Z7-20 configurat cu dispozitivul corespunzător, rezultatul poate fi: 

xc7z020clg400-1

Un alt exemplu: 

get_property NAME [current_project]

Acesta returnează numele proiectului curent.

Putem utiliza valorile returnate în alte comenzi Tcl: 

set project_name [get_property NAME [current_project]]
set fpga_part    [get_property PART [current_project]]

puts "Project: $project_name"
puts "Device:  $fpga_part"

Enumerarea proprietăților

Comanda: 

list_property [current_project]

returnează numele proprietăților disponibile pentru obiectul proiect.

Pentru o prezentare mai detaliată: 

report_property [current_project]

O variantă este: 

report_property -all [current_project]

Opțiunea -all permite includerea tuturor proprietăților aplicabile conform modelului de raportare.

Putem interoga și un obiect de tip dispozitiv: 

set part [get_parts xc7z020clg400-1]

report_property $part

Filtrarea proprietăților

Comanda report_property permite selectarea proprietăților după un model de căutare.

De exemplu: 

report_property [current_project] *PART*

Pentru a identifica toate numele proprietăților care conțin un anumit text, putem utiliza și comenzile standard Tcl: 

foreach property [list_property [current_project]] {
    if {[string match *PART* $property]} {
        puts $property
    }
}

Modificarea unei proprietăți

Sintaxa generală este: 

set_property PROPERTY_NAME VALUE OBJECT

Exemplu: 

set_property target_language Verilog [current_project]

Aceasta configurează limbajul țintă al proiectului ca Verilog.

Pentru verificare: 

get_property TARGET_LANGUAGE [current_project]

Proprietățile nu sunt toate modificabile. Unele sunt calculate de Vivado sau sunt disponibile numai în anumite stări ale designului.

Explorarea dispozitivului FPGA

Identificarea dispozitivului Arty Z7-20

Placa Digilent Arty Z7-20 utilizează dispozitivul Zynq-7000: 

XC7Z020-1CLG400C

Denumirea utilizată în catalogul de componente Vivado este, în mod obișnuit: 

xc7z020clg400-1

Putem verifica prezența dispozitivului în instalarea Vivado: 

get_parts xc7z020clg400-1

Pentru a obține proprietățile sale: 

set fpga [get_parts xc7z020clg400-1]

report_property $fpga

Pentru a enumera toate dispozitivele din familia Zynq-7000 care corespund unui model: 

get_parts *xc7z020*

Enumerarea dispozitivelor disponibile

Comanda: 

get_parts

poate produce o listă foarte mare.

Este mai util să folosim un filtru: 

get_parts *xc7z*

Sau: 

get_parts *xc7a*

Aceste interogări permit identificarea unor dispozitive Zynq-7000, respectiv Artix-7, dacă sunt instalate în mediul Vivado.

Explorarea proprietăților dispozitivului

Următorul script identifică toate proprietățile disponibile pentru dispozitivul Arty Z7-20 și le afișează împreună cu valorile lor. 

set fpga [get_parts xc7z020clg400-1]

foreach property [list_property $fpga] {
    set value [get_property $property $fpga]
    puts "$property = $value"
}

Acesta este un exemplu important de utilizare combinată a limbajului Tcl și a modelului de obiecte Vivado.

Scriptul poate fi adaptat pentru alte clase de obiecte.

Identificarea definițiilor plăcilor

Comanda: 

get_board_parts

returnează definițiile de plăci disponibile.

Pentru identificarea plăcilor Arty: 

get_board_parts *arty*

Pentru a afișa numele și proprietățile definițiilor identificate: 

foreach board [get_board_parts *arty*] {
    puts "Board: $board"
    report_property $board
}

Important: Definițiile de plăci Digilent trebuie să fie instalate și vizibile pentru Vivado. Absența lor din get_board_parts nu înseamnă că dispozitivul FPGA lipsește din catalog.

Un proiect poate fi creat specificând direct dispozitivul FPGA, fără a utiliza o definiție de placă.

Colecții de obiecte și filtrare

Colecțiile returnate de comenzile get_*

Comenzile Vivado de tip get_* returnează colecții de obiecte.

Aceste colecții pot fi utilizate în alte comenzi, fără a converti manual obiectele în șiruri de caractere.

Exemplu: 

set cells [get_cells -hierarchical *]

Această comandă necesită un design deschis.

Numărarea obiectelor

Comanda Tcl llength poate fi utilizată pentru a număra obiectele returnate. 

set cells [get_cells -hierarchical *]

puts "Number of cells: [llength $cells]"

Pentru dispozitive: 

set parts [get_parts *xc7z020*]

puts "Matching parts: [llength $parts]"

Parcurgerea obiectelor

O colecție poate fi parcursă folosind foreach. 

foreach cell [get_cells -hierarchical *] {
    puts [get_property NAME $cell]
}

Această comandă afișează numele instanțelor logice identificabile în designul deschis.

Filtrarea obiectelor după proprietăți

Vivado oferă opțiunea -filter pentru numeroase comenzi de interogare.

Exemplu: 

get_cells -hierarchical -filter {IS_PRIMITIVE == 1}

Această comandă selectează instanțele primitive din ierarhia designului.

Pentru identificarea registrelor de tip flip-flop: 

get_cells -hierarchical -filter {PRIMITIVE_GROUP == FLOP_LATCH}

Disponibilitatea și semnificația unor proprietăți depind de etapa de procesare și de versiunea Vivado.

Înainte de construirea unui filtru, putem inspecta proprietățile unui obiect existent: 

set cells [get_cells -hierarchical *]

if {[llength $cells] > 0} {
    report_property [lindex $cells 0]
}

Utilizarea expresiilor Tcl

Tcl permite construirea condițiilor și a expresiilor numerice. 

set total_cells [llength [get_cells -hierarchical *]]

if {$total_cells > 1000} {
    puts "Large design"
} else {
    puts "Small design"
}

Pragul de 1000 de celule este arbitrar și servește numai ca exemplu.

Explorarea netlist-ului după sinteză

Deschiderea designului sintetizat

În Project Mode, după finalizarea sintezei, designul poate fi deschis folosind: 

open_run synth_1

Dacă sinteza nu a fost executată, aceasta poate fi lansată astfel: 

launch_runs synth_1
wait_on_run synth_1

Apoi: 

open_run synth_1

După deschiderea designului sintetizat, comenzile get_cells, get_nets, get_pins și get_ports permit explorarea netlist-ului.

Identificarea porturilor

get_ports

Pentru a afișa proprietățile unui port numit clk: 

report_property [get_ports clk]

Aceasta presupune că portul clk există în modulul de nivel superior.

Identificarea celulelor

get_cells -hierarchical *

Pentru a identifica primitivele utilizate: 

foreach cell [get_cells -hierarchical -filter {IS_PRIMITIVE == 1}] {
    set name [get_property NAME $cell]
    set type [get_property REF_NAME $cell]

    puts "$name : $type"
}

Un rezultat posibil poate include primitive precum: 

FDRE
LUT6
BUFG

Valorile reale depind de design și de optimizările efectuate de sinteză.

Identificarea rețelelor

get_nets -hierarchical *

Pentru a inspecta o rețea cu nume cunoscut: 

report_property [get_nets signal_name]

Numele signal_name trebuie înlocuit cu un nume existent în netlist.

Relațiile dintre obiecte

Un aspect important al modelului Vivado este posibilitatea de a naviga între obiectele conectate.

De exemplu, putem obține pinii conectați la un net: 

set nets [get_nets -hierarchical *]

if {[llength $nets] > 0} {
    set net [lindex $nets 0]

    puts "Net: $net"

    foreach pin [get_pins -of_objects $net] {
        puts "Connected pin: $pin"
    }
}

Opțiunea -of_objects este esențială pentru explorarea relațiilor dintre obiecte.

Constrângeri XDC și proprietăți I/O

Ce este un fișier XDC?

Fișierele XDC (Xilinx Design Constraints) conțin comenzi Tcl utilizate pentru definirea constrângerilor electrice, fizice și temporale ale designului.

De exemplu: 

set_property IOSTANDARD LVCMOS33 [get_ports led]

Această comandă configurează standardul electric al portului led ca LVCMOS33.

Pentru atribuirea unui pin fizic: 

set_property PACKAGE_PIN <PIN_NAME> [get_ports led]

Atenție: <PIN_NAME> este un substituent explicativ, nu un nume de pin valid. Trebuie înlocuit cu pinul corespunzător din documentația plăcii și din fișierul Master XDC.

Constrângeri de ceas

Pentru un semnal de ceas de 100 MHz, perioada este de 10 ns.

Constrângerea poate fi definită astfel: 

create_clock -name sys_clk -period 10.000 [get_ports clk]

Această comandă definește un obiect clock asociat portului clk.

Pentru afișarea ceasurilor: 

get_clocks

Pentru inspectarea proprietăților: 

report_property [get_clocks sys_clk]

Verificarea constrângerilor

După deschiderea unui design corespunzător, putem executa: 

report_clocks
report_io
report_timing_summary

Aceste comenzi sunt utile pentru verificarea interpretării constrângerilor de către Vivado.

Important: Un raport temporal nu poate înlocui validarea asignării pinilor și a compatibilității electrice cu schema plăcii.

Comenzi pentru sinteză, implementare și raportare

Project Mode și Non-Project Mode

Vivado oferă două modele principale de organizare a fluxului de proiectare.

Operație Project Mode Non-Project Mode
Crearea proiectului create_project Nu este obligatoriu un proiect persistent.
Adăugarea surselor HDL add_files read_verilog, read_vhdl
Citirea constrângerilor Fișiere XDC asociate proiectului read_xdc
Sinteză launch_runs synth_1 synth_design
Optimizare Etapă administrată de run opt_design
Placement Etapă administrată de run place_design
Routing Etapă administrată de run route_design
Generarea bitstream-ului launch_runs impl_1 -to_step write_bitstream write_bitstream

În Project Mode, Vivado administrează dependențele dintre etape și rezultatele intermediare.

În Non-Project Mode, scriptul controlează explicit succesiunea operațiilor.

Rapoarte utile

Comandă Funcționalitate
report_utilization Utilizarea resurselor FPGA.
report_timing_summary Analiza globală a temporizării.
report_drc Verificarea regulilor de proiectare.
report_power Estimarea consumului de putere.
report_io Raportul porturilor și configurațiilor I/O.
report_route_status Starea rutării designului.
report_high_fanout_nets Identificarea rețelelor cu fanout ridicat.
report_clock_utilization Utilizarea resurselor dedicate pentru ceas.

Exemplu de salvare a rapoartelor: 

file mkdir reports

report_utilization \
    -file reports/utilization.rpt

report_timing_summary \
    -file reports/timing_summary.rpt

report_drc \
    -file reports/drc.rpt

Aceste comenzi trebuie executate după deschiderea unui design în etapa corespunzătoare.

Automatizarea unui proiect Arty Z7-20

Structura recomandată a directoarelor

Pentru a putea reproduce construcția proiectului, este util să separăm sursele HDL, constrângerile și scripturile Tcl de fișierele generate de Vivado. 

arty_z7_project/
|
+-- rtl/
|   +-- top.v
|
+-- constraints/
|   +-- arty_z7.xdc
|
+-- scripts/
|   +-- create_project.tcl
|   +-- build.tcl
|
+-- reports/
|
+-- vivado_project/

Script pentru crearea proiectului

Următorul script Tcl creează un proiect pentru Arty Z7-20 și adaugă sursele HDL și fișierele de constrângeri.

Fișier: scripts/create_project.tcl 

# Project name
set project_name "arty_z7_example"

# Determine repository root relative to this script
set script_dir [file dirname [file normalize [info script]]]
set root_dir [file dirname $script_dir]

# Directories
set project_dir [file join $root_dir vivado_project]
set rtl_dir     [file join $root_dir rtl]
set constr_dir  [file join $root_dir constraints]

# FPGA target
set fpga_part "xc7z020clg400-1"

# Create project
create_project $project_name $project_dir \
    -part $fpga_part -force

# Configure Verilog as target language
set_property target_language Verilog [current_project]

# Add HDL source
add_files -fileset sources_1 \
    [file join $rtl_dir top.v]

# Add constraints
add_files -fileset constrs_1 \
    [file join $constr_dir arty_z7.xdc]

# Define top module
set_property top top [get_filesets sources_1]

# Update compile order
update_compile_order -fileset sources_1

# Save project
save_project

puts "Project created successfully."
puts "Project: $project_name"
puts "FPGA: $fpga_part"

Scriptul folosește comanda file join pentru a construi căile într-un mod portabil.

Directorul de bază este calculat pornind de la locația scriptului, nu de la directorul de lucru al terminalului.

Observație: Scriptul nu selectează o definiție de placă Digilent. El selectează direct dispozitivul Zynq-7000 de pe Arty Z7-20. Definiția de placă poate fi configurată separat dacă aceasta este instalată.

Executarea scriptului

Din directorul principal: 

vivado -mode batch -source scripts/create_project.tcl

Vivado va crea proiectul în directorul vivado_project.

Script pentru sinteză și implementare

Fișier: scripts/build.tcl 

# Determine root directory
set script_dir [file dirname [file normalize [info script]]]
set root_dir [file dirname $script_dir]

set project_name "arty_z7_example"

set project_file [file join \
    $root_dir \
    vivado_project \
    $project_name.xpr]

set reports_dir [file join $root_dir reports]

file mkdir $reports_dir

# Open project
open_project $project_file

# Run synthesis
launch_runs synth_1
wait_on_run synth_1

# Check synthesis status
set synth_status [get_property STATUS [get_runs synth_1]]
puts "Synthesis status: $synth_status"

if {[get_property PROGRESS [get_runs synth_1]] ne "100%"} {
    error "Synthesis did not complete successfully."
}

# Run implementation and bitstream generation
launch_runs impl_1 -to_step write_bitstream
wait_on_run impl_1

# Check implementation status
set impl_status [get_property STATUS [get_runs impl_1]]
puts "Implementation status: $impl_status"

if {[get_property PROGRESS [get_runs impl_1]] ne "100%"} {
    error "Implementation did not complete successfully."
}

# Open implemented design
open_run impl_1

# Generate reports
report_utilization \
    -file [file join $reports_dir utilization.rpt]

report_timing_summary \
    -file [file join $reports_dir timing.rpt]

report_drc \
    -file [file join $reports_dir drc.rpt]

puts "Build procedure completed."

Atenție: Acest script presupune existența fișierului top.v și a unui fișier XDC valid. Fără constrângerile I/O necesare, generarea bitstream-ului poate eșua.

Verificarea proprietății PROGRESS indică faptul că execuția a ajuns la final, dar nu este suficientă pentru a demonstra succesul. Pentru un flux de producție, verificarea trebuie extinsă și la proprietățile de stare, precum STATUS, la rezultatele efective și la rapoartele DRC și timing.

Lansarea automatizată

vivado -mode batch -source scripts/build.tcl

Acest mod de executare este util în Windows, Linux și în procese de integrare continuă.

Funcții Tcl reutilizabile

Proceduri Tcl

O procedură Tcl poate fi definită folosind proc.

Exemplu: 

proc print_project_info {} {

    set project [current_project]

    puts "Project name: [get_property NAME $project]"
    puts "FPGA part:    [get_property PART $project]"
}

Executare: 

print_project_info

Procedură generică pentru afișarea proprietăților

Putem crea o funcție care afișează toate proprietățile unui obiect Vivado: 

proc show_properties {object} {

    foreach property [list_property $object] {

        set value [get_property $property $object]

        puts [format "%-35s : %s" $property $value]
    }
}

Utilizare: 

show_properties [current_project]

Sau: 

show_properties [get_parts xc7z020clg400-1]

Avantajul constă în faptul că aceeași procedură poate fi utilizată pentru categorii diferite de obiecte.

Exportarea proprietăților într-un fișier

Putem extinde procedura anterioară pentru a salva rezultatele într-un fișier text. 

proc export_properties {object filename} {

    set fp [open $filename "w"]

    foreach property [list_property $object] {

        set value [get_property $property $object]

        puts $fp "$property = $value"
    }

    close $fp
}

Exemplu: 

export_properties \
    [get_parts xc7z020clg400-1] \
    "xc7z020_properties.txt"

Această abordare este utilă pentru documentarea configurației hardware sau pentru compararea proprietăților între versiuni de Vivado.

Recomandări pentru dezvoltarea scripturilor Tcl

Evitarea căilor absolute

Este preferabil să evităm căile absolute care depind de calculatorul pe care este executat proiectul.

În loc de: 

set source_file "C:/Users/user/Desktop/project/top.v"

putem folosi: 

set source_file [file join $root_dir rtl top.v]

Tratarea erorilor

Comanda catch permite detectarea erorilor. 

if {[catch {
    set fpga [get_parts xc7z020clg400-1]

    if {[llength $fpga] == 0} {
        error "FPGA device is not available."
    }
} message]} {

    puts "ERROR: $message"
}

Pentru un script de construire, este adesea preferabil să se utilizeze error sau return -code error pentru propagarea eșecului către procesul care a lansat Vivado.

Jurnalizarea operațiilor

Tcl permite scrierea mesajelor în fișiere. 

set log_file [open "custom_build.log" "w"]

puts $log_file "Starting build procedure"

puts $log_file "Target: xc7z020clg400-1"

close $log_file

În plus, Vivado generează propriile fișiere jurnal și loguri ale etapelor de execuție.

Organizarea scripturilor

Pentru proiectele complexe, este util să împărțim automatizarea în mai multe scripturi.

De exemplu: 

scripts/
|
+-- device_info.tcl
+-- project_setup.tcl
+-- synthesis.tcl
+-- implementation.tcl
+-- reports.tcl
+-- build.tcl

Scripturile pot fi incluse folosind comanda: 

source device_info.tcl

Pentru o structură portabilă, căile către scripturile incluse trebuie construite relativ la locația scriptului principal.

Exerciții practice

Pentru familiarizarea cu interfața Tcl, sunt recomandate următoarele exerciții.

Exercițiul 1: Identificarea dispozitivului FPGA

Scrieți un script Tcl care:

  1. Identifică dispozitivul xc7z020clg400-1.
  2. Afișează proprietățile disponibile.
  3. Salvează proprietățile într-un fișier text.

Exercițiul 2: Analiza unui proiect

Deschideți un proiect Vivado și scrieți un script care identifică:

  1. Numele proiectului.
  2. Dispozitivul utilizat.
  3. Seturile de fișiere existente.
  4. Fișierele HDL.
  5. Execuțiile de sinteză și implementare.

Exercițiul 3: Analiza netlist-ului

După sinteză, creați un script care:

  1. Numără instanțele logice.
  2. Identifică primitivele de tip flip-flop.
  3. Identifică primitivele LUT.
  4. Afișează tipul fiecărei primitive identificate.

Exercițiul 4: Automatizarea rapoartelor

Creați o procedură Tcl care generează într-un director separat:

  1. Raportul de utilizare.
  2. Raportul temporal.
  3. Raportul DRC.
  4. Raportul de consum energetic.

Exercițiul 5: Construirea automată a proiectului

Creați un proiect Verilog pentru Arty Z7-20 și implementați un flux complet automatizat, de la crearea proiectului până la generarea bitstream-ului.

Pentru acest exercițiu, utilizați un fișier XDC verificat pentru placa de dezvoltare.

Concluzii

Interfața Tcl reprezintă un instrument fundamental pentru dezvoltarea eficientă a proiectelor FPGA în AMD Vivado.

Prin utilizarea acesteia, dezvoltatorul poate:

  • explora arhitectura și proprietățile dispozitivelor;
  • interoga structura logică a designului;
  • configura proiecte fără intervenție manuală;
  • genera automat rapoarte tehnice;
  • controla etapele de sinteză și implementare;
  • crea fluxuri de construire reproductibile;
  • integra Vivado cu sisteme externe de automatizare.

Pentru proiectele care combină FPGA, procesoare ARM, periferice AXI și comunicații Ethernet, precum cele dezvoltate pe Arty Z7-20, scriptingul Tcl este deosebit de util.

Acesta permite automatizarea configurării hardware și constituie baza unor fluxuri mai complexe care pot include Vivado IP Integrator, exportul platformei hardware și integrarea cu instrumentele software utilizate pentru Zynq-7000.

Referințe


Adus de la „https://www.yo3iti.ro/index.php?title=Interfața_Tcl_în_Vivado&oldid=3758”