~~TechArticle~~
====== Using a Peripheral with a Hierarchical Block in Vivado IPI and Vitis ======

In Vivado, a //Hierarchical Block// is a block design within a block design. These blocks allow engineers to partition their designs into separate functional groups. This guide steps through the process of adding a pre-existing hierarchical block to a block design, recreating its example software application, and running the design in hardware.

**Note:** //Screenshots presented in this guide may not have been taken with your version of the tools. The workflow presented here has been verified in Vivado 2020.1. While there are some differences between 2020.1 and older versions of the tools, older screenshots have been checked, and contain the same user interfaces that are seen in 2020.1.//
===== Inventory =====
  * A Digilent FPGA development board.
  * A computer with Vivado installed.
    * //See the [[programmable-logic:guides:installing-vivado-and-vitis]] guide for more information.//
  * Familiarity with Vivado IP Integrator and a base block design to work from.
    * //Following the [[programmable-logic:guides:getting-started-with-ipi]] guide will result in a design that fits all requirements.//
===== Guide =====
==== Setting Up Dependencies ====
A ZIP archive including all required IP, software examples, and hierarchy scripts for each peripheral this guide supports can be downloaded from Github here: [[https://github.com/Digilent/vivado-library/archive/hierarchies.zip|vivado-library-hierarchies.zip]].

Download this file, and extract it to somewhere memorable on your computer.

Some users may wish to get access to these files through git, which provides a way to pull in any updates or fixes Digilent may apply to these files in future. Cloning these sources with git is detailed in the dropdown below.

--> Getting Sources through Git #

**Note**: //In order to use git commands,// git //must be installed on the computer. There are various different applications which can be used to interact with the git tools. The code blocks below detail the commands used in a bash shell.//

Check if vivado-library is already included in the Vivado project, if it is not, then it should be cloned:

<code>
cd (somewhere memorable)
git clone https://github.com/digilent/vivado-library -b hierarchies
</code>

Otherwise (if a separate clone of vivado-library is already included in the project), use git tools to check out the branch:

**Warning!** //If IP from the library are already included in the project, checking out a different branch may cause changes to them. Be careful!//

<code>
cd (path)/vivado-library
git checkout hierarchies
</code>

<--

----
==== Adding a Hierarchical Block to a Hardware Design ====
<WRAP GROUP> <WRAP COLUMN HALF>
Launch Vivado, then open the Vivado Project the hierarchical block is to be used in, and open the project's Block Design.

**Note**: //The design must contain a processor and a peripheral that can be used for stdout. In the case of Microblaze, a UART IP must be connected to the board's USBUART interface. In the case of Zynq, the PS UART is used by default.//

Completing the [[programmable-logic:guides:getting-started-with-ipi]] guide will result in a design that fits the requirements for using these hierarchical blocks.
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:base-bd.png?600 |}}
</WRAP> </WRAP>

----

<WRAP GROUP> <WRAP COLUMN HALF>
In Vivado's TCL Console, enter the following command: <code>source (path)/vivado-library/hierarchies/(hierarchy of choice)/create_hier.tcl</code>

When the script is finished running, the block design will contain a //Hierarchical Block// with several IP inside of it. The IP will be connected to one another and to the block's ports and pins. The contents of the hierarchy can be viewed and changed by expanding it with the "**+**" button.
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:source-create-hier.png?600 |}}
</WRAP> </WRAP>

----

<WRAP GROUP> <WRAP COLUMN HALF>
Check the README.txt file, which can be found in the hierarchical block's folder in vivado-library/hierarchies, for additional information about how the ports of the Hierarchy must be connected to the rest of the design. With this information in mind:
   - Connect all of the hierarchical block's AXI interfaces to the processor in the design by clicking on **Run Connection Automation**, and checking the appropriate boxes. These interfaces may appear more than once in the connection automation dialog. Select only one entry for each interface.
   - Connect any interrupts the Hierarchy may have to the appropriate interrupt controller: an AXI Interrupt Controller IP (for Microblaze designs), the Zynq Processing System's irq_f2p port (for Zynq designs).
   - Connect any additional clocks to clocks generated by a Memory Interface Generator or a Clocking Wizard (for Microblaze designs), or a Zynq Processing System (for Zynq designs).
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:connection-automation.png?nolink&600 |}}
</WRAP> </WRAP>

----

The next step, constraining the Hierarchy's external port/s, has two different Workflows:

  - If a board was selected when creating the project, the **Board Flow** can be used for this step.
  - If a part was selected instead of a board, or the Board Flow cannot be used for whatever reason, the **Manual Constraint Flow** should be used instead.

----
=== Creating an External Pmod Port ===
Open the dropdown for the chosen Workflow, below, and follow the instructions.

**Note**: //This step is only required for Pmod hierarchical blocks. Zmod hierarchical scripts automatically create their external ports. For the purposes of this guide, consider the Zmod's external ports to have been created using the Manual Constraint Flow.//

--> Board Flow #
<WRAP GROUP> <WRAP COLUMN HALF>
Go to Vivado's //Board// tab and select a Pmod connector to connect to the hierarchical block. Right click on the connector's entry, typically named something like "Connector JA", and select **Connect Board Component**. In the popup window, under //Connect to existing IP//, select the "Pmod_out" interface of the Hierarchy's Pmod Bridge IP. Click **OK**.
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:board-flow.png?nolink&600 |}}
</WRAP> </WRAP>
<--

--> Manual Constraint Flow #
<WRAP GROUP> <WRAP COLUMN HALF>
Select the Pmod_out port, then right click on it and select **Make External**. Select the newly created external interface port (named something like "Pmod_out_0") in the design, and give it a memorable name.
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:make_external.png?nolink&600 |}}
</WRAP> </WRAP>
<--

----
=== Validating the Design and Creating a Wrapper File ===
<WRAP GROUP> <WRAP COLUMN HALF>
Regardless of the chosen workflow, validate the block design by clicking the Validate button ( {{:learn:programmable-logic:tutorials:vivado-hierarchical-blocks:validate_button.png?nolink|}} ) and save it. \\
Then create an HDL wrapper file, if one doesn't already exist, by right clicking on the design in the //Sources// pane and selecting "Create HDL Wrapper".
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:create_wrapper.png?nolink&600 |}}
</WRAP> </WRAP>
----
=== Constraining the Design ===
This step works a little differently depending on whether the peripheral targeted by the hierarchical block is a [[zmod:start|Zmod]] or a [[pmod:start|Pmod]]. Select the dropdown for the chosen peripheral:

--> Pmod#
<WRAP GROUP> <WRAP COLUMN HALF>
If the **Board Flow** was chosen, open the README.txt file in the hierarchical block's folder in vivado-library-hierarchies to determine whether any additional constraints are required. If there are none, //skip the rest of this section//.

When the Hierarchy was created, a constraint file, named "(Hierarchy Name)_Pmod_out.xdc", was imported into the Vivado project. This file contains a template for all required constraints, regardless of the flow used. Open it now from the //Sources// pane, by finding it under //Constraints// and double clicking on it.

Constraints required for the **Board Flow** are left uncommented by default.

If the **Manual Constraint Flow** was chosen, uncomment any commented out lines that start with "set_property", by removing the "#" symbol at the start of each of these lines.

The text "%%FIXME%%" is used in the constraint file to indicate places where values specific to the board and design must be manually entered.

Two types of manually entered values are typical of constraint files in these Hierarchies:

**Port Names:** \\
These %%FIXME%%s come after the text "get_ports". The correct values for these FIXMEs can be found by reviewing the HDL wrapper file created in the previous step. Find the names of the ports of the Pmod_out interface that is connected to the hierarchy within the port map of the HDL wrapper. Enter these names into the corresponding places in the hierarchy's constraints file.

**Location Constraints:** \\
These %%FIXME%%s come after the text "PACKAGE_PIN", and are only required in the **Manual Constraint Flow**. The correct values for these FIXMEs can be found by reviewing the master XDC file for the target board. Master XDC files for Digilent boards can be found in the [[https://github.com/Digilent/digilent-xdc|digilent-xdc]] repository on Github. Find the LOC property values that correspond to the Pmod connector that the hierarchical block's Pmod_out port is to be connected to. Enter these values into the corresponding places in the hierarchy's constraint file.
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:edit_constraints.png?nolink&600 |}}
</WRAP> </WRAP>

<--

--> Zmod#

<WRAP GROUP> <WRAP COLUMN HALF>
When create_hier.tcl is run for a Zmod Hierarchical Block, a constraint file is imported which contains template constraints for each external port created by the script. The constraint file is named after the hierarchical block created by the script, followed by the name of the particular Zmod, for example: "ZmodADC_0_ZmodADC.xdc". The constraint file can be found under the Constraints section of Vivado IP Integrato's Sources pane.

At time of writing, each Zmod Hierarchical Block provides template constraints for each of the Eclypse Z7's Zmod Ports. By default, the Zmod ADC is connected to the Eclypse Z7's Zmod Port A, and the Zmod DAC is connected to Zmod Port B. To connect to a different port, the user need only comment out the section of the xdc corresponding to the default port, and uncomment the section corresponding to the chosen port.

For other boards, the user must replace the PACKAGE_PIN location constraints for the Zmod ports with the corresponding locations found in the chosen board's master XDC file, which can be obtained through the [[https://github.com/digilent/digilent-xdc|digilent-xdc]] repository on GitHub.
</WRAP> <WRAP COLUMN HALF>
{{:learn:programmable-logic:tutorials:vivado-hierarchical-blocks:zmod_constraint.png?600|}}
</WRAP> </WRAP>

<--

----
=== Build the Hardware ===
<WRAP GROUP> <WRAP COLUMN HALF>
Click **Generate Bitstream**. This process may take some time, depending on the complexity of the project.
</WRAP> <WRAP COLUMN HALF>
{{ :learn:programmable-logic:tutorials:vivado-hierarchical-blocks:generate-bitstream.png?nolink&600 |}}
</WRAP> </WRAP>

----
==== Baremetal Software ====
<WRAP round center important>
Zmod Hierarchical Blocks are supported in software by the Zmod Library. If using a Zmod, see the [[zmod:zmodbaselibraryuserguide|Zmod Base Library User Guide]], and skip the rest of this guide. If Petalinux support for the added hierarchy is desired, first see the [[programmable-logic:eclypse-z7:customizing-zmods-os|Zmod Petalinux Configuration Guide]]
</WRAP>

This section covers creating a baremetal software application from example source files in Vitis.

--> Export Hardware #

<WRAP GROUP>
{{page>programmable-logic:guides:vivado-export-fixed-platform&noheader}}
</WRAP>

<--

--> Launch Vitis #

<WRAP GROUP>
{{page>programmable-logic:guides:vitis-launch&noheader}}
</WRAP>

<--

--> Create an Empty Application #

<WRAP GROUP>
{{page>programmable-logic:guides:vitis-create-app&noheader}}
</WRAP>

<--

--> Add Example Sources to the Application #

<WRAP GROUP>
{{page>programmable-logic:guides:vitis-add-hierarchy-example&noheader}}
</WRAP>

<--

--> Launch the Application #

<WRAP GROUP>
{{page>programmable-logic:guides:vitis-launch-app&showheader}}
</WRAP>

<--

===== Next Steps =====
Now that the hierarchical block's example design is running, modifications can easily be made to the hardware or software.

The Vitis sources provided with the hierarchical blocks are set up such that they can be easily included in any design using that block. The subfolder below sdk_sources contains all necessary drivers for the block.

For more reference materials and guides on the Digilent products being used, navigate to their resource centers, which can be found through this wiki's [[programmable-logic:start]] page.

For technical support, please visit the [[https://forum.digilentinc.com|Digilent Forums]].