Master VHDL & Rust
Your North Star

3-Input AND Gate

Create entity for a 3-input AND gate

4-Bit Input Entity

Design entity with 4-bit input and 1-bit output

8-Bit Data Bus

Declare signals for an 8-bit data bus

Constants

Create constants for clock period and delay values

2-Input OR Gate

Write architecture for a 2-input OR gate

Bidirectional Port

Design a 4-bit wide entity with bidirectional port

Type Conversion

Convert between std_logic_vector and integer types

Custom Package

Create a package with custom data types

Debug Exercise

Debug given code with 5 syntax errors

Data Types Quiz

Quiz on data types and port modes

2-to-1 MUX

Implement 2-to-1 MUX using when/else

3-to-8 Decoder

Design 3-to-8 decoder with with/select

4-to-1 MUX

Create 4-to-1 MUX using conditional assignment

Priority Encoder

Implement priority encoder (4-bit to 2-bit)

7-Segment Decoder

Design 7-segment decoder for hex digits 0-F

Barrel Shifter

Create barrel shifter using concurrent statements

Magnitude Comparator

Implement magnitude comparator (2-bit numbers)

Parity Generator

Design parity generator (even/odd selection)

Generate Statement

Use generate to create array of 8 AND gates

ALU Slice

Implement ALU slice with add/subtract operations

Debug Concurrent Code

Debug concurrent code (find 3 logical errors)

Mini-Project

Design a simple calculator (add/sub/and/or)

D Flip-Flop

Write process for D flip-flop with async reset

8-to-1 MUX

Implement 8-to-1 MUX using case statement

BCD Converter

Design BCD to excess-3 converter using process

Variables Practice

Create process with variables for temporary calculations

Timing Comparison

Compare variable vs signal assignment timing

Full Adder

Implement full adder using process

Gray Code Converter

Design 4-bit binary to gray code converter

ALU Design

Create arithmetic logic unit (ALU) with 4 operations

Conditional Branches

Write process with multiple conditional branches

Look-up Table

Implement look-up table using case statement

Sensitivity List Debug

Debug process with incomplete sensitivity list

Hamming Encoder

Design Hamming code encoder (7,4)

Thermometer Code

Create process for thermometer code converter

Booth Multiplier

Implement booth multiplier (4x4 bits)

Mini-Project

Simple CPU control unit

Integer to Binary

Write function to convert integer to binary vector

Parity Function

Create function for even parity calculation

Memory Init Procedure

Design procedure to initialize memory array

Maximum Function

Implement function for finding maximum of 3 numbers

Out Parameters

Create procedure with out parameters

CRC Calculation

Write function for CRC calculation (simple)

Bit Reversal

Design procedure for bit reversal

Function Overload

Implement function overload for different types

Reusable Package

Create package with reusable functions

Mini-Project

Math operations package

Custom Types Package

Create package with custom types and constants

Conversion Package

Design package for conversion functions

Component Package

Implement package with component declarations

Numeric Std Practice

Use numeric_std for arithmetic operations

Math Package

Create math package with add/sub/mult functions

Testbench Utilities

Design testbench utilities package

UART Constants

Implement package for UART constants

Mini-Project

Complete design using packages

Sync Reset D-FF

Design D flip-flop with synchronous reset

T Flip-Flop

Implement T flip-flop from D flip-flop

D-FF with Enable

Create D-FF with async reset and enable

4-Bit Register

Design 4-bit register with parallel load

Universal Shift Register

Implement universal shift register

Register File

Create 8-bit register file (4 registers)

JK Flip-Flop

Design JK flip-flop with preset and clear

Ripple Counter

Implement ripple counter using T flip-flops

Tri-State Register

Create register with tri-state output

Up/Down Counter

Design synchronous up/down counter

Johnson Counter

Implement Johnson counter

FIFO Buffer

Create FIFO buffer (4x8 bits)

Debounce Circuit

Design debounce circuit for push button

Clock Divider

Implement clock divider (divide by 2, 4, 8)

Mini-Project

8-bit accumulator

3-State Moore

Design simple 3-state Moore machine

4-State Mealy

Implement 4-state Mealy machine

Sequence Detector

Create sequence detector for "1011"

Traffic Light

Design traffic light controller

Vending Machine

Implement vending machine FSM

Elevator Controller

Create elevator controller (3 floors)

UART Receiver FSM

Design UART receiver FSM

One-Hot FSM

Implement one-hot encoded FSM

Door Controller

Create automatic door controller

Washing Machine

Design washing machine controller

FSM Debug

Debug FSM with unreachable states

Mini-Project

Digital safe combination lock

Binary Counter

Design 4-bit binary up counter

Decade Counter

Implement decade (0-9) counter

Programmable Counter

Create programmable counter (loadable)

Digital Clock

Design 24-hour digital clock

Frequency Divider

Implement frequency divider

PWM Generator

Create PWM generator

Stopwatch

Design stopwatch with lap time

Real-Time Clock

Implement real-time clock (hours, minutes, seconds)

Timeout Timer

Create timeout timer with interrupt

Mini-Project

Kitchen timer with display

ROM Design

Design 16x8 ROM with constant data

Single Port RAM

Implement 32x16 single port RAM

Dual Port RAM

Create dual port RAM with separate clocks

FIFO with Flags

Design FIFO with almost full/empty flags

LIFO Stack

Implement LIFO (stack) memory

ROM from File

Create ROM from file using TEXTIO

Memory Controller

Design memory controller with wait states

CAM

Implement content addressable memory (CAM)

Byte Enable Memory

Create memory with byte enable

Mini-Project

Cache controller

Basic Testbench

Create simple testbench for AND gate

Clock Generation

Design testbench with clock generation

File Input

Implement testbench with file input

Self-Checking TB

Create self-checking testbench for adder

Random Stimulus

Design testbench with random stimulus

Coverage Collection

Implement testbench with coverage collection

FSM Testbench

Create testbench for FSM

Multiple Test Cases

Design testbench with multiple test cases

Assertions

Implement testbench with assertions

Memory TB

Create testbench for memory module

Constrained Random

Design constrained random testbench

Mini-Project

Complete test suite for ALU

4-Bit Adder

Create 4-bit adder from 1-bit full adders

8-Bit Multiplier

Design 8-bit multiplier using generate

Parameterized Register

Implement parameterized shift register

Hierarchical Processor

Create hierarchical processor design

Multi-Level Hierarchy

Design using multiple levels of hierarchy

Configurable ALU

Implement configurable ALU

Generic Components

Create generic components with parameters

Configuration Statements

Design using configuration statements

Chip-Level Design

Implement chip-level design with pads

Mini-Project

Complete system integration

UART Transmitter

Design UART transmitter

UART Receiver

Implement UART receiver

SPI Master

Create SPI master controller

I2C Slave

Design I2C slave device

7-Segment Display

Implement 7-segment display controller

VGA Sync

Create VGA sync generator

PS/2 Keyboard

Design PS/2 keyboard interface

Manchester Encoder

Implement Manchester encoder/decoder

I2S Audio

Create I2S audio interface

Mini-Project

UART loopback with FIFO

FIR Filter

Design 4-tap FIR filter

Moving Average

Implement moving average filter

MAC Unit

Create MAC unit for DSP

DDS

Design direct digital synthesizer (DDS)

CORDIC

Implement CORDIC algorithm (rotation mode)

Noise Generator

Create digital noise generator

LMS Filter

Design adaptive filter LMS algorithm

Mini-Project

Complete audio filter

Choose 3-4 Projects

Select and complete 3-4 capstone projects from the list below