Yao Zheng@UHM

Take-Home Midterm Exam: Combinational Logic and Advanced Verilog

Fri, 27 Feb 2026 00:00:00 +0000

Scope: Number systems, Boolean algebra, multi-level optimization, hazards, arithmetic circuits, encoder/decoder/PLA/ROM, scalable MUX structures, parameterized Verilog
Duration: 48 hours

Instructions

Attempt all questions. Show complete derivations and clearly state assumptions.
Provide commented, synthesizable Verilog and a self-checking testbench where requested.
Include timing and area reasoning (gate depth, gate count, or asymptotic arguments).
No collaboration. Cite any references consulted.

Part A — Multiple Choice (10 × 3 = 30 pts)

Select the best answer.

Q1. Which transformation always preserves functional equivalence but may reduce logic depth?
a) Converting SOP to canonical SOP
b) Algebraic factoring
c) Expanding minterms
d) Adding consensus terms

Q2. A static-1 hazard occurs when:
a) Output should remain 1 but temporarily glitches to 0
b) Output should remain 0 but glitches to 1
c) Clock frequency is too high
d) Fan-out exceeds limit

Q3. For an N-bit ripple carry adder, worst-case delay is proportional to:
a) log₂N
b) N
c) √N
d) constant

Q4. Which gate set is functionally complete?
a) {XOR}
b) {AND, OR}
c) {NAND}
d) {XNOR}

Q5. In synthesizable combinational Verilog, the safest template is:
a) always @(posedge clk)
b) always @(*)
c) initial begin
d) #5 y = a & b;

Q6. A 16→1 multiplexer implemented as a balanced tree of 2→1 MUXes has depth:
a) 4
b) 8
c) 15
d) 16

Q7. ROM implementation size grows:
a) Linearly with inputs
b) Quadratically with inputs
c) Exponentially with inputs
d) Logarithmically with inputs

Q8. The consensus term of $A'B + AC$ is:
a) BC
b) B’C
c) AB
d) A’C

Q9. Which operator performs bitwise XNOR in Verilog?
a) ~^
b) ^~
c) Both
d) None

Q10. A balanced adder tree reduces delay complexity from O(N) to:
a) O(1)
b) O(log N)
c) O(N²)
d) O(N log N)

Part B — Design & Analysis (10 × 7 = 70 pts)

Problem 1 — Multi-Level Optimization and Cost Analysis
Given
$F(A,B,C,D,E)=\Sigma(1,3,4,7,11,15,16,18,19,23,27,31)$

a) Write canonical SOP and POS.
b) Minimize using K-map.
c) Factor to reduce depth.
d) Compare literal count and logic depth between two-level and factored implementations.

Problem 2 — Hazard Analysis
Given
$F(A,B,C)=A'B+AC$

a) Identify static hazards and show transition causing glitch.
b) Add minimal consensus terms to eliminate hazard.
c) Estimate glitch width assuming uniform 1 ns gate delay.

Problem 3 — NAND-Only Realization
a) Prove NAND is functionally complete.
b) Implement $F(A,B,C)=AB+A'C$ using only 2-input NAND gates.
c) Count gates and compute logic depth.

Problem 4 — 32→5 Priority Encoder
a) Define truth table with D31 highest priority and valid.
b) Build hierarchically from 4→2 encoders.
c) Structural Verilog implementation.
d) Estimate worst-case delay if each 4→2 block delay = 2 ns.

Problem 5 — Shared PLA vs ROM Implementation
Given
$F_1=\Sigma(0,2,5,8,10,13)$
$F_2=\Sigma(1,3,6,9,14,15)$

a) Minimize jointly and identify shared product terms.
b) Draw PLA matrix (AND plane and OR plane).
c) Determine memory size for equivalent 16×2 ROM.
d) Compare area tradeoffs.

Problem 6 — Balanced Adder Tree
Sum eight 12-bit numbers.

a) Serial ripple accumulation: compute depth.
b) Balanced tree: draw structure and compute depth.
c) Determine required output width.

Problem 7 — Parameterized ALU

Operations: ADD, SUB, AND, OR, XOR, CMP(==,>,<). Width parameter N.

a) Write synthesizable Verilog using unique case.
b) Implement comparison efficiently (no redundant subtraction).
c) Provide self-checking randomized testbench.
d) Compare resource growth for N=8 and N=32.

Problem 8 — Recursive MUX Tree

a) Implement a parameterized mux_tree #(N=16,W=8) using generate.
b) Ensure balanced structure.
c) Derive logic depth as function of N.
d) Provide synthesizable code.

Problem 9 — Gray/Binary Converters

a) Derive 4-bit Gray→Binary and Binary→Gray equations.
b) Prove composition correctness.
c) Provide parameterized Verilog and exhaustive testbench.

Problem 10 — Power-of-Two Detector

Design combinational circuit to detect if a 16-bit input is a power of two.

a) Derive minimal Boolean condition.
b) Implement structural and behavioral Verilog versions.
c) Compare gate complexity.

Online Verilog Simulation Guide

Tue, 30 Sep 2025 00:00:00 +0000

If you don’t have a local Verilog simulator (e.g., Icarus Verilog or Vivado XSim) installed, you can run this lab directly in your web browser using free online tools such as EDA Playground or Makerchip. These platforms allow you to paste your Verilog source and testbench, simulate, and view console outputs or waveforms.

🧩 Option 1 — Using EDA Playground (Recommended)

Website:

Steps

Open the website and click “Create New Playground”.
In the left code pane, paste your design source file:
- e.g., src/reg_multifunc.v or src/regfile_2r1w.v
In the right code pane, paste the corresponding testbench:
- e.g., tb/tb_reg_multifunc.v or tb/tb_regfile_2r1w.v
In the Tools & Simulators panel:
- Set Language to Verilog 2001 or SystemVerilog 2012
- Choose Simulator: Icarus Verilog (vvp)
- Uncheck “Enable Design for UVM” if it appears
Click Run ▶️ at the top.
Watch the console output:
- You should see [PASS] and [FAIL] messages from the testbench.
- All “PASS” messages indicate correct behavior.

Click Share → Save & Share Link.
Include the generated link in your lab report or submission.

⚙️ Option 2 — Using Makerchip (Advanced Visualizer)

Website:

Steps

Go to the Makerchip homepage → click “Start Designing”.
Paste both your design and testbench codes into the editor.
Click Build & Run.
View the console log for pass/fail messages and use the waveform viewer for debugging.
Makerchip automatically recognizes any module ending with _tb as the top-level testbench.

✅ Expected Output

A successful run will produce console logs like:

[PASS] LOAD: q=A5 @ t=10
[PASS] SHL: q=4A @ t=20
[PASS] SHR: q=25 @ t=30
tb_reg_multifunc completed OK

If something fails, you’ll see:

[FAIL] SAR from 0x80: got 40 expected C0 @ t=70

Fix your RTL code and re-run the simulation.

💡 Tips

Use Ctrl + Enter (EDA Playground) or Ctrl + R (Makerchip) to rerun quickly.
To view waveforms in EDA Playground:
- Check “Enable VCD dump” under Run Options, then open the waveform viewer.
Always verify reset behavior and edge timing (posedge clock updates).
Record your simulation logs and include screenshots in your report.

End of Online Simulation Guide

Take-Home Midterm Exam: Combinational Circuits and Verilog

Tue, 30 Sep 2025 00:00:00 +0000

Scope: Number systems, Boolean algebra, combinational design, optimization, hazards, MUX/decoder/PLA, Verilog HDL
Duration: 48 hours
Instructions

Attempt all questions. Show reasoning, derivations, and clearly state assumptions.
Provide commented, synthesizable Verilog and a self‑checking testbench where requested.
Include brief timing/area reasoning (big‑O style or gate/count estimates).
No collaboration. Cite any external references you consulted.

Part A — Multiple Choice (10 × 3 = 30 pts)

Select the best answer.

Q1. Which of the following is not a characteristic of combinational logic?
a) Output depends only on present inputs
b) No feedback paths
c) May exhibit propagation delay
d) Requires clock edge to update

Q2. Which Verilog statement is not synthesizable in general FPGA/ASIC tools?
a) assign y = a & b;
b) always @(*) y = a | b;
c) initial y = 0;
d) case(sel) y = d0; endcase

Q3. The critical path delay in a ripple‑carry adder grows:
a) Linearly with bit‑width
b) Logarithmically with bit‑width
c) Constant with bit‑width
d) Randomly with input values

Q4. Which gate set is not functionally complete?
a) {NAND}
b) {NOR}
c) {AND, OR}
d) {XOR, AND}

Q5. In Verilog, reg and wire differ because:
a) reg can only be used in sequential circuits
b) wire holds values without drivers
c) reg stores a value until reassigned; wire reflects drivers continuously
d) wire is faster than reg

Q6. A 32‑to‑1 multiplexer can be implemented most efficiently using:
a) One 32‑input gate
b) A tree of 2‑to‑1 multiplexers
c) A PLA
d) Multiple XOR gates

Q7. Which optimization reduces logic depth the most?
a) Gate duplication
b) Pipelining
c) Karnaugh map simplification
d) Multi‑level factoring

Q8. Which Verilog operator performs bitwise XNOR?
a) ~^
b) ^~
c) Both a and b
d) None

Q9. Main limitation of ROM implementation for logic functions is:
a) Too slow for combinational circuits
b) Size grows exponentially with #inputs
c) Can only implement sequential logic
d) Does not support initialization

Q10. If two drivers assign conflicting values to a Verilog wire:
a) Last assignment wins
b) Wire holds 0
c) Wire holds 1
d) Wire becomes unknown (x)

Part B — Design & Analysis (10 × 7 = 70 pts)

Problem 1 — Functional Completeness (NAND‑Only)
a) Prove {NAND} is functionally complete (construct NOT, AND, OR).
b) Implement $F(A,B,C)=\Sigma(0,2,5,7)$ using NAND‑only. Show product terms and sharing.
c) Provide synthesizable Verilog for the NAND‑only implementation and compare gate count v.s. SOP using AND/OR/NOT.

Problem 2 — Arithmetic: Carry‑Save Adder (CSA)
a) Derive a 3‑operand (A,B,C) 4‑bit CSA producing (Sum, Carry).
b) Compare worst‑case delay against 2‑operand ripple add repeated twice.
c) Provide synthesizable Verilog for a parameterized CSA.

Problem 3 — 16→4 Priority Encoder
a) Specify truth table/priority convention (D$15$ highest). Include valid.
b) Build hierarchically from 4×(4→2) encoders + 4→2 encoder.
c) Structural Verilog with module instances.

Problem 4 — PLA and ROM Implementations
Given:
$F_1(A,B,C,D)=\Sigma(0,2,5,8,12),\quad F_2(A,B,C,D)=\Sigma(1,3,4,9,15)$
a) Derive minimized SOPs with shared product terms for a PLA.
b) Sketch a PLA with labeled shared products.
c) Show 16×2 ROM mapping (address=A B C D).
d) Provide generic Verilog: (i) PLA using and of literals + or planes; (ii) ROM using case or packed localparam.

Problem 5 — Scalable MUX
a) Build a 16→1 MUX using only 2→1 MUXes (balanced tree).
b) Count 2→1 cells and tree depth.
c) Write a parameterized recursive Verilog module mux_tree #(N=16,W=1).

Problem 6 — Comparator (4‑bit)
a) Derive equations for GT, EQ, LT.
b) Show hierarchical design from chained 1‑bit comparators.
c) Provide synthesizable Verilog and a constrained‑random testbench.

Problem 7 — Gray/Binary Converters (4‑bit)
a) Derive equations: Gray→Bin and Bin→Gray.
b) Compose them in loopback to prove Bin == g2b(b2g(Bin)).
c) Parameterized Verilog + exhaustive testbench.

Problem 8 — Digital Lock
Opens for inputs 110101 or 011110.
a) Minimize SOP.
b) Implement via decoder + OR.
c) Verilog (behavioral and structural).
d) Short note: why loose “don’t care” policies are risky for security.

Problem 9 — Parameterized ALU
Ops: ADD, SUB, AND, OR, XOR, CMP(==,>,<). Width parameter N.
a) Synthesizable Verilog with unique case.
b) Self‑checking randomized testbench (seeded).
c) Brief resource discussion for N=8 vs N=32 (qualitative + simple count).

Problem 10 — Adder Tree
Sum eight 16‑bit numbers with minimal depth.
a) Draw balanced adder tree and give depth.
b) Compare with serial accumulation.
c) Parameterized Verilog using generate and a reduction tree.

Take-Home Midterm Exam Solution: Combinational Circuits and Verilog

Tue, 30 Sep 2025 00:00:00 +0000

Scope: Number systems, Boolean algebra, combinational design, optimization, hazards, MUX/decoder/PLA, Verilog HDL
Duration: 48 hours
Instructions

Attempt all questions. Show reasoning, derivations, and clearly state assumptions.
Provide commented, synthesizable Verilog and a self‑checking testbench where requested.
Include brief timing/area reasoning (big‑O style or gate/count estimates).
No collaboration. Cite any external references you consulted.

Part A — Multiple Choice (Keys)

Part B — Design & Analysis

Problem 1 — Functional Completeness (NAND‑Only)

a) Constructions

NOT: $ \neg A = A\,\text{NAND}\,A $
AND: $ A\land B = (A\,\text{NAND}\,B)\,\text{NAND}\,(A\,\text{NAND}\,B) $
OR (by De Morgan): $ A\lor B = (\neg A)\,\text{NAND}\,(\neg B) = (A\,\text{NAND}\,A)\,\text{NAND}\,(B\,\text{NAND}\,B) $

b) Minimal SOP for $F=\Sigma(0,2,5,7)$ → $F = A' C' + A C$. (Covers 0,2 and 5,7.)

c) NAND‑only Verilog

module F_nand_only(input A,B,C, output F);
 wire nA, nC, t1, t2; // B not used after minimization
 nand (nA, A, A);
 nand (nC, C, C);
 wire nA_and_nC, AbarCbar;
 nand (nA_and_nC, nA, nC);
 nand (AbarCbar, nA_and_nC, nA_and_nC);
 wire AandC_n, AandC;
 nand (AandC_n, A, C);
 nand (AandC, AandC_n, AandC_n);
 wire nAbarCbar, nAandC;
 nand (nAbarCbar, AbarCbar, AbarCbar);
 nand (nAandC, AandC, AandC);
 nand (F, nAbarCbar, nAandC);
endmodule

Gate count ~7 NANDs.

Problem 2 — CSA

Sum bits: $s_i = a_i \oplus b_i \oplus c_i$, carry bits: $k_i=(a_ib_i)+(b_ic_i)+(a_ic_i)$. Final result = s + (k<<1) via one CPA. Delay better than two ripples.

module csa3 #(parameter N=4)(input [N-1:0] a,b,c,
 output [N-1:0] s, output [N-1:0] k);
 genvar i;
 generate for(i=0;i<N;i=i+1) begin: g
 assign s[i]=a[i]^b[i]^c[i];
 assign k[i]=(a[i]&b[i])|(b[i]&c[i])|(a[i]&c[i]);
 end endgenerate
endmodule

Problem 3 — 16→4 Priority Encoder

See hierarchical structural solution:

module pe4(input [3:0] d, output valid, output [1:0] y);
 assign valid = |d;
 assign y = !valid ? 2'b00 :
 d[3] ? 2'b11 :
 d[2] ? 2'b10 :
 d[1] ? 2'b01 : 2'b00;
endmodule

module pe16(input [15:0] d, output valid, output [3:0] y);
 wire [3:0] v; wire [1:0] y0,y1,y2,y3;
 pe4 u0(d[3:0], v[0], y0);
 pe4 u1(d[7:4], v[1], y1);
 pe4 u2(d[11:8], v[2], y2);
 pe4 u3(d[15:12], v[3], y3);
 pe4 uT(v, valid, y[3:2]);
 reg [1:0] low;
 always @(*) case(y[3:2])
 2'd0: low=y0; 2'd1: low=y1; 2'd2: low=y2; default: low=y3;
 endcase
 assign y[1:0]=low;
endmodule

Problem 4 — PLA & ROM

One valid sharing (not unique):

$F_1 = A'B' + C'D' + AD'$
$F_2 = A'CD + AB' + B'D$

PLA code shown (shared terms). ROM mapping by full truth table is acceptable (example mapping provided in handout).

Problem 5 — Scalable MUX

Uses $N-1$ 2→1 cells; for 16→1, 15 cells, depth 4. Recursive mux_tree given in handout; students verify widths and $clog2 correctness with synthesis/sim.

Problem 6 — Comparator

Equations:
EQ = Π_i ~(Ai ^ Bi)
GT = g3 | (eq3&g2) | (eq3&eq2&g1) | (eq3&eq2&eq1&g0)
LT mirror. Verilog in handout accepted.

Problem 7 — Gray/Binary

Gray→Bin prefix XOR; Bin→Gray adjacent XOR. Parameterized modules and exhaustive TB as shown.

Problem 8 — Lock

assign open = (in==6'b110101) || (in==6'b011110);
Security note: define all unspecified inputs as closed (0); avoid ‘x’ in synthesizable paths.

Problem 9 — ALU

Reference ALU with unique case. TB randomizes A,B and compares against high‑level model. Resource: adder dominates; scaling roughly linear with N for ripple implementations.

Problem 10 — Adder Tree

Balanced tree depth 3 for 8 inputs; serial is 7. Example parameterized module provided; students may generalize to 2^k inputs or pad to nearest power of two.

module sum8 #(parameter W=16)(input [W-1:0] a0,a1,a2,a3,a4,a5,a6,a7,
 output [W+3:0] sum);
 wire [W:0] s0=a0+a1, s1=a2+a3, s2=a4+a5, s3=a6+a7;
 wire [W+1:0] t0=s0+s1, t1=s2+s3;
 assign sum = t0 + t1;
endmodule

Take-Home Midterm Exam: Sequential Circuits and Verilog

Tue, 28 Oct 2025 00:00:00 +0000

Scope: Sequential logic, finite state machines, registers, counters, with Verilog modeling
Duration: 48 hours
Instructions

Attempt all questions. Show reasoning, derivations, and clearly state assumptions.
Provide commented, synthesizable Verilog and a self‑checking testbench where requested.
Include brief timing/area reasoning (big‑O style or gate/count estimates).
No collaboration. Cite any external references you consulted.
Tutorial of Online tools for Verilog simulation can be found .

Part A — Multiple Choice (10 × 3 pts = 30 pts)

Select the best answer.

Q1. A positive-level D latch is best described as:

A. Sampling on rising edges only
B. Transparent when clock=1 and opaque when clock=0
C. Triggered on both edges
D. Metastability-free by design

Q2. The parameter that primarily limits f_max is:

A. Hold time
B. Recovery time
C. t_clk-q + t_comb + t_setup
D. Clock duty cycle

Q3. A T flip-flop divides the clock by two because it:

A. Filters every other edge by delay
B. Toggles its output at each active edge
C. Samples input twice per cycle
D. Has J=0, K=1

Q4. A ripple counter differs from a synchronous counter because:

A. It uses fewer flip-flops
B. Its stages are clocked by preceding stage outputs
C. It is immune to propagation delay
D. It is always faster

Q5. In a Moore machine, outputs depend on:

A. Current input only
B. Current state only
C. Next state only
D. Current and previous inputs

Q6. In a Mealy machine:

A. Outputs change only at clock edges
B. Outputs depend on state and inputs
C. It needs more states than Moore always
D. It cannot be coded in Verilog

Q7. A 4-bit shift register with serial input 1101 after four clocks contains (MSB..LSB):

A. 1011
B. 1101
C. 0110
D. 1110

Q8. A hold-time violation can be mitigated by:

A. Adding delay to data path
B. Increasing clock frequency
C. Reducing setup time
D. Removing all registers

Q9. One-hot encoding of an N-state FSM uses:

A. log2(N) flip-flops
B. N flip-flops
C. N-1 flip-flops
D. 2N flip-flops

Q10. Pipeline registers primarily:

A. Reduce combinational delay per stage
B. Store only final outputs
C. Remove all hazards
D. Reduce setup time of FFs

Part B — Design & Analysis (10 × 7 = 70 pts)

For each problem, complete the Verilog template in the and verify using the provided self‑checking testbench. Name your top‑level modules exactly as specified.

Files provided (in the questions zip):

Templates: *.v (one per problem)
Testbenches: tb_*.v (one per problem)
Timescale: 1ns/1ps

Problems:

Problem 1 — Synchronizer + Edge Detect (sync_edge)
Synchronize asynchronous btn_async into clk with a two‑FF synchronizer; output btn_sync level and one‑cycle btn_pulse on rising edges. Active‑low rst_n.

Problem 2 — Dual‑Edge Capture (ddr_reg)
Capture D on posedge into Q_pos and on negedge into Q_neg. Active‑low rst_n.

Problem 3 — Mealy Sequence Detector “11010” (seq_11010_mealy)
Detect the overlapping pattern and assert Z on the final bit. Use a minimal FSM.

Problem 4 — Mod‑6 Up/Down Counter with Enable (mod6_counter)
3‑bit counter over 0..5. En gates counting; Dir=1 up, 0 down. Synchronous reset to 0.

Problem 5 — 4×4 Serial Multiplier Controller (mul4_ctrl)
Shift‑add controller with signals LdA,LdB,ClrP,Add,Shift,Done. Start with start=1. Iterate 4 times.

Problem 6 — 2‑Stage Pipeline (A+B)*C with Valid/Ready (pipe_add_mul)
Implement a two‑stage pipeline (add then multiply) with back‑pressure (in_valid/in_ready, out_valid/out_ready).

Problem 7 — CDC Bridge 1 MHz → 100 MHz (cdc_bridge)
Use a req/ack handshake and 2FF synchronizers both directions to transfer an 8‑bit word reliably.

Problem 8 — Moore FSM with Registered Output (moore_safe)
Provide both combinational output Zc and registered Zr (hazard‑free).

Problem 9 — Sequential 4‑bit ALU (seq_alu4)
Opcode: 00=ADD, 01=AND, 10=XOR, 11=SHL. Registered outputs Y and Cout with synchronous reset.

Problem 10 — Traffic Lights with Pedestrian Preempt (traffic_ped)
Main: G×3, Y×1; Side: G×2, Y×1. Insert WALK×4 at a safe point when ped_req=1; resume correctly.

Deliverables:

PDF with answers to Section A and brief design notes for Section B.
Verilog sources for all 10 designs.
Simulation logs/screenshots demonstrating passing testbenches.

Take-Home Midterm Exam: Sequential Circuits and Verilog

Tue, 28 Oct 2025 00:00:00 +0000

Scope: Sequential logic, finite state machines, registers, counters, with Verilog modeling
Duration: 48 hours
Instructions

Attempt all questions. Show reasoning, derivations, and clearly state assumptions.
Provide commented, synthesizable Verilog and a self‑checking testbench where requested.
Include brief timing/area reasoning (big‑O style or gate/count estimates).
No collaboration. Cite any external references you consulted.
Tutorial of Online tools for Verilog simulation can be found .

Part A — Multiple Choice (10 × 3 pts = 30 pts)

Select the best answer.

Part A — Multiple Choice (Keys)

Part A (MP) — Multiple Choice (Keys)

Part B — Design & Analysis (10 × 7 = 70 pts)

Download solutions .

Files provided (in the questions zip):

Templates: *.v (one per problem)
Testbenches: tb_*.v (one per problem)
Timescale: 1ns/1ps