Best products from r/FPGA

[part 3 of 3]

REGARDING ALT SOURCES FOR XILINX FPGA DEVELOPMENT BOARDS

Xilinx, Digilent and Zedboard aren’t the only sources for Xilinx development boards, not by a long shot. I was considering doing some Kintex or Virtex development for a supermassive parallel processor to solve a specific type of math problem. The Xilinx development board would have been USD$2,500 or so. That’s when I ran across Trenz Electronic GmbH (Germany) as another source, and they have a LEGO-like approach to having various IO boards onto which FPGA/SoC daughterboards can snap aboard. So you select the level of IO sophistication and form factor you want, and then what FPGA module to drive it with. For Artix-7 FPGA, the total cost is usually higher than equivalent Digilent or Zedboard boards. But for Kintex-7 or Virtex-7 FPGAs, the cost is often lower competitive equivalents. Worth checking out.

REGARDING INTEL (née Altera)If your desire it be most hirable, then yes: I would suggest purchasing a mix of development boards (if you have the budget) across at least Xilinx and Altera, and maybe Lattice for their great “less is more boards. I haven’t had time & budget to explore the Altera FPGAs and SoCs, but if I did I’d definitely be purchasing development boards through Terasic (Taiwan-based company) because they have the same lower-price, more marketable designs for boards as is true for Digilent (USA-based) with Xilinx chips.

[10] Terasic (English-language website):

https://www.terasic.com.tw/en/

REGARDING LATTICE

Last year I bought two small development boards from Lattice. I love these little boards which, like Digilent’s small 40-pin Cmod-A7 series, are great for those who love to tinker with FPGA-driven custom hardware designs. I love the idea that perhaps because Lattice are #3 in sales volume, they get the fact that you probably shouldn’t gouge folks for development boards. I first purchased an older (almost legacy) MachXO2-based development board (I forget the exact model) for $25 and then a newer MachXO3-based development board for $35, one from Lattice and the other from Digi-Key, as I recall. The big difference is how you want the bitcode stored: I chose the flash models over the alternative for the MachXO3.

These are teeny-tiny boards (roughly 3”x3” form factor) and are more like the Digilent Cmod-A7 except that they have four rows of 2x20 female headers on them as GPIO+power connectors for external hardware. I typically just install jumpers from the headers to my breadboards for projects. The margins would be too small for me to sell these alone, so I‘m thinking of listing each with a nice sized breadboard, jumpers and a bunch of RGB LEDs and 220Ω resistors as a “Lattice FPGA Development Starter Kit” for MachXO2 or MachXO3 designs. I don’t know what the price points would be, but that will all be figured out this coming weekend. I might also do the same with my Cmod-A7 boards to make them more attractive as well. I think I have four large breadboards in total, though I’ll probably skimp on the LEDs, resistors, and jumpers for the Cmod-A7 boards (and I might just list those by themselves to keep shipping costs to a minimum).

That’s really all I have to say other than to say I post quite often my thoughts about FPGAs to the @µCauliflowerBrewClub on FB, as I mentioned, and to Quora.com to answer questions there when I have time (because anything FPGA-related often requires a very detailed answer, as I’m overdoing here). I am only weeks in to Reddit and so I don’t know how much I’ll be posting about FPGA stuff here.

Finally, since I am a professional tutor of various technologies (including FPGAs), general math and science, should anyone want individual or group training on such things via group Skype video sessions, we can make that happen for as-needed or regular basis. FPGA/SoC designs have a tremendous learning curve associated with them, and even five years in I consider myself an intermediate, not expert, programmer and designer. Most recently I explored high-speed parallel adder circuits which was a lot of fun; ways of going wider than 32-bits to 64-bit or 128-bit adders/subtractors. I have fully scalable IP I hope release in 2019 into the public domain when I can document it which goes far beyond any free IP I’ve seen. Very proud of that, and that would be a great tutoring project to consider because switches+adders+LEDs or 7-segment outputs is a great entry-level project to tackle on ANY type of FPGA or SoC.

I’ll include contact info below, if anyone wants to snag the boards before I list them this weekend, or to inquire about FPGA tutoring or other subjects.

“Blind Man” Bert Sierra

The Kanamit Collective

Prescott, Arizona, United States

bertsierra@gmail.com [allow 2-3 days for replies]

(928) 458-5809 [24x7; no texts please]

@Bert.Sierra on Facebook

PS — Another good resource are books which focus on FPGA-specific topics like state machines, piplines, and so on. It can take time to detoxify your brain from thinking in sequential programming terms (which is partly why I am personally less interested in SoC development than pure FPGA designs). It can take a while to think purely in state machine terms, and also to deal with the various issues that arise as signals cross clocking domains which is something that can also trip up newbies if not properly trained on how to inject little synchronizer logic blocks. This is true even when switching from the asynchronous world of input buttons and switchs. I’ve been going over all my designs and inserting input synchronizers on switches and buttons (in addition to button debouncers, of course), and myriads of long-standing weirdnesses have disappeared as a result.

Here is a great book for getting on the state machine learning curve, with VHDL and SystemVerilog code snippets:

[11] “Finite State Machines in Hardware: Theory and Design (with VHDL and SystemVerilog)” — Volnei A. Pedroni — $45 ($25 from me; used, great condition, unmarked):

https://www.amazon.com/Finite-State-Machines-Hardware-SystemVerilog/dp/0262019663

​

[end part 3 of 3]

For books, my adviser seems to like: https://www.amazon.com/VHDL-Digital-Design-Frank-Vahid/dp/0470052635/ref=sr_1_11?ie=UTF8&s=books&qid=1231766888&sr=8-11.
I'm sure it has nothing to do with Frank Vahid being his old advisor... but Frank does know his stuff and his books are typically easy to follow (I have not read this book). It's obviously VHDL and not Verilog, but it's not hard to go from one language to another.

I'm currently reading through: https://www.amazon.com/gp/product/1523364025/ref=oh_aui_detailpage_o04_s03?ie=UTF8&psc=1.
It's SystemVerilog, still not Verilog, but SV is a super-set of Verilog so it still may be useful. Also, if you use SV for verification you will be happy. DPI is your friend.

Hopefully this was a little helpful.

Which problem is the main problem? Is it the logic design or is it not having documentation on which pins each peripheral on the display is connected to and not having documentation on how each one works?

The main information you need from the board manual is, for each device on the board: 1) what is the model number of the part? You should be able to get an English data sheet pretty easily if you do a web search for the part number. 2) which pins on the FPGA are connected to what pins on the part? Once you know the PIN numbers you can assign them to signal names in the constraint file.

I've been using Lattice tools so I don't even have Xilinx tools installed right now. If you want some code help, the best way to make it easy for people to read and modify for you would be to copy and paste it into https://www.edaplayground.com and paste the link. But that is generic HDL simulation stuff so doesn't help much with the vendor specific signal to pin assignment stuff in the constraint file.

Here is a popular beginner/hobbyist book on FPGAs: Programming FPGAs: Getting Started with Verilog https://www.amazon.com/dp/125964376X/

The main problem with books and tutorials is that they're rather board-specific. For example a tutorial might explain how to use one type of display on a certain board, but if you have a different board then the display may work differently or be attached to different pins. Certain things are pretty similar though, and it may just be a matter of determining which pins on the FPGA the display is connected to.

This site has some pretty good examples. For example here is how you encode a number for display on a 7 segment display: http://fpga4fun.com/Opto3.html

FPGA Prototyping by SystemVerilog Examples or FPGA Prototyping by VHDL Examples by Pong P Chu are both great books. They not only teach you syntax, but also some good guidelines all by taking you through a whole bunch of prototyping examples and exercises. They also teach you a bit about SoC design and give you some explanation of the Vivado software. There are also books by Chu that focus on development with Intel/Altera FPGAs, but personally I find Vivado a whole lot easier to work with than Quartus, so for your first FPGA I would recommend getting a Xilinx FPGA. You do need a 7+ series FPGA to use the Vivado environment. Furthermore, I'd recommend learning SystemVerilog as it has better support than VHDL 2008.

Bebop to Boolean Boogie is pretty good. Very easy and fun book to read. Covers a ton of great entry level topics.

https://www.amazon.com/Bebop-Boolean-Boogie-Unconventional-Electronics/dp/1856175073/ref=sr_1_1?keywords=bebop+to+boolean+boogie&qid=1573568129&sr=8-1

Then move towards something more FPGA specific like

https://www.amazon.com/FPGA-Prototyping-Verilog-Examples-Spartan-3/dp/0470185325/ref=sr_1_2?keywords=fpga+verilog+examples&qid=1573568177&sr=8-2

Knowing C will probably hurt you more than help you. Forget what you know about C when learning Verilog. You need to approach learning Verilog in a different manner. Verilog is not another top-down procedural language expressing instructions one after another. There are some general programming tenets that still hold true, and attention to detail in regards to syntax is important. But forget about line-by-line procedural execution because that's not how these hardware description languages work. You need to learn DIGITAL DESIGN before you learn Verilog....

EDIT: for clarity and to tighten up my thoughts.

This site has a decent variety of beginner FPGA tutorials that would probably be interesting: https://www.fpga4fun.com

I would absolutely not recommend trying to use a bitcoin miner on an FPGA for a couple of reasons:

1. It's going to be very difficult for a beginner (or even an intermediate) hardware designer to be able to jump in and understand how this whole thing works and try and change things in it. If you actually want to learn how to design hardware on an FPGA, it's much better to start slow and learn the fundamentals of design than to jump in the deep end.
   
   
2. Mining bitcoin on an FPGA is not competitive anymore, especially on a small FPGA like this one. For instance, when I tried it on a DE0-nano (which is a larger and faster FPGA than this one), I got 9-10 MH/s. Compare this to a miner I found on amazon which costs $45 and can get 15GH/s. This miner is on the very low end of bitcoin miners, and yet it gets 1000x the hash rate over my FPGA for a lower price (the DE0 now goes for around $70 I think). Suffice it to say, you have no hope of making money with this device.
   
   
3. The FPGA targeted by the link you posted has several times more LEs than your FPGA, so you will have to port the design to the smaller FPGA. As discussed in point 1, this won't be easy, especially for a beginner.
   
   In short, I recommend learning FPGAs by starting small and working your way up. And (I know this is going to be hard, but it will help) try to resist the urge to test everything on the device. Unlike writing code on a desktop or even a microcontroller where you can open a debugger, debugging an FPGA is like working with a black box, in that it's really difficult to get a good idea of what's going on inside it. Instead, before your design ever goes on the FPGA, you really should simulate it using something like Icarus Verilog or Verilator or even modelsim to find the bugs in your design, and only when you're sure it will actually work, put it on an FPGA. I recommend checking out zipcpu's blog where he gives examples of how to simulate a design effectively. My life would have been so much easier if someone had told me this when I was first starting.

> Pynq-Z2 is pretty good bang for the buck (if you still have your uni email you should be able to get it with student discount).

The Pynq Z2 also has that Raspberry Pi header, and one of the things you can do with it is connect high resolution high frame rate parallel displays like this one, or the Adafruit Kippah.

It's a quirk of the fact that the real Raspberry Pi has a parallel display interface meant for 60fps+ output, so there are displays for sale that can actually work at that rate specifically made for that header.

It's also nice if you're making your own add-on boards, since that header has a ton of usable pins.

Note that some of those pins are shared with one of the PMODs though.

> Considering how often posts like these pop up, should there be a community curated list of suggested dev boards?

Yea there should, I had to write up my own spreadsheet when I was looking for a Zynq board a few months ago, it was overwhelming trying to sort through all the different options and remembering which ones have specific features.

Actually, I worded it so there isn't an assumption on the languages being discussed, just using Language A and Language B as examples to show the flaw in the methodology used. It may or may not be reality, I don't know, but the article drawing the conclusions don't show that the data they used for the conclusion is valid either. It could be just the opposite, and verilog requires more googling, in that case, the data would be just as flawed.

You are right, they may require similar amounts of googling, Verilog may require much, much more, or it may be VHDL that requires more. However, to make a conclusion from the data (the one in the article is that the google search results represented the number of users, and could be counted on to make a fairly significant decision), you need to show that the data represents what is claimed.

With respect to the decision on what language to learn first, either will work, I learned VHDL before Verilog. The person should use real data based on their needs to make the decision. Look at the industries, schools, etc that you are aiming to work with/in. If you are learning FPGA's as a hobby, what sources are you using to learn, are they VHDL or Verilog oriented. I would also recommend a good book that gives examples in both languages like this, it is an older book, so I would look for a newer one, but it gives examples in both languages side by side. This gives a person exposure to the language they are not using while learning one, making it much easier to learn the second later. Like most programing problems, the language really doesn't matter if you get good fundementals, switching languages becomes a minor issue.

TL;DR: Learn the language that makes sense for your situation first, but don't trust the data from the article to make this decision.

Digital Design and Computer Architecture is my favorite plain-language start to digital design.

You start with transistors and logic gates, and move all the way up to assembly language and compilers. Basically all the knowledge you need to create a simple processor.

It's going to help you think of Verilog as what it is, a description of physical hardware on a chip, as opposed to a set of instructions. Programming is like giving someone directions on a map, HDL is like building the roads. An if statement in C is a set of instructions executed in order. An if statement in Verilog is saying "Place a multiplexer here, and wire it up to these other pieces of hardware."

Well, you need to learn some HDL(s) first, VHDL or Verilog for exemple. I would recommend you to pick up a reference book like the Volnei Pedroni VHDL, or Pong. P. Chu.


http://www.amazon.com.br/Circuit-Design-Simulation-Volnei-Pedroni/dp/0262014335

http://www.amazon.com/FPGA-Prototyping-VHDL-Examples-Spartan-3/dp/0470185317/ref=asap_bc?ie=UTF8


And you can practice here: http://www.edaplayground.com/ without having to download any tool. After you stick to the HDL methodology, you start to think about prototyping, placing, routing, layout on a physical FPGA. I would recommend you to take a look in hardware verification and testbench design, depending on what you're implement it will be crucial to have a robust verification enviroment to avoid huge debugging efforts and lots of headaches.

There is a free ~50 pages "FPGA for Dummies" book which you can download from here: https://plan.seek.intel.com/PSG_WW_NC_LPCD_FR_2018_FPGAforDummiesbook

There is also a very good title by Simon Monk who has written many good books for makers: https://www.amazon.com/Programming-FPGAs-Getting-Started-Verilog/dp/125964376X

EDIT: no idea why this was downvoted; here is yet another useful title: The Design Warrior’s Guide to FPGAs

No, this would be a completely unsuitable book to learn from. It's a collection of academic papers, not an instructional text.

I'd personally recommend FPGA Prototyping by Verilog Examples (or the equivalent VHDL version). It's an older book, but still a pretty good introduction.

Yes, it's possible. But unless you have a good reason to do so, I'd stick to using development boards to learn FPGA design. Making the FPGA board alone will be a very time consuming project if you don't have much experience making hardware.

Your Digilent board should be fine for your requirements unless you want to make large or high-speed design projects (which is unlikely if you are just learning).

I'd look into this book for a good refresher. You can also find projects in www.FPGA4fun.com.

This is good advice. Specifically, I'd suggest a how-to book to get started. The "Learning By Example" publishers have a nice series with applications for Xilinx/Digilent FPGA systems. See http://www.lbebooks.com/

Most of the digital design books (University Level) are all theory and homework with minimal examples you can implement RIGHT NOW in verilog. If you need a University-level reference, Harris and Harris is better than most. https://www.amazon.com/Digital-Design-Computer-Architecture-ARM/dp/0128000562

Either of these references would work with https://store.digilentinc.com/basys-3-artix-7-fpga-trainer-board-recommended-for-introductory-users/ note, there's a "student price" if you ask.

Good luck to you.

This is the best VHDL reference by far.

Ashenden

A decent reference for system verilog, I guess verilog as well.

sysverilog for design

This github account has a good bit of decent FPGA focused Hdl

https://github.com/analogdevicesinc/hdl

And this one

https://github.com/EttusResearch/fpga

If I was you I would focus on being fluent in one vendor, probably Xilinx. I would also focus on learning how to implement Axi4 Streaming Interfaces with back pressure. It’s relatively new on that side of things and may be a decent way to differentiate yourself early on. It’s subtlety complex and very powerful when used consistently.

Anyone I’d think about hiring as a 3 to do FPGA needs to know modelsim or the equivalent. Vendors will try to convince you their generator stuff is so good “you don’t have to simulate it!” They are lying.

Get the vendor one from microsemi or Altera, or use xsim. Xsim I find dumb, but I’ve got lots of stick time on more expensive tools.

A tutorial written by Ashenden himself

However, I consider his full book as the bible: https://www.amazon.com/Designers-Guide-Third-Systems-Silicon/dp/0120887851/ref=sr_1_1?ie=UTF8&qid=1492258842&sr=8-1&keywords=ashenden+vhdl

Edit: Check out the all time top posts for this subreddit. Multiple posts with free books.

Thx. Tell me It is useful?

https://www.amazon.com/Handbook-Digital-Techniques-High-Speed-Design/dp/013142291X

​

Check this out for a newbie friendly introduction to digital systems:
https://www.amazon.com/Bebop-Boolean-Boogie-Third-Unconventional/dp/1856175073/ref=sr_1_1?ie=UTF8&qid=1494656076&sr=8-1&keywords=bebop+to+the+boolean+boogie

You can choose:

1. FPGA Board: Elbert V2 Spartan 3 FPGA Development Board
   
2. Book: Programming FPGAs: Getting Started with Verilog 1st Edition by Simon Monk
   
   Please do note that Xilinx ISE Design Suite software, although still widely used for legacy devices, has been effectively EOLed (End-of-life) by Xilinx, and for installation on Windows 10, it needs few extra steps to make it compatible. Linux version of ISE has no such restriction.

What are you shooting for?

RTL Modeling with SystemVerilog for Simulation and Synthesis: Using SystemVerilog for ASIC and FPGA Design

SystemVerilog for Verification

Pong Chu's Books

Digital Design and Computer Architecture

Xilinx University's Workshop Labs

Intel Workshops

Intel Tutorials

this one

https://www.amazon.com/gp/aw/d/0120887851/

There are two books that are decent

SystemVerilog for Verification and SystemVerilog for Design


I have found The Designer's Guide to VHDL by Peter Ashenden to be a god-send for learning VHDL from a language perspective. I have found nothing as good for SystemVerilog. Those two books I mentioned are close though.

My personal opinion is that SystemVerilog is cool, but frankly just an unmitigated shit-show of language design. They should be ashamed of how poor it is.

There is no concept of a standard library, and things that should be in a standard library are core language. Then there is this idea of a "Verification Methodology" like OVM and UVM, which are libraries, but they are glued into the core language through MACROS!!! MACROS!! I'm not kidding. It is almost comical how bad it is.
As I've said before. We need an open source simulator that can handle multiple language simulations, and then to replace this mess with something modern and awesome.


I would also suggest checking out this guys stuff http://syswip.com/. It is a little funny in some places, but it really helped me understand so of the approaches that a designer could take. The approach a UVM guy would take, is sadly, almost completely different than this. I don't think it is better though depending on what you are doing.