RAPPORT DE CIRUIT PROGRAMMABLE

Réalisation d’une UAL avec le logiciel QUARTUS II

Réalisé par :
- Hafsa LAMRABAT n° 18
- Aya ZOUIRE n° 28
- Hajar DRISSI n° 8
- Mohamed BOUTAHRI n° 7

Encadré par :
- Pr .Yassine ELAAFOU

Année universitaire :
- 2024 / 2025

GESI II

0
 Introduction :
Ce rapport présente la réalisation d'une unité arithmétique et logique sur Quartus Altera, associée à un
afficheur à sept segments et une LCD pour afficher les résultats des opérations. L'unité arithmétique et logique,
capable d'effectuer des opérations de base telles que l'addition et la soustraction et les opérations logiques. Nous
détaillons les étapes de conception, la modélisation de ces opérations et l'interface avec l'afficheur à sept
segments. Enfin, les résultats de la simulation et de l'implémentation sur FPGA sont analysés pour valider
l'ensemble du système.

I. Réalisation d’une unité arithmétique et logique et affichage par LEDs :

- D’abord on choisit Cylone II et nom de la carte FPGA EP2C35672C6

- On commence par créer nouveau projet sur le logiciel Quartus Altera , puis on intègre le code VHDL
Apres avoir enregistré le code on l’a compilé .
- On clique après sur Pin planner dans lequel on a fait entré les données , pour chaque entrée et sortie du
code , on a attribué une LED .

1
 - Enfin on a validé les résultats du code sur le Kit alter, en obtenant les résultats compatibles .

Pour les entrées on a choisit les Pins suivants :

A[1] → Pin L4 , A[0] → Pin L5 , B[1] → Pin L8 , B[0] → Pin L7 , op[2] → Pin AB25 , op[1] → Pin AB26,
op[0] → Pin AA23

Pour les sorties on a choisit les Pins suivants :

result[1] → PinAK5 , result[0] → Pin AJ6 , Zero → PinAC13

▪ Le code utilisé :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL; -- Utilisation de la bibliothèque standard

entity UAL is
Port (
A : in STD_LOGIC_VECTOR(1 downto 0); -- Entrée A (2 bits)
B : in STD_LOGIC_VECTOR(1 downto 0); -- Entrée B (2 bits)

2
 SEL : in STD_LOGIC_VECTOR(2 downto 0); -- Signal de sélection (3 bits)
CLK : in STD_LOGIC; -- Horloge pour les bascules D
Y : out STD_LOGIC_VECTOR(3 downto 0) -- Résultat (4 bits pour gérer le débordement)
);
end UAL;

architecture Behavioral of UAL is

signal Temp : STD_LOGIC_VECTOR(3 downto 0); -- Signal temporaire pour le résultat
begin
-- Processus combinatoire pour les opérations
process(A, B, SEL)
begin
case SEL is
-- Addition
when "000" =>
Temp <= std_logic_vector(resize(unsigned(A) + unsigned(B), 4));

-- Soustraction
when "001" =>
Temp <= std_logic_vector(resize(unsigned(A) - unsigned(B), 4));

-- Multiplication
when "010" =>
Temp <= std_logic_vector(resize(unsigned(A) * unsigned(B), 4));

-- Complément de A (NOT A)
when "011" =>
Temp <= std_logic_vector(resize(not unsigned(A), 4));

-- NAND (A NAND B)
when "100" =>
Temp <= std_logic_vector(resize(not (unsigned(A) and unsigned(B)), 4));

-- XNOR (A XNOR B)
when "101" =>
Temp <= std_logic_vector(resize(not (unsigned(A) xor unsigned(B)), 4));

-- AND (A AND B)
when "110" =>
Temp <= std_logic_vector(resize(unsigned(A) and unsigned(B), 4));

-- OR (A OR B)
when "111" =>
Temp <= std_logic_vector(resize(unsigned(A) or unsigned(B), 4));

3
 -- Par défaut : sortie à 0
when others =>
Temp <= (others => '0');
end case;
end process;

-- Processus synchrone pour la bascule D

process(CLK)
begin
if rising_edge(CLK) then
Y <= Temp; -- Stocker le résultat à chaque front montant de l'horloge
end if;
end process;
end Behavioral;
▪ Résultat obtenus
Lorsque on met “op” a op[0] = 0 , op[ 1] = 0 , op[2] = 0 , et les entrées A et B a A[0] = 0 et A[ 1] = 0 et
B[0] = 0 et B[ 1] = 1
L’addition s’est effectuée et on a obtenu comme resultat [0] = 0 et resultat [ 1] = 1 alors oLEDR[ 1] va
s’allumer et ainsi de suite .

4
 II. Affichage de l’UAL sur l’afficheur 7 segments :
Dans cette partie on va réaliser l’unité arithmétique et logique avec le code VHDL de sorte que les résultats
s’affichent sur l’afficheur 7 segments de la carte FPGA.
➔ Le code VHDL :

Library IEEE;
use ieee_std_logic_1164.all;
use ieee_numeric_std.all;
Entity UAL
Port (A, B: in std_logic_vector (2 downto 0);
op: in std_logic_vector (2 downto 0),
result: buffer std_logic_vector (2 downto 0); -- entree et sortie a la fois
Zero: out std_logic;
Segments: out std_logic_vector (6 downto 0));
end UAL;
Architecture Behavioral of UAL is
function to_7seg ( input: std_logic_vector (2 downto 0)
return std_logic_vector is
Begin
case input is
when "000" => return "1111110 ";
when "001" => return "0110000";
when: "010" => return "1101101";
when "011"=> return "1111001";
when "100" => return "0110011";
when "101"=> return "1011011";
when "110" => return "1011111";
when "111" => return "1110000";
when others => return "0000000";
end case;
end function;

5
 begin
process (A, B, op)
variable temp_result: unsigned (2 downto 0);
begin
case op is
when "000" => temp_result <= unsigned (A) + unsigned (B);
result <= std_logic_vector (temp_result);
when" 001" => result <= A and B;
when "010" => result <= A or B;
when "011" => tamp_result <= unsigned(A) - unsigned (B);
result = std_logic_vector (temp-result);
when others => temp_result <= unsigned (A) + unsigned (B);
result <= std_logic-_vector (temp_result);
end case,
if result <= "000" then zero='1';
else zero <= '0';
end if;
segments <= to_7seg (result);
end process;
end Behavioral;

➔ Association des pins pour connecter le code dans Quartus avec la carte Alter :
- Pour les entrées on a choisi les pins suivants :
A[2] → Pin_AC27, A[1] → Pin_L4 , A[0] → Pin_L5 , B[2] → Pin_T9, B[1] → Pin_L8 , B[0] →
Pin_L7 , op[2] → Pin_ AB25 , op[1] → Pin_AB26, op[0] → Pin_AA23, result[2]
- Pour les sorties on a choisi les Pins suivants :
segments[6] → Pin_AD12 , segments[5] → Pin_AD11 , segments[4] → Pin_AF10, segments[3] →
Pin_AD10, segments[2] → Pin_AH9, segments[1] → Pin_AF9, segments[0] → Pin_AE8, Zero → PinAC13
-

6
III. Intégration de l’unité arithmétique et logique ave LCD
➢ Description générale de LCD

Un circuit programmable LCD (Liquid Crystal Display) est un circuit électronique conçu pour contrôler et
afficher des informations sur un écran LCD. Cela peut être décrit comme un circuit programmable pour écran
LCD.

Un tel circuit permet de :

• Contrôler les segments d’un écran LCD.

• Programmer différents modes d’affichage.
• Gérer des fonctions comme l’intensité, le contraste, et les animations.
• Communiquer avec des microcontrôleurs ou des microprocesseurs via des protocoles comme I²C, SPI
ou UART.

➢ Composants typiques :

1. Écran LCD : Un écran à cristaux liquides qui affiche des données visuelles.
2. Microcontrôleur : Gère la logique et envoie les signaux nécessaires à l’écran.
3. Pilote LCD : Une puce dédiée pour interfacer le microcontrôleur avec l’écran LCD.
4. Alimentation : Fournit l'énergie nécessaire pour le fonctionnement du circuit.
5. Interfaces programmables : Permettent d'envoyer des instructions (par exemple, programmation via
Arduino, Raspberry Pi, etc.).

➢ Utilisation typique :

• Montres numériques et horloges.

• Afficheurs dans les appareils électroménagers.
• Panneaux de contrôle pour l'électronique industrielle.
• Projets de développement DIY.

➔ Intégrer une unité arithmétique et logique (UAL) avec un LCD pour afficher les résultats des
opérations peut être réalisé en combinant une conception VHDL pour l'UAL et une interface pour
contrôler l'affichage LCD. Voici un guide pour y parvenir.

7
➢ Étapes principales

1. UAL (Unité Arithmétique et Logique) :

o Créez une unité en VHDL capable d'effectuer des opérations de base (addition, soustraction,
AND, OR, etc.).
o L'UAL aura des entrées pour les opérandes et une sortie pour le résultat.
2. Interface LCD :
o Configurez une interface en VHDL pour communiquer avec un écran LCD (généralement en
mode 4 bits ou I2C).
o Envoyez les données calculées par l'UAL vers l'écran pour les afficher.
3. Top-level (Intégration) :
o Connectez l'UAL et l'interface LCD dans un module principal.
o Ajoutez une logique pour sélectionner les opérations et afficher le résultat sur le LCD.

➢ Code VHDL
1. UAL (Unité Arithmétique et Logique) :

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

entity UAL_2bits is

Port (

A : in STD_LOGIC_VECTOR(1 downto 0); -- Opérande A

B : in STD_LOGIC_VECTOR(1 downto 0); -- Opérande B

Op : in STD_LOGIC_VECTOR(1 downto 0); -- Code de l'opération : 00=Add, 01=AND,

10=OR

Result : out STD_LOGIC_VECTOR(1 downto 0) -- Résultat de l'opération

);

end UAL_2bits;

8
 architecture Behavioral of UAL_2bits is

begin

process (A, B, Op)

begin

case Op is

when "00" => Result <= std_logic_vector(unsigned(A) + unsigned(B)); -- Addition

when "01" => Result <= A and B; -- AND

when "10" => Result <= A or B; -- OR

when others => Result <= (others => '0'); -- Valeur par défaut

end case;

end process;

end Behavioral;

2. Interface LCD simplifiée

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

entity LCD_Interface_2bits is

Port (

clk : in STD_LOGIC; -- Horloge

reset : in STD_LOGIC; -- Réinitialisation

data : in STD_LOGIC_VECTOR(1 downto 0); -- Données à afficher (2 bits)

lcd_rs : out STD_LOGIC; -- Signal Register Select

lcd_rw : out STD_LOGIC; -- Lecture/Écriture (0 = Écriture)

lcd_e : out STD_LOGIC; -- Signal Enable

lcd_data : out STD_LOGIC_VECTOR(3 downto 0) -- Données en mode 4 bits

9
 );

end LCD_Interface_2bits;

architecture Behavioral of LCD_Interface_2bits is

signal init_done : STD_LOGIC := '0'; -- Indique si le LCD est initialisé

signal current_state : STD_LOGIC_VECTOR(3 downto 0); -- État du FSM pour l'envoi

begin

process (clk, reset)

begin

if reset = '1' then

init_done <= '0';

current_state <= (others => '0');

elsif rising_edge(clk) then

if init_done = '0' then

-- Logique d'initialisation du LCD (à compléter selon datasheet)

init_done <= '1'; -- Initialisation terminée

else

-- Convertir les 2 bits en une forme lisible pour le LCD

case data is

when "00" => lcd_data <= "0000"; -- Affiche 0

when "01" => lcd_data <= "0001"; -- Affiche 1

when "10" => lcd_data <= "0010"; -- Affiche 2

when "11" => lcd_data <= "0011"; -- Affiche 3

when others => lcd_data <= "1111"; -- Valeur par défaut

end case;

lcd_rs <= '1'; -- Envoi de données

10
 lcd_rw <= '0'; -- Écriture

lcd_e <= '1'; -- Pulse Enable (à gérer dans le temps réel)

end if;

end if;

end process;

end Behavioral;

3. Intégration (Top-Level Module)

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

entity UAL_LCD_System_2bits is

Port (

clk : in STD_LOGIC;

reset : in STD_LOGIC;

A : in STD_LOGIC_VECTOR(1 downto 0); -- Opérande A

B : in STD_LOGIC_VECTOR(1 downto 0); -- Opérande B

Op : in STD_LOGIC_VECTOR(1 downto 0); -- Opération

lcd_rs : out STD_LOGIC; -- LCD Register Select

lcd_rw : out STD_LOGIC; -- LCD Read/Write

lcd_e : out STD_LOGIC; -- LCD Enable

lcd_data : out STD_LOGIC_VECTOR(3 downto 0) -- LCD Data

);

end UAL_LCD_System_2bits;

architecture Structural of UAL_LCD_System_2bits is

11
 signal result : STD_LOGIC_VECTOR(1 downto 0); -- Résultat de l'UAL

begin

-- Instanciation de l'UAL

UAL_inst : entity work.UAL_2bits

port map (

A => A,

B => B,

Op => Op,

Result => result

);

-- Instanciation de l'interface LCD

LCD_Interface_inst : entity work.LCD_Interface_2bits

port map (

clk => clk,

reset => reset,

data => result, -- Envoi du résultat au LCD

lcd_rs => lcd_rs,

lcd_rw => lcd_rw,

lcd_e => lcd_e,

lcd_data => lcd_data

);

end Structural;

➔ Interprétation :

Le module principal intègre l'UAL et l'interface LCD :

• Les entrées A, B, et Op sont transmises à l'UAL pour le calcul.

12
 • La sortie Result de l'UAL est connectée à l'entrée data de l'interface LCD.

Cela signifie que tout résultat produit par l'UAL sera automatiquement envoyé au LCD pour affichage.

Ce module gère la coordination de tout le système. Par exemple :

Si A = "11" (3 en décimal), B = "01" (1 en décimal), et Op = "01" (AND logique), le résultat sera "01" (1
en décimal), qui sera affiché sur le LCD.

➢ Conclusion

Au terme de ce projet, la conception et la réalisation d’une unité arithmétique et logique (UAL) sur un
circuit programmable ont permis de démontrer l’efficacité des FPGA dans le traitement et l’affichage de
résultats complexes. Les fonctionnalités implémentées, notamment l’exécution d’opérations arithmétiques et
logiques, ainsi que l’affichage des résultats sur des LED, un afficheur 7 segments, et un écran LCD, ont montré
la flexibilité et la polyvalence des circuits programmables.

13