def __init__(self): gr.top_block.__init__(self, "Antenna Sweep module") ################################################## # Variables ################################################## self.trans_width = trans_width = 500e3 self.samp_rate = samp_rate = 32e6 self.sweep_tone = sweep_tone = 0 self.step_size = step_size = samp_rate / 2 - trans_width self.input_scale = input_scale = 1e-5 self.gain_tx = gain_tx = int(10) self.gain_rx = gain_rx = int(10) self.freq = freq = 50e6 ################################################## # Blocks ################################################## self.zmq_tx_pub = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5000', 100, True, -1) self.zmq_rx_pub = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5001', 100, True, -1) self.scale_tx = blocks.multiply_vcc(1) self.lo_input = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq + sweep_tone, 1, 0) self.limesdr_tx = limesdr.sink('', 0, '', '') self.limesdr_tx.set_sample_rate(samp_rate) self.limesdr_tx.set_center_freq(freq, 0) self.limesdr_tx.set_bandwidth(step_size, 0) self.limesdr_tx.set_digital_filter(step_size, 0) self.limesdr_tx.set_gain(gain_rx, 0) self.limesdr_tx.set_antenna(255, 0) self.limesdr_tx.calibrate(step_size, 0) self.limesdr_rx = limesdr.source('', 0, '') self.limesdr_rx.set_sample_rate(samp_rate) self.limesdr_rx.set_center_freq(freq, 0) self.limesdr_rx.set_bandwidth(step_size, 0) self.limesdr_rx.set_digital_filter(step_size, 0) self.limesdr_rx.set_gain(30, 0) self.limesdr_rx.set_antenna(255, 0) self.limesdr_rx.calibrate(step_size, 0) self.input_scale_source = analog.sig_source_c(0, analog.GR_CONST_WAVE, 0, 0, input_scale) ################################################## # Connections ################################################## self.connect((self.input_scale_source, 0), (self.scale_tx, 0)) self.connect((self.limesdr_rx, 0), (self.zmq_rx_pub, 0)) self.connect((self.lo_input, 0), (self.limesdr_tx, 0)) self.connect((self.lo_input, 0), (self.scale_tx, 1)) self.connect((self.scale_tx, 0), (self.zmq_tx_pub, 0))
def __init__(self, options): gr.top_block.__init__(self) self.options = options # socket addresses rpc_adr = "tcp://*:6667" probe_adr = "tcp://*:5557" source_adr = "tcp://"+self.options.servername+":5555" # blocks #self.zmq_source = zeromq.req_source(gr.sizeof_float, 1, source_adr) #self.zmq_source = zeromq.pull_source(gr.sizeof_float, 1, source_adr) self.zmq_source = zeromq.sub_source(gr.sizeof_float, 1, source_adr) #self.zmq_probe = zeromq.push_sink(gr.sizeof_float, 1, probe_adr) self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, 1, probe_adr) # connects self.connect(self.zmq_source, self.zmq_probe) # ZeroMQ self.rpc_manager = zeromq.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr) self.rpc_manager.add_interface("start_fg",self.start_fg) self.rpc_manager.add_interface("stop_fg",self.stop_fg) self.rpc_manager.start_watcher()
def __init__(self): gr.top_block.__init__(self, "Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 48000 * 24 self.freq = freq = int(96.9e6) ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_float, 1, 'tcp://0.0.0.0:5555', 100, False, -1) self.pluto_source_0 = iio.pluto_source('local:', freq, samp_rate, 20000000, 0x8000, True, True, True, "manual", 55, '', True) self.low_pass_filter_0 = filter.fir_filter_ccf( 6, firdes.low_pass(1, samp_rate, 100000, 100000, firdes.WIN_HAMMING, 6.76)) self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float * 1) self.analog_wfm_rcv_0 = analog.wfm_rcv( quad_rate=samp_rate / 6, audio_decimation=8, ) ################################################## # Connections ################################################## self.connect((self.analog_wfm_rcv_0, 0), (self.blocks_null_sink_0, 0)) self.connect((self.analog_wfm_rcv_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.analog_wfm_rcv_0, 0)) self.connect((self.pluto_source_0, 0), (self.low_pass_filter_0, 0))
def test_002 (self): # same as test_001, but insert a tag and set key filter vlen = 10 src_data = list(range(vlen))*100 src_tags = tuple([make_tag('key', 'val', 0, 'src'), make_tag('key', 'val', 1, 'src')]) src = blocks.vector_source_f(src_data, False, vlen, tags=src_tags) zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0", 0, pass_tags=True, key="filter_key") address = zeromq_pub_sink.last_endpoint() zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, address, 0, pass_tags=True, key="filter_key") sink = blocks.vector_sink_f(vlen) self.send_tb.connect(src, zeromq_pub_sink) self.recv_tb.connect(zeromq_sub_source, sink) # start both flowgraphs self.recv_tb.start() time.sleep(0.5) self.send_tb.start() time.sleep(0.5) self.recv_tb.stop() self.send_tb.stop() self.recv_tb.wait() self.send_tb.wait() # compare data self.assertFloatTuplesAlmostEqual(sink.data(), src_data) # compare all tags rx_tags = sink.tags() self.assertEqual(len(src_tags), len(rx_tags)) for in_tag, out_tag in zip(src_tags, rx_tags): self.assertTrue(compare_tags(in_tag, out_tag))
def __init__(self, port, channel_rate, samp_rate, offset): gr.hier_block2.__init__( self, "channel", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(0, 0, 0)) # Output signature self.samp_rate = samp_rate self.channel_rate = channel_rate self.port = port self.offset = offset self.in_use = False self.source_id = None decim = int(samp_rate / (channel_rate)) / 2 taps = firdes.low_pass(1, self.samp_rate, (self.channel_rate - 2000) / 2, 4000) #print 'taps: %s' % len(taps) self.prefilter = filter.freq_xlating_fir_filter_ccc( decim, (taps), offset, samp_rate) self.sink = zeromq.pub_sink(gr.sizeof_gr_complex * 1, 1, 'tcp://0.0.0.0:%s' % port) self.connect(self, self.prefilter, self.sink) self.init_time = time.time() self.channel_close_time = 0
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 4e6 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5557', 100, False, -1) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate,True) self.blocks_add_xx_0 = blocks.add_vcc(1) self.analog_sig_source_x_1 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 5e6, 1, 0) self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 3e6, 1, 0) ################################################## # Connections ################################################## self.connect((self.analog_sig_source_x_0, 0), (self.blocks_add_xx_0, 0)) self.connect((self.analog_sig_source_x_1, 0), (self.blocks_add_xx_0, 1)) self.connect((self.blocks_add_xx_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.zeromq_pub_sink_0, 0))
def __init__(self, options): gr.top_block.__init__(self) self.options = options # socket addresses rpc_adr = "tcp://*:6667" probe_adr = "tcp://*:5557" source_adr = "tcp://" + self.options.servername + ":5555" # blocks #self.zmq_source = zeromq.req_source(gr.sizeof_float, 1, source_adr) #self.zmq_source = zeromq.pull_source(gr.sizeof_float, 1, source_adr) self.zmq_source = zeromq.sub_source(gr.sizeof_float, 1, source_adr) #self.zmq_probe = zeromq.push_sink(gr.sizeof_float,probe_adr) self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, probe_adr) # connects self.connect(self.zmq_source, self.zmq_probe) # ZeroMQ self.rpc_manager = zeromq.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr) self.rpc_manager.add_interface("start_fg", self.start_fg) self.rpc_manager.add_interface("stop_fg", self.stop_fg) self.rpc_manager.start_watcher()
def __init__(self): gr.top_block.__init__(self, "Quetzal-1 Receiver") ################################################## # Variables ################################################## self.symb_rate = symb_rate = 4800 self.samp_rate = samp_rate = 48000 self.samp_per_sym = samp_per_sym = int(samp_rate/symb_rate) self.log = log = 0 self.homedir = homedir = "" self.hhmmss = hhmmss = "" self.gain_mu = gain_mu = 0.175*3 self.filename_raw_beacon = filename_raw_beacon = "" self.filename_parsed_beacon = filename_parsed_beacon = "" self.filename_image_metadata = filename_image_metadata = "" self.filename_image = filename_image = "" self.do_once = do_once = 0 self.data_rate = data_rate = 4800 self.count = count = 0 self.center_freq = center_freq = 437.2e6 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_char, 1, 'tcp://127.0.0.1:1502', 100, False, -1) self.satellites_strip_ax25_header_0 = satellites.strip_ax25_header() self.satellites_nrzi_decode_0 = satellites.nrzi_decode() self.satellites_hdlc_deframer_0 = satellites.hdlc_deframer(check_fcs=True, max_length=10000) self.quetzal1_parse = quetzal1_parse.quetzal1_parse(filename_parsed_beacon='', filename_raw_beacon='') self.low_pass_filter_0_0 = filter.fir_filter_fff(1, firdes.low_pass( 1, 48000, 2400, 2000, firdes.WIN_HAMMING, 6.76)) self.digital_descrambler_bb_0 = digital.descrambler_bb(0x21, 0, 16) self.digital_clock_recovery_mm_xx_0_0 = digital.clock_recovery_mm_ff(10, 0.25*gain_mu*gain_mu, 0.5, gain_mu, 0.005) self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb() self.blocks_wavfile_source_0 = blocks.wavfile_source('/home/dan/Documents/repos/gr-quetzal1/recordings/example_beacon_quetzal1.wav', False) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1, samp_rate,True) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len') self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((5, )) self.blocks_add_const_vxx_0 = blocks.add_const_vff((0, )) ################################################## # Connections ################################################## self.msg_connect((self.satellites_hdlc_deframer_0, 'out'), (self.satellites_strip_ax25_header_0, 'in')) self.msg_connect((self.satellites_strip_ax25_header_0, 'out'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.satellites_strip_ax25_header_0, 'out'), (self.quetzal1_parse, 'in')) self.connect((self.blocks_add_const_vxx_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.low_pass_filter_0_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_add_const_vxx_0, 0)) self.connect((self.blocks_wavfile_source_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.digital_binary_slicer_fb_0, 0), (self.satellites_nrzi_decode_0, 0)) self.connect((self.digital_clock_recovery_mm_xx_0_0, 0), (self.digital_binary_slicer_fb_0, 0)) self.connect((self.digital_descrambler_bb_0, 0), (self.satellites_hdlc_deframer_0, 0)) self.connect((self.low_pass_filter_0_0, 0), (self.digital_clock_recovery_mm_xx_0_0, 0)) self.connect((self.satellites_nrzi_decode_0, 0), (self.digital_descrambler_bb_0, 0))
def test_001 (self): vlen = 10 self.rx_data = None src_data = range(vlen)*100 src = blocks.vector_source_f(src_data, False, vlen) zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:5555") self.tb.connect(src, zeromq_pub_sink) self.probe_manager = zeromq.probe_manager() self.probe_manager.add_socket("tcp://127.0.0.1:5555", 'float32', self.recv_data) self.tb.run() self.probe_manager.watcher() self.assertFloatTuplesAlmostEqual(self.rx_data, src_data)
def __init__(self, options): gr.top_block.__init__(self) self.options = options # socket addresses rpc_adr = "tcp://*:6666" probe_adr = "tcp://*:5556" sink_adr = "tcp://*:5555" # the strange sampling rate gives a nice movement in the plot :P self.samp_rate = samp_rate = 48200 # blocks self.gr_sig_source = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, 1000, 1, 0) self.throttle = blocks.throttle(gr.sizeof_float, samp_rate) self.mult = blocks.multiply_const_ff(1) #self.zmq_sink = zeromq.rep_sink(gr.sizeof_float, 1, sink_adr) self.zmq_sink = zeromq.pub_sink(gr.sizeof_float, 1, sink_adr) #self.zmq_sink = zeromq.push_sink(gr.sizeof_float, 1, sink_adr) #self.zmq_probe = zeromq.push_sink(gr.sizeof_float, 1, probe_adr) self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, 1, probe_adr) #self.null_sink = blocks.null_sink(gr.sizeof_float) # connects self.connect(self.gr_sig_source, self.mult, self.throttle, self.zmq_sink) self.connect(self.throttle, self.zmq_probe) # ZeroMQ self.rpc_manager = zeromq.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr) self.rpc_manager.add_interface("start_fg", self.start_fg) self.rpc_manager.add_interface("stop_fg", self.stop_fg) self.rpc_manager.add_interface("set_waveform", self.set_waveform) self.rpc_manager.add_interface("set_k", self.mult.set_k) self.rpc_manager.add_interface("get_sample_rate", self.throttle.sample_rate) self.rpc_manager.start_watcher()
def test_001(self): vlen = 10 src_data = range(vlen) * 100 src = blocks.vector_source_f(src_data, False, vlen) zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:5556", 0) zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, "tcp://127.0.0.1:5556", 0) sink = blocks.vector_sink_f(vlen) self.tb.connect(src, zeromq_pub_sink) self.tb.connect(zeromq_sub_source, sink) self.tb.start() time.sleep(0.25) self.tb.stop() self.tb.wait() self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
def __init__(self, options): gr.top_block.__init__(self) self.options = options # socket addresses rpc_adr = "tcp://*:6666" probe_adr = "tcp://*:5556" sink_adr = "tcp://*:5555" # the strange sampling rate gives a nice movement in the plot :P self.samp_rate = samp_rate = 48200 # blocks self.gr_sig_source = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE , 1000, 1, 0) self.throttle = blocks.throttle(gr.sizeof_float, samp_rate) self.mult = blocks.multiply_const_ff(1) #self.zmq_sink = zeromq.rep_sink(gr.sizeof_float, 1, sink_adr) self.zmq_sink = zeromq.pub_sink(gr.sizeof_float, 1, sink_adr) #self.zmq_sink = zeromq.push_sink(gr.sizeof_float, 1, sink_adr) #self.zmq_probe = zeromq.push_sink(gr.sizeof_float, probe_adr) self.zmq_probe = zeromq.pub_sink(gr.sizeof_float, probe_adr) #self.null_sink = blocks.null_sink(gr.sizeof_float) # connects self.connect(self.gr_sig_source, self.mult, self.throttle, self.zmq_sink) self.connect(self.throttle, self.zmq_probe) # ZeroMQ self.rpc_manager = zeromq.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr) self.rpc_manager.add_interface("start_fg",self.start_fg) self.rpc_manager.add_interface("stop_fg",self.stop_fg) self.rpc_manager.add_interface("set_waveform",self.set_waveform) self.rpc_manager.add_interface("set_k",self.mult.set_k) self.rpc_manager.add_interface("get_sample_rate",self.throttle.sample_rate) self.rpc_manager.start_watcher()
def __init__(self, zmq_address_iq_in='tcp://127.0.0.1:5052', zmq_address_iq_out='tcp://*:5051'): gr.top_block.__init__(self, "Zero Mq Split A") ################################################## # Parameters ################################################## self.zmq_address_iq_in = zmq_address_iq_in self.zmq_address_iq_out = zmq_address_iq_out ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1e6 self.offset = offset = 0 self.capture_freq = capture_freq = 868.5e6 ################################################## # Blocks ################################################## self.zeromq_sub_source_0 = zeromq.sub_source(gr.sizeof_gr_complex, 1, zmq_address_iq_in, -1, False, -1) self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, zmq_address_iq_out, -1, False, -1) self.limesdr_source_0 = limesdr.source('0009072C0287211A', 0, '') self.limesdr_source_0.set_sample_rate(samp_rate) self.limesdr_source_0.set_center_freq(capture_freq, 0) self.limesdr_source_0.set_bandwidth(5e6, 0) self.limesdr_source_0.set_gain(30, 0) self.limesdr_source_0.set_antenna(2, 0) self.limesdr_source_0.calibrate(5e6, 0) self.limesdr_sink_0 = limesdr.sink('', 0, '', '') self.limesdr_sink_0.set_sample_rate(samp_rate) self.limesdr_sink_0.set_center_freq(capture_freq, 0) self.limesdr_sink_0.set_bandwidth(5e6, 0) self.limesdr_sink_0.set_gain(50, 0) self.limesdr_sink_0.set_antenna(255, 0) self.limesdr_sink_0.calibrate(5e6, 0) ################################################## # Connections ################################################## self.connect((self.limesdr_source_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.zeromq_sub_source_0, 0), (self.limesdr_sink_0, 0))
def test_001(self): vlen = 10 self.rx_data = None src_data = list(range(vlen)) * 100 src = blocks.vector_source_f(src_data, False, vlen) zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:5555") self.tb.connect(src, zeromq_pub_sink) self.probe_manager = zeromq.probe_manager() self.probe_manager.add_socket("tcp://127.0.0.1:5555", 'float32', self.recv_data) zmq_pull_t = threading.Thread(target=self.probe_manager.watcher) zmq_pull_t.daemon = True zmq_pull_t.start() self.tb.run() zmq_pull_t.join() self.assertFloatTuplesAlmostEqual(self.rx_data, src_data)
def test_001 (self): vlen = 10 self.rx_data = None src_data = list(range(vlen))*100 src = blocks.vector_source_f(src_data, False, vlen) zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0") address = zeromq_pub_sink.last_endpoint() self.tb.connect(src, zeromq_pub_sink) self.probe_manager = zeromq.probe_manager() self.probe_manager.add_socket(address, 'float32', self.recv_data) zmq_pull_t = threading.Thread(target=self.probe_manager.watcher) zmq_pull_t.daemon = True zmq_pull_t.start() self.tb.run() zmq_pull_t.join(6.0) # Check to see if we timed out self.assertFalse(zmq_pull_t.is_alive()) self.assertFloatTuplesAlmostEqual(self.rx_data, src_data)
def test_001(self): vlen = 10 src_data = list(range(vlen)) * 100 src = blocks.vector_source_f(src_data, False, vlen) zeromq_pub_sink = zeromq.pub_sink("tcp://127.0.0.1:0", 0) address = zeromq_pub_sink.last_endpoint() zeromq_sub_source = zeromq.sub_source(address, 0) sink = blocks.vector_sink_f(vlen) self.send_tb.connect(src, zeromq_pub_sink) self.recv_tb.connect(zeromq_sub_source, sink) self.recv_tb.start() time.sleep(0.5) self.send_tb.start() time.sleep(0.5) self.recv_tb.stop() self.send_tb.stop() # self.recv_tb.wait() # self.send_tb.wait() self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
def test_001 (self): vlen = 10 src_data = list(range(vlen))*100 src = blocks.vector_source_f(src_data, False, vlen) zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0", 0) address = zeromq_pub_sink.last_endpoint() zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen, address, 0) sink = blocks.vector_sink_f(vlen) self.send_tb.connect(src, zeromq_pub_sink) self.recv_tb.connect(zeromq_sub_source, sink) self.recv_tb.start() time.sleep(0.5) self.send_tb.start() time.sleep(0.5) self.recv_tb.stop() self.send_tb.stop() self.recv_tb.wait() self.send_tb.wait() self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
def __init__(self): gr.top_block.__init__(self, "lora_sim_send") ################################################## # Variables ################################################## self.bw = bw = 250000 self.time_wait = time_wait = 200 self.threshold = threshold = 10 self.sf = sf = 7 self.samp_rate = samp_rate = bw self.pay_len = pay_len = 64 self.n_frame = n_frame = 1 self.multi_control = multi_control = True self.mult_const = mult_const = 1 self.impl_head = impl_head = True self.has_crc = has_crc = False self.frame_period = frame_period = 200 self.cr = cr = 4 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:50246', 100, False, -1) self.lora_sdr_hier_tx_1 = lora_sdr.hier_tx( pay_len, n_frame, "TrccpfQHyKfvXswsA4ySxtTiIvi10nSJCUJPYonkWqDHH005UmNfGuocPw3FHKc9", cr, sf, impl_head, has_crc, samp_rate, bw, time_wait, [8, 16], True) self.lora_sdr_hier_tx_1.set_min_output_buffer(10000000) self.blocks_throttle_0_1_0 = blocks.throttle(gr.sizeof_gr_complex * 1, samp_rate * 10, True) ################################################## # Connections ################################################## self.connect((self.blocks_throttle_0_1_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.lora_sdr_hier_tx_1, 0), (self.blocks_throttle_0_1_0, 0))
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Gmsk Receive") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_char, 1, "tcp://127.0.0.1:5557", 1000, False) self.wxgui_fftsink2_0 = fftsink2.fft_sink_c( self.GetWin(), baseband_freq=102.3e6, y_per_div=10, y_divs=10, ref_level=0, ref_scale=2.0, sample_rate=samp_rate, fft_size=1024, fft_rate=15, average=False, avg_alpha=None, title="FFT Plot", peak_hold=False, ) self.Add(self.wxgui_fftsink2_0.win) self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq(102.3e6, 0) self.uhd_usrp_source_0.set_gain(75, 0) self.uhd_usrp_source_0.set_antenna("RX2", 0) self.uhd_usrp_source_0.set_bandwidth(1e6, 0) self.digital_gmsk_demod_0 = digital.gmsk_demod( samples_per_symbol=2, gain_mu=0.175, mu=0.5, omega_relative_limit=0.005, freq_error=0.0, verbose=False, log=False, ) self.blks2_packet_decoder_0 = grc_blks2.packet_demod_b(grc_blks2.packet_decoder( access_code="", threshold=-1, callback=lambda ok, payload: self.blks2_packet_decoder_0.recv_pkt(ok, payload), ), ) ################################################## # Connections ################################################## self.connect((self.blks2_packet_decoder_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.digital_gmsk_demod_0, 0), (self.blks2_packet_decoder_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.digital_gmsk_demod_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.wxgui_fftsink2_0, 0)) ### t = Thread(target=sub, args=(self.change_freq,)) t.start()
def __init__(self, num_bins=256, num_integrations=100000): gr.top_block.__init__(self, "radio_process") ################################################## # Parameters ################################################## self.num_bins = num_bins self.num_integrations = num_integrations ################################################## # Variables ################################################## self.sinc_sample_locations = sinc_sample_locations = np.arange( -np.pi * 4 / 2.0, np.pi * 4 / 2.0, np.pi / num_bins) self.sinc_samples = sinc_samples = np.sinc(sinc_sample_locations / np.pi) self.vslr = vslr = np.nan self.tsys = tsys = 171 self.tcal = tcal = 290 self.soutrack = soutrack = "at_stow" self.samp_rate = samp_rate = 2400000 self.motor_el = motor_el = np.nan self.motor_az = motor_az = np.nan self.is_running = is_running = False self.glon = glon = np.nan self.glat = glat = np.nan self.freq = freq = 1420000000 self.fft_window = fft_window = window.blackmanharris(num_bins) self.custom_window = custom_window = sinc_samples * np.hamming( 4 * num_bins) self.cal_values = cal_values = np.repeat(np.nan, num_bins) self.cal_pwr = cal_pwr = 1 self.beam_switch = beam_switch = 0 ################################################## # Blocks ################################################## self.zeromq_pub_sink_2_0 = zeromq.pub_sink(gr.sizeof_float, num_bins, 'tcp://127.0.0.1:5561', 100, False, -1) self.zeromq_pub_sink_2 = zeromq.pub_sink(gr.sizeof_float, num_bins, 'tcp://127.0.0.1:5560', 100, True, -1) self.zeromq_pub_sink_1_0 = zeromq.pub_sink(gr.sizeof_float, num_bins, 'tcp://127.0.0.1:5562', 100, True, -1) self.zeromq_pub_sink_1 = zeromq.pub_sink(gr.sizeof_float, num_bins, 'tcp://127.0.0.1:5563', 100, False, -1) self.zeromq_pub_sink_0_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5559', 100, False, -1) self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5558', 100, True, -1) self.xmlrpc_server_0 = xmlrpc.server.SimpleXMLRPCServer( ('localhost', 5557), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread( target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.osmosdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + "soapy=0") self.osmosdr_source_0.set_time_unknown_pps(osmosdr.time_spec_t()) self.osmosdr_source_0.set_sample_rate(samp_rate) self.osmosdr_source_0.set_center_freq(freq, 0) self.osmosdr_source_0.set_freq_corr(0, 0) self.osmosdr_source_0.set_gain(49.6, 0) self.osmosdr_source_0.set_if_gain(0, 0) self.osmosdr_source_0.set_bb_gain(0, 0) self.osmosdr_source_0.set_antenna('', 0) self.osmosdr_source_0.set_bandwidth(0, 0) self.fft_vxx_0 = fft.fft_vcc(num_bins, True, fft_window, True, 3) self.dc_blocker_xx_0 = filter.dc_blocker_cc( num_bins * num_integrations, False) self.blocks_tags_strobe_0_0 = blocks.tags_strobe( gr.sizeof_gr_complex * 1, pmt.to_pmt({ "num_bins": num_bins, "samp_rate": samp_rate, "num_integrations": num_integrations, "motor_az": motor_az, "motor_el": motor_el, "freq": freq, "tsys": tsys, "tcal": tcal, "cal_pwr": cal_pwr, "vslr": vslr, "glat": glat, "glon": glon, "soutrack": soutrack, "bsw": beam_switch }), min(num_bins * 64, num_bins * num_integrations), pmt.intern("metadata")) self.blocks_tags_strobe_0 = blocks.tags_strobe( gr.sizeof_gr_complex * 1, pmt.to_pmt(float(freq)), min(num_bins * 64, num_bins * num_integrations), pmt.intern("rx_freq")) self.blocks_stream_to_vector_0_2 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, num_bins) self.blocks_stream_to_vector_0_1 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, num_bins) self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, num_bins) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, num_bins) self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex * 1, num_bins * num_integrations) self.blocks_selector_0 = blocks.selector(gr.sizeof_gr_complex * 1, 0, 0) self.blocks_selector_0.set_enabled(True) self.blocks_multiply_const_xx_0 = blocks.multiply_const_ff( 1.0 / float(num_integrations), num_bins) self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vff([ (tsys + tcal) / (value * cal_pwr) for value in cal_values ]) self.blocks_multiply_const_vxx_0_0_0_0 = blocks.multiply_const_vcc( custom_window[0:num_bins]) self.blocks_multiply_const_vxx_0_0_0 = blocks.multiply_const_vcc( custom_window[num_bins:2 * num_bins]) self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vcc( custom_window[2 * num_bins:3 * num_bins]) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc( custom_window[-num_bins:]) self.blocks_message_strobe_0 = blocks.message_strobe( pmt.to_pmt(is_running), 100) self.blocks_integrate_xx_0 = blocks.integrate_ff( num_integrations, num_bins) self.blocks_delay_0_1 = blocks.delay(gr.sizeof_gr_complex * 1, num_bins) self.blocks_delay_0_0 = blocks.delay(gr.sizeof_gr_complex * 1, num_bins * 2) self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex * 1, num_bins * 3) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared( num_bins) self.blocks_add_xx_0_0 = blocks.add_vcc(1) self.blocks_add_xx_0 = blocks.add_vcc(num_bins) self.add_clock_tags = add_clock_tags.clk(nsamps=num_bins * 8) ################################################## # Connections ################################################## self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.blocks_selector_0, 'en')) self.connect((self.add_clock_tags, 0), (self.blocks_add_xx_0_0, 1)) self.connect((self.blocks_add_xx_0, 0), (self.fft_vxx_0, 0)) self.connect((self.blocks_add_xx_0_0, 0), (self.blocks_selector_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0)) self.connect((self.blocks_delay_0, 0), (self.blocks_stream_to_vector_0_2, 0)) self.connect((self.blocks_delay_0_0, 0), (self.blocks_stream_to_vector_0_0, 0)) self.connect((self.blocks_delay_0_1, 0), (self.blocks_stream_to_vector_0_1, 0)) self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_multiply_const_xx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_add_xx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.blocks_add_xx_0, 1)) self.connect((self.blocks_multiply_const_vxx_0_0_0, 0), (self.blocks_add_xx_0, 2)) self.connect((self.blocks_multiply_const_vxx_0_0_0_0, 0), (self.blocks_add_xx_0, 3)) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.zeromq_pub_sink_1, 0)) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.zeromq_pub_sink_1_0, 0)) self.connect((self.blocks_multiply_const_xx_0, 0), (self.blocks_multiply_const_vxx_1, 0)) self.connect((self.blocks_multiply_const_xx_0, 0), (self.zeromq_pub_sink_2, 0)) self.connect((self.blocks_multiply_const_xx_0, 0), (self.zeromq_pub_sink_2_0, 0)) self.connect((self.blocks_selector_0, 0), (self.dc_blocker_xx_0, 0)) self.connect((self.blocks_selector_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_selector_0, 0), (self.zeromq_pub_sink_0_0, 0)) self.connect((self.blocks_skiphead_0, 0), (self.blocks_delay_0, 0)) self.connect((self.blocks_skiphead_0, 0), (self.blocks_delay_0_0, 0)) self.connect((self.blocks_skiphead_0, 0), (self.blocks_delay_0_1, 0)) self.connect((self.blocks_skiphead_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_stream_to_vector_0_0, 0), (self.blocks_multiply_const_vxx_0_0_0, 0)) self.connect((self.blocks_stream_to_vector_0_1, 0), (self.blocks_multiply_const_vxx_0_0, 0)) self.connect((self.blocks_stream_to_vector_0_2, 0), (self.blocks_multiply_const_vxx_0_0_0_0, 0)) self.connect((self.blocks_tags_strobe_0, 0), (self.blocks_add_xx_0_0, 0)) self.connect((self.blocks_tags_strobe_0_0, 0), (self.blocks_add_xx_0_0, 2)) self.connect((self.dc_blocker_xx_0, 0), (self.blocks_skiphead_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.osmosdr_source_0, 0), (self.add_clock_tags, 0))
def publish_rx_performance_measure(self): if self._rx_performance_measure_initialized(): return self.rx_performance_measure_initialized = True config = station_configuration() vlen = config.data_subcarriers vlen_sinr_sc = config.subcarriers # self.rx_per_sink = rpsink = rpsink_dummy() self.setup_ber_measurement() self.setup_snr_measurement() self.setup_snr_measurement_2() ber_mst = self._ber_measuring_tool if self._options.sinr_est: sinr_mst = self._sinr_measurement sinr_mst_2 = self._sinr_measurement_2 else: snr_mst = self._snr_measurement snr_mst_2 = self._snr_measurement_2 # 1. frame id # 2. channel transfer function ctf = self.filter_ctf() ctf_2 = self.filter_ctf_2() self.zmq_probe_ctf = zeromq.pub_sink(gr.sizeof_float,config.data_subcarriers, "tcp://*:5559") self.zmq_probe_ctf_2 = zeromq.pub_sink(gr.sizeof_float,config.data_subcarriers, "tcp://*:5558") self.connect(ctf, blocks.keep_one_in_n(gr.sizeof_float*config.data_subcarriers,20) ,self.zmq_probe_ctf) self.connect(ctf_2, blocks.keep_one_in_n(gr.sizeof_float*config.data_subcarriers,20) ,self.zmq_probe_ctf_2) # 3. BER ### FIXME HACK print "Normal BER measurement" trig_src = dynamic_trigger_ib(False) self.connect(self.bitcount_src,trig_src) ber_sampler = vector_sampler(gr.sizeof_float,1) self.connect(ber_mst,(ber_sampler,0)) self.connect(trig_src,(ber_sampler,1)) if self._options.log: trig_src_float = gr.char_to_float() self.connect(trig_src,trig_src_float) log_to_file(self, trig_src_float , 'data/dynamic_trigger_out.float') if self._options.sinr_est is False: self.zmq_probe_ber = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5556") self.connect(ber_sampler,blocks.keep_one_in_n(gr.sizeof_float,20) ,self.zmq_probe_ber) self.zmq_probe_snr = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5555") self.connect(snr_mst,blocks.keep_one_in_n(gr.sizeof_float,20) ,self.zmq_probe_snr) self.zmq_probe_snr_2 = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5554") self.connect(snr_mst_2,blocks.keep_one_in_n(gr.sizeof_float,20) ,self.zmq_probe_snr_2)
def __init__(self): gr.top_block.__init__(self, "Testvolts") ################################################## # Variables - Some get overridden after block definition before connections. ################################################## self.samp_rate = samp_rate = 48000 # Initial wavelength assumption, which must be calibrated carefully. self.fundamental_wavelength_samples = 800 # self.probed_rms_volts = probed_rms_volts = 0 # Things from config file # self.avg_length = avg_length = 10000 self.probe_interval = probe_interval = float(SETTINGS["display"]["probe_interval"]) self.rms_alpha = rms_alpha = 1 # Calibration (Conversion) parameters, to convert from sample domain to volts/current domain. self.average_rms_slope = float(SETTINGS["calibration"]["average_rms_slope"]) self.average_rms_intercept = float(SETTINGS["calibration"]["average_rms_intercept"]) # RMS Block parameters self.voltage_calculation_rms_alpha = float(SETTINGS["calibration"]["voltage_calculation_rms_alpha"]) # Averaging block parameters self.voltage_rms_average_length = int(SETTINGS["calibration"]["voltage_rms_average_length"]) self.voltage_rms_average_scale = float(SETTINGS["calibration"]["voltage_rms_average_scale"]) self.voltage_rms_max_iter = int(SETTINGS["calibration"]["voltage_rms_max_iter"]) # for averaging block stuff self.last_sampled_wavelength = 1 # Input source parameters. self.audioSource = SETTINGS["input"]["input_type"] # Frequency calculation parameters self.freq_getfreq_alpha = float(SETTINGS["calibration"]["freq_getfreq_alpha"]) self.freq_interpolation = float(SETTINGS["calibration"]["freq_interpolation"]) self.freq_interpolation_multiplier = float(SETTINGS["calibration"]["freq_interpolation_multiplier"]) self.current_readings = self.getDefaultReadings() # AC Volts self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1, samp_rate, True) # self.blocks_rms_volts = blocks.rms_ff(self.voltage_calculation_rms_alpha) # self.blocks_moving_average_volts = blocks.moving_average_ff(self.voltage_rms_average_length, self.voltage_rms_average_scale, self.voltage_rms_max_iter) # self.probe_rms_volts = blocks.probe_signal_f() # AC Frequency # if (setting_acfreq_enabled() is True): self.probe_avgwave = blocks.probe_signal_f() self.upsampler = filter.fractional_resampler_ff(0, self.freq_interpolation) self.getfreq_block = powerquality.getfreqcpp(self.freq_getfreq_alpha) # Streaming support - Permit access to the raw samples to ZeroMQ clients. self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_float, 1, SETTINGS["tap_rawsamples"]["zmq_bind_uri"], SETTINGS["tap_rawsamples"]["zmq_timeout"], True, -1) # TODO: Connect the streaming blocks # self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((-1, )) # self.blocks_delay_0 = blocks.delay(gr.sizeof_float*1, self.fundamental_wavelength_samples) # self.blocks_add_xx_0 = blocks.add_vff(1) # Bias detection - these parameters are tuned to 48khz samp rate: (1 * samp_rate / 60, .00125, 4000) if ("bias" in SETTINGS and "bias_avg_num_waves" in SETTINGS["bias"]): bias_avg_num_waves = SETTINGS["bias"]["bias_avg_num_waves"] else: bias_avg_num_waves = 1 # Calculate the number of samples associated with n wavelengths specified in settings or the default. avgBiasNumSamples = bias_avg_num_waves * samp_rate / 60 self.blocks_bias_moving_average = blocks.moving_average_ff(avgBiasNumSamples, 1.0/avgBiasNumSamples, 4000) self.probe_bias = blocks.probe_signal_f() ### Calibrate the blocks based on settings from config file # self.set_rms_alpha(asdfasdfasdfasdf from settings) # Instantiate the message consumer that we'll use to get json messages from the getfreq block self.msgConsumer = message_consumer() ################################################## # RMS Volts Connections ################################################## # self.connect((self.blocks_rms_volts, 0), (self.blocks_moving_average_volts, 0)) # self.connect((self.blocks_moving_average_volts, 0), (self.probe_rms_volts, 0)) # Set up a variable with a default value. Below we'll override the value depending on whether we are reading from file or audio device. self.sourceOfSamplesBlock = self.blocks_throttle_0 # Select input source - wav file or sound card. if (self.audioSource == "wav"): # Variable source type: wav file # self.wavfile_input = blocks.wavfile_source('./samples/sample.wav', False) self.input_wav_filename = SETTINGS["input"]["input_wav_filename"] self.wavfile_input = blocks.wavfile_source(self.input_wav_filename, True) # wav input requires throttle block. Then we connect things to the throttle block directly instead of the wav source. self.connect((self.wavfile_input, 0), (self.blocks_throttle_0, 0)) self.sourceOfSamplesBlock = self.blocks_throttle_0 else: # Variable source type: sound device. self.soundcard_device_name = "" if (SETTINGS["input"]["input_sound_device"]): self.soundcard_device_name = SETTINGS["input"]["input_sound_device"] self.soundcard_input = audio.source(samp_rate, self.soundcard_device_name, True) # no throttle block needed in the case of sound card self.sourceOfSamplesBlock = self.soundcard_input # Volts flow print "CONNECTIONS: Defining the voltage calculation flow" # self.connect((self.sourceOfSamplesBlock , 0), (self.blocks_rms_volts, 0)) # Hz flow print "CONNECTIONS: Defining the frequency calculation flow" self.connect((self.sourceOfSamplesBlock , 0), (self.upsampler, 0)) self.connect((self.upsampler, 0), (self.getfreq_block, 0)) self.connect((self.getfreq_block, 0), (self.probe_avgwave, 0)) # Raw Tap port Tap flow print "CONNECTIONS: Connecting raw samples tap (ZMQ)" self.connect((self.sourceOfSamplesBlock , 0), (self.zeromq_pub_sink_0, 0)) # Bias Detection flow self.connect((self.sourceOfSamplesBlock, 0), (self.blocks_bias_moving_average, 0)) self.connect((self.blocks_bias_moving_average, 0), (self.probe_bias, 0)) # Connect our message consumer block to the message output of the getfreq block so we can get messages from it. self.msg_connect((self.getfreq_block, 'out'), (self.msgConsumer, 'in_port'))
def __init__(self, decim=50, decim_df=.2, decim_f=.4, device_address="type=b200", device_arguments="master_clock_rate=30.72e6", df_ref=0, df_test=10e3, f_sample=960e3*4, f_sig=6e9, g_ref=0, g_sig=0, g_test=49, n_samples=1<<24, name="test", pass_tags=False, port_base=6880, f_dsp=0): gr.top_block.__init__(self, "Ampm Cli") ################################################## # Parameters ################################################## self.decim = decim self.decim_df = decim_df self.decim_f = decim_f self.device_address = device_address self.device_arguments = device_arguments self.df_ref = df_ref self.df_test = df_test self.f_sample = f_sample self.f_sig = f_sig self.g_ref = g_ref self.g_sig = g_sig self.g_test = g_test self.n_samples = n_samples self.name = name self.pass_tags = pass_tags self.port_base = port_base self.f_dsp = f_dsp ################################################## # Variables ################################################## self.info = info = {"name":name, "f_sig":f_sig, "df_ref":df_ref, "f_sample":f_sample, "decim":decim} self.filename = filename = "{:s}_f0{:.5g}_df{:.5g}_fs{:.5g}_d{:.5g}".format(name, f_sig/1e6, df_ref, f_sample/1e6, decim) ################################################## # Blocks ################################################## self.zeromq_sub_source_0_2_0 = zeromq.sub_source(gr.sizeof_float, decim**0, "tcp://localhost:{}".format(port_base + 9), 100, pass_tags) self.zeromq_sub_source_0_2 = zeromq.sub_source(gr.sizeof_gr_complex, decim**0, "tcp://localhost:{}".format(port_base + 0), 100, pass_tags) self.zeromq_sub_source_0_1 = zeromq.sub_source(gr.sizeof_gr_complex, decim**1, "tcp://localhost:6881", 100, pass_tags) self.zeromq_sub_source_0_0 = zeromq.sub_source(gr.sizeof_gr_complex, decim**3, "tcp://localhost:6883", 100, pass_tags) self.zeromq_sub_source_0 = zeromq.sub_source(gr.sizeof_gr_complex, decim**2, "tcp://localhost:6882", 100, pass_tags) self.zeromq_pub_sink_0_1_2 = zeromq.pub_sink(gr.sizeof_float, decim**0, "tcp://*:{}".format(port_base + 9), 100, pass_tags) self.zeromq_pub_sink_0_1_1 = zeromq.pub_sink(gr.sizeof_gr_complex, decim**1, "tcp://*:{}".format(port_base + 1), 100, pass_tags) self.zeromq_pub_sink_0_1_0_0 = zeromq.pub_sink(gr.sizeof_gr_complex, decim**3, "tcp://*:{}".format(port_base + 3), 100, pass_tags) self.zeromq_pub_sink_0_1_0 = zeromq.pub_sink(gr.sizeof_gr_complex, decim**2, "tcp://*:{}".format(port_base + 2), 100, pass_tags) self.zeromq_pub_sink_0_1 = zeromq.pub_sink(gr.sizeof_gr_complex, decim**0, "tcp://*:{}".format(port_base + 0), 100, pass_tags) self.uhd_usrp_source_0_0 = uhd.usrp_source( ",".join((device_address, device_arguments)), uhd.stream_args( cpu_format="fc32", channels=range(2), ), ) self.uhd_usrp_source_0_0.set_subdev_spec("A:A A:B", 0) self.uhd_usrp_source_0_0.set_time_unknown_pps(uhd.time_spec()) self.uhd_usrp_source_0_0.set_samp_rate(f_sample) self.uhd_usrp_source_0_0.set_center_freq(uhd.tune_request(target_freq=f_sig , dsp_freq=f_dsp, rf_freq_policy=uhd.tune_request.POLICY_AUTO, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_source_0_0.set_gain(g_sig, 0) self.uhd_usrp_source_0_0.set_bandwidth(30.72e6, 0) self.uhd_usrp_source_0_0.set_center_freq(uhd.tune_request(target_freq=f_sig + df_ref, dsp_freq=f_dsp, rf_freq_policy=uhd.tune_request.POLICY_AUTO, dsp_freq_policy=uhd.tune_request.POLICY_MANUAL), 1) self.uhd_usrp_source_0_0.set_gain(g_ref, 1) self.uhd_usrp_source_0_0.set_bandwidth(30.72e6, 1) self.blocks_stream_to_vector_0_1_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, decim**3) self.blocks_stream_to_vector_0_1 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, decim**2) self.blocks_stream_to_vector_0_0_0 = blocks.stream_to_vector(gr.sizeof_float*1, decim**0) self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, decim**0) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, decim**1) self.blocks_skiphead_0 = blocks.skiphead(gr.sizeof_gr_complex*decim**3, n_samples/decim**3) self.blocks_head_0_1 = blocks.head(gr.sizeof_gr_complex*decim**1, n_samples/decim**1) self.blocks_head_0_0 = blocks.head(gr.sizeof_gr_complex*decim**3, n_samples/decim**3) self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*decim**2, n_samples/decim**2) self.blocks_file_meta_sink_0_3_0 = blocks.file_meta_sink(gr.sizeof_float*decim**0, "{}_w.bin".format(filename), f_sample, decim**3, blocks.GR_FILE_FLOAT, False, 1<<20, "", True) self.blocks_file_meta_sink_0_3_0.set_unbuffered(False) self.blocks_file_meta_sink_0_3 = blocks.file_meta_sink(gr.sizeof_gr_complex*decim**0, "{}_0.bin".format(filename), f_sample, decim**3, blocks.GR_FILE_FLOAT, True, 1<<20, "", True) self.blocks_file_meta_sink_0_3.set_unbuffered(False) self.blocks_file_meta_sink_0_1 = blocks.file_meta_sink(gr.sizeof_gr_complex*decim**1, "{}_1.bin".format(filename), f_sample, decim**2, blocks.GR_FILE_FLOAT, True, 1<<20, "", True) self.blocks_file_meta_sink_0_1.set_unbuffered(False) self.blocks_file_meta_sink_0_0 = blocks.file_meta_sink(gr.sizeof_gr_complex*decim**3, "{}_3.bin".format(filename), f_sample, decim**0, blocks.GR_FILE_FLOAT, True, 1<<20, "", True) self.blocks_file_meta_sink_0_0.set_unbuffered(False) self.blocks_file_meta_sink_0 = blocks.file_meta_sink(gr.sizeof_gr_complex*decim**2, "{}_2.bin".format(filename), f_sample, decim**1, blocks.GR_FILE_FLOAT, True, 1<<20, "", True) self.blocks_file_meta_sink_0.set_unbuffered(False) self.blocks_ctrlport_probe2_c_0_1 = blocks.ctrlport_probe2_c("d0", "diff0", 1024, gr.DISPTIME) self.blocks_ctrlport_probe2_c_0_0 = blocks.ctrlport_probe2_c("b", "input b", 1024, gr.DISPTIME) self.blocks_ctrlport_probe2_c_0 = blocks.ctrlport_probe2_c("a", "input a", 1024, gr.DISPTIME) self.blocks_ctrlport_monitor_0 = not True or monitor() self.Ampm_0 = Ampm( decim=decim, decim_df=decim_df, decim_f=decim_f, ) ################################################## # Connections ################################################## self.connect((self.Ampm_0, 0), (self.blocks_ctrlport_probe2_c_0_1, 0)) self.connect((self.Ampm_0, 2), (self.blocks_stream_to_vector_0, 0)) self.connect((self.Ampm_0, 3), (self.blocks_stream_to_vector_0_0, 0)) self.connect((self.Ampm_0, 4), (self.blocks_stream_to_vector_0_0_0, 0)) self.connect((self.Ampm_0, 1), (self.blocks_stream_to_vector_0_1, 0)) self.connect((self.Ampm_0, 0), (self.blocks_stream_to_vector_0_1_0, 0)) self.connect((self.blocks_head_0, 0), (self.blocks_file_meta_sink_0, 0)) self.connect((self.blocks_head_0_0, 0), (self.blocks_file_meta_sink_0_0, 0)) self.connect((self.blocks_head_0_1, 0), (self.blocks_file_meta_sink_0_1, 0)) self.connect((self.blocks_skiphead_0, 0), (self.blocks_head_0_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.zeromq_pub_sink_0_1_1, 0)) self.connect((self.blocks_stream_to_vector_0_0, 0), (self.zeromq_pub_sink_0_1, 0)) self.connect((self.blocks_stream_to_vector_0_0_0, 0), (self.zeromq_pub_sink_0_1_2, 0)) self.connect((self.blocks_stream_to_vector_0_1, 0), (self.zeromq_pub_sink_0_1_0, 0)) self.connect((self.blocks_stream_to_vector_0_1_0, 0), (self.zeromq_pub_sink_0_1_0_0, 0)) self.connect((self.uhd_usrp_source_0_0, 0), (self.Ampm_0, 0)) self.connect((self.uhd_usrp_source_0_0, 1), (self.Ampm_0, 1)) self.connect((self.uhd_usrp_source_0_0, 0), (self.blocks_ctrlport_probe2_c_0, 0)) self.connect((self.uhd_usrp_source_0_0, 1), (self.blocks_ctrlport_probe2_c_0_0, 0)) self.connect((self.zeromq_sub_source_0, 0), (self.blocks_head_0, 0)) self.connect((self.zeromq_sub_source_0_0, 0), (self.blocks_skiphead_0, 0)) self.connect((self.zeromq_sub_source_0_1, 0), (self.blocks_head_0_1, 0)) self.connect((self.zeromq_sub_source_0_2, 0), (self.blocks_file_meta_sink_0_3, 0)) self.connect((self.zeromq_sub_source_0_2_0, 0), (self.blocks_file_meta_sink_0_3_0, 0))
def __init__(self, options): gr.top_block.__init__(self) self.c = 299700000 self.options = options self.cnt = 0 self.run_loop = False self.samp_rate = 100000000 self.hostname = os.uname()[1] self.gps = "emu_" self.id_rx = options.id_rx self.noise_amp = 1 / np.sqrt(np.power(10, options.snr / 10)) self.modulation = options.modulation self.seed = 10 self.delay = options.delay self.samples_to_receive = 300 self.samples_to_receive_calibration = 1000 self.freq = 550000000 coordinates_string = options.coordinates_m.split(",") self.coordinates = (float(coordinates_string[0]), float(coordinates_string[1])) tx_coordinates_string = options.tx_coordinates.split(",") self.tx_coordinates = np.array( [float(tx_coordinates_string[0]), float(tx_coordinates_string[1])]) # socket addresses rpc_port = 6665 + options.id_rx rpc_adr = "tcp://*:" + str(rpc_port) fusion_center_adr = "tcp://" + options.fusion_center + ":6665" probe_port = 5555 + options.id_rx probe_adr = "tcp://*:" + str(probe_port) self.stp_cnt = 0 if options.movement_file != "EMPTY": self.track_coordinates = genfromtxt(options.movement_file, delimiter=',') print self.track_coordinates self.tx_coordinates = self.track_coordinates[0, :] else: self.track_coordinates = np.array([]) # blocks self.zmq_probe = zeromq.pub_sink(gr.sizeof_gr_complex, 1, probe_adr, 10, True) self.mod_block = ModulatorBlock(self.seed, self.samp_rate, self.noise_amp, self.modulation, self.delay, self.samples_to_receive, self.freq, self.id_rx) self.seed += 1 # connects self.connect(self.mod_block, self.zmq_probe) # ZeroMQ self.rpc_manager = rpc_manager_local.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr) self.rpc_manager.set_request_socket(fusion_center_adr) self.rpc_manager.add_interface("start_fg", self.start_fg) self.rpc_manager.add_interface("set_gain", self.set_gain) self.rpc_manager.add_interface("set_samp_rate", self.set_samp_rate) self.rpc_manager.add_interface("set_bw", self.set_bw) self.rpc_manager.add_interface("set_antenna", self.set_antenna) self.rpc_manager.add_interface("get_gps_position", self.get_gps_position) self.rpc_manager.add_interface("set_run_loop", self.set_run_loop) self.rpc_manager.add_interface("sync_time", self.sync_time) self.rpc_manager.add_interface("program_gps_position", self.program_gps_position) self.rpc_manager.add_interface("stop_transmitter", self.stop_transmitter) self.rpc_manager.add_interface("start_transmitter", self.start_transmitter) self.rpc_manager.start_watcher() # Find out ip address s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) if not options.ssh_proxy: s.connect((options.fusion_center, 6665)) else: s.connect(("www.rwth-aachen.de", 80)) self.ip_addr = s.getsockname()[0]
def __init__(self): gr.top_block.__init__(self, "OPS-SAT UHF demodulator/decoder") Qt.QWidget.__init__(self) self.setWindowTitle("OPS-SAT UHF demodulator/decoder") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "os_demod_decode") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 57600 self.baud_rate = baud_rate = 9600 self.gaussian_taps = gaussian_taps = firdes.gaussian( 1.5, 2 * (samp_rate / baud_rate), 0.5, 12) self.gain_mu = gain_mu = 0.175 ################################################## # Blocks ################################################## self.zeromq_sub_source_0 = zeromq.sub_source(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5555', 100, False, -1) self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_char, 1, 'tcp://127.0.0.1:38211', 100, False, -1) self.satellites_strip_ax25_header_0 = satellites.strip_ax25_header() self.satellites_nrzi_decode_0 = satellites.nrzi_decode() self.satellites_hdlc_deframer_0_0 = satellites.hdlc_deframer( check_fcs=True, max_length=1000) self.satellites_decode_rs_0 = satellites.decode_rs(True, 0) self.satellites_check_address_0 = satellites.check_address( 'DP0OPS', "from") self.qtgui_waterfall_sink_x_0 = qtgui.waterfall_sink_c( 512, #size firdes.WIN_HAMMING, #wintype 0, #fc samp_rate, #bw "OPS-SAT UHF BEACON", #name 1 #number of inputs ) self.qtgui_waterfall_sink_x_0.set_update_time(0.03) self.qtgui_waterfall_sink_x_0.enable_grid(False) self.qtgui_waterfall_sink_x_0.enable_axis_labels(True) if not True: self.qtgui_waterfall_sink_x_0.disable_legend() if "complex" == "float" or "complex" == "msg_float": self.qtgui_waterfall_sink_x_0.set_plot_pos_half(not True) labels = ['', '', '', '', '', '', '', '', '', ''] colors = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(1): if len(labels[i]) == 0: self.qtgui_waterfall_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_waterfall_sink_x_0.set_line_label(i, labels[i]) self.qtgui_waterfall_sink_x_0.set_color_map(i, colors[i]) self.qtgui_waterfall_sink_x_0.set_line_alpha(i, alphas[i]) self.qtgui_waterfall_sink_x_0.set_intensity_range(-140, 10) self._qtgui_waterfall_sink_x_0_win = sip.wrapinstance( self.qtgui_waterfall_sink_x_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_waterfall_sink_x_0_win) self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c( 512, #size firdes.WIN_BLACKMAN_hARRIS, #wintype 0, #fc samp_rate, #bw "", #name 1 #number of inputs ) self.qtgui_freq_sink_x_0.set_update_time(0.10) self.qtgui_freq_sink_x_0.set_y_axis(-140, 10) self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB') self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "") self.qtgui_freq_sink_x_0.enable_autoscale(False) self.qtgui_freq_sink_x_0.enable_grid(False) self.qtgui_freq_sink_x_0.set_fft_average(0.1) self.qtgui_freq_sink_x_0.enable_axis_labels(True) self.qtgui_freq_sink_x_0.enable_control_panel(False) if not True: self.qtgui_freq_sink_x_0.disable_legend() if "complex" == "float" or "complex" == "msg_float": self.qtgui_freq_sink_x_0.set_plot_pos_half(not True) labels = ['', '', '', '', '', '', '', '', '', ''] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ "blue", "red", "green", "black", "cyan", "magenta", "yellow", "dark red", "dark green", "dark blue" ] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(1): if len(labels[i]) == 0: self.qtgui_freq_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_freq_sink_x_0.set_line_label(i, labels[i]) self.qtgui_freq_sink_x_0.set_line_width(i, widths[i]) self.qtgui_freq_sink_x_0.set_line_color(i, colors[i]) self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_freq_sink_x_0_win = sip.wrapinstance( self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win) self.fir_filter_xxx_0 = filter.fir_filter_fff(1, (gaussian_taps)) self.fir_filter_xxx_0.declare_sample_delay(0) self.digital_descrambler_bb_0_0 = digital.descrambler_bb(0x21, 0, 16) self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff( (samp_rate / baud_rate) * (1 + 0.0), 0.25 * gain_mu * gain_mu, 0.5, gain_mu, 0.005) self.digital_binary_slicer_fb_0 = digital.binary_slicer_fb() self.digital_additive_scrambler_bb_0_0 = digital.additive_scrambler_bb( 0xA9, 0xFF, 7, count=0, bits_per_byte=1, reset_tag_key="packet_len") self.blocks_unpacked_to_packed_xx_0_0_0_0 = blocks.unpacked_to_packed_bb( 1, gr.GR_MSB_FIRST) self.blocks_tagged_stream_to_pdu_0_0_0_0_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, 'packet_len') self.blocks_pdu_to_tagged_stream_1 = blocks.pdu_to_tagged_stream( blocks.byte_t, 'packet_len') self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream( blocks.byte_t, 'packet_len') self.blocks_packed_to_unpacked_xx_0 = blocks.packed_to_unpacked_bb( 1, gr.GR_MSB_FIRST) self.blocks_message_debug_0 = blocks.message_debug() self.analog_quadrature_demod_cf_0 = analog.quadrature_demod_cf( 2 * (samp_rate / baud_rate) / (math.pi)) ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0_0_0_0_0, 'pdus'), (self.satellites_decode_rs_0, 'in')) self.msg_connect((self.satellites_check_address_0, 'ok'), (self.satellites_strip_ax25_header_0, 'in')) self.msg_connect((self.satellites_decode_rs_0, 'out'), (self.blocks_message_debug_0, 'print_pdu')) self.msg_connect((self.satellites_decode_rs_0, 'out'), (self.blocks_pdu_to_tagged_stream_1, 'pdus')) self.msg_connect((self.satellites_hdlc_deframer_0_0, 'out'), (self.satellites_check_address_0, 'in')) self.msg_connect((self.satellites_strip_ax25_header_0, 'out'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.connect((self.analog_quadrature_demod_cf_0, 0), (self.fir_filter_xxx_0, 0)) self.connect((self.blocks_packed_to_unpacked_xx_0, 0), (self.digital_additive_scrambler_bb_0_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_packed_to_unpacked_xx_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_1, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_unpacked_to_packed_xx_0_0_0_0, 0), (self.blocks_tagged_stream_to_pdu_0_0_0_0_0, 0)) self.connect((self.digital_additive_scrambler_bb_0_0, 0), (self.blocks_unpacked_to_packed_xx_0_0_0_0, 0)) self.connect((self.digital_binary_slicer_fb_0, 0), (self.satellites_nrzi_decode_0, 0)) self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.digital_binary_slicer_fb_0, 0)) self.connect((self.digital_descrambler_bb_0_0, 0), (self.satellites_hdlc_deframer_0_0, 0)) self.connect((self.fir_filter_xxx_0, 0), (self.digital_clock_recovery_mm_xx_0, 0)) self.connect((self.satellites_nrzi_decode_0, 0), (self.digital_descrambler_bb_0_0, 0)) self.connect((self.zeromq_sub_source_0, 0), (self.analog_quadrature_demod_cf_0, 0)) self.connect((self.zeromq_sub_source_0, 0), (self.qtgui_freq_sink_x_0, 0)) self.connect((self.zeromq_sub_source_0, 0), (self.qtgui_waterfall_sink_x_0, 0))
def __init__(self, options): gr.top_block.__init__(self) self.c = 299700000 self.options = options self.cnt = 0 self.run_loop = False self.samp_rate = 100000000 self.hostname = os.uname()[1] self.gps = "emu_" self.id_rx = options.id_rx self.noise_amp = 1/np.sqrt(np.power(10,options.snr/10)) self.modulation = options.modulation self.seed = 10 self.delay = options.delay self.samples_to_receive = 300 self.samples_to_receive_calibration = 1000 self.freq = 550000000 coordinates_string = options.coordinates_m.split(",") self.coordinates = (float(coordinates_string[0]),float(coordinates_string[1])) tx_coordinates_string = options.tx_coordinates.split(",") self.tx_coordinates = np.array([float(tx_coordinates_string[0]),float(tx_coordinates_string[1])]) # socket addresses rpc_port = 6665 + options.id_rx rpc_adr = "tcp://*:" + str(rpc_port) fusion_center_adr = "tcp://" + options.fusion_center + ":6665" probe_port = 5555 + options.id_rx probe_adr = "tcp://*:" + str(probe_port) self.stp_cnt = 0 if options.movement_file != "EMPTY": self.track_coordinates = genfromtxt(options.movement_file, delimiter=',') print self.track_coordinates self.tx_coordinates = self.track_coordinates[0,:] else: self.track_coordinates = np.array([]) # blocks self.zmq_probe = zeromq.pub_sink(gr.sizeof_gr_complex, 1, probe_adr, 10, True) self.mod_block = ModulatorBlock(self.seed, self.samp_rate, self.noise_amp, self.modulation, self.delay, self.samples_to_receive, self.freq, self.id_rx) self.seed += 1 # connects self.connect(self.mod_block, self.zmq_probe) # ZeroMQ self.rpc_manager = rpc_manager_local.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr) self.rpc_manager.set_request_socket(fusion_center_adr) self.rpc_manager.add_interface("start_fg",self.start_fg) self.rpc_manager.add_interface("set_gain",self.set_gain) self.rpc_manager.add_interface("set_samp_rate",self.set_samp_rate) self.rpc_manager.add_interface("set_bw",self.set_bw) self.rpc_manager.add_interface("set_antenna",self.set_antenna) self.rpc_manager.add_interface("get_gps_position",self.get_gps_position) self.rpc_manager.add_interface("set_run_loop",self.set_run_loop) self.rpc_manager.add_interface("sync_time",self.sync_time) self.rpc_manager.add_interface("program_gps_position",self.program_gps_position) self.rpc_manager.add_interface("stop_transmitter", self.stop_transmitter) self.rpc_manager.add_interface("start_transmitter", self.start_transmitter) self.rpc_manager.start_watcher() # Find out ip address s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) if not options.ssh_proxy: s.connect((options.fusion_center,6665)) else: s.connect(("www.rwth-aachen.de",80)) self.ip_addr = s.getsockname()[0]
def __init__(self, options): gr.hier_block2.__init__(self, "fbmc_receive_path", gr.io_signature(1,1,gr.sizeof_gr_complex), gr.io_signature(0,0,0)) print "This is FBMC receive path 1x1" common_options.defaults(options) config = self.config = station_configuration() config.data_subcarriers = dsubc = options.subcarriers config.cp_length = 0 config.frame_data_blocks = options.data_blocks config._verbose = options.verbose #TODO: update config.fft_length = options.fft_length config.dc_null = options.dc_null config.training_data = default_block_header(dsubc, config.fft_length,config.dc_null,options) config.coding = options.coding config.ber_window = options.ber_window config.periodic_parts = 8 config.frame_id_blocks = 1 # FIXME self._options = copy.copy(options) #FIXME: do we need this? config.fbmc = options.fbmc config.block_length = config.fft_length + config.cp_length config.frame_data_part = config.frame_data_blocks + config.frame_id_blocks config.frame_length = config.training_data.fbmc_no_preambles + 2*config.frame_data_part config.postpro_frame_length = config.frame_data_part + \ config.training_data.no_pilotsyms config.subcarriers = dsubc + \ config.training_data.pilot_subcarriers config.virtual_subcarriers = config.fft_length - config.subcarriers - config.dc_null total_subc = config.subcarriers # check some bounds if config.fft_length < config.subcarriers: raise SystemError, "Subcarrier number must be less than FFT length" if config.fft_length < config.cp_length: raise SystemError, "Cyclic prefix length must be less than FFT length" #self.input = gr.kludge_copy(gr.sizeof_gr_complex) #self.connect( self, self.input ) self.input = self self.ideal = options.ideal self.ideal2 = options.ideal2 ## Inner receiver ## Timing & Frequency Synchronization ## Channel estimation + Equalization ## Phase Tracking for sampling clock frequency offset correction inner_receiver = self.inner_receiver = fbmc_inner_receiver( options, options.log ) self.connect( self.input, inner_receiver ) ofdm_blocks = ( inner_receiver, 2 ) frame_start = ( inner_receiver, 1 ) disp_ctf = ( inner_receiver, 0 ) #self.snr_est_preamble = ( inner_receiver, 3 ) #terminate_stream(self,snr_est_preamble) disp_cfo = ( inner_receiver, 3 ) if self.ideal is False and self.ideal2 is False: self.zmq_probe_freqoff = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5557") self.connect(disp_cfo, self.zmq_probe_freqoff) else: self.connect(disp_cfo, blocks.null_sink(gr.sizeof_float)) # for ID decoder used_id_bits = config.used_id_bits = 8 #TODO: constant in source code! rep_id_bits = config.rep_id_bits = dsubc/used_id_bits #BPSK if options.log: print "rep_id_bits %d" % (rep_id_bits) if dsubc % used_id_bits <> 0: raise SystemError,"Data subcarriers need to be multiple of 10" ## Workaround to avoid periodic structure seed(1) whitener_pn = [randint(0,1) for i in range(used_id_bits*rep_id_bits)] ## NOTE!!! BIG HACK!!! ## first preamble ain't equalized .... ## for Milan's SNR estimator ## Outer Receiver ## Make new inner receiver compatible with old outer receiver ## FIXME: renew outer receiver self.ctf = disp_ctf #frame_sampler = ofdm_frame_sampler(options) frame_sampler = fbmc_frame_sampler(options) self.connect( ofdm_blocks, frame_sampler) self.connect( frame_start, (frame_sampler,1) ) # # ft = [0] * config.frame_length # ft[0] = 1 # # # The next block ensures that only complete frames find their way into # # the old outer receiver. The dynamic frame start trigger is hence # # replaced with a static one, fixed to the frame length. # # frame_sampler = ofdm.vector_sampler( gr.sizeof_gr_complex * total_subc, # config.frame_length ) # self.symbol_output = blocks.vector_to_stream( gr.sizeof_gr_complex * total_subc, # config.frame_length ) # delayed_frame_start = blocks.delay( gr.sizeof_char, config.frame_length - 1 ) # damn_static_frame_trigger = blocks.vector_source_b( ft, True ) # # if options.enable_erasure_decision: # frame_gate = vector_sampler( # gr.sizeof_gr_complex * total_subc * config.frame_length, 1 ) # self.connect( ofdm_blocks, frame_sampler, frame_gate, # self.symbol_output ) # else: # self.connect( ofdm_blocks, frame_sampler, self.symbol_output ) # # self.connect( frame_start, delayed_frame_start, ( frame_sampler, 1 ) ) if options.enable_erasure_decision: frame_gate = frame_sampler.frame_gate self.symbol_output = frame_sampler orig_frame_start = frame_start frame_start = (frame_sampler,1) self.frame_trigger = frame_start #terminate_stream(self, self.frame_trigger) ## Pilot block filter pb_filt = self._pilot_block_filter = fbmc_pilot_block_filter() self.connect(self.symbol_output,pb_filt) self.connect(self.frame_trigger,(pb_filt,1)) self.frame_data_trigger = (pb_filt,1) #self.symbol_output = pb_filt #if options.log: #log_to_file(self, pb_filt, "data/pb_filt_out.compl") if config.fbmc: pda_in = pb_filt else: ## Pilot subcarrier filter ps_filt = self._pilot_subcarrier_filter = pilot_subcarrier_filter() self.connect(self.symbol_output,ps_filt) if options.log: log_to_file(self, ps_filt, "data/ps_filt_out.compl") pda_in = ps_filt ## Workaround to avoid periodic structure # for ID decoder seed(1) whitener_pn = [randint(0,1) for i in range(used_id_bits*rep_id_bits)] if not options.enable_erasure_decision: ## ID Block Filter # Filter ID block, skip data blocks id_bfilt = self._id_block_filter = vector_sampler( gr.sizeof_gr_complex * dsubc, 1 ) if not config.frame_id_blocks == 1: raise SystemExit, "# ID Blocks > 1 not supported" self.connect( pda_in , id_bfilt ) self.connect( self.frame_data_trigger, ( id_bfilt, 1 ) ) # trigger #log_to_file( self, id_bfilt, "data/id_bfilt.compl" ) ## ID Demapper and Decoder, soft decision self.id_dec = self._id_decoder = ofdm.coded_bpsk_soft_decoder( dsubc, used_id_bits, whitener_pn ) self.connect( id_bfilt, self.id_dec ) print "Using coded BPSK soft decoder for ID detection" else: # options.enable_erasure_decision: id_bfilt = self._id_block_filter = vector_sampler( gr.sizeof_gr_complex * total_subc, config.frame_id_blocks ) id_bfilt_trig_delay = 0 for x in range( config.frame_length ): if x in config.training_data.pilotsym_pos: id_bfilt_trig_delay += 1 else: break print "Position of ID block within complete frame: %d" %(id_bfilt_trig_delay) assert( id_bfilt_trig_delay > 0 ) # else not supported id_bfilt_trig = blocks.delay( gr.sizeof_char, id_bfilt_trig_delay ) self.connect( ofdm_blocks, id_bfilt ) self.connect( orig_frame_start, id_bfilt_trig, ( id_bfilt, 1 ) ) self.id_dec = self._id_decoder = ofdm.coded_bpsk_soft_decoder( total_subc, used_id_bits, whitener_pn, config.training_data.shifted_pilot_tones ) self.connect( id_bfilt, self.id_dec ) print "Using coded BPSK soft decoder for ID detection" # The threshold block either returns 1.0 if the llr-value from the # id decoder is below the threshold, else 0.0. Hence we convert this # into chars, 0 and 1, and use it as trigger for the sampler. min_llr = ( self.id_dec, 1 ) erasure_threshold = gr.threshold_ff( 10.0, 10.0, 0 ) # FIXME is it the optimal threshold? erasure_dec = gr.float_to_char() id_gate = vector_sampler( gr.sizeof_short, 1 ) ctf_gate = vector_sampler( gr.sizeof_float * total_subc, 1 ) self.connect( self.id_dec , id_gate ) self.connect( self.ctf, ctf_gate ) self.connect( min_llr, erasure_threshold, erasure_dec ) self.connect( erasure_dec, ( frame_gate, 1 ) ) self.connect( erasure_dec, ( id_gate, 1 ) ) self.connect( erasure_dec, ( ctf_gate, 1 ) ) self.id_dec = self._id_decoder = id_gate self.ctf = ctf_gate print "Erasure decision for IDs is enabled" if options.log: id_dec_f = gr.short_to_float() self.connect(self.id_dec,id_dec_f) log_to_file(self, id_dec_f, "data/id_dec_out.float") if options.log: log_to_file(self, id_bfilt, "data/id_blockfilter_out.compl") # TODO: refactor names if options.log: map_src_f = gr.char_to_float(dsubc) self.connect(map_src,map_src_f) log_to_file(self, map_src_f, "data/map_src_out.float") ## Allocation Control if options.static_allocation: #DEBUG if options.coding: mode = 1 # Coding mode 1-9 bitspermode = [0.5,1,1.5,2,3,4,4.5,5,6] # Information bits per mode bitcount_vec = [(int)(config.data_subcarriers*config.frame_data_blocks*bitspermode[mode-1])] bitloading = mode else: bitloading = 1 bitcount_vec = [config.data_subcarriers*config.frame_data_blocks*bitloading] #bitcount_vec = [config.data_subcarriers*config.frame_data_blocks] self.bitcount_src = blocks.vector_source_i(bitcount_vec,True,1) # 0s for ID block, then data #bitloading_vec = [0]*dsubc+[0]*(dsubc/2)+[2]*(dsubc/2) bitloading_vec = [0]*dsubc+[bitloading]*dsubc bitloading_src = blocks.vector_source_b(bitloading_vec,True,dsubc) power_vec = [1]*config.data_subcarriers power_src = blocks.vector_source_f(power_vec,True,dsubc) else: self.allocation_buffer = ofdm.allocation_buffer(config.data_subcarriers, config.frame_data_blocks, "tcp://"+options.tx_hostname+":3333",config.coding) self.bitcount_src = (self.allocation_buffer,0) bitloading_src = (self.allocation_buffer,1) power_src = (self.allocation_buffer,2) self.connect(self.id_dec, self.allocation_buffer) if options.benchmarking: self.allocation_buffer.set_allocation([4]*config.data_subcarriers,[1]*config.data_subcarriers) if options.log: log_to_file(self, self.bitcount_src, "data/bitcount_src_rx.int") log_to_file(self, bitloading_src, "data/bitloading_src_rx.char") log_to_file(self, power_src, "data/power_src_rx.cmplx") log_to_file(self, self.id_dec, "data/id_dec_rx.short") ## Power Deallocator pda = self._power_deallocator = multiply_frame_fc(config.frame_data_part, dsubc) self.connect(pda_in,(pda,0)) self.connect(power_src,(pda,1)) ## Demodulator # if 0: # ac_vector = [0.0+0.0j]*208 # ac_vector[0] = (2*10**(-0.452)) # ac_vector[3] = (10**(-0.651)) # ac_vector[7] = (10**(-1.151)) # csi_vector_inv=abs(numpy.fft.fft(numpy.sqrt(ac_vector)))**2 # dm_csi = numpy.fft.fftshift(csi_vector_inv) # TODO dm_csi = [1]*dsubc # TODO dm_csi = blocks.vector_source_f(dm_csi,True) ## Depuncturer dp_trig = [0]*(config.frame_data_blocks/2) dp_trig[0] = 1 dp_trig = blocks.vector_source_b(dp_trig,True) # TODO if(options.coding): fo=ofdm.fsm(1,2,[91,121]) if options.interleave: int_object=trellis.interleaver(2000,666) deinterlv = trellis.permutation(int_object.K(),int_object.DEINTER(),1,gr.sizeof_float) demod = self._data_demodulator = generic_softdemapper_vcf(dsubc, config.frame_data_part, config.coding) #self.connect(dm_csi,blocks.stream_to_vector(gr.sizeof_float,dsubc),(demod,2)) if(options.ideal): self.connect(dm_csi,blocks.stream_to_vector(gr.sizeof_float,dsubc),(demod,2)) else: dm_csi_filter = self.dm_csi_filter = filter.single_pole_iir_filter_ff(0.01,dsubc) self.connect(self.ctf, self.dm_csi_filter,(demod,2)) #log_to_file(self, dm_csi_filter, "data/softs_csi.float") #self.connect(dm_trig,(demod,3)) else: demod = self._data_demodulator = generic_demapper_vcb(dsubc, config.frame_data_part) if options.benchmarking: # Do receiver benchmarking until the number of frames x symbols are collected self.connect(pda,blocks.head(gr.sizeof_gr_complex*dsubc, options.N*config.frame_data_blocks),demod) else: self.connect(pda,demod) self.connect(bitloading_src,(demod,1)) if(options.coding): ## Depuncturing if not options.nopunct: depuncturing = depuncture_ff(dsubc,0) frametrigger_bitmap_filter = blocks.vector_source_b([1,0],True) self.connect(bitloading_src,(depuncturing,1)) self.connect(dp_trig,(depuncturing,2)) ## Decoding chunkdivisor = int(numpy.ceil(config.frame_data_blocks/5.0)) print "Number of chunks at Viterbi decoder: ", chunkdivisor decoding = self._data_decoder = ofdm.viterbi_combined_fb(fo,dsubc,-1,-1,2,chunkdivisor,[-1,-1,-1,1,1,-1,1,1],ofdm.TRELLIS_EUCLIDEAN) if options.log and options.coding: log_to_file(self, decoding, "data/decoded.char") if not options.nopunct: log_to_file(self, depuncturing, "data/vit_in.float") if not options.nopunct: if options.interleave: self.connect(demod,deinterlv,depuncturing,decoding) else: self.connect(demod,depuncturing,decoding) else: self.connect(demod,decoding) self.connect(self.bitcount_src, multiply_const_ii(1./chunkdivisor), (decoding,1)) if options.scatterplot or options.scatter_plot_before_phase_tracking: if self.ideal2 is False: scatter_vec_elem = self._scatter_vec_elem = ofdm.vector_element(dsubc,40) scatter_s2v = self._scatter_s2v = blocks.stream_to_vector(gr.sizeof_gr_complex,config.frame_data_blocks) scatter_id_filt = skip(gr.sizeof_gr_complex*dsubc,config.frame_data_blocks) scatter_id_filt.skip_call(0) scatter_trig = [0]*config.frame_data_part scatter_trig[0] = 1 scatter_trig = blocks.vector_source_b(scatter_trig,True) self.connect(scatter_trig,(scatter_id_filt,1)) self.connect(scatter_vec_elem,scatter_s2v) if not options.scatter_plot_before_phase_tracking: print "Enabling Scatterplot for data subcarriers" self.connect(pda,scatter_id_filt,scatter_vec_elem) # Work on this #scatter_sink = ofdm.scatterplot_sink(dsubc) #self.connect(pda,scatter_sink) #self.connect(map_src,(scatter_sink,1)) #self.connect(dm_trig,(scatter_sink,2)) #print "Enabled scatterplot gui interface" self.zmq_probe_scatter = zeromq.pub_sink(gr.sizeof_gr_complex,config.frame_data_blocks, "tcp://*:5560") self.connect(scatter_s2v, blocks.keep_one_in_n(gr.sizeof_gr_complex*config.frame_data_blocks,20), self.zmq_probe_scatter) else: print "Enabling Scatterplot for data before phase tracking" inner_rx = inner_receiver.before_phase_tracking #scatter_sink2 = ofdm.scatterplot_sink(dsubc,"phase_tracking") op = copy.copy(options) op.enable_erasure_decision = False new_framesampler = ofdm_frame_sampler(op) self.connect( inner_rx, new_framesampler ) self.connect( orig_frame_start, (new_framesampler,1) ) new_ps_filter = pilot_subcarrier_filter() new_pb_filter = fbmc_pilot_block_filter() self.connect( (new_framesampler,1), (new_pb_filter,1) ) self.connect( new_framesampler, new_pb_filter, new_ps_filter, scatter_id_filt, scatter_vec_elem ) #self.connect( new_ps_filter, scatter_sink2 ) #self.connect( map_src, (scatter_sink2,1)) #self.connect( dm_trig, (scatter_sink2,2)) if options.log: if(options.coding): log_to_file(self, demod, "data/data_stream_out.float") else: data_f = gr.char_to_float() self.connect(demod,data_f) log_to_file(self, data_f, "data/data_stream_out.float") if options.sfo_feedback: used_id_bits = 8 rep_id_bits = config.data_subcarriers/used_id_bits seed(1) whitener_pn = [randint(0,1) for i in range(used_id_bits*rep_id_bits)] id_enc = ofdm.repetition_encoder_sb(used_id_bits,rep_id_bits,whitener_pn) self.connect( self.id_dec, id_enc ) id_mod = ofdm_bpsk_modulator(dsubc) self.connect( id_enc, id_mod ) id_mod_conj = gr.conjugate_cc(dsubc) self.connect( id_mod, id_mod_conj ) id_mult = blocks.multiply_vcc(dsubc) self.connect( id_bfilt, ( id_mult,0) ) self.connect( id_mod_conj, ( id_mult,1) ) # id_mult_avg = filter.single_pole_iir_filter_cc(0.01,dsubc) # self.connect( id_mult, id_mult_avg ) id_phase = gr.complex_to_arg(dsubc) self.connect( id_mult, id_phase ) log_to_file( self, id_phase, "data/id_phase.float" ) est=ofdm.LS_estimator_straight_slope(dsubc) self.connect(id_phase,est) slope=blocks.multiply_const_ff(1e6/2/3.14159265) self.connect( (est,0), slope ) log_to_file( self, slope, "data/slope.float" ) log_to_file( self, (est,1), "data/offset.float" ) # ------------------------------------------------------------------------ # # Display some information about the setup if config._verbose: self._print_verbage() ## debug logging ## if options.log: # log_to_file(self,self.ofdm_symbols,"data/unequalized_rx_ofdm_symbols.compl") # log_to_file(self,self.ofdm_symbols,"data/unequalized_rx_ofdm_symbols.float",mag=True) fftlen = 256 my_window = window.hamming(fftlen) #.blackmanharris(fftlen) rxs_sampler = vector_sampler(gr.sizeof_gr_complex,fftlen) rxs_sampler_vect = concatenate([[1],[0]*49]) rxs_trigger = blocks.vector_source_b(rxs_sampler_vect.tolist(),True) rxs_window = blocks.multiply_const_vcc(my_window) rxs_spectrum = gr.fft_vcc(fftlen,True,[],True) rxs_mag = gr.complex_to_mag(fftlen) rxs_avg = filter.single_pole_iir_filter_ff(0.01,fftlen) #rxs_logdb = blocks.nlog10_ff(20.0,fftlen,-20*log10(fftlen)) rxs_logdb = gr.kludge_copy( gr.sizeof_float * fftlen ) rxs_decimate_rate = gr.keep_one_in_n(gr.sizeof_float*fftlen,1) self.connect(rxs_trigger,(rxs_sampler,1)) self.connect(self.input,rxs_sampler,rxs_window, rxs_spectrum,rxs_mag,rxs_avg,rxs_logdb, rxs_decimate_rate) log_to_file( self, rxs_decimate_rate, "data/psd_input.float" ) #output branches self.publish_rx_performance_measure()
def __init__(self, options): gr.hier_block2.__init__(self, "transmit_path", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex)) common_options.defaults(options) config = self.config = station_configuration() config.data_subcarriers = options.subcarriers config.cp_length = options.cp_length config.frame_data_blocks = options.data_blocks config._verbose = options.verbose config.fft_length = options.fft_length config.dc_null = options.dc_null config.training_data = default_block_header(config.data_subcarriers, config.fft_length, config.dc_null, options) config.coding = options.coding config.bandwidth = options.bandwidth config.gui_frame_rate = options.gui_frame_rate config.fbmc = options.fbmc config.frame_id_blocks = 1 # FIXME # digital rms amplitude sent to USRP rms_amp = options.rms_amplitude self._options = copy.copy(options) config.block_length = config.fft_length + config.cp_length config.frame_data_part = config.frame_data_blocks + config.frame_id_blocks config.frame_length = config.frame_data_part + \ config.training_data.no_pilotsyms config.subcarriers = config.data_subcarriers + \ config.training_data.pilot_subcarriers config.virtual_subcarriers = config.fft_length - config.subcarriers - config.dc_null # default values if parameters not set if rms_amp is None: rms_amp = math.sqrt(config.subcarriers) config.rms_amplitude = rms_amp # check some bounds if config.fft_length < config.subcarriers: raise SystemError, "Subcarrier number must be less than FFT length" if config.fft_length < config.cp_length: raise SystemError, "Cyclic prefix length must be less than FFT length" ## shortcuts blen = config.block_length flen = config.frame_length dsubc = config.data_subcarriers vsubc = config.virtual_subcarriers # Adaptive Transmitter Concept used_id_bits = config.used_id_bits = 8 #TODO: no constant in source code rep_id_bits = config.rep_id_bits = config.data_subcarriers / used_id_bits #BPSK if config.data_subcarriers % used_id_bits <> 0: raise SystemError, "Data subcarriers need to be multiple of %d" % ( used_id_bits) # adapt OFDM frame rate and GUI display frame rate self.keep_frame_n = int( 1.0 / (config.frame_length * (config.cp_length + config.fft_length) / config.bandwidth) / config.gui_frame_rate) ## Allocation Control self.allocation_src = allocation_src( config.data_subcarriers, config.frame_data_blocks, config.coding, "tcp://*:3333", "tcp://" + options.rx_hostname + ":3322") if options.static_allocation: #DEBUG # how many bits per subcarrier if options.coding: mode = 1 # Coding mode 1-9 bitspermode = [0.5, 1, 1.5, 2, 3, 4, 4.5, 5, 6] # Information bits per mode modulbitspermode = [1, 2, 2, 4, 4, 6, 6, 6, 8] # Coding bits per mode bitcount_vec = [ (int)(config.data_subcarriers * config.frame_data_blocks * bitspermode[mode - 1]) ] modul_bitcount_vec = [ config.data_subcarriers * config.frame_data_blocks * modulbitspermode[mode - 1] ] bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1) modul_bitcount_src = blocks.vector_source_i( modul_bitcount_vec, True, 1) bitloading = mode else: bitloading = 1 bitcount_vec = [ config.data_subcarriers * config.frame_data_blocks * bitloading ] bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1) modul_bitcount_src = bitcount_src # id's for frames id_vec = range(0, 256) id_src = blocks.vector_source_s(id_vec, True, 1) # bitloading for ID symbol and then once for data symbols #bitloading_vec = [1]*dsubc+[0]*(dsubc/2)+[2]*(dsubc/2) #test_allocation = [bitloading]*(int)(config.data_subcarriers/8)+ [0]*(int)(config.data_subcarriers/4*3) + [bitloading]*(int)(config.data_subcarriers/8) #bitloading_vec = [1]*dsubc+[bitloading]*dsubc test_allocation = [bitloading] * dsubc bitloading_vec = [bitloading] * dsubc + test_allocation bitloading_src = blocks.vector_source_b(bitloading_vec, True, dsubc) # bitcount for frames #bitcount_vec = [config.data_subcarriers*config.frame_data_blocks*bitloading] bitcount_vec = [config.frame_data_blocks * sum(test_allocation)] bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1) # power loading, here same for all symbols #power_vec = [1]*(int)(config.data_subcarriers/8)+ [0]*(int)(config.data_subcarriers/4*3) + [1]*(int)(config.data_subcarriers/8) power_vec = [1] * config.data_subcarriers power_src = blocks.vector_source_f(power_vec, True, dsubc) # mux control stream to mux id and data bits mux_vec = [0] * dsubc + [1] * bitcount_vec[0] mux_ctrl = blocks.vector_source_b(mux_vec, True, 1) else: id_src = (self.allocation_src, 0) bitcount_src = (self.allocation_src, 4) bitloading_src = (self.allocation_src, 2) power_src = (self.allocation_src, 1) if options.coding: modul_bitcount_src = (self.allocation_src, 5) else: modul_bitcount_src = bitcount_src mux_ctrl = ofdm.tx_mux_ctrl(dsubc) self.connect(modul_bitcount_src, mux_ctrl) #Initial allocation self.allocation_src.set_allocation([2] * config.data_subcarriers, [1] * config.data_subcarriers) self.allocation_src.set_allocation_scheme(0) if options.benchmarking: self.allocation_src.set_allocation( [4] * config.data_subcarriers, [1] * config.data_subcarriers) if options.lab_special_case: self.allocation_src.set_allocation( [0] * (config.data_subcarriers / 4) + [2] * (config.data_subcarriers / 2) + [0] * (config.data_subcarriers / 4), [1] * config.data_subcarriers) if options.log: log_to_file(self, id_src, "data/id_src.short") log_to_file(self, bitcount_src, "data/bitcount_src.int") log_to_file(self, bitloading_src, "data/bitloading_src.char") log_to_file(self, power_src, "data/power_src.cmplx") ## GUI probe output zmq_probe_bitloading = zeromq.pub_sink(gr.sizeof_char, dsubc, "tcp://*:4445") # also skip ID symbol bitloading with keep_one_in_n (side effect) # factor 2 for bitloading because we have two vectors per frame, one for id symbol and one for all payload/data symbols # factor config.frame_data_part for power because there is one vector per ofdm symbol per frame self.connect(bitloading_src, blocks.keep_one_in_n(gr.sizeof_char * dsubc, 2 * 40), zmq_probe_bitloading) zmq_probe_power = zeromq.pub_sink(gr.sizeof_float, dsubc, "tcp://*:4444") #self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_gr_complex*dsubc,40), blocks.complex_to_real(dsubc), zmq_probe_power) self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_float * dsubc, 40), zmq_probe_power) ## Workaround to avoid periodic structure seed(1) whitener_pn = [ randint(0, 1) for i in range(used_id_bits * rep_id_bits) ] ## ID Encoder id_enc = self._id_encoder = repetition_encoder_sb( used_id_bits, rep_id_bits, whitener_pn) self.connect(id_src, id_enc) if options.log: id_enc_f = gr.char_to_float() self.connect(id_enc, id_enc_f) log_to_file(self, id_enc_f, "data/id_enc_out.float") ## Reference Data Source ber_ref_src = ber_reference_source(self._options) self.connect(id_src, (ber_ref_src, 0)) self.connect(bitcount_src, (ber_ref_src, 1)) if options.log: log_to_file(self, ber_ref_src, "data/ber_rec_src_tx.char") if options.log: log_to_file(self, btrig, "data/bitmap_trig.char") ## Bitmap Update Trigger for puncturing if not options.nopunct: bmaptrig_stream_puncturing = [ 1 ] + [0] * (config.frame_data_blocks / 2 - 1) btrig_puncturing = self._bitmap_trigger_puncturing = blocks.vector_source_b( bmaptrig_stream_puncturing, True) bmapsrc_stream_puncturing = [1] * dsubc + [2] * dsubc bsrc_puncturing = self._bitmap_src_puncturing = blocks.vector_source_b( bmapsrc_stream_puncturing, True, dsubc) if options.log and options.coding and not options.nopunct: log_to_file(self, btrig_puncturing, "data/bitmap_trig_puncturing.char") ## Frame Trigger ftrig_stream = [1] + [0] * (config.frame_data_part - 1) ftrig = self._frame_trigger = blocks.vector_source_b( ftrig_stream, True) ## Data Multiplexer # Input 0: control stream # Input 1: encoded ID stream # Inputs 2..n: data streams dmux = self._data_multiplexer = stream_controlled_mux_b() self.connect(mux_ctrl, (dmux, 0)) self.connect(id_enc, (dmux, 1)) if options.coding: fo = trellis.fsm(1, 2, [91, 121]) encoder = self._encoder = trellis.encoder_bb(fo, 0) unpack = self._unpack = blocks.unpack_k_bits_bb(2) self.connect(ber_ref_src, encoder, unpack) if options.interleave: int_object = trellis.interleaver(2000, 666) interlv = trellis.permutation(int_object.K(), int_object.INTER(), 1, gr.sizeof_char) if not options.nopunct: bmaptrig_stream_puncturing = [ 1 ] + [0] * (config.frame_data_blocks / 2 - 1) btrig_puncturing = self._bitmap_trigger_puncturing = blocks.vector_source_b( bmaptrig_stream_puncturing, True) puncturing = self._puncturing = puncture_bb( config.data_subcarriers) self.connect(bitloading_src, (puncturing, 1)) self.connect(self._bitmap_trigger_puncturing, (puncturing, 2)) self.connect(unpack, puncturing) last_block = puncturing if options.interleave: self.connect(last_block, interlv) last_block = interlv if options.benchmarking: self.connect(last_block, blocks.head(gr.sizeof_char, options.N), (dmux, 2)) else: self.connect(last_block, (dmux, 2)) else: if options.benchmarking: self.connect(unpack, blocks.head(gr.sizeof_char, options.N), (dmux, 2)) else: self.connect(unpack, (dmux, 2)) else: if options.benchmarking: self.connect(ber_ref_src, blocks.head(gr.sizeof_char, options.N), (dmux, 2)) else: self.connect(ber_ref_src, (dmux, 2)) if options.log: dmux_f = gr.char_to_float() self.connect(dmux, dmux_f) log_to_file(self, dmux_f, "data/dmux_out.float") ## Modulator mod = self._modulator = generic_mapper_bcv(config.data_subcarriers, config.coding, config.frame_data_part) self.connect(dmux, (mod, 0)) self.connect(bitloading_src, (mod, 1)) #log_to_file(self, mod, "data/mod_out.compl") if options.log: log_to_file(self, mod, "data/mod_out.compl") modi = blocks.complex_to_imag(config.data_subcarriers) modr = blocks.complex_to_real(config.data_subcarriers) self.connect(mod, modi) self.connect(mod, modr) log_to_file(self, modi, "data/mod_imag_out.float") log_to_file(self, modr, "data/mod_real_out.float") ## Power allocator pa = self._power_allocator = multiply_frame_fc(config.frame_data_part, config.data_subcarriers) self.connect(mod, (pa, 0)) self.connect(power_src, (pa, 1)) if options.log: log_to_file(self, pa, "data/pa_out.compl") # Standard Transmitter Parts ## Pilot subcarriers psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter() self.connect(pa, psubc) if options.log: log_to_file(self, psubc, "data/psubc_out.compl") ## Add virtual subcarriers if config.fft_length > config.subcarriers: vsubc = self._virtual_subcarrier_extender = \ vector_padding_dc_null(config.subcarriers, config.fft_length,config.dc_null) self.connect(psubc, vsubc) else: vsubc = self._virtual_subcarrier_extender = psubc if options.log: log_to_file(self, vsubc, "data/vsubc_out.compl") ## IFFT, no window, block shift ifft = self._ifft = fft_blocks.fft_vcc(config.fft_length, False, [], True) self.connect(vsubc, ifft) if options.log: log_to_file(self, ifft, "data/ifft_out.compl") ## Pilot blocks (preambles) pblocks = self._pilot_block_inserter = pilot_block_inserter(5, False) self.connect(ifft, pblocks) if options.log: log_to_file(self, pblocks, "data/pilot_block_ins_out.compl") ## Cyclic Prefix cp = self._cyclic_prefixer = cyclic_prefixer(config.fft_length, config.block_length) self.connect(pblocks, cp) lastblock = cp if options.log: log_to_file(self, cp, "data/cp_out.compl") #Digital Amplifier for resource allocation #if not options.coding: rep = blocks.repeat(gr.sizeof_gr_complex, config.frame_length * config.block_length) amp = blocks.multiply_cc() self.connect(lastblock, (amp, 0)) self.connect((self.allocation_src, 3), rep, (amp, 1)) lastblock = amp ## Digital Amplifier #amp = self._amplifier = gr.multiply_const_cc(1) amp = self._amplifier = ofdm.multiply_const_ccf(1.0) self.connect(lastblock, amp) self.set_rms_amplitude(rms_amp) if options.log: log_to_file(self, amp, "data/amp_tx_out.compl") ## Tx parameters bandwidth = options.bandwidth or 2e6 bits = 8 * config.data_subcarriers * config.frame_data_blocks # max. QAM256 samples_per_frame = config.frame_length * config.block_length tb = samples_per_frame / bandwidth # set dummy carrier frequency if none available due to baseband mode if (options.tx_freq is None): options.tx_freq = 0.0 self.tx_parameters = {'carrier_frequency':options.tx_freq/1e9,'fft_size':config.fft_length, 'cp_size':config.cp_length \ , 'subcarrier_spacing':options.bandwidth/config.fft_length/1e3 \ , 'data_subcarriers':config.data_subcarriers, 'bandwidth':options.bandwidth/1e6 \ , 'frame_length':config.frame_length \ , 'symbol_time':(config.cp_length + config.fft_length)/options.bandwidth*1e6, 'max_data_rate':(bits/tb)/1e6} ## Setup Output self.connect(amp, self) # Display some information about the setup if config._verbose: self._print_verbage()
def __init__(self): gr.top_block.__init__(self, "AM_transmit tutorial") Qt.QWidget.__init__(self) self.setWindowTitle("AM_transmit tutorial") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "am_transmit") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.volume = volume = 1.2 self.samp_rate = samp_rate = 768e3 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://127.0.0.1:50001", 100, False, -1) self._volume_range = Range(0, 10, 100e-3, 1.2, 200) self._volume_win = RangeWidget(self._volume_range, self.set_volume, "Audio_gain", "counter_slider", float) self.top_layout.addWidget(self._volume_win) self.qtgui_time_sink_x_0 = qtgui.time_sink_f( 4096, #size samp_rate, #samp_rate "", #name 2 #number of inputs ) self.qtgui_time_sink_x_0.set_update_time(0.10) self.qtgui_time_sink_x_0.set_y_axis(-1, 1) self.qtgui_time_sink_x_0.set_y_label("Amplitude", "") self.qtgui_time_sink_x_0.enable_tags(-1, True) self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.qtgui_time_sink_x_0.enable_autoscale(False) self.qtgui_time_sink_x_0.enable_grid(False) self.qtgui_time_sink_x_0.enable_control_panel(False) if not True: self.qtgui_time_sink_x_0.disable_legend() labels = ["", "", "", "", "", "", "", "", "", ""] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ "blue", "red", "green", "black", "cyan", "magenta", "yellow", "dark red", "dark green", "blue" ] styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(2): if len(labels[i]) == 0: self.qtgui_time_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_time_sink_x_0.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_win = sip.wrapinstance( self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_time_sink_x_0_win) self.blocks_repeat_0 = blocks.repeat(gr.sizeof_float * 1, 16) self.blocks_multiply_xx_0 = blocks.multiply_vff(1) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((1.2, )) self.blocks_file_source_0 = blocks.file_source( gr.sizeof_float * 1, "/home/hypersonic/Downloads/around_the_world-atc.wav", True) self.blocks_add_const_vxx_0 = blocks.add_const_vff((1, )) self.analog_sig_source_x_0 = analog.sig_source_f( samp_rate, analog.GR_COS_WAVE, 48e3, 500e-3, 0) ################################################## # Connections ################################################## self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_add_const_vxx_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.blocks_file_source_0, 0), (self.blocks_repeat_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_add_const_vxx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.qtgui_time_sink_x_0, 1)) self.connect((self.blocks_multiply_xx_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_repeat_0, 0), (self.blocks_multiply_const_vxx_0, 0))
def __init__(self): gr.top_block.__init__(self, "Example") Qt.QWidget.__init__(self) self.setWindowTitle("Example") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "example") try: if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"): self.restoreGeometry( self.settings.value("geometry").toByteArray()) else: self.restoreGeometry(self.settings.value("geometry")) except: pass ################################################## # Variables ################################################## self.samp_rate = samp_rate = 16000 self.frequency = frequency = 1000 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5556', 1000, False, -1) self.xmlrpc_server_0 = SimpleXMLRPCServer(('localhost', 8080), allow_none=True) self.xmlrpc_server_0.register_instance(self) self.xmlrpc_server_0_thread = threading.Thread( target=self.xmlrpc_server_0.serve_forever) self.xmlrpc_server_0_thread.daemon = True self.xmlrpc_server_0_thread.start() self.qtgui_time_sink_x_0 = qtgui.time_sink_c( 3000, #size samp_rate, #samp_rate "", #name 1 #number of inputs ) self.qtgui_time_sink_x_0.set_update_time(0.10) self.qtgui_time_sink_x_0.set_y_axis(-2.5, 2.5) self.qtgui_time_sink_x_0.set_y_label('Amplitude', "") self.qtgui_time_sink_x_0.enable_tags(True) self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.qtgui_time_sink_x_0.enable_autoscale(False) self.qtgui_time_sink_x_0.enable_grid(False) self.qtgui_time_sink_x_0.enable_axis_labels(True) self.qtgui_time_sink_x_0.enable_control_panel(False) self.qtgui_time_sink_x_0.enable_stem_plot(False) labels = ['', '', '', '', '', '', '', '', '', ''] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ 'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow', 'dark red', 'dark green', 'dark blue' ] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1] for i in range(2): if len(labels[i]) == 0: if (i % 2 == 0): self.qtgui_time_sink_x_0.set_line_label( i, "Re{{Data {0}}}".format(i / 2)) else: self.qtgui_time_sink_x_0.set_line_label( i, "Im{{Data {0}}}".format(i / 2)) else: self.qtgui_time_sink_x_0.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_win = sip.wrapinstance( self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_time_sink_x_0_win) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1, samp_rate, True) self.blocks_file_source_0 = blocks.file_source( gr.sizeof_gr_complex * 1, '/Users/stefanosperett/Documents/Research/FlaReSS/GitHub/OBC_Emulator/test.raw', True, 0, 0) self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL) ################################################## # Connections ################################################## self.connect((self.blocks_file_source_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.zeromq_pub_sink_0, 0))
def __init__(self, fD=10): gr.top_block.__init__(self, "Polar Coding with Coded Caching") ################################################## # Parameters ################################################## self.fD = fD ################################################## # Variables ################################################## self.snr_pld = snr_pld = 10 self.boost = boost = 15 self.snr = snr = 30 + 0 * (snr_pld + boost) self.pilot_symbols = pilot_symbols = (( 1, 1, 1, -1, ), ) self.pilot_carriers = pilot_carriers = (( -21, -7, 7, 21, ), ) self.payload_mod = payload_mod = digital.constellation_qpsk() self.packet_length_tag_key = packet_length_tag_key = "packet_len" self.occupied_carriers = occupied_carriers = ( range(-26, -21) + range(-20, -7) + range(-6, 0) + range(1, 7) + range(8, 21) + range(22, 27), ) self.length_tag_key = length_tag_key = "frame_len" self.header_mod = header_mod = digital.constellation_bpsk() self.fft_len = fft_len = 64 self.variance = variance = 1 / pow(10, snr / 10.0) self.sync_word2 = sync_word2 = [ 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, 0, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 0, 0, 0, 0, 0 ] self.sync_word1 = sync_word1 = [ 0., 0., 0., 0., 0., 0., 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 0., 0., 0., 0., 0. ] self.small_packet_len = small_packet_len = 52 self.samp_rate = samp_rate = int(1e6) self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe( fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 0, 1) self.id_user = id_user = 0 self.header_formatter = header_formatter = digital.packet_header_ofdm( occupied_carriers, n_syms=1, len_tag_key=packet_length_tag_key, frame_len_tag_key=length_tag_key, bits_per_header_sym=header_mod.bits_per_symbol(), bits_per_payload_sym=payload_mod.bits_per_symbol(), scramble_header=False) self.header_equalizer = header_equalizer = digital.ofdm_equalizer_simpledfe( fft_len, header_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 0, 1) self.Users = Users = 4 self.Nbfiles = Nbfiles = 20 self.NbStrgUsers = NbStrgUsers = 1 self.NbChuncks = NbChuncks = 200 self.N = N = 2048 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://*:5565', 100, False, -1) self.zeromq_pub_msg_sink_0_0_0 = zeromq.pub_msg_sink( 'tcp://*:5575', 10) self.zeromq_pub_msg_sink_0_0 = zeromq.pub_msg_sink('tcp://*:5555', 10) self.projectCACHE_polarEnc_b_0_0 = projectCACHE.polarEnc_b( N, Nbfiles, NbChuncks, NbStrgUsers, id_user, small_packet_len, packet_length_tag_key) self.projectCACHE_map_header_payload_bc_0 = projectCACHE.map_header_payload_bc( 4, 2, 'packet_len') self.fft_vxx_0_0 = fft.fft_vcc(fft_len, False, (()), True, 1) self.digital_packet_headergenerator_bb_0 = digital.packet_headergenerator_bb( header_formatter.formatter(), packet_length_tag_key) self.digital_ofdm_cyclic_prefixer_0 = digital.ofdm_cyclic_prefixer( fft_len, fft_len + fft_len / 4, 0, packet_length_tag_key) self.digital_ofdm_carrier_allocator_cvc_0 = digital.ofdm_carrier_allocator_cvc( fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (sync_word1, sync_word2), packet_length_tag_key) self.digital_chunks_to_symbols_xx_0_1 = digital.chunks_to_symbols_bc( (header_mod.points()), 1) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.complex_t, 'packet_len') self.blocks_tagged_stream_mux_0 = blocks.tagged_stream_mux( gr.sizeof_gr_complex * 1, packet_length_tag_key, 0) (self.blocks_tagged_stream_mux_0).set_max_output_buffer(8192) self.blocks_tag_gate_0 = blocks.tag_gate(gr.sizeof_gr_complex * 1, False) self.blocks_tag_gate_0.set_single_key("") self.blocks_multiply_const_vxx_1 = blocks.multiply_const_vcc((.05, )) ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.zeromq_pub_msg_sink_0_0_0, 'in')) self.msg_connect((self.projectCACHE_polarEnc_b_0_0, 'BER_INFO'), (self.zeromq_pub_msg_sink_0_0, 'in')) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_tag_gate_0, 0), (self.blocks_multiply_const_vxx_1, 0)) self.connect((self.blocks_tagged_stream_mux_0, 0), (self.digital_ofdm_carrier_allocator_cvc_0, 0)) self.connect((self.digital_chunks_to_symbols_xx_0_1, 0), (self.blocks_tagged_stream_mux_0, 0)) self.connect((self.digital_ofdm_carrier_allocator_cvc_0, 0), (self.fft_vxx_0_0, 0)) self.connect((self.digital_ofdm_cyclic_prefixer_0, 0), (self.blocks_tag_gate_0, 0)) self.connect((self.digital_ofdm_cyclic_prefixer_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.digital_packet_headergenerator_bb_0, 0), (self.digital_chunks_to_symbols_xx_0_1, 0)) self.connect((self.fft_vxx_0_0, 0), (self.digital_ofdm_cyclic_prefixer_0, 0)) self.connect((self.projectCACHE_map_header_payload_bc_0, 0), (self.blocks_tagged_stream_mux_0, 1)) self.connect((self.projectCACHE_polarEnc_b_0_0, 0), (self.digital_packet_headergenerator_bb_0, 0)) self.connect((self.projectCACHE_polarEnc_b_0_0, 0), (self.projectCACHE_map_header_payload_bc_0, 0))
def publish_rx_performance_measure(self): if self._rx_performance_measure_initialized(): return self.rx_performance_measure_initialized = True config = station_configuration() vlen = config.data_subcarriers vlen_sinr_sc = config.subcarriers if self.ideal2 is False: self.setup_ber_measurement() self.setup_snr_measurement() ber_mst = self._ber_measuring_tool if self._options.sinr_est: sinr_mst = self._sinr_measurement else: if self.ideal2 is False: snr_mst = self._snr_measurement if self.ideal is False and self.ideal2 is False: self.ctf = self.filter_ctf() self.zmq_probe_ctf = zeromq.pub_sink(gr.sizeof_float,config.data_subcarriers, "tcp://*:5559") self.connect(self.ctf, blocks.keep_one_in_n(gr.sizeof_float*config.data_subcarriers,20) ,self.zmq_probe_ctf) else: #self.zmq_probe_ctf = zeromq.pub_sink(gr.sizeof_float,config.subcarriers, "tcp://*:5559") self.connect(self.ctf,blocks.null_sink(gr.sizeof_float*config.subcarriers)) #self.rx_per_sink = rpsink = corba_rxinfo_sink("himalaya",config.ns_ip, # config.ns_port,vlen,config.rx_station_id) # print "BER img xfer" # self.connect(ber_mst,(rpsink,3)) # ## no sampling needed # 3. SNR if self.ideal2 is False: print "Normal BER measurement" trig_src = dynamic_trigger_ib(False) self.connect(self.bitcount_src,trig_src) ber_sampler = vector_sampler(gr.sizeof_float,1) self.connect(ber_mst,(ber_sampler,0)) self.connect(trig_src,(ber_sampler,1)) else: if(self._options.coding): demod = self._data_decoder else: demod = self._data_demodulator self.connect(self.bitcount_src,blocks.null_sink(gr.sizeof_int) ) self.connect(demod,blocks.null_sink(gr.sizeof_char)) if self._options.log: trig_src_float = gr.char_to_float() self.connect(trig_src,trig_src_float) log_to_file(self, trig_src_float , 'data/dynamic_trigger_out.float') if self._options.sinr_est is False and self.ideal2 is False: self.zmq_probe_ber = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5556") self.connect(ber_sampler,blocks.keep_one_in_n(gr.sizeof_float,20) ,self.zmq_probe_ber) if self.ideal2 is False: self.zmq_probe_snr = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5555") self.connect(snr_mst,blocks.keep_one_in_n(gr.sizeof_float,20) ,self.zmq_probe_snr)
def __init__(self): gr.top_block.__init__(self, "Top Block") Qt.QWidget.__init__(self) self.setWindowTitle("Top Block") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "top_block") try: if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"): self.restoreGeometry( self.settings.value("geometry").toByteArray()) else: self.restoreGeometry(self.settings.value("geometry")) except: pass ################################################## # Variables ################################################## self.variable_qtgui_range_1 = variable_qtgui_range_1 = 50 self.variable_qtgui_range_0 = variable_qtgui_range_0 = 50 self.freq = freq = 1e3 self.default_samp_rate = default_samp_rate = 5e6 self.carrier = carrier = 1e6 self.baud_rate = baud_rate = 9600 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_float, 1, 'tcp://127.0.0.1:50002', 100, False, -1) self._variable_qtgui_range_1_range = Range(0, 100, 1, 50, 200) self._variable_qtgui_range_1_win = RangeWidget( self._variable_qtgui_range_1_range, self.set_variable_qtgui_range_1, 'variable_qtgui_range_1', "counter_slider", float) self.top_grid_layout.addWidget(self._variable_qtgui_range_1_win) self._variable_qtgui_range_0_range = Range(0, 100, 1, 50, 200) self._variable_qtgui_range_0_win = RangeWidget( self._variable_qtgui_range_0_range, self.set_variable_qtgui_range_0, 'variable_qtgui_range_0', "counter_slider", float) self.top_grid_layout.addWidget(self._variable_qtgui_range_0_win) self.qtgui_time_sink_x_0 = qtgui.time_sink_f( 1024, #size default_samp_rate, #samp_rate "", #name 1 #number of inputs ) self.qtgui_time_sink_x_0.set_update_time(0.10) self.qtgui_time_sink_x_0.set_y_axis(-1, 1) self.qtgui_time_sink_x_0.set_y_label('Amplitude', "") self.qtgui_time_sink_x_0.enable_tags(True) self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.qtgui_time_sink_x_0.enable_autoscale(False) self.qtgui_time_sink_x_0.enable_grid(False) self.qtgui_time_sink_x_0.enable_axis_labels(True) self.qtgui_time_sink_x_0.enable_control_panel(False) self.qtgui_time_sink_x_0.enable_stem_plot(False) labels = [ 'Signal 1', 'Signal 2', 'Signal 3', 'Signal 4', 'Signal 5', 'Signal 6', 'Signal 7', 'Signal 8', 'Signal 9', 'Signal 10' ] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ 'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow', 'dark red', 'dark green', 'dark blue' ] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1] for i in range(1): if len(labels[i]) == 0: self.qtgui_time_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_time_sink_x_0.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_win = sip.wrapinstance( self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win) self.blocks_unpack_k_bits_bb_0 = blocks.unpack_k_bits_bb(8) self.blocks_uchar_to_float_0 = blocks.uchar_to_float() self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1, default_samp_rate, True) self.blocks_repeat_0 = blocks.repeat( gr.sizeof_char * 1, int((default_samp_rate / baud_rate) * 1.05)) self.blocks_multiply_xx_0 = blocks.multiply_vff(1) self.blocks_file_source_0 = blocks.file_source( gr.sizeof_char * 1, 'C:\\Users\\Avipe\\Desktop\\Year 4\\Final Project - Nano-Satelllite Transmitter\\GNU Radio Tests\\0.txt', True, 0, 0) self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL) self.analog_sig_source_x_0 = analog.sig_source_f( default_samp_rate, analog.GR_COS_WAVE, carrier, 1, 0, 0) ################################################## # Connections ################################################## self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_file_source_0, 0), (self.blocks_unpack_k_bits_bb_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_repeat_0, 0), (self.blocks_uchar_to_float_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_uchar_to_float_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.blocks_unpack_k_bits_bb_0, 0), (self.blocks_repeat_0, 0))
def __init__(self, options): gr.hier_block2.__init__( self, "fbmc_transmit_path", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex) ) common_options.defaults(options) config = self.config = station_configuration() config.data_subcarriers = options.subcarriers config.cp_length = 0 config.frame_data_blocks = options.data_blocks config._verbose = options.verbose config.fft_length = options.fft_length config.dc_null = options.dc_null config.training_data = default_block_header(config.data_subcarriers, config.fft_length, config.dc_null, options) config.coding = options.coding config.fbmc = options.fbmc config.adaptive_fbmc = options.adaptive_fbmc config.frame_id_blocks = 1 # FIXME # digital rms amplitude sent to USRP rms_amp = options.rms_amplitude self._options = copy.copy(options) config.block_length = config.fft_length + config.cp_length config.frame_data_part = config.frame_data_blocks + config.frame_id_blocks config.frame_length = config.training_data.fbmc_no_preambles + 2 * config.frame_data_part config.subcarriers = config.data_subcarriers + config.training_data.pilot_subcarriers config.virtual_subcarriers = config.fft_length - config.subcarriers - config.dc_null # default values if parameters not set if rms_amp is None: rms_amp = math.sqrt(config.subcarriers) config.rms_amplitude = rms_amp # check some bounds if config.fft_length < config.subcarriers: raise SystemError, "Subcarrier number must be less than FFT length" if config.fft_length < config.cp_length: raise SystemError, "Cyclic prefix length must be less than FFT length" ## shortcuts blen = config.block_length flen = config.frame_length dsubc = config.data_subcarriers vsubc = config.virtual_subcarriers # Adaptive Transmitter Concept used_id_bits = config.used_id_bits = 8 # TODO: no constant in source code rep_id_bits = config.rep_id_bits = config.data_subcarriers / used_id_bits # BPSK if config.data_subcarriers % used_id_bits <> 0: raise SystemError, "Data subcarriers need to be multiple of %d" % (used_id_bits) ## Allocation Control self.allocation_src = allocation_src( config.data_subcarriers, config.frame_data_blocks, config.coding, "tcp://*:3333", "tcp://" + options.rx_hostname + ":3322", ) if options.static_allocation: # DEBUG # how many bits per subcarrier if options.coding: mode = 1 # Coding mode 1-9 bitspermode = [0.5, 1, 1.5, 2, 3, 4, 4.5, 5, 6] # Information bits per mode modulbitspermode = [1, 2, 2, 4, 4, 6, 6, 6, 8] # Coding bits per mode bitcount_vec = [(int)(config.data_subcarriers * config.frame_data_blocks * bitspermode[mode - 1])] modul_bitcount_vec = [config.data_subcarriers * config.frame_data_blocks * modulbitspermode[mode - 1]] bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1) modul_bitcount_src = blocks.vector_source_i(modul_bitcount_vec, True, 1) bitloading = mode else: bitloading = 1 bitcount_vec = [config.data_subcarriers * config.frame_data_blocks * bitloading] bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1) modul_bitcount_src = bitcount_src # id's for frames id_vec = range(0, 256) id_src = blocks.vector_source_s(id_vec, True, 1) # bitloading for ID symbol and then once for data symbols # bitloading_vec = [1]*dsubc+[0]*(dsubc/2)+[2]*(dsubc/2) test_allocation = ( [bitloading] * (int)(config.data_subcarriers / 8) + [0] * (int)(config.data_subcarriers / 4 * 3) + [bitloading] * (int)(config.data_subcarriers / 8) ) # bitloading_vec = [1]*dsubc+[bitloading]*dsubc bitloading_vec = [1] * dsubc + test_allocation bitloading_src = blocks.vector_source_b(bitloading_vec, True, dsubc) # bitcount for frames # bitcount_vec = [config.data_subcarriers*config.frame_data_blocks*bitloading] bitcount_vec = [config.frame_data_blocks * sum(test_allocation)] bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1) # power loading, here same for all symbols power_vec = ( [1] * (int)(config.data_subcarriers / 8) + [0] * (int)(config.data_subcarriers / 4 * 3) + [1] * (int)(config.data_subcarriers / 8) ) power_src = blocks.vector_source_f(power_vec, True, dsubc) # mux control stream to mux id and data bits mux_vec = [0] * dsubc + [1] * bitcount_vec[0] mux_ctrl = blocks.vector_source_b(mux_vec, True, 1) else: id_src = (self.allocation_src, 0) bitcount_src = (self.allocation_src, 4) bitloading_src = (self.allocation_src, 2) power_src = (self.allocation_src, 1) if options.coding: modul_bitcount_src = (self.allocation_src, 5) else: modul_bitcount_src = bitcount_src mux_ctrl = ofdm.tx_mux_ctrl(dsubc) self.connect(modul_bitcount_src, mux_ctrl) # Initial allocation self.allocation_src.set_allocation([4] * config.data_subcarriers, [1] * config.data_subcarriers) if options.benchmarking: self.allocation_src.set_allocation([4] * config.data_subcarriers, [1] * config.data_subcarriers) if options.lab_special_case: self.allocation_src.set_allocation( [0] * (config.data_subcarriers / 4) + [2] * (config.data_subcarriers / 2) + [0] * (config.data_subcarriers / 4), [1] * config.data_subcarriers, ) if options.log: log_to_file(self, id_src, "data/id_src.short") log_to_file(self, bitcount_src, "data/bitcount_src.int") log_to_file(self, bitloading_src, "data/bitloading_src.char") log_to_file(self, power_src, "data/power_src.cmplx") ## GUI probe output zmq_probe_bitloading = zeromq.pub_sink(gr.sizeof_char, dsubc, "tcp://*:4445") # also skip ID symbol bitloading with keep_one_in_n (side effect) # factor 2 for bitloading because we have two vectors per frame, one for id symbol and one for all payload/data symbols # factor config.frame_data_part for power because there is one vector per ofdm symbol per frame self.connect(bitloading_src, blocks.keep_one_in_n(gr.sizeof_char * dsubc, 2 * 40), zmq_probe_bitloading) zmq_probe_power = zeromq.pub_sink(gr.sizeof_float, dsubc, "tcp://*:4444") # self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_gr_complex*dsubc,40), blocks.complex_to_real(dsubc), zmq_probe_power) self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_float * dsubc, 40), zmq_probe_power) ## Workaround to avoid periodic structure seed(1) whitener_pn = [randint(0, 1) for i in range(used_id_bits * rep_id_bits)] ## ID Encoder id_enc = self._id_encoder = repetition_encoder_sb(used_id_bits, rep_id_bits, whitener_pn) self.connect(id_src, id_enc) if options.log: id_enc_f = gr.char_to_float() self.connect(id_enc, id_enc_f) log_to_file(self, id_enc_f, "data/id_enc_out.float") ## Reference Data Source ber_ref_src = ber_reference_source(self._options) self.connect(id_src, (ber_ref_src, 0)) self.connect(bitcount_src, (ber_ref_src, 1)) if options.log: log_to_file(self, ber_ref_src, "data/ber_rec_src_tx.char") if options.log: log_to_file(self, btrig, "data/bitmap_trig.char") ## Frame Trigger ftrig_stream = [1] + [0] * (config.frame_data_part - 1) ftrig = self._frame_trigger = blocks.vector_source_b(ftrig_stream, True) ## Data Multiplexer # Input 0: control stream # Input 1: encoded ID stream # Inputs 2..n: data streams dmux = self._data_multiplexer = stream_controlled_mux_b() self.connect(mux_ctrl, (dmux, 0)) self.connect(id_enc, (dmux, 1)) if options.coding: fo = trellis.fsm(1, 2, [91, 121]) encoder = self._encoder = trellis.encoder_bb(fo, 0) unpack = self._unpack = blocks.unpack_k_bits_bb(2) self.connect(ber_ref_src, encoder, unpack) if options.interleave: int_object = trellis.interleaver(2000, 666) interlv = trellis.permutation(int_object.K(), int_object.INTER(), 1, gr.sizeof_char) if not options.nopunct: bmaptrig_stream_puncturing = [1] + [0] * (config.frame_data_blocks / 2 - 1) btrig_puncturing = self._bitmap_trigger_puncturing = blocks.vector_source_b( bmaptrig_stream_puncturing, True ) puncturing = self._puncturing = puncture_bb(config.data_subcarriers) self.connect(bitloading_src, (puncturing, 1)) self.connect(self._bitmap_trigger_puncturing, (puncturing, 2)) self.connect(unpack, puncturing) last_block = puncturing if options.interleave: self.connect(last_block, interlv) last_block = interlv if options.benchmarking: self.connect(last_block, blocks.head(gr.sizeof_char, options.N), (dmux, 2)) else: self.connect(last_block, (dmux, 2)) else: if options.benchmarking: self.connect(unpack, blocks.head(gr.sizeof_char, options.N), (dmux, 2)) else: self.connect(unpack, (dmux, 2)) else: if options.benchmarking: self.connect(ber_ref_src, blocks.head(gr.sizeof_char, options.N), (dmux, 2)) else: self.connect(ber_ref_src, (dmux, 2)) if options.log: dmux_f = gr.char_to_float() self.connect(dmux, dmux_f) log_to_file(self, dmux_f, "data/dmux_out.float") ## Modulator mod = self._modulator = generic_mapper_bcv(config.data_subcarriers, config.coding, config.frame_data_part) self.connect(dmux, (mod, 0)) self.connect(bitloading_src, (mod, 1)) if options.log: log_to_file(self, mod, "data/mod_out.compl") modi = blocks.complex_to_imag(config.data_subcarriers) modr = blocks.complex_to_real(config.data_subcarriers) self.connect(mod, modi) self.connect(mod, modr) log_to_file(self, modi, "data/mod_imag_out.float") log_to_file(self, modr, "data/mod_real_out.float") ## Power allocator pa = self._power_allocator = multiply_frame_fc(config.frame_data_part, config.data_subcarriers) self.connect(mod, (pa, 0)) self.connect(power_src, (pa, 1)) if options.log: log_to_file(self, pa, "data/pa_out.compl") if options.fbmc: psubc = pa else: psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter() self.connect(pa, psubc) if options.log: log_to_file(self, psubc, "data/psubc_out.compl") subcarriers = config.subcarriers # fbmc_pblocks_timing = self._fbmc_timing_pilot_block_inserter = fbmc_timing_pilot_block_inserter(5,False) oqam_prep = self._oqam_prep = fbmc_oqam_preprocessing_vcvc(config.subcarriers, 0, 0) self.connect(psubc, oqam_prep) fbmc_pblocks = self._fbmc_pilot_block_inserter = fbmc_pilot_block_inserter(5, False) self.connect(oqam_prep, fbmc_pblocks) # log_to_file(self, fbmc_pblocks, "data/fbmc_pblocks_out.compl") # fbmc_insert_pream = self._fbmc_insert_pream = fbmc_insert_preamble_vcvc(M, syms_per_frame, preamble) # log_to_file(self, oqam_prep, "data/oqam_prep.compl") # log_to_file(self, psubc, "data/psubc_out.compl") # fbmc_pblocks = fbmc_pblocks_timing # log_to_file(self, fbmc_pblocks, "data/fbmc_pblocks_out.compl") beta_mult = self._beta_mult = fbmc_beta_multiplier_vcvc(config.subcarriers, 4, 4 * config.fft_length - 1, 0) self.connect(fbmc_pblocks, beta_mult) log_to_file(self, beta_mult, "data/beta_mult.compl") ## Add virtual subcarriers if config.fft_length > subcarriers: vsubc = self._virtual_subcarrier_extender = vector_padding_dc_null( config.subcarriers, config.fft_length, config.dc_null ) self.connect(beta_mult, vsubc) else: vsubc = self._virtual_subcarrier_extender = beta_mult if options.log: log_to_file(self, vsubc, "data/vsubc_out.compl") ## IFFT, no window, block shift ifft = self._ifft = fft_blocks.fft_vcc(config.fft_length, False, [], True) self.connect(vsubc, ifft) if options.log: log_to_file(self, ifft, "data/ifft_out.compl") # FBMC separate stream + filterbanks separate_oqam = self._separate_oqam = fbmc_separate_vcvc(config.fft_length, 2) poly_netw_1 = self._poly_netw_1 = fbmc_polyphase_network_vcvc( config.fft_length, 4, 4 * config.fft_length - 1, False ) poly_netw_2 = self._poly_netw_2 = fbmc_polyphase_network_vcvc( config.fft_length, 4, 4 * config.fft_length - 1, False ) overlap_p2s = self._overlap_p2s = fbmc_overlapping_parallel_to_serial_vcc(config.fft_length) self.connect(ifft, (separate_oqam, 0), poly_netw_1) self.connect((separate_oqam, 1), poly_netw_2) self.connect(poly_netw_1, (overlap_p2s, 0)) self.connect(poly_netw_2, (overlap_p2s, 1)) ## Pilot blocks (preambles) # pblocks = self._pilot_block_inserter = pilot_block_inserter2(5,False) # self.connect( overlap_p2s, blocks.stream_to_vector(gr.sizeof_gr_complex,config.fft_length/2), pblocks ) # log_to_file(self, pblocks, "data/fbmc_pilot_block_ins_out.compl") if options.log: log_to_file(self, pblocks, "data/pilot_block_ins_out.compl") ## Cyclic Prefix # cp = self._cyclic_prefixer = cyclic_prefixer(config.fft_length, # config.block_length) # cp= blocks.vector_to_stream(gr.sizeof_gr_complex, config.fft_length/2) # self.connect(pblocks, cp ) # self.connect( overlap_p2s,blocks.stream_to_vector(gr.sizeof_gr_complex,config.fft_length/2), cp ) lastblock = overlap_p2s if options.log: log_to_file(self, overlap_p2s, "data/overlap_p2s_out.compl") # Digital Amplifier for resource allocation if config.adaptive_fbmc: rep = blocks.repeat(gr.sizeof_gr_complex, config.frame_length * config.block_length) amp = blocks.multiply_cc() self.connect(lastblock, (amp, 0)) self.connect((self.allocation_src, 3), rep, (amp, 1)) lastblock = amp else: self.connect((self.allocation_src, 3), blocks.null_sink(gr.sizeof_gr_complex)) ## Digital Amplifier # amp = self._amplifier = gr.multiply_const_cc(1) amp = self._amplifier = ofdm.multiply_const_ccf(1.0) self.connect(lastblock, amp) self.set_rms_amplitude(rms_amp) # log_to_file(self, amp, "data/amp_tx_out.compl") if options.log: log_to_file(self, amp, "data/amp_tx_out.compl") ## Tx parameters bandwidth = options.bandwidth or 2e6 bits = 8 * config.data_subcarriers * config.frame_data_blocks # max. QAM256 samples_per_frame = config.frame_length * config.block_length tb = samples_per_frame / bandwidth # set dummy carrier frequency if none available due to baseband mode if options.tx_freq is None: options.tx_freq = 0.0 self.tx_parameters = { "carrier_frequency": options.tx_freq / 1e9, "fft_size": config.fft_length, "cp_size": config.cp_length, "subcarrier_spacing": options.bandwidth / config.fft_length / 1e3, "data_subcarriers": config.data_subcarriers, "bandwidth": options.bandwidth / 1e6, "frame_length": config.frame_length, "symbol_time": (config.cp_length + config.fft_length) / options.bandwidth * 1e6, "max_data_rate": (bits / tb) / 1e6, } ## Setup Output self.connect(amp, self) # Display some information about the setup if config._verbose: self._print_verbage()
def __init__(self, input_port_num="55555", output_port_num="55556", rx_bw=1e6, rx_freq=2.2e9, rx_gain=0.8, serial_num="31C9237", tx_bw=1e6, tx_freq=2.2e9, tx_gain=0.8): gr.top_block.__init__(self, "tranceiver_ofdm_usrp_RS") ################################################## # Parameters ################################################## self.input_port_num = input_port_num self.output_port_num = output_port_num self.rx_bw = rx_bw self.rx_freq = rx_freq self.rx_gain = rx_gain self.serial_num = serial_num self.tx_bw = tx_bw self.tx_freq = tx_freq self.tx_gain = tx_gain ################################################## # Variables ################################################## self.packet_len = packet_len = 200 self.pilot_symbols = pilot_symbols = (( 1, 1, 1, -1, ), ) self.pilot_carriers = pilot_carriers = (( -21, -7, 7, 21, ), ) self.payload_mod = payload_mod = digital.constellation_qpsk() self.packet_length_tag_key = packet_length_tag_key = "packet_len" self.occupied_carriers = occupied_carriers = ( list(range(-26, -21)) + list(range(-20, -7)) + list(range(-6, 0)) + list(range(1, 7)) + list(range(8, 21)) + list(range(22, 27)), ) self.n = n = 255 self.length_tag_key = length_tag_key = "frame_len" self.k = k = packet_len + 4 self.header_mod = header_mod = digital.constellation_bpsk() self.fft_len = fft_len = 64 self.blocks_RS = blocks_RS = 1 self.t = t = int((n * blocks_RS - k) / 2) self.sync_word2 = sync_word2 = [ 0j, 0j, 0j, 0j, 0j, 0j, (-1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), (1 + 0j), (1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), (1 + 0j), (-1 + 0j), (1 + 0j), (1 + 0j), (1 + 0j), (1 + 0j), (1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), (1 + 0j), (-1 + 0j), (-1 + 0j), (1 + 0j), (-1 + 0j), 0j, (1 + 0j), (-1 + 0j), (1 + 0j), (1 + 0j), (1 + 0j), (-1 + 0j), (1 + 0j), (1 + 0j), (1 + 0j), (-1 + 0j), (1 + 0j), (1 + 0j), (1 + 0j), (1 + 0j), (-1 + 0j), (1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), (1 + 0j), (-1 + 0j), (1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), (-1 + 0j), 0j, 0j, 0j, 0j, 0j ] self.sync_word1 = sync_word1 = [ 0., 0., 0., 0., 0., 0., 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., -1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., -1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 1.41421356, 0., 0., 0., 0., 0., 0. ] self.samp_rate = samp_rate = 10000 self.rolloff = rolloff = 0 self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe( fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 1) self.out_buf_size = out_buf_size = 0 self.header_formatter = header_formatter = digital.packet_header_ofdm( occupied_carriers, n_syms=1, len_tag_key=packet_length_tag_key, frame_len_tag_key=length_tag_key, bits_per_header_sym=header_mod.bits_per_symbol(), bits_per_payload_sym=payload_mod.bits_per_symbol(), scramble_header=False) self.header_equalizer = header_equalizer = digital.ofdm_equalizer_simpledfe( fft_len, header_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols) self.hdr_format = hdr_format = digital.header_format_ofdm( occupied_carriers, 1, length_tag_key, ) ################################################## # Blocks ################################################## self.zeromq_sub_source_0 = zeromq.sub_source( gr.sizeof_char, 1, "tcp://127.0.0.1:" + input_port_num, 100, False, -1) self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_char, 1, "tcp://127.0.0.1:55556", 100, False, -1) self.uhd_usrp_source_0 = uhd.usrp_source( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", args='', channels=list(range(0, 1)), ), ) self.uhd_usrp_source_0.set_center_freq(rx_freq, 0) self.uhd_usrp_source_0.set_normalized_gain(rx_gain, 0) self.uhd_usrp_source_0.set_antenna('RX2', 0) self.uhd_usrp_source_0.set_samp_rate(rx_bw) self.uhd_usrp_source_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS) self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(("", "")), uhd.stream_args( cpu_format="fc32", args='', channels=list(range(0, 1)), ), packet_length_tag_key, ) self.uhd_usrp_sink_0.set_center_freq(tx_freq, 0) self.uhd_usrp_sink_0.set_normalized_gain(tx_gain, 0) self.uhd_usrp_sink_0.set_antenna('TX/RX', 0) self.uhd_usrp_sink_0.set_samp_rate(tx_bw) self.uhd_usrp_sink_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS) self.foo_packet_pad2_0 = foo.packet_pad2(False, False, 0.001, 100, 1000) self.fft_vxx_1 = fft.fft_vcc(fft_len, True, (), True, 1) self.fft_vxx_0_0 = fft.fft_vcc(fft_len, False, (), True, 1) self.fft_vxx_0 = fft.fft_vcc(fft_len, True, (), True, 1) self.dtv_dvbt_reed_solomon_enc_0 = dtv.dvbt_reed_solomon_enc( 2, 8, 0x11d, n, k, t, 0, blocks_RS) self.dtv_dvbt_reed_solomon_dec_0 = dtv.dvbt_reed_solomon_dec( 2, 8, 0x11d, n, k, t, 0, 1) self.digital_protocol_formatter_bb_0 = digital.protocol_formatter_bb( hdr_format, packet_length_tag_key) self.digital_packet_headerparser_b_0 = digital.packet_headerparser_b( header_formatter.base()) self.digital_ofdm_sync_sc_cfb_0 = digital.ofdm_sync_sc_cfb( fft_len, fft_len // 4, False, 0.9) self.digital_ofdm_serializer_vcc_payload = digital.ofdm_serializer_vcc( fft_len, occupied_carriers, length_tag_key, packet_length_tag_key, 1, '', True) self.digital_ofdm_serializer_vcc_header = digital.ofdm_serializer_vcc( fft_len, occupied_carriers, length_tag_key, '', 0, '', True) self.digital_ofdm_frame_equalizer_vcvc_1 = digital.ofdm_frame_equalizer_vcvc( payload_equalizer.base(), fft_len // 4, length_tag_key, True, 0) self.digital_ofdm_frame_equalizer_vcvc_0 = digital.ofdm_frame_equalizer_vcvc( header_equalizer.base(), fft_len // 4, length_tag_key, True, 1) self.digital_ofdm_cyclic_prefixer_0 = digital.ofdm_cyclic_prefixer( fft_len, fft_len + fft_len // 4, rolloff, packet_length_tag_key) self.digital_ofdm_chanest_vcvc_0 = digital.ofdm_chanest_vcvc( sync_word1, sync_word2, 1, 0, 3, False) self.digital_ofdm_carrier_allocator_cvc_0 = digital.ofdm_carrier_allocator_cvc( fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (sync_word1, sync_word2), packet_length_tag_key, True) self.digital_header_payload_demux_0 = digital.header_payload_demux( 3, fft_len, fft_len // 4, length_tag_key, "", True, gr.sizeof_gr_complex, "rx_time", samp_rate, (), 0) self.digital_crc32_bb_0_0 = digital.crc32_bb(False, packet_length_tag_key, True) self.digital_crc32_bb_0 = digital.crc32_bb(True, packet_length_tag_key, True) self.digital_constellation_decoder_cb_1 = digital.constellation_decoder_cb( payload_mod.base()) self.digital_constellation_decoder_cb_0 = digital.constellation_decoder_cb( header_mod.base()) self.digital_chunks_to_symbols_xx_0_0 = digital.chunks_to_symbols_bc( payload_mod.points(), 1) self.digital_chunks_to_symbols_xx_0 = digital.chunks_to_symbols_bc( header_mod.points(), 1) self.blocks_vector_to_stream_0_0 = blocks.vector_to_stream( gr.sizeof_char * 1, k) self.blocks_vector_to_stream_0 = blocks.vector_to_stream( gr.sizeof_char * 1, n) self.blocks_tagged_stream_mux_0 = blocks.tagged_stream_mux( gr.sizeof_gr_complex * 1, packet_length_tag_key, 0) self.blocks_tagged_stream_multiply_length_0_0 = blocks.tagged_stream_multiply_length( gr.sizeof_char * 1, packet_length_tag_key, k / n) self.blocks_tagged_stream_multiply_length_0 = blocks.tagged_stream_multiply_length( gr.sizeof_char * 1, packet_length_tag_key, n / k) self.blocks_stream_to_vector_1 = blocks.stream_to_vector( gr.sizeof_char * 1, k) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_char * 1, n) self.blocks_stream_to_tagged_stream_0_0_0 = blocks.stream_to_tagged_stream( gr.sizeof_char, 1, k, packet_length_tag_key) self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream( gr.sizeof_char, 1, packet_len, packet_length_tag_key) self.blocks_repack_bits_bb_0_1 = blocks.repack_bits_bb( 8, payload_mod.bits_per_symbol(), packet_length_tag_key, False, gr.GR_LSB_FIRST) self.blocks_repack_bits_bb_0_0 = blocks.repack_bits_bb( 8, 1, packet_length_tag_key, False, gr.GR_LSB_FIRST) self.blocks_repack_bits_bb_0 = blocks.repack_bits_bb( payload_mod.bits_per_symbol(), 8, packet_length_tag_key, True, gr.GR_LSB_FIRST) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_cc(0.05) self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex * 1, fft_len + fft_len // 4) self.analog_frequency_modulator_fc_0 = analog.frequency_modulator_fc( -2.0 / fft_len) ################################################## # Connections ################################################## self.msg_connect((self.digital_packet_headerparser_b_0, 'header_data'), (self.digital_header_payload_demux_0, 'header_data')) self.connect((self.analog_frequency_modulator_fc_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.blocks_delay_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.foo_packet_pad2_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.digital_header_payload_demux_0, 0)) self.connect((self.blocks_repack_bits_bb_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_repack_bits_bb_0_0, 0), (self.digital_chunks_to_symbols_xx_0, 0)) self.connect((self.blocks_repack_bits_bb_0_1, 0), (self.digital_chunks_to_symbols_xx_0_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.digital_crc32_bb_0_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0_0_0, 0), (self.blocks_tagged_stream_multiply_length_0_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.dtv_dvbt_reed_solomon_dec_0, 0)) self.connect((self.blocks_stream_to_vector_1, 0), (self.dtv_dvbt_reed_solomon_enc_0, 0)) self.connect((self.blocks_tagged_stream_multiply_length_0, 0), (self.blocks_repack_bits_bb_0_1, 0)) self.connect((self.blocks_tagged_stream_multiply_length_0, 0), (self.digital_protocol_formatter_bb_0, 0)) self.connect((self.blocks_tagged_stream_multiply_length_0_0, 0), (self.digital_crc32_bb_0, 0)) self.connect((self.blocks_tagged_stream_mux_0, 0), (self.digital_ofdm_carrier_allocator_cvc_0, 0)) self.connect((self.blocks_vector_to_stream_0, 0), (self.blocks_tagged_stream_multiply_length_0, 0)) self.connect((self.blocks_vector_to_stream_0_0, 0), (self.blocks_stream_to_tagged_stream_0_0_0, 0)) self.connect((self.digital_chunks_to_symbols_xx_0, 0), (self.blocks_tagged_stream_mux_0, 0)) self.connect((self.digital_chunks_to_symbols_xx_0_0, 0), (self.blocks_tagged_stream_mux_0, 1)) self.connect((self.digital_constellation_decoder_cb_0, 0), (self.digital_packet_headerparser_b_0, 0)) self.connect((self.digital_constellation_decoder_cb_1, 0), (self.blocks_repack_bits_bb_0, 0)) self.connect((self.digital_crc32_bb_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.digital_crc32_bb_0_0, 0), (self.blocks_stream_to_vector_1, 0)) self.connect((self.digital_header_payload_demux_0, 0), (self.fft_vxx_0, 0)) self.connect((self.digital_header_payload_demux_0, 1), (self.fft_vxx_1, 0)) self.connect((self.digital_ofdm_carrier_allocator_cvc_0, 0), (self.fft_vxx_0_0, 0)) self.connect((self.digital_ofdm_chanest_vcvc_0, 0), (self.digital_ofdm_frame_equalizer_vcvc_0, 0)) self.connect((self.digital_ofdm_cyclic_prefixer_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.digital_ofdm_frame_equalizer_vcvc_0, 0), (self.digital_ofdm_serializer_vcc_header, 0)) self.connect((self.digital_ofdm_frame_equalizer_vcvc_1, 0), (self.digital_ofdm_serializer_vcc_payload, 0)) self.connect((self.digital_ofdm_serializer_vcc_header, 0), (self.digital_constellation_decoder_cb_0, 0)) self.connect((self.digital_ofdm_serializer_vcc_payload, 0), (self.digital_constellation_decoder_cb_1, 0)) self.connect((self.digital_ofdm_sync_sc_cfb_0, 0), (self.analog_frequency_modulator_fc_0, 0)) self.connect((self.digital_ofdm_sync_sc_cfb_0, 1), (self.digital_header_payload_demux_0, 1)) self.connect((self.digital_protocol_formatter_bb_0, 0), (self.blocks_repack_bits_bb_0_0, 0)) self.connect((self.dtv_dvbt_reed_solomon_dec_0, 0), (self.blocks_vector_to_stream_0_0, 0)) self.connect((self.dtv_dvbt_reed_solomon_enc_0, 0), (self.blocks_vector_to_stream_0, 0)) self.connect((self.fft_vxx_0, 0), (self.digital_ofdm_chanest_vcvc_0, 0)) self.connect((self.fft_vxx_0_0, 0), (self.digital_ofdm_cyclic_prefixer_0, 0)) self.connect((self.fft_vxx_1, 0), (self.digital_ofdm_frame_equalizer_vcvc_1, 0)) self.connect((self.foo_packet_pad2_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.blocks_delay_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.digital_ofdm_sync_sc_cfb_0, 0)) self.connect((self.zeromq_sub_source_0, 0), (self.blocks_stream_to_tagged_stream_0, 0))
def __init__(self): gr.top_block.__init__(self, "OPS-SAT UHF RX") Qt.QWidget.__init__(self) self.setWindowTitle("OPS-SAT UHF RX") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "os_uhf_rx") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.signal_freq = signal_freq = 437.2e6 self.true_freq = true_freq = signal_freq self.samp_rate = samp_rate = 200e3 self.offset_freq = offset_freq = -40e3 self.doppler_freq = doppler_freq = true_freq - signal_freq self.variable_low_pass_filter_taps_0 = variable_low_pass_filter_taps_0 = firdes.low_pass( 1.0, samp_rate, 25000, 1000, firdes.WIN_HAMMING, 6.76) self.samp_rate_down = samp_rate_down = 57.6e3 self.freq_tuned = freq_tuned = offset_freq - doppler_freq self.Squelch = Squelch = -130 ################################################## # Blocks ################################################## self._Squelch_range = Range(-180, -50, 1, -130, 200) self._Squelch_win = RangeWidget(self._Squelch_range, self.set_Squelch, "Squelch", "counter_slider", float) self.top_grid_layout.addWidget(self._Squelch_win) self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_gr_complex, 1, 'tcp://127.0.0.1:5555', 100, False, -1) self.rational_resampler_xxx_0 = filter.rational_resampler_ccc( interpolation=int(samp_rate_down), decimation=int(samp_rate), taps=None, fractional_bw=None, ) self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c( 1024, #size firdes.WIN_BLACKMAN_hARRIS, #wintype 0, #fc samp_rate, #bw "", #name 2 #number of inputs ) self.qtgui_freq_sink_x_0.set_update_time(0.10) self.qtgui_freq_sink_x_0.set_y_axis(-140, 10) self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB') self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "") self.qtgui_freq_sink_x_0.enable_autoscale(False) self.qtgui_freq_sink_x_0.enable_grid(True) self.qtgui_freq_sink_x_0.set_fft_average(0.1) self.qtgui_freq_sink_x_0.enable_axis_labels(True) self.qtgui_freq_sink_x_0.enable_control_panel(False) if not True: self.qtgui_freq_sink_x_0.disable_legend() if "complex" == "float" or "complex" == "msg_float": self.qtgui_freq_sink_x_0.set_plot_pos_half(not True) labels = ['', '', '', '', '', '', '', '', '', ''] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ "blue", "red", "green", "black", "cyan", "magenta", "yellow", "dark red", "dark green", "dark blue" ] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(2): if len(labels[i]) == 0: self.qtgui_freq_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_freq_sink_x_0.set_line_label(i, labels[i]) self.qtgui_freq_sink_x_0.set_line_width(i, widths[i]) self.qtgui_freq_sink_x_0.set_line_color(i, colors[i]) self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_freq_sink_x_0_win = sip.wrapinstance( self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win) self.gpredict_doppler_1 = gpredict.doppler(self.set_true_freq, "localhost", 4532, False) self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc( 1, (variable_low_pass_filter_taps_0), -freq_tuned, samp_rate) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1, samp_rate, True) self.blocks_file_source_0 = blocks.file_source( gr.sizeof_gr_complex * 1, '/home/osops/tom/dev/workspace/osat_437.16M_200k_beacon_mode6.cf32', True) self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL) self.analog_simple_squelch_cc_0 = analog.simple_squelch_cc(Squelch, 1) self.analog_sig_source_x_0 = analog.sig_source_c( samp_rate, analog.GR_COS_WAVE, -freq_tuned, 1, 0) ################################################## # Connections ################################################## self.connect((self.analog_sig_source_x_0, 0), (self.qtgui_freq_sink_x_0, 0)) self.connect((self.analog_simple_squelch_cc_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0)) self.connect((self.analog_simple_squelch_cc_0, 0), (self.qtgui_freq_sink_x_0, 1)) self.connect((self.blocks_file_source_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.analog_simple_squelch_cc_0, 0)) self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.rational_resampler_xxx_0, 0)) self.connect((self.rational_resampler_xxx_0, 0), (self.zeromq_pub_sink_0, 0))
def __init__(self, fc=629e6, gaindB=23, samp_rate=12.5e6): gr.top_block.__init__(self, "Usrp 2Chrx Save") ################################################## # Parameters ################################################## self.fc = fc self.gaindB = gaindB self.samp_rate = samp_rate ################################################## # Variables ################################################## self.chans = chans = 4096 ################################################## # Blocks ################################################## self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_float, chans, 'tcp://*:50001', 100, False, -1) self.uhd_usrp_source = uhd.usrp_source( ",".join(("addr=10.11.2.61", "master_clock_rate=250e6")), uhd.stream_args( cpu_format="fc32", otw_format="sc16", args='', channels=list(range(0,2)), ), ) self.uhd_usrp_source.set_subdev_spec('A:0 B:0', 0) self.uhd_usrp_source.set_time_source('external', 0) self.uhd_usrp_source.set_clock_source('external', 0) self.uhd_usrp_source.set_center_freq(fc, 0) self.uhd_usrp_source.set_gain(gaindB, 0) self.uhd_usrp_source.set_antenna('TX/RX', 0) self.uhd_usrp_source.set_center_freq(fc, 1) self.uhd_usrp_source.set_gain(gaindB, 1) self.uhd_usrp_source.set_antenna('TX/RX', 1) self.uhd_usrp_source.set_samp_rate(samp_rate) self.uhd_usrp_source.set_time_unknown_pps(uhd.time_spec()) self.fft_vxx_0_0 = fft.fft_vcc(chans, True, window.blackmanharris(chans), True, 1) self.fft_vxx_0 = fft.fft_vcc(chans, True, window.blackmanharris(chans), True, 1) self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, chans) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, chans) self.blocks_interleave_0 = blocks.interleave(gr.sizeof_float*chans, 1) self.blocks_integrate_xx_0_0 = blocks.integrate_ff(1000, chans) self.blocks_integrate_xx_0 = blocks.integrate_ff(1000, chans) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, 'test.cfile', False) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_complex_to_mag_squared_0_0 = blocks.complex_to_mag_squared(chans) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(chans) ################################################## # Connections ################################################## self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0)) self.connect((self.blocks_complex_to_mag_squared_0_0, 0), (self.blocks_integrate_xx_0_0, 0)) self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_interleave_0, 0)) self.connect((self.blocks_integrate_xx_0_0, 0), (self.blocks_interleave_0, 1)) self.connect((self.blocks_interleave_0, 0), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.fft_vxx_0_0, 0)) self.connect((self.blocks_stream_to_vector_0_0, 0), (self.fft_vxx_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) self.connect((self.fft_vxx_0_0, 0), (self.blocks_complex_to_mag_squared_0_0, 0)) self.connect((self.uhd_usrp_source, 0), (self.blocks_file_sink_0, 0)) self.connect((self.uhd_usrp_source, 1), (self.blocks_stream_to_vector_0, 0)) self.connect((self.uhd_usrp_source, 0), (self.blocks_stream_to_vector_0_0, 0))
def __init__(self, options): gr.top_block.__init__(self) self.options = options # create scheduler for retuning self.scheduler = sched.scheduler(time.time, time.sleep) self.transmit_flag = True # will be set to false after end of constructor self.run_loop = False coordinates_string = options.coordinates_m.split(",") self.coordinates = (float(coordinates_string[0]),float(coordinates_string[1])) # socket addresses rpc_port = 6665 + options.id_rx rpc_adr = "tcp://*:" + str(rpc_port) fusion_center_adr = "tcp://" + options.fusion_center + ":6665" probe_port = 5555 + options.id_rx probe_adr = "tcp://*:" + str(probe_port) # blocks self.zmq_probe = zeromq.pub_sink(gr.sizeof_gr_complex, 1, probe_adr, 10, True) self.tag_debug = blocks.tag_debug(gr.sizeof_gr_complex*1, "", ""); self.tag_debug.set_display(True) if self.options.serial != "": if self.options.mcr != 0: self.usrp_source = uhd.usrp_source( "serial == " + self.options.serial + ",master_clock_rate == " + str(self.options.mcr), uhd.stream_args( cpu_format="fc32", channels=range(1), ), False ) else: self.usrp_source = uhd.usrp_source( "serial == " + self.options.serial, uhd.stream_args( cpu_format="fc32", channels=range(1), ), False ) else: if self.options.mcr != 0: self.usrp_source = uhd.usrp_source( "master_clock_rate == " + str(self.options.mcr), uhd.stream_args( cpu_format="fc32", channels=range(1), ), False ) else: self.usrp_source = uhd.usrp_source( "", uhd.stream_args( cpu_format="fc32", channels=range(1), ), False ) print "passed constructor" self.gps = options.gps if self.gps != "internal": print "Using " + self.gps self.usrp_source.set_clock_source("external", 0) self.usrp_source.set_time_source("external", 0) if self.gps == "ltelite": self.ser = serial.Serial("/dev/ttyUSB0", 38400, timeout = 1) self.nmea_external = "" self.nmea_external_lock = threading.Lock() threading.Thread(target = self.poll_lte_lite).start() elif self.gps == "leam8f": self.ser = serial.Serial("/dev/ttyACM0", 38400, timeout = 1) self.nmea_external = "" self.nmea_external_lock = threading.Lock() threading.Thread(target = self.poll_lea_m8f).start() if self.options.log: file_name = "../log/receiver_" + time.strftime("%d_%m_%y-%H:%M:%S") + ".txt" self.file_sink = blocks.file_sink(gr.sizeof_gr_complex*1, file_name, True) self.file_sink.set_unbuffered(False) # call constructor at fist to secure synchronization self.tx_bpsk_0 = tx_bpsk( serial = self.options.serial, mcr= self.options.mcr, gps = self.gps, bandwidth=5000000, center_freq=2510000000, gain=89.5, num_pulses=20000, pulse_length=1, samp_rate=20000000, ) # connects self.connect(self.tx_bpsk_0) #self.connect(self.usrp_source, self.s_to_v, self.zmq_probe) self.connect(self.usrp_source, self.zmq_probe) self.connect(self.usrp_source, self.tag_debug) if self.options.log: self.connect(self.usrp_source, self.file_sink) # ZeroMQ self.rpc_manager = rpc_manager_local.rpc_manager() self.rpc_manager.set_reply_socket(rpc_adr) self.rpc_manager.set_request_socket(fusion_center_adr) self.rpc_manager.add_interface("set_run_loop",self.set_run_loop) self.rpc_manager.add_interface("start_fg",self.start_fg) self.rpc_manager.add_interface("set_gain",self.set_gain) self.rpc_manager.add_interface("set_samp_rate",self.set_samp_rate) self.rpc_manager.add_interface("set_bw",self.set_bw) self.rpc_manager.add_interface("set_antenna",self.set_antenna) self.rpc_manager.add_interface("get_gps_position",self.get_gps_position) self.rpc_manager.add_interface("sync_time",self.sync_time) self.rpc_manager.add_interface("program_gps_position",self.program_gps_position) self.rpc_manager.add_interface("stop_transmitter", self.stop_transmitter) self.rpc_manager.add_interface("start_transmitter", self.start_transmitter) self.rpc_manager.add_interface("set_tx_gain", self.set_tx_gain) self.rpc_manager.start_watcher() # Find out ip address s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) if not options.ssh_proxy: s.connect((options.fusion_center,6665)) else: s.connect(("www.rwth-aachen.de",80)) self.ip_addr = s.getsockname()[0] print "Master clock rate: ", self.usrp_source.get_clock_rate() self.stop_transmitter() # transmit flag toggled inside
def __init__(self): gr.top_block.__init__(self, "Top Block") Qt.QWidget.__init__(self) self.setWindowTitle("Top Block") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "top_block") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.used_id_bits = used_id_bits = 8 self.subcarriers = subcarriers = 208 self.id_blocks = id_blocks = 1 self.fft_length = fft_length = 256 self.fbmc = fbmc = 1 self.estimation_preamble = estimation_preamble = 0 self.data_blocks = data_blocks = 10 self.training_data = training_data = default_block_header(subcarriers,fft_length,fbmc,estimation_preamble,[]) self.repeated_id_bits = repeated_id_bits = subcarriers/used_id_bits self.data_part = data_part = data_blocks + id_blocks self.whitener_seed = whitener_seed = seed(1) self.whitener_pn = whitener_pn = [randint(0,1) for i in range(used_id_bits*repeated_id_bits)] self.variable_function_probe_2 = variable_function_probe_2 = 0 self.variable_function_probe_1 = variable_function_probe_1 = 0 self.variable_function_probe_0 = variable_function_probe_0 = 0 self.tx_hostname = tx_hostname = "localhost" self.samp_rate = samp_rate = 4*250000 self.interleaver = interleaver = trellis.interleaver(2000,666) self.frame_length = frame_length = 2*data_part + training_data.fbmc_no_preambles self.filter_length = filter_length = 4 self.disable_freq_sync = disable_freq_sync = 1 self.coding = coding = 1 self.chunkdivisor = chunkdivisor = int(numpy.ceil(data_blocks/5.0)) self.ber_window = ber_window = 100000 self.amplitude = amplitude = 1 self.SNR = SNR = 40 ################################################## # Blocks ################################################## self._amplitude_layout = Qt.QVBoxLayout() self._amplitude_tool_bar = Qt.QToolBar(self) self._amplitude_layout.addWidget(self._amplitude_tool_bar) self._amplitude_tool_bar.addWidget(Qt.QLabel("amplitude"+": ")) class qwt_counter_pyslot(Qwt.QwtCounter): def __init__(self, parent=None): Qwt.QwtCounter.__init__(self, parent) @pyqtSlot('double') def setValue(self, value): super(Qwt.QwtCounter, self).setValue(value) self._amplitude_counter = qwt_counter_pyslot() self._amplitude_counter.setRange(0, 1, 0.02) self._amplitude_counter.setNumButtons(2) self._amplitude_counter.setValue(self.amplitude) self._amplitude_tool_bar.addWidget(self._amplitude_counter) self._amplitude_counter.valueChanged.connect(self.set_amplitude) self._amplitude_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot) self._amplitude_slider.setRange(0, 1, 0.02) self._amplitude_slider.setValue(self.amplitude) self._amplitude_slider.setMinimumWidth(200) self._amplitude_slider.valueChanged.connect(self.set_amplitude) self._amplitude_layout.addWidget(self._amplitude_slider) self.top_layout.addLayout(self._amplitude_layout) self.tx_rpc_manager_0 = tx_rpc_manager(fft_length, subcarriers, data_blocks, frame_length, 0, 0.0, samp_rate) self.tigr_transmit_control_0 = tigr_transmit_control( subcarriers=subcarriers, fft_length=fft_length, used_id_bits=used_id_bits, estimation_preamble=estimation_preamble, filter_length=filter_length, fbmc=fbmc, data_blocks=data_blocks, data_part=data_part, repeated_id_bits=repeated_id_bits, coding=coding, ) self.tigr_scatterplot_0 = tigr_scatterplot( subcarriers=subcarriers, fbmc=fbmc, fft_length=fft_length, estimation_preamble=estimation_preamble, data_blocks=data_blocks, data_part=11, frame_length=frame_length, ) self.rx_rpc_manager_0 = rx_rpc_manager() self.rms = fbmc_rms_amplifier(amplitude, subcarriers) self.zeromq_pub_sink_1 = zeromq.pub_sink(gr.sizeof_float, subcarriers, "tcp://*:5559", 100) self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5557", 100) def _variable_function_probe_2_probe(): while True: val = self.rx_rpc_manager_0.add_set_scatter_subcarrier_interface(self.tigr_scatterplot_0.ofdm_vector_element_0.set_element) try: self.set_variable_function_probe_2(val) except AttributeError: pass time.sleep(1.0 / (0.000000001)) _variable_function_probe_2_thread = threading.Thread(target=_variable_function_probe_2_probe) _variable_function_probe_2_thread.daemon = True _variable_function_probe_2_thread.start() def _variable_function_probe_1_probe(): while True: val = self.tx_rpc_manager_0.add_tx_modulation_interface(self.tigr_transmit_control_0.ofdm_allocation_src_0.set_allocation) try: self.set_variable_function_probe_1(val) except AttributeError: pass time.sleep(1.0 / (0.000000001)) _variable_function_probe_1_thread = threading.Thread(target=_variable_function_probe_1_probe) _variable_function_probe_1_thread.daemon = True _variable_function_probe_1_thread.start() def _variable_function_probe_0_probe(): while True: val = self.tx_rpc_manager_0.add_tx_ampl_interface(self.rms.set_rms_amplitude) try: self.set_variable_function_probe_0(val) except AttributeError: pass time.sleep(1.0 / (0.000000001)) _variable_function_probe_0_thread = threading.Thread(target=_variable_function_probe_0_probe) _variable_function_probe_0_thread.daemon = True _variable_function_probe_0_thread.start() self.trellis_permutation_0 = trellis.permutation(interleaver.K(), (interleaver.DEINTER()), 1, gr.sizeof_float*1) self.tigr_fbmc_snr_estimator_0 = tigr_fbmc_snr_estimator( subcarriers=subcarriers, fbmc=fbmc, fft_length=fft_length, estimation_preamble=estimation_preamble, frame_length=frame_length, ) self.tigr_fbmc_inner_receiver_0 = tigr_fbmc_inner_receiver( subcarriers=subcarriers, fft_length=fft_length, data_blocks=data_blocks, estimation_preamble=estimation_preamble, filter_length=filter_length, frame_length=frame_length, disable_freq_sync=disable_freq_sync, ) self.tigr_ber_measurement_0 = tigr_ber_measurement( subcarriers=subcarriers, fbmc=fbmc, fft_length=fft_length, estimation_preamble=estimation_preamble, ber_window=ber_window, data_blocks=data_blocks, ) self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(0.1, subcarriers) self.ofdm_viterbi_combined_fb_0 = ofdm.viterbi_combined_fb(ofdm.fsm(ofdm.fsm(1,2,[91,121])), subcarriers, -1, -1, 2, chunkdivisor, ([-1,-1,-1,1,1,-1,1,1]), ofdm.TRELLIS_EUCLIDEAN) self.ofdm_vector_sampler_0 = ofdm.vector_sampler(gr.sizeof_gr_complex*subcarriers, 1) self.ofdm_vector_padding_0 = ofdm.vector_padding(subcarriers, fft_length, -1) self.ofdm_multiply_frame_fc_0 = ofdm.multiply_frame_fc(data_part, subcarriers) self.ofdm_multiply_const_ii_0 = ofdm.multiply_const_ii(1./int(numpy.ceil(data_blocks/5.0))) self.ofdm_generic_softdemapper_vcf_0 = ofdm.generic_softdemapper_vcf(subcarriers, data_part, 1) self.ofdm_fbmc_separate_vcvc_1 = ofdm.fbmc_separate_vcvc(fft_length, 2) self.ofdm_fbmc_polyphase_network_vcvc_1 = ofdm.fbmc_polyphase_network_vcvc(fft_length, filter_length, filter_length*fft_length-1, False) self.ofdm_fbmc_polyphase_network_vcvc_0 = ofdm.fbmc_polyphase_network_vcvc(fft_length, filter_length, filter_length*fft_length-1, False) self.ofdm_fbmc_pilot_block_inserter_0 = fbmc_pilot_block_inserter(subcarriers, data_part, training_data, 5) self.ofdm_fbmc_pilot_block_filter_0 = fbmc_pilot_block_filter(subcarriers, frame_length, data_part, training_data) self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0 = ofdm.fbmc_overlapping_parallel_to_serial_vcc(fft_length) self.ofdm_fbmc_oqam_preprocessing_vcvc_0 = ofdm.fbmc_oqam_preprocessing_vcvc(subcarriers, 0, 0) self.ofdm_fbmc_frame_sampler_0 = fbmc_frame_sampler(subcarriers, frame_length, data_part, training_data) self.ofdm_fbmc_beta_multiplier_vcvc_0 = ofdm.fbmc_beta_multiplier_vcvc(fft_length, filter_length, fft_length*fft_length-1, 0) self.ofdm_dynamic_trigger_ib_0 = ofdm.dynamic_trigger_ib(0) self.ofdm_depuncture_ff_0 = ofdm.depuncture_ff(subcarriers, 0) self.ofdm_coded_bpsk_soft_decoder_0 = ofdm.coded_bpsk_soft_decoder(subcarriers, used_id_bits, (whitener_pn)) self.ofdm_allocation_buffer_0 = ofdm.allocation_buffer(subcarriers, data_blocks, "tcp://"+tx_hostname+":3333", 1) self.fft_vxx_1 = fft.fft_vcc(fft_length, False, ([]), True, 1) self.channels_channel_model_0 = channels.channel_model( noise_voltage=math.sqrt(1.0*fft_length/subcarriers)*math.sqrt(0.5)*10**(-SNR/20.0), frequency_offset=0.0/fft_length, epsilon=1, taps=((1.0 ), ), noise_seed=0, block_tags=False ) self.blocks_vector_source_x_0 = blocks.vector_source_b([1] + [0]*(data_blocks/2-1), True, 1, []) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate,True) self.blocks_keep_one_in_n_1 = blocks.keep_one_in_n(gr.sizeof_float*subcarriers, 20) self.blks2_selector_0 = grc_blks2.selector( item_size=gr.sizeof_float*1, num_inputs=2, num_outputs=1, input_index=0, output_index=0, ) ################################################## # Connections ################################################## self.connect((self.ofdm_fbmc_polyphase_network_vcvc_0, 0), (self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0, 0)) self.connect((self.ofdm_fbmc_polyphase_network_vcvc_1, 0), (self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0, 1)) self.connect((self.ofdm_fbmc_separate_vcvc_1, 1), (self.ofdm_fbmc_polyphase_network_vcvc_1, 0)) self.connect((self.ofdm_fbmc_oqam_preprocessing_vcvc_0, 0), (self.ofdm_fbmc_pilot_block_inserter_0, 0)) self.connect((self.ofdm_fbmc_pilot_block_inserter_0, 0), (self.ofdm_vector_padding_0, 0)) self.connect((self.ofdm_fbmc_beta_multiplier_vcvc_0, 0), (self.fft_vxx_1, 0)) self.connect((self.fft_vxx_1, 0), (self.ofdm_fbmc_separate_vcvc_1, 0)) self.connect((self.tigr_transmit_control_0, 0), (self.ofdm_fbmc_oqam_preprocessing_vcvc_0, 0)) self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_keep_one_in_n_1, 0)) self.connect((self.ofdm_fbmc_frame_sampler_0, 1), (self.ofdm_fbmc_pilot_block_filter_0, 1)) self.connect((self.ofdm_fbmc_frame_sampler_0, 0), (self.ofdm_fbmc_pilot_block_filter_0, 0)) self.connect((self.ofdm_fbmc_pilot_block_filter_0, 1), (self.ofdm_vector_sampler_0, 1)) self.connect((self.ofdm_vector_sampler_0, 0), (self.ofdm_coded_bpsk_soft_decoder_0, 0)) self.connect((self.ofdm_coded_bpsk_soft_decoder_0, 0), (self.ofdm_allocation_buffer_0, 0)) self.connect((self.ofdm_allocation_buffer_0, 1), (self.ofdm_generic_softdemapper_vcf_0, 1)) self.connect((self.single_pole_iir_filter_xx_0, 0), (self.ofdm_generic_softdemapper_vcf_0, 2)) self.connect((self.ofdm_generic_softdemapper_vcf_0, 0), (self.trellis_permutation_0, 0)) self.connect((self.ofdm_depuncture_ff_0, 0), (self.ofdm_viterbi_combined_fb_0, 0)) self.connect((self.ofdm_allocation_buffer_0, 1), (self.ofdm_depuncture_ff_0, 1)) self.connect((self.blocks_vector_source_x_0, 0), (self.ofdm_depuncture_ff_0, 2)) self.connect((self.ofdm_allocation_buffer_0, 0), (self.ofdm_multiply_const_ii_0, 0)) self.connect((self.ofdm_multiply_const_ii_0, 0), (self.ofdm_viterbi_combined_fb_0, 1)) self.connect((self.ofdm_fbmc_separate_vcvc_1, 0), (self.ofdm_fbmc_polyphase_network_vcvc_0, 0)) self.connect((self.ofdm_viterbi_combined_fb_0, 0), (self.tigr_ber_measurement_0, 2)) self.connect((self.ofdm_dynamic_trigger_ib_0, 0), (self.tigr_ber_measurement_0, 3)) self.connect((self.ofdm_fbmc_frame_sampler_0, 0), (self.tigr_fbmc_snr_estimator_0, 0)) self.connect((self.ofdm_fbmc_frame_sampler_0, 1), (self.tigr_fbmc_snr_estimator_0, 1)) self.connect((self.tigr_fbmc_inner_receiver_0, 1), (self.ofdm_fbmc_frame_sampler_0, 1)) self.connect((self.tigr_fbmc_inner_receiver_0, 2), (self.ofdm_fbmc_frame_sampler_0, 0)) self.connect((self.rms, 0), (self.blocks_throttle_0, 0)) self.connect((self.tigr_fbmc_inner_receiver_0, 3), (self.zeromq_pub_sink_0, 0)) self.connect((self.blocks_keep_one_in_n_1, 0), (self.zeromq_pub_sink_1, 0)) self.connect((self.ofdm_vector_padding_0, 0), (self.ofdm_fbmc_beta_multiplier_vcvc_0, 0)) self.connect((self.tigr_fbmc_inner_receiver_0, 0), (self.single_pole_iir_filter_xx_0, 0)) self.connect((self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0, 0), (self.rms, 0)) self.connect((self.ofdm_allocation_buffer_0, 0), (self.ofdm_dynamic_trigger_ib_0, 0)) self.connect((self.ofdm_coded_bpsk_soft_decoder_0, 0), (self.tigr_ber_measurement_0, 0)) self.connect((self.ofdm_allocation_buffer_0, 0), (self.tigr_ber_measurement_0, 1)) self.connect((self.blks2_selector_0, 0), (self.ofdm_depuncture_ff_0, 0)) self.connect((self.trellis_permutation_0, 0), (self.blks2_selector_0, 1)) self.connect((self.ofdm_generic_softdemapper_vcf_0, 0), (self.blks2_selector_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.channels_channel_model_0, 0)) self.connect((self.channels_channel_model_0, 0), (self.tigr_fbmc_inner_receiver_0, 0)) self.connect((self.ofdm_fbmc_pilot_block_filter_0, 0), (self.ofdm_vector_sampler_0, 0)) self.connect((self.ofdm_allocation_buffer_0, 2), (self.ofdm_multiply_frame_fc_0, 1)) self.connect((self.ofdm_fbmc_pilot_block_filter_0, 0), (self.ofdm_multiply_frame_fc_0, 0)) self.connect((self.ofdm_multiply_frame_fc_0, 0), (self.tigr_scatterplot_0, 0)) self.connect((self.ofdm_multiply_frame_fc_0, 0), (self.ofdm_generic_softdemapper_vcf_0, 0))