def test_002_holdoff (self):
self.tb = gr.top_block ()
trig_key = pmt.intern("TRIGGER")
tags = []
tags.append(gr.tag_utils.python_to_tag((5, trig_key, pmt.PMT_T))) # should trigger
tags.append(gr.tag_utils.python_to_tag((6, trig_key, pmt.PMT_T)))
tags.append(gr.tag_utils.python_to_tag((9, trig_key, pmt.PMT_T))) # should trigger
tags.append(gr.tag_utils.python_to_tag((10, trig_key, pmt.PMT_T)))
tags.append(gr.tag_utils.python_to_tag((11, trig_key, pmt.PMT_T)))
tags.append(gr.tag_utils.python_to_tag((12, trig_key, pmt.PMT_T)))
tags.append(gr.tag_utils.python_to_tag((13, trig_key, pmt.PMT_T))) # should trigger
msg = pmt.cons(pmt.dict_add(pmt.make_dict(), pmt.intern("K1"), pmt.intern("V1")), pmt.init_u8vector(4,[48,49,50,51,]))
src = blocks.vector_source_f(range(20), False, 1, tags)
tmt = pdu_utils.tag_message_trigger_f(trig_key, pmt.PMT_NIL, msg, 3, 0.0, 0.0, 0.0, False)
debug = blocks.message_debug()
self.tb.connect(src, tmt)
self.tb.msg_connect((tmt, 'msg'), (debug, 'store'))
self.tb.run ()
self.assertEquals(debug.num_messages(),3)
self.assertTrue(pmt.eqv(msg, debug.get_message(0)))
self.assertTrue(pmt.eqv(msg, debug.get_message(1)))
self.tb = None
def handle_command(self, msg):
# incoming message will be a dictionary that should contain the items
# freq and lo_offset at a minimum - if this is met, issue a command
# that can be handled by the freq_xlating_fir_filter_ccf block
try:
#print "got a message!"
# we don't care about the frequency since we are CORDIC tuning
lo_offset = pmt.dict_ref(msg, self.dict_key, pmt.PMT_NIL)
if not pmt.eqv(lo_offset, pmt.PMT_NIL):
offset = pmt.to_python(lo_offset)
#print "lo offset is " + repr(offset*-1.0)
self.message_port_pub(pmt.intern("freq"),
pmt.cons(pmt.intern("freq"), pmt.from_double(-1.0*offset)))
#print "published msg, offset = " + repr(-1.0*offset)
# if the dictionary has a time value, use it
time_tag = pmt.dict_ref(msg, pmt.intern("time"), pmt.PMT_NIL)
if not pmt.eqv(time_tag, pmt.PMT_NIL):
secs = pmt.to_uint64(pmt.car(time_tag)) - self.origin_time['secs']
frac = pmt.to_double(pmt.cdr(time_tag)) - self.origin_time['frac']
tune_sample = long(secs * self.sample_rate) + long(frac * self.sample_rate)
else:
tune_sample = TAG_IMMEDIATELY
# we will also set the block to tag the output when it is time
self.tag_offset = tune_sample
self.tag_value = pmt.from_double(-1.0*offset)
except Exception as e:
print "exception: " + repr(e)
def test_002_normal(self):
tnow = time.time()
in_data = [
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,
0, 1
]
meta = pmt.dict_add(pmt.make_dict(), pmt.intern('wall_clock_time'),
pmt.from_double(tnow - 10))
in_pdu = pmt.cons(meta, pmt.init_c32vector(len(in_data), in_data))
e_data = [
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1,
0, 1
]
e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern('wall_clock_time'),
pmt.from_double(tnow))
e_pdu = pmt.cons(e_meta, pmt.init_c32vector(len(e_data), e_data))
# set up fg
self.tb.start()
time.sleep(.001)
self.emitter.emit(in_pdu)
time.sleep(.01)
self.tb.stop()
self.tb.wait()
# check data
self.assertEqual(1, self.debug.num_messages())
#print("test_002_normal2:")
#print("pdu expected: " + repr(pmt.car(e_pdu)))
#print("pdu got: " + repr(pmt.car(self.debug.get_message(0))))
#print("data expected: " + repr(pmt.to_python(pmt.cdr(e_pdu))))
#print("data got: " + repr(pmt.to_python(pmt.cdr(self.debug.get_message(0)))))
#print
a_meta = pmt.car(self.debug.get_message(0))
time_tag = pmt.dict_ref(a_meta, pmt.intern("wall_clock_time"),
pmt.PMT_NIL)
if not pmt.eqv(time_tag, pmt.PMT_NIL):
self.assertAlmostEqual(tnow, pmt.to_double(time_tag), delta=60)
else:
self.assertTrue(False)
delta_tag = pmt.dict_ref(a_meta, pmt.intern("time_delta_ms"),
pmt.PMT_NIL)
if not pmt.eqv(delta_tag, pmt.PMT_NIL):
self.assertAlmostEqual(10000, pmt.to_double(delta_tag), delta=10)
else:
self.assertTrue(False)
def work(self, input_items, output_items):
in0 = input_items[0]
start = self.nitems_read(0)
end = start + len(in0)
tags = self.get_tags_in_range(0, start, end)
for tag in tags:
if pmt.eqv(tag.key, self.st):
self.start_idx = tag.offset
elif pmt.eqv(tag.key, self.et):
if self.start_idx:
print(
repr(
round((tag.offset - self.start_idx) * 1000.0 /
self.rate, 3)) + ", ")
self.start_idx = 0
return len(in0)
def test_002_emit2(self):
emitter = pdu_utils.message_emitter()
debug = blocks.message_debug()
msg = pmt.cons(pmt.intern("TEST MESSAGE"),
pmt.init_u8vector(4, range(4)))
self.tb.msg_connect((emitter, 'msg'), (debug, 'store'))
self.tb.start()
time.sleep(.001)
emitter.emit()
time.sleep(.001)
emitter.emit(msg)
time.sleep(.01)
self.tb.stop()
self.tb.wait()
print(emitter.get_n_msgs())
self.assertEquals(2, debug.num_messages())
self.assertTrue(pmt.eqv(pmt.PMT_NIL, debug.get_message(0)))
self.assertTrue(pmt.eqv(msg, debug.get_message(1)))
def handle_command(self, msg):
with self.lock:
# incoming message will be a dictionary that should contain the items
# freq and lo_offset at a minimum - if this is met, issue a command
# that can be handled by the freq_xlating_fir_filter_ccf block
try:
# print "got a message!"
# we don't care about the frequency since we are CORDIC tuning
lo_offset = pmt.dict_ref(msg, self.dict_key, pmt.PMT_NIL)
if not pmt.eqv(lo_offset, pmt.PMT_NIL):
offset = pmt.to_python(lo_offset)
# print "lo offset is " + repr(offset*-1.0)
self.message_port_pub(
timing_utils.PMTCONSTSTR__freq(),
pmt.cons(timing_utils.PMTCONSTSTR__freq(),
pmt.from_double(-1.0 * offset)))
# print "published msg, offset = " + repr(-1.0*offset)
# if the dictionary has a time value, use it
time_tag = pmt.dict_ref(msg,
timing_utils.PMTCONSTSTR__time(),
pmt.PMT_NIL)
if not pmt.eqv(time_tag, pmt.PMT_NIL):
secs = pmt.to_uint64(
pmt.car(time_tag)) - self.ref_time['secs']
frac = pmt.to_double(
pmt.cdr(time_tag)) - self.ref_time['frac']
tune_sample = int(secs * self.sample_rate) + int(
frac * self.sample_rate) + self.ref_time['offset']
else:
tune_sample = TAG_IMMEDIATELY
# we will also set the block to tag the output when it is time
if len(self.tune_commands) < self.tune_commands.maxlen:
self.tune_commands.append(
(tune_sample, pmt.from_double(-1.0 * offset)))
except Exception as e:
print("exception: " + repr(e))
def test_debug_401(self):
msg = pmt.intern("TESTING")
src = blocks.message_strobe(msg, 500)
snk = blocks.message_debug()
tb = gr.top_block()
tb.msg_connect(src, "strobe", snk, "store")
tb.start()
time.sleep(1)
tb.stop()
tb.wait()
rec_msg = snk.get_message(0)
self.assertTrue(pmt.eqv(rec_msg, msg))
def test_debug_401(self):
msg = pmt.intern("TESTING")
src = blocks.message_strobe(msg, 500)
snk = blocks.message_debug()
tb = gr.top_block()
tb.msg_connect(src, "strobe", snk, "store")
tb.start()
time.sleep(1)
tb.stop()
tb.wait()
rec_msg = snk.get_message(0)
self.assertTrue(pmt.eqv(rec_msg, msg))
def test_002_tags(self):
self.duration = 125000
tnow = time.time()
src_tag = gr.tag_utils.python_to_tag([
0,
pmt.intern("wall_clock_time"),
pmt.from_double(tnow - 10000),
pmt.intern("test_002_tags")
])
self.src = blocks.vector_source_c(list(range(self.duration)), False, 1,
[src_tag])
self.throttle = blocks.throttle(gr.sizeof_gr_complex * 1, 250000)
self.dut = timing_utils.system_time_diff_c(True, False)
self.tag_dbg = blocks.tag_debug(gr.sizeof_gr_complex * 1, '', "")
self.nullf = blocks.null_sink(gr.sizeof_float * 1)
self.tb.connect((self.src, 0), (self.throttle, 0))
self.tb.connect((self.throttle, 0), (self.dut, 0))
self.tb.connect((self.dut, 0), (self.tag_dbg, 0))
self.tb.connect((self.dut, 1), (self.nullf, 0))
self.tb.start()
time.sleep(.02)
tags = self.tag_dbg.current_tags()
time_tag = None
print("Dumping tags")
for t in tags:
print('Tag:', t.key, ' ', t.value)
if pmt.eqv(t.key, pmt.intern("wall_clock_time")):
time_tag = t
if time_tag:
self.assertAlmostEqual(tnow,
pmt.to_double(time_tag.value),
delta=60)
else:
self.assertTrue(False)
time.sleep(.1)
self.tb.stop()
