def setup_bpsk0(self):
self.tb = gr.top_block()
# Build the constellation object
arity = 2
bps = 1
pts, code = digital.psk_2_0x0()
constellation = digital.constellation_psk(pts, code, 2)
# Create BPSK data to pass to the demodulator
src = blocks.vector_source_b(self.src_data_bpsk)
p2u = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
mod = digital.generic_mod(constellation, True, self.sps, True, self.eb)
snk = blocks.vector_sink_c()
tb = gr.top_block()
tb.connect(src, p2u, mod, snk)
tb.run()
self.src = blocks.vector_source_c(snk.data())
self.freq_recov = digital.fll_band_edge_cc(self.sps, self.eb,
self.fll_ntaps, self.freq_bw)
self.time_recov = digital.pfb_clock_sync_ccf(self.sps, self.timing_bw, self.taps,
self.nfilts, self.nfilts//2, self.timing_max_dev)
self.receiver = digital.constellation_receiver_cb(
constellation.base(), self.phase_bw, self.fmin, self.fmax)
self.diffdec = digital.diff_decoder_bb(arity)
self.symbol_mapper = digital.map_bb(
mod_codes.invert_code(constellation.pre_diff_code()))
self.unpack = blocks.unpack_k_bits_bb(bps)
self.snk = blocks.null_sink(gr.sizeof_char)
self.tb.connect(self.src, self.freq_recov, self.time_recov, self.receiver)
self.tb.connect(self.receiver, self.diffdec, self.symbol_mapper, self.unpack)
self.tb.connect(self.unpack, self.snk)
def setup_test05(self):
print "... benchmarking 8-PSK demapper"
self.nobits = 4
self.data_subcarriers = 200
self.blks = self.N*(10 + 1)
self.tb = gr.top_block()
#self.bitmap = [self.nobits]*self.data_subcarriers
self.demodulator = generic_demapper_vcb(self.data_subcarriers,10)
const = self.demodulator.get_constellation( self.nobits )
assert( len( const ) == 2**self.nobits )
self.bitdata = [random()+1j*random() for i in range(self.blks*self.data_subcarriers)]
self.src = blocks.vector_source_c(self.bitdata,False, self.data_subcarriers)
#self.src = symbol_random_src( const, self.data_subcarriers )
self.bitmap = [0]*self.data_subcarriers + [self.nobits]*self.data_subcarriers
self.bitmap_src = blocks.vector_source_b(self.bitmap,True, self.data_subcarriers)
#self.bmaptrig_stream = [1, 2]+[0]*(11-2)
#self.bitmap_trigger = blocks.vector_source_b(self.bmaptrig_stream, True)
self.snk = blocks.null_sink(gr.sizeof_char)
self.tb.connect(self.src,self.demodulator,self.snk)
self.tb.connect(self.bitmap_src,(self.demodulator,1))
def xtest_005_interp_random_vals(self):
MAX_TAPS = 9
MAX_INTERP = 7
INPUT_LEN = 9
random.seed(0) # we want reproducibility
for ntaps in xrange(1, MAX_TAPS + 1):
for interp in xrange(1, MAX_INTERP+1):
for ilen in xrange(ntaps, ntaps + INPUT_LEN):
src_data = random_floats(ilen)
taps = random_floats(ntaps)
expected_result = reference_interp_filter(src_data, interp, taps)
tb = gr.top_block()
src = gr.vector_source_f(src_data)
op = gr.rational_resampler_base_fff(interp, 1, taps)
dst = gr.vector_sink_f()
tb.connect(src, op, dst)
tb.run()
tb = None
result_data = dst.data()
L1 = len(result_data)
L2 = len(expected_result)
L = min(L1, L2)
#if True or abs(L1-L2) > 1:
if False:
sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' % (L2 - L1, ntaps, interp, ilen))
#sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' %
# (len(result_data), len(expected_result)))
#self.assertEqual(expected_result[0:L], result_data[0:L])
# FIXME check first ntaps+1 answers
self.assertEqual(expected_result[ntaps+1:L], result_data[ntaps+1:L])
def main():
sys.path.append(os.getcwd())
from PHY import PhysicalLayer
samples_per_symbol = 4
samp_rate = 4e6
tb = gr.top_block()
modulator = blks2.gmsk_mod(samples_per_symbol=samples_per_symbol)
demodulator = blks2.gmsk_demod(samples_per_symbol=samples_per_symbol)
sys.stderr.write('Using bitrate %sbits/s\n' % eng_notation.num_to_str(samp_rate / samples_per_symbol / modulator.bits_per_symbol()))
sys.stderr.flush()
phy = PhysicalLayer.PhysicalLayer(modulator, demodulator, hint = 'addr=192.168.10.2', access_code = 'master')
tb.connect(phy)
phy.tune(1.8e9)
phy.set_gain(45)
phy.set_samp_rate(samp_rate)
args = shlex.split('cvlc --sout "#transcode{vcodec=theora, vb=128}:std{access=file, mux=ogg, dst=-}" v4l2:///dev/video0')
child = subprocess.Popen(args, stdout = subprocess.PIPE, stdin = subprocess.PIPE, stderr=None)
print 'Started vlc with pid', child.pid
def read_data_from_child():
print "[DEBUG] reading from child's pipe"
phy.send_pkt(child.stdout.read(512))
return True
tb.start()
gobject.threads_init()
gobject.idle_add(read_data_from_child)
loop = gobject.MainLoop()
loop.run()
def test_006_interp_decim(self):
taps = (0,1,0,0)
src_data = range(10000)
interp = 3
decimation = 2
expected_result = reference_interp_dec_filter(src_data, interp, decimation, taps)
tb = gr.top_block()
src = gr.vector_source_f(src_data)
op = gr.rational_resampler_base_fff(interp, decimation, taps)
dst = gr.vector_sink_f()
tb.connect(src, op)
tb.connect(op, dst)
tb.run()
result_data = dst.data()
L1 = len(result_data)
L2 = len(expected_result)
L = min(L1, L2)
if False:
sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' %
(L2 - L1, len(taps), decimation, len(src_data)))
sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' %
(len(result_data), len(expected_result)))
self.assertEqual(expected_result[1:L], result_data[1:L])
def test_002_interp(self):
taps = random_floats(31)
#src_data = random_floats(10000) # FIXME the 10k case fails!
src_data = random_floats(1000)
interpolation = 3
expected_result = reference_interp_filter(src_data, interpolation, taps)
tb = gr.top_block()
src = gr.vector_source_f(src_data)
op = gr.rational_resampler_base_fff(interpolation, 1, taps)
dst = gr.vector_sink_f()
tb.connect(src, op)
tb.connect(op, dst)
tb.run()
result_data = dst.data()
L1 = len(result_data)
L2 = len(expected_result)
L = min(L1, L2)
if False:
sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' %
(L2 - L1, len(taps), interpolation, len(src_data)))
sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' %
(len(result_data), len(expected_result)))
#self.assertEqual(expected_result[0:L], result_data[0:L])
# FIXME check first 3 answers
self.assertEqual(expected_result[3:L], result_data[3:L])
def xtest_004_decim_random_vals(self):
MAX_TAPS = 9
MAX_DECIM = 7
OUTPUT_LEN = 9
random.seed(0) # we want reproducibility
for ntaps in xrange(1, MAX_TAPS + 1):
for decim in xrange(1, MAX_DECIM+1):
for ilen in xrange(ntaps + decim, ntaps + OUTPUT_LEN*decim):
src_data = random_floats(ilen)
taps = random_floats(ntaps)
expected_result = reference_dec_filter(src_data, decim, taps)
tb = gr.top_block()
src = gr.vector_source_f(src_data)
op = gr.rational_resampler_base_fff(1, decim, taps)
dst = gr.vector_sink_f()
tb.connect(src, op, dst)
tb.run()
tb = None
result_data = dst.data()
L1 = len(result_data)
L2 = len(expected_result)
L = min(L1, L2)
if False:
sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' % (L2 - L1, ntaps, decim, ilen))
sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' %
(len(result_data), len(expected_result)))
self.assertEqual(expected_result[0:L], result_data[0:L])
def setUp (self):
self.tb = gr.top_block()
self.tmpfile = tempfile.NamedTemporaryFile()
self.prevfd = os.dup(sys.stdout.fileno())
os.dup2(self.tmpfile.fileno(), sys.stdout.fileno())
self.prev = sys.stdout
sys.stdout = os.fdopen(self.prevfd, "w")
def setUp(self):
self.tb = gr.top_block()
random.seed(0) # make repeatable
N = 10000
self._noise = [get_n_cplx() for i in xrange(N)]
self._bits = [get_cplx() for i in xrange(N)]
def build_graph():
sample_rate = 8000
scale_factor = 32000
tb = gr.top_block()
src = audio.source(sample_rate, "plughw:0,0")
src_scale = blocks.multiply_const_ff(scale_factor)
interp = filter.rational_resampler_fff(8, 1)
f2s = blocks.float_to_short()
enc = vocoder.cvsd_encode_sb()
dec = vocoder.cvsd_decode_bs()
s2f = blocks.short_to_float()
decim = filter.rational_resampler_fff(1, 8)
sink_scale = blocks.multiply_const_ff(1.0/scale_factor)
sink = audio.sink(sample_rate, "plughw:0,0")
tb.connect(src, src_scale, interp, f2s, enc)
tb.connect(enc, dec, s2f, decim, sink_scale, sink)
if 0: # debug
tb.conect(src, blocks.file_sink(gr.sizeof_float, "source.dat"))
tb.conect(src_scale, blocks.file_sink(gr.sizeof_float, "src_scale.dat"))
tb.conect(interp, blocks.file_sink(gr.sizeof_float, "interp.dat"))
tb.conect(f2s, blocks.file_sink(gr.sizeof_short, "f2s.dat"))
tb.conect(enc, blocks.file_sink(gr.sizeof_char, "enc.dat"))
tb.conect(dec, blocks.file_sink(gr.sizeof_short, "dec.dat"))
tb.conect(s2f, blocks.file_sink(gr.sizeof_float, "s2f.dat"))
tb.conect(decim, blocks.file_sink(gr.sizeof_float, "decim.dat"))
tb.conect(sink_scale, blocks.file_sink(gr.sizeof_float, "sink_scale.dat"))
return tb
def derandomizer_pp_desync(self, offset): """ Tests the ability of the derandomiser to synchronise when the inverted SYNC is <offset> packets away Note: This method itself is not a unit test method. """ assert offset < 8 useful_data = make_transport_stream() src = gr.vector_source_b(useful_data) pad = dvb_swig.pad_mpeg_ts_packet_bp() randomizer = dvb_swig.randomizer_pp() depad = dvb_swig.depad_mpeg_ts_packet_pb() dst = gr.vector_sink_b() self.tb.connect(src, pad, randomizer, depad, dst) self.tb.run() randomized_data = dst.data() src_data = make_fake_transport_stream_packet(offset) src_data.extend(randomized_data) self.tb = gr.top_block() src = gr.vector_source_b(src_data) pad = dvb_swig.pad_mpeg_ts_packet_bp() derandomizer = dvb_swig.derandomizer_pp() depad = dvb_swig.depad_mpeg_ts_packet_pb() dst = gr.vector_sink_b() self.tb.connect(src, pad, derandomizer, depad, dst) self.tb.run() result_data = dst.data() self.assertEqual(tuple(useful_data), result_data[-len(useful_data):])
def vars_receive(self):
if self.waterfall or self.FFTIN or self.FFTOUT:
t = grc_wxgui.top_block_gui(title="OrcaTUN")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
t.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
else:
t = gr.top_block()
##################################################
# Variables
##################################################
t.transistion = self.transistion
t.sps = self.sps
t.sideband_rx = self.sideband_rx
#t.sideband = self.sideband
t.samp_rate = self.samp_rate
#t.payload = self.payload
#t.interpolation = self.interpolation
#t._crcpolynom_config = self._crcpolynom_config
#t.crcpolynom = self.crcpolynom
#t.crcpolynom = self.crcpolynom
t.carrier_b = self.carrier_b
#t.carrier_a = self.carrier_a
#t._accesscode_config = self._accesscode_config
#t.accesscode = self.accesscode
return t
def setUp (self):
print "setUp"
self.tb = gr.top_block ()
self.src = gr.vector_source_c([0]*240,False,240)
self.demapper = lte_swig.layer_demapper_vcvc(0, "tx_diversity")
self.snk = gr.vector_sink_c(240)
self.tb.connect(self.src, self.demapper, self.snk)
def test_024_disconnect_single(self):
hblock = gr.top_block("test_block")
blk = gr.hier_block2("block",
gr.io_signature(0, 0, 0),
gr.io_signature(0, 0, 0))
hblock.connect(blk)
hblock.disconnect(blk)
def test_025_disconnect_single_not_connected(self):
hblock = gr.top_block("test_block")
blk = gr.hier_block2("block",
gr.io_signature(0, 0, 0),
gr.io_signature(0, 0, 0))
self.assertRaises(RuntimeError,
lambda: hblock.disconnect(blk))
def setUp (self):
#print os.getpid()
#raw_input("press the any key")
self.tb = gr.top_block ()
offset = 43223 #sample15 = 21839 #sample20 = 43223
fftl = 512
cpl = 144*fftl/2048
cpl0 = 160*fftl/2048
slotl = 7*fftl+6*cpl+cpl0
cell_id = 124
N_rb_dl = 6
mod=scipy.io.loadmat('/home/demel/exchange/matlab_test_first_freq.mat')
mat_u1=tuple(mod['test'].flatten())
mat_d=range(len(mat_u1))
for idx, val in enumerate(mat_u1):
mat_d[idx]=val
intu=tuple(mat_d[0:slotl*60])
self.src = gr.vector_source_c(intu,False,1)
self.tag = lte.tag_symbol_cc(offset,fftl)
#self.head = gr.head(gr.sizeof_gr_complex,70000)
self.sel = lte.sss_selector_cvc(fftl)
self.vtos = gr.vector_to_stream(gr.sizeof_gr_complex,512)
self.snk = gr.vector_sink_c(1)
self.tb.connect(self.src,self.tag,self.sel,self.vtos,self.snk)#,self.head
def test_022_connect_single_with_ports(self):
hblock = gr.top_block("test_block")
blk = gr.hier_block2("block",
gr.io_signature(1, 1, 1),
gr.io_signature(1, 1, 1))
self.assertRaises(RuntimeError,
lambda: hblock.connect(blk))
def setUp (self):
print "qa_remove_cp2_cvc SetUp!"
self.fftl = fftl = 2048
cpl = 144*fftl/2048
cpl0 = 160*fftl/2048
self.slotl = slotl = 7*fftl+6*cpl+cpl0
self.tb = gr.top_block ()
#provide test data
self.src = gr.noise_source_c(gr.GR_GAUSSIAN,1)
self.head = gr.head( gr.sizeof_gr_complex, 10*slotl )
self.tag = lte.pss_tagging_cc(fftl)
# set up tagging block
self.tag.set_half_frame_start(0)
self.tag.set_N_id_2(1)
self.tag.lock()
# UUT
self.rcp = lte.remove_cp2_cvc(fftl)
# sinks
self.snk = gr.vector_sink_c(fftl)
self.tagsnc = gr.tag_debug(gr.sizeof_gr_complex*fftl, "remove_cp2_cvc")
# connect blocks
self.tb.connect(self.src, self.head, self.tag, self.rcp, self.snk )
def setUp (self):
self.tb = gr.top_block ()
fftl = 512
waveform = gr.GR_SIN_WAVE
freq = 0.0
ampl = 1.0
offset = 0.0
cpl = 144 * fftl / 2048
cpl0 = 160 * fftl / 2048
slotl = 7 * fftl + 6 * cpl + cpl0
samp_rate = slotl / 0.0005
self.sig = gr.sig_source_c(samp_rate,waveform,freq,ampl,offset)
self.head = gr.head(gr.sizeof_gr_complex, 100000)
print "amplitude\t" + str(self.sig.amplitude())
print "frequency\t" + str(self.sig.frequency())
print "name\t" + str(self.sig.name())
print "offset\t" + str(self.sig.offset())
print "samp_rate\t" + str(self.sig.sampling_freq())
print "waveform\t" + str(self.sig.waveform())
#print type(self.sig)
self.est = lte_swig.freq_estimate_c(self.sig,fftl)
self.tb.connect(self.sig,self.head,self.est)
def test_004_es_source_pdus(self):
print "test_004_es_source_pdus"
msg = pmt.cons( pmt.to_pmt( {"somekey":"val2", "somekey2":"someval2" } ),
pmt.to_pmt( numpy.array( [0,1,2,3,4,5,6,7,8,9] , dtype=numpy.float32) ) );
src = es.source([gr.sizeof_float], 8, 2);
stb = blocks.message_strobe( msg, 100.0 );
tb = gr.top_block();
tb.msg_connect(stb, "strobe", src, "schedule_event");
th = blocks.throttle(gr.sizeof_float, 1000*100);
hd = blocks.head(gr.sizeof_float, 1000*100);
snk = blocks.vector_sink_f();
tb.connect(src,th,hd,snk);
# TODO: this can not use run because it is
# subject to GNU Radio's shutdown msg block bug
# for remaining upstream msg blocks ...
#tb.run();
# workaround
tb.start();
time.sleep(1);
tb.stop();
tb.wait();
self.assertEqual( sum(snk.data())>0, True );
def setUp (self):
self.tb = gr.top_block ()
self.c = phy(slow_rate=True)
self.dqcsk_mapper = ieee802_15_4.dqcsk_mapper_fc(self.c.chirp_seq, self.c.time_gap_1, self.c.time_gap_2, c.n_sub, self.c.n_subchirps)
self.dqcsk_demapper = ieee802_15_4.dqcsk_demapper_cf(self.c.chirp_seq, self.c.time_gap_1, self.c.time_gap_2, c.n_sub, self.c.n_subchirps)
self.dqpsk_mapper = ieee802_15_4.dqpsk_mapper_ff(framelen=self.c.nsym_frame, forward=True)
self.dqpsk_demapper = ieee802_15_4.dqpsk_mapper_ff(framelen=self.c.nsym_frame, forward=False)
self.qpsk_mapper = ieee802_15_4.qpsk_mapper_if()
self.qpsk_demapper = ieee802_15_4.qpsk_demapper_fi()
self.preamble_sfd_prefixer_I = ieee802_15_4.preamble_sfd_prefixer_ii(self.c.preamble, self.c.SFD, self.c.nsym_frame)
self.preamble_sfd_removal_I = blocks.keep_m_in_n(gr.sizeof_int, self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD), self.c.nsym_frame, len(self.c.preamble)+len(self.c.SFD))
self.preamble_sfd_prefixer_Q = ieee802_15_4.preamble_sfd_prefixer_ii(self.c.preamble, self.c.SFD, self.c.nsym_frame)
self.preamble_sfd_removal_Q = blocks.keep_m_in_n(gr.sizeof_int, self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD), self.c.nsym_frame, len(self.c.preamble)+len(self.c.SFD))
self.interleaver_I = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=True)
self.interleaver_Q = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=True)
self.deinterleaver_I = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=False)
self.deinterleaver_Q = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=False)
self.codeword_mapper_I = ieee802_15_4.codeword_mapper_bi(self.c.bits_per_symbol, self.c.codewords)
self.codeword_mapper_Q = ieee802_15_4.codeword_mapper_bi(self.c.bits_per_symbol, self.c.codewords)
self.codeword_demapper_I = ieee802_15_4.codeword_demapper_ib(self.c.bits_per_symbol, self.c.codewords)
self.codeword_demapper_Q = ieee802_15_4.codeword_demapper_ib(self.c.bits_per_symbol, self.c.codewords)
self.demux = blocks.deinterleave(gr.sizeof_char*1,1)
self.mux = blocks.interleave(gr.sizeof_char*1,1)
self.zeropadding = ieee802_15_4.zeropadding_b(self.c.padded_zeros)
self.zeropadding_removal = ieee802_15_4.zeropadding_removal_b(self.c.phy_packetsize_bytes*8+len(self.c.PHR), self.c.padded_zeros)
self.phr_prefixer = ieee802_15_4.phr_prefixer(self.c.PHR)
self.phr_removal = ieee802_15_4.phr_removal(self.c.PHR)
self.fragmentation = ieee802_15_4.fragmentation(self.c.phy_packetsize_bytes)
def _update_sliced(self, filtered_symbols):
self.slicer_view.data = filtered_symbols
if filtered_symbols is None:
self.sliced_view.data = None
return
omega = float(filtered_symbols.sampling_rate) / self.burst.symbol_rate
mu = 0.5
data_source = filtered_symbols.samples
numpy_source = NumpySource(data_source)
clock_recovery = digital.clock_recovery_mm_ff(omega, self._gain_omega, mu, self._gain_mu, self._omega_relative_limit)
numpy_sink = NumpySink(numpy.float32)
top = gr.top_block()
top.connect(numpy_source, clock_recovery)
top.connect(clock_recovery, numpy_sink)
top.run()
symbol_data = numpy_sink.data
numpy.max(symbol_data)
# TODO: Adjust sampling rate
bits = []
for i in xrange(len(symbol_data)):
if symbol_data[i] >= 0:
symbol_data[i] = 1
bits.append('1')
else:
symbol_data[i] = -1
bits.append('0')
bits = ''.join(bits)
#print(bits)
self.sliced_view.data = TimeData(symbol_data, self.burst.symbol_rate)
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 setUp (self):
self.tb = gr.top_block ()
self.tp = drm.transm_params(1, 3, False, 0, False, 1, 0, 1, 1, 0, False, 24000, "station label", "text message")
vlen_msc = self.tp.msc().N_MUX() * self.tp.ofdm().M_TF()
vlen_sdc = self.tp.sdc().N()
vlen_fac = self.tp.fac().N() * self.tp.ofdm().M_TF()
self.cell_mapping = drm.cell_mapping_vcvc(self.tp, (vlen_msc, vlen_sdc, vlen_fac))
def run_test (f,Kb,bitspersymbol,K,dimensionality,tot_constellation,N0,seed):
tb = gr.top_block ()
# TX
src = gr.lfsr_32k_source_s()
src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts
s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality
enc = trellis.encoder_ss(f,0) # initial state = 0
# essentially here we implement the combination of modulation and channel as a memoryless modulation (the memory induced by the channel is hidden in the FSM)
mod = gr.chunks_to_symbols_sf(tot_constellation,dimensionality)
# CHANNEL
add = gr.add_ff()
noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed)
# RX
metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,digital.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi
va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set.
fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts
dst = gr.check_lfsr_32k_s();
tb.connect (src,src_head,s2fsmi,enc,mod)
tb.connect (mod,(add,0))
tb.connect (noise,(add,1))
tb.connect (add,metrics)
tb.connect (metrics,va,fsmi2s,dst)
tb.run()
ntotal = dst.ntotal ()
nright = dst.nright ()
runlength = dst.runlength ()
#print ntotal,nright,runlength
return (ntotal,ntotal-nright)
def xtest_fff_003(self):
random.seed(0)
for i in xrange(25):
sys.stderr.write("\n>>> Loop = %d\n" % (i,))
src_len = 4096
src_data = make_random_float_tuple(src_len)
ntaps = int(random.uniform(2, 1000))
taps = make_random_float_tuple(ntaps)
expected_result = reference_filter_fff(1, taps, src_data)
src = gr.vector_source_f(src_data)
op = gr.fft_filter_fff(1, taps)
dst = gr.vector_sink_f()
tb = gr.top_block()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
#print "src_len =", src_len, " ntaps =", ntaps
try:
self.assert_fft_float_ok2(expected_result, result_data, abs_eps=1.0)
except:
expected = open('expected', 'w')
for x in expected_result:
expected.write(`x` + '\n')
actual = open('actual', 'w')
for x in result_data:
actual.write(`x` + '\n')
raise
def setUp (self):
self.tb = gr.top_block ()
self.tp = drm.transm_params(1, 3, False, 0, False, 1, 0, 1, 1, 0, False, 24000, "station label", "text message")
self.src = drm.generate_sdc_b(self.tp)
self.head = blocks.head(self.tp.sdc().L(), 1)
self.snk = blocks.vector_sink_b(self.tp.sdc().L())
self.tb.connect(self.src, self.head, self.snk)
def _update_filtered(self, translated): if translated is not None and self._taps is not None: filtered = TimeData(numpy.complex64(scipy.signal.lfilter(self._taps, 1, translated.samples)), translated.sampling_rate) filtered_abs = filtered.abs data_source = filtered_abs.samples numpy_source = NumpySource(data_source) peak_detector = blocks.peak_detector_fb(1.0, 0.3, 10, 0.001) sample_and_hold = blocks.sample_and_hold_ff() multiply_const = blocks.multiply_const_vff((0.5, )) subtract = blocks.sub_ff(1) numpy_sink = NumpySink(numpy.float32) top = gr.top_block() top.connect((numpy_source, 0), (peak_detector, 0)) top.connect((numpy_source, 0), (sample_and_hold, 0)) top.connect((numpy_source, 0), (subtract, 0)) top.connect((peak_detector, 0), (sample_and_hold, 1)) top.connect((sample_and_hold, 0), (multiply_const, 0)) top.connect((multiply_const, 0), (subtract, 1)) top.connect((subtract, 0), (numpy_sink, 0)) top.run() filtered = TimeData(numpy_sink.data, translated.sampling_rate) self.filtered_view.data = filtered # abs_min = filtered.abs.min # abs_max = filtered.abs.max # abs_mid = (abs_min + abs_max) / 2.0 # self.burst.filtered = filtered.abs - abs_mid self.burst.filtered = filtered else: self.filtered_view.data = None self.burst.filtered = None
def test_disconnect(self):
msgs = ("this", "test", "should", "pass")
tb = gr.top_block()
#put the source in a hier block
hb_src = gr.hier_block2("hb src", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, 1))
src = demo_msg_src(msgs)
#put the sink in a hier block
hb_sink = gr.hier_block2("hb sink", gr.io_signature(1, 1, 1), gr.io_signature(0, 0, 0))
sink = demo_msg_sink(len(msgs))
#connect
hb_src.connect(src, hb_src)
hb_sink.connect(hb_sink, sink)
tb.connect(hb_src, hb_sink)
#disconnect
hb_src.disconnect(src, hb_src)
hb_sink.disconnect(hb_sink, sink)
tb.disconnect(hb_src, hb_sink)
#reconnect
hb_src.connect(src, hb_src)
hb_sink.connect(hb_sink, sink)
tb.connect(hb_src, hb_sink)
tb.run()
self.assertItemsEqual(sink.msgs(), msgs)
def test_003_es_sink (self):
print "test_003_es_sink"
iv = [0,1,2,3,4,5,6,7,8,9];
src = blocks.vector_source_f(iv, repeat=True);
hd = blocks.head(gr.sizeof_float, 10000);
snk = es.sink([gr.sizeof_float], 8);
t = es.trigger_sample_timer(gr.sizeof_float, 10, 5, 10, 10);
tb = gr.top_block();
pduh = es.es_make_handler_pdu(es.es_handler_print.TYPE_F32);
msgdb = blocks.message_debug()
tb.connect(src, hd, t, snk);
tb.msg_connect( t, "which_stream", snk, "schedule_event" )
tb.msg_connect( t, "sample_timer_event", pduh, "handle_event" )
tb.msg_connect( pduh, "pdus_out", msgdb, "store" )
tb.run();
# expected output of each event in the periodic sequence
sv = numpy.array( iv[5:] + iv[:5], dtype=numpy.float32 );
# verify each received message
nm = msgdb.num_messages();
print "nm = %d"%(nm);
for i in range(0, nm):
m = msgdb.get_message(i);
mp = pmt.to_python(pmt.cdr(m));
print mp;
self.assertEqual( sv.all(), mp.all() );
def setUp(self):
self.tb = gr.top_block()
self.strobe = blocks.message_strobe(pmt.PMT_NIL, 25)
self.ctr = pdu_utils.message_counter(pmt.intern("counter"))
self.tb.msg_connect((self.strobe, 'strobe'), (self.ctr, 'msg'))
def setUp(self):
self.tb = gr.top_block()
def setUp(self):
self.tb = gr.top_block()
self.dbg = blocks.message_debug()
from .. base.Param import Param as _Param
from .. gui.Param import Param as _GUIParam
import Constants
import numpy
from gnuradio import eng_notation
import re
from gnuradio import gr
_check_id_matcher = re.compile('^[a-z|A-Z]\w*$')
_show_id_matcher = re.compile('^(variable\w*|parameter|options|notebook)$')
#blacklist certain ids, its not complete, but should help
import __builtin__
ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'wxgui', 'wx', 'math', 'forms', 'firdes'] + \
filter(lambda x: not x.startswith('_'), dir(gr.top_block())) + dir(__builtin__)
#define types, native python + numpy
VECTOR_TYPES = (tuple, list, set, numpy.ndarray)
COMPLEX_TYPES = [complex, numpy.complex, numpy.complex64, numpy.complex128]
REAL_TYPES = [float, numpy.float, numpy.float32, numpy.float64]
INT_TYPES = [int, long, numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.uint64,
numpy.uint, numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64]
#cast to tuple for isinstance, concat subtypes
COMPLEX_TYPES = tuple(COMPLEX_TYPES + REAL_TYPES + INT_TYPES)
REAL_TYPES = tuple(REAL_TYPES + INT_TYPES)
INT_TYPES = tuple(INT_TYPES)
class Param(_Param, _GUIParam):
def __init__(self, **kwargs):
_Param.__init__(self, **kwargs)
def setUp(self):
self.fg = gr.top_block("test_block")
def setUp(self):
self.tb = gr.top_block()
self.tsb_key = "tsb_key"
def run(self, starttime=None, endtime=None, duration=None, period=1):
op = self.op
# window in seconds that we allow for setup time so that we don't
# issue a start command that's in the past when the flowgraph starts
SETUP_TIME = 10
# print current time and NTP status
if op.verbose and sys.platform.startswith('linux'):
try:
call(('timedatectl', 'status'))
except OSError:
# no timedatectl command, ignore
pass
# parse time arguments
st = drf.util.parse_identifier_to_time(starttime)
if st is not None:
# find next suitable start time by cycle repeat period
now = datetime.utcnow()
now = now.replace(tzinfo=pytz.utc)
soon = now + timedelta(seconds=SETUP_TIME)
diff = max(soon - st, timedelta(0)).total_seconds()
periods_until_next = (diff - 1) // period + 1
st = st + timedelta(seconds=periods_until_next * period)
if op.verbose:
ststr = st.strftime('%a %b %d %H:%M:%S %Y')
stts = (st - drf.util.epoch).total_seconds()
print('Start time: {0} ({1})'.format(ststr, stts))
et = drf.util.parse_identifier_to_time(endtime, ref_datetime=st)
if et is not None:
if op.verbose:
etstr = et.strftime('%a %b %d %H:%M:%S %Y')
etts = (et - drf.util.epoch).total_seconds()
print('End time: {0} ({1})'.format(etstr, etts))
if ((et < (pytz.utc.localize(datetime.utcnow()) +
timedelta(seconds=SETUP_TIME)))
or (st is not None and et <= st)):
raise ValueError('End time is before launch time!')
if op.realtime:
r = gr.enable_realtime_scheduling()
if op.verbose:
if r == gr.RT_OK:
print('Realtime scheduling enabled')
else:
print('Note: failed to enable realtime scheduling')
# wait for the start time if it is not past
while (st is not None) and ((st - pytz.utc.localize(datetime.utcnow()))
> timedelta(seconds=SETUP_TIME)):
ttl = int(
(st - pytz.utc.localize(datetime.utcnow())).total_seconds())
if (ttl % 10) == 0:
print('Standby {0} s remaining...'.format(ttl))
sys.stdout.flush()
time.sleep(1)
# get UHD USRP source
u = self._usrp_setup()
# set device time
tt = time.time()
if op.sync:
# wait until time 0.2 to 0.5 past full second, then latch
# we have to trust NTP to be 0.2 s accurate
while tt - math.floor(tt) < 0.2 or tt - math.floor(tt) > 0.3:
time.sleep(0.01)
tt = time.time()
if op.verbose:
print('Latching at ' + str(tt))
# waits for the next pps to happen
# (at time math.ceil(tt))
# then sets the time for the subsequent pps
# (at time math.ceil(tt) + 1.0)
u.set_time_unknown_pps(uhd.time_spec(math.ceil(tt) + 1.0))
# wait for time registers to be in known state
time.sleep(math.ceil(tt) - tt + 1.0)
else:
u.set_time_now(uhd.time_spec(tt), uhd.ALL_MBOARDS)
# wait for time registers to be in known state
time.sleep(1)
# set launch time
# (at least 1 second out so USRP start time can be set properly and
# there is time to set up flowgraph)
if st is not None:
lt = st
else:
now = pytz.utc.localize(datetime.utcnow())
# launch on integer second by default for convenience (ceil + 1)
lt = now.replace(microsecond=0) + timedelta(seconds=2)
ltts = (lt - drf.util.epoch).total_seconds()
# adjust launch time forward so it falls on an exact sample since epoch
lt_samples = np.ceil(ltts * op.samplerate)
ltts = lt_samples / op.samplerate
lt = drf.util.sample_to_datetime(lt_samples, op.samplerate)
if op.verbose:
ltstr = lt.strftime('%a %b %d %H:%M:%S.%f %Y')
print('Launch time: {0} ({1})'.format(ltstr, repr(ltts)))
# command launch time
ct_td = lt - drf.util.epoch
ct_secs = ct_td.total_seconds() // 1.0
ct_frac = ct_td.microseconds / 1000000.0
u.set_start_time(uhd.time_spec(ct_secs) + uhd.time_spec(ct_frac))
# populate flowgraph one channel at a time
fg = gr.top_block()
for k in range(op.nchs):
mult_k = op.amplitudes[k] * np.exp(1j * op.phases[k])
if op.waveform is not None:
waveform_k = mult_k * op.waveform
src_k = blocks.vector_source_c(
waveform_k.tolist(),
repeat=True,
)
else:
src_k = analog.sig_source_c(
0,
analog.GR_CONST_WAVE,
0,
0,
mult_k,
)
fg.connect(src_k, (u, k))
# start the flowgraph once we are near the launch time
# (start too soon and device buffers might not yet be flushed)
# (start too late and device might not be able to start in time)
while ((lt - pytz.utc.localize(datetime.utcnow())) >
timedelta(seconds=1.2)):
time.sleep(0.1)
fg.start()
# wait until end time or until flowgraph stops
if et is None and duration is not None:
et = lt + timedelta(seconds=duration)
try:
if et is None:
fg.wait()
else:
# sleep until end time nears
while (pytz.utc.localize(datetime.utcnow()) <
et - timedelta(seconds=2)):
time.sleep(1)
else:
# issue stream stop command at end time
ct_td = et - drf.util.epoch
ct_secs = ct_td.total_seconds() // 1.0
ct_frac = ct_td.microseconds / 1000000.0
u.set_command_time(
(uhd.time_spec(ct_secs) + uhd.time_spec(ct_frac)),
uhd.ALL_MBOARDS,
)
stop_enum = uhd.stream_cmd.STREAM_MODE_STOP_CONTINUOUS
u.issue_stream_cmd(uhd.stream_cmd(stop_enum))
u.clear_command_time(uhd.ALL_MBOARDS)
# sleep until after end time
time.sleep(2)
except KeyboardInterrupt:
# catch keyboard interrupt and simply exit
pass
fg.stop()
# need to wait for the flowgraph to clean up, otherwise it won't exit
fg.wait()
print('done')
sys.stdout.flush()
def setUp(self):
self.tb = gr.top_block()
self.src = blocks.vector_source_f([float(i) for i in xrange(10)])
self.head = blocks.head(gr.sizeof_float, int(1e6))
self.sink = debugme.buggy_cplusplus_sink()
self.tb.connect(self.src, self.head, self.sink)
#
# SPDX-License-Identifier: GPL-2.0-or-later
#
import re
import builtins
from .. import blocks
from .. import Constants
# Blacklist certain ids, its not complete, but should help
ID_BLACKLIST = ['self', 'options', 'gr', 'math', 'firdes', 'default'
] + dir(builtins)
try:
from gnuradio import gr
ID_BLACKLIST.extend(attr for attr in dir(gr.top_block())
if not attr.startswith('_'))
except (ImportError, AttributeError):
pass
validators = {}
def validates(*dtypes):
def decorator(func):
for dtype in dtypes:
assert dtype in Constants.PARAM_TYPE_NAMES
validators[dtype] = func
return func
return decorator
def processInput2tx(file_num, snr):
freq = numpy.random.permutation([0, -2.5e6, 2.5e6])
snr_new = numpy.random.permutation([snr - 5, snr + 5])
source_A = blocks.vector_source_b(
map(int, numpy.random.randint(0, 255, 1000000)), True)
source_B = blocks.vector_source_b(
map(int, numpy.random.randint(0, 255, 1000000)), True)
#source_C = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000000)), True)
#source_D = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000000)), True)
#source_E = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000000)), True)
throttle_A = blocks.throttle(gr.sizeof_char * 1, samp_rate_base, True)
throttle_B = blocks.throttle(gr.sizeof_char * 1, samp_rate_base, True)
constellation_modulator_A = digital.generic_mod(
constellation=constellation_variable,
differential=False,
samples_per_symbol=sps,
pre_diff_code=True,
excess_bw=0.35,
verbose=False,
log=False,
)
constellation_modulator_B = digital.generic_mod(
constellation=constellation_variable,
differential=False,
samples_per_symbol=sps,
pre_diff_code=True,
excess_bw=0.35,
verbose=False,
log=False,
)
sig_source_A = analog.sig_source_c(
upsamp_rate, analog.GR_COS_WAVE, freq[1],
(10**(float(snr_new[0]) / 20)) * noise_amplitude, 0)
sig_source_B = analog.sig_source_c(
upsamp_rate, analog.GR_COS_WAVE, freq[2],
(10**(float(snr_new[1]) / 20)) * noise_amplitude, 0)
const_A = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, 0)
resampler_A = filter.rational_resampler_ccc(10,
2,
taps=None,
fractional_bw=None)
resampler_B = filter.rational_resampler_ccc(10,
2,
taps=None,
fractional_bw=None)
multiply_A = blocks.multiply_vcc(1)
multiply_A1 = blocks.multiply_vcc(1)
multiply_B = blocks.multiply_vcc(1)
float_to_complex_A = blocks.float_to_complex(1)
delay_B = blocks.delay(gr.sizeof_gr_complex * 1, 500000)
sqr_source_A = analog.sig_source_f(samp_rate_base, analog.GR_SQR_WAVE, -1,
signal_amp, 0)
channel_A = channels.fading_model(12, 0, False, 4.0, 0)
channel_B = channels.fading_model(12, 0, False, 4.0, 0)
add_block = blocks.add_vcc(1)
channel = channels.channel_model(noise_voltage=noise_amplitude,
frequency_offset=0.0,
epsilon=1.0,
taps=(1 + 1j, ),
noise_seed=0,
block_tags=False)
skip_head = blocks.skiphead(gr.sizeof_gr_complex * 1, 1024)
head_block = blocks.head(gr.sizeof_gr_complex * 1, 1000000)
file_sink = blocks.file_sink(
gr.sizeof_gr_complex * 1,
'data_2tx_' + str(snr) + 'dB_' + str(file_num) + '.dat', False)
tb = gr.top_block()
tb.connect(source_A, throttle_A, constellation_modulator_A, resampler_A,
(multiply_A, 0))
tb.connect(sig_source_A, (multiply_A, 1))
tb.connect(multiply_A, (multiply_A1, 0))
tb.connect(sqr_source_A, (float_to_complex_A, 0))
tb.connect(const_A, (float_to_complex_A, 1))
tb.connect(float_to_complex_A, (multiply_A1, 1))
tb.connect(multiply_A1, channel_A, (add_block, 0))
tb.connect(source_B, throttle_B, constellation_modulator_B, resampler_B,
(multiply_B, 0))
tb.connect(sig_source_B, (multiply_B, 1))
tb.connect(multiply_B, channel_B, delay_B, (add_block, 1))
tb.connect(add_block, channel, skip_head)
tb.connect(skip_head, head_block)
tb.connect(head_block, file_sink)
tb.run()
def setUp (self):
os.environ['GR_CONF_CONTROLPORT_ON'] = 'False'
self.tb = gr.top_block ()
def setUp(self):
self.tb = gr.top_block()
self.src_data = [int(x) for x in range(65536)]
def main():
N = 10000
fs = 2000.0
Ts = 1.0 / fs
t = numpy.arange(0, N*Ts, Ts)
# When playing with the number of channels, be careful about the filter
# specs and the channel map of the synthesizer set below.
nchans = 10
# Build the filter(s)
bw = 1000
tb = 400
proto_taps = filter.firdes.low_pass_2(1, nchans*fs,
bw, tb, 80,
filter.firdes.WIN_BLACKMAN_hARRIS)
print("Filter length: ", len(proto_taps))
# Create a modulated signal
npwr = 0.01
data = numpy.random.randint(0, 256, N)
rrc_taps = filter.firdes.root_raised_cosine(1, 2, 1, 0.35, 41)
src = blocks.vector_source_b(data.astype(numpy.uint8).tolist(), False)
mod = digital.bpsk_mod(samples_per_symbol=2)
chan = channels.channel_model(npwr)
rrc = filter.fft_filter_ccc(1, rrc_taps)
# Split it up into pieces
channelizer = filter.pfb.channelizer_ccf(nchans, proto_taps, 2)
# Put the pieces back together again
syn_taps = [nchans*t for t in proto_taps]
synthesizer = filter.pfb_synthesizer_ccf(nchans, syn_taps, True)
src_snk = blocks.vector_sink_c()
snk = blocks.vector_sink_c()
# Remap the location of the channels
# Can be done in synth or channelizer (watch out for rotattions in
# the channelizer)
synthesizer.set_channel_map([ 0, 1, 2, 3, 4,
15, 16, 17, 18, 19])
tb = gr.top_block()
tb.connect(src, mod, chan, rrc, channelizer)
tb.connect(rrc, src_snk)
vsnk = []
for i in range(nchans):
tb.connect((channelizer,i), (synthesizer, i))
vsnk.append(blocks.vector_sink_c())
tb.connect((channelizer,i), vsnk[i])
tb.connect(synthesizer, snk)
tb.run()
sin = numpy.array(src_snk.data()[1000:])
sout = numpy.array(snk.data()[1000:])
# Plot original signal
fs_in = nchans*fs
f1 = pyplot.figure(1, figsize=(16,12), facecolor='w')
s11 = f1.add_subplot(2,2,1)
s11.psd(sin, NFFT=fftlen, Fs=fs_in)
s11.set_title("PSD of Original Signal")
s11.set_ylim([-200, -20])
s12 = f1.add_subplot(2,2,2)
s12.plot(sin.real[1000:1500], "o-b")
s12.plot(sin.imag[1000:1500], "o-r")
s12.set_title("Original Signal in Time")
start = 1
skip = 2
s13 = f1.add_subplot(2,2,3)
s13.plot(sin.real[start::skip], sin.imag[start::skip], "o")
s13.set_title("Constellation")
s13.set_xlim([-2, 2])
s13.set_ylim([-2, 2])
# Plot channels
nrows = int(numpy.sqrt(nchans))
ncols = int(numpy.ceil(float(nchans) / float(nrows)))
f2 = pyplot.figure(2, figsize=(16,12), facecolor='w')
for n in range(nchans):
s = f2.add_subplot(nrows, ncols, n+1)
s.psd(vsnk[n].data(), NFFT=fftlen, Fs=fs_in)
s.set_title("Channel {0}".format(n))
s.set_ylim([-200, -20])
# Plot reconstructed signal
fs_out = 2*nchans*fs
f3 = pyplot.figure(3, figsize=(16,12), facecolor='w')
s31 = f3.add_subplot(2,2,1)
s31.psd(sout, NFFT=fftlen, Fs=fs_out)
s31.set_title("PSD of Reconstructed Signal")
s31.set_ylim([-200, -20])
s32 = f3.add_subplot(2,2,2)
s32.plot(sout.real[1000:1500], "o-b")
s32.plot(sout.imag[1000:1500], "o-r")
s32.set_title("Reconstructed Signal in Time")
start = 0
skip = 4
s33 = f3.add_subplot(2,2,3)
s33.plot(sout.real[start::skip], sout.imag[start::skip], "o")
s33.set_title("Constellation")
s33.set_xlim([-2, 2])
s33.set_ylim([-2, 2])
pyplot.show()
def __init__(self, spreadingFactor = 7, codingRate = "4/5", gains = [10, 20, 20]):
##################################################
# Variables #
##################################################
self.target_freq = 868.1e6
self.sf = spreadingFactor # 7 8 9 10 11 12
self.samp_rate = 1e6
self.capture_freq = 868.0e6
self.bw = 125e3
#self.symbols_per_sec = self.bw / (2**self.sf)
self.offset = -(self.capture_freq - self.target_freq)
#self.bitrate = self.sf * (1 / (2**self.sf / self.bw ))
self.crc = True
self.pwr = 1
self.codingRate = codingRate # 4/5 4/6 4/7 4/8
self.pre_delay = 0.150
self.post_delay = 0.350
self.trans_delay = 0.250
self.testResults = None
# Socket connection for sink
self.host = "127.0.0.1"
self.port = 40868
self.server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server.bind((self.host, self.port))
self.server.setblocking(0)
##################################################
# LoRa transmitter #
##################################################
try:
self.lc = RN2483Controller("/dev/lora")
self.lc.set_cr ( self.codingRate)
self.lc.set_bw ( self.bw / 1e3)
self.lc.set_sf ( self.sf )
self.lc.set_crc( "on" if self.crc else "off")
self.lc.set_pwr( self.pwr )
except:
raise Exception("Error initialising LoRa transmitter: RN2483Controller")
##################################################
# Blocks #
##################################################
self.tb = gr.top_block ()
self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
self.osmosdr_source_0.set_sample_rate(self.samp_rate)
self.osmosdr_source_0.set_center_freq(self.capture_freq, 0)
self.osmosdr_source_0.set_freq_corr(0, 0)
self.osmosdr_source_0.set_dc_offset_mode(0, 0)
self.osmosdr_source_0.set_iq_balance_mode(0, 0)
self.osmosdr_source_0.set_gain_mode(False, 0)
self.osmosdr_source_0.set_gain(gains[0], 0)
self.osmosdr_source_0.set_if_gain(gains[1], 0)
self.osmosdr_source_0.set_bb_gain(gains[2], 0)
self.osmosdr_source_0.set_antenna('', 0)
self.osmosdr_source_0.set_bandwidth(0, 0)
self.lora_lora_receiver_0 = lora.lora_receiver(self.samp_rate, self.capture_freq, self.offset, self.sf, self.samp_rate, 0.01)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, self.samp_rate, True)
self.blocks_message_socket_sink_0 = lora.message_socket_sink()
self.tb.connect( (self.osmosdr_source_0, 0), (self.blocks_throttle_0, 0))
self.tb.connect( (self.blocks_throttle_0, 0), (self.lora_lora_receiver_0, 0))
self.tb.msg_connect( (self.lora_lora_receiver_0, 'frames'), (self.blocks_message_socket_sink_0, 'in'))
def run(self):
op = self.op
# window in seconds that we allow for setup time so that we don't
# issue a start command that's in the past when the flowgraph starts
SETUP_TIME = 10
# print current time and NTP status
if op.verbose and sys.platform.startswith('linux'):
try:
call(('timedatectl', 'status'))
except OSError:
# no timedatectl command, ignore
pass
# get UHD USRP source
usrp = self._usrp_setup()
# set launch time
# (at least 1 second out so USRP start time can be set properly and
# there is time to set up flowgraph)
ltts = usrp.get_time_last_pps().get_real_secs() + 2
usrp.set_start_time(uhd.time_spec(ltts))
# populate flowgraph one channel at a time
fg = gr.top_block()
for k in range(op.nchs):
mult_k = op.amplitudes[k] * np.exp(1j * op.phases[k])
if op.waveform is not None:
waveform_k = mult_k * op.waveform
src_k = blocks.vector_source_c(
waveform_k.tolist(),
repeat=True,
)
else:
src_k = analog.sig_source_c(
0,
analog.GR_CONST_WAVE,
0,
0,
mult_k,
)
fg.connect(src_k, (usrp, k))
# start the flowgraph once we are near the launch time
# (start too soon and device buffers might not yet be flushed)
# (start too late and device might not be able to start in time)
while (ltts - usrp.get_mboard_sensor("gps_time").to_int()) > 1.2:
time.sleep(0.1)
fg.start()
# Step the USRP through a list of frequencies
basedir = '/'.join(op.freq_list_fname.split('/')[:-2])
flog_fname = os.path.join(basedir, 'logs/freqstep.log')
lock_fname = os.path.join(basedir, 'logs/gps_lock.log')
freq_stepper.step(
usrp,
op,
freq_list_fname=op.freq_list_fname,
flog_fname=flog_fname,
lock_fname=lock_fname,
)
# wait until flowgraph stops
try:
fg.wait()
except KeyboardInterrupt:
# catch keyboard interrupt and simply exit
pass
fg.stop()
# need to wait for the flowgraph to clean up, otherwise it won't exit
fg.wait()
print('done')
sys.stdout.flush()
def setUp(self):
np.set_printoptions(2, linewidth=150)
self.tb = gr.top_block()
def test_robustness_AWGN():
N = 10000#9000
zc_len = [29,201]
n_repeats = [20,1]
samples_per_frame = 2000
samples_of_awgn = 50
preamble_amp = np.random.uniform(0.5,100)
SNRdBrange = range(-10,10)
toffset = 200
Nruns = 100
sum_ratios = np.zeros(len(SNRdBrange))
sum_falarm = np.zeros(len(SNRdBrange))
cfo = 0#0.01
for ii, s in enumerate(SNRdBrange):
for rr in range(Nruns):
awgn_pwr = preamble_amp**2/(10**(s/10.0))
tb = gr.top_block()
# derived
preamble, pseq_list, pseq_norm_list = generate_preamble(zc_len,n_repeats)
x = np.random.normal(0, np.sqrt(awgn_pwr)/np.sqrt(2), N)+np.random.normal(0, np.sqrt(awgn_pwr)/np.sqrt(2), N)*1j
x = add_preambles(x,toffset,apply_cfo(preamble*preamble_amp, cfo),samples_per_frame)
hist_len = 2*preamble.size + samples_of_awgn
x_with_history = np.append(np.zeros(hist_len,dtype=np.complex128),x)
toffset_with_hist = toffset+hist_len
N_frames_tot = int(np.floor((N-toffset-preamble.size)/float(samples_per_frame))+1)
vector_source = blocks.vector_source_c(x, True)
head = blocks.head(gr.sizeof_gr_complex, len(x_with_history))
frame_sync = specmonitor.frame_sync_cc(pseq_list,n_repeats,0.15,samples_per_frame, samples_of_awgn, awgn_pwr)
dst = blocks.vector_sink_c()
tb.connect(vector_source,head)
tb.connect(head,frame_sync)
tb.connect(frame_sync,dst)
print '\nTest: '
print '- toffset: ', toffset
print '- preamble start:', toffset+hist_len
print '- crosscorr peak0: ', toffset+hist_len+(n_repeats[0]-1)*zc_len[0]
print '- preamble end: ', toffset+hist_len+n_repeats[0]*zc_len[0]+n_repeats[1]*zc_len[1]
print '- number of preambles: ', N_frames_tot
print ''
tb.run ()
in_data = dst.data()
h = frame_sync.history()-1
assert h == hist_len
# raw_input ('Press Enter to continue: ')
js_dict = json.loads(frame_sync.get_peaks_json())
print js_dict
if len(js_dict)>=1:
n_frames_detected = js_dict[0]['n_frames_detected']
print 'got:', js_dict[0]['peak_idx'], ', expected ', toffset+samples_per_frame*(N_frames_tot+1)
if js_dict[0]['peak_idx']==(toffset+samples_per_frame*(N_frames_tot+1)):
r = n_frames_detected / float(N_frames_tot+1)
print 'r:', r
sum_ratios[ii] = sum_ratios[ii] + r
sum_falarm[ii] += len(js_dict)-1
rate_detection = sum_ratios / Nruns
rate_falarm = sum_falarm / Nruns
fig, (ax0, ax1) = plt.subplots(nrows=2)
ax0.plot(SNRdBrange, rate_detection)
ax1.plot(SNRdBrange, rate_falarm, ':')
plt.show()
def main(args):
nargs = len(args)
if nargs == 1:
infile = args[0]
outfile = None
elif nargs == 2:
infile = args[0]
outfile = args[1]
else:
sys.stderr.write("Usage: dvbt2-blade.py input_file [output_file]\n");
sys.exit(1)
version = dvbt2.VERSION_111
fft_size = dvbt2.FFTSIZE_32K
input_mode = dvbt2.INPUTMODE_NORMAL
frame_size = dvbt2.FECFRAME_NORMAL
code_rate = dvbt2.C3_4
data_symbols = 100
fec_blocks = 31
ti_blocks = 3
constellation = dvbt2.MOD_256QAM
rotation = dvbt2.ROTATION_ON
guard_interval = dvbt2.GI_19_128
mode = dvbt2.PREAMBLE_T2_SISO
carrier_mode = dvbt2.CARRIERS_NORMAL
pilot_pattern = dvbt2.PILOT_PP2
l1_constellation = dvbt2.L1_MOD_16QAM
papr_mode = dvbt2.PAPR_OFF
papr_vclip = 3.3
papr_iterations = 3
channel_mhz = 8
samp_rate = channel_mhz * 8000000.0 / 7
# center_freq = 429000000
center_freq = 666000000
# center_freq = 441000000
# txvga1_gain = -8
txvga1_gain = -8
txvga2_gain = 14
if channel_mhz == 10:
bandwidth = 10000000
equalization_bandwidth = dvbt2.BANDWIDTH_10_0_MHZ
elif channel_mhz == 8:
bandwidth = 8750000
equalization_bandwidth = dvbt2.BANDWIDTH_8_0_MHZ
elif channel_mhz == 7:
bandwidth = 7000000
equalization_bandwidth = dvbt2.BANDWIDTH_7_0_MHZ
elif channel_mhz == 6:
bandwidth = 5500000
equalization_bandwidth = dvbt2.BANDWIDTH_6_0_MHZ
elif channel_mhz == 5:
bandwidth = 5000000
equalization_bandwidth = dvbt2.BANDWIDTH_5_0_MHZ
else:
bandwidth = 1750000
equalization_bandwidth = dvbt2.BANDWIDTH_1_7_MHZ
if fft_size == dvbt2.FFTSIZE_1K:
fftsize = 1024
elif fft_size == dvbt2.FFTSIZE_2K:
fftsize = 2048
elif fft_size == dvbt2.FFTSIZE_4K:
fftsize = 4096
elif fft_size == dvbt2.FFTSIZE_8K:
fftsize = 8192
elif fft_size == dvbt2.FFTSIZE_8K_T2GI:
fftsize = 8192
elif fft_size == dvbt2.FFTSIZE_16K:
fftsize = 16384
elif fft_size == dvbt2.FFTSIZE_16K_T2GI:
fftsize = 16384
elif fft_size == dvbt2.FFTSIZE_32K:
fftsize = 32768
elif fft_size == dvbt2.FFTSIZE_32K_T2GI:
fftsize = 32768
if guard_interval == dvbt2.GI_1_32:
gi = fftsize / 32
elif guard_interval == dvbt2.GI_1_16:
gi = fftsize / 16
elif guard_interval == dvbt2.GI_1_8:
gi = fftsize / 8
elif guard_interval == dvbt2.GI_1_4:
gi = fftsize / 4
elif guard_interval == dvbt2.GI_1_128:
gi = fftsize / 128
elif guard_interval == dvbt2.GI_19_128:
gi = (fftsize * 19) / 128
elif guard_interval == dvbt2.GI_19_256:
gi = (fftsize * 19) / 256
tb = gr.top_block()
src = blocks.file_source(gr.sizeof_char, infile, True)
dvbt2_bbheader = dvbt2.bbheader_bb(frame_size, code_rate, input_mode, dvbt2.INBAND_OFF, fec_blocks, 4000000)
dvbt2_bbscrambler = dvbt2.bbscrambler_bb(frame_size, code_rate)
dvbt2_bch = dvbt2.bch_bb(frame_size, code_rate)
dvbt2_ldpc = dvbt2.ldpc_bb(frame_size, code_rate)
dvbt2_interleaver = dvbt2.interleaver_bb(frame_size, code_rate, constellation)
dvbt2_modulator = dvbt2.modulator_bc(frame_size, constellation, rotation)
dvbt2_cellinterleaver = dvbt2.cellinterleaver_cc(frame_size, constellation, fec_blocks, ti_blocks)
dvbt2_framemapper = dvbt2.framemapper_cc(frame_size, code_rate, constellation, rotation, fec_blocks, ti_blocks, carrier_mode, fft_size, guard_interval, l1_constellation, pilot_pattern, 2, data_symbols, papr_mode, version, mode, input_mode, dvbt2.RESERVED_OFF, dvbt2.L1_SCRAMBLED_OFF, dvbt2.INBAND_OFF)
dvbt2_freqinterleaver = dvbt2.freqinterleaver_cc(carrier_mode, fft_size, pilot_pattern, guard_interval, data_symbols, papr_mode, version, mode)
dvbt2_pilotgenerator = dvbt2.pilotgenerator_cc(carrier_mode, fft_size, pilot_pattern, guard_interval, data_symbols, papr_mode, version, mode, dvbt2.MISO_TX1, dvbt2.EQUALIZATION_ON, equalization_bandwidth, fftsize)
dvbt2_paprtr = dvbt2.paprtr_cc(carrier_mode, fft_size, pilot_pattern, guard_interval, data_symbols, papr_mode, version, papr_vclip, papr_iterations, fftsize)
digital_ofdm_cyclic_prefixer = digital.ofdm_cyclic_prefixer(fftsize, fftsize+(gi), 0, "")
dvbt2_p1insertion = dvbt2.p1insertion_cc(carrier_mode, fft_size, guard_interval, data_symbols, mode, dvbt2.SHOWLEVELS_OFF, 3.31)
blocks_multiply_const = blocks.multiply_const_vcc((0.2, ))
out = osmosdr.sink(args="bladerf=0,buffers=128,buflen=32768")
out.set_sample_rate(samp_rate)
out.set_center_freq(center_freq, 0)
out.set_freq_corr(0, 0)
out.set_gain(txvga2_gain, 0)
out.set_bb_gain(txvga1_gain, 0)
out.set_bandwidth(bandwidth, 0)
tb.connect(src, dvbt2_bbheader)
tb.connect(dvbt2_bbheader, dvbt2_bbscrambler)
tb.connect(dvbt2_bbscrambler, dvbt2_bch)
tb.connect(dvbt2_bch, dvbt2_ldpc)
tb.connect(dvbt2_ldpc, dvbt2_interleaver)
tb.connect(dvbt2_interleaver, dvbt2_modulator)
tb.connect(dvbt2_modulator, dvbt2_cellinterleaver)
tb.connect(dvbt2_cellinterleaver, dvbt2_framemapper)
tb.connect(dvbt2_framemapper, dvbt2_freqinterleaver)
tb.connect(dvbt2_freqinterleaver, dvbt2_pilotgenerator)
tb.connect(dvbt2_pilotgenerator, dvbt2_paprtr)
tb.connect(dvbt2_paprtr, digital_ofdm_cyclic_prefixer)
tb.connect(digital_ofdm_cyclic_prefixer, dvbt2_p1insertion)
tb.connect(dvbt2_p1insertion, blocks_multiply_const)
tb.connect(blocks_multiply_const, out)
if outfile:
dst = blocks.file_sink(gr.sizeof_gr_complex, outfile)
tb.connect(blocks_multiply_const, dst)
tb.run()
def setUp(self):
random.seed(0)
self.tb = gr.top_block()
def test():
N = 9000#9000
zc_len = [5,13]
toffset = 3500#8070
n_repeats = [40,1]
samples_per_frame = 9000
samples_of_awgn = 50
preamble_amp = np.random.uniform(0.5,100)
awgn_floor = 1e-3
for r in range(N-np.sum([n_repeats[i]*zc_len[i] for i in range(2)])):
cfo = np.random.uniform(0,0.45)/zc_len[0]
tb = gr.top_block()
toffset = r
# derived
preamble, pseq_list, pseq_norm_list = generate_preamble(zc_len,n_repeats)
x = np.ones(N,dtype=np.complex128)*awgn_floor
x = add_preambles(x,toffset,apply_cfo(preamble*preamble_amp, cfo),samples_per_frame)
hist_len = 2*preamble.size + samples_of_awgn
x_with_history = np.append(np.zeros(hist_len,dtype=np.complex128),x)
toffset_with_hist = toffset+hist_len
N_frames_tot = int(np.ceil((N-toffset-preamble.size)/float(samples_per_frame)))
vector_source = blocks.vector_source_c(x, True)
head = blocks.head(gr.sizeof_gr_complex, len(x_with_history))
frame_sync = specmonitor.frame_sync_cc(pseq_list,n_repeats,0.5,samples_per_frame, samples_of_awgn, awgn_floor**2)
dst = blocks.vector_sink_c()
tb.connect(vector_source,head)
tb.connect(head,frame_sync)
tb.connect(frame_sync,dst)
print '\nTest: '
print '- toffset: ', toffset
print '- preamble start:', toffset+hist_len
print '- crosscorr peak0: ', toffset+hist_len+(n_repeats[0]-1)*zc_len[0]
print '- preamble end: ', toffset+hist_len+n_repeats[0]*zc_len[0]+n_repeats[1]*zc_len[1]
print '- number of preambles: ', N_frames_tot
print ''
tb.run ()
in_data = dst.data()
h = frame_sync.history()-1
if(h != hist_len):
print 'The history length is not consistent. ', h, '!=', hist_len
return
error_num = [False]*6
js_dict0 = json.loads(frame_sync.get_crosscorr0_peaks())
js_dict = json.loads(frame_sync.get_peaks_json())
error_num[0] = False if len(js_dict0) == 1 else True
error_num[1] = False if len(js_dict) == 1 else True
if error_num[1] == False:
error_num[2] = False if js_dict[0]['peak_idx']==(toffset+samples_per_frame*N_frames_tot) else True
error_num[3] = False if js_dict[0]['n_frames_elapsed']==N_frames_tot else True
error_num[4] = False if abs(js_dict[0]['awgn_estim']-awgn_floor**2)<0.001 else True
error_num[5] = False if abs(js_dict[0]['cfo']-cfo)<0.001 else True
if any(error_num):
print 'There were errors', error_num
xcorr = frame_sync.get_crosscorr0(1000)
plt.plot(np.abs(xcorr))
plt.show()
return
def setUp(self):
self.tb = gr.top_block()
self.emitter = pdu_utils.message_emitter()
self.debug = blocks.message_debug()
def run(self, suites_to_run, pause=False, write_output=True):
for test_suite in self.test_suites:
# Skip test suites that we don't want to run
if suites_to_run != [] and (not test_suite in suites_to_run):
continue
print("[+] Testing suite: '%s'" % test_suite)
summary = TestSummary(suite=test_suite, pause=pause)
# Get all metadata files associated with the suite
get_mtime = lambda f: os.stat(
os.path.join(self.test_suites_directory, test_suite, f)
).st_mtime
metadata_files = [
os.path.join(self.test_suites_directory, test_suite, x)
for x in sorted(os.listdir(
os.path.join(self.test_suites_directory, test_suite)),
key=get_mtime) if x.endswith('.sigmf-meta')
]
# Parse metadata files
for metadata_file in metadata_files:
print("[+] %s" % metadata_file)
data_file = os.path.splitext(metadata_file)[0] + '.sigmf-data'
# Load sigmf data TODO abstract
f = open(metadata_file, 'r')
sigmf = SigMFFile(metadata=f.read())
if not sigmf.validate():
raise Exception("Invalid SigMF format")
global_meta = sigmf.get_global_info()
capture_meta = sigmf.get_capture_info(0)
f.close()
# Initialize test parameters
sample_rate = global_meta["core:sample_rate"]
# Get LoRa configuration
capture_freq = capture_meta["core:frequency"]
if "lora:frequency_offset" in capture_meta:
frequency_offset = capture_meta["lora:frequency_offset"]
else:
frequency_offset = 0
transmit_freq = capture_meta["lora:frequency"]
sf = capture_meta["lora:sf"]
cr = capture_meta["lora:cr"]
bw = int(capture_meta["lora:bw"])
prlen = capture_meta["lora:prlen"]
crc = capture_meta["lora:crc"]
implicit = capture_meta["lora:implicit"]
lora_config = LoRaConfig(transmit_freq, sf, cr, bw, prlen, crc,
implicit)
# Get test case configuration
payload = capture_meta["test:expected"]
times = capture_meta["test:times"]
test = Test(payload, times)
# Build flowgraph
tb = gr.top_block()
file_source = blocks.file_source(gr.sizeof_gr_complex,
data_file, False)
lora_receiver = lora.lora_receiver(sample_rate,
capture_freq, [868100000],
bw,
sf,
False,
4,
True,
reduced_rate=False,
decimation=1)
throttle = blocks.throttle(gr.sizeof_gr_complex, sample_rate,
True)
message_socket_sink = lora.message_socket_sink(
"127.0.0.1", 40868, 2)
freq_xlating_fir_filter = filter.freq_xlating_fir_filter_ccc(
1, (firdes.low_pass(1, sample_rate, 200000, 100000,
firdes.WIN_HAMMING, 6.67)),
frequency_offset, sample_rate)
# Make connections
tb.connect((file_source, 0), (throttle, 0))
tb.connect((throttle, 0), (freq_xlating_fir_filter, 0))
tb.connect((freq_xlating_fir_filter, 0), (lora_receiver, 0))
tb.msg_connect((lora_receiver, 'frames'),
(message_socket_sink, 'in'))
tb.start()
tb.wait()
decoded_data = self.server.get_payloads(
times) # Output from the flowgraph
summary.add(TestResult(decoded_data=decoded_data,
lora_config=lora_config,
test=test),
print_intermediate=True)
# Finally, export the result for the suite
summary.export_summary(path=self.reports_directory,
write_output=write_output)
def setUp(self):
self.send_tb = gr.top_block()
self.recv_tb = gr.top_block()
def main(args):
nargs = len(args)
if nargs == 1:
infile = args[0]
outfile = None
elif nargs == 2:
port = int(args[0])
outfile = args[1]
else:
sys.stderr.write("Usage: dvbt-hackrf.py port [output_file]\n");
sys.exit(1)
channel_mhz = 6
mode = dtv.T2k
code_rate = dtv.C1_2
constellation = dtv.MOD_QPSK
guard_interval = dtv.GI_1_32
symbol_rate = channel_mhz * 8000000.0 / 7
center_freq = 441000000
rf_gain = 14
if_gain = 40
if mode == dtv.T2k:
factor = 1
carriers = 2048
elif mode == dtv.T8k:
factor = 4
carriers = 8192
if guard_interval == dtv.GI_1_32:
gi = carriers / 32
elif guard_interval == dtv.GI_1_16:
gi = carriers / 16
elif guard_interval == dtv.GI_1_8:
gi = carriers / 8
elif guard_interval == dtv.GI_1_4:
gi = carriers / 4
if channel_mhz == 8:
bandwidth = 8750000
elif channel_mhz == 7:
bandwidth = 7000000
elif channel_mhz == 6:
bandwidth = 6000000
elif channel_mhz == 5:
bandwidth = 5000000
else:
bandwidth = 8750000
tb = gr.top_block()
src = blocks.file_source(gr.sizeof_char, infile, True)
dvbt_energy_dispersal = dtv.dvbt_energy_dispersal(1 * factor)
dvbt_reed_solomon_enc = dtv.dvbt_reed_solomon_enc(2, 8, 0x11d, 255, 239, 8, 51, (8 * factor))
dvbt_convolutional_interleaver = dtv.dvbt_convolutional_interleaver((136 * factor), 12, 17)
dvbt_inner_coder = dtv.dvbt_inner_coder(1, (1512 * factor), constellation, dtv.NH, code_rate)
dvbt_bit_inner_interleaver = dtv.dvbt_bit_inner_interleaver((1512 * factor), constellation, dtv.NH, mode)
dvbt_symbol_inner_interleaver = dtv.dvbt_symbol_inner_interleaver((1512 * factor), mode, 1)
dvbt_map = dtv.dvbt_map((1512 * factor), constellation, dtv.NH, mode, 1)
dvbt_reference_signals = dtv.dvbt_reference_signals(gr.sizeof_gr_complex, (1512 * factor), carriers, constellation, dtv.NH, code_rate, code_rate, dtv.GI_1_32, mode, 0, 0)
fft_vxx = fft.fft_vcc(carriers, False, (window.rectangular(carriers)), True, 10)
digital_ofdm_cyclic_prefixer = digital.ofdm_cyclic_prefixer(carriers, carriers+(gi), 0, "")
blocks_multiply_const_vxx = blocks.multiply_const_vcc((0.0022097087 * 2.5, ))
out = osmosdr.sink()
out.set_sample_rate(symbol_rate)
out.set_center_freq(center_freq, 0)
out.set_freq_corr(0, 0)
out.set_gain(rf_gain, 0)
out.set_if_gain(if_gain, 0)
out.set_bandwidth(bandwidth, 0)
tb.connect(src, dvbt_energy_dispersal)
tb.connect(dvbt_energy_dispersal, dvbt_reed_solomon_enc)
tb.connect(dvbt_reed_solomon_enc, dvbt_convolutional_interleaver)
tb.connect(dvbt_convolutional_interleaver, dvbt_inner_coder)
tb.connect(dvbt_inner_coder, dvbt_bit_inner_interleaver)
tb.connect(dvbt_bit_inner_interleaver, dvbt_symbol_inner_interleaver)
tb.connect(dvbt_symbol_inner_interleaver, dvbt_map)
tb.connect(dvbt_map, dvbt_reference_signals)
tb.connect(dvbt_reference_signals, fft_vxx)
tb.connect(fft_vxx, digital_ofdm_cyclic_prefixer)
tb.connect(digital_ofdm_cyclic_prefixer, blocks_multiply_const_vxx)
tb.connect(blocks_multiply_const_vxx, out)
if outfile:
dst = blocks.file_sink(gr.sizeof_gr_complex, outfile)
tb.connect(blocks_multiply_const_vxx, dst)
tb.run()
def setUp(self):
self.tb = gr.top_block()
tp = drm.transm_params(1, 3, False, 0, False, 1, 0, 1, 1, 0, False,
24000, "station label", "text message")
self.tables = tp.cfg().ptables()
def main(args):
nargs = len(args)
if nargs == 1:
infile = args[0]
outfile = None
elif nargs == 2:
infile = args[0]
outfile = args[1]
else:
sys.stderr.write("Usage: atsc-blade.py input_file [output_file]\n")
sys.exit(1)
symbol_rate = 4500000.0 / 286 * 684
pilot_freq = 309441
center_freq = 441000000
txvga1_gain = -4
txvga2_gain = 25
tb = gr.top_block()
src = blocks.file_source(gr.sizeof_char, infile, True)
pad = atsc.pad()
rand = atsc.randomizer()
rs_enc = atsc.rs_encoder()
inter = atsc.interleaver()
trell = atsc.trellis_encoder()
fsm = atsc.field_sync_mux()
v2s = blocks.vector_to_stream(gr.sizeof_char, 1024)
minn = blocks.keep_m_in_n(gr.sizeof_char, 832, 1024, 4)
c2sym = digital.chunks_to_symbols_bc(
([symbol + 1.25 for symbol in [-7, -5, -3, -1, 1, 3, 5, 7]]), 1)
offset = analog.sig_source_c(symbol_rate, analog.GR_COS_WAVE,
-3000000 + pilot_freq, 0.9, 0)
mix = blocks.multiply_vcc(1)
rrc_taps = firdes.root_raised_cosine(0.1, symbol_rate * 2, symbol_rate / 2,
0.1152, 200)
rrc = filter.rational_resampler_ccc(
interpolation=2,
decimation=3,
taps=rrc_taps,
fractional_bw=None,
)
out = osmosdr.sink(args="bladerf=0,buffers=128,buflen=32768")
out.set_sample_rate(symbol_rate * 2 / 3)
out.set_center_freq(center_freq, 0)
out.set_freq_corr(0, 0)
out.set_gain(txvga2_gain, 0)
out.set_bb_gain(txvga1_gain, 0)
out.set_bandwidth(6000000, 0)
tb.connect(src, pad, rand, rs_enc, inter, trell, fsm, v2s, minn, c2sym)
tb.connect((c2sym, 0), (mix, 0))
tb.connect((offset, 0), (mix, 1))
tb.connect(mix, rrc, out)
if outfile:
dst = blocks.file_sink(gr.sizeof_gr_complex, outfile)
tb.connect(rrc, dst)
tb.run()
def setUp (self):
self.fg = gr.top_block ()
while tt - math.floor(tt) < 0.2 or tt - math.floor(tt) > 0.3:
tt = time.time()
time.sleep(0.01)
print("Latching at " + str(tt))
if not op.nosync:
u.set_time_unknown_pps(uhd.time_spec(math.ceil(tt) + 1.0))
u.set_subdev_spec(op.subdev)
u.set_samp_rate(op.samplerate)
u.set_center_freq(op.centerfreqs[0], 0)
u.set_center_freq(op.centerfreqs[1], 1)
u.set_gain(op.gain, 0)
u.set_gain(op.gain, 1)
# create flowgraph
fg = gr.top_block()
dst_0 = None
dst_1 = None
if op.stop_on_dropped == True:
op.stop_on_dropped = 1
else:
op.stop_on_dropped = 0
if op.dec > 1:
dst_0 = drf.digital_rf(op.dir0, int(op.filesize), int(3600),
gr.sizeof_gr_complex, op.samplerate, 0,
op.stop_on_dropped)
dst_1 = drf.digital_rf(op.dir1, int(op.filesize), int(3600),
gr.sizeof_gr_complex, op.samplerate, 0,
def setUp(self):
self.tb = gr.top_block()
self.tsb_key = "packet_len"
def setUp (self):
self.tb = gr.top_block ()
self.pdf = Pdf_class(self.id().split(".")[1])
