def main(): print(" +--------------------------------+") print(" | Discover Specific Devices Test |") print(" +--------------------------------+\n") device = XBeeDevice(PORT, BAUD_RATE) try: device.open() network = device.get_network() # Discover a valid remote device. remote = network.discover_device(REMOTE_NODE_ID) assert (remote is not None) assert (remote.get_node_id() == REMOTE_NODE_ID) # Discover an invalid remote device. remote = network.discover_device("!inv4lid_1d!") assert (remote is None) # Discover myself. network.set_discovery_options({DiscoveryOptions.DISCOVER_MYSELF}) if device.get_protocol() == XBeeProtocol.RAW_802_15_4: assert (network.get_discovery_options()[0] == 1) else: assert (network.get_discovery_options()[0] == 2) remote = network.discover_device(device.get_node_id()) assert (remote == device) network.clear() # Discover the remote device and myself. devices_list = network.discover_devices( [REMOTE_NODE_ID, device.get_node_id()]) assert (len(devices_list) == 2) assert (network.get_device_by_node_id(device.get_node_id()) == device) # Restore the discovery options. network.set_discovery_options({}) assert (network.get_discovery_options()[0] == 0) print("Test finished successfully") finally: if device is not None and device.is_open(): device.close()
def main(): print(" +-----------------------------------------------------+") print(" | XBee Python Library Manage Common parameters Sample |") print(" +-----------------------------------------------------+\n") device = XBeeDevice(PORT, BAUD_RATE) try: device.open() print("Cached parameters\n" + "-" * 50) print("64-bit address: %s" % device.get_64bit_addr()) print("16-bit address: %s" % device.get_16bit_addr()) print("Node Identifier: %s" % device.get_node_id()) print("Firmware version: %s" % utils.hex_to_string(device.get_firmware_version())) print("Hardware version: %s" % device.get_hardware_version().description) print("") # Configure and read non-cached parameters. device.set_pan_id(PARAM_VALUE_PAN_ID) device.set_dest_address(PARAM_DESTINATION_ADDR) device.set_power_level(PARAM_POWER_LEVEL) print("Non-Cached parameters\n" + "-" * 50) print("PAN ID: %s" % utils.hex_to_string(device.get_pan_id())) print("Dest address: %s" % device.get_dest_address()) print("Power level: %s" % device.get_power_level().description) finally: if device is not None and device.is_open(): device.close()
class ModuleSingleton: def __init__(self): self.device = XBeeDevice(LOCAL_PORT, BAUD_RATE) self.device.open() self.remote_device = None self.queue = None try: self.remote_device = RemoteXBeeDevice( self.device, XBee64BitAddress.from_hex_string(REMOTE_NODE_ADDRESS)) if self.remote_device is None: print("Could not find the remote device") except XBeeException: print("Exception has occurred") def send(self, data): print("Testing data: " + data) try: print("Sending data to %s >> %s..." % (self.remote_device.get_64bit_addr(), DATA_TO_SEND)) logging.basicConfig(stream=sys.stdout, level=logging.DEBUG, format="[root] %(levelname)s - %(message)s") logger = logging.getLogger(self.device.get_node_id()) self.device.send_data(self.remote_device, data) print("Success") finally: if self.device is not None and self.device.is_open(): # self.device.close() print("Commented out close") def bind_queue(self, queue): self.queue = queue def receive(self): try: def data_receive_callback(msg): data = msg.data.decode("utf8") json_data = json.loads(data) self.queue.put(json_data) self.device.add_data_received_callback(data_receive_callback) print("Waiting for data...\n") input() finally: if self.device is not None and self.device.is_open(): #self.device.close() print("Commented out 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 initXBee(port, baud): global CONTROLLER_ADDR print("Init XBee at {0}, {1:d}".format(port, baud)) #device = ZigBeeDevice(port, baud) device = XBeeDevice(port, baud) device.open() device.add_modem_status_received_callback(xbee_status_callback) device.add_data_received_callback(xbee_received_callback) xnet = device.get_network() xnet.set_discovery_timeout(5) xnet.start_discovery_process() while xnet.is_discovery_running(): time.sleep(0.5) controller16Addr = XBee16BitAddress.COORDINATOR_ADDRESS remote_device = xnet.get_device_by_16(controller16Addr) if remote_device is None: print("Could not find the remote device {0}".format(controller16Addr)) print("init, nodeId= {0}".format(device.get_node_id())) return device, remote_device
from digi.xbee.devices import XBeeDevice PORT = '/dev/ttyUSB0' BAUD_RATE = 57600 device = XBeeDevice(PORT, BAUD_RATE) device.open() # Get the 64-bit address of the device. addr_64 = device.get_64bit_addr() # Get the node identifier of the device. node_id = device.get_node_id() # Get the hardware version of the device. hardware_version = device.get_hardware_version() # Get the firmware version of the device. firmware_version = device.get_firmware_version() print("MAC ADDRESS = ",addr_64) print("Node ID = ",node_id)
class XBeeInterfaceNode(Node): coordinator: str = '0' __platform__: str = platform.system() """" """ def __init__(self): """ Creates a ROS2 Node for interfacing with XBee Device """ super().__init__('XBeeInterface') # ---> Declare ROS Parameters <--- # self.declare_parameter( 'port', '/dev/ttyUSB0' if self.__platform__ == 'Linux' else 'COM0') self.declare_parameter('baud_rate', 115200) # ---> Get Xbee Device Object <--- # try: self.xbee = XBeeDevice( self.get_parameter('port').value, self.get_parameter('baud_rate').value) self.xbee.open() self.get_logger().info( 'Successfully interfaced XBee module with node ID: ' + self.xbee.get_node_id()) except XBeeException as error: self.get_logger().info('XBee Exception Occurred, ERROR: ' + str(error)) except SerialException as error: self.get_logger().info( 'Cannot establish connection with the XBee Module,: ' + str(error)) except Exception as error: self.get_logger().info('Exception occurred, Error: ' + str(error)) finally: # self.set_call_back() pass def transmit(self, data: bytes, recipient_address: str = coordinator) -> TransmitStatusPacket: """ Takes the address of the receiver xbee module and transmit the data to the receiver :param data: Data in bytes to be transmitted to the desired xbee module/device :type data: bytes :param recipient_address: 64 bit xbee address of the recipient module/device :type recipient_address: str :return: Digi-xbee 'TransmitStatusPacket' object, which gives us the transmit status of the transmitted data """ try: if type(data) is not bytes or type(recipient_address) is not str: raise TypeError( 'Args "data" must be bytes & "recipient_address" must be a str' ) if not self.xbee.is_open(): self.xbee.open() # Instantiate a remote XBee device object target = RemoteXBeeDevice( self.xbee, XBee64BitAddress.from_hex_string(recipient_address)) # Send data using the remote object status_packet: TransmitStatusPacket = self.xbee.send_data( target, data) return status_packet except TypeError as e: self.get_logger().info('Bad arg types, ERROR: ', e) except TransmitException as e: self.get_logger().info('Failed to transmit data, ERROR: ', e.status)
from digi.xbee.devices import XBeeDevice, RemoteXBeeDevice, XBee64BitAddress, XBeeMessage from struct import * import json from digi.xbee.io import IOLine, IOMode, IOValue xbee = XBeeDevice('/dev/tty.usbserial-A505N9YU', 9600) xbee.open() print(xbee.get_node_id()) try: def data_receive_callback(xbee_message): print("pulse count data recieved") pulseCount = (256 * xbee_message.data[0] + xbee_message.data[1]) print("From", xbee_message.remote_device.get_64bit_addr(), " >> Pulse count = ", pulseCount) print(xbee_message.remote_device.get_node_id()) def io_sample_callback(io_sample, remote_xbee, send_time): print("IO sample:") print("IO sample received at time %s." % str(send_time)) print("IO sample:") print(str(io_sample)) print(str(remote_xbee)) print(type(remote_xbee)) print(remote_xbee.get_64bit_addr()) print(type(remote_xbee.get_64bit_addr())) print(remote_xbee.get_node_id()) b = io_sample.get_digital_value(IOLine.DIO1_AD1) print(b)
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')