Você está na página 1de 4

# -*- coding: utf-8 -*- <nbformat>3.

0</nbformat>

# Construindo uma Simulao Simples no GNU Radio


# Download the [Python script](./GNURadioforSimulation.py). or the [IPython]
(./GNURadioforSimulation.ipynb) notebook.

Este documento fornece um passo-a-passo para como configurar um fluxograma GNU Radio para
executar uma simulao simples. Enquanto o GNU Radio projetado para tempo real, uso contnuo,
existem muitas situaes (testes, desenvolvimento, educao, etc.) onde queremos simular sinais e
comportamento de blocos. A diferena que ns pretendemos executar um flowgraph para um perodo
finito, e provavelmente curto, de tempo. Este tutorial ir configurar um top_block simples e gerar,
armazenar e ento trace um sinal ruidoso.

Antes de iniciar qualquer programa, vamos puxar os mdulos Python necessrios. GNU Radio
composto de muitos mdulos com o principal tempo de execuo e tipo de dados definies encontradas
em gnuradio.gr . Ns puxamos em outros mdulos GNU Radio que contm vrios blocos de
processamento de sinal como blocos , que contm math, converses de tipo e blocos de utilidade geral, e
analgico , que mantm blocos relacionados a sinais analgicos e modulao analgica.

#%matplotlib inline
from gnuradio import gr # Pull in the GNU Radio runtime system
from gnuradio import blocks, analog # Get some of the GNU Radio block modules
import scipy # Some useful tools for handling the data
import matplotlib.pyplot as plt

try:
import pylab
except ImportError:
print "Error: could not import pylab (http://matplotlib.sourceforge.net/)"
sys.exit(1)

# Construindo o top_block superior e os blocos de processamento de sinal

# O seguinte constri um top_block padro e configura algumas variveis que usaremos mais tarde.

tb = gr.top_block() # the top container class for a flowgraph


samp_rate = 32e3 # the sample rate of the system
freq = 1e3 # the frequency of the signal.
amp = 1 # the signal amplitude
namp = 0.1 # the amplitude of the noise source (variance of the Gaussian signal)
N = 10000 # number of samples to run in this simulation
# Construiremos um bloco de fonte de sinal que gera uma onda senoidal ( analog.GR_SIN_WAVE ) e
passamos as variveis acima para definir as propriedades.

# No GNU Radio, a taxa de amostragem quase um nmero sem sentido. O GPP no tem nenhum
conceito de tempo de amostragem, portanto, no h relgio funcionando a essa taxa. Utilizamos o
conceito de uma taxa de amostragem como convenincia para o usurio, o que nos permite especificar
freqncias em termos de Hz em vez de uma freqncia normalizada. Na realidade, este gerador de sinal
utiliza a frequncia de freq / samp_rate.

signal = analog.sig_source_c(samp_rate, analog.GR_SIN_WAVE, freq, amp)

# Cria uma fonte de rudo que gere valores aleatrios gaussianos complexos com variao namp.

noise = analog.noise_source_c(analog.GR_GAUSSIAN, namp)

# Acrescente a onda senoidal e os valores gaussianos juntos.


# Note que aqui especificamos _cc como um sufixo, que diz que esse bloco recebe e produz fluxos de
amostra complexos.

add = blocks.add_cc()

# Limitar o nmero de amostras produzidas para <i> N </ i>. Quando este bloco conta <i> N </ i>
amostras, ele ir parar o fluxograma. Uma vez que esta uma simulao e s queremos gerar tantas
amostras, o bloco de cabea uma maneira conveniente de lidar com isso. Os fluxogramas do GNU Radio
sero executados at haver um evento ou quando algo explicitamente diz para ele. Caso contrrio, as
fontes de sinal e rudo continuaro produzindo novas amostras.

head = blocks.head(gr.sizeof_gr_complex, N)

# Agora queremos armazenar os dados para que possamos usar ferramentas Matplotlib para plot-lo.
Usamos um bloco vector_sink que armazena os dados internamente como um vetor. Este bloco pode ser
perigoso porque simplesmente mantm o crescimento do vetor. Se no houver limites colocados sobre
ele (como o bloco de cabea acima), ele pode rapidamente comer a memria do seu sistema. S
aconselhvel usar esse bloco ao executar uma simulao e para ps-anlise de colees de dados, mas
no para aplicativos de transmisso ao vivo.

sink = blocks.vector_sink_c()
# Conectando e executando o Flowgraph

# Agora temos um conjunto de blocos que formaro um fluxograma:


#
# <Pre>
# Sinal ->
# Add -> head -> sink
# Rudo ->
# </ Pre>
#
# Agora precisamos conectar esses blocos juntos em um flowgraph real que mantido pelo top_block
acima. S precisamos usar a funo de conexo do top_block para isso. A funo de conexo toma a
forma connect ((fonte, porta), (destino, porta)) onde as portas definem qual porta de sada ou de
entrada deve ser usada na conexo. Se nenhuma porta for especificada, o Python a interpretar como a
porta 0. No nosso flowgraph aqui, somente o bloco add tem vrias portas de entrada.
# Ligamos sinal porta 0 de adicionar e conecta rudo porta 1 de adicionar .

tb.connect(signal, (add,0)) # signal:0 to add:0


tb.connect((noise,0), (add,1)) # more explicit --> noise:0 to add:1
tb.connect(add, head, sink) # convenience function to string together multiple blocks

# Agora queremos executar o nosso flowgraph. Quando inici-lo, ele vai comear a gerar amostras nas
fontes de sinal e rudo e executar as amostras para baixo fluxo no fluxograma. Podemos iniciar o fluxograma
de uma de duas formas:

* Tb.start (): Esta uma chamada sem bloqueio que inicia o top_block como um thread para executar o
scheduler. Ele retorna imediatamente e nos permite continuar nosso programa enquanto o flowgraph est
sendo executado.

* Tb.run (): Esta uma chamada de bloqueio. Ele inicia o thread top_block e espera at que ele termine
antes de retornar. Isso til para ns em uma simulao como essa onde queremos que ela complete o
processamento de todas as amostras de N.

O top_block tambm tem uma funo tb.wait (). Isso usado para bloquear o thread do top_block. Se
comeamos a usar o tb.start () e terminamos com "nosso" programa e precisamos esperar at que o
flowgraph termine,
Podemos chamar a funo wait para fazer isso. Na realidade, tb.run () apenas um alias para tb.start ();
Tb.wait ().

tb.run()
#Extraindo e traando os dados

Agora hora de tirar os dados do flowgraph. O bloco vector_sink tem


Armazenadas todas as amostras num vector interno. Ns o recuperamos chamando
A funo data () no objeto. Isso nos devolve o vetor como um
Lista de Python. Vamos envolver os dados em uma matriz Scipy para fazer mais tarde
Manipulaes mais fceis e depois imprimir apenas as primeiras 10 amostras.

data = scipy.array(sink.data())
print data[0:10]
print "Ok"

Now we want to plot the data. Let's plot a few hundred samples of the real and
imaginary parts of the noisy sine wave as well as a histogram of signal over
100 bins.

fig = pylab.figure()
sp1 = fig.add_subplot(2,1,1)
sp2 = fig.add_subplot(2,1,2)

sp1.plot(data.real[100:300], 'b')
sp1.plot(data.imag[100:300], 'r')
h = sp2.hist(data, 10)

pylab.show()