Der PSKReporter ist wohl jedem Funkamateur bekannt. Um die Ausbreitungsbedingungen an meinem QTH besser beurteilen zu können habe ich mir eine Empfangsanlage zugelegt, die 24 Stunden in Betrieb ist und den PSKReporter mit Daten versorgt. Der PSKReporter zeigt welche Stationen von meiner Empfangsanlage gehört wurden und ich kann dann beurteilen wie die Möglichkeiten eines QSOs mit meiner Funkanlage auf den verschiedenen Bändern sind. Im Folgenden beschreibe ich den Aufbau meines "Bandbeobachtungssystems" (BBS). Als Vorlage diente das Open Source Programm Openwebrx, von dem ich das Komandozeilen-Tool csdr genutzt habe. Die Aufbereitung der IQ-Daten für die Anwendungen erfolgt unter Linux mit "Bordmitteln".

Das BBS besteht grundlegend aus zwei Skripten - dem RTL-SDR-Server und den RTL-SDR-Clients. Server und Clients nutzen Linux als Host-System.

Bild 1 zeigt das Blockschaltbild des RTL-SDR-Servers. Als Empfänger nutze ich 7 RTL-SDR-Sticks, die über einen UP-Konverter und einem Antennensplitter von einer Mini-Whip mit den Kurzwellensignalen versorgt werden. Die Daten jedes Sticks werden auf einem Netzwerk-Port den Clients zur Verfügung gestellt. Damit ist es möglich den Server auch "abgesetzt" zu betreiben. Mit dem Modul RTL_SDR() werden die RTL-SDR-Sticks auf die Frequenz und die Bandbreite (Samples) eingestellt. Die RTL-SDR-Sticks reichen ihre IQ-Daten an das Modul NMUX() weiter, das die IQ-Daten im Netzwerk auf je einen Port den Clients zur Verfügung stellen.

Das Blockschaltbild der Clients ist in Bild 2 zu sehen. Das NC() Modul (NetConncet) holt sich die IQ-Daten aus dem Netzwerk und übergibt sie dem CSDR() Modul. Dieses Modul besteht aus mehreren Untermodulen, die einen bestimmten Bereich der IQ-Daten in einen Audio-Stream umwandeln und an das Soundsystem weiterleiten. Das Soundsystem (PulseAudio) stellt virtuelle Ein- und Ausgangsports zur Verfügung über die die Anwendungen mit den Audio-Daten versorgt werden.

Hardware

Antenne

Die Empfangsantenne ist eine im Eigenbau gefertigte Mini-Whip nach PA0RDT. Den Aufbau habe ich in einem separaten Artikel dokumentiert. Es kann aber auch eine andere Breitband-Antenne genutzt werden. Ein 20m langer in 10m Höhe horizontal aufgehängter Draht brachte auch gut Ergebnisse. Die bei dem RTL-SDR-Stick mitgelieferte Antenne reicht für den KW-Empfang nicht aus. Für diejenigen, die eine kleine Breitband-Antenne einsetzen wollen, den Selbstbau aber scheuen, bietet der Fachhandel entsprechende Antennen, z.B. Bonito Mini Whip an.

UP-Konverter

Ein UP-Konverter ist nötig um den KW-Bereich (1-30 MHz) auf den Empfangsbereich der verwendeten RTL-USB-Sticks (25-1750 MHz) umzusetzen. Der UP-Konverter Ham It Up v1.3 wurde von NooElec bezogen. Die KW-Frequenz wird damit auf 125-155 MHz herauf gemischt.

Antennensplitter

Bei dem Antennensplitter handelt es sich um eine Kombination aus einem 4-fach-Splitter und drei 2-fach-Splitter nach DC4KU.

Das Rezept für den Nachbau ist hier zu finden. Der Frequenzbereich des Splitters ist eigentlich nur für den Bereich bis 30 MHz vorgesehen, arbeitet aber auch noch im Bereich von 125-155 MHz zufriedenstellend. Die Dämpfung durch die Aufteilung des Antennensignal hat nach meinen Beobachtungen keine Auswirkung auf die Empfangsqualität. Der Signal-Rausch-Abstand (SNR) verändert sich, ob mit oder ohne Splitter nicht. Die Absenkung des absoluten Signalpegels wird durch die Einstellung der Verstärkung des RTL-SDR-Sticks ausgeglichen. Die Zuordnung der Ausgänge zu den zu lesenden KW-Bändern habe ich nach der Dämpfung und dem Signalpegel der KW-Bänder vorgenommen - d.h. das "lauteste" Band kam an den Ausgang mit der größten Dämpfung (12dB), bei mir das 160m- bzw. 80m-Band. Die "leisen" Bänder, hier 15m- bzw. 10m-Band an die Anschlüsse mit 6dB Dämpfung. Der Fachhandel bietet hier auch geeignete Antennensplitter an, z.B. bei BOX73.

RTL-SDR-Stick

Die RTL-SDR-Sticks wurde, wie der UP-Konverter, von NooElec bezogen - 5 NESDR Mini und 2 NESDR Mini 2+ 0.5PPM TCXO-based. Obwohl auch der NESDR Mini ohne TCXO nach einer Warmlaufphase recht frequenzstabil arbeitet, würde ich trotzdem den NESDR Mini 2+ mit TCXO für ein paar Euro mehr zum Kauf empfehlen.

Rechner

Das BBS läuft bei mir nach Client und Server getrennt auf 2 älteren Rechnern (Intel(R) Core(TM)2 Duo CPU, P8600  @ 2.40GHz) unter Ubuntu 17.04. Die RTL-SDR-Sticks sind über einen USB-HUB 3.0, 7 Port, mit dem Server-Rechner verbunden. Insbesondere für die Dekodierung der Signale (JT, PKS, CW, etc) sollte aber auf eine leistungsfähigeren Hardware zurückgegriffen werden.

Software

Installation und Konfiguration des Grundsystems

Wenn ein lauffähiges Linux-System installiert ist, müssen für die RTL-SDR-Sticks und dem BBS noch einige Pakete nachgeladen und einige grundsätzlichen Konfigurationen durchgeführt werden.

Der Linux rtl-Treiber für DVB-T muss deinstalliert mit werden:

sudo modprobe -r dvb_usb_rtl28xxu

Damit dieses dauerhaft wird ist folgende Zeile:

blacklist dvb_usb_rtl28xxu

in der Datei /etc/modprobe.d/blacklist.conf anzufügen.

Im nächsten Schritt wird mit gqrx ein SDR-Receiver installiert. Es sollte die neuste Version von der GQRX-Webseite verwendet werden und nach der dortige Installationsanleitung vorgegangen werden. Hier noch einmal aufgelistet:

Eine evtl. vorhandene alte Version von gqrx muss entfernt werden. Es ist ein Terminal zu öffnen und dort nacheinander folgende Zeilen einzugeben:

sudo apt-get purge --auto-remove gqrx
sudo apt-get purge --auto-remove gqrx-sdr
sudo apt-get purge --auto-remove libgnuradio*

Neue Repositorys für die Installation der aktuellen gqrx-Version anlegen:

sudo add-apt-repository -y ppa:bladerf/bladerf
sudo add-apt-repository -y ppa:ettusresearch/uhd
sudo add-apt-repository -y ppa:myriadrf/drivers
sudo add-apt-repository -y ppa:myriadrf/gnuradio
sudo add-apt-repository -y ppa:gqrx/gqrx-sdr
sudo apt-get update

gqrx installieren:

sudo apt-get install gqrx-sdr

Die Installation dauert einige Zeit, da nicht nur das Programm an sich, sondern auch alle zusätzlichen Pakete installiert werden. Mit dem Paket libvolkl-bin wird die Leistungsfähigkeit auf den verwendeten Rechner optimiert:

sudo apt-get install libvolk1-bin
volk_profile

Je nach Rechnerleistung kann dies sehr lange dauern. Nun kann ein RTL-SDR-Stick eingesteckt werden und in einem Terminal durch Eingabe von

gqrx

gestartet werden. Das Programm meldet sich dann mit seinem Fenster wie in Bild 4.

 

Mit einem Klick auf das Dreieck oben links sollte dann der Wasserfall loslaufen. Da gqrx später nicht unbedingt benötigt wird gehe ich hier auf die Bedienung nicht weiter ein. 

Die Ternimalausgaben listet unter anderen den RTL-SDR-Stick auf:

getDeviceList : Available input devices:
0 : "Realtek RTL2838UHIDIR SN: 00000001"
1 : "RFSPACE SDR-IQ Receiver"
2 : "RFSPACE SDR-IP Receiver"
3 : "RFSPACE NetSDR Receiver"
4 : "RFSPACE Cloud-IQ Receiver"
5 : "RTL-SDR Spectrum Server"
6 : "Red Pitaya Transceiver Server"
7 : "Complex Sampled (IQ) File"

An erster Stelle der DeviceList ist der RTL-SDR-Stick mit der Seriennummer (SN) 00000001 aufgeführt. Ich habe für meine RTL-SDR-Stick neue Seriennummer von 1-7 vergeben. Dieser werden in meinen Skripten genutzt. Mit:

rtl_eeprom -d <DeviceNummer> -s <NeueSeriennummer>

wird eine neue Seriennummer gesetzt. <Serienummer> z.B. durch 1( bzw. 2, 3, ... für weitere Sticks) ersetzen.  

Ein zweiter Punkt ist die Korrektur der Frequenz. Hierfür steht das Programm rtl_test -p zur Verfügung. Durch die Eingabe in einem Terminal wie in Bild 5 wird der Korrekturwert ermittelt. Wenn sich der Wert am Ende der Ausgabezeilen nicht mehr ändert kann man das Programm mittels Ctrl-C abbrechen.

 

Die Seriennummer und den Korrekturwert vermerkt man nun am besten direkt auf dem RTL-SDR-Stick. Diese Werte werden später in den Skripten verwendet.

Nun fehlt noch die Bibliothek csdr. Der Download erfolgt von github.com durch anklicken der grünen Schaltfläche "Clone or download" und anschließend auf klicken von "Download ZIP". Nach dem Speicher ist die Datei csdr-master.zip im Download-Verzeichnis zu finden. Hier wird die Datei entpackt und dann in das Verzeichnis gewechselt. Die Installation erfolgt durch die folgenden Eingaben in ein Terminalfenster:

make
sudo make install

Die Warnungen können ignoriert werden. Jetzt können die Bibliotheksfunktionen getestet werden:

rtl_sdr -s 2400000 -f 89300000 -g 20 - | csdr convert_u8_f | csdr shift_addition_cc -0.085 | csdr fir_decimate_cc 10 0.05 HAMMING | csdr fmdemod_quadri_cf | csdr fractional_decimator_ff 5 | csdr deemphasis_wfm_ff 48000 50e-6 | csdr convert_f_s16 | aplay -r 48000 -f S16_LE

Diese Zeile in ein Terrminalfenster kopieren und abschicken.  Der RTL-SDR-Stick wird hiermit auf die Frequenz 89.3MHz abgestimmt, das Signal aufbereitet und mit den Programm aplay ausgegeben. Ist aus dem Lautsprecher nun zumindest Rauschen zu hören funktioniert alles und die Grundinstallation und -konfiguration ist  fast abgeschlossen.

Für mehr als 4 RTL-SDR-Sticks am Rechner muss der maximum usbfs memory limit auf 0 gesetzt werden. Damit wird der Speicher dynamisch verwaltet. Die permanente Einrichtung erfolgt durch folgende Vorgehensweise:

1. Öffnen der /etc/default/grub Datei mit einem Texteditor.
2. Die Zeile GRUB_CMDLINE_LINUX_DEFAULT="quiet splash" mit der Zeile GRUB_CMDLINE_LINUX_DEFAULT="quiet splash usbcore.usbfs_memory_mb=0" ersetzen.
3. grub aktualisieren:

   $ sudo update-grub

Nach einem Neustart sollten nun auch mehr als 4 RTL-SDR-Sticks funktionieren.

Das Server-Skript

Das Skript konfiguriert den RTL-SDR-Stick und stellt die Rohdaten (IQ-Daten) auf einem Netzwerkport zur Verfügung. Im folgenden ist das Server-Skript für das 15m-Band aufgelistet:

 1 #!/bin/bash
 2 #---------------------------------------------------
 3 # Server-Skript
 4 #---------------------------------------------------
 5 # Variablen die gesetzt werden müssen
 6 #---------------------------------------------------
 7 StickSN=6                    # Seriennummer des Sticks. Kann im Stick mit rtl_eeprom gesetzt werden.
 8 UP_Con=125000000             # Up-Frequenz des Konverters eintragen. 0 = kein Konverter.
 9 RTL_SDR_Port=4956            # Port-Nummer dieses Servers. 
10 RTL_SDR_Adress=192.168.2.2   # IP-Adresse des Servers.
11 Startfreq=21000000           # Startfrequenz in Hz.
12 Sample=2400000               # entspricht der Bandbreite.
13 Gain=40                      # Gain-Einstellung des Sticks. Wert kann mit gqrx ausgetestet werden.
14 PPM=-2                       # Frequenzkorrektur der Sticks. Kann mit rtl_test ermittelt werden.
15 #----------------------------------------------------
16 # Ab hier kann alles so bleiben
17 #----------------------------------------------------
18 # An Hand der StickSN die Dev-Nummer setzen
19 StickDev=$(rtl_test -d 99 2> liste.tmp; cat liste.tmp | grep "SN: $StickSN" | cut -d":" -f1)
20 rm liste.tmp                                   # Temporäre Liste löschen
21 Mittenfreq=$(($Startfreq+($Sample/2)+$UP_Con)) # Mittenfrequenz für rtl_sdr() Aufruf berechnen
22 # max 2 Sekunden Zwischenspeicher sonst synchronisiert wsjtx nicht mehr
23 nmuxBufsize=$(((($Sample/4/4096)+1)*4096)) 
24 nmux_memory=$(($Sample/3*4)) 
25 nmuxBufcnt=$((($nmux_memory/$nmuxBufsize)+1))
26 # Kontroll-Ausgaben
27 echo StickSN: $StickSN
28 echo StickDev: $StickDev
29 echo UP_Con: $UP_Con
30 echo RTL_SDR_Port: $RTL_SDR_Port 
31 echo RTL_SDR_Adress: $RTL_SDR_Adress
32 echo Startfreq: $Startfreq
33 echo Sample: $Sample
34 echo Gain: $Gain
35 echo PPM: $PPM
36 echo Mittefreq: $Mittenfreq
37 echo nmuxBufsize: $nmuxBufsize
38 echo nmuxBufcnt: $nmuxBufcnt
39 #---------------------------------------------------
40 # RTL-Stick konfigurieren und die IQ-Daten an nmux weiterleiten
41 rtl_sdr -d $StickDev -s $Sample -f $Mittenfreq -p $PPM -g $Gain -| nmux --bufsize $nmuxBufsize --bufcnt $nmuxBufcnt --port $RTL_SDR_Port --address $RTL_SDR_Adress

• In die Zeilen 7 bis 14 sind die Werte für die Konfiguration des RTL-SDR-Sticks zu setzen. In Zeile 7 ist die vergebene Seriennummer eingetragen. Zeile 8 ist die UP-Frequenz des verwendeten UP-Konverters. Die Port-Nummer steht in Zeile 9. Jedes Server-Skript muss eine eigene Port-Nummer erhalten. Es folgt in Zeile 10 die IP-Adresse des Rechners auf dem das Server-Skript läuft. Die Startfrequenz, hier für das 15m-Band, 21000000Hz (21MHz), ist in der Zeile 11 hinterlegt. Die Anzahl der Samples in Zeile 12 stellen gleichzeitig die Bandbreite, - also 2,4MHz - dar. In Zeile 13 steht die Verstärkung und in Zeile 14 die ermittelte Frequenzkorrektur (PPM).
• Zeile 19 und 20 holt die Dev-Nummer des RTL-SDR-Sticks. Die Dev-Nummer wird vom System vergeben und kann sich bei mehreren RTL-SDR-Sticks je nach USB-Port ändern.
• In Zeile 23 bis 25 wird die Puffergröße berechnet. Da wsjtx synchronisiert, die Netzwerk-Komunikation aber asynchron abläuft ist der Puffer sehr klein gehalten und läuft nach ca. 2 Sekunde über, wenn der Rechner es nicht schafft die Daten abzuholen.
• Es folgen Kontrollausgaben von Zeile 27 bis 38, damit man nach dem Start des Skriptes eine Kontrolle hat.
• In Zeile 41 wird der RTL-SDR-Stick konfiguriert und die Daten dem Netzwerk-Multiplexer übergeben, der mehrere Client-Skripts bedienen kann.

Mit diesen Vorgaben werden die IQ-Daten von 21Mhz bis 23,4Mhz über die IP-Adresse 192.168.2.2 auf den Port 4956 geleitet und stehen den Client-Skripts zur Verfügung.

Das Client-Skript

Dies ist das Client-Skript mit den Werten für die Dekodierung von JT65 Signalen z.B. mit wsjtx auf dem 15m-Band. Das Skript nutzt die Daten vom obigen 15m-Band-Server-Skript. Ferner wird ein virtueller Port im Sound-System PulseAudio angelegt auf den dann z.B. wsjtx zugreifen kann.

 1 #!/bin/bash
 2 #---------------------------------------------------
 3 # Client-Skript
 4 #---------------------------------------------------
 5 # Variablen die gesetzt werden müssen
 6 #---------------------------------------------------
 7 UP_Con=125000000             # Up-Frequenz des Konverters eintragen. 0 = kein Konverter.
 8 RTL_SDR_Port=4956            # Port-Nummer des Servers.
 9 RTL_SDR_Adress=192.168.2.2   # IP-Adresse des Servers.
 10 Freq=21076000               # Empfangsfrequenz
 11 Startfreq=21000000          # Startfrequenz des Servers
 12 Sample=2400000              # Samplerate des Servers
 13 Audio_Sample=48000          # Audio-Sample-Rate des Audio-Systems (PC)
 14 #---------------------------------------------------
 15 # Ab hier kann alles so bleiben
 16 #---------------------------------------------------
 17 Mittenfreq=$(($Startfreq+($Sample/2)+$UP_Con))
 18 # Tuning -> Shift berechnen
 19 myShift="`python -c "print float($Mittenfreq-$Freq-$UP_Con)/$Sample"`"
 20 myDecimate=$(($Sample/$Audio_Sample))
 21 # Konroll-Ausgabe
 22 echo UP_Con: $UP_Con
 23 echo RTL_SDR_Port: $RTL_SDR_Port
 24 echo RTL_SDR_Adress: $RTL_SDR_Adress
 25 echo Freq: $Freq
 26 echo Startfreq: $Startfreq
 27 echo Sample: $Sample
 28 echo Audio_Sample: $Audio_Sample
 29 echo Mittefreq: $Mittenfreq
 30 echo myShift: $myShift
 31 echo myDecimate: $myDecimate
 32 
 33 # Soundport prüfen bzw. erstellen
 34 PortName=$(echo $0 | cut -d"." -f1)     # Portname aus Scriptnamen bauen
 35 sinkID=$(pactl list | grep -B 2 "Argument: sink_name=$PortName" | grep Modul | sed 's/[^0-9]//g')    # Prüfen ob es den Soundport schon gibt
 36 if [ -z "$sinkID" ] # keine ID, keinPort
 37   then 
 38   pactlNr=$(pactl load-module module-null-sink sink_name=$PortName sink_properties=device.description=$PortName)
 39   echo SoundportPort $pactlNr angelegt.-$sinkID-
 40 else
 41   echo Sound-Port $sinkID gefunden!
 42 fi
 43 
 44 PreAplay=$(echo $0 | cut -d"." -f1)_aplay # Prefix für aplay aus Scriptnamen bauen
 45 if [ ! -x /usr/bin/$PreAplay ]                   # Programm nicht gefunden
 46   then
 47   sudo cp /usr/bin/aplay /usr/bin/$PreAplay      # Datei erzeugen
 48   echo $PreAplay angelegt.
 49 fi
 50 echo $PreAplay vorhanden.
 51 #---------------------------------------------------
 52 # Daten lesen und ans Audio übergeben
 53 # 1. Daten von nmux holen.
 54 # 2. Daten nach float konvertieren
 55 # 3. Frequenz abstimmen
 56 # 4. Frequen auf die Audiobandbreite herrunterbrechen
 57 # 5. Frequenzbereich auswählen
 58 # 6. weiter Verarbeitung -> Audio-System
 59 # < -----------Daten holen---------> <--Konvertieren---> <----------Tuning---------------> <----------Freq in Audio-Sample-- Filter???------> <--Freq-Bereich auschneiden-----???-> 
 60 nc -v $RTL_SDR_Adress $RTL_SDR_Port | csdr convert_u8_f | csdr shift_addition_cc $myShift | csdr fir_decimate_cc $myDecimate 0.01 HAMMING | csdr bandpass_fir_fft_cc 0 0.1 0.01 | csdr realpart_cf | csdr agc_ff | csdr limit_ff | csdr convert_f_s16 | $PreAplay -r 48000 -f S16_LE

• Zeile 7 bis 9, 11, 12 sind mit den korrespondieren Daten des Server-Skriptes zu belegen. Zeile 10 ist die Frequenz für JT-Signale auf dem 15m-Band. in Zeile 13 sind die Sample-Rate für das Audio-Systems hinterlegt.
• Zeile 17 bis 19 berechnet den Startpunkt für die genutzte Frequenz im IQ-Datenstrom
• Zeile 20 berechnet den Teiler für das "herrunterbrechen" des IO-Datenstroms (2,4MHz) auf die Audio-Sample-Zahl (hier: 48kHz).
• Es folgen mit Zeile 21 bis 31 wieder Kontrollausgaben.
• In Zeile 33 bis 42 wird ein "virtueller" Sound-Port erzeugt bzw. geprüft, falls noch vorhanden. Der Port-Name wird aus dem Skript-Namen gebildet. So ist der Port im Lautstärkeregler von PulseAudio eindeutig zuzuordnen.
• Zeile 44 bis 49 erstellt eine Kopie des Soundprogrammes aplay mit dem ersten Teil des Skriptnames (jt_15m_aplay), damit auch dies im Lautstärkeregler eindeutig ist. Dieses muss mit root-Rechten erfolgen und das Passwort wird bei Bedarf von Skript abgefragt. 
• Die Verarbeitung der Daten erfolgt in Zeile 60. Das Programm nc holt sich die IQ-Daten des 15m-Server-Skripts. Die IQ-Daten werden verarbeitet, insbesondere wird das obere Seitenband (USB) selektiert, und dem Sound-Programm aplay  übergeben.

Datenaufbereitung

Grundlage für die Datenaufbereitung sind die Komandozeilen-Tools der Bibliothek von csdr und von osmocom, dessen Tools mit GQRX installiert wurden.  Die Daten werden im Server- und Client-Skript jeweils in der letzten Zeile bearbeitet. Im Server-Skript hat diese Zeile die Form:

rtl_sdr -d $StickDev -s $Sample -f $Mittenfreq -p $PPM -g $Gain -| nmux --bufsize $nmuxBufsize --bufcnt $nmuxBufcnt --port $RTL_SDR_Port --address $RTL_SDR_Adress

Hier werden zwei Befehle, rtl_sdr und nmux verwendet. rtl_sdr  von osmocom initialisiert den RTL-SDR-Stick und gibt die IQ-Daten über die Pipe - das ist der senkrechte Strich - an nmux aus der csdr Bibliothek weiter. Bei nmux handel es sich um ein Tool, das Daten entgegen nimmt und dann über die angegebenen Netzwerkadresse und den angegebenen Port ins Netzwerk einspeist. Dabei können mehrer Ausgaben gleichzeitig erfolgen. Die Datenübertragung erfolgt asynchron und wird bei Bedarf im internen Buffer zwischengespeichert. 

Die letzte Zeile im Client-Skript zur Datenaufbereitung ist etwas komplexer und abhängig von der nachgeschalteten Anwendung. Ich verwende zwei Varianten. Eine für Anwendungen, die Audiodaten benötigen, wie wsjtx oder fldigi und eine zweite für Programme, die IQ-Daten weiterverarbeiten wie der CW Skimmer im Breitbandmodus mit 48-194kHz.

Die Daten werden mit den folgenden Zeilen erzeugt:

1. nc -v $RTL_SDR_Adress $RTL_SDR_Port | csdr convert_u8_f | csdr shift_addition_cc $myShift | csdr fir_decimate_cc $myDecimate 0.01 HAMMING | csdr agc_ff | csdr limit_ff | csdr convert_f_s16 | $PreAplay -c 2 -r 96000 -f S16_LE

2. nc -v $RTL_SDR_Adress $RTL_SDR_Port | csdr convert_u8_f | csdr shift_addition_cc $myShift | csdr fir_decimate_cc $myDecimate 0.01 HAMMING | csdr bandpass_fir_fft_cc 0 0.1 0.01 | csdr realpart_cf | csdr agc_ff | csdr limit_ff | csdr convert_f_s16 | $PreAplay -r 48000 -f S16_LE

Die erste Zeile zeigt die Erzeugung der IQ-Daten (CW Skimmer). Das erste Programm nc - im Linux enthalten - holt die IQ-Daten vom nmux Programm aus dem Netzwerk ab und gibt sie per Pipe an csdr weiter. Hier werden die IQ-Daten durch die Angabe des Parameters convert_u8_f in das interne Datenformat von csdr konvertiert. Die Daten werden dann per Pipe weitergereicht. Mit csdr shift_addition_cc $myShift wird die Frequenzabstimmung vorgenommen. Es wird dabei ein Frequenz-Zeiger auf die Frequenz im IQ-Datenstrom gesetzt und per Pipe csdr fir_decimate_cc übergeben. Nun wird der 2.4 MHz breite IQ-Datenstrom durch die Angabe $myDecimate heruntergerechnet.  Mit dem $myDecimate-Wert 25 wird die Bandbreite um den Frequenz-Zeiger eingestellt. Heraus kommt 2.400000Hz/25 = 96000Hz = 96kHz. Nun noch zur den Parametern 0.01 und HAMMING. Diese stellen den internen Filter ein. Der Filter entfernt unerwünschte Signale, die bei der Umrechnung entstehen. 0.01 bestimmt die "Bandbreite" der einzelnen Filterschritte. Hier wäre das, 2400000Hz*0.01 = 24000Hz. Bei 96kHz sind das "4 Abschnitte". Das ist sehr wenig, reicht aber für die digitalen Signale nach meiner Erfahrung aus und hält die benötigte Rechenleistung klein. Weiter Informationen, wie über HAMMING, sind in der Dokumentation von csdr zu finden. Damit sind die IQ-Daten für eine Weiterverarbeitung im CW Skimmer vorbereitet. Es folgt noch ein AGC Filter und ein Limiter um die Daten im zulässigen Bereich zu halten. Die Wandlung ins 16Bit-Format der Soundkarte erledigt csdr convert_f_s16. Der letzte Befehl  $PreAplay -c 2 -r 96000 -f S16_LE ruft das Programm aplay für die Ausgabe eines (IQ-)Stereo-Signals (-c 2) mit der Samplerate 96kHz (-r 96000) und 16-Bit-Format (-f S16_LE) auf.

Die zweite Zeile zeigt wie aus den IQ-Daten Audio-Daten des oberen Seitenbandes entstehen. Die ersten drei Bearbeitungsabschnitte sind gleich. Mit csdr fir_decimate_cc wird mit $myDecimate = 50 wird der Frequenzbereich von 48kHz um den Freqeunz-Zeiger ausgefiltert und csdr bandpass_fir_ft_cc übergeben. Die 0 bewirkt, dass das untere Seitenband nicht genutzt wird. Die folgende 0.1 bestimmt, dass 0,1 des oberen Seitenbanden (24000Hz * 0,1 = 2400Hz) herausgefiltert werden. Mit der anschließenden 0.01 wird wieder die Filterbandbreite eingestellt. Nun wird das Oberseitenband nach  csdr realpart_cf zugeführt. Hier wird der reale Part des Signales herausgefilter. Es folgt wie oben der AGC- und der Limiter-Filter. Nach der Datenkonvertierung mit csdr convert_f_s16, werden die Daten wie oben, nun als Mono-Signal (kein -c 2) dem Programm aplay  gegeben.

Server und Clients in der Praxis

Im praktischen Betrieb muss das Server-Skript im Terminal auf dem Rechner mit den RTL-SDR-Sticks laufen. Bild 6 zeigt das Terminal-Fenster.

Das Server-Skript hat den Namen rtl_nmux_15m.sh. Die Kontrollausgaben zeigen die Einstellungen des Server.  Das Programm nmux meldet, dass es auf der Adresse 192.168.2.2 Port 4956 auf Clients hört. rtl_srd hat 7 RTL-SDR-Sticks gefunden und nutzt das Device 5, d.h. den RTL-SDR-Stick mit der Seriennummer 6 wie im Skript angegeben. Es folgen die Einstellwerte des RTL-SDR-Sticks. Zum Schluss die Meldung das Daten gelesen werden. Jetzt können beliebig viele Clients die Daten abholen. Das funktioniert natürlich auch über ein Netzwerk, so können die Clients auch auf anderen Rechnern laufen.  

 In Bild 7 ist das Terminal-Fenster für den Client-Start zu sehen.

Das Client-Skript hat den Namen jt_15m.sh. Schon der Name und die Kontroll-Ausgaben zeigen, das es hier um Digimode JT65/9 auf dem 15m-Band geht. Der erste Teil des Namens (jt_15m) ist auch der Port-Name im PulseAudio-Lautstärkeregler. Im Bild 8 ist der Lautstärkeregler mit dem erzeugten Ausgabe-Port zu sehen.

Das im Client-Skript gestartete Programm jt_15m_aplay ist mit dem im Skript  erzeugten dem "virtuellen" Port jt_15m verbunden. Anwendungen wie wsjtx können sich nun im Lautstärkeregler mit dem Monitor of jt_15m verbinden und die Audiodaten des 15m-Bandes auf der Frequenz 21.076MHz nutzen um JT-Daten zu dekodieren (Bild 9).

Es ist nun auch möglich weitere Client-Skripte zu erstellen, die auf die IQ-Daten des 15m-Servers (21MHz - 23.4MHz) zugreifen, z.B. ein Client psk_15m.sh der als Startfrequenz 21.070MHz bekommt. Die Anwendung z.B. FLDigi wird dann im Lautstärkeregler  mit dem Monitor of psk_15m verbunden. Oder es wird eine zweite Instanz von wsjtx zur Dekodierung von JT9 gestartet und über den Monitor of jt_15 mit den Daten verbunden. Wer bis hierher gekommen ist und jetzt noch einmal die beiden Blockbilder 1+2 betrachtet, dem werden sie nun wohl verständlicher erscheinen. 

Daten dekodieren und an den PSKReporter leiten

Nun stehen die Audiodaten im Lautstärkeregler zum Abruf bereit und können dekodiert werden. Unter Linux hatte ich für die verschiedenen Digi-Modes folgende Programme am Laufen:

• wsjtx: JT65, JT9 und das neue FT8. 
• FLDigi: PSK, RTTY, ...
• CWSkimmer (unter Wine)

Um von wsjtx mehrere Instanzen zu starten ist die Option -r vorgesehen. Der Aufruf im Terminal sieht folgendermaßen aus:

wsjtx -r jt15m

Damit wird ein Verzeichnis und eine eigene Konfigurationsdatei für diese Instanz erzeugt. Der Name der Instanz, hier jt15m, ist beliebig, sollte aber für die Übersichtlichkeit sinnvoll vergeben werden. Unter File/Settings/Audio ist dann der entsprechende Port auszuwählen. wsjtx-jt15m merkt sich diesen Port für den nächsten Start.

Von fldigi sollten - um im Lautstärkergeler besser erkannt zu werden - Kopien mit für die Bänder und Modes, z.B. fldigi_psk31_10m, angelegt werden:

sudo cp /usr/bin/fldigi /usr/bin/fldigi_psk31_10m

Der Aufruf erfolgt dann mit:

fldigi_psk31_10m --home-dir ~/fldigi_psk31_10m --config-dir ~/fldigi_psk31_10m

In fldigi ist dann unter Konfiguration/Soundkarte/Geräte ist PortAudio anzuhaken und für Aufnahme Pulse auszuwählen.

Eine 30 Tage - Version des CWSkimmers lief bei mir mit Wine problemlos - auch in mehreren Instanzen.  Für jedes Band sollte eine Kopie des CWSkimmers angelegt werden, z.B. CwSimmer_10m.exe, dann findet man sich besser im Lautstärkergeler zurecht. Es sollte je eine Kopie des Desktop - Starters für diese Programmversion mit dem Pfad zu den Konfigurationsdaten zu erstellen. Beispieleintrag für den Starter:

Befehl: env WINEPREFIX="/home/<user>/.wine" wine C:\\windows\\command\\start.exe /Unix /home/<user>/.wine/dosdevices/c:/Program\ Files\ (x86)/Afreet/CwSkimmer/CwSkimmer_10m.exe ini="C:\CWS_10m.ini"
Arbeitsverzeichnis: home/<user>/.wine/dosdevices/c:/Program\ Files\ (x86)/Afreet/Cw\ Skimmer

 <user> ist durch den Namen des User-Verzeichnisses zu ersetzen. So sind mehrer Instanzen problemlos ausfügbar und auffindbar.

Im CWSkimmer wird unter Setting/Radio/Hardware Type SoftRock markiert und die Sample Rate 48 khz ausgewählt. Bei LO Frequenzy wird die (Empfangs-) Frequenz aus dem Client - Skript eingetragen. Für 10m wären das 28024000 Hz. Der CWSkimmer dekodiert dann von 2800000 bis ca. 28048000 Hz. Unter Audio sollte schon Pulse als Eingabe und Ausgabe stehen. Zum Spotten der Daten muss dann noch unter Telnet der Telnet-Server aktiviert werden. Für das Spotten zum PSKReporter wird weiter das Programm CW-Reporter benötigt. Es liest vom Telnet-Server des CWSkimmers die Daten und leitet sie automatisch an den PSKReporter. Eine ausführlich Beschreibung des CWSkimmers in der Praxis ist im FA [1] zufinden.

Auch die Client-Skripte müssen beim ersten Start im Lautstärkeregeler mit dem zugehörigen Port verbunden werden.  Der Lautstärkeregeler merkt sich an Hand des Skript - Namens den Port und weist ihn bei erneutem Start automatisch zu.

Fazit

Die Vorstellung hier zeigt kein fertiges Programm. Es sollte vielmehr zeigen wie unter Linux mit einfachen Mitteln - zwei Skripte - die Daten von einem bzw. mehreren RTL-SDR-Sticks verschieden Dekodier - Progammen zur Verfügung gestellt werden. Die Skripte sind auch mehr als "Hacks" zu verstehen und sollen die Grundlage für eigene Untersuchungen geben. 

Die DO-Bänder (10m, 15m, 80m, 160m) und dem Mode JT65/9 reichten meine beiden PCs (Intel(R) Core(TM)2 Duo CPU, P8600  @ 2.40GHz) von der Rechnerleistung her aus. Für die Beobachtung von mehr Bändern und Modi ist - insbesondere beim Einsatz des CW Skimmers - mehr Rechenleistung nötig.

Literatur und Bezugsquellen

[1] Hegewald, W., DL2RD: CW Skimmer am DVB-T-Stick. FUNKAMATEUR 65 (2016) H. 5, S. 456 f., H. 6, S. 554 f., H. 7, S. 658 f., H. 8, S. 756 f., H. 9, S. 856 f.

---