def test_002 (self):
l = 100000
stream = [ [0]*l, [1]*l, [2]*l, [3]*l ]
mux = concatenate(stream)
seed()
for i in range(l):
a = randint(0,len(mux)-1)
b = randint(0,len(mux)-1)
mux[a],mux[b] = mux[b],mux[a]
imux = []
for x in mux:
imux.append(int(x))
data = [gr.vector_source_s(stream[0]),
gr.vector_source_s(stream[1]),
gr.vector_source_s(stream[2]),
gr.vector_source_s(stream[3])]
dst = gr.vector_sink_s()
uut = ofdm.static_mux_v(gr.sizeof_short, imux)
self.fg.connect(data[0], (uut,0))
self.fg.connect(data[1], (uut,1))
self.fg.connect(data[2], (uut,2))
self.fg.connect(data[3], (uut,3))
self.fg.connect(uut,dst)
self.fg.run()
self.assertEqual(list(mux),list(dst.data()))
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_006(self):
l = 100000
stream = [[0] * l, [1] * l, [2] * l]
mux = [0, 2, 1]
ref = concatenate([mux] * l)
imux = []
for x in mux:
imux.append(int(x))
data = [
gr.vector_source_s(stream[0]),
gr.vector_source_s(stream[1]),
gr.vector_source_s(stream[2])
]
dst = gr.vector_sink_s()
uut = ofdm.static_mux_v(gr.sizeof_short, imux)
self.fg.connect(data[0], (uut, 0))
self.fg.connect(data[1], (uut, 1))
self.fg.connect(data[2], (uut, 2))
self.fg.connect(uut, dst)
self.fg.run()
self.assertEqual(list(ref), list(dst.data()))
def test_001(self):
stream = [[0] * 10, [1] * 10, [2] * 10]
mux = [
0, 2, 2, 1, 1, 2, 0, 2, 0, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 1, 2, 0,
0, 2, 1, 2, 0, 1, 2, 0
]
imux = []
for x in mux:
imux.append(int(x))
data = [
gr.vector_source_s(stream[0]),
gr.vector_source_s(stream[1]),
gr.vector_source_s(stream[2])
]
dst = gr.vector_sink_s()
uut = ofdm.static_mux_v(gr.sizeof_short, imux)
self.fg.connect(data[0], (uut, 0))
self.fg.connect(data[1], (uut, 1))
self.fg.connect(data[2], (uut, 2))
self.fg.connect(uut, dst)
self.fg.run()
self.assertEqual(mux, list(dst.data()))
def test_002(self):
l = 100000
stream = [[0] * l, [1] * l, [2] * l, [3] * l]
mux = concatenate(stream)
seed()
for i in range(l):
a = randint(0, len(mux) - 1)
b = randint(0, len(mux) - 1)
mux[a], mux[b] = mux[b], mux[a]
imux = []
for x in mux:
imux.append(int(x))
data = [
gr.vector_source_s(stream[0]),
gr.vector_source_s(stream[1]),
gr.vector_source_s(stream[2]),
gr.vector_source_s(stream[3])
]
dst = gr.vector_sink_s()
uut = ofdm.static_mux_v(gr.sizeof_short, imux)
self.fg.connect(data[0], (uut, 0))
self.fg.connect(data[1], (uut, 1))
self.fg.connect(data[2], (uut, 2))
self.fg.connect(data[3], (uut, 3))
self.fg.connect(uut, dst)
self.fg.run()
self.assertEqual(list(mux), list(dst.data()))
def test_005 (self):
stream = [ [0]*10, [1]*10, [2]*10 ]
mux = [ 0,1,2 ]
ref = [ 0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,
0,1,2,0,1,2,0,1,2 ]
imux = []
for x in mux:
imux.append(int(x))
data = [gr.vector_source_s(stream[0]),
gr.vector_source_s(stream[1]),
gr.vector_source_s(stream[2])]
dst = gr.vector_sink_s()
uut = ofdm.static_mux_v(gr.sizeof_short, imux)
self.fg.connect(data[0], (uut,0))
self.fg.connect(data[1], (uut,1))
self.fg.connect(data[2], (uut,2))
self.fg.connect(uut,dst)
self.fg.run()
self.assertEqual(ref,list(dst.data()))
def test_006 (self):
l = 100000
stream = [ [0]*l, [1]*l, [2]*l ]
mux = [ 0,2,1 ]
ref = concatenate([mux]*l)
imux = []
for x in mux:
imux.append(int(x))
data = [gr.vector_source_s(stream[0]),
gr.vector_source_s(stream[1]),
gr.vector_source_s(stream[2])]
dst = gr.vector_sink_s()
uut = ofdm.static_mux_v(gr.sizeof_short, imux)
self.fg.connect(data[0], (uut,0))
self.fg.connect(data[1], (uut,1))
self.fg.connect(data[2], (uut,2))
self.fg.connect(uut,dst)
self.fg.run()
self.assertEqual(list(ref),list(dst.data()))
def test_001(self):
src_data = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
trg_data = (-1, -1, 1, 1, -1, -1, 1, 1, -1, -1)
src = gr.vector_source_i(src_data)
trg = gr.vector_source_s(trg_data)
op = blocks.burst_tagger(gr.sizeof_int)
snk = blocks.tagged_file_sink(gr.sizeof_int, 1)
self.tb.connect(src, (op,0))
self.tb.connect(trg, (op,1))
self.tb.connect(op, snk)
self.tb.run()
# Tagged file sink gets 2 burst tags at index 2 and index 5.
# Creates two new files, each with two integers in them from
# src_data at these indexes (3,4) and (7,8).
file0 = "file{0}_0_2.00000000.dat".format(snk.unique_id())
file1 = "file{0}_1_6.00000000.dat".format(snk.unique_id())
# Open the files and read in the data, then remove the files
# to clean up the directory.
outfile0 = file(file0, 'rb')
outfile1 = file(file1, 'rb')
data0 = outfile0.read(8)
data1 = outfile1.read(8)
outfile0.close()
outfile1.close()
os.remove(file0)
os.remove(file1)
# Convert the 8 bytes from the files into a tuple of 2 ints.
idata0 = struct.unpack('ii', data0)
idata1 = struct.unpack('ii', data1)
self.assertEqual(idata0, (3, 4))
self.assertEqual(idata1, (7, 8))
def __init__(self, uhd_address, options):
gr.top_block.__init__(self)
self.uhd_addr = uhd_address
self.freq = options.freq
self.samp_rate = options.samp_rate
self.gain = options.gain
self.threshold = options.threshold
self.trigger = options.trigger
self.uhd_src = uhd.single_usrp_source(
device_addr=self.uhd_addr, stream_args=uhd.stream_args('fc32'))
self.uhd_src.set_samp_rate(self.samp_rate)
self.uhd_src.set_center_freq(self.freq, 0)
self.uhd_src.set_gain(self.gain, 0)
taps = firdes.low_pass_2(1, 1, 0.4, 0.1, 60)
self.chanfilt = gr.fir_filter_ccc(10, taps)
self.tagger = gr.burst_tagger(gr.sizeof_gr_complex)
# Dummy signaler to collect a burst on known periods
data = 1000 * [
0,
] + 1000 * [
1,
]
self.signal = gr.vector_source_s(data, True)
# Energy detector to get signal burst
## use squelch to detect energy
self.det = gr.simple_squelch_cc(self.threshold, 0.01)
## convert to mag squared (float)
self.c2m = gr.complex_to_mag_squared()
## average to debounce
self.avg = gr.single_pole_iir_filter_ff(0.01)
## rescale signal for conversion to short
self.scale = gr.multiply_const_ff(2**16)
## signal input uses shorts
self.f2s = gr.float_to_short()
# Use file sink burst tagger to capture bursts
self.fsnk = gr.tagged_file_sink(gr.sizeof_gr_complex, self.samp_rate)
##################################################
# Connections
##################################################
self.connect((self.uhd_src, 0), (self.tagger, 0))
self.connect((self.tagger, 0), (self.fsnk, 0))
if self.trigger:
# Connect a dummy signaler to the burst tagger
self.connect((self.signal, 0), (self.tagger, 1))
else:
# Connect an energy detector signaler to the burst tagger
self.connect(self.uhd_src, self.det)
self.connect(self.det, self.c2m, self.avg, self.scale, self.f2s)
self.connect(self.f2s, (self.tagger, 1))
def test_deint_001(self):
lenx = 64
src0 = gr.vector_source_s(range(lenx))
op = gr.deinterleave(gr.sizeof_short, 4)
dst0 = gr.vector_sink_s()
dst1 = gr.vector_sink_s()
dst2 = gr.vector_sink_s()
dst3 = gr.vector_sink_s()
self.tb.connect(src0, op)
op.connect(dst0, usesPortName="short_out_0")
op.connect(dst1, usesPortName="short_out_1")
op.connect(dst2, usesPortName="short_out_2")
op.connect(dst3, usesPortName="short_out_3")
self.tb.run()
expected_result0 = tuple(range(0, lenx, 4))
expected_result1 = tuple(range(1, lenx, 4))
expected_result2 = tuple(range(2, lenx, 4))
expected_result3 = tuple(range(3, lenx, 4))
self.assertFloatTuplesAlmostEqual(expected_result0, dst0.data())
self.assertFloatTuplesAlmostEqual(expected_result1, dst1.data())
self.assertFloatTuplesAlmostEqual(expected_result2, dst2.data())
self.assertFloatTuplesAlmostEqual(expected_result3, dst3.data())
def test_fir_filter_scc_002(self):
self.generate_scc_source()
expected_data = ((-0.0080680437386-0.00158522999845j),
(-0.0037795654498+0.00733159901574j),
(0.00842926371843+0.00777021236718j),
(0.0112090632319-0.00249325321056j),
(-0.0027476802934-0.0115710813552j),
(-0.0158688724041-0.00715934624895j),
(-0.00802888441831+0.00620818417519j),
(0.0131985172629+0.0149175003171j),
(0.0190298333764+0.00956719089299j),
(-0.00112380902283-0.00936658866704j),
(-0.0204226914793-0.0333464704454j),
(-0.00695514678955-0.0437445007265j),
(0.0314490310848-0.0207983348519j),
(0.0529675260186+0.0302227605134j),
(0.0317338332534+0.0667510479689j),
(-0.00775565672666+0.0437112376094j),
(-0.024347923696-0.0303014591336j),
(-0.0108893103898-0.0875638127327j),
(0.00204296782613-0.0721434056759j),
(-0.00527479872108-0.00698097236454j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scc(4, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_scc_001(self):
self.generate_scc_source()
expected_data = (
(-0.00775564694777 + 0.0437113791704j),
(0.0108830630779 + 0.0433648750186j),
(0.015553932637 - 0.0133284125477j), (-0.0264905355871 -
0.0403266139328j),
(-0.0243480335921 - 0.03030154109j), (-0.000327925226884 -
0.069333948195j),
(-0.0306392069906 - 0.107313856483j), (-0.0452371090651 -
0.0854917764664j),
(-0.0108894333243 - 0.0875641107559j), (-0.0182112380862 -
0.118961036205j),
(-0.0447825863957 - 0.0922874584794j), (-0.0147479763255 -
0.0572904124856j),
(0.00204290449619 - 0.0721436738968j), (-0.027713002637 -
0.0548989400268j),
(-0.0149045493454 - 0.00210141134448j), (0.0176361314952 -
0.00149522523861j),
(-0.00527482619509 - 0.00698099425063j), (-0.0151527002454 +
0.036265052855j),
(0.0199296213686 + 0.0452499426901j), (0.0122985243797 +
0.0143278446048j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scc(1, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
5)
def __init__(self, uhd_address, options):
gr.top_block.__init__(self)
self.uhd_addr = uhd_address
self.freq = options.freq
self.samp_rate = options.samp_rate
self.gain = options.gain
self.threshold = options.threshold
self.trigger = options.trigger
self.uhd_src = uhd.single_usrp_source(
device_addr=self.uhd_addr,
io_type=uhd.io_type_t.COMPLEX_FLOAT32,
num_channels=1,
)
self.uhd_src.set_samp_rate(self.samp_rate)
self.uhd_src.set_center_freq(self.freq, 0)
self.uhd_src.set_gain(self.gain, 0)
taps = firdes.low_pass_2(1, 1, 0.4, 0.1, 60)
self.chanfilt = gr.fir_filter_ccc(10, taps)
self.tagger = gr.burst_tagger(gr.sizeof_gr_complex)
# Dummy signaler to collect a burst on known periods
data = 1000*[0,] + 1000*[1,]
self.signal = gr.vector_source_s(data, True)
# Energy detector to get signal burst
## use squelch to detect energy
self.det = gr.simple_squelch_cc(self.threshold, 0.01)
## convert to mag squared (float)
self.c2m = gr.complex_to_mag_squared()
## average to debounce
self.avg = gr.single_pole_iir_filter_ff(0.01)
## rescale signal for conversion to short
self.scale = gr.multiply_const_ff(2**16)
## signal input uses shorts
self.f2s = gr.float_to_short()
# Use file sink burst tagger to capture bursts
self.fsnk = gr.tagged_file_sink(gr.sizeof_gr_complex, self.samp_rate)
##################################################
# Connections
##################################################
self.connect((self.uhd_src, 0), (self.tagger, 0))
self.connect((self.tagger, 0), (self.fsnk, 0))
if self.trigger:
# Connect a dummy signaler to the burst tagger
self.connect((self.signal, 0), (self.tagger, 1))
else:
# Connect an energy detector signaler to the burst tagger
self.connect(self.uhd_src, self.det)
self.connect(self.det, self.c2m, self.avg, self.scale, self.f2s)
self.connect(self.f2s, (self.tagger, 1))
def test_fir_filter_scc_002(self):
self.generate_scc_source()
expected_data = (
(-0.0080680437386 - 0.00158522999845j),
(-0.0037795654498 + 0.00733159901574j),
(0.00842926371843 + 0.00777021236718j), (0.0112090632319 -
0.00249325321056j),
(-0.0027476802934 - 0.0115710813552j), (-0.0158688724041 -
0.00715934624895j),
(-0.00802888441831 + 0.00620818417519j), (0.0131985172629 +
0.0149175003171j),
(0.0190298333764 + 0.00956719089299j), (-0.00112380902283 -
0.00936658866704j),
(-0.0204226914793 - 0.0333464704454j), (-0.00695514678955 -
0.0437445007265j),
(0.0314490310848 - 0.0207983348519j), (0.0529675260186 +
0.0302227605134j),
(0.0317338332534 + 0.0667510479689j), (-0.00775565672666 +
0.0437112376094j),
(-0.024347923696 - 0.0303014591336j), (-0.0108893103898 -
0.0875638127327j),
(0.00204296782613 - 0.0721434056759j), (-0.00527479872108 -
0.00698097236454j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scc(4, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
5)
def test_fir_filter_scc_001(self):
self.generate_scc_source()
expected_data = ((-0.00775564694777+0.0437113791704j),
(0.0108830630779+0.0433648750186j),
(0.015553932637-0.0133284125477j),
(-0.0264905355871-0.0403266139328j),
(-0.0243480335921-0.03030154109j),
(-0.000327925226884-0.069333948195j),
(-0.0306392069906-0.107313856483j),
(-0.0452371090651-0.0854917764664j),
(-0.0108894333243-0.0875641107559j),
(-0.0182112380862-0.118961036205j),
(-0.0447825863957-0.0922874584794j),
(-0.0147479763255-0.0572904124856j),
(0.00204290449619-0.0721436738968j),
(-0.027713002637-0.0548989400268j),
(-0.0149045493454-0.00210141134448j),
(0.0176361314952-0.00149522523861j),
(-0.00527482619509-0.00698099425063j),
(-0.0151527002454+0.036265052855j),
(0.0199296213686+0.0452499426901j),
(0.0122985243797+0.0143278446048j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scc(1, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_deint_001 (self):
lenx = 64
src0 = gr.vector_source_s (range (lenx))
op = gr.deinterleave (gr.sizeof_short,4)
dst0 = gr.vector_sink_s ()
dst1 = gr.vector_sink_s ()
dst2 = gr.vector_sink_s ()
dst3 = gr.vector_sink_s ()
self.tb.connect (src0, op)
op.connect(dst0,usesPortName="short_out_0")
op.connect(dst1,usesPortName="short_out_1")
op.connect(dst2,usesPortName="short_out_2")
op.connect(dst3,usesPortName="short_out_3")
self.tb.run ()
expected_result0 = tuple (range (0, lenx, 4))
expected_result1 = tuple (range (1, lenx, 4))
expected_result2 = tuple (range (2, lenx, 4))
expected_result3 = tuple (range (3, lenx, 4))
self.assertFloatTuplesAlmostEqual (expected_result0, dst0.data())
self.assertFloatTuplesAlmostEqual (expected_result1, dst1.data())
self.assertFloatTuplesAlmostEqual (expected_result2, dst2.data ())
self.assertFloatTuplesAlmostEqual (expected_result3, dst3.data ())
def test_fir_filter_scf_002(self):
self.generate_scf_source()
expected_data = ((0.00824625696987 - 1.50158575707e-05j),
(0.0020101047121 - 0.0116540221497j),
(-0.0126378880814 - 0.00259830290452j),
(-0.00363933457993 + 0.00837504956871j),
(0.00107023562305 + 0.00915473792702j),
(0.0169738996774 + 0.00422182958573j),
(0.00630031805485 - 0.025423232466j),
(-0.0283014029264 + 0.00104465708137j),
(0.00890890974551 + 0.0115978596732j),
(-0.0142687577754 + 0.00306978379376j),
(0.02845691517 + 0.0331163145602j),
(0.0538152232766 - 0.0908300876617j),
(-0.0843691527843 - 0.0956566259265j),
(0.0476895272732 + 0.0747984498739j),
(0.0898786485195 + 0.082478672266j),
(-0.0330070182681 + 0.101965606213j),
(0.0574697069824 - 0.0350842289627j),
(-0.0770940706134 - 0.230615705252j),
(-0.103762261569 -
0.0382265634835j), (0.11808334291 + 0.104863762856j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scf(4, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
5)
def test_fir_filter_scf_001(self):
self.generate_scf_source()
expected_data = (
(-0.0330070219934 + 0.101965591311j),
(-0.0484239049256 + 0.0872343629599j),
(-0.0214109234512 + 0.102555386722j), (0.0484058149159 +
0.0557125210762j),
(0.0574690811336 - 0.0350844524801j), (0.0365394353867 -
0.0802438184619j),
(0.0453781634569 - 0.130992040038j), (0.00801951438189 -
0.214278846979j),
(-0.0770946145058 - 0.230616629124j), (-0.105601429939 -
0.190731987357j),
(-0.105361394584 - 0.177761554718j), (-0.131518915296 -
0.136102750897j),
(-0.103761836886 - 0.0382263250649j), (-0.0167790111154 +
0.0152206514031j),
(0.0277570039034 + 0.0300403907895j), (0.056065287441 +
0.0806603953242j),
(0.118084669113 + 0.104863211513j), (0.128281414509 +
0.0677760615945j),
(0.0748447552323 + 0.0619902014732j), (0.0512856245041 +
0.0775099247694j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scf(1, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:],
5)
def test_fir_filter_scf_001(self):
self.generate_scf_source()
expected_data = ((-0.0330070219934+0.101965591311j),
(-0.0484239049256+0.0872343629599j),
(-0.0214109234512+0.102555386722j),
(0.0484058149159+0.0557125210762j),
(0.0574690811336-0.0350844524801j),
(0.0365394353867-0.0802438184619j),
(0.0453781634569-0.130992040038j),
(0.00801951438189-0.214278846979j),
(-0.0770946145058-0.230616629124j),
(-0.105601429939-0.190731987357j),
(-0.105361394584-0.177761554718j),
(-0.131518915296-0.136102750897j),
(-0.103761836886-0.0382263250649j),
(-0.0167790111154+0.0152206514031j),
(0.0277570039034+0.0300403907895j),
(0.056065287441+0.0806603953242j),
(0.118084669113+0.104863211513j),
(0.128281414509+0.0677760615945j),
(0.0748447552323+0.0619902014732j),
(0.0512856245041+0.0775099247694j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scf(1, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_scf_002(self):
self.generate_scf_source()
expected_data = ((0.00824625696987-1.50158575707e-05j),
(0.0020101047121-0.0116540221497j),
(-0.0126378880814-0.00259830290452j),
(-0.00363933457993+0.00837504956871j),
(0.00107023562305+0.00915473792702j),
(0.0169738996774+0.00422182958573j),
(0.00630031805485-0.025423232466j),
(-0.0283014029264+0.00104465708137j),
(0.00890890974551+0.0115978596732j),
(-0.0142687577754+0.00306978379376j),
(0.02845691517+0.0331163145602j),
(0.0538152232766-0.0908300876617j),
(-0.0843691527843-0.0956566259265j),
(0.0476895272732+0.0747984498739j),
(0.0898786485195+0.082478672266j),
(-0.0330070182681+0.101965606213j),
(0.0574697069824-0.0350842289627j),
(-0.0770940706134-0.230615705252j),
(-0.103762261569-0.0382265634835j),
(0.11808334291+0.104863762856j))
src = gr.vector_source_s(self.src_data)
op = filter.freq_xlating_fir_filter_scf(4, self.taps, self.fc, self.fs)
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
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.symbol_rate = symbol_rate = 1000000
self.samp_rate = samp_rate = 500000
##################################################
# Blocks
##################################################
self.uhd_usrp_sink_0 = uhd.usrp_sink(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(symbol_rate)
self.uhd_usrp_sink_0.set_center_freq(915000000, 0)
self.uhd_usrp_sink_0.set_gain(20, 0)
self.random_source_x_0 = gr.vector_source_s(
map(int, numpy.random.randint(0, 2, 2000000)), True)
self.digital_qam_mod_0 = digital.qam.qam_mod(
constellation_points=4,
mod_code="gray",
differential=True,
samples_per_symbol=2,
excess_bw=0.01,
verbose=False,
log=False,
)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1,
symbol_rate)
self.blocks_short_to_float_0 = blocks.short_to_float(1, 1)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_float_to_uchar_0 = blocks.float_to_uchar()
self.analog_sig_source_x_0 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, 915000000, 1, 0)
##################################################
# Connections
##################################################
self.connect((self.random_source_x_0, 0),
(self.blocks_short_to_float_0, 0))
self.connect((self.blocks_short_to_float_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0),
(self.blocks_float_to_uchar_0, 0))
self.connect((self.blocks_float_to_uchar_0, 0),
(self.digital_qam_mod_0, 0))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_multiply_xx_0, 0), (self.uhd_usrp_sink_0, 0))
self.connect((self.digital_qam_mod_0, 0),
(self.blocks_multiply_xx_0, 0))
def test_000_ss(self):
src_data = (1, 2, 3, 4, 5, 6)
dst_data = (6, 15)
src = gr.vector_source_s(src_data)
itg = gr.integrate_ss(3)
dst = gr.vector_sink_s()
self.tb.connect(src, itg, dst)
self.tb.run()
self.assertEqual(dst_data, dst.data())
def help_sf_const (self, src_data, exp_data, op):
for s in zip (range (len (src_data)), src_data):
src = gr.vector_source_s (s[1])
self.tb.connect (src, (op, s[0]))
dst = gr.vector_sink_f ()
self.tb.connect (op, dst)
self.tb.run ()
result_data = dst.data ()
self.assertEqual (exp_data, result_data)
def test_interleaved_short_to_complex(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j, 9 + 10j)
src = gr.vector_source_s(src_data)
op = blocks_swig.interleaved_short_to_complex()
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_short_to_char(self):
src_data = (256, 512, 768, 1024, 1280)
expected_data = (1, 2, 3, 4, 5)
src = gr.vector_source_s(src_data)
op = blocks_swig.short_to_char()
dst = gr.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_and_const_ss (self):
src_data = (1, 2, 3, 0x5004, 0x1150)
expected_result = (0, 2, 2, 0x5000, 0x1100)
src = gr.vector_source_s(src_data)
op = blocks_swig.and_const_ss (0x55AA)
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(dst.data(), expected_result)
def test_000_ss(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_s(src_data) itg = blocks_swig.integrate_ss(3) dst = gr.vector_sink_s() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def test_short_to_float_scale(self):
src_data = (5, 10, 15, 20, 25)
expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
src = gr.vector_source_s(src_data)
op = blocks_swig.short_to_float(1, 5)
dst = gr.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def help_const_ss(self, src_data, exp_data, op):
src = gr.vector_source_s(src_data)
srcv = gr.stream_to_vector(gr.sizeof_short, len(src_data))
rhs = gr.vector_to_stream(gr.sizeof_short, len(src_data))
dst = gr.vector_sink_s()
self.tb.connect(src, srcv, op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def help_const_ss(self, src_data, exp_data, op):
for s in zip(range(len(src_data)), src_data):
src = gr.vector_source_s(s[1])
self.tb.connect(src, (op, s[0]))
dst = gr.vector_sink_s()
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_short_to_float_scale(self):
src_data = (5, 10, 15, 20, 25)
expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
src = gr.vector_source_s(src_data)
op = blocks_swig.short_to_float(1, 5)
dst = gr.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_short_to_char(self):
src_data = (256, 512, 768, 1024, 1280)
expected_data = (1, 2, 3, 4, 5)
src = gr.vector_source_s(src_data)
op = blocks_swig.short_to_char()
dst = gr.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_interleaved_short_to_complex(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j)
src = gr.vector_source_s(src_data)
op = blocks_swig.interleaved_short_to_complex()
dst = gr.vector_sink_c()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def help_const_ss(self, src_data, exp_data, op):
src = gr.vector_source_s(src_data)
srcv = gr.stream_to_vector(gr.sizeof_short, len(src_data))
rhs = gr.vector_to_stream(gr.sizeof_short, len(src_data))
dst = gr.vector_sink_s()
self.tb.connect(src, srcv, op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_001_fpdata_sink (self):
src_data = (-3, 4, -5, 2, 3)
expected_result = (-3, 4, -5, 2, 3)
src = gr.vector_source_s (src_data)
fpgnu = fpgnu_swig.fpdata_sink (1)
dst = gr.vector_sink_s ()
self.tb.connect (src, fpgnu)
self.tb.connect (fpgnu, dst)
self.tb.run ()
result_data = dst.data ()
def test_skip_all(self):
skip_cnt = len(self.src_data)
expected_result = tuple(self.src_data[skip_cnt:])
src1 = gr.vector_source_s (self.src_data)
op = gr.skiphead (gr.sizeof_short, skip_cnt)
dst1 = gr.vector_sink_s ()
self.tb.connect (src1, op, dst1)
self.tb.run ()
dst_data = dst1.data ()
self.assertEqual (expected_result, dst_data)
def test_skip_all(self):
skip_cnt = len(self.src_data)
expected_result = tuple(self.src_data[skip_cnt:])
src1 = gr.vector_source_s(self.src_data)
op = gr.skiphead(gr.sizeof_short, skip_cnt)
dst1 = gr.vector_sink_s()
self.tb.connect(src1, op, dst1)
self.tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_copy_drop (self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_result = ()
src = gr.vector_source_s(src_data)
op = gr.copy(gr.sizeof_short, False, 2)
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
dst_data = dst.data()
self.assertEqual(expected_result, dst_data)
def main():
data = scipy.arange(0, 32000, 1).tolist()
trig = 100*[0,] + 100*[1,]
src = gr.vector_source_s(data, True)
trigger = gr.vector_source_s(trig, True)
thr = gr.throttle(gr.sizeof_short, 10e3)
ann = gr.annotator_alltoall(1000000, gr.sizeof_short)
tagger = gr.burst_tagger(gr.sizeof_short)
fsnk = gr.tagged_file_sink(gr.sizeof_short, 1)
tb = gr.top_block()
tb.connect(src, thr, (tagger, 0))
tb.connect(trigger, (tagger, 1))
tb.connect(tagger, fsnk)
tb.run()
def help_sf (self, src_data, exp_data, op):
for s in zip (range (len (src_data)), src_data):
src = gr.vector_source_s (s[1])
src.source.connect(op,providesPortName="data_in_"+str(s[0]))
src.streamID = str(s[0])
self.tb.sources.append(src)
dst = gr.vector_sink_f ()
self.tb.connect (op, dst)
self.tb.run ()
result_data = dst.data ()
self.assertEqual (exp_data, result_data)
def help_ss(self, src_data, exp_data, op, port_prefix='data_in_'):
for s in zip(range(len(src_data)), src_data):
src = gr.vector_source_s(s[1])
src.source.connect(op, providesPortName=port_prefix + str(s[0]))
src.streamID = str(s[0])
self.tb.sources.append(src)
dst = gr.vector_sink_s()
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_001_short(self):
src_data = [n*1 for n in range(100)];
dst_data = []
for n in range(100):
dst_data += [n, n, n]
src = gr.vector_source_s(src_data)
rpt = gr.repeat(gr.sizeof_short, 3)
dst = gr.vector_sink_s()
self.tb.connect(src, rpt, dst)
self.tb.run()
self.assertEqual(tuple(dst_data), dst.data())
def run_test(f, Kb, bitspersymbol, K, channel, modulation, dimensionality,
tot_constellation, N0, seed):
tb = gr.top_block()
L = len(channel)
# TX
# this for loop is TOO slow in python!!!
packet = [0] * (K + 2 * L)
random.seed(seed)
for i in range(len(packet)):
packet[i] = random.randint(0, 2**bitspersymbol - 1) # random symbols
for i in range(L): # first/last L symbols set to 0
packet[i] = 0
packet[len(packet) - i - 1] = 0
src = gr.vector_source_s(packet, False)
mod = gr.chunks_to_symbols_sf(modulation[1], modulation[0])
# CHANNEL
isi = gr.fir_filter_fff(1, channel)
add = gr.add_ff()
noise = gr.noise_source_f(gr.GR_GAUSSIAN, math.sqrt(N0 / 2), seed)
# RX
skip = gr.skiphead(
gr.sizeof_float, L
) # skip the first L samples since you know they are coming from the L zero symbols
#metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi
#va = trellis.viterbi_s(f,K+L,0,0) # Put -1 if the Initial/Final states are not set.
va = trellis.viterbi_combined_s(
f, K + L, 0, 0, dimensionality, tot_constellation,
trellis.TRELLIS_EUCLIDEAN
) # using viterbi_combined_s instead of metrics_f/viterbi_s allows larger packet lengths because metrics_f is complaining for not being able to allocate large buffers. This is due to the large f.O() in this application...
dst = gr.vector_sink_s()
tb.connect(src, mod)
tb.connect(mod, isi, (add, 0))
tb.connect(noise, (add, 1))
#tb.connect (add,metrics)
#tb.connect (metrics,va,dst)
tb.connect(add, skip, va, dst)
tb.run()
data = dst.data()
ntotal = len(data) - L
nright = 0
for i in range(ntotal):
if packet[i + L] == data[i]:
nright = nright + 1
#else:
#print "Error in ", i
return (ntotal, ntotal - nright)
def help_ss(self, size, src_data, exp_data, op):
for s in zip(range (len (src_data)), src_data):
src = gr.vector_source_s(s[1])
srcv = gr.stream_to_vector(gr.sizeof_short, size)
self.tb.connect(src, srcv)
self.tb.connect(srcv, (op, s[0]))
rhs = gr.vector_to_stream(gr.sizeof_short, size)
dst = gr.vector_sink_s()
self.tb.connect(op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_001 (self): repetitions = 4 #unsigned short input_bits, unsigned short repetitions uut = ofdm.repetition_encoder_sb(4, repetitions, [0]*(4*repetitions)) src = gr.vector_source_s([16+8+4+2+1, 16+1]) dst = gr.vector_sink_b() self.fg.connect(src, uut, dst) self.fg.run() ref = concatenate([[1,1,1,1]*repetitions, [1,0,0,0]*repetitions]) self.assertEqual(list(ref), list(dst.data()))
def test_deint_001(self):
lenx = 64
src = gr.vector_source_s(range(lenx))
op = gr.deinterleave(gr.sizeof_short, 1)
dst0 = gr.vector_sink_s()
self.tb.connect(src, op)
self.tb.connect((op, 0), dst0)
self.tb.run()
expected_result0 = tuple(range(0, lenx, 1))
self.assertFloatTuplesAlmostEqual(expected_result0, dst0.data())
def test_deint_001 (self):
lenx = 64
src = gr.vector_source_s (range (lenx))
op = gr.deinterleave (gr.sizeof_short, 1)
dst0 = gr.vector_sink_s ()
self.tb.connect (src, op)
self.tb.connect ((op, 0), dst0)
self.tb.run ()
expected_result0 = tuple (range (0, lenx, 1))
self.assertFloatTuplesAlmostEqual (expected_result0, dst0.data ())
def help_ss(self, size, src_data, exp_data, op):
for s in zip(range(len(src_data)), src_data):
src = gr.vector_source_s(s[1])
srcv = gr.stream_to_vector(gr.sizeof_short, size)
self.tb.connect(src, srcv)
self.tb.connect(srcv, (op, s[0]))
rhs = gr.vector_to_stream(gr.sizeof_short, size)
dst = gr.vector_sink_s()
self.tb.connect(op, rhs, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_001(self):
self.maxDiff = None
tb = gr.top_block()
src1 = gr.vector_source_s(range(0, 100))
src2 = gr.vector_source_s(range(0, 100))
src3 = gr.vector_source_s(range(0, 100))
# itemsize, M, N, offset
km2 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 2, 0)
km3 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 3, 1)
km7 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 7, 2)
snk2 = gr.vector_sink_s()
snk3 = gr.vector_sink_s()
snk7 = gr.vector_sink_s()
tb.connect(src1, km2, snk2)
tb.connect(src2, km3, snk3)
tb.connect(src3, km7, snk7)
tb.run()
self.assertEqual(range(0, 100, 2), list(snk2.data()))
self.assertEqual(range(1, 100, 3), list(snk3.data()))
self.assertEqual(range(2, 100, 7), list(snk7.data()))
def test_003 (self): repetitions = 4 inout = [8+4+2+1, 1] #unsigned short input_bits, unsigned short repetitions uut1 = ofdm.repetition_encoder_sb(4, repetitions, [1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,0]) uut2 = ofdm.repetition_decoder_bs(4, repetitions, [1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,0]) src = gr.vector_source_s(inout) dst = gr.vector_sink_s() self.fg.connect(src, uut1, uut2, dst) self.fg.run() self.assertEqual(inout, list(dst.data()))
def test_003_s(self):
value = 12
repeats = 100
src_data = [value] * repeats
src = gr.vector_source_s(src_data)
dst = gr.probe_signal_s()
self.tb.connect(src, dst)
self.tb.run()
output = dst.level
self.assertEqual(value, output)
def test_003_s(self):
value = 12
repeats = 100
src_data = [value] * repeats
src = gr.vector_source_s(src_data)
dst = gr.probe_signal_s()
self.tb.connect(src, dst)
self.tb.run()
output = dst.level
self.assertEqual(value, output)
def test_001(self):
self.maxDiff = None
tb = gr.top_block()
src1 = gr.vector_source_s(range(0, 100))
src2 = gr.vector_source_s(range(0, 100))
src3 = gr.vector_source_s(range(0, 100))
# itemsize, M, N, offset
km2 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 2, 0)
km3 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 3, 1)
km7 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 7, 2)
snk2 = gr.vector_sink_s()
snk3 = gr.vector_sink_s()
snk7 = gr.vector_sink_s()
tb.connect(src1, km2, snk2)
tb.connect(src2, km3, snk3)
tb.connect(src3, km7, snk7)
tb.run()
self.assertEqual(range(0, 100, 2), list(snk2.data()))
self.assertEqual(range(1, 100, 3), list(snk3.data()))
self.assertEqual(range(2, 100, 7), list(snk7.data()))
def test_001(self):
src_data = [1, 2, 3, 4]
expected_result = [256, 512, 768, 1024]
src = gr.vector_source_s(src_data)
op = gr.endian_swap(2)
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
def main():
data = scipy.arange(0, 32000, 1).tolist()
trig = 100 * [
0,
] + 100 * [
1,
]
src = gr.vector_source_s(data, True)
trigger = gr.vector_source_s(trig, True)
thr = gr.throttle(gr.sizeof_short, 10e3)
ann = gr.annotator_alltoall(1000000, gr.sizeof_short)
tagger = gr.burst_tagger(gr.sizeof_short)
fsnk = gr.tagged_file_sink(gr.sizeof_short, 1)
tb = gr.top_block()
tb.connect(src, thr, (tagger, 0))
tb.connect(trigger, (tagger, 1))
tb.connect(tagger, fsnk)
tb.run()
def test_001(self):
src_data = range(0, 32767, 32767 / 127)
src_data = [int(s) for s in src_data]
expected_result = range(0, 128)
src = gr.vector_source_s(src_data)
op = gr.short_to_char()
dst = gr.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_result, result_data)
