ALU :

entity alu_8bit is
port (
opcode : in std_logic_vector(2 downto 0); -- Opcode pour sélectionner l'opération
ALU
operand_a : in std_logic_vector(7 downto 0); -- Opérande A
operand_b : in std_logic_vector(7 downto 0); -- Opérande B
result : out std_logic_vector(7 downto 0); -- Résultat de l'opération ALU
carry_out : out std_logic; -- Indicateur de retenue
digit_carry_out : out std_logic; -- Indicateur de retenue de chiffre
zero : out std_logic -- Indicateur de zéro
);
end entity alu_8bit;

architecture behavioral of alu_8bit is

signal temp_result : unsigned(7 downto 0); -- Signal temporaire pour stocker le
résultat intermédiaire
signal temp_carry_out : std_logic; -- Signal temporaire pour l'indicateur de
retenue
signal temp_digit_carry_out : std_logic; -- Signal temporaire pour l'indicateur de
retenue de chiffre
begin
process(opcode, operand_a, operand_b)
begin
case opcode is
when "000" => -- Addition
temp_result <= unsigned(operand_a) + unsigned(operand_b);
temp_carry_out <= '1' when temp_result(8) = '1' else '0'; -- Détermine si une
retenue est générée
temp_digit_carry_out <= '1' when temp_result(3) = '1' else '0'; -- Détermine si
une retenue de chiffre est générée
when "001" => -- Subtraction
temp_result <= unsigned(operand_a) - unsigned(operand_b);
temp_carry_out <= '0' when operand_a >= operand_b else '1'; -- Détermine si une
retenue est générée
temp_digit_carry_out <= '0' when operand_a(3 downto 0) >= operand_b(3 downto 0)
else '1'; -- Détermine si une retenue de chiffre est générée
when "010" => -- Shift Left
temp_result <= shift_left(unsigned(operand_a), 1);
temp_carry_out <= operand_a(7); -- Détermine si le bit de retenue est généré
temp_digit_carry_out <= '0'; -- Aucune retenue de chiffre générée pour le décalage
when "011" => -- Shift Right
temp_result <= shift_right(unsigned(operand_a), 1);
temp_carry_out <= operand_a(0); -- Détermine si le bit de retenue est généré
temp_digit_carry_out <= '0'; -- Aucune retenue de chiffre générée pour le décalage
when "100" => -- Logical AND
temp_result <= unsigned(operand_a) and unsigned(operand_b);
temp_carry_out <= '0'; -- Aucune retenue générée pour l'opération logique
temp_digit_carry_out <= '0'; -- Aucune retenue de chiffre générée pour l'opération
logique
when "101" => -- Logical OR
temp_result <= unsigned(operand_a) or unsigned(operand_b);
temp_carry_out <= '0'; -- Aucune retenue générée pour l'opération logique
temp_digit_carry_out <= '0'; -- Aucune retenue de chiffre générée pour l'opération
logique
when "110" => -- Logical XOR
temp_result <= unsigned(operand_a) xor unsigned(operand_b);
temp_carry_out <= '0'; -- Aucune retenue générée pour l'opération logique
temp_digit_carry_out <= '0'; -- Aucune retenue de chiffre générée pour l'opération
logique
when "111" => -- Logical NOT
temp_result <= not unsigned(operand_a);
temp_carry_out <= '0'; -- Aucune retenue générée pour l'opération logique
temp_digit_carry_out <= '0'; -- Aucune retenue de chiffre générée pour l'opération
logique
when others =>
temp_result <= (others => '0'); -- Valeur par défaut si l'opcode n'est pas reconnu
temp_carry_out <= '0'; -- Aucune retenue générée
temp_digit_carry_out <= '0'; -- Aucune retenue de chiffre générée
end case;
end process;

result <= std_logic_vector(temp_result); -- Conversion du résultat en

std_logic_vector
carry_out <= temp_carry_out; -- Sortie de l'indicateur de retenue
digit_carry_out <= temp_digit_carry_out; -- Sortie de l'indicateur de retenue de
chiffre
zero <= '1' when temp_result = 0 else '0'; -- Détermine si le résultat est zéro
end architecture behavioral;

Program Memory :
entity program_memory is
port (
address : in std_logic_vector(8 downto 0); -- Adresse d'accès à la mémoire
programme
data_out : out std_logic_vector(11 downto 0) -- Données lues depuis la mémoire
programme
);
end entity program_memory;

architecture behavioral of program_memory is

type memory_array is array (0 to 255) of std_logic_vector(11 downto 0); -- Tableau
de mémoire pour les 256 premières adresses
constant program_memory_data : memory_array := (
-- Adresses de la mémoire programme avec les données correspondantes
-- Adresse 0000h
"XXXXXXXXXXXX", -- Données à remplir selon le programme
-- Adresse 0001h
"XXXXXXXXXXXX",
-- ... (remplir les données pour les adresses restantes)
-- Adresse 00FFh (Contient la valeur de calibration de l'oscillateur interne)
"XXXXXXXXXXXX"
);
begin
process(address)
begin
-- Lecture des données de la mémoire programme en fonction de l'adresse d'accès
data_out <= program_memory_data(to_integer(unsigned(address)));
end process;
end architecture behavioral;

Data Memory :
entity data_memory is
port (
address : in std_logic_vector(4 downto 0); -- Adresse d'accès à la mémoire de
données
data_in : in std_logic_vector(7 downto 0); -- Données à écrire dans la mémoire de
données
write_enable : in std_logic; -- Signal d'activation d'écriture
data_out : out std_logic_vector(7 downto 0) -- Données lues depuis la mémoire de
données
);
end entity data_memory;

architecture behavioral of data_memory is

type memory_array is array (0 to 30) of std_logic_vector(7 downto 0); -- Tableau
de mémoire pour les 31 registres
signal register_file : memory_array := (
-- Registres spéciaux (SFR)
-- Adresse 0 : PCL (Program Counter Low)
"00000000",
-- Adresse 1 : STATUS
"00000000",
-- Adresse 2 : GPIO (I/O register)
"00000000",
-- Adresse 3 : FSR (File Select Register)
"00000000",
-- ... (remplir les données pour les registres spéciaux restants)

-- Registres généraux (GPR)

-- Adresse 7 : GPR0
"00000000",
-- Adresse 8 : GPR1
"00000000",
-- ... (remplir les données pour les registres généraux restants)

-- Adresse 30 : Dernier registre général (GPR23)

"00000000"
);
begin
process(address, data_in, write_enable)
begin
-- Lecture des données depuis la mémoire de données en fonction de l'adresse
d'accès
data_out <= register_file(to_integer(unsigned(address)));

-- Écriture des données dans la mémoire de données si le signal d'activation

d'écriture est activé
if write_enable = '1' then
register_file(to_integer(unsigned(address))) <= data_in;
end if;
end process;
end architecture behavioral;

STATUS Register :
entity status_register is
port (
write_enable : in std_logic; -- Signal d'activation d'écriture
z_flag : in std_logic; -- Valeur du bit Z
dc_flag : in std_logic; -- Valeur du bit DC
c_flag : in std_logic; -- Valeur du bit C
data_out : out std_logic_vector(7 downto 0) -- Données lues depuis le registre
STATUS
);
end entity status_register;

architecture behavioral of status_register is

signal status : std_logic_vector(7 downto 0) := "00000000"; -- Registre STATUS
initialisé à 00000000
begin
process(write_enable, z_flag, dc_flag, c_flag)
begin
-- Lecture des données depuis le registre STATUS
data_out <= status;

-- Écriture des données dans le registre STATUS si le signal d'activation

d'écriture est activé
if write_enable = '1' then
-- Les bits Z, DC et C ne sont pas modifiables directement, donc ils sont
conservés dans le registre lors de l'écriture
status(7) <= '0'; -- Bit TO (non modifiable)
status(6) <= '0'; -- Bit PD (non modifiable)
status(5) <= z_flag; -- Bit Z
status(4) <= dc_flag; -- Bit DC
status(3) <= c_flag; -- Bit C
status(2 downto 0) <= "000"; -- Bits non modifiables
end if;
end process;
end architecture behavioral;

Comparator :
entity comparator is
port (
vin_p : in std_logic; -- Tension d'entrée positive du comparateur
vin_n : in std_logic; -- Tension d'entrée négative du comparateur
cmp_out : out std_logic, -- Sortie du comparateur
wake_up_flag : out std_logic -- Drapeau de réveil du comparateur
);
end entity comparator;

architecture behavioral of comparator is

signal cmp_out_internal : std_logic;
signal cmp_out_previous : std_logic;
signal wake_up_flag_internal : std_logic;
begin
process(vin_p, vin_n)
begin
-- Comparaison des tensions d'entrée
if vin_p = '1' and vin_n = '0' then
cmp_out_internal <= '1'; -- La tension d'entrée positive est supérieure à la
tension d'entrée négative
else
cmp_out_internal <= '0'; -- La tension d'entrée positive est inférieure ou égale à
la tension d'entrée négative
end if;

-- Détection du changement d'état de sortie du comparateur

if cmp_out_internal /= cmp_out_previous then
wake_up_flag_internal <= '1'; -- Le drapeau de réveil est activé lorsque l'état de
sortie change
else
wake_up_flag_internal <= '0';
end if;

cmp_out_previous <= cmp_out_internal;

end process;

-- Lecture de l'état de sortie du comparateur à travers le registre CMCON0 (non

implémenté en VHDL)
cmp_out <= cmp_out_internal;
wake_up_flag <= wake_up_flag_internal;
end architecture behavioral;

sequenceur & Decodeur :

entity sequence_decoder_block is
port (
clk : in std_logic;
reset : in std_logic;
enable : in std_logic;
output : out std_logic_vector(3 downto 0);
decoded_output : out std_logic_vector(7 downto 0)
);
end entity sequence_decoder_block;

architecture behavioral of sequence_decoder_block is

signal counter : unsigned(2 downto 0);
begin
process(clk, reset)
begin
if reset = '1' then
counter <= "000";
output <= (others => '0');
decoded_output <= (others => '0');
elsif rising_edge(clk) then
if enable = '1' then
counter <= counter + 1;
case counter is
when "000" =>
output <= "0001";
decoded_output <= "00000001";
when "001" =>
output <= "0010";
decoded_output <= "00000010";
when "010" =>
output <= "0100";
decoded_output <= "00000100";
when "011" =>
output <= "1000";
decoded_output <= "00001000";
when others =>
output <= (others => '0');
decoded_output <= (others => '0');
end case;
end if;
end if;
end process;
end architecture behavioral;