def _send_qubits(self):
print("Sending {} qubits...".format(self.N))
for i in range(0, self.N):
# Generate a key bit
k = random.randint(0, 1)
self.raw_key.append(k)
chosen_basis = random.randint(0, 1)
self.basis_list.append(chosen_basis)
# Create a qubit
q = qubit(self.cqc)
# Encode the key in the qubit
if k == 1:
q.X()
# Encode in H basis if basis = 1
if chosen_basis == 1:
q.H()
self.cqc.sendQubit(q, "Eve")
qubit_received = communication.receive_message(
self.cqc, self.receiver_pkey)
print_progress_bar(i, self.N - 1)
done_receiving = communication.receive_message(self.cqc,
self.receiver_pkey)
assert done_receiving == 'DONE'
def main():
n = parse_arguments()
basis_string = ''
bitstring = ''
# Initialize the connection
with CQCConnection("Alice") as Alice:
for i in range(0, n):
# Generate a key
k = random.randint(0, 1)
bitstring += str(k)
chosen_basis = random.randint(0, 1)
basis_string += str(chosen_basis)
# Create a qubit
q = qubit(Alice)
# Encode the key in the qubit
if k == 1:
q.X()
# Encode in H basis if basis = 1
if chosen_basis == 1:
q.H()
# Send qubit to Bob (via Eve)
Alice.sendQubit(q, "Eve")
receive_message(Alice)
print("\nAlice basis={}".format(basis_string))
print("Alice sent the key k={} to Bob".format(bitstring))
def receive_parities_addresses(self, sets, sender):
parities = []
parities.append([int(x) for x in receive_message(self.cqc, sender)])
parities.append([int(x) for x in receive_message(self.cqc, sender)])
parity = 0
for i in range(0, len(parities[self.good_index])):
parity = (parity +
sets[self.good_index][parities[self.good_index][i]]) % 2
return parity
def main():
n = parse_arguments()
basis_list = []
raw_key = []
# Initialize the connection
with CQCConnection("Alice") as Alice:
Alice.closeClassicalServer()
for i in range(0, n):
# Generate a key
k = random.randint(0, 1)
raw_key.append(str(k))
chosen_basis = random.randint(0, 1)
basis_list.append(chosen_basis)
# Create a qubit
q = qubit(Alice)
# Encode the key in the qubit
if k == 1:
q.X()
# Encode in H basis if basis = 1
if chosen_basis == 1:
q.H()
# Send qubit to Bob (via Eve)
Alice.sendQubit(q, "Eve")
receive_message(Alice)
send_message(Alice, "Bob", bytes(basis_list))
bob_basis = list(receive_message(Alice))
for i in range(0, len(bob_basis)):
if bob_basis[i] != basis_list[i]:
raw_key[i] = 'X'
basis_list[i] = 'X'
sifted_key = list(filter(lambda k: k != 'X', raw_key))
print('\nAlice Sifted Key:' + ''.join(sifted_key))
seed = generate_seed(len(sifted_key))
send_message(Alice, "Bob", bytes(seed))
key = 0
for i in range(0, len(seed)):
key = (key + (int(sifted_key[i]) * seed[i])) % 2
print("Alice extracted key={}".format(key))
m = 1
c = (m + key) % 2
send_message(Alice, "Bob", bytes([c]))
print("Alice sent m={} encrypted to c={}".format(m, c))
def _execute_string_ot(self, c, n, sender="Alice", cqc=None):
self.cqc = cqc
c_prime, rc = self.execute_rot(n * 2)
d = (c + c_prime) % 2
send_message(self.cqc, sender, [d])
e = []
e.append([int(x) for x in receive_message(self.cqc, sender)])
e.append([int(x) for x in receive_message(self.cqc, sender)])
ac = list((np.asarray(e[c], dtype=np.uint8) + rc) % 2)
#print(ac)
return ac
def run_algorithm(self):
n = math.ceil(0.73 / self.party.error_estimation)
iterations = [[]]
# 1st iteration
for i in range(0, len(self.party.sifted_key), n):
iterations[0].append(
list(range(i, min(i + n,
len(self.party.sifted_key) - 1))))
parities = utils.calculate_parities(self.party.sifted_key,
iterations[0])
communication.send_binary_list(self.party.cqc, self.party.receiver,
self.party.skey, parities)
msg = communication.receive_message(self.party.cqc,
self.party.receiver_pkey)
while msg != 'ALL DONE':
block_num = int(msg)
self._binary(iterations[0][block_num])
msg = communication.receive_message(self.party.cqc,
self.party.receiver_pkey)
# nth iteration
for iter_num in range(1, 4):
n = 2 * n
iterations.append([])
# Choose function fi [1...n] -> [1...n/ki], send and save in iterations[iter_num]
temp_indices = list(range(0, len(self.party.sifted_key)))
random.shuffle(temp_indices)
communication.send_message(self.party.cqc, self.party.receiver,
self.party.skey, temp_indices)
for i in range(0, len(self.party.sifted_key), n):
iterations[iter_num].append(
temp_indices[i:min(i + n,
len(self.party.sifted_key) - 1)])
parities = utils.calculate_parities(self.party.sifted_key,
iterations[iter_num])
communication.send_binary_list(self.party.cqc, self.party.receiver,
self.party.skey, parities)
msg = communication.receive_message(self.party.cqc,
self.party.receiver_pkey)
while msg != 'ALL DONE':
iter_num, block_num = json.loads(msg)
self._binary(iterations[iter_num][block_num])
msg = communication.receive_message(self.party.cqc,
self.party.receiver_pkey)
print(self.party.sifted_key)
def _execute_rot(self, n, sender="Alice", cqc=None):
self.cqc = cqc
c = random.random() < 0.5
rc = []
for _ in range(0, n):
rc.append(self.execute_bit_ot(c))
m = []
k = int(n / 2)
m.append(
np.asarray(list(receive_message(self.cqc, sender)),
dtype=np.uint8).reshape(k, n))
m.append(
np.asarray(list(receive_message(self.cqc, sender)),
dtype=np.uint8).reshape(k, n))
return c, np.matmul(m[c], np.asarray(rc, dtype=np.uint8).T).T
def main():
# Initialize the connection
with CQCConnection("Bob") as Bob:
Bob.closeClassicalServer()
# Receive qubit from Alice (via Eve)
q = Bob.recvQubit()
# Choose a random basis
chosen_basis = random.randint(0, 1)
if chosen_basis == 1:
q.H()
# Retrieve key
k = q.measure()
# Receive classical encoded message from Alice
enc = receive_message(Bob)[0]
# Calculate message
m = (enc + k) % 2
print("\nBob basis={}".format(BASIS[chosen_basis]))
print("Bob key={}".format(k))
print("Bob retrieved the message m={} from Alice.".format(m))
def get_chosen_bit(self, sender, good_set_parity):
send_message(self.cqc, sender, [self.good_index == self.decision_bit])
parities = receive_message(self.cqc, sender)
retrieved_bit = (
good_set_parity + parities[self.good_index]
) % 2 # choose from x0+b0, x1+b1 or x0+b1, x1+b0 the one that contains the good set
return retrieved_bit
def _binary(self, block):
alice_first_half_par = int(
communication.receive_message(self.party.cqc,
self.party.sender_pkey))
first_half_size = math.ceil(len(block) / 2.0)
first_half_par = utils.calculate_parity(self.party.sifted_key,
block[:first_half_size])
if first_half_par != alice_first_half_par:
if first_half_size == 1:
self.party.sifted_key[
block[0]] = (self.party.sifted_key[block[0]] + 1) % 2
communication.send_message(self.party.cqc, self.party.sender,
self.party.skey, 'DONE')
return block[0]
else:
communication.send_message(self.party.cqc, self.party.sender,
self.party.skey, 0)
return self._binary(block[:first_half_size])
else:
if len(block) - first_half_size == 1:
self.party.sifted_key[
block[-1]] = (self.party.sifted_key[block[-1]] + 1) % 2
communication.send_message(self.party.cqc, self.party.sender,
self.party.skey, 'DONE')
return block[-1]
else:
communication.send_message(self.party.cqc, self.party.sender,
self.party.skey, 1)
return self._binary(block[first_half_size:])
def start():
sock = communication.init_receiver('', c.PORT)
message = ''
message, addr = communication.receive_message(sock)
status = "In comm_bot_test"
print status
communication.send_broadcast_message(5003, status)
return message
def main():
n = parse_arguments()
basis_list = []
raw_key = []
# Initialize the connection
with CQCConnection("Bob") as Bob:
Bob.closeClassicalServer()
for i in range(0, n):
# Receive qubit from Alice (via Eve)
q = Bob.recvQubit()
# Choose a random basis
chosen_basis = random.randint(0, 1)
basis_list.append(chosen_basis)
if chosen_basis == 1:
q.H()
# Retrieve key bit
k = q.measure()
raw_key.append(str(k))
send_message(Bob, 'Alice', 'ok'.encode('utf-8'))
alice_basis = list(receive_message(Bob))
send_message(Bob, "Alice", bytes(basis_list))
for i in range(0, len(alice_basis)):
if alice_basis[i] != basis_list[i]:
raw_key[i] = 'X'
sifted_key = list(filter(lambda k: k != 'X', raw_key))
print('\nBob Sifted Key:' + ''.join(sifted_key))
seed = list(receive_message(Bob))
key = 0
for i in range(0, len(seed)):
key = (key + (int(sifted_key[i]) * seed[i])) % 2
print("Bob extracted key={}".format(key))
c = receive_message(Bob)[0]
m = (c + key) % 2
print("Bob received m={} that was encrypted as c={}".format(m, c))
def start():
sock = communication.init_receiver('', c.PORT)
message = ''
message, addr = communication.receive_message(sock)
status = "In comm_bot_test"
print status
communication.send_broadcast_message(5003, status)
return message
def _binary(self, block):
first_half_size = math.ceil(len(block) / 2.0)
first_half_par = utils.calculate_parity(self.party.sifted_key,
block[:first_half_size])
communication.send_message(self.party.cqc, self.party.receiver,
self.party.skey, first_half_par)
msg = communication.receive_message(self.party.cqc,
self.party.receiver_pkey)
if msg != 'DONE':
block_part = int(msg)
if block_part == 0:
self._binary(block[:first_half_size])
else:
self._binary(block[first_half_size:])
def _execute_string_ot(self, a0, a1, receiver="Bob", cqc=None):
self.cqc = cqc
r = self.execute_rot(len(a0) * 2)
d = receive_message(self.cqc, receiver)[0]
e = []
e.append(
(np.asarray(a0, dtype=np.uint8) + np.asarray(r[d], dtype=np.uint8))
% 2)
e.append((np.asarray(a1, dtype=np.uint8) +
np.asarray(r[(d + 1) % 2], dtype=np.uint8)) % 2)
send_message(self.cqc, "Bob", e[0])
send_message(self.cqc, "Bob", e[1])
def start():
state = 'INIT'
prev_state = ''
mode = 'STOP'
prev_mode = ''
try:
while True:
if state == 'INIT':
SPEED_RUN = c.SPEED_RUN
SPEED_WARN = round(float(SPEED_RUN)/3,0)
SPEED_CONTROL_MAX = SPEED_RUN
SPEED_CONTROL_MIN = SPEED_WARN
DIST_MIN = c.DIST_MIN
speed = 0
distance = 0
warning = []
last_meas_time = 0
times = []
times.append(['prev_get_dist',0.0])
times.append(['prev_get_switch',0.0])
times.append(['prev_set_motor',0.0])
times.append(['get_warning',0.0])
times.append(['prev_set_LED',0.0])
flags = []
flags.append(['set_motor',False])
flags.append(['status_warn_LED',False])
flags.append(['button_release',False])
flags.append(['master_set_speed',False])
flags.append(['master_set_button',False])
flags.append(['master_set_LED',False])
flags.append(['master_set_state',False])
pi2go.init()
pi2go.setAllLEDs(c.LED_ON,c.LED_ON,c.LED_ON)
time.sleep(1)
sock = com.init_nonblocking_receiver('',c.PORT)
for x in range(c.TEAM_SIZE):
warning.append(True)
OWN_IP = com.get_ip()
OWN_ID = com.get_id_from_ip(OWN_IP)
prev_state = state
state = 'IDLE'
if state == 'IDLE':
if prev_state != 'IDLE':
pi2go.setAllLEDs(c.LED_OFF,c.LED_OFF,c.LED_ON)
pi2go.stop()
if helper.check_time_limit(times,'prev_get_switch',c.WAIT_SWITCH):
# Pressed = 1, Released = 0
button = pi2go.getSwitch()
if not button:
helper.set_element(flags,'button_release',True)
if button and helper.get_element(flags,'button_release'):
helper.set_element(flags,'button_release',False)
prev_mode = ''
prev_state = state
state = 'RUNNING'
# change to sensor-based or master_idle type
data = 'new_round'
while data != '':
data, addr = com.receive_message(sock)
if data != '':
sender_ID = com.get_id_from_ip(addr[0])
if sender_ID < c.TEAM_START or sender_ID > c.TEAM_END:
command, value = com.string_to_command(data)
#
print 'MASTER:' , sender_ID , ' : ' , data
try:
if command == c.COMMAND_SPEED:
helper.set_element(flags,'master_set_speed',True)
prev_SPEED_RUN = SPEED_RUN
if value == '+':
SPEED_RUN += 5
elif value == '-':
SPEED_RUN -= 5
else:
SPEED_RUN = value
print 'Set SPEED_RUN from '+ str(prev_SPEED_RUN) + ' to ' + str(SPEED_RUN)
elif command == c.COMMAND_DIST:
prev_DIST_MIN = DIST_MIN
if not value.isdigit():
print "Something went terribly wrong with the protocol..."
raise KeyboardInterrupt
DIST_MIN = value
print 'Set DIST_MIN from '+ str(prev_DIST_MIN) + ' to ' + str(DIST_MIN)
elif command == c.COMMAND_BLINK:
helper.blink('white')
helper.set_element(flags, 'master_set_LED', True)
elif command == c.COMMAND_RESET:
SPEED_RUN = c.SPEED_RUN
SPEED_WARN = round(float(SPEED_RUN)/3,0)
SPEED_CONTROL_MAX = SPEED_RUN
SPEED_CONTROL_MIN = SPEED_WARN
DIST_MIN = c.DIST_MIN
helper.set_element(times,'prev_get_dist',0)
helper.set_element(flags,'master_set_LED', True)
helper.set_element(flags,'master_set_speed', True)
warning = [True] * len(warning)
print "Reset major values"
elif command == c.COMMAND_STATE:
local_prev_state = state
if value == c.VALUE_STATE_RUNNING:
state = 'RUNNING'
elif value == c.VALUE_STATE_IDLE:
state = 'IDLE'
print 'Going from state ' + local_prev_state + ' to state ' + state
elif command == c.COMMAND_TYPE:
if value == c.VALUE_TYPE_ORIGINAL:
value = helper.determine_team(OWN_ID)
return value
except:
print "Error interpreting message from master! Continuing anyway"
elif state == 'RUNNING':
# Distance
if helper.check_time_limit(times,'prev_get_dist',c.WAIT_DIST):
time_between = time.time() - last_meas_time
last_meas_time = time.time()
new_dist = pi2go.getDistance()
if new_dist > 1:
distance = new_dist
#print 'dt:', time_between , distance
# Obstacle = 1, No Obstacle = 0
irCentre = pi2go.irCentre()
# Obstacle Analysis
if irCentre or (distance < DIST_MIN):
distance_level = 0
elif distance > c.DIST_MAX:
distance_level = 2
else:
distance_level = 1
# Receive
data = 'new_round'
while data != '':
data, addr = com.receive_message(sock)
if data != '':
sender_ID = com.get_id_from_ip(addr[0])
if sender_ID == OWN_ID:
#print 'OWN: ' , sender_ID, ' : ' , data
continue
if sender_ID >= c.TEAM_START and sender_ID <= c.TEAM_END:
#print 'ROBOT: ', sender_ID, ' : ' , data
if data == 'PROBLEM':
warning[sender_ID-c.TEAM_START] = False
elif data == 'RELEASE':
warning[sender_ID-c.TEAM_START] = True
else:
try:
#print 'MASTER:' , sender_ID , ' : ' , data
command, value = com.string_to_command(data)
if command == c.COMMAND_SPEED:
helper.set_element(flags,'master_set_speed',True)
prev_SPEED_RUN = SPEED_RUN
if value == '+':
SPEED_RUN += 5
elif value == '-':
SPEED_RUN -= 5
else:
SPEED_RUN = value
print 'MASTER: Set SPEED_RUN from '+ str(prev_SPEED_RUN) + ' to ' + str(SPEED_RUN)
elif command == c.COMMAND_DIST:
prev_DIST_MIN = DIST_MIN
if not value.isdigit():
print "Something went terribly wrong with the protocol..."
raise KeyboardInterrupt
DIST_MIN = value
print 'MASTER: Set DIST_MIN from '+ str(prev_DIST_MIN) + ' to ' + str(DIST_MIN)
elif command == c.COMMAND_BLINK:
helper.blink('white')
helper.set_element(flags, 'master_set_LED', True)
elif command == c.COMMAND_RESET:
SPEED_RUN = c.SPEED_RUN
SPEED_WARN = round(float(SPEED_RUN)/3,0)
SPEED_CONTROL_MAX = SPEED_RUN
SPEED_CONTROL_MIN = SPEED_WARN
DIST_MIN = c.DIST_MIN
helper.set_element(times,'prev_get_dist',0)
helper.set_element(flags,'master_set_LED', True)
helper.set_element(flags,'master_set_speed', True)
warning = [True] * len(warning)
print 'MASTER: Reset major values'
elif command == c.COMMAND_STATE:
helper.set_element(flags,'master_set_state', True)
if value == c.VALUE_STATE_RUNNING:
next_state = 'RUNNING'
elif value == c.VALUE_STATE_IDLE:
next_state = 'IDLE'
print 'MASTER: Going from state ' + state + ' to state ' + next_state
#elif command == c.COMMAND_TYPE and value != c.VALUE_TYPE_COM:
elif command == c.COMMAND_TYPE:
local_prev_value = value
if value == c.VALUE_TYPE_ORIGINAL:
value = helper.determine_team(OWN_ID)
print "MASTER: Changing from type " + local_prev_value + " to type " + value
return value
except:
print "Error interpreting message from master! Continuing anyway"
# Analyse --> Calculate MODE
if prev_state == 'RUNNING':
prev_mode = mode
if distance_level == 0:
mode = 'STOP'
elif distance_level == 1 and all(warning):
mode = 'SLOW'
elif distance_level == 2 and all(warning):
mode = 'RUN'
elif distance_level != 0 and not all(warning):
mode = 'WARN'
# Set own Warning-Flag
if mode != prev_mode:
if mode == 'STOP':
warning[OWN_ID-c.TEAM_START] = False
else:
warning[OWN_ID-c.TEAM_START] = True
# LEDs
if mode != prev_mode or helper.get_element(flags,'master_set_LED'):
if helper.get_element(flags,'master_set_LED'):
helper.set_element(flags,'master_set_LED',False)
if mode == 'RUN':
pi2go.setAllLEDs(c.LED_OFF,c.LED_ON,c.LED_OFF)
elif mode == 'SLOW':
pi2go.setAllLEDs(c.LED_OFF,c.LED_OFF,c.LED_ON) #TODO: test
#pi2go.setAllLEDs(c.LED_OFF,c.LED_ON,c.LED_OFF) #TODO: presentation
#elif mode == 'WARN':
#pi2go.setAllLEDs(c.LED_ON,c.LED_ON,c.LED_OFF)
elif mode == 'STOP':
pi2go.setAllLEDs(c.LED_ON,c.LED_OFF,c.LED_OFF)
# Blinking-Mode
if mode == 'WARN':
if helper.check_time_limit(times,'prev_set_LED',c.WAIT_LED):
if helper.get_element(flags,'status_warn_LED'):
pi2go.setAllLEDs(c.LED_OFF,c.LED_OFF,c.LED_OFF)
helper.set_element(flags,'status_warn_LED',False)
else:
pi2go.setAllLEDs(c.LED_ON,c.LED_ON,c.LED_OFF)
helper.set_element(flags,'status_warn_LED',True)
# Calculate new speed
if mode == 'RUN':
if prev_mode != 'RUN' or helper.get_element(flags,'master_set_speed'):
speed = SPEED_RUN
helper.set_element(flags,'master_set_speed',False)
helper.set_element(flags,'set_motor',True)
# Blocking Avoidance
elif mode == 'SLOW':
#linear
gradient = float(SPEED_CONTROL_MAX - SPEED_CONTROL_MIN)/float(c.DIST_MAX-DIST_MIN)
error = c.DIST_MAX - distance
new_value = round(SPEED_RUN - error * gradient,1)
if new_value < SPEED_CONTROL_MIN:
new_value = SPEED_CONTROL_MIN
elif new_value > SPEED_CONTROL_MAX:
new_value = SPEED_CONTROL_MAX
if new_value != speed:
speed = new_value
helper.set_element(flags,'set_motor',True)
# Slow-Down in Warning-Mode
elif mode == 'WARN':
if prev_mode != 'WARN':
helper.set_element(times,'get_warning',time.time())
speed_get_warning = speed
new_value = round(speed_get_warning * (1-(time.time()-helper.get_element(times,'get_warning'))/c.TIME_TO_SLOW_DOWN),1)
if new_value < SPEED_WARN:
new_value = SPEED_WARN
if new_value != speed:
speed = new_value
helper.set_element(flags,'set_motor',True)
elif mode == 'STOP':
if prev_mode != 'STOP':
speed = c.SPEED_STOP
helper.set_element(flags,'set_motor',True)
# Motor
if helper.get_element(flags,'set_motor'):
if speed > c.SPEED_LIMIT_MAX:
speed = c.SPEED_LIMIT_MAX
elif speed < c.SPEED_LIMIT_MIN:
speed = c.SPEED_LIMIT_MIN
if mode == 'SLOW' or mode == 'WARN':
if helper.check_time_limit(times,'prev_set_motor',c.WAIT_MOTOR):
pi2go.go(speed,speed)
helper.set_element(flags,'set_motor',False)
else:
pi2go.go(speed,speed)
helper.set_element(flags,'set_motor',False)
# Send
if mode != prev_mode:
if prev_mode == 'STOP':
com.send_x_broadcast_messages(c.PORT, "RELEASE", c.SENDING_ATTEMPTS, c.WAIT_SEND)
elif mode == 'STOP':
com.send_x_broadcast_messages(c.PORT, "PROBLEM", c.SENDING_ATTEMPTS, c.WAIT_SEND)
# Next State
prev_state = state
if helper.get_element(flags,'master_set_state'):
helper.set_element(flags,'master_set_state',False)
state = next_state
# Button
if helper.check_time_limit(times,'prev_get_switch',c.WAIT_SWITCH):
# Pressed = 1, Released = 0
button = pi2go.getSwitch()
if not button:
helper.set_element(flags,'button_release',True)
if button and helper.get_element(flags,'button_release'):
helper.set_element(flags,'button_release',False)
prev_state = state
state = 'IDLE'
com.send_x_broadcast_messages(c.PORT, "RELEASE", c.SENDING_ATTEMPTS, c.WAIT_SEND)
except KeyboardInterrupt:
print 'KEYBOARD'
finally:
pi2go.stop()
pi2go.cleanup()
sock.close()
print 'END'
pi2go.init()
sock = communication.init_nonblocking_receiver('', PORT)
#log = open(senseless_log)
try:
while True:
if time.time() - start > TIME_BETWEEN_MEASUREMENT:
#print("Starting distance measuring", file = log)
#print "Starting distance measuring"
#dist = 5+4
dist = (int(pi2go.getDistance() * 10)) / 10.0
start = time.time()
#print "Distance measuring finished"
data_buf, addr = communication.receive_message(sock)
if "State" in data_buf and not OWN_IP in addr:
data = data_buf
print data
#print "OWN_IP: " + OWN_IP
#print "addr: " + str(addr)
if dist < DIST_STOP:
state = STATE_STOP
state_string = "STOP"
elif dist < DIST_RUN or ("WARN" in data and not OWN_IP in addr):
state = STATE_WARN
state_string = "WARN"
else:
state = STATE_RUN
state_string = "RUN"
def update_state_list():
for msg, ID in message_list:
if ID == OWN_ID:
continue
# print OWN_ID, " : ", message, " from ", ID
if msg == "False":
msg = False
elif msg == "True" or msg == "SLOW":
msg = True
state_list[ID] = msg
# return state_list
while True:
if state == "IDLE":
pi2go.setAllLEDs(LED_OFF, LED_OFF, LED_ON)
message, addr = communication.receive_message(sock)
print OWN_ID
if message != '':
# print message
pass
# if "MASTER_START" in message:
if "START" in message:
state = "NOT_IDLE"
if state == "NOT_IDLE":
# #### SENSOR
if time.time() - last_dist_check > 0.2:
last_dist_check = time.time()
distance = pi2go.getDistance()
# print state_list
irCentre = pi2go.irCentre()
pi2go.init()
sock = communication.init_nonblocking_receiver('', PORT)
#log = open(senseless_log)
try:
while True:
if time.time() - start > TIME_BETWEEN_MEASUREMENT:
#print("Starting distance measuring", file = log)
#print "Starting distance measuring"
#dist = 5+4
dist = (int(pi2go.getDistance()*10))/10.0
start = time.time()
#print "Distance measuring finished"
data_buf, addr = communication.receive_message(sock)
if "State" in data_buf and not OWN_IP in addr:
data = data_buf
print data
#print "OWN_IP: " + OWN_IP
#print "addr: " + str(addr)
if dist < DIST_STOP:
state = STATE_STOP
state_string = "STOP"
elif dist < DIST_RUN or ("WARN" in data and not OWN_IP in addr):
state = STATE_WARN
state_string = "WARN"
else:
def main():
n = parse_arguments()
basis_list = []
raw_key = []
# Initialize the connection
with CQCConnection("Bob") as Bob:
Bob.closeClassicalServer()
for i in range(0, n):
# Receive qubit from Alice (via Eve)
q = Bob.recvQubit()
# Choose a random basis
chosen_basis = random.randint(0, 1)
basis_list.append(chosen_basis)
if chosen_basis == 1:
q.H()
# Retrieve key bit
k = q.measure()
raw_key.append(str(k))
send_message(Bob, 'Alice', 'ok'.encode('utf-8'))
alice_basis = list(receive_message(Bob))
send_message(Bob, "Alice", bytes(basis_list))
for i in range(0, len(alice_basis)):
if alice_basis[i] != basis_list[i]:
raw_key[i] = 'X'
basis_list[i] = 'X'
sifted_key = list(
map(lambda x: int(x), (filter(lambda x: x != 'X', raw_key))))
sifted_basis = list(filter(lambda x: x != 'X', basis_list))
send_message(Bob, "Alice", bytes(sifted_key))
alice_key = list(receive_message(Bob))
z_basis_error = 0.0
x_basis_error = 0.0
z_count = 0.0
x_count = 0.0
for i in range(0, len(sifted_basis)):
if int(sifted_basis[i]) == 0:
z_count += 1.0
if int(sifted_key[i]) != alice_key[i]:
z_basis_error += 1.0
else:
x_count += 1.0
if int(sifted_key[i]) != alice_key[i]:
x_basis_error += 1.0
if z_count == 0:
z_count = 1
if x_count == 0:
x_count = 1
print(
"\n Standard Basis Error: {}\n Hadamard Basis Error: {}\n".format(
z_basis_error / z_count, x_basis_error / x_count))
def receive_sets(self, receiver):
set0 = [int(x) for x in receive_message(self.cqc, receiver)]
set1 = [int(x) for x in receive_message(self.cqc, receiver)]
return set0, set1
LEDon = 4095
LEDoff = 0
pi2go.init()
pi2go.setAllLEDs(LEDoff, LEDoff, LEDoff)
state = 'RUN'
prev_state = 'STOP'
# state = 'RUN' robot detect no obstacles
# state = 'STOP' robot detect an obstacles
# state = 'WARN' robot get message
try:
while True:
state = communication.receive_message(sock)
#print "received message: " + state + " at: %f" %time.time()
#print "time: %f", %time.time()
# set LEDs
if state != prev_state:
print state
if 'RUN' in state:
pi2go.setAllLEDs(LEDoff, LEDon, LEDoff)
elif 'WARN' in state:
pi2go.setAllLEDs(LEDon, LEDon, LEDoff)
elif 'STOP' in state:
pi2go.setAllLEDs(LEDon, LEDoff, LEDoff)
prev_state = state
except KeyboardInterrupt:
print 'KEYBOARD_STOPP'
def main():
n = parse_arguments()
basis_list = []
raw_key = []
# Initialize the connection
with CQCConnection("Alice") as Alice:
Alice.closeClassicalServer()
for i in range(0, n):
# Generate a key
k = random.randint(0, 1)
raw_key.append(str(k))
chosen_basis = random.randint(0, 1)
basis_list.append(chosen_basis)
# Create a qubit
q = qubit(Alice)
# Encode the key in the qubit
if k == 1:
q.X()
# Encode in H basis if basis = 1
if chosen_basis == 1:
q.H()
# Send qubit to Bob (via Eve)
Alice.sendQubit(q, "Eve")
receive_message(Alice)
send_message(Alice, "Bob", bytes(basis_list))
bob_basis = list(receive_message(Alice))
for i in range(0, len(bob_basis)):
if bob_basis[i] != basis_list[i]:
raw_key[i] = 'X'
basis_list[i] = 'X'
sifted_key = list(
map(lambda k: int(k), (filter(lambda k: k != 'X', raw_key))))
sifted_basis = list(filter(lambda k: k != 'X', basis_list))
bob_key = list(receive_message(Alice))
send_message(Alice, "Bob", bytes(sifted_key))
# print('A BAS = {}'.format(sifted_basis))
print('\nA KEY = {}'.format(sifted_key))
print('B KEY = {}'.format(bob_key))
z_basis_error = 0.0
x_basis_error = 0.0
z_count = 0.0
x_count = 0.0
for i in range(0, len(sifted_basis)):
if int(sifted_basis[i]) == 0:
z_count += 1.0
if int(sifted_key[i]) != bob_key[i]:
z_basis_error += 1.0
else:
x_count += 1.0
if int(sifted_key[i]) != bob_key[i]:
x_basis_error += 1.0
if z_count == 0:
z_count = 1
if x_count == 0:
x_count = 1
print(
"\n Standard Basis Error: {}\n Hadamard Basis Error: {}\n".format(
z_basis_error / z_count, x_basis_error / x_count))
import multiprocessing
import communication
import time
import pi2go
def send_distance():
while True:
distance = (int(pi2go.getDistance()*10))/10.0
communication.send_udp_unicast_message("127.0.0.1", 38235, str(distance))
print "Sent distance: " + str(distance) + " at: %f " %time.time()
time.sleep(0.1)
if __name__ == '__main__':
pi2go.init()
distance_process = multiprocessing.Process(name='send_distance', target=send_distance)
distance_process.daemon = True
distance_process.start()
distance_socket = communication.init_nonblocking_receiver("127.0.0.1", 38235)
try:
while True:
current_distance, addr = communication.receive_message(distance_socket)
if current_distance != "":
print " - Received distance: " + str(current_distance) + " at: %f " %time.time()
except KeyboardInterrupt:
print "Exciting! Exiting!"
distance_process.join(0.2)
pi2go.cleanup()
def send_distance():
while True:
distance = (int(pi2go.getDistance() * 10)) / 10.0
communication.send_udp_unicast_message("127.0.0.1", 38235,
str(distance))
print "Sent distance: " + str(distance) + " at: %f " % time.time()
time.sleep(0.1)
if __name__ == '__main__':
pi2go.init()
distance_process = multiprocessing.Process(name='send_distance',
target=send_distance)
distance_process.daemon = True
distance_process.start()
distance_socket = communication.init_nonblocking_receiver(
"127.0.0.1", 38235)
try:
while True:
current_distance, addr = communication.receive_message(
distance_socket)
if current_distance != "":
print " - Received distance: " + str(
current_distance) + " at: %f " % time.time()
except KeyboardInterrupt:
print "Exciting! Exiting!"
distance_process.join(0.2)
pi2go.cleanup()
LEDon = 4095
LEDoff = 0
pi2go.init()
pi2go.setAllLEDs(LEDoff, LEDoff, LEDoff)
state = 'RUN'
prev_state = 'STOP'
# state = 'RUN' robot detect no obstacles
# state = 'STOP' robot detect an obstacles
# state = 'WARN' robot get message
try:
while True:
state = communication.receive_message(sock)
#print "received message: " + state + " at: %f" %time.time()
#print "time: %f", %time.time()
# set LEDs
if state != prev_state:
print state
if 'RUN' in state:
pi2go.setAllLEDs(LEDoff, LEDon, LEDoff)
elif 'WARN' in state:
pi2go.setAllLEDs(LEDon, LEDon, LEDoff)
elif 'STOP' in state:
pi2go.setAllLEDs(LEDon, LEDoff, LEDoff)
prev_state = state
except KeyboardInterrupt:
print 'KEYBOARD_STOPP'
def receive_decision(self, receiver):
return receive_message(self.cqc, receiver)[0]
def receive_basis_information(self, sender):
msg = receive_message(self.cqc, sender)
return list(msg)
def update_state_list():
for msg, ID in message_list:
if ID == OWN_ID:
continue
# print OWN_ID, " : ", message, " from ", ID
if msg == "False":
msg = False
elif msg == "True" or msg == "SLOW":
msg = True
state_list[ID] = msg
# return state_list
while True:
if state == "IDLE":
pi2go.setAllLEDs(LED_OFF, LED_OFF, LED_ON)
message, addr = communication.receive_message(sock)
print OWN_ID
if message != '':
# print message
pass
# if "MASTER_START" in message:
if "START" in message:
state = "NOT_IDLE"
if state == "NOT_IDLE":
# #### SENSOR
if time.time() - last_dist_check > 0.2:
last_dist_check = time.time()
distance = pi2go.getDistance()
# print state_list
irCentre = pi2go.irCentre()
def start():
state = 'INIT'
prev_state = ''
mode = 'STOP'
prev_mode = ''
try:
while True:
if state == 'INIT':
SPEED_RUN = c.SPEED_RUN
SPEED_WARN = round(float(SPEED_RUN) / 3, 0)
SPEED_CONTROL_MAX = SPEED_RUN
SPEED_CONTROL_MIN = SPEED_WARN
DIST_MIN = c.DIST_MIN
speed = 0
distance = 0
warning = []
last_meas_time = 0
times = []
times.append(['prev_get_dist', 0.0])
times.append(['prev_get_switch', 0.0])
times.append(['prev_set_motor', 0.0])
times.append(['get_warning', 0.0])
times.append(['prev_set_LED', 0.0])
flags = []
flags.append(['set_motor', False])
flags.append(['status_warn_LED', False])
flags.append(['button_release', False])
flags.append(['master_set_speed', False])
flags.append(['master_set_button', False])
flags.append(['master_set_LED', False])
flags.append(['master_set_state', False])
pi2go.init()
pi2go.setAllLEDs(c.LED_ON, c.LED_ON, c.LED_ON)
time.sleep(1)
sock = com.init_nonblocking_receiver('', c.PORT)
for x in range(c.TEAM_SIZE):
warning.append(True)
OWN_IP = com.get_ip()
OWN_ID = com.get_id_from_ip(OWN_IP)
prev_state = state
state = 'IDLE'
if state == 'IDLE':
if prev_state != 'IDLE':
pi2go.setAllLEDs(c.LED_OFF, c.LED_OFF, c.LED_ON)
pi2go.stop()
if helper.check_time_limit(times, 'prev_get_switch',
c.WAIT_SWITCH):
# Pressed = 1, Released = 0
button = pi2go.getSwitch()
if not button:
helper.set_element(flags, 'button_release', True)
if button and helper.get_element(flags, 'button_release'):
helper.set_element(flags, 'button_release', False)
prev_mode = ''
prev_state = state
state = 'RUNNING'
# change to sensor-based or master_idle type
data = 'new_round'
while data != '':
data, addr = com.receive_message(sock)
if data != '':
sender_ID = com.get_id_from_ip(addr[0])
if sender_ID < c.TEAM_START or sender_ID > c.TEAM_END:
command, value = com.string_to_command(data)
#
print 'MASTER:', sender_ID, ' : ', data
try:
if command == c.COMMAND_SPEED:
helper.set_element(flags,
'master_set_speed',
True)
prev_SPEED_RUN = SPEED_RUN
if value == '+':
SPEED_RUN += 5
elif value == '-':
SPEED_RUN -= 5
else:
SPEED_RUN = value
print 'Set SPEED_RUN from ' + str(
prev_SPEED_RUN) + ' to ' + str(
SPEED_RUN)
elif command == c.COMMAND_DIST:
prev_DIST_MIN = DIST_MIN
if not value.isdigit():
print "Something went terribly wrong with the protocol..."
raise KeyboardInterrupt
DIST_MIN = value
print 'Set DIST_MIN from ' + str(
prev_DIST_MIN) + ' to ' + str(DIST_MIN)
elif command == c.COMMAND_BLINK:
helper.blink('white')
helper.set_element(flags, 'master_set_LED',
True)
elif command == c.COMMAND_RESET:
SPEED_RUN = c.SPEED_RUN
SPEED_WARN = round(float(SPEED_RUN) / 3, 0)
SPEED_CONTROL_MAX = SPEED_RUN
SPEED_CONTROL_MIN = SPEED_WARN
DIST_MIN = c.DIST_MIN
helper.set_element(times, 'prev_get_dist',
0)
helper.set_element(flags, 'master_set_LED',
True)
helper.set_element(flags,
'master_set_speed',
True)
warning = [True] * len(warning)
print "Reset major values"
elif command == c.COMMAND_STATE:
local_prev_state = state
if value == c.VALUE_STATE_RUNNING:
state = 'RUNNING'
elif value == c.VALUE_STATE_IDLE:
state = 'IDLE'
print 'Going from state ' + local_prev_state + ' to state ' + state
elif command == c.COMMAND_TYPE:
if value == c.VALUE_TYPE_ORIGINAL:
value = helper.determine_team(OWN_ID)
return value
except:
print "Error interpreting message from master! Continuing anyway"
elif state == 'RUNNING':
# Distance
if helper.check_time_limit(times, 'prev_get_dist',
c.WAIT_DIST):
time_between = time.time() - last_meas_time
last_meas_time = time.time()
new_dist = pi2go.getDistance()
if new_dist > 1:
distance = new_dist
#print 'dt:', time_between , distance
# Obstacle = 1, No Obstacle = 0
irCentre = pi2go.irCentre()
# Obstacle Analysis
if irCentre or (distance < DIST_MIN):
distance_level = 0
elif distance > c.DIST_MAX:
distance_level = 2
else:
distance_level = 1
# Receive
data = 'new_round'
while data != '':
data, addr = com.receive_message(sock)
if data != '':
sender_ID = com.get_id_from_ip(addr[0])
if sender_ID == OWN_ID:
#print 'OWN: ' , sender_ID, ' : ' , data
continue
if sender_ID >= c.TEAM_START and sender_ID <= c.TEAM_END:
#print 'ROBOT: ', sender_ID, ' : ' , data
if data == 'PROBLEM':
warning[sender_ID - c.TEAM_START] = False
elif data == 'RELEASE':
warning[sender_ID - c.TEAM_START] = True
else:
try:
#print 'MASTER:' , sender_ID , ' : ' , data
command, value = com.string_to_command(data)
if command == c.COMMAND_SPEED:
helper.set_element(flags,
'master_set_speed',
True)
prev_SPEED_RUN = SPEED_RUN
if value == '+':
SPEED_RUN += 5
elif value == '-':
SPEED_RUN -= 5
else:
SPEED_RUN = value
print 'MASTER: Set SPEED_RUN from ' + str(
prev_SPEED_RUN) + ' to ' + str(
SPEED_RUN)
elif command == c.COMMAND_DIST:
prev_DIST_MIN = DIST_MIN
if not value.isdigit():
print "Something went terribly wrong with the protocol..."
raise KeyboardInterrupt
DIST_MIN = value
print 'MASTER: Set DIST_MIN from ' + str(
prev_DIST_MIN) + ' to ' + str(DIST_MIN)
elif command == c.COMMAND_BLINK:
helper.blink('white')
helper.set_element(flags, 'master_set_LED',
True)
elif command == c.COMMAND_RESET:
SPEED_RUN = c.SPEED_RUN
SPEED_WARN = round(float(SPEED_RUN) / 3, 0)
SPEED_CONTROL_MAX = SPEED_RUN
SPEED_CONTROL_MIN = SPEED_WARN
DIST_MIN = c.DIST_MIN
helper.set_element(times, 'prev_get_dist',
0)
helper.set_element(flags, 'master_set_LED',
True)
helper.set_element(flags,
'master_set_speed',
True)
warning = [True] * len(warning)
print 'MASTER: Reset major values'
elif command == c.COMMAND_STATE:
helper.set_element(flags,
'master_set_state',
True)
if value == c.VALUE_STATE_RUNNING:
next_state = 'RUNNING'
elif value == c.VALUE_STATE_IDLE:
next_state = 'IDLE'
print 'MASTER: Going from state ' + state + ' to state ' + next_state
#elif command == c.COMMAND_TYPE and value != c.VALUE_TYPE_COM:
elif command == c.COMMAND_TYPE:
local_prev_value = value
if value == c.VALUE_TYPE_ORIGINAL:
value = helper.determine_team(OWN_ID)
print "MASTER: Changing from type " + local_prev_value + " to type " + value
return value
except:
print "Error interpreting message from master! Continuing anyway"
# Analyse --> Calculate MODE
if prev_state == 'RUNNING':
prev_mode = mode
if distance_level == 0:
mode = 'STOP'
elif distance_level == 1 and all(warning):
mode = 'SLOW'
elif distance_level == 2 and all(warning):
mode = 'RUN'
elif distance_level != 0 and not all(warning):
mode = 'WARN'
# Set own Warning-Flag
if mode != prev_mode:
if mode == 'STOP':
warning[OWN_ID - c.TEAM_START] = False
else:
warning[OWN_ID - c.TEAM_START] = True
# LEDs
if mode != prev_mode or helper.get_element(
flags, 'master_set_LED'):
if helper.get_element(flags, 'master_set_LED'):
helper.set_element(flags, 'master_set_LED', False)
if mode == 'RUN':
pi2go.setAllLEDs(c.LED_OFF, c.LED_ON, c.LED_OFF)
elif mode == 'SLOW':
pi2go.setAllLEDs(c.LED_OFF, c.LED_OFF,
c.LED_ON) #TODO: test
#pi2go.setAllLEDs(c.LED_OFF,c.LED_ON,c.LED_OFF) #TODO: presentation
#elif mode == 'WARN':
#pi2go.setAllLEDs(c.LED_ON,c.LED_ON,c.LED_OFF)
elif mode == 'STOP':
pi2go.setAllLEDs(c.LED_ON, c.LED_OFF, c.LED_OFF)
# Blinking-Mode
if mode == 'WARN':
if helper.check_time_limit(times, 'prev_set_LED',
c.WAIT_LED):
if helper.get_element(flags, 'status_warn_LED'):
pi2go.setAllLEDs(c.LED_OFF, c.LED_OFF, c.LED_OFF)
helper.set_element(flags, 'status_warn_LED', False)
else:
pi2go.setAllLEDs(c.LED_ON, c.LED_ON, c.LED_OFF)
helper.set_element(flags, 'status_warn_LED', True)
# Calculate new speed
if mode == 'RUN':
if prev_mode != 'RUN' or helper.get_element(
flags, 'master_set_speed'):
speed = SPEED_RUN
helper.set_element(flags, 'master_set_speed', False)
helper.set_element(flags, 'set_motor', True)
# Blocking Avoidance
elif mode == 'SLOW':
#linear
gradient = float(SPEED_CONTROL_MAX -
SPEED_CONTROL_MIN) / float(c.DIST_MAX -
DIST_MIN)
error = c.DIST_MAX - distance
new_value = round(SPEED_RUN - error * gradient, 1)
if new_value < SPEED_CONTROL_MIN:
new_value = SPEED_CONTROL_MIN
elif new_value > SPEED_CONTROL_MAX:
new_value = SPEED_CONTROL_MAX
if new_value != speed:
speed = new_value
helper.set_element(flags, 'set_motor', True)
# Slow-Down in Warning-Mode
elif mode == 'WARN':
if prev_mode != 'WARN':
helper.set_element(times, 'get_warning', time.time())
speed_get_warning = speed
new_value = round(
speed_get_warning *
(1 - (time.time() - helper.get_element(
times, 'get_warning')) / c.TIME_TO_SLOW_DOWN), 1)
if new_value < SPEED_WARN:
new_value = SPEED_WARN
if new_value != speed:
speed = new_value
helper.set_element(flags, 'set_motor', True)
elif mode == 'STOP':
if prev_mode != 'STOP':
speed = c.SPEED_STOP
helper.set_element(flags, 'set_motor', True)
# Motor
if helper.get_element(flags, 'set_motor'):
if speed > c.SPEED_LIMIT_MAX:
speed = c.SPEED_LIMIT_MAX
elif speed < c.SPEED_LIMIT_MIN:
speed = c.SPEED_LIMIT_MIN
if mode == 'SLOW' or mode == 'WARN':
if helper.check_time_limit(times, 'prev_set_motor',
c.WAIT_MOTOR):
pi2go.go(speed, speed)
helper.set_element(flags, 'set_motor', False)
else:
pi2go.go(speed, speed)
helper.set_element(flags, 'set_motor', False)
# Send
if mode != prev_mode:
if prev_mode == 'STOP':
com.send_x_broadcast_messages(c.PORT, "RELEASE",
c.SENDING_ATTEMPTS,
c.WAIT_SEND)
elif mode == 'STOP':
com.send_x_broadcast_messages(c.PORT, "PROBLEM",
c.SENDING_ATTEMPTS,
c.WAIT_SEND)
# Next State
prev_state = state
if helper.get_element(flags, 'master_set_state'):
helper.set_element(flags, 'master_set_state', False)
state = next_state
# Button
if helper.check_time_limit(times, 'prev_get_switch',
c.WAIT_SWITCH):
# Pressed = 1, Released = 0
button = pi2go.getSwitch()
if not button:
helper.set_element(flags, 'button_release', True)
if button and helper.get_element(flags, 'button_release'):
helper.set_element(flags, 'button_release', False)
prev_state = state
state = 'IDLE'
com.send_x_broadcast_messages(c.PORT, "RELEASE",
c.SENDING_ATTEMPTS,
c.WAIT_SEND)
except KeyboardInterrupt:
print 'KEYBOARD'
finally:
pi2go.stop()
pi2go.cleanup()
sock.close()
print 'END'
elif c.VALUE_TYPE_AUTO == value:
status = "I'm in auto_mode now!"
print status
# communication.send_broadcast_message(PORT, status)
com.close_socket(sock)
value = auto_bot.start()
sock = com.init_nonblocking_receiver('', c.PORT)
status = "Exiting auto_mode"
print status
# communication.send_broadcast_message(PORT, status)
elif c.VALUE_TYPE_IDLE == value:
status = "I'm in idle_mode now!"
print status
# communication.send_broadcast_message(PORT, status)
data, addr = com.receive_message(sock)
command, value = com.string_to_command(data)
while command != c.COMMAND_TYPE and (value != c.VALUE_TYPE_AUTO or value != c.VALUE_TYPE_COM):
data, addr = com.receive_message(sock)
command, value = com.string_to_command(data)
# if command != c.COMMAND_TYPE:
# value = c.VALUE_TYPE_IDLE
# else:
# value = c.VALUE_TYPE_IDLE
status = "Exiting idle_mode"
print status
# communication.send_broadcast_message(c.PORT, status)
else:
print "Error! Going in idle_mode..."
value = c.VALUE_TYPE_IDLE
def receiveMessage(self):
data = cherrypy.request.json
return communication.receive_message(data)
