Eclypse Z7: Zynq-7000 SoC Development Board - Review

Table of contents

RoadTest: Eclypse Z7: Zynq-7000 SoC Development Board

Author: Fred27

Creation date:

Evaluation Type: Development Boards & Tools

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: Other Zynq based development boards.

What were the biggest problems encountered?:

Detailed Review:

Road Test outline

My goal for this road test is to give you an overview of the Eclypse Z7 board. I'll focus on how it compares to other Zynq-based boards that you might be considering as an alternative. I've worked with - and road tested - a few Zynq boards. Whilst they all share the same key feature of a Xilinx Zynq SoC, they all tend to be designed with different purpose in mind and some have very different connectivity. This is the first board I've seen with a SYZYGY connector, so I'll dig a little into this. I also find that how well the board is supported is significant. Are there good examples? Can you find a Board Support Package so you can work with a recent version of Vivado / Vitis / Petalinux? I feel these are the things that will make the difference between hitting the ground running with your design and struggling with the tools at hand.


What is the Eclypse Z7?

The Zynq Z-7020

The Eclypse Z7 is of course a development board based around the Xilinx Zynq. The Zynq 7000 range combines an ARM processor and FPGA fabric in the same SoC. This board uses a Z-7020 which is somewhere around the middle of the Zynq 7000 range. It has a dual-core ARM A9 processor running at up to 866MHz. It also has FPGA fabric roughly equivalent to a Spartan-7. In this case we have 85K logic cells, 4.9Mb of block RAM, and 220 DSP slices. To put this into perspective, the smallest Zynq in the range (the Z-7007S) has a single ARM core and about 1/4 of the FPGA resources. The largest (the Z-7100) has about 5 times the FPGA resources.


Like I said, it's about in the middle of the Zynq 7000 range. The ARM cores are quite capable of running Linux. The FPGA fabric is must likely adequate unless you have something hefty l going on. It's worth noting that the Zynq 7000 is marketed as "cost optimised". There are also much more power full Zynq UltraScale+ processors available, but that's not what we're looking at today.


Here you can see what was provided for the road test. The main Eclypse board is supplied with a USB On The Go cable, a micro USB cable and a power supply. Note that the power supply includes twist-on style adapters for US and European sockets. For my UK outlet I needed the clunky beige adapter seen above (not supplied). It's not a huge deal but a bit annoying that the adapter is now one of those wobbly oversized ones. In comparison, the power supply with my Ultra96 has a cable with a C8 connector, so I could easily and neatly swap this out. I also considered using my Ultra96's 12V power supply for the Eclypse, but unfortunately the barrel jack on the Z7 is an unusual size.


The two Zmod boards are also shown attached to the Eclypse. They are supplied separately from the Eclypse board, so need to be purchased separately if you need them.


Eclypse Z7 and ZMODsForm factor and connectivity

I'd describe the Eclypse Z7 as a medium-sided development board. The stand-out features are an Ethernet jack, an micro USB OTG port (with a short cable to a USB socket), and of course the two ZMOD connectors. There are also the usual buttons (2), user LEDs (2 x RGB), USB for onboard JTAG, external JTAG header and 2 x PMOD. There are two reset buttons - one for the processor and one for the whole board - which are a bit hidden under the microSD card slot and are side action. This stock photo shows the board and ZMODs. The fan makes it look bigger than it is but the fan is tiny. The RJ45 and microSD on the left and the SMA connectors on the right should give you a sense of scale.


The form factor certainly hints heavily towards using the two Zmod peripherals supplied for this road test - one ADC and one DAC board. There's ample room to secure the peripherals to the board. The Samtec Q-strip connectors are not massively supportive, so couple of screws aren't a bad idea, especially if you have something connected to the SMA sockets. I would have expected some screws (M3 by 5mm) to be supplied with either the Z7 or the peripherals. Obviously it's not a very expensive addition but it's the sort of thing that would have made it feel a bit more complete.


Eclypze Z7 enclosure These two peripheral are made to feel even more an essential part of the board by the fact that there is an aluminium enclosurealuminium enclosure available and this has cutouts which fit them exactly. I suppose you could chose 4 ADC inputs or 4 DAC outputs instead of 2 of each if you wanted. Anyone tempted to make their own 4 channel PC based scope? Sure it'd only have a 70MHz bandwidth and be more expensive that something off the shelf, but when has that ever stopped us?


Actually, looking at the product photos, the enclosure does seem to include a few flat headed M3 screws, so there you go. It also solves the mystery of the location of the reset buttons. These are obviously located where they are so they're accessible (using a pin or wire) when the board is in the enclosure.


All in all, the Eclypse Z7 seems definitely aimed at enterprise use rather than the "bare dev board sitting on a hobbyist's desk" sort of thing.


What's this Zmod / SYZYGY thing anyway?

You can't ignore one of the unique features of the Eclypse Z7, the Zmod ports. This is an unusual interface. In fact the only other board I've seen it on is the larger Genesys ZU: Zynq Ultrascale+ MPSoC Dev Board which was also road tested on E14. That only had the connector on the edge of the board rather than a large expanse of PCB real estate dedicated to mounting a whole peripheral board. The ZMOD follow the SYZYGY standard which is something created by Opal Kelly. Excluding the 2 Digilent peripherals here, the only SYZYGY compatible boards I can find are a range of 6 peripherals and 2 breakout boards from Opal Kelly themselves. They also have a Zynq SoC based and a strangely expensive Artix-7 FPGA based carrier board and a couple of cables and loopback test boards.


The concept seems nice. It's designed to be an improvement over PMOD - for when you need something a little higher speed than 0.1" pin headers can handle. There is of course the high speed and high pin count FPC mezzanine connector, so where is the SYZYGY supposed to fit? Well - the mezzanine connectors certainly work well but they're expensive and complicated. SYZYGY is supposed to go in the middle. I shall be digging a bit more into Zmod / SYZYGY later in the road test.


Getting started with the Z7

One of the most important things about a development board is how easy it is to get started. Can you concentrate on your design or do you spend ages battling the documentation? I've worked with a few Zynq boards and sometime you find that examples are stuck on an older version of Vivado. It can be particularly tricky to upgrade a project to a later version of the tools if it contains a block design with IP from a repository.


I did a quick check before applying for this road test and Digilent do seem to provide a lot of support material. They seem to target a reasonably recent version of the tools - Vivado 2019.1 - which compared to other vendors is pretty good. There was a significant change in Xilinx tooling just after this - especially on the software side of things. Vivado 2019.2 was when the SDK was replaced with Vitis and the BSP files which are needed for petalinux builds were replaced with XSA. Whilst it would be great to see the latest 2020.1 supported, 2019.1 seems reasonable.


OOB demo and basic support files

The Z7 comes with a very basic OOB demo installed. The two onboard RGB LEDs pulse and change colour and the two onboard buttons report "Button X pressed!" over a USB serial port. This really is just enough to prove that the board is loading the FPGA bitstream and microcontroller code from flash and everything is working.


There are two things that are essential if you want to get started quickly building a bitstream for your device - board files and a constraint file. Both of these are provided by Digilent in their github repositories in the same place as their other boards. You'll find the board files at and the constraints as These files tell Vivado what chip is on board, and how it's connected to peripherals and the outside world. Once you've followed the instruction and copied these to the appropriate folders on your PC then it's easy enough for anyone familiar with FPGA development to create a project in any recent version of Vivado.


Support for more advanced features

Whilst basic support for the Zynq SoC on the board is fairly easy, things get slightly more complicated when you dig a little deeper and want to make use of the two Zmod peripherals. Once again Digilent have supplied lots of useful information, but it's not as simple to make use of it. There is a comprehensive git repository just for the Eclypse-Z7 although you will need to read the instructions carefully before jumping in. You'll find these instructions here.


Cloning (the right branch of) the Eclypse Z7 repo

There is a detailed explanation of exactly how to clone the right branch of the Eclypse Z7 repo. Digilent have clearly spent a lot of time thinking through exactly how to best support the board and the Zmod peripherals that go with it. They seems to have developed a branching strategy that not only supports various versions of the code as it is developed, but also have non-merged feature branches which they call "dodders" for different peripherals.image


In some ways I applaud the effort they've gone to, but in others is seems like I need to learn Digilent's internal procedures just to run some sample code. For instance, here's a diagram that explains it all. Clear as mud, right? It's great to have these processes and procedures, but they should be internal. I shouldn't have to know all about them.


Once you have found the right branch for the "dodder" you need - and of course, the right sub-branch of the dodder because dodders also have branches too - then you can pull the code down. Don't forget about the sub-modules! You didn't forget about the sub-modules, did you? OK - we've now got the code.


I won't try to re-explain the procedures that to be fair are thoroughly documented. Suffice it to say that I got the code I needed with the following:


git clone --recursive
git checkout zmod_adc_dac/master
git submodule update --init --recursive


The three submodules of the repo are hw (for the Vivado hardware project), sw (for baremetal examples) and os (for running the petalinux examples). Going through these one by one should give us a view of how to use the ADC and DAC Zmod peripheral boards.


Opening the hardware project

Now, you'd think there would be a Vivado project in here, and you'd be almost right. Vivado projects can be a little tricky to put under source control and Digilent have found their own way to address this. It does seem like a good way, but once again I fend myself learning about how Digilent do source control before I can open a sample project.


There isn't actually a Vivado project you can open until you run a Digilent TCL script to create it for you. You need to open up Vivado, change to the appropriate folder and run digilent_vivado-checkout.tcl. Once you've done this then the Vivado project appears and you can work with it as normal.

cd D:/Documents/Xilinx/digilent-Eclypse-Z7
set argv ""; source /hw/digilent-vivado-scripts/digilent_vivado_checkout.tcl


This Block Design contains everything you need to create a hardware design based around the Eclypse Z7 and the two supplied Zmod board. You're not on your own controlling them. Digilent have very helpfully created a couple of IP blocks that abstract away the details of how the boards are connected.


Running the baremetal software example

This hardware design has already been synthesised and wrapped up ready to be used by any C code you write for the Zynq's ARM code. You could modify and resynthesise it, but it's already available for use in a pre-made SDK project. Rather than running the SDk from within Vivado as you might do for your own project, the Digilent guide tells you to open the sw folder and import the preexisting projects into the workspace. Rather the parroting out these instructions, you'll find them here. Before long you'll find that your C code is up and running. There are nice, clear and well commented C++ classes for interacting with the Zmod. By default it produces a ramp output with a 3V peak with a 2V offset (i.e. from -1V to 5V) on channel 1.



Running the petalinux example

Running the petalinux example is slightly more complicated, but not too much so. Digilent supply a prebuilt petalinux disc image and running this is as simple as flashing a microSD card (not supplied), setting the bot jumper to SD and powering on. This image doesn't by do anything with the Zmods on startup. I was quite impress by the way the example code is run. i wasn't aware that you could remotely debug an executable running in petalinux from the SDK environment, but that's what we do.


Once again following Digilent guide, we extracted a zipped sysroot folder and make a configuration change to the project. Then we connect the Eclypse Z7 via Ethernet determine its IP address. Once we have this, the Xilinx SDK can connect to the Linux TCF Agent and remotely deploy and debug the Linux C++ application. The configuration of the connection to the Zmod is a little different, but we run exactly the same ramp generator code. There's surprisingly little difference in the experience of running this as baremetal, which is impressive - even if it's not impressive to look at!



I know that my fellow road tester Bartosz intends to dive a bit deeper into the petalinux side of things so I'm going to shift my focus to more of the hardware side.


A custom Zmod board?

In order to test out the theory that SYZYGY is a bit more accessible than FPC, I decided to create my own Zmod board. The specification is all open and well documented here. The Samtec QTE-020Samtec QTE-020 connector used is available from Farnell for about £5 each. There's no excuse to avoid firing up Eagle and designing something!


As I'll have to design the PCB, wait for them to be manufactured in China and sent on the slow boat to the UK, populate them and only then test integration with the Eclypse Z7 this may take me longer than a usual road test. I've decided to publish this part and blog about the Zmod hardware deep-dive separately. I know, I know. Often when you see "to be continued..." on a road test that the last you hear of it. That won't be the case. The design is already in progress. It just won't be quick!



The first part of my Zmod (which technically is not a Zmod but a SYZYGY board) is here: Creating a SYZYGY board for the Eclypse Z7 - PCB design



The Eclypse Z7 seems a well thought out Zynq board. It's clearly aimed at a different market to many others. There are no Raspberry Pi or Arduino style headers you'd expect from a hobbyist or experimenter's board. There's no WiFI or Bluetooth; it favours Ethernet (which I like). There's no built-in audio or video capability. The real focus is the 2 SYZYGY ports. Time will tell whether anyone else apart from Opal Kelly and Digilent embrace this. It would be odd I become #3 in the SYZYGY ecosystem! image


The software support is very good, even if it takes a little while to get into. To be honest I expected this from Digilent and they did disappoint. They usually do a good job of this.


In summary, I can thoroughly recommend the board if it fits your use case. If you need different connectors or peripherals then Digilent (and others) have Zynq boards that might suit you better. If this has what you need or particularly if you want to create your own high speed peripherals then go for it!