def publisher(xbee):
'''Xbee station'''
#****************************************************************************************#
# TODO: Replace with the serial port where your local module is connected to.
PORT = "/dev/ttyUSB0" #La estacion
# TODO: Replace with the baud rate of your local module.
BAUD_RATE = 9600
REMOTE_NODE_ID = "vtecboat" #El remoto es el bote, Esta es la estacion
#****************************************************************************************#
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)
if remote_device is None:
print("Could not find the remote device")
exit(1)
print(" +--------------------------------------+")
print(" | Give 1 to receive GPS coords |")
print(" | Give 2 to send target coords |")
print(" | Give 3 to autonomous nav 1 |")
print(" | Give 4 to autonomous nav 2 |")
print(" | Give 5 to path planning |")
print(" +--------------------------------------+\n")
action = input("action: ")
xbee.set_action(action)
if action == '1':
xbee.set_target('0.000', '0.000')
elif action == '2':
print(
"Dame la latitud y longitud del waypoint donde se iniciara el challenge: "
)
lat = input("\n lat: ")
lon = input("\n lon: ")
xbee.set_target(lat, lon)
elif action == '5':
#path planning
print("path plan")
device.send_data(remote_device, xbee.send())
while True:
xbee_message = device.read_data()
if xbee_message is not None:
jmessage = json.loads(bytes(
xbee_message.data).decode()) ###### Guarda el json
print(jmessage) #Imprime el json para prueba
print("\n")
xbee_network = device.get_network()
remote_device = xbee_network.discover_device(REMOTE_NODE_ID)
action = input("action: ")
xbee.set_action(action)
if action == '1':
xbee.set_target('0.000', '0.000')
elif action == '2':
print(
"Dame la latitud y longitud del waypoint donde se iniciara el challenge: "
)
lat = input("\n lat: ")
lon = input("\n lon: ")
xbee.set_target(lat, lon)
elif action == '5':
#path planning
print("path plan")
device.send_data(remote_device, xbee.send())
print("Success")
finally:
if device is not None and device.is_open():
device.close()
def get_parameter(xbee: XBeeDevice, param: str) -> str:
return utils.hex_to_string(xbee.get_parameter(param))
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 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
lightADC = IOLine.DIO1_AD1
tempADC = IOLine.DIO2_AD2
humidityADC = IOLine.DIO3_AD3
# IMPORTANT: Set these to the port that
# your coordinator is connected to and
# its baud rate.
port = "/dev/ttyUSB0"
baud = 9600
# IMPORTANT: Set these to the Node Identifiers (NI)
# for your remote sensors. The NI can be set
# with Digi's XCTU application.
node_ids = ["SENSE1", "SENSE2", "SENSE3"]
local_device = XBeeDevice(port, baud)
local_device.open()
# Obtain the remote XBee device from the XBee network.
net = local_device.get_network()
sensors = [net.discover_device(node) for node in node_ids]
# Set up TCP socket
host = ''
port = 12000
TCPSock = socket(AF_INET, SOCK_STREAM)
TCPSock.bind((host, port))
connected = False
while True:
if not connected:
print("Waiting for a connection...")
def data_call(self):
device = XBeeDevice(self.config.port, self.config.baudrate)
return device
def main():
def read_adc_task(indice):
global systembusy
while True or intentos[indice] < MAX_INTENTOS_LEER_DATOS:
try:
print("entro hilo")
lock.acquire()
print(threading.current_thread().getName())
# Leemos el valor del nodo para luego calcular el valor de la resistencia del termistor mediante la
# ley de Ohm para un divisor de tensión
#time.sleep(1)
vcc = nodos_activos[indice].get_parameter("%V")
vcc = int(utils.hex_to_string(vcc).replace(' ', ''), 16)
# Leemos el valor crudo de las entradas analógicas
raw_value_1 = nodos_activos[indice].get_adc_value(IOLINE_IN_0)
raw_value_2 = nodos_activos[indice].get_adc_value(IOLINE_IN_1)
raw_value_3 = nodos_activos[indice].get_adc_value(IOLINE_IN_2)
raw_value_4 = nodos_activos[indice].get_adc_value(IOLINE_IN_3)
# Calculamos el valor de temperatura en cada entrada en función de la tensión de alimentación y del
# valor crudo
#print("Nodo %s" % nodos_activos[indice])
tntc_1 = ntc10k_calculate_temp(raw_value_1, vcc)
tntc_2 = ntc10k_calculate_temp(raw_value_2, vcc)
tntc_3 = ntc10k_calculate_temp(raw_value_3, vcc)
tntc_4 = ntc10k_calculate_temp(raw_value_4, vcc)
# ************************************************************************
# ESTA ES LA PARTE DE TELEGRAF
intentos[indice] = 0
print(str(datetime.now()))
send_data_to_telegraf.main(REMOTE_NODES_ID[indice], tntc_1,
tntc_2, tntc_3, tntc_4, float(vcc))
print("Telegraf!")
# Esperamos hasta la siguiente toma de muestras
espera[indice] = LONG_WAIT
print("Systembusy: %s" % systembusy)
print("indice %s" % indice)
print("Nodos esperas %s" % espera)
lock.release()
#except TimeoutException as ex:
except:
intentos[indice] += 1
lock.release()
espera[indice] = SHORT_WAIT
print(REMOTE_NODES_ID[indice])
print("Systembusy: %s" % systembusy)
print("ADC timeouts %s" % intentos)
print("Nodos esperas %s" % espera)
if intentos[indice] > MAX_INTENTOS_LEER_DATOS:
#th[indice].join()
raise
#print("Espera: %s" % espera)
print(espera[indice])
time.sleep(espera[indice])
def status():
global systembusy
while True:
print("Systembusy: %s" % systembusy)
time.sleep(1)
index_devices = 0
th = []
nodos_activos = []
intentos = []
print("Cantidad de nodos: %s" % len(REMOTE_NODES_ID))
try:
local_device = XBeeDevice(port, baud_rate)
xbee_network = local_device.get_network()
local_device.open()
th2 = threading.Thread(name='log', target=status)
#th2.start()
for index in range(0, len(REMOTE_NODES_ID)):
nodo_descubierto = False
intentos.append(0)
# Procedimiento de descubrimiento de nodos, ver que pasa si uno está apagado
while (nodo_descubierto !=
True) and intentos[index] < MAX_INTENTOS_DESCUBRIMIENTO:
remote_device = (xbee_network.discover_device(
REMOTE_NODES_ID[index]))
if remote_device is None:
print("Could not find the remote device: " +
REMOTE_NODES_ID[index]
) # ESTOY HAY QUE VER COMO SE HACE
intentos[index] += 1
print("Nodo: %s" % (REMOTE_NODES_ID[index]))
print("Intentos descubrimiento restantes: %s" %
(MAX_INTENTOS_DESCUBRIMIENTO - intentos[index]))
time.sleep(1)
else:
nodos_activos.append(remote_device)
index_devices += 1
print('Descubierto: %s' % remote_device)
nodo_descubierto = True
#ejecución de los hilos
for index in range(0, index_devices):
thread = threading.Thread(name=nodos_activos[index],
target=read_adc_task,
args=(index, ))
th.append(thread)
intentos = []
espera = []
for index in range(0, index_devices):
intentos.append(0)
espera.append(SHORT_WAIT)
th[index].start()
th[index].join()
time.sleep(1)
except:
print("eRRor")
finally:
for index in range(0, index_devices):
if th[index] is not None and th[index].isAlive():
th[index].join()
if local_device.is_open():
local_device.close()
exit(-1)
def connect(self):
self.device = XBeeDevice(self.PORT, self.BAUD_RATE)
from digi.xbee.devices import XBeeDevice
from digi.xbee.devices import RemoteXBeeDevice
from digi.xbee.models.address import XBee64BitAddress
import time
#Import regarding scheduler tasks
from apscheduler.schedulers.background import BackgroundScheduler
# define background scheduler
sched = BackgroundScheduler()
PORT = '/dev/ttyUSB0'
BAUD_RATE = 9600
DRONE_ID = "0013A200419B5208"
DATA_TO_SEND = "Hello World:"
my_device = XBeeDevice(PORT, BAUD_RATE)
count = 0
my_device.open()
def send_data():
global count
count = count + 1
remote_device = RemoteXBeeDevice(
my_device, XBee64BitAddress.from_hex_string(DRONE_ID))
my_device.send_data(remote_device, DATA_TO_SEND + str(count))
sched.add_job(send_data, 'interval', seconds=1)
sched.start()
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
from digi.xbee.devices import XBeeDevice
import serial
import time
import threading
import queue
import struct
import datetime
GPS_PORT = '/dev/serial/by-id/usb-FTDI_USB_Serial_Converter_FT8VW9AR-if00-port0' #Pi ADCP
xbee_port = '/dev/serial/by-id/usb-FTDI_FT231X_USB_UART_DN02Z3LX-if00-port0' #Pi xbee
COM_PORT = '/dev/serial/by-id/usb-FTDI_USB_Serial_Converter_FT8VWDWP-if00-port0'
BAUD_RATE = "115200"
ADCP_ser = serial.Serial(COM_PORT, BAUD_RATE, stopbits=serial.STOPBITS_ONE)
GPS_ser = serial.Serial(GPS_PORT, bytesize=8)
boat_xbee = XBeeDevice(xbee_port, 9600)
adcp_filename = 'Log/ADCP_' + datetime.datetime.now().replace(
microsecond=0).strftime('%y-%m-%d %H.%M.%S') + '.bin'
gps_filename = 'Log/GPS_' + datetime.datetime.now().replace(
microsecond=0).strftime('%y-%m-%d %H.%M.%S') + '.txt'
f = open(adcp_filename, 'wb')
gps_f = open(gps_filename, 'w')
###############################################################################
# GPS Setup Function
###############################################################################
def GPS_setup(gps_ser):
gps_ser.baudrate = 19200
gps_ser.parity = serial.PARITY_NONE
import random
import os
from digi.xbee.devices import XBeeDevice
from digi.xbee.devices import RemoteXBeeDevice
from digi.xbee.models.address import XBee64BitAddress
from digi.xbee.models.status import TransmitStatus
import tkinter as tk
from tkinter import *
from tkinter import font
import sys
import datetime
import time
Tx = XBeeDevice("COM5", 9600)
Rx1 = RemoteXBeeDevice(Tx,
XBee64BitAddress.from_hex_string("0013A200416411DF"))
Rx2 = RemoteXBeeDevice(Tx,
XBee64BitAddress.from_hex_string("0013A20041630A75"))
Rx3 = RemoteXBeeDevice(Tx,
XBee64BitAddress.from_hex_string("0013A200418B68F8"))
Tx.open()
window = tk.Tk()
window.title('LMU AirLions')
#You can set the geometry attribute to change the root windows size
window.geometry("1000x1000") #You want the size of the app to be 500x500
back = tk.Frame(window, bg='black')
window.configure(background='black')
# Codigo desarrollado por Francisco Jose Lara.
# NODO-ROUTER
#Librerias
import serial, time, sys
from digi.xbee.devices import XBeeDevice, RemoteXBeeDevice
from digi.xbee.models.address import XBee64BitAddress, XBee16BitAddress
from digi.xbee.packets.common import TransmitPacket
from digi.xbee.packets.raw import TX64Packet
from digi.xbee.util import utils
import struct
#Inicio XBee Device
device = XBeeDevice("/dev/serial0", 9600)
device.open()
print("-- Dispositivo abierto --")
while 1:
#Leer
mens = None
print("\nEsperando peticion de datos...\n")
while mens == None:
# Recivo de coordinador
mens = device.read_data()
#print(".")
time.sleep(0.5)
# Decodifico mensaje
com = mens.data.decode("utf8")
print("Peticion decodificada: ", com, "\n")
if com == 'Fin':
break
def main():
print(" +-----------------------------------------+")
print(" | XBee Python Library Receive Data Sample |")
print(" +-----------------------------------------+\n")
device = XBeeDevice(PORT, BAUD_RATE)
#remote_device=RemoteXBeeDevice(device,XBee64BitAddress.from_hex_string(REMOTE_NODE_ID))
try:
device.open()
def data_receive_callback(xbee_message):
data = xbee_message.data
command = [
int.from_bytes(data[:2], "big"),
int.from_bytes(data[2:3], "big"),
int.from_bytes(data[3:4], "big"),
int.from_bytes(data[5:6], "big"),
int.from_bytes(data[6:7], "big")
]
print("Data[0]:", command[0])
print("Data[1]:", command[1])
print("Data[2]:", command[2])
print("Data[3]:", command[3])
print("Data[4]:", command[4])
temperature, pressure, humidity = readBME280All()
if command[1] == 3:
if command[2] == 1:
if command[0] == 1:
#teste="teste2"
remote_device = RemoteXBeeDevice(
device,
XBee64BitAddress.from_hex_string(
"0000000000000000"))
print("Temp = {0:0.3f} Deg C", temperature,
float.hex(temperature),
float.fromhex(float.hex(temperature)))
# Send data using the remote object.
print("", float.fromhex(float.hex(temperature)))
print("" + float.hex(temperature))
device.send_data(remote_device,
'' + float.hex(temperature))
if command[0] == 2:
print("Press = {0:0.3f}", pressure,
float.hex(pressure),
float.fromhex(float.hex(pressure)))
remote_device = RemoteXBeeDevice(
device,
XBee64BitAddress.from_hex_string(
"0000000000000000"))
# Send data using the remote object.
print("", float.fromhex(float.hex(pressure)))
print("" + float.hex(pressure))
device.send_data(remote_device,
'' + float.hex(pressure))
if command[0] == 3:
print("Humity = {0:0.3f} %", humidity,
float.hex(humidity),
float.fromhex(float.hex(humidity)))
remote_device = RemoteXBeeDevice(
device,
XBee64BitAddress.from_hex_string(
"0000000000000000"))
# Send data using the remote object.
print("", float.fromhex(float.hex(humidity)))
print("" + float.hex(humidity))
device.send_data(remote_device,
'' + float.hex(humidity))
#if command[0]==4:
if command[1] == 1:
if command[2] == 2:
if command[4] == 1:
print("Meta-TEDS")
device.add_data_received_callback(data_receive_callback)
print("Waiting for data...\n")
input()
finally:
if device is not None and device.is_open():
device.close()
class XBee:
_buffer = ExpiringDict(default_ttl=120)
def __init__(self, port: str, baud_rate: int = 9600):
self._device = XBeeDevice(port, baud_rate)
@classmethod
def _normalize_data(self, data: typing.Union[bytearray, bytes]):
if isinstance(data, bytes):
data = bytearray(data)
return data
def open(self):
self._device.open()
self._device.add_data_received_callback(self._on_data_received)
def close(self):
self._device.close()
def send_broadcast(self, data: typing.Union[bytearray, bytes]):
data = self._normalize_data(data)
self._device.send_data_broadcast(data)
def send(self, remote_address: bytearray, data: typing.Union[bytearray, bytes]):
data = XBee._normalize_data(data)
remote_device = RemoteXBeeDevice(self._device, x64bit_addr=XBee64BitAddress(remote_address))
id = random.randint(0, 4000000)
init_frame = InitFrame(id=id, size=len(data))
self._device.send_data(remote_device, init_frame.serialize())
sent = 0
while sent < len(data):
s = data[sent:sent + 50]
frame = Frame(id=id, data=s)
self._device.send_data(remote_device, frame.serialize())
sent += len(s)
async def discover_first_remote_device(self, discovery_timeout=25) -> typing.Optional[bytearray]:
network = self._device.get_network()
network.set_discovery_timeout(discovery_timeout)
network.start_discovery_process()
await asyncio.sleep(1)
while network.is_discovery_running() and not network.get_devices():
await asyncio.sleep(1)
network.stop_discovery_process()
devices = network.get_devices()
return get_address(devices[0]) if devices else None
def on_message_received(self, remote_address: bytearray, data: bytearray):
pass
def _on_data_received(self, message):
if message.is_broadcast:
# there are no support for fragmentation of broadcast messages yet :(
return self.on_message_received(get_address(message.remote_device), message.data)
init_frame = InitFrame.deserialize(message.data)
try:
if init_frame.id in self._buffer:
frame = Frame.deserialize(message.data)
self._buffer[frame.id][1].extend(frame.data)
full_size = self._buffer[frame.id][0]
if len(self._buffer[frame.id][1]) >= full_size:
self.on_message_received(get_address(message.remote_device), self._buffer[frame.id][1][:full_size])
del self._buffer[frame.id]
else:
self._buffer[init_frame.id] = [init_frame.size, bytearray()]
except Exception as e:
logger.error(e)
self._buffer.pop(init_frame.id, None)
class Antenna:
def __init__(self, port="", remote_address="", verbose=False):
self.verbose = verbose
if port == "":
port = self.find_port()
self.port = port
self.verbose_print(f"Port: {self.port}")
self.last_time_sent = 0
if self.port != "" and remote_address != "":
self.device = XBeeDevice(self.port, 9600)
self.active = True
self.has_remote = True
try:
self.device.open()
except:
self.active = False
try:
add_64 = (XBee64BitAddress.from_hex_string(remote_address))
self.remote_device = RemoteXBeeDevice(self.device, add_64)
except Exception as e:
self.has_remote = False
print("Error on remote device: ", e)
else:
self.active = False
self.device = None
def find_port(self):
ports = prtlst.comports()
for port in ports:
try:
if "FTDI" in port.manufacturer:
return port.device
except Exception:
pass
return ""
def send(self,
data,
time=None,
data_key=None,
skip_time=0,
parent="",
as_json=False):
"""
Recursively send asynchronous data.
"""
if as_json:
data = loads(data)
# Update Time
if time == None:
time = unixtimestamp()
#self.last_time_sent = time
# Skip if time buffer too low
if skip_time != 0:
if time - self.last_time_sent < skip_time:
return None
self.last_time_sent = time
if self.active:
try:
if type(data) == dict:
for key in data:
parent = "" if data_key == None else data_key
self.send(data[key],
time=time,
data_key=key,
parent=parent)
else:
send_data = {
"uts": time,
f"{parent}_{str(data_key)}": data
}
to_send = dumps(send_data).encode()
self.device.send_data_async(self.remote_device, to_send)
except Exception as e:
self.verbose_print(f"COULDN'T SEND {data}, ERROR {e}")
return None
def verbose_print(self, message):
if self.verbose:
print(message)
def read_time(self, time=None):
if not self.active:
return "{}"
try:
d = self.device.read_data(time)
if d is None:
return "{}"
return d.data.decode()
except Exception as e:
print(f"[low_level/low_comm.py]: {e}")
return "{}"
def __init__(self, port: str, baud_rate: int = 9600):
self._device = XBeeDevice(port, baud_rate)
from digi.xbee.devices import XBeeDevice, XBee64BitAddress, RemoteXBeeDevice
import time
device = XBeeDevice("COM7", 9600)
device.open()
device.set_sync_ops_timeout(10)
remote_device = RemoteXBeeDevice(device, XBee64BitAddress.from_hex_string("0013A20041C7BFFC"))
while(1):
device.send_data(remote_device, "Data")
print("sent")
time.sleep(3)
device.close()
def main():
print(" +----------------------------------+")
print(" | Image send test - Xbee to Python |")
print(" +----------------------------------+\n")
Overallstart = time.time()
dir = "/Users/IEEE/Desktop/Hog-pics/"
pics = os.listdir("/Users/IEEE/Desktop/Hog-pics")
device = XBeeDevice(PORT, BAUD_RATE)
for img in pics: #put everything in this loop so you until you send all the pic in the dir
with open(dir + img, 'rb') as image:
t0 = time.time()
f = image.read()
teststring = base64.b64encode(f)
test1 = teststring.decode("utf-8")
first_message = MessageBuffer()
first_message.msg_type = 'BN'
first_message.file_size = len(test1)
first_message.offset = 0
first_message.buffer = img # filename
s = first_message.firstmsg()
print(s)
try:
device.open()
device.send_data_broadcast(s)
message = MessageBuffer()
place = 0
headersize = 0
MAXbuffersize = 256
buffersize = 0
next_sting = 0
packetcount = 0
while place < first_message.file_size:
if first_message.file_size - place > 255:
message.msg_type = 'DT'
else:
message.msg_type = 'ED'
message.offset = place
headersize = message.getheadersize()
buffersize = MAXbuffersize - headersize
next_sting = buffersize + next_sting
message.buffer = test1[message.offset:next_sting]
place = buffersize + place
q = message.prepmsg()
#print(q)
device.send_data_broadcast(q)
packetcount = packetcount + 1
t1 = time.time()
total = t1 - t0
print("Success")
print("Number of Packets: " + str(packetcount))
print("Time for Image " + first_message.buffer + ": " +
str(total))
print("Size for Image " + first_message.buffer + ": " +
str(first_message.file_size))
finally:
if device is not None and device.is_open():
device.close()
Overallend = time.time()
overall = Overallend - Overallstart
print("Overall time = " + str(overall))
def main():
coord = XBeeDevice('COM7', 9600) # Create XBeeDevice object for the coordinator at COM7 with Baud Rate 9600
try:
coord.open() # Open communication with the XBee device
coord.flush_queues()
xbee_network = coord.get_network() # Get the network that coord is connected to
router2 = xbee_network.discover_device('R2') # Find the remote device on the network with ID 'R2'
if router2 is None: # If we could not find R2 then the program will continue to run
print("Could not find the remote alert device (R2)")
else :
print("Remote alert device (R2) found")
timestamp, date, time_ = getTime(True)
with open(".\\logs\\{0}-{1}.log".format(date, time_), mode="a") as myFile: # Creates a new log file
myFile.write("# Date\t\tTime\t\tTimestamp\tTemperature\tHumidity\n")
while True:
xbee_message = coord.read_data() # Read the data from R1 on the Sensor Arduino
if xbee_message is not None:
timestamp, date, time_ = getTime() # Get the time
data_raw = xbee_message.data.decode().split(",") # Turn the sensor data into a list
data = [float(element) for element in data_raw] # Turn each element of data_raw into a float
dataToSend = ""
# Temperature
print("\nAt {0} {1} Temperature is {2}".format(date, time_, data[0]), end=": ")
if data[0] > 24.65:
print("Unsafe")
dataToSend += "T1"
stateT = "U"
else:
print("Safe")
dataToSend += "T0"
stateT = "S"
## Pressure
#print("At {0} {1} Pressure is {2}".format(date, time_, data[1]), end=": ")
#if data[1] > 1000:
# print("Unsafe")
# dataToSend += "P1"
# stateP = "U"
#else:
# print("Safe")
# dataToSend += "P0"
# stateP = "S"
# Humidity
print("At {0} {1} Humidity is {2}".format(date, time_, data[2]), end=": ")
if data[2] > 70:
print("Unsafe")
dataToSend += "H1"
stateH = "U"
else:
print("Safe")
stateH = "S"
dataToSend += "H0"
if router2 is not None:
coord.send_data(router2, dataToSend)
text = "{0}\t{1}\t{2}\t{3}{4}\t\t{5}{6}\n".format(date, time_, timestamp, stateT, data[0], stateH, data[2])
myFile.write(text)
finally:
if coord is not None and coord.is_open(): # Closes the communications to the coordinator when the program closes
coord.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 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):
data = self.device.read_data()
if data is not None:
# we have an XBeeMessage object
return {'payload': bytes(data.data)}
else:
return None # None = no data w/in timeout (set to zero for instant)
def main():
class ReadAD:
def __init__(self, start=0):
self.lock = threading.Lock()
self.value = start
def read_AD(self, indice):
logging.debug('Waiting for lock')
self.lock.acquire()
try:
self.timeout = False
logging.debug('Acquired lock')
vcc = nodos_activos[indice].get_parameter("%V")
vcc = int(utils.hex_to_string(vcc).replace(' ', ''), 16)
# Leemos el valor crudo de las entradas analógicas
raw_value_1 = nodos_activos[indice].get_adc_value(IOLINE_IN_0)
raw_value_2 = nodos_activos[indice].get_adc_value(IOLINE_IN_1)
raw_value_3 = nodos_activos[indice].get_adc_value(IOLINE_IN_2)
raw_value_4 = nodos_activos[indice].get_adc_value(IOLINE_IN_3)
# Calculamos el valor de temperatura en cada entrada en función de la tensión de alimentación y del
tntc_1 = ntc10k_calculate_temp(raw_value_1, vcc)
tntc_2 = ntc10k_calculate_temp(raw_value_2, vcc)
tntc_3 = ntc10k_calculate_temp(raw_value_3, vcc)
tntc_4 = ntc10k_calculate_temp(raw_value_4, vcc)
# ************************************************************************
# ESTA ES LA PARTE DE TELEGRAF
send_data_to_telegraf.main(REMOTE_NODES_ID[indice], tntc_1,
tntc_2, tntc_3, tntc_4, float(vcc))
except TimeoutException:
self.timeout = True
logging.debug('ADC error')
local_device.reset()
finally:
self.lock.release()
return self.timeout
# función que realiza las tareas de lectura de las entradas en los nodos
timeouts = []
def worker(c, i):
#La petición se hace con tiempo variable, si no responde, esto es si da timeout se hacen más rápidas para ver
#si el nodo estaba en una secuencia de sueño, si sobre pasa el límite de timeouts cortos ya no se le pregunta más
timeouts.append(0)
try:
while True and (timeouts[i] < MAX_INTENTOS_LEER_DATOS):
logging.debug('Stamp: %s', str(datetime.now()))
logging.debug("TIMEOUTS %s",
timeouts) #estudiar bien esto y quitar
if c.read_AD(i):
timeouts[i] += 1
logging.debug("Timeouts %s", timeouts)
pause = SHORT_WAIT
else:
#timeouts[i] = 0 #reseteamos la cuenta de timeouts
pause = LONG_WAIT
logging.debug('Sleeping %0.02f', pause)
time.sleep(pause)
except ValueError:
logging.debug('Worker error')
# función que realiza el procedimiento de descubrimiento de los nodos listado en el archivo list_of_nodes.ini
nodos_activos = []
def descubre_nodos():
index_devices = 0
try:
for index in range(0, len(REMOTE_NODES_ID)):
nodo_descubierto = False
intentos_descubir = 0
while (nodo_descubierto != True
) and intentos_descubir < MAX_INTENTOS_DESCUBRIMIENTO:
remote_device = (xbee_network.discover_device(
REMOTE_NODES_ID[index]))
if remote_device is None:
logging.debug('Could not find the remote device: %s',
REMOTE_NODES_ID[index])
intentos_descubir += 1
logging.debug("Nodo: %s", (REMOTE_NODES_ID[index]))
logging.debug(
'Intentos descubrimiento restantes: %s',
(MAX_INTENTOS_DESCUBRIMIENTO - intentos_descubir))
time.sleep(1)
else:
nodos_activos.append(remote_device)
index_devices += 1
logging.debug('Descubierto: %s', remote_device)
nodo_descubierto = True
except:
logging.debug('Error proceso descubrimiento')
# Configuracíon de la salida del log
logging.basicConfig(
level=logging.DEBUG,
format='(%(threadName)-10s) %(message)s',
)
# Conexión al nodo local
local_device = XBeeDevice(port, baud_rate)
xbee_network = local_device.get_network()
local_device.open()
local_device.set_sync_ops_timeout(40)
descubre_nodos()
try:
lectura = ReadAD()
# Creación de un hilo por cada nodo activo
for i in range(len(nodos_activos)):
logging.debug('creando hilo')
t = threading.Thread(name=nodos_activos[i],
target=worker,
args=(
lectura,
i,
))
t.start()
if len(nodos_activos) == 0:
logging.debug('No nodes found')
sys.exti(-1)
else:
logging.debug('Waiting for worker threads')
main_thread = threading.main_thread()
for t in threading.enumerate():
if t is not main_thread:
t.join()
logging.debug('Counter: %d', lectura.value)
except:
logging.debug('exept')
sys.exit(1)
def main():
print(" +----------------------------------------------------------+")
print(" | XBee Python Library Network modifications Devices Sample |")
print(" +----------------------------------------------------------+\n")
xbee_network = None
xbee = XBeeDevice(PORT, BAUD_RATE)
try:
xbee.open()
xbee_network = xbee.get_network()
xbee_network.set_discovery_timeout(15) # 15 seconds.
xbee_network.add_discovery_process_finished_callback(
callback_discovery_finished)
xbee_network.add_network_modified_callback(cb_network_modified)
print("* Discover remote XBee devices...")
xbee_network.start_discovery_process()
while xbee_network.is_discovery_running():
time.sleep(1)
print_nodes(xbee_network)
print("\n* Manually add a new remote XBee device...")
remote = RemoteXBeeDevice(
xbee,
x64bit_addr=XBee64BitAddress.from_hex_string("1234567890ABCDEF"),
node_id="manually_added")
xbee_network.add_remote(remote)
print_nodes(xbee_network)
time.sleep(1)
print("\n* Update the last added remote XBee device...")
remote = RemoteXBeeDevice(xbee,
x64bit_addr=remote.get_64bit_addr(),
node_id="updated_node")
xbee_network.add_remote(remote)
print_nodes(xbee_network)
time.sleep(1)
print("\n* Manually remove a remote XBee device...")
xbee_network.remove_device(remote)
print_nodes(xbee_network)
time.sleep(1)
print("\n* Clear network...")
xbee_network.clear()
print_nodes(xbee_network)
finally:
if xbee_network is not None:
xbee_network.del_discovery_process_finished_callback(
callback_discovery_finished)
xbee_network.del_network_modified_callback(cb_network_modified)
if xbee is not None and xbee.is_open():
xbee.close()
def shutdown_cleanly(xbee: XBeeDevice) -> Error:
"""
Helper function to attempt to cleanly shut down the XBee.
Note that only XBee 3 Cellular devices require a clean shutdown; this function
behaves as a NOP for XBee 3 Zigbee/802.15.4/DigiMesh devices.
You should invoke this function prior to issuing the ATFR command or removing power to the XBee.
Otherwise, you risk corrupting/bricking the XBee's cell modem chip.
For more info, see the "Clean shutdown" page in the XBee3 Cellular User Guide:
https://www.digi.com/resources/documentation/Digidocs/90002258/#Reference/r_clean_shutdown.htm
This function assumes that the XBee is currently in API Mode Without Escapes.
The clean shutdown is performed by issuing the XBee 3 Cellular ATSD (Shutdown) command to the XBee module.
Note that on XBee 3 Zigbee and 802.15.4 devices, the ATSD command does something completely different
(SD = Scan Duration).
Note that ATSD command does NOT put the XBee 3 Cellular device to sleep. Rather, it simply
puts the XBee module (particularly its cell modem chip) into a state in which it is safe to power off.
The XBee will continue to respond to API Frames messages even after it is in this shutdown state.
Note that the XBee 3 Cellular ATSD command takes a long time to respond, usually somewhere between
6 and 12 seconds, but it could be longer, so give it a nice long timeout, say 30 seconds, since
that is what the user guide recommends for alternate airplane mode shutdown approach.
We don't retry the shutdown command in a loop because a failure is highly unlikely.
If the shutdown command fails, we report the error, but we don't do anything else--
chances are you're still going to turn off the power no matter what, but at least
we tried to shut down so gracefully.
If the XBee 3 Cellular ATSD fails, we do attempt an alternate, fallback shutdown approach.
Note that the shutdown command (ATSD) was not introduced until the August 2019 release of
the XBee3 Cellular firmware, so older versions of firmware will need to rely upon this
alternate approach.
One approach mentioned on the [Clean shutdown page of the User Guide](
https://www.digi.com/resources/documentation/Digidocs/90002258/#Reference/r_clean_shutdown.htm)
is to de-assert the DTR_n/SLEEP_REQUEST pin and wait until the SLEEP_STATUS pin goes low.
However, if your XBee carrier board hardware was not designed with this in mind, you won't
be able to monitor this. Instead, we just wait for a specific reasonable amount of time, say 30 seconds.
After all, this is a fallback shutdown approach, and this is better than nothing.
However, there is another, bigger issue with the DTR_n/SLEEP_REQUEST approach:
this pin might not be configured as a sleep request input! In other words, the XBee register "D8"
might instead have it configured as a general-purposes digital I/O pin, in which case strobing
this pin won't work. Since I don't want to make any assumptions about how the XBee is configured,
I'm going to avoid the pin-based approach.
So instead, we will use the third shutdown approach described in the User Guide:
send the ATAM (Airplane Mode) command to put the device into airplane mode. Then we wait
30 seconds as prescribed in the User Guide to give it plenty of time to shut down.
Note that the ATAM (Airplane Mode) command gets applied immediately;
no need to subsequently send ATAC (Apply Configuration) to apply the changes.
"""
proto = xbee.get_protocol()
if proto not in (XBeeProtocol.CELLULAR, XBeeProtocol.CELLULAR_NBIOT):
log("%s: Device is not an XBee 3 Cellular; no need for clean shutdown. Bypassing clean shutdown."
% func())
return Success
xbee_atsd_timeout_sec = 30
xbee_time_to_wait_in_airplane_mode_sec = 30
log("%s: Adjusting the xbee-python command timeout value..." % func())
try:
default_timeout_sec = xbee.get_sync_ops_timeout(
) # Store default value so that we can put it back.
xbee.set_sync_ops_timeout(
xbee_atsd_timeout_sec
) # ATSD takes longer than most commands so give it extra time.
except Exception as ex:
return Error(
"%s: Failed to adjust the xbee-python command timeout value. Reason: "
% (func(), ex))
log("%s: Attempting to cleanly shut down the XBee. Sending shutdown command (ATSD)..."
% func())
try:
xbee.execute_command("SD")
log("%s: XBee shutdown command (ATSD) succeeded. Now safe to remove power from the module."
% func())
return Success
except Exception as ex:
log("%s: XBee shutdown command (ATSD) failed. Reason: %s. Will attempt fallback approach."
% (func(), ex))
finally:
xbee.set_sync_ops_timeout(default_timeout_sec)
log("%s: Attempting fallback approach to cleanly shut down. Sending ATAM command and waiting for %s seconds."
% (func(), xbee_time_to_wait_in_airplane_mode_sec))
try:
xbee.set_parameter("AM", b"\x01")
except Exception as ex:
return Error("%s: XBee ATAM command failed. Reason: %s" % (func(), ex))
time.sleep(xbee_time_to_wait_in_airplane_mode_sec)
log("%s: Done waiting for XBee to enter airplane mode. You may now remove power from the module."
% func())
return Success
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 __init__(self, path_to_device, baud_rate=9600):
self._device = XBeeDevice(path_to_device, baud_rate)
self._device.open()
from tkinter import *
import tkinter.messagebox
from digi.xbee.devices import XBeeDevice
from digi.xbee.devices import RemoteXBeeDevice
from digi.xbee.models.address import XBee64BitAddress
from digi.xbee.reader import XBeeMessage
import time
import os
from datetime import *
from tkcalendar import Calendar
import sqlite3
os.system('sudo chmod 777 /dev/ttyUSB0')
coordenador = XBeeDevice('/dev/ttyUSB0', 9600)
router1 = RemoteXBeeDevice(
coordenador, XBee64BitAddress.from_hex_string("0013A200409BAF15"))
router2 = RemoteXBeeDevice(
coordenador, XBee64BitAddress.from_hex_string("0013A200409BAF12"))
print('Done')
try:
coordenador.open()
except:
print('\n\nERRO NA COMUNICAÇÃO!\n\n')
exit()
DATABASE_EXISTS = False
if (os.path.isfile('agendamento.db') == False):
def main():
def get_parameter(xbee: XBeeDevice, param: str) -> str:
return utils.hex_to_string(xbee.get_parameter(param))
local_xbee = XBeeDevice(PORT, BAUD_RATE)
try:
local_xbee.open()
xbee_network = local_xbee.get_network()
print("Cheking network...", end='', flush=True)
xbee_network.start_discovery_process()
while xbee_network.is_discovery_running():
sleep(0.5)
xbee_devices = xbee_network.get_devices()
print("done")
print(f"""
LOCAL XBEE
- Node ID: {local_xbee.get_node_id()}
- PAN ID: {get_parameter(local_xbee, "ID")}
- Protocol: {local_xbee.get_protocol()}
- 16-bit address: {local_xbee.get_16bit_addr()}
- 64-bit address: {local_xbee.get_64bit_addr()}
- API: {get_parameter(local_xbee, "AP")}
- Encryption enabled: {get_parameter(local_xbee, "EE")}
- Hardware version: {local_xbee.get_hardware_version()}
- Firmware version: {utils.hex_to_string(local_xbee.get_firmware_version())}
NETWORK
- Remote devices: {len(xbee_devices)}
""")
for remote_device in xbee_devices:
if not (remote_device is None):
try:
remote_device.read_device_info()
except:
continue
print(f"""
REMOTE DEVICE:
- Node ID: {remote_device.get_node_id()}
- PAN ID: {get_parameter(remote_device, "ID")}
- Protocol: {remote_device.get_protocol()}
- 16-bit address: {remote_device.get_16bit_addr()}
- 64-bit address: {remote_device.get_64bit_addr()}
- API: {get_parameter(remote_device, "AP")}
- Encryption enabled: {get_parameter(remote_device, "EE")}
- Hardware version: {remote_device.get_hardware_version()}
- Firmware version: {utils.hex_to_string(remote_device.get_firmware_version())}
""")
finally:
if local_xbee is not None and local_xbee.is_open():
print("Closing device")
local_xbee.close()
'comm_error': False
}}),
qos=1,
retain=True)
MQTT.publish(topicAttr,
json.dumps({(turbineName + '_'): {
'comm_error': False
}}),
qos=1,
retain=True) #Send data to Wind Farm Observer dashboard
lastMessageTime[turbineName] = time.time(
) #record the time this message was processed in seconds since epoch.
try:
xbee = XBeeDevice(localXBeePort, 9600)
xbee.open()
xbee.add_data_received_callback(
data_receive_callback
) # Subscribe to data message reception (for power pulse count data).
xbee.add_io_sample_received_callback(
io_sample_callback) # Subscribe to IO samples reception.
print("Waiting for data...\n", file=open(standardOutput, 'a'))
while True:
for name in name2addr.keys(
): #we're going to cycle through our list of turbines to check a few things.
try: #first try to poll all of the turbines to get an update on their fault and on/off status
remote = RemoteXBeeDevice(
xbee,
XBee64BitAddress.from_hex_string(name2addr.get(name)))
io_sample_callback(remote.read_io_sample(), remote,
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()
import time #Time package gives time syncing functionality
from digi.xbee.devices import XBeeDevice #XBee package gives XBee management functionality
import pygame #Pygame package gives music playing functionality
from pygame import mixer
port = "COM7" #The port the XBee is plugged in to.
BR = 9600 #Baud rate, configured in XCTU. Should stay as 9600.
my_xbee = XBeeDevice(
port,
BR) #Declare/name the XBee that is plugged into the computer as "my_xbee"
song = "Freedom.mp3" #This is the file name of the song you're using. Make sure this song file lives in the same folder as the code.
mixer.init()
mixer.music.load(song) #Load the song
#Initialize light timing things, add as many cues as needed.
cueA = False
cueB = False
cueC = False
cueD = False
cueE = False
cueF = False
cueG = False
cueH = False
cueZ = False
mixer.music.play() #Start playing the song
while pygame.mixer.music.get_busy(): #While the music is playing,
ts = pygame.mixer.music.get_pos() / 1000.0 #Get the timestamp in the music
if (
