Package declaration and body in VHDL - Mini Project: Build & Apply

Package declaration and body

📖 Scenario: You are designing a VHDL project where you want to reuse a set of constants and a function across multiple modules. To do this, you will create a package that declares these items and a package body that implements the function.

🎯 Goal: Create a VHDL package named Math_Pkg that declares a constant and a function, then create the package body that implements the function. Finally, display the result of calling the function with a test value.

📋 What You'll Learn

Create a package declaration named Math_Pkg

Declare a constant PI of type real with value 3.14159

Declare a function circle_area that takes a real radius and returns a real

Create a package body named Math_Pkg that implements the circle_area function

The circle_area function should return the area of a circle using the formula PI * radius * radius

Write a simple test process that calls circle_area with radius 2.0 and prints the result

💡 Why This Matters

🌍 Real World

Packages in VHDL help organize reusable code like constants and functions, making designs cleaner and easier to maintain.

💼 Career

Understanding packages is essential for FPGA and ASIC engineers who write modular and reusable VHDL code for hardware design.

1

Create the package declaration

Create a VHDL package declaration named Math_Pkg that declares a constant PI of type real with value 3.14159 and declares a function circle_area that takes a real parameter radius and returns a real.

VHDL

-- Your code here to create package declaration Math_Pkg
-- Declare constant PI and function circle_area

Hint

Use package and end package keywords. Declare the constant and function inside.

2

Create the package body

Create a VHDL package body named Math_Pkg that implements the function circle_area. The function should return PI * radius * radius.

VHDL

package Math_Pkg is
    constant PI : real := 3.14159;
    function circle_area(radius : real) return real;
end package Math_Pkg;

-- Your code here to create package body Math_Pkg
-- Implement function circle_area

Hint

Use package body and implement the function with the formula.

3

Write a test process to call the function

Write a VHDL process named test_process inside an architecture that calls Math_Pkg.circle_area with radius 2.0 and stores the result in a variable area of type real.

VHDL

package Math_Pkg is
    constant PI : real := 3.14159;
    function circle_area(radius : real) return real;
end package Math_Pkg;

package body Math_Pkg is
    function circle_area(radius : real) return real is
    begin
        return PI * radius * radius;
    end function circle_area;
end package body Math_Pkg;

entity Test is
end entity Test;

architecture Behavioral of Test is
    use work.Math_Pkg.all;
begin
    test_process : process
        variable area : real;
    begin
        -- Your code here to call circle_area with 2.0 and store in area
    end process test_process;
end Behavioral;

Hint

Inside the process, declare a variable area and assign it the result of circle_area(2.0).

4

Print the result of the function call

Add a line inside the test_process to print the value of area using report statement with the message "Area: " & real'image(area).

VHDL

package Math_Pkg is
    constant PI : real := 3.14159;
    function circle_area(radius : real) return real;
end package Math_Pkg;

package body Math_Pkg is
    function circle_area(radius : real) return real is
    begin
        return PI * radius * radius;
    end function circle_area;
end package body Math_Pkg;

entity Test is
end entity Test;

architecture Behavioral of Test is
    use work.Math_Pkg.all;
begin
    test_process : process
        variable area : real;
    begin
        area := circle_area(2.0);
        -- Print the area value here
        wait;
    end process test_process;
end Behavioral;

Hint

Use report "Area: " & real'image(area); to print the area.

Practice

1. What is the main purpose of a package declaration in VHDL?

easy

A. To define the entity and architecture of a design

B. To list constants, types, and function headers available for reuse

C. To implement the internal logic of functions

D. To simulate the behavior of a circuit

Solution

1. Step 1: Understand the role of package declaration

   The package declaration specifies what items (constants, types, function headers) are available to other parts of the design.

2. Step 2: Differentiate from package body

   The package body contains the actual implementation of functions, not the declaration.

3. Final Answer:

   To list constants, types, and function headers available for reuse -> Option B

4. Quick Check:

   Package declaration = lists available items [OK]

Hint: Declaration lists items; body defines them [OK]

Common Mistakes:

• Confusing package declaration with package body
• Thinking package declaration implements functions
• Mixing entity/architecture with packages

2. Which of the following is the correct syntax to start a package declaration named MyPackage in VHDL?

easy

A. package MyPackage is

B. package body MyPackage is

C. entity MyPackage is

D. architecture MyPackage of package is

Solution

1. Step 1: Identify package declaration syntax

   The correct syntax to declare a package is package PackageName is.

2. Step 2: Eliminate other options

   package body is for the package body, entity and architecture are unrelated to package declaration.

3. Final Answer:

   package MyPackage is -> Option A

4. Quick Check:

   Package declaration starts with 'package Name is' [OK]

Hint: Package declaration starts with 'package Name is' [OK]

Common Mistakes:

• Using 'package body' instead of 'package' for declaration
• Confusing entity/architecture keywords with package
• Incorrect order of keywords

3. Given the following package declaration and body, what will be the output of TestFunc(3)?

package MathPkg is
  function TestFunc(x : integer) return integer;
end package MathPkg;

package body MathPkg is
  function TestFunc(x : integer) return integer is
  begin
    return x * x;
  end TestFunc;
end package body MathPkg;

medium

A. Compilation error

B. 3

C. 6

D. 9

Solution

1. Step 1: Understand function implementation in package body

   The function TestFunc returns the square of the input x (x * x).

2. Step 2: Calculate output for input 3

   Input 3 squared is 3 * 3 = 9.

3. Final Answer:

   9 -> Option D

4. Quick Check:

   3 squared = 9 [OK]

Hint: Function returns x squared; input 3 -> 9 [OK]

Common Mistakes:

• Confusing declaration with implementation
• Assuming function returns input unchanged
• Thinking package body is optional for function

4. Identify the error in the following VHDL package code:

package Utils is
  function Add(a : integer; b : integer) return integer;
end package Utils;

package body Utils is
  function Add(a : integer; b : integer) return integer is
  begin
    return a + b
  end Add;
end package body Utils;

medium

A. Missing semicolon after return statement in function body

B. Package declaration missing 'body' keyword

C. Function parameters must be declared in package body only

D. Package body cannot contain function implementations

Solution

1. Step 1: Check function body syntax

   The return statement return a + b is missing a semicolon at the end.

2. Step 2: Verify other parts

   Package declaration and body keywords are correct; parameters are correctly declared in both places; package body can contain function implementations.

3. Final Answer:

   Missing semicolon after return statement in function body -> Option A

4. Quick Check:

   Statements need semicolons in VHDL [OK]

Hint: Check semicolons after statements in function body [OK]

Common Mistakes:

• Omitting semicolon after return statement
• Confusing package declaration with package body syntax
• Thinking function parameters only go in body

5. You want to create a package that shares a constant array and a function that returns the sum of its elements. Which of the following correctly shows the package declaration and body structure?

hard

A. package DataPkg is
constant Arr : integer_array := (1, 2, 3);
function SumArray return integer;
end package DataPkg;

package body DataPkg is
function SumArray return integer is
begin
return 6;
end SumArray;
end package body DataPkg;

B. package body DataPkg is
constant Arr : integer_array := (1, 2, 3);
function SumArray(a : integer_array) return integer;
end package body DataPkg;

package DataPkg is
function SumArray(a : integer_array) return integer is
begin
return 0;
end SumArray;
end package DataPkg;

C. package DataPkg is
constant Arr : integer_array := (1, 2, 3);
function SumArray(a : integer_array) return integer;
end package DataPkg;

package body DataPkg is
function SumArray(a : integer_array) return integer is
variable total : integer := 0;
begin
for i in a'range loop
total := total + a(i);
end loop;
return total;
end SumArray;
end package body DataPkg;

D. package DataPkg is
constant Arr : integer_array := (1, 2, 3);
function SumArray(a : integer_array) return integer;
end package DataPkg;

package body DataPkg is
function SumArray(a : integer_array) return integer is
begin
return a(1) + a(2);
end SumArray;
end package body DataPkg;

Solution

1. Step 1: Package declaration

   The declaration must contain the constant array definition constant Arr : integer_array := (1, 2, 3); and the function prototype function SumArray(a : integer_array) return integer;. This allows reuse across designs.

2. Step 2: Package body

   The body implements the function with a loop to sum all elements: variable total : integer := 0; for i in a'range loop total := total + a(i); end loop; return total;. Distractors lack proper structure, parameters, or dynamic summation.

3. Final Answer:

   Correct structure: constant and prototype in declaration, dynamic sum loop in body -> Option C

4. Quick Check:

   Declaration lists; body defines function logic [OK]

Hint: Declaration lists constants and function headers; body implements functions [OK]

Common Mistakes:

• Swapping package and package body order
• Omitting function parameters in declaration
• Incorrect function implementation missing loop or summation