def ensure_micropython_is_disabled(xbee: XBeeDevice) -> Error:
"""
Ensures that ATPS (MicroPython auto start) is disabled. If it was running, it writes the change
so that it persists across reboots and then restarts the device-- this stops any running MicroPython code
and won't restart after the reboot because ATPS has been disabled.
This function is useful if you were running some MicroPython code on the device and now
you want to instead run some xbee-python based code using the XBee from a PC, and furthermore
you want to ensure there is no code running on the device that could interfere with your PC app.
"""
param = "PS"
desired = b"\x00"
actual = xbee.get_parameter(param)
if actual == desired:
logc("AT%s is already set to the desired value; nothing to be done." %
param)
return Success
logc("AT%s needs to be changed. was %s, changing to %s" %
(param, actual, desired))
xbee.set_parameter(param, desired)
xbee.write_changes() # Persist this change across device resets.
actual = xbee.get_parameter(param)
if actual != desired:
return Error("Failed to change AT%s setting" % param)
logc("Need to restart the device because AT%s has changed." % param)
err = restart_micropython_interpreter(xbee)
if err:
return wrap_error(err, "Failed to restart the device.")
logc("Successfully restarted the device.")
return Success
def main():
print(" +-----------------------------------------------+")
print(" | XBee Python Library Set/Get parameters Sample |")
print(" +-----------------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Set parameters.
device.set_parameter(PARAM_NODE_ID, bytearray(PARAM_VALUE_NODE_ID, 'utf8'))
device.set_parameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID)
device.set_parameter(PARAM_DEST_ADDRESS_H, PARAM_VALUE_DEST_ADDRESS_H)
device.set_parameter(PARAM_DEST_ADDRESS_L, PARAM_VALUE_DEST_ADDRESS_L)
# Get parameters.
print("Node ID: %s" % device.get_parameter(PARAM_NODE_ID).decode())
print("PAN ID: %s" % utils.hex_to_string(device.get_parameter(PARAM_PAN_ID)))
print("Destination address high: %s" % utils.hex_to_string(device.get_parameter(PARAM_DEST_ADDRESS_H)))
print("Destination address low: %s" % utils.hex_to_string(device.get_parameter(PARAM_DEST_ADDRESS_L)))
print("")
print("All parameters were set correctly!")
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +-------------+")
print(" | Calculating |")
print(" +-------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
device1 = XBeeDevice(PORT1, BAUD_RATE)
device2 = XBeeDevice(PORT2, BAUD_RATE)
try:
device.open()
device1.open()
device2.open()
with open('web/data.csv', 'w') as csv_file:
csv_writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
csv_writer.writeheader()
# Obtain the remote XBee device from the XBee network.
xbee_network = device.get_network()
xbee_network1 = device1.get_network()
xbee_network2 = device2.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
remote_device1 = xbee_network1.discover_device(REMOTE_NODE_ID)
remote_device2 = xbee_network2.discover_device(REMOTE_NODE_ID)
if remote_device and remote_device1 and remote_device2 is None:
print("Could not find the remote device")
exit(1)
while True:
# Calculating the rssi of each node from DB rigester in the XBee module .
device.send_data(remote_device, 'a')
device1.send_data(remote_device1, 'c')
device2.send_data(remote_device2, 'b')
rssi = device.get_parameter("DB")
rssi1 = device1.get_parameter("DB")
rssi2 = device2.get_parameter("DB")
res = int.from_bytes(rssi, byteorder='big')
res1 = int.from_bytes(rssi1, byteorder='big')
res2 = int.from_bytes(rssi2, byteorder='big')
R1 = (f"-{res}dbm")
R2 = (f"-{res1}dbm")
R3 = (f"-{res2}dbm")
with open('web/data.csv', 'a') as outfile:
csv_writer = csv.DictWriter(outfile, fieldnames=fieldnames)
info = {"R1": res, "R2": res1, "R3": res2}
csv_writer.writerow(info)
print([R1, R2, R3])
time.sleep(1)
finally:
if device and device1 and device2 is not None and device.is_open(
) and device1.is_open() and device2.is_open():
device.close() and device1.close() and device2.close()
def main():
print(" +-----------------------------------------------+")
print(" | XBee Python Library Set/Get parameters Sample |")
print(" +-----------------------------------------------+\n")
local_device = XBeeDevice(PORT, BAUD_RATE)
try:
local_device.open()
remote_device = RemoteZigBeeDevice(local_device,
PARAM_VALUE_REMOTE_NODE_ADDR)
# Set parameters.
local_device.set_parameter(PARAM_NODE_ID,
bytearray(PARAM_VALUE_NODE_ID, 'utf8'))
local_device.set_parameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID)
local_device.set_parameter(PARAM_DEST_ADDRESS_H,
PARAM_VALUE_DEST_ADDRESS_H)
local_device.set_parameter(PARAM_DEST_ADDRESS_L,
PARAM_VALUE_DEST_ADDRESS_L)
# Get parameters.
print("Node ID: %s" %
local_device.get_parameter(PARAM_NODE_ID).decode())
print("PAN ID: %s" %
utils.hex_to_string(local_device.get_parameter(PARAM_PAN_ID)))
print("Destination address high: %s" % utils.hex_to_string(
local_device.get_parameter(PARAM_DEST_ADDRESS_H)))
print("Destination address low: %s" % utils.hex_to_string(
local_device.get_parameter(PARAM_DEST_ADDRESS_L)))
# Set remote parameters.
remote_device.set_parameter(
PARAM_NODE_ID, bytearray(PARAM_VALUE_REMOTE_NODE_ID, 'utf8'))
remote_device.set_parameter(PARAM_SLEEP_PER,
PARAM_VALUE_REMOTE_NODE_SP)
remote_device.write_changes() #make changes permanet
# Get remote parameters.
print("Remote Node ID: %s" %
remote_device.get_parameter(PARAM_NODE_ID).decode())
print(
"Remote Node SP: %s" %
utils.hex_to_string(remote_device.get_parameter(PARAM_SLEEP_PER)))
print("")
print("All parameters were set correctly!")
finally:
if local_device is not None and local_device.is_open():
local_device.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():
device = XBeeDevice("COM6", 9600)
device.open()
print(device.get_parameter("NI").decode())
device.close()
device.open()
print(device.get_parameter("NI").decode())
device.close()
device.open()
print(device.get_parameter("NI").decode())
device.close()
device.open()
print(device.get_parameter("NI").decode())
device.close()
device.open()
print(device.get_parameter("NI").decode())
device.close()
def heartbeat(self, xbee: XBeeDevice, coordinator: RemoteXBeeDevice):
"""
HEARTBEAT reply/"acknowledgement"
Need to manually construct a RADIO_STATUS MAVLink message and place it at the front of
priority_queue, as RADIO_STATUS messages are automatically constructed and sent back to the
GCS on SiK radio firmware in response to a HEARTBEAT. This is crucial for establishing a
recognisable link on GCS software, such as QGroundControl.
:param xbee:
:param coordinator:
"""
logging.debug('Generating fake heartbeat')
rssi = bytes_to_int(xbee.get_parameter('DB'))
remrssi = bytes_to_int(coordinator.get_parameter('DB'))
errors = bytes_to_int(xbee.get_parameter('ER'))
radio_status_msg = self.px4.mav.radio_status_encode(
rssi=rssi, remrssi=remrssi, rxerrors=errors, txbuf=100, noise=0, remnoise=0, fixed=0)
radio_status_msg.pack(self.px4.mav)
self.queue_out.write(radio_status_msg)
def main():
print(" +------------------------------------------------+")
print(" | XBee Python Library Get XBee Statistics Sample |")
print(" +------------------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
try:
device.open()
# Set parameters.
device.set_parameter(PARAM_NODE_ID,
bytearray(PARAM_VALUE_NODE_ID, 'utf8'))
device.set_parameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID)
device.set_parameter(PARAM_DEST_ADDRESS_H, PARAM_VALUE_DEST_ADDRESS_H)
device.set_parameter(PARAM_DEST_ADDRESS_L, PARAM_VALUE_DEST_ADDRESS_L)
# Get parameters.
print("Node ID: %s" %
device.get_parameter(PARAM_NODE_ID).decode())
print("PAN ID: %s" %
utils.hex_to_string(device.get_parameter(PARAM_PAN_ID)))
print("Destination address high: %s" %
utils.hex_to_string(device.get_parameter(PARAM_DEST_ADDRESS_H)))
print("Destination address low: %s" %
utils.hex_to_string(device.get_parameter(PARAM_DEST_ADDRESS_L)))
print("")
print("All parameters were set correctly!")
print("Showing XBee statistics")
print(" RX: packets=%d, bytes=%d" %
(device.stats.rx_packets, device.stats.rx_bytes))
print(" TX: packets=%d, bytes=%d" %
(device.stats.tx_packets, device.stats.tx_bytes))
print("Showing network errors")
print(" Remote AT commands errors=%d" % device.stats.rmt_cmd_errors)
print(" TX errors=%d" % device.stats.tx_errors)
print("All XBee statistics displayed!")
finally:
if device is not None and device.is_open():
device.close()
def main():
print(" +---------------------------------+")
print(" | Get and Set Params Local/Remote |")
print(" +---------------------------------+\n")
local_xbee = XBeeDevice(PORT, BAUD_RATE)
try:
local_xbee.open()
remote_xbee = RemoteXBeeDevice(local_xbee,
x64bit_addr=REMOTE_DEVICE_ADDRESS)
local_xbee.read_device_info()
print("Read device info of local device successfully")
remote_xbee.read_device_info()
print("Read device info of remote device successfully")
print("\nLocal:")
print(local_xbee.get_node_id())
print(local_xbee.get_hardware_version())
print(hex_to_string(local_xbee.get_firmware_version()))
print(local_xbee.get_protocol())
print("\nRemote:")
print(remote_xbee.get_node_id())
print(remote_xbee.get_hardware_version())
print(hex_to_string(remote_xbee.get_firmware_version()))
print(remote_xbee.get_protocol())
ni = ''.join(
random.choice(string.ascii_letters)
for i in range(random.randint(1, 20)))
local_xbee.set_parameter("NI", bytearray(ni, "utf8"))
param = local_xbee.get_parameter("NI")
assert (param.decode() == ni)
ni = ''.join(
random.choice(string.ascii_letters)
for i in range(random.randint(1, 20)))
remote_xbee.set_parameter("NI", bytearray(ni, "utf8"))
param = remote_xbee.get_parameter("NI")
assert (param.decode() == ni)
print("\nTest finished successfully")
finally:
if local_xbee is not None and local_xbee.is_open():
local_xbee.close()
def main():
if len(sys.argv) < 2:
output_log = logfile
xbee_port = default_port
elif len(sys.argv) < 3:
output_log = sys.argv[1]
xbee_port = default_port
else:
output_log = sys.argv[1]
xbee_port = sys.argv[2]
device = XBeeDevice(xbee_port, baud_rate)
device.open()
while True:
try:
# Returns an object
# .remote_device
# .data
# .is_broadcast
# .timestamp
xbee_msg = device.read_data()
if (xbee_msg):
remote_device = xbee_msg.remote_device
data = xbee_msg.data
# We also want RSSI info
rssi = device.get_parameter("DB")
log(xbee_msg, rssi, output_log)
'''
# DEBUG
print("Received: {}\nFrom: {}".format(data, remote_device))
hexdump(data)
print("RSSI: {}".format(rssi))
hexdump(rssi)
print("\n")
'''
except KeyboardInterrupt:
break
device.close()
def main():
device = XBeeDevice(xbee_port, baud_rate)
if device.open():
print("ERROR. DEVICE DID NOT OPEN")
num = 0
#signaler.ledOff() #TO assure that it is not left on from the last run
while True:
try:
# Returns an object
# .remote_device
# .data
# .is_broadcast
# .timestamp
xbee_msg = device.read_data()
if (xbee_msg):
remote_device = xbee_msg.remote_device
data = xbee_msg.data
# We also want RSSI info
rssi = device.get_parameter("DB")
log(xbee_msg, rssi, output_log)
# DEBUG
'''
print("Received: {}\nFrom: {}".format(data, remote_device))
hexdump(data)
print("RSSI: {}".format(rssi))
hexdump(rssi)
print("\n")
'''
print("received \n")
except KeyboardInterrupt:
print("KeyboardInterrupt..... ")
break
device.close()
signaler.ledOff()
def main(NodeAddress):
print(" +-----------------------------------------------+")
print(" | Write Local XBee parameters |")
print(" +-----------------------------------------------+\n")
local_device = XBeeDevice(PORT, BAUD_RATE)
try:
local_device.open()
# Get Hardware Models with extended DIO (P5 to P9)
Hardware_Extended = read_sys_config.ReadHardwareVersionWhithP5ToP9PinsFromFile(
)
HV = utils.hex_to_string(local_device.get_parameter("HV"))
# Set filne name source of the params
read_node_config_file.set_path_to_file(NodeAddress)
# Networking
local_device.set_parameter(
"ID",
utils.hex_string_to_bytes(
read_node_config_file.ReadPanIDFromFile(NodeAddress)))
local_device.set_parameter(
"SC",
utils.hex_string_to_bytes(
read_node_config_file.ReadScanChannelsFromFile(NodeAddress)))
local_device.set_parameter(
"SD",
utils.hex_string_to_bytes(
read_node_config_file.ReadScanDurationFromFile(NodeAddress)))
local_device.set_parameter(
"ZS",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeStackProfileFromFile(
NodeAddress)))
local_device.set_parameter(
"NJ",
utils.hex_string_to_bytes(
read_node_config_file.ReadNodeJoinTimeFromFile(NodeAddress)))
local_device.set_parameter(
"NW",
utils.hex_string_to_bytes(
read_node_config_file.ReadNetworkWatchdogTimeoutFromFile(
NodeAddress)))
local_device.set_parameter(
"JV",
utils.hex_string_to_bytes(
read_node_config_file.ReadChannelVerificationFromFile(
NodeAddress)))
local_device.set_parameter(
"JN",
utils.hex_string_to_bytes(
read_node_config_file.ReadJoinNotificationFromFile(
NodeAddress)))
local_device.set_parameter(
"CE",
utils.hex_string_to_bytes(
read_node_config_file.ReadCoordinatorEnableFromFile(
NodeAddress)))
local_device.set_parameter(
"DO",
utils.hex_string_to_bytes(
read_node_config_file.ReadDeviceOptionsFromFile(NodeAddress)))
local_device.set_parameter(
"DC",
utils.hex_string_to_bytes(
read_node_config_file.ReadDeviceControlsFromFile(NodeAddress)))
# Addressing
local_device.set_parameter(
"DH",
utils.hex_string_to_bytes(
read_node_config_file.ReadDestinationAddressHighFromFile(
NodeAddress)))
local_device.set_parameter(
"DL",
utils.hex_string_to_bytes(
read_node_config_file.ReadDestinationAddressLowFromFile(
NodeAddress)))
local_device.set_parameter(
"NI",
bytearray(
read_node_config_file.ReadNodeIdentifierFromFile(NodeAddress),
'utf8'))
local_device.set_parameter(
"NH",
utils.hex_string_to_bytes(
read_node_config_file.ReadMaximumHopsFromFile(NodeAddress)))
local_device.set_parameter(
"BH",
utils.hex_string_to_bytes(
read_node_config_file.ReadBroadcastRadiusFromFile(
NodeAddress)))
local_device.set_parameter(
"AR",
utils.hex_string_to_bytes(
read_node_config_file.ReadManyToOneRouteBroadcastTimeFromFile(
NodeAddress)))
local_device.set_parameter(
"DD",
utils.hex_string_to_bytes(
read_node_config_file.ReadDeviceTypeIdentifierFromFile(
NodeAddress)))
local_device.set_parameter(
"NT",
utils.hex_string_to_bytes(
read_node_config_file.ReadNodeDiscoveryBackoffFromFile(
NodeAddress)))
local_device.set_parameter(
"NO",
utils.hex_string_to_bytes(
read_node_config_file.ReadNodeDiscoveryOptionsFromFile(
NodeAddress)))
local_device.set_parameter(
"CR",
utils.hex_string_to_bytes(
read_node_config_file.ReadPanConflictThresholdFromFile(
NodeAddress)))
# ZigBee Addressing
local_device.set_parameter(
"SE",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeSourceEndPointFromFile(
NodeAddress)))
local_device.set_parameter(
"DE",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeDestinationEndpointFromFile(
NodeAddress)))
local_device.set_parameter(
"CI",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeClusterIDFromFile(
NodeAddress)))
local_device.set_parameter(
"TO",
utils.hex_string_to_bytes(
read_node_config_file.ReadTransmitOptionsFromFile(
NodeAddress)))
# RF Interfacing
local_device.set_parameter(
"PL",
utils.hex_string_to_bytes(
read_node_config_file.ReadTxPowerLevelFromFile(NodeAddress)))
local_device.set_parameter(
"PM",
utils.hex_string_to_bytes(
read_node_config_file.ReadPowerModeFromFile(NodeAddress)))
# Security
local_device.set_parameter(
"EE",
utils.hex_string_to_bytes(
read_node_config_file.ReadEncryptionEnableFromFile(
NodeAddress)))
local_device.set_parameter(
"EO",
utils.hex_string_to_bytes(
read_node_config_file.ReadEncryptionOptionsFromFile(
NodeAddress)))
local_device.set_parameter(
"KY",
utils.hex_string_to_bytes(
read_node_config_file.ReadEncryptionKeyFromFile(NodeAddress)))
local_device.set_parameter(
"NK",
utils.hex_string_to_bytes(
read_node_config_file.ReadNetworkEncryptionKeyFromFile(
NodeAddress)))
# Serial Interfacing
local_device.set_parameter(
"BD",
utils.hex_string_to_bytes(
read_node_config_file.ReadBaudRateFromFile(NodeAddress)))
local_device.set_parameter(
"NB",
utils.hex_string_to_bytes(
read_node_config_file.ReadParityFromFile(NodeAddress)))
local_device.set_parameter(
"SB",
utils.hex_string_to_bytes(
read_node_config_file.ReadStopBitsFromFile(NodeAddress)))
local_device.set_parameter(
"RO",
utils.hex_string_to_bytes(
read_node_config_file.ReadPacketizationTimeoutFromFile(
NodeAddress)))
local_device.set_parameter(
"D6",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO6ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D7",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO7ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"AP",
utils.hex_string_to_bytes(
read_node_config_file.ReadApiEnableFromFile(NodeAddress)))
local_device.set_parameter(
"AO",
utils.hex_string_to_bytes(
read_node_config_file.ReadApiOutputModeFromFile(NodeAddress)))
# AT Command Options
local_device.set_parameter(
"CT",
utils.hex_string_to_bytes(
read_node_config_file.ReadATCommandModeTimeoutFromFile(
NodeAddress)))
local_device.set_parameter(
"GT",
utils.hex_string_to_bytes(
read_node_config_file.ReadGuardTimesFromFile(NodeAddress)))
local_device.set_parameter(
"CC",
utils.hex_string_to_bytes(
read_node_config_file.ReadCommandSequenceCharacterFromFile(
NodeAddress)))
# Sleep Modes
local_device.set_parameter(
"SP",
utils.hex_string_to_bytes(
read_node_config_file.ReadCyclicSleepPeriodFromFile(
NodeAddress)))
local_device.set_parameter(
"SN",
utils.hex_string_to_bytes(
read_node_config_file.ReadNumberOfCyclicSleepPeriodsFromFile(
NodeAddress)))
local_device.set_parameter(
"SM",
utils.hex_string_to_bytes(
read_node_config_file.ReadSleepModeFromFile(NodeAddress)))
local_device.set_parameter(
"ST",
utils.hex_string_to_bytes(
read_node_config_file.ReadTimeBeforeSleepFromFile(
NodeAddress)))
local_device.set_parameter(
"SO",
utils.hex_string_to_bytes(
read_node_config_file.ReadSleepOptionsFromFile(NodeAddress)))
local_device.set_parameter(
"WH",
utils.hex_string_to_bytes(
read_node_config_file.ReadWakeHostFromFile(NodeAddress)))
local_device.set_parameter(
"PO",
utils.hex_string_to_bytes(
read_node_config_file.ReadPollRateFromFile(NodeAddress)))
# I/O Settings
local_device.set_parameter(
"D0",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO0AD0ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D1",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO1AD1ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D2",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO2AD2ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D3",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO3AD3ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D4",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO4ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D5",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO5ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D8",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO8ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"D9",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO9ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P0",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO10ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P1",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO11ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P2",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO12ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P3",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO13ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P4",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO14ConfigurationFromFile(
NodeAddress)))
if HV == Hardware_Extended: # Not all hardware have this inputs
local_device.set_parameter(
"P5",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO15ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P6",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO16ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P7",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO17ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P8",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO18ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"P9",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO19ConfigurationFromFile(
NodeAddress)))
local_device.set_parameter(
"PR",
utils.hex_string_to_bytes(
read_node_config_file.ReadPullUpResistorEnableFromFile(
NodeAddress)))
local_device.set_parameter(
"PD",
utils.hex_string_to_bytes(
read_node_config_file.ReadPullUpDownDirectionFromFile(
NodeAddress)))
local_device.set_parameter(
"LT",
utils.hex_string_to_bytes(
read_node_config_file.ReadAssociatedLedBlinkTimeFromFile(
NodeAddress)))
local_device.set_parameter(
"RP",
utils.hex_string_to_bytes(
read_node_config_file.ReadRssiPwmTimerFromFile(NodeAddress)))
# I/O Sampling
local_device.set_parameter(
"IR",
utils.hex_string_to_bytes(
read_node_config_file.ReadIOSamplingRateFromFile(NodeAddress)))
local_device.set_parameter(
"IC",
utils.hex_string_to_bytes(
read_node_config_file.ReadDigitalIOChangeDetectionFromFile(
NodeAddress)))
local_device.set_parameter(
"V+",
utils.hex_string_to_bytes(
read_node_config_file.ReadSupplyVoltageHihgThresholdFromFile(
NodeAddress)))
# Make params permanent
local_device.write_changes() # make changes permanet
#print parameters
print(" Success!! All Parameters Were Written ")
log = " Success!! All Parameters Were Written \n\n"
except:
log = " Sorry, an error has happened during writting operation\n"
if local_device.is_open():
local_device.close()
pass
finally:
if local_device is not None and local_device.is_open():
local_device.close()
else:
log = " No local device found\n"
return log
def main():
print(" +-----------------------------------------------+")
print(" | Get Local XBee parameters |")
print(" +-----------------------------------------------+\n")
local_device = XBeeDevice(PORT, BAUD_RATE)
try:
local_device.open()
# Get Hardware Models with extended DIO (P5 to P9)
Hardware_Extended = read_sys_config.ReadHardwareVersionWhithP5ToP9PinsFromFile(
)
# Get parameters.
# Diagnostic Commads
VR = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadFirmwareVersionCmdFromFile()))
HV = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadHardwareVersionCmdFromFile()))
AI = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadAssociationIndicationCmdFromFile()))
DB = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadRSSIOfLastPacketCmdFromFile()))
V = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadSupplyVotageCmdFromFile()))
# Networking
ID = utils.hex_to_string(
local_device.get_parameter(read_sys_config.ReadPanIDCmdFromFile()))
SC = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadScanChannelsCmdFromFile()))
SD = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadScanDurationCmdFromFile()))
ZS = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadZigBeeStackProfileCmdFromFile()))
NJ = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadNodeJoinTimeCmdFromFile()))
NW = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadNetworkWatchdogTimeoutCmdFromFile()))
JV = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadChannelVerificationCmdFromFile()))
JN = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadJoinNotificationCmdFromFile()))
OP = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadOperatingPanIdCmdFromFile()))
OI = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadOperating16BitPanIdCmdFromFile()))
CH = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadOperatingChannelCmdFromFile()))
NC = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadNumberOfRemainingChildrenCmdFromFile()))
CE = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadCoordinatorEnableCmdFromFile()))
DO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDeviceOptionsCmdFromFile()))
DC = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDeviceControlsCmdFromFile()))
# Addressing
SH = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadSerialNumberHighCmdFromFile()))
SL = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadSerialNumberLowCmdFromFile()))
MY = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.Read16BitNetworkAddressCmdFromFile()))
MP = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.Read16BitParentAddressCmdFromFile()))
DH = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDestinationAddressHighCmdFromFile()))
DL = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDestinationAddressLowCmdFromFile()))
NI = local_device.get_parameter(
read_sys_config.ReadNodeIdentifierCmdFromFile()).decode()
NH = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadMaximumHopsCmdFromFile()))
BH = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadBroadcastRadiusCmdFromFile()))
AR = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadManyToOneRouteBroadcastTimeCmdFromFile()))
DD = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDeviceTypeIdentifierCmdFromFile()))
NT = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadNodeDiscoveryBackoffCmdFromFile()))
NO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadNodeDiscoveryOptionsCmdFromFile()))
NP = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.
ReadMaximumNumberOfTransmissionBytesCmdFromFile()))
CR = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadPanConflictThresholdCmdFromFile()))
# ZigBee Addressing
SE = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadZigBeeSourceEndPointCmdFromFile()))
DE = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadZigBeeDestinationEndpointCmdFromFile()))
CI = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadZigBeeClusterIDCmdFromFile()))
TO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadTransmitOptionsCmdFromFile()))
# RF Interfacing
PL = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadTxPowerLevelCmdFromFile()))
PM = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadPowerModeCmdFromFile()))
PP = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadPowerAtPL4CmdFromFile()))
# Security
EE = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadEncryptionEnableCmdFromFile()))
EO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadEncryptionOptionsCmdFromFile()))
KY = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadEncryptionKeyCmdFromFile()))
NK = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadNetworkEncryptionKeyCmdFromFile()))
# Serial Interfacing
BD = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadBaudRateCmdFromFile()))
NB = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadParityCmdFromFile()))
SB = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadStopBitsCmdFromFile()))
RO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadPacketizationTimeoutCmdFromFile()))
D6 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO6ConfigurationCmdFromFile()))
D7 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO7ConfigurationCmdFromFile()))
AP = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadApiEnableCmdFromFile()))
AO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadApiOutputModeCmdFromFile()))
# AT Command Options
CT = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadATCommandModeTimeoutCmdFromFile()))
GT = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadGuardTimesCmdFromFile()))
CC = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadCommandSequenceCharacterCmdFromFile()))
# Sleep Modes
SP = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadCyclicSleepPeriodCmdFromFile()))
SN = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadNumberOfCyclicSleepPeriodsCmdFromFile()))
SM = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadSleepModeCmdFromFile()))
ST = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadTimeBeforeSleepCmdFromFile()))
SO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadSleepOptionsCmdFromFile()))
WH = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadWakeHostCmdFromFile()))
PO = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadPollRateCmdFromFile()))
# I/O Settomgs
D0 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO0AD0ConfigurationCmdFromFile()))
D1 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO1AD1ConfigurationCmdFromFile()))
D2 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO2AD2ConfigurationCmdFromFile()))
D3 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO3AD3ConfigurationCmdFromFile()))
D4 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO4ConfigurationCmdFromFile()))
D5 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO5ConfigurationCmdFromFile()))
D8 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO8ConfigurationCmdFromFile()))
D9 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO9ConfigurationCmdFromFile()))
P0 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO10ConfigurationCmdFromFile()))
P1 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO11ConfigurationCmdFromFile()))
P2 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO12ConfigurationCmdFromFile()))
P3 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO13ConfigurationCmdFromFile()))
P4 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO14ConfigurationCmdFromFile()))
if HV == Hardware_Extended:
P5 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO15ConfigurationCmdFromFile()))
P6 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO16ConfigurationCmdFromFile()))
P7 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO17ConfigurationCmdFromFile()))
P8 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO18ConfigurationCmdFromFile()))
P9 = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDIO19ConfigurationCmdFromFile()))
PR = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadPullUpResistorEnableCmdFromFile()))
PD = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadPullUpDownDirectionCmdFromFile()))
LT = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadAssociatedLedBlinkTimeCmdFromFile()))
RP = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadRssiPwmTimerCmdFromFile()))
# I/O Sampling
IR = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadIOSamplingRateCmdFromFile()))
IC = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadDigitalIOChangeDetectionCmdFromFile()))
Vplus = utils.hex_to_string(
local_device.get_parameter(
read_sys_config.ReadSupplyVoltageHihgThresholdCmdFromFile()))
#print parameters
print(" +-----------------------------+")
print(" | Networking |")
print(" +-----------------------------+")
print(" PAN ID: %s" % ID)
print(" Scan Channel: %s" % SC)
print(" Scan Duration: %s" % SD)
print(" ZigBee Stack Profile: %s" % ZS)
print(" Node Join Time: %s" % NJ)
print(" Network Watchdog Timeout: %s" % NW)
print(" Channel Verification: %s" % JV)
print(" Join Notification: %s" % JN)
print(" Operating PAN ID: %s" % OP)
print(" Operating 16-bit PAN ID: %s" % OI)
print(" Operating Channel: %s" % CH)
print(" Number of Remaining Children:%s" % NC)
print(" Coordinator Enable: %s" % CE)
print(" Device Options: %s" % DO)
print(" Device Controls: %s" % DC + "\n")
print(" +-----------------------------+")
print(" | Addressing |")
print(" +-----------------------------+")
print(" Serial Number High: %s" % SH)
print(" Serial Number Low: %s" % SL)
print(" 16-bit Network Address: %s" % MY)
print(" 16-bit Parent Address: %s" % MP)
print(" Destination Address High: %s" % DH)
print(" Destination Address Low: %s" % DL)
print(" Node Identifier: %s" % NI)
print(" Maximum Hops: %s" % NH)
print(" Broadcast Radius: %s" % BH)
print(" Many-to-One Route Bro. Time: %s" % AR)
print(" Device Type Identifier: %s" % DD)
print(" Node Discovery Backoff: %s" % NT)
print(" Node Discovery Options: %s" % NO)
print(" Maximum Num.Trans. Bytes: %s" % NP)
print(" PAN Conflict Threshold: %s" % CR + "\n")
print(" +-----------------------------+")
print(" | ZigBee Addressing |")
print(" +-----------------------------+")
print(" Zigbee Source Endpoint: %s" % SE)
print(" Zigbee Destination Endpoint: %s" % DE)
print(" Zigbee Cluster ID: %s" % CI)
print(" Transmit Options: %s" % TO + "\n")
print(" +-----------------------------+")
print(" | RF Interfacing |")
print(" +-----------------------------+")
print(" Tx Power Level: %s" % PL)
print(" Power Mode: %s" % PM)
print(" Power at PL4: %s" % PP + "\n")
print(" +-----------------------------+")
print(" | Security |")
print(" +-----------------------------+")
print(" Encryption Enable: %s" % EE)
print(" Encryption Options: %s" % EO)
print(" Encryption Key: %s" % KY)
print(" Network Encryption Key: %s" % NK + "\n")
print(" +-----------------------------+")
print(" | Serial Interfacing |")
print(" +-----------------------------+")
print(" Baud Rate: %s" % BD)
print(" Parity: %s" % NB)
print(" Stop Bits: %s" % SB)
print(" Packetization Timeout: %s" % RO)
print(" DIO6/nRTS Configuration : %s" % D6)
print(" DIO7/nCTS Configuration: %s" % D7)
print(" API Enable: %s" % AP)
print(" API Output Mode: %s" % AO + "\n")
print(" +-----------------------------+")
print(" | AT Command Options |")
print(" +-----------------------------+")
print(" AT Command Mode Timeout: %s" % CT)
print(" Guard Times: %s" % GT)
print(" Command Sequence Character: %s" % CC + "\n")
print(" +-----------------------------+")
print(" | Sleep Modes |")
print(" +-----------------------------+")
print(" Cyclic Sleep Period: %s" % SP)
print(" Number of Cyclic Sleep Per.: %s" % SN)
print(" Sleep Mode: %s" % SM)
print(" Time Before Sleep:sss %s" % ST)
print(" Sleep Options: %s" % SO)
print(" Wake Hosts: %s" % WH)
print(" Poll Rate: %s" % PO + "\n")
print(" +-----------------------------+")
print(" | I/O Settings |")
print(" +-----------------------------+")
print(" DIO0/ADO/CB Configuration: %s" % D0)
print(" DIO1/AD1 Configuration: %s" % D1)
print(" DIO2/AD2 Configuration: %s" % D2)
print(" DIO3/AD3 Configuration: %s" % D3)
print(" DIO4 Configuration: %s" % D4)
print(" DIO5 Configuration: %s" % D5)
print(" DIO8 Configuration: %s" % D8)
print(" DIO9 Configuration: %s" % D9)
print(" DIO10 Configuration: %s" % P0)
print(" DIO11 Configuration: %s" % P1)
print(" DIO12 Configuration: %s" % P2)
print(" DIO13 Configuration: %s" % P3)
print(" DIO14 Configuration: %s" % P4)
if HV == Hardware_Extended:
print(" DIO15 Configuration: %s" % P5)
print(" DIO16 Configuration: %s" % P6)
print(" DIO17 Configuration: %s" % P7)
print(" DIO18 Configuration: %s" % P8)
print(" DIO19 Configuration: %s" % P9)
print(" Pull-UP Resistor Enable: %s" % PR)
print(" Pull-Up/down Direction: %s" % PD)
print(" Associate LED Blink Time: %s" % LT)
print(" RSSI PWM Timer: %s" % RP + "\n")
print(" +-----------------------------+")
print(" | I/O Sampling |")
print(" +-----------------------------+")
print(" IO Sampling Rate: %s" % IR)
print(" Digital IO Change Detection: %s" % IC)
print(" Supply Votage High Thres.: %s" % Vplus + "\n")
print(" +-----------------------------+")
print(" | Diagnostic Commands |")
print(" +-----------------------------+")
print(" Firmaware Version: %s" % VR)
print(" Hardware Version: %s" % HV)
print(" Association Indication: %s" % AI)
print(" RSSI of Last Packet: %s" % DB)
print(" Supply Votage: %s" % V + "\n")
finally:
if local_device is not None and local_device.is_open():
local_device.close()
class strangenet_xbee:
def __init__(self):
logging.debug("Initializing local XBee...")
port = os.getenv("STRANGENET_XBEE_PORT", "/dev/ttyUSB0")
baud = os.getenv("STRANGENET_XBEE_BAUD", 230400)
logging.debug("Using port: " + port + " and baud: " + str(baud))
self.device = XBeeDevice(port, baud)
self.device.open(
) # automatically does read_device_info() for local device
# the XBee waits NT * 0.1 sec on a ND, DN or FN (default 0x82
# self.device.set_parameter('NT', xbu.hex_string_to_bytes('10'))
print('Printing NP value')
print(self.device.get_parameter("NP")) # NP: max packet size in hex
self.mtu = self.device.get_parameter("NP")
ipv4 = os.getenv('STRANGENET_IP', '10.0.0.1')
logging.debug('Writing IP address ' + ipv4 + ' to XBee device...')
self.device.set_parameter("NI", bytearray(('STR_' + ipv4), 'utf-8'))
self.device.write_changes() # in case of accidental reset
# create a XBeeNetwork object to store discovered devices
self.xnet = self.device.get_network()
def tx(self, dst_ip, payload):
# we have an IP, encode to NI
# dst is a bytearray representing the destination IPv4
# there is probably a cleaner way to do this
dst = dst_ip.hex() # in hex this should be a fixed size
dstNI = 'STR_' + (
str(int(dst[:2], 16)) + '.' + str(int(dst[2:4], 16)) + '.' +
str(int(dst[4:6], 16)) + '.' + str(int(dst[6:8], 16)))
print('\nSending to NI:', dstNI)
# special procedures for broadcast
if dstNI[3:] is "10.0.0.0": # FIXME do the things to support other subnets
return self.broadcast_tx(payload)
# see if we have the MAC cached, note that caching last duration of runtime
# so we do not have an easy way for devices to change IP
destdev = self.xnet.get_device_by_node_id(dstNI)
if destdev is None: # not in xnet
# we will have to resolve, this will block for NT * 0.1 sec
# unpredictable behavior will result from duplicate NI's, the following picks the first
destdev = self.xnet.discover_device(dstNI)
if destdev is None:
return "NOROUTE"
# proceed to send the data now that we have destdev
# TODO do this asynchronously
try:
self.device.send_data(destdev,
payload) # no exec == success (ACK recd)
except digi.xbee.TimeoutException:
logging.warning("Timeout on XBee link")
return "TIMEOUT"
except XBeeException: # wrong op mode, corrupt response, serial error
return "ERROR"
def broadcast_tx(self, payload):
pass
def poll(self, timeout):
logging.debug("Polling XBee device for incoming packets...")
data = self.device.read_data()
if data is not None:
logging.debug("Packet recd from XBee, forwarding to TUN...")
# we have an XBeeMessage object
return {'payload': bytes(data.data)}
else:
logging.debug("Nothing from XBee this time.")
return None # None = no data w/in timeout (set to zero for instant)
def get_parameter(xbee: XBeeDevice, param: str) -> str:
return utils.hex_to_string(xbee.get_parameter(param))
def ensure_running_latest_micropython_app(build_dir: str,
xbee: XBeeDevice) -> Error:
"""
Deploys the compiled .mpy files to the target. Also ensures that no main.py file exists on the device.
Assumes that the xbee device has already been already opened.
A note about main.py versus main.mpy:
We compile main.py to main.mpy and deploy the .mpy version to the device.
Note that if the device already contains a main.py, it will run the main.py instead.
It is therefore up to the host processor (if one) or else the MicroPython deployment process
to ensure that no main.py file exists on the device. When I first started using XBees, I deployed
.mpy versions of all files EXCEPT main.py so that you'd never have a case where you accidentally
deploy an out-of-date main.py that keeps running at startup instead of your desired main.mpy file.
But that approach has the following downsides: 1) waste RAM and time at startup because the device
must compile the .py file every time, 2) more complexity because you need to train main.py
as a special case, 3) you don't the compile-time checking advantages of cross-compiling main.py
unless you compile it too. Short answer: Use main.mpy on the device.
"""
# TODO Make this function also remote any extraneous .mpy file from the device!
mpy_files = [
XBeeFile(file_path) for file_path in glob.glob("%s/*.mpy" % build_dir)
]
updated_files = False # Indicates if file(s) were updated so that MicroPython interpreter can be restarted.
main_py_was_deleted = False # Indicates if main.py was removed so that MicroPython interpreter can be restarted.
updated_atps = False # Indicates if the ATPS setting (automatically launch MicroPython code at startup) is set.
with OpenFileSystem(xbee) as fs:
# Update any missing or out-of-date .mpy files on the device.
for f in mpy_files:
# Test if file needs to be deployed.
log("Checking SHA-256 hash of the file %s" % f.name)
f.retrieve_xbeehash(fs)
if f.xbeehash == f.localhash:
continue
# Deploy the file.
try:
log("Deploying file %s" % f.name)
fs.put_file(source_path=f.localpath,
dest_path=f.xbeepath,
secure=False)
except FileSystemException as ex:
return Error("ERROR: Failed to deploy file %s: %s" %
(f.xbeepath, ex))
# Check that file was correctly deployed.
log("Verifying correct deployment of the file %s" % f.name)
f.retrieve_xbeehash(fs)
if f.xbeehash != f.localhash:
return Error(
"ERROR: Deployed file checksum mismatch! %s vs %s" %
(f.xbeehash, f.localhash))
updated_files = True
log("mpy_files:\n%s" % "\n".join(["%s" % f for f in mpy_files]))
# Ensure that main.py does not exist on the device.
try:
fs.remove_element(MAIN_PY)
main_py_was_deleted = True
log("Successfully deleted file %s." % MAIN_PY)
except FileSystemException as ex:
if "ENOENT" not in repr(ex):
return Error("ERROR: Failed to delete %s. Details: %s" %
(MAIN_PY, ex))
log("Looks like file %s does not exist. Good." % MAIN_PY)
# Ensure that ATPS is set to enable MicroPython to run at startup.
param = "PS"
desired = b"\x01"
actual = xbee.get_parameter(param)
if actual != desired:
log("AT%s needs to be changed. was %s, changing to %s" %
(param, actual, desired))
xbee.set_parameter(param, desired)
xbee.write_changes() # Persist this change across device resets.
updated_atps = True
actual = xbee.get_parameter(param)
if actual != desired:
return Error("ERROR: Failed to change AT%s setting" % param)
log("Confirmed that AT%s is set correctly." % param)
# Determine if the MicroPython interpreter needs to be restarted.
if updated_files or main_py_was_deleted or updated_atps:
log("Need need to restart the MicroPython interpreter because %s%s%s" %
("one or more MicroPython files changed." if updated_files else "",
"an old main.py was deleted." if main_py_was_deleted else "",
"ATPS was not previously set." if updated_atps else ""))
err = restart_micropython_interpreter(xbee)
if err:
return Error(
"Error: Failed to restart MicroPython interpreter. Details: %s"
% err)
log("Successfully restarted MicroPython interpreter.")
else:
log("MicroPython interpreter does not need to be restarted. It is already running the latest code."
)
return Success
from digi.xbee.devices import XBeeDevice,RemoteXBeeDevice,XBee64BitAddress
import numpy
import serial
i=1;
local_xbee=XBeeDevice("/dev/ttyUSB0",9600)
local_xbee.open()
remote_xbee=RemoteXBeeDevice(local_xbee,XBee64BitAddress.from_hex_string("0013A200415656E8"))
while i<=100:
db=local_xbee.get_parameter("DB")
file=open("/home/pi/test1.xlt","a")
x=db;
file.write("%s\n"%x[0])
i+=1
print("%s\n"%x[0])
remote_xbee.read_device_info(
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')
root = Tk()
root.geometry("800x800")
root.resizable(1, 1)
root.title("Packet Traffic Visualisation")
root.protocol("WM_DELETE_WINDOW", ask_quit)
# Asks the user to enter the baudrate
BAUD_RATE = input("Enter the baudrate of the device: ")
gateway = XBeeDevice(PORT, BAUD_RATE)
gateway.open()
# Get the 64-bit address of the device.
GATEWAY = "0x" + str(gateway.get_64bit_addr())
# Set the ID & NI Parameter
gateway.set_parameter(PARAM_NODE_ID,
bytearray(PARAM_VALUE_NODE_ID, 'utf8'))
gateway.set_parameter(PARAM_PAN_ID, PARAM_VALUE_PAN_ID)
# Get parameters.
print("Node ID:\t%s" % gateway.get_parameter(PARAM_NODE_ID).decode())
print("PAN ID:\t%s" %
utils.hex_to_string(gateway.get_parameter(PARAM_PAN_ID)))
# Assign the data received callback to the gateway
gateway.add_data_received_callback(packages_received_callback)
app = Application(master=root)
app.mainloop()
else:
sys.exit("No serial port seems to have an XBee connected.")
def main():
#log=""
# Parámetros de conexión con el puerto serie al dispositivo local
port = read_sys_config.ReadLocalPortFromFile()
baud_rate = read_sys_config.ReadLocalBaudRateFromFile()
local_device = XBeeDevice(port, baud_rate)
try:
print(" +-----------------------------------------------+")
print(" | Get Local XBee Parameters |")
print(" +-----------------------------------------------+\n")
local_device.open()
# Get Hardware Models with extended DIO (P5 to P9)
Hardware_Extended = read_sys_config.ReadHardwareVersionWhithP5ToP9PinsFromFile()
# Get parameters.
# Diagnostic Commads
VR = utils.hex_to_string(local_device.get_parameter("VR"))
HV = utils.hex_to_string(local_device.get_parameter("HV"))
AI = utils.hex_to_string(local_device.get_parameter("AI"))
DB = utils.hex_to_string(local_device.get_parameter("DB"))
V = utils.hex_to_string(local_device.get_parameter("%V"))
# Networking
ID = utils.hex_to_string(local_device.get_parameter("ID"))
SC = utils.hex_to_string(local_device.get_parameter("SC"))
SD = utils.hex_to_string(local_device.get_parameter("SD"))
ZS = utils.hex_to_string(local_device.get_parameter("ZS"))
NJ = utils.hex_to_string(local_device.get_parameter("NJ"))
NW = utils.hex_to_string(local_device.get_parameter("NW"))
JV = utils.hex_to_string(local_device.get_parameter("JV"))
JN = utils.hex_to_string(local_device.get_parameter("JN"))
OP = utils.hex_to_string(local_device.get_parameter("OP"))
OI = utils.hex_to_string(local_device.get_parameter("OI"))
CH = utils.hex_to_string(local_device.get_parameter("CH"))
NC = utils.hex_to_string(local_device.get_parameter("NC"))
CE = utils.hex_to_string(local_device.get_parameter("CE"))
DO = utils.hex_to_string(local_device.get_parameter("DO"))
DC = utils.hex_to_string(local_device.get_parameter("DC"))
# Addressing
SH = utils.hex_to_string(local_device.get_parameter("SH"))
SL = utils.hex_to_string(local_device.get_parameter("SL"))
MY = utils.hex_to_string(local_device.get_parameter("MY"))
MP = utils.hex_to_string(local_device.get_parameter("MP"))
DH = utils.hex_to_string(local_device.get_parameter("DH"))
DL = utils.hex_to_string(local_device.get_parameter("DL"))
NI = local_device.get_parameter("NI").decode()
NH = utils.hex_to_string(local_device.get_parameter("NH"))
BH = utils.hex_to_string(local_device.get_parameter("BH"))
AR = utils.hex_to_string(local_device.get_parameter("AR"))
DD = utils.hex_to_string(local_device.get_parameter("DD"))
NT = utils.hex_to_string(local_device.get_parameter("NT"))
NO = utils.hex_to_string(local_device.get_parameter("NO"))
NP = utils.hex_to_string(local_device.get_parameter("NP"))
CR = utils.hex_to_string(local_device.get_parameter("CR"))
# ZigBee Addressing
SE = utils.hex_to_string(local_device.get_parameter("SE"))
DE = utils.hex_to_string(local_device.get_parameter("DE"))
CI = utils.hex_to_string(local_device.get_parameter("CI"))
TO = utils.hex_to_string(local_device.get_parameter("TO"))
# RF Interfacing
PL = utils.hex_to_string(local_device.get_parameter("PL"))
PM = utils.hex_to_string(local_device.get_parameter("PM"))
PP = utils.hex_to_string(local_device.get_parameter("PP"))
# Security
EE = utils.hex_to_string(local_device.get_parameter("EE"))
EO = utils.hex_to_string(local_device.get_parameter("EO"))
KY = utils.hex_to_string(local_device.get_parameter("KY"))
NK = utils.hex_to_string(local_device.get_parameter("NK"))
# Serial Interfacing
BD = utils.hex_to_string(local_device.get_parameter("BD"))
NB = utils.hex_to_string(local_device.get_parameter("NB"))
SB = utils.hex_to_string(local_device.get_parameter("SB"))
RO = utils.hex_to_string(local_device.get_parameter("RO"))
D6 = utils.hex_to_string(local_device.get_parameter("D6"))
D7 = utils.hex_to_string(local_device.get_parameter("D7"))
AP = utils.hex_to_string(local_device.get_parameter("AP"))
AO = utils.hex_to_string(local_device.get_parameter("AO"))
# AT Command Options
CT = utils.hex_to_string(local_device.get_parameter("CT"))
GT = utils.hex_to_string(local_device.get_parameter("GT"))
CC = utils.hex_to_string(local_device.get_parameter("CC"))
# Sleep Modes
SP = utils.hex_to_string(local_device.get_parameter("SP"))
SN = utils.hex_to_string(local_device.get_parameter("SN"))
SM = utils.hex_to_string(local_device.get_parameter("SM"))
ST = utils.hex_to_string(local_device.get_parameter("ST"))
SO = utils.hex_to_string(local_device.get_parameter("SO"))
WH = utils.hex_to_string(local_device.get_parameter("WH"))
PO = utils.hex_to_string(local_device.get_parameter("PO"))
# I/O Settomgs
D0 = utils.hex_to_string(local_device.get_parameter("D0"))
D1 = utils.hex_to_string(local_device.get_parameter("D1"))
D2 = utils.hex_to_string(local_device.get_parameter("D2"))
D3 = utils.hex_to_string(local_device.get_parameter("D3"))
D4 = utils.hex_to_string(local_device.get_parameter("D4"))
D5 = utils.hex_to_string(local_device.get_parameter("D5"))
D8 = utils.hex_to_string(local_device.get_parameter("D8"))
D9 = utils.hex_to_string(local_device.get_parameter("D9"))
P0 = utils.hex_to_string(local_device.get_parameter("P0"))
P1 = utils.hex_to_string(local_device.get_parameter("P1"))
P2 = utils.hex_to_string(local_device.get_parameter("P2"))
P3 = utils.hex_to_string(local_device.get_parameter("P3"))
P4 = utils.hex_to_string(local_device.get_parameter("P4"))
if HV == Hardware_Extended:
P5 = utils.hex_to_string(local_device.get_parameter("P5"))
P6 = utils.hex_to_string(local_device.get_parameter("P6"))
P7 = utils.hex_to_string(local_device.get_parameter("P7"))
P8 = utils.hex_to_string(local_device.get_parameter("P8"))
P9 = utils.hex_to_string(local_device.get_parameter("P9"))
PR = utils.hex_to_string(local_device.get_parameter("PR"))
PD = utils.hex_to_string(local_device.get_parameter("PD"))
LT = utils.hex_to_string(local_device.get_parameter("LT"))
RP = utils.hex_to_string(local_device.get_parameter("RP"))
# I/O Sampling
IR = utils.hex_to_string(local_device.get_parameter("IR"))
IC = utils.hex_to_string(local_device.get_parameter("IC"))
Vplus = utils.hex_to_string(local_device.get_parameter("V+"))
#print parameters
log= " +-----------------------------+\n"
log= log + " | Networking |\n"
log = log + " +-----------------------------+\n"
log = log + " PAN ID: %s" % ID + "\n"
log = log + " Scan Channel: %s" % SC + "\n"
log = log + " Scan Duration: %s" % SD + "\n"
log = log + " Network Watchdog Timeout: %s" % NW + "\n"
log = log + " Channel Verification: %s" % JV + "\n"
log = log + " Join Notification: %s" % JN + "\n"
log = log + " Operating PAN ID: %s" % OP + "\n"
log = log + " Operating 16-bit PAN ID: %s" % OI + "\n"
log = log + " Operating Channel: %s" % CH + "\n"
log = log + " Number of Remaining Children:%s" % NC + "\n"
log = log + " Coordinator Enable: %s" % CE + "\n"
log = log + " Device Options: %s" % DO + "\n"
log = log + " Device Controls: %s" % DC + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | Addressing |\n"
log = log + " +-----------------------------+\n"
log = log + " Serial Number High: %s" % SH + "\n"
log = log + " Serial Number Low: %s" % SL + "\n"
log = log + " 16-bit Network Address: %s" % MY + "\n"
log = log + " 16-bit Parent Address: %s" % MP + "\n"
log = log + " Destination Address High: %s" % DH + "\n"
log = log + " Destination Address Low: %s" % DL + "\n"
log = log + " Node Identifier: %s" % NI + "\n"
log = log + " Maximum Hops: %s" % NH + "\n"
log = log + " Broadcast Radius: %s" % BH + "\n"
log = log + " Many-to-One Route Bro. Time: %s" % AR + "\n"
log = log + " Device Type Identifier: %s" % DD + "\n"
log = log + " Node Discovery Backoff: %s" % NT + "\n"
log = log + " Node Discovery Options: %s" % NO + "\n"
log = log + " Maximum Num.Trans. Bytes: %s" % NP + "\n"
log = log + " PAN Conflict Threshold: %s" % CR + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | ZigBee Addressing |\n"
log = log + " +-----------------------------+\n"
log = log + " Zigbee Source Endpoint: %s" % SE + "\n"
log = log + " Zigbee Destination Endpoint: %s" % DE + "\n"
log = log + " Zigbee Cluster ID: %s" % CI + "\n"
log = log + " Transmit Options: %s" % TO + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | RF Interfacing |\n"
log = log + " +-----------------------------+\n"
log = log + " Tx Power Level: %s" % PL + "\n"
log = log + " Power Mode: %s" % PM + "\n"
log = log + " Power at PL4: %s" % PP + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | Security |\n"
log = log + " +-----------------------------+\n"
log = log + " Encryption Enable: %s" % EE + "\n"
log = log + " Encryption Options: %s" % EO + "\n"
log = log + " Encryption Key: %s" % KY + "\n"
log = log + " Network Encryption Key: %s" % NK + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | Serial Interfacing |\n"
log = log + " +-----------------------------+\n"
log = log + " Baud Rate: %s" % BD + "\n"
log = log + " Parity: %s" % NB + "\n"
log = log + " Stop Bits: %s" % SB + "\n"
log = log + " Packetization Timeout: %s" % RO + "\n"
log = log + " DIO6/nRTS Configuration : %s" % D6 + "\n"
log = log + " DIO7/nCTS Configuration: %s" % D7 + "\n"
log = log + " API Enable: %s" % AP + "\n"
log = log + " API Output Mode: %s" % AO + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | AT Command Options |\n"
log = log + " +-----------------------------+\n"
log = log + " AT Command Mode Timeout: %s" % CT + "\n"
log = log + " Guard Times: %s" % GT + "\n"
log = log + " Command Sequence Character: %s" % CC + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | Sleep Modes |\n"
log = log + " +-----------------------------+\n"
log = log + " Cyclic Sleep Period: %s" % SP + "\n"
log = log + " Number of Cyclic Sleep Per.: %s" % SN + "\n"
log = log + " Sleep Mode: %s" % SM + "\n"
log = log + " Time Before Sleep:sss %s" % ST + "\n"
log = log + " Sleep Options: %s" % SO + "\n"
log = log + " Wake Hosts: %s" % WH + "\n"
log = log + " Poll Rate: %s" % PO + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | I/O Settings |\n"
log = log + " +-----------------------------+\n"
log = log + " DIO0/ADO/CB Configuration: %s" % D0 + "\n"
log = log + " DIO1/AD1 Configuration: %s" % D1 + "\n"
log = log + " DIO2/AD2 Configuration: %s" % D2 + "\n"
log = log + " DIO3/AD3 Configuration: %s" % D3 + "\n"
log = log + " DIO4 Configuration: %s" % D4 + "\n"
log = log + " DIO5 Configuration: %s" % D5 + "\n"
log = log + " DIO8 Configuration: %s" % D8 + "\n"
log = log + " DIO9 Configuration: %s" % D9 + "\n"
log = log + " DIO10 Configuration: %s" % P0 + "\n"
log = log + " DIO11 Configuration: %s" % P1 + "\n"
log = log + " DIO12 Configuration: %s" % P2 + "\n"
log = log + " DIO13 Configuration: %s" % P3 + "\n"
log = log + " DIO14 Configuration: %s" % P4 + "\n"
if HV == Hardware_Extended:
log = log + " DIO15 Configuration: %s" % P5 + "\n"
log = log + " DIO16 Configuration: %s" % P6 + "\n"
log = log + " DIO17 Configuration: %s" % P7 + "\n"
log = log + " DIO18 Configuration: %s" % P8 + "\n"
log = log + " DIO19 Configuration: %s" % P9 + "\n"
log = log + " Pull-UP Resistor Enable: %s" % PR + "\n"
log = log + " Pull-Up/down Direction: %s" % PD + "\n"
log = log + " Associate LED Blink Time: %s" % LT + "\n"
log = log + " RSSI PWM Timer: %s" % RP + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | I/O Sampling |\n"
log = log + " +-----------------------------+\n"
log = log + " IO Sampling Rate: %s" % IR + "\n"
log = log + " Digital IO Change Detection: %s" % IC + "\n"
log = log + " Supply Votage High Thres.: %s" % Vplus + "\n\n"
log = log + " +-----------------------------+\n"
log = log + " | Diagnostic Commands |\n"
log = log + " +-----------------------------+\n"
log = log + " Firmaware Version: %s" % VR + "\n"
log = log + " Hardware Version: %s" % HV + "\n"
log = log + " Association Indication: %s" % AI + "\n"
log = log + " RSSI of Last Packet: %s" % DB + "\n"
except:
if local_device.is_open():
local_device.close()
log ="Sorry an error has happened"
pass
finally:
if local_device is not None and local_device.is_open():
local_device.close()
pass
return log
