Why process is used for sequential logic in VHDL - Visual Breakdown

Concept Flow - Why process is used for sequential logic

Start

↓

Enter process block

↓

Evaluate sequential statements in order

↓

Update signals/variables

↓

Wait for event or condition

↓

Repeat process when triggered

↓

End or loop back

The process block runs sequential statements step-by-step, waits for events, then repeats, enabling sequential logic in VHDL.

Execution Sample

VHDL

process(clk)
begin
  if rising_edge(clk) then
    q <= d;
  end if;
end process;

This process copies input d to output q on the rising edge of clock clk, showing sequential logic.

Execution Table

Step	Event	Condition	Action	Signal q
1	clk rising edge	rising_edge(clk) = true	q <= d (q updated)	q = d
2	clk falling edge	rising_edge(clk) = false	No action	q unchanged
3	clk rising edge	rising_edge(clk) = true	q <= d (q updated)	q = new d
4	clk falling edge	rising_edge(clk) = false	No action	q unchanged

💡 Process waits for next clk event to run again

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
q	undefined	d (at step 1)	new d (at step 3)	new d

Key Moments - 3 Insights

Why does the process run only on clock edges?

Because the process sensitivity list includes clk and the if condition checks rising_edge(clk), so actions happen only when clk rises (see execution_table steps 1 and 3).

Why is the assignment inside the process sequential?

Statements inside a process run one after another in order, unlike concurrent statements outside. Here, the if condition is checked first, then assignment happens if true (see concept_flow).

What happens on a clk falling edge?

The process runs but the if condition is false, so no signal update occurs (see execution_table steps 2 and 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of q after step 1?

A q is unchanged

B q equals d

C q is undefined

D q equals new d

💡 Hint

Check the 'Signal q' column in row for step 1 in execution_table

At which step does the process NOT update q?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for steps where 'Action' is 'No action' in execution_table

If the if condition was removed, how would the execution change?

A q never updates

B q updates only on rising edge

C q updates on every process run

D Process would not run

💡 Hint

Without the if, assignment happens every time process runs (see concept_flow)

Concept Snapshot

process(clk) begin
  if rising_edge(clk) then
    -- sequential statements run in order
  end if;
end process;

- Process groups sequential logic
- Runs on events in sensitivity list
- Enables clocked behavior in VHDL

Full Transcript

In VHDL, a process block is used to write sequential logic because it allows statements to run one after another inside it. The process runs when an event occurs on signals in its sensitivity list, like a clock edge. Inside the process, conditions like if rising_edge(clk) check for clock edges to update signals sequentially. This way, signals update only at specific times, mimicking real hardware behavior. The execution table shows how the signal q updates only on clock rising edges, and remains unchanged otherwise. This helps beginners see why processes are essential for sequential logic in VHDL.

Practice

1. Why is a process used in VHDL to describe sequential logic?

easy

A. Because it allows writing step-by-step instructions executed in order

B. Because it automatically creates combinational logic without clocks

C. Because it is used only for defining constants

D. Because it runs only once when the program starts

Solution

1. Step 1: Understand what sequential logic means

   Sequential logic requires instructions to run in a specific order, often controlled by a clock.

2. Step 2: Identify the role of a process in VHDL

   A process allows writing instructions that execute step-by-step when signals change, matching sequential logic needs.

3. Final Answer:

   Because it allows writing step-by-step instructions executed in order -> Option A

4. Quick Check:

   Sequential logic needs ordered steps = process [OK]

Hint: Processes run sequential code stepwise, perfect for clocks [OK]

Common Mistakes:

• Thinking processes run only once
• Confusing processes with combinational logic
• Believing processes define constants only

2. Which of the following is the correct way to start a process block in VHDL for sequential logic?

easy

A. process(clk);

B. process begin(clk)

C. process(clk) begin

D. process(clk) {

Solution

1. Step 1: Recall VHDL process syntax

   A process starts with the keyword process followed by a sensitivity list in parentheses, then begin.

2. Step 2: Check each option for correct syntax

   process(clk) begin matches the correct syntax: process(clk) begin. Others have wrong order, punctuation, or braces not used in VHDL.

3. Final Answer:

   process(clk) begin -> Option C

4. Quick Check:

   Process syntax = process(sensitivity) begin [OK]

Hint: Process starts with 'process(sensitivity) begin' exactly [OK]

Common Mistakes:

• Using semicolon after process header
• Placing sensitivity list after begin
• Using braces {} instead of begin/end

3. What will be the output of the following VHDL process when the clock rises?

process(clk)
begin
  if rising_edge(clk) then
    q <= d;
  end if;
end process;

medium

A. No signal updates because process lacks sensitivity list

B. The signal q updates to the value of d at the rising clock edge

C. The signal q updates continuously without clock

D. The signal d updates to the value of q at the rising clock edge

Solution

1. Step 1: Understand the process sensitivity and condition

   The process triggers on changes to clk. Inside, it checks for a rising edge on clk.

2. Step 2: Analyze the assignment inside the if statement

   When a rising edge occurs, q is assigned the current value of d. This means q updates only at clock rising edges.

3. Final Answer:

   The signal q updates to the value of d at the rising clock edge -> Option B

4. Quick Check:

   rising_edge(clk) triggers q <= d [OK]

Hint: rising_edge(clk) updates q from d only at clock rise [OK]

Common Mistakes:

• Confusing q and d assignment direction
• Thinking q updates continuously
• Ignoring sensitivity list effect

4. Identify the error in this VHDL process for sequential logic:

process(clk)
begin
  if clk = '1' then
    q <= d;
  end if;
end process;

medium

A. Missing rising_edge(clk) check causes incorrect behavior

B. Process sensitivity list is empty

C. Assignment operator <= is invalid inside process

D. Process must use 'wait' statement instead of sensitivity list

Solution

1. Step 1: Review the clock condition inside the process

   The condition if clk = '1' checks level, not edge, so it triggers whenever clk is high, not just on rising edge.

2. Step 2: Understand why rising_edge(clk) is needed

   Sequential logic requires triggering only on clock edges to avoid multiple assignments during clock high level.

3. Final Answer:

   Missing rising_edge(clk) check causes incorrect behavior -> Option A

4. Quick Check:

   Use rising_edge(clk) for correct sequential trigger [OK]

Hint: Use rising_edge(clk) to detect clock edges, not level [OK]

Common Mistakes:

• Using clk = '1' instead of rising_edge(clk)
• Leaving sensitivity list empty
• Confusing assignment operators

5. You want to design a flip-flop that sets output q to '1' on the rising edge of clk only if input set is '1'. Which process structure correctly implements this behavior?

hard

A. process(clk)
begin
q <= '1' when set = '1' else '0';
end process;

B. process(set)
begin
if set = '1' then
q <= '1';
end if;
end process;

C. process(clk)
begin
if clk = '1' then
q <= set;
end if;
end process;

D. process(clk)
begin
if rising_edge(clk) then
if set = '1' then
q <= '1';
end if;
end if;
end process;

Solution

1. Step 1: Identify the clock event trigger

   The flip-flop must update only on the rising edge of clk, so rising_edge(clk) is required.

2. Step 2: Check the condition for setting q

   Inside the clock check, if set = '1' sets q to '1'. This matches the requirement.

3. Step 3: Evaluate other options for correctness

   process(set) begin if set = '1' then q <= '1'; end if; end process; triggers on set changes, not clock edges. process(clk) begin if clk = '1' then q <= set; end if; end process; uses level check, not edge. process(clk) begin q <= '1' when set = '1' else '0'; end process; uses concurrent assignment inside process incorrectly.

4. Final Answer:

   process(clk) begin if rising_edge(clk) then if set = '1' then q <= '1'; end if; end if; end process; -> Option D

5. Quick Check:

   Use rising_edge(clk) and nested if for set condition [OK]

Hint: Nest set check inside rising_edge(clk) for correct flip-flop [OK]

Common Mistakes:

• Triggering on set signal instead of clock
• Using clk = '1' instead of rising_edge(clk)
• Incorrect assignment outside clock check