Cheap FPGA Development Boards: What to look for | Hacker News Reader

Cheap FPGA Development Boards: What to look for

joelw.id.au

127 pointsjestinjoy153 comments

I got interested in FPGAs a few years ago out of a desire to design a toy processor for a Coursera class. I had a similar issue figuring out what board(s) to get, mostly because I didn't know what the number of gates could actually implement. I too ended up with an Atlys board, which is an impressive little beast.

When it came to learning an HDL, I got in contact with several people who worked on FPGAs and learned that most of the experience people seemed to be gaining is how to navigate the development environments. Each FPGA manufacturer has their own environment that only works for their own chips and only supports their own (or partner's) JTAG controllers. Each development environment is completely different and often a design-by-committee mess to navigate, let alone use.

So I continued like most in the direction of my first purchase and messed with Xilinx ISE. I could write pages about this tool (Doesn't support spaces in installation path, 15 gigabyte install, matlab-level licensing even for the free version, on linux first command to run before you use ISE is source settings64.sh, etc.).

Above all that, my primary issue is that while the synthesizing/place-and-route (FPGA form of compiling) work on linux, in the newer versions of ISE that no longer require broken kernel drivers, they incorrectly load libusb, so you have to LD_PRELOAD the library, and even then it only seems to correctly load a third of the time.

(shameless plug time)

I don't think anyone else should have to deal with this crap. I called BS, and started a project I (for now) call "Adapt" to make a tool that runs on all POSIX systems to be able to support all FPGA chips and all JTAG controllers with an easily-extensible code base.

Do note that this project does not synthesize or route for chips, only load the bit files onto the chips. Other work is being done on that.

I am currently working on re-implementing some JTAG controller firmware so the tool can be distributed without proprietary software, and after that I will get back to the core of the project, add testing, and finish the ability to support multiple chips.

http://diamondman.github.io/Adapt/

This project is very much in progress so this is just a heads up for now. However if anyone would like to contribute support for their favorite controller or chip, it would be greatly appreciated.

What Coursera class did you take that implement toy processor?

https://www.coursera.org/course/comparch

Thanks

> Do note that this project does not synthesize or route for chips, only load the bit files onto the chips. Other work is being done on that.

The only project I'm aware of that has made progress on reverse engineering the Xilinx bitstream is fpgatools:

https://github.com/Wolfgang-Spraul/fpgatools

It only works with a Spartan-6 LX9, and then only has partial support (e.g. no block RAM). I'd be interested in hearing about other projects like this if you're aware of them.

A few friends are working on making a generic tool that will support lots of different architectures, but since Xilinx has a clause in their agreement for downloading ISE that you will not reverse engineer the software, and that you will not use the output of the software (the bit files for example) to reverse engineer anything. This means that you can't compile a bunch of slightly different things in ISE and check what the bit files look like. The only alternative my friends can think about are rather extreme ways of getting around this.

Usually most people just cave and use Windows, on which ISE works a bit better.

Yeah, that's what I did eventually.

I fear that this article misses out on one of the most important aspects of cheap FPGA boards, which is the software stack. Do not be fooled. There is no freeware, open-source, GNU, LLVM etc software in the FPGA world. You will need to use the manufacturers very own, proprietary, place & route (and often synthesis too) software.

For this reason, go with Xilinx or Altera who both offer free versions of their development kits. Also, make sure that the particular part you have is supported by the free kit. Often only the smallest and simplest parts are supported.

Form a quick scan of the website, it seems that Lattice-Semi still does not offer free licenses of development tools. Years ago I bought a cheap ($99) Lattice-Semi PCIe/1G FPGA board, this board is still useless as I can't get the software without a $1000 license for the software kits. Although the board was cheap, it's nothing without the software.

Lattice does offer free licenses for the low end. They're certainly not going to give you a free license for PCIe; I'm pretty sure Xilinx and Altera don't either, that's still a premium feature.

I haven't used either in the last year or two, so a lot may have changed, although, in the past, many of the low end parts had a built-in (slow) PCIe Gen 1 block, so only wrappers were needed to use it, no licenses. IIRC, this was (one of) the problems with the Lattice board, because with no built in endpoint, you needed to license an expensive "softcore" PCIe block (or write your own...) The same is true of 1/10/40G MAC blocks.

Good points. Though I'd say that at least Altera provides good support for most of their devices in the Web Edition.

Also Altera and Xilinx (I think) provides a free version of Mentor Graphics simulation tool ModelSim that supports up to moderate size designs.

I wish I knew what this person was using them for :-)

Has anyone made a similar comparative study of my biggest gripe with FPGAs: the quality of the (more or less mandatory) development software? In my experience, it's pretty horrendously terrible :(

(Sorry for the down vote, meant to up vote; HN UI is prone to misclicks especially from mobile users)

I neutralized yours, no worries.

Yeah, tools from hardware vendors are notoriously awful. Embedded debuggers (JTAG) are almost always terrible, too.

I agree, the whole toolchain is extremely bloated and still growing. My academic teacher simply refused to upgrade Xilinx ISE in the lab and the only thing that could force him to upgrade was eval board that wasn't supported by the old version.

Embedded debuggers (JTAG) are almost always terrible

Weeeell debugging is difficult by nature. No such thing as code stepping, all you can really do is examine waveforms.

A few years back I was working on a PhD project that involved software defined radio for tracking wildlife in real time, which was an ideal FPGA project. With a limited budget I was keen to find the cheapest boards out there, and decided to start maintaining the list.

Sadly I don't have much time to use them from day to day any more, but still help people out when they email.

The comparison of development environments is a great idea which I'll definitely work on! They have a baffling range of paid editions with different featured and it's difficult to know what they all mean and why you'd want them. Thanks for the idea :)

Not exactly a dev board, and $500 price bracket, but possibly more practical for many: http://redpitaya.com/

If you want to interface with the real world it is great to get something where the analog part is done well. All the low level stuff already works.

That board is so cool. Want!

My problem with FPGA is two fold - I have no idea what to use them for and I have no idea how to use them.

Yet with all these mentions here I fear that I may become unemployable as a software developer if I don't keep up.

I worked w/ FPGAs exclusively for 5 years and still don't have many ideas for using them. (In other words, small ARM computers running Linux are more exciting. And low-power boards like the JeeNode etc)

Actually an interesting arch for me would be small FPGAs together w/ an ARM system, where the FPGA would handle the fast interrupts, buffering things, and communicate w/ the processor when its ready.

Theres Zynq which combines an ARM core with an FPGA.

The Parallella board contains one I believe (http://www.parallella.org/)

Theres also the SocKit from arrow: http://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=E...

Very similar to Zynq but from altera rather than xilinx

Depending what you're doing, you might still have a better time pairing a high level ARM processor running Linux to a low-level ARM MCU running bare metal or FreeRTOS.

What kinds of things can you really do better/faster/cheaper on an FPGA vs, say, STM32 F4 series?

"STM32 F4 series"

You know how you start a microcontroller project with a "dream shopping list" of timers, I/O devices, memory, whatever features, then all the mfgrs have a giant table you scroll thru and then you trade off, "well, I need at least 3 SPI and 128K of ram, but they don't sell 128K ram with 3 SPI I need to buy a 192K to get my 3 hardware SPI, of course I could do two in hardware and bit-bang in software the 3rd...". Or even worse "I need at least three hardware PWM timers although they only need to be 24 bit, but the entire F4 series has exactly two 32 bit timers, oh knoes what am I going to do?" Even worse as the project changes over time.

With a FPGA you skip all that garbage and just synthesize in what you need. Oh I need 3 PWM timers, well, include three of them, no big deal. Wanna HDMI, if you can wire it in, you're good.

Ideally you'd put the "boring" parts of your software in the FPGA I/O device. If you're building a thermostat, why write the state machine in assembly or C, just use some mag comps and timers. Put the UI in the softcore processor.

If you're doin' it right, your UI soft processor need run no faster than a human, say 100 KHz clock speed. How fast can a human being hit a hardware debounced up arrow and read the LCD? If you're doing it wrong, you've got a softcore processor running multiply-add in software at 80 MHz and wishing for higher CPU performance.

There was an era of a couple decades which ends with FPGAs where its cheaper to throw in software than hardware, even throw in multiple microcontrollers. Why put in hardware schmidt trigger gates and resistors/caps to hardware debounce a switch if you can write 10 lines of code to do it in software? The hardware of the future will be a FPGA with exactly what you need and a very smart/advanced peripheral library. Why write 10 lines of buggy code to soft debounce a switch when you can just include some FPGA library code to get a perfect debounce with no race conditions or interrupt collision problems in the software, its just perfect.

Processing streams. You have inputs, process what comes in, you have outputs. For example video encoding/decoding is a good utilization of FPGA.

If you're designing for FPGAs, you're not a software developer.

I can think of a few uses for FPGA:

* Pedagogical. When I was an undergrad, I took a computer architecture course. We wired up a simple computer with breadboards and discrete logic. The computer was microcoded to execute a variant of a modern ISA. The computer was useless and slow, but you learned a lot about computer architecture. I think this exercises is properly done with FPGAs these days.

* High-speed VLSI design simulation. You can simulate large designs at partial speed in circuit with FPGAs before you fab. I have no personal experience with this, but I'm guessing big chip design companies like Intel buy a lot of FPGAs for this purpose.

* Interfacing to high-speed data interfaces. Say you're building a hardware board with SATA, HDMI, or a high-speed ADC, but the microprocessor on your board doesn't support that interface natively. You can use an FPGA to connect that interface to the rest of the system.

For example, bunnie's Novena laptop has an FPGA with a high-speed IO connector. He has connected this to a high-speed DAC to create a homemade oscilloscope.

* High-speed DSP. Modern FPGAs have distributed DSP blocks. For example, the Xilinx Artix-7 100T can do nearly 1TMAC/s. So if you want to do video or audio processing, an FPGA might be a good solution.

I briefly looked into building a board to combine two video streams into one with barrel distortion for the Oculus Rift. An FPGA is perfect for an application like this.

They are used a lot in audio processing - digital mixers, effect boxes etc. In a digital mixer, you'll need to get 32+ channels of audio encoded into the correct format, mixed, effects added, re-encoded, and back out in under 10ms, hopefully a lot less. The encoders/decoders and the main mix will usually be in a FPGA. The effects will have their own DSPs.

In my experience FPGAs are broadly used as "glue" chips to interface between microcontrollers, DSPs, codecs, and other hardware elements (encoders, LEDs, etc). Technically these are called CPLDs but depending on how much work they do, they may use a larger family with more logic cells and memory.

Basically if you need to interface with any digital hardware that isn't natively supported by your microcontroller/CPU/DSP, you'll probably want an FPGA to do it unless you have enough resources to write a bit-banged interface in the micro.

While researching contemporary intersections of encryption and databases (for a presentation), I learned about Microsoft's Cipherbase.[1] They made a dbms which uses an FPGA as trusted hardware that will decrypt db fields & perform the appropriate query. In my wild fantasy, I hope to recreate the ASIC for bragging rights.

Talking about ASICs, I'm surprised no one mentioned how the public heard of FPGAs in the last few years: bitcoin mining.

[1] http://research.microsoft.com/en-us/projects/cipherbase/

Here's a nice use case example of using fpga to speed up an algorithm in a camera versus implementing in firmware.

http://wiki.elphel.com/index.php?title=FPGA_Development_in_E...

This wiki is a great resource for setting up a fpga tool chain on Xilinx.

What would folks recommend if my only goal is learning? I do some microcontroller development, so I'm aware of the need for an inexpensive board and (preferably) free tools. I'm OK with a free tool that has a limited program size, which I've never managed to fill up.

Naturally I say my only goal is learning, but... I wouldn't mind finding a development board that's small and cheap enough that it could be pushed into small run production as a component in a pinch.

If you are starting completely from scratch? Go cheap. Basys/Nexys or something like that. HDMI ports and ethernet ports and 1GB RAM will not be useful to you if you have never written HDL before.

Give up on free tools...

I've made this post about cheap FPGA kits: http://www.embarcados.com.br/kitsdsvfpga/

You can check it out, it's in portuguese but the figures/names/prices are in english/dollars.

FPGAs should be used more often then they are. If you are doing a lot of things (or can do) in parallel, that's what you want a FPGA for.

Its a good article in general with one very minor error. It explains you want on board LEDs and switches because its too easy to screw up soldering your own. The core reason why you want LEDs and switches on a FPGA board, why you'd buy included or solder your own, is too often during debugging this will be your UI.

So you are in a quandary about which of several PLL designs to implement. Its not 1990 anymore, you've probably got space on the chip to put them all in, and select which operates in real time using the switches. Then you wire up your spectrum analyzer or scope or whatever exotic test gear you require, fire it up, and instantly flip between implementations while its running. You figured it out in theory, now in practice which one actually has the fastest lock up, or the lowest noise performance, or the least noise spurs at critical freqs? Just flip the switches and find out.

And on the LED side, there's a lot of testing patterns that boil down to "and when the state machine hits this state, aside from entering state 8, it also fires the LED on a little timer" Again hook up all your real world hardware and see what happens.

True, you could implement a VGA display and PS/2 keyboard without much hardware work, but then you have to drive them probably with an embedded processor, a little picoblaze or whatever running the UI... and all that screwing around to basically re-implement LEDs and switches, just slower and harder to do.

There are in circuit analysis tools, some of them pretty cool, and some of them are actually reliable, but fundamentally you're always going to find some LEDs and switches, its just too easy and convenient.

There is also the "hello world" test proving your hardware and dev system aren't screwed up, everyone has their personal favorite, what I always use is a simple 3-input switch / 2 output LED full adder.

I've also been known to do things like output the version number of my project on the LEDs. Hey, they're just sitting there and everyone who's actually done labwork has had the amusing experience of thinking they're testing version 12 but finding out they uploaded version 11 or whatever.

Finally when the analog / hardware side isn't ready, if theres no timeouts and its a strict state machine, I've been known to flip switches as inputs, many millions of times slower than the real hardware works. Hand toggling switches to talk to an I2C slave or SPI is a little tedious, but sometimes the best option. Once you get past layer 2/3 type problems there's higher level protocol tools, some are even cheap like the "bus pirate" or you can send $375K to Agilent for slightly more advanced test equipment.

Excellent point about the LEDs and switches - and that's exactly what I use then for! You can never have too many LEDs when you want to track the progress of a ponderous and misbehaving state machine. I'll update the article with a clarification in the morning!

Seven-segment LED displays are nice as the next step up for debug from single LEDs.

I used the Altera DE1 in my college EE class a few years ago and am interested in getting back into writing VHDL to help learn more about reverse engineering on a hardware level.

Should I go ahead and get the DE1-SoC since I already have experience with Quartus II or should I go for one of the Spartans (which I know nothing about). If I go with Altera is a DE2 worth the investment (it's 2x the price)?

The DE1-SoC is definitely worth it for the ARM HPS. A hard processor which can run Linux attached to an FPGA is a very powerful combination. Check out http://zhehaomao.com/project/2014/01/02/fpga-series.html for examples of stuff you can do with it.

> Digilent Basys 2 is, if you're a student, only $49

The article appears a little outdated because I bought this board last year as a student for $69.

http://www.digilentinc.com/Products/Detail.cfm?Prod=BASYS2&N...

I strongly recommend Cypress PSoC3 and PSoC5 if your budget is tight and you want to achieve the blazing fast speed of FPGA within a tight budget. I implemented Wavelet Transform with de-noising scheme, a classifier model to match against that Wavelet Transform, and a RMS machine, all in hardware, all in that small PSoC3 chip. Magic.

The Cypress chips are amazing. And you can even buy a basic Cypress PSoC dev board for $5:

http://hackaday.com/2014/06/16/cypress-launches-5-arm-dev-bo...

Tragically -- as is the case with FPGAs -- the development environment only runs on Windows.

I really think these companies are missing out on a large market segment of software developers who are increasingly interested in hardware, but who work exclusively on Linux or OSX.

Worse actually, since at least for Xilinx and Altera the development environment is available for linux.

The cubicboard could be considered the raspberry pi of the FPGA world: 168 gpio, 512mbit ram, cyclone V with 25k logic elements (huge, a nios 2 cpu uses 600LE!), usb, sd leds and pushbutton onboard - $39. https://code.google.com/p/cubicboard/

Another option is http://www.zedboard.org The MicroZed has a Zynq 7010, 1 GB DDR3, gigabit Ethernet and USB 2 for $199.

Is there resources where people share their FPGA projects? I really like idea of FPGA but have hard time to find real world project for it to start my introduction with.

Have a look on OpenCores - http://opencores.org/

I hear the OpenCores website is nearly unmaintained. Someone went and made a github clone of all the code:

https://github.com/freecores

Love the UI on the new site, 38 pages of stuff to look through. It uses git though so it must be better.

I have a personal blog (http://idle-logic.com/) where I fiddle with FPGAs. Lately I've been working with the DE0-Nano from Terasic (Altera Cyclone IV FPGA).

There is a lot of good information if you dig through the archive, but no big 'real world' projects to share yet.

For example, here is a crash course in FPGAs: http://idle-logic.com/2010/02/11/dissecting-the-cyclone-2-ha...

DE0 is dope, and it comes for a very good price (especially for academics). It's very reliable, and Quartus is remarkably stable (compared to Xilinx ISE)

Reply on news.ycombinator.com