🤹 🚷 🖖🏾 Radio définie par logiciel - comment ça marche? Partie 4 🥉 👨🏽 👨🏾‍🤝‍👨🏻

Salut, Habr.

La troisième partie a décrit comment accéder au récepteur SDR à l'aide de Python. Nous allons maintenant nous familiariser avec le programme GNU Radio - un système qui vous permet de créer une configuration assez complexe d'un appareil radio sans écrire une seule ligne de code.

Par exemple, considérons le problème de la réception parallèle de plusieurs stations FM sur un même récepteur. Nous utiliserons le même RTL SDR V3 que le récepteur.

Suite sous la coupe.

L'installation

Pour commencer, GNU Radio doit être installé, le kit de distribution pour Windows peut être téléchargé ici . Ce système est multiplateforme, il existe également des versions pour Linux et OSX (il semble que GNU Radio a été lancé avec succès sur le Raspberry Pi, mais je ne peux pas donner une garantie à 100%).

En fait, GNU Radio est un cadre complet pour le traitement numérique du signal, dans lequel le programme est «assemblé» à partir de modules séparés. Il existe un grand nombre de blocs prêts à l'emploi, si vous le souhaitez, vous pouvez également créer les vôtres. Les modules eux-mêmes sont écrits en C ++ et Python interagit les uns avec les autres. Ceux qui le souhaitent peuvent regarder l'API plus en détail , mais en pratique, cela n'est probablement pas utile - toutes les actions peuvent être effectuées visuellement dans le programme GNU Radio Companion.

Le système se concentre sur le traitement des flux de données, de sorte que chaque bloc a généralement une entrée et une sortie. Ensuite, en connectant les blocs dans l'éditeur, nous obtenons un système prêt à l'emploi. L'interface GNU Radio elle-même est assez simple, la difficulté est de comprendre ce que fait un bloc. Comme mentionné précédemment, le travail de bas niveau avec SDR a un seuil d'entrée élevé et nécessite des connaissances en DSP et en mathématiques. Mais nous considérerons une tâche simple pour laquelle aucune connaissance particulière n'est requise. Commençons donc.

Pour commencer

Nous lançons le GNU Radio Companion, créons un nouveau projet, sélectionnons le type de projet WX GUI, ajoutons à l'écran et connectons les deux blocs, comme indiqué dans la capture d'écran.

Nous voyons deux types de blocs - Source (source) et Sink (sortie, "drain"). RTL-SDR est notre récepteur, FFT GUI est un analyseur de spectre virtuel.

La variable Sample Rate est définie sur 2048000, c'est la fréquence d'échantillonnage de notre récepteur. La fréquence RTL-SDR par défaut est de 100 MHz.

Nous commençons le projet - tout fonctionne, nous voyons une gamme de stations FM. Le premier programme pour GNU Radio est prêt!

Si nous regardons le journal, nous verrons de telles lignes.

Génération: 'D: \\ MyProjects \\ GNURadio \\ top_block.py'
Exécution: C: \ Python27 \ python.exe -u D: \ MyProjects \ GNURadio \ top_block.py

Oui, nous pouvons voir le fichier top_block.py que GNU Radio Companion a généré pour nous. True Jedi peut écrire directement en Python, mais le code requis, comme nous le voyons, est assez volumineux. Nous l'avons créé en 1 minute.

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()

Cependant, si nous supprimons l'initialisation fastidieuse, nous verrons qu'il n'y a pas autant de lignes de code clés.

 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()

Donc, fondamentalement, il peut être écrit manuellement. Mais c'est encore plus rapide avec une souris. Bien que la possibilité de modifier le code puisse parfois être utile si vous souhaitez ajouter une logique non standard.

Recevoir la radio FM

Essayez maintenant de prendre l'une des stations. Comme on l'a vu sur les captures d'écran, la fréquence centrale du récepteur est de 100 MHz et la bande passante est d'environ 2 MHz. Dans le spectre, nous voyons deux stations, à 100,1 MHz et 100,7 MHz, respectivement.

La première étape consiste à transférer le spectre de la station au centre, maintenant il est de 100KHz à droite. Pour ce faire, nous rappelons la formule de l'école pour multiplier les cosinus - en conséquence, il y aura deux fréquences, la somme et la différence - la station souhaitée se déplacera vers le centre, ce dont nous avons besoin (et nous filtrons l'excédent).

Nous créons deux variables pour stocker les fréquences freq_center = 100000000 et freq_1 = 100100000, nous ajoutons également un générateur de signal avec la fréquence freq_center - freq_1.

Parce que Comme le système est basé sur Python, nous pouvons utiliser des expressions dans les champs de saisie des paramètres, ce qui est assez pratique.

Le diagramme devrait ressembler à ceci:

Vous devez maintenant ajouter plusieurs blocs à la fois - réduisez la fréquence d'horloge du signal d'entrée (c'est 2048KHz), filtrez le signal, appliquez-le au décodeur FM, puis réduisez à nouveau la fréquence d'horloge à 48KHz.

Le résultat est montré dans l'image:

Nous réfléchissons attentivement. Nous divisons la vitesse d'horloge de 2048 KHz par 4 fois avec le bloc Rational Resampler (nous obtenons 512 KHz), puis après le filtre passe-bas, il y a un décodeur WBFM avec décimation 10 (nous obtenons 51,2 KHz). En principe, ce signal peut déjà être envoyé à la carte son, mais la hauteur sera légèrement différente. Encore une fois, nous modifions la fréquence d'horloge à 48/51, par conséquent, la fréquence d'horloge sera de 48,2 KHz, la différence peut déjà être négligée.

Le deuxième point important est le type d'entrées. Un signal IQ complexe (entrées / sorties en bleu) est reçu du récepteur, un signal réel est émis par le décodeur FM - les entrées et sorties sont jaunes. Si mélangé, rien ne fonctionnera. Plus était déjà sur Habré , il nous suffit de comprendre le principe général.

En général, exécutez, assurez-vous que tout fonctionne. Vous pouvez exécuter le programme et écouter la radio. Nous irons plus loin - nous avons toujours la radio Software Defined - nous ajouterons la réception simultanée de la deuxième station.

Réception multicanal

Le deuxième récepteur est ajouté par votre méthode de programmation préférée - Ctrl + C / Ctrl + V. Ajoutez la variable freq_2, copiez les blocs et connectez-les de la même manière.

Le résultat est assez surréaliste - vous pouvez écouter deux stations FM simultanément. En utilisant la même méthode (Ctrl + V), vous pouvez ajouter une troisième station.

Record

Écouter deux stations de manière originale, mais en pratique n'est pas très utile. Nous ferons quelque chose de plus nécessaire, par exemple, ajouter un enregistrement sonore à des fichiers séparés. Cela peut être très pratique - plusieurs canaux peuvent être enregistrés simultanément à partir d'un seul récepteur physique.

Ajoutez un composant File Sink à chaque sortie, comme indiqué dans la capture d'écran.

La version Windows pour une raison quelconque nécessite des chemins de fichier absolus, sinon l'enregistrement ne fonctionne pas. Nous commençons, nous sommes convaincus que tout est normal. La taille des fichiers enregistrés est assez grande, car le format par défaut est float. L'entrée au format int laissera les lecteurs comme devoirs.

Les fichiers résultants peuvent être ouverts dans Cool Edit et assurez-vous que le son est enregistré normalement.

Bien sûr, le nombre de canaux enregistrés peut être augmenté, il n'est limité que par la bande passante du récepteur et la puissance de l'ordinateur. En plus de File Sink, UDP Sink peut également être utilisé, de sorte que le programme peut être utilisé pour une diffusion sur le réseau.

Exécuter à partir de la ligne de commande

Et le dernier. Si vous utilisez le programme de manière autonome, par exemple, pour l'enregistrement multicanal, l'interface utilisateur, en principe, n'est pas nécessaire. Dans le bloc supérieur gauche d'Options, changez le paramètre Run Options en No UI. Exécutez à nouveau le programme, assurez-vous que tout fonctionne. Maintenant, nous enregistrons le fichier généré top_block.py - nous pouvons simplement l'exécuter à partir de la ligne de commande, par exemple à partir d'un fichier bat ou de la console.

Si quelqu'un est intéressé, le fichier généré est enregistré sous un spoiler.

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()

Il est également pratique que le système soit multiplateforme et que le programme résultant puisse s'exécuter sur Linux, Windows et OSX.

Conclusion

Nous pouvons dire que GNU Radio est un système assez compliqué, non pas en termes de blocs de dessin bien sûr, mais en termes de compréhension de la façon dont tout cela fonctionne. Mais faire des choses simples est tout à fait réalisable et intéressant. La radio GNU est également utilisée comme un «laboratoire virtuel» pour la formation - vous pouvez connecter un oscilloscope virtuel ou un analyseur de spectre à n'importe quelle partie du circuit et voir à quoi ressemble le signal.

S'il n'y a pas de souhait individuel, le sujet de la réception SDR peut probablement être fermé - tous les points principaux ont déjà été pris en compte, et le nombre de vues de la première à la troisième partie diminue presque exponentiellement (bien que vous puissiez toujours écrire sur le transfert, mais cela nécessite un prix plus élevé " matériel »pour les tests que RTL SDR). Néanmoins, j'espère qu'une certaine compréhension de la façon dont cela fonctionne reste avec les lecteurs. Eh bien, toutes les expériences réussies.

Radio définie par logiciel - comment ça marche? Partie 4