Student name – Senevirathne S.M.P.U.

Index number – 220599M

In the lab session, the assigned task was to design and implement a 4-bit Ripple
Carry Adder (RCA). This involved creating and integrating various components such
as Half Adders, Full Adders, and ultimately the Ripple Carry Adder itself. Through
this task, we learned about hierarchical design principles, where complex
components are constructed from simpler ones and the process of verifying their
functionality through simulation and practical implementation on a development
board.

1. Half Adder

A B Sum Carry

0 0 0 0

0 1 1 0

1 0 1 0

1 1 0 1
2. Full Adder

A B C in Sum C out

0 0 0 0 0

0 0 1 1 0

0 1 0 1 0

0 1 1 0 1

1 0 0 1 0

1 0 1 0 1

1 1 0 0 1

1 1 1 1 1
3. Ripple Carry Adder (RCA)

4. Schematic Diagram
5. VHDL files

1. HA.vhd
2. FA.vhd
3. RCA_4.vhd
4. TB_HA.vhd
5. TB_FA.vhd
6. TB_RCA_4.vhd
6. Timing Diagrams

1. HA

2. FA

3. RCA

7. Discussion

LED LD0-LD3 typically represent the least significant bits (LSBs) of the RCA's
output. With a 4-bit RCA, LD0-LD3 can display 16 different combinations
(2^4 = 16). However, if the sum of the inputs exceeds 15 (1111 in binary),
LD0-LD3 won't be able to represent those outputs directly. For example, if the
output of the RCA is 16 (10000 in binary), LD0-LD3 would only show 0000,
which could lead to confusion or misinterpretation.

LD15 plays a crucial role in representing outputs that cannot be displayed

directly on LD0-LD3. LD15 serves as an overflow indicator. When the sum of
the inputs exceeds the maximum value represented by LD0-LD3, LD15 lights
up to indicate that an overflow has occurred. This overflow indication is
essential for understanding when the result exceeds the capacity of the display
and provides additional information to the user.

During the lab, we learned how to build complicated stuff like the Ripple
Carry Adder using simpler components like Half Adders and Full Adders. We
practiced by programming this onto the Basys3 board and testing it with
different inputs. We faced some challenges, like figuring out the board's limits
and fixing mistakes in our designs. Also, we learned about something called
arithmetic overflow, which happens when our numbers get too big for the
system to handle. We could see this on the LEDs and LD15.