def __init__(self, options):
ofdm = ofdm_rxtx.RX(options)
qam = raw.qam_rx(options.bitrate, ofdm.params.data_tones, ofdm.size, log=options.log)
framebytes = qam.framebytes
if options.crc:
framebytes = 188
gr.hier_block2.__init__(self, "QAM_RX",
gr.io_signature(1,1, gr.sizeof_gr_complex),
gr.io_signature(1,1, gr.sizeof_char * framebytes))
self.connect(self,
ofdm,
gr.vector_to_stream(gr.sizeof_gr_complex, ofdm.params.data_tones),
qam)
if options.crc:
self.connect(qam,
gr.stream_to_vector(gr.sizeof_char, framebytes + 4),
raw.crc_dec(framebytes),
self)
else:
self.connect(qam,
gr.stream_to_vector(gr.sizeof_char, qam.framebytes),
self)
self.ofdm = ofdm
self.qam = qam
self.framebytes = framebytes
def test_001(self):
fg = self.fg
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 = gr.vector_source_f (src1_data)
s2v1 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
fg.connect( src1, s2v1 )
src2 = gr.vector_source_f (src2_data)
s2v2 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
fg.connect( src2, s2v2 )
src3 = gr.vector_source_f (src3_data)
s2v3 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
fg.connect( src3, s2v3 )
dst1 = gr.vector_sink_s ()
dst2 = gr.vector_sink_s ()
argmax = gr.argmax_fs (len(src1_data))
fg.connect (s2v1, (argmax, 0))
fg.connect (s2v2, (argmax, 1))
fg.connect (s2v3, (argmax, 2))
fg.connect ((argmax,0), dst1)
fg.connect ((argmax,1), dst2)
fg.run ()
index = dst1.data ()
source = dst2.data ()
self.assertEqual ( index, (4,))
self.assertEqual ( source, (0,))
def __init__(self):
gr.top_block.__init__(self)
length = 101
data_r = range(length)
data_i = range(length,2*length)
src_r = gr.vector_source_s(data_r, False)
src_i = gr.vector_source_s(data_i, False)
s2f_r = gr.short_to_float()
s2f_i = gr.short_to_float()
f2c = gr.float_to_complex()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, length)
shift = True
ifft = gr.fft_vcc(length, False, [], shift)
fft = gr.fft_vcc(length, True, [], shift)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, length)
snk_in = gr.file_sink(gr.sizeof_gr_complex, "fftshift.in")
snk_out = gr.file_sink(gr.sizeof_gr_complex, "fftshift.out")
self.connect(src_r, s2f_r, (f2c,0))
self.connect(src_i, s2f_i, (f2c,1))
self.connect(f2c, snk_in)
self.connect(f2c, s2v, ifft, fft, v2s, snk_out)
def test_004_de_diff_mod_vcc(self):
#################################
# Testsequenz generieren
src_data = (1 + 0j, 0 + 2j, 0 - 0j, 0 + 1j, 2 + 0j, 0 + 0j, -1 + 0j,
2 + 0j, -0 + 0j)
#################################
# Ergebnis generieren
expected_result_0 = (0 + 0j, 0 + 0j, 0 - 0j, 0 + 1j, 0 - 4j, 0 - 0j,
0 + 1j, 4 + 0j, 0 + 0j)
expected_result_1 = (0 + 0j, 0 - 4j, 4 + 0j)
#################################
# Objekte erzeugen
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, 3)
diff = howto_swig.de_diff_mod_vcc(3, 1)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, 3)
dst0 = gr.vector_sink_c()
dst1 = gr.vector_sink_c()
# Objekte verbinden
self.tb.connect(src, s2v, (diff, 0), v2s, dst0)
self.tb.connect((diff, 1), dst1)
# Simulationsstart
self.tb.run()
# Ergebnis auswerten
result_data0 = dst0.data()
result_data1 = dst1.data()
self.assertComplexTuplesAlmostEqual(expected_result_0, result_data0, 6)
self.assertComplexTuplesAlmostEqual(expected_result_1, result_data1, 6)
def test_003(self):
# Need to add padding to keep proper alignment
padding = tuple([0 for i in range(5)])
scale = 2
vlen = 3
src_data = (0.0, 1.1, 2.2,) + padding + \
(3.3, 4.4, 5.5,) + padding + \
(-1.1, -2.2, -3.3,) + padding
expected_result = [0, 2, 4]
expected_result.extend(padding)
expected_result.extend([7, 9, 11])
expected_result.extend(padding)
expected_result.extend([-2, -4, -7])
expected_result.extend(padding)
src = gr.vector_source_f(src_data)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
op = gr.float_to_int(vlen, scale)
v2s = gr.vector_to_stream(gr.sizeof_int, vlen)
dst = gr.vector_sink_i()
self.tb.connect(src, s2v, op, v2s, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
def test_001(self):
vlen = 128
syms = 4
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[vlen / 2 - vlen / 4] = 1.0
vec = concatenate([vec] * syms)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f([0.0] * syms)
trig = gr.vector_source_b([1] * syms)
self.fg.connect(src, s2v, ifft, (freq_shift, 0))
self.fg.connect(eps, (freq_shift, 1))
self.fg.connect(trig, (freq_shift, 2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual(vec, numpy.array(dst.data()))
def test_007(self):
vlen = 128
syms = 4
bin1 = vlen / 2 + 2
bin1_val = 1.0
expec = numpy.array(numpy.zeros(vlen), numpy.complex)
expec[bin1] = bin1_val
expec = concatenate([expec] * syms)
epsilon = [0.5]
frame_trigger = numpy.concatenate([[1], [0] * (syms - 1)])
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0 / vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
fft_scale = gr.multiply_const_vcc([1.0 / vlen] * vlen)
src = gr.sig_source_c(vlen, gr.GR_COS_WAVE, 1.5, 1.0, 0.0)
# bin vlen/2 + 1.5
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger.tolist())
self.fg.connect(src, s2v, (freq_shift, 0))
self.fg.connect(eps, (freq_shift, 1))
self.fg.connect(trig, (freq_shift, 2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5, 1e-5)
def __init__(self, samplerate, bits_per_sec, fftlen):
gr.hier_block2.__init__(
self,
"gmsk_sync",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
#this is just the old square-and-fft method
#ais.freqest is simply looking for peaks spaced bits-per-sec apart
self.square = gr.multiply_cc(1)
self.fftvect = gr.stream_to_vector(gr.sizeof_gr_complex, fftlen)
self.fft = gr.fft_vcc(fftlen, True, window.rectangular(fftlen), True)
self.freqest = ais.freqest(int(samplerate), int(bits_per_sec), fftlen)
self.repeat = gr.repeat(gr.sizeof_float, fftlen)
self.fm = gr.frequency_modulator_fc(-1.0 / (float(samplerate) /
(2 * pi)))
self.mix = gr.multiply_cc(1)
self.connect(self, (self.square, 0))
self.connect(self, (self.square, 1))
#this is the feedforward branch
self.connect(self, (self.mix, 0))
#this is the feedback branch
self.connect(self.square, self.fftvect, self.fft, self.freqest,
self.repeat, self.fm, (self.mix, 1))
#and this is the output
self.connect(self.mix, self)
def test_003(self):
# Need to add padding
padding = tuple([0 for i in range(29)])
scale = 2
vlen = 3
src_data = (0.0, 1.1, 2.2,) + padding + \
(3.2, 4.2, 5.5,) + padding + \
(-1.1, -2.2, -3.2,) + padding
expected_result = [0, 2, 4]
expected_result.extend(padding)
expected_result.extend([6, 8, 11])
expected_result.extend(padding)
expected_result.extend([-2, -4, -6])
expected_result.extend(padding)
src = gr.vector_source_f(src_data)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
op = gr.float_to_char(vlen, scale)
v2s = gr.vector_to_stream(gr.sizeof_char, vlen)
dst = gr.vector_sink_c()
self.tb.connect(src, s2v, op, v2s, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
def __init__(self, fs, svn, alpha, fd_range, dump_bins=False):
gr.hier_block2.__init__(self, "acquisition",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(3, 3, gr.sizeof_float))
fft_size = int(1e-3 * fs)
doppler_range = self.get_doppler_range(fd_range)
agc = gr.agc_cc(1.0 / fs, 1.0, 1.0, 1.0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fft = gr.fft_vcc(fft_size, True, [])
argmax = gr.argmax_fs(fft_size)
max = gr.max_ff(fft_size)
self.connect(self, s2v, fft)
self.connect((argmax, 0), gr.short_to_float(), (self, 0))
self.connect((argmax, 1), gr.short_to_float(),
gr.add_const_ff(-fd_range), gr.multiply_const_ff(1e3),
(self, 1))
self.connect(max, (self, 2))
# Connect the individual channels to the input and the output.
self.correlators = [
single_channel_correlator(fs, fd, svn, alpha, dump_bins)
for fd in doppler_range
]
for (correlator, i) in zip(self.correlators,
range(len(self.correlators))):
self.connect(fft, correlator)
self.connect(correlator, (argmax, i))
self.connect(correlator, (max, i))
def test_003(self):
# Need to add padding
padding = tuple([0 for i in range(29)])
scale = 2
vlen = 3
src_data = (0.0, 1.1, 2.2,) + padding + \
(3.2, 4.2, 5.5,) + padding + \
(-1.1, -2.2, -3.2,) + padding
expected_result = [0, 2, 4]
expected_result.extend(padding)
expected_result.extend([6, 8, 11])
expected_result.extend(padding)
expected_result.extend([-2, -4, -6])
expected_result.extend(padding)
src = gr.vector_source_f(src_data)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
op = gr.float_to_char(vlen, scale)
v2s = gr.vector_to_stream(gr.sizeof_char, vlen)
dst = gr.vector_sink_c()
self.tb.connect(src, s2v, op, v2s, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
def __init__(self, N=512 , NW=3 , K=5, weighting='adaptive', fftshift=False):
gr.hier_block2.__init__(self, "mtm",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_float*N))
self.check_parameters(N, NW, K)
self.s2v = gr.stream_to_vector(gr.sizeof_gr_complex, N)
self.connect(self, self.s2v)
dpss = specest_gendpss.gendpss(N=N, NW=NW, K=K)
self.mtm = [eigenspectrum(dpss.dpssarray[i], fftshift) for i in xrange(K)]
if weighting == 'adaptive':
self.sum = specest_swig.adaptiveweighting_vff(N, dpss.lambdas)
self.connect_mtm(K)
self.connect(self.sum, self)
elif weighting == 'unity':
self.sum = gr.add_ff(N)
self.divide = gr.multiply_const_vff([1./K]*N)
self.connect_mtm(K)
self.connect(self.sum, self.divide, self)
elif weighting == 'eigenvalues':
self.eigvalmulti = []
self.lambdasum = 0
for i in xrange(K):
self.eigvalmulti.append(gr.multiply_const_vff([dpss.lambdas[i]]*N))
self.lambdasum += dpss.lambdas[i]
self.divide = gr.multiply_const_vff([1./self.lambdasum]*N)
self.sum = gr.add_ff(N)
self.connect_mtm(K)
self.connect(self.sum, self.divide, self)
else:
raise ValueError, 'weighting-type should be: adaptive, unity or eigenvalues'
def __init__(self, dBm, pfa, pfd, useless_bw, plot_histogram, location):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
self.histogram = plot_histogram
primary_user_location = 5
nframes_to_check = 1
nframes_to_average = 1
downconverter = 1
mu = 0
src_data = self.generateRandomSignalSource(
dBm, fft_size, mu, nframes_to_check * nframes_to_average, location)
# Blocks
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
self.ss = howto.spectrum_sensing_cf(samp_rate, fft_size,
samples_per_band, pfd, pfa, tcme,
output_pfa, debug_stats,
primary_user_location, useless_bw,
self.histogram, nframes_to_check,
nframes_to_average, downconverter)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, s2v, self.ss, self.sink)
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
histogram = True
primary_user_location = 42
nsegs_to_check = 6
downconverter = 1
# Blocks
rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
rtlsdr_source.set_sample_rate(samp_rate)
rtlsdr_source.set_center_freq(freq, 0)
rtlsdr_source.set_freq_corr(0, 0)
rtlsdr_source.set_gain_mode(0, 0)
rtlsdr_source.set_gain(10, 0)
rtlsdr_source.set_if_gain(24, 0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def __init__(self, dBm, pfa, pfd, useless_bw):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
histogram = True
primary_user_location = 0
mu = 0
fft_size = 16
history = 3
src_data = [1 + 1j] * fft_size * history
# Blocks
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
self.ss = howto.spectrum_sensing_cf(samp_rate, fft_size,
samples_per_band, pfd, pfa, tcme,
output_pfa, debug_stats,
primary_user_location, useless_bw,
histogram, history)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, s2v, self.ss, self.sink)
def test_003(self):
# Need to add padding to keep proper alignment
padding = tuple([0 for i in range(5)])
scale = 2
vlen = 3
src_data = (0.0, 1.1, 2.2) + padding + (3.3, 4.4, 5.5) + padding + (-1.1, -2.2, -3.3) + padding
expected_result = [0, 2, 4]
expected_result.extend(padding)
expected_result.extend([7, 9, 11])
expected_result.extend(padding)
expected_result.extend([-2, -4, -7])
expected_result.extend(padding)
src = gr.vector_source_f(src_data)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
op = gr.float_to_int(vlen, scale)
v2s = gr.vector_to_stream(gr.sizeof_int, vlen)
dst = gr.vector_sink_i()
self.tb.connect(src, s2v, op, v2s, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
def __init__(self, N=512 , NW=3 , K=5, weighting='adaptive', fftshift=False):
gr.hier_block2.__init__(self, "mtm",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(1, 1, gr.sizeof_float*N))
self.check_parameters(N, NW, K)
self.s2v = gr.stream_to_vector(gr.sizeof_gr_complex, N)
self.connect(self, self.s2v)
dpss = specest_gendpss.gendpss(N=N, NW=NW, K=K)
self.mtm = [eigenspectrum(dpss.dpssarray[i], fftshift) for i in xrange(K)]
if weighting == 'adaptive':
self.sum = specest_swig.adaptiveweighting_vff(N, dpss.lambdas)
self.connect_mtm(K)
self.connect(self.sum, self)
elif weighting == 'unity':
self.sum = gr.add_ff(N)
self.divide = gr.multiply_const_vff([1./K]*N)
self.connect_mtm(K)
self.connect(self.sum, self.divide, self)
elif weighting == 'eigenvalues':
self.eigvalmulti = []
self.lambdasum = 0
for i in xrange(K):
self.eigvalmulti.append(gr.multiply_const_vff([dpss.lambdas[i]]*N))
self.lambdasum += dpss.lambdas[i]
self.divide = gr.multiply_const_vff([1./self.lambdasum]*N)
self.sum = gr.add_ff(N)
self.connect_mtm(K)
self.connect(self.sum, self.divide, self)
else:
raise ValueError, 'weighting-type should be: adaptive, unity or eigenvalues'
def test_001_cutter_vbb(self):
#################################
# Testsequenz generieren
src_data_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
################################
# Ergebnis generieren
expected_result_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
#################################
# Objekte erzeugen
src_0 = gr.vector_source_b(src_data_0)
throttle_0 = gr.throttle(gr.sizeof_char * 1, 320000)
s2v_0 = gr.stream_to_vector(gr.sizeof_char, 6)
cutter = howto_swig.cutter_vbb(6, 2)
v2s_0 = gr.vector_to_stream(gr.sizeof_char, 2)
dst_0 = gr.vector_sink_b()
self.tb.connect(src_0, throttle_0, s2v_0, cutter, v2s_0, dst_0)
self.tb.run()
result_data0 = dst_0.data()
self.assertEqual(expected_result_0, result_data0)
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 = gr.vector_source_c(src_data0) src1 = gr.vector_source_b(src_data1) s2v0 = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length) ofdm_coarse_frequency_correct = dab_swig.ofdm_coarse_frequency_correct(fft_length,num_carriers,cp_length) v2s0 = gr.vector_to_stream(gr.sizeof_gr_complex, num_carriers) dst0 = gr.vector_sink_c() dst1 = gr.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 __init__(self, dbW, pfa, pfd):
gr.top_block.__init__(self)
# Parameters
samp_rate = 2e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
primary_user_location = 0
useless_bw = 0.0 # As we are not using any of the dongles it can be set as zero, i.e., all the band can be used.
histogram = False
nframes_to_check = 1
nframes_to_average = 1
downconverter = 1
nsegs_to_check = 6
# Create AWGN noise
noise = awgn(fft_size, dbW)
# Blocks
src = gr.vector_source_c(noise)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, s2v, fftb, self.ss, self.sink)
def __init__(self, vlen, channel_block, delay):
gr.hier_block2.__init__(self, 'apply_channel_to_vect',
gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen),
gr.io_signature(1, 1, gr.sizeof_gr_complex * vlen))
self.vlen=vlen
self.channel_block = channel_block
self.delay = delay
pad_len = self.vlen + self.delay*2
if(delay>0):
self.padding = gr.vector_source_c((0,)*(delay*2),True,delay*2)
self.pad_cat = mlse.vector_concat_vv(vlen*gr.sizeof_gr_complex,gr.sizeof_gr_complex*2*delay)
self.connect(self, self.pad_cat)
self.connect(self.padding, (self.pad_cat,1))
else:
self.pad_cat = self
self.tostream = gr.vector_to_stream(gr.sizeof_gr_complex, pad_len)
self.connect(self.pad_cat, self.tostream)
# connect channel
self.connect(self.tostream, self.channel_block)
self.tovector = gr.stream_to_vector(gr.sizeof_gr_complex, pad_len)
self.connect(self.channel_block, self.tovector)
# cut out the proper part
self.trim = mlse.vector_slice_vv(
gr.sizeof_gr_complex,
pad_len,
delay,
vlen)
self.connect(self.tovector, self.trim, self)
def helper(self, v0, v1, fft_length, preamble):
tb = self.tb
src0 = gr.vector_source_c(v0)
src1 = gr.vector_source_b(v1)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length)
# print "len(v) = %d" % (len(v))
op = gr.ofdm_insert_preamble(fft_length, preamble)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_length)
dst0 = gr.vector_sink_c()
dst1 = gr.vector_sink_b()
tb.connect(src0, s2v, (op, 0))
tb.connect(src1, (op, 1))
tb.connect((op, 0), v2s, dst0)
tb.connect((op, 1), dst1)
tb.run()
r0 = dst0.data()
r0v = []
for i in range(len(r0) // fft_length):
r0v.append(r0[i * fft_length:(i + 1) * fft_length])
r1 = dst1.data()
self.assertEqual(len(r0v), len(r1))
return (r1, r0v)
def test_002_energy_disp_vbb (self):
#################################
src_data_0 = []
for number in range(22):
src_data_0.append(0)
for number in range(22):
src_data_0.append(1)
################################
expected_result_0 = (0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,0,
1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,1)
#################################
# Objekte erzeugen
src_0 = gr.vector_source_b (src_data_0)
s2v_0 = gr.stream_to_vector(gr.sizeof_char, 22)
Energy_disp = howto_swig.energy_disp_vbb(22)
v2s_0 = gr.vector_to_stream(gr.sizeof_char, 16)
dst_0 = gr.vector_sink_b()
# Objekte verbinden
self.tb.connect(src_0, s2v_0,Energy_disp,v2s_0,dst_0)
# Simulationsstart
self.tb.run ()
# Ergebnis auswerten
result_data0 = dst_0.data ()
self.assertEqual(expected_result_0, result_data0)
def test_001(self):
frames = 5
config = station_configuration()
config.subcarriers = 12
config.data_subcarriers = 8
config.training_data = dummy()
config.training_data.shifted_pilot_tones = [1, 4, 8, 11]
data = [1.0] * config.subcarriers
for x in config.training_data.shifted_pilot_tones:
data[x] = 2.0
data = concatenate([data] * frames)
ref = [1.0] * (config.data_subcarriers * frames)
src = gr.vector_source_c(data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, config.subcarriers)
dst = gr.vector_sink_c()
v2s = gr.vector_to_stream(gr.sizeof_gr_complex,
config.data_subcarriers)
uut = preambles.pilot_subcarrier_filter()
self.fg.connect(src, s2v, uut, v2s, dst)
self.fg.run()
self.assertEqual(ref, list(dst.data()))
def test_014_bonder_vbb(self):
#################################
src_data_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
################################
expected_result_0 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
#################################
# Objekte erzeugen
src_0 = gr.vector_source_f(src_data_0)
throttle_0 = gr.throttle(gr.sizeof_float * 1, 320000)
s2v_0 = gr.stream_to_vector(gr.sizeof_float, 2)
bonder = howto_swig.bonder_vff(2, 6)
v2s_0 = gr.vector_to_stream(gr.sizeof_float, 6)
dst_0 = gr.vector_sink_f()
# Objekte verbinden
self.tb.connect(src_0, throttle_0, s2v_0, bonder, v2s_0, dst_0)
# Simulationsstart
self.tb.run()
# Ergebnis auswerten
result_data0 = dst_0.data()
self.assertEqual(expected_result_0, result_data0)
def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step) self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
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 = gr.vector_source_c(src_data) s2v = gr.stream_to_vector(gr.sizeof_gr_complex, 5) diff_phasor_vcc = dab_swig.diff_phasor_vcc(5) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, 5) dst = gr.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 test_001 (self):
vlen = 128
syms = 4
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
ifft = gr.fft_vcc(vlen, False, [], True)
fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)
vec = numpy.array(numpy.zeros(vlen), numpy.complex)
vec[vlen/2-vlen/4] = 1.0
vec = concatenate([vec]*syms)
src = gr.vector_source_c(vec)
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f([0.0]*syms)
trig = gr.vector_source_b([1]*syms)
self.fg.connect(src, s2v, ifft, (freq_shift,0))
self.fg.connect(eps, (freq_shift,1))
self.fg.connect(trig, (freq_shift,2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual(vec, numpy.array(dst.data()))
def test_001_ofdm_coarse_frequency_correct(self):
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]
expected_result0 = [complex(x) for x in expected_result0]
src_data1 = [1, 1, 1, 0]
expected_result1 = (1, 1, 1, 0)
src0 = gr.vector_source_c(src_data0)
src1 = gr.vector_source_b(src_data1)
s2v0 = gr.stream_to_vector(gr.sizeof_gr_complex, 10)
ofdm_coarse_frequency_correct = dab_swig.ofdm_coarse_frequency_correct(
10, 2)
v2s0 = gr.vector_to_stream(gr.sizeof_gr_complex, 2)
dst0 = gr.vector_sink_c()
dst1 = gr.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, 6)
self.assertEqual(result_data1, expected_result1)
def test_007 (self):
vlen = 128
syms = 4
bin1 = vlen/2 + 2
bin1_val = 1.0
expec = numpy.array(numpy.zeros(vlen), numpy.complex)
expec[bin1] = bin1_val
expec = concatenate([expec]*syms)
epsilon = [0.5]
frame_trigger = numpy.concatenate([[1],[0]*(syms-1)])
freq_shift = ofdm.frequency_shift_vcc(vlen, 1.0/vlen)
fft = gr.fft_vcc(vlen, True, [], True) # natural order, dc = vlen / 2
fft_scale = gr.multiply_const_vcc([1.0/vlen]*vlen)
src = gr.sig_source_c(vlen, gr.GR_COS_WAVE, 1.5, 1.0, 0.0)
# bin vlen/2 + 1.5
dst = gr.vector_sink_c()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, vlen)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen)
eps = gr.vector_source_f(epsilon)
trig = gr.vector_source_b(frame_trigger.tolist())
self.fg.connect(src, s2v, (freq_shift,0))
self.fg.connect(eps, (freq_shift,1))
self.fg.connect(trig, (freq_shift,2))
self.fg.connect(freq_shift, fft, fft_scale, v2s, dst)
self.fg.run()
self.assertComplexTuplesAlmostEqual2(expec, dst.data(), 1e-5, 1e-5)
def test_014_bonder_vbb (self):
#################################
src_data_0 =(1,2,3,4,5,6,7,8,9,10,11,12)
################################
expected_result_0 = (1,2,3,4,5,6,7,8,9,10,11,12)
#################################
# Objekte erzeugen
src_0 = gr.vector_source_f (src_data_0)
throttle_0 = gr.throttle(gr.sizeof_float*1, 320000)
s2v_0 = gr.stream_to_vector(gr.sizeof_float, 2)
bonder = howto_swig.bonder_vff(2,6)
v2s_0 = gr.vector_to_stream(gr.sizeof_float, 6)
dst_0 = gr.vector_sink_f()
# Objekte verbinden
self.tb.connect(src_0,throttle_0, s2v_0,bonder,v2s_0,dst_0)
# Simulationsstart
self.tb.run ()
# Ergebnis auswerten
result_data0 = dst_0.data ()
self.assertEqual(expected_result_0, result_data0)
def test_001_cutter_vbb (self):
#################################
# Testsequenz generieren
src_data_0 =(1,2,3,4,5,6,7,8,9,10,11,12)
################################
# Ergebnis generieren
expected_result_0 = (1,2,3,4,5,6,7,8,9,10,11,12)
#################################
# Objekte erzeugen
src_0 = gr.vector_source_b (src_data_0)
throttle_0 = gr.throttle(gr.sizeof_char*1, 320000)
s2v_0 = gr.stream_to_vector(gr.sizeof_char, 6)
cutter = howto_swig.cutter_vbb(6,2)
v2s_0 = gr.vector_to_stream(gr.sizeof_char, 2)
dst_0 = gr.vector_sink_b()
self.tb.connect(src_0,throttle_0, s2v_0,cutter,v2s_0,dst_0)
self.tb.run ()
result_data0 = dst_0.data ()
self.assertEqual(expected_result_0, result_data0)
def helper(self, v0, v1, fft_length, preamble):
tb = self.tb
src0 = gr.vector_source_c(v0)
src1 = gr.vector_source_b(v1)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length)
# print "len(v) = %d" % (len(v))
op = digital.ofdm_insert_preamble(fft_length, preamble)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, fft_length)
dst0 = gr.vector_sink_c()
dst1 = gr.vector_sink_b()
tb.connect(src0, s2v, (op, 0))
tb.connect(src1, (op, 1))
tb.connect((op, 0), v2s, dst0)
tb.connect((op, 1), dst1)
tb.run()
r0 = dst0.data()
r0v = []
for i in range(len(r0)//fft_length):
r0v.append(r0[i*fft_length:(i+1)*fft_length])
r1 = dst1.data()
self.assertEqual(len(r0v), len(r1))
return (r1, r0v)
def test_004_de_diff_mod_vcc (self):
#################################
# Testsequenz generieren
src_data = (1+0j, 0+2j, 0-0j, 0+1j, 2+0j, 0+0j,-1+0j,2+0j,-0+0j)
#################################
# Ergebnis generieren
expected_result_0 = (0+0j, 0+0j, 0-0j, 0+1j, 0-4j, 0-0j, 0+1j, 4+0j, 0+0j)
expected_result_1 = (0+0j, 0-4j, 4+0j)
#################################
# Objekte erzeugen
src = gr.vector_source_c (src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, 3)
diff = howto_swig.de_diff_mod_vcc(3,1)
v2s = gr.vector_to_stream(gr.sizeof_gr_complex, 3)
dst0 = gr.vector_sink_c()
dst1 = gr.vector_sink_c()
# Objekte verbinden
self.tb.connect(src, s2v, (diff,0), v2s, dst0)
self.tb.connect((diff,1), dst1)
# Simulationsstart
self.tb.run ()
# Ergebnis auswerten
result_data0 = dst0.data ()
result_data1 = dst1.data ()
self.assertComplexTuplesAlmostEqual (expected_result_0, result_data0, 6)
self.assertComplexTuplesAlmostEqual (expected_result_1, result_data1, 6)
def __init__(self, dBm, pfa, pfd, nTrials):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
histogram = False
primary_user_location = 0
useless_bw = 200000.0
src_data = [0+0j]*fft_size*nTrials
voltage = self.powerToAmplitude(dBm);
# Blocks
src = gr.vector_source_c(src_data)
noise = gr.noise_source_c(gr.GR_GAUSSIAN, voltage, 42)
add = gr.add_vcc()
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, add, s2v, fftb, ss, self.sink)
self.connect(noise, (add, 1))
def xtest_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 = gr.vector_source_f(src_data, False)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
stats = gr.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__002_t (self):
"""
Generate a signal with SNR as given below.
Calculate the RMSE.
"""
nsamples = 1024
n_trials = 100
samp_rate = 32000
SNR = 20 # in dB
self.siggen = siggen.signal_generator(n_sinusoids = 1,
SNR = SNR, samp_rate = samp_rate,
nsamples = nsamples * n_trials)
self.stream = gr.stream_to_vector(gr.sizeof_gr_complex, nsamples)
self.esprit = specest.esprit_vcf(n=1, m=64, nsamples = nsamples)
self.sink = gr.vector_sink_f(vlen=1)
# wire it up ...
self.tb.connect(self.siggen, self.stream, self.esprit, self.sink)
self.tb.run()
MSE = 0.0
omega = self.siggen.omegas()[0]
for i in range(n_trials):
MSE += (omega - self.sink.data()[i])**2.0
print '\n' + 70*'-'
print 'Testing specest_esprit_vcf ...'
print 'Ran %u trials to estimate the frequency' % n_trials
print 'Used %u samples to estimate the frequency' % nsamples
print 'Sampling rate %s' % eng_notation.num_to_str(samp_rate)
print 'SNR of %u dB' % SNR
print 'Root mean square error %g' % numpy.sqrt(MSE/n_trials)
print 'Cramer-Rao Bound %g' % numpy.sqrt(6/10**(SNR/10.0)/nsamples**3)
print 70*'-'
def __init__(self,options,Freq): gr.top_block.__init__(self) if options.input_file == "": self.IS_USRP2 = True else: self.IS_USRP2 = False #self.min_freq = options.start #self.max_freq = options.stop self.min_freq = Freq.value-(3*10**6) # same as that of the transmitter bandwidth ie 6MHZ approx for a given value of decimation line option any more self.max_freq = Freq.value+(3*10**6) if self.min_freq > self.max_freq: self.min_freq, self.max_freq = self.max_freq, self.min_freq # swap them print "Start and stop frequencies order swapped!" self.fft_size = options.fft_size self.ofdm_bins = options.sense_bins # build graph s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size) mywindow = window.blackmanharris(self.fft_size) fft = gr.fft_vcc(self.fft_size, True, mywindow) power = 0 for tap in mywindow: power += tap*tap c2mag = gr.complex_to_mag_squared(self.fft_size) #log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size)) # modifications for USRP2 if self.IS_USRP2: self.u = uhd.usrp_source(options.args,uhd.io_type.COMPLEX_FLOAT32,num_channels=1) # Modified Line # self.u.set_decim(options.decim) # samp_rate = self.u.adc_rate()/self.u.decim() samp_rate = 100e6/options.decim # modified sampling rate self.u.set_samp_rate(samp_rate) else: self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True) samp_rate = 100e6 /options.decim # modified sampling rate self.freq_step =0 #0.75* samp_rate self.min_center_freq = (self.min_freq + self.max_freq)/2 global BW BW = self.max_freq - self.min_freq global size size=self.fft_size global ofdm_bins ofdm_bins = self.ofdm_bins global usr #global thrshold_inorder usr=samp_rate nsteps = 10 self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step) self.next_freq = self.min_center_freq tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames self.msgq = gr.msg_queue(16) # thread-safe message queue self._tune_callback = tune(self) # hang on to this to keep it from being GC'd stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay, dwell_delay) # control scanning and record frequency domain statistics self.connect(self.u, s2v, fft,c2mag,stats) if options.gain is None: g = self.u.get_gain_range() options.gain = float(g.start()+g.stop())/2 # if no gain was specified, use the mid-point in dB
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 = gr.vector_source_c(tx_data, False, fft_len)
chan= gr.multiply_const_vcc(channel)
noise = gr.noise_source_c(gr.GR_GAUSSIAN, wgn_amplitude)
add = gr.add_cc(fft_len)
chanest = digital.ofdm_chanest_vcvc(sync_sym1, sync_sym2, 1)
sink = gr.vector_sink_c(fft_len)
top_block.connect(src, chan, (add, 0), chanest, sink)
top_block.connect(noise, gr.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.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset':
carr_offset_hat = pmt.pmt_to_long(tag.value)
self.assertEqual(carr_offset, carr_offset_hat)
if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps':
channel_est = shift_tuple(pmt.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, fs, svn, alpha, fd_range, dump_bins=False):
gr.hier_block2.__init__(self,
"acquisition",
gr.io_signature(1,1, gr.sizeof_gr_complex),
gr.io_signature(3,3, gr.sizeof_float))
fft_size = int( 1e-3*fs)
doppler_range = self.get_doppler_range(fd_range)
agc = gr.agc_cc( 1.0/fs, 1.0, 1.0, 1.0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fft = gr.fft_vcc(fft_size, True, [])
argmax = gr.argmax_fs(fft_size)
max = gr.max_ff(fft_size)
self.connect( self, s2v, fft)
self.connect( (argmax, 0),
gr.short_to_float(),
(self, 0))
self.connect( (argmax,1),
gr.short_to_float(),
gr.add_const_ff(-fd_range),
gr.multiply_const_ff(1e3),
(self,1))
self.connect( max, (self, 2))
# Connect the individual channels to the input and the output.
self.correlators = [ single_channel_correlator( fs, fd, svn, alpha, dump_bins) for fd in doppler_range ]
for (correlator, i) in zip( self.correlators, range(len(self.correlators))):
self.connect( fft, correlator )
self.connect( correlator, (argmax, i) )
self.connect( correlator, (max, i) )
def __init__(self, dBm, pfa, pfd, useless_bw, plot_histogram):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
self.histogram = plot_histogram
primary_user_location = 5
mu = 0
fft_size = 4096
nframes_to_check = 1
nframes_to_average = 1
downconverter = 1
src_data = self.generateRandomSignalSource(dBm, fft_size, mu, nframes_to_check*nframes_to_average)
# Blocks
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,self.histogram,nframes_to_check,nframes_to_average,downconverter)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, s2v, fftb, self.ss, self.sink)
def __init__(self, dBm, pfa, pfd, useless_bw):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
samples_per_band = 16
tcme = 1.9528
output_pfa = True
debug_stats = False
histogram = True
primary_user_location = 0
mu = 0
fft_size = 16
history = 3
src_data = [1+1j]*fft_size*history
# Blocks
src = gr.vector_source_c(src_data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,history)
self.sink = gr.vector_sink_f()
# Connections
self.connect(src, s2v, self.ss, self.sink)
def test_001(self):
frames = 5
config = station_configuration()
config.subcarriers = 12
config.data_subcarriers = 8
config.training_data = dummy()
config.training_data.shifted_pilot_tones = [1,4,8,11]
data = [1.0] * config.subcarriers
for x in config.training_data.shifted_pilot_tones:
data[x] = 2.0
data = concatenate([data]*frames)
ref = [1.0]*(config.data_subcarriers*frames)
src = gr.vector_source_c(data)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex,config.subcarriers)
dst = gr.vector_sink_c()
v2s = gr.vector_to_stream(gr.sizeof_gr_complex,config.data_subcarriers)
uut = preambles.pilot_subcarrier_filter()
self.fg.connect(src,s2v,uut,v2s,dst)
self.fg.run()
self.assertEqual(ref,list(dst.data()))
def __init__(
self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title="",
size=default_facsink_size,
peak_hold=False,
):
fac_sink_base.__init__(
self,
input_is_real=False,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold,
)
s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_gr_complex * self.fac_size, max(1, int(self.sample_rate / self.fac_size / self.fac_rate))
)
# windowing removed ...
fac = gr.fft_vcc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(fac_size)
# Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do...
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size)
log = gr.nlog10_ff(
20, self.fac_size, -20 * math.log10(self.fac_size)
) # - 20*math.log10(norm) ) # - self.avg[0] )
sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag, self.avg, log, sink)
# gr.hier_block2.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def stdtest_01(self,bps): # no reuse, bps bits per symbol vsyms = 10 vlen = 10 bits = vsyms*vlen*bps refdata = [randint(0,1) for i in range(bits)] cmap = [bps]*(vsyms*vlen) src = gr.vector_source_b(refdata) dst = gr.vector_sink_b() src_map = gr.vector_source_b(cmap) s2v = gr.stream_to_vector(gr.sizeof_char, vlen) self.tb.connect(src_map,s2v) dut1 = ofdm.generic_mapper_bcv(vlen) dut2 = ofdm.generic_demapper_vcb(vlen) self.tb.connect(src,dut1,dut2,dst) self.tb.connect(s2v,(dut1,1)) self.tb.connect(s2v,(dut2,1)) self.tb.run() self.assertEqual(list(dst.data()),refdata)
def __init__(self,subdev_spec=None,gain=None,length=1,alpha=1.0,msgq=None,loopback=False,verbose=False,debug=False):
self._subdev_spec = subdev_spec
self._gain = gain
self._length = length
self._alpha = alpha
self._msgq = msgq
self._loopback = loopback
self._verbose = verbose
self._debug = debug
self._fg = gr.flow_graph()
self._u = usrp.source_c(fpga_filename='usrp_sounder.rbf')
if not self._loopback:
if self._subdev_spec == None:
self._subdev_spec = pick_subdevice(self._u)
self._u.set_mux(usrp.determine_rx_mux_value(self._u, self._subdev_spec))
self._subdev = usrp.selected_subdev(self._u, self._subdev_spec)
if self._verbose:
print "Using", self._subdev.name(), "for sounder receiver."
self.set_gain(self._gain)
self._vblen = gr.sizeof_gr_complex*self._length
if self._debug:
print "Generating impulse vectors of length", self._length, "byte length", self._vblen
self._s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self._length)
if self._verbose:
print "Using smoothing alpha of", self._alpha
self._lpf = gr.single_pole_iir_filter_cc(self._alpha, self._length)
self._sink = gr.message_sink(self._vblen, self._msgq, True)
self._fg.connect(self._u, self._s2v, self._lpf, self._sink)
def __init__(self, pfa, pfd, freq, useless_bw, nframes_to_check, nframes_to_average):
gr.top_block.__init__(self)
# Constants
samp_rate = 2.4e6
fft_size = 4096
samples_per_band = 16
tcme = 1.9528
output_pfa = False
debug_stats = False
histogram = False
primary_user_location = 20
nsegs_to_check = 6
downconverter = 1
# Blocks
rtlsdr_source = osmosdr.source_c( args="nchan=" + str(1) + " " + "" )
rtlsdr_source.set_sample_rate(samp_rate)
rtlsdr_source.set_center_freq(freq, 0)
rtlsdr_source.set_freq_corr(0, 0)
rtlsdr_source.set_gain_mode(0, 0)
rtlsdr_source.set_gain(10, 0)
rtlsdr_source.set_if_gain(24, 0)
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, fft_size)
fftb = fft.fft_vcc(fft_size, True, (window.blackmanharris(1024)), False, 1)
self.ss = howto.spectrum_sensing_cf(samp_rate,fft_size,samples_per_band,pfd,pfa,tcme,output_pfa,debug_stats,primary_user_location,useless_bw,histogram,nframes_to_check,nframes_to_average,downconverter,nsegs_to_check)
self.sink = gr.vector_sink_f()
# Connections
self.connect(rtlsdr_source, s2v, fftb, self.ss, self.sink)
def xtest_002(self):
vlen = 4
tune = counter(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 = gr.vector_source_f(src_data, False)
s2v = gr.stream_to_vector(gr.sizeof_float, vlen)
stats = gr.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(self):
fft_length = 260
carriers = 100
shift = 20
# select maximum estimation range
estim_range = (fft_length - carriers) / 2
l = estim_range + shift
r = estim_range - shift
# create preambles
pn1 = pn_preamble(carriers)
pn2 = pn_preamble(carriers)
diff_pn = concatenate(
[[conjugate(math.sqrt(2) * pn2[2 * i] / pn1[2 * i]), 0.0j]
for i in range(carriers / 2)])
pn1_sym = extend_symbol(pn1, l, r)
pn2_sym = extend_symbol(pn2, l, r)
# block under tests
cfo_estimator = ofdm.schmidl_cfo_estimator(fft_length, carriers,
estim_range, diff_pn)
# source, conversion, sink
src_1 = gr.vector_source_c(pn1_sym)
src_2 = gr.vector_source_c(pn2_sym)
s2v_1 = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length)
s2v_2 = gr.stream_to_vector(gr.sizeof_gr_complex, fft_length)
v2s = gr.vector_to_stream(gr.sizeof_float, 2 * estim_range + 1)
dst = gr.vector_sink_f()
self.fg.connect(src_1, s2v_1, (cfo_estimator, 0))
self.fg.connect(src_2, s2v_2, (cfo_estimator, 1))
self.fg.connect(cfo_estimator, v2s, dst)
# file output
filesink = gr.file_sink(gr.sizeof_float, "test_cfo.float")
vec_equ = vector_equalizer(2 * estim_range + 1)
self.fg.connect(
v2s, gr.float_to_complex(),
gr.stream_to_vector(gr.sizeof_gr_complex, 2 * estim_range + 1),
vec_equ,
gr.vector_to_stream(gr.sizeof_gr_complex, 2 * estim_range + 1),
gr.complex_to_float(), filesink)
runtime = self.fg
runtime.run()
def __init__(self, decim=16, N_id_1=134, N_id_2=0): grc_wxgui.top_block_gui.__init__(self, title="Sss Corr Gui") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Parameters ################################################## self.decim = decim self.N_id_1 = N_id_1 self.N_id_2 = N_id_2 ################################################## # Variables ################################################## self.sss_start_ts = sss_start_ts = 10608 - 2048 - 144 self.samp_rate = samp_rate = 30720e3/decim ################################################## # Blocks ################################################## self.wxgui_scopesink2_0 = scopesink2.scope_sink_f( self.GetWin(), title="Scope Plot", sample_rate=200, v_scale=0, v_offset=0, t_scale=0, ac_couple=False, xy_mode=False, num_inputs=1, trig_mode=gr.gr_TRIG_MODE_AUTO, y_axis_label="Counts", ) self.Add(self.wxgui_scopesink2_0.win) self.gr_vector_to_stream_0 = gr.vector_to_stream(gr.sizeof_gr_complex*1, 2048/decim) self.gr_throttle_0 = gr.throttle(gr.sizeof_gr_complex*1, samp_rate*decim) self.gr_stream_to_vector_0 = gr.stream_to_vector(gr.sizeof_gr_complex*1, 2048/decim) self.gr_skiphead_0 = gr.skiphead(gr.sizeof_gr_complex*1, sss_start_ts) self.gr_multiply_const_vxx_0 = gr.multiply_const_vcc((gen_sss_fd(N_id_1, N_id_2, 2048/decim).get_sss_conj_rev())) self.gr_integrate_xx_0 = gr.integrate_cc(2048/decim) self.gr_file_source_0 = gr.file_source(gr.sizeof_gr_complex*1, "/home/user/git/gr-lte/gr-lte/test/traces/lte_02_796m_30720k_frame.cfile", True) self.gr_fft_vxx_0 = gr.fft_vcc(2048/decim, True, (window.blackmanharris(1024)), True, 1) self.gr_complex_to_mag_0 = gr.complex_to_mag(1) self.fir_filter_xxx_0 = filter.fir_filter_ccc(decim, (firdes.low_pass(1, decim*samp_rate, 550e3, 100e3))) ################################################## # Connections ################################################## self.connect((self.gr_file_source_0, 0), (self.gr_throttle_0, 0)) self.connect((self.gr_stream_to_vector_0, 0), (self.gr_fft_vxx_0, 0)) self.connect((self.gr_fft_vxx_0, 0), (self.gr_multiply_const_vxx_0, 0)) self.connect((self.gr_multiply_const_vxx_0, 0), (self.gr_vector_to_stream_0, 0)) self.connect((self.gr_vector_to_stream_0, 0), (self.gr_integrate_xx_0, 0)) self.connect((self.gr_integrate_xx_0, 0), (self.gr_complex_to_mag_0, 0)) self.connect((self.gr_complex_to_mag_0, 0), (self.wxgui_scopesink2_0, 0)) self.connect((self.gr_throttle_0, 0), (self.gr_skiphead_0, 0)) self.connect((self.gr_skiphead_0, 0), (self.fir_filter_xxx_0, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.gr_stream_to_vector_0, 0))
def test_001_vector_concat_vv(self):
src1 = gr.vector_source_f((1, 2, 3, 4, 5))
src2 = gr.vector_source_f((11, 12, 13))
expected_result = (1, 2, 3, 4, 5, 11, 12, 13)
dst = gr.vector_sink_f()
reor1 = gr.stream_to_vector(gr.sizeof_float, 5)
reor2 = gr.stream_to_vector(gr.sizeof_float, 3)
reor3 = gr.vector_to_stream(gr.sizeof_float, 8)
cat = mlse_swig.vector_concat_vv(gr.sizeof_float * 5,
gr.sizeof_float * 3)
self.tb.connect(src1, reor1, (cat, 0))
self.tb.connect(src2, reor2, (cat, 1))
self.tb.connect(cat, reor3, dst)
self.tb.run()
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def __init__(self):
sense_band_start=900*10**6
sense_band_stop=940*10**6
self.fft_size = options.fft_size
self.ofdm_bins = options.sense_bins
# build graph
s2v = gr.stream_to_vector(gr.sizeof_gr_complex, self.fft_size)
mywindow = window.blackmanharris(self.fft_size)
fft = gr.fft_vcc(self.fft_size, True, mywindow)
power = 0
for tap in mywindow:
power += tap*tap
c2mag = gr.complex_to_mag_squared(self.fft_size)
#log = gr.nlog10_ff(10, self.fft_size, -20*math.log10(self.fft_size)-10*math.log10(power/self.fft_size))
# modifications for USRP2
print "*******************in sensor init********************"
if self.IS_USRP2:
self.u = usrp2.source_32fc(options.interface, options.MAC_addr)
self.u.set_decim(options.decim)
samp_rate = self.u.adc_rate() / self.u.decim()
else:
self.u = gr.file_source(gr.sizeof_gr_complex,options.input_file, True)
samp_rate = 100e6 / options.decim
self.freq_step =0.75* samp_rate
#self.min_center_freq = (self.min_freq + self.max_freq)/2
global BW
BW = 0.75* samp_rate #self.max_freq - self.min_freq
global size
size=self.fft_size
global ofdm_bins
ofdm_bins = self.ofdm_bins
global usr
#global thrshold_inorder
usr=samp_rate
nsteps = 10 #math.ceil((self.max_freq - self.min_freq) / self.freq_step)
self.max_center_freq = self.min_center_freq + (nsteps * self.freq_step)
self.next_freq = self.min_center_freq
tune_delay = max(0, int(round(options.tune_delay * samp_rate / self.fft_size))) # in fft_frames
print tune_delay
dwell_delay = max(1, int(round(options.dwell_delay * samp_rate / self.fft_size))) # in fft_frames
print dwell_delay
self.msgq = gr.msg_queue(16)
self._tune_callback = tune(self)
# hang on to this to keep it from being GC'd
stats = gr.bin_statistics_f(self.fft_size, self.msgq, self._tune_callback, tune_delay,
dwell_delay)
self.connect(self.u, s2v, fft,c2mag,stats)
if options.gain is None:
# if no gain was specified, use the mid-point in dB
g = self.u.gain_range()
options.gain = float(g[0]+g[1])/2
def help_const_ii(self, src_data, exp_data, op):
src = gr.vector_source_i(src_data)
srcv = gr.stream_to_vector(gr.sizeof_int, len(src_data))
rhs = gr.vector_to_stream(gr.sizeof_int, len(src_data))
dst = gr.vector_sink_i()
self.tb.connect(src, srcv, op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def main():
tb = gr.top_block()
# noise source
n = mlse.randint_b(2)
reshape_n = gr.stream_to_vector(1, 58 * 2)
tb.connect(n, reshape_n)
# limit experiment length
head = gr.head(58 * 2, 1)
tb.connect(reshape_n, head)
# modulate
gsm_burstmod = gsm.gsm_modulate_burst()
tb.connect(head, gsm_burstmod)
random_tsc_index = mlse.randint_b(8)
tb.connect(random_tsc_index, (gsm_burstmod, 1))
# apply channel
channel = gsm.my_channel(-100, [0.2, 1, 0.2])
channel_apply = gsm.apply_channel_to_vect(148, channel, 1)
tb.connect(gsm_burstmod, channel_apply)
# derotate
derot = mlse.derotate_cc(148, 4,
-1) #FIXME: why -1? (not as if it matters)
tb.connect(channel_apply, derot)
modsink = gr.vector_sink_c(148)
datasink = gr.vector_sink_b(58 * 2)
tb.connect(derot, modsink)
tb.connect(head, datasink)
# mlse-decode
decode = mlse.equalizer_midamble_vcb(mlse.make_packet_config_gsm())
tb.connect(derot, decode)
tb.connect(random_tsc_index, (decode, 1))
# ber
ber = mlse.ber_vbi(58 * 2)
tb.connect(decode, ber)
tb.connect(head, (ber, 1))
result_sink = gr.vector_sink_b(58 * 2)
tb.connect(decode, result_sink)
chanest_sink = gr.vector_sink_c(7)
tb.connect((decode, 1), chanest_sink)
tb.run()
tb.run()
d = modsink.data()
# printvect_c(d)
print ber.bit_error_rate()
print_bitvect(datasink.data())
print_bitvect(result_sink.data())
import operator
print_bitvect(map(operator.xor, datasink.data(), result_sink.data()))
printvect_c(chanest_sink.data())
def __init__(self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title='',
size=default_facsink_size,
peak_hold=False):
fac_sink_base.__init__(self,
input_is_real=True,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold)
s2p = gr.stream_to_vector(gr.sizeof_float, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_float * self.fac_size,
max(1, int(self.sample_rate / self.fac_size / self.fac_rate)))
# windowing removed...
fac = gr.fft_vfc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(self.fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, self.fac_size)
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
# FIXME We need to add 3dB to all bins but the DC bin
log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10(self.fac_size))
sink = gr.message_sink(gr.sizeof_float * self.fac_size, self.msgq,
True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag,
self.avg, log, sink)
# gr.hier_block.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def __init__(self,
parent,
baseband_freq=0,
y_per_div=10,
ref_level=50,
sample_rate=1,
fac_size=512,
fac_rate=default_fac_rate,
average=False,
avg_alpha=None,
title='',
size=default_facsink_size,
peak_hold=False):
fac_sink_base.__init__(self,
input_is_real=False,
baseband_freq=baseband_freq,
y_per_div=y_per_div,
ref_level=ref_level,
sample_rate=sample_rate,
fac_size=fac_size,
fac_rate=fac_rate,
average=average,
avg_alpha=avg_alpha,
title=title,
peak_hold=peak_hold)
s2p = gr.stream_to_vector(gr.sizeof_gr_complex, self.fac_size)
self.one_in_n = gr.keep_one_in_n(
gr.sizeof_gr_complex * self.fac_size,
max(1, int(self.sample_rate / self.fac_size / self.fac_rate)))
# windowing removed ...
fac = gr.fft_vcc(self.fac_size, True, ())
c2mag = gr.complex_to_mag(fac_size)
# Things go off into the weeds if we try for an inverse FFT so a forward FFT will have to do...
fac_fac = gr.fft_vfc(self.fac_size, True, ())
fac_c2mag = gr.complex_to_mag(fac_size)
self.avg = gr.single_pole_iir_filter_ff(1.0, fac_size)
log = gr.nlog10_ff(20, self.fac_size, -20 * math.log10(
self.fac_size)) # - 20*math.log10(norm) ) # - self.avg[0] )
sink = gr.message_sink(gr.sizeof_float * fac_size, self.msgq, True)
self.connect(s2p, self.one_in_n, fac, c2mag, fac_fac, fac_c2mag,
self.avg, log, sink)
# gr.hier_block2.__init__(self, fg, s2p, sink)
self.win = fac_window(self, parent, size=size)
self.set_average(self.average)
self.wxgui_connect(self, s2p)
def __init__(self, decim=16):
grc_wxgui.top_block_gui.__init__(self, title="File Fft")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Parameters
##################################################
self.decim = decim
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
self.fft_size = fft_size = 2048 / decim
self.N_re = N_re = 62
##################################################
# Blocks
##################################################
self.wxgui_scopesink2_0 = scopesink2.scope_sink_c(
self.GetWin(),
title="Scope Plot",
sample_rate=samp_rate,
v_scale=0,
v_offset=0,
t_scale=0,
ac_couple=False,
xy_mode=False,
num_inputs=1,
trig_mode=gr.gr_TRIG_MODE_AUTO,
y_axis_label="Counts",
)
self.Add(self.wxgui_scopesink2_0.win)
self.gr_vector_to_stream_0 = gr.vector_to_stream(
gr.sizeof_gr_complex * 1, fft_size)
self.gr_stream_to_vector_0 = gr.stream_to_vector(
gr.sizeof_gr_complex * 1, fft_size)
self.gr_keep_m_in_n_0 = gr.keep_m_in_n(gr.sizeof_gr_complex, N_re,
fft_size, (fft_size - N_re) / 2)
self.gr_file_source_0 = gr.file_source(
gr.sizeof_gr_complex * 1,
"/home/user/git/gr-lte/gr-lte/test/foo_pss0_sss_in.cfile", True)
self.gr_fft_vxx_0 = gr.fft_vcc(fft_size, True,
(window.blackmanharris(1024)), True, 1)
##################################################
# Connections
##################################################
self.connect((self.gr_stream_to_vector_0, 0), (self.gr_fft_vxx_0, 0))
self.connect((self.gr_file_source_0, 0),
(self.gr_stream_to_vector_0, 0))
self.connect((self.gr_vector_to_stream_0, 0),
(self.gr_keep_m_in_n_0, 0))
self.connect((self.gr_fft_vxx_0, 0), (self.gr_vector_to_stream_0, 0))
self.connect((self.gr_keep_m_in_n_0, 0), (self.wxgui_scopesink2_0, 0))
