From VHDL Code to Real Hardware: Designing an 8-bit ALU

October 22, 2023 by Kristijan Nelkovski

In this project we create an 8-bit arithmetic logic unit (ALU) in the VHDL language and run it on an Altera CPLD development board connected to a custom PCB with input switches and LED display.

Developing electronic systems using a hardware-based approach doesn’t always have to involve physically connecting various transistors and logic gates onto a breadboard or a PCB. It is possible to build an arithmetic logic unit (ALU) using discrete logic, but as logic complexity increases, there are better options. Through programmable logic devices and hardware description languages (HDL), anything from a simple circuit to a highly specialized processing unit can be implemented within a single chip.


ALU Project Overview

In this project, I will walk through the creation of the 8-bit ALU circuit with input DIP switches and output LEDs demonstrated in operation in Figure 1. I used the VHDL language to code the ALU and ran it on a Complex Programmable Logic Device (CPLD) development board. My goal was to give an introduction to programmable logic and open the door for working with real hardware rather than just diagrams and computer simulations.


Custom PCB switches and LEDs demonstrate ALU operation

Figure 1. The 8-bit ALU project in operation (GIF). Image used courtesy of Kristijan Nelkovski


For this project, I built a custom printed circuit board (PCB) with All About Circuits branding, as illustrated in Figure 2. The CPLD is a more affordable but less powerful programmable logic device than the more well-known Field Programmable Gate Array (FPGA). Both devices can be used to create custom electronic designs with dedicated inputs and outputs.


The completed ALU project includes a custom PCB

Figure 2. The completed ALU project includes a custom PCB. Image used courtesy of Kristijan Nelkovski


Internally, these CPLD and FPGA components contain arrays of reconfigurable logic blocks and come packaged as standalone ICs for embedding into your own designs. Manufacturers offer development boards for learning, testing, and experimenting using their technologies and software environments. I used a development board for my CPLD.


What Is an ALU?

At the core of every processor lies a combinational logic circuit that executes arithmetic and bitwise operations on integer binary numbers called an Arithmetic Logic Unit. The circuit that we’re going to be building in this project is an 8-bit ALU that contains two 8-bit operands (inputs), one 8-bit result (output), and a 4-bit opcode (input) that defines what operation is going to be executed (Figure 3)


Symbolic representation of an ALU

Figure 3. A symbolic representation of an ALU. Image used courtesy of Jim Lamberson, Wikimedia Commons


An ALU will typically contain status bits (both as inputs and as outputs) that give important information to a processor about the last executed operation. This status info can include whether the result was zero or whether the result overflowed outside of the most significant bit (MSB). However, our circuit doesn’t need them and, as such, will not contain any.

The ALU provides an excellent starting point for learning about VHDL coding and CPLD programming operations. Once you complete this project, you can easily expand to more difficult applications.


Project Details and References

In this project, we will create an 8-bit arithmetic logic unit (ALU) in the VHDL language and run it on an Altera Max II EPM240 CPLD development board using Intel’s Quartus Prime Lite Edition software (Altera is now part of Intel). The code for this circuit is built upon lab exercise designs published by the University of California, Riverside.

For this project, you need to have a basic comprehension of programming and discrete logic. Checking out AAC’s introduction to VHDL and 4-bit discrete logic ALU project would also be beneficial.

Note: Although I created a “shield” type board for use in this project, everything covered here is completely breadboard and perfboard friendly.


Setting up a New Project With Quartus Prime for the Altera MAX II Dev Board

To start working on our project, we need to download and install the Quartus Prime Lite Edition and create a folder to store all of our projects. I downloaded the software from Intel’s website and created a folder called “quartus” in the “Windows Documents” directory.

When we run Quartus, the first thing we need to do is set up a new project via the “New Project Wizard,” which can be found under “File -> New Project Wizard.” Then, we need to click “Next” on the first screen called “Introduction”.

As illustrated in Figure 4, on the second screen called “Directory, Name, Top-Level Entity,” we need to select the folder we created earlier as the working directory and give the current project an adequate name. I named this project “ALU”.


Quartus “Directory, Name, Top-Level Entity” screen

Figure 4. Quartus “Directory, Name, Top-Level Entity” screen. Image used courtesy of Kristijan Nelkovski (Click image to enlarge)


For the “Project Type” screen, we need to select “Empty project” and leave the next screen called “Add Files” empty (Figure 5).


Quartus “Project Type” screen

Figure 5. Quartus “Project Type” screen. Image used courtesy of Kristijan Nelkovski (Click image to enlarge)


On the “Family, Device & Board Settings” screen, we need to select “MAX II” from the drop-down menu in the “Device family” section (Figure 6). Then, from the “Available devices” section, select “EPM240T100C5”, as this is the chip onboard the Altera MAX II EPM240.


Quartus filled Family screen

Figure 6. Quartus filled “Family, Device & Board Settings” screen. Image used courtesy of Kristijan Nelkovski (Click image to enlarge)


Next, we need to change “Verilog HDL” to “VHDL” on the “EDA Tool Settings” screen, click next, and check if everything is done correctly in the “Summary” (Figure 7). After this, we can click on the “Finish” button, and our new project will be created.


Quartus EDA tool settings screen

Figure 7. Quartus “EDA Tool Settings” screen. Image used courtesy of Kristijan Nelkovski (Click image to enlarge)


Once this project opens, we need to click on the name of our entity in the “Project Navigator: Hierarchy” window and create a new VHDL file by pressing “CTRL+N” and selecting “VHDL File.”

After this file opens, we have to save it as the VHDL file for our entity by going into “File -> Save As.” When all of this is done, we can start writing the code for our ALU.


Declaring the VHDL Libraries

So as with all programming languages, the first thing that we need to do at the top of the VHDL code is to declare the libraries that will be used in the project.

USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.ALL;
USE ieee.std_logic_arith.ALL;


Creating the ALU Circuit Entity

Next, we will create an ALU entity that defines all of its input and output ports. Here we have defined ports A and B as “IN STD_LOGIC_VECTOR(7 DOWNTO 0)” which means that each of these inputs is actually an 8-bit bus with its bits numbered from 7 down to 0 where the seventh bit is the MSB. Similarly, the SEL port is defined as a 4-bit input, and the RES port is defined as an 8-bit output.

   PORT (


Creating a VHDL Behavioral Architecture of the ALU Circuit

Now we need to design the architecture or behavior of our circuit. We will create a process using the three inputs or ports A, B, and Sel.

Inside this process, we can call a “case-when” statement (similar to “switch-case” in other programming languages) where we check the state of the port SEL. The SEL value is the opcode for our ALU and determines which operation needs to be executed between the two 8-bit numbers that are received on ports A and B.

This is done within the “when XXXX =>” portions of the statement where XXXX represents the binary state of SEL (a position between 0000 and 1111). Each state is assigned to a corresponding ALU operation being executed using the values received on ports A and B. The output is written out on port RES.

After this, we can end the “case” statement, the process, and the behavioral architecture, and with that, end the code portion of our project.

    PROCESS (A, B, Sel)
        CASE Sel IS
            WHEN "0000" =>
                RES <= "00000000"; -- no operation
            WHEN "0001" =>
                RES <= A + B; -- addition 
            WHEN "0010" =>
                RES <= A + (NOT B) + 1; -- subtraction
            WHEN "0011" =>
                RES <= A + 1; -- add one to operand A
            WHEN "0100" =>
                RES <= A - 1; -- subtract one from operand A
            WHEN "0101" =>
                RES <= A(6 DOWNTO 0) & '0'; -- shift operand A to the left
            WHEN "0110" =>
                RES <= '0' & A(7 DOWNTO 1); -- shift operand A to the right
            WHEN "0111" =>
                RES <= NOT A; -- one's complement of operand A
            WHEN "1000" =>
                RES <= NOT A + 1; -- two's complement of operand A
            WHEN "1001" =>
                RES <= A AND B; -- logical and
            WHEN "1010" =>
                RES <= A OR B; -- logical or
            WHEN "1011" =>
                RES <= A NAND B; -- logical nand
            WHEN "1100" =>
                RES <= A NOR B; -- logical nor
            WHEN "1101" =>
                RES <= A XOR B; -- logical xor
            WHEN "1110" =>
                RES <= (NOT A) + (NOT B); -- random operation
            WHEN "1111" =>
                RES <= (A + B) AND (A OR B); -- another random operation
            WHEN OTHERS =>
                RES <= "00000000"; 
        END CASE;
END behv;

In the code above, I’ve included some of the most common arithmetic and logic operations as well as some random ones, commenting on what each of them does. Here you can replace and include any arbitrary arithmetic or logic operation that you’d like!


Pin Mapping

After our code is finished, the first thing that we need to do is compile it. This can be done by going into “Processing -> Start Compilation.” If everything compiles correctly, we shouldn't get any error messages, although we’ll probably get some warnings that we can ignore.

Next, we need to connect the ports we defined earlier for our entity to physical pins located on the Altera development board. We’re going to do this through Quartus’ Pin Planner tool which is accessible through “Assignments -> Pin Planner.”

The pin planner tool contains:

  • A visual representation of the chip in use (the EPM240 in this case.
  • A pin legend describing each pin type.
  • A table containing each individual node from our entity’s ports. Inside this table, we can connect every node to a dedicated pin by writing it out in the corresponding row of the “Location” column.

Table 1 contains my resulting pinout table.


Table 1. Quartus pin mapping table for the ALU
A[7] PIN_89 Res[7] PIN_68
A[6] PIN_90 Res[6] PIN_61
A[5] PIN_87 Res[5] PIN_66
A[4] PIN_88 Res[4] PIN_57
A[3] PIN_85 Res[3] PIN_58
A[2] PIN_86 Res[2] PIN_55
A[1] PIN_83 Res[1] PIN_56
A[0] PIN_84 Res[0] PIN_54
B[7] PIN_81 Sel[3] PIN_71
B[6] PIN_82 Sel[2] PIN_72
B[5] PIN_77 Sel[1] PIN_69
B[4] PIN_78 Sel[0] PIN_70
B[3] PIN_75    
B[2] PIN_76    
B[1] PIN_73    
B[0] PIN_74    


Uploading Code to the Altera Dev Board

Once we’ve assigned every input and output to a pin, we need to compile the code again. If no error messages pop up, we can proceed uploading it to the Altera MAX II.

In order to do so, we first have to connect the board itself to a 5 V power source through the onboard barrel jack. Next, we have to connect it to the USB Blaster via the JTAG port and then connect the USB Blaster to our computer using the mini USB jack (Figure 8).


Altera board and USB Blaster connections.

Figure 8. Altera board and USB Blaster connections. Image used courtesy of Kristijan Nelkovski


Afterward, we can run the programmer by going into “Tools -> Programmer” and checking “Program/Configure,” as shown in Figure 9. Then we need to open “Hardware Setup” and select “USB Blaster” as our “available hardware item” (our programmer) and then click “Start” for our code to be uploaded to the Altera MAX II.


Quartus programmer screen

Figure 9. Quartus programmer screen. Image used courtesy of Kristijan Nelkovski (Click image to enlarge)


PCB Circuit Diagram

The schematic of Figure 10 depicts our circuit diagram. Each LED is connected to an output pin through a current-limiting resistor. Each contact from a DIP switch that is connected to an input pin is also pulled down to the ground with resistor networks (on the custom PCB, these are hidden underneath the DIP switches).


Circuit diagram for the custom PCB wih switch inputs and LED outputs

Figure 10. Circuit diagram for the custom PCB wih switch inputs and LED outputs. Image used courtesy of Kristijan Nelkovski (Click image to enlarge)


After wiring everything up and powering the Altera board with 5 V, we can see the ALU spring into action by inputting numbers on our operand ports and switching the operation mode to any operation we like. The LEDs display the result as illustrated above in Figure 1.


BOM for the ALU Project

Table 2 contains the bill of materials for this project.


Table 2. VHDL ALU bill of materials
Part Description Quantity Notes
Altera Max II EPM240 development board and USB Blaster bundle (with a barrel jack and mini USB cable) 1 You need the main Altera board plus the USB blaster for uploading code through Quartus via JTAG.
LEDs 8 Here we represent each bit using an LED, so 8 bits for the ALU give us a total of 8 LEDs.
Resistors (R_0 to R_7) 8 Current limiting resistors for our LEDs (220 Ω to 1 kΩ).
DIP Switch - 8-position 2 Two 8-bit inputs for our ALU.
Resistor network of 8 resistors (RESISTOR NETWORK_A and RESISTOR NETWORK_B) 2 Pull-down resistor network for the 8 position switches (4.7 kΩ and up).
DIP Switch - 4 position 1 A 4-bit mode select input for the ALU.
Resistor network of 4 resistors (RESISTOR NETWORK_MODE) 1 Pull-down resistor network for the 4 position switches (4.7 kΩ and up).
Male-to-female jumper wires (or a custom IDC cable for the full PCB version) 30 Jumper wires from the Altera board to the breadboard or perfboard.


Your Turn!

In this project, we created an 8-bit ALU circuit in the VHDL language and ran it on a CPLD development board. Here, my goal was to give an introduction to programmable logic and open the door for working with FPGA components with real hardware components instead of diagrams and computer simulations.

If you duplicate this project, you can easily add additional opcodes to the VHDL operation of the ALU. You could also modify the circuit design to output and display status codes. Share your ideas or projects in the comments below!