Im Sinne einer Projektarbeit galt es ein SDR (Software Defined Radio) in Betrieb zu nehmen. Die Aufgabe bestand im wesentlichen darin ein geeignetes SDR für die Einsatzgebiete der Hochschule zu finden, in Betrieb zu nehmen und zu testen. Ein persönliches Ziel der Arbeit war es ein Dokument zu schaffen welches als Leitfaden für die Verwendung von SDRs fungiert. Aus den oben genannten Gründen werden die verschiedenen Einsatzgebiete eines SDRs kurz beleuchtet, die Funktionsweise sowie das I/Q Verfahren beschrieben bevor es zur Inbetriebnahme durch das GNU Radio Framework kommt.

1. Projektarbeit
SDR - Software Defined Radio
Christoph Leberer
9. März 2018
Fakultät Elektrotechnik und Informatik
Hochschule Ravensburg-Weingarten

2. Inhaltsverzeichnis
1 Einleitung 3
2 Das SDR 4
2.1 SDR allgemein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 SDR Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 I&Q-Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Quadraturamplitudenmodulation . . . . . . . . . . . . . . . . . . . . . . 7
3 USRP B210 11
3.1 Features des USRP B210 . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4 Installation UHD Treiber 12
4.1 System Tools & Abhängigkeiten . . . . . . . . . . . . . . . . . . . . . . . 13
4.2 Build UHD Treier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5 Installation GNU Radio 17
6 GNU Radio 18
6.1 GNU Radio Benutzeroberfläche . . . . . . . . . . . . . . . . . . . . . . . 18
6.2 Code Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
7 Ausblick 27
7.1 Messaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.2 Schrittmotor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3. 1 Einleitung
Im Sinne einer Projektarbeit galt es ein SDR (SoftwareDefinedRadio) in Betrieb zu
nehmen. Die Aufgabe bestand im wesentlichen darin ein geeignetes SDR für die Einsatz-
gebiete der Hochschule zu finden, in Betrieb zu nehmen und zu testen. Ein persönliches
Ziel der Arbeit war es ein Dokument zu schaffen welches als Leitfaden für die Verwendung
von SDRs fungiert. Die Wahl fiel auf ein USRP210 der Firma Ettus Research eine Tochter
Firma von National Instruments (NI).
Ettus Research ist der führende Lieferant von Software Defined Radio Plattformen ein-
schließlich der Universal Software Radio Peripheral (USRPTM
) Produkten. Die Produk-
te der USRP Familie sind entworfen für RF Anwendungen von DC bis 6 GHz, ein-
schließlich der Nutzung mehrerer Sende- und Empfangsantennen (MIMO) Systemen.
Beispielanwendungen sind:
• Mobilfunk
• WLAN
• Spektrum Analysen
• Funknetzwerke
• CR Systemen
• Satellitennavigation
• Amateurfunk
Dank des großen Umfang des USRP Hardware Treibers (UHD) ist es möglich auf eine
Vielfalt von Anwendungen, Open-Source Projekte und grafischem System Design zurück-
zugreifen. Die große Beliebtheit des USRP hat eine große Community geschaffen, welche
stetig neue Entwicklungen hervorbringt. Dies ist unter anderem auf eine ausführliche und
gute Dokumentation zurückzuführen.
Die Open-Source GNU Radio Software Repositories helfen dabei mit hunderten von
anderen aktiven Mitgliedern Unterstützung zu erhalten und die Code-Basis wachsen zu
lassen. Durch diese Open-Source Community wird GNU Radio ständig weiter entwickelt
und beinhaltet immer mehr RF sowie Kommunikations-System-Design Anwendungen.
Des weiteren ist es möglich andere Softwareoptionen zu nutzen. Es kann auch durch
ein grafisches Systemdesign wie LabView programmiert werden. Dadurch ist eine Pro-
totypen Entwicklung von kabellosen Systemen schneller und kann signifikant Entwick-
lungszeit einsparen. Allerdings wird in dieser Arbeit nur auf die GNU Radio Software
eingegangen.
3

4. 2 Das SDR
2.1 SDR allgemein
Unter einem Software Defined Radio (SDR) werden Konzepte für einen hochfrequenten
Sender und Empfänger zusammen gefasst, bei welchem verschiedene Anteile der Signal-
verarbeitung in Software realisiert werden. Mittels digitaler Signalverarbeitung werden
die Selektion, Modulation und Demodulation von Signalen realisiert. So ist es nicht
unüblich, dass bei einem SDR-System der Großteil der Signalverarbeitung von Univer-
salrechnern durchgeführt wird. Kleine Bandbreiten von wenigen 10MHz lassen sich noch
mit „einfachen“ PCs verwirklichen (z.B.: Soundkarte oder GPIO-Pins). Bei großen Band-
breiten und komplexeren Verarbeitungsalgorithmen werden kombinierte Systeme einge-
setzt bei denen Signalprozessoren oder FPGAs (Field Programmable Gate Array)die
Berechnungen durchführen. Die wesentliche Eigenschaft eines SDR ist, dass sich die un-
terschiedlichen Parameter des Funksystems über eine Änderung der Software realisieren
lassen. Aus diesem Grund werden immer mehr digitale Rundfunkempfänger/Sender auf
der Basis eines SDR realisiert. Ein Protokollwechsel kann in Echtzeit implementiert wer-
den. Basisstationen zellularer Netze als SDR realisiert, können innerhalb kurzer Zeit auf
einen neuen Standard aufgerüstet werden.
Ein SDR besteht mindestens aus einem Empfangs-/Sendemodul, A/D- und D/A-Wandler
und der softwarebasierten Signalverarbeitung. Die Analogkomponente kann als Gerade-
ausempfänger oder als ein Überlagerungsempfänger (Superhet) realisiert sein. Die kom-
plexe Signalverarbeitung besteht aus einem Signalpfad welcher sich aus einem Paar von
zwei parallel geführten reellen Zahlenfolgen zusammensetzt. Dieses wird auch als I/Q-
Signal bezeichnet.
2.2 SDR Funktionsweise
Direkte Digitalisierung:
Die einfachste Art eines SDR würde aus einer Antenne und einem ADC bestehen, des-
sen Daten direkt nach der Wandlung durch einen Rechner verarbeitet werden. Sende
Seitig wäre nach dem Rechner ein DAC mit Antenne realisiert. Diese direkte Digita-
lisierung des Eingangssignales könnte mit einem ADC12J4000 von Texas Instruments
realisiert werden. Mit einer maximalen Sampling Rate von 4000 MSPS wären nach dem
Nyquist-Theorem 2000MHz Eingangssignal möglich. Bei einer FPWB (Full-Power Band-
width) von 3.2GHz sollten jedoch nur 1600MHz realisiert werden. Vor dem ADC ist ein
dementsprechend dimensionierter Tiefpass (Antialiasing-Filer) so wie ein Verstärkungs-
oder Dämpfungsglied zu schalten. Es wird in diesem Dokument nicht weiter auf die AD-
Wandlung eingegangen, da dies nicht das eigentliche Thema ist.
Direktmischer-Konzept
Bei diesem Konzept, wird die Eingangsfrequnez (welches die Information enthält ) fe mit
einer Oszillatorfrequenz FOsz welche gleich der Trägerfrequenz ist gemischt und so demo-
4

5. duliert/moduliert. Dies ist möglich da bei einem idealen Mischer gilt fDif = |fOsz − fe|
und fSum = |fOsz + fe|, somit entstehen zwei neue Seitenbänder welche die Signale ent-
halten. Durch Filterung (Bandpass) kann nun das gewünschte Seitenband durchgelassen
und übertragen/empfangen werden. Ein Problem hierbei ist, dass bei dem Mischen ei-
ne zweite Frequenz entsteht und zu Empfangsstörungen führen kann. Diese sogenannte
Spiegelfrequenz fSP hat den doppelten Abstand der Zwischenfrequenz fZF zur Emp-
fangsfrequenz fE. Es gilt fSP = fE ±2fZF bzw. fSP = fLO ±fZF . Dies geschieht weil das
Signal der Zwischenfrequenz ebenfalls auf FZF herabgesetzt wird. In diesem Fall arbei-
tet der Mischer in Gleich- und Kehrlage gleichzeitig. Das SP-Signal wird normalerweise
in mehreren Vorkreisen soweit gedämpft, das es keine Störungen auf der Empfangsseite
verursacht. Jedoch kann es bei starken Sendern vorkommen. Die Vorselektion des Signals
wird umso schwieriger je niedriger die Zwischenfrequenz fZF ist, da die Empfangs- und
Spiegelfrequenz dann sehr nahe beieinander liegen (2fZF ). Da die Vorselektion kompli-
ziert ist und der Aufwand für die abstimmbaren Kreise hoch ist, möchte man dies stets
gering halten (Kostenaufwand reduzieren).
fDif = |fOsz − fe| (2.1)
fSum = |fOsz + fe| (2.2)
fSP = fE ± 2fZF (2.3)
fSP = fLO ± fZF (2.4)
Abbildung 1: Darstellung im Frequenzbereich
Das Problem der fehlenden Spiegelfrequenzunterdrückung löst ein SDR mittels „kom-
plexer“ Signalverarbeitung. Das heißt durch rechnen mit Real- und Imaginäranteil, wel-
ches auch als I/Q-Signal bezeichnet wird. Hierbei steht das I für In Phase und den
5

6. Realanteil. Das Q steht für Quadrature und für den imaginären Anteil des Signals. Um
dies zuerreichen werden im Eingangsbereich des Direktmischer-Empfänger zwei parallele
Mischstufen, deren Oszillationsignale um 90◦
phaseverschoben sind genutzt. In der Digi-
taltechnik lassen sich solche Oszilationssignale relativ einfach generieren und verarbeiten.
D.h. die beiden Ausgangssignale der jeweiligen Mischer werden parallel digitalisiert und
verarbeitet. Die Phasendrehung wird mittels der Hilbert-Transformation erreicht, sie be-
wirkt eine frequenzabhängige Verzögerung ohne die Amplitude dabei zu beeinflussen. So
wird z.B. ein 1-kHz-Signal um 250s verzögert. Es stehen zwei Direktüberlagerungssi-
gnale mit 0◦
und 90◦
Phasenverschiebung zuverfügung. Das Umschalten zwischen den
zwei Seitenbändern erfolgt nun durch Addition und Subtraktion der beiden Signale.
Dank dem geringen Elektronikaufwand hat sich das Direktmischer-Konzept mit I&Q-
Verfahren sehr weit verbreitet. Beispiele hier für wären der Transceiver in einem Handy
oder DVB-T Sticks welche auch auf dem SDR-Direktmischerkonzept basieren.
2.3 I&Q-Verfahren
Das In-Phase&Quadrature-Verfahren kurz I&Q-Verfahren ermöglicht es aus einer Demo-
dulation eines meist hochfrequenten Trägersignals die Phaseninformation zu erhalten.
Abbildung 2: I&Q-Verfahren
Wie in der Grafik zuerkennen ist wird das Signal in zwei Wege aufgeteilt. Auf dem ersten
Weg wird der Realteil in der originalen Phasenlage durchgelassen und die I-Daten ermit-
telt. Beim zweiten Weg wird die Referenzfrequenz um 90◦
phasenverschoben und enthält
die Q-Daten. Über Winkelfunktionen lassen sich nun die größen der Einzelkomponenten
I und Q berechnen.
I = A · cos(Φ) (2.5)
6

7. Q = A · sin(Φ) (2.6)
Die Rückberechnung der Signalamplitude A und des Phasenwinkel φ kann wie folgt vor-
genommen werden:
φ = arctan(
Q
I
) (2.7)
A = I2 + Q2 (2.8)
Dies ist möglich da die beiden Amplituden der jeweiligen Signale (I&Q) im Ursprung
Rechtwinklig zueinander stehen. Somit lässt sich nach (2.8) die absolute Größe des Si-
gnals berechnen. Da für eine Echtzeitanwendung eine Wurzelberechnung unpraktisch ist
wird meist mit einer Näherung gearbeitet, um interne Laufzeiten durch Rechenschritte
gleich zuhalten. Somit ergibt sich die Länge der Hypotenuse c aus der Länge der Kathete
a plus der halben Länge der kürzeren Kathete b.
Abbildung 3: Näherungsverfahren
Mit folgender Gleichung:
c ≈ a +
b
2
(2.9)
Es entsteht hierbei ein maximaler Fehler bei 26◦
von 12%. Eine viel exaktere Berechnung
liefert jedoch der CORDIC-Algorithmus welcher ebenfalls für Echtzeitanwendungen in
Frage kommt und in der digitalen Signalverarbeitung so wie in Mobilfunk Anwendungen
eingesetzt wird.
2.4 Quadraturamplitudenmodulation
Quadraturamplitudenmodulation (QAM) ist ein Modulationsverfahren das auf dem I&Q-
Verfahren beruht und mehr als nur zwei Zustände (AN/AUS) von Bits zu mehreren Zu-
ständen zusammenfasst. Es eignet sich besonders gut für hohe Übertragungsdichten. Bei
der QAM werden die Amplitudenmodulation sowie die Phasenmodulation miteinander
7

8. kombiniert und liefern so eine höhere Effektivität wie zum Beispiel die Amplituden-
modulation. Die Bits werden jeweils zu einem 4-, 16-, 32-, oder höherstufiges Symbol
zusammen gefasst. Somit gibt es 4QAM, 16QAM, 32QAM oder höher. Die Zahl vor-
ne gibt jeweils die größtmögliche Anzahl der Zustände an, jedoch sollte klar sein, je
mehr Zustände, desto störanfälliger wird das modulierte Signal. Die QAM wird im I&Q-
Modulator umgesetzt. Ein QAM-Signal erhält man, wenn man die zwei Trägersignale
I&Q zusammen addiert.
Abbildung 4: Quadraturamplitudenmodulation
Das oben stehende Sendesignal s(t) wird durch folgende Beziehung aus dem Basisband-
signal I(t) und dem Quadratursignal Q(t) im Modulator gebildet.
s(t) = I(t) · cos(ωt) − Q(t) · sin(ωt) (2.10)
= I(t) · cos(ωt) + Q(t) · cos(
π
2
+ ωt) (2.11)
Zur Demodulation wird eine zum Sender identische Phasenlage vorausgesetzt. Ist das
Empfangene Signal r(t) Störungsfrei, ist es gleich dem Sendesignal s(t). Sollte kein stö-
rungsfreier Übertragungskanal vorliegen kommt ein Fehleranteil e(t) zu dem Empfangs-
signal dazu:
r(t) = s(t) + e(t) (2.12)
Im fehlerfreien Fall gilt e(t) = 0 und für die Basisbandgewinnung Ir:
Ir(t) = s(t) · cos(ωt) (2.13)
8

9. Setzt man nun in (2.13) für s(t) (2.10) ein, erhält man:
Ir(t) = I(t)cos(ωt) · cos(ωt) − Q(t)sin(ωt) · cos(ωt) (2.14)
=
1
2
I(t)[1 + cos(2ωt)] −
1
2
Q(t)[sin(2ωt)] (2.15)
Durch Ausmultiplizieren ergibt sich:
Ir(t) =
1
2
I(t) +
1
2
[I(t)cos(2ωt) − Q(t)sin(2ωt)] (2.16)
Wie nach (2.16) zuerkennen entsteht hierbei aus dem Ir(t) Signal das Basisbandsignal
I(t) und zusätzliche Mischprodukte 1
2
[I(t)cos(2ωt) − Q(t)sin(2ωt)] mit der doppelten
Frequenz. Analog dazu verhält sich die Bildung von Qr(t):
Qr(t) = s(t) · (−sin(ωt)) (2.17)
= −I(t)cos(ωt) · sin(ωt) + Q(t)sin(ωt) · sin(ωt) (2.18)
= −
1
2
I(t)[sin(2ωt)] +
1
2
Q(t)[1 − cos(2ωt)] (2.19)
=
1
2
Q(t) −
1
2
[I(t)sin(2ωt) + Q(t)cos(2ωt)] (2.20)
Auch hier entsteht ein Mischprodukt 1
2
[I(t)sin(2ωt) + Q(t)cos(2ωt)]. Dies sind uner-
wünschte Frequenzanteile, welche durch einen nachfolgenden Tiefpassfilter (TP) elimi-
niert werden können. Somit stehen am Ausgang des jeweiligen TP die gewünschten
Signale I(t) und Q(t) wieder zu Verfügung. Der konstante Faktor von 1
2
kann durch
einen Verstärker kompensiert werden.
Abbildung 5: Tiefpassfilter
Das gesendete Signal wurde vollständig auf der Empfangsseite wiederhergestellt und
übertragen. Werden wert- und zeitdiskrete Signale übertragen, spricht man von einer
9

10. quantisierten QAM (Digitalsignal). Da die I&Q-Signale senkrecht aufeinander stehen,
lassen sich die Symbole in der komplexen Ebene in Form eines Konstelltionsdiagramms
darstellen.
Abbildung 6: Konstelltionsdiagramm
Durch dieses Verfahren lassen sich die jeweiligen Daten-Symbole Hier:(0001) über den
Winkel φ und die Länge der Amplitude A bestimmen. Sollten die Phasenlagen des Emp-
fängers und des Senders nicht genau abgestimmt sein, kommt es zu Empfangsfehlern, da
sich das Konstellationsdiagramm in der komplexen Ebene dreht. Im nachfolgenden sind
zwei Matlab-Simulationen mit Rauschanteilen dargestellt.
10

11. (a) 4QAM mit SNR = 10 (b) 16QAM mit SNR = 10
3 USRP B210
Das USRP B210 umfasst einen RF Frequenzbereich von 70MHz bis zu 6GHz. Es besteht
aus einem Xilinx Spartan6 FPGA und unterstützt eine USB 3.0 Verbindung. Das USRP
B210 stellt zwei empfangs und zwei sende Kanäle zu Verfügung sowie die Möglichkeit
GPIOs des FPGAs an zusprechen. Die Spannungsversorgung erfolgt über ein externes
Netzteil. Ein RFIC von Alalog Devices liefert eine kostengünstige RF Experimentier-
plattform. Die USB 3.0 Verbindung ist rückwärtskompatibel zu USB 2.0. Der UHD
Treiber welcher eingesetzt wird um mit der Firmware des FPGAs zu kommunizieren ist
Open-Source und auch als Cross-Platform Projekt realisiert. Er stellt eine gemeinsame
API zu Verfügung was eine Zusammenarbeit mit einer großen Community mit sich bring.
3.1 Features des USRP B210
• RF Abdeckung von 70MHz-6GHz
• GNU Radio, C++ und Python APIs
• USB 3.0 Interface
• Standard B-USB 3.0 Stecker
• Veränderbare Rate des 12 bit ADC/DAC
• 2 TX & 2 RX, Half oder Full Duplex
• Volle-Kohärente 2x2 MIMO Kompatibilität
• Xilinx Spartan 6 XC6SLX150 FPGA
11

12. • Bis zu 56 MHz unverzögerter Bandbreite im 1x1 Modus
• Bis zu 30.72 MHz unverzögerter Bandbreite im 2x2 Modus
• GPIO Kompatibilität
Wie im Blockschaltbild 7 zuerkennen gibt es nur einen Zeitgenerator. Der FPGA teilt
oder vervielfacht die Zeitbasis für seinen Takt, welchen er benötigt um die Signale zu
mischen, selbst. Werden beide Sendeeinheiten verwendet muss die Zeitbasis aufgeteilt
werden, sprich aus den bisher 56 MHz Bandbreite wird 30.72 MHz. Die Master Clock
Rate lässt ich stufenlos in einem Bereich von 5 MHz und 61.44 MHz einstellen. Frequen-
zen über 56 MHz sind somit möglich aber nicht empfohlen. Die Master Clock Rate kann
mit folgendem UHD Befehl gesetzt werden:
$ uhd_usrp_probe −−args="master_clock_rate=52e6"
oder über die API mittels:
$ uhd : : usrp : : multi_usrp : : set_master_clock_rate ( double rate , size_t mboard)
/∗ mboard : Board index 0 bis M−1 ∗/
An dieser Stelle soll auf die Dokumentation des UHD Treibers hingewiesen werden, wel-
che unter folgendem Link zu finden ist:
http://files.ettus.com/manual/index.html.
Das Problem der Frequenzaufteilung wirkt sich erst aus sobald die Sendeeinheiten unter-
schiedliche Frequenzen haben. Dies ist der Fall, wenn mit mehr als 6 GHz, zum Beispiel
mit Hilfe eines Mischers gesendet werden soll. Hier empfiehlt es sich die die Lokaloszil-
latorfrequenz und die Eingangsfrequenz in die Mitte zu legen. Werden zum Beispiel 9.6
GHz benötig, so sollte der eine Sendekanal mit 4.8 GHz die Lokaloszillatorfrequenz für
den Mischer und der andere Sendekanal das Signal der Eingangsfrequenz ebenfalls mit
4.6 GHz liefern.
4 Installation UHD Treiber
Wie bereits erwähnt wird zur Kommunikation mit dem USRP B210 der USRP Hardware
Driver (UHD) verwendet. Dieser Treiber stellt eine API zu Verfügung über welche mit
der Hardware kommuniziert werden kann. Durch diese Abstraktion der verschiedenen
Schichten ist es möglich einen plattformunabhängigen Treiber bereit zustellen. Dies er-
möglicht es dem Endbenutzer sich voll und ganz auf seine Algorithmen zu konzentrieren
unabhängig von der Plattform auf welcher entwickelt wird. Des weiteren ist es möglich
durch die API des UHD unabhängig von der Applikation zu entwickeln. Dadurch kann
auf einfachem Weg mit dem USRP kommuniziert werden ohne sich im Detail mit den
unteren Schichten des Treibers auskennen zu müssen. Applikationen welchen den UHD
Treiber unterstützen können ohne großen Aufwand schnell eingesetzt werden. In den
folgenden Abschnitten wird erklärt wie man den UHD Treiber auf einem Linux System
installiert und diesen in Verbindung mit dem GNU Radio Software Toolkit in betrieb
nimmt.
12

13. Abbildung 7: Blockschaltbild USRP
4.1 System Tools & Abhängigkeiten
Zuerst sollte sicher gestellt sein, dass das System auf einem aktuellen Stand ist und alle
Repositories upgedatet wurden. Dies geschieht am einfachsten und schnellsten über den
Terminal. Um den Terminal zu öffnen drücken Sie STRG + ALT + T. Nun sollte sich
das Fenster wie in Abbildung 8 öffnen.
Für die folgenden Aktionen wird das Root-Passwort benötigt. Sollte dies nicht bekannt
sein, muss der Support um Hilfe gebeten werden. Der Updateprozess wird mit dem
folgenden Befehl gestartet:
$ sudo apt−get update && apt−get upgrade
Sobald alle Updateprozesse fertig gestellt sind, sollte git nach installiert werden, wenn
nicht schon vorhanden. Aus dem git Repository werden nun alle aktuellen Versionen
nach geladen. Der git Service wird mit installiert:
$ sudo apt−get i n s t a l l g i t
Nach dem der git Service installiert ist, kann mit den einzelne git Repositories gearbei-
tet werden. Im weiteren wird ein Paketmanager für Python Module verwendet. Dieser
ermöglicht es einzelne Module für Python nachzuladen und orientiert sich an der sel-
ben Syntax wie der Paketverwalter APT, welcher bereits verwendet wurde um den git
Service zu installieren. Um pip (Pip Install Python) zu installieren muss der folgende
Befehl im Terminal eingeben werden:
$ sudo apt−get i n s t a l l python−pip
13

14. Abbildung 8: Terminal
Die Python Version hierbei ist wichtig, soll Python 3 verwendet werden muss
$ sudo apt−get i n s t a l l python3−pip
eingegeben werden.
4.2 Build UHD Treier
Über pip kann nun PyBOMBS installiert werden. PyBOMBS ist ein Assistenz-Tool um
GNU Radio, veraltete Module und Softwarepakete vom binären Quellcode zu installieren.
Um die aktuelle Version von PyBOMBS aus den git Repositories zu installieren wird
folgender Befehl benötigt:
$ sudo pip i n s t a l l −−upgrade g i t+https :// github . com/ gnuradio /pybombs . g i t
Es empfiehlt sich die Installation über PyBOMBS durch zuführen. Nach dem PyBOMBS
wie bereits erwähnt über pip installiert wurde, wird eine Konfigurationsdatei benötigt.
Diese Datei lässt sich mit
$ pybombs auto−config
erzeugen. Danach muss ein sogenanntes Rezept hinzugefügt werden. Dies geschieht mit
$ pybombs r e c i p e s add−d e f a u l t s
Nun kann der aktuelle UHD Treiber installiert werden. Es hat sich heraus gestellt, dass
es am zuverlässigsten über PyBOMBS funktioniert. Mit dem nachfolgenden Befehl wird
der Treiber aus den Quelldateien erzeugt und auf dem System installiert. Alternativ
kann dieser auch manuell aus den Quelldateien erzeugt und installiert werden.
$ pybombs i n s t a l l uhd
Um sicher zustellen ob der Treiber richtig installiert wurde und das richtige FPGA Image
vorhanden ist, kann nach der Installation folgender Befehl verwendet werden.
14

15. $ uhd_find_devices
Oben genannter Befehl scannt das System nach unterstützen Geräten und listet sie nach
den entdeckten Geräten auf. Sollte im Terminal einen Fehler nach Abbildung 9 "No
UHD Devices Found" ausgegeben werden, liegt es sehr wahrscheinlich daran, dass das
korrekte FPGA Image noch nicht auf dem System zu Verfügung steht. Abhilfe schafft hier
Abbildung 9: No UHD Devices Found
ein Python Skript welches das benötigte FPGA Image nach lädt. Das Skript liegt nach
der Installation des UHD Treibers unter folgendem Systempfad: "/usr/lib/uhd/utils".
Wie in Abbildung 10 zu erkennen benötigt es bei der Ausführung des Skriptes erneut
die Root-Berechtigung. Dies kommt zustande, da das Verzeichnis "/usr" dem Benutzer
root gehört und Benutzergruppen sowie einzelne Benutzer nur eine Berechtigung zum
Ausführen von Dateien innerhalb des Ordners haben. Da das Skript jedoch Dateien in
dem Verzeichnispfad nachlädt wird die Berechtigung des Verzeichnisbesitzers, in diesem
Fall der Benutzer root benötigt.
sudo python / usr / l i b /uhd/ u t i l s /uhd_images_downloader . py
Mit dem oben genannten Befehl kann das richtige Image nach geladen werden. Dies ist
jedoch nur möglich, wenn das SDR bereits am System angeschlossen war. Es empfiehlt
sich während des scannen und beim automatischen Download des FPGA images das
SDR am System angeschlossen zu haben. Nach dem das Image ausgeführt wurde, kann
erneut überprüft werden ob der Treiber nun das SDR richtig erkannt hat. Eine voll
funktionsfähige Hardware sowie Installation ist vorhanden, wenn die Terminalausgabe
aussieht wie in Abbildung 11.
15

16. Abbildung 10: Find UHD Devices and Load FPGA Image
Abbildung 11: UHD Device 0
16

17. 5 Installation GNU Radio
GNU Radio, gr-osmosdr und weitere Tools werden mit
pybombs p r e f i x i n i t ~/SDR −a mySDR −R gnuradio−default
unter dem Homeverzeichnis SDR installiert. Abbildung 12 zeigt den Installationsprozess.
Der Prefix kann jederzeit nach der Installation mit geändert werden.
pybombs config default_prefix NEWPREFIX
Abbildung 12: PyBOMBS install GRC
Alternativ zu PyBOMBS kann das build-gnuradio Install Scripts verwendet werden.
Mit dem folgenden Befehlt wird das Skript herunter geladen und ausführbar gemacht.
Danach werden alle Abhängigkeiten von git geladen und der make Prozess gestartet. Da-
nach werden alle Treiber, Programme und Module installiert. Vieles von diesem Prozess
läuft im Hintergrund und einige Build-Prozesse können einige Zeit in Anspruch nehmen.
wget http : / /www. sbrac . org / f i l e s / build −gnuradio && chmod a+x build −gnuradio && . / build −gnuradio
Um nun GNU Radio auszuführen wird einer der nachfolgenden Befehle benötigt.
1. source ~/ p r e f i x /setup_env . sh
2. gnuradio−companion
Des weiteren sollte im Startmenü unter Entwicklung das GRC Tool auftauchen.
17

18. 6 GNU Radio
GNU Radio ist ein freies Softwareentwicklung Framework, welches Signalverarbeitungs-
blöcke zur Implementierung von Software Defined Radio (SDR) zu Verfügung stellt. Es
stellt neben den Programmiersprachen Python und C++ auch eine Oberfläche mit gra-
fischem Designer bereit. Es wird durch eine globale open-source Community gepflegt
und weiter entwickelt. Das Toolkit kann entweder mit oder ohne Hardware verwendet
werden, bei zweiteren mit Hilfe einer simulationsähnlichen Umgebung. GNU Radio ist
unter der GNU General Public License (GPL) V3 lizenziert.
6.1 GNU Radio Benutzeroberfläche
Die Benutzeroberfläche von GNU Radio ist einfach gehalten. Abbildung 13 zeigt die
Benutzeroberfläche. Beginnend im oberen Bildbereich der Anzeige ist die Menüleiste an-
Abbildung 13: GRC Benutzeroberfläche
gebracht. Darunter befinden sich die Werkzeugleiste. Von dort kann eine Kompilierung,
das Starten des generierten Codes oder das Abbrechen einer Ausführung vorgenommen
werden. Direkt darunter befindet sich die Freifläche zur visuellen Programmierung mit-
tels Blöcken. Diese Blöcke können rechts vom Editorfenster aus einer Auswahlliste in
die freie Fläche gezogen werden. Einzelne Blöcke werden mit Signalen (Pfeile) verbun-
den. Um schnelleren Zugriff auf die einzelnen Blöcke zu haben, stellt die Auswahlliste
eine Funktion zum durch suchen bereit. Um den Code später besser und leichter edi-
tierbar zuhalten empfiehlt es sich wie in der normalen Programmierung Variablen zu
18

19. verwenden. Die einzelnen Blöcke lassen sich mit einem Rechtsklick editieren. Abbildung
14 zeigt die Einstellungen für die Datenquelle. Wenn mehrere Ein- oder Ausgänge des
USRP B210 verwendet werden sollen, müssen diese unter dem Menüpunkt "Num Chan-
nels" angegeben werden. Als Standard ist ein Kanal vor ausgewählt. Sollten zwei USRP
B210 vorliegen, werden zwei Quellen (zwei Blöcke) benötigt. Um den zweiten Kanal des
Abbildung 14: USRP Properties
USRP B210 zu konfigurieren, ist der Reiter "RF Options" zu wählen. Hier werden alle
zuvor definierten Kanäle aufgeführt und können individuell eingestellt werden. Jedoch
sind die Grenzen der Hardware zu beachten. Wie bereits erwähnt kann es zu "Effek-
ten" führen wenn die Ausgänge (Tx) und Eingänge (Rx) zu unterschiedlich sind, da
nur eine Zeitbasis im SDR vorhanden ist. Wie in Abbildung 15 zuerkennen ist, lassen
sich auch in diesem Dialogfeld Variablen verwenden. Ob der Antennentype ein Eingang,
Ausgang oder beides sein soll, lässt sich mit einer Dropdownbar auswählen. Sobald al-
le Blöcke eingestellt und parametriert wurden, kann die Applikation gestartet werden.
Dies geschieht über den "Play" Button. Danach werden die Blöcke in Code umgesetzt
und kompiliert. Je nach ausgewählter Oberfläche im Block "Options" wird nun eine QT
Oberfläche erzeugt oder eine wxWidgets Oberfläche. Beides sind Cross-Platform Biblio-
theken zum erzeugen von Oberflächen. Ein Gemisch aus beiden Oberflächen führt zu
einem Kompilirungs-Fehler. hier ist zu beachten, dass immer nur mit einer der beiden
Oberflächen gearbeitet wird. An dieser Stelle soll erwähnt sein, dass die QT-Bibliothek
die Standardbibliothek von GNU Radio ist und diese auch stets weiter entwickelt wird.
19

20. Abbildung 15: USRP RF Options
Es empfiehlt sich aus diesem Grund die QT-Bibliothek zu priorisieren. Das Beispielpro-
gramm welches in Abbildung 13 angezeigt wird, erzeugt ein einfaches Radio, welches
im Frequenzbereich von 90 MHz - 108 MHz in 1 KHz Schritten abtastet. Die Sample-
Rate beträgt 100k. Im Rational Resampler Block wird nun die Eingangs-Abtastrate von
100k auf 192k angepasst. Im weiteren Block WBFM Receive wird nun das Wideband
Frequency Modulierte FM Signal demoduliert und auf die Ausgangsfrequenz der Audio-
senke (Lautsprecher) gebracht. Um das Signal zu verstärken kann zwischen dem WBFM
Block und der Senke noch ein Multiply Const Block geschaltet werden. Der Standard-
wert des Constant (hier die Verstärkung) ist 1, dieser kann nach belieben erhöht werden
um eine Verstärkung des Audiosignal zu erreichen.
6.2 Code Analyse
Nach dem die Blöcke in einen Code übersetzt wurden liegt dieser als Python Code
Datei im Projektverzeichnis. Dieser Pythoncode kann mit einem beliebigen Editor edi-
tiert werden. In dem Falle des Beispiels aus diesem Dokument nennt sich die Datei
"top_block.py". Dieser Bezeichnung stammt aus der ID des Options-Block. Wird nun
der Code in einem Editor betrachtet, sind die zuvor definierten Variablen und Blöcke
leicht zu erkennen (zur besseren Lesbarkeit wurden die Kommentare der erzeugten Blö-
cke bereits erweitert). Die einzelnen Verbindungen der jeweiligen Blöcke wird mit der
20

21. "connect"-Funktion realisiert. In diesem Skript können nun auch die jeweiligen Daten
weiter manipuliert und verarbeitet werden. Im nachfolgenden ist der erzeugte Python
Source Code zu sehen.
#!/ usr / bin /env python2
# −∗− coding : utf −8 −∗−
##################################################
# GNU Radio Python Flow Graph
# Title : Top Block
# Generated : Tue Nov 28 16:54:53 2017
##################################################
i f __name__ == ’__main__ ’ :
import ctypes
import sys
i f sys . platform . startswith ( ’ linux ’ ) :
try :
x11 = ctypes . c d l l . LoadLibrary ( ’ libX11 . so ’ )
x11 . XInitThreads ()
except :
print "Warning : ␣ f a i l e d ␣ to ␣XInitThreads () "
from PyQt4 import Qt
from gnuradio import analog
from gnuradio import audio
from gnuradio import eng_notation
from gnuradio import f i l t e r
from gnuradio import gr
from gnuradio import qtgui
from gnuradio import uhd
from gnuradio . eng_option import eng_option
from gnuradio . f i l t e r import f i r d e s
from gnuradio . qtgui import Range , RangeWidget
from optparse import OptionParser
import sip
import sys
import time
c l a s s top_block ( gr . top_block , Qt . QWidget) :
def __init__( s e l f ) :
gr . top_block . __init__( s e l f , "Top␣Block" )
Qt . QWidget . __init__( s e l f )
s e l f . setWindowTitle ( "Top␣Block" )
try :
s e l f . setWindowIcon (Qt . QIcon . fromTheme( ’ gnuradio−grc ’ ) )
except :
pass
s e l f . top_scroll_layout = Qt . QVBoxLayout ()
s e l f . setLayout ( s e l f . top_scroll_layout )
s e l f . top_scroll = Qt . QScrollArea ()
s e l f . top_scroll . setFrameStyle (Qt . QFrame . NoFrame)
21

22. s e l f . top_scroll_layout . addWidget ( s e l f . top_scroll )
s e l f . top_scroll . setWidgetResizable ( True )
s e l f . top_widget = Qt . QWidget ()
s e l f . top_scroll . setWidget ( s e l f . top_widget )
s e l f . top_layout = Qt . QVBoxLayout( s e l f . top_widget )
s e l f . top_grid_layout = Qt . QGridLayout ()
s e l f . top_layout . addLayout ( s e l f . top_grid_layout )
s e l f . s e t t i n g s = Qt . QSettings ( "GNU␣Radio" , "top_block" )
s e l f . restoreGeometry ( s e l f . s e t t i n g s . value ( "geometry" ) . toByteArray ()
)
##################################################
# Variables
##################################################
s e l f . samp_rate = samp_rate = 100 e3
s e l f . gain = gain = 60
s e l f . freq = freq = 96.9 e6
s e l f . audio_rate = audio_rate = 48000
s e l f . audio_interp = audio_interp = 4
##################################################
# Blocks
##################################################
s e l f . _gain_range = Range (0 , 74 , 1 , 60 , 200)
s e l f . _gain_win = RangeWidget ( s e l f . _gain_range , s e l f . set_gain , ’
gain ’ , " counter_slider " , f l o a t )
s e l f . top_layout . addWidget ( s e l f . _gain_win )
s e l f . _freq_range = Range(90 e6 , 108e6 , 1000 , 96.9 e6 , 200)
s e l f . _freq_win = RangeWidget ( s e l f . _freq_range , s e l f . set_freq , ’
freq ’ , " counter_slider " , f l o a t )
s e l f . top_layout . addWidget ( s e l f . _freq_win )
s e l f . uhd_usrp_source_0 = uhd . usrp_source (
" , " . j o i n (( ’ ’ , "" ) ) ,
uhd . stream_args (
cpu_format=" fc32 " ,
channels=range (1) ,
) ,
)
s e l f . uhd_usrp_source_0 . set_samp_rate ( samp_rate )
s e l f . uhd_usrp_source_0 . set_center_freq ( freq , 0)
s e l f . uhd_usrp_source_0 . set_gain ( gain , 0)
s e l f . uhd_usrp_source_0 . set_antenna ( ’RX2 ’ , 0)
s e l f . rational_resampler_xxx_0 = f i l t e r . rational_resampler_ccc (
i n t e r p o l a t i o n=int (1.05 ∗ ( audio_rate ∗ audio_interp ) ) ,
decimation=int ( samp_rate ) ,
taps=None ,
fractional_bw=None ,
)
s e l f . qtgui_time_sink_x_0 = qtgui . time_sink_c (
2048 , #s i z e
samp_rate , #samp_rate
22

23. "" , #name
1 #number of inputs
)
s e l f . qtgui_time_sink_x_0 . set_update_time (0.20)
s e l f . qtgui_time_sink_x_0 . set_y_axis (−1, 1)
s e l f . qtgui_time_sink_x_0 . set_y_label ( ’ Amplitude ’ , "" )
s e l f . qtgui_time_sink_x_0 . enable_tags (−1, True )
s e l f . qtgui_time_sink_x_0 . set_trigger_mode ( qtgui .TRIG_MODE_FREE,
qtgui .TRIG_SLOPE_POS, 0.0 , 0 , 0 , "" )
s e l f . qtgui_time_sink_x_0 . enable_autoscale ( False )
s e l f . qtgui_time_sink_x_0 . enable_grid ( False )
s e l f . qtgui_time_sink_x_0 . enable_axis_labels ( True )
s e l f . qtgui_time_sink_x_0 . enable_control_panel ( False )
i f not True :
s e l f . qtgui_time_sink_x_0 . disable_legend ()
l a b e l s = [ ’ ’ , ’ ’ , ’ ’ , ’ ’ , ’ ’ ,
’ ’ , ’ ’ , ’ ’ , ’ ’ , ’ ’ ]
widths = [1 , 1 , 1 , 1 , 1 ,
1 , 1 , 1 , 1 , 1]
c o l o r s = [ " blue " , " red " , " green " , " black " , "cyan" ,
"magenta" , " yellow " , "dark␣ red " , "dark␣ green " , " blue " ]
s t y l e s = [1 , 1 , 1 , 1 , 1 ,
1 , 1 , 1 , 1 , 1]
markers = [ −1 , −1, −1, −1, −1,
−1, −1, −1, −1, −1]
alphas = [ 1 . 0 , 1.0 , 1.0 , 1.0 , 1.0 ,
1.0 , 1.0 , 1.0 , 1.0 , 1 . 0 ]
f or i in xrange (2∗1) :
i f len ( l a b e l s [ i ] ) == 0:
i f ( i % 2 == 0) :
s e l f . qtgui_time_sink_x_0 . set_line_label ( i , "Re{{Data␣
{0}}}" . format ( i /2) )
e l s e :
s e l f . qtgui_time_sink_x_0 . set_line_label ( i , "Im{{Data␣
{0}}}" . format ( i /2) )
e l s e :
s e l f . qtgui_time_sink_x_0 . set_line_label ( i , l a b e l s [ i ] )
s e l f . qtgui_time_sink_x_0 . set_line_width ( i , widths [ i ] )
s e l f . qtgui_time_sink_x_0 . set_line_color ( i , c o l o r s [ i ] )
s e l f . qtgui_time_sink_x_0 . set_line_style ( i , s t y l e s [ i ] )
s e l f . qtgui_time_sink_x_0 . set_line_marker ( i , markers [ i ] )
s e l f . qtgui_time_sink_x_0 . set_line_alpha ( i , alphas [ i ] )
s e l f . _qtgui_time_sink_x_0_win = sip . wrapinstance ( s e l f .
qtgui_time_sink_x_0 . pyqwidget () , Qt . QWidget)
s e l f . top_layout . addWidget ( s e l f . _qtgui_time_sink_x_0_win )
s e l f . qtgui_sink_x_0 = qtgui . sink_c (
23

24. 1024 , #f f t s i z e
f i r d e s .WIN_BLACKMAN_hARRIS, #wintype
0 , #fc
samp_rate , #bw
’QT␣GUI␣ Plot ’ , #name
True , #p l o t f r e q
True , #p l o t w a t e r f a l l
True , #plottime
True , #plotconst
)
s e l f . qtgui_sink_x_0 . set_update_time (1.0/10)
s e l f . _qtgui_sink_x_0_win = sip . wrapinstance ( s e l f . qtgui_sink_x_0 .
pyqwidget () , Qt . QWidget)
s e l f . top_layout . addWidget ( s e l f . _qtgui_sink_x_0_win )
s e l f . qtgui_sink_x_0 . enable_rf_freq ( False )
s e l f . qtgui_freq_sink_x_0 = qtgui . freq_sink_c (
1024 , #s i z e
f i r d e s .WIN_BLACKMAN_hARRIS, #wintype
0 , #fc
samp_rate , #bw
"" , #name
1 #number of inputs
)
s e l f . qtgui_freq_sink_x_0 . set_update_time (0.10)
s e l f . qtgui_freq_sink_x_0 . set_y_axis (−140, 10)
s e l f . qtgui_freq_sink_x_0 . set_y_label ( ’ Relative ␣Gain ’ , ’dB ’ )
s e l f . qtgui_freq_sink_x_0 . set_trigger_mode ( qtgui .TRIG_MODE_FREE,
0.0 , 0 , "" )
s e l f . qtgui_freq_sink_x_0 . enable_autoscale ( False )
s e l f . qtgui_freq_sink_x_0 . enable_grid ( False )
s e l f . qtgui_freq_sink_x_0 . set_fft_average ( 1 . 0 )
s e l f . qtgui_freq_sink_x_0 . enable_axis_labels ( True )
s e l f . qtgui_freq_sink_x_0 . enable_control_panel ( False )
i f not True :
s e l f . qtgui_freq_sink_x_0 . disable_legend ()
i f "complex" == " f l o a t " or "complex" == "msg_float" :
s e l f . qtgui_freq_sink_x_0 . set_plot_pos_half ( not True )
l a b e l s = [ ’ ’ , ’ ’ , ’ ’ , ’ ’ , ’ ’ ,
’ ’ , ’ ’ , ’ ’ , ’ ’ , ’ ’ ]
widths = [1 , 1 , 1 , 1 , 1 ,
1 , 1 , 1 , 1 , 1]
c o l o r s = [ " blue " , " red " , " green " , " black " , "cyan" ,
"magenta" , " yellow " , "dark␣ red " , "dark␣ green " , "dark␣
blue " ]
alphas = [ 1 . 0 , 1.0 , 1.0 , 1.0 , 1.0 ,
24

25. 1.0 , 1.0 , 1.0 , 1.0 , 1 . 0 ]
f or i in xrange (1) :
i f len ( l a b e l s [ i ] ) == 0:
s e l f . qtgui_freq_sink_x_0 . set_line_label ( i , "Data␣{0}" .
format ( i ) )
e l s e :
s e l f . qtgui_freq_sink_x_0 . set_line_label ( i , l a b e l s [ i ] )
s e l f . qtgui_freq_sink_x_0 . set_line_width ( i , widths [ i ] )
s e l f . qtgui_freq_sink_x_0 . set_line_color ( i , c o l o r s [ i ] )
s e l f . qtgui_freq_sink_x_0 . set_line_alpha ( i , alphas [ i ] )
s e l f . _qtgui_freq_sink_x_0_win = sip . wrapinstance ( s e l f .
qtgui_freq_sink_x_0 . pyqwidget () , Qt . QWidget)
s e l f . top_layout . addWidget ( s e l f . _qtgui_freq_sink_x_0_win )
s e l f . audio_sink_0 = audio . sink ( audio_rate , ’ ’ , False )
s e l f . analog_wfm_rcv_0 = analog . wfm_rcv(
quad_rate=audio_rate ∗ audio_interp ,
audio_decimation=audio_interp ,
)
##################################################
# Connections
##################################################
s e l f . connect (( s e l f . analog_wfm_rcv_0 , 0) , ( s e l f . audio_sink_0 , 0) )
s e l f . connect (( s e l f . rational_resampler_xxx_0 , 0) , ( s e l f .
analog_wfm_rcv_0 , 0) )
s e l f . connect (( s e l f . rational_resampler_xxx_0 , 0) , ( s e l f .
qtgui_freq_sink_x_0 , 0) )
s e l f . connect (( s e l f . rational_resampler_xxx_0 , 0) , ( s e l f .
qtgui_time_sink_x_0 , 0) )
s e l f . connect (( s e l f . uhd_usrp_source_0 , 0) , ( s e l f . qtgui_sink_x_0 , 0)
)
s e l f . connect (( s e l f . uhd_usrp_source_0 , 0) , ( s e l f .
rational_resampler_xxx_0 , 0) )
def closeEvent ( s e l f , event ) :
s e l f . s e t t i n g s = Qt . QSettings ( "GNU␣Radio" , "top_block" )
s e l f . s e t t i n g s . setValue ( "geometry" , s e l f . saveGeometry () )
event . accept ()
def get_samp_rate ( s e l f ) :
return s e l f . samp_rate
def set_samp_rate ( s e l f , samp_rate ) :
s e l f . samp_rate = samp_rate
s e l f . uhd_usrp_source_0 . set_samp_rate ( s e l f . samp_rate )
s e l f . qtgui_time_sink_x_0 . set_samp_rate ( s e l f . samp_rate )
s e l f . qtgui_sink_x_0 . set_frequency_range (0 , s e l f . samp_rate )
s e l f . qtgui_freq_sink_x_0 . set_frequency_range (0 , s e l f . samp_rate )
def get_gain ( s e l f ) :
return s e l f . gain
25

26. def set_gain ( s e l f , gain ) :
s e l f . gain = gain
s e l f . uhd_usrp_source_0 . set_gain ( s e l f . gain , 0)
def get_freq ( s e l f ) :
return s e l f . freq
def set_freq ( s e l f , freq ) :
s e l f . freq = freq
s e l f . uhd_usrp_source_0 . set_center_freq ( s e l f . freq , 0)
def get_audio_rate ( s e l f ) :
return s e l f . audio_rate
def set_audio_rate ( s e l f , audio_rate ) :
s e l f . audio_rate = audio_rate
def get_audio_interp ( s e l f ) :
return s e l f . audio_interp
def set_audio_interp ( s e l f , audio_interp ) :
s e l f . audio_interp = audio_interp
def main ( top_block_cls=top_block , options=None) :
from d i s t u t i l s . version import StrictVersion
i f StrictVersion (Qt . qVersion () ) >= StrictVersion ( " 4 . 5 . 0 " ) :
s t y l e = gr . p r e f s () . get_string ( ’ qtgui ’ , ’ s t y l e ’ , ’ r a s t e r ’ )
Qt . QApplication . setGraphicsSystem ( s t y l e )
qapp = Qt . QApplication ( sys . argv )
tb = top_block_cls ()
tb . s t a r t ()
tb . show ()
def quitting () :
tb . stop ()
tb . wait ()
qapp . connect (qapp , Qt .SIGNAL( "aboutToQuit () " ) , quitting )
qapp . exec_ ()
i f __name__ == ’__main__ ’ :
main ()
Der erzeugte code kann nun von einem CPython-Interpreter ausgeführt werden. Das
starten der GRC Oberfläche ist nicht weiter notwendig.
$ python / PathToPythonfile /top_block . py
26

27. 7 Ausblick
Im weiteren soll ein kurzer Ausblick auf eine Idee für eine automatische Messeinrichtung
gegeben werden. Die Realisierung kann mit einen oder zwei SDR erfolgen. Es sei zu
beachten, das wenn der Ausgang des SDR auf einen Eingang direkt zurückgeführt
wird, muss mit einem Dämpfungsglied gearbeitet werden. Dies kommt zustande, da
gilt für Tx max: 89 dB und Rx max: 76 dB folglich muss um 13 dB gedämpft werden.
Dies ist jedoch nur der Fall, wenn der Ausgang direkt mit dem Eingang verbunden wird.
7.1 Messaufbau
Die Idee des Messaufbau ist, das SDR befindet sich mit einer Antenne auf einer dreh-
baren Scheibe. Die Scheibe wird durch einen Schrittmotor auf die gewünschte Position
gefahren. Ein Signal wird von einer festen Referenzantenne (zweites SDR) erzeugt und
auf die Antenne übertragen, welche sich auf der Scheibe befindet. Nun wird die Signal-
stärke ermittelt, danach wird die Scheibe mit Hilfe des Schrittmotors auf eine andere
Position gefahren, dadurch dreht sich die Antenne auf der Scheibe aus dem Empfangs-
bereich. Dies wird so oft wiederholt bis die komplette Antenne auf dem Teller vermessen
wurde. Abbildung 16 illustriert den Aufbau der Messeinrichtung. Anstatt einer Audio
Abbildung 16: Beispiel Aufbau
Sink könnten die Daten nun in eine Datei geschrieben werden. Mittels dem Python-
Package Matplotlib können die Messdaten in 3D dargestellt werden.
Es müsste eine Funktion für das Skript geschrieben werden, welche den Schrittmotor auf
die nächste Position fahren lässt. Während die Funktion ausgeführt wird (Motor fährt
Position an) kann der Kontrollflussgraph (flow graph) mittels
tb . stop ()
tb . wait ()
angehalten werden. Die wait() Funktion muss aufgerufen werden, um den Graphen neu
starten zu können. Nach dem der Motor seine Position angefahren hat, kann die Messung
erneut gestartet werden mit dem Aufruf von
27

28. tb . s t a r t ()
sleep (5) # Warte 5 Sekunden
7.2 Schrittmotor
Der Schrittmotor sollte über eine Serielle-Schnittstelle ansprechbar sein. Dadurch wird
es in dem Python Skript einfach den Motor auf bestimmt Positionen fahren zulassen,
da bereits ein fertiges Modul für Python existiert, um Seriell Daten zu senden oder zu
empfangen. Die Aufgabe bestünde darin einen geeigneten Treiber auf einem Mikrocon-
troller zu realisieren. Es müsste ein Protokoll überlegt werden wie die Daten auf der
Seriellen-Schnittstelle übertragen werden. Es könnte zum Beispiel ein Steuerbyte geben,
dieses gibt an ob der Motor in einzelnen Schritten oder in Winkeln verfahren soll. Zwei
Weitere Bytes würden den Winkel angeben oder wie viele Schritte der Motor zu fahren
hat.
Steuerbyte Byte1 Byte2 = 3 Byte
Als Rückgabewert liefert der Mikrocontroller über die Serielle-Schnittstelle ein Status-
byte, dieses gibt an ob der Motor seine Position erreicht hat, sich noch in Bewegung
befindet oder ob ein Fehler vorliegt. Sobald über das Statusbyte ein ready Flag erhal-
ten wird, kann eine neue Messung wie im Kapitel 7.1 Messaufbau beschrieben gestartet
werden (tb.start)).
28

29. Literatur
[1] Analog Devices. AD9361. 5. Jan. 2018. url: http://www.analog.com/en/
products/rf-microwave/integrated-transceivers-transmitters-receivers/
wideband-transceivers-ic/ad9361.html#product-overview.
[2] ettus. USRP B2x0 Series. 5. Jan. 2018. url: http://files.ettus.com/manual/
page_usrp_b200.html.
[3] ettus. USRP Hardware Driver and USRP Manual. 5. Jan. 2018. url: http://
files.ettus.com/manual/.
[4] Stephan Großklaß. SSB. 5. Jan. 2018. url: http://stephan.win31.de/kurzwell.
htm#ssb.
[5] Dave Jones. The Amp Hour. 5. Jan. 2018. url: http://theamphour.com.
[6] radartutorial.eu. Grundlagen der Radartechnik. 5. Jan. 2018. url: http://www.
radartutorial.eu/09.receivers/rx06.de.html.
[7] GNU Radio. TutorialsWritePythonApplications. 5. Jan. 2018. url: https://wiki.
gnuradio.org/index.php/TutorialsWritePythonApplications.
[8] w2aew. Basics of IQ Signals and IQ modulation - A tutorial. 5. Jan. 2018. url:
https://www.youtube.com/watch?v=h_7d-m1ehoY.
[9] w2aew. Basics of the Gilbert Cell | Analog Multiplier | Mixer | Modulator. 5. Jan.
2018. url: https://www.youtube.com/watch?v=7nmmb0pqTU0.
[10] Wikipedia. 16QAM map. 5. Jan. 2018. url: https://commons.wikimedia.org/
wiki/File:16QAM_map.png.
[11] Wikipedia. Direktmischempfänger. 5. Jan. 2018. url: https://de.wikipedia.
org/wiki/DirektmischempfÃďnger.
[12] Wikipedia. IQ-Verfahren. 5. Jan. 2018. url: https://de.wikipedia.org/wiki/
I%26Q-Verfahren.
[13] Wikipedia. Komplex2. 5. Jan. 2018. url: https://de.wikipedia.org/wiki/
Datei:Komplex2.png.
[14] Wikipedia. Mischer. 5. Jan. 2018. url: https://de.wikipedia.org/wiki/
Mischer_(Elektronik).
[15] Wikipedia. Quadraturamplitudenmodulation. 5. Jan. 2018. url: https : / / de .
wikipedia.org/wiki/Quadraturamplitudenmodulation#Mathematischer_Hintergrund.
[16] Wikipedia. Software Defined Radio. 5. Jan. 2018. url: https://de.wikipedia.
org/wiki/Software_Defined_Radio.
[17] Wikipedia. Spiegelfrequenz. 5. Jan. 2018. url: https://de.wikipedia.org/
wiki/Spiegelfrequenz.
[18] Wikipedia. Synchrondemodulation. 5. Jan. 2018. url: https://de.wikipedia.
org/wiki/Synchrondemodulation.
29

30. [19] Wikipedia. Universal Software Radio Peripheral. 5. Jan. 2018. url: https://de.
wikipedia.org/wiki/Universal_Software_Radio_Peripheral.
[20] Wikipedia. Überlagerungsempfänger. 5. Jan. 2018. url: https://de.wikipedia.
org/wiki/ÃœberlagerungsempfÃďnger.
[21] Glen A. Williamson. Q A M. 5. Jan. 2018. url: http : / / www . williamson -
labs.com/480_qam.htm.
30

31. Erklärung
Hiermit versichere ich, dass ich diese Arbeit selbständig verfasst und keine anderen, als
die angegebenen Quellen und Hilfsmittel benutzt, die wörtlich oder inhaltlich übernom-
menen Stellen als solche kenntlich gemacht habe.
Ort, den Datum