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, "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 test_001_t(self):
# set up fg
msg_meta = pmt.make_dict()
msg_meta = pmt.dict_add(msg_meta, pmt.to_pmt("freq"),
pmt.to_pmt("val"))
vec1 = [
0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00,
0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00
]
msg_vector = pmt.init_u8vector(len(vec1), vec1)
msg = pmt.cons(msg_meta, msg_vector)
src = blocks.message_strobe(msg, 10)
dut = capture_tools.bit_sniffer(fade_out=500, hexadecimal=True)
self.tb.msg_connect((src, "strobe"), (dut, "packets"))
self.tb.start()
time.sleep(5)
vec1 = [0x01, 0x00, 0x01, 0x00, 0x01, 0x00]
msg_vector = pmt.init_u8vector(len(vec1), vec1)
msg = pmt.cons(msg_meta, msg_vector)
src.set_msg(msg)
time.sleep(5)
vec1 = [0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01]
msg_vector = pmt.init_u8vector(len(vec1), vec1)
msg = pmt.cons(msg_meta, msg_vector)
src.set_msg(msg)
time.sleep(5)
self.tb.stop()
def test_001_t(self):
data = [ord('t'), ord('e'), ord('s'), ord('t')]
msg = pmt.list1(
pmt.list2(pmt.string_to_symbol("msg_clear"),
pmt.init_u8vector(len(data), data)))
filename_key = "secret.key"
nacl.generate_key(filename_key)
strobe = blocks.message_strobe(msg, 100)
encrypt_secret = nacl.encrypt_secret(filename_key)
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", encrypt_secret, "Msg clear")
self.tb.msg_connect(encrypt_secret, "Msg encrypted", debug, "store")
self.tb.start()
sleep(0.15)
self.tb.stop()
self.tb.wait()
# check results
msg_stored = debug.get_message(0)
nonce = pmt.nth(0, msg_stored)
msg_encrypted = pmt.nth(1, msg_stored)
print pmt.symbol_to_string(pmt.nth(0, nonce)), pmt.u8vector_elements(
pmt.nth(1, nonce))
print pmt.symbol_to_string(pmt.nth(
0,
msg_encrypted)), pmt.u8vector_elements(pmt.nth(1, msg_encrypted))
def test_004(self):
# Test that the TCP server can stream PDUs <= the MTU size.
port = str(random.Random().randint(0, 30000) + 10000)
mtu = 10000
srcdata = tuple(x % 256 for x in range(mtu))
data = pmt.init_u8vector(srcdata.__len__(), srcdata)
pdu_msg = pmt.cons(pmt.PMT_NIL, data)
self.pdu_source = blocks.message_strobe(pdu_msg, 500)
self.pdu_send = blocks.socket_pdu("TCP_SERVER", "localhost", port, mtu)
self.pdu_recv = blocks.socket_pdu("TCP_CLIENT", "localhost", port, mtu)
self.pdu_sink = blocks.message_debug()
self.tb.msg_connect(self.pdu_source, "strobe", self.pdu_send, "pdus")
self.tb.msg_connect(self.pdu_recv, "pdus", self.pdu_sink, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
received = self.pdu_sink.get_message(0)
received_data = pmt.cdr(received)
msg_data = []
for i in range(mtu):
msg_data.append(pmt.u8vector_ref(received_data, i))
self.assertEqual(srcdata, tuple(msg_data))
def test_001_t (self):
# set up message
msg1 = pmt.list3(pmt.string_to_symbol('id'),pmt.string_to_symbol('int'),pmt.from_long(42))
msg2 = pmt.list3(pmt.string_to_symbol('value'),pmt.string_to_symbol('float'),pmt.from_float(3.1416))
#msg3 = pmt.list3(pmt.string_to_symbol('text'),pmt.string_to_symbol('string'),pmt.string_to_symbol('some text'))
msg = pmt.list2(msg1,msg2)
# set up sql connection
host = '127.0.0.1'
port = 0 # default
user = '******'
password = '******'
database = 'my_db'
table = 'my_table'
# set up flowgraph
if 0: # Enable and disable here
msg_src = blocks.message_strobe(msg,100)
sql_connector = sql.msg_to_table(user,password,database,table,host,port)
self.tb.msg_connect(msg_src,'strobe',sql_connector,'Msg in')
# run flowgraph
self.tb.start()
sleep(0.2)
self.tb.stop()
self.tb.wait()
def test_002(self):
# Send a PDU through a pair of UDP sockets
port = str(random.Random().randint(0, 30000) + 10000)
srcdata = (0x64, 0x6f, 0x67, 0x65)
data = pmt.init_u8vector(srcdata.__len__(), srcdata)
pdu_msg = pmt.cons(pmt.PMT_NIL, data)
self.pdu_source = blocks.message_strobe(pdu_msg, 500)
self.pdu_recv = blocks.socket_pdu("UDP_SERVER", "localhost", port)
self.pdu_send = blocks.socket_pdu("UDP_CLIENT", "localhost", port)
self.dbg = blocks.message_debug()
self.tb.msg_connect(self.pdu_source, "strobe", self.pdu_send, "pdus")
self.tb.msg_connect(self.pdu_recv, "pdus", self.dbg, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.pdu_send = None
self.pdu_recv = None
received = self.dbg.get_message(0)
received_data = pmt.cdr(received)
msg_data = []
for i in range(4):
msg_data.append(pmt.u8vector_ref(received_data, i))
self.assertEqual(srcdata, tuple(msg_data))
def test_004_es_source_pdus(self):
print "test_004_es_source_pdus"
msg = pmt.cons( pmt.to_pmt( {"somekey":"val2", "somekey2":"someval2" } ),
pmt.to_pmt( numpy.array( [0,1,2,3,4,5,6,7,8,9] , dtype=numpy.float32) ) );
src = es.source([gr.sizeof_float], 8, 2);
stb = blocks.message_strobe( msg, 100.0 );
tb = gr.top_block();
tb.msg_connect(stb, "strobe", src, "schedule_event");
th = blocks.throttle(gr.sizeof_float, 1000*100);
hd = blocks.head(gr.sizeof_float, 1000*100);
snk = blocks.vector_sink_f();
tb.connect(src,th,hd,snk);
# TODO: this can not use run because it is
# subject to GNU Radio's shutdown msg block bug
# for remaining upstream msg blocks ...
#tb.run();
# workaround
tb.start();
time.sleep(1);
tb.stop();
tb.wait();
self.assertEqual( sum(snk.data())>0, True );
def test_002 (self):
# Send a PDU through a pair of UDP sockets
port = str(random.Random().randint(0, 30000) + 10000)
srcdata = (0x64, 0x6f, 0x67, 0x65)
data = pmt.init_u8vector(srcdata.__len__(), srcdata)
pdu_msg = pmt.cons(pmt.PMT_NIL, data)
self.pdu_source = blocks.message_strobe(pdu_msg, 500)
self.pdu_recv = blocks.socket_pdu("UDP_SERVER", "localhost", port)
self.pdu_send = blocks.socket_pdu("UDP_CLIENT", "localhost", port)
self.dbg = blocks.message_debug()
self.tb.msg_connect(self.pdu_source, "strobe", self.pdu_send, "pdus")
self.tb.msg_connect(self.pdu_recv, "pdus", self.dbg, "store")
self.tb.start ()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.pdu_send = None
self.pdu_recv = None
received = self.dbg.get_message(0)
received_data = pmt.cdr(received)
msg_data = []
for i in range(4):
msg_data.append(pmt.u8vector_ref(received_data, i))
self.assertEqual(srcdata, tuple(msg_data))
def __init__(self, baudrate=19200, device="/dev/pts/4"):
grc_wxgui.top_block_gui.__init__(self, title="Simple Message Passing Example")
##################################################
# Parameters
##################################################
self.baudrate = baudrate
self.device = device
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.openavionics_serial_io_0 = openavionics.serial_io(device,0,baudrate,0,1,False)
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 1000)
self.blocks_message_debug_0 = blocks.message_debug()
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.blocks_message_strobe_0, "strobe", self.openavionics_serial_io_0, "in")
self.msg_connect(self.openavionics_serial_io_0, "out", self.blocks_message_debug_0, "print")
def test_001_t (self):
data = [ord('t'),ord('e'),ord('s'),ord('t')]
msg = pmt.list1(pmt.list2(pmt.string_to_symbol("msg_clear"),pmt.init_u8vector(len(data),data)))
filename_sk = "secret.key"
filename_pk = "public.key"
nacl.generate_keypair(filename_sk,filename_pk)
strobe = blocks.message_strobe(msg, 100)
encrypt_public = nacl.encrypt_public(filename_pk,filename_sk)
debug = blocks.message_debug()
self.tb.msg_connect(strobe,"strobe",encrypt_public,"Msg clear")
self.tb.msg_connect(encrypt_public,"Msg encrypted",debug,"store")
self.tb.start()
sleep(0.15)
self.tb.stop()
self.tb.wait()
# check results
msg_stored = debug.get_message(0)
nonce = pmt.nth(0,msg_stored)
msg_encrypted = pmt.nth(1,msg_stored)
print pmt.symbol_to_string(pmt.nth(0,nonce)), pmt.u8vector_elements(pmt.nth(1,nonce))
print pmt.symbol_to_string(pmt.nth(0,msg_encrypted)), pmt.u8vector_elements(pmt.nth(1,msg_encrypted))
def test_001_t(self):
data = [ord("a"), ord("b"), ord("c"), ord("d")]
msg = pmt.list1(pmt.list2(pmt.string_to_symbol("msg_clear"), pmt.init_u8vector(len(data), data)))
filename_key = "secret.a"
nacl.generate_key(filename_key)
strobe = blocks.message_strobe(msg, 100)
encrypt_secret = nacl.encrypt_secret(filename_key)
decrypt_secret = nacl.decrypt_secret(filename_key)
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", encrypt_secret, "Msg clear")
self.tb.msg_connect(encrypt_secret, "Msg encrypted", decrypt_secret, "Msg encrypted")
self.tb.msg_connect(decrypt_secret, "Msg decrypted", debug, "store")
self.tb.start()
sleep(0.15)
self.tb.stop()
self.tb.wait()
# check results
msg_out = debug.get_message(0)
msg_symbol = pmt.symbol_to_string(pmt.nth(0, pmt.nth(0, msg_out)))
msg_decrypted = pmt.u8vector_elements(pmt.nth(1, pmt.nth(0, msg_out)))
print msg_symbol, msg_decrypted
print "msg_clear", data
for k in range(len(data)):
self.assertEqual(data[k], msg_decrypted[k])
def encode_decode_test(self, payload_str="TEST", whitening=False, encode_crc=False, decode_crc=False):
preamble = "01010101"
sync1 = 0x2
sync2 = 0x3
sync_length = 2
payload = [ord(c) for c in payload_str]
strobe = blocks.message_strobe(pmt.cons(pmt.PMT_NIL, pmt.to_pmt(payload)), 200)
encoder = cc11xx_encoder.cc11xx_encoder(preamble=[int(preamble, 2)], syncword=[sync1, sync2], whitening=whitening, crc=encode_crc)
pdu_to_stream = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len")
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", encoder, "in")
self.tb.msg_connect(encoder, "out", pdu_to_stream, "pdus")
unpack = blocks.packed_to_unpacked_bb(1, 0)
acc_code_block = digital.correlate_access_code_tag_bb(preamble, 0, "preamble")
deframer = cc11xx.cc11xx_deframer_bb(sync1 ,sync2, whitening, decode_crc, sync_length)
self.tb.connect(pdu_to_stream,unpack)
self.tb.connect(unpack, acc_code_block)
self.tb.connect(acc_code_block, deframer)
self.tb.msg_connect((deframer, 'out'), (debug, 'store'))
self.tb.start()
time.sleep(1)
self.tb.stop()
#Please get rid of this sleep if you know how!
time.sleep(0.1)
self.tb.stop()
result_data = [i for i in pmt.to_python(pmt.cdr(debug.get_message(0)))]
self.assertEqual(payload, result_data)
def __init__(self, baudrate=19200, device="/dev/pts/4"):
grc_wxgui.top_block_gui.__init__(
self, title="Simple Message Passing Example")
##################################################
# Parameters
##################################################
self.baudrate = baudrate
self.device = device
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.openavionics_serial_io_0 = openavionics.serial_io(
device, 0, baudrate, 0, 1, False)
self.blocks_message_strobe_0 = blocks.message_strobe(
pmt.intern("TEST"), 1000)
self.blocks_message_debug_0 = blocks.message_debug()
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.blocks_message_strobe_0, "strobe",
self.openavionics_serial_io_0, "in")
self.msg_connect(self.openavionics_serial_io_0, "out",
self.blocks_message_debug_0, "print")
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.simple_mac_0_0 = mac.simple_mac(1,0.1,10)
self.simple_mac_0 = mac.simple_mac(0,0.1,10)
self.mac_virtual_channel_encoder_0 = mac.virtual_channel_encoder(0,0)
self.blocks_random_pdu_0 = blocks.random_pdu(5, 5)
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 1000)
self.blocks_message_debug_0 = blocks.message_debug()
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.simple_mac_0, "to_radio", self.simple_mac_0_0, "from_radio")
self.msg_connect(self.simple_mac_0_0, "to_radio", self.simple_mac_0, "from_radio")
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.mac_virtual_channel_encoder_0, "in")
self.msg_connect(self.mac_virtual_channel_encoder_0, "out", self.simple_mac_0_0, "from_app")
self.msg_connect(self.simple_mac_0, "to_app", self.blocks_message_debug_0, "print_pdu")
def test_003_trim_from_end(self):
orig_array = np.array([1.1, 2.2, 3.3, 4.4, 5.5])
expected_out_array = np.array([1.1, 2.2, 3.3])
metadata = {'a': 1, 'b': 2}
in_pmt = pmt.cons(pmt.to_pmt(metadata), pmt.to_pmt(orig_array))
expected_pmt = pmt.cons(pmt.to_pmt(metadata),
pmt.to_pmt(expected_out_array))
# We just need something connected to the trimmer block for
# the flowgraph to compile, but we'll post messages to it directly
src = blocks.message_strobe(pmt.PMT_NIL, 9999999)
trimmer = pdu_trim_uvector(0, 2)
snk = blocks.message_debug()
self.tb.msg_connect((src, 'strobe'), (trimmer, 'in'))
self.tb.msg_connect((trimmer, 'out'), (snk, 'store'))
self.tb.start()
trimmer.to_basic_block()._post(pmt.intern('in'), in_pmt)
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
# check data
self.assertEqual(snk.num_messages(), 1)
self.assertTrue(pmt.equal(snk.get_message(0), expected_pmt))
def run_clear_test(filter_str, expected_tags):
data, json_dict, data_path, json_path = self.make_file(
"clearing",
[{
"core:sample_start": 0,
"test:foo": 1,
"test:foobar": 2,
"test:bar": 3,
"test:baz": 4,
"blargh:foo": 5
}]
)
anno_sink = sigmf.annotation_sink(
data_path, sigmf.annotation_mode_clear(filter_str))
# Strobe block is just here for the flowgraph to run
strobe = blocks.message_strobe(pmt.to_pmt("asdf"), 1)
tb = gr.top_block()
tb.msg_connect(strobe, "strobe", anno_sink, "annotations")
tb.start()
tb.stop()
tb.wait()
with open(json_path, "r") as f:
meta = json.load(f)
anno_dict = meta["annotations"][0]
expect_set = set(expected_tags)
anno_keys = set(anno_dict.keys())
self.assertIn("core:sample_start", anno_keys)
anno_keys.remove("core:sample_start")
self.assertEqual(anno_keys, expect_set,
"Key filtering is incorrect")
def test_gwnblock_py(self):
'''GWN block in Python test.
'''
tst_msg = "--- A message from message strobe"
src = blocks.message_strobe(pmt.intern(tst_msg), 1000)
blk_gwn = gwnblock_py(name="MsgPasser",
number_in=1,
number_out=1,
number_timers=0,
number_timeouts=0)
dbg = blocks.message_debug()
self.tb.msg_connect((src, "strobe"),
(blk_gwn, blk_gwn.ports_in[0].port))
self.tb.msg_connect((blk_gwn, blk_gwn.ports_out[0].port),
(dbg, "print"))
#self.tb.run() # for flowgraphs that will stop on its own!
self.tb.start()
#mutex_prt(self.tb.msg_edge_list())
#print tb.dump()
time.sleep(8)
#blk_gwn.stop_timers()
print '\n--- gwnblock_py, timers stopped'
time.sleep(2)
self.tb.stop()
self.tb.wait()
print '\n--- top block stopped'
return
def test_010_t (self):
# PHR prefixer to removal
data_in = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(2*self.c.phy_packetsize_bytes,170))
self.src = blocks.message_strobe(data_in,100)
self.snk = blocks.message_debug()
self.tb.msg_connect(self.src, "strobe", self.fragmentation, "in")
self.tb.msg_connect(self.fragmentation, "out", self.phr_prefixer, "in")
self.tb.msg_connect(self.phr_prefixer, "out", self.zeropadding, "in")
self.tb.connect(self.zeropadding, self.demux)
self.tb.connect((self.demux,0), self.codeword_mapper_I, self.interleaver_I, self.preamble_sfd_prefixer_I, (self.qpsk_mapper,0))
self.tb.connect((self.demux,1), self.codeword_mapper_Q, self.interleaver_Q, self.preamble_sfd_prefixer_Q, (self.qpsk_mapper,1))
self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper, self.dqcsk_demapper, self.dqpsk_demapper, self.qpsk_demapper)
self.tb.connect((self.qpsk_demapper,0), self.preamble_sfd_removal_I, self.deinterleaver_I, self.codeword_demapper_I, (self.mux,0))
self.tb.connect((self.qpsk_demapper,1), self.preamble_sfd_removal_Q, self.deinterleaver_Q, self.codeword_demapper_Q, (self.mux,1))
self.tb.connect(self.mux, self.zeropadding_removal)
self.tb.msg_connect(self.zeropadding_removal, "out", self.phr_removal, "in")
self.tb.msg_connect(self.phr_removal, "out", self.snk, "store")
self.tb.start()
time.sleep(0.3)
self.tb.stop()
msg_out1 = self.snk.get_message(0)
msg_out2 = self.snk.get_message(1)
data_out1 = pmt.to_python(msg_out1)[1]
data_out2 = pmt.to_python(msg_out2)[1]
ref = pmt.to_python(data_in)[1]
self.assertTrue((data_out1==ref[:len(data_out1)]).all() and (data_out2==ref[:len(data_out2)]).all())
def test_004 (self):
# Test that the TCP server can stream PDUs <= the MTU size.
port = str(random.Random().randint(0, 30000) + 10000)
mtu = 10000
srcdata = tuple(x % 256 for x in range(mtu))
data = pmt.init_u8vector(srcdata.__len__(), srcdata)
pdu_msg = pmt.cons(pmt.PMT_NIL, data)
self.pdu_source = blocks.message_strobe(pdu_msg, 500)
self.pdu_send = blocks.socket_pdu("TCP_SERVER", "localhost", port, mtu)
self.pdu_recv = blocks.socket_pdu("TCP_CLIENT", "localhost", port, mtu)
self.pdu_sink = blocks.message_debug()
self.tb.msg_connect(self.pdu_source, "strobe", self.pdu_send, "pdus")
self.tb.msg_connect(self.pdu_recv, "pdus", self.pdu_sink, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
received = self.pdu_sink.get_message(0)
received_data = pmt.cdr(received)
msg_data = []
for i in range(mtu):
msg_data.append(pmt.u8vector_ref(received_data, i))
self.assertEqual(srcdata, tuple(msg_data))
def test_001_t(self):
# set up message
msg1 = pmt.list3(pmt.string_to_symbol('id'),
pmt.string_to_symbol('int'), pmt.from_long(42))
msg2 = pmt.list3(pmt.string_to_symbol('value'),
pmt.string_to_symbol('float'), pmt.from_float(3.1416))
#msg3 = pmt.list3(pmt.string_to_symbol('text'),pmt.string_to_symbol('string'),pmt.string_to_symbol('some text'))
msg = pmt.list2(msg1, msg2)
# set up sql connection
host = '127.0.0.1'
port = 0 # default
user = '******'
password = '******'
database = 'my_db'
table = 'my_table'
# set up flowgraph
if 0: # Enable and disable here
msg_src = blocks.message_strobe(msg, 100)
sql_connector = sql.msg_to_table(user, password, database, table,
host, port)
self.tb.msg_connect(msg_src, 'strobe', sql_connector, 'Msg in')
# run flowgraph
self.tb.start()
sleep(0.2)
self.tb.stop()
self.tb.wait()
def test_001_t(self):
data = [ord('a'), ord('b'), ord('c'), ord('d')]
msg = pmt.list1(
pmt.list2(pmt.string_to_symbol("msg_clear"),
pmt.init_u8vector(len(data), data)))
filename_key = "secret.a"
nacl.generate_key(filename_key)
strobe = blocks.message_strobe(msg, 100)
encrypt_secret = nacl.encrypt_secret(filename_key)
decrypt_secret = nacl.decrypt_secret(filename_key)
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", encrypt_secret, "Msg clear")
self.tb.msg_connect(encrypt_secret, "Msg encrypted", decrypt_secret,
"Msg encrypted")
self.tb.msg_connect(decrypt_secret, "Msg decrypted", debug, "store")
self.tb.start()
sleep(0.15)
self.tb.stop()
self.tb.wait()
# check results
msg_out = debug.get_message(0)
msg_symbol = pmt.symbol_to_string(pmt.nth(0, pmt.nth(0, msg_out)))
msg_decrypted = pmt.u8vector_elements(pmt.nth(1, pmt.nth(0, msg_out)))
print msg_symbol, msg_decrypted
print "msg_clear", data
for k in range(len(data)):
self.assertEqual(data[k], msg_decrypted[k])
def test_001_t (self):
# set up fg
fft_len = 256
cp_len = 32
samp_rate = 32000
data = np.random.choice([-1, 1], [100, fft_len])
timefreq = np.fft.ifft(data, axis=0)
#add cp
timefreq = np.hstack((timefreq[:, -cp_len:], timefreq))
# msg (only 4th and 5th tuples are needed)
id1 = pmt.make_tuple(pmt.intern("Signal"), pmt.from_uint64(0))
name = pmt.make_tuple(pmt.intern("OFDM"), pmt.from_float(1.0));
id2 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(0.0))
id3 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(0.0))
id4 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(256))
id5 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(32))
msg = pmt.make_tuple(id1, name, id2, id3, id4, id5)
tx = np.reshape(timefreq, (1, -1))
# GR time!
src = blocks.vector_source_c(tx[0].tolist(), True, 1, [])
freq_offset = analog.sig_source_c(1, analog.GR_SIN_WAVE,
50.0/samp_rate, 1.0, 0.0)
mixer = blocks.multiply_cc()
sync = inspector.ofdm_synchronizer_cc(4096)
dst = blocks.vector_sink_c()
dst2 = blocks.vector_sink_c()
msg_src = blocks.message_strobe(msg, 0)
# connect
self.tb.connect(src, (mixer, 0))
self.tb.connect(freq_offset, (mixer, 1))
self.tb.connect(mixer, sync)
self.tb.msg_connect((msg_src, 'strobe'), (sync, 'ofdm_in'))
self.tb.connect(sync, dst)
self.tb.connect(src, dst2)
self.tb.start()
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
# check data
output = dst.data()
expect = dst2.data()
# block outputs 0j until it has enough OFDM symbols to perform estimations
k = (k for k in range(len(output)) if output[k] != 0j).next()
# use 10,000 samples for comparison since block fails sometimes
# for one work function
output = output[k:k+10000]
expect = expect[k:k+10000]
self.assertComplexTuplesAlmostEqual2(expect, output, abs_eps = 0.001, rel_eps=10)
def test_002_msg(self):
print "test_002"
msg = pmt.pmt_from_long(220)
self.strobe = blocks.message_strobe(msg, 1000)
self.tb.msg_connect(self.strobe, "strobe", self.demux, self.msg_buf_name)
self.tb.run()
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.dflood_dflood_3 = dflood.dflood(
3, 0, 20, False, False,
5, 65, 2, 120, 50, 0, 0.8, True, None
)
self.dflood_dflood_1 = dflood.dflood(
1, 0, 20, False, False,
1, 5, 0, 120, 50, 2, 0.8, True, None
)
self.dflood_dflood_0 = dflood.dflood(
0, 0, 10, False, False,
5, 65, 2, 120, 50, 2, 0.8, True, None
)
self.blocks_random_pdu_0 = blocks.random_pdu(6, 6, chr(0xFF), 2)
self.blocks_message_strobe_3 = blocks.message_strobe(pmt.intern("TEST"), 20000)
self.blocks_message_strobe_2_0 = blocks.message_strobe(pmt.intern("TEST"), 10000)
self.blocks_message_strobe_1 = blocks.message_strobe(pmt.intern("TEST"), 20000)
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 20000)
self.blocks_message_debug_0 = blocks.message_debug()
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.dflood_dflood_0, 'ctrl_in'))
self.msg_connect((self.blocks_message_strobe_1, 'strobe'), (self.dflood_dflood_1, 'ctrl_in'))
self.msg_connect((self.blocks_message_strobe_2_0, 'strobe'), (self.blocks_random_pdu_0, 'generate'))
self.msg_connect((self.blocks_message_strobe_3, 'strobe'), (self.dflood_dflood_3, 'ctrl_in'))
self.msg_connect((self.blocks_random_pdu_0, 'pdus'), (self.dflood_dflood_3, 'from_app'))
self.msg_connect((self.dflood_dflood_0, 'to_app'), (self.blocks_message_debug_0, 'print_pdu'))
self.msg_connect((self.dflood_dflood_0, 'to_radio'), (self.dflood_dflood_1, 'from_radio'))
self.msg_connect((self.dflood_dflood_1, 'to_radio'), (self.dflood_dflood_0, 'from_radio'))
self.msg_connect((self.dflood_dflood_1, 'to_radio'), (self.dflood_dflood_3, 'from_radio'))
self.msg_connect((self.dflood_dflood_3, 'to_radio'), (self.dflood_dflood_1, 'from_radio'))
def notest_debug(self):
src = blocks.vector_source_c(range(100), False, 1, [])
separator = inspector_test.signal_separator_c(32000, firdes.WIN_HAMMING, 0.1, 100)
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12500)
pmt.f32vector_set(flanks, 1, 20)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
def test_012(self):
s, st, h, k = analog.sig_source_c(44100, analog.GR_COS_WAVE, 440, 1.0, 0.0), blocks.message_strobe(pmt.PMT_NIL, 100), blocks.head(gr.sizeof_gr_complex, 1000), test_hblk([gr.sizeof_gr_complex], 16)
tb = gr.top_block()
tb.connect(s,h,k)
tb.msg_connect(st,"strobe",k,"msg_in")
tb.start()
time.sleep(1)
tb.stop()
tb.wait()
def test_001_5x_pass (self):
strobe = blocks.message_strobe(pmt.PMT_NIL, 25)
ctr = pdu_utils.message_counter(pmt.intern("counter"))
self.tb.msg_connect((strobe, 'strobe'), (ctr, 'msg'))
self.tb.start()
time.sleep(.135)
self.tb.stop()
self.tb.wait()
self.assertEquals(5, ctr.get_ctr())
def __init__(self):
gr.top_block.__init__(self, "Test_general_timeout")
Qt.QWidget.__init__(self)
self.setWindowTitle("Test_general_timeout")
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", "Test_general_timeout")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.timeout_duration_ms = timeout_duration_ms = 1000
self.system_time_granularity_us = system_time_granularity_us = 1000
self.samp_rate = samp_rate = 320000
self.develop_mode_list = develop_mode_list = [1, 3, 4, 16]
##################################################
# Blocks
##################################################
self.inets_general_timeout_0 = inets.general_timeout(1, 43, 1000, 1000, 1, 1)
self.inets_framing_0 = inets.framing(0, 17, 1, 1, 0, 1, 1, 1, 2, 1, 318, 2, 524, 2, 2, 1, 1, 0, ([2, 3]), ([1000, 1000]), 2)
self.inets_frame_probe_0_0 = inets.frame_probe(1, 101, 0, 0, 0.01)
self.inets_frame_probe_0 = inets.frame_probe(0, 100, 0, 0, 0.01)
self.inets_frame_index_selector_0 = inets.frame_index_selector(0, 41, ([1,2,3,4,5]), 0)
self.inets_dummy_source_0 = inets.dummy_source(0, 23, 100, 1, 1)
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 1000)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.inets_dummy_source_0, 'trigger'))
self.msg_connect((self.inets_dummy_source_0, 'output'), (self.inets_framing_0, 'data_in'))
self.msg_connect((self.inets_frame_index_selector_0, 'frame_out'), (self.inets_general_timeout_0, 'frame_in'))
self.msg_connect((self.inets_framing_0, 'frame_out'), (self.inets_frame_index_selector_0, 'frame_in'))
self.msg_connect((self.inets_general_timeout_0, 'expired_frame_out'), (self.inets_frame_probe_0, 'info_in'))
self.msg_connect((self.inets_general_timeout_0, 'killed_frame_out'), (self.inets_frame_probe_0_0, 'info_in'))
def test_ports_timer(self):
print "\n===\n=== TEST message_timer_example input and output ports \n===\n"
tst_msg = "--- A message from message strobe"
src = blocks.message_strobe(pmt.intern(tst_msg), 1000)
pss = gwncppvgb.message_timer_example("AAAA", 1000, 6, "BBBB", 500, 6)
dbg = blocks.message_debug()
self.tb.msg_connect((src, "strobe"), (pss, "in_port_0"))
self.tb.msg_connect((pss, "out_port_0"), (dbg, "print"))
self.tb.start()
time.sleep(8)
self.tb.stop()
def test_005_some_wrong_length_packets(self):
snk = prbs_sink_pdu(self.PACKET_LENGTH_BYTES * 8, self.PRBS_RESET_LEN,
self.NUM_GENERATED_PACKETS)
# We just need something connected to the trimmer block for
# the flowgraph to compile, but we'll post messages to it directly
src = blocks.message_strobe(pmt.PMT_NIL, 9999999)
self.tb.msg_connect((src, 'strobe'), (snk, 'all'))
self.tb.msg_connect((src, 'strobe'), (snk, 'corrected'))
self.tb.start()
for packet in self.packets:
snk.to_basic_block()._post(
pmt.intern('all'), pmt.cons(pmt.PMT_NIL, pmt.to_pmt(packet)))
for i, packet in enumerate(self.packets):
if i == 10:
packet = np.concatenate(
(packet, np.array([0, 0], dtype=np.uint8)))
elif i == 20:
packet = packet[:-2]
snk.to_basic_block()._post(
pmt.intern('corrected'),
pmt.cons(pmt.PMT_NIL, pmt.to_pmt(packet)))
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
self.assertEqual(snk.statistics["Expected number of packets sent"],
200)
self.assertEqual(snk.statistics["Total number of packets received"],
200)
self.assertEqual(
snk.statistics["Total number of correct packets after FEC"], 198)
self.assertEqual(
snk.statistics[
"Total number of wrong length packets after FEC (This should be 0)"],
2)
self.assertEqual(
snk.statistics[
"Total number of erroneous packets after FEC (This should be 0)"],
0)
self.assertEqual(
snk.statistics["Total number of unique packets after FEC"], 198)
self.assertEqual(snk.statistics["Total number of duplicates"], 0)
self.assertAlmostEqual(snk.statistics["Frame error rate"], 0.01)
expected = np.ones([self.NUM_GENERATED_PACKETS])
expected[10] = 0
expected[20] = 0
self.assertTrue(np.array_equal(snk.collected_packets, expected))
def test_001_t(self):
src = blocks.vector_source_c(list(range(10000)), False, 1, [])
separator = inspector_test.signal_separator_c(
32000, firdes.WIN_HAMMING, 0.1, 100, False,
inspector_test.map_float_vector({0.0: [0.0]}))
vec_sink = blocks.vector_sink_c(1)
ext = inspector_test.signal_extractor_c(0)
snk = blocks.vector_sink_c(1)
# pack message
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12500)
pmt.f32vector_set(flanks, 1, 20)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
taps = filter.firdes.low_pass(1, 32000, 500, 50, firdes.WIN_HAMMING,
6.76)
self.tb.connect(src, separator)
self.tb.connect(src, vec_sink)
self.tb.msg_connect((msg_src, 'strobe'), (separator, 'map_in'))
self.tb.msg_connect((separator, 'sig_out'), (ext, 'sig_in'))
self.tb.connect(ext, snk)
self.tb.start()
time.sleep(0.3)
self.tb.stop()
self.tb.wait()
data = vec_sink.data()
sig = numpy.zeros(len(vec_sink.data()), dtype=complex)
for i in range(len(vec_sink.data())):
sig[i] = data[i] * numpy.exp(
-1j * 2 * numpy.pi * 12500 * i * 1 / 32000)
taps = filter.firdes.low_pass(1, 32000, 900, 90, firdes.WIN_HAMMING,
6.76)
sig = numpy.convolve(sig, taps, 'full')
out = numpy.empty([0])
decim = 32000 / 20 / 100
j = 0
for i in range(len(sig) / decim):
out = numpy.append(out, sig[j])
j += decim
data = snk.data()
for i in range(min(len(out), len(data))):
self.assertComplexAlmostEqual2(out[i], data[i], abs_eps=0.01)
def test_012(self):
import math
exp = 1j * 440 / 44100
src = blocks.vector_source_c([math.e**(exp * n) for n in range(10**6)])
strobe = blocks.message_strobe(pmt.PMT_NIL, 100)
head = blocks.head(gr.sizeof_gr_complex, 1000)
test = test_hblk([gr.sizeof_gr_complex], 16)
tb = gr.top_block()
tb.connect(src, head, test)
tb.msg_connect(strobe, "strobe", test, "msg_in")
tb.start()
time.sleep(0.5)
tb.stop()
tb.wait()
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.ec_ax25_decoder_b_0 = ec.ax25_decoder_b(True, 0, "")
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char*1, samp_rate,True)
self.blocks_socket_pdu_0 = blocks.socket_pdu("TCP_SERVER", "", "52001", 10000, False)
self.blocks_random_pdu_0 = blocks.random_pdu(256, 256, chr(0xFF), 1)
self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len")
self.blocks_packed_to_unpacked_xx_0 = blocks.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST)
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 2000)
self.ax25_ax25_encoder_0 = ax25.ax25_encoder("SPACE ", "EARTH ", 0, 0)
##################################################
# Connections
##################################################
self.msg_connect((self.ax25_ax25_encoder_0, 'pdu_out'), (self.blocks_pdu_to_tagged_stream_0, 'pdus'))
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.ax25_ax25_encoder_0, 'pdu_in'))
self.msg_connect((self.ec_ax25_decoder_b_0, 'pdus'), (self.blocks_socket_pdu_0, 'pdus'))
self.connect((self.blocks_packed_to_unpacked_xx_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_packed_to_unpacked_xx_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.ec_ax25_decoder_b_0, 0))
def test_debug_401(self):
msg = pmt.intern("TESTING")
src = blocks.message_strobe(msg, 500)
snk = blocks.message_debug()
tb = gr.top_block()
tb.msg_connect(src, "strobe", snk, "store")
tb.start()
time.sleep(1)
tb.stop()
tb.wait()
rec_msg = snk.get_message(0)
self.assertTrue(pmt.eqv(rec_msg, msg))
def __init__(self):
gr.top_block.__init__(self, "TFG")
Qt.QWidget.__init__(self)
self.setWindowTitle("TFG")
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", "testNWK")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Blocks
##################################################
self.tfg_test_nwk_0 = tfg.test_nwk()
self.tfg_NWK_stack_0 = tfg.NWK_stack(True, True)
self.tfg_MAC_stack_0 = tfg.MAC_stack(False, False)
self.ieee802_15_4_oqpsk_phy_0 = ieee802_15_4_oqpsk_phy()
self.foo_wireshark_connector_0 = foo.wireshark_connector(195, False)
self.foo_packet_pad_0 = foo.packet_pad(False, True, 0.1, 2000, 2000)
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("A"), 1000)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_char*1, '/tmp/sensor.pcap', False)
self.blocks_file_sink_0.set_unbuffered(True)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.tfg_test_nwk_0, 'entrada'))
self.msg_connect((self.ieee802_15_4_oqpsk_phy_0, 'rxout'), (self.foo_wireshark_connector_0, 'in'))
self.msg_connect((self.ieee802_15_4_oqpsk_phy_0, 'rxout'), (self.tfg_MAC_stack_0, 'in(PHY)'))
self.msg_connect((self.tfg_MAC_stack_0, 'out(PHY)'), (self.foo_wireshark_connector_0, 'in'))
self.msg_connect((self.tfg_MAC_stack_0, 'out(PHY)'), (self.ieee802_15_4_oqpsk_phy_0, 'txin'))
self.msg_connect((self.tfg_MAC_stack_0, 'out(NWK)'), (self.tfg_NWK_stack_0, 'in(MAC)'))
self.msg_connect((self.tfg_NWK_stack_0, 'out(MAC)'), (self.tfg_MAC_stack_0, 'in(NWK)'))
self.msg_connect((self.tfg_test_nwk_0, 'salida'), (self.tfg_NWK_stack_0, 'in(APS)'))
self.connect((self.foo_packet_pad_0, 0), (self.ieee802_15_4_oqpsk_phy_0, 0))
self.connect((self.foo_wireshark_connector_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.ieee802_15_4_oqpsk_phy_0, 0), (self.foo_packet_pad_0, 0))
def test_ports (self):
print "\n===\n=== TEST gwnblockc input and output ports \n===\n"
tst_msg = "--- A test message from message strobe"
src = blocks.message_strobe(pmt.intern(tst_msg), 1000)
pss = gwncppvgb.gwnblockc("GWN test message 2", 10)
dbg = blocks.message_debug()
self.tb.msg_connect( (src, "strobe"), (pss, "in_port_0") )
self.tb.msg_connect( (pss, "out_port_0"), (dbg, "print") )
#self.tb.msg_connect( (src, "port_out_0"), (dbg, "print") )
self.tb.start ()
time.sleep(6)
self.tb.stop()
def test_001_4x_pass(self):
strobe = blocks.message_strobe(pmt.PMT_NIL, 25)
gate = pdu_utils.message_gate(True)
debug = blocks.message_debug()
self.tb.msg_connect((strobe, 'strobe'), (gate, 'in'))
self.tb.msg_connect((gate, 'out'), (debug, 'store'))
self.tb.start()
time.sleep(.11)
self.tb.stop()
self.tb.wait()
self.assertEquals(4, gate.get_n_passed())
self.assertEquals(4, debug.num_messages())
def test_debug_401(self):
msg = pmt.intern("TESTING")
src = blocks.message_strobe(msg, 500)
snk = blocks.message_debug()
tb = gr.top_block()
tb.msg_connect(src, "strobe", snk, "store")
tb.start()
time.sleep(1)
tb.stop()
tb.wait()
rec_msg = snk.get_message(0)
self.assertTrue(pmt.eqv(rec_msg, msg))
def __init__(self):
gr.top_block.__init__(self, "Nwk")
Qt.QWidget.__init__(self)
self.setWindowTitle("Nwk")
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", "nwk")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.tfg_repetidor_caracteres_0 = tfg.repetidor_caracteres(2)
self.tfg_mensaje_a_mayusculas_0 = tfg.mensaje_a_mayusculas()
self.tfg_imprimir_mensajes_0 = tfg.imprimir_mensajes()
self.tfg_NWK_stack_constructor_0 = tfg.NWK_stack_constructor(
0x12, 0x24)
self.blocks_message_strobe_0 = blocks.message_strobe(
pmt.intern("asdfghk"), 1000)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0, 'strobe'),
(self.tfg_mensaje_a_mayusculas_0, 'entrada'))
self.msg_connect((self.tfg_NWK_stack_constructor_0, 'out(MAC)'),
(self.tfg_repetidor_caracteres_0, 'entrada'))
self.msg_connect((self.tfg_mensaje_a_mayusculas_0, 'salida'),
(self.tfg_NWK_stack_constructor_0, 'in(APS)'))
self.msg_connect((self.tfg_repetidor_caracteres_0, 'salida'),
(self.tfg_imprimir_mensajes_0, 'entrada'))
def test_001_t (self):
# set up pmt
in_2 = (-1,2,-3,4,5,0)
in_3 = (1,2,3,4,5,0)
in_4 = (1,-2.1,3,-4.2,5.9,0)
pmt_1 = pmt.list2(pmt.string_to_symbol("rx_time"),pmt.from_long(0))
pmt_2 = pmt.list2(pmt.string_to_symbol("test"),pmt.init_f32vector(6,in_2))
pmt_3 = pmt.list2(pmt.string_to_symbol("velocity"),pmt.init_f32vector(6,in_3))
pmt_4 = pmt.list2(pmt.string_to_symbol("test2"),pmt.init_f32vector(6,in_4))
pmt_in = pmt.list4(pmt_1,pmt_2,pmt_3,pmt_4)
# set up fg
symbols = ("test", "test2")
const_add = (1, -2)
const_mult = (-5, 1)
strobe = blocks.message_strobe(pmt_in,400);
test = radar.msg_manipulator(symbols,const_add,const_mult)
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", test, "Msg in")
self.tb.msg_connect(test, "Msg out", debug, "store")
self.tb.msg_connect(test, "Msg out", debug, "print")
# run fg
self.tb.start()
sleep(0.5)
self.tb.stop()
self.tb.wait()
# check data
msg = debug.get_message(0)
out_2 = pmt.f32vector_elements(pmt.nth(1,pmt.nth(1,msg)))
out_3 = pmt.f32vector_elements(pmt.nth(1,pmt.nth(2,msg)))
out_4 = pmt.f32vector_elements(pmt.nth(1,pmt.nth(3,msg)))
ref_2 = [0]*6
ref_3 = [0]*6
ref_4 = [0]*6
for k in range(6):
ref_2[k] = (in_2[k]+const_add[0])*const_mult[0]
ref_3[k] = in_3[k]
ref_4[k] = (in_4[k]+const_add[1])*const_mult[1]
for k in range(6): # do asserts
self.assertAlmostEqual(ref_2[k],out_2[k],3)
self.assertAlmostEqual(ref_3[k],out_3[k],3)
self.assertAlmostEqual(ref_4[k],out_4[k],3)
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 test_msg_strobe(self):
print("\n=== Test 1, with GNU Radio message_strobe\n")
tst_msg = "--- FROM message strobe TO msg_sink"
src = blocks.message_strobe(pmt.intern(tst_msg), 1000)
blk_sink = msg_sink()
self.tb.msg_connect((src, "strobe"),
(blk_sink, blk_sink.ports_in[0].port))
#self.tb.run() # for flowgraphs that will stop on its own!
self.tb.start()
time.sleep(5)
self.tb.stop()
self.tb.wait()
return
def test_003_some_unfixable_packets(self):
snk = prbs_sink_pdu(self.PACKET_LENGTH_BYTES * 8, self.PRBS_RESET_LEN,
self.NUM_GENERATED_PACKETS)
# We just need something connected to the trimmer block for
# the flowgraph to compile, but we'll post messages to it directly
src = blocks.message_strobe(pmt.PMT_NIL, 9999999)
self.tb.msg_connect((src, 'strobe'), (snk, 'all'))
self.tb.msg_connect((src, 'strobe'), (snk, 'corrected'))
self.tb.start()
for packet in self.packets[:180]:
snk.to_basic_block()._post(
pmt.intern('all'), pmt.cons(pmt.PMT_NIL, pmt.to_pmt(packet)))
for packet in self.packets[:160]:
snk.to_basic_block()._post(
pmt.intern('corrected'),
pmt.cons(pmt.PMT_NIL, pmt.to_pmt(packet)))
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
self.assertEqual(snk.statistics["Expected number of packets sent"],
200)
self.assertEqual(snk.statistics["Total number of packets received"],
180)
self.assertEqual(
snk.statistics["Total number of correct packets after FEC"], 160)
self.assertEqual(
snk.statistics[
"Total number of wrong length packets after FEC (This should be 0)"],
0)
self.assertEqual(
snk.statistics[
"Total number of erroneous packets after FEC (This should be 0)"],
0)
self.assertEqual(
snk.statistics["Total number of unique packets after FEC"], 160)
self.assertEqual(snk.statistics["Total number of duplicates"], 0)
self.assertAlmostEqual(snk.statistics["Frame error rate"], 0.2)
self.assertTrue(
np.array_equal(
snk.collected_packets,
np.concatenate((np.ones([self.NUM_GENERATED_PACKETS - 40]),
np.zeros([40])))))
def concat_test (self, data_to_concat):
payload = [0x00]
strobe = blocks.message_strobe(pmt.cons(pmt.PMT_NIL, pmt.to_pmt(payload)), 200)
concatenator = data_concatenator(data_to_concat=data_to_concat)
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", concatenator, "in")
self.tb.msg_connect(concatenator, "out", debug, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
#Please get rid of this sleep if you know how!
time.sleep(0.1)
self.tb.stop()
result_data = pmt.to_python(pmt.cdr(debug.get_message(0)))
self.assertEqual(payload + data_to_concat , result_data.tolist())
def test_001_t (self):
src = blocks.vector_source_c(range(10000), False, 1, [])
separator = inspector_test.signal_separator_c(32000, firdes.WIN_HAMMING, 0.1, 100, False, inspector_test.map_float_vector({0.0:[0.0]}))
vec_sink = blocks.vector_sink_c(1)
ext = inspector_test.signal_extractor_c(0)
snk = blocks.vector_sink_c(1)
# pack message
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12500)
pmt.f32vector_set(flanks, 1, 20)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
taps = filter.firdes.low_pass(1, 32000, 500, 50, firdes.WIN_HAMMING, 6.76)
self.tb.connect(src, separator)
self.tb.connect(src, vec_sink)
self.tb.msg_connect((msg_src, 'strobe'), (separator, 'map_in'))
self.tb.msg_connect((separator, 'sig_out'), (ext, 'sig_in'))
self.tb.connect(ext, snk)
self.tb.start()
time.sleep(0.3)
self.tb.stop()
self.tb.wait()
data = vec_sink.data()
sig = numpy.zeros(len(vec_sink.data()), dtype=complex)
for i in range(len(vec_sink.data())):
sig[i] = data[i]*numpy.exp(-1j*2*numpy.pi*12500*i*1/32000)
taps = filter.firdes.low_pass(1, 32000, 900, 90, firdes.WIN_HAMMING, 6.76)
sig = numpy.convolve(sig, taps, 'full')
out = numpy.empty([0])
decim = 32000/20/100
j = 0
for i in range(len(sig)/decim):
out = numpy.append(out, sig[j])
j += decim
data = snk.data()
for i in range(min(len(out), len(data))):
self.assertComplexAlmostEqual2(out[i], data[i], abs_eps=0.01)
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
import pyqt
from gnuradio import blocks
self.strobe = blocks.message_strobe(
pmt.cons(
pmt.PMT_NIL,
pmt.to_pmt( numpy.random.normal( 0, 1, 256 ) )
),
500 )
self.raster = raster_plot("")
self._raster_win = self.raster;
self.top_layout.addWidget(self._raster_win)
self.msg_connect( self.strobe, "strobe", self.raster, "pdus" )
def test_001_t (self):
# set up fg
num_mean = 1
center_freq = 1
antenna_gain_tx = 1
antenna_gain_rx = 1
usrp_gain_rx = 1
amplitude = 1
corr_factor = 1
exponent = 1
Range = (10, 20, 30)
power = (15, 30, 45)
pmt_range = pmt.list2(pmt.string_to_symbol('range'),pmt.init_f32vector(len(Range),Range))
pmt_power = pmt.list2(pmt.string_to_symbol('power'),pmt.init_f32vector(len(power),power))
pmt_misc = pmt.list2(pmt.string_to_symbol('misc'),pmt.init_f32vector(3,(1,2,3)))
pmt_in = pmt.list3(pmt_misc,pmt_range,pmt_power)
src = blocks.message_strobe(pmt_in, 300)
est = radar.estimator_rcs(num_mean, center_freq, antenna_gain_tx, antenna_gain_rx, usrp_gain_rx, amplitude, corr_factor, exponent)
snk = blocks.message_debug()
self.tb.msg_connect(src,"strobe",est,"Msg in")
self.tb.msg_connect(est,"Msg out",snk,"store")
self.tb.msg_connect(est,"Msg out",snk,"print")
self.tb.start()
sleep(0.5)
self.tb.stop()
self.tb.wait()
# check data
msg = snk.get_message(0)
wavel = 3e8/center_freq
d_antenna_gain_abs_rx = 10**(antenna_gain_rx/10)
d_antenna_gain_abs_tx = 10**(antenna_gain_tx/10)
power_rx = power[0]**exponent / 10**(usrp_gain_rx/10);
power_tx = amplitude
rcs_ref = (4*math.pi)**(3)/(d_antenna_gain_abs_rx*d_antenna_gain_abs_tx*wavel**2)*Range[0]**4*power_rx/power_tx*corr_factor
self.assertAlmostEqual( rcs_ref, pmt.f32vector_ref(pmt.nth(1,(pmt.nth(0,msg))),0), 4 ) # check rcs value
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.blocks_random_pdu_0 = blocks.random_pdu(32, 32, chr(0xFF), 1)
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 10000)
self.blocks_message_debug_0 = blocks.message_debug()
self.ax25_pdu_prepend_append_0 = ax25.pdu_prepend_append(-6, -2, 0xAA)
##################################################
# Connections
##################################################
self.msg_connect((self.ax25_pdu_prepend_append_0, 'pdu_out'), (self.blocks_message_debug_0, 'print_pdu'))
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.ax25_pdu_prepend_append_0, 'pdu_in'))
self.msg_connect((self.blocks_random_pdu_0, 'pdus'), (self.blocks_message_debug_0, 'print_pdu'))
def test_001_t (self):
# set up fg
self.trigger = blocks.message_strobe(pmt.cons(pmt.intern("trigger"), pmt.intern("dummycdr")),10)
self.src_ref = ieee802_15_4.make_pair_with_blob((0,1,2,3))
self.src_test = ieee802_15_4.make_pair_with_blob((0,1,4,3))
self.snk = ieee802_15_4.compare_blobs()
self.tb.msg_connect(self.trigger, "strobe", self.src_ref, "in")
self.tb.msg_connect(self.trigger, "strobe", self.src_test, "in")
self.tb.msg_connect(self.src_ref, "out", self.snk, "ref")
self.tb.msg_connect(self.src_test, "out", self.snk, "test")
self.tb.start()
time.sleep(0.1)
self.tb.stop()
# check data
bits_per_blob = 4*8
errors_per_blob = 2.0
ref_ber = errors_per_blob/bits_per_blob
ber = self.snk.get_ber()
print "ber: ", ber
print "ref ber:", ref_ber
self.assertTrue(ref_ber == ber)
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Blocks
##################################################
self.crypto_sym_ciph_desc_0 = crypto.sym_ciph_desc("aes-256-ofb", False, ())
self.crypto_sym_enc_0 = crypto.sym_enc(self.crypto_sym_ciph_desc_0)
self.crypto_sym_dec_0 = crypto.sym_dec(self.crypto_sym_ciph_desc_0)
self.blocks_message_strobe_0_0 = blocks.message_strobe(pmt.make_u8vector(16,65), 500)
self.blocks_message_debug_0 = blocks.message_debug()
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0_0, 'strobe'), (self.crypto_sym_enc_0, 'pdus'))
self.msg_connect((self.crypto_sym_dec_0, 'pdus'), (self.blocks_message_debug_0, 'print'))
self.msg_connect((self.crypto_sym_enc_0, 'pdus'), (self.crypto_sym_dec_0, 'pdus'))
def test_001_t (self):
# set up fg
msg_meta = pmt.make_dict()
msg_meta = pmt.dict_add(msg_meta, pmt.to_pmt("freq"), pmt.to_pmt("val"))
vec1 = [0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00];
msg_vector = pmt.init_u8vector(len(vec1), vec1)
msg = pmt.cons(msg_meta, msg_vector)
src = blocks.message_strobe(msg, 10)
dut = capture_tools.bit_sniffer(fade_out=500, hexadecimal=True)
self.tb.msg_connect((src, "strobe"), (dut, "packets"))
self.tb.start ()
time.sleep(5)
vec1 = [0x01, 0x00, 0x01, 0x00, 0x01, 0x00];
msg_vector = pmt.init_u8vector(len(vec1), vec1)
msg = pmt.cons(msg_meta, msg_vector)
src.set_msg(msg);
time.sleep(5)
vec1 = [0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01];
msg_vector = pmt.init_u8vector(len(vec1), vec1)
msg = pmt.cons(msg_meta, msg_vector)
src.set_msg(msg);
time.sleep(5)
self.tb.stop()
def setUp (self):
self.tb = gr.top_block ()
# These are block parameters
msg_buf_name_in = "cell_id"
msg_buf_name_out = "pilots"
N_rb_dl = 6
ant_port = 0
# These parameters are regarded as "data"
cell_id = 124
# Set up msg inputs and outputs
msg = pmt.pmt_from_long(cell_id)
self.strobe = blocks.message_strobe(msg, 1000)
self.dbg = blocks.message_debug()
# UUT
self.param = estimator_parameterizer_msg(msg_buf_name_in, msg_buf_name_out, N_rb_dl, ant_port)
# Set up connections
self.tb.msg_connect(self.strobe, "strobe", self.param, msg_buf_name_in)
self.tb.msg_connect(self.param, msg_buf_name_out, self.dbg, "store")
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
_icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png"
self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.tnc_hdlc_framer_0 = tnc.hdlc_framer(preamble_length=50, postamble_length=7,verbose=False, use_scrambler=False)
self.tnc_hdlc_deframer_0 = tnc.hdlc_deframer()
self.tnc_ax25_framer_0 = tnc.ax25_framer(mycall="KI4MTT",destcall="KI4MTS",verbose=True)
self.tnc_ax25_deframer_0 = tnc.ax25_deframer(mycall="KI4MTT",verbose=True)
self.blocks_random_pdu_0 = blocks.random_pdu(50, 50)
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.intern("TEST"), 1000)
self.blocks_message_debug_0 = blocks.message_debug()
##################################################
# Connections
##################################################
self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.tnc_hdlc_deframer_0, 0))
##################################################
# Asynch Message 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.tnc_ax25_framer_0, "in")
self.msg_connect(self.tnc_ax25_deframer_0, "out", self.blocks_message_debug_0, "print_pdu")
self.msg_connect(self.tnc_ax25_framer_0, "out", self.tnc_hdlc_framer_0, "in")
self.msg_connect(self.tnc_hdlc_framer_0, "out", self.blocks_pdu_to_tagged_stream_0, "pdus")
self.msg_connect(self.tnc_hdlc_deframer_0, "out", self.tnc_ax25_deframer_0, "in")
def __init__(self):
gr.top_block.__init__(self, "Calibration Example")
Qt.QWidget.__init__(self)
self.setWindowTitle("Calibration Example")
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", "calibration_example_gui_manual")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.speed_of_light = speed_of_light = 299792458
self.antenna_spacing = antenna_spacing = 0.1
self.variable_qtgui_chooser_0_1_1 = variable_qtgui_chooser_0_1_1 = 1
self.variable_qtgui_chooser_0_1_0 = variable_qtgui_chooser_0_1_0 = 0
self.variable_qtgui_chooser_0_0_0 = variable_qtgui_chooser_0_0_0 = 1
self.variable_qtgui_chooser_0_0 = variable_qtgui_chooser_0_0 = 0
self.samp_rate = samp_rate = 100000000/64
self.gain_rx = gain_rx = 0
self.center_freq = center_freq = speed_of_light/(2*antenna_spacing)
self.cal_freq = cal_freq = 1024
self.Shift_1 = Shift_1 = -4
self.Shift_0 = Shift_0 = -4
self.Shift = Shift = -4
##################################################
# Blocks
##################################################
self._variable_qtgui_chooser_0_1_1_options = (1, 0, )
self._variable_qtgui_chooser_0_1_1_labels = ("Not Started", "Start Save", )
self._variable_qtgui_chooser_0_1_1_group_box = Qt.QGroupBox("Trigger Data Save")
self._variable_qtgui_chooser_0_1_1_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._variable_qtgui_chooser_0_1_1_button_group = variable_chooser_button_group()
self._variable_qtgui_chooser_0_1_1_group_box.setLayout(self._variable_qtgui_chooser_0_1_1_box)
for i, label in enumerate(self._variable_qtgui_chooser_0_1_1_labels):
radio_button = Qt.QRadioButton(label)
self._variable_qtgui_chooser_0_1_1_box.addWidget(radio_button)
self._variable_qtgui_chooser_0_1_1_button_group.addButton(radio_button, i)
self._variable_qtgui_chooser_0_1_1_callback = lambda i: Qt.QMetaObject.invokeMethod(self._variable_qtgui_chooser_0_1_1_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._variable_qtgui_chooser_0_1_1_options.index(i)))
self._variable_qtgui_chooser_0_1_1_callback(self.variable_qtgui_chooser_0_1_1)
self._variable_qtgui_chooser_0_1_1_button_group.buttonClicked[int].connect(
lambda i: self.set_variable_qtgui_chooser_0_1_1(self._variable_qtgui_chooser_0_1_1_options[i]))
self.top_layout.addWidget(self._variable_qtgui_chooser_0_1_1_group_box)
self._variable_qtgui_chooser_0_0_0_options = (0, 1, )
self._variable_qtgui_chooser_0_0_0_labels = ("Enable", "Disable", )
self._variable_qtgui_chooser_0_0_0_group_box = Qt.QGroupBox("Distant Transmitter Enable")
self._variable_qtgui_chooser_0_0_0_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._variable_qtgui_chooser_0_0_0_button_group = variable_chooser_button_group()
self._variable_qtgui_chooser_0_0_0_group_box.setLayout(self._variable_qtgui_chooser_0_0_0_box)
for i, label in enumerate(self._variable_qtgui_chooser_0_0_0_labels):
radio_button = Qt.QRadioButton(label)
self._variable_qtgui_chooser_0_0_0_box.addWidget(radio_button)
self._variable_qtgui_chooser_0_0_0_button_group.addButton(radio_button, i)
self._variable_qtgui_chooser_0_0_0_callback = lambda i: Qt.QMetaObject.invokeMethod(self._variable_qtgui_chooser_0_0_0_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._variable_qtgui_chooser_0_0_0_options.index(i)))
self._variable_qtgui_chooser_0_0_0_callback(self.variable_qtgui_chooser_0_0_0)
self._variable_qtgui_chooser_0_0_0_button_group.buttonClicked[int].connect(
lambda i: self.set_variable_qtgui_chooser_0_0_0(self._variable_qtgui_chooser_0_0_0_options[i]))
self.top_layout.addWidget(self._variable_qtgui_chooser_0_0_0_group_box)
self._variable_qtgui_chooser_0_0_options = (0, 1, )
self._variable_qtgui_chooser_0_0_labels = ("Enable", "Disable", )
self._variable_qtgui_chooser_0_0_group_box = Qt.QGroupBox("Source Enable")
self._variable_qtgui_chooser_0_0_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._variable_qtgui_chooser_0_0_button_group = variable_chooser_button_group()
self._variable_qtgui_chooser_0_0_group_box.setLayout(self._variable_qtgui_chooser_0_0_box)
for i, label in enumerate(self._variable_qtgui_chooser_0_0_labels):
radio_button = Qt.QRadioButton(label)
self._variable_qtgui_chooser_0_0_box.addWidget(radio_button)
self._variable_qtgui_chooser_0_0_button_group.addButton(radio_button, i)
self._variable_qtgui_chooser_0_0_callback = lambda i: Qt.QMetaObject.invokeMethod(self._variable_qtgui_chooser_0_0_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._variable_qtgui_chooser_0_0_options.index(i)))
self._variable_qtgui_chooser_0_0_callback(self.variable_qtgui_chooser_0_0)
self._variable_qtgui_chooser_0_0_button_group.buttonClicked[int].connect(
lambda i: self.set_variable_qtgui_chooser_0_0(self._variable_qtgui_chooser_0_0_options[i]))
self.top_layout.addWidget(self._variable_qtgui_chooser_0_0_group_box)
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, "Input")
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, "Post Gain Correct")
self.tab_widget_2 = Qt.QWidget()
self.tab_layout_2 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_2)
self.tab_grid_layout_2 = Qt.QGridLayout()
self.tab_layout_2.addLayout(self.tab_grid_layout_2)
self.tab.addTab(self.tab_widget_2, "Post Phase Correct")
self.top_layout.addWidget(self.tab)
self._Shift_1_range = Range(-4, 4, 0.01, -4, 200)
self._Shift_1_win = RangeWidget(self._Shift_1_range, self.set_Shift_1, "Shift", "counter_slider", float)
self.top_layout.addWidget(self._Shift_1_win)
self._Shift_0_range = Range(-4, 4, 0.01, -4, 200)
self._Shift_0_win = RangeWidget(self._Shift_0_range, self.set_Shift_0, "Shift", "counter_slider", float)
self.top_layout.addWidget(self._Shift_0_win)
self._Shift_range = Range(-4, 4, 0.01, -4, 200)
self._Shift_win = RangeWidget(self._Shift_range, self.set_Shift, "Shift", "counter_slider", float)
self.top_layout.addWidget(self._Shift_win)
self._variable_qtgui_chooser_0_1_0_options = (1, 0, )
self._variable_qtgui_chooser_0_1_0_labels = ("Stop", "Running", )
self._variable_qtgui_chooser_0_1_0_group_box = Qt.QGroupBox("Sync System")
self._variable_qtgui_chooser_0_1_0_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._variable_qtgui_chooser_0_1_0_button_group = variable_chooser_button_group()
self._variable_qtgui_chooser_0_1_0_group_box.setLayout(self._variable_qtgui_chooser_0_1_0_box)
for i, label in enumerate(self._variable_qtgui_chooser_0_1_0_labels):
radio_button = Qt.QRadioButton(label)
self._variable_qtgui_chooser_0_1_0_box.addWidget(radio_button)
self._variable_qtgui_chooser_0_1_0_button_group.addButton(radio_button, i)
self._variable_qtgui_chooser_0_1_0_callback = lambda i: Qt.QMetaObject.invokeMethod(self._variable_qtgui_chooser_0_1_0_button_group, "updateButtonChecked", Qt.Q_ARG("int", self._variable_qtgui_chooser_0_1_0_options.index(i)))
self._variable_qtgui_chooser_0_1_0_callback(self.variable_qtgui_chooser_0_1_0)
self._variable_qtgui_chooser_0_1_0_button_group.buttonClicked[int].connect(
lambda i: self.set_variable_qtgui_chooser_0_1_0(self._variable_qtgui_chooser_0_1_0_options[i]))
self.top_layout.addWidget(self._variable_qtgui_chooser_0_1_0_group_box)
self.uhd_usrp_source_0_0 = uhd.usrp_source(
",".join(("addr0=192.168.70.2,addr1=192.168.20.2,addr2=192.168.30.2,addr3=192.168.50.2", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(4),
),
)
self.uhd_usrp_source_0_0.set_clock_source("external", 0)
self.uhd_usrp_source_0_0.set_time_source("external", 0)
self.uhd_usrp_source_0_0.set_clock_source("external", 1)
self.uhd_usrp_source_0_0.set_time_source("external", 1)
self.uhd_usrp_source_0_0.set_clock_source("external", 2)
self.uhd_usrp_source_0_0.set_time_source("external", 2)
self.uhd_usrp_source_0_0.set_clock_source("external", 3)
self.uhd_usrp_source_0_0.set_time_source("external", 3)
self.uhd_usrp_source_0_0.set_time_unknown_pps(uhd.time_spec())
self.uhd_usrp_source_0_0.set_samp_rate(samp_rate)
self.uhd_usrp_source_0_0.set_center_freq(center_freq, 0)
self.uhd_usrp_source_0_0.set_gain(gain_rx, 0)
self.uhd_usrp_source_0_0.set_center_freq(center_freq, 1)
self.uhd_usrp_source_0_0.set_gain(gain_rx, 1)
self.uhd_usrp_source_0_0.set_center_freq(center_freq, 2)
self.uhd_usrp_source_0_0.set_gain(gain_rx, 2)
self.uhd_usrp_source_0_0.set_center_freq(center_freq, 3)
self.uhd_usrp_source_0_0.set_gain(gain_rx, 3)
self.uhd_usrp_sink_0_0_0 = uhd.usrp_sink(
",".join(("addr=192.168.80.2", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0_0_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
self.uhd_usrp_sink_0_0_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0_0_0.set_center_freq(center_freq, 0)
self.uhd_usrp_sink_0_0_0.set_gain(30, 0)
self.uhd_usrp_sink_0_0 = uhd.usrp_sink(
",".join(("addr=192.168.40.2", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0_0.set_clock_source("mimo", 0)
self.uhd_usrp_sink_0_0.set_time_source("mimo", 0)
self.uhd_usrp_sink_0_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
self.uhd_usrp_sink_0_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0_0.set_center_freq(center_freq, 0)
self.uhd_usrp_sink_0_0.set_gain(10, 0)
self.save_data_hier_0 = save_data_hier(
keep=1,
samples=2**22,
skips=2**18,
vec_size=1,
)
self.real_time_scope_hier_0_0_0 = real_time_scope_hier(
npoints=3000,
samp_rate=samp_rate,
)
self.tab_layout_2.addWidget(self.real_time_scope_hier_0_0_0)
self.real_time_scope_hier_0 = real_time_scope_hier(
npoints=3000,
samp_rate=samp_rate,
)
self.tab_layout_0.addWidget(self.real_time_scope_hier_0)
self.blocks_multiply_const_vxx_0_2 = blocks.multiply_const_vcc((complex(numpy.cos(Shift_1),numpy.sin(Shift_1)), ))
self.blocks_multiply_const_vxx_0_1 = blocks.multiply_const_vcc((complex(numpy.cos(Shift_0),numpy.sin(Shift_0)), ))
self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vcc((complex(numpy.cos(Shift),numpy.sin(Shift)), ))
self.blocks_message_strobe_0_0 = blocks.message_strobe(pmt.from_double(variable_qtgui_chooser_0_1_1), 1000)
self.blks2_valve_0_0 = grc_blks2.valve(item_size=gr.sizeof_gr_complex*1, open=bool(variable_qtgui_chooser_0_0_0))
self.blks2_valve_0 = grc_blks2.valve(item_size=gr.sizeof_gr_complex*1, open=bool(variable_qtgui_chooser_0_0))
self.analog_sig_source_x_0_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, cal_freq, 1, 0)
self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, cal_freq, 1, 0)
##################################################
# Connections
##################################################
self.msg_connect((self.blocks_message_strobe_0_0, 'strobe'), (self.save_data_hier_0, 'Trigger'))
self.connect((self.analog_sig_source_x_0, 0), (self.blks2_valve_0, 0))
self.connect((self.analog_sig_source_x_0_0, 0), (self.blks2_valve_0_0, 0))
self.connect((self.blks2_valve_0, 0), (self.uhd_usrp_sink_0_0, 0))
self.connect((self.blks2_valve_0_0, 0), (self.uhd_usrp_sink_0_0_0, 0))
self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.real_time_scope_hier_0_0_0, 1))
self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.save_data_hier_0, 1))
self.connect((self.blocks_multiply_const_vxx_0_1, 0), (self.real_time_scope_hier_0_0_0, 2))
self.connect((self.blocks_multiply_const_vxx_0_1, 0), (self.save_data_hier_0, 2))
self.connect((self.blocks_multiply_const_vxx_0_2, 0), (self.real_time_scope_hier_0_0_0, 3))
self.connect((self.blocks_multiply_const_vxx_0_2, 0), (self.save_data_hier_0, 3))
self.connect((self.uhd_usrp_source_0_0, 1), (self.blocks_multiply_const_vxx_0_0, 0))
self.connect((self.uhd_usrp_source_0_0, 2), (self.blocks_multiply_const_vxx_0_1, 0))
self.connect((self.uhd_usrp_source_0_0, 3), (self.blocks_multiply_const_vxx_0_2, 0))
self.connect((self.uhd_usrp_source_0_0, 0), (self.real_time_scope_hier_0, 0))
self.connect((self.uhd_usrp_source_0_0, 1), (self.real_time_scope_hier_0, 1))
self.connect((self.uhd_usrp_source_0_0, 2), (self.real_time_scope_hier_0, 2))
self.connect((self.uhd_usrp_source_0_0, 3), (self.real_time_scope_hier_0, 3))
self.connect((self.uhd_usrp_source_0_0, 0), (self.real_time_scope_hier_0_0_0, 0))
self.connect((self.uhd_usrp_source_0_0, 0), (self.save_data_hier_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Ofdm Tx")
Qt.QWidget.__init__(self)
self.setWindowTitle("Ofdm Tx")
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_tx")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1e6
self.packet_len = packet_len = 100
self.len_tag_key = len_tag_key = "packet_len"
self.gain = gain = 60
self.fft_len = fft_len = 128
##################################################
# Blocks
##################################################
self._gain_layout = Qt.QVBoxLayout()
self._gain_tool_bar = Qt.QToolBar(self)
self._gain_layout.addWidget(self._gain_tool_bar)
self._gain_tool_bar.addWidget(Qt.QLabel("gain"+": "))
class qwt_counter_pyslot(Qwt.QwtCounter):
def __init__(self, parent=None):
Qwt.QwtCounter.__init__(self, parent)
@pyqtSlot('double')
def setValue(self, value):
super(Qwt.QwtCounter, self).setValue(value)
self._gain_counter = qwt_counter_pyslot()
self._gain_counter.setRange(0, 90, 1)
self._gain_counter.setNumButtons(2)
self._gain_counter.setValue(self.gain)
self._gain_tool_bar.addWidget(self._gain_counter)
self._gain_counter.valueChanged.connect(self.set_gain)
self._gain_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._gain_slider.setRange(0, 90, 1)
self._gain_slider.setValue(self.gain)
self._gain_slider.setMinimumWidth(200)
self._gain_slider.valueChanged.connect(self.set_gain)
self._gain_layout.addWidget(self._gain_slider)
self.top_layout.addLayout(self._gain_layout)
self.uhd_usrp_sink_0 = uhd.usrp_sink(
device_addr="",
stream_args=uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_subdev_spec("A:A", 0)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(400e6, 0)
self.uhd_usrp_sink_0.set_gain(gain, 0)
self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
interpolation=2,
decimation=1,
taps=None,
fractional_bw=None,
)
self.fosdem_burst_marker_0 = fosdem.burst_marker(gr.sizeof_gr_complex, len_tag_key, 0)
self.digital_ofdm_tx_0 = digital.ofdm_tx(
fft_len=fft_len, cp_len=fft_len/4,
packet_length_tag_key=len_tag_key,
bps_header=1,
bps_payload=2,
rolloff=0,
debug_log=False,
scramble_bits=True
)
self.blocks_tagged_stream_multiply_length_0 = blocks.tagged_stream_multiply_length(gr.sizeof_gr_complex*1, len_tag_key, 2)
self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len")
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.05, ))
self.blocks_message_strobe_0 = blocks.message_strobe(pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(packet_len, 0xAA)), 1000)
##################################################
# Connections
##################################################
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_tagged_stream_multiply_length_0, 0))
self.connect((self.digital_ofdm_tx_0, 0), (self.rational_resampler_xxx_0, 0))
self.connect((self.rational_resampler_xxx_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_ofdm_tx_0, 0))
self.connect((self.blocks_tagged_stream_multiply_length_0, 0), (self.fosdem_burst_marker_0, 0))
self.connect((self.fosdem_burst_marker_0, 0), (self.uhd_usrp_sink_0, 0))
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.blocks_message_strobe_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus")