def BuildFFT(self,scope=True):
fft0w = filter.window.blackmanharris(2048)
fft0 = fft.fft_vcc(2048, True, fft0w, True)
fft1w = filter.window.blackmanharris(2048)
fft1 = fft.fft_vcc(2048, True, fft1w, True)
self.connect(self.rx0,blocks.stream_to_vector(gr.sizeof_gr_complex, 2048),fft0)
self.connect(self.rx1,blocks.stream_to_vector(gr.sizeof_gr_complex, 2048),fft1)
v2s = blocks.vector_to_stream(gr.sizeof_float,20)
fp2 = findphase_c(2048)
self.connect(fft0,(fp2,0))
self.connect(fft1,(fp2,1))
self.connect(fp2,v2s)
if scope:
self.ffth = qtgui.histogram_sink_f(100,360,-179,180,"FFT Phase Histogram")
#self.ffth.enable_autoscale(False)
self.ffth.enable_accumulate(True)
self.ffth.enable_grid(True)
#self.histo.enable_menu(True)
self.connect(v2s,self.ffth)
self.ffthqt = sip.wrapinstance(self.ffth.pyqwidget(), QtGui.QWidget)
self.ffthqt.show()
def __init__(self, parent,
y_per_div=1, y_divs=8, ref_level=50, x_vals=numpy.arange(10), ninputs=1,
size=default_curvesink_size,
title='', x_units='', y_units='', legends=[], **kwargs):
self.x_vals=x_vals;
self.legends=legends
gr.hier_block2.__init__(self, "curve_sink_f",
gr.io_signature(ninputs, ninputs, gr.sizeof_float),
gr.io_signature(0,0,0))
curve_sink_base.__init__(self, input_is_real=True,
y_per_div=y_per_div, y_divs=y_divs, ref_level=ref_level,
title=title, x_units=x_units, y_units=y_units)
self.s2p = [];
for i in range(0, ninputs):
self.s2p.append(blocks.stream_to_vector(gr.sizeof_float, len(x_vals)))
#self.one_in_n = gr.keep_one_in_n(gr.sizeof_float * self.fft_size,
# max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
self.interleave = blocks.interleave(gr.sizeof_float * len(x_vals));
self.s2v = blocks.stream_to_vector(gr.sizeof_float * len(x_vals), ninputs);
self.sink = blocks.message_sink(gr.sizeof_float * len(x_vals) * ninputs, self.msgq, True);
for i in range(0, ninputs):
self.connect((self, i), self.s2p[i], (self.interleave, i))
self.connect(self.interleave, self.s2v, self.sink);
self.win=curve_window(self, parent, size=size, x_units=self.x_units, y_units=self.y_units, ninputs=ninputs)
def __init__(self, size, factor, itemsize=gr.sizeof_gr_complex):
"""
size: (int) vector size (FFT size) of next block
factor: (int) output will have this many more samples than input
If size is not divisible by factor, then the output will necessarily have jitter.
"""
size = int(size)
factor = int(factor)
# assert size % factor == 0
offset = size // factor
gr.hier_block2.__init__(
self, type(self).__name__,
gr.io_signature(1, 1, itemsize),
gr.io_signature(1, 1, itemsize * size),
)
if factor == 1:
# No duplication needed; simplify flowgraph
self.connect(self, blocks.stream_to_vector(itemsize, size), self)
else:
interleave = blocks.interleave(itemsize * size)
self.connect(interleave, self)
for i in xrange(0, factor):
self.connect(
self,
blocks.delay(itemsize, (factor - 1 - i) * offset),
blocks.stream_to_vector(itemsize, size),
(interleave, i))
def test_001(self):
tb = self.tb
src1_data = (0,0.2,-0.3,0,12,0)
src2_data = (0,0.0,3.0,0,10,0)
src3_data = (0,0.0,3.0,0,1,0)
src1 = blocks.vector_source_f(src1_data)
s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src1, s2v1)
src2 = blocks.vector_source_f(src2_data)
s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src2, s2v2)
src3 = blocks.vector_source_f(src3_data)
s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src3, s2v3)
dst1 = blocks.vector_sink_s()
dst2 = blocks.vector_sink_s()
argmax = blocks.argmax_fs(len(src1_data))
tb.connect(s2v1, (argmax, 0))
tb.connect(s2v2, (argmax, 1))
tb.connect(s2v3, (argmax, 2))
tb.connect((argmax,0), dst1)
tb.connect((argmax,1), dst2)
tb.run()
index = dst1.data()
source = dst2.data()
self.assertEqual(index, (4,))
self.assertEqual(source, (0,))
def __init__(self, update_period=32, window=1024, step_size=0.001, num_ports=2):
gr.hier_block2.__init__(
self, "Phase Align",
gr.io_signaturev(num_ports, num_ports, gen_sig_io(num_ports)),
gr.io_signaturev(num_ports, num_ports, gen_sig_io(num_ports)),
)
self.message_port_register_hier_in("Trigger")
##################################################
# Parameters
##################################################
self.update_period = update_period
self.window = window
self.step_size = step_size
self.num_ports = num_ports
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
# Const block for reference signal to do nothing
self.blocks_add_const_vxx_0 = blocks.add_const_vcc((0, ))
self.connect((self, 0), (self.blocks_add_const_vxx_0, 0))
self.connect((self.blocks_add_const_vxx_0, 0), (self, 0))
for p in range(num_ports-1):
# Create PC object
object_name_pc = 'wifius_phase_correct_vci_'+str(p)
setattr(self, object_name_pc, wifius.phase_correct_vci(1024, samp_rate, window, step_size, update_period, False))
# Add Stream To Vector For Ref
object_name_vr = 'blocks_stream_to_vector_a_'+str(p)
setattr(self, object_name_vr, blocks.stream_to_vector(gr.sizeof_gr_complex*1, window))
# Add Stream To Vector For Next Signal
object_name_sv = 'blocks_stream_to_vector_b_'+str(p)
setattr(self, object_name_sv, blocks.stream_to_vector(gr.sizeof_gr_complex*1, window))
# Add Vector To Stream For Output of PC
object_name_vs = 'blocks_vector_to_stream_'+str(p)
setattr(self, object_name_vs, blocks.vector_to_stream(gr.sizeof_gr_complex*1, window))
# Make Connections
self.connect((self, 0), (getattr(self,object_name_vr), 0))
self.connect((self, p+1), (getattr(self,object_name_sv), 0))
self.connect((getattr(self,object_name_vr), 0), (getattr(self,object_name_pc), 0))
self.connect((getattr(self,object_name_sv), 0), (getattr(self,object_name_pc), 1))
self.connect((getattr(self,object_name_pc), 0), (getattr(self,object_name_vs), 0))
self.connect((getattr(self,object_name_vs), 0), (self, p+1))
self.msg_connect((self, 'Trigger'), (getattr(self,object_name_pc), 'set_enable_sync'))
def __init__(self, filename, dev_addrs,
onebit, gain, digital_gain, fs, fc, sync_pps):
gr.top_block.__init__(self)
if onebit:
raise NotImplementedError("TODO: 1-bit mode not implemented.")
uhd_srcs = [
uhd.usrp_source(",".join(
[addr, "num_recv_frames=256,recv_frame_size=16384"]),
uhd.stream_args(
cpu_format="fc32",
otwformat="sc16",
channels=[0]))
for addr in dev_addrs]
str2vec = blocks.streams_to_vector(2, len(uhd_srcs))
self.connect(str2vec,
blocks.stream_to_vector(2 * len(uhd_srcs), 16*1024*1024),
blocks.file_sink(2 * len(uhd_srcs) * 16 * 1024 * 1024, filename, False))
for ix, src in enumerate(uhd_srcs):
src.set_clock_rate(fs*2, uhd.ALL_MBOARDS)
src.set_samp_rate(fs)
src.set_center_freq(uhd.tune_request(fc, 3e6))
src.set_gain(gain, 0)
# TODO Use offset tuning?
if sync_pps:
src.set_clock_source("external") # 10 MHz
src.set_time_source("external") # PPS
self.connect(src, # [-1.0, 1.0]
blocks.multiply_const_cc(32767 * digital_gain[ix]), # [-32767.0, 32767.0]
blocks.complex_to_interleaved_short(), #[-32768, 32767]
blocks.short_to_char(), #[-128, 127]
blocks.stream_to_vector(1, 2), # I,Q,I,Q -> IQ, IQ
(str2vec, ix))
print "Setting clocks..."
if sync_pps:
time.sleep(1.1) # Ensure there's been an edge. TODO: necessary?
last_pps_time = uhd_srcs[0].get_time_last_pps()
while last_pps_time == uhd_srcs[0].get_time_last_pps():
time.sleep(0.1)
print "Got edge"
[src.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for src in uhd_srcs]
time.sleep(1.0) # Wait for edge to set the clocks
else:
# No external PPS/10 MHz. Just set each clock and accept some skew.
t = time.time()
[src.set_time_now(uhd.time_spec(time.time())) for src in uhd_srcs]
if len(uhd_srcs) > 1:
print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % (
(time.time()-t) * 1000)
t_start = uhd.time_spec(time.time() + 1.5)
[src.set_start_time(t_start) for src in uhd_srcs]
print "ready"
def test_002_t (self): #print "TEST: discarded carriers and num sync words" # set up fg test_len = 200 vlen = 20 ts_len = test_len/vlen discarded_carriers = (-8,-4,-2,1,2,3,9) num_sync_words = 2 in_data0 = [0]*test_len in_data1 = [0]*test_len for k in range(test_len): in_data0[k] = complex(k-4, k+1) in_data1[k] = complex(k+3, k-2) src0 = blocks.vector_source_c(in_data0) s2v0 = blocks.stream_to_vector(8,vlen) s2ts0 = blocks.stream_to_tagged_stream(8,vlen,ts_len,'packet_len') src1 = blocks.vector_source_c(in_data1) s2v1 = blocks.stream_to_vector(8,vlen) s2ts1 = blocks.stream_to_tagged_stream(8,vlen,ts_len,'packet_len') div = radar.ofdm_divide_vcvc(vlen,vlen,discarded_carriers,num_sync_words) v2s = blocks.vector_to_stream(8,vlen) snk = blocks.vector_sink_c() self.tb.connect(src0,s2v0,s2ts0) self.tb.connect(src1,s2v1,s2ts1) self.tb.connect((s2ts0,0),(div,0)) self.tb.connect((s2ts1,0),(div,1)) self.tb.connect(div,v2s,snk) self.tb.run () # get ref data discarded_carriers_shift = [0]*len(discarded_carriers) for k in range(len(discarded_carriers)): discarded_carriers_shift[k] = discarded_carriers[k] + vlen/2 ref_data = [0]*test_len for k in range(test_len/vlen): for l in range(vlen): if k < num_sync_words: # do not process sync words with discarded carriers ref_data[vlen*k+l] = in_data0[vlen*k+l]/in_data1[vlen*k+l] else: # process discarded carriers if l in discarded_carriers_shift: # if actual item shall be discarded ref_data[vlen*k+l] = 0 else: # if actual item shall NOT be discarded ref_data[vlen*k+l] = in_data0[vlen*k+l]/in_data1[vlen*k+l] # check data #print "REF" #print ref_data out_data = snk.data() #print "DATA" #print out_data for k in range(len(out_data)): self.assertAlmostEqual(ref_data[k], out_data[k],4)
def __init__(self, M):
gr.hier_block2.__init__(self,
"overlap_serial_to_parallel_cvc",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signature(1, 1, gr.sizeof_gr_complex*M),
)
##################################################
# Parameters
##################################################
self.M = M
##################################################
# Blocks
##################################################
##self.fbmc_vector_reshape_vcvc_1 = fbmc_vector_reshape_vcvc(M/2, M)
##self.fbmc_vector_reshape_vcvc_0 = fbmc_vector_reshape_vcvc(M, M/2)
self.fbmc_vector_copy_vcvc_0 = ofdm.fbmc_vector_copy_vcvc(M/2, 2)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, M/2)
# self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex*M/2, 1)
##################################################
# Connections
##################################################
# self.connect((self.blocks_skiphead_0, 0), (self.fbmc_vector_reshape_vcvc_1, 0))
self.connect((self, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fbmc_vector_copy_vcvc_0, 0))
# self.connect((self.fbmc_vector_copy_vcvc_0, 0), (self, 0))
# self.connect((self.fbmc_vector_copy_vcvc_0, 0), (self.fbmc_vector_reshape_vcvc_0, 0))
# self.connect((self.fbmc_vector_reshape_vcvc_0, 0), (self.blocks_skiphead_0, 0))
# self.connect((self.fbmc_vector_reshape_vcvc_0, 0), (self, 0))
# self.fbmc_vector_copy_vcvc_0 = fbmc.vector_copy_vcvc(M, 2)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_gr_complex*1, M/2)
self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*M/2, 2)
# self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, M)
self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex*M/2, 1)
# ##################################################
# # Connections
# ##################################################
# self.connect((self.blocks_stream_to_vector_0, 0), (self.fbmc_vector_copy_vcvc_0, 0))
# self.connect((self.fbmc_vector_copy_vcvc_0, 0), (self.blocks_vector_to_stream_0, 0))
# # self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_stream_to_vector_0_0, 0))
# self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_skiphead_0, 0))
# self.connect((self.blocks_skiphead_0, 0), (self.blocks_stream_to_vector_0_0, 0))
# # self.connect((self, 0), (self.blocks_stream_to_vector_0, 0))
# self.connect((self.blocks_stream_to_vector_0_0, 0), (self, 0))
self.connect((self.fbmc_vector_copy_vcvc_0, 0),(self.blocks_skiphead_0, 0))
self.connect((self.blocks_skiphead_0, 0), (self.blocks_stream_to_vector_0_0, 0))
# self.connect((self, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_stream_to_vector_0_0, 0), (self, 0))
def __init__(self, n=512):
gr.top_block.__init__(self, "SDR Spectrum Analyzer Server")
##################################################
# Variables
##################################################
self.port = port = 9999
self.gan = gan = 10
self.fc = fc = 99700000
self.ab = ab = 20000000
self.N = N = 1024
self.n = n
self.IP = IP = "192.168.1.103"
self.Antena = Antena = "RX2"
self.ventana = ventana = window.blackmanharris
self.base = base = "exponencial"
##################################################
# Blocks
##################################################
self.src = uhd.usrp_source(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.src.set_samp_rate(ab)
self.src.set_center_freq(fc, 0)
self.src.set_gain(gan, 0)
self.src.set_antenna("RX2", 0)
self.dbm = RadioGIS.dbm()
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(gr.sizeof_float*1, N)
self.blocks_vector_to_stream_1 = blocks.vector_to_stream(gr.sizeof_float*1, N)
self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_float*1, N*n)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, N)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(N)
self.udp_sink_0 = blocks.udp_sink(gr.sizeof_float*1, IP, port, 1472, True)
self.RadioGIS_fft_0 = RadioGIS.fft(N, base, (ventana(N)))
self.RadioGIS_averager_0 = RadioGIS.averager(N, n)
##################################################
# Connections
##################################################
self.connect((self.RadioGIS_averager_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.dbm, 0), (self.udp_sink_0, 0))
self.connect((self.RadioGIS_fft_0, 0), (self.blocks_complex_to_mag_0, 0))
self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_vector_to_stream_1, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.RadioGIS_fft_0, 0))
self.connect((self.blocks_stream_to_vector_1, 0), (self.RadioGIS_averager_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0), (self.dbm, 0))
self.connect((self.blocks_vector_to_stream_1, 0), (self.blocks_stream_to_vector_1, 0))
self.connect((self.src, 0), (self.blocks_stream_to_vector_0, 0))
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Fft To Tcp")
##################################################
# Variables
##################################################
self.veclen = veclen = 8192
self.test = test = 1420e6
self.samp_rate = samp_rate = 1500000
##################################################
# Blocks
##################################################
self.xmlrpc_server_0 = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", 8080), allow_none=True)
self.xmlrpc_server_0.register_instance(self)
threading.Thread(target=self.xmlrpc_server_0.serve_forever).start()
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(test, 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(1, 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.fft_vxx_0 = fft.fft_vcc(veclen, True, (window.blackmanharris(veclen)), True, 1)
self.blocks_stream_to_vector_1 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, samp_rate)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex * 1, veclen)
self.blocks_complex_to_mag_0 = blocks.complex_to_mag(veclen)
self.blks2_tcp_sink_0_0 = grc_blks2.tcp_sink(
itemsize=gr.sizeof_gr_complex * samp_rate, addr="127.0.0.1", port=10002, server=True
)
self.blks2_tcp_sink_0 = grc_blks2.tcp_sink(
itemsize=gr.sizeof_float * veclen, addr="127.0.0.1", port=10001, server=True
)
##################################################
# Connections
##################################################
self.connect((self.blocks_complex_to_mag_0, 0), (self.blks2_tcp_sink_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.blocks_stream_to_vector_1, 0), (self.blks2_tcp_sink_0_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.rtlsdr_source_0, 0), (self.blocks_stream_to_vector_1, 0))
def test_001_diff_phasor_vcc(self): a = [1+2j,2+3.5j,3.5+4j,4+5j,5+6j] b = [1j,1j,1j,1j,1j] c = [-1j+3,1j,-7+0j,2.5j+0.333,3.2j] d = [(0.35979271051026462+0.89414454782483865j), (0.19421665709046287+0.024219594550527801j), (0.12445564785882557+0.40766238899138718j), (0.041869638845043688+0.97860437393366329j), (0.068927762235083234+0.16649764877365247j)] e = [(0.16207552830286298+0.435385030608331j), (0.47195779613669675+0.37824764113272558j), (0.13911998015446148+0.6585095669811617j), (0.093510743358783954+0.98446560079828938j), (0.86036393297704694+0.72043005342024602j)] multconj = lambda x,y: x.conjugate()*y src_data = a+b+c+d+e expected_result = [0j,0j,0j,0j,0j]+map(multconj,a,b)+map(multconj,b,c)+map(multconj,c,d)+map(multconj,d,e) src = blocks.vector_source_c(src_data) s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, 5) diff_phasor_vcc = grdab.diff_phasor_vcc(5) v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, 5) dst = blocks.vector_sink_c() self.tb.connect(src, s2v, diff_phasor_vcc, v2s, dst) self.tb.run() result_data = dst.data() # print expected_result # print result_data self.assertComplexTuplesAlmostEqual(expected_result, result_data, 6)
def __init__(self, n_chans, n_filterbanks=1, taps=None, outchans=None,
atten=100, bw=1.0, tb=0.2, ripple=0.1):
if n_filterbanks > n_chans:
n_filterbanks = n_chans
if outchans is None:
outchans = range(n_chans)
gr.hier_block2.__init__(
self, "pfb_channelizer_hier_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(len(outchans), len(outchans), gr.sizeof_gr_complex))
if taps is None:
taps = optfir.low_pass(1, n_chans, bw, bw+tb, ripple, atten)
taps = list(taps)
extra_taps = int(math.ceil(1.0*len(taps)/n_chans)*n_chans - len(taps))
taps = taps + [0] * extra_taps
# Make taps for each channel
chantaps = [list(reversed(taps[i: len(taps): n_chans])) for i in range(0, n_chans)]
# Convert the input stream into a stream of vectors.
self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, n_chans)
# Create a mapping to separate out each filterbank (a group of channels to be processed together)
# And a list of sets of taps for each filterbank.
low_cpp = int(n_chans/n_filterbanks)
extra = n_chans - low_cpp*n_filterbanks
cpps = [low_cpp+1]*extra + [low_cpp]*(n_filterbanks-extra)
splitter_mapping = []
filterbanktaps = []
total = 0
for cpp in cpps:
splitter_mapping.append([(0, i) for i in range(total, total+cpp)])
filterbanktaps.append(chantaps[total: total+cpp])
total += cpp
assert(total == n_chans)
# Split the stream of vectors in n_filterbanks streams of vectors.
self.splitter = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], splitter_mapping)
# Create the filterbanks
self.fbs = [filter.filterbank_vcvcf(taps) for taps in filterbanktaps]
# Combine the streams of vectors back into a single stream of vectors.
combiner_mapping = [[]]
for i, cpp in enumerate(cpps):
for j in range(cpp):
combiner_mapping[0].append((i, j))
self.combiner = blocks.vector_map(gr.sizeof_gr_complex, cpps, combiner_mapping)
# Add the final FFT to the channelizer.
self.fft = fft.fft_vcc(n_chans, forward=True, window=[1.0]*n_chans)
# Select the desired channels
if outchans != range(n_chans):
selector_mapping = [[(0, i) for i in outchans]]
self.selector = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], selector_mapping)
# Convert stream of vectors to a normal stream.
self.v2ss = blocks.vector_to_streams(gr.sizeof_gr_complex, len(outchans))
self.connect(self, self.s2v, self.splitter)
for i in range(0, n_filterbanks):
self.connect((self.splitter, i), self.fbs[i], (self.combiner, i))
self.connect(self.combiner, self.fft)
if outchans != range(n_chans):
self.connect(self.fft, self.selector, self.v2ss)
else:
self.connect(self.fft, self.v2ss)
for i in range(0, len(outchans)):
self.connect((self.v2ss, i), (self, i))
def test_004(self):
vlen = 4
tune = counter4(self, 1)
tune_delay = 1
dwell_delay = 2
msgq = gr.msg_queue()
src_data = tuple([float(x) for x in
( 1, 2, 3, 4,
9, 6, 11, 8,
5, 10, 7, 12,
13, 14, 15, 16
)])
expected_results = tuple([float(x) for x in
( 9, 10, 11, 12)])
src = blocks.vector_source_f(src_data, False)
s2v = blocks.stream_to_vector(gr.sizeof_float, vlen)
stats = blocks.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay)
self.tb.connect(src, s2v, stats)
self.tb.run()
self.assertEqual(1, msgq.count())
for i in range(1):
m = parse_msg(msgq.delete_head())
#print "m =", m.center_freq, m.data
self.assertEqual(expected_results[vlen*i:vlen*i + vlen], m.data)
def test_001_ofdm_coarse_frequency_correct(self): fft_length = 10 num_carriers = 2 cp_length = 3 src_data0 = [0,1,2,3,4,5,6,7,8,9,1,2,0,5,7,6,0,4,0,6,1,1,1,0.8,0.1,1.3,1,0.7,1,1,0,1,2,3,4,5,6,7,8,9] expected_result0 = [7,9,5,6,0.8,1.3,3,5] offset = [3,3,-1,-1,-1,-1,-1,-1] frame_index = [0,0, 0, 0, 0, 0, 1, 1] expected_result0 = [complex(expected_result0[i])*cmath.exp(-2j*cmath.pi*offset[i]*cp_length/float(fft_length)*frame_index[i]) for i in range(0,8)] src_data1 = [1,1,1,0] expected_result1 = (1,1,1,0) src0 = blocks.vector_source_c(src_data0) src1 = blocks.vector_source_b(src_data1) s2v0 = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_length) ofdm_coarse_frequency_correct = grdab.ofdm_coarse_frequency_correct(fft_length,num_carriers,cp_length) v2s0 = blocks.vector_to_stream(gr.sizeof_gr_complex, num_carriers) dst0 = blocks.vector_sink_c() dst1 = blocks.vector_sink_b() self.tb.connect(src0, s2v0, (ofdm_coarse_frequency_correct,0)) self.tb.connect(src1, (ofdm_coarse_frequency_correct,1)) self.tb.connect((ofdm_coarse_frequency_correct,0), v2s0, dst0) self.tb.connect((ofdm_coarse_frequency_correct,1), dst1) self.tb.run() result_data0 = dst0.data() result_data1 = dst1.data() # print expected_result0 # print result_data0 self.assertComplexTuplesAlmostEqual(expected_result0, result_data0, 4) self.assertEqual(result_data1, expected_result1)
def test_03(self):
tb = self.tb
vlen = 5
N = 10*vlen
seed = 0
data = make_random_float_tuple(N, 2**10)
data = [int(d*1000) for d in data]
src = blocks.vector_source_i(data, False)
one_to_many = blocks.stream_to_streams(gr.sizeof_int, vlen)
one_to_vector = blocks.stream_to_vector(gr.sizeof_int, vlen)
many_to_vector = blocks.streams_to_vector(gr.sizeof_int, vlen)
isolated = [ blocks.moving_average_ii(100, 1) for i in range(vlen)]
dut = blocks.moving_average_ii(100, 1, vlen=vlen)
dut_dst = blocks.vector_sink_i(vlen=vlen)
ref_dst = blocks.vector_sink_i(vlen=vlen)
tb.connect(src, one_to_many)
tb.connect(src, one_to_vector, dut, dut_dst)
tb.connect(many_to_vector, ref_dst)
for idx, single in enumerate(isolated):
tb.connect((one_to_many,idx), single, (many_to_vector,idx))
tb.run()
dut_data = dut_dst.data()
ref_data = ref_dst.data()
# make sure result is close to zero
self.assertTupleEqual(dut_data, ref_data)
def test_001_t (self): # set up fg # check samples on output test_len = 12 in_data = range(test_len) vlen_in = 3 vlen_out = 4 src = blocks.vector_source_c(in_data) stv = blocks.stream_to_vector(8,vlen_in) s2ts = blocks.stream_to_tagged_stream(8,vlen_in,test_len/vlen_in,'packet_len') transpose = radar.transpose_matrix_vcvc(vlen_in,vlen_out,'packet_len') vts = blocks.vector_to_stream(8,vlen_out) snk = blocks.vector_sink_c() self.tb.connect(src,stv,s2ts,transpose,vts,snk) self.tb.run() # check data out_data = snk.data() ref_data = [0]*len(in_data) counter = 0; for k in range(vlen_in): for l in range(test_len/vlen_in): ref_data[counter] = in_data[l*vlen_in+k] counter = counter+1 out_data_real = [0]*len(in_data) for k in range(len(in_data)): out_data_real[k] = out_data[k].real for k in range(len(out_data_real)): self.assertEqual(out_data_real[k],ref_data[k])
def test_002_ofdm_remove_first_symbol_vcc(self): src_data0 = (0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7) src_data1 = (1,0,0,1,0,0) expected_result0 = (3,4,5,6,7,8,2,3,4,5,6,7) expected_result0 = [x+0j for x in expected_result0] expected_result1 = (1,0,1,0) src0 = blocks.vector_source_c(src_data0) src1 = blocks.vector_source_b(src_data1) s2v0 = blocks.stream_to_vector(gr.sizeof_gr_complex,3) ofdm_remove_first_symbol = grdab.ofdm_remove_first_symbol_vcc(3) v2s0 = blocks.vector_to_stream(gr.sizeof_gr_complex,3) dst0 = blocks.vector_sink_c() dst1 = blocks.vector_sink_b() self.tb.connect(src0, s2v0, (ofdm_remove_first_symbol,0)) self.tb.connect(src1, (ofdm_remove_first_symbol,1)) self.tb.connect((ofdm_remove_first_symbol,0), v2s0, dst0) self.tb.connect((ofdm_remove_first_symbol,1), dst1) self.tb.run() result_data0 = dst0.data() result_data1 = dst1.data() # print src_data0 # print expected_result0 # print result_data0 self.assertComplexTuplesAlmostEqual(expected_result0, result_data0, 6) self.assertEqual(result_data1, expected_result1)
def test_003_t (self):
vec_len = 3
my_select = 2
src_data = (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,1.0,10.0,100.0)
expected_result = (3.0,6.0,9.0,100.0)
src = blocks.vector_source_f(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_float, vec_len)
blk = testblocks.vec_select(vec_len, my_select)
dst = blocks.vector_sink_f()
blk.set_select(3)
self.tb.connect(src, s2v)
self.tb.connect(s2v, blk)
self.tb.connect(blk, dst)
self.tb.run()
result_data = dst.data()
print "T3 Source: "
print str(src_data).strip('[]')
print "T3 Expected Results: "
print str(expected_result).strip('[]')
print "T3 Results: "
print str(result_data).strip('[]')
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_003_t (self): # test fft against gnuradio fft # set up fg test_len = 1024*2 packet_len = test_len samp_rate = 2000 frequency = (100,100) amplitude = 1 src = radar.signal_generator_cw_c(packet_len,samp_rate,frequency,amplitude) head = blocks.head(8,test_len) tsfft = radar.ts_fft_cc(packet_len) snk1 = blocks.vector_sink_c() self.tb.connect(src,head,tsfft,snk1) s2v = blocks.stream_to_vector(8, packet_len) fft_inbuild = fft.fft_vcc(test_len,True,fft.window_rectangular(0)) snk2 = blocks.vector_sink_c() v2s = blocks.vector_to_stream(8, packet_len); self.tb.connect(head,s2v,fft_inbuild,v2s,snk2) self.tb.run() # compaire ffts data_tsfft = snk1.data() data_fft_inbuild = snk2.data() self.assertComplexTuplesAlmostEqual(data_tsfft,data_fft_inbuild,2) # compare inbuild fft and fft from block
def __init__(self, fft_size, mavg_size, ed_threshold):
"""
CTOR
@param fft_size FFT Size
@param mavg_size Energy Detector mavg size.
"""
gr.hier_block2.__init__(
self,
name="simple_ranking_detector",
input_signature=gr.io_signature(1, 1, gr.sizeof_gr_complex),
output_signature=gr.io_signature(2, 2, gr.sizeof_float),
)
# Blocks
# Convert the output of a FFT
self.s2v_0 = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_size)
self.fft_0 = fft.fft_vcc(fft_size, True, [])
self.c2mag_0 = blocks.complex_to_mag_squared(fft_size)
# Instantiate the energy calculator
from sensing import EnergyDecision
self.ql = QLearningWorker(fft_size, algorithm=EnergyDecision(ed_threshold))
#::TODO:: parece que nao tem mais o metodo connect
# Flow graph
self.connect(self, self.s2v_0, self.fft_0, self.c2mag_0, self.ql)
self.connect((self.ql, 0), (self, 0))
self.connect((self.ql, 1), (self, 1))
def __init__(self, fft_len, rate, sample_rate):
gr.hier_block2.__init__(self,
"psd_logger",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(0,0,0))
self.fft_len = fft_len
self.rate = rate
self.sample_rate = sample_rate
self.msgq = gr.msg_queue(2)
self.log_file = open('/tmp/psd_log'+'-'+ time.strftime("%y%m%d") + '-' + time.strftime("%H%M%S"),'w')
self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len,
max(1, int(self.sample_rate/self.fft_len/self.rate)))
mywindow = window.blackmanharris(self.fft_len)
self.fft = fft.fft_vcc(self.fft_len, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
self.c2mag = blocks.complex_to_mag(self.fft_len)
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.sink)
self._watcher = _queue_watcher(self.msgq, self.log_file)
def run_flow_graph(sync_sym1, sync_sym2, data_sym):
top_block = gr.top_block()
carr_offset = random.randint(-max_offset/2, max_offset/2) * 2
tx_data = shift_tuple(sync_sym1, carr_offset) + \
shift_tuple(sync_sym2, carr_offset) + \
shift_tuple(data_sym, carr_offset)
channel = [rand_range(min_chan_ampl, max_chan_ampl) * numpy.exp(1j * rand_range(0, 2 * numpy.pi)) for x in range(fft_len)]
src = blocks.vector_source_c(tx_data, False, fft_len)
chan = blocks.multiply_const_vcc(channel)
noise = analog.noise_source_c(analog.GR_GAUSSIAN, wgn_amplitude)
add = blocks.add_cc(fft_len)
chanest = digital.ofdm_chanest_vcvc(sync_sym1, sync_sym2, 1)
sink = blocks.vector_sink_c(fft_len)
top_block.connect(src, chan, (add, 0), chanest, sink)
top_block.connect(noise, blocks.stream_to_vector(gr.sizeof_gr_complex, fft_len), (add, 1))
top_block.run()
channel_est = None
carr_offset_hat = 0
rx_sym_est = [0,] * fft_len
tags = sink.tags()
for tag in tags:
if pmt.symbol_to_string(tag.key) == 'ofdm_sync_carr_offset':
carr_offset_hat = pmt.to_long(tag.value)
self.assertEqual(carr_offset, carr_offset_hat)
if pmt.symbol_to_string(tag.key) == 'ofdm_sync_chan_taps':
channel_est = shift_tuple(pmt.c32vector_elements(tag.value), carr_offset)
shifted_carrier_mask = shift_tuple(carrier_mask, carr_offset)
for i in range(fft_len):
if shifted_carrier_mask[i] and channel_est[i]:
self.assertAlmostEqual(channel[i], channel_est[i], places=0)
rx_sym_est[i] = (sink.data()[i] / channel_est[i]).real
return (carr_offset, list(shift_tuple(rx_sym_est, -carr_offset_hat)))
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 2.4e6 ################################################## # Blocks ################################################## self.howto_spectrum_sensing_cf_0 = howto.spectrum_sensing_cf(samp_rate,2048,16,0.001,0.0001,1.9528,True,True,0,200000.0,False,3,4,1,6) self.gr_null_sink_0 = gr.null_sink(gr.sizeof_float*1) self.fft_vxx_0 = fft.fft_vcc(2048, True, (window.blackmanharris(1024)), False, 1) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, 2048) self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 1000, 1, 0) ################################################## # Connections ################################################## self.connect((self.fft_vxx_0, 0), (self.howto_spectrum_sensing_cf_0, 0)) self.connect((self.howto_spectrum_sensing_cf_0, 0), (self.gr_null_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0)) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_stream_to_vector_0, 0))
def test_002_t (self): # set up fg # check on reverse by using two times test_len = 12 in_data = range(test_len) vlen_in = 3 vlen_out = 4 src = blocks.vector_source_c(in_data) stv = blocks.stream_to_vector(8,vlen_in) s2ts = blocks.stream_to_tagged_stream(8,vlen_in,test_len/vlen_in,'packet_len') transpose1 = radar.transpose_matrix_vcvc(vlen_in,vlen_out,'packet_len') transpose2 = radar.transpose_matrix_vcvc(vlen_out,vlen_in,'packet_len') vts = blocks.vector_to_stream(8,vlen_in) snk = blocks.vector_sink_c() vts2 = blocks.vector_to_stream(8,vlen_out) snk2 = blocks.vector_sink_c() self.tb.connect(src,stv,s2ts,transpose1,transpose2,vts,snk) self.tb.connect(transpose1,vts2,snk2) self.tb.run() # check data out_data_real = [0]*len(in_data) out_data = snk.data() for k in range(len(in_data)): out_data_real[k] = out_data[k].real print "Input data:", in_data print "Output data:", out_data_real print "Transpose data:", snk2.data() for k in range(len(out_data_real)): self.assertEqual(out_data_real[k],in_data[k])
def __init__(self, size, factor, migrate=None): ''' size: (int) vector size (FFT size) of next block factor: (int) output will have this many more samples than input If size is not divisible by factor, then the output will necessarily have jitter. ''' size = int(size) factor = int(factor) # assert size % factor == 0 offset = size // factor gr.hier_block2.__init__( self, self.__class__.__name__, gr.io_signature(1, 1, self.__element), gr.io_signature(1, 1, self.__element), ) if factor == 1: # No duplication needed; simplify flowgraph # GR refused to connect self to self, so insert a dummy block self.connect(self, blocks.copy(self.__element), self) else: interleave = blocks.interleave(self.__element * size) self.connect( interleave, blocks.vector_to_stream(self.__element, size), self) for i in xrange(0, factor): self.connect( self, blocks.delay(self.__element, (factor - 1 - i) * offset), blocks.stream_to_vector(self.__element, size), (interleave, i))
def device_definition(options):
"""
Definition of the devices used in the program.
@param options
"""
tb = OpERAFlow(name='US')
the_source = blocks.file_source(gr.sizeof_gr_complex, "./%d_%d_%d_%d_noise.bin" % (options.fft_length, options.cp_length, options.ebn0, options.it), False)
radio = RadioDevice(name="radio")
det = Correlator()
middle = gr.hier_block2(
name='hier',
input_signature = gr.io_signature(1, 1, gr.sizeof_gr_complex),
output_signature = gr.io_signature(1, 1, gr.sizeof_float * 1024),
)
middle.connect(middle, blocks.stream_to_vector(gr.sizeof_gr_complex, 1024), blocks.complex_to_mag(1024), middle)
ed = EnergySSArch(1024, 1, EnergyDecision(th = options.threshold))
radio.add_arch(source = the_source, arch = middle, sink =(det,0), uhd_device=the_source, name='estimator')
radio.add_arch(source = the_source, arch = ed, sink =(det,1), uhd_device=the_source, name = "ed")
tb.add_radio(radio, "radio")
return tb, radio, det
def __init__(self, parent, baseband_freq=0,
y_per_div=10, ref_level=50, sample_rate=1, fft_size=512,
fft_rate=default_fft_rate, average=False, avg_alpha=None,
title='', size=default_fftsink_size, **kwargs):
gr.hier_block2.__init__(self, "waterfall_sink_f",
gr.io_signature(1, 1, gr.sizeof_float),
gr.io_signature(0,0,0))
waterfall_sink_base.__init__(self, input_is_real=True, baseband_freq=baseband_freq,
sample_rate=sample_rate, fft_size=fft_size,
fft_rate=fft_rate,
average=average, avg_alpha=avg_alpha, title=title)
self.s2p = blocks.stream_to_vector(gr.sizeof_float, self.fft_size)
self.one_in_n = blocks.keep_one_in_n(gr.sizeof_float * self.fft_size,
max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
mywindow = window.blackmanharris(self.fft_size)
self.fft = fft.fft_vfc(self.fft_size, True, mywindow)
self.c2mag = blocks.complex_to_mag(self.fft_size)
self.avg = filter.single_pole_iir_filter_ff(1.0, self.fft_size)
self.log = blocks.nlog10_ff(20, self.fft_size, -20*math.log10(self.fft_size))
self.sink = blocks.message_sink(gr.sizeof_float * self.fft_size, self.msgq, True)
self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag, self.avg, self.log, self.sink)
self.win = waterfall_window(self, parent, size=size)
self.set_average(self.average)
def __init__(self, fft_len, sample_rate, tune_freq, average, rate, length, height): gr.hier_block2.__init__(self, "ascii plot", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(0,0,0)) self.fft_len = fft_len self.sample_rate = sample_rate self.average = average self.tune_freq = tune_freq self.rate = rate self.length = length self.height = height self.msgq = gr.msg_queue(2) #######BLOCKS##### self.s2p = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_len) self.one_in_n = blocks.keep_one_in_n(gr.sizeof_gr_complex * self.fft_len, max(1, int(self.sample_rate/self.fft_len/self.rate))) mywindow = window.blackmanharris(self.fft_len) self.fft = fft.fft_vcc(self.fft_len, True, (), True) self.c2mag2 = blocks.complex_to_mag_squared(self.fft_len) self.avg = grfilter.single_pole_iir_filter_ff(1.0, self.fft_len) self.log = blocks.nlog10_ff(10, self.fft_len, -10*math.log10(self.fft_len) # Adjust for number of bins -10*math.log10(self.sample_rate)) # Adjust for sample rate self.sink = blocks.message_sink(gr.sizeof_float * self.fft_len, self.msgq, True) #####CONNECTIONS#### self.connect(self, self.s2p, self.one_in_n, self.fft, self.c2mag2, self.avg, self.log, self.sink) self._main = main_thread(self.msgq, self.fft_len, self.sample_rate, self.tune_freq, self.length, self.height)
def test_002_t (self): # set up fg in_data = range(20) vlen_in = 5 crop_x = (2,4) crop_y = (1,4) src = blocks.vector_source_c(in_data) s2v = blocks.stream_to_vector(8,vlen_in) s2ts = blocks.stream_to_tagged_stream(8,vlen_in,len(in_data)/vlen_in,'packet_len') crop = radar.crop_matrix_vcvc(vlen_in,crop_x,crop_y) v2s = blocks.vector_to_stream(8,crop_x[1]-crop_x[0]) snk = blocks.vector_sink_c() debug = blocks.tag_debug(8,'debug') self.tb.connect(src,s2v,s2ts,crop,v2s,snk) self.tb.connect(v2s,debug) self.tb.run () # check data ref_data = (7,8,12,13,17,18) out_data = snk.data() print "INDATA:", in_data print "REF: ", ref_data print "OUTPUT:", out_data for k in range(len(out_data)): self.assertEqual(out_data[k].real,ref_data[k])
def __init__(self, samp_rate=1000, vecsize=500, folding=5, pulse_rate=0.7477): gr.hier_block2.__init__( self, "Synch Folder2", gr.io_signature(1, 1, gr.sizeof_float*1), gr.io_signature(1, 1, gr.sizeof_float*vecsize), ) ################################################## # Parameters ################################################## self.samp_rate = samp_rate self.vecsize = vecsize self.folding = folding self.pulse_rate = pulse_rate ################################################## # Blocks ################################################## self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(1.0/folding, vecsize) self.fractional_resampler_xx_0 = filter.fractional_resampler_ff(0, float(samp_rate)/(float(pulse_rate)*float(vecsize))) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_float*1, vecsize) ################################################## # Connections ################################################## self.connect((self.blocks_stream_to_vector_0, 0), (self.single_pole_iir_filter_xx_0, 0)) self.connect((self.fractional_resampler_xx_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self, 0), (self.fractional_resampler_xx_0, 0)) self.connect((self.single_pole_iir_filter_xx_0, 0), (self, 0))
def test_001(self):
src_data = (0, 0.2, -0.25, 0, 12, 0)
expected_result = (float(min(src_data)),)
src = blocks.vector_source_f(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data))
op = blocks.min_ff(len(src_data))
dst = blocks.vector_sink_f()
self.tb.connect(src, s2v, op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def help_cc(self, size, src_data, exp_data, op):
for s in zip(list(range(len(src_data))), src_data):
src = blocks.vector_source_c(s[1])
srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, size)
self.tb.connect(src, srcv)
self.tb.connect(srcv, (op, s[0]))
rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, size)
dst = blocks.vector_sink_c()
self.tb.connect(op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_002_unpuncture_vff(self):
src_data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
punc_seq = (1, 0, 0, 0, 1, 0, 1, 1, 1)
exp_res = (0, 0, 0, 0, 1, 0, 2, 3, 4, 5, 0, 0, 0, 6, 0, 7, 8, 9)
src = blocks.vector_source_f(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_float, 5)
unpuncture_vff = dab.unpuncture_vff(punc_seq)
v2s = blocks.vector_to_stream(gr.sizeof_float, 9)
dst = blocks.vector_sink_f()
self.tb.connect(src, s2v, unpuncture_vff, v2s, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(exp_res, result_data)
def stest_s001(self):
src_data = (0, 2, -3, 0, 12, 0)
expected_result = (min(src_data),)
src = blocks.vector_source_s(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_short,len(src_data))
op = blocks.min_ss(len(src_data))
dst = blocks.vector_sink_s()
self.tb.connect(src, s2v, op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_001(self):
tb = self.tb
src1_data = [0, 0.2, -0.3, 0, 12, 0]
src2_data = [0, 0.0, 3.0, 0, 10, 0]
src3_data = [0, 0.0, 3.0, 0, 1, 0]
src1 = blocks.vector_source_f(src1_data)
s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src1, s2v1)
src2 = blocks.vector_source_f(src2_data)
s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src2, s2v2)
src3 = blocks.vector_source_f(src3_data)
s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src3, s2v3)
dst1 = blocks.vector_sink_s()
dst2 = blocks.vector_sink_s()
argmax = blocks.argmax_fs(len(src1_data))
tb.connect(s2v1, (argmax, 0))
tb.connect(s2v2, (argmax, 1))
tb.connect(s2v3, (argmax, 2))
tb.connect((argmax, 0), dst1)
tb.connect((argmax, 1), dst2)
tb.run()
index = dst1.data()
source = dst2.data()
self.assertEqual(index, [
4,
])
self.assertEqual(source, [
0,
])
def setUp(self):
self.tb = gr.top_block()
print "begin setup"
key = "descr_part"
self.src = blocks.vector_source_f([0.0] * 480, False, 480)
self.rpt = blocks.repeat(gr.sizeof_float * 480, 4)
self.stv = blocks.stream_to_vector(gr.sizeof_float * 480, 4)
self.descr = lte.pbch_descrambler_vfvf(key)
self.snk = blocks.vector_sink_f(120)
self.tb.connect(self.src, self.rpt, self.stv, self.descr, self.snk)
print "end setup"
def test_001_correct_individual_phase_offset_vff(self):
expected_result = [x * pi / 2 + pi / 4 for x in [1, -2, -1, 0, 1, -2]]
src_data = map(lambda x, y: x + y, expected_result,
[0.1, 0.3, -0.2, 0.2, 0.4, 0.1])
src = blocks.vector_source_f(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_float, 3)
mut = grdab.correct_individual_phase_offset_vff(3, 1)
v2s = blocks.vector_to_stream(gr.sizeof_float, 3)
dst = blocks.vector_sink_f()
self.tb.connect(src, s2v, mut, v2s, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
def stest_002(self):
src_data=(-100,-99,-98,-97,-96,-1)
expected_result = (float(min(src_data)),)
src = blocks.vector_source_f(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data))
op = blocks.min_ff(len(src_data))
dst = blocks.vector_sink_f()
self.tb.connect(src, s2v, op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def stest_s002(self):
src_data=(-100,-99,-98,-97,-96,-1)
expected_result = (max(src_data),)
src = blocks.vector_source_s(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_short, len(src_data))
op = blocks.max_ss(len(src_data))
dst = blocks.vector_sink_s()
self.tb.connect(src, s2v, op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_ff_003(self):
block_size = 2
src_data = (0, 1000, 2000, 3000, 4000, 5000)
expected_result = (0, 125, 250, 484.375, 718.75, 1048.828125)
src = blocks.vector_source_f(src_data)
s2p = blocks.stream_to_vector(gr.sizeof_float, block_size)
op = filter.single_pole_iir_filter_ff(0.125, block_size)
p2s = blocks.vector_to_stream(gr.sizeof_float, block_size)
dst = blocks.vector_sink_f()
self.tb.connect(src, s2p, op, p2s, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 3)
def __init__(self):
gr.top_block.__init__(self, "Salsa Eceiver")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 5000000.0
self.outfile = outfile = "/tmp/vale.dat"
self.int_time = int_time = 10
self.gain = gain = 60
self.fftsize = fftsize = 4096
self.c_freq = c_freq = 1420.4e6
##################################################
# Blocks
##################################################
self.uhd_usrp_source_0 = uhd.usrp_source(
device_addr="addr=192.168.10.2",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_source_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0.set_center_freq(c_freq, 0)
self.uhd_usrp_source_0.set_gain(gain, 0)
self.fft_vxx_0 = fft.fft_vcc(fftsize, True,
(window.blackmanharris(fftsize)), True, 1)
self.blocks_vector_to_stream_0 = blocks.vector_to_stream(
gr.sizeof_gr_complex * 1, fftsize)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(
gr.sizeof_gr_complex * 1, fftsize)
self.blocks_head_0 = blocks.head(gr.sizeof_float * 1,
int(int_time * samp_rate))
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float * 1,
outfile, False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(1)
##################################################
# Connections
##################################################
self.connect((self.fft_vxx_0, 0), (self.blocks_vector_to_stream_0, 0))
self.connect((self.uhd_usrp_source_0, 0),
(self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_vector_to_stream_0, 0),
(self.blocks_complex_to_mag_squared_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0),
(self.blocks_head_0, 0))
self.connect((self.blocks_head_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
def __init__(self):
gr.top_block.__init__(self)
################################################
### EL FLUJOGRAMA ###
################################################
# Las variables usadas en el flujograma
samp_rate = 11025
N = 1024
Sps = 6
ntaps = 6 * 6
beta = 0
# respuesta al impulso
#h=misbloques.rect(Sps) # forma rectangular
#h=misbloques.nyq(Sps,ntaps) # forma sinc
#h=misbloques.rcos(Sps,ntaps,beta) # forma coseno alzado
#h=misbloques.rrcos(Sps,ntaps,beta) # forma raiz coseno alzado
#h=misbloques.B_NRZ_L(Sps) # forma NRZ_L
#h=misbloques.RZ(Sps) # forma RZ
h = misbloques.saw(Sps) # forma saw
# Los bloques
p_fuente = misbloques.e_generador_fun_f(Sps, h)
p_pantalla_t = qtgui.time_sink_f(
512, # numero de muestras en la ventana del osciloscopio
samp_rate,
"senal promediada", # nombre que aparece en la grafica
1 # Nuemero de entradas del osciloscopio
)
p_chorro_a_vector = blocks.stream_to_vector(gr.sizeof_float * 1, N)
p_psd = misbloques.e_vector_psd_ff(N, 2000000)
p_pantalla_vectorial = qtgui.vector_sink_f(
N,
-samp_rate / 2.,
samp_rate / N,
"frecuencia",
"Magnitud",
"PSD",
1 # Number of inputs
)
p_pantalla_vectorial.enable_autoscale(True)
# LAS CONEXIONES
self.connect(p_fuente, p_pantalla_t)
self.connect(p_fuente, p_chorro_a_vector, p_psd, p_pantalla_vectorial)
# La configuracion para graficar
pyobj = sip.wrapinstance(p_pantalla_vectorial.pyqwidget(), Qt.QWidget)
pyobj1 = sip.wrapinstance(p_pantalla_t.pyqwidget(), Qt.QWidget)
pyobj.show()
pyobj1.show()
def test_001_t(self):
vsize = 2048
vin = numpy.zeros(vsize)
for i in range(vsize):
vin[i] = float(i)
# create a set of vectors
src = blocks.vector_source_f(vin.tolist(), False)
s2v = blocks.stream_to_vector(gr.sizeof_float, vsize)
# parameters we're setting
frequency = 1419.5E6
bandwidth = 6.E6
azimuth = 179.9
elevation = 44.9
observers = "Science Aficionados"
setupFile = "Watch.not"
site = "Moumau House"
device = "rtlsdr,bias=0"
device = "airspy,pack=1,bias=1"
obstype = radioastronomy.OBSSURVEY
record = radioastronomy.INTRECORD
nmedian = 4**6
nave = 10
gain1 = 40.5
gain2 = 11.0
gain3 = 11.0
# block we're testing
vblock = ra_ascii_sink(setupFile, observers, vsize, frequency,
bandwidth, azimuth, elevation, record, obstype,
nmedian, nave, site, device, gain1, gain2,
gain3)
print 'Test init DataDir: ', vblock.obs.datadir
# skip writing the notes file over and over
dosave = False
# now set all parameters
vblock.set_frequency(frequency, dosave)
vblock.set_bandwidth(bandwidth, dosave)
vblock.set_azimuth(azimuth, dosave)
vblock.set_elevation(elevation, dosave)
vblock.set_nmedian(nmedian, dosave)
vblock.set_gain1(gain1, dosave)
vblock.set_gain2(gain2, dosave)
vblock.set_gain3(gain3, dosave)
vblock.set_record(record)
self.tb.connect(src, s2v)
self.tb.connect(s2v, vblock)
self.tb.run()
vblock.set_record(radioastronomy.INTWAIT)
self.tb.run()
def test_004_connect (self):
"""
Advanced test:
- Allocator -> IFFT -> Frequency offset -> FFT -> Serializer
- FFT does shift (moves DC to middle)
- Make sure input == output
- Frequency offset is -2 carriers
"""
fft_len = 8
n_syms = 1
carr_offset = -2
freq_offset = 1.0 / fft_len * carr_offset # Normalized frequency
occupied_carriers = ((-2, -1, 1, 2),)
pilot_carriers = ((-3,),(3,))
pilot_symbols = ((1j,),(-1j,))
tx_data = (1, 2, 3, 4)
tag_name = "len"
tag = gr.tag_t()
tag.offset = 0
tag.key = pmt.string_to_symbol(tag_name)
tag.value = pmt.from_long(len(tx_data))
offsettag = gr.tag_t()
offsettag.offset = 0
offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset")
offsettag.value = pmt.from_long(carr_offset)
src = blocks.vector_source_c(tx_data, False, 1, (tag, offsettag))
alloc = digital.ofdm_carrier_allocator_cvc(fft_len,
occupied_carriers,
pilot_carriers,
pilot_symbols, (),
tag_name)
tx_ifft = fft.fft_vcc(fft_len, False, (1.0/fft_len,)*fft_len, True)
oscillator = analog.sig_source_c(1.0, analog.GR_COS_WAVE, freq_offset, 1.0)
mixer = blocks.multiply_cc()
rx_fft = fft.fft_vcc(fft_len, True, (), True)
sink2 = blocks.vector_sink_c(fft_len)
self.tb.connect(rx_fft, sink2)
serializer = digital.ofdm_serializer_vcc(
alloc, "", 0, "ofdm_sync_carr_offset", True
)
sink = blocks.vector_sink_c()
self.tb.connect(
src, alloc, tx_ifft,
blocks.vector_to_stream(gr.sizeof_gr_complex, fft_len),
(mixer, 0),
blocks.stream_to_vector(gr.sizeof_gr_complex, fft_len),
rx_fft, serializer, sink
)
self.tb.connect(oscillator, (mixer, 1))
self.tb.run ()
self.assertComplexTuplesAlmostEqual(sink.data()[-len(occupied_carriers[0]):], tx_data, places=4)
def fft_channelizer( self, fft_len, channel_bins):
#do a fwd fft
self.fft_channelizer_s2v = blocks.stream_to_vector( gr.sizeof_gr_complex*1, fft_len)
self.fft_channelizer_fft_fwd = fft.fft_vcc( fft_len, True, (window.blackmanharris(1024)), True, 1)
self.fft_channelizer_v2s = blocks.vector_to_stream( gr.sizeof_gr_complex*1, fft_len)
self.connect( self.fft_channelizer_s2v,
self.fft_channelizer_fft_fwd,
self.fft_channelizer_v2s)
#per channel
self.fft_channelizer_skiphead = []
self.fft_channelizer_keep_m_in_n = []
self.fft_channelizer_stream2vector = []
self.fft_channelizer_multiply_const = []
self.fft_channelizer_fft_rev = []
self.fft_channelizer_vector2stream = []
for from_bin, to_bin in channel_bins:
#output samp rate: samp_rate / (fft_len/keep)
keep = to_bin - from_bin
fft_channelizer_taps = taps.taps(keep)
self.fft_channelizer_skiphead.append( blocks.skiphead(gr.sizeof_gr_complex*1, from_bin))
self.fft_channelizer_keep_m_in_n.append( blocks.keep_m_in_n(gr.sizeof_gr_complex, keep, fft_len, 0))
self.fft_channelizer_stream2vector.append( blocks.stream_to_vector(gr.sizeof_gr_complex*1, keep))
self.fft_channelizer_multiply_const.append( blocks.multiply_const_vcc(fft_channelizer_taps))
self.fft_channelizer_fft_rev.append( fft.fft_vcc( keep, False, (window.blackmanharris(1024)), True, 1))
self.fft_channelizer_vector2stream.append( blocks.vector_to_stream( gr.sizeof_gr_complex*1, keep))
self.connect( self.fft_channelizer_v2s,
self.fft_channelizer_skiphead[-1],
self.fft_channelizer_keep_m_in_n[-1],
self.fft_channelizer_stream2vector[-1],
self.fft_channelizer_multiply_const[-1],
self.fft_channelizer_fft_rev[-1],
self.fft_channelizer_vector2stream[-1])
return self.fft_channelizer_s2v, self.fft_channelizer_vector2stream
def test_001_puncture_vbb(self):
src_data = (0, 77, 78, 78, 1, 80, 2, 3, 4, 5, 81, 82, 83, 6, 84, 7, 8,
9)
punc_seq = (1, 0, 0, 0, 1, 0, 1, 1, 1)
exp_res = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
src = blocks.vector_source_b(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_char, 9)
puncture_vbb = dab.puncture_vbb(punc_seq)
v2s = blocks.vector_to_stream(gr.sizeof_char, 5)
dst = blocks.vector_sink_b()
self.tb.connect(src, s2v, puncture_vbb, v2s, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_res, result_data)
def test_002_t(self):
vector01 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
expected_result = (1, 0, 0, 0, 5, 0, 0, 4, 9, 0, 3, 8, 13, 2, 7, 12)
src = blocks.vector_source_b(vector01, True)
s2v = blocks.stream_to_vector(gr.sizeof_char, 4)
time_interleaver = dab.time_interleave_bb(4, [0, 3, 2, 1])
v2s = blocks.vector_to_stream(gr.sizeof_char, 4)
dst = blocks.vector_sink_b()
self.tb.connect(src, s2v, time_interleaver,
blocks.head_make(gr.sizeof_char * 4, 4), v2s, dst)
self.tb.run()
result = dst.data()
#print result
self.assertEqual(expected_result, result)
def stest_004(self):
dim = 2
src_data0 = (0, 2, -3, 0, 12, 0)
src_data1 = (1, 1, 1, 1, 1, 1)
expected_data = []
tmp = [float(max(x, y)) for x, y in zip(src_data0, src_data1)]
for i in range(len(tmp) / dim):
expected_data.append(float(max(tmp[i * dim:(i + 1) * dim])))
src0 = blocks.vector_source_f(src_data0)
s2v0 = blocks.stream_to_vector(gr.sizeof_float, dim)
src1 = blocks.vector_source_f(src_data1)
s2v1 = blocks.stream_to_vector(gr.sizeof_float, dim)
op = blocks.max_ff(dim)
dst = blocks.vector_sink_f()
self.tb.connect(src0, s2v0, (op, 0))
self.tb.connect(src1, s2v1, (op, 1))
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_002_prune_vectors(self):
src_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
expected_result = [3, 4, 8, 9, 13, 14]
src = blocks.vector_source_b(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_char, 5)
prune_vectors = dab.prune_vectors(gr.sizeof_char, 5, 2, 1)
v2s = blocks.vector_to_stream(gr.sizeof_char, 2)
dst = blocks.vector_sink_b()
self.tb.connect(src, s2v, prune_vectors, v2s, dst)
self.tb.run()
result_data = dst.data()
# print expected_result
# print result_data
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_001_t (self):
vsize = 2048
# setup for random distribution of samples with zero mean
mu = 0.
sigma = 0.01
nsigma = 3.
vtest = vsize/8
vreal = np.random.normal( mu, sigma, vsize)
vimg = np.random.normal( mu, sigma, vsize)
vcomplex = (1j*vimg) + vreal
# create a set of vectors
src = blocks.vector_source_c( vcomplex.tolist(), False)
snk1 = blocks.stream_to_vector(gr.sizeof_float, vsize)
snk2 = blocks.stream_to_vector(gr.sizeof_float, vsize)
# parameters we're setting
bandwidth = 6.E6
setupFile = "Watch.not"
eventblock = ra_event( vtest, nsigma, bandwidth, setupFile)
self.tb.connect (src, eventblock)
self.tb.connect (eventblock, snk1, 0)
self.tb.connect (eventblock, snk2, 1)
self.tb.run ()
def test_004_t(self):
vector01 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
expected_result = (0,0,0,4,0,0,0,8,0,0,0,12,0,0,0,16,0,0,3,4,0,0,7,8,0,0,11,12,0,0,15,16)
src = blocks.vector_source_b(vector01, True)
b2f = blocks.char_to_float_make()
s2v = blocks.stream_to_vector(gr.sizeof_float, 16)
time_deinterleaver = dab.time_deinterleave_ff_make(16, [0, 1, 2, 4])
v2s = blocks.vector_to_stream(gr.sizeof_float, 16)
dst = blocks.vector_sink_f()
self.tb.connect(src, b2f, time_deinterleaver, blocks.head_make(gr.sizeof_float, 16*2), dst)
self.tb.run()
result = dst.data()
#print result
self.assertEqual(expected_result, result)
def test_002_t(self):
vector01 = (1, 0, 0, 0, 5, 4, 0, 0, 9, 8, 3, 0, 13, 12, 7, 2)
expected_result = (0, 0, 0, 0, 0, 4, 0, 0, 0, 8, 0, 0, 1, 12, 3, 0)
src = blocks.vector_source_b(vector01, True)
b2f = blocks.char_to_float_make()
s2v = blocks.stream_to_vector(gr.sizeof_float, 4)
time_deinterleaver = dab.time_deinterleave_ff_make(4, [0, 3, 2, 1])
v2s = blocks.vector_to_stream(gr.sizeof_float, 4)
dst = blocks.vector_sink_f()
self.tb.connect(src, b2f, time_deinterleaver, blocks.head_make(gr.sizeof_float, 4*4), dst)
self.tb.run()
result = dst.data()
#print result
self.assertEqual(expected_result, result)
def stest_s004(self):
dim = 2
src_data0 = [0, 2, -3, 0, 12, 0]
src_data1 = [1, 1, 1, 1, 1, 1]
expected_data = []
tmp = [min(x, y) for x, y in zip(src_data0, src_data1)]
for i in range(len(tmp) / dim):
expected_data.append(min(tmp[i * dim:(i + 1) * dim]))
src0 = blocks.vector_source_s(src_data0)
s2v0 = blocks.stream_to_vector(gr.sizeof_short, dim)
src1 = blocks.vector_source_s(src_data1)
s2v1 = blocks.stream_to_vector(gr.sizeof_short, dim)
op = blocks.min_ss(dim)
dst = blocks.vector_sink_s()
self.tb.connect(src0, s2v0, (op, 0))
self.tb.connect(src1, s2v1, (op, 1))
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_001_complex_to_interleaved_float_vcf(self):
src_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j)
expected_result = (1, 3, 2, 4, 5, 7, 6, 8)
src = blocks.vector_source_c(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, 2)
complex_to_interleaved_float_vcf = grdab.complex_to_interleaved_float_vcf(
2)
v2s = blocks.vector_to_stream(gr.sizeof_float, 4)
dst = blocks.vector_sink_f()
self.tb.connect(src, s2v, complex_to_interleaved_float_vcf, v2s, dst)
self.tb.run()
result_data = dst.data()
# print result_data
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def __init__(self, fft_size, samp_rate):
gr.hier_block2.__init__(
self,
"spectrum_sense",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1,
gr.sizeof_float * fft_size)) # Output signature
self.fft_size = fft_size
self.samp_rate = samp_rate
##################################################
# Blocks
##################################################
# stream to vector for fft
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
#self.one_in_n = gr.keep_one_in_n(gr.sizeof_float * self.fft_size,
# max(1, int(self.sample_rate/self.fft_size/self.fft_rate)))
# filter window
mywindow = filter.window.blackmanharris(self.fft_size)
# fft
ffter = fft.fft_vcc(self.fft_size, True, mywindow, True)
# complex to magnitude block
c2mag = blocks.complex_to_mag_squared(
self.fft_size) # use sqrt of this for power
# average
avg = filter.single_pole_iir_filter_ff(0.4, self.fft_size)
multiply_const = blocks.multiply_const_vff(
(np.ones(self.fft_size) * (1.0 / self.samp_rate)))
nlog10 = blocks.nlog10_ff(10, self.fft_size, 0)
# FIXME We need to add 3dB to all bins but the DC bin
#self.log = gr.nlog10_ff(20, self.fft_size,
# -20*math.log10(self.fft_size) # Adjust for number of bins
# -10*math.log10(power/self.fft_size) # Adjust for windowing loss
# -20*math.log10(ref_scale/2)) # Adjust for reference scale
#v2s = blocks.vector_to_stream(gr.sizeof_float*1, self.fft_size)
# connect blocks
self.connect(self, s2v, ffter, c2mag, avg, multiply_const, nlog10,
self)
def test_001_t(self):
# set up fg
src_data = (1, 2.1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20)
expected_result = (8.5, 9.525, 10.5, 11.5, 12.5)
src = blocks.vector_source_f(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_float, 5)
stats = usrpcalibrator.bin_statistics_ff(5, 4)
dst = blocks.vector_sink_f(5)
self.tb.connect(src, s2v, stats, dst)
self.tb.run()
# check data
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_003_t(self):
vector01 = (3, 0, 0, 0, 7, 0, 0, 0, 11, 4, 0, 0, 15, 8, 0, 0, 19, 12, 1, 0, 23, 16, 5, 0, 27, 20, 9, 2, 31, 24, 13, 6)
expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 0, 0, 7, 8, 0, 0, 11, 12, 0, 0, 15, 16, 0, 0, 19,20, 0, 0, 23, 24, 0, 0)
src = blocks.vector_source_b(vector01, True)
b2f = blocks.char_to_float_make()
s2v = blocks.stream_to_vector(gr.sizeof_float, 8)
time_deinterleaver = dab.time_deinterleave_ff_make(8, [2, 3, 0, 1])
v2s = blocks.vector_to_stream(gr.sizeof_float, 8)
dst = blocks.vector_sink_f()
self.tb.connect(src, b2f, time_deinterleaver, blocks.head_make(gr.sizeof_float, 8*4), dst)
self.tb.run()
result = dst.data()
#print result
self.assertEqual(expected_result, result)
def test_002_t(self):
# set up fg
src_data = (0, 0, 1, 0, 0, 1.0, 1, 2, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 0,
0, 0, 0, 1, 0, 0)
src = blocks.vector_source_f(src_data)
f2c = blocks.float_to_char()
s2v = blocks.stream_to_vector(gr.sizeof_char, 5)
f = open('/tmp/threshold_timestamp_test002.out', 'w')
tts = msod_sensor.threshold_timestamp(5, gr.sizeof_char, 1, 1.5,
f.fileno())
ns = blocks.null_sink(5 * gr.sizeof_float)
self.tb.connect(src, f2c, s2v, tts, ns)
self.tb.run()
f.close()
def __init__(self, fname, epsilon, max_iterations):
gr.top_block.__init__(self)
self.src = blocks.vector_source_b(())
print "initializing encoder"
self.encoder = ldpc.ldpc_encoder_bb(fname)
print "encoder initialized"
self.K = self.encoder.get_K()
self.N = self.encoder.get_N()
print self.K
print self.N
str2Kvec = blocks.stream_to_vector(1, self.K)
chk2symb = digital.chunks_to_symbols_bf(([1, -1]), 1)
str2Nvec = blocks.stream_to_vector(4, self.N)
self.channel = ldpc.bsc_bb(self.N, epsilon)
self.decoder = ldpc.ldpc_decoder_bb(fname, epsilon, max_iterations)
print "decoder initialized"
self.noise = analog.noise_source_f(analog.GR_GAUSSIAN, epsilon, 0)
self.adder = blocks.add_vff(1)
Kvec2str = blocks.vector_to_stream(1, self.K)
Nvec2str = blocks.vector_to_stream(4, self.N)
self.dst = blocks.vector_sink_b()
self.connect(self.src, str2Kvec, self.encoder, self.channel,
self.decoder, Kvec2str, self.dst)
def __init__(self, c_freq=1420000000, nbin=1000, nchan=1024, obs_time=60, samp_rate=2400000):
gr.top_block.__init__(self, "Top Block")
##################################################
# Parameters
##################################################
self.c_freq = c_freq
self.nbin = nbin
self.nchan = nchan
self.obs_time = obs_time
self.samp_rate = samp_rate
##################################################
# Variables
##################################################
self.gain = gain = 10000
##################################################
# Blocks
##################################################
self.fft_vxx_0 = fft.fft_vcc(nchan, True, (window.blackmanharris(nchan)), True, 1)
self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan)
self.blocks_integrate_xx_0 = blocks.integrate_ff(nbin, nchan)
self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(obs_time*samp_rate))
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*nchan, '/home/pictor/Desktop/pictortelescope/observation.dat', True)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(nchan)
self.RTL820T = osmosdr.source( args="numchan=" + str(1) + " " + '' )
self.RTL820T.set_sample_rate(samp_rate)
self.RTL820T.set_center_freq(c_freq, 0)
self.RTL820T.set_freq_corr(0, 0)
self.RTL820T.set_dc_offset_mode(0, 0)
self.RTL820T.set_iq_balance_mode(0, 0)
self.RTL820T.set_gain_mode(False, 0)
self.RTL820T.set_gain(30, 0)
self.RTL820T.set_if_gain(30, 0)
self.RTL820T.set_bb_gain(30, 0)
self.RTL820T.set_antenna('', 0)
self.RTL820T.set_bandwidth(0, 0)
##################################################
# Connections
##################################################
self.connect((self.RTL820T, 0), (self.blocks_head_0, 0))
self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0))
self.connect((self.blocks_head_0, 0), (self.blocks_stream_to_vector_0, 0))
self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
