def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
if pmt.length(msg) + 2 > self.mtu:
print "[ERROR] Transmitted frame is too long (%d bytes). Cannot exceed %d bytes." % (pmt.length(msg), self.mtu - 2)
return
#length = struct.pack('h', pmt.length(msg))
#print length, pmt.length(msg)
buff = list()
#buff.extend([x for x in length])
#buff.extend(pmt.u8vector_elements(msg))
length = pmt.length(msg)
buff.append(length >> 8) # MSB
buff.append(length & 0xFF) # LSB
buff.extend(pmt.u8vector_elements(msg))
pad_length = self.mtu - len(buff)
if pad_length:
buff.extend([self.pad_byte] * pad_length)
if debug:
print "Pushing a packet of length %d bytes" % length
self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
if pmt.length(msg) > self.mtu:
print "[ERROR] Received frame is too long (%d bytes). Cannot exceed %d bytes." % (
pmt.length(msg), self.mtu)
return
#print pmt.u8vector_elements(msg)[0:2]
#length = struct.unpack('h', pmt.u8vector_elements(msg)[0:2])
length_bytes = pmt.u8vector_elements(msg)[0:2]
length = length_bytes[0] << 8 | length_bytes[1]
#print length, pmt.length(msg)
if length == 0: # caught a Filler packet, drop it
return
buff = list()
buff.extend(pmt.u8vector_elements(msg)[2:2 + length])
#print buff
# TODO: Check for pad byte if there are any
#print pmt.length(buff)
buff = array.array('B', buff)
if debug:
print "Received a packet of length %d bytes" % length
self.message_port_pub(
pmt.intern('out'),
pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def test_001_t(self):
# set up fg
test_len = 1024
packet_len = test_len
samp_rate = 2000
center_freq = 1e9
velocity = (5, 15, 20)
src = radar.signal_generator_cw_c(packet_len, samp_rate, (0, 0), 1)
head = blocks.head(8, test_len)
sim = radar.static_target_simulator_cc(
(10, 10, 10), velocity, (1e12, 1e12, 1e12), (0, 0, 0), (0, ),
samp_rate, center_freq, 1, True, False)
mult = blocks.multiply_cc()
fft = radar.ts_fft_cc(packet_len)
cfar = radar.os_cfar_c(samp_rate, 5, 0, 0.78, 10, True)
est = radar.estimator_cw(center_freq)
res1 = radar.print_results()
res2 = radar.print_results()
gate = radar.msg_gate(('velocity', 'bla'), (8, 8), (17, 17))
debug1 = blocks.message_debug()
debug2 = blocks.message_debug()
self.tb.connect(src, head, (mult, 1))
self.tb.connect(head, sim, (mult, 0))
self.tb.connect(mult, fft, cfar)
self.tb.msg_connect(cfar, 'Msg out', est, 'Msg in')
self.tb.msg_connect(est, 'Msg out', res1, 'Msg in')
self.tb.msg_connect(est, 'Msg out', debug1, 'store')
self.tb.msg_connect(est, 'Msg out', gate, 'Msg in')
self.tb.msg_connect(gate, 'Msg out', debug2, 'store')
self.tb.msg_connect(gate, 'Msg out', res2, 'Msg in')
self.tb.start()
sleep(0.5)
self.tb.stop()
self.tb.wait()
# check data
msg1 = debug1.get_message(0) # msg without gate
msg2 = debug2.get_message(0) # msg with gate
self.assertEqual(
"velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth(
1, msg1))))) # check velocity message part (symbol), 1
self.assertEqual(
"velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth(
1, msg2))))) # check velocity message part (symbol), 2
self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg1))),
3) # check number of targets without gate
self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg2))),
1) # check nubmer of targets with gate
self.assertAlmostEqual(
1, velocity[1] / pmt.f32vector_ref(pmt.nth(1,
(pmt.nth(1, msg2))), 0),
1) # check velocity value
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 = pdu.pdu_to_tagged_stream(gr.types.byte_t)
snk3 = pdu.tagged_stream_to_pdu(gr.types.byte_t)
snk2 = blocks.vector_sink_b()
snk = blocks.tag_debug(1, "test")
snk.set_display(False)
dbg = blocks.message_debug()
# Test that the right number of ports exist.
pi = snk3.message_ports_in()
po = snk3.message_ports_out()
# system port is defined automatically
self.assertEqual(pmt.length(pi), 1)
self.assertEqual(pmt.length(po), 1)
self.tb.connect(src, snk)
self.tb.connect(src, snk2)
self.tb.connect(src, snk3)
self.tb.msg_connect(snk3, "pdus", dbg, "store")
# make our reference and message pmts
port = pmt.intern("pdus")
msg = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF))
# post the message
src.to_basic_block()._post(port, msg)
src.to_basic_block()._post(
pmt.intern("system"), pmt.cons(pmt.intern("done"),
pmt.from_long(1)))
self.tb.start()
self.tb.wait()
# Get the vector of data from the vector sink
result_data = snk2.data()
# Get the vector of data from the message sink
# Convert the message PMT as a pair into its vector
result_msg = dbg.get_message(0)
msg_vec = pmt.cdr(result_msg)
# pmt.print(msg_vec)
# Convert the PMT vector into a Python list
msg_data = []
for i in range(16):
msg_data.append(pmt.u8vector_ref(msg_vec, i))
actual_data = 16 * [
0xFF,
]
self.assertEqual(actual_data, list(result_data))
self.assertEqual(actual_data, msg_data)
def test_001_t(self):
# set up fg
test_len = 1024
packet_len = test_len
samp_rate = 2000
center_freq = 1e9
velocity = (5, 15, 20)
src = radar.signal_generator_cw_c(packet_len, samp_rate, (0, 0), 1)
head = blocks.head(8, test_len)
sim = radar.static_target_simulator_cc(
(10, 10, 10), velocity, (1e12, 1e12, 1e12), (0, 0, 0), (0,), samp_rate, center_freq, 1, True, False
)
mult = blocks.multiply_cc()
fft = radar.ts_fft_cc(packet_len)
cfar = radar.os_cfar_c(samp_rate, 5, 0, 0.78, 10, True)
est = radar.estimator_cw(center_freq)
res1 = radar.print_results()
res2 = radar.print_results()
gate = radar.msg_gate(("velocity", "bla"), (8, 8), (17, 17))
debug1 = blocks.message_debug()
debug2 = blocks.message_debug()
self.tb.connect(src, head, (mult, 1))
self.tb.connect(head, sim, (mult, 0))
self.tb.connect(mult, fft, cfar)
self.tb.msg_connect(cfar, "Msg out", est, "Msg in")
self.tb.msg_connect(est, "Msg out", res1, "Msg in")
self.tb.msg_connect(est, "Msg out", debug1, "store")
self.tb.msg_connect(est, "Msg out", gate, "Msg in")
self.tb.msg_connect(gate, "Msg out", debug2, "store")
self.tb.msg_connect(gate, "Msg out", res2, "Msg in")
self.tb.start()
sleep(0.5)
self.tb.stop()
self.tb.wait()
# check data
msg1 = debug1.get_message(0) # msg without gate
msg2 = debug2.get_message(0) # msg with gate
self.assertEqual(
"velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth(1, msg1))))
) # check velocity message part (symbol), 1
self.assertEqual(
"velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth(1, msg2))))
) # check velocity message part (symbol), 2
self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg1))), 3) # check number of targets without gate
self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg2))), 1) # check nubmer of targets with gate
self.assertAlmostEqual(
1, velocity[1] / pmt.f32vector_ref(pmt.nth(1, (pmt.nth(1, msg2))), 0), 1
) # check velocity value
def test_000(self):
# Just run some data through and make sure it doesn't puke.
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
src = blocks.pdu_to_tagged_stream(blocks.byte_t)
snk3 = blocks.tagged_stream_to_pdu(blocks.byte_t)
snk2 = blocks.vector_sink_b()
snk = blocks.tag_debug(1, "test")
snk.set_display(False)
dbg = blocks.message_debug()
# Test that the right number of ports exist.
pi = snk3.message_ports_in()
po = snk3.message_ports_out()
self.assertEqual(pmt.length(pi), 0)
self.assertEqual(pmt.length(po), 1)
self.tb.connect(src, snk)
self.tb.connect(src, snk2)
self.tb.connect(src, snk3)
self.tb.msg_connect(snk3, "pdus", dbg, "store")
self.tb.start()
# make our reference and message pmts
port = pmt.intern("pdus")
msg = pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF))
# post the message
src.to_basic_block()._post(port, msg) # eww, what's that smell?
while dbg.num_messages() < 1:
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
# Get the vector of data from the vector sink
result_data = snk2.data()
# Get the vector of data from the message sink
# Convert the message PMT as a pair into its vector
result_msg = dbg.get_message(0)
msg_vec = pmt.cdr(result_msg)
#pmt.print(msg_vec)
# Convert the PMT vector into a Python list
msg_data = []
for i in xrange(16):
msg_data.append(pmt.u8vector_ref(msg_vec, i))
actual_data = 16*[0xFF,]
self.assertEqual(actual_data, list(result_data))
self.assertEqual(actual_data, msg_data)
def msg_handler(self, p):
length = pmt.length(p)
for i in range(0,length):
element = pmt.nth(i, p)
key = pmt.nth(0, element)
value = pmt.nth(1, element)
if str(key) == "power":
output = pmt.f32vector_elements(value)[0]
output = 10 * math.log(output, 10)
output = pmt.make_f32vector(1, output)
if i==0:
outpmt = pmt.list1(pmt.list2(pmt.string_to_symbol(str(key) + "_dB"), output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol(str(key) + "_dB"), output))
output = pmt.nth(1, element)
if i==0:
outpmt = pmt.list1(pmt.list2(key, output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(key, output))
self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def test_001_t (self):
src = analog.sig_source_c(32000, analog.GR_COS_WAVE,
12500, 1)
detector = inspector.signal_detector_cvf(32000, 1024,
firdes.WIN_BLACKMAN_hARRIS, -80, 0.6, False, 0.5, 0.0001)
dst1 = blocks.null_sink(gr.sizeof_float*1024)
dst2 = blocks.null_sink(gr.sizeof_float*1024)
msg_dst = blocks.message_debug()
self.tb.connect(src, detector)
self.tb.connect((detector, 0), dst1)
self.tb.connect((detector, 1), dst2)
self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store'))
self.tb.start()
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
msg = msg_dst.get_message(1)
res_vector = numpy.empty([0, 2])
for i in range(pmt.length(msg)):
row = pmt.vector_ref(msg, i)
res_vector = numpy.vstack((res_vector, numpy.array(
[pmt.f32vector_ref(row, 0), pmt.f32vector_ref(row, 1)]
)))
self.assertAlmostEqual(12500.0, res_vector[0][0], delta=100)
self.assertAlmostEqual(0.0, res_vector[0][1], delta=200)
def test_001_t (self):
""" Simplest possible test: put in zeros, then header,
then payload, trigger signal, try to demux.
The return signal from the header parser is faked via _post()
Add in some tags for fun.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = make_tag('tag1', 0, 0)
# This goes on output 0, item 0:
testtag2 = make_tag('tag2', 23, n_zeros)
# This goes on output 0, item 2:
testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1)
# This goes on output 1, item 3:
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(testtag1, testtag2, testtag3, testtag4)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
mock_header_demod = HeaderToMessageBlock(
numpy.float32,
len(header),
[len(payload)]
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
payload_sink = blocks.vector_sink_f()
header_sink = blocks.vector_sink_f()
self.connect_all_blocks(data_src, trigger_src, hpd, mock_header_demod, payload_sink, header_sink)
self.run_tb(payload_sink, len(payload), header_sink, len(header))
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t (self):
""" Simplest possible test: put in zeros, then header,
then payload, trigger signal, try to demux.
The return signal from the header parser is faked via _post()
Add in some tags for fun.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = make_tag('tag1', 0, 0)
# This goes on output 0, item 0:
testtag2 = make_tag('tag2', 23, n_zeros)
# This goes on output 0, item 2:
testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1)
# This goes on output 1, item 3:
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(testtag1, testtag2, testtag3, testtag4)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
mock_header_demod = HeaderToMessageBlock(
numpy.float32,
len(header),
[len(payload)]
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
payload_sink = blocks.vector_sink_f()
header_sink = blocks.vector_sink_f()
self.connect_all_blocks(data_src, trigger_src, hpd, mock_header_demod, payload_sink, header_sink)
self.run_tb(payload_sink, len(payload), header_sink, len(header))
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def msg_handler(self, p):
length = pmt.length(p)
# iterate over all elements
for i in range(0, length):
element = pmt.nth(i, p)
key = pmt.nth(0, element)
value = pmt.nth(1, element)
initial_phase = None
# when we found the phase key
if str(key) == "phase" and pmt.length(value) >= 1:
# print "length of vector: ", pmt.length(value)
value = pmt.f32vector_elements(value)[0]
self.last_val = value
# save that value
initial_phase = value
value = value - self.subtract
while value < -numpy.pi:
value = value + numpy.pi
while value > numpy.pi:
value = value - numpy.pi
initial_phase = pmt.make_f32vector(1, initial_phase)
initial_phase = pmt.list2(pmt.string_to_symbol("phase_initial"), initial_phase)
outvalue = pmt.make_f32vector(1, value)
output = pmt.list2(pmt.string_to_symbol(str(key)), outvalue)
else:
output = element
if i == 0:
outpmt = pmt.list1(output)
else:
outpmt = pmt.list_add(outpmt, output)
if initial_phase != None:
outpmt = pmt.list_add(outpmt, initial_phase)
self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def zmq_msg_payload_to_str(raw_msg):
msg = pmt.deserialize_str(raw_msg)
cdr = pmt.cdr(msg)
packet_len = pmt.length(cdr)
cdr_str = pmt.serialize_str(cdr)
output_str = cdr_str[-1 * packet_len:]
return output_str
def test_001_t_tags(self):
""" Like the previous test, but use a trigger tag instead of
a trigger signal.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
# Trigger tag
trigger_tag = make_tag('detect', True, n_zeros)
# This is dropped:
testtag1 = make_tag('tag1', 0, 0)
# This goes on output 0, item 0:
testtag2 = make_tag('tag2', 23, n_zeros)
# This goes on output 0, item 2:
testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1)
# This goes on output 1, item 3:
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(trigger_tag, testtag1, testtag2, testtag3, testtag4)
)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
mock_header_demod = HeaderToMessageBlock(
numpy.float32,
len(header),
[len(payload)]
)
self.connect_all_blocks(data_src, None, hpd, mock_header_demod, payload_sink, header_sink)
self.run_tb(payload_sink, len(payload), header_sink, len(header))
# Check results
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t_tags (self):
""" Like the previous test, but use a trigger tag instead of
a trigger signal.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
# Trigger tag
trigger_tag = make_tag('detect', True, n_zeros)
# This is dropped:
testtag1 = make_tag('tag1', 0, 0)
# This goes on output 0, item 0:
testtag2 = make_tag('tag2', 23, n_zeros)
# This goes on output 0, item 2:
testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1)
# This goes on output 1, item 3:
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(trigger_tag, testtag1, testtag2, testtag3, testtag4)
)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
mock_header_demod = HeaderToMessageBlock(
numpy.float32,
len(header),
[len(payload)]
)
self.connect_all_blocks(data_src, None, hpd, mock_header_demod, payload_sink, header_sink)
self.run_tb(payload_sink, len(payload), header_sink, len(header))
# Check results
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def app_in(self, msg): # Generate messages
global d_msg_len, d_mac_id, d_seq_nr, d_msg
if self.debug:
print "******************************** \nGenerating messages ...\n******************************** "
print ""
print "MAC:app_in: got something:", msg
data = msg
if (pmt.is_pair(msg)):
data = pmt.cdr(msg)
#if self.debug: print "mac.py:app_in: pmt_is_pair \n"
elif (pmt.is_eof_object(msg)):
if self.debug: print "MAC: exiting"
return
elif (pmt.is_blob(msg)):
data = pmt.cdr(msg)
if self.debug: print "data is blob"
else:
if self.debug: print "MAC: unknown input"
return
if pmt.is_u8vector(data):
"data is u8vector"
data_elements = pmt.u8vector_elements(data)
if self.debug:
print "Data from Application Layer: ", data_elements, "\n"
print "Data length :", len(data_elements), "\n"
d_msg = []
if pmt.is_symbol(data):
dataString = pmt.symbol_to_string(data)
if self.debug:
print "len(pmt.symbol_to_string(data)): ", len(
dataString), "pmt.symbol_to_string(data): ", dataString
generate_mac(data, len(dataString), self.debug, d_mac_id, d_seq_nr,
self.no_self_loop)
else:
generate_mac(data, pmt.length(data), self.debug, d_mac_id,
d_seq_nr, self.no_self_loop)
generatedMacPayload = pmt.make_u8vector(len(d_msg), 0)
for i in range(len(d_msg)):
#if (pmt.is_vector(data)):
#print "d_msg[",i,"]: ", d_msg[i], " ; type: ", type(d_msg[i])
# pmt.vector_set(generatedMacPayload, i, pmt.to_pmt(d_msg[i]))
pmt.u8vector_set(generatedMacPayload, i, d_msg[i])
#else: pmt.u8vector_set(generatedMacPayload, i, d_msg[i])
self.message_port_pub(pmt.intern("pdu out"),
pmt.cons(pmt.PMT_NIL, generatedMacPayload))
print
print "**********************************"
print
if self.debug:
print "Data Published to physical Layer: ", pmt.u8vector_elements(
generatedMacPayload), "\n"
def map_handler(self, msg):
content = pmt.to_python(msg) #type:float
length = pmt.length(msg)
#list of signals (their freqs and bandwidths)
self.freq_list = []
self.bw_list = []
for i in range(0, length):
self.freq_list.append(content[i][0])
self.bw_list.append(content[i][1])
def print_msg(self, msg):
""" Print the rx'd message. """
meta = pmt.to_python(pmt.car(msg))
vect = pmt.cdr(msg)
msg_str = ''.join([
chr(pmt.u8vector_ref(vect, i)) for i in range(pmt.length(vect))
]).strip()
if len(msg_str):
print 'Incoming message: ', msg_str
print meta
def assert_has_num_subscriptions(self, block, port, number):
"""assert that the given block has the given number of subscriptions
on the given port
:param block: a block sptr
:param string port: the port name
:param number: the number of subscriptions expected
"""
subs = block.message_subscribers(pmt.intern(port))
self.assertEqual(pmt.length(subs), number)
def assert_has_num_subscriptions(self, block, port, number):
"""assert that the given block has the given number of subscriptions
on the given port
:param block: a block sptr
:param string port: the port name
:param number: the number of subscriptions expected
"""
subs = block.message_subscribers(pmt.intern(port))
self.assertEqual(pmt.length(subs), number)
def map_handler(self, msg):
content = pmt.to_python(msg) #type:float
length = pmt.length(msg)
#update freq/bandwidth information of the signals
self.freq_list = []
self.bw_list = []
for i in range(0, length):
self.freq_list.append(content[i][0])
self.bw_list.append(content[i][1])
def pdu_in(self, msg): # consume messages
global d_mac_id
if self.debug: print "****************************** \nConsuming messages...\n******************************** "
data = 0
if(pmt.is_eof_object(msg)):
self.message_port_pub(pmt.intern('pdu out'), pmt.PMT_EOF)
return
elif(pmt.is_pair(msg)):
#if self.debug: print "pmt_is_pair"
data = pmt.cdr(msg)
elif(pmt.is_bool(msg)):
if self.debug: print "mac.py:pdu in: got a busy notification"
return
data_len = pmt.length(data)
if self.debug:
print ""
print "Data received from pdusical Layer: ", pmt.u8vector_elements(data)
print ""
if (data_len < 13):
if self.debug: print "MAC: frame too short. Dropping! \n"
return
else:
if self.no_self_loop: # Compare to our own "mac ID" and reject if we are self routing packets.
macId = pmt.u8vector_elements(data)[0]
if self.debug:
print "macId of the packet: ", macId
print "our macId: ", d_mac_id
print "data_len: ", data_len
if (macId != d_mac_id):
crc = crc16(pmt.u8vector_elements(data), data_len)
if self.debug: print "#### CRC at Reception: #### " , crc.get_crc(), "\n"
if (crc.get_crc()):
print "MAC: wrong crc. Dropping packet! \n"
return
macPayload = pmt.make_u8vector(data_len - 13, 0)
#Because of the iperf 'E' issue
#macPayload = pmt.make_u8vector(data_len - 14, 0)
#for i in range(data_len - 14):
for i in range(data_len - 13):
pmt.u8vector_set(macPayload, i, pmt.u8vector_elements(data)[i+11])
self.message_port_pub(pmt.intern('app out'), pmt.cons(pmt.PMT_NIL, macPayload))
if self.debug: print "Data sent up to Application Layer : ", pmt.u8vector_elements(macPayload), "\n"
else:
crc = crc16(pmt.u8vector_elements(data), data_len)
if self.debug: print "#### CRC at Reception: #### " , crc.get_crc(), "\n"
if(crc.get_crc()):
if self.debug: print "MAC: wrong crc. Dropping packet! \n"
return
macPayload = pmt.make_u8vector(data_len - 14, 0)
for i in range(data_len - 14):
pmt.u8vector_set(macPayload, i, pmt.u8vector_elements(data)[i+10])
self.message_port_pub(pmt.intern('app out'), pmt.cons(pmt.PMT_NIL, macPayload))
if self.debug: print "Data sent up to Application Layer : ", pmt.u8vector_elements(macPayload), "\n"
def zmq_msg_payload_to_bytes(raw_msg):
msg = pmt.deserialize_str(raw_msg)
cdr = pmt.cdr(msg)
packet_len = pmt.length(cdr)
cdr_str = pmt.serialize_str(cdr)
output_str = cdr_str[-1 * packet_len:]
byte_list = list()
for i in xrange(len(output_str)):
byte_list.append(ord(output_str[i]))
return byte_list
def test_003_t (self):
"""
Like test 1, but twice, plus one fail
"""
n_zeros = 5
header = (1, 2, 3)
header_fail = (-1, -2, -4) # Contents don't really matter
payload1 = tuple(range(5, 20))
payload2 = (42,)
data_signal = (0,) * n_zeros + header + payload1
trigger_signal = [0,] * len(data_signal) * 2
trigger_signal[n_zeros] = 1
trigger_signal[len(data_signal)] = 1
trigger_signal[len(data_signal)+len(header_fail)+n_zeros] = 1
tx_signal = data_signal + header_fail + (0,) * n_zeros + header + payload2 + (0,) * 1000
data_src = blocks.vector_source_f(tx_signal, False)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 1)
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload1))
)
while len(payload_sink.data()) < len(payload1):
time.sleep(.2)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.PMT_F
)
# This next command is a bit of a showstopper, but there's no condition to check upon
# to see if the previous msg handling is finished
time.sleep(.7)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload2))
)
while len(payload_sink.data()) < len(payload1) + len(payload2):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header + header_fail + header)
self.assertEqual(payload_sink.data(), payload1 + payload2)
def msg_handler(self, p):
if self.filename != "":
self.fdout = open(self.filename, "a")
length = pmt.length(p)
if self.key == "all":
#if all keys are printed, they need however be printed once above
if self.counter == 0:
for i in range(0, length):
element = pmt.nth(i, p)
current_key = str(pmt.nth(0, element))
self.fdout.write(current_key + ",")
self.fdout.write("\n")
self.counter=1
#print all
for i in range(0, length):
element = pmt.nth(i, p)
current_key = str(pmt.nth(0, element))
current_value = pmt.nth(1, element)
if current_key=="rx_time":
number = pmt.to_uint64(pmt.tuple_ref(current_value,0)) + \
pmt.to_double(pmt.tuple_ref(current_value,1))
self.fdout.write(str(number) + ",")
else:
self.fdout.write(str(pmt.f32vector_elements(current_value)[0]) + ",")
else:
#print all values that correspond to keys
for key in self.key:
for i in range(0, length):
element = pmt.nth(i, p)
current_key = str(pmt.nth(0, element))
current_value = pmt.nth(1, element)
if current_key == key:
if key=="rx_time":
number = pmt.to_uint64(pmt.tuple_ref(current_value,0)) + \
pmt.to_double(pmt.tuple_ref(current_value,1))
self.fdout.write(str(number) + ",")
else:
self.fdout.write(str(pmt.f32vector_elements(current_value)[0]) + ",")
self.fdout.write("\n")
self.fdout.close()
def parse_extra_dict(p, info, VERBOSE=False):
if(pmt.is_dict(p) is False):
sys.stderr.write("Extra header is not a PMT dictionary: invalid or corrupt data file.\n")
sys.exit(1)
items = pmt.dict_items(p)
nitems = pmt.length(items)
for i in xrange(nitems):
item = pmt.nth(i, items)
key = pmt.symbol_to_string(pmt.car(item))
val = pmt.cdr(item)
info[key] = val
if(VERBOSE):
print "{0}: {1}".format(key, val)
return info
def sched_pdu(self, pdu):
sched_time = self.nproduced_val + 10000
# pick a time in the future
if sched_time < self.sched_barrier:
sched_time = self.sched_barrier
print "delaying packet to sched barrier"
sched_time = sched_time - sched_time % 1000
# round to nearest slot
event_length = pmt.length(pmt.cdr(pdu))
# event_length = pmt.to_long(pmt.dict_ref(pmt.car(pdu), pmt.intern("event_length"), pmt.PMT_NIL));
self.sched_barrier = sched_time + event_length + 1000
print "SCHED_EVENT: time=%d, len=%d " % (sched_time, event_length)
pdu = pdulib.pdu_arg_add(pdu, pmt.intern("event_time"), pmt.from_uint64(sched_time))
self.message_port_pub(pmt.intern("sched_pdu"), pdu)
def parse_extra_dict(p, info, VERBOSE=False):
if(pmt.is_dict(p) is False):
sys.stderr.write("Extra header is not a PMT dictionary: invalid or corrupt data file.\n")
sys.exit(1)
items = pmt.dict_items(p)
nitems = pmt.length(items)
for i in range(nitems):
item = pmt.nth(i, items)
key = pmt.symbol_to_string(pmt.car(item))
val = pmt.cdr(item)
info[key] = val
if(VERBOSE):
print("{0}: {1}".format(key, val))
return info
def sched_pdu(self, pdu):
sched_time = (self.nproduced_val + 10000)
# pick a time in the future
if (sched_time < self.sched_barrier):
sched_time = self.sched_barrier
print "delaying packet to sched barrier"
sched_time = sched_time - sched_time % 1000
# round to nearest slot
event_length = pmt.length(pmt.cdr(pdu))
#event_length = pmt.to_long(pmt.dict_ref(pmt.car(pdu), pmt.intern("event_length"), pmt.PMT_NIL));
self.sched_barrier = sched_time + event_length + 1000
print "SCHED_EVENT: time=%d, len=%d " % (sched_time, event_length)
pdu = pdulib.pdu_arg_add(pdu, pmt.intern("event_time"),
pmt.from_uint64(sched_time))
self.message_port_pub(pmt.intern("sched_pdu"), pdu)
def handle_msg(self, msg):
d_size_msg = pmt.length(msg)
# rx_time, frequency, power, phase
time_tuple = pmt.nth(1, pmt.nth(0, msg))
time_s = pmt.to_uint64(pmt.tuple_ref(time_tuple, 0))
time_ms = pmt.to_double(pmt.tuple_ref(time_tuple, 1))
timestamp = time_s + time_ms
phase_val_vec = pmt.nth(1, pmt.nth(d_size_msg - 1, msg))
phase_val = pmt.f32vector_elements(phase_val_vec)[0]
#plt.scatter(timestamp, phase_val)
#plt.pause(0.05)
#power_val_vec = pmt.nth(1, pmt.nth(d_size_msg-2, msg))
#power_val = pmt.f32vector_elements(power_val_vec)[0]
self.phase = phase_val
self.time = timestamp
def main():
src_id = 42
dest_id = 84
frame_num = 4711
checksum = range(16)
raw_payload = range(16)
payload = get_pdu_payload(raw_payload)
print(payload, pmt.length(payload))
meta = get_pdu_header(dest_id, src_id, frame_num)
# pl = pmt.u
print(meta)
print(pmt.dict_keys(meta))
print(pmt.dict_values(meta))
meta = set_pdu_header_checksum(meta, checksum)
print(meta)
K = "00010203 04050607 08090A0B 0C0D0E0F "
K += "10111213 14151617 18191A1B 1C1D1E1F"
print(K)
vals = hex_string_to_int_list(K)
print(get_hex_char_string(vals))
def test_001_t (self):
""" Simplest possible test: put in zeros, then header,
then payload, trigger signal, try to demux.
The return signal from the header parser is faked via _post()
"""
n_zeros = 100
header = (1, 2, 3)
payload = tuple(range(17))
data_signal = (0,) * n_zeros + header + payload
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
data_src = blocks.vector_source_f(data_signal, False)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 1)
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload))
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
def test_001_t(self):
src1 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 12500, 3)
src2 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 9800, 3)
add = blocks.add_cc()
detector = inspector.signal_detector_cvf(32000, 4096,
firdes.WIN_BLACKMAN_hARRIS,
-80, 0.6, False, 0.5, 0.001)
dst1 = blocks.null_sink(gr.sizeof_float * 4096)
msg_dst = blocks.message_debug()
# connections
self.tb.connect(src1, (add, 0))
self.tb.connect(src2, (add, 1))
self.tb.connect(add, detector)
self.tb.connect((detector, 0), dst1)
self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store'))
self.tb.start()
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
# take most recent message
msg = msg_dst.get_message(msg_dst.num_messages() - 1)
res_vector = numpy.empty([0, 2])
for i in range(pmt.length(msg)):
row = pmt.vector_ref(msg, i)
res_vector = numpy.vstack(
(res_vector,
numpy.array(
[pmt.f32vector_ref(row, 0),
pmt.f32vector_ref(row, 1)])))
self.assertAlmostEqual(9800.0, res_vector[0][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[0][1], delta=100)
self.assertAlmostEqual(12500.0, res_vector[1][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[1][1], delta=100)
def test_001_t (self):
src1 = analog.sig_source_c(32000, analog.GR_COS_WAVE,
12500, 3)
src2 = analog.sig_source_c(32000, analog.GR_COS_WAVE,
9800, 3)
add = blocks.add_cc()
detector = inspector.signal_detector_cvf(32000, 4096,
firdes.WIN_BLACKMAN_hARRIS, -80, 0.6, False, 0.5, 0.001)
dst1 = blocks.null_sink(gr.sizeof_float*4096)
msg_dst = blocks.message_debug()
#connections
self.tb.connect(src1, (add, 0))
self.tb.connect(src2, (add, 1))
self.tb.connect(add, detector)
self.tb.connect((detector, 0), dst1)
self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store'))
self.tb.start()
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
#take most recent message
msg = msg_dst.get_message(msg_dst.num_messages()-1)
res_vector = numpy.empty([0, 2])
for i in range(pmt.length(msg)):
row = pmt.vector_ref(msg, i)
res_vector = numpy.vstack((res_vector, numpy.array(
[pmt.f32vector_ref(row, 0), pmt.f32vector_ref(row, 1)]
)))
self.assertAlmostEqual(9800.0, res_vector[0][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[0][1], delta=100)
self.assertAlmostEqual(12500.0, res_vector[1][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[1][1], delta=100)
def check_file(self, fname, expected, has_header=False, data_type='uint8'):
# instantiate objects
debug = blocks.message_debug()
reader = csv_reader(fname=fname,
has_header=has_header,
period=10,
repeat=False,
start_delay=0,
data_type=data_type)
tb = gr.top_block()
tb.msg_connect((reader, 'out'), (debug, 'store'))
tb.start()
time.sleep(.25)
tb.stop()
tb.wait()
# collect results
got = debug.get_message(0)
got_car = pmt.car(got)
print("got: {}".format(got))
print("expected: {}".format(expected))
# do a manual equal on elements because pmt equal is not the best
expected_items = pmt.dict_items(pmt.car(expected))
valid = True
for i in range(pmt.length(expected_items)):
key = pmt.car(pmt.nth(i, expected_items))
value = pmt.cdr(pmt.nth(i, expected_items))
got_value = pmt.dict_ref(got_car, key, pmt.PMT_NIL)
if not pmt.equal(got_value, value):
valid = False
break
return (valid and pmt.equal(pmt.cdr(got), pmt.cdr(expected)))
def test_003_t (self):
"""
Like test 1, but twice, plus one fail
"""
### Tx Data
n_zeros = 5
header = (1, 2, 3)
header_fail = (-1, -2, -4) # Contents don't really matter
payload1 = tuple(range(5, 20))
payload2 = (42,)
sampling_rate = 2
data_signal = (0,) * n_zeros + header + payload1
trigger_signal = [0,] * len(data_signal) * 2
trigger_signal[n_zeros] = 1
trigger_signal[len(data_signal)] = 1
trigger_signal[len(data_signal)+len(header_fail)+n_zeros] = 1
print("Triggers at: {0} {1} {2}".format(
n_zeros,
len(data_signal),
len(data_signal)+len(header_fail)+n_zeros)
)
tx_signal = data_signal + \
header_fail + (0,) * n_zeros + \
header + payload2 + (0,) * 1000
# Timing tag: This is preserved and updated:
timing_tag = make_tag('rx_time', (0, 0), 0)
# Rx freq tags:
rx_freq_tag1 = make_tag('rx_freq', 1.0, 0)
rx_freq_tag2 = make_tag('rx_freq', 1.5, 29)
rx_freq_tag3 = make_tag('rx_freq', 2.0, 30)
### Flow graph
data_src = blocks.vector_source_f(
tx_signal, False,
tags=(timing_tag, rx_freq_tag1, rx_freq_tag2, rx_freq_tag3)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
header_len=len(header),
items_per_symbol=1,
guard_interval=0,
length_tag_key="frame_len",
trigger_tag_key="detect",
output_symbols=False,
itemsize=gr.sizeof_float,
timing_tag_key='rx_time',
samp_rate=sampling_rate,
special_tags=('rx_freq',),
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload1))
)
while len(payload_sink.data()) < len(payload1):
time.sleep(.2)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.PMT_F
)
# This next command is a bit of a showstopper, but there's no condition to check upon
# to see if the previous msg handling is finished
time.sleep(.7)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload2))
)
while len(payload_sink.data()) < len(payload1) + len(payload2):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
# Signal description:
# 0: 5 zeros
# 5: header 1
# 8: payload 1 (length: 15)
# 23: header 2 (fail)
# 26: 5 zeros
# 31: header 3
# 34: payload 2 (length 1)
# 35: 1000 zeros
self.assertEqual(header_sink.data(), header + header_fail + header)
self.assertEqual(payload_sink.data(), payload1 + payload2)
tags_payload = [gr.tag_to_python(x) for x in payload_sink.tags()]
tags_payload = sorted([(x.offset, x.key, x.value) for x in tags_payload])
tags_expected_payload = [
(0, 'frame_len', len(payload1)),
(len(payload1), 'frame_len', len(payload2)),
]
tags_header = [gr.tag_to_python(x) for x in header_sink.tags()]
tags_header = sorted([(x.offset, x.key, x.value) for x in tags_header])
tags_expected_header = [
(0, 'rx_freq', 1.0),
(0, 'rx_time', (2, 0.5)), # Hard coded time value :( Is n_zeros/sampling_rate
(len(header), 'rx_freq', 1.0),
(len(header), 'rx_time', (11, .5)), # Hard coded time value :(. See above.
(2*len(header), 'rx_freq', 2.0),
(2*len(header), 'rx_time', (15, .5)), # Hard coded time value :(. See above.
]
self.assertEqual(tags_header, tags_expected_header)
self.assertEqual(tags_payload, tags_expected_payload)
def test_001_headerpadding_payload_offset (self):
""" Like test 1, but with header padding + payload offset. """
n_zeros = 3
header = (1, 2, 3)
header_padding = 1
payload_offset = -1
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload + (0,) * 100
trigger_signal = [0] * len(data_signal)
trigger_signal[n_zeros] = 1
# This goes on output 1, item 3 + 1 (for payload offset)
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(testtag4,)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header),
1, # Items per symbol
0, # Guard interval
"frame_len", # TSB tag key
"detect", # Trigger tag key
False, # No symbols please
gr.sizeof_float, # Item size
"", # Timing tag key
1.0, # Samp rate
(), # No special tags
header_padding
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.to_pmt({'frame_len': len(payload), 'payload_offset': payload_offset})
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
# Header is now padded:
self.assertEqual(header_sink.data(), (0,) + header + (payload[0],))
# Payload is now offset:
self.assertEqual(
payload_sink.data(),
data_signal[n_zeros + len(header) + payload_offset:n_zeros + len(header) + payload_offset + len(payload)]
)
ptags_payload = {}
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload[ptag.key] = ptag.offset
expected_tags_payload = {
'frame_len': 0,
'payload_offset': 0,
'tag4': 3 - payload_offset,
}
self.assertEqual(expected_tags_payload, ptags_payload)
def test_003_t(self):
"""
Like test 1, but twice, plus one fail
"""
### Tx Data
n_zeros = 5
header = (1, 2, 3)
header_fail = (-1, -2, -4) # Contents don't really matter
payload1 = tuple(range(5, 20))
payload2 = (42, )
sampling_rate = 2
data_signal = (0, ) * n_zeros + header + payload1
trigger_signal = [
0,
] * len(data_signal) * 2
trigger_signal[n_zeros] = 1
trigger_signal[len(data_signal)] = 1
trigger_signal[len(data_signal) + len(header_fail) + n_zeros] = 1
tx_signal = data_signal + header_fail + (
0, ) * n_zeros + header + payload2 + (0, ) * 1000
# Timing tag: This is preserved and updated:
timing_tag = gr.tag_t()
timing_tag.offset = 0
timing_tag.key = pmt.string_to_symbol('rx_time')
timing_tag.value = pmt.to_pmt((0, 0))
# Rx freq tags:
rx_freq_tag1 = gr.tag_t()
rx_freq_tag1.offset = 0
rx_freq_tag1.key = pmt.string_to_symbol('rx_freq')
rx_freq_tag1.value = pmt.from_double(1.0)
rx_freq_tag2 = gr.tag_t()
rx_freq_tag2.offset = 29
rx_freq_tag2.key = pmt.string_to_symbol('rx_freq')
rx_freq_tag2.value = pmt.from_double(1.5)
rx_freq_tag3 = gr.tag_t()
rx_freq_tag3.offset = 30
rx_freq_tag3.key = pmt.string_to_symbol('rx_freq')
rx_freq_tag3.value = pmt.from_double(2.0)
### Flow graph
data_src = blocks.vector_source_f(tx_signal,
False,
tags=(timing_tag, rx_freq_tag1,
rx_freq_tag2, rx_freq_tag3))
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
header_len=len(header),
items_per_symbol=1,
guard_interval=0,
length_tag_key="frame_len",
trigger_tag_key="detect",
output_symbols=False,
itemsize=gr.sizeof_float,
timing_tag_key='rx_time',
samp_rate=sampling_rate,
special_tags=('rx_freq', ),
)
self.assertEqual(pmt.length(hpd.message_ports_in()),
2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(pmt.intern('header_data'),
pmt.from_long(len(payload1)))
while len(payload_sink.data()) < len(payload1):
time.sleep(.2)
hpd.to_basic_block()._post(pmt.intern('header_data'), pmt.PMT_F)
# This next command is a bit of a showstopper, but there's no condition to check upon
# to see if the previous msg handling is finished
time.sleep(.7)
hpd.to_basic_block()._post(pmt.intern('header_data'),
pmt.from_long(len(payload2)))
while len(payload_sink.data()) < len(payload1) + len(payload2):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
# Signal description:
# 0: 5 zeros
# 5: header 1
# 8: payload 1 (length: 15)
# 23: header 2 (fail)
# 26: 5 zeros
# 31: header 3
# 34: payload 2 (length 1)
# 35: 1000 zeros
self.assertEqual(header_sink.data(), header + header_fail + header)
self.assertEqual(payload_sink.data(), payload1 + payload2)
tags_payload = [gr.tag_to_python(x) for x in payload_sink.tags()]
tags_payload = sorted([(x.offset, x.key, x.value)
for x in tags_payload])
tags_expected_payload = [
(0, 'frame_len', len(payload1)),
(len(payload1), 'frame_len', len(payload2)),
]
tags_header = [gr.tag_to_python(x) for x in header_sink.tags()]
tags_header = sorted([(x.offset, x.key, x.value) for x in tags_header])
tags_expected_header = [
(0, 'rx_freq', 1.0),
(0, 'rx_time',
(2, 0.5)), # Hard coded time value :( Is n_zeros/sampling_rate
(len(header), 'rx_freq', 1.0),
(len(header), 'rx_time',
(11, .5)), # Hard coded time value :(. See above.
(2 * len(header), 'rx_freq', 2.0),
(2 * len(header), 'rx_time',
(15, .5)), # Hard coded time value :(. See above.
]
self.assertEqual(tags_header, tags_expected_header)
self.assertEqual(tags_payload, tags_expected_payload)
def test_001_t(self):
""" Simplest possible test: put in zeros, then header,
then payload, trigger signal, try to demux.
The return signal from the header parser is faked via _post()
Add in some tags for fun.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0, ) * n_zeros + header + payload
trigger_signal = [
0,
] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0:
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 2:
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + len(header) - 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 3:
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + len(header) + 3
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
data_src = blocks.vector_source_f(data_signal,
False,
tags=(testtag1, testtag2, testtag3,
testtag4))
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(len(header), 1, 0, "frame_len",
"detect", False, gr.sizeof_float)
self.assertEqual(pmt.length(hpd.message_ports_in()),
2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(pmt.intern('header_data'),
pmt.from_long(len(payload)))
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{
'key': 'tag2',
'offset': 0
},
{
'key': 'tag3',
'offset': 2
},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{
'key': 'frame_len',
'offset': 0
},
{
'key': 'tag4',
'offset': 3
},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t_tags (self):
""" Like the previous test, but use a trigger tag instead of
a trigger signal.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
# Trigger tag
trigger_tag = gr.tag_t()
trigger_tag.offset = n_zeros
trigger_tag.key = pmt.string_to_symbol('detect')
trigger_tag.value = pmt.PMT_T
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0:
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 2:
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + len(header) - 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 3:
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + len(header) + 3
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(trigger_tag, testtag1, testtag2, testtag3, testtag4)
)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload))
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def test_002_symbols(self):
"""
Same as before, but operate on symbols
"""
n_zeros = 1
items_per_symbol = 3
gi = 1
n_symbols = 4
header = (1, 2, 3)
payload = (1, 2, 3)
data_signal = (0, ) * n_zeros + (0, ) + header + (
(0, ) + payload) * n_symbols
trigger_signal = [
0,
] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0 (from the GI)
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 0 (middle of the header symbol)
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + gi + 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 1 (middle of the first payload symbol)
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + (gi + items_per_symbol) * 2 + 1
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
data_src = blocks.vector_source_f(data_signal,
False,
tags=(testtag1, testtag2, testtag3,
testtag4))
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header) / items_per_symbol, # Header length (in symbols)
items_per_symbol, # Items per symbols
gi, # Items per guard time
"frame_len", # Frame length tag key
"detect", # Trigger tag key
True, # Output symbols (not items)
gr.sizeof_float # Bytes per item
)
self.assertEqual(pmt.length(hpd.message_ports_in()),
2) #extra system port defined for you
header_sink = blocks.vector_sink_f(items_per_symbol)
payload_sink = blocks.vector_sink_f(items_per_symbol)
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(pmt.intern('header_data'),
pmt.from_long(n_symbols))
while len(payload_sink.data()) < len(payload) * n_symbols:
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload * n_symbols)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{
'key': 'tag2',
'offset': 0
},
{
'key': 'tag3',
'offset': 0
},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{
'key': 'frame_len',
'offset': 0
},
{
'key': 'tag4',
'offset': 1
},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def __init__(self, buf, len, debug, d_mac_id, d_seq_nr, no_self_loop):
self.debug = debug
self.buf = buf
self.len = len
self.d_seq_nr = d_seq_nr
self.d_mac_id = d_mac_id
self.no_self_loop = no_self_loop
if self.no_self_loop:
#Insert an id here to check for self routing. This makes the packet non standard.
d_msg.insert(0, self.d_mac_id)
d_msg.insert(1, 11 + self.len + 2)
#FCF
d_msg.insert(2,0x41)
d_msg.insert(3,0x88)
#seq nr
d_msg.insert(4,++self.d_seq_nr)
#addr info
d_msg.insert(5,0xcd)
d_msg.insert(6,0xab)
d_msg.insert(7,0xff)
d_msg.insert(8,0xff)
d_msg.insert(9,0x40)
d_msg.insert(10,0xe8)
#Copy the data here.
if (pmt.is_vector(buf)):
for i in range(pmt.length(buf)):
d_msg.insert(10+i,pmt.to_long(pmt.vector_ref(buf,i)))
elif (pmt.is_uniform_vector(buf)):
d_msg.extend(pmt.u8vector_elements(buf))
else:
bufString = pmt.symbol_to_string(buf)
#print "pmt.symbol_to_string(buf): ", bufString
#print "pmt.length(buf): ", pmt.length(buf)
bytes = map(ord,bufString)
#print "map(ord,buf): ", bytes
d_msg.extend(bytes)
#Compute the CRC over the whole packet (excluding the CRC bytes themselves)
crc = crc16(d_msg, self.len + 11)
#if self.debug: print "#### CRC at Transmission: #### ", crc.get_crc()
#CRC goes on the end.
d_msg.insert(11+ self.len, crc.get_crc() & 0xFF)
d_msg.insert(12+ self.len, crc.get_crc() >> 8)
d_msg_len = 11 + self.len + 2
print
print
if self.debug: print "d_msg: ", d_msg
print
print
else:
#Preamble length + CRC length ( CRC at the end)
d_msg.insert(0, 10 + self.len + 2)
#FCF
d_msg.insert(1,0x41)
d_msg.insert(2,0x88)
#seq nr
d_msg.insert(3,++self.d_seq_nr)
#addr info
d_msg.insert(4,0xcd)
d_msg.insert(5,0xab)
d_msg.insert(6,0xff)
d_msg.insert(7,0xff)
d_msg.insert(8,0x40)
d_msg.insert(9,0xe8)
#Copy the data here.
d_msg.extend(pmt.u8vector_elements(buf))
#Compute the CRC over the whole packet (excluding the CRC bytes themselves)
crc = crc16(d_msg, self.len + 10)
if self.debug: print "#### CRC at Transmission: #### ", crc.get_crc()
d_msg.insert(10 + self.len, crc.get_crc() & 0xFF)
d_msg.insert(11 + self.len, crc.get_crc() >> 8)
d_msg_len = 10 + self.len + 2 # Preamble + Data + CRC
if self.debug: print " msg len ", d_msg_len, " len ", self.len, "\n"
def msg_handler(self, p):
verbose = False
length = pmt.length(p)
if verbose:
print "PMT contrains " + str(length) + " key/value pairs"
for i in range(0,length):
element = pmt.nth(i, p)
key = pmt.nth(0, element)
value = pmt.nth(1, element)
if verbose:
print "Key of " + str(i) + "th element: " + str(key)
print "Value of " + str(i) + "th element: " + str(value)
print
found = False
for j in range(0, len(self.n)):
if str(key) == self.kk[j]:
found = True
if verbose:
print "found the key " + str(key)
#rotate the values, the latest one disappears
self.prev_values[j] = numpy.roll(self.prev_values[j], -1)
#set the vector accordingly
self.prev_values[j][-1] = pmt.f32vector_elements(value)[0]
output = sum(self.prev_values[j])/len(self.prev_values[j])
output = pmt.make_f32vector(1, output)
if i==0:
outpmt = pmt.list1(pmt.list2(pmt.string_to_symbol(str(key) + "_filtered"), output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol(str(key) + "_filtered"), output))
output = pmt.nth(1, element)
if i==0:
outpmt = pmt.list1(pmt.list2(key, output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(key, output))
if verbose:
print
#iterate over all keys
for i in range(0, len(self.kk)):
minimum = self.prev_values[i][0]
maximum = self.prev_values[i][0]
#iterate over all saved values
for j in range(0, self.n[i]):
if self.prev_values[i][j] < minimum:
minimum = self.prev_values[i][j]
if self.prev_values[i][j] > maximum:
maximum = self.prev_values[i][j]
#print out a min, diff, max for every key
difference = maximum-minimum
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("min"), pmt.make_f32vector(1, minimum)))
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("max"), pmt.make_f32vector(1, maximum)))
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("diff"), pmt.make_f32vector(1, difference)))
self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def test_001_headerpadding_payload_offset (self):
""" Like test 1, but with header padding + payload offset. """
n_zeros = 3
header = (1, 2, 3)
header_padding = 1
payload_offset = -1
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload + (0,) * 100
trigger_signal = [0] * len(data_signal)
trigger_signal[n_zeros] = 1
# This goes on output 1, item 3 + 1 (for payload offset)
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(testtag4,)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header),
1, # Items per symbol
0, # Guard interval
"frame_len", # TSB tag key
"detect", # Trigger tag key
False, # No symbols please
gr.sizeof_float, # Item size
"", # Timing tag key
1.0, # Samp rate
(), # No special tags
header_padding
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.to_pmt({'frame_len': len(payload), 'payload_offset': payload_offset})
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
# Header is now padded:
self.assertEqual(header_sink.data(), (0,) + header + (payload[0],))
# Payload is now offset:
self.assertEqual(
payload_sink.data(),
data_signal[n_zeros + len(header) + payload_offset:n_zeros + len(header) + payload_offset + len(payload)]
)
ptags_payload = {}
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload[ptag.key] = ptag.offset
expected_tags_payload = {
'frame_len': 0,
'payload_offset': 0,
'tag4': 3 - payload_offset,
}
self.assertEqual(expected_tags_payload, ptags_payload)
def test_004_long_burst(self):
# This test processes a single burst that exceeds the maximum burst size that will be truncated
# data
min_data_size = 32 * 1024 # arbitrary constant in tagged_burst_to_pdu_impl.h
src_data = (1, ) * min_data_size * 8
new_burst_offset = 64
new_burst_dict = pmt.make_dict()
new_burst_dict = pmt.dict_add(new_burst_dict,
fhss_utils.PMTCONSTSTR__burst_id(),
pmt.from_uint64(505))
new_burst_dict = pmt.dict_add(
new_burst_dict, fhss_utils.PMTCONSTSTR__relative_frequency(),
pmt.from_float(1e6 / 30.72e6)) # in [-1.0,1.0], not Hz
new_burst_dict = pmt.dict_add(
new_burst_dict, fhss_utils.PMTCONSTSTR__center_frequency(),
pmt.from_float(915e6)) # of the whole signal, not the burst
new_burst_dict = pmt.dict_add(new_burst_dict,
fhss_utils.PMTCONSTSTR__magnitude(),
pmt.from_float(40))
new_burst_dict = pmt.dict_add(new_burst_dict,
fhss_utils.PMTCONSTSTR__sample_rate(),
pmt.from_float(30.72e6))
new_burst_dict = pmt.dict_add(new_burst_dict,
fhss_utils.PMTCONSTSTR__noise_density(),
pmt.from_float(-100)) # in dBFS/Hz
new_burst_dict = pmt.dict_add(new_burst_dict,
fhss_utils.PMTCONSTSTR__bandwidth(),
pmt.from_float(0.1e6))
nb_tag = gr.tag_utils.python_to_tag([
new_burst_offset,
fhss_utils.PMTCONSTSTR__new_burst(), new_burst_dict,
pmt.intern("qa_test")
])
duration = 1024
gone_burst_offset = new_burst_offset + duration
gone_burst_dict = pmt.make_dict()
gone_burst_dict = pmt.dict_add(gone_burst_dict,
fhss_utils.PMTCONSTSTR__burst_id(),
pmt.from_uint64(505))
gb_tag = gr.tag_utils.python_to_tag([
gone_burst_offset,
fhss_utils.PMTCONSTSTR__gone_burst(), gone_burst_dict,
pmt.intern("qa_test")
])
# blocks
src = blocks.vector_source_c(src_data, False, 1, [nb_tag, gb_tag])
#src.set_min_output_buffer(min_data_size*2) # not necessary, block calls set_output_multiple
debug = blocks.message_debug()
dec = 16
taps = [1]
min_time = 1e-6
max_time = 10e-6
nthreads = 3
samp_rate = 30.72e6
rel_span = 1
rel_samp_rate = 1
rel_cf = 0
dut = fhss_utils.tagged_burst_to_pdu(dec, taps, min_time, max_time,
rel_cf, rel_span, rel_samp_rate,
samp_rate, nthreads)
self.tb.connect(src, dut)
self.tb.msg_connect((dut, 'cpdus'), (debug, 'store'))
#self.tb.run() # blocking, vector_source will end flowgraph
self.tb.start()
time.sleep(0.1)
self.tb.stop()
time.sleep(0.1)
self.tb.wait()
time.sleep(0.1)
print("test long burst:")
#print(f"how many msg? {debug.num_messages()}")
self.assertEqual(debug.num_messages(), 1)
#print(f"received: {pmt.car(debug.get_message(0))}")
#print(f"received: {pmt.cdr(debug.get_message(0))}")
#print(f"received len: {pmt.length(pmt.cdr(debug.get_message(0)))}")
rcv_meta = pmt.car(debug.get_message(0))
# we expect a duration equal to `max_time` and a vector of length that corrseponds to `max_time` samples
self.assertAlmostEqual(
pmt.to_double(
pmt.dict_ref(rcv_meta, pmt.intern("duration"), pmt.PMT_NIL)),
max_time, 6)
self.assertEqual(pmt.length(pmt.cdr(debug.get_message(0))),
(max_time * samp_rate) // dec)
self.assertEqual(
pmt.to_uint64(
pmt.dict_ref(rcv_meta, pmt.intern("burst_id"), pmt.PMT_NIL)),
505)
def test_002_symbols (self):
"""
Same as before, but operate on symbols
"""
n_zeros = 1
items_per_symbol = 3
gi = 1
n_symbols = 4
header = (1, 2, 3)
payload = (1, 2, 3)
data_signal = (0,) * n_zeros + (0,) + header + ((0,) + payload) * n_symbols
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0 (from the GI)
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 0 (middle of the header symbol)
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + gi + 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 1 (middle of the first payload symbol)
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + (gi + items_per_symbol) * 2 + 1
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
data_src = blocks.vector_source_f(data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4))
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header) / items_per_symbol, # Header length (in symbols)
items_per_symbol, # Items per symbols
gi, # Items per guard time
"frame_len", # Frame length tag key
"detect", # Trigger tag key
True, # Output symbols (not items)
gr.sizeof_float # Bytes per item
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 1)
header_sink = blocks.vector_sink_f(items_per_symbol)
payload_sink = blocks.vector_sink_f(items_per_symbol)
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(n_symbols)
)
while len(payload_sink.data()) < len(payload) * n_symbols:
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload * n_symbols)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 0},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 1},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t (self):
""" Simplest possible test: put in zeros, then header,
then payload, trigger signal, try to demux.
The return signal from the header parser is faked via _post()
Add in some tags for fun.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0:
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 2:
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + len(header) - 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 3:
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + len(header) + 3
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
data_src = blocks.vector_source_f(data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4))
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 1)
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload))
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
rc = sock.bind(_ADDR)
#%%
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, np.radians(15))
pmt.f32vector_set(flanks, 1, np.radians(70))
c = pmt.cons(pmt.to_pmt("doa"), flanks)
#%%
sock.recv()
#%%
sock.send(pmt.serialize_str(c))
# %% De acá para arriba anda
key0 = pmt.intern("doa")
val0 = pmt.from_long(123)
val1 = pmt.from_long(234)
val_list = pmt.list2(val0, val1)
pmt.length(val_list)
# %%
a = pmt.make_dict()
# %%
a = pmt.dict_add(a, key0, val_list)
print(pmt.cdr(a))
# %%
pmt.set_car(a, key0)
pmt.set_cdr(a, val_list)
# %%
print(pmt.cons(pmt.to_pmt("doa"), val_list))
# %%
print(
pmt.cons(pmt.to_pmt("doa"),
pmt.list2(pmt.from_long(123), pmt.from_long(234))))
# %%