def test_pdu_add_meta(self):
tb = gr.top_block()
dbg = blocks.message_debug()
meta = pmt.make_dict()
meta = pmt.dict_add(meta, pmt.intern('k1'), pmt.intern('v1'))
meta = pmt.dict_add(meta, pmt.intern('k2'), pmt.intern('v2'))
add_meta = pdu_add_meta(meta)
pdu = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(10, 0))
tb.msg_connect((add_meta, 'out'), (dbg, 'store'))
add_meta.to_basic_block()._post(pmt.intern('in'), pdu)
add_meta.to_basic_block()._post(
pmt.intern('system'), pmt.cons(pmt.intern('done'),
pmt.from_long(1)))
tb.start()
tb.wait()
pdu_out = dbg.get_message(0)
meta_out = pmt.car(pdu_out)
self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k1')),
'Test key k1 not in output PDU metadata')
self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k2')),
'Test key k1 not in output PDU metadata')
self.assertEqual(pmt.u8vector_elements(pmt.cdr(pdu_out)),
pmt.u8vector_elements(pmt.cdr(pdu)),
'Output PDU data does not match input PDU data')
def test_packet_parse_default(self):
ac = packet_utils.default_access_code
length = '0000000000000001'
hdr_format_1bps = digital.header_format_default(ac, 0)
hdr_format_4bps = digital.header_format_default(ac, 0, 4)
ac_bits = [int(x) & 1 for x in ac]
length_bits = [int(x) & 1 for x in length]
header_bits = ac_bits + length_bits + length_bits
src_hdr = blocks.vector_source_b(header_bits)
parser_1bps = digital.protocol_parser_b(hdr_format_1bps)
parser_4bps = digital.protocol_parser_b(hdr_format_4bps)
snk_hdr_1bps = blocks.message_debug()
snk_hdr_4bps = blocks.message_debug()
self.tb.connect(src_hdr, parser_1bps)
self.tb.connect(src_hdr, parser_4bps)
self.tb.msg_connect(parser_1bps, 'info', snk_hdr_1bps, 'store')
self.tb.msg_connect(parser_4bps, 'info', snk_hdr_4bps, 'store')
self.tb.start()
while (snk_hdr_1bps.num_messages() <
1) or (snk_hdr_4bps.num_messages() < 1):
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
result_1bps = snk_hdr_1bps.get_message(0)
result_4bps = snk_hdr_4bps.get_message(0)
self.assertTrue(
pmt.dict_has_key(result_1bps, pmt.intern('payload symbols')))
self.assertEqual(
pmt.to_long(
pmt.dict_ref(result_1bps, pmt.intern('payload symbols'),
pmt.PMT_F)), 8)
self.assertTrue(
pmt.dict_has_key(result_4bps, pmt.intern('payload symbols')))
self.assertEqual(
pmt.to_long(
pmt.dict_ref(result_4bps, pmt.intern('payload symbols'),
pmt.PMT_F)), 2)
def handle_msg(self, msg):
if pmt.dict_has_key(msg, pmt.intern(self.len_tag_key)):
packet_len = pmt.to_python(msg)[self.len_tag_key]
msg = pmt.dict_delete(msg, pmt.intern(self.len_tag_key))
msg = pmt.dict_add(msg, pmt.intern(self.len_tag_key), pmt.from_long(packet_len * 8))
self.message_port_pub(self.msg_buf_out, msg)
def test_packet_parse_default(self):
ac = packet_utils.default_access_code
length = '0000000000000001'
hdr_format_1bps = digital.header_format_default(ac, 0)
hdr_format_4bps = digital.header_format_default(ac, 0, 4)
ac_bits = [int(x) & 1 for x in ac]
length_bits = [int(x) & 1 for x in length]
header_bits = ac_bits + length_bits + length_bits
src_hdr = blocks.vector_source_b(header_bits)
parser_1bps = digital.protocol_parser_b(hdr_format_1bps)
parser_4bps = digital.protocol_parser_b(hdr_format_4bps)
snk_hdr_1bps = blocks.message_debug()
snk_hdr_4bps = blocks.message_debug()
self.tb.connect(src_hdr, parser_1bps)
self.tb.connect(src_hdr, parser_4bps)
self.tb.msg_connect(parser_1bps, 'info', snk_hdr_1bps, 'store')
self.tb.msg_connect(parser_4bps, 'info', snk_hdr_4bps, 'store')
self.tb.start()
while (snk_hdr_1bps.num_messages() < 1) and (snk_hdr_4bps.num_messages() < 1):
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
result_1bps = snk_hdr_1bps.get_message(0)
result_4bps = snk_hdr_4bps.get_message(0)
self.assertTrue(pmt.dict_has_key(
result_1bps, pmt.intern('payload symbols')))
self.assertEqual(pmt.to_long(pmt.dict_ref(
result_1bps, pmt.intern('payload symbols'), pmt.PMT_F)), 8)
self.assertTrue(pmt.dict_has_key(
result_4bps, pmt.intern('payload symbols')))
self.assertEqual(pmt.to_long(pmt.dict_ref(
result_4bps, pmt.intern('payload symbols'), pmt.PMT_F)), 2)
def update_timestamp(hdr, seg_size):
if pmt.dict_has_key(hdr, pmt.string_to_symbol("rx_time")):
r = pmt.dict_ref(hdr, pmt.string_to_symbol("rx_time"), pmt.PMT_NIL)
secs = pmt.tuple_ref(r, 0)
fracs = pmt.tuple_ref(r, 1)
secs = float(pmt.to_uint64(secs))
fracs = pmt.to_double(fracs)
t = secs + fracs
else:
sys.stderr.write("Could not find key 'time': \
invalid or corrupt data file.\n")
sys.exit(1)
new_hdr = pmt.dict_delete(hdr, pmt.intern("rx_time"))
if pmt.dict_has_key(hdr, pmt.intern("rx_rate")):
r = pmt.dict_ref(hdr, pmt.intern("rx_rate"), pmt.PMT_NIL)
rate = pmt.to_double(r)
new_t = t + float(seg_size) / rate
new_secs = long(new_t)
new_fracs = new_t - new_secs
time_val = pmt.make_tuple(pmt.from_uint64(new_secs),
pmt.from_double(new_fracs))
new_hdr = pmt.dict_add(new_hdr, pmt.intern("rx_time"), time_val)
return new_hdr
def update_timestamp(hdr,seg_size):
if pmt.dict_has_key(hdr, pmt.string_to_symbol("rx_time")):
r = pmt.dict_ref(hdr, pmt.string_to_symbol("rx_time"), pmt.PMT_NIL)
secs = pmt.tuple_ref(r, 0)
fracs = pmt.tuple_ref(r, 1)
secs = float(pmt.to_uint64(secs))
fracs = pmt.to_double(fracs)
t = secs + fracs
else:
sys.stderr.write("Could not find key 'time': \
invalid or corrupt data file.\n")
sys.exit(1)
new_hdr = pmt.dict_delete(hdr, pmt.intern("rx_time"))
if pmt.dict_has_key(hdr, pmt.intern("rx_rate")):
r = pmt.dict_ref(hdr, pmt.intern("rx_rate"), pmt.PMT_NIL)
rate = pmt.to_double(r)
new_t = t + float(seg_size)/rate
new_secs = long(new_t)
new_fracs = new_t - new_secs
time_val = pmt.make_tuple(pmt.from_uint64(new_secs),
pmt.from_double(new_fracs))
new_hdr = pmt.dict_add(new_hdr, pmt.intern("rx_time"), time_val)
return new_hdr
def test_001_basic_io(self):
self.tb.start()
# provide two non PDU inputs and one PDU input
self.add_sys_time.to_basic_block()._post(
pmt.intern("pdu"), pmt.intern("BAD PDU"))
self.add_sys_time.to_basic_block()._post(pmt.intern("pdu"),
pmt.cons(pmt.from_long(4), pmt.PMT_NIL))
self.add_sys_time.to_basic_block()._post(pmt.intern("pdu"),
pmt.cons(pmt.make_dict(), pmt.init_f32vector(1, [0.0])))
self.waitFor(lambda: self.debug.num_messages() >=
1, timeout=1.0, poll_interval=0.01)
self.tb.stop()
self.tb.wait()
# make sure we got one message and it has a systime key
self.assertEqual(1, self.debug.num_messages())
self.assertTrue(pmt.dict_has_key(
pmt.car(self.debug.get_message(0)), pmt.intern('systime')))
def parse_header(p, VERBOSE=False):
dump = pmt.PMT_NIL
info = dict()
if (pmt.is_dict(p) is False):
sys.stderr.write(
"Header is not a PMT dictionary: invalid or corrupt data file.\n")
sys.exit(1)
# GET FILE FORMAT VERSION NUMBER
if (pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
version = pmt.to_long(r)
if (VERBOSE):
print("Version Number: {0}".format(version))
else:
sys.stderr.write(
"Could not find key 'version': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SAMPLE RATE
if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
samp_rate = pmt.to_double(r)
info["rx_rate"] = samp_rate
if (VERBOSE):
print("Sample Rate: {0:.2f} sps".format(samp_rate))
else:
sys.stderr.write(
"Could not find key 'sr': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT TIME STAMP
if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
secs = pmt.tuple_ref(r, 0)
fracs = pmt.tuple_ref(r, 1)
secs = float(pmt.to_uint64(secs))
fracs = pmt.to_double(fracs)
t = secs + fracs
info["rx_time"] = t
if (VERBOSE):
print("Seconds: {0:.6f}".format(t))
else:
sys.stderr.write(
"Could not find key 'time': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT ITEM SIZE
if (pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
dsize = pmt.to_long(r)
info["size"] = dsize
if (VERBOSE):
print("Item size: {0}".format(dsize))
else:
sys.stderr.write(
"Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT DATA TYPE
if (pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
dtype = pmt.to_long(r)
stype = ftype_to_string[dtype]
info["type"] = stype
if (VERBOSE):
print("Data Type: {0} ({1})".format(stype, dtype))
else:
sys.stderr.write(
"Could not find key 'type': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT COMPLEX
if (pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
cplx = pmt.to_bool(r)
info["cplx"] = cplx
if (VERBOSE):
print("Complex? {0}".format(cplx))
else:
sys.stderr.write(
"Could not find key 'cplx': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT WHERE CURRENT SEGMENT STARTS
if (pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
seg_start = pmt.to_uint64(r)
info["hdr_len"] = seg_start
info["extra_len"] = seg_start - HEADER_LENGTH
info["has_extra"] = info["extra_len"] > 0
if (VERBOSE):
print("Header Length: {0} bytes".format(info["hdr_len"]))
print("Extra Length: {0}".format((info["extra_len"])))
print("Extra Header? {0}".format(info["has_extra"]))
else:
sys.stderr.write(
"Could not find key 'strt': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SIZE OF DATA
if (pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
nbytes = pmt.to_uint64(r)
nitems = nbytes / dsize
info["nitems"] = nitems
info["nbytes"] = nbytes
if (VERBOSE):
print("Size of Data: {0} bytes".format(nbytes))
print(" {0} items".format(nitems))
else:
sys.stderr.write(
"Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
return info
def handle_msg(self, msg):
if(pmt.dict_has_key( msg, pmt.to_pmt("log_msg"))):
log_msg = pmt.dict_ref( msg, pmt.to_pmt("log_msg"), pmt.PMT_NIL)
self.console_msg = pmt.to_python(log_msg)
self.emit(QtCore.SIGNAL("console_update"))
def parse_header(p, VERBOSE=False):
dump = pmt.PMT_NIL
info = dict()
if(pmt.is_dict(p) is False):
sys.stderr.write("Header is not a PMT dictionary: invalid or corrupt data file.\n")
sys.exit(1)
# GET FILE FORMAT VERSION NUMBER
if(pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
version = pmt.to_long(r)
if(VERBOSE):
print("Version Number: {0}".format(version))
else:
sys.stderr.write("Could not find key 'version': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SAMPLE RATE
if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
samp_rate = pmt.to_double(r)
info["rx_rate"] = samp_rate
if(VERBOSE):
print("Sample Rate: {0:.2f} sps".format(samp_rate))
else:
sys.stderr.write("Could not find key 'sr': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT TIME STAMP
if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
secs = pmt.tuple_ref(r, 0)
fracs = pmt.tuple_ref(r, 1)
secs = float(pmt.to_uint64(secs))
fracs = pmt.to_double(fracs)
t = secs + fracs
info["rx_time"] = t
if(VERBOSE):
print("Seconds: {0:.6f}".format(t))
else:
sys.stderr.write("Could not find key 'time': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT ITEM SIZE
if(pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
dsize = pmt.to_long(r)
info["size"] = dsize
if(VERBOSE):
print("Item size: {0}".format(dsize))
else:
sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT DATA TYPE
if(pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
dtype = pmt.to_long(r)
stype = ftype_to_string[dtype]
info["type"] = stype
if(VERBOSE):
print("Data Type: {0} ({1})".format(stype, dtype))
else:
sys.stderr.write("Could not find key 'type': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT COMPLEX
if(pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
cplx = pmt.to_bool(r)
info["cplx"] = cplx
if(VERBOSE):
print("Complex? {0}".format(cplx))
else:
sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT WHERE CURRENT SEGMENT STARTS
if(pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
seg_start = pmt.to_uint64(r)
info["hdr_len"] = seg_start
info["extra_len"] = seg_start - HEADER_LENGTH
info["has_extra"] = info["extra_len"] > 0
if(VERBOSE):
print("Header Length: {0} bytes".format(info["hdr_len"]))
print("Extra Length: {0}".format((info["extra_len"])))
print("Extra Header? {0}".format(info["has_extra"]))
else:
sys.stderr.write("Could not find key 'strt': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SIZE OF DATA
if(pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
nbytes = pmt.to_uint64(r)
nitems = nbytes / dsize
info["nitems"] = nitems
info["nbytes"] = nbytes
if(VERBOSE):
print("Size of Data: {0} bytes".format(nbytes))
print(" {0} items".format(nitems))
else:
sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
return info
def parse_header(p, VERBOSE=False):
dump = pmt.PMT_NIL
info = dict()
if (pmt.is_dict(p) is False):
sys.stderr.write(
"Header is not a PMT dictionary: invalid or corrupt data file.\n")
sys.exit(1)
# GET FILE FORMAT VERSION NUMBER
if (pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
version = pmt.to_long(r)
if (VERBOSE):
print "Version Number: {0}".format(version)
else:
sys.stderr.write(
"Could not find key 'version': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SAMPLE RATE
if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
samp_rate = pmt.to_double(r)
info["rx_rate"] = samp_rate
if (VERBOSE):
print "Sample Rate: " + eng_notation.num_to_str(samp_rate) + "SPS"
else:
sys.stderr.write(
"Could not find key 'sr': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT TIME STAMP
if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
secs = pmt.tuple_ref(r, 0)
fracs = pmt.tuple_ref(r, 1)
secs = float(pmt.to_uint64(secs))
fracs = pmt.to_double(fracs)
t = secs + fracs
info["rx_time"] = t
if (VERBOSE):
time = datetime.fromtimestamp(t).strftime('%m/%d/%Y %H:%M:%S')
print "Timestamp (Unix Epoch): " + time
print "Integer Seconds: " + repr(secs)
print "Fractional Seconds: " + repr(fracs)
#print "Linux Epoch: {0:.6f}".format(t) + " Seconds"
else:
sys.stderr.write(
"Could not find key 'time': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT ITEM SIZE
if (pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
dsize = pmt.to_long(r)
info["size"] = dsize
if (VERBOSE):
print "Item Size: " + eng_notation.num_to_str(dsize) + " Bytes"
else:
sys.stderr.write(
"Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT DATA TYPE
if (pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
dtype = pmt.to_long(r)
stype = ftype_to_string[dtype]
info["type"] = stype
if (VERBOSE):
print "Data Type: {0} ({1})".format(stype, dtype)
else:
sys.stderr.write(
"Could not find key 'type': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT COMPLEX
if (pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
#global cplx
cplx = pmt.to_bool(r)
info["cplx"] = cplx
if (VERBOSE):
print "Complex? {0}".format(cplx)
global vecchk
global tsize
#print cplx
#print dtype
#print dsize
if (cplx == False):
if (dtype == 0):
tsize = 1
elif (dtype == 1):
tsize = 4
elif (dtype == 2):
tsize = 4
elif (dtype == 3):
tsize = 4
elif (dtype == 5):
tsize = 4
elif (dtype == 6):
tsize = 8
else:
tsize = 64
#print tsize
vecchk = dsize / tsize
#print vecchk
if (vecchk > 1):
print "The data is a vector containing {0} elements.".format(
vecchk)
else:
print "The data is not a vector."
'''else:
sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n")
sys.exit(1)
'''
# EXTRACT WHERE CURRENT SEGMENT STARTS
if (pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
seg_start = pmt.to_uint64(r)
info["hdr_len"] = seg_start
info["extra_len"] = seg_start - HEADER_LENGTH
info["has_extra"] = info["extra_len"] > 0
if (VERBOSE):
print "Header Length: {0} bytes".format(info["hdr_len"])
print "Extra Length: {0}".format((info["extra_len"]))
print "Extra Header? {0}".format(info["has_extra"])
else:
sys.stderr.write(
"Could not find key 'strt': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SIZE OF DATA
if (pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
nbytes = pmt.to_uint64(r)
nitems = nbytes / dsize
info["nitems"] = nitems
info["nbytes"] = nbytes
#info["types"] = types
if (VERBOSE):
#print "Size of Data: {0:2.1e} bytes".format(nbytes)
print "Segment Size (bytes): " + eng_notation.num_to_str(nbytes)
#print " {0:2.1e} items".format(nitems)
print "Segment Size (items): " + eng_notation.num_to_str(nitems)
else:
sys.stderr.write(
"Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
return info
def handle_msg(self, msg):
if pmt.dict_has_key(msg, pmt.to_pmt("log_msg")):
log_msg = pmt.dict_ref(msg, pmt.to_pmt("log_msg"), pmt.PMT_NIL)
self.console_msg = pmt.to_python(log_msg)
self.emit(QtCore.SIGNAL("console_update"))
def parse_header(p, VERBOSE=False):
dump = pmt.PMT_NIL
info = dict()
if(pmt.is_dict(p) is False):
sys.stderr.write("Header is not a PMT dictionary: invalid or corrupt data file.\n")
sys.exit(1)
# GET FILE FORMAT VERSION NUMBER
if(pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
version = pmt.to_long(r)
if(VERBOSE):
print "Version Number: {0}".format(version)
else:
sys.stderr.write("Could not find key 'version': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SAMPLE RATE
if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
samp_rate = pmt.to_double(r)
info["rx_rate"] = samp_rate
if(VERBOSE):
print "Sample Rate: " + eng_notation.num_to_str(samp_rate) + "SPS"
else:
sys.stderr.write("Could not find key 'sr': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT TIME STAMP
if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
secs = pmt.tuple_ref(r, 0)
fracs = pmt.tuple_ref(r, 1)
secs = float(pmt.to_uint64(secs))
fracs = pmt.to_double(fracs)
t = secs + fracs
info["rx_time"] = t
if(VERBOSE):
time = datetime.fromtimestamp(t).strftime('%m/%d/%Y %H:%M:%S')
print "Timestamp (Unix Epoch): " + time
print "Integer Seconds: " + repr(secs)
print "Fractional Seconds: " + repr(fracs)
#print "Linux Epoch: {0:.6f}".format(t) + " Seconds"
else:
sys.stderr.write("Could not find key 'time': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT ITEM SIZE
if(pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
dsize = pmt.to_long(r)
info["size"] = dsize
if(VERBOSE):
print "Item Size: " + eng_notation.num_to_str(dsize) + " Bytes"
else:
sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT DATA TYPE
if(pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
dtype = pmt.to_long(r)
stype = ftype_to_string[dtype]
info["type"] = stype
if(VERBOSE):
print "Data Type: {0} ({1})".format(stype, dtype)
else:
sys.stderr.write("Could not find key 'type': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT COMPLEX
if(pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
#global cplx
cplx = pmt.to_bool(r)
info["cplx"] = cplx
if(VERBOSE):
print "Complex? {0}".format(cplx)
global vecchk
global tsize
#print cplx
#print dtype
#print dsize
if(cplx==False):
if(dtype==0):
tsize=1
elif(dtype==1):
tsize=4
elif(dtype==2):
tsize=4
elif(dtype==3):
tsize=4
elif(dtype==5):
tsize=4
elif(dtype==6):
tsize=8
else:
tsize=64
#print tsize
vecchk = dsize/tsize
#print vecchk
if(vecchk>1):
print "The data is a vector containing {0} elements.".format(vecchk)
else:
print "The data is not a vector."
'''else:
sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n")
sys.exit(1)
'''
# EXTRACT WHERE CURRENT SEGMENT STARTS
if(pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
seg_start = pmt.to_uint64(r)
info["hdr_len"] = seg_start
info["extra_len"] = seg_start - HEADER_LENGTH
info["has_extra"] = info["extra_len"] > 0
if(VERBOSE):
print "Header Length: {0} bytes".format(info["hdr_len"])
print "Extra Length: {0}".format((info["extra_len"]))
print "Extra Header? {0}".format(info["has_extra"])
else:
sys.stderr.write("Could not find key 'strt': invalid or corrupt data file.\n")
sys.exit(1)
# EXTRACT SIZE OF DATA
if(pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
nbytes = pmt.to_uint64(r)
nitems = nbytes/dsize
info["nitems"] = nitems
info["nbytes"] = nbytes
#info["types"] = types
if(VERBOSE):
#print "Size of Data: {0:2.1e} bytes".format(nbytes)
print "Segment Size (bytes): " + eng_notation.num_to_str(nbytes)
#print " {0:2.1e} items".format(nitems)
print "Segment Size (items): " + eng_notation.num_to_str(nitems)
else:
sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
sys.exit(1)
return info
