This course provides a comprehensive introduction to FPGA design and implementation, combining theoretical foundations with practical experience. Participants will learn key concepts of digital logic, FPGA architecture, and Verilog programming, progressing from basic design principles to real-world applications using the Vivado Design Suite. The course is ideal for those new to FPGA development, offering hands-on training for creating and implementing hardware designs.

The course provides experience with:

• Understanding the fundamentals of digital logic, Boolean algebra, and Karnaugh maps.
• Designing combinational and sequential circuits using logic gates and flip-flops.
• Learning FPGA architecture and the design flow.
• Creating projects in Vivado Design Suite, including source file management and synthesis.
• Writing and debugging Verilog code for combinational and sequential circuits.
• Implementing designs, generating bitstreams, and testing on FPGA hardware.

Who Should Attend?

Digital designers new to FPGA design who need to learn the FPGA design cycle and the major aspects of the Vivado Design Suite

After completing this training, you will have the necessary skills to:

▪ Use the New Project Wizard to create a new Vivado IDE project

▪ Describe the supported design flows of the Vivado IDE

▪ Generate a DRC report to detect and fix design issues early in the flow

▪ Synthesize and implement an HDL design

About the Instructor

Ron Amir, the admin of the EmbeddedMaker community and an Electrical and Computer Engineer graduate from Ben-Gurion University, brings extensive industry experience.

Ron has worked at Intel in various roles, including as a developer and as a manager of development teams.

FPGA Course Syllabus

Session 1: Binary System and Boolean Algebra

• Topics:
  1. Binary System:
     • Binary to decimal and decimal to binary conversions.
     • Gray code: Definition and applications.
     • Conversions between binary and Gray code.
  2. Boolean Algebra:
     • Laws of Boolean algebra (Commutative, Associative, Distributive).
     • De Morgan’s Theorems.
     • Simplifying Boolean expressions.
  3. Functions Presentation:
     • Sum of Products (SOP).
     • Writing expressions from truth tables.
     • Simplifying SOP forms.
  4. Basic Operations and Truth Tables:
     • AND, OR, NOT operations.
     • Building truth tables for logical functions.

Session 2: Logic Gates and Circuit Optimization

• Topics:
  1. Fundamental Gates:
     • AND, OR, NOT, NAND, NOR, XOR gates.
     • Truth tables and logical operations.
  2. Multiple Entrance Gates:
     • Gates with multiple inputs (e.g., 3-input AND, OR gates).
     • Real-life applications of multi-input gates.
  3. Universal Gates:
     • NAND and NOR as universal gates.
     • Designing any logical function using only NAND or NOR.
  4. Karnaugh Maps (K-Maps):
     • Simplifying Boolean functions using K-Maps.
     • Optimal logic reduction for combinational circuits.
     • Handling “don’t care” conditions in K-Maps.

Session 3: Sequential Logic and Flip-Flops

• Topics:
  1. Introduction to Sequential Logic:
     • Differences between combinational and sequential logic.
     • Applications of sequential circuits.
  2. Flip-Flops:
     • D, T, JK, and SR flip-flops: Structure and truth tables.
     • Designing edge-triggered and level-triggered flip-flops.
     • Registers and counters using flip-flops.

Session 4: Finite State Machines (FSMs)

• Topics:
  1. Introduction to FSMs:
     • Mealy vs. Moore state machines.
     • State diagrams and state tables.
  2. FSM Design:
     • Defining states and transitions.
     • Designing FSMs for simple applications (e.g., sequence detectors).
  3. FSM Implementation:
     • Converting state diagrams to flip-flop-based circuits.

Session 5: FPGA Architecture Overview and Design Flow

• Topics:
  1. FPGA Architecture:
     • Configurable Logic Blocks (CLBs).
     • Interconnects and routing.
     • Input/Output (I/O) blocks.
  2. FPGA Design Flow:
     • RTL design, synthesis, and implementation steps.
     • Overview of tools and steps for FPGA development.

Session 6: Vivado Introduction and Verilog Basics

• Topics:
  1. Vivado Design Suite:
     • Setting up a Vivado project.
     • Adding and managing source files.
     • Navigating Vivado’s interface and tools.
  2. Verilog Basics:
     • Module structure, syntax, and keywords.
     • Writing combinational logic in Verilog.
     • Common mistakes and debugging Verilog code.

Session 7: Verilog for Sequential Circuits, Behavioral Simulation, and Synthesis

• Topics:
  1. Verilog for Sequential Circuits:
     • Using always blocks and sensitivity lists.
     • Implementing flip-flops, registers, and counters in Verilog.
  2. Behavioral Simulation:
     • Testing Verilog designs in Vivado.
     • Simulating and validating functionality before synthesis.
  3. Synthesis:
     • Translating RTL to a netlist.
     • Resolving synthesis warnings and optimizing designs.

Session 8: Implementation, Bitstream Generation, Debugging, and Optimization

• Topics:
  1. Implementation and Bitstream Generation:
     • Design Rule Checks (DRC) and resolving errors.
     • Generating a bitstream and programming the FPGA.
  2. Debugging and Optimization:
     • Using Vivado logic analyzer.
     • Timing constraints and power optimization techniques.

Session 9: ALU Project (Part 1)

• Topics:
  1. Project Introduction:
     • Design specifications for an Arithmetic Logic Unit (ALU).
     • Functional requirements: Addition, subtraction, AND, OR, etc.
  2. Design Phase:
     • Writing the RTL for ALU operations in Verilog.
     • Simulating individual ALU operations.

Session 10: ALU Project (Part 2)

• Topics:
  1. Integration and Testing:
     • Integrating ALU modules.
     • Verifying correct operation through simulation.
  2. Implementation and Optimization:
     • Synthesizing the design.
     • Implementing, debugging, and testing on FPGA hardware.

Each class will include homework for practice.

Upcoming Course

📅 Starting from December 17th

⏰ Tuesday 19:30 – 21:30