Function and procedure in packages in VHDL

Introduction

Functions and procedures in packages help organize reusable code in VHDL. They make designs cleaner and easier to manage.

When you want to reuse a calculation or operation in multiple places.

When you want to group related helper code together for clarity.

When you want to separate design logic from implementation details.

When you want to share common code across multiple VHDL files.

When you want to improve readability by naming complex operations.

Syntax

VHDL

package package_name is
  -- Function declaration
  function function_name (parameters) return return_type;

  -- Procedure declaration
  procedure procedure_name (parameters);
end package package_name;

package body package_name is
  -- Function definition
  function function_name (parameters) return return_type is
  begin
    -- function code
  end function function_name;

  -- Procedure definition
  procedure procedure_name (parameters) is
  begin
    -- procedure code
  end procedure procedure_name;
end package body package_name;

Functions return a value and can be used in expressions.

Procedures do not return a value but can modify parameters.

Examples

This package declares a function add that returns the sum and a procedure display_sum that shows the sum.

VHDL

package math_pkg is
  function add(a : integer; b : integer) return integer;
  procedure display_sum(a : integer; b : integer);
end package math_pkg;

This package body defines the function and procedure declared earlier.

VHDL

package body math_pkg is
  function add(a : integer; b : integer) return integer is
  begin
    return a + b;
  end function add;

  procedure display_sum(a : integer; b : integer) is
  begin
    report "Sum is " & integer'image(a + b);
  end procedure display_sum;
end package body math_pkg;

Sample Program

This program defines a package with a function and procedure, then uses them in a test entity to multiply two numbers and display the results.

VHDL

library ieee;
use ieee.std_logic_1164.all;

package math_pkg is
  function multiply(a : integer; b : integer) return integer;
  procedure show_product(a : integer; b : integer);
end package math_pkg;

package body math_pkg is
  function multiply(a : integer; b : integer) return integer is
  begin
    return a * b;
  end function multiply;

  procedure show_product(a : integer; b : integer) is
  begin
    report "Product is " & integer'image(a * b);
  end procedure show_product;
end package body math_pkg;

entity test_pkg is
end entity test_pkg;

architecture behavior of test_pkg is
begin
  process
    variable result : integer;
  begin
    result := multiply(4, 5);
    report "Result from function: " & integer'image(result);
    show_product(4, 5);
    wait;
  end process;
end architecture behavior;

Important Notes

Functions must return a value using the return statement.

Procedures can have in, out, or inout parameters.

Use packages to keep your VHDL code organized and reusable.

Summary

Functions return values and can be used in expressions.

Procedures perform actions but do not return values.

Packages group functions and procedures for reuse and clarity.

Practice

1. What is the main difference between a function and a procedure in a VHDL package?

easy

A. A procedure returns a value, while a function does not.

B. A function returns a value, while a procedure does not.

C. Both return values but differ in syntax.

D. Neither returns a value; both perform actions only.

Solution

1. Step 1: Understand function behavior

   A function in VHDL always returns a value and can be used in expressions.

2. Step 2: Understand procedure behavior

   A procedure performs actions but does not return a value directly.

3. Final Answer:

   A function returns a value, while a procedure does not. -> Option B

4. Quick Check:

   Function returns value = B [OK]

Hint: Functions return values; procedures do not [OK]

Common Mistakes:

• Thinking procedures return values
• Confusing syntax differences with return behavior
• Assuming both can be used in expressions

2. Which of the following is the correct way to declare a function inside a VHDL package?

easy

A. function add(a : integer; b : integer) return integer;

B. procedure add(a : integer; b : integer) return integer;

C. function add(a, b : integer);

D. procedure add(a : integer; b : integer);

Solution

1. Step 1: Check function declaration syntax

   A function must specify parameters with types and a return type using return.

2. Step 2: Validate options

   function add(a : integer; b : integer) return integer; correctly declares a function with parameters and return type. Options A and B are procedures, and C misses return type.

3. Final Answer:

   function add(a : integer; b : integer) return integer; -> Option A

4. Quick Check:

   Function declaration needs return type = D [OK]

Hint: Functions must declare return type explicitly [OK]

Common Mistakes:

• Using 'procedure' keyword for functions
• Omitting return type in function declaration
• Adding return type to procedures

3. Given the following package body code, what is the output of calling result := math_pkg.multiply(3, 4);?

package body math_pkg is
  function multiply(x : integer; y : integer) return integer is
  begin
    return x * y;
  end multiply;
end math_pkg;

medium

A. 12

B. 7

C. Error: function not found

D. 0

Solution

1. Step 1: Understand function multiply

   The function returns the product of x and y, so multiply(3,4) returns 3*4 = 12.

2. Step 2: Confirm no errors

   The function is correctly declared and defined in the package body, so no errors occur.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply returns product of inputs [OK]

Common Mistakes:

• Confusing addition with multiplication
• Assuming function is undefined
• Expecting procedure behavior

4. Identify the error in this package declaration:

package util_pkg is
  procedure display_message(msg : in string);
  function get_length(msg : string) return integer;
end util_pkg;

medium

A. Package missing body keyword.

B. Procedure missing return type.

C. Function parameter missing mode (in/out).

D. Procedure parameter mode is incorrect.

Solution

1. Step 1: Check procedure parameter modes

   Procedure parameters must specify mode (in, out, inout). The procedure parameter msg correctly uses in.

2. Step 2: Check function parameter modes

   Function parameters must also specify mode explicitly. The function parameter msg : string lacks mode, which is required.

3. Final Answer:

   Function parameter missing mode (in/out). -> Option C

4. Quick Check:

   Function parameters need mode = A [OK]

Hint: Always specify parameter mode in functions and procedures [OK]

Common Mistakes:

• Omitting parameter mode in functions
• Confusing package and package body syntax
• Thinking procedures need return types

5. You want to create a VHDL package that includes a function to calculate the factorial of a number and a procedure to print the result. Which of the following is the best approach?

hard

A. Define factorial as a procedure modifying a global variable; print as a function returning string.

B. Define both factorial and print as functions returning integer.

C. Define factorial as a procedure returning integer; print as a procedure with no parameters.

D. Define the factorial as a function returning integer; define the print as a procedure taking integer input.

Solution

1. Step 1: Choose correct return types

   Factorial calculation returns a value, so it should be a function returning integer.

2. Step 2: Choose correct procedure for printing

   Printing is an action without return value, so it should be a procedure taking the integer to print.

3. Final Answer:

   Define the factorial as a function returning integer; define the print as a procedure taking integer input. -> Option D

4. Quick Check:

   Function returns value; procedure performs action = C [OK]

Hint: Use function for calculations, procedure for actions [OK]

Common Mistakes:

• Using procedures to return values
• Defining print as function with return value
• Not passing parameters to procedures