Commit 04bc17ab authored by Hafiz Emin Kosar's avatar Hafiz Emin Kosar
Browse files

- updated copyright and added separation line to each notebook

parent bb5be608
%% Cell type:code id: tags:
``` python
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
# Copyright 2020 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib widget
from ipywidgets import interact, interactive, fixed
import ipywidgets as widgets
from IPython.display import clear_output, display, HTML, Audio
import numpy as np
from scipy import signal
from ient_nb.ient_plots import *
from ient_nb.ient_signals import *
from ient_nb.ient_filters import *
from ient_nb.ient_audio import *
fs = 22050 # Samplingrate
(t,deltat) = np.linspace(0,10, 10*fs, retstep=True) # Zeitachse
(x,deltax) = np.linspace(-5,5, 1024, retstep=True) # VDF
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Zufallssignale in LTI-Systemen
%% Cell type:markdown id: tags:
Für jede Musterfunktion ${}^k s(t)$ eines stochastischen Prozesses gilt bei Übertragung über ein LTI-System der Impulsantwort $h(t)$ das Faltungsprodukt ${}^k s(t)∗h(t)={}^{k}g(t)$. Wird ein Zufallssignal ${}^k n(t)$ über ein LTI-System übertragen, kann dies durch folgendes Blockschaltbild dargestellt werden:
![Blockdiagramm](figures/white_noise_lti_block_diagram.png)
Der Ausgangsprozess $g(t)$ kann wie jeder Zufallsprozess durch Mittelwerte und Verbundmittelwerte beschrieben werden.
Der hier verwendete Zufallsprozess $n(t)$ ist gleichverteiltes, weißes Rauschen mit
$$p_n(x) = \frac{1}{a} \mathrm{rect}\left(\frac{x-m_n}{a}\right)$$
mit Mittelwert $m_n$ und Varianz $\sigma_n^2=\frac{a^2}{12}$.
Beides ist in der nachfolgenden Abbildung dargestellt. Ebenso kann man das Rauschsignal anhören.
%% Cell type:code id: tags:
``` python
# Sample ^k n(t)
m_n = 0 # Mittelwert
sigma_n = 1 # Varianz
a = np.sqrt(12)*sigma_n
n = np.random.uniform(-0.5*a+m_n, 0.5*a+m_n, len(t))
# Gemessene Verteilungsdichtefunktion
pn_meas,bins = np.histogram(n,bins=200,range=(-5,5),density=True)
x_meas = (bins[:-1] + bins[1:]) / 2; x_meas0 = x_meas
# Berechnete Verteilungsdichtefunktion
pn = 1/a*rect((x-m_n)/a)
# Plot
fig,axs = plt.subplots(2,1,figsize=(8,4));
ax = axs[0]; ax.plot(1000*t, n, 'rwth');
ax.set_xlabel(r'$\rightarrow t$ [ms]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow {}^k n(t)$', bbox=ient_wbbox);
ax.set_xlim([0,11]); ient_axis(ax);
ax = axs[1]
ax.plot(x_meas, pn_meas, 'rwth'); ax.plot(x,pn,'k--');
ax.set_xlabel(r'$\rightarrow x$'); ax.set_ylabel(r'$\uparrow p_n(x)$');
ient_update_ylim(ax,pn_meas,0.1); ient_axis(ax);
ient_audio_play(n,fs)
```
%% Cell type:markdown id: tags:
## LTI System
### Tiefpassfilterung
Zunächst wird der gleichverteilte Rauschprozess über einen Tiefpass $h(t)$ mit Grenzfrequenz $f_\mathrm{g}$ übertragen. Der Betrag der Übertragungsfunktion ist in der nachfolgenden Grafik dargestellt.
%% Cell type:code id: tags:
``` python
# Filter requirements.
order = 4
fg = 500 # desired cutoff frequency of the filter, Hz
b, a = ient_butter_lowpass(fg, fs, order) # generate filter coefficients
w, H = signal.freqz(b, a, worN=len(t)) # compute H(f)=H(z=e^(j 2 pi f)) out of b, a
f = 0.5*fs*w/np.pi
fig,ax = plt.subplots(1,1); ax.plot(f, np.abs(H), 'rwth');
ax.axvline(fg, color='k',linestyle='--',lw=0.5); # cutoff frequency
ax.set_xlabel(r'$\rightarrow f$ [Hz]'); ax.set_ylabel(r'$\uparrow |H(f)|$', bbox=ient_wbbox);
ax.set_xlim([0,4000]); ax.set_ylim([-.25,1.19]); ient_axis(ax);
```
%% Cell type:markdown id: tags:
${}^k n(t)$, die $k$-te Realisierung von $n(t)$, wird nun über $h(t)$ übertragen:
![Blockdiagramm](figures/white_noise_lti_block_diagram.png)
Das Eingangssignal ${}^k n(t)$ ist in der folgenden Abbildung dargestellt. Darunter befindet sich der Plot des tiefpassgefilterten Ausgangssignals. Beide Signale stehen auch als Hörbeispiel zur Verfügung. Der Effekt der Tiefpassfilterung ist sowohl optisch als auch akustisch deutlich zu erkennen.
%% Cell type:code id: tags:
``` python
g = ient_filter(n, b, a)
fig,axs = plt.subplots(2,1);
ax = axs[0]; ax.plot(1000*t, n, 'rwth');
ax.set_xlabel(r'$\rightarrow t$ [ms]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow {}^k n(t)$', bbox=ient_wbbox);
ax.set_xlim([0,22]); ient_axis(ax);
ax = axs[1]; ax.plot(1000*t, g, 'rwth');
ax.set_xlabel(r'$\rightarrow t$ [ms]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow {}^k g(t)$', bbox=ient_wbbox);
ax.set_xlim([0,22]); ient_axis(ax);
ient_audio_play(n, fs, r'${}^k n(t)$')
ient_audio_play(g, fs, r'${}^k g(t)$')
```
%% Cell type:markdown id: tags:
Nun werden die Verteilungsdichtefunktionen des Eingangs- und Ausgangssignals gemessen.
Für die Verteilungsdichtefunktion $p_n(x)$ des Rauschsignals wird näherungsweise eine Gleichverteilung festgestellt.
Die Verteilungsdichtefunktion des Ausgangssignals $p_g(x)$ ist deutlich schmaler und nicht mehr gleichverteilt, sondern eher gauß-verteilt.
%% Cell type:code id: tags:
``` python
# Gemessene Verteilungsdichtefunktionen
pg_meas,bins = np.histogram(g, bins=200, range=(-5,5), density=True)
x_meas = (bins[:-1] + bins[1:]) / 2
fig,axs = plt.subplots(2,1);
ax = axs[0]; ax.plot(x_meas0, pn_meas, 'rwth');
ax.set_xlabel(r'$\rightarrow x$'); ax.set_ylabel(r'$\uparrow p_n(x)$');
ax.set_ylim([0,0.39]); ient_axis(ax);
ax = axs[1]; ax.plot(x_meas, pg_meas, 'rwth');
ax.set_xlabel(r'$\rightarrow x$'); ax.set_ylabel(r'$\uparrow p_g(x)$'); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Hochpassfilterung
Nun sei $h(t)$ ein Hochpass mit Grenzfrequenz $f_\mathrm{g}$, wie in der folgenden Abbildung dargestellt. Ein- und Ausgangssignal können auch hier angehört werden.
%% Cell type:code id: tags:
``` python
fg = 1000 # Hz
b, a = ient_butter_highpass(fg, fs, order) # generate filter coefficients
w, H = signal.freqz(b, a, worN=len(t)) # compute H(f)=H(z=e^(j 2 pi f)) out of b, a
f = 0.5*fs*w/np.pi
fig,ax = plt.subplots(1,1); ax.plot(f, np.abs(H), 'rwth');
ax.axvline(fg, color='k',linestyle='--',lw=0.5); # cutoff frequency
ax.set_xlabel(r'$\rightarrow f$ [Hz]'); ax.set_ylabel(r'$\uparrow |H(f)|$');
ax.set_xlim([0,4000]); ax.set_ylim([-.25,1.19]); ient_axis(ax);
g = ient_filter(n, b, a)
ient_audio_play(n, fs, r'${}^k n(t)$')
ient_audio_play(g, fs, r'${}^k g(t)$')
```
%% Cell type:markdown id: tags:
Nachfolgend wird noch die gemessene Verteilungsdichtefunktion des Rauschprozesses nach der Hochpassfilterung geplottet. Es ist zu erkennen, dass hier zwar eine eher gauß-verteilte Verteilungsdichte erzeugt wird, diese aber von der Breite und Höhe ähnlich zu der Gleichverteilung des Eingangsprozesses ist. Im Hörbeispiel ist auch zu hören, dass diese Hochpassfilterung auf das Rauschen einen sehr viel geringeren akustischen Einfluss hat, als die vorherige Tiefpassfilterung.
%% Cell type:code id: tags:
``` python
# Gemessene Verteilungsdichtefunktion
pg_meas,bins = np.histogram(g, bins=200, range=(-5,5), density=True)
x_meas = (bins[:-1] + bins[1:]) / 2
fig,axs = plt.subplots(2,1);
ax = axs[0]; ax.plot(x_meas0, pn_meas, 'rwth');
ax.set_xlabel(r'$\rightarrow x$'); ax.set_ylabel(r'$\uparrow p_n(x)$');
ax.set_ylim([0,0.39]); ient_axis(ax);
ax = axs[1]; ax.plot(x_meas, pg_meas, 'rwth');
ax.set_xlabel(r'$\rightarrow x$'); ax.set_ylabel(r'$\uparrow p_g(x)$'); ient_axis(ax);
```
%% Cell type:markdown id: tags:
## Interaktive GUI
In dieser interaktiven GUI kann ausprobiert werden, welchen Effekt eine Hoch- oder Tiefpassfilterung auf einen gleichverteilten Rauschprozess haben. Über das Drop-Down-Menü kann der gewünschte Filtertyp ausgewählt werden. Die Grenzfrequenz des Filters ist über den Schieberegler anpassbar.
Geplottet wird die erzeugte Verteilungsdichtefunktion des Ausgangssignal $p_g(x)$, ebenso kann der Effekt der Filterung angehört werden.
%% Cell type:code id: tags:
``` python
fig,axs = plt.subplots(2,1);
@widgets.interact(fg=widgets.FloatSlider(min=300, max=10000, step=100, description='$f_g$ [Hz]', continuous_update=False),
btype= widgets.Dropdown(options=['Tiefpass','Hochpass'], description='Filtertyp'))
def update_plot(fg, btype):
# LTI
b,a = ient_butter(fg, fs, order, btype)
g = ient_filter(n, b,a)
ient_audio_play(g, fs)
# Histogram
pg_meas,bins = np.histogram(g, bins=200, range=(-5,5), density=True)
x_meas = (bins[:-1] + bins[1:]) / 2
# Update plot
if not axs[0].lines:
ax = axs[0]; ax.plot(x_meas0, pn_meas, 'rwth');
ax.set_xlabel(r'$\rightarrow x$'); ax.set_ylabel(r'$\uparrow p_n(x)$');
ient_update_ylim(ax,pn_meas,0.1); ient_axis(ax);
ax = axs[1]; ax.plot(x_meas, pg_meas, 'rwth');
ient_update_ylim(ax,pg_meas,0.1);
ax.set_xlabel(r'$\rightarrow x$'); ax.set_ylabel(r'$\uparrow p_g(x)$'); ient_axis(ax);
else:
axs[1].lines[0].set_ydata(pg_meas)
```
%% Cell type:markdown id: tags:
## Aufgaben
* Höre dir zur Erinnerung nocheinmal das Eingangssignal an.
* Wähle eine kleine Grenzfrequenz aus. Wie hört sich das tiefpassgefilterte Signal im Vergleich zum Eingangssignal an, wie das hochpassgefilterte?
* Erhöhe die Grenzfrequenz. Welchen Effekt hat dies auf das tiefpass- bzw hochpassgefilterte Signal?
* Betrachte ebenfalls die Verteilungsdichtefunktion $p_g(x)$ des gefilterten Signals. Kannst du das Verhalten der Verteilungsdichten erklären?
%% Cell type:markdown id: tags:
___
This notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources) (OER). Feel free to use the notebook for your own purposes. The code is licensed under the [MIT license](https://opensource.org/licenses/MIT).
Please attribute the work as follows:
*Christian Rohlfing, Übungsbeispiele zur Vorlesung "Grundgebiete der Elektrotechnik 3 - Signale und Systeme"*, gehalten von Jens-Rainer Ohm, 2019, Institut für Nachrichtentechnik, RWTH Aachen University.
*Christian Rohlfing, Übungsbeispiele zur Vorlesung "Grundgebiete der Elektrotechnik 3 - Signale und Systeme"*, gehalten von Jens-Rainer Ohm, 2020, Institut für Nachrichtentechnik, RWTH Aachen University.
......
%% Cell type:code id: tags:
``` python
# Copyright 2020 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib widget
from ient_nb.ient_signals import *
from ient_nb.ient_plots import *
from ient_nb.ient_transforms import *
from src.z_transform.z_transform import zPlot
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import numpy as np
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# $z$-Transformation
Zum Starten: Im Menü: Run <span class="fa-chevron-right fa"></span> Run All Cells auswählen.
%% Cell type:markdown id: tags:
## Interaktive Demo
%% Cell type:code id: tags:
``` python
fig = plt.figure(figsize=(10, 10/16*9))
zp = zPlot(fig)
```
%% Cell type:markdown id: tags:
### Anleitung
In dieser interaktiven Demo kann das Pol-/Nullstellen-Diagramm, die zugehörige Impulsantwort sowie der Betrag der Übertragungsfunktion für verschiedene Filter betrachtet werden. Hierbei kann das Filter durch manuelles Hinzufügen und Löschen von Polen und Nullstellen definiert werden.
Über den Schieberegler kann der Wert für $H_0$ angepasst werden.
Bei *Modus* kann die Position des Konvergenzbereichs geändert werden, indem die entsprechende Option eingestellt und im Pol-/Nullstellendiagramm auf den Bereich geklickt wird, der der neue Konvergenzbereich sein soll.
Ähnlich können auch Pol- und Nullstellen hinzugefügt oder gelöscht werden. Bei *Typ* wird eingestellt, ob es sich um eine Pol- oder Nullstelle handeln soll und unter *Modus* wird dann *hinzufügen* oder *löschen* ausgewählt. Durch Klicken im Pol-/Nullstellendiagramm können nun Pol- und Nullstellen hinzugefügt oder gelöscht werden. Entsprechend ändern sich dann auch die zugehörige Impulsantwort und Übertragungsfunktion.
### Aufgaben
* Zunächst ist weder eine Pol-, noch eine Nullstelle vorhanden. Wie sehen Impulsantwort und Übertragungsfunktion aus? Welche Auswirkung hat das Ändern von $H_0$?
* Erstelle eine Polstelle auf dem Einheitskreis. Welche Auswirkung hat diese auf die Übertragungsfunktion?
* Erstelle ein Pol-/Nullstellendiagram mit mehreren möglichen Polstellen. Ändere den Konvergenzbereich. Wann existiert eine Übertragungsfunktion?
* Teste verschiedene Kombinationen von Pol- und Nullstellen und ihre Auswirkungen auf Impulsantwort und Übertragungsfunktion. Welche Auswirkung hat das Ändern von $H_0$ jetzt?
%% Cell type:markdown id: tags:
____
This notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources) (OER). Feel free to use the notebook for your own purposes. The code is licensed under the [MIT license](https://opensource.org/licenses/MIT).
Please attribute the work as follows:
*Emin Kosar, Christian Rohlfing, Übungsbeispiele zur Vorlesung "Grundgebiete der Elektrotechnik 3 - Signale und Systeme"*, gehalten von Jens-Rainer Ohm, 2020, Institut für Nachrichtentechnik, RWTH Aachen University.
......
%% Cell type:code id: tags:
``` python
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
# Copyright 2020 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib widget
from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets
from scipy.io import wavfile # wavfile
from ient_nb.ient_plots import *
from ient_nb.ient_signals import *
from ient_nb.ient_audio import *
from ient_nb.ient_transforms import *
from ient_nb.ient_filters import *
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Äquivalenter Tiefpass
Dieses Notebook beschäftigt sich mit den Auswirkungen von Tiefpass- und Bandpassfilterung, sowie Modulation auf ein Signal. Als Beispiel wird ein Sprachsignal verwendet. Dies hat den Vorteil, dass man sich die Auswirkung der verschiedenen Methoden direkt anhören kann. Hierzu einfach auf den Playbutton unter den Abbildungen klicken.
## Sprachsignal
Zunächst wird das Sprachsignal $s(t)$ eingelesen, dessen Fourier-Transformierte $S(f)$ wird berechnet und beides wird im nachfolgenden Plot dargestellt.
Bei reellwertigen Signalen $s(t)$, wie hier der Fall, ist das Spektrum $S(f)$ eine gerade
komplexe Funktion mit $S(-f)=S^\ast(f)$.
Des Weiteren ist im Spektrum zu erkennen, dass viele Anteile im niederfrequenten Bereich vorhanden sind.
%% Cell type:code id: tags:
``` python
fs, data = wavfile.read('data/krawehl_krawehl.wav'); data = data[int(3.25*fs):int(4.5*fs),0] # crop and mono
s = 0.99*data/np.max(np.abs(data)) # Normalisieren
(t, deltat) = np.linspace(0, len(s)/fs, len(s), retstep=True) # time axis in seconds
S, f = ient_dft(s, fs) # Fourier transform
# Plot
fix, axs = plt.subplots(2,1, **ient_landscape)
ax = axs[0]; ax.plot(t, s, 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow s(t)$', bbox=ient_wbbox);
ax = axs[1]; ax.plot(f/1000, np.abs(S), 'rwth'); ient_axis(ax); ax.set_xlim([-7.5, 7.5]);
ax.set_xlabel(r'$\rightarrow f$ [kHz]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow |S(f)|$');
ient_audio_play(s, fs, r'$s(t)$')
```
%% Cell type:markdown id: tags:
## Tiefpassfilterung
Um ein Tiefpasssignal $\tilde{s}(t)$ zu erhalten, wird $s(t)$ mit einem Butterworth-Tiefpass gefiltert. Der Frequenzgang des Filters ist in der folgenden Abbildung dargestellt. Die Grenzfrequenz liegt bei $f_\mathrm{g}=3\,\mathrm{kHz}$ und ist mit einer gestrichelten Linie dargestellt.
Nachfolgend ist das Signal $\tilde{s}(t)$, sowie das zugehörige Spektrum $|\tilde{S}(f)|$ geplottet. Der Effekt der Tiefpassfilterung ist im Spektrum deutlich zu erkennen. Ab der Grenzfrequenz $f_\mathrm{g}=3\,\mathrm{kHz}$ werden die Frequenzanteile deutlich gedämpft.
Im Vergleich zum Originalsprachsignal hört sich das neue Signal deutlich gedämpft an, ist aber noch gut zu verstehen.
%% Cell type:code id: tags:
``` python
fg = 3000
b, a = ient_butter_lowpass(fg, fs) # generate filter coefficients
_, H = signal.freqz(b, a, worN=int(len(t)/2+1)) # compute H(f)=H(z=e^(j 2 pi f)) out of b, a
f = np.linspace(0, fs/2, len(H));
# Plot
fig,ax = plt.subplots(1,1); ax.plot(f/1000, np.abs(H), 'rwth');
ax.axvline(fg/1000, color='k', linestyle='--',lw=0.5); # cutoff frequency
ax.set_xlabel(r'$\rightarrow f$ [kHz]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow |H_\mathrm{TP}(f)|$');
ax.set_xlim([0,7.5]); ax.set_ylim([-.25,1.19]); ient_axis(ax);
```
%% Cell type:code id: tags:
``` python
s_tilde = ient_filter(s, b, a)
# Plot
fig,axs = plt.subplots(2,1, **ient_landscape); ax = axs[0]; ax.plot(t, s_tilde, 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow \tilde{s}(t)$', bbox=ient_wbbox);
S_tilde, f = ient_dft(s_tilde, fs);
ax = axs[1]; ax.plot(f/1000, np.abs(S_tilde), 'rwth'); ax.set_xlim([-7.5, 7.5]); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow f$ [kHz]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow |\tilde{S}(f)|$');
ient_audio_play(s_tilde, fs, r'$\tilde{s}(t)$')
```
%% Cell type:markdown id: tags:
## Modulation
Da oft eine Übertragung eines Signals im höherfrequenten Bereich gewünscht ist, viele wichtige Signalanteile sich jedoch im tieffrequenten Bereich befinden, kann das Signal mit einem sogenannten Trägersignal moduliert werden. Hier wird als Beispiel mit einem Cosinus der Frequenz $f_0$ moduliert und es entsteht das Signal
$$m(t) = \tilde{s}(t) \cdot \cos(2\pi f_0 t)\text{ .}$$
Für die Trägerfrequenz wird hier $f_0=6\,\mathrm{kHz}$ gewählt.
Die folgende Abbildung zeigt einen kurzen Ausschnitt aus dem Signal $\tilde{s}(t)$, das Cosinussignal für diesen Zeitausschnitt, sowie das entstehende modulierte Signal $m(t)$.
%% Cell type:code id: tags:
``` python
f0 = 6000
m = s_tilde * np.cos(2*np.pi*f0*t)
# Plot
fig,axs = plt.subplots(3,1);
ax = axs[0]; ax.plot(t*1000, s_tilde, 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.set_title(r'$\tilde{s}(t)$');
ax = axs[1]; ax.plot(t*1000, np.cos(2*np.pi*f0*t), 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.set_title(r'$\cos(2 \pi f_0 t)$');
ax = axs[2]; ax.plot(t*1000, m, 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.set_title(r'$m(t)=\tilde{s}(t)\cos(2 \pi f_0 t)$');
[ax.set_xlim([400,410]) for ax in axs];
```
%% Cell type:markdown id: tags:
Die nächste Abbildung zeigt das gesamte Zeitsignal $m(t)$ und dessen Spektrum $M(f)$. Der Effekt der Modulation ist im Spektrum deutlich zu erkennen. Wo zuvor die Komponenten im niederfrequenten Bereich lagen, sind nun zwei verschobene Spektren zu erkennen, die sich bei der Trägerfrequenz $f_0=6\,\mathrm{kHz}$ befinden. Hört man sich nun das Sprachsignal an, ist vom Original nur noch wenig zu hören, da sich die Information nun im höherfrequenten Bereich befindet. Um das Originalsignal zurückzugewinnen, muss es demoduliert und damit wieder in den niederfrequenten Bereich verschoben werden.
%% Cell type:code id: tags:
``` python
fig,axs = plt.subplots(2,1, **ient_landscape); ax = axs[0]; ax.plot(t, m, 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow m(t)$');
M, f = ient_dft(m, fs); ax = axs[1]; ax.plot(f/1000, np.abs(M), 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow f$ [kHz]'); ax.set_ylabel(r'$\uparrow |M(f)|$'); ax.set_xlim([-12,12])
ient_audio_play(m, fs, r'$m(t)$')
```
%% Cell type:markdown id: tags:
## Äquivalentes Tiefpasssignal
Die Übertragungsfunktion eines Bandpasssystems $H(f)$ kann durch die Übertragungsfunktion $H_{\mathrm{T}}(f)$ ein äquivalentes Tiefpasssystem zusammen mit einer Frequenz $f_0$ beschrieben werden. Hierzu wird zunächst die Übertragungsfunktion $H(f)$ auf positive Frequenzen begrenzt, mit dem Faktor 2 multipliziert und zur Bildung von $H_{\mathrm{T}}(f)$ um eine geeignete Frequenz, die Trägerfrequenz $f_0$ genannt wird, in Richtung negativer Frequenzen verschoben.
Dies hat zum Einen rechnerische Vorteile, zum Anderen kann dies schaltungstechnisch genutzt werden. Praktische Anwendungen findet dieses Verfahren beispielsweise in der Empfängertechnik und der Messtechnik, sowie bei der Realisierung von Bandpass-Übertragungssystemen mittels digitaler Signalverarbeitungsmethoden mit möglichst geringer Taktrate.
%% Cell type:markdown id: tags:
Im Folgenden wird die Berechnung des äquivalenten Tiefpasssignals $m_\mathrm{T}(t)$ bezüglich Mittenfrequenz $f_0$ des reellwertigen Bandpasssignals $m(t)$ erklärt und mit Hilfe der Abbildungen deutlich gemacht.
Zunächst wird nur die rechte Seite (rechtsseitige Frequenzanteile) des Spektrums $M(f)$ behalten
$$M_+(f) = M(f) \varepsilon(f) \text{.}$$
Im Zeitbereich wird das korrespondierende $m_+(t)$ auch analytische Komponente genannt.
Mit $\mathcal{F}^{-1}\{\varepsilon(f)\} = \frac{1}{2}\delta(t) + \mathrm{j}\frac{1}{2 \pi t}$ erhält man
$$m_+(t) = \frac{1}{2} m(t) + \frac{\mathrm{j}}{2}s(t) \ast \frac{1}{\pi t} \text{.}$$
Die analytische Komponente $m_+(t)$ kann bei reellwertigen Signalen über die Hilbert-Transformation gewonnen werden.
In der Abbildung ist dieses Vorgehen zu erkennen: Der obere Plot zeigt das rechtsseitige Spektrum, direkt darunter ist die analytische Komponente zu sehen.
%% Cell type:markdown id: tags:
Nun wird $M_+(f)$, die rechtsseitigen Frequenzanteile von $M(f)$, um $f_0$ nach links verschoben:
$$M_\mathrm{T}(f) = 2 M_+(f) \ast \delta(f+f_0) \text{.}$$
So erhält man das äquivalente Tiefpasssignal $m_\mathrm{T}(t)$ des Bandpasssignals $m(t)$
$$m_\mathrm{T}(t)=2 m_+(t) \mathrm{e}^{-\mathrm{j}2\pi f_0 t} \text{.}$$
Das äquivalente Tiefpasssignal, sowie das zugehörige Spektrum, sind ebenfalls in der Abbildung dargestellt.
%% Cell type:code id: tags:
``` python
def calculate_eq_lp(s, f0): # s: BP signal, f0: center frequency
""""
g = signal.hilbert(s) is NOT calculating the Hilbert transform,
but the scaled analytic component g=2*s_plus using the Hilbert transform,
such that Re{g(t)} = s(t) and Im{g(t)} = s(t) * 1/(pi t)
"""
s_plus = 0.5*signal.hilbert(s) # analytic component
s_T = 2*s_plus*np.exp(-2*1J*np.pi*f0*t) # modulate to get equivalent lowpass signal
return s_T, s_plus
m_T, m_plus = calculate_eq_lp(m, f0); m_T = np.real(m_T);
M_T, f = ient_dft(m_T, fs); M_plus,_ = ient_dft(m_plus, fs);
# Plot
fig,axs = plt.subplots(2,1, **ient_landscape);
ax = axs[0]; ax.plot(f/1000, np.abs(M_plus), 'rwth'); ient_axis(ax); ax.set_title('Rechtsseitiges Spektrum')
ax.set_xlabel(r'$\rightarrow f$ [kHz]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow |M_+(f)|$');
ax = axs[1]; ient_axis(ax); ax.set_title('Analytische Komponente')
ax.plot(t, np.real(m_plus), 'rwth', label=r'$\mathrm{Re}\{m_+(t)\}$'); ax.plot(t, np.imag(m_plus), 'grun', label=r'$\mathrm{Im}\{m_+(t)\}$');
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.legend();
fig,axs = plt.subplots(2,1, **ient_landscape); ax = axs[0]; ax.plot(t, m_T, 'rwth'); ient_axis(ax); ax.set_title('Äquivalentes Tiefpasssignal')
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow m_\mathrm{T}(t)$', bbox=ient_wbbox);
ax = axs[1]; ax.plot(f/1000, np.abs(M_T), 'rwth'); ient_axis(ax);
ax.set_xlabel(r'$\rightarrow f$ [kHz]', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow |M_\mathrm{T}(f)|$');
ient_audio_play(m_T, fs, r'$m_\mathrm{T}(t)$')
```
%% Cell type:markdown id: tags:
Es sei noch einmal darauf hingewiesen, dass einem gegebenen Bandpasssystem mit reeller Impulsantwort beliebig viele äquivalente Tiefpasssysteme mit unterschiedlichen Übertragungsfunktionen $H_{\mathrm{T}}(f)$ bzw. Impulsantworten $h_{\mathrm{T}}(t)$ zugeordnet werden können, da die Zuordnung von $H(f)$ zu $H_{\mathrm{T}}(f)$ abhängig von der Trägerfrequenz $f_0$ ist.
%% Cell type:markdown id: tags:
Der Betrag $|m_\mathrm{T}(t)|$ des äquivalenten Tiefpasssignals $m_\mathrm{T}(t)$ wird auch als Einhüllende von $m(t)$ bezeichnet. Warum dies so ist, kann in der folgenden Grafik anschaulich betrachtet werden:
%% Cell type:code id: tags:
``` python
# Plot
fig, axs = plt.subplots(2, 1, **ient_landscape);
ax = axs[0]; ax.plot(t, m, 'rwth', label=r'$m(t)$');
ax.plot(t, np.abs(m_T), 'grun', label=r'$|m_\mathrm{T}(t)|$');
ax.set_xlabel(r'$\rightarrow t$ [s]', bbox=ient_wbbox);
ax.legend(); ient_axis(ax);
ax = axs[1]; ax.plot(t*1000, m, 'rwth', label=r'$g(t)$'); ient_axis(ax);
ax.plot(t*1000, np.abs(m_T), 'grun', label=r'$|m_\mathrm{T}(t)|$');
ax.set_xlim([400,410]); ax.set_xlabel(r'$\rightarrow t$ [ms]', bbox=ient_wbbox);
```
%% Cell type:markdown id: tags:
---
This notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources) (OER). Feel free to use the notebook for your own purposes. The code is licensed under the [MIT license](https://opensource.org/licenses/MIT).
Please attribute the work as follows:
*Christian Rohlfing, Übungsbeispiele zur Vorlesung "Grundgebiete der Elektrotechnik 3 - Signale und Systeme"*, gehalten von Jens-Rainer Ohm, 2019, Institut für Nachrichtentechnik, RWTH Aachen University.
*Christian Rohlfing, Übungsbeispiele zur Vorlesung "Grundgebiete der Elektrotechnik 3 - Signale und Systeme"*, gehalten von Jens-Rainer Ohm, 2020, Institut für Nachrichtentechnik, RWTH Aachen University.
......
%% Cell type:code id: tags:
``` python
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
# Copyright 2020 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib widget
import ipywidgets as widgets
from ipywidgets import interact, interactive, fixed, Layout
from IPython.display import clear_output, display, HTML
from scipy import signal # convolution
from ient_nb.ient_plots import *
from ient_nb.ient_signals import *
from ient_nb.ient_transforms import *
eps = np.finfo(float).eps
def convolution(s, h):
# Convolve s and h numerically
return signal.convolve(s(t), h(t), mode='same')*deltat
(t,deltat) = np.linspace(-20, 20, 50001, retstep=True) # t Achse
(f,deltaf) = np.linspace(-20, 20, 50001, retstep=True) # f Achse
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Übertragungsfunktion
Zum Starten: Im Menü: Run <span class="fa-chevron-right fa"></span> Run All Cells auswählen.
In diesem Beispiel wird die Übertragung eines Eingangssignal $s(t)$ über ein System mit der Impulsantwort $h(t)$ und der zugehörigen Übertragungsfunktion $H(f)$ gezeigt.
## Eingangssignal
Das verwendete Eingangssignal ist ein Rechteck mit der Breite $T_0=4$:
$\displaystyle s(t) = \frac{1}{T_0}\mathrm{rect}\left(\frac{t}{T_0}\right)$. Dieses ist in der folgenden Abbildung dargestellt.
%% Cell type:code id: tags:
``` python
s = lambda t: 1/T0*rect(t/T0)
# PLot
T0 = 4
plt.close(); fig,ax=plt.subplots();
ax.plot(t, s(t), 'rwth');
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)$')
ax.set_xlim([-5,5]); ax.set_ylim([0,0.5]); ient_axis(ax);
```
%% Cell type:markdown id: tags:
Das System hat die Impulsantwort $\displaystyle h(t) = \frac{1}{T}\varepsilon(t)\mathrm{e}^{-t/T}$ und die Übertragungsfunktion $\displaystyle H(f) = \frac{1}{1+\mathrm{j}2 \pi f T}$ mit $T=RC$. Der Betrag der Übertragungsfunktion ist nachfolgend geplottet.
%% Cell type:code id: tags: