Table of contents

RoadTest: AVNET MicroZed™ Evaluation Kit

Author: Fred27

Creation date: 21 Oct 2019

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.

Board	Notable 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

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.

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. 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.

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.

Edit media

Dimensions x Small Medium Large Custom

Subject (required) Brief Description Tags (separated by comma) Video visibility in search results Visible Hidden

Parent content

AVNET MicroZed™ Evaluation Kit - Review

Poster

Upload Preview

Ok

Cancel

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 192.168.1.10, 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 http://192.168.1.10 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.

Zynq strengths and weaknesses

The power of Zynq

The problems with Zynq

Next steps

MicroZed strengths and weaknesses