def test_001_c32(self): ''' uint8_t input data, no decimation, no filter ''' self.dut = pdu_utils.pdu_fir_filter(1, [1.0]) self.connectUp() i_data = [1, 0, 0, 0] * 5 i_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_float(1000.0)) in_pdu = pmt.cons(i_meta, pmt.init_c32vector(len(i_data), i_data)) e_data = [1, 0, 0, 0] * 5 e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_float(1000.0)) e_pdu = pmt.cons(e_meta, pmt.init_c32vector(len(e_data), e_data)) self.tb.start() time.sleep(.01) self.emitter.emit(in_pdu) time.sleep(.1) self.tb.stop() self.tb.wait() #print("test_001:") #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 self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_002(self): ''' Input data has extra quiet time front and rear ''' self.dut = pdu_utils.pdu_fine_time_measure(0.005, 0.005, 10, 15) self.connectUp() i_data = [0.1 + 0j] * 10 + [1.0 + 0j] * 980 + [0.1 + 0j] * 10 i_vec = pmt.init_c32vector(3, [3 + 4j, 1 + 0j, 0 + 1j]) i_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("start_time"), pmt.from_double(1.0)) i_meta = pmt.dict_add(i_meta, pmt.intern("sample_rate"), pmt.from_float(1000.0)) i_meta = pmt.dict_add(i_meta, pmt.intern("duration"), pmt.from_float(1000.0)) in_pdu = pmt.cons(i_meta, pmt.init_c32vector(len(i_data), i_data)) e_data = [1.0 + 0j] * 980 + [0.1 + 0j] * 10 e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_float(1000.0)) e_meta = pmt.dict_add(e_meta, pmt.intern("start_time"), pmt.from_double(1.01)) e_meta = pmt.dict_add(e_meta, pmt.intern("duration"), pmt.from_float(999.99)) e_pdu = pmt.cons(e_meta, pmt.init_c32vector(len(e_data), e_data)) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() #print("test_002:") #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 self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_001(self): ''' Input data perfectly matches params to pdu_fine_time_measure ''' self.dut = pdu_utils.pdu_fine_time_measure(0.005, 0.005, 10, 15) self.connectUp() i_data = [0.1 + 0j] * 5 + [1.0 + 0j] * 990 + [0.1 + 0j] * 5 i_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("start_time"), pmt.from_double(1.0)) i_meta = pmt.dict_add(i_meta, pmt.intern("sample_rate"), pmt.from_float(1000.0)) i_meta = pmt.dict_add(i_meta, pmt.intern("duration"), pmt.from_float(1000.0)) in_pdu = pmt.cons(i_meta, pmt.init_c32vector(len(i_data), i_data)) e_data = [1.0 + 0j] * 990 + [0.1 + 0j] * 5 e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_float(1000.0)) e_meta = pmt.dict_add(e_meta, pmt.intern("start_time"), pmt.from_double(1.005)) e_meta = pmt.dict_add(e_meta, pmt.intern("duration"), pmt.from_float(999.995)) e_pdu = pmt.cons(e_meta, pmt.init_c32vector(len(e_data), e_data)) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() #print("test_001:") #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 self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_001_t (self): # set up fg fft_len = 256 cp_len = 32 samp_rate = 32000 data = np.random.choice([-1, 1], [100, fft_len]) timefreq = np.fft.ifft(data, axis=0) #add cp timefreq = np.hstack((timefreq[:, -cp_len:], timefreq)) # msg (only 4th and 5th tuples are needed) id1 = pmt.make_tuple(pmt.intern("Signal"), pmt.from_uint64(0)) name = pmt.make_tuple(pmt.intern("OFDM"), pmt.from_float(1.0)); id2 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(0.0)) id3 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(0.0)) id4 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(256)) id5 = pmt.make_tuple(pmt.intern("xxx"), pmt.from_float(32)) msg = pmt.make_tuple(id1, name, id2, id3, id4, id5) tx = np.reshape(timefreq, (1, -1)) # GR time! src = blocks.vector_source_c(tx[0].tolist(), True, 1, []) freq_offset = analog.sig_source_c(1, analog.GR_SIN_WAVE, 50.0/samp_rate, 1.0, 0.0) mixer = blocks.multiply_cc() sync = inspector.ofdm_synchronizer_cc(4096) dst = blocks.vector_sink_c() dst2 = blocks.vector_sink_c() msg_src = blocks.message_strobe(msg, 0) # connect self.tb.connect(src, (mixer, 0)) self.tb.connect(freq_offset, (mixer, 1)) self.tb.connect(mixer, sync) self.tb.msg_connect((msg_src, 'strobe'), (sync, 'ofdm_in')) self.tb.connect(sync, dst) self.tb.connect(src, dst2) self.tb.start() time.sleep(0.1) self.tb.stop() self.tb.wait() # check data output = dst.data() expect = dst2.data() # block outputs 0j until it has enough OFDM symbols to perform estimations k = (k for k in range(len(output)) if output[k] != 0j).next() # use 10,000 samples for comparison since block fails sometimes # for one work function output = output[k:k+10000] expect = expect[k:k+10000] self.assertComplexTuplesAlmostEqual2(expect, output, abs_eps = 0.001, rel_eps=10)
def onToggleClicked(self, pressed): if pressed: self.state = 1 self.callback(self.pressReleasedDict['Pressed']) else: self.state = 0 self.callback(self.pressReleasedDict['Released']) self.setColor() if pressed: if type(self.pressReleasedDict['Pressed']) == bool: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_bool(self.pressReleasedDict['Pressed']))) elif type(self.pressReleasedDict['Pressed']) == int: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_long(self.pressReleasedDict['Pressed']))) elif type(self.pressReleasedDict['Pressed']) == float: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_float( self.pressReleasedDict['Pressed']))) else: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.intern(self.pressReleasedDict['Pressed']))) else: if type(self.pressReleasedDict['Released']) == bool: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_bool( self.pressReleasedDict['Released']))) elif type(self.pressReleasedDict['Released']) == int: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_long( self.pressReleasedDict['Released']))) elif type(self.pressReleasedDict['Released']) == float: self.message_port_pub( pmt.intern("state"), pmt.cons( pmt.intern(self.outputmsgname), pmt.from_float(self.pressReleasedDict['Released']))) else: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.intern(self.pressReleasedDict['Released'])))
def test_coerce(self): samp_rate = 1e6 freq_offset = -400e3 center_freq = 911e6 # blocks self.emitter = pdu_utils.message_emitter() self.cf = fhss_utils.cf_estimate(fhss_utils.COERCE, [x * 1e6 for x in range(900, 930)]) self.debug = blocks.message_debug() # connections self.tb.msg_connect((self.emitter, 'msg'), (self.cf, 'in')) self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store')) # data in_data = (1 + 0j, ) * 2048 i_vec = pmt.init_c32vector(len(in_data), in_data) out_data = np.exp(1j * np.arange(0, 2 * np.pi * (freq_offset / samp_rate * len(in_data)), 2 * np.pi * (freq_offset / samp_rate), dtype=np.complex64)) e_vec = pmt.init_c32vector(len(out_data), out_data.tolist( )) # pmt doesn't play nice with numpy sometimes, convert to list meta = pmt.make_dict() meta = pmt.dict_add(meta, pmt.intern("sample_rate"), pmt.from_float(samp_rate)) meta = pmt.dict_add(meta, pmt.intern("center_frequency"), pmt.from_float(center_freq + freq_offset)) in_pdu = pmt.cons(meta, i_vec) e_pdu = pmt.cons(meta, e_vec) # flowgraph self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() # parse output #print "got ", list(pmt.to_python(pmt.cdr(self.debug.get_message(0)))) #print "got ", self.debug.get_message(0) rcv = self.debug.get_message(0) rcv_meta = pmt.car(rcv) rcv_data = pmt.cdr(rcv) rcv_cf = pmt.dict_ref(rcv_meta, pmt.intern("center_frequency"), pmt.PMT_NIL) # asserts self.assertComplexTuplesAlmostEqual( tuple(pmt.c32vector_elements(rcv_data)), tuple(out_data), 2) self.assertTrue(pmt.equal(rcv_cf, pmt.from_float(911e6)))
def msg_handler_QOBJ_in(self, msg): print("in msg_handler_QOBJ_in") self.lock() qubit_id_PMT = pmt.dict_ref( msg, pmt.from_float( quantum_qubit_param_type.quantum_qubit_param_type.ID), pmt.PMT_NIL) if (pmt.eq(qubit_id_PMT, pmt.PMT_NIL)): return qubit_id = pmt.to_float(qubit_id_PMT) print("quantum_qubit_param_type.qubit_id=" + str(qubit_id)) if (this._qubit_id != qubit_id): return qubit_angle_PMT = pmt.dict_ref( msg, pmt.from_float( quantum_qubit_param_type.quantum_qubit_param_type.ANGLE), pmt.PMT_NIL) if (pmt.eq(qubit_angle_PMT, pmt.PMT_NIL)): return qubit_angle = pmt.to_float(qubit_angle_PMT) print("quantum_qubit_param_type.qubit_angle=" + str(qubit_angle)) qubit_pole_PMT = pmt.dict_ref( msg, pmt.from_float( quantum_qubit_param_type.quantum_qubit_param_type.POLE), pmt.PMT_NIL) if (pmt.eq(qubit_pole_PMT, pmt.PMT_NIL)): return qubit_pole = pmt.to_float(qubit_pole_PMT) print("quantum_qubit_param_type.qubit_pole=" + str(qubit_pole)) e_ops = [sigmax(), sigmay(), sigmaz()] if (qubit_pole == 1.0): Z = sigmaz() else: Z = -sigmaz() if (qubit_angle == 0.0): Q = Z elif (qubit_angle > 0.0): Q = sigmax() * self.angle_converter(qubit_angle) Q = Q + Z elif (): Q = sigmax() * self.angle_converter(-qubit_angle) Q = Q + (-Z) # self._block_view.clear() self._block_view.add_vectors(expect(Q.unit(), e_ops)) self._block_view.make_sphere() self._block_view.show()
def notifyUpdate(self, new_val): if self.callback is not None: if new_val: self.callback(self.pressReleasedDict['Pressed']) else: self.callback(self.pressReleasedDict['Released']) if new_val: if type(self.pressReleasedDict['Pressed']) == bool: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_bool(self.pressReleasedDict['Pressed']))) elif type(self.pressReleasedDict['Pressed']) == int: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_long(self.pressReleasedDict['Pressed']))) elif type(self.pressReleasedDict['Pressed']) == float: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_float( self.pressReleasedDict['Pressed']))) else: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.intern(self.pressReleasedDict['Pressed']))) else: if type(self.pressReleasedDict['Released']) == bool: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_bool( self.pressReleasedDict['Released']))) elif type(self.pressReleasedDict['Released']) == int: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_long( self.pressReleasedDict['Released']))) elif type(self.pressReleasedDict['Released']) == float: self.message_port_pub( pmt.intern("state"), pmt.cons( pmt.intern(self.outputmsgname), pmt.from_float(self.pressReleasedDict['Released']))) else: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.intern(self.pressReleasedDict['Released'])))
def test_rms(self): self.emitter = pdu_utils.message_emitter() self.cf = fhss_utils.cf_estimate(fhss_utils.RMS, []) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.cf, 'in')) self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store')) # original data in_data = np.exp(1j * np.array(np.linspace(0, 1 * np.pi * .02, 20))) i_vec = pmt.init_c32vector(len(in_data), in_data) out_data = [(1 + 0j), (0.9999966 + 0.0026077442j), (0.9999864 + 0.0052154697j), (0.9999694 + 0.007823161j), (0.99994564 + 0.010430798j), (0.99991506 + 0.013038365j), (0.99987763 + 0.015645843j), (0.99983346 + 0.018253215j), (0.99978244 + 0.020860463j), (0.9997247 + 0.023467569j), (0.99966 + 0.026074518j), (0.99958867 + 0.028681284j), (0.9995105 + 0.03128786j), (0.9994256 + 0.033894222j), (0.99933374 + 0.03650035j), (0.99923515 + 0.03910623j), (0.9991298 + 0.04171185j), (0.99901766 + 0.044317182j), (0.9988987 + 0.046922214j), (0.9987729 + 0.04952693j)] e_vec = pmt.init_c32vector(len(out_data), out_data) meta = pmt.make_dict() meta = pmt.dict_add(meta, pmt.intern("sample_rate"), pmt.from_float(1e6)) meta = pmt.dict_add(meta, pmt.intern("center_frequency"), pmt.from_float(910.6e6)) in_pdu = pmt.cons(meta, i_vec) e_pdu = pmt.cons(meta, e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() # parse output #print("got ", list(pmt.to_python(pmt.cdr(self.debug.get_message(0))))) #print("got ", self.debug.get_message(0)) rcv = self.debug.get_message(0) rcv_meta = pmt.car(rcv) rcv_data = pmt.cdr(rcv) rcv_cf = pmt.to_double( pmt.dict_ref(rcv_meta, pmt.intern("center_frequency"), pmt.PMT_NIL)) # asserts self.assertComplexTuplesAlmostEqual( tuple(pmt.c32vector_elements(rcv_data)), tuple(out_data), 2) self.assertTrue(abs(rcv_cf - 910.6001e6) < 100)
def test_coerce(self): self.emitter = pdu_utils.message_emitter() self.cf = fhss_utils.cf_estimate(fhss_utils.COERCE, [x * 1e6 for x in range(900, 930)]) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.cf, 'in')) self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store')) # original data in_data = np.exp(1j * np.array(np.linspace(0, 10 * np.pi * 2, 20))) i_vec = pmt.init_c32vector(len(in_data), in_data) out_data = [(1 + 0j), (-0.9863691 - 0.16454819j), (0.9458478 + 0.32461047j), (-0.8795409 - 0.47582325j), (0.7892561 + 0.61406416j), (-0.67745465 - 0.7355646j), (0.54718447 + 0.8370121j), (-0.40199703 - 0.915641j), (0.24585037 + 0.9693079j), (-0.083001345 - 0.9965495j), (-0.08211045 + 0.99662334j), (0.24498378 - 0.96952736j), (-0.4011784 + 0.9160001j), (0.5464361 - 0.83750105j), (-0.6767969 + 0.73617005j), (0.78870696 - 0.6147696j), (-0.87911534 + 0.47660938j), (0.94555736 - 0.3254559j), (-0.9862217 + 0.16542989j), (0.9999997 - 0.00089395075j)] e_vec = pmt.init_c32vector(len(out_data), out_data) meta = pmt.make_dict() meta = pmt.dict_add(meta, pmt.intern("sample_rate"), pmt.from_float(1e3)) meta = pmt.dict_add(meta, pmt.intern("center_frequency"), pmt.from_float(910.6e6)) in_pdu = pmt.cons(meta, i_vec) e_pdu = pmt.cons(meta, e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() # parse output #print "got ", list(pmt.to_python(pmt.cdr(self.debug.get_message(0)))) #print "got ", self.debug.get_message(0) rcv = self.debug.get_message(0) rcv_meta = pmt.car(rcv) rcv_data = pmt.cdr(rcv) rcv_cf = pmt.dict_ref(rcv_meta, pmt.intern("center_frequency"), pmt.PMT_NIL) # asserts self.assertComplexTuplesAlmostEqual( tuple(pmt.c32vector_elements(rcv_data)), tuple(out_data), 2) self.assertTrue(pmt.equal(rcv_cf, pmt.from_float(911e6)))
def test_half_power(self): self.emitter = pdu_utils.message_emitter() self.cf = fhss_utils.cf_estimate(fhss_utils.HALF_POWER, []) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.cf, 'in')) self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store')) # original data in_data = np.exp(1j * np.array(np.linspace(0, 1 * np.pi * .02, 20))) i_vec = pmt.init_c32vector(len(in_data), in_data) out_data = [(1 + 0j), (0.9999945 + 0.0033069337j), (0.9999781 + 0.006613831j), (0.99995077 + 0.009920656j), (0.9999125 + 0.013227372j), (0.9998633 + 0.016533945j), (0.9998032 + 0.019840335j), (0.9997321 + 0.02314651j), (0.99965006 + 0.026452431j), (0.99955714 + 0.029758062j), (0.99945325 + 0.03306337j), (0.99933845 + 0.036368314j), (0.99921274 + 0.039672863j), (0.99907607 + 0.042976975j), (0.9989285 + 0.04628062j), (0.99877 + 0.049583755j), (0.99860054 + 0.05288635j), (0.9984202 + 0.056188367j), (0.9982289 + 0.059489768j), (0.9980267 + 0.06279052j)] e_vec = pmt.init_c32vector(len(out_data), out_data) meta = pmt.make_dict() meta = pmt.dict_add(meta, pmt.intern("sample_rate"), pmt.from_float(1e6)) meta = pmt.dict_add(meta, pmt.intern("center_frequency"), pmt.from_float(910.6e6)) in_pdu = pmt.cons(meta, i_vec) e_pdu = pmt.cons(meta, e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() # parse output #print "got ", list(pmt.to_python(pmt.cdr(self.debug.get_message(0)))) #print "got ", self.debug.get_message(0) rcv = self.debug.get_message(0) rcv_meta = pmt.car(rcv) rcv_data = pmt.cdr(rcv) rcv_cf = pmt.to_double( pmt.dict_ref(rcv_meta, pmt.intern("center_frequency"), pmt.PMT_NIL)) # asserts self.assertComplexTuplesAlmostEqual( tuple(pmt.c32vector_elements(rcv_data)), tuple(out_data), 2) self.assertTrue(abs(rcv_cf - 910.6e6) < 100)
def test_middle_out_metadata(self): samp_rate = 1e6 rot_offset = 1.0 / 16.0 self.emitter = pdu_utils.message_emitter() self.cf = fhss_utils.cf_estimate(fhss_utils.MIDDLE_OUT, []) self.sm = self.simple_modulator() self.rt = self.pdu_rotate(rot_offset) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.sm, 'in')) #self.tb.msg_connect((self.cf, 'debug'), (self.debug, 'print')) self.tb.msg_connect((self.sm, 'out'), (self.rt, 'in')) self.tb.msg_connect((self.rt, 'out'), (self.cf, 'in')) self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store')) # original data in_data = [0xAA] * 10 + [0x69] * 10 + [ 0x55 ] * 10 # 30 bytes = 240 bits = 1920 samples i_vec = pmt.init_u8vector(len(in_data), in_data) fc = 100e6 meta = pmt.make_dict() meta = pmt.dict_add(meta, pmt.intern("sample_rate"), pmt.from_float(1e6)) meta = pmt.dict_add(meta, pmt.intern("center_frequency"), pmt.from_float(fc)) meta = pmt.dict_add(meta, pmt.intern("noise_density"), pmt.from_float(-105.0)) in_pdu = pmt.cons(meta, i_vec) self.tb.start() time.sleep(.1) self.emitter.emit(in_pdu) time.sleep(.1) self.tb.stop() self.tb.wait() # parse output rcv = self.debug.get_message(0) rcv_meta = pmt.car(rcv) rcv_data = pmt.cdr(rcv) # asserts rcv_cf = pmt.to_double( pmt.dict_ref(rcv_meta, pmt.intern("center_frequency"), pmt.PMT_NIL)) expected_cf = 100e6 + samp_rate * rot_offset # we rotated the burst 62500 Hz off max_diff = samp_rate / 256 / 2 # half an FFT bin error allowed #print("M-O: got ", rcv_cf - fc, " expected ", expected_cf-fc, "(diff ", rcv_cf-expected_cf, ")") self.assertTrue(abs(rcv_cf - expected_cf) < max_diff)
def onToggleClicked(self, checked): if self.chkBox.isChecked(): self.callback(self.pressReleasedDict['Pressed']) if type(self.pressReleasedDict['Pressed']) == bool: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_bool(self.pressReleasedDict['Pressed']))) elif type(self.pressReleasedDict['Pressed']) == int: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_long(self.pressReleasedDict['Pressed']))) elif type(self.pressReleasedDict['Pressed']) == float: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_float( self.pressReleasedDict['Pressed']))) else: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.intern(self.pressReleasedDict['Pressed']))) else: self.callback(self.pressReleasedDict['Released']) if type(self.pressReleasedDict['Released']) == bool: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_bool( self.pressReleasedDict['Released']))) elif type(self.pressReleasedDict['Released']) == int: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_long( self.pressReleasedDict['Released']))) elif type(self.pressReleasedDict['Released']) == float: self.message_port_pub( pmt.intern("state"), pmt.cons( pmt.intern(self.outputmsgname), pmt.from_float(self.pressReleasedDict['Released']))) else: self.message_port_pub( pmt.intern("state"), pmt.cons(pmt.intern(self.outputmsgname), pmt.intern(self.pressReleasedDict['Released'])))
def msg_handler_analyzed_data_in(self, msg): print("in msg_handler_analyzed_data_in") self.lock() gate_params = pmt.vector_ref(msg, 0) gate_type_PMT = pmt.dict_ref( gate_params, pmt.from_float( quantum_gate_param_type.quantum_gate_param_type.GATE_TYPE), pmt.PMT_NIL) if (pmt.eq(gate_type_PMT, pmt.PMT_NIL)): return gate_type = pmt.to_float(gate_type_PMT) print("gate_params.gate_type=" + str(gate_type)) qubit_id_PMT = pmt.dict_ref( gate_params, pmt.from_float( quantum_gate_param_type.quantum_gate_param_type.QUBIT_ID), pmt.PMT_NIL) if (pmt.eq(qubit_id_PMT, pmt.PMT_NIL)): return qubit_id = pmt.to_float(qubit_id_PMT) print("gate_params.qubit_id=" + str(qubit_id)) if (gate_type == quantum_gate_type.quantum_gate_type.X): print("in msg_handler_analyzed_data_in X gate") #回路を作る RO_STATE = self._qubit_stat_map[qubit_id] if (float(RO_STATE.angle) == 0.0): RO_STATE.angle = 180.0 else: RO_STATE.angle = 0.0 self._qubit_stat_map[qubit_id] = RO_STATE elif (gate_type == quantum_gate_type.quantum_gate_type.RO): print("in msg_handler_analyzed_data_in RO") #回路を実行する RO_STATE = self._qubit_stat_map[qubit_id] SIM_msg = pmt.make_dict() SIM_msg = pmt.dict_add( SIM_msg, pmt.from_float( quantum_qubit_param_type.quantum_qubit_param_type.ID), pmt.from_float(qubit_id)) SIM_msg = pmt.dict_add( SIM_msg, pmt.from_float( quantum_qubit_param_type.quantum_qubit_param_type.ANGLE), pmt.from_float(float(RO_STATE.angle))) SIM_msg = pmt.dict_add( SIM_msg, pmt.from_float( quantum_qubit_param_type.quantum_qubit_param_type.STATE), pmt.from_float(quantum_qubit_RO_state_type. quantum_qubit_RO_state_type.START)) self.message_port_pub(pmt.intern('simulated_data'), SIM_msg) RO_STATE.state = quantum_qubit_RO_state_type.quantum_qubit_RO_state_type.START self._qubit_stat_map[qubit_id] = RO_STATE self.unlock()
def test_half_power_metadata(self): samp_rate = 1e6 rot_offset = 1.0 / 16.0 self.emitter = pdu_utils.message_emitter() self.cf = fhss_utils.cf_estimate(fhss_utils.HALF_POWER, []) self.sm = self.simple_modulator() self.rt = self.pdu_rotate(rot_offset) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.sm, 'in')) self.tb.msg_connect((self.sm, 'out'), (self.rt, 'in')) self.tb.msg_connect((self.rt, 'out'), (self.cf, 'in')) self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store')) # original data in_data = [0xAA] * 10 + [0x69] * 10 + [ 0x55 ] * 10 # 30 bytes = 240 bits = 1920 samples i_vec = pmt.init_u8vector(len(in_data), in_data) meta = pmt.make_dict() meta = pmt.dict_add(meta, pmt.intern("sample_rate"), pmt.from_float(1e6)) meta = pmt.dict_add(meta, pmt.intern("center_frequency"), pmt.from_float(100.0e6)) in_pdu = pmt.cons(meta, i_vec) self.tb.start() time.sleep(.1) self.emitter.emit(in_pdu) time.sleep(.1) self.tb.stop() self.tb.wait() # parse output #print("got ", list(pmt.to_python(pmt.cdr(self.debug.get_message(0))))) #print("got ", pmt.car(self.debug.get_message(0))) rcv = self.debug.get_message(0) rcv_meta = pmt.car(rcv) rcv_data = pmt.cdr(rcv) # asserts rcv_cf = pmt.to_double( pmt.dict_ref(rcv_meta, pmt.intern("center_frequency"), pmt.PMT_NIL)) expected_cf = 100e6 + samp_rate * rot_offset # we rotated the burst 62500 Hz off self.assertTrue( abs(rcv_cf - expected_cf) < 1.0) # less than 1 Hz off (no noise)
def click_callback(self, new_value): self.call_var_callback(new_value) self.message_port_pub( pmt.intern("valueout"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_float(float(new_value))))
def test_001_t (self): # set up message msg1 = pmt.list3(pmt.string_to_symbol('id'),pmt.string_to_symbol('int'),pmt.from_long(42)) msg2 = pmt.list3(pmt.string_to_symbol('value'),pmt.string_to_symbol('float'),pmt.from_float(3.1416)) #msg3 = pmt.list3(pmt.string_to_symbol('text'),pmt.string_to_symbol('string'),pmt.string_to_symbol('some text')) msg = pmt.list2(msg1,msg2) # set up sql connection host = '127.0.0.1' port = 0 # default user = '******' password = '******' database = 'my_db' table = 'my_table' # set up flowgraph if 0: # Enable and disable here msg_src = blocks.message_strobe(msg,100) sql_connector = sql.msg_to_table(user,password,database,table,host,port) self.tb.msg_connect(msg_src,'strobe',sql_connector,'Msg in') # run flowgraph self.tb.start() sleep(0.2) self.tb.stop() self.tb.wait()
def setValue(self, new_val): self.setFrequency(new_val) self.message_port_pub( pmt.intern("valueout"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_float(float(self.getFrequency()))))
def test_002_float (self): self.emd.set_key(pmt.intern("float")) self.emd.set_scale(0.5) self.emd.set_offset(900) in_msg = pmt.dict_add(self.base_dict, pmt.intern("float"), pmt.from_float(-493.5)) expected_msg = pmt.cons(pmt.intern("float"), pmt.from_float(-493.5/2 + 900)) self.tb.start() time.sleep(.001) self.emitter.emit(in_msg) time.sleep(.01) self.tb.stop() self.tb.wait() self.assertTrue(pmt.equal(self.debug.get_message(0), expected_msg))
def test_001_t(self): # set up message msg1 = pmt.list3(pmt.string_to_symbol('id'), pmt.string_to_symbol('int'), pmt.from_long(42)) msg2 = pmt.list3(pmt.string_to_symbol('value'), pmt.string_to_symbol('float'), pmt.from_float(3.1416)) #msg3 = pmt.list3(pmt.string_to_symbol('text'),pmt.string_to_symbol('string'),pmt.string_to_symbol('some text')) msg = pmt.list2(msg1, msg2) # set up sql connection host = '127.0.0.1' port = 0 # default user = '******' password = '******' database = 'my_db' table = 'my_table' # set up flowgraph if 0: # Enable and disable here msg_src = blocks.message_strobe(msg, 100) sql_connector = sql.msg_to_table(user, password, database, table, host, port) self.tb.msg_connect(msg_src, 'strobe', sql_connector, 'Msg in') # run flowgraph self.tb.start() sleep(0.2) self.tb.stop() self.tb.wait()
def clickCallback(self, newValue): # print("click callback called") self.callVarCallback(newValue) self.message_port_pub( pmt.intern("valueout"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_float(float(newValue))))
def event_handler(self, msg): """ Receive the Peak, RMS and MJD on the input stream """ print 'Event Message received: ' # Grab packet PDU data self.eventmjd = pmt.from_float(msg) print 'MJD: %15.6f ' % (self.eventmjd) return
def test_001_all_header_fields(self): with open('/tmp/file.csv', 'w') as f: # write header f.write('field0(string), , field1(bool), field2(float),' + 'field3(long), field4(uint64), field5(double),' + 'field6(complex),field7,field8(time),field9(time_tuple)\n') # add some data f.write( 'field0, empty, True, 1.0,1234567890,987654321, 2.5,1+2j,string,1.0,1.0,1,2,3,4,5\n' ) # start reader/ reader = csv_reader(fname='/tmp/file.csv', has_header=True, period=10, start_delay=0, repeat=False) # expected pdu metadata = pmt.dict_add(pmt.make_dict(), pmt.intern('field0'), pmt.intern('field0')) metadata = pmt.dict_add(metadata, pmt.intern('field1'), pmt.from_bool(True)) metadata = pmt.dict_add(metadata, pmt.intern('field2'), pmt.from_float(1.0)) metadata = pmt.dict_add(metadata, pmt.intern('field3'), pmt.from_long(1234567890)) metadata = pmt.dict_add(metadata, pmt.intern('field4'), pmt.from_uint64(987654321)) metadata = pmt.dict_add(metadata, pmt.intern('field5'), pmt.from_double(2.5)) metadata = pmt.dict_add(metadata, pmt.intern('field6'), pmt.from_complex(1.0 + 2j)) metadata = pmt.dict_add(metadata, pmt.intern('field7'), pmt.intern('string')) metadata = pmt.dict_add( metadata, pmt.intern('field8'), pmt.cons(pmt.from_uint64(1), pmt.from_double(0))) metadata = pmt.dict_add( metadata, pmt.intern('field9'), pmt.make_tuple(pmt.from_uint64(1), pmt.from_double(0))) data = pmt.init_u8vector(5, [1, 2, 3, 4, 5]) expected = pmt.cons(metadata, data) # run self.tb.msg_connect((reader, 'out'), (self.debug, 'store')) self.tb.start() time.sleep(.5) self.tb.stop() self.tb.wait() got = self.debug.get_message(0) self.assertTrue(pmt.equal(expected, got))
def test_input_sanitization(self): samp_rate = 1e6 freq_offset = -400e3 center_freq = 911e6 # blocks self.emitter = pdu_utils.message_emitter() self.cf = fhss_utils.cf_estimate(fhss_utils.COERCE, [x * 1e6 for x in range(900, 930)]) self.debug = blocks.message_debug() # connections self.tb.msg_connect((self.emitter, 'msg'), (self.cf, 'in')) self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store')) # data in_data = (1 + 0j, ) * 2048 i_vec = pmt.init_c32vector(len(in_data), in_data) meta = pmt.make_dict() meta = pmt.dict_add(meta, pmt.intern("sample_rate"), pmt.from_float(samp_rate)) meta = pmt.dict_add(meta, pmt.intern("center_freq"), pmt.from_float(center_freq + freq_offset)) in_pdu = pmt.cons(meta, i_vec) # flowgraph self.tb.start() time.sleep(.001) self.emitter.emit(pmt.PMT_T) time.sleep(.01) self.emitter.emit(pmt.cons(pmt.PMT_T, pmt.PMT_NIL)) time.sleep(.01) self.emitter.emit(meta) time.sleep(.01) self.emitter.emit(i_vec) time.sleep(.01) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() self.assertEqual(0, self.debug.num_messages())
def work(self, input_items, output_items): in0 = input_items[0] #out = output_items[0] for idx in range(in0.shape[0]): self.nsamplesread += len(in0[idx, :]) # continue#return len(input_items[0]) self.imgnp[self.count, :] += in0[idx, :] self.countavg += 1 if self.countavg == self.avgsize: self.countavg = 0 self.count += 1 if self.count == self.nrows: self.count = 0 self.dropcount += 1 if self.dropcount >= self.n_drops: self.dropcount = 0 Sxx = spectrogram.normalize_spectrogram( self.imgnp) #/self.avgsize) if self.cancel_DCoffset: pwr_min = np.min(Sxx) Sxx[:, Sxx.shape[1] / 2] = pwr_min self.imgcv[:, 0:self.vlen, 0] = np.uint8(Sxx * 255) self.imgcv[:, :, 1] = self.imgcv[:, :, 0] self.imgcv[:, :, 2] = self.imgcv[:, :, 0] detected_boxes = self.classifier.classify(self.imgcv) self.last_result = detected_boxes for box in detected_boxes: d = pmt.make_dict() d = pmt.dict_add(d, pmt.intern('tstamp'), pmt.from_long(self.img_tstamp)) for k, v in box.items(): if k == 'topleft' or k == 'bottomright': pmt_val = pmt.make_dict() pmt_val = pmt.dict_add(pmt_val, pmt.intern('x'), pmt.from_long(v['x'])) pmt_val = pmt.dict_add(pmt_val, pmt.intern('y'), pmt.from_long(v['y'])) elif k == 'confidence': pmt_val = pmt.from_float(float(v)) elif k == 'label': pmt_val = pmt.string_to_symbol(v) else: raise NotImplementedError( 'Did not expect parameter {}'.format(k)) d = pmt.dict_add(d, pmt.intern(k), pmt_val) # print 'gonna send:',pmt.write_string(d) self.message_port_pub(pmt.intern('msg_out'), d) # self.message_port_pub(pmt.intern('boxes'), pmt.intern(detected_boxes)) self.imgnp[:] = 0 self.img_tstamp += int(self.vlen * self.nrows) return len(input_items[0])
def handler(self, pdu): data = pmt.to_python(pmt.cdr(pdu)) meta = pmt.car(pdu) data = data - numpy.mean(data) # remove DC mag_sq = numpy.mean(numpy.real(data*numpy.conj(data))) #compute average Mag Sq p = self.k + 10*numpy.log10(mag_sq) # print "Power: %f"%(p) meta = pmt.dict_add(meta, pmt.intern("power"), pmt.from_float( p ) ) # done pass vector element for now ... self.message_port_pub( pmt.intern("cpdus"), pmt.cons( meta, pmt.PMT_NIL ) );
def send_frame(self, timestamp, center_frequency, confidence): msg_meta = pmt.dict_add(pmt.make_dict(), pmt.intern('timestamp'), pmt.from_uint64(timestamp)) msg_meta = pmt.dict_add(msg_meta, pmt.intern('center_frequency'), pmt.from_float(center_frequency)) msg_meta = pmt.dict_add(msg_meta, pmt.intern('confidence'), pmt.from_long(confidence)) msg = pmt.cons(msg_meta, pmt.init_u8vector(2, range(2))) if timestamp > self.max_timestamp: self.max_timestamp = timestamp self.sorter.to_basic_block()._post(pmt.intern("pdus"), msg)
def verify_scalar_snr(self, constellation_order, nbits): constellation, bits_rep = generate_gray_constellation( constellation_order) data = np.random.randint(0, 2, constellation_order * nbits).astype(np.uint8) symbols = map_to_constellation(data, constellation) snr = 5.0 snr_step = .5 tags = [] offsets = (0, 50, 400, 450, 800) last_offset = 0 ref = np.array([], dtype=np.float32) for offset in offsets: t = gr.tag_utils.python_to_tag( (offset, pmt.string_to_symbol("snr"), pmt.from_float(snr))) tags.append(t) syms = symbols[last_offset:offset] # print(syms.size) ref_ln_probs = calculate_symbol_log_probabilities( syms, constellation, snr - snr_step) refs = calculate_llrs(ref_ln_probs) ref = np.concatenate((ref, refs)) last_offset = offset snr += snr_step syms = symbols[last_offset:] ref_ln_probs = calculate_symbol_log_probabilities( syms, constellation, snr - snr_step) refs = calculate_llrs(ref_ln_probs) ref = np.concatenate((ref, refs)) ref *= .5 # print(f'test: Order={constellation_order}, bits={nbits}/{data.size}, packed={is_packed}') mapper = symbolmapping.symbol_demapper_cf(constellation_order, "GRAY", "snr") src = blocks.vector_source_c(symbols, False, 1, tags) snk = blocks.vector_sink_f() self.tb.connect(src, mapper, snk) self.tb.run() res = np.array(snk.data()) if constellation_order > 3: self.assertFloatTuplesAlmostEqual(tuple(np.sign(res)), tuple(np.sign(ref))) else: # for i in range(ref.size - 10): # if not np.abs(ref[i + 10] - res[i + 10]) < 1e-5: # print(i, ref[i], res[i], np.abs(ref[i] - res[i]) < 1e-5) self.assertFloatTuplesAlmostEqual(tuple(res), tuple(ref), 5)
def handler(self, pdu): data = pmt.to_python(pmt.cdr(pdu)) meta = pmt.car(pdu) data = data - numpy.mean(data) # remove DC mag_sq = numpy.mean(numpy.real( data * numpy.conj(data))) #compute average Mag Sq p = self.k + 10 * numpy.log10(mag_sq) # print "Power: %f"%(p) meta = pmt.dict_add(meta, pmt.intern("power"), pmt.from_float(p)) # done pass vector element for now ... self.message_port_pub(pmt.intern("cpdus"), pmt.cons(meta, pmt.PMT_NIL))
def variable_changed(self, value): if type(value) == float: p = pmt.from_float(value) elif type(value) == int: p = pmt.from_long(value) elif type(value) == bool: p = pmt.from_bool(value) else: p = pmt.intern(value) self.message_port_pub(pmt.intern("msgout"), pmt.cons(pmt.intern(self.pairname), p))
def valueChanged(self, new_value): if int(self.scaleFactor) != 1: new_value = new_value * self.scaleFactor if self.varCallback is not None: self.varCallback(new_value) if self.isFloat: self.message_port_pub(pmt.intern("value"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_float(new_value))) else: self.message_port_pub(pmt.intern("value"), pmt.cons(pmt.intern(self.outputmsgname), pmt.from_long(new_value)))
def newValue(self, curValue, curIndex): p_val = pmt.from_float(curValue) p_index = pmt.from_long(curIndex) if curValue != self.lastValue: try: self.varCallback(curValue) except: pass self.message_port_pub(pmt.intern("value"), pmt.cons(pmt.intern("value"), p_val)) self.lastValue = curValue self.message_port_pub(pmt.intern("index"), pmt.cons(pmt.intern("index"), p_index))
def event_msg(self): """ Put the Peak, RMS and MJD on the output vector as tags """ # print 'Preparing to send event message' #Send event message to sink if 0: self.message_port_pub(pmt.intern('out_port'), pmt.from_float(self.eventmjd)) print 'Event message sent:', self.eventmjd else: self.add_item_tag(0, # Port number self.nitems_written(0) + 1, # offset pmt.to_pmt('event'), # Key pmt.to_pmt(('MJD', self.eventmjd))),# Value print 'Event tagged: ', self.eventmjd return
def work(self, input_items, output_items): out = output_items[0] out[:] = [random.randrange(0, 16) for i in range(len(out))] self.add_item_tag(0, self.nitems_written(0), pmt.intern("timestamp"), pmt.from_float(time.time())) self.add_item_tag(0, self.nitems_written(0), pmt.intern("packet_len"), pmt.integer(96)) return len(output_items[0])
def work(self, input_items, output_items): #print "Block work function called: ", len(output_items[0]) out = output_items[0] #print "Need to generate ", len(out), " items" i=0 while i<len(out): line = self.f.readline() line.rstrip() #print "Read the following line: ", line ss = re.split(" ", line) out[i] = i #print "Starting loop iteration ",i,"/",len(out) if(ss[0]=="stream"): real = ss[1] imag = ss[2].replace('\n', '') #print "complex number(",real,",",imag,")" #out[i] = complex(float(real), float(imag)) out[i] = numpy.complex(float(real), float(imag)) out[i] = numpy.complex64(out[i]) #print out[i] #out[i] = numpy.complex64(float(real) + float(imag)*j) #print "generated item ", i, " of ", len(out) i=i+1 elif(ss[0] == "tag"): #offset,source,key,value1,value2 = ss[1:] offset = ss[1] source = ss[2] key = ss[3] value1 = ss[4] #print "tag information: ",offset, source, key, value #we have a tuple here (this is specific to the toolbox #it looks like this now #ss[4]: {0 #ss[5]: 0.131072} if(value1[0] == '{'): value2 = ss[5] value1 = long(value1[1:]) value2 = float(value2[:-2]) #print "ss[4]: ", ss[4] #print "ss[5]: ", ss[5] #print "value1: ", value1 #print "value2: ", value2 _value = pmt.make_tuple( pmt.from_long(value1), pmt.from_float(value2) ) else: value1 = value1[:-1] counter=0 #for i in value1: #print counter, ": ", i #counter=counter+1 #print "value1: ", value1 value1 = long(value1) #print "value1: ", value1 _value = pmt.from_long(value1) #add tag to stream self.add_item_tag(0, # output int(offset), # offset pmt.string_to_symbol(key), # key _value, # value pmt.string_to_symbol(source) # source ) #break ##out[:] = 1+2j #print "returning a length of ",len(output_items[0]) return len(output_items[0])