Rádio definido por software - como funciona? Parte 4

Oi Habr.

A terceira parte descreveu como acessar o receptor SDR usando Python. Agora vamos nos familiarizar com o programa GNU Radio - um sistema que permite criar uma configuração bastante complexa de um dispositivo de rádio sem escrever uma única linha de código.



Como exemplo, considere o problema da recepção paralela de várias estações FM em um receptor. Usaremos o mesmo RTL SDR V3 do receptor.

Continua sob o corte.

Instalação


Para começar, o GNU Radio precisa ser instalado, o kit de distribuição para Windows pode ser baixado aqui . Este sistema é multiplataforma, também existem versões para Linux e OSX (parece que o GNU Radio foi lançado com sucesso no Raspberry Pi, mas não posso dar 100% de garantia).

De fato, o GNU Radio é uma estrutura completa para processamento de sinal digital, na qual o programa é "montado" a partir de módulos separados. Há um grande número de blocos prontos, se você desejar, também pode criar seus próprios. Os módulos são escritos em C ++ e o Python interage entre si. Quem desejar pode olhar para a API com mais detalhes , mas na prática isso provavelmente não é útil - todas as ações podem ser realizadas visualmente no programa GNU Radio Companion.

O sistema está focado no processamento de fluxos de dados, para que cada bloco geralmente tenha uma entrada e uma saída. Em seguida, conectando os blocos no editor, obtemos um sistema pronto. A interface do GNU Radio em si é bastante simples, a dificuldade está em entender o que um bloco está fazendo. Como mencionado anteriormente, o trabalho de baixo nível com SDR possui um alto limite de entrada e requer algum conhecimento de DSP e matemática. Mas consideraremos uma tarefa simples para a qual nenhum conhecimento especial é necessário. Então, vamos começar.

Introdução


Iniciamos o GNU Radio Companion, criamos um novo projeto, selecionamos o tipo de projeto WX GUI, adicionamos à tela e conectamos os dois blocos, conforme mostrado na captura de tela.



Vemos dois tipos de blocos - Fonte (fonte) e Pia (saída, "dreno"). O RTL-SDR é o nosso receptor, a FFT GUI é um analisador de espectro virtual.

A variável Sample Rate está ajustada para 2048000, esta é a taxa de amostragem do nosso receptor. A frequência RTL-SDR padrão é 100 MHz.

Começamos o projeto - tudo funciona, vemos várias estações de FM. O primeiro programa para o GNU Radio está pronto!



Se olharmos para o log, veremos essas linhas.

Gerando: 'D: \\ MyProjects \\ GNURadio \\ top_block.py'
Executando: C: \ Python27 \ python.exe -u D: \ MyProjects \ GNURadio \ top_block.py

Sim, podemos ver o arquivo top_block.py que o GNU Radio Companion gerou para nós. O verdadeiro Jedi pode escrever diretamente em Python, mas o código necessário, como vemos, é bastante grande. Nós o criamos em 1 minuto.

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


No entanto, se removermos a inicialização complicada, veremos que não existem muitas linhas de código principais.
 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() 

Então, basicamente, pode ser escrito manualmente. Mas ainda é mais rápido com um mouse. Embora a capacidade de alterar o código às vezes possa ser útil se você quiser adicionar alguma lógica não padrão.

Receba Rádio FM


Agora tente pegar uma das estações. Como foi visto nas capturas de tela, a frequência central do receptor é de 100 MHz e a largura de banda é de cerca de 2 MHz. No espectro, vemos duas estações, a 100,1 MHz e 100,7 MHz, respectivamente.

O primeiro passo é transferir o espectro da estação para o centro, agora é de 100KHz para a direita. Para fazer isso, lembramos a fórmula da escola para multiplicar cossenos - como resultado, haverá duas frequências, a soma e a diferença - a estação desejada se moverá para o centro, que é o que precisamos (e filtramos o excesso).

Criamos duas variáveis ​​para armazenar as frequências freq_center = 100000000 e freq_1 = 100100000, também adicionamos um gerador de sinal com frequência freq_center - freq_1.



Porque Como o sistema é baseado em Python, podemos usar expressões nos campos de entrada de parâmetros, o que é bastante conveniente.

O diagrama deve ficar assim:



Agora você precisa adicionar vários blocos de uma só vez - reduza a frequência do relógio do sinal de entrada (é 2048KHz), filtre o sinal, aplique-o ao decodificador de FM e reduza novamente a frequência do relógio para 48KHz.

O resultado é mostrado na figura:



Nós consideramos cuidadosamente. Dividimos a velocidade do relógio de 2048KHz por 4 vezes com o bloco Rational Resampler (obtemos 512KHz); depois do filtro passa-baixo, existe um decodificador WBFM com dizimação 10 (obtemos 51,2KHz). Em princípio, esse sinal já pode ser alimentado na placa de som, mas o tom será ligeiramente diferente. Mais uma vez, alteramos a frequência do relógio para 48/51, como resultado, a frequência do relógio será 48,2 KHz, a diferença já pode ser negligenciada.

O segundo ponto importante é o tipo de entradas. Um sinal IQ complexo (entradas / saídas em azul) é recebido do receptor, um sinal real é emitido pelo decodificador de FM - as entradas e saídas são amarelas. Se misturado, nada vai funcionar. Já havia mais sobre Habr , é o suficiente para entendermos o princípio geral.

Em geral, execute, verifique se tudo funciona. Você pode executar o programa e ouvir rádio. Iremos além - ainda temos rádio definido por software - adicionaremos a recepção simultânea da segunda estação.

Recepção multicanal


O segundo receptor é adicionado pelo seu método de programação favorito - Ctrl + C / Ctrl + V. Adicione a variável freq_2, copie os blocos e conecte-os da mesma maneira.



O resultado é bastante surreal - você pode ouvir duas estações FM simultaneamente. Usando o mesmo método (Ctrl + V), você pode adicionar uma terceira estação.

Record


Ouvir duas estações de maneira original, mas na prática não é muito útil. Faremos algo mais necessário, por exemplo, adicionar gravação de som a arquivos separados. Isso pode ser bastante conveniente - vários canais podem ser gravados simultaneamente a partir de um receptor físico.

Adicione um componente Coletor de arquivos a cada saída, conforme mostrado na captura de tela.



A versão do Windows, por algum motivo, requer caminhos absolutos de arquivo, caso contrário, a gravação não funciona. Começamos, estamos convencidos de que tudo está normal. O tamanho dos arquivos salvos é bastante grande, porque o formato padrão é float. A entrada no formato int deixará os leitores como lição de casa.

Os arquivos resultantes podem ser abertos no Cool Edit e verifique se o som é gravado normalmente.





Obviamente, o número de canais gravados pode ser aumentado, limitando-se apenas à largura de banda do receptor e à potência do computador. Além do File Sink, o UDP Sink também pode ser usado, para que o programa possa ser transmitido pela rede.

Executar a partir da linha de comando


E o último. Se você usar o programa de forma autônoma, por exemplo, para gravação multicanal, a interface do usuário, em princípio, não será necessária. No bloco superior esquerdo de Opções, altere o parâmetro Opções de Execução para Nenhuma UI. Execute o programa novamente, verifique se tudo funciona. Agora salvamos o arquivo gerado top_block.py - podemos apenas executá-lo na linha de comando, por exemplo, em um arquivo bat ou no console.



Se alguém estiver interessado, o arquivo gerado é salvo em um 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() 


Também é conveniente que o sistema seja multiplataforma e o programa resultante possa ser executado no Linux, Windows e OSX.

Conclusão


Podemos dizer que o GNU Radio é um sistema bastante complicado, não em termos de desenhar blocos, é claro, mas em termos de entender como tudo funciona. Mas fazer algumas coisas simples é bastante viável e interessante. O GNU Radio também é convenientemente usado como um “laboratório virtual” para treinamento - você pode conectar um osciloscópio virtual ou analisador de espectro a qualquer parte do circuito e ver a aparência do sinal.

Se não houver desejos individuais, o tópico da recepção do SDR provavelmente poderá ser encerrado - todos os pontos principais já foram considerados e o número de visualizações da primeira à terceira parte cai quase exponencialmente (embora você ainda possa escrever sobre a transferência, mas isso exige um custo mais caro " hardware ”para testes que RTL SDR). No entanto, espero que alguma compreensão de como isso funcione permaneça com os leitores. Bem, todas as experiências bem-sucedidas.

Source: https://habr.com/ru/post/pt453038/


All Articles