Skip to content
Learnings · VHDL · Labs

VHDL labs.

Strongly-typed HDL exercises that walk from your first entity/architecture pair up to reusable packages and parameterised IP.

0of 7 labs live5 phases · grouped by difficulty
Lab Philosophy

Small, working pieces of silicon-grade code.

VHDL rewards engineers who respect its type system. These labs make that discipline pay off — each one ends with synthesizable RTL plus a deliberate observation about contract, conversion, or generic reuse.

Lab Roadmap

5-phase progression.

  1. 01Foundations1
  2. 02Modeling2
  3. 03Sequential2
  4. 04Control1
  5. 05Reuse1

All Labs

Grouped by difficulty

Foundation

4 labs
  1. Lab 01

    Entity / Architecture Basics Lab

    Model a simple half-adder using strict entity/architecture separation and instantiate it inside a test wrapper.

    Skills practiced
    • Entity declaration
    • Architecture body
    • Port mapping
    Deliverable
    A reusable half-adder + its testbench plus a one-paragraph note on contract-vs-implementation.
    FoundationPlannedFoundations
  2. Lab 02

    Combinational Logic Lab

    Build a 4-bit ALU slice with `when/else` and `with/select` and contrast both forms.

    Skills practiced
    • Concurrent statements
    • Conditional assignment
    • Selected signal assignment
    Deliverable
    Two architectures for the same entity plus a waveform proving equivalence.
    FoundationPlannedModeling
  3. Lab 03

    Process Sensitivity Lab

    Demonstrate why an incomplete sensitivity list silently desynchronises simulation from synthesis.

    Skills practiced
    • Process statement
    • Sensitivity lists
    • VHDL-2008 `all`
    Deliverable
    A buggy vs fixed pair of processes with a write-up of the synthesis mismatch.
    FoundationPlannedModeling
  4. Lab 04

    D Flip-Flop Lab

    Model a D flip-flop with async reset and prove it infers a single FF in synthesis.

    Skills practiced
    • Clocked process
    • rising_edge()
    • Reset modeling
    Deliverable
    A clocked entity plus its synthesis schematic showing exactly one FF inferred.
    FoundationPlannedSequential

Intermediate

2 labs
  1. Lab 05

    Counter Design Lab

    Parameterise a counter using a `generic` and instantiate three widths from one entity.

    Skills practiced
    • Generics
    • Integer ranges
    • Unsigned arithmetic
    Deliverable
    A generic-parameterised counter with three sized instances and shared testbench.
    IntermediatePlannedSequential
  2. Lab 06

    FSM Design Lab

    Model a Moore FSM using an enumerated state type and prove the state graph is bisimilar to the spec.

    Skills practiced
    • Type-safe states
    • Two-process FSM style
    • State coverage
    Deliverable
    An enumerated-state FSM plus a state-transition coverage report.
    IntermediatePlannedControl

Advanced

1 lab
  1. Lab 07

    Package & Record Usage Lab

    Bundle a bus interface into a `record` inside a `package` and reuse it across master, slave and monitor.

    Skills practiced
    • Packages
    • Records
    • Library reuse
    Deliverable
    A package providing one record type referenced by three components, with shared compile order.
    AdvancedPlannedReuse