AVNET MicroZed™ Evaluation Kit - Review

Table of contents

RoadTest: AVNET MicroZed™ Evaluation Kit

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 board, as outlined in review.

What were the biggest problems encountered?: Vivado and Petalinux versioning

Detailed Review:

Road Test outline

My goal for this road test is to give you an idea of what the MicroZed is and how it can be used. I will be comparing it to other Single Board Computer that you may be more familiar with. I will also be comparing it to it's siblings - other Zynq based board. Hope fully by the end of this road test you'll know what the MicroZed can do and if it suits a project you might have in mind.


I won't go into loads of detail on unboxing and getting started with the MicroZed as my fellow Road Tester b_smith has done an excellent job of this. I suggest you also checkout his road test here: AVNET MicroZed™ Evaluation Kit - Review


What are we road testing?

The MicroZed is a small (4" x 2.25" or 101mm x 57mm) and fairly unassuming development board. Take a quick look and the only distinctive features are an combined Ethernet / USB socket, a micro USB connector, a 14-pin JTAG connector and a 12-pin Pmod socket. It looks like any old Ethernet capable development board. Flip it over and you'll see a micro SD socket (still nothing remarkable). Then only thing to distinguish it from something like a Raspberry Pi is the two extremely dense and fine pitch micro headers underneath. These are the only things that suggest it might be something out of the ordinary. Well, read on. The MicroZed is anything but ordinary...


This MicroZed - being a bit "micro" - is designed to be small, hence it does not come with an on-board debugger. It needs and external JTAG debugger in order to be able to program it, and this Road Test included a suitable one - the Digilent JTAG HS3.


What is Zynq?

SBCs are everywhere these days. The Raspberry Pi is probably best known. It's great for a lot of things and it has sold millions of units to people who want to have a small computer that can also interact with hardware, reacting to switches and sensors, lighting LEDs, etc. A Raspberry Pi will usually be running Linux. Once again this is great for a lot of things, but not for anything real-time. Doing fast I/O isn't easy and doing predictably fast I/O is harder still. Just when you least expect it, Linux may swap your process out, garbage collect to free up memory, or who knows what. Even something fairly simple like PWM to drive a servo can be a problem without external peripherals.


I've recently been having a lot of fun with the BeagleBone - specifically the 2 Programmable Realtime Units that sit alongside the main ARM core - which will once again probably be running Linux. These PRUs are basically 16-bit microcontrollers and they will happily handle timing-critical tasks. If you like, you can think of it as a Raspberry Pi with a couple of Arduinos strapped to the side. And all of this in one little Sitara chip. Very handy. Where am I going with this? Well, if you thought having a couple of microcontrollers alongside you ARM microcontroller core was useful, how would you like a fairly hefty FPGA there instead? You would? Great. Welcome to the Zynq!


The essence of the Zynq is an ARM Cortex A9 core for the Processing System (PS) side of things. There's one in the S series, or two in the rest of the range such as this MicroZed. The ARM core(s) are combined with an FPGA for the Programmable Logic (PL) side of things. This is more or less an Artix-7 for most of the range although teh high end Zynq chips are more like a Kintex-7. These FPGAs are really powerful - powerful enough that you can even use it to create more microcontrollers if the BeagleBone's PRUs were to your liking. If not, well the world of programmable logic is your oyster. Hang on to the PS and PL acronyms by the way. The Zynq documentation will use them a lot.


How does the MicroZed compare to other Zynq boards?

OK, so you're interested in the Zynq processor. What now? There are quite a few Zynq boards available. The main manufacturers are Avnet (with their Zedboard range), and Digilent. I won't describe every Zynq board available, but here's a selection of the more notable ones.


BoardNotable features

PicoZed (Avnet)

This is one of the smallest boards available. Even more so that the MicroZed I'll be testing, this is intended to be a drop-in module on another board. It's available in quite a few variants of the Zynq - the 7Z010, 7Z015, 7Z020 and 7Z030. If size is very important and Ethernet / USB connectivity is not then this might be the right choice. Where the MicroZed has 2 high-density connectors underneath, the PicoZed has 3 - but very little else, not even a debug header. Debugging must be done via one of the high density connectors.


MicroZed (Avnet)

This is the board I'll be road testing, so expect more details to follow. Like the PicoZed it's mainly intended to be added to your own carrier board. Any Ethernet or USB requirements are handled for you though. A JTAg debug header is included although the debugger is not onboard. It's available with either the Zynq 7Z010 onboard (as tested here) or the larger 7Z020.


To make use of those high density connectors you will either need a breakout boardbreakout board, Pmod boardPmod board, FMC carrier cardFMC carrier card or to spin up your own design. This makes it a little harder for hobbyist use, but ideally suited to being a SOM for a production design.


MiniZed (Avnet)

This is a great getting-started board. Perhaps better than the MicroZed for many users. It has an onboard debugger, Arduino style headers and WiFi rather than Ethernet. If you want to get to grips with Zynq this might be the board for you. It's cheaper and can be used standalone.


Ultra96 (Avnet)

This is a much more powerful Zynq board. It contains a Zynq Ultrascale+ chip and is a huge step up for the boards we've mentioned so far. For instance it has a DisplayPort output if you want to Petalinux as a desktop environment. There are currently a few lucky traines learning about the Ultra96 v2 as part of Path II Programmable. I suggest that if you want to know more about this high-end Zynq board that would be the place to start.


UltraZed (Avnet)

This another Ultrascale+ Zynq board like the Ultra96, but available as a System on Module in two versions, the EG and EV.


Cora Z7 (Digilent)

This is another basic low cost offering, this time from Digilent. It's available with a Zynq 7Z010 onboard (like the lower MicroZed) but rather than stepping up to the 7Z020 it steps down to the single-core ARM version of the 7Z007S. A nice starter board though. Compared to the MiniZed though, it does need an external JTAG programmer.


Zybo Z7 (Digilent)

This is a nice Zynq board available in 7Z010 and 7Z020 variants. It's ideal if you want to do video processing. It has been road tested in that capacity here: Digilent Zybo Z7 + Pcam 5C


Pynq-Z2 (Tul)

Don't fancy getting your hands dirty with Vivado and HDL? More comfortable with Python? This Z7020 based board is the one for you. Once again, this has been thoroughly road tested by E14 members here: PYNQ-Z2 Dev Board: Python Productivity for Zynq®


MicroZed hardware

As this is a road test of the MicroZed rather than just a generic Zynq board, I'm going to start with the hardware - i.e. what makes the MicroZed a different choice from the others above.



The purpose of a SoM

It's a physically small board and it's primarily intended to be a SoM (System on Module) to add to your own designs. It certainly can be used as a development board, but the biggest gain will be to save you the hassle of designing the difficult bit of a custom Zynq board. You may have a particular requirement for a certain combination of peripherals and connectors to go on your Zynq board. A SoM means you can design the specific bits you need without having to do the really hard bit of the Zynq itself, DDR memory, etc. As long as your custom board has the appropriate Mezzanine connectors on it then you can drop the MicroZed on. There are other SoM options such as the PicoZed (if you don't need Ethernet) or UltraZed (if you need more power).


Using a carrier board

Apart from the single PMod connector, the only way to add to the MicroZed (or PicoZed or UltraZed-EG) is via the 100 pin fine pitch connectors on the underside. These are Amphenol BergStakAmphenol BergStak mezzanine. They're intended for placing one PCB above another - much like a mezzanine floor. The MicroZed contains the receptacles so your custom PCB will need matching plugs - part number 61083-10x400LF where x is the height you want.


If you don't feel like spinning up your own board then there are a number of carrier cards available. There is the standard breakoutstandard breakout, the 12 x Pmod12 x Pmod board and a development and FMCdevelopment and FMC carrier board. It might have been useful to have one of these included with the road test, but I can manage to test the board without needed a great deal of GPIO, so it's not a big problem. I notice my fellow road tester bought a breakout board to simplify his own work with the MicroZed. Note that some of the carrier board are almost the same cost as the MicroZed. If you're thinking of buying a MicroZed then bear in mind the cost of the debbugger and whatever board you chose to mount it on, as these are likely to be significant.


Getting started

So it's time to get started with the board. We'll obviously need an IDE even if it's just to get "Hello World" going and we'll need to attach the debugger to the board. The appropriate Xilinx IDE for the MicroZed is Vivado. The standard free WebPACK edition should be fine. The documentation mentions that the MicroZed comes with a device-locked voucher for the slightly better Design Edition, but I didn't find this. (The box had been opened, so maybe it went missing. It doesn't matter. I don't need it anyway.)



Vivado is the IDE you'll need to use with Zynq - at least until Vitis appears later in 2019. I have a love / hate relationship with Vivado. Let me sum it up for you.

Good things about VivadoBad things about Vivado
It's amazingly powerful. FPGAs aren't simple and the toolchain needs to be powerful. Vivado is an incredible piece of software that does a lot.It's HUGE. Not just a bit bloaty. Even the "just download what you need" web installer is a 7.5GB download and requires 25.9GB of disk space. Make that a 21GB download requiring 40GB of installation space if you go for the full thing!
The WebPACK version is free. It's not open source, which some people find important, but it's free to use - at least for the lower end non-commercial stuff.Versioning is hell. There are a few versions of Vivado over the years. Many examples or IP will only run on a specific version and porting between them is unnecessarily difficult. You may have to install more than one version of that huge IDE.

I've already installed the latest version of Vivado which is 2019.1. I'm going to try to use this with the MicroZed despite current examples being for versions no later than 2016.4. That's right - over 3 years and 8 versions out of date. image Wish me luck!


Installing Vivado is fairly simple. It may be huge and bloaty but installation is not difficult. Once it was installed I fired it up and decided to create a project for the MicroZed. Unfortunately, as it stands, Vivado is unaware of the existence of the MicroZed board. I have no idea why as other Avnet boards are there and the MicroZed isn't exactly new, but they're missing. Luckily they can be downloaded from here. The file your after is entitled "MicroZed Board Definition Install for Vivado 2015.3 through 2017.4" instructions ponly cover versions up to 2016.2, but if you extract the files as instructed to your 2019.1 installation directory then they appear to work just fine. You can then create a new Vivado project for the MicroZed as show in in the slideshow.

{gallery} New Vivado 2019 project


New Vivado 2019.1 Project: Step 1


New Vivado 2019.1 Project: Step 2


New Vivado 2019.1 Project: Step 3


New Vivado 2019.1 Project: Step 4


New Vivado 2019.1 Project: Step 5


Creating an application

The first step when using your wonderful and enormously configurable Zynq, is to decide exactly how your hardware is going to look. You have a few options.

  1. You can just use the Programmable Logic (FPGA) part of the Zynq. No problem with that. You could have just bought a cheaper FPGA, but this will work fine. If that's what you want to do then just start writing Verilog / VHDL using Vivado exactly as you would for an Artix-7.
  2. The FPGA is powerful enough that you can create your own microprocessor. That's a lot of work, but luckily Xilinx have written a 32-bit RISC soft processor for you. It's called Microblaze. Unless you're an FPGA guru (in which case why are you reading this?) then I'm going to guess that Xilinx have done a better job than you would. Once again this is more likely to be a desirable option if you have a pure FPGA, but you might want to do this. You could always run a Microblaze alongside the hard ARM cores in the Zynq if you want more processing power.
  3. You can use the ARM core(s) present in your Zynq. This is most likely what you'll want to do so that's what we'll be going through in this road test.


We're now going to create an application to run on one of the ARM cores. We'll start with the standard "Hello World over serial" example, but rather than just tell you what the steps are, I'm going to explain why we're doing them as this often seem to be forgotten. You can see this process demonstrated end-to-end in this video, although I'll summarise what I'm doing in case you'd rather read than watch.



Defining your hardware

In order to tell Vivado that you want an ARM core we need to define our hardware. On the left hand side under "IP INTEGRATOR" you'll find "Create Block Design". Click this and accept the defaults (unless you object to your design being called "design_1". This gives us an empty canvas onto which we can add our IP (Intellectual Property). In this case we're adding a wrapper round one of the Zynq's hard ARM processors. We then configure the processor and select "Create HDL Wrapper" to create a Verilog wrapper for it.


Placing this hardware in the FPGA

We then tell Vivado to generate the bitstream that represents the hardware we've defined. In this example we've just got a simple wrapper round the ARM core, but the whole point of programmable logic is that it could be more. Click "Generate Bitstream" and Vivado will create it for you. This isn't the quickest process if you're more used to compiling software.


Telling your IDE what your hardware looks like

Before we can program against this hardware, we need to tell our IDE exactly how the hardware looks. You're probably used to picking an appropriate processor when starting your favourite microcontroller IDE. This is no different, except that we have determined what the hardware is! Click "File / Export / Export Hardware.." and we have a definition that the IDE can work with.


Using the IDE to write software

Once we've told our SDK what we're developing against, we can start developing. "File / Launch SDK" should transport you into what's probably a more familiar world of using an Eclipse-based IDE to write some C code. We have a few samples to choose from, but "Hello World" is the simplest and just tests that our processor is running and can output a message over a serial port.


Exploring the pre-loaded Linux

This is explained in detail in the MicroZed getting started guide but I'll summarize it here. If you plug your MicroZed in straight out of the box, you will find that it loads a bitstream from QSPI flash which contains a build of PetaLinux. As the MicroZed has no video output, it is a command-line only build which you can explore this in a number of ways.


Using a serial port

If you've powered your MicroZed by connecting it to your PC over USB then you should see a new serial port appear. Simply connect to this using your favourite terminal (115200 8N1) and you're away. At the bash prompt you can do all the things you'd expect of a minimal Linux build.


Using SSH

If you've connected your MicroZed to you network using an Ethernet cable, then you can similarly connect using SSH. The default IP address is, so assuming your router is happy with this then we're away.


Web browser

The Petalinux OS running out of the box on the MicroZed includes BusyBox and is configured to serve a simple web page using httpd. Pointing your browser at should show you this. It's an old and out-of-date static web page, but serves to demonstrate that the Zynq can act as a web server.


The Getting Started guide covers the exploration of this Linux environment well and even includes examples of how to interact with GPIO (LEDs and buttons) from the command line or shell scripts. However, this is the sort of thing that the Raspberry Pi excels at and you'll find far more documentation and support. This isn't where the Zynq shines, and as such I don't think it's as good place to concentrate effort.

Zynq strengths and weaknesses

The power of Zynq

As you can imaging, the real strength of this device is combining the power to be able to run an embedded Linux distribution, but on top of custom hardware. Let's say you needed  to control 20 UARTs from a single web interface. No problem. Create the UARTs in Vivado and then control them from Linux. Maybe there's some very obscure protocol that you have no option but to create the peripheral yourself? Once again, that can be part of your custom hardware.

The problems with Zynq

I'm finding that just as it starts to get interesting, it also starts to get really (and to some degree unnecessarily) difficult. Whilst using Petalinux is reasonably easy, building it is lengthy and complicated. Whilst researching it, I've seen quite a few people get stuck. Particular versions of a Linux desktop OS is required. Board support packages are available for some versions of Vivado but not others. The current version of Vivado is certainly not supported.

Next steps

I'm definitely going to continue this journey. I'll be continuing to explore creating a custom processor underneath Petalinux. However, I feel that if I try to include all of this as part of this road test then I risk not completing it and detracting from what you need to know about the MicroZed. Hopefully it will turn out to be one of those "not too bad once you know about the traps" sort of journeys. Whether it is or not, it will probably warrant a separate post rather than tacking it onto this road test.

MicroZed strengths and weaknesses

You may have noticed that this road test has more or less being about the Zynq rather than specifically about the MicroZed. It's hard to do one without the other. The only thing that really distinguishes the MicroZed from other Zynq board is the form factor. This will either suit you or it won't. It's niche is when you need to produce a custom board but don't want to do the whole of a custom board. It has all the basics ready for you - Ethernet, USB, flash and SD card. It breaks out loads of high speed IO on those two high density headers so you won't be lacking for whatever you add.
Where it isn't as well suited is as a development board. That's OK though - there are plenty of other choices if that's what you're after. Maybe one of those is a better fit until you're ready to productionize your design?
All in all though, the Zynq is an amazing platform and the MicroZed is a great System on Module board for that platform.
  • It seems that the information in this road test is already somewhat out-of-date!


    I'm currently looking further into the PetaLinux side of things. I thought I might as well update everything from Vivado 2019.1 to the recently released Vivado/Vitis 2019.2. I was following the steps in my own video and it seems that the Xilinx SDK no longer exists! The File / Launch SDK entry in Vivado has gone! From this page I found that "There will be no 2019.2 or future releases of Xilinx SDK". I'm sure there is an equivalent, but it seems it's all changed and is now done via Vitis. Tools / Launch Vitis seems to an IDE experience with some resemblances to the Xilinx SDK. Yet more to learn...

  • It's now on my list of things to doimage . I was thinking that each Microblaze could then run the same code to test out how they interact as a single entity - e.g. program each to be an 'ant' with some simple code and see how they behave. Such a system would need the code to undertake some sort of algorithm but with an influence from their peers. Whatever the output metric I could see many experiments ramping to one of the 'end stops' in terms of value. But somewhere I suspect something really interesting and fun could be achieved.


    I'd love to know the kinds of messages that ants make when they collectively move some dead insect along the pathway, manoevre it, dissect it, rotate it and finally pull it into their nest. You'd find it hard to organise 1000's of people to do a similar task.


    ...or maybe it just needs some breadboard experimentation and a few handfuls of microcontrollers.

  • My experiments with PetaLinux is going reasonably well. I didn't want to install a VM and more copies of Vivado, so I've managed to get the PetaLinux tools running under WSL (Windows Subsystem for Linux) on Windows 10. It was a bit tricky. Surprisingly, one error seemed to be solved by moving to an insider build of Windows and enabling WSL2. This means that for now at least it's probably not a route most people would go down over using a VM.


    I think the problems I'm getting now are down to "normal" PetaLinux issues to do with versioning and BSP files. I've decided to go with a VM and get that working first. No point confusing myself further by trying to find my feet with PetaLinux and also going off-piste at the same time.

  • That would be interesting. The number of Microblaze (or Picoblaze) processors should only be limited by the size of the FPGA fabric. If you're coming from a software background one of the surprising things is that adding more won't slow them down. Each one is configured in hardware and will run entirely independently of the others.

  • Hi , I apologise as I missed your roadtest review a few days ago but luckily I did see an article by Randall linking back here image


    Your report is very interesting, well written and it is great to see the boards being compared. I nodded many times at your comments, good and bad, in agreement. I know some people have different versions of Vivado installed and have to switch between them depending upon board. Maybe I was luckily as I stumbled through the process and managed to pick a version that installed and works with several boards (Xilinx ZC702 and Arty S7-50).


    Whilst reading your report I did think of something: I wondered how many Microblaze have been implemented on a Zynq at the same time. That then made me think it would be a great base to test out some neutral type processing problems.


    I'm interested to see how you get on with PetaLinux.