Learning FPGA

Nice topic.

I saw some VHDL at university a few years ago, but this discussion is definitely
bringing back the need to learn more and refresh, or even update, my hands-on FPGA
experience.

As michaelkellett mentioned the Artix platform, I realized that it’s actually the same
direction I’ve been looking at recently. I’m planning to buy an Artix development board
soon and add it to my short-term project bucket list. In my case, it’s the Digilent
Cmod A7 with the Xilinx Artix-7 FPGA.

Funny timing, because this is exactly the kind of topic I’ve been thinking about
getting into lately, so all the recommendations here are really useful.

This might be controversial but I think the best way to learn FPGA is not to jump into the HDL languages right away.  If you are using the Altera environment use their block diagram editor which allows you to string together logic gates and flip flops in a schematic.... but don't stop there... use their wizard to create parametrized counter and compare blocks.  You may have heard that unlike software, FPGAs are parallel.. well that is true, but you can create sequences by decoding count values (of a clocked counter) for instance... or you can have a series of interdependent clocked registers that only advance when certain conditions occur.  I would spend a month to see what can be accomplished with counters, gates and compare blocks before moving to HDL.  The behavior of your designs can be tested using ModelSim (which I assume is still packaged with their software) or if you are working with a development board on Signal Tap II (their embedded logic analyzer) 

Just remembered, one of the examples that comes with the Microphase Artix dev board (see third link above) has a bare metal to RMII interface.

This is NOT the place to start learning about FPGAs  - try something simpler first.

SPI is much, much easier.

MK

Altera FPGAs are well documented and at the lower and simpler end have some advantages over AMD/Xilinx.

They have a wider range of low end parts and some of these are available on very attractively priced dev boards. There are many Altera FPGAs still available in TQFP packages which makes the attractive for low cost prototyping.

For a complete beginner I would recommend Lattice or Efinix FPGAs.

Small Lattice FPGAs are cheap and very cheap dev boards are avaialble. The Lattice tools and workflow for the simple chips is much easier to get started with than Altera or Xilinx. If you care about this there are Open Source tools for the small Lattice chips (I haven't used them so can't comment on ease of use.)

I find the Efinix chips to be good cheap and the tools OK but harder work than Lattice.

Another option is Gowin, very cheap boards, very cheap parts if you want to but  a lot but less easy tools.

Here's a really cheap Altera baord, lot smore on Aliexpress and you will need  a "Byte Blaster" to program it. You can download the Altera tools for free..

https://www.aliexpress.com/item/1005008090630134.html

Here's a Lattice board with an Ethernet port and a rather bigger Lattice FPGA. The iceNano boards are maybe easier to get started with but cost more for a lot less FPGA. You will need a programmer for the ECP based board.

https://www.aliexpress.com/item/1005008611836768.html

This is quite a nice Xilinx board (an I've actually bought and used these and they are quite good - documentation and support is OK, not brilliant, bet you can get schematics and examples that work (you will need to use a translator on the comments in the examples unless you can read Chinese))

https://www.aliexpress.com/item/1005005252087623.html

MK

Do you know of any places I could learn how to implement SPI? or RMII?

What do you think about Altera FPGAs? Are they also well documented?

Hi, it's great that you are looking into FPGAs. It's a steep learning curve, there area a lot of topics to cover and depending on the FPGA vendor you might have easier/hard time with the tools.

I'd recommend starting with Xilinx/AMD devices as the tools are a bit "easier" to navigate, and the documentation is ample.

1. I'd suggest downloading Vivado from the AMD website and start exploring it a bit by writing some simple VHDL code, making a test bench for it and synthesizing the design.
    This is a good starting point as you can see how your code works, without wasting time of HW debugging.

2. While doing 1, explore the VHDL language, the best resource is the "VHDL golden reference guide", also sites like vhdlwhiz.
     It is quite different from the programming languages in a sense that you have to think "hardware", and not just a list of commands. 

3. Once you get the basic idea of the language you can start with some simple designs - UART, SPI, etc.
     At this point, you can implement the design on your FPGA and observe it with your logic analyser to test whether it works as expected.  

4. Finally, there are also plenty of IPs  (intellectual Property, i.e. like a library) provided by the vendors, including virtual probes and analysers and ever RMII.
    To ge to know these, you simply read through the manuals for the respective IP.

Good luck with it, don't hesitate to ask questions

shabaz said:

You may wish to read up on digital electronics too, since with HDLs you're describing digital logic.

This might be one to add to the reading list as it covers both camps.

Video accompaniment for the book "Introduction to Logic Circuits & Logic Design with VHDL" by Brock LaMeres.

https://www.youtube.com/watch?v=HLM2epN9C2I&list=PL643xA3Ie_Et2uM4xu1yFk-A5ZQQ8gQ5e&index=47

Unfortunately the audio recording quality isn't great.

There is a matching book on Verilog if there is a need to flip between the two HDLs. 

There isn't any single comprehensive resource/book for complete beginners. You could try checking out the resources mentioned here:
The Art of FPGA Design - Post 3  

You may wish to read up on digital electronics too, since with HDLs you're describing digital logic.

You'll also need to plan in advance what software apps you need, because some of them can take a day to download, and others may require licenses to be obtained (which may also take days). Some have particular operating system, processor and memory requirements. After you've read up a bit, you could purchase an FPGA board to try things on.

You will need to invest a fair bit of time, and be prepared that things move differently in the FPGA world than for software development; unlike software where you can rapidly compile and just try it out, generally, for FPGAs, things need a lot more planning, you'd try to write test cases, and try it out virtually before trying it for real; plus, the entire "build" process takes a lot longer than running gcc hello_world.c.