Skip navigation
> RoadTest Reviews

Digilent ARTY S7 Dev Board (Xilinx Spartan 7) - Review

Scoring

Product Performed to Expectations: 10
Specifications were sufficient to design with: 10
Demo Software was of good quality: 10
Product was easy to use: 8
Support materials were available: 9
The price to performance ratio was good: 10
TotalScore: 57 / 60
  • RoadTest: Digilent ARTY S7 Dev Board (Xilinx Spartan 7)
  • Buy Now
  • Evaluation Type: Development Boards & Tools
  • Was everything in the box required?: Yes
  • Comparable Products/Other parts you considered: The Arty S7 is probably the only board with a Spartan-7 available (at least at this price), so there is really no board to compare to. The closest Xilinx-based board for comparison, with similar characteristics and price, would be the Arty A7, based on Artix-7 35T FPGA. From a different vendor, but still in the same price bracket and performance, there are boards based on the Intel MAX 10 FPGA (10M50)
  • What were the biggest problems encountered?: Documentation: the abundance of very detailed and very specific guides from Xilinx, extremely useful to the experienced and the professionals, can be daunting for a maker without experience. More "quick start" or "fast track" kind of documentation, targeted to getting a novice up to speed quickly, would be very helpful.

  • Detailed Review:

    Introduction

    I would like to start by saying thank you to rscasny, Element14 and Digilent for the opportunity given to test the Arty S7 board.

     

    I have done some digital design in the past, but it has been long time since I last used FPGAs, so this was a great opportunity to get back on the saddle and give it a go again. I applied to this RoadTest to test the Arty S7  because, as a maker, I am interested in finding out if, and how,  a maker can benefit from this board, and the FPGA technology in general. I have no experience with Digilent's boards, Spartan-7 FPGA or the Vivado toolset, so I'm approaching this review as a novice.

     

    I have been reading about the FPGArduino, a project aiming to integrate FPGA development boards with the Arduino IDE, allowing the makers to use the well known Arduino development process to program their FPGA board. As part of the RoadTest, I was going to use FPGArduino to design a thermal detector using the Arty board and the Panasonic GridEye sensor, without the need to design the hardware part for the FPGA (the porting would have taken care of that, creating a system based on the f32c soft processor).

     

    Unfortunately, I haven't manage to complete the porting of the board yet, so for the RoadTest, my project has been carried out using my backup plan: design the hardware for FPGA around the MicroBlaze soft processor. I will be creating separate blogs about FPGArduino and the porting later on.

     

    To give a better structure to the review, I have written several blogs about the board and my project, following its evolution from start to finish, and below you can find the links to such blogs (idea borrowed from three-phase's Megger Insulation Tester - Review).

     

     

    The Digilent Arty S7 Series
    The Digilent Arty S7: An Unexpected journey - Part 1 - The Board
    The Digilent Arty S7: An Unexpected Journey - Part 2 - The Tools
    The Digilent Arty S7: An Unexpected Journey - Part 3 - To the drawing board
    The Digilent Arty S7: An Unexpected Journey - Part 4 - The Code

     

     

    The review will cover the following:

     

    • Getting familiar with the board: this part includes the usual unboxing ritual to show what you get with the box and a description of the main features of the board
    • Basic setup for functional testing of the board: this part illustrates how  to set up the development environment, configure the board and run the standard demo applications available on Digilent's website, to make sure everything is in order
    • Development of my project using Arty S7: for this I'm planning on using the Panasonic Grid-Eye 8x8 pixel IR sensor to create a simple thermal object detection device. The sensor will be connected to the board via I2C, and will detect human presence/movement by analysing the change in the 8x8 pixels frames, triggering an alarm upon detection (using the LEDs on the board).

     

    Unboxing

    The first thing you notice once you open the box, and get rid of the wrapping, is the nice paper packaging the board comes in. After fiddling a bit, trying to get to the board without ripping the paper, finally you get to see the board, nicely padded in pink molded foam. The board is of a nice size, and the build quality is good. The components are well placed on the board, so that connecting wires won't get in the way.

     

    {gallery} Unboxing the Arty S7

    Arty S7 Paper Packaging

    Arty S7 Paper Packaging

    Arty S7 foam padding

    Arty S7 Foam Padding

    Arty S7 Out of the box

    Arty S7 Out of the box

    Arty S7 front

    Arty S7 Front

    Arty S7 back

    Arty S7 Back

     

    The board comes without USB cable, but that is not a big deal, as it is a common cable, and chances are everybody will have one hanging around the house somewhere that can be borrowed.

    The same cable can be also used to supply power to the board. Alternatively, you can use a dedicated 7-12V power supply, connecting it to the jack available on the board.

     

    Board Specifications

    The board received for the Roadtest is the Digilent Arty S7-50, rev.B. This board is packed with features, also considering the price. Below you can find all the features of the board. If you want to know more, in Part 1of my blogs, you can find a more detailed description of the components on the board, or you can check the reference manual from the Digilent website.

     

    The board will give you:

     

    Xilinx Spartan-7 FPGA
    xc7s50csga324-1
    MemoryBasic I/OExpansion
    Connectors
    PortsPower
    choices
    Other
    8,150 slices (4 6-input LUTs + 8 FF per slice)
    75 blocks of 36Kb BRAM (2700 Kb)
    5 clock management tiles
    120 DSP slices
    On-chip analog-to-digital converter (XADC 1MSPS)
    256MB DDR3 SDRAM (16-bit bus @650 MHz)
    16MB Quad-SPI Flash
    4 Switches
    4 Buttons
    4 LEDs
    2 RGB LEDs
    4 Pmods
    1 Arduino/chipKIT shield connector
    USB (JTAG - UART)
    I2C
    SPI
    USB
    7V-15V external power source
    1 Reset button
    1 Program
    button

     

    Particularly interesting, from a maker's perspective, are the expansion connectors: together with the power and flexibility of the FPGA, the 4 Pmod headers and the Arduino/chipKIT shields connector provide quite a rich set of interfaces for extending this board. When planning to use Arduino/chipKIT shields, though, you need to make sure they are not designed for a 5.0V signal level, as the pins of the header are connected to the FPGA I/O pins, which can only accept up to 3.3V, and could burn the FPGA's pins.

     

     

    Set up and testing

    The board is shipped with the Out of the Box Demo preloaded in the Flash memory, so when you power it up, you are greeted by some fancy LED animation display, and you can also play with the buttons and switches, as it i shown in the video below:

     

     

    The next step is the set up of development environment for the board.

    For the Roadtest, I'm using 2 Intel i7 machines, one equipped with 8GB RAM and 1TB HD, and the other with 16GB of RAM and 500GB HD (SSD). Each of the machines is configured with dual boot, and both have a Linux boot (Debian 9) and a Windows 10 boot.

     

    To get started, the Digilent Arty S7 resource page contains all the necessary information to download and configure the tools.

    As for all the Xilinx FPGA-based boards, to be able to program the Arty S7 you need to use the Xilinx proprietary toolset. Xilinx tools tend to be pricey, but fortunately the Spartan-7 family is supported by the Vivado® HLx Design Suite WebPack™ Edition, which is free to use (but you need to register on the Xilinx website in order to be allowed to download the software).

     

    Part 2 of my blogs describes in detail the process of setting up Vivado WebPack. This development environment is an heavy tool, with quite taxing requirements for processing power, RAM utilisation and disk space. In particular, before starting the installation, it is advisable to check the recommendations for the minimum amount of RAM required (the Spartan-7 are not listed there, but probably you can apply the same recommendations as for the Artix-7/Zynq-7000).

     

    The space on the disk occupied by Vivado depends on the options chosen during the installation, and can vary between 22GB and 32GB roughly. I have chosen to install only the support for the Spartan-7, Artix-7 and Kintex-7 devices, leaving out all the others. Similar choice for the Compiler Tool Chain: I have chosen to install only the MicroBlaze one. This way I manage to reduce  the occupation on disk to "just" 24GB. I also have chosen to install  the Documentation Navigator: Xilinx produces an incredible amount of documentation (Guides, Application Notes), and navigating through all this stuff can be daunting, especially when you have to search it on the internet. I found the Documentation Navigator extremely helpful, offering a clean and friendly way of accessing the documents, although at expense of some disk space.

     

    The install procedure takes some time, as it need to download the software from the internet (in my case, about 5GB of data, and if you happen to have a slow internet connection, you can make yourself a brew or two while you wait for the install to finish). On Windows, the installation procedure will also take car of installing the drivers to connect to the board via USB. On Linux, this has to be done manually, by running a script created by the installation.

     

    Once installed, Vivado needs to be configured for the Arty S7. This is achieved by importing the Digilent Board Files for Arty into Vivado, an again, the Digilent's guide is of great help to successfully complete the task (the board files can be downloaded from Digilent's GitHub boards repository).

     

    With the development environment set up, the next step is to test the board, using the demos provided by Digilent. All the source code for the demos can be downloaded from Digilent's GitHub, and the demos are shown in the videos below:

     

     

     

    {tabbedtable} Tab LabelTab Content
    XADC Demo

    XADC Demo

     

    This demo uses the 1MSPS analog-to-digital converter that comes with the Spartan-7 FPGA to sample the voltage applied to 2 pins of the Arduino compatible header (the voltage needs to be limited to 0V-3.3V, to avoid damaging the FPGA pins). The LEDs on the boards will act as rudimental meter (0V – all LEDs off, with the LEDs turning on one at time when the voltage increases, to reach the 3.3V – all LEDs on). The selection of which pins of the header to use as ADC input can be made by using a specific combination for the 4 switches on the board.

    The tutorial to guide you through the demo can be found here, and the source code of the demo can be found on Digilent's GitHub,

    General I/O Demo

    General I/O Demo

     

     

    This demo tests the  LEDs, switches, buttons, and USB-UART bridge.

    The tutorial to guide you through the demo can be found here, and the source code of the demo can be found on Digilent's GitHub.

     

     

    The Project

    For this RoadTest, my idea was to build a simple Infra-Red thermal detector based on the Arty board, which would trigger an alarm when a change in temperature is detected. The sensor used for the temperature is the Panasonic AMG8833 GridEye, mounted on the Maxim MAXREFDES131, and it is driven via I2C connection.

    Basically, the system needs to be able to:

    • manage monitored zones: the field of view of the Grid-Eye sensor will be split in 4 regions, and each region can be enabled/disabled independently;
    • set temperature threshold: this is the temperature that will trigger the alarm. Normally, for thermal detection, you can use the temperature reading either for absolute or differential check. In case of absolute check, the reading is compared against a preset threshold value, and if it equal or greater than the reference, the alarm will set off. For the differential temperature, you need to have a background reference temperature, which will be subtracted from the reading, and such difference will be compared to the set threshold, setting off the alarm if equal or greater;
    • acquire the background frame: this is the reference frame used for temperature differential check;
    • reset the alarm: well, I think this is self-explanatory! :-)

     

    The design of the project included the hardware design (ie the MicroBlaze based system to be implemented in hardware on the FPGA), and the software design. The software will be created using the Xilinx SDK, and leveraging the seamless integration offered for design based on the MicroBlaze soft processor. You can find a detailed write-up about both designs respectively in Part 3 and Part 4 of my blogs.

     

    For the hardware, to keep the design the process as easy as possible, I used Vivado's Block Design feature, and worked with the IP Integrator. The nice thing about using the block design is that, every time you add a new IP core to your design, you can leverage the Designer Assistance wizard tools:

     

    • the Block Automation wizard: guides you through the customisation of the IP block;
    • the Connection Automation wizard: helps connecting correctly the blocks bewteen them and with the external ports.

     

    I was impressed by how smart those tools are: clearly a lot of knowledge has been embedded in them by the Xilinx developers. This is definitely good news for the makers, as moving the design to a higher level means there is less details to deal with. Unfortunately, as smart as these tools can be, some times they can exercise a bit too much "creativity" while inferring what you want to do with the new module, creating some bizarre connections between the ports. Below you can take a look at the finalised design for the hardware.

     

    Block Design

     

    The software part of the project has been created using the Xilinx SDK, an Eclipse based development environment. As previously mentioned, having used MicroBlaze for the hardware design, I was able to leverage the integration between the Hardware development environment and the SDK. This meant that all the libraries to support the IP cores I have used in the hardware design were available "out of the box", and I was ready to start developing the application code straight away.

     

    The code for the software part can be found in my GitHub repository. For a detailed walk-through of the design and implemetation of the software, please have a look at Part 4 of my blogs.

     

    Below there is a demo of the implemented system, where I show in particular how the user interface works (that was the trickiest part of the project, as I could only use the 4 buttons, the 4 switches, the 4 green LEDs and the 2 RGB LEDs to create the user interface!).

     

     

     

    Remarks on Vivado

    During the Roadtest, I wanted to do some tests on Vivado. On my machines, I have installed Vivado version 2017.4 and 2018.1, on both the Linux and Windows OSes. Then I run my project's design on both versions and compared the results.

    The results have been consistent with all the versions tested, and besides the differences in the graphics (the newer version of Vivado looks better), the processing times are basically the same.

    The implemented design result were different though. Below you can appreciate how differently the 2 versions have placed and routed the same IP blocks.

     

    implemented designs comparison

     

    Now, this is possibly due to the heuristic rules used by the software to place and route the components, considering that I have not provided constraints on paths or nets. Nevertheless, it is quite an interesting thing to notice, because those differences could have some repercussions on performances, in particular on power usage. The estimates don't seem to be showing much difference, which would imply the 2 implementations are indeed equivalent, from a power consumption perspective (you can see on the power estimation report summary below).

     

    power comparison

     

    Those reported are estimates for the power, and Vivado explains the confidence level is low, because of lack of specification on the I/O activity. Anyway, to have an idea on how far those estimates are from the real values, I decided to calculate the power used by the FPGA. The board provides 2 jumpers (J3 and J4, in the figure below) to calculate the current drawn by the 2 rails (1.0V and 1.8V) which power the FPGA, by reading the voltage across the 0.01 ohm sensing resistors.

     

    power schematic

    The readings, and the power calculations are reported in the table below:

     

    Vivado Version1.0V rail (JP3) 1.8V rail (JP4)Power (actual)
    Power (estimated)
    Error on estimate (%)
    2017.43.7mV / 370mA4.11mV / 411mA1.110W0.907W22.4
    2018.13.69mV / 369mA4.11mV / 411mA1.109W0.919W20.7

     

    From the numbers above, we can infer that Vivado is right in grading the confidence level as low, as the errors are quite large. The good news is that, according to the readings, the 2 implementations, although slightly different in the way the components have been placed, seem to be identical in terms of power consumption, again proving the 2 versions of the software behave consistently.

     

    It is also interisting to note that, still on the power front, the FPGA doesn't seem to dissipate a lot of heat (in agreement with what is stated in the power summary report). I left the system running for hours, and when I checked, the reading for the temperature of the Spartan-7 was 43C (measured with the GridEye sensor at a distance of about 4 cm from the chip).

     

    Conclusions

    Let me start by saying I think this board is great, and for the price, it is packed with features. The Spartan-7 xc7s50, although the entry level of the Xilinx 7-Series, is a very respectable FPGA, with great specs. And you get Pmods interfaces, Arduino compatible headers, 256MB RAM and 16MB Flash on board, leds, buttons and switches to play with, as those are all great building blocks for any maker.

     

    Although the roadtest object was the board, I feel the center stage has been taken by the tools used to program it. I suspect this was unavoidable, as only using the Xilinx tools you can actually use the board.

     

    Is this board good for markers and hobbyists?

     

    Let's see: to get proficient with this board, and the Xilinx toolset needed to program it, it does require time. How much time depends on the level of knowledge you have on this subject to start with and how much drive/passion/commitment/effort you are willing to put into learning. For a novice the biggest problem is often you "can't see the wood for the trees".

     

    If your objective is to learn about digital design and HDL programming for the FPGA, before jumping in and buy this board, I would advise to look around. Don't get me wrong, this board is fantastic, but for learning, I think there are better suited boards out there, and a lot cheaper than the Arty S7.

     

    But if you are eager to start using FPGAs for your projects, not necessarily focussing straight away on learning the intricacy of digital design and HDL, but with the determination of learning it at your pace, and the commitment to a long-term plan, then this could be the board for you. This doesn't mean you will be able to use it right away: you still need to invest some time in learning Vivado and the SDK before you will be able to do anything that is not the demo projects on the Digilent's website.

     

    Sure, it takes time, but won't be long before you will have learnt enough to take advantage of the MicroBlaze soft processor and all the IP cores available and be able to design your "microcontroller" based system, which would take you on a more familiar ground. Also, the great expandibility of this board (Pmods and Arduino/chipKIT shields) will give a maker plenty of choices to experiment with. And, before you know it, also thanks to the many other features of this board, you will have your first FPGA based project working.

     

    Building on that success, you can start digging more into the low level details of FPGA: you could start replacing some parts of your design, writing your own components from scratch in HDL. Again, it is not something you will be able to do in just few weeks, but if you keep at it, there is definitely a path you can follow to learn digital design with FPGAs.

     

    So, to answer the question, I think, ultimately, it really depends on what kind of maker you are. Personally I think the answer is yes, and the proof is in the fact I have thoroughly enjoyed the time spent roadtesting the board.


Comments

Also Enrolling

Enrollment Closes: Jul 1 
Enroll
Enrollment Closes: Jul 12 
Enroll
Enrollment Closes: Jun 25 
Enroll
Enrollment Closes: Jul 1 
Enroll
Enrollment Closes: Jul 16 
Enroll
Enrollment Closes: Jun 17 
Enroll
Enrollment Closes: Jun 17 
Enroll
Enrollment Closes: Jun 17 
Enroll