mini projet vhdl - freeseb.france.free.fr/eseo/i2/vhdl/rapport-mp-vhdl-i2.pdf · 2006-03-28 · 1....

1

Mini projet

VHDL

( http://seb.france.free.fr/eseo/I2/vhdl )

Professeur responsable : Daniel GENET

Etudiants I2 : Sébastien FRANÇOIS

Yvonnick BRUNET

2

SOMMAIRE

1. Introduction 3

2. Spécifications 3

1) Description fonctionnelle 3

2) Implémentation 3

3) Vue externe 4

4) Structure interne 4

5) Schéma structurel du projet (architecture PAINT) 5

6) Détail des blocs 6

1) SOURIS 6

2) COLORATION 6

3) ADRESSEURMUX 7

4) VGASIGNALS 8

5) CTRL_VGA 9

6) DIVISEUR 9

7) CURSEUR 10

3. Grafcet de la partie séquentielle 11

4. Taux d’occupation du circuit cible 11

5. Listing commenté du code VHDL 12

1) COLORATION.vhd 12

2) ADRESSEURMUX.vhd 13

3) VGASIGNALS.vhd 14

4) DIVISEUR.vhd 15

5) CURSEUR.vhd 16

6) PROJET_PAINT.vhd 17

6. Conclusion 19

3

1. Introduction

Nous avons choisi de réaliser un programme inspiré du logiciel Paint de Microsoft. Le but est

de pouvoir dessiner une image sur un écran à l’aide d’une souris. Nous avons décidé que le

dessin s’effectuerait pixel par pixel pour en simplifier la mise en oeuvre, le dessin par

méthode vectorielle ou interpolée nécessitant des calculs de coefficients directeurs.

L’objectif du mini-projet est de concevoir puis développer une application VHDL embarquée

sur une carte prototype Xilinx.

2. Spécifications

1) Description fonctionnelle

Notre dispositif permet de dessiner, il comporte une souris et un écran d’ordinateur. Lors d’un

clic, on applique une couleur à l’endroit où se situe le curseur. Nous avons attribué une

couleur par bouton. Il nous faudra donc gérer les mouvements de la souris, les couleurs, ainsi

que la modification des pixels de l’image.

2) Implémentation

Nous utiliserons une carte d’évaluation à base de FPGA XILINX SPARTAN3 XC3S200 de

200 000 portes cadencé à 50MHz. Parmi les périphériques inclus sur la carte, nous utiliserons

la sortie VGA ainsi que le port PS/2. Il nous faudra aussi utiliser la SRAM disponible sur la

carte pour créer un tampon graphique.

Nous stockerons la couleur d’un pixel sur 3 bits, pour une image de 400x262, chaque pixel

sera codé sur un octet, soit environ 102ko. Nous configurerons donc la SRAM pour n’utiliser

qu’un seul boîtier (mot de 16 bits) puis en activant seulement l’octet de poids faible. Il nous

faudra par la suite gérer lorsque l’écran tente d’accéder à des adresses hors de la RAM.

Ces ressources seront affectées de la manière suivante :

- déplacement du curseur selon les mouvements de la souris

- affectation de la couleur de dessin à un pixel lors d’un clic

- choix de la couleur de dessin

- utilisation de la zone mémoire pour stocker l’image affichée à l’écran

- balayage de la mémoire et génération des signaux de contrôle de l’écran.

4

3) Vue externe

4) Structure interne

Nous aurons besoin en plus du séquenceur des blocs suivants :

- un composant souris qui en gère l’initialisation (PS/2) et nous fournit sa position dans

un espace 800x525 ainsi que l’état de ses boutons (souris)

- un bloc gérant la coloration des pixels (coloration)

- un contrôleur de SRAM (adresseurmux)

- un bloc gérant la décomposition des pixels lus en mémoire pour générer les signaux R,

V et B (vgasignals)

- un contrôleur d’affichage RGB générant l’ensemble des signaux de contrôle : les

composantes rouge, verte et bleue ainsi que les informations de synchronisation

verticales et horizontales (ctrl_vga)

Il nous faudra utiliser un diviseur de fréquence pour activer ce dernier bloc, la norme

VGA nous impose d’utiliser une fréquence de 25MHz.

Souris

PS2 SRAM

5

5) Schéma structurel du projet (architecture PAINT)

6

6) Détail des blocs

1) SOURIS

Description fonctionnelle

Le code gérant la souris PS/2 nous est fourni, ce bloc procède à l’initialisation, puis nous

permet d’accéder directement aux coordonnées de la souris ainsi qu’à l’état de ses boutons.

Les coordonnées de la souris sont exprimées dans un espace de 800x525, nous les utiliserons

directement pour adresser la RAM.

Vue externe

2) COLORATION


Ce bloc a pour fonction, lors d’un clic droit ou gauche (BD ou BG), de sélectionner la couleur

de dessin.

Vue externe

Structure interne

Un appui sur le bouton droit (CLICKD) ou le bouton gauche (CLICKG) définit la valeur qui

sera écrite en ram ce qui permettra d’avoir trois couleurs.

Les couleurs associées aux boutons sont définies sous la forme de signaux internes au bloc,

nommés couleurd (bouton droit) et couleurg (bouton gauche). Un xor entre ces deux couleurs

est effectué si les deux boutons sont appuyés simultanément.

Schéma structurel

7

3) ADRESSEURMUX


Ce bloc contient l’ensemble des multiplexeurs servant à l’adressage de la ram mais aussi à

l’aiguillage des données sortant de la RAM.

Le premier a pour fonction, pendant que l’écran n’est pas dessiné (blanking), et lors d’un clic

(BG ou BG), de convertir les coordonnées de la souris (X1 et Y2) afin de fournir l’adresse en

RAM où l’on va stocker la couleur (XYout). Lorsque l’on dessine vers l’écran, il fournit

l’adresse en RAM du pixel à afficher, cette adresse est calculée grâce aux signaux fournis par

ctrl_vga et entrant sur X2 et Y2.

Le deuxième gère l’entrée des données dans la RAM, pendant sa remise à zéro, il place les

broches de données à 0. Ensuite pendant l’affichage de l’écran il déconnecte le bloc coloration

de la RAM afin qu’il n’y ait pas de court-circuit pendant sa lecture. Pendant la période de

blanking, il connecte le bloc coloration à la RAM afin que le pixel dessiné y soit stocké.

Nous avons inséré dans ce bloc du code remettant à zéro le contenu de la RAM lors d’une

RAZ, et ce, afin qu’elle ne contienne pas de valeurs aléatoires à sa mise sous tension. Durant

cette mise à zéro, le signal progress est à ‘1’.

Vue externe

Structure interne

Un appui sur le bouton droit (CLICKD) ou le bouton gauche (CLICKG) définit la valeur qui

sera écrite en ram ce qui permettra d’avoir deux couleurs ou un crayon et une gomme.

Les coordonnées X et Y du curseur nous permettent de calculer l’adresse en RAM.

8

Schéma structurel

Bloc de gestion de l’adressage de la RAM

Bloc de gestion des données fournies à la RAM

Bloc de remise à zéro du contenu de la RAM

4) VGASIGNALS


Ce bloc a pour fonction de préparer les signaux de couleur à être envoyés à l’écran.

Vue externe

Structure interne

Le vecteur de bits contenant les composantes de couleur de chaque pixel (VGAout) est

décomposé en trois signaux distincts (R, G, B) destinés à l’écran.

La norme indique que ces trois signaux doivent être mis à zéro pendant la période où l’écran

n’est pas dessiné (blanking).

9

Schéma structurel

5) CTRL_VGA


Le code gérant les signaux de contrôle de l’écran nous est fourni. Il fonctionne pour résolution

VGA (640x480). Il nous fournit les signaux de synchronisation verticale et horizontale

(V_SYNC et H_SYNC) nécessaires au bon fonctionnement de l’écran, mais aussi deux

entiers, X et Y, parcourant les valeurs de 0, 0 à 799, 524. Ceux-ci nous servent à balayer le

contenu de la ram pour sortir les pixels vers l’écran. La broche EN nous permet de désactiver

le bloc de manière à ce que la valeur en sortie soit figée. Ceci est nécessaire car l’horloge du

système fonctionne à 50 MHz tandis que les données VGA doivent être fournies à 25 MHz.

Vue externe

6) DIVISEUR


Ce bloc a pour fonction de ralentir les signaux envoyés à l’écran. En effet pour contrôler

celui-ci on doit le piloter à 25 Mhz, il suffit donc de diviser par deux l’horloge de notre

système. On va créer un simple diviseur de fréquence qui ira ensuite activer ou désactiver le

bloc ctrl_vga.

Vue externe

Structure interne

Nous avons utilisé ici un simple compteur synchrone sur 2 bits dont on prélève le bit de poids

fort.

10

Schéma structurel

7) CURSEUR


Ce bloc a pour fonction d’afficher un point représentant le curseur de la souris, nous

permettant de localiser la position sur l’écran. Pour cela, il faut comparer la position de la

souris et des coordonnées de l’écran.

Vue externe

Structure interne

On compare en permanence les coordonnées du point dessiné (XPIX, YPIX) et les

coordonnées de la souris (XP, YP). Lorsqu’il y a égalité, on inverse la couleur lue en ram, ce

qui nous permet de différencier le curseur de l’image dans tous les cas possibles. En revanche,

lorsqu’il n’y a pas d’égalité on ne fait rien. Les couleurs sont directement transmises au bloc

suivant.

Schéma structurel

11

3. Grafcet de la partie séquentielle

CS_CPT : Mise à zéro synchrone de CPT

EN_CPT : Validation d’incrémentation du compteur CPT

Dataram <= "000" : Mise à zéro de chaque case mémoire

progress : flag indiquant une remise à zéro de RAM en cours

INIT_SRAM : initialisation de la ram

Lors d’une remise à zéro, le signal progress est validé, il active notamment l’écriture en RAM

dans le bloc racine.

On met alors à zéro le bus de données de la RAM tandis que le compteur CPT est incrémenté

jusqu’à ce qu’il soit égal aux 400*262 cases utilisées, remettant ainsi chaque case de la RAM

à zéro. On redonne la main au programme principal.

4. Taux d’occupation du circuit cible Device utilization summary:

---------------------------

Selected Device : 3s200ft256-5

Number of Slices: 150 out of 1920 7%

Number of Slice Flip Flops: 97 out of 3840 2%

Number of 4 input LUTs: 267 out of 3840 6%

Number of bonded IOBs: 39 out of 173 22%

Number of GCLKs: 1 out of 8 12%

12

5. Listing commenté du code VHDL

1) COLORATION.vhd ---------------------------------------------------------------------------

-- Company: ESEO

-- Engineer: BRUNET Yvonnick & Sébastien FRANÇOIS

--

-- Create Date: 09:54:45 01/04/06

-- Module Name: COLORATION - Behavioral

-- Project Name: Paint

-- Target Device: Spartan 3

-- Description: Bloc de gestion de la couleur et de l'affectation aux

-- boutons de la souris

--

-- Revision:

-- Revision 0.01 - File Created

---------------------------------------------------------------------------

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_ARITH.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity COLORATION is

Port ( BG : in std_logic;

BD : in std_logic;

data : out std_logic_vector(2 downto 0));

end COLORATION;

architecture Behavioral of COLORATION is

signal couleurd : std_logic_vector (2 downto 0);

signal couleurg : std_logic_vector (2 downto 0);

signal boutons : std_logic_vector (1 downto 0);

begin

couleurg <= "100"; -- couleur click gauche

couleurd <= "110"; -- couleur click droit

boutons(0)<=BD;

boutons(1)<=BG;

with boutons select

data <= couleurd when "01",

couleurg when "10",

couleurd xor couleurg when "11",

"000" when others;

-- on fournit en sortie la couleur sélectionnée

end Behavioral;

13

2) ADRESSEURMUX.vhd ---------------------------------------------------------------------------

-- Company: ESEO


--

-- Create Date: 08:24:19 01/04/06

-- Module Name: ADRESSEURMUX - Behavioral



-- Description: Effectue le multiplexage d'adresse pour la SRAM

-- pour permettre l'écriture puis la lecture

--

-- Revision:


---------------------------------------------------------------------------

library IEEE;




entity ADRESSEURMUX is

Port (

CLK, RAZ : in std_logic;

X1 : in integer range 0 to 799;

Y1 : in integer range 0 to 524;



XYout : out std_logic_vector(17 downto 0);

progress : inout std_logic;

blanking, BD, BG : in std_logic;

ColorIN : in std_logic_vector(2 downto 0);

ColorRAM : out std_logic_vector(2 downto 0)

);

end ADRESSEURMUX;

architecture Behavioral of ADRESSEURMUX is

signal X : std_logic_vector (8 downto 0);

signal Y : std_logic_vector (8 downto 0);

signal CPT : std_logic_vector(17 downto 0);

begin

-- MUX 1 Les coordonnées adressent directement en mémoire

X<=CONV_STD_LOGIC_VECTOR(X1/2,9) when blanking = '1'

else CONV_STD_LOGIC_VECTOR(X2/2,9);

Y<=CONV_STD_LOGIC_VECTOR(Y1/2,9) when blanking = '1'

else CONV_STD_LOGIC_VECTOR(Y2/2,9);

XYout(17 downto 9) <= CPT(17 downto 9) when progress = '1' else Y;

XYout(8 downto 0) <= CPT (8 downto 0) when progress = '1' else X;

-- MUX 2 Les données de couleur peuvent être mises à zéro ou

-- aiguillées entre le bloc de dessin et la SRAM

ColorRAM <= "000" when progress = '1' else

ColorIN when (BD or BG) = '1' and blanking = '1' and progress = '0'

else (others => 'Z') ;

14

-- Bloc séquentiel de remise à zéro du contenu de la SRAM,

-- l'exécution commence ici!

P_RAZRAM : process(CLK, RAZ)

begin

if RAZ = '1' then

progress <= '1';

elsif CLK'event and CLK = '1' then

if(progress = '1') then

CPT <= CPT+1;

if CPT = CONV_STD_LOGIC_VECTOR(400*262,18) then

progress <= '0';

-- on parcourt les 400*262 cases

end if;

end if;

end if;

end process P_RAZRAM;

end Behavioral;

3) VGASIGNALS.vhd ---------------------------------------------------------------------------

-- Company: ESEO


--

-- Create Date: 10:13:32 01/04/06

-- Module Name: VGASignals - Behavioral



-- Description: Décompose un vecteur de bits en trois informations

-- R, G et B pour l'écran avec possibilité de neutralisation

-- lorsque blanking = 1

--

-- Revision:


---------------------------------------------------------------------------

library IEEE;




entity VGASignals is

Port ( VGAout : in std_logic_vector(2 downto 0);

blanking : in std_logic;

R : out std_logic;

G : out std_logic;

B : out std_logic);

end VGASignals;

architecture Behavioral of VGASignals is

begin

R <= '0' when blanking = '1'

else VGAout(2);

G <= '0' when blanking = '1'

else VGAout(1);

B <= '0' when blanking = '1'

else VGAout(0);

end Behavioral;

15

4) DIVISEUR.vhd

---------------------------------------------------------------------------

-- Company: ESEO


--

-- Create Date: 10:21:37 01/04/06

-- Module Name: Diviseur - Behavioral



-- Description: Génère un signal synchrone à 25 MHz

--

-- Revision:


---------------------------------------------------------------------------

library IEEE;




entity Diviseur is

Port ( input,raz : in std_logic;

output : out std_logic);

end Diviseur;

architecture Behavioral of Diviseur is

signal cpt : std_logic_vector(1 downto 0);

begin

P_CPT : process(raz,input)

begin

if raz = '1' then cpt <= "00"; -- compteur 2 bits RAZ asynchrone

elsif input'event and input = '1' then

if(cpt<3) then

cpt <= cpt+1;

else

cpt <= "00";

end if;

end if;

end process P_CPT;

output <= cpt(1); -- on prélève le bit de poids fort

end Behavioral;

16

5) CURSEUR.vhd

---------------------------------------------------------------------------

-- Company: ESEO


--

-- Create Date: 11:24:34 01/09/06

-- Module Name: curseur - Behavioral



-- Description: Superpose un pixel en video inversée à l'emplacement du curseur

-- traitement fait directement au niveau de l'image

--

-- Revision:


---------------------------------------------------------------------------

library IEEE;




entity curseur is

Port ( XP : in integer range 0 to 799;

YP : in integer range 0 to 524;

XPIX : in integer range 0 to 799;

YPIX : in integer range 0 to 524;

imgin : in std_logic_vector(2 downto 0);

imgout : out std_logic_vector(2 downto 0));

end curseur;

architecture Behavioral of curseur is

begin

imgout <= not(imgin) when (XPIX<=XP) and (XP<XPIX+4) and (YPIX<=YP) and

(YP<YPIX+4) else imgin;

-- video inversée pour le curseur de 8x8 pixels

end Behavioral;

17

6) PROJET_PAINT.vhd ---------------------------------------------------------------------------

-- Company: ESEO


--

-- Create Date: 08:03:48 01/04/06

-- Module Name: projet_paint - Behavioral



-- Description: Ce composant permet de dessiner à l'aide d'une souris

-- sur un écran d’ordinateur

--

-- Dependencies: ADRESSEUR, COLORATION, CTRL_VGA, DIVISEUR, SOURIS,

-- VGASIGNALS, CURSEUR

--

-- Revision:


---------------------------------------------------------------------------

library IEEE;




entity projet_paint is

Port ( RAZ : in std_logic;

CLK : in std_logic;

R : out std_logic;

G : out std_logic;

B : out std_logic;

H_SYNC : out std_logic;

V_SYNC : out std_logic;

Data_Mouse : inout std_logic;

Clk_Mouse : in std_logic;

we, oe, ce1, ub1, lb1, ce2 : out std_logic;

dataram : inout std_logic_vector(2 downto 0);

address : out std_logic_vector(17 downto 0));

-- Affectations des broches sur la carte

attribute loc : string;

attribute loc of CLK : signal is "T9";

attribute loc of RAZ : signal is "L14";

attribute loc of Data_Mouse : signal is "M15";

attribute loc of Clk_Mouse : signal is "M16";

attribute loc of R : signal is "R12";

attribute loc of G : signal is "T12";

attribute loc of B : signal is "R11";

attribute loc of we : signal is "G3"; -- Write Enable conditionné

attribute loc of oe : signal is "K4";

-- Output Enable permanent à 0

attribute loc of ce1 : signal is "P7"; -- à mettre à 0

attribute loc of ub1 : signal is "T4"; -- à mettre à 1

attribute loc of lb1 : signal is "P6"; -- à mettre à 0

attribute loc of ce2 : signal is "N5"; -- à mettre à 1

attribute loc of dataram : signal is "R6,T8,N7";

attribute loc of address : signal is

"L3,K5,K3,J3,J4,H4,H3,G5,E4,E3,F4,F3,G4,L4,M3,M4,N3,L5";

end projet_paint;

18

architecture Behavioral of projet_paint is

----

-- COMPONENTS

----

component CTRL_VGA is

port(CLK,EN: in std_logic;

H_SYNC,V_SYNC,BLANKING: out std_logic;

X: out integer range 0 to 799;

Y: out integer range 0 to 524);

end component;

component COLORATION is

Port ( BG : in std_logic;

BD : in std_logic;

data : out std_logic_vector(2 downto 0));

end component;

component souris is

port (clock, raz : in std_logic;

MOUSE_DATA : inout std_logic;

MOUSE_CLK : in std_logic;

XP : out integer range 0 to 799;

YP : OUT integer range 0 to 524;

BG : out std_logic;

BD : out std_logic);

end component;

component ADRESSEURMUX is

Port ( CLK, RAZ : in std_logic;





XYout : out std_logic_vector(17 downto 0);

progress : inout std_logic;

blanking, BD, BG : in std_logic;

ColorIN : in std_logic_vector(2 downto 0);

ColorRAM : out std_logic_vector(2 downto 0));

end component;

component VGASignals is

Port ( VGAout : in std_logic_vector(2 downto 0);

blanking : in std_logic;

R : out std_logic;

G : out std_logic;

B : out std_logic);

end component;

component Diviseur is

Port ( input,raz : in std_logic;

output : out std_logic);

end component;

component curseur is

Port ( XP : in integer range 0 to 799;

YP : in integer range 0 to 524;

XPIX : in integer range 0 to 799;

YPIX : in integer range 0 to 524;

imgin : in std_logic_vector(2 downto 0);

imgout : out std_logic_vector(2 downto 0));

end component;

19

signal BD,BG : std_logic;

signal XP : integer range 0 to 799; -- coordonnées de la souris

signal YP : integer range 0 to 524;

signal XPIX : integer range 0 to 799; -- coordonnées du pixel dessiné

signal YPIX : integer range 0 to 524;

signal sel : std_logic; -- bascule le dessin ou l'affichage

signal colordraw : std_logic_vector(2 downto 0);

-- lien entre coloration et adresseurmux

signal image : std_logic_vector(2 downto 0);

-- lien entre la sortie du curseur et vgasignals

signal progress, blanking: std_logic;

begin

ce2 <= '1';

ce1 <= '0'; -- selection du premier bloc de SRAM

ub1 <= '1'; -- lecture de l'octet de poids faible

lb1 <= '0';

we <= '0' when ((BG or BD) = '1' and blanking = '1') or progress = '1' else

'1';

-- écriture active après un clic pendant que l'on ne

-- dessine pas ou bien pendant la remise à zéro de la SRAM

oe <= '0';

-- Instanciation des composants

U0 : SOURIS port map(clock => CLK, raz => RAZ, MOUSE_CLK => Clk_Mouse,

MOUSE_DATA => Data_Mouse, BD => BD, BG => BG, XP => XP,

YP => YP);

U1 : ADRESSEURMUX port map(CLK => CLK, RAZ => RAZ, X1 => XP, Y1 => YP, X2

=> XPIX, Y2 => YPIX, ColorIN => colordraw, ColorRAM => dataram,

XYout => address, progress => progress, blanking => blanking, BD =>

BD, BG => BG);

U2 : CTRL_VGA port map(CLK => CLK, EN => sel, H_SYNC => H_SYNC, V_SYNC =>

V_SYNC, blanking => blanking, X => XPIX, Y => YPIX);

U3 : COLORATION port map(BD => BD, BG => BG, data => colordraw);

U4 : VGASignals port map(VGAout => image, blanking => blanking, R => R, G

=> G, B => B);

U5 : Diviseur port map(raz => RAZ, input => CLK, output => sel);

U6 : curseur port map(imgin => dataram, imgout => image, XP => XP,

XPIX => XPIX, YP => YP, YPIX => YPIX);

end Behavioral;

6. Conclusion

Le sujet nous a beaucoup intéressés car nous avons pu nous pencher sur la mise en œuvre

d’un framebuffer et d’un curseur matériel.

Nous avons apporté de l’attention à la conception des blocs fonctionnels sur papier. Ainsi,

après avoir établi la structure du programme, nous avons pu facilement définir les blocs, et

plus tard lorsque nous avons fait des corrections, il nous a suffi d’adapter le schéma interne.

Dans un premier temps, nous avions omis de remettre à zéro le contenu de la SRAM. A la

mise sous tension, l’écran affichait des couleurs aléatoires. Nous avons ajouté du code dans le

bloc Adresseurmux pour y remédier. La remise à zéro de la RAM mériterait un bloc

spécifique.

Nous avons été surpris de voir la vitesse avec laquelle ce projet a pu prendre forme, comparé

par exemple au temps qu’il faudrait pour réaliser le même projet à base de programmation de

microprocesseur. Une fois le modèle établi, le passage du modèle au VHDL s’est effectué

sans problème.

mini projet vhdl - freeseb.france.free.fr/eseo/i2/vhdl/rapport-mp-vhdl-i2.pdf · 2006-03-28 · 1....

Documents