def __init__(self, syncword_threshold=None, options=None): gr.hier_block2.__init__(self, "lilacsat_1_deframer", gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(0, 0, 0)) options_block.__init__(self, options) self.message_port_register_hier_out('out') self.message_port_register_hier_out('codec2') if syncword_threshold is None: syncword_threshold = self.options.syncword_threshold self.delay1 = blocks.delay(gr.sizeof_float, 1) self.viterbi0 = ccsds_viterbi() self.viterbi1 = ccsds_viterbi() self.differential0 = digital.diff_decoder_bb(2) self.differential1 = digital.diff_decoder_bb(2) self.tag0 = digital.correlate_access_code_tag_bb( _syncword, syncword_threshold, 'syncword') self.tag1 = digital.correlate_access_code_tag_bb( _syncword, syncword_threshold, 'syncword') self.scrambler0 = digital.additive_scrambler_bb( 0xA9, 0xFF, 7, count=0, bits_per_byte=1, reset_tag_key='syncword') self.scrambler1 = digital.additive_scrambler_bb( 0xA9, 0xFF, 7, count=0, bits_per_byte=1, reset_tag_key='syncword') self.demux0 = lilacsat1_demux('syncword') self.demux1 = lilacsat1_demux('syncword') self.pdu2tag = blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len') self.pack = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) self.multiply_length = blocks.tagged_stream_multiply_length( gr.sizeof_char * 1, 'packet_len', 1 / 8.0) self.tag2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len') self.pdu2tag_codec2 = blocks.pdu_to_tagged_stream( blocks.byte_t, 'packet_len') self.pack_codec2 = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) self.multiply_length_codec2 = blocks.tagged_stream_multiply_length( gr.sizeof_char * 1, 'packet_len', 1 / 8.0) self.tag2pdu_codec2 = blocks.tagged_stream_to_pdu( blocks.byte_t, 'packet_len') self.connect(self, self.viterbi0, self.differential0, self.tag0, self.scrambler0, self.demux0) self.connect(self, self.delay1, self.viterbi1, self.differential1, self.tag1, self.scrambler1, self.demux1) self.connect(self.pdu2tag, self.pack, self.multiply_length, self.tag2pdu) self.connect(self.pdu2tag_codec2, self.pack_codec2, self.multiply_length_codec2, self.tag2pdu_codec2) self.msg_connect((self.demux0, 'kiss'), (self.pdu2tag, 'pdus')) self.msg_connect((self.demux1, 'kiss'), (self.pdu2tag, 'pdus')) self.msg_connect((self.demux0, 'codec2'), (self.pdu2tag_codec2, 'pdus')) self.msg_connect((self.demux1, 'codec2'), (self.pdu2tag_codec2, 'pdus')) self.msg_connect((self.tag2pdu, 'pdus'), (self, 'out')) self.msg_connect((self.tag2pdu_codec2, 'pdus'), (self, 'codec2'))
def test_003(self): # Test that block stops when interacting with streaming interface port = str(random.Random().randint(0, 30000) + 10000) srcdata = (0x73, 0x75, 0x63, 0x68, 0x74, 0x65, 0x73, 0x74, 0x76, 0x65, 0x72, 0x79, 0x70, 0x61, 0x73, 0x73) tag_dict = {"offset": 0} tag_dict["key"] = pmt.intern("len") tag_dict["value"] = pmt.from_long(8) tag1 = gr.python_to_tag(tag_dict) tag_dict["offset"] = 8 tag2 = gr.python_to_tag(tag_dict) tags = [tag1, tag2] src = blocks.vector_source_b(srcdata, False, 1, tags) ts_to_pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "len") pdu_send = blocks.socket_pdu("UDP_CLIENT", "localhost", "4141") #pdu_recv = blocks.socket_pdu("UDP_SERVER", "localhost", port) pdu_to_ts = blocks.pdu_to_tagged_stream(blocks.byte_t, "len") head = blocks.head(gr.sizeof_char, 10) sink = blocks.vector_sink_b(1) self.tb.connect(src, ts_to_pdu) self.tb.msg_connect(ts_to_pdu, "pdus", pdu_send, "pdus") # a UDP socket connects pdu_send to pdu_recv # TODO: test that the recv socket can be destroyed from downstream # that signals DONE. Also that we get the PDUs we sent #self.tb.msg_connect(pdu_recv, "pdus", pdu_to_ts, "pdus") #self.tb.connect(pdu_to_ts, head, sink) self.tb.run()
def test_001_t(self): # set up fg pkt_tag = gr.tag_t() pkt_tag.key = pmt.intern("pkt") mod_types = ['BPSK', 'QPSK', '8PSK', 'QAM16', 'QAM64'] for mod_type in mod_types: print("Testing {}...".format(mod_type)) modulator = modulator_classic(mod_type) src_data = get_random_bits(100 * modulator.bits_per_symbol) pkt_tag.value = pmt.to_pmt(len(src_data)) expected_data = modulator.modulate( bits_to_integers(data_b=src_data, bits_per_symbol=modulator.bits_per_symbol)) src = blocks.vector_source_b(src_data, False, 1, [pkt_tag]) tag2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "pkt") pdu2tag = blocks.pdu_to_tagged_stream(blocks.complex_t, "pkt") snk = blocks.vector_sink_c() self.tb.connect(src, tag2pdu) self.tb.msg_connect(tag2pdu, "pdus", modulator, "bits") self.tb.msg_connect(modulator, "symbols", pdu2tag, "pdus") self.tb.connect(pdu2tag, snk) self.tb.start() while modulator.packet_cnt < 1: time.sleep(0.1) self.tb.stop() self.tb.wait() # check data result_data = snk.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data, 6)
def test_001_t(self): print("Enable plotting to manually verify result of wrapping") body = get_random_bits(256) src = tvsb(body.astype(numpy.int8), None, True, "body") mod = modulator_classic("BPSK") wrapper = echo_packet_wrapper(self.nfreq_samps, self.freqs, self.corr_reps) sink = blocks.vector_sink_c() pdu2strm = blocks.pdu_to_tagged_stream(blocks.complex_t, "frame") strm2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "body") # Connect blocks self.tb.connect(src, strm2pdu) self.tb.connect(pdu2strm, sink) self.tb.msg_connect(strm2pdu, "pdus", mod, "bits") self.tb.msg_connect(mod, "symbols", wrapper, "body") self.tb.msg_connect(wrapper, "frame", pdu2strm, "pdus") # Run self.tb.start() while wrapper.npackets < 1: time.sleep(0.1) self.tb.stop() self.tb.wait() # check data result = sink.data() # self.plot_outcome(result) self.assertEqual(len(result), self.nfreq_samps + 2 * self.corr_reps * 256 + 256, "Incorrect number of output bits")
def __init__(self): gr.top_block.__init__(self, "Strobe") ################################################## # Blocks ################################################## self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.blocks_message_strobe_0_0 = blocks.message_strobe(pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(64,0) ), 750) self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 1000) self.blocks_message_debug_0 = blocks.message_debug() self.blocks_copy_0 = blocks.copy(gr.sizeof_char*1) self.blocks_copy_0.set_enabled(True) ################################################## # Connections ################################################## self.connect((self.blocks_copy_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_copy_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.blocks_message_strobe_0, "strobe", self.blocks_message_debug_0, "print") self.msg_connect(self.blocks_message_strobe_0_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus") self.msg_connect(self.blocks_tagged_stream_to_pdu_0, "pdus", self.blocks_message_debug_0, "print_pdu")
def setUp(self): self.tb = gr.top_block() ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32e3 self.preamble = preamble = get_random_bits(64 * 3) self.npreamble = len(self.preamble) # self.modulation = modulation = "QPSK" self.nbits = 16 * 3 self.bits = get_random_bits(self.nbits) self.tag_preamble = gr.tag_t() self.tag_preamble.key = pmt.intern("pkt") self.tag_preamble.value = pmt.from_long(self.npreamble) self.tag_preamble.offset = 0 self.tag_body = gr.tag_t() self.tag_body.key = pmt.intern("pkt") self.tag_body.value = pmt.from_long(self.nbits) ################################################## # Blocks ################################################## # self.modulator = modulator_classic(modulation) # self.demodulator = demodulator_neural(seed=0, hidden_layers=(64, ), bits_per_symbol=2, preamble=preamble) self.vector_source_preamble = blocks.vector_source_b( preamble, True, 1, [self.tag_preamble]) self.vector_source_body = blocks.vector_source_b( self.bits, True, 1, [self.tag_body]) self.tags_mux = blocks.tagged_stream_mux(gr.sizeof_char * 1, "pkt") self.strm_to_pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "pkt") self.pdu_to_strm = blocks.pdu_to_tagged_stream(blocks.byte_t, "pkt") self.vector_sink = blocks.vector_sink_b()
def __init__(self): gr.hier_block2.__init__( self, "OFDM PHY", gr.io_signature(1, 1, gr.sizeof_gr_complex * 1), gr.io_signature2(2, 2, gr.sizeof_gr_complex * 1, gr.sizeof_char)) # Message Port self.message_port_register_hier_out("from_mac") self.message_port_register_hier_in("to_mac") # Blocks self.tx_pdu = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_length") self.tx_path = ofdm_tx(scramble_bits=True) self.rx_path = ofdm_rx(scramble_bits=True) self.rx_pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_length") # Connections self.connect(self.tx_pdu, self.tx_path, self) self.connect(self, self.rx_path, self.rx_pdu) self.connect((self.rx_path, 1), (self, 1)) # Message Connection self.msg_connect(self, "from_mac", self.tx_pdu, "pdus") self.msg_connect(self.rx_pdu, "pdus", self, "to_mac")
def test_001_t (self): # set up fg phr = np.random.randint(0,2,size=(12,)) data = np.array(np.random.randint(0,256, size=(6*3,))) data_bin = np.unpackbits(np.array(data,dtype=np.uint8)) self.src = blocks.vector_source_b(data, False, 1, []) self.s2ts = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 6, "packet_len") self.ts2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.pref = ieee802_15_4.phr_prefixer(phr) self.pdu2ts = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.snk = blocks.vector_sink_b(1) self.tb.connect(self.src, self.s2ts, self.ts2pdu) self.tb.msg_connect(self.ts2pdu, "pdus", self.pref, "in") self.tb.msg_connect(self.pref, "out", self.pdu2ts, "pdus") self.tb.connect(self.pdu2ts, self.snk) self.tb.start() time.sleep(1) self.tb.stop() # check data data_out = self.snk.data() # print "input:" # for i in data: # print i # print "output:" # for i in data_out: # print data_out expected_output = np.concatenate((phr,data_bin[0:6*8], phr, data_bin[6*8:12*8], phr, data_bin[12*8:18*8])) self.assertFloatTuplesAlmostEqual(data_out, expected_output)
def __init__(self): gr.top_block.__init__(self, "Strobe") ################################################## # Blocks ################################################## self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, "packet_len") self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream( blocks.byte_t, "packet_len") self.blocks_message_strobe_0_0 = blocks.message_strobe( pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(64, 0)), 750) self.blocks_message_strobe_0 = blocks.message_strobe( pmt.intern("TEST"), 1000) self.blocks_message_debug_0 = blocks.message_debug() self.blocks_copy_0 = blocks.copy(gr.sizeof_char * 1) self.blocks_copy_0.set_enabled(True) ################################################## # Connections ################################################## self.connect((self.blocks_copy_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_copy_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.blocks_message_strobe_0, "strobe", self.blocks_message_debug_0, "print") self.msg_connect(self.blocks_message_strobe_0_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus") self.msg_connect(self.blocks_tagged_stream_to_pdu_0, "pdus", self.blocks_message_debug_0, "print_pdu")
def __init__(self): gr.top_block.__init__(self, "Bit Padding Test") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, 'packet_len') self.blocks_random_pdu_0 = blocks.random_pdu(10, 12, chr(0xFF), 2) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream( blocks.byte_t, 'packet_len') self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_random_pdu_0, 'pdus'), (self.blocks_message_debug_0, 'print_pdu')) self.msg_connect((self.blocks_random_pdu_0, 'pdus'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.blocks_message_debug_0, 'print_pdu')) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0))
def test_001_t(self): cipher_name = "aes-256-cbc" plainlen = 1600 packet_len = 1600 key = bytearray(numpy.random.randint(0, 256, 32).tolist()) plain = bytearray(numpy.random.randint(0, 256, plainlen).tolist()) cipher_desc = crypto.sym_ciph_desc(cipher_name, False, key) src = blocks.vector_source_b(plain) stts = blocks.stream_to_tagged_stream(1, 1, packet_len, "packet_len") tstpdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") enc = crypto.sym_enc(cipher_desc) dec = crypto.sym_dec(cipher_desc) snk = blocks.message_debug() self.tb.connect(src, stts, tstpdu) self.tb.msg_connect(tstpdu, "pdus", enc, "pdus") self.tb.msg_connect(enc, "pdus", dec, "pdus") self.tb.msg_connect(dec, "pdus", snk, "store") self.tb.run() num_msg = snk.num_messages() decrypted = bytearray( pmt.u8vector_elements(pmt.cdr((snk.get_message(0))))) self.assertEqual(plain, decrypted)
def test_001_t(self): # set up fg phr = np.random.randint(0, 2, size=(12, )) data = np.array(np.random.randint(0, 256, size=(6 * 3, ))) data_bin = np.unpackbits(np.array(data, dtype=np.uint8)) self.src = blocks.vector_source_b(data, False, 1, []) self.s2ts = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 6, "packet_len") self.ts2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.pref = ieee802_15_4.phr_prefixer(phr) self.pdu2ts = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.snk = blocks.vector_sink_b(1) self.tb.connect(self.src, self.s2ts, self.ts2pdu) self.tb.msg_connect(self.ts2pdu, "pdus", self.pref, "in") self.tb.msg_connect(self.pref, "out", self.pdu2ts, "pdus") self.tb.connect(self.pdu2ts, self.snk) self.tb.start() time.sleep(1) self.tb.stop() # check data data_out = self.snk.data() # print "input:" # for i in data: # print i # print "output:" # for i in data_out: # print data_out expected_output = np.concatenate( (phr, data_bin[0:6 * 8], phr, data_bin[6 * 8:12 * 8], phr, data_bin[12 * 8:18 * 8])) self.assertFloatTuplesAlmostEqual(data_out, expected_output)
def __init__(self): gr.hier_block2.__init__( self, 'PN9 scrambler', gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0), ) self.message_port_register_hier_in('in') self.message_port_register_hier_out('out') ################################################## # Blocks ################################################## self.digital_additive_scrambler_bb_0 = ( digital.additive_scrambler_bb(0x21, 0x1FF, 8, count=0, bits_per_byte=8, reset_tag_key='packet_len')) self.blocks_tagged_stream_to_pdu_0 = ( blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len')) self.blocks_pdu_to_tagged_stream_0 = ( blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len')) ################################################## # Connections ################################################## self.msg_connect( (self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self, 'out')) self.msg_connect( (self, 'in'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.connect( (self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_additive_scrambler_bb_0, 0)) self.connect( (self.digital_additive_scrambler_bb_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0))
def test_filtered_keep_t(self): print("Filtered Keep Test") bits = util_data.get_random_bits(100).astype(np.int8) source = tvsb(data=bits, triggers=["DEBUG"], initial_trigger=True, tag_key=self.tag_key, debug_key="DEBUG") sink = blocks.vector_sink_b() strm2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, self.tag_key) # Connect self.tb.connect(source, sink) self.tb.connect(source, strm2pdu) self.tb.msg_connect(strm2pdu, "pdus", source, "trigger") # Confirm self.tb.start() cycles = 0 while source.ntriggers < 3 and cycles < 50: time.sleep(0.1) cycles += 1 self.tb.stop() self.tb.wait() ntrigs = source.ntriggers result = sink.data() self.assertGreater(ntrigs, 2, "Insufficient number of triggers {}".format(ntrigs)) for i, r in enumerate(result): self.assertEqual(r, bits[i % len(bits)], "Incorrect data out at index {}".format(i))
def test_001_t(self): pkt_tag = gr.tag_t() pkt_tag.key = pmt.intern("pkt") mod_types = ('BPSK', 'QPSK', '8PSK', 'QAM16', 'QAM64') for mod_type in mod_types: print("Testing {}...".format(mod_type)) modulator = modulator_classic(mod_type) demodulator = demodulator_classic(mod_type, 200) src_data = get_random_bits(1000 * modulator.bits_per_symbol) pkt_tag.value = pmt.to_pmt(len(src_data)) src = blocks.vector_source_b(src_data, False, 1, [pkt_tag]) snk = blocks.vector_sink_b() tag2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "pkt") pdu2tag = blocks.pdu_to_tagged_stream(blocks.byte_t, "pkt") self.tb.connect(src, tag2pdu) self.tb.msg_connect(tag2pdu, "pdus", modulator, "bits") self.tb.msg_connect(modulator, "symbols", demodulator, "symbols") self.tb.msg_connect(demodulator, "bits", pdu2tag, "pdus") self.tb.connect(pdu2tag, snk) self.tb.start() # check data while demodulator.packet_cnt < 1: time.sleep(0.1) self.tb.stop() self.tb.wait() result_data = snk.data() for i in range(1000 * modulator.bits_per_symbol): self.assertEqual(src_data[i], result_data[i])
def __init__(self, host='127.0.0.1', iq_port='9094', packet_port='9095', sample_filename='sample_filename.dat'): gr.top_block.__init__(self, "Hurdle 1 Solution Stub") ################################################## # Parameters ################################################## self.host = host self.iq_port = iq_port self.packet_port = packet_port self.sample_filename = sample_filename ################################################## # Variables ################################################## self.samp_rate = samp_rate = 4e6 self.num_garbage = num_garbage = int(1e6 / 8) ################################################## # Blocks ################################################## self.blocks_throttle_1 = blocks.throttle(gr.sizeof_char * 1, samp_rate / 8.0, True) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, 'packet_len') self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream( gr.sizeof_char, 1, 1000, 'packet_len') self.blocks_socket_pdu_0_0 = blocks.socket_pdu("TCP_CLIENT", host, packet_port, 10000, False) self.blocks_socket_pdu_0 = blocks.socket_pdu("TCP_CLIENT", host, iq_port, 10000, False) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream( blocks.complex_t, 'packet_len') self.blocks_head_0 = blocks.head(gr.sizeof_char * 1, num_garbage) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex * 1, sample_filename, False) self.blocks_file_sink_0.set_unbuffered(False) self.analog_random_source_x_0 = blocks.vector_source_b( map(int, numpy.random.randint(0, 255, 1000)), True) ################################################## # Connections ################################################## self.msg_connect((self.blocks_socket_pdu_0, 'pdus'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.blocks_socket_pdu_0_0, 'pdus')) self.connect((self.analog_random_source_x_0, 0), (self.blocks_throttle_1, 0)) self.connect((self.blocks_head_0, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_throttle_1, 0), (self.blocks_head_0, 0))
def test_002_tags_plus_data(self): packet_len = 16 src_data = range(packet_len) tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol('spam') tag1.value = pmt.from_long(23) tag2 = gr.tag_t() tag2.offset = 10 # Must be < packet_len tag2.key = pmt.string_to_symbol('eggs') tag2.value = pmt.from_long(42) src = blocks.vector_source_f(src_data, tags=(tag1, tag2)) s2ts = blocks.stream_to_tagged_stream(gr.sizeof_float, vlen=1, packet_len=packet_len, len_tag_key="packet_len") ts2pdu = blocks.tagged_stream_to_pdu(blocks.float_t, "packet_len") dbg = blocks.message_debug() self.tb.connect(src, s2ts, ts2pdu) self.tb.msg_connect(ts2pdu, "pdus", dbg, "store") self.tb.start() self.tb.wait() result_msg = dbg.get_message(0) metadata = pmt.to_python(pmt.car(result_msg)) vector = pmt.f32vector_elements(pmt.cdr(result_msg)) self.assertEqual(metadata, {'eggs': 42, 'spam': 23}) self.assertFloatTuplesAlmostEqual(tuple(vector), src_data)
def test_003 (self): # Test that block stops when interacting with streaming interface port = str(random.Random().randint(0, 30000) + 10000) srcdata = (0x73, 0x75, 0x63, 0x68, 0x74, 0x65, 0x73, 0x74, 0x76, 0x65, 0x72, 0x79, 0x70, 0x61, 0x73, 0x73) tag_dict = {"offset": 0} tag_dict["key"] = pmt.intern("len") tag_dict["value"] = pmt.from_long(8) tag1 = gr.python_to_tag(tag_dict) tag_dict["offset"] = 8 tag2 = gr.python_to_tag(tag_dict) tags = [tag1, tag2] src = blocks.vector_source_b(srcdata, False, 1, tags) ts_to_pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "len") pdu_send = blocks.socket_pdu("UDP_CLIENT", "localhost", "4141") #pdu_recv = blocks.socket_pdu("UDP_SERVER", "localhost", port) pdu_to_ts = blocks.pdu_to_tagged_stream(blocks.byte_t, "len") head = blocks.head(gr.sizeof_char, 10) sink = blocks.vector_sink_b(1) self.tb.connect(src, ts_to_pdu) self.tb.msg_connect(ts_to_pdu, "pdus", pdu_send, "pdus") # a UDP socket connects pdu_send to pdu_recv # TODO: test that the recv socket can be destroyed from downstream # that signals DONE. Also that we get the PDUs we sent #self.tb.msg_connect(pdu_recv, "pdus", pdu_to_ts, "pdus") #self.tb.connect(pdu_to_ts, head, sink) self.tb.run()
def test_002_tags_plus_data(self): packet_len = 16 src_data = range(packet_len) tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol('spam') tag1.value = pmt.from_long(23) tag2 = gr.tag_t() tag2.offset = 10 # Must be < packet_len tag2.key = pmt.string_to_symbol('eggs') tag2.value = pmt.from_long(42) src = blocks.vector_source_f(src_data, tags=(tag1, tag2)) s2ts = blocks.stream_to_tagged_stream(gr.sizeof_float, vlen=1, packet_len=packet_len, len_tag_key="packet_len") ts2pdu = blocks.tagged_stream_to_pdu(blocks.float_t, "packet_len") dbg = blocks.message_debug() self.tb.connect(src, s2ts, ts2pdu) self.tb.msg_connect(ts2pdu, "pdus", dbg, "store") self.tb.start() while dbg.num_messages() < 1: time.sleep(0.1) self.tb.stop() self.tb.wait() result_msg = dbg.get_message(0) metadata = pmt.to_python(pmt.car(result_msg)) vector = pmt.f32vector_elements(pmt.cdr(result_msg)) self.assertEqual(metadata, {'eggs': 42, 'spam': 23}) self.assertFloatTuplesAlmostEqual(tuple(vector), src_data)
def test_000(self): # Just run some data through and make sure it doesn't puke. src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = blocks.pdu_to_tagged_stream(blocks.byte_t) snk3 = blocks.tagged_stream_to_pdu(blocks.byte_t) snk2 = blocks.vector_sink_b() snk = blocks.tag_debug(1, "test") snk.set_display(False) dbg = blocks.message_debug() # Test that the right number of ports exist. pi = snk3.message_ports_in() po = snk3.message_ports_out() # system port is defined automatically self.assertEqual(pmt.length(pi), 1) self.assertEqual(pmt.length(po), 1) self.tb.connect(src, snk) self.tb.connect(src, snk2) self.tb.connect(src, snk3) self.tb.msg_connect(snk3, "pdus", dbg, "store") # make our reference and message pmts port = pmt.intern("pdus") msg = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF)) # post the message src.to_basic_block()._post(port, msg) src.to_basic_block()._post( pmt.intern("system"), pmt.cons(pmt.intern("done"), pmt.from_long(1))) self.tb.start() self.tb.wait() # Get the vector of data from the vector sink result_data = snk2.data() # Get the vector of data from the message sink # Convert the message PMT as a pair into its vector result_msg = dbg.get_message(0) msg_vec = pmt.cdr(result_msg) # pmt.print(msg_vec) # Convert the PMT vector into a Python list msg_data = [] for i in range(16): msg_data.append(pmt.u8vector_ref(msg_vec, i)) actual_data = 16 * [ 0xFF, ] self.assertEqual(actual_data, list(result_data)) self.assertEqual(actual_data, msg_data)
def __init__(self, bb_params, tcp_addr): gr.hier_block2.__init__( self, "Build and Send Pkt", gr.io_signature(1, 1, gr.sizeof_char * 1), # single in gr.io_signature(0, 0, 0) # output via zmq ) # parameters self.bb_params = bb_params self.tcp_addr = tcp_addr # variables self.tag_name = "packet_len" self.preamble_str = "" for bit in self.bb_params.preamble: if bit == 1: self.preamble_str = self.preamble_str + '1' else: self.preamble_str = self.preamble_str + '0' # blocks # detect and tag any preambles self.digital_correlate_access_code_xx_ts_0 = \ digital.correlate_access_code_bb_ts( self.preamble_str, 0, self.tag_name) self.connect((self, 0), (self.digital_correlate_access_code_xx_ts_0, 0)) # pack the bits into bytes self.blocks_repack_bits_bb_0 = \ blocks.repack_bits_bb( 1, 8, self.tag_name, False, gr.GR_MSB_FIRST) self.connect((self.digital_correlate_access_code_xx_ts_0, 0), (self.blocks_repack_bits_bb_0, 0)) # convert payloads to PDUs self.blocks_tagged_stream_to_pdu_0 = \ blocks.tagged_stream_to_pdu(blocks.byte_t, self.tag_name) self.connect((self.blocks_repack_bits_bb_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) # send PDU to zmq sink self.zeromq_push_msg_sink_0 = \ zeromq.push_msg_sink( self.tcp_addr, 100) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.zeromq_push_msg_sink_0, 'in'))
def test_000(self): # Just run some data through and make sure it doesn't puke. src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = blocks.pdu_to_tagged_stream(blocks.byte_t) snk3 = blocks.tagged_stream_to_pdu(blocks.byte_t) snk2 = blocks.vector_sink_b() snk = blocks.tag_debug(1, "test") snk.set_display(False) dbg = blocks.message_debug() # Test that the right number of ports exist. pi = snk3.message_ports_in() po = snk3.message_ports_out() self.assertEqual(pmt.length(pi), 0) self.assertEqual(pmt.length(po), 1) self.tb.connect(src, snk) self.tb.connect(src, snk2) self.tb.connect(src, snk3) self.tb.msg_connect(snk3, "pdus", dbg, "store") self.tb.start() # make our reference and message pmts port = pmt.intern("pdus") msg = pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF)) # post the message src.to_basic_block()._post(port, msg) # eww, what's that smell? while dbg.num_messages() < 1: time.sleep(0.1) self.tb.stop() self.tb.wait() # Get the vector of data from the vector sink result_data = snk2.data() # Get the vector of data from the message sink # Convert the message PMT as a pair into its vector result_msg = dbg.get_message(0) msg_vec = pmt.cdr(result_msg) #pmt.print(msg_vec) # Convert the PMT vector into a Python list msg_data = [] for i in xrange(16): msg_data.append(pmt.u8vector_ref(msg_vec, i)) actual_data = 16*[0xFF,] self.assertEqual(actual_data, list(result_data)) self.assertEqual(actual_data, msg_data)
def __init__(self): gr.top_block.__init__(self, "Ask Tx Top Raspi") ################################################## # Variables ################################################## self.sound_card_sample_rate = sound_card_sample_rate = 44000 self.samples_per_symbol = samples_per_symbol = 19 self.symbol_rate = symbol_rate = sound_card_sample_rate / samples_per_symbol self.bits_per_symbol = bits_per_symbol = 1 self.variable_rrc_filter_taps = variable_rrc_filter_taps = firdes.root_raised_cosine( 15, sound_card_sample_rate, symbol_rate, 0.5, 70) self.bit_rate = bit_rate = symbol_rate / bits_per_symbol ################################################## # Blocks ################################################## self.interp_fir_filter_xxx_0 = filter.interp_fir_filter_fff( samples_per_symbol, (variable_rrc_filter_taps)) self.interp_fir_filter_xxx_0.declare_sample_delay(0) self.digital_hdlc_framer_pb_0 = digital.hdlc_framer_pb('packet_len') self.digital_chunks_to_symbols_xx_0 = digital.chunks_to_symbols_bf( ([-1, 1]), 1) self.blocks_throttle_1 = blocks.throttle(gr.sizeof_char * 1, bit_rate, True) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, 'packet_len') self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream( gr.sizeof_char, 1, 32, "packet_len") self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char * 1, './test_src_file.txt', True) self.audio_sink_0 = audio.sink(int(sound_card_sample_rate), '', True) ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.digital_hdlc_framer_pb_0, 'in')) self.connect((self.blocks_file_source_0, 0), (self.blocks_throttle_1, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_throttle_1, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.digital_chunks_to_symbols_xx_0, 0), (self.interp_fir_filter_xxx_0, 0)) self.connect((self.digital_hdlc_framer_pb_0, 0), (self.digital_chunks_to_symbols_xx_0, 0)) self.connect((self.interp_fir_filter_xxx_0, 0), (self.audio_sink_0, 0))
def __init__(self, syncword_threshold=None, options=None): gr.hier_block2.__init__(self, 'aausat4_deframer', gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(0, 0, 0)) options_block.__init__(self, options) self.message_port_register_hier_out('out') if syncword_threshold is None: syncword_threshold = self.options.syncword_threshold self.deframer = sync_to_pdu_soft(packlen=1996 + 8, sync=_syncword, threshold=syncword_threshold) self.fsm = aausat4_remove_fsm() self.viterbi_short = fec.cc_decoder.make(1020, 7, 2, [79, -109], 0, -1, fec.CC_TERMINATED, False) self.viterbi_decoder_short = fec.async_decoder(self.viterbi_short, True, False, 1020 // 8) self.viterbi_long = fec.cc_decoder.make(1996, 7, 2, [79, -109], 0, -1, fec.CC_TERMINATED, False) self.viterbi_decoder_long = fec.async_decoder(self.viterbi_long, False, False, 1996 // 8) # Workaround for bug https://github.com/gnuradio/gnuradio/pull/2965 # We use packed output for Viterbi short decoder and then # we unpack the PDUs. self.pdu2tag = blocks.pdu_to_tagged_stream(byte_t, 'packet_len') self.unpack = blocks.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST) self.taglength = blocks.tagged_stream_multiply_length( gr.sizeof_char * 1, 'packet_len', 8) self.tag2pdu = blocks.tagged_stream_to_pdu(byte_t, 'packet_len') self.scrambler = ccsds_descrambler() self.rs = decode_rs(False, 1) self.connect(self, self.deframer) self.msg_connect((self.deframer, 'out'), (self.fsm, 'in')) self.msg_connect((self.fsm, 'short'), (self.viterbi_decoder_short, 'in')) self.msg_connect((self.fsm, 'long'), (self.viterbi_decoder_long, 'in')) # Workaround self.msg_connect((self.viterbi_decoder_short, 'out'), (self.pdu2tag, 'pdus')) self.connect(self.pdu2tag, self.unpack, self.taglength, self.tag2pdu) self.msg_connect((self.tag2pdu, 'pdus'), (self.scrambler, 'in')) self.msg_connect((self.viterbi_decoder_long, 'out'), (self.scrambler, 'in')) self.msg_connect((self.scrambler, 'out'), (self.rs, 'in')) self.msg_connect((self.rs, 'out'), (self, 'out'))
def __init__(self, frameTag="packet_len", numRevs=20): gr.hier_block2.__init__( self, "AX.25 Packet Formatter", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0), ) self.message_port_register_hier_in("in") self.message_port_register_hier_out("out") ################################################## # Parameters ################################################## self.frameTag = frameTag self.numRevs = numRevs ################################################## # Blocks ################################################## self.digital_hdlc_framer_pb_0 = digital.hdlc_framer_pb(frameTag) self.blocks_vector_source_x_0 = blocks.vector_source_b( tuple([0, 1, 1, 1, 1, 1, 1, 0] * numRevs), True, 1, []) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, frameTag) self.blocks_tagged_stream_mux_0 = blocks.tagged_stream_mux( gr.sizeof_char * 1, frameTag, 0) self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream( gr.sizeof_char, 1, numRevs * 8, frameTag) self.amateur_Tagged_Nrzi_Encoder_0 = amateur.Tagged_Nrzi_Encoder( frameTag, 1) self.amateur_AX25_Packet_Encoder_0 = amateur.AX25_Packet_Encoder() ################################################## # Connections ################################################## self.msg_connect((self.amateur_AX25_Packet_Encoder_0, 'pkt'), (self.digital_hdlc_framer_pb_0, 'in')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self, 'out')) self.msg_connect((self, 'in'), (self.amateur_AX25_Packet_Encoder_0, 'data')) self.connect((self.amateur_Tagged_Nrzi_Encoder_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tagged_stream_mux_0, 0)) self.connect((self.blocks_tagged_stream_mux_0, 0), (self.amateur_Tagged_Nrzi_Encoder_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.digital_hdlc_framer_pb_0, 0), (self.blocks_tagged_stream_mux_0, 1))
def __init__(self): gr.top_block.__init__(self, "OFDMChatAppRx") ################################################## # Variables ################################################## self.tune_offset = tune_offset = 500e3 self.samp_rate = samp_rate = 500000 self.len_tag_key = len_tag_key = "packet_len" self.fft_len = fft_len = 128 self.decimation = decimation = 4 ################################################## # Blocks ################################################## self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "" ) self.osmosdr_source_0.set_sample_rate(samp_rate*decimation) self.osmosdr_source_0.set_center_freq(400e6-tune_offset, 0) self.osmosdr_source_0.set_freq_corr(0, 0) self.osmosdr_source_0.set_dc_offset_mode(0, 0) self.osmosdr_source_0.set_iq_balance_mode(0, 0) self.osmosdr_source_0.set_gain_mode(0, 0) self.osmosdr_source_0.set_gain(10, 0) self.osmosdr_source_0.set_if_gain(20, 0) self.osmosdr_source_0.set_bb_gain(20, 0) self.osmosdr_source_0.set_antenna("", 0) self.osmosdr_source_0.set_bandwidth(0, 0) self.freq_xlating_fir_filter_xxx_0 = filter.freq_xlating_fir_filter_ccc( decimation, (filter.firdes.low_pass(1.0, samp_rate*decimation, 300e3, 100e3)), tune_offset, samp_rate*decimation ) self.digital_ofdm_rx_0 = digital.ofdm_rx( fft_len=fft_len, cp_len=fft_len/4, frame_length_tag_key='frame_'+"rx_len", packet_length_tag_key="rx_len", bps_header=1, bps_payload=2, debug_log=False, scramble_bits=True ) self.tagged_stream_to_pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, 'rx_len') self.pdu_receiver = fosdem.pdu_receiver() ################################################## # Connections ################################################## self.connect((self.osmosdr_source_0, 0), (self.freq_xlating_fir_filter_xxx_0, 0)) self.connect((self.freq_xlating_fir_filter_xxx_0, 0), (self.digital_ofdm_rx_0, 0), self.tagged_stream_to_pdu) self.msg_connect(self.tagged_stream_to_pdu, "pdus", self.pdu_receiver, "pdus")
def __init__(self, packlen=0, sync='00011010110011111111110000011101', threshold=4): gr.hier_block2.__init__( self, 'Sync and create packed PDU', gr.io_signature(1, 1, gr.sizeof_char * 1), gr.io_signature(0, 0, 0), ) self.message_port_register_hier_out('out') ################################################## # Parameters ################################################## self.packlen = packlen self.sync = sync self.threshold = threshold ################################################## # Blocks ################################################## self.satellites_fixedlen_tagger_0_0_0 = (satellites.fixedlen_tagger( 'syncword', 'packet_len', packlen * 8, numpy.byte)) self.digital_correlate_access_code_tag_bb_0_0_0 = ( digital.correlate_access_code_tag_bb(sync, threshold, 'syncword')) self.blocks_unpacked_to_packed_xx_0 = (blocks.unpacked_to_packed_bb( 1, gr.GR_MSB_FIRST)) self.blocks_tagged_stream_to_pdu_0_0_0 = (blocks.tagged_stream_to_pdu( blocks.byte_t, 'packet_len')) self.blocks_tagged_stream_multiply_length_0 = ( blocks.tagged_stream_multiply_length(gr.sizeof_char * 1, 'packet_len', 1 / 8.0)) ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0_0_0, 'pdus'), (self, 'out')) self.connect((self.blocks_tagged_stream_multiply_length_0, 0), (self.blocks_tagged_stream_to_pdu_0_0_0, 0)) self.connect((self.blocks_unpacked_to_packed_xx_0, 0), (self.blocks_tagged_stream_multiply_length_0, 0)) self.connect((self.digital_correlate_access_code_tag_bb_0_0_0, 0), (self.satellites_fixedlen_tagger_0_0_0, 0)) self.connect((self, 0), (self.digital_correlate_access_code_tag_bb_0_0_0, 0)) self.connect((self.satellites_fixedlen_tagger_0_0_0, 0), (self.blocks_unpacked_to_packed_xx_0, 0))
def test_001_t(self): # set up fg src1 = analog.sig_source_c(512, analog.GR_COS_WAVE, 128, 0.5, 0) op1 = blocks.head(gr.sizeof_gr_complex, 128) op2 = blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, 1, 1, "packet_len") op3 = blocks.tagged_stream_to_pdu(blocks.complex_t, "packet_len") dst = blocks.vector_sink_c(1) DUT = hydra.hydra_async_sink(1, 64, 100e3, 200e3, ((100e3, 200e3), )) self.tb.msg_connect((op3, 'pdus'), (DUT, 'vr0')) self.tb.connect(src1, op1, op2, op3) self.tb.connect(DUT, dst) self.tb.run()
def __init__(self): gr.top_block.__init__(self, "ZMQ RX Test") ################################################## # Variables ################################################## self.tcp_addr_msg_out = zmu.TCP_RX_XFIL self.samp_rate = samp_rate = 1e3 self.preamble = (85, 85, 0, 6, 0, 6, 80, 73, 80, 73, 70, 90, 0, 0, 0, 0, 0, 0, 0) ################################################## # Blocks ################################################## self.zeromq_push_msg_sink_0 = \ zeromq.push_msg_sink(self.tcp_addr_msg_out, 100) self.digital_correlate_access_code_xx_ts_0 = \ digital.correlate_access_code_bb_ts( '0101010101010101', 0, 'packet_len') self.blocks_vector_source_x_0 = \ blocks.vector_source_b( self.preamble, True, 1, []) self.blocks_throttle_0 = \ blocks.throttle(gr.sizeof_char*1, samp_rate,True) self.blocks_tagged_stream_to_pdu_0 = \ blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len') self.blocks_repack_bits_bb_0 = \ blocks.repack_bits_bb(1, 8, 'packet_len', False, gr.GR_MSB_FIRST) self.blocks_packed_to_unpacked_xx_0 = \ blocks.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST) ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.zeromq_push_msg_sink_0, 'in')) self.connect((self.blocks_packed_to_unpacked_xx_0, 0), (self.digital_correlate_access_code_xx_ts_0, 0)) self.connect((self.blocks_repack_bits_bb_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_packed_to_unpacked_xx_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.digital_correlate_access_code_xx_ts_0, 0), (self.blocks_repack_bits_bb_0, 0))
def __init__(self): gr.top_block.__init__(self, "Ber Test") ################################################## # Variables ################################################## self.sps = sps = 4 self.nfilts = nfilts = 32 self.timing_loop_bw = timing_loop_bw = 62.8e-3 self.samp_rate = samp_rate = 32000 self.rrc_taps = rrc_taps = firdes.root_raised_cosine(nfilts, nfilts, 1.0/float(sps), 0.35, 11*sps*nfilts) self.qpsk = qpsk = digital.constellation_rect(([1+1j, -1+1j, -1-1j, 1-1j]), ([0, 1, 2, 3]), 4, 2, 2, 1, 1).base() self.excess_bw = excess_bw = 0.35 ################################################## # Blocks ################################################## self.digital_pfb_clock_sync_xxx_0_0 = digital.pfb_clock_sync_ccf(sps, timing_loop_bw, (rrc_taps), nfilts, nfilts/2, 1.5, 1) self.digital_constellation_modulator_0 = digital.generic_mod( constellation=qpsk, differential=False, samples_per_symbol=sps, pre_diff_code=True, excess_bw=excess_bw, verbose=True, log=False, ) self.digital_constellation_decoder_cb_0_0 = digital.constellation_decoder_cb(qpsk) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len') self.blocks_repack_bits_bb_0_0 = blocks.repack_bits_bb(2, 8, "", False, gr.GR_LSB_FIRST) self.blocks_repack_bits_bb_0 = blocks.repack_bits_bb(8, 2, "", False, gr.GR_LSB_FIRST) self.blocks_random_pdu_0 = blocks.random_pdu(5, 6, chr(0xFF), 2) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len') self.blocks_message_strobe_0 = blocks.message_strobe(pmt.PMT_T, 2000) self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.blocks_random_pdu_0, 'generate')) self.msg_connect((self.blocks_random_pdu_0, 'pdus'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.blocks_message_debug_0, 'print_pdu')) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_repack_bits_bb_0, 0)) self.connect((self.blocks_repack_bits_bb_0, 0), (self.digital_constellation_modulator_0, 0)) self.connect((self.blocks_repack_bits_bb_0_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.digital_constellation_decoder_cb_0_0, 0), (self.blocks_repack_bits_bb_0_0, 0)) self.connect((self.digital_constellation_modulator_0, 0), (self.digital_pfb_clock_sync_xxx_0_0, 0)) self.connect((self.digital_pfb_clock_sync_xxx_0_0, 0), (self.digital_constellation_decoder_cb_0_0, 0))
def __init__(self, callback): gr.hier_block2.__init__(self, "payload_sink_pdu", gr.io_signature(1, 1, gr.sizeof_char * 1), gr.io_signature(0, 0, 0)) self.callback = callback #blocks self.tagged_stream_to_pdu = blocks.tagged_stream_to_pdu( blocks.byte_t, "packet_len") self.check_crc = digital.crc32_async_bb(True) self.msg_sink = ofdm_cr_tools.message_handler(self.callback) # Connections self.connect(self, self.tagged_stream_to_pdu) self.msg_connect((self.tagged_stream_to_pdu, 'pdus'), (self.check_crc, 'in')) self.msg_connect((self.check_crc, 'out'), (self.msg_sink, 'in'))
def setUp(self): self.tb = gr.top_block() self.nfreq_samps = 256 self.freqs = [11. / 256, 41. / 256, 93. / 256] self.corr_reps = 4 self.channel = channels.channel_model( noise_voltage=0.01, frequency_offset=1e-5, epsilon=1.0, taps=[0.8, 0.1, 0.05, 0.01, 0.01, 0.005]) self.channel_in = blocks.pdu_to_tagged_stream(blocks.complex_t, "frame") self.channel_out = blocks.tagged_stream_to_pdu(blocks.complex_t, "frame") self.tb.connect(self.channel_in, self.channel) self.tb.connect(self.channel, self.channel_out)
def test_001_t (self): # set up fg self.src = blocks.vector_source_b(range(12), False, 1, []) self.s2ts = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 4, "packet_len") self.ts2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.zeropadding = ieee802_15_4.zeropadding_b(2) self.snk = blocks.vector_sink_b(1) self.tb.connect(self.src, self.s2ts, self.ts2pdu) self.tb.msg_connect(self.ts2pdu, "pdus", self.zeropadding, "in") self.tb.connect(self.zeropadding, self.snk) self.tb.start() time.sleep(1) self.tb.stop() # check data data = self.snk.data() self.assertFloatTuplesAlmostEqual(data, (0,1,2,3,0,0,4,5,6,7,0,0,8,9,10,11,0,0))
def __init__(self): gr.hier_block2.__init__( self, 'CCSDS descrambler', gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0), ) self.message_port_register_hier_in("in") self.message_port_register_hier_out("out") ################################################## # Blocks ################################################## 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_tagged_stream_multiply_length_0_0_0_0 = ( blocks.tagged_stream_multiply_length( gr.sizeof_char*1, 'packet_len', 1/8.0)) self.blocks_pdu_to_tagged_stream_0 = ( blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len')) ################################################## # Connections ################################################## self.msg_connect( (self.blocks_tagged_stream_to_pdu_0_0_0_0_0, 'pdus'), (self, 'out')) self.msg_connect( (self, 'in'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.connect( (self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_additive_scrambler_bb_0_0, 0)) self.connect( (self.blocks_tagged_stream_multiply_length_0_0_0_0, 0), (self.blocks_tagged_stream_to_pdu_0_0_0_0_0, 0)) self.connect( (self.blocks_unpacked_to_packed_xx_0_0_0_0, 0), (self.blocks_tagged_stream_multiply_length_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))
def run_with_frame_len(self, frame_len): self.tb = gr.top_block() noise = analog.noise_source_f(analog.GR_GAUSSIAN, 1, 0) head = blocks.head(gr.sizeof_float, self.n_frames * frame_len) tag = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, frame_len, "packet_len") stream2pdu = blocks.tagged_stream_to_pdu(blocks.float_t, 'packet_len') viterbi = fec.cc_decoder.make(frame_len//2, 7, 2, [79,-109], 0, -1, fec.CC_TERMINATED, False) cc_decoder = fec.async_decoder(viterbi, False, False, frame_len) self.tb.connect(noise, head, tag, stream2pdu) self.tb.msg_connect((stream2pdu, 'pdus'), (cc_decoder, 'in')) self.tb.run() # the test is considered successful if it hasn't segfaulted or aborted self.tb = None
def __init__(self, syncword_threshold=None, options=None): gr.hier_block2.__init__(self, 'grizu263a_deframer', gr.io_signature(1, 1, gr.sizeof_float), gr.io_signature(0, 0, 0)) options_block.__init__(self, options) self.message_port_register_hier_out('out') if syncword_threshold is None: syncword_threshold = self.options.syncword_threshold self.slicer = digital.binary_slicer_fb() self.sync = sync_to_pdu_packed(packlen=255, sync=_syncword, threshold=syncword_threshold) self.reflect_1 = reflect_bytes() # The scrambler is like the PN9, but uses 0x100 instead of 0x1FF # as seed. self.scrambler = digital.additive_scrambler_bb( 0x21, 0x100, 8, count=0, bits_per_byte=8, reset_tag_key='packet_len') self.stream2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len') self.pdu2stream = blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len') self.reflect_2 = reflect_bytes() self.crop = sx12xx_packet_crop(crc_len=2) self.crc = check_cc11xx_crc(self.options.verbose_crc) self.remove_length = pdu_head_tail(3, 1) self.connect(self, self.slicer, self.sync) self.msg_connect((self.sync, 'out'), (self.reflect_1, 'in')) self.msg_connect((self.reflect_1, 'out'), (self.pdu2stream, 'pdus')) self.connect(self.pdu2stream, self.scrambler, self.stream2pdu) self.msg_connect((self.stream2pdu, 'pdus'), (self.reflect_2, 'in')) self.msg_connect((self.reflect_2, 'out'), (self.crop, 'in')) self.msg_connect((self.crop, 'out'), (self.crc, 'in')) self.msg_connect((self.crc, 'ok'), (self.remove_length, 'in')) self.msg_connect((self.remove_length, 'out'), (self, 'out'))
def __init__(self): gr.hier_block2.__init__( self, 'SI4463 scrambler', gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0), ) self.message_port_register_hier_in('in') self.message_port_register_hier_out('out') ################################################## # Blocks ################################################## self.digital_additive_scrambler_bb_0_0 = ( digital.additive_scrambler_bb( 0x21, 0x1e1, 8, count=0, bits_per_byte=1, reset_tag_key="packet_len")) self.blocks_tagged_stream_to_pdu_0_0 = ( blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len')) self.blocks_tagged_stream_multiply_length_0 = ( blocks.tagged_stream_multiply_length(gr.sizeof_char*1, 'packet_len', 1.0/8)) self.blocks_pdu_to_tagged_stream_0 = ( blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len')) self.blocks_pack_k_bits_bb_0 = blocks.pack_k_bits_bb(8) ################################################## # Connections ################################################## self.msg_connect( (self.blocks_tagged_stream_to_pdu_0_0, 'pdus'), (self, 'out')) self.msg_connect( (self, 'in'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.connect( (self.blocks_pack_k_bits_bb_0, 0), (self.blocks_tagged_stream_multiply_length_0, 0)) self.connect( (self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_additive_scrambler_bb_0_0, 0)) self.connect( (self.blocks_tagged_stream_multiply_length_0, 0), (self.blocks_tagged_stream_to_pdu_0_0, 0)) self.connect( (self.digital_additive_scrambler_bb_0_0, 0), (self.blocks_pack_k_bits_bb_0, 0))
def test_001_t(self): # set up fg self.src = blocks.vector_source_b(range(12), False, 1, []) self.s2ts = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 4, "packet_len") self.ts2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.zeropadding = ieee802_15_4.zeropadding_b(2) self.snk = blocks.vector_sink_b(1) self.tb.connect(self.src, self.s2ts, self.ts2pdu) self.tb.msg_connect(self.ts2pdu, "pdus", self.zeropadding, "in") self.tb.connect(self.zeropadding, self.snk) self.tb.start() time.sleep(1) self.tb.stop() # check data data = self.snk.data() self.assertFloatTuplesAlmostEqual( data, (0, 1, 2, 3, 0, 0, 4, 5, 6, 7, 0, 0, 8, 9, 10, 11, 0, 0))
def test_001_t (self): hash_func = "md5" text = bytearray("ABCDEFGH") exp_result = bytearray(["\x47","\x83","\xe7","\x84","\xb4","\xfa","\x2f","\xba","\x9e","\x4d","\x65","\x02","\xdb","\xc6","\x4f","\x8f"]) src = blocks.vector_source_b(text) stts = blocks.stream_to_tagged_stream(1, 1, 8, "packet_len") tstpdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") hash_block = crypto.hash(hash_func) snk = blocks.message_debug() self.tb.connect(src, stts, tstpdu); self.tb.msg_connect(tstpdu, "pdus", hash_block, "pdus") self.tb.msg_connect(hash_block, "pdus", snk, "store") self.tb.run() hash = bytearray(pmt.u8vector_elements(pmt.cdr((snk.get_message(0))))) self.assertEqual(exp_result, hash)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="tun_source Test") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Blocks ################################################## self.orcatun_tun_source_b_0 = orcatun.tun_source_b("tun3", "packet_len", True) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.blocks_tag_debug_0 = blocks.tag_debug(gr.sizeof_char*1, "tun_source_debug", ""); self.blocks_tag_debug_0.set_display(True) self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.blocks_message_debug_0, 'print_pdu')) self.connect((self.orcatun_tun_source_b_0, 0), (self.blocks_tag_debug_0, 0)) self.connect((self.orcatun_tun_source_b_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0))
def test_001_t (self): # set up fg phr = np.zeros((12,),dtype=int) data1 = np.array([7, 128], dtype=int) data2 = np.array([8, 129], dtype=int) data1_unp = np.unpackbits(np.array(data1,dtype=np.uint8)) data2_unp = np.unpackbits(np.array(data2,dtype=np.uint8)) data_in = np.concatenate((phr, data1_unp, phr, data2_unp)) # blob = pmt.make_blob(data_in, len(data_in)) self.src = blocks.vector_source_b(data_in, False, 1, []) self.s2ts = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 2*8+len(phr), "packet_len") self.ts2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.phr_removal = ieee802_15_4.phr_removal(phr) self.msg_sink = blocks.message_debug() # self.pdu2ts = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") # self.snk = blocks.vector_sink_b(1) self.tb.connect(self.src, self.s2ts, self.ts2pdu) self.tb.msg_connect(self.ts2pdu, "pdus", self.phr_removal, "in") self.tb.msg_connect(self.phr_removal, "out", self.msg_sink, "store") # self.tb.msg_connect(self.phr_removal, "out", self.pdu2ts, "pdus") # self.tb.connect(self.pdu2ts, self.snk) self.tb.start() time.sleep(0.5) self.tb.stop() num_msgs = self.msg_sink.num_messages() self.assertTrue(num_msgs == 2) data_out = [] for i in range(num_msgs): tmp = pmt.to_python(self.msg_sink.get_message(i)) data_out = np.concatenate((data_out, tmp[1])) # check data # data_out = self.snk.data() # print "input:" # for i in data: # print i # print "output:" # for i in data_out: # print data_out ref = np.concatenate((data1,data2)) print "ref:", ref # print "data_out:", data_out self.assertFloatTuplesAlmostEqual(data_out, ref)
def test_004_t (self): # PDU size < fragmentation size, overlap # set up fg self.src = blocks.vector_source_b(range(255), False, 1, []) self.s2ts = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 4, "packet_len") self.ts2pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.frag = ieee802_15_4.fragmentation(6) self.pdu2ts = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.snk = blocks.vector_sink_b(1) self.tb.connect(self.src, self.s2ts, self.ts2pdu) self.tb.msg_connect(self.ts2pdu, "pdus", self.frag, "in") self.tb.msg_connect(self.frag, "out", self.pdu2ts, "pdus") self.tb.connect(self.pdu2ts, self.snk) self.tb.start() time.sleep(1) self.tb.stop() # check data data = [i for i in self.snk.data()] print data self.assertTrue(data==range(252))
def __init__(self): gr.top_block.__init__(self, "TW-1 test decoder") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 48000 self.samp_per_sym = samp_per_sym = 10 self.gain_mu = gain_mu = 0.175*3 ################################################## # Blocks ################################################## self.synctags_fixedlen_tagger_0 = synctags.fixedlen_tagger("syncword", "packet_len", 256*8, numpy.byte) self.low_pass_filter_0 = filter.fir_filter_fff(1, firdes.low_pass( 1, samp_rate, 2400, 2000, firdes.WIN_HAMMING, 6.76)) self.digital_descrambler_bb_0 = digital.descrambler_bb(0x21, 0x00, 16) self.digital_correlate_access_code_tag_bb_0 = digital.correlate_access_code_tag_bb("10010011000010110101000111011110", 4, "syncword") self.digital_clock_recovery_mm_xx_0 = digital.clock_recovery_mm_ff(samp_per_sym*(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.blocks_wavfile_source_0 = blocks.wavfile_source("/tmp/tw-1c.wav", False) self.blocks_unpacked_to_packed_xx_0 = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.blocks_tagged_stream_multiply_length_0 = blocks.tagged_stream_multiply_length(gr.sizeof_char*1, "packet_len", 1/8.0) self.blocks_message_debug_1 = blocks.message_debug() self.ax100_gomx3_rs_decode_0 = ax100.gomx3_rs_decode(True) ################################################## # Connections ################################################## self.msg_connect((self.ax100_gomx3_rs_decode_0, 'out'), (self.blocks_message_debug_1, 'print_pdu')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.ax100_gomx3_rs_decode_0, 'in')) self.connect((self.blocks_tagged_stream_multiply_length_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_unpacked_to_packed_xx_0, 0), (self.blocks_tagged_stream_multiply_length_0, 0)) self.connect((self.blocks_wavfile_source_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.digital_binary_slicer_fb_0, 0), (self.digital_descrambler_bb_0, 0)) self.connect((self.digital_clock_recovery_mm_xx_0, 0), (self.digital_binary_slicer_fb_0, 0)) self.connect((self.digital_correlate_access_code_tag_bb_0, 0), (self.synctags_fixedlen_tagger_0, 0)) self.connect((self.digital_descrambler_bb_0, 0), (self.digital_correlate_access_code_tag_bb_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.digital_clock_recovery_mm_xx_0, 0)) self.connect((self.synctags_fixedlen_tagger_0, 0), (self.blocks_unpacked_to_packed_xx_0, 0))
def __init__(self, fifo_file, poling_rate, pkt_size): gr.hier_block2.__init__(self, "fifo_async_source", gr.io_signature(0,0,0), # Input signature gr.io_signature(0,0,0)) # Output signature self.message_port_register_hier_out("async_pdu") ################################################## # Blocks ################################################## self.mods_file_source_nonblock_0 = mods.file_source_nonblock(fifo_file, poling_rate) self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, pkt_size, "packet_len") self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len') ################################################## # Connections ################################################## self.connect((self.mods_file_source_nonblock_0, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self,"async_pdu"))
def __init__(self): gr.top_block.__init__(self, "Tun Sink Pdu Test") Qt.QWidget.__init__(self) self.setWindowTitle("Tun Sink Pdu Test") 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", "tun_sink_pdu_test") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Blocks ################################################## self.blocks_vector_source_x_0 = blocks.vector_source_b((193, 73, 64, 0, 17, 163, 94, 5, 57, 0, 13, 94, 119, 116, 101, 115, 116, 10), False, 1, []) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, 18, "packet_len") self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.blocks_message_debug_0, 'print_pdu')) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_stream_to_tagged_stream_0, 0))
def __init__(self): gr.top_block.__init__(self, "OFDM Transceiver") Qt.QWidget.__init__(self) self.setWindowTitle("OFDM Transceiver") 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", "ofdm_transceiver") self.restoreGeometry(self.settings.value("geometry").toByteArray()) self._lock = threading.RLock() ################################################## # Variables ################################################## 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.waterfall_min = waterfall_min = -140 self.waterfall_max = waterfall_max = -20 self.tx_gain = tx_gain = 0.01 self.th = th = 10**(-40/10) 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.size = size = 256 self.samp_rate = samp_rate = 2e6 self.period = period = 10 self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 1) self.nsamples = nsamples = 1000 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.center_freq = center_freq = 2.412e9 ################################################## # Blocks ################################################## self.tab = Qt.QTabWidget() self.tab_widget_0 = Qt.QWidget() self.tab_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_0) self.tab_grid_layout_0 = Qt.QGridLayout() self.tab_layout_0.addLayout(self.tab_grid_layout_0) self.tab.addTab(self.tab_widget_0, "Spectrum") self.tab_widget_1 = Qt.QWidget() self.tab_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_1) self.tab_grid_layout_1 = Qt.QGridLayout() self.tab_layout_1.addLayout(self.tab_grid_layout_1) self.tab.addTab(self.tab_widget_1, "Settings") self.top_layout.addWidget(self.tab) self._waterfall_min_range = Range(-200, -50, 1, -140, 200) self._waterfall_min_win = RangeWidget(self._waterfall_min_range, self.set_waterfall_min, "Waterfall Min", "counter_slider", float) self.tab_layout_1.addWidget(self._waterfall_min_win) self._waterfall_max_range = Range(-50, 0, 1, -20, 200) self._waterfall_max_win = RangeWidget(self._waterfall_max_range, self.set_waterfall_max, "Waterfall Max", "counter_slider", float) self.tab_layout_1.addWidget(self._waterfall_max_win) self._samp_rate_options = [1.5e6, 2e6, 4e6, 5e6, 10e6, 20e6 ] self._samp_rate_labels = ["1.5 MHz", "2 MHz", "4 MHz", "5 MHz", "10 MHz", "20 MHz"] self._samp_rate_tool_bar = Qt.QToolBar(self) self._samp_rate_tool_bar.addWidget(Qt.QLabel("Sample Rate [MHz]"+": ")) self._samp_rate_combo_box = Qt.QComboBox() self._samp_rate_tool_bar.addWidget(self._samp_rate_combo_box) for label in self._samp_rate_labels: self._samp_rate_combo_box.addItem(label) self._samp_rate_callback = lambda i: Qt.QMetaObject.invokeMethod(self._samp_rate_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._samp_rate_options.index(i))) self._samp_rate_callback(self.samp_rate) self._samp_rate_combo_box.currentIndexChanged.connect( lambda i: self.set_samp_rate(self._samp_rate_options[i])) self.tab_layout_0.addWidget(self._samp_rate_tool_bar) self._center_freq_options = [868e6, 2.412e9, 2.417e9, 2.422e9, 2.427e9, 2.432e9, 2.437e9, 2.442e9, 2.447e9, 2.452e9, 2.457e9, 2.462e9, 2.467e9, 2.472e9] self._center_freq_labels = ["868M", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"] self._center_freq_tool_bar = Qt.QToolBar(self) self._center_freq_tool_bar.addWidget(Qt.QLabel("Channel"+": ")) self._center_freq_combo_box = Qt.QComboBox() self._center_freq_tool_bar.addWidget(self._center_freq_combo_box) for label in self._center_freq_labels: self._center_freq_combo_box.addItem(label) self._center_freq_callback = lambda i: Qt.QMetaObject.invokeMethod(self._center_freq_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._center_freq_options.index(i))) self._center_freq_callback(self.center_freq) self._center_freq_combo_box.currentIndexChanged.connect( lambda i: self.set_center_freq(self._center_freq_options[i])) self.top_layout.addWidget(self._center_freq_tool_bar) self._tx_gain_range = Range(0, 1, 0.001, 0.01, 200) self._tx_gain_win = RangeWidget(self._tx_gain_range, self.set_tx_gain, "TX Gain", "counter_slider", float) self.top_layout.addWidget(self._tx_gain_win) self._th_range = Range(10**(-80/10), 10**(-10/10), 0.0001, 10**(-40/10), 200) self._th_win = RangeWidget(self._th_range, self.set_th, "Threshold", "counter_slider", float) self.tab_layout_0.addWidget(self._th_win) self.qtgui_waterfall_sink_x_0_0 = qtgui.waterfall_sink_c( 1024, #size firdes.WIN_BLACKMAN_hARRIS, #wintype center_freq, #fc samp_rate, #bw "", #name 1 #number of inputs ) self.qtgui_waterfall_sink_x_0_0.set_update_time(0.01) self.qtgui_waterfall_sink_x_0_0.enable_grid(False) if not True: self.qtgui_waterfall_sink_x_0_0.disable_legend() if complex == type(float()): self.qtgui_waterfall_sink_x_0_0.set_plot_pos_half(not True) labels = ["", "", "", "", "", "", "", "", "", ""] colors = [5, 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_0.set_line_label(i, "Data {0}".format(i)) else: self.qtgui_waterfall_sink_x_0_0.set_line_label(i, labels[i]) self.qtgui_waterfall_sink_x_0_0.set_color_map(i, colors[i]) self.qtgui_waterfall_sink_x_0_0.set_line_alpha(i, alphas[i]) self.qtgui_waterfall_sink_x_0_0.set_intensity_range(waterfall_min, waterfall_max) self._qtgui_waterfall_sink_x_0_0_win = sip.wrapinstance(self.qtgui_waterfall_sink_x_0_0.pyqwidget(), Qt.QWidget) self.tab_layout_0.addWidget(self._qtgui_waterfall_sink_x_0_0_win) self._period_range = Range(1, 10000, 1, 10, 200) self._period_win = RangeWidget(self._period_range, self.set_period, "Period", "counter_slider", float) self.tab_layout_1.addWidget(self._period_win) self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "bladerf=0" ) self.osmosdr_source_0.set_sample_rate(samp_rate) self.osmosdr_source_0.set_center_freq(center_freq, 0) self.osmosdr_source_0.set_freq_corr(0, 0) self.osmosdr_source_0.set_dc_offset_mode(1, 0) self.osmosdr_source_0.set_iq_balance_mode(1, 0) self.osmosdr_source_0.set_gain_mode(False, 0) self.osmosdr_source_0.set_gain(10, 0) self.osmosdr_source_0.set_if_gain(20, 0) self.osmosdr_source_0.set_bb_gain(20, 0) self.osmosdr_source_0.set_antenna("", 0) self.osmosdr_source_0.set_bandwidth(samp_rate, 0) self.digital_ofdm_rx_0 = digital.ofdm_rx( fft_len=64, cp_len=fft_len/4, frame_length_tag_key='frame_'+packet_length_tag_key, packet_length_tag_key=packet_length_tag_key, occupied_carriers=occupied_carriers, pilot_carriers=pilot_carriers, pilot_symbols=pilot_symbols, sync_word1=sync_word1, sync_word2=sync_word2, bps_header=1, bps_payload=1, debug_log=False, scramble_bits=False ) self.dc_blocker_xx_0 = filter.dc_blocker_cc(128, True) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, packet_length_tag_key) self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.blocks_message_debug_0, 'print_pdu')) self.connect((self.dc_blocker_xx_0, 0), (self.digital_ofdm_rx_0, 0)) self.connect((self.dc_blocker_xx_0, 0), (self.qtgui_waterfall_sink_x_0_0, 0)) self.connect((self.digital_ofdm_rx_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.osmosdr_source_0, 0), (self.dc_blocker_xx_0, 0))
def __init__(self): gr.top_block.__init__(self, "Top Block") ################################################## # Variables ################################################## self.rate = rate = 2 self.polys = polys = [109, 79] self.k = k = 7 self.samp_rate = samp_rate = 48000 self.enc_cc = enc_cc = fec.cc_encoder_make(8000, k, rate, (polys), 0, fec.CC_TERMINATED, False) self.dec_cc = dec_cc = fec.cc_decoder.make(8000, k, rate, (polys), 0, -1, fec.CC_TERMINATED, False) ################################################## # Blocks ################################################## self.splash_packet_encoder_0 = splash.packet_encoder( samples_per_symbol=8, bits_per_symbol=1, preamble="", access_code="", pad_for_usrp=False, payload_length=9 ) self.splash_packet_decoder_0 = splash.packet_decoder( access_code="", threshold=-1 ) self.splash_XCEIVER_0 = splash.XCEIVER() self.digital_map_bb_0 = digital.map_bb(([-1,1])) self.dflood_dflood_0 = dflood.dflood( 2, 0, 30, False, False, 5, 65, 2, 120, 50, 2, True, None ) self.blocks_tagged_stream_to_pdu_1 = blocks.tagged_stream_to_pdu(blocks.float_t, "packet_len") self.blocks_repack_bits_bb_0 = blocks.repack_bits_bb(8, 1, "packet_len", True, gr.GR_MSB_FIRST) self.blocks_random_pdu_0_0 = blocks.random_pdu(1, 5, chr(0xFF), 1) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.blocks_message_strobe_2 = blocks.message_strobe(pmt.intern("TEST"), 10000) self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 10000) self.blocks_message_debug_0 = blocks.message_debug() self.blocks_char_to_float_0_1 = blocks.char_to_float(1, 1) self.audio_source_0 = audio.source(48000, "", True) self.audio_sink_0 = audio.sink(48000, "", True) self.analog_probe_avg_mag_sqrd_x_0 = analog.probe_avg_mag_sqrd_c(-70, 1) self.Async_Ecnoder = fec.async_encoder(enc_cc, True, False, False, 1500) self.Async_Decoder = fec.async_decoder(dec_cc, True, False, 1500) ################################################## # Connections ################################################## self.msg_connect((self.Async_Decoder, 'out'), (self.dflood_dflood_0, 'from_radio')) self.msg_connect((self.Async_Ecnoder, 'out'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.blocks_random_pdu_0_0, 'generate')) self.msg_connect((self.blocks_message_strobe_2, 'strobe'), (self.dflood_dflood_0, 'ctrl_in')) self.msg_connect((self.blocks_random_pdu_0_0, 'pdus'), (self.dflood_dflood_0, 'from_app')) self.msg_connect((self.blocks_tagged_stream_to_pdu_1, 'pdus'), (self.Async_Decoder, 'in')) self.msg_connect((self.dflood_dflood_0, 'to_radio'), (self.Async_Ecnoder, 'in')) self.msg_connect((self.dflood_dflood_0, 'to_app'), (self.blocks_message_debug_0, 'print_pdu')) self.connect((self.audio_source_0, 0), (self.splash_XCEIVER_0, 0)) self.connect((self.blocks_char_to_float_0_1, 0), (self.blocks_tagged_stream_to_pdu_1, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.splash_packet_encoder_0, 0)) self.connect((self.blocks_repack_bits_bb_0, 0), (self.digital_map_bb_0, 0)) self.connect((self.digital_map_bb_0, 0), (self.blocks_char_to_float_0_1, 0)) self.connect((self.splash_XCEIVER_0, 2), (self.analog_probe_avg_mag_sqrd_x_0, 0)) self.connect((self.splash_XCEIVER_0, 0), (self.audio_sink_0, 0)) self.connect((self.splash_XCEIVER_0, 1), (self.splash_packet_decoder_0, 0)) self.connect((self.splash_packet_decoder_0, 0), (self.blocks_repack_bits_bb_0, 0)) self.connect((self.splash_packet_encoder_0, 0), (self.splash_XCEIVER_0, 1))
def __init__(self): gr.top_block.__init__(self, "OFDM Transceiver") self._lock = threading.RLock() ################################################## # Variables ################################################## self.sent_pkt = 0 self.rcv_pkt = 0 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.waterfall_min = waterfall_min = -80 self.waterfall_max = waterfall_max = -20 self.tx_gain = tx_gain = 0.03 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 = 20e6 self.payload_equalizer = payload_equalizer = digital.ofdm_equalizer_simpledfe(fft_len, payload_mod.base(), occupied_carriers, pilot_carriers, pilot_symbols, 1) 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.center_freq = center_freq = 2.412e9 ################################################## # Blocks ################################################## self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + "bladerf=1" ) self.osmosdr_source_0.set_sample_rate(samp_rate) self.osmosdr_source_0.set_center_freq(center_freq, 0) self.osmosdr_source_0.set_freq_corr(0, 0) self.osmosdr_source_0.set_dc_offset_mode(1, 0) self.osmosdr_source_0.set_iq_balance_mode(1, 0) self.osmosdr_source_0.set_gain_mode(False, 0) self.osmosdr_source_0.set_gain(10, 0) self.osmosdr_source_0.set_if_gain(20, 0) self.osmosdr_source_0.set_bb_gain(20, 0) self.osmosdr_source_0.set_antenna("", 0) self.osmosdr_source_0.set_bandwidth(samp_rate, 0) self.osmosdr_sink_0 = osmosdr.sink( args="numchan=" + str(1) + " " + "bladerf=0" ) self.osmosdr_sink_0.set_sample_rate(samp_rate) self.osmosdr_sink_0.set_center_freq(center_freq, 0) self.osmosdr_sink_0.set_freq_corr(10, 0) self.osmosdr_sink_0.set_gain(20, 0) self.osmosdr_sink_0.set_if_gain(20, 0) self.osmosdr_sink_0.set_bb_gain(0, 0) self.osmosdr_sink_0.set_antenna("", 0) self.osmosdr_sink_0.set_bandwidth(samp_rate, 0) self.digital_ofdm_tx_0 = digital.ofdm_tx( fft_len=64, cp_len=fft_len/4, packet_length_tag_key=packet_length_tag_key, occupied_carriers=occupied_carriers, pilot_carriers=pilot_carriers, pilot_symbols=pilot_symbols, sync_word1=sync_word1, sync_word2=sync_word2, bps_header=1, bps_payload=1, rolloff=0, debug_log=True, scramble_bits=False ) self.digital_ofdm_rx_0 = digital.ofdm_rx( fft_len=64, cp_len=fft_len/4, frame_length_tag_key='frame_'+packet_length_tag_key, packet_length_tag_key=packet_length_tag_key, occupied_carriers=occupied_carriers, pilot_carriers=pilot_carriers, pilot_symbols=pilot_symbols, sync_word1=sync_word1, sync_word2=sync_word2, bps_header=1, bps_payload=1, debug_log=False, scramble_bits=False ) self.dc_blocker_xx_0 = filter.dc_blocker_cc(1024, False) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, packet_length_tag_key) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, packet_length_tag_key) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((tx_gain, )) self.blocks_message_debug_0 = blocks.message_debug() self.pdu_block = messaging.pdu_block(self) ################################################## # Connections ################################################## self.msg_connect((self.pdu_block, 'out_pdu'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.pdu_block, 'in_pdu')) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.osmosdr_sink_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_ofdm_tx_0, 0)) self.connect((self.dc_blocker_xx_0, 0), (self.digital_ofdm_rx_0, 0)) self.connect((self.digital_ofdm_rx_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.digital_ofdm_tx_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.osmosdr_source_0, 0), (self.dc_blocker_xx_0, 0))
def __init__(self,**param): gr.top_block.__init__(self, "Dl Recv") ################################################## # Variables ################################################## try: if param['Bandwidth'] == '1.4': self.prbl = prbl = 6 self.fftl = fftl = 128 self.multiply_const = multiply_const = 128.0 else: self.prbl = prbl = 15 self.fftl = fftl = 256 self.multiply_const = multiply_const = 256.0 if param['samp_rate_T'] == '2M': self.samp_rate = samp_rate = 2000000 else: self.samp_rate = samp_rate = 4000000 self.threshold = threshold = float(param['Threshold']) self.gain = gain = int(param['gain_r_T']) self.RNTI_A = RNTI_A = int(param['RNTI_A']) self.sacle_0 = sacle_0 = 1024 self.sacle = sacle = 1024 except: print '变量初始化失败' ################################################## # Blocks ################################################## self.uhd_usrp_source_0 = uhd.usrp_source( device_addr="addr=192.168.10.2", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_source_0.set_samp_rate(samp_rate) self.uhd_usrp_source_0.set_center_freq(2.0e7, 0) self.uhd_usrp_source_0.set_gain(gain, 0) self.lte_sat_layer2_ue_0 = lte_sat.layer2_ue(RNTI_A) self.lte_sat_dl_subframe_demapper_0 = lte_sat.dl_subframe_demapper(RNTI_A) self.lte_sat_dl_baseband_sync_0 = lte_sat.dl_baseband_sync(threshold) self.blocks_tagged_stream_to_pdu_0_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.blocks_null_source_0 = blocks.null_source(gr.sizeof_char*1) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((multiply_const, )) self.blocks_char_to_float_0_0 = blocks.char_to_float(1, 1024) self.audio_sink_0_0 = audio.sink(48000, "", True) ################################################## # Connections ################################################## self.connect((self.blocks_null_source_0, 0), (self.blocks_tagged_stream_to_pdu_0_0, 0)) self.connect((self.uhd_usrp_source_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.lte_sat_dl_subframe_demapper_0, 0), (self.lte_sat_layer2_ue_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_char_to_float_0_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.lte_sat_dl_baseband_sync_0, 0)) self.connect((self.blocks_char_to_float_0_0, 0), (self.audio_sink_0_0, 0)) self.connect((self.lte_sat_dl_baseband_sync_0, 0), (self.lte_sat_dl_subframe_demapper_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.lte_sat_dl_baseband_sync_0, "sys_info", self.lte_sat_dl_subframe_demapper_0, "sys_info") self.msg_connect(self.lte_sat_layer2_ue_0, "sdus", self.blocks_pdu_to_tagged_stream_0, "pdus") self.msg_connect(self.blocks_tagged_stream_to_pdu_0_0, "pdus", self.lte_sat_layer2_ue_0, "pdus") self.msg_connect(self.lte_sat_dl_subframe_demapper_0, "usg", self.lte_sat_layer2_ue_0, "usg")
def receiver(self): log = logging.getLogger('master.BlockFactory') t = self.vars_receive() ################################################## # Blocks - build blocks for their functionality ################################################## #FFT In Block if self.FFTIN: if self.tk_context != None: t.wxgui_fftsink2_0 = self.make_fftsink(self.tk_context, "FFT IN") else: #Set the ownership accordingly t.wxgui_fftsink2_0 = self.make_fftsink(t, "FFT IN") t.Add(t.wxgui_fftsink2_0.win) if self.waterfall: t.wxgui_waterfallsink2_0 = waterfallsink2.waterfall_sink_c( t.GetWin(), baseband_freq=0, dynamic_range=100, ref_level=0, ref_scale=2.0, sample_rate=self.samp_rate, fft_size=512, fft_rate=15, average=False, avg_alpha=None, title="Waterfall Plot", ) t.Add(t.wxgui_waterfallsink2_0.win) t.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") #Tunsink if self.tun_handler != None: t.orcatun_tun_sink_pdu_0 = orcatun.tun_sink_pdu(self.tun_handler, str(self.ot)) else: #implement tun_handler log.error("No TunHandler specified") sys.exit(1) #Decimator resampler t.rational_resampler_xxx_0_0_0_3 = self.make_resampler(1, self.interpolation_values[4] ) t.rational_resampler_xxx_0_0_0_2 = self.make_resampler(1, self.interpolation_values[3] ) t.rational_resampler_xxx_0_0_0_1 = self.make_resampler(1, self.interpolation_values[2] ) t.rational_resampler_xxx_0_0_0_0 = self.make_resampler(1, self.interpolation_values[1] ) t.rational_resampler_xxx_0_0_0 = self.make_resampler(1, self.interpolation_values[0] ) #frame decoder t.orcatun_frame_decoder_0 = orcatun.frame_decoder("packet_len", self.samp_rate, self.crc) #Low pass frequence filter t.freq_xlating_fir_filter_xxx_0_0 = self.make_lowpassfrqfilter() #Complex bandpass filter t.fft_filter_xxx_0 = self.make_fft_filter() t.fft_filter_xxx_0.declare_sample_delay(0) #GFSK demod t.digital_gfsk_demod_0 = self.make_gfsk_demod() #Multiply constance t.blocks_multiply_const_vxx_0 = self.multiply_const((1, )) #float o complex t.blocks_float_to_complex_0 = self.float_to_complex(1) #File sinks (currently made here #t.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, "./rec.txt", False) #t.blocks_file_sink_0.set_unbuffered(True) #Audio source t.audio_source_0 = audio.source(self.samp_rate, "", True) #DEBUG t.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections - Relate blocks to each other ################################################## t.connect((t.audio_source_0, 0), (t.blocks_float_to_complex_0, 0)) if self.waterfall: t.connect((t.blocks_float_to_complex_0, 0), (t.wxgui_waterfallsink2_0, 0)) t.connect((t.blocks_float_to_complex_0, 0), (t.blocks_multiply_const_vxx_0, 0)) t.connect((t.blocks_multiply_const_vxx_0, 0), (t.fft_filter_xxx_0, 0)) t.connect((t.digital_gfsk_demod_0, 0), (t.orcatun_frame_decoder_0, 0)) t.connect((t.fft_filter_xxx_0, 0), (t.freq_xlating_fir_filter_xxx_0_0, 0)) t.connect((t.freq_xlating_fir_filter_xxx_0_0, 0), (t.rational_resampler_xxx_0_0_0, 0)) if self.FFTIN: t.connect((t.freq_xlating_fir_filter_xxx_0_0, 0), (t.wxgui_fftsink2_0, 0)) #t.connect((t.orcatun_frame_decoder_0, 0), (t.blocks_file_sink_0, 0)) t.connect((t.orcatun_frame_decoder_0, 0), (t.blocks_tagged_stream_to_pdu_0, 0)) t.msg_connect((t.blocks_tagged_stream_to_pdu_0, 'pdus'), (t.orcatun_tun_sink_pdu_0, 'packet')) t.msg_connect((t.blocks_tagged_stream_to_pdu_0, 'pdus'), (t.blocks_message_debug_0, 'print_pdu')) t.connect((t.rational_resampler_xxx_0_0_0, 0), (t.rational_resampler_xxx_0_0_0_0, 0)) t.connect((t.rational_resampler_xxx_0_0_0_0, 0), (t.rational_resampler_xxx_0_0_0_2, 0)) t.connect((t.rational_resampler_xxx_0_0_0_1, 0), (t.digital_gfsk_demod_0, 0)) t.connect((t.rational_resampler_xxx_0_0_0_2, 0), (t.rational_resampler_xxx_0_0_0_3, 0)) t.connect((t.rational_resampler_xxx_0_0_0_3, 0), (t.rational_resampler_xxx_0_0_0_1, 0)) #t.msg_connect((t.blocks_tagged_stream_to_pdu_0, 'pdus'), (t.blocks_message_debug_0, 'print')) return t
def __init__(self): gr.top_block.__init__(self, "Test Channel Number2") Qt.QWidget.__init__(self) self.setWindowTitle("Test Channel Number2") 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", "Test_channel_Number2") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.packet_size_gige = packet_size_gige = 1024 self.samp_rate = samp_rate = 20e6 self.packet_size = packet_size = packet_size_gige self.cucala = cucala = 2.5e6 self.RF_freq = RF_freq = 943e6 ################################################## # Blocks ################################################## self.spectsensing_subband_selector_0 = spectsensing.subband_selector(40, 40) self.qtgui_time_sink_x_0_0 = qtgui.time_sink_f( 1024, #size samp_rate/1e5/40, #samp_rate "QT GUI Plot", #name 1 #number of inputs ) self.qtgui_time_sink_x_0_0.set_update_time(0.10) self.qtgui_time_sink_x_0_0.set_y_axis(-1, 1) self.qtgui_time_sink_x_0_0.enable_tags(-1, True) self.qtgui_time_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self._qtgui_time_sink_x_0_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_time_sink_x_0_0_win) self.qtgui_time_sink_x_0 = qtgui.time_sink_f( 2048, #size samp_rate/1e5, #samp_rate "QT GUI Plot", #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.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_win = sip.wrapinstance(self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_time_sink_x_0_win) self.nutaq_radio420_tx_0_0 = nutaq.radio420_tx("nutaq_carrier_perseus_TX", 2, 1) self.nutaq_radio420_tx_0_0.set_default_enable(1) self.nutaq_radio420_tx_0_0.set_default_tx_freq(RF_freq) self.nutaq_radio420_tx_0_0.set_default_reference(0) self.nutaq_radio420_tx_0_0.set_default_datarate(samp_rate*2) self.nutaq_radio420_tx_0_0.set_default_calibrate(0) self.nutaq_radio420_tx_0_0.set_default_band(1) self.nutaq_radio420_tx_0_0.set_default_update_rate(1) self.nutaq_radio420_tx_0_0.set_default_tx_vga1_gain(-10) self.nutaq_radio420_tx_0_0.set_default_tx_vga2_gain(15) self.nutaq_radio420_tx_0_0.set_default_tx_gain3(3) self.nutaq_radio420_tx_0_0.set_default_tx_lpf_bandwidth(1) self.nutaq_radio420_tx_0_0.set_default_ref_clk_ctrl(0) self.nutaq_radio420_tx_0_0.set_default_rf_ctrl(0) self.nutaq_radio420_tx_0_0.set_default_tx_gain_ctrl(0) self.nutaq_radio420_tx_0_0.set_default_pll_cpld_ctrl(0) self.nutaq_radio420_tx_0 = nutaq.radio420_tx("nutaq_carrier_perseus_TX", 1, 0) self.nutaq_radio420_tx_0.set_default_enable(1) self.nutaq_radio420_tx_0.set_default_tx_freq(RF_freq) self.nutaq_radio420_tx_0.set_default_reference(0) self.nutaq_radio420_tx_0.set_default_datarate(samp_rate*2) self.nutaq_radio420_tx_0.set_default_calibrate(0) self.nutaq_radio420_tx_0.set_default_band(1) self.nutaq_radio420_tx_0.set_default_update_rate(1) self.nutaq_radio420_tx_0.set_default_tx_vga1_gain(-10) self.nutaq_radio420_tx_0.set_default_tx_vga2_gain(15) self.nutaq_radio420_tx_0.set_default_tx_gain3(3) self.nutaq_radio420_tx_0.set_default_tx_lpf_bandwidth(1) self.nutaq_radio420_tx_0.set_default_ref_clk_ctrl(0) self.nutaq_radio420_tx_0.set_default_rf_ctrl(0) self.nutaq_radio420_tx_0.set_default_tx_gain_ctrl(1) self.nutaq_radio420_tx_0.set_default_pll_cpld_ctrl(0) self.nutaq_radio420_rx_0_0 = nutaq.radio420_rx("nutaq_carrier_perseus_TX", 2, 3) self.nutaq_radio420_rx_0_0.set_default_enable(1) self.nutaq_radio420_rx_0_0.set_default_rx_freq(RF_freq) self.nutaq_radio420_rx_0_0.set_default_reference(0) self.nutaq_radio420_rx_0_0.set_default_datarate(samp_rate*2) self.nutaq_radio420_rx_0_0.set_default_calibrate(0) self.nutaq_radio420_rx_0_0.set_default_band(1) self.nutaq_radio420_rx_0_0.set_default_update_rate(1) self.nutaq_radio420_rx_0_0.set_default_rx_lna_gain(2) self.nutaq_radio420_rx_0_0.set_default_rx_vga1_gain(2) self.nutaq_radio420_rx_0_0.set_default_rx_gain2(0) self.nutaq_radio420_rx_0_0.set_default_rx_gain3(-8) self.nutaq_radio420_rx_0_0.set_default_rx_rf_filter(2) self.nutaq_radio420_rx_0_0.set_default_rx_lpf_bandwidth(1) self.nutaq_radio420_rx_0_0.set_default_ref_clk_ctrl(0) self.nutaq_radio420_rx_0_0.set_default_rf_ctrl(0) self.nutaq_radio420_rx_0_0.set_default_rx_gain_ctrl(0) self.nutaq_radio420_rx_0_0.set_default_pll_cpld_ctrl(0) self.nutaq_radio420_rx_0 = nutaq.radio420_rx("nutaq_carrier_perseus_TX", 1, 2) self.nutaq_radio420_rx_0.set_default_enable(1) self.nutaq_radio420_rx_0.set_default_rx_freq(RF_freq) self.nutaq_radio420_rx_0.set_default_reference(0) self.nutaq_radio420_rx_0.set_default_datarate(samp_rate*2) self.nutaq_radio420_rx_0.set_default_calibrate(0) self.nutaq_radio420_rx_0.set_default_band(1) self.nutaq_radio420_rx_0.set_default_update_rate(1) self.nutaq_radio420_rx_0.set_default_rx_lna_gain(2) self.nutaq_radio420_rx_0.set_default_rx_vga1_gain(2) self.nutaq_radio420_rx_0.set_default_rx_gain2(0) self.nutaq_radio420_rx_0.set_default_rx_gain3(-8) self.nutaq_radio420_rx_0.set_default_rx_rf_filter(2) self.nutaq_radio420_rx_0.set_default_rx_lpf_bandwidth(1) self.nutaq_radio420_rx_0.set_default_ref_clk_ctrl(0) self.nutaq_radio420_rx_0.set_default_rf_ctrl(0) self.nutaq_radio420_rx_0.set_default_rx_gain_ctrl(0) self.nutaq_radio420_rx_0.set_default_pll_cpld_ctrl(0) self.nutaq_custom_register_0_1_1 = nutaq.custom_register("nutaq_carrier_perseus_TX",9) self.nutaq_custom_register_0_1_1.set_index(6) self.nutaq_custom_register_0_1_1.set_default_value(820) self.nutaq_custom_register_0_1_1.set_update_rate(1) self.nutaq_custom_register_0_1_0 = nutaq.custom_register("nutaq_carrier_perseus_TX",7) self.nutaq_custom_register_0_1_0.set_index(2) self.nutaq_custom_register_0_1_0.set_update_rate(1) self.nutaq_custom_register_0_1 = nutaq.custom_register("nutaq_carrier_perseus_TX",6) self.nutaq_custom_register_0_1.set_index(0) self.nutaq_custom_register_0_1.set_update_rate(1) self.nutaq_custom_register_0_0_0 = nutaq.custom_register("nutaq_carrier_perseus_TX",8) self.nutaq_custom_register_0_0_0.set_index(3) self.nutaq_custom_register_0_0_0.set_default_value(7) self.nutaq_custom_register_0_0_0.set_update_rate(1) self.nutaq_custom_register_0_0 = nutaq.custom_register("nutaq_carrier_perseus_TX",5) self.nutaq_custom_register_0_0.set_index(4) self.nutaq_custom_register_0_0.set_default_value(1) self.nutaq_custom_register_0_0.set_update_rate(1) self.nutaq_custom_register_0 = nutaq.custom_register("nutaq_carrier_perseus_TX",4) self.nutaq_custom_register_0.set_index(1) self.nutaq_custom_register_0.set_update_rate(1) self.nutaq_carrier_perseus_TX = nutaq.carrier(0,"nutaq_carrier_perseus_TX", "192.168.0.101") self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1, samp_rate/1e4,True) self.blocks_tags_strobe_0 = blocks.tags_strobe(gr.sizeof_float*1, pmt.intern("TEST"), 1000, pmt.intern("strobe")) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.float_t, "packet_len") self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_float*1, 40) self.blocks_message_debug_0 = blocks.message_debug() self.blocks_float_to_int_0_0_0 = blocks.float_to_int(1, 1) self.blocks_float_to_int_0_0 = blocks.float_to_int(1, 1) self.blocks_add_xx_0 = blocks.add_vff(1) self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate/1e5, analog.GR_COS_WAVE, 10, 1, 0) self.analog_const_source_x_0_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, 1e5*(2**32)/samp_rate) self.analog_const_source_x_0 = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, ( cucala)/samp_rate*(2**32)) ################################################## # Connections ################################################## self.connect((self.blocks_float_to_int_0_0, 0), (self.nutaq_custom_register_0_1_0, 0)) self.connect((self.blocks_float_to_int_0_0_0, 0), (self.nutaq_custom_register_0_1, 0)) self.connect((self.analog_const_source_x_0, 0), (self.blocks_float_to_int_0_0_0, 0)) self.connect((self.analog_const_source_x_0_0, 0), (self.blocks_float_to_int_0_0, 0)) self.connect((self.blocks_stream_to_vector_0, 0), (self.spectsensing_subband_selector_0, 1)) self.connect((self.blocks_stream_to_vector_0, 0), (self.spectsensing_subband_selector_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_stream_to_vector_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.spectsensing_subband_selector_0, 0), (self.qtgui_time_sink_x_0_0, 0)) self.connect((self.blocks_tags_strobe_0, 0), (self.blocks_add_xx_0, 1)) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_add_xx_0, 0)) self.connect((self.blocks_add_xx_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.blocks_tagged_stream_to_pdu_0, "pdus", self.blocks_message_debug_0, "print") self.msg_connect(self.blocks_tagged_stream_to_pdu_0, "pdus", self.blocks_message_debug_0, "print_pdu")
self.callback(msg_str) else: print msg_str if meta is not None: print "[METADATA]: ", meta if __name__ == "__main__": import time # Create a flow graph tb = gr.top_block() # Create chat blocks chat_tx = message_pdu(None) chat_rx = message_pdu(None) pdu_to_tagged_stream = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") tagged_stream_to_pdu = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") # Connect them up tb.msg_connect(chat_tx, 'out', chat_rx, 'in') # Start flow graph tb.start() chat_str = "" print "======= Chat/Message Passing Tester. Please type a message (type /quit to exit) =========" try: while chat_str != "/quit": chat_str = raw_input('> ') chat_tx.post_message("freq.", chat_str) time.sleep(0.1) except KeyboardInterrupt: print "\n" except EOFError: print "\n"
def __init__(self): gr.top_block.__init__(self, "OFDM PU Phy") Qt.QWidget.__init__(self) self.setWindowTitle("OFDM PU Phy") 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", "tx_ofdm_newv") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 10e6 self.taps = taps = filter.firdes.low_pass(1,samp_rate, 0.98e6,0.5e6) 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.pilot_symbols = pilot_symbols = ((1, 1, 1, -1,),) self.pilot_carriers = pilot_carriers = ((-21, -7, 7, 21,),) self.packet_len = packet_len = 64 self.occupied_carriers = occupied_carriers = (range(-26, -21) + range(-20, -7) + range(-6, 0) + range(1, 7) + range(8, 21) + range(22, 27),) self.len_tag_key = len_tag_key = "packet_len" self.interp_factor = interp_factor = 5 self.fft_len = fft_len = 64 self.decim_factor = decim_factor = 1 ################################################## # Blocks ################################################## self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(("addr=192.168.10.2", "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0.set_samp_rate(samp_rate) self.uhd_usrp_sink_0.set_center_freq(1255e6, 0) self.uhd_usrp_sink_0.set_gain(15, 0) self.uhd_usrp_sink_0.set_antenna("TX/RX", 0) self.rational_resampler_xxx_0_0_1_1 = filter.rational_resampler_ccc( interpolation=interp_factor, decimation=decim_factor, taps=(taps), fractional_bw=None, ) self.rational_resampler_xxx_0_0_1_0 = filter.rational_resampler_ccc( interpolation=interp_factor, decimation=decim_factor, taps=(taps), fractional_bw=None, ) self.rational_resampler_xxx_0_0_1 = filter.rational_resampler_ccc( interpolation=interp_factor, decimation=decim_factor, taps=(taps), fractional_bw=None, ) self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc( interpolation=interp_factor, decimation=decim_factor, taps=(taps), fractional_bw=None, ) self.digital_ofdm_tx_0 = digital.ofdm_tx( fft_len=fft_len, cp_len=fft_len/4, packet_length_tag_key=len_tag_key, occupied_carriers=occupied_carriers, pilot_carriers=pilot_carriers, pilot_symbols=pilot_symbols, sync_word1=sync_word1, sync_word2=sync_word2, bps_header=1, bps_payload=2, rolloff=0, debug_log=False, scramble_bits=False ) self.dbconnect_packet_controller_0 = dbconnect.packet_controller(samp_rate/interp_factor, (10000,), 5, 10, 2, 20, 10, 5, 6643, 30000, (10,20,30), (0,1,2), True) self.dbconnect_cmd_pktgen_0 = dbconnect.cmd_pktgen("127.0.0.1", 5002, 64, True) self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.complex_t, "packet_len") self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.blocks_multiply_xx_0_3 = blocks.multiply_vcc(1) self.blocks_multiply_xx_0_2 = blocks.multiply_vcc(1) self.blocks_multiply_xx_0_1 = blocks.multiply_vcc(1) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.09, )) self.blocks_message_debug_0 = blocks.message_debug() self.blocks_add_xx_2 = blocks.add_vcc(1) self.analog_sig_source_x_0_3 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, -3.75e6, 1, 0) self.analog_sig_source_x_0_2 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 3.75e6, 1, 0) self.analog_sig_source_x_0_1 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, -1.25e6, 1, 0) self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, 1.25e6, 1, 0) ################################################## # Connections ################################################## self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.dbconnect_packet_controller_0, 'in0')) self.msg_connect((self.dbconnect_cmd_pktgen_0, 'out0'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.dbconnect_packet_controller_0, 'gcmd'), (self.blocks_message_debug_0, 'print')) self.msg_connect((self.dbconnect_packet_controller_0, 'cmd'), (self.dbconnect_cmd_pktgen_0, 'cmd')) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.analog_sig_source_x_0_1, 0), (self.blocks_multiply_xx_0_1, 1)) self.connect((self.analog_sig_source_x_0_2, 0), (self.blocks_multiply_xx_0_2, 1)) self.connect((self.analog_sig_source_x_0_3, 0), (self.blocks_multiply_xx_0_3, 1)) self.connect((self.blocks_add_xx_2, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.blocks_multiply_xx_0, 0), (self.blocks_add_xx_2, 0)) self.connect((self.blocks_multiply_xx_0_1, 0), (self.blocks_add_xx_2, 1)) self.connect((self.blocks_multiply_xx_0_2, 0), (self.blocks_add_xx_2, 2)) self.connect((self.blocks_multiply_xx_0_3, 0), (self.blocks_add_xx_2, 3)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_ofdm_tx_0, 0)) self.connect((self.dbconnect_packet_controller_0, 0), (self.rational_resampler_xxx_0_0, 0)) self.connect((self.dbconnect_packet_controller_0, 1), (self.rational_resampler_xxx_0_0_1, 0)) self.connect((self.dbconnect_packet_controller_0, 2), (self.rational_resampler_xxx_0_0_1_0, 0)) self.connect((self.dbconnect_packet_controller_0, 3), (self.rational_resampler_xxx_0_0_1_1, 0)) self.connect((self.digital_ofdm_tx_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.rational_resampler_xxx_0_0, 0), (self.blocks_multiply_xx_0, 0)) self.connect((self.rational_resampler_xxx_0_0_1, 0), (self.blocks_multiply_xx_0_1, 0)) self.connect((self.rational_resampler_xxx_0_0_1_0, 0), (self.blocks_multiply_xx_0_2, 0)) self.connect((self.rational_resampler_xxx_0_0_1_1, 0), (self.blocks_multiply_xx_0_3, 0))
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") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 10e6 self.pdu_length = pdu_length = 500 self.lo_offset = lo_offset = 0 self.gain = gain = 0.75 self.freq = freq = 5890000000 self.encoding = encoding = [0,0,0,0,0] self.chan_est = chan_est = 0 ################################################## # Blocks ################################################## self.frequencyAdaptiveOFDM_mac_and_parse_0 = frequencyAdaptiveOFDM.mac_and_parse(([0x42, 0x42, 0x42, 0x42, 0x42, 0x42]), ([0x23, 0x23, 0x23, 0x23, 0x23, 0x23]), ([0xff, 0xff, 0xff, 0xff, 0xff, 0xff]), False, True, '/tmp/tx_packets.csv', '/tmp/rx_packets.csv') self._samp_rate_options = [5e6, 10e6, 20e6] self._samp_rate_labels = ["5 MHz", "10 MHz", "20 MHz"] self._samp_rate_tool_bar = Qt.QToolBar(self) self._samp_rate_tool_bar.addWidget(Qt.QLabel("samp_rate"+": ")) self._samp_rate_combo_box = Qt.QComboBox() self._samp_rate_tool_bar.addWidget(self._samp_rate_combo_box) for label in self._samp_rate_labels: self._samp_rate_combo_box.addItem(label) self._samp_rate_callback = lambda i: Qt.QMetaObject.invokeMethod(self._samp_rate_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._samp_rate_options.index(i))) self._samp_rate_callback(self.samp_rate) self._samp_rate_combo_box.currentIndexChanged.connect( lambda i: self.set_samp_rate(self._samp_rate_options[i])) self.top_layout.addWidget(self._samp_rate_tool_bar) self._pdu_length_range = Range(0, 1500, 1, 500, 200) self._pdu_length_win = RangeWidget(self._pdu_length_range, self.set_pdu_length, "pdu_length", "counter_slider", int) self.top_layout.addWidget(self._pdu_length_win) self._lo_offset_options = (0, 6e6, 11e6, ) self._lo_offset_labels = (str(self._lo_offset_options[0]), str(self._lo_offset_options[1]), str(self._lo_offset_options[2]), ) self._lo_offset_tool_bar = Qt.QToolBar(self) self._lo_offset_tool_bar.addWidget(Qt.QLabel("lo_offset"+": ")) self._lo_offset_combo_box = Qt.QComboBox() self._lo_offset_tool_bar.addWidget(self._lo_offset_combo_box) for label in self._lo_offset_labels: self._lo_offset_combo_box.addItem(label) self._lo_offset_callback = lambda i: Qt.QMetaObject.invokeMethod(self._lo_offset_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._lo_offset_options.index(i))) self._lo_offset_callback(self.lo_offset) self._lo_offset_combo_box.currentIndexChanged.connect( lambda i: self.set_lo_offset(self._lo_offset_options[i])) self.top_layout.addWidget(self._lo_offset_tool_bar) self._gain_range = Range(0, 1, 0.01, 0.75, 200) self._gain_win = RangeWidget(self._gain_range, self.set_gain, "gain", "counter_slider", float) self.top_layout.addWidget(self._gain_win) self._freq_options = [2412000000.0, 2417000000.0, 2422000000.0, 2427000000.0, 2432000000.0, 2437000000.0, 2442000000.0, 2447000000.0, 2452000000.0, 2457000000.0, 2462000000.0, 2467000000.0, 2472000000.0, 2484000000.0, 5170000000.0, 5180000000.0, 5190000000.0, 5200000000.0, 5210000000.0, 5220000000.0, 5230000000.0, 5240000000.0, 5250000000.0, 5260000000.0, 5270000000.0, 5280000000.0, 5290000000.0, 5300000000.0, 5310000000.0, 5320000000.0, 5500000000.0, 5510000000.0, 5520000000.0, 5530000000.0, 5540000000.0, 5550000000.0, 5560000000.0, 5570000000.0, 5580000000.0, 5590000000.0, 5600000000.0, 5610000000.0, 5620000000.0, 5630000000.0, 5640000000.0, 5660000000.0, 5670000000.0, 5680000000.0, 5690000000.0, 5700000000.0, 5710000000.0, 5720000000.0, 5745000000.0, 5755000000.0, 5765000000.0, 5775000000.0, 5785000000.0, 5795000000.0, 5805000000.0, 5825000000.0, 5860000000.0, 5870000000.0, 5880000000.0, 5890000000.0, 5900000000.0, 5910000000.0, 5920000000.0] self._freq_labels = [' 1 | 2412.0 | 11g', ' 2 | 2417.0 | 11g', ' 3 | 2422.0 | 11g', ' 4 | 2427.0 | 11g', ' 5 | 2432.0 | 11g', ' 6 | 2437.0 | 11g', ' 7 | 2442.0 | 11g', ' 8 | 2447.0 | 11g', ' 9 | 2452.0 | 11g', ' 10 | 2457.0 | 11g', ' 11 | 2462.0 | 11g', ' 12 | 2467.0 | 11g', ' 13 | 2472.0 | 11g', ' 14 | 2484.0 | 11g', ' 34 | 5170.0 | 11a', ' 36 | 5180.0 | 11a', ' 38 | 5190.0 | 11a', ' 40 | 5200.0 | 11a', ' 42 | 5210.0 | 11a', ' 44 | 5220.0 | 11a', ' 46 | 5230.0 | 11a', ' 48 | 5240.0 | 11a', ' 50 | 5250.0 | 11a', ' 52 | 5260.0 | 11a', ' 54 | 5270.0 | 11a', ' 56 | 5280.0 | 11a', ' 58 | 5290.0 | 11a', ' 60 | 5300.0 | 11a', ' 62 | 5310.0 | 11a', ' 64 | 5320.0 | 11a', '100 | 5500.0 | 11a', '102 | 5510.0 | 11a', '104 | 5520.0 | 11a', '106 | 5530.0 | 11a', '108 | 5540.0 | 11a', '110 | 5550.0 | 11a', '112 | 5560.0 | 11a', '114 | 5570.0 | 11a', '116 | 5580.0 | 11a', '118 | 5590.0 | 11a', '120 | 5600.0 | 11a', '122 | 5610.0 | 11a', '124 | 5620.0 | 11a', '126 | 5630.0 | 11a', '128 | 5640.0 | 11a', '132 | 5660.0 | 11a', '134 | 5670.0 | 11a', '136 | 5680.0 | 11a', '138 | 5690.0 | 11a', '140 | 5700.0 | 11a', '142 | 5710.0 | 11a', '144 | 5720.0 | 11a', '149 | 5745.0 | 11a (SRD)', '151 | 5755.0 | 11a (SRD)', '153 | 5765.0 | 11a (SRD)', '155 | 5775.0 | 11a (SRD)', '157 | 5785.0 | 11a (SRD)', '159 | 5795.0 | 11a (SRD)', '161 | 5805.0 | 11a (SRD)', '165 | 5825.0 | 11a (SRD)', '172 | 5860.0 | 11p', '174 | 5870.0 | 11p', '176 | 5880.0 | 11p', '178 | 5890.0 | 11p', '180 | 5900.0 | 11p', '182 | 5910.0 | 11p', '184 | 5920.0 | 11p'] self._freq_tool_bar = Qt.QToolBar(self) self._freq_tool_bar.addWidget(Qt.QLabel("freq"+": ")) self._freq_combo_box = Qt.QComboBox() self._freq_tool_bar.addWidget(self._freq_combo_box) for label in self._freq_labels: self._freq_combo_box.addItem(label) self._freq_callback = lambda i: Qt.QMetaObject.invokeMethod(self._freq_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._freq_options.index(i))) self._freq_callback(self.freq) self._freq_combo_box.currentIndexChanged.connect( lambda i: self.set_freq(self._freq_options[i])) self.top_layout.addWidget(self._freq_tool_bar) def _encoding_probe(): while True: val = self.frequencyAdaptiveOFDM_mac_and_parse_0.get_encoding() try: self.set_encoding(val) except AttributeError: pass time.sleep(1.0 / (1000)) _encoding_thread = threading.Thread(target=_encoding_probe) _encoding_thread.daemon = True _encoding_thread.start() self._chan_est_options = 0, 1, 3, 2 self._chan_est_labels = ["LS", "LMS", "STA", "Linear Comb"] self._chan_est_group_box = Qt.QGroupBox("chan_est") self._chan_est_box = Qt.QHBoxLayout() class variable_chooser_button_group(Qt.QButtonGroup): def __init__(self, parent=None): Qt.QButtonGroup.__init__(self, parent) @pyqtSlot(int) def updateButtonChecked(self, button_id): self.button(button_id).setChecked(True) self._chan_est_button_group = variable_chooser_button_group() self._chan_est_group_box.setLayout(self._chan_est_box) for i, label in enumerate(self._chan_est_labels): radio_button = Qt.QRadioButton(label) self._chan_est_box.addWidget(radio_button) self._chan_est_button_group.addButton(radio_button, i) self._chan_est_callback = lambda i: Qt.QMetaObject.invokeMethod(self._chan_est_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._chan_est_options.index(i))) self._chan_est_callback(self.chan_est) self._chan_est_button_group.buttonClicked[int].connect( lambda i: self.set_chan_est(self._chan_est_options[i])) self.top_layout.addWidget(self._chan_est_group_box) self.wifi_freq_adap_phy_hier_0 = wifi_freq_adap_phy_hier( bandwidth=10e6, chan_est=0, encoding=encoding, frequency=5.89e9, sensitivity=0.56, ) 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_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS) self.uhd_usrp_source_0.set_center_freq(uhd.tune_request(freq, rf_freq = freq - lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_source_0.set_normalized_gain(gain, 0) self.uhd_usrp_source_0.set_antenna("TX/RX", 0) self.uhd_usrp_sink_0 = uhd.usrp_sink( ",".join(('', "")), uhd.stream_args( cpu_format="fc32", channels=range(1), ), 'packet_len', ) self.uhd_usrp_sink_0.set_samp_rate(samp_rate) self.uhd_usrp_sink_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS) self.uhd_usrp_sink_0.set_center_freq(uhd.tune_request(freq, rf_freq = freq - lo_offset, rf_freq_policy=uhd.tune_request.POLICY_MANUAL), 0) self.uhd_usrp_sink_0.set_normalized_gain(gain, 0) self.uhd_usrp_sink_0.set_antenna("TX/RX", 0) self.qtgui_time_sink_x_0 = qtgui.time_sink_f( 1024, #size 300000, #samp_rate "Data Received", #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(-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(True) 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) 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(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_layout.addWidget(self._qtgui_time_sink_x_0_win) self.qtgui_number_sink_0 = qtgui.number_sink( gr.sizeof_float, 0, qtgui.NUM_GRAPH_NONE, 1 ) self.qtgui_number_sink_0.set_update_time(0.10) self.qtgui_number_sink_0.set_title("") labels = ['Error Rate', '', '', '', '', '', '', '', '', ''] units = ['Percent', '', '', '', '', '', '', '', '', ''] colors = [("black", "black"), ("black", "black"), ("black", "black"), ("black", "black"), ("black", "black"), ("black", "black"), ("black", "black"), ("black", "black"), ("black", "black"), ("black", "black")] factor = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] for i in xrange(1): self.qtgui_number_sink_0.set_min(i, 0) self.qtgui_number_sink_0.set_max(i, 100) self.qtgui_number_sink_0.set_color(i, colors[i][0], colors[i][1]) if len(labels[i]) == 0: self.qtgui_number_sink_0.set_label(i, "Data {0}".format(i)) else: self.qtgui_number_sink_0.set_label(i, labels[i]) self.qtgui_number_sink_0.set_unit(i, units[i]) self.qtgui_number_sink_0.set_factor(i, factor[i]) self.qtgui_number_sink_0.enable_autoscale(False) self._qtgui_number_sink_0_win = sip.wrapinstance(self.qtgui_number_sink_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_number_sink_0_win) self.qtgui_const_sink_x_0 = qtgui.const_sink_c( 48*10, #size "", #name 4 #number of inputs ) self.qtgui_const_sink_x_0.set_update_time(0.10) self.qtgui_const_sink_x_0.set_y_axis(-2, 2) self.qtgui_const_sink_x_0.set_x_axis(-2, 2) self.qtgui_const_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, "") self.qtgui_const_sink_x_0.enable_autoscale(False) self.qtgui_const_sink_x_0.enable_grid(False) self.qtgui_const_sink_x_0.enable_axis_labels(True) if not True: self.qtgui_const_sink_x_0.disable_legend() labels = ['RB1', 'RB2', 'RB3', 'RB4', '', '', '', '', '', ''] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = ["blue", "red", "green", "yellow", "red", "red", "red", "red", "red", "red"] styles = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] markers = [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(4): if len(labels[i]) == 0: self.qtgui_const_sink_x_0.set_line_label(i, "Data {0}".format(i)) else: self.qtgui_const_sink_x_0.set_line_label(i, labels[i]) self.qtgui_const_sink_x_0.set_line_width(i, widths[i]) self.qtgui_const_sink_x_0.set_line_color(i, colors[i]) self.qtgui_const_sink_x_0.set_line_style(i, styles[i]) self.qtgui_const_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_const_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_const_sink_x_0_win = sip.wrapinstance(self.qtgui_const_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_const_sink_x_0_win) self.frequencyAdaptiveOFDM_write_frame_data_0 = frequencyAdaptiveOFDM.write_frame_data('/tmp/snr.csv', '/tmp/encoding.csv', '/tmp/wifi_frame_delay.csv', True) self.frequencyAdaptiveOFDM_rb_const_demux_stream_0 = frequencyAdaptiveOFDM.rb_const_demux_stream('packet_len') self.foo_packet_pad2_0 = foo.packet_pad2(False, False, 0.001, 10000, 10000) (self.foo_packet_pad2_0).set_min_output_buffer(100000) self.blocks_vector_source_x_0 = blocks.vector_source_b(range(100), True, 1, []) self.blocks_uchar_to_float_0 = blocks.uchar_to_float() self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, 'packet_len') self.blocks_stream_to_tagged_stream_0 = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, pdu_length, 'packet_len') self.blocks_socket_pdu_0 = blocks.socket_pdu("UDP_SERVER", '', '52001', 10000, False) self.blocks_pdu_to_tagged_stream_0_1 = blocks.pdu_to_tagged_stream(blocks.byte_t, 'packet_len') self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.float_t, 'packet_len') self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.6, )) (self.blocks_multiply_const_vxx_0).set_min_output_buffer(100000) self.adaptiveOFDM_stream_spacer_0 = adaptiveOFDM.stream_spacer(blocks.byte_t, 500) ################################################## # Connections ################################################## self.msg_connect((self.blocks_socket_pdu_0, 'pdus'), (self.frequencyAdaptiveOFDM_mac_and_parse_0, 'app in')) self.msg_connect((self.blocks_tagged_stream_to_pdu_0, 'pdus'), (self.frequencyAdaptiveOFDM_mac_and_parse_0, 'app in')) self.msg_connect((self.frequencyAdaptiveOFDM_mac_and_parse_0, 'fer'), (self.blocks_pdu_to_tagged_stream_0, 'pdus')) self.msg_connect((self.frequencyAdaptiveOFDM_mac_and_parse_0, 'app out'), (self.blocks_pdu_to_tagged_stream_0_1, 'pdus')) self.msg_connect((self.frequencyAdaptiveOFDM_mac_and_parse_0, 'frame data'), (self.frequencyAdaptiveOFDM_write_frame_data_0, 'frame data')) self.msg_connect((self.frequencyAdaptiveOFDM_mac_and_parse_0, 'phy out'), (self.wifi_freq_adap_phy_hier_0, 'mac_in')) self.msg_connect((self.wifi_freq_adap_phy_hier_0, 'mac_out'), (self.frequencyAdaptiveOFDM_mac_and_parse_0, 'phy in')) self.msg_connect((self.wifi_freq_adap_phy_hier_0, 'carrier'), (self.frequencyAdaptiveOFDM_rb_const_demux_stream_0, 'symbols_in')) self.connect((self.adaptiveOFDM_stream_spacer_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.foo_packet_pad2_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.qtgui_number_sink_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0_1, 0), (self.blocks_uchar_to_float_0, 0)) self.connect((self.blocks_stream_to_tagged_stream_0, 0), (self.adaptiveOFDM_stream_spacer_0, 0)) self.connect((self.blocks_uchar_to_float_0, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_stream_to_tagged_stream_0, 0)) self.connect((self.foo_packet_pad2_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.frequencyAdaptiveOFDM_rb_const_demux_stream_0, 0), (self.qtgui_const_sink_x_0, 0)) self.connect((self.frequencyAdaptiveOFDM_rb_const_demux_stream_0, 1), (self.qtgui_const_sink_x_0, 1)) self.connect((self.frequencyAdaptiveOFDM_rb_const_demux_stream_0, 2), (self.qtgui_const_sink_x_0, 2)) self.connect((self.frequencyAdaptiveOFDM_rb_const_demux_stream_0, 3), (self.qtgui_const_sink_x_0, 3)) self.connect((self.uhd_usrp_source_0, 0), (self.wifi_freq_adap_phy_hier_0, 0)) self.connect((self.wifi_freq_adap_phy_hier_0, 0), (self.blocks_multiply_const_vxx_0, 0))