_______ Résumé

De nombreuses opérations de traitement d'image telles que le redimensionnement et la rotation nécessitent un rééchantillonnage ou

filtrage par convolution pour chaque pixel de l'image. Les convolutions sur les images numériques sont importantes

puisqu'ils représentent des opérations qui sont plus générales que les opérations qui peuvent être effectuées
sur les images analogiques. La convolution a de nombreuses applications qui ont une grande signification dans le discret

traitement du signal. Il est généralement difficile de traiter des signaux analogiques. Par conséquent, les signaux sont convertis

à l'état numérique. Le filtrage des signaux est très important pour déterminer lequel accepter.
et lequel rejeter, et tout cela se fait par convolution.

Cet article présente une méthode directe de réduction du temps de traitement de la convolution en utilisant

matériel informatique et implémentations de la convolution linéaire discrète de deux longueurs finies

séquences (NXN). Cette méthode d'implémentation est réalisée en simplifiant la convolution
blocs de construction. L'objectif de cette recherche est de prouver la faisabilité d'un FPGA qui effectue
une convolution sur une image acquise en temps réel. L'implémentation proposée utilise une modifiée
approche de conception hiérarchique, qui accélère efficacement et avec précision le calcul; réduit
puissance, ressources matérielles et surface de manière significative. L'efficacité de la convolution proposée

Le circuit est testé en l'intégrant dans un FPGA de niveau supérieur. De plus, le circuit présenté utilise moins
consommation d'énergie et délai de l'entrée à la sortie. Il fournit également la modularité nécessaire,
expansibilité et régularité pour former différentes convolutions pour un nombre quelconque de bits.
 CHAPITRE 1
INTRODUCTION

1.1 Introduction
La convolution fournit le cadre mathématique pour le DSP. C'est le plus important.
technique en traitement du signal numérique. La convolution est une méthode mathématique pour combiner deux
signaux pour former un troisième signal. En utilisant la stratégie de décomposition d'impulsions, les systèmes sont

décrit par un signal appelé la réponse impulsionnelle. Dans le traitement du signal, la réponse impulsionnelle, ou
La fonction de réponse impulsionnelle (FRI) d'un système dynamique est sa sortie lorsqu'il est présenté avec une brève

signal d'entrée, appelé une impulsion. Plus généralement, une réponse impulsionnelle fait référence à la réaction de tout

système dynamique en réponse à un changement externe. Il a des applications qui incluentstatistiques,

vision par ordinateur, imageettraitement du signal, génie électrique, et équations différentielles.

1.2 Introduction à la convolution

L'un des concepts les plus importants de la théorie de Fourier et de la cristallographie est celui d'un
convolution. Les convolutions se présentent sous de nombreuses formes, comme cela sera montré ci-dessous. En raison d'un

propriété mathématique de la transformée de Fourier, appelée théorème de convolution, il est

pratique pour effectuer des calculs impliquant des convolutions.

1.2.1 Définition de la convolution

La convolution de ƒ et g est écrite ƒ ∗ g, utilisant un astérisque ou une étoile. Elle est définie comme l'intégrale

of the product of the two functions after one is reversed and shifted. As such, it is a particular
sorte detransformée intégrale:
 Bien que le symbole soit utilisé ci-dessus, il ne doit pas nécessairement représenter le domaine temporel. Mais dans ce contexte, le

La formule de convolution peut être décrite comme une moyenne pondérée de la fonction ƒ(τ) au moment t.
où le poids est donné par g(−τ) simplement décalé par un montant t. À mesure que cela change, le poids
La fonction met l'accent sur différentes parties de la fonction d'entrée.

Plus généralement, iffandgare des fonctions à valeurs complexes sur Rd, alors leur convolution peut être

défini comme l'intégrale :

1.3 Types de Convolution

Il existe deux types de convolution. Ils sont :

Convolution linéaire
Convolution circulaire

1.3.1 Convolution linéaire

La convolution est une concaténation intégrale de deux signaux. Elle a de nombreuses applications dans de nombreux

Les domaines du traitement du signal. La convolution décrite ci-dessus n'est rien d'autre qu'une convolution linéaire.

L'application la plus populaire est la détermination du signal de sortie d'un système linéaire à temps invariant

système en convoluant le signal d'entrée avec la réponse impulsionnelle du système. Convoluer deux
les signaux sont équivalents à multiplier la transformée de Fourier des deux signaux.

MathematicalFormula:
La convolution linéaire de deux signaux en temps continu et est défini par

Pour les signaux à temps discret x(n) et h(n), l'intégration est remplacée par une sommation.
1.3.2 Convolution circulaire
La convolution circulaire de deux fonctions apériodiques se produit lorsque l'une d'elles est convoluée dans le

façon normale avec unsommation périodiquede l'autre fonction. Cela se produit naturellement danssignal numérique

traitementquandDTFTset les DTFT inverses sont remplacés parDFTset DFT inverses.

Équivalemment, le domaine de fréquence continu est remplacé par un domaine discret. (VoirCirculaire
théorème de convolution.)

Pour une fonction périodique xT(t), avec la période T, leconvolutionavec une autre fonction, h(t), est également
périodique, et peut être exprimé en termes d'intégration sur un intervalle fini comme suit :

[1]

Où, toest un paramètre arbitraire, ethT(t) est unsomme périodiqueofh, défini par :

Quand?T(t) s'exprime comme lesommation périodiqued'une autre fonction, x, cette convolution est

parfois appelée convolution acirculaire des fonctions h et x.

1.4 Propriétés de la convolution

Cette section décrit les propriétés de la convolution. Les propriétés de la convolution sont :
Commutatif
Associatif
Distributif
1.4.1 Propriété commutative :
La propriété commutative pour la convolution s'exprime sous forme mathématique :

a[n]*b[n]=b[n]*a[n]

En mots, l'ordre dans lequel deux signaux sont convolués ne fait aucune différence, les résultats sont
identique.

1.4.2 Propriété associative :

La propriété associative décrit la manière de convoluer plus de deux signaux. Convoluez deux des signaux pour
produire un signal intermédiaire, puis convoluer le signal intermédiaire avec le troisième signal. L'associatif
la propriété stipule que l'ordre des convolutions n'a pas d'importance. Sous forme d'équation :

(a[n] * b[n]) * c[n] = a[n] * (b[n] * c[n])

La propriété associative est utilisée dans la théorie des systèmes pour décrire comment les systèmes en cascade se comportent. Deux ou plusieurs

on dit que les systèmes sont en cascade si la sortie d'un système est utilisée comme entrée pour le système suivant.
la propriété associative, l'ordre des systèmes peut être réarrangé sans changer la réponse globale de
la cascade. De plus, tout nombre de systèmes en cascade peut être remplacé par un seul système. L'impulsion
La réponse du système de remplacement est trouvée en convoluant les réponses impulsionnelles de tous les originaux.

systèmes.

1.4.3 Propriété distributive :

Sous forme d'équation, la propriété distributive s'écrit comme :

a[n] *b[n] +a[n] *c[n] =a[n] * (b[n] +c[n] )

La propriété distributive décrit l'opération de systèmes parallèles avec des sorties supplémentaires. Deux ou plusieurs
les systèmes peuvent partager la même entrée, x[n], et avoir leurs sorties additionnées pour produire y[n]. La distributivité

la propriété permet à cette combinaison de systèmes d'être remplacée par un seul système, ayant une réponse impulsionnelle

égal à la somme des réponses impulsionnelles des systèmes d'origine.

1.5 Applications de la Convolution
La convolution et les opérations associées se trouvent dans de nombreuses applications d'ingénierie et
mathématiques. Voici les domaines où la convolution est appliquée.

En statistiques, comme mentionné ci-dessus, une moyenne mobile pondérée est une convolution.

Dans la théorie des probabilities, la distribution de probabilité de la somme de deux variables aléatoires indépendantes

les variables est la convolution de leurs distributions individuelles.

En optique, de nombreux types de "flou" sont décrits par des convolutions. Une ombre (par exemple l'ombre sur

la table lorsque vous tenez votre main entre la table et une source de lumière) est la convolution de
la forme de la source de lumière qui projette l'ombre et l'objet dont l'ombre est projetée
Un photographie floue est la convolution de l'image nette avec la forme de la
diaphragme iris. Le terme photographique pour cela est bokeh.
De même, dans le traitement d'images numériques, le filtrage par convolution joue un rôle important dans de nombreux
algorithmes importants dans la détection de contours et les processus associés.

In linear acoustics, an echo is the convolution of the original sound with a function
représentant les divers objets qui le reflètent.
Dans la réverbération artificielle (traitement du signal numérique, audio professionnel), la convolution est utilisée pour mapper

la réponse impulsionnelle d'une vraie pièce sur un signal audio numérique (voir le point précédent et le point suivant pour

additional information).
En ingénierie électrique et dans d'autres disciplines, la sortie (réponse) d'un système (stationnaire ou temporel)
ou système linéaire invariant dans le temps) est la convolution de l'entrée (excitation) avec le système
réponse à un impulsion ou fonction delta de Dirac. Voir la théorie des systèmes LTI et le signal numérique

traitement.
Dans la spectroscopie de fluorescence résolue dans le temps, le signal d'excitation peut être traité comme une chaîne de

pulses delta, et la fluorescence mesurée est une somme des décroissances exponentielles de chaque delta

pouls.
En physique, partout où il y a un système linéaire avec un "principe de superposition", une convolution
l'opération fait une apparition.
 Dans le traitement du signal numérique, le filtrage fréquentiel peut être simplifié en convoluant deux

fonctions (données avec un filtre) dans le tempsdomaine, qui est analogue à multiplier les données
avec un filtre dans le domaine de la fréquence

CHAPITRE 2
Revuedelittérature

2.1 Introduction

L'opération la plus importante réalisée sur les signaux est le filtrage linéaire, qui peut être
réalisé par convolution. La raison pour laquelle le filtrage linéaire est si important pour le traitement du signal est

qu'il résout de nombreux problèmes et qu'il est relativement simple à décrire mathématiquement. Dans ce chapitre

nous allons examiner la convolution. La convolution aide à déterminer l'effet qu'un système a sur un
signal d'entrée. Il peut être démontré qu'un système linéaire et invariant dans le temps est complètement caractérisé par

sa réponse impulsionnelle. En utilisant la propriété d'échantillonnage de la fonction delta pour le temps continu

signaux et l'échantillon unitaire pour les signaux en temps discret, nous pouvons décomposer un signal en une infinité

somme / intégrale d'impulsions mises à l'échelle et décalées. En sachant comment un système affecte un seul

impulsion, et en comprenant comment un signal est constitué d'impulsions mises à l'échelle et additionnées, cela
Il semble raisonnable qu'il devrait être possible de mettre à l'échelle et de sommer les réponses impulsionnelles d'un système dans

pour déterminer quel signal de sortie résultera d'une entrée particulière. C'est précisément ce que
la convolution fait - la convolution détermine la sortie du système à partir de la connaissance de l'entrée et
la réponse impulsionnelle du système.

2.2 Convolution - Temps discret

L'idée de la convolution en temps discret est exactement la même que celle de la convolution en temps continu.
Pour cette raison, il peut être utile de regarder les deux versions pour vous aider à comprendre cela.
concept extrêmement important. La convolution est un outil très puissant pour déterminer un système.
sortie d'une connaissance d'une entrée arbitraire et de la réponse impulsionnelle du système.
Nous savons que tout signal en temps discret peut être représenté par une sommation de valeurs mises à l'échelle et

impulsions discrètes décalées. Puisque nous supposons que le système est linéaire et invariant dans le temps,
il semblerait raisonnable qu'un signal d'entrée composé de la somme d'impulsions mises à l'échelle et décalées
donnerait lieu à une sortie composée d'une somme de réponses impulsionnelles mises à l'échelle et décalées. Cela est
exactement ce qui se passe dans la convolution.

Pour les signaux en temps discret et l'équation de convolution est donnée par :

Interprétation Graphique :
Réflexion de en résultant
Changement de aboutissant à
Multiplication élément par élément des séquences et
Somme de la séquence de produits ce qui donne la valeur de convolution pour

2.2.1 Illustration graphique des propriétés de convolution (Temps discret)

Un exemple graphique rapide peut aider à démontrer pourquoi la convolution fonctionne.

Fig 1 : Une seule entrée d'impulsion produit la réponse impulsionnelle du système.

Fig 2 : Une entrée d'impulsion mise à l'échelle produit une réponse mise à l'échelle, en raison de la propriété d'échelle du système.

linéarité.

Fig 3 : Nous utilisons maintenant la propriété d'invariance temporelle du système pour montrer qu'une entrée retardée

résultats dans une sortie de la même forme, seulement retardée de la même quantité que l'entrée.
Fig 4 : Nous utilisons maintenant la partie additive de la propriété de linéarité du système pour compléter le
image. Puisque tout signal à temps discret n'est qu'une somme d'impulsions à temps discret mises à l'échelle et décalées,
nous pouvons trouver la sortie en connaissant l'entrée et la réponse impulsionnelle.

2.3 Convolution – Analog

Dans ce module, nous examinons la convolution pour les signaux en temps continu. Cela entraînera le
intégrale de convolution et ses propriétés. Ces concepts sont très importants en ingénierie et
rendra la vie de tout ingénieur beaucoup plus facile si le temps est consacré maintenant à vraiment comprendre ce qui est

en cours.
2.3.1 Dérivation de l'intégrale de convolution

Pour commencer cela, il est nécessaire d'énoncer les hypothèses que nous allons faire. Dans ce cas, le
les seules contraintes sur notre système sont qu'il soit linéaire et invariant dans le temps.

Aperçu des étapes de dérivation :

1. Une entrée d'impulsion entraîne une sortie de réponse d'impulsion.

2. Une entrée d'impulsion décalée conduit à une sortie de réponse impulsionnelle décalée. Cela est dû au temps-

invariance du système.
3. Nous mettons maintenant à l'échelle l'entrée impulsionnelle pour obtenir une sortie impulsionnelle mise à l'échelle. Cela utilise le scalaire

propriété de multiplication de la linéarité.

4. Nous pouvons maintenant "résumer" un nombre infini de ces impulsions échelonnées pour obtenir une somme d'un infini

nombre de réponses impulsionnelles mises à l'échelle. Cela utilise l'attribut additif de la linéarité.
5. Maintenant, nous reconnaissons que cette somme infinie n'est rien d'autre qu'un integral, donc nous convertissons les deux

côtés en intégrales.
6. Reconnaissant que l'entrée est la fonction f(t), nous reconnaissons également que la sortie est exactement le
intégrale de convolution.

Fig 1 : Nous commençons avec un système défini par sa réponse impulsionnelle, h(t).

Fig 2 : Nous considérons ensuite une version décalée de l'impulsion d'entrée. En raison de l'invariance temporelle du

système, nous obtenons une version décalée de la réponse impulsionnelle de sortie.

 Fig 3 : Maintenant, nous utilisons la partie d'échelle de la linéarité en échelonnant le système par une valeur, f(τ), qui est

constant par rapport à la variable système, t.

Fig 4 : Nous pouvons maintenant utiliser l'aspect additif de la linéarité pour ajouter un nombre infini de ceux-ci, un

pour chaque τ possible. Puisqu'une somme infinie est exactement un intégral, nous aboutissons à l'intégration
connu sous le nom d'Intégrale de Convolution. En utilisant la propriété d'échantillonnage, nous reconnaissons le côté gauche

simplement comme l'entrée f(t) .

2.3.2 Intégrale de convolution

Comme mentionné ci-dessus, l'intégrale de convolution fournit un moyen mathématique simple d'exprimer le
sortie d'un système LTI basé sur un signal arbitraire, x(t), et la réponse impulsionnelle du système,
h(t). L'intégrale de convolution est exprimée comme

La convolution est un outil si important qu'elle est représentée par le symbole *, et peut être écrite
comme

y (t) = x(t) * h(t)

En effectuant un simple changement de variables dans l'intégrale de convolution, τ = t−τ, nous pouvons facilement

montrez que la convolution est commutative :

x (t) * h(t) = h(t) * x(t)

2.3.3 Mise en œuvre de la Convolution

En examinant de plus près l'intégrale de convolution, nous constatons que nous multiplions l'entrée.
signal par la réponse impulsionnelle inversée dans le temps et en intégrant. Cela nous donnera la valeur de la
sortie à une valeur donnée de t. Si nous décalons ensuite la réponse impulsionnelle inversée temporellement par un petit

montant, nous obtenons le résultat pour une autre valeur de t. En répétant cela pour chaque valeur possible de t,

produit la fonction de production totale. Bien que nous ne ferions jamais réellement ce calcul à la main dans

de cette manière, cela nous donne un aperçu de ce qui se passe réellement. Nous constatons que
nous inversions essentiellement la fonction de réponse impulsionnelle et la faisons glisser sur l'entrée

function, integrating as we go. This method, referred to as the graphical method, provides us with
une méthode beaucoup plus simple pour résoudre l'output pour des signaux simples (artificiels), tout en améliorant notre

intuitions pour les cas plus complexes où nous comptons sur les ordinateurs. En fait, Texas Instruments.
développe des processeurs de signal numérique qui possèdent des ensembles d'instructions spéciaux pour des calculs tels que

convolution.

2.4Convolution symétrique

Dansmathématiquesla convolution symétrique est un sous-ensemble spécial deconvolutionopérations dans lesquelles

lenoyau de convolutionestsymétriqueà travers son point zéro. De nombreuses convolutions courantes basées sur
des processus tels queFlou gaussienet prenant ledérivéed'un signal dansespace fréquentielsont
symétrique et cette propriété peut être exploitée pour rendre ces convolutions plus faciles à évaluer.

Lethéorème de convolutionindique qu'une convolution dans le domaine réel peut être représentée
en tant quemultiplication point par pointà travers le domaine de fréquence d'untransformée de Fourier. Depuissinus et
transformées cosinusles transformations liées sont une version modifiée du théorème de convolution
appliqué, dans lequel le concept deconvolution circulaireest remplacé par une convolution symétrique.
Utiliser ces transformations pour calculer des convolutions symétriques discrètes n'est pas trivial puisquediscret
transformées sinusoïdales(DST) ettransformées cosinus discrètes(DCT) peuvent être contre-intuitifs
incompatible pour le calcul de la convolution symétrique, c'est-à-dire que la convolution symétrique ne peut être que

calculé entre un ensemble fixe de transformations compatibles.

2.4.1 Avantages des convolutions symétriques

Il y a un certain nombre d'avantages à calculer des convolutions symétriques dans les DST et

DCTs par rapport à la convolution circulaire plus courante avec la transformée de Fourier.
Il est particulièrement remarquable que la symétrie implicite des transformations impliquées est telle que seules les données incapables de

être déduit par la symétrie est requis. Par exemple, en utilisant une DCT-II, un signal symétrique doit
n'avoir que la moitié positive de la DCT-II transformée, puisque le domaine fréquentiel sera implicitement

construire les données miroitées comprenant l'autre moitié. Cela permet des noyaux de convolution plus grands à
être utilisé avec le même coût que des noyaux plus petits convolués circulairement sur le DFT. Aussi le
Les conditions aux limites implicites dans les DST et DCT créent des effets de bord qui sont souvent plus dans

en gardant les données voisines plutôt que les effets périodiques introduits par l'utilisation de la Fourier

transformer.

BASES DU VHDL
Entités de conception et configurations
L'entité de conception est la principale abstraction matérielle dans VHDL. Elle représente

une portion d'une conception matérielle qui a des entrées et des sorties bien définies et qui effectue une

fonction bien définie. Une entité de conception peut représenter un système entier, un sous-système, un

carte, une puce, une macro-cellule, une porte logique ou tout niveau d'abstraction intermédiaire.

La configuration peut être utilisée pour décrire comment les entités de conception sont assemblées pour former un
design complet.

Une entité de conception peut être décrite en termes d'une hiérarchie de blocs, chacun d'eux
représente une partie de l'ensemble du design. Le bloc de niveau supérieur dans une telle hiérarchie est le

concevoir l'entité elle-même ; un tel bloc est un bloc externe qui réside dans une bibliothèque et peut être
utilisé comme un composant d'autres conceptions. Les blocs imbriqués dans la hiérarchie sont des blocs internes,

défini par des instructions de bloc

1.1 Déclarations d'entité :

Une déclaration d'entité définit l'interface entre une entité de conception donnée et le
environnement dans lequel il a été émis. Il peut également spécifier des déclarations et des énoncés qui sont

partie de l'entité de conception. Une déclaration d'entité donnée peut être partagée par de nombreux designs

entités, chacune ayant une architecture différente. Ainsi, une déclaration d'entité peut
représenter potentiellement une classe d'entités de conception, chacune ayant la même interface.

entity_declaration ::=
identifiantentitéest
en-tête_d'entité
partie_déclarative_de_l'entité
[début
partie_de_l'énoncé_d'entité
fin[entité] [nom_entité_simple] ;
1.1.1 Génériques :

Les génériques fournissent un canal pour que des informations statiques soient communiquées à un bloc depuis son
environnement. Ce qui suit s'applique à la fois aux blocs externes définis par des entités de conception et
aux blocs internes définis par le bloc

déclarations.
generic_list ::=generic_interface_list

Les génériques d'un bloc sont définis par une liste d'interfaces génériques. Chaque élément d'interface dans
une telle liste d'interface générique déclare un générique formel.
1.1.2 Ports:
Les ports fournissent des canaux pour une communication dynamique entre un bloc et son environnement.

port_list ::=port_interface_list

1.2 Architecture bodies:

Un corps d'architecture définit le corps d'une entité de conception. Il spécifie le

les relations entre les entrées et les sorties d'une entité de conception et peuvent être exprimées en
en termes de structure, de flux de données ou de comportement. De telles spécifications peuvent être partielles ou complètes.

architecture_body ::=
l'architectureidentificateurdel'entité_nomest
architecture_declarative_part
commencer
architecture_statement_part
fin[architecture] [nom_simple_de_l_architecture] ;

1.3 Sous-programmes et paquets

1.3.1 Déclarations de sous-programmes :

Une déclaration de sous-programme déclare une procédure ou une fonction, comme indiqué par le

mot réservé approprié.

subprogram_declaration ::=
spécification_de_sous_programme ;
subprogram_specification ::=
désignation_de_procédure [ ( liste_de_paramètres_formels ) ]
| [pure|impure]désignateur de fonction [ ( liste_des_paramètres_formels ) ]
type_de_retour_marque

La spécification d'une procédure spécifie son désignateur et ses paramètres formels

(le cas échéant). La spécification d'une fonction précise son désignateur, ses paramètres formels (si
n'importe lequel), le sous-type de la valeur retournée (le sous-type du résultat), et si oui ou non le

une fonction est pure. Une fonction est impure si sa spécification contient le mot réservé
impur; sinon, on dit qu'il est pur. Un désignateur de procédure est toujours un identifiant. Un
un désignateur de fonction est soit un identifiant soit un symbole opérateur

1.3.2 Corps de sous-programmes :

Un corps de sous-programme spécifie l'exécution d'un sous-programme.
 subprogram_body ::=
spécification_de_sous_programme
partie_déclarative_du_sous-programme
commencer
partie_de_déclaration_de_sous-programme
fin[ type_de_sous_programme ] [ désignateur ] ;

1.3.3 Package declarations:

Une déclaration de package définit l'interface à un package. Le champ d'application d'un

La déclaration au sein d'un paquet peut être étendue à d'autres unités de conception.

package_declaration ::=
l'identifiant du paquet est
partie_déclarative_du_package
fin[paquet] [nom_simple_du_paquet] ;
1.3.4 Package bodies
Un corps de package définit les corps des sous-programmes et les valeurs des éléments différés.

constantes déclarées dans l'interface au package.

package_body ::=
package bodypackage_simple_nameis
partie_déclarative_du_corps_du_package
fin[corps de package] [nom_simple_de_package] ;
1.4 Data Types:
1.4.1 Types scalaires :

Les types scalaires peuvent être classés en quatre types. Ils sont

-- Énumération
-- Entier
-- Physique
-- Nombre à virgule flottante

[Link] Types d'énumération :

Une définition de type d'énumération définit un type d'énumération.

enumeration_type_definition ::=
( littéral_d_enumération { , littéral_d_enumération } )

enumeration_literal ::= identifier | character_literal

[Link] Types entiers :
 Une définition de type entier définit un type entier dont l'ensemble des valeurs inclut
ceux de la plage spécifiée.
définition_type_entier ::= contrainte_intervalle.
[Link] Types physiques :
Les valeurs d'un type physique représentent des mesures d'une certaine quantité. Toute valeur de
un type physique est un multiple entier de l'unité de mesure primaire pour ce type.

physical_type_definition ::=
range_constraint
unités
primary_unit_declaration
{ secondary_unit_declaration }
unités de fin [nom_type_physique_simple]

[Link] Types de points flottants :

Les types à virgule flottante fournissent des approximations des nombres réels. Virgule flottante

les types sont utiles pour les modèles dans lesquels la caractérisation précise d'un point flottant

le calcul n'est pas important ou non déterminé.

floating_type_definition ::= range_constraint
1.4.2 Types composites :
Les types composites sont utilisés pour définir des collections de valeurs. Celles-ci incluent à la fois

tableaux de valeurs (collections de valeurs d'un type homogène) et enregistrements de valeurs

(collections de valeurs de types potentiellement hétérogènes).
[Link] Types de tableaux

Un objet tableau est un objet composite constitué d'éléments ayant le même

sous-type. Le nom d'un élément d'un tableau utilise une ou plusieurs valeurs d'index appartenant à
types discrets spécifiés. La valeur d'un objet tableau est une valeur composite consistant en
les valeurs de ses éléments
unconstrained_array_definition ::=
tableau( définition_sous_type_index { , définition_sous_type_index } )
indication_de_sous_type_de_l'élément

constrained_array_definition ::=
indication_de_sous-type_de_contraintes_d'index_de_tableau

[Link] Record types:

 Un type d'enregistrement est un type composite, dont les objets se composent d'éléments nommés.

La valeur d'un objet d'enregistrement est une valeur composite constituée des valeurs de ses éléments.
record_type_definition ::=
enregistrer
element_declaration
{ element_declaration }
fin enregistrement[nom_type_enregistrement_simple]

1.4.3 Access types:

Un objet déclaré par une déclaration d'objet est créé par l'élaboration de la
La déclaration d'objet est indiquée par un nom simple ou par une autre forme de nom. Dans
En revanche, les objets créés par l'évaluation des allocateurs (voir 7.3.6) n'ont aucune simplicité.
nom. L'accès à un tel objet est réalisé par un évaluateur d'accès retourné par un allocateur;
la valeur d'accès est censée désigner l'objet.
access_type_definition ::=accesssubtype_indication
1.4.4 Types de fichiers
Une définition de type de fichier définit un type de fichier. Les types de fichiers sont utilisés pour définir des objets.

représentation des fichiers dans l'environnement du système hôte. La valeur d'un objet fichier est le

séquence de valeurs contenues dans le fichier du système hôte.

definition_de_type_de_fichier ::= fichier de type_marque

1.5 Objets de données :

1.5.1 Déclarations d'objets
Une déclaration d'objet déclare un objet d'un type spécifié. Un tel objet est
appelé un objet déclaré explicitement.
[Link] Déclarations de constantes
Une déclaration de constante déclare une constante du type spécifié. Une telle constante est
une constante déclarée explicitement.
constant_declaration ::=
constantidentifier_list : subtype_indication [ := expression ] ;

Si le symbole d'assignation ':=' suivi d'une expression est présent dans une constante
déclaration, l'expression spécifie la valeur de la constante ; le type de l'expression
doit être celle de la constante. La valeur d'une constante ne peut pas être modifiée après le

la déclaration est élaborée.

[Link] Déclarations de signal
Une déclaration de signal déclare un signal du type spécifié. Un tel signal est un explicitement
signal déclaré.
signal_declaration ::=
signalidentifier_list : subtype_indication [ signal_kind ] [ := expression ] ;

signal_kind ::=register|bus
[Link] Déclarations de variables
Une déclaration de variable déclare une variable du type spécifié. Une telle variable est
une variable déclarée explicitement.
variable_declaration ::=
[partagé]liste_identifiant_variable : indication_sous_type [ := expression ] ;
[Link] Déclarations de fichiers
Une déclaration de fichier déclare un fichier du type spécifié. Un tel fichier est une déclaration explicite.
fichier.

file_declaration ::=
fileidentifier_list : subtype_indication [ file_open_information ] ;

1.6 Operators:

1.6.1. Opérateurs Logiques :

Les opérateurs logiques et, ou, nand, nor, xor, xnor et not sont définis pour
types prédéfinis BIT et BOOLEAN. Ils sont également définis pour tout tableau unidimensionnel

array type whose element type is BIT or BOOLEAN. For the binary operatorsand,or,
nand, nor, xor, et xnor, les opérandes doivent être du même type de base. De plus, pour le
opérateurs binaires et, ou, nand, nor, xor, et xnor définis sur un tableau unidimensionnel

types, les opérandes doivent être des tableaux de la même longueur, l'opération est effectuée sur
éléments correspondants des tableaux, et le résultat est un tableau avec la même plage d'index que
l'opérande de gauche.

1.6.2. Opérateurs relationnels.

Les opérateurs relationnels incluent des tests pour l'égalité, l'inégalité et l'ordre de
opérandes. Les opérandes de chaque opérateur relationnel doivent être du même type. Le résultat
le type de chaque opérateur relationnel est le type prédéfini BOOLEAN.
 Opérateur
Operation Opérande Type de résultat
Type
= Égalité Tout type Booléen
/= Inégalité Tout type Booléen
< Moins que Tout ScalarType ou
Type discret Booléen
<= Moins que ou égal à n'importe quel ScalarType ou
Type discret Booléen
> Tout ScalarType ou
SupérieurÀ Type discret Booléen
>= Plus grand que ou Tout ScalarType ou
Égal Type discret Booléen

1.6.3. Opérateurs de décalage.

Les opérateurs de décalage sll, srl, sla, sra, rol et ror sont définis pour toute dimension unidimensionnelle.

type de tableau dont le type d'élément est soit l'un des types prédéfinis BIT soit BOOLEAN.

Opérateur Opérande gauche Right operand Result

Type d'opération Tapez taper
Toute dimension unidimensionnelle

sll Décaler à gauche type de tableau dont l'élément ENTIER Identique à gauche
logique le type est BIT ou BOOLEAN
Tout dimensionnel
srl Décaler à droite type de tableau dont l'élément ENTIER Même que à gauche
logique le type est BIT ou BOOLEAN
Tout unidimensionnel
sla Déplacement à gauche
type de tableau dont l'élément ENTIER Même que gauche
arithmétique le type est BIT ou BOOLEAN
Déplacer vers la droite
Tout dimensionnel ENTIER
sra arithmétique type de tableau dont l'élément Identique à gauche
le type est BIT ou BOOLEAN
Faire tourner à gauche
Tout dimension unidimensionnelle ENTIER
rol logique type de tableau dont l'élément Même que gauche
le type est BIT ou BOOLEAN
Une dimensionnelle
ror Rotate right array type whose element ENTIER Pareil à
le type logique est BIT ou gauche
BOOLEAN

[Link] d'opérateurs.
Les opérateurs d'addition + et Ð sont prédéfinis pour tout type numérique et ont leur
conventional mathematical meaning. The concatenation operator & is predefined for any
type de tableau unidimensionnel.
 Opérande gauche Right operand Résultat
Opérateur Opération type Type Taper
+ Addition Tout numérique Même type
type Même type
- Soustraction Tout numérique Même type
taper Même type
Tout type de tableau Même tableau
& Même type de tableau type
N'importe quel tableau Même élément Même tableau
Concaténation type type type
L'élément Tout type de tableau Même tableau
type type
L'élément Tout élément n'importe quel tableau

taper type taper

1.6.5. Opérateurs de multiplication :

Les opérateurs * et / sont prédéfinis pour tout type entier et tout type à virgule flottante et
ont leur signification mathématique conventionnelle ; les opérateurs mod et rem sont

prédefini pour tout type d'entier. Pour chacun de ces opérateurs, les opérandes et le résultat
sont du même type.

Opérande gauche Droit Result

Opérateur Opération taper opérande Taper
Type
Tout type entier Même type Même type
Tout point flottant Même type Même type
* Multiplication
type
Tout type d'entier Même type Même type
Tout point flottant Même type Même type
/ Division
taper
mod Modulus Tout type entier Même type Même type
rem Rappel Tout type d'entier Same type Même type

1.6.6. Miscellaneous operators:

L'opérateur unaire abs est prédéfini pour tout type numérique.
Opérateur Opération Type d'opérande Type de résultat

abs Absolute value Any numeric type Same numeric type

L'opérateur exponentiation ** est prédéfini pour chaque type entier et pour chaque flottant
type de point. Dans les deux cas, l'opérande de droite, appelé l'exposant, est de type prédéfini
ENTIER.
Opérande gauche Right operand Result
Opérateur Opération tape Type Type
Tout type entier INTEGER Same as left
Tout flottant ENTIER Même que la gauche
** Exponentiation
type de point

En VHDL, il y a principalement trois styles de modélisation. Ce sont

[Link]élisation comportementale.

2. Data Flow Modeling.

3. Modélisation Structurelle.

1.7 Behaviorial Modeling:

1.7 .1 Déclaration de processus
Une déclaration de processus définit un processus séquentiel indépendant représentant le
comportement d'une partie de la conception.
process_statement ::=
[process_label : ]
[reporté]processus[ ( liste_de_sensibilité ) ] [est]
process_declarative_part
début
partie_de_l'énoncé_de_processus
end[postponed]process[process_label ] ;

où la liste de sensibilité de l'instruction d'attente est celle qui suit le mot réservé
process. Such a process statement must not contain an explicit wait statement. Similarly,
si une telle déclaration de processus est un parent d'une procédure, alors cette procédure ne peut pas
contiennent une instruction d'attente.

1.7.2 Instructions séquentielles :

Les différentes formes d'instructions séquentielles sont décrites dans cette section. Séquentiel
les instructions sont utilisées pour définir des algorithmes pour l'exécution d'un sous-programme ou d'un processus;
ils s'exécutent dans l'ordre dans lequel ils apparaissent.
[Link] Instruction d'attente
L'instruction d'attente provoque la suspension d'une instruction de processus ou d'une procédure..

wait_statement ::=
[ label : ]wait[ sensitivity_clause ] [ condition_clause ] [ timeout_clause ] ;
 sensitivity_clause ::=onsensitivity_list

sensitivity_list ::=signal_name { ,signal_name }

condition_clause ::=untilcondition

condition ::=boolean_expression

timeout_clause ::=fortime_expression

[Link] Déclaration d'assertion :

Une déclaration d'assertion vérifie qu'une condition spécifiée est vraie et rapporte un
erreur si ce n'est pas le cas.
assertion_statement ::= [ étiquette : ] assertion ;

assertion ::=
conditionassert
[expressionderapport]
[severityexpression ]
[Link] Déclaration de rapport :
Une déclaration de rapport affiche un message.

report_statement ::=
[ label : ]
expression de rapport
[severityexpression ] ;

[Link] Instruction if :
Une instruction if sélectionne pour l'exécution une ou aucune des séquences englobées.
déclarations, en fonction de la valeur d'une ou plusieurs conditions correspondantes.

if_statement ::=
[if_label : ]
siconditionalors
sequence_of_statements
{elsifconditionthen
sequence_of_statements }
[sinon
sequence_of_statements ]
fin si[étiquette_si] ;

Si une étiquette apparaît à la fin d'une instruction if, elle doit répéter l'étiquette if.
 Pour l'exécution d'une instruction if, la condition spécifiée après if, et tout
conditions specified afterelsif, are evaluated in succession (treating a finalelseaselsif
VRAI alors) jusqu'à ce qu'une évaluation soit à VRAI ou que toutes les conditions soient évaluées et donnent

FAUX. Si une condition est évaluée à VRAI, alors la séquence correspondante de

les instructions sont exécutées ; sinon, aucune des séquences d'instructions n'est exécutée.
[Link] Instruction case :
Une instruction case sélectionne pour l'exécution une des plusieurs séquences alternatives de
les déclarations ; l'alternative choisie est définie par la valeur d'une expression.

case_statement ::=
[case_label : ]
expressiondecas
case_statement_alternative
{ case_statement_alternative }
fin du cas [étiquette_du_cas] ;

case_statement_alternative ::=
whenchoices =>
sequence_of_statements

L'expression doit être d'un type discret ou d'un type de tableau unidimensionnel
dont le type de base des éléments est un type de caractère. Ce type doit être déterminable

indépendamment du contexte dans lequel l'expression se produit, mais en utilisant le fait que le
l'expression doit être d'un type discret ou d'un type de tableau de caractères unidimensionnel. Chaque

le choix dans une instruction de cas doit être du même type que l'expression ; la liste
des choix spécifie pour quelles valeurs de l'expression l'alternative est choisie.
[Link] Instruction de boucle :
Une instruction de boucle comprend une séquence d'instructions qui doit être exécutée

répété, zéro ou plusieurs fois.

loop_statement ::=
[loop_label : ]
[ iteration_scheme ]loop
sequence_of_statements
fin de boucle[étiquette_boucle] ;

iteration_scheme ::=
conditiondewhile
|forloop_parameter_specification
 parameter_specification ::=
identifierplage_indiscrète
[Link] Prochaine déclaration :
Une instruction suivante est utilisée pour terminer l'exécution de l'une des itérations d'un
instruction de boucle englobante (appelée boucle dans le texte suivant). L'achèvement est
conditionnel si l'énoncé inclut une condition.
next_statement ::=
[ label : ]next[loop_label ] [whencondition ] ;

[Link] Déclaration de sortie :

Une instruction de sortie est utilisée pour terminer l'exécution d'une boucle englobante.

déclaration (appelée boucle dans le texte suivant). L'achèvement est conditionnel si le

L'énoncé inclut une condition.
exit_statement ::=
[ label : ]exit[loop_label ] [whencondition ] ;
[Link] Instruction de retour
Une instruction de retour est utilisée pour compléter l'exécution de l'enclos le plus interne.
corps de fonction ou de procédure

.return_statement ::=
[ label : ]return[ expression ] ;
[Link] Déclaration nulle
Une instruction nulle n'exécute aucune action.

null_statement ::=
[ label : ]null;

1.8 Data Flow Modeling:

The various forms of concurrent statements are described in this section.
Les instructions concurrentes sont utilisées pour définir des blocs et des processus interconnectés qui conjointement

décrire le comportement général ou la structure d'un design. Les déclarations simultanées s'exécutent

de manière asynchrone l'un par rapport à l'autre.

1.8.1 Déclaration de bloc :

Une instruction de bloc définit un bloc interne représentant une partie d'un design.
Les blocs peuvent être imbriqués de manière hiérarchique pour supporter la décomposition de la conception.
 block_statement ::=
block_label :
bloc[ (expression_de_garde) ] [est]
block_header
partie_déclarative_du_bloc
début
partie_de_l'instruction_bloc
fin bloc[étiquette_bloc] ;
Si une expression de garde apparaît après le mot réservé bloc, alors un signal avec le
le nom simple GUARD de type prédéfini BOOLEAN est déclaré implicitement à la
début de la partie déclarative du bloc, et l'expression de garde définit la valeur
de ce signal à tout moment donné (voir 12.6.4). Le type de l'expression de garde doit être
type BOOLEAN. Le signal GUARD peut être utilisé pour contrôler le fonctionnement de certains

déclarations à l'intérieur du bloc (voir 9.5).

1.8.2 Instructions d'appel de procédure concurrentes :
Une instruction d'appel de procédure concurrente représente un processus contenant le
instruction d'appel de procédure séquentielle correspondante.

concurrent_procedure_call_statement ::=
[ label : ] [postponed] procedure_call ;

Pour toute instruction d'appel de procédure concurrente, il existe un processus équivalent.

L'énoncé équivalent d'un processus est un processus différé si et seulement si le

L'instruction d'appel de procédure concurrente inclut le mot réservé reporté.
1.8.3 Déclarations d'assertion concurrentes :
Une déclaration d'assertion concurrente représente une déclaration de processus passif

contenant l'énoncé d'assertion spécifié.

concurrent_assertion_statement ::=
[ label : ] [postponed] assertion ;

1.8.4 Instructions d'assignation de signal concurrent

A concurrent signal assignment statement represents an equivalent process

déclaration qui attribue des valeurs aux signaux.

concurrent_signal_assignment_statement ::=
[ label : ] [postponed] conditional_signal_assignment
| [ label : ] [postponed] selected_signal_assignment
1.8.5 Attributions de signal conditionnelles :

L'assignation conditionnelle de signal représente une déclaration de processus dans laquelle le

La transformation du signal est une instruction if.

cible <= options forme_d'onde1quandcondition1sinon

onde2quandcondition2sinon
forme d'onde3quandcondition3sinon
--------------
---------------
ondeformeN-1quandcondition-1sinon
ondeformeNquandconditionN;
1.8.6 Attributions de signal sélectionnées :

L'affectation de signal sélectionnée représente une instruction de processus dans laquelle le signal

transform est une instruction case.

avec des expressions sélectionnées

cible <= options onde1quandchoix_liste1 ,

ondeforme2quandchoix_liste2
onde3quandchoix_liste3
--------------
---------------
ondeformeN-1quandchoix_listeN-1,
ondeformeNquandchoix_listeN ;
1.9 .Modélisation structurelle :

1.9.1 Déclarations de composants :

Une déclaration de composant déclare une interface d'entité de conception virtuelle qui peut être

used in a component instantiation statement. A component configuration or a

La spécification de configuration peut être utilisée pour associer une instance de composant à un design.

entité qui réside dans une bibliothèque.

component_declaration ::=
componentidentifier [is]
[clause_générique_locale]
[local_port_clause ]
fin du composant[composant_nom_simple] ;

Chaque objet d'interface dans la clause générique locale déclare un générique local. Chaque
L'interface de l'objet dans la clause de port local déclare un port local. Si un nom simple apparaît à
la fin d'une déclaration de composant, elle doit répéter l'identifiant du composant
déclaration.
1.9.2 Déclarations d'instanciation de composants :
Une déclaration d'instanciation de composant définit un sous-composant de l'entité de conception

dans lequel il apparaît, associe des signaux ou des valeurs aux ports de ce sous-composant, et
associe des valeurs avec des génériques de ce sous-composant. Ce sous-composant est une instance
d'une classe de composants définie par une déclaration de composant correspondante, conception

entité, ou déclaration de configuration.

component_instantiation_statement ::=
instantiation_label :
unité_instanciée
[ generic_map_aspect ]
[ port_map_aspect ] ;

unité_instanciée ::=
[component]component_name
|entityentity_name [ (architecture_identifier ) ]
|configurationconfiguration_name
 CHAPITRE 3
Conceptiondumodèlematériel

3.1 Convolution
La convolution est un outil important dans le traitement des données, en particulier dans le traitement des signaux et des images numériques.

traitement. De nombreuses opérations de traitement d'image telles que le redimensionnement et la rotation nécessitent un rééchantillonnage

ou filtrage par convolution pour chaque pixel de l'image Les images numériques peuvent être modifiées (par
convolution) par des opérations de voisinage ; ces opérations vont au-delà des opérations ponctuelles, et
inclure le lissage, le renforcement et la détection des contours. La convolution a de nombreuses applications qui

have great significance in discrete signal processing. It is usually difficult to deal with analog
signaux. Ainsi, les signaux sont convertis en état numérique. De nombreuses approches ont été tentées pour

reduce the convolution processing time using hardware and software algorithms but they are
restreint à des applications spécifiques. Le principal problème dans la mise en œuvre et le calcul
la convolution est la vitesse, la surface et la puissance qui affectent tout système DSP. Accélérer la convolution

l'utilisation d'un langage de description matériel pour l'entrée de conception augmente (améliore) non seulement le

niveau d'abstraction, mais ouvre également de nouvelles possibilités d'utilisation des dispositifs programmables. Aujourd'hui,

la plupart des DSP souffrent de limitations dans l'espace d'adresses disponible, ou de la capacité à s'interfacer avec
systèmes environnants. L'utilisation de circuits intégrés reprogrammables sur le terrain à haute vitesse, c'est-à-dire les FPGA, ensemble

avec des DSP, il est souvent possible d'augmenter la bande passante du système, en fournissant des fonctionnalités supplémentaires à

DSPs à usage général. Dans ce projet, une méthode novatrice pour calculer la convolution linéaire de
Deux séquences de longueur finie sont présentées. Un circuit de convolution 4x4 peut être instancié pour plus grand.

Cette méthode est similaire à la multiplication de deux nombres décimaux, cette similarité que
rend cette méthode facile à apprendre et rapide à calculer.
3.2 Convolution dans le domaine temporel

Lorsque la convolution de deux signaux est effectuée dans le domaine temporel, elle est appelée convolution dans
domaine temporel. Nous traitons la convolution dans le domaine temporel dans ce projet. Dans le domaine temporel

la convolution peut également être continue ou discrète. Lorsque la convolution est dans le domaine temporel, c'est

discret alors on l'appelle convolutions dans le temps discret et quand la convolution est effectuée
en ce qui concerne le temps continu, on l'appelle convolution comme convolution en temps continu.
La convolution dans le temps discret et continu est décrite dans le chapitre précédent.

3.3 Convolution dans le domaine fréquentiel

Lorsque deux signaux sont convolués dans le domaine de fréquence, on appelle cela la convolution dans
domaine de fréquence. Il est prouvé que la convolution dans le domaine temporel est équivalente à
multiplication dans le domaine de la fréquence.

Preuve :

Letf,gbelong toL1(Rn). Soit F la transformée de Fourier de f et G la transformée de Fourier de g :

Où le point entre x et ν indique le produit intérieur de Rn. Lethbe leconvolutionde f

etg

Maintenant, remarquez que

Donc parLe théorème de Fubininous avons cela donc sa transformation de Fourier est définie par
la formule intégrale

Observez que et donc par l'argument ci-dessus

nous pouvons appliquer à nouveau le théorème de Fubini :

Substitutey=z−x; thendy=dz, so:

Ces deux intégrales sont les définitions de F(ν) et G(ν), donc :

Ainsi, il est prouvé que la convolution dans le domaine temporel est équivalente à la multiplication dans
domaine de fréquence.

3.4 FLUX D'INVESTISSEMENT GÉNÉRAL

Le diagramme de flux d'implémentation généralisé du projet est représenté comme suit.
Figure 3.5 Diagramme de flux d'implémentation général
 Au départ, une étude de marché devrait être réalisée, couvrant la version précédente de la
la conception et les exigences actuelles sur la conception. Sur la base de cette enquête, la spécification et le
l'architecture doit être identifiée. Ensuite, la modélisation RTL doit être effectuée en VERILOG
VHDL par rapport à l'architecture identifiée. Une fois que la modélisation RTL est terminée, elle devrait être

simulé et vérifié pour tous les cas. La vérification fonctionnelle doit répondre aux exigences prévues
architecture et devrait passer tous les cas de test.
Une fois la vérification fonctionnelle claire, le modèle RTL sera soumis à la synthèse.
processus. Trois opérations seront réalisées dans le processus de synthèse, telles que

Traduire
Carte
Placement et Routage

Le modèle RTL développé sera traduit au format d'équation mathématique qui

sera dans le format compréhensible de l'outil. Ces équations traduites seront ensuite cartographiées
à la bibliothèque c'est-à-dire, mappé sur le matériel. Une fois le mappage effectué, les portes ont été placées

et acheminé. Avant ces processus, les contraintes peuvent être données afin d'optimiser la conception.
Enfin, le fichier BIT MAP sera généré avec les informations de conception au format binaire.
qui sera déchargé dans la carte FPGA.

3.5 Mise en œuvre

Dans ce projet, la mise en œuvre est réalisée en concevant d'abord les blocs individuels et ensuite
ceux-ci sont combinés à l'architecture finale. Les blocs individuels sont montrés dans un diagramme de blocs

ci-dessous :

3.5.1 Schéma de bloc

Le schéma du bloc de l'architecture proposée est montré ci-dessous :
[Link] Multiplexeur 4*1 et 8*1 :
Un multiplexeur, parfois appelé un "multiplexeurou simplement "mux", est un dispositif qui sélectionne
entre un certain nombre de signaux d'entrée. Dans sa forme la plus simple, un multiplexer aura deux signaux

entrées, une entrée de contrôle, et une sortie.

Un multiplexeur est un dispositif qui sélectionne l'une des entrées parmi 2nentrées et dirigées
pour sortir en fonction de n-lignes sélectionnées.

Fig : multiplexeur 4*1

 Fig. Multiplexeur 8*1
Les multiplexeurs de plus haut rang peuvent être implémentés en utilisant des multiplexeurs de plus bas rang. Le 4*1

un multiplexeur peut être implémenté en utilisant deux multiplexeurs 2*1, et ainsi de suite. De même, un 8*1

Un multiplexeur peut être implémenté en utilisant deux multiplexeurs 4x1.

[Link] Bloc série en sortie parallèle :

Un registre à décalage série-en/parallèle-sortie est similaire au registre à décalage série-en/série-sortie dans
qu'il transfère des données dans des éléments de stockage internes et transfère des données à la sortie série, à la sortie des données, à la broche.

Il est différent en ce sens qu'il rend toutes les étapes internes disponibles en tant que sorties. Par conséquent, un série

Le registre à décalage in/parallel-out convertit les données du format série au format parallèle. Si quatre bits de données

sont décalés de quatre impulsions d'horloge via un seul fil à l'entrée de données, ci-dessous, les données deviennent disponibles

simultanément sur les quatre sorties QUnà QDaprès la quatrième impulsion d'horloge.
L'application pratique du registre à décalage série/en parallèle est de convertir des données de série
format sur un seul fil au format parallèle sur plusieurs fils. Peut-être que nous allons éclairer quatre
LEDs (Diodes Électroluminescentes) avec les quatre sorties (QAQBQCQD).

Les détails ci-dessus du registre à décalage série-en/parallèle-sont assez simples. Cela ressemble à un série-
dans un registre à décalage série-sortie avec des prises ajoutées à chaque sortie de stade. Les données série se décalent à l'entrée SI

Après un nombre d'horloges égal au nombre d'étapes, le premier bit de données apparaît à SO
(QD) dans la figure ci-dessus. En général, il n'y a pas de broche SO. La dernière étape (QDci-dessus) sert de SO
et est transmis au paquet suivant s'il existe.

The shift register has been cleared prior to any data byCLR', an active low signal, which clears
tous les bascules D de type D dans le registre à décalage. Notez le motif de données en série 1011 présenté à la
SIinput. Ces données sont synchronisées avec l'horloge CLK. Ce serait le cas si elle est en cours de
déplacé à partir de quelque chose comme un autre registre à décalage, par exemple, un registre à décalage parallèle en/série.

registre (non montré ici). Sur la première horloge att1, le data1atSI est décalé de D à Q de la
première étape du registre à décalage. Après t2, ce premier bit de données est à QB. Aprèst3it est àQC. Aprèst4it est àQD.

Quatre impulsions d'horloge ont déplacé le premier bit de données jusqu'à la dernière étape QDLes deuxième données

bit a0is atQCaprès le 4ème horloge. Le troisième bit de données a1 est à QBLe quatrième bit de données est un autre1
àQA. Ainsi, le motif d'entrée de données série 1011 est contenu dans (QDQCQBQA). Il est maintenant disponible
sur les quatre sorties.
Il sera disponible sur les quatre sorties juste après l'horloge.4juste avant5. Ce parallèle
les données doivent être utilisées ou stockées entre ces deux moments, sinon elles seront perdues en raison du décalage du QD

étape sur les horloges suivantes5tot8as shown above.

[Link] Multiplicateur binaire :

Le multiplicateur binaire utilisé ici est un multiplicateur de 4 bits qui prend deux entrées de quatre bits et

donne une sortie de 8 bits.

 Fig : Multiplicateur binaire

Le multiplicateur binaire qui est utilisé dans la convolution ici dans le présent
le projet a une caractéristique spéciale selon laquelle le transport interne ne sera pas transféré à l'étape suivante. Donc

le nombre de sorties obtenues ici est de sept seulement parce que dans le multiplicateur binaire, la partie MSB est

rien d'autre que le report obtenu du deuxième MSB donc comme le report n'est pas transféré, seulement sept bits

sera obtenu en sortie.

[Link] Registre :
Un circuit avec des bascules est considéré comme un circuit séquentiel même en l'absence de combinatoire
logique. Les circuits qui incluent des bascules sont généralement classés par la fonction qu'ils remplissent. Deux
de tels circuits sont des registres et des compteurs.

Un registre est un groupe de bascules. Sa fonction principale est de conserver des informations.

dans un système numérique afin de le rendre disponible aux unités logiques pendant le calcul
processus. Cependant, un registre peut également avoir des fonctionnalités supplémentaires qui lui sont associées. Il peut

ont des portes combinatoires qui effectuent certaines tâches de traitement de données.

Fig : un registre de 8 bits

Divers types de registres sont disponibles sur le marché. Un registre simple de 4 bits est montré.
ci-dessous. L'horloge commune déclenche tous les bascules et les données binaires disponibles aux quatre
inputs are transferred into the register. The clear input is useful for clearing the register to all
0's sortie.

Registres capables de décaler leur contenu binaire dans une ou les deux directions. A
registre à décalage unidirectionnel de 4 bits qui utilise uniquement des bascules est comme suit :
Fig : Registre à décalage
 CHAPITRE 4
Résultatsetdiscussions
4.1IntroductiontoModelSimulator:
4.1.1 Flux de simulation de base

Le diagramme suivant montre les étapes de base pour simuler un design dans ModelSim.

Figure -4.1. Flux de Simulation de Base - Aperçu du Lab

Dans ModelSim, tous les conceptions sont compilées dans une bibliothèque. Vous commencez généralement une nouvelle simulation dans ModelSim en

création d'une bibliothèque de travail appelée "travail". "Travail" est le nom de la bibliothèque utilisé par le compilateur comme valeur par défaut

destination pour les unités de conception compilées.

Compiler votre conception

Après avoir créé la bibliothèque de travail, vous compilez vos unités de conception dedans. Le format de bibliothèque ModelSim est

compatible sur toutes les plateformes supportées. Vous pouvez simuler votre conception sur n'importe quelle plateforme sans avoir

recompiler votre conception.

Charger le simulateur avec votre conception et exécuter la simulation Avec la conception compilée, vous
chargez le simulateur avec votre conception en invoquant le simulateur sur un module de niveau supérieur (Verilog) ou un

configuration ou paire entité/architecture (VHDL). En supposant que la conception se charge avec succès, la simulation
le temps est fixé à zéro, et vous entrez
une commande d'exécution pour commencer la simulation.

Débogage de vos résultats

Si vous n'obtenez pas les résultats escomptés, vous pouvez utiliser le débogage robuste de ModelSim.

environnement pour identifier la cause du problème.

4.1.2 Flux de projet

Un projet est un mécanisme de collecte pour une conception HDL sous spécification ou test. Même si

vous n'avez pas besoin d'utiliser des projets dans ModelSim, ils peuvent faciliter l'interaction avec l'outil et sont

utile pour organiser des fichiers et spécifier les paramètres de simulation.

Le diagramme suivant montre les étapes de base pour simuler une conception dans un projet ModelSim.

Figure -4.2 Flux de conception du projet

Comme vous pouvez le voir, le flux est similaire au flux de simulation de base. Cependant, il y a deux

important differences:

Vous n'avez pas à créer de bibliothèque fonctionnelle dans le flux du projet ; cela est fait pour vous.
automatiquement.

Les projets sont persistants. En d'autres termes, ils s'ouvriront chaque fois que vous invoquez ModelSim.

à moins que vous ne les fermiez spécifiquement.

4.1.3 Flux de plusieurs bibliothèques

ModelSim utilise les bibliothèques de deux manières : 1) en tant que bibliothèque de travail locale contenant les compilés

version of your design; 2) as a resource library. The contents of your working library will

changez au fur et à mesure que vous mettez à jour votre design et recompilez. Une bibliothèque de ressources est généralement statique et

sert de source de pièces pour votre conception. Vous pouvez créer vos propres bibliothèques de ressources, ou elles

peut être fourni par une autre équipe de conception ou un tiers (par exemple, un fournisseur de silicium).

Vous spécifiez quelles bibliothèques de ressources seront utilisées lorsque le design est compilé, et il y a

règles pour spécifier dans quel ordre ils sont recherchés. Un exemple commun de l'utilisation des deux un fonctionnel

une bibliothèque et une bibliothèque de ressources est un endroit où votre conception au niveau porte et votre banc d'essai sont compilés.

dans la bibliothèque de travail, et les références de conception utilisent des modèles au niveau de la porte dans une ressource séparée

bibliothèque.

Le diagramme ci-dessous montre les étapes de base pour simuler avec plusieurs bibliothèques.
 Figure 4-3. Flux de plusieurs bibliothèques

Outils de débogage

ModelSim offre de nombreux outils pour déboguer et analyser votre conception. Plusieurs d'entre eux

Les outils sont couverts dans les leçons suivantes, y compris :

Utiliser des projets

Travailler avec plusieurs bibliothèques

Définir des points d'arrêt et parcourir le code source

Visualiser des formes d'onde et mesurer le temps

Visionner et initialiser les mémoires

Créer un stimulus avec l'éditeur de forme d'onde

Automatisation de la simulation

4.1.4 Simulation de base

Figure 4-4. Flux de simulation de base - Laboratoire de simulation

Fichiers de conception pour cette leçon

Le design de l'échantillon pour cette leçon est un simple compteur binaire de 8 bits avec un associé

banc d'essai. Les chemins sont les suivants :

Verilog–<install_dir>/exemples/tutoriels/verilog/simulationBasiques/compteur.v et tcompteur.v

VHDL–<install_dir>/exemples/tutoriels/vhdl/simulationDeBase/[Link]

Cette leçon utilise les fichiers Verilog filescounter.v et tcounter.v. Si vous avez une licence VHDL, utilisez

[Link] à la place. Ou, si vous avez une licence mixte, n'hésitez pas à utiliser le

Testbench Verilog avec le compteur VHDL ou vice versa.

4.1.5 Créer la bibliothèque de conception fonctionnelle

Avant de pouvoir simuler un design, vous devez d'abord créer une bibliothèque et compiler le code source dans celle-ci.

bibliothèque.

1. Créez un nouveau répertoire et copiez les fichiers de conception pour cette leçon dedans.

Commencez par créer un nouveau répertoire pour cet exercice (au cas où d'autres utilisateurs travailleront avec ces leçons).

Verilog : Copier le compteur.v et le compteur.v fichiers de

/<install_dir>/exemples/tutoriels/verilog/simulationDeBase vers le nouveau répertoire.

VHDL : Copier les fichiers [Link] et [Link] de

/<install_dir>/exemples/tutoriels/vhdl/simulationBasiquevers le nouveau répertoire.

2. Démarrez ModelSim si nécessaire.

a. Tapez vsimat à l'invite de commande UNIX ou utilisez l'icône ModelSim sous Windows. En ouvrant ModelSim
pour la première fois, vous verrez la boîte de dialogue Bienvenue dans ModelSim. Cliquez sur Fermer.

b. Sélectionner le fichier > Changer de répertoire et changer pour le répertoire que vous avez créé à l'étape 1.

3. Créez la bibliothèque de travail.

a. Sélectionner Fichier > Nouveau > Bibliothèque.

Cela ouvre une boîte de dialogue où vous spécifiez des noms physiques et logiques pour la bibliothèque (Figure 3-2). Vous pouvez

créer une nouvelle bibliothèque ou mapper à une bibliothèque existante. Nous ferons la première option.
 Figure 4.5. La boîte de dialogue Créer une nouvelle bibliothèque

b. Tapez dans le champ Nom de la bibliothèque (s'il n'est pas déjà rempli automatiquement).

c. CliquezOK.

ModelSim crée un répertoire appelé work et écrit un fichier au format spécial nommé _info dedans.
répertoire. Le fichier_info doit rester dans le répertoire pour le distinguer comme une bibliothèque ModelSim. Ne pas éditer
le contenu du dossier de votre système d'exploitation ; tous les changements doivent être effectués depuis ModelSim.
ModelSim ajoute également la bibliothèque à la liste dans l'espace de travail (Figure 3-3) et enregistre la cartographie de la bibliothèque.

pour référence future dans le fichier d'initialisation de ModelSim ([Link]).

Figure 4-6. Bibliothèque de travail dans l'espace de travail

Lorsque vous avez appuyé sur OK à l'étape 3c ci-dessus, ce qui suit a été imprimé dans le Transcript :

vlib travail

vmap travail travail

Ces deux lignes sont les équivalents en ligne de commande des sélections de menu que vous avez effectuées. De nombreuses

Les équivalents en ligne de commande afficheront leurs fonctions basées sur un menu de cette manière.

4.1.6 Compiler le design

Avec la bibliothèque de travail créée, vous êtes prêt à compiler vos fichiers source.

Vous pouvez compiler en utilisant les menus et les dialogues de l'interface graphique, comme dans le Verilog

exemple ci-dessous, ou en saisissant une commande à l'invite ModelSim>.

1. [Link].v.

a. Sélectionnez Compiler > Compiler. Cela ouvre la boîte de dialogue Compiler les fichiers source (Figure 3-4).

Si l'option de menu Compiler n'est pas disponible, vous avez probablement un projet ouvert. Dans ce cas, fermez le projet en

making the Workspace pane active and selectingFile > Closefrom the menus.

b. Sélectionnez à la fois counter.v et tcounter.v dans la boîte de dialogue Compiler les fichiers source et cliquez sur Compiler.

Les fichiers sont compilés dans theworklibrary.c. Lorsque la compilation est terminée, cliquez sur Terminer.
Dialogue de compilation des fichiers source 4-7

2. Voir les unités de conception compilées.

a. Dans l'onglet Bibliothèque, cliquez sur l'icône '+' à côté de theworklibrary et vous verrez deux unités de conception (Figure

3-5). Vous pouvez également voir leurs types (Modules, Entités, etc.) et le chemin vers les fichiers source sous-jacents
(faites défiler vers la droite si nécessaire).

b. Double-cliquez sur test_counter pour charger le design.

Vous pouvez également charger le design en sélectionnant Simuler > Démarrer la simulation dans la barre de menu. Cela ouvre le

Démarrer le dialogue de simulation. Avec l'onglet Conception sélectionné, cliquez sur le signe ‘+’ à côté de la bibliothèque de travaux pour voir le

modules_controle_et_test. Sélectionner

letest_compteurmodule et cliquez sur OK (Figure 4.8).

Figure 4-8. Chargement du design avec la boîte de dialogue Démarrer la simulation

Lorsque le design est chargé, vous verrez un nouvel onglet dans l'espace de travail nommé sim qui affiche le
structure hiérarchique de la conception (Figure 4-8). Vous pouvez naviguer dans la hiérarchie en cliquant sur n'importe quel
ligne avec une icône ‘+’ (développer) ou ‘-’ (réduire). Vous verrez également un onglet nommé Fichiers qui affiche tous les fichiers

inclus dans la conception.

Figure 4-8. Modules VHDL compilés dans la bibliothèque de travail

4.1.7 Charger le design

1. Charge le module test_counter dans le simulateur.

a. Dans l'Espace de travail, cliquez sur le signe ‘+’ à côté du travail bibliothécaire pour afficher les fichiers contenus là.
Figure 4-9. L'onglet de simulation de l'espace de travail affiche la hiérarchie de conception

2. Afficher les objets de design dans le volet Objets.

a. Ouvrez le menu Vue et sélectionnez Objets. L'équivalent en ligne de commande est : voir objets

Le panneau Objets (Figure 3-8) montre les noms et les valeurs actuelles des objets de données dans la région actuelle.
(sélectionné dans l'espace de travail). Les objets de données incluent des signaux, des réseaux, des registres, des constantes et des variables non

déclaré dans un processus, génériques, paramètres.

Figure 4-10. Le panneau d'objet affiche les objets de conception

Vous pouvez ouvrir d'autres fenêtres et panneaux avec le menu Affichage ou avec la commande vue. Voir Navigation

l'Interface.

4.1.8 Lancer la simulation

Vous allez maintenant ouvrir la fenêtre Wave, y ajouter des signaux, puis exécuter la simulation.

1. Ouvrez la fenêtre de débogage Wave.

a. Entrez l'onde à la ligne de commande

You can also use theView > Wavemenu selection to open a Wave window.

La fenêtre Wave est l'une des plusieurs fenêtres disponibles pour le débogage. Pour voir une liste

des autres fenêtres de débogage, sélectionnez le menu Affichage. Vous devrez peut-être déplacer ou

redimensionnez les fenêtres à votre goût. Les carreaux de fenêtre dans la fenêtre principale peuvent être

zoomé pour occuper l'ensemble de la fenêtre principale ou non arrimé pour être autonome. Pour des détails,

voir Naviguer dans l'interface.

2. Ajoutez des signaux à la fenêtre d'onde.

a. Dans le panneau de l'espace de travail, sélectionnez le tab thesim.

b. Cliquez avec le bouton droit sur test_counter pour ouvrir un menu contextuel.

c. Sélectionnez Ajouter > À Vague > Tous les éléments de la région (Figure 3-9).

Tous les signaux dans la conception sont ajoutés à la fenêtre d'onde.

Figure 4-11. Utiliser le menu contextuel pour ajouter des signaux à la fenêtre d'ondes
3. Exécutez la simulation.

a. Cliquez sur l'icône Exécuter dans la barre d'outils de la fenêtre Principale ou Vague.

La simulation dure 100 ns (la durée de simulation par défaut) et les vagues sont

dessiné dans la fenêtre Wave.

b. Entrez run 500 à l'invite VSIM> dans la fenêtre principale.

La simulation avance de 500 ns supplémentaires pour un total de 600 ns (Figure 3-10).

Figure 4-11. Vagues dessinées dans la fenêtre des vagues

c. Cliquez sur l'icône Exécuter tout sur la barre d'outils de la fenêtre principale ou de la fenêtre Onde.

La simulation continue de s'exécuter jusqu'à ce que vous exécutez une commande d'arrêt ou qu'elle

atteint une déclaration dans votre code (par exemple, une déclaration $stop de Verilog) qui arrête le

simulation.

d. Cliquez sur l'icône de rupture. La simulation cesse de fonctionner.

4.2 Introduction
Le processus de convolution et l'architecture développée pour la fonctionnalité requise
ont été discutés dans les chapitres précédents. Maintenant, ce chapitre traite de la simulation et
résultats de synthèse du processus de convolution. Ici, l'outil Modelsim est utilisé pour simuler le
conçoit et vérifie la fonctionnalité du design. Une fois la vérification fonctionnelle effectuée, le
la conception sera prise dans l'outil Xilinx pour le processus de synthèse et la génération de netlist.

Les cas de test appropriés ont été identifiés afin de tester ce modèle de convolution
architecture des processus. Sur la base des valeurs identifiées, les résultats de la simulation qui décrivent le
l'opération du processus a été réalisée. Cela prouve que le design modélisé fonctionne correctement
selon sa fonctionnalité.
4.3 Résultats de la simulation :

4.3.1 Niveau de convolution :

4.4 Modules individuels :

4.4.1 Multiplexeurs :
4.4.2 SIPO :
4.4.3 Multiplier binaire :
4.4.4 Multiplexeur 8*1 :

4.4.5 Register:
4.5 Introduction aux FPGA :
FPGA signifie tableau logique programmable sur le terrain, qui dispose d'un ensemble de modules logiques.

Module I/O et pistes de routage (interconnexion programmable). Le FPGA peut être configuré par l'utilisateur final.

utilisateur pour mettre en œuvre un circuit spécifique. La vitesse est jusqu'à 100 MHz mais à l'heure actuelle la vitesse est en GHz.

Les principales applications sont le DSP, les ordinateurs basés sur FPGA, l'émulation logique, l'ASIC et l'ASSP.

Les FPGA peuvent être programmés principalement sur SRAM (Mémoire à Accès Aléatoire Statique). C'est volatil et

L'avantage principal de l'utilisation de la technologie de programmation SRAM est la reconfigurabilité. Problèmes dans FPGA

la technologie est la complexité des éléments logiques, le support d'horloge, le support d'E/S et les interconnexions

(Routage).
Dans ce travail, la conception d'un DWT et d'un IDWT est réalisée en utilisant Verilog HDL et est synthétisée.

sur la famille FPGA de Spartan 3E via l'outil XILINX ISE. Ce processus comprend les étapes suivantes :

Traduire
Carte
Placement et routage

4.5.1 Flux FPGA

L'implémentation de base du design sur FPGA comporte les étapes suivantes.
Entrée de conception

Optimisation logique
Cartographie Technologique

Placement
Routage
Unité de Programmation

FPGA configuré
 Ci-dessus sont montrés les étapes de base impliquées dans la mise en œuvre. L'entrée de conception initiale de peut

être Verilog HDL, schéma ou expression booléenne. L'optimisation de l'expression booléenne

sera réalisé en tenant compte de la zone ou de la vitesse.

Figure 4.8 Bloc de logique

Dans le mappage technologique, la transformation d'une expression booléenne optimisée en FPGA

les blocs logiques, qui sont appelés Slices. Ici, l'optimisation de la surface et du délai aura lieu.
Lors du placement, les algorithmes sont utilisés pour placer chaque bloc dans le réseau FPGA. L'assignation du

Segments de fil FPGA, qui sont programmables, pour établir des connexions entre les blocs FPGA
à travers le routage. La configuration de la puce finale est effectuée dans l'unité de programmation.

4.6 Flux de conception Xilinx

La première étape de la mise en œuvre d'un design sur FPGA implique les spécifications du système.
Les spécifications font référence aux types d'entrées et de sorties, ainsi qu'à la gamme de valeurs que le kit peut accepter.

basé sur ces spécifications. Après la première étape des spécifications du système, l'étape suivante est l'architecture.
L'architecture décrit les interconnexions entre tous les blocs impliqués dans notre conception. Chacun de ces blocs
le bloc dans l'Architecture ainsi que leurs interconnexions est modélisé en VHDL ou Verilog
selon la facilité. Tous ces blocs sont ensuite simulés et les sorties sont vérifiées pour leur exactitude
fonctionnement.
Figure 4-12 Diagramme de flux de conception d'implémentation Xilinx.

Après l'étape de simulation, les étapes suivantes, c'est-à-dire la Synthèse. C'est une étape très importante pour connaître

si notre conception peut être implémentée sur un kit FPGA ou non. La synthèse convertit notre code VHDL en son
composants fonctionnels qui sont spécifiques au fournisseur. Après avoir effectué le schéma RTL de synthèse, technologie

Le schéma est généré et les délais de temporisation sont générés. Les délais de temporisation seront présents dans le

FPGA si le design est implémenté dessus. Le placement et le routage est l'étape suivante où l'outil place tous les
composants sur une puce FPGA pour des performances optimales tant en termes de surface que de vitesse. Nous voyons également le

les interconnexions qui seront réalisées dans cette partie du flux de mise en œuvre.

Dans l'étape de simulation après placement et routage, les délais qui seront impliqués sur le kit FPGA sont

considéré par l'outil et la simulation est effectuée en tenant compte de ces délais qui seront
présent dans les mises en œuvre sur le kit. Les délais ici signifient effet de charge électrique, délais de câblage, dérive

capacitances.

Après le placement et le routage postérieurs, vient la génération du fichier bitmap, ce qui signifie la conversion du VHDL.

code into bit streams which is useful to configure the FPGA kit. A bit file is generated this step is
réalisé. Après cela vient l'étape finale de téléchargement du fichier bitmap sur la carte FPGA qui est
réalisé en connectant l'ordinateur à la carte FPGA avec l'aide d'un câble JTAG (Joint Test Action Group)
qui est une norme IEEE. Le fichier de carte de bits contient l'ensemble du design qui est placé sur la puce FPGA,
les sorties peuvent maintenant être observées à partir des LED FPGA. Cette étape complète tout le processus de

implémenter notre conception sur un FPGA.

4.7 Logiciel Xilinx ISE 10.1

4.7.1 Introduction

Le logiciel Xilinx ISE (Integrated Software Environment) 9.2i provient de la société XILINX, qui est
utilisé pour concevoir tout circuit numérique et l'implémenter sur un dispositif FPGA Spartan-3E. XILINX ISE 9.2i

le logiciel est utilisé pour concevoir l'application, vérifier la fonctionnalité et enfin télécharger le design sur un
Dispositif FPGA Spartan-3E.

4.7.2 Outils logiciels Xilinx ISE 10.1

SIMULATION : ISE (Integrated Software Environment) Simulator

SYNTHÈSE, LIEU & POUTE : XST (Technologie de Synthèse Xilinx) Synthétiseur

4.7.3 Étapes de conception utilisant Xilinx ISE 10.1

1 Créez un PROJET ISE pour une application de système embarqué particulière.

2 Écrivez le code d'assemblage dans notepad ou write pad et générez le module verilog ou vhdl en faisant
utilisation de l'assembleur.

3 Vérifiez la syntaxe pour le design.

4 Créez un banc d'essai Verilog du design.

5 Simulez la forme d'onde du banc d'essai (SIMULATION COMPORTEMENTALE) pour la vérification fonctionnelle de la
conception utilisant le simulateur ISE.

6 Synthétiser et mettre en œuvre le module de niveau supérieur en utilisant le synthétiseur XST.

4.8 Résultat de la synthèse

Le projet de convolution développé est simulé et sa fonctionnalité est vérifiée. Une fois que le
la vérification fonctionnelle est effectuée, le modèle RTL est pris pour le processus de synthèse à l'aide de l'outil Xilinx ISE.

Dans le processus de synthèse, le modèle RTL sera converti en liste de portes au niveau des portes mappée à un spécifique
bibliothèque de technologie. Ici dans cette famille Spartan 3E, de nombreux appareils différents étaient disponibles dans le Xilinx

Outil ISE. Le dispositif cible est le kit FPGA SPARTAN 2. Pour synthétiser ce design, le dispositif nommé est
"XC3S100E" a été choisi et le boîtier comme "TQ144" avec une vitesse de dispositif telle que "5".

4.4 Résultat de Synthèse

Le projet de convolution développé est simulé et sa fonctionnalité est vérifiée. Une fois que le
La vérification fonctionnelle est effectuée, le modèle RTL est soumis au processus de synthèse en utilisant le Xilinx

Outil ISE. Dans le processus de synthèse, le modèle RTL sera converti en liste de connexion au niveau des portes.
à une bibliothèque technologique spécifique. Ici, dans cette famille Spartan 3E, de nombreux dispositifs différents ont été

disponible dans l'outil Xilinx ISE. Pour synthétiser ce design, le dispositif nommé comme
"XC3S500E" a été choisi et le boîtier comme "FG320" avec une vitesse de dispositif telle que "-4".
Ce design est synthétisé et ses résultats ont été analysés comme suit.
 CHAPITRE 5

ConclusionetTravauxFuturs

5.1 Conclusion

5.2 Portée future du travail