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)