Connected users can download this tutorial in pdf
First use of the Zynq-7000 Processor System on a Zynq Board
In this tutorial, we will use the Processor System (PS) part of a Zynq-7000 of a Zynq Board using the Vivado 2016.2. For this tutorial we will use a Xilinx ZC702 board but this could also been done on another board with a Xilinx Zynq -7000 SoC.
Configure the Processor System (PS) in Vivado
In this part, we will use Vivado to configure the Processor System part of the Zynq-7000. In particular we will see the mapping of the I/O peripherals (IOP) to the pins of the device.
Create a Vivado Project
Create a new Vivado RTL project targeting a ZC702 board. Create a new Block Diagram (BD) by clicking on “Create Block Diagram” in the flow navigator.
Figure 1 - Create a new Block Diagram in Vivado
Name the block diagram “zynq_platform”, keep the default settings for “Directory” and “Specify Source set” and click OK.
Figure 2 - Create Block Design
Add the Zynq SoC’s processing system in the BD by clicking at the add IP button and selecting ZYNQ7 Processing System. This IP is called a hard IP. It is already present in the Zynq SoC. Adding it to our project allow us only to select which component we want to enable an which pins we want to use (among the pins reserved for the PS).
Figure 3 – Add ZYNQ7 Processing System IP
Configure the Zynq7 PS
Double click on the IP to configure it. There are default settings for the ZC702. Click on “Presets > ZC702”.
Figure 4 - ZC702 Presets
By doing this, Vivado configure the MIO (Multi-use IO) to map the IO peripherals that can be used with the ZC702 to the correct pins.
Figure 5 - XC7Z020 AP SoC to CP2103 Connections (source: Xilinx UG850)
For example, as mentioned in the Xilinx UG850, the ZC702 board contains a Silicon Labs CP2103GM USB-to-UART bridge device which allows a connection to a host computer with a USB port. The CP2013GM TX and RX pins are physically wired to the UART_1 IP block within the XC7Z020 AP SoC PS I/O Peripherals set. As shown in the Figure 5, the CP2013GM TX and RX pins are connected to the MIO48 and MIO49 pins of the FPGA.
If we click on “MIO configuration” in the Zynq7 PS customizing GUI, under “I/O peripherals” we can see that Vivado has correctly mapped the UART 1 to the MIO48 and MIO49. You can check/configure the UART Baud Rate in “PS-PL configuration” under “General”. By default, this should be 115200.
Figure 6 - Zynq PS MIO Configuration
Exit the Zynq7 PS customizing GUI by clicking OK. In the BD, connect the output pin FCLK_CLK0 of the Zynq7 PS to its input pin M_AXI_GP0_ACLK.
Figure 7 - Connect the output pin FCLK_CLK0 of the Zynq7 PS to its input pin M_AXI_GP0_ACLK
Verify that the design is correct by clicking on the “Validate Design” icon. You should have no issue. Save the BD.
Generate the HDL files
In the source window, right click on the BD and click on “Generate Output Products”. This will generate the HDL files corresponding to the Zynq7 PS IP.
Figure 8 - Generate Output Products
In the “Generate Output Products” window, select “Global” and click on “Generate”. When the Output Products generation is over, right click again on the BD and click on “Create HDL Wrapper”. On the “Create HDL Wrapper” window select “Let Vivado manage wrapper and auto-update”.
Figure 9 - Let Vivado manage wrapper and auto-update
You can see that a HDL (VHDL or Verilog) file has been created on the top of your BD. The file type (VHDL or Verilog) depends on your project settings. You can change it by clicking on “Project Setting” in the Flow Navigator and changing the setting for “Target language”.
Figure 10 - Target language setting
When the wrapper is created, click on “Generate Bitstream” in the Flow Navigator and click yes if a “No Implementation Results Available” window appears.
Program the PS using Xilinx SDK
Export the hardware to Xilinx SDK
To program the Zynq PS we will use the Xilinx tool SDK. First we need to export our PS configuration (and the generated Bitstream (optional)) to Xilinx SDK: In Vivado, click on “File > Export > Export Hardware”. In the “Export Hardware” window, select “Include Bitstream”.
Figure 11 - Export Hardware
When you leave the “Export to” option to “<Local to Project>”, the Hardware is exported in the folder “<project_folder>/<project_name>.sdk”. In this folder, the file exported is the file “zynq_platform_wrapper.hdf”, HDF standing for Hardware Definition File. An interesting thing to note is that this file is a compressed folder. If you open it using a tool such as 7-zip you can see that it contains several files including the Bitstream file “zynq_platform_wrapper.bit”.
Figure 12 - zynq_platform_wrapper.hdf file
Then, in Vivado, launch Xilinx SDK by clicking on “File > Launch SDK”. Keep the default settings in the “Launch SDK” window and click OK.
Test the Processing System with the “Hello World” project
In this part we will realize a bare-metal application. Bare-metal refers to a software system without an operating system.
In SDK, in the “Project Explorer” we can see the Hardware Platform “zynq_platform_wrapper_ hw_platform_0” created from our .hdf file (we can see that it includes the same files).
At least three parts are needed to have an application running on the Zynq PS:
· An hardware platform
· A bare-metal Board support Package (BSP). This is a collection of libraries and drivers that form the lowest layer of your application.
· Your application.
Create the application
To create a new “Hello World” application, click on “File > New > Application Project”. Name the application “hello_world”. Make sure that the “OS Platform value” is “standalone” which corresponds to a bare-metal application. You should have your hardware platform selected. We will use the first core (ps7_cortexa9_0). As you can see at the bottom of the window, Xilinx SDK will automatically create a BSP for our application containing all the drivers we will need.
Figure 13 - Create a new application in SDK
Click “NEXT”, select the “Hello World” template and click “FINISH”.
Figure 14 - Hello World template
Launch the application on the board
Build the application by clicking on the build icon. To test the application on the board, first make sure the the USB-to-JTAG and the USB-to-UART cables are connected from the PC to the board. Then power on the board. Program the FPGA by clicking on the program icon and clicking on “Program”.
To launch the debbuger, select your application, click on the little arrow next to the debug icon and click on “Debug Configurations…”
Figure 15 - Xilinx SDK - Debug Configurations
Right click on “Xilinx C/C++ application (GDB)” and click “New”.
Figure 16 - New Xilinx C/C++ Debug application (GDB)
When the new Xilinx C/C++ Debug application (GDB) has been create, click on “Debug”.
Figure 17 - Launch the Debug
If a new Debug window appears to ask you if you want to change for the Debug view, click YES.
Open an UART terminal to see the output of the console. You can open an “external” tool such as “Tera Term” or open an UART console in SDK by clicking on “Window > Show View > Other…” and selecting “Terminal”.
Figure 18 - Open an UART terminal in Xilinx SDK
In the terminal, click on the settings icon to configure the terminal. Select “Serial” and “115200” as “Baud Rate”.
Figure 19 – UART terminal configuration
Launch the application by clicking on the Resume icon.
We can see “Hello World” printed in the console, showing that our application is correctly working.
Figure 20 - Hello World printed in the UART terminal
Understand the Software code
Figure 21 - Content of the file helloworld.c created by Xilinx SDK
The code of the application is shown in the Figure 21. You can see it by opening the file helloworld.c in the application hello_world.
Figure 22 - file helloworld.c created by Xilinx SDK
In the library declaration part of the file, we can see that 3 libraries are declared:
· stdio.h which is part of the standard C library.
· platform.h which contains the function prototypes init_platform() and cleanup_platform().
· xil_printf.h which contains Xilinx function for input/output data through the UART.
In the first line of the main(), the SW call the function init_platform() which initialize the platform. Basically, for our application this function will configure the UART. In the second line the function print() is called to send “Hello World” to the UART. This function is a simplified version of the printf() function from the stdio C standard library. The third line of the main() call the function cleanup_platform() which clean up the platform (disable cache). The last lane, “return 0” ends the program.
Post a comment
Only connected users can post comments