SEm/laboratoires/03 convertisseur

From FSI
(Difference between revisions)
Jump to: navigation, search
(Modulateur de premier ordre)
 
(12 intermediate revisions by 2 users not shown)
Line 1: Line 1:
 
{{TOC right}}
 
{{TOC right}}
 +
 +
= Convertisseur numérique / analogique =
  
 
== Introduction ==
 
== Introduction ==
 +
Ce laboratoire permet de consolider les connaissances acquises sur le traitement de nombres. Il nous fournira un composant utile pour la suite: le convertisseur numérique / analogique. Il soulève certaines questions au sujet de la simulation de circuits de complexité moyenne.
 +
La conversion numérique / analogique se fera ici avec un modulateur sigma-delta (SD). Le signal original est codé en impulsions à une fréquence bien supérieure à la fréquence d'échantillonnage minimale. Le codage en impulsions est similaire à la modulation de largeur d'impulsions (Pulse Width Modulation, PWM) dans le fait que le signal d'origine se retrouve dans la moyenne des impulsions. A fréquences de fonctionnement identiques, le codage SD donne un meilleur rapport signal sur bruit que la PWM.
  
</div></div></div>
+
[[Image:SEm_DAC.png|center|Modulateur sigma-delta]]
  
Dans ce laboratoire, nous allons effectuer des opérations sur des nombres. Ceci sera illustré par le clacul de l'interpolation de points de la fonction sinus d'un générateur de fonctions numérique.
+
== Modulateur de premier ordre ==
 +
Le modulateur SD reçoit un signal numérique et le convertit en signal codé sur un bit, avec la forme d'un train d'impulsions.
  
<div class="figure">
+
Le modulateur SD de premier ordre peut se comprendre par l'analogie de la mesure du débit d'un cours d'eau:
  
'''Figure 1. Générateur de fonctions avec calcul de sinus par interpolation'''
+
* Le cours d'eau est amené dans un bassin qu'il va remplir.
 +
* Dès que le niveau du bassin dépasse une ligne de référence, un opérateur retire un seau d'eau du bassin.
 +
* Le débit moyen du cours d'eau est égal à la contenance du seau fois le nombre de seaux écopés par unité de temps.
  
<div class="figure-contents"><div class="mediaobject"><center>[[Image:sineGen.png]]</center></div></div></div><br class="figure-break" />
+
Le modulateur se réalise comme suit:
  
Le calcul de l'interpolation se base sur l'approximation de la fonction entre deux points donnés par des fonctions polynomiales du troisième ordre. Cette méthode appartient à la grande famille des "splines".
+
* A chaque période d'horloge, la nouvelle valeur du signal est additionnée à un accumulateur.
 +
* Le bit de poids fort du résultat est le signal de sortie du modulateur (impulsion ou pas).
 +
* Si ce bit de poids fort est à '1', une valeur de 2<sup>n</sup> est soustraite à l'accumulateur, n étant le nombre de bits du signal à convertir.
  
Le circuit se trouve dans la librairie <span class="command">'''SineInterpolator'''</span>, le banc de test dans la librairie <span class="command">'''SineInterpolator_test'''</span>.
+
[[Image:SEm_sigmaDelta1.png|thumb|Modulateur sigma-delta de premier ordre]]
 
+
</div><div class="section" title="Table de sinus"><div class="titlepage"><div><div>
+
 
+
== Table de sinus ==
+
 
+
</div></div></div>
+
 
+
L'interpolation se fera à partir d'une table contenant 8 valeurs de sinus pour un quart de sa période. Pour fonctionner sur toute la période, le signal en dents de scie provenant du compteur et considéré comme phase du sinus est utilisé comme suit:
+
 
+
<div class="itemizedlist">
+
 
+
* Le bit de poids fort signale le changement de signe des valeurs du sinus.
+
* Le bit suivant signale un changement à apporter à la phase pour lire la table dans le sens inverse, ceci pour les deuxième et quatrième quarts de la période.
+
* Les 3 bits suivants (<span class="command">'''tableAddressBitNb = 3'''</span>) sont utilisés pour adresser les valeurs de la table.
+
* Les autres bits sont ignorés.
+
 
+
</div><div class="figure">
+
 
+
'''Figure 2. Table de sinus'''
+
 
+
<div class="figure-contents"><div class="mediaobject"><center>[[Image:sineTable.png]]</center></div></div></div><br class="figure-break" /><div class="section" title="Code VHDL"><div class="titlepage"><div><div>
+
  
 
=== Code VHDL ===
 
=== Code VHDL ===
  
</div></div></div>
+
L'accumulateur interne a besoin de plus de bits que le signal d'entrée. Prévoir 4 bits supplémentaires et la simulation montrera le nombre effectivement nécessaire.
  
Ecrire l'architecture VHDL du générateur de sinus.
+
{{TaskBox|content=
 
+
Ecrire l'architecture VHDL du modulateur SD.}}
L'adresse de la table de sinus est tirée des 3 bits suivant les 2 bits de poids fort de la phase. Elle effectue la séquence 0, 1, 2, 3, 4, 5, 6, 7, 0, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, ....
+
 
+
La table de sinus contient les valeurs hexadécimales 0000 ou 7FFF (selon la valeur du deuxième bit de poids fort), 18F9, 30FB, 471C, 5A82, 6A6D, 7641 et 7D89.
+
 
+
Lorsque le bit de poids fort de la phase vaut '1', la valeur lue de la table change de signe pour donner la sortie.
+
 
+
</div><div class="section" title="Simulation"><div class="titlepage"><div><div>
+
  
 
=== Simulation ===
 
=== Simulation ===
  
</div></div></div>
+
{{TaskBox|content=
 +
Compiler et simuler le bloc '''DAC_tb'''.}}
  
Compiler et simuler le bloc <span class="command">'''sineGen_tb'''</span>. Vérifier le bon fonctionnement du générateur de sinus.
+
L'amplitude du signal de sortie est donnée par la valeur moyenne de la sortie.  
  
</div></div><div class="section" title="Interpolation"><div class="titlepage"><div><div>
+
{{TaskBox|content=
 +
Trouver un moyen d'estimer cette valeur moyenne pour comparer le signal parallèle d'entrée et le train d'impulsions en sortie.}}
  
== Interpolation ==
+
La restitution analogique du signal qui reste longtemps à '1' ou à '0' est délicate.
  
</div></div></div>
+
{{TaskBox|content=
 +
Ajouter un gain de 1/2 et un décalage au signal d'entrée pour éviter ce problème en réduisant la gamme du signal.
 +
Refaire la simulation avec cette modification.}}
  
L'interpolation se fait en associant une fonction polynomiale d'ordre 3 entre chaque point de la table de sinus:
+
{{TaskBox|content=
 +
Examiner le déroulement temporel du contenu de l'accumulateur et déterminer le nombre de bits nécessaire.}}
  
<span class="command">'''    y = a·k^3 b·k^2 c·k d'''</span>
+
{{TaskBox|content=
 +
Réduire le nombre de bits de l'accumulateur et relancer la simulation.}}
  
Au cours du calcul, le point courant de la table de sinus est défini en <span class="command">'''k = 0'''</span>, le point précédent en <span class="command">'''k = -1'''</span> et le point suivant en <span class="command">'''k = 1'''</span>. Nous calculerons la valeur du polynome pour <span class="command">'''n = 2^m'''</span> points situés entre 0 et 1.
+
== Modulateur de deuxième ordre ==
 +
Le modulateur du deuxième ordre comporte deux accumulateurs. La figure suivante présente le modulateur à réaliser:
  
Pour assurer la continuité entre le polynôme qui relie le segment <span class="command">'''-1 &lt; k &lt; 0'''</span> et celui qui relie <span class="command">'''0 &lt; k &lt; 1'''</span>, nous spécifons la dérivée au point <span class="command">'''y(k=0)'''</span> comme étant égale à la pente entre les points <span class="command">'''y(k=-1)'''</span> et <span class="command">'''y(k=1)'''</span>. Nous ferons de même pour tous les points de la fonction à interpoler.
+
[[Image:SEm_sigmaDelta2.png|thumb|Modulateur sigma-delta de deuxième ordre]]
  
Le segment <span class="command">'''0 &lt; k &lt; 1'''</span> est donc soumis aux 4 conditions suivantes
+
Pour ce circuit, les nombres seront considérés comme signés.
 +
Lorsque la valeur du second accumulateur est positive:
  
<span class="command">'''    y(k=0) = y0'''</span><nowiki>: le polynôme passe par le point </nowiki><span class="command">'''(k=0, y=y0)'''</span>,
+
* La sortie vaut '1'.
 +
* Une valeur de '''c1=2<sup>nBits-1</sup>''' est retranchée du premier accumulateur.
 +
* Une valeur de '''c2=2<sup>nBits+3</sup>''' est retranchée du second accumulateur.
  
<span class="command">'''    y(k=1) = y1'''</span><nowiki>: le polynôme passe par le point </nowiki><span class="command">'''(k=1, y=y1)'''</span>,
+
Lorsque la valeur du second accumulateur est négative:
  
<span class="command">'''    y'(k=0) = [y(k=1) - y(k=-1)] / 2'''</span><nowiki>: la dérivée au point </nowiki><span class="command">'''(k=0)'''</span> est la pente entre <span class="command">'''y(k=-1)'''</span> et <span class="command">'''y(k=1)'''</span>,
+
* La sortie vaut '0'.
 +
* Une valeur de '''c1=2<sup>nBits-1</sup>''' est ajoutée au premier accumulateur.
 +
* Une valeur de '''c2=2<sup>nBits+3</sup>''' est ajoutée au second accumulateur.
  
<span class="command">'''    y'(k=1) = [y(k=2) - y(k=0)] / 2'''</span><nowiki>: la dérivée au point </nowiki><span class="command">'''(k=1)'''</span> est la pente entre <span class="command">'''y(k=0)'''</span> et <span class="command">'''y(k=2)'''</span>.
+
La valeur '''nBits''' est le nombre de bits du signal d'entrée du modulateur, '''x'''.
  
Ces 4 conditions nous servent à déterminer les 4 coefficients <span class="command">'''a'''</span>, <span class="command">'''b'''</span>, <span class="command">'''c'''</span> et <span class="command">'''d'''</span> du ploynôme à partir des 4 points <span class="command">'''y(k=-1)'''</span> à <span class="command">'''y(k=2)'''</span> de la courbe à interpoler. La résolution de ce système d'équations nous donne les valeurs suivantes des coefficients:
+
=== Code VHDL ===
  
<span class="command">'''    a = 1/2 [ - y(k=-1) 3·y(k=0) -3·y(k=1) y(k=2) ]'''</span>
+
Prévoir pour chacun des accumulateurs 8 bits de plus que le signal d'entrée.
 +
Inverser le bit de poids fort du signal d'entrée et lui appliquer un gain de 7/8.
  
<span class="command">'''    b = 1/2 [ 2·y(k=-1) -5·y(k=0) 4·y(k=1) - y(k=2) ]'''</span>
+
{{TaskBox|content=
 
+
Ecrire une deuxième architecture VHDL pour le modulateur SD.}}
<span class="command">'''    c = 1/2 [ - y(k=-1)   y(k=1) ]'''</span>
+
 
+
<span class="command">'''    d = y(k=0)'''</span>
+
 
+
Par souci de simplification, nous calculerons le double de la valeur des coefficients et par la suite nous diviserons la valeur du polynome calculé par 2.
+
 
+
A chaque nouvelle valeur du signal d'origine (ici, de la table de sinus), il faut recalculer les coefficients du polynôme. Puis, à chaque période d'horloge et en attendant l'arrivée de la valeur suivante, on calcule la fonction polynomiale pour déterminer la valeur courante de l'échantillon de sortie.
+
 
+
<div class="section" title="G&eacute;n&eacute;rateur d&#39;impulsions de s&eacute;quencement"><div class="titlepage"><div><div>
+
 
+
=== Générateur d'impulsions de séquencement ===
+
 
+
</div></div></div>
+
 
+
Ecrire l'architecture VHDL du générateur d'impulsions de séquencement.
+
 
+
<div class="figure">
+
 
+
'''Figure 3. Générateurs d'impulsions de séquencement'''
+
 
+
<div class="figure-contents"><div class="mediaobject"><center>[[Image:interpolatorTrigger.png]]</center></div></div></div><br class="figure-break" />
+
 
+
Ce circuit fournit une impulsion qui dure une période d'horloge à chaque changement de polynôme, c'est-à-dire pour chaque nouveau segment de courbe.
+
 
+
Ceci se fait chaque <span class="command">'''2^n'''</span> périodes d'horloge où <span class="command">'''en = '1''''</span>, avec <span class="command">'''n = sampleCountBitNb = phaseBitNb-2-tableAddressBitNb'''</span>. Dans notre exemple de laboratoire, <span class="command">'''phaseBitNb = 10'''</span> et <span class="command">'''sampleCountBitNb = 5'''</span>.
+
 
+
</div><div class="section" title="Registre &agrave; d&eacute;calage"><div class="titlepage"><div><div>
+
 
+
=== Registre à décalage ===
+
 
+
</div></div></div>
+
 
+
Ecrire l'architecture VHDL du registre à décalage qui mémorise les 4 derniers points de la fonction à interpoler.
+
 
+
<div class="figure">
+
 
+
'''Figure 4. Registre à décalage'''
+
 
+
<div class="figure-contents"><div class="mediaobject"><center>[[Image:interpolatorShiftRegister.png]]</center></div></div></div><br class="figure-break" />
+
 
+
A chaque impulsion de synchronisation <span class="command">'''shiftSamples'''</span>, le circuit mémorise le nouvel échantillon de la fonction à interpoler, <span class="command">'''sampleIn'''</span>, et le mémorise comme dernière valeur d'échantillon, <span class="command">'''sample4'''</span>. En même temps, il décale l'échantillon <span class="command">'''sample4'''</span> dans <span class="command">'''sample3'''</span>, etc...
+
 
+
</div><div class="section" title="Calcul des coefficients"><div class="titlepage"><div><div>
+
 
+
=== Calcul des coefficients ===
+
 
+
</div></div></div>
+
 
+
Ecrire l'architecture VHDL du bloc qui calcule les coefficients du polynôme en fonction de la valeur des 4 derniers points de la fonction à interpoler.
+
 
+
<div class="figure">
+
 
+
'''Figure 5. Bloc de calcul des coefficients pour l'interpolation'''
+
 
+
<div class="figure-contents"><div class="mediaobject"><center>[[Image:interpolatorCoefficients.png]]</center></div></div></div><br class="figure-break" />
+
 
+
Les coefficients se calculent comme suit:
+
 
+
<span class="command">'''    a = - sample1 3·sample2 -3·sample3 sample4'''</span>
+
 
+
<span class="command">'''    b = 2·sample1 -5·sample2 4·sample3 - sample4'''</span>
+
 
+
<span class="command">'''    c = - sample1  sample3'''</span>
+
 
+
<span class="command">'''    d = sample2'''</span>
+
 
+
Expliquer le choix effectué <span class="command">'''coeffBitNb := signalBitNb 3'''</span>.
+
 
+
Parcourir la librairie <span class="command">'''ieee.numeric_std'''</span> et vérifier l'effet de la multiplication d'un signal de type <span class="command">'''signed'''</span> par un nombre entier. Vérifier également le fonctionnement de la fonction <span class="command">'''resize'''</span>. Elle est très utile ici pour forcer le nombre de bits des signaux.
+
 
+
</div><div class="section" title="Calcul du polyn&ocirc;me"><div class="titlepage"><div><div>
+
 
+
=== Calcul du polynôme ===
+
 
+
</div></div></div>
+
 
+
Ecrire l'architecture VHDL du bloc qui calcule la valeur du polynôme d'interpolation de fonction à chaque nouvelle période d'horloge.
+
 
+
<div class="figure">
+
 
+
'''Figure 6. Bloc de calcul de l'interpolation'''
+
 
+
<div class="figure-contents"><div class="mediaobject"><center>[[Image:interpolatorPolynom.png]]</center></div></div></div><br class="figure-break" />
+
 
+
Le polynôme se calcule de manière itérative.
+
 
+
Ainsi, pour une fonction de premier ordre, <span class="command">'''y(x) = a·x   b'''</span>, la valeur suivante vaut <span class="command">'''y(x eps) = y(x)   a·eps'''</span>. Ceci se calcule en initialisant <span class="command">'''u = a·eps'''</span>, <span class="command">'''y(0) = b'''</span>, et en calculant <span class="command">'''y(i 1) = y(i)   u'''</span> à chaque nouvelle période d'horloge.
+
 
+
Pour une fonction de deuxième ordre, <span class="command">'''y(x) = a·x^2   b·x   c'''</span>, ce qui donne <span class="command">'''y(x eps) = y(x)   u(x)'''</span>, avec <span class="command">'''u(x) = 2·a·eps·x   (a·eps^2   b·eps)'''</span>. L'incrément <span class="command">'''u(x)'''</span> se calcule de la manière définie pour une fonction du premier ordre. Ceci se calcule donc en initialisant <span class="command">'''v = 2·a·eps^2'''</span>, <span class="command">'''u(0) = a·eps^2   b·eps'''</span>, <span class="command">'''y(0) = c'''</span>, et en calculant <span class="command">'''y(i 1) = y(i)   u(i)'''</span> et <span class="command">'''u(i 1) = u(i)   v'''</span> à chaque nouvelle période d'horloge.
+
 
+
Le calcul de la fonction de troisième ordre se fait de manière similaire.
+
 
+
Pour le calcul numérique, <span class="command">'''eps'''</span> est choisi comme égal à une puissance négative de 2, ce qui permet de la calculer par un décalage. De même, pour rester avec des nombres entiers, on calculera la fonction <span class="command">'''y(i)'''</span> multipliée par une puissance de 2 et un décalage terminal nous donnera la valeur finale des échantillons du polynôme.
+
 
+
Notre algorithme est donc le suivant:
+
 
+
<div class="itemizedlist">
+
 
+
* A l'arrivée d'un nouvel échantillon, il faut calculer les valeurs initiales utilisée pour développer le polynôme de manière itérative.
+
* Entre deux échantillons d'entrée, le calcul de la fonction polynomiale se fait par additions à l'aide des équations itératives.
+
 
+
</div>
+
 
+
Les valeurs initiales sont les suivantes:
+
 
+
<span class="command">'''    x = 2·d·2^(3·m)'''</span>
+
 
+
<span class="command">'''    u = a b·2^m c·2^(2·m)'''</span>
+
 
+
<span class="command">'''    v = 6·a 2·b·2^m'''</span>
+
 
+
<span class="command">'''    w = 6·a'''</span>
+
 
+
<span class="command">'''    y = d'''</span>
+
 
+
Le calcul itératif du polynôme se fait comme suit:
+
 
+
<span class="command">'''    x = x u'''</span>
+
 
+
<span class="command">'''    u = u v'''</span>
+
 
+
<span class="command">'''    v = v w'''</span>
+
 
+
<span class="command">'''    y = x / 2·2^(3·m)'''</span>
+
 
+
Il est évident que, du fait des décalages <span class="command">'''2^m'''</span>, le nombre de bits des signaux internes devra être plus élevé que le nombre de bits des échantillons d'entrée ou de sortie. En fonction de la valeur du décalage <span class="command">'''m = oversamplingBitNb'''</span>, estimer la taille nécessaire pour ces signaux. Les décalrer avec 8 bits supplémentaires pour s'assurer de ne pas avoir de dépassement de capacité.
+
 
+
A nouveau, la fonction <span class="command">'''resize'''</span>sera très utile ici.
+
 
+
</div><div class="section" title="Simulation"><div class="titlepage"><div><div>
+
  
 
=== Simulation ===
 
=== Simulation ===
  
</div></div></div>
+
{{TaskBox|content=
 
+
Reompiler et resimuler le bloc '''DAC_tb'''.
Recompiler et simuler le bloc <span class="command">'''sineGen_tb'''</span>. Vérifier la forme du signal sinusoïdal après interpolation.
+
Vérifier la forme du signal de sortie.}}
 
+
Réduire le nombre de bits des signaux du circuit là où cela est possible.
+
  
</div></div></div>
+
{{TaskBox|content=
 +
Déterminer le nombre minimal de bits nécessaire pour chacun des accumulateurs, réduire leur taille à ce nombre et vérifier que le fonctionnement du modulateur reste bon.}}
  
{{navNamed|left=SEm/laboratoires/02_interpolation|left_name=02 Générateur de fonctions avec calcul d'interpolation|up=SEm/laboratoires|up_name=Instructions en français|right=SEm/laboratoires/04_synthese|right_name=04 Synthèse automatique}}
+
{{navNamed
 +
|left=SEm/laboratoires/02_interpolation|left_name=02 Générateur de fonctions avec calcul d'interpolation
 +
|up=SEm/laboratoires|up_name= Travaux de laboratoire
 +
|right=SEm/laboratoires/04_synthese|right_name=04 Synthèse automatique
 +
}}
  
[[Category:SEm]]
+
[[Category:Bachelor]] [[Category:SEm]] [[Category:Français]]

Latest revision as of 10:17, 6 March 2019

Contents

Convertisseur numérique / analogique

Introduction

Ce laboratoire permet de consolider les connaissances acquises sur le traitement de nombres. Il nous fournira un composant utile pour la suite: le convertisseur numérique / analogique. Il soulève certaines questions au sujet de la simulation de circuits de complexité moyenne. La conversion numérique / analogique se fera ici avec un modulateur sigma-delta (SD). Le signal original est codé en impulsions à une fréquence bien supérieure à la fréquence d'échantillonnage minimale. Le codage en impulsions est similaire à la modulation de largeur d'impulsions (Pulse Width Modulation, PWM) dans le fait que le signal d'origine se retrouve dans la moyenne des impulsions. A fréquences de fonctionnement identiques, le codage SD donne un meilleur rapport signal sur bruit que la PWM.

Modulateur sigma-delta

Modulateur de premier ordre

Le modulateur SD reçoit un signal numérique et le convertit en signal codé sur un bit, avec la forme d'un train d'impulsions.

Le modulateur SD de premier ordre peut se comprendre par l'analogie de la mesure du débit d'un cours d'eau:

  • Le cours d'eau est amené dans un bassin qu'il va remplir.
  • Dès que le niveau du bassin dépasse une ligne de référence, un opérateur retire un seau d'eau du bassin.
  • Le débit moyen du cours d'eau est égal à la contenance du seau fois le nombre de seaux écopés par unité de temps.

Le modulateur se réalise comme suit:

  • A chaque période d'horloge, la nouvelle valeur du signal est additionnée à un accumulateur.
  • Le bit de poids fort du résultat est le signal de sortie du modulateur (impulsion ou pas).
  • Si ce bit de poids fort est à '1', une valeur de 2n est soustraite à l'accumulateur, n étant le nombre de bits du signal à convertir.
Modulateur sigma-delta de premier ordre

Code VHDL

L'accumulateur interne a besoin de plus de bits que le signal d'entrée. Prévoir 4 bits supplémentaires et la simulation montrera le nombre effectivement nécessaire.


View-pim-tasks.png

Ecrire l'architecture VHDL du modulateur SD.

Simulation

View-pim-tasks.png

Compiler et simuler le bloc DAC_tb.

L'amplitude du signal de sortie est donnée par la valeur moyenne de la sortie.


View-pim-tasks.png

Trouver un moyen d'estimer cette valeur moyenne pour comparer le signal parallèle d'entrée et le train d'impulsions en sortie.

La restitution analogique du signal qui reste longtemps à '1' ou à '0' est délicate.


View-pim-tasks.png

Ajouter un gain de 1/2 et un décalage au signal d'entrée pour éviter ce problème en réduisant la gamme du signal. Refaire la simulation avec cette modification.


View-pim-tasks.png

Examiner le déroulement temporel du contenu de l'accumulateur et déterminer le nombre de bits nécessaire.


View-pim-tasks.png

Réduire le nombre de bits de l'accumulateur et relancer la simulation.

Modulateur de deuxième ordre

Le modulateur du deuxième ordre comporte deux accumulateurs. La figure suivante présente le modulateur à réaliser:

Modulateur sigma-delta de deuxième ordre

Pour ce circuit, les nombres seront considérés comme signés. Lorsque la valeur du second accumulateur est positive:

  • La sortie vaut '1'.
  • Une valeur de c1=2nBits-1 est retranchée du premier accumulateur.
  • Une valeur de c2=2nBits+3 est retranchée du second accumulateur.

Lorsque la valeur du second accumulateur est négative:

  • La sortie vaut '0'.
  • Une valeur de c1=2nBits-1 est ajoutée au premier accumulateur.
  • Une valeur de c2=2nBits+3 est ajoutée au second accumulateur.

La valeur nBits est le nombre de bits du signal d'entrée du modulateur, x.

Code VHDL

Prévoir pour chacun des accumulateurs 8 bits de plus que le signal d'entrée. Inverser le bit de poids fort du signal d'entrée et lui appliquer un gain de 7/8.


View-pim-tasks.png

Ecrire une deuxième architecture VHDL pour le modulateur SD.

Simulation

View-pim-tasks.png

Reompiler et resimuler le bloc DAC_tb. Vérifier la forme du signal de sortie.


View-pim-tasks.png

Déterminer le nombre minimal de bits nécessaire pour chacun des accumulateurs, réduire leur taille à ce nombre et vérifier que le fonctionnement du modulateur reste bon.


Navigation
Arrow left.gif 02 Générateur de fonctions avec calcul d'interpolation Arrow up.gif Travaux de laboratoire 04 Synthèse automatique Arrow right.gif

Personal tools
Namespaces
Variants
Actions
Navigation
Modules / Projects
Browse
Toolbox