class XBeeClient(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 send_raw(self, recipient, data):
try:
self._xbee.send_data(recipient, data)
except TimeoutException:
pass
except XBeeException as e:
print(e)
def listen_thread(self):
def callback(xbee_msg):
try:
self.recv_raw(xbee_msg.remote_device, xbee_msg.data)
except ValueError:
logging.exception("Problem parsing xbee packet")
self._xbee.add_data_received_callback(callback)
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 XBeeConnect(QObject):
successful_connection_signal = pyqtSignal()
error_connection_signal = pyqtSignal()
def __init__(self, parent=None):
super(XBeeConnect, self).__init__(parent)
self.local_device = None
self.com = ''
self.speed = ''
self.connected = False
self.parent = parent
self.parent.signal_start_connect.connect(self.start_connection)
self.parent.signal_read_info.connect(self.read_info)
self.parent.signal_write_info.connect(self.write_info)
self.parent.signal_disconnect_module.connect(self.close_port)
self.parent.signal_info_type_s2c_dev.connect(self.info_type_s2c_dev)
self.parent.signal_update_info_id.connect(self.update_info_id)
self.parent.signal_apply_change_id.connect(self.apply_change_id)
self.parent.signal_update_info_ni.connect(self.update_info_ni)
self.parent.signal_apply_change_ni.connect(self.apply_change_ni)
self.parent.signal_update_info_ce.connect(self.update_info_ce)
self.parent.signal_apply_change_ce.connect(self.apply_change_ce)
self.parent.signal_update_info_jv.connect(self.update_info_jv)
self.parent.signal_apply_change_jv.connect(self.apply_change_jv)
self.parent.signal_update_info_sm.connect(self.update_info_sm)
self.parent.signal_apply_change_sm.connect(self.apply_change_sm)
@pyqtSlot()
def start_connection(self):
self.local_device = XBeeDevice(self.com, self.speed)
try:
self.local_device.open()
self.connected = True
# делаем для теста print
print('ПОРТ ОТКРЫТ. Устройство готово к работе')
self.type_device = hex_to_string(
self.local_device.get_firmware_version())
print("Firmware version: %s" % self.type_device)
self.successful_connection_signal.emit()
except Exception as e:
self.connected = False
print(e)
self.error_connection_signal.emit()
self.local_device.close()
def read_info(self):
self.pan_id = self.local_device.get_parameter('ID')
self.node_id = self.local_device.get_node_id()
def write_info(self, parameters):
self.local_device.set_pan_id(hex_string_to_bytes(str(parameters[0])))
self.local_device.set_parameter('NI',
bytearray(str(parameters[1]), 'utf8'))
time.sleep(1)
self.local_device.apply_changes()
time.sleep(1)
self.local_device.write_changes()
time.sleep(1)
self.new_pan_id = self.local_device.get_parameter('ID')
self.new_node_id = self.local_device.get_node_id()
print('ПАРАМЕТРЫ ОБНОВЛЕНЫ')
def close_port(self):
self.local_device.close()
print('ПОРТ ЗАКРЫТ')
def info_type_s2c_dev(self):
self.coordinator_enabled = self.local_device.get_parameter('CE')
self.sleep_mode = self.local_device.get_parameter('SM')
def update_info_id(self):
self.info_id = self.local_device.get_parameter('ID')
def apply_change_id(self, id):
self.local_device.set_pan_id(hex_string_to_bytes(str(id)))
self.local_device.apply_changes()
self.local_device.write_changes()
self.new_id = self.local_device.get_parameter('ID')
def update_info_ni(self):
self.info_ni = self.local_device.get_node_id()
def apply_change_ni(self, ni):
self.local_device.set_parameter('NI', bytearray(str(ni), 'utf8'))
self.local_device.apply_changes()
self.local_device.write_changes()
self.new_ni = self.local_device.get_node_id()
def update_info_ce(self):
self.info_ce = self.local_device.get_parameter('CE')
def apply_change_ce(self, ce):
self.local_device.set_parameter('CE', hex_string_to_bytes(str(ce)))
self.local_device.apply_changes()
self.local_device.write_changes()
self.new_ce = self.local_device.get_parameter('CE')
def update_info_jv(self):
self.info_jv = self.local_device.get_parameter('JV')
def apply_change_jv(self, jv):
self.local_device.set_parameter('JV', hex_string_to_bytes(str(jv)))
self.local_device.apply_changes()
self.local_device.write_changes()
self.new_jv = self.local_device.get_parameter('JV')
def update_info_sm(self):
self.info_sm = self.local_device.get_parameter('SM')
def apply_change_sm(self, sm):
self.local_device.set_parameter('SM', hex_string_to_bytes(str(sm)))
self.local_device.apply_changes()
self.local_device.write_changes()
self.new_sm = self.local_device.get_parameter('SM')
#cmd = 'AP2,'
device.set_parameter("AP", bytearray.fromhex("02"))
if (opts.coordinator):
device.set_parameter("CE", bytearray.fromhex("01"))
else:
device.set_parameter("CE", bytearray.fromhex("00"))
#cmd += 'CE1,' #API mode 2, and enable coordinator
device.set_parameter("MY", utils.int_to_bytes(my_address))
device.set_parameter("NI", bytearray(opts.name, 'utf8'))
device.set_parameter("BD", utils.int_to_bytes(baud_lookup[57600]))
device.set_parameter("CH", bytearray.fromhex(opts.channel))
device.set_parameter("RN", bytearray.fromhex("01"))
device.set_parameter("RO", bytearray.fromhex("05"))
device.apply_changes()
device.write_changes()
device.reset()
device.close()
# cmd += 'MY%d,'%int(args[1]) #set the xbee address
# cmd += 'BD%d,'%baud_lookup[57600] #set the xbee to interface at 57600 baud
# cmd += 'ID%d,'%opts.pan_id
# cmd += 'CH%s,'%opts.channel
# cmd += 'DL0,'
# cmd += 'RN1,' #enables collision avoidance on first transmission
# cmd += 'RO5,' #sets packetization timeout to 5 characters
# cmd += 'WR' #wrtie the commands to nonvolatile memory
