MISE EN ŒUVRE D'UN SOMMATEUR 8 BITS À L'AIDE DE XILINX

OBJECTIF :
Concevoir, simuler, synthétiser un additionneur de 8 bits en utilisant le codage Verilog et mettre en œuvre le même.
FPGA Xilinx.

APPAREIL REQUIS :
PC avec Windows
Xilinx 14.7
FPGA SPARTAN 3
CÂBLE JTAG

PROCÉDURE :
Ouvrir un nouveau projet, taper le nom du projet et vérifier le type de source de niveau supérieur comme HDL Entrer
les propriétés de l'appareil et cliquez sur Suivant
Cliquez sur Nouvelle Source et sélectionnez le module Verilog, puis donnez le nom du fichier
Donnez les noms des ports d'entrée et de sortie et cliquez sur terminer
Tapez le programme Verilog et enregistrez-le
Double-cliquez sur le synthétiseur XST et vérifiez la syntaxe
Simuler la forme d'onde par simulation comportementale
Pour la mise en œuvre, sélectionnez les contraintes de l'utilisateur et indiquez le numéro de broche des ports d'entrée et de sortie.

Cliquez sur Implémenter le design pour Traduire, mapper et placer & router
Générer un fichier .bit à l'aide d'un fichier de programmation
Implémentez dans le FPGA via un câble JTAG parallèle
Vérifiez le comportement du design dans le FPGA en donnant des entrées

ADDENDEUR 8 BIT
Additionneur complet :

module additionneur_complet(a,b,cin,s,cout);
entrer a,b;
entrée cin;
sortie s,cout;
câble out1, out2, out3, out4, out5, out6;
et (out1,a,b);
et (out2,out5,cin);
ou (out3, out2, out1);
attribuer cout = out3;
xor (out5,a,b);
xor (out6, out5, c);
assigner s = out6;
fin de module
Additionneur 8 bits :

module additionneur_8bit(a,b,cin,s,Retoursur);
entrée [7:0]a,b;
sortie [7:0]s;
Exécuter
entrée cin;
fil cout0, cout1, cout2, cout3, cout4, cout5, cout6;
full_adder c1(a[0],b[0],cin,s[0],cout0);
full_adder c2(a[1],b[1],cout0,s[1],cout1);
full_adder c3(a[2],b[2],cout1,s[2],cout2);
full_adder c4(a[3],b[3],cout2,s[3],cout3);
additionneur_complet
full_adder c6(a[5],b[5],cout4,s[5],cout5);
full_adder c7(a[6],b[6],cout5,s[6],cout6);
full_adder c8(a[7],b[7],cout6,s[7],Carryout);
endmodule

BANQUE D'ESSAI :
module FA_TEST;
// Entrées
reg [7:0] a;
reg [7:0] b;
règlement c;

// Sorties
fil [8:0] s;
fil co;

// Instancier l'Unité Sous Test (UST)

FA uut (
.a(a),
.b(b),
.c(c),
.s(s),
.co(co)
);
début initial
// Initialiser les entrées
a = 0;
b = 0;
c = 0;
#100;
a = 8'b01101010;
b = 8'b10111101;
c = 0;
fin
endmodule
RTL
Additionneur complet

additionneur_complet
additionneur_complet
additionneur_complet:c6
additionneur_complet:c5 a
additionneur_complet un s
additionneur_complet:c3 un s b
additionneur_complet a s b coût Effectuer
c1 a s b coût cin
a s b coût cin
un s b coût cin
a[7..0] a s b coût cin
s b coût cin
b[7..0] b coût cin
coût cin
cin cin
s[7..0]
 MISE EN ŒUVRE D'UN ALU À L'AIDE DE XILINX
OBJECTIF :
Concevoir, simuler, synthétiser une ALU en utilisant du code Verilog et mettre en œuvre la même.
FPGA Xilinx.

APPAREIL REQUIS :
PC avec Windows
Xilinx 14.7
FPGA SPARTAN 3
Câble JTAG

PROCÉDURE :
Ouvrir un nouveau projet et taper le nom du projet et vérifier le type de source de niveau supérieur comme HDL Entrez
les propriétés de l'appareil et cliquez sur Suivant
Cliquez sur Nouvelle source et sélectionnez le module Verilog, puis donnez le nom de fichier
Donnez les noms des ports d'entrée et de sortie et cliquez sur terminer
Tapez le programme Verilog et enregistrez-le
Double-cliquez sur le synthétiseur XST et vérifiez la syntaxe
Simulez la forme d'onde par simulation comportementale
Pour la mise en œuvre, sélectionnez les contraintes d'utilisateur et indiquez le numéro de broche d'entrée et de sortie.

Cliquez sur Implémenter le design pour Traduire, cartographier et placer & router
Générez un fichier .bit en utilisant un fichier de programmation
Implémentez dans un FPGA via un câble JTAG parallèle
Vérifiez le comportement de la conception dans le FPGA en donnant des entrées
 ALU
module ALU (A,B,aluout,carryout,alusel);
entrée [7:0]A,B;
entrée [3:0]alusel;
sortie[7:0]aluout;
emporter
reg [7:0]aluresult;
fil [8:0]temp;
assign aluout=aluresult;
assign temp={4'b0000}+{4'b0000};
assigner carryout=temp[8];
toujours@(*)
commencer
cas(alusel)
4'b0000:
aluresult=(A+B);
4'b0001:
aluresult=(A-B);
4'b0010:
aluresultat=(A*B);
4'b0011:
aluresult=(A/B);
4'b0100 :
aluresult=(A<<1);
4'b0101:
aluresult=(A>>1);
4'b0110:
{A[6:0], A[7]};
4'b0111:
{A[0],A[7:1]};
4'b1000:
aluresult=(A&B);
4'b1001:
aluresult=(A|B);
4'b1010:
aluresult=(A^B);
4'b1011:
aluresult=(~(A&B));
4'b1100:
(~(A|B));
4'b1101:
(~(A^B));
4'b1110:
(A > B) ? 8'd1 : 8'd0;
4'b1111:
aluresult=(A==B)?8'd1:8'd0;
default
A+B;
fin de cas
fin
fin de module

BANQUE D'ESSAI POUR ALU :

module ALU_TEST;
// Entrées
reg [7:0] A;
reg [7:0] B;
reg [3:0] alusel;
// Sorties
fil [7:0] aluout;
transport par fil;
// Instancier l'Unité Sous Test (UST)
mad uut (
.A(A),
.B(B),
.aluout(aluout),
.effectuer(effectuer),
.alusel(alusel)
);
début initial
// Initialiser les entrées
A = 0;
B = 0;
alusel = 0;

// Attendre 100 ns pour que la réinitialisation globale soit terminée

#100;
A = 01 ;
B = 10;
4'b0000
#100;
A = 11;
B = 00;
4'b0001
#100;
01
B = 01;
4'b1010
fin
fin de module
RTL
Sortie de simulation
 MISE EN ŒUVRE D'UN MULTIPLICATEUR 4 BITS UTILISANT XILINX
OBJECTIF :
Concevoir, simuler, synthétiser un multiplicateur de 4 bits en utilisant le codage Verilog et mettre en œuvre le même.
utiliser FPGA Xilinx.

APPAREIL REQUIS :
PC avec Windows
Xilinx 14.7
FPGA SPARTAN 3
CÂBLE JTAG

PROCÉDURE :
Ouvrir un nouveau projet et saisir le nom du projet et vérifier le type de source de niveau supérieur comme HDL Entrer
les propriétés de l'appareil et cliquez sur Suivant
Cliquez sur Nouvelle source et sélectionnez le module Verilog, puis donnez le nom du fichier
Donnez les noms des ports d'entrée et de sortie et cliquez sur terminer
Tapez le programme Verilog et sauvegardez-le
Double-cliquez sur le synthétiseur XST et vérifiez la syntaxe
Simuler la forme d'onde par simulation comportementale
Pour la mise en œuvre, sélectionnez les contraintes d'utilisateur et donnez le numéro de broche d'entrée et de sortie.

Cliquez sur Implémenter le design pour Traduire, mapper et placer & router
Générer un fichier .bit en utilisant le fichier de programmation

Implémentez dans FPGA via un câble JTAG parallèle

Vérifiez le comportement du design dans le FPGA en donnant des entrées

MULTIPLICATEUR 4 BIT
module multiplicateur(
[3:0] a,
entrée [3:0] b,
[7:0] c
);
fil [7:0]pp1,pp2,pp3,pp4;
assign pp1={4'b0,a[3]&b[0],a[2]&b[0],a[1]&b[0],a[0]&b[0]};
assign pp2={3'b0,a[3]&b[1],a[2]&b[1],a[1]&b[1],a[0]&b[1],1'b0};
assign pp3={2'b0,a[3]&b[2],a[2]&b[2],a[1]&b[2],a[0]&b[2],2'b0};
assign pp4={1'b0,a[3]&b[3],a[2]&b[3],a[1]&b[3],a[0]&b[3],3'b0};
attribuer c=pp1+pp2+pp3+pp4;

endmodule
BANQUE D'ESSAI POUR MULTIPLICATEUR 4 BITS :

module TEST_DE_MULTIPLICATEUR;

// Entrées
reg [3:0] a;
reg [3:0] b;

Sorties
fil [7:0] c;

// Instancier l'Unité Sous Test (UST)

MULTIPLIER1 uut (
.a(a),
.b(b),
.c(c)
);

début initial
// Initialiser les entrées
a = 0;
b = 0;

// Attendre 100 ns pour que la réinitialisation globale se termine

a=101;
b=011;
#100;
a=101;
b=101;
#100;
a=111;
b=11;

// Ajouter un stimulus ici

fin

fin de module
RTL
Sortie de simulation
 MISE EN ŒUVRE D'UNE CELLULE RAM EN UTILISANT XILINX
OBJECTIF :
Concevoir, simuler, synthétiser une cellule RAM en utilisant le codage Verilog et mettre en œuvre la même chose en utilisant

FPGA Xilinx.

APPAREIL REQUIS :
PC avec Windows
Xilinx 14.7
FPGA SPARTAN 3
CÂBLE JTAG

PROCÉDURE :
Ouvrez un nouveau projet et tapez le nom du projet puis vérifiez le type de source de niveau supérieur comme HDL.
les propriétés de l'appareil et cliquez sur Suivant
Cliquez sur Nouvelle Source et sélectionnez le module Verilog, puis donnez le nom du fichier
Donnez les noms des ports d'entrée et de sortie et cliquez sur terminer
Tapez le programme Verilog et enregistrez-le
Double-cliquez sur la synthèse XST et vérifiez la syntaxe
Simulez l'onde par simulation comportementale
Pour la mise en œuvre, sélectionnez les contraintes utilisateur et donnez le numéro de broche d'entrée et de sortie.

Cliquez sur Implémenter le design pour Traduire, mapper et placer & router
Générer un fichier .bit en utilisant un fichier de programmation

Implémenter dans FPGA via un câble JTAG parallèle

Vérifiez le comportement du design dans le FPGA en donnant des entrées

CELLULE RAM
module ram(
horloge d'entrée,
entrée [5:0] addr,
entrée [7:0] data_in,
écrire_en
[7:0] data_out
);
reg [5:0]adresse_de_lecture;
reg [7:0]ram[63:0];

toujours @ (posedge clk)

commencer
si (write_en==1)
ram[addr]=data_in;
addr;
fin

assign data_out=ram[read_addr];

endmodule
BANQUE D'ESSAI POUR RAM :
module ram_test;

// Entrées
reg clk;
reg [5:0] addr;
reg [7:0] data_in;
écrire_en

// Sorties
fil [7:0] data_sortie;

// Instancier l'Unité Sous Test (UST)

ram uut
.clk(clk),
.addr(addr),
data_in
écrire_en
data_out
);

début initial
// Initialiser les entrées
clk = 0;
addr = 0;
0
write_en = 0;

// Attendre 100 ns que la réinitialisation globale se termine

#100;
clk = 1;
data_in = 101;
write_en = 1;
#100;
clk = 1;
data_in = 111;
write_en = 1;
// Ajouter un stimulus ici

fin

endmodule
RTL

Sortie de simulation
 Mise en œuvre d'un registre à décalage universel à l'aide de Xilinx
OBJECTIF :
Concevoir, simuler, synthétiser un registre à décalage universel en utilisant le codage Verilog et mettre en œuvre
le même en utilisant FPGA Xilinx.

APPAREIL NÉCESSAIRE :
PC avec Windows
Xilinx 14.7
FPGA SPARTAN 3
CÂBLE JTAG

PROCÉDURE :
Ouvrez un nouveau projet et tapez le nom du projet, puis vérifiez le type de source de niveau supérieur en tant que HDL. Appuyez sur Entrée.
les propriétés de l'appareil et cliquez sur Suivant
Cliquez sur Nouvelle source et sélectionnez le module Verilog, puis donnez le nom de fichier
Donnez les noms des ports d'entrée et de sortie et cliquez sur terminer
Tapez le programme Verilog et enregistrez-le
Double cliquez sur le synthétiseur XST et vérifiez la syntaxe
Simuler l'onde par simulation comportementale
Pour l'implémentation, sélectionnez les contraintes utilisateur et donnez le numéro de broche d'entrée et de sortie.

Cliquez sur Implémenter le design pour Traduire, cartographier et placer & router
Générer un fichier .bit en utilisant le fichier de programmation
Implémentez dans l'FPGA via un câble JTAG parallèle
Vérifiez le comportement du design dans le FPGA en donnant des entrées

REGISTRE À DÉCALAGE UNIVERSEL

module usr(
entrée [7:0] données_entree,
entrée clk,
entrée rst
entrée à gauche
entrée droite,
entrée [1:0] opsel,
[7:0] data_out
);

reg [7:0]q;
toujours @ (posedge clk ou posedge rst)
commencer
si (rst==1)
q=0;
sinon
 cas (opsel)
0 : q=données_en;
1: q={q<<1,din_gauche};
2: q={din_droite,q>>1};
3 : q=data_en;
fin de cas
fin
assigner data_out=q;
fin de module

BANQUE D'ESSAI POUR ENREGISTREUR À DÉCALAGE UNIVERSEL :

module usr_test;

// Entrées
reg [7:0] data_in;
reg clk;
reg rst;
reg din_gauche;
reg din_droite;
reg [1:0] opsel;

Outputs
fil [7:0] data_out;

// Instancier l'Unité Sous Test (UST)

usr uut (
data_in
.clk(clk),
.rst(rst),
.din_gauche(din_gauche),
.din_droite(din_droite),
.opsel(opsel),
data_out
);

début initial
// Initialiser les entrées
data_in = 0;
clk = 0;
rst = 0;
din_gauche = 0;
din_right = 0;
opsel = 0;

// Attendre 100 ns pour que la réinitialisation globale soit terminée

#100;
data_in = 101;
clk = 1;
rst = 1;
011
 01011
opsel = 1;
#100;
data_in = 101;
clk = 0;
rst = 0;
011
01011
opsel = 0;
// Ajoutez le stimulus ici

fin

fin de module
 MISE EN ŒUVRE D'UNE MACHINE À ÉTATS FINIS À L'AIDE DE XILINX
OBJECTIF :
Concevoir, Simuler, Synthétiser un FSM en utilisant le codage Verilog et mettre en œuvre le même à l'aide de
FPGA Xilinx.

APPAREIL REQUIS :
PC avec Windows
Xilinx 14.7
FPGA SPARTAN 3
CÂBLE JTAG

PROCÉDURE :
Ouvrir un nouveau projet et saisir le nom du projet et vérifier le type de source de niveau supérieur comme HDL. Appuyer sur Entrée.
les propriétés de l'appareil et cliquez sur Suivant
Cliquez sur Nouvelle Source et sélectionnez le Module Verilog, puis donnez le nom de fichier
Donnez les noms des ports d'entrée et de sortie et cliquez sur terminer
Tapez le programme Verilog et enregistrez-le
Double-cliquez sur le synthétiseur XST et vérifiez la syntaxe
Simuler l'onde par simulation comportementale
Pour la mise en œuvre, sélectionnez les contraintes utilisateur et indiquez le numéro de broche d'entrée et de sortie.

Cliquez sur Implémenter le design pour Traduire, mapper et placer & router
Générer un fichier .bit en utilisant un fichier de programmation

Implémentez dans FPGA via un câble JTAG parallèle

Vérifiez le comportement de la conception dans le FPGA en donnant des entrées.

MACHINE À ÉTATS FINIS

module fsm(rst, clk, in, out1);
entrée rst, clk, in;
sortie out1;
reg out2;
reg [1:0]état;
assigner out1=out2;
toujours @ (front montant clk ou front montant rst)
commencer
si (rst) commencer
out2=0; state=2'b00;
fin
sinon commencer
cas (état)
2'b00: commencer
si (dans) commencer
état=2'b01;
out2=1'b0;
fin
sinon commencer
 état=2'b11;
out2=1'b1;
fin
fin
2'b01 : début
si (dans) commencer
état=2'b11;
out2=1'b1;
fin
sinon commence
état=2'b10;
out2=1'b0;
fin
fin
2'b10: commencer
si (dans) commencer
état=2'b00;
out2=1'b0;
fin
sinon commencer
état=2'b01;
out2=1'b0;
fin
fin
2'b11: commencer
si (dans) commencer
état=2'b11;
out2=1'b1;
fin
sinon commencer
état=2'b10;
out2=1'b0;
fin
fin
fin de cas
fin
fin
endmodule

BANQUE D'ESSAI POUR MACHINE À ÉTATS FINIS :

module fsm_test;

// Entrées
reg rst;
reg clk;
s'inscrire;
enregistrement en dehors;

// Instancier l'Unité Sous Test (UST)

fsm uut (
 rst
.clk(clk),
.dans(dans)
.sortie(sortie)
);

début initial
// Initialiser les entrées
rst = 0;
clk = 0;
in = 0;
sortie = 0;

// Attendre 100 ns pour que la réinitialisation globale se termine

#100;
rst = 1;
clk = 1;
dans = 101;
#100;
1
clk = 1;
in = 110;
#100;
rst = 1;
clk = 1;
dans = 101;
#100;
rst = 0;
clk = 0;
in = 110;
// Ajoutez un stimulus ici

fin
endmodule

RTL
FSM