🚱 💞 👃🏼 Software Defined Radio - wie funktioniert es? Teil 4 👶🏼 🗯️ 😨

Hallo Habr.

Im dritten Teil wurde beschrieben, wie Sie mit Python auf den SDR-Empfänger zugreifen. Jetzt lernen wir das GNU- Radioprogramm kennen - ein System, mit dem Sie eine ziemlich komplexe Konfiguration eines Funkgeräts erstellen können, ohne eine einzige Codezeile schreiben zu müssen.

Betrachten Sie als Beispiel das Problem des parallelen Empfangs mehrerer UKW-Sender auf einem Empfänger. Wir werden den gleichen RTL SDR V3 wie den Empfänger verwenden.

Fortsetzung unter dem Schnitt.

Installation

Um loszulegen, muss GNU Radio installiert sein. Das Distributionskit für Windows kann hier heruntergeladen werden . Dieses System ist plattformübergreifend, es gibt auch Versionen für Linux und OSX (es scheint, dass GNU Radio erfolgreich auf dem Raspberry Pi gestartet wurde, aber ich kann keine 100% ige Garantie geben).

Tatsächlich ist GNU Radio ein ganzes Framework für die digitale Signalverarbeitung, bei dem das Programm aus separaten Modulen "zusammengesetzt" wird. Es gibt eine große Anzahl von vorgefertigten Blöcken. Wenn Sie möchten, können Sie auch eigene Blöcke erstellen. Die Module selbst sind in C ++ geschrieben und Python interagiert miteinander. Wer möchte, kann sich die API genauer ansehen, aber in der Praxis ist dies höchstwahrscheinlich nicht sinnvoll - alle Aktionen können visuell im GNU Radio Companion-Programm ausgeführt werden.

Das System konzentriert sich auf die Verarbeitung von Datenströmen, so dass jeder Block normalerweise eine Eingabe und eine Ausgabe hat. Als nächstes erhalten wir durch Verbinden der Blöcke im Editor ein vorgefertigtes System. Die GNU Radio-Schnittstelle selbst ist recht einfach. Die Schwierigkeit besteht darin, zu verstehen, was ein Block tut. Wie bereits erwähnt, hat die Arbeit mit SDR auf niedriger Ebene eine hohe Eingabeschwelle und erfordert einige Kenntnisse in DSP und Mathematik. Wir werden jedoch eine einfache Aufgabe betrachten, für die keine besonderen Kenntnisse erforderlich sind. Also fangen wir an.

Erste Schritte

Wir starten den GNU Radio Companion, erstellen ein neues Projekt, wählen den Projekttyp WX GUI aus, fügen ihn dem Bildschirm hinzu und verbinden die beiden Blöcke, wie im Screenshot gezeigt.

Wir sehen zwei Arten von Blöcken - Source (Source) und Sink (Output, "Drain"). RTL-SDR ist unser Empfänger, FFT GUI ist ein virtueller Spektrumanalysator.

Die Variable Abtastrate ist auf 2048000 eingestellt. Dies ist die Abtastrate unseres Empfängers. Die Standard-RTL-SDR-Frequenz beträgt 100 MHz.

Wir starten das Projekt - alles funktioniert, wir sehen eine Reihe von UKW-Sendern. Das erste Programm für GNU Radio ist fertig!

Wenn wir uns das Protokoll ansehen, werden wir solche Zeilen sehen.

Generieren: 'D: \\ MyProjects \\ GNURadio \\ top_block.py'
Ausführen: C: \ Python27 \ python.exe -u D: \ MyProjects \ GNURadio \ top_block.py

Ja, wir können die Datei top_block.py sehen, die GNU Radio Companion für uns generiert hat. Echte Jedi können direkt in Python schreiben, aber der erforderliche Code ist, wie wir sehen, ziemlich groß. Wir haben es in 1 Minute erstellt.

top_blocks.py

#!/usr/bin/env python2 # -*- coding: utf-8 -*- ################################################## # GNU Radio Python Flow Graph # Title: Top Block # Generated: Wed May 22 22:05:14 2019 ################################################## if __name__ == '__main__': import ctypes import sys if sys.platform.startswith('linux'): try: x11 = ctypes.cdll.LoadLibrary('libX11.so') x11.XInitThreads() except: print "Warning: failed to XInitThreads()" from gnuradio import eng_notation from gnuradio import gr from gnuradio import wxgui from gnuradio.eng_option import eng_option from gnuradio.fft import window from gnuradio.filter import firdes from gnuradio.wxgui import fftsink2 from grc_gnuradio import wxgui as grc_wxgui from optparse import OptionParser import osmosdr import time import wx class top_block(grc_wxgui.top_block_gui): def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 2048000 ################################################## # Blocks ################################################## self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=0, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate, fft_size=1024, fft_rate=15, average=False, avg_alpha=None, title='FFT Plot', peak_hold=False, ) self.Add(self.wxgui_fftsink2_0.win) self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' ) self.rtlsdr_source_0.set_sample_rate(samp_rate) self.rtlsdr_source_0.set_center_freq(100e6, 0) self.rtlsdr_source_0.set_freq_corr(0, 0) self.rtlsdr_source_0.set_dc_offset_mode(0, 0) self.rtlsdr_source_0.set_iq_balance_mode(0, 0) self.rtlsdr_source_0.set_gain_mode(False, 0) self.rtlsdr_source_0.set_gain(10, 0) self.rtlsdr_source_0.set_if_gain(20, 0) self.rtlsdr_source_0.set_bb_gain(20, 0) self.rtlsdr_source_0.set_antenna('', 0) self.rtlsdr_source_0.set_bandwidth(0, 0) ################################################## # Connections ################################################## self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0)) def get_samp_rate(self): return self.samp_rate def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.wxgui_fftsink2_0.set_sample_rate(self.samp_rate) self.rtlsdr_source_0.set_sample_rate(self.samp_rate) def main(top_block_cls=top_block, options=None): tb = top_block_cls() tb.Start(True) tb.Wait() if __name__ == '__main__': main()

Wenn wir jedoch die umständliche Initialisierung entfernen, werden wir feststellen, dass es nicht so viele wichtige Codezeilen gibt.

 from gnuradio import gr from gnuradio.wxgui import fftsink2 import osmosdr class top_block(grc_wxgui.top_block_gui): def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") self.samp_rate = samp_rate = 2048000 self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(...) self.Add(self.wxgui_fftsink2_0.win) self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + '' ) self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0)) def main(top_block_cls=top_block, options=None): tb = top_block_cls() tb.Start(True) tb.Wait()

Grundsätzlich kann es also manuell geschrieben werden. Mit einer Maus geht es aber immer noch schneller. Obwohl die Möglichkeit, den Code zu ändern, manchmal nützlich sein kann, wenn Sie eine nicht standardmäßige Logik hinzufügen möchten.

UKW-Radio empfangen

Versuchen Sie nun, eine der Stationen zu nehmen. Wie aus den Screenshots hervorgeht, beträgt die Mittenfrequenz des Empfängers 100 MHz und die Bandbreite etwa 2 MHz. Im Spektrum sehen wir zwei Stationen mit 100,1 MHz bzw. 100,7 MHz.

Der erste Schritt besteht darin, das Spektrum der Station in die Mitte zu übertragen, jetzt sind es 100 kHz rechts. Dazu erinnern wir uns an die Schulformel zum Multiplizieren von Cosinus - als Ergebnis gibt es zwei Frequenzen, die Summe und die Differenz - die gewünschte Station bewegt sich in die Mitte, was wir brauchen (und wir filtern den Überschuss heraus).

Wir erstellen zwei Variablen zum Speichern der Frequenzen freq_center = 100000000 und freq_1 = 100100000 und fügen einen Signalgenerator mit der Frequenz freq_center hinzu - freq_1.

Weil Da das System auf Python basiert, können wir Ausdrücke in den Parametereingabefeldern verwenden, was sehr praktisch ist.

Das Diagramm sollte folgendermaßen aussehen:

Jetzt müssen Sie mehrere Blöcke gleichzeitig hinzufügen - reduzieren Sie die Taktfrequenz des Eingangssignals (2048 kHz), filtern Sie das Signal, legen Sie es auf den FM-Decoder an und reduzieren Sie die Taktfrequenz erneut auf 48 kHz.

Das Ergebnis ist im Bild dargestellt:

Wir überlegen genau. Wir teilen die Taktrate von 2048 kHz mit dem Rational Resampler-Block durch das Vierfache (wir erhalten 512 kHz), dann gibt es nach dem Tiefpassfilter einen WBFM-Decoder mit Dezimierung 10 (wir erhalten 51,2 kHz). Grundsätzlich kann dieses Signal bereits der Soundkarte zugeführt werden, die Tonhöhe ist jedoch geringfügig unterschiedlich. Wir ändern erneut die Taktfrequenz auf 48/51, wodurch die Taktfrequenz 48,2 kHz beträgt, die Differenz kann bereits vernachlässigt werden.

Der zweite wichtige Punkt ist die Art der Eingaben. Ein komplexes IQ-Signal (Ein- / Ausgänge in Blau) wird vom Empfänger empfangen, ein reales Signal wird vom FM-Decoder ausgegeben - Ein- und Ausgänge sind gelb. Wenn verwechselt, wird nichts funktionieren. Mehr war schon auf Habré , es reicht uns, das allgemeine Prinzip zu verstehen.

Stellen Sie im Allgemeinen sicher, dass alles funktioniert. Sie können das Programm ausführen und Radio hören. Wir werden weiter gehen - wir haben immer noch Software Defined Radio - wir werden den gleichzeitigen Empfang der zweiten Station hinzufügen.

Mehrkanalempfang

Der zweite Empfänger wird durch Ihre bevorzugte Programmiermethode hinzugefügt - Strg + C / Strg + V. Fügen Sie die Variable freq_2 hinzu, kopieren Sie die Blöcke und verbinden Sie sie auf die gleiche Weise.

Das Ergebnis ist ziemlich surreal - Sie können zwei UKW-Sender gleichzeitig hören. Mit derselben Methode (Strg + V) können Sie eine dritte Station hinzufügen.

Aufzeichnen

Das Hören von zwei Sendern auf originelle Weise, aber in der Praxis ist nicht sehr nützlich. Wir werden etwas Notwendigeres tun, zum Beispiel Tonaufnahmen zu separaten Dateien hinzufügen. Dies kann sehr praktisch sein - mehrere Kanäle können gleichzeitig von einem physischen Empfänger aufgezeichnet werden.

Fügen Sie jeder Ausgabe eine File Sink-Komponente hinzu, wie im Screenshot gezeigt.

Die Windows-Version erfordert aus irgendeinem Grund absolute Dateipfade, andernfalls funktioniert die Aufzeichnung nicht. Wir fangen an, wir sind überzeugt, dass alles normal ist. Die Größe der gespeicherten Dateien ist ziemlich groß, weil Das Standardformat ist float. Bei Eingabe im int-Format bleiben die Leser als Hausaufgaben.

Die resultierenden Dateien können in Cool Edit geöffnet werden und stellen sicher, dass der Ton normal aufgenommen wird.

Natürlich kann die Anzahl der aufgezeichneten Kanäle erhöht werden, sie ist nur durch die Empfängerbandbreite und die Computerleistung begrenzt. Neben File Sink kann auch UDP Sink verwendet werden, sodass das Programm für die Übertragung über das Netzwerk verwendet werden kann.

Führen Sie über die Befehlszeile aus

Und der letzte. Wenn Sie das Programm beispielsweise für die Mehrkanalaufnahme autonom verwenden, wird die Benutzeroberfläche im Prinzip nicht benötigt. Ändern Sie im oberen linken Block von Optionen den Parameter Ausführungsoptionen in Keine Benutzeroberfläche. Führen Sie das Programm erneut aus und stellen Sie sicher, dass alles funktioniert. Jetzt speichern wir die generierte Datei top_block.py - wir können sie einfach über die Befehlszeile ausführen, zum Beispiel über eine Bat-Datei oder über die Konsole.

Bei Interesse wird die generierte Datei unter einem Spoiler gespeichert.

recorder.py

 #!/usr/bin/env python2 # -*- coding: utf-8 -*- ################################################## # GNU Radio Python Flow Graph # Title: Top Block # Generated: Fri May 24 21:47:03 2019 ################################################## from gnuradio import analog from gnuradio import audio from gnuradio import blocks from gnuradio import eng_notation from gnuradio import filter from gnuradio import gr from gnuradio.eng_option import eng_option from gnuradio.filter import firdes from optparse import OptionParser import osmosdr import time class top_block(gr.top_block): def __init__(self): gr.top_block.__init__(self, "Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 2048000 self.freq_center = freq_center = 100000000 self.freq_2 = freq_2 = 100700000 self.freq_1 = freq_1 = 100100000 ################################################## # Blocks ################################################## self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' ) self.rtlsdr_source_0.set_sample_rate(samp_rate) self.rtlsdr_source_0.set_center_freq(freq_center, 0) self.rtlsdr_source_0.set_freq_corr(0, 0) self.rtlsdr_source_0.set_dc_offset_mode(0, 0) self.rtlsdr_source_0.set_iq_balance_mode(0, 0) self.rtlsdr_source_0.set_gain_mode(False, 0) self.rtlsdr_source_0.set_gain(10, 0) self.rtlsdr_source_0.set_if_gain(20, 0) self.rtlsdr_source_0.set_bb_gain(20, 0) self.rtlsdr_source_0.set_antenna('', 0) self.rtlsdr_source_0.set_bandwidth(0, 0) self.rational_resampler_xxx_1_0 = filter.rational_resampler_fff( interpolation=48, decimation=51, taps=None, fractional_bw=None, ) self.rational_resampler_xxx_1 = filter.rational_resampler_fff( interpolation=48, decimation=51, taps=None, fractional_bw=None, ) self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc( interpolation=1, decimation=4, taps=None, fractional_bw=None, ) self.rational_resampler_xxx_0 = filter.rational_resampler_ccc( interpolation=1, decimation=4, taps=None, fractional_bw=None, ) self.low_pass_filter_0_0 = filter.fir_filter_ccf(1, firdes.low_pass( 1, samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass( 1, samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76)) self.blocks_multiply_xx_0_0 = blocks.multiply_vcc(1) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_file_sink_0_0 = blocks.file_sink(gr.sizeof_float*1, 'D:\\Temp\\1\\audio2.snd', False) self.blocks_file_sink_0_0.set_unbuffered(False) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, 'D:\\Temp\\1\\audio1.snd', False) self.blocks_file_sink_0.set_unbuffered(False) self.audio_sink_0 = audio.sink(48000, '', True) self.analog_wfm_rcv_0_0 = analog.wfm_rcv( quad_rate=samp_rate/4, audio_decimation=10, ) self.analog_wfm_rcv_0 = analog.wfm_rcv( quad_rate=samp_rate/4, audio_decimation=10, ) self.analog_sig_source_x_0_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq_center - freq_2, 1, 0) self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq_center - freq_1, 1, 0) ################################################## # Connections ################################################## self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.analog_sig_source_x_0_0, 0), (self.blocks_multiply_xx_0_0, 1)) self.connect((self.analog_wfm_rcv_0, 0), (self.rational_resampler_xxx_1, 0)) self.connect((self.analog_wfm_rcv_0_0, 0), (self.rational_resampler_xxx_1_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.rational_resampler_xxx_0, 0)) self.connect((self.blocks_multiply_xx_0_0, 0), (self.rational_resampler_xxx_0_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.analog_wfm_rcv_0, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.analog_wfm_rcv_0_0, 0)) self.connect((self.rational_resampler_xxx_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.rational_resampler_xxx_0_0, 0), (self.low_pass_filter_0_0, 0)) self.connect((self.rational_resampler_xxx_1, 0), (self.audio_sink_0, 0)) self.connect((self.rational_resampler_xxx_1, 0), (self.blocks_file_sink_0, 0)) self.connect((self.rational_resampler_xxx_1_0, 0), (self.audio_sink_0, 1)) self.connect((self.rational_resampler_xxx_1_0, 0), (self.blocks_file_sink_0_0, 0)) self.connect((self.rtlsdr_source_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.rtlsdr_source_0, 0), (self.blocks_multiply_xx_0_0, 0)) def get_samp_rate(self): return self.samp_rate def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate self.rtlsdr_source_0.set_sample_rate(self.samp_rate) self.low_pass_filter_0_0.set_taps(firdes.low_pass(1, self.samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76)) self.low_pass_filter_0.set_taps(firdes.low_pass(1, self.samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76)) self.analog_sig_source_x_0_0.set_sampling_freq(self.samp_rate) self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate) def get_freq_center(self): return self.freq_center def set_freq_center(self, freq_center): self.freq_center = freq_center self.rtlsdr_source_0.set_center_freq(self.freq_center, 0) self.analog_sig_source_x_0_0.set_frequency(self.freq_center - self.freq_2) self.analog_sig_source_x_0.set_frequency(self.freq_center - self.freq_1) def get_freq_2(self): return self.freq_2 def set_freq_2(self, freq_2): self.freq_2 = freq_2 self.analog_sig_source_x_0_0.set_frequency(self.freq_center - self.freq_2) def get_freq_1(self): return self.freq_1 def set_freq_1(self, freq_1): self.freq_1 = freq_1 self.analog_sig_source_x_0.set_frequency(self.freq_center - self.freq_1) def main(top_block_cls=top_block, options=None): tb = top_block_cls() tb.start() try: raw_input('Press Enter to quit: ') except EOFError: pass tb.stop() tb.wait() if __name__ == '__main__': main()

Es ist auch praktisch, dass das System plattformübergreifend ist und das resultierende Programm unter Linux, Windows und OSX ausgeführt werden kann.

Fazit

Wir können sagen, dass GNU Radio ein ziemlich kompliziertes System ist, natürlich nicht in Bezug auf das Zeichnen von Blöcken, sondern in Bezug auf das Verständnis, wie alles funktioniert. Aber einige einfache Dinge zu tun ist durchaus machbar und interessant. GNU Radio wird auch bequem als „virtuelles Labor“ für Schulungen verwendet. Sie können ein virtuelles Oszilloskop oder einen Spektrumanalysator an einen beliebigen Teil der Schaltung anschließen und sehen, wie das Signal aussieht.

Wenn es keine individuellen Wünsche gibt, kann das Thema SDR-Empfang wahrscheinlich geschlossen werden - alle Hauptpunkte wurden bereits berücksichtigt, und die Anzahl der Ansichten vom ersten bis zum dritten Teil sinkt fast exponentiell (obwohl Sie immer noch über die Übertragung schreiben können, aber es erfordert eine teurere “ Hardware “für Tests als RTL SDR). Trotzdem hoffe ich, dass den Lesern ein gewisses Verständnis dafür bleibt, wie dies funktioniert. Nun, alle erfolgreichen Experimente.

Software Defined Radio - wie funktioniert es? Teil 4