Digitale Signalverarbeitung - Exam

Aufgabe 1)

Die Fourier-Transformation ist ein mächtiges Werkzeug, um Signale in ihre Frequenzkomponenten zu zerlegen. Gegeben sei ein Signal f(t), das mit der Fourier-Transformation in die Frequenzdomäne transformiert werden soll. Die Fourier-Transformierte eines Signals ist gegeben durch:

• F(\theta) = \int_{-\infty}^{\infty} f(t) e^{-i \theta t} \ d t

Darüber hinaus soll auch die inverse Fourier-Transformation berechnet werden:

• f(t) = \frac{1}{2 \pi} \int_{-\infty}^{\infty} F(\theta) e^{i \theta t} \ d \theta

Diese Transformation ist eng mit der Fourier-Reihe verknüpft, eignet sich jedoch speziell für nicht-periodische Signale. Analysiere die Eigenschaften der Fourier-Transformation, inklusive der wichtigen Eigenschaften wie Linearität, Zeitverschiebung und das Faltungstheorem.

a)

Berechne die Fourier-Transformierte des Signals f(t) = e^{-a|t|}, wobei a eine positive Konstante ist. Zeige den vollen Rechenweg.

Lösung:

Um die Fourier-Transformierte des Signals f(t) = e^{-a|t|} zu berechnen, folgen wir diesen Schritten:

• Die Definition der Fourier-Transformation ist gegeben durch:

   F(\theta) = \int_{-\infty}^{\infty} f(t) e^{-i \theta t} \ d t 

• Setze das gegebene Signal f(t) = e^{-a|t|} in die Fourier-Transformationsformel ein:

   F(\theta) = \int_{-\infty}^{\infty} e^{-a|t|} e^{-i \theta t} \ d t 

• Da |t| sowohl positive als auch negative Werte annehmen kann, teilen wir das Integral in zwei Bereiche - von -∞ bis 0 und von 0 bis ∞:

   F(\theta) = \int_{-\infty}^{0} e^{at} e^{-i \theta t} \ d t + \int_{0}^{\infty} e^{-at} e^{-i \theta t} \ d t 

• Löse die einzelnen Integrale: Für den Bereich von -∞ bis 0:

   \int_{-\infty}^{0} e^{(a - i \theta)t} \ d t 

  • Da (a - i \theta) positiv ist, können wir das Integral wie folgt lösen:

     \int e^{bt} \ d t = \frac{e^{bt}}{b} 

     = \left[\frac{e^{(a - i \theta)t}}{a - i \theta}\right]_{-\infty}^{0} = \frac{1}{a - i \theta} \left( e^{0} - e^{-\infty} \right) = \frac{1}{a - i \theta} \left( 1 - 0 \right) = \frac{1}{a - i \theta} 

• Für den Bereich von 0 bis ∞:

   \int_{0}^{\infty} e^{-(a + i \theta)t} \ d t 

  • Da (a + i \theta) positiv ist, können wir das Integral wie folgt lösen:

     \int e^{bt} \ d t = \frac{e^{bt}}{b} 

     = \left[\frac{e^{-(a + i \theta)t}}{-(a + i \theta)}\right]_{0}^{\infty} = -\frac{1}{a + i \theta} \left(e^{-(a + i \theta)\infty} - e^{0} \right) = -\frac{1}{a + i \theta} \left( 0 - 1 \right) = \frac{1}{a + i \theta} 

• Nun addieren wir die beiden Integrale:

   F(\theta) = \frac{1}{a - i \theta} + \frac{1}{a + i \theta} 

• Um diesen Ausdruck zu vereinfachen, erhalten wir einen gemeinsamen Nenner:

   F(\theta) = \frac{a + i \theta + a - i \theta}{a^2 + \theta^2} = \frac{2a}{a^2 + \theta^2} 

• Daher lautet die Fourier-Transformierte von f(t) = e^{-a|t|}:

   F(\theta) = \frac{2a}{a^2 + \theta^2} 

b)

Bestimme die Fourier-Transformierte eines Rechtecksignals, das durch

• f(t) = 1 für |t| ≤ T/2
• f(t) = 0 sonst

gegeben ist. Berechne die resultierende Frequenzdomänenrepräsentation.

Lösung:

Um die Fourier-Transformierte eines Rechtecksignals zu bestimmen, folge diesen Schritten:

• Die Definition der Fourier-Transformation ist gegeben durch:

   F(\theta) = \int_{-\infty}^{\infty} f(t) e^{-i \theta t} \ d t 

• Setze das gegebene Rechtecksignal in die Fourier-Transformationsformel ein:

   f(t) = \begin{cases} 1 & \text{für } |t| \leq \frac{T}{2} \ 0 & \text{sonst} \end{cases} 

• Da das Signal außerhalb des Bereichs \(|t| \leq \frac{T}{2}\) null ist, kann das Integral von \(-∞\) bis \(∞\) zu einem Integral von \(-\frac{T}{2}\) bis \(\frac{T}{2}\) vereinfacht werden:

   F(\theta) = \int_{-\frac{T}{2}}^{\frac{T}{2}} 1 \, e^{-i \theta t} \, dt 

• Berechne das Integral, wobei das Integral von \(e^{-i \theta t}\) zu berücksichtigen ist:

   F(\theta) = \int_{-\frac{T}{2}}^{\frac{T}{2}} e^{-i \theta t} \ d t 

• Die Stammfunktion von \(e^{-i \theta t}\) ist \(\frac{e^{-i \theta t}}{-i \theta}\), also:

   F(\theta) = \left[ \frac{e^{-i \theta t}}{-i \theta} \right]_{-\frac{T}{2}}^{\frac{T}{2}} = \frac{1}{-i \theta} \left( e^{-i \theta \frac{T}{2}} - e^{i \theta \frac{T}{2}} \right) 

• Das kann weiter vereinfacht werden, indem man den Ausdruck für die Exponentialfunktion verwendet:

   F(\theta) = \frac{1}{-i \theta} \left( e^{-i \theta \frac{T}{2}} - e^{i \theta \frac{T}{2}} \right) = \frac{1}{-i \theta} \left( -2i \sin \left( \theta \frac{T}{2} \right) \right) = \frac{2 \sin \left( \theta \frac{T}{2} \right)}{\theta} 

• Das lässt sich weiter vereinfachen zu:

   F(\theta) = 2 \frac{\sin \left( \theta \frac{T}{2} \right)}{\theta} 

• Somit lautet die Fourier-Transformierte des Rechtecksignals:

   F(\theta) = 2 \frac{\sin \left( \theta \frac{T}{2} \right)}{\theta} 

c)

Erläutere das Faltungstheorem in der Fourier-Transformation und zeige durch eine Rechnung, wie die Faltung zweier Signale in der Zeitdomäne als Multiplikation ihrer Fourier-Transformierten in der Frequenzdomäne dargestellt werden kann.

Lösung:

Das Faltungstheorem ist eine der bedeutendsten Eigenschaften der Fourier-Transformation und besagt, dass die Faltung zweier Signale in der Zeitdomäne der Multiplikation ihrer Fourier-Transformierten in der Frequenzdomäne entspricht.

Definitionen:

• Faltung in der Zeitdomäne: Gegeben seien zwei Funktionen f(t) und g(t). Die Faltung dieser beiden Funktionen ist definiert als:

   (f * g)(t) = \int_{-\infty}^{\infty} f(\tau) g(t - \tau) \, d\tau 

• Fourier-Transformation: Die Fourier-Transformierte einer Funktion f(t) ist definiert als:

   F(\theta) = \int_{-\infty}^{\infty} f(t) e^{-i \theta t} \, dt 

Faltungstheorem:

Das Faltungstheorem besagt, dass:

 \mathcal{F}\{(f * g)(t)\} = F(\theta) \, G(\theta) 

wobei \mathcal{F} die Fourier-Transformation darstellt und F(\theta) bzw. G(\theta) die Fourier-Transformierten von f(t) bzw. g(t) sind.

Rechenweg:

Um dies zu beweisen, gehen wir wie folgt vor:

• Faltung ausdrücken:

   (f * g)(t) = \int_{-\infty}^{\infty} f(\tau) g(t - \tau) \, d\tau 

• Fourier-Transformation der Faltung berechnen:

   \mathcal{F}\{(f * g)(t)\} = \int_{-\infty}^{\infty} \left( \int_{-\infty}^{\infty} f(\tau) g(t - \tau) \, d\tau \right) e^{-i \theta t} \, dt 

• Integrationsreihenfolge tauschen:

   \int_{-\infty}^{\infty} f(\tau) \left( \int_{-\infty}^{\infty} g(t - \tau) e^{-i \theta t} \, dt \right) \, d\tau 

• Substitution durchführen: Setze u = t - \tau, was bedeutet du = dt. Die Grenzen ändern sich nicht, da \tau konstant ist.

   \int_{-\infty}^{\infty} f(\tau) \left( \int_{-\infty}^{\infty} g(u) e^{-i \theta (u + \tau)} \, du \right) \, d\tau 

• Exponentialterme auseinanderziehen:

   \int_{-\infty}^{\infty} f(\tau) e^{-i \theta \tau} \left( \int_{-\infty}^{\infty} g(u) e^{-i \theta u} \, du \right) \, d\tau 

• Fourier-Transformationen identifizieren:
  • Fourier-Transformation von g(u):

     G(\theta) = \int_{-\infty}^{\infty} g(u) e^{-i \theta u} \, du 

  • Fourier-Transformation von f(\tau):

     F(\theta) = \int_{-\infty}^{\infty} f(\tau) e^{-i \theta \tau} \, d\tau 

• Schlussfolgerung:

   \mathcal{F}\{(f * g)(t)\} = F(\theta) \, G(\theta) 

Damit haben wir gezeigt, dass die Fourier-Transformierte der Faltung zweier Signale in der Zeitdomäne gleich dem Produkt ihrer Fourier-Transformierten in der Frequenzdomäne ist.

d)

Angenommen, Du verschiebst das gegebene Signal f(t) = e^{-a|t|} um eine Zeit τ. Verwende die Eigenschaft der Zeitverschiebung der Fourier-Transformation, um die Fourier-Transformierte des verschobenen Signals zu bestimmen.

Lösung:

Um die Fourier-Transformierte eines verschobenen Signals zu bestimmen, verwenden wir die Zeitverschiebungseigenschaft der Fourier-Transformation. Diese Eigenschaft besagt, dass eine Verschiebung eines Signals in der Zeitdomäne zu einer Multiplikation des transformierten Signals mit einem komplexen Exponentialfaktor führt.

Definition der Zeitverschiebungseigenschaft:

• Wenn ein Signal f(t) um eine Zeit \(\tau\) verschoben wird:
• Originalsignal:

   f(t) 

• Verschobenes Signal:

   f(t - \tau) 

Die Fourier-Transformierte des verschobenen Signals ist gegeben durch:

•  \bar{F}(\theta) = F(\theta) \, e^{-i \theta \tau} 

Berechnung:

Das gegebene Signal ist:

•  f(t) = e^{-a|t|} 

Bestimme die Fourier-Transformierte des Originalsignals:

Wir haben bereits die Fourier-Transformierte des Signals f(t) = e^{-a|t|} berechnet:

•  F(\theta) = \frac{2a}{a^2 + \theta^2} 

Fourier-Transformierte des verschobenen Signals:

Verwende die Zeitverschiebungseigenschaft, um die Fourier-Transformierte des um \(\tau\) verschobenen Signals zu berechnen:

• Das verschobene Signal ist:

   f(t - \tau) = e^{-a|t - \tau|} 

• Die Fourier-Transformierte des verschobenen Signals lautet:

   \bar{F}(\theta) = F(\theta) \, e^{-i \theta \tau} 

• Setze F(\theta) ein:

   \bar{F}(\theta) = \frac{2a}{a^2 + \theta^2} \, e^{-i \theta \tau} 

Ergebnis:

Die Fourier-Transformierte des um \(\tau\) verschobenen Signals f(t) = e^{-a|t|} ist:

•  \bar{F}(\theta) = \frac{2a}{a^2 + \theta^2} \, e^{-i \theta \tau} 

Aufgabe 2)

Schnelle Fourier-Transformation (FFT) und ihre ImplementierungDie FFT ist ein Algorithmus zur effizienten Berechnung der diskreten Fourier-Transformation (DFT). Die DFT wird definiert durch die Formel:

• DFT: \(X[k] = \sum_{n=0}^{N-1} x[n] e^{-2\pi i kn/N}\)
• Die FFT reduziert die Rechenkomplexität von \(O(N^2)\) auf \(O(N \log N)\)
• Typische FFT-Algorithmen umfassen Cooley-Tukey, Radix-2 und Radix-4
• Implementierung der FFT ist in vielen häufig verwendeten Bibliotheken verfügbar, z.B., FFTW in C und numpy.fft in Python
• Bei der Verwendung der FFT müssen Quantisierungs- und Rundungsfehler berücksichtigt werden

Berechne und analysiere die FFT für die folgenden Fälle:

a)

a) Implementiere den Cooley-Tukey FFT-Algorithmus in Python. Berechne die DFT für das folgene Signal:

import numpy as npx = [1, 2, 3, 4]np.fft.fft(x)

Erkläre jeden Schritt des Cooley-Tukey Algorithmus und verifiziere Deine Ergebnisse im Vergleich zur resultierenden Ausgabe von numpy.fft.

Lösung:

Schnelle Fourier-Transformation (FFT) und ihre ImplementierungDie FFT ist ein Algorithmus zur effizienten Berechnung der diskreten Fourier-Transformation (DFT). Die DFT wird definiert durch die Formel:

• DFT: \(X[k] = \sum_{n=0}^{N-1} x[n] e^{-2\pi i kn/N}\)
• Die FFT reduziert die Rechenkomplexität von \(O(N^2)\) auf \(O(N \log N)\)
• Typische FFT-Algorithmen umfassen Cooley-Tukey, Radix-2 und Radix-4
• Implementierung der FFT ist in vielen häufig verwendeten Bibliotheken verfügbar, z.B., FFTW in C und numpy.fft in Python
• Bei der Verwendung der FFT müssen Quantisierungs- und Rundungsfehler berücksichtigt werden

Berechne und analysiere die FFT für die folgenden Fälle:a) Implementiere den Cooley-Tukey FFT-Algorithmus in Python. Berechne die DFT für das folgende Signal:

import numpy as npx = [1, 2, 3, 4]np.fft.fft(x)

Erkläre jeden Schritt des Cooley-Tukey Algorithmus und verifiziere Deine Ergebnisse im Vergleich zur resultierenden Ausgabe von numpy.fft.Implementierung des Cooley-Tukey FFT-AlgorithmusHier ist eine Implementierung des Cooley-Tukey FFT-Algorithmus in Python:

import numpy as npdef fft(x):    N = len(x)    if N <= 1:        return x    even = fft(x[0::2])    odd = fft(x[1::2])    T = [np.exp(-2j * np.pi * k / N) * odd[k] for k in range(N // 2)]    return [even[k] + T[k] for k in range(N // 2)] + [even[k] - T[k] for k in range(N // 2)]x = [1, 2, 3, 4]print(fft(x))print(np.fft.fft(x))

• Erklärung:
  • Rekursive Aufteilung: Das Eingabesignal wird rekursiv in gerade und ungerade Teile aufgeteilt.
  • FFT-Berechnung: Die FFT wird für die gerade und ungerade Untersequenzen berechnet.
  • Kombination: Die Ergebnisse der Teil-FFTs werden kombiniert, um die endgültige FFT zu berechnen. Dies erfolgt durch die Nutzung der Symmetrieeigenschaften der FFT, um die Anzahl der Multiplikationen zu reduzieren.
  • Baseline-Fall: Wenn die Länge des Signals 1 ist, wird dasselbe Signal zurückgegeben.
• Verifikation: Die Ausgabe der obigen Implementierung kann mit der Ausgabe von numpy.fft.fft(x) verglichen werden, um sicherzustellen, dass der Algorithmus korrekt funktioniert.

Vergleich der Ergebnisse:Nachdem Du den obigen Code ausführst, solltest Du sehen, dass die Ausgabe des selbst implementierten Cooley-Tukey FFT-Algorithmus und die Ausgabe von numpy.fft.fft(x) übereinstimmen. Dies bestätigt, dass die Implementierung korrekt ist.

# Beispielergebnis:# [10.+0.j -2.+2.j -2.+0.j -2.-2.j]# [10.+0.j -2.+2.j -2.+0.j -2.-2.j]

Falls die Ausgaben übereinstimmen, bedeutet dies, dass der selbst implementierte Algorithmus korrekt arbeitet.

b)

b) Verwende den Cooley-Tukey FFT-Algorithmus, um die DFT für ein Signal der Länge \(N = 8\) zu berechnen. Wähle ein Signal, dessen Werte 0 bis 7 sind. Bestimme die Fehler, die durch Rundungsfehler entstehen könnten, und berechne die relative Fehlerquote für das Signal.

Lösung:

Schnelle Fourier-Transformation (FFT) und ihre ImplementierungDie FFT ist ein Algorithmus zur effizienten Berechnung der diskreten Fourier-Transformation (DFT). Die DFT wird definiert durch die Formel:

• DFT: \(X[k] = \sum_{n=0}^{N-1} x[n] e^{-2\pi i kn/N}\)
• Die FFT reduziert die Rechenkomplexität von \(O(N^2)\) auf \(O(N \log N)\)
• Typische FFT-Algorithmen umfassen Cooley-Tukey, Radix-2 und Radix-4
• Implementierung der FFT ist in vielen häufig verwendeten Bibliotheken verfügbar, z.B., FFTW in C und numpy.fft in Python
• Bei der Verwendung der FFT müssen Quantisierungs- und Rundungsfehler berücksichtigt werden

Berechne und analysiere die FFT für die folgenden Fälle:b) Verwende den Cooley-Tukey FFT-Algorithmus, um die DFT für ein Signal der Länge \(N = 8\) zu berechnen. Wähle ein Signal, dessen Werte 0 bis 7 sind. Bestimme die Fehler, die durch Rundungsfehler entstehen könnten, und berechne die relative Fehlerquote für das Signal.Implementierung des Cooley-Tukey FFT-AlgorithmusHier ist eine Implementierung des Cooley-Tukey FFT-Algorithmus in Python für ein Signal der Länge 8:

import numpy as npdef fft(x):    N = len(x)    if N <= 1:        return x    even = fft(x[0::2])    odd = fft(x[1::2])    T = [np.exp(-2j * np.pi * k / N) * odd[k] for k in range(N // 2)]    return [even[k] + T[k] for k in range(N // 2)] + [even[k] - T[k] for k in range(N // 2)]x = np.arange(8) # Signal von 0 bis 7print('Eigenimplementierung FFT:', fft(x))print('Numpy FFT:', np.fft.fft(x))

Berechnung der relativen Fehlerquote

• Zum Berechnen des Fehlers und der relativen Fehlerquote können wir die Differenz zwischen den Ergebnissen unserer Implementierung und denen von numpy.fft berechnen.
• Der absolute Fehler kann durch die Differenz der Ergebnisse berechnet werden.
• Die relative Fehlerquote berechnet sich als relativer Fehler, gemessen an den wahrheitsgetreuen Werten (numpy.fft).

Hier ist der Python-Code zur Fehlerberechnung:

def relative_error(own_result, numpy_result):    error = np.abs(own_result - numpy_result)    relative_error = error / np.abs(numpy_result)    return relative_errorx = np.arange(8)own_result = fft(x)numpy_result = np.fft.fft(x)error = relative_error(np.array(own_result), numpy_result)relative_error_rate = np.mean(error)print('Fehler:', error)print('Relative Fehlerquote:', relative_error_rate)

• Erklärung:
  • Fehler: Der absolute Fehler zwischen den beiden Ergebnissen (eigene Implementierung vs. numpy.fft) wird berechnet.
  • Relative Fehlerquote: Der Durchschnitt aller relativen Fehler gibt die durchschnittliche relative Fehlerquote an.
• Vergleiche die Ergebnisse:

# Beispielergebnis:# Eigenimplementierung FFT: [(28+0j), (-4+9.65685424949238j), (-4+4j), (-4+1.6568542494923818j), (-4+0j), (-4-1.6568542494923806j), (-4-4j), (-4-9.65685424949238j)]# Numpy FFT: [28.+0.j -4.+9.65685425j -4.+4.j -4.+1.65685425j -4.+0.j -4.-1.65685425j -4.-4.j -4.-9.65685425j]# Fehler: [0. 0. 0. 0. 0. 0. 0. 0.]# Relative Fehlerquote: 0.0

Dies zeigt, dass der selbst implementierte Algorithmus korrekt funktioniert und keine signifikanten Fehler gegenüber der numpy.fft Implementierung hat. Verbleibende Rundungsfehler sind sehr klein, wie durch die nahe null liegende relative Fehlerquote gegeben ist.

c)

c) Analysiere die Komplexität der FFT und berechne, um wie viel schneller eine FFT mit \(N = 1024\) im Vergleich zur direkten Berechnung der DFT ist. Zeige die Berechnungen und Vergleichswerte auf, indem Du die Zeitkomplexität \(O(N^2)\) für die DFT und \(O(N \log N)\) für die FFT verwendest.

Lösung:

Schnelle Fourier-Transformation (FFT) und ihre ImplementierungDie FFT ist ein Algorithmus zur effizienten Berechnung der diskreten Fourier-Transformation (DFT). Die DFT wird definiert durch die Formel:

• DFT: \(X[k] = \sum_{n=0}^{N-1} x[n] e^{-2\pi i kn/N}\)
• Die FFT reduziert die Rechenkomplexität von \(O(N^2)\) auf \(O(N \log N)\)
• Typische FFT-Algorithmen umfassen Cooley-Tukey, Radix-2 und Radix-4
• Implementierung der FFT ist in vielen häufig verwendeten Bibliotheken verfügbar, z.B., FFTW in C und numpy.fft in Python
• Bei der Verwendung der FFT müssen Quantisierungs- und Rundungsfehler berücksichtigt werden

Berechne und analysiere die FFT für die folgenden Fälle:c) Analysiere die Komplexität der FFT und berechne, um wie viel schneller eine FFT mit \(N = 1024\) im Vergleich zur direkten Berechnung der DFT ist. Zeige die Berechnungen und Vergleichswerte auf, indem Du die Zeitkomplexität \(O(N^2)\) für die DFT und \(O(N \log N)\) für die FFT verwendest.Analyse der Komplexität der FFTDie Zeitkomplexität der beiden Algorithmen wird durch folgende Formeln beschrieben:

• Für die DFT: \(O(N^2)\)
• Für die FFT: \(O(N \log N)\)

Berechne die Komplexität für \(N = 1024\):

• DFTDie Komplexität der DFT berechnet sich wie folgt:
  • \(O(N^2) = O(1024^2) = O(1048576)\)
• FFTDie Komplexität der FFT berechnet sich wie folgt:
  • \(O(N \log N) = O(1024 \log 1024)\)\(= O(1024 \times 10)\) (Da \(\log_2(1024) = 10\))\(= O(10240)\)

Vergleich der Berechnungen:

• DFTDie Anzahl der Operationen beträgt \(1048576\).
• FFTDie Anzahl der Operationen beträgt \(10240\).

Vergleichen wir diese Werte, um die Geschwindigkeit der FFT relativ zur DFT zu bestimmen:

• Der Geschwindigkeitsfaktor beträgt \(\frac{1048576}{10240} = 102.4\).
• Das bedeutet, dass die FFT etwa 102.4-mal schneller ist als die direkte Berechnung der DFT bei \(N = 1024\).

Zusammenfassend:Die FFT reduziert die Rechenkomplexität von quadratischer \(O(N^2)\) zur linearen logarithmischen \(O(N \log N)\) Komplexität. Bei einem Signal der Länge \(N = 1024\) ist die FFT etwa 102.4-mal schneller als die direkte Berechnung der DFT. Dies zeigt die erhebliche Effizienzsteigerung, die durch die Anwendung der FFT erreicht wird.

Aufgabe 3)

Ein Audio-Ingenieur arbeitet mit einem digitalen Signal, das eine Länge von N=16 Samples hat. Er möchte das Signal sowohl im Zeit- als auch im Frequenzbereich analysieren und bearbeiten. Seine Hauptaufgaben umfassen das Berechnen der Diskreten Fourier-Transformation (DFT), das Anwenden eines Tiefpassfilters im Frequenzbereich und das Transformieren des bearbeiteten Signals zurück in den Zeitbereich.

b)

Ein Tiefpassfilter soll im Frequenzbereich angewendet werden, um die hohen Frequenzkomponenten des DFT des Signals auszusieben. Der Filter lässt Frequenzen unterhalb von \(k = 4\) passieren und setzt alle anderen Frequenzen auf null. Wende diesen Filter auf \(X(k)\) an und zeige die modifizierten Frequenzkomponenten \(X_f(k)\).

Lösung:

Um den Tiefpassfilter im Frequenzbereich anzuwenden und die hohen Frequenzkomponenten auszusieben, setzen wir alle Frequenzkomponenten oberhalb von k = 4 auf Null. Das bedeutet, dass nur die Frequenzkomponenten X(0), X(1), X(2) und X(3) unverändert bleiben.

Die ursprünglichen Frequenzkomponenten X(k) des Signals sind:

 X(0) = 4  X(1) = 0  X(2) = 0  X(3) = 0  X(4) = 0  X(5) = 0  X(6) = 0  X(7) = 0  X(8) = -8i  X(9) = 0  X(10) = 0  X(11) = 0  X(12) = 0  X(13) = 0  X(14) = 0  X(15) = 0 

Nach Anwenden des Tiefpassfilters, der Frequenzen oberhalb von k = 4 blockiert, erhalten wir die modifizierten Frequenzkomponenten X_f(k):

 X_f(0) = X(0) = 4  X_f(1) = X(1) = 0  X_f(2) = X(2) = 0  X_f(3) = X(3) = 0  X_f(4) = X(4) = 0  X_f(5) = 0  X_f(6) = 0  X_f(7) = 0  X_f(8) = 0  X_f(9) = 0  X_f(10) = 0  X_f(11) = 0  X_f(12) = 0  X_f(13) = 0  X_f(14) = 0  X_f(15) = 0 

Das Ergebnis ist ein Signal, bei dem nur die tiefen Frequenzkomponenten bis einschließlich k = 4 beibehalten werden, während alle anderen auf null gesetzt wurden.

Aufgabe 4)

Filterentwurf und -analyse bezieht sich auf die Gestaltung und Bewertung digitaler Filter zur Signalverarbeitung. Ziel ist es, bestimmte Frequenzbereiche zu betonen oder zu unterdrücken. Zu den wichtigen Parametern gehören die Filterordnung, das Übergangsband und die Dämpfung im Stoppband. Es gibt verschiedene Arten von Filtern, wie FIR (finite Impulse Response) und IIR (infinite Impulse Response). Zu den Entwurfsmethoden zählen die Fenstermethode, der Parks-McClellan-Algorithmus und die bilineare Transformation. Die Analyse im Frequenzbereich erfolgt durch die Berechnung der Frequenzantwort: \[ H(e^{j\omega}) = \sum_{n=0}^{N-1} h[n] e^{-j\omega n} \]. Der Filter ist stabil, wenn alle Pole innerhalb des Einheitskreises liegen. Software-Tools wie MATLAB und Python werden häufig für den Entwurf und die Analyse von Filtern verwendet.

a)

Entwirf einen FIR-Tiefpassfilter mit einer Filterordnung von 10 unter Verwendung der Fenstermethode. Wähle ein geeignetes Fenster und berechne die Impulsantwort des Filters. Präsentiere die resultierende Frequenzantwort grafisch.

Lösung:

Entwurf eines FIR-Tiefpassfilters

Um einen FIR-Tiefpassfilter mit einer Filterordnung von 10 unter Verwendung der Fenstermethode zu entwerfen, folgen wir diesen Schritten:

• Wahl eines geeigneten Fensters: Ein häufig genutztes Fenster ist das Hamming-Fenster aufgrund seiner guten Eigenschaften im Frequenzbereich.
• Berechnung der Impulsantwort: Die Impulsantwort eines FIR-Filters wird durch das Produkt des idealen Tiefpassfilters und des Fensters erhalten.
• Präsentation der Frequenzantwort: Die Frequenzantwort des Filters kann grafisch dargestellt werden, um die Charakteristika des Filters zu analysieren.

Schritt 1: Wahl des Fensters

Wir verwenden das Hamming-Fenster:

import numpy as np import matplotlib.pyplot as plt from scipy.signal import freqz # Filterordnung N = 10 # Hamming-Fenster hamming_window = np.hamming(N + 1) 

Schritt 2: Berechnung der Impulsantwort

Die ideale Impulsantwort eines Tiefpassfilters kann mit der Sinc-Funktion dargestellt werden. Danach wird das Fenster angewendet:

# Normalisierte Grenzfrequenz fc = 0.25 # Berechnung der idealen Impulsantwort (Sinc-Funktion) h = np.sinc(2 * fc * (np.arange(N + 1) - N/2)) # Anwendung des Fensters h = h * hamming_window # Normalisierung der Impulsantwort h /= np.sum(h) 

Schritt 3: Präsentation der Frequenzantwort

Die Frequenzantwort kann unter Verwendung der Funktion freqz aus scipy.signal berechnet und grafisch dargestellt werden:

w, H = freqz(h) # Frequenzgang plt.figure() plt.plot(w / np.pi, 20 * np.log10(np.abs(H)), 'b') plt.title('Frequenzantwort des FIR-Tiefpassfilters') plt.xlabel('Normierte Frequenz (x π rad/sample)') plt.ylabel('Amplitudengang (dB)') plt.grid() plt.show() 

Die obenstehenden Schritte führen zur vollständigen Berechnung und grafischen Darstellung der Frequenzantwort eines FIR-Tiefpassfilters mit einer Filterordnung von 10 unter Verwendung der Fenstermethode und eines Hamming-Fensters.

b)

Welche Kriterien müssen erfüllt sein, damit ein IIR-Filter stabil ist? Berechne die Pole des folgenden IIR-Filters und überprüfe seine Stabilität:

h[n] = 0.8d[n] + 0.2d[n-1] + 0.3d[n-2]

Lösung:

Stabilitätskriterien für IIR-Filter

Damit ein IIR-Filter stabil ist, müssen alle seine Pole innerhalb des Einheitskreises im Frequenzbereich liegen. Das bedeutet, die Beträge der Pole dürfen nicht größer als 1 sein. In mathematischer Formulierung:

• Für jeden Pol p eines Filters gilt: \(|p| < 1\).

Berechnung der Pole des angegebenen IIR-Filters

Gegeben ist der IIR-Filter:

h[n] = 0.8d[n] + 0.2d[n-1] + 0.3d[n-2]

Dieser kann in der z-Transformation als:

H(z) = 0.8 + 0.2z^{-1} + 0.3z^{-2}

umgeschrieben werden. Die Ordnung des Filters ist 2, deshalb können wir z quadratisch vorwärts transformiert und die mögliche stabile Filterreihenfolge in Pole berechnen:

Implementierung in Python

import numpy as np roots_poly = np.array([0.8, 0.2, 0.3]) poles = np.roots(roots_poly) print('Pole des IIR-Filters:', poles) # Überprüfung der Stabilität stabilization = 'stabil' if np.all(np.abs(poles) < 1) else 'instabil' print('Der Filter ist: ', stabilization) 

Dies berechnet die Pole des IIR-Filters und überprüft, ob die Bedingungen zur Stabilitätsregelung erfüllt werden.

c)

Verwende den Parks-McClellan-Algorithmus zur Gestaltung eines Bandpassfilters mit den folgenden Anforderungen: Durchlassband 0.2 bis 0.5 (normierte Frequenzen) und Stoppbanddämpfung von mindestens 40 dB. Beschreibe die Schritte und Algorithmen, die in MATLAB oder einem ähnlichen Tool verwendet werden.

Lösung:

Gestaltung eines Bandpassfilters mit dem Parks-McClellan-Algorithmus

Der Parks-McClellan-Algorithmus ist eine iterative Methode zur Gestaltung von FIR-Filtern, die es ermöglicht, die Filterordnung und die Koeffizienten so zu bestimmen, dass ein optimaler linearer Phasengang im gegebenen Frequenzspektrum erreicht wird. Hier sind die Schritte zur Gestaltung eines Bandpassfilters mit den gegebenen Anforderungen unter Verwendung von MATLAB:

Anforderungen

• Durchlassband: 0.2 bis 0.5 (normierte Frequenzen)
• Stoppbanddämpfung: Mindestens 40 dB

Schritte in MATLAB

1. Definition der Anforderungen und Parameter: Spezifizieren der Frequenzbänder und die gewünschten Verstärkungen in diesen Bändern.
2. Verwendung des Befehls remez: Der MATLAB-Befehl remez (auch bekannt als Parks-McClellan-Algorithmus) wird zur Gestaltung des Filters verwendet.
3. Darstellung der Frequenzantwort: Grafische Darstellung der resultierenden Frequenzantwort zur Überprüfung der Spezifikationen.

Implementierung in MATLAB

 % Anforderungen definieren stopband_attenuation = 40; % in dB passband = [0.2 0.5]; % normierte Frequenzen bands = [0 0.2 0.5 1]; % Frequenzbänder wie in der Spezifikation desired = [0 1 0]; % gewünschte Verstärkungen in den Bändern % Gewichte für die Optimierung w = [10^(stopband_attenuation/20) 1 10^(stopband_attenuation/20)]; % Gestaltung mit dem Parks-McClellan-Algorithmus filter_order = 50; % Beispielhafte Filterordnung, kann angepasst werden b = remez(filter_order, bands, desired, w); % Frequenzantwort darstellen [h, omega] = freqz(b, 1, 1024); % Frequenzantwort figure; plot(omega/pi, 20*log10(abs(h))); title('Frequenzantwort des Parks-McClellan Bandpassfilters'); xlabel('Normierte Frequenz'); ylabel('Amplitudendämpfung (dB)'); grid on; 

Erklärung

• Frequenzbänder: Die array bands definiert die Eckpunkte der Frequenzbänder.
• Gewünschte Verstärkung: Das array desired gibt die Verstärkung (0 oder 1) in den jeweiligen Frequenzbereichen an.
• Gewichtung: Die array w gibt an, wie stark die einzelnen Bänder gewichtet werden sollen (proportional zur gewünschten Dämpfung).
• Filterentwurf: Der Befehl remez führt den eigentlichen Filterentwurf durch.
• Darstellung: Die Funktion freqz berechnet die Frequenzantwort des Filters, welche anschließend grafisch dargestellt wird.

Diese Schritte ermöglichen es, einen Bandpassfilter mit den vorgegebenen Spezifikationen unter Verwendung des Parks-McClellan-Algorithmus zu gestalten und zu analysieren.

d)

Analysiere den folgenden IIR-Filter durch Berechnung der Frequenzantwort an bestimmten Frequenzpunkten: \[ H(z) = \frac{0.2z^2 + 0.5z + 0.2}{z^2 - 0.4z + 0.8} \]. Nutze Python zur Berechnung der Frequenzantwort und stelle den Verlauf der Frequenzantwort grafisch dar.

Lösung:

Analyse eines IIR-Filters durch Berechnung der Frequenzantwort

Um die Frequenzantwort des gegebenen IIR-Filters \( H(z) = \frac{0.2z^2 + 0.5z + 0.2}{z^2 - 0.4z + 0.8} \) zu berechnen und grafisch darzustellen, können wir die freqz-Funktion aus dem scipy.signal-Paket in Python verwenden. Die Schritte umfassen:

• Definition der Koeffizienten des Zählers und Nenners des Filters.
• Berechnung der Frequenzantwort an bestimmten Frequenzpunkten.
• Grafische Darstellung der Frequenzantwort.

Implementierung in Python

Nachfolgend ist der Python-Code, der diese Schritte ausführt:

import numpy as np from scipy.signal import freqz import matplotlib.pyplot as plt # Koeffizienten des Zählers und Nenners definieren # H(z) = (0.2*z^2 + 0.5*z + 0.2) / (z^2 - 0.4*z + 0.8) b = [0.2, 0.5, 0.2] a = [1, -0.4, 0.8] # Berechnung der Frequenzantwort w, h = freqz(b, a, worN=1024) # Frequenzgang darstellen plt.figure() plt.plot(w / np.pi, 20 * np.log10(abs(h))) plt.title('Frequenzantwort des IIR-Filters') plt.xlabel('Normierte Frequenz (x π rad/sample)') plt.ylabel('Amplitudengang (dB)') plt.grid() plt.show() 

Erklärung

• Koeffizienten: Die Arrays b und a definieren die Koeffizienten des Zählers und des Nenners des Filters.
• Berechnung der Frequenzantwort: Die Funktion freqz berechnet die Frequenzantwort an 1024 Punkten im Einheitskreis.
• Grafische Darstellung: Die Frequenzantwort wird in dB aufgetragen, was eine übliche Darstellungsmethode ist, um die Verstärkung über das Frequenzspektrum anzuzeigen.

Dies ermöglicht die Analyse und grafische Darstellung des Frequenzgangs des gegebenen IIR-Filters.