SEm/labore/02 interpolation

(Difference between revisions)
Jump to: navigation, search
(Created page with "{{TOC right}} {{TOC right}} = Funktionsgenerator mit Interpolationsberechnung = ---- '''Inhaltsverzeichnis''' EinleitungSägezahnVHDL CodeSimulation[[S...")
 
(Schieberegister)
(27 intermediate revisions by 3 users not shown)
Line 1: Line 1:
{{TOC right}}
 
 
{{TOC right}}
 
{{TOC right}}
  
 
= Funktionsgenerator mit Interpolationsberechnung =
 
= Funktionsgenerator mit Interpolationsberechnung =
  
----
 
 
'''Inhaltsverzeichnis'''
 
 
[[Einleitung]][[Sägezahn]][[VHDL Code]][[Simulation]][[Sinustabelle]][[VHDL Code]][[Simulation]][[Interpolation]][[Generator von Sequenzierungsimpulsen]][[Schieberegister]][[Berechnung der Koeffizienten]][[Berechnung des Polynoms]][[Simulation]]
 
 
== Einleitung ==
 
== Einleitung ==
  
In diesem Labor werden wir Operationen auf Zahlen durchführen. Dies wird illustriert mit
+
In diesem Labor werden wir verschiedene Operationen mit Zahlen durchführen.
der Berechnung der Interpolation von Pünkten in der Sinusfunktion eines digitales
+
Dies am Beispiel der Interpolation der Punkte der Sinuskurve eines digitales Funktionsgenerator.
Funktionsgenerator.
+
 
+
[[Image:sineGen.png]]
+
'''Abbildung 1. Funktionsgenerator mit Berechnung des Sinus durch Interpolation'''
+
  
<br>
+
Die Berechnung der Interpolation basiert auf der Annäherung der Funktion zwischen 2 Punkten mit Polynomialfunktionen dritter Ordnung.
Die Berechnung der Interpolation basiert auf der Ann&auml;herung der Funktion zwischen
+
Diese Methode gehört zur grossen Familie der ''Splines''.
2 P&uuml;nkte mit Polynomialfunktionen dritter Ordnung. Diese Methode geh&ouml;rt der grossen
+
Familie der "Splines".
+
  
Die Schaltung befindet sich in der Library '''SineInterpolator''', die
+
Die Schaltung befindet sich in der Library '''SineInterpolator''', die Testbank in der Library '''SineInterpolator_test'''.
Testbank in der Library '''SineInterpolator_test'''.
+
  
== S&auml;gezahn ==
+
[[Image:SEm_sineGen.png|center|Funktionsgenerator mit Berechnung des Sinus durch Interpolation]]
  
In dieser Schaltung ist die Anzahl Bits der Phase nicht gleich der Anzahl Bits der
+
== Sägezahn ==
Funktionsgenerator-Ausg&auml;nge.
+
  
Zur erstellung der Grundausg&auml;nge: S&auml;gezahn, Viereck und Dreieck &auml;ndert der Block
+
In dieser Schaltung ist die Anzahl Bits der Phase nicht gleich derjenigen der Funktionsgenerator-Ausgänge.
'''resizer''' die Anzahl Bits des Phasensignals und passt es den
+
Ausg&auml;ngssignalen an. Drei f&auml;lle sind zu betrachten:
+
  
Pour la g&eacute;n&eacute;ration des signaux de base: dent de scie, carr&eacute; et triangle, le bloc
+
Wenn Ihr die Basisausgänge ''Sägezahn'', ''Viereck'' und ''Dreieck'' erstellt, ändert der Block '''resizer''' die Anzahl Bits des Phasensignals und passt es den Ausgängssignalen an. Dabei gibt es drei Fälle zu beachten:
'''resizer''' change la taille du signal de phase afin de l'adapter &agrave; celle des
+
signaux de sortie. trois cas sont &agrave; pr&eacute;voir:
+
  
* Die Anzahl Bits der Ausg&auml;ngen ist kleiner als die des Phasensignals: in diesem Fall werden die MSBs behalten.
+
* Die Anzahl Bits der Ausgänge ist kleiner als die des Phasensignals: in diesem Fall werden die MSBs behalten.
* Die Anzahl Bits der Ausg&auml;ngen ist gleich wie die des Phasensignals: in diesem Fall werden alle Bits &uuml;bertagt.
+
* Die Anzahl Bits der Ausgänge ist gleich wie die des Phasensignals: in diesem Fall werden alle Bits übertragen.
* Die Anzahl Bits der Ausg&auml;ngen ist kleiner als die des Phasensignals: in diesem Fall wird der Phasensignal in den MSBs des S&auml;gezahnsignals gelegt.
+
* Die Anzahl Bits der Ausgänge ist kleiner als die des Phasensignals: in diesem Fall wird das Phasensignal in die MSBs des Sägezahnsignals gelegt.
  
 
=== VHDL Code ===
 
=== VHDL Code ===
  
Mit Hilfe des Konstruktes '''if &#8230; generate''', schreiben Sie den VHDL Code
+
{{TaskBox|content=
des '''resizer'''-Blocks.
+
Mit Hilfe des Konstruktes '''if ... generate''', schreiben Sie den VHDL Code des '''resizer'''-Blocks.}}
  
 
=== Simulation ===
 
=== Simulation ===
  
Compilieren Sie und simulieren Sie den Block '''sineGen_tb'''. &Auml;ndern Sie
+
{{TaskBox|content=
die Anzahl Bits des Phasensignals und &uuml;berpr&uuml;fen Sie die Anpassung der Anzahl Bits in jedem
+
Kompilieren und simulieren Sie den Block '''sineGen_tb'''.
m&ouml;glichen Operationsfall.
+
Ändern Sie die Anzahl Bits des Phasensignals und überprüfen Sie die Anpassung der Anzahl Bits in jedem möglichen Operationsfall.}}
  
 
== Sinustabelle ==
 
== Sinustabelle ==
  
Die Interpolation wird durchgef&uuml;hrt abhand einer Tabelle, welche 8 Werte der
+
[[Image:SEm_sineTable.png|thumb|Sinustabelle]]
Sinusfunktion im ersten Viertel der Periode enth&auml;lt. Um die Werte f&uuml;r die ganze Periode
+
anzuwenden, wird das S&auml;gezahnsignal des Phasenz&auml;hlers wie folgt angewandt:
+
  
* Der MSB gibt an, ob das Vorzeichen zu &auml;ndern ist.
+
Die Interpolation wird durchgeführt abhand einer Tabelle, welche 8 Werte der Sinusfunktion im ersten Viertel der Periode enthält. Um die Werte für die ganze Periode
* Der n&auml;chste Bit meldet, dass die Phase ge&auml;ndert sein soll, um die Tabelle in der umgekehrten Richtung zu lesen, dies f&uuml;r den zweiten und den vierten Viertel der Periode.
+
anzuwenden, wird das Sägezahnsignal des Phasenzählers wie folgt angewandt:
* Die 3 weitere Bits ('''tableAddressBitNb = 3''') sind als Adresse f&uuml;r das Lesen der Tabellenwerte angewandt.
+
 
* Alle andere Bits werden vernachl&auml;ssigt.
+
* Der MSB gibt an, ob das Vorzeichen zu ändern ist.
[[Image:sineTable.png]]
+
* Der nächste Bit meldet, dass die Phase geändert sein soll, um die Tabelle in der umgekehrten Richtung zu lesen, dies für den zweiten und den vierten Viertel der Periode.
'''Abbildung 2. Sinustabelle'''
+
* Die 3 weitere Bits ('''tableAddressBitNb = 3''') sind als Adresse für das Lesen der Tabellenwerte angewandt.
 +
* Alle andere Bits werden vernachlässigt.
  
<br>
 
 
=== VHDL Code ===
 
=== VHDL Code ===
  
Schreiben Sie die VHDL Architektur des Sinuswellengenerators.
+
{{TaskBox|content=
 +
Schreiben Sie die VHDL Architektur des Sinuswellengenerators.}}
  
Die Adresse der tabelle stammt aus den 3 Bits nach den 2 MSBs. Sie z&auml;hlt die
+
Die Adresse der tabelle stammt aus den 3 Bits nach den 2 MSBs. Sie zählt die Sequenz 0, 1, 2, 3, 4, 5, 6, 7, 0, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, ....
Sequenz 0, 1, 2, 3, 4, 5, 6, 7, 0, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, ....
+
  
Die SinusTabelle enth&auml;lt die Hexadezimalwerte 0000 oder 7FFF (abh&auml;ngend auf den zweiten
+
Die Sinustabelle enthält die Hexadezimalwerte 0000 oder 7FFF (abhängig vom zweithöchstwertigsten Bit), 18F9, 30FB, 471C, 5A82, 6A6D, 7641 und 7D89.
MSB), 18F9, 30FB, 471C, 5A82, 6A6D, 7641 und 7D89.
+
 
 +
Wenn das MSB der Phase gleich '1' ist, so wird das Vorzeichen des Tabellenwertes invertiert, um den Ausgang zu erzeugen.
  
Wenn der MSB der Phase gleich '1' ist, so wird das Vorzeichen des Tabellenwertes
 
invertiert, um den Ausgang zu erzeugen.
 
 
=== Simulation ===
 
=== Simulation ===
  
Compilieren Sie und simulieren Sie den Block '''sineGen_tb'''. Pr&uuml;fen Sie
+
{{TaskBox|content=
die Funktionalit&auml;t des Sinuswellensignalgenerators.
+
Kompilieren Sie und simulieren Sie den Block '''sineGen_tb'''. Prüfen Sie die Funktionalität des Sinuswellensignalgenerators.}}
  
 
== Interpolation ==
 
== Interpolation ==
  
Die Interpolation wird gemacht, indem man eine verschiedene Polynomialfunktion 3. Ordnung
+
Die Interpolation wird gemacht, indem man eine verschiedene Polynomialfunktion 3. Ordnung zu jedem Intervall zwischen zwei Punkte der Sinustabelle zuweist:
zu jedem Intervall zwischen zwei P&uuml;nkte der Sinustabelle zuweist:
+
  
''' y = a&middot;k^3 + b&middot;k^2 + c&middot;k +d'''
+
''' y = a·k<sup>3</sup> + b·k<sup>2</sup> + c·k +d '''
  
W&auml;hrend dieser Berechnung wird der jeweilige Punkt der Tabelle mit
+
Während dieser Berechnung wird der jeweilige Punkt der Tabelle mit '''k = 0''' definiert, der vorige Punkt mit '''k = -1''' und der nächste mit '''k = 1''' definiert. Wir werden die Polynomialfunktion für '''n = 2<sup>m</sup>''' Punkte zwischen 0 und 1 berechnen.
'''k = 0''' definiert, der vorige Punkt mit '''k = -1''' und der
+
n&auml;chste mit '''k = 1''' definiert. Wir werden die Polynomialfunktion f&uuml;r
+
'''n = 2^m''' P&uuml;nkte zwischen 0 und 1 berechnen.
+
  
Um die Kontinuit&auml;t der Kurve beim &Uuml;bergang vom Polynom des Segments
+
Um die Kontinuität der Kurve beim Übergang vom Polynom des Segments '''-1 < k < 0''' und dem von '''0 < k < 1''', spezifieren wir, dass die derivative am Punkt '''y(k=0)''' gleich der Steigung zwischen den Punkten '''y(k=-1)''' und '''y(k=1)'''sein soll. Wir werden dasselbe für alle Punkte der zu interpolierenden Funktion machen.
'''-1 &lt; k &lt; 0''' und dem von '''0 &lt; k &lt; 1''',
+
spezifieren wir, dass die derivative am Punkt '''y(k=0)''' gleich der Steigung
+
zwischen den P&uuml;nkten '''y(k=-1)''' und '''y(k=1)'''sein soll. Wir
+
werden dasselbe f&uuml;r alle P&uuml;nkte der zu interpolierenden Funktion machen.
+
  
Das Segment '''0 &lt; k &lt; 1''' dient somit den 4 folgenden
+
Das Segment '''0 < k < 1''' dient somit den 4 folgenden Bedingungen:
Bedingungen:
+
  
''' y(k=0) = y0''': das Polynom geht &uuml;ber den Punkt '''(k=0,
+
''' y(k=0) = y0''': das Polynom geht durch den Punkt '''(k=0, y=y0)''',
y=y0)''',
+
  
''' y(k=1) = y1''': das Polynom geht &uuml;ber den Punkt '''(k=1,
+
''' y(k=1) = y1''': das Polynom geht durch den Punkt '''(k=1, y=y1)''',
y=y1)''',
+
  
''' y'(k=0) = [y(k=1) - y(k=-1)] / 2''': die Derivative am Punkt
+
''' y'(k=0) = [y(k=1) - y(k=-1)] / 2''': die Ableitung am Punkt '''(k=0)''' ist die Steigung zwischen '''y(k=-1)''' und '''y(k=1)''',
'''(k=0)''' ist die Steigung zwischen '''y(k=-1)''' und
+
'''y(k=1)''',
+
  
''' y'(k=1) = [y(k=2) - y(k=0)] / 2''': die Derivative am Punkt
+
''' y'(k=1) = [y(k=2) - y(k=0)] / 2''': die Ableitung am Punkt '''(k=1)''' ist die Steigung zwischen '''y(k=0)''' und '''y(k=2)'''.
'''(k=1)''' ist die Steigung zwischen '''y(k=0)''' und
+
'''y(k=2)'''.
+
  
Diese 4 Bedingungen dienen zur Bestimmung des 4 Koeffizienten '''a''',
+
Diese 4 Bedingungen dienen zur Bestimmung der 4 Koeffizienten '''a''', '''b''', '''c''' und '''d''' des Polynoms anhand der 4 Punkte '''y(k=-1)''' bis '''y(k=2)''' der zu interpolierenden
'''b''', '''c''' und '''d''' des Polynoms abhand der
+
Kurve. Die Auflösung dieses Gleichungssystems gibt uns die folgenden Werte der Koeffizienten:
4 P&uuml;nkte '''y(k=-1)''' bis '''y(k=2)''' der zu interpolierende
+
Kurve. Die Aufl&ouml;sung dieses Gleichungssystems gibt uns die folgenden Werte der
+
Koeffizienten:
+
  
''' a = 1/2 [ - y(k=-1) +3&middot;y(k=0) -3&middot;y(k=1) + y(k=2) ]'''
+
''' a = 1/2 [ - y(k=-1) +3·y(k=0) -3·y(k=1) + y(k=2) ]'''
  
''' b = 1/2 [ 2&middot;y(k=-1) -5&middot;y(k=0) +4&middot;y(k=1) - y(k=2) ]'''
+
''' b = 1/2 [ 2·y(k=-1) -5·y(k=0) +4·y(k=1) - y(k=2) ]'''
  
 
''' c = 1/2 [ - y(k=-1) + y(k=1) ]'''
 
''' c = 1/2 [ - y(k=-1) + y(k=1) ]'''
Line 134: Line 95:
 
''' d = y(k=0)'''
 
''' d = y(k=0)'''
  
Um die Berechnungen zu vereinfachen werden wir den doppelten Wert der Koeffizienten
+
Um die Berechnungen zu vereinfachen werden wir den doppelten Wert der Koeffizienten evaluieren und später die berechnete Werte des Polynoms durch 2 teilen.
evaluieren und sp&auml;ter die berechnete Werte des Polynoms durch 2 teilen.
+
  
Beim Auftreten jedes neuen Werts des urspr&uuml;nglichen Signals (hier die Sinustabelle),
+
Beim Auftreten jedes neuen Werts des ursprünglichen Signals (hier die Sinustabelle), müssen die Polynomkoeffiziente neu berechnet werden. Dann, in der Zwischenzeit, wird die Polynomilafunktion berechnet, um den jeweilgen Wert des Ausgangssignal zu bestimmen.
m&uuml;ssen die Ploynomkoeffiziente neu berechnet werden. Dann, in der Zwischenzeit, wird die
+
Polynomilafunktion berechnet, um den jeweilgen Wert des Ausgangssignal zu bestimmen.
+
  
 
=== Generator von Sequenzierungsimpulsen ===
 
=== Generator von Sequenzierungsimpulsen ===
  
Schreiben Sie die VHDL Architektur des Generators von Sequenzierungsimpulsen.
+
[[Image:SEm_interpolatorTrigger.png|thumb|Genrator von Sequenzierungsimpulsen]]
  
[[Image:interpolatorTrigger.png]]
+
{{TaskBox|content=
'''Abbildung 3. Generator von Sequenzierungsimpulsen'''
+
Schreiben Sie die VHDL Architektur des Generators von Sequenzierungsimpulsen.}}
  
<br>
+
Diese Schaltung ermittelt einen Impuls mit der Dauer einer Taktperiode bei jedem Polynomwechsel, das heisst zu jedem neuen Kurvensegment.
Diese Schaltung ermittelt einen Impuls mit der Dauer einer Taktperiode bei jedem
+
Polynomwechsel, das heisst zu jedem neuen Kurvensegment.
+
  
Dies erfolgt zu jeden '''2^n''' Taktperioden wo '''en =
+
Dies erfolgt zu jeden '''2<sup>n</sup>''' Taktperioden wo '''en = '1'''', wobei '''n = sampleCountBitNb = phaseBitNb-2-tableAddressBitNb'''. In unserem Laborbeispiel sind '''phaseBitNb = 10''' und '''sampleCountBitNb = 5'''.
'1'''', wobei '''n = sampleCountBitNb
+
= phaseBitNb-2-tableAddressBitNb'''. In unserem Laborbeispiel sind
+
'''phaseBitNb = 10''' und '''sampleCountBitNb = 5'''.
+
  
 
=== Schieberegister ===
 
=== Schieberegister ===
  
Schreiben Sie die VHDL Architektur des Schieberegisters, welcher die 4 letzte
+
[[Image:SEm_interpolatorShiftRegister.png|thumb|Schieberegister]]
P&uuml;nkte der zu interpolendierenden Funktion speichert.
+
  
[[Image:interpolatorShiftRegister.png]]
+
{{TaskBox|content=
'''Abbildung 4. Schieberegister'''
+
Schreiben Sie die VHDL Architektur des Schieberegisters, welcher die 4 letzten Punkte der zu interpolendierenden Funktion speichert.}}
  
<br>
+
Bei jedem Synchronisationsimplus '''shiftSamples''' speichert dis Schaltung den neuen Wert der zu interpolendierenden Funktion, '''sampleIn''', und speichert es als letzes Abtastwert, '''sample4'''. Zugleich schiebt er den gespeicherten Wert von '''sample4''' zurück in '''sample3''', usw...
Bei jedem Synchronisationsimplus '''shiftSamples''' speichert dis Schaltung
+
 
den neuen Wert der zu interpolendierenden Funktion, '''sampleIn''', und
+
{{WarningBox|content=Verwenden Sie ein Array von Zahlen, um den Shieberegister zu beschreiben.}}
speichert es als letzes Abtastwert, '''sample4'''. Zugleich schiebt er den
+
gespeicherten Wert von '''sample4''' zur&uuml;ck in '''sample3''',
+
usw...
+
  
 
=== Berechnung der Koeffizienten ===
 
=== Berechnung der Koeffizienten ===
  
Schreiben Sie die VHDL Architektur des Blocks, welcher die Koeffizienten des Polynoms
+
[[Image:SEm_interpolatorCoefficients.png|thumb|Block zur Berechnung der Koeffizienten für die Interpolation]]
berechnet als Funktion der 4 letzten P&uuml;nkten der zu interpolendierenden
+
Funktion.
+
  
[[Image:interpolatorCoefficients.png]]
+
{{TaskBox|content=
'''Abbildung 5. Block zur Berechnung der Koeffizienten f&uuml;r die Interpolation'''
+
Öffnen Sie die Library '''ieee.numeric_std''' und durchsuchen Sie die Auswirkung der Multiplikation eines Signals von Typ '''signed''' durch eine ganze Zahl. Prüfen Sie ebenfalls das Funktionieren der Funktion '''resize'''. Sie ist hier sehr nützlich, um die Anzahl der Bits der Signale zu bestimmen.}}
  
<br>
+
Die Koeffizienten werden wie folgt berechnet:
Die Koeffiziente werden wie folgt berechnet:
+
  
''' a = - sample1 +3&middot;sample2 -3&middot;sample3 + sample4'''
+
''' a = - sample1 +3·sample2 -3·sample3 + sample4'''
  
''' b = 2&middot;sample1 -5&middot;sample2 +4&middot;sample3 - sample4'''
+
''' b = 2·sample1 -5·sample2 +4·sample3 - sample4'''
  
 
''' c = - sample1 + sample3'''
 
''' c = - sample1 + sample3'''
Line 192: Line 138:
 
''' d = sample2'''
 
''' d = sample2'''
  
Erkl&auml;ren Sie die getroffene Wahl im Schema '''coeffBitNb :=
+
{{TaskBox|content=
signalBitNb+3'''.
+
Schreiben Sie die VHDL Architektur des Blocks, welcher die Koeffizienten des Polynoms als Funktion der 4 letzten Punkten der zu interpolendierenden Funktion berechnet.}}
  
&Ouml;ffnen Sie die Library '''ieee.numeric_std''' und durchsuchen Sie die
+
[[File:SEm_sinegen_coeffs.svg|thumb|Interpolationskoeffizienten]]
Auswirkung der Multiplikation eines Signals von Typ '''signed''' durch eine
+
Die von Ihnen berechneten Koeffizienten können mit der [[Media:SEm_sinegen_coeffs.svg|nebenstehenden Waveform]] überprüft werden.
ganze Zahl. Pr&uuml;fen Sie ebenfalls das Funktionieren der Funktion '''resize'''.
+
 
Sie ist hier sehr n&uuml;tzlich, um die Anzahl der Bits der Signale zu bestimmen.
+
{{TaskBox|content=
 +
Erklären Sie die getroffene Wahl im Schema '''coeffBitNb := signalBitNb+4'''.}}
  
 
=== Berechnung des Polynoms ===
 
=== Berechnung des Polynoms ===
  
Schreiben Sie die VHDL Architektur des Blocks, welcher den Wert des
+
[[Image:SEm_interpolatorPolynom.png|thumb|Block zur Berechnung der Interpolation]]
Interpolationspolynom bei jeder neuen Taktperiode berechnet.
+
  
[[Image:interpolatorPolynom.png]]
+
{{TaskBox|content=
'''Abbildung 6. Block zur Berechnung der Interpolation'''
+
Schreiben Sie die VHDL Architektur des Blocks, welcher den Wert des Interpolationspolynom bei jeder neuen Taktperiode berechnet.}}
  
<br>
 
 
Das Polynom wird iterativ berechnet.
 
Das Polynom wird iterativ berechnet.
  
Als Beispiel, f&uuml;r eine Funktion 1. Ordnung, '''y(x) = a&middot;x + b''', ist der
+
Als Beispiel, für eine Funktion 1. Ordnung, '''y(x) = a·x + b''', ist der nächste Wert gleich '''y(x+eps) = y(x) + a·eps'''. Die berechnet sich, indem anfangs '''u = a·eps''', '''y(0) = b''' initialisiert wird, und indem '''y(i+1) = y(i) + u''' bei jeder Taktperiode neu berchenet wird.
n&auml;chste Wert gleich '''y(x+eps) = y(x) + a&middot;eps'''. Die berechnet sich, indem
+
anfangs '''u = a&middot;eps''', '''y(0) = b''' initialisiert wird, und
+
indem '''y(i+1) = y(i) + u''' bei jeder Taktperiode neu berchenet wird.
+
  
F&uuml;r eine Funktion 2. Ordnung, '''y(x) = a&middot;x^2 + b&middot;x + c''', ergibt
+
Für eine Funktion 2. Ordnung, '''y(x) = a·x<sup>2</sup> + b·x + c''', ergibt sich '''y(x+eps) = y(x) + u(x)''', mit '''u(x) = 2·a·eps·x + (a·eps<sup>2</sup> + b·eps)'''. Der Zusatz '''u(x)''' berechnet sich mit der Methode, welche für eine Funktion 1. Ordnung vorgegeben wurde. Dies berechnet sich also mit '''v = 2·a·eps<sup>2</sup>''', '''u(0) = a·eps<sup>2</sup> + b·eps''', '''y(0) = c''' bei der Initialisation und mit '''y(i+1) = y(i) + u(i)''' und '''u(i+1) = u(i) + v''' bei jeder neuen Taktperiode.
sich '''y(x+eps) = y(x) + u(x)''', mit
+
'''u(x) = 2&middot;a&middot;eps&middot;x + (a&middot;eps^2 + b&middot;eps)'''. Der zusatz
+
'''u(x)''' berechnet sich mit der Methode, welche f&uuml;r eine Funktion
+
1. Ordnung vorgegeben wurde. Dies berechnet sich also mit
+
'''v = 2&middot;a&middot;eps^2''', '''u(0) = a&middot;eps^2 + b&middot;eps''',
+
'''y(0) = c''' zu initialisation und mit
+
'''y(i+1) = y(i) + u(i)''' et '''u(i+1) = u(i) + v''' bei jeder
+
neuen Taktperiode.
+
  
Die Berechnung der Funktion dritter Ordnung erfolgt &auml;hnlich.
+
Die Berechnung der Funktion dritter Ordnung erfolgt ähnlich.
  
F&uuml;r die digitale Berechnung wird '''eps''' als gleich einer negativen
+
Für die digitale Berechnung wird '''eps''' als gleich einer negativen Potenz von 2 gewählt, was es erlaubt, Werte durch eine Verschiebung zu berechnen. Ebenso, um mit ganzen Zahlen zu verbleiben, wird man die Funktion '''y(i)''' mit einer Potenz von 2 multipliziert berechnen, und eine Abschlussverschiebung wird uns den Abtastwert des Polynoms geben.
Potenz von 2 gew&auml;hlt, was es erlaubt, Werte durch eine Verschiebung zu berechnen.
+
Ebenso, um mit ganzen Zahlen zu verbleiben, wird man die Funktion '''y(i)'''
+
mit einer Potenz von 2 multipliziert berechnen, und eine Abschlussverschiebung wird uns
+
den Abtastwert des Polynoms geben.
+
  
 
Somit ist unser Algorithmus der folgende:
 
Somit ist unser Algorithmus der folgende:
  
 
* Bei der Ankunft eines neuen Abtastwertes werden die Initialwerte zur iterativen Bestimmung des Polynoms berechnet.
 
* Bei der Ankunft eines neuen Abtastwertes werden die Initialwerte zur iterativen Bestimmung des Polynoms berechnet.
* Zwischen zwei Abtastwerte wird die Berechnung der Polynomialfunktion mit Hilfe von Additionen durchgef&uuml;hrt, abhand der iterativen Gleichungen.
+
* Zwischen zwei Abtastwerte wird die Berechnung der Polynomialfunktion mit Hilfe von Additionen durchgeführt, abhand der iterativen Gleichungen.
  
 
Die Initialwerte sind die folgende:
 
Die Initialwerte sind die folgende:
  
''' x = 2&middot;d&middot;2^(3&middot;m)'''
+
''' x = 2·d·2<sup>(3·m)</sup>'''
  
''' u = a + b&middot;2^m + c&middot;2^(2&middot;m)'''
+
''' u = a + b·2<sup>m</sup> + c·2<sup>(2·m)</sup>'''
  
''' v = 6&middot;a + 2&middot;b&middot;2^m'''
+
''' v = 6·a + 2·b·2<sup>m</sup>'''
  
''' w = 6&middot;a'''
+
''' w = 6·a'''
  
 
''' y = d'''
 
''' y = d'''
  
Die Iterativberechnung des Polynoms wird wie folgt durchgef&uuml;hrt:
+
Die Iterativberechnung des Polynoms wird wie folgt durchgeführt:
  
 
''' x = x + u'''
 
''' x = x + u'''
Line 259: Line 189:
 
''' v = v + w'''
 
''' v = v + w'''
  
''' y = x / 2&middot;2^(3&middot;m)'''
+
''' y = x / (2·2<sup>(3·m)</sup>)'''
  
Es ist offensichtlich, das wegen der Verschiebungen '''2^m''', die Anzahl
+
Es ist offensichtlich, dass, wegen der Verschiebungen '''2<sup>m</sup>''', die Anzahl der Bits der internen Signale höher sein muss als die Anzahl der Bits der Eingangs- oder Ausgangswerte. Schätzen Sie die notwendige Grösse für diese Signale als Funktion der Verschiebung '''m = oversamplingBitNb'''. Geben Sie diesen Signalen 8 zusätzliche Bits, um sicherzustellen, dass kein Overflow auftreten wird.
der Bits der internen Signale h&ouml;her sein muss als die Anzahl der Bits der Eingangs- oder
+
Ausgangswerte. Sch&auml;tzen Sie die notwendige Gr&ouml;sse f&uuml;r diese Signale als Funktion der
+
Verschiebung '''m = oversamplingBitNb'''. Geben Sie diesen Signalen
+
8 zus&auml;tzliche Bits, um sicherzustellen, dass kein Overflow vortauschen wird.
+
  
Wiederum wird die Funktion '''resize''' hier von grosser Interesse
+
Wiederum wird die Funktion '''resize''' hier von grossem Nutzen sein.
sein.
+
  
 
=== Simulation ===
 
=== Simulation ===
  
Compilieren Sie und simulieren Sie den Block '''sineGen_tb''' neu. Pr&uuml;fen
+
{{TaskBox|content=
Sie die Form des Sinuswelle nach Interpolation.
+
Kompilieren Sie und simulieren Sie den Block '''sineGen_tb''' neu. Prüfen Sie die Form des Sinuswelle nach Interpolation.}}
 +
 
 +
{{TaskBox|content=
 +
Verkleinern Sie die Anzahl Bits der Signale in der Schaltung überall, wo es möglich ist, unter Beibehaltung der selben Sinuswelle nach Interpolation.}}
 +
 
 +
{{navNamed|left=SEm/labore/01_generator|left_name=01 Funktionsgenerator|up=SEm/labore|up_name=Anleitung auf Deutsch|right=SEm/labore/03_konverter|right_name=03 Digital / Analog Wandler}}
  
Verkleinern Sie dia Anzahl Bits der Signale in der Schaltung &uuml;berall, wo es m&ouml;glich
+
[[Category:Bachelor]][[Category:SEm]][[Category:Deutsch]]
ist.
+

Revision as of 12:20, 16 March 2017

Contents

Funktionsgenerator mit Interpolationsberechnung

Einleitung

In diesem Labor werden wir verschiedene Operationen mit Zahlen durchführen. Dies am Beispiel der Interpolation der Punkte der Sinuskurve eines digitales Funktionsgenerator.

Die Berechnung der Interpolation basiert auf der Annäherung der Funktion zwischen 2 Punkten mit Polynomialfunktionen dritter Ordnung. Diese Methode gehört zur grossen Familie der Splines.

Die Schaltung befindet sich in der Library SineInterpolator, die Testbank in der Library SineInterpolator_test.

Funktionsgenerator mit Berechnung des Sinus durch Interpolation

Sägezahn

In dieser Schaltung ist die Anzahl Bits der Phase nicht gleich derjenigen der Funktionsgenerator-Ausgänge.

Wenn Ihr die Basisausgänge Sägezahn, Viereck und Dreieck erstellt, ändert der Block resizer die Anzahl Bits des Phasensignals und passt es den Ausgängssignalen an. Dabei gibt es drei Fälle zu beachten:

  • Die Anzahl Bits der Ausgänge ist kleiner als die des Phasensignals: in diesem Fall werden die MSBs behalten.
  • Die Anzahl Bits der Ausgänge ist gleich wie die des Phasensignals: in diesem Fall werden alle Bits übertragen.
  • Die Anzahl Bits der Ausgänge ist kleiner als die des Phasensignals: in diesem Fall wird das Phasensignal in die MSBs des Sägezahnsignals gelegt.

VHDL Code

View-pim-tasks.png

Mit Hilfe des Konstruktes if ... generate, schreiben Sie den VHDL Code des resizer-Blocks.

Simulation

View-pim-tasks.png

Kompilieren und simulieren Sie den Block sineGen_tb. Ändern Sie die Anzahl Bits des Phasensignals und überprüfen Sie die Anpassung der Anzahl Bits in jedem möglichen Operationsfall.

Sinustabelle

Sinustabelle

Die Interpolation wird durchgeführt abhand einer Tabelle, welche 8 Werte der Sinusfunktion im ersten Viertel der Periode enthält. Um die Werte für die ganze Periode anzuwenden, wird das Sägezahnsignal des Phasenzählers wie folgt angewandt:

  • Der MSB gibt an, ob das Vorzeichen zu ändern ist.
  • Der nächste Bit meldet, dass die Phase geändert sein soll, um die Tabelle in der umgekehrten Richtung zu lesen, dies für den zweiten und den vierten Viertel der Periode.
  • Die 3 weitere Bits (tableAddressBitNb = 3) sind als Adresse für das Lesen der Tabellenwerte angewandt.
  • Alle andere Bits werden vernachlässigt.

VHDL Code

View-pim-tasks.png

Schreiben Sie die VHDL Architektur des Sinuswellengenerators.

Die Adresse der tabelle stammt aus den 3 Bits nach den 2 MSBs. Sie zählt die Sequenz 0, 1, 2, 3, 4, 5, 6, 7, 0, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, ....

Die Sinustabelle enthält die Hexadezimalwerte 0000 oder 7FFF (abhängig vom zweithöchstwertigsten Bit), 18F9, 30FB, 471C, 5A82, 6A6D, 7641 und 7D89.

Wenn das MSB der Phase gleich '1' ist, so wird das Vorzeichen des Tabellenwertes invertiert, um den Ausgang zu erzeugen.

Simulation

View-pim-tasks.png

Kompilieren Sie und simulieren Sie den Block sineGen_tb. Prüfen Sie die Funktionalität des Sinuswellensignalgenerators.

Interpolation

Die Interpolation wird gemacht, indem man eine verschiedene Polynomialfunktion 3. Ordnung zu jedem Intervall zwischen zwei Punkte der Sinustabelle zuweist:

y = a·k3 + b·k2 + c·k +d

Während dieser Berechnung wird der jeweilige Punkt der Tabelle mit k = 0 definiert, der vorige Punkt mit k = -1 und der nächste mit k = 1 definiert. Wir werden die Polynomialfunktion für n = 2m Punkte zwischen 0 und 1 berechnen.

Um die Kontinuität der Kurve beim Übergang vom Polynom des Segments -1 < k < 0 und dem von 0 < k < 1, spezifieren wir, dass die derivative am Punkt y(k=0) gleich der Steigung zwischen den Punkten y(k=-1) und y(k=1)sein soll. Wir werden dasselbe für alle Punkte der zu interpolierenden Funktion machen.

Das Segment 0 < k < 1 dient somit den 4 folgenden Bedingungen:

y(k=0) = y0: das Polynom geht durch den Punkt (k=0, y=y0),

y(k=1) = y1: das Polynom geht durch den Punkt (k=1, y=y1),

y'(k=0) = [y(k=1) - y(k=-1)] / 2: die Ableitung am Punkt (k=0) ist die Steigung zwischen y(k=-1) und y(k=1),

y'(k=1) = [y(k=2) - y(k=0)] / 2: die Ableitung am Punkt (k=1) ist die Steigung zwischen y(k=0) und y(k=2).

Diese 4 Bedingungen dienen zur Bestimmung der 4 Koeffizienten a, b, c und d des Polynoms anhand der 4 Punkte y(k=-1) bis y(k=2) der zu interpolierenden Kurve. Die Auflösung dieses Gleichungssystems gibt uns die folgenden Werte der Koeffizienten:

a = 1/2 [ - y(k=-1) +3·y(k=0) -3·y(k=1) + y(k=2) ]

b = 1/2 [ 2·y(k=-1) -5·y(k=0) +4·y(k=1) - y(k=2) ]

c = 1/2 [ - y(k=-1) + y(k=1) ]

d = y(k=0)

Um die Berechnungen zu vereinfachen werden wir den doppelten Wert der Koeffizienten evaluieren und später die berechnete Werte des Polynoms durch 2 teilen.

Beim Auftreten jedes neuen Werts des ursprünglichen Signals (hier die Sinustabelle), müssen die Polynomkoeffiziente neu berechnet werden. Dann, in der Zwischenzeit, wird die Polynomilafunktion berechnet, um den jeweilgen Wert des Ausgangssignal zu bestimmen.

Generator von Sequenzierungsimpulsen

Genrator von Sequenzierungsimpulsen


View-pim-tasks.png

Schreiben Sie die VHDL Architektur des Generators von Sequenzierungsimpulsen.

Diese Schaltung ermittelt einen Impuls mit der Dauer einer Taktperiode bei jedem Polynomwechsel, das heisst zu jedem neuen Kurvensegment.

Dies erfolgt zu jeden 2n Taktperioden wo en = '1', wobei n = sampleCountBitNb = phaseBitNb-2-tableAddressBitNb. In unserem Laborbeispiel sind phaseBitNb = 10 und sampleCountBitNb = 5.

Schieberegister

Schieberegister


View-pim-tasks.png

Schreiben Sie die VHDL Architektur des Schieberegisters, welcher die 4 letzten Punkte der zu interpolendierenden Funktion speichert.

Bei jedem Synchronisationsimplus shiftSamples speichert dis Schaltung den neuen Wert der zu interpolendierenden Funktion, sampleIn, und speichert es als letzes Abtastwert, sample4. Zugleich schiebt er den gespeicherten Wert von sample4 zurück in sample3, usw...

Dialog-warning.png

Verwenden Sie ein Array von Zahlen, um den Shieberegister zu beschreiben.

Berechnung der Koeffizienten

Block zur Berechnung der Koeffizienten für die Interpolation


View-pim-tasks.png

Öffnen Sie die Library ieee.numeric_std und durchsuchen Sie die Auswirkung der Multiplikation eines Signals von Typ signed durch eine ganze Zahl. Prüfen Sie ebenfalls das Funktionieren der Funktion resize. Sie ist hier sehr nützlich, um die Anzahl der Bits der Signale zu bestimmen.

Die Koeffizienten werden wie folgt berechnet:

a = - sample1 +3·sample2 -3·sample3 + sample4

b = 2·sample1 -5·sample2 +4·sample3 - sample4

c = - sample1 + sample3

d = sample2


View-pim-tasks.png

Schreiben Sie die VHDL Architektur des Blocks, welcher die Koeffizienten des Polynoms als Funktion der 4 letzten Punkten der zu interpolendierenden Funktion berechnet.

Interpolationskoeffizienten

Die von Ihnen berechneten Koeffizienten können mit der nebenstehenden Waveform überprüft werden.


View-pim-tasks.png

Erklären Sie die getroffene Wahl im Schema coeffBitNb := signalBitNb+4.

Berechnung des Polynoms

Block zur Berechnung der Interpolation


View-pim-tasks.png

Schreiben Sie die VHDL Architektur des Blocks, welcher den Wert des Interpolationspolynom bei jeder neuen Taktperiode berechnet.

Das Polynom wird iterativ berechnet.

Als Beispiel, für eine Funktion 1. Ordnung, y(x) = a·x + b, ist der nächste Wert gleich y(x+eps) = y(x) + a·eps. Die berechnet sich, indem anfangs u = a·eps, y(0) = b initialisiert wird, und indem y(i+1) = y(i) + u bei jeder Taktperiode neu berchenet wird.

Für eine Funktion 2. Ordnung, y(x) = a·x2 + b·x + c, ergibt sich y(x+eps) = y(x) + u(x), mit u(x) = 2·a·eps·x + (a·eps2 + b·eps). Der Zusatz u(x) berechnet sich mit der Methode, welche für eine Funktion 1. Ordnung vorgegeben wurde. Dies berechnet sich also mit v = 2·a·eps2, u(0) = a·eps2 + b·eps, y(0) = c bei der Initialisation und mit y(i+1) = y(i) + u(i) und u(i+1) = u(i) + v bei jeder neuen Taktperiode.

Die Berechnung der Funktion dritter Ordnung erfolgt ähnlich.

Für die digitale Berechnung wird eps als gleich einer negativen Potenz von 2 gewählt, was es erlaubt, Werte durch eine Verschiebung zu berechnen. Ebenso, um mit ganzen Zahlen zu verbleiben, wird man die Funktion y(i) mit einer Potenz von 2 multipliziert berechnen, und eine Abschlussverschiebung wird uns den Abtastwert des Polynoms geben.

Somit ist unser Algorithmus der folgende:

  • Bei der Ankunft eines neuen Abtastwertes werden die Initialwerte zur iterativen Bestimmung des Polynoms berechnet.
  • Zwischen zwei Abtastwerte wird die Berechnung der Polynomialfunktion mit Hilfe von Additionen durchgeführt, abhand der iterativen Gleichungen.

Die Initialwerte sind die folgende:

x = 2·d·2(3·m)

u = a + b·2m + c·2(2·m)

v = 6·a + 2·b·2m

w = 6·a

y = d

Die Iterativberechnung des Polynoms wird wie folgt durchgeführt:

x = x + u

u = u + v

v = v + w

y = x / (2·2(3·m))

Es ist offensichtlich, dass, wegen der Verschiebungen 2m, die Anzahl der Bits der internen Signale höher sein muss als die Anzahl der Bits der Eingangs- oder Ausgangswerte. Schätzen Sie die notwendige Grösse für diese Signale als Funktion der Verschiebung m = oversamplingBitNb. Geben Sie diesen Signalen 8 zusätzliche Bits, um sicherzustellen, dass kein Overflow auftreten wird.

Wiederum wird die Funktion resize hier von grossem Nutzen sein.

Simulation

View-pim-tasks.png

Kompilieren Sie und simulieren Sie den Block sineGen_tb neu. Prüfen Sie die Form des Sinuswelle nach Interpolation.


View-pim-tasks.png

Verkleinern Sie die Anzahl Bits der Signale in der Schaltung überall, wo es möglich ist, unter Beibehaltung der selben Sinuswelle nach Interpolation.


Navigation
Arrow left.gif 01 Funktionsgenerator Arrow up.gif Anleitung auf Deutsch 03 Digital / Analog Wandler Arrow right.gif

Personal tools
Namespaces
Variants
Actions
Navigation
Modules / Projects
Browse
Toolbox