def poiCriticoTimeout(self, poi):
if ACTIVATE_LOG is not None and ACTIVATE_LOG is True:
poiKey = convertTupleToString(poi)
self.poiCriticoTimers[convertTupleToString(poi)] = time.time()
self.poiCriticoTotalTimersActivados += 1
if poiKey not in self.poiCriticoTiempoAtencion:
self.poiCriticoTiempoAtencion[poiKey] = []
def execute(self):
client1 = client()
timer = Timer(SYNC_WAIT, self.wakeUp)
timer.start()
self.syncLock.acquire()
client1.search_friends(self.bebop.ip)
if not self.awoken:
message = createMessage(INICIO, SYNC, 'wake up!')
client1.send_message(message)
for i in range(len(POI_POSITIONS)):
new_timer = Timer(POI_TIMERS[i], self.setTimerFunc, (POI_POSITIONS[i],))
new_timer.start()
self.poiVigilarTimeoutDict[convertTupleToString(POI_POSITIONS[i])] = new_timer
return client1
def execute(self):
result = []
for key in self.poisVigilar:
if convertTupleToString(key) in self.assignedPOIs and self.client.check_connection(self.assignedPOIs[convertTupleToString(key)]["ip"]) == 0:
self.client.send_message(createMessage(ASIGNAR_POI, MISSION_OK, key))
self.poisVigilar.remove(key)
timer2 = threading.Timer(TIME_BETWEEN_POI_PING, self.checkMissionStatus, (key,))
timer2.start()
else:
self.nextState = ASIGNAR_POI
result.append(key)
for key in self.poisCritico:
if convertTupleToString(key) in self.assignedPOIs and self.client.check_connection(self.assignedPOIs[convertTupleToString(key)]["ip"]) == 0:
self.client.send_message(createMessage(ASIGNAR_POI, MISSION_OK, key))
self.poisCritico.remove(key)
timer2 = threading.Timer(TIME_BETWEEN_POI_PING, self.checkMissionStatus, (key,))
timer2.start()
else:
self.nextState = ASIGNAR_POI
result.append(key)
minPoi = getClosestPOI(self.bebop.current_position, result)
if minPoi is None:
return None
return {"poi": minPoi, "type": POI_CRITICO}
def execute(self):
if not self.timeout:
if len(self.client.check_friends()) != 0:
self.client.send_message(
createMessage(
GENERAL, UPDATE_MAP,
utils.convertTupleToString(
self.bebop.current_position)))
elif not self.isAlone:
self.nextState = DESPLAZARSE_SIN_CONEXION
return self.client
if self.bebop.poi_position is not None:
if self.bebop.poi_position in self.poisCritico:
self.nextState = POI_CRITICO
else:
self.nextState = POI_VIGILAR
return self.bebop.poi_position
isChequearMisionResult = self.isChequearMision()
if isChequearMisionResult is not None:
return isChequearMisionResult
else:
return self.isAsignarPOI()
return None
def execute(self):
current_position = self.bebop.current_position
nextState = self.dataBuffer
if (self.bebop.poi_position == current_position):
self.bebop.poi_position = None
poiKey = convertTupleToString(current_position)
if (poiKey in self.poiVigilarTimeoutDict):
executionTimer = self.poiVigilarTimeoutDict[poiKey]
executionTimer.cancel()
executionTimerNew = Timer(
POI_TIMERS[POI_POSITIONS.index(current_position)],
self.poiVigilarTimeout, (current_position, ))
executionTimerNew.start()
self.poiVigilarTimeoutDict[poiKey] = executionTimerNew
self.logStats.poiExplorado(poiKey)
if current_position in self.poisVigilar:
self.poisVigilar.remove(current_position)
if current_position in self.poisCriticos:
self.poisCriticos.remove(current_position)
if poiKey in self.assignedPOIs:
del (self.assignedPOIs[poiKey])
nextState = EXPLORAR
self.bebop.updateSearchMap(self.bebop.current_position)
return nextState
def main(drone1):
drone1 = drone.drone((0, 0))
my_ip = connections.get_server_ip()
client_handler = threading.Thread(target=connections.run_server,
args=(
my_ip,
drone1,
))
client_handler.start()
client1 = client.client()
client1.search_friends(my_ip)
print('take_off', drone1)
drone1.take_off()
#result2= (23,31)
#drone2.updateSearchMap(result)
#drone1.updateSearchMap(result2)
for i in range(4000):
new_position = drone1.explore()
drone1.move(new_position)
message = utils.convertTupleToString(drone1.current_position)
client1.send_message(message)
#drone2.updateSearchMap(result)
#result2 = drone2.explorar(result2)
#drone1.updateSearchMap(result2)
if i == 200:
drone1.battery_status = LOW
print("es low")
if i == 230:
print("es critical")
drone1.goHome()
if drone1.current_position == drone1.home:
drone1.battery_status = NORMAL
def execute(self):
self.bebop.updateSearchMap(self.bebop.current_position)
self.client.send_message(createMessage(GENERAL, UPDATE_MAP, utils.convertTupleToString(self.bebop.current_position)))
return None
def execute(self):
if self.isAlone:
self.result = self.poiType
self.bebop.poi_position = self.poi
self.assignedPOIs[self.poi] = self.bebop.ip
else:
if len(self.poiAlreadyAssigned
) > 0 and self.previousState == CANCELAR_MISION:
return None
if len(self.availableDistances) > 0 or len(
self.availableResults) > 0:
# im late to the party
return None
connected_drones = self.client.check_friends()
distance = cartesianDistance(self.poi, self.bebop.current_position)
available_battery = self.bebop.getBatteryPercentage()
ipPort = dict({"ip": self.bebop.ip, "port": self.bebop.port})
if available_battery - (distance /
DISTANCE_ENERGY_RATIO) > LOW_BATTERY:
message = createMessage(ASIGNAR_POI, AVAILABLE, ipPort)
self.availableDrones.append(ipPort)
for ipPort in connected_drones:
# antes estaba send_message
self.client.send_direct_message(message, ipPort["ip"],
ipPort["port"])
else:
message = createMessage(
ASIGNAR_POI, UNAVAILABLE,
concatIpPort(self.bebop.ip, self.bebop.port))
for ipPort in connected_drones:
# antes estaba send_message
self.client.send_direct_message(message, ipPort["ip"],
ipPort["port"])
return None
timer1 = threading.Timer(WAIT_TIME, self.messageWaitTimeout)
timer1.start()
conditionMet = False
while not conditionMet and not self.timeout:
self.messageWait.acquire()
if self.blockHandleMessage.locked():
self.blockHandleMessage.release()
self.messageMutex.acquire()
conditionMet = len(self.availableDrones) + len(
self.unavailableDrones) - 1 >= len(connected_drones)
self.messageMutex.release()
self.timeout = False
timer1.cancel()
availableDronesNumber = len(self.availableDrones)
distanceDict = dict({
"distance": distance,
"ip": self.bebop.ip,
"port": self.bebop.port
})
message2 = createMessage(ASIGNAR_POI, DISTANCE, distanceDict)
self.messageMutex.acquire()
# for ip in self.availableDrones:
# if ip != self.bebop.ip:
self.client.send_message(message2)
self.messageMutex.release()
timer2 = threading.Timer(SYNC_ASIGNARPOI_MSG,
self.messageWaitTimeout)
timer2.start()
conditionMet = False
self.availableDistances.append(distanceDict)
while not conditionMet and not self.timeout:
self.messageWait.acquire()
if self.blockHandleMessage.locked():
self.blockHandleMessage.release()
self.messageMutex.acquire()
conditionMet = len(
self.availableDistances) >= availableDronesNumber
self.messageMutex.release()
self.timeout = False
timer2.cancel()
minDistance = distance
minIp = self.bebop.ip
minPort = self.bebop.port
self.messageMutex.acquire()
minimoEncontrado = dict({"ip": minIp, "port": minPort})
for elem in self.availableDistances:
if elem["distance"] < minDistance:
minDistance = elem["distance"]
minIp = elem["ip"]
minPort = elem["port"]
elif elem["distance"] == minDistance:
if self.isLower(elem, minimoEncontrado):
minDistance = elem["distance"]
minIp = elem["ip"]
minPort = elem["port"]
minimoEncontrado = dict({"ip": minIp, "port": minPort})
# minimoEncontrado = dict({"ip": minIp, "port": minPort})
message3 = createMessage(ASIGNAR_POI, RESULT, minimoEncontrado)
for ipPort in self.availableDrones:
if ipPort["ip"] != self.bebop.ip or ipPort[
"port"] != self.bebop.port:
self.client.send_direct_message(message3, ipPort["ip"],
ipPort["port"])
self.messageMutex.release()
timer3 = threading.Timer(SYNC_ASIGNARPOI_MSG,
self.messageWaitTimeout)
timer3.start()
conditionMet = False
self.availableResults.append(minimoEncontrado)
while not conditionMet and not self.timeout:
self.messageWait.acquire()
if self.blockHandleMessage.locked():
self.blockHandleMessage.release()
self.messageMutex.acquire()
conditionMet = len(self.availableResults) >= len(
self.availableDrones)
self.messageMutex.release()
self.timeout = False
timer3.cancel()
concensus = ''
concensusValue = 0
self.messageMutex.acquire()
for ipPort in self.availableDrones:
count = 0
for elem in self.availableResults:
if elem == ipPort["ip"]:
count += 1
if count > concensusValue:
concensusValue = count
concensus = ipPort
elif count == concensusValue:
if self.isLower(ipPort, concensus):
concensusValue = count
concensus = ipPort
self.messageMutex.release()
if concensus["ip"] == self.bebop.ip and concensus[
"port"] == self.bebop.port:
self.result = self.poiType
self.bebop.poi_position = self.poi
message4 = createMessage(GENERAL, POI_ASSIGNED,
convertTupleToString(self.poi))
self.client.send_message(message4)
timer2 = threading.Timer(TIME_BETWEEN_POI_PING,
self.checkMissionStatus, (self.poi, ))
timer2.start()
self.assignedPOIs[convertTupleToString(self.poi)] = concensus
return self.poi
def checkMissionStatus(self, poi):
if (convertTupleToString(poi) in self.assignedPOIs):
self.poisVigilar.append(poi)
