def reconnect_blocker(local: XBeeDevice, remote: RemoteXBeeDevice):
"""
Blocking function that awaits a message from a recently disconnected device.
:param local: Local XBee radio (connected to computer via USB)
:param remote: Remote XBee radio that a connection has been lost with
"""
logging.warning(f'Link lost with {remote}')
reconnected = False
while not reconnected:
try:
local.read_data_from(remote)
except XBeeException:
time.sleep(1)
else:
reconnected = True
logging.warning(f'Link regained with {remote}')
def check_coordinator(self, xbee: XBeeDevice, remote: RemoteXBeeDevice):
"""
Checks whether an unknown XBee device corresponds to a coordinator
:param xbee: Local XBee radio
:param remote: Remote XBee radio
:return: None if timeout awaiting reply, True if remote is a coordinator, False if an endpoint
"""
identifier = self.settings['id']
port = self.settings['port']
data = struct.pack('>BH', identifier, port)
xbee.send_data(remote, data)
rx_packet = xbee.read_data_from(remote)
start = time.time()
logging.info('Awaiting response or 5s timeout')
while not rx_packet and time.time() - start < 5:
rx_packet = xbee.read_data_from(remote)
time.sleep(0.1)
if not rx_packet:
msg = f'No response: {remote}'
ret = None
elif rx_packet.data == b'COORD':
msg = f'Coordinator found: {remote}'
self.known_endpoints.append(remote)
ret = True
elif rx_packet.data == b'ENDPT':
msg = f'Endpoint found: {remote}'
ret = False
else:
except_msg = f'Unexpected data packet {rx_packet.data}'
logging.exception(except_msg)
raise Exception(except_msg)
logging.info(msg)
return ret
class XBeeServer(UWHProtoHandler):
def __init__(self, mgr, serial_port, baud):
UWHProtoHandler.__init__(self, mgr)
self._xbee = XBeeDevice(serial_port, baud)
self._xbee.open()
def setup(self, atid, atch, atni):
self._xbee.set_parameter('ID', binascii.unhexlify(atid))
self._xbee.set_parameter('CH', binascii.unhexlify(atch))
self._xbee.set_node_id(atni)
self._xbee.write_changes()
self._xbee.apply_changes()
def client_discovery(self, cb_found_client):
xnet = self._xbee.get_network()
xnet.clear()
xnet.set_discovery_timeout(5) # seconds
xnet.add_device_discovered_callback(cb_found_client)
xnet.start_discovery_process()
while xnet.is_discovery_running():
time.sleep(0.5)
def recipient_from_address(self, address):
return RemoteXBeeDevice(self._xbee,
XBee64BitAddress.from_hex_string(address))
def send_raw(self, recipient, data):
try:
self._xbee.send_data(recipient, data)
except TimeoutException:
pass
except XBeeException as e:
print(e)
def time_ping(self, remote, val):
ping_kind = messages_pb2.MessageType_Ping
ping = self.message_for_msg_kind(ping_kind)
ping.Data = val
start = time.time()
self.send_message(remote, ping_kind, ping)
try:
xbee_msg = self._xbee.read_data_from(remote, 2)
end = time.time()
data = self.expect_Pong(xbee_msg.remote_device, xbee_msg.data)
if data != val:
# Data mismatch
return None
return end - start
except TimeoutException:
return None
def find_clients(self):
clients = []
def found_client(remote):
clients.append(remote)
self.client_discovery(found_client)
return clients
def broadcast_loop(self, client_addrs):
while True:
try:
while True:
(gkf_kind, gkf_msg) = self.get_GameKeyFrame()
(pen_kind, pen_msgs) = self.get_Penalties()
(gol_kind, gol_msgs) = self.get_Goals()
for addr in client_addrs:
client = self.recipient_from_address(addr)
self.send_message(client, gkf_kind, gkf_msg)
for msg in pen_msgs:
self.send_message(client, pen_kind, msg)
for msg in gol_msgs:
self.send_message(client, gol_kind, msg)
except Exception as e:
import traceback
print(e)
traceback.print_tb(e.__traceback__)
time.sleep(1)
def broadcast_thread(self, client_addrs):
thread = threading.Thread(target=self.broadcast_loop,
args=(client_addrs, ))
thread.daemon = True
thread.start()
class RxController:
""" Class for managing serial connection with XBee Pro S1 """
def __init__(self, port=None, baud_rate=9600):
self.port = port
self.baud_rate = baud_rate
self.remote = None
self.xbee: XBeeDevice = None
self.timeout = 100
self.packet = None
self.dataframe = pd.DataFrame()
def connect(self):
try:
if self.port is None:
self.port = serial_ports()[
0] # will display text box later for options
self.xbee = XBeeDevice(port=self.port,
baud_rate=self.baud_rate)
self.xbee.open()
return True
elif self.port is not None:
self.xbee = XBeeDevice(port=self.port,
baud_rate=self.baud_rate)
self.xbee.open()
return True
else:
if self.is_open():
self.xbee.close()
print("Disconnected from {}".format(self.port))
return False
except serial.SerialException:
return False
def is_open(self):
return self.xbee.is_open()
def disconnect(self):
try:
if self.is_open():
self.xbee.close()
return True
else:
return False
except serial.SerialException:
return False
def receive(self):
self.packet = XBeePacket(self.xbee.read_data())
print(self.packet.data.decode("utf8"))
def receive_from(self):
self.packet = XBeePacket(
self.xbee.read_data_from(self.remote, self.timeout))
data = self.packet.data.decode("utf8").split(' ')
if float(data[0]) == 0:
print('No data, but still connected. Try # ', data[-1])
else:
image = g_img.get_image(float(data[1]))
kml.kml_gen(i=float(data[0]),
lon=data[3],
lat=data[2],
alt=(float(data[4]) - 117),
icon=image)
def configure_remote(self):
if self.xbee.get_64bit_addr() == "0013A2004093DF98":
self.remote = RemoteXBeeDevice(
self.xbee,
XBee64BitAddress.from_hex_string('0013A2004093DFA1'))
else:
self.remote = RemoteXBeeDevice(
self.xbee,
XBee64BitAddress.from_hex_string("0013A2004093DF98"))
def to_csv(self):
a = pd.ExcelWriter('../RxData.xlsx', engine='xlsxwriter')
self.dataframe.to_excel(a, sheet_name='Sheet1')
a.save()
@staticmethod
def list_ports():
return serial_ports()
def __del__(self):
if self.is_open():
self.disconnect()
del self
# if x == 'a':
# # GPIO.output(23,GPIO.HIGH)
# print("RECEIVED 'A'")
# time.sleep(3)
# # else:
# # # GPIO.output(23,GPIO.LOW)
# # print("...")
receiver = XBeeDevice("/dev/serial0", 9600)
# receiver.close()
receiver.open()
# receiver.set_sync_ops_timeout(10)
remote_device = RemoteXBeeDevice(
receiver, XBee64BitAddress.from_hex_string("0013A20041C7BFD1"))
while (1):
data_variable = receiver.read_data_from(remote_device)
if (data_variable is None):
print('No Data Found')
else:
print(data_variable.data.decode("utf-8"))
print(data_variable.timestamp)
print("============================")
print()
time.sleep(3)
receiver.close()
# import struct
# port = serial.Serial('/dev/serial0', baudrate=9600, rtscts=True, timeout=0.75)
# data_struct = struct.Struct('>BHBBBBBBBBBBBBBBBBBBHB')
# while True:
# buf = port.read(24)
while x < 2:
# Peticion a sensores
data = 'Sensores'
data = data.encode("utf8")
print("Enviando peticion...")
# Envio en modo broadcast
device.send_data_broadcast(data, 0)
print("Peticion enviada")
time.sleep(1)
j = 0
for j in range(i + 1):
# Datos recogidos desde los sensores
print("Esperando a dispositivo ", j, "...")
mens = None
while mens == None:
mens = device.read_data_from(remoto[j])
data = mens.data.decode("utf8")
time.sleep(0.5)
print("\nDatos ", data)
# Asignacion de turno
print("Recolectando esos datos...")
data = 'Tu turno'
data = data.encode("utf8")
device.send_data(remoto[j], data)
#Leer
mens = None
while mens == None:
# Recivo de router
mens = device.read_data_from(remoto[j])
if len(texto) == 21:
x = 1
arduino.close()
# Datos recogidos
time.sleep(1)
data = "Recogidos"
data = data.encode("utf8")
coord = RemoteXBeeDevice(
device, XBee64BitAddress.from_hex_string("0013A20040C53D49"))
device.send_data(coord, data)
#Leer
mens = None
print("\nEsperando mi turno...\n")
while mens == None:
# Recivo de coordinador
mens = device.read_data_from(coord)
time.sleep(0.5)
print("\nEnviando datos solicitados\n")
data = texto.encode("utf8")
# Envio a coordinador
device.send_data(coord, data)
print("Datos enviados con exito!\n")
print("Cerrando dispositivo de comunicacion...\n")
#Cierro conexion
device.close()
print("Fin de la comunicacion.\n")
