import os
import time
#import digi.xbee.devices
from digi.xbee.devices import XBeeDevice
from digi.xbee.devices import RemoteXBeeDevice
from digi.xbee.models.address import XBee64BitAddress
Tx = XBeeDevice("COM11", 9600) # COM port of the Receiver
Rx = RemoteXBeeDevice(Tx, XBee64BitAddress.from_hex_string("0013A20041630A6B"))
received_ack = True
Tx.open()
#def message_received(data):
xbee_message = Tx.read_data()
#if xbee_message.data == "Acknowledgment":
# print "Acknowledgment received"
# global recieved_ack
# recieved_ack = True
def my_data_received_callback(xbee_message):
address = xbee_message.remote_device.get_64bit_addr()
data = xbee_message.data.decode("utf8")
if data == "Transmitting":
print("Received data from %s: %s" % (address, data))
global received_ack
received_ack = True
# Add the callback.
Tx.add_data_received_callback(my_data_received_callback)
def at_response_received_cb(self, response):
"""
Callback to deal with AT command responses and update the
corresponding node. Only for internal use.
Args:
response (:class: `.XBeeAPIPacket`): The received API packet.
"""
f_type = response.get_frame_type()
if f_type not in (ApiFrameType.AT_COMMAND_RESPONSE,
ApiFrameType.REMOTE_AT_COMMAND_RESPONSE):
return
node = self.__xbee
# Get remote node in case of a remote at command
if (f_type == ApiFrameType.REMOTE_AT_COMMAND_RESPONSE
and XBee64BitAddress.is_known_node_addr(response.x64bit_source_addr)):
node = self.__xbee.get_network().get_device_by_64(response.x64bit_source_addr)
if not node:
return
key = str(node.get_64bit_addr())
requests = self._at_cmds_sent.get(key, {})
req = requests.pop(response.frame_id, None)
if not req or response.status != ATCommandStatus.OK:
return
def is_req_apply(at_req):
fr_type = at_req.get_frame_type()
return (at_req.command.upper() == ATStringCommand.AC.command
or fr_type == ApiFrameType.AT_COMMAND
or (fr_type == ApiFrameType.REMOTE_AT_COMMAND_REQUEST
and at_req.transmit_options & RemoteATCmdOptions.APPLY_CHANGES.value))
def is_node_info_param(at_pkt):
at_cmd = at_pkt.command.upper()
return at_cmd in (ATStringCommand.NI.command,
ATStringCommand.MY.command)
def is_port_param(at_pkt):
at_cmd = at_pkt.command.upper()
return at_cmd in (ATStringCommand.AP.command,
ATStringCommand.BD.command,
ATStringCommand.NB.command,
ATStringCommand.SB.command)
apply = is_req_apply(req)
if apply:
if key not in self._future_apply:
self._future_apply[key] = {}
node_fut_apply = self._future_apply.get(key, {})
node_fut_apply.pop(req.command.upper(), None)
for key, value in list(node_fut_apply.items()):
self._refresh_if_cached(node, key, value, apply=True)
if req.parameter and (is_port_param(req) or is_node_info_param(req)):
self._refresh_if_cached(node, req.command.upper(), req.parameter,
apply=apply)
#LOOK FOR XBEE
context = pyudev.Context()
port_name = '/dev/ttyUSB0'
for device in context.list_devices(subsystem='tty'):
if 'ID_VENDOR' in device and device['ID_VENDOR'] == 'FTDI':
port_name = device['DEVNAME']
my_address = int(args[0])
#Connect to XBEE
device = XBeeDevice(port_name, baud)
device.open()
dest_address = XBee64BitAddress.from_hex_string("000000000000FFFF")
device.set_dest_address(dest_address)
device.set_pan_id(bytearray.fromhex(opts.pan_id))
#cmd = 'AP2,'
device.set_parameter("AP", bytearray.fromhex("02"))
if (opts.coordinator):
device.set_parameter("CE", bytearray.fromhex("01"))
else:
device.set_parameter("CE", bytearray.fromhex("00"))
#cmd += 'CE1,' #API mode 2, and enable coordinator
device.set_parameter("MY", utils.int_to_bytes(my_address))
device.set_parameter("NI", bytearray(opts.name, 'utf8'))
def main(Node_Address):
NodeAddress = XBee64BitAddress.from_hex_string(Node_Address)
print(" +-------------------------------------------------------+")
print(" | Write Remote XBee (" + Node_Address + ") parameters |")
print(" +---------------------------------------------------- --+\n")
local_device = XBeeDevice(PORT, BAUD_RATE)
local_device.open()
remote_device = RemoteZigBeeDevice(local_device, NodeAddress)
try:
# Get Hardware Models with extended DIO (P5 to P9)
Hardware_Extended = read_sys_config.ReadHardwareVersionWhithP5ToP9PinsFromFile(
)
HV = utils.hex_to_string(remote_device.get_parameter("HV"))
# Set file name source of the params
print("0013A200416299FE")
read_node_config_file.set_path_to_file(Node_Address)
#No se puede modificar la PAN ID vía RF porque se pierde conexión
print(read_node_config_file.ReadScanChannelsFromFile(Node_Address))
remote_device.set_parameter(
"SC",
utils.hex_string_to_bytes(
read_node_config_file.ReadScanChannelsFromFile(Node_Address)))
remote_device.set_parameter(
"SD",
utils.hex_string_to_bytes(
read_node_config_file.ReadScanDurationFromFile(Node_Address)))
remote_device.set_parameter(
"ZS",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeStackProfileFromFile(
Node_Address)))
remote_device.set_parameter(
"NJ",
utils.hex_string_to_bytes(
read_node_config_file.ReadNodeJoinTimeFromFile(Node_Address)))
remote_device.set_parameter(
"NW",
utils.hex_string_to_bytes(
read_node_config_file.ReadNetworkWatchdogTimeoutFromFile(
Node_Address)))
remote_device.set_parameter(
"JV",
utils.hex_string_to_bytes(
read_node_config_file.ReadChannelVerificationFromFile(
Node_Address)))
remote_device.set_parameter(
"JN",
utils.hex_string_to_bytes(
read_node_config_file.ReadJoinNotificationFromFile(
Node_Address)))
remote_device.set_parameter(
"CE",
utils.hex_string_to_bytes(
read_node_config_file.ReadCoordinatorEnableFromFile(
Node_Address)))
remote_device.set_parameter(
"DO",
utils.hex_string_to_bytes(
read_node_config_file.ReadDeviceOptionsFromFile(Node_Address)))
remote_device.set_parameter(
"DC",
utils.hex_string_to_bytes(
read_node_config_file.ReadDeviceControlsFromFile(
Node_Address)))
# Addressing
remote_device.set_parameter(
"DH",
utils.hex_string_to_bytes(
read_node_config_file.ReadDestinationAddressHighFromFile(
Node_Address)))
remote_device.set_parameter(
"DL",
utils.hex_string_to_bytes(
read_node_config_file.ReadDestinationAddressLowFromFile(
Node_Address)))
remote_device.set_parameter(
"NI",
bytearray(
read_node_config_file.ReadNodeIdentifierFromFile(Node_Address),
'utf8'))
remote_device.set_parameter(
"NH",
utils.hex_string_to_bytes(
read_node_config_file.ReadMaximumHopsFromFile(Node_Address)))
remote_device.set_parameter(
"BH",
utils.hex_string_to_bytes(
read_node_config_file.ReadBroadcastRadiusFromFile(
Node_Address)))
remote_device.set_parameter(
"AR",
utils.hex_string_to_bytes(
read_node_config_file.ReadManyToOneRouteBroadcastTimeFromFile(
Node_Address)))
remote_device.set_parameter(
"DD",
utils.hex_string_to_bytes(
read_node_config_file.ReadDeviceTypeIdentifierFromFile(
Node_Address)))
remote_device.set_parameter(
"NT",
utils.hex_string_to_bytes(
read_node_config_file.ReadNodeDiscoveryBackoffFromFile(
Node_Address)))
remote_device.set_parameter(
"NO",
utils.hex_string_to_bytes(
read_node_config_file.ReadNodeDiscoveryOptionsFromFile(
Node_Address)))
remote_device.set_parameter(
"CR",
utils.hex_string_to_bytes(
read_node_config_file.ReadPanConflictThresholdFromFile(
Node_Address)))
# ZigBee Addressing
remote_device.set_parameter(
"SE",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeSourceEndPointFromFile(
Node_Address)))
remote_device.set_parameter(
"DE",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeDestinationEndpointFromFile(
Node_Address)))
remote_device.set_parameter(
"CI",
utils.hex_string_to_bytes(
read_node_config_file.ReadZigBeeClusterIDFromFile(
Node_Address)))
remote_device.set_parameter(
"TO",
utils.hex_string_to_bytes(
read_node_config_file.ReadTransmitOptionsFromFile(
Node_Address)))
# RF Interfacing
remote_device.set_parameter(
"PL",
utils.hex_string_to_bytes(
read_node_config_file.ReadTxPowerLevelFromFile(Node_Address)))
remote_device.set_parameter(
"PM",
utils.hex_string_to_bytes(
read_node_config_file.ReadPowerModeFromFile(Node_Address)))
# Security
remote_device.set_parameter(
"EE",
utils.hex_string_to_bytes(
read_node_config_file.ReadEncryptionEnableFromFile(
Node_Address)))
remote_device.set_parameter(
"EO",
utils.hex_string_to_bytes(
read_node_config_file.ReadEncryptionOptionsFromFile(
Node_Address)))
# No se pueden cambiar las keys vía RF
# Serial Interfacing
remote_device.set_parameter(
"BD",
utils.hex_string_to_bytes(
read_node_config_file.ReadBaudRateFromFile(Node_Address)))
remote_device.set_parameter(
"NB",
utils.hex_string_to_bytes(
read_node_config_file.ReadParityFromFile(Node_Address)))
remote_device.set_parameter(
"SB",
utils.hex_string_to_bytes(
read_node_config_file.ReadStopBitsFromFile(Node_Address)))
remote_device.set_parameter(
"RO",
utils.hex_string_to_bytes(
read_node_config_file.ReadPacketizationTimeoutFromFile(
Node_Address)))
remote_device.set_parameter(
"D6",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO6ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D7",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO7ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"AP",
utils.hex_string_to_bytes(
read_node_config_file.ReadApiEnableFromFile(Node_Address)))
remote_device.set_parameter(
"AO",
utils.hex_string_to_bytes(
read_node_config_file.ReadApiOutputModeFromFile(Node_Address)))
# AT Command Options
remote_device.set_parameter(
"CT",
utils.hex_string_to_bytes(
read_node_config_file.ReadATCommandModeTimeoutFromFile(
Node_Address)))
remote_device.set_parameter(
"GT",
utils.hex_string_to_bytes(
read_node_config_file.ReadGuardTimesFromFile(Node_Address)))
remote_device.set_parameter(
"CC",
utils.hex_string_to_bytes(
read_node_config_file.ReadCommandSequenceCharacterFromFile(
Node_Address)))
# Sleep Modes
remote_device.set_parameter(
"SP",
utils.hex_string_to_bytes(
read_node_config_file.ReadCyclicSleepPeriodFromFile(
Node_Address)))
remote_device.set_parameter(
"SN",
utils.hex_string_to_bytes(
read_node_config_file.ReadNumberOfCyclicSleepPeriodsFromFile(
Node_Address)))
remote_device.set_parameter(
"SM",
utils.hex_string_to_bytes(
read_node_config_file.ReadSleepModeFromFile(Node_Address)))
remote_device.set_parameter(
"ST",
utils.hex_string_to_bytes(
read_node_config_file.ReadTimeBeforeSleepFromFile(
Node_Address)))
remote_device.set_parameter(
"SO",
utils.hex_string_to_bytes(
read_node_config_file.ReadSleepOptionsFromFile(Node_Address)))
remote_device.set_parameter(
"WH",
utils.hex_string_to_bytes(
read_node_config_file.ReadWakeHostFromFile(Node_Address)))
remote_device.set_parameter(
"PO",
utils.hex_string_to_bytes(
read_node_config_file.ReadPollRateFromFile(Node_Address)))
# I/O Settings
remote_device.set_parameter(
"D0",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO0AD0ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D1",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO1AD1ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D2",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO2AD2ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D3",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO3AD3ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D4",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO4ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D5",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO5ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D8",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO8ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"D9",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO9ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P0",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO10ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P1",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO11ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P2",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO12ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P3",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO13ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P4",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO14ConfigurationFromFile(
Node_Address)))
if HV == Hardware_Extended:
remote_device.set_parameter(
"P5",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO15ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P6",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO16ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P7",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO17ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P8",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO18ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"P9",
utils.hex_string_to_bytes(
read_node_config_file.ReadDIO19ConfigurationFromFile(
Node_Address)))
remote_device.set_parameter(
"PR",
utils.hex_string_to_bytes(
read_node_config_file.ReadPullUpResistorEnableFromFile(
Node_Address)))
remote_device.set_parameter(
"PD",
utils.hex_string_to_bytes(
read_node_config_file.ReadPullUpDownDirectionFromFile(
Node_Address)))
remote_device.set_parameter(
"LT",
utils.hex_string_to_bytes(
read_node_config_file.ReadAssociatedLedBlinkTimeFromFile(
Node_Address)))
remote_device.set_parameter(
"RP",
utils.hex_string_to_bytes(
read_node_config_file.ReadRssiPwmTimerFromFile(Node_Address)))
# I/O Sampling
remote_device.set_parameter(
"IR",
utils.hex_string_to_bytes(
read_node_config_file.ReadIOSamplingRateFromFile(
Node_Address)))
remote_device.set_parameter(
"IC",
utils.hex_string_to_bytes(
read_node_config_file.ReadDigitalIOChangeDetectionFromFile(
Node_Address)))
remote_device.set_parameter(
"V+",
utils.hex_string_to_bytes(
read_node_config_file.ReadSupplyVoltageHihgThresholdFromFile(
Node_Address)))
# Make params permanent
remote_device.write_changes() # make changes permanet"""
# print parameters
log = " Success!! All Parameters Were Written \n\n"
print(" Success!! All Parameters Were Written ")
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()
return log
def remote_device(self):
return RemoteXBeeDevice(
self.device, XBee64BitAddress.from_hex_string(self.coordenador))
def create_packet(raw, operating_mode):
"""
Override method.
Returns:
:class:`.RouteInformationPacket`.
Raises:
InvalidPacketException: If the bytearray length is less than 46.
(start delim. + length (2 bytes) + frame type + src_event
+ length + timestamp (4 bytes) + ack timeout count
+ tx blocked count + reserved + dest addr (8 bytes)
+ src addr (8 bytes) + responder addr (8 bytes)
+ succesor addr (8 bytes) + checksum = 46 bytes).
InvalidPacketException: If the length field of `raw` is different
from its real length. (length field: bytes 1 and 3)
InvalidPacketException: If the first byte of 'raw' is not the
header byte. See :class:`.SpecialByte`.
InvalidPacketException: If the calculated checksum is different
from the checksum field value (last byte).
InvalidPacketException: If the frame type is not
:attr:`.ApiFrameType.DIGIMESH_ROUTE_INFORMATION`.
InvalidPacketException: If the internal length byte of the rest
of the frame (without the checksum) is different from its real
length.
InvalidOperatingModeException: If `operating_mode` is not
supported.
.. seealso::
| :meth:`.XBeePacket.create_packet`
| :meth:`.XBeeAPIPacket._check_api_packet`
"""
if operating_mode not in (OperatingMode.ESCAPED_API_MODE,
OperatingMode.API_MODE):
raise InvalidOperatingModeException(operating_mode.name +
" is not supported.")
XBeeAPIPacket._check_api_packet(
raw, min_length=RouteInformationPacket.__MIN_PACKET_LENGTH)
if raw[3] != ApiFrameType.DIGIMESH_ROUTE_INFORMATION.code:
raise InvalidPacketException(
"This packet is not a Route Information packet.")
# 7: frame len starting from this byte (index 5) and without the checksum
if raw[5] != len(raw) - 7:
raise InvalidPacketException(
"Length does not match with the data length")
additional_data = []
if len(raw) > RouteInformationPacket.__MIN_PACKET_LENGTH:
additional_data = raw[45:]
packet = RouteInformationPacket(raw[4], utils.bytes_to_int(raw[6:10]),
raw[10], raw[11],
XBee64BitAddress(raw[13:21]),
XBee64BitAddress(raw[21:29]),
XBee64BitAddress(raw[29:37]),
XBee64BitAddress(raw[37:45]),
additional_data)
packet._reserved = raw[12]
return packet
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
import random
import string
from digi.xbee.devices import XBeeDevice, RemoteXBeeDevice
from digi.xbee.models.address import XBee64BitAddress
from digi.xbee.util.utils import hex_to_string
# TODO: Replace with the serial port where your local module is connected to.
PORT = "COM1"
# TODO: Replace with the baud rate of your local module.
BAUD_RATE = 9600
# TODO: Replace with the 64-bit address of the remote device.
REMOTE_DEVICE_ADDRESS = XBee64BitAddress.from_hex_string("0013A20040D47B73")
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)
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):
DATABASE_EXISTS = False
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 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))
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')
while arduino.inWaiting() > 0:
texto = arduino.readline()
texto = texto.decode("utf8")
texto = texto[:-2]
print("\nDatos del sensor: ", texto, "\n")
# Con 21 para "TEMP-xx:SND-xx:LUZ-xx"
if len(texto) == 21:
x = 1
arduino.close()
# Datos recogidos
time.sleep(1)
data = "Recogidos"
data = data.encode("utf8")
coord = RemoteXBeeDevice(
device, XBee64BitAddress.from_hex_string("0013A20040C53D49"))
device.send_data(coord, data)
#Leer
mens = None
print("\nEsperando mi turno...\n")
while mens == None:
# Recivo de coordinador
mens = device.read_data_from(coord)
time.sleep(0.5)
print("\nEnviando datos solicitados\n")
data = texto.encode("utf8")
# Envio a coordinador
device.send_data(coord, data)
print("Datos enviados con exito!\n")
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")
