Editing Xilinx Vivado

[[Category:Software]]
[[Category:Xilinx]]
[[Category:IDEs]]
[[Category:FPGAs]]

[https://www.xilinx.com/products/design-tools/vivado.html Vivado] is a streamlined set of tools for Xilinx FPGA development.

= Installation = 
Navigate to the file server on [http://hive.ee.uct.ac.za Hive] or go straight to the [https://www.xilinx.com/products/design-tools/vivado.html Vivado Download site], and scroll down to standalone installers. Grab the latest <strong>WebPack version</strong> of Vivado (See image). You may need to enter some details if using the Vivado site.

[[File:Vivado-standalone.png|thumb]]

Once downloaded, walk through the installation process.
# When selecting which product to install, select "Vivado".
# When selecting Vivado version, select "WebPack".
# When selecting which components to install, it is worth determining which devices you need to install for, as this can save you a large amount of download time, and space on your harddrive. For most purposes, installing just the 7 series chips (Artix-7, Kintex-7 and Spartan-7) is sufficient. You can always re-run the installer to install additional devices
## If you wish to use MATLAB and SimuLink to generate HDL, you will also want to install the "System Generator for DSP" and "Model Composer"
# Select where to install Vivado. Double check if you want to install for just the current user, or all users
# If downloading, let it run. It will likely take a while

= Installing Custom Board Definitions = 
Board definitions tell Vivado the parts and layout of the board you're using. This can be very useful when using commercial/educational boards. The process for these boards is all the same once you find the board definition files.

For a quick overview of this section, watch [https://www.youtube.com/watch?v=ojwIVznvH7o this video].

Note: You need to restart the IDE for new board definitions to load.

# Download the board definition file
## For Digilent Boards, you can visit the [https://github.com/Digilent/vivado-boards Digilent GitHub page] or [https://github.com/Digilent/vivado-boards/archive/master.zip download all board definitions].
## Note that "old boards" are used when using Vivado 14.4 and below. Otherwise, use the new definitions. <b>The remainder of the instructions assume you're using a version of Vivado above 2015.1.</b>
# Navigate to where the board definitions were installed (e.g. C:\Xilinx\Vivado\2019.2\data\boards\board_files) and place the board definition folders inside
## There should be one folder per board.
# You should now be able to open Vivado and, when creating a new project, select your given board.

= Creating a new project =
NB: If it's your first time running Vivado, it's suggested you install the board definitions first, as the IDE needs to be restarted to load new board definitions.
To create a new project:
# Select "Create Project" on the main page as Vivado Opens.
# Set a project name and directory
# In most cases, the Project type will be "RTL Project"
## If you don't have any source files to start with, select "Do not specify sources at this time"
## If you have a project file, select "Imported Project"
# If you do have source files (such as Veirlog or VHDL files), you will be asked to add them
# You will then be asked for the constraints file for your board. For more information on constraint files, see below.
# Next you will be asked to select your board. 
## You can select a part or a board. 
## If your board is not found in the repository but there exists a board definition for it (as is the case with Digilent Boards), see the guide on installing custom definitions below.
# Finish the wizard. Your project is now created.

You will still need to set the top module, and include your constraints as the default constraint set. See below.

= Understanding the Files =
== The Vivado File Overview ==
[[File:Vivado Sources.png|none Example Vivado Sources]]

== Design Sources ==
Design sources are generally the Verilog or VHDL files you will write or use in your implementation.

In order to correctly synthesize the design, you need to set a top level module (TLM). You can do so by right clicking on the desired TLM, and click "Set as Top".

== Constraint Files ==
Constraint files list constraints in the project, and also allow you to initialize and refer to pins in your HDL. Take, for example, this snippet of the Nexys A7 constraints file:

<pre>
# Clock signal
set_property -dict { PACKAGE_PIN E3    IOSTANDARD LVCMOS33 } [get_ports { CLK100MHZ }]; #IO_L12P_T1_MRCC_35 Sch=clk100mhz
create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports {CLK100MHZ}];

set_property -dict { PACKAGE_PIN J15   IOSTANDARD LVCMOS33 } [get_ports { sw[0] }]; #IO_L24N_T3_RS0_15 Sch=sw[0]
set_property -dict { PACKAGE_PIN L16   IOSTANDARD LVCMOS33 } [get_ports { sw[1] }]; #IO_L3N_T0_DQS_EMCCLK_14 Sch=sw[1]

set_property -dict { PACKAGE_PIN H17   IOSTANDARD LVCMOS33 } [get_ports { LED[0] }]; #IO_L18P_T2_A24_15 Sch=led[0]
set_property -dict { PACKAGE_PIN K15   IOSTANDARD LVCMOS33 } [get_ports { LED[1] }]; #IO_L24P_T3_RS1_15 Sch=led[1]
</pre>

This short constraints file enables the 100 MHz clock called "CLK100MHZ", and a two-bit "array" of switches called "sw" and LEDs called "LED". One could reference these in a Verilog module as follows:
<pre>
module project_1(
    input	CLK100MHZ,
    input[1:0] sw,
    output reg [1:0] LED
    );
    
    
    always @(posedge CLK100MHZ) begin
        LED[0] <= sw[0];
        LED[1] <= !sw[1];
    end
    
endmodule
</pre>

== Simulation Sources ==
Simulation Sources consist of "sets". Each set is a new simulation. You can read more about simulating your design lower in this article.

= Running Your HDL =
In order to run the HDL on the FPGA, you need to follow a few steps. The general process in Vivado is shown in the figure below. Throughout any of these steps, you can see if Vivado is busy running a job by looking in the top left corner.

[[File:VivadoProcess.png|frame|none| The General Vivado Design Cycle]]

== Writing HDL ==
See pages on writing Verilog and VHDL (coming eventually).

== Synthesize ==
To synthesize your design, you can press F11, or use the command window on the left hand side of the Vivado IDE.

== Simulate ==
Simulate your design to ensure it operates as expected. You can run test benches to fully test your code.

Once you begin writing your modules you’re going to check that they’re working. You can do this though simulation.

Once you’ve synthesized your project, you should be able to click “run simulation”.

This will only run a simulation of your top module. It is far more useful to create a testbench.

<ol>
<li>Right click "Simulation Sources" and Select "Add new" <br>
In the dialog box, ensure Simulation sources is selected.
</li>

<li>Create it in a new simulation set, and use the checkbox to set it as active<br>
You can toggle which simulation source is active by setting it in the same way you'd set your top level module under design sources - just right click on the simulation source and select "Make active"
</li>

<li>Create a file for your testbench<br>
It's a good idea to name it the same as the module you're testing, followed by a "_tb" to distinguish it. For example, if you're creating a test bench for a clock, you might call the file "clock_tb". This file will appear under "non module sources" in the simulation set until you add some code to it.
</li>


<li>Add basic TB code to the modele<br>
A super simple testbench consists of a generated clock and an instantiation of the module you're testing. Add the simple clock generation code, save the file, and set it as top in the simulation source.
<pre>
module clock_tb();

//create a fake clock signal
reg clk = 0;

//toggle the clock
always begin
    #1 clk = ~clk;
end

//

endmodule

</pre>
</li>

<li>You should now be able to instantiate modules and run behavioral simulations to ensure your design works. You can connect the modules in such a way to minic switches by setting register values and using delay constructs.
</li>

</ol>

== Implement ==
"Vivado implementation includes all steps necessary to place and route the netlist onto device resources, within the logical, physical, and timing constraints of the design. " (From the [https://www.xilinx.com/support/documentation/sw_manuals/xilinx2019_2/ug904-vivado-implementation.pdf Vivado Manual on Implementation])

Implement your design by selecting "Implement design" on the left hand side of the Vivado IDE. 

=== Implementation Details ===
Here you can get details on resource usage, etc

== Generate bitstream ==
This is done by pressing "Generate Bitstream" on the left hand side of the Vivado IDE.

== Programming the FPGA ==
To program the FPGA, do the following:

# Connect the board and turn it on
# Select "Open Hardware Manager" on the left hand side of the Vivado IDE.
# Click "Open Target" and "Auto Connect"
# Once the bitstream is generated, you can program the FPGA

= Xilinx Vivado IP =
IP Cores are pre-written blocks of logic that you can import in to your project. Some examples include floating point mathematics modules, communication protocols, memory modules, and queues.

== Generating IP Cores ==
While IP blocks will abstract quite a bit away for you, you need to be knowledgeable of the IP that you're wanting to use - for example you can't import RAM IP if you don't understand certain features and qualities of the memory. To generate IP, select "IP catalog" on the left hand side of the IDE and search for whatever IP you might want to use. 

== Instantiating IP Cores ==
Once you've generated the IP, you can get a template for instantiation. 
# Under the sources tab, select "IP Sources"
# Click the arrow on the right hand side of the IP core you have to open the drop down menu
# Under "Instantiation template", select the correct one for your HDL (VHDL/Verilog)
# Copy paste the template to where you need to instantiate it.