LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all;


ENTITY bombomCPU IS
	PORT (clock, reset, inC, inD: in BIT;
		  mdr: IN STD_LOGIC_VECTOR(15 DOWNTO 0);
		  libera_bombom, memory_write: out BIT;
		  mar: out std_logic_vector(7 DOWNTO 0);
		  display1, display2: out std_logic_vector(6 DOWNTO 0);
		  mdr_out: out std_logic_vector(15 DOWNTO 0));
END bombomCPU;

ARCHITECTURE a OF bombomCPU IS
	TYPE STATE_TYPE IS (reset_pc, fetch, fetch2, fetch3, decode, execute_add, execute_jump, execute_inC, execute_inD, 
						execute_verify, execute_update_display, execute_store, execute_store2, execute_store3,
						execute_load, execute_sub15, execute_add2, execute_add3);
					
	SIGNAL state: STATE_TYPE := reset_pc;
	SIGNAL instruction_register: STD_LOGIC_VECTOR(15 DOWNTO 0);
	SIGNAL acumulador: STD_LOGIC_VECTOR(15 DOWNTO 0);
	SIGNAL program_counter: STD_LOGIC_VECTOR(7 DOWNTO 0);
	
	BEGIN
		PROCESS(clock, reset)
			BEGIN
			
			IF (reset = '1') THEN
				state <= reset_pc;
			ELSIF (clock'EVENT AND clock = '1') THEN
				CASE state IS 
				
					WHEN reset_pc =>
						program_counter <= "00000000";
						mar <= "00000000";
						acumulador <= "0000000000000000";
						memory_write <= '0';
						libera_bombom <= '0';
						display1 <= "0000001";
						display2 <= "0000001";
						mdr_out <= "0000000000000000";
						state <= fetch;
						
					WHEN fetch =>
						state <= fetch2;				
					WHEN fetch2 =>					
						state <= fetch3;
					WHEN fetch3 =>
						instruction_register <= mdr;
						
						program_counter <= unsigned(program_counter) + 1;
						
						memory_write <= '0';
						state <= decode;
					WHEN decode =>			
						mar <= instruction_register(7 DOWNTO 0);
								
						CASE instruction_register(15 DOWNTO 8) IS
						
							WHEN "00000000" =>
								state <= execute_inC;
							WHEN "00000001" =>
				 			    state <= execute_inD;
							WHEN "00000010" =>
				    			state <= execute_verify;		
							WHEN "00000011" =>
				   				state <= execute_jump;
							WHEN "00000100" =>
								state <= execute_update_display;
							WHEN "00000101" =>
				    			state <= execute_load;		
							WHEN "00000110" =>
				   				state <= execute_store;
							WHEN "00000111" =>
								state <= execute_add;
							WHEN "00001000" =>
								state <= execute_sub15;	
							WHEN OTHERS =>
								mar <= program_counter;
				    			state <= fetch;
						END CASE;
						
					WHEN execute_inC =>
						IF (inC = '1') THEN
							acumulador <= "0000000000000101";
						ELSE
							acumulador <= "0000000000000000";
						END IF;
						
						mar <= program_counter;
						state <= fetch;
					WHEN execute_inD =>
						IF (inD = '1') THEN
							acumulador <= "0000000000001010";
						ELSE 
							acumulador <= "0000000000000000";
						END IF;
						
						mar <= program_counter;
						state <= fetch;
						
					WHEN execute_store =>
						mdr_out <= acumulador;
						memory_write <= '1';
						
						state <= execute_store2;
					WHEN execute_store2 =>
						state <= execute_store3;
					WHEN execute_store3 =>
						memory_write <= '0';
						mar <= program_counter;
						state <= fetch;
						
					WHEN execute_load =>
						acumulador <= mdr;
						
						mar <= program_counter;
						state <= fetch;
						
					WHEN execute_add =>
						state <= execute_add2;
						
					WHEN execute_add2 =>
						state <= execute_add3;
						
					WHEN execute_add3 =>
						acumulador <= unsigned(acumulador) + unsigned(mdr);
						
						mar <= program_counter;
						state <= fetch;
					WHEN execute_verify =>
						IF (acumulador >= "0000000000001111") THEN
							libera_bombom <= '1';
						ELSE
							program_counter <= instruction_register(7 DOWNTO 0);
							mar <= program_counter;
						END IF;
						
						state <= fetch;
						
					WHEN execute_sub15 =>
						acumulador <= unsigned(acumulador) - 15;
						
						mar <= program_counter;
						state <= fetch;
					WHEN execute_update_Display =>
						IF (acumulador = "0000000000000000") THEN
							display1 <= "0000001";
							display2 <= "0000001";
						ELSIF (acumulador = "0000000000000101") THEN
							display1 <= "0000001";
							display2 <= "0100100";
						ELSIF (acumulador = "0000000000001010") THEN
							display1 <= "1001111";
							display2 <= "0000001";
						ELSIF (acumulador = "0000000000001111") THEN
							display1 <= "1001111";
							display2 <= "0100100";
						ELSIF (acumulador = "0000000000010100") THEN
							display1 <= "0010010";
							display2 <= "0000001";
						END IF;
						
						libera_bombom <= '0';
						
						mar <= program_counter;
						state <= fetch;						
					WHEN execute_jump =>
						program_counter <= instruction_register(7 DOWNTO 0);
						state <= fetch;
					WHEN OTHERS =>
						mar <= program_counter;
						memory_write <= '0';
						mar <= program_counter;
						state <= fetch;
						
				END CASE;
			END IF;
		END PROCESS;
END a;