Skip navigation
> RoadTest Reviews

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


Product Performed to Expectations: 10
Specifications were sufficient to design with: 9
Demo Software was of good quality: 8
Product was easy to use: 6
Support materials were available: 8
The price to performance ratio was good: 8
TotalScore: 49 / 60
  • RoadTest: Digilent ARTY S7 Dev Board (Xilinx Spartan 7)
  • Buy Now
  • Evaluation Type: Development Boards & Tools
  • Was everything in the box required?: Yes - Additionally the user will need a USB to micro-USB cable and optionally a 7-15v DC PSU
  • Comparable Products/Other parts you considered: Boards for learning FPGA concepts and HDL include: Basys 3 Artix-7 FPGA Board, Adafruit Mojo, Terasic Inc P0192, Microsemi SoC A2F-EVAL-KIT-2 and Lattice iCE Stick. More detail in section 8.2 below.
  • What were the biggest problems encountered?: I RoadTested the Digilent Arty S7 FPGA board from a novice's point of view. Finding a beginner's tutorial that was correct in terms of screen shots and applicable software was difficult initially although I believe the Digilent website may have addressed some of those issues already. This would be far less of an issue for someone working fulltime with FPGA software and for whom the board operation would be easier to understand. As I worked through my test plan I encountered many other issues that, although would be minor to a knowledgable FPGA designer, left me lost. That said the board is fantastically capable - just expect to put in some ground work rather than working from a beginners guide.

  • Detailed Review:

    Roadtest of Digilent Arty S7 FPGA Development Board

    My Background

    I'm a chartered engineer working in the UK. My background is Electronic Engineering and Software Design. Several decades ago I learnt the basics of Programmable Array Logic (PAL) and from that I went on to self-teach myself to use the early Lattice-Semiconductor range of isp CPLD devices using schematic design capture software. The software that I used back then allowed you to drag and drop the standard IEEE logic symbols as building blocks and connecting them with virtual wires; which was similar to how I designed and built circuits using discrete logic chips at the time. That software also allowed for circuit description using Hardware Description Languages (HDL) such as Verilog or VHDL, but I never really got into programming using those tools. I built some good systems for my employer, using the Lattice chips to undertake fast logic tasks whilst interfacing the Man Machine Interface (MMI) to control them via a Microchip PIC microcontroller. Since those days I did little more CPLD or FPGA work and, as the devices moved on, I never got the opportunity to refresh my knowledge - I was considering purchasing a development FPGA board and then this E14 roadtest came out.

    My Application/Test Plan

    I applied for this roadtest as a novice (stating I had some latent knowledge of earlier FPGA design that could help) and as such my testing of the board is aligned to show what a hobbyist/novice might gain from this board rather than a specialist hardware design company.


    My proposed test plan to E14 consisted of:


         Initial Impression / Unpacking
         Setup and Support
         Basic Demo Projects
         My own project
         Arduino Integration
         Microblaze IP Core


    1.     Initial Impression and Unpacking

    The board arrived to me in the UK via UPS; I had an email to state when it was arriving. UPS slipped delivery by just one day due to the bad weather but still delivered it while the snow was starting to affect most travel and my road had already turned to an icerink - so top marks to UPS there.  On opening I found the board was well packaged both by Digilent (in pink dense foam/thin cardboard box) and Farnell Element14 (larger sturdier cardboard box) and therefore arrived undamaged. I expected the board to be bigger,I'm not really sure why, but in reality it is slightly larger than a Raspberry Pi.


    2.    Setup and Support

    Just a few days prior to this product arriving I upgraded some parts of my home PC, namely the graphics card and RAM, as the PC was having serious issues running some of my larger development programs such as C# and Xamarin.


    2.1     System Specification

    After upgrading my PC specification is now:

    • AMD x86-64 @ 3.2GHz
    • 8GB RAM (DDR3 PC1333)
    • GT710 Graphics Card
    • Windows 10 Creator (+dual boot to Debian via GRUB bootloader)


    2.2     Software Installation

    There is no installation CD or booklet provided with the Arty S7 so I decide to start my journey using the website link written on the Arty packaging. This was for - using my default browser's URL field took me to a non-related insecure website which wasn't the best of starts! Typing the web address into Google took me to which was better. The Digilent website stated "..and comes out of the box ready to use with the free Xilinx WebPack licensing with the Vivado Design Suite.". The Digilent site's 'software' tab did have Vivado listed but that subsequent page didn't have a download. This is where things got a bit confusing for me and after searching around the internet decided to download some software from Xilinx. I initially installed some software. This ended up running in a Oracle Virtual Machine (VM) and didn't look like anything in the subsequent tutorials I tried to follow.  However I pushed on and did finally manage to get the correct version of Vivado 2017.4 HLx installed and, although the demos and tutorials in the Digilent website were for Vivado 2014, most of the steps made sense and I could often find the equivalent tab, menu or screen in my 2017 version.


    I think over the weeks I have been creating this RoadTest report the Arty S7 webpage has been updated continually by the Digilent team - which is to be expected with any new product release - as when writing this Roadtest up and checking a few links I already see issues have been resolved.


    At this point I also have to remember that I am roadtesting the Digilent Arty S7 board and not the Xilinx Vivado software suite - although the divide becomes clouded as the Arty S7 needs some IDE in order to get programmed.


    2.3     Licensing

    Product licensing for the Vivado suite was a bit fiddly but ultimately completes properly - the HLs WebPACK Edition is device limited but the software is free and I believe doesn't expire. The versions of Vivado for more serious FPGA design work can be obtained free for a 30 day evaluation.


    2.4     Adding Arty S7 to Vivado Board List

    The Arty S7 board file needs to be loaded into Vivado so that the pin configurations are understood - that wasn't too difficult following the guide I found here


    2.5     Initial Power On

    Somewhere during the software install process I got the urge to just connect power to the Arty S7 board and see the power LED illuminate. However I did first read the online manual regarding power supply to ensure I got polarity, voltage and current within specification. The Arty S7 can be powered by either an external 7-15v DC supply through the 2.1mm jack or via the micro-USB port; I opted for running from my PC via a USB lead for simplicity. Upon power up I was impressed to see the board was already pre-programmed with a small design that strobed some LEDs whilst changing the colours on the two RGB LEDs - I must say it is one of the most impressive start ups on a 'non-display based' board I have ever seen.


    I did video my board powering-up but a fellow Roadtester,dixonselvan , has already posted effectively the same thing you can see the same great effect on his video (and save placing redundant data on the E14 website).


    2.6     Board Overview

    The main Digilent webpage for this product is a great starting point and something I had already looked through prior to my roadtest application. The main board layout is:


    1.     LED to indicate when FPGA programming is in progress/complete

    2.     A USB port for connection to PC via standard USB-Micro USB lead. Also used for JTAG programming.

    3.     Power select between the USB and the external 2.1mm connector (see item 4 below)

    4.     2.1mm Power connector (7-15v DC)

    5.     Power on LED

    6.     Four standard SMT LEDs

    7.     Two RGB LEDs

    8.     Four slide switches

    9.     Four push buttons

    10.     Arduino/ChipKit shield connector

    11.     SPI header

    12.     Arduino IDE reset

    13.     FPGA prog mode (JTAG or Flash)

    14.     Processor Reset

    15.     Pmod Headers - for Digilent add-on modules

    16.     FPGA programmer reset

    17.     SPI Flash

    18.     Spartan-7

    19.     DDR3 RAM

    20.     PSU IC


    3.     Basic Demostration Projects


    3.1     Demo 1: Blinky

    Aim: to run through a demonstration project on the Digilent website called blinky to become familiar with the design flow of both the board and the Vivado software.


    Outcome: I was able to make my way through the blinky demo fairly easily even though the screen shots were not quite exact to what I was seeing in my version of Vivado - I now realise it was meant for Vivado HLx 2016 rather than 2017.4 There was modification to the CONSTRAINTS file required and I did get stuck a few times as the guide wasn't quite accurate but with a bit of thought I managed to address those issues. [Now I'm writing this Roadtest a few weeks later I see my notes don't quite match the Digilent website - I think that Digilent are constantly improving their online literature from feedback on the new product....which equates to great product support.]


    My first real issue was when I plugged in the Arty S7 board to my PC via USB - it powered up but I could not connect to it. This was my first use of the online Digilent Forum which offered really good support through a range of dedicated developers and Digilent staff. I tried out a few of the suggested points for help before realising that the issue was because I had extended my USB lead to be able to keep the Arty board a safe distance from the edge of the desk. Reducing my USB lead to the shorter lead provided with the board resolved those issues and I was able to upload the bitstream to the FPGA and get my LED blinking away - that was my first complete Verilog project. The next day, upon power up, the board had reverted back to the multi-colour demonstration - not a huge issue but I just needed to work out how to setup the bootloaded RAM rather than program the FPGA directly (which was obviously volatile).


    I also realised that I needed to learn some basic Verilog or VHDL to be able to Roadtest this product as Vivado doesn't support schematic capture. I was mildly pleased with that outcome as I now had a real reason to learn a HDL rather than keep opting out in the past and using schematic design. I chose to push on with Verilog as it seemed close to C, and I am quite used to working with C on microcontrollers.


    Naturally I modified the Verilog code to make a version two of Blinky; and LED blink at a faster rate - just to prove it was my code that was setting the FPGA structure to achieve this.


    3.2     Demo 2: GPIO

    Aim: get another design example completed to gain knowledge of the board and the whole design process. From the description it at first appeared this was the pre-loaded demo that the board arrived with.


    Outcome: The first time I ran into some issues and onscreen errors that were linked to pin configurations as the CONSTRAINTS file provided was for the Rev. A of the Arty S7 and I am using Rev. B. I tried to combine the two CONSTRAINT files but started to increase the number of errors and warnings. I used a diff tool to compare the two files but at this early stage of learning was unsure what to change and every change I did make resulted in even more errors. I eventually decided to move on and record that as 'a learning experience'.


    Later in the Roadtest period I managed to find a Github repository for the GPIO Demo that did have a constraints file for my Rev.b Arty S7 board. I built this project, ran synthesis and implementation to create the bitstream. Uploading that resulted in the two RGB LEDs glowing various shades and hues (so this isn't the initial startup demo). Also opening PuTTY gave a message for each button press as described in the tutorial

    I can also use both of these tutorials to better understand how the CONSTRAINTS file is structured.


    3.3     Demo 3: XADC

    Aim: to consolidate my understanding of using Vivado to program the board, using the second demo on Digilent's website, such that I can move on to my own project design and show off the board's capabilities.


    Outcome: Unfortunately my first attempt to follow the tutorial also failed - I believe the tutorial was for an older version of Vivado so the IP designed blocks were out of date. I was able to upgrade the project IP to 'Core Container' which allows IP to be taken across a range of software versions but I still had to modify the CONSTRAINTS file to match my Arty-S7 board which had a different number of LEDs than the example board. I had two more attempts at running through the complete XADC tutorial before deciding to again move onwards. A slight bit of Deja Vu at this point.


    Later on I revisited this demo. I'm not sure if I had picked up on an outdated link but the link above, on the Digilent website, is now for my Arty-S7 board. This fourth attempt did work and I was able to utilise the Spartan's ADC to measure a voltage and illuminate LEDs depending upon those breaks. I used a potentiometer on my breadboard to divide the 3.3v from the Arty board to ground and fed that back into the XADC pin. I had just received an Arduino LCD shield (for the later chapters of Roadtesting) and so added that to my Arduino Mega to make a simple DVM for the following screen shot; the two green LED in the bottom left corner are part of the 'LED bargraph' display, with the two lsbs being illuminated for 1.23v input. NB: I wasn't convinced this was entirely linear but it proved the XADC operation.


    3.4     Demo 4: My Simple AND gate combinational logic

    Aim: having successfully completed several demonstration projects I wanted to try something myself. Changing the constraints folder and writing my own Verilog file for the FPGA design. I used the Blinky example as a basis.


    Outcome: the code below enabled me to use two of the slide switches to illuminate an LED...probably not the best use of the Spartan-7 ...but it worked!


    module Blink_LD5(
      output LED,
      input CLK,
      input IN_A,
      input IN_B
      assign LED = IN_A & IN_B;


    3.5     Demo 5: A debounce Circuit

    AIm: debounce one of the push switches and use that to illuminate an LED. I used the code from here and started to realise how modules can be quickly built from smaller component parts using HDL.


    Outcome: the LED illuminated as expected - again not too useful on its own but it gave me confidence at Verilog and using Vivado as well as how code can be repurposed from the internet. When doing that I like to include a comment to the original source or author. This benign test actually proved useful as I reused the code for the latter Servo demo - which I guess is the real beauty of HDL modules and how they can be instantiated many times throughout the overall design.


    3.6      Summary So Far

    Although the designs I've tried have been functionally trivial I have now a good confidence in using the Vivado Design Suite, where to find help if I get stuck, what typical errors mean and a basic understanding of Verilog. At this point I can already see that the Digilent Arty S7 board would make a great learning platform for anyone wishing to learn about FPGA; it has reasonable cost v. performance, a great IDE and plenty of connectivity to expand out to sensors and interface components. I can also see that the board requires some perseverance at times to succeed which might not appeal to all prospective purchasers. There are a large number of relatively minor issues that can easily prevent the beginner from completing a tutorial first time through - but help isn't too hard to find.


    4.     My Own Projects


    4.1     A servo controller

    Whilst I was RoadTesting the Arty-S7 shabaz wrote a fantastic article about Servo control. In the past I have made a multi-channel servo controller using a PIC so I thought I'd try and make a controller using the FPGA. I searched the web and found an example which I then merged with my debounce switch example from above to produce a system that could control a servo from four push buttons - the four command buttons are fast Counter Clockwise (CCW), slow CCW, slow Clockwise (CW) and fast CW. I've pushed the Verilog code to my Github page here and included reference to the original source should anyone want to try it out. I was quite happy with this simple project as it reused the switch debounce whilst also generating a PWM signal. In the video below you will see the servo in the bottom of the video, I use the four push buttons in the top right and the LEDs blink to give visual confirmation that the buttons are pressed.


    I used an old CD4011 quad NAND gate to convert the PWM signal from the Arty S7 (as seen in the scope photo below) from 3.3v to the 5v peak required by the servo and to also act as a buffer should I get a connection wrong (I'd rather replace the CMOS chip as I have a tin full of them rather than damage the Spartan's outputs).


    4.2     WS2812 Controller

    My RoadTest application stated that I wanted to build a WS2812 controller - something that could be loaded in slow time from a microcontroller or Arduino via SPI with a sequence of RGB bytes. Then the FPGA would push that data out quickly to the WS2812 chain with the correct timing. I made quite a good amount of progress but it was soon apparent my lack of HDL knowledge was seriously impacting on my ability to build this successfully. I didn't want to delay Roadtesting of the Arty board just to complete this project so parked my 'ambitious' project for now - however I do still want to build that unit and will attempt it in the future as a separate blog post when I've improved my HDL skills or perhaps when it fits well to one of the monthly E14 themes.


    5.     Arduino Integration

    When I first read the specification for the Arty S7 I thought it could accept the Arduino mainboard and this chapter I planned to explore that further - I assumed the Arduino could interact directly with the FPGA for controlling fast digital signals whilst running its own bespoke C code. When I got to this section I dug out the spare Arduino from my 3D printer - a Mega2560 - and it soon became obvious that that didn't plug into the Arty S7. I then wondered if I should have kept the Arduino Starter Kit I won last year (as it came with an Arduino Uno). I did a web search and soon found that the headers on the Digilent board were for accepting Arduino standard shields - that made much more sense; and on checking the Digilent webpage, that is what is actually stated.


    Therefore, the Arty S7 can accept a whole range of Arduino shields to expand on the project being made. The beauty of including this header footprint is that customers can reuse any Arduino shields they have whilst in a rapid prototyping phase. There is also a shield that can expand from the Arty S7 to include the mikroBUS footprint - and allow customers to use any existing mikroBUS boards they have.















    I cannot see any IP that creates an Arduino microcontroller within the Spartan FPGA and so I would conclude that the Arduino libraries could not be utilised directly. Instead you would have to develop your own IP core and HDL code to drive that addon board. However, the Vivado HSE did include a C/C++ compiler. I believe that could be used to modify functions from the Arduino libraries to make your own custom IP cores to drive your own boards. That might also be fairly easy to do.


    When the Arty-S7 initially arrived I didn't own any Arduino or mikroBUS shields - so I bought one to further my Roadtest whilst also selecting a unit that I thought might add utility to several of my future projects (both on the Arty-S7 and when using the Arduino). I chose the LCD keypad shield by Velleman and sold via CPC Farnell.


    I did plan on making a simple example to write to the screen but became cautious to actually try and utilise the LCD shield on my Arty-S7 having seen a warning "The Arty S7 is not compatible with shields that output 5V digital or analog signals. Driving pins on the Arty S7 shield connector above 5V may cause damage to the FPGA.". Naturally I didn't want to damage the Arty board prior to completing the RoadTest and my current knowledge of pin voltage standards on FPGA is still lacking lacking - I've shyed away for now but will try and do a separate update on E14 community in the future. As you will see later, the Arduino shield was not unemployed for long. Below is a photo where I have mounted my Arduino LCD shield on the Arty S7 (but I haven't powered it up).


    6.     IP and Microblaze IP Core


    6.1     IP

    I looked through the available IP catalogue that is built into Vivado. There are some pretty cool modules available that can be incorporated into the user's design. For example, if you want the hardware that you are building to have some sort of SPI control then you just drag that IP block into a design, add the parts around it and compile it up....then reference it from your main HDL code. You could make the whole SPI interface yourself using HDL or code snippets from the web but there is no need - these IP blocks are tried and tested. They allow fast prototyping of any design. I've taken a screen shot that shows a small amount of the available IP blocks - many of which are included in Vivado for free and some require additional purchasing (or searching the internet for an open source equivalent). Most basic building blocks such as adders, counters, multipliers and multiplexers are free as is the SPI and UART interfaces.


    6.2     Microblaze Core

    The Spartan-7 and Vivado come with IP from which you can build your own customisable microcontroller - how fantastic is that ! You can choose all the internal parts you want - if you need 16x SPI controllers and nothing else...then just drag them in [assuming there is enough resource in your FPGA]. You can configure the entire inside of your own microcontroller and most of that is achieved by one autocomplete command.


    I found what I thought was a good tutorial to guide me through making my first SoftCore processor on an FPGA here and from that was able to build the design into the FPGA as below:

    The tutorial flowed well and I was able to complete the Microblaze SoC design but I then ran into many issues getting the SoC's C code to compile - and a more detailed and correct tutorial would have been really fantastic....


    The next day I ran through another online tutorial here. As before I was able to make the Soft SoC Microblaze core and then moved across to the Xilinx Software Development Kit (XSDK) to write some code. The simple C example I initially picked was the AXI GPIO driver, the code for which is shown further down - compilation of that C source code went well and it almost worked as expected. The C code would read the four push buttons and would light all the LEDs if any button is pressed - that part worked well. It was also meant to output the switch value to the UART which appeared garbled when viewed using PuTTY even though the correct serial settings were being used. Below is a schematic of the IP blocks used in the Microblaze core when I got it working - which I think looks awesome - along with the PuTTY screen.




    This is the simple C code example running on the Microblaze Core as provided in that tutorial:

    //AXI GPIO driver
    #include "xgpio.h"
    //send data over UART
    #include "xil_printf.h"
    //information about AXI peripherals
    #include "xparameters.h"
    int main()
     XGpio gpio;
     u32 btn, led;
     XGpio_Initialize(&gpio, 0);
     XGpio_SetDataDirection(&gpio, 2, 0x00000000); // set LED GPIO channel tristates to All Output
     XGpio_SetDataDirection(&gpio, 1, 0xFFFFFFFF); // set BTN GPIO channel tristates to All Input
     while (1)
     btn = XGpio_DiscreteRead(&gpio, 1);
     if (btn != 0) // turn all LEDs on when any button is pressed
     led = 0xFFFFFFFF;
     led = 0x00000000;
     XGpio_DiscreteWrite(&gpio, 2, led);
     xil_printf("\rbutton state: %08x", btn);


    All of those steps and time may seem a bit long winded and I could have easily achieved the same functionality using a Microchip PIC and my PICKIT3 (as I am familiar with their operation) in a much smaller space of time. However with this approach there is no reason why, with resources allowing, we cannot have multiple Microblaze cores, or  other peripherals that are not normally included in a standard ASIC microcontroller. For instance I could have combined the Microblaze with multiple instances of my WS2812 controller idea and buffer RAM - the Microblaze core would control data flow to that IP block but would not need to be tied up processing the output timings. If I wanted to control that via CAN bus (for some odd reason) then I could have added a CAN IP block to my design (although that IP isn't free).


    7.     Other Functionality of the Arty S7


    7.1     PMod

    PMods are similar to the Arduino shields and there is a huge range available, most prices are reasonable and equally priced to comparable Arduino shields. I didn't get around to purchasing one for the Roadtest, although I will in the future to further my HDL learning using the board. The PMod VGA adapter looks like a great first contender: I note that the other current FPGA Roadtest board from Digilent has VGA functionality built in. There are seven current PMod standard interfaces including SPI, I2C, UART and GPIO. These are detailed in a Digilent document and so will enable users to build their own addon boards for the Arty S7 - although the range below looks quite extensive already. Many of the boards use a single 6-pin header to connect to the Arty board but some utilise a dual row header (12 pins).


    I would recommend that anyone purchasing a Digilent Arty board for learning and tinkering/making should invest in a few PMod so they can try out some ideas and make better progress.


    I've included a screen shot from the Digilent store that lists some of the PMod range (one of three pages). It also seems that the PMod standard is utilised by other manufacturers like Analog Devices - this is a great way of adding even greater flexibility and power to this Spartan-7 board.





    8.      Last Points

    8.1      Learning HDL

    In the course of this Roadtest I found that there were many online tutorials for Verilog and VHDL. I particularly liked ASIC-World and FPGA4Student , which incidentally has a great intro for anyone undertaking the Basys3 FPGA Roadtest or who had bought the board directly.


    I have also spotted what could be a great book. I have a Raspberry Pi book by Simon Monk and find it really inspiring. The book I have seen is "Programming FPGAs - Getting Started with Verilog" by Simon Monk.


    8.2     Other 'Similar' Boards

    The following boards look like they could also provide a good learning platform for those starting out in FPGA, although to the more knowledgeable I am sure some boards are far superior/inferior to the Arty S7. This area of technology is making rapid progress and as such many of the boards I am finding that appear to be comparable are listed on Farnell as 'no longer manufactured'. There are many other boards and manufacturers -  a quick look at the 'Embedded Development Kits - FPGA/CPLD" on Farnell gives a rough idea of choice but I have added a few additional from a simple web search. As these boards seem to have a short lifespan on market my advice for a novice would be to choose something that has good vendor support, a wide userbase adoption, good forum support and ability to utilise existing boards or has its own wide bespoke range of boards. The Digilent Arty S7 seems to tick all of those points. Those with more FPGA knowledge can easily branch out to the more niche boards if they provide something the others cannot.


    8.2.1     Basys 3 Artix-7 FPGA Board

                 This board is currently under a separate E14 Roadtest and it will be interesting to read that report and see what it is capable of. It uses the Artix-7 FPGA by Xilinx. The board also makes use of the PMod connectors, has a large number of slide switches, a cross-pad of push switches, and LED 7-segment display (4x digit), user LEDs and a VGA port. Price is similar to the Arty-S7 and so could be a better choice for novices as they would be able to try out more ideas without any additional expense.












    8.2.2    Altera Cyclone II DK-CYC11-2C20N Development Kit

                 This slightly more expensive board comes with a wide range of connectors which make it more suited to audio and video processing(CODEC).

    DK-CYCII-2C20N - Development Kit, Altera Cyclone II 2C20 FPGA, C++ Software Controller, USB Command Controller

    8.2.3     Lattice Semiconductors iCE40HX1K-STICK

                 This is a real entry level board that is low cost and comes with limited I/O but does still have one adaptable PMod port. This board looks like real fun and even though I have the Arty S7 this is on my wishlist of things to buy.

    ICE40HX1K-STICK-EVN - Evaluation Kit, Easy to Use, Small Size Board, Rapid Prototyping of Functions Using iCE40 FPGA


    8.2.4     Adafruit Mojo

                A small form factor Spartan 6 based board. It looks like it can accept RPi shields but I cannot find much information regarding that aspect.

    Adafruit Mojo FPGA Development Board - Development Boards - The Pi Hut - 1

    8.2.5     Terasic Inc P0192

                 The P0192 is an Altera Cyclone V based board with VGA, 6-digit 7-segment display, 10x slide switches, 4x push buttons and 10x LEDs - it looks visually similar to the Basys board.

    8.2.6     Microsemi SoC A2F-EVAL-KIT-2

                 The SmartFusion evaluation kit is of a similar price to the Arty S7 but also includes a dedicated onboard ARM processor as well as the MicroSemi SmartFusion FPGA IC. the board looks jam packed with goodies including an onboard potentiometer and wired Ethernet port.

    9.     Summary


    I've tried to base my roadtest on the actual Digilent Arty S7 board rather than the Xilinx Vivado software suite and HDL - although the two are very closely coupled.


    Some of my good intentions in my application and test plan haven't been as successful as I initially planned - in part due to the slight inconsistencies in tutorials and guides and mainly my lack of Verilog knowledge. In my opinion the board is not suitable for a complete novice unless they have the commitment to keep trying and asking on forums; that will hopefully improve as the board gains popularity and there are more articles available describing its use. However for novices with dedication and drive I think this board will offer a learning challenge they can rise to and will not leave them bored towards the end. The board's features enable a great range of products to be built and my miniscule designs only scratched the surface of what this board can achieve. Professional FPGA designers who will already know many of the techniques using Verilog or VHDL coding required for complex designs will be able to use this board for testing out building blocks prior to incorporating that IP into their own bespoke Spartan-7 powered boards.


    I believe the content of the Digilent site was updated continually whilst I was undertaking the RoadTest - likely because of ongoing feedback from users; I take that continual improvement by Digilent as a sign of commitment to providing a good support base. I used their forum for help and can vouch that the friendly and accurate support given was very welcome. Hopefully the slight discrepancies I noticed between articles, boards, software versions and board revisions can be smoothed out in time.


    Any FPGA board will allow students and hobbyists to experiment and learn HDL of choice. However the Digilent Arty-S7 would seem like a reasonable price for a high specification board. The ability to expand functionally in a modular way using pre-made PMod boards or Arduino shields is a great addition and should enable users to be able to realise almost anything the wish to make. The board is quite limited if no additional boards are purchased.


    This little board is a great asset for learning HDL. It is portable and could easily be used for testing out designs whilst away from the office/home work bench. Unfortunately I need to use my tower PC as I doubt that my old 32-bit Intel Atom Netbook would run the Vivado design suite.


    My journey with FPGA has only just started and I will continue to learn Verilog (or VHDL), explore testbenches and simulation and build up some more complex projects over the coming months. I look forward to adding a blog on E14 with any projects I make using this board.


    This ends my first Roadtest for E14. I'd like to thank the E14 team and Digilent for selecting my RoadTest application and I do hope that everyone finds my review useful and constructive. If you want to learn about FPGA a Digilent board will help you along the way. I look forward to reading any community comments below and answering any questions you have on my Roadtest report for this product.




Also Enrolling

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