def __init__(self, value=None, rate=1.0):
gr.basic_block.__init__(
self,
name="py_msg_strobe",
in_sig=None,
out_sig=None,
)
self.init = True
self.value = None
self.msgOut = None
self.rate = 0.0
self.interval = 0.0
print "py_msg_strobe.__init__".center(80, "~")
self.inPortName = pmt.intern("msg")
self.message_port_register_in(self.inPortName)
self.set_msg_handler(self.inPortName, self.msgRx)
self.outPortName = pmt.intern("msg")
self.message_port_register_out(self.outPortName)
self.setValue(value)
self.setRate(rate)
self.thread = threading.Thread(target=self.msgTxLoop)
self.thread.daemon = True
self.thread.start()
self.init = False
def __init__(self, autoscale, log_plot, plot_depth_db, *args):
gr.sync_block.__init__(self,
name="polar_plot",
in_sig=None,
out_sig=None)
PlotWidget.__init__(self, enableMenu=False, axisItems={}, *args)
self.curve = self.plot([],
pen=(0, 200, 100),
width=2.0,
name="Polar Response")
self.circles = []
self.autoscale = autoscale
self.log_plot = log_plot
self.plot_depth = plot_depth_db
angles = np.array(np.linspace(-180.0, 180.0, 361), dtype=np.float32)
for kk in range(0, int(10 * math.floor(self.plot_depth / 10.0)), 10):
mag = 1 - float(kk) / self.plot_depth
r = mag * np.ones(len(angles))
x = self.pol_to_car_x(r, angles)
y = self.pol_to_car_y(r, angles)
self.circles.append(
self.plot(x,
y,
pen=pg.mkPen((128, 128, 128),
style=QtCore.Qt.DashLine)))
self.message_port_register_in(pmt.intern("plot"))
self.set_msg_handler(pmt.intern("plot"), self.handler)
self.sigUpdateData.connect(self.updateGraph)
def __init__(self, preamble):
gr.basic_block.__init__(self,
name="preamble_adder",
in_sig=[],
out_sig=[])
self.message_port_register_out(pmt.intern("out"))
self.message_port_register_in(pmt.intern("in"))
self.set_msg_handler(pmt.intern("in"), self._handle_msg)
self.preamble = preamble
def __init__(self, prefix):
gr.basic_block.__init__(self,
name="preamble_stripper",
in_sig=[],
out_sig=[])
self.message_port_register_out(pmt.intern('out'))
self.message_port_register_in(pmt.intern('in'))
self.set_msg_handler(pmt.intern('in'), self._handle_msg)
self.prefix = prefix
self.search = len(prefix) * 2
def __init__(self):
gr.basic_block.__init__(self,
name="magic_decoder",
in_sig=[],
out_sig=[])
self.port_out = pmt.intern("out")
self.port_in = pmt.intern("in")
self.port_info = pmt.intern("info")
self.message_port_register_out(self.port_out)
self.message_port_register_out(self.port_info)
self.message_port_register_in(self.port_in)
self.set_msg_handler(self.port_in, self._handle_msg)
def __init__(self, prefix):
gr.basic_block.__init__(self,
name="pn_decode_identity_b",
in_sig=[numpy.byte],
out_sig=[])
self.message_port_register_out(pmt.intern("pdus"))
self.packet = []
self.prefix = prefix
def test_001_t(self):
for src_data, padding, expected_result in [
(
[],
10,
[],
),
(
[
[1, 0, 1],
],
10,
[
(1, 0, 1),
],
),
(
[
[1, 0, 1],
[0, 1, 0],
],
1,
[
(1, 0, 1),
(0, 1, 0),
],
),
]:
# Set up flowgraph.
source = habets.pn_source_f(padding)
dst = habets.pn_decode_f(1, 0, 0, 1)
dbg = blocks.message_debug()
self.tb.connect(source, dst)
self.tb.msg_connect(dst, "pdus", dbg, "store")
for pack in src_data:
source.to_basic_block()._post(
pmt.intern("pdus"),
pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(pack), pack)))
self.tb.start()
while dbg.num_messages() < len(expected_result):
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
for n, msg in enumerate(expected_result):
res = tuple(pmt.to_python(pmt.cdr(dbg.get_message(n))))
try:
self.assertTupleEqual(expected_result[n], res)
except AssertionError:
print "--"
print "Source:", msg
print "Padding:", padding
print "Want: ", expected_result[n]
print "Got: ", res
raise
def test_001_t (self):
for src_data, expected_result in (
(
[],
[],
),
(
[0],
[0,0,0,0,0,0,0,0],
),
(
[128],
[1,0,0,0,0,0,0,0],
),
(
[2],
[0,0,0,0,0,0,1,0],
),
(
[128],
[1,0,0,0,0,0,0,0],
),
(
[128, 64],
[1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0],
),
):
pack = habets.bitunpacker()
dbg = blocks.message_debug()
self.tb.msg_connect(pack, "out", dbg, "store")
self.tb.start()
pack.to_basic_block()._post(
pmt.intern("in"),
pmt.cons(
pmt.PMT_NIL,
pmt.init_u8vector(len(src_data), src_data)
)
)
while dbg.num_messages() < 1:
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
res = pmt.to_python(pmt.cdr(dbg.get_message(0)))
try:
self.assertFloatTuplesAlmostEqual(expected_result, res, 1)
except AssertionError:
print "--"
print "Source:", src_data
print "Want: ", expected_result
print "Got: ", list(res)
raise
def test_001_t(self):
for src_data, expected_result in (
(
[],
[],
),
(
[0],
[],
),
(
[1],
[],
),
(
[0, 1, 0, 1, 0, 0, 1],
[0, 0, 1],
),
( # Garbage beginning.
[1, 1, 0, 1, 0, 1, 0, 0, 1],
[0, 0, 1],
),
( # Pick last preamble.
[0, 1, 0, 1, 0, 1, 0, 0, 1],
[0, 0, 1],
),
):
if not expected_result:
continue
strip = preamble_stripper(prefix=[0, 1, 0, 1])
dbg = blocks.message_debug()
self.tb.msg_connect(strip, "out", dbg, "store")
self.tb.start()
strip.to_basic_block()._post(
pmt.intern("in"),
pmt.cons(pmt.PMT_NIL,
pmt.init_u8vector(len(src_data), src_data)))
while dbg.num_messages() < 1:
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
res = pmt.to_python(pmt.cdr(dbg.get_message(0)))
try:
self.assertFloatTuplesAlmostEqual(expected_result, res, 1)
except AssertionError:
print "--"
print "Source:", src_data
print "Want: ", expected_result
print "Got: ", list(res)
raise
def test_001_t(self):
try:
fs = open("jt65.floats").read()
except IOError:
print "Test input not found; skipping unit test"
return
fs = list(struct.unpack("f" * (len(fs) / 4), fs))
rnd = lambda x: [random.randint(-120, 120) for _ in range(x)]
for name, src_data, expected_result in (
('clean', fs, "CQ M0THC IO91"),
('random-prefix', rnd(44100 * 2) + fs, "CQ M0THC IO91"),
):
# print 'Making data'
pmt_data = pmt.cons(
pmt.PMT_NIL, pmt.init_f32vector(len(src_data), list(src_data)))
# print 'Making flowgraph'
dec = habets.jt65_decode(44100, int(44100 * 0.372), 10, 8192, 10.8)
dbg = blocks.message_debug()
self.tb.msg_connect(dec, "out", dbg, "store")
# print 'Starting flowgraph'
self.tb.start()
# print 'Posting message'
dec.to_basic_block()._post(
pmt.intern("in"),
pmt_data,
)
# print 'Waiting for message'
while dbg.num_messages() < 1:
time.sleep(0.1)
# print 'Stopping flowgraph'
self.tb.stop()
self.tb.wait()
# print 'Getting reply'
res = pmt.to_python(pmt.cdr(dbg.get_message(0)))
res = ''.join([chr(x) for x in res])
try:
# print res
assert res == expected_result
print "%s OK" % name
except AssertionError:
print "--"
print "Want: ", expected_result
print "Got: ", res
raise
def _handle_msg(self, msg_pmt):
meta = pmt.car(msg_pmt)
bs = pmt.u8vector_elements(pmt.cdr(msg_pmt))
fs = numpy.frombuffer(''.join([chr(x) for x in bs]),
dtype=numpy.float32)
#print "Got msg of size %d" % len(fs)
#print midpoint(fs)
misc, data = wpcr(fs)
bits = slice_bits(data)
vec = pmt.init_u8vector(len(bits), [int(x) for x in bits])
meta = pmt.dict_add(meta, pmt.intern("magic_decoder"),
pmt.to_pmt(misc))
self.message_port_pub(self.port_out, pmt.cons(meta, vec))
self.message_port_pub(self.port_info, meta)
def _handle_msg(self, msg_pmt):
bits = pmt.u8vector_elements(pmt.cdr(msg_pmt))
found = None
for i in range(self.search - 1, -1, -1):
candidate = list(bits[i:i + len(self.prefix)])
if candidate == self.prefix:
found = i
break
if found is None:
return
bits = bits[found + len(self.prefix):]
vec = pmt.init_u8vector(len(bits), bits)
self.message_port_pub(pmt.intern('out'),
pmt.cons(pmt.car(msg_pmt), vec))
def test_001_t(self):
for src_data, expected_result in (
#(
# [],
# [],
#),
( # Three samples per step.
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0],
[1.0, 1.0, 2.0, 3.0],
),
( # Discard initial crap.
[
-1, 1, -1, 1, -1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0,
2.0, 3.0, 3.0, 3.0
],
[1.0, 1.0, 2.0, 3.0],
),
( # Three samples per step, but with one garbage in between.
[
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 2.0, 2.0, 2.0, 0.5, 3.0,
3.0, 3.0
],
[1.0, 1.0, 2.0, 3.0],
),
):
stair = habets.stairclocker(3, 3, 0.02)
dbg = blocks.message_debug()
self.tb.msg_connect(stair, "out", dbg, "store")
self.tb.start()
stair.to_basic_block()._post(
pmt.intern("in"),
pmt.cons(pmt.PMT_NIL,
pmt.init_f32vector(len(src_data), src_data)))
while dbg.num_messages() < 1:
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
res = pmt.to_python(pmt.cdr(dbg.get_message(0)))
res = struct.unpack('f' * (len(res) / 4), res)
try:
self.assertFloatTuplesAlmostEqual(expected_result, res, 1)
except AssertionError:
print "--"
print "Source:", src_data
print "Want: ", expected_result
print "Got: ", res
raise
def test_001_t (self):
for src_data, expected_result in (
(
[],
[0,1,0,1],
),
(
[0],
[0,1,0,1,0],
),
(
[1],
[0,1,0,1,1],
),
(
[0,1,0,1,0,0,1],
[0,1,0,1,0,1,0,1,0,0,1],
),
):
adder = preamble_adder(preamble=[0,1,0,1])
dbg = blocks.message_debug()
self.tb.msg_connect(adder, "out", dbg, "store")
self.tb.start()
vec = pmt.init_u8vector(len(src_data), src_data)
adder.to_basic_block()._post(
pmt.intern("in"),
pmt.cons(
pmt.PMT_NIL,
pmt.init_u8vector(len(src_data), src_data),
)
)
while dbg.num_messages() < 1:
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
res = pmt.to_python(pmt.cdr(dbg.get_message(0)))
try:
self.assertFloatTuplesAlmostEqual(expected_result, res, 1)
except AssertionError:
print "--"
print "Source:", src_data
print "Want: ", expected_result
print "Got: ", res
raise
def emit(self):
if not len(self.packet):
return
payload = None
for i in range(len(self.packet)):
if self.packet[i:i + len(self.prefix)] == self.prefix:
payload = self.packet[i:]
break
if payload:
b = list(bits_to_bytes(payload))
data = pmt.make_u8vector(len(b), ord(' '))
for i in range(len(b)):
pmt.u8vector_set(data, i, b[i])
self.message_port_pub(pmt.intern('pdus'),
pmt.cons(pmt.PMT_NIL, data))
else:
pass
#print self.packet
self.packet = []
def _handle_msg(self, msg_pmt):
bits = list(self.preamble) + list(
pmt.u8vector_elements(pmt.cdr(msg_pmt)))
vec = pmt.init_u8vector(len(bits), bits)
self.message_port_pub(pmt.intern("out"), pmt.cons(pmt.PMT_NIL, vec))
def __init__(self, radioObj, debug=False, **kwargs):
self._init = True
self._started = False
self._stopped = False
gr.basic_block.__init__(self,
name=self._name,
in_sig=None,
out_sig=None)
self.log = logging.getLogger(self._name)
self.log.setLevel(logging.DEBUG if debug else logging.INFO)
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
handler.setFormatter(
logging.Formatter(
'%(asctime)s :: %(name)s(%(levelname)s) :: %(message)s'))
self.log.addHandler(handler)
self.log.debug("__init__")
self.radioObj = radioObj
self.log.debug("Radio Object = %r" % (self.radioObj, ))
## Setup ports for control messaging
self.msgPort_control = pmt.intern("control")
if self._portEnable_controlRx:
self.log.debug("Enabling control message reception")
self.message_port_register_in(self.msgPort_control)
self.set_msg_handler(self.msgPort_control, self.rxControlMsg)
if self._portEnable_controlTx:
self.log.debug("Enabling control message transmission")
self.message_port_register_out(self.msgPort_control)
## Setup ports for status messaging
self.msgPort_status = pmt.intern("status")
if self._portEnable_statusRx:
self.log.debug("Enabling status message reception")
self.message_port_register_in(self.msgPort_status)
self.set_msg_handler(self.msgPort_status, self.rxStatusMsg)
if self._portEnable_statusTx:
self.log.debug("Enabling status message transmission")
self.message_port_register_out(self.msgPort_status)
## Setup ports for enable messaging
self.msgPort_enable = pmt.intern("enable")
if self._portEnable_enableRx:
self.log.debug("Enabling enable message reception")
self.message_port_register_in(self.msgPort_enable)
self.set_msg_handler(self.msgPort_enable, self.rxEnableMsg)
if self._portEnable_enableTx:
self.log.debug("Enabling enable message reception")
self.message_port_register_out(self.msgPort_enable)
## Setup ports for frequency messaging
self.msgPort_freq = pmt.intern("freq")
if self._portEnable_freqRx:
self.log.debug("Enabling freq message reception")
self.message_port_register_in(self.msgPort_freq)
self.set_msg_handler(self.msgPort_freq, self.rxFreqMsg)
if self._portEnable_freqTx:
self.log.debug("Enabling freq message reception")
self.message_port_register_out(self.msgPort_freq)
## Setup ports for UDP block messaging
self.msgPort_udp = pmt.intern("udp")
if self._portEnable_udpRx:
self.log.debug("Enabling UDP message reception")
self.message_port_register_in(self.msgPort_udp)
self.set_msg_handler(self.msgPort_udp, self.rxUdpMsg)
if self._portEnable_udpTx:
self.log.debug("Enabling UDP message reception")
self.message_port_register_out(self.msgPort_udp)
def _sendPmtPair(self, port, key, value):
a = pmt.intern(key)
b = pmt.to_pmt(value)
msg = pmt.cons(a, b)
self.message_port_pub(port, msg)
