Python XBee.send方法代码示例

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
def main():
    """
    Sends an API AT command to read the lower-order address bits from
    an XBee Series 1 and looks for a response
    """
    try:

        # Open serial port
        ser = serial.Serial('/dev/cu.usbserial-DA00T2BX', 9600)

        # Create XBee Series 1 object
        xbee = XBee(ser)


        # Send AT packet
        xbee.send('at', frame_id='A', command='DH')

        # Wait for response
        response = xbee.wait_read_frame()
        print response


        # Wait for response
        response = xbee.wait_read_frame()
        print response
    except KeyboardInterrupt:
        pass
    finally:
        ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
class XBeeTransport(ThreadedTransport):
  
  def __init__(self, port='/dev/ttyUSB0', baudrate=9600, channel='\x0C'):
    self.serial = serial.Serial(port, baudrate)
    self.xbee = XBee(self.serial, escaped=True)
    self.channel = channel

    self.config = XBeeAPIConfig(xbee=self.xbee)
    self.default_xbee(self.channel)
    self.config.transport = self

    super(XBeeTransport, self).__init__()

  def default_xbee(self, channel):
    """Set default XBee settings for the tiles"""
    self.config.adjust_baudrate()
    self.config.set_channel(channel)
    for key in DEFAULT_XBEE_SETTINGS:
      if not self.config.set_param(key, DEFAULT_XBEE_SETTINGS[key]):
        raise Exception("Failed to set XBee settings for key %s!" % key)
      sleep(0.01)

  def _send(self, data):
    if type(data) is dict:
      self.xbee.send(**data)
    else:
      self.xbee.send("tx_long_addr", data=data, dest_addr='\x00\x00\x00\x00\x00\x00\xFF\xFF')

  def _receive(self):
    if self.serial.inWaiting() > 0:
      data = self.xbee.wait_read_frame()
      if type(data) is dict and data.has_key('rf_data'):
        data['data'] = data['rf_data']
      return data
    else:
      return None

  def stop(self):
    super(XBeeTransport, self).stop()
    self.serial.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
def main():
    """
    Sends an API AT command to read the lower-order address bits from 
    an XBee Series 1 and looks for a response
    """
    try:
        
        # Open serial port
        ser = serial.Serial( serialport, 57600)
        
        # Create XBee Series 1 object
        xbee = XBee(ser)
        
        framecnt = 0
        while True:
	  framecnt = framecnt + 1
	  if framecnt == 16:
	    framecnt = 1
	  msgid = chr( framecnt )
	  datalist = [ msgid ]
	  #//datalist.extend( datalistin )
	  data = ''.join( datalist )
	  hrm = struct.pack('>H', destination )
	  xbee.send('tx',
	    dest_addr=hrm,
	    data=data,
	    frame_id=msgid,
	    options='\x02'
          )

	  # Wait for response
	  response = xbee.wait_read_frame()
	  print response
	  time.sleep( 0.1 )
                
    except KeyboardInterrupt:
        pass
    finally:
        ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
def driveXbee():
    global speed

    ser = serial.Serial('/dev/ttyUSB0', 9600)
    xbee = XBee(ser)

    pygame.init()
    pygame.display.set_mode((100,100))
    clock = pygame.time.Clock()

    up = 0
    down = 0
    left = 0
    right = 0

    while 1:
        clock.tick(10)

        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
                # Send the packet to stop several times
                xbee.send('tx', dest_addr='\x00\x02', data='\x00')
                xbee.send('tx', dest_addr='\x00\x02', data='\x00')
                xbee.send('tx', dest_addr='\x00\x02', data='\x00')
                xbee.send('tx', dest_addr='\x00\x02', data='\x00')
                return

            if event.type == KEYDOWN and (event.key == K_w or event.key == K_UP):
                up = 1
            if event.type == KEYUP and (event.key == K_w or event.key == K_UP):
                up = 0

            if event.type == KEYDOWN and (event.key == K_s or event.key == K_DOWN):
                down = 1
            if event.type == KEYUP and (event.key == K_s or event.key == K_DOWN):
                down = 0

            if event.type == KEYDOWN and (event.key == K_a or event.key == K_LEFT):
                left = 1
            if event.type == KEYUP and (event.key == K_a or event.key == K_LEFT):
                left = 0

            if event.type == KEYDOWN and (event.key == K_d or event.key == K_RIGHT):
                right = 1
            if event.type == KEYUP and (event.key == K_d or event.key == K_RIGHT):
                right = 0

        data_to_send = chr(speed | (up << 2) | (down << 3) | (left << 4) | (right << 5))
        #print bin(int(data_to_send))
        xbee.send('tx', dest_addr='\x00\x02', data=data_to_send)

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
Continuously read the serial port and process IO data received from a remote XBee.
"""

# This version is for the pi

import time
from xbee import XBee
from serial import Serial

ser = Serial('/dev/tty.usbserial-A7025WZ6', 57600)
#ser = Serial('/dev/xbee', 57600)

xbee = XBee(ser)

data = 1
# Continuously send
while data == 1:
    try:
        
        signal = ['up', 'down', 'right', 'left']
        #print signal
        #send = xbee.send("str(signal")
        xbee.send("at", frame="A", command='MY', parameter=None)
        ser.flush()
        #send = ser.writelines("testing API\n")
        time.sleep(.5)
        data += 1
    except KeyboardInterrupt:
        break
        
ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
class beemanager:


	def __init__(self,port,timeouttime):
		'initialise xbee manager'
		try:
			self.ser = serial.Serial(port,timeout=1)
			self.xbee = XBee(self.ser)
			self.timeout = timeouttime
		except Exception as inst:
			print type(inst)     # the exception instance
			print inst.args      # arguments stored in .args
			print inst           # __str__ allows args to be printed directly
			print "ooops something went wrong setting up"
			


	def senddata(self,addr,datain):
		'sends data to specified node address'
		sent = False
		error = False
		counter = 0
		while((sent==False) and (error==False) and (counter<5)):
			try:
				self.xbee.send('tx',frame_id='A',dest_addr=addr,data=datain)
				if(self.ser.inWaiting):
					response = self.xbee.wait_read_frame()
					if(response['status'] == '\x00'):
						sent = True

					else:
						sent = False
						counter = counter +1

			except Exception as inst:
				print type(inst)     # the exception instance
				print inst.args      # arguments stored in .args
				print inst           # __str__ allows args to be printed directly
				print "ooops something went wrong sending"
				error = True

		if((sent==False)):	
			return False
		else:
			return True



	def readxbee(self):
		'returns data and address'
		counter = 0
		while((self.ser.inWaiting() < 1) and counter <= self.timeout):
			counter = counter + 1
			time.sleep(1.0)

		if(counter > self.timeout):
			return False
		else:
			response = self.xbee.wait_read_frame()
			return (response['rf_data'],struct.unpack(">h", response['source_addr'])[0])
	
	def sendwater(self,timeval,addr):
		#print "sent: " + "w"+str(timeval) + "\n"
		self.senddata(addr,"w" +str(timeval) + "\n")
		reply = self.readxbee()
		#print "reply is:" + str(reply)
		if(reply != False):
			#print(int(reply[0]))
			#print timeval-1
			if((int(reply[0]) == timeval) or (int(reply[0]) == (timeval-1))):
				return True
			else:
				return "incorrect"
		else:
			return "no reply"


	def readmoisture(self,node):
		self.senddata(node,"t\n")
		reply = self.readxbee()
		#print reply
		if(reply != False):
			return reply[0]
		else:
			return False



	def __del__(self):
		self.ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
class MeshDeckClient:
  def __init__(self, port, baud):
    self.serial_port = serial.Serial(port, baud) # if using cape /dev/ttyO2
    self.xbee = XBee(self.serial_port)

# This function handles fragmentation of responses from drone scripts/commands
  def sendToController(self, msg):
    resplen = len(msg) # tell the command console how much to expect
    self.xbee.tx(dest_addr='\x00\x00', data="lr:"+str(resplen))
    sentlen = 0
    while sentlen <= resplen:
      endindex = sentlen + 98 # max packet length is 100 bytes
      if (endindex > resplen):
	line = msg[sentlen:]
      else:
	line = msg[sentlen:endindex]
      self.xbee.tx(dest_addr='\x00\x00', data="r:"+line)
      sentlen += 98

# announce an event such as drone start to the command console      
  def sendAnnounce(self, msg):
      self.xbee.tx(dest_addr='\x00\x00', data="a:"+msg)
      
# this is the main loop for the drone clients      
  def clientLoop(self):	
    # Series 2 adapters will have a my address of 0xFFFE until they have an address
    # assigned by the coordinator.  Sending packets without an address could be
    # problematic.  This can be avoided by check for this first
    self.xbee.send('at', frame_id='A', command='MY')
    resp = self.xbee.wait_read_frame()
    while (resp['parameter'] == '\xff\xfe'):
      sleep(1)
      self.xbee.send('at', frame_id='A', command='MY')
      resp = self.xbee.wait_read_frame()
      
    # initial beacon to the controller
    self.sendAnnounce("By your command-drone is awaiting orders")
    # These variables are for transfering files
    rc_size = 0
    rc_bytes = 0
    rc_packet_num = 0
    rc_name = ""
    rc_file = None
    sdl_path = "./"
    
    while True:
      try:
	# get a command from the controller
	cmd = self.xbee.wait_read_frame()
	if (cmd['rf_data'].find('c:') == 0): # sanity check this should be the start of a command
	  self.sendToController("---Process started----\n")
	  proc = subprocess.Popen(cmd['rf_data'][2:], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, bufsize=4096)
	  signal.alarm(3600) # nothing should take an hour to run this will reset a drone if it all goes bad
	  rc = proc.wait() # this call blocks until the process completes
	  signal.alarm(0) # process succeeded so reset the timer
	  if (rc == 0): #returned successfully
            resp = ""
	    for line in iter(proc.stdout.readline, ''):
	      resp += line
	    resp += "---------Process completed successfully------\n"
            self.sendToController(resp)
	  else:
	    self.sendToController("+++++++Process errored out++++++++\n")
	elif (cmd['rf_data'].find("ft:") == 0): # command console is attempting to transfer a file
	  rc_size = int(cmd['rf_data'].split(':')[2])
	  rc_bytes = 0
	  rc_packet_num = 0
	  rc_name = cmd['rf_data'].split(':')[3]
	  rc_file = open(sdl_path+rc_name, 'w')
	elif (cmd['rf_data'].find("fd:") == 0): # data packet for a file
	  packet_num = int(cmd['rf_data'].split(':')[2])
	  rc_packet_num += 1
	  if (rc_packet_num != packet_num):
	    print "Warning possible file corruption in file " + rc_name
	  data = str(cmd['rf_data'].split(':', 3)[3])
	  rc_bytes += len(data)
	  rc_file.write(data)
	  if (rc_bytes >= rc_size):
	    rc_file.close()
      except KeyboardInterrupt:
	break
      except Alarm:
	self.sendToController("+++++++++++Process never completed++++++++++\n")
	signal.alarm(0)
    self.serial_port.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
class RCProtocol(object):
    waiting = False
    request = None
    rssi = 0
    rssi_remote = 0

    signal = 0
    _frameid = "\x01"

    cnt_snt = 0
    cnt_rcv = 0

    def __init__(self):
        log.msg("Initializing XBee port...")
        self._ser = serial.Serial(settings.SERIAL_PORT, settings.SERIAL_SPEED, timeout=settings.SERIAL_TIMEOUT)
        self._xbee = XBee(self._ser, api_mode=2)
        reactor.addSystemEventTrigger("before", "shutdown", self._xbee.halt)
        reactor.callLater(0, self._loop)

    def _loop(self):
        def cb(xframe):
            self.cnt_rcv = self.cnt_rcv + 1
            # log.msg(xframe)
            if self.waiting is False:
                log.err(UnexpectedFrameException())
                reactor.callLater(0, self._loop)
                return
            d = self.request

            if xframe["id"] == "tx_status":
                if xframe["status"] == "\x00":
                    pass
                else:
                    failure = Failure(exc_value=FrameNoACKException("Frame was not delivered %s" % xframe["status"]))
                    d.errback(failure)
            if xframe["id"] == "rx":
                self.waiting = False
                self.rssi = ord(xframe["rssi"])
                d.callback(xframe["rf_data"])
            reactor.callLater(0, self._loop)

        def eb(err):
            reactor.callLater(0, self._loop)

        d = threads.deferToThread(self._xbee.wait_read_frame)
        d.addCallbacks(cb, eb)

    def send_frame(self, data):
        if self.waiting is True:
            failure = Failure(exc_value=AlreadyRequestedException("Another request already sent"))
            d = defer.Deferred()
            d.errback(failure)
            return d

        fid = self.gen_frameid()
        self.cnt_snt = self.cnt_snt + 1
        # log.msg("Sending frame")
        self._xbee.send("tx", frame_id=fid, dest_addr="\x00\x00", data=data)
        self.waiting = True
        d = defer.Deferred()
        d.setTimeout(0.1)
        self.request = d
        return d

    def gen_frameid(self):
        "Sequential generator of frame ids"
        fid = ord(self._frameid) + 1
        if fid > 255:
            fid = 1
        return chr(fid)

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
import serial, time, datetime, sys
from xbee import XBee

print 'Time Delay Switch to XBee'
time.sleep(10)
print 'Delay Over'

SERIALPORT = "/dev/ttyUSB0"    # the com/serial port the XBee is connected to
BAUDRATE = 9600      # the baud rate

ser = serial.Serial(SERIALPORT, BAUDRATE)

xbee = XBee(ser)

while True:
    try:
        command = xbee.wait_read_frame()
        if command['rf_data'] == 'PINGA':
                xbee.send("tx_long_addr", frame_id='\x00', dest_addr='\x00\x13\xA2\x00\x40\xE2\xCF\xC5', data='\x50\x49\x4E\x47\x42\x41\x43\x4B')
	elif command['rf_data'] == 'PINGB':
                xbee.send("tx_long_addr", frame_id='\x00', dest_addr='\x00\x13\xA2\x00\x40\xD8\x76\x2E', data='\x50\x49\x4E\x47\x42\x41\x43\x4B')
	elif command['rf_data'] == 'PINGC':
                xbee.send("tx_long_addr", frame_id='\x00', dest_addr='\x00\x13\xA2\x00\x40\xE2\xCF\xE3', data='\x50\x49\x4E\x47\x42\x41\x43\x4B')
    except KeyboardInterrupt:
        break

ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
class xBeeDevices():
    def __init__(self):
        self.PORT = 'COM4'
        self.BAUD_RATE = 9600

        #словарь 'адрес MY : Имя' для xCoordinator'ов
        self.dict_src_addr_coord = {'\x01\x01':'Coordinator (101)'}

        #словарь 'адрес MY : Имя' для xSlave'ов
        self.dict_src_addr_slave = {'\x00\x02':'Slave (2)'}

        #словари для преобразования получаемых данных в удобный вид
        self.dict_names_in_coord = {'dio-0':'IN1', 
                                    'dio-1':'IN2', 
                                    'dio-2':'IN3'}

        self.dict_names_out_coord = {'dio-3':'OUT1', 
                                    'dio-4':'OUT2', 
                                    'dio-5':'OUT3'}

        self.dict_status_in_coord = {True:'OFF', False:'ON'}

        self.dict_status_out_coord = {True:'ON', False:'OFF'}

        self.dict_names_in_slave = {'dio-0':'IN1', 
                                    'dio-1':'IN2', 
                                    'dio-2':'IN3', 
                                    'dio-3':'IN4', 
                                    'dio-4':'IN5', 
                                    'dio-5':'IN6'}

        self.dict_names_out_slave = {'dio-6':'OUT1', 'dio-7':'OUT2'}

        self.dict_names_analog_in_slave = {'adc-0':'ANALOG_IN1', 
                                            'adc-1':'ANALOG_IN2', 
                                            'adc-2':'ANALOG_IN3', 
                                            'adc-3':'ANALOG_IN4', 
                                            'adc-4':'ANALOG_IN5', 
                                            'adc-5':'ANALOG_IN6'}

        self.dict_status_in_slave = {True:'OFF', False:'ON'}

        self.dict_status_out_slave = {True:'ON', False:'OFF'}

        self.dictionary_json = {}

        try:
            self.ser = serial.Serial(self.PORT, self.BAUD_RATE)
            self.xbee = XBee(self.ser, callback=self.message_received)
        except:
            print 'Could not open port ' + self.PORT
        
        
    def message_received(self, data):
        try:
            #Преобразование полученного пакета от xCoordinator'ов в читаемый вид
            if data['id']=='rx_io_data' and data['source_addr'] in self.dict_src_addr_coord:
                self.name = self.dict_src_addr_coord[data['source_addr']]
                self.dictionary_json[self.name]={None : None}
                for i in data['samples'][0]:
                    if i in self.dict_names_in_coord:
                        self.port, self.status = self.dict_names_in_coord[i], self.dict_status_in_coord[data['samples'][0][i]]
                    elif i in self.dict_names_out_coord:
                        self.port, self.status = self.dict_names_out_coord[i], self.dict_status_out_coord[data['samples'][0][i]]
                    self.dictionary_json[self.name][self.port] = self.status
                    #print self.name, self.port, self.status
                del self.dictionary_json[self.name][None]
            
            #Преобразование полученного пакета от xSlave'ов в читаемый вид
            elif data['id']=='rx_io_data' and data['source_addr'] in self.dict_src_addr_slave:
                self.name = self.dict_src_addr_slave[data['source_addr']]
                self.dictionary_json[self.name]={None : None}
                for i in data['samples'][0]:
                    if i in self.dict_names_in_slave:
                        self.port, self.status =  self.dict_names_in_slave[i], self.dict_status_in_slave[data['samples'][0][i]]
                    elif i in self.dict_names_out_slave:
                        self.port, self.status =  self.dict_names_out_slave[i], self.dict_status_out_slave[data['samples'][0][i]]
                    elif i in self.dict_names_analog_in_slave:
                        self.port, self.status =  self.dict_names_analog_in_slave[i], data['samples'][0][i]
                    self.dictionary_json[self.name][self.port] = self.status
                    #print self.name, self.port, self.status
                del self.dictionary_json[self.name][None]
        except:
            print 'Error read packet'    
    

    def message_transmit(self):
        try:
            #Отправка запроса на состояние портов у локального xCoordinator'а
            self.xbee.send('at', frame_id='R', command='IS', parameter=None)
        except:
            print 'Error send message'

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
import serial
from xbee import XBee
import time

SERIALPORT = "/dev/tts/0"
BAUDRATE = 9600

serial_port = serial.Serial(SERIALPORT,BAUDRATE)
xbee = XBee(serial_port)

thisDest = '\x00\x0f'

xbee.send('remote_at', 
          frame_id='C',
          dest_addr=thisDest,
          options='\x02',
          command='IR',
          parameter='\x32')

print xbee.wait_read_frame()['status']

# Deactivate LED pin, D4
xbee.remote_at(dest_addr=thisDest,command='D4',parameter='\x04')
xbee.remote_at(dest_addr=thisDest,command='WR')


led=False
while 1:

        #set led status
        led=not led

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
"""
# Continuously read or print packets
while True:
	try:
		# Code for TX
		try:
			head = b'\x43' + order_move.to_bytes(1, "big") + b'\x01' # \x43 : adresse du destinataire, \x04 : id de l'ordre, \x01 : id unique du packet
			x = int(input("PWM: "))
			#y = int(input("new delay: "))

			# if y < 0:
			#	y += 4294967295
			
			order = head + x.to_bytes(1, "big")

			xbee.send('tx', dest_addr=b'\x00\x43', data=order)

			#print(order)
			#print("");
		except:
			break

		# Code for RX
		"""
		sleep(0.1)
		"""
	except KeyboardInterrupt:
		break

xbee.halt()
ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
class XbeeChat(threading.Thread):
    def __init__(self, port, panid, address, channel = 15, callback = None):
        super(XbeeChat, self).__init__()
        self.setDaemon(True)
        self.port = port
        self.name = "Xbee Chat Worker Thread on port {}".format(self.port)
        self.log = logging.getLogger("xbee[{}]".format(self.port))
        self.address = address
        self.panid = panid
        if channel < 11 or channel > 26:
            raise Exception("Invalid channel, must be 11-26 (XBee), other are not supported.")
        self.channel = channel

        self.seqno = 1
        self.inflight = {}

        self.callback = callback
        self.cmd_queue = Queue.Queue()

        self.startedEvt = threading.Event()

        self.ser = serial.Serial(self.port, 38400, rtscts = True)
        self.ser.flushInput()
        self.ser.flushOutput()
        self.xbee = XBee(self.ser, callback = self.on_packet, escaped = True)
        self.start()
        if not self.startedEvt.wait(5):
            raise Exception("XBee send thread failed to start") 
        
        try:
            self.configure([('AP', struct.pack(">H", 2)),  # API enabled with escaped chars = 2
                    ('MM', "\x02"),  # 802.15.4 with ACKS = 2
                    ('MY', struct.pack(">H", self.address)),
                    ("CH", struct.pack(">B", self.channel)),
                    ("ID", struct.pack(">H", self.panid)),
                    ("D7", "\x01"),  # CTS flow control = 1
                    ("D6", "\x01"),  # RTS flow control = 1
                    ("D5", "\x00"),  # DIO disabled = 0
                    ("D4", "\x00"),  # DIO disabled = 0
                    ("D3", "\x00"),  # DIO disabled = 0
                    ("D2", "\x00"),  # DIO disabled = 0
                    ("D1", "\x00"),  # DIO disabled = 0
                    ("D0", "\x00"),  # DIO disabled = 0
                    ("IU", "\x00"),  # I/O output disabled = 0
                    ("P0", "\x01"),  # PWM0 output RSSI = 1
                    ("P1", "\x00"),  # PWM1 output disabled = 0
                    ("RN", "\x01"),  # larger random delay slot backoff in CSMA-CA
                    ("AI", None)     # read association indication
                    ])       
        except Exception as x:
            # if we fail at this point, we have to shutdown, then raise the exception
            self.log.info("shutting down, init failed with: {}".format(x))
            self.xbee.halt()
            self.ser.close()
            raise x

    """
    The callback function which analysis incoming packet and display the result
    """
    def on_packet(self, pkt):
        tx_status_codes = {'\x00': 'Success', '\x01': 'No ACK', '\x02': 'CCA fail', '\x03': 'Purged'}

        if 'frame_id' in pkt:    
            frame_id = struct.unpack("B", pkt['frame_id'])[0]
        else:
            frame_id = None
            
        if pkt and 'id' in pkt and pkt['id'] == 'at_response':
            status = struct.unpack("B", pkt['status'])[0]
                        
            if status > 0:
                log = self.log.warn
            else:
                log = self.log.debug
                    
            if 'parameter' not in pkt:
                pkt['parameter'] = None
        
            log("AT response, frame_id: {}, command: {}, parameter: {}, status: {}".format(
                                                                                         hexdump(pkt['frame_id']),
                                                                                         pkt['command'],
                                                                                         hexdump(pkt['parameter']), 
                                                                                         status))                    
            if frame_id not in self.inflight:
                self.log.warn("No matching command packet to this frame_id!")
                
        elif pkt and 'id' in pkt and pkt['id'] == 'tx_status':

            self.log.info("TX status: frame_id: {}, status: {}".format(frame_id,
                                                                       tx_status_codes[pkt['status']]))

            if frame_id not in self.inflight:
                self.log.warn("No matching TX packet to this frame_id!")

        elif pkt and 'id' in pkt and pkt['id'] == 'rx':
            self.log.debug("RX: src: {}, rssi: -{} dbm, data: {}".format(struct.unpack(">H", pkt['source_addr'])[0],
                                                                   struct.unpack("B", pkt['rssi'])[0],
                                                                   hexdump(pkt['rf_data'])))
        else:
            self.log.info("RX: {}".format(pkt))
#.........这里部分代码省略.........

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
import numpy as np

print 'Time Delay Switch to XBee'
time.sleep(10)
print 'Delay Over'

SERIALPORT = "/dev/ttyUSB0"    # the com/serial port the XBee is connected to
BAUDRATE = 9600      # the baud rate we talk to the xbee

ser = serial.Serial(SERIALPORT, BAUDRATE)

xbee = XBee(ser)

while True:
        try:
                command = xbee.wait_read_frame()
                total = np.array([],int)
                if command['rf_data'] == 'GETRSSI':
                        for x in range(0,50):
                                xbee.send("tx_long_addr", frame_id='\x00', dest_addr='\x00\x13\xA2\x00\x40\xDC\x0D\x78', data='\x50\x49\x4E\x47\x41')
                                frame = xbee.wait_read_frame()
                                rssi_ASCII = frame['rssi']
                                rssi_int = ord(rssi_ASCII)
                                total = np.append(total,rssi_int)
                                avg_rssi = str(int(np.mean(total)))
				time.sleep(0.2)
                        xbee.send("tx_long_addr", frame_id='\x00', dest_addr='\x00\x13\xA2\x00\x40\xE2\xD0\xAA', data=avg_rssi)
        except KeyboardInterrupt:
                break

ser.close()

# 需要导入模块: from xbee import XBee [as 别名]
# 或者: from xbee.XBee import send [as 别名]
from xbee import XBee

# Open serial port
# ser = serial.Serial(PORT,BAUD_RATE)
serial_port = serial.Serial('COM4', 9600)

# Continuously read and print packets
zb = XBee(serial_port)

for i in range(100):
    try:
        time.sleep(5)
        print("Sending : ")
        if i % 2 == 1:
            print("1")
            payload = str(1).encode()
            zb.send("tx", dest_addr=b"\x00\x00", data=payload)
            data = zb.wait_read_frame().get('rf_data')
            print(data.decode())
        if i % 2 == 0:
            print("2")
            payload = str(2).encode()
            zb.send("tx", dest_addr=b"\x00\x00", data=payload)
            data = zb.wait_read_frame().get('rf_data')
            print(data.decode())
    except KeyboardInterrupt:
        break


serial_port.close()