-[PySDR: A Guide to SDR and DSP using Python](https://pysdr.org) is a guide to software-defined radio (SDR) and RF signal processing using Python code examples, live at https://pysdr.org. It is a free online textbook that provides a gentle introduction to wireless communications and SDR using an abundance of diagrams, animations, and code examples. From FFTs to filters to digital modulation to receiving and transmitting from SDRs in Python, PySDR has you covered! This repo specifically contains the source content used to generate the textbook, including the body text and Python scripts to generate the figures. For questions/comments/suggestions feel free to submit an issue at the top of this page, or if you want to propose a change to the textbook (e.g. fix or improvement), you can use a Pull Request. Those who submit valuable feedback/fixes be permanently added to the acknowledgments section. Not good at Git but have changes to suggest? Feel free to email Marc at marc@pysdr.org.
+[PySDR: Ein Leitfaden zu SDR und DSP mit Python](https://pysdr.org) ist ein Leitfaden zur softwaredefinierten Funktechnik (SDR) und HF-Signalverarbeitung mit Python-Codebeispielen, verfügbar unter https://pysdr.org. Es handelt sich um ein kostenloses Online-Lehrbuch, das eine sanfte Einführung in drahtlose Kommunikation und SDR bietet – mit zahlreichen Diagrammen, Animationen und Codebeispielen. Von FFTs über Filter bis hin zu digitaler Modulation sowie dem Empfangen und Senden über SDRs in Python – PySDR hat alles abgedeckt! Dieses Repository enthält speziell den Quellinhalt zur Generierung des Lehrbuchs, einschließlich des Haupttexts und der Python-Skripte zur Erzeugung der Abbildungen. Bei Fragen, Anmerkungen oder Vorschlägen können Sie oben auf dieser Seite ein Issue einreichen. Wenn Sie eine Änderung am Lehrbuch vorschlagen möchten (z. B. eine Korrektur oder Verbesserung), können Sie einen Pull Request verwenden. Wer wertvolles Feedback oder Korrekturen einreicht, wird dauerhaft im Danksagungsabschnitt aufgeführt. Nicht vertraut mit Git, aber Änderungen vorschlagen? Schreiben Sie Marc gerne eine E-Mail an marc@pysdr.org.
-You can also support PySDR through the [PySDR Patreon page](https://www.patreon.com/c/PySDR) or a [one-time donation](https://www.paypal.com/donate/?hosted_button_id=FH3LQCJRUVPWL).
+Sie können PySDR auch über die [PySDR Patreon-Seite](https://www.patreon.com/c/PySDR) oder eine [Einmalspende](https://www.paypal.com/donate/?hosted_button_id=FH3LQCJRUVPWL) unterstützen.
-## Building
+## Erstellen
-Note that the website is now automatically built and deployed with each push/merge into master branch, using the GitHub action [build-and-deploy.yml](https://github.com/777arc/PySDR/blob/master/.github/workflows/build-and-deploy.yml) and the GitHub pages system for hosting the actual textbook.
+Die Website wird nun bei jedem Push/Merge in den Master-Branch automatisch erstellt und bereitgestellt, mithilfe der GitHub-Aktion [build-and-deploy.yml](https://github.com/777arc/PySDR/blob/master/.github/workflows/build-and-deploy.yml) und dem GitHub Pages-System zum Hosten des eigentlichen Lehrbuchs.
-For testing changes to the textbook locally, you can build using the following steps:
+Um Änderungen am Lehrbuch lokal zu testen, kann mit folgenden Schritten gebaut werden:
### Ubuntu/Debian
-Look at `.github/workflows/build-and-deploy.yml` and run the apt/pip installs, then:
+Schauen Sie sich `.github/workflows/build-and-deploy.yml` an und führen Sie die apt/pip-Installationen aus, dann:
```bash
make html
@@ -27,35 +27,36 @@ make html-zh
make html-ja
```
-In _build there should be an index.html that represents the main page of the English site
+In `_build` sollte eine `index.html` vorhanden sein, die die Hauptseite der englischen Website darstellt.
-Note: on one machine I had to add `~/.local/bin` to PATH
+Hinweis: Auf einem Rechner musste ich `~/.local/bin` zum PATH hinzufügen.
### Windows
-Install pre-requisite software with:
+Installieren Sie die erforderliche Software wie folgt:
-1. From the Microsoft Store install Python 3.10 (3.8-3.12 is fine too if you already have it installed).
-1. In a PowerShell terminal (click start menu then type powershell, or open a terminal in VSCode) run `pip install sphinx sphinxcontrib-tikz patreon setuptools`
-1. `cd` to the directory you cloned PySDR
+1. Installieren Sie Python 3.10 aus dem Microsoft Store (3.8–3.12 ist ebenfalls in Ordnung, falls bereits installiert).
+1. Führen Sie in einem PowerShell-Terminal (Startmenü öffnen, dann „powershell" eingeben, oder ein Terminal in VSCode öffnen) den Befehl `pip install sphinx sphinxcontrib-tikz patreon setuptools` aus.
+1. Wechseln Sie mit `cd` in das Verzeichnis, in das Sie PySDR geklont haben.
-Build the English version only using:
+Erstellen Sie nur die englische Version mit:
```
python -m sphinx.cmd.build -b html . _build
```
-The first time running this it might take a while because it has to download LaTeX packages.
+Beim ersten Ausführen kann dies etwas länger dauern, da LaTeX-Pakete heruntergeladen werden müssen.
+
+Testen Sie den JavaScript-Teil mit folgendem Befehl, um CORS-Fehler zu vermeiden:
-Test the javascript part with the following to avoid CORS errors:
```
cd _build
python -m http.server
```
-## Creating a PDF Export
+## PDF-Export erstellen
-Not fully working yet due to animated gifs, they all need to be removed for this to not error out:
+Noch nicht vollständig funktionsfähig aufgrund animierter GIFs – diese müssen alle entfernt werden, damit kein Fehler auftritt:
```
sudo apt-get install -y latexmk
@@ -63,15 +64,15 @@ sphinx-build -b latex . _build/latex
make latexpdf
```
-## Misc
+## Sonstiges
-Ideas for future chapters:
+Ideen für zukünftige Kapitel:
-* Equalization, would be the last step needed to finish the end-to-end communications link
-* OFDM, simulating OFDM and CP, show via Python how it turns freq selective fading into flat fading
-* How to create real-time SDR apps with GUIs in Python using pyqt and pyqtgraph, or even just matplotlib with updating
-* Python code that lets the Pluto (or RTL-SDR) act as an FM receiver, like with sound output
-* End-to-end example that shows how to detect start of packet and other concepts not covered in RDS chapter
-* Intro to radar
+* Entzerrung – wäre der letzte fehlende Schritt zum Abschluss der Ende-zu-Ende-Kommunikationsstrecke
+* OFDM – Simulation von OFDM und CP, Darstellung per Python, wie frequenzselektives Fading in flaches Fading umgewandelt wird
+* Erstellung von Echtzeit-SDR-Anwendungen mit GUIs in Python mithilfe von pyqt und pyqtgraph oder sogar mit aktualisierendem matplotlib
+* Python-Code, der den Pluto (oder RTL-SDR) als UKW-Empfänger mit Audioausgabe betreibt
+* End-to-End-Beispiel, das zeigt, wie der Paketanfang erkannt wird und andere Konzepte, die im RDS-Kapitel nicht behandelt werden
+* Einführung in Radar
-+ von + + Dr. Marc Lichtman + + - + + pysdr@vt.edu + +
+ +
English
- 
Dutch
+ Dutch
French
Ukrainian
Chinese
Spanish
- 
Japanese
+ Japanese
+ 
German
+
{% endblock %}
diff --git a/conf.py b/conf.py
index 9b2ba809..2a29f4b6 100644
--- a/conf.py
+++ b/conf.py
@@ -70,7 +70,7 @@
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
-exclude_patterns = ['_build', 'index-fr.rst', 'content-fr/*', 'index-nl.rst', 'content-nl/*', 'index-ukraine.rst', 'content-ukraine/*', 'index-zh.rst', 'content-zh/*', 'index-es.rst', 'content-es/*', 'index-ja.rst', 'content-ja/*']
+exclude_patterns = ['_build', 'venv', 'venv/**', 'index-de.rst', 'content-de/*', 'index-fr.rst', 'content-fr/*', 'index-nl.rst', 'content-nl/*', 'index-ukraine.rst', 'content-ukraine/*', 'index-zh.rst', 'content-zh/*', 'index-es.rst', 'content-es/*', 'index-ja.rst', 'content-ja/*']
# The reST default role (used for this markup: `text`) to use for all
# documents.
diff --git a/content-de/2d_beamforming.rst b/content-de/2d_beamforming.rst
new file mode 100644
index 00000000..aaceac3a
--- /dev/null
+++ b/content-de/2d_beamforming.rst
@@ -0,0 +1,564 @@
+.. _2d-beamforming-chapter:
+
+####################
+2D-Beamforming
+####################
+
+Dieses Kapitel erweitert das 1D-Beamforming/DOA-Kapitel auf 2D-Arrays. Wir beginnen mit einem einfachen Rechteck-Array und entwickeln die Steuervektorgleichung und den MVDR-Beamformer, dann arbeiten wir mit echten Daten von einem 3×5-Array. Abschließend verwenden wir das interaktive Werkzeug, um die Auswirkungen verschiedener Array-Geometrien und Elementabstände zu erkunden.
+
+*************************************
+Rechteck-Arrays und 2D-Beamforming
+*************************************
+
+Rechteck-Arrays (a.k.a. planare Arrays) bestehen aus einem 2D-Array von Elementen. Mit einer zusätzlichen Dimension erhalten wir etwas mehr Komplexität, aber dieselben Grundprinzipien gelten, und der schwierigste Teil ist die Visualisierung der Ergebnisse (z.B. keine einfachen Polarplots mehr, jetzt brauchen wir 3D-Oberflächenplots). Obwohl unser Array jetzt 2D ist, müssen wir nicht jede Datenstruktur um eine Dimension erweitern. Zum Beispiel behalten wir unsere Gewichte als 1D-Array komplexer Zahlen bei. Wir müssen jedoch die Positionen unserer Elemente in 2D darstellen. Wir verwenden weiterhin :code:`theta` für den Azimutwinkel, aber jetzt führen wir einen neuen Winkel :code:`phi` als Elevationswinkel ein. Es gibt viele sphärische Koordinatenkonventionen, aber wir verwenden folgende:
+
+.. image:: ../_images/Spherical_Coordinates.svg
+ :align: center
+ :target: ../_images/Spherical_Coordinates.svg
+ :alt: Sphärisches Koordinatensystem mit theta und phi
+
+Was entspricht:
+
+.. math::
+
+ x = \sin(\theta) \cos(\phi)
+
+ y = \cos(\theta) \cos(\phi)
+
+ z = \sin(\phi)
+
+Wir wechseln auch zu einer verallgemeinerten Steuervektorgleichung, die nicht spezifisch für eine Array-Geometrie ist:
+
+.. math::
+
+ s = e^{2j \pi \boldsymbol{p} u / \lambda}
+
+wobei :math:`\boldsymbol{p}` die Menge der x/y/z-Elementpositionen in Metern ist (Größe :code:`Nr` x 3) und :math:`u` der Richtungseinheitsvektor in x/y/z ist (Größe 3x1). In Python sieht das so aus:
+
+.. code-block:: python
+
+ def steering_vector(pos, dir):
+ # Nrx3 3x1
+ return np.exp(2j * np.pi * pos @ dir / wavelength) # gibt Nr x 1 aus (Spaltenvektor)
+
+Versuchen wir, diese verallgemeinerte Steuervektorgleichung mit einem einfachen ULA mit 4 Elementen zu verwenden, um die Verbindung zu dem herzustellen, was wir bisher gelernt haben. Wir stellen :code:`d` jetzt in Metern statt relativ zur Wellenlänge dar. Wir platzieren die Elemente entlang der y-Achse:
+
+.. code-block:: python
+
+ Nr = 4
+ fc = 5e9
+ wavelength = 3e8 / fc
+ d = 0.5 * wavelength # in Metern
+
+ # Elementpositionen als Liste von (x,y,z)-Koordinaten, auch wenn es nur ein ULA entlang der y-Achse ist
+ pos = np.zeros((Nr, 3)) # Elementpositionen als Liste von x,y,z-Koordinaten in Metern
+ for i in range(Nr):
+ pos[i,0] = 0 # x-Position
+ pos[i,1] = d * i # y-Position
+ pos[i,2] = 0 # z-Position
+
+Die folgende Grafik zeigt eine Draufsicht des ULA mit einem Beispiel-Theta von 20 Grad.
+
+.. image:: ../_images/2d_beamforming_ula.svg
+ :align: center
+ :target: ../_images/2d_beamforming_ula.svg
+ :alt: ULA mit Theta von 20 Grad
+
+Das Einzige, was noch fehlt, ist die Verbindung unseres alten :code:`theta` mit diesem neuen Einheitsvektoransatz. Wir können :code:`dir` basierend auf :code:`theta` leicht berechnen. Wir wissen, dass die x- und z-Komponente unseres Einheitsvektors 0 sein wird, da wir uns noch im 1D-Raum befinden, und basierend auf unserer sphärischen Koordinatenkonvention ist die y-Komponente :code:`np.cos(theta)`, also lautet der vollständige Code :code:`dir = np.asmatrix([0, np.cos(theta_i), 0]).T`. An diesem Punkt solltest du die Verbindung zwischen unserer verallgemeinerten Steuervektorgleichung und der ULA-Steuervektorgleichung herstellen können. Probiere diesen neuen Code aus, wähle ein :code:`theta` zwischen 0 und 360 Grad (vergiss die Umrechnung in Bogenmaß!), und der Steuervektor sollte ein 4x1-Array sein.
+
+Gehen wir jetzt zum 2D-Fall über. Wir platzieren unser Array in der X-Z-Ebene, mit Boresight horizontal in Richtung der positiven y-Achse zeigend (:math:`\theta = 0`, :math:`\phi = 0`). Wir verwenden denselben Elementabstand wie zuvor, haben jetzt aber insgesamt 16 Elemente:
+
+.. code-block:: python
+
+ # Jetzt auf 2D umsteigen, mit einem 4x4-Array mit halbem Wellenlängenabstand, also 16 Elemente insgesamt
+ Nr = 16
+
+ # Elementpositionen als Liste von x,y,z-Koordinaten in Metern, Array in der X-Z-Ebene
+ pos = np.zeros((Nr,3))
+ for i in range(Nr):
+ pos[i,0] = d * (i % 4) # x-Position
+ pos[i,1] = 0 # y-Position
+ pos[i,2] = d * (i // 4) # z-Position
+
+Die Draufsicht unseres rechteckigen 4×4-Arrays:
+
+.. image:: ../_images/2d_beamforming_element_pos.svg
+ :align: center
+ :target: ../_images/2d_beamforming_element_pos.svg
+ :alt: Rechteckige Array-Elementpositionen
+
+Um auf ein bestimmtes Theta und Phi zu zeigen, müssen wir diese Winkel in einen Einheitsvektor umrechnen. Wir können dieselbe verallgemeinerte Steuervektorgleichung wie zuvor verwenden, müssen aber jetzt den Einheitsvektor basierend auf Theta und Phi berechnen, mithilfe der Gleichungen am Anfang dieses Kapitels:
+
+.. code-block:: python
+
+ # In eine beliebige Richtung zeigen
+ theta = np.deg2rad(60) # Azimutwinkel
+ phi = np.deg2rad(30) # Elevationswinkel
+
+ # Mit unserer sphärischen Koordinatenkonvention den Einheitsvektor berechnen:
+ def get_unit_vector(theta, phi): # Winkel in Bogenmaß
+ return np.asmatrix([np.sin(theta) * np.cos(phi), # x-Komponente
+ np.cos(theta) * np.cos(phi), # y-Komponente
+ np.sin(phi)]).T # z-Komponente
+
+ dir = get_unit_vector(theta, phi)
+ # dir ist 3x1
+ # [[0.75 ]
+ # [0.4330127]
+ # [0.5 ]]
+
+Jetzt verwenden wir unsere verallgemeinerte Steuervektorfunktion, um den Steuervektor zu berechnen:
+
+.. code-block:: python
+
+ s = steering_vector(pos, dir)
+
+ # Konventionellen Beamformer verwenden (Gewichte gleich dem Steuervektor), Strahlmuster plotten
+ w = s # 16x1 Gewichtsvektor
+
+An dieser Stelle ist es erwähnenswert, dass wir beim Übergang von 1D zu 2D die Dimensionen von nichts geändert haben – wir haben nur nicht-null x/y/z-Komponenten, die Steuervektorgleichung ist dieselbe und die Gewichte sind immer noch ein 1D-Array. Es mag verlockend sein, die Gewichte als 2D-Array zusammenzustellen, damit sie visuell der Array-Geometrie entsprechen, aber das ist nicht notwendig und am besten als 1D zu belassen. Für jedes Element gibt es ein entsprechendes Gewicht, und die Liste der Gewichte ist in derselben Reihenfolge wie die Liste der Elementpositionen.
+
+Das Strahlmuster dieser Gewichte zu visualisieren ist etwas komplizierter, da wir einen 3D-Plot oder eine 2D-Heatmap benötigen. Wir scannen :code:`theta` und :code:`phi`, um ein 2D-Array von Leistungspegeln zu erhalten, und plotten das dann mit :code:`imshow()`. Der folgende Code macht genau das, und das Ergebnis wird in der Abbildung unten gezeigt, zusammen mit einem Punkt an dem zuvor eingegebenen Winkel:
+
+.. code-block:: python
+
+ resolution = 100 # Anzahl der Punkte in jeder Richtung
+ theta_scan = np.linspace(-np.pi/2, np.pi/2, resolution) # Azimutwinkel
+ phi_scan = np.linspace(-np.pi/4, np.pi/4, resolution) # Elevationswinkel
+ results = np.zeros((resolution, resolution)) # 2D-Array zum Speichern der Ergebnisse
+ for i, theta_i in enumerate(theta_scan):
+ for j, phi_i in enumerate(phi_scan):
+ a = steering_vector(pos, get_unit_vector(theta_i, phi_i)) # Arrayfaktor
+ results[i, j] = np.abs(w.conj().T @ a)[0,0] # Leistung im Signal, linear sieht besser aus
+ plt.imshow(results.T, extent=(theta_scan[0]*180/np.pi, theta_scan[-1]*180/np.pi, phi_scan[0]*180/np.pi, phi_scan[-1]*180/np.pi), origin='lower', aspect='auto', cmap='viridis')
+ plt.colorbar(label='Leistung [linear]')
+ plt.scatter(theta*180/np.pi, phi*180/np.pi, color='red', s=50) # Punkt an richtigem Theta/Phi hinzufügen
+ plt.xlabel('Azimutwinkel [Grad]')
+ plt.ylabel('Elevationswinkel [Grad]')
+ plt.show()
+
+.. image:: ../_images/2d_beamforming_2dplot.svg
+ :align: center
+ :target: ../_images/2d_beamforming_2dplot.svg
+ :alt: 3D-Plot des Strahlmusters
+
+Simulieren wir jetzt einige echte Abtastwerte; wir fügen zwei Ton-Jammer hinzu, die aus verschiedenen Richtungen ankommen:
+
+.. code-block:: python
+
+ N = 10000 # Anzahl der zu simulierenden Abtastwerte
+
+ jammer1_theta = np.deg2rad(-30)
+ jammer1_phi = np.deg2rad(10)
+ jammer1_dir = get_unit_vector(jammer1_theta, jammer1_phi)
+ jammer1_s = steering_vector(pos, jammer1_dir) # Nr x 1
+ jammer1_tone = np.exp(2j*np.pi*0.1*np.arange(N)).reshape(1,-1) # als Zeilenvektor
+
+ jammer2_theta = np.deg2rad(10)
+ jammer2_phi = np.deg2rad(50)
+ jammer2_dir = get_unit_vector(jammer2_theta, jammer2_phi)
+ jammer2_s = steering_vector(pos, jammer2_dir)
+ jammer2_tone = np.exp(2j*np.pi*0.2*np.arange(N)).reshape(1,-1) # als Zeilenvektor
+
+ noise = np.random.normal(0, 1, (Nr, N)) + 1j * np.random.normal(0, 1, (Nr, N)) # komplexes Gaußsches Rauschen
+ r = jammer1_s @ jammer1_tone + jammer2_s @ jammer2_tone + noise # erzeugt 16 x 10000 Matrix
+
+Spaßeshalber berechnen wir die MVDR-Beamformer-Gewichte in Richtung des zuvor verwendeten Theta und Phi (ein Einheitsvektor in diese Richtung ist noch als :code:`dir` gespeichert):
+
+.. code-block:: python
+
+ s = steering_vector(pos, dir) # 16 x 1
+ R = np.cov(r) # Kovarianzmatrix, 16 x 16
+ Rinv = np.linalg.pinv(R)
+ w = (Rinv @ s)/(s.conj().T @ Rinv @ s) # MVDR/Capon-Gleichung
+
+Anstatt das Strahlmuster im wenig übersichtlichen 3D-Plot anzusehen, verwenden wir eine alternative Methode, um zu prüfen, ob diese Gewichte sinnvoll sind: Wir bewerten die Antwort der Gewichte in verschiedene Richtungen und berechnen die Leistung in dB. Beginnen wir mit der Richtung, in die wir zeigen:
+
+.. code-block:: python
+
+ # Leistung in der Richtung, in die wir zeigen (theta=60, phi=30, noch als dir gespeichert):
+ a = steering_vector(pos, dir) # Arrayfaktor
+ resp = w.conj().T @ a # Skalar
+ print("Leistung in Zeige-Richtung:", 10*np.log10(np.abs(resp)[0,0]), 'dB')
+
+Dies gibt 0 dB aus, was wir erwarten, da MVDRs Ziel ist, in der gewünschten Richtung Einheitsleistung zu erzielen. Jetzt prüfen wir die Leistung in Richtung der zwei Jammer sowie in einer zufälligen Richtung und einer Richtung, die einen Grad von unserer gewünschten Richtung abweicht (derselbe Code, nur :code:`dir` aktualisieren). Die Ergebnisse sind in der folgenden Tabelle dargestellt:
+
+.. list-table::
+ :widths: 70 30
+ :header-rows: 1
+
+ * - Zeige-Richtung
+ - Gewinn
+ * - :code:`dir` (für MVDR-Gewichtsberechnung verwendete Richtung)
+ - 0 dB
+ * - Jammer 1
+ - -17,488 dB
+ * - Jammer 2
+ - -18,551 dB
+ * - 1 Grad weg von :code:`dir` in :math:`\theta` und :math:`\phi`
+ - -0,00683 dB
+ * - Eine zufällige Richtung
+ - -10,591 dB
+
+Deine Ergebnisse können aufgrund des zufälligen Rauschens variieren. Die wichtigste Erkenntnis ist: die Jammer befinden sich in einem Null und haben sehr niedrige Leistung, die 1-Grad-Abweichung von :code:`dir` liegt leicht unter 0 dB, befindet sich aber noch in der Hauptkeule, und eine zufällige Richtung liegt unter 0 dB, aber über den Jammern. Beachte, dass du mit MVDR einen Gewinn von 0 dB für die Hauptkeule erhältst, aber mit dem konventionellen Beamformer würdest du :math:`10 \log_{10}(Nr)` erhalten, also etwa 12 dB für unser 16-Element-Array – das zeigt einen der Kompromisse von MVDR.
+
+Den Code für diesen Abschnitt findest du `hier