# TP Modul 8 - Microprogramming (Finite State Machine)

> Pembuat Soal: MF

Nama : Reinathan Ezkhiel Kurniawan
NPM  : 2406397675

## Teori (25 pts)

### 1. Jelaskan apa itu Finite State Machine (FSM) serta jenis-jenisnya dan kegunannya masing-masing! (10 pts)

FSM (*Finite State Machine*) adalah sebuah sebuah model mesin yang mempunyai sejumlah kondisi (*states*) terbatas dan berpindah antar kondisi tersebut berdasarkan *input* dan/atau *state* sekarang. Saat berada di suatu *state*, keluaran (**output**) dan *next state* ditentukan oleh keadaan sekarang dan input.

Jenis - jenis FSM adalah :
* **Moore Machine** : **Output** hanya bergantung pada *state* sekarang, bukan langsung pada *input*. Kegunaan tipe ini adalah untuk membuat prediksi *output* lebih sederhana, lebih aman dari *glitch* karena *output* tidak tergantung langsung pada kombinasi *input*.
* **Mealy Machine** : **Output** pada mesin ini bergantung pada *state* dan *input* saat ini. Kegunaannya adalah untuk bisa merespon *input* lebih cepat (sering satu siklus lebih cepat daripada *Moore* untuk keadaan yang sama) dan kadang *state*nya lebih sedikit.
* **Algorithmic State Machine**/**Finite State Machine with Datapath** : Kombinasi FSM dengan Datapath (*register*, *ALU*, *multiplexer*). Dalam tipe ini, *state* mengontrol operasi *datapath*. Kegunaannya adalah untuk algoritma sekeuensial yang kompleks, misalnya kalkulasi, pemrosesan data, kontrol *loop* dalam *hardware*.

### Referensi:
- GeeksforGeeks, “Mealy and Moore Machines in TOC,” GeeksforGeeks. [Online]. Available: https://www.geeksforgeeks.org/theory-of-computation/mealy-and-moore-machines-in-toc/. [Diakses: 7-Nov-2025]
- Jan Weeks, “Lecture Notes Week 3.1 — FSM and ASM,” Department of Informatics & Mathematical Modelling, Technical University of Denmark. [Online]. Available: https://www2.imm.dtu.dk/courses/02131/02131/web/jan_week3_1.pdf. [Diakses: 7-Nov-2025]
- GeeksforGeeks, “Introduction of Algorithmic State Machines (ASMs),” GeeksforGeeks. [Online]. Available: https://www.geeksforgeeks.org/digital-logic/introduction-of-algorithmic-state-machines-asms/. [Diakses: 7-Nov-2025]

### 2. Jelaskan keyword-keyword berikut dalam konteks VHDL! (5 pts) <ul><li>Record</li><li>Alias</li><li>Aggregate</li></ul>

**Record** adalah tipe komposit variabel yang terdiri dari beberapa elemen (atau *field*) dengan nama masing-masing. Contohnya seperti:

type Data_Siswa is record
   NoAbsen : integer;
   Name : string(1 to 8);
end record;

Variabel atau sinyal dari tipe `record` kemudian bisa dideklarasikan. Penggunaannya memudahkan pengelompokan data berbeda tipe dalam satu *container*.

**Alias** digunakan untuk meberikan nama alternatif(alias) terhadap elemen pada kode sumber yang sudah dideklarasikan sebelumnya (sinyal,*port*,variabel, atau bagian dari `record`/`array`). Dengan `alias`, kita bisa mengakses atau menetapkan nilai melalui nama yang lebih mudah diingat atau lebih pendek.
Contohnya seperti:

alias ConnectorBus : std_logic_vector(7 downto 0) is B(15 downto 8);

**Aggregate** adalah konstruksi untuk menetapkan nilai ke seluruh atau sebagian elemen dari `array` atau `record` dalam satu penugasan. Dengan `aggregate` kita bisa menetapkan nilai ke beberapa elemen atau seluruh elemen lebih ringkas.

Contohnya seperti:

variable DS : Data_Siswa := (NPM => 69, Name => "Rei");

### Referensi:
- FPGA Tutorial, “VHDL Records, Arrays, and Custom Types,” FPGA Tutorial. [Online]. Available: https://fpgatutorial.com/vhdl-records-arrays-and-custom-types/. [Diakses: 7-Nov-2025]
- J. Moorkan, “Alias Declaration in VHDL,” Department of Information and Computer Science, University of California, Irvine. [Online]. Available: https://ics.uci.edu/~jmoorkan/vhdlref/aliasdec.html. [Diakses: 7-Nov-2025]
- HDLWorks, “Aggregate – VHDL Reference,” HDLWorks. [Online]. Available: https://www.hdlworks.com/hdl_corner/vhdl_ref/VHDLContents/Aggregate.htm. [Diakses: 7-Nov-2025]

### 3. Apa itu microprogramming? Apa itu datapath dan control unit? (10 pts)

**Microprogamming** merupakan teknik pengendalian (*control*) sebuah *processor* atau *digital unit* dengan menggunakan **microinstsruction** atau **micro-program** yang tersimpan dalam memori kontrol (*control-store*). *Controller* di desain adalah sebagai mesin mikroinstruksi yang menjalankan **micro-operations** untuk setiap instruksi mesin tingkat atas.

**Datapath** adalah bagian dari sistem digital atau prosesor yang menangani aliran data dan operasi aritmetika/logika (ALU), register, *multiplexers*, dan jalur data (*buses*). **Datapath** melakukan pengolahan data berdasarkan instruksi kontrol.

**Control Unit** merupakan bagian dari sistem yang menghasilkan sinyal kontrol untuk mengatur *datapath* seperti pada keadaan memiliki operasi ALU, mengaktifkan penulisan register, memilih *multiplexer*, dan sebagainya. *Control Unit* menentukan urutan operasi (*state*), memutuskan kapan *datapath* melakukan tindakan tertentu.

### Referensi:
- GeeksforGeeks, “Microprogramming — Basics,” GeeksforGeeks. [Online]. Available: https://www.geeksforgeeks.org/computer-organization-architecture/microprogramming-basics-1/. [Diakses: 7-Nov-2025]
- GeeksforGeeks, “Introduction of Control Unit and Its Design,” GeeksforGeeks. [Online]. Available: https://www.geeksforgeeks.org/computer-organization-architecture/introduction-of-control-unit-and-its-design/. [Diakses: 7-Nov-2025]
- GeeksforGeeks, “Differences Between Data Paths,” GeeksforGeeks. [Online]. Available: https://www.geeksforgeeks.org/computer-organization-architecture/differences-between-data-paths/. [Diakses: 7-Nov-2025]

## Praktik (35)
> Tidak perlu referensi

### Diketahui state diagram dari sebuah FSM dengan input 2 bit Q (Q1Q0) berikut:


### FSM mulai pada `S0` dan setiap state juga menghasilkan output 3 bit O (O2O1O0) dengan spesifikasi berikut:

| State | OUTPUT |
|-------|--------|
| S0 | 000 |
| S1 | 001 |
| S2 | 100 |
| S3 | 101 |
| S4 | 010 |

#### A. Buatlah state transition table berdasarkan spesifikasi-spesifikasi tersebut! (10 pts)

| State | Input (Q1Q0) | Next State | Output |
|-------|-----------|------------|--------|
| S0 | 00 | S0 | 000 |
| S0 | 11 | S1 | 001 |
| S1 | 00 | S1 | 001 |
| S1 | 10 | S2 | 100 |
| S1 | 11 | S0 | 000 |
| S2 | 00 | S2 | 100 |
| S2 | 10 | S3 | 101 |
| S2 | 11 | S0 | 000 |
| S3 | 00 | S3 | 101 |
| S3 | 10 | S4 | 010 |
| S3 | 11 | S0 | 000 |
| S4 | 00 | S4 | 010 |
| S4 | 10 | S1 | 001 |
| S4 | 11 | S0 | 000 |

#### B. Lengkapi kode berikut untuk mengimplementasikan FSM tersebut dalam VHDL! (20 pts)

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;

entity fsm_tp_8 is
    port (
        CLK : in std_logic;
        RST : in std_logic;
        Q   : in std_logic_vector(1 downto 0);
        O   : out std_logic_vector(2 downto 0)
    );
end entity fsm_tp_8;

architecture rtl of fsm_tp_8 is
    type t_State is (S0, S1, S2, S3, S4);
    signal State     : t_State := S0;
    signal NextState : t_State;
begin

    STATE_TRANSITION: process(CLK)
    begin
        if rising_edge(CLK) then
            if RST = '1' then
                State <= S0;
            else
                State <= NextState;
            end if;
        end if;
    end process;

    STATE_OUTPUT: process(State)
    begin
        case State is
            when S0 =>
                O <= "000";
            when S1 =>
                O <= "001";
            when S2 =>
                O <= "100";
            when S3 =>
                O <= "101";
            when S4 =>
                O <= "010";
        end case;
    end process;

    STATE_CONDITION: process(State, Q)
    begin
        case State is
            when S0 =>
                if Q = "00" then
                    NextState <= S0;
                elsif Q = "11" then
                    NextState <= S1;
                else
                    NextState <= S0;
                end if;
            when S1 =>
                if Q = "00" then
                    NextState <= S1;
                elsif Q = "10" then
                    NextState <= S2;
                elsif Q = "11" then
                    NextState <= S0;
                else
                    NextState <= S1;
                end if;
            when S2 =>
                if Q = "00" then
                    NextState <= S2;
                elsif Q = "10" then
                    NextState <= S3;
                elsif Q = "11" then
                    NextState <= S0;
                else
                    NextState <= S2;
                end if;
            when S3 =>
                if Q = "00" then
                    NextState <= S3;
                elsif Q = "10" then
                    NextState <= S4;
                elsif Q = "11" then
                    NextState <= S0;
                else
                    NextState <= S3;
                end if;
            when S4 =>
                if Q = "00" then
                    NextState <= S4;
                elsif Q = "10" then
                    NextState <= S1;
                elsif Q = "11" then
                    NextState <= S0;
                else
                    NextState <= S4;
                end if;
        end case;
    end process;

end architecture rtl;

#### C. Jalankan rangkaian dengan input dan timing yang sesuai sehingga output menghasilkan perubahan state
##### S0 -> S1 -> S2 -> S2 -> S0 -> S1 -> S1 -> S2 -> S3 -> S4 -> S4 -> S1 -> S0
#### Screenshot! (5 pts)

| State | Input (Q1Q0) | Next State | Output |
|-------|-----------|------------|--------|
| S0 | 11 | S1 | 001 |
| S1 | 10 | S2 | 100 |
| S2 | 00 | S2 | 100 |
| S2 | 11 | S0 | 000 |
| S0 | 11 | S1 | 001 |
| S1 | 00 | S1 | 001 |
| S1 | 10 | S2 | 100 |
| S2 | 10 | S3 | 101 |
| S3 | 10 | S4 | 010 |
| S4 | 00 | S4 | 010 |
| S4 | 10 | S1 | 001 |
| S1 | 11 | S0 | 000 |


## Pre-CS (40 pts)

### Perhatikan diagram arsitektur CPU sederhana 8 bit berikut!

### CPU tersebut memiliki 8 buah komponen yang terhubung dengan satu bus 8 bit serta 14 sinyal kontrol (control signals) untuk microprogram. CPU menggunakan instruction word 8 bit yang terdiri atas 4 bit opcode serta 4 bit operand yang dapat berupa baik address maupun immediate value. CPU tersebut memiliki RAM dengan addressing 4 bit yang mampu menyimpan 16 buah data 8 bit.

### Penjelasan Arsitektur
<details>
<summary>
Click to expand.
</summary>

#### Register (A & B)
##### Keterangan
- Menyimpan data 8 bit.
##### Control Signals
- RXO: Menulis data dari register X ke bus.
- RXI: Membaca data dari bus ke register X.

#### Arithmatic Logic Unit (ALU)
##### Keterangan
- Menjumlahkan atau mengurangi register A dengan B.
##### Control Signals
- SUB: Jika diset ke 1, output berupa A - B, sebaliknya akan menghasilkan A + B.
- ALO: Menulis output dari ALU ke bus.
##### Flags
- Zero Flag: Diset ke 1 jika output berupa nol.
- Carry Flag: Diset ke 1 jika operasi aritmatika menghasilkan carry/borrow.

#### Program Counter (PC)
##### Keterangan
- Counter dari lokasi memori instruksi.
- Dapat melakukan increment untuk instruksi selanjutnya ataupun melakukan jump dengan membaca dari bus.
##### Control Signals
- PCI: Mengambil data instruksi selanjutnya dari bus. Dapat digunakan untuk melakukan jump.
- PCO: Menulis data dari PC ke bus.
- CNT: Melakukan increment counter instruksi di dalamnya.

#### Memory Address Register (MAR)
##### Keterangan
- Menyimpan lokasi memori 4 bit untuk RAM.
- Mempengaruhi lokasi data yang diubah dalam RAM.
##### Control Signals
- MRI: Menulis 4 least significant bits (4 bit terakhir) dari bus ke dalamm MAR.

#### Program Counter (RAM)
##### Keterangan
- Menyimpan data 8 bit dalam lokasi 4 bit.
- Mampu menyimpan 16 buah data 8 bit.
##### Control Signals
- RMI: Membaca data dari bus dan menyimpannya ke lokasi memori yang diset oleh MAR.
- RMO: Menulis data dari lokasi memori yang diset MAR ke bus.

#### Instruction Register (IR)
##### Keterangan
- Menyimpan instruction byte yang diambil dari RAM berdasarkan PC.
- Instruction byte terdiri atas 4 bit MSB opcode dan 4 bit LSB operand.
##### Control Signals
- IRI: Menyimpan data dari bus ke IR.
- IRO: Menulis 4 bit LSB dari IR ke bus.

#### Control Unit (CU)
##### Keterangan
- Merupakan pengendali keseluruhan control signal dari datapath setiap component sebelumnya.
- Melakukan decoding instruksi yang ada di IR dan mengatur microprogram yang sesuai.
- Mengandung state machine yang mengatur urutan control signal microprogram untuk setiap siklus clock.

</details>

### CPU memiliki siklus fetch - execute. Untuk setiap instruksi yang ada di dalam instruction set, CPU melakukan fetching dengan microprogram berikut:

#### MP - Fetch
| CC | RAO | RAI | RBO | RBI | SUB | ALO | PCI | PCO | CNT | MRI | RMI | RMO | IRI | IRO |
|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 |

### dilanjutkan dengan instruksi yang sesuai dengan opcode yang ada pada IR.

### Set Instruksi
#### Instruksi 1 - LDA [MEM]
##### Opcode: 0001 MMMM
##### Keterangan: Menyimpan data dari memori berlokasi `MEM` ke register A.
##### Microprogram:
MP - Fetch lalu...
| CC | RAO | RAI | RBO | RBI | SUB | ALO | PCI | PCO | CNT | MRI | RMI | RMO | IRI | IRO |
|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
| 2 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 |

`CNT` diset ke 1 untuk melakukan increment PC agar mengeksekusi instruksi selanjutnya pada siklus clock setelah ini.

### Tugas anda adalah mengimplementasikan Control Unit dengan menerapkan instruction set CPU ini.

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;

entity control_unit is
    port (
        CLK             : in std_logic;
        enable          : in std_logic;
        RST             : in std_logic;
        carry_flag      : in std_logic;
        zero_flag       : in std_logic;
        opcode          : in std_logic_vector(3 downto 0);
        control_signals : out std_logic_vector(13 downto 0)
    );
end entity control_unit;

architecture rtl of control_unit is
    type t_State is (IDLE, FETCH, DECODE, LDA1, LDA2);
    signal State : t_State := IDLE;
    signal NextState : t_State;
begin

    STATE_TRANSITION: process(CLK) is
    begin
        if enable = '1' and rising_edge(CLK) then
            if RST = '1' then
                State <= IDLE;
            else
                State <= NextState;
            end if;
        end if;
    end process;
    
    STATE_OUTPUT: process(State)
    begin
        case State is
            when IDLE =>
                control_signals <= "00000000000000";
            when FETCH =>
                control_signals <= "00000001010000";
            when DECODE =>
                control_signals <= "00000000000110";

            when LDA1 =>
                control_signals <= "00000000010001";
            when LDA2 =>
                control_signals <= "01000000100100";
        end case;
    end process STATE_OUTPUT;

    STATE_CONDITION: process(State, carry_flag, zero_flag)
    begin
        case State is
            when IDLE =>
                NextState <= FETCH;

            when FETCH =>
                NextState <= DECODE;

            when DECODE =>
                case opcode is
                    when "0001" =>
                        NextState <= LDA1;
                    -- when OPCODE LAIN => ... (kembangkan)
                    when others =>
                        NextState <= IDLE;
                end case;

            when LDA1 => 
                NextState <= LDA2;
            when LDA2 =>
                NextState <= FETCH;

            -- Kembangkan untuk instruksi lebih lanjut
        end case;
    end process STATE_CONDITION;
end architecture rtl;

### Kerjakan sejumlah instruksi berikut dan lalu cantumkan kode VHDL akhir anda!

#### Instruksi 2 - STA [MEM] (5 pts)
##### Opcode: 0010 MMMM
##### Keterangan: Mengambil data dari MEM ke register A.
##### Microprogram:

| CC | RAO | RAI | RBO | RBI | SUB | ALO | PCI | PCO | CNT | MRI | RMI | RMO | IRI | IRO |
|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 |
| 3 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |0 |0 | 1 | 0 | 0 | 0 |
|....| | | | | | | | | | | | | | |

#### Instruksi 3 - LDB [MEM] (5 pts)
##### Opcode: 0101 MMMM
##### Keterangan: Mengambil data dari MEM ke register B.
##### Microprogram:

| CC | RAO | RAI | RBO | RBI | SUB | ALO | PCI | PCO | CNT | MRI | RMI | RMO | IRI | IRO |
|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
| 3 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
|....| | | | | | | | | | | | | | |

#### Instruksi 4 - STB [MEM] (5 pts)
##### Opcode: 0110 MMMM
##### Keterangan: Menyimpan data dari memori berlokasi `MEM` ke register B.
##### Microprogram:

| CC | RAO | RAI | RBO | RBI | SUB | ALO | PCI | PCO | CNT | MRI | RMI | RMO | IRI | IRO |
|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |1 | 0 | 0 | 0 | 1 |
| 3 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |0 | 0 | 0 |
|....| | | | | | | | | | | | | | |

#### Instruksi 5 - MAB (5 pts)
##### Opcode: 0100 XXXX
##### Keterangan: Memindahkan data register A ke register B.
##### Microprogram:

| CC | RAO | RAI | RBO | RBI | SUB | ALO | PCI | PCO | CNT | MRI | RMI | RMO | IRI | IRO |
|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|....| | | | | | | | | | | | | | |

#### Instruksi 6 - MBA (5 pts)
##### Opcode: 0111 XXXX
##### Keterangan: Memindahkan data register B ke register A.
##### Microprogram:

| CC | RAO | RAI | RBO | RBI | SUB | ALO | PCI | PCO | CNT | MRI | RMI | RMO | IRI | IRO |
|----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|....| | | | | | | | | | | | | | |

### Cantumkan kode VHDL akhir anda! (10 pts)

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;

entity control_unit is
    port (
        CLK             : in std_logic;
        enable          : in std_logic;
        RST             : in std_logic;
        carry_flag      : in std_logic;
        zero_flag       : in std_logic;
        opcode          : in std_logic_vector(3 downto 0);
        control_signals : out std_logic_vector(13 downto 0)
    );
end entity control_unit;

architecture rtl of control_unit is
    type t_State is (IDLE, FETCH, DECODE, LDA1, LDA2, STA1, STA2, LDB1, LDB2, STB1, STB2, MAB1, MAB2, MBA1, MBA2);
    signal State : t_State := IDLE;
    signal NextState : t_State;
begin

    STATE_TRANSITION: process(CLK) is
    begin
	if enable = '1' and rising_edge(CLK) then
    		if RST = '1' then
        		State <= IDLE;
    	elsif enable = '1' then
        	State <= NextState;
    		end if;
	end if;
    end process;
    
    STATE_OUTPUT: process(State)
    begin
        case State is
            when IDLE =>
                control_signals <= "00000000000000";
            when FETCH =>
                control_signals <= "00000001010000";
            when DECODE =>
                control_signals <= "00000000000110";
            when LDA1 =>
                control_signals <= "00000000010001";
            when LDA2 =>
                control_signals <= "01000000100100";
            when STA1 =>
                control_signals <= "00000000010001";
            when STA2 =>
                control_signals <= "10000000001000";
            when LDB1 =>
                control_signals <= "00000000010001";
            when LDB2 =>
                control_signals <= "00010000000100";
            when STB1 =>
                control_signals <= "00000000010001";
            when STB2 =>
                control_signals <= "00100000001000";
            when MAB1 =>
                control_signals <= "10010000000000";
            when MAB2 =>
                control_signals <= "00000000000000";
            when MBA1 =>
                control_signals <= "01100000000000";
            when MBA2 =>
                control_signals <= "00000000000000";
        end case;
    end process STATE_OUTPUT;

    STATE_CONDITION: process(State, carry_flag, zero_flag,opcode)
    begin
        case State is
            when IDLE =>
                NextState <= FETCH;

            when FETCH =>
                NextState <= DECODE;

            when DECODE =>
                case opcode is
                    when "0001" =>
                        NextState <= LDA1;
                    when "0010" =>        
                        NextState <= STA1;
                    when "0101" =>        
                        NextState <= LDB1;
                    when "0110" =>       
                        NextState <= STB1;
                    when "0100" =>       
                        NextState <= MAB1;
                    when "0111" =>       
                        NextState <= MBA1;
                    when others =>
                        NextState <= IDLE;
                end case;

            when LDA1 => 
                NextState <= LDA2;
            when LDA2 =>
                NextState <= FETCH;

            when STA1 =>
                NextState <= STA2;
            when STA2 =>
                NextState <= FETCH;

            when LDB1 =>
                NextState <= LDB2;
            when LDB2 =>
                NextState <= FETCH;

            when STB1 =>
                NextState <= STB2;
            when STB2 =>
                NextState <= FETCH;

            when MAB1 =>
                NextState <= MAB2;
            when MAB2 =>
                NextState <= FETCH;

            when MBA1 =>
                NextState <= MBA2;
            when MBA2 =>
                NextState <= FETCH;
        end case;
    end process STATE_CONDITION;
end architecture rtl;

### Dengan kode testbench berikut, cantumkan screenshot hasil jalan rangkaian anda! (5 pts)

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;

entity control_unit_tb is
end entity control_unit_tb;

architecture sim of control_unit_tb is

    component control_unit is
        port (
            CLK             : in std_logic;
            enable          : in std_logic;
            RST             : in std_logic;
            carry_flag      : in std_logic;
            zero_flag       : in std_logic;
            opcode          : in std_logic_vector(3 downto 0);
            control_signals : out std_logic_vector(13 downto 0)
        );
    end component;

    signal CLK             : std_logic := '0';
    signal enable          : std_logic := '0';
    signal RST             : std_logic := '0';
    signal carry_flag      : std_logic := '0';
    signal zero_flag       : std_logic := '0';
    signal opcode          : std_logic_vector(3 downto 0) := (others => '0');
    signal control_signals : std_logic_vector(13 downto 0);

    constant CLK_PERIOD : time := 10 ns;

begin
    DUT: control_unit
        port map (
            CLK             => CLK,
            enable          => enable,
            RST             => RST,
            carry_flag      => carry_flag,
            zero_flag       => zero_flag,
            opcode          => opcode,
            control_signals => control_signals
        );

    CLK_PROCESS : process
    begin
        while true loop
            CLK <= '0';
            wait for CLK_PERIOD / 2;
            CLK <= '1';
            wait for CLK_PERIOD / 2;
        end loop;
    end process;

    STIM_PROC: process
    begin
        enable <= '1';
        RST <= '1';
        wait for 2 * CLK_PERIOD;
        RST <= '0';
        
        -- LDA
        opcode <= "0001";
        wait for 6 * CLK_PERIOD;

        -- MAB
        opcode <= "0100";
        wait for 6 * CLK_PERIOD;

        -- STA
        opcode <= "0010";
        wait for 6 * CLK_PERIOD;

        -- LDB
        opcode <= "0101";
        wait for 6 * CLK_PERIOD;

        -- MBA
        opcode <= "0111";
        wait for 6 * CLK_PERIOD;

        -- STB
        opcode <= "0110";
        wait for 6 * CLK_PERIOD;

        enable <= '0';

        wait;
    end process;

end architecture sim;

> Pastikan setiap bit control unit terlihat. Expand supaya kelihatan.