def test_001_t (self):
src = analog.sig_source_c(32000, analog.GR_COS_WAVE,
12500, 1)
detector = inspector.signal_detector_cvf(32000, 1024,
firdes.WIN_BLACKMAN_hARRIS, -80, 0.6, False, 0.5, 0.0001)
dst1 = blocks.null_sink(gr.sizeof_float*1024)
dst2 = blocks.null_sink(gr.sizeof_float*1024)
msg_dst = blocks.message_debug()
self.tb.connect(src, detector)
self.tb.connect((detector, 0), dst1)
self.tb.connect((detector, 1), dst2)
self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store'))
self.tb.start()
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
msg = msg_dst.get_message(1)
res_vector = numpy.empty([0, 2])
for i in range(pmt.length(msg)):
row = pmt.vector_ref(msg, i)
res_vector = numpy.vstack((res_vector, numpy.array(
[pmt.f32vector_ref(row, 0), pmt.f32vector_ref(row, 1)]
)))
self.assertAlmostEqual(12500.0, res_vector[0][0], delta=100)
self.assertAlmostEqual(0.0, res_vector[0][1], delta=200)
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_000(self):
num_msgs = 10
msg_interval = 1000
msg_list = []
for i in range(num_msgs):
msg_list.append(pmt.from_long(i))
# Create vector source with dummy data to trigger messages
src_data = []
for i in range(num_msgs * msg_interval):
src_data.append(float(i))
src = blocks.vector_source_f(src_data, False)
msg_gen = message_generator(msg_list, msg_interval)
msg_cons = message_consumer()
# Connect vector source to message gen
self.tb.connect(src, msg_gen)
# Connect message generator to message consumer
self.tb.msg_connect(msg_gen, 'out_port', msg_cons, 'in_port')
# Verify that the messgae port query functions work
self.assertEqual(
pmt.symbol_to_string(pmt.vector_ref(msg_gen.message_ports_out(),
0)), 'out_port')
self.assertEqual(
pmt.symbol_to_string(pmt.vector_ref(msg_cons.message_ports_in(),
0)), 'in_port')
# Run to verify message passing
self.tb.start()
# Wait for all messages to be sent
while msg_gen.msg_ctr < num_msgs:
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
# Verify that the message consumer got all the messages
self.assertEqual(num_msgs, len(msg_cons.msg_list))
for i in range(num_msgs):
self.assertTrue(pmt.equal(msg_list[i], msg_cons.msg_list[i]))
def test_000(self):
num_msgs = 10
msg_interval = 1000
msg_list = []
for i in range(num_msgs):
msg_list.append(pmt.from_long(i))
# Create vector source with dummy data to trigger messages
src_data = []
for i in range(num_msgs*msg_interval):
src_data.append(float(i))
src = blocks.vector_source_f(src_data, False)
msg_gen = message_generator(msg_list, msg_interval)
msg_cons = message_consumer()
# Connect vector source to message gen
self.tb.connect(src, msg_gen)
# Connect message generator to message consumer
self.tb.msg_connect(msg_gen, 'out_port', msg_cons, 'in_port')
# Verify that the messgae port query functions work
self.assertEqual(pmt.symbol_to_string(pmt.vector_ref(
msg_gen.message_ports_out(), 0)), 'out_port')
self.assertEqual(pmt.symbol_to_string(pmt.vector_ref(
msg_cons.message_ports_in(), 0)), 'in_port')
# Run to verify message passing
self.tb.start()
# Wait for all messages to be sent
while msg_gen.msg_ctr < num_msgs:
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
# Verify that the message consumer got all the messages
self.assertEqual(num_msgs, len(msg_cons.msg_list))
for i in range(num_msgs):
self.assertTrue(pmt.equal(msg_list[i], msg_cons.msg_list[i]))
def occ_handler_method(self, msg):
occvec = []
for i in range(0, self.num_split):
occvec.append(pmt.to_double(pmt.vector_ref(msg, i)))
pmt_to_send = pmt.make_dict()
curtime = strftime("%Y-%m-%d %H:%M:%S", gmtime())
attributes = pmt.make_dict()
attributes = pmt.dict_add(attributes,
pmt.string_to_symbol("center_freq"),
pmt.from_double(self.center_freq))
attributes = pmt.dict_add(attributes, pmt.string_to_symbol("occ"),
pmt.init_f32vector(self.num_split, occvec))
attributes = pmt.dict_add(attributes,
pmt.string_to_symbol("bandwidth"),
pmt.from_double(self.bw))
attributes = pmt.dict_add(attributes, pmt.string_to_symbol("timetag"),
pmt.intern(curtime))
attributes = pmt.dict_add(
attributes, pmt.string_to_symbol("noise_floor"),
pmt.init_f32vector(self.num_split, self.noise_floor))
attributes = pmt.dict_add(attributes, pmt.string_to_symbol("nodeid"),
pmt.from_long(self.nodeid))
attributes = pmt.dict_add(attributes, pmt.string_to_symbol("latitude"),
pmt.from_double(self.latitude))
attributes = pmt.dict_add(attributes,
pmt.string_to_symbol("longitude"),
pmt.from_double(self.longitude))
command = pmt.make_dict()
command = pmt.dict_add(command, pmt.string_to_symbol("table"),
pmt.string_to_symbol("spectruminfo"))
command = pmt.dict_add(command, pmt.string_to_symbol("attributes"),
attributes)
pmt_to_send = pmt.dict_add(pmt_to_send, pmt.string_to_symbol("INSERT"),
command)
serialized_pmt = pmt.serialize_str(pmt_to_send)
#print pmt_to_send
UDP_IP = self.host
UDP_PORT = self.port
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(serialized_pmt, (UDP_IP, UDP_PORT))
def test_001_t(self):
src1 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 12500, 3)
src2 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 9800, 3)
add = blocks.add_cc()
detector = inspector.signal_detector_cvf(32000, 4096,
firdes.WIN_BLACKMAN_hARRIS,
-80, 0.6, False, 0.5, 0.001)
dst1 = blocks.null_sink(gr.sizeof_float * 4096)
msg_dst = blocks.message_debug()
# connections
self.tb.connect(src1, (add, 0))
self.tb.connect(src2, (add, 1))
self.tb.connect(add, detector)
self.tb.connect((detector, 0), dst1)
self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store'))
self.tb.start()
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
# take most recent message
msg = msg_dst.get_message(msg_dst.num_messages() - 1)
res_vector = numpy.empty([0, 2])
for i in range(pmt.length(msg)):
row = pmt.vector_ref(msg, i)
res_vector = numpy.vstack(
(res_vector,
numpy.array(
[pmt.f32vector_ref(row, 0),
pmt.f32vector_ref(row, 1)])))
self.assertAlmostEqual(9800.0, res_vector[0][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[0][1], delta=100)
self.assertAlmostEqual(12500.0, res_vector[1][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[1][1], delta=100)
def test_001_t (self):
src1 = analog.sig_source_c(32000, analog.GR_COS_WAVE,
12500, 3)
src2 = analog.sig_source_c(32000, analog.GR_COS_WAVE,
9800, 3)
add = blocks.add_cc()
detector = inspector.signal_detector_cvf(32000, 4096,
firdes.WIN_BLACKMAN_hARRIS, -80, 0.6, False, 0.5, 0.001)
dst1 = blocks.null_sink(gr.sizeof_float*4096)
msg_dst = blocks.message_debug()
#connections
self.tb.connect(src1, (add, 0))
self.tb.connect(src2, (add, 1))
self.tb.connect(add, detector)
self.tb.connect((detector, 0), dst1)
self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store'))
self.tb.start()
time.sleep(0.5)
self.tb.stop()
self.tb.wait()
#take most recent message
msg = msg_dst.get_message(msg_dst.num_messages()-1)
res_vector = numpy.empty([0, 2])
for i in range(pmt.length(msg)):
row = pmt.vector_ref(msg, i)
res_vector = numpy.vstack((res_vector, numpy.array(
[pmt.f32vector_ref(row, 0), pmt.f32vector_ref(row, 1)]
)))
self.assertAlmostEqual(9800.0, res_vector[0][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[0][1], delta=100)
self.assertAlmostEqual(12500.0, res_vector[1][0], delta=50)
self.assertAlmostEqual(0.0, res_vector[1][1], delta=100)
def __init__(self, buf, len, debug, d_mac_id, d_seq_nr, no_self_loop):
self.debug = debug
self.buf = buf
self.len = len
self.d_seq_nr = d_seq_nr
self.d_mac_id = d_mac_id
self.no_self_loop = no_self_loop
if self.no_self_loop:
#Insert an id here to check for self routing. This makes the packet non standard.
d_msg.insert(0, self.d_mac_id)
d_msg.insert(1, 11 + self.len + 2)
#FCF
d_msg.insert(2,0x41)
d_msg.insert(3,0x88)
#seq nr
d_msg.insert(4,++self.d_seq_nr)
#addr info
d_msg.insert(5,0xcd)
d_msg.insert(6,0xab)
d_msg.insert(7,0xff)
d_msg.insert(8,0xff)
d_msg.insert(9,0x40)
d_msg.insert(10,0xe8)
#Copy the data here.
if (pmt.is_vector(buf)):
for i in range(pmt.length(buf)):
d_msg.insert(10+i,pmt.to_long(pmt.vector_ref(buf,i)))
elif (pmt.is_uniform_vector(buf)):
d_msg.extend(pmt.u8vector_elements(buf))
else:
bufString = pmt.symbol_to_string(buf)
#print "pmt.symbol_to_string(buf): ", bufString
#print "pmt.length(buf): ", pmt.length(buf)
bytes = map(ord,bufString)
#print "map(ord,buf): ", bytes
d_msg.extend(bytes)
#Compute the CRC over the whole packet (excluding the CRC bytes themselves)
crc = crc16(d_msg, self.len + 11)
#if self.debug: print "#### CRC at Transmission: #### ", crc.get_crc()
#CRC goes on the end.
d_msg.insert(11+ self.len, crc.get_crc() & 0xFF)
d_msg.insert(12+ self.len, crc.get_crc() >> 8)
d_msg_len = 11 + self.len + 2
print
print
if self.debug: print "d_msg: ", d_msg
print
print
else:
#Preamble length + CRC length ( CRC at the end)
d_msg.insert(0, 10 + self.len + 2)
#FCF
d_msg.insert(1,0x41)
d_msg.insert(2,0x88)
#seq nr
d_msg.insert(3,++self.d_seq_nr)
#addr info
d_msg.insert(4,0xcd)
d_msg.insert(5,0xab)
d_msg.insert(6,0xff)
d_msg.insert(7,0xff)
d_msg.insert(8,0x40)
d_msg.insert(9,0xe8)
#Copy the data here.
d_msg.extend(pmt.u8vector_elements(buf))
#Compute the CRC over the whole packet (excluding the CRC bytes themselves)
crc = crc16(d_msg, self.len + 10)
if self.debug: print "#### CRC at Transmission: #### ", crc.get_crc()
d_msg.insert(10 + self.len, crc.get_crc() & 0xFF)
d_msg.insert(11 + self.len, crc.get_crc() >> 8)
d_msg_len = 10 + self.len + 2 # Preamble + Data + CRC
if self.debug: print " msg len ", d_msg_len, " len ", self.len, "\n"
def msg_handler_analyzed_data_in_circuit(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")
self._qubit_circuit.add_gate("RX",
targets=qubit_id,
arg_value=pi,
index=this._qcircuit_index_cnt)
elif (gate_type == quantum_gate_type.quantum_gate_type.Y):
print("in msg_handler_analyzed_data_in Y gate")
self._qubit_circuit.add_gate("RY",
targets=qubit_id,
arg_value=pi,
index=this._qcircuit_index_cnt)
elif (gate_type == quantum_gate_type.quantum_gate_type.Z):
print("in msg_handler_analyzed_data_in Z gate")
self._qubit_circuit.add_gate("RZ",
targets=qubit_id,
arg_value=pi,
index=this._qcircuit_index_cnt)
elif (gate_type == quantum_gate_type.quantum_gate_type.H):
print("in msg_handler_analyzed_data_in H gate")
self._qubit_circuit.add_gate("hadamard_transform",
targets=qubit_id,
index=this._qcircuit_index_cnt)
elif (gate_type == quantum_gate_type.quantum_gate_type.S):
print("in msg_handler_analyzed_data_in S gate")
self._qubit_circuit.add_gate("RZ",
targets=qubit_id,
arg_value=pi / 2,
index=this._qcircuit_index_cnt)
elif (gate_type == quantum_gate_type.quantum_gate_type.T):
print("in msg_handler_analyzed_data_in T gate")
self._qubit_circuit.add_gate("RZ",
targets=qubit_id,
arg_value=pi / 4,
index=this._qcircuit_index_cnt)
elif (gate_type == quantum_gate_type.quantum_gate_type.INIT):
print("in msg_handler_analyzed_data_in INIT gate")
pass
elif (gate_type == quantum_gate_type.quantum_gate_type.CNOT):
print("in msg_handler_analyzed_data_in CNOT gate")
self._qubit_circuit.add_gate("CNOT", controls=[0], targets=[1])
elif (gate_type == quantum_gate_type.quantum_gate_type.JUNC):
print("in msg_handler_analyzed_data_in JUNC gate")
pass
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 pmt_to_tracked_peaks(pmt_vector):
return [
tracked_peak.from_pmt(pmt.vector_ref(pmt_vector, i))
for i in range(pmt.length(pmt_vector))
]
def gps_handler_method(self, msg):
self.latitude = pmt.to_double(pmt.vector_ref(msg, 0))
self.longitude = pmt.to_double(pmt.vector_ref(msg, 1))
def noise_floor_handler_method(self, msg):
nfvec = []
for i in range(0, self.num_split):
nfvec.append(pmt.to_double(pmt.vector_ref(msg, i)))
self.noise_floor = copy.copy(nfvec)
