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])
