Where to start for an easy intro to FPGAs?

Question

I'm sure this is one of those questions that is going to have more opinion that definitive answer, but I'm going to ask it anyway. I've not done anything with FPGAs. I know what they are and what they can do. I know that they're a bit of a shift in mindset for someone who's used to coding for a microcontroller. I'm at the same stage that I'm sure many people are. I want to find out if FPGAs are the sort of thing that I want to get into or not. To dip my toe in the water so to speak.

The trouble is there are a lot of manufacturers who seem to have their own tool chains and programming approaches. It's tricky picking one to start with. There are road tests of a few on here but to be honest they all sound hard and are difficult to compare. Has anyone got advice on where to start? I suppose my priorities are:

Once I pick a manufacturer I want to stick with it. Jumping from one to another will just make it harder.
It would be hopefully easy to get the basics. I don't need raw power right now. Being able to create a microcontroller core is great, but will only confuse me at this stage.
The option of a SoC alongside a microcontroller would be a nice option for later, but once again I don't need it right now.
Reasonably cheap. It doesn't have to be the cheapest, but this may be a dead end experience so I'd prefer 10s rather than 100s of £/$.

Right now I was thinking of waiting see how the pans out for those selected, and to learn from their experience. However, any opinions are welcome

genebren · Answer

David, You might want to look at CPLD's first. They are very much the same as FPGA, but smaller (#gates and #pins). They are typically programmed with the same tools and languages as FPGAs. I started with CPLDs to build sequencers, and co-processors like circuits to work together with uP and handle the things that are too fast or just to difficult to do on a uP. I like the CPLDs from the XILINX product line (especially the coolrunner line). They are much cheaper and easier to work with than some of the larger FPGAs. The tools are free ( https://www.xilinx.com/products/design-tools/ise-design-suite/ise-webpack.html ) and fairly easy to learn. Good luck! Gene

michaelkellett · Answer

If you want to learn about FPGAs then don't mess with CPLDs. The CoolRunners are ancient (15 year old designs). There are 4 major players in the FPGA business, Xilinx, Intel (was Altera), Lattice and Microsemi. Lattice are the only player interested in cheap FPGAs and they are actively working on their ice40 parts. They also have an XP2 range. They have FPGAs in thse ranges TQFP and QFN packages. The tools are the simplest to use but a bit basic. Intel (Altera) have the Cyclone 10 range which are nice in that the whole range is available in TQFP, they offer many parts in single 3.3V working and they are real full function FPGAs. The Altera free tool set is (in my opinion) the nicest of the free tools. Xilinx are the market leader in mega stuff and their main (Vivado) toolset is huge, very powerful and rather overwhelming (it has a free version too). Their CPLDs and older chips are not supported by Viavado but by older tools ( still free but one feels the coprporate focus is elsewhere.) Xilinx have no FPGAs in TQFP that are also supported by Vivado. The cheapest dev boards are Chinese boards with older Altera chips on them - you can get going for well under £30. There are Lattice boards as cheap from Farnell - I'd go with the Brevia 2253073 for about £35 - it's got a RAM chip and debug interface on the baord. There is a really cheap Lattice ice40 board from Gnarlygrey but these do have some issues which might be hard for a novice to deal with. Gnarly Grey - a microelectronic architecture company i'd leave the Arduino MKR Vidor 4000 for a few months (till it's properly sorted) - I really don't like the Arduino approach of wrapping everything up in it's own cloak but the board is cheap and has a decent FPGA on it (unfortunately matched with a totally under powered processor.) And of course some people really like the Arduino way. (Ooops - I didn't say anything about Microsemi - but that's because I've never used their stuff !) MK

michaelkellett · Answer

Lots of interesting points - I'm off on a long weekend hol so not enough time to cover them all but I'll have a go.

There are two primary HDL (Hardware Definition Languages), Verilog and VHDL. They both come in different versions, there are fewer versions of VHDL than of Verilog. The latest versions of Verilog and VHDL both contain many features that synthesizers are unable to deal with. This is one reason why HDL "code" may be non-portable.

Once you start using an HDL to target an FPGA you may want to use the special features of the FPGA like on chip RAM blocks, PLLs, DDRAM interface hardware etc etc. These are all different for different FPGAs and once your project uses them it becomes specific to that FPGA type.

Many people use the FPGA vendors toolset including HDL editor, compiler, simulator, synthesizer, timing checking, fitter, programmer and debugger.

As you move up the food chain you'll find more use of separate tools, I use Aldec HDL for design and simulation, this makes it a bit easier to port designs from one part to another but you still gut stuck with targeting features which are specific to different chips.

The tools have to do a great many things - the Aldec tool gives me a bunch of files in HDL that I know work OK in simulation, the vendor tool still has synthesize that into FPGA blocks, fit it into the FPGA, route it, check timing, and maybe re-route/fit many times. The vendor tools also include stuff for helping you use the on chip features and joining together loads of different bits of IP (other peoples' HDL) and managing the whole thing. A serious FPGA project will include hundreds of files.

In terms of what FPGAs can do:

AN FPGA is probably at least 10x less efficient in use of silicon than an ASIC. If you want an ASIC that can out compute a $2000 Xilinx FPGA expect to spend at least $100M getting it to production - if you only want less than 50,000 of them this doesn't work out fo you - even though the ASIC might only cost $100 each. (These are very rough figures but you get the idea).

For big projects big FPGAs can massively out compute pretty much anything, they have thousands of DSP blocks that can all work at once.

For smaller projects - I'll give you some real examples:

Glue together 4 different audio chips to talk to a piece of pro audio gear with a rather odd digital interface. A Lattice ICE40 chip costing £5, using a few mA of current was used to do this. It was also able to replace the tiny processor previously used for configuring the chips and can easily be tweaked if any of the audio chips is upgraded. No processor could handle 4 different protocols and talk to 5 chips using two different voltages.

Pre-process data from an 8 channel ADC generating 24 bit samples at an aggregate data rate of 1.92Ms/s. There are some DSPs that can just about talk to the ADC but none of them could handle the 128 bit wide data paths involved in the pre-processing. The DSP was a Cyclone 10.

Control 32 channels of 10 bit resolution PWM - this was a 1000 LUT ICE40 in a 100 pin TQFP package - very low power and cheap.

Debugging:

Simulation is the key - make sure everything works before it hits the hardware. Of course some things get missed and still don't work.

There are tools that try to embed some logic analysis in the FPGA but I've found them to be pretty much useless - the last project I tried to use them (Xilinx Vivado, Artix FPGA) whenever the debugging stuff was added the design wouldn't meet timing any more. I try to make sure that on a big project the FPGA has at least 16 pins on connectors exclusively for debugging. Then you can connect signals of interest to them and look with a logic analyzer. It's also a really good idea to add test connectors, series resistors or test pads (in descending order of preference) to on chip buses, so you can get access. On really fast stuff you can't do this - else it will stop working.

MK

johnbeetem · Answer

Good questions. I'd like to add my own comments to Michael Kellett's excellent points.

VHDL and Verilog do pretty much the same thing, so it's mostly a matter of how much you like typing. VHDL is based on Ada and is wordy. Verilog is based on C and is more concise. I personally prefer Verilog since I like to fit a lot of logic onto a printed page. Also, I don't have room to store VHDL source code listings. Chacun a son goût.

I once heard a manager say he prefers his FPGA designers to use VHDL because it's so different from C. He found that with Verilog some of his designers would write C-like code that did not synthesize well into FPGA logic. By making them use VHDL, they realized they were designing hardware and not software. I think this is rather silly, but then I've never been a successful manager.

Michael is correct about portability. If you write generic VHDL/Verilog it's very portable, but as soon as you use special features of the FPGA it becomes non-portable. Those special features are very useful for reducing the size of your design so it can fit into a cheaper part. Companies typically choose one FPGA family and stick with it, so portability is not an issue. As they say in Vermont during Mud Season: "Choose your ruts carefully."

FPGAs are particularly good at two things: very high performance computing and low-latency I/O. A general-purpose CPU has to share one or a few cores for all computations whereas FPGAs can perform a huge number of computations in parallel and pass results directly between computing element instead of constantly transferring them to and from shared memory (or cache or registers). On the other hand, a parallel GPU can often compete with or outperform and FPGA on many applications.

A general-purpose computer is typically bad at low-latency I/O, especially if it's running an operating system. FPGAs can do bit-level I/O with precision timing.

FPGA debug is more difficult than software because you don't have "printf". Most people recommend simulation, since it provides access to as many internal signals as you want. Personally, I avoid simulation since most of my designs are either trivial or else require writing a complex "test bench" to generate stimuli and expected results. My FPGAs often work in a complex software environment so it's much easier to have the actual hardware or a development board that can act as surrogate for the actual hardware.

As Michael said, include lots of extra test points. Those are your "printfs": you can route internal signals to the test points and see what's going on inside the FPGA.

When I design FPGAs I do lots and lots of synthesis. This is to make sure my design continues to fit inside a smaller, cheaper FPGA and that it meets timing. Most of my designs have been Xilinx Spartan chips. I annoy sales reps because I'm able to fit my designs in smaller Spartan chips instead of requiring large chips from more expensive families.

I'll often synthesize just part of the chip. One of the annoyances of most FPGA synthesis tools is that you make a small change to your source code and it produces an unexpectedly large increase in logic. Trying to track down why is difficult or impossible. Sure, the tool may generate schematics for you, but they're pretty much useless for a large design. By synthesizing frequently I can find which source code change caused the unexpected behavior and try to find a way around it.

Debugging timing issues isn't hard as long as you plan ahead and don't try to do more than the FPGA family can easily support. If at all possible, only use one clock. Signals crossing clock domains are a total pain and should be avoided at all costs. Synthesize early to see if you're going to run into trouble. You may need to pipeline the design, which is really hard to do later on but reasonable early in the design. Most FPGA families have lots of extra flip-flops so pipelining is cheap.

andywest · Answer

I learned most of what I know from the following books and documents: Learning FPGAs: Digital Design for Beginners with Mojo and Lucid HDL by Justin Rajewski The first thing I did was read this book. It uses the Mojo dev board and a language called Lucid, but it was close enough to Verilog to be useful. I bought a Mojo, but I never actually programmed it. I just read the book and moved on. Programming FPGAs: Getting Started with Verilog by Simon Monk I read this next and got a pretty good feel for Verilog concepts and syntax. It covers three boards: The Elbert 2, the Mojo, and the Papilio. DE0-Nano User Manual After doing a bunch of research and settling on the DE0-Nano dev kit, I downloaded the software and manual and read through it. This product-specific documentation was just as important as the books I read, if not more. At this point I was equipped with a good foundation of knowledge which gave me more confidence when I opened the Quartus II code editor for the first time. After that I looked at lots and lots of code examples on the web. One of the best ways to learn is to read a lot of code.

shabaz · Answer

Hi David, I've never done anything complex in programmable logic so I can't say which is the best approach, but I agree with Gene that CPLDs are a fun stepping-stone if you're interested. This Digilent board This Digilent board should really be a quarter of the price since there is nothing on there except the CPLD (Coolrunner-II) but it's still affordable as a one-off to experiment with. That Arduino board that Rod mentions looks really fantastic. It could be really worthwhile exploring that, initially to experience the power of 'hardware acceleration' and hopefully the documentation will eventually be there for people to write their own blocks of hardware. I tried some easy projects to get familiar with HDLs, like making a random noise generator (linear feedback shift generator), I've used the coolrunner for a couple of experiments - also since the chip is TQFP, it is easy to solder (and cheaper) to make your own board too. I used it it to create a TFT screen driver (using an external dual port RAM chip) for a small display, generating the pixel and sync signals. I wanted to make a handheld 68000 based computer ages ago. I simulated the screen driver, but never got round to implementing it..

DAB · Answer

Hi David, Take a look at the Cypress Semiconductor PSOC series. They are inexpensive, though not a full FPGA, you get access to programmable hardware for digital and analog circuits, which is a high level look at FPGA type implementation. You can get started for 4 USD and then decide if you want to go into the more detailed world of hardware design. DAB

rolandl · Answer

I bought a board from nandland.com. The guy also has a youtube channel, nandland. As I understand it it's not so much the manufacturer that should be your first pick but what language you choose. All FPGA's are programmed in either VHDL or verilog. My experience with the nandland board is positive. Together with the video's and this https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=2ahUKEwiYp_yW4MfdAhUEgRoKHYqJCNcQFjAA… book you will have a good introduction into FPGA's. You won't be hassled by the ridiculously complicated IDE's of the big manufacturers, which I consider to be a real plus when starting out.

14rhb · Answer

Hi David, Did you want to learn the Hardware Description Languages (HDL) such as VHDL/Verilog or do you just want to be able to utilise the processing power of the FPGA in the easiest way you can? My reason for asking is that I've just written a blog about the Digilent PYNQ - An Overview - it takes the use of an FPGA to another level of abstraction and uses Python and C code controlled through a web browser to configure the FPGA. Although the device is likely not optimised it is a simple route to getting the FPGA to do interesting stuff. No need to fiddle with any of those difficult toolchains. If you want something along the same lines then the Arduino MKR Vidor 4000 may be promising. According to the founder of Arduino (Massimo Banzi) during their webinar this evening there will be a simple drag and drop IDE for this board by the end of the year. Again it might be a really simple way to get into using the power of an FPGA without having to spend hours 'fighting' the complexities of a huge IDE, config files and optimisation. There are a couple of libraries available for the Vidor at the moment - so it can be used still. You access the IP blocks from the C code - again no HDL. Rod

johnbeetem · Answer

I'm afraid there's no "easy introduction" to FPGAs at this time -- at least I don't know of one. We had a good discussion here about this a couple of years ago: Barriers to designing with FPGAs? I don't think much has changed. I see the primary barrier as the steep learning curve, which I sometimes call the "The Cliffs of Insanity". You have to be pretty motivated to face that climb. Professionally, I've mostly designed using Xilinx. I started serious FPGA design with Spartan-II and ISE 5.2, which was quite simple compared to the later versions. My favorite Xilinx family is Spartan-3A, which is relatively simple but very powerful. Unfortunately, the Spartan-3A has passed its peak. Spartan-6 is very powerful and has excellent price/performance, but it's very complex so I wouldn't recommend it for a novice. I'd check out Lattice iCE40. It's a very simple architecture with 4-input look-up tables, kind of like the early Xilinx chips before they added (useful!) bells and whistles. You can get a Lattice iCEstick for US$20-25 which has a decent size iCE40, a built-in programmer, LEDs, and 0.1" headers for your experiments. It's a good way to get started. A huge advantage of iCE40 is that it has the open-source IceStorm tool suite so you don't need to download a huge program from Lattice. I've only used IceStorm for iCE40 design so I don't know what the Lattice tools are like. I watched Clifford Wolf's demo of how much faster IceStorm tools are. To a certain extent, you can just program FPGAs at the Verilog or VHDL level and let the tools worry about the details. However, at some point you'll need to understand the FPGA architecture enough to make sense of the error messages. I've read of people doing Spartan-6 design, making a minor VHDL error, and getting baffling error messages about clocks when the design was supposed to have been combinational. (The Spartan-6 has a separate long reference manual for clocks.) Having a simpler architecture makes debugging that much simpler. I'd stay away from CPLDs. They were very useful in their time (I've done lots of Xilinx XC9572XL designs), but with the low cost and superior capabilities of iCE40 chips there isn't much point to using CPLDs in new designs.

Fred27 · Answer

There's so much helpful information for all of you. Thanks.

Weighing a few things up, I think I'm going to go down the Cypress PSoC route. There are a number of things that pushed me in this direction, but I understand that everyone's priorities are different so it may well not be the best route for someone else. The positives for me were:

The smaller devices are in packages that are hand-solder friendly. I like SSOP and QFP, can tolerate QFN if I have to, but I'm scared of BGA.
Raw FPGA power isn't important to me right now. I'm just getting my feet wet. There's PSoC6 if I need power later.
It looks like PSoC Creator allows use of schematics or Verilog. (No VHDL - so that decision's made for me!)
It's a cheap way to get started. I can get a PSoC4 board with an easy to solder IC and a PSoC5 board with a built-in debugger for less than £20.
The SoC concept appeals. I can imagine anything I make will need a microcontroller too.

The Lattice iCE40 also sounded good but they have only one device that QFN32. Every other manufacturer seems mostly BGA.

I might wait until the Path to Programmable blogs start coming through, so I reserve the right to completely change my mind later and go Xilinx!

Fred27 · Answer

Thanks for all the helpful replies. I definitely want to do things "properly" and learn to use a hardware description language. The fact that there are CPLDs that are available as an easy way in without having to start again if moving up to a full FPGA is the sort of gem of information I was after. Thanks, Gene. If there's a manufacturer that makes CPLDs, FPGAs and SoCs that all use the same language and toolchain then that sounds perfect. I'll look a bit more into the Xilinx ecosystem. I'll look a bit more into Cypress too, DAB. A $4 board certainly sounds like a good starting point, but saving time is more important then saving money.

afmishaq · Answer

Hi DAB, Can you provide a little more info / link to the inexpensive Cypress PSOC? Just curious. Thanks, Faiz

mjardini · Answer

I've found the book ' Free Range VHDL ' a smooth reading. There's also the other links and book listed by our fellows. Some inexpensive boards for starts are the iCEStick and iCEBlink, you can also see the TinyFPGA from Luke ( Twitter ). I've bought to myself one iCEBlink (iCE40) and a PapilioOne 250K (Spartan3E) to start. The Arduino Vidor 4000 HDL Tutorial (SystemVerilog) is also a nice kickoff.

michaelkellett · Answer

The downside of the CPLDs is that you don't get memory or multipliers or that many logic elements (except in the modern ones ), since you'll use VHDL or Verilog it's no harder to work with the simple FPGAs. The Digilent board doesn't include a JTAG programmer (and the CPLD is tiny with only 64 logic elements v the 5000 or more in the FPGAs we've mentioned) so you would need to budget for that as well. It does rather depend on what you might try doing first, which we haven't asked yet ........ MK

gsgill112 · Answer

Hi Abdul, http://www.cypress.com/documentation/development-kitsboards/psoc-4-cy8ckit-049-4xxx-prototyping-kits has a couple of boards, starting from PSoC 4 (Go for the PSOC 4 4200 series as that has 4 UDB unlike the other one 41xx which has none.) . This board also has only an Usb to serial programming interface like Arduino, so no debugging there. If you can I would personally recommend PSOC5 LP Kit (its about 10$) , It has an On board Full fledged debugger that can be customised , and it has about 24 UDB's and you can also use the 24 on the debugger. It is a very interesting module, but nothing complex can be implemented. which is a bang for buck. I would suggest getting an FPGA dev board also. Regards, GS Gill

michaelkellett · Answer

I'm not trying to change your mind, the entry costs on the PSOC are certainly very low and I think the tools are more friendly than some of the traditional FPGAs. Good luck - I'll be interested to hear how you get on.

However, for when you need to step up a notch or two:

Lattice have hand solderable TQFP packages for XP2 (up to the 17k LUT version) and some older ice40 parts in TQFP 100 and 144, as well as the latest ones in 48 pin QFN.

Intel (Altera) Cyclone 10 are available across the full range up to 50k LUT in 144 pin TQFP.

Xilinx (IMO) are currently the worst choice for beginners or small scale because they have nothing modern other than in BGA. Once you've got the need for it they are almost certainly the market leader in raw performance and capability.

MK

michaelkellett · Answer

The ARTY S7 is about the simplest route into the Spartan 7, which in turn is the cheapest and simplest FPGA supported by Vivado.

Vivado is an awesome tool but not that difficult to do simple things with - it allows you to do very very high end stuff but it's OK for a beginner. It is very different from the Coolrunner toolset.

I do wish Xlinx would put a Spartan7 in a hand solderable package. They do offer it in 196 pin 1mm pitch BGA which would be feasible for small runs by hand assembly.

A free S7 board doesn't seem a bad offer

MK

Where to start for an easy intro to FPGAs?

Top Replies