FPGA (Field-Programmable Gate Array) Design & Implementation

Become FPGA Design Engineer. Learn FPGA Design Engineering, Design Flows & Tools, FPGA DSP Circuits, Protoflex, PLI etc.

A warm welcome to the FPGA Design & Implementation course by Uplatz

What you’ll learn

  • Gain end-to-end knowledge of FPGA design engineering & implementation.
  • Acquire skills to become FPGA Design & Implementation Engineer.
  • Learn FPGA Design flows & design tools.
  • Understand and implement FPGA Design using Verilog.
  • Learn FPGA Testing.
  • Simulate and implement SOPC Design.
  • Learn how to read data from Peripherals.
  • Learn FPGA implementation of DSP Circuits.
  • Define Wordcount using MapReduce for FPGA.
  • Describe Protoflex and Reconfigurable Hardware.
  • Understand challenges in using FPAA FPGA in Mixed Signal Technology.
  • Get knowledge of Mentor Graphics Tools & Guidelines.
  • Define & execute Spartan FPGA and Memristive FPGA.
  • Perform Image processing using FPGA.

Course Content

  • Introduction to FPGA (Field Programmable Gate Arrays) –> 1 lecture • 32min.
  • FPGA Testing –> 1 lecture • 17min.
  • FPGA Design Flows & Design Tools –> 1 lecture • 36min.
  • FPGA Design using Verilog –> 12 lectures • 4hr 6min.
  • Simulate and Implement SOPC Design –> 1 lecture • 27min.
  • Reading Data from Peripherals –> 1 lecture • 9min.
  • UART SDRAM Python –> 1 lecture • 22min.
  • Script execution in Quartus and ModelSim NIOS –> 1 lecture • 14min.
  • Image Processing using FPGA –> 1 lecture • 32min.
  • Challenges in using FPAA FPGA in Mixed Signal Technology –> 1 lecture • 5min.
  • Protoflex –> 1 lecture • 20min.
  • Reconfigurable Hardware –> 1 lecture • 30min.
  • Wordcount using MapReduce for FPGA –> 1 lecture • 19min.
  • FPGA implementation of DSP Circuits –> 1 lecture • 26min.
  • Reversible Logic Circuits –> 1 lecture • 24min.
  • FPGA implementation of Divider in Finite Field –> 1 lecture • 13min.
  • Principles of PLI –> 1 lecture • 13min.
  • Spartan FPGA implementation –> 1 lecture • 13min.
  • Programmable Chips and Boards –> 1 lecture • 29min.
  • Memristive FPGA –> 1 lecture • 30min.
  • Mentor Graphics Tools & Guidelines –> 1 lecture • 32min.

Auto Draft

Requirements

  • Enthusiasm and determination to make your mark on the world!.

A warm welcome to the FPGA Design & Implementation course by Uplatz

 

FPGA stands for Field Programmable Gate Array. FPGA is essentially an integrated circuit that can be programmed by a user for a specific use after it has been manufactured. The modern day FPGAs contain adaptive logic modules (ALMs) and logic elements (LEs) connected via programmable interconnects. These blocks create a physical array of logic gates that can be customized to perform specific computing tasks. This makes them very different from other types of microcontrollers or Central Processing Units (CPUs), whose configuration is set and sealed by a manufacturer and cannot be modified.

FPGA programming has become a buzzword these days due to it offering considerable benefits over the traditional ICs. FPGA allows you to offload resource hungry-tasks to hardware and thus cause a significant increase in performance. FPGAs can be programmed and reprogrammed according to the dynamic needs.

 

FPGAs (Field Programmable Gate Arrays) are integrated circuits that are commonly available off-the-shelf. They’re called ‘field programmable’ because they allow customers to alter the hardware after it’s been manufactured to satisfy particular use case needs. This enables for in-place feature updates and bug fixes, which is particularly important for remote deployments. FPGAs include customizable logic blocks (CLBs) and programmable interconnects that enable the designer to link and configure the blocks to accomplish a wide range of tasks, from basic logic gates to complicated functions. On a single FPGA chip, whole SoC architectures with various processes may be implemented.

FPGAs are very adaptable. After the board has been developed, they enable engineers to test any number of variables. New configuration files are transferred onto the device when modifications are necessary, allowing new capability to be accessed. OEMs may supply systems earlier in the design phase because of this flexibility. Developers create prototypes on FPGA to gradually improve the design before it is taped out. FPGAs are often employed in commercial applications where parallel processing is required and the requirements are dynamic, such as telecommunications and aircraft.

 

The FPGA evolved from older devices such as programmable read-only memory (PROMs) and programmable logic devices (PLDs) (PLDs). These devices could be programmed in the factory or in the field, but they utilised fuse technology (thus the term “burning a PROM”) and couldn’t be modified after they were programmed. FPGAs, on the other hand, store their configuration data in a reprogrammable media like static RAM (SRAM) or flash memory. Intel, Xilinx, Lattice Semiconductor, Microchip Technology, and Microsemi are among the FPGA manufacturers.

 

The goal of this FPGA Design & Implementation course is to gain knowledge about Field Programmable Gate Arrays (FPGAs) in order to create prototypes or products for a number of applications. Although FPGA design is a complicated subject, we will explain it in such a way that the fundamental ideas may be readily mastered with a little effort, while simultaneously offering a challenge for the more experienced designer. Field Programmable Gate Arrays (FPGA) and Complex Programmable Logic Devices (CPLD) will be examined for their complexity, capabilities, and trends (CPLD). The abilities of conception, design, implementation, and debugging will be honed. You’ll learn about embedded IP and processor cores, as well as the advantages and disadvantages of implementing vs purchasing IP. The newest software and FPGA development tools, as well as hardware platforms are demonstrated in this FPGA course to assist establish a wide understanding of the capabilities of different Programmable SoC solutions. The delegates will learn the fundamentals of digital systems design utilizing FPGAs in this course.

 

FPGA Design & Implementation – Course Syllabus

 

  1. Introduction to FPGA (Field Programmable Gate Arrays)
  2. FPGA Testing
  3. FPGA Design Flows & Design Tools
  4. FPGA Design using Verilog – Introduction
  5. FPGA Design using Verilog – Verilog overview
  6. FPGA Design using Verilog – Data Types
  7. FPGA Design using Verilog – Procedural Assignments
  8. FPGA Design using Verilog – VHDL Design using Verilog
  9. FPGA Design using Verilog – Visual Verification of Designs
  10. FPGA Design using Verilog – Finite State Machines – part 1
  11. FPGA Design using Verilog – Finite State Machines – part 2
  12. FPGA Design using Verilog – Design Examples
  13. FPGA Design using Verilog – Test Benches
  14. FPGA Design using Verilog – SystemVerilog for Synthesis
  15. FPGA Design using Verilog – Packages & Interfaces
  16. Simulate and implement SOPC Design
  17. Reading Data from Peripherals
  18. UART SDRAM Python
  19. Script execution in Quartus and ModelSim NIOS
  20. Image Processing using FPGA
  21. Challenges in using FPAA FPGA in Mixed Signal Technology
  22. Protoflex
  23. Reconfigurable Hardware
  24. Wordcount using MapReduce for FPGA
  25. FPGA implementation of DSP Circuits
  26. Reversible Logic Circuits
  27. FPGA implementation of Divider in Finite Field
  28. Principles of PLI
  29. Spartan FPGA implementation
  30. Programmable Chips and Boards
  31. Memristive FPGA
  32. Mentor Graphics Tools & Guidelines

 

FPGA Functional Design

The process of turning an original system concept into an actual FPGA implementation that accomplishes the needed tasks is known as functional design. The basic concept for the design cycle must specify how the design will be partitioned among various FPGAs if necessary. The process of functional design starts with the formation of a description of a system’s sections (building blocks) in the most natural way feasible for the component in question. The simplest description methodology for fundamental structures built from primitive Actel, such as Multi-bit registers and multiplexors, is schematic capture using Design Architect (DA). For blocks containing random programming, such as decoders or ALUs, the easiest explanation is typically a hand-generated synthesizable VHDL model. Although automated HDL generators such as Renoir may be used to construct the natural graph description of a VHDL model, the simplest description is also a Synthesizable VHDL model for Finite State Machines (FSMs), such as controllers. After the building blocks have been first described, they should be separately simulated to check that they are properly functioning. This is done using the model-simulator, schematic Quicksim or VHDL model ModelSim.

Get Tutorial