Sequential Logic

SR Latch (Gate-Level)

Build a cross-coupled NOR SR latch and reason about its set/reset/hold/invalid behavior.

D Flip-Flop with Asynchronous Reset

A D flip-flop that samples d on the rising clock edge, with an asynchronous active-high reset.

D Flip-Flop with Synchronous Reset and Enable

A D flip-flop with a synchronous, active-high reset that takes priority over a clock-enable input.

4-bit Up/Down Counter

A 4-bit counter that increments or decrements each clock, with a synchronous reset and free-running wraparound.

Decade (Mod-10) Counter

A synchronous-reset counter that cycles through 0-9 and wraps back to 0, rather than the full 4-bit range.

Universal Shift Register

A 4-bit register that can hold, parallel-load, shift left, or shift right, selected by a mode input.

Moore FSM: Non-Overlapping Sequence Detector (1011)

A Moore-style FSM that flags each non-overlapping occurrence of the bit pattern 1011 in a serial input stream.

Mealy FSM: Overlapping Sequence Detector (1011)

A Mealy-style FSM that flags every occurrence of the bit pattern 1011 in a serial input stream, including overlapping matches.

D Flip-Flop

Store one bit on each rising clock edge.

D Flip-Flops

Register an eight-bit vector on the rising clock edge.

DFF with Synchronous Reset

Add a synchronous active-high reset to a D flip-flop.

DFF with Configurable Reset Value

Reset a four-bit register to a specified nonzero value.

DFF with Byte Enable

Update a 32-bit register only when its write enable is asserted.

D Latch

Implement a level-sensitive D latch.

D Flip-Flop with Input Gate

Feed a gated data value into a rising-edge-triggered register.

Mux and DFF

Register the selected one of two input bytes.

Detect a Rising Edge

Convert a sampled low-to-high transition into a one-cycle pulse.

Detect Both Edges

Generate a one-cycle pulse for either sampled signal transition.

Edge Capture Register

Capture data once on a rising capture event and hold the result.

Dual-Edge Register

Capture data on both the rising and falling clock transitions.

Counter 1 to 12

Build a clocked counter cycling through values 1 to 12.

Counter 1000

Count modulo 1000 with a synchronous reset.

Slow Decade Counter

Use a slower enable pulse to advance a decade counter.

4-Digit Decimal Counter

Count from 0000 through 9999 and present the value as packed BCD.

12-Hour Clock

Advance hours, minutes, and seconds in a 12-hour clock.

4-Bit Shift Register

Shift one serial input bit into a four-bit register each cycle.

Left/Right Rotator

Rotate an eight-bit value left or right by one bit per cycle.

Arithmetic Shift by 1 or 8

Register a signed value after an arithmetic right shift of one or eight bits.

5-Bit LFSR

Advance a five-bit linear-feedback shift register from a fixed nonzero seed.

3-Bit LFSR

Build a three-bit linear-feedback shift register.

32-Bit LFSR

Advance a 32-bit LFSR using four feedback taps.

Enabled Shift Register

Shift a serial input into a register only on enabled cycles.

Bidirectional Shift Register

Shift an eight-bit register in either direction with a serial input.

3-Input Lookup Table

Use three logic inputs as the address of an eight-bit lookup table.

Simple FSM 1 (Asynchronous Reset)

Implement a two-state Moore machine with an active-high asynchronous reset.

Simple FSM 1 (Synchronous Reset)

Implement a two-state Moore machine with synchronous reset.

Simple FSM 2 (Asynchronous Reset)

Toggle between two states on input events with an asynchronous reset.

Simple FSM 2 (Synchronous Reset)

Toggle between two states on input events with a synchronous reset.

Simple One-Hot State Transitions

Cycle a three-state machine through one-hot encoded states.

Design a Moore FSM

Build a Moore machine that recognizes two consecutive sampled ones.

Simple FSM 3 (Asynchronous Reset)

Build a three-state counter-style FSM with asynchronous reset.

Simple FSM 3 (Synchronous Reset)

Build a three-state counter-style FSM with synchronous reset.

Lemmings 1: Walk

Create the walking outputs for a simple two-direction character controller.

Lemmings 2: Bump

Turn the character around when it bumps into either wall.

Lemmings 3: Fall

Track whether the character is walking or falling based on ground support.

Lemmings 4: Bump and Fall

Combine wall collisions and missing ground in a small character controller.

Simple State Transitions 3

Implement a three-state transition graph driven by a serial control input.

One-Hot FSM

Implement a four-state ring machine using one-hot state encoding.

Sequence Recognition

Detect a five-bit pattern in a serial stream.

Serial Two's Complementer (Mealy)

Convert a least-significant-bit-first serial word to its two's complement.

Serial Two's Complementer (Moore)

Build a registered serial two's-complement conversion machine.

Serial Receiver

Receive a start bit, eight data bits, and a stop bit using a sample enable.

Serial Receiver and Datapath

Coordinate serial frame timing and byte capture in a receiver.

Serial Receiver with Parity Checking

Check odd parity while receiving serial data frames.

Q8: Design a Mealy FSM

Recognize an overlapping 1101 pattern with an output pulse on its final input bit.

Q3a: FSM State Register

Build a three-state request, busy, and done controller.

Q3b: FSM Output Logic

Decode status outputs from a two-bit state encoding.

Q3c: FSM Next-State Logic

Implement the combinational next-state table for a request controller.

Q6: Complete an FSM

Complete a Moore FSM that reports after two consecutive input samples.

Q6b: FSM Next-State Logic

Compute next-state bits from encoded state and current input.

Q6c: One-Hot Next-State Logic

Derive next-state equations for a one-hot input recognizer.

Q2a: FSM Controller

Build a two-state start and finish controller.

Q2b: One-Hot FSM Equations

Write next-state equations for a one-hot start/finish controller.

Four-Bit Binary Counter

Build a four-bit modulo-16 binary counter.

Decade Counter with Enable

Add a count enable to a modulo-10 counter.

Rule 90 Cellular Automaton

Update a one-dimensional cellular automaton using Rule 90.

Rule 110 Cellular Automaton

Implement a one-dimensional cellular automaton with Rule 110.

Conway's Game of Life 16x16

Compute a 16 by 16 Game of Life generation with dead cells beyond the boundary.

Q2a: Another FSM

Detect a run of three consecutive high input samples.

Q2b: Another One-Hot FSM

Represent the progress of a run-length detector using one-hot state bits.

Mux and DFF with Enable

Combine a data mux and an enabled register.

DFFs and Gates

Compute a bitwise gate function and register its result.

Create Circuit from Truth Table

Implement a sequential transition table as a clocked circuit.

Decade Counter Again

Add a synchronous load path to a decade counter.

PS/2 Packet Parser

Recognize three-byte PS/2 packets in a continuous byte stream.

PS/2 Packet Parser and 3-Byte Datapath

Find three-byte PS/2 message boundaries and capture each completed packet.