def test_003_ofdm (self):
""" Header 1: 193 bytes
Header 2: 8 bytes
2 bits per complex symbol, 32 carriers => 64 bits = 8 bytes per OFDM symbol
"""
encoded_headers = (
# | Number of bytes | Packet number | Parity
1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
)
packet_len_tagname = "packet_len"
frame_len_tagname = "frame_len"
src = gr.vector_source_b(encoded_headers)
header_formatter = digital.packet_header_ofdm(
(range(32),), # 32 carriers are occupied (which doesn't matter here)
1, # 1 OFDM symbol per header (= 32 bits)
packet_len_tagname,
frame_len_tagname,
"packet_num",
1, # 1 bit per header symbols (BPSK)
2 # 2 bits per payload symbol (QPSK)
)
parser = digital.packet_headerparser_b(header_formatter.base())
sink = gr.message_debug()
self.tb.connect(src, parser)
self.tb.msg_connect(parser, "header_data", sink, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.assertEqual(sink.num_messages(), 2)
msg1 = pmt.to_python(sink.get_message(0))
msg2 = pmt.to_python(sink.get_message(1))
self.assertEqual(msg1, {'packet_len': 193*4, 'frame_len': 25, 'packet_num': 0})
self.assertEqual(msg2, {'packet_len': 8*4, 'frame_len': 1, 'packet_num': 1})
def test_001_t (self):
"""
First header: Packet length 4, packet num 0
Second header: Packet 2, packet num 1
Third header: Invalid (parity bit does not check) (would be len 4, num 2)
"""
encoded_headers = (
# | Number of bytes | Packet number | Parity
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0
)
packet_len_tagname = "packet_len"
random_tag = gr.gr_tag_t()
random_tag.offset = 5
random_tag.key = pmt.pmt_string_to_symbol("foo")
random_tag.value = pmt.pmt_from_long(42)
src = gr.vector_source_b(encoded_headers, tags=(random_tag,))
parser = digital.packet_headerparser_b(32, packet_len_tagname)
sink = gr.message_debug()
self.tb.connect(src, parser)
self.tb.msg_connect(parser, "header_data", sink, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.assertEqual(sink.num_messages(), 3)
msg1 = pmt.to_python(sink.get_message(0))
msg2 = pmt.to_python(sink.get_message(1))
msg3 = pmt.to_python(sink.get_message(2))
self.assertEqual(msg1, {'packet_len': 4, 'packet_num': 0, 'foo': 42})
self.assertEqual(msg2, {'packet_len': 2, 'packet_num': 1})
self.assertEqual(msg3, False)
def test_001_t (self):
"""
First header: Packet length 4, packet num 0
Second header: Packet 2, packet num 1
Third header: Invalid (parity bit does not check) (would be len 4, num 2)
"""
encoded_headers = (
# | Number of bytes | Packet number | Parity
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0
)
packet_len_tagname = "packet_len"
src = gr.vector_source_b(encoded_headers)
parser = digital.packet_headerparser_b(32, packet_len_tagname)
sink = gr.message_debug()
self.tb.connect(src, parser)
self.tb.msg_connect(parser, "header_data", sink, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.assertEqual(sink.num_messages(), 3)
msg1 = pmt.to_python(sink.get_message(0))
msg2 = pmt.to_python(sink.get_message(1))
msg3 = pmt.to_python(sink.get_message(2))
self.assertEqual(msg1, {'packet_len': 4, 'packet_num': 0})
self.assertEqual(msg2, {'packet_len': 2, 'packet_num': 1})
self.assertEqual(msg3, False)
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 = gr.vector_sink_b()
snk = gr.tag_debug(1, "test")
snk.set_display(False)
dbg = gr.message_debug()
# Test that the right number of ports exist.
pi = snk3.message_ports_in()
po = snk3.message_ports_out()
self.assertEqual(pmt.pmt_length(pi), 0)
self.assertEqual(pmt.pmt_length(po), 1)
time.sleep(0.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.pmt_intern("pdus")
msg = pmt.pmt_cons(pmt.PMT_NIL, pmt.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.5)
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.pmt_cdr(result_msg)
#pmt.pmt_print(msg_vec)
# Convert the PMT vector into a Python list
msg_data = []
for i in xrange(16):
msg_data.append(pmt.pmt_u8vector_ref(msg_vec, i))
actual_data = 16 * [
0xFF,
]
self.assertEqual(actual_data, list(result_data))
self.assertEqual(actual_data, msg_data)
def setUp(self):
self.tb = gr.top_block()
N_rb_dl = 6
self.eq = lte_swig.linear_OFDM_estimator_vcvc(N_rb_dl)
self.demux = lte_swig.pbch_demux_vcvc(N_rb_dl)
self.ld = lte_swig.descrambling_vfvf()
self.daemon = lte_swig.cell_id_daemon(self.eq, self.demux, self.ld)
self.dbg = gr.message_debug()
self.tb.msg_connect(self.daemon, "cell_id", self.dbg, "print")
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 = gr.vector_sink_b()
snk = gr.tag_debug(1, "test")
snk.set_display(False)
dbg = gr.message_debug()
# Test that the right number of ports exist.
pi = snk3.message_ports_in()
po = snk3.message_ports_out()
self.assertEqual(pmt.pmt_length(pi), 0)
self.assertEqual(pmt.pmt_length(po), 1)
time.sleep(0.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.pmt_intern("pdus")
msg = pmt.pmt_cons( pmt.PMT_NIL, pmt.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.5)
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.pmt_cdr(result_msg)
#pmt.pmt_print(msg_vec)
# Convert the PMT vector into a Python list
msg_data = []
for i in xrange(16):
msg_data.append(pmt.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): grc_wxgui.top_block_gui.__init__(self, title="Top Block") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.openavionics_joystick_interface_0 = openavionics.joystick_interface() self.gr_message_debug_0 = gr.message_debug() ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.openavionics_joystick_interface_0, "out", self.gr_message_debug_0, "print")
def __init__(self):
grc_wxgui.top_block_gui.__init__(self, title="Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.openavionics_joystick_interface_0 = openavionics.joystick_interface(
)
self.gr_message_debug_0 = gr.message_debug()
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.openavionics_joystick_interface_0, "out",
self.gr_message_debug_0, "print")
def test_001_t (self):
expected_data = (
# | Number of symbols | Packet number | Parity
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0
)
tagname = "packet_len"
src = gr.vector_source_b(expected_data)
parser = digital.packet_headerparser_b(32, tagname)
sink = gr.message_debug()
self.tb.connect(src, parser)
self.tb.msg_connect(parser, "header_data", sink, "store")
self.tb.start ()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.assertEqual(sink.num_messages(), 3)
msg = sink.get_message(0)
def test_002_pipe(self):
"""
Create N packets of random length, pipe them through header generator,
back to header parser, make sure output is the same.
"""
N = 20
header_len = 32
packet_len_tagname = "packet_len"
packet_lengths = [random.randint(1, 100) for x in range(N)]
data, tags = tagged_streams.packets_to_vectors([range(packet_lengths[i]) for i in range(N)], packet_len_tagname)
src = gr.vector_source_b(data, False, 1, tags)
header_gen = digital.packet_headergenerator_bb(header_len, packet_len_tagname)
header_parser = digital.packet_headerparser_b(header_len, packet_len_tagname)
sink = gr.message_debug()
self.tb.connect(src, header_gen, header_parser)
self.tb.msg_connect(header_parser, "header_data", sink, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.assertEqual(sink.num_messages(), N)
for i in xrange(N):
msg = pmt.to_python(sink.get_message(i))
self.assertEqual(msg, {'packet_len': packet_lengths[i], 'packet_num': i})
def __init__(self, options, hostname):
gr.top_block.__init__(self)
##################################################
# Variables
##################################################
window_size = options.window_size
sync_length = options.sync_length
gain = options.gain
freq = options.freq
samp_rate = options.bandwidth
self.uhd_usrp_source_0 = uhd.usrp_source(device_addr="", 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(freq, 0)
self.uhd_usrp_source_0.set_gain(gain, 0)
self.ieee802_1_ofdm_sync_short_0 = gr_ieee802_11.ofdm_sync_short(0.8, 80 * 80, 2, False)
self.ieee802_1_ofdm_sync_long_0 = gr_ieee802_11.ofdm_sync_long(sync_length, 100, False)
self.ieee802_1_ofdm_equalize_symbols_0 = gr_ieee802_11.ofdm_equalize_symbols(False)
self.ieee802_1_ofdm_decode_signal_0 = gr_ieee802_11.ofdm_decode_signal(False)
self.ieee802_1_ofdm_decode_mac_0 = gr_ieee802_11.ofdm_decode_mac(False)
self.ieee802_11_ofdm_parse_mac_0 = gr_ieee802_11.ofdm_parse_mac(True)
self.gr_stream_to_vector_0 = gr.stream_to_vector(gr.sizeof_gr_complex*1, 64)
self.gr_socket_pdu_0 = gr.socket_pdu("TCP_SERVER", hostname, str(options.PHYRXport), 10000)
self.gr_skiphead_0 = gr.skiphead(gr.sizeof_gr_complex*1, 20000000)
self.gr_multiply_xx_0 = gr.multiply_vcc(1)
self.gr_divide_xx_0 = gr.divide_ff(1)
self.gr_delay_0_0 = gr.delay(gr.sizeof_gr_complex*1, sync_length)
self.gr_delay_0 = gr.delay(gr.sizeof_gr_complex*1, 16)
self.gr_conjugate_cc_0 = gr.conjugate_cc()
self.gr_complex_to_mag_squared_0 = gr.complex_to_mag_squared(1)
self.gr_complex_to_mag_0 = gr.complex_to_mag(1)
self.fir_filter_xxx_0_0 = filter.fir_filter_ccf(1, ([1]*window_size))
self.fir_filter_xxx_0 = filter.fir_filter_fff(1, ([1]*window_size))
self.fft_vxx_0 = fft.fft_vcc(64, True, (), True, 1)
self.message_debug = gr.message_debug()
##################################################
# Connections
##################################################
self.connect((self.uhd_usrp_source_0, 0), (self.gr_skiphead_0, 0))
self.connect((self.gr_skiphead_0, 0), (self.gr_complex_to_mag_squared_0, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.gr_divide_xx_0, 1))
self.connect((self.gr_complex_to_mag_squared_0, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.gr_skiphead_0, 0), (self.gr_multiply_xx_0, 0))
self.connect((self.gr_conjugate_cc_0, 0), (self.gr_multiply_xx_0, 1))
self.connect((self.gr_complex_to_mag_0, 0), (self.gr_divide_xx_0, 0))
self.connect((self.gr_multiply_xx_0, 0), (self.fir_filter_xxx_0_0, 0))
self.connect((self.fir_filter_xxx_0_0, 0), (self.gr_complex_to_mag_0, 0))
self.connect((self.gr_skiphead_0, 0), (self.gr_delay_0, 0))
self.connect((self.gr_delay_0, 0), (self.gr_conjugate_cc_0, 0))
self.connect((self.fft_vxx_0, 0), (self.ieee802_1_ofdm_equalize_symbols_0, 0))
self.connect((self.ieee802_1_ofdm_equalize_symbols_0, 0), (self.ieee802_1_ofdm_decode_signal_0, 0))
self.connect((self.ieee802_1_ofdm_decode_signal_0, 0), (self.ieee802_1_ofdm_decode_mac_0, 0))
self.connect((self.ieee802_1_ofdm_sync_short_0, 0), (self.gr_delay_0_0, 0))
self.connect((self.gr_delay_0, 0), (self.ieee802_1_ofdm_sync_short_0, 0))
self.connect((self.gr_divide_xx_0, 0), (self.ieee802_1_ofdm_sync_short_0, 1))
self.connect((self.gr_delay_0_0, 0), (self.ieee802_1_ofdm_sync_long_0, 1))
self.connect((self.ieee802_1_ofdm_sync_short_0, 0), (self.ieee802_1_ofdm_sync_long_0, 0))
self.connect((self.ieee802_1_ofdm_sync_long_0, 0), (self.gr_stream_to_vector_0, 0))
self.connect((self.gr_stream_to_vector_0, 0), (self.fft_vxx_0, 0))
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.ieee802_1_ofdm_decode_mac_0, "out", self.ieee802_11_ofdm_parse_mac_0, "in")
self.msg_connect(self.ieee802_11_ofdm_parse_mac_0, "out", self.gr_socket_pdu_0, "pdus")