Getting Started with FPGA Programming with VHDL

Field Programmable Gate Arrays are a technology that sits between general-purpose microprocessors and fixed-structure Application Specific Integrated Circuits, and you can build almost anything with them. This course will teach you how.
Course info
Rating
(15)
Level
Beginner
Updated
Nov 14, 2016
Duration
3h 8m
Table of contents
Description
Course info
Rating
(15)
Level
Beginner
Updated
Nov 14, 2016
Duration
3h 8m
Description

Field Programmable Gate Array (FPGA)s provide both the ability to effectively design your own processor to perform a specific task yet, at the same time, allow for later reprogramming the processor in the field. FPGAs are used across many industries, from home automation to financial engineering, aerospace and many others. While this all sounds deadly serious, it's important to understand that working with FPGAs can also be quite fun. You can think of them as the world's fastest set of Lego blocks. What you can build with an FPGA is mostly limited only by your imagination. In this course, Getting Started with FPGA Programming with VHDL, you'll first learn an overview of FPGA architecture. Next, you'll learn the fundamentals of VHDL programming language. Finally, you'll wrap up the course by learning about debugging and analysis. You'll look at how to create configurations, define signals and triggers to monitor, configure signals, and recompile to embed the logic analyzer in the design. By the end of this course, you'll have a strong foundation of FPGA programming with the VHDL language to use in your own work.

About the author
About the author

Dmitri is a developer, speaker, podcaster, technical evangelist and wannabe quant.

More from the author
ReSharper Fundamentals
Intermediate
2h 54m
Apr 28, 2017
More courses by Dmitri Nesteruk
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone. My name is Dmitri Nesteruk, and I'd like to welcome you to my course on Getting Started with FPGA Programming using VHDL. Now I am myself a quantitative analyst, and I am particularly interested in the use of high performance computing technologies, such as FPGAs in the field of finance. This course introduces the topic of Field Programmable Gate Array Development. FPGAs are a technology that sits between general purpose micro processes and fixed structure application specific integrated circuits. FPGAs provide both the ability to effectively design your own processor to perform a specific task, yet at the same time allow for later reprogramming the processor in the field. FPGAs are used across many industries from home automation to financial engineering, aerospace, and many others. While this all sounds deadly serious, it's important to understand that working with FPGAs can also be quite a lot of fun. You can think of them as the world's fastest set of Lego blocks. What you can build with an FPGA is mostly limited by your imagination. Now in this course we will teach you how to program FPGAs using the VHDL programming language, and it covers the following modules. First of all, we'll have an FPGA Architecture Overview. Then we'll have a Digital Design Primer, so you can remind yourself how to build electronic circuits. Then we're going to discuss the Introduction to VHDL. We'll take a look at writing sequential code and also writing concurrent code. We'll discuss Packages and Components, and we'll finish off the course with a discussion of Debugging and Analysis. By the end of the course you'll know how to program for an FPGA, how to run your programs on the development board, and how to analyze and debug your designs. This course doesn't have any requirements beyond basic knowledge of computer science, such as understanding what bits and bytes are, but some knowledge of digital design principles will certainly be beneficial, so I hope you will join me on this journey to learn about FPGAs with the Getting Started With FPGA Programming Using the VHDL course here on Pluralsight.

Digital Design Primer
Hi there. In this module we're going to get acquainted with some of the fundamental principles of digital design. So the goal here is to learn some of the basics. This module isn't a replacement for a comprehensive digital design course, which typically takes a semester or two, so what we're going to cover is only those elements of digital design, which are relevant to our understanding of the logic element, which is a fundamental building block of an FPGA. So here's what we're going to cover. First of all, we'll talk about Boolean logic, which is a fundamental piece of logic that's used in digital design. Then we're going to take a look at some of the basic logic gates, out of which different digital designs are actually constructed. We're going to discuss addition and multiplication of numbers. We're going to take a look at some of the more complicated circuits like a flip-flop, a multiplexer, and a Lookup Table, and finally, we'll talk about clocks and timing on an FPGA.

Introduction to VHDL
Hi there, and welcome to this module on VHDL. Now the goal of this module is to get yourselves acquainted with VHDL, and learn just the basics. We're not going to go into too much depth, but we are going to cover those parts of VHDL which are necessary for interacting with boardio or at least some of the input and output elements. Specifically, we're going to take a look at how to program the buttons and switches to actually do something, to light up and LED, for example, so here's what we're going to see in this module. First of all we'll discuss what VHDL is and why you need it, and then we'll take a look at the two principle parts of any kind of FPGA design, the entity and architecture, that's what makes a single design unit. We'll talk about the port declaration, and how these ports actually relate to some of the board I/O elements. Then we'll take a look at the fundamental, the kind of core data types of VHDL bits and bit vectors, and finally, we'll do a demo where we'll actually interact with the board I/O. We'll program the switches and buttons to actually do something with the LEDs.

Packages and Components
Hi there. So far all the demos that we've done were single file, and they were fairly simple. So the goal of this module is to talk about what happens when you have a larger project. How do you organize your code to make the whole project understandable and manageable? So the goal of this project is for us to learn how to organize the code better, but we're also going to take a look at how to actually use third party packages, and there's one particular package that we're actually going to discuss in depth. So here's what we're going to see in this particular module. First of all, we'll talk about the IEEE Library, and the standard logic type, which is very important, and is actually used all over the place instead of things like bit and bit vector that we've been using so far. Then we'll take a look at packages and libraries generally, and we're actually going to learn how to make our own library, which we'll do in the demo part. Then we're going to talk about components and port maps. This is important for arranging multi-level designs in your FPGA. This way you can use entities inside architectures, and you can build a fairly complicated architecture out of simple building blocks. Then we'll take a look at the generate statement, and this is something that actually helps us put several elements of the same type, for example, into our architecture, and finally, we're going to do a demo where we'll actually use all this knowledge to build something which involves both packages as well as components.

Debugging and Analysis
Hi there, and welcome to the last module of this course. Now in this module we're not going to program anymore. Instead, we're going to take a look at simulation and debugging. So the goal of this module is for you to learn how to use the tools, which are provided by Altera, to find and correct different errors in your designs, and there are two specific tools that we're going to discuss. First of all, we'll take a look at ModelSim, which allows you to simulate the code that you write without actually having a physical hardware device, so you can simply feed your code into a simulator, which then gives you the waveforms as if it was executing on the actual FPGA, and then the next part is we're going to take a look at the SignalTap Logic Analyzer. Now this is something which does require compilation, and does require actual hardware, but it lets you monitor what's happening on your FPGA while sitting at your computer.