Commit dbf42712 authored by Christian Rohlfing's avatar Christian Rohlfing
Browse files

- used matplotlib widget instead of ... notebook

- hopefully postBuild and requirements.txt are working fine
parent bfc1ce19
%% Cell type:code id: tags:
``` python
%matplotlib notebook
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib widget
from ipywidgets import interact, interactive, fixed, HBox, VBox
import ipywidgets as widgets
from IPython.display import clear_output, display, HTML
from src.sampling.sampling_plot import SamplingPlot
from ient_nb.ient_plots import *
from ient_nb.ient_transforms import *
from ient_nb.ient_signals import *
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Ideale Abtastung
Dieses Notebook soll die ideale Abtastung veranschaulichen.
![Blockdiagramm](figures/sampling_block_diagram.png)
Das zeitkontinuierliche Signal $s(t)$ wird zu Zeitpunkten $nT$ mit Abtastperiode $T$ abgetastet. Das resultierende, ideal abgetastete Signal
$$s_\mathrm{a}(t) = \sum\limits_{n=-\infty}^\infty s(nT) \delta(t-nT)$$
besteht aus Dirac-Impulsen, positioniert an den Zeitpunkten $nT$ und gewichtet mit dem Funktionswerten $s(nT)$. Die zugehörige Fourier-Transformierte $S_{\mathrm{a}}(f)$ wird aus periodischen Wiederholungen des Signalspektrums $S(f)$ zusammengesetzt:
$$S_\mathrm{a}(f) = \frac{1}{T}\sum\limits_{k=-\infty}^\infty S\left(f-\frac{k}{T}\right) \text{.}$$
Zur Rückgewinnung wird ein Rekonstruktionsfilter $h_\mathrm{TP}(t)$ eingesetzt, welches im Idealfall die die spektrale Kopie bei $k=0$ (auch Basisband genannt) aus $S_\mathrm{a}(f)$ rekonstruieren soll.
Hier wird das ideale Tiefpassfilter $H_\mathrm{TP}(f)=\mathrm{rect}(f)$ verwendet.
%% Cell type:markdown id: tags:
Zur Auswahl stehen vier Signale $s(t)$:
* $s(t) = \cos(2 \pi t)$,
* $s(t) = \mathrm{si}(2 \pi t)$,
* $s(t) = \mathrm{rect} (t)$ und
* $s(t) = \Lambda(t)$.
Achtung: Die letzten beiden Signale $s(t)$, Rechteck- und Dreieckimpuls, haben unendlich ausgedehnte Spektren $S(f)$. Daher ist eine fehlerfreie Rekonstruktion prinzipiell nicht möglich!
Zunächst werden $s(t)$ und $s_\mathrm{a}(t)$ im Zeitbereich betrachtet. Weiterhin wird das zu $s_\mathrm{a}(t)$ gehörige Spektrum $S_\mathrm{a}(f)$ dargestellt. In der gleichen Abbildung ist die Übertragungsfunktion $H_\mathrm{TP}(f)$ des Rekonstruktionsfilters gezeigt. In der letzten Abbildung wird nun das rekonstruierte Signal $g(t)$ gezeigt. Im Alias-freien Fall gilt $g(t)=s(t)$.
%% Cell type:code id: tags:
``` python
# Open figures and create GUI elements
sPlot = SamplingPlot()
signal = interactive(sPlot.update_signal, signal=widgets.Dropdown(
options=['cos-Funktion', 'si-Funktion', 'Rechteckimpuls', 'Dreieckimpuls'], description=r'$s(t)$'))
T = interactive(sPlot.update_T, T=widgets.FloatSlider(min=0.1, max=2.55, value=0.1, step=.1, description=r'$T$'))
display(VBox([signal, T]));
```
%% 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, 2019, Institut für Nachrichtentechnik, RWTH Aachen University.
......
%% Cell type:code id: tags:
``` python
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib notebook
%matplotlib widget
import ipywidgets as widgets
from ipywidgets import interact, interactive
import scipy as sp
import scipy.special
import scipy.signal
from ient_nb.ient_plots import *
from ient_nb.ient_signals import *
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Auto- und Kreuzkorrelationsfunktion von Energiesignalen
## Einleitung
### Energiesignal
$E_s = \int\limits_{-\infty}^\infty |s(t)|^2 \mathrm{d} t$ existiert
### Kreuzkorrelationsfunktion
$$
\varphi_{sg}^\mathrm{E}(\tau)
= \int\limits_{-\infty}^\infty s^\ast(t) g(t+\tau)\mathrm{d}t
\stackrel{t\rightarrow -t}{=} \int\limits_{-\infty}^\infty s(-t)^\ast g(\tau-t) \mathrm{d} t
= s^\ast(-\tau) \ast g(\tau)
= \left[\varphi_{gs}^\mathrm{E}(-\tau)\right]^\ast
$$
### Autokorrelationsfunktion
Setze $g(t) = s(t)$
%% Cell type:markdown id: tags:
### Signale
Generiere $t$- und $\tau$-Achsen und generiere Auswahl an [Elementarsignalen](GDET3%20Elementarsignale.ipynb).
%% Cell type:code id: tags:
``` python
def correlation(s, g):
# Correlate s and g numerically
return sp.signal.convolve(np.conj(s(-t)),g(t), mode='full')*deltat
fs = 2000 # Samplingrate
(t,deltat) = np.linspace(-8,8, 16*fs, retstep=True) # Zeitachse
(tau,deltatau) = np.linspace(-16,16, 2*len(t)-1, retstep=True) # Korrelation
signal_types = {'Rechteck' : rect,
'Dreieck' : tri,
'Sprungfunktion' : unitstep,
'si-Funktion' : lambda t: si(t*np.pi),
'Exponentialimpuls' : lambda t: unitstep(t)*np.exp(-t),
'Gauß-Signal' : gauss,
'Rampe' : lambda t: t*rect(t-0.5),
'Versch. Rechteck' : lambda t: -rect(t-0.5),
'Eigene Kreation' : lambda t: rect(t/2-1/2),
}
```
%% Cell type:markdown id: tags:
## Interaktive Demo
$$
\varphi_{sg}^\mathrm{E}(\tau)
= s^\ast(-\tau) \ast g(\tau)
= g(\tau) \ast s^\ast(-\tau)
= \int\limits_{-\infty}^\infty g(t) s^\ast(t-\tau) \mathrm{d} t
$$
Wähle $s(t)$ und $g(t)$
%% Cell type:code id: tags:
``` python
fig0, axs0 = plt.subplots(1, 2, figsize=(8,2))
@widgets.interact(s_type=widgets.Dropdown(options=list(signal_types.keys()), description=r'Wähle $s(t)$:'),
s_T=widgets.FloatSlider(min=0.5, max=4, value=1, step=.1, description=r'Dehnung T', style=ient_wdgtl_style),
s_t0=widgets.FloatSlider(min=-2, max=2, value=0, step=.1, description=r'Verschiebung $t_0$', style=ient_wdgtl_style),
g_type=widgets.Dropdown(options=list(signal_types.keys()), description=r'Wähle $g(t)$:'),
g_T=widgets.FloatSlider(min=0.5, max=4, value=1, step=.1, description=r'Dehnung T', style=ient_wdgtl_style),
g_t0=widgets.FloatSlider(min=-2, max=2, value=0, step=.1, description=r'Verschiebung $t_0$', style=ient_wdgtl_style))
def update_signals(s_type, s_T, s_t0, g_type, g_T, g_t0):
global s, g, phi_sg # reused in second interactive plot
s = lambda t: signal_types[s_type]((t-s_t0)/s_T);
g = lambda t: signal_types[g_type]((t-g_t0)/g_T);
phi_sg = correlation(s, g) # numerical correlation
if not axs0[0].lines: # plot s(t) and g(t)
ax = axs0[0]; ax.plot(t, s(t), 'rwth');
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)$')
ax.set_xlim([-2.9, 2.9]); ax.set_ylim([-1.19, 1.19]); ient_axis(ax); ient_grid(ax);
ax = axs0[1]; ax.plot(t, g(t), 'rwth');
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow g(t)$')
ax.set_xlim(axs0[0].get_xlim()); ax.set_ylim(axs0[0].get_ylim()); ient_axis(ax); ient_grid(ax);
else: # update lines
axs0[0].lines[0].set_ydata(s(t));
axs0[1].lines[0].set_ydata(g(t));
try: # if convolution figure is already opened, update s(t)
if axs[0].lines:
axs[0].lines[0].set_ydata((g(t)));
ient_update_ylim(axs[0], np.concatenate((g(t), s(t))), 0.19, 5); ient_update_ylim(axs[1], phi_sg, 0.19, 5);
update_plot(-2); # update correlation plot
except: pass
ient_update_ylim(axs0[0], s(t), 0.19, 5); ient_update_ylim(axs0[1], g(t), 0.19, 5);
```
%% Cell type:code id: tags:
``` python
fig, axs=plt.subplots(2, 1, figsize=(8,6),) # gridspec_kw = {'width_ratios':[3, 1]}
@widgets.interact(tau_shft=widgets.FloatSlider(min=-4, max=4, value=-2, step=.1, description=r'Verschiebung $\tau$', style=ient_wdgtl_style),
show_integrand=widgets.Checkbox(value=True, description='Zeige Integrand', style=ient_wdgtl_style))
def update_plot(tau_shft, show_integrand=True):
tau_ind = np.where(tau>=tau_shft); tau_ind = tau_ind[0][0]; phi_plot = phi_sg.copy(); phi_plot[tau_ind:] = np.nan; # hide g(t') with t'>t
sg = np.conj(s(t-tau_shft))*g(t) # integrand
if not axs[0].lines: # Call plot() and decorate axes. Usually, these functions take some processing time
ax = axs[0]; ax.plot(t, g(t), 'rwth', label=r'$g(t)$'); # plot g(t)
ax.plot(t, np.conj(s(t-tau_shft)), 'grun', label=r'$s^\ast(t-\tau)$'); # plot s(t-tau)
ax.plot(t, sg, '--', color='orange', lw=1, label=r'$g(t)s^\ast(t-\tau)$'); # plot integrand
ient_annotate_xtick(ax, r'$\tau$', tau_shft, -0.1, 'rwth', 15); # mark t on tau axis
ax.fill_between(t, 0, sg, facecolor="none", hatch="//", edgecolor='k', linewidth=0.0); # hatch common area
ax.set_xlabel(r'$\rightarrow t$');
ax.set_xlim([-4.2,4.2]); ient_update_ylim(ax, np.concatenate((g(t), s(t))), 0.19, 5);
ax.legend(); ient_grid(ax); ient_axis(ax);
ax = axs[1]; ax.plot(tau, phi_plot); # plot phi_sg(tau)
ax.plot([tau_shft, tau_shft], [0, phi_sg[tau_ind]], 'ko--', lw=1);
ax.set_xlabel(r'$\rightarrow \tau$');
ax.set_ylabel(r'$\uparrow \varphi_{sg}^\mathrm{E}(\tau) = \int g(t) s^\ast(t-\tau)\mathrm{d}t$');
ax.set_xlim(axs[0].get_xlim()); ient_update_ylim(ax, phi_sg, 0.19, 5);
ient_axis(ax); ient_grid(ax); fig.tight_layout();
else: # Replace only xdata and ydata since plt.plot() takes longer time
ax = axs[0]; ax.lines[1].set_ydata(np.conj(s(t-tau_shft))); ax.lines[2].set_ydata(sg); # update signals
ax.texts[0].set_x(tau_shft); ax.lines[3].set_xdata([tau_shft,tau_shft]) # update labels
if ax.collections: ax.collections[0].remove(); # update integrand
if show_integrand: ax.fill_between(t,0,sg, facecolor="none", hatch="//", edgecolor='k', linewidth=0.0);
ax = axs[1]; ax.lines[0].set_ydata(phi_plot); # update signals
ax.lines[1].set_xdata([tau_shft, tau_shft]); ax.lines[1].set_ydata([0, phi_sg[tau_ind]]); # update labels
axs[0].lines[2].set_visible(show_integrand)
```
%% 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.
......
%% Cell type:code id: tags:
``` python
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib notebook
%matplotlib widget
from ient_nb.ient_plots import *
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Diskrete Faltung
%% Cell type:code id: tags:
``` python
M = 17
n = np.arange(0, M)
k = n
n
```
%% Cell type:code id: tags:
``` python
sd = np.array([1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1]) # s(n)
hd = sd
# Plot
fig,ax = plt.subplots()
ient_stem(ax, n, sd, 'rwth')
ax.set_xlabel(r'$\rightarrow n$', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow s_\mathrm{d}(n)$', bbox=ient_wbbox);
ax.set_ylim([-0.09,1.09]); ient_axis(ax)
```
%% Cell type:code id: tags:
``` python
M = len(n)
Sd = np.real(np.fft.fft(sd, M)) # np.real() discards very small negative values
Hd = np.real(np.fft.fft(hd, M))
# Plot
fig,ax = plt.subplots()
ient_stem(ax, k, Sd, 'rwth')
ax.set_xlabel(r'$\rightarrow k$', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow S_\mathrm{d}(k)$', bbox=ient_wbbox);
ax.set_ylim([-1.9,7.9]); ient_axis(ax)
```
%% Cell type:code id: tags:
``` python
Gd = Sd * Hd
# Plot
gd = np.real(np.fft.ifft((Gd)))
fig,axs = plt.subplots(2,1)
ax = axs[0]; ient_stem(ax,k,Gd, 'rwth')
ax.set_xlabel(r'$\rightarrow k$', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow G_\mathrm{d}(k)$', bbox=ient_wbbox);
ax.set_ylim([-1,59]); ient_axis(ax)
ax = axs[1]; ient_stem(ax,n,gd, 'rwth')
ax.set_xlabel(r'$\rightarrow n$', bbox=ient_wbbox); ax.set_ylabel(r'$\uparrow g_\mathrm{d}(n)$', bbox=ient_wbbox);
ax.set_ylim([-0.09,8.9]); ient_axis(ax)
```
%% 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.
......
%% Cell type:code id: tags:
``` python
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib notebook
%matplotlib widget
from ipywidgets import interact, interactive
import ipywidgets as widgets
from ient_nb.ient_plots import *
from ient_nb.ient_signals import *
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Elementarsignale
Ein Signal ist i. Allg. die Darstellung des Amplitudenverlaufs einer physikalischen Größe, wie z. B. einer elektrische Spannung, Feldstärke oder auch eines Schalldrucks, Helligkeitsverlaufs, Lichtpegels usw. Häufig werden als Signale Zeitfunktionen solcher Größen benutzt, aber auch andere Abhängigkeiten,wie z. B. Ortsabhängigkeiten bei Bildsignalen, sind möglich. Speziell in der Nachrichtentechnik hat das Signal als Träger einer dem Empfänger unbekannten Information zumeist Zufallscharakter. Aufbauelemente (Elementarkomponenten) solcher Zufallssignale sind aber häufig die determinierten Signale, deren Verlauf zumindest im Prinzip durch einen geschlossenen Ausdruck vollständig beschrieben werden kann.
Ein Elementarsignal ist ein Signal mit einer besonders einfachen Form. Sie können technisch oft recht einfach erzeugt werden und werden vielfach auch zur Ermittlung der Eigenschaften von Systemen verwendet.
Im Folgenden werden einige Elementarsignale aufgeführt.
%% Cell type:markdown id: tags:
## Signale
### Gauß-Signal
Ein Beispiel für ein Elementarsignal, das durch einen algebraischen Ausdruck ausgedrückt wird, ist das Gaußsignal $\displaystyle s(t) = \mathrm{e}^{\pi t^2}$.
%% Cell type:code id: tags:
``` python
fig,ax = plt.subplots(1,1); ax.plot(t, gauss(t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)=\mathrm{e}^{-\pi t^2}$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.75, 2.75]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Sprungfunktion
Die Sprungfunktion wird beschrieben durch
$\epsilon(t)=\begin{cases}
0\quad\text{für}\ t<0 \\
1\quad\text{für}\ t\geq 0 \text{ .}
\end{cases}$
Ein Beispiel für eine Sprungfunktion ist der Spannungsverlauf an einem Ohm’schen Widerstand, der zur Zeit $t= 0$ an eine Gleichspannungsquelle geschaltet wird.
%% Cell type:code id: tags:
``` python
fig,ax = plt.subplots(1,1); ax.plot(t, unitstep(t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)=\epsilon(t)$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.25,2.25]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Rechteckimpuls
Der Rechteckimpuls wird definiert als
$\mathrm{rect}(t) = \begin{cases}
1\quad\text{für}\ |t| \leq 1/2\\
0\quad\text{für}\ |t| > 1/2\text{ .}
\end{cases}$
%% Cell type:code id: tags:
``` python
fig,ax = plt.subplots(1,1); ax.plot(t, rect(t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)=\mathrm{rect}(t)$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.25,2.25]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Dreieckimpuls
Der Dreieckimpuls wird definiert als
$\Lambda(t) = \begin{cases}
1-|t|\quad\text{für}\ |t|\leq 1\\
0\quad\text{für}\ |t| > 1\text{ .}
\end{cases}$
%% Cell type:code id: tags:
``` python
fig,ax = plt.subplots(1,1); ax.plot(t, tri(t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)=\Lambda(t)$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.25,2.25]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Si-Funktion
Die Si-Funktion ist definiert als $\displaystyle \mathrm{si}(t) = \frac{\sin(t)}{t}$
Die si-Funktion ist auch als Spaltfunktion bekannt, da in optischen Systemen und Antennensystemen ein Spalt als räumliche rect-Funktion beschrieben werden kann (Bracewell, 1986). Sie hat außerdem die besondere Eigenschaft, sich bei Faltung mit sich selbst zu reproduzieren: $\mathrm{si*\pi}(t)=\mathrm{si*\pi}(t)*\mathrm{si*\pi}(t)$.
%% Cell type:code id: tags:
``` python
fig,ax = plt.subplots(1,1); ax.plot(t, si(np.pi*t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)=\mathrm{si}(\pi t)$', bbox=ient_wbbox)
ax.set_xlim([-5.5,5.5]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
## Zeitverschiebung, -dehnung und -spiegelung
%% Cell type:markdown id: tags:
Jedes Signal $s(t)$ kann verschoben, gedehnt/gestaucht und/oder gespiegelt werden. Im Folgenden werden die Effekte dieser Operationen auf das Signal verdeutlicht. Als grundlegende Form wird
$\displaystyle s\left(\pm\frac{t-t_0}{T}\right)$
gewählt. Hierbei steht $t_0$ für die Verschiebung des Signals, $T$ für die Dehnung/Stauchung und $\pm$ beschreibt die Spiegelung.
### Zeitverschiebung
Als Beispiel wird ein verschobener Rechteckimpuls $s(t) = \mathrm{rect}\left(t-\frac{1}{2}\right)$ betrachtet. Die Funktion $\mathrm{rect}(t)$ hat die Breite 1 und ist um $0$ zentriert, der um $t_0=\frac{1}{2}$ verschobene Rechteckimpuls ist in Abbildung 6 dargestellt.
#### Aufgabe
Verändere den Wert $t_0$. Wie ändert sich die geplottete Funktion? Was passiert für negative Werte von $t_0$?
%% Cell type:code id: tags:
``` python
s = lambda t: rect(t-1/2)
# Plot
fig,ax = plt.subplots(1,1); ax.plot(t, s(t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.25,2.25]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Dehnung/Stauchung
Als nächstes wird die Dehnung eines Rechteckimpulses betrachet. Dies geschieht über den Faktor $T$. Die folgende Abbildung zeigt den mit $T=2$ gedehnten Rechteckimpuls $s(t) = \mathrm{rect}\left(\frac{t}{2}\right)$. Der normale Rechteckimpuls hat die Breite 1, der hier dargestellte erhält entsprechend die Breite $T*1=2$.
#### Aufgabe
Ändere den Wert für $T$. Was passiert mit der dargestellten Funktion? Was passiert für Werte von $|T| < 1$?
Ersetze den Rechteckimpuls durch einen Dreiecksimpuls $\Lambda(t) = \begin{cases}
1-|t|\quad\text{für}\ |t|\leq 1\\
0\quad\text{für}\ |t| > 1\text{ .}
\end{cases}$.
Ersetze hierfür rect durch tri. Wie breit wird die dargestellte Funktion für $T=2$?
%% Cell type:code id: tags:
``` python
s = lambda t: rect(t/2)
# Plot
fig,ax = plt.subplots(1,1); ax.plot(t, s(t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.25,2.25]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Zeitspiegelung
Zur Verdeutlichung der Zeitspiegelung wird das in der folgenden Abbildung dargestellte Signal $s(t) = t \cdot \mathrm{rect}\left(t-\frac{1}{2}\right)$ betrachtet.
%% Cell type:code id: tags:
``` python
s = lambda t: rect(t-0.5)*t
# Plot
fig,ax = plt.subplots(1,1); ax.plot(t, s(t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(t)$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.25,2.25]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
Betrachte nun $s(-t)$ in der folgenden Abbildung. Das negative Vorzeichen bewirkt eine Spiegelung des Signals an der y-Achse.
%% Cell type:code id: tags:
``` python
# Plot
fig,ax = plt.subplots(1,1); ax.plot(t, s(-t));
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s(-t)$', bbox=ient_wbbox)
ax.axis('equal'); ax.set_xlim([-2.25,2.25]); ient_grid(ax); ient_axis(ax);
```
%% Cell type:markdown id: tags:
### Demo: Zeitverschiebung, -dehnung und -spiegelung
Die Demo fasst nun alle diese Funktionen interaktiv zusammen. Das allgemeine Signal ist weiterhin
$\displaystyle s\left(\pm\frac{t-t_0}{T}\right)$.
Mit den Schiebereglern können unterschiedliche Werte für den Dehnungsfaktor $T$ und die Zeitverschiebung $t_0$ ausgewählt werden. Die Spiegelung kann über den entsprechenden Button ein- und ausgeschaltet werden.
%% Cell type:code id: tags:
``` python
s = lambda t: rect(t-0.5)*t
# Plot & demo
fig, ax = plt.subplots(1, 1, figsize=(8, 4))
@widgets.interact(T=widgets.FloatSlider(min=0.25, max=4, value=1, step=.1, description=r'Dehnung $T$', style=ient_wdgtl_style),
@widgets.interact(T=widgets.FloatSlider(min=-4, max=4, value=1, step=.1, description=r'Dehnung $T$', style=ient_wdgtl_style),
t0=widgets.FloatSlider(min=-2, max=2, value=0, step=.1, description=r'Verschiebung $t_0$', style=ient_wdgtl_style),
reflection=widgets.Checkbox(value=False, description='Spiegelung', style=ient_wdgtl_style))
def update_signals(T, t0, reflection):
if reflection:
T = -T
T = 0.1 if T==0 else T
T = -T if reflection else T
s_plot = s((t-t0)/T)
if not ax.lines: # plot s(t) and g(t)
ax.plot(t, s_plot, 'rwth');
ax.set_xlabel(r'$\rightarrow t$'); ax.set_ylabel(r'$\uparrow s\left(\pm\frac{t-t_0}{T}\right)$')
ax.axis('equal'); ax.set_xlim([-4.75, 4.75]); ient_axis(ax); ient_grid(ax); ax.minorticks_on()
else: # update lines
ax.lines[0].set_ydata(s_plot);
```
%% Cell type:markdown id: tags:
### Aufgaben
* Verändere den Wert für $t_0$. In welche Richtung bewegt sich das Signal?
* Verändere nun den Dehnungsfaktor $T$. Was passiert für $T<0$? Was passiert für Werte $T>0$?
* Setze die Werte zurück auf $T=1$ und $t_0=0$. Dies kann entweder über den Schieberegler oder durch erneutes Ausführen der Cell erfolgen.
* Aktiviere und deaktivere die Spiegelung und beobachte, was passiert.
* Verschiebe nun das Signal mit $t_0=1$. Aktiviere und deaktiviere die Spiegelung. Wie lässt sich dieses Verhalten erklären?
* Ändere nun $T$. Wie ändert sich das Signal? Aktiviere nun die Spiegelung. Was passiert nun bei einer Änderung von $T$?
* Teste abschließend verschiedene Kombinationen von $T$, $t_0$ und der Spiegelung und beobachte, welche Unterschiede die Reihenfolge der Ausführung der Operationen auf das Signal hat.
%% 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.
......
%% Cell type:code id: tags:
``` python
# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University
%matplotlib notebook
%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 *
```
%% Cell type:markdown id: tags:
<div>
<img src="ient_nb/figures/rwth_ient_logo@2x.png" style="float: right;height: 5em;">
</div>
# Demonstrator Faltung
Zum Starten: Im Menü: Cell <span class="fa-chevron-right fa"></span> Run All auswählen.
## Einleitung
Im Folgenden wird das Faltungsintegral
$$g(t)
= s(t)\ast h(t)
= \int\limits_{-\infty}^{\infty} s(\tau) h(t-\tau) \,\mathrm{d}\tau
$$
betrachtet.
%% Cell type:markdown id: tags:
## Demo
Wähle $s(t)$ und $h(t)$ sowie jeweils Verschiebung $t_0$ und Dehnungsfaktor $T$ für beide Signale: $s\left(\frac{t-t_0}{T}\right)$ und $h\left(\frac{t-t_0}{T}\right)$.
Zusätzlich zu Elementarsignalen kann auch eine frei definierbare Funktion $s_0(t)$ zur Faltung verwendet werden.