def main():
print(" +-----------------------------------------------------+")
print(" | XBee Python Library Send Data Asynchronously Sample |")
print(" +-----------------------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
print("Sending data asynchronously to %s >> %s..." %
(remote_device.get_64bit_addr(), DATA_TO_SEND))
device.send_data_async(remote_device, DATA_TO_SEND)
print("Success")
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +---------------------------------------------------+")
print(" | XBee Python Library Remote Firmware Update Sample |")
print(" +---------------------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
print("Starting firmware update process...")
remote_device.update_firmware(
XML_FIRMWARE_FILE,
xbee_firmware_file=OTA_FIRMWARE_FILE,
bootloader_firmware_file=OTB_FIRMWARE_FILE,
progress_callback=progress_callback)
print("Firmware updated successfully!")
except (XBeeException, FirmwareUpdateException,
OperationNotSupportedException) as e:
print("ERROR: %s" % str(e))
exit(1)
finally:
if device is not None and device.is_open():
device.close()
def find_coordinator(self, xbee: XBeeDevice):
"""
Finds the coordinator XBee radio for targeting MAVLink data transmission
:param xbee: Local XBee device object
:return: Remote XBee coordinator device object
"""
# Discover network. Repeat until GCS has been found.
network = xbee.get_network()
network.add_device_discovered_callback(logging.debug)
network.set_discovery_timeout(5)
logging.debug('Beginning Coordinator Discovery loop.')
while True:
network.start_discovery_process()
# Block until discovery is finished TODO is blocking required?
while network.is_discovery_running():
time.sleep(0.1)
# Check devices on the network by Node ID
for device in network.get_devices():
if device not in self.known_endpoints or device not in self.old_coordinators:
check = self.check_coordinator(xbee, device)
if check is True:
return device
def main():
print(" +------------------------------------------------------+")
print(" | XBee Python Library Apply XBee Profile Remote Sample |")
print(" +------------------------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
print("Updating profile '%s'...\n" % PROFILE_PATH)
remote_device.apply_profile(PROFILE_PATH,
progress_callback=progress_callback)
print("\nProfile updated successfully!")
except Exception as e:
print(str(e))
exit(1)
finally:
if device.is_open():
device.close()
def main():
print(" +--------------------------------------+")
print(" | Sender (Station) |")
print(" +--------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
commActive = True
if remote_device is None:
print("Could not find the remote device")
exit(1)
while commActive:
print(remote_device)
action = input("action: ")
device.send_data_async(remote_device, action)
print("Success")
if action == "exit":
commActive = False
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +--------------------------------------+")
print(" | XBee Python Library Send Data Sample |")
print(" +--------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
print("open device")
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device. We will try 5 second")
time.sleep(5)
#exit(1)
numero = 300
count = 0
#numero = int(input("Escriba un número positivo: "))
while (count < numero):
DATA_TO_SEND = "Fecha: " + dt.datetime.now().strftime('%Y-%m-%d Hora: %H:%M:%S') + " Temperatura: 24.7 Humedad: 33% Presion 44mb Co2: 674.5" + "\n"
time.sleep(2)
count = count + 1
print("Sending data to %s >> %s..." % (remote_device.get_64bit_addr(), DATA_TO_SEND))
device.send_data(remote_device, DATA_TO_SEND)
print("Success")
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +-----------------------+")
print(" | Discover Network Test |")
print(" +-----------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
network = device.get_network()
devices_callback = []
def device_discovered_callback(remote):
devices_callback.append(remote)
network.add_device_discovered_callback(device_discovered_callback)
network.start_discovery_process()
while network.is_discovery_running():
time.sleep(0.1)
assert(devices_callback == network.get_devices())
print("Test finished successfully")
finally:
if device is not None and device.is_open():
device.close()
def connect():
zigbee_device = XBeeDevice('/dev/ttyUSB0', 230400)
REMOTE_NODE_ID = "Sender"
zigbee_device.open()
xbee_network = zigbee_device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
return remote_device, zigbee_device
def main():
#Define your xbee device with the defined port and baudrate
device = XBeeDevice(PORT, BAUD_RATE)
try:
#open the xbee device
device.open()
#set the io pins on the xbee board itself
#in this example, we are using the DIO_AD0 pin on the board
#refrence the datasheet for other availible pins
device.set_io_configuration(IOLine.DIO0_AD0, IOMode.ADC)
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
# a simple while loop to read the adc sample, convert it and send to the main reciever
while True:
raw_val = device.get_adc_value(IOLine.DIO0_AD0)
voltage = ((raw_val / 1024)) * 2.5
p = ((voltage - .3333) / 1.32000) - 1.00
string = str(p)
print(string)
time.sleep(0.05)
device.send_data(remote_device, string)
# close the device if any error occurs
finally:
if device is not None and device.is_open():
device.close()
def main():
coord = XBeeDevice('COM7', 9600) #create Xbeedevice Coord at COM7 & baud rate 9600
try:
coord.open() #calling method to open communication with Xbee device
coord.flush_queues()
xbee_network = coord.get_network() #getting a newtwork and assigning it to the xbee
router2 = xbee_network.discover_device('R3') # find the remote device on the network at R1
if router2 is None:
print("Could not find the remote device")
else :
print("Remote device found")
while True:
xbee_message = coord.read_data()
if xbee_message is not None:
timestamp = round(time.time())
data_raw = xbee_message.data.decode().split(",")
data = [float(element) for element in data_raw]
# Temperature
print("At {0} Temperature is {1}".format(timestamp, data[0]), end=": ")
if data[0] > 23.7:
print("Unsafe")
if router2 is not None:
coord.send_data(router2, "T1")
else:
print("Safe")
if router2 is not None:
coord.send_data(router2, "T0")
finally:
if coord is not None and coord.is_open():
coord.close()
def main():
print(" +-------------+")
print(" | Calculating ..! |")
print(" +-------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
while True:
device.send_data(remote_device, 'a')
rssi = device.get_parameter("DB")
r = int.from_bytes(rssi, byteorder='big')
res = (f"-{r}dbm")
with open('web/data.csv', 'a') as outfile:
writer = csv.writer(outfile)
writer.writerow([res])
print(res)
time.sleep(0.2)
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +-------------------------------------------+")
print(" | XBee Python Library List Directory Sample |")
print(" +-------------------------------------------+\n")
local_xbee = XBeeDevice(PORT, BAUD_RATE)
fs_xbee = local_xbee
try:
local_xbee.open()
if REMOTE_NODE_ID:
# Obtain the remote XBee from the network.
xbee_network = local_xbee.get_network()
fs_xbee = xbee_network.discover_device(REMOTE_NODE_ID)
if not fs_xbee:
print("Could not find remote device '%s'" % REMOTE_NODE_ID)
exit(1)
filesystem_manager = fs_xbee.get_file_manager()
path_to_list = PATH_TO_LIST
if not path_to_list:
path_to_list = "/flash"
files = filesystem_manager.list_directory(path_to_list)
print("Contents of '%s' (%s):\n" %
(path_to_list, fs_xbee if fs_xbee.is_remote() else "local"))
for file in files:
print(file)
except (XBeeException, FileSystemException) as e:
print("ERROR: %s" % str(e))
exit(1)
finally:
if local_xbee and local_xbee.is_open():
local_xbee.close()
def main():
print(" +--------------------------------------+")
print(" | XBee Python Library Send Data Sample |")
print(" +--------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
# 这部分可选，传输Timeout
# Retrieving the configured timeout for synchronous operations.
print("Current timeout: %d seconds" % device.get_sync_ops_timeout())
# 默认是4s
# Configuring the new timeout (in seconds) for synchronous operations.
device.set_sync_ops_timeout(NEW_TIMEOUT_FOR_SYNC_OPERATIONS)
try:
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
print("Sending data to %s >> %s..." % (remote_device.get_64bit_addr(), DATA_TO_SEND))
device.send_data(remote_device, DATA_TO_SEND)
print("Success")
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +---------------------------------+")
print(" | Add Devices to the Network Test |")
print(" +---------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
network = device.get_network()
# Add "Remote A" device with 64-bit address.
remote_a = RemoteXBeeDevice(device, x64bit_addr=ADDR_64_REMOTE_A)
network.add_remote(remote_a)
assert (len(network.get_devices()) == 1)
assert (network.get_device_by_64(ADDR_64_REMOTE_A) == remote_a)
# Add "Remote B" device with 64-bit address.
remote_b = RemoteXBeeDevice(device, x64bit_addr=ADDR_64_REMOTE_B)
network.add_remote(remote_b)
assert (len(network.get_devices()) == 2)
assert (network.get_device_by_64(ADDR_64_REMOTE_B) == remote_b)
# Construct again "Remote A" with 16-bit address and add it to the network.
remote_a = RemoteXBeeDevice(device,
x64bit_addr=ADDR_64_REMOTE_A,
x16bit_addr=ADDR_16_REMOTE_A)
network.add_remote(remote_a)
assert (len(network.get_devices()) == 2)
assert (network.get_device_by_64(ADDR_64_REMOTE_A) == remote_a)
assert (network.get_device_by_16(ADDR_16_REMOTE_A) == remote_a)
# Construct again "Remote A" with a different 16-bit address and add it to the network.
remote_a = RemoteXBeeDevice(device,
x64bit_addr=ADDR_64_REMOTE_A,
x16bit_addr=ADDR_16_REMOTE_A_2)
network.add_remote(remote_a)
assert (len(network.get_devices()) == 2)
assert (network.get_device_by_64(ADDR_64_REMOTE_A) == remote_a)
assert (network.get_device_by_16(ADDR_16_REMOTE_A) is None)
assert (network.get_device_by_16(ADDR_16_REMOTE_A_2) == remote_a)
# Set the node ID to "Remote A" and add it again to the network.
remote_a = RemoteXBeeDevice(device,
x64bit_addr=ADDR_64_REMOTE_A,
x16bit_addr=ADDR_16_REMOTE_A_2,
node_id=NODE_ID_REMOTE_A)
network.add_remote(remote_a)
assert (len(network.get_devices()) == 2)
assert (network.get_device_by_node_id(NODE_ID_REMOTE_A) == remote_a)
print("Test finished successfully")
finally:
if device is not None and device.is_open():
device.close()
class XbeeBoat:
def __init__(self, _port, _baud_rate, _remote_id, _ros_rate):
self.usv_master_status = ""
# Initialize and configure the DigiXTend Xbee Device
self.device = XBeeDevice(_port, _baud_rate)
self.device.open()
if not self.device.is_open():
rospy.loginfo('[USV] Device could not be opened.')
raise Exception()
self.device.flush_queues()
self.xnetwork = self.device.get_network()
self.remote_device = self.xnetwork.discover_device(_remote_id)
if self.remote_device is None:
rospy.loginfo('[USV] Could not find the remote device.')
self.device.close()
raise Exception()
rospy.loginfo('[USV] Digi XTend device initialized.')
# ROS Configuration
self.ros_rate = rospy.Rate(_ros_rate)
# ROS Subscriber
rospy.Subscriber("/usv_comms/boat_transceiver/data_input", String,
self.data_callback)
rospy.Subscriber("/usv_master/usv_master_status", String,
self.usv_master_callback)
# ROS Publisher
self.stop_pub = rospy.Publisher(
"/usv_comms/boat_transceiver/stop_mission", Empty, queue_size=10)
self.course_pub = rospy.Publisher(
"/usv_comms/boat_transceiver/course_config", String, queue_size=10)
self.start_pub = rospy.Publisher(
"/usv_comms/boat_transceiver/start_mission", Empty, queue_size=10)
self.general_status_pub = rospy.Publisher(
"/usv_comms/boat_transceiver/general_status",
String,
queue_size=10)
self.empty_msg = Empty()
self.boat_data = String()
self.comm_active = True
rospy.loginfo('[USV] Awaiting conversation...\n')
def data_callback(self, _data):
self.boat_data = _data.data
#rospy.loginfo('[USV] Sending data: ', self.boat_data)
#self.device.send_data_async(self.remote_device, self.boat_data)
def usv_master_callback(self, status):
self.usv_master_status = status.data
def main():
print(" +-----------------------------+")
print(" | Add Remote Device by Reader |")
print(" +-----------------------------+\n")
device_a = XBeeDevice(PORT_A, BAUD_RATE_A)
device_b = XBeeDevice(PORT_B, BAUD_RATE_B)
try:
device_a.open()
device_b.open()
network = device_a.get_network()
remote = RemoteXBeeDevice(device_b, device_a.get_64bit_addr())
# Send a message from B to A.
device_b.send_data(remote, "Test")
# Give some time to device A to receive the packet.
time.sleep(1)
# Check that B is in the network of A.
assert (len(network.get_devices()) == 1)
try:
assert (network.get_device_by_64(
device_b.get_64bit_addr()) == device_b)
except AssertionError:
assert (network.get_device_by_16(
device_b.get_16bit_addr()).get_16bit_addr() ==
device_b.get_16bit_addr())
# Send another message from B to A.
device_b.send_data(remote, "Test")
# Check that B is not duplicated.
assert (len(network.get_devices()) == 1)
try:
assert (network.get_device_by_64(
device_b.get_64bit_addr()) == device_b)
except AssertionError:
assert (network.get_device_by_16(
device_b.get_16bit_addr()).get_16bit_addr() ==
device_b.get_16bit_addr())
print("Test finished successfully")
finally:
if device_a is not None and device_a.is_open():
device_a.close()
if device_b is not None and device_b.is_open():
device_b.close()
class Radio(object):
# current xbee only can send once every ~60ms, sending faster may block
MESSAGE_DELAY = .1
def __init__(self, is_second_radio=False):
# Find our XBee device connected to this computer
port = RADIO_PORT_2 if is_second_radio else RADIO_PORT_1
self.device = XBeeDevice(port, BAUD_RATE)
# TODO: sometimes it errors about operating mode, try replugging xbee
self.device.open()
# Obtain the remote XBee devices from the XBee network.
xbee_network = self.device.get_network()
# Try to find devices
xbee_network.start_discovery_process()
time.sleep(3) # wait a few seconds to find all of the xbees
xbee_network.stop_discovery_process()
self.net_devs = xbee_network.get_devices()
if not self.net_devs:
raise RuntimeError("Cound not find any XBEE devices on network")
def send(self, message):
for remote_device in self.net_devs:
try:
start = time.time()
# asynchronous send is fast for first msg, but waits if more
# long messages (>30?) take longer because they must be split
try:
self.device.send_data_async(remote_device, message)
except Exception as e:
print('xbee error - something using same port? (xtcu):')
print(e)
# TODO: reconnect when error?
delta = time.time() - start
if delta > .003:
print('xbee send is taking a long time, too long/many?')
print("time taken: " + str(delta))
print("message length: " + str(len(message)))
except XBeeException as xbee_exp:
print(str(xbee_exp))
def read(self):
for remote_device in self.net_devs:
try:
return self.device.read_data()
except XBeeException as xbee_exp:
print(str(xbee_exp))
def close(self):
if self.device.is_open():
self.device.close()
def main():
print(" +-----------------------------------------+")
print(" | XBee Sending Data |")
print(" +-----------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
# Now wake the 6050 up as it starts in sleep mode
bus.write_byte_data(int(address, base=16), int(power_mgmt_1, base=16),
0)
# Wake up XBee
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
while True:
time.sleep(5) # pauses your Python program for 5seconds
gyro_xout = read_word_2c(0x43) #anuglar velocity in x-axis
gyro_yout = read_word_2c(0x45) #angular velocity in y-axis
gyro_zout = read_word_2c(0x47) #angular velocity in z-axis
# Pick DATA_TO_SEND
x_threshold = int(get_gyroData_from_config_file('x_threshold'))
y_threshold = int(get_gyroData_from_config_file('y_threshold'))
z_threshold = int(get_gyroData_from_config_file('z_threshold'))
if (gyro_xout > x_threshold and gyro_yout > y_threshold
and gyro_zout > z_threshold):
#use config file here to set threshold values through config
DATA_TO_SEND = "OK"
else:
DATA_TO_SEND = "ERROR"
print("Sending data to %s >> %s..." %
(remote_device.get_64bit_addr(), DATA_TO_SEND))
device.send_data(remote_device, DATA_TO_SEND)
print("Success")
time.sleep(5) # pauses your Python program for 5seconds
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +-----------------------------------------------+")
print(" | XBee Python Library Get/Set Remote DIO Sample |")
print(" +-----------------------------------------------+\n")
stop = False
th = None
local_device = XBeeDevice(PORT, BAUD_RATE)
try:
local_device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = local_device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
def io_detection_callback():
while not stop:
# Read the digital value from the input line.
io_value = remote_device.get_dio_value(IOLINE_IN)
print("%s: %s" % (IOLINE_IN, io_value))
# Set the previous value to the local output line.
#local_device.set_dio_value(IOLINE_OUT, io_value)
remote_device.set_dio_value(IOLINE_OUT, io_value)
time.sleep(0.2)
th = threading.Thread(target=io_detection_callback)
remote_device.set_io_configuration(IOLINE_IN, IOMode.DIGITAL_IN)
local_device.set_io_configuration(IOLINE_OUT, IOMode.DIGITAL_OUT_LOW)
time.sleep(0.5)
th.start()
input()
finally:
stop = True
if th is not None and th.is_alive():
th.join()
if local_device is not None and local_device.is_open():
local_device.close()
def main():
print(" +--------------------------------+")
print(" | Discover Specific Devices Test |")
print(" +--------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
network = device.get_network()
# Discover a valid remote device.
remote = network.discover_device(REMOTE_NODE_ID)
assert (remote is not None)
assert (remote.get_node_id() == REMOTE_NODE_ID)
# Discover an invalid remote device.
remote = network.discover_device("!inv4lid_1d!")
assert (remote is None)
# Discover myself.
network.set_discovery_options({DiscoveryOptions.DISCOVER_MYSELF})
if device.get_protocol() == XBeeProtocol.RAW_802_15_4:
assert (network.get_discovery_options()[0] == 1)
else:
assert (network.get_discovery_options()[0] == 2)
remote = network.discover_device(device.get_node_id())
assert (remote == device)
network.clear()
# Discover the remote device and myself.
devices_list = network.discover_devices(
[REMOTE_NODE_ID, device.get_node_id()])
assert (len(devices_list) == 2)
assert (network.get_device_by_node_id(device.get_node_id()) == device)
# Restore the discovery options.
network.set_discovery_options({})
assert (network.get_discovery_options()[0] == 0)
print("Test finished successfully")
finally:
if device is not None and device.is_open():
device.close()
def main():
Number = 0
while 1:
try:
Port = "COM" + str(Number)
device = XBeeDevice(Port, Baud_Rate)
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
device.send_data(remote_device, "1/100")
sleep(1)
device.send_data(remote_device, "2/100")
sleep(1)
device.send_data(remote_device, "1/70")
sleep(1)
device.send_data(remote_device, "2/60")
sleep(1)
device.send_data(remote_device, "1/50")
sleep(1)
device.send_data(remote_device, "2/40")
sleep(1)
device.send_data(remote_device, "1/30")
sleep(1)
device.send_data(remote_device, "2/20")
sleep(1)
device.send_data(remote_device, "1/0")
sleep(1)
device.send_data(remote_device, "2/0")
sleep(7)
except:
Number = Number + 1
finally:
if device is not None and device.is_open():
device.close()
class XbeeStation:
def __init__(self, _port, _baud_rate, _remote_id, _ros_rate):
# Initialize and configure the DigiXTend Xbee Device
self.device = XBeeDevice(_port, _baud_rate)
self.device.open()
if not self.device.is_open():
rospy.loginfo('[STATION] Device could not be opened.')
raise Exception()
self.device.flush_queues()
self.xnetwork = self.device.get_network()
self.remote_device = self.xnetwork.discover_device(_remote_id)
if self.remote_device is None:
rospy.loginfo('[STATION] Could not find the remote device.')
self.device.close()
raise Exception()
rospy.loginfo('[STATION] Digi XTend device initialized.')
# ROS Configuration
self.ros_rate = rospy.Rate(_ros_rate)
# ROS Publisher
self.boat_data_pub = rospy.Publisher(
'/usv_comms/station_transceiver/boat_data', String, queue_size=10)
# ROS Subscriber
rospy.Subscriber('/usv_comms/station_transceiver/course_config',
String, self.config_callback)
rospy.Subscriber("/usv_comms/boat_transceiver/general_status", String,
self.general_status_callback)
rospy.loginfo('[STATION] ROS Node initialized.')
self.comm_active = True
rospy.loginfo('[STATION] Awaiting conversation...\n')
def config_callback(self, _config):
rospy.loginfo('[STATION] Sending following message: ' +
str(_config.data))
self.device.send_data_async(self.remote_device, str(_config.data))
if str(_config.data) == 'exit':
self.comm_active = False
def general_status_callback(self, status):
self.boat_general_status = status.data
def main():
device = connect()
initData(device)
zigbee_device = XBeeDevice('/dev/ttyUSB0', 230400)
REMOTE_NODE_ID = "Sender"
zigbee_device.open()
xbee_network = zigbee_device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
while True:
values = getData(device)
if len(values) <= 1: # only got the currtime
device = handleTimeout(device)
else:
# do something with data (printing for now)
output = printData(values)
zigbee_device.send_data(remote_device, output)
def main():
print(" +---------------------------------------------+")
print(" | XBee Python Library Discover Devices Sample |")
print(" +---------------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
xbee_network = device.get_network()
xbee_network.set_discovery_timeout(15) # 15 seconds.
xbee_network.clear()
# Callback for discovered devices.
def callback_device_discovered(remote):
print("Device discovered: %s" % remote)
print(type(remote))
# Callback for discovery finished.
def callback_discovery_finished(status):
if status == NetworkDiscoveryStatus.SUCCESS:
print("Discovery process finished successfully.")
else:
print("There was an error discovering devices: %s" %
status.description)
xbee_network.add_device_discovered_callback(callback_device_discovered)
xbee_network.add_discovery_process_finished_callback(
callback_discovery_finished)
xbee_network.start_discovery_process()
print("Discovering remote XBee devices...")
while xbee_network.is_discovery_running():
time.sleep(0.1)
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +--------------------------------------------+")
print(" | XBee Python Library Read Remote ADC Sample |")
print(" +--------------------------------------------+\n")
stop = False
th = None
local_device = XBeeDevice(PORT, BAUD_RATE)
try:
local_device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = local_device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
remote_device.set_io_configuration(IOLINE_IN, IOMode.ADC)
def read_adc_task():
while not stop:
# Read the analog value from the remote input line.
value = remote_device.get_adc_value(IOLINE_IN)
value = (value / 1023) * 1200
print("%s: %d" % (IOLINE_IN, value))
time.sleep(0.2)
th = threading.Thread(target=read_adc_task)
time.sleep(0.5)
th.start()
input()
finally:
stop = True
if th is not None and th.isAlive():
th.join()
if local_device is not None and local_device.is_open():
local_device.close()
def initXBee(port, baud):
global CONTROLLER_ADDR
print("Init XBee at {0}, {1:d}".format(port, baud))
#device = ZigBeeDevice(port, baud)
device = XBeeDevice(port, baud)
device.open()
device.add_modem_status_received_callback(xbee_status_callback)
device.add_data_received_callback(xbee_received_callback)
xnet = device.get_network()
xnet.set_discovery_timeout(5)
xnet.start_discovery_process()
while xnet.is_discovery_running():
time.sleep(0.5)
controller16Addr = XBee16BitAddress.COORDINATOR_ADDRESS
remote_device = xnet.get_device_by_16(controller16Addr)
if remote_device is None:
print("Could not find the remote device {0}".format(controller16Addr))
print("init, nodeId= {0}".format(device.get_node_id()))
return device, remote_device
def main():
print(" +-------------------------------------------------+")
print(" | XBee Python Library Upload/Download File Sample |")
print(" +-------------------------------------------------+\n")
local_xbee = XBeeDevice(PORT, BAUD_RATE)
fs_xbee = local_xbee
try:
local_xbee.open()
if REMOTE_NODE_ID:
# Obtain the remote XBee from the network.
xbee_network = local_xbee.get_network()
fs_xbee = xbee_network.discover_device(REMOTE_NODE_ID)
if not fs_xbee:
print("Could not find remote device '%s'" % REMOTE_NODE_ID)
exit(1)
filesystem_manager = fs_xbee.get_file_manager()
xb_upload_path = os.path.join(XBEE_UPLOAD_DIR_PATH,
os.path.basename(FILE_TO_UPLOAD_PATH))
filesystem_manager.put_file(FILE_TO_UPLOAD_PATH, xb_upload_path,
overwrite=True, progress_cb=progress_upload_callback)
download_path = os.path.join(LOCAL_DOWNLOAD_DIR_PATH,
os.path.basename(FILE_TO_UPLOAD_PATH))
filesystem_manager.get_file(xb_upload_path, download_path,
progress_cb=progress_download_callback)
print("\nFile hash summary\n-----------------------")
print("%s %s" % ("Local:".ljust(15), get_sha256_hash(FILE_TO_UPLOAD_PATH).upper()))
print("%s %s" % ("Uploaded:".ljust(15),
utils.hex_to_string(filesystem_manager.get_file_hash(xb_upload_path), pretty=False)))
print("%s %s\n" % ("Downloaded:".ljust(15), get_sha256_hash(download_path).upper()))
except (XBeeException, FileSystemException) as e:
print("ERROR: %s" % str(e))
exit(1)
finally:
if local_xbee and local_xbee.is_open():
local_xbee.close()
def main():
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
latitude, longitude = getLocation()
data = "Latitude: " + str(latitude) + " Longitude: " + str(longitude)
#modify this
print("Sending data to %s >> %s..." %
(remote_device.get_64bit_addr(), data))
device.send_data(remote_device, data)
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +----------------------------------------------+")
print(" | XBee Python Library Handle IO Samples Sample |")
print(" +----------------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
# Set the local device as destination address of the remote.
remote_device.set_dest_address(device.get_64bit_addr())
remote_device.set_io_configuration(DIGITAL_LINE, IOMode.DIGITAL_IN)
remote_device.set_io_configuration(ANALOG_LINE, IOMode.ADC)
# Enable periodic sampling every IO_SAMPLING_RATE seconds in the remote device.
remote_device.set_io_sampling_rate(IO_SAMPLING_RATE)
# Enable DIO change detection in the remote device.
remote_device.set_dio_change_detection({DIGITAL_LINE})
# Register a listener to handle the samples received by the local device.
def io_samples_callback(sample, remote, time):
print("New sample received from %s - %s" %
(remote.get_64bit_addr(), sample))
device.add_io_sample_received_callback(io_samples_callback)
input()
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +--------------------------------------+")
print(" | XBee Python Library Send Data Sample |")
print(" +--------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
def data_receive_callback(xbee_message):
print("From {} >> {}".format(
xbee_message.remote_device.get_64bit_addr(),
xbee_message.data.decode()))
device.add_data_received_callback(data_receive_callback)
print("Waiting for data...\n")
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
if remote_device is None:
print("Could not find the remote device")
exit(1)
print("Sending data to {} >> {}...".format(
remote_device.get_64bit_addr(), DATA_TO_SEND))
device.send_data(remote_device, DATA_TO_SEND)
print("Success")
input("Press any key to quit...\n")
finally:
if device is not None and device.is_open():
device.close()
def main():
coord = XBeeDevice('COM7',
9600) #create Xbeedevice Coord at COM7 & baud rate 9600
try:
coord.open() #calling method to open communication with Xbee device
coord.flush_queues()
xbee_network = coord.get_network(
) #getting a newtwork and assigning it to the xbee
router2 = xbee_network.discover_device(
'R3') # find the remote device on the network at R1
if router2 is None:
print("Could not find the remote device")
else:
print("Remote device found")
while True:
xbee_message = coord.read_data()
if xbee_message is not None:
timestamp = round(time.time())
data_raw = xbee_message.data.decode().split(",")
data = [float(element) for element in data_raw]
# Temperature
print("At {0} Temperature is {1}".format(timestamp, data[0]),
end=": ")
if data[0] > 23.7:
print("Unsafe")
if router2 is not None:
coord.send_data(router2, "T1")
else:
print("Safe")
if router2 is not None:
coord.send_data(router2, "T0")
finally:
if coord is not None and coord.is_open():
coord.close()
